Closes#1300
Changes to support the first example below (partial specialization of
template parameter types like Vect<int>). Previous implementation and
design could only handle one template parameter name per template
specialization argument, such as Vect<TS> for the first template
specialization argument (for first example below)
template<class TS, typename TTS> class Foo<Vect<TS>, int> { ... };
and not
template<class TS, typename TTS> class Foo<Vect<TS, TTS>, int> { ... };
New approach is to not modify 'templateparms' in the template node,
(except to fill in default args from primary template)
Previous implementation also assumed a template parameter could not be
used more than once in the specialized arguments, such as
template<typename T> struct Hey<T, T> { void specialA() {} };
Examples
========
1) For primary:
template<class T, typename TT> class Foo { ... };
and specialization:
template<class TS, typename TTS> class Foo<Vect<TS>, TTS> { ... };
Fix specialization template from (wrong)
| templateparms - 'Vect< TS >,typename TTS'
to (correct/new way)
| templateparms - 'class TS,typename TTS'
2) For primary:
template<typename P1 = int, typename P2 = double> struct Partialler { void primary(P1, P2) {}; };
and specialization:
template<typename S1, typename S2> struct Partialler<S2, S1*> { void special(S1*, S2, bool) {}; };
Specialized template changes from (wrong)
| templateparms - 'typename S2=int,typename S1=double'
to (correct/new way, default args are removed)
| templateparms - 'typename S1,typename S2'
and subsequent change to partialargs from
| partialargs - "Partialler<($1,p.$2)>"
to
| partialargs - "Partialler<($2,p.$1)>"
so that the $n number is now more logically the nth template parameter in templateparms
3) For primary:
template<typename X, typename Y> struct Hey { void primary() {} };
and specialization:
template<typename T> struct Hey<T, T> { void specialA() {} };
old (wrong/old way)
| templateparms - 'typename T,typename T'
new (correct/new way)
| templateparms - 'typename T'
These are unchanged and are okay:
| partialargs - "Hey<($1,$1)>"
4) For primary:
enum Hello { hi, hello };
template <Hello, class A> struct C {};
and specialization:
template <class A> struct C<hello,A> { ... };
old (wrong/old way)
| templateparms - 'hello,class A'
new (correct/new way)
| templateparms - 'class A'
and subsequent changes to partialargs from
| partialargs - "C<(hi,$2)>"
to
| partialargs - "C<(hi,$1)>"
Test-suite
==========
Identical output as before in Python but in Java, an unimportant change
in cpp11_variadic_function_templates.i results in one variadic parameter
name being different.
New testcase template_partial_specialization_more.i with more testcases
added including above examples that are not already in the test-suite.
SWIG Examples
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.
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 concerning C++ ***
The configure script is currently unable to handle all of the possible
options for producing dynamically loadable C++ extensions. Here are
the rules of thumb for making C++ work:
- Try using the C++ as the linker for the shared library. For example:
g++ -shared $(OBJS) -o module.so
- If that doesn't work, you may need to explicitly link against some
kind of C++ runtime library. For example:
ld -G $(OBJS) -L/opt/SUNWspro/lib -lCrun -o module.so
This can be set by modifying the setting of CPP_DLLIBS in the
Makefile.
*** Special note for SWIG Maintainers ***
When you add an example, consider arranging for the example to be also
useful as part of the SWIG testing framework. To do this, include in
the example makefile a target "check" ("check: all" is sufficient for a
first pass), and add an invocation to ../Makefile.in under target
"check-examples" (or whatever is appropriate). Later, we can add or
expand the actions under target "check" to do more in-depth testing.
817c700ced