Points&Forces (survey)
Software tools facilitating the task of surveying architecture
a_mechanicsTCL8_wrap.cxx
Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 4.0.2
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10 
11 
12 #ifndef SWIGTCL
13 #define SWIGTCL
14 #endif
15 
16 
17 #ifdef __cplusplus
18 /* SwigValueWrapper is described in swig.swg */
19 template<typename T> class SwigValueWrapper {
20  struct SwigMovePointer {
21  T *ptr;
22  SwigMovePointer(T *p) : ptr(p) { }
23  ~SwigMovePointer() { delete ptr; }
24  SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
25  } pointer;
26  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
28 public:
29  SwigValueWrapper() : pointer(0) { }
30  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
31  operator T&() const { return *pointer.ptr; }
32  T *operator&() { return pointer.ptr; }
33 };
34 
35 template <typename T> T SwigValueInit() {
36  return T();
37 }
38 #endif
39 
40 /* -----------------------------------------------------------------------------
41  * This section contains generic SWIG labels for method/variable
42  * declarations/attributes, and other compiler dependent labels.
43  * ----------------------------------------------------------------------------- */
44 
45 /* template workaround for compilers that cannot correctly implement the C++ standard */
46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
48 # define SWIGTEMPLATEDISAMBIGUATOR template
49 # elif defined(__HP_aCC)
50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
52 # define SWIGTEMPLATEDISAMBIGUATOR template
53 # else
54 # define SWIGTEMPLATEDISAMBIGUATOR
55 # endif
56 #endif
57 
58 /* inline attribute */
59 #ifndef SWIGINLINE
60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
61 # define SWIGINLINE inline
62 # else
63 # define SWIGINLINE
64 # endif
65 #endif
66 
67 /* attribute recognised by some compilers to avoid 'unused' warnings */
68 #ifndef SWIGUNUSED
69 # if defined(__GNUC__)
70 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
71 # define SWIGUNUSED __attribute__ ((__unused__))
72 # else
73 # define SWIGUNUSED
74 # endif
75 # elif defined(__ICC)
76 # define SWIGUNUSED __attribute__ ((__unused__))
77 # else
78 # define SWIGUNUSED
79 # endif
80 #endif
81 
82 #ifndef SWIG_MSC_UNSUPPRESS_4505
83 # if defined(_MSC_VER)
84 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
85 # endif
86 #endif
87 
88 #ifndef SWIGUNUSEDPARM
89 # ifdef __cplusplus
90 # define SWIGUNUSEDPARM(p)
91 # else
92 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
93 # endif
94 #endif
95 
96 /* internal SWIG method */
97 #ifndef SWIGINTERN
98 # define SWIGINTERN static SWIGUNUSED
99 #endif
100 
101 /* internal inline SWIG method */
102 #ifndef SWIGINTERNINLINE
103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
104 #endif
105 
106 /* exporting methods */
107 #if defined(__GNUC__)
108 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
109 # ifndef GCC_HASCLASSVISIBILITY
110 # define GCC_HASCLASSVISIBILITY
111 # endif
112 # endif
113 #endif
114 
115 #ifndef SWIGEXPORT
116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
117 # if defined(STATIC_LINKED)
118 # define SWIGEXPORT
119 # else
120 # define SWIGEXPORT __declspec(dllexport)
121 # endif
122 # else
123 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
124 # define SWIGEXPORT __attribute__ ((visibility("default")))
125 # else
126 # define SWIGEXPORT
127 # endif
128 # endif
129 #endif
130 
131 /* calling conventions for Windows */
132 #ifndef SWIGSTDCALL
133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
134 # define SWIGSTDCALL __stdcall
135 # else
136 # define SWIGSTDCALL
137 # endif
138 #endif
139 
140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
142 # define _CRT_SECURE_NO_DEPRECATE
143 #endif
144 
145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
147 # define _SCL_SECURE_NO_DEPRECATE
148 #endif
149 
150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
153 #endif
154 
155 /* Intel's compiler complains if a variable which was never initialised is
156  * cast to void, which is a common idiom which we use to indicate that we
157  * are aware a variable isn't used. So we just silence that warning.
158  * See: https://github.com/swig/swig/issues/192 for more discussion.
159  */
160 #ifdef __INTEL_COMPILER
161 # pragma warning disable 592
162 #endif
163 
164 
165 #include <stdio.h>
166 #include <tcl.h>
167 #include <errno.h>
168 #include <stdlib.h>
169 #include <stdarg.h>
170 #include <ctype.h>
171 
172 /* -----------------------------------------------------------------------------
173  * swigrun.swg
174  *
175  * This file contains generic C API SWIG runtime support for pointer
176  * type checking.
177  * ----------------------------------------------------------------------------- */
178 
179 /* This should only be incremented when either the layout of swig_type_info changes,
180  or for whatever reason, the runtime changes incompatibly */
181 #define SWIG_RUNTIME_VERSION "4"
182 
183 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
184 #ifdef SWIG_TYPE_TABLE
185 # define SWIG_QUOTE_STRING(x) #x
186 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
187 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
188 #else
189 # define SWIG_TYPE_TABLE_NAME
190 #endif
191 
192 /*
193  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
194  creating a static or dynamic library from the SWIG runtime code.
195  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
196 
197  But only do this if strictly necessary, ie, if you have problems
198  with your compiler or suchlike.
199 */
200 
201 #ifndef SWIGRUNTIME
202 # define SWIGRUNTIME SWIGINTERN
203 #endif
204 
205 #ifndef SWIGRUNTIMEINLINE
206 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
207 #endif
208 
209 /* Generic buffer size */
210 #ifndef SWIG_BUFFER_SIZE
211 # define SWIG_BUFFER_SIZE 1024
212 #endif
213 
214 /* Flags for pointer conversions */
215 #define SWIG_POINTER_DISOWN 0x1
216 #define SWIG_CAST_NEW_MEMORY 0x2
217 #define SWIG_POINTER_NO_NULL 0x4
218 
219 /* Flags for new pointer objects */
220 #define SWIG_POINTER_OWN 0x1
221 
222 
223 /*
224  Flags/methods for returning states.
225 
226  The SWIG conversion methods, as ConvertPtr, return an integer
227  that tells if the conversion was successful or not. And if not,
228  an error code can be returned (see swigerrors.swg for the codes).
229 
230  Use the following macros/flags to set or process the returning
231  states.
232 
233  In old versions of SWIG, code such as the following was usually written:
234 
235  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
236  // success code
237  } else {
238  //fail code
239  }
240 
241  Now you can be more explicit:
242 
243  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
244  if (SWIG_IsOK(res)) {
245  // success code
246  } else {
247  // fail code
248  }
249 
250  which is the same really, but now you can also do
251 
252  Type *ptr;
253  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
254  if (SWIG_IsOK(res)) {
255  // success code
256  if (SWIG_IsNewObj(res) {
257  ...
258  delete *ptr;
259  } else {
260  ...
261  }
262  } else {
263  // fail code
264  }
265 
266  I.e., now SWIG_ConvertPtr can return new objects and you can
267  identify the case and take care of the deallocation. Of course that
268  also requires SWIG_ConvertPtr to return new result values, such as
269 
270  int SWIG_ConvertPtr(obj, ptr,...) {
271  if (<obj is ok>) {
272  if (<need new object>) {
273  *ptr = <ptr to new allocated object>;
274  return SWIG_NEWOBJ;
275  } else {
276  *ptr = <ptr to old object>;
277  return SWIG_OLDOBJ;
278  }
279  } else {
280  return SWIG_BADOBJ;
281  }
282  }
283 
284  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
285  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
286  SWIG errors code.
287 
288  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
289  allows to return the 'cast rank', for example, if you have this
290 
291  int food(double)
292  int fooi(int);
293 
294  and you call
295 
296  food(1) // cast rank '1' (1 -> 1.0)
297  fooi(1) // cast rank '0'
298 
299  just use the SWIG_AddCast()/SWIG_CheckState()
300 */
301 
302 #define SWIG_OK (0)
303 #define SWIG_ERROR (-1)
304 #define SWIG_IsOK(r) (r >= 0)
305 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
306 
307 /* The CastRankLimit says how many bits are used for the cast rank */
308 #define SWIG_CASTRANKLIMIT (1 << 8)
309 /* The NewMask denotes the object was created (using new/malloc) */
310 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
311 /* The TmpMask is for in/out typemaps that use temporal objects */
312 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
313 /* Simple returning values */
314 #define SWIG_BADOBJ (SWIG_ERROR)
315 #define SWIG_OLDOBJ (SWIG_OK)
316 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
317 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
318 /* Check, add and del mask methods */
319 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
320 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
321 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
322 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
323 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
324 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
325 
326 /* Cast-Rank Mode */
327 #if defined(SWIG_CASTRANK_MODE)
328 # ifndef SWIG_TypeRank
329 # define SWIG_TypeRank unsigned long
330 # endif
331 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
332 # define SWIG_MAXCASTRANK (2)
333 # endif
334 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
335 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
336 SWIGINTERNINLINE int SWIG_AddCast(int r) {
337  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
338 }
340  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
341 }
342 #else /* no cast-rank mode */
343 # define SWIG_AddCast(r) (r)
344 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
345 #endif
346 
347 
348 #include <string.h>
349 
350 #ifdef __cplusplus
351 extern "C" {
352 #endif
353 
354 typedef void *(*swig_converter_func)(void *, int *);
355 typedef struct swig_type_info *(*swig_dycast_func)(void **);
356 
357 /* Structure to store information on one type */
358 typedef struct swig_type_info {
359  const char *name; /* mangled name of this type */
360  const char *str; /* human readable name of this type */
361  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
362  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
363  void *clientdata; /* language specific type data */
364  int owndata; /* flag if the structure owns the clientdata */
366 
367 /* Structure to store a type and conversion function used for casting */
368 typedef struct swig_cast_info {
369  swig_type_info *type; /* pointer to type that is equivalent to this type */
370  swig_converter_func converter; /* function to cast the void pointers */
371  struct swig_cast_info *next; /* pointer to next cast in linked list */
372  struct swig_cast_info *prev; /* pointer to the previous cast */
374 
375 /* Structure used to store module information
376  * Each module generates one structure like this, and the runtime collects
377  * all of these structures and stores them in a circularly linked list.*/
378 typedef struct swig_module_info {
379  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
380  size_t size; /* Number of types in this module */
381  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
382  swig_type_info **type_initial; /* Array of initially generated type structures */
383  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
384  void *clientdata; /* Language specific module data */
386 
387 /*
388  Compare two type names skipping the space characters, therefore
389  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
390 
391  Return 0 when the two name types are equivalent, as in
392  strncmp, but skipping ' '.
393 */
394 SWIGRUNTIME int
395 SWIG_TypeNameComp(const char *f1, const char *l1,
396  const char *f2, const char *l2) {
397  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
398  while ((*f1 == ' ') && (f1 != l1)) ++f1;
399  while ((*f2 == ' ') && (f2 != l2)) ++f2;
400  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
401  }
402  return (int)((l1 - f1) - (l2 - f2));
403 }
404 
405 /*
406  Check type equivalence in a name list like <name1>|<name2>|...
407  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
408 */
409 SWIGRUNTIME int
410 SWIG_TypeCmp(const char *nb, const char *tb) {
411  int equiv = 1;
412  const char* te = tb + strlen(tb);
413  const char* ne = nb;
414  while (equiv != 0 && *ne) {
415  for (nb = ne; *ne; ++ne) {
416  if (*ne == '|') break;
417  }
418  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
419  if (*ne) ++ne;
420  }
421  return equiv;
422 }
423 
424 /*
425  Check type equivalence in a name list like <name1>|<name2>|...
426  Return 0 if not equal, 1 if equal
427 */
428 SWIGRUNTIME int
429 SWIG_TypeEquiv(const char *nb, const char *tb) {
430  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
431 }
432 
433 /*
434  Check the typename
435 */
437 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
438  if (ty) {
439  swig_cast_info *iter = ty->cast;
440  while (iter) {
441  if (strcmp(iter->type->name, c) == 0) {
442  if (iter == ty->cast)
443  return iter;
444  /* Move iter to the top of the linked list */
445  iter->prev->next = iter->next;
446  if (iter->next)
447  iter->next->prev = iter->prev;
448  iter->next = ty->cast;
449  iter->prev = 0;
450  if (ty->cast) ty->cast->prev = iter;
451  ty->cast = iter;
452  return iter;
453  }
454  iter = iter->next;
455  }
456  }
457  return 0;
458 }
459 
460 /*
461  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
462 */
465  if (ty) {
466  swig_cast_info *iter = ty->cast;
467  while (iter) {
468  if (iter->type == from) {
469  if (iter == ty->cast)
470  return iter;
471  /* Move iter to the top of the linked list */
472  iter->prev->next = iter->next;
473  if (iter->next)
474  iter->next->prev = iter->prev;
475  iter->next = ty->cast;
476  iter->prev = 0;
477  if (ty->cast) ty->cast->prev = iter;
478  ty->cast = iter;
479  return iter;
480  }
481  iter = iter->next;
482  }
483  }
484  return 0;
485 }
486 
487 /*
488  Cast a pointer up an inheritance hierarchy
489 */
490 SWIGRUNTIMEINLINE void *
491 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
492  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
493 }
494 
495 /*
496  Dynamic pointer casting. Down an inheritance hierarchy
497 */
500  swig_type_info *lastty = ty;
501  if (!ty || !ty->dcast) return ty;
502  while (ty && (ty->dcast)) {
503  ty = (*ty->dcast)(ptr);
504  if (ty) lastty = ty;
505  }
506  return lastty;
507 }
508 
509 /*
510  Return the name associated with this type
511 */
512 SWIGRUNTIMEINLINE const char *
514  return ty->name;
515 }
516 
517 /*
518  Return the pretty name associated with this type,
519  that is an unmangled type name in a form presentable to the user.
520 */
521 SWIGRUNTIME const char *
523  /* The "str" field contains the equivalent pretty names of the
524  type, separated by vertical-bar characters. We choose
525  to print the last name, as it is often (?) the most
526  specific. */
527  if (!type) return NULL;
528  if (type->str != NULL) {
529  const char *last_name = type->str;
530  const char *s;
531  for (s = type->str; *s; s++)
532  if (*s == '|') last_name = s+1;
533  return last_name;
534  }
535  else
536  return type->name;
537 }
538 
539 /*
540  Set the clientdata field for a type
541 */
542 SWIGRUNTIME void
544  swig_cast_info *cast = ti->cast;
545  /* if (ti->clientdata == clientdata) return; */
546  ti->clientdata = clientdata;
547 
548  while (cast) {
549  if (!cast->converter) {
550  swig_type_info *tc = cast->type;
551  if (!tc->clientdata) {
553  }
554  }
555  cast = cast->next;
556  }
557 }
558 SWIGRUNTIME void
561  ti->owndata = 1;
562 }
563 
564 /*
565  Search for a swig_type_info structure only by mangled name
566  Search is a O(log #types)
567 
568  We start searching at module start, and finish searching when start == end.
569  Note: if start == end at the beginning of the function, we go all the way around
570  the circular list.
571 */
574  swig_module_info *end,
575  const char *name) {
576  swig_module_info *iter = start;
577  do {
578  if (iter->size) {
579  size_t l = 0;
580  size_t r = iter->size - 1;
581  do {
582  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
583  size_t i = (l + r) >> 1;
584  const char *iname = iter->types[i]->name;
585  if (iname) {
586  int compare = strcmp(name, iname);
587  if (compare == 0) {
588  return iter->types[i];
589  } else if (compare < 0) {
590  if (i) {
591  r = i - 1;
592  } else {
593  break;
594  }
595  } else if (compare > 0) {
596  l = i + 1;
597  }
598  } else {
599  break; /* should never happen */
600  }
601  } while (l <= r);
602  }
603  iter = iter->next;
604  } while (iter != end);
605  return 0;
606 }
607 
608 /*
609  Search for a swig_type_info structure for either a mangled name or a human readable name.
610  It first searches the mangled names of the types, which is a O(log #types)
611  If a type is not found it then searches the human readable names, which is O(#types).
612 
613  We start searching at module start, and finish searching when start == end.
614  Note: if start == end at the beginning of the function, we go all the way around
615  the circular list.
616 */
619  swig_module_info *end,
620  const char *name) {
621  /* STEP 1: Search the name field using binary search */
622  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
623  if (ret) {
624  return ret;
625  } else {
626  /* STEP 2: If the type hasn't been found, do a complete search
627  of the str field (the human readable name) */
628  swig_module_info *iter = start;
629  do {
630  size_t i = 0;
631  for (; i < iter->size; ++i) {
632  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
633  return iter->types[i];
634  }
635  iter = iter->next;
636  } while (iter != end);
637  }
638 
639  /* neither found a match */
640  return 0;
641 }
642 
643 /*
644  Pack binary data into a string
645 */
646 SWIGRUNTIME char *
647 SWIG_PackData(char *c, void *ptr, size_t sz) {
648  static const char hex[17] = "0123456789abcdef";
649  const unsigned char *u = (unsigned char *) ptr;
650  const unsigned char *eu = u + sz;
651  for (; u != eu; ++u) {
652  unsigned char uu = *u;
653  *(c++) = hex[(uu & 0xf0) >> 4];
654  *(c++) = hex[uu & 0xf];
655  }
656  return c;
657 }
658 
659 /*
660  Unpack binary data from a string
661 */
662 SWIGRUNTIME const char *
663 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
664  unsigned char *u = (unsigned char *) ptr;
665  const unsigned char *eu = u + sz;
666  for (; u != eu; ++u) {
667  char d = *(c++);
668  unsigned char uu;
669  if ((d >= '0') && (d <= '9'))
670  uu = (unsigned char)((d - '0') << 4);
671  else if ((d >= 'a') && (d <= 'f'))
672  uu = (unsigned char)((d - ('a'-10)) << 4);
673  else
674  return (char *) 0;
675  d = *(c++);
676  if ((d >= '0') && (d <= '9'))
677  uu |= (unsigned char)(d - '0');
678  else if ((d >= 'a') && (d <= 'f'))
679  uu |= (unsigned char)(d - ('a'-10));
680  else
681  return (char *) 0;
682  *u = uu;
683  }
684  return c;
685 }
686 
687 /*
688  Pack 'void *' into a string buffer.
689 */
690 SWIGRUNTIME char *
691 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
692  char *r = buff;
693  if ((2*sizeof(void *) + 2) > bsz) return 0;
694  *(r++) = '_';
695  r = SWIG_PackData(r,&ptr,sizeof(void *));
696  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
697  strcpy(r,name);
698  return buff;
699 }
700 
701 SWIGRUNTIME const char *
702 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
703  if (*c != '_') {
704  if (strcmp(c,"NULL") == 0) {
705  *ptr = (void *) 0;
706  return name;
707  } else {
708  return 0;
709  }
710  }
711  return SWIG_UnpackData(++c,ptr,sizeof(void *));
712 }
713 
714 SWIGRUNTIME char *
715 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
716  char *r = buff;
717  size_t lname = (name ? strlen(name) : 0);
718  if ((2*sz + 2 + lname) > bsz) return 0;
719  *(r++) = '_';
720  r = SWIG_PackData(r,ptr,sz);
721  if (lname) {
722  strncpy(r,name,lname+1);
723  } else {
724  *r = 0;
725  }
726  return buff;
727 }
728 
729 SWIGRUNTIME const char *
730 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
731  if (*c != '_') {
732  if (strcmp(c,"NULL") == 0) {
733  memset(ptr,0,sz);
734  return name;
735  } else {
736  return 0;
737  }
738  }
739  return SWIG_UnpackData(++c,ptr,sz);
740 }
741 
742 #ifdef __cplusplus
743 }
744 #endif
745 
746 /* Errors in SWIG */
747 #define SWIG_UnknownError -1
748 #define SWIG_IOError -2
749 #define SWIG_RuntimeError -3
750 #define SWIG_IndexError -4
751 #define SWIG_TypeError -5
752 #define SWIG_DivisionByZero -6
753 #define SWIG_OverflowError -7
754 #define SWIG_SyntaxError -8
755 #define SWIG_ValueError -9
756 #define SWIG_SystemError -10
757 #define SWIG_AttributeError -11
758 #define SWIG_MemoryError -12
759 #define SWIG_NullReferenceError -13
760 
761 
762 
763 /* -----------------------------------------------------------------------------
764  * error manipulation
765  * ----------------------------------------------------------------------------- */
766 
767 SWIGINTERN const char*
769  const char* type = 0;
770  switch(code) {
771  case SWIG_MemoryError:
772  type = "MemoryError";
773  break;
774  case SWIG_IOError:
775  type = "IOError";
776  break;
777  case SWIG_RuntimeError:
778  type = "RuntimeError";
779  break;
780  case SWIG_IndexError:
781  type = "IndexError";
782  break;
783  case SWIG_TypeError:
784  type = "TypeError";
785  break;
786  case SWIG_DivisionByZero:
787  type = "ZeroDivisionError";
788  break;
789  case SWIG_OverflowError:
790  type = "OverflowError";
791  break;
792  case SWIG_SyntaxError:
793  type = "SyntaxError";
794  break;
795  case SWIG_ValueError:
796  type = "ValueError";
797  break;
798  case SWIG_SystemError:
799  type = "SystemError";
800  break;
801  case SWIG_AttributeError:
802  type = "AttributeError";
803  break;
804  default:
805  type = "RuntimeError";
806  }
807  return type;
808 }
809 
810 
811 SWIGINTERN void
812 SWIG_Tcl_SetErrorObj(Tcl_Interp *interp, const char *ctype, Tcl_Obj *obj)
813 {
814  Tcl_ResetResult(interp);
815  Tcl_SetObjResult(interp, obj);
816  Tcl_SetErrorCode(interp, "SWIG", ctype, NULL);
817 }
818 
819 SWIGINTERN void
820 SWIG_Tcl_SetErrorMsg(Tcl_Interp *interp, const char *ctype, const char *mesg)
821 {
822  Tcl_ResetResult(interp);
823  Tcl_SetErrorCode(interp, "SWIG", ctype, NULL);
824  Tcl_AppendResult(interp, ctype, " ", mesg, NULL);
825  /*
826  Tcl_AddErrorInfo(interp, ctype);
827  Tcl_AddErrorInfo(interp, " ");
828  Tcl_AddErrorInfo(interp, mesg);
829  */
830 }
831 
832 SWIGINTERNINLINE void
833 SWIG_Tcl_AddErrorMsg(Tcl_Interp *interp, const char* mesg)
834 {
835  Tcl_AddErrorInfo(interp, mesg);
836 }
837 
838 
839 
840 /* -----------------------------------------------------------------------------
841  * SWIG API. Portion that goes into the runtime
842  * ----------------------------------------------------------------------------- */
843 #ifdef __cplusplus
844 extern "C" {
845 #endif
846 
847 /* -----------------------------------------------------------------------------
848  * Constant declarations
849  * ----------------------------------------------------------------------------- */
850 
851 /* Constant Types */
852 #define SWIG_TCL_POINTER 4
853 #define SWIG_TCL_BINARY 5
854 
855 /* Constant information structure */
856 typedef struct swig_const_info {
857  int type;
858  const char *name;
859  long lvalue;
860  double dvalue;
861  void *pvalue;
864 
865 typedef int (*swig_wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
866 typedef int (*swig_wrapper_func)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
867 typedef char *(*swig_variable_func)(ClientData, Tcl_Interp *, char *, char *, int);
868 typedef void (*swig_delete_func)(ClientData);
869 
870 typedef struct swig_method {
871  const char *name;
874 
875 typedef struct swig_attribute {
876  const char *name;
880 
881 typedef struct swig_class {
882  const char *name;
885  void (*destructor)(void *);
888  struct swig_class **bases;
889  const char **base_names;
891  Tcl_HashTable hashtable;
893 
894 typedef struct swig_instance {
895  Tcl_Obj *thisptr;
896  void *thisvalue;
898  int destroy;
899  Tcl_Command cmdtok;
901 
902 /* Structure for command table */
903 typedef struct {
904  const char *name;
905  int (*wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
906  ClientData clientdata;
908 
909 /* Structure for variable linking table */
910 typedef struct {
911  const char *name;
912  void *addr;
913  char * (*get)(ClientData, Tcl_Interp *, char *, char *, int);
914  char * (*set)(ClientData, Tcl_Interp *, char *, char *, int);
915 } swig_var_info;
916 
917 
918 /* -----------------------------------------------------------------------------*
919  * Install a constant object
920  * -----------------------------------------------------------------------------*/
921 
922 static Tcl_HashTable swigconstTable;
923 static int swigconstTableinit = 0;
924 
925 SWIGINTERN void
926 SWIG_Tcl_SetConstantObj(Tcl_Interp *interp, const char* name, Tcl_Obj *obj) {
927  int newobj;
928  Tcl_ObjSetVar2(interp,Tcl_NewStringObj(name,-1), NULL, obj, TCL_GLOBAL_ONLY);
929  Tcl_SetHashValue(Tcl_CreateHashEntry(&swigconstTable, name, &newobj), (ClientData) obj);
930 }
931 
932 SWIGINTERN Tcl_Obj *
933 SWIG_Tcl_GetConstantObj(const char *key) {
934  Tcl_HashEntry *entryPtr;
935  if (!swigconstTableinit) return 0;
936  entryPtr = Tcl_FindHashEntry(&swigconstTable, key);
937  if (entryPtr) {
938  return (Tcl_Obj *) Tcl_GetHashValue(entryPtr);
939  }
940  return 0;
941 }
942 
943 #ifdef __cplusplus
944 }
945 #endif
946 
947 
948 
949 /* -----------------------------------------------------------------------------
950  * tclrun.swg
951  *
952  * This file contains the runtime support for Tcl modules and includes
953  * code for managing global variables and pointer type checking.
954  * ----------------------------------------------------------------------------- */
955 
956 /* Common SWIG API */
957 
958 /* for raw pointers */
959 #define SWIG_ConvertPtr(oc, ptr, ty, flags) SWIG_Tcl_ConvertPtr(interp, oc, ptr, ty, flags)
960 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Tcl_NewPointerObj(ptr, type, flags)
961 
962 /* for raw packed data */
963 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Tcl_ConvertPacked(interp, obj, ptr, sz, ty)
964 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Tcl_NewPackedObj(ptr, sz, type)
965 
966 /* for class or struct pointers */
967 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, flags)
968 #define SWIG_NewInstanceObj(thisvalue, type, flags) SWIG_Tcl_NewInstanceObj(interp, thisvalue, type, flags)
969 
970 /* for C or C++ function pointers */
971 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, 0)
972 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Tcl_NewPointerObj(ptr, type, 0)
973 
974 /* for C++ member pointers, ie, member methods */
975 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Tcl_ConvertPacked(interp,obj, ptr, sz, ty)
976 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Tcl_NewPackedObj(ptr, sz, type)
977 
978 
979 /* Runtime API */
980 
981 #define SWIG_GetModule(clientdata) SWIG_Tcl_GetModule((Tcl_Interp *) (clientdata))
982 #define SWIG_SetModule(clientdata, pointer) SWIG_Tcl_SetModule((Tcl_Interp *) (clientdata), pointer)
983 
984 
985 /* Error manipulation */
986 
987 #define SWIG_ErrorType(code) SWIG_Tcl_ErrorType(code)
988 #define SWIG_Error(code, msg) SWIG_Tcl_SetErrorMsg(interp, SWIG_Tcl_ErrorType(code), msg)
989 #define SWIG_fail goto fail
990 
991 
992 /* Tcl-specific SWIG API */
993 
994 #define SWIG_Acquire(ptr) SWIG_Tcl_Acquire(ptr)
995 #define SWIG_MethodCommand SWIG_Tcl_MethodCommand
996 #define SWIG_Disown(ptr) SWIG_Tcl_Disown(ptr)
997 #define SWIG_ConvertPtrFromString(c, ptr, ty, flags) SWIG_Tcl_ConvertPtrFromString(interp, c, ptr, ty, flags)
998 #define SWIG_MakePtr(c, ptr, ty, flags) SWIG_Tcl_MakePtr(c, ptr, ty, flags)
999 #define SWIG_PointerTypeFromString(c) SWIG_Tcl_PointerTypeFromString(c)
1000 #define SWIG_GetArgs SWIG_Tcl_GetArgs
1001 #define SWIG_GetConstantObj(key) SWIG_Tcl_GetConstantObj(key)
1002 #define SWIG_ObjectConstructor SWIG_Tcl_ObjectConstructor
1003 #define SWIG_Thisown(ptr) SWIG_Tcl_Thisown(ptr)
1004 #define SWIG_ObjectDelete SWIG_Tcl_ObjectDelete
1005 
1006 
1007 #define SWIG_TCL_DECL_ARGS_2(arg1, arg2) (Tcl_Interp *interp SWIGUNUSED, arg1, arg2)
1008 #define SWIG_TCL_CALL_ARGS_2(arg1, arg2) (interp, arg1, arg2)
1009 /* -----------------------------------------------------------------------------
1010  * pointers/data manipulation
1011  * ----------------------------------------------------------------------------- */
1012 
1013 /* For backward compatibility only */
1014 #define SWIG_POINTER_EXCEPTION 0
1015 #define SWIG_GetConstant SWIG_GetConstantObj
1016 #define SWIG_Tcl_GetConstant SWIG_Tcl_GetConstantObj
1017 
1018 #if TCL_MAJOR_VERSION >= 8 && TCL_MINOR_VERSION >= 5
1019 #define SWIG_TCL_HASHTABLE_INIT {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1020 #else
1021 #define SWIG_TCL_HASHTABLE_INIT {0}
1022 #endif
1023 
1024 #include "assert.h"
1025 
1026 #ifdef __cplusplus
1027 extern "C" {
1028 #endif
1029 
1030 /* Object support */
1031 
1032 SWIGRUNTIME Tcl_HashTable*
1034  static Tcl_HashTable swigobjectTable;
1035  static int swigobjectTableinit = 0;
1036  if (!swigobjectTableinit) {
1037  Tcl_InitHashTable(&swigobjectTable, TCL_ONE_WORD_KEYS);
1038  swigobjectTableinit = 1;
1039  }
1040  return &swigobjectTable;
1041 }
1042 
1043 /* Acquire ownership of a pointer */
1044 SWIGRUNTIME void
1045 SWIG_Tcl_Acquire(void *ptr) {
1046  int newobj;
1047  Tcl_CreateHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr, &newobj);
1048 }
1049 
1050 SWIGRUNTIME int
1051 SWIG_Tcl_Thisown(void *ptr) {
1052  if (Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr)) {
1053  return 1;
1054  }
1055  return 0;
1056 }
1057 
1058 /* Disown a pointer. Returns 1 if we owned it to begin with */
1059 SWIGRUNTIME int
1060 SWIG_Tcl_Disown(void *ptr) {
1061  Tcl_HashEntry *entryPtr = Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr);
1062  if (entryPtr) {
1063  Tcl_DeleteHashEntry(entryPtr);
1064  return 1;
1065  }
1066  return 0;
1067 }
1068 
1069 /* Convert a pointer value */
1070 SWIGRUNTIME int
1071 SWIG_Tcl_ConvertPtrFromString(Tcl_Interp *interp, const char *c, void **ptr, swig_type_info *ty, int flags) {
1072  swig_cast_info *tc;
1073  /* Pointer values must start with leading underscore */
1074  while (*c != '_') {
1075  *ptr = (void *) 0;
1076  if (strcmp(c,"NULL") == 0)
1078 
1079  /* Empty string: not a pointer */
1080  if (*c == 0) return SWIG_ERROR;
1081 
1082  /* Hmmm. It could be an object name. */
1083 
1084  /* Check if this is a command at all. Prevents <c> cget -this */
1085  /* from being called when c is not a command, firing the unknown proc */
1086  if (Tcl_VarEval(interp,"info commands ", c, (char *) NULL) == TCL_OK) {
1087  Tcl_Obj *result = Tcl_GetObjResult(interp);
1088  if (*(Tcl_GetStringFromObj(result, NULL)) == 0) {
1089  /* It's not a command, so it can't be a pointer */
1090  Tcl_ResetResult(interp);
1091  return SWIG_ERROR;
1092  }
1093  } else {
1094  /* This will only fail if the argument is multiple words. */
1095  /* Multiple words are also not commands. */
1096  Tcl_ResetResult(interp);
1097  return SWIG_ERROR;
1098  }
1099 
1100  /* Check if this is really a SWIG pointer */
1101  if (Tcl_VarEval(interp,c," cget -this", (char *) NULL) != TCL_OK) {
1102  Tcl_ResetResult(interp);
1103  return SWIG_ERROR;
1104  }
1105 
1106  c = Tcl_GetStringFromObj(Tcl_GetObjResult(interp), NULL);
1107  }
1108 
1109  c++;
1110  c = SWIG_UnpackData(c,ptr,sizeof(void *));
1111  if (ty) {
1112  tc = c ? SWIG_TypeCheck(c,ty) : 0;
1113  if (!tc) {
1114  return SWIG_ERROR;
1115  }
1116  if (flags & SWIG_POINTER_DISOWN) {
1117  SWIG_Disown((void *) *ptr);
1118  }
1119  {
1120  int newmemory = 0;
1121  *ptr = SWIG_TypeCast(tc,(void *) *ptr,&newmemory);
1122  assert(!newmemory); /* newmemory handling not yet implemented */
1123  }
1124  }
1125  return SWIG_OK;
1126 }
1127 
1128 /* Convert a pointer value */
1130 SWIG_Tcl_ConvertPtr(Tcl_Interp *interp, Tcl_Obj *oc, void **ptr, swig_type_info *ty, int flags) {
1131  return SWIG_Tcl_ConvertPtrFromString(interp, Tcl_GetStringFromObj(oc,NULL), ptr, ty, flags);
1132 }
1133 
1134 /* Convert a pointer value */
1135 SWIGRUNTIME char *
1137  char d;
1138  /* Pointer values must start with leading underscore. NULL has no type */
1139  if (*c != '_') {
1140  return 0;
1141  }
1142  c++;
1143  /* Extract hex value from pointer */
1144  while ((d = *c)) {
1145  if (!(((d >= '0') && (d <= '9')) || ((d >= 'a') && (d <= 'f')))) break;
1146  c++;
1147  }
1148  return c;
1149 }
1150 
1151 /* Convert a packed pointer value */
1152 SWIGRUNTIME int
1153 SWIG_Tcl_ConvertPacked(Tcl_Interp *SWIGUNUSEDPARM(interp) , Tcl_Obj *obj, void *ptr, int sz, swig_type_info *ty) {
1154  swig_cast_info *tc;
1155  const char *c;
1156 
1157  if (!obj) goto type_error;
1158  c = Tcl_GetStringFromObj(obj,NULL);
1159  /* Pointer values must start with leading underscore */
1160  if (*c != '_') goto type_error;
1161  c++;
1162  c = SWIG_UnpackData(c,ptr,sz);
1163  if (ty) {
1164  tc = SWIG_TypeCheck(c,ty);
1165  if (!tc) goto type_error;
1166  }
1167  return SWIG_OK;
1168 
1169  type_error:
1170 
1171  return SWIG_ERROR;
1172 }
1173 
1174 
1175 /* Take a pointer and convert it to a string */
1176 SWIGRUNTIME void
1177 SWIG_Tcl_MakePtr(char *c, void *ptr, swig_type_info *ty, int SWIGUNUSEDPARM(flags)) {
1178  if (ptr) {
1179  *(c++) = '_';
1180  c = SWIG_PackData(c,&ptr,sizeof(void *));
1181  strcpy(c,ty->name);
1182  } else {
1183  strcpy(c,"NULL");
1184  }
1185 }
1186 
1187 /* Create a new pointer object */
1188 SWIGRUNTIMEINLINE Tcl_Obj *
1189 SWIG_Tcl_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
1190  Tcl_Obj *robj;
1191  char result[SWIG_BUFFER_SIZE];
1192  SWIG_MakePtr(result,ptr,type,flags);
1193  robj = Tcl_NewStringObj(result,-1);
1194  return robj;
1195 }
1196 
1197 SWIGRUNTIME Tcl_Obj *
1198 SWIG_Tcl_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
1199  char result[1024];
1200  char *r = result;
1201  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
1202  *(r++) = '_';
1203  r = SWIG_PackData(r,ptr,sz);
1204  strcpy(r,type->name);
1205  return Tcl_NewStringObj(result,-1);
1206 }
1207 
1208 /* -----------------------------------------------------------------------------*
1209  * Get type list
1210  * -----------------------------------------------------------------------------*/
1211 
1213 SWIG_Tcl_GetModule(Tcl_Interp *interp) {
1214  const char *data;
1215  swig_module_info *ret = 0;
1216 
1217  /* first check if pointer already created */
1218  data = Tcl_GetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TCL_GLOBAL_ONLY);
1219  if (data) {
1220  SWIG_UnpackData(data, &ret, sizeof(swig_type_info **));
1221  }
1222 
1223  return ret;
1224 }
1225 
1226 SWIGRUNTIME void
1227 SWIG_Tcl_SetModule(Tcl_Interp *interp, swig_module_info *module) {
1228  char buf[SWIG_BUFFER_SIZE];
1229  char *data;
1230 
1231  /* create a new pointer */
1232  data = SWIG_PackData(buf, &module, sizeof(swig_type_info **));
1233  *data = 0;
1234  Tcl_SetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, buf, TCL_GLOBAL_ONLY);
1235 }
1236 
1237 /* -----------------------------------------------------------------------------*
1238  * Object auxiliaries
1239  * -----------------------------------------------------------------------------*/
1240 
1241 
1242 SWIGRUNTIME void
1243 SWIG_Tcl_ObjectDelete(ClientData clientData) {
1244  swig_instance *si = (swig_instance *) clientData;
1245  if (!si) return;
1246  if (si->destroy && SWIG_Disown(si->thisvalue)) {
1247  if (si->classptr->destructor) {
1248  (si->classptr->destructor)(si->thisvalue);
1249  }
1250  }
1251  Tcl_DecrRefCount(si->thisptr);
1252  free(si);
1253 }
1254 
1255 /* Function to invoke object methods given an instance */
1256 SWIGRUNTIME int
1257 SWIG_Tcl_MethodCommand(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST _objv[]) {
1258  char *method, *attrname;
1259  swig_instance *inst = (swig_instance *) clientData;
1260  swig_method *meth;
1261  swig_attribute *attr;
1262  Tcl_Obj *oldarg;
1263  Tcl_Obj **objv;
1264  int rcode;
1265  swig_class *cls;
1266  swig_class *cls_stack[64];
1267  int cls_stack_bi[64];
1268  int cls_stack_top = 0;
1269  int numconf = 2;
1270  int bi;
1271 
1272  objv = (Tcl_Obj **) _objv;
1273  if (objc < 2) {
1274  Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1275  return TCL_ERROR;
1276  }
1277  method = Tcl_GetStringFromObj(objv[1],NULL);
1278  if (strcmp(method,"-acquire") == 0) {
1279  inst->destroy = 1;
1280  SWIG_Acquire(inst->thisvalue);
1281  return TCL_OK;
1282  }
1283  if (strcmp(method,"-disown") == 0) {
1284  if (inst->destroy) {
1285  SWIG_Disown(inst->thisvalue);
1286  }
1287  inst->destroy = 0;
1288  return TCL_OK;
1289  }
1290  if (strcmp(method,"-delete") == 0) {
1291  Tcl_DeleteCommandFromToken(interp,inst->cmdtok);
1292  return TCL_OK;
1293  }
1294  cls_stack[cls_stack_top] = inst->classptr;
1295  cls_stack_bi[cls_stack_top] = -1;
1296  while (1) {
1297  Tcl_HashEntry* hashentry;
1298  bi = cls_stack_bi[cls_stack_top];
1299  cls = cls_stack[cls_stack_top];
1300  if (bi != -1) {
1301  if (!cls->bases[bi] && cls->base_names[bi]) {
1302  /* lookup and cache the base class */
1303  swig_type_info *info = SWIG_TypeQueryModule(cls->module, cls->module, cls->base_names[bi]);
1304  if (info) cls->bases[bi] = (swig_class *) info->clientdata;
1305  }
1306  cls = cls->bases[bi];
1307  if (cls) {
1308  cls_stack_bi[cls_stack_top]++;
1309  cls_stack_top++;
1310  cls_stack[cls_stack_top] = cls;
1311  cls_stack_bi[cls_stack_top] = -1;
1312  continue;
1313  }
1314  }
1315  if (!cls) {
1316  cls_stack_top--;
1317  if (cls_stack_top < 0) break;
1318  else continue;
1319  }
1320  cls_stack_bi[cls_stack_top]++;
1321 
1322  hashentry = Tcl_FindHashEntry(&(cls->hashtable), method);
1323  if (hashentry) {
1324  ClientData cd = Tcl_GetHashValue(hashentry);
1325  swig_wrapper method_wrapper = (swig_wrapper)cd;
1326  oldarg = objv[1];
1327  objv[1] = inst->thisptr;
1328  Tcl_IncrRefCount(inst->thisptr);
1329  rcode = (method_wrapper)(clientData,interp,objc,objv);
1330  objv[1] = oldarg;
1331  Tcl_DecrRefCount(inst->thisptr);
1332  return rcode;
1333  }
1334  /* Check class methods for a match */
1335  if (strcmp(method,"cget") == 0) {
1336  if (objc < 3) {
1337  Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1338  return TCL_ERROR;
1339  }
1340  attrname = Tcl_GetStringFromObj(objv[2],NULL);
1341  attr = cls->attributes;
1342  while (attr && attr->name) {
1343  if ((strcmp(attr->name, attrname) == 0) && (attr->getmethod)) {
1344  oldarg = objv[1];
1345  objv[1] = inst->thisptr;
1346  Tcl_IncrRefCount(inst->thisptr);
1347  rcode = (*attr->getmethod)(clientData,interp,2, objv);
1348  objv[1] = oldarg;
1349  Tcl_DecrRefCount(inst->thisptr);
1350  return rcode;
1351  }
1352  attr++;
1353  }
1354  if (strcmp(attrname, "-this") == 0) {
1355  Tcl_SetObjResult(interp, Tcl_DuplicateObj(inst->thisptr));
1356  return TCL_OK;
1357  }
1358  if (strcmp(attrname, "-thisown") == 0) {
1359  if (SWIG_Thisown(inst->thisvalue)) {
1360  Tcl_SetResult(interp,(char*)"1",TCL_STATIC);
1361  } else {
1362  Tcl_SetResult(interp,(char*)"0",TCL_STATIC);
1363  }
1364  return TCL_OK;
1365  }
1366  } else if (strcmp(method, "configure") == 0) {
1367  int i;
1368  if (objc < 4) {
1369  Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1370  return TCL_ERROR;
1371  }
1372  i = 2;
1373  while (i < objc) {
1374  attrname = Tcl_GetStringFromObj(objv[i],NULL);
1375  attr = cls->attributes;
1376  while (attr && attr->name) {
1377  if ((strcmp(attr->name, attrname) == 0) && (attr->setmethod)) {
1378  oldarg = objv[i];
1379  objv[i] = inst->thisptr;
1380  Tcl_IncrRefCount(inst->thisptr);
1381  rcode = (*attr->setmethod)(clientData,interp,3, &objv[i-1]);
1382  objv[i] = oldarg;
1383  Tcl_DecrRefCount(inst->thisptr);
1384  if (rcode != TCL_OK) return rcode;
1385  numconf += 2;
1386  }
1387  attr++;
1388  }
1389  i+=2;
1390  }
1391  }
1392  }
1393  if (strcmp(method,"configure") == 0) {
1394  if (numconf >= objc) {
1395  return TCL_OK;
1396  } else {
1397  Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC);
1398  return TCL_ERROR;
1399  }
1400  }
1401  if (strcmp(method,"cget") == 0) {
1402  Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC);
1403  return TCL_ERROR;
1404  }
1405  Tcl_SetResult(interp, (char *) "Invalid method. Must be one of: configure cget -acquire -disown -delete", TCL_STATIC);
1406  cls = inst->classptr;
1407  bi = 0;
1408  while (cls) {
1409  meth = cls->methods;
1410  while (meth && meth->name) {
1411  char *cr = (char *) Tcl_GetStringResult(interp);
1412  size_t meth_len = strlen(meth->name);
1413  char* where = strchr(cr,':');
1414  while(where) {
1415  where = strstr(where, meth->name);
1416  if(where) {
1417  if(where[-1] == ' ' && (where[meth_len] == ' ' || where[meth_len]==0)) {
1418  break;
1419  } else {
1420  where++;
1421  }
1422  }
1423  }
1424 
1425  if (!where)
1426  Tcl_AppendElement(interp, (char *) meth->name);
1427  meth++;
1428  }
1429  cls = inst->classptr->bases[bi++];
1430  }
1431  return TCL_ERROR;
1432 }
1433 
1434 /* This function takes the current result and turns it into an object command */
1435 SWIGRUNTIME Tcl_Obj *
1436 SWIG_Tcl_NewInstanceObj(Tcl_Interp *interp, void *thisvalue, swig_type_info *type, int flags) {
1437  Tcl_Obj *robj = SWIG_NewPointerObj(thisvalue, type,0);
1438  /* Check to see if this pointer belongs to a class or not */
1439  if (thisvalue && (type->clientdata) && (interp)) {
1440  Tcl_CmdInfo ci;
1441  char *name;
1442  name = Tcl_GetStringFromObj(robj,NULL);
1443  if (!Tcl_GetCommandInfo(interp,name, &ci) || (flags)) {
1444  swig_instance *newinst = (swig_instance *) malloc(sizeof(swig_instance));
1445  newinst->thisptr = Tcl_DuplicateObj(robj);
1446  Tcl_IncrRefCount(newinst->thisptr);
1447  newinst->thisvalue = thisvalue;
1448  newinst->classptr = (swig_class *) type->clientdata;
1449  newinst->destroy = flags;
1450  newinst->cmdtok = Tcl_CreateObjCommand(interp, Tcl_GetStringFromObj(robj,NULL), (swig_wrapper_func) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete);
1451  if (flags) {
1452  SWIG_Acquire(thisvalue);
1453  }
1454  }
1455  }
1456  return robj;
1457 }
1458 
1459 /* Function to create objects */
1460 SWIGRUNTIME int
1461 SWIG_Tcl_ObjectConstructor(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1462  Tcl_Obj *newObj = 0;
1463  void *thisvalue = 0;
1464  swig_instance *newinst = 0;
1465  swig_class *classptr = (swig_class *) clientData;
1466  swig_wrapper cons = 0;
1467  char *name = 0;
1468  int firstarg = 0;
1469  int thisarg = 0;
1470  int destroy = 1;
1471 
1472  if (!classptr) {
1473  Tcl_SetResult(interp, (char *) "swig: internal runtime error. No class object defined.", TCL_STATIC);
1474  return TCL_ERROR;
1475  }
1476  cons = classptr->constructor;
1477  if (objc > 1) {
1478  char *s = Tcl_GetStringFromObj(objv[1],NULL);
1479  if (strcmp(s,"-this") == 0) {
1480  thisarg = 2;
1481  cons = 0;
1482  } else if (strcmp(s,"-args") == 0) {
1483  firstarg = 1;
1484  } else if (objc == 2) {
1485  firstarg = 1;
1486  name = s;
1487  } else if (objc >= 3) {
1488  char *s1;
1489  name = s;
1490  s1 = Tcl_GetStringFromObj(objv[2],NULL);
1491  if (strcmp(s1,"-this") == 0) {
1492  thisarg = 3;
1493  cons = 0;
1494  } else {
1495  firstarg = 1;
1496  }
1497  }
1498  }
1499  if (cons) {
1500  int result;
1501  result = (*cons)(0, interp, objc-firstarg, &objv[firstarg]);
1502  if (result != TCL_OK) {
1503  return result;
1504  }
1505  newObj = Tcl_DuplicateObj(Tcl_GetObjResult(interp));
1506  if (!name) name = Tcl_GetStringFromObj(newObj,NULL);
1507  } else if (thisarg > 0) {
1508  if (thisarg < objc) {
1509  destroy = 0;
1510  newObj = Tcl_DuplicateObj(objv[thisarg]);
1511  if (!name) name = Tcl_GetStringFromObj(newObj,NULL);
1512  } else {
1513  Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1514  return TCL_ERROR;
1515  }
1516  } else {
1517  Tcl_SetResult(interp, (char *) "No constructor available.", TCL_STATIC);
1518  return TCL_ERROR;
1519  }
1520  if (SWIG_Tcl_ConvertPtr(interp,newObj, (void **) &thisvalue, *(classptr->type), 0) != SWIG_OK) {
1521  Tcl_DecrRefCount(newObj);
1522  return TCL_ERROR;
1523  }
1524  newinst = (swig_instance *) malloc(sizeof(swig_instance));
1525  newinst->thisptr = newObj;
1526  Tcl_IncrRefCount(newObj);
1527  newinst->thisvalue = thisvalue;
1528  newinst->classptr = classptr;
1529  newinst->destroy = destroy;
1530  if (destroy) {
1531  SWIG_Acquire(thisvalue);
1532  }
1533  newinst->cmdtok = Tcl_CreateObjCommand(interp,name, (swig_wrapper) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete);
1534  return TCL_OK;
1535 }
1536 
1537 /* -----------------------------------------------------------------------------*
1538  * Get arguments
1539  * -----------------------------------------------------------------------------*/
1540 SWIGRUNTIME int
1541 SWIG_Tcl_GetArgs(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], const char *fmt, ...) {
1542  int argno = 0, opt = 0;
1543  long tempi;
1544  double tempd;
1545  const char *c;
1546  va_list ap;
1547  void *vptr;
1548  Tcl_Obj *obj = 0;
1549  swig_type_info *ty;
1550 
1551  va_start(ap,fmt);
1552  for (c = fmt; (*c && (*c != ':') && (*c != ';')); c++,argno++) {
1553  if (*c == '|') {
1554  opt = 1;
1555  c++;
1556  }
1557  if (argno >= (objc-1)) {
1558  if (!opt) {
1559  Tcl_SetResult(interp, (char *) "Wrong number of arguments ", TCL_STATIC);
1560  goto argerror;
1561  } else {
1562  va_end(ap);
1563  return TCL_OK;
1564  }
1565  }
1566 
1567  vptr = va_arg(ap,void *);
1568  if (vptr) {
1569  if (isupper(*c)) {
1570  obj = SWIG_Tcl_GetConstantObj(Tcl_GetStringFromObj(objv[argno+1],0));
1571  if (!obj) obj = objv[argno+1];
1572  } else {
1573  obj = objv[argno+1];
1574  }
1575  switch(*c) {
1576  case 'i': case 'I':
1577  case 'l': case 'L':
1578  case 'h': case 'H':
1579  case 'b': case 'B':
1580  if (Tcl_GetLongFromObj(interp,obj,&tempi) != TCL_OK) goto argerror;
1581  if ((*c == 'i') || (*c == 'I')) *((int *)vptr) = (int)tempi;
1582  else if ((*c == 'l') || (*c == 'L')) *((long *)vptr) = (long)tempi;
1583  else if ((*c == 'h') || (*c == 'H')) *((short*)vptr) = (short)tempi;
1584  else if ((*c == 'b') || (*c == 'B')) *((unsigned char *)vptr) = (unsigned char)tempi;
1585  break;
1586  case 'f': case 'F':
1587  case 'd': case 'D':
1588  if (Tcl_GetDoubleFromObj(interp,obj,&tempd) != TCL_OK) goto argerror;
1589  if ((*c == 'f') || (*c == 'F')) *((float *) vptr) = (float)tempd;
1590  else if ((*c == 'd') || (*c == 'D')) *((double*) vptr) = tempd;
1591  break;
1592  case 's': case 'S':
1593  if (*(c+1) == '#') {
1594  int *vlptr = (int *) va_arg(ap, void *);
1595  *((char **) vptr) = Tcl_GetStringFromObj(obj, vlptr);
1596  c++;
1597  } else {
1598  *((char **)vptr) = Tcl_GetStringFromObj(obj,NULL);
1599  }
1600  break;
1601  case 'c': case 'C':
1602  *((char *)vptr) = *(Tcl_GetStringFromObj(obj,NULL));
1603  break;
1604  case 'p': case 'P':
1605  ty = (swig_type_info *) va_arg(ap, void *);
1606  if (SWIG_Tcl_ConvertPtr(interp, obj, (void **) vptr, ty, 0) != SWIG_OK) goto argerror;
1607  break;
1608  case 'o': case 'O':
1609  *((Tcl_Obj **)vptr) = objv[argno+1];
1610  break;
1611  default:
1612  break;
1613  }
1614  }
1615  }
1616 
1617  if ((*c != ';') && ((objc-1) > argno)) {
1618  Tcl_SetResult(interp, (char *) "Wrong # args.", TCL_STATIC);
1619  goto argerror;
1620  }
1621  va_end(ap);
1622  return TCL_OK;
1623 
1624  argerror:
1625  {
1626  char temp[32];
1627  sprintf(temp,"%d", argno+1);
1628  c = strchr(fmt,':');
1629  if (!c) c = strchr(fmt,';');
1630  if (!c) c = (char *)"";
1631  Tcl_AppendResult(interp,c," argument ", temp, NULL);
1632  va_end(ap);
1633  return TCL_ERROR;
1634  }
1635 }
1636 
1637 #ifdef __cplusplus
1638 }
1639 #endif
1640 
1641 
1642 
1643 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1644 
1645 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1646 
1647 
1648 
1649 /* -------- TYPES TABLE (BEGIN) -------- */
1650 
1651 #define SWIGTYPE_p_a_block swig_types[0]
1652 #define SWIGTYPE_p_a_block_2d3 swig_types[1]
1653 #define SWIGTYPE_p_a_block_2d4 swig_types[2]
1654 #define SWIGTYPE_p_a_block_2d5 swig_types[3]
1655 #define SWIGTYPE_p_a_contact swig_types[4]
1656 #define SWIGTYPE_p_a_face swig_types[5]
1657 #define SWIGTYPE_p_a_face_2d4 swig_types[6]
1658 #define SWIGTYPE_p_a_fcriteria swig_types[7]
1659 #define SWIGTYPE_p_a_fcriteria_coulomb swig_types[8]
1660 #define SWIGTYPE_p_a_fcriteria_in swig_types[9]
1661 #define SWIGTYPE_p_a_linecloud swig_types[10]
1662 #define SWIGTYPE_p_a_material swig_types[11]
1663 #define SWIGTYPE_p_a_ocriteria swig_types[12]
1664 #define SWIGTYPE_p_a_ocriteria_H swig_types[13]
1665 #define SWIGTYPE_p_a_ocriteria_ex swig_types[14]
1666 #define SWIGTYPE_p_a_ocriteria_exmax swig_types[15]
1667 #define SWIGTYPE_p_a_plane swig_types[16]
1668 #define SWIGTYPE_p_a_plucker swig_types[17]
1669 #define SWIGTYPE_p_a_point swig_types[18]
1670 #define SWIGTYPE_p_a_segment swig_types[19]
1671 #define SWIGTYPE_p_a_structure swig_types[20]
1672 #define SWIGTYPE_p_a_trianglecloud swig_types[21]
1673 #define SWIGTYPE_p_a_twist swig_types[22]
1674 #define SWIGTYPE_p_a_wrench swig_types[23]
1675 #define SWIGTYPE_p_char swig_types[24]
1676 #define SWIGTYPE_p_difference_type swig_types[25]
1677 #define SWIGTYPE_p_size_type swig_types[26]
1678 #define SWIGTYPE_p_std__istream swig_types[27]
1679 #define SWIGTYPE_p_std__ostream swig_types[28]
1680 #define SWIGTYPE_p_std__out_of_range swig_types[29]
1681 #define SWIGTYPE_p_std__vectorT_double_t swig_types[30]
1682 #define SWIGTYPE_p_std__vectorT_int_t swig_types[31]
1683 #define SWIGTYPE_p_value_type swig_types[32]
1684 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1685 #define SWIGTYPE_std__size_t swig_types[34]
1687 static swig_module_info swig_module = {swig_types, 35, 0, 0, 0, 0};
1688 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1689 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1690 
1691 /* -------- TYPES TABLE (END) -------- */
1692 
1693 #define SWIG_init A_mechanics_Init
1694 #define SWIG_name "a_mechanics"
1695 #define SWIG_prefix ""
1696 #define SWIG_version "0.0"
1697 
1698 #define SWIGVERSION 0x040002
1699 #define SWIG_VERSION SWIGVERSION
1700 
1701 
1702 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
1703 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
1704 
1705 
1706 #include <stdexcept>
1707 
1708 
1709 
1710 #ifdef __cplusplus
1711 extern "C" {
1712 #endif
1713 #ifdef MAC_TCL
1714 #pragma export on
1715 #endif
1716 SWIGEXPORT int SWIG_init(Tcl_Interp *);
1717 #ifdef MAC_TCL
1718 #pragma export off
1719 #endif
1720 #ifdef __cplusplus
1721 }
1722 #endif
1723 
1724 /* Compatibility version for TCL stubs */
1725 #ifndef SWIG_TCL_STUBS_VERSION
1726 #define SWIG_TCL_STUBS_VERSION "8.1"
1727 #endif
1728 
1729 
1730 
1731 #include <string>
1732 
1733 
1734 #include <typeinfo>
1735 #include <stdexcept>
1736 
1737 
1738 #include <algorithm>
1739 
1740 
1741 #include <vector>
1742 
1743 Tcl_Obj* SwigString_FromString(const std::string &s) {
1744  return Tcl_NewStringObj(s.data(), (int)s.length());
1745 }
1746 
1747 int Tcl_GetBoolFromObj(Tcl_Interp *interp, Tcl_Obj *o, bool *val) {
1748  int v;
1749  int res = Tcl_GetBooleanFromObj(interp, o, &v);
1750  if (res == TCL_OK) {
1751  *val = v ? true : false;
1752  }
1753  return res;
1754 }
1755 
1756 int SwigString_AsString(Tcl_Interp *interp, Tcl_Obj *o, std::string *val) {
1757  int len;
1758  const char* temp = Tcl_GetStringFromObj(o, &len);
1759  if (temp == NULL)
1760  return TCL_ERROR;
1761  val->assign(temp, len);
1762  return TCL_OK;
1763 }
1764 
1765 // behaviour of this is such as the real Tcl_GetIntFromObj
1766 template <typename Type>
1767 int SwigInt_As(Tcl_Interp *interp, Tcl_Obj *o, Type *val) {
1768  int temp_val, return_val;
1769  return_val = Tcl_GetIntFromObj(interp, o, &temp_val);
1770  *val = (Type) temp_val;
1771  return return_val;
1772 }
1773 
1774 // behaviour of this is such as the real Tcl_GetDoubleFromObj
1775 template <typename Type>
1776 int SwigDouble_As(Tcl_Interp *interp, Tcl_Obj *o, Type *val) {
1777  int return_val;
1778  double temp_val;
1779  return_val = Tcl_GetDoubleFromObj(interp, o, &temp_val);
1780  *val = (Type) temp_val;
1781  return return_val;
1782 }
1783 
1784 
1785 
1786 #include <limits.h>
1787 #if !defined(SWIG_NO_LLONG_MAX)
1788 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1789 # define LLONG_MAX __LONG_LONG_MAX__
1790 # define LLONG_MIN (-LLONG_MAX - 1LL)
1791 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1792 # endif
1793 #endif
1794 
1795 
1796 SWIGINTERN int
1797 SWIG_AsVal_unsigned_SS_long SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, unsigned long *val) {
1798  long v;
1799  if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
1800  if (v >= 0) {
1801  if (val) *val = (unsigned long) v;
1802  return SWIG_OK;
1803  }
1804  /* If v is negative, then this could be a negative number, or an
1805  unsigned value which doesn't fit in a signed long, so try to
1806  get it as a string so we can distinguish these cases. */
1807  }
1808  {
1809  int len = 0;
1810  const char *nptr = Tcl_GetStringFromObj(obj, &len);
1811  if (nptr && len > 0) {
1812  char *endptr;
1813  unsigned long v;
1814  if (*nptr == '-') return SWIG_OverflowError;
1815  errno = 0;
1816  v = strtoul(nptr, &endptr,0);
1817  if (nptr[0] == '\0' || *endptr != '\0')
1818  return SWIG_TypeError;
1819  if (v == ULONG_MAX && errno == ERANGE) {
1820  errno = 0;
1821  return SWIG_OverflowError;
1822  } else {
1823  if (*endptr == '\0') {
1824  if (val) *val = v;
1825  return SWIG_OK;
1826  }
1827  }
1828  }
1829  }
1830 
1831  return SWIG_TypeError;
1832 }
1833 
1834 
1835 SWIGINTERN int
1836 SWIG_AsVal_unsigned_SS_int SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, unsigned int *val)
1837 {
1838  unsigned long v;
1839  int res = SWIG_AsVal_unsigned_SS_long SWIG_TCL_CALL_ARGS_2(obj, &v);
1840  if (SWIG_IsOK(res)) {
1841  if ((v > UINT_MAX)) {
1842  return SWIG_OverflowError;
1843  } else {
1844  if (val) *val = static_cast< unsigned int >(v);
1845  }
1846  }
1847  return res;
1848 }
1849 
1850 
1851 SWIGINTERN int
1852 SWIG_AsVal_long SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, long* val)
1853 {
1854  long v;
1855  if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
1856  if (val) *val = (long) v;
1857  return SWIG_OK;
1858  }
1859  return SWIG_TypeError;
1860 }
1861 
1862 
1863 SWIGINTERN int
1864 SWIG_AsVal_int SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, int *val)
1865 {
1866  long v;
1867  int res = SWIG_AsVal_long SWIG_TCL_CALL_ARGS_2(obj, &v);
1868  if (SWIG_IsOK(res)) {
1869  if ((v < INT_MIN || v > INT_MAX)) {
1870  return SWIG_OverflowError;
1871  } else {
1872  if (val) *val = static_cast< int >(v);
1873  }
1874  }
1875  return res;
1876 }
1877 
1878 
1879 SWIGINTERNINLINE Tcl_Obj*
1880 SWIG_From_long (long value)
1881 {
1882  if (((long) INT_MIN <= value) && (value <= (long) INT_MAX)) {
1883  return Tcl_NewIntObj(static_cast< int >(value));
1884  } else {
1885  return Tcl_NewLongObj(value);
1886  }
1887 }
1888 
1889 
1890 #include <stdio.h>
1891 #if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__BORLANDC__) || defined(_WATCOM)
1892 # ifndef snprintf
1893 # define snprintf _snprintf
1894 # endif
1895 #endif
1896 
1897 
1898 SWIGINTERNINLINE Tcl_Obj*
1899 SWIG_From_unsigned_SS_long (unsigned long value)
1900 {
1901  if (value < (unsigned long) LONG_MAX) {
1902  return SWIG_From_long (static_cast< long >(value));
1903  } else {
1904  char temp[256];
1905  sprintf(temp, "%lu", value);
1906  return Tcl_NewStringObj(temp,-1);
1907  }
1908 }
1909 
1910 
1911 SWIGINTERNINLINE Tcl_Obj *
1912 SWIG_From_unsigned_SS_int (unsigned int value)
1913 {
1914  return SWIG_From_unsigned_SS_long (value);
1915 }
1916 
1917 
1918  #define SWIG_From_bool Tcl_NewBooleanObj
1919 
1920 SWIGINTERN int std_vector_Sl_int_Sg__pop(std::vector< int > *self){
1921  if (self->size() == 0)
1922  throw std::out_of_range("pop from empty vector");
1923  int x = self->back();
1924  self->pop_back();
1925  return x;
1926  }
1927 
1928 SWIGINTERNINLINE Tcl_Obj *
1929 SWIG_From_int (int value)
1930 {
1931  return SWIG_From_long (value);
1932 }
1933 
1934 SWIGINTERN int std_vector_Sl_int_Sg__get(std::vector< int > *self,int i){
1935  int size = int(self->size());
1936  if (i<0) i += size;
1937  if (i>=0 && i<size)
1938  return (*self)[i];
1939  else
1940  throw std::out_of_range("vector index out of range");
1941  }
1942 SWIGINTERN void std_vector_Sl_int_Sg__set(std::vector< int > *self,int i,int x){
1943  int size = int(self->size());
1944  if (i<0) i+= size;
1945  if (i>=0 && i<size)
1946  (*self)[i] = x;
1947  else
1948  throw std::out_of_range("vector index out of range");
1949  }
1950 
1951 SWIGINTERN int
1952 SWIG_AsVal_double SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, double *val)
1953 {
1954  double v;
1955  if (Tcl_GetDoubleFromObj(0, obj, &v) == TCL_OK) {
1956  if (val) *val = v;
1957  return SWIG_OK;
1958  }
1959  return SWIG_TypeError;
1960 }
1961 
1962 SWIGINTERN double std_vector_Sl_double_Sg__pop(std::vector< double > *self){
1963  if (self->size() == 0)
1964  throw std::out_of_range("pop from empty vector");
1965  double x = self->back();
1966  self->pop_back();
1967  return x;
1968  }
1969 
1970  #define SWIG_From_double Tcl_NewDoubleObj
1971 
1972 SWIGINTERN double std_vector_Sl_double_Sg__get(std::vector< double > *self,int i){
1973  int size = int(self->size());
1974  if (i<0) i += size;
1975  if (i>=0 && i<size)
1976  return (*self)[i];
1977  else
1978  throw std::out_of_range("vector index out of range");
1979  }
1980 SWIGINTERN void std_vector_Sl_double_Sg__set(std::vector< double > *self,int i,double x){
1981  int size = int(self->size());
1982  if (i<0) i+= size;
1983  if (i>=0 && i<size)
1984  (*self)[i] = x;
1985  else
1986  throw std::out_of_range("vector index out of range");
1987  }
1988 
1989 #include "a_material.h"
1990 
1991 
1992 SWIGINTERN int
1993 SWIG_AsCharPtrAndSize(Tcl_Obj *obj, char** cptr, size_t* psize, int *alloc)
1994 {
1995  int len = 0;
1996  char *cstr = Tcl_GetStringFromObj(obj, &len);
1997  if (cstr) {
1998  if (cptr) *cptr = cstr;
1999  if (psize) *psize = len + 1;
2000  if (alloc) *alloc = SWIG_OLDOBJ;
2001  return SWIG_OK;
2002  }
2003  return SWIG_TypeError;
2004 }
2005 
2006 
2007 SWIGINTERN int
2008 SWIG_AsPtr_std_string SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, std::string **val)
2009 {
2010  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
2011  if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
2012  if (buf) {
2013  if (val) *val = new std::string(buf, size - 1);
2014  if (alloc == SWIG_NEWOBJ) delete[] buf;
2015  return SWIG_NEWOBJ;
2016  } else {
2017  if (val) *val = 0;
2018  return SWIG_OLDOBJ;
2019  }
2020  } else {
2021  static int init = 0;
2022  static swig_type_info* descriptor = 0;
2023  if (!init) {
2024  descriptor = SWIG_TypeQuery("std::string" " *");
2025  init = 1;
2026  }
2027  if (descriptor) {
2028  std::string *vptr;
2029  int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
2030  if (SWIG_IsOK(res) && val) *val = vptr;
2031  return res;
2032  }
2033  }
2034  return SWIG_ERROR;
2035 }
2036 
2037 
2038 SWIGINTERNINLINE Tcl_Obj *
2039 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
2040 {
2041  return (size < INT_MAX) ? Tcl_NewStringObj(carray, static_cast< int >(size)) : NULL;
2042 }
2043 
2044 
2045 SWIGINTERNINLINE Tcl_Obj *
2046 SWIG_From_std_string (const std::string& s)
2047 {
2048  return SWIG_FromCharPtrAndSize(s.data(), s.size());
2049 }
2050 
2052  std::ostringstream out;
2053  out << *self;
2054  return out.str();
2055  }
2056 
2057 #include <sstream>
2058 #include "a_plucker.h"
2059 
2061  std::ostringstream out;
2062  out << *self;
2063  return out.str();
2064  }
2065 
2066 #include "a_wrench.h"
2067 
2068 
2069 a_wrench * p2w(a_plucker *p) { return (a_wrench*)(p); }
2070 
2071 
2072 #include "a_twist.h"
2073 
2074 
2075 a_twist * p2t(a_plucker *p) { return (a_twist*)(p); }
2076 
2077 
2078 #include "a_block.h"
2079 
2080 SWIGINTERN std::string a_block_print(a_block *self){
2081  std::ostringstream out;
2082  out << *self;
2083  return out.str();
2084  }
2085 SWIGINTERN std::string a_block_convert(a_block *self,std::string const &code){
2086  std::ostringstream out;
2087  if (code=="brlcad") self->writeg(out);
2088  else if (code=="tri") self->writetri(out);
2089  else if (code=="blender") self->writeb(out);
2090  else out << "Wrong code. block_name convert code (tri, brlcad, blender)";
2091  return out.str();
2092  }
2093 
2094 #include "a_block.h"
2095 #include "a_block_2d3.h"
2096 
2097 
2098 #include "a_block.h"
2099 #include "a_block_2d4.h"
2100 
2101 
2102 #include "a_block.h"
2103 #include "a_block_2d5.h"
2104 
2105 
2106 #include "a_face.h"
2107 
2108 
2109 SWIGINTERN int
2110 SWIG_AsVal_unsigned_SS_short SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, unsigned short *val)
2111 {
2112  unsigned long v;
2113  int res = SWIG_AsVal_unsigned_SS_long SWIG_TCL_CALL_ARGS_2(obj, &v);
2114  if (SWIG_IsOK(res)) {
2115  if ((v > USHRT_MAX)) {
2116  return SWIG_OverflowError;
2117  } else {
2118  if (val) *val = static_cast< unsigned short >(v);
2119  }
2120  }
2121  return res;
2122 }
2123 
2124 
2125 SWIGINTERN int
2126 SWIG_AsVal_bool SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, bool *val)
2127 {
2128  int v;
2129  if (Tcl_GetBooleanFromObj(0, obj, &v) == TCL_OK) {
2130  if (val) *val = v ? true : false;
2131  return SWIG_OK;
2132  }
2133  return SWIG_TypeError;
2134 }
2135 
2136 SWIGINTERN a_wrench *a_face_f__SWIG_3(a_face *self){return self->fp();}
2137 SWIGINTERN std::string a_face_print(a_face *self){
2138  std::ostringstream out;
2139  out << *self;
2140  return out.str();
2141  }
2142 
2143 #include "a_face_2d4.h"
2144 
2145 
2146 #include "a_ocriteria.h"
2147 
2148 
2149 #include "a_ocriteria_H.h"
2150 
2151 
2152 #include "a_ocriteria_ex.h"
2153 
2154 
2155 #include "a_ocriteria_exmax.h"
2156 
2157 
2158 #include "a_fcriteria.h"
2159 
2160 
2161 #include "a_fcriteria_in.h"
2162 
2163 
2164 #include "a_fcriteria_coulomb.h"
2165 
2166 
2167 #include "a_contact.h"
2168 
2170  std::ostringstream out;
2171  out << *self;
2172  return out.str();
2173  }
2174 
2175 #include "a_structure.h"
2176 
2177 SWIGINTERN std::string a_structure_convert__SWIG_0(a_structure *self,std::string const &code){
2178  std::ostringstream out;
2179  if (code=="blender") self->writeb(out);
2180  else if (code=="brlcad") self->writeg(out);
2181  else if (code=="tri") self->writetri(out);
2182  else out << "Wrong code. block_name convert code (blender, brlcad, tri)";
2183  out.flush();
2184  return out.str();
2185  }
2186 SWIGINTERN void a_structure_convert__SWIG_1(a_structure *self,std::string const &code,std::string const &name){
2187  std::ofstream out(name.c_str());
2188  //std::ostringstream out;
2189  if (code=="blender") self->writeb(out);
2190  else if (code=="brlcad") self->writeg(out);
2191  else if (code=="tri") self->writetri(out);
2192  else out << "Wrong code. block_name convert code (blender, brlcad, tri)";
2193  out.close();
2194  return;
2195  }
2197  std::ostringstream out;
2198  out << "Function non available!" << std::endl;
2199  out << "Structures may have more than one material" << std::endl;
2200  out << "Use instead: ['a_structure' b 'ref'] material" << std::endl;
2201  return out.str();
2202  }
2203 #ifdef __cplusplus
2204 extern "C" {
2205 #endif
2206 SWIGINTERN int
2207 _wrap_new_vectori__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2208  unsigned int arg1 ;
2209  unsigned int val1 ;
2210  int ecode1 = 0 ;
2211  std::vector< int > *result = 0 ;
2212 
2213  if (SWIG_GetArgs(interp, objc, objv,"o:new_vectori size ",(void *)0) == TCL_ERROR) SWIG_fail;
2214  ecode1 = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(objv[1], &val1);
2215  if (!SWIG_IsOK(ecode1)) {
2216  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_vectori" "', argument " "1"" of type '" "unsigned int""'");
2217  }
2218  arg1 = static_cast< unsigned int >(val1);
2219  result = (std::vector< int > *)new std::vector< int >(arg1);
2220  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_t,0));
2221  return TCL_OK;
2222 fail:
2223  return TCL_ERROR;
2224 }
2225 
2226 
2227 SWIGINTERN int
2228 _wrap_new_vectori__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2229  std::vector< int > *result = 0 ;
2230 
2231  if (SWIG_GetArgs(interp, objc, objv,":new_vectori ") == TCL_ERROR) SWIG_fail;
2232  result = (std::vector< int > *)new std::vector< int >();
2233  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_t,0));
2234  return TCL_OK;
2235 fail:
2236  return TCL_ERROR;
2237 }
2238 
2239 
2240 SWIGINTERN int
2241 _wrap_new_vectori__SWIG_2(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2242  unsigned int arg1 ;
2243  int *arg2 = 0 ;
2244  unsigned int val1 ;
2245  int ecode1 = 0 ;
2246  int temp2 ;
2247  int val2 ;
2248  int ecode2 = 0 ;
2249  std::vector< int > *result = 0 ;
2250 
2251  if (SWIG_GetArgs(interp, objc, objv,"oo:new_vectori size value ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2252  ecode1 = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(objv[1], &val1);
2253  if (!SWIG_IsOK(ecode1)) {
2254  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_vectori" "', argument " "1"" of type '" "unsigned int""'");
2255  }
2256  arg1 = static_cast< unsigned int >(val1);
2257  ecode2 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2258  if (!SWIG_IsOK(ecode2)) {
2259  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_vectori" "', argument " "2"" of type '" "int""'");
2260  }
2261  temp2 = static_cast< int >(val2);
2262  arg2 = &temp2;
2263  result = (std::vector< int > *)new std::vector< int >(arg1,(int const &)*arg2);
2264  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_t,0));
2265  return TCL_OK;
2266 fail:
2267  return TCL_ERROR;
2268 }
2269 
2270 
2271 SWIGINTERN int
2272 _wrap_new_vectori__SWIG_3(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2273  std::vector< int > *arg1 = 0 ;
2274  std::vector< int > *v1 ;
2275  std::vector< int > w1 ;
2276  std::vector< int > *result = 0 ;
2277 
2278  if (SWIG_GetArgs(interp, objc, objv,"o:new_vectori other ",(void *)0) == TCL_ERROR) SWIG_fail;
2279  {
2280  Tcl_Obj **listobjv;
2281  int nitems;
2282  int i;
2283  int temp;
2284 
2285  if(SWIG_ConvertPtr(objv[1], (void **) &v1, \
2286  SWIGTYPE_p_std__vectorT_int_t, 0) == 0) {
2287  arg1 = v1;
2288  } else {
2289  // It isn't a vector< int > so it should be a list of int's
2290  if(Tcl_ListObjGetElements(interp, objv[1],
2291  &nitems, &listobjv) == TCL_ERROR)
2292  return TCL_ERROR;
2293  w1 = std::vector< int >();
2294  for (i = 0; i < nitems; i++) {
2295  if (Tcl_GetIntFromObj(interp, listobjv[i], &temp) == TCL_ERROR)
2296  return TCL_ERROR;
2297  w1.push_back(temp);
2298  }
2299  arg1 = &w1;
2300  }
2301  }
2302  result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
2303  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_t,0));
2304  return TCL_OK;
2305 fail:
2306  return TCL_ERROR;
2307 }
2308 
2309 
2310 SWIGINTERN int
2311 _wrap_new_vectori(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2312  Tcl_Obj *CONST *argv = objv+1;
2313  int argc = objc-1;
2314  if (argc == 0) {
2315  return _wrap_new_vectori__SWIG_1(clientData, interp, objc, argv - 1);
2316  }
2317  if (argc == 1) {
2318  int _v;
2319  {
2320  int res = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(argv[0], NULL);
2321  _v = SWIG_CheckState(res);
2322  }
2323  if (_v) {
2324  return _wrap_new_vectori__SWIG_0(clientData, interp, objc, argv - 1);
2325  }
2326  }
2327  if (argc == 1) {
2328  int _v;
2329  {
2330  Tcl_Obj **listobjv;
2331  int nitems;
2332  int temp;
2333  std::vector< int > *v;
2334 
2335  if(SWIG_ConvertPtr(argv[0], (void **) &v, \
2337  /* wrapped vector */
2338  _v = 1;
2339  } else {
2340  // It isn't a vector< int > so it should be a list of int's
2341  if(Tcl_ListObjGetElements(interp, argv[0],
2342  &nitems, &listobjv) == TCL_ERROR)
2343  _v = 0;
2344  else
2345  if (nitems == 0)
2346  _v = 1;
2347  //check the first value to see if it is of correct type
2348  if (Tcl_GetIntFromObj(interp, listobjv[0], &temp) == TCL_ERROR)
2349  _v = 0;
2350  else
2351  _v = 1;
2352  }
2353  }
2354  if (_v) {
2355  return _wrap_new_vectori__SWIG_3(clientData, interp, objc, argv - 1);
2356  }
2357  }
2358  if (argc == 2) {
2359  int _v;
2360  {
2361  int res = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(argv[0], NULL);
2362  _v = SWIG_CheckState(res);
2363  }
2364  if (_v) {
2365  {
2366  int res = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
2367  _v = SWIG_CheckState(res);
2368  }
2369  if (_v) {
2370  return _wrap_new_vectori__SWIG_2(clientData, interp, objc, argv - 1);
2371  }
2372  }
2373  }
2374 
2375  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'new_vectori'.\n"
2376  " Possible C/C++ prototypes are:\n"
2377  " std::vector< int >::vector(unsigned int)\n"
2378  " std::vector< int >::vector()\n"
2379  " std::vector< int >::vector(unsigned int,int const &)\n"
2380  " std::vector< int >::vector(std::vector< int > const &)\n", TCL_STATIC);
2381  return TCL_ERROR;
2382 }
2383 
2384 
2385 SWIGINTERN int
2386 _wrap_vectori_size(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2387  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2388  std::vector< int > *v1 ;
2389  std::vector< int > w1 ;
2390  unsigned int result;
2391 
2392  if (SWIG_GetArgs(interp, objc, objv,"o:vectori_size self ",(void *)0) == TCL_ERROR) SWIG_fail;
2393  {
2394  Tcl_Obj **listobjv;
2395  int nitems;
2396  int i;
2397  int temp;
2398 
2399  if(SWIG_ConvertPtr(objv[1], (void **) &v1, \
2400  SWIGTYPE_p_std__vectorT_int_t, 0) == 0) {
2401  arg1 = v1;
2402  } else {
2403  // It isn't a vector< int > so it should be a list of int's
2404  if(Tcl_ListObjGetElements(interp, objv[1],
2405  &nitems, &listobjv) == TCL_ERROR)
2406  return TCL_ERROR;
2407  w1 = std::vector< int >();
2408  for (i = 0; i < nitems; i++) {
2409  if (Tcl_GetIntFromObj(interp, listobjv[i], &temp) == TCL_ERROR)
2410  return TCL_ERROR;
2411  w1.push_back(temp);
2412  }
2413  arg1 = &w1;
2414  }
2415  }
2416  result = (unsigned int)((std::vector< int > const *)arg1)->size();
2417  Tcl_SetObjResult(interp,SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)));
2418  return TCL_OK;
2419 fail:
2420  return TCL_ERROR;
2421 }
2422 
2423 
2424 SWIGINTERN int
2425 _wrap_vectori_empty(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2426  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2427  std::vector< int > *v1 ;
2428  std::vector< int > w1 ;
2429  bool result;
2430 
2431  if (SWIG_GetArgs(interp, objc, objv,"o:vectori_empty self ",(void *)0) == TCL_ERROR) SWIG_fail;
2432  {
2433  Tcl_Obj **listobjv;
2434  int nitems;
2435  int i;
2436  int temp;
2437 
2438  if(SWIG_ConvertPtr(objv[1], (void **) &v1, \
2439  SWIGTYPE_p_std__vectorT_int_t, 0) == 0) {
2440  arg1 = v1;
2441  } else {
2442  // It isn't a vector< int > so it should be a list of int's
2443  if(Tcl_ListObjGetElements(interp, objv[1],
2444  &nitems, &listobjv) == TCL_ERROR)
2445  return TCL_ERROR;
2446  w1 = std::vector< int >();
2447  for (i = 0; i < nitems; i++) {
2448  if (Tcl_GetIntFromObj(interp, listobjv[i], &temp) == TCL_ERROR)
2449  return TCL_ERROR;
2450  w1.push_back(temp);
2451  }
2452  arg1 = &w1;
2453  }
2454  }
2455  result = (bool)((std::vector< int > const *)arg1)->empty();
2456  Tcl_SetObjResult(interp,SWIG_From_bool(static_cast< bool >(result)));
2457  return TCL_OK;
2458 fail:
2459  return TCL_ERROR;
2460 }
2461 
2462 
2463 SWIGINTERN int
2464 _wrap_vectori_clear(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2465  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2466  void *argp1 = 0 ;
2467  int res1 = 0 ;
2468 
2469  if (SWIG_GetArgs(interp, objc, objv,"o:vectori_clear self ",(void *)0) == TCL_ERROR) SWIG_fail;
2470  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 | 0 );
2471  if (!SWIG_IsOK(res1)) {
2472  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectori_clear" "', argument " "1"" of type '" "std::vector< int > *""'");
2473  }
2474  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
2475  (arg1)->clear();
2476 
2477  return TCL_OK;
2478 fail:
2479  return TCL_ERROR;
2480 }
2481 
2482 
2483 SWIGINTERN int
2484 _wrap_vectori_push(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2485  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2486  int arg2 ;
2487  void *argp1 = 0 ;
2488  int res1 = 0 ;
2489  int val2 ;
2490  int ecode2 = 0 ;
2491 
2492  if (SWIG_GetArgs(interp, objc, objv,"oo:vectori_push self x ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2493  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 | 0 );
2494  if (!SWIG_IsOK(res1)) {
2495  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectori_push" "', argument " "1"" of type '" "std::vector< int > *""'");
2496  }
2497  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
2498  ecode2 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2499  if (!SWIG_IsOK(ecode2)) {
2500  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectori_push" "', argument " "2"" of type '" "int""'");
2501  }
2502  arg2 = static_cast< int >(val2);
2503  (arg1)->push_back(arg2);
2504 
2505  return TCL_OK;
2506 fail:
2507  return TCL_ERROR;
2508 }
2509 
2510 
2511 SWIGINTERN int
2512 _wrap_vectori_pop(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2513  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2514  void *argp1 = 0 ;
2515  int res1 = 0 ;
2516  int result;
2517 
2518  if (SWIG_GetArgs(interp, objc, objv,"o:vectori_pop self ",(void *)0) == TCL_ERROR) SWIG_fail;
2519  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 | 0 );
2520  if (!SWIG_IsOK(res1)) {
2521  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectori_pop" "', argument " "1"" of type '" "std::vector< int > *""'");
2522  }
2523  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
2524  try {
2525  result = (int)std_vector_Sl_int_Sg__pop(arg1);
2526  } catch(std::out_of_range &_e) {
2527  SWIG_Tcl_SetErrorObj(interp,"std::out_of_range",SWIG_NewPointerObj((new std::out_of_range(static_cast< const std::out_of_range& >(_e))),SWIGTYPE_p_std__out_of_range,SWIG_POINTER_OWN)); SWIG_fail;
2528  }
2529  Tcl_SetObjResult(interp,SWIG_From_int(static_cast< int >(result)));
2530  return TCL_OK;
2531 fail:
2532  return TCL_ERROR;
2533 }
2534 
2535 
2536 SWIGINTERN int
2537 _wrap_vectori_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2538  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2539  int arg2 ;
2540  void *argp1 = 0 ;
2541  int res1 = 0 ;
2542  int val2 ;
2543  int ecode2 = 0 ;
2544  int result;
2545 
2546  if (SWIG_GetArgs(interp, objc, objv,"oo:vectori_get self i ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2547  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 | 0 );
2548  if (!SWIG_IsOK(res1)) {
2549  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectori_get" "', argument " "1"" of type '" "std::vector< int > *""'");
2550  }
2551  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
2552  ecode2 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2553  if (!SWIG_IsOK(ecode2)) {
2554  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectori_get" "', argument " "2"" of type '" "int""'");
2555  }
2556  arg2 = static_cast< int >(val2);
2557  try {
2558  result = (int)std_vector_Sl_int_Sg__get(arg1,arg2);
2559  } catch(std::out_of_range &_e) {
2560  SWIG_Tcl_SetErrorObj(interp,"std::out_of_range",SWIG_NewPointerObj((new std::out_of_range(static_cast< const std::out_of_range& >(_e))),SWIGTYPE_p_std__out_of_range,SWIG_POINTER_OWN)); SWIG_fail;
2561  }
2562  Tcl_SetObjResult(interp,SWIG_From_int(static_cast< int >(result)));
2563  return TCL_OK;
2564 fail:
2565  return TCL_ERROR;
2566 }
2567 
2568 
2569 SWIGINTERN int
2570 _wrap_vectori_set(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2571  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2572  int arg2 ;
2573  int arg3 ;
2574  void *argp1 = 0 ;
2575  int res1 = 0 ;
2576  int val2 ;
2577  int ecode2 = 0 ;
2578  int val3 ;
2579  int ecode3 = 0 ;
2580 
2581  if (SWIG_GetArgs(interp, objc, objv,"ooo:vectori_set self i x ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2582  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 | 0 );
2583  if (!SWIG_IsOK(res1)) {
2584  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectori_set" "', argument " "1"" of type '" "std::vector< int > *""'");
2585  }
2586  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
2587  ecode2 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2588  if (!SWIG_IsOK(ecode2)) {
2589  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectori_set" "', argument " "2"" of type '" "int""'");
2590  }
2591  arg2 = static_cast< int >(val2);
2592  ecode3 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
2593  if (!SWIG_IsOK(ecode3)) {
2594  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectori_set" "', argument " "3"" of type '" "int""'");
2595  }
2596  arg3 = static_cast< int >(val3);
2597  try {
2598  std_vector_Sl_int_Sg__set(arg1,arg2,arg3);
2599  } catch(std::out_of_range &_e) {
2600  SWIG_Tcl_SetErrorObj(interp,"std::out_of_range",SWIG_NewPointerObj((new std::out_of_range(static_cast< const std::out_of_range& >(_e))),SWIGTYPE_p_std__out_of_range,SWIG_POINTER_OWN)); SWIG_fail;
2601  }
2602 
2603  return TCL_OK;
2604 fail:
2605  return TCL_ERROR;
2606 }
2607 
2608 
2609 SWIGINTERN int
2610 _wrap_delete_vectori(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2611  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2612  void *argp1 = 0 ;
2613  int res1 = 0 ;
2614 
2615  if (SWIG_GetArgs(interp, objc, objv,"o:delete_vectori self ",(void *)0) == TCL_ERROR) SWIG_fail;
2617  if (!SWIG_IsOK(res1)) {
2618  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vectori" "', argument " "1"" of type '" "std::vector< int > *""'");
2619  }
2620  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
2621  delete arg1;
2622 
2623  return TCL_OK;
2624 fail:
2625  return TCL_ERROR;
2626 }
2627 
2628 
2630 std::vector< int > *arg1 = (std::vector< int > *) obj;
2631 delete arg1;
2632 }
2634  {"size", _wrap_vectori_size},
2635  {"empty", _wrap_vectori_empty},
2636  {"clear", _wrap_vectori_clear},
2637  {"push", _wrap_vectori_push},
2638  {"pop", _wrap_vectori_pop},
2639  {"get", _wrap_vectori_get},
2640  {"set", _wrap_vectori_set},
2641  {0,0}
2642 };
2644  {0,0,0}
2645 };
2647 static const char * swig_std_vector_Sl_int_Sg__base_names[] = {0};
2649 SWIGINTERN int
2650 _wrap_new_vectord__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2651  unsigned int arg1 ;
2652  unsigned int val1 ;
2653  int ecode1 = 0 ;
2654  std::vector< double > *result = 0 ;
2655 
2656  if (SWIG_GetArgs(interp, objc, objv,"o:new_vectord size ",(void *)0) == TCL_ERROR) SWIG_fail;
2657  ecode1 = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(objv[1], &val1);
2658  if (!SWIG_IsOK(ecode1)) {
2659  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_vectord" "', argument " "1"" of type '" "unsigned int""'");
2660  }
2661  arg1 = static_cast< unsigned int >(val1);
2662  result = (std::vector< double > *)new std::vector< double >(arg1);
2663  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_t,0));
2664  return TCL_OK;
2665 fail:
2666  return TCL_ERROR;
2667 }
2668 
2669 
2670 SWIGINTERN int
2671 _wrap_new_vectord__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2672  std::vector< double > *result = 0 ;
2673 
2674  if (SWIG_GetArgs(interp, objc, objv,":new_vectord ") == TCL_ERROR) SWIG_fail;
2675  result = (std::vector< double > *)new std::vector< double >();
2676  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_t,0));
2677  return TCL_OK;
2678 fail:
2679  return TCL_ERROR;
2680 }
2681 
2682 
2683 SWIGINTERN int
2684 _wrap_new_vectord__SWIG_2(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2685  unsigned int arg1 ;
2686  double *arg2 = 0 ;
2687  unsigned int val1 ;
2688  int ecode1 = 0 ;
2689  double temp2 ;
2690  double val2 ;
2691  int ecode2 = 0 ;
2692  std::vector< double > *result = 0 ;
2693 
2694  if (SWIG_GetArgs(interp, objc, objv,"oo:new_vectord size value ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2695  ecode1 = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(objv[1], &val1);
2696  if (!SWIG_IsOK(ecode1)) {
2697  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_vectord" "', argument " "1"" of type '" "unsigned int""'");
2698  }
2699  arg1 = static_cast< unsigned int >(val1);
2700  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2701  if (!SWIG_IsOK(ecode2)) {
2702  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_vectord" "', argument " "2"" of type '" "double""'");
2703  }
2704  temp2 = static_cast< double >(val2);
2705  arg2 = &temp2;
2706  result = (std::vector< double > *)new std::vector< double >(arg1,(double const &)*arg2);
2707  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_t,0));
2708  return TCL_OK;
2709 fail:
2710  return TCL_ERROR;
2711 }
2712 
2713 
2714 SWIGINTERN int
2715 _wrap_new_vectord__SWIG_3(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2716  std::vector< double > *arg1 = 0 ;
2717  std::vector< double > *v1 ;
2718  std::vector< double > w1 ;
2719  std::vector< double > *result = 0 ;
2720 
2721  if (SWIG_GetArgs(interp, objc, objv,"o:new_vectord other ",(void *)0) == TCL_ERROR) SWIG_fail;
2722  {
2723  Tcl_Obj **listobjv;
2724  int nitems;
2725  int i;
2726  double temp;
2727 
2728  if(SWIG_ConvertPtr(objv[1], (void **) &v1, \
2730  arg1 = v1;
2731  } else {
2732  // It isn't a vector< double > so it should be a list of double's
2733  if(Tcl_ListObjGetElements(interp, objv[1],
2734  &nitems, &listobjv) == TCL_ERROR)
2735  return TCL_ERROR;
2736  w1 = std::vector< double >();
2737  for (i = 0; i < nitems; i++) {
2738  if (Tcl_GetDoubleFromObj(interp, listobjv[i], &temp) == TCL_ERROR)
2739  return TCL_ERROR;
2740  w1.push_back(temp);
2741  }
2742  arg1 = &w1;
2743  }
2744  }
2745  result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1);
2746  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_t,0));
2747  return TCL_OK;
2748 fail:
2749  return TCL_ERROR;
2750 }
2751 
2752 
2753 SWIGINTERN int
2754 _wrap_new_vectord(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2755  Tcl_Obj *CONST *argv = objv+1;
2756  int argc = objc-1;
2757  if (argc == 0) {
2758  return _wrap_new_vectord__SWIG_1(clientData, interp, objc, argv - 1);
2759  }
2760  if (argc == 1) {
2761  int _v;
2762  {
2763  int res = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(argv[0], NULL);
2764  _v = SWIG_CheckState(res);
2765  }
2766  if (_v) {
2767  return _wrap_new_vectord__SWIG_0(clientData, interp, objc, argv - 1);
2768  }
2769  }
2770  if (argc == 1) {
2771  int _v;
2772  {
2773  Tcl_Obj **listobjv;
2774  int nitems;
2775  double temp;
2776  std::vector< double > *v;
2777 
2778  if(SWIG_ConvertPtr(argv[0], (void **) &v, \
2780  /* wrapped vector */
2781  _v = 1;
2782  } else {
2783  // It isn't a vector< double > so it should be a list of double's
2784  if(Tcl_ListObjGetElements(interp, argv[0],
2785  &nitems, &listobjv) == TCL_ERROR)
2786  _v = 0;
2787  else
2788  if (nitems == 0)
2789  _v = 1;
2790  //check the first value to see if it is of correct type
2791  if (Tcl_GetDoubleFromObj(interp, listobjv[0], &temp) == TCL_ERROR)
2792  _v = 0;
2793  else
2794  _v = 1;
2795  }
2796  }
2797  if (_v) {
2798  return _wrap_new_vectord__SWIG_3(clientData, interp, objc, argv - 1);
2799  }
2800  }
2801  if (argc == 2) {
2802  int _v;
2803  {
2804  int res = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(argv[0], NULL);
2805  _v = SWIG_CheckState(res);
2806  }
2807  if (_v) {
2808  {
2809  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
2810  _v = SWIG_CheckState(res);
2811  }
2812  if (_v) {
2813  return _wrap_new_vectord__SWIG_2(clientData, interp, objc, argv - 1);
2814  }
2815  }
2816  }
2817 
2818  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'new_vectord'.\n"
2819  " Possible C/C++ prototypes are:\n"
2820  " std::vector< double >::vector(unsigned int)\n"
2821  " std::vector< double >::vector()\n"
2822  " std::vector< double >::vector(unsigned int,double const &)\n"
2823  " std::vector< double >::vector(std::vector< double > const &)\n", TCL_STATIC);
2824  return TCL_ERROR;
2825 }
2826 
2827 
2828 SWIGINTERN int
2829 _wrap_vectord_size(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2830  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2831  std::vector< double > *v1 ;
2832  std::vector< double > w1 ;
2833  unsigned int result;
2834 
2835  if (SWIG_GetArgs(interp, objc, objv,"o:vectord_size self ",(void *)0) == TCL_ERROR) SWIG_fail;
2836  {
2837  Tcl_Obj **listobjv;
2838  int nitems;
2839  int i;
2840  double temp;
2841 
2842  if(SWIG_ConvertPtr(objv[1], (void **) &v1, \
2844  arg1 = v1;
2845  } else {
2846  // It isn't a vector< double > so it should be a list of double's
2847  if(Tcl_ListObjGetElements(interp, objv[1],
2848  &nitems, &listobjv) == TCL_ERROR)
2849  return TCL_ERROR;
2850  w1 = std::vector< double >();
2851  for (i = 0; i < nitems; i++) {
2852  if (Tcl_GetDoubleFromObj(interp, listobjv[i], &temp) == TCL_ERROR)
2853  return TCL_ERROR;
2854  w1.push_back(temp);
2855  }
2856  arg1 = &w1;
2857  }
2858  }
2859  result = (unsigned int)((std::vector< double > const *)arg1)->size();
2860  Tcl_SetObjResult(interp,SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)));
2861  return TCL_OK;
2862 fail:
2863  return TCL_ERROR;
2864 }
2865 
2866 
2867 SWIGINTERN int
2868 _wrap_vectord_empty(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2869  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2870  std::vector< double > *v1 ;
2871  std::vector< double > w1 ;
2872  bool result;
2873 
2874  if (SWIG_GetArgs(interp, objc, objv,"o:vectord_empty self ",(void *)0) == TCL_ERROR) SWIG_fail;
2875  {
2876  Tcl_Obj **listobjv;
2877  int nitems;
2878  int i;
2879  double temp;
2880 
2881  if(SWIG_ConvertPtr(objv[1], (void **) &v1, \
2883  arg1 = v1;
2884  } else {
2885  // It isn't a vector< double > so it should be a list of double's
2886  if(Tcl_ListObjGetElements(interp, objv[1],
2887  &nitems, &listobjv) == TCL_ERROR)
2888  return TCL_ERROR;
2889  w1 = std::vector< double >();
2890  for (i = 0; i < nitems; i++) {
2891  if (Tcl_GetDoubleFromObj(interp, listobjv[i], &temp) == TCL_ERROR)
2892  return TCL_ERROR;
2893  w1.push_back(temp);
2894  }
2895  arg1 = &w1;
2896  }
2897  }
2898  result = (bool)((std::vector< double > const *)arg1)->empty();
2899  Tcl_SetObjResult(interp,SWIG_From_bool(static_cast< bool >(result)));
2900  return TCL_OK;
2901 fail:
2902  return TCL_ERROR;
2903 }
2904 
2905 
2906 SWIGINTERN int
2907 _wrap_vectord_clear(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2908  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2909  void *argp1 = 0 ;
2910  int res1 = 0 ;
2911 
2912  if (SWIG_GetArgs(interp, objc, objv,"o:vectord_clear self ",(void *)0) == TCL_ERROR) SWIG_fail;
2913  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 | 0 );
2914  if (!SWIG_IsOK(res1)) {
2915  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectord_clear" "', argument " "1"" of type '" "std::vector< double > *""'");
2916  }
2917  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
2918  (arg1)->clear();
2919 
2920  return TCL_OK;
2921 fail:
2922  return TCL_ERROR;
2923 }
2924 
2925 
2926 SWIGINTERN int
2927 _wrap_vectord_push(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2928  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2929  double arg2 ;
2930  void *argp1 = 0 ;
2931  int res1 = 0 ;
2932  double val2 ;
2933  int ecode2 = 0 ;
2934 
2935  if (SWIG_GetArgs(interp, objc, objv,"oo:vectord_push self x ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2936  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 | 0 );
2937  if (!SWIG_IsOK(res1)) {
2938  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectord_push" "', argument " "1"" of type '" "std::vector< double > *""'");
2939  }
2940  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
2941  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2942  if (!SWIG_IsOK(ecode2)) {
2943  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectord_push" "', argument " "2"" of type '" "double""'");
2944  }
2945  arg2 = static_cast< double >(val2);
2946  (arg1)->push_back(arg2);
2947 
2948  return TCL_OK;
2949 fail:
2950  return TCL_ERROR;
2951 }
2952 
2953 
2954 SWIGINTERN int
2955 _wrap_vectord_pop(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2956  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2957  void *argp1 = 0 ;
2958  int res1 = 0 ;
2959  double result;
2960 
2961  if (SWIG_GetArgs(interp, objc, objv,"o:vectord_pop self ",(void *)0) == TCL_ERROR) SWIG_fail;
2962  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 | 0 );
2963  if (!SWIG_IsOK(res1)) {
2964  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectord_pop" "', argument " "1"" of type '" "std::vector< double > *""'");
2965  }
2966  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
2967  try {
2968  result = (double)std_vector_Sl_double_Sg__pop(arg1);
2969  } catch(std::out_of_range &_e) {
2970  SWIG_Tcl_SetErrorObj(interp,"std::out_of_range",SWIG_NewPointerObj((new std::out_of_range(static_cast< const std::out_of_range& >(_e))),SWIGTYPE_p_std__out_of_range,SWIG_POINTER_OWN)); SWIG_fail;
2971  }
2972  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
2973  return TCL_OK;
2974 fail:
2975  return TCL_ERROR;
2976 }
2977 
2978 
2979 SWIGINTERN int
2980 _wrap_vectord_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2981  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2982  int arg2 ;
2983  void *argp1 = 0 ;
2984  int res1 = 0 ;
2985  int val2 ;
2986  int ecode2 = 0 ;
2987  double result;
2988 
2989  if (SWIG_GetArgs(interp, objc, objv,"oo:vectord_get self i ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2990  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 | 0 );
2991  if (!SWIG_IsOK(res1)) {
2992  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectord_get" "', argument " "1"" of type '" "std::vector< double > *""'");
2993  }
2994  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
2995  ecode2 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2996  if (!SWIG_IsOK(ecode2)) {
2997  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectord_get" "', argument " "2"" of type '" "int""'");
2998  }
2999  arg2 = static_cast< int >(val2);
3000  try {
3001  result = (double)std_vector_Sl_double_Sg__get(arg1,arg2);
3002  } catch(std::out_of_range &_e) {
3003  SWIG_Tcl_SetErrorObj(interp,"std::out_of_range",SWIG_NewPointerObj((new std::out_of_range(static_cast< const std::out_of_range& >(_e))),SWIGTYPE_p_std__out_of_range,SWIG_POINTER_OWN)); SWIG_fail;
3004  }
3005  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
3006  return TCL_OK;
3007 fail:
3008  return TCL_ERROR;
3009 }
3010 
3011 
3012 SWIGINTERN int
3013 _wrap_vectord_set(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3014  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
3015  int arg2 ;
3016  double arg3 ;
3017  void *argp1 = 0 ;
3018  int res1 = 0 ;
3019  int val2 ;
3020  int ecode2 = 0 ;
3021  double val3 ;
3022  int ecode3 = 0 ;
3023 
3024  if (SWIG_GetArgs(interp, objc, objv,"ooo:vectord_set self i x ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3025  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 | 0 );
3026  if (!SWIG_IsOK(res1)) {
3027  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectord_set" "', argument " "1"" of type '" "std::vector< double > *""'");
3028  }
3029  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
3030  ecode2 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3031  if (!SWIG_IsOK(ecode2)) {
3032  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectord_set" "', argument " "2"" of type '" "int""'");
3033  }
3034  arg2 = static_cast< int >(val2);
3035  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
3036  if (!SWIG_IsOK(ecode3)) {
3037  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectord_set" "', argument " "3"" of type '" "double""'");
3038  }
3039  arg3 = static_cast< double >(val3);
3040  try {
3041  std_vector_Sl_double_Sg__set(arg1,arg2,arg3);
3042  } catch(std::out_of_range &_e) {
3043  SWIG_Tcl_SetErrorObj(interp,"std::out_of_range",SWIG_NewPointerObj((new std::out_of_range(static_cast< const std::out_of_range& >(_e))),SWIGTYPE_p_std__out_of_range,SWIG_POINTER_OWN)); SWIG_fail;
3044  }
3045 
3046  return TCL_OK;
3047 fail:
3048  return TCL_ERROR;
3049 }
3050 
3051 
3052 SWIGINTERN int
3053 _wrap_delete_vectord(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3054  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
3055  void *argp1 = 0 ;
3056  int res1 = 0 ;
3057 
3058  if (SWIG_GetArgs(interp, objc, objv,"o:delete_vectord self ",(void *)0) == TCL_ERROR) SWIG_fail;
3060  if (!SWIG_IsOK(res1)) {
3061  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vectord" "', argument " "1"" of type '" "std::vector< double > *""'");
3062  }
3063  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
3064  delete arg1;
3065 
3066  return TCL_OK;
3067 fail:
3068  return TCL_ERROR;
3069 }
3070 
3071 
3073 std::vector< double > *arg1 = (std::vector< double > *) obj;
3074 delete arg1;
3075 }
3077  {"size", _wrap_vectord_size},
3078  {"empty", _wrap_vectord_empty},
3079  {"clear", _wrap_vectord_clear},
3080  {"push", _wrap_vectord_push},
3081  {"pop", _wrap_vectord_pop},
3082  {"get", _wrap_vectord_get},
3083  {"set", _wrap_vectord_set},
3084  {0,0}
3085 };
3087  {0,0,0}
3088 };
3090 static const char * swig_std_vector_Sl_double_Sg__base_names[] = {0};
3092 SWIGINTERN int
3093 _wrap_new_a_material__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3094  a_material *result = 0 ;
3095 
3096  if (SWIG_GetArgs(interp, objc, objv,":new_a_material ") == TCL_ERROR) SWIG_fail;
3097  result = (a_material *)new a_material();
3098  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_material,0));
3099  return TCL_OK;
3100 fail:
3101  return TCL_ERROR;
3102 }
3103 
3104 
3105 SWIGINTERN int
3106 _wrap_new_a_material__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3107  std::string *arg1 = 0 ;
3108  double arg2 ;
3109  int res1 = SWIG_OLDOBJ ;
3110  double val2 ;
3111  int ecode2 = 0 ;
3112  a_material *result = 0 ;
3113 
3114  if (SWIG_GetArgs(interp, objc, objv,"oo:new_a_material name density ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3115  {
3116  std::string *ptr = (std::string *)0;
3117  res1 = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[1], &ptr);
3118  if (!SWIG_IsOK(res1)) {
3119  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_a_material" "', argument " "1"" of type '" "std::string const &""'");
3120  }
3121  if (!ptr) {
3122  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_a_material" "', argument " "1"" of type '" "std::string const &""'");
3123  }
3124  arg1 = ptr;
3125  }
3126  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3127  if (!SWIG_IsOK(ecode2)) {
3128  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_a_material" "', argument " "2"" of type '" "double""'");
3129  }
3130  arg2 = static_cast< double >(val2);
3131  result = (a_material *)new a_material((std::string const &)*arg1,arg2);
3132  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_material,0));
3133  if (SWIG_IsNewObj(res1)) delete arg1;
3134  return TCL_OK;
3135 fail:
3136  if (SWIG_IsNewObj(res1)) delete arg1;
3137  return TCL_ERROR;
3138 }
3139 
3140 
3141 SWIGINTERN int
3142 _wrap_new_a_material(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3143  Tcl_Obj *CONST *argv = objv+1;
3144  int argc = objc-1;
3145  if (argc == 0) {
3146  return _wrap_new_a_material__SWIG_0(clientData, interp, objc, argv - 1);
3147  }
3148  if (argc == 2) {
3149  int _v;
3150  int res = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(argv[0], (std::string**)(0));
3151  _v = SWIG_CheckState(res);
3152  if (_v) {
3153  {
3154  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
3155  _v = SWIG_CheckState(res);
3156  }
3157  if (_v) {
3158  return _wrap_new_a_material__SWIG_1(clientData, interp, objc, argv - 1);
3159  }
3160  }
3161  }
3162 
3163  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'new_a_material'.\n"
3164  " Possible C/C++ prototypes are:\n"
3165  " a_material::a_material()\n"
3166  " a_material::a_material(std::string const &,double)\n", TCL_STATIC);
3167  return TCL_ERROR;
3168 }
3169 
3170 
3171 SWIGINTERN int
3172 _wrap_a_material_help(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3173  std::string result;
3174 
3175  if (SWIG_GetArgs(interp, objc, objv,":a_material_help ") == TCL_ERROR) SWIG_fail;
3176  result = a_material::help();
3177  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
3178  return TCL_OK;
3179 fail:
3180  return TCL_ERROR;
3181 }
3182 
3183 
3184 SWIGINTERN int
3185 _wrap_a_material_ref__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3186  a_material *arg1 = (a_material *) 0 ;
3187  int arg2 ;
3188  void *argp1 = 0 ;
3189  int res1 = 0 ;
3190  int val2 ;
3191  int ecode2 = 0 ;
3192 
3193  if (SWIG_GetArgs(interp, objc, objv,"oo:a_material_ref self ref ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3194  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_material, 0 | 0 );
3195  if (!SWIG_IsOK(res1)) {
3196  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_material_ref" "', argument " "1"" of type '" "a_material *""'");
3197  }
3198  arg1 = reinterpret_cast< a_material * >(argp1);
3199  ecode2 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3200  if (!SWIG_IsOK(ecode2)) {
3201  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_material_ref" "', argument " "2"" of type '" "int""'");
3202  }
3203  arg2 = static_cast< int >(val2);
3204  (arg1)->ref(arg2);
3205 
3206  return TCL_OK;
3207 fail:
3208  return TCL_ERROR;
3209 }
3210 
3211 
3212 SWIGINTERN int
3213 _wrap_a_material_ref__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3214  a_material *arg1 = (a_material *) 0 ;
3215  void *argp1 = 0 ;
3216  int res1 = 0 ;
3217  int result;
3218 
3219  if (SWIG_GetArgs(interp, objc, objv,"o:a_material_ref self ",(void *)0) == TCL_ERROR) SWIG_fail;
3220  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_material, 0 | 0 );
3221  if (!SWIG_IsOK(res1)) {
3222  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_material_ref" "', argument " "1"" of type '" "a_material const *""'");
3223  }
3224  arg1 = reinterpret_cast< a_material * >(argp1);
3225  result = (int)((a_material const *)arg1)->ref();
3226  Tcl_SetObjResult(interp,SWIG_From_int(static_cast< int >(result)));
3227  return TCL_OK;
3228 fail:
3229  return TCL_ERROR;
3230 }
3231 
3232 
3233 SWIGINTERN int
3234 _wrap_a_material_ref(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3235  Tcl_Obj *CONST *argv = objv+1;
3236  int argc = objc-1;
3237  if (argc == 1) {
3238  int _v;
3239  void *vptr = 0;
3240  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_material, 0);
3241  _v = SWIG_CheckState(res);
3242  if (_v) {
3243  return _wrap_a_material_ref__SWIG_1(clientData, interp, objc, argv - 1);
3244  }
3245  }
3246  if (argc == 2) {
3247  int _v;
3248  void *vptr = 0;
3249  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_material, 0);
3250  _v = SWIG_CheckState(res);
3251  if (_v) {
3252  {
3253  int res = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
3254  _v = SWIG_CheckState(res);
3255  }
3256  if (_v) {
3257  return _wrap_a_material_ref__SWIG_0(clientData, interp, objc, argv - 1);
3258  }
3259  }
3260  }
3261 
3262  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_material_ref'.\n"
3263  " Possible C/C++ prototypes are:\n"
3264  " a_material::ref(int const)\n"
3265  " a_material::ref() const\n", TCL_STATIC);
3266  return TCL_ERROR;
3267 }
3268 
3269 
3270 SWIGINTERN int
3271 _wrap_a_material_density__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3272  a_material *arg1 = (a_material *) 0 ;
3273  double arg2 ;
3274  void *argp1 = 0 ;
3275  int res1 = 0 ;
3276  double val2 ;
3277  int ecode2 = 0 ;
3278 
3279  if (SWIG_GetArgs(interp, objc, objv,"oo:a_material_density self density ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3280  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_material, 0 | 0 );
3281  if (!SWIG_IsOK(res1)) {
3282  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_material_density" "', argument " "1"" of type '" "a_material *""'");
3283  }
3284  arg1 = reinterpret_cast< a_material * >(argp1);
3285  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3286  if (!SWIG_IsOK(ecode2)) {
3287  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_material_density" "', argument " "2"" of type '" "double""'");
3288  }
3289  arg2 = static_cast< double >(val2);
3290  (arg1)->density(arg2);
3291 
3292  return TCL_OK;
3293 fail:
3294  return TCL_ERROR;
3295 }
3296 
3297 
3298 SWIGINTERN int
3299 _wrap_a_material_density__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3300  a_material *arg1 = (a_material *) 0 ;
3301  void *argp1 = 0 ;
3302  int res1 = 0 ;
3303  double result;
3304 
3305  if (SWIG_GetArgs(interp, objc, objv,"o:a_material_density self ",(void *)0) == TCL_ERROR) SWIG_fail;
3306  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_material, 0 | 0 );
3307  if (!SWIG_IsOK(res1)) {
3308  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_material_density" "', argument " "1"" of type '" "a_material const *""'");
3309  }
3310  arg1 = reinterpret_cast< a_material * >(argp1);
3311  result = (double)((a_material const *)arg1)->density();
3312  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
3313  return TCL_OK;
3314 fail:
3315  return TCL_ERROR;
3316 }
3317 
3318 
3319 SWIGINTERN int
3320 _wrap_a_material_density(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3321  Tcl_Obj *CONST *argv = objv+1;
3322  int argc = objc-1;
3323  if (argc == 1) {
3324  int _v;
3325  void *vptr = 0;
3326  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_material, 0);
3327  _v = SWIG_CheckState(res);
3328  if (_v) {
3329  return _wrap_a_material_density__SWIG_1(clientData, interp, objc, argv - 1);
3330  }
3331  }
3332  if (argc == 2) {
3333  int _v;
3334  void *vptr = 0;
3335  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_material, 0);
3336  _v = SWIG_CheckState(res);
3337  if (_v) {
3338  {
3339  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
3340  _v = SWIG_CheckState(res);
3341  }
3342  if (_v) {
3343  return _wrap_a_material_density__SWIG_0(clientData, interp, objc, argv - 1);
3344  }
3345  }
3346  }
3347 
3348  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_material_density'.\n"
3349  " Possible C/C++ prototypes are:\n"
3350  " a_material::density(double const)\n"
3351  " a_material::density() const\n", TCL_STATIC);
3352  return TCL_ERROR;
3353 }
3354 
3355 
3356 SWIGINTERN int
3357 _wrap_a_material_name__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3358  a_material *arg1 = (a_material *) 0 ;
3359  std::string arg2 ;
3360  void *argp1 = 0 ;
3361  int res1 = 0 ;
3362 
3363  if (SWIG_GetArgs(interp, objc, objv,"oo:a_material_name self name ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3364  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_material, 0 | 0 );
3365  if (!SWIG_IsOK(res1)) {
3366  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_material_name" "', argument " "1"" of type '" "a_material *""'");
3367  }
3368  arg1 = reinterpret_cast< a_material * >(argp1);
3369  {
3370  std::string *ptr = (std::string *)0;
3371  int res = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[2], &ptr);
3372  if (!SWIG_IsOK(res) || !ptr) {
3373  SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "a_material_name" "', argument " "2"" of type '" "std::string const""'");
3374  }
3375  arg2 = *ptr;
3376  if (SWIG_IsNewObj(res)) delete ptr;
3377  }
3378  (arg1)->name(arg2);
3379 
3380  return TCL_OK;
3381 fail:
3382  return TCL_ERROR;
3383 }
3384 
3385 
3386 SWIGINTERN int
3387 _wrap_a_material_name__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3388  a_material *arg1 = (a_material *) 0 ;
3389  void *argp1 = 0 ;
3390  int res1 = 0 ;
3391  std::string result;
3392 
3393  if (SWIG_GetArgs(interp, objc, objv,"o:a_material_name self ",(void *)0) == TCL_ERROR) SWIG_fail;
3394  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_material, 0 | 0 );
3395  if (!SWIG_IsOK(res1)) {
3396  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_material_name" "', argument " "1"" of type '" "a_material const *""'");
3397  }
3398  arg1 = reinterpret_cast< a_material * >(argp1);
3399  result = ((a_material const *)arg1)->name();
3400  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
3401  return TCL_OK;
3402 fail:
3403  return TCL_ERROR;
3404 }
3405 
3406 
3407 SWIGINTERN int
3408 _wrap_a_material_name(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3409  Tcl_Obj *CONST *argv = objv+1;
3410  int argc = objc-1;
3411  if (argc == 1) {
3412  int _v;
3413  void *vptr = 0;
3414  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_material, 0);
3415  _v = SWIG_CheckState(res);
3416  if (_v) {
3417  return _wrap_a_material_name__SWIG_1(clientData, interp, objc, argv - 1);
3418  }
3419  }
3420  if (argc == 2) {
3421  int _v;
3422  void *vptr = 0;
3423  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_material, 0);
3424  _v = SWIG_CheckState(res);
3425  if (_v) {
3426  int res = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(argv[1], (std::string**)(0));
3427  _v = SWIG_CheckState(res);
3428  if (_v) {
3429  return _wrap_a_material_name__SWIG_0(clientData, interp, objc, argv - 1);
3430  }
3431  }
3432  }
3433 
3434  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_material_name'.\n"
3435  " Possible C/C++ prototypes are:\n"
3436  " a_material::name(std::string const)\n"
3437  " a_material::name() const\n", TCL_STATIC);
3438  return TCL_ERROR;
3439 }
3440 
3441 
3442 SWIGINTERN int
3443 _wrap_a_material_read(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3444  a_material *arg1 = (a_material *) 0 ;
3445  std::istream *arg2 = 0 ;
3446  void *argp1 = 0 ;
3447  int res1 = 0 ;
3448  void *argp2 = 0 ;
3449  int res2 = 0 ;
3450 
3451  if (SWIG_GetArgs(interp, objc, objv,"oo:a_material_read self i ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3452  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_material, 0 | 0 );
3453  if (!SWIG_IsOK(res1)) {
3454  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_material_read" "', argument " "1"" of type '" "a_material *""'");
3455  }
3456  arg1 = reinterpret_cast< a_material * >(argp1);
3457  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__istream, 0 );
3458  if (!SWIG_IsOK(res2)) {
3459  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_material_read" "', argument " "2"" of type '" "std::istream &""'");
3460  }
3461  if (!argp2) {
3462  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_material_read" "', argument " "2"" of type '" "std::istream &""'");
3463  }
3464  arg2 = reinterpret_cast< std::istream * >(argp2);
3465  (arg1)->read(*arg2);
3466 
3467  return TCL_OK;
3468 fail:
3469  return TCL_ERROR;
3470 }
3471 
3472 
3473 SWIGINTERN int
3474 _wrap_a_material_write(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3475  a_material *arg1 = (a_material *) 0 ;
3476  std::ostream *arg2 = 0 ;
3477  void *argp1 = 0 ;
3478  int res1 = 0 ;
3479  void *argp2 = 0 ;
3480  int res2 = 0 ;
3481 
3482  if (SWIG_GetArgs(interp, objc, objv,"oo:a_material_write self o ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3483  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_material, 0 | 0 );
3484  if (!SWIG_IsOK(res1)) {
3485  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_material_write" "', argument " "1"" of type '" "a_material const *""'");
3486  }
3487  arg1 = reinterpret_cast< a_material * >(argp1);
3488  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__ostream, 0 );
3489  if (!SWIG_IsOK(res2)) {
3490  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_material_write" "', argument " "2"" of type '" "std::ostream &""'");
3491  }
3492  if (!argp2) {
3493  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_material_write" "', argument " "2"" of type '" "std::ostream &""'");
3494  }
3495  arg2 = reinterpret_cast< std::ostream * >(argp2);
3496  ((a_material const *)arg1)->write(*arg2);
3497 
3498  return TCL_OK;
3499 fail:
3500  return TCL_ERROR;
3501 }
3502 
3503 
3504 SWIGINTERN int
3505 _wrap_a_material_print(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3506  a_material *arg1 = (a_material *) 0 ;
3507  void *argp1 = 0 ;
3508  int res1 = 0 ;
3509  std::string result;
3510 
3511  if (SWIG_GetArgs(interp, objc, objv,"o:a_material_print self ",(void *)0) == TCL_ERROR) SWIG_fail;
3512  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_material, 0 | 0 );
3513  if (!SWIG_IsOK(res1)) {
3514  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_material_print" "', argument " "1"" of type '" "a_material *""'");
3515  }
3516  arg1 = reinterpret_cast< a_material * >(argp1);
3517  result = a_material_print(arg1);
3518  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
3519  return TCL_OK;
3520 fail:
3521  return TCL_ERROR;
3522 }
3523 
3524 
3525 SWIGINTERN int
3526 _wrap_delete_a_material(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3527  a_material *arg1 = (a_material *) 0 ;
3528  void *argp1 = 0 ;
3529  int res1 = 0 ;
3530 
3531  if (SWIG_GetArgs(interp, objc, objv,"o:delete_a_material self ",(void *)0) == TCL_ERROR) SWIG_fail;
3532  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_material, SWIG_POINTER_DISOWN | 0 );
3533  if (!SWIG_IsOK(res1)) {
3534  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_a_material" "', argument " "1"" of type '" "a_material *""'");
3535  }
3536  arg1 = reinterpret_cast< a_material * >(argp1);
3537  delete arg1;
3538 
3539  return TCL_OK;
3540 fail:
3541  return TCL_ERROR;
3542 }
3543 
3544 
3546 a_material *arg1 = (a_material *) obj;
3547 delete arg1;
3548 }
3550  {"ref", _wrap_a_material_ref},
3551  {"density", _wrap_a_material_density},
3552  {"name", _wrap_a_material_name},
3553  {"read", _wrap_a_material_read},
3554  {"write", _wrap_a_material_write},
3555  {"print", _wrap_a_material_print},
3556  {0,0}
3557 };
3559  {0,0,0}
3560 };
3562 static const char * swig_a_material_base_names[] = {0};
3564 SWIGINTERN int
3565 _wrap_new_a_plucker(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3566  double arg1 ;
3567  double arg2 ;
3568  double arg3 ;
3569  double arg4 ;
3570  double arg5 ;
3571  double arg6 ;
3572  double val1 ;
3573  int ecode1 = 0 ;
3574  double val2 ;
3575  int ecode2 = 0 ;
3576  double val3 ;
3577  int ecode3 = 0 ;
3578  double val4 ;
3579  int ecode4 = 0 ;
3580  double val5 ;
3581  int ecode5 = 0 ;
3582  double val6 ;
3583  int ecode6 = 0 ;
3584  a_plucker *result = 0 ;
3585 
3586  if (SWIG_GetArgs(interp, objc, objv,"oooooo:new_a_plucker ax ay az bx by bz ",(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3587  ecode1 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[1], &val1);
3588  if (!SWIG_IsOK(ecode1)) {
3589  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_a_plucker" "', argument " "1"" of type '" "double""'");
3590  }
3591  arg1 = static_cast< double >(val1);
3592  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3593  if (!SWIG_IsOK(ecode2)) {
3594  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_a_plucker" "', argument " "2"" of type '" "double""'");
3595  }
3596  arg2 = static_cast< double >(val2);
3597  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
3598  if (!SWIG_IsOK(ecode3)) {
3599  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_a_plucker" "', argument " "3"" of type '" "double""'");
3600  }
3601  arg3 = static_cast< double >(val3);
3602  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
3603  if (!SWIG_IsOK(ecode4)) {
3604  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_a_plucker" "', argument " "4"" of type '" "double""'");
3605  }
3606  arg4 = static_cast< double >(val4);
3607  ecode5 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[5], &val5);
3608  if (!SWIG_IsOK(ecode5)) {
3609  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_a_plucker" "', argument " "5"" of type '" "double""'");
3610  }
3611  arg5 = static_cast< double >(val5);
3612  ecode6 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[6], &val6);
3613  if (!SWIG_IsOK(ecode6)) {
3614  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_a_plucker" "', argument " "6"" of type '" "double""'");
3615  }
3616  arg6 = static_cast< double >(val6);
3617  result = (a_plucker *)new a_plucker(arg1,arg2,arg3,arg4,arg5,arg6);
3618  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_plucker,0));
3619  return TCL_OK;
3620 fail:
3621  return TCL_ERROR;
3622 }
3623 
3624 
3625 SWIGINTERN int
3626 _wrap_a_plucker_name(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3627  a_plucker *arg1 = (a_plucker *) 0 ;
3628  void *argp1 = 0 ;
3629  int res1 = 0 ;
3630  std::string result;
3631 
3632  if (SWIG_GetArgs(interp, objc, objv,"o:a_plucker_name self ",(void *)0) == TCL_ERROR) SWIG_fail;
3633  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_plucker, 0 | 0 );
3634  if (!SWIG_IsOK(res1)) {
3635  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_plucker_name" "', argument " "1"" of type '" "a_plucker const *""'");
3636  }
3637  arg1 = reinterpret_cast< a_plucker * >(argp1);
3638  result = ((a_plucker const *)arg1)->name();
3639  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
3640  return TCL_OK;
3641 fail:
3642  return TCL_ERROR;
3643 }
3644 
3645 
3646 SWIGINTERN int
3647 _wrap_a_plucker_a___(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3648  a_plucker *arg1 = (a_plucker *) 0 ;
3649  a_plucker *arg2 = 0 ;
3650  void *argp1 = 0 ;
3651  int res1 = 0 ;
3652  void *argp2 ;
3653  int res2 = 0 ;
3654  SwigValueWrapper< a_plucker > result;
3655 
3656  if (SWIG_GetArgs(interp, objc, objv,"oo:a_plucker_+ self a ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3657  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_plucker, 0 | 0 );
3658  if (!SWIG_IsOK(res1)) {
3659  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_plucker_+" "', argument " "1"" of type '" "a_plucker *""'");
3660  }
3661  arg1 = reinterpret_cast< a_plucker * >(argp1);
3662  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_plucker, 0 );
3663  if (!SWIG_IsOK(res2)) {
3664  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_plucker_+" "', argument " "2"" of type '" "a_plucker const &""'");
3665  }
3666  if (!argp2) {
3667  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_plucker_+" "', argument " "2"" of type '" "a_plucker const &""'");
3668  }
3669  arg2 = reinterpret_cast< a_plucker * >(argp2);
3670  result = (arg1)->operator +((a_plucker const &)*arg2);
3671  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_plucker(static_cast< const a_plucker& >(result))), SWIGTYPE_p_a_plucker, SWIG_POINTER_OWN | 0 ));
3672  return TCL_OK;
3673 fail:
3674  return TCL_ERROR;
3675 }
3676 
3677 
3678 SWIGINTERN int
3679 _wrap_a_plucker_s_____SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3680  a_plucker *arg1 = (a_plucker *) 0 ;
3681  a_plucker *arg2 = 0 ;
3682  void *argp1 = 0 ;
3683  int res1 = 0 ;
3684  void *argp2 ;
3685  int res2 = 0 ;
3686  SwigValueWrapper< a_plucker > result;
3687 
3688  if (SWIG_GetArgs(interp, objc, objv,"oo:a_plucker_- self a ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3689  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_plucker, 0 | 0 );
3690  if (!SWIG_IsOK(res1)) {
3691  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_plucker_-" "', argument " "1"" of type '" "a_plucker *""'");
3692  }
3693  arg1 = reinterpret_cast< a_plucker * >(argp1);
3694  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_plucker, 0 );
3695  if (!SWIG_IsOK(res2)) {
3696  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_plucker_-" "', argument " "2"" of type '" "a_plucker const &""'");
3697  }
3698  if (!argp2) {
3699  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_plucker_-" "', argument " "2"" of type '" "a_plucker const &""'");
3700  }
3701  arg2 = reinterpret_cast< a_plucker * >(argp2);
3702  result = (arg1)->operator -((a_plucker const &)*arg2);
3703  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_plucker(static_cast< const a_plucker& >(result))), SWIGTYPE_p_a_plucker, SWIG_POINTER_OWN | 0 ));
3704  return TCL_OK;
3705 fail:
3706  return TCL_ERROR;
3707 }
3708 
3709 
3710 SWIGINTERN int
3711 _wrap_a_plucker_s_____SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3712  a_plucker *arg1 = (a_plucker *) 0 ;
3713  void *argp1 = 0 ;
3714  int res1 = 0 ;
3715  a_plucker *result = 0 ;
3716 
3717  if (SWIG_GetArgs(interp, objc, objv,"o:a_plucker_- self ",(void *)0) == TCL_ERROR) SWIG_fail;
3718  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_plucker, 0 | 0 );
3719  if (!SWIG_IsOK(res1)) {
3720  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_plucker_-" "', argument " "1"" of type '" "a_plucker *""'");
3721  }
3722  arg1 = reinterpret_cast< a_plucker * >(argp1);
3723  result = (a_plucker *) &(arg1)->operator -();
3724  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_plucker,0));
3725  return TCL_OK;
3726 fail:
3727  return TCL_ERROR;
3728 }
3729 
3730 
3731 SWIGINTERN int
3732 _wrap_a_plucker_s___(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3733  Tcl_Obj *CONST *argv = objv+1;
3734  int argc = objc-1;
3735  if (argc == 1) {
3736  int _v;
3737  void *vptr = 0;
3738  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_plucker, 0);
3739  _v = SWIG_CheckState(res);
3740  if (_v) {
3741  return _wrap_a_plucker_s_____SWIG_1(clientData, interp, objc, argv - 1);
3742  }
3743  }
3744  if (argc == 2) {
3745  int _v;
3746  void *vptr = 0;
3747  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_plucker, 0);
3748  _v = SWIG_CheckState(res);
3749  if (_v) {
3750  void *vptr = 0;
3751  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_plucker, SWIG_POINTER_NO_NULL);
3752  _v = SWIG_CheckState(res);
3753  if (_v) {
3754  return _wrap_a_plucker_s_____SWIG_0(clientData, interp, objc, argv - 1);
3755  }
3756  }
3757  }
3758 
3759  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_plucker_-'.\n"
3760  " Possible C/C++ prototypes are:\n"
3761  " a_plucker::operator -(a_plucker const &)\n"
3762  " a_plucker::operator -()\n", TCL_STATIC);
3763  return TCL_ERROR;
3764 }
3765 
3766 
3767 SWIGINTERN int
3768 _wrap_a_plucker_p1__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3769  a_plucker *arg1 = (a_plucker *) 0 ;
3770  void *argp1 = 0 ;
3771  int res1 = 0 ;
3772  a_point result;
3773 
3774  if (SWIG_GetArgs(interp, objc, objv,"o:a_plucker_p1 self ",(void *)0) == TCL_ERROR) SWIG_fail;
3775  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_plucker, 0 | 0 );
3776  if (!SWIG_IsOK(res1)) {
3777  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_plucker_p1" "', argument " "1"" of type '" "a_plucker const *""'");
3778  }
3779  arg1 = reinterpret_cast< a_plucker * >(argp1);
3780  result = ((a_plucker const *)arg1)->p1();
3781  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_point(static_cast< const a_point& >(result))), SWIGTYPE_p_a_point, SWIG_POINTER_OWN | 0 ));
3782  return TCL_OK;
3783 fail:
3784  return TCL_ERROR;
3785 }
3786 
3787 
3788 SWIGINTERN int
3789 _wrap_a_plucker_p2__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3790  a_plucker *arg1 = (a_plucker *) 0 ;
3791  void *argp1 = 0 ;
3792  int res1 = 0 ;
3793  a_point result;
3794 
3795  if (SWIG_GetArgs(interp, objc, objv,"o:a_plucker_p2 self ",(void *)0) == TCL_ERROR) SWIG_fail;
3796  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_plucker, 0 | 0 );
3797  if (!SWIG_IsOK(res1)) {
3798  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_plucker_p2" "', argument " "1"" of type '" "a_plucker const *""'");
3799  }
3800  arg1 = reinterpret_cast< a_plucker * >(argp1);
3801  result = ((a_plucker const *)arg1)->p2();
3802  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_point(static_cast< const a_point& >(result))), SWIGTYPE_p_a_point, SWIG_POINTER_OWN | 0 ));
3803  return TCL_OK;
3804 fail:
3805  return TCL_ERROR;
3806 }
3807 
3808 
3809 SWIGINTERN int
3810 _wrap_a_plucker_p1__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3811  a_plucker *arg1 = (a_plucker *) 0 ;
3812  a_point *arg2 = 0 ;
3813  void *argp1 = 0 ;
3814  int res1 = 0 ;
3815  void *argp2 ;
3816  int res2 = 0 ;
3817 
3818  if (SWIG_GetArgs(interp, objc, objv,"oo:a_plucker_p1 self p ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3819  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_plucker, 0 | 0 );
3820  if (!SWIG_IsOK(res1)) {
3821  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_plucker_p1" "', argument " "1"" of type '" "a_plucker *""'");
3822  }
3823  arg1 = reinterpret_cast< a_plucker * >(argp1);
3824  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
3825  if (!SWIG_IsOK(res2)) {
3826  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_plucker_p1" "', argument " "2"" of type '" "a_point const &""'");
3827  }
3828  if (!argp2) {
3829  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_plucker_p1" "', argument " "2"" of type '" "a_point const &""'");
3830  }
3831  arg2 = reinterpret_cast< a_point * >(argp2);
3832  (arg1)->p1((a_point const &)*arg2);
3833 
3834  return TCL_OK;
3835 fail:
3836  return TCL_ERROR;
3837 }
3838 
3839 
3840 SWIGINTERN int
3841 _wrap_a_plucker_p1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3842  Tcl_Obj *CONST *argv = objv+1;
3843  int argc = objc-1;
3844  if (argc == 1) {
3845  int _v;
3846  void *vptr = 0;
3847  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_plucker, 0);
3848  _v = SWIG_CheckState(res);
3849  if (_v) {
3850  return _wrap_a_plucker_p1__SWIG_0(clientData, interp, objc, argv - 1);
3851  }
3852  }
3853  if (argc == 2) {
3854  int _v;
3855  void *vptr = 0;
3856  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_plucker, 0);
3857  _v = SWIG_CheckState(res);
3858  if (_v) {
3859  void *vptr = 0;
3860  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
3861  _v = SWIG_CheckState(res);
3862  if (_v) {
3863  return _wrap_a_plucker_p1__SWIG_1(clientData, interp, objc, argv - 1);
3864  }
3865  }
3866  }
3867 
3868  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_plucker_p1'.\n"
3869  " Possible C/C++ prototypes are:\n"
3870  " a_plucker::p1() const\n"
3871  " a_plucker::p1(a_point const &)\n", TCL_STATIC);
3872  return TCL_ERROR;
3873 }
3874 
3875 
3876 SWIGINTERN int
3877 _wrap_a_plucker_p2__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3878  a_plucker *arg1 = (a_plucker *) 0 ;
3879  a_point *arg2 = 0 ;
3880  void *argp1 = 0 ;
3881  int res1 = 0 ;
3882  void *argp2 ;
3883  int res2 = 0 ;
3884 
3885  if (SWIG_GetArgs(interp, objc, objv,"oo:a_plucker_p2 self p ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3886  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_plucker, 0 | 0 );
3887  if (!SWIG_IsOK(res1)) {
3888  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_plucker_p2" "', argument " "1"" of type '" "a_plucker *""'");
3889  }
3890  arg1 = reinterpret_cast< a_plucker * >(argp1);
3891  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
3892  if (!SWIG_IsOK(res2)) {
3893  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_plucker_p2" "', argument " "2"" of type '" "a_point const &""'");
3894  }
3895  if (!argp2) {
3896  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_plucker_p2" "', argument " "2"" of type '" "a_point const &""'");
3897  }
3898  arg2 = reinterpret_cast< a_point * >(argp2);
3899  (arg1)->p2((a_point const &)*arg2);
3900 
3901  return TCL_OK;
3902 fail:
3903  return TCL_ERROR;
3904 }
3905 
3906 
3907 SWIGINTERN int
3908 _wrap_a_plucker_p2(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3909  Tcl_Obj *CONST *argv = objv+1;
3910  int argc = objc-1;
3911  if (argc == 1) {
3912  int _v;
3913  void *vptr = 0;
3914  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_plucker, 0);
3915  _v = SWIG_CheckState(res);
3916  if (_v) {
3917  return _wrap_a_plucker_p2__SWIG_0(clientData, interp, objc, argv - 1);
3918  }
3919  }
3920  if (argc == 2) {
3921  int _v;
3922  void *vptr = 0;
3923  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_plucker, 0);
3924  _v = SWIG_CheckState(res);
3925  if (_v) {
3926  void *vptr = 0;
3927  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
3928  _v = SWIG_CheckState(res);
3929  if (_v) {
3930  return _wrap_a_plucker_p2__SWIG_1(clientData, interp, objc, argv - 1);
3931  }
3932  }
3933  }
3934 
3935  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_plucker_p2'.\n"
3936  " Possible C/C++ prototypes are:\n"
3937  " a_plucker::p2() const\n"
3938  " a_plucker::p2(a_point const &)\n", TCL_STATIC);
3939  return TCL_ERROR;
3940 }
3941 
3942 
3943 SWIGINTERN int
3944 _wrap_a_plucker_read(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3945  a_plucker *arg1 = (a_plucker *) 0 ;
3946  std::istream *arg2 = 0 ;
3947  void *argp1 = 0 ;
3948  int res1 = 0 ;
3949  void *argp2 = 0 ;
3950  int res2 = 0 ;
3951 
3952  if (SWIG_GetArgs(interp, objc, objv,"oo:a_plucker_read self i ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3953  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_plucker, 0 | 0 );
3954  if (!SWIG_IsOK(res1)) {
3955  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_plucker_read" "', argument " "1"" of type '" "a_plucker *""'");
3956  }
3957  arg1 = reinterpret_cast< a_plucker * >(argp1);
3958  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__istream, 0 );
3959  if (!SWIG_IsOK(res2)) {
3960  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_plucker_read" "', argument " "2"" of type '" "std::istream &""'");
3961  }
3962  if (!argp2) {
3963  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_plucker_read" "', argument " "2"" of type '" "std::istream &""'");
3964  }
3965  arg2 = reinterpret_cast< std::istream * >(argp2);
3966  (arg1)->read(*arg2);
3967 
3968  return TCL_OK;
3969 fail:
3970  return TCL_ERROR;
3971 }
3972 
3973 
3974 SWIGINTERN int
3975 _wrap_a_plucker_write(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3976  a_plucker *arg1 = (a_plucker *) 0 ;
3977  std::ostream *arg2 = 0 ;
3978  void *argp1 = 0 ;
3979  int res1 = 0 ;
3980  void *argp2 = 0 ;
3981  int res2 = 0 ;
3982 
3983  if (SWIG_GetArgs(interp, objc, objv,"oo:a_plucker_write self o ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3984  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_plucker, 0 | 0 );
3985  if (!SWIG_IsOK(res1)) {
3986  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_plucker_write" "', argument " "1"" of type '" "a_plucker const *""'");
3987  }
3988  arg1 = reinterpret_cast< a_plucker * >(argp1);
3989  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__ostream, 0 );
3990  if (!SWIG_IsOK(res2)) {
3991  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_plucker_write" "', argument " "2"" of type '" "std::ostream &""'");
3992  }
3993  if (!argp2) {
3994  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_plucker_write" "', argument " "2"" of type '" "std::ostream &""'");
3995  }
3996  arg2 = reinterpret_cast< std::ostream * >(argp2);
3997  ((a_plucker const *)arg1)->write(*arg2);
3998 
3999  return TCL_OK;
4000 fail:
4001  return TCL_ERROR;
4002 }
4003 
4004 
4005 SWIGINTERN int
4006 _wrap_a_plucker_print(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4007  a_plucker *arg1 = (a_plucker *) 0 ;
4008  void *argp1 = 0 ;
4009  int res1 = 0 ;
4010  std::string result;
4011 
4012  if (SWIG_GetArgs(interp, objc, objv,"o:a_plucker_print self ",(void *)0) == TCL_ERROR) SWIG_fail;
4013  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_plucker, 0 | 0 );
4014  if (!SWIG_IsOK(res1)) {
4015  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_plucker_print" "', argument " "1"" of type '" "a_plucker *""'");
4016  }
4017  arg1 = reinterpret_cast< a_plucker * >(argp1);
4018  result = a_plucker_print(arg1);
4019  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
4020  return TCL_OK;
4021 fail:
4022  return TCL_ERROR;
4023 }
4024 
4025 
4026 SWIGINTERN int
4027 _wrap_delete_a_plucker(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4028  a_plucker *arg1 = (a_plucker *) 0 ;
4029  void *argp1 = 0 ;
4030  int res1 = 0 ;
4031 
4032  if (SWIG_GetArgs(interp, objc, objv,"o:delete_a_plucker self ",(void *)0) == TCL_ERROR) SWIG_fail;
4033  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_plucker, SWIG_POINTER_DISOWN | 0 );
4034  if (!SWIG_IsOK(res1)) {
4035  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_a_plucker" "', argument " "1"" of type '" "a_plucker *""'");
4036  }
4037  arg1 = reinterpret_cast< a_plucker * >(argp1);
4038  delete arg1;
4039 
4040  return TCL_OK;
4041 fail:
4042  return TCL_ERROR;
4043 }
4044 
4045 
4047 a_plucker *arg1 = (a_plucker *) obj;
4048 delete arg1;
4049 }
4051  {"name", _wrap_a_plucker_name},
4052  {"+", _wrap_a_plucker_a___},
4053  {"-", _wrap_a_plucker_s___},
4054  {"p1", _wrap_a_plucker_p1},
4055  {"p2", _wrap_a_plucker_p2},
4056  {"read", _wrap_a_plucker_read},
4057  {"write", _wrap_a_plucker_write},
4058  {"print", _wrap_a_plucker_print},
4059  {0,0}
4060 };
4062  {0,0,0}
4063 };
4065 static const char * swig_a_plucker_base_names[] = {0};
4067 SWIGINTERN int
4068 _wrap_p2w(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4069  a_plucker *arg1 = (a_plucker *) 0 ;
4070  void *argp1 = 0 ;
4071  int res1 = 0 ;
4072  a_wrench *result = 0 ;
4073 
4074  if (SWIG_GetArgs(interp, objc, objv,"o:p2w p ",(void *)0) == TCL_ERROR) SWIG_fail;
4075  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_plucker, 0 | 0 );
4076  if (!SWIG_IsOK(res1)) {
4077  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "p2w" "', argument " "1"" of type '" "a_plucker *""'");
4078  }
4079  arg1 = reinterpret_cast< a_plucker * >(argp1);
4080  result = (a_wrench *)p2w(arg1);
4081  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_wrench,0));
4082  return TCL_OK;
4083 fail:
4084  return TCL_ERROR;
4085 }
4086 
4087 
4088 SWIGINTERN int
4089 _wrap_new_a_wrench__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4090  a_wrench *result = 0 ;
4091 
4092  if (SWIG_GetArgs(interp, objc, objv,":new_a_wrench ") == TCL_ERROR) SWIG_fail;
4093  result = (a_wrench *)new a_wrench();
4094  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_wrench,0));
4095  return TCL_OK;
4096 fail:
4097  return TCL_ERROR;
4098 }
4099 
4100 
4101 SWIGINTERN int
4102 _wrap_new_a_wrench__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4103  a_plucker *arg1 = 0 ;
4104  void *argp1 ;
4105  int res1 = 0 ;
4106  a_wrench *result = 0 ;
4107 
4108  if (SWIG_GetArgs(interp, objc, objv,"o:new_a_wrench m ",(void *)0) == TCL_ERROR) SWIG_fail;
4109  res1 = SWIG_ConvertPtr(objv[1], &argp1, SWIGTYPE_p_a_plucker, 0 );
4110  if (!SWIG_IsOK(res1)) {
4111  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_a_wrench" "', argument " "1"" of type '" "a_plucker const &""'");
4112  }
4113  if (!argp1) {
4114  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_a_wrench" "', argument " "1"" of type '" "a_plucker const &""'");
4115  }
4116  arg1 = reinterpret_cast< a_plucker * >(argp1);
4117  result = (a_wrench *)new a_wrench((a_plucker const &)*arg1);
4118  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_wrench,0));
4119  return TCL_OK;
4120 fail:
4121  return TCL_ERROR;
4122 }
4123 
4124 
4125 SWIGINTERN int
4126 _wrap_a_wrench_name(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4127  a_wrench *arg1 = (a_wrench *) 0 ;
4128  void *argp1 = 0 ;
4129  int res1 = 0 ;
4130  std::string result;
4131 
4132  if (SWIG_GetArgs(interp, objc, objv,"o:a_wrench_name self ",(void *)0) == TCL_ERROR) SWIG_fail;
4133  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_wrench, 0 | 0 );
4134  if (!SWIG_IsOK(res1)) {
4135  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_wrench_name" "', argument " "1"" of type '" "a_wrench const *""'");
4136  }
4137  arg1 = reinterpret_cast< a_wrench * >(argp1);
4138  result = ((a_wrench const *)arg1)->name();
4139  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
4140  return TCL_OK;
4141 fail:
4142  return TCL_ERROR;
4143 }
4144 
4145 
4146 SWIGINTERN int
4147 _wrap_a_wrench_help(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4148  std::string result;
4149 
4150  if (SWIG_GetArgs(interp, objc, objv,":a_wrench_help ") == TCL_ERROR) SWIG_fail;
4151  result = a_wrench::help();
4152  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
4153  return TCL_OK;
4154 fail:
4155  return TCL_ERROR;
4156 }
4157 
4158 
4159 SWIGINTERN int
4160 _wrap_a_wrench_set__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4161  a_wrench *arg1 = (a_wrench *) 0 ;
4162  a_point *arg2 = 0 ;
4163  a_point arg3 ;
4164  double arg4 ;
4165  void *argp1 = 0 ;
4166  int res1 = 0 ;
4167  void *argp2 ;
4168  int res2 = 0 ;
4169  void *argp3 ;
4170  int res3 = 0 ;
4171  double val4 ;
4172  int ecode4 = 0 ;
4173 
4174  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_wrench_set self p f m ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4175  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_wrench, 0 | 0 );
4176  if (!SWIG_IsOK(res1)) {
4177  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_wrench_set" "', argument " "1"" of type '" "a_wrench *""'");
4178  }
4179  arg1 = reinterpret_cast< a_wrench * >(argp1);
4180  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
4181  if (!SWIG_IsOK(res2)) {
4182  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_wrench_set" "', argument " "2"" of type '" "a_point const &""'");
4183  }
4184  if (!argp2) {
4185  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_wrench_set" "', argument " "2"" of type '" "a_point const &""'");
4186  }
4187  arg2 = reinterpret_cast< a_point * >(argp2);
4188  {
4189  res3 = SWIG_ConvertPtr(objv[3], &argp3, SWIGTYPE_p_a_point, 0 );
4190  if (!SWIG_IsOK(res3)) {
4191  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_wrench_set" "', argument " "3"" of type '" "a_point""'");
4192  }
4193  if (!argp3) {
4194  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_wrench_set" "', argument " "3"" of type '" "a_point""'");
4195  } else {
4196  arg3 = *(reinterpret_cast< a_point * >(argp3));
4197  }
4198  }
4199  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
4200  if (!SWIG_IsOK(ecode4)) {
4201  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_wrench_set" "', argument " "4"" of type '" "double""'");
4202  }
4203  arg4 = static_cast< double >(val4);
4204  (arg1)->set((a_point const &)*arg2,arg3,arg4);
4205 
4206  return TCL_OK;
4207 fail:
4208  return TCL_ERROR;
4209 }
4210 
4211 
4212 SWIGINTERN int
4213 _wrap_a_wrench_set__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4214  a_wrench *arg1 = (a_wrench *) 0 ;
4215  a_point *arg2 = 0 ;
4216  a_point arg3 ;
4217  void *argp1 = 0 ;
4218  int res1 = 0 ;
4219  void *argp2 ;
4220  int res2 = 0 ;
4221  void *argp3 ;
4222  int res3 = 0 ;
4223 
4224  if (SWIG_GetArgs(interp, objc, objv,"ooo:a_wrench_set self p f ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4225  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_wrench, 0 | 0 );
4226  if (!SWIG_IsOK(res1)) {
4227  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_wrench_set" "', argument " "1"" of type '" "a_wrench *""'");
4228  }
4229  arg1 = reinterpret_cast< a_wrench * >(argp1);
4230  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
4231  if (!SWIG_IsOK(res2)) {
4232  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_wrench_set" "', argument " "2"" of type '" "a_point const &""'");
4233  }
4234  if (!argp2) {
4235  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_wrench_set" "', argument " "2"" of type '" "a_point const &""'");
4236  }
4237  arg2 = reinterpret_cast< a_point * >(argp2);
4238  {
4239  res3 = SWIG_ConvertPtr(objv[3], &argp3, SWIGTYPE_p_a_point, 0 );
4240  if (!SWIG_IsOK(res3)) {
4241  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_wrench_set" "', argument " "3"" of type '" "a_point""'");
4242  }
4243  if (!argp3) {
4244  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_wrench_set" "', argument " "3"" of type '" "a_point""'");
4245  } else {
4246  arg3 = *(reinterpret_cast< a_point * >(argp3));
4247  }
4248  }
4249  (arg1)->set((a_point const &)*arg2,arg3);
4250 
4251  return TCL_OK;
4252 fail:
4253  return TCL_ERROR;
4254 }
4255 
4256 
4257 SWIGINTERN int
4258 _wrap_a_wrench_set__SWIG_2(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4259  a_wrench *arg1 = (a_wrench *) 0 ;
4260  double arg2 ;
4261  double arg3 ;
4262  double arg4 ;
4263  double arg5 ;
4264  double arg6 ;
4265  double arg7 ;
4266  double arg8 ;
4267  void *argp1 = 0 ;
4268  int res1 = 0 ;
4269  double val2 ;
4270  int ecode2 = 0 ;
4271  double val3 ;
4272  int ecode3 = 0 ;
4273  double val4 ;
4274  int ecode4 = 0 ;
4275  double val5 ;
4276  int ecode5 = 0 ;
4277  double val6 ;
4278  int ecode6 = 0 ;
4279  double val7 ;
4280  int ecode7 = 0 ;
4281  double val8 ;
4282  int ecode8 = 0 ;
4283 
4284  if (SWIG_GetArgs(interp, objc, objv,"oooooooo:a_wrench_set self x y z fx fy fz m ",(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4285  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_wrench, 0 | 0 );
4286  if (!SWIG_IsOK(res1)) {
4287  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_wrench_set" "', argument " "1"" of type '" "a_wrench *""'");
4288  }
4289  arg1 = reinterpret_cast< a_wrench * >(argp1);
4290  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
4291  if (!SWIG_IsOK(ecode2)) {
4292  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_wrench_set" "', argument " "2"" of type '" "double""'");
4293  }
4294  arg2 = static_cast< double >(val2);
4295  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
4296  if (!SWIG_IsOK(ecode3)) {
4297  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_wrench_set" "', argument " "3"" of type '" "double""'");
4298  }
4299  arg3 = static_cast< double >(val3);
4300  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
4301  if (!SWIG_IsOK(ecode4)) {
4302  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_wrench_set" "', argument " "4"" of type '" "double""'");
4303  }
4304  arg4 = static_cast< double >(val4);
4305  ecode5 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[5], &val5);
4306  if (!SWIG_IsOK(ecode5)) {
4307  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "a_wrench_set" "', argument " "5"" of type '" "double""'");
4308  }
4309  arg5 = static_cast< double >(val5);
4310  ecode6 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[6], &val6);
4311  if (!SWIG_IsOK(ecode6)) {
4312  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "a_wrench_set" "', argument " "6"" of type '" "double""'");
4313  }
4314  arg6 = static_cast< double >(val6);
4315  ecode7 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[7], &val7);
4316  if (!SWIG_IsOK(ecode7)) {
4317  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "a_wrench_set" "', argument " "7"" of type '" "double""'");
4318  }
4319  arg7 = static_cast< double >(val7);
4320  ecode8 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[8], &val8);
4321  if (!SWIG_IsOK(ecode8)) {
4322  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "a_wrench_set" "', argument " "8"" of type '" "double""'");
4323  }
4324  arg8 = static_cast< double >(val8);
4325  (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
4326 
4327  return TCL_OK;
4328 fail:
4329  return TCL_ERROR;
4330 }
4331 
4332 
4333 SWIGINTERN int
4334 _wrap_a_wrench_set__SWIG_3(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4335  a_wrench *arg1 = (a_wrench *) 0 ;
4336  double arg2 ;
4337  double arg3 ;
4338  double arg4 ;
4339  double arg5 ;
4340  double arg6 ;
4341  double arg7 ;
4342  void *argp1 = 0 ;
4343  int res1 = 0 ;
4344  double val2 ;
4345  int ecode2 = 0 ;
4346  double val3 ;
4347  int ecode3 = 0 ;
4348  double val4 ;
4349  int ecode4 = 0 ;
4350  double val5 ;
4351  int ecode5 = 0 ;
4352  double val6 ;
4353  int ecode6 = 0 ;
4354  double val7 ;
4355  int ecode7 = 0 ;
4356 
4357  if (SWIG_GetArgs(interp, objc, objv,"ooooooo:a_wrench_set self x y z fx fy fz ",(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4358  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_wrench, 0 | 0 );
4359  if (!SWIG_IsOK(res1)) {
4360  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_wrench_set" "', argument " "1"" of type '" "a_wrench *""'");
4361  }
4362  arg1 = reinterpret_cast< a_wrench * >(argp1);
4363  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
4364  if (!SWIG_IsOK(ecode2)) {
4365  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_wrench_set" "', argument " "2"" of type '" "double""'");
4366  }
4367  arg2 = static_cast< double >(val2);
4368  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
4369  if (!SWIG_IsOK(ecode3)) {
4370  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_wrench_set" "', argument " "3"" of type '" "double""'");
4371  }
4372  arg3 = static_cast< double >(val3);
4373  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
4374  if (!SWIG_IsOK(ecode4)) {
4375  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_wrench_set" "', argument " "4"" of type '" "double""'");
4376  }
4377  arg4 = static_cast< double >(val4);
4378  ecode5 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[5], &val5);
4379  if (!SWIG_IsOK(ecode5)) {
4380  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "a_wrench_set" "', argument " "5"" of type '" "double""'");
4381  }
4382  arg5 = static_cast< double >(val5);
4383  ecode6 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[6], &val6);
4384  if (!SWIG_IsOK(ecode6)) {
4385  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "a_wrench_set" "', argument " "6"" of type '" "double""'");
4386  }
4387  arg6 = static_cast< double >(val6);
4388  ecode7 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[7], &val7);
4389  if (!SWIG_IsOK(ecode7)) {
4390  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "a_wrench_set" "', argument " "7"" of type '" "double""'");
4391  }
4392  arg7 = static_cast< double >(val7);
4393  (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7);
4394 
4395  return TCL_OK;
4396 fail:
4397  return TCL_ERROR;
4398 }
4399 
4400 
4401 SWIGINTERN int
4402 _wrap_a_wrench_set(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4403  Tcl_Obj *CONST *argv = objv+1;
4404  int argc = objc-1;
4405  if (argc == 3) {
4406  int _v;
4407  void *vptr = 0;
4408  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_wrench, 0);
4409  _v = SWIG_CheckState(res);
4410  if (_v) {
4411  void *vptr = 0;
4412  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
4413  _v = SWIG_CheckState(res);
4414  if (_v) {
4415  void *vptr = 0;
4416  int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
4417  _v = SWIG_CheckState(res);
4418  if (_v) {
4419  return _wrap_a_wrench_set__SWIG_1(clientData, interp, objc, argv - 1);
4420  }
4421  }
4422  }
4423  }
4424  if (argc == 4) {
4425  int _v;
4426  void *vptr = 0;
4427  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_wrench, 0);
4428  _v = SWIG_CheckState(res);
4429  if (_v) {
4430  void *vptr = 0;
4431  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
4432  _v = SWIG_CheckState(res);
4433  if (_v) {
4434  void *vptr = 0;
4435  int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
4436  _v = SWIG_CheckState(res);
4437  if (_v) {
4438  {
4439  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[3], NULL);
4440  _v = SWIG_CheckState(res);
4441  }
4442  if (_v) {
4443  return _wrap_a_wrench_set__SWIG_0(clientData, interp, objc, argv - 1);
4444  }
4445  }
4446  }
4447  }
4448  }
4449  if (argc == 7) {
4450  int _v;
4451  void *vptr = 0;
4452  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_wrench, 0);
4453  _v = SWIG_CheckState(res);
4454  if (_v) {
4455  {
4456  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
4457  _v = SWIG_CheckState(res);
4458  }
4459  if (_v) {
4460  {
4461  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
4462  _v = SWIG_CheckState(res);
4463  }
4464  if (_v) {
4465  {
4466  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[3], NULL);
4467  _v = SWIG_CheckState(res);
4468  }
4469  if (_v) {
4470  {
4471  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[4], NULL);
4472  _v = SWIG_CheckState(res);
4473  }
4474  if (_v) {
4475  {
4476  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[5], NULL);
4477  _v = SWIG_CheckState(res);
4478  }
4479  if (_v) {
4480  {
4481  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[6], NULL);
4482  _v = SWIG_CheckState(res);
4483  }
4484  if (_v) {
4485  return _wrap_a_wrench_set__SWIG_3(clientData, interp, objc, argv - 1);
4486  }
4487  }
4488  }
4489  }
4490  }
4491  }
4492  }
4493  }
4494  if (argc == 8) {
4495  int _v;
4496  void *vptr = 0;
4497  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_wrench, 0);
4498  _v = SWIG_CheckState(res);
4499  if (_v) {
4500  {
4501  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
4502  _v = SWIG_CheckState(res);
4503  }
4504  if (_v) {
4505  {
4506  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
4507  _v = SWIG_CheckState(res);
4508  }
4509  if (_v) {
4510  {
4511  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[3], NULL);
4512  _v = SWIG_CheckState(res);
4513  }
4514  if (_v) {
4515  {
4516  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[4], NULL);
4517  _v = SWIG_CheckState(res);
4518  }
4519  if (_v) {
4520  {
4521  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[5], NULL);
4522  _v = SWIG_CheckState(res);
4523  }
4524  if (_v) {
4525  {
4526  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[6], NULL);
4527  _v = SWIG_CheckState(res);
4528  }
4529  if (_v) {
4530  {
4531  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[7], NULL);
4532  _v = SWIG_CheckState(res);
4533  }
4534  if (_v) {
4535  return _wrap_a_wrench_set__SWIG_2(clientData, interp, objc, argv - 1);
4536  }
4537  }
4538  }
4539  }
4540  }
4541  }
4542  }
4543  }
4544  }
4545 
4546  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_wrench_set'.\n"
4547  " Possible C/C++ prototypes are:\n"
4548  " a_wrench::set(a_point const &,a_point,double)\n"
4549  " a_wrench::set(a_point const &,a_point)\n"
4550  " a_wrench::set(double,double,double,double,double,double,double)\n"
4551  " a_wrench::set(double,double,double,double,double,double)\n", TCL_STATIC);
4552  return TCL_ERROR;
4553 }
4554 
4555 
4556 SWIGINTERN int
4557 _wrap_new_a_wrench__SWIG_2(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4558  a_point *arg1 = 0 ;
4559  a_point arg2 ;
4560  double arg3 ;
4561  void *argp1 ;
4562  int res1 = 0 ;
4563  void *argp2 ;
4564  int res2 = 0 ;
4565  double val3 ;
4566  int ecode3 = 0 ;
4567  a_wrench *result = 0 ;
4568 
4569  if (SWIG_GetArgs(interp, objc, objv,"ooo:new_a_wrench p f m ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4570  res1 = SWIG_ConvertPtr(objv[1], &argp1, SWIGTYPE_p_a_point, 0 );
4571  if (!SWIG_IsOK(res1)) {
4572  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_a_wrench" "', argument " "1"" of type '" "a_point const &""'");
4573  }
4574  if (!argp1) {
4575  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_a_wrench" "', argument " "1"" of type '" "a_point const &""'");
4576  }
4577  arg1 = reinterpret_cast< a_point * >(argp1);
4578  {
4579  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
4580  if (!SWIG_IsOK(res2)) {
4581  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_a_wrench" "', argument " "2"" of type '" "a_point""'");
4582  }
4583  if (!argp2) {
4584  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_a_wrench" "', argument " "2"" of type '" "a_point""'");
4585  } else {
4586  arg2 = *(reinterpret_cast< a_point * >(argp2));
4587  }
4588  }
4589  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
4590  if (!SWIG_IsOK(ecode3)) {
4591  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_a_wrench" "', argument " "3"" of type '" "double""'");
4592  }
4593  arg3 = static_cast< double >(val3);
4594  result = (a_wrench *)new a_wrench((a_point const &)*arg1,arg2,arg3);
4595  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_wrench,0));
4596  return TCL_OK;
4597 fail:
4598  return TCL_ERROR;
4599 }
4600 
4601 
4602 SWIGINTERN int
4603 _wrap_new_a_wrench__SWIG_3(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4604  a_point *arg1 = 0 ;
4605  a_point arg2 ;
4606  void *argp1 ;
4607  int res1 = 0 ;
4608  void *argp2 ;
4609  int res2 = 0 ;
4610  a_wrench *result = 0 ;
4611 
4612  if (SWIG_GetArgs(interp, objc, objv,"oo:new_a_wrench p f ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4613  res1 = SWIG_ConvertPtr(objv[1], &argp1, SWIGTYPE_p_a_point, 0 );
4614  if (!SWIG_IsOK(res1)) {
4615  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_a_wrench" "', argument " "1"" of type '" "a_point const &""'");
4616  }
4617  if (!argp1) {
4618  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_a_wrench" "', argument " "1"" of type '" "a_point const &""'");
4619  }
4620  arg1 = reinterpret_cast< a_point * >(argp1);
4621  {
4622  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
4623  if (!SWIG_IsOK(res2)) {
4624  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_a_wrench" "', argument " "2"" of type '" "a_point""'");
4625  }
4626  if (!argp2) {
4627  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_a_wrench" "', argument " "2"" of type '" "a_point""'");
4628  } else {
4629  arg2 = *(reinterpret_cast< a_point * >(argp2));
4630  }
4631  }
4632  result = (a_wrench *)new a_wrench((a_point const &)*arg1,arg2);
4633  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_wrench,0));
4634  return TCL_OK;
4635 fail:
4636  return TCL_ERROR;
4637 }
4638 
4639 
4640 SWIGINTERN int
4641 _wrap_new_a_wrench__SWIG_4(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4642  double arg1 ;
4643  double arg2 ;
4644  double arg3 ;
4645  double arg4 ;
4646  double arg5 ;
4647  double arg6 ;
4648  double arg7 ;
4649  double val1 ;
4650  int ecode1 = 0 ;
4651  double val2 ;
4652  int ecode2 = 0 ;
4653  double val3 ;
4654  int ecode3 = 0 ;
4655  double val4 ;
4656  int ecode4 = 0 ;
4657  double val5 ;
4658  int ecode5 = 0 ;
4659  double val6 ;
4660  int ecode6 = 0 ;
4661  double val7 ;
4662  int ecode7 = 0 ;
4663  a_wrench *result = 0 ;
4664 
4665  if (SWIG_GetArgs(interp, objc, objv,"ooooooo:new_a_wrench x y z fx fy fz m ",(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4666  ecode1 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[1], &val1);
4667  if (!SWIG_IsOK(ecode1)) {
4668  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_a_wrench" "', argument " "1"" of type '" "double""'");
4669  }
4670  arg1 = static_cast< double >(val1);
4671  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
4672  if (!SWIG_IsOK(ecode2)) {
4673  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_a_wrench" "', argument " "2"" of type '" "double""'");
4674  }
4675  arg2 = static_cast< double >(val2);
4676  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
4677  if (!SWIG_IsOK(ecode3)) {
4678  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_a_wrench" "', argument " "3"" of type '" "double""'");
4679  }
4680  arg3 = static_cast< double >(val3);
4681  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
4682  if (!SWIG_IsOK(ecode4)) {
4683  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_a_wrench" "', argument " "4"" of type '" "double""'");
4684  }
4685  arg4 = static_cast< double >(val4);
4686  ecode5 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[5], &val5);
4687  if (!SWIG_IsOK(ecode5)) {
4688  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_a_wrench" "', argument " "5"" of type '" "double""'");
4689  }
4690  arg5 = static_cast< double >(val5);
4691  ecode6 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[6], &val6);
4692  if (!SWIG_IsOK(ecode6)) {
4693  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_a_wrench" "', argument " "6"" of type '" "double""'");
4694  }
4695  arg6 = static_cast< double >(val6);
4696  ecode7 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[7], &val7);
4697  if (!SWIG_IsOK(ecode7)) {
4698  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_a_wrench" "', argument " "7"" of type '" "double""'");
4699  }
4700  arg7 = static_cast< double >(val7);
4701  result = (a_wrench *)new a_wrench(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
4702  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_wrench,0));
4703  return TCL_OK;
4704 fail:
4705  return TCL_ERROR;
4706 }
4707 
4708 
4709 SWIGINTERN int
4710 _wrap_new_a_wrench__SWIG_5(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4711  double arg1 ;
4712  double arg2 ;
4713  double arg3 ;
4714  double arg4 ;
4715  double arg5 ;
4716  double arg6 ;
4717  double val1 ;
4718  int ecode1 = 0 ;
4719  double val2 ;
4720  int ecode2 = 0 ;
4721  double val3 ;
4722  int ecode3 = 0 ;
4723  double val4 ;
4724  int ecode4 = 0 ;
4725  double val5 ;
4726  int ecode5 = 0 ;
4727  double val6 ;
4728  int ecode6 = 0 ;
4729  a_wrench *result = 0 ;
4730 
4731  if (SWIG_GetArgs(interp, objc, objv,"oooooo:new_a_wrench x y z fx fy fz ",(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4732  ecode1 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[1], &val1);
4733  if (!SWIG_IsOK(ecode1)) {
4734  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_a_wrench" "', argument " "1"" of type '" "double""'");
4735  }
4736  arg1 = static_cast< double >(val1);
4737  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
4738  if (!SWIG_IsOK(ecode2)) {
4739  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_a_wrench" "', argument " "2"" of type '" "double""'");
4740  }
4741  arg2 = static_cast< double >(val2);
4742  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
4743  if (!SWIG_IsOK(ecode3)) {
4744  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_a_wrench" "', argument " "3"" of type '" "double""'");
4745  }
4746  arg3 = static_cast< double >(val3);
4747  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
4748  if (!SWIG_IsOK(ecode4)) {
4749  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_a_wrench" "', argument " "4"" of type '" "double""'");
4750  }
4751  arg4 = static_cast< double >(val4);
4752  ecode5 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[5], &val5);
4753  if (!SWIG_IsOK(ecode5)) {
4754  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_a_wrench" "', argument " "5"" of type '" "double""'");
4755  }
4756  arg5 = static_cast< double >(val5);
4757  ecode6 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[6], &val6);
4758  if (!SWIG_IsOK(ecode6)) {
4759  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_a_wrench" "', argument " "6"" of type '" "double""'");
4760  }
4761  arg6 = static_cast< double >(val6);
4762  result = (a_wrench *)new a_wrench(arg1,arg2,arg3,arg4,arg5,arg6);
4763  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_wrench,0));
4764  return TCL_OK;
4765 fail:
4766  return TCL_ERROR;
4767 }
4768 
4769 
4770 SWIGINTERN int
4771 _wrap_new_a_wrench__SWIG_6(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4772  a_point *arg1 = 0 ;
4773  a_point *arg2 = 0 ;
4774  a_point *arg3 = 0 ;
4775  a_wrench *arg4 = 0 ;
4776  a_wrench *arg5 = 0 ;
4777  void *argp1 ;
4778  int res1 = 0 ;
4779  void *argp2 ;
4780  int res2 = 0 ;
4781  void *argp3 ;
4782  int res3 = 0 ;
4783  void *argp4 ;
4784  int res4 = 0 ;
4785  void *argp5 ;
4786  int res5 = 0 ;
4787  a_wrench *result = 0 ;
4788 
4789  if (SWIG_GetArgs(interp, objc, objv,"ooooo:new_a_wrench p1 p2 p3 f1 f2 ",(void *)0,(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4790  res1 = SWIG_ConvertPtr(objv[1], &argp1, SWIGTYPE_p_a_point, 0 );
4791  if (!SWIG_IsOK(res1)) {
4792  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_a_wrench" "', argument " "1"" of type '" "a_point const &""'");
4793  }
4794  if (!argp1) {
4795  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_a_wrench" "', argument " "1"" of type '" "a_point const &""'");
4796  }
4797  arg1 = reinterpret_cast< a_point * >(argp1);
4798  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
4799  if (!SWIG_IsOK(res2)) {
4800  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_a_wrench" "', argument " "2"" of type '" "a_point const &""'");
4801  }
4802  if (!argp2) {
4803  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_a_wrench" "', argument " "2"" of type '" "a_point const &""'");
4804  }
4805  arg2 = reinterpret_cast< a_point * >(argp2);
4806  res3 = SWIG_ConvertPtr(objv[3], &argp3, SWIGTYPE_p_a_point, 0 );
4807  if (!SWIG_IsOK(res3)) {
4808  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_a_wrench" "', argument " "3"" of type '" "a_point const &""'");
4809  }
4810  if (!argp3) {
4811  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_a_wrench" "', argument " "3"" of type '" "a_point const &""'");
4812  }
4813  arg3 = reinterpret_cast< a_point * >(argp3);
4814  res4 = SWIG_ConvertPtr(objv[4], &argp4, SWIGTYPE_p_a_wrench, 0 );
4815  if (!SWIG_IsOK(res4)) {
4816  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_a_wrench" "', argument " "4"" of type '" "a_wrench const &""'");
4817  }
4818  if (!argp4) {
4819  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_a_wrench" "', argument " "4"" of type '" "a_wrench const &""'");
4820  }
4821  arg4 = reinterpret_cast< a_wrench * >(argp4);
4822  res5 = SWIG_ConvertPtr(objv[5], &argp5, SWIGTYPE_p_a_wrench, 0 );
4823  if (!SWIG_IsOK(res5)) {
4824  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_a_wrench" "', argument " "5"" of type '" "a_wrench const &""'");
4825  }
4826  if (!argp5) {
4827  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_a_wrench" "', argument " "5"" of type '" "a_wrench const &""'");
4828  }
4829  arg5 = reinterpret_cast< a_wrench * >(argp5);
4830  result = (a_wrench *)new a_wrench((a_point const &)*arg1,(a_point const &)*arg2,(a_point const &)*arg3,(a_wrench const &)*arg4,(a_wrench const &)*arg5);
4831  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_wrench,0));
4832  return TCL_OK;
4833 fail:
4834  return TCL_ERROR;
4835 }
4836 
4837 
4838 SWIGINTERN int
4839 _wrap_new_a_wrench(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4840  Tcl_Obj *CONST *argv = objv+1;
4841  int argc = objc-1;
4842  if (argc == 0) {
4843  return _wrap_new_a_wrench__SWIG_0(clientData, interp, objc, argv - 1);
4844  }
4845  if (argc == 1) {
4846  int _v;
4847  void *vptr = 0;
4848  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_plucker, SWIG_POINTER_NO_NULL);
4849  _v = SWIG_CheckState(res);
4850  if (_v) {
4851  return _wrap_new_a_wrench__SWIG_1(clientData, interp, objc, argv - 1);
4852  }
4853  }
4854  if (argc == 2) {
4855  int _v;
4856  void *vptr = 0;
4857  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
4858  _v = SWIG_CheckState(res);
4859  if (_v) {
4860  void *vptr = 0;
4861  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
4862  _v = SWIG_CheckState(res);
4863  if (_v) {
4864  return _wrap_new_a_wrench__SWIG_3(clientData, interp, objc, argv - 1);
4865  }
4866  }
4867  }
4868  if (argc == 3) {
4869  int _v;
4870  void *vptr = 0;
4871  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
4872  _v = SWIG_CheckState(res);
4873  if (_v) {
4874  void *vptr = 0;
4875  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
4876  _v = SWIG_CheckState(res);
4877  if (_v) {
4878  {
4879  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
4880  _v = SWIG_CheckState(res);
4881  }
4882  if (_v) {
4883  return _wrap_new_a_wrench__SWIG_2(clientData, interp, objc, argv - 1);
4884  }
4885  }
4886  }
4887  }
4888  if (argc == 5) {
4889  int _v;
4890  void *vptr = 0;
4891  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
4892  _v = SWIG_CheckState(res);
4893  if (_v) {
4894  void *vptr = 0;
4895  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
4896  _v = SWIG_CheckState(res);
4897  if (_v) {
4898  void *vptr = 0;
4899  int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
4900  _v = SWIG_CheckState(res);
4901  if (_v) {
4902  void *vptr = 0;
4903  int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_a_wrench, SWIG_POINTER_NO_NULL);
4904  _v = SWIG_CheckState(res);
4905  if (_v) {
4906  void *vptr = 0;
4907  int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_a_wrench, SWIG_POINTER_NO_NULL);
4908  _v = SWIG_CheckState(res);
4909  if (_v) {
4910  return _wrap_new_a_wrench__SWIG_6(clientData, interp, objc, argv - 1);
4911  }
4912  }
4913  }
4914  }
4915  }
4916  }
4917  if (argc == 6) {
4918  int _v;
4919  {
4920  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[0], NULL);
4921  _v = SWIG_CheckState(res);
4922  }
4923  if (_v) {
4924  {
4925  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
4926  _v = SWIG_CheckState(res);
4927  }
4928  if (_v) {
4929  {
4930  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
4931  _v = SWIG_CheckState(res);
4932  }
4933  if (_v) {
4934  {
4935  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[3], NULL);
4936  _v = SWIG_CheckState(res);
4937  }
4938  if (_v) {
4939  {
4940  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[4], NULL);
4941  _v = SWIG_CheckState(res);
4942  }
4943  if (_v) {
4944  {
4945  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[5], NULL);
4946  _v = SWIG_CheckState(res);
4947  }
4948  if (_v) {
4949  return _wrap_new_a_wrench__SWIG_5(clientData, interp, objc, argv - 1);
4950  }
4951  }
4952  }
4953  }
4954  }
4955  }
4956  }
4957  if (argc == 7) {
4958  int _v;
4959  {
4960  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[0], NULL);
4961  _v = SWIG_CheckState(res);
4962  }
4963  if (_v) {
4964  {
4965  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
4966  _v = SWIG_CheckState(res);
4967  }
4968  if (_v) {
4969  {
4970  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
4971  _v = SWIG_CheckState(res);
4972  }
4973  if (_v) {
4974  {
4975  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[3], NULL);
4976  _v = SWIG_CheckState(res);
4977  }
4978  if (_v) {
4979  {
4980  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[4], NULL);
4981  _v = SWIG_CheckState(res);
4982  }
4983  if (_v) {
4984  {
4985  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[5], NULL);
4986  _v = SWIG_CheckState(res);
4987  }
4988  if (_v) {
4989  {
4990  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[6], NULL);
4991  _v = SWIG_CheckState(res);
4992  }
4993  if (_v) {
4994  return _wrap_new_a_wrench__SWIG_4(clientData, interp, objc, argv - 1);
4995  }
4996  }
4997  }
4998  }
4999  }
5000  }
5001  }
5002  }
5003 
5004  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'new_a_wrench'.\n"
5005  " Possible C/C++ prototypes are:\n"
5006  " a_wrench::a_wrench()\n"
5007  " a_wrench::a_wrench(a_plucker const &)\n"
5008  " a_wrench::a_wrench(a_point const &,a_point,double)\n"
5009  " a_wrench::a_wrench(a_point const &,a_point)\n"
5010  " a_wrench::a_wrench(double,double,double,double,double,double,double)\n"
5011  " a_wrench::a_wrench(double,double,double,double,double,double)\n"
5012  " a_wrench::a_wrench(a_point const &,a_point const &,a_point const &,a_wrench const &,a_wrench const &)\n", TCL_STATIC);
5013  return TCL_ERROR;
5014 }
5015 
5016 
5017 SWIGINTERN int
5018 _wrap_delete_a_wrench(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
5019  a_wrench *arg1 = (a_wrench *) 0 ;
5020  void *argp1 = 0 ;
5021  int res1 = 0 ;
5022 
5023  if (SWIG_GetArgs(interp, objc, objv,"o:delete_a_wrench self ",(void *)0) == TCL_ERROR) SWIG_fail;
5024  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_wrench, SWIG_POINTER_DISOWN | 0 );
5025  if (!SWIG_IsOK(res1)) {
5026  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_a_wrench" "', argument " "1"" of type '" "a_wrench *""'");
5027  }
5028  arg1 = reinterpret_cast< a_wrench * >(argp1);
5029  delete arg1;
5030 
5031  return TCL_OK;
5032 fail:
5033  return TCL_ERROR;
5034 }
5035 
5036 
5037 SWIGINTERN int
5038 _wrap_a_wrench_F(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
5039  a_wrench *arg1 = (a_wrench *) 0 ;
5040  void *argp1 = 0 ;
5041  int res1 = 0 ;
5042  a_point result;
5043 
5044  if (SWIG_GetArgs(interp, objc, objv,"o:a_wrench_F self ",(void *)0) == TCL_ERROR) SWIG_fail;
5045  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_wrench, 0 | 0 );
5046  if (!SWIG_IsOK(res1)) {
5047  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_wrench_F" "', argument " "1"" of type '" "a_wrench const *""'");
5048  }
5049  arg1 = reinterpret_cast< a_wrench * >(argp1);
5050  result = ((a_wrench const *)arg1)->F();
5051  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_point(static_cast< const a_point& >(result))), SWIGTYPE_p_a_point, SWIG_POINTER_OWN | 0 ));
5052  return TCL_OK;
5053 fail:
5054  return TCL_ERROR;
5055 }
5056 
5057 
5058 SWIGINTERN int
5059 _wrap_a_wrench_fx(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
5060  a_wrench *arg1 = (a_wrench *) 0 ;
5061  void *argp1 = 0 ;
5062  int res1 = 0 ;
5063  double result;
5064 
5065  if (SWIG_GetArgs(interp, objc, objv,"o:a_wrench_fx self ",(void *)0) == TCL_ERROR) SWIG_fail;
5066  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_wrench, 0 | 0 );
5067  if (!SWIG_IsOK(res1)) {
5068  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_wrench_fx" "', argument " "1"" of type '" "a_wrench const *""'");
5069  }
5070  arg1 = reinterpret_cast< a_wrench * >(argp1);
5071  result = (double)((a_wrench const *)arg1)->fx();
5072  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
5073  return TCL_OK;
5074 fail:
5075  return TCL_ERROR;
5076 }
5077 
5078 
5079 SWIGINTERN int
5080 _wrap_a_wrench_fy(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
5081  a_wrench *arg1 = (a_wrench *) 0 ;
5082  void *argp1 = 0 ;
5083  int res1 = 0 ;
5084  double result;
5085 
5086  if (SWIG_GetArgs(interp, objc, objv,"o:a_wrench_fy self ",(void *)0) == TCL_ERROR) SWIG_fail;
5087  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_wrench, 0 | 0 );
5088  if (!SWIG_IsOK(res1)) {
5089  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_wrench_fy" "', argument " "1"" of type '" "a_wrench const *""'");
5090  }
5091  arg1 = reinterpret_cast< a_wrench * >(argp1);
5092  result = (double)((a_wrench const *)arg1)->fy();
5093  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
5094  return TCL_OK;
5095 fail:
5096  return TCL_ERROR;
5097 }
5098 
5099 
5100 SWIGINTERN int
5101 _wrap_a_wrench_fz(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
5102  a_wrench *arg1 = (a_wrench *) 0 ;
5103  void *argp1 = 0 ;
5104  int res1 = 0 ;
5105  double result;
5106 
5107  if (SWIG_GetArgs(interp, objc, objv,"o:a_wrench_fz self ",(void *)0) == TCL_ERROR) SWIG_fail;
5108  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_wrench, 0 | 0 );
5109  if (!SWIG_IsOK(res1)) {
5110  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_wrench_fz" "', argument " "1"" of type '" "a_wrench const *""'");
5111  }
5112  arg1 = reinterpret_cast< a_wrench * >(argp1);
5113  result = (double)((a_wrench const *)arg1)->fz();
5114  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
5115  return TCL_OK;
5116 fail:
5117  return TCL_ERROR;
5118 }
5119 
5120 
5121 SWIGINTERN int
5122 _wrap_a_wrench_M(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
5123  a_wrench *arg1 = (a_wrench *) 0 ;
5124  void *argp1 = 0 ;
5125  int res1 = 0 ;
5126  a_point result;
5127 
5128  if (SWIG_GetArgs(interp, objc, objv,"o:a_wrench_M self ",(void *)0) == TCL_ERROR) SWIG_fail;
5129  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_wrench, 0 | 0 );
5130  if (!SWIG_IsOK(res1)) {
5131  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_wrench_M" "', argument " "1"" of type '" "a_wrench const *""'");
5132  }
5133  arg1 = reinterpret_cast< a_wrench * >(argp1);
5134  result = ((a_wrench const *)arg1)->M();
5135  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new a_point(static_cast< const a_point& >(result))), SWIGTYPE_p_a_point, SWIG_POINTER_OWN | 0 ));
5136  return TCL_OK;
5137 fail:
5138  return TCL_ERROR;
5139 }
5140 
5141 
5142 SWIGINTERN int
5143 _wrap_a_wrench_mx(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
5144  a_wrench *arg1 = (a_wrench *) 0 ;
5145  void *argp1 = 0 ;
5146  int res1 = 0 ;
5147  double result;
5148 
5149  if (SWIG_GetArgs(interp, objc, objv,"o:a_wrench_mx self ",(void *)0) == TCL_ERROR) SWIG_fail;
5150  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_wrench, 0 | 0 );
5151  if (!SWIG_IsOK(res1)) {
5152  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_wrench_mx" "', argument " "1"" of type '" "a_wrench const *""'");
5153  }
5154  arg1 = reinterpret_cast< a_wrench * >(argp1);
5155  result = (double)((a_wrench const *)arg1)->mx();
5156  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
5157  return TCL_OK;
5158 fail:
5159  return TCL_ERROR;
5160 }
5161 
5162 
5163 SWIGINTERN int
5164 _wrap_a_wrench_my(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
5165  a_wrench *arg1 = (a_wrench *) 0 ;
5166  void *argp1 = 0 ;
5167  int res1 = 0 ;
5168  double result;
5169 
5170  if (SWIG_GetArgs(interp, objc, objv,"o:a_wrench_my self ",(void *)0) == TCL_ERROR) SWIG_fail;
5171  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_wrench, 0 | 0 );
5172  if (!SWIG_IsOK(res1)) {
5173  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_wrench_my" "', argument " "1"" of type '" "a_wrench const *""'");
5174  }
5175  arg1 = reinterpret_cast< a_wrench * >(argp1);
5176  result = (double)((a_wrench const *)arg1)->my();
5177  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
5178  return TCL_OK;
5179 fail:
5180  return TCL_ERROR;
5181 }
5182 
5183 
5184 SWIGINTERN int
5185 _wrap_a_wrench_mz(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
5186  a_wrench *arg1 = (a_wrench *) 0 ;
5187  void *argp1 = 0 ;
5188  int res1 = 0 ;
5189  double result;
5190 
5191  if (SWIG_GetArgs(interp, objc, objv,"o:a_wrench_mz self ",(void *)0) == TCL_ERROR) SWIG_fail;
5192  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_wrench, 0 | 0 );
5193  if (!SWIG_IsOK(res1)) {
5194  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_wrench_mz" "', argument " "1"" of type '" "a_wrench const *""'");
5195  }
5196  arg1 = reinterpret_cast< a_wrench * >(argp1);
5197  result = (double)((a_wrench const *)arg1)->mz();
5198  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
5199  return TCL_OK;
5200 fail:
5201  return TCL_ERROR;
5202 }
5203 
5204 
5205 SWIGINTERN int
5206 _wrap_a_wrench_f(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
5207  a_wrench *arg1 = (a_wrench *) 0 ;
5208  void *argp1 = 0 ;
5209  int res1 = 0 ;
5210  double result;
5211 
5212  if (SWIG_GetArgs(interp, objc, objv,"o:a_wrench_f self ",(void *)0) == TCL_ERROR) SWIG_fail;
5213  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_wrench, 0 | 0 );
5214  if (!SWIG_IsOK(res1)) {
5215  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_wrench_f" "', argument " "1"" of type '" "a_wrench const *""'");
5216  }
5217  arg1 = reinterpret_cast< a_wrench * >(argp1);
5218  result = (double)((a_wrench const *)arg1)->f();
5219  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
5220  return TCL_OK;
5221 fail:
5222  return TCL_ERROR;
5223 }
5224 
5225 
5226 SWIGINTERN int
5227 _wrap_a_wrench_m(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
5228  a_wrench *arg1 = (a_wrench *) 0 ;
5229  void *argp1 = 0 ;
5230  int res1 = 0 ;
5231  double result;
5232 
5233  if (SWIG_GetArgs(interp, objc, objv,"o:a_wrench_m self ",(void *)0) == TCL_ERROR) SWIG_fail;
5234  res1 =