Compatibility note: The default typemap matching rules were modified in SWIG-2.0.0 from a slightly
-simpler scheme to match the current C++ template partial specialization matching rules.
+simpler scheme to match the current C++ class template partial specialization matching rules.
-
-10.3.4 Multi-arguments typemaps
+10.3.5 Multi-arguments typemaps
@@ -1441,7 +1448,165 @@ but all subsequent arguments must match exactly.
-10.3.5 Debugging typemap pattern matching
+10.3.4 Matching rules compared to C++ templates
+
+
+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.
+
+
+
+For default (SWIGTYPE) typemaps the rules are inspired by C++ class template
+partial specialization. For example, given partial specialization for T const& :
+
+
+
+
+template <typename T> struct X { void a(); };
+template <typename T> struct X< T const& > { void b(); };
+
+
+The full (unspecialized) template is matched with most types, such as:
+
+
+
+
+X< int & > x1; x1.a();
+
+
+and the following all match the T const& partial specialization:
+
+
+
+
+X< int *const& > x2; x2.b();
+X< int const*const& > x3; x3.b();
+X< int const& > x4; x4.b();
+
+
+Now, given just these two default typemaps, where T is analogous to SWIGTYPE:
+
+
+
+
+%typemap(...) SWIGTYPE { ... }
+%typemap(...) SWIGTYPE const& { ... }
+
+
+The generic default typemap SWIGTYPE is used with most types, such as
+
+
+
+
+
+and the following all match the SWIGTYPE const& typemap, just like the partial template matching:
+
+
+
+
+int *const&
+int const*const&
+int const&
+
+
+Note that the template and typemap matching rules are not identical for all default typemaps though, for example, with arrays.
+
+
+
+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:
+
+
+
+
+template <typename T> struct Y { void a(); };
+template <> struct Y< int const & > { void b(); };
+
+
+Only the one type matches the specialized template exactly:
+
+
+
+
+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
+
+
+Given typemaps with the same types used for the template declared above, where T is again analogous to SWIGTYPE:
+
+
+
+
+%typemap(...) SWIGTYPE { ... }
+%typemap(...) int const& { ... }
+
+
+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:
+
+
+
+
+int &
+int *const&
+int const*const&
+int const& // matches non-default typemap int const&
+
+
+However, if a non-const type is used instead:
+
+
+
+
+%typemap(...) SWIGTYPE { ... }
+%typemap(...) int & { ... }
+
+
+then there is a clear difference to template matching as both the const and non-const types match the typemap:
+
+
+
+
+int & // matches non-default typemap int &
+int *const&
+int const*const&
+int const& // matches non-default typemap int &
+
+
+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.
+
+
+
+10.3.6 Debugging typemap pattern matching
diff --git a/Examples/test-suite/char_strings.i b/Examples/test-suite/char_strings.i
index 26f3f22a5..cc59815b2 100644
--- a/Examples/test-suite/char_strings.i
+++ b/Examples/test-suite/char_strings.i
@@ -21,7 +21,7 @@ below.
static char *global_str = NULL;
const int UINT_DIGITS = 10; // max unsigned int is 4294967295
-bool check(const char *str, unsigned int number) {
+bool check(const char *const str, unsigned int number) {
static char expected[256];
sprintf(expected, "%s%d", OTHERLAND_MSG, number);
bool matches = (strcmp(str, expected) == 0);
@@ -105,6 +105,18 @@ bool SetConstCharArrayStaticString(const char str[], unsigned int number) {
return check(static_str, number);
}
+bool SetCharConstStaticString(char *const str, unsigned int number) {
+ static char static_str[] = CPLUSPLUS_MSG;
+ strcpy(static_str, str);
+ return check(static_str, number);
+}
+
+bool SetConstCharConstStaticString(const char *const str, unsigned int number) {
+ static char static_str[] = CPLUSPLUS_MSG;
+ strcpy(static_str, str);
+ return check(static_str, number);
+}
+
// get set function
char *CharPingPong(char *str) {
return str;
diff --git a/Examples/test-suite/common.mk b/Examples/test-suite/common.mk
index 308ff9f1e..831b1b78f 100644
--- a/Examples/test-suite/common.mk
+++ b/Examples/test-suite/common.mk
@@ -387,12 +387,14 @@ CPP_TEST_CASES += \
typedef_scope \
typedef_sizet \
typedef_struct \
+ typemap_delete \
typemap_global_scope \
typemap_namespace \
typemap_ns_using \
typemap_numinputs \
typemap_template \
typemap_out_optimal \
+ typemap_qualifier_strip \
typemap_variables \
typemap_various \
typename \
diff --git a/Examples/test-suite/csharp/char_strings_runme.cs b/Examples/test-suite/csharp/char_strings_runme.cs
index 59bcc64df..414d32b7a 100644
--- a/Examples/test-suite/csharp/char_strings_runme.cs
+++ b/Examples/test-suite/csharp/char_strings_runme.cs
@@ -76,6 +76,16 @@ public class char_strings_runme {
throw new Exception("Test char set 6 failed, iteration " + i);
}
+ for (i=0; igetName());
+ temp_count = strlen(temp_name.getNamePtr()->getName());
(void)$input;
$1 = temp_name.getNamePtr();
$2 = temp_count + 100;
@@ -103,7 +103,7 @@ $typemap(in, (Name *multiname, int num))
%inline %{
const char * testJim(Name *jim, int count) {
- if (count != (int)strlen(jim->getNamePtr()->getName()) + 100)
+ if (count != strlen(jim->getNamePtr()->getName()) + 100)
return "size check failed";
else
return jim->getName();
diff --git a/Examples/test-suite/typemap_delete.i b/Examples/test-suite/typemap_delete.i
new file mode 100644
index 000000000..eb6abe73c
--- /dev/null
+++ b/Examples/test-suite/typemap_delete.i
@@ -0,0 +1,16 @@
+%module typemap_delete
+
+%typemap(in) Rect* (Rect temp) {
+ $1 = 0;
+ will_not_compile
+}
+
+%typemap(in) Rect*;
+
+%inline %{
+struct Rect
+{
+ int val;
+ Rect(int v) : val(v) {}
+};
+%}
diff --git a/Examples/test-suite/typemap_qualifier_strip.i b/Examples/test-suite/typemap_qualifier_strip.i
new file mode 100644
index 000000000..d91a7b109
--- /dev/null
+++ b/Examples/test-suite/typemap_qualifier_strip.i
@@ -0,0 +1,76 @@
+%module typemap_qualifier_strip
+
+%typemap(in) int *ptr {
+ int temp = 1234;
+ $1 = &temp;
+}
+
+%typemap(in) int *const ptrConst {
+ int temp = 5678;
+ $1 = &temp;
+}
+
+%typemap(in) int const* constPtr {
+ int temp = 3456;
+ $1 = &temp;
+}
+
+%inline %{
+int *create_int(int newval) {
+ static int val = 0;
+ val = newval;
+ return &val;
+}
+int testA1(int const*const ptr) {
+ return *ptr;
+}
+int testA2(int const* ptr) {
+ return *ptr;
+}
+int testA3(int *const ptr) {
+ return *ptr;
+}
+int testA4(int * ptr) {
+ return *ptr;
+}
+
+int testB1(int const*const p) {
+ return *p;
+}
+int testB2(int const* p) {
+ return *p;
+}
+int testB3(int *const p) {
+ return *p;
+}
+int testB4(int * p) {
+ return *p;
+}
+
+int testC1(int const*const ptrConst) {
+ return *ptrConst;
+}
+int testC2(int const* ptrConst) {
+ return *ptrConst;
+}
+int testC3(int *const ptrConst) {
+ return *ptrConst;
+}
+int testC4(int * ptrConst) {
+ return *ptrConst;
+}
+
+int testD1(int const*const constPtr) {
+ return *constPtr;
+}
+int testD2(int const* constPtr) {
+ return *constPtr;
+}
+int testD3(int *const constPtr) {
+ return *constPtr;
+}
+int testD4(int * constPtr) {
+ return *constPtr;
+}
+%}
+
diff --git a/Lib/r/rfragments.swg b/Lib/r/rfragments.swg
index f6191dfeb..7c8da2a5f 100644
--- a/Lib/r/rfragments.swg
+++ b/Lib/r/rfragments.swg
@@ -122,7 +122,7 @@ SWIGINTERN int
SWIG_AsCharPtrAndSize(SEXP obj, char** cptr, size_t* psize, int *alloc)
{
if (cptr && Rf_isString(obj)) {
- const char *cstr = CHAR(STRING_ELT(obj, 0));
+ char *cstr = %const_cast(CHAR(STRING_ELT(obj, 0)), char *);
int len = strlen(cstr);
if (alloc) {
@@ -130,9 +130,7 @@ SWIG_AsCharPtrAndSize(SEXP obj, char** cptr, size_t* psize, int *alloc)
*cptr = %new_copy_array(cstr, len + 1, char);
*alloc = SWIG_NEWOBJ;
} else {
- *cptr = %reinterpret_cast(malloc(len + 1), char *);
- *cptr = strcpy(*cptr, cstr);
- *alloc = SWIG_OLDOBJ;
+ *cptr = cstr;
}
} else {
*cptr = %reinterpret_cast(malloc(len + 1), char *);
diff --git a/Source/Swig/stype.c b/Source/Swig/stype.c
index 533b8195f..c984d639b 100644
--- a/Source/Swig/stype.c
+++ b/Source/Swig/stype.c
@@ -357,8 +357,8 @@ SwigType *SwigType_default_create(SwigType *ty) {
* SwigType_default_deduce()
*
* This function implements type deduction used in the typemap matching rules
- * and is very close to the type deduction used in partial template specialization
- * matching in that the most specialized type is always chosen.
+ * and is very close to the type deduction used in partial template class
+ * specialization matching in that the most specialized type is always chosen.
* SWIGTYPE is used as the generic type. The basic idea is to repeatedly call
* this function to find a deduced type unless until nothing matches.
*
diff --git a/Source/Swig/swig.h b/Source/Swig/swig.h
index 2b2c7f4cf..f90a5ffb1 100644
--- a/Source/Swig/swig.h
+++ b/Source/Swig/swig.h
@@ -159,6 +159,7 @@ extern "C" {
extern int SwigType_isenum(SwigType *t);
extern int SwigType_check_decl(SwigType *t, const_String_or_char_ptr decl);
extern SwigType *SwigType_strip_qualifiers(SwigType *t);
+ extern SwigType *SwigType_strip_single_qualifier(SwigType *t);
extern SwigType *SwigType_functionpointer_decompose(SwigType *t);
extern String *SwigType_base(const SwigType *t);
extern String *SwigType_namestr(const SwigType *t);
diff --git a/Source/Swig/typemap.c b/Source/Swig/typemap.c
index 37f8c3d82..2bf806e66 100644
--- a/Source/Swig/typemap.c
+++ b/Source/Swig/typemap.c
@@ -698,11 +698,11 @@ static Hash *typemap_search(const_String_or_char_ptr tmap_method, SwigType *type
Hash *backup = 0;
SwigType *primitive = 0;
SwigType *ctype = 0;
+ SwigType *ctype_unstripped = 0;
int ts;
int isarray;
const String *cname = 0;
const String *cqualifiedname = 0;
- SwigType *unstripped = 0;
String *tm_method = typemap_method_name(tmap_method);
int debug_display = (in_typemap_search_multi == 0) && typemap_search_debug;
@@ -718,12 +718,13 @@ static Hash *typemap_search(const_String_or_char_ptr tmap_method, SwigType *type
Delete(typestr);
}
while (ts >= 0) {
- ctype = type;
+ 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)
+ if (result && Getattr(result, "code"))
goto ret_result;
{
@@ -733,7 +734,7 @@ static Hash *typemap_search(const_String_or_char_ptr tmap_method, SwigType *type
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)
+ if (result && Getattr(result, "code"))
goto ret_result;
}
}
@@ -747,33 +748,29 @@ static Hash *typemap_search(const_String_or_char_ptr tmap_method, SwigType *type
tm = get_typemap(ts, noarrays);
result = typemap_search_helper(debug_display, tm, tm_method, noarrays, cqualifiedname, cname, &backup);
Delete(noarrays);
- if (result)
+ if (result && Getattr(result, "code"))
goto ret_result;
}
- /* No match so far. If the type is unstripped, we'll strip its
- qualifiers and check. Otherwise, we'll try to resolve a typedef */
-
- if (!unstripped) {
- unstripped = ctype;
- ctype = SwigType_strip_qualifiers(ctype);
- if (!Equal(ctype, unstripped))
- continue; /* Types are different */
- Delete(ctype);
- ctype = unstripped;
- unstripped = 0;
- }
+ /* 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. */
{
- String *octype;
- if (unstripped) {
- Delete(ctype);
- ctype = unstripped;
- unstripped = 0;
+ SwigType *oldctype = ctype;
+ ctype = SwigType_strip_single_qualifier(oldctype);
+ if (!Equal(ctype, oldctype)) {
+ Delete(oldctype);
+ continue;
}
- octype = ctype;
- ctype = SwigType_typedef_resolve(ctype);
- if (octype != type)
- Delete(octype);
+ Delete(oldctype);
+ }
+
+ /* Once all qualifiers are stripped try resolve a typedef */
+ {
+ SwigType *oldctype = ctype;
+ ctype = SwigType_typedef_resolve(ctype_unstripped);
+ Delete(oldctype);
+ ctype_unstripped = Copy(ctype);
}
}
@@ -783,7 +780,7 @@ static Hash *typemap_search(const_String_or_char_ptr tmap_method, SwigType *type
while (primitive) {
tm = get_typemap(ts, primitive);
result = typemap_search_helper(debug_display, tm, tm_method, primitive, cqualifiedname, cname, &backup);
- if (result)
+ if (result && Getattr(result, "code"))
goto ret_result;
{
@@ -802,12 +799,10 @@ static Hash *typemap_search(const_String_or_char_ptr tmap_method, SwigType *type
ret_result:
Delete(primitive);
- if ((unstripped) && (unstripped != type))
- Delete(unstripped);
if (matchtype)
*matchtype = Copy(ctype);
- if (type != ctype)
- Delete(ctype);
+ Delete(ctype);
+ Delete(ctype_unstripped);
return result;
}
diff --git a/Source/Swig/typeobj.c b/Source/Swig/typeobj.c
index a2e23e52d..074bbf904 100644
--- a/Source/Swig/typeobj.c
+++ b/Source/Swig/typeobj.c
@@ -1125,3 +1125,62 @@ SwigType *SwigType_strip_qualifiers(SwigType *t) {
}
return r;
}
+
+/* -----------------------------------------------------------------------------
+ * SwigType_strip_single_qualifier()
+ *
+ * If the type contains a qualifier, strip one qualifier and return a new type.
+ * The left most qualifier is stripped first (when viewed as C source code) but
+ * this is the equivalent to the right most qualifier using SwigType notation.
+ * Example:
+ * r.q(const).p.q(const).int => r.q(const).p.int
+ * r.q(const).p.int => r.p.int
+ * r.p.int => r.p.int
+ * ----------------------------------------------------------------------------- */
+
+SwigType *SwigType_strip_single_qualifier(SwigType *t) {
+ static Hash *memoize_stripped = 0;
+ SwigType *r = 0;
+ List *l;
+ int numitems;
+
+ if (!memoize_stripped)
+ memoize_stripped = NewHash();
+ r = Getattr(memoize_stripped, t);
+ if (r)
+ return Copy(r);
+
+ l = SwigType_split(t);
+
+ numitems = Len(l);
+ if (numitems >= 2) {
+ int item;
+ /* iterate backwards from last but one item */
+ for (item = numitems - 2; item >= 0; --item) {
+ String *subtype = Getitem(l, item);
+ if (SwigType_isqualifier(subtype)) {
+ Iterator it;
+ Delitem(l, item);
+ r = NewStringEmpty();
+ for (it = First(l); it.item; it = Next(it)) {
+ Append(r, it.item);
+ }
+ break;
+ }
+ }
+ }
+ if (!r)
+ r = Copy(t);
+
+ Delete(l);
+ {
+ String *key, *value;
+ key = Copy(t);
+ value = Copy(r);
+ Setattr(memoize_stripped, key, value);
+ Delete(key);
+ Delete(value);
+ }
+ return r;
+}
+