/[hyperestraier_wrappers]/0.0.13/perl/HyperEstraier_wrap.cpp
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Contents of /0.0.13/perl/HyperEstraier_wrap.cpp

Parent Directory Parent Directory | Revision Log Revision Log

Revision 14 - (show annotations)
Fri Sep 9 15:26:39 2005 UTC (17 years, 8 months ago) by dpavlin
File size: 135785 byte(s) 
import of 0.0.13
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11
12 #ifdef __cplusplus
13 template<class T> class SwigValueWrapper {
14 T *tt;
15 public:
16 SwigValueWrapper() : tt(0) { }
17 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
18 SwigValueWrapper(const T& t) : tt(new T(t)) { }
19 ~SwigValueWrapper() { delete tt; }
20 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
21 operator T&() const { return *tt; }
22 T *operator&() { return tt; }
23 private:
24 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
25 };
26 #endif
27
28
29 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
30 # if defined(__SUNPRO_CC)
31 # define SWIG_TEMPLATE_DISAMBIGUATOR template
32 # else
33 # define SWIG_TEMPLATE_DISAMBIGUATOR
34 # endif
35 #endif
36
37 /***********************************************************************
38 * swigrun.swg
39 *
40 * This file contains generic CAPI SWIG runtime support for pointer
41 * type checking.
42 *
43 ************************************************************************/
44
45 /* This should only be incremented when either the layout of swig_type_info changes,
46 or for whatever reason, the runtime changes incompatibly */
47 #define SWIG_RUNTIME_VERSION "1"
48
49 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
50 #ifdef SWIG_TYPE_TABLE
51 #define SWIG_QUOTE_STRING(x) #x
52 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
53 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
54 #else
55 #define SWIG_TYPE_TABLE_NAME
56 #endif
57
58 #include <string.h>
59
60 #ifndef SWIGINLINE
61 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
62 # define SWIGINLINE inline
63 #else
64 # define SWIGINLINE
65 #endif
66 #endif
67
68 /*
69 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
70 creating a static or dynamic library from the swig runtime code.
71 In 99.9% of the cases, swig just needs to declare them as 'static'.
72
73 But only do this if is strictly necessary, ie, if you have problems
74 with your compiler or so.
75 */
76 #ifndef SWIGRUNTIME
77 #define SWIGRUNTIME static
78 #endif
79 #ifndef SWIGRUNTIMEINLINE
80 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
81 #endif
82
83 #ifdef __cplusplus
84 extern "C" {
85 #endif
86
87 typedef void *(*swig_converter_func)(void *);
88 typedef struct swig_type_info *(*swig_dycast_func)(void **);
89
90 typedef struct swig_type_info {
91 const char *name;
92 swig_converter_func converter;
93 const char *str;
94 void *clientdata;
95 swig_dycast_func dcast;
96 struct swig_type_info *next;
97 struct swig_type_info *prev;
98 } swig_type_info;
99
100 /*
101 Compare two type names skipping the space characters, therefore
102 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
103
104 Return 0 when the two name types are equivalent, as in
105 strncmp, but skipping ' '.
106 */
107 SWIGRUNTIME int
108 SWIG_TypeNameComp(const char *f1, const char *l1,
109 const char *f2, const char *l2) {
110 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
111 while ((*f1 == ' ') && (f1 != l1)) ++f1;
112 while ((*f2 == ' ') && (f2 != l2)) ++f2;
113 if (*f1 != *f2) return *f1 - *f2;
114 }
115 return (l1 - f1) - (l2 - f2);
116 }
117
118 /*
119 Check type equivalence in a name list like <name1>|<name2>|...
120 */
121 SWIGRUNTIME int
122 SWIG_TypeEquiv(const char *nb, const char *tb) {
123 int equiv = 0;
124 const char* te = tb + strlen(tb);
125 const char* ne = nb;
126 while (!equiv && *ne) {
127 for (nb = ne; *ne; ++ne) {
128 if (*ne == '|') break;
129 }
130 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
131 if (*ne) ++ne;
132 }
133 return equiv;
134 }
135
136 /*
137 Register a type mapping with the type-checking
138 */
139 SWIGRUNTIME swig_type_info *
140 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
141 swig_type_info *tc, *head, *ret, *next;
142 /* Check to see if this type has already been registered */
143 tc = *tl;
144 while (tc) {
145 /* check simple type equivalence */
146 int typeequiv = (strcmp(tc->name, ti->name) == 0);
147 /* check full type equivalence, resolving typedefs */
148 if (!typeequiv) {
149 /* only if tc is not a typedef (no '|' on it) */
150 if (tc->str && ti->str && !strstr(tc->str,"|")) {
151 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
152 }
153 }
154 if (typeequiv) {
155 /* Already exists in the table. Just add additional types to the list */
156 if (ti->clientdata) tc->clientdata = ti->clientdata;
157 head = tc;
158 next = tc->next;
159 goto l1;
160 }
161 tc = tc->prev;
162 }
163 head = ti;
164 next = 0;
165
166 /* Place in list */
167 ti->prev = *tl;
168 *tl = ti;
169
170 /* Build linked lists */
171 l1:
172 ret = head;
173 tc = ti + 1;
174 /* Patch up the rest of the links */
175 while (tc->name) {
176 head->next = tc;
177 tc->prev = head;
178 head = tc;
179 tc++;
180 }
181 if (next) next->prev = head;
182 head->next = next;
183
184 return ret;
185 }
186
187 /*
188 Check the typename
189 */
190 SWIGRUNTIME swig_type_info *
191 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
192 swig_type_info *s;
193 if (!ty) return 0; /* Void pointer */
194 s = ty->next; /* First element always just a name */
195 do {
196 if (strcmp(s->name,c) == 0) {
197 if (s == ty->next) return s;
198 /* Move s to the top of the linked list */
199 s->prev->next = s->next;
200 if (s->next) {
201 s->next->prev = s->prev;
202 }
203 /* Insert s as second element in the list */
204 s->next = ty->next;
205 if (ty->next) ty->next->prev = s;
206 ty->next = s;
207 s->prev = ty;
208 return s;
209 }
210 s = s->next;
211 } while (s && (s != ty->next));
212 return 0;
213 }
214
215 /*
216 Cast a pointer up an inheritance hierarchy
217 */
218 SWIGRUNTIMEINLINE void *
219 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
220 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
221 }
222
223 /*
224 Dynamic pointer casting. Down an inheritance hierarchy
225 */
226 SWIGRUNTIME swig_type_info *
227 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
228 swig_type_info *lastty = ty;
229 if (!ty || !ty->dcast) return ty;
230 while (ty && (ty->dcast)) {
231 ty = (*ty->dcast)(ptr);
232 if (ty) lastty = ty;
233 }
234 return lastty;
235 }
236
237 /*
238 Return the name associated with this type
239 */
240 SWIGRUNTIMEINLINE const char *
241 SWIG_TypeName(const swig_type_info *ty) {
242 return ty->name;
243 }
244
245 /*
246 Return the pretty name associated with this type,
247 that is an unmangled type name in a form presentable to the user.
248 */
249 SWIGRUNTIME const char *
250 SWIG_TypePrettyName(const swig_type_info *type) {
251 /* The "str" field contains the equivalent pretty names of the
252 type, separated by vertical-bar characters. We choose
253 to print the last name, as it is often (?) the most
254 specific. */
255 if (type->str != NULL) {
256 const char *last_name = type->str;
257 const char *s;
258 for (s = type->str; *s; s++)
259 if (*s == '|') last_name = s+1;
260 return last_name;
261 }
262 else
263 return type->name;
264 }
265
266 /*
267 Search for a swig_type_info structure
268 */
269 SWIGRUNTIME swig_type_info *
270 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
271 swig_type_info *ty = tl;
272 while (ty) {
273 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
274 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
275 ty = ty->prev;
276 }
277 return 0;
278 }
279
280 /*
281 Set the clientdata field for a type
282 */
283 SWIGRUNTIME void
284 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
285 swig_type_info *tc, *equiv;
286 if (ti->clientdata) return;
287 /* if (ti->clientdata == clientdata) return; */
288 ti->clientdata = clientdata;
289 equiv = ti->next;
290 while (equiv) {
291 if (!equiv->converter) {
292 tc = tl;
293 while (tc) {
294 if ((strcmp(tc->name, equiv->name) == 0))
295 SWIG_TypeClientDataTL(tl,tc,clientdata);
296 tc = tc->prev;
297 }
298 }
299 equiv = equiv->next;
300 }
301 }
302
303 /*
304 Pack binary data into a string
305 */
306 SWIGRUNTIME char *
307 SWIG_PackData(char *c, void *ptr, size_t sz) {
308 static char hex[17] = "0123456789abcdef";
309 unsigned char *u = (unsigned char *) ptr;
310 const unsigned char *eu = u + sz;
311 register unsigned char uu;
312 for (; u != eu; ++u) {
313 uu = *u;
314 *(c++) = hex[(uu & 0xf0) >> 4];
315 *(c++) = hex[uu & 0xf];
316 }
317 return c;
318 }
319
320 /*
321 Unpack binary data from a string
322 */
323 SWIGRUNTIME const char *
324 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
325 register unsigned char *u = (unsigned char *) ptr;
326 register const unsigned char *eu = u + sz;
327 for (; u != eu; ++u) {
328 register int d = *(c++);
329 register unsigned char uu = 0;
330 if ((d >= '0') && (d <= '9'))
331 uu = ((d - '0') << 4);
332 else if ((d >= 'a') && (d <= 'f'))
333 uu = ((d - ('a'-10)) << 4);
334 else
335 return (char *) 0;
336 d = *(c++);
337 if ((d >= '0') && (d <= '9'))
338 uu |= (d - '0');
339 else if ((d >= 'a') && (d <= 'f'))
340 uu |= (d - ('a'-10));
341 else
342 return (char *) 0;
343 *u = uu;
344 }
345 return c;
346 }
347
348 /*
349 This function will propagate the clientdata field of type to any new
350 swig_type_info structures that have been added into the list of
351 equivalent types. It is like calling SWIG_TypeClientData(type,
352 clientdata) a second time.
353 */
354 SWIGRUNTIME void
355 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
356 swig_type_info *equiv = type->next;
357 swig_type_info *tc;
358 if (!type->clientdata) return;
359 while (equiv) {
360 if (!equiv->converter) {
361 tc = tl;
362 while (tc) {
363 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
364 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
365 tc = tc->prev;
366 }
367 }
368 equiv = equiv->next;
369 }
370 }
371
372 /*
373 Pack 'void *' into a string buffer.
374 */
375 SWIGRUNTIME char *
376 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
377 char *r = buff;
378 if ((2*sizeof(void *) + 2) > bsz) return 0;
379 *(r++) = '_';
380 r = SWIG_PackData(r,&ptr,sizeof(void *));
381 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
382 strcpy(r,name);
383 return buff;
384 }
385
386 SWIGRUNTIME const char *
387 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
388 if (*c != '_') {
389 if (strcmp(c,"NULL") == 0) {
390 *ptr = (void *) 0;
391 return name;
392 } else {
393 return 0;
394 }
395 }
396 return SWIG_UnpackData(++c,ptr,sizeof(void *));
397 }
398
399 SWIGRUNTIME char *
400 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
401 char *r = buff;
402 size_t lname = (name ? strlen(name) : 0);
403 if ((2*sz + 2 + lname) > bsz) return 0;
404 *(r++) = '_';
405 r = SWIG_PackData(r,ptr,sz);
406 if (lname) {
407 strncpy(r,name,lname+1);
408 } else {
409 *r = 0;
410 }
411 return buff;
412 }
413
414 SWIGRUNTIME const char *
415 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
416 if (*c != '_') {
417 if (strcmp(c,"NULL") == 0) {
418 memset(ptr,0,sz);
419 return name;
420 } else {
421 return 0;
422 }
423 }
424 return SWIG_UnpackData(++c,ptr,sz);
425 }
426
427 #ifdef __cplusplus
428 }
429 #endif
430
431 /***********************************************************************
432 * common.swg
433 *
434 * This file contains generic SWIG runtime support for pointer
435 * type checking as well as a few commonly used macros to control
436 * external linkage.
437 *
438 * Author : David Beazley (beazley@cs.uchicago.edu)
439 *
440 * Copyright (c) 1999-2000, The University of Chicago
441 *
442 * This file may be freely redistributed without license or fee provided
443 * this copyright message remains intact.
444 ************************************************************************/
445
446
447 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
448 # if !defined(STATIC_LINKED)
449 # define SWIGEXPORT(a) __declspec(dllexport) a
450 # else
451 # define SWIGEXPORT(a) a
452 # endif
453 #else
454 # define SWIGEXPORT(a) a
455 #endif
456
457 #ifdef __cplusplus
458 extern "C" {
459 #endif
460
461
462 /*************************************************************************/
463
464
465 /* The static type info list */
466
467 static swig_type_info *swig_type_list = 0;
468 static swig_type_info **swig_type_list_handle = &swig_type_list;
469
470
471 /* Register a type mapping with the type-checking */
472 static swig_type_info *
473 SWIG_TypeRegister(swig_type_info *ti) {
474 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
475 }
476
477 /* Search for a swig_type_info structure */
478 static swig_type_info *
479 SWIG_TypeQuery(const char *name) {
480 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
481 }
482
483 /* Set the clientdata field for a type */
484 static void
485 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
486 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
487 }
488
489 /* This function will propagate the clientdata field of type to
490 * any new swig_type_info structures that have been added into the list
491 * of equivalent types. It is like calling
492 * SWIG_TypeClientData(type, clientdata) a second time.
493 */
494 static void
495 SWIG_PropagateClientData(swig_type_info *type) {
496 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
497 }
498
499 #ifdef __cplusplus
500 }
501 #endif
502
503 /* ---------------------------------------------------------------------- -*- c -*-
504 * perl5.swg
505 *
506 * Perl5 runtime library
507 * $Header: /cvsroot/swig/SWIG/Lib/perl5/perlrun.swg,v 1.20 2004/11/29 23:13:57 wuzzeb Exp $
508 * ----------------------------------------------------------------------------- */
509
510 #define SWIGPERL
511 #define SWIGPERL5
512 #ifdef __cplusplus
513 /* Needed on some windows machines---since MS plays funny games with the header files under C++ */
514 #include <math.h>
515 #include <stdlib.h>
516 extern "C" {
517 #endif
518 #include "EXTERN.h"
519 #include "perl.h"
520 #include "XSUB.h"
521
522 /* Get rid of free and malloc defined by perl */
523 #undef free
524 #undef malloc
525
526 #ifndef pTHX_
527 #define pTHX_
528 #endif
529
530 #include <string.h>
531 #ifdef __cplusplus
532 }
533 #endif
534
535 /* Macro to call an XS function */
536
537 #ifdef PERL_OBJECT
538 # define SWIG_CALLXS(_name) _name(cv,pPerl)
539 #else
540 # ifndef MULTIPLICITY
541 # define SWIG_CALLXS(_name) _name(cv)
542 # else
543 # define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv)
544 # endif
545 #endif
546
547 /* Contract support */
548
549 #define SWIG_contract_assert(expr,msg) if (!(expr)) { SWIG_croak(msg); } else
550
551 /* Note: SwigMagicFuncHack is a typedef used to get the C++ compiler to just shut up already */
552
553 #ifdef PERL_OBJECT
554 #define MAGIC_PPERL CPerlObj *pPerl = (CPerlObj *) this;
555 typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
556
557 #ifdef __cplusplus
558 extern "C" {
559 #endif
560 typedef int (CPerlObj::*SwigMagicFuncHack)(SV *, MAGIC *);
561 #ifdef __cplusplus
562 }
563 #endif
564
565 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
566 #define SWIGCLASS_STATIC
567 #else
568 #define MAGIC_PPERL
569 #define SWIGCLASS_STATIC static
570 #ifndef MULTIPLICITY
571 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
572 typedef int (*SwigMagicFunc)(SV *, MAGIC *);
573
574 #ifdef __cplusplus
575 extern "C" {
576 #endif
577 typedef int (*SwigMagicFuncHack)(SV *, MAGIC *);
578 #ifdef __cplusplus
579 }
580 #endif
581
582
583 #else
584 #define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
585 typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
586 #ifdef __cplusplus
587 extern "C" {
588 #endif
589 typedef int (*SwigMagicFuncHack)(struct interpreter *, SV *, MAGIC *);
590 #ifdef __cplusplus
591 }
592 #endif
593
594 #endif
595 #endif
596
597 #if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
598 #define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
599 #endif
600
601 /* Modifications for newer Perl 5.005 releases */
602
603 #if !defined(PERL_REVISION) || ((PERL_REVISION >= 5) && ((PERL_VERSION < 5) || ((PERL_VERSION == 5) && (PERL_SUBVERSION < 50))))
604 # ifndef PL_sv_yes
605 # define PL_sv_yes sv_yes
606 # endif
607 # ifndef PL_sv_undef
608 # define PL_sv_undef sv_undef
609 # endif
610 # ifndef PL_na
611 # define PL_na na
612 # endif
613 #endif
614
615 #include <stdlib.h>
616
617 #ifdef __cplusplus
618 extern "C" {
619 #endif
620
621 #define SWIG_OWNER 1
622 #define SWIG_SHADOW 2
623
624 /* Common SWIG API */
625
626 #ifdef PERL_OBJECT
627 # define SWIG_ConvertPtr(obj, pp, type, flags) \
628 SWIG_Perl_ConvertPtr(pPerl, obj, pp, type, flags)
629 # define SWIG_NewPointerObj(p, type, flags) \
630 SWIG_Perl_NewPointerObj(pPerl, p, type, flags)
631 # define SWIG_MakePackedObj(sv, p, s, type) \
632 SWIG_Perl_MakePackedObj(pPerl, sv, p, s, type)
633 # define SWIG_ConvertPacked(obj, p, s, type, flags) \
634 SWIG_Perl_ConvertPacked(pPerl, obj, p, s, type, flags)
635
636 #else
637 # define SWIG_ConvertPtr(obj, pp, type, flags) \
638 SWIG_Perl_ConvertPtr(obj, pp, type, flags)
639 # define SWIG_NewPointerObj(p, type, flags) \
640 SWIG_Perl_NewPointerObj(p, type, flags)
641 # define SWIG_MakePackedObj(sv, p, s, type) \
642 SWIG_Perl_MakePackedObj(sv, p, s, type )
643 # define SWIG_ConvertPacked(obj, p, s, type, flags) \
644 SWIG_Perl_ConvertPacked(obj, p, s, type, flags)
645 #endif
646
647 /* Perl-specific API */
648 #ifdef PERL_OBJECT
649 # define SWIG_MakePtr(sv, ptr, type, flags) \
650 SWIG_Perl_MakePtr(pPerl, sv, ptr, type, flags)
651 # define SWIG_SetError(str) \
652 SWIG_Perl_SetError(pPerl, str)
653 #else
654 # define SWIG_MakePtr(sv, ptr, type, flags) \
655 SWIG_Perl_MakePtr(sv, ptr, type, flags)
656 # define SWIG_SetError(str) \
657 SWIG_Perl_SetError(str)
658 # define SWIG_SetErrorSV(str) \
659 SWIG_Perl_SetErrorSV(str)
660 #endif
661
662 #define SWIG_SetErrorf SWIG_Perl_SetErrorf
663
664
665 #ifdef PERL_OBJECT
666 # define SWIG_MAYBE_PERL_OBJECT CPerlObj *pPerl,
667 #else
668 # define SWIG_MAYBE_PERL_OBJECT
669 #endif
670
671 static swig_type_info **
672 SWIG_Perl_GetTypeListHandle() {
673 static void *type_pointer = (void *)0;
674 SV *pointer;
675
676 /* first check if pointer already created */
677 if (!type_pointer) {
678 pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE);
679 if (pointer && SvOK(pointer)) {
680 type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
681 }
682 }
683
684 return (swig_type_info **) type_pointer;
685 }
686
687 /*
688 Search for a swig_type_info structure
689 */
690 SWIGRUNTIMEINLINE swig_type_info *
691 SWIG_Perl_GetTypeList() {
692 swig_type_info **tlh = SWIG_Perl_GetTypeListHandle();
693 return tlh ? *tlh : (swig_type_info*)0;
694 }
695
696 #define SWIG_Runtime_GetTypeList SWIG_Perl_GetTypeList
697
698 static swig_type_info *
699 SWIG_Perl_TypeCheckRV(SWIG_MAYBE_PERL_OBJECT SV *rv, swig_type_info *ty) {
700 swig_type_info *s;
701 if (!ty) return 0; /* Void pointer */
702 s = ty->next; /* First element always just a name */
703 do {
704 if (sv_derived_from(rv, (char *) s->name)) {
705 if (s == ty->next) return s;
706 /* Move s to the top of the linked list */
707 s->prev->next = s->next;
708 if (s->next) {
709 s->next->prev = s->prev;
710 }
711 /* Insert s as second element in the list */
712 s->next = ty->next;
713 if (ty->next) ty->next->prev = s;
714 ty->next = s;
715 s->prev = ty;
716 return s;
717 }
718 s = s->next;
719 } while (s && (s != ty->next));
720 return 0;
721 }
722
723 /* Function for getting a pointer value */
724
725 static int
726 SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
727 swig_type_info *tc;
728 void *voidptr = (void *)0;
729
730 /* If magical, apply more magic */
731 if (SvGMAGICAL(sv))
732 mg_get(sv);
733
734 /* Check to see if this is an object */
735 if (sv_isobject(sv)) {
736 SV *tsv = (SV*) SvRV(sv);
737 IV tmp = 0;
738 if ((SvTYPE(tsv) == SVt_PVHV)) {
739 MAGIC *mg;
740 if (SvMAGICAL(tsv)) {
741 mg = mg_find(tsv,'P');
742 if (mg) {
743 sv = mg->mg_obj;
744 if (sv_isobject(sv)) {
745 tmp = SvIV((SV*)SvRV(sv));
746 }
747 }
748 } else {
749 return -1;
750 }
751 } else {
752 tmp = SvIV((SV*)SvRV(sv));
753 }
754 voidptr = (void *)tmp;
755 if (!_t) {
756 *(ptr) = voidptr;
757 return 0;
758 }
759 } else if (! SvOK(sv)) { /* Check for undef */
760 *(ptr) = (void *) 0;
761 return 0;
762 } else if (SvTYPE(sv) == SVt_RV) { /* Check for NULL pointer */
763 *(ptr) = (void *) 0;
764 if (!SvROK(sv))
765 return 0;
766 else
767 return -1;
768 } else { /* Don't know what it is */
769 *(ptr) = (void *) 0;
770 return -1;
771 }
772 if (_t) {
773 /* Now see if the types match */
774 char *_c = HvNAME(SvSTASH(SvRV(sv)));
775 tc = SWIG_TypeCheck(_c,_t);
776 if (!tc) {
777 *ptr = voidptr;
778 return -1;
779 }
780 *ptr = SWIG_TypeCast(tc,voidptr);
781 return 0;
782 }
783 *ptr = voidptr;
784 return 0;
785 }
786
787 static void
788 SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
789 if (ptr && (flags & SWIG_SHADOW)) {
790 SV *self;
791 SV *obj=newSV(0);
792 HV *hash=newHV();
793 HV *stash;
794 sv_setref_pv(obj, (char *) t->name, ptr);
795 stash=SvSTASH(SvRV(obj));
796 if (flags & SWIG_OWNER) {
797 HV *hv;
798 GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
799 if (!isGV(gv))
800 gv_init(gv, stash, "OWNER", 5, FALSE);
801 hv=GvHVn(gv);
802 hv_store_ent(hv, obj, newSViv(1), 0);
803 }
804 sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
805 SvREFCNT_dec(obj);
806 self=newRV_noinc((SV *)hash);
807 sv_setsv(sv, self);
808 SvREFCNT_dec((SV *)self);
809 sv_bless(sv, stash);
810 }
811 else {
812 sv_setref_pv(sv, (char *) t->name, ptr);
813 }
814 }
815
816 static SWIGINLINE SV *
817 SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
818 SV *result = sv_newmortal();
819 SWIG_MakePtr(result, ptr, t, flags);
820 return result;
821 }
822
823 static void
824 SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
825 char result[1024];
826 char *r = result;
827 if ((2*sz + 1 + strlen(type->name)) > 1000) return;
828 *(r++) = '_';
829 r = SWIG_PackData(r,ptr,sz);
830 strcpy(r,type->name);
831 sv_setpv(sv, result);
832 }
833
834 /* Convert a packed value value */
835 static int
836 SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty, int flags) {
837 swig_type_info *tc;
838 const char *c = 0;
839
840 if ((!obj) || (!SvOK(obj))) return -1;
841 c = SvPV(obj, PL_na);
842 /* Pointer values must start with leading underscore */
843 if (*c != '_') return -1;
844 c++;
845 c = SWIG_UnpackData(c,ptr,sz);
846 if (ty) {
847 tc = SWIG_TypeCheck(c,ty);
848 if (!tc) return -1;
849 }
850 return 0;
851 }
852
853 static SWIGINLINE void
854 SWIG_Perl_SetError(SWIG_MAYBE_PERL_OBJECT const char *error) {
855 if (error) sv_setpv(perl_get_sv("@", TRUE), error);
856 }
857
858 static SWIGINLINE void
859 SWIG_Perl_SetErrorSV(SWIG_MAYBE_PERL_OBJECT SV *error) {
860 if (error) sv_setsv(perl_get_sv("@", TRUE), error);
861 }
862
863 static void
864 SWIG_Perl_SetErrorf(const char *fmt, ...) {
865 va_list args;
866 va_start(args, fmt);
867 sv_vsetpvfn(perl_get_sv("@", TRUE), fmt, strlen(fmt), &args, Null(SV**), 0, Null(bool*));
868 va_end(args);
869 }
870
871 /* Macros for low-level exception handling */
872 #define SWIG_fail goto fail
873 #define SWIG_croak(x) { SWIG_SetError(x); goto fail; }
874 #define SWIG_croakSV(x) { SWIG_SetErrorSV(x); goto fail; }
875 /* most preprocessors do not support vararg macros :-( */
876 /* #define SWIG_croakf(x...) { SWIG_SetErrorf(x); goto fail; } */
877
878
879 typedef XS(SwigPerlWrapper);
880 typedef SwigPerlWrapper *SwigPerlWrapperPtr;
881
882 /* Structure for command table */
883 typedef struct {
884 const char *name;
885 SwigPerlWrapperPtr wrapper;
886 } swig_command_info;
887
888 /* Information for constant table */
889
890 #define SWIG_INT 1
891 #define SWIG_FLOAT 2
892 #define SWIG_STRING 3
893 #define SWIG_POINTER 4
894 #define SWIG_BINARY 5
895
896 /* Constant information structure */
897 typedef struct swig_constant_info {
898 int type;
899 const char *name;
900 long lvalue;
901 double dvalue;
902 void *pvalue;
903 swig_type_info **ptype;
904 } swig_constant_info;
905
906 #ifdef __cplusplus
907 }
908 #endif
909
910 /* Structure for variable table */
911 typedef struct {
912 const char *name;
913 SwigMagicFunc set;
914 SwigMagicFunc get;
915 swig_type_info **type;
916 } swig_variable_info;
917
918 /* Magic variable code */
919 #ifndef PERL_OBJECT
920 #define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
921 #ifndef MULTIPLICITY
922 static void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *)) {
923 #else
924 static void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *)) {
925 #endif
926 #else
927 # define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
928 static void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *)) {
929 #endif
930 MAGIC *mg;
931 sv_magic(sv,sv,'U',(char *) name,strlen(name));
932 mg = mg_find(sv,'U');
933 mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
934 mg->mg_virtual->svt_get = (SwigMagicFuncHack) get;
935 mg->mg_virtual->svt_set = (SwigMagicFuncHack) set;
936 mg->mg_virtual->svt_len = 0;
937 mg->mg_virtual->svt_clear = 0;
938 mg->mg_virtual->svt_free = 0;
939 }
940
941
942
943
944
945
946 #ifdef do_open
947 #undef do_open
948 #endif
949 #ifdef do_close
950 #undef do_close
951 #endif
952 #ifdef scalar
953 #undef scalar
954 #endif
955 #ifdef list
956 #undef list
957 #endif
958 #ifdef apply
959 #undef apply
960 #endif
961 #ifdef convert
962 #undef convert
963 #endif
964 #ifdef Error
965 #undef Error
966 #endif
967 #ifdef form
968 #undef form
969 #endif
970 #ifdef vform
971 #undef vform
972 #endif
973 #ifdef LABEL
974 #undef LABEL
975 #endif
976 #ifdef METHOD
977 #undef METHOD
978 #endif
979 #ifdef Move
980 #undef Move
981 #endif
982 #ifdef yylex
983 #undef yylex
984 #endif
985 #ifdef yyparse
986 #undef yyparse
987 #endif
988 #ifdef yyerror
989 #undef yyerror
990 #endif
991 #ifdef invert
992 #undef invert
993 #endif
994 #ifdef ref
995 #undef ref
996 #endif
997 #ifdef ENTER
998 #undef ENTER
999 #endif
1000
1001
1002 /* -------- TYPES TABLE (BEGIN) -------- */
1003
1004 #define SWIGTYPE_p_estraier__Condition swig_types[0]
1005 #define SWIGTYPE_p_ESTCOND swig_types[1]
1006 #define SWIGTYPE_p_estraier__Database swig_types[2]
1007 #define SWIGTYPE_p_ESTDOC swig_types[3]
1008 #define SWIGTYPE_p_std__vectorTstd__string_t swig_types[4]
1009 #define SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[5]
1010 #define SWIGTYPE_p_std__vectorTint_t swig_types[6]
1011 #define SWIGTYPE_p_std__string swig_types[7]
1012 #define SWIGTYPE_p_estraier__Document swig_types[8]
1013 #define SWIGTYPE_p_size_t swig_types[9]
1014 static swig_type_info *swig_types[11];
1015
1016 /* -------- TYPES TABLE (END) -------- */
1017
1018 #define SWIG_init boot_HyperEstraier
1019
1020 #define SWIG_name "HyperEstraierc::boot_HyperEstraier"
1021 #define SWIG_prefix "HyperEstraierc::"
1022
1023 #ifdef __cplusplus
1024 extern "C"
1025 #endif
1026 #ifndef PERL_OBJECT
1027 #ifndef MULTIPLICITY
1028 SWIGEXPORT(void) SWIG_init (CV* cv);
1029 #else
1030 SWIGEXPORT(void) SWIG_init (pTHXo_ CV* cv);
1031 #endif
1032 #else
1033 SWIGEXPORT(void) SWIG_init (CV *cv, CPerlObj *);
1034 #endif
1035
1036
1037 #define SWIG_MemoryError 1
1038 #define SWIG_IOError 2
1039 #define SWIG_RuntimeError 3
1040 #define SWIG_IndexError 4
1041 #define SWIG_TypeError 5
1042 #define SWIG_DivisionByZero 6
1043 #define SWIG_OverflowError 7
1044 #define SWIG_SyntaxError 8
1045 #define SWIG_ValueError 9
1046 #define SWIG_SystemError 10
1047 #define SWIG_UnknownError 99
1048
1049
1050 #define SWIG_exception(a,b) SWIG_croak(b)
1051
1052
1053 #include <stdexcept>
1054
1055
1056 #include <string>
1057
1058 double SwigSvToNumber(SV* sv) {
1059 return SvIOK(sv) ? double(SvIVX(sv)) : SvNVX(sv);
1060 }
1061 std::string SwigSvToString(SV* sv) {
1062 STRLEN len;
1063 return SvPV(sv,len);
1064 }
1065 void SwigSvFromString(SV* sv, const std::string& s) {
1066 sv_setpv(sv,s.c_str());
1067 }
1068
1069
1070 #include <string>
1071
1072
1073 #include <vector>
1074 #include <algorithm>
1075 #include <stdexcept>
1076
1077
1078 #include <map>
1079 #include <algorithm>
1080 #include <stdexcept>
1081
1082
1083 #include <utility>
1084
1085 static std::string std_vector_Sl_std_string_Sg__pop(std::vector<std::string > *self){
1086 if (self->size() == 0)
1087 throw std::out_of_range("pop from empty vector");
1088 std::string x = self->back();
1089 self->pop_back();
1090 return x;
1091 }
1092 static std::string std_vector_Sl_std_string_Sg__get(std::vector<std::string > *self,int i){
1093 int size = int(self->size());
1094 if (i>=0 && i<size)
1095 return (*self)[i];
1096 else
1097 throw std::out_of_range("vector index out of range");
1098 }
1099 static void std_vector_Sl_std_string_Sg__set(std::vector<std::string > *self,int i,std::string x){
1100 int size = int(self->size());
1101 if (i>=0 && i<size)
1102 (*self)[i] = x;
1103 else
1104 throw std::out_of_range("vector index out of range");
1105 }
1106 static int std_vector_Sl_int_Sg__pop(std::vector<int > *self){
1107 if (self->size() == 0)
1108 throw std::out_of_range("pop from empty vector");
1109 int x = self->back();
1110 self->pop_back();
1111 return x;
1112 }
1113 static int std_vector_Sl_int_Sg__get(std::vector<int > *self,int i){
1114 int size = int(self->size());
1115 if (i>=0 && i<size)
1116 return (*self)[i];
1117 else
1118 throw std::out_of_range("vector index out of range");
1119 }
1120 static void std_vector_Sl_int_Sg__set(std::vector<int > *self,int i,int x){
1121 int size = int(self->size());
1122 if (i>=0 && i<size)
1123 (*self)[i] = x;
1124 else
1125 throw std::out_of_range("vector index out of range");
1126 }
1127 static std::string &std_map_Sl_std_string_Sc_std_string_Sg__get(std::map<std::string,std::string > *self,std::string const &key){
1128 std::map<std::string,std::string >::iterator i = self->find(key);
1129 if (i != self->end())
1130 return i->second;
1131 else
1132 throw std::out_of_range("key not found");
1133 }
1134 static void std_map_Sl_std_string_Sc_std_string_Sg__set(std::map<std::string,std::string > *self,std::string const &key,std::string const &x){
1135 (*self)[key] = x;
1136 }
1137 static void std_map_Sl_std_string_Sc_std_string_Sg__del(std::map<std::string,std::string > *self,std::string const &key){
1138 std::map<std::string,std::string >::iterator i = self->find(key);
1139 if (i != self->end())
1140 self->erase(i);
1141 else
1142 throw std::out_of_range("key not found");
1143 }
1144 static bool std_map_Sl_std_string_Sc_std_string_Sg__has_key(std::map<std::string,std::string > *self,std::string const &key){
1145 std::map<std::string,std::string >::iterator i = self->find(key);
1146 return i != self->end();
1147 }
1148
1149 #include "HyperEstraierWrapper.cpp"
1150
1151 #ifdef PERL_OBJECT
1152 #define MAGIC_CLASS _wrap_HyperEstraier_var::
1153 class _wrap_HyperEstraier_var : public CPerlObj {
1154 public:
1155 #else
1156 #define MAGIC_CLASS
1157 #endif
1158 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *sv, MAGIC *mg) {
1159 MAGIC_PPERL
1160 sv = sv; mg = mg;
1161 croak("Value is read-only.");
1162 return 0;
1163 }
1164
1165
1166 #ifdef PERL_OBJECT
1167 };
1168 #endif
1169
1170 #ifdef __cplusplus
1171 extern "C" {
1172 #endif
1173 XS(_wrap_new_StrVector__SWIG_0) {
1174 {
1175 unsigned int arg1 ;
1176 std::vector<std::string > *result;
1177 int argvi = 0;
1178 dXSARGS;
1179
1180 if ((items < 1) || (items > 1)) {
1181 SWIG_croak("Usage: new_StrVector(size);");
1182 }
1183 arg1 = (unsigned int) SvUV(ST(0));
1184 {
1185 try {
1186 result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1187
1188 } catch (const char *msg) {
1189 SWIG_exception(SWIG_RuntimeError, msg);
1190 }
1191 }
1192 ST(argvi) = sv_newmortal();
1193 SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTstd__string_t, SWIG_SHADOW|SWIG_OWNER);
1194 XSRETURN(argvi);
1195 fail:
1196 ;
1197 }
1198 croak(Nullch);
1199 }
1200
1201
1202 XS(_wrap_new_StrVector__SWIG_1) {
1203 {
1204 std::vector<std::string > *result;
1205 int argvi = 0;
1206 dXSARGS;
1207
1208 if ((items < 0) || (items > 0)) {
1209 SWIG_croak("Usage: new_StrVector();");
1210 }
1211 {
1212 try {
1213 result = (std::vector<std::string > *)new std::vector<std::string >();
1214
1215 } catch (const char *msg) {
1216 SWIG_exception(SWIG_RuntimeError, msg);
1217 }
1218 }
1219 ST(argvi) = sv_newmortal();
1220 SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTstd__string_t, SWIG_SHADOW|0);
1221 XSRETURN(argvi);
1222 fail:
1223 ;
1224 }
1225 croak(Nullch);
1226 }
1227
1228
1229 XS(_wrap_new_StrVector__SWIG_2) {
1230 {
1231 unsigned int arg1 ;
1232 std::string arg2 ;
1233 std::vector<std::string > *result;
1234 int argvi = 0;
1235 dXSARGS;
1236
1237 if ((items < 2) || (items > 2)) {
1238 SWIG_croak("Usage: new_StrVector(size,value);");
1239 }
1240 arg1 = (unsigned int) SvUV(ST(0));
1241 {
1242 STRLEN len;
1243 const char *ptr = SvPV(ST(1), len);
1244 if (!ptr) {
1245 SWIG_croak("Undefined variable in argument 2 of new_StrVector.");
1246 } else {
1247 arg2 = std::string(ptr, len);
1248 }
1249 }
1250 {
1251 try {
1252 result = (std::vector<std::string > *)new std::vector<std::string >(arg1,arg2);
1253
1254 } catch (const char *msg) {
1255 SWIG_exception(SWIG_RuntimeError, msg);
1256 }
1257 }
1258 ST(argvi) = sv_newmortal();
1259 SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTstd__string_t, SWIG_SHADOW|SWIG_OWNER);
1260 XSRETURN(argvi);
1261 fail:
1262 ;
1263 }
1264 croak(Nullch);
1265 }
1266
1267
1268 XS(_wrap_new_StrVector__SWIG_3) {
1269 {
1270 std::vector<std::string > *arg1 = 0 ;
1271 std::vector<std::string > *result;
1272 std::vector<std::string > temp1 ;
1273 std::vector<std::string > *v1 ;
1274 int argvi = 0;
1275 dXSARGS;
1276
1277 if ((items < 1) || (items > 1)) {
1278 SWIG_croak("Usage: new_StrVector(std::vector<std::string > const &);");
1279 }
1280 {
1281 if (SWIG_ConvertPtr(ST(0),(void **) &v1,
1282 SWIGTYPE_p_std__vectorTstd__string_t,1) != -1) {
1283 arg1 = v1;
1284 } else if (SvROK(ST(0))) {
1285 AV *av = (AV *)SvRV(ST(0));
1286 if (SvTYPE(av) != SVt_PVAV)
1287 SWIG_croak("Type error in argument 1 of new_StrVector. "
1288 "Expected an array of ""std::string");
1289 SV **tv;
1290 I32 len = av_len(av) + 1;
1291 std::string* obj;
1292 for (int i=0; i<len; i++) {
1293 tv = av_fetch(av, i, 0);
1294 if (SvPOK(*tv)) {
1295 temp1.push_back(SvPVX(*tv));
1296 } else {
1297 SWIG_croak("Type error in argument 1 of "
1298 "new_StrVector. "
1299 "Expected an array of ""std::string");
1300 }
1301 }
1302 arg1 = &temp1;
1303 } else {
1304 SWIG_croak("Type error in argument 1 of new_StrVector. "
1305 "Expected an array of ""std::string");
1306 }
1307 }
1308 {
1309 try {
1310 result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1311
1312 } catch (const char *msg) {
1313 SWIG_exception(SWIG_RuntimeError, msg);
1314 }
1315 }
1316 ST(argvi) = sv_newmortal();
1317 SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTstd__string_t, SWIG_SHADOW|SWIG_OWNER);
1318 XSRETURN(argvi);
1319 fail:
1320 ;
1321 }
1322 croak(Nullch);
1323 }
1324
1325
1326 XS(_wrap_new_StrVector) {
1327 dXSARGS;
1328
1329 if (items == 0) {
1330 (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrVector__SWIG_1); return;
1331 }
1332 if (items == 1) {
1333 int _v;
1334 {
1335 _v = SvIOK(ST(0)) ? 1 : 0;
1336 }
1337 if (_v) {
1338 (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrVector__SWIG_0); return;
1339 }
1340 }
1341 if (items == 1) {
1342 int _v;
1343 {
1344 {
1345 /* wrapped vector? */
1346 std::vector<std::string >* v;
1347 if (SWIG_ConvertPtr(ST(0),(void **) &v,
1348 SWIGTYPE_p_std__vectorTstd__string_t,0) != -1) {
1349 _v = 1;
1350 } else if (SvROK(ST(0))) {
1351 /* native sequence? */
1352 AV *av = (AV *)SvRV(ST(0));
1353 if (SvTYPE(av) == SVt_PVAV) {
1354 SV **tv;
1355 I32 len = av_len(av) + 1;
1356 if (len == 0) {
1357 /* an empty sequence can be of any type */
1358 _v = 1;
1359 } else {
1360 /* check the first element only */
1361 tv = av_fetch(av, 0, 0);
1362 if (SvPOK(*tv))
1363 _v = 1;
1364 else
1365 _v = 0;
1366 }
1367 }
1368 } else {
1369 _v = 0;
1370 }
1371 }
1372 }
1373 if (_v) {
1374 (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrVector__SWIG_3); return;
1375 }
1376 }
1377 if (items == 2) {
1378 int _v;
1379 {
1380 _v = SvIOK(ST(0)) ? 1 : 0;
1381 }
1382 if (_v) {
1383 {
1384 _v = SvPOK(ST(1)) ? 1 : 0;
1385 }
1386 if (_v) {
1387 (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrVector__SWIG_2); return;
1388 }
1389 }
1390 }
1391
1392 croak("No matching function for overloaded 'new_StrVector'");
1393 XSRETURN(0);
1394 }
1395
1396
1397 XS(_wrap_StrVector_size) {
1398 {
1399 std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1400 unsigned int result;
1401 std::vector<std::string > temp1 ;
1402 std::vector<std::string > *v1 ;
1403 int argvi = 0;
1404 dXSARGS;
1405
1406 if ((items < 1) || (items > 1)) {
1407 SWIG_croak("Usage: StrVector_size(self);");
1408 }
1409 {
1410 if (SWIG_ConvertPtr(ST(0),(void **) &v1,
1411 SWIGTYPE_p_std__vectorTstd__string_t,1) != -1) {
1412 arg1 = v1;
1413 } else if (SvROK(ST(0))) {
1414 AV *av = (AV *)SvRV(ST(0));
1415 if (SvTYPE(av) != SVt_PVAV)
1416 SWIG_croak("Type error in argument 1 of StrVector_size. "
1417 "Expected an array of ""std::string");
1418 SV **tv;
1419 I32 len = av_len(av) + 1;
1420 std::string* obj;
1421 for (int i=0; i<len; i++) {
1422 tv = av_fetch(av, i, 0);
1423 if (SvPOK(*tv)) {
1424 temp1.push_back(SvPVX(*tv));
1425 } else {
1426 SWIG_croak("Type error in argument 1 of "
1427 "StrVector_size. "
1428 "Expected an array of ""std::string");
1429 }
1430 }
1431 arg1 = &temp1;
1432 } else {
1433 SWIG_croak("Type error in argument 1 of StrVector_size. "
1434 "Expected an array of ""std::string");
1435 }
1436 }
1437 {
1438 try {
1439 result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1440
1441 } catch (const char *msg) {
1442 SWIG_exception(SWIG_RuntimeError, msg);
1443 }
1444 }
1445 ST(argvi) = sv_newmortal();
1446 sv_setuv(ST(argvi++), (UV) result);
1447 XSRETURN(argvi);
1448 fail:
1449 ;
1450 }
1451 croak(Nullch);
1452 }
1453
1454
1455 XS(_wrap_StrVector_empty) {
1456 {
1457 std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1458 bool result;
1459 std::vector<std::string > temp1 ;
1460 std::vector<std::string > *v1 ;
1461 int argvi = 0;
1462 dXSARGS;
1463
1464 if ((items < 1) || (items > 1)) {
1465 SWIG_croak("Usage: StrVector_empty(self);");
1466 }
1467 {
1468 if (SWIG_ConvertPtr(ST(0),(void **) &v1,
1469 SWIGTYPE_p_std__vectorTstd__string_t,1) != -1) {
1470 arg1 = v1;
1471 } else if (SvROK(ST(0))) {
1472 AV *av = (AV *)SvRV(ST(0));
1473 if (SvTYPE(av) != SVt_PVAV)
1474 SWIG_croak("Type error in argument 1 of StrVector_empty. "
1475 "Expected an array of ""std::string");
1476 SV **tv;
1477 I32 len = av_len(av) + 1;
1478 std::string* obj;
1479 for (int i=0; i<len; i++) {
1480 tv = av_fetch(av, i, 0);
1481 if (SvPOK(*tv)) {
1482 temp1.push_back(SvPVX(*tv));
1483 } else {
1484 SWIG_croak("Type error in argument 1 of "
1485 "StrVector_empty. "
1486 "Expected an array of ""std::string");
1487 }
1488 }
1489 arg1 = &temp1;
1490 } else {
1491 SWIG_croak("Type error in argument 1 of StrVector_empty. "
1492 "Expected an array of ""std::string");
1493 }
1494 }
1495 {
1496 try {
1497 result = (bool)((std::vector<std::string > const *)arg1)->empty();
1498
1499 } catch (const char *msg) {
1500 SWIG_exception(SWIG_RuntimeError, msg);
1501 }
1502 }
1503 ST(argvi) = sv_newmortal();
1504 sv_setiv(ST(argvi++), (IV) result);
1505 XSRETURN(argvi);
1506 fail:
1507 ;
1508 }
1509 croak(Nullch);
1510 }
1511
1512
1513 XS(_wrap_StrVector_clear) {
1514 {
1515 std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1516 int argvi = 0;
1517 dXSARGS;
1518
1519 if ((items < 1) || (items > 1)) {
1520 SWIG_croak("Usage: StrVector_clear(self);");
1521 }
1522 {
1523 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
1524 SWIG_croak("Type error in argument 1 of StrVector_clear. Expected _p_std__vectorTstd__string_t");
1525 }
1526 }
1527 {
1528 try {
1529 (arg1)->clear();
1530
1531 } catch (const char *msg) {
1532 SWIG_exception(SWIG_RuntimeError, msg);
1533 }
1534 }
1535
1536 XSRETURN(argvi);
1537 fail:
1538 ;
1539 }
1540 croak(Nullch);
1541 }
1542
1543
1544 XS(_wrap_StrVector_push) {
1545 {
1546 std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1547 std::string arg2 ;
1548 int argvi = 0;
1549 dXSARGS;
1550
1551 if ((items < 2) || (items > 2)) {
1552 SWIG_croak("Usage: StrVector_push(self,x);");
1553 }
1554 {
1555 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
1556 SWIG_croak("Type error in argument 1 of StrVector_push. Expected _p_std__vectorTstd__string_t");
1557 }
1558 }
1559 {
1560 STRLEN len;
1561 const char *ptr = SvPV(ST(1), len);
1562 if (!ptr) {
1563 SWIG_croak("Undefined variable in argument 2 of StrVector_push.");
1564 } else {
1565 arg2 = std::string(ptr, len);
1566 }
1567 }
1568 {
1569 try {
1570 (arg1)->push_back(arg2);
1571
1572 } catch (const char *msg) {
1573 SWIG_exception(SWIG_RuntimeError, msg);
1574 }
1575 }
1576
1577 XSRETURN(argvi);
1578 fail:
1579 ;
1580 }
1581 croak(Nullch);
1582 }
1583
1584
1585 XS(_wrap_StrVector_pop) {
1586 {
1587 std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1588 std::string result;
1589 int argvi = 0;
1590 dXSARGS;
1591
1592 if ((items < 1) || (items > 1)) {
1593 SWIG_croak("Usage: StrVector_pop(self);");
1594 }
1595 {
1596 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
1597 SWIG_croak("Type error in argument 1 of StrVector_pop. Expected _p_std__vectorTstd__string_t");
1598 }
1599 }
1600 {
1601 try {
1602 result = std_vector_Sl_std_string_Sg__pop(arg1);
1603
1604 } catch (std::out_of_range& e) {
1605 SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
1606 }
1607 }
1608 {
1609 if (argvi >= items) EXTEND(sp, 1); // bump stack ptr, if needed
1610 char *data = const_cast<char*>((&result)->data());
1611 sv_setpvn(ST(argvi) = sv_newmortal(), data, (&result)->size());
1612 ++argvi;
1613 }
1614 XSRETURN(argvi);
1615 fail:
1616 ;
1617 }
1618 croak(Nullch);
1619 }
1620
1621
1622 XS(_wrap_StrVector_get) {
1623 {
1624 std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1625 int arg2 ;
1626 std::string result;
1627 int argvi = 0;
1628 dXSARGS;
1629
1630 if ((items < 2) || (items > 2)) {
1631 SWIG_croak("Usage: StrVector_get(self,i);");
1632 }
1633 {
1634 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
1635 SWIG_croak("Type error in argument 1 of StrVector_get. Expected _p_std__vectorTstd__string_t");
1636 }
1637 }
1638 arg2 = (int) SvIV(ST(1));
1639 {
1640 try {
1641 result = std_vector_Sl_std_string_Sg__get(arg1,arg2);
1642
1643 } catch (std::out_of_range& e) {
1644 SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
1645 }
1646 }
1647 {
1648 if (argvi >= items) EXTEND(sp, 1); // bump stack ptr, if needed
1649 char *data = const_cast<char*>((&result)->data());
1650 sv_setpvn(ST(argvi) = sv_newmortal(), data, (&result)->size());
1651 ++argvi;
1652 }
1653 XSRETURN(argvi);
1654 fail:
1655 ;
1656 }
1657 croak(Nullch);
1658 }
1659
1660
1661 XS(_wrap_StrVector_set) {
1662 {
1663 std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1664 int arg2 ;
1665 std::string arg3 ;
1666 int argvi = 0;
1667 dXSARGS;
1668
1669 if ((items < 3) || (items > 3)) {
1670 SWIG_croak("Usage: StrVector_set(self,i,x);");
1671 }
1672 {
1673 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
1674 SWIG_croak("Type error in argument 1 of StrVector_set. Expected _p_std__vectorTstd__string_t");
1675 }
1676 }
1677 arg2 = (int) SvIV(ST(1));
1678 {
1679 STRLEN len;
1680 const char *ptr = SvPV(ST(2), len);
1681 if (!ptr) {
1682 SWIG_croak("Undefined variable in argument 3 of StrVector_set.");
1683 } else {
1684 arg3 = std::string(ptr, len);
1685 }
1686 }
1687 {
1688 try {
1689 std_vector_Sl_std_string_Sg__set(arg1,arg2,arg3);
1690
1691 } catch (std::out_of_range& e) {
1692 SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
1693 }
1694 }
1695
1696 XSRETURN(argvi);
1697 fail:
1698 ;
1699 }
1700 croak(Nullch);
1701 }
1702
1703
1704 XS(_wrap_delete_StrVector) {
1705 {
1706 std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1707 int argvi = 0;
1708 dXSARGS;
1709
1710 if ((items < 1) || (items > 1)) {
1711 SWIG_croak("Usage: delete_StrVector(self);");
1712 }
1713 {
1714 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
1715 SWIG_croak("Type error in argument 1 of delete_StrVector. Expected _p_std__vectorTstd__string_t");
1716 }
1717 }
1718 {
1719 try {
1720 delete arg1;
1721
1722 } catch (const char *msg) {
1723 SWIG_exception(SWIG_RuntimeError, msg);
1724 }
1725 }
1726
1727 XSRETURN(argvi);
1728 fail:
1729 ;
1730 }
1731 croak(Nullch);
1732 }
1733
1734
1735 XS(_wrap_new_IntVector__SWIG_0) {
1736 {
1737 unsigned int arg1 ;
1738 std::vector<int > *result;
1739 int argvi = 0;
1740 dXSARGS;
1741
1742 if ((items < 1) || (items > 1)) {
1743 SWIG_croak("Usage: new_IntVector(size);");
1744 }
1745 arg1 = (unsigned int) SvUV(ST(0));
1746 {
1747 try {
1748 result = (std::vector<int > *)new std::vector<int >(arg1);
1749
1750 } catch (const char *msg) {
1751 SWIG_exception(SWIG_RuntimeError, msg);
1752 }
1753 }
1754 ST(argvi) = sv_newmortal();
1755 SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTint_t, SWIG_SHADOW|SWIG_OWNER);
1756 XSRETURN(argvi);
1757 fail:
1758 ;
1759 }
1760 croak(Nullch);
1761 }
1762
1763
1764 XS(_wrap_new_IntVector__SWIG_1) {
1765 {
1766 std::vector<int > *result;
1767 int argvi = 0;
1768 dXSARGS;
1769
1770 if ((items < 0) || (items > 0)) {
1771 SWIG_croak("Usage: new_IntVector();");
1772 }
1773 {
1774 try {
1775 result = (std::vector<int > *)new std::vector<int >();
1776
1777 } catch (const char *msg) {
1778 SWIG_exception(SWIG_RuntimeError, msg);
1779 }
1780 }
1781 ST(argvi) = sv_newmortal();
1782 SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTint_t, SWIG_SHADOW|0);
1783 XSRETURN(argvi);
1784 fail:
1785 ;
1786 }
1787 croak(Nullch);
1788 }
1789
1790
1791 XS(_wrap_new_IntVector__SWIG_2) {
1792 {
1793 unsigned int arg1 ;
1794 int arg2 ;
1795 std::vector<int > *result;
1796 int argvi = 0;
1797 dXSARGS;
1798
1799 if ((items < 2) || (items > 2)) {
1800 SWIG_croak("Usage: new_IntVector(size,value);");
1801 }
1802 arg1 = (unsigned int) SvUV(ST(0));
1803 arg2 = (int) SvIV(ST(1));
1804 {
1805 try {
1806 result = (std::vector<int > *)new std::vector<int >(arg1,arg2);
1807
1808 } catch (const char *msg) {
1809 SWIG_exception(SWIG_RuntimeError, msg);
1810 }
1811 }
1812 ST(argvi) = sv_newmortal();
1813 SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTint_t, SWIG_SHADOW|SWIG_OWNER);
1814 XSRETURN(argvi);
1815 fail:
1816 ;
1817 }
1818 croak(Nullch);
1819 }
1820
1821
1822 XS(_wrap_new_IntVector__SWIG_3) {
1823 {
1824 std::vector<int > *arg1 = 0 ;
1825 std::vector<int > *result;
1826 std::vector<int > temp1 ;
1827 std::vector<int > *v1 ;
1828 int argvi = 0;
1829 dXSARGS;
1830
1831 if ((items < 1) || (items > 1)) {
1832 SWIG_croak("Usage: new_IntVector(std::vector<int > const &);");
1833 }
1834 {
1835 if (SWIG_ConvertPtr(ST(0),(void **) &v1,
1836 SWIGTYPE_p_std__vectorTint_t,1) != -1) {
1837 arg1 = v1;
1838 } else if (SvROK(ST(0))) {
1839 AV *av = (AV *)SvRV(ST(0));
1840 if (SvTYPE(av) != SVt_PVAV)
1841 SWIG_croak("Type error in argument 1 of new_IntVector. "
1842 "Expected an array of ""int");
1843 SV **tv;
1844 I32 len = av_len(av) + 1;
1845 int* obj;
1846 for (int i=0; i<len; i++) {
1847 tv = av_fetch(av, i, 0);
1848 if (SvIOK(*tv)) {
1849 temp1.push_back(SvIVX(*tv));
1850 } else {
1851 SWIG_croak("Type error in argument 1 of "
1852 "new_IntVector. "
1853 "Expected an array of ""int");
1854 }
1855 }
1856 arg1 = &temp1;
1857 } else {
1858 SWIG_croak("Type error in argument 1 of new_IntVector. "
1859 "Expected an array of ""int");
1860 }
1861 }
1862 {
1863 try {
1864 result = (std::vector<int > *)new std::vector<int >((std::vector<int > const &)*arg1);
1865
1866 } catch (const char *msg) {
1867 SWIG_exception(SWIG_RuntimeError, msg);
1868 }
1869 }
1870 ST(argvi) = sv_newmortal();
1871 SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTint_t, SWIG_SHADOW|SWIG_OWNER);
1872 XSRETURN(argvi);
1873 fail:
1874 ;
1875 }
1876 croak(Nullch);
1877 }
1878
1879
1880 XS(_wrap_new_IntVector) {
1881 dXSARGS;
1882
1883 if (items == 0) {
1884 (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_IntVector__SWIG_1); return;
1885 }
1886 if (items == 1) {
1887 int _v;
1888 {
1889 _v = SvIOK(ST(0)) ? 1 : 0;
1890 }
1891 if (_v) {
1892 (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_IntVector__SWIG_0); return;
1893 }
1894 }
1895 if (items == 1) {
1896 int _v;
1897 {
1898 {
1899 /* wrapped vector? */
1900 std::vector<int >* v;
1901 if (SWIG_ConvertPtr(ST(0),(void **) &v,
1902 SWIGTYPE_p_std__vectorTint_t,0) != -1) {
1903 _v = 1;
1904 } else if (SvROK(ST(0))) {
1905 /* native sequence? */
1906 AV *av = (AV *)SvRV(ST(0));
1907 if (SvTYPE(av) == SVt_PVAV) {
1908 SV **tv;
1909 I32 len = av_len(av) + 1;
1910 if (len == 0) {
1911 /* an empty sequence can be of any type */
1912 _v = 1;
1913 } else {
1914 /* check the first element only */
1915 tv = av_fetch(av, 0, 0);
1916 if (SvIOK(*tv))
1917 _v = 1;
1918 else
1919 _v = 0;
1920 }
1921 }
1922 } else {
1923 _v = 0;
1924 }
1925 }
1926 }
1927 if (_v) {
1928 (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_IntVector__SWIG_3); return;
1929 }
1930 }
1931 if (items == 2) {
1932 int _v;
1933 {
1934 _v = SvIOK(ST(0)) ? 1 : 0;
1935 }
1936 if (_v) {
1937 {
1938 _v = SvIOK(ST(1)) ? 1 : 0;
1939 }
1940 if (_v) {
1941 (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_IntVector__SWIG_2); return;
1942 }
1943 }
1944 }
1945
1946 croak("No matching function for overloaded 'new_IntVector'");
1947 XSRETURN(0);
1948 }
1949
1950
1951 XS(_wrap_IntVector_size) {
1952 {
1953 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
1954 unsigned int result;
1955 std::vector<int > temp1 ;
1956 std::vector<int > *v1 ;
1957 int argvi = 0;
1958 dXSARGS;
1959
1960 if ((items < 1) || (items > 1)) {
1961 SWIG_croak("Usage: IntVector_size(self);");
1962 }
1963 {
1964 if (SWIG_ConvertPtr(ST(0),(void **) &v1,
1965 SWIGTYPE_p_std__vectorTint_t,1) != -1) {
1966 arg1 = v1;
1967 } else if (SvROK(ST(0))) {
1968 AV *av = (AV *)SvRV(ST(0));
1969 if (SvTYPE(av) != SVt_PVAV)
1970 SWIG_croak("Type error in argument 1 of IntVector_size. "
1971 "Expected an array of ""int");
1972 SV **tv;
1973 I32 len = av_len(av) + 1;
1974 int* obj;
1975 for (int i=0; i<len; i++) {
1976 tv = av_fetch(av, i, 0);
1977 if (SvIOK(*tv)) {
1978 temp1.push_back(SvIVX(*tv));
1979 } else {
1980 SWIG_croak("Type error in argument 1 of "
1981 "IntVector_size. "
1982 "Expected an array of ""int");
1983 }
1984 }
1985 arg1 = &temp1;
1986 } else {
1987 SWIG_croak("Type error in argument 1 of IntVector_size. "
1988 "Expected an array of ""int");
1989 }
1990 }
1991 {
1992 try {
1993 result = (unsigned int)((std::vector<int > const *)arg1)->size();
1994
1995 } catch (const char *msg) {
1996 SWIG_exception(SWIG_RuntimeError, msg);
1997 }
1998 }
1999 ST(argvi) = sv_newmortal();
2000 sv_setuv(ST(argvi++), (UV) result);
2001 XSRETURN(argvi);
2002 fail:
2003 ;
2004 }
2005 croak(Nullch);
2006 }
2007
2008
2009 XS(_wrap_IntVector_empty) {
2010 {
2011 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
2012 bool result;
2013 std::vector<int > temp1 ;
2014 std::vector<int > *v1 ;
2015 int argvi = 0;
2016 dXSARGS;
2017
2018 if ((items < 1) || (items > 1)) {
2019 SWIG_croak("Usage: IntVector_empty(self);");
2020 }
2021 {
2022 if (SWIG_ConvertPtr(ST(0),(void **) &v1,
2023 SWIGTYPE_p_std__vectorTint_t,1) != -1) {
2024 arg1 = v1;
2025 } else if (SvROK(ST(0))) {
2026 AV *av = (AV *)SvRV(ST(0));
2027 if (SvTYPE(av) != SVt_PVAV)
2028 SWIG_croak("Type error in argument 1 of IntVector_empty. "
2029 "Expected an array of ""int");
2030 SV **tv;
2031 I32 len = av_len(av) + 1;
2032 int* obj;
2033 for (int i=0; i<len; i++) {
2034 tv = av_fetch(av, i, 0);
2035 if (SvIOK(*tv)) {
2036 temp1.push_back(SvIVX(*tv));
2037 } else {
2038 SWIG_croak("Type error in argument 1 of "
2039 "IntVector_empty. "
2040 "Expected an array of ""int");
2041 }
2042 }
2043 arg1 = &temp1;
2044 } else {
2045 SWIG_croak("Type error in argument 1 of IntVector_empty. "
2046 "Expected an array of ""int");
2047 }
2048 }
2049 {
2050 try {
2051 result = (bool)((std::vector<int > const *)arg1)->empty();
2052
2053 } catch (const char *msg) {
2054 SWIG_exception(SWIG_RuntimeError, msg);
2055 }
2056 }
2057 ST(argvi) = sv_newmortal();
2058 sv_setiv(ST(argvi++), (IV) result);
2059 XSRETURN(argvi);
2060 fail:
2061 ;
2062 }
2063 croak(Nullch);
2064 }
2065
2066
2067 XS(_wrap_IntVector_clear) {
2068 {
2069 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
2070 int argvi = 0;
2071 dXSARGS;
2072
2073 if ((items < 1) || (items > 1)) {
2074 SWIG_croak("Usage: IntVector_clear(self);");
2075 }
2076 {
2077 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
2078 SWIG_croak("Type error in argument 1 of IntVector_clear. Expected _p_std__vectorTint_t");
2079 }
2080 }
2081 {
2082 try {
2083 (arg1)->clear();
2084
2085 } catch (const char *msg) {
2086 SWIG_exception(SWIG_RuntimeError, msg);
2087 }
2088 }
2089
2090 XSRETURN(argvi);
2091 fail:
2092 ;
2093 }
2094 croak(Nullch);
2095 }
2096
2097
2098 XS(_wrap_IntVector_push) {
2099 {
2100 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
2101 int arg2 ;
2102 int argvi = 0;
2103 dXSARGS;
2104
2105 if ((items < 2) || (items > 2)) {
2106 SWIG_croak("Usage: IntVector_push(self,x);");
2107 }
2108 {
2109 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
2110 SWIG_croak("Type error in argument 1 of IntVector_push. Expected _p_std__vectorTint_t");
2111 }
2112 }
2113 arg2 = (int) SvIV(ST(1));
2114 {
2115 try {
2116 (arg1)->push_back(arg2);
2117
2118 } catch (const char *msg) {
2119 SWIG_exception(SWIG_RuntimeError, msg);
2120 }
2121 }
2122
2123 XSRETURN(argvi);
2124 fail:
2125 ;
2126 }
2127 croak(Nullch);
2128 }
2129
2130
2131 XS(_wrap_IntVector_pop) {
2132 {
2133 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
2134 int result;
2135 int argvi = 0;
2136 dXSARGS;
2137
2138 if ((items < 1) || (items > 1)) {
2139 SWIG_croak("Usage: IntVector_pop(self);");
2140 }
2141 {
2142 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
2143 SWIG_croak("Type error in argument 1 of IntVector_pop. Expected _p_std__vectorTint_t");
2144 }
2145 }
2146 {
2147 try {
2148 result = (int)std_vector_Sl_int_Sg__pop(arg1);
2149
2150 } catch (std::out_of_range& e) {
2151 SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2152 }
2153 }
2154 ST(argvi) = sv_newmortal();
2155 sv_setiv(ST(argvi++), (IV) result);
2156 XSRETURN(argvi);
2157 fail:
2158 ;
2159 }
2160 croak(Nullch);
2161 }
2162
2163
2164 XS(_wrap_IntVector_get) {
2165 {
2166 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
2167 int arg2 ;
2168 int result;
2169 int argvi = 0;
2170 dXSARGS;
2171
2172 if ((items < 2) || (items > 2)) {
2173 SWIG_croak("Usage: IntVector_get(self,i);");
2174 }
2175 {
2176 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
2177 SWIG_croak("Type error in argument 1 of IntVector_get. Expected _p_std__vectorTint_t");
2178 }
2179 }
2180 arg2 = (int) SvIV(ST(1));
2181 {
2182 try {
2183 result = (int)std_vector_Sl_int_Sg__get(arg1,arg2);
2184
2185 } catch (std::out_of_range& e) {
2186 SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2187 }
2188 }
2189 ST(argvi) = sv_newmortal();
2190 sv_setiv(ST(argvi++), (IV) result);
2191 XSRETURN(argvi);
2192 fail:
2193 ;
2194 }
2195 croak(Nullch);
2196 }
2197
2198
2199 XS(_wrap_IntVector_set) {
2200 {
2201 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
2202 int arg2 ;
2203 int arg3 ;
2204 int argvi = 0;
2205 dXSARGS;
2206
2207 if ((items < 3) || (items > 3)) {
2208 SWIG_croak("Usage: IntVector_set(self,i,x);");
2209 }
2210 {
2211 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
2212 SWIG_croak("Type error in argument 1 of IntVector_set. Expected _p_std__vectorTint_t");
2213 }
2214 }
2215 arg2 = (int) SvIV(ST(1));
2216 arg3 = (int) SvIV(ST(2));
2217 {
2218 try {
2219 std_vector_Sl_int_Sg__set(arg1,arg2,arg3);
2220
2221 } catch (std::out_of_range& e) {
2222 SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2223 }
2224 }
2225
2226 XSRETURN(argvi);
2227 fail:
2228 ;
2229 }
2230 croak(Nullch);
2231 }
2232
2233
2234 XS(_wrap_delete_IntVector) {
2235 {
2236 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
2237 int argvi = 0;
2238 dXSARGS;
2239
2240 if ((items < 1) || (items > 1)) {
2241 SWIG_croak("Usage: delete_IntVector(self);");
2242 }
2243 {
2244 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
2245 SWIG_croak("Type error in argument 1 of delete_IntVector. Expected _p_std__vectorTint_t");
2246 }
2247 }
2248 {
2249 try {
2250 delete arg1;
2251
2252 } catch (const char *msg) {
2253 SWIG_exception(SWIG_RuntimeError, msg);
2254 }
2255 }
2256
2257 XSRETURN(argvi);
2258 fail:
2259 ;
2260 }
2261 croak(Nullch);
2262 }
2263
2264
2265 XS(_wrap_new_StrStrMap__SWIG_0) {
2266 {
2267 std::map<std::string,std::string > *result;
2268 int argvi = 0;
2269 dXSARGS;
2270
2271 if ((items < 0) || (items > 0)) {
2272 SWIG_croak("Usage: new_StrStrMap();");
2273 }
2274 {
2275 try {
2276 result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
2277
2278 } catch (const char *msg) {
2279 SWIG_exception(SWIG_RuntimeError, msg);
2280 }
2281 }
2282 ST(argvi) = sv_newmortal();
2283 SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, SWIG_SHADOW|SWIG_OWNER);
2284 XSRETURN(argvi);
2285 fail:
2286 ;
2287 }
2288 croak(Nullch);
2289 }
2290
2291
2292 XS(_wrap_new_StrStrMap__SWIG_1) {
2293 {
2294 std::map<std::string,std::string > *arg1 = 0 ;
2295 std::map<std::string,std::string > *result;
2296 int argvi = 0;
2297 dXSARGS;
2298
2299 if ((items < 1) || (items > 1)) {
2300 SWIG_croak("Usage: new_StrStrMap(std::map<std::string,std::string > const &);");
2301 }
2302 {
2303 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2304 SWIG_croak("Type error in argument 1 of new_StrStrMap. Expected _p_std__mapTstd__string_std__string_t");
2305 }
2306 }
2307 {
2308 try {
2309 result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
2310
2311 } catch (const char *msg) {
2312 SWIG_exception(SWIG_RuntimeError, msg);
2313 }
2314 }
2315 ST(argvi) = sv_newmortal();
2316 SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, SWIG_SHADOW|SWIG_OWNER);
2317 XSRETURN(argvi);
2318 fail:
2319 ;
2320 }
2321 croak(Nullch);
2322 }
2323
2324
2325 XS(_wrap_new_StrStrMap) {
2326 dXSARGS;
2327
2328 if (items == 0) {
2329 (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrStrMap__SWIG_0); return;
2330 }
2331 if (items == 1) {
2332 int _v;
2333 {
2334 void *tmp;
2335 if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_std__mapTstd__string_std__string_t, 0) == -1) {
2336 _v = 0;
2337 } else {
2338 _v = 1;
2339 }
2340 }
2341 if (_v) {
2342 (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrStrMap__SWIG_1); return;
2343 }
2344 }
2345
2346 croak("No matching function for overloaded 'new_StrStrMap'");
2347 XSRETURN(0);
2348 }
2349
2350
2351 XS(_wrap_StrStrMap_size) {
2352 {
2353 std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
2354 unsigned int result;
2355 int argvi = 0;
2356 dXSARGS;
2357
2358 if ((items < 1) || (items > 1)) {
2359 SWIG_croak("Usage: StrStrMap_size(self);");
2360 }
2361 {
2362 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2363 SWIG_croak("Type error in argument 1 of StrStrMap_size. Expected _p_std__mapTstd__string_std__string_t");
2364 }
2365 }
2366 {
2367 try {
2368 result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
2369
2370 } catch (const char *msg) {
2371 SWIG_exception(SWIG_RuntimeError, msg);
2372 }
2373 }
2374 ST(argvi) = sv_newmortal();
2375 sv_setuv(ST(argvi++), (UV) result);
2376 XSRETURN(argvi);
2377 fail:
2378 ;
2379 }
2380 croak(Nullch);
2381 }
2382
2383
2384 XS(_wrap_StrStrMap_empty) {
2385 {
2386 std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
2387 bool result;
2388 int argvi = 0;
2389 dXSARGS;
2390
2391 if ((items < 1) || (items > 1)) {
2392 SWIG_croak("Usage: StrStrMap_empty(self);");
2393 }
2394 {
2395 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2396 SWIG_croak("Type error in argument 1 of StrStrMap_empty. Expected _p_std__mapTstd__string_std__string_t");
2397 }
2398 }
2399 {
2400 try {
2401 result = (bool)((std::map<std::string,std::string > const *)arg1)->empty();
2402
2403 } catch (const char *msg) {
2404 SWIG_exception(SWIG_RuntimeError, msg);
2405 }
2406 }
2407 ST(argvi) = sv_newmortal();
2408 sv_setiv(ST(argvi++), (IV) result);
2409 XSRETURN(argvi);
2410 fail:
2411 ;
2412 }
2413 croak(Nullch);
2414 }
2415
2416
2417 XS(_wrap_StrStrMap_clear) {
2418 {
2419 std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
2420 int argvi = 0;
2421 dXSARGS;
2422
2423 if ((items < 1) || (items > 1)) {
2424 SWIG_croak("Usage: StrStrMap_clear(self);");
2425 }
2426 {
2427 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2428 SWIG_croak("Type error in argument 1 of StrStrMap_clear. Expected _p_std__mapTstd__string_std__string_t");
2429 }
2430 }
2431 {
2432 try {
2433 (arg1)->clear();
2434
2435 } catch (const char *msg) {
2436 SWIG_exception(SWIG_RuntimeError, msg);
2437 }
2438 }
2439
2440 XSRETURN(argvi);
2441 fail:
2442 ;
2443 }
2444 croak(Nullch);
2445 }
2446
2447
2448 XS(_wrap_StrStrMap_get) {
2449 {
2450 std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
2451 std::string *arg2 = 0 ;
2452 std::string *result;
2453 std::string temp2 ;
2454 int argvi = 0;
2455 dXSARGS;
2456
2457 if ((items < 2) || (items > 2)) {
2458 SWIG_croak("Usage: StrStrMap_get(self,key);");
2459 }
2460 {
2461 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2462 SWIG_croak("Type error in argument 1 of StrStrMap_get. Expected _p_std__mapTstd__string_std__string_t");
2463 }
2464 }
2465 {
2466 STRLEN len;
2467 const char *ptr = SvPV(ST(1), len);
2468 if (!ptr) {
2469 SWIG_croak("Undefined variable in argument 2 of StrStrMap_get.");
2470 } else {
2471 temp2.assign(ptr, len);
2472 arg2 = &temp2;
2473 }
2474 }
2475 {
2476 try {
2477 {
2478 std::string &_result_ref = std_map_Sl_std_string_Sc_std_string_Sg__get(arg1,(std::string const &)*arg2);
2479 result = (std::string *) &_result_ref;
2480 }
2481
2482 } catch (std::out_of_range& e) {
2483 SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2484 }
2485 }
2486 ST(argvi) = sv_newmortal();
2487 SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__string, 0|0);
2488 XSRETURN(argvi);
2489 fail:
2490 ;
2491 }
2492 croak(Nullch);
2493 }
2494
2495
2496 XS(_wrap_StrStrMap_set) {
2497 {
2498 std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
2499 std::string *arg2 = 0 ;
2500 std::string *arg3 = 0 ;
2501 std::string temp2 ;
2502 std::string temp3 ;
2503 int argvi = 0;
2504 dXSARGS;
2505
2506 if ((items < 3) || (items > 3)) {
2507 SWIG_croak("Usage: StrStrMap_set(self,key,x);");
2508 }
2509 {
2510 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2511 SWIG_croak("Type error in argument 1 of StrStrMap_set. Expected _p_std__mapTstd__string_std__string_t");
2512 }
2513 }
2514 {
2515 STRLEN len;
2516 const char *ptr = SvPV(ST(1), len);
2517 if (!ptr) {
2518 SWIG_croak("Undefined variable in argument 2 of StrStrMap_set.");
2519 } else {
2520 temp2.assign(ptr, len);
2521 arg2 = &temp2;
2522 }
2523 }
2524 {
2525 STRLEN len;
2526 const char *ptr = SvPV(ST(2), len);
2527 if (!ptr) {
2528 SWIG_croak("Undefined variable in argument 3 of StrStrMap_set.");
2529 } else {
2530 temp3.assign(ptr, len);
2531 arg3 = &temp3;
2532 }
2533 }
2534 {
2535 try {
2536 std_map_Sl_std_string_Sc_std_string_Sg__set(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
2537
2538 } catch (const char *msg) {
2539 SWIG_exception(SWIG_RuntimeError, msg);
2540 }
2541 }
2542
2543 XSRETURN(argvi);
2544 fail:
2545 ;
2546 }
2547 croak(Nullch);
2548 }
2549
2550
2551 XS(_wrap_StrStrMap_del) {
2552 {
2553 std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
2554 std::string *arg2 = 0 ;
2555 std::string temp2 ;
2556 int argvi = 0;
2557 dXSARGS;
2558
2559 if ((items < 2) || (items > 2)) {
2560 SWIG_croak("Usage: StrStrMap_del(self,key);");
2561 }
2562 {
2563 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2564 SWIG_croak("Type error in argument 1 of StrStrMap_del. Expected _p_std__mapTstd__string_std__string_t");
2565 }
2566 }
2567 {
2568 STRLEN len;
2569 const char *ptr = SvPV(ST(1), len);
2570 if (!ptr) {
2571 SWIG_croak("Undefined variable in argument 2 of StrStrMap_del.");
2572 } else {
2573 temp2.assign(ptr, len);
2574 arg2 = &temp2;
2575 }
2576 }
2577 {
2578 try {
2579 std_map_Sl_std_string_Sc_std_string_Sg__del(arg1,(std::string const &)*arg2);
2580
2581 } catch (std::out_of_range& e) {
2582 SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2583 }
2584 }
2585
2586 XSRETURN(argvi);
2587 fail:
2588 ;
2589 }
2590 croak(Nullch);
2591 }
2592
2593
2594 XS(_wrap_StrStrMap_has_key) {
2595 {
2596 std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
2597 std::string *arg2 = 0 ;
2598 bool result;
2599 std::string temp2 ;
2600 int argvi = 0;
2601 dXSARGS;
2602
2603 if ((items < 2) || (items > 2)) {
2604 SWIG_croak("Usage: StrStrMap_has_key(self,key);");
2605 }
2606 {
2607 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2608 SWIG_croak("Type error in argument 1 of StrStrMap_has_key. Expected _p_std__mapTstd__string_std__string_t");
2609 }
2610 }
2611 {
2612 STRLEN len;
2613 const char *ptr = SvPV(ST(1), len);
2614 if (!ptr) {
2615 SWIG_croak("Undefined variable in argument 2 of StrStrMap_has_key.");
2616 } else {
2617 temp2.assign(ptr, len);
2618 arg2 = &temp2;
2619 }
2620 }
2621 {
2622 try {
2623 result = (bool)std_map_Sl_std_string_Sc_std_string_Sg__has_key(arg1,(std::string const &)*arg2);
2624
2625 } catch (const char *msg) {
2626 SWIG_exception(SWIG_RuntimeError, msg);
2627 }
2628 }
2629 ST(argvi) = sv_newmortal();
2630 sv_setiv(ST(argvi++), (IV) result);
2631 XSRETURN(argvi);
2632 fail:
2633 ;
2634 }
2635 croak(Nullch);
2636 }
2637
2638
2639 XS(_wrap_delete_StrStrMap) {
2640 {
2641 std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
2642 int argvi = 0;
2643 dXSARGS;
2644
2645 if ((items < 1) || (items > 1)) {
2646 SWIG_croak("Usage: delete_StrStrMap(self);");
2647 }
2648 {
2649 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2650 SWIG_croak("Type error in argument 1 of delete_StrStrMap. Expected _p_std__mapTstd__string_std__string_t");
2651 }
2652 }
2653 {
2654 try {
2655 delete arg1;
2656
2657 } catch (const char *msg) {
2658 SWIG_exception(SWIG_RuntimeError, msg);
2659 }
2660 }
2661
2662 XSRETURN(argvi);
2663 fail:
2664 ;
2665 }
2666 croak(Nullch);
2667 }
2668
2669
2670 XS(_wrap_Condition_cond_set) {
2671 {
2672 estraier::Condition *arg1 = (estraier::Condition *) 0 ;
2673 ESTCOND *arg2 = (ESTCOND *) 0 ;
2674 int argvi = 0;
2675 dXSARGS;
2676
2677 if ((items < 2) || (items > 2)) {
2678 SWIG_croak("Usage: Condition_cond_set(self,cond);");
2679 }
2680 {
2681 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
2682 SWIG_croak("Type error in argument 1 of Condition_cond_set. Expected _p_estraier__Condition");
2683 }
2684 }
2685 {
2686 if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_ESTCOND,0) < 0) {
2687 SWIG_croak("Type error in argument 2 of Condition_cond_set. Expected _p_ESTCOND");
2688 }
2689 }
2690 if (arg1) (arg1)->cond = arg2;
2691
2692
2693 XSRETURN(argvi);
2694 fail:
2695 ;
2696 }
2697 croak(Nullch);
2698 }
2699
2700
2701 XS(_wrap_Condition_cond_get) {
2702 {
2703 estraier::Condition *arg1 = (estraier::Condition *) 0 ;
2704 ESTCOND *result;
2705 int argvi = 0;
2706 dXSARGS;
2707
2708 if ((items < 1) || (items > 1)) {
2709 SWIG_croak("Usage: Condition_cond_get(self);");
2710 }
2711 {
2712 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
2713 SWIG_croak("Type error in argument 1 of Condition_cond_get. Expected _p_estraier__Condition");
2714 }
2715 }
2716 result = (ESTCOND *) ((arg1)->cond);
2717
2718 ST(argvi) = sv_newmortal();
2719 SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ESTCOND, 0|0);
2720 XSRETURN(argvi);
2721 fail:
2722 ;
2723 }
2724 croak(Nullch);
2725 }
2726
2727
2728 XS(_wrap_new_Condition) {
2729 {
2730 estraier::Condition *result;
2731 int argvi = 0;
2732 dXSARGS;
2733
2734 if ((items < 0) || (items > 0)) {
2735 SWIG_croak("Usage: new_Condition();");
2736 }
2737 {
2738 try {
2739 result = (estraier::Condition *)new estraier::Condition();
2740
2741 } catch (const char *msg) {
2742 SWIG_exception(SWIG_RuntimeError, msg);
2743 }
2744 }
2745 ST(argvi) = sv_newmortal();
2746 SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_estraier__Condition, SWIG_SHADOW|SWIG_OWNER);
2747 XSRETURN(argvi);
2748 fail:
2749 ;
2750 }
2751 croak(Nullch);
2752 }
2753
2754
2755 XS(_wrap_delete_Condition) {
2756 {
2757 estraier::Condition *arg1 = (estraier::Condition *) 0 ;
2758 int argvi = 0;
2759 dXSARGS;
2760
2761 if ((items < 1) || (items > 1)) {
2762 SWIG_croak("Usage: delete_Condition(self);");
2763 }
2764 {
2765 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
2766 SWIG_croak("Type error in argument 1 of delete_Condition. Expected _p_estraier__Condition");
2767 }
2768 }
2769 {
2770 try {
2771 delete arg1;
2772
2773 } catch (const char *msg) {
2774 SWIG_exception(SWIG_RuntimeError, msg);
2775 }
2776 }
2777
2778 XSRETURN(argvi);
2779 fail:
2780 ;
2781 }
2782 croak(Nullch);
2783 }
2784
2785
2786 XS(_wrap_Condition_set_phrase) {
2787 {
2788 estraier::Condition *arg1 = (estraier::Condition *) 0 ;
2789 char *arg2 = (char *) 0 ;
2790 int argvi = 0;
2791 dXSARGS;
2792
2793 if ((items < 2) || (items > 2)) {
2794 SWIG_croak("Usage: Condition_set_phrase(self,phrase);");
2795 }
2796 {
2797 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
2798 SWIG_croak("Type error in argument 1 of Condition_set_phrase. Expected _p_estraier__Condition");
2799 }
2800 }
2801 if (!SvOK((SV*) ST(1))) arg2 = 0;
2802 else arg2 = (char *) SvPV(ST(1), PL_na);
2803 {
2804 try {
2805 (arg1)->set_phrase((char const *)arg2);
2806
2807 } catch (const char *msg) {
2808 SWIG_exception(SWIG_RuntimeError, msg);
2809 }
2810 }
2811
2812 XSRETURN(argvi);
2813 fail:
2814 ;
2815 }
2816 croak(Nullch);
2817 }
2818
2819
2820 XS(_wrap_Condition_add_attr) {
2821 {
2822 estraier::Condition *arg1 = (estraier::Condition *) 0 ;
2823 char *arg2 = (char *) 0 ;
2824 int argvi = 0;
2825 dXSARGS;
2826
2827 if ((items < 2) || (items > 2)) {
2828 SWIG_croak("Usage: Condition_add_attr(self,expr);");
2829 }
2830 {
2831 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
2832 SWIG_croak("Type error in argument 1 of Condition_add_attr. Expected _p_estraier__Condition");
2833 }
2834 }
2835 if (!SvOK((SV*) ST(1))) arg2 = 0;
2836 else arg2 = (char *) SvPV(ST(1), PL_na);
2837 {
2838 try {
2839 (arg1)->add_attr((char const *)arg2);
2840
2841 } catch (const char *msg) {
2842 SWIG_exception(SWIG_RuntimeError, msg);
2843 }
2844 }
2845
2846 XSRETURN(argvi);
2847 fail:
2848 ;
2849 }
2850 croak(Nullch);
2851 }
2852
2853
2854 XS(_wrap_Condition_set_order) {
2855 {
2856 estraier::Condition *arg1 = (estraier::Condition *) 0 ;
2857 char *arg2 = (char *) 0 ;
2858 int argvi = 0;
2859 dXSARGS;
2860
2861 if ((items < 2) || (items > 2)) {
2862 SWIG_croak("Usage: Condition_set_order(self,expr);");
2863 }
2864 {
2865 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
2866 SWIG_croak("Type error in argument 1 of Condition_set_order. Expected _p_estraier__Condition");
2867 }
2868 }
2869 if (!SvOK((SV*) ST(1))) arg2 = 0;
2870 else arg2 = (char *) SvPV(ST(1), PL_na);
2871 {
2872 try {
2873 (arg1)->set_order((char const *)arg2);
2874
2875 } catch (const char *msg) {
2876 SWIG_exception(SWIG_RuntimeError, msg);
2877 }
2878 }
2879
2880 XSRETURN(argvi);
2881 fail:
2882 ;
2883 }
2884 croak(Nullch);
2885 }
2886
2887
2888 XS(_wrap_Condition_set_max) {
2889 {
2890 estraier::Condition *arg1 = (estraier::Condition *) 0 ;
2891 int arg2 ;
2892 int argvi = 0;
2893 dXSARGS;
2894
2895 if ((items < 2) || (items > 2)) {
2896 SWIG_croak("Usage: Condition_set_max(self,_max);");
2897 }
2898 {
2899 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
2900 SWIG_croak("Type error in argument 1 of Condition_set_max. Expected _p_estraier__Condition");
2901 }
2902 }
2903 arg2 = (int) SvIV(ST(1));
2904 {
2905 try {
2906 (arg1)->set_max(arg2);
2907
2908 } catch (const char *msg) {
2909 SWIG_exception(SWIG_RuntimeError, msg);
2910 }
2911 }
2912
2913 XSRETURN(argvi);
2914 fail:
2915 ;
2916 }
2917 croak(Nullch);
2918 }
2919
2920
2921 XS(_wrap_Condition_set_options) {
2922 {
2923 estraier::Condition *arg1 = (estraier::Condition *) 0 ;
2924 int arg2 ;
2925 int argvi = 0;
2926 dXSARGS;
2927
2928 if ((items < 2) || (items > 2)) {
2929 SWIG_croak("Usage: Condition_set_options(self,options);");
2930 }
2931 {
2932 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
2933 SWIG_croak("Type error in argument 1 of Condition_set_options. Expected _p_estraier__Condition");
2934 }
2935 }
2936 arg2 = (int) SvIV(ST(1));
2937 {
2938 try {
2939 (arg1)->set_options(arg2);
2940
2941 } catch (const char *msg) {
2942 SWIG_exception(SWIG_RuntimeError, msg);
2943 }
2944 }
2945
2946 XSRETURN(argvi);
2947 fail:
2948 ;
2949 }
2950 croak(Nullch);
2951 }
2952
2953
2954 XS(_wrap_Document_doc_set) {
2955 {
2956 estraier::Document *arg1 = (estraier::Document *) 0 ;
2957 ESTDOC *arg2 = (ESTDOC *) 0 ;
2958 int argvi = 0;
2959 dXSARGS;
2960
2961 if ((items < 2) || (items > 2)) {
2962 SWIG_croak("Usage: Document_doc_set(self,doc);");
2963 }
2964 {
2965 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
2966 SWIG_croak("Type error in argument 1 of Document_doc_set. Expected _p_estraier__Document");
2967 }
2968 }
2969 {
2970 if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_ESTDOC,0) < 0) {
2971 SWIG_croak("Type error in argument 2 of Document_doc_set. Expected _p_ESTDOC");
2972 }
2973 }
2974 if (arg1) (arg1)->doc = arg2;
2975
2976
2977 XSRETURN(argvi);
2978 fail:
2979 ;
2980 }
2981 croak(Nullch);
2982 }
2983
2984
2985 XS(_wrap_Document_doc_get) {
2986 {
2987 estraier::Document *arg1 = (estraier::Document *) 0 ;
2988 ESTDOC *result;
2989 int argvi = 0;
2990 dXSARGS;
2991
2992 if ((items < 1) || (items > 1)) {
2993 SWIG_croak("Usage: Document_doc_get(self);");
2994 }
2995 {
2996 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
2997 SWIG_croak("Type error in argument 1 of Document_doc_get. Expected _p_estraier__Document");
2998 }
2999 }
3000 result = (ESTDOC *) ((arg1)->doc);
3001
3002 ST(argvi) = sv_newmortal();
3003 SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ESTDOC, 0|0);
3004 XSRETURN(argvi);
3005 fail:
3006 ;
3007 }
3008 croak(Nullch);
3009 }
3010
3011
3012 XS(_wrap_new_Document__SWIG_0) {
3013 {
3014 estraier::Document *result;
3015 int argvi = 0;
3016 dXSARGS;
3017
3018 if ((items < 0) || (items > 0)) {
3019 SWIG_croak("Usage: new_Document();");
3020 }
3021 {
3022 try {
3023 result = (estraier::Document *)new estraier::Document();
3024
3025 } catch (const char *msg) {
3026 SWIG_exception(SWIG_RuntimeError, msg);
3027 }
3028 }
3029 ST(argvi) = sv_newmortal();
3030 SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_estraier__Document, SWIG_SHADOW|SWIG_OWNER);
3031 XSRETURN(argvi);
3032 fail:
3033 ;
3034 }
3035 croak(Nullch);
3036 }
3037
3038
3039 XS(_wrap_new_Document__SWIG_1) {
3040 {
3041 char *arg1 = (char *) 0 ;
3042 estraier::Document *result;
3043 int argvi = 0;
3044 dXSARGS;
3045
3046 if ((items < 1) || (items > 1)) {
3047 SWIG_croak("Usage: new_Document(draft);");
3048 }
3049 if (!SvOK((SV*) ST(0))) arg1 = 0;
3050 else arg1 = (char *) SvPV(ST(0), PL_na);
3051 {
3052 try {
3053 result = (estraier::Document *)new estraier::Document((char const *)arg1);
3054
3055 } catch (const char *msg) {
3056 SWIG_exception(SWIG_RuntimeError, msg);
3057 }
3058 }
3059 ST(argvi) = sv_newmortal();
3060 SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_estraier__Document, SWIG_SHADOW|SWIG_OWNER);
3061 XSRETURN(argvi);
3062 fail:
3063 ;
3064 }
3065 croak(Nullch);
3066 }
3067
3068
3069 XS(_wrap_new_Document__SWIG_2) {
3070 {
3071 ESTDOC *arg1 = (ESTDOC *) 0 ;
3072 estraier::Document *result;
3073 int argvi = 0;
3074 dXSARGS;
3075
3076 if ((items < 1) || (items > 1)) {
3077 SWIG_croak("Usage: new_Document(_doc);");
3078 }
3079 {
3080 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ESTDOC,0) < 0) {
3081 SWIG_croak("Type error in argument 1 of new_Document. Expected _p_ESTDOC");
3082 }
3083 }
3084 {
3085 try {
3086 result = (estraier::Document *)new estraier::Document(arg1);
3087
3088 } catch (const char *msg) {
3089 SWIG_exception(SWIG_RuntimeError, msg);
3090 }
3091 }
3092 ST(argvi) = sv_newmortal();
3093 SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_estraier__Document, SWIG_SHADOW|SWIG_OWNER);
3094 XSRETURN(argvi);
3095 fail:
3096 ;
3097 }
3098 croak(Nullch);
3099 }
3100
3101
3102 XS(_wrap_new_Document) {
3103 dXSARGS;
3104
3105 if (items == 0) {
3106 (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_Document__SWIG_0); return;
3107 }
3108 if (items == 1) {
3109 int _v;
3110 {
3111 void *tmp;
3112 if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_ESTDOC, 0) == -1) {
3113 _v = 0;
3114 } else {
3115 _v = 1;
3116 }
3117 }
3118 if (_v) {
3119 (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_Document__SWIG_2); return;
3120 }
3121 }
3122 if (items == 1) {
3123 int _v;
3124 {
3125 _v = SvPOK(ST(0)) ? 1 : 0;
3126 }
3127 if (_v) {
3128 (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_Document__SWIG_1); return;
3129 }
3130 }
3131
3132 croak("No matching function for overloaded 'new_Document'");
3133 XSRETURN(0);
3134 }
3135
3136
3137 XS(_wrap_delete_Document) {
3138 {
3139 estraier::Document *arg1 = (estraier::Document *) 0 ;
3140 int argvi = 0;
3141 dXSARGS;
3142
3143 if ((items < 1) || (items > 1)) {
3144 SWIG_croak("Usage: delete_Document(self);");
3145 }
3146 {
3147 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
3148 SWIG_croak("Type error in argument 1 of delete_Document. Expected _p_estraier__Document");
3149 }
3150 }
3151 {
3152 try {
3153 delete arg1;
3154
3155 } catch (const char *msg) {
3156 SWIG_exception(SWIG_RuntimeError, msg);
3157 }
3158 }
3159
3160 XSRETURN(argvi);
3161 fail:
3162 ;
3163 }
3164 croak(Nullch);
3165 }
3166
3167
3168 XS(_wrap_Document_add_attr) {
3169 {
3170 estraier::Document *arg1 = (estraier::Document *) 0 ;
3171 char *arg2 = (char *) 0 ;
3172 char *arg3 = (char *) 0 ;
3173 int argvi = 0;
3174 dXSARGS;
3175
3176 if ((items < 3) || (items > 3)) {
3177 SWIG_croak("Usage: Document_add_attr(self,name,value);");
3178 }
3179 {
3180 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
3181 SWIG_croak("Type error in argument 1 of Document_add_attr. Expected _p_estraier__Document");
3182 }
3183 }
3184 if (!SvOK((SV*) ST(1))) arg2 = 0;
3185 else arg2 = (char *) SvPV(ST(1), PL_na);
3186 if (!SvOK((SV*) ST(2))) arg3 = 0;
3187 else arg3 = (char *) SvPV(ST(2), PL_na);
3188 {
3189 try {
3190 (arg1)->add_attr((char const *)arg2,(char const *)arg3);
3191
3192 } catch (const char *msg) {
3193 SWIG_exception(SWIG_RuntimeError, msg);
3194 }
3195 }
3196
3197 XSRETURN(argvi);
3198 fail:
3199 ;
3200 }
3201 croak(Nullch);
3202 }
3203
3204
3205 XS(_wrap_Document_add_text) {
3206 {
3207 estraier::Document *arg1 = (estraier::Document *) 0 ;
3208 char *arg2 = (char *) 0 ;
3209 int argvi = 0;
3210 dXSARGS;
3211
3212 if ((items < 2) || (items > 2)) {
3213 SWIG_croak("Usage: Document_add_text(self,text);");
3214 }
3215 {
3216 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
3217 SWIG_croak("Type error in argument 1 of Document_add_text. Expected _p_estraier__Document");
3218 }
3219 }
3220 if (!SvOK((SV*) ST(1))) arg2 = 0;
3221 else arg2 = (char *) SvPV(ST(1), PL_na);
3222 {
3223 try {
3224 (arg1)->add_text((char const *)arg2);
3225
3226 } catch (const char *msg) {
3227 SWIG_exception(SWIG_RuntimeError, msg);
3228 }
3229 }
3230
3231 XSRETURN(argvi);
3232 fail:
3233 ;
3234 }
3235 croak(Nullch);
3236 }
3237
3238
3239 XS(_wrap_Document_add_hidden_text) {
3240 {
3241 estraier::Document *arg1 = (estraier::Document *) 0 ;
3242 char *arg2 = (char *) 0 ;
3243 int argvi = 0;
3244 dXSARGS;
3245
3246 if ((items < 2) || (items > 2)) {
3247 SWIG_croak("Usage: Document_add_hidden_text(self,text);");
3248 }
3249 {
3250 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
3251 SWIG_croak("Type error in argument 1 of Document_add_hidden_text. Expected _p_estraier__Document");
3252 }
3253 }
3254 if (!SvOK((SV*) ST(1))) arg2 = 0;
3255 else arg2 = (char *) SvPV(ST(1), PL_na);
3256 {
3257 try {
3258 (arg1)->add_hidden_text((char const *)arg2);
3259
3260 } catch (const char *msg) {
3261 SWIG_exception(SWIG_RuntimeError, msg);
3262 }
3263 }
3264
3265 XSRETURN(argvi);
3266 fail:
3267 ;
3268 }
3269 croak(Nullch);
3270 }
3271
3272
3273 XS(_wrap_Document_id) {
3274 {
3275 estraier::Document *arg1 = (estraier::Document *) 0 ;
3276 int result;
3277 int argvi = 0;
3278 dXSARGS;
3279
3280 if ((items < 1) || (items > 1)) {
3281 SWIG_croak("Usage: Document_id(self);");
3282 }
3283 {
3284 if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
3285 SWIG_croak("Type error in argument 1 of Document_id. Expected _p_estraier__Document");
3286 }
3287 }
3288 {
3289 try {
3290 result = (int)(arg1)->id();
3291
3292 } catch (const char *msg) {
3293 SWIG_exception(SWIG_RuntimeError, msg);
3294 }
3295 }
3296 ST(argvi) = sv_newmortal();
3297 sv_setiv(ST(argvi++), (IV) result);
3298 XSRETURN(argvi);
3299 fail:
3300 ;
3301 }
3302 croak(Nullch);
3303 }
3304
3305
3306 XS(_wrap_Document_attr_names) {
3307 {
3308 estraier::Document *arg1 = (estraier::Document *) 0 ;
3309 std::vector<std::string > *result;
3310 int argvi = 0;
3311 dXSARGS;
3312
3313 if ((items < 1) || (items > 1)) {
3314 SWIG_croak("Usage: Document_attr_names(self);");
3315 }
3316 {
3317