Support multiple arguments in variadic templates.

Remove warning SWIGWARN_CPP11_VARIADIC_TEMPLATE which was issued if more
than one argument was used for a variadic template.

SwigType enhancement: 'v.' now represents a variadic argument.

Source/Swig/parms.c

@@ -122,11 +122,10 @@ ParmList *CopyParmList(ParmList *p) {
 
 ParmList *ParmList_join(ParmList *p, ParmList *p2) {
   Parm *firstparm = p ? p : p2;
-  Parm *lastparm = p;
+  Parm *lastparm = 0;
   while (p) {
+    lastparm = p;
     p = nextSibling(p);
-    if (p)
-      lastparm = p;
   }
   if (lastparm)
     set_nextSibling(lastparm, p2);
@@ -134,22 +133,60 @@ ParmList *ParmList_join(ParmList *p, ParmList *p2) {
   return firstparm;
 }
 
+/* -----------------------------------------------------------------------------
+ * ParmList_replace_last()
+ *
+ * Delete last parameter in p and replace it with parameter list p2.
+ * p must have at least one element, that is, must not be NULL.
+ * Return beginning of modified parameter list.
+ * ----------------------------------------------------------------------------- */
+
+ParmList *ParmList_replace_last(ParmList *p, ParmList *p2) {
+  ParmList *start = p;
+  int len = ParmList_len(p);
+  assert(p);
+  if (len == 1) {
+    start = p2;
+  } else if (len > 1) {
+    Parm *secondlastparm = ParmList_nth_parm(p, len - 2);
+    set_nextSibling(secondlastparm, p2);
+  }
+  return start;
+}
+
 /* -----------------------------------------------------------------------------
  * ParmList_nth_parm()
  *
  * return the nth parameter (0 based) in the parameter list
+ * return NULL if there are not enough parameters in the list
  * ----------------------------------------------------------------------------- */
 
 Parm *ParmList_nth_parm(ParmList *p, unsigned int n) {
   while (p) {
-    if (n == 0)
+    if (n == 0) {
       break;
+    }
     n--;
     p = nextSibling(p);
   }
   return p;
 }
 
+/* -----------------------------------------------------------------------------
+ * ParmList_variadic_parm()
+ *
+ * Return the variadic parm (last in list if it is variadic), NULL otherwise
+ * ----------------------------------------------------------------------------- */
+
+Parm *ParmList_variadic_parm(ParmList *p) {
+  Parm *lastparm = 0;
+  while (p) {
+    lastparm = p;
+    p = nextSibling(p);
+  }
+  return lastparm && SwigType_isvariadic(Getattr(lastparm, "type")) ? lastparm : 0;
+}
+
 /* -----------------------------------------------------------------------------
  * ParmList_numrequired()
  *
@@ -303,10 +340,10 @@ int ParmList_has_defaultargs(ParmList *p) {
  * ---------------------------------------------------------------------- */
 
 int ParmList_has_varargs(ParmList *p) {
-  Parm *lp = 0;
+  Parm *lastparm = 0;
   while (p) {
-    lp = p;
+    lastparm = p;
     p = nextSibling(p);
   }
-  return lp ? SwigType_isvarargs(Getattr(lp, "type")) : 0;
+  return lastparm ? SwigType_isvarargs(Getattr(lastparm, "type")) : 0;
 }

Source/Swig/stype.c

@@ -42,6 +42,7 @@
  *  'p.'                = Pointer (*)
  *  'r.'                = Reference (&)
  *  'z.'                = Rvalue reference (&&)
+ *  'v.'                = Variadic (...)
  *  'a(n).'             = Array of size n  [n]
  *  'f(..,..).'         = Function with arguments  (args)
  *  'q(str).'           = Qualifier, such as const or volatile (cv-qualifier)
@@ -624,6 +625,12 @@ String *SwigType_str(const SwigType *s, const_String_or_char_ptr id) {
 	Insert(result, 0, "(");
 	Append(result, ")");
       }
+    } else if (SwigType_isvariadic(element)) {
+      Insert(result, 0, "...");
+      if ((forwardelement) && ((SwigType_isfunction(forwardelement) || (SwigType_isarray(forwardelement))))) {
+	Insert(result, 0, "(");
+	Append(result, ")");
+      }
     } else if (SwigType_isarray(element)) {
       DOH *size;
       Append(result, "[");

Source/Swig/swig.h

@@ -129,6 +129,8 @@ extern "C" {
   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_variadic(SwigType *t);
+  extern SwigType *SwigType_del_variadic(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);
@@ -155,6 +157,7 @@ extern "C" {
   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_isvariadic(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);

Source/Swig/swigparm.h

@@ -22,7 +22,10 @@ extern Parm      *CopyParm(Parm *p);
 extern ParmList  *CopyParmList(ParmList *p);
 extern ParmList  *CopyParmListMax(ParmList *p, int count);
 extern ParmList  *ParmList_join(ParmList *p, ParmList *p2);
-extern Parm	 *ParmList_nth_parm(ParmList *p, unsigned int n);
+extern ParmList  *ParmList_replace_last(ParmList *p, ParmList *p2);
+extern Parm      *ParmList_nth_parm(ParmList *p, unsigned int n);
+extern Parm      *ParmList_variadic_parm(ParmList *p);
+extern Parm      *ParmList_add_parm(ParmList *p, Parm *newparm);
 extern int        ParmList_numrequired(ParmList *);
 extern int        ParmList_len(ParmList *);
 extern int        ParmList_has_defaultargs(ParmList *p);

Source/Swig/tree.c

@@ -114,6 +114,10 @@ void Swig_print_node(Node *obj) {
 	}
 	Printf(stdout, "%-12s - \"%(escape)-0.80s%s\"\n", k, o, trunc);
 	Delete(o);
+/*
+      } else if (DohIsSequence(value)) {
+	Printf(stdout, "%-12s - %s\n", k, value);
+*/
       } else {
 	Printf(stdout, "%-12s - %p\n", k, value);
       }

Source/Swig/typeobj.c

@@ -45,6 +45,7 @@
  *  'p.'                = Pointer (*)
  *  'r.'                = Reference or ref-qualifier (&)
  *  'z.'                = Rvalue reference or ref-qualifier (&&)
+ *  'v.'                = Variadic (...)
  *  'a(n).'             = Array of size n  [n]
  *  'f(..,..).'         = Function with arguments  (args)
  *  'q(str).'           = Qualifier, such as const or volatile (cv-qualifier)
@@ -79,6 +80,7 @@
  *       SwigType_add_pointer()
  *       SwigType_add_reference()
  *       SwigType_add_rvalue_reference()
+ *       SwigType_add_variadic()
  *       SwigType_add_array()
  *
  * These are used to build new types.  There are also functions to undo these
@@ -87,6 +89,7 @@
  *       SwigType_del_pointer()
  *       SwigType_del_reference()
  *       SwigType_del_rvalue_reference()
+ *       SwigType_del_variadic()
  *       SwigType_del_array()
  *
  * In addition, there are query functions
@@ -94,6 +97,7 @@
  *       SwigType_ispointer()
  *       SwigType_isreference()
  *       SwigType_isrvalue_reference()
+ *       SwigType_isvariadic()
  *       SwigType_isarray()
  *
  * Finally, there are some data extraction functions that can be used to
@@ -499,6 +503,43 @@ int SwigType_isrvalue_reference(const SwigType *t) {
   return 0;
 }
 
+/* -----------------------------------------------------------------------------
+ *                                 Variadic
+ *
+ * SwigType_add_variadic()
+ * SwigType_del_variadic()
+ * SwigType_isvariadic()
+ *
+ * Add, remove, and test if a type is a variadic.  The deletion and query
+ * functions take into account qualifiers (if any).
+ * ----------------------------------------------------------------------------- */
+
+SwigType *SwigType_add_variadic(SwigType *t) {
+  Insert(t, 0, "v.");
+  return t;
+}
+
+SwigType *SwigType_del_variadic(SwigType *t) {
+  char *c = Char(t);
+  if (strncmp(c, "v.", 2)) {
+    printf("Fatal error: SwigType_del_variadic applied to non-variadic.\n");
+    Exit(EXIT_FAILURE);
+  }
+  Delslice(t, 0, 2);
+  return t;
+}
+
+int SwigType_isvariadic(const SwigType *t) {
+  char *c;
+  if (!t)
+    return 0;
+  c = Char(t);
+  if (strncmp(c, "v.", 2) == 0) {
+    return 1;
+  }
+  return 0;
+}
+
 /* -----------------------------------------------------------------------------
  *                                  Qualifiers
  *