Graphviz 13.0.0~dev.20250204.0809
Loading...
Searching...
No Matches
gv_perl.cpp
Go to the documentation of this file.
1/* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (https://www.swig.org).
3 * Version 4.2.0
4 *
5 * Do not make changes to this file unless you know what you are doing - modify
6 * the SWIG interface file instead.
7 * ----------------------------------------------------------------------------- */
8
9
10#define SWIG_VERSION 0x040200
11#define SWIGPERL
12#define SWIG_CASTRANK_MODE
13
14/* -----------------------------------------------------------------------------
15 * This section contains generic SWIG labels for method/variable
16 * declarations/attributes, and other compiler dependent labels.
17 * ----------------------------------------------------------------------------- */
18
19/* template workaround for compilers that cannot correctly implement the C++ standard */
20#ifndef SWIGTEMPLATEDISAMBIGUATOR
21# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
22# define SWIGTEMPLATEDISAMBIGUATOR template
23# elif defined(__HP_aCC)
24/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
25/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
26# define SWIGTEMPLATEDISAMBIGUATOR template
27# else
28# define SWIGTEMPLATEDISAMBIGUATOR
29# endif
30#endif
31
32/* inline attribute */
33#ifndef SWIGINLINE
34# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
35# define SWIGINLINE inline
36# else
37# define SWIGINLINE
38# endif
39#endif
40
41/* attribute recognised by some compilers to avoid 'unused' warnings */
42#ifndef SWIGUNUSED
43# if defined(__GNUC__)
44# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
45# define SWIGUNUSED __attribute__ ((__unused__))
46# else
47# define SWIGUNUSED
48# endif
49# elif defined(__ICC)
50# define SWIGUNUSED __attribute__ ((__unused__))
51# else
52# define SWIGUNUSED
53# endif
54#endif
55
56#ifndef SWIG_MSC_UNSUPPRESS_4505
57# if defined(_MSC_VER)
58# pragma warning(disable : 4505) /* unreferenced local function has been removed */
59# endif
60#endif
61
62#ifndef SWIGUNUSEDPARM
63# ifdef __cplusplus
64# define SWIGUNUSEDPARM(p)
65# else
66# define SWIGUNUSEDPARM(p) p SWIGUNUSED
67# endif
68#endif
69
70/* internal SWIG method */
71#ifndef SWIGINTERN
72# define SWIGINTERN static SWIGUNUSED
73#endif
74
75/* internal inline SWIG method */
76#ifndef SWIGINTERNINLINE
77# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
78#endif
79
80/* exporting methods */
81#if defined(__GNUC__)
82# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
83# ifndef GCC_HASCLASSVISIBILITY
84# define GCC_HASCLASSVISIBILITY
85# endif
86# endif
87#endif
88
89#ifndef SWIGEXPORT
90# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
91# if defined(STATIC_LINKED)
92# define SWIGEXPORT
93# else
94# define SWIGEXPORT __declspec(dllexport)
95# endif
96# else
97# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
98# define SWIGEXPORT __attribute__ ((visibility("default")))
99# else
100# define SWIGEXPORT
101# endif
102# endif
103#endif
104
105/* calling conventions for Windows */
106#ifndef SWIGSTDCALL
107# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
108# define SWIGSTDCALL __stdcall
109# else
110# define SWIGSTDCALL
111# endif
112#endif
113
114/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
115#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
116# define _CRT_SECURE_NO_DEPRECATE
117#endif
118
119/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
120#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
121# define _SCL_SECURE_NO_DEPRECATE
122#endif
123
124/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
125#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
126# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
127#endif
128
129/* Intel's compiler complains if a variable which was never initialised is
130 * cast to void, which is a common idiom which we use to indicate that we
131 * are aware a variable isn't used. So we just silence that warning.
132 * See: https://github.com/swig/swig/issues/192 for more discussion.
133 */
134#ifdef __INTEL_COMPILER
135# pragma warning disable 592
136#endif
137
138#if __cplusplus >=201103L
139# define SWIG_NULLPTR nullptr
140#else
141# define SWIG_NULLPTR NULL
142#endif
143
144/* -----------------------------------------------------------------------------
145 * swigrun.swg
146 *
147 * This file contains generic C API SWIG runtime support for pointer
148 * type checking.
149 * ----------------------------------------------------------------------------- */
150
151/* This should only be incremented when either the layout of swig_type_info changes,
152 or for whatever reason, the runtime changes incompatibly */
153#define SWIG_RUNTIME_VERSION "4"
154
155/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
156#ifdef SWIG_TYPE_TABLE
157# define SWIG_QUOTE_STRING(x) #x
158# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
159# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
160#else
161# define SWIG_TYPE_TABLE_NAME
162#endif
163
164/*
165 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
166 creating a static or dynamic library from the SWIG runtime code.
167 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
168
169 But only do this if strictly necessary, ie, if you have problems
170 with your compiler or suchlike.
171*/
172
173#ifndef SWIGRUNTIME
174# define SWIGRUNTIME SWIGINTERN
175#endif
176
177#ifndef SWIGRUNTIMEINLINE
178# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
179#endif
180
181/* Generic buffer size */
182#ifndef SWIG_BUFFER_SIZE
183# define SWIG_BUFFER_SIZE 1024
184#endif
185
186/* Flags for pointer conversions */
187#define SWIG_POINTER_DISOWN 0x1
188#define SWIG_CAST_NEW_MEMORY 0x2
189#define SWIG_POINTER_NO_NULL 0x4
190#define SWIG_POINTER_CLEAR 0x8
191#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
192
193/* Flags for new pointer objects */
194#define SWIG_POINTER_OWN 0x1
195
196
197/*
198 Flags/methods for returning states.
199
200 The SWIG conversion methods, as ConvertPtr, return an integer
201 that tells if the conversion was successful or not. And if not,
202 an error code can be returned (see swigerrors.swg for the codes).
203
204 Use the following macros/flags to set or process the returning
205 states.
206
207 In old versions of SWIG, code such as the following was usually written:
208
209 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
210 // success code
211 } else {
212 //fail code
213 }
214
215 Now you can be more explicit:
216
217 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
218 if (SWIG_IsOK(res)) {
219 // success code
220 } else {
221 // fail code
222 }
223
224 which is the same really, but now you can also do
225
226 Type *ptr;
227 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
228 if (SWIG_IsOK(res)) {
229 // success code
230 if (SWIG_IsNewObj(res) {
231 ...
232 delete *ptr;
233 } else {
234 ...
235 }
236 } else {
237 // fail code
238 }
239
240 I.e., now SWIG_ConvertPtr can return new objects and you can
241 identify the case and take care of the deallocation. Of course that
242 also requires SWIG_ConvertPtr to return new result values, such as
243
244 int SWIG_ConvertPtr(obj, ptr,...) {
245 if (<obj is ok>) {
246 if (<need new object>) {
247 *ptr = <ptr to new allocated object>;
248 return SWIG_NEWOBJ;
249 } else {
250 *ptr = <ptr to old object>;
251 return SWIG_OLDOBJ;
252 }
253 } else {
254 return SWIG_BADOBJ;
255 }
256 }
257
258 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
259 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
260 SWIG errors code.
261
262 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
263 allows returning the 'cast rank', for example, if you have this
264
265 int food(double)
266 int fooi(int);
267
268 and you call
269
270 food(1) // cast rank '1' (1 -> 1.0)
271 fooi(1) // cast rank '0'
272
273 just use the SWIG_AddCast()/SWIG_CheckState()
274*/
275
276#define SWIG_OK (0)
277/* Runtime errors are < 0 */
278#define SWIG_ERROR (-1)
279/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
280/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
281/* Errors < -200 are generic runtime specific errors */
282#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
283
284#define SWIG_IsOK(r) (r >= 0)
285#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
286
287/* The CastRankLimit says how many bits are used for the cast rank */
288#define SWIG_CASTRANKLIMIT (1 << 8)
289/* The NewMask denotes the object was created (using new/malloc) */
290#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
291/* The TmpMask is for in/out typemaps that use temporary objects */
292#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
293/* Simple returning values */
294#define SWIG_BADOBJ (SWIG_ERROR)
295#define SWIG_OLDOBJ (SWIG_OK)
296#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
297#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
298/* Check, add and del object mask methods */
299#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
300#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
301#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
302#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
303#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
304#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
305
306/* Cast-Rank Mode */
307#if defined(SWIG_CASTRANK_MODE)
308# ifndef SWIG_TypeRank
309# define SWIG_TypeRank unsigned long
310# endif
311# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
312# define SWIG_MAXCASTRANK (2)
313# endif
314# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
315# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
317 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
318}
320 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
321}
322#else /* no cast-rank mode */
323# define SWIG_AddCast(r) (r)
324# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
325#endif
326
327/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
328 * if you're missing it.
329 */
330#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
331 (defined __cplusplus && __cplusplus >= 201103L) || \
332 defined SWIG_HAVE_SNPRINTF) && \
333 !defined SWIG_NO_SNPRINTF
334# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
335# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
336#else
337/* Fallback versions ignore the buffer size, but most of our uses either have a
338 * fixed maximum possible size or dynamically allocate a buffer that's large
339 * enough.
340 */
341# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
342# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
343#endif
344
345#include <string.h>
346
347#ifdef __cplusplus
348extern "C" {
349#endif
350
351typedef void *(*swig_converter_func)(void *, int *);
352typedef struct swig_type_info *(*swig_dycast_func)(void **);
353
354/* Structure to store information on one type */
355typedef struct swig_type_info {
356 const char *name; /* mangled name of this type */
357 const char *str; /* human readable name of this type */
358 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
359 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
360 void *clientdata; /* language specific type data */
361 int owndata; /* flag if the structure owns the clientdata */
363
364/* Structure to store a type and conversion function used for casting */
365typedef struct swig_cast_info {
366 swig_type_info *type; /* pointer to type that is equivalent to this type */
367 swig_converter_func converter; /* function to cast the void pointers */
368 struct swig_cast_info *next; /* pointer to next cast in linked list */
369 struct swig_cast_info *prev; /* pointer to the previous cast */
371
372/* Structure used to store module information
373 * Each module generates one structure like this, and the runtime collects
374 * all of these structures and stores them in a circularly linked list.*/
375typedef struct swig_module_info {
376 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
377 size_t size; /* Number of types in this module */
378 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
379 swig_type_info **type_initial; /* Array of initially generated type structures */
380 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
381 void *clientdata; /* Language specific module data */
383
384/*
385 Compare two type names skipping the space characters, therefore
386 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
387
388 Return 0 when the two name types are equivalent, as in
389 strncmp, but skipping ' '.
390*/
391SWIGRUNTIME int
392SWIG_TypeNameComp(const char *f1, const char *l1,
393 const char *f2, const char *l2) {
394 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
395 while ((*f1 == ' ') && (f1 != l1)) ++f1;
396 while ((*f2 == ' ') && (f2 != l2)) ++f2;
397 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
398 }
399 return (int)((l1 - f1) - (l2 - f2));
400}
401
402/*
403 Check type equivalence in a name list like <name1>|<name2>|...
404 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
405*/
406SWIGRUNTIME int
407SWIG_TypeCmp(const char *nb, const char *tb) {
408 int equiv = 1;
409 const char* te = tb + strlen(tb);
410 const char* ne = nb;
411 while (equiv != 0 && *ne) {
412 for (nb = ne; *ne; ++ne) {
413 if (*ne == '|') break;
414 }
415 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
416 if (*ne) ++ne;
417 }
418 return equiv;
419}
420
421/*
422 Check type equivalence in a name list like <name1>|<name2>|...
423 Return 0 if not equal, 1 if equal
424*/
425SWIGRUNTIME int
426SWIG_TypeEquiv(const char *nb, const char *tb) {
427 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
428}
429
430/*
431 Check the typename
432*/
434SWIG_TypeCheck(const char *c, swig_type_info *ty) {
435 if (ty) {
436 swig_cast_info *iter = ty->cast;
437 while (iter) {
438 if (strcmp(iter->type->name, c) == 0) {
439 if (iter == ty->cast)
440 return iter;
441 /* Move iter to the top of the linked list */
442 iter->prev->next = iter->next;
443 if (iter->next)
444 iter->next->prev = iter->prev;
445 iter->next = ty->cast;
446 iter->prev = 0;
447 if (ty->cast) ty->cast->prev = iter;
448 ty->cast = iter;
449 return iter;
450 }
451 iter = iter->next;
452 }
453 }
454 return 0;
455}
456
457/*
458 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
459*/
462 if (ty) {
463 swig_cast_info *iter = ty->cast;
464 while (iter) {
465 if (iter->type == from) {
466 if (iter == ty->cast)
467 return iter;
468 /* Move iter to the top of the linked list */
469 iter->prev->next = iter->next;
470 if (iter->next)
471 iter->next->prev = iter->prev;
472 iter->next = ty->cast;
473 iter->prev = 0;
474 if (ty->cast) ty->cast->prev = iter;
475 ty->cast = iter;
476 return iter;
477 }
478 iter = iter->next;
479 }
480 }
481 return 0;
482}
483
484/*
485 Cast a pointer up an inheritance hierarchy
486*/
488SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
489 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
490}
491
492/*
493 Dynamic pointer casting. Down an inheritance hierarchy
494*/
497 swig_type_info *lastty = ty;
498 if (!ty || !ty->dcast) return ty;
499 while (ty && (ty->dcast)) {
500 ty = (*ty->dcast)(ptr);
501 if (ty) lastty = ty;
502 }
503 return lastty;
504}
505
506/*
507 Return the name associated with this type
508*/
509SWIGRUNTIMEINLINE const char *
511 return ty->name;
512}
513
514/*
515 Return the pretty name associated with this type,
516 that is an unmangled type name in a form presentable to the user.
517*/
518SWIGRUNTIME const char *
520 /* The "str" field contains the equivalent pretty names of the
521 type, separated by vertical-bar characters. Choose the last
522 name. It should be the most specific; a fully resolved name
523 but not necessarily with default template parameters expanded. */
524 if (!type) return NULL;
525 if (type->str != NULL) {
526 const char *last_name = type->str;
527 const char *s;
528 for (s = type->str; *s; s++)
529 if (*s == '|') last_name = s+1;
530 return last_name;
531 }
532 else
533 return type->name;
534}
535
536/*
537 Set the clientdata field for a type
538*/
539SWIGRUNTIME void
541 swig_cast_info *cast = ti->cast;
542 /* if (ti->clientdata == clientdata) return; */
544
545 while (cast) {
546 if (!cast->converter) {
547 swig_type_info *tc = cast->type;
548 if (!tc->clientdata) {
550 }
551 }
552 cast = cast->next;
553 }
554}
555SWIGRUNTIME void
560
561/*
562 Search for a swig_type_info structure only by mangled name
563 Search is a O(log #types)
564
565 We start searching at module start, and finish searching when start == end.
566 Note: if start == end at the beginning of the function, we go all the way around
567 the circular list.
568*/
571 swig_module_info *end,
572 const char *name) {
573 swig_module_info *iter = start;
574 do {
575 if (iter->size) {
576 size_t l = 0;
577 size_t r = iter->size - 1;
578 do {
579 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
580 size_t i = (l + r) >> 1;
581 const char *iname = iter->types[i]->name;
582 if (iname) {
583 int compare = strcmp(name, iname);
584 if (compare == 0) {
585 return iter->types[i];
586 } else if (compare < 0) {
587 if (i) {
588 r = i - 1;
589 } else {
590 break;
591 }
592 } else if (compare > 0) {
593 l = i + 1;
594 }
595 } else {
596 break; /* should never happen */
597 }
598 } while (l <= r);
599 }
600 iter = iter->next;
601 } while (iter != end);
602 return 0;
603}
604
605/*
606 Search for a swig_type_info structure for either a mangled name or a human readable name.
607 It first searches the mangled names of the types, which is a O(log #types)
608 If a type is not found it then searches the human readable names, which is O(#types).
609
610 We start searching at module start, and finish searching when start == end.
611 Note: if start == end at the beginning of the function, we go all the way around
612 the circular list.
613*/
616 swig_module_info *end,
617 const char *name) {
618 /* STEP 1: Search the name field using binary search */
619 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
620 if (ret) {
621 return ret;
622 } else {
623 /* STEP 2: If the type hasn't been found, do a complete search
624 of the str field (the human readable name) */
625 swig_module_info *iter = start;
626 do {
627 size_t i = 0;
628 for (; i < iter->size; ++i) {
629 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
630 return iter->types[i];
631 }
632 iter = iter->next;
633 } while (iter != end);
634 }
635
636 /* neither found a match */
637 return 0;
638}
639
640/*
641 Pack binary data into a string
642*/
643SWIGRUNTIME char *
644SWIG_PackData(char *c, void *ptr, size_t sz) {
645 static const char hex[17] = "0123456789abcdef";
646 const unsigned char *u = (unsigned char *) ptr;
647 const unsigned char *eu = u + sz;
648 for (; u != eu; ++u) {
649 unsigned char uu = *u;
650 *(c++) = hex[(uu & 0xf0) >> 4];
651 *(c++) = hex[uu & 0xf];
652 }
653 return c;
654}
655
656/*
657 Unpack binary data from a string
658*/
659SWIGRUNTIME const char *
660SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
661 unsigned char *u = (unsigned char *) ptr;
662 const unsigned char *eu = u + sz;
663 for (; u != eu; ++u) {
664 char d = *(c++);
665 unsigned char uu;
666 if ((d >= '0') && (d <= '9'))
667 uu = (unsigned char)((d - '0') << 4);
668 else if ((d >= 'a') && (d <= 'f'))
669 uu = (unsigned char)((d - ('a'-10)) << 4);
670 else
671 return (char *) 0;
672 d = *(c++);
673 if ((d >= '0') && (d <= '9'))
674 uu |= (unsigned char)(d - '0');
675 else if ((d >= 'a') && (d <= 'f'))
676 uu |= (unsigned char)(d - ('a'-10));
677 else
678 return (char *) 0;
679 *u = uu;
680 }
681 return c;
682}
683
684/*
685 Pack 'void *' into a string buffer.
686*/
687SWIGRUNTIME char *
688SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
689 char *r = buff;
690 if ((2*sizeof(void *) + 2) > bsz) return 0;
691 *(r++) = '_';
692 r = SWIG_PackData(r,&ptr,sizeof(void *));
693 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
694 strcpy(r,name);
695 return buff;
696}
697
698SWIGRUNTIME const char *
699SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
700 if (*c != '_') {
701 if (strcmp(c,"NULL") == 0) {
702 *ptr = (void *) 0;
703 return name;
704 } else {
705 return 0;
706 }
707 }
708 return SWIG_UnpackData(++c,ptr,sizeof(void *));
709}
710
711SWIGRUNTIME char *
712SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
713 char *r = buff;
714 size_t lname = (name ? strlen(name) : 0);
715 if ((2*sz + 2 + lname) > bsz) return 0;
716 *(r++) = '_';
717 r = SWIG_PackData(r,ptr,sz);
718 if (lname) {
719 strncpy(r,name,lname+1);
720 } else {
721 *r = 0;
722 }
723 return buff;
724}
725
726SWIGRUNTIME const char *
727SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
728 if (*c != '_') {
729 if (strcmp(c,"NULL") == 0) {
730 memset(ptr,0,sz);
731 return name;
732 } else {
733 return 0;
734 }
735 }
736 return SWIG_UnpackData(++c,ptr,sz);
737}
738
739#ifdef __cplusplus
740}
741#endif
742
743/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
744#define SWIG_UnknownError -1
745#define SWIG_IOError -2
746#define SWIG_RuntimeError -3
747#define SWIG_IndexError -4
748#define SWIG_TypeError -5
749#define SWIG_DivisionByZero -6
750#define SWIG_OverflowError -7
751#define SWIG_SyntaxError -8
752#define SWIG_ValueError -9
753#define SWIG_SystemError -10
754#define SWIG_AttributeError -11
755#define SWIG_MemoryError -12
756#define SWIG_NullReferenceError -13
757
758
759#ifdef __cplusplus
760/* Needed on some windows machines---since MS plays funny games with the header files under C++ */
761#include <math.h>
762#include <stdlib.h>
763extern "C" {
764#endif
765
766#if __GNUC__ >= 10
767#if defined(__cplusplus)
768#pragma GCC diagnostic push
769#pragma GCC diagnostic ignored "-Wvolatile"
770#endif
771#endif
772
773#include "EXTERN.h"
774#include "perl.h"
775#include "XSUB.h"
776
777#if __GNUC__ >= 10
778#if defined(__cplusplus)
779#pragma GCC diagnostic pop
780#endif
781#endif
782
783/* PERL_REVISION was added in Perl 5.6. */
784#if !defined PERL_REVISION || (PERL_REVISION-0 == 5 && PERL_VERSION-0 < 8)
785# error SWIG requires Perl >= 5.8.0
786#endif
787
788#if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
789#define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
790#endif
791
792#ifndef SvIOK_UV
793# define SvIOK_UV(sv) (SvIOK(sv) && (SvUVX(sv) == SvIVX(sv)))
794#endif
795
796#ifndef SvUOK
797# define SvUOK(sv) SvIOK_UV(sv)
798#endif
799
800#ifndef IVSIZE
801# ifdef LONGSIZE
802# define IVSIZE LONGSIZE
803# else
804# define IVSIZE 4 /* A bold guess, but the best we can make. */
805# endif
806#endif
807
808#ifndef INT2PTR
809# if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
810# define PTRV UV
811# define INT2PTR(any,d) (any)(d)
812# else
813# if PTRSIZE == LONGSIZE
814# define PTRV unsigned long
815# else
816# define PTRV unsigned
817# endif
818# define INT2PTR(any,d) (any)(PTRV)(d)
819# endif
820
821# define NUM2PTR(any,d) (any)(PTRV)(d)
822# define PTR2IV(p) INT2PTR(IV,p)
823# define PTR2UV(p) INT2PTR(UV,p)
824# define PTR2NV(p) NUM2PTR(NV,p)
825
826# if PTRSIZE == LONGSIZE
827# define PTR2ul(p) (unsigned long)(p)
828# else
829# define PTR2ul(p) INT2PTR(unsigned long,p)
830# endif
831#endif /* !INT2PTR */
832
833#ifndef SvPV_nolen
834# define SvPV_nolen(x) SvPV(x,PL_na)
835#endif
836
837#ifndef get_sv
838# define get_sv perl_get_sv
839#endif
840
841#ifndef ERRSV
842# define ERRSV get_sv("@",FALSE)
843#endif
844
845#ifndef pTHX_
846#define pTHX_
847#endif
848
849#include <string.h>
850#ifdef __cplusplus
851}
852#endif
853
854/* -----------------------------------------------------------------------------
855 * error manipulation
856 * ----------------------------------------------------------------------------- */
857
858SWIGINTERN const char*
860 switch(code) {
861 case SWIG_MemoryError:
862 return "MemoryError";
863 case SWIG_IOError:
864 return "IOError";
866 return "RuntimeError";
867 case SWIG_IndexError:
868 return "IndexError";
869 case SWIG_TypeError:
870 return "TypeError";
872 return "ZeroDivisionError";
874 return "OverflowError";
875 case SWIG_SyntaxError:
876 return "SyntaxError";
877 case SWIG_ValueError:
878 return "ValueError";
879 case SWIG_SystemError:
880 return "SystemError";
882 return "AttributeError";
883 default:
884 return "RuntimeError";
885 }
886}
887
888
889/* -----------------------------------------------------------------------------
890 * perlrun.swg
891 *
892 * This file contains the runtime support for Perl modules
893 * and includes code for managing global variables and pointer
894 * type checking.
895 * ----------------------------------------------------------------------------- */
896
897#define SWIG_PERL_OBJECT_DECL
898#define SWIG_PERL_OBJECT_CALL
899
900/* Common SWIG API */
901
902/* for raw pointers */
903#define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
904#define SWIG_ConvertPtrAndOwn(obj, pp, type, flags,own) SWIG_Perl_ConvertPtrAndOwn(SWIG_PERL_OBJECT_CALL obj, pp, type, flags, own)
905#define SWIG_NewPointerObj(p, type, flags) SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
906#define SWIG_AcquirePtr(ptr, src) SWIG_Perl_AcquirePtr(ptr, src)
907#define swig_owntype int
908
909/* for raw packed data */
910#define SWIG_ConvertPacked(obj, p, s, type) SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
911#define SWIG_NewPackedObj(p, s, type) SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
912
913/* for class or struct pointers */
914#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
915#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
916
917/* for C or C++ function pointers */
918#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
919#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
920
921/* for C++ member pointers, ie, member methods */
922#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_ConvertPacked(obj, ptr, sz, ty)
923#define SWIG_NewMemberObj(ptr, sz, type) SWIG_NewPackedObj(ptr, sz, type)
924
925
926/* Runtime API */
927
928#define SWIG_GetModule(clientdata) SWIG_Perl_GetModule(clientdata)
929#define SWIG_SetModule(clientdata, pointer) SWIG_Perl_SetModule(pointer)
930
931
932/* Error manipulation */
933
934#define SWIG_ErrorType(code) SWIG_Perl_ErrorType(code)
935#define SWIG_Error(code, msg) sv_setpvf(get_sv("@", GV_ADD), "%s %s", SWIG_ErrorType(code), msg)
936#define SWIG_fail goto fail
937
938/* Perl-specific SWIG API */
939
940#define SWIG_MakePtr(sv, ptr, type, flags) SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
941#define SWIG_MakePackedObj(sv, p, s, type) SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
942#define SWIG_SetError(str) SWIG_Error(SWIG_RuntimeError, str)
943
944
945#define SWIG_PERL_DECL_ARGS_1(arg1) (SWIG_PERL_OBJECT_DECL arg1)
946#define SWIG_PERL_CALL_ARGS_1(arg1) (SWIG_PERL_OBJECT_CALL arg1)
947#define SWIG_PERL_DECL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_DECL arg1, arg2)
948#define SWIG_PERL_CALL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_CALL arg1, arg2)
949
950/* -----------------------------------------------------------------------------
951 * pointers/data manipulation
952 * ----------------------------------------------------------------------------- */
953
954/* For backward compatibility only */
955#define SWIG_POINTER_EXCEPTION 0
956
957#ifdef __cplusplus
958extern "C" {
959#endif
960
961#define SWIG_OWNER SWIG_POINTER_OWN
962#define SWIG_SHADOW SWIG_OWNER << 1
963
964#define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
965
966/* SWIG Perl macros */
967
968/* Macro to declare an XS function */
969#ifndef XSPROTO
970# define XSPROTO(name) void name(pTHX_ CV* cv)
971#endif
972
973/* Macro to call an XS function */
974#ifndef MULTIPLICITY
975# define SWIG_CALLXS(_name) _name(cv)
976#else
977# define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv)
978#endif
979
980#define MAGIC_PPERL
981#define SWIGCLASS_STATIC static SWIGUNUSED
982
983#ifndef MULTIPLICITY
984#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
985
986#ifdef __cplusplus
987extern "C" {
988#endif
989typedef int (*SwigMagicFunc)(SV *, MAGIC *);
990#ifdef __cplusplus
991}
992#endif
993
994#else /* MULTIPLICITY */
995
996#define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
997
998#ifdef __cplusplus
999extern "C" {
1000#endif
1001typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
1002#ifdef __cplusplus
1003}
1004#endif
1005
1006#endif /* MULTIPLICITY */
1007
1009{
1010 SV *err = get_sv("@", GV_ADD);
1011 if (sv_isobject(err))
1012 croak(0);
1013 else
1014 croak("%s", SvPV_nolen(err));
1015}
1016
1017
1018/*
1019 Define how strict is the cast between strings and integers/doubles
1020 when overloading between these types occurs.
1021
1022 The default is making it as strict as possible by using SWIG_AddCast
1023 when needed.
1024
1025 You can use -DSWIG_PERL_NO_STRICT_STR2NUM at compilation time to
1026 disable the SWIG_AddCast, making the casting between string and
1027 numbers less strict.
1028
1029 In the end, we try to solve the overloading between strings and
1030 numerical types in the more natural way, but if you can avoid it,
1031 well, avoid it using %rename, for example.
1032*/
1033#ifndef SWIG_PERL_NO_STRICT_STR2NUM
1034# ifndef SWIG_PERL_STRICT_STR2NUM
1035# define SWIG_PERL_STRICT_STR2NUM
1036# endif
1037#endif
1038#ifdef SWIG_PERL_STRICT_STR2NUM
1039/* string takes precedence */
1040#define SWIG_Str2NumCast(x) SWIG_AddCast(x)
1041#else
1042/* number takes precedence */
1043#define SWIG_Str2NumCast(x) x
1044#endif
1045
1046
1047
1048#include <stdlib.h>
1049
1050SWIGRUNTIME const char *
1052 if (!type) return NULL;
1053 if (type->clientdata != NULL) {
1054 return (const char*) type->clientdata;
1055 }
1056 else {
1057 return type->name;
1058 }
1059}
1060
1061/* Identical to SWIG_TypeCheck, except for strcmp comparison */
1064 if (ty) {
1065 swig_cast_info *iter = ty->cast;
1066 while (iter) {
1067 if (strcmp(SWIG_Perl_TypeProxyName(iter->type), c) == 0) {
1068 if (iter == ty->cast)
1069 return iter;
1070 /* Move iter to the top of the linked list */
1071 iter->prev->next = iter->next;
1072 if (iter->next)
1073 iter->next->prev = iter->prev;
1074 iter->next = ty->cast;
1075 iter->prev = 0;
1076 if (ty->cast) ty->cast->prev = iter;
1077 ty->cast = iter;
1078 return iter;
1079 }
1080 iter = iter->next;
1081 }
1082 }
1083 return 0;
1084}
1085
1086/* Acquire a pointer value */
1087
1088SWIGRUNTIME int
1090 /* TODO */
1091 return 0;
1092}
1093
1094/* Function for getting a pointer value */
1095
1096SWIGRUNTIME int
1098 swig_cast_info *tc;
1099 void *voidptr = (void *)0;
1100 SV *tsv = 0;
1101 int check_owned_pointer_release = (flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE;
1102
1103 if (own)
1104 *own = 0;
1105
1106 /* If magical, apply more magic */
1107 if (SvGMAGICAL(sv))
1108 mg_get(sv);
1109
1110 /* Check to see if this is an object */
1111 if (sv_isobject(sv)) {
1112 IV tmp = 0;
1113 tsv = (SV*) SvRV(sv);
1114 if ((SvTYPE(tsv) == SVt_PVHV)) {
1115 MAGIC *mg;
1116 if (SvMAGICAL(tsv)) {
1117 mg = mg_find(tsv,'P');
1118 if (mg) {
1119 sv = mg->mg_obj;
1120 if (sv_isobject(sv)) {
1121 tsv = (SV*)SvRV(sv);
1122 tmp = SvIV(tsv);
1123 }
1124 }
1125 } else {
1126 return SWIG_ERROR;
1127 }
1128 } else {
1129 tmp = SvIV(tsv);
1130 }
1131 voidptr = INT2PTR(void *,tmp);
1132 } else if (! SvOK(sv)) { /* Check for undef */
1133 *(ptr) = (void *) 0;
1135 } else if (SvTYPE(sv) == SVt_RV) { /* Check for NULL pointer */
1136 if (!SvROK(sv)) {
1137 /* In Perl 5.12 and later, SVt_RV == SVt_IV, so sv could be a valid integer value. */
1138 if (SvIOK(sv)) {
1139 return SWIG_ERROR;
1140 } else {
1141 /* NULL pointer (reference to undef). */
1142 *(ptr) = (void *) 0;
1143 return SWIG_OK;
1144 }
1145 } else {
1146 return SWIG_ERROR;
1147 }
1148 } else { /* Don't know what it is */
1149 return SWIG_ERROR;
1150 }
1151 if (_t) {
1152 /* Now see if the types match */
1153 char *_c = HvNAME(SvSTASH(SvRV(sv)));
1154 tc = SWIG_TypeProxyCheck(_c,_t);
1155#ifdef SWIG_DIRECTORS
1156 if (!tc && !sv_derived_from(sv,SWIG_Perl_TypeProxyName(_t))) {
1157#else
1158 if (!tc) {
1159#endif
1160 return SWIG_ERROR;
1161 }
1162 {
1163 int newmemory = 0;
1164 *ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
1165 if (newmemory == SWIG_CAST_NEW_MEMORY) {
1166 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1167 if (own)
1168 *own = *own | SWIG_CAST_NEW_MEMORY;
1169 }
1170 }
1171 } else {
1172 *ptr = voidptr;
1173 }
1174
1175 /*
1176 * DISOWN implementation: we need a perl guru to check this one.
1177 */
1178 if (tsv && ((flags & SWIG_POINTER_DISOWN) || check_owned_pointer_release)) {
1179 /*
1180 * almost copy paste code from below SWIG_POINTER_OWN setting
1181 */
1182 SV *obj = sv;
1183 HV *stash = SvSTASH(SvRV(obj));
1184 GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1185 int owned = 0;
1186 if (isGV(gv)) {
1187 HV *hv = GvHVn(gv);
1188 /*
1189 * To set ownership (see below), a newSViv(1) entry is added.
1190 * Hence, to remove ownership, we delete the entry.
1191 */
1192 if (hv_exists_ent(hv, obj, 0)) {
1193 owned = 1;
1194 if (flags & SWIG_POINTER_DISOWN) {
1195 hv_delete_ent(hv, obj, 0, 0);
1196 }
1197 }
1198 }
1199 if (check_owned_pointer_release && !owned) {
1201 }
1202 }
1203
1204 if (tsv && (flags & SWIG_POINTER_CLEAR)) {
1205 SvIV_set(tsv, 0);
1206 }
1207
1208 return SWIG_OK;
1209}
1210
1211SWIGRUNTIME int
1213 return SWIG_Perl_ConvertPtrAndOwn(sv, ptr, _t, flags, 0);
1214}
1215
1216SWIGRUNTIME void
1218 if (ptr && (flags & (SWIG_SHADOW | SWIG_POINTER_OWN))) {
1219 SV *self;
1220 SV *obj=newSV(0);
1221 HV *hash=newHV();
1222 HV *stash;
1223 sv_setref_pv(obj, SWIG_Perl_TypeProxyName(t), ptr);
1224 stash=SvSTASH(SvRV(obj));
1225 if (flags & SWIG_POINTER_OWN) {
1226 HV *hv;
1227 GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1228 if (!isGV(gv))
1229 gv_init(gv, stash, "OWNER", 5, FALSE);
1230 hv=GvHVn(gv);
1231 hv_store_ent(hv, obj, newSViv(1), 0);
1232 }
1233 sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
1234 SvREFCNT_dec(obj);
1235 self=newRV_noinc((SV *)hash);
1236 sv_setsv(sv, self);
1237 SvREFCNT_dec((SV *)self);
1238 sv_bless(sv, stash);
1239 }
1240 else {
1241 sv_setref_pv(sv, SWIG_Perl_TypeProxyName(t), ptr);
1242 }
1243}
1244
1247 SV *result = sv_newmortal();
1248 SWIG_MakePtr(result, ptr, t, flags);
1249 return result;
1250}
1251
1252SWIGRUNTIME void
1254 char result[1024];
1255 char *r = result;
1256 if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
1257 *(r++) = '_';
1258 r = SWIG_PackData(r,ptr,sz);
1259 strcpy(r,SWIG_Perl_TypeProxyName(type));
1260 sv_setpv(sv, result);
1261}
1262
1263SWIGRUNTIME SV *
1265 SV *result = sv_newmortal();
1266 SWIG_Perl_MakePackedObj(result, ptr, sz, type);
1267 return result;
1268}
1269
1270/* Convert a packed pointer value */
1271SWIGRUNTIME int
1273 swig_cast_info *tc;
1274 const char *c = 0;
1275
1276 if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
1277 c = SvPV_nolen(obj);
1278 /* Pointer values must start with leading underscore */
1279 if (*c != '_') return SWIG_ERROR;
1280 c++;
1281 c = SWIG_UnpackData(c,ptr,sz);
1282 if (ty) {
1283 tc = SWIG_TypeCheck(c,ty);
1284 if (!tc) return SWIG_ERROR;
1285 }
1286 return SWIG_OK;
1287}
1288
1289
1290/* Macros for low-level exception handling */
1291#define SWIG_croak(x) { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
1292
1293
1294typedef XSPROTO(SwigPerlWrapper);
1295typedef SwigPerlWrapper *SwigPerlWrapperPtr;
1296
1297/* Structure for command table */
1298typedef struct {
1299 const char *name;
1302
1303/* Information for constant table */
1304
1305#define SWIG_INT 1
1306#define SWIG_FLOAT 2
1307#define SWIG_STRING 3
1308#define SWIG_POINTER 4
1309#define SWIG_BINARY 5
1310
1311/* Constant information structure */
1320
1321
1322/* Structure for variable table */
1329
1330/* Magic variable code */
1331#ifdef __cplusplus
1332# define swig_create_magic(s,a,b,c) _swig_create_magic(s,const_cast<char*>(a),b,c)
1333#else
1334# define swig_create_magic(s,a,b,c) _swig_create_magic(s,(char*)(a),b,c)
1335#endif
1336#ifndef MULTIPLICITY
1337SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *))
1338#else
1339SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *))
1340#endif
1341{
1342 MAGIC *mg;
1343 sv_magic(sv,sv,'U',name,(I32)strlen(name));
1344 mg = mg_find(sv,'U');
1345 mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
1346 mg->mg_virtual->svt_get = (SwigMagicFunc) get;
1347 mg->mg_virtual->svt_set = (SwigMagicFunc) set;
1348 mg->mg_virtual->svt_len = 0;
1349 mg->mg_virtual->svt_clear = 0;
1350 mg->mg_virtual->svt_free = 0;
1351}
1352
1353
1356 static void *type_pointer = (void *)0;
1357 SV *pointer;
1358
1359 /* first check if pointer already created */
1360 if (!type_pointer) {
1361 pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE | GV_ADDMULTI);
1362 if (pointer && SvOK(pointer)) {
1363 type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
1364 }
1365 }
1366
1367 return (swig_module_info *) type_pointer;
1368}
1369
1370SWIGRUNTIME void
1372 SV *pointer;
1373
1374 /* create a new pointer */
1375 pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE | GV_ADDMULTI);
1376 sv_setiv(pointer, PTR2IV(module));
1377}
1378
1379#ifdef __cplusplus
1380}
1381#endif
1382
1383/* Workaround perl5 global namespace pollution. Note that undefining library
1384 * functions like fopen will not solve the problem on all platforms as fopen
1385 * might be a macro on Windows but not necessarily on other operating systems. */
1386#ifdef do_open
1387 #undef do_open
1388#endif
1389#ifdef do_close
1390 #undef do_close
1391#endif
1392#ifdef do_exec
1393 #undef do_exec
1394#endif
1395#ifdef scalar
1396 #undef scalar
1397#endif
1398#ifdef list
1399 #undef list
1400#endif
1401#ifdef apply
1402 #undef apply
1403#endif
1404#ifdef convert
1405 #undef convert
1406#endif
1407#ifdef Error
1408 #undef Error
1409#endif
1410#ifdef form
1411 #undef form
1412#endif
1413#ifdef vform
1414 #undef vform
1415#endif
1416#ifdef LABEL
1417 #undef LABEL
1418#endif
1419#ifdef METHOD
1420 #undef METHOD
1421#endif
1422#ifdef Move
1423 #undef Move
1424#endif
1425#ifdef yylex
1426 #undef yylex
1427#endif
1428#ifdef yyparse
1429 #undef yyparse
1430#endif
1431#ifdef yyerror
1432 #undef yyerror
1433#endif
1434#ifdef invert
1435 #undef invert
1436#endif
1437#ifdef ref
1438 #undef ref
1439#endif
1440#ifdef read
1441 #undef read
1442#endif
1443#ifdef write
1444 #undef write
1445#endif
1446#ifdef eof
1447 #undef eof
1448#endif
1449#ifdef close
1450 #undef close
1451#endif
1452#ifdef rewind
1453 #undef rewind
1454#endif
1455#ifdef free
1456 #undef free
1457#endif
1458#ifdef malloc
1459 #undef malloc
1460#endif
1461#ifdef calloc
1462 #undef calloc
1463#endif
1464#ifdef Stat
1465 #undef Stat
1466#endif
1467#ifdef check
1468 #undef check
1469#endif
1470#ifdef seekdir
1471 #undef seekdir
1472#endif
1473#ifdef open
1474 #undef open
1475#endif
1476#ifdef readdir
1477 #undef readdir
1478#endif
1479#ifdef bind
1480 #undef bind
1481#endif
1482#ifdef access
1483 #undef access
1484#endif
1485#ifdef stat
1486 #undef stat
1487#endif
1488#ifdef seed
1489 #undef seed
1490#endif
1491
1492#ifdef bool
1493 /* Leave if macro is from C99 stdbool.h */
1494 #ifndef __bool_true_false_are_defined
1495 #undef bool
1496 #endif
1497#endif
1498
1499
1500
1501
1502#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1503
1504#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
1505
1506
1507
1508/* -------- TYPES TABLE (BEGIN) -------- */
1509
1510#define SWIGTYPE_p_Agedge_t swig_types[0]
1511#define SWIGTYPE_p_Agnode_t swig_types[1]
1512#define SWIGTYPE_p_Agraph_t swig_types[2]
1513#define SWIGTYPE_p_Agsym_t swig_types[3]
1514#define SWIGTYPE_p_FILE swig_types[4]
1515#define SWIGTYPE_p_char swig_types[5]
1517static swig_module_info swig_module = {swig_types, 6, 0, 0, 0, 0};
1518#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1519#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1520
1521/* -------- TYPES TABLE (END) -------- */
1522
1523#define SWIG_init boot_gv
1524
1525#define SWIG_name "gvc::boot_gv"
1526#define SWIG_prefix "gvc::"
1527
1528#ifdef __cplusplus
1529#include <utility>
1530/* SwigValueWrapper is described in swig.swg */
1531template<typename T> class SwigValueWrapper {
1532 struct SwigSmartPointer {
1533 T *ptr;
1534 SwigSmartPointer(T *p) : ptr(p) { }
1535 ~SwigSmartPointer() { delete ptr; }
1536 SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
1537 void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; }
1538 } pointer;
1539 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
1540 SwigValueWrapper(const SwigValueWrapper<T>& rhs);
1541public:
1542 SwigValueWrapper() : pointer(0) { }
1543 SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; }
1544#if __cplusplus >=201103L
1545 SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; }
1546 operator T&&() const { return std::move(*pointer.ptr); }
1547#else
1548 operator T&() const { return *pointer.ptr; }
1549#endif
1550 T *operator&() const { return pointer.ptr; }
1551 static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
1552};
1553
1554/*
1555 * SwigValueInit() is a generic initialisation solution as the following approach:
1556 *
1557 * T c_result = T();
1558 *
1559 * doesn't compile for all types for example:
1560 *
1561 * unsigned int c_result = unsigned int();
1562 */
1563template <typename T> T SwigValueInit() {
1564 return T();
1565}
1566
1567#if __cplusplus >=201103L
1568# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
1569#else
1570# define SWIG_STD_MOVE(OBJ) OBJ
1571#endif
1572
1573#endif
1574
1575
1576#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
1577#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
1578
1579
1580#include <stdexcept>
1581
1582
1583#ifdef __cplusplus
1584extern "C"
1585#endif
1586#ifndef MULTIPLICITY
1587SWIGEXPORT void SWIG_init (CV* cv);
1588#else
1589SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1590#endif
1591
1592
1593#include <gvc/gvc.h>
1594
1596/*** New empty graph */
1597extern Agraph_t *graph(char *name);
1598extern Agraph_t *digraph(char *name);
1599extern Agraph_t *strictgraph(char *name);
1600extern Agraph_t *strictdigraph(char *name);
1601/*** New graph from a dot-syntax string or file */
1602extern Agraph_t *readstring(char *string);
1603extern Agraph_t *read(const char *filename);
1604extern Agraph_t *read(FILE *f);
1605/*** Add new subgraph to existing graph */
1606extern Agraph_t *graph(Agraph_t *g, char *name);
1607
1609/*** Add new node to existing graph */
1610extern Agnode_t *node(Agraph_t *g, char *name);
1611
1613/*** Add new edge between existing nodes */
1614extern Agedge_t *edge(Agnode_t *t, Agnode_t *h);
1615/*** Add a new edge between an existing tail node, and a named head node which will be induced in the graph if it doesn't already exist */
1616extern Agedge_t *edge(Agnode_t *t, char *hname);
1617/*** Add a new edge between an existing head node, and a named tail node which will be induced in the graph if it doesn't already exist */
1618extern Agedge_t *edge(char *tname, Agnode_t *h);
1619/*** Add a new edge between named tail and head nodes which will be induced in the graph if they don't already exist */
1620extern Agedge_t *edge(Agraph_t *g, char *tname, char *hname);
1621
1623/*** Set value of named attribute of graph/node/edge - creating attribute if necessary */
1624extern char *setv(Agraph_t *g, char *attr, char *val);
1625extern char *setv(Agnode_t *n, char *attr, char *val);
1626extern char *setv(Agedge_t *e, char *attr, char *val);
1627
1628/*** Set value of existing attribute of graph/node/edge (using attribute handle) */
1629extern char *setv(Agraph_t *g, Agsym_t *a, char *val);
1630extern char *setv(Agnode_t *n, Agsym_t *a, char *val);
1631extern char *setv(Agedge_t *e, Agsym_t *a, char *val);
1632
1634/*** Get value of named attribute of graph/node/edge */
1635extern char *getv(Agraph_t *g, char *attr);
1636extern char *getv(Agnode_t *n, char *attr);
1637extern char *getv(Agedge_t *e, char *attr);
1638
1639/*** Get value of attribute of graph/node/edge (using attribute handle) */
1640extern char *getv(Agraph_t *g, Agsym_t *a);
1641extern char *getv(Agnode_t *n, Agsym_t *a);
1642extern char *getv(Agedge_t *e, Agsym_t *a);
1643
1645extern char *nameof(Agraph_t *g);
1646extern char *nameof(Agnode_t *n);
1647extern char *nameof(Agsym_t *a);
1648
1650extern Agraph_t *findsubg(Agraph_t *g, char *name);
1651extern Agnode_t *findnode(Agraph_t *g, char *name);
1652extern Agedge_t *findedge(Agnode_t *t, Agnode_t *h);
1653
1655extern Agsym_t *findattr(Agraph_t *g, char *name);
1656extern Agsym_t *findattr(Agnode_t *n, char *name);
1657extern Agsym_t *findattr(Agedge_t *e, char *name);
1658
1660extern Agnode_t *headof(Agedge_t *e);
1661extern Agnode_t *tailof(Agedge_t *e);
1662extern Agraph_t *graphof(Agraph_t *g);
1663extern Agraph_t *graphof(Agedge_t *e);
1664extern Agraph_t *graphof(Agnode_t *n);
1665extern Agraph_t *rootof(Agraph_t *g);
1666
1668extern Agnode_t *protonode(Agraph_t *g);
1669extern Agedge_t *protoedge(Agraph_t *g);
1670
1672/*** Iteration termination tests */
1673extern bool ok(Agraph_t *g);
1674extern bool ok(Agnode_t *n);
1675extern bool ok(Agedge_t *e);
1676extern bool ok(Agsym_t *a);
1677
1678/*** Iterate over subgraphs of a graph */
1679extern Agraph_t *firstsubg(Agraph_t *g);
1680extern Agraph_t *nextsubg(Agraph_t *g, Agraph_t *sg);
1681
1682/*** Iterate over supergraphs of a graph (obscure and rarely useful) */
1683extern Agraph_t *firstsupg(Agraph_t *g);
1684extern Agraph_t *nextsupg(Agraph_t *g, Agraph_t *sg);
1685
1686/*** Iterate over edges of a graph */
1687extern Agedge_t *firstedge(Agraph_t *g);
1688extern Agedge_t *nextedge(Agraph_t *g, Agedge_t *e);
1689
1690/*** Iterate over outedges of a graph */
1691extern Agedge_t *firstout(Agraph_t *g);
1692extern Agedge_t *nextout(Agraph_t *g, Agedge_t *e);
1693
1694/*** Iterate over edges of a node */
1695extern Agedge_t *firstedge(Agnode_t *n);
1696extern Agedge_t *nextedge(Agnode_t *n, Agedge_t *e);
1697
1698/*** Iterate over out-edges of a node */
1699extern Agedge_t *firstout(Agnode_t *n);
1700extern Agedge_t *nextout(Agnode_t *n, Agedge_t *e);
1701
1702/*** Iterate over head nodes reachable from out-edges of a node */
1703extern Agnode_t *firsthead(Agnode_t *n);
1704extern Agnode_t *nexthead(Agnode_t *n, Agnode_t *h);
1705
1706/*** Iterate over in-edges of a graph */
1707extern Agedge_t *firstin(Agraph_t *g);
1708extern Agedge_t *nextin(Agnode_t *n, Agedge_t *e);
1709
1710/*** Iterate over in-edges of a node */
1711extern Agedge_t *firstin(Agnode_t *n);
1712extern Agedge_t *nextin(Agraph_t *g, Agedge_t *e);
1713
1714/*** Iterate over tail nodes reachable from in-edges of a node */
1715extern Agnode_t *firsttail(Agnode_t *n);
1716extern Agnode_t *nexttail(Agnode_t *n, Agnode_t *t);
1717
1718/*** Iterate over nodes of a graph */
1719extern Agnode_t *firstnode(Agraph_t *g);
1720extern Agnode_t *nextnode(Agraph_t *g, Agnode_t *n);
1721
1722/*** Iterate over nodes of an edge */
1723extern Agnode_t *firstnode(Agedge_t *e);
1724extern Agnode_t *nextnode(Agedge_t *e, Agnode_t *n);
1725
1726/*** Iterate over attributes of a graph */
1727extern Agsym_t *firstattr(Agraph_t *g);
1728extern Agsym_t *nextattr(Agraph_t *g, Agsym_t *a);
1729
1730/*** Iterate over attributes of an edge */
1731extern Agsym_t *firstattr(Agedge_t *e);
1732extern Agsym_t *nextattr(Agedge_t *e, Agsym_t *a);
1733
1734/*** Iterate over attributes of a node */
1735extern Agsym_t *firstattr(Agnode_t *n);
1736extern Agsym_t *nextattr(Agnode_t *n, Agsym_t *a);
1737
1739extern bool rm(Agraph_t *g);
1740extern bool rm(Agnode_t *n);
1741extern bool rm(Agedge_t *e);
1742
1744/*** Annotate a graph with layout attributes and values using a specific layout engine */
1745extern bool layout(Agraph_t *g, const char *engine);
1746
1748/*** Render a layout into attributes of the graph */
1749extern bool render(Agraph_t *g);
1750/*** Render a layout to stdout */
1751extern bool render(Agraph_t *g, const char *format);
1752/*** Render to an open file */
1753extern bool render(Agraph_t *g, const char *format, FILE *fout);
1754/*** Render a layout to an unopened file by name */
1755extern bool render(Agraph_t *g, const char *format, const char *filename);
1756/*** Render to a string result */
1757#ifdef SWIGJAVA
1758extern char* renderresult(Agraph_t *ing, const char *format);
1759#else
1760extern void renderresult(Agraph_t *g, const char *format, char *outdata);
1761/*** Render to an open channel */
1762extern bool renderchannel(Agraph_t *g, const char *format, const char *channelname);
1763#endif
1764/*** Render a layout to a malloc'ed string, to be free'd by the caller */
1765/*** (deprecated - too easy to leak memory) */
1766/*** (still needed for "eval [gv::renderdata $G tk]" ) */
1767extern char* renderdata(Agraph_t *g, const char *format);
1768
1769/*** Writing graph back to file */
1770extern bool write(Agraph_t *g, const char *filename);
1771extern bool write(Agraph_t *g, FILE *f);
1772
1773/*** Graph transformation tools */
1774extern bool tred(Agraph_t *g);
1775
1776
1777
1780{
1781 static int init = 0;
1782 static swig_type_info* info = 0;
1783 if (!init) {
1784 info = SWIG_TypeQuery("_p_char");
1785 init = 1;
1786 }
1787 return info;
1788}
1789
1790
1791SWIGINTERN int
1792SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1793{
1794 if (SvMAGICAL(obj)) {
1795 SV *tmp = sv_newmortal();
1796 SvSetSV(tmp, obj);
1797 obj = tmp;
1798 }
1799 if (SvPOK(obj)) {
1800 STRLEN len = 0;
1801 char *cstr = SvPV(obj, len);
1802 size_t size = len + 1;
1803 if (cptr) {
1804 if (alloc) {
1805 if (*alloc == SWIG_NEWOBJ) {
1806 *cptr = reinterpret_cast< char* >(memcpy(new char[size], cstr, sizeof(char)*(size)));
1807 } else {
1808 *cptr = cstr;
1809 *alloc = SWIG_OLDOBJ;
1810 }
1811 }
1812 }
1813 if (psize) *psize = size;
1814 return SWIG_OK;
1815 } else {
1816 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1817 if (pchar_descriptor) {
1818 char* vptr = 0;
1819 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
1820 if (cptr) *cptr = vptr;
1821 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1822 if (alloc) *alloc = SWIG_OLDOBJ;
1823 return SWIG_OK;
1824 }
1825 }
1826 }
1827 return SWIG_TypeError;
1828}
1829
1830
1831
1832
1833
1835SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1836{
1837 SV *obj = sv_newmortal();
1838 if (carray) {
1839 sv_setpvn(obj, carray, size);
1840 } else {
1841 sv_setsv(obj, &PL_sv_undef);
1842 }
1843 return obj;
1844}
1845
1846
1847SWIGINTERNINLINE SV *
1848SWIG_FromCharPtr(const char *cptr)
1849{
1850 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1851}
1852
1853
1856{
1857 return boolSV(value);
1858}
1859
1860#ifdef __cplusplus
1861extern "C" {
1862#endif
1863
1864#define MAGIC_CLASS
1867 croak("Value is read-only.");
1868 return 0;
1869}
1870
1871#ifdef __cplusplus
1872}
1873#endif
1874
1875#ifdef __cplusplus
1876extern "C" {
1877#endif
1879 {
1880 char *arg1 = (char *) 0 ;
1881 int res1 ;
1882 char *buf1 = 0 ;
1883 int alloc1 = 0 ;
1884 int argvi = 0;
1885 Agraph_t *result = 0 ;
1886 dXSARGS;
1887
1888 if ((items < 1) || (items > 1)) {
1889 SWIG_croak("Usage: graph(name);");
1890 }
1891 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
1892 if (!SWIG_IsOK(res1)) {
1893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "graph" "', argument " "1"" of type '" "char *""'");
1894 }
1895 arg1 = reinterpret_cast< char * >(buf1);
1896 result = (Agraph_t *)graph(arg1);
1897 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agraph_t, 0 | 0); argvi++ ;
1898 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
1899 XSRETURN(argvi);
1900 fail:
1901 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
1903 }
1904}
1905
1906
1908 {
1909 char *arg1 = (char *) 0 ;
1910 int res1 ;
1911 char *buf1 = 0 ;
1912 int alloc1 = 0 ;
1913 int argvi = 0;
1914 Agraph_t *result = 0 ;
1915 dXSARGS;
1916
1917 if ((items < 1) || (items > 1)) {
1918 SWIG_croak("Usage: digraph(name);");
1919 }
1920 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
1921 if (!SWIG_IsOK(res1)) {
1922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "digraph" "', argument " "1"" of type '" "char *""'");
1923 }
1924 arg1 = reinterpret_cast< char * >(buf1);
1925 result = (Agraph_t *)digraph(arg1);
1926 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agraph_t, 0 | 0); argvi++ ;
1927 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
1928 XSRETURN(argvi);
1929 fail:
1930 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
1932 }
1933}
1934
1935
1937 {
1938 char *arg1 = (char *) 0 ;
1939 int res1 ;
1940 char *buf1 = 0 ;
1941 int alloc1 = 0 ;
1942 int argvi = 0;
1943 Agraph_t *result = 0 ;
1944 dXSARGS;
1945
1946 if ((items < 1) || (items > 1)) {
1947 SWIG_croak("Usage: strictgraph(name);");
1948 }
1949 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
1950 if (!SWIG_IsOK(res1)) {
1951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "strictgraph" "', argument " "1"" of type '" "char *""'");
1952 }
1953 arg1 = reinterpret_cast< char * >(buf1);
1954 result = (Agraph_t *)strictgraph(arg1);
1955 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agraph_t, 0 | 0); argvi++ ;
1956 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
1957 XSRETURN(argvi);
1958 fail:
1959 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
1961 }
1962}
1963
1964
1966 {
1967 char *arg1 = (char *) 0 ;
1968 int res1 ;
1969 char *buf1 = 0 ;
1970 int alloc1 = 0 ;
1971 int argvi = 0;
1972 Agraph_t *result = 0 ;
1973 dXSARGS;
1974
1975 if ((items < 1) || (items > 1)) {
1976 SWIG_croak("Usage: strictdigraph(name);");
1977 }
1978 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
1979 if (!SWIG_IsOK(res1)) {
1980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "strictdigraph" "', argument " "1"" of type '" "char *""'");
1981 }
1982 arg1 = reinterpret_cast< char * >(buf1);
1983 result = (Agraph_t *)strictdigraph(arg1);
1984 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agraph_t, 0 | 0); argvi++ ;
1985 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
1986 XSRETURN(argvi);
1987 fail:
1988 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
1990 }
1991}
1992
1993
1995 {
1996 char *arg1 = (char *) 0 ;
1997 int res1 ;
1998 char *buf1 = 0 ;
1999 int alloc1 = 0 ;
2000 int argvi = 0;
2001 Agraph_t *result = 0 ;
2002 dXSARGS;
2003
2004 if ((items < 1) || (items > 1)) {
2005 SWIG_croak("Usage: readstring(string);");
2006 }
2007 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2008 if (!SWIG_IsOK(res1)) {
2009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "readstring" "', argument " "1"" of type '" "char *""'");
2010 }
2011 arg1 = reinterpret_cast< char * >(buf1);
2012 result = (Agraph_t *)readstring(arg1);
2013 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agraph_t, 0 | 0); argvi++ ;
2014 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
2015 XSRETURN(argvi);
2016 fail:
2017 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
2019 }
2020}
2021
2022
2024 {
2025 char *arg1 = (char *) 0 ;
2026 int res1 ;
2027 char *buf1 = 0 ;
2028 int alloc1 = 0 ;
2029 int argvi = 0;
2030 Agraph_t *result = 0 ;
2031 dXSARGS;
2032
2033 if ((items < 1) || (items > 1)) {
2034 SWIG_croak("Usage: read(filename);");
2035 }
2036 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2037 if (!SWIG_IsOK(res1)) {
2038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "read" "', argument " "1"" of type '" "char const *""'");
2039 }
2040 arg1 = reinterpret_cast< char * >(buf1);
2041 result = (Agraph_t *)read((char const *)arg1);
2042 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agraph_t, 0 | 0); argvi++ ;
2043 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
2044 XSRETURN(argvi);
2045 fail:
2046 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
2048 }
2049}
2050
2051
2053 {
2054 FILE *arg1 = (FILE *) 0 ;
2055 void *argp1 = 0 ;
2056 int res1 = 0 ;
2057 int argvi = 0;
2058 Agraph_t *result = 0 ;
2059 dXSARGS;
2060
2061 if ((items < 1) || (items > 1)) {
2062 SWIG_croak("Usage: read(f);");
2063 }
2064 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_FILE, 0 | 0 );
2065 if (!SWIG_IsOK(res1)) {
2066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "read" "', argument " "1"" of type '" "FILE *""'");
2067 }
2068 arg1 = reinterpret_cast< FILE * >(argp1);
2069 result = (Agraph_t *)read(arg1);
2070 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agraph_t, 0 | 0); argvi++ ;
2071
2072 XSRETURN(argvi);
2073 fail:
2074
2076 }
2077}
2078
2079
2081 dXSARGS;
2082
2083 {
2084 unsigned long _index = 0;
2085 SWIG_TypeRank _rank = 0;
2086 if (items == 1) {
2087 SWIG_TypeRank _ranki = 0;
2088 SWIG_TypeRank _rankm = 0;
2089 SWIG_TypeRank _pi = 1;
2090 int _v = 0;
2091 {
2092 void *vptr = 0;
2093 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_FILE, 0);
2094 _v = SWIG_CheckState(res);
2095 }
2096 if (!_v) goto check_1;
2097 _ranki += _v*_pi;
2098 _rankm += _pi;
2099 _pi *= SWIG_MAXCASTRANK;
2100 if (!_index || (_ranki < _rank)) {
2101 _rank = _ranki; _index = 1;
2102 if (_rank == _rankm) goto dispatch;
2103 }
2104 }
2105 check_1:
2106
2107 if (items == 1) {
2108 SWIG_TypeRank _ranki = 0;
2109 SWIG_TypeRank _rankm = 0;
2110 SWIG_TypeRank _pi = 1;
2111 int _v = 0;
2112 {
2113 int res = SWIG_AsCharPtrAndSize(ST(0), 0, NULL, 0);
2114 _v = SWIG_CheckState(res);
2115 }
2116 if (!_v) goto check_2;
2117 _ranki += _v*_pi;
2118 _rankm += _pi;
2119 _pi *= SWIG_MAXCASTRANK;
2120 if (!_index || (_ranki < _rank)) {
2121 _rank = _ranki; _index = 2;
2122 if (_rank == _rankm) goto dispatch;
2123 }
2124 }
2125 check_2:
2126
2127 dispatch:
2128 switch(_index) {
2129 case 1:
2130 PUSHMARK(MARK); SWIG_CALLXS(_wrap_read__SWIG_1); return;
2131 case 2:
2132 PUSHMARK(MARK); SWIG_CALLXS(_wrap_read__SWIG_0); return;
2133 }
2134 }
2135
2136 croak("No matching function for overloaded 'read'");
2137 XSRETURN(0);
2138}
2139
2140
2142 {
2143 Agraph_t *arg1 = (Agraph_t *) 0 ;
2144 char *arg2 = (char *) 0 ;
2145 void *argp1 = 0 ;
2146 int res1 = 0 ;
2147 int res2 ;
2148 char *buf2 = 0 ;
2149 int alloc2 = 0 ;
2150 int argvi = 0;
2151 Agraph_t *result = 0 ;
2152 dXSARGS;
2153
2154 if ((items < 2) || (items > 2)) {
2155 SWIG_croak("Usage: graph(g,name);");
2156 }
2157 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
2158 if (!SWIG_IsOK(res1)) {
2159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "graph" "', argument " "1"" of type '" "Agraph_t *""'");
2160 }
2161 arg1 = reinterpret_cast< Agraph_t * >(argp1);
2162 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2163 if (!SWIG_IsOK(res2)) {
2164 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "graph" "', argument " "2"" of type '" "char *""'");
2165 }
2166 arg2 = reinterpret_cast< char * >(buf2);
2167 result = (Agraph_t *)graph(arg1,arg2);
2168 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agraph_t, 0 | 0); argvi++ ;
2169
2170 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2171 XSRETURN(argvi);
2172 fail:
2173
2174 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2176 }
2177}
2178
2179
2181 dXSARGS;
2182
2183 {
2184 unsigned long _index = 0;
2185 SWIG_TypeRank _rank = 0;
2186 if (items == 1) {
2187 SWIG_TypeRank _ranki = 0;
2188 SWIG_TypeRank _rankm = 0;
2189 SWIG_TypeRank _pi = 1;
2190 int _v = 0;
2191 {
2192 int res = SWIG_AsCharPtrAndSize(ST(0), 0, NULL, 0);
2193 _v = SWIG_CheckState(res);
2194 }
2195 if (!_v) goto check_1;
2196 _ranki += _v*_pi;
2197 _rankm += _pi;
2198 _pi *= SWIG_MAXCASTRANK;
2199 if (!_index || (_ranki < _rank)) {
2200 _rank = _ranki; _index = 1;
2201 if (_rank == _rankm) goto dispatch;
2202 }
2203 }
2204 check_1:
2205
2206 if (items == 2) {
2207 SWIG_TypeRank _ranki = 0;
2208 SWIG_TypeRank _rankm = 0;
2209 SWIG_TypeRank _pi = 1;
2210 int _v = 0;
2211 {
2212 void *vptr = 0;
2213 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agraph_t, 0);
2214 _v = SWIG_CheckState(res);
2215 }
2216 if (!_v) goto check_2;
2217 _ranki += _v*_pi;
2218 _rankm += _pi;
2219 _pi *= SWIG_MAXCASTRANK;
2220 {
2221 int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
2222 _v = SWIG_CheckState(res);
2223 }
2224 if (!_v) goto check_2;
2225 _ranki += _v*_pi;
2226 _rankm += _pi;
2227 _pi *= SWIG_MAXCASTRANK;
2228 if (!_index || (_ranki < _rank)) {
2229 _rank = _ranki; _index = 2;
2230 if (_rank == _rankm) goto dispatch;
2231 }
2232 }
2233 check_2:
2234
2235 dispatch:
2236 switch(_index) {
2237 case 1:
2238 PUSHMARK(MARK); SWIG_CALLXS(_wrap_graph__SWIG_0); return;
2239 case 2:
2240 PUSHMARK(MARK); SWIG_CALLXS(_wrap_graph__SWIG_1); return;
2241 }
2242 }
2243
2244 croak("No matching function for overloaded 'graph'");
2245 XSRETURN(0);
2246}
2247
2248
2250 {
2251 Agraph_t *arg1 = (Agraph_t *) 0 ;
2252 char *arg2 = (char *) 0 ;
2253 void *argp1 = 0 ;
2254 int res1 = 0 ;
2255 int res2 ;
2256 char *buf2 = 0 ;
2257 int alloc2 = 0 ;
2258 int argvi = 0;
2259 Agnode_t *result = 0 ;
2260 dXSARGS;
2261
2262 if ((items < 2) || (items > 2)) {
2263 SWIG_croak("Usage: node(g,name);");
2264 }
2265 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
2266 if (!SWIG_IsOK(res1)) {
2267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "node" "', argument " "1"" of type '" "Agraph_t *""'");
2268 }
2269 arg1 = reinterpret_cast< Agraph_t * >(argp1);
2270 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2271 if (!SWIG_IsOK(res2)) {
2272 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "node" "', argument " "2"" of type '" "char *""'");
2273 }
2274 arg2 = reinterpret_cast< char * >(buf2);
2275 result = (Agnode_t *)node(arg1,arg2);
2276 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agnode_t, 0 | 0); argvi++ ;
2277
2278 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2279 XSRETURN(argvi);
2280 fail:
2281
2282 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2284 }
2285}
2286
2287
2289 {
2290 Agnode_t *arg1 = (Agnode_t *) 0 ;
2291 Agnode_t *arg2 = (Agnode_t *) 0 ;
2292 void *argp1 = 0 ;
2293 int res1 = 0 ;
2294 void *argp2 = 0 ;
2295 int res2 = 0 ;
2296 int argvi = 0;
2297 Agedge_t *result = 0 ;
2298 dXSARGS;
2299
2300 if ((items < 2) || (items > 2)) {
2301 SWIG_croak("Usage: edge(t,h);");
2302 }
2303 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
2304 if (!SWIG_IsOK(res1)) {
2305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "edge" "', argument " "1"" of type '" "Agnode_t *""'");
2306 }
2307 arg1 = reinterpret_cast< Agnode_t * >(argp1);
2308 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Agnode_t, 0 | 0 );
2309 if (!SWIG_IsOK(res2)) {
2310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "edge" "', argument " "2"" of type '" "Agnode_t *""'");
2311 }
2312 arg2 = reinterpret_cast< Agnode_t * >(argp2);
2313 result = (Agedge_t *)edge(arg1,arg2);
2314 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agedge_t, 0 | 0); argvi++ ;
2315
2316
2317 XSRETURN(argvi);
2318 fail:
2319
2320
2322 }
2323}
2324
2325
2327 {
2328 Agnode_t *arg1 = (Agnode_t *) 0 ;
2329 char *arg2 = (char *) 0 ;
2330 void *argp1 = 0 ;
2331 int res1 = 0 ;
2332 int res2 ;
2333 char *buf2 = 0 ;
2334 int alloc2 = 0 ;
2335 int argvi = 0;
2336 Agedge_t *result = 0 ;
2337 dXSARGS;
2338
2339 if ((items < 2) || (items > 2)) {
2340 SWIG_croak("Usage: edge(t,hname);");
2341 }
2342 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
2343 if (!SWIG_IsOK(res1)) {
2344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "edge" "', argument " "1"" of type '" "Agnode_t *""'");
2345 }
2346 arg1 = reinterpret_cast< Agnode_t * >(argp1);
2347 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2348 if (!SWIG_IsOK(res2)) {
2349 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "edge" "', argument " "2"" of type '" "char *""'");
2350 }
2351 arg2 = reinterpret_cast< char * >(buf2);
2352 result = (Agedge_t *)edge(arg1,arg2);
2353 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agedge_t, 0 | 0); argvi++ ;
2354
2355 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2356 XSRETURN(argvi);
2357 fail:
2358
2359 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2361 }
2362}
2363
2364
2366 {
2367 char *arg1 = (char *) 0 ;
2368 Agnode_t *arg2 = (Agnode_t *) 0 ;
2369 int res1 ;
2370 char *buf1 = 0 ;
2371 int alloc1 = 0 ;
2372 void *argp2 = 0 ;
2373 int res2 = 0 ;
2374 int argvi = 0;
2375 Agedge_t *result = 0 ;
2376 dXSARGS;
2377
2378 if ((items < 2) || (items > 2)) {
2379 SWIG_croak("Usage: edge(tname,h);");
2380 }
2381 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2382 if (!SWIG_IsOK(res1)) {
2383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "edge" "', argument " "1"" of type '" "char *""'");
2384 }
2385 arg1 = reinterpret_cast< char * >(buf1);
2386 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Agnode_t, 0 | 0 );
2387 if (!SWIG_IsOK(res2)) {
2388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "edge" "', argument " "2"" of type '" "Agnode_t *""'");
2389 }
2390 arg2 = reinterpret_cast< Agnode_t * >(argp2);
2391 result = (Agedge_t *)edge(arg1,arg2);
2392 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agedge_t, 0 | 0); argvi++ ;
2393 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
2394
2395 XSRETURN(argvi);
2396 fail:
2397 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
2398
2400 }
2401}
2402
2403
2405 {
2406 Agraph_t *arg1 = (Agraph_t *) 0 ;
2407 char *arg2 = (char *) 0 ;
2408 char *arg3 = (char *) 0 ;
2409 void *argp1 = 0 ;
2410 int res1 = 0 ;
2411 int res2 ;
2412 char *buf2 = 0 ;
2413 int alloc2 = 0 ;
2414 int res3 ;
2415 char *buf3 = 0 ;
2416 int alloc3 = 0 ;
2417 int argvi = 0;
2418 Agedge_t *result = 0 ;
2419 dXSARGS;
2420
2421 if ((items < 3) || (items > 3)) {
2422 SWIG_croak("Usage: edge(g,tname,hname);");
2423 }
2424 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
2425 if (!SWIG_IsOK(res1)) {
2426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "edge" "', argument " "1"" of type '" "Agraph_t *""'");
2427 }
2428 arg1 = reinterpret_cast< Agraph_t * >(argp1);
2429 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2430 if (!SWIG_IsOK(res2)) {
2431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "edge" "', argument " "2"" of type '" "char *""'");
2432 }
2433 arg2 = reinterpret_cast< char * >(buf2);
2434 res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
2435 if (!SWIG_IsOK(res3)) {
2436 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "edge" "', argument " "3"" of type '" "char *""'");
2437 }
2438 arg3 = reinterpret_cast< char * >(buf3);
2439 result = (Agedge_t *)edge(arg1,arg2,arg3);
2440 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agedge_t, 0 | 0); argvi++ ;
2441
2442 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2443 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
2444 XSRETURN(argvi);
2445 fail:
2446
2447 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2448 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
2450 }
2451}
2452
2453
2455 dXSARGS;
2456
2457 {
2458 unsigned long _index = 0;
2459 SWIG_TypeRank _rank = 0;
2460 if (items == 2) {
2461 SWIG_TypeRank _ranki = 0;
2462 SWIG_TypeRank _rankm = 0;
2463 SWIG_TypeRank _pi = 1;
2464 int _v = 0;
2465 {
2466 void *vptr = 0;
2467 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agnode_t, 0);
2468 _v = SWIG_CheckState(res);
2469 }
2470 if (!_v) goto check_1;
2471 _ranki += _v*_pi;
2472 _rankm += _pi;
2473 _pi *= SWIG_MAXCASTRANK;
2474 {
2475 void *vptr = 0;
2476 int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_Agnode_t, 0);
2477 _v = SWIG_CheckState(res);
2478 }
2479 if (!_v) goto check_1;
2480 _ranki += _v*_pi;
2481 _rankm += _pi;
2482 _pi *= SWIG_MAXCASTRANK;
2483 if (!_index || (_ranki < _rank)) {
2484 _rank = _ranki; _index = 1;
2485 if (_rank == _rankm) goto dispatch;
2486 }
2487 }
2488 check_1:
2489
2490 if (items == 2) {
2491 SWIG_TypeRank _ranki = 0;
2492 SWIG_TypeRank _rankm = 0;
2493 SWIG_TypeRank _pi = 1;
2494 int _v = 0;
2495 {
2496 void *vptr = 0;
2497 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agnode_t, 0);
2498 _v = SWIG_CheckState(res);
2499 }
2500 if (!_v) goto check_2;
2501 _ranki += _v*_pi;
2502 _rankm += _pi;
2503 _pi *= SWIG_MAXCASTRANK;
2504 {
2505 int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
2506 _v = SWIG_CheckState(res);
2507 }
2508 if (!_v) goto check_2;
2509 _ranki += _v*_pi;
2510 _rankm += _pi;
2511 _pi *= SWIG_MAXCASTRANK;
2512 if (!_index || (_ranki < _rank)) {
2513 _rank = _ranki; _index = 2;
2514 if (_rank == _rankm) goto dispatch;
2515 }
2516 }
2517 check_2:
2518
2519 if (items == 2) {
2520 SWIG_TypeRank _ranki = 0;
2521 SWIG_TypeRank _rankm = 0;
2522 SWIG_TypeRank _pi = 1;
2523 int _v = 0;
2524 {
2525 int res = SWIG_AsCharPtrAndSize(ST(0), 0, NULL, 0);
2526 _v = SWIG_CheckState(res);
2527 }
2528 if (!_v) goto check_3;
2529 _ranki += _v*_pi;
2530 _rankm += _pi;
2531 _pi *= SWIG_MAXCASTRANK;
2532 {
2533 void *vptr = 0;
2534 int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_Agnode_t, 0);
2535 _v = SWIG_CheckState(res);
2536 }
2537 if (!_v) goto check_3;
2538 _ranki += _v*_pi;
2539 _rankm += _pi;
2540 _pi *= SWIG_MAXCASTRANK;
2541 if (!_index || (_ranki < _rank)) {
2542 _rank = _ranki; _index = 3;
2543 if (_rank == _rankm) goto dispatch;
2544 }
2545 }
2546 check_3:
2547
2548 if (items == 3) {
2549 SWIG_TypeRank _ranki = 0;
2550 SWIG_TypeRank _rankm = 0;
2551 SWIG_TypeRank _pi = 1;
2552 int _v = 0;
2553 {
2554 void *vptr = 0;
2555 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agraph_t, 0);
2556 _v = SWIG_CheckState(res);
2557 }
2558 if (!_v) goto check_4;
2559 _ranki += _v*_pi;
2560 _rankm += _pi;
2561 _pi *= SWIG_MAXCASTRANK;
2562 {
2563 int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
2564 _v = SWIG_CheckState(res);
2565 }
2566 if (!_v) goto check_4;
2567 _ranki += _v*_pi;
2568 _rankm += _pi;
2569 _pi *= SWIG_MAXCASTRANK;
2570 {
2571 int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
2572 _v = SWIG_CheckState(res);
2573 }
2574 if (!_v) goto check_4;
2575 _ranki += _v*_pi;
2576 _rankm += _pi;
2577 _pi *= SWIG_MAXCASTRANK;
2578 if (!_index || (_ranki < _rank)) {
2579 _rank = _ranki; _index = 4;
2580 if (_rank == _rankm) goto dispatch;
2581 }
2582 }
2583 check_4:
2584
2585 dispatch:
2586 switch(_index) {
2587 case 1:
2588 PUSHMARK(MARK); SWIG_CALLXS(_wrap_edge__SWIG_0); return;
2589 case 2:
2590 PUSHMARK(MARK); SWIG_CALLXS(_wrap_edge__SWIG_1); return;
2591 case 3:
2592 PUSHMARK(MARK); SWIG_CALLXS(_wrap_edge__SWIG_2); return;
2593 case 4:
2594 PUSHMARK(MARK); SWIG_CALLXS(_wrap_edge__SWIG_3); return;
2595 }
2596 }
2597
2598 croak("No matching function for overloaded 'edge'");
2599 XSRETURN(0);
2600}
2601
2602
2604 {
2605 Agraph_t *arg1 = (Agraph_t *) 0 ;
2606 char *arg2 = (char *) 0 ;
2607 char *arg3 = (char *) 0 ;
2608 void *argp1 = 0 ;
2609 int res1 = 0 ;
2610 int res2 ;
2611 char *buf2 = 0 ;
2612 int alloc2 = 0 ;
2613 int res3 ;
2614 char *buf3 = 0 ;
2615 int alloc3 = 0 ;
2616 int argvi = 0;
2617 char *result = 0 ;
2618 dXSARGS;
2619
2620 if ((items < 3) || (items > 3)) {
2621 SWIG_croak("Usage: setv(g,attr,val);");
2622 }
2623 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
2624 if (!SWIG_IsOK(res1)) {
2625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setv" "', argument " "1"" of type '" "Agraph_t *""'");
2626 }
2627 arg1 = reinterpret_cast< Agraph_t * >(argp1);
2628 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2629 if (!SWIG_IsOK(res2)) {
2630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "setv" "', argument " "2"" of type '" "char *""'");
2631 }
2632 arg2 = reinterpret_cast< char * >(buf2);
2633 res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
2634 if (!SWIG_IsOK(res3)) {
2635 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "setv" "', argument " "3"" of type '" "char *""'");
2636 }
2637 arg3 = reinterpret_cast< char * >(buf3);
2638 result = (char *)setv(arg1,arg2,arg3);
2639 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2640
2641 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2642 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
2643 XSRETURN(argvi);
2644 fail:
2645
2646 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2647 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
2649 }
2650}
2651
2652
2654 {
2655 Agnode_t *arg1 = (Agnode_t *) 0 ;
2656 char *arg2 = (char *) 0 ;
2657 char *arg3 = (char *) 0 ;
2658 void *argp1 = 0 ;
2659 int res1 = 0 ;
2660 int res2 ;
2661 char *buf2 = 0 ;
2662 int alloc2 = 0 ;
2663 int res3 ;
2664 char *buf3 = 0 ;
2665 int alloc3 = 0 ;
2666 int argvi = 0;
2667 char *result = 0 ;
2668 dXSARGS;
2669
2670 if ((items < 3) || (items > 3)) {
2671 SWIG_croak("Usage: setv(n,attr,val);");
2672 }
2673 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
2674 if (!SWIG_IsOK(res1)) {
2675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setv" "', argument " "1"" of type '" "Agnode_t *""'");
2676 }
2677 arg1 = reinterpret_cast< Agnode_t * >(argp1);
2678 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2679 if (!SWIG_IsOK(res2)) {
2680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "setv" "', argument " "2"" of type '" "char *""'");
2681 }
2682 arg2 = reinterpret_cast< char * >(buf2);
2683 res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
2684 if (!SWIG_IsOK(res3)) {
2685 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "setv" "', argument " "3"" of type '" "char *""'");
2686 }
2687 arg3 = reinterpret_cast< char * >(buf3);
2688 result = (char *)setv(arg1,arg2,arg3);
2689 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2690
2691 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2692 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
2693 XSRETURN(argvi);
2694 fail:
2695
2696 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2697 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
2699 }
2700}
2701
2702
2704 {
2705 Agedge_t *arg1 = (Agedge_t *) 0 ;
2706 char *arg2 = (char *) 0 ;
2707 char *arg3 = (char *) 0 ;
2708 void *argp1 = 0 ;
2709 int res1 = 0 ;
2710 int res2 ;
2711 char *buf2 = 0 ;
2712 int alloc2 = 0 ;
2713 int res3 ;
2714 char *buf3 = 0 ;
2715 int alloc3 = 0 ;
2716 int argvi = 0;
2717 char *result = 0 ;
2718 dXSARGS;
2719
2720 if ((items < 3) || (items > 3)) {
2721 SWIG_croak("Usage: setv(e,attr,val);");
2722 }
2723 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agedge_t, 0 | 0 );
2724 if (!SWIG_IsOK(res1)) {
2725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setv" "', argument " "1"" of type '" "Agedge_t *""'");
2726 }
2727 arg1 = reinterpret_cast< Agedge_t * >(argp1);
2728 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2729 if (!SWIG_IsOK(res2)) {
2730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "setv" "', argument " "2"" of type '" "char *""'");
2731 }
2732 arg2 = reinterpret_cast< char * >(buf2);
2733 res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
2734 if (!SWIG_IsOK(res3)) {
2735 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "setv" "', argument " "3"" of type '" "char *""'");
2736 }
2737 arg3 = reinterpret_cast< char * >(buf3);
2738 result = (char *)setv(arg1,arg2,arg3);
2739 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2740
2741 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2742 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
2743 XSRETURN(argvi);
2744 fail:
2745
2746 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2747 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
2749 }
2750}
2751
2752
2754 {
2755 Agraph_t *arg1 = (Agraph_t *) 0 ;
2756 Agsym_t *arg2 = (Agsym_t *) 0 ;
2757 char *arg3 = (char *) 0 ;
2758 void *argp1 = 0 ;
2759 int res1 = 0 ;
2760 void *argp2 = 0 ;
2761 int res2 = 0 ;
2762 int res3 ;
2763 char *buf3 = 0 ;
2764 int alloc3 = 0 ;
2765 int argvi = 0;
2766 char *result = 0 ;
2767 dXSARGS;
2768
2769 if ((items < 3) || (items > 3)) {
2770 SWIG_croak("Usage: setv(g,a,val);");
2771 }
2772 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
2773 if (!SWIG_IsOK(res1)) {
2774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setv" "', argument " "1"" of type '" "Agraph_t *""'");
2775 }
2776 arg1 = reinterpret_cast< Agraph_t * >(argp1);
2777 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Agsym_t, 0 | 0 );
2778 if (!SWIG_IsOK(res2)) {
2779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "setv" "', argument " "2"" of type '" "Agsym_t *""'");
2780 }
2781 arg2 = reinterpret_cast< Agsym_t * >(argp2);
2782 res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
2783 if (!SWIG_IsOK(res3)) {
2784 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "setv" "', argument " "3"" of type '" "char *""'");
2785 }
2786 arg3 = reinterpret_cast< char * >(buf3);
2787 result = (char *)setv(arg1,arg2,arg3);
2788 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2789
2790
2791 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
2792 XSRETURN(argvi);
2793 fail:
2794
2795
2796 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
2798 }
2799}
2800
2801
2803 {
2804 Agnode_t *arg1 = (Agnode_t *) 0 ;
2805 Agsym_t *arg2 = (Agsym_t *) 0 ;
2806 char *arg3 = (char *) 0 ;
2807 void *argp1 = 0 ;
2808 int res1 = 0 ;
2809 void *argp2 = 0 ;
2810 int res2 = 0 ;
2811 int res3 ;
2812 char *buf3 = 0 ;
2813 int alloc3 = 0 ;
2814 int argvi = 0;
2815 char *result = 0 ;
2816 dXSARGS;
2817
2818 if ((items < 3) || (items > 3)) {
2819 SWIG_croak("Usage: setv(n,a,val);");
2820 }
2821 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
2822 if (!SWIG_IsOK(res1)) {
2823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setv" "', argument " "1"" of type '" "Agnode_t *""'");
2824 }
2825 arg1 = reinterpret_cast< Agnode_t * >(argp1);
2826 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Agsym_t, 0 | 0 );
2827 if (!SWIG_IsOK(res2)) {
2828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "setv" "', argument " "2"" of type '" "Agsym_t *""'");
2829 }
2830 arg2 = reinterpret_cast< Agsym_t * >(argp2);
2831 res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
2832 if (!SWIG_IsOK(res3)) {
2833 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "setv" "', argument " "3"" of type '" "char *""'");
2834 }
2835 arg3 = reinterpret_cast< char * >(buf3);
2836 result = (char *)setv(arg1,arg2,arg3);
2837 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2838
2839
2840 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
2841 XSRETURN(argvi);
2842 fail:
2843
2844
2845 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
2847 }
2848}
2849
2850
2852 {
2853 Agedge_t *arg1 = (Agedge_t *) 0 ;
2854 Agsym_t *arg2 = (Agsym_t *) 0 ;
2855 char *arg3 = (char *) 0 ;
2856 void *argp1 = 0 ;
2857 int res1 = 0 ;
2858 void *argp2 = 0 ;
2859 int res2 = 0 ;
2860 int res3 ;
2861 char *buf3 = 0 ;
2862 int alloc3 = 0 ;
2863 int argvi = 0;
2864 char *result = 0 ;
2865 dXSARGS;
2866
2867 if ((items < 3) || (items > 3)) {
2868 SWIG_croak("Usage: setv(e,a,val);");
2869 }
2870 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agedge_t, 0 | 0 );
2871 if (!SWIG_IsOK(res1)) {
2872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setv" "', argument " "1"" of type '" "Agedge_t *""'");
2873 }
2874 arg1 = reinterpret_cast< Agedge_t * >(argp1);
2875 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Agsym_t, 0 | 0 );
2876 if (!SWIG_IsOK(res2)) {
2877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "setv" "', argument " "2"" of type '" "Agsym_t *""'");
2878 }
2879 arg2 = reinterpret_cast< Agsym_t * >(argp2);
2880 res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
2881 if (!SWIG_IsOK(res3)) {
2882 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "setv" "', argument " "3"" of type '" "char *""'");
2883 }
2884 arg3 = reinterpret_cast< char * >(buf3);
2885 result = (char *)setv(arg1,arg2,arg3);
2886 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2887
2888
2889 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
2890 XSRETURN(argvi);
2891 fail:
2892
2893
2894 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
2896 }
2897}
2898
2899
2901 dXSARGS;
2902
2903 {
2904 unsigned long _index = 0;
2905 SWIG_TypeRank _rank = 0;
2906 if (items == 3) {
2907 SWIG_TypeRank _ranki = 0;
2908 SWIG_TypeRank _rankm = 0;
2909 SWIG_TypeRank _pi = 1;
2910 int _v = 0;
2911 {
2912 void *vptr = 0;
2913 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agraph_t, 0);
2914 _v = SWIG_CheckState(res);
2915 }
2916 if (!_v) goto check_1;
2917 _ranki += _v*_pi;
2918 _rankm += _pi;
2919 _pi *= SWIG_MAXCASTRANK;
2920 {
2921 void *vptr = 0;
2922 int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_Agsym_t, 0);
2923 _v = SWIG_CheckState(res);
2924 }
2925 if (!_v) goto check_1;
2926 _ranki += _v*_pi;
2927 _rankm += _pi;
2928 _pi *= SWIG_MAXCASTRANK;
2929 {
2930 int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
2931 _v = SWIG_CheckState(res);
2932 }
2933 if (!_v) goto check_1;
2934 _ranki += _v*_pi;
2935 _rankm += _pi;
2936 _pi *= SWIG_MAXCASTRANK;
2937 if (!_index || (_ranki < _rank)) {
2938 _rank = _ranki; _index = 1;
2939 if (_rank == _rankm) goto dispatch;
2940 }
2941 }
2942 check_1:
2943
2944 if (items == 3) {
2945 SWIG_TypeRank _ranki = 0;
2946 SWIG_TypeRank _rankm = 0;
2947 SWIG_TypeRank _pi = 1;
2948 int _v = 0;
2949 {
2950 void *vptr = 0;
2951 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agnode_t, 0);
2952 _v = SWIG_CheckState(res);
2953 }
2954 if (!_v) goto check_2;
2955 _ranki += _v*_pi;
2956 _rankm += _pi;
2957 _pi *= SWIG_MAXCASTRANK;
2958 {
2959 void *vptr = 0;
2960 int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_Agsym_t, 0);
2961 _v = SWIG_CheckState(res);
2962 }
2963 if (!_v) goto check_2;
2964 _ranki += _v*_pi;
2965 _rankm += _pi;
2966 _pi *= SWIG_MAXCASTRANK;
2967 {
2968 int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
2969 _v = SWIG_CheckState(res);
2970 }
2971 if (!_v) goto check_2;
2972 _ranki += _v*_pi;
2973 _rankm += _pi;
2974 _pi *= SWIG_MAXCASTRANK;
2975 if (!_index || (_ranki < _rank)) {
2976 _rank = _ranki; _index = 2;
2977 if (_rank == _rankm) goto dispatch;
2978 }
2979 }
2980 check_2:
2981
2982 if (items == 3) {
2983 SWIG_TypeRank _ranki = 0;
2984 SWIG_TypeRank _rankm = 0;
2985 SWIG_TypeRank _pi = 1;
2986 int _v = 0;
2987 {
2988 void *vptr = 0;
2989 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agedge_t, 0);
2990 _v = SWIG_CheckState(res);
2991 }
2992 if (!_v) goto check_3;
2993 _ranki += _v*_pi;
2994 _rankm += _pi;
2995 _pi *= SWIG_MAXCASTRANK;
2996 {
2997 void *vptr = 0;
2998 int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_Agsym_t, 0);
2999 _v = SWIG_CheckState(res);
3000 }
3001 if (!_v) goto check_3;
3002 _ranki += _v*_pi;
3003 _rankm += _pi;
3004 _pi *= SWIG_MAXCASTRANK;
3005 {
3006 int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
3007 _v = SWIG_CheckState(res);
3008 }
3009 if (!_v) goto check_3;
3010 _ranki += _v*_pi;
3011 _rankm += _pi;
3012 _pi *= SWIG_MAXCASTRANK;
3013 if (!_index || (_ranki < _rank)) {
3014 _rank = _ranki; _index = 3;
3015 if (_rank == _rankm) goto dispatch;
3016 }
3017 }
3018 check_3:
3019
3020 if (items == 3) {
3021 SWIG_TypeRank _ranki = 0;
3022 SWIG_TypeRank _rankm = 0;
3023 SWIG_TypeRank _pi = 1;
3024 int _v = 0;
3025 {
3026 void *vptr = 0;
3027 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agraph_t, 0);
3028 _v = SWIG_CheckState(res);
3029 }
3030 if (!_v) goto check_4;
3031 _ranki += _v*_pi;
3032 _rankm += _pi;
3033 _pi *= SWIG_MAXCASTRANK;
3034 {
3035 int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
3036 _v = SWIG_CheckState(res);
3037 }
3038 if (!_v) goto check_4;
3039 _ranki += _v*_pi;
3040 _rankm += _pi;
3041 _pi *= SWIG_MAXCASTRANK;
3042 {
3043 int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
3044 _v = SWIG_CheckState(res);
3045 }
3046 if (!_v) goto check_4;
3047 _ranki += _v*_pi;
3048 _rankm += _pi;
3049 _pi *= SWIG_MAXCASTRANK;
3050 if (!_index || (_ranki < _rank)) {
3051 _rank = _ranki; _index = 4;
3052 if (_rank == _rankm) goto dispatch;
3053 }
3054 }
3055 check_4:
3056
3057 if (items == 3) {
3058 SWIG_TypeRank _ranki = 0;
3059 SWIG_TypeRank _rankm = 0;
3060 SWIG_TypeRank _pi = 1;
3061 int _v = 0;
3062 {
3063 void *vptr = 0;
3064 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agnode_t, 0);
3065 _v = SWIG_CheckState(res);
3066 }
3067 if (!_v) goto check_5;
3068 _ranki += _v*_pi;
3069 _rankm += _pi;
3070 _pi *= SWIG_MAXCASTRANK;
3071 {
3072 int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
3073 _v = SWIG_CheckState(res);
3074 }
3075 if (!_v) goto check_5;
3076 _ranki += _v*_pi;
3077 _rankm += _pi;
3078 _pi *= SWIG_MAXCASTRANK;
3079 {
3080 int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
3081 _v = SWIG_CheckState(res);
3082 }
3083 if (!_v) goto check_5;
3084 _ranki += _v*_pi;
3085 _rankm += _pi;
3086 _pi *= SWIG_MAXCASTRANK;
3087 if (!_index || (_ranki < _rank)) {
3088 _rank = _ranki; _index = 5;
3089 if (_rank == _rankm) goto dispatch;
3090 }
3091 }
3092 check_5:
3093
3094 if (items == 3) {
3095 SWIG_TypeRank _ranki = 0;
3096 SWIG_TypeRank _rankm = 0;
3097 SWIG_TypeRank _pi = 1;
3098 int _v = 0;
3099 {
3100 void *vptr = 0;
3101 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agedge_t, 0);
3102 _v = SWIG_CheckState(res);
3103 }
3104 if (!_v) goto check_6;
3105 _ranki += _v*_pi;
3106 _rankm += _pi;
3107 _pi *= SWIG_MAXCASTRANK;
3108 {
3109 int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
3110 _v = SWIG_CheckState(res);
3111 }
3112 if (!_v) goto check_6;
3113 _ranki += _v*_pi;
3114 _rankm += _pi;
3115 _pi *= SWIG_MAXCASTRANK;
3116 {
3117 int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
3118 _v = SWIG_CheckState(res);
3119 }
3120 if (!_v) goto check_6;
3121 _ranki += _v*_pi;
3122 _rankm += _pi;
3123 _pi *= SWIG_MAXCASTRANK;
3124 if (!_index || (_ranki < _rank)) {
3125 _rank = _ranki; _index = 6;
3126 if (_rank == _rankm) goto dispatch;
3127 }
3128 }
3129 check_6:
3130
3131 dispatch:
3132 switch(_index) {
3133 case 1:
3134 PUSHMARK(MARK); SWIG_CALLXS(_wrap_setv__SWIG_3); return;
3135 case 2:
3136 PUSHMARK(MARK); SWIG_CALLXS(_wrap_setv__SWIG_4); return;
3137 case 3:
3138 PUSHMARK(MARK); SWIG_CALLXS(_wrap_setv__SWIG_5); return;
3139 case 4:
3140 PUSHMARK(MARK); SWIG_CALLXS(_wrap_setv__SWIG_0); return;
3141 case 5:
3142 PUSHMARK(MARK); SWIG_CALLXS(_wrap_setv__SWIG_1); return;
3143 case 6:
3144 PUSHMARK(MARK); SWIG_CALLXS(_wrap_setv__SWIG_2); return;
3145 }
3146 }
3147
3148 croak("No matching function for overloaded 'setv'");
3149 XSRETURN(0);
3150}
3151
3152
3154 {
3155 Agraph_t *arg1 = (Agraph_t *) 0 ;
3156 char *arg2 = (char *) 0 ;
3157 void *argp1 = 0 ;
3158 int res1 = 0 ;
3159 int res2 ;
3160 char *buf2 = 0 ;
3161 int alloc2 = 0 ;
3162 int argvi = 0;
3163 char *result = 0 ;
3164 dXSARGS;
3165
3166 if ((items < 2) || (items > 2)) {
3167 SWIG_croak("Usage: getv(g,attr);");
3168 }
3169 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
3170 if (!SWIG_IsOK(res1)) {
3171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getv" "', argument " "1"" of type '" "Agraph_t *""'");
3172 }
3173 arg1 = reinterpret_cast< Agraph_t * >(argp1);
3174 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
3175 if (!SWIG_IsOK(res2)) {
3176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getv" "', argument " "2"" of type '" "char *""'");
3177 }
3178 arg2 = reinterpret_cast< char * >(buf2);
3179 result = (char *)getv(arg1,arg2);
3180 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3181
3182 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3183 XSRETURN(argvi);
3184 fail:
3185
3186 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3188 }
3189}
3190
3191
3193 {
3194 Agnode_t *arg1 = (Agnode_t *) 0 ;
3195 char *arg2 = (char *) 0 ;
3196 void *argp1 = 0 ;
3197 int res1 = 0 ;
3198 int res2 ;
3199 char *buf2 = 0 ;
3200 int alloc2 = 0 ;
3201 int argvi = 0;
3202 char *result = 0 ;
3203 dXSARGS;
3204
3205 if ((items < 2) || (items > 2)) {
3206 SWIG_croak("Usage: getv(n,attr);");
3207 }
3208 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
3209 if (!SWIG_IsOK(res1)) {
3210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getv" "', argument " "1"" of type '" "Agnode_t *""'");
3211 }
3212 arg1 = reinterpret_cast< Agnode_t * >(argp1);
3213 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
3214 if (!SWIG_IsOK(res2)) {
3215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getv" "', argument " "2"" of type '" "char *""'");
3216 }
3217 arg2 = reinterpret_cast< char * >(buf2);
3218 result = (char *)getv(arg1,arg2);
3219 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3220
3221 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3222 XSRETURN(argvi);
3223 fail:
3224
3225 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3227 }
3228}
3229
3230
3232 {
3233 Agedge_t *arg1 = (Agedge_t *) 0 ;
3234 char *arg2 = (char *) 0 ;
3235 void *argp1 = 0 ;
3236 int res1 = 0 ;
3237 int res2 ;
3238 char *buf2 = 0 ;
3239 int alloc2 = 0 ;
3240 int argvi = 0;
3241 char *result = 0 ;
3242 dXSARGS;
3243
3244 if ((items < 2) || (items > 2)) {
3245 SWIG_croak("Usage: getv(e,attr);");
3246 }
3247 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agedge_t, 0 | 0 );
3248 if (!SWIG_IsOK(res1)) {
3249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getv" "', argument " "1"" of type '" "Agedge_t *""'");
3250 }
3251 arg1 = reinterpret_cast< Agedge_t * >(argp1);
3252 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
3253 if (!SWIG_IsOK(res2)) {
3254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getv" "', argument " "2"" of type '" "char *""'");
3255 }
3256 arg2 = reinterpret_cast< char * >(buf2);
3257 result = (char *)getv(arg1,arg2);
3258 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3259
3260 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3261 XSRETURN(argvi);
3262 fail:
3263
3264 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3266 }
3267}
3268
3269
3271 {
3272 Agraph_t *arg1 = (Agraph_t *) 0 ;
3273 Agsym_t *arg2 = (Agsym_t *) 0 ;
3274 void *argp1 = 0 ;
3275 int res1 = 0 ;
3276 void *argp2 = 0 ;
3277 int res2 = 0 ;
3278 int argvi = 0;
3279 char *result = 0 ;
3280 dXSARGS;
3281
3282 if ((items < 2) || (items > 2)) {
3283 SWIG_croak("Usage: getv(g,a);");
3284 }
3285 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
3286 if (!SWIG_IsOK(res1)) {
3287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getv" "', argument " "1"" of type '" "Agraph_t *""'");
3288 }
3289 arg1 = reinterpret_cast< Agraph_t * >(argp1);
3290 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Agsym_t, 0 | 0 );
3291 if (!SWIG_IsOK(res2)) {
3292 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getv" "', argument " "2"" of type '" "Agsym_t *""'");
3293 }
3294 arg2 = reinterpret_cast< Agsym_t * >(argp2);
3295 result = (char *)getv(arg1,arg2);
3296 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3297
3298
3299 XSRETURN(argvi);
3300 fail:
3301
3302
3304 }
3305}
3306
3307
3309 {
3310 Agnode_t *arg1 = (Agnode_t *) 0 ;
3311 Agsym_t *arg2 = (Agsym_t *) 0 ;
3312 void *argp1 = 0 ;
3313 int res1 = 0 ;
3314 void *argp2 = 0 ;
3315 int res2 = 0 ;
3316 int argvi = 0;
3317 char *result = 0 ;
3318 dXSARGS;
3319
3320 if ((items < 2) || (items > 2)) {
3321 SWIG_croak("Usage: getv(n,a);");
3322 }
3323 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
3324 if (!SWIG_IsOK(res1)) {
3325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getv" "', argument " "1"" of type '" "Agnode_t *""'");
3326 }
3327 arg1 = reinterpret_cast< Agnode_t * >(argp1);
3328 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Agsym_t, 0 | 0 );
3329 if (!SWIG_IsOK(res2)) {
3330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getv" "', argument " "2"" of type '" "Agsym_t *""'");
3331 }
3332 arg2 = reinterpret_cast< Agsym_t * >(argp2);
3333 result = (char *)getv(arg1,arg2);
3334 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3335
3336
3337 XSRETURN(argvi);
3338 fail:
3339
3340
3342 }
3343}
3344
3345
3347 {
3348 Agedge_t *arg1 = (Agedge_t *) 0 ;
3349 Agsym_t *arg2 = (Agsym_t *) 0 ;
3350 void *argp1 = 0 ;
3351 int res1 = 0 ;
3352 void *argp2 = 0 ;
3353 int res2 = 0 ;
3354 int argvi = 0;
3355 char *result = 0 ;
3356 dXSARGS;
3357
3358 if ((items < 2) || (items > 2)) {
3359 SWIG_croak("Usage: getv(e,a);");
3360 }
3361 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agedge_t, 0 | 0 );
3362 if (!SWIG_IsOK(res1)) {
3363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getv" "', argument " "1"" of type '" "Agedge_t *""'");
3364 }
3365 arg1 = reinterpret_cast< Agedge_t * >(argp1);
3366 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Agsym_t, 0 | 0 );
3367 if (!SWIG_IsOK(res2)) {
3368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getv" "', argument " "2"" of type '" "Agsym_t *""'");
3369 }
3370 arg2 = reinterpret_cast< Agsym_t * >(argp2);
3371 result = (char *)getv(arg1,arg2);
3372 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3373
3374
3375 XSRETURN(argvi);
3376 fail:
3377
3378
3380 }
3381}
3382
3383
3385 dXSARGS;
3386
3387 {
3388 unsigned long _index = 0;
3389 SWIG_TypeRank _rank = 0;
3390 if (items == 2) {
3391 SWIG_TypeRank _ranki = 0;
3392 SWIG_TypeRank _rankm = 0;
3393 SWIG_TypeRank _pi = 1;
3394 int _v = 0;
3395 {
3396 void *vptr = 0;
3397 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agraph_t, 0);
3398 _v = SWIG_CheckState(res);
3399 }
3400 if (!_v) goto check_1;
3401 _ranki += _v*_pi;
3402 _rankm += _pi;
3403 _pi *= SWIG_MAXCASTRANK;
3404 {
3405 void *vptr = 0;
3406 int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_Agsym_t, 0);
3407 _v = SWIG_CheckState(res);
3408 }
3409 if (!_v) goto check_1;
3410 _ranki += _v*_pi;
3411 _rankm += _pi;
3412 _pi *= SWIG_MAXCASTRANK;
3413 if (!_index || (_ranki < _rank)) {
3414 _rank = _ranki; _index = 1;
3415 if (_rank == _rankm) goto dispatch;
3416 }
3417 }
3418 check_1:
3419
3420 if (items == 2) {
3421 SWIG_TypeRank _ranki = 0;
3422 SWIG_TypeRank _rankm = 0;
3423 SWIG_TypeRank _pi = 1;
3424 int _v = 0;
3425 {
3426 void *vptr = 0;
3427 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agnode_t, 0);
3428 _v = SWIG_CheckState(res);
3429 }
3430 if (!_v) goto check_2;
3431 _ranki += _v*_pi;
3432 _rankm += _pi;
3433 _pi *= SWIG_MAXCASTRANK;
3434 {
3435 void *vptr = 0;
3436 int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_Agsym_t, 0);
3437 _v = SWIG_CheckState(res);
3438 }
3439 if (!_v) goto check_2;
3440 _ranki += _v*_pi;
3441 _rankm += _pi;
3442 _pi *= SWIG_MAXCASTRANK;
3443 if (!_index || (_ranki < _rank)) {
3444 _rank = _ranki; _index = 2;
3445 if (_rank == _rankm) goto dispatch;
3446 }
3447 }
3448 check_2:
3449
3450 if (items == 2) {
3451 SWIG_TypeRank _ranki = 0;
3452 SWIG_TypeRank _rankm = 0;
3453 SWIG_TypeRank _pi = 1;
3454 int _v = 0;
3455 {
3456 void *vptr = 0;
3457 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agedge_t, 0);
3458 _v = SWIG_CheckState(res);
3459 }
3460 if (!_v) goto check_3;
3461 _ranki += _v*_pi;
3462 _rankm += _pi;
3463 _pi *= SWIG_MAXCASTRANK;
3464 {
3465 void *vptr = 0;
3466 int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_Agsym_t, 0);
3467 _v = SWIG_CheckState(res);
3468 }
3469 if (!_v) goto check_3;
3470 _ranki += _v*_pi;
3471 _rankm += _pi;
3472 _pi *= SWIG_MAXCASTRANK;
3473 if (!_index || (_ranki < _rank)) {
3474 _rank = _ranki; _index = 3;
3475 if (_rank == _rankm) goto dispatch;
3476 }
3477 }
3478 check_3:
3479
3480 if (items == 2) {
3481 SWIG_TypeRank _ranki = 0;
3482 SWIG_TypeRank _rankm = 0;
3483 SWIG_TypeRank _pi = 1;
3484 int _v = 0;
3485 {
3486 void *vptr = 0;
3487 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agraph_t, 0);
3488 _v = SWIG_CheckState(res);
3489 }
3490 if (!_v) goto check_4;
3491 _ranki += _v*_pi;
3492 _rankm += _pi;
3493 _pi *= SWIG_MAXCASTRANK;
3494 {
3495 int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
3496 _v = SWIG_CheckState(res);
3497 }
3498 if (!_v) goto check_4;
3499 _ranki += _v*_pi;
3500 _rankm += _pi;
3501 _pi *= SWIG_MAXCASTRANK;
3502 if (!_index || (_ranki < _rank)) {
3503 _rank = _ranki; _index = 4;
3504 if (_rank == _rankm) goto dispatch;
3505 }
3506 }
3507 check_4:
3508
3509 if (items == 2) {
3510 SWIG_TypeRank _ranki = 0;
3511 SWIG_TypeRank _rankm = 0;
3512 SWIG_TypeRank _pi = 1;
3513 int _v = 0;
3514 {
3515 void *vptr = 0;
3516 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agnode_t, 0);
3517 _v = SWIG_CheckState(res);
3518 }
3519 if (!_v) goto check_5;
3520 _ranki += _v*_pi;
3521 _rankm += _pi;
3522 _pi *= SWIG_MAXCASTRANK;
3523 {
3524 int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
3525 _v = SWIG_CheckState(res);
3526 }
3527 if (!_v) goto check_5;
3528 _ranki += _v*_pi;
3529 _rankm += _pi;
3530 _pi *= SWIG_MAXCASTRANK;
3531 if (!_index || (_ranki < _rank)) {
3532 _rank = _ranki; _index = 5;
3533 if (_rank == _rankm) goto dispatch;
3534 }
3535 }
3536 check_5:
3537
3538 if (items == 2) {
3539 SWIG_TypeRank _ranki = 0;
3540 SWIG_TypeRank _rankm = 0;
3541 SWIG_TypeRank _pi = 1;
3542 int _v = 0;
3543 {
3544 void *vptr = 0;
3545 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agedge_t, 0);
3546 _v = SWIG_CheckState(res);
3547 }
3548 if (!_v) goto check_6;
3549 _ranki += _v*_pi;
3550 _rankm += _pi;
3551 _pi *= SWIG_MAXCASTRANK;
3552 {
3553 int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
3554 _v = SWIG_CheckState(res);
3555 }
3556 if (!_v) goto check_6;
3557 _ranki += _v*_pi;
3558 _rankm += _pi;
3559 _pi *= SWIG_MAXCASTRANK;
3560 if (!_index || (_ranki < _rank)) {
3561 _rank = _ranki; _index = 6;
3562 if (_rank == _rankm) goto dispatch;
3563 }
3564 }
3565 check_6:
3566
3567 dispatch:
3568 switch(_index) {
3569 case 1:
3570 PUSHMARK(MARK); SWIG_CALLXS(_wrap_getv__SWIG_3); return;
3571 case 2:
3572 PUSHMARK(MARK); SWIG_CALLXS(_wrap_getv__SWIG_4); return;
3573 case 3:
3574 PUSHMARK(MARK); SWIG_CALLXS(_wrap_getv__SWIG_5); return;
3575 case 4:
3576 PUSHMARK(MARK); SWIG_CALLXS(_wrap_getv__SWIG_0); return;
3577 case 5:
3578 PUSHMARK(MARK); SWIG_CALLXS(_wrap_getv__SWIG_1); return;
3579 case 6:
3580 PUSHMARK(MARK); SWIG_CALLXS(_wrap_getv__SWIG_2); return;
3581 }
3582 }
3583
3584 croak("No matching function for overloaded 'getv'");
3585 XSRETURN(0);
3586}
3587
3588
3590 {
3591 Agraph_t *arg1 = (Agraph_t *) 0 ;
3592 void *argp1 = 0 ;
3593 int res1 = 0 ;
3594 int argvi = 0;
3595 char *result = 0 ;
3596 dXSARGS;
3597
3598 if ((items < 1) || (items > 1)) {
3599 SWIG_croak("Usage: nameof(g);");
3600 }
3601 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
3602 if (!SWIG_IsOK(res1)) {
3603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nameof" "', argument " "1"" of type '" "Agraph_t *""'");
3604 }
3605 arg1 = reinterpret_cast< Agraph_t * >(argp1);
3606 result = (char *)nameof(arg1);
3607 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3608
3609 XSRETURN(argvi);
3610 fail:
3611
3613 }
3614}
3615
3616
3618 {
3619 Agnode_t *arg1 = (Agnode_t *) 0 ;
3620 void *argp1 = 0 ;
3621 int res1 = 0 ;
3622 int argvi = 0;
3623 char *result = 0 ;
3624 dXSARGS;
3625
3626 if ((items < 1) || (items > 1)) {
3627 SWIG_croak("Usage: nameof(n);");
3628 }
3629 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
3630 if (!SWIG_IsOK(res1)) {
3631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nameof" "', argument " "1"" of type '" "Agnode_t *""'");
3632 }
3633 arg1 = reinterpret_cast< Agnode_t * >(argp1);
3634 result = (char *)nameof(arg1);
3635 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3636
3637 XSRETURN(argvi);
3638 fail:
3639
3641 }
3642}
3643
3644
3646 {
3647 Agsym_t *arg1 = (Agsym_t *) 0 ;
3648 void *argp1 = 0 ;
3649 int res1 = 0 ;
3650 int argvi = 0;
3651 char *result = 0 ;
3652 dXSARGS;
3653
3654 if ((items < 1) || (items > 1)) {
3655 SWIG_croak("Usage: nameof(a);");
3656 }
3657 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agsym_t, 0 | 0 );
3658 if (!SWIG_IsOK(res1)) {
3659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nameof" "', argument " "1"" of type '" "Agsym_t *""'");
3660 }
3661 arg1 = reinterpret_cast< Agsym_t * >(argp1);
3662 result = (char *)nameof(arg1);
3663 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3664
3665 XSRETURN(argvi);
3666 fail:
3667
3669 }
3670}
3671
3672
3674 dXSARGS;
3675
3676 {
3677 unsigned long _index = 0;
3678 SWIG_TypeRank _rank = 0;
3679 if (items == 1) {
3680 SWIG_TypeRank _ranki = 0;
3681 SWIG_TypeRank _rankm = 0;
3682 SWIG_TypeRank _pi = 1;
3683 int _v = 0;
3684 {
3685 void *vptr = 0;
3686 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agraph_t, 0);
3687 _v = SWIG_CheckState(res);
3688 }
3689 if (!_v) goto check_1;
3690 _ranki += _v*_pi;
3691 _rankm += _pi;
3692 _pi *= SWIG_MAXCASTRANK;
3693 if (!_index || (_ranki < _rank)) {
3694 _rank = _ranki; _index = 1;
3695 if (_rank == _rankm) goto dispatch;
3696 }
3697 }
3698 check_1:
3699
3700 if (items == 1) {
3701 SWIG_TypeRank _ranki = 0;
3702 SWIG_TypeRank _rankm = 0;
3703 SWIG_TypeRank _pi = 1;
3704 int _v = 0;
3705 {
3706 void *vptr = 0;
3707 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agnode_t, 0);
3708 _v = SWIG_CheckState(res);
3709 }
3710 if (!_v) goto check_2;
3711 _ranki += _v*_pi;
3712 _rankm += _pi;
3713 _pi *= SWIG_MAXCASTRANK;
3714 if (!_index || (_ranki < _rank)) {
3715 _rank = _ranki; _index = 2;
3716 if (_rank == _rankm) goto dispatch;
3717 }
3718 }
3719 check_2:
3720
3721 if (items == 1) {
3722 SWIG_TypeRank _ranki = 0;
3723 SWIG_TypeRank _rankm = 0;
3724 SWIG_TypeRank _pi = 1;
3725 int _v = 0;
3726 {
3727 void *vptr = 0;
3728 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agsym_t, 0);
3729 _v = SWIG_CheckState(res);
3730 }
3731 if (!_v) goto check_3;
3732 _ranki += _v*_pi;
3733 _rankm += _pi;
3734 _pi *= SWIG_MAXCASTRANK;
3735 if (!_index || (_ranki < _rank)) {
3736 _rank = _ranki; _index = 3;
3737 if (_rank == _rankm) goto dispatch;
3738 }
3739 }
3740 check_3:
3741
3742 dispatch:
3743 switch(_index) {
3744 case 1:
3745 PUSHMARK(MARK); SWIG_CALLXS(_wrap_nameof__SWIG_0); return;
3746 case 2:
3747 PUSHMARK(MARK); SWIG_CALLXS(_wrap_nameof__SWIG_1); return;
3748 case 3:
3749 PUSHMARK(MARK); SWIG_CALLXS(_wrap_nameof__SWIG_2); return;
3750 }
3751 }
3752
3753 croak("No matching function for overloaded 'nameof'");
3754 XSRETURN(0);
3755}
3756
3757
3759 {
3760 Agraph_t *arg1 = (Agraph_t *) 0 ;
3761 char *arg2 = (char *) 0 ;
3762 void *argp1 = 0 ;
3763 int res1 = 0 ;
3764 int res2 ;
3765 char *buf2 = 0 ;
3766 int alloc2 = 0 ;
3767 int argvi = 0;
3768 Agraph_t *result = 0 ;
3769 dXSARGS;
3770
3771 if ((items < 2) || (items > 2)) {
3772 SWIG_croak("Usage: findsubg(g,name);");
3773 }
3774 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
3775 if (!SWIG_IsOK(res1)) {
3776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "findsubg" "', argument " "1"" of type '" "Agraph_t *""'");
3777 }
3778 arg1 = reinterpret_cast< Agraph_t * >(argp1);
3779 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
3780 if (!SWIG_IsOK(res2)) {
3781 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "findsubg" "', argument " "2"" of type '" "char *""'");
3782 }
3783 arg2 = reinterpret_cast< char * >(buf2);
3784 result = (Agraph_t *)findsubg(arg1,arg2);
3785 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agraph_t, 0 | 0); argvi++ ;
3786
3787 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3788 XSRETURN(argvi);
3789 fail:
3790
3791 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3793 }
3794}
3795
3796
3798 {
3799 Agraph_t *arg1 = (Agraph_t *) 0 ;
3800 char *arg2 = (char *) 0 ;
3801 void *argp1 = 0 ;
3802 int res1 = 0 ;
3803 int res2 ;
3804 char *buf2 = 0 ;
3805 int alloc2 = 0 ;
3806 int argvi = 0;
3807 Agnode_t *result = 0 ;
3808 dXSARGS;
3809
3810 if ((items < 2) || (items > 2)) {
3811 SWIG_croak("Usage: findnode(g,name);");
3812 }
3813 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
3814 if (!SWIG_IsOK(res1)) {
3815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "findnode" "', argument " "1"" of type '" "Agraph_t *""'");
3816 }
3817 arg1 = reinterpret_cast< Agraph_t * >(argp1);
3818 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
3819 if (!SWIG_IsOK(res2)) {
3820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "findnode" "', argument " "2"" of type '" "char *""'");
3821 }
3822 arg2 = reinterpret_cast< char * >(buf2);
3823 result = (Agnode_t *)findnode(arg1,arg2);
3824 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agnode_t, 0 | 0); argvi++ ;
3825
3826 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3827 XSRETURN(argvi);
3828 fail:
3829
3830 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3832 }
3833}
3834
3835
3837 {
3838 Agnode_t *arg1 = (Agnode_t *) 0 ;
3839 Agnode_t *arg2 = (Agnode_t *) 0 ;
3840 void *argp1 = 0 ;
3841 int res1 = 0 ;
3842 void *argp2 = 0 ;
3843 int res2 = 0 ;
3844 int argvi = 0;
3845 Agedge_t *result = 0 ;
3846 dXSARGS;
3847
3848 if ((items < 2) || (items > 2)) {
3849 SWIG_croak("Usage: findedge(t,h);");
3850 }
3851 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
3852 if (!SWIG_IsOK(res1)) {
3853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "findedge" "', argument " "1"" of type '" "Agnode_t *""'");
3854 }
3855 arg1 = reinterpret_cast< Agnode_t * >(argp1);
3856 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Agnode_t, 0 | 0 );
3857 if (!SWIG_IsOK(res2)) {
3858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "findedge" "', argument " "2"" of type '" "Agnode_t *""'");
3859 }
3860 arg2 = reinterpret_cast< Agnode_t * >(argp2);
3861 result = (Agedge_t *)findedge(arg1,arg2);
3862 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agedge_t, 0 | 0); argvi++ ;
3863
3864
3865 XSRETURN(argvi);
3866 fail:
3867
3868
3870 }
3871}
3872
3873
3875 {
3876 Agraph_t *arg1 = (Agraph_t *) 0 ;
3877 char *arg2 = (char *) 0 ;
3878 void *argp1 = 0 ;
3879 int res1 = 0 ;
3880 int res2 ;
3881 char *buf2 = 0 ;
3882 int alloc2 = 0 ;
3883 int argvi = 0;
3884 Agsym_t *result = 0 ;
3885 dXSARGS;
3886
3887 if ((items < 2) || (items > 2)) {
3888 SWIG_croak("Usage: findattr(g,name);");
3889 }
3890 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
3891 if (!SWIG_IsOK(res1)) {
3892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "findattr" "', argument " "1"" of type '" "Agraph_t *""'");
3893 }
3894 arg1 = reinterpret_cast< Agraph_t * >(argp1);
3895 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
3896 if (!SWIG_IsOK(res2)) {
3897 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "findattr" "', argument " "2"" of type '" "char *""'");
3898 }
3899 arg2 = reinterpret_cast< char * >(buf2);
3900 result = (Agsym_t *)findattr(arg1,arg2);
3901 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agsym_t, 0 | 0); argvi++ ;
3902
3903 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3904 XSRETURN(argvi);
3905 fail:
3906
3907 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3909 }
3910}
3911
3912
3914 {
3915 Agnode_t *arg1 = (Agnode_t *) 0 ;
3916 char *arg2 = (char *) 0 ;
3917 void *argp1 = 0 ;
3918 int res1 = 0 ;
3919 int res2 ;
3920 char *buf2 = 0 ;
3921 int alloc2 = 0 ;
3922 int argvi = 0;
3923 Agsym_t *result = 0 ;
3924 dXSARGS;
3925
3926 if ((items < 2) || (items > 2)) {
3927 SWIG_croak("Usage: findattr(n,name);");
3928 }
3929 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
3930 if (!SWIG_IsOK(res1)) {
3931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "findattr" "', argument " "1"" of type '" "Agnode_t *""'");
3932 }
3933 arg1 = reinterpret_cast< Agnode_t * >(argp1);
3934 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
3935 if (!SWIG_IsOK(res2)) {
3936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "findattr" "', argument " "2"" of type '" "char *""'");
3937 }
3938 arg2 = reinterpret_cast< char * >(buf2);
3939 result = (Agsym_t *)findattr(arg1,arg2);
3940 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agsym_t, 0 | 0); argvi++ ;
3941
3942 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3943 XSRETURN(argvi);
3944 fail:
3945
3946 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3948 }
3949}
3950
3951
3953 {
3954 Agedge_t *arg1 = (Agedge_t *) 0 ;
3955 char *arg2 = (char *) 0 ;
3956 void *argp1 = 0 ;
3957 int res1 = 0 ;
3958 int res2 ;
3959 char *buf2 = 0 ;
3960 int alloc2 = 0 ;
3961 int argvi = 0;
3962 Agsym_t *result = 0 ;
3963 dXSARGS;
3964
3965 if ((items < 2) || (items > 2)) {
3966 SWIG_croak("Usage: findattr(e,name);");
3967 }
3968 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agedge_t, 0 | 0 );
3969 if (!SWIG_IsOK(res1)) {
3970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "findattr" "', argument " "1"" of type '" "Agedge_t *""'");
3971 }
3972 arg1 = reinterpret_cast< Agedge_t * >(argp1);
3973 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
3974 if (!SWIG_IsOK(res2)) {
3975 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "findattr" "', argument " "2"" of type '" "char *""'");
3976 }
3977 arg2 = reinterpret_cast< char * >(buf2);
3978 result = (Agsym_t *)findattr(arg1,arg2);
3979 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agsym_t, 0 | 0); argvi++ ;
3980
3981 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3982 XSRETURN(argvi);
3983 fail:
3984
3985 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3987 }
3988}
3989
3990
3992 dXSARGS;
3993
3994 {
3995 unsigned long _index = 0;
3996 SWIG_TypeRank _rank = 0;
3997 if (items == 2) {
3998 SWIG_TypeRank _ranki = 0;
3999 SWIG_TypeRank _rankm = 0;
4000 SWIG_TypeRank _pi = 1;
4001 int _v = 0;
4002 {
4003 void *vptr = 0;
4004 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agraph_t, 0);
4005 _v = SWIG_CheckState(res);
4006 }
4007 if (!_v) goto check_1;
4008 _ranki += _v*_pi;
4009 _rankm += _pi;
4010 _pi *= SWIG_MAXCASTRANK;
4011 {
4012 int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
4013 _v = SWIG_CheckState(res);
4014 }
4015 if (!_v) goto check_1;
4016 _ranki += _v*_pi;
4017 _rankm += _pi;
4018 _pi *= SWIG_MAXCASTRANK;
4019 if (!_index || (_ranki < _rank)) {
4020 _rank = _ranki; _index = 1;
4021 if (_rank == _rankm) goto dispatch;
4022 }
4023 }
4024 check_1:
4025
4026 if (items == 2) {
4027 SWIG_TypeRank _ranki = 0;
4028 SWIG_TypeRank _rankm = 0;
4029 SWIG_TypeRank _pi = 1;
4030 int _v = 0;
4031 {
4032 void *vptr = 0;
4033 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agnode_t, 0);
4034 _v = SWIG_CheckState(res);
4035 }
4036 if (!_v) goto check_2;
4037 _ranki += _v*_pi;
4038 _rankm += _pi;
4039 _pi *= SWIG_MAXCASTRANK;
4040 {
4041 int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
4042 _v = SWIG_CheckState(res);
4043 }
4044 if (!_v) goto check_2;
4045 _ranki += _v*_pi;
4046 _rankm += _pi;
4047 _pi *= SWIG_MAXCASTRANK;
4048 if (!_index || (_ranki < _rank)) {
4049 _rank = _ranki; _index = 2;
4050 if (_rank == _rankm) goto dispatch;
4051 }
4052 }
4053 check_2:
4054
4055 if (items == 2) {
4056 SWIG_TypeRank _ranki = 0;
4057 SWIG_TypeRank _rankm = 0;
4058 SWIG_TypeRank _pi = 1;
4059 int _v = 0;
4060 {
4061 void *vptr = 0;
4062 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agedge_t, 0);
4063 _v = SWIG_CheckState(res);
4064 }
4065 if (!_v) goto check_3;
4066 _ranki += _v*_pi;
4067 _rankm += _pi;
4068 _pi *= SWIG_MAXCASTRANK;
4069 {
4070 int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
4071 _v = SWIG_CheckState(res);
4072 }
4073 if (!_v) goto check_3;
4074 _ranki += _v*_pi;
4075 _rankm += _pi;
4076 _pi *= SWIG_MAXCASTRANK;
4077 if (!_index || (_ranki < _rank)) {
4078 _rank = _ranki; _index = 3;
4079 if (_rank == _rankm) goto dispatch;
4080 }
4081 }
4082 check_3:
4083
4084 dispatch:
4085 switch(_index) {
4086 case 1:
4087 PUSHMARK(MARK); SWIG_CALLXS(_wrap_findattr__SWIG_0); return;
4088 case 2:
4089 PUSHMARK(MARK); SWIG_CALLXS(_wrap_findattr__SWIG_1); return;
4090 case 3:
4091 PUSHMARK(MARK); SWIG_CALLXS(_wrap_findattr__SWIG_2); return;
4092 }
4093 }
4094
4095 croak("No matching function for overloaded 'findattr'");
4096 XSRETURN(0);
4097}
4098
4099
4101 {
4102 Agedge_t *arg1 = (Agedge_t *) 0 ;
4103 void *argp1 = 0 ;
4104 int res1 = 0 ;
4105 int argvi = 0;
4106 Agnode_t *result = 0 ;
4107 dXSARGS;
4108
4109 if ((items < 1) || (items > 1)) {
4110 SWIG_croak("Usage: headof(e);");
4111 }
4112 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agedge_t, 0 | 0 );
4113 if (!SWIG_IsOK(res1)) {
4114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "headof" "', argument " "1"" of type '" "Agedge_t *""'");
4115 }
4116 arg1 = reinterpret_cast< Agedge_t * >(argp1);
4117 result = (Agnode_t *)headof(arg1);
4118 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agnode_t, 0 | 0); argvi++ ;
4119
4120 XSRETURN(argvi);
4121 fail:
4122
4124 }
4125}
4126
4127
4129 {
4130 Agedge_t *arg1 = (Agedge_t *) 0 ;
4131 void *argp1 = 0 ;
4132 int res1 = 0 ;
4133 int argvi = 0;
4134 Agnode_t *result = 0 ;
4135 dXSARGS;
4136
4137 if ((items < 1) || (items > 1)) {
4138 SWIG_croak("Usage: tailof(e);");
4139 }
4140 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agedge_t, 0 | 0 );
4141 if (!SWIG_IsOK(res1)) {
4142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tailof" "', argument " "1"" of type '" "Agedge_t *""'");
4143 }
4144 arg1 = reinterpret_cast< Agedge_t * >(argp1);
4145 result = (Agnode_t *)tailof(arg1);
4146 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agnode_t, 0 | 0); argvi++ ;
4147
4148 XSRETURN(argvi);
4149 fail:
4150
4152 }
4153}
4154
4155
4157 {
4158 Agraph_t *arg1 = (Agraph_t *) 0 ;
4159 void *argp1 = 0 ;
4160 int res1 = 0 ;
4161 int argvi = 0;
4162 Agraph_t *result = 0 ;
4163 dXSARGS;
4164
4165 if ((items < 1) || (items > 1)) {
4166 SWIG_croak("Usage: graphof(g);");
4167 }
4168 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
4169 if (!SWIG_IsOK(res1)) {
4170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "graphof" "', argument " "1"" of type '" "Agraph_t *""'");
4171 }
4172 arg1 = reinterpret_cast< Agraph_t * >(argp1);
4173 result = (Agraph_t *)graphof(arg1);
4174 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agraph_t, 0 | 0); argvi++ ;
4175
4176 XSRETURN(argvi);
4177 fail:
4178
4180 }
4181}
4182
4183
4185 {
4186 Agedge_t *arg1 = (Agedge_t *) 0 ;
4187 void *argp1 = 0 ;
4188 int res1 = 0 ;
4189 int argvi = 0;
4190 Agraph_t *result = 0 ;
4191 dXSARGS;
4192
4193 if ((items < 1) || (items > 1)) {
4194 SWIG_croak("Usage: graphof(e);");
4195 }
4196 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agedge_t, 0 | 0 );
4197 if (!SWIG_IsOK(res1)) {
4198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "graphof" "', argument " "1"" of type '" "Agedge_t *""'");
4199 }
4200 arg1 = reinterpret_cast< Agedge_t * >(argp1);
4201 result = (Agraph_t *)graphof(arg1);
4202 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agraph_t, 0 | 0); argvi++ ;
4203
4204 XSRETURN(argvi);
4205 fail:
4206
4208 }
4209}
4210
4211
4213 {
4214 Agnode_t *arg1 = (Agnode_t *) 0 ;
4215 void *argp1 = 0 ;
4216 int res1 = 0 ;
4217 int argvi = 0;
4218 Agraph_t *result = 0 ;
4219 dXSARGS;
4220
4221 if ((items < 1) || (items > 1)) {
4222 SWIG_croak("Usage: graphof(n);");
4223 }
4224 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
4225 if (!SWIG_IsOK(res1)) {
4226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "graphof" "', argument " "1"" of type '" "Agnode_t *""'");
4227 }
4228 arg1 = reinterpret_cast< Agnode_t * >(argp1);
4229 result = (Agraph_t *)graphof(arg1);
4230 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agraph_t, 0 | 0); argvi++ ;
4231
4232 XSRETURN(argvi);
4233 fail:
4234
4236 }
4237}
4238
4239
4241 dXSARGS;
4242
4243 {
4244 unsigned long _index = 0;
4245 SWIG_TypeRank _rank = 0;
4246 if (items == 1) {
4247 SWIG_TypeRank _ranki = 0;
4248 SWIG_TypeRank _rankm = 0;
4249 SWIG_TypeRank _pi = 1;
4250 int _v = 0;
4251 {
4252 void *vptr = 0;
4253 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agraph_t, 0);
4254 _v = SWIG_CheckState(res);
4255 }
4256 if (!_v) goto check_1;
4257 _ranki += _v*_pi;
4258 _rankm += _pi;
4259 _pi *= SWIG_MAXCASTRANK;
4260 if (!_index || (_ranki < _rank)) {
4261 _rank = _ranki; _index = 1;
4262 if (_rank == _rankm) goto dispatch;
4263 }
4264 }
4265 check_1:
4266
4267 if (items == 1) {
4268 SWIG_TypeRank _ranki = 0;
4269 SWIG_TypeRank _rankm = 0;
4270 SWIG_TypeRank _pi = 1;
4271 int _v = 0;
4272 {
4273 void *vptr = 0;
4274 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agedge_t, 0);
4275 _v = SWIG_CheckState(res);
4276 }
4277 if (!_v) goto check_2;
4278 _ranki += _v*_pi;
4279 _rankm += _pi;
4280 _pi *= SWIG_MAXCASTRANK;
4281 if (!_index || (_ranki < _rank)) {
4282 _rank = _ranki; _index = 2;
4283 if (_rank == _rankm) goto dispatch;
4284 }
4285 }
4286 check_2:
4287
4288 if (items == 1) {
4289 SWIG_TypeRank _ranki = 0;
4290 SWIG_TypeRank _rankm = 0;
4291 SWIG_TypeRank _pi = 1;
4292 int _v = 0;
4293 {
4294 void *vptr = 0;
4295 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agnode_t, 0);
4296 _v = SWIG_CheckState(res);
4297 }
4298 if (!_v) goto check_3;
4299 _ranki += _v*_pi;
4300 _rankm += _pi;
4301 _pi *= SWIG_MAXCASTRANK;
4302 if (!_index || (_ranki < _rank)) {
4303 _rank = _ranki; _index = 3;
4304 if (_rank == _rankm) goto dispatch;
4305 }
4306 }
4307 check_3:
4308
4309 dispatch:
4310 switch(_index) {
4311 case 1:
4312 PUSHMARK(MARK); SWIG_CALLXS(_wrap_graphof__SWIG_0); return;
4313 case 2:
4314 PUSHMARK(MARK); SWIG_CALLXS(_wrap_graphof__SWIG_1); return;
4315 case 3:
4316 PUSHMARK(MARK); SWIG_CALLXS(_wrap_graphof__SWIG_2); return;
4317 }
4318 }
4319
4320 croak("No matching function for overloaded 'graphof'");
4321 XSRETURN(0);
4322}
4323
4324
4326 {
4327 Agraph_t *arg1 = (Agraph_t *) 0 ;
4328 void *argp1 = 0 ;
4329 int res1 = 0 ;
4330 int argvi = 0;
4331 Agraph_t *result = 0 ;
4332 dXSARGS;
4333
4334 if ((items < 1) || (items > 1)) {
4335 SWIG_croak("Usage: rootof(g);");
4336 }
4337 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
4338 if (!SWIG_IsOK(res1)) {
4339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rootof" "', argument " "1"" of type '" "Agraph_t *""'");
4340 }
4341 arg1 = reinterpret_cast< Agraph_t * >(argp1);
4342 result = (Agraph_t *)rootof(arg1);
4343 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agraph_t, 0 | 0); argvi++ ;
4344
4345 XSRETURN(argvi);
4346 fail:
4347
4349 }
4350}
4351
4352
4354 {
4355 Agraph_t *arg1 = (Agraph_t *) 0 ;
4356 void *argp1 = 0 ;
4357 int res1 = 0 ;
4358 int argvi = 0;
4359 Agnode_t *result = 0 ;
4360 dXSARGS;
4361
4362 if ((items < 1) || (items > 1)) {
4363 SWIG_croak("Usage: protonode(g);");
4364 }
4365 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
4366 if (!SWIG_IsOK(res1)) {
4367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "protonode" "', argument " "1"" of type '" "Agraph_t *""'");
4368 }
4369 arg1 = reinterpret_cast< Agraph_t * >(argp1);
4370 result = (Agnode_t *)protonode(arg1);
4371 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agnode_t, 0 | 0); argvi++ ;
4372
4373 XSRETURN(argvi);
4374 fail:
4375
4377 }
4378}
4379
4380
4382 {
4383 Agraph_t *arg1 = (Agraph_t *) 0 ;
4384 void *argp1 = 0 ;
4385 int res1 = 0 ;
4386 int argvi = 0;
4387 Agedge_t *result = 0 ;
4388 dXSARGS;
4389
4390 if ((items < 1) || (items > 1)) {
4391 SWIG_croak("Usage: protoedge(g);");
4392 }
4393 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
4394 if (!SWIG_IsOK(res1)) {
4395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "protoedge" "', argument " "1"" of type '" "Agraph_t *""'");
4396 }
4397 arg1 = reinterpret_cast< Agraph_t * >(argp1);
4398 result = (Agedge_t *)protoedge(arg1);
4399 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agedge_t, 0 | 0); argvi++ ;
4400
4401 XSRETURN(argvi);
4402 fail:
4403
4405 }
4406}
4407
4408
4410 {
4411 Agraph_t *arg1 = (Agraph_t *) 0 ;
4412 void *argp1 = 0 ;
4413 int res1 = 0 ;
4414 int argvi = 0;
4415 bool result;
4416 dXSARGS;
4417
4418 if ((items < 1) || (items > 1)) {
4419 SWIG_croak("Usage: ok(g);");
4420 }
4421 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
4422 if (!SWIG_IsOK(res1)) {
4423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ok" "', argument " "1"" of type '" "Agraph_t *""'");
4424 }
4425 arg1 = reinterpret_cast< Agraph_t * >(argp1);
4426 result = (bool)ok(arg1);
4427 ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
4428
4429 XSRETURN(argvi);
4430 fail:
4431
4433 }
4434}
4435
4436
4438 {
4439 Agnode_t *arg1 = (Agnode_t *) 0 ;
4440 void *argp1 = 0 ;
4441 int res1 = 0 ;
4442 int argvi = 0;
4443 bool result;
4444 dXSARGS;
4445
4446 if ((items < 1) || (items > 1)) {
4447 SWIG_croak("Usage: ok(n);");
4448 }
4449 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
4450 if (!SWIG_IsOK(res1)) {
4451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ok" "', argument " "1"" of type '" "Agnode_t *""'");
4452 }
4453 arg1 = reinterpret_cast< Agnode_t * >(argp1);
4454 result = (bool)ok(arg1);
4455 ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
4456
4457 XSRETURN(argvi);
4458 fail:
4459
4461 }
4462}
4463
4464
4466 {
4467 Agedge_t *arg1 = (Agedge_t *) 0 ;
4468 void *argp1 = 0 ;
4469 int res1 = 0 ;
4470 int argvi = 0;
4471 bool result;
4472 dXSARGS;
4473
4474 if ((items < 1) || (items > 1)) {
4475 SWIG_croak("Usage: ok(e);");
4476 }
4477 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agedge_t, 0 | 0 );
4478 if (!SWIG_IsOK(res1)) {
4479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ok" "', argument " "1"" of type '" "Agedge_t *""'");
4480 }
4481 arg1 = reinterpret_cast< Agedge_t * >(argp1);
4482 result = (bool)ok(arg1);
4483 ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
4484
4485 XSRETURN(argvi);
4486 fail:
4487
4489 }
4490}
4491
4492
4494 {
4495 Agsym_t *arg1 = (Agsym_t *) 0 ;
4496 void *argp1 = 0 ;
4497 int res1 = 0 ;
4498 int argvi = 0;
4499 bool result;
4500 dXSARGS;
4501
4502 if ((items < 1) || (items > 1)) {
4503 SWIG_croak("Usage: ok(a);");
4504 }
4505 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agsym_t, 0 | 0 );
4506 if (!SWIG_IsOK(res1)) {
4507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ok" "', argument " "1"" of type '" "Agsym_t *""'");
4508 }
4509 arg1 = reinterpret_cast< Agsym_t * >(argp1);
4510 result = (bool)ok(arg1);
4511 ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
4512
4513 XSRETURN(argvi);
4514 fail:
4515
4517 }
4518}
4519
4520
4522 dXSARGS;
4523
4524 {
4525 unsigned long _index = 0;
4526 SWIG_TypeRank _rank = 0;
4527 if (items == 1) {
4528 SWIG_TypeRank _ranki = 0;
4529 SWIG_TypeRank _rankm = 0;
4530 SWIG_TypeRank _pi = 1;
4531 int _v = 0;
4532 {
4533 void *vptr = 0;
4534 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agraph_t, 0);
4535 _v = SWIG_CheckState(res);
4536 }
4537 if (!_v) goto check_1;
4538 _ranki += _v*_pi;
4539 _rankm += _pi;
4540 _pi *= SWIG_MAXCASTRANK;
4541 if (!_index || (_ranki < _rank)) {
4542 _rank = _ranki; _index = 1;
4543 if (_rank == _rankm) goto dispatch;
4544 }
4545 }
4546 check_1:
4547
4548 if (items == 1) {
4549 SWIG_TypeRank _ranki = 0;
4550 SWIG_TypeRank _rankm = 0;
4551 SWIG_TypeRank _pi = 1;
4552 int _v = 0;
4553 {
4554 void *vptr = 0;
4555 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agnode_t, 0);
4556 _v = SWIG_CheckState(res);
4557 }
4558 if (!_v) goto check_2;
4559 _ranki += _v*_pi;
4560 _rankm += _pi;
4561 _pi *= SWIG_MAXCASTRANK;
4562 if (!_index || (_ranki < _rank)) {
4563 _rank = _ranki; _index = 2;
4564 if (_rank == _rankm) goto dispatch;
4565 }
4566 }
4567 check_2:
4568
4569 if (items == 1) {
4570 SWIG_TypeRank _ranki = 0;
4571 SWIG_TypeRank _rankm = 0;
4572 SWIG_TypeRank _pi = 1;
4573 int _v = 0;
4574 {
4575 void *vptr = 0;
4576 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agedge_t, 0);
4577 _v = SWIG_CheckState(res);
4578 }
4579 if (!_v) goto check_3;
4580 _ranki += _v*_pi;
4581 _rankm += _pi;
4582 _pi *= SWIG_MAXCASTRANK;
4583 if (!_index || (_ranki < _rank)) {
4584 _rank = _ranki; _index = 3;
4585 if (_rank == _rankm) goto dispatch;
4586 }
4587 }
4588 check_3:
4589
4590 if (items == 1) {
4591 SWIG_TypeRank _ranki = 0;
4592 SWIG_TypeRank _rankm = 0;
4593 SWIG_TypeRank _pi = 1;
4594 int _v = 0;
4595 {
4596 void *vptr = 0;
4597 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agsym_t, 0);
4598 _v = SWIG_CheckState(res);
4599 }
4600 if (!_v) goto check_4;
4601 _ranki += _v*_pi;
4602 _rankm += _pi;
4603 _pi *= SWIG_MAXCASTRANK;
4604 if (!_index || (_ranki < _rank)) {
4605 _rank = _ranki; _index = 4;
4606 if (_rank == _rankm) goto dispatch;
4607 }
4608 }
4609 check_4:
4610
4611 dispatch:
4612 switch(_index) {
4613 case 1:
4614 PUSHMARK(MARK); SWIG_CALLXS(_wrap_ok__SWIG_0); return;
4615 case 2:
4616 PUSHMARK(MARK); SWIG_CALLXS(_wrap_ok__SWIG_1); return;
4617 case 3:
4618 PUSHMARK(MARK); SWIG_CALLXS(_wrap_ok__SWIG_2); return;
4619 case 4:
4620 PUSHMARK(MARK); SWIG_CALLXS(_wrap_ok__SWIG_3); return;
4621 }
4622 }
4623
4624 croak("No matching function for overloaded 'ok'");
4625 XSRETURN(0);
4626}
4627
4628
4630 {
4631 Agraph_t *arg1 = (Agraph_t *) 0 ;
4632 void *argp1 = 0 ;
4633 int res1 = 0 ;
4634 int argvi = 0;
4635 Agraph_t *result = 0 ;
4636 dXSARGS;
4637
4638 if ((items < 1) || (items > 1)) {
4639 SWIG_croak("Usage: firstsubg(g);");
4640 }
4641 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
4642 if (!SWIG_IsOK(res1)) {
4643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "firstsubg" "', argument " "1"" of type '" "Agraph_t *""'");
4644 }
4645 arg1 = reinterpret_cast< Agraph_t * >(argp1);
4646 result = (Agraph_t *)firstsubg(arg1);
4647 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agraph_t, 0 | 0); argvi++ ;
4648
4649 XSRETURN(argvi);
4650 fail:
4651
4653 }
4654}
4655
4656
4658 {
4659 Agraph_t *arg1 = (Agraph_t *) 0 ;
4660 Agraph_t *arg2 = (Agraph_t *) 0 ;
4661 void *argp1 = 0 ;
4662 int res1 = 0 ;
4663 void *argp2 = 0 ;
4664 int res2 = 0 ;
4665 int argvi = 0;
4666 Agraph_t *result = 0 ;
4667 dXSARGS;
4668
4669 if ((items < 2) || (items > 2)) {
4670 SWIG_croak("Usage: nextsubg(g,sg);");
4671 }
4672 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
4673 if (!SWIG_IsOK(res1)) {
4674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nextsubg" "', argument " "1"" of type '" "Agraph_t *""'");
4675 }
4676 arg1 = reinterpret_cast< Agraph_t * >(argp1);
4677 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Agraph_t, 0 | 0 );
4678 if (!SWIG_IsOK(res2)) {
4679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nextsubg" "', argument " "2"" of type '" "Agraph_t *""'");
4680 }
4681 arg2 = reinterpret_cast< Agraph_t * >(argp2);
4682 result = (Agraph_t *)nextsubg(arg1,arg2);
4683 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agraph_t, 0 | 0); argvi++ ;
4684
4685
4686 XSRETURN(argvi);
4687 fail:
4688
4689
4691 }
4692}
4693
4694
4696 {
4697 Agraph_t *arg1 = (Agraph_t *) 0 ;
4698 void *argp1 = 0 ;
4699 int res1 = 0 ;
4700 int argvi = 0;
4701 Agraph_t *result = 0 ;
4702 dXSARGS;
4703
4704 if ((items < 1) || (items > 1)) {
4705 SWIG_croak("Usage: firstsupg(g);");
4706 }
4707 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
4708 if (!SWIG_IsOK(res1)) {
4709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "firstsupg" "', argument " "1"" of type '" "Agraph_t *""'");
4710 }
4711 arg1 = reinterpret_cast< Agraph_t * >(argp1);
4712 result = (Agraph_t *)firstsupg(arg1);
4713 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agraph_t, 0 | 0); argvi++ ;
4714
4715 XSRETURN(argvi);
4716 fail:
4717
4719 }
4720}
4721
4722
4724 {
4725 Agraph_t *arg1 = (Agraph_t *) 0 ;
4726 Agraph_t *arg2 = (Agraph_t *) 0 ;
4727 void *argp1 = 0 ;
4728 int res1 = 0 ;
4729 void *argp2 = 0 ;
4730 int res2 = 0 ;
4731 int argvi = 0;
4732 Agraph_t *result = 0 ;
4733 dXSARGS;
4734
4735 if ((items < 2) || (items > 2)) {
4736 SWIG_croak("Usage: nextsupg(g,sg);");
4737 }
4738 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
4739 if (!SWIG_IsOK(res1)) {
4740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nextsupg" "', argument " "1"" of type '" "Agraph_t *""'");
4741 }
4742 arg1 = reinterpret_cast< Agraph_t * >(argp1);
4743 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Agraph_t, 0 | 0 );
4744 if (!SWIG_IsOK(res2)) {
4745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nextsupg" "', argument " "2"" of type '" "Agraph_t *""'");
4746 }
4747 arg2 = reinterpret_cast< Agraph_t * >(argp2);
4748 result = (Agraph_t *)nextsupg(arg1,arg2);
4749 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agraph_t, 0 | 0); argvi++ ;
4750
4751
4752 XSRETURN(argvi);
4753 fail:
4754
4755
4757 }
4758}
4759
4760
4762 {
4763 Agraph_t *arg1 = (Agraph_t *) 0 ;
4764 void *argp1 = 0 ;
4765 int res1 = 0 ;
4766 int argvi = 0;
4767 Agedge_t *result = 0 ;
4768 dXSARGS;
4769
4770 if ((items < 1) || (items > 1)) {
4771 SWIG_croak("Usage: firstedge(g);");
4772 }
4773 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
4774 if (!SWIG_IsOK(res1)) {
4775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "firstedge" "', argument " "1"" of type '" "Agraph_t *""'");
4776 }
4777 arg1 = reinterpret_cast< Agraph_t * >(argp1);
4778 result = (Agedge_t *)firstedge(arg1);
4779 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agedge_t, 0 | 0); argvi++ ;
4780
4781 XSRETURN(argvi);
4782 fail:
4783
4785 }
4786}
4787
4788
4790 {
4791 Agraph_t *arg1 = (Agraph_t *) 0 ;
4792 Agedge_t *arg2 = (Agedge_t *) 0 ;
4793 void *argp1 = 0 ;
4794 int res1 = 0 ;
4795 void *argp2 = 0 ;
4796 int res2 = 0 ;
4797 int argvi = 0;
4798 Agedge_t *result = 0 ;
4799 dXSARGS;
4800
4801 if ((items < 2) || (items > 2)) {
4802 SWIG_croak("Usage: nextedge(g,e);");
4803 }
4804 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
4805 if (!SWIG_IsOK(res1)) {
4806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nextedge" "', argument " "1"" of type '" "Agraph_t *""'");
4807 }
4808 arg1 = reinterpret_cast< Agraph_t * >(argp1);
4809 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Agedge_t, 0 | 0 );
4810 if (!SWIG_IsOK(res2)) {
4811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nextedge" "', argument " "2"" of type '" "Agedge_t *""'");
4812 }
4813 arg2 = reinterpret_cast< Agedge_t * >(argp2);
4814 result = (Agedge_t *)nextedge(arg1,arg2);
4815 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agedge_t, 0 | 0); argvi++ ;
4816
4817
4818 XSRETURN(argvi);
4819 fail:
4820
4821
4823 }
4824}
4825
4826
4828 {
4829 Agraph_t *arg1 = (Agraph_t *) 0 ;
4830 void *argp1 = 0 ;
4831 int res1 = 0 ;
4832 int argvi = 0;
4833 Agedge_t *result = 0 ;
4834 dXSARGS;
4835
4836 if ((items < 1) || (items > 1)) {
4837 SWIG_croak("Usage: firstout(g);");
4838 }
4839 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
4840 if (!SWIG_IsOK(res1)) {
4841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "firstout" "', argument " "1"" of type '" "Agraph_t *""'");
4842 }
4843 arg1 = reinterpret_cast< Agraph_t * >(argp1);
4844 result = (Agedge_t *)firstout(arg1);
4845 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agedge_t, 0 | 0); argvi++ ;
4846
4847 XSRETURN(argvi);
4848 fail:
4849
4851 }
4852}
4853
4854
4856 {
4857 Agraph_t *arg1 = (Agraph_t *) 0 ;
4858 Agedge_t *arg2 = (Agedge_t *) 0 ;
4859 void *argp1 = 0 ;
4860 int res1 = 0 ;
4861 void *argp2 = 0 ;
4862 int res2 = 0 ;
4863 int argvi = 0;
4864 Agedge_t *result = 0 ;
4865 dXSARGS;
4866
4867 if ((items < 2) || (items > 2)) {
4868 SWIG_croak("Usage: nextout(g,e);");
4869 }
4870 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
4871 if (!SWIG_IsOK(res1)) {
4872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nextout" "', argument " "1"" of type '" "Agraph_t *""'");
4873 }
4874 arg1 = reinterpret_cast< Agraph_t * >(argp1);
4875 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Agedge_t, 0 | 0 );
4876 if (!SWIG_IsOK(res2)) {
4877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nextout" "', argument " "2"" of type '" "Agedge_t *""'");
4878 }
4879 arg2 = reinterpret_cast< Agedge_t * >(argp2);
4880 result = (Agedge_t *)nextout(arg1,arg2);
4881 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agedge_t, 0 | 0); argvi++ ;
4882
4883
4884 XSRETURN(argvi);
4885 fail:
4886
4887
4889 }
4890}
4891
4892
4894 {
4895 Agnode_t *arg1 = (Agnode_t *) 0 ;
4896 void *argp1 = 0 ;
4897 int res1 = 0 ;
4898 int argvi = 0;
4899 Agedge_t *result = 0 ;
4900 dXSARGS;
4901
4902 if ((items < 1) || (items > 1)) {
4903 SWIG_croak("Usage: firstedge(n);");
4904 }
4905 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
4906 if (!SWIG_IsOK(res1)) {
4907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "firstedge" "', argument " "1"" of type '" "Agnode_t *""'");
4908 }
4909 arg1 = reinterpret_cast< Agnode_t * >(argp1);
4910 result = (Agedge_t *)firstedge(arg1);
4911 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agedge_t, 0 | 0); argvi++ ;
4912
4913 XSRETURN(argvi);
4914 fail:
4915
4917 }
4918}
4919
4920
4922 dXSARGS;
4923
4924 {
4925 unsigned long _index = 0;
4926 SWIG_TypeRank _rank = 0;
4927 if (items == 1) {
4928 SWIG_TypeRank _ranki = 0;
4929 SWIG_TypeRank _rankm = 0;
4930 SWIG_TypeRank _pi = 1;
4931 int _v = 0;
4932 {
4933 void *vptr = 0;
4934 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agraph_t, 0);
4935 _v = SWIG_CheckState(res);
4936 }
4937 if (!_v) goto check_1;
4938 _ranki += _v*_pi;
4939 _rankm += _pi;
4940 _pi *= SWIG_MAXCASTRANK;
4941 if (!_index || (_ranki < _rank)) {
4942 _rank = _ranki; _index = 1;
4943 if (_rank == _rankm) goto dispatch;
4944 }
4945 }
4946 check_1:
4947
4948 if (items == 1) {
4949 SWIG_TypeRank _ranki = 0;
4950 SWIG_TypeRank _rankm = 0;
4951 SWIG_TypeRank _pi = 1;
4952 int _v = 0;
4953 {
4954 void *vptr = 0;
4955 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agnode_t, 0);
4956 _v = SWIG_CheckState(res);
4957 }
4958 if (!_v) goto check_2;
4959 _ranki += _v*_pi;
4960 _rankm += _pi;
4961 _pi *= SWIG_MAXCASTRANK;
4962 if (!_index || (_ranki < _rank)) {
4963 _rank = _ranki; _index = 2;
4964 if (_rank == _rankm) goto dispatch;
4965 }
4966 }
4967 check_2:
4968
4969 dispatch:
4970 switch(_index) {
4971 case 1:
4972 PUSHMARK(MARK); SWIG_CALLXS(_wrap_firstedge__SWIG_0); return;
4973 case 2:
4974 PUSHMARK(MARK); SWIG_CALLXS(_wrap_firstedge__SWIG_1); return;
4975 }
4976 }
4977
4978 croak("No matching function for overloaded 'firstedge'");
4979 XSRETURN(0);
4980}
4981
4982
4984 {
4985 Agnode_t *arg1 = (Agnode_t *) 0 ;
4986 Agedge_t *arg2 = (Agedge_t *) 0 ;
4987 void *argp1 = 0 ;
4988 int res1 = 0 ;
4989 void *argp2 = 0 ;
4990 int res2 = 0 ;
4991 int argvi = 0;
4992 Agedge_t *result = 0 ;
4993 dXSARGS;
4994
4995 if ((items < 2) || (items > 2)) {
4996 SWIG_croak("Usage: nextedge(n,e);");
4997 }
4998 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
4999 if (!SWIG_IsOK(res1)) {
5000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nextedge" "', argument " "1"" of type '" "Agnode_t *""'");
5001 }
5002 arg1 = reinterpret_cast< Agnode_t * >(argp1);
5003 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Agedge_t, 0 | 0 );
5004 if (!SWIG_IsOK(res2)) {
5005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nextedge" "', argument " "2"" of type '" "Agedge_t *""'");
5006 }
5007 arg2 = reinterpret_cast< Agedge_t * >(argp2);
5008 result = (Agedge_t *)nextedge(arg1,arg2);
5009 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agedge_t, 0 | 0); argvi++ ;
5010
5011
5012 XSRETURN(argvi);
5013 fail:
5014
5015
5017 }
5018}
5019
5020
5022 dXSARGS;
5023
5024 {
5025 unsigned long _index = 0;
5026 SWIG_TypeRank _rank = 0;
5027 if (items == 2) {
5028 SWIG_TypeRank _ranki = 0;
5029 SWIG_TypeRank _rankm = 0;
5030 SWIG_TypeRank _pi = 1;
5031 int _v = 0;
5032 {
5033 void *vptr = 0;
5034 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agraph_t, 0);
5035 _v = SWIG_CheckState(res);
5036 }
5037 if (!_v) goto check_1;
5038 _ranki += _v*_pi;
5039 _rankm += _pi;
5040 _pi *= SWIG_MAXCASTRANK;
5041 {
5042 void *vptr = 0;
5043 int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_Agedge_t, 0);
5044 _v = SWIG_CheckState(res);
5045 }
5046 if (!_v) goto check_1;
5047 _ranki += _v*_pi;
5048 _rankm += _pi;
5049 _pi *= SWIG_MAXCASTRANK;
5050 if (!_index || (_ranki < _rank)) {
5051 _rank = _ranki; _index = 1;
5052 if (_rank == _rankm) goto dispatch;
5053 }
5054 }
5055 check_1:
5056
5057 if (items == 2) {
5058 SWIG_TypeRank _ranki = 0;
5059 SWIG_TypeRank _rankm = 0;
5060 SWIG_TypeRank _pi = 1;
5061 int _v = 0;
5062 {
5063 void *vptr = 0;
5064 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agnode_t, 0);
5065 _v = SWIG_CheckState(res);
5066 }
5067 if (!_v) goto check_2;
5068 _ranki += _v*_pi;
5069 _rankm += _pi;
5070 _pi *= SWIG_MAXCASTRANK;
5071 {
5072 void *vptr = 0;
5073 int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_Agedge_t, 0);
5074 _v = SWIG_CheckState(res);
5075 }
5076 if (!_v) goto check_2;
5077 _ranki += _v*_pi;
5078 _rankm += _pi;
5079 _pi *= SWIG_MAXCASTRANK;
5080 if (!_index || (_ranki < _rank)) {
5081 _rank = _ranki; _index = 2;
5082 if (_rank == _rankm) goto dispatch;
5083 }
5084 }
5085 check_2:
5086
5087 dispatch:
5088 switch(_index) {
5089 case 1:
5090 PUSHMARK(MARK); SWIG_CALLXS(_wrap_nextedge__SWIG_0); return;
5091 case 2:
5092 PUSHMARK(MARK); SWIG_CALLXS(_wrap_nextedge__SWIG_1); return;
5093 }
5094 }
5095
5096 croak("No matching function for overloaded 'nextedge'");
5097 XSRETURN(0);
5098}
5099
5100
5102 {
5103 Agnode_t *arg1 = (Agnode_t *) 0 ;
5104 void *argp1 = 0 ;
5105 int res1 = 0 ;
5106 int argvi = 0;
5107 Agedge_t *result = 0 ;
5108 dXSARGS;
5109
5110 if ((items < 1) || (items > 1)) {
5111 SWIG_croak("Usage: firstout(n);");
5112 }
5113 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
5114 if (!SWIG_IsOK(res1)) {
5115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "firstout" "', argument " "1"" of type '" "Agnode_t *""'");
5116 }
5117 arg1 = reinterpret_cast< Agnode_t * >(argp1);
5118 result = (Agedge_t *)firstout(arg1);
5119 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agedge_t, 0 | 0); argvi++ ;
5120
5121 XSRETURN(argvi);
5122 fail:
5123
5125 }
5126}
5127
5128
5130 dXSARGS;
5131
5132 {
5133 unsigned long _index = 0;
5134 SWIG_TypeRank _rank = 0;
5135 if (items == 1) {
5136 SWIG_TypeRank _ranki = 0;
5137 SWIG_TypeRank _rankm = 0;
5138 SWIG_TypeRank _pi = 1;
5139 int _v = 0;
5140 {
5141 void *vptr = 0;
5142 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agraph_t, 0);
5143 _v = SWIG_CheckState(res);
5144 }
5145 if (!_v) goto check_1;
5146 _ranki += _v*_pi;
5147 _rankm += _pi;
5148 _pi *= SWIG_MAXCASTRANK;
5149 if (!_index || (_ranki < _rank)) {
5150 _rank = _ranki; _index = 1;
5151 if (_rank == _rankm) goto dispatch;
5152 }
5153 }
5154 check_1:
5155
5156 if (items == 1) {
5157 SWIG_TypeRank _ranki = 0;
5158 SWIG_TypeRank _rankm = 0;
5159 SWIG_TypeRank _pi = 1;
5160 int _v = 0;
5161 {
5162 void *vptr = 0;
5163 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agnode_t, 0);
5164 _v = SWIG_CheckState(res);
5165 }
5166 if (!_v) goto check_2;
5167 _ranki += _v*_pi;
5168 _rankm += _pi;
5169 _pi *= SWIG_MAXCASTRANK;
5170 if (!_index || (_ranki < _rank)) {
5171 _rank = _ranki; _index = 2;
5172 if (_rank == _rankm) goto dispatch;
5173 }
5174 }
5175 check_2:
5176
5177 dispatch:
5178 switch(_index) {
5179 case 1:
5180 PUSHMARK(MARK); SWIG_CALLXS(_wrap_firstout__SWIG_0); return;
5181 case 2:
5182 PUSHMARK(MARK); SWIG_CALLXS(_wrap_firstout__SWIG_1); return;
5183 }
5184 }
5185
5186 croak("No matching function for overloaded 'firstout'");
5187 XSRETURN(0);
5188}
5189
5190
5192 {
5193 Agnode_t *arg1 = (Agnode_t *) 0 ;
5194 Agedge_t *arg2 = (Agedge_t *) 0 ;
5195 void *argp1 = 0 ;
5196 int res1 = 0 ;
5197 void *argp2 = 0 ;
5198 int res2 = 0 ;
5199 int argvi = 0;
5200 Agedge_t *result = 0 ;
5201 dXSARGS;
5202
5203 if ((items < 2) || (items > 2)) {
5204 SWIG_croak("Usage: nextout(n,e);");
5205 }
5206 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
5207 if (!SWIG_IsOK(res1)) {
5208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nextout" "', argument " "1"" of type '" "Agnode_t *""'");
5209 }
5210 arg1 = reinterpret_cast< Agnode_t * >(argp1);
5211 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Agedge_t, 0 | 0 );
5212 if (!SWIG_IsOK(res2)) {
5213 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nextout" "', argument " "2"" of type '" "Agedge_t *""'");
5214 }
5215 arg2 = reinterpret_cast< Agedge_t * >(argp2);
5216 result = (Agedge_t *)nextout(arg1,arg2);
5217 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agedge_t, 0 | 0); argvi++ ;
5218
5219
5220 XSRETURN(argvi);
5221 fail:
5222
5223
5225 }
5226}
5227
5228
5230 dXSARGS;
5231
5232 {
5233 unsigned long _index = 0;
5234 SWIG_TypeRank _rank = 0;
5235 if (items == 2) {
5236 SWIG_TypeRank _ranki = 0;
5237 SWIG_TypeRank _rankm = 0;
5238 SWIG_TypeRank _pi = 1;
5239 int _v = 0;
5240 {
5241 void *vptr = 0;
5242 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agraph_t, 0);
5243 _v = SWIG_CheckState(res);
5244 }
5245 if (!_v) goto check_1;
5246 _ranki += _v*_pi;
5247 _rankm += _pi;
5248 _pi *= SWIG_MAXCASTRANK;
5249 {
5250 void *vptr = 0;
5251 int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_Agedge_t, 0);
5252 _v = SWIG_CheckState(res);
5253 }
5254 if (!_v) goto check_1;
5255 _ranki += _v*_pi;
5256 _rankm += _pi;
5257 _pi *= SWIG_MAXCASTRANK;
5258 if (!_index || (_ranki < _rank)) {
5259 _rank = _ranki; _index = 1;
5260 if (_rank == _rankm) goto dispatch;
5261 }
5262 }
5263 check_1:
5264
5265 if (items == 2) {
5266 SWIG_TypeRank _ranki = 0;
5267 SWIG_TypeRank _rankm = 0;
5268 SWIG_TypeRank _pi = 1;
5269 int _v = 0;
5270 {
5271 void *vptr = 0;
5272 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agnode_t, 0);
5273 _v = SWIG_CheckState(res);
5274 }
5275 if (!_v) goto check_2;
5276 _ranki += _v*_pi;
5277 _rankm += _pi;
5278 _pi *= SWIG_MAXCASTRANK;
5279 {
5280 void *vptr = 0;
5281 int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_Agedge_t, 0);
5282 _v = SWIG_CheckState(res);
5283 }
5284 if (!_v) goto check_2;
5285 _ranki += _v*_pi;
5286 _rankm += _pi;
5287 _pi *= SWIG_MAXCASTRANK;
5288 if (!_index || (_ranki < _rank)) {
5289 _rank = _ranki; _index = 2;
5290 if (_rank == _rankm) goto dispatch;
5291 }
5292 }
5293 check_2:
5294
5295 dispatch:
5296 switch(_index) {
5297 case 1:
5298 PUSHMARK(MARK); SWIG_CALLXS(_wrap_nextout__SWIG_0); return;
5299 case 2:
5300 PUSHMARK(MARK); SWIG_CALLXS(_wrap_nextout__SWIG_1); return;
5301 }
5302 }
5303
5304 croak("No matching function for overloaded 'nextout'");
5305 XSRETURN(0);
5306}
5307
5308
5310 {
5311 Agnode_t *arg1 = (Agnode_t *) 0 ;
5312 void *argp1 = 0 ;
5313 int res1 = 0 ;
5314 int argvi = 0;
5315 Agnode_t *result = 0 ;
5316 dXSARGS;
5317
5318 if ((items < 1) || (items > 1)) {
5319 SWIG_croak("Usage: firsthead(n);");
5320 }
5321 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
5322 if (!SWIG_IsOK(res1)) {
5323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "firsthead" "', argument " "1"" of type '" "Agnode_t *""'");
5324 }
5325 arg1 = reinterpret_cast< Agnode_t * >(argp1);
5326 result = (Agnode_t *)firsthead(arg1);
5327 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agnode_t, 0 | 0); argvi++ ;
5328
5329 XSRETURN(argvi);
5330 fail:
5331
5333 }
5334}
5335
5336
5338 {
5339 Agnode_t *arg1 = (Agnode_t *) 0 ;
5340 Agnode_t *arg2 = (Agnode_t *) 0 ;
5341 void *argp1 = 0 ;
5342 int res1 = 0 ;
5343 void *argp2 = 0 ;
5344 int res2 = 0 ;
5345 int argvi = 0;
5346 Agnode_t *result = 0 ;
5347 dXSARGS;
5348
5349 if ((items < 2) || (items > 2)) {
5350 SWIG_croak("Usage: nexthead(n,h);");
5351 }
5352 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
5353 if (!SWIG_IsOK(res1)) {
5354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nexthead" "', argument " "1"" of type '" "Agnode_t *""'");
5355 }
5356 arg1 = reinterpret_cast< Agnode_t * >(argp1);
5357 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Agnode_t, 0 | 0 );
5358 if (!SWIG_IsOK(res2)) {
5359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nexthead" "', argument " "2"" of type '" "Agnode_t *""'");
5360 }
5361 arg2 = reinterpret_cast< Agnode_t * >(argp2);
5362 result = (Agnode_t *)nexthead(arg1,arg2);
5363 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agnode_t, 0 | 0); argvi++ ;
5364
5365
5366 XSRETURN(argvi);
5367 fail:
5368
5369
5371 }
5372}
5373
5374
5376 {
5377 Agraph_t *arg1 = (Agraph_t *) 0 ;
5378 void *argp1 = 0 ;
5379 int res1 = 0 ;
5380 int argvi = 0;
5381 Agedge_t *result = 0 ;
5382 dXSARGS;
5383
5384 if ((items < 1) || (items > 1)) {
5385 SWIG_croak("Usage: firstin(g);");
5386 }
5387 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agraph_t, 0 | 0 );
5388 if (!SWIG_IsOK(res1)) {
5389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "firstin" "', argument " "1"" of type '" "Agraph_t *""'");
5390 }
5391 arg1 = reinterpret_cast< Agraph_t * >(argp1);
5392 result = (Agedge_t *)firstin(arg1);
5393 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agedge_t, 0 | 0); argvi++ ;
5394
5395 XSRETURN(argvi);
5396 fail:
5397
5399 }
5400}
5401
5402
5404 {
5405 Agnode_t *arg1 = (Agnode_t *) 0 ;
5406 Agedge_t *arg2 = (Agedge_t *) 0 ;
5407 void *argp1 = 0 ;
5408 int res1 = 0 ;
5409 void *argp2 = 0 ;
5410 int res2 = 0 ;
5411 int argvi = 0;
5412 Agedge_t *result = 0 ;
5413 dXSARGS;
5414
5415 if ((items < 2) || (items > 2)) {
5416 SWIG_croak("Usage: nextin(n,e);");
5417 }
5418 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
5419 if (!SWIG_IsOK(res1)) {
5420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nextin" "', argument " "1"" of type '" "Agnode_t *""'");
5421 }
5422 arg1 = reinterpret_cast< Agnode_t * >(argp1);
5423 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_Agedge_t, 0 | 0 );
5424 if (!SWIG_IsOK(res2)) {
5425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nextin" "', argument " "2"" of type '" "Agedge_t *""'");
5426 }
5427 arg2 = reinterpret_cast< Agedge_t * >(argp2);
5428 result = (Agedge_t *)nextin(arg1,arg2);
5429 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agedge_t, 0 | 0); argvi++ ;
5430
5431
5432 XSRETURN(argvi);
5433 fail:
5434
5435
5437 }
5438}
5439
5440
5442 {
5443 Agnode_t *arg1 = (Agnode_t *) 0 ;
5444 void *argp1 = 0 ;
5445 int res1 = 0 ;
5446 int argvi = 0;
5447 Agedge_t *result = 0 ;
5448 dXSARGS;
5449
5450 if ((items < 1) || (items > 1)) {
5451 SWIG_croak("Usage: firstin(n);");
5452 }
5453 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Agnode_t, 0 | 0 );
5454 if (!SWIG_IsOK(res1)) {
5455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "firstin" "', argument " "1"" of type '" "Agnode_t *""'");
5456 }
5457 arg1 = reinterpret_cast< Agnode_t * >(argp1);
5458 result = (Agedge_t *)firstin(arg1);
5459 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Agedge_t, 0 | 0); argvi++ ;
5460
5461 XSRETURN(argvi);
5462 fail:
5463
5465 }
5466}
5467
5468
5470 dXSARGS;
5471
5472 {
5473 unsigned long _index = 0;
5474 SWIG_TypeRank _rank = 0;
5475 if (items == 1) {
5476 SWIG_TypeRank _ranki = 0;
5477 SWIG_TypeRank _rankm = 0;
5478 SWIG_TypeRank _pi = 1;
5479 int _v = 0;
5480 {
5481 void *vptr = 0;
5482 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Agraph_t, 0);
5483 _v = SWIG_CheckState(res);
5484 }