1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 3.0.12
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11
12 #ifndef SWIGRUBY
13 #define SWIGRUBY
14 #endif
15
16
17 /* -----------------------------------------------------------------------------
18 * This section contains generic SWIG labels for method/variable
19 * declarations/attributes, and other compiler dependent labels.
20 * ----------------------------------------------------------------------------- */
21
22 /* template workaround for compilers that cannot correctly implement the C++ standard */
23 #ifndef SWIGTEMPLATEDISAMBIGUATOR
24 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
25 # define SWIGTEMPLATEDISAMBIGUATOR template
26 # elif defined(__HP_aCC)
27 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
28 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
29 # define SWIGTEMPLATEDISAMBIGUATOR template
30 # else
31 # define SWIGTEMPLATEDISAMBIGUATOR
32 # endif
33 #endif
34
35 /* inline attribute */
36 #ifndef SWIGINLINE
37 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
38 # define SWIGINLINE inline
39 # else
40 # define SWIGINLINE
41 # endif
42 #endif
43
44 /* attribute recognised by some compilers to avoid 'unused' warnings */
45 #ifndef SWIGUNUSED
46 # if defined(__GNUC__)
47 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
48 # define SWIGUNUSED __attribute__ ((__unused__))
49 # else
50 # define SWIGUNUSED
51 # endif
52 # elif defined(__ICC)
53 # define SWIGUNUSED __attribute__ ((__unused__))
54 # else
55 # define SWIGUNUSED
56 # endif
57 #endif
58
59 #ifndef SWIG_MSC_UNSUPPRESS_4505
60 # if defined(_MSC_VER)
61 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
62 # endif
63 #endif
64
65 #ifndef SWIGUNUSEDPARM
66 # ifdef __cplusplus
67 # define SWIGUNUSEDPARM(p)
68 # else
69 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
70 # endif
71 #endif
72
73 /* internal SWIG method */
74 #ifndef SWIGINTERN
75 # define SWIGINTERN static SWIGUNUSED
76 #endif
77
78 /* internal inline SWIG method */
79 #ifndef SWIGINTERNINLINE
80 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
81 #endif
82
83 /* exporting methods */
84 #if defined(__GNUC__)
85 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
86 # ifndef GCC_HASCLASSVISIBILITY
87 # define GCC_HASCLASSVISIBILITY
88 # endif
89 # endif
90 #endif
91
92 #ifndef SWIGEXPORT
93 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
94 # if defined(STATIC_LINKED)
95 # define SWIGEXPORT
96 # else
97 # define SWIGEXPORT __declspec(dllexport)
98 # endif
99 # else
100 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
101 # define SWIGEXPORT __attribute__ ((visibility("default")))
102 # else
103 # define SWIGEXPORT
104 # endif
105 # endif
106 #endif
107
108 /* calling conventions for Windows */
109 #ifndef SWIGSTDCALL
110 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
111 # define SWIGSTDCALL __stdcall
112 # else
113 # define SWIGSTDCALL
114 # endif
115 #endif
116
117 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
118 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
119 # define _CRT_SECURE_NO_DEPRECATE
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
123 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
124 # define _SCL_SECURE_NO_DEPRECATE
125 #endif
126
127 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
128 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
129 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
130 #endif
131
132 /* Intel's compiler complains if a variable which was never initialised is
133 * cast to void, which is a common idiom which we use to indicate that we
134 * are aware a variable isn't used. So we just silence that warning.
135 * See: https://github.com/swig/swig/issues/192 for more discussion.
136 */
137 #ifdef __INTEL_COMPILER
138 # pragma warning disable 592
139 #endif
140
141 /* -----------------------------------------------------------------------------
142 * This section contains generic SWIG labels for method/variable
143 * declarations/attributes, and other compiler dependent labels.
144 * ----------------------------------------------------------------------------- */
145
146 /* template workaround for compilers that cannot correctly implement the C++ standard */
147 #ifndef SWIGTEMPLATEDISAMBIGUATOR
148 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
149 # define SWIGTEMPLATEDISAMBIGUATOR template
150 # elif defined(__HP_aCC)
151 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
152 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
153 # define SWIGTEMPLATEDISAMBIGUATOR template
154 # else
155 # define SWIGTEMPLATEDISAMBIGUATOR
156 # endif
157 #endif
158
159 /* inline attribute */
160 #ifndef SWIGINLINE
161 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
162 # define SWIGINLINE inline
163 # else
164 # define SWIGINLINE
165 # endif
166 #endif
167
168 /* attribute recognised by some compilers to avoid 'unused' warnings */
169 #ifndef SWIGUNUSED
170 # if defined(__GNUC__)
171 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
172 # define SWIGUNUSED __attribute__ ((__unused__))
173 # else
174 # define SWIGUNUSED
175 # endif
176 # elif defined(__ICC)
177 # define SWIGUNUSED __attribute__ ((__unused__))
178 # else
179 # define SWIGUNUSED
180 # endif
181 #endif
182
183 #ifndef SWIG_MSC_UNSUPPRESS_4505
184 # if defined(_MSC_VER)
185 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
186 # endif
187 #endif
188
189 #ifndef SWIGUNUSEDPARM
190 # ifdef __cplusplus
191 # define SWIGUNUSEDPARM(p)
192 # else
193 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
194 # endif
195 #endif
196
197 /* internal SWIG method */
198 #ifndef SWIGINTERN
199 # define SWIGINTERN static SWIGUNUSED
200 #endif
201
202 /* internal inline SWIG method */
203 #ifndef SWIGINTERNINLINE
204 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
205 #endif
206
207 /* exporting methods */
208 #if defined(__GNUC__)
209 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
210 # ifndef GCC_HASCLASSVISIBILITY
211 # define GCC_HASCLASSVISIBILITY
212 # endif
213 # endif
214 #endif
215
216 #ifndef SWIGEXPORT
217 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
218 # if defined(STATIC_LINKED)
219 # define SWIGEXPORT
220 # else
221 # define SWIGEXPORT __declspec(dllexport)
222 # endif
223 # else
224 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
225 # define SWIGEXPORT __attribute__ ((visibility("default")))
226 # else
227 # define SWIGEXPORT
228 # endif
229 # endif
230 #endif
231
232 /* calling conventions for Windows */
233 #ifndef SWIGSTDCALL
234 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
235 # define SWIGSTDCALL __stdcall
236 # else
237 # define SWIGSTDCALL
238 # endif
239 #endif
240
241 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
242 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
243 # define _CRT_SECURE_NO_DEPRECATE
244 #endif
245
246 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
247 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
248 # define _SCL_SECURE_NO_DEPRECATE
249 #endif
250
251 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
252 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
253 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
254 #endif
255
256 /* Intel's compiler complains if a variable which was never initialised is
257 * cast to void, which is a common idiom which we use to indicate that we
258 * are aware a variable isn't used. So we just silence that warning.
259 * See: https://github.com/swig/swig/issues/192 for more discussion.
260 */
261 #ifdef __INTEL_COMPILER
262 # pragma warning disable 592
263 #endif
264
265 /* -----------------------------------------------------------------------------
266 * swigrun.swg
267 *
268 * This file contains generic C API SWIG runtime support for pointer
269 * type checking.
270 * ----------------------------------------------------------------------------- */
271
272 /* This should only be incremented when either the layout of swig_type_info changes,
273 or for whatever reason, the runtime changes incompatibly */
274 #define SWIG_RUNTIME_VERSION "4"
275
276 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
277 #ifdef SWIG_TYPE_TABLE
278 # define SWIG_QUOTE_STRING(x) #x
279 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
280 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
281 #else
282 # define SWIG_TYPE_TABLE_NAME
283 #endif
284
285 /*
286 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
287 creating a static or dynamic library from the SWIG runtime code.
288 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
289
290 But only do this if strictly necessary, ie, if you have problems
291 with your compiler or suchlike.
292 */
293
294 #ifndef SWIGRUNTIME
295 # define SWIGRUNTIME SWIGINTERN
296 #endif
297
298 #ifndef SWIGRUNTIMEINLINE
299 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
300 #endif
301
302 /* Generic buffer size */
303 #ifndef SWIG_BUFFER_SIZE
304 # define SWIG_BUFFER_SIZE 1024
305 #endif
306
307 /* Flags for pointer conversions */
308 #define SWIG_POINTER_DISOWN 0x1
309 #define SWIG_CAST_NEW_MEMORY 0x2
310
311 /* Flags for new pointer objects */
312 #define SWIG_POINTER_OWN 0x1
313
314
315 /*
316 Flags/methods for returning states.
317
318 The SWIG conversion methods, as ConvertPtr, return an integer
319 that tells if the conversion was successful or not. And if not,
320 an error code can be returned (see swigerrors.swg for the codes).
321
322 Use the following macros/flags to set or process the returning
323 states.
324
325 In old versions of SWIG, code such as the following was usually written:
326
327 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
328 // success code
329 } else {
330 //fail code
331 }
332
333 Now you can be more explicit:
334
335 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
336 if (SWIG_IsOK(res)) {
337 // success code
338 } else {
339 // fail code
340 }
341
342 which is the same really, but now you can also do
343
344 Type *ptr;
345 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
346 if (SWIG_IsOK(res)) {
347 // success code
348 if (SWIG_IsNewObj(res) {
349 ...
350 delete *ptr;
351 } else {
352 ...
353 }
354 } else {
355 // fail code
356 }
357
358 I.e., now SWIG_ConvertPtr can return new objects and you can
359 identify the case and take care of the deallocation. Of course that
360 also requires SWIG_ConvertPtr to return new result values, such as
361
362 int SWIG_ConvertPtr(obj, ptr,...) {
363 if (<obj is ok>) {
364 if (<need new object>) {
365 *ptr = <ptr to new allocated object>;
366 return SWIG_NEWOBJ;
367 } else {
368 *ptr = <ptr to old object>;
369 return SWIG_OLDOBJ;
370 }
371 } else {
372 return SWIG_BADOBJ;
373 }
374 }
375
376 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
377 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
378 SWIG errors code.
379
380 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
381 allows to return the 'cast rank', for example, if you have this
382
383 int food(double)
384 int fooi(int);
385
386 and you call
387
388 food(1) // cast rank '1' (1 -> 1.0)
389 fooi(1) // cast rank '0'
390
391 just use the SWIG_AddCast()/SWIG_CheckState()
392 */
393
394 #define SWIG_OK (0)
395 #define SWIG_ERROR (-1)
396 #define SWIG_IsOK(r) (r >= 0)
397 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
398
399 /* The CastRankLimit says how many bits are used for the cast rank */
400 #define SWIG_CASTRANKLIMIT (1 << 8)
401 /* The NewMask denotes the object was created (using new/malloc) */
402 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
403 /* The TmpMask is for in/out typemaps that use temporal objects */
404 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
405 /* Simple returning values */
406 #define SWIG_BADOBJ (SWIG_ERROR)
407 #define SWIG_OLDOBJ (SWIG_OK)
408 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
409 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
410 /* Check, add and del mask methods */
411 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
412 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
413 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
414 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
415 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
416 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
417
418 /* Cast-Rank Mode */
419 #if defined(SWIG_CASTRANK_MODE)
420 # ifndef SWIG_TypeRank
421 # define SWIG_TypeRank unsigned long
422 # endif
423 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
424 # define SWIG_MAXCASTRANK (2)
425 # endif
426 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
427 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIG_AddCast(int r)428 SWIGINTERNINLINE int SWIG_AddCast(int r) {
429 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
430 }
SWIG_CheckState(int r)431 SWIGINTERNINLINE int SWIG_CheckState(int r) {
432 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
433 }
434 #else /* no cast-rank mode */
435 # define SWIG_AddCast(r) (r)
436 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
437 #endif
438
439
440 #include <string.h>
441
442 #ifdef __cplusplus
443 extern "C" {
444 #endif
445
446 typedef void *(*swig_converter_func)(void *, int *);
447 typedef struct swig_type_info *(*swig_dycast_func)(void **);
448
449 /* Structure to store information on one type */
450 typedef struct swig_type_info {
451 const char *name; /* mangled name of this type */
452 const char *str; /* human readable name of this type */
453 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
454 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
455 void *clientdata; /* language specific type data */
456 int owndata; /* flag if the structure owns the clientdata */
457 } swig_type_info;
458
459 /* Structure to store a type and conversion function used for casting */
460 typedef struct swig_cast_info {
461 swig_type_info *type; /* pointer to type that is equivalent to this type */
462 swig_converter_func converter; /* function to cast the void pointers */
463 struct swig_cast_info *next; /* pointer to next cast in linked list */
464 struct swig_cast_info *prev; /* pointer to the previous cast */
465 } swig_cast_info;
466
467 /* Structure used to store module information
468 * Each module generates one structure like this, and the runtime collects
469 * all of these structures and stores them in a circularly linked list.*/
470 typedef struct swig_module_info {
471 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
472 size_t size; /* Number of types in this module */
473 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
474 swig_type_info **type_initial; /* Array of initially generated type structures */
475 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
476 void *clientdata; /* Language specific module data */
477 } swig_module_info;
478
479 /*
480 Compare two type names skipping the space characters, therefore
481 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
482
483 Return 0 when the two name types are equivalent, as in
484 strncmp, but skipping ' '.
485 */
486 SWIGRUNTIME int
SWIG_TypeNameComp(const char * f1,const char * l1,const char * f2,const char * l2)487 SWIG_TypeNameComp(const char *f1, const char *l1,
488 const char *f2, const char *l2) {
489 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
490 while ((*f1 == ' ') && (f1 != l1)) ++f1;
491 while ((*f2 == ' ') && (f2 != l2)) ++f2;
492 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
493 }
494 return (int)((l1 - f1) - (l2 - f2));
495 }
496
497 /*
498 Check type equivalence in a name list like <name1>|<name2>|...
499 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
500 */
501 SWIGRUNTIME int
SWIG_TypeCmp(const char * nb,const char * tb)502 SWIG_TypeCmp(const char *nb, const char *tb) {
503 int equiv = 1;
504 const char* te = tb + strlen(tb);
505 const char* ne = nb;
506 while (equiv != 0 && *ne) {
507 for (nb = ne; *ne; ++ne) {
508 if (*ne == '|') break;
509 }
510 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
511 if (*ne) ++ne;
512 }
513 return equiv;
514 }
515
516 /*
517 Check type equivalence in a name list like <name1>|<name2>|...
518 Return 0 if not equal, 1 if equal
519 */
520 SWIGRUNTIME int
SWIG_TypeEquiv(const char * nb,const char * tb)521 SWIG_TypeEquiv(const char *nb, const char *tb) {
522 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
523 }
524
525 /*
526 Check the typename
527 */
528 SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char * c,swig_type_info * ty)529 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
530 if (ty) {
531 swig_cast_info *iter = ty->cast;
532 while (iter) {
533 if (strcmp(iter->type->name, c) == 0) {
534 if (iter == ty->cast)
535 return iter;
536 /* Move iter to the top of the linked list */
537 iter->prev->next = iter->next;
538 if (iter->next)
539 iter->next->prev = iter->prev;
540 iter->next = ty->cast;
541 iter->prev = 0;
542 if (ty->cast) ty->cast->prev = iter;
543 ty->cast = iter;
544 return iter;
545 }
546 iter = iter->next;
547 }
548 }
549 return 0;
550 }
551
552 /*
553 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
554 */
555 SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info * from,swig_type_info * ty)556 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
557 if (ty) {
558 swig_cast_info *iter = ty->cast;
559 while (iter) {
560 if (iter->type == from) {
561 if (iter == ty->cast)
562 return iter;
563 /* Move iter to the top of the linked list */
564 iter->prev->next = iter->next;
565 if (iter->next)
566 iter->next->prev = iter->prev;
567 iter->next = ty->cast;
568 iter->prev = 0;
569 if (ty->cast) ty->cast->prev = iter;
570 ty->cast = iter;
571 return iter;
572 }
573 iter = iter->next;
574 }
575 }
576 return 0;
577 }
578
579 /*
580 Cast a pointer up an inheritance hierarchy
581 */
582 SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info * ty,void * ptr,int * newmemory)583 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
584 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
585 }
586
587 /*
588 Dynamic pointer casting. Down an inheritance hierarchy
589 */
590 SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info * ty,void ** ptr)591 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
592 swig_type_info *lastty = ty;
593 if (!ty || !ty->dcast) return ty;
594 while (ty && (ty->dcast)) {
595 ty = (*ty->dcast)(ptr);
596 if (ty) lastty = ty;
597 }
598 return lastty;
599 }
600
601 /*
602 Return the name associated with this type
603 */
604 SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info * ty)605 SWIG_TypeName(const swig_type_info *ty) {
606 return ty->name;
607 }
608
609 /*
610 Return the pretty name associated with this type,
611 that is an unmangled type name in a form presentable to the user.
612 */
613 SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info * type)614 SWIG_TypePrettyName(const swig_type_info *type) {
615 /* The "str" field contains the equivalent pretty names of the
616 type, separated by vertical-bar characters. We choose
617 to print the last name, as it is often (?) the most
618 specific. */
619 if (!type) return NULL;
620 if (type->str != NULL) {
621 const char *last_name = type->str;
622 const char *s;
623 for (s = type->str; *s; s++)
624 if (*s == '|') last_name = s+1;
625 return last_name;
626 }
627 else
628 return type->name;
629 }
630
631 /*
632 Set the clientdata field for a type
633 */
634 SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info * ti,void * clientdata)635 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
636 swig_cast_info *cast = ti->cast;
637 /* if (ti->clientdata == clientdata) return; */
638 ti->clientdata = clientdata;
639
640 while (cast) {
641 if (!cast->converter) {
642 swig_type_info *tc = cast->type;
643 if (!tc->clientdata) {
644 SWIG_TypeClientData(tc, clientdata);
645 }
646 }
647 cast = cast->next;
648 }
649 }
650 SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info * ti,void * clientdata)651 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
652 SWIG_TypeClientData(ti, clientdata);
653 ti->owndata = 1;
654 }
655
656 /*
657 Search for a swig_type_info structure only by mangled name
658 Search is a O(log #types)
659
660 We start searching at module start, and finish searching when start == end.
661 Note: if start == end at the beginning of the function, we go all the way around
662 the circular list.
663 */
664 SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info * start,swig_module_info * end,const char * name)665 SWIG_MangledTypeQueryModule(swig_module_info *start,
666 swig_module_info *end,
667 const char *name) {
668 swig_module_info *iter = start;
669 do {
670 if (iter->size) {
671 size_t l = 0;
672 size_t r = iter->size - 1;
673 do {
674 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
675 size_t i = (l + r) >> 1;
676 const char *iname = iter->types[i]->name;
677 if (iname) {
678 int compare = strcmp(name, iname);
679 if (compare == 0) {
680 return iter->types[i];
681 } else if (compare < 0) {
682 if (i) {
683 r = i - 1;
684 } else {
685 break;
686 }
687 } else if (compare > 0) {
688 l = i + 1;
689 }
690 } else {
691 break; /* should never happen */
692 }
693 } while (l <= r);
694 }
695 iter = iter->next;
696 } while (iter != end);
697 return 0;
698 }
699
700 /*
701 Search for a swig_type_info structure for either a mangled name or a human readable name.
702 It first searches the mangled names of the types, which is a O(log #types)
703 If a type is not found it then searches the human readable names, which is O(#types).
704
705 We start searching at module start, and finish searching when start == end.
706 Note: if start == end at the beginning of the function, we go all the way around
707 the circular list.
708 */
709 SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info * start,swig_module_info * end,const char * name)710 SWIG_TypeQueryModule(swig_module_info *start,
711 swig_module_info *end,
712 const char *name) {
713 /* STEP 1: Search the name field using binary search */
714 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
715 if (ret) {
716 return ret;
717 } else {
718 /* STEP 2: If the type hasn't been found, do a complete search
719 of the str field (the human readable name) */
720 swig_module_info *iter = start;
721 do {
722 size_t i = 0;
723 for (; i < iter->size; ++i) {
724 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
725 return iter->types[i];
726 }
727 iter = iter->next;
728 } while (iter != end);
729 }
730
731 /* neither found a match */
732 return 0;
733 }
734
735 /*
736 Pack binary data into a string
737 */
738 SWIGRUNTIME char *
SWIG_PackData(char * c,void * ptr,size_t sz)739 SWIG_PackData(char *c, void *ptr, size_t sz) {
740 static const char hex[17] = "0123456789abcdef";
741 const unsigned char *u = (unsigned char *) ptr;
742 const unsigned char *eu = u + sz;
743 for (; u != eu; ++u) {
744 unsigned char uu = *u;
745 *(c++) = hex[(uu & 0xf0) >> 4];
746 *(c++) = hex[uu & 0xf];
747 }
748 return c;
749 }
750
751 /*
752 Unpack binary data from a string
753 */
754 SWIGRUNTIME const char *
SWIG_UnpackData(const char * c,void * ptr,size_t sz)755 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
756 unsigned char *u = (unsigned char *) ptr;
757 const unsigned char *eu = u + sz;
758 for (; u != eu; ++u) {
759 char d = *(c++);
760 unsigned char uu;
761 if ((d >= '0') && (d <= '9'))
762 uu = (unsigned char)((d - '0') << 4);
763 else if ((d >= 'a') && (d <= 'f'))
764 uu = (unsigned char)((d - ('a'-10)) << 4);
765 else
766 return (char *) 0;
767 d = *(c++);
768 if ((d >= '0') && (d <= '9'))
769 uu |= (unsigned char)(d - '0');
770 else if ((d >= 'a') && (d <= 'f'))
771 uu |= (unsigned char)(d - ('a'-10));
772 else
773 return (char *) 0;
774 *u = uu;
775 }
776 return c;
777 }
778
779 /*
780 Pack 'void *' into a string buffer.
781 */
782 SWIGRUNTIME char *
SWIG_PackVoidPtr(char * buff,void * ptr,const char * name,size_t bsz)783 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
784 char *r = buff;
785 if ((2*sizeof(void *) + 2) > bsz) return 0;
786 *(r++) = '_';
787 r = SWIG_PackData(r,&ptr,sizeof(void *));
788 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
789 strcpy(r,name);
790 return buff;
791 }
792
793 SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char * c,void ** ptr,const char * name)794 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
795 if (*c != '_') {
796 if (strcmp(c,"NULL") == 0) {
797 *ptr = (void *) 0;
798 return name;
799 } else {
800 return 0;
801 }
802 }
803 return SWIG_UnpackData(++c,ptr,sizeof(void *));
804 }
805
806 SWIGRUNTIME char *
SWIG_PackDataName(char * buff,void * ptr,size_t sz,const char * name,size_t bsz)807 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
808 char *r = buff;
809 size_t lname = (name ? strlen(name) : 0);
810 if ((2*sz + 2 + lname) > bsz) return 0;
811 *(r++) = '_';
812 r = SWIG_PackData(r,ptr,sz);
813 if (lname) {
814 strncpy(r,name,lname+1);
815 } else {
816 *r = 0;
817 }
818 return buff;
819 }
820
821 SWIGRUNTIME const char *
SWIG_UnpackDataName(const char * c,void * ptr,size_t sz,const char * name)822 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
823 if (*c != '_') {
824 if (strcmp(c,"NULL") == 0) {
825 memset(ptr,0,sz);
826 return name;
827 } else {
828 return 0;
829 }
830 }
831 return SWIG_UnpackData(++c,ptr,sz);
832 }
833
834 #ifdef __cplusplus
835 }
836 #endif
837
838 /* Errors in SWIG */
839 #define SWIG_UnknownError -1
840 #define SWIG_IOError -2
841 #define SWIG_RuntimeError -3
842 #define SWIG_IndexError -4
843 #define SWIG_TypeError -5
844 #define SWIG_DivisionByZero -6
845 #define SWIG_OverflowError -7
846 #define SWIG_SyntaxError -8
847 #define SWIG_ValueError -9
848 #define SWIG_SystemError -10
849 #define SWIG_AttributeError -11
850 #define SWIG_MemoryError -12
851 #define SWIG_NullReferenceError -13
852
853
854
855 #include <ruby.h>
856
857 /* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
858 * breaks using rb_intern as an lvalue, as SWIG does. We work around this
859 * issue for now by disabling this.
860 * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
861 */
862 #ifdef rb_intern
863 # undef rb_intern
864 #endif
865
866 /* Remove global macros defined in Ruby's win32.h */
867 #ifdef write
868 # undef write
869 #endif
870 #ifdef read
871 # undef read
872 #endif
873 #ifdef bind
874 # undef bind
875 #endif
876 #ifdef close
877 # undef close
878 #endif
879 #ifdef connect
880 # undef connect
881 #endif
882
883
884 /* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
885 #ifndef NUM2LL
886 #define NUM2LL(x) NUM2LONG((x))
887 #endif
888 #ifndef LL2NUM
889 #define LL2NUM(x) INT2NUM((long) (x))
890 #endif
891 #ifndef ULL2NUM
892 #define ULL2NUM(x) UINT2NUM((unsigned long) (x))
893 #endif
894
895 /* Ruby 1.7 doesn't (yet) define NUM2ULL() */
896 #ifndef NUM2ULL
897 #ifdef HAVE_LONG_LONG
898 #define NUM2ULL(x) rb_num2ull((x))
899 #else
900 #define NUM2ULL(x) NUM2ULONG(x)
901 #endif
902 #endif
903
904 /* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
905 /* Define these for older versions so we can just write code the new way */
906 #ifndef RSTRING_LEN
907 # define RSTRING_LEN(x) RSTRING(x)->len
908 #endif
909 #ifndef RSTRING_PTR
910 # define RSTRING_PTR(x) RSTRING(x)->ptr
911 #endif
912 #ifndef RSTRING_END
913 # define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
914 #endif
915 #ifndef RARRAY_LEN
916 # define RARRAY_LEN(x) RARRAY(x)->len
917 #endif
918 #ifndef RARRAY_PTR
919 # define RARRAY_PTR(x) RARRAY(x)->ptr
920 #endif
921 #ifndef RFLOAT_VALUE
922 # define RFLOAT_VALUE(x) RFLOAT(x)->value
923 #endif
924 #ifndef DOUBLE2NUM
925 # define DOUBLE2NUM(x) rb_float_new(x)
926 #endif
927 #ifndef RHASH_TBL
928 # define RHASH_TBL(x) (RHASH(x)->tbl)
929 #endif
930 #ifndef RHASH_ITER_LEV
931 # define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
932 #endif
933 #ifndef RHASH_IFNONE
934 # define RHASH_IFNONE(x) (RHASH(x)->ifnone)
935 #endif
936 #ifndef RHASH_SIZE
937 # define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
938 #endif
939 #ifndef RHASH_EMPTY_P
940 # define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
941 #endif
942 #ifndef RSTRUCT_LEN
943 # define RSTRUCT_LEN(x) RSTRUCT(x)->len
944 #endif
945 #ifndef RSTRUCT_PTR
946 # define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
947 #endif
948
949
950
951 /*
952 * Need to be very careful about how these macros are defined, especially
953 * when compiling C++ code or C code with an ANSI C compiler.
954 *
955 * VALUEFUNC(f) is a macro used to typecast a C function that implements
956 * a Ruby method so that it can be passed as an argument to API functions
957 * like rb_define_method() and rb_define_singleton_method().
958 *
959 * VOIDFUNC(f) is a macro used to typecast a C function that implements
960 * either the "mark" or "free" stuff for a Ruby Data object, so that it
961 * can be passed as an argument to API functions like Data_Wrap_Struct()
962 * and Data_Make_Struct().
963 */
964
965 #ifdef __cplusplus
966 # ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
967 # define PROTECTFUNC(f) ((VALUE (*)()) f)
968 # define VALUEFUNC(f) ((VALUE (*)()) f)
969 # define VOIDFUNC(f) ((void (*)()) f)
970 # else
971 # ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
972 # define PROTECTFUNC(f) ((VALUE (*)()) f)
973 # define VALUEFUNC(f) ((VALUE (*)()) f)
974 # define VOIDFUNC(f) ((RUBY_DATA_FUNC) f)
975 # else /* These definitions should work for Ruby 1.7+ */
976 # define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
977 # define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
978 # define VOIDFUNC(f) ((RUBY_DATA_FUNC) f)
979 # endif
980 # endif
981 #else
982 # define VALUEFUNC(f) (f)
983 # define VOIDFUNC(f) (f)
984 #endif
985
986 /* Don't use for expressions have side effect */
987 #ifndef RB_STRING_VALUE
988 #define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
989 #endif
990 #ifndef StringValue
991 #define StringValue(s) RB_STRING_VALUE(s)
992 #endif
993 #ifndef StringValuePtr
994 #define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
995 #endif
996 #ifndef StringValueLen
997 #define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
998 #endif
999 #ifndef SafeStringValue
1000 #define SafeStringValue(v) do {\
1001 StringValue(v);\
1002 rb_check_safe_str(v);\
1003 } while (0)
1004 #endif
1005
1006 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
1007 #define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
1008 #define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
1009 #endif
1010
1011 static VALUE _mSWIG = Qnil;
1012
1013 /* -----------------------------------------------------------------------------
1014 * error manipulation
1015 * ----------------------------------------------------------------------------- */
1016
1017
1018 /* Define some additional error types */
1019 #define SWIG_ObjectPreviouslyDeletedError -100
1020
1021
1022 /* Define custom exceptions for errors that do not map to existing Ruby
1023 exceptions. Note this only works for C++ since a global cannot be
1024 initialized by a function in C. For C, fallback to rb_eRuntimeError.*/
1025
1026 SWIGINTERN VALUE
getNullReferenceError(void)1027 getNullReferenceError(void) {
1028 static int init = 0;
1029 static VALUE rb_eNullReferenceError ;
1030 if (!init) {
1031 init = 1;
1032 rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
1033 }
1034 return rb_eNullReferenceError;
1035 }
1036
1037 SWIGINTERN VALUE
getObjectPreviouslyDeletedError(void)1038 getObjectPreviouslyDeletedError(void) {
1039 static int init = 0;
1040 static VALUE rb_eObjectPreviouslyDeleted ;
1041 if (!init) {
1042 init = 1;
1043 rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
1044 }
1045 return rb_eObjectPreviouslyDeleted;
1046 }
1047
1048
1049 SWIGINTERN VALUE
SWIG_Ruby_ErrorType(int SWIG_code)1050 SWIG_Ruby_ErrorType(int SWIG_code) {
1051 VALUE type;
1052 switch (SWIG_code) {
1053 case SWIG_MemoryError:
1054 type = rb_eNoMemError;
1055 break;
1056 case SWIG_IOError:
1057 type = rb_eIOError;
1058 break;
1059 case SWIG_RuntimeError:
1060 type = rb_eRuntimeError;
1061 break;
1062 case SWIG_IndexError:
1063 type = rb_eIndexError;
1064 break;
1065 case SWIG_TypeError:
1066 type = rb_eTypeError;
1067 break;
1068 case SWIG_DivisionByZero:
1069 type = rb_eZeroDivError;
1070 break;
1071 case SWIG_OverflowError:
1072 type = rb_eRangeError;
1073 break;
1074 case SWIG_SyntaxError:
1075 type = rb_eSyntaxError;
1076 break;
1077 case SWIG_ValueError:
1078 type = rb_eArgError;
1079 break;
1080 case SWIG_SystemError:
1081 type = rb_eFatal;
1082 break;
1083 case SWIG_AttributeError:
1084 type = rb_eRuntimeError;
1085 break;
1086 case SWIG_NullReferenceError:
1087 type = getNullReferenceError();
1088 break;
1089 case SWIG_ObjectPreviouslyDeletedError:
1090 type = getObjectPreviouslyDeletedError();
1091 break;
1092 case SWIG_UnknownError:
1093 type = rb_eRuntimeError;
1094 break;
1095 default:
1096 type = rb_eRuntimeError;
1097 }
1098 return type;
1099 }
1100
1101
1102 /* This function is called when a user inputs a wrong argument to
1103 a method.
1104 */
1105 SWIGINTERN
Ruby_Format_TypeError(const char * msg,const char * type,const char * name,const int argn,VALUE input)1106 const char* Ruby_Format_TypeError( const char* msg,
1107 const char* type,
1108 const char* name,
1109 const int argn,
1110 VALUE input )
1111 {
1112 char buf[128];
1113 VALUE str;
1114 VALUE asStr;
1115 if ( msg && *msg )
1116 {
1117 str = rb_str_new2(msg);
1118 }
1119 else
1120 {
1121 str = rb_str_new(NULL, 0);
1122 }
1123
1124 str = rb_str_cat2( str, "Expected argument " );
1125 sprintf( buf, "%d of type ", argn-1 );
1126 str = rb_str_cat2( str, buf );
1127 str = rb_str_cat2( str, type );
1128 str = rb_str_cat2( str, ", but got " );
1129 str = rb_str_cat2( str, rb_obj_classname(input) );
1130 str = rb_str_cat2( str, " " );
1131 asStr = rb_inspect(input);
1132 if ( RSTRING_LEN(asStr) > 30 )
1133 {
1134 str = rb_str_cat( str, StringValuePtr(asStr), 30 );
1135 str = rb_str_cat2( str, "..." );
1136 }
1137 else
1138 {
1139 str = rb_str_append( str, asStr );
1140 }
1141
1142 if ( name )
1143 {
1144 str = rb_str_cat2( str, "\n\tin SWIG method '" );
1145 str = rb_str_cat2( str, name );
1146 str = rb_str_cat2( str, "'" );
1147 }
1148
1149 return StringValuePtr( str );
1150 }
1151
1152 /* This function is called when an overloaded method fails */
1153 SWIGINTERN
Ruby_Format_OverloadedError(const int argc,const int maxargs,const char * method,const char * prototypes)1154 void Ruby_Format_OverloadedError(
1155 const int argc,
1156 const int maxargs,
1157 const char* method,
1158 const char* prototypes
1159 )
1160 {
1161 const char* msg = "Wrong # of arguments";
1162 if ( argc <= maxargs ) msg = "Wrong arguments";
1163 rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"
1164 "Possible C/C++ prototypes are:\n%s",
1165 msg, method, prototypes);
1166 }
1167
1168 /* -----------------------------------------------------------------------------
1169 * rubytracking.swg
1170 *
1171 * This file contains support for tracking mappings from
1172 * Ruby objects to C++ objects. This functionality is needed
1173 * to implement mark functions for Ruby's mark and sweep
1174 * garbage collector.
1175 * ----------------------------------------------------------------------------- */
1176
1177 #ifdef __cplusplus
1178 extern "C" {
1179 #endif
1180
1181 #if !defined(ST_DATA_T_DEFINED)
1182 /* Needs to be explicitly included for Ruby 1.8 and earlier */
1183 #include <st.h>
1184 #endif
1185
1186 /* Ruby 1.8 actually assumes the first case. */
1187 #if SIZEOF_VOIDP == SIZEOF_LONG
1188 # define SWIG2NUM(v) LONG2NUM((unsigned long)v)
1189 # define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
1190 #elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
1191 # define SWIG2NUM(v) LL2NUM((unsigned long long)v)
1192 # define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
1193 #else
1194 # error sizeof(void*) is not the same as long or long long
1195 #endif
1196
1197 /* Global hash table to store Trackings from C/C++
1198 structs to Ruby Objects.
1199 */
1200 static st_table* swig_ruby_trackings = NULL;
1201
swig_ruby_trackings_count(ANYARGS)1202 static VALUE swig_ruby_trackings_count(ANYARGS) {
1203 return SWIG2NUM(swig_ruby_trackings->num_entries);
1204 }
1205
1206
1207 /* Setup a hash table to store Trackings */
SWIG_RubyInitializeTrackings(void)1208 SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
1209 /* Create a hash table to store Trackings from C++
1210 objects to Ruby objects. */
1211
1212 /* Try to see if some other .so has already created a
1213 tracking hash table, which we keep hidden in an instance var
1214 in the SWIG module.
1215 This is done to allow multiple DSOs to share the same
1216 tracking table.
1217 */
1218 VALUE trackings_value = Qnil;
1219 /* change the variable name so that we can mix modules
1220 compiled with older SWIG's - this used to be called "@__trackings__" */
1221 ID trackings_id = rb_intern( "@__safetrackings__" );
1222 VALUE verbose = rb_gv_get("VERBOSE");
1223 rb_gv_set("VERBOSE", Qfalse);
1224 trackings_value = rb_ivar_get( _mSWIG, trackings_id );
1225 rb_gv_set("VERBOSE", verbose);
1226
1227 /* The trick here is that we have to store the hash table
1228 pointer in a Ruby variable. We do not want Ruby's GC to
1229 treat this pointer as a Ruby object, so we convert it to
1230 a Ruby numeric value. */
1231 if (trackings_value == Qnil) {
1232 /* No, it hasn't. Create one ourselves */
1233 swig_ruby_trackings = st_init_numtable();
1234 rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
1235 } else {
1236 swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
1237 }
1238
1239 rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", swig_ruby_trackings_count, NULL);
1240 }
1241
1242 /* Add a Tracking from a C/C++ struct to a Ruby object */
SWIG_RubyAddTracking(void * ptr,VALUE object)1243 SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
1244 /* Store the mapping to the global hash table. */
1245 st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
1246 }
1247
1248 /* Get the Ruby object that owns the specified C/C++ struct */
SWIG_RubyInstanceFor(void * ptr)1249 SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
1250 /* Now lookup the value stored in the global hash table */
1251 VALUE value;
1252
1253 if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
1254 return value;
1255 } else {
1256 return Qnil;
1257 }
1258 }
1259
1260 /* Remove a Tracking from a C/C++ struct to a Ruby object. It
1261 is very important to remove objects once they are destroyed
1262 since the same memory address may be reused later to create
1263 a new object. */
SWIG_RubyRemoveTracking(void * ptr)1264 SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
1265 /* Delete the object from the hash table */
1266 st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
1267 }
1268
1269 /* This is a helper method that unlinks a Ruby object from its
1270 underlying C++ object. This is needed if the lifetime of the
1271 Ruby object is longer than the C++ object */
SWIG_RubyUnlinkObjects(void * ptr)1272 SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
1273 VALUE object = SWIG_RubyInstanceFor(ptr);
1274
1275 if (object != Qnil) {
1276 if (TYPE(object) != T_DATA)
1277 abort();
1278 DATA_PTR(object) = 0;
1279 }
1280 }
1281
1282 /* This is a helper method that iterates over all the trackings
1283 passing the C++ object pointer and its related Ruby object
1284 to the passed callback function. */
1285
1286 /* Proxy method to abstract the internal trackings datatype */
swig_ruby_internal_iterate_callback(void * ptr,VALUE obj,void (* meth)(void * ptr,VALUE obj))1287 static int swig_ruby_internal_iterate_callback(void* ptr, VALUE obj, void(*meth)(void* ptr, VALUE obj)) {
1288 (*meth)(ptr, obj);
1289 return ST_CONTINUE;
1290 }
1291
SWIG_RubyIterateTrackings(void (* meth)(void * ptr,VALUE obj))1292 SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
1293 st_foreach(swig_ruby_trackings, (int (*)(ANYARGS))&swig_ruby_internal_iterate_callback, (st_data_t)meth);
1294 }
1295
1296 #ifdef __cplusplus
1297 }
1298 #endif
1299
1300 /* -----------------------------------------------------------------------------
1301 * Ruby API portion that goes into the runtime
1302 * ----------------------------------------------------------------------------- */
1303
1304 #ifdef __cplusplus
1305 extern "C" {
1306 #endif
1307
1308 SWIGINTERN VALUE
SWIG_Ruby_AppendOutput(VALUE target,VALUE o)1309 SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
1310 if (NIL_P(target)) {
1311 target = o;
1312 } else {
1313 if (TYPE(target) != T_ARRAY) {
1314 VALUE o2 = target;
1315 target = rb_ary_new();
1316 rb_ary_push(target, o2);
1317 }
1318 rb_ary_push(target, o);
1319 }
1320 return target;
1321 }
1322
1323 /* For ruby1.8.4 and earlier. */
1324 #ifndef RUBY_INIT_STACK
1325 RUBY_EXTERN void Init_stack(VALUE* addr);
1326 # define RUBY_INIT_STACK \
1327 VALUE variable_in_this_stack_frame; \
1328 Init_stack(&variable_in_this_stack_frame);
1329 #endif
1330
1331
1332 #ifdef __cplusplus
1333 }
1334 #endif
1335
1336
1337 /* -----------------------------------------------------------------------------
1338 * rubyrun.swg
1339 *
1340 * This file contains the runtime support for Ruby modules
1341 * and includes code for managing global variables and pointer
1342 * type checking.
1343 * ----------------------------------------------------------------------------- */
1344
1345 /* For backward compatibility only */
1346 #define SWIG_POINTER_EXCEPTION 0
1347
1348 /* for raw pointers */
1349 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1350 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1351 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Ruby_NewPointerObj(ptr, type, flags)
1352 #define SWIG_AcquirePtr(ptr, own) SWIG_Ruby_AcquirePtr(ptr, own)
1353 #define swig_owntype swig_ruby_owntype
1354
1355 /* for raw packed data */
1356 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
1357 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type)
1358
1359 /* for class or struct pointers */
1360 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1361 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1362
1363 /* for C or C++ function pointers */
1364 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
1365 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
1366
1367 /* for C++ member pointers, ie, member methods */
1368 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
1369 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type)
1370
1371
1372 /* Runtime API */
1373
1374 #define SWIG_GetModule(clientdata) SWIG_Ruby_GetModule(clientdata)
1375 #define SWIG_SetModule(clientdata, pointer) SWIG_Ruby_SetModule(pointer)
1376
1377
1378 /* Error manipulation */
1379
1380 #define SWIG_ErrorType(code) SWIG_Ruby_ErrorType(code)
1381 #define SWIG_Error(code, msg) rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
1382 #define SWIG_fail goto fail
1383
1384
1385 /* Ruby-specific SWIG API */
1386
1387 #define SWIG_InitRuntime() SWIG_Ruby_InitRuntime()
1388 #define SWIG_define_class(ty) SWIG_Ruby_define_class(ty)
1389 #define SWIG_NewClassInstance(value, ty) SWIG_Ruby_NewClassInstance(value, ty)
1390 #define SWIG_MangleStr(value) SWIG_Ruby_MangleStr(value)
1391 #define SWIG_CheckConvert(value, ty) SWIG_Ruby_CheckConvert(value, ty)
1392
1393 #include "assert.h"
1394
1395 /* -----------------------------------------------------------------------------
1396 * pointers/data manipulation
1397 * ----------------------------------------------------------------------------- */
1398
1399 #ifdef __cplusplus
1400 extern "C" {
1401 #endif
1402
1403 typedef struct {
1404 VALUE klass;
1405 VALUE mImpl;
1406 void (*mark)(void *);
1407 void (*destroy)(void *);
1408 int trackObjects;
1409 } swig_class;
1410
1411
1412 /* Global pointer used to keep some internal SWIG stuff */
1413 static VALUE _cSWIG_Pointer = Qnil;
1414 static VALUE swig_runtime_data_type_pointer = Qnil;
1415
1416 /* Global IDs used to keep some internal SWIG stuff */
1417 static ID swig_arity_id = 0;
1418 static ID swig_call_id = 0;
1419
1420 /*
1421 If your swig extension is to be run within an embedded ruby and has
1422 director callbacks, you should set -DRUBY_EMBEDDED during compilation.
1423 This will reset ruby's stack frame on each entry point from the main
1424 program the first time a virtual director function is invoked (in a
1425 non-recursive way).
1426 If this is not done, you run the risk of Ruby trashing the stack.
1427 */
1428
1429 #ifdef RUBY_EMBEDDED
1430
1431 # define SWIG_INIT_STACK \
1432 if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
1433 ++swig_virtual_calls;
1434 # define SWIG_RELEASE_STACK --swig_virtual_calls;
1435 # define Ruby_DirectorTypeMismatchException(x) \
1436 rb_raise( rb_eTypeError, "%s", x ); return c_result;
1437
1438 static unsigned int swig_virtual_calls = 0;
1439
1440 #else /* normal non-embedded extension */
1441
1442 # define SWIG_INIT_STACK
1443 # define SWIG_RELEASE_STACK
1444 # define Ruby_DirectorTypeMismatchException(x) \
1445 throw Swig::DirectorTypeMismatchException( x );
1446
1447 #endif /* RUBY_EMBEDDED */
1448
1449
1450 SWIGRUNTIME VALUE
getExceptionClass(void)1451 getExceptionClass(void) {
1452 static int init = 0;
1453 static VALUE rubyExceptionClass ;
1454 if (!init) {
1455 init = 1;
1456 rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
1457 }
1458 return rubyExceptionClass;
1459 }
1460
1461 /* This code checks to see if the Ruby object being raised as part
1462 of an exception inherits from the Ruby class Exception. If so,
1463 the object is simply returned. If not, then a new Ruby exception
1464 object is created and that will be returned to Ruby.*/
1465 SWIGRUNTIME VALUE
SWIG_Ruby_ExceptionType(swig_type_info * desc,VALUE obj)1466 SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
1467 VALUE exceptionClass = getExceptionClass();
1468 if (rb_obj_is_kind_of(obj, exceptionClass)) {
1469 return obj;
1470 } else {
1471 return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
1472 }
1473 }
1474
1475 /* Initialize Ruby runtime support */
1476 SWIGRUNTIME void
SWIG_Ruby_InitRuntime(void)1477 SWIG_Ruby_InitRuntime(void)
1478 {
1479 if (_mSWIG == Qnil) {
1480 _mSWIG = rb_define_module("SWIG");
1481 swig_call_id = rb_intern("call");
1482 swig_arity_id = rb_intern("arity");
1483 }
1484 }
1485
1486 /* Define Ruby class for C type */
1487 SWIGRUNTIME void
SWIG_Ruby_define_class(swig_type_info * type)1488 SWIG_Ruby_define_class(swig_type_info *type)
1489 {
1490 char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
1491 sprintf(klass_name, "TYPE%s", type->name);
1492 if (NIL_P(_cSWIG_Pointer)) {
1493 _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
1494 rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
1495 }
1496 rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
1497 free((void *) klass_name);
1498 }
1499
1500 /* Create a new pointer object */
1501 SWIGRUNTIME VALUE
SWIG_Ruby_NewPointerObj(void * ptr,swig_type_info * type,int flags)1502 SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
1503 {
1504 int own = flags & SWIG_POINTER_OWN;
1505 int track;
1506 char *klass_name;
1507 swig_class *sklass;
1508 VALUE klass;
1509 VALUE obj;
1510
1511 if (!ptr)
1512 return Qnil;
1513
1514 if (type->clientdata) {
1515 sklass = (swig_class *) type->clientdata;
1516
1517 /* Are we tracking this class and have we already returned this Ruby object? */
1518 track = sklass->trackObjects;
1519 if (track) {
1520 obj = SWIG_RubyInstanceFor(ptr);
1521
1522 /* Check the object's type and make sure it has the correct type.
1523 It might not in cases where methods do things like
1524 downcast methods. */
1525 if (obj != Qnil) {
1526 VALUE value = rb_iv_get(obj, "@__swigtype__");
1527 const char* type_name = RSTRING_PTR(value);
1528
1529 if (strcmp(type->name, type_name) == 0) {
1530 return obj;
1531 }
1532 }
1533 }
1534
1535 /* Create a new Ruby object */
1536 obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark),
1537 ( own ? VOIDFUNC(sklass->destroy) :
1538 (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
1539 ), ptr);
1540
1541 /* If tracking is on for this class then track this object. */
1542 if (track) {
1543 SWIG_RubyAddTracking(ptr, obj);
1544 }
1545 } else {
1546 klass_name = (char *) malloc(4 + strlen(type->name) + 1);
1547 sprintf(klass_name, "TYPE%s", type->name);
1548 klass = rb_const_get(_mSWIG, rb_intern(klass_name));
1549 free((void *) klass_name);
1550 obj = Data_Wrap_Struct(klass, 0, 0, ptr);
1551 }
1552 rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
1553
1554 return obj;
1555 }
1556
1557 /* Create a new class instance (always owned) */
1558 SWIGRUNTIME VALUE
SWIG_Ruby_NewClassInstance(VALUE klass,swig_type_info * type)1559 SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
1560 {
1561 VALUE obj;
1562 swig_class *sklass = (swig_class *) type->clientdata;
1563 obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
1564 rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
1565 return obj;
1566 }
1567
1568 /* Get type mangle from class name */
1569 SWIGRUNTIMEINLINE char *
SWIG_Ruby_MangleStr(VALUE obj)1570 SWIG_Ruby_MangleStr(VALUE obj)
1571 {
1572 VALUE stype = rb_iv_get(obj, "@__swigtype__");
1573 return StringValuePtr(stype);
1574 }
1575
1576 /* Acquire a pointer value */
1577 typedef struct {
1578 void (*datafree)(void *);
1579 int own;
1580 } swig_ruby_owntype;
1581
1582 SWIGRUNTIME swig_ruby_owntype
SWIG_Ruby_AcquirePtr(VALUE obj,swig_ruby_owntype own)1583 SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
1584 swig_ruby_owntype oldown = {0, 0};
1585 if (obj) {
1586 oldown.datafree = RDATA(obj)->dfree;
1587 RDATA(obj)->dfree = own.datafree;
1588 }
1589 return oldown;
1590 }
1591
1592 /* Convert a pointer value */
1593 SWIGRUNTIME int
SWIG_Ruby_ConvertPtrAndOwn(VALUE obj,void ** ptr,swig_type_info * ty,int flags,swig_ruby_owntype * own)1594 SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
1595 {
1596 char *c;
1597 swig_cast_info *tc;
1598 void *vptr = 0;
1599
1600 /* Grab the pointer */
1601 if (NIL_P(obj)) {
1602 if (ptr)
1603 *ptr = 0;
1604 return SWIG_OK;
1605 } else {
1606 if (TYPE(obj) != T_DATA) {
1607 return SWIG_ERROR;
1608 }
1609 Data_Get_Struct(obj, void, vptr);
1610 }
1611
1612 if (own) {
1613 own->datafree = RDATA(obj)->dfree;
1614 own->own = 0;
1615 }
1616
1617 /* Check to see if the input object is giving up ownership
1618 of the underlying C struct or C++ object. If so then we
1619 need to reset the destructor since the Ruby object no
1620 longer owns the underlying C++ object.*/
1621 if (flags & SWIG_POINTER_DISOWN) {
1622 /* Is tracking on for this class? */
1623 int track = 0;
1624 if (ty && ty->clientdata) {
1625 swig_class *sklass = (swig_class *) ty->clientdata;
1626 track = sklass->trackObjects;
1627 }
1628
1629 if (track) {
1630 /* We are tracking objects for this class. Thus we change the destructor
1631 * to SWIG_RubyRemoveTracking. This allows us to
1632 * remove the mapping from the C++ to Ruby object
1633 * when the Ruby object is garbage collected. If we don't
1634 * do this, then it is possible we will return a reference
1635 * to a Ruby object that no longer exists thereby crashing Ruby. */
1636 RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
1637 } else {
1638 RDATA(obj)->dfree = 0;
1639 }
1640 }
1641
1642 /* Do type-checking if type info was provided */
1643 if (ty) {
1644 if (ty->clientdata) {
1645 if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
1646 if (vptr == 0) {
1647 /* The object has already been deleted */
1648 return SWIG_ObjectPreviouslyDeletedError;
1649 }
1650 }
1651 }
1652 if ((c = SWIG_MangleStr(obj)) == NULL) {
1653 return SWIG_ERROR;
1654 }
1655 tc = SWIG_TypeCheck(c, ty);
1656 if (!tc) {
1657 return SWIG_ERROR;
1658 } else {
1659 if (ptr) {
1660 if (tc->type == ty) {
1661 *ptr = vptr;
1662 } else {
1663 int newmemory = 0;
1664 *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
1665 if (newmemory == SWIG_CAST_NEW_MEMORY) {
1666 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1667 if (own)
1668 own->own = own->own | SWIG_CAST_NEW_MEMORY;
1669 }
1670 }
1671 }
1672 }
1673 } else {
1674 if (ptr)
1675 *ptr = vptr;
1676 }
1677
1678 return SWIG_OK;
1679 }
1680
1681 /* Check convert */
1682 SWIGRUNTIMEINLINE int
SWIG_Ruby_CheckConvert(VALUE obj,swig_type_info * ty)1683 SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
1684 {
1685 char *c = SWIG_MangleStr(obj);
1686 if (!c) return 0;
1687 return SWIG_TypeCheck(c,ty) != 0;
1688 }
1689
1690 SWIGRUNTIME VALUE
SWIG_Ruby_NewPackedObj(void * ptr,int sz,swig_type_info * type)1691 SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
1692 char result[1024];
1693 char *r = result;
1694 if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
1695 *(r++) = '_';
1696 r = SWIG_PackData(r, ptr, sz);
1697 strcpy(r, type->name);
1698 return rb_str_new2(result);
1699 }
1700
1701 /* Convert a packed value value */
1702 SWIGRUNTIME int
SWIG_Ruby_ConvertPacked(VALUE obj,void * ptr,int sz,swig_type_info * ty)1703 SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
1704 swig_cast_info *tc;
1705 const char *c;
1706
1707 if (TYPE(obj) != T_STRING) goto type_error;
1708 c = StringValuePtr(obj);
1709 /* Pointer values must start with leading underscore */
1710 if (*c != '_') goto type_error;
1711 c++;
1712 c = SWIG_UnpackData(c, ptr, sz);
1713 if (ty) {
1714 tc = SWIG_TypeCheck(c, ty);
1715 if (!tc) goto type_error;
1716 }
1717 return SWIG_OK;
1718
1719 type_error:
1720 return SWIG_ERROR;
1721 }
1722
1723 SWIGRUNTIME swig_module_info *
SWIG_Ruby_GetModule(void * SWIGUNUSEDPARM (clientdata))1724 SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
1725 {
1726 VALUE pointer;
1727 swig_module_info *ret = 0;
1728 VALUE verbose = rb_gv_get("VERBOSE");
1729
1730 /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
1731 rb_gv_set("VERBOSE", Qfalse);
1732
1733 /* first check if pointer already created */
1734 pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
1735 if (pointer != Qnil) {
1736 Data_Get_Struct(pointer, swig_module_info, ret);
1737 }
1738
1739 /* reinstate warnings */
1740 rb_gv_set("VERBOSE", verbose);
1741 return ret;
1742 }
1743
1744 SWIGRUNTIME void
SWIG_Ruby_SetModule(swig_module_info * pointer)1745 SWIG_Ruby_SetModule(swig_module_info *pointer)
1746 {
1747 /* register a new class */
1748 VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
1749 /* create and store the structure pointer to a global variable */
1750 swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
1751 rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
1752 }
1753
1754 /* This function can be used to check whether a proc or method or similarly
1755 callable function has been passed. Usually used in a %typecheck, like:
1756
1757 %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
1758 $result = SWIG_Ruby_isCallable( $input );
1759 }
1760 */
1761 SWIGINTERN
SWIG_Ruby_isCallable(VALUE proc)1762 int SWIG_Ruby_isCallable( VALUE proc )
1763 {
1764 if ( rb_respond_to( proc, swig_call_id ) )
1765 return 1;
1766 return 0;
1767 }
1768
1769 /* This function can be used to check the arity (number of arguments)
1770 a proc or method can take. Usually used in a %typecheck.
1771 Valid arities will be that equal to minimal or those < 0
1772 which indicate a variable number of parameters at the end.
1773 */
1774 SWIGINTERN
SWIG_Ruby_arity(VALUE proc,int minimal)1775 int SWIG_Ruby_arity( VALUE proc, int minimal )
1776 {
1777 if ( rb_respond_to( proc, swig_arity_id ) )
1778 {
1779 VALUE num = rb_funcall( proc, swig_arity_id, 0 );
1780 int arity = NUM2INT(num);
1781 if ( arity < 0 && (arity+1) < -minimal ) return 1;
1782 if ( arity == minimal ) return 1;
1783 return 1;
1784 }
1785 return 0;
1786 }
1787
1788
1789 #ifdef __cplusplus
1790 }
1791 #endif
1792
1793
1794
1795 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1796
1797 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1798
1799
1800
1801 #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0)
1802
1803
1804 /* -------- TYPES TABLE (BEGIN) -------- */
1805
1806 #define SWIGTYPE_p_apr_array_header_t swig_types[0]
1807 #define SWIGTYPE_p_apr_file_t swig_types[1]
1808 #define SWIGTYPE_p_apr_hash_t swig_types[2]
1809 #define SWIGTYPE_p_apr_int32_t swig_types[3]
1810 #define SWIGTYPE_p_apr_int64_t swig_types[4]
1811 #define SWIGTYPE_p_apr_pool_t swig_types[5]
1812 #define SWIGTYPE_p_apr_size_t swig_types[6]
1813 #define SWIGTYPE_p_char swig_types[7]
1814 #define SWIGTYPE_p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t swig_types[8]
1815 #define SWIGTYPE_p_f_p_p_svn_txdelta_stream_t_p_void_p_apr_pool_t_p_apr_pool_t__p_svn_error_t swig_types[9]
1816 #define SWIGTYPE_p_f_p_p_svn_txdelta_window_t_p_void_p_apr_pool_t__p_svn_error_t swig_types[10]
1817 #define SWIGTYPE_p_f_p_p_void_p_q_const__svn_delta_editor_t_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t swig_types[11]
1818 #define SWIGTYPE_p_f_p_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t swig_types[12]
1819 #define SWIGTYPE_p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t swig_types[13]
1820 #define SWIGTYPE_p_f_p_q_const__char_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t swig_types[14]
1821 #define SWIGTYPE_p_f_p_q_const__char_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t swig_types[15]
1822 #define SWIGTYPE_p_f_p_q_const__char_svn_revnum_t_p_void_p_apr_pool_t__p_svn_error_t swig_types[16]
1823 #define SWIGTYPE_p_f_p_q_const__struct_svn_delta_editor_t_p_void_p_q_const__char_svn_txdelta_stream_open_func_t_p_void_p_apr_pool_t__p_svn_error_t swig_types[17]
1824 #define SWIGTYPE_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t swig_types[18]
1825 #define SWIGTYPE_p_f_p_void__p_svn_error_t swig_types[19]
1826 #define SWIGTYPE_p_f_p_void__p_unsigned_char swig_types[20]
1827 #define SWIGTYPE_p_f_p_void_p_apr_pool_t__p_svn_error_t swig_types[21]
1828 #define SWIGTYPE_p_f_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t swig_types[22]
1829 #define SWIGTYPE_p_f_p_void_p_q_const__char_p_apr_pool_t_p_svn_txdelta_window_handler_t_p_p_void__p_svn_error_t swig_types[23]
1830 #define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t_p_apr_pool_t__p_svn_error_t swig_types[24]
1831 #define SWIGTYPE_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t swig_types[25]
1832 #define SWIGTYPE_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t swig_types[26]
1833 #define SWIGTYPE_p_f_p_void_svn_revnum_t_p_apr_pool_t__p_svn_error_t swig_types[27]
1834 #define SWIGTYPE_p_f_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t swig_types[28]
1835 #define SWIGTYPE_p_int swig_types[29]
1836 #define SWIGTYPE_p_long swig_types[30]
1837 #define SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t swig_types[31]
1838 #define SWIGTYPE_p_p_svn_checksum_t swig_types[32]
1839 #define SWIGTYPE_p_p_svn_delta_editor_t swig_types[33]
1840 #define SWIGTYPE_p_p_svn_delta_path_driver_state_t swig_types[34]
1841 #define SWIGTYPE_p_p_svn_txdelta_stream_t swig_types[35]
1842 #define SWIGTYPE_p_p_svn_txdelta_window_t swig_types[36]
1843 #define SWIGTYPE_p_p_void swig_types[37]
1844 #define SWIGTYPE_p_svn_auth_baton_t swig_types[38]
1845 #define SWIGTYPE_p_svn_auth_cred_simple_t swig_types[39]
1846 #define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_pw_t swig_types[40]
1847 #define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_t swig_types[41]
1848 #define SWIGTYPE_p_svn_auth_cred_ssl_server_trust_t swig_types[42]
1849 #define SWIGTYPE_p_svn_auth_cred_username_t swig_types[43]
1850 #define SWIGTYPE_p_svn_auth_iterstate_t swig_types[44]
1851 #define SWIGTYPE_p_svn_auth_provider_object_t swig_types[45]
1852 #define SWIGTYPE_p_svn_auth_provider_t swig_types[46]
1853 #define SWIGTYPE_p_svn_auth_ssl_server_cert_info_t swig_types[47]
1854 #define SWIGTYPE_p_svn_cache_config_t swig_types[48]
1855 #define SWIGTYPE_p_svn_checksum_ctx_t swig_types[49]
1856 #define SWIGTYPE_p_svn_checksum_kind_t swig_types[50]
1857 #define SWIGTYPE_p_svn_checksum_t swig_types[51]
1858 #define SWIGTYPE_p_svn_commit_info_t swig_types[52]
1859 #define SWIGTYPE_p_svn_config_t swig_types[53]
1860 #define SWIGTYPE_p_svn_delta_editor_t swig_types[54]
1861 #define SWIGTYPE_p_svn_delta_path_driver_state_t swig_types[55]
1862 #define SWIGTYPE_p_svn_depth_t swig_types[56]
1863 #define SWIGTYPE_p_svn_diff_binary_patch_t swig_types[57]
1864 #define SWIGTYPE_p_svn_diff_conflict_display_style_t swig_types[58]
1865 #define SWIGTYPE_p_svn_diff_datasource_e swig_types[59]
1866 #define SWIGTYPE_p_svn_diff_file_ignore_space_t swig_types[60]
1867 #define SWIGTYPE_p_svn_diff_file_options_t swig_types[61]
1868 #define SWIGTYPE_p_svn_diff_fns2_t swig_types[62]
1869 #define SWIGTYPE_p_svn_diff_fns_t swig_types[63]
1870 #define SWIGTYPE_p_svn_diff_hunk_t swig_types[64]
1871 #define SWIGTYPE_p_svn_diff_operation_kind_e swig_types[65]
1872 #define SWIGTYPE_p_svn_diff_output_fns_t swig_types[66]
1873 #define SWIGTYPE_p_svn_diff_t swig_types[67]
1874 #define SWIGTYPE_p_svn_dirent_t swig_types[68]
1875 #define SWIGTYPE_p_svn_errno_t swig_types[69]
1876 #define SWIGTYPE_p_svn_error_t swig_types[70]
1877 #define SWIGTYPE_p_svn_io_dirent2_t swig_types[71]
1878 #define SWIGTYPE_p_svn_io_dirent_t swig_types[72]
1879 #define SWIGTYPE_p_svn_io_file_del_t swig_types[73]
1880 #define SWIGTYPE_p_svn_location_segment_t swig_types[74]
1881 #define SWIGTYPE_p_svn_lock_t swig_types[75]
1882 #define SWIGTYPE_p_svn_log_changed_path2_t swig_types[76]
1883 #define SWIGTYPE_p_svn_log_changed_path_t swig_types[77]
1884 #define SWIGTYPE_p_svn_log_entry_t swig_types[78]
1885 #define SWIGTYPE_p_svn_merge_range_t swig_types[79]
1886 #define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[80]
1887 #define SWIGTYPE_p_svn_node_kind_t swig_types[81]
1888 #define SWIGTYPE_p_svn_opt_revision_range_t swig_types[82]
1889 #define SWIGTYPE_p_svn_opt_revision_t swig_types[83]
1890 #define SWIGTYPE_p_svn_opt_revision_value_t swig_types[84]
1891 #define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[85]
1892 #define SWIGTYPE_p_svn_opt_subcommand_desc3_t swig_types[86]
1893 #define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[87]
1894 #define SWIGTYPE_p_svn_patch_file_t swig_types[88]
1895 #define SWIGTYPE_p_svn_patch_t swig_types[89]
1896 #define SWIGTYPE_p_svn_prop_inherited_item_t swig_types[90]
1897 #define SWIGTYPE_p_svn_prop_kind swig_types[91]
1898 #define SWIGTYPE_p_svn_prop_patch_t swig_types[92]
1899 #define SWIGTYPE_p_svn_stream_mark_t swig_types[93]
1900 #define SWIGTYPE_p_svn_stream_t swig_types[94]
1901 #define SWIGTYPE_p_svn_string_t swig_types[95]
1902 #define SWIGTYPE_p_svn_stringbuf_t swig_types[96]
1903 #define SWIGTYPE_p_svn_tristate_t swig_types[97]
1904 #define SWIGTYPE_p_svn_txdelta_op_t swig_types[98]
1905 #define SWIGTYPE_p_svn_txdelta_stream_t swig_types[99]
1906 #define SWIGTYPE_p_svn_txdelta_window_t swig_types[100]
1907 #define SWIGTYPE_p_svn_version_checklist_t swig_types[101]
1908 #define SWIGTYPE_p_svn_version_ext_linked_lib_t swig_types[102]
1909 #define SWIGTYPE_p_svn_version_ext_loaded_lib_t swig_types[103]
1910 #define SWIGTYPE_p_svn_version_extended_t swig_types[104]
1911 #define SWIGTYPE_p_svn_version_t swig_types[105]
1912 #define SWIGTYPE_p_unsigned_char swig_types[106]
1913 #define SWIGTYPE_p_unsigned_long swig_types[107]
1914 #define SWIGTYPE_p_void swig_types[108]
1915 static swig_type_info *swig_types[110];
1916 static swig_module_info swig_module = {swig_types, 109, 0, 0, 0, 0};
1917 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1918 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1919
1920 /* -------- TYPES TABLE (END) -------- */
1921
1922 #define SWIG_init Init_delta
1923 #define SWIG_name "Svn::Ext::Delta"
1924
1925 static VALUE mDelta;
1926
1927 #define SWIG_RUBY_THREAD_BEGIN_BLOCK
1928 #define SWIG_RUBY_THREAD_END_BLOCK
1929
1930
1931 #define SWIGVERSION 0x030012
1932 #define SWIG_VERSION SWIGVERSION
1933
1934
1935 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1936 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1937
1938
1939 #ifdef __cplusplus
1940 extern "C" {
1941 #endif
1942
1943 /* Ruby 1.9 changed the file name of this header */
1944 #ifdef HAVE_RUBY_IO_H
1945 #include "ruby/io.h"
1946 #else
1947 #include "rubyio.h"
1948 #endif
1949
1950 #ifdef __cplusplus
1951 }
1952 #endif
1953
1954
1955 #ifdef __cplusplus
1956 extern "C" {
1957 #endif
1958 #ifdef HAVE_SYS_TIME_H
1959 # include <sys/time.h>
1960 struct timeval rb_time_timeval(VALUE);
1961 #endif
1962 #ifdef __cplusplus
1963 }
1964 #endif
1965
1966
1967 #include "svn_time.h"
1968 #include "svn_pools.h"
1969
1970
1971 #include "swigutil_rb.h"
1972
1973
1974 static VALUE _global_svn_swig_rb_pool = Qnil;
1975 static apr_pool_t *_global_pool = NULL;
1976 static VALUE vresult = Qnil;
1977 static VALUE *_global_vresult_address = &vresult;
1978
1979
1980 #include <apr_md5.h>
1981 #include "svn_md5.h"
1982
1983
1984 static VALUE
svn_txdelta_window_t_ops_get(svn_txdelta_window_t * window)1985 svn_txdelta_window_t_ops_get(svn_txdelta_window_t *window)
1986 {
1987 return svn_swig_rb_txdelta_window_t_ops_get(window);
1988 }
1989
1990
1991 #include "svn_delta.h"
1992
1993
1994 #include <limits.h>
1995 #if !defined(SWIG_NO_LLONG_MAX)
1996 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1997 # define LLONG_MAX __LONG_LONG_MAX__
1998 # define LLONG_MIN (-LLONG_MAX - 1LL)
1999 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2000 # endif
2001 #endif
2002
2003
2004 #define SWIG_From_long LONG2NUM
2005
2006
2007 SWIGINTERNINLINE VALUE
SWIG_From_int(int value)2008 SWIG_From_int (int value)
2009 {
2010 return SWIG_From_long (value);
2011 }
2012
2013
2014 SWIGINTERN VALUE
SWIG_ruby_failed(void)2015 SWIG_ruby_failed(void)
2016 {
2017 return Qnil;
2018 }
2019
2020
2021 /*@SWIG:/opt/svnrm/prefix/share/swig/3.0.12/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
SWIG_AUX_NUM2LONG(VALUE * args)2022 SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
2023 {
2024 VALUE obj = args[0];
2025 VALUE type = TYPE(obj);
2026 long *res = (long *)(args[1]);
2027 *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
2028 return obj;
2029 }
2030 /*@SWIG@*/
2031
2032 SWIGINTERN int
SWIG_AsVal_long(VALUE obj,long * val)2033 SWIG_AsVal_long (VALUE obj, long* val)
2034 {
2035 VALUE type = TYPE(obj);
2036 if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
2037 long v;
2038 VALUE a[2];
2039 a[0] = obj;
2040 a[1] = (VALUE)(&v);
2041 if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
2042 if (val) *val = v;
2043 return SWIG_OK;
2044 }
2045 }
2046 return SWIG_TypeError;
2047 }
2048
2049
2050 SWIGINTERN int
SWIG_AsVal_int(VALUE obj,int * val)2051 SWIG_AsVal_int (VALUE obj, int *val)
2052 {
2053 long v;
2054 int res = SWIG_AsVal_long (obj, &v);
2055 if (SWIG_IsOK(res)) {
2056 if ((v < INT_MIN || v > INT_MAX)) {
2057 return SWIG_OverflowError;
2058 } else {
2059 if (val) *val = (int)(v);
2060 }
2061 }
2062 return res;
2063 }
2064
2065
2066 /*@SWIG:/opt/svnrm/prefix/share/swig/3.0.12/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
SWIG_AUX_NUM2ULONG(VALUE * args)2067 SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
2068 {
2069 VALUE obj = args[0];
2070 VALUE type = TYPE(obj);
2071 unsigned long *res = (unsigned long *)(args[1]);
2072 *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj);
2073 return obj;
2074 }
2075 /*@SWIG@*/
2076
2077 SWIGINTERN int
SWIG_AsVal_unsigned_SS_long(VALUE obj,unsigned long * val)2078 SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val)
2079 {
2080 VALUE type = TYPE(obj);
2081 if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
2082 unsigned long v;
2083 VALUE a[2];
2084 a[0] = obj;
2085 a[1] = (VALUE)(&v);
2086 if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
2087 if (val) *val = v;
2088 return SWIG_OK;
2089 }
2090 }
2091 return SWIG_TypeError;
2092 }
2093
2094
2095 SWIGINTERNINLINE VALUE
SWIG_From_unsigned_SS_long(unsigned long value)2096 SWIG_From_unsigned_SS_long (unsigned long value)
2097 {
2098 return ULONG2NUM(value);
2099 }
2100
2101
2102 SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)2103 SWIG_pchar_descriptor(void)
2104 {
2105 static int init = 0;
2106 static swig_type_info* info = 0;
2107 if (!init) {
2108 info = SWIG_TypeQuery("_p_char");
2109 init = 1;
2110 }
2111 return info;
2112 }
2113
2114
2115 SWIGINTERN int
SWIG_AsCharPtrAndSize(VALUE obj,char ** cptr,size_t * psize,int * alloc)2116 SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
2117 {
2118 if (TYPE(obj) == T_STRING) {
2119 char *cstr = StringValuePtr(obj);
2120 size_t size = RSTRING_LEN(obj) + 1;
2121 if (cptr) {
2122 if (alloc) {
2123 if (*alloc == SWIG_NEWOBJ) {
2124 *cptr = (char *)memcpy(malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
2125 } else {
2126 *cptr = cstr;
2127 *alloc = SWIG_OLDOBJ;
2128 }
2129 }
2130 }
2131 if (psize) *psize = size;
2132 return SWIG_OK;
2133 } else {
2134 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2135 if (pchar_descriptor) {
2136 void* vptr = 0;
2137 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
2138 if (cptr) *cptr = (char *)vptr;
2139 if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
2140 if (alloc) *alloc = SWIG_OLDOBJ;
2141 return SWIG_OK;
2142 }
2143 }
2144 }
2145 return SWIG_TypeError;
2146 }
2147
2148
2149
2150
2151
svn_delta_editor_invoke_set_target_revision(svn_delta_editor_t * _obj,void * edit_baton,svn_revnum_t target_revision,apr_pool_t * scratch_pool)2152 static svn_error_t * svn_delta_editor_invoke_set_target_revision(
2153 svn_delta_editor_t * _obj, void *edit_baton, svn_revnum_t target_revision, apr_pool_t *scratch_pool) {
2154 return (_obj->set_target_revision)(edit_baton, target_revision, scratch_pool);
2155 }
2156
svn_delta_editor_invoke_open_root(svn_delta_editor_t * _obj,void * edit_baton,svn_revnum_t base_revision,apr_pool_t * result_pool,void ** root_baton)2157 static svn_error_t * svn_delta_editor_invoke_open_root(
2158 svn_delta_editor_t * _obj, void *edit_baton, svn_revnum_t base_revision, apr_pool_t *result_pool, void **root_baton) {
2159 return (_obj->open_root)(edit_baton, base_revision, result_pool, root_baton);
2160 }
2161
svn_delta_editor_invoke_delete_entry(svn_delta_editor_t * _obj,const char * path,svn_revnum_t revision,void * parent_baton,apr_pool_t * scratch_pool)2162 static svn_error_t * svn_delta_editor_invoke_delete_entry(
2163 svn_delta_editor_t * _obj, const char *path, svn_revnum_t revision, void *parent_baton, apr_pool_t *scratch_pool) {
2164 return (_obj->delete_entry)(path, revision, parent_baton, scratch_pool);
2165 }
2166
svn_delta_editor_invoke_add_directory(svn_delta_editor_t * _obj,const char * path,void * parent_baton,const char * copyfrom_path,svn_revnum_t copyfrom_revision,apr_pool_t * result_pool,void ** child_baton)2167 static svn_error_t * svn_delta_editor_invoke_add_directory(
2168 svn_delta_editor_t * _obj, const char *path, void *parent_baton, const char *copyfrom_path, svn_revnum_t copyfrom_revision, apr_pool_t *result_pool, void **child_baton) {
2169 return (_obj->add_directory)(path, parent_baton, copyfrom_path, copyfrom_revision, result_pool, child_baton);
2170 }
2171
svn_delta_editor_invoke_open_directory(svn_delta_editor_t * _obj,const char * path,void * parent_baton,svn_revnum_t base_revision,apr_pool_t * result_pool,void ** child_baton)2172 static svn_error_t * svn_delta_editor_invoke_open_directory(
2173 svn_delta_editor_t * _obj, const char *path, void *parent_baton, svn_revnum_t base_revision, apr_pool_t *result_pool, void **child_baton) {
2174 return (_obj->open_directory)(path, parent_baton, base_revision, result_pool, child_baton);
2175 }
2176
svn_delta_editor_invoke_change_dir_prop(svn_delta_editor_t * _obj,void * dir_baton,const char * name,const svn_string_t * value,apr_pool_t * scratch_pool)2177 static svn_error_t * svn_delta_editor_invoke_change_dir_prop(
2178 svn_delta_editor_t * _obj, void *dir_baton, const char *name, const svn_string_t *value, apr_pool_t *scratch_pool) {
2179 return (_obj->change_dir_prop)(dir_baton, name, value, scratch_pool);
2180 }
2181
svn_delta_editor_invoke_close_directory(svn_delta_editor_t * _obj,void * dir_baton,apr_pool_t * scratch_pool)2182 static svn_error_t * svn_delta_editor_invoke_close_directory(
2183 svn_delta_editor_t * _obj, void *dir_baton, apr_pool_t *scratch_pool) {
2184 return (_obj->close_directory)(dir_baton, scratch_pool);
2185 }
2186
svn_delta_editor_invoke_absent_directory(svn_delta_editor_t * _obj,const char * path,void * parent_baton,apr_pool_t * scratch_pool)2187 static svn_error_t * svn_delta_editor_invoke_absent_directory(
2188 svn_delta_editor_t * _obj, const char *path, void *parent_baton, apr_pool_t *scratch_pool) {
2189 return (_obj->absent_directory)(path, parent_baton, scratch_pool);
2190 }
2191
svn_delta_editor_invoke_add_file(svn_delta_editor_t * _obj,const char * path,void * parent_baton,const char * copyfrom_path,svn_revnum_t copyfrom_revision,apr_pool_t * result_pool,void ** file_baton)2192 static svn_error_t * svn_delta_editor_invoke_add_file(
2193 svn_delta_editor_t * _obj, const char *path, void *parent_baton, const char *copyfrom_path, svn_revnum_t copyfrom_revision, apr_pool_t *result_pool, void **file_baton) {
2194 return (_obj->add_file)(path, parent_baton, copyfrom_path, copyfrom_revision, result_pool, file_baton);
2195 }
2196
svn_delta_editor_invoke_open_file(svn_delta_editor_t * _obj,const char * path,void * parent_baton,svn_revnum_t base_revision,apr_pool_t * result_pool,void ** file_baton)2197 static svn_error_t * svn_delta_editor_invoke_open_file(
2198 svn_delta_editor_t * _obj, const char *path, void *parent_baton, svn_revnum_t base_revision, apr_pool_t *result_pool, void **file_baton) {
2199 return (_obj->open_file)(path, parent_baton, base_revision, result_pool, file_baton);
2200 }
2201
svn_delta_editor_invoke_apply_textdelta(svn_delta_editor_t * _obj,void * file_baton,const char * base_checksum,apr_pool_t * result_pool,svn_txdelta_window_handler_t * handler,void ** handler_baton)2202 static svn_error_t * svn_delta_editor_invoke_apply_textdelta(
2203 svn_delta_editor_t * _obj, void *file_baton, const char *base_checksum, apr_pool_t *result_pool, svn_txdelta_window_handler_t *handler, void **handler_baton) {
2204 return (_obj->apply_textdelta)(file_baton, base_checksum, result_pool, handler, handler_baton);
2205 }
2206
svn_delta_editor_invoke_change_file_prop(svn_delta_editor_t * _obj,void * file_baton,const char * name,const svn_string_t * value,apr_pool_t * scratch_pool)2207 static svn_error_t * svn_delta_editor_invoke_change_file_prop(
2208 svn_delta_editor_t * _obj, void *file_baton, const char *name, const svn_string_t *value, apr_pool_t *scratch_pool) {
2209 return (_obj->change_file_prop)(file_baton, name, value, scratch_pool);
2210 }
2211
svn_delta_editor_invoke_close_file(svn_delta_editor_t * _obj,void * file_baton,const char * text_checksum,apr_pool_t * scratch_pool)2212 static svn_error_t * svn_delta_editor_invoke_close_file(
2213 svn_delta_editor_t * _obj, void *file_baton, const char *text_checksum, apr_pool_t *scratch_pool) {
2214 return (_obj->close_file)(file_baton, text_checksum, scratch_pool);
2215 }
2216
svn_delta_editor_invoke_absent_file(svn_delta_editor_t * _obj,const char * path,void * parent_baton,apr_pool_t * scratch_pool)2217 static svn_error_t * svn_delta_editor_invoke_absent_file(
2218 svn_delta_editor_t * _obj, const char *path, void *parent_baton, apr_pool_t *scratch_pool) {
2219 return (_obj->absent_file)(path, parent_baton, scratch_pool);
2220 }
2221
svn_delta_editor_invoke_close_edit(svn_delta_editor_t * _obj,void * edit_baton,apr_pool_t * scratch_pool)2222 static svn_error_t * svn_delta_editor_invoke_close_edit(
2223 svn_delta_editor_t * _obj, void *edit_baton, apr_pool_t *scratch_pool) {
2224 return (_obj->close_edit)(edit_baton, scratch_pool);
2225 }
2226
svn_delta_editor_invoke_abort_edit(svn_delta_editor_t * _obj,void * edit_baton,apr_pool_t * scratch_pool)2227 static svn_error_t * svn_delta_editor_invoke_abort_edit(
2228 svn_delta_editor_t * _obj, void *edit_baton, apr_pool_t *scratch_pool) {
2229 return (_obj->abort_edit)(edit_baton, scratch_pool);
2230 }
2231
svn_delta_editor_invoke_apply_textdelta_stream(svn_delta_editor_t * _obj,const struct svn_delta_editor_t * editor,void * file_baton,const char * base_checksum,svn_txdelta_stream_open_func_t open_func,void * open_baton,apr_pool_t * scratch_pool)2232 static svn_error_t * svn_delta_editor_invoke_apply_textdelta_stream(
2233 svn_delta_editor_t * _obj, const struct svn_delta_editor_t *editor, void *file_baton, const char *base_checksum, svn_txdelta_stream_open_func_t open_func, void *open_baton, apr_pool_t *scratch_pool) {
2234 return (_obj->apply_textdelta_stream)(editor, file_baton, base_checksum, open_func, open_baton, scratch_pool);
2235 }
2236
svn_txdelta_invoke_window_handler(svn_txdelta_window_handler_t _obj,svn_txdelta_window_t * window,void * baton)2237 static svn_error_t * svn_txdelta_invoke_window_handler(
2238 svn_txdelta_window_handler_t _obj, svn_txdelta_window_t *window, void *baton) {
2239 return _obj(window, baton);
2240 }
2241
svn_txdelta_invoke_next_window_fn(svn_txdelta_next_window_fn_t _obj,svn_txdelta_window_t ** window,void * baton,apr_pool_t * pool)2242 static svn_error_t * svn_txdelta_invoke_next_window_fn(
2243 svn_txdelta_next_window_fn_t _obj, svn_txdelta_window_t **window, void *baton, apr_pool_t *pool) {
2244 return _obj(window, baton, pool);
2245 }
2246
svn_txdelta_invoke_md5_digest_fn(svn_txdelta_md5_digest_fn_t _obj,void * baton)2247 static const unsigned char * svn_txdelta_invoke_md5_digest_fn(
2248 svn_txdelta_md5_digest_fn_t _obj, void *baton) {
2249 return _obj(baton);
2250 }
2251
svn_txdelta_invoke_stream_open_func(svn_txdelta_stream_open_func_t _obj,svn_txdelta_stream_t ** txdelta_stream,void * baton,apr_pool_t * result_pool,apr_pool_t * scratch_pool)2252 static svn_error_t * svn_txdelta_invoke_stream_open_func(
2253 svn_txdelta_stream_open_func_t _obj, svn_txdelta_stream_t **txdelta_stream, void *baton, apr_pool_t *result_pool, apr_pool_t *scratch_pool) {
2254 return _obj(txdelta_stream, baton, result_pool, scratch_pool);
2255 }
2256
svn_delta_invoke_path_driver_cb_func2(svn_delta_path_driver_cb_func2_t _obj,void ** dir_baton,const svn_delta_editor_t * editor,void * edit_baton,void * parent_baton,void * callback_baton,const char * relpath,apr_pool_t * pool)2257 static svn_error_t * svn_delta_invoke_path_driver_cb_func2(
2258 svn_delta_path_driver_cb_func2_t _obj, void **dir_baton, const svn_delta_editor_t *editor, void *edit_baton, void *parent_baton, void *callback_baton, const char *relpath, apr_pool_t *pool) {
2259 return _obj(dir_baton, editor, edit_baton, parent_baton, callback_baton, relpath, pool);
2260 }
2261
svn_delta_invoke_path_driver_cb_func(svn_delta_path_driver_cb_func_t _obj,void ** dir_baton,void * parent_baton,void * callback_baton,const char * path,apr_pool_t * pool)2262 static svn_error_t * svn_delta_invoke_path_driver_cb_func(
2263 svn_delta_path_driver_cb_func_t _obj, void **dir_baton, void *parent_baton, void *callback_baton, const char *path, apr_pool_t *pool) {
2264 return _obj(dir_baton, parent_baton, callback_baton, path, pool);
2265 }
2266
svn_file_invoke_rev_handler(svn_file_rev_handler_t _obj,void * baton,const char * path,svn_revnum_t rev,apr_hash_t * rev_props,svn_boolean_t result_of_merge,svn_txdelta_window_handler_t * delta_handler,void ** delta_baton,apr_array_header_t * prop_diffs,apr_pool_t * pool)2267 static svn_error_t * svn_file_invoke_rev_handler(
2268 svn_file_rev_handler_t _obj, void *baton, const char *path, svn_revnum_t rev, apr_hash_t *rev_props, svn_boolean_t result_of_merge, svn_txdelta_window_handler_t *delta_handler, void **delta_baton, apr_array_header_t *prop_diffs, apr_pool_t *pool) {
2269 return _obj(baton, path, rev, rev_props, result_of_merge, delta_handler, delta_baton, prop_diffs, pool);
2270 }
2271
svn_file_invoke_rev_handler_old(svn_file_rev_handler_old_t _obj,void * baton,const char * path,svn_revnum_t rev,apr_hash_t * rev_props,svn_txdelta_window_handler_t * delta_handler,void ** delta_baton,apr_array_header_t * prop_diffs,apr_pool_t * pool)2272 static svn_error_t * svn_file_invoke_rev_handler_old(
2273 svn_file_rev_handler_old_t _obj, void *baton, const char *path, svn_revnum_t rev, apr_hash_t *rev_props, svn_txdelta_window_handler_t *delta_handler, void **delta_baton, apr_array_header_t *prop_diffs, apr_pool_t *pool) {
2274 return _obj(baton, path, rev, rev_props, delta_handler, delta_baton, prop_diffs, pool);
2275 }
2276
2277
2278
2279 static VALUE
svn_swig_rb_delta_editor_get_target_revision(VALUE editor)2280 svn_swig_rb_delta_editor_get_target_revision(VALUE editor)
2281 {
2282 static ID id_target_revision_address = 0;
2283 VALUE rb_target_address;
2284 svn_revnum_t *target_address;
2285
2286 if (id_target_revision_address == 0)
2287 id_target_revision_address = rb_intern("@target_revision_address");
2288
2289 if (!RTEST(rb_ivar_defined(editor, id_target_revision_address)))
2290 return Qnil;
2291
2292 rb_target_address = rb_ivar_get(editor, id_target_revision_address);
2293 if (NIL_P(rb_target_address))
2294 return Qnil;
2295
2296 target_address = (svn_revnum_t *)(NUM2LONG(rb_target_address));
2297 if (!target_address)
2298 return Qnil;
2299
2300 return LONG2NUM(*target_address);
2301 }
2302
2303
2304 static VALUE
svn_swig_rb_txdelta_apply_instructions(svn_txdelta_window_t * window,const char * sbuf)2305 svn_swig_rb_txdelta_apply_instructions(svn_txdelta_window_t *window,
2306 const char *sbuf)
2307 {
2308 char *tbuf;
2309 apr_size_t tlen;
2310
2311 tlen = window->tview_len + 1;
2312 tbuf = ALLOCA_N(char, tlen);
2313 svn_txdelta_apply_instructions(window, sbuf, tbuf, &tlen);
2314
2315 return rb_str_new(tbuf, tlen);
2316 }
2317
2318
2319 static void
svn_txdelta_apply_wrapper(svn_stream_t * source,svn_stream_t * target,unsigned char * result_digest,const char * error_info,svn_txdelta_window_handler_t * handler,void ** handler_baton,apr_pool_t * pool)2320 svn_txdelta_apply_wrapper(svn_stream_t *source,
2321 svn_stream_t *target,
2322 unsigned char *result_digest,
2323 const char *error_info,
2324 svn_txdelta_window_handler_t *handler,
2325 void **handler_baton,
2326 apr_pool_t *pool)
2327 {
2328 svn_txdelta_apply(source, target, result_digest, error_info,
2329 pool, handler, handler_baton);
2330 }
2331
2332 static svn_error_t *
svn_delta_editor_invoke_open_root_wrapper(svn_delta_editor_t * editor,void * edit_baton,svn_revnum_t base_revision,void ** root_baton,apr_pool_t * dir_pool)2333 svn_delta_editor_invoke_open_root_wrapper(svn_delta_editor_t *editor,
2334 void *edit_baton,
2335 svn_revnum_t base_revision,
2336 void **root_baton,
2337 apr_pool_t *dir_pool)
2338 {
2339 return svn_delta_editor_invoke_open_root(editor, edit_baton,
2340 base_revision, dir_pool, root_baton);
2341 }
2342
2343 static svn_error_t *
svn_delta_editor_invoke_add_directory_wrapper(svn_delta_editor_t * editor,const char * path,void * parent_baton,const char * copyfrom_path,svn_revnum_t copyfrom_revision,void ** child_baton,apr_pool_t * dir_pool)2344 svn_delta_editor_invoke_add_directory_wrapper(svn_delta_editor_t *editor,
2345 const char *path,
2346 void *parent_baton,
2347 const char *copyfrom_path,
2348 svn_revnum_t copyfrom_revision,
2349 void **child_baton,
2350 apr_pool_t *dir_pool)
2351 {
2352 return svn_delta_editor_invoke_add_directory(editor, path, parent_baton,
2353 copyfrom_path, copyfrom_revision,
2354 dir_pool, child_baton);
2355 }
2356
2357 static svn_error_t *
svn_delta_editor_invoke_open_directory_wrapper(svn_delta_editor_t * editor,const char * path,void * parent_baton,svn_revnum_t base_revision,void ** child_baton,apr_pool_t * dir_pool)2358 svn_delta_editor_invoke_open_directory_wrapper(svn_delta_editor_t *editor,
2359 const char *path,
2360 void *parent_baton,
2361 svn_revnum_t base_revision,
2362 void **child_baton,
2363 apr_pool_t *dir_pool)
2364 {
2365 return svn_delta_editor_invoke_open_directory(editor, path, parent_baton,
2366 base_revision, dir_pool,
2367 child_baton);
2368 }
2369
2370 static svn_error_t *
svn_delta_editor_invoke_add_file_wrapper(svn_delta_editor_t * editor,const char * path,void * parent_baton,const char * copyfrom_path,svn_revnum_t copyfrom_revision,void ** file_baton,apr_pool_t * file_pool)2371 svn_delta_editor_invoke_add_file_wrapper(svn_delta_editor_t *editor,
2372 const char *path,
2373 void *parent_baton,
2374 const char *copyfrom_path,
2375 svn_revnum_t copyfrom_revision,
2376 void **file_baton,
2377 apr_pool_t *file_pool)
2378 {
2379 return svn_delta_editor_invoke_add_file(editor, path, parent_baton,
2380 copyfrom_path,
2381 copyfrom_revision,
2382 file_pool, file_baton);
2383 }
2384
2385 static svn_error_t *
svn_delta_editor_invoke_open_file_wrapper(svn_delta_editor_t * editor,const char * path,void * parent_baton,svn_revnum_t base_revision,void ** file_baton,apr_pool_t * file_pool)2386 svn_delta_editor_invoke_open_file_wrapper(svn_delta_editor_t *editor,
2387 const char *path,
2388 void *parent_baton,
2389 svn_revnum_t base_revision,
2390 void **file_baton,
2391 apr_pool_t *file_pool)
2392 {
2393 return svn_delta_editor_invoke_open_file(editor, path, parent_baton,
2394 base_revision,
2395 file_pool, file_baton);
2396 }
2397
2398 static svn_error_t *
svn_delta_editor_invoke_apply_textdelta_wrapper(svn_delta_editor_t * editor,void * file_baton,const char * base_checksum,svn_txdelta_window_handler_t * handler,void ** handler_baton,apr_pool_t * pool)2399 svn_delta_editor_invoke_apply_textdelta_wrapper(svn_delta_editor_t *editor,
2400 void *file_baton,
2401 const char *base_checksum,
2402 svn_txdelta_window_handler_t *handler,
2403 void **handler_baton,
2404 apr_pool_t *pool)
2405 {
2406 return svn_delta_editor_invoke_apply_textdelta(editor, file_baton,
2407 base_checksum, pool,
2408 handler, handler_baton);
2409 }
2410
2411 static svn_error_t *
svn_txdelta_invoke_window_handler_wrapper(VALUE obj,svn_txdelta_window_t * window,apr_pool_t * pool)2412 svn_txdelta_invoke_window_handler_wrapper(VALUE obj,
2413 svn_txdelta_window_t *window,
2414 apr_pool_t *pool)
2415 {
2416 return svn_swig_rb_invoke_txdelta_window_handler_wrapper(obj, window, pool);
2417 }
2418
2419 static svn_error_t *
svn_txdelta_editor_invoke_apply_textdelta_wrapper(VALUE obj,svn_txdelta_window_t * window,apr_pool_t * pool)2420 svn_txdelta_editor_invoke_apply_textdelta_wrapper(VALUE obj,
2421 svn_txdelta_window_t *window,
2422 apr_pool_t *pool)
2423 {
2424 return svn_swig_rb_invoke_txdelta_window_handler_wrapper(obj, window, pool);
2425 }
2426
2427 static const char *
svn_txdelta_md5_digest_as_cstring(svn_txdelta_stream_t * stream,apr_pool_t * pool)2428 svn_txdelta_md5_digest_as_cstring(svn_txdelta_stream_t *stream,
2429 apr_pool_t *pool)
2430 {
2431 const unsigned char *digest;
2432
2433 digest = svn_txdelta_md5_digest(stream);
2434
2435 if (digest) {
2436 return svn_md5_digest_to_cstring(digest, pool);
2437 } else {
2438 return NULL;
2439 }
2440 }
2441
2442
2443 SWIGINTERN VALUE
_wrap_svn_txdelta_window_t_ops_get(int argc,VALUE * argv,VALUE self)2444 _wrap_svn_txdelta_window_t_ops_get(int argc, VALUE *argv, VALUE self) {
2445 svn_txdelta_window_t *arg1 = (svn_txdelta_window_t *) 0 ;
2446 void *argp1 = 0 ;
2447 int res1 = 0 ;
2448 VALUE result;
2449 VALUE vresult = Qnil;
2450
2451 if ((argc < 1) || (argc > 1)) {
2452 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2453 }
2454 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
2455 if (!SWIG_IsOK(res1)) {
2456 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_txdelta_window_t *","svn_txdelta_window_t_ops_get", 1, argv[0] ));
2457 }
2458 arg1 = (svn_txdelta_window_t *)(argp1);
2459 {
2460 result = (VALUE)svn_txdelta_window_t_ops_get(arg1);
2461
2462
2463
2464 }
2465 vresult = result;
2466 return vresult;
2467 fail:
2468 return Qnil;
2469 }
2470
2471
2472 SWIGINTERN VALUE
_wrap_svn_delta_version(int argc,VALUE * argv,VALUE self)2473 _wrap_svn_delta_version(int argc, VALUE *argv, VALUE self) {
2474 svn_version_t *result = 0 ;
2475 VALUE vresult = Qnil;
2476
2477 if ((argc < 0) || (argc > 0)) {
2478 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2479 }
2480 {
2481 result = (svn_version_t *)svn_delta_version();
2482
2483
2484
2485 }
2486 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_svn_version_t, 0 | 0 );
2487 return vresult;
2488 fail:
2489 return Qnil;
2490 }
2491
2492
2493 static swig_class SwigClassSvn_txdelta_op_t;
2494
2495 SWIGINTERN VALUE
_wrap_svn_txdelta_op_t_action_code_set(int argc,VALUE * argv,VALUE self)2496 _wrap_svn_txdelta_op_t_action_code_set(int argc, VALUE *argv, VALUE self) {
2497 struct svn_txdelta_op_t *arg1 = (struct svn_txdelta_op_t *) 0 ;
2498 enum svn_delta_action arg2 ;
2499 void *argp1 = 0 ;
2500 int res1 = 0 ;
2501 int val2 ;
2502 int ecode2 = 0 ;
2503
2504 if ((argc < 1) || (argc > 1)) {
2505 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2506 }
2507 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_txdelta_op_t, 0 | 0 );
2508 if (!SWIG_IsOK(res1)) {
2509 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_txdelta_op_t *","action_code", 1, self ));
2510 }
2511 arg1 = (struct svn_txdelta_op_t *)(argp1);
2512 ecode2 = SWIG_AsVal_int(argv[0], &val2);
2513 if (!SWIG_IsOK(ecode2)) {
2514 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "enum svn_delta_action","action_code", 2, argv[0] ));
2515 }
2516 arg2 = (enum svn_delta_action)(val2);
2517 if (arg1) (arg1)->action_code = arg2;
2518 return Qnil;
2519 fail:
2520 return Qnil;
2521 }
2522
2523
2524 SWIGINTERN VALUE
_wrap_svn_txdelta_op_t_action_code_get(int argc,VALUE * argv,VALUE self)2525 _wrap_svn_txdelta_op_t_action_code_get(int argc, VALUE *argv, VALUE self) {
2526 struct svn_txdelta_op_t *arg1 = (struct svn_txdelta_op_t *) 0 ;
2527 void *argp1 = 0 ;
2528 int res1 = 0 ;
2529 enum svn_delta_action result;
2530 VALUE vresult = Qnil;
2531
2532 if ((argc < 0) || (argc > 0)) {
2533 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2534 }
2535 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_txdelta_op_t, 0 | 0 );
2536 if (!SWIG_IsOK(res1)) {
2537 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_txdelta_op_t *","action_code", 1, self ));
2538 }
2539 arg1 = (struct svn_txdelta_op_t *)(argp1);
2540 result = (enum svn_delta_action) ((arg1)->action_code);
2541 vresult = SWIG_From_int((int)(result));
2542 return vresult;
2543 fail:
2544 return Qnil;
2545 }
2546
2547
2548 SWIGINTERN VALUE
_wrap_svn_txdelta_op_t_offset_set(int argc,VALUE * argv,VALUE self)2549 _wrap_svn_txdelta_op_t_offset_set(int argc, VALUE *argv, VALUE self) {
2550 struct svn_txdelta_op_t *arg1 = (struct svn_txdelta_op_t *) 0 ;
2551 apr_size_t arg2 ;
2552 void *argp1 = 0 ;
2553 int res1 = 0 ;
2554 unsigned long val2 ;
2555 int ecode2 = 0 ;
2556
2557 if ((argc < 1) || (argc > 1)) {
2558 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2559 }
2560 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_txdelta_op_t, 0 | 0 );
2561 if (!SWIG_IsOK(res1)) {
2562 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_txdelta_op_t *","offset", 1, self ));
2563 }
2564 arg1 = (struct svn_txdelta_op_t *)(argp1);
2565 ecode2 = SWIG_AsVal_unsigned_SS_long(argv[0], &val2);
2566 if (!SWIG_IsOK(ecode2)) {
2567 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "apr_size_t","offset", 2, argv[0] ));
2568 }
2569 arg2 = (apr_size_t)(val2);
2570 if (arg1) (arg1)->offset = arg2;
2571 return Qnil;
2572 fail:
2573 return Qnil;
2574 }
2575
2576
2577 SWIGINTERN VALUE
_wrap_svn_txdelta_op_t_offset_get(int argc,VALUE * argv,VALUE self)2578 _wrap_svn_txdelta_op_t_offset_get(int argc, VALUE *argv, VALUE self) {
2579 struct svn_txdelta_op_t *arg1 = (struct svn_txdelta_op_t *) 0 ;
2580 void *argp1 = 0 ;
2581 int res1 = 0 ;
2582 apr_size_t result;
2583 VALUE vresult = Qnil;
2584
2585 if ((argc < 0) || (argc > 0)) {
2586 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2587 }
2588 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_txdelta_op_t, 0 | 0 );
2589 if (!SWIG_IsOK(res1)) {
2590 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_txdelta_op_t *","offset", 1, self ));
2591 }
2592 arg1 = (struct svn_txdelta_op_t *)(argp1);
2593 result = ((arg1)->offset);
2594 vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
2595 return vresult;
2596 fail:
2597 return Qnil;
2598 }
2599
2600
2601 SWIGINTERN VALUE
_wrap_svn_txdelta_op_t_length_set(int argc,VALUE * argv,VALUE self)2602 _wrap_svn_txdelta_op_t_length_set(int argc, VALUE *argv, VALUE self) {
2603 struct svn_txdelta_op_t *arg1 = (struct svn_txdelta_op_t *) 0 ;
2604 apr_size_t arg2 ;
2605 void *argp1 = 0 ;
2606 int res1 = 0 ;
2607 unsigned long val2 ;
2608 int ecode2 = 0 ;
2609
2610 if ((argc < 1) || (argc > 1)) {
2611 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2612 }
2613 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_txdelta_op_t, 0 | 0 );
2614 if (!SWIG_IsOK(res1)) {
2615 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_txdelta_op_t *","length", 1, self ));
2616 }
2617 arg1 = (struct svn_txdelta_op_t *)(argp1);
2618 ecode2 = SWIG_AsVal_unsigned_SS_long(argv[0], &val2);
2619 if (!SWIG_IsOK(ecode2)) {
2620 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "apr_size_t","length", 2, argv[0] ));
2621 }
2622 arg2 = (apr_size_t)(val2);
2623 if (arg1) (arg1)->length = arg2;
2624 return Qnil;
2625 fail:
2626 return Qnil;
2627 }
2628
2629
2630 SWIGINTERN VALUE
_wrap_svn_txdelta_op_t_length_get(int argc,VALUE * argv,VALUE self)2631 _wrap_svn_txdelta_op_t_length_get(int argc, VALUE *argv, VALUE self) {
2632 struct svn_txdelta_op_t *arg1 = (struct svn_txdelta_op_t *) 0 ;
2633 void *argp1 = 0 ;
2634 int res1 = 0 ;
2635 apr_size_t result;
2636 VALUE vresult = Qnil;
2637
2638 if ((argc < 0) || (argc > 0)) {
2639 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2640 }
2641 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_txdelta_op_t, 0 | 0 );
2642 if (!SWIG_IsOK(res1)) {
2643 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_txdelta_op_t *","length", 1, self ));
2644 }
2645 arg1 = (struct svn_txdelta_op_t *)(argp1);
2646 result = ((arg1)->length);
2647 vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
2648 return vresult;
2649 fail:
2650 return Qnil;
2651 }
2652
2653
2654 SWIGINTERN VALUE
2655 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
_wrap_svn_txdelta_op_t_allocate(VALUE self)2656 _wrap_svn_txdelta_op_t_allocate(VALUE self)
2657 #else
2658 _wrap_svn_txdelta_op_t_allocate(int argc, VALUE *argv, VALUE self)
2659 #endif
2660 {
2661 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_svn_txdelta_op_t);
2662 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
2663 rb_obj_call_init(vresult, argc, argv);
2664 #endif
2665 return vresult;
2666 }
2667
2668
2669 SWIGINTERN VALUE
_wrap_new_svn_txdelta_op_t(int argc,VALUE * argv,VALUE self)2670 _wrap_new_svn_txdelta_op_t(int argc, VALUE *argv, VALUE self) {
2671 struct svn_txdelta_op_t *result = 0 ;
2672
2673 if ((argc < 0) || (argc > 0)) {
2674 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2675 }
2676 {
2677 result = (struct svn_txdelta_op_t *)calloc(1, sizeof(struct svn_txdelta_op_t));
2678 DATA_PTR(self) = result;
2679
2680
2681
2682 }
2683 return self;
2684 fail:
2685 return Qnil;
2686 }
2687
2688
2689 SWIGINTERN void
free_svn_txdelta_op_t(void * self)2690 free_svn_txdelta_op_t(void *self) {
2691 struct svn_txdelta_op_t *arg1 = (struct svn_txdelta_op_t *)self;
2692 free((char *) arg1);
2693 }
2694
2695 static swig_class SwigClassSvn_txdelta_window_t;
2696
2697 SWIGINTERN VALUE
_wrap_svn_txdelta_window_t_sview_offset_set(int argc,VALUE * argv,VALUE self)2698 _wrap_svn_txdelta_window_t_sview_offset_set(int argc, VALUE *argv, VALUE self) {
2699 struct svn_txdelta_window_t *arg1 = (struct svn_txdelta_window_t *) 0 ;
2700 svn_filesize_t arg2 ;
2701 void *argp1 = 0 ;
2702 int res1 = 0 ;
2703
2704 if ((argc < 1) || (argc > 1)) {
2705 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2706 }
2707 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
2708 if (!SWIG_IsOK(res1)) {
2709 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_txdelta_window_t *","sview_offset", 1, self ));
2710 }
2711 arg1 = (struct svn_txdelta_window_t *)(argp1);
2712 {
2713 arg2 = (svn_filesize_t)NUM2LL(argv[0]);
2714 }
2715 if (arg1) (arg1)->sview_offset = arg2;
2716 return Qnil;
2717 fail:
2718 return Qnil;
2719 }
2720
2721
2722 SWIGINTERN VALUE
_wrap_svn_txdelta_window_t_sview_offset_get(int argc,VALUE * argv,VALUE self)2723 _wrap_svn_txdelta_window_t_sview_offset_get(int argc, VALUE *argv, VALUE self) {
2724 struct svn_txdelta_window_t *arg1 = (struct svn_txdelta_window_t *) 0 ;
2725 void *argp1 = 0 ;
2726 int res1 = 0 ;
2727 svn_filesize_t result;
2728 VALUE vresult = Qnil;
2729
2730 if ((argc < 0) || (argc > 0)) {
2731 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2732 }
2733 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
2734 if (!SWIG_IsOK(res1)) {
2735 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_txdelta_window_t *","sview_offset", 1, self ));
2736 }
2737 arg1 = (struct svn_txdelta_window_t *)(argp1);
2738 result = ((arg1)->sview_offset);
2739 {
2740 vresult = LL2NUM((svn_filesize_t)(result));
2741 }
2742 return vresult;
2743 fail:
2744 return Qnil;
2745 }
2746
2747
2748 SWIGINTERN VALUE
_wrap_svn_txdelta_window_t_sview_len_set(int argc,VALUE * argv,VALUE self)2749 _wrap_svn_txdelta_window_t_sview_len_set(int argc, VALUE *argv, VALUE self) {
2750 struct svn_txdelta_window_t *arg1 = (struct svn_txdelta_window_t *) 0 ;
2751 apr_size_t arg2 ;
2752 void *argp1 = 0 ;
2753 int res1 = 0 ;
2754 unsigned long val2 ;
2755 int ecode2 = 0 ;
2756
2757 if ((argc < 1) || (argc > 1)) {
2758 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2759 }
2760 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
2761 if (!SWIG_IsOK(res1)) {
2762 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_txdelta_window_t *","sview_len", 1, self ));
2763 }
2764 arg1 = (struct svn_txdelta_window_t *)(argp1);
2765 ecode2 = SWIG_AsVal_unsigned_SS_long(argv[0], &val2);
2766 if (!SWIG_IsOK(ecode2)) {
2767 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "apr_size_t","sview_len", 2, argv[0] ));
2768 }
2769 arg2 = (apr_size_t)(val2);
2770 if (arg1) (arg1)->sview_len = arg2;
2771 return Qnil;
2772 fail:
2773 return Qnil;
2774 }
2775
2776
2777 SWIGINTERN VALUE
_wrap_svn_txdelta_window_t_sview_len_get(int argc,VALUE * argv,VALUE self)2778 _wrap_svn_txdelta_window_t_sview_len_get(int argc, VALUE *argv, VALUE self) {
2779 struct svn_txdelta_window_t *arg1 = (struct svn_txdelta_window_t *) 0 ;
2780 void *argp1 = 0 ;
2781 int res1 = 0 ;
2782 apr_size_t result;
2783 VALUE vresult = Qnil;
2784
2785 if ((argc < 0) || (argc > 0)) {
2786 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2787 }
2788 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
2789 if (!SWIG_IsOK(res1)) {
2790 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_txdelta_window_t *","sview_len", 1, self ));
2791 }
2792 arg1 = (struct svn_txdelta_window_t *)(argp1);
2793 result = ((arg1)->sview_len);
2794 vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
2795 return vresult;
2796 fail:
2797 return Qnil;
2798 }
2799
2800
2801 SWIGINTERN VALUE
_wrap_svn_txdelta_window_t_tview_len_set(int argc,VALUE * argv,VALUE self)2802 _wrap_svn_txdelta_window_t_tview_len_set(int argc, VALUE *argv, VALUE self) {
2803 struct svn_txdelta_window_t *arg1 = (struct svn_txdelta_window_t *) 0 ;
2804 apr_size_t arg2 ;
2805 void *argp1 = 0 ;
2806 int res1 = 0 ;
2807 unsigned long val2 ;
2808 int ecode2 = 0 ;
2809
2810 if ((argc < 1) || (argc > 1)) {
2811 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2812 }
2813 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
2814 if (!SWIG_IsOK(res1)) {
2815 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_txdelta_window_t *","tview_len", 1, self ));
2816 }
2817 arg1 = (struct svn_txdelta_window_t *)(argp1);
2818 ecode2 = SWIG_AsVal_unsigned_SS_long(argv[0], &val2);
2819 if (!SWIG_IsOK(ecode2)) {
2820 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "apr_size_t","tview_len", 2, argv[0] ));
2821 }
2822 arg2 = (apr_size_t)(val2);
2823 if (arg1) (arg1)->tview_len = arg2;
2824 return Qnil;
2825 fail:
2826 return Qnil;
2827 }
2828
2829
2830 SWIGINTERN VALUE
_wrap_svn_txdelta_window_t_tview_len_get(int argc,VALUE * argv,VALUE self)2831 _wrap_svn_txdelta_window_t_tview_len_get(int argc, VALUE *argv, VALUE self) {
2832 struct svn_txdelta_window_t *arg1 = (struct svn_txdelta_window_t *) 0 ;
2833 void *argp1 = 0 ;
2834 int res1 = 0 ;
2835 apr_size_t result;
2836 VALUE vresult = Qnil;
2837
2838 if ((argc < 0) || (argc > 0)) {
2839 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2840 }
2841 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
2842 if (!SWIG_IsOK(res1)) {
2843 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_txdelta_window_t *","tview_len", 1, self ));
2844 }
2845 arg1 = (struct svn_txdelta_window_t *)(argp1);
2846 result = ((arg1)->tview_len);
2847 vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
2848 return vresult;
2849 fail:
2850 return Qnil;
2851 }
2852
2853
2854 SWIGINTERN VALUE
_wrap_svn_txdelta_window_t_num_ops_set(int argc,VALUE * argv,VALUE self)2855 _wrap_svn_txdelta_window_t_num_ops_set(int argc, VALUE *argv, VALUE self) {
2856 struct svn_txdelta_window_t *arg1 = (struct svn_txdelta_window_t *) 0 ;
2857 int arg2 ;
2858 void *argp1 = 0 ;
2859 int res1 = 0 ;
2860 int val2 ;
2861 int ecode2 = 0 ;
2862
2863 if ((argc < 1) || (argc > 1)) {
2864 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2865 }
2866 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
2867 if (!SWIG_IsOK(res1)) {
2868 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_txdelta_window_t *","num_ops", 1, self ));
2869 }
2870 arg1 = (struct svn_txdelta_window_t *)(argp1);
2871 ecode2 = SWIG_AsVal_int(argv[0], &val2);
2872 if (!SWIG_IsOK(ecode2)) {
2873 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","num_ops", 2, argv[0] ));
2874 }
2875 arg2 = (int)(val2);
2876 if (arg1) (arg1)->num_ops = arg2;
2877 return Qnil;
2878 fail:
2879 return Qnil;
2880 }
2881
2882
2883 SWIGINTERN VALUE
_wrap_svn_txdelta_window_t_num_ops_get(int argc,VALUE * argv,VALUE self)2884 _wrap_svn_txdelta_window_t_num_ops_get(int argc, VALUE *argv, VALUE self) {
2885 struct svn_txdelta_window_t *arg1 = (struct svn_txdelta_window_t *) 0 ;
2886 void *argp1 = 0 ;
2887 int res1 = 0 ;
2888 int result;
2889 VALUE vresult = Qnil;
2890
2891 if ((argc < 0) || (argc > 0)) {
2892 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2893 }
2894 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
2895 if (!SWIG_IsOK(res1)) {
2896 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_txdelta_window_t *","num_ops", 1, self ));
2897 }
2898 arg1 = (struct svn_txdelta_window_t *)(argp1);
2899 result = (int) ((arg1)->num_ops);
2900 vresult = SWIG_From_int((int)(result));
2901 return vresult;
2902 fail:
2903 return Qnil;
2904 }
2905
2906
2907 SWIGINTERN VALUE
_wrap_svn_txdelta_window_t_src_ops_set(int argc,VALUE * argv,VALUE self)2908 _wrap_svn_txdelta_window_t_src_ops_set(int argc, VALUE *argv, VALUE self) {
2909 struct svn_txdelta_window_t *arg1 = (struct svn_txdelta_window_t *) 0 ;
2910 int arg2 ;
2911 void *argp1 = 0 ;
2912 int res1 = 0 ;
2913 int val2 ;
2914 int ecode2 = 0 ;
2915
2916 if ((argc < 1) || (argc > 1)) {
2917 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2918 }
2919 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
2920 if (!SWIG_IsOK(res1)) {
2921 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_txdelta_window_t *","src_ops", 1, self ));
2922 }
2923 arg1 = (struct svn_txdelta_window_t *)(argp1);
2924 ecode2 = SWIG_AsVal_int(argv[0], &val2);
2925 if (!SWIG_IsOK(ecode2)) {
2926 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","src_ops", 2, argv[0] ));
2927 }
2928 arg2 = (int)(val2);
2929 if (arg1) (arg1)->src_ops = arg2;
2930 return Qnil;
2931 fail:
2932 return Qnil;
2933 }
2934
2935
2936 SWIGINTERN VALUE
_wrap_svn_txdelta_window_t_src_ops_get(int argc,VALUE * argv,VALUE self)2937 _wrap_svn_txdelta_window_t_src_ops_get(int argc, VALUE *argv, VALUE self) {
2938 struct svn_txdelta_window_t *arg1 = (struct svn_txdelta_window_t *) 0 ;
2939 void *argp1 = 0 ;
2940 int res1 = 0 ;
2941 int result;
2942 VALUE vresult = Qnil;
2943
2944 if ((argc < 0) || (argc > 0)) {
2945 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2946 }
2947 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
2948 if (!SWIG_IsOK(res1)) {
2949 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_txdelta_window_t *","src_ops", 1, self ));
2950 }
2951 arg1 = (struct svn_txdelta_window_t *)(argp1);
2952 result = (int) ((arg1)->src_ops);
2953 vresult = SWIG_From_int((int)(result));
2954 return vresult;
2955 fail:
2956 return Qnil;
2957 }
2958
2959
2960 SWIGINTERN VALUE
_wrap_svn_txdelta_window_t_new_data_get(int argc,VALUE * argv,VALUE self)2961 _wrap_svn_txdelta_window_t_new_data_get(int argc, VALUE *argv, VALUE self) {
2962 struct svn_txdelta_window_t *arg1 = (struct svn_txdelta_window_t *) 0 ;
2963 void *argp1 = 0 ;
2964 int res1 = 0 ;
2965 svn_string_t *result = 0 ;
2966 VALUE vresult = Qnil;
2967
2968 if ((argc < 0) || (argc > 0)) {
2969 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2970 }
2971 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
2972 if (!SWIG_IsOK(res1)) {
2973 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_txdelta_window_t *","new_data", 1, self ));
2974 }
2975 arg1 = (struct svn_txdelta_window_t *)(argp1);
2976 result = (svn_string_t *) ((arg1)->new_data);
2977 {
2978 if (result) {
2979 vresult = rb_str_new(result->data, result->len);
2980 } else {
2981 vresult = Qnil;
2982 }
2983 }
2984 return vresult;
2985 fail:
2986 return Qnil;
2987 }
2988
2989
2990 SWIGINTERN VALUE
2991 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
_wrap_svn_txdelta_window_t_allocate(VALUE self)2992 _wrap_svn_txdelta_window_t_allocate(VALUE self)
2993 #else
2994 _wrap_svn_txdelta_window_t_allocate(int argc, VALUE *argv, VALUE self)
2995 #endif
2996 {
2997 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_svn_txdelta_window_t);
2998 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
2999 rb_obj_call_init(vresult, argc, argv);
3000 #endif
3001 return vresult;
3002 }
3003
3004
3005 SWIGINTERN VALUE
_wrap_new_svn_txdelta_window_t(int argc,VALUE * argv,VALUE self)3006 _wrap_new_svn_txdelta_window_t(int argc, VALUE *argv, VALUE self) {
3007 struct svn_txdelta_window_t *result = 0 ;
3008
3009 if ((argc < 0) || (argc > 0)) {
3010 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3011 }
3012 {
3013 result = (struct svn_txdelta_window_t *)calloc(1, sizeof(struct svn_txdelta_window_t));
3014 DATA_PTR(self) = result;
3015
3016
3017
3018 }
3019 return self;
3020 fail:
3021 return Qnil;
3022 }
3023
3024
3025 SWIGINTERN void
free_svn_txdelta_window_t(void * self)3026 free_svn_txdelta_window_t(void *self) {
3027 struct svn_txdelta_window_t *arg1 = (struct svn_txdelta_window_t *)self;
3028 free((char *) arg1);
3029 }
3030
3031 SWIGINTERN VALUE
_wrap_svn_txdelta_window_dup(int argc,VALUE * argv,VALUE self)3032 _wrap_svn_txdelta_window_dup(int argc, VALUE *argv, VALUE self) {
3033 svn_txdelta_window_t *arg1 = (svn_txdelta_window_t *) 0 ;
3034 apr_pool_t *arg2 = (apr_pool_t *) 0 ;
3035 VALUE _global_svn_swig_rb_pool ;
3036 apr_pool_t *_global_pool ;
3037 void *argp1 = 0 ;
3038 int res1 = 0 ;
3039 svn_txdelta_window_t *result = 0 ;
3040 VALUE vresult = Qnil;
3041
3042 {
3043 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg2);
3044 _global_pool = arg2;
3045 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
3046 }
3047 if ((argc < 1) || (argc > 2)) {
3048 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3049 }
3050 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
3051 if (!SWIG_IsOK(res1)) {
3052 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_txdelta_window_t const *","svn_txdelta_window_dup", 1, argv[0] ));
3053 }
3054 arg1 = (svn_txdelta_window_t *)(argp1);
3055 if (argc > 1) {
3056
3057 }
3058 {
3059 result = (svn_txdelta_window_t *)svn_txdelta_window_dup((struct svn_txdelta_window_t const *)arg1,arg2);
3060
3061
3062
3063 }
3064 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
3065 {
3066 VALUE target;
3067 target = _global_vresult_address == &vresult ? self : vresult;
3068 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3069 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3070 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3071 }
3072 return vresult;
3073 fail:
3074 {
3075 VALUE target;
3076 target = _global_vresult_address == &vresult ? self : vresult;
3077 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3078 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3079 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3080 }
3081 return Qnil;
3082 }
3083
3084
3085 SWIGINTERN VALUE
_wrap_svn_txdelta_compose_windows(int argc,VALUE * argv,VALUE self)3086 _wrap_svn_txdelta_compose_windows(int argc, VALUE *argv, VALUE self) {
3087 svn_txdelta_window_t *arg1 = (svn_txdelta_window_t *) 0 ;
3088 svn_txdelta_window_t *arg2 = (svn_txdelta_window_t *) 0 ;
3089 apr_pool_t *arg3 = (apr_pool_t *) 0 ;
3090 VALUE _global_svn_swig_rb_pool ;
3091 apr_pool_t *_global_pool ;
3092 void *argp1 = 0 ;
3093 int res1 = 0 ;
3094 void *argp2 = 0 ;
3095 int res2 = 0 ;
3096 svn_txdelta_window_t *result = 0 ;
3097 VALUE vresult = Qnil;
3098
3099 {
3100 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
3101 _global_pool = arg3;
3102 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
3103 }
3104 if ((argc < 2) || (argc > 3)) {
3105 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3106 }
3107 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
3108 if (!SWIG_IsOK(res1)) {
3109 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_txdelta_window_t const *","svn_txdelta_compose_windows", 1, argv[0] ));
3110 }
3111 arg1 = (svn_txdelta_window_t *)(argp1);
3112 res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
3113 if (!SWIG_IsOK(res2)) {
3114 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "svn_txdelta_window_t const *","svn_txdelta_compose_windows", 2, argv[1] ));
3115 }
3116 arg2 = (svn_txdelta_window_t *)(argp2);
3117 if (argc > 2) {
3118
3119 }
3120 {
3121 result = (svn_txdelta_window_t *)svn_txdelta_compose_windows((struct svn_txdelta_window_t const *)arg1,(struct svn_txdelta_window_t const *)arg2,arg3);
3122
3123
3124
3125 }
3126 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
3127 {
3128 VALUE target;
3129 target = _global_vresult_address == &vresult ? self : vresult;
3130 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3131 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3132 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3133 }
3134 return vresult;
3135 fail:
3136 {
3137 VALUE target;
3138 target = _global_vresult_address == &vresult ? self : vresult;
3139 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3140 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3141 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3142 }
3143 return Qnil;
3144 }
3145
3146
3147 SWIGINTERN VALUE
_wrap_svn_txdelta_apply_instructions(int argc,VALUE * argv,VALUE self)3148 _wrap_svn_txdelta_apply_instructions(int argc, VALUE *argv, VALUE self) {
3149 svn_txdelta_window_t *arg1 = (svn_txdelta_window_t *) 0 ;
3150 char *arg2 = (char *) 0 ;
3151 char *arg3 = (char *) 0 ;
3152 apr_size_t *arg4 = (apr_size_t *) 0 ;
3153 void *argp1 = 0 ;
3154 int res1 = 0 ;
3155 int res2 ;
3156 char *buf2 = 0 ;
3157 int alloc2 = 0 ;
3158 int res3 ;
3159 char *buf3 = 0 ;
3160 int alloc3 = 0 ;
3161 apr_size_t temp4 ;
3162 int res4 = SWIG_TMPOBJ ;
3163 VALUE vresult = Qnil;
3164
3165 arg4 = &temp4;
3166 if ((argc < 3) || (argc > 3)) {
3167 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
3168 }
3169 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
3170 if (!SWIG_IsOK(res1)) {
3171 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_txdelta_window_t *","svn_txdelta_apply_instructions", 1, argv[0] ));
3172 }
3173 arg1 = (svn_txdelta_window_t *)(argp1);
3174 res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
3175 if (!SWIG_IsOK(res2)) {
3176 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_txdelta_apply_instructions", 2, argv[1] ));
3177 }
3178 arg2 = (char *)(buf2);
3179 res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
3180 if (!SWIG_IsOK(res3)) {
3181 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","svn_txdelta_apply_instructions", 3, argv[2] ));
3182 }
3183 arg3 = (char *)(buf3);
3184 {
3185 svn_txdelta_apply_instructions(arg1,(char const *)arg2,arg3,arg4);
3186
3187
3188
3189 }
3190 if (SWIG_IsTmpObj(res4)) {
3191 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_long((*arg4)));
3192 } else {
3193 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3194 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_apr_size_t, new_flags));
3195 }
3196 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3197 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3198 return vresult;
3199 fail:
3200 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3201 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3202 return Qnil;
3203 }
3204
3205
3206 SWIGINTERN VALUE
_wrap_svn_txdelta_run(int argc,VALUE * argv,VALUE self)3207 _wrap_svn_txdelta_run(int argc, VALUE *argv, VALUE self) {
3208 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
3209 svn_stream_t *arg2 = (svn_stream_t *) 0 ;
3210 svn_txdelta_window_handler_t arg3 = (svn_txdelta_window_handler_t) 0 ;
3211 void *arg4 = (void *) 0 ;
3212 svn_checksum_kind_t arg5 ;
3213 svn_checksum_t **arg6 = (svn_checksum_t **) 0 ;
3214 svn_cancel_func_t arg7 = (svn_cancel_func_t) 0 ;
3215 void *arg8 = (void *) 0 ;
3216 apr_pool_t *arg9 = (apr_pool_t *) 0 ;
3217 apr_pool_t *arg10 = (apr_pool_t *) 0 ;
3218 VALUE _global_svn_swig_rb_pool ;
3219 apr_pool_t *_global_pool ;
3220 int val5 ;
3221 int ecode5 = 0 ;
3222 svn_checksum_t *temp6 ;
3223 svn_error_t *result = 0 ;
3224 VALUE vresult = Qnil;
3225
3226 {
3227 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg9);
3228 _global_pool = arg9;
3229 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
3230 }
3231 {
3232 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg10);
3233 _global_pool = arg10;
3234 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
3235 }
3236 arg6 = &temp6;
3237 if ((argc < 5) || (argc > 7)) {
3238 rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
3239 }
3240 {
3241 arg1 = svn_swig_rb_make_stream(argv[0]);
3242 }
3243 {
3244 arg2 = svn_swig_rb_make_stream(argv[1]);
3245 }
3246 {
3247 if (RTEST(rb_obj_is_kind_of(argv[2],
3248 svn_swig_rb_svn_delta_text_delta_window_handler()))) {
3249 arg3 = svn_swig_rb_to_swig_type(argv[2],
3250 "svn_txdelta_window_handler_t",
3251 _global_pool);
3252 arg4 = svn_swig_rb_to_swig_type(rb_funcall(argv[2], rb_intern("baton"), 0),
3253 "void *", _global_pool);
3254 } else {
3255 arg3 = svn_swig_rb_txdelta_window_handler;
3256 arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
3257 }
3258 }
3259 ecode5 = SWIG_AsVal_int(argv[3], &val5);
3260 if (!SWIG_IsOK(ecode5)) {
3261 SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "svn_checksum_kind_t","svn_txdelta_run", 5, argv[3] ));
3262 }
3263 arg5 = (svn_checksum_kind_t)(val5);
3264 {
3265 arg7 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
3266 arg8 = (void *)svn_swig_rb_make_baton(argv[4], _global_svn_swig_rb_pool);
3267 }
3268 if (argc > 5) {
3269
3270 }
3271 if (argc > 6) {
3272
3273 }
3274 {
3275 result = (svn_error_t *)svn_txdelta_run(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
3276
3277
3278
3279 }
3280 {
3281 if (result) {
3282 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3283 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3284 svn_swig_rb_handle_svn_error(result);
3285 }
3286 vresult = Qnil;
3287 }
3288 {
3289 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg6, SWIGTYPE_p_svn_checksum_t, 0));
3290 }
3291 {
3292 svn_swig_rb_set_baton(vresult, (VALUE)arg8);
3293 }
3294 {
3295 VALUE target;
3296 target = _global_vresult_address == &vresult ? self : vresult;
3297 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3298 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3299 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3300 }
3301 {
3302 VALUE target;
3303 target = _global_vresult_address == &vresult ? self : vresult;
3304 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3305 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3306 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3307 }
3308 return vresult;
3309 fail:
3310 {
3311 VALUE target;
3312 target = _global_vresult_address == &vresult ? self : vresult;
3313 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3314 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3315 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3316 }
3317 {
3318 VALUE target;
3319 target = _global_vresult_address == &vresult ? self : vresult;
3320 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3321 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3322 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3323 }
3324 return Qnil;
3325 }
3326
3327
3328 SWIGINTERN VALUE
_wrap_svn_txdelta_stream_create(int argc,VALUE * argv,VALUE self)3329 _wrap_svn_txdelta_stream_create(int argc, VALUE *argv, VALUE self) {
3330 void *arg1 = (void *) 0 ;
3331 svn_txdelta_next_window_fn_t arg2 = (svn_txdelta_next_window_fn_t) 0 ;
3332 svn_txdelta_md5_digest_fn_t arg3 = (svn_txdelta_md5_digest_fn_t) 0 ;
3333 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
3334 VALUE _global_svn_swig_rb_pool ;
3335 apr_pool_t *_global_pool ;
3336 int res1 ;
3337 svn_txdelta_stream_t *result = 0 ;
3338 VALUE vresult = Qnil;
3339
3340 {
3341 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
3342 _global_pool = arg4;
3343 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
3344 }
3345 if ((argc < 3) || (argc > 4)) {
3346 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
3347 }
3348 res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
3349 if (!SWIG_IsOK(res1)) {
3350 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","svn_txdelta_stream_create", 1, argv[0] ));
3351 }
3352 {
3353 int res = SWIG_ConvertFunctionPtr(argv[1], (void**)(&arg2), SWIGTYPE_p_f_p_p_svn_txdelta_window_t_p_void_p_apr_pool_t__p_svn_error_t);
3354 if (!SWIG_IsOK(res)) {
3355 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_txdelta_next_window_fn_t","svn_txdelta_stream_create", 2, argv[1] ));
3356 }
3357 }
3358 {
3359 int res = SWIG_ConvertFunctionPtr(argv[2], (void**)(&arg3), SWIGTYPE_p_f_p_void__p_unsigned_char);
3360 if (!SWIG_IsOK(res)) {
3361 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_txdelta_md5_digest_fn_t","svn_txdelta_stream_create", 3, argv[2] ));
3362 }
3363 }
3364 if (argc > 3) {
3365
3366 }
3367 {
3368 result = (svn_txdelta_stream_t *)svn_txdelta_stream_create(arg1,arg2,(unsigned char const *(*)(void *))arg3,arg4);
3369
3370
3371
3372 }
3373 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_svn_txdelta_stream_t, 0 | 0 );
3374 {
3375 VALUE target;
3376 target = _global_vresult_address == &vresult ? self : vresult;
3377 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3378 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3379 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3380 }
3381 return vresult;
3382 fail:
3383 {
3384 VALUE target;
3385 target = _global_vresult_address == &vresult ? self : vresult;
3386 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3387 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3388 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3389 }
3390 return Qnil;
3391 }
3392
3393
3394 SWIGINTERN VALUE
_wrap_svn_txdelta_next_window(int argc,VALUE * argv,VALUE self)3395 _wrap_svn_txdelta_next_window(int argc, VALUE *argv, VALUE self) {
3396 svn_txdelta_window_t **arg1 = (svn_txdelta_window_t **) 0 ;
3397 svn_txdelta_stream_t *arg2 = (svn_txdelta_stream_t *) 0 ;
3398 apr_pool_t *arg3 = (apr_pool_t *) 0 ;
3399 VALUE _global_svn_swig_rb_pool ;
3400 apr_pool_t *_global_pool ;
3401 svn_txdelta_window_t *temp1 ;
3402 void *argp2 = 0 ;
3403 int res2 = 0 ;
3404 svn_error_t *result = 0 ;
3405 VALUE vresult = Qnil;
3406
3407 {
3408 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
3409 _global_pool = arg3;
3410 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
3411 }
3412 arg1 = &temp1;
3413 if ((argc < 1) || (argc > 2)) {
3414 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3415 }
3416 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_svn_txdelta_stream_t, 0 | 0 );
3417 if (!SWIG_IsOK(res2)) {
3418 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "svn_txdelta_stream_t *","svn_txdelta_next_window", 2, argv[0] ));
3419 }
3420 arg2 = (svn_txdelta_stream_t *)(argp2);
3421 if (argc > 1) {
3422
3423 }
3424 {
3425 result = (svn_error_t *)svn_txdelta_next_window(arg1,arg2,arg3);
3426
3427
3428
3429 }
3430 {
3431 if (result) {
3432 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3433 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3434 svn_swig_rb_handle_svn_error(result);
3435 }
3436 vresult = Qnil;
3437 }
3438 {
3439 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_txdelta_window_t, 0));
3440 }
3441 {
3442 VALUE target;
3443 target = _global_vresult_address == &vresult ? self : vresult;
3444 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3445 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3446 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3447 }
3448 return vresult;
3449 fail:
3450 {
3451 VALUE target;
3452 target = _global_vresult_address == &vresult ? self : vresult;
3453 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3454 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3455 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3456 }
3457 return Qnil;
3458 }
3459
3460
3461 SWIGINTERN VALUE
_wrap_svn_txdelta_md5_digest(int argc,VALUE * argv,VALUE self)3462 _wrap_svn_txdelta_md5_digest(int argc, VALUE *argv, VALUE self) {
3463 svn_txdelta_stream_t *arg1 = (svn_txdelta_stream_t *) 0 ;
3464 void *argp1 = 0 ;
3465 int res1 = 0 ;
3466 unsigned char *result = 0 ;
3467 VALUE vresult = Qnil;
3468
3469 if ((argc < 1) || (argc > 1)) {
3470 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3471 }
3472 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_txdelta_stream_t, 0 | 0 );
3473 if (!SWIG_IsOK(res1)) {
3474 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_txdelta_stream_t *","svn_txdelta_md5_digest", 1, argv[0] ));
3475 }
3476 arg1 = (svn_txdelta_stream_t *)(argp1);
3477 {
3478 result = (unsigned char *)svn_txdelta_md5_digest(arg1);
3479
3480
3481
3482 }
3483 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
3484 return vresult;
3485 fail:
3486 return Qnil;
3487 }
3488
3489
3490 SWIGINTERN VALUE
_wrap_svn_txdelta2(int argc,VALUE * argv,VALUE self)3491 _wrap_svn_txdelta2(int argc, VALUE *argv, VALUE self) {
3492 svn_txdelta_stream_t **arg1 = (svn_txdelta_stream_t **) 0 ;
3493 svn_stream_t *arg2 = (svn_stream_t *) 0 ;
3494 svn_stream_t *arg3 = (svn_stream_t *) 0 ;
3495 svn_boolean_t arg4 ;
3496 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
3497 VALUE _global_svn_swig_rb_pool ;
3498 apr_pool_t *_global_pool ;
3499 svn_txdelta_stream_t *temp1 ;
3500 VALUE vresult = Qnil;
3501
3502 {
3503 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
3504 _global_pool = arg5;
3505 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
3506 }
3507 arg1 = &temp1;
3508 if ((argc < 3) || (argc > 4)) {
3509 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
3510 }
3511 {
3512 arg2 = svn_swig_rb_make_stream(argv[0]);
3513 }
3514 {
3515 arg3 = svn_swig_rb_make_stream(argv[1]);
3516 }
3517 arg4 = RTEST(argv[2]);
3518 if (argc > 3) {
3519
3520 }
3521 {
3522 svn_txdelta2(arg1,arg2,arg3,arg4,arg5);
3523
3524
3525
3526 }
3527 {
3528 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_txdelta_stream_t, 0));
3529 }
3530 {
3531 VALUE target;
3532 target = _global_vresult_address == &vresult ? self : vresult;
3533 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3534 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3535 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3536 }
3537 return vresult;
3538 fail:
3539 {
3540 VALUE target;
3541 target = _global_vresult_address == &vresult ? self : vresult;
3542 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3543 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3544 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3545 }
3546 return Qnil;
3547 }
3548
3549
3550 SWIGINTERN VALUE
_wrap_svn_txdelta(int argc,VALUE * argv,VALUE self)3551 _wrap_svn_txdelta(int argc, VALUE *argv, VALUE self) {
3552 svn_txdelta_stream_t **arg1 = (svn_txdelta_stream_t **) 0 ;
3553 svn_stream_t *arg2 = (svn_stream_t *) 0 ;
3554 svn_stream_t *arg3 = (svn_stream_t *) 0 ;
3555 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
3556 VALUE _global_svn_swig_rb_pool ;
3557 apr_pool_t *_global_pool ;
3558 svn_txdelta_stream_t *temp1 ;
3559 VALUE vresult = Qnil;
3560
3561 {
3562 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
3563 _global_pool = arg4;
3564 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
3565 }
3566 arg1 = &temp1;
3567 if ((argc < 2) || (argc > 3)) {
3568 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3569 }
3570 {
3571 arg2 = svn_swig_rb_make_stream(argv[0]);
3572 }
3573 {
3574 arg3 = svn_swig_rb_make_stream(argv[1]);
3575 }
3576 if (argc > 2) {
3577
3578 }
3579 {
3580 svn_txdelta(arg1,arg2,arg3,arg4);
3581
3582
3583
3584 }
3585 {
3586 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_txdelta_stream_t, 0));
3587 }
3588 {
3589 VALUE target;
3590 target = _global_vresult_address == &vresult ? self : vresult;
3591 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3592 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3593 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3594 }
3595 return vresult;
3596 fail:
3597 {
3598 VALUE target;
3599 target = _global_vresult_address == &vresult ? self : vresult;
3600 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3601 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3602 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3603 }
3604 return Qnil;
3605 }
3606
3607
3608 SWIGINTERN VALUE
_wrap_svn_txdelta_target_push(int argc,VALUE * argv,VALUE self)3609 _wrap_svn_txdelta_target_push(int argc, VALUE *argv, VALUE self) {
3610 svn_txdelta_window_handler_t arg1 = (svn_txdelta_window_handler_t) 0 ;
3611 void *arg2 = (void *) 0 ;
3612 svn_stream_t *arg3 = (svn_stream_t *) 0 ;
3613 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
3614 VALUE _global_svn_swig_rb_pool ;
3615 apr_pool_t *_global_pool ;
3616 svn_stream_t *result = 0 ;
3617 VALUE vresult = Qnil;
3618
3619 {
3620 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
3621 _global_pool = arg4;
3622 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
3623 }
3624 if ((argc < 2) || (argc > 3)) {
3625 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3626 }
3627 {
3628 if (RTEST(rb_obj_is_kind_of(argv[0],
3629 svn_swig_rb_svn_delta_text_delta_window_handler()))) {
3630 arg1 = svn_swig_rb_to_swig_type(argv[0],
3631 "svn_txdelta_window_handler_t",
3632 _global_pool);
3633 arg2 = svn_swig_rb_to_swig_type(rb_funcall(argv[0], rb_intern("baton"), 0),
3634 "void *", _global_pool);
3635 } else {
3636 arg1 = svn_swig_rb_txdelta_window_handler;
3637 arg2 = (void *)svn_swig_rb_make_baton(argv[0], _global_svn_swig_rb_pool);
3638 }
3639 }
3640 {
3641 arg3 = svn_swig_rb_make_stream(argv[1]);
3642 }
3643 if (argc > 2) {
3644
3645 }
3646 {
3647 result = (svn_stream_t *)svn_txdelta_target_push(arg1,arg2,arg3,arg4);
3648
3649
3650
3651 }
3652 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_svn_stream_t, 0 | 0 );
3653 {
3654 VALUE target;
3655 target = _global_vresult_address == &vresult ? self : vresult;
3656 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3657 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3658 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3659 }
3660 return vresult;
3661 fail:
3662 {
3663 VALUE target;
3664 target = _global_vresult_address == &vresult ? self : vresult;
3665 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3666 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3667 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3668 }
3669 return Qnil;
3670 }
3671
3672
3673 SWIGINTERN VALUE
_wrap_svn_txdelta_send_string(int argc,VALUE * argv,VALUE self)3674 _wrap_svn_txdelta_send_string(int argc, VALUE *argv, VALUE self) {
3675 svn_string_t *arg1 = (svn_string_t *) 0 ;
3676 svn_txdelta_window_handler_t arg2 = (svn_txdelta_window_handler_t) 0 ;
3677 void *arg3 = (void *) 0 ;
3678 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
3679 VALUE _global_svn_swig_rb_pool ;
3680 apr_pool_t *_global_pool ;
3681 svn_string_t value1 ;
3682 svn_error_t *result = 0 ;
3683 VALUE vresult = Qnil;
3684
3685 {
3686 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
3687 _global_pool = arg4;
3688 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
3689 }
3690 if ((argc < 2) || (argc > 3)) {
3691 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3692 }
3693 {
3694 if (NIL_P(argv[0])) {
3695 arg1 = NULL;
3696 } else {
3697 value1.data = StringValuePtr(argv[0]);
3698 value1.len = RSTRING_LEN(argv[0]);
3699 arg1 = &value1;
3700 }
3701 }
3702 {
3703 if (RTEST(rb_obj_is_kind_of(argv[1],
3704 svn_swig_rb_svn_delta_text_delta_window_handler()))) {
3705 arg2 = svn_swig_rb_to_swig_type(argv[1],
3706 "svn_txdelta_window_handler_t",
3707 _global_pool);
3708 arg3 = svn_swig_rb_to_swig_type(rb_funcall(argv[1], rb_intern("baton"), 0),
3709 "void *", _global_pool);
3710 } else {
3711 arg2 = svn_swig_rb_txdelta_window_handler;
3712 arg3 = (void *)svn_swig_rb_make_baton(argv[1], _global_svn_swig_rb_pool);
3713 }
3714 }
3715 if (argc > 2) {
3716
3717 }
3718 {
3719 result = (svn_error_t *)svn_txdelta_send_string((struct svn_string_t const *)arg1,arg2,arg3,arg4);
3720
3721
3722
3723 }
3724 {
3725 if (result) {
3726 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3727 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3728 svn_swig_rb_handle_svn_error(result);
3729 }
3730 vresult = Qnil;
3731 }
3732 {
3733 VALUE target;
3734 target = _global_vresult_address == &vresult ? self : vresult;
3735 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3736 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3737 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3738 }
3739 return vresult;
3740 fail:
3741 {
3742 VALUE target;
3743 target = _global_vresult_address == &vresult ? self : vresult;
3744 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3745 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3746 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3747 }
3748 return Qnil;
3749 }
3750
3751
3752 SWIGINTERN VALUE
_wrap_svn_txdelta_send_stream(int argc,VALUE * argv,VALUE self)3753 _wrap_svn_txdelta_send_stream(int argc, VALUE *argv, VALUE self) {
3754 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
3755 svn_txdelta_window_handler_t arg2 = (svn_txdelta_window_handler_t) 0 ;
3756 void *arg3 = (void *) 0 ;
3757 unsigned char *arg4 = (unsigned char *) 0 ;
3758 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
3759 VALUE _global_svn_swig_rb_pool ;
3760 apr_pool_t *_global_pool ;
3761 unsigned char temp4[APR_MD5_DIGESTSIZE] ;
3762 svn_error_t *result = 0 ;
3763 VALUE vresult = Qnil;
3764
3765 {
3766 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
3767 _global_pool = arg5;
3768 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
3769 }
3770 arg4 = temp4;
3771 if ((argc < 2) || (argc > 3)) {
3772 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3773 }
3774 {
3775 arg1 = svn_swig_rb_make_stream(argv[0]);
3776 }
3777 {
3778 if (RTEST(rb_obj_is_kind_of(argv[1],
3779 svn_swig_rb_svn_delta_text_delta_window_handler()))) {
3780 arg2 = svn_swig_rb_to_swig_type(argv[1],
3781 "svn_txdelta_window_handler_t",
3782 _global_pool);
3783 arg3 = svn_swig_rb_to_swig_type(rb_funcall(argv[1], rb_intern("baton"), 0),
3784 "void *", _global_pool);
3785 } else {
3786 arg2 = svn_swig_rb_txdelta_window_handler;
3787 arg3 = (void *)svn_swig_rb_make_baton(argv[1], _global_svn_swig_rb_pool);
3788 }
3789 }
3790 if (argc > 2) {
3791
3792 }
3793 {
3794 result = (svn_error_t *)svn_txdelta_send_stream(arg1,arg2,arg3,arg4,arg5);
3795
3796
3797
3798 }
3799 {
3800 if (result) {
3801 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3802 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3803 svn_swig_rb_handle_svn_error(result);
3804 }
3805 vresult = Qnil;
3806 }
3807 {
3808 char *digest_string = (char *)svn_md5_digest_to_cstring(arg4, _global_pool);
3809 vresult = SWIG_Ruby_AppendOutput(vresult, rb_str_new2(digest_string ? digest_string : ""));
3810 }
3811 {
3812 VALUE target;
3813 target = _global_vresult_address == &vresult ? self : vresult;
3814 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3815 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3816 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3817 }
3818 return vresult;
3819 fail:
3820 {
3821 VALUE target;
3822 target = _global_vresult_address == &vresult ? self : vresult;
3823 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3824 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3825 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3826 }
3827 return Qnil;
3828 }
3829
3830
3831 SWIGINTERN VALUE
_wrap_svn_txdelta_send_txstream(int argc,VALUE * argv,VALUE self)3832 _wrap_svn_txdelta_send_txstream(int argc, VALUE *argv, VALUE self) {
3833 svn_txdelta_stream_t *arg1 = (svn_txdelta_stream_t *) 0 ;
3834 svn_txdelta_window_handler_t arg2 = (svn_txdelta_window_handler_t) 0 ;
3835 void *arg3 = (void *) 0 ;
3836 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
3837 VALUE _global_svn_swig_rb_pool ;
3838 apr_pool_t *_global_pool ;
3839 void *argp1 = 0 ;
3840 int res1 = 0 ;
3841 svn_error_t *result = 0 ;
3842 VALUE vresult = Qnil;
3843
3844 {
3845 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
3846 _global_pool = arg4;
3847 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
3848 }
3849 if ((argc < 2) || (argc > 3)) {
3850 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3851 }
3852 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_txdelta_stream_t, 0 | 0 );
3853 if (!SWIG_IsOK(res1)) {
3854 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_txdelta_stream_t *","svn_txdelta_send_txstream", 1, argv[0] ));
3855 }
3856 arg1 = (svn_txdelta_stream_t *)(argp1);
3857 {
3858 if (RTEST(rb_obj_is_kind_of(argv[1],
3859 svn_swig_rb_svn_delta_text_delta_window_handler()))) {
3860 arg2 = svn_swig_rb_to_swig_type(argv[1],
3861 "svn_txdelta_window_handler_t",
3862 _global_pool);
3863 arg3 = svn_swig_rb_to_swig_type(rb_funcall(argv[1], rb_intern("baton"), 0),
3864 "void *", _global_pool);
3865 } else {
3866 arg2 = svn_swig_rb_txdelta_window_handler;
3867 arg3 = (void *)svn_swig_rb_make_baton(argv[1], _global_svn_swig_rb_pool);
3868 }
3869 }
3870 if (argc > 2) {
3871
3872 }
3873 {
3874 result = (svn_error_t *)svn_txdelta_send_txstream(arg1,arg2,arg3,arg4);
3875
3876
3877
3878 }
3879 {
3880 if (result) {
3881 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3882 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3883 svn_swig_rb_handle_svn_error(result);
3884 }
3885 vresult = Qnil;
3886 }
3887 {
3888 VALUE target;
3889 target = _global_vresult_address == &vresult ? self : vresult;
3890 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3891 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3892 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3893 }
3894 return vresult;
3895 fail:
3896 {
3897 VALUE target;
3898 target = _global_vresult_address == &vresult ? self : vresult;
3899 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3900 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3901 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3902 }
3903 return Qnil;
3904 }
3905
3906
3907 SWIGINTERN VALUE
_wrap_svn_txdelta_send_contents(int argc,VALUE * argv,VALUE self)3908 _wrap_svn_txdelta_send_contents(int argc, VALUE *argv, VALUE self) {
3909 unsigned char *arg1 = (unsigned char *) 0 ;
3910 apr_size_t arg2 ;
3911 svn_txdelta_window_handler_t arg3 = (svn_txdelta_window_handler_t) 0 ;
3912 void *arg4 = (void *) 0 ;
3913 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
3914 VALUE _global_svn_swig_rb_pool ;
3915 apr_pool_t *_global_pool ;
3916 void *argp1 = 0 ;
3917 int res1 = 0 ;
3918 unsigned long val2 ;
3919 int ecode2 = 0 ;
3920 svn_error_t *result = 0 ;
3921 VALUE vresult = Qnil;
3922
3923 {
3924 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
3925 _global_pool = arg5;
3926 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
3927 }
3928 if ((argc < 3) || (argc > 4)) {
3929 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
3930 }
3931 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_unsigned_char, 0 | 0 );
3932 if (!SWIG_IsOK(res1)) {
3933 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "unsigned char const *","svn_txdelta_send_contents", 1, argv[0] ));
3934 }
3935 arg1 = (unsigned char *)(argp1);
3936 ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
3937 if (!SWIG_IsOK(ecode2)) {
3938 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "apr_size_t","svn_txdelta_send_contents", 2, argv[1] ));
3939 }
3940 arg2 = (apr_size_t)(val2);
3941 {
3942 if (RTEST(rb_obj_is_kind_of(argv[2],
3943 svn_swig_rb_svn_delta_text_delta_window_handler()))) {
3944 arg3 = svn_swig_rb_to_swig_type(argv[2],
3945 "svn_txdelta_window_handler_t",
3946 _global_pool);
3947 arg4 = svn_swig_rb_to_swig_type(rb_funcall(argv[2], rb_intern("baton"), 0),
3948 "void *", _global_pool);
3949 } else {
3950 arg3 = svn_swig_rb_txdelta_window_handler;
3951 arg4 = (void *)svn_swig_rb_make_baton(argv[2], _global_svn_swig_rb_pool);
3952 }
3953 }
3954 if (argc > 3) {
3955
3956 }
3957 {
3958 result = (svn_error_t *)svn_txdelta_send_contents((unsigned char const *)arg1,arg2,arg3,arg4,arg5);
3959
3960
3961
3962 }
3963 {
3964 if (result) {
3965 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3966 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3967 svn_swig_rb_handle_svn_error(result);
3968 }
3969 vresult = Qnil;
3970 }
3971 {
3972 VALUE target;
3973 target = _global_vresult_address == &vresult ? self : vresult;
3974 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3975 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3976 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3977 }
3978 return vresult;
3979 fail:
3980 {
3981 VALUE target;
3982 target = _global_vresult_address == &vresult ? self : vresult;
3983 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
3984 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
3985 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
3986 }
3987 return Qnil;
3988 }
3989
3990
3991 SWIGINTERN VALUE
_wrap_svn_txdelta_apply(int argc,VALUE * argv,VALUE self)3992 _wrap_svn_txdelta_apply(int argc, VALUE *argv, VALUE self) {
3993 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
3994 svn_stream_t *arg2 = (svn_stream_t *) 0 ;
3995 unsigned char *arg3 = (unsigned char *) 0 ;
3996 char *arg4 = (char *) 0 ;
3997 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
3998 svn_txdelta_window_handler_t *arg6 = (svn_txdelta_window_handler_t *) 0 ;
3999 void **arg7 = (void **) 0 ;
4000 VALUE _global_svn_swig_rb_pool ;
4001 apr_pool_t *_global_pool ;
4002 svn_txdelta_window_handler_t temp6 ;
4003 void *temp7 ;
4004 VALUE vresult = Qnil;
4005
4006 {
4007 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
4008 _global_pool = arg5;
4009 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
4010 }
4011 arg3 = NULL;
4012 arg6 = &temp6;
4013 arg7 = &temp7;
4014 if ((argc < 3) || (argc > 4)) {
4015 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
4016 }
4017 {
4018 arg1 = svn_swig_rb_make_stream(argv[0]);
4019 }
4020 {
4021 arg2 = svn_swig_rb_make_stream(argv[1]);
4022 }
4023 {
4024 if (NIL_P(argv[2])) {
4025 arg4 = NULL;
4026 } else {
4027 arg4 = StringValuePtr(argv[2]);
4028 }
4029 }
4030 if (argc > 3) {
4031
4032 }
4033 {
4034 svn_txdelta_apply(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7);
4035
4036
4037
4038 }
4039 vresult = rb_ary_new();
4040 {
4041 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg6, SWIGTYPE_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, 0));
4042 }
4043 {
4044 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg7, SWIGTYPE_p_void, 0));
4045 }
4046 {
4047 VALUE target;
4048 target = _global_vresult_address == &vresult ? self : vresult;
4049 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
4050 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4051 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4052 }
4053 return vresult;
4054 fail:
4055 {
4056 VALUE target;
4057 target = _global_vresult_address == &vresult ? self : vresult;
4058 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
4059 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4060 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4061 }
4062 return Qnil;
4063 }
4064
4065
4066 SWIGINTERN VALUE
_wrap_svn_txdelta_to_svndiff3(int argc,VALUE * argv,VALUE self)4067 _wrap_svn_txdelta_to_svndiff3(int argc, VALUE *argv, VALUE self) {
4068 svn_txdelta_window_handler_t *arg1 = (svn_txdelta_window_handler_t *) 0 ;
4069 void **arg2 = (void **) 0 ;
4070 svn_stream_t *arg3 = (svn_stream_t *) 0 ;
4071 int arg4 ;
4072 int arg5 ;
4073 apr_pool_t *arg6 = (apr_pool_t *) 0 ;
4074 VALUE _global_svn_swig_rb_pool ;
4075 apr_pool_t *_global_pool ;
4076 svn_txdelta_window_handler_t temp1 ;
4077 void *temp2 ;
4078 int val4 ;
4079 int ecode4 = 0 ;
4080 int val5 ;
4081 int ecode5 = 0 ;
4082 VALUE vresult = Qnil;
4083
4084 {
4085 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg6);
4086 _global_pool = arg6;
4087 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
4088 }
4089 arg1 = &temp1;
4090 arg2 = &temp2;
4091 if ((argc < 3) || (argc > 4)) {
4092 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
4093 }
4094 {
4095 arg3 = svn_swig_rb_make_stream(argv[0]);
4096 }
4097 ecode4 = SWIG_AsVal_int(argv[1], &val4);
4098 if (!SWIG_IsOK(ecode4)) {
4099 SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","svn_txdelta_to_svndiff3", 4, argv[1] ));
4100 }
4101 arg4 = (int)(val4);
4102 ecode5 = SWIG_AsVal_int(argv[2], &val5);
4103 if (!SWIG_IsOK(ecode5)) {
4104 SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","svn_txdelta_to_svndiff3", 5, argv[2] ));
4105 }
4106 arg5 = (int)(val5);
4107 if (argc > 3) {
4108
4109 }
4110 {
4111 svn_txdelta_to_svndiff3(arg1,arg2,arg3,arg4,arg5,arg6);
4112
4113
4114
4115 }
4116 vresult = rb_ary_new();
4117 {
4118 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, 0));
4119 }
4120 {
4121 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_void, 0));
4122 }
4123 {
4124 VALUE target;
4125 target = _global_vresult_address == &vresult ? self : vresult;
4126 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
4127 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4128 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4129 }
4130 return vresult;
4131 fail:
4132 {
4133 VALUE target;
4134 target = _global_vresult_address == &vresult ? self : vresult;
4135 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
4136 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4137 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4138 }
4139 return Qnil;
4140 }
4141
4142
4143 SWIGINTERN VALUE
_wrap_svn_txdelta_to_svndiff2(int argc,VALUE * argv,VALUE self)4144 _wrap_svn_txdelta_to_svndiff2(int argc, VALUE *argv, VALUE self) {
4145 svn_txdelta_window_handler_t *arg1 = (svn_txdelta_window_handler_t *) 0 ;
4146 void **arg2 = (void **) 0 ;
4147 svn_stream_t *arg3 = (svn_stream_t *) 0 ;
4148 int arg4 ;
4149 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
4150 VALUE _global_svn_swig_rb_pool ;
4151 apr_pool_t *_global_pool ;
4152 svn_txdelta_window_handler_t temp1 ;
4153 void *temp2 ;
4154 int val4 ;
4155 int ecode4 = 0 ;
4156 VALUE vresult = Qnil;
4157
4158 {
4159 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
4160 _global_pool = arg5;
4161 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
4162 }
4163 arg1 = &temp1;
4164 arg2 = &temp2;
4165 if ((argc < 2) || (argc > 3)) {
4166 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
4167 }
4168 {
4169 arg3 = svn_swig_rb_make_stream(argv[0]);
4170 }
4171 ecode4 = SWIG_AsVal_int(argv[1], &val4);
4172 if (!SWIG_IsOK(ecode4)) {
4173 SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","svn_txdelta_to_svndiff2", 4, argv[1] ));
4174 }
4175 arg4 = (int)(val4);
4176 if (argc > 2) {
4177
4178 }
4179 {
4180 svn_txdelta_to_svndiff2(arg1,arg2,arg3,arg4,arg5);
4181
4182
4183
4184 }
4185 vresult = rb_ary_new();
4186 {
4187 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, 0));
4188 }
4189 {
4190 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_void, 0));
4191 }
4192 {
4193 VALUE target;
4194 target = _global_vresult_address == &vresult ? self : vresult;
4195 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
4196 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4197 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4198 }
4199 return vresult;
4200 fail:
4201 {
4202 VALUE target;
4203 target = _global_vresult_address == &vresult ? self : vresult;
4204 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
4205 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4206 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4207 }
4208 return Qnil;
4209 }
4210
4211
4212 SWIGINTERN VALUE
_wrap_svn_txdelta_to_svndiff(int argc,VALUE * argv,VALUE self)4213 _wrap_svn_txdelta_to_svndiff(int argc, VALUE *argv, VALUE self) {
4214 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
4215 apr_pool_t *arg2 = (apr_pool_t *) 0 ;
4216 svn_txdelta_window_handler_t *arg3 = (svn_txdelta_window_handler_t *) 0 ;
4217 void **arg4 = (void **) 0 ;
4218 VALUE _global_svn_swig_rb_pool ;
4219 apr_pool_t *_global_pool ;
4220 svn_txdelta_window_handler_t temp3 ;
4221 void *temp4 ;
4222 VALUE vresult = Qnil;
4223
4224 {
4225 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg2);
4226 _global_pool = arg2;
4227 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
4228 }
4229 arg3 = &temp3;
4230 arg4 = &temp4;
4231 if ((argc < 1) || (argc > 2)) {
4232 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4233 }
4234 {
4235 arg1 = svn_swig_rb_make_stream(argv[0]);
4236 }
4237 if (argc > 1) {
4238
4239 }
4240 {
4241 svn_txdelta_to_svndiff(arg1,arg2,arg3,arg4);
4242
4243
4244
4245 }
4246 vresult = rb_ary_new();
4247 {
4248 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg3, SWIGTYPE_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, 0));
4249 }
4250 {
4251 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg4, SWIGTYPE_p_void, 0));
4252 }
4253 {
4254 VALUE target;
4255 target = _global_vresult_address == &vresult ? self : vresult;
4256 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
4257 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4258 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4259 }
4260 return vresult;
4261 fail:
4262 {
4263 VALUE target;
4264 target = _global_vresult_address == &vresult ? self : vresult;
4265 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
4266 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4267 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4268 }
4269 return Qnil;
4270 }
4271
4272
4273 SWIGINTERN VALUE
_wrap_svn_txdelta_to_svndiff_stream(int argc,VALUE * argv,VALUE self)4274 _wrap_svn_txdelta_to_svndiff_stream(int argc, VALUE *argv, VALUE self) {
4275 svn_txdelta_stream_t *arg1 = (svn_txdelta_stream_t *) 0 ;
4276 int arg2 ;
4277 int arg3 ;
4278 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
4279 VALUE _global_svn_swig_rb_pool ;
4280 apr_pool_t *_global_pool ;
4281 void *argp1 = 0 ;
4282 int res1 = 0 ;
4283 int val2 ;
4284 int ecode2 = 0 ;
4285 int val3 ;
4286 int ecode3 = 0 ;
4287 svn_stream_t *result = 0 ;
4288 VALUE vresult = Qnil;
4289
4290 {
4291 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
4292 _global_pool = arg4;
4293 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
4294 }
4295 if ((argc < 3) || (argc > 4)) {
4296 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
4297 }
4298 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_txdelta_stream_t, 0 | 0 );
4299 if (!SWIG_IsOK(res1)) {
4300 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_txdelta_stream_t *","svn_txdelta_to_svndiff_stream", 1, argv[0] ));
4301 }
4302 arg1 = (svn_txdelta_stream_t *)(argp1);
4303 ecode2 = SWIG_AsVal_int(argv[1], &val2);
4304 if (!SWIG_IsOK(ecode2)) {
4305 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","svn_txdelta_to_svndiff_stream", 2, argv[1] ));
4306 }
4307 arg2 = (int)(val2);
4308 ecode3 = SWIG_AsVal_int(argv[2], &val3);
4309 if (!SWIG_IsOK(ecode3)) {
4310 SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","svn_txdelta_to_svndiff_stream", 3, argv[2] ));
4311 }
4312 arg3 = (int)(val3);
4313 if (argc > 3) {
4314
4315 }
4316 {
4317 result = (svn_stream_t *)svn_txdelta_to_svndiff_stream(arg1,arg2,arg3,arg4);
4318
4319
4320
4321 }
4322 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_svn_stream_t, 0 | 0 );
4323 {
4324 VALUE target;
4325 target = _global_vresult_address == &vresult ? self : vresult;
4326 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
4327 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4328 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4329 }
4330 return vresult;
4331 fail:
4332 {
4333 VALUE target;
4334 target = _global_vresult_address == &vresult ? self : vresult;
4335 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
4336 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4337 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4338 }
4339 return Qnil;
4340 }
4341
4342
4343 SWIGINTERN VALUE
_wrap_svn_txdelta_parse_svndiff(int argc,VALUE * argv,VALUE self)4344 _wrap_svn_txdelta_parse_svndiff(int argc, VALUE *argv, VALUE self) {
4345 svn_txdelta_window_handler_t arg1 = (svn_txdelta_window_handler_t) 0 ;
4346 void *arg2 = (void *) 0 ;
4347 svn_boolean_t arg3 ;
4348 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
4349 VALUE _global_svn_swig_rb_pool ;
4350 apr_pool_t *_global_pool ;
4351 svn_stream_t *result = 0 ;
4352 VALUE vresult = Qnil;
4353
4354 {
4355 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
4356 _global_pool = arg4;
4357 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
4358 }
4359 if ((argc < 2) || (argc > 3)) {
4360 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
4361 }
4362 {
4363 if (RTEST(rb_obj_is_kind_of(argv[0],
4364 svn_swig_rb_svn_delta_text_delta_window_handler()))) {
4365 arg1 = svn_swig_rb_to_swig_type(argv[0],
4366 "svn_txdelta_window_handler_t",
4367 _global_pool);
4368 arg2 = svn_swig_rb_to_swig_type(rb_funcall(argv[0], rb_intern("baton"), 0),
4369 "void *", _global_pool);
4370 } else {
4371 arg1 = svn_swig_rb_txdelta_window_handler;
4372 arg2 = (void *)svn_swig_rb_make_baton(argv[0], _global_svn_swig_rb_pool);
4373 }
4374 }
4375 arg3 = RTEST(argv[1]);
4376 if (argc > 2) {
4377
4378 }
4379 {
4380 result = (svn_stream_t *)svn_txdelta_parse_svndiff(arg1,arg2,arg3,arg4);
4381
4382
4383
4384 }
4385 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_svn_stream_t, 0 | 0 );
4386 {
4387 VALUE target;
4388 target = _global_vresult_address == &vresult ? self : vresult;
4389 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
4390 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4391 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4392 }
4393 return vresult;
4394 fail:
4395 {
4396 VALUE target;
4397 target = _global_vresult_address == &vresult ? self : vresult;
4398 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
4399 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4400 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4401 }
4402 return Qnil;
4403 }
4404
4405
4406 SWIGINTERN VALUE
_wrap_svn_txdelta_read_svndiff_window(int argc,VALUE * argv,VALUE self)4407 _wrap_svn_txdelta_read_svndiff_window(int argc, VALUE *argv, VALUE self) {
4408 svn_txdelta_window_t **arg1 = (svn_txdelta_window_t **) 0 ;
4409 svn_stream_t *arg2 = (svn_stream_t *) 0 ;
4410 int arg3 ;
4411 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
4412 VALUE _global_svn_swig_rb_pool ;
4413 apr_pool_t *_global_pool ;
4414 svn_txdelta_window_t *temp1 ;
4415 int val3 ;
4416 int ecode3 = 0 ;
4417 svn_error_t *result = 0 ;
4418 VALUE vresult = Qnil;
4419
4420 {
4421 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
4422 _global_pool = arg4;
4423 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
4424 }
4425 arg1 = &temp1;
4426 if ((argc < 2) || (argc > 3)) {
4427 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
4428 }
4429 {
4430 arg2 = svn_swig_rb_make_stream(argv[0]);
4431 }
4432 ecode3 = SWIG_AsVal_int(argv[1], &val3);
4433 if (!SWIG_IsOK(ecode3)) {
4434 SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","svn_txdelta_read_svndiff_window", 3, argv[1] ));
4435 }
4436 arg3 = (int)(val3);
4437 if (argc > 2) {
4438
4439 }
4440 {
4441 result = (svn_error_t *)svn_txdelta_read_svndiff_window(arg1,arg2,arg3,arg4);
4442
4443
4444
4445 }
4446 {
4447 if (result) {
4448 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4449 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4450 svn_swig_rb_handle_svn_error(result);
4451 }
4452 vresult = Qnil;
4453 }
4454 {
4455 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_txdelta_window_t, 0));
4456 }
4457 {
4458 VALUE target;
4459 target = _global_vresult_address == &vresult ? self : vresult;
4460 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
4461 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4462 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4463 }
4464 return vresult;
4465 fail:
4466 {
4467 VALUE target;
4468 target = _global_vresult_address == &vresult ? self : vresult;
4469 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
4470 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4471 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4472 }
4473 return Qnil;
4474 }
4475
4476
4477 SWIGINTERN VALUE
_wrap_svn_txdelta_skip_svndiff_window(int argc,VALUE * argv,VALUE self)4478 _wrap_svn_txdelta_skip_svndiff_window(int argc, VALUE *argv, VALUE self) {
4479 apr_file_t *arg1 = (apr_file_t *) 0 ;
4480 int arg2 ;
4481 apr_pool_t *arg3 = (apr_pool_t *) 0 ;
4482 VALUE _global_svn_swig_rb_pool ;
4483 apr_pool_t *_global_pool ;
4484 int val2 ;
4485 int ecode2 = 0 ;
4486 svn_error_t *result = 0 ;
4487 VALUE vresult = Qnil;
4488
4489 {
4490 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
4491 _global_pool = arg3;
4492 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
4493 }
4494 if ((argc < 2) || (argc > 3)) {
4495 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
4496 }
4497 {
4498 arg1 = svn_swig_rb_make_file(argv[0], _global_pool);
4499 }
4500 ecode2 = SWIG_AsVal_int(argv[1], &val2);
4501 if (!SWIG_IsOK(ecode2)) {
4502 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","svn_txdelta_skip_svndiff_window", 2, argv[1] ));
4503 }
4504 arg2 = (int)(val2);
4505 if (argc > 2) {
4506
4507 }
4508 {
4509 result = (svn_error_t *)svn_txdelta_skip_svndiff_window(arg1,arg2,arg3);
4510
4511
4512
4513 }
4514 {
4515 if (result) {
4516 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4517 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4518 svn_swig_rb_handle_svn_error(result);
4519 }
4520 vresult = Qnil;
4521 }
4522 {
4523 VALUE target;
4524 target = _global_vresult_address == &vresult ? self : vresult;
4525 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
4526 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4527 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4528 }
4529 return vresult;
4530 fail:
4531 {
4532 VALUE target;
4533 target = _global_vresult_address == &vresult ? self : vresult;
4534 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
4535 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
4536 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
4537 }
4538 return Qnil;
4539 }
4540
4541
4542 static swig_class SwigClassSvn_delta_editor_t;
4543
4544 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_set_target_revision_set(int argc,VALUE * argv,VALUE self)4545 _wrap_svn_delta_editor_t_set_target_revision_set(int argc, VALUE *argv, VALUE self) {
4546 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4547 svn_error_t *(*arg2)(void *,svn_revnum_t,apr_pool_t *) = (svn_error_t *(*)(void *,svn_revnum_t,apr_pool_t *)) 0 ;
4548 void *argp1 = 0 ;
4549 int res1 = 0 ;
4550
4551 if ((argc < 1) || (argc > 1)) {
4552 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4553 }
4554 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
4555 if (!SWIG_IsOK(res1)) {
4556 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","set_target_revision", 1, self ));
4557 }
4558 arg1 = (struct svn_delta_editor_t *)(argp1);
4559 {
4560 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_void_svn_revnum_t_p_apr_pool_t__p_svn_error_t);
4561 if (!SWIG_IsOK(res)) {
4562 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(void *,svn_revnum_t,apr_pool_t *)","set_target_revision", 2, argv[0] ));
4563 }
4564 }
4565 if (arg1) (arg1)->set_target_revision = arg2;
4566 return Qnil;
4567 fail:
4568 return Qnil;
4569 }
4570
4571
4572 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_set_target_revision_get(int argc,VALUE * argv,VALUE self)4573 _wrap_svn_delta_editor_t_set_target_revision_get(int argc, VALUE *argv, VALUE self) {
4574 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4575 void *argp1 = 0 ;
4576 int res1 = 0 ;
4577 svn_error_t *(*result)(void *,svn_revnum_t,apr_pool_t *) = 0 ;
4578 VALUE vresult = Qnil;
4579
4580 if ((argc < 0) || (argc > 0)) {
4581 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4582 }
4583 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
4584 if (!SWIG_IsOK(res1)) {
4585 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","set_target_revision", 1, self ));
4586 }
4587 arg1 = (struct svn_delta_editor_t *)(argp1);
4588 result = (svn_error_t *(*)(void *,svn_revnum_t,apr_pool_t *)) ((arg1)->set_target_revision);
4589 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_svn_revnum_t_p_apr_pool_t__p_svn_error_t);
4590 return vresult;
4591 fail:
4592 return Qnil;
4593 }
4594
4595
4596 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_open_root_set(int argc,VALUE * argv,VALUE self)4597 _wrap_svn_delta_editor_t_open_root_set(int argc, VALUE *argv, VALUE self) {
4598 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4599 svn_error_t *(*arg2)(void *,svn_revnum_t,apr_pool_t *,void **) = (svn_error_t *(*)(void *,svn_revnum_t,apr_pool_t *,void **)) 0 ;
4600 void *argp1 = 0 ;
4601 int res1 = 0 ;
4602
4603 if ((argc < 1) || (argc > 1)) {
4604 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4605 }
4606 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
4607 if (!SWIG_IsOK(res1)) {
4608 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","open_root", 1, self ));
4609 }
4610 arg1 = (struct svn_delta_editor_t *)(argp1);
4611 {
4612 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t);
4613 if (!SWIG_IsOK(res)) {
4614 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(void *,svn_revnum_t,apr_pool_t *,void **)","open_root", 2, argv[0] ));
4615 }
4616 }
4617 if (arg1) (arg1)->open_root = arg2;
4618 return Qnil;
4619 fail:
4620 return Qnil;
4621 }
4622
4623
4624 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_open_root_get(int argc,VALUE * argv,VALUE self)4625 _wrap_svn_delta_editor_t_open_root_get(int argc, VALUE *argv, VALUE self) {
4626 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4627 void *argp1 = 0 ;
4628 int res1 = 0 ;
4629 svn_error_t *(*result)(void *,svn_revnum_t,apr_pool_t *,void **) = 0 ;
4630 VALUE vresult = Qnil;
4631
4632 if ((argc < 0) || (argc > 0)) {
4633 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4634 }
4635 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
4636 if (!SWIG_IsOK(res1)) {
4637 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","open_root", 1, self ));
4638 }
4639 arg1 = (struct svn_delta_editor_t *)(argp1);
4640 result = (svn_error_t *(*)(void *,svn_revnum_t,apr_pool_t *,void **)) ((arg1)->open_root);
4641 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t);
4642 return vresult;
4643 fail:
4644 return Qnil;
4645 }
4646
4647
4648 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_delete_entry_set(int argc,VALUE * argv,VALUE self)4649 _wrap_svn_delta_editor_t_delete_entry_set(int argc, VALUE *argv, VALUE self) {
4650 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4651 svn_error_t *(*arg2)(char const *,svn_revnum_t,void *,apr_pool_t *) = (svn_error_t *(*)(char const *,svn_revnum_t,void *,apr_pool_t *)) 0 ;
4652 void *argp1 = 0 ;
4653 int res1 = 0 ;
4654
4655 if ((argc < 1) || (argc > 1)) {
4656 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4657 }
4658 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
4659 if (!SWIG_IsOK(res1)) {
4660 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","delete_entry", 1, self ));
4661 }
4662 arg1 = (struct svn_delta_editor_t *)(argp1);
4663 {
4664 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char_svn_revnum_t_p_void_p_apr_pool_t__p_svn_error_t);
4665 if (!SWIG_IsOK(res)) {
4666 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(char const *,svn_revnum_t,void *,apr_pool_t *)","delete_entry", 2, argv[0] ));
4667 }
4668 }
4669 if (arg1) (arg1)->delete_entry = arg2;
4670 return Qnil;
4671 fail:
4672 return Qnil;
4673 }
4674
4675
4676 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_delete_entry_get(int argc,VALUE * argv,VALUE self)4677 _wrap_svn_delta_editor_t_delete_entry_get(int argc, VALUE *argv, VALUE self) {
4678 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4679 void *argp1 = 0 ;
4680 int res1 = 0 ;
4681 svn_error_t *(*result)(char const *,svn_revnum_t,void *,apr_pool_t *) = 0 ;
4682 VALUE vresult = Qnil;
4683
4684 if ((argc < 0) || (argc > 0)) {
4685 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4686 }
4687 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
4688 if (!SWIG_IsOK(res1)) {
4689 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","delete_entry", 1, self ));
4690 }
4691 arg1 = (struct svn_delta_editor_t *)(argp1);
4692 result = (svn_error_t *(*)(char const *,svn_revnum_t,void *,apr_pool_t *)) ((arg1)->delete_entry);
4693 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_svn_revnum_t_p_void_p_apr_pool_t__p_svn_error_t);
4694 return vresult;
4695 fail:
4696 return Qnil;
4697 }
4698
4699
4700 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_add_directory_set(int argc,VALUE * argv,VALUE self)4701 _wrap_svn_delta_editor_t_add_directory_set(int argc, VALUE *argv, VALUE self) {
4702 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4703 svn_error_t *(*arg2)(char const *,void *,char const *,svn_revnum_t,apr_pool_t *,void **) = (svn_error_t *(*)(char const *,void *,char const *,svn_revnum_t,apr_pool_t *,void **)) 0 ;
4704 void *argp1 = 0 ;
4705 int res1 = 0 ;
4706
4707 if ((argc < 1) || (argc > 1)) {
4708 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4709 }
4710 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
4711 if (!SWIG_IsOK(res1)) {
4712 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","add_directory", 1, self ));
4713 }
4714 arg1 = (struct svn_delta_editor_t *)(argp1);
4715 {
4716 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t);
4717 if (!SWIG_IsOK(res)) {
4718 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(char const *,void *,char const *,svn_revnum_t,apr_pool_t *,void **)","add_directory", 2, argv[0] ));
4719 }
4720 }
4721 if (arg1) (arg1)->add_directory = arg2;
4722 return Qnil;
4723 fail:
4724 return Qnil;
4725 }
4726
4727
4728 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_add_directory_get(int argc,VALUE * argv,VALUE self)4729 _wrap_svn_delta_editor_t_add_directory_get(int argc, VALUE *argv, VALUE self) {
4730 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4731 void *argp1 = 0 ;
4732 int res1 = 0 ;
4733 svn_error_t *(*result)(char const *,void *,char const *,svn_revnum_t,apr_pool_t *,void **) = 0 ;
4734 VALUE vresult = Qnil;
4735
4736 if ((argc < 0) || (argc > 0)) {
4737 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4738 }
4739 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
4740 if (!SWIG_IsOK(res1)) {
4741 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","add_directory", 1, self ));
4742 }
4743 arg1 = (struct svn_delta_editor_t *)(argp1);
4744 result = (svn_error_t *(*)(char const *,void *,char const *,svn_revnum_t,apr_pool_t *,void **)) ((arg1)->add_directory);
4745 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t);
4746 return vresult;
4747 fail:
4748 return Qnil;
4749 }
4750
4751
4752 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_open_directory_set(int argc,VALUE * argv,VALUE self)4753 _wrap_svn_delta_editor_t_open_directory_set(int argc, VALUE *argv, VALUE self) {
4754 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4755 svn_error_t *(*arg2)(char const *,void *,svn_revnum_t,apr_pool_t *,void **) = (svn_error_t *(*)(char const *,void *,svn_revnum_t,apr_pool_t *,void **)) 0 ;
4756 void *argp1 = 0 ;
4757 int res1 = 0 ;
4758
4759 if ((argc < 1) || (argc > 1)) {
4760 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4761 }
4762 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
4763 if (!SWIG_IsOK(res1)) {
4764 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","open_directory", 1, self ));
4765 }
4766 arg1 = (struct svn_delta_editor_t *)(argp1);
4767 {
4768 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t);
4769 if (!SWIG_IsOK(res)) {
4770 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(char const *,void *,svn_revnum_t,apr_pool_t *,void **)","open_directory", 2, argv[0] ));
4771 }
4772 }
4773 if (arg1) (arg1)->open_directory = arg2;
4774 return Qnil;
4775 fail:
4776 return Qnil;
4777 }
4778
4779
4780 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_open_directory_get(int argc,VALUE * argv,VALUE self)4781 _wrap_svn_delta_editor_t_open_directory_get(int argc, VALUE *argv, VALUE self) {
4782 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4783 void *argp1 = 0 ;
4784 int res1 = 0 ;
4785 svn_error_t *(*result)(char const *,void *,svn_revnum_t,apr_pool_t *,void **) = 0 ;
4786 VALUE vresult = Qnil;
4787
4788 if ((argc < 0) || (argc > 0)) {
4789 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4790 }
4791 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
4792 if (!SWIG_IsOK(res1)) {
4793 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","open_directory", 1, self ));
4794 }
4795 arg1 = (struct svn_delta_editor_t *)(argp1);
4796 result = (svn_error_t *(*)(char const *,void *,svn_revnum_t,apr_pool_t *,void **)) ((arg1)->open_directory);
4797 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t);
4798 return vresult;
4799 fail:
4800 return Qnil;
4801 }
4802
4803
4804 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_change_dir_prop_set(int argc,VALUE * argv,VALUE self)4805 _wrap_svn_delta_editor_t_change_dir_prop_set(int argc, VALUE *argv, VALUE self) {
4806 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4807 svn_error_t *(*arg2)(void *,char const *,svn_string_t const *,apr_pool_t *) = (svn_error_t *(*)(void *,char const *,svn_string_t const *,apr_pool_t *)) 0 ;
4808 void *argp1 = 0 ;
4809 int res1 = 0 ;
4810
4811 if ((argc < 1) || (argc > 1)) {
4812 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4813 }
4814 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
4815 if (!SWIG_IsOK(res1)) {
4816 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","change_dir_prop", 1, self ));
4817 }
4818 arg1 = (struct svn_delta_editor_t *)(argp1);
4819 {
4820 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t_p_apr_pool_t__p_svn_error_t);
4821 if (!SWIG_IsOK(res)) {
4822 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(void *,char const *,svn_string_t const *,apr_pool_t *)","change_dir_prop", 2, argv[0] ));
4823 }
4824 }
4825 if (arg1) (arg1)->change_dir_prop = arg2;
4826 return Qnil;
4827 fail:
4828 return Qnil;
4829 }
4830
4831
4832 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_change_dir_prop_get(int argc,VALUE * argv,VALUE self)4833 _wrap_svn_delta_editor_t_change_dir_prop_get(int argc, VALUE *argv, VALUE self) {
4834 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4835 void *argp1 = 0 ;
4836 int res1 = 0 ;
4837 svn_error_t *(*result)(void *,char const *,svn_string_t const *,apr_pool_t *) = 0 ;
4838 VALUE vresult = Qnil;
4839
4840 if ((argc < 0) || (argc > 0)) {
4841 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4842 }
4843 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
4844 if (!SWIG_IsOK(res1)) {
4845 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","change_dir_prop", 1, self ));
4846 }
4847 arg1 = (struct svn_delta_editor_t *)(argp1);
4848 result = (svn_error_t *(*)(void *,char const *,svn_string_t const *,apr_pool_t *)) ((arg1)->change_dir_prop);
4849 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t_p_apr_pool_t__p_svn_error_t);
4850 return vresult;
4851 fail:
4852 return Qnil;
4853 }
4854
4855
4856 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_close_directory_set(int argc,VALUE * argv,VALUE self)4857 _wrap_svn_delta_editor_t_close_directory_set(int argc, VALUE *argv, VALUE self) {
4858 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4859 svn_error_t *(*arg2)(void *,apr_pool_t *) = (svn_error_t *(*)(void *,apr_pool_t *)) 0 ;
4860 void *argp1 = 0 ;
4861 int res1 = 0 ;
4862
4863 if ((argc < 1) || (argc > 1)) {
4864 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4865 }
4866 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
4867 if (!SWIG_IsOK(res1)) {
4868 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","close_directory", 1, self ));
4869 }
4870 arg1 = (struct svn_delta_editor_t *)(argp1);
4871 {
4872 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_apr_pool_t__p_svn_error_t);
4873 if (!SWIG_IsOK(res)) {
4874 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(void *,apr_pool_t *)","close_directory", 2, argv[0] ));
4875 }
4876 }
4877 if (arg1) (arg1)->close_directory = arg2;
4878 return Qnil;
4879 fail:
4880 return Qnil;
4881 }
4882
4883
4884 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_close_directory_get(int argc,VALUE * argv,VALUE self)4885 _wrap_svn_delta_editor_t_close_directory_get(int argc, VALUE *argv, VALUE self) {
4886 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4887 void *argp1 = 0 ;
4888 int res1 = 0 ;
4889 svn_error_t *(*result)(void *,apr_pool_t *) = 0 ;
4890 VALUE vresult = Qnil;
4891
4892 if ((argc < 0) || (argc > 0)) {
4893 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4894 }
4895 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
4896 if (!SWIG_IsOK(res1)) {
4897 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","close_directory", 1, self ));
4898 }
4899 arg1 = (struct svn_delta_editor_t *)(argp1);
4900 result = (svn_error_t *(*)(void *,apr_pool_t *)) ((arg1)->close_directory);
4901 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_apr_pool_t__p_svn_error_t);
4902 return vresult;
4903 fail:
4904 return Qnil;
4905 }
4906
4907
4908 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_absent_directory_set(int argc,VALUE * argv,VALUE self)4909 _wrap_svn_delta_editor_t_absent_directory_set(int argc, VALUE *argv, VALUE self) {
4910 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4911 svn_error_t *(*arg2)(char const *,void *,apr_pool_t *) = (svn_error_t *(*)(char const *,void *,apr_pool_t *)) 0 ;
4912 void *argp1 = 0 ;
4913 int res1 = 0 ;
4914
4915 if ((argc < 1) || (argc > 1)) {
4916 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4917 }
4918 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
4919 if (!SWIG_IsOK(res1)) {
4920 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","absent_directory", 1, self ));
4921 }
4922 arg1 = (struct svn_delta_editor_t *)(argp1);
4923 {
4924 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t);
4925 if (!SWIG_IsOK(res)) {
4926 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(char const *,void *,apr_pool_t *)","absent_directory", 2, argv[0] ));
4927 }
4928 }
4929 if (arg1) (arg1)->absent_directory = arg2;
4930 return Qnil;
4931 fail:
4932 return Qnil;
4933 }
4934
4935
4936 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_absent_directory_get(int argc,VALUE * argv,VALUE self)4937 _wrap_svn_delta_editor_t_absent_directory_get(int argc, VALUE *argv, VALUE self) {
4938 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4939 void *argp1 = 0 ;
4940 int res1 = 0 ;
4941 svn_error_t *(*result)(char const *,void *,apr_pool_t *) = 0 ;
4942 VALUE vresult = Qnil;
4943
4944 if ((argc < 0) || (argc > 0)) {
4945 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4946 }
4947 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
4948 if (!SWIG_IsOK(res1)) {
4949 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","absent_directory", 1, self ));
4950 }
4951 arg1 = (struct svn_delta_editor_t *)(argp1);
4952 result = (svn_error_t *(*)(char const *,void *,apr_pool_t *)) ((arg1)->absent_directory);
4953 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t);
4954 return vresult;
4955 fail:
4956 return Qnil;
4957 }
4958
4959
4960 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_add_file_set(int argc,VALUE * argv,VALUE self)4961 _wrap_svn_delta_editor_t_add_file_set(int argc, VALUE *argv, VALUE self) {
4962 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4963 svn_error_t *(*arg2)(char const *,void *,char const *,svn_revnum_t,apr_pool_t *,void **) = (svn_error_t *(*)(char const *,void *,char const *,svn_revnum_t,apr_pool_t *,void **)) 0 ;
4964 void *argp1 = 0 ;
4965 int res1 = 0 ;
4966
4967 if ((argc < 1) || (argc > 1)) {
4968 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4969 }
4970 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
4971 if (!SWIG_IsOK(res1)) {
4972 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","add_file", 1, self ));
4973 }
4974 arg1 = (struct svn_delta_editor_t *)(argp1);
4975 {
4976 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t);
4977 if (!SWIG_IsOK(res)) {
4978 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(char const *,void *,char const *,svn_revnum_t,apr_pool_t *,void **)","add_file", 2, argv[0] ));
4979 }
4980 }
4981 if (arg1) (arg1)->add_file = arg2;
4982 return Qnil;
4983 fail:
4984 return Qnil;
4985 }
4986
4987
4988 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_add_file_get(int argc,VALUE * argv,VALUE self)4989 _wrap_svn_delta_editor_t_add_file_get(int argc, VALUE *argv, VALUE self) {
4990 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
4991 void *argp1 = 0 ;
4992 int res1 = 0 ;
4993 svn_error_t *(*result)(char const *,void *,char const *,svn_revnum_t,apr_pool_t *,void **) = 0 ;
4994 VALUE vresult = Qnil;
4995
4996 if ((argc < 0) || (argc > 0)) {
4997 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4998 }
4999 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5000 if (!SWIG_IsOK(res1)) {
5001 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","add_file", 1, self ));
5002 }
5003 arg1 = (struct svn_delta_editor_t *)(argp1);
5004 result = (svn_error_t *(*)(char const *,void *,char const *,svn_revnum_t,apr_pool_t *,void **)) ((arg1)->add_file);
5005 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t);
5006 return vresult;
5007 fail:
5008 return Qnil;
5009 }
5010
5011
5012 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_open_file_set(int argc,VALUE * argv,VALUE self)5013 _wrap_svn_delta_editor_t_open_file_set(int argc, VALUE *argv, VALUE self) {
5014 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
5015 svn_error_t *(*arg2)(char const *,void *,svn_revnum_t,apr_pool_t *,void **) = (svn_error_t *(*)(char const *,void *,svn_revnum_t,apr_pool_t *,void **)) 0 ;
5016 void *argp1 = 0 ;
5017 int res1 = 0 ;
5018
5019 if ((argc < 1) || (argc > 1)) {
5020 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5021 }
5022 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5023 if (!SWIG_IsOK(res1)) {
5024 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","open_file", 1, self ));
5025 }
5026 arg1 = (struct svn_delta_editor_t *)(argp1);
5027 {
5028 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t);
5029 if (!SWIG_IsOK(res)) {
5030 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(char const *,void *,svn_revnum_t,apr_pool_t *,void **)","open_file", 2, argv[0] ));
5031 }
5032 }
5033 if (arg1) (arg1)->open_file = arg2;
5034 return Qnil;
5035 fail:
5036 return Qnil;
5037 }
5038
5039
5040 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_open_file_get(int argc,VALUE * argv,VALUE self)5041 _wrap_svn_delta_editor_t_open_file_get(int argc, VALUE *argv, VALUE self) {
5042 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
5043 void *argp1 = 0 ;
5044 int res1 = 0 ;
5045 svn_error_t *(*result)(char const *,void *,svn_revnum_t,apr_pool_t *,void **) = 0 ;
5046 VALUE vresult = Qnil;
5047
5048 if ((argc < 0) || (argc > 0)) {
5049 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5050 }
5051 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5052 if (!SWIG_IsOK(res1)) {
5053 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","open_file", 1, self ));
5054 }
5055 arg1 = (struct svn_delta_editor_t *)(argp1);
5056 result = (svn_error_t *(*)(char const *,void *,svn_revnum_t,apr_pool_t *,void **)) ((arg1)->open_file);
5057 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t);
5058 return vresult;
5059 fail:
5060 return Qnil;
5061 }
5062
5063
5064 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_apply_textdelta_set(int argc,VALUE * argv,VALUE self)5065 _wrap_svn_delta_editor_t_apply_textdelta_set(int argc, VALUE *argv, VALUE self) {
5066 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
5067 svn_error_t *(*arg2)(void *,char const *,apr_pool_t *,svn_txdelta_window_handler_t *,void **) = (svn_error_t *(*)(void *,char const *,apr_pool_t *,svn_txdelta_window_handler_t *,void **)) 0 ;
5068 void *argp1 = 0 ;
5069 int res1 = 0 ;
5070
5071 if ((argc < 1) || (argc > 1)) {
5072 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5073 }
5074 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5075 if (!SWIG_IsOK(res1)) {
5076 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","apply_textdelta", 1, self ));
5077 }
5078 arg1 = (struct svn_delta_editor_t *)(argp1);
5079 {
5080 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_p_apr_pool_t_p_svn_txdelta_window_handler_t_p_p_void__p_svn_error_t);
5081 if (!SWIG_IsOK(res)) {
5082 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(void *,char const *,apr_pool_t *,svn_txdelta_window_handler_t *,void **)","apply_textdelta", 2, argv[0] ));
5083 }
5084 }
5085 if (arg1) (arg1)->apply_textdelta = arg2;
5086 return Qnil;
5087 fail:
5088 return Qnil;
5089 }
5090
5091
5092 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_apply_textdelta_get(int argc,VALUE * argv,VALUE self)5093 _wrap_svn_delta_editor_t_apply_textdelta_get(int argc, VALUE *argv, VALUE self) {
5094 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
5095 void *argp1 = 0 ;
5096 int res1 = 0 ;
5097 svn_error_t *(*result)(void *,char const *,apr_pool_t *,svn_txdelta_window_handler_t *,void **) = 0 ;
5098 VALUE vresult = Qnil;
5099
5100 if ((argc < 0) || (argc > 0)) {
5101 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5102 }
5103 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5104 if (!SWIG_IsOK(res1)) {
5105 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","apply_textdelta", 1, self ));
5106 }
5107 arg1 = (struct svn_delta_editor_t *)(argp1);
5108 result = (svn_error_t *(*)(void *,char const *,apr_pool_t *,svn_txdelta_window_handler_t *,void **)) ((arg1)->apply_textdelta);
5109 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char_p_apr_pool_t_p_svn_txdelta_window_handler_t_p_p_void__p_svn_error_t);
5110 return vresult;
5111 fail:
5112 return Qnil;
5113 }
5114
5115
5116 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_change_file_prop_set(int argc,VALUE * argv,VALUE self)5117 _wrap_svn_delta_editor_t_change_file_prop_set(int argc, VALUE *argv, VALUE self) {
5118 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
5119 svn_error_t *(*arg2)(void *,char const *,svn_string_t const *,apr_pool_t *) = (svn_error_t *(*)(void *,char const *,svn_string_t const *,apr_pool_t *)) 0 ;
5120 void *argp1 = 0 ;
5121 int res1 = 0 ;
5122
5123 if ((argc < 1) || (argc > 1)) {
5124 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5125 }
5126 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5127 if (!SWIG_IsOK(res1)) {
5128 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","change_file_prop", 1, self ));
5129 }
5130 arg1 = (struct svn_delta_editor_t *)(argp1);
5131 {
5132 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t_p_apr_pool_t__p_svn_error_t);
5133 if (!SWIG_IsOK(res)) {
5134 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(void *,char const *,svn_string_t const *,apr_pool_t *)","change_file_prop", 2, argv[0] ));
5135 }
5136 }
5137 if (arg1) (arg1)->change_file_prop = arg2;
5138 return Qnil;
5139 fail:
5140 return Qnil;
5141 }
5142
5143
5144 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_change_file_prop_get(int argc,VALUE * argv,VALUE self)5145 _wrap_svn_delta_editor_t_change_file_prop_get(int argc, VALUE *argv, VALUE self) {
5146 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
5147 void *argp1 = 0 ;
5148 int res1 = 0 ;
5149 svn_error_t *(*result)(void *,char const *,svn_string_t const *,apr_pool_t *) = 0 ;
5150 VALUE vresult = Qnil;
5151
5152 if ((argc < 0) || (argc > 0)) {
5153 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5154 }
5155 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5156 if (!SWIG_IsOK(res1)) {
5157 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","change_file_prop", 1, self ));
5158 }
5159 arg1 = (struct svn_delta_editor_t *)(argp1);
5160 result = (svn_error_t *(*)(void *,char const *,svn_string_t const *,apr_pool_t *)) ((arg1)->change_file_prop);
5161 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_string_t_p_apr_pool_t__p_svn_error_t);
5162 return vresult;
5163 fail:
5164 return Qnil;
5165 }
5166
5167
5168 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_close_file_set(int argc,VALUE * argv,VALUE self)5169 _wrap_svn_delta_editor_t_close_file_set(int argc, VALUE *argv, VALUE self) {
5170 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
5171 svn_error_t *(*arg2)(void *,char const *,apr_pool_t *) = (svn_error_t *(*)(void *,char const *,apr_pool_t *)) 0 ;
5172 void *argp1 = 0 ;
5173 int res1 = 0 ;
5174
5175 if ((argc < 1) || (argc > 1)) {
5176 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5177 }
5178 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5179 if (!SWIG_IsOK(res1)) {
5180 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","close_file", 1, self ));
5181 }
5182 arg1 = (struct svn_delta_editor_t *)(argp1);
5183 {
5184 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t);
5185 if (!SWIG_IsOK(res)) {
5186 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(void *,char const *,apr_pool_t *)","close_file", 2, argv[0] ));
5187 }
5188 }
5189 if (arg1) (arg1)->close_file = arg2;
5190 return Qnil;
5191 fail:
5192 return Qnil;
5193 }
5194
5195
5196 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_close_file_get(int argc,VALUE * argv,VALUE self)5197 _wrap_svn_delta_editor_t_close_file_get(int argc, VALUE *argv, VALUE self) {
5198 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
5199 void *argp1 = 0 ;
5200 int res1 = 0 ;
5201 svn_error_t *(*result)(void *,char const *,apr_pool_t *) = 0 ;
5202 VALUE vresult = Qnil;
5203
5204 if ((argc < 0) || (argc > 0)) {
5205 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5206 }
5207 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5208 if (!SWIG_IsOK(res1)) {
5209 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","close_file", 1, self ));
5210 }
5211 arg1 = (struct svn_delta_editor_t *)(argp1);
5212 result = (svn_error_t *(*)(void *,char const *,apr_pool_t *)) ((arg1)->close_file);
5213 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t);
5214 return vresult;
5215 fail:
5216 return Qnil;
5217 }
5218
5219
5220 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_absent_file_set(int argc,VALUE * argv,VALUE self)5221 _wrap_svn_delta_editor_t_absent_file_set(int argc, VALUE *argv, VALUE self) {
5222 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
5223 svn_error_t *(*arg2)(char const *,void *,apr_pool_t *) = (svn_error_t *(*)(char const *,void *,apr_pool_t *)) 0 ;
5224 void *argp1 = 0 ;
5225 int res1 = 0 ;
5226
5227 if ((argc < 1) || (argc > 1)) {
5228 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5229 }
5230 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5231 if (!SWIG_IsOK(res1)) {
5232 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","absent_file", 1, self ));
5233 }
5234 arg1 = (struct svn_delta_editor_t *)(argp1);
5235 {
5236 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t);
5237 if (!SWIG_IsOK(res)) {
5238 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(char const *,void *,apr_pool_t *)","absent_file", 2, argv[0] ));
5239 }
5240 }
5241 if (arg1) (arg1)->absent_file = arg2;
5242 return Qnil;
5243 fail:
5244 return Qnil;
5245 }
5246
5247
5248 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_absent_file_get(int argc,VALUE * argv,VALUE self)5249 _wrap_svn_delta_editor_t_absent_file_get(int argc, VALUE *argv, VALUE self) {
5250 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
5251 void *argp1 = 0 ;
5252 int res1 = 0 ;
5253 svn_error_t *(*result)(char const *,void *,apr_pool_t *) = 0 ;
5254 VALUE vresult = Qnil;
5255
5256 if ((argc < 0) || (argc > 0)) {
5257 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5258 }
5259 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5260 if (!SWIG_IsOK(res1)) {
5261 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","absent_file", 1, self ));
5262 }
5263 arg1 = (struct svn_delta_editor_t *)(argp1);
5264 result = (svn_error_t *(*)(char const *,void *,apr_pool_t *)) ((arg1)->absent_file);
5265 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t);
5266 return vresult;
5267 fail:
5268 return Qnil;
5269 }
5270
5271
5272 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_close_edit_set(int argc,VALUE * argv,VALUE self)5273 _wrap_svn_delta_editor_t_close_edit_set(int argc, VALUE *argv, VALUE self) {
5274 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
5275 svn_error_t *(*arg2)(void *,apr_pool_t *) = (svn_error_t *(*)(void *,apr_pool_t *)) 0 ;
5276 void *argp1 = 0 ;
5277 int res1 = 0 ;
5278
5279 if ((argc < 1) || (argc > 1)) {
5280 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5281 }
5282 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5283 if (!SWIG_IsOK(res1)) {
5284 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","close_edit", 1, self ));
5285 }
5286 arg1 = (struct svn_delta_editor_t *)(argp1);
5287 {
5288 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_apr_pool_t__p_svn_error_t);
5289 if (!SWIG_IsOK(res)) {
5290 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(void *,apr_pool_t *)","close_edit", 2, argv[0] ));
5291 }
5292 }
5293 if (arg1) (arg1)->close_edit = arg2;
5294 return Qnil;
5295 fail:
5296 return Qnil;
5297 }
5298
5299
5300 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_close_edit_get(int argc,VALUE * argv,VALUE self)5301 _wrap_svn_delta_editor_t_close_edit_get(int argc, VALUE *argv, VALUE self) {
5302 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
5303 void *argp1 = 0 ;
5304 int res1 = 0 ;
5305 svn_error_t *(*result)(void *,apr_pool_t *) = 0 ;
5306 VALUE vresult = Qnil;
5307
5308 if ((argc < 0) || (argc > 0)) {
5309 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5310 }
5311 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5312 if (!SWIG_IsOK(res1)) {
5313 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","close_edit", 1, self ));
5314 }
5315 arg1 = (struct svn_delta_editor_t *)(argp1);
5316 result = (svn_error_t *(*)(void *,apr_pool_t *)) ((arg1)->close_edit);
5317 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_apr_pool_t__p_svn_error_t);
5318 return vresult;
5319 fail:
5320 return Qnil;
5321 }
5322
5323
5324 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_abort_edit_set(int argc,VALUE * argv,VALUE self)5325 _wrap_svn_delta_editor_t_abort_edit_set(int argc, VALUE *argv, VALUE self) {
5326 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
5327 svn_error_t *(*arg2)(void *,apr_pool_t *) = (svn_error_t *(*)(void *,apr_pool_t *)) 0 ;
5328 void *argp1 = 0 ;
5329 int res1 = 0 ;
5330
5331 if ((argc < 1) || (argc > 1)) {
5332 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5333 }
5334 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5335 if (!SWIG_IsOK(res1)) {
5336 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","abort_edit", 1, self ));
5337 }
5338 arg1 = (struct svn_delta_editor_t *)(argp1);
5339 {
5340 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_apr_pool_t__p_svn_error_t);
5341 if (!SWIG_IsOK(res)) {
5342 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(void *,apr_pool_t *)","abort_edit", 2, argv[0] ));
5343 }
5344 }
5345 if (arg1) (arg1)->abort_edit = arg2;
5346 return Qnil;
5347 fail:
5348 return Qnil;
5349 }
5350
5351
5352 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_abort_edit_get(int argc,VALUE * argv,VALUE self)5353 _wrap_svn_delta_editor_t_abort_edit_get(int argc, VALUE *argv, VALUE self) {
5354 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
5355 void *argp1 = 0 ;
5356 int res1 = 0 ;
5357 svn_error_t *(*result)(void *,apr_pool_t *) = 0 ;
5358 VALUE vresult = Qnil;
5359
5360 if ((argc < 0) || (argc > 0)) {
5361 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5362 }
5363 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5364 if (!SWIG_IsOK(res1)) {
5365 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","abort_edit", 1, self ));
5366 }
5367 arg1 = (struct svn_delta_editor_t *)(argp1);
5368 result = (svn_error_t *(*)(void *,apr_pool_t *)) ((arg1)->abort_edit);
5369 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_apr_pool_t__p_svn_error_t);
5370 return vresult;
5371 fail:
5372 return Qnil;
5373 }
5374
5375
5376 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_apply_textdelta_stream_set(int argc,VALUE * argv,VALUE self)5377 _wrap_svn_delta_editor_t_apply_textdelta_stream_set(int argc, VALUE *argv, VALUE self) {
5378 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
5379 svn_error_t *(*arg2)(struct svn_delta_editor_t const *,void *,char const *,svn_txdelta_stream_open_func_t,void *,apr_pool_t *) = (svn_error_t *(*)(struct svn_delta_editor_t const *,void *,char const *,svn_txdelta_stream_open_func_t,void *,apr_pool_t *)) 0 ;
5380 void *argp1 = 0 ;
5381 int res1 = 0 ;
5382
5383 if ((argc < 1) || (argc > 1)) {
5384 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5385 }
5386 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5387 if (!SWIG_IsOK(res1)) {
5388 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","apply_textdelta_stream", 1, self ));
5389 }
5390 arg1 = (struct svn_delta_editor_t *)(argp1);
5391 {
5392 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_q_const__struct_svn_delta_editor_t_p_void_p_q_const__char_svn_txdelta_stream_open_func_t_p_void_p_apr_pool_t__p_svn_error_t);
5393 if (!SWIG_IsOK(res)) {
5394 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(struct svn_delta_editor_t const *,void *,char const *,svn_txdelta_stream_open_func_t,void *,apr_pool_t *)","apply_textdelta_stream", 2, argv[0] ));
5395 }
5396 }
5397 if (arg1) (arg1)->apply_textdelta_stream = arg2;
5398 return Qnil;
5399 fail:
5400 return Qnil;
5401 }
5402
5403
5404 SWIGINTERN VALUE
_wrap_svn_delta_editor_t_apply_textdelta_stream_get(int argc,VALUE * argv,VALUE self)5405 _wrap_svn_delta_editor_t_apply_textdelta_stream_get(int argc, VALUE *argv, VALUE self) {
5406 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *) 0 ;
5407 void *argp1 = 0 ;
5408 int res1 = 0 ;
5409 svn_error_t *(*result)(struct svn_delta_editor_t const *,void *,char const *,svn_txdelta_stream_open_func_t,void *,apr_pool_t *) = 0 ;
5410 VALUE vresult = Qnil;
5411
5412 if ((argc < 0) || (argc > 0)) {
5413 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5414 }
5415 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5416 if (!SWIG_IsOK(res1)) {
5417 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_delta_editor_t *","apply_textdelta_stream", 1, self ));
5418 }
5419 arg1 = (struct svn_delta_editor_t *)(argp1);
5420 result = (svn_error_t *(*)(struct svn_delta_editor_t const *,void *,char const *,svn_txdelta_stream_open_func_t,void *,apr_pool_t *)) ((arg1)->apply_textdelta_stream);
5421 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__struct_svn_delta_editor_t_p_void_p_q_const__char_svn_txdelta_stream_open_func_t_p_void_p_apr_pool_t__p_svn_error_t);
5422 return vresult;
5423 fail:
5424 return Qnil;
5425 }
5426
5427
5428 SWIGINTERN VALUE
5429 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
_wrap_svn_delta_editor_t_allocate(VALUE self)5430 _wrap_svn_delta_editor_t_allocate(VALUE self)
5431 #else
5432 _wrap_svn_delta_editor_t_allocate(int argc, VALUE *argv, VALUE self)
5433 #endif
5434 {
5435 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_svn_delta_editor_t);
5436 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
5437 rb_obj_call_init(vresult, argc, argv);
5438 #endif
5439 return vresult;
5440 }
5441
5442
5443 SWIGINTERN VALUE
_wrap_new_svn_delta_editor_t(int argc,VALUE * argv,VALUE self)5444 _wrap_new_svn_delta_editor_t(int argc, VALUE *argv, VALUE self) {
5445 struct svn_delta_editor_t *result = 0 ;
5446
5447 if ((argc < 0) || (argc > 0)) {
5448 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5449 }
5450 {
5451 result = (struct svn_delta_editor_t *)calloc(1, sizeof(struct svn_delta_editor_t));
5452 DATA_PTR(self) = result;
5453
5454
5455
5456 }
5457 return self;
5458 fail:
5459 return Qnil;
5460 }
5461
5462
5463 SWIGINTERN void
free_svn_delta_editor_t(void * self)5464 free_svn_delta_editor_t(void *self) {
5465 struct svn_delta_editor_t *arg1 = (struct svn_delta_editor_t *)self;
5466 free((char *) arg1);
5467 }
5468
5469 SWIGINTERN VALUE
_wrap_svn_delta_default_editor(int argc,VALUE * argv,VALUE self)5470 _wrap_svn_delta_default_editor(int argc, VALUE *argv, VALUE self) {
5471 apr_pool_t *arg1 = (apr_pool_t *) 0 ;
5472 VALUE _global_svn_swig_rb_pool ;
5473 apr_pool_t *_global_pool ;
5474 svn_delta_editor_t *result = 0 ;
5475 VALUE vresult = Qnil;
5476
5477 {
5478 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg1);
5479 _global_pool = arg1;
5480 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
5481 }
5482 if ((argc < 0) || (argc > 1)) {
5483 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5484 }
5485 if (argc > 0) {
5486
5487 }
5488 {
5489 result = (svn_delta_editor_t *)svn_delta_default_editor(arg1);
5490
5491
5492
5493 }
5494 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5495 {
5496 VALUE target;
5497 target = _global_vresult_address == &vresult ? self : vresult;
5498 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
5499 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5500 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5501 }
5502 return vresult;
5503 fail:
5504 {
5505 VALUE target;
5506 target = _global_vresult_address == &vresult ? self : vresult;
5507 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
5508 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5509 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5510 }
5511 return Qnil;
5512 }
5513
5514
5515 SWIGINTERN VALUE
_wrap_svn_delta_noop_window_handler(int argc,VALUE * argv,VALUE self)5516 _wrap_svn_delta_noop_window_handler(int argc, VALUE *argv, VALUE self) {
5517 svn_txdelta_window_t *arg1 = (svn_txdelta_window_t *) 0 ;
5518 void *arg2 = (void *) 0 ;
5519 void *argp1 = 0 ;
5520 int res1 = 0 ;
5521 int res2 ;
5522 svn_error_t *result = 0 ;
5523 VALUE vresult = Qnil;
5524
5525 if ((argc < 2) || (argc > 2)) {
5526 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
5527 }
5528 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
5529 if (!SWIG_IsOK(res1)) {
5530 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_txdelta_window_t *","svn_delta_noop_window_handler", 1, argv[0] ));
5531 }
5532 arg1 = (svn_txdelta_window_t *)(argp1);
5533 res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
5534 if (!SWIG_IsOK(res2)) {
5535 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_delta_noop_window_handler", 2, argv[1] ));
5536 }
5537 {
5538 result = (svn_error_t *)svn_delta_noop_window_handler(arg1,arg2);
5539
5540
5541
5542 }
5543 {
5544 if (result) {
5545 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5546 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5547 svn_swig_rb_handle_svn_error(result);
5548 }
5549 vresult = Qnil;
5550 }
5551 return vresult;
5552 fail:
5553 return Qnil;
5554 }
5555
5556
5557 SWIGINTERN VALUE
_wrap_svn_delta_get_cancellation_editor(int argc,VALUE * argv,VALUE self)5558 _wrap_svn_delta_get_cancellation_editor(int argc, VALUE *argv, VALUE self) {
5559 svn_cancel_func_t arg1 = (svn_cancel_func_t) 0 ;
5560 void *arg2 = (void *) 0 ;
5561 svn_delta_editor_t *arg3 = (svn_delta_editor_t *) 0 ;
5562 void *arg4 = (void *) 0 ;
5563 svn_delta_editor_t **arg5 = (svn_delta_editor_t **) 0 ;
5564 void **arg6 = (void **) 0 ;
5565 apr_pool_t *arg7 = (apr_pool_t *) 0 ;
5566 VALUE _global_svn_swig_rb_pool ;
5567 apr_pool_t *_global_pool ;
5568 void *argp3 = 0 ;
5569 int res3 = 0 ;
5570 int res4 ;
5571 svn_delta_editor_t *temp5 ;
5572 void *temp6 ;
5573 svn_error_t *result = 0 ;
5574 VALUE vresult = Qnil;
5575
5576 {
5577 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
5578 _global_pool = arg7;
5579 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
5580 }
5581 arg5 = &temp5;
5582 arg6 = &temp6;
5583 if ((argc < 3) || (argc > 4)) {
5584 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
5585 }
5586 {
5587 arg1 = (svn_cancel_func_t) svn_swig_rb_cancel_func;
5588 arg2 = (void *)svn_swig_rb_make_baton(argv[0], _global_svn_swig_rb_pool);
5589 }
5590 res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5591 if (!SWIG_IsOK(res3)) {
5592 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "svn_delta_editor_t const *","svn_delta_get_cancellation_editor", 3, argv[1] ));
5593 }
5594 arg3 = (svn_delta_editor_t *)(argp3);
5595 res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
5596 if (!SWIG_IsOK(res4)) {
5597 SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","svn_delta_get_cancellation_editor", 4, argv[2] ));
5598 }
5599 if (argc > 3) {
5600
5601 }
5602 {
5603 result = (svn_error_t *)svn_delta_get_cancellation_editor(arg1,arg2,(struct svn_delta_editor_t const *)arg3,arg4,(struct svn_delta_editor_t const **)arg5,arg6,arg7);
5604
5605
5606
5607 }
5608 {
5609 if (result) {
5610 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5611 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5612 svn_swig_rb_handle_svn_error(result);
5613 }
5614 vresult = Qnil;
5615 }
5616 {
5617 svn_swig_rb_set_baton(vresult, (VALUE)arg2);
5618 }
5619 {
5620 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg5, SWIGTYPE_p_svn_delta_editor_t, 0));
5621 }
5622 {
5623 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg6, SWIGTYPE_p_void, 0));
5624 }
5625 {
5626 VALUE target;
5627 target = _global_vresult_address == &vresult ? self : vresult;
5628 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
5629 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5630 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5631 }
5632 return vresult;
5633 fail:
5634 {
5635 VALUE target;
5636 target = _global_vresult_address == &vresult ? self : vresult;
5637 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
5638 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5639 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5640 }
5641 return Qnil;
5642 }
5643
5644
5645 SWIGINTERN VALUE
_wrap_svn_delta_depth_filter_editor(int argc,VALUE * argv,VALUE self)5646 _wrap_svn_delta_depth_filter_editor(int argc, VALUE *argv, VALUE self) {
5647 svn_delta_editor_t **arg1 = (svn_delta_editor_t **) 0 ;
5648 void **arg2 = (void **) 0 ;
5649 svn_delta_editor_t *arg3 = (svn_delta_editor_t *) 0 ;
5650 void *arg4 = (void *) 0 ;
5651 svn_depth_t arg5 ;
5652 svn_boolean_t arg6 ;
5653 apr_pool_t *arg7 = (apr_pool_t *) 0 ;
5654 VALUE _global_svn_swig_rb_pool ;
5655 apr_pool_t *_global_pool ;
5656 svn_delta_editor_t *temp1 ;
5657 void *temp2 ;
5658 void *argp3 = 0 ;
5659 int res3 = 0 ;
5660 int res4 ;
5661 svn_error_t *result = 0 ;
5662 VALUE vresult = Qnil;
5663
5664 {
5665 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
5666 _global_pool = arg7;
5667 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
5668 }
5669 arg1 = &temp1;
5670 arg2 = &temp2;
5671 if ((argc < 4) || (argc > 5)) {
5672 rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
5673 }
5674 res3 = SWIG_ConvertPtr(argv[0], &argp3,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
5675 if (!SWIG_IsOK(res3)) {
5676 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "svn_delta_editor_t const *","svn_delta_depth_filter_editor", 3, argv[0] ));
5677 }
5678 arg3 = (svn_delta_editor_t *)(argp3);
5679 res4 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg4), 0, 0);
5680 if (!SWIG_IsOK(res4)) {
5681 SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","svn_delta_depth_filter_editor", 4, argv[1] ));
5682 }
5683 {
5684 arg5 = svn_swig_rb_to_depth(argv[2]);
5685 }
5686 arg6 = RTEST(argv[3]);
5687 if (argc > 4) {
5688
5689 }
5690 {
5691 result = (svn_error_t *)svn_delta_depth_filter_editor((struct svn_delta_editor_t const **)arg1,arg2,(struct svn_delta_editor_t const *)arg3,arg4,arg5,arg6,arg7);
5692
5693
5694
5695 }
5696 {
5697 if (result) {
5698 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5699 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5700 svn_swig_rb_handle_svn_error(result);
5701 }
5702 vresult = Qnil;
5703 }
5704 {
5705 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg1, SWIGTYPE_p_svn_delta_editor_t, 0));
5706 }
5707 {
5708 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_void, 0));
5709 }
5710 {
5711 VALUE target;
5712 target = _global_vresult_address == &vresult ? self : vresult;
5713 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
5714 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5715 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5716 }
5717 return vresult;
5718 fail:
5719 {
5720 VALUE target;
5721 target = _global_vresult_address == &vresult ? self : vresult;
5722 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
5723 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5724 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5725 }
5726 return Qnil;
5727 }
5728
5729
5730 SWIGINTERN VALUE
_wrap_svn_delta_path_driver3(int argc,VALUE * argv,VALUE self)5731 _wrap_svn_delta_path_driver3(int argc, VALUE *argv, VALUE self) {
5732 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
5733 void *arg2 = (void *) 0 ;
5734 apr_array_header_t *arg3 = (apr_array_header_t *) 0 ;
5735 svn_boolean_t arg4 ;
5736 svn_delta_path_driver_cb_func2_t arg5 = (svn_delta_path_driver_cb_func2_t) 0 ;
5737 void *arg6 = (void *) 0 ;
5738 apr_pool_t *arg7 = (apr_pool_t *) 0 ;
5739 VALUE _global_svn_swig_rb_pool ;
5740 apr_pool_t *_global_pool ;
5741 void *argp3 = 0 ;
5742 int res3 = 0 ;
5743 int res6 ;
5744 svn_error_t *result = 0 ;
5745 VALUE vresult = Qnil;
5746
5747 {
5748 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
5749 _global_pool = arg7;
5750 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
5751 }
5752 if ((argc < 5) || (argc > 6)) {
5753 rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
5754 }
5755 {
5756 if (RTEST(rb_obj_is_kind_of(argv[0],
5757 svn_swig_rb_svn_delta_editor()))) {
5758 arg1 = svn_swig_rb_to_swig_type(argv[0],
5759 "svn_delta_editor_t *",
5760 _global_pool);
5761 arg2 = svn_swig_rb_to_swig_type(rb_funcall(argv[0], rb_intern("baton"), 0),
5762 "void *", _global_pool);
5763 } else {
5764 svn_swig_rb_make_delta_editor(&arg1, &arg2, argv[0], _global_pool);
5765 }
5766 }
5767 res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_apr_array_header_t, 0 | 0 );
5768 if (!SWIG_IsOK(res3)) {
5769 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "apr_array_header_t const *","svn_delta_path_driver3", 3, argv[1] ));
5770 }
5771 arg3 = (apr_array_header_t *)(argp3);
5772 arg4 = RTEST(argv[2]);
5773 {
5774 int res = SWIG_ConvertFunctionPtr(argv[3], (void**)(&arg5), SWIGTYPE_p_f_p_p_void_p_q_const__svn_delta_editor_t_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t);
5775 if (!SWIG_IsOK(res)) {
5776 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_delta_path_driver_cb_func2_t","svn_delta_path_driver3", 5, argv[3] ));
5777 }
5778 }
5779 res6 = SWIG_ConvertPtr(argv[4],SWIG_as_voidptrptr(&arg6), 0, 0);
5780 if (!SWIG_IsOK(res6)) {
5781 SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "void *","svn_delta_path_driver3", 6, argv[4] ));
5782 }
5783 if (argc > 5) {
5784
5785 }
5786 {
5787 result = (svn_error_t *)svn_delta_path_driver3((struct svn_delta_editor_t const *)arg1,arg2,(apr_array_header_t const *)arg3,arg4,arg5,arg6,arg7);
5788
5789
5790
5791 }
5792 {
5793 if (result) {
5794 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5795 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5796 svn_swig_rb_handle_svn_error(result);
5797 }
5798 vresult = Qnil;
5799 }
5800 {
5801 VALUE target;
5802 target = _global_vresult_address == &vresult ? self : vresult;
5803 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
5804 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5805 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5806 }
5807 return vresult;
5808 fail:
5809 {
5810 VALUE target;
5811 target = _global_vresult_address == &vresult ? self : vresult;
5812 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
5813 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5814 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5815 }
5816 return Qnil;
5817 }
5818
5819
5820 SWIGINTERN VALUE
_wrap_svn_delta_path_driver2(int argc,VALUE * argv,VALUE self)5821 _wrap_svn_delta_path_driver2(int argc, VALUE *argv, VALUE self) {
5822 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
5823 void *arg2 = (void *) 0 ;
5824 apr_array_header_t *arg3 = (apr_array_header_t *) 0 ;
5825 svn_boolean_t arg4 ;
5826 svn_delta_path_driver_cb_func_t arg5 = (svn_delta_path_driver_cb_func_t) 0 ;
5827 void *arg6 = (void *) 0 ;
5828 apr_pool_t *arg7 = (apr_pool_t *) 0 ;
5829 VALUE _global_svn_swig_rb_pool ;
5830 apr_pool_t *_global_pool ;
5831 svn_error_t *result = 0 ;
5832 VALUE vresult = Qnil;
5833
5834 {
5835 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
5836 _global_pool = arg7;
5837 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
5838 }
5839 if ((argc < 4) || (argc > 5)) {
5840 rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
5841 }
5842 {
5843 if (RTEST(rb_obj_is_kind_of(argv[0],
5844 svn_swig_rb_svn_delta_editor()))) {
5845 arg1 = svn_swig_rb_to_swig_type(argv[0],
5846 "svn_delta_editor_t *",
5847 _global_pool);
5848 arg2 = svn_swig_rb_to_swig_type(rb_funcall(argv[0], rb_intern("baton"), 0),
5849 "void *", _global_pool);
5850 } else {
5851 svn_swig_rb_make_delta_editor(&arg1, &arg2, argv[0], _global_pool);
5852 }
5853 }
5854 {
5855 arg3 = svn_swig_rb_strings_to_apr_array(argv[1], _global_pool);
5856 }
5857 arg4 = RTEST(argv[2]);
5858 {
5859 arg5 = (svn_delta_path_driver_cb_func_t) svn_swig_rb_delta_path_driver_cb_func;
5860 arg6 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
5861 }
5862 if (argc > 4) {
5863
5864 }
5865 {
5866 result = (svn_error_t *)svn_delta_path_driver2((struct svn_delta_editor_t const *)arg1,arg2,(apr_array_header_t const *)arg3,arg4,arg5,arg6,arg7);
5867
5868
5869
5870 }
5871 {
5872 if (result) {
5873 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5874 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5875 svn_swig_rb_handle_svn_error(result);
5876 }
5877 vresult = Qnil;
5878 }
5879 {
5880 VALUE target;
5881 target = _global_vresult_address == &vresult ? self : vresult;
5882 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
5883 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5884 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5885 }
5886 return vresult;
5887 fail:
5888 {
5889 VALUE target;
5890 target = _global_vresult_address == &vresult ? self : vresult;
5891 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
5892 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5893 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5894 }
5895 return Qnil;
5896 }
5897
5898
5899 SWIGINTERN VALUE
_wrap_svn_delta_path_driver(int argc,VALUE * argv,VALUE self)5900 _wrap_svn_delta_path_driver(int argc, VALUE *argv, VALUE self) {
5901 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
5902 void *arg2 = (void *) 0 ;
5903 svn_revnum_t arg3 ;
5904 apr_array_header_t *arg4 = (apr_array_header_t *) 0 ;
5905 svn_delta_path_driver_cb_func_t arg5 = (svn_delta_path_driver_cb_func_t) 0 ;
5906 void *arg6 = (void *) 0 ;
5907 apr_pool_t *arg7 = (apr_pool_t *) 0 ;
5908 VALUE _global_svn_swig_rb_pool ;
5909 apr_pool_t *_global_pool ;
5910 long val3 ;
5911 int ecode3 = 0 ;
5912 svn_error_t *result = 0 ;
5913 VALUE vresult = Qnil;
5914
5915 {
5916 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
5917 _global_pool = arg7;
5918 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
5919 }
5920 if ((argc < 4) || (argc > 5)) {
5921 rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
5922 }
5923 {
5924 if (RTEST(rb_obj_is_kind_of(argv[0],
5925 svn_swig_rb_svn_delta_editor()))) {
5926 arg1 = svn_swig_rb_to_swig_type(argv[0],
5927 "svn_delta_editor_t *",
5928 _global_pool);
5929 arg2 = svn_swig_rb_to_swig_type(rb_funcall(argv[0], rb_intern("baton"), 0),
5930 "void *", _global_pool);
5931 } else {
5932 svn_swig_rb_make_delta_editor(&arg1, &arg2, argv[0], _global_pool);
5933 }
5934 }
5935 ecode3 = SWIG_AsVal_long(argv[1], &val3);
5936 if (!SWIG_IsOK(ecode3)) {
5937 SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "svn_revnum_t","svn_delta_path_driver", 3, argv[1] ));
5938 }
5939 arg3 = (svn_revnum_t)(val3);
5940 {
5941 arg4 = svn_swig_rb_strings_to_apr_array(argv[2], _global_pool);
5942 }
5943 {
5944 arg5 = (svn_delta_path_driver_cb_func_t) svn_swig_rb_delta_path_driver_cb_func;
5945 arg6 = (void *)svn_swig_rb_make_baton(argv[3], _global_svn_swig_rb_pool);
5946 }
5947 if (argc > 4) {
5948
5949 }
5950 {
5951 result = (svn_error_t *)svn_delta_path_driver((struct svn_delta_editor_t const *)arg1,arg2,arg3,(apr_array_header_t const *)arg4,arg5,arg6,arg7);
5952
5953
5954
5955 }
5956 {
5957 if (result) {
5958 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5959 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5960 svn_swig_rb_handle_svn_error(result);
5961 }
5962 vresult = Qnil;
5963 }
5964 {
5965 VALUE target;
5966 target = _global_vresult_address == &vresult ? self : vresult;
5967 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
5968 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5969 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5970 }
5971 return vresult;
5972 fail:
5973 {
5974 VALUE target;
5975 target = _global_vresult_address == &vresult ? self : vresult;
5976 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
5977 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
5978 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
5979 }
5980 return Qnil;
5981 }
5982
5983
5984 SWIGINTERN VALUE
_wrap_svn_delta_path_driver_start(int argc,VALUE * argv,VALUE self)5985 _wrap_svn_delta_path_driver_start(int argc, VALUE *argv, VALUE self) {
5986 svn_delta_path_driver_state_t **arg1 = (svn_delta_path_driver_state_t **) 0 ;
5987 svn_delta_editor_t *arg2 = (svn_delta_editor_t *) 0 ;
5988 void *arg3 = (void *) 0 ;
5989 svn_delta_path_driver_cb_func2_t arg4 = (svn_delta_path_driver_cb_func2_t) 0 ;
5990 void *arg5 = (void *) 0 ;
5991 apr_pool_t *arg6 = (apr_pool_t *) 0 ;
5992 VALUE _global_svn_swig_rb_pool ;
5993 apr_pool_t *_global_pool ;
5994 svn_delta_path_driver_state_t *temp1 ;
5995 int res5 ;
5996 svn_error_t *result = 0 ;
5997 VALUE vresult = Qnil;
5998
5999 {
6000 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg6);
6001 _global_pool = arg6;
6002 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
6003 }
6004 arg1 = &temp1;
6005 if ((argc < 3) || (argc > 4)) {
6006 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
6007 }
6008 {
6009 if (RTEST(rb_obj_is_kind_of(argv[0],
6010 svn_swig_rb_svn_delta_editor()))) {
6011 arg2 = svn_swig_rb_to_swig_type(argv[0],
6012 "svn_delta_editor_t *",
6013 _global_pool);
6014 arg3 = svn_swig_rb_to_swig_type(rb_funcall(argv[0], rb_intern("baton"), 0),
6015 "void *", _global_pool);
6016 } else {
6017 svn_swig_rb_make_delta_editor(&arg2, &arg3, argv[0], _global_pool);
6018 }
6019 }
6020 {
6021 int res = SWIG_ConvertFunctionPtr(argv[1], (void**)(&arg4), SWIGTYPE_p_f_p_p_void_p_q_const__svn_delta_editor_t_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t);
6022 if (!SWIG_IsOK(res)) {
6023 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_delta_path_driver_cb_func2_t","svn_delta_path_driver_start", 4, argv[1] ));
6024 }
6025 }
6026 res5 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg5), 0, 0);
6027 if (!SWIG_IsOK(res5)) {
6028 SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "void *","svn_delta_path_driver_start", 5, argv[2] ));
6029 }
6030 if (argc > 3) {
6031
6032 }
6033 {
6034 result = (svn_error_t *)svn_delta_path_driver_start(arg1,(struct svn_delta_editor_t const *)arg2,arg3,arg4,arg5,arg6);
6035
6036
6037
6038 }
6039 {
6040 if (result) {
6041 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6042 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6043 svn_swig_rb_handle_svn_error(result);
6044 }
6045 vresult = Qnil;
6046 }
6047 {
6048 /* FIXME: Missing argout typemap: svn_delta_path_driver_start arg 1 (svn_delta_path_driver_state_t **) */
6049
6050
6051
6052
6053 SWIG_exception(SWIG_ValueError, "svn_delta_path_driver_start is not implemented yet");
6054
6055 }
6056 {
6057 VALUE target;
6058 target = _global_vresult_address == &vresult ? self : vresult;
6059 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6060 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6061 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6062 }
6063 return vresult;
6064 fail:
6065 {
6066 VALUE target;
6067 target = _global_vresult_address == &vresult ? self : vresult;
6068 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6069 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6070 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6071 }
6072 return Qnil;
6073 }
6074
6075
6076 SWIGINTERN VALUE
_wrap_svn_delta_path_driver_step(int argc,VALUE * argv,VALUE self)6077 _wrap_svn_delta_path_driver_step(int argc, VALUE *argv, VALUE self) {
6078 svn_delta_path_driver_state_t *arg1 = (svn_delta_path_driver_state_t *) 0 ;
6079 char *arg2 = (char *) 0 ;
6080 apr_pool_t *arg3 = (apr_pool_t *) 0 ;
6081 VALUE _global_svn_swig_rb_pool ;
6082 apr_pool_t *_global_pool ;
6083 void *argp1 = 0 ;
6084 int res1 = 0 ;
6085 int res2 ;
6086 char *buf2 = 0 ;
6087 int alloc2 = 0 ;
6088 svn_error_t *result = 0 ;
6089 VALUE vresult = Qnil;
6090
6091 {
6092 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
6093 _global_pool = arg3;
6094 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
6095 }
6096 if ((argc < 2) || (argc > 3)) {
6097 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
6098 }
6099 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_path_driver_state_t, 0 | 0 );
6100 if (!SWIG_IsOK(res1)) {
6101 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_path_driver_state_t *","svn_delta_path_driver_step", 1, argv[0] ));
6102 }
6103 arg1 = (svn_delta_path_driver_state_t *)(argp1);
6104 res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
6105 if (!SWIG_IsOK(res2)) {
6106 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_delta_path_driver_step", 2, argv[1] ));
6107 }
6108 arg2 = (char *)(buf2);
6109 if (argc > 2) {
6110
6111 }
6112 {
6113 result = (svn_error_t *)svn_delta_path_driver_step(arg1,(char const *)arg2,arg3);
6114
6115
6116
6117 }
6118 {
6119 if (result) {
6120 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6121 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6122 svn_swig_rb_handle_svn_error(result);
6123 }
6124 vresult = Qnil;
6125 }
6126 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6127 {
6128 VALUE target;
6129 target = _global_vresult_address == &vresult ? self : vresult;
6130 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6131 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6132 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6133 }
6134 return vresult;
6135 fail:
6136 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6137 {
6138 VALUE target;
6139 target = _global_vresult_address == &vresult ? self : vresult;
6140 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6141 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6142 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6143 }
6144 return Qnil;
6145 }
6146
6147
6148 SWIGINTERN VALUE
_wrap_svn_delta_path_driver_finish(int argc,VALUE * argv,VALUE self)6149 _wrap_svn_delta_path_driver_finish(int argc, VALUE *argv, VALUE self) {
6150 svn_delta_path_driver_state_t *arg1 = (svn_delta_path_driver_state_t *) 0 ;
6151 apr_pool_t *arg2 = (apr_pool_t *) 0 ;
6152 VALUE _global_svn_swig_rb_pool ;
6153 apr_pool_t *_global_pool ;
6154 void *argp1 = 0 ;
6155 int res1 = 0 ;
6156 svn_error_t *result = 0 ;
6157 VALUE vresult = Qnil;
6158
6159 {
6160 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg2);
6161 _global_pool = arg2;
6162 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
6163 }
6164 if ((argc < 1) || (argc > 2)) {
6165 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6166 }
6167 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_path_driver_state_t, 0 | 0 );
6168 if (!SWIG_IsOK(res1)) {
6169 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_path_driver_state_t *","svn_delta_path_driver_finish", 1, argv[0] ));
6170 }
6171 arg1 = (svn_delta_path_driver_state_t *)(argp1);
6172 if (argc > 1) {
6173
6174 }
6175 {
6176 result = (svn_error_t *)svn_delta_path_driver_finish(arg1,arg2);
6177
6178
6179
6180 }
6181 {
6182 if (result) {
6183 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6184 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6185 svn_swig_rb_handle_svn_error(result);
6186 }
6187 vresult = Qnil;
6188 }
6189 {
6190 VALUE target;
6191 target = _global_vresult_address == &vresult ? self : vresult;
6192 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6193 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6194 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6195 }
6196 return vresult;
6197 fail:
6198 {
6199 VALUE target;
6200 target = _global_vresult_address == &vresult ? self : vresult;
6201 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6202 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6203 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6204 }
6205 return Qnil;
6206 }
6207
6208
6209 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_set_target_revision(int argc,VALUE * argv,VALUE self)6210 _wrap_svn_delta_editor_invoke_set_target_revision(int argc, VALUE *argv, VALUE self) {
6211 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
6212 void *arg2 = (void *) 0 ;
6213 svn_revnum_t arg3 ;
6214 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
6215 VALUE _global_svn_swig_rb_pool ;
6216 apr_pool_t *_global_pool ;
6217 void *argp1 = 0 ;
6218 int res1 = 0 ;
6219 int res2 ;
6220 long val3 ;
6221 int ecode3 = 0 ;
6222 svn_error_t *result = 0 ;
6223 VALUE vresult = Qnil;
6224
6225 {
6226 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
6227 _global_pool = arg4;
6228 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
6229 }
6230 if ((argc < 3) || (argc > 4)) {
6231 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
6232 }
6233 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
6234 if (!SWIG_IsOK(res1)) {
6235 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_set_target_revision", 1, argv[0] ));
6236 }
6237 arg1 = (svn_delta_editor_t *)(argp1);
6238 res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
6239 if (!SWIG_IsOK(res2)) {
6240 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_set_target_revision", 2, argv[1] ));
6241 }
6242 ecode3 = SWIG_AsVal_long(argv[2], &val3);
6243 if (!SWIG_IsOK(ecode3)) {
6244 SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "svn_revnum_t","svn_delta_editor_invoke_set_target_revision", 3, argv[2] ));
6245 }
6246 arg3 = (svn_revnum_t)(val3);
6247 if (argc > 3) {
6248
6249 }
6250 {
6251 result = (svn_error_t *)svn_delta_editor_invoke_set_target_revision(arg1,arg2,arg3,arg4);
6252
6253
6254
6255 }
6256 {
6257 if (result) {
6258 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6259 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6260 svn_swig_rb_handle_svn_error(result);
6261 }
6262 vresult = Qnil;
6263 }
6264 {
6265 VALUE target;
6266 target = _global_vresult_address == &vresult ? self : vresult;
6267 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6268 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6269 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6270 }
6271 return vresult;
6272 fail:
6273 {
6274 VALUE target;
6275 target = _global_vresult_address == &vresult ? self : vresult;
6276 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6277 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6278 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6279 }
6280 return Qnil;
6281 }
6282
6283
6284 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_open_root(int argc,VALUE * argv,VALUE self)6285 _wrap_svn_delta_editor_invoke_open_root(int argc, VALUE *argv, VALUE self) {
6286 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
6287 void *arg2 = (void *) 0 ;
6288 svn_revnum_t arg3 ;
6289 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
6290 void **arg5 = (void **) 0 ;
6291 VALUE _global_svn_swig_rb_pool ;
6292 apr_pool_t *_global_pool ;
6293 void *argp1 = 0 ;
6294 int res1 = 0 ;
6295 int res2 ;
6296 long val3 ;
6297 int ecode3 = 0 ;
6298 void *temp5 ;
6299 svn_error_t *result = 0 ;
6300 VALUE vresult = Qnil;
6301
6302 {
6303 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
6304 _global_pool = arg4;
6305 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
6306 }
6307 arg5 = &temp5;
6308 if ((argc < 3) || (argc > 4)) {
6309 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
6310 }
6311 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
6312 if (!SWIG_IsOK(res1)) {
6313 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_open_root", 1, argv[0] ));
6314 }
6315 arg1 = (svn_delta_editor_t *)(argp1);
6316 res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
6317 if (!SWIG_IsOK(res2)) {
6318 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_open_root", 2, argv[1] ));
6319 }
6320 ecode3 = SWIG_AsVal_long(argv[2], &val3);
6321 if (!SWIG_IsOK(ecode3)) {
6322 SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "svn_revnum_t","svn_delta_editor_invoke_open_root", 3, argv[2] ));
6323 }
6324 arg3 = (svn_revnum_t)(val3);
6325 if (argc > 3) {
6326
6327 }
6328 {
6329 result = (svn_error_t *)svn_delta_editor_invoke_open_root(arg1,arg2,arg3,arg4,arg5);
6330
6331
6332
6333 }
6334 {
6335 if (result) {
6336 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6337 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6338 svn_swig_rb_handle_svn_error(result);
6339 }
6340 vresult = Qnil;
6341 }
6342 {
6343 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg5, SWIGTYPE_p_void, 0));
6344 }
6345 {
6346 VALUE target;
6347 target = _global_vresult_address == &vresult ? self : vresult;
6348 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6349 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6350 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6351 }
6352 return vresult;
6353 fail:
6354 {
6355 VALUE target;
6356 target = _global_vresult_address == &vresult ? self : vresult;
6357 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6358 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6359 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6360 }
6361 return Qnil;
6362 }
6363
6364
6365 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_delete_entry(int argc,VALUE * argv,VALUE self)6366 _wrap_svn_delta_editor_invoke_delete_entry(int argc, VALUE *argv, VALUE self) {
6367 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
6368 char *arg2 = (char *) 0 ;
6369 svn_revnum_t arg3 ;
6370 void *arg4 = (void *) 0 ;
6371 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
6372 VALUE _global_svn_swig_rb_pool ;
6373 apr_pool_t *_global_pool ;
6374 void *argp1 = 0 ;
6375 int res1 = 0 ;
6376 int res2 ;
6377 char *buf2 = 0 ;
6378 int alloc2 = 0 ;
6379 long val3 ;
6380 int ecode3 = 0 ;
6381 int res4 ;
6382 svn_error_t *result = 0 ;
6383 VALUE vresult = Qnil;
6384
6385 {
6386 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
6387 _global_pool = arg5;
6388 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
6389 }
6390 if ((argc < 4) || (argc > 5)) {
6391 rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
6392 }
6393 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
6394 if (!SWIG_IsOK(res1)) {
6395 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_delete_entry", 1, argv[0] ));
6396 }
6397 arg1 = (svn_delta_editor_t *)(argp1);
6398 res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
6399 if (!SWIG_IsOK(res2)) {
6400 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_delta_editor_invoke_delete_entry", 2, argv[1] ));
6401 }
6402 arg2 = (char *)(buf2);
6403 ecode3 = SWIG_AsVal_long(argv[2], &val3);
6404 if (!SWIG_IsOK(ecode3)) {
6405 SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "svn_revnum_t","svn_delta_editor_invoke_delete_entry", 3, argv[2] ));
6406 }
6407 arg3 = (svn_revnum_t)(val3);
6408 res4 = SWIG_ConvertPtr(argv[3],SWIG_as_voidptrptr(&arg4), 0, 0);
6409 if (!SWIG_IsOK(res4)) {
6410 SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_delete_entry", 4, argv[3] ));
6411 }
6412 if (argc > 4) {
6413
6414 }
6415 {
6416 result = (svn_error_t *)svn_delta_editor_invoke_delete_entry(arg1,(char const *)arg2,arg3,arg4,arg5);
6417
6418
6419
6420 }
6421 {
6422 if (result) {
6423 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6424 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6425 svn_swig_rb_handle_svn_error(result);
6426 }
6427 vresult = Qnil;
6428 }
6429 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6430 {
6431 VALUE target;
6432 target = _global_vresult_address == &vresult ? self : vresult;
6433 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6434 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6435 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6436 }
6437 return vresult;
6438 fail:
6439 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6440 {
6441 VALUE target;
6442 target = _global_vresult_address == &vresult ? self : vresult;
6443 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6444 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6445 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6446 }
6447 return Qnil;
6448 }
6449
6450
6451 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_add_directory(int argc,VALUE * argv,VALUE self)6452 _wrap_svn_delta_editor_invoke_add_directory(int argc, VALUE *argv, VALUE self) {
6453 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
6454 char *arg2 = (char *) 0 ;
6455 void *arg3 = (void *) 0 ;
6456 char *arg4 = (char *) 0 ;
6457 svn_revnum_t arg5 ;
6458 apr_pool_t *arg6 = (apr_pool_t *) 0 ;
6459 void **arg7 = (void **) 0 ;
6460 VALUE _global_svn_swig_rb_pool ;
6461 apr_pool_t *_global_pool ;
6462 void *argp1 = 0 ;
6463 int res1 = 0 ;
6464 int res2 ;
6465 char *buf2 = 0 ;
6466 int alloc2 = 0 ;
6467 int res3 ;
6468 long val5 ;
6469 int ecode5 = 0 ;
6470 void *temp7 ;
6471 svn_error_t *result = 0 ;
6472 VALUE vresult = Qnil;
6473
6474 {
6475 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg6);
6476 _global_pool = arg6;
6477 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
6478 }
6479 arg7 = &temp7;
6480 if ((argc < 5) || (argc > 6)) {
6481 rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
6482 }
6483 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
6484 if (!SWIG_IsOK(res1)) {
6485 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_add_directory", 1, argv[0] ));
6486 }
6487 arg1 = (svn_delta_editor_t *)(argp1);
6488 res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
6489 if (!SWIG_IsOK(res2)) {
6490 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_delta_editor_invoke_add_directory", 2, argv[1] ));
6491 }
6492 arg2 = (char *)(buf2);
6493 res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
6494 if (!SWIG_IsOK(res3)) {
6495 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_add_directory", 3, argv[2] ));
6496 }
6497 {
6498 if (NIL_P(argv[3])) {
6499 arg4 = NULL;
6500 } else {
6501 arg4 = StringValuePtr(argv[3]);
6502 }
6503 }
6504 ecode5 = SWIG_AsVal_long(argv[4], &val5);
6505 if (!SWIG_IsOK(ecode5)) {
6506 SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "svn_revnum_t","svn_delta_editor_invoke_add_directory", 5, argv[4] ));
6507 }
6508 arg5 = (svn_revnum_t)(val5);
6509 if (argc > 5) {
6510
6511 }
6512 {
6513 result = (svn_error_t *)svn_delta_editor_invoke_add_directory(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,arg6,arg7);
6514
6515
6516
6517 }
6518 {
6519 if (result) {
6520 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6521 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6522 svn_swig_rb_handle_svn_error(result);
6523 }
6524 vresult = Qnil;
6525 }
6526 {
6527 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg7, SWIGTYPE_p_void, 0));
6528 }
6529 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6530 {
6531 VALUE target;
6532 target = _global_vresult_address == &vresult ? self : vresult;
6533 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6534 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6535 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6536 }
6537 return vresult;
6538 fail:
6539 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6540 {
6541 VALUE target;
6542 target = _global_vresult_address == &vresult ? self : vresult;
6543 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6544 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6545 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6546 }
6547 return Qnil;
6548 }
6549
6550
6551 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_open_directory(int argc,VALUE * argv,VALUE self)6552 _wrap_svn_delta_editor_invoke_open_directory(int argc, VALUE *argv, VALUE self) {
6553 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
6554 char *arg2 = (char *) 0 ;
6555 void *arg3 = (void *) 0 ;
6556 svn_revnum_t arg4 ;
6557 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
6558 void **arg6 = (void **) 0 ;
6559 VALUE _global_svn_swig_rb_pool ;
6560 apr_pool_t *_global_pool ;
6561 void *argp1 = 0 ;
6562 int res1 = 0 ;
6563 int res2 ;
6564 char *buf2 = 0 ;
6565 int alloc2 = 0 ;
6566 int res3 ;
6567 long val4 ;
6568 int ecode4 = 0 ;
6569 void *temp6 ;
6570 svn_error_t *result = 0 ;
6571 VALUE vresult = Qnil;
6572
6573 {
6574 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
6575 _global_pool = arg5;
6576 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
6577 }
6578 arg6 = &temp6;
6579 if ((argc < 4) || (argc > 5)) {
6580 rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
6581 }
6582 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
6583 if (!SWIG_IsOK(res1)) {
6584 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_open_directory", 1, argv[0] ));
6585 }
6586 arg1 = (svn_delta_editor_t *)(argp1);
6587 res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
6588 if (!SWIG_IsOK(res2)) {
6589 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_delta_editor_invoke_open_directory", 2, argv[1] ));
6590 }
6591 arg2 = (char *)(buf2);
6592 res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
6593 if (!SWIG_IsOK(res3)) {
6594 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_open_directory", 3, argv[2] ));
6595 }
6596 ecode4 = SWIG_AsVal_long(argv[3], &val4);
6597 if (!SWIG_IsOK(ecode4)) {
6598 SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "svn_revnum_t","svn_delta_editor_invoke_open_directory", 4, argv[3] ));
6599 }
6600 arg4 = (svn_revnum_t)(val4);
6601 if (argc > 4) {
6602
6603 }
6604 {
6605 result = (svn_error_t *)svn_delta_editor_invoke_open_directory(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
6606
6607
6608
6609 }
6610 {
6611 if (result) {
6612 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6613 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6614 svn_swig_rb_handle_svn_error(result);
6615 }
6616 vresult = Qnil;
6617 }
6618 {
6619 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg6, SWIGTYPE_p_void, 0));
6620 }
6621 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6622 {
6623 VALUE target;
6624 target = _global_vresult_address == &vresult ? self : vresult;
6625 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6626 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6627 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6628 }
6629 return vresult;
6630 fail:
6631 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6632 {
6633 VALUE target;
6634 target = _global_vresult_address == &vresult ? self : vresult;
6635 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6636 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6637 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6638 }
6639 return Qnil;
6640 }
6641
6642
6643 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_change_dir_prop(int argc,VALUE * argv,VALUE self)6644 _wrap_svn_delta_editor_invoke_change_dir_prop(int argc, VALUE *argv, VALUE self) {
6645 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
6646 void *arg2 = (void *) 0 ;
6647 char *arg3 = (char *) 0 ;
6648 svn_string_t *arg4 = (svn_string_t *) 0 ;
6649 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
6650 VALUE _global_svn_swig_rb_pool ;
6651 apr_pool_t *_global_pool ;
6652 void *argp1 = 0 ;
6653 int res1 = 0 ;
6654 int res2 ;
6655 int res3 ;
6656 char *buf3 = 0 ;
6657 int alloc3 = 0 ;
6658 svn_string_t value4 ;
6659 svn_error_t *result = 0 ;
6660 VALUE vresult = Qnil;
6661
6662 {
6663 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
6664 _global_pool = arg5;
6665 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
6666 }
6667 if ((argc < 4) || (argc > 5)) {
6668 rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
6669 }
6670 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
6671 if (!SWIG_IsOK(res1)) {
6672 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_change_dir_prop", 1, argv[0] ));
6673 }
6674 arg1 = (svn_delta_editor_t *)(argp1);
6675 res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
6676 if (!SWIG_IsOK(res2)) {
6677 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_change_dir_prop", 2, argv[1] ));
6678 }
6679 res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
6680 if (!SWIG_IsOK(res3)) {
6681 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","svn_delta_editor_invoke_change_dir_prop", 3, argv[2] ));
6682 }
6683 arg3 = (char *)(buf3);
6684 {
6685 if (NIL_P(argv[3])) {
6686 arg4 = NULL;
6687 } else {
6688 value4.data = StringValuePtr(argv[3]);
6689 value4.len = RSTRING_LEN(argv[3]);
6690 arg4 = &value4;
6691 }
6692 }
6693 if (argc > 4) {
6694
6695 }
6696 {
6697 result = (svn_error_t *)svn_delta_editor_invoke_change_dir_prop(arg1,arg2,(char const *)arg3,(struct svn_string_t const *)arg4,arg5);
6698
6699
6700
6701 }
6702 {
6703 if (result) {
6704 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6705 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6706 svn_swig_rb_handle_svn_error(result);
6707 }
6708 vresult = Qnil;
6709 }
6710 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
6711 {
6712 VALUE target;
6713 target = _global_vresult_address == &vresult ? self : vresult;
6714 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6715 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6716 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6717 }
6718 return vresult;
6719 fail:
6720 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
6721 {
6722 VALUE target;
6723 target = _global_vresult_address == &vresult ? self : vresult;
6724 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6725 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6726 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6727 }
6728 return Qnil;
6729 }
6730
6731
6732 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_close_directory(int argc,VALUE * argv,VALUE self)6733 _wrap_svn_delta_editor_invoke_close_directory(int argc, VALUE *argv, VALUE self) {
6734 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
6735 void *arg2 = (void *) 0 ;
6736 apr_pool_t *arg3 = (apr_pool_t *) 0 ;
6737 VALUE _global_svn_swig_rb_pool ;
6738 apr_pool_t *_global_pool ;
6739 void *argp1 = 0 ;
6740 int res1 = 0 ;
6741 int res2 ;
6742 svn_error_t *result = 0 ;
6743 VALUE vresult = Qnil;
6744
6745 {
6746 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
6747 _global_pool = arg3;
6748 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
6749 }
6750 if ((argc < 2) || (argc > 3)) {
6751 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
6752 }
6753 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
6754 if (!SWIG_IsOK(res1)) {
6755 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_close_directory", 1, argv[0] ));
6756 }
6757 arg1 = (svn_delta_editor_t *)(argp1);
6758 res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
6759 if (!SWIG_IsOK(res2)) {
6760 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_close_directory", 2, argv[1] ));
6761 }
6762 if (argc > 2) {
6763
6764 }
6765 {
6766 result = (svn_error_t *)svn_delta_editor_invoke_close_directory(arg1,arg2,arg3);
6767
6768
6769
6770 }
6771 {
6772 if (result) {
6773 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6774 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6775 svn_swig_rb_handle_svn_error(result);
6776 }
6777 vresult = Qnil;
6778 }
6779 {
6780 VALUE target;
6781 target = _global_vresult_address == &vresult ? self : vresult;
6782 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6783 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6784 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6785 }
6786 return vresult;
6787 fail:
6788 {
6789 VALUE target;
6790 target = _global_vresult_address == &vresult ? self : vresult;
6791 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6792 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6793 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6794 }
6795 return Qnil;
6796 }
6797
6798
6799 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_absent_directory(int argc,VALUE * argv,VALUE self)6800 _wrap_svn_delta_editor_invoke_absent_directory(int argc, VALUE *argv, VALUE self) {
6801 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
6802 char *arg2 = (char *) 0 ;
6803 void *arg3 = (void *) 0 ;
6804 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
6805 VALUE _global_svn_swig_rb_pool ;
6806 apr_pool_t *_global_pool ;
6807 void *argp1 = 0 ;
6808 int res1 = 0 ;
6809 int res2 ;
6810 char *buf2 = 0 ;
6811 int alloc2 = 0 ;
6812 int res3 ;
6813 svn_error_t *result = 0 ;
6814 VALUE vresult = Qnil;
6815
6816 {
6817 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
6818 _global_pool = arg4;
6819 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
6820 }
6821 if ((argc < 3) || (argc > 4)) {
6822 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
6823 }
6824 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
6825 if (!SWIG_IsOK(res1)) {
6826 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_absent_directory", 1, argv[0] ));
6827 }
6828 arg1 = (svn_delta_editor_t *)(argp1);
6829 res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
6830 if (!SWIG_IsOK(res2)) {
6831 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_delta_editor_invoke_absent_directory", 2, argv[1] ));
6832 }
6833 arg2 = (char *)(buf2);
6834 res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
6835 if (!SWIG_IsOK(res3)) {
6836 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_absent_directory", 3, argv[2] ));
6837 }
6838 if (argc > 3) {
6839
6840 }
6841 {
6842 result = (svn_error_t *)svn_delta_editor_invoke_absent_directory(arg1,(char const *)arg2,arg3,arg4);
6843
6844
6845
6846 }
6847 {
6848 if (result) {
6849 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6850 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6851 svn_swig_rb_handle_svn_error(result);
6852 }
6853 vresult = Qnil;
6854 }
6855 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6856 {
6857 VALUE target;
6858 target = _global_vresult_address == &vresult ? self : vresult;
6859 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6860 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6861 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6862 }
6863 return vresult;
6864 fail:
6865 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6866 {
6867 VALUE target;
6868 target = _global_vresult_address == &vresult ? self : vresult;
6869 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6870 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6871 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6872 }
6873 return Qnil;
6874 }
6875
6876
6877 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_add_file(int argc,VALUE * argv,VALUE self)6878 _wrap_svn_delta_editor_invoke_add_file(int argc, VALUE *argv, VALUE self) {
6879 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
6880 char *arg2 = (char *) 0 ;
6881 void *arg3 = (void *) 0 ;
6882 char *arg4 = (char *) 0 ;
6883 svn_revnum_t arg5 ;
6884 apr_pool_t *arg6 = (apr_pool_t *) 0 ;
6885 void **arg7 = (void **) 0 ;
6886 VALUE _global_svn_swig_rb_pool ;
6887 apr_pool_t *_global_pool ;
6888 void *argp1 = 0 ;
6889 int res1 = 0 ;
6890 int res2 ;
6891 char *buf2 = 0 ;
6892 int alloc2 = 0 ;
6893 int res3 ;
6894 long val5 ;
6895 int ecode5 = 0 ;
6896 void *temp7 ;
6897 svn_error_t *result = 0 ;
6898 VALUE vresult = Qnil;
6899
6900 {
6901 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg6);
6902 _global_pool = arg6;
6903 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
6904 }
6905 arg7 = &temp7;
6906 if ((argc < 5) || (argc > 6)) {
6907 rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
6908 }
6909 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
6910 if (!SWIG_IsOK(res1)) {
6911 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_add_file", 1, argv[0] ));
6912 }
6913 arg1 = (svn_delta_editor_t *)(argp1);
6914 res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
6915 if (!SWIG_IsOK(res2)) {
6916 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_delta_editor_invoke_add_file", 2, argv[1] ));
6917 }
6918 arg2 = (char *)(buf2);
6919 res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
6920 if (!SWIG_IsOK(res3)) {
6921 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_add_file", 3, argv[2] ));
6922 }
6923 {
6924 if (NIL_P(argv[3])) {
6925 arg4 = NULL;
6926 } else {
6927 arg4 = StringValuePtr(argv[3]);
6928 }
6929 }
6930 ecode5 = SWIG_AsVal_long(argv[4], &val5);
6931 if (!SWIG_IsOK(ecode5)) {
6932 SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "svn_revnum_t","svn_delta_editor_invoke_add_file", 5, argv[4] ));
6933 }
6934 arg5 = (svn_revnum_t)(val5);
6935 if (argc > 5) {
6936
6937 }
6938 {
6939 result = (svn_error_t *)svn_delta_editor_invoke_add_file(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,arg6,arg7);
6940
6941
6942
6943 }
6944 {
6945 if (result) {
6946 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6947 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6948 svn_swig_rb_handle_svn_error(result);
6949 }
6950 vresult = Qnil;
6951 }
6952 {
6953 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg7, SWIGTYPE_p_void, 0));
6954 }
6955 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6956 {
6957 VALUE target;
6958 target = _global_vresult_address == &vresult ? self : vresult;
6959 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6960 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6961 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6962 }
6963 return vresult;
6964 fail:
6965 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6966 {
6967 VALUE target;
6968 target = _global_vresult_address == &vresult ? self : vresult;
6969 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
6970 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
6971 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
6972 }
6973 return Qnil;
6974 }
6975
6976
6977 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_open_file(int argc,VALUE * argv,VALUE self)6978 _wrap_svn_delta_editor_invoke_open_file(int argc, VALUE *argv, VALUE self) {
6979 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
6980 char *arg2 = (char *) 0 ;
6981 void *arg3 = (void *) 0 ;
6982 svn_revnum_t arg4 ;
6983 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
6984 void **arg6 = (void **) 0 ;
6985 VALUE _global_svn_swig_rb_pool ;
6986 apr_pool_t *_global_pool ;
6987 void *argp1 = 0 ;
6988 int res1 = 0 ;
6989 int res2 ;
6990 char *buf2 = 0 ;
6991 int alloc2 = 0 ;
6992 int res3 ;
6993 long val4 ;
6994 int ecode4 = 0 ;
6995 void *temp6 ;
6996 svn_error_t *result = 0 ;
6997 VALUE vresult = Qnil;
6998
6999 {
7000 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
7001 _global_pool = arg5;
7002 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
7003 }
7004 arg6 = &temp6;
7005 if ((argc < 4) || (argc > 5)) {
7006 rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
7007 }
7008 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
7009 if (!SWIG_IsOK(res1)) {
7010 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_open_file", 1, argv[0] ));
7011 }
7012 arg1 = (svn_delta_editor_t *)(argp1);
7013 res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
7014 if (!SWIG_IsOK(res2)) {
7015 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_delta_editor_invoke_open_file", 2, argv[1] ));
7016 }
7017 arg2 = (char *)(buf2);
7018 res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
7019 if (!SWIG_IsOK(res3)) {
7020 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_open_file", 3, argv[2] ));
7021 }
7022 ecode4 = SWIG_AsVal_long(argv[3], &val4);
7023 if (!SWIG_IsOK(ecode4)) {
7024 SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "svn_revnum_t","svn_delta_editor_invoke_open_file", 4, argv[3] ));
7025 }
7026 arg4 = (svn_revnum_t)(val4);
7027 if (argc > 4) {
7028
7029 }
7030 {
7031 result = (svn_error_t *)svn_delta_editor_invoke_open_file(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
7032
7033
7034
7035 }
7036 {
7037 if (result) {
7038 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7039 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7040 svn_swig_rb_handle_svn_error(result);
7041 }
7042 vresult = Qnil;
7043 }
7044 {
7045 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg6, SWIGTYPE_p_void, 0));
7046 }
7047 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7048 {
7049 VALUE target;
7050 target = _global_vresult_address == &vresult ? self : vresult;
7051 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7052 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7053 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7054 }
7055 return vresult;
7056 fail:
7057 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7058 {
7059 VALUE target;
7060 target = _global_vresult_address == &vresult ? self : vresult;
7061 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7062 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7063 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7064 }
7065 return Qnil;
7066 }
7067
7068
7069 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_apply_textdelta(int argc,VALUE * argv,VALUE self)7070 _wrap_svn_delta_editor_invoke_apply_textdelta(int argc, VALUE *argv, VALUE self) {
7071 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
7072 void *arg2 = (void *) 0 ;
7073 char *arg3 = (char *) 0 ;
7074 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
7075 svn_txdelta_window_handler_t *arg5 = (svn_txdelta_window_handler_t *) 0 ;
7076 void **arg6 = (void **) 0 ;
7077 VALUE _global_svn_swig_rb_pool ;
7078 apr_pool_t *_global_pool ;
7079 void *argp1 = 0 ;
7080 int res1 = 0 ;
7081 int res2 ;
7082 svn_txdelta_window_handler_t temp5 ;
7083 void *temp6 ;
7084 svn_error_t *result = 0 ;
7085 VALUE vresult = Qnil;
7086
7087 {
7088 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
7089 _global_pool = arg4;
7090 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
7091 }
7092 arg5 = &temp5;
7093 arg6 = &temp6;
7094 if ((argc < 3) || (argc > 4)) {
7095 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
7096 }
7097 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
7098 if (!SWIG_IsOK(res1)) {
7099 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_apply_textdelta", 1, argv[0] ));
7100 }
7101 arg1 = (svn_delta_editor_t *)(argp1);
7102 res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
7103 if (!SWIG_IsOK(res2)) {
7104 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_apply_textdelta", 2, argv[1] ));
7105 }
7106 {
7107 if (NIL_P(argv[2])) {
7108 arg3 = NULL;
7109 } else {
7110 arg3 = StringValuePtr(argv[2]);
7111 }
7112 }
7113 if (argc > 3) {
7114
7115 }
7116 {
7117 result = (svn_error_t *)svn_delta_editor_invoke_apply_textdelta(arg1,arg2,(char const *)arg3,arg4,arg5,arg6);
7118
7119
7120
7121 }
7122 {
7123 if (result) {
7124 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7125 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7126 svn_swig_rb_handle_svn_error(result);
7127 }
7128 vresult = Qnil;
7129 }
7130 {
7131 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg5, SWIGTYPE_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, 0));
7132 }
7133 {
7134 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg6, SWIGTYPE_p_void, 0));
7135 }
7136 {
7137 VALUE target;
7138 target = _global_vresult_address == &vresult ? self : vresult;
7139 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7140 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7141 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7142 }
7143 return vresult;
7144 fail:
7145 {
7146 VALUE target;
7147 target = _global_vresult_address == &vresult ? self : vresult;
7148 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7149 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7150 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7151 }
7152 return Qnil;
7153 }
7154
7155
7156 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_change_file_prop(int argc,VALUE * argv,VALUE self)7157 _wrap_svn_delta_editor_invoke_change_file_prop(int argc, VALUE *argv, VALUE self) {
7158 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
7159 void *arg2 = (void *) 0 ;
7160 char *arg3 = (char *) 0 ;
7161 svn_string_t *arg4 = (svn_string_t *) 0 ;
7162 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
7163 VALUE _global_svn_swig_rb_pool ;
7164 apr_pool_t *_global_pool ;
7165 void *argp1 = 0 ;
7166 int res1 = 0 ;
7167 int res2 ;
7168 int res3 ;
7169 char *buf3 = 0 ;
7170 int alloc3 = 0 ;
7171 svn_string_t value4 ;
7172 svn_error_t *result = 0 ;
7173 VALUE vresult = Qnil;
7174
7175 {
7176 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
7177 _global_pool = arg5;
7178 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
7179 }
7180 if ((argc < 4) || (argc > 5)) {
7181 rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
7182 }
7183 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
7184 if (!SWIG_IsOK(res1)) {
7185 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_change_file_prop", 1, argv[0] ));
7186 }
7187 arg1 = (svn_delta_editor_t *)(argp1);
7188 res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
7189 if (!SWIG_IsOK(res2)) {
7190 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_change_file_prop", 2, argv[1] ));
7191 }
7192 res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
7193 if (!SWIG_IsOK(res3)) {
7194 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","svn_delta_editor_invoke_change_file_prop", 3, argv[2] ));
7195 }
7196 arg3 = (char *)(buf3);
7197 {
7198 if (NIL_P(argv[3])) {
7199 arg4 = NULL;
7200 } else {
7201 value4.data = StringValuePtr(argv[3]);
7202 value4.len = RSTRING_LEN(argv[3]);
7203 arg4 = &value4;
7204 }
7205 }
7206 if (argc > 4) {
7207
7208 }
7209 {
7210 result = (svn_error_t *)svn_delta_editor_invoke_change_file_prop(arg1,arg2,(char const *)arg3,(struct svn_string_t const *)arg4,arg5);
7211
7212
7213
7214 }
7215 {
7216 if (result) {
7217 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7218 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7219 svn_swig_rb_handle_svn_error(result);
7220 }
7221 vresult = Qnil;
7222 }
7223 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7224 {
7225 VALUE target;
7226 target = _global_vresult_address == &vresult ? self : vresult;
7227 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7228 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7229 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7230 }
7231 return vresult;
7232 fail:
7233 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7234 {
7235 VALUE target;
7236 target = _global_vresult_address == &vresult ? self : vresult;
7237 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7238 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7239 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7240 }
7241 return Qnil;
7242 }
7243
7244
7245 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_close_file(int argc,VALUE * argv,VALUE self)7246 _wrap_svn_delta_editor_invoke_close_file(int argc, VALUE *argv, VALUE self) {
7247 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
7248 void *arg2 = (void *) 0 ;
7249 char *arg3 = (char *) 0 ;
7250 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
7251 VALUE _global_svn_swig_rb_pool ;
7252 apr_pool_t *_global_pool ;
7253 void *argp1 = 0 ;
7254 int res1 = 0 ;
7255 int res2 ;
7256 svn_error_t *result = 0 ;
7257 VALUE vresult = Qnil;
7258
7259 {
7260 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
7261 _global_pool = arg4;
7262 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
7263 }
7264 if ((argc < 3) || (argc > 4)) {
7265 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
7266 }
7267 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
7268 if (!SWIG_IsOK(res1)) {
7269 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_close_file", 1, argv[0] ));
7270 }
7271 arg1 = (svn_delta_editor_t *)(argp1);
7272 res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
7273 if (!SWIG_IsOK(res2)) {
7274 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_close_file", 2, argv[1] ));
7275 }
7276 {
7277 if (NIL_P(argv[2])) {
7278 arg3 = NULL;
7279 } else {
7280 arg3 = StringValuePtr(argv[2]);
7281 }
7282 }
7283 if (argc > 3) {
7284
7285 }
7286 {
7287 result = (svn_error_t *)svn_delta_editor_invoke_close_file(arg1,arg2,(char const *)arg3,arg4);
7288
7289
7290
7291 }
7292 {
7293 if (result) {
7294 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7295 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7296 svn_swig_rb_handle_svn_error(result);
7297 }
7298 vresult = Qnil;
7299 }
7300 {
7301 VALUE target;
7302 target = _global_vresult_address == &vresult ? self : vresult;
7303 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7304 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7305 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7306 }
7307 return vresult;
7308 fail:
7309 {
7310 VALUE target;
7311 target = _global_vresult_address == &vresult ? self : vresult;
7312 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7313 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7314 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7315 }
7316 return Qnil;
7317 }
7318
7319
7320 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_absent_file(int argc,VALUE * argv,VALUE self)7321 _wrap_svn_delta_editor_invoke_absent_file(int argc, VALUE *argv, VALUE self) {
7322 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
7323 char *arg2 = (char *) 0 ;
7324 void *arg3 = (void *) 0 ;
7325 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
7326 VALUE _global_svn_swig_rb_pool ;
7327 apr_pool_t *_global_pool ;
7328 void *argp1 = 0 ;
7329 int res1 = 0 ;
7330 int res2 ;
7331 char *buf2 = 0 ;
7332 int alloc2 = 0 ;
7333 int res3 ;
7334 svn_error_t *result = 0 ;
7335 VALUE vresult = Qnil;
7336
7337 {
7338 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
7339 _global_pool = arg4;
7340 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
7341 }
7342 if ((argc < 3) || (argc > 4)) {
7343 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
7344 }
7345 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
7346 if (!SWIG_IsOK(res1)) {
7347 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_absent_file", 1, argv[0] ));
7348 }
7349 arg1 = (svn_delta_editor_t *)(argp1);
7350 res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
7351 if (!SWIG_IsOK(res2)) {
7352 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_delta_editor_invoke_absent_file", 2, argv[1] ));
7353 }
7354 arg2 = (char *)(buf2);
7355 res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
7356 if (!SWIG_IsOK(res3)) {
7357 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_absent_file", 3, argv[2] ));
7358 }
7359 if (argc > 3) {
7360
7361 }
7362 {
7363 result = (svn_error_t *)svn_delta_editor_invoke_absent_file(arg1,(char const *)arg2,arg3,arg4);
7364
7365
7366
7367 }
7368 {
7369 if (result) {
7370 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7371 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7372 svn_swig_rb_handle_svn_error(result);
7373 }
7374 vresult = Qnil;
7375 }
7376 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7377 {
7378 VALUE target;
7379 target = _global_vresult_address == &vresult ? self : vresult;
7380 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7381 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7382 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7383 }
7384 return vresult;
7385 fail:
7386 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7387 {
7388 VALUE target;
7389 target = _global_vresult_address == &vresult ? self : vresult;
7390 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7391 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7392 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7393 }
7394 return Qnil;
7395 }
7396
7397
7398 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_close_edit(int argc,VALUE * argv,VALUE self)7399 _wrap_svn_delta_editor_invoke_close_edit(int argc, VALUE *argv, VALUE self) {
7400 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
7401 void *arg2 = (void *) 0 ;
7402 apr_pool_t *arg3 = (apr_pool_t *) 0 ;
7403 VALUE _global_svn_swig_rb_pool ;
7404 apr_pool_t *_global_pool ;
7405 void *argp1 = 0 ;
7406 int res1 = 0 ;
7407 int res2 ;
7408 svn_error_t *result = 0 ;
7409 VALUE vresult = Qnil;
7410
7411 {
7412 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
7413 _global_pool = arg3;
7414 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
7415 }
7416 if ((argc < 2) || (argc > 3)) {
7417 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
7418 }
7419 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
7420 if (!SWIG_IsOK(res1)) {
7421 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_close_edit", 1, argv[0] ));
7422 }
7423 arg1 = (svn_delta_editor_t *)(argp1);
7424 res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
7425 if (!SWIG_IsOK(res2)) {
7426 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_close_edit", 2, argv[1] ));
7427 }
7428 if (argc > 2) {
7429
7430 }
7431 {
7432 result = (svn_error_t *)svn_delta_editor_invoke_close_edit(arg1,arg2,arg3);
7433
7434
7435
7436 }
7437 {
7438 if (result) {
7439 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7440 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7441 svn_swig_rb_handle_svn_error(result);
7442 }
7443 vresult = Qnil;
7444 }
7445 {
7446 VALUE target;
7447 target = _global_vresult_address == &vresult ? self : vresult;
7448 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7449 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7450 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7451 }
7452 return vresult;
7453 fail:
7454 {
7455 VALUE target;
7456 target = _global_vresult_address == &vresult ? self : vresult;
7457 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7458 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7459 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7460 }
7461 return Qnil;
7462 }
7463
7464
7465 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_abort_edit(int argc,VALUE * argv,VALUE self)7466 _wrap_svn_delta_editor_invoke_abort_edit(int argc, VALUE *argv, VALUE self) {
7467 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
7468 void *arg2 = (void *) 0 ;
7469 apr_pool_t *arg3 = (apr_pool_t *) 0 ;
7470 VALUE _global_svn_swig_rb_pool ;
7471 apr_pool_t *_global_pool ;
7472 void *argp1 = 0 ;
7473 int res1 = 0 ;
7474 int res2 ;
7475 svn_error_t *result = 0 ;
7476 VALUE vresult = Qnil;
7477
7478 {
7479 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
7480 _global_pool = arg3;
7481 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
7482 }
7483 if ((argc < 2) || (argc > 3)) {
7484 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
7485 }
7486 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
7487 if (!SWIG_IsOK(res1)) {
7488 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_abort_edit", 1, argv[0] ));
7489 }
7490 arg1 = (svn_delta_editor_t *)(argp1);
7491 res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
7492 if (!SWIG_IsOK(res2)) {
7493 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_abort_edit", 2, argv[1] ));
7494 }
7495 if (argc > 2) {
7496
7497 }
7498 {
7499 result = (svn_error_t *)svn_delta_editor_invoke_abort_edit(arg1,arg2,arg3);
7500
7501
7502
7503 }
7504 {
7505 if (result) {
7506 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7507 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7508 svn_swig_rb_handle_svn_error(result);
7509 }
7510 vresult = Qnil;
7511 }
7512 {
7513 VALUE target;
7514 target = _global_vresult_address == &vresult ? self : vresult;
7515 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7516 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7517 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7518 }
7519 return vresult;
7520 fail:
7521 {
7522 VALUE target;
7523 target = _global_vresult_address == &vresult ? self : vresult;
7524 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7525 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7526 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7527 }
7528 return Qnil;
7529 }
7530
7531
7532 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_apply_textdelta_stream(int argc,VALUE * argv,VALUE self)7533 _wrap_svn_delta_editor_invoke_apply_textdelta_stream(int argc, VALUE *argv, VALUE self) {
7534 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
7535 struct svn_delta_editor_t *arg2 = (struct svn_delta_editor_t *) 0 ;
7536 void *arg3 = (void *) 0 ;
7537 char *arg4 = (char *) 0 ;
7538 svn_txdelta_stream_open_func_t arg5 = (svn_txdelta_stream_open_func_t) 0 ;
7539 void *arg6 = (void *) 0 ;
7540 apr_pool_t *arg7 = (apr_pool_t *) 0 ;
7541 VALUE _global_svn_swig_rb_pool ;
7542 apr_pool_t *_global_pool ;
7543 void *argp1 = 0 ;
7544 int res1 = 0 ;
7545 void *argp2 = 0 ;
7546 int res2 = 0 ;
7547 int res3 ;
7548 int res6 ;
7549 svn_error_t *result = 0 ;
7550 VALUE vresult = Qnil;
7551
7552 {
7553 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
7554 _global_pool = arg7;
7555 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
7556 }
7557 if ((argc < 6) || (argc > 7)) {
7558 rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
7559 }
7560 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
7561 if (!SWIG_IsOK(res1)) {
7562 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_apply_textdelta_stream", 1, argv[0] ));
7563 }
7564 arg1 = (svn_delta_editor_t *)(argp1);
7565 res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
7566 if (!SWIG_IsOK(res2)) {
7567 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "struct svn_delta_editor_t const *","svn_delta_editor_invoke_apply_textdelta_stream", 2, argv[1] ));
7568 }
7569 arg2 = (struct svn_delta_editor_t *)(argp2);
7570 res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
7571 if (!SWIG_IsOK(res3)) {
7572 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_apply_textdelta_stream", 3, argv[2] ));
7573 }
7574 {
7575 if (NIL_P(argv[3])) {
7576 arg4 = NULL;
7577 } else {
7578 arg4 = StringValuePtr(argv[3]);
7579 }
7580 }
7581 {
7582 int res = SWIG_ConvertFunctionPtr(argv[4], (void**)(&arg5), SWIGTYPE_p_f_p_p_svn_txdelta_stream_t_p_void_p_apr_pool_t_p_apr_pool_t__p_svn_error_t);
7583 if (!SWIG_IsOK(res)) {
7584 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_txdelta_stream_open_func_t","svn_delta_editor_invoke_apply_textdelta_stream", 5, argv[4] ));
7585 }
7586 }
7587 res6 = SWIG_ConvertPtr(argv[5],SWIG_as_voidptrptr(&arg6), 0, 0);
7588 if (!SWIG_IsOK(res6)) {
7589 SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_apply_textdelta_stream", 6, argv[5] ));
7590 }
7591 if (argc > 6) {
7592
7593 }
7594 {
7595 result = (svn_error_t *)svn_delta_editor_invoke_apply_textdelta_stream(arg1,(struct svn_delta_editor_t const *)arg2,arg3,(char const *)arg4,arg5,arg6,arg7);
7596
7597
7598
7599 }
7600 {
7601 if (result) {
7602 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7603 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7604 svn_swig_rb_handle_svn_error(result);
7605 }
7606 vresult = Qnil;
7607 }
7608 {
7609 VALUE target;
7610 target = _global_vresult_address == &vresult ? self : vresult;
7611 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7612 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7613 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7614 }
7615 return vresult;
7616 fail:
7617 {
7618 VALUE target;
7619 target = _global_vresult_address == &vresult ? self : vresult;
7620 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7621 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7622 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7623 }
7624 return Qnil;
7625 }
7626
7627
7628 SWIGINTERN VALUE
_wrap_svn_txdelta_invoke_window_handler(int argc,VALUE * argv,VALUE self)7629 _wrap_svn_txdelta_invoke_window_handler(int argc, VALUE *argv, VALUE self) {
7630 svn_txdelta_window_handler_t arg1 = (svn_txdelta_window_handler_t) 0 ;
7631 svn_txdelta_window_t *arg2 = (svn_txdelta_window_t *) 0 ;
7632 void *arg3 = (void *) 0 ;
7633 void *argp2 = 0 ;
7634 int res2 = 0 ;
7635 int res3 ;
7636 svn_error_t *result = 0 ;
7637 VALUE vresult = Qnil;
7638
7639 if ((argc < 3) || (argc > 3)) {
7640 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
7641 }
7642 {
7643 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t);
7644 if (!SWIG_IsOK(res)) {
7645 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_txdelta_window_handler_t","svn_txdelta_invoke_window_handler", 1, argv[0] ));
7646 }
7647 }
7648 res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
7649 if (!SWIG_IsOK(res2)) {
7650 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "svn_txdelta_window_t *","svn_txdelta_invoke_window_handler", 2, argv[1] ));
7651 }
7652 arg2 = (svn_txdelta_window_t *)(argp2);
7653 res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
7654 if (!SWIG_IsOK(res3)) {
7655 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_txdelta_invoke_window_handler", 3, argv[2] ));
7656 }
7657 {
7658 result = (svn_error_t *)svn_txdelta_invoke_window_handler(arg1,arg2,arg3);
7659
7660
7661
7662 }
7663 {
7664 if (result) {
7665 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7666 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7667 svn_swig_rb_handle_svn_error(result);
7668 }
7669 vresult = Qnil;
7670 }
7671 return vresult;
7672 fail:
7673 return Qnil;
7674 }
7675
7676
7677 SWIGINTERN VALUE
_wrap_svn_txdelta_invoke_next_window_fn(int argc,VALUE * argv,VALUE self)7678 _wrap_svn_txdelta_invoke_next_window_fn(int argc, VALUE *argv, VALUE self) {
7679 svn_txdelta_next_window_fn_t arg1 = (svn_txdelta_next_window_fn_t) 0 ;
7680 svn_txdelta_window_t **arg2 = (svn_txdelta_window_t **) 0 ;
7681 void *arg3 = (void *) 0 ;
7682 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
7683 VALUE _global_svn_swig_rb_pool ;
7684 apr_pool_t *_global_pool ;
7685 svn_txdelta_window_t *temp2 ;
7686 int res3 ;
7687 svn_error_t *result = 0 ;
7688 VALUE vresult = Qnil;
7689
7690 {
7691 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
7692 _global_pool = arg4;
7693 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
7694 }
7695 arg2 = &temp2;
7696 if ((argc < 2) || (argc > 3)) {
7697 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
7698 }
7699 {
7700 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_p_svn_txdelta_window_t_p_void_p_apr_pool_t__p_svn_error_t);
7701 if (!SWIG_IsOK(res)) {
7702 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_txdelta_next_window_fn_t","svn_txdelta_invoke_next_window_fn", 1, argv[0] ));
7703 }
7704 }
7705 res3 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg3), 0, 0);
7706 if (!SWIG_IsOK(res3)) {
7707 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_txdelta_invoke_next_window_fn", 3, argv[1] ));
7708 }
7709 if (argc > 2) {
7710
7711 }
7712 {
7713 result = (svn_error_t *)svn_txdelta_invoke_next_window_fn(arg1,arg2,arg3,arg4);
7714
7715
7716
7717 }
7718 {
7719 if (result) {
7720 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7721 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7722 svn_swig_rb_handle_svn_error(result);
7723 }
7724 vresult = Qnil;
7725 }
7726 {
7727 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_svn_txdelta_window_t, 0));
7728 }
7729 {
7730 VALUE target;
7731 target = _global_vresult_address == &vresult ? self : vresult;
7732 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7733 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7734 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7735 }
7736 return vresult;
7737 fail:
7738 {
7739 VALUE target;
7740 target = _global_vresult_address == &vresult ? self : vresult;
7741 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7742 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7743 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7744 }
7745 return Qnil;
7746 }
7747
7748
7749 SWIGINTERN VALUE
_wrap_svn_txdelta_invoke_md5_digest_fn(int argc,VALUE * argv,VALUE self)7750 _wrap_svn_txdelta_invoke_md5_digest_fn(int argc, VALUE *argv, VALUE self) {
7751 svn_txdelta_md5_digest_fn_t arg1 = (svn_txdelta_md5_digest_fn_t) 0 ;
7752 void *arg2 = (void *) 0 ;
7753 int res2 ;
7754 unsigned char *result = 0 ;
7755 VALUE vresult = Qnil;
7756
7757 if ((argc < 2) || (argc > 2)) {
7758 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
7759 }
7760 {
7761 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_void__p_unsigned_char);
7762 if (!SWIG_IsOK(res)) {
7763 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_txdelta_md5_digest_fn_t","svn_txdelta_invoke_md5_digest_fn", 1, argv[0] ));
7764 }
7765 }
7766 res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
7767 if (!SWIG_IsOK(res2)) {
7768 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_txdelta_invoke_md5_digest_fn", 2, argv[1] ));
7769 }
7770 {
7771 result = (unsigned char *)svn_txdelta_invoke_md5_digest_fn((unsigned char const *(*)(void *))arg1,arg2);
7772
7773
7774
7775 }
7776 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
7777 return vresult;
7778 fail:
7779 return Qnil;
7780 }
7781
7782
7783 SWIGINTERN VALUE
_wrap_svn_txdelta_invoke_stream_open_func(int argc,VALUE * argv,VALUE self)7784 _wrap_svn_txdelta_invoke_stream_open_func(int argc, VALUE *argv, VALUE self) {
7785 svn_txdelta_stream_open_func_t arg1 = (svn_txdelta_stream_open_func_t) 0 ;
7786 svn_txdelta_stream_t **arg2 = (svn_txdelta_stream_t **) 0 ;
7787 void *arg3 = (void *) 0 ;
7788 apr_pool_t *arg4 = (apr_pool_t *) 0 ;
7789 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
7790 VALUE _global_svn_swig_rb_pool ;
7791 apr_pool_t *_global_pool ;
7792 svn_txdelta_stream_t *temp2 ;
7793 int res3 ;
7794 svn_error_t *result = 0 ;
7795 VALUE vresult = Qnil;
7796
7797 {
7798 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
7799 _global_pool = arg4;
7800 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
7801 }
7802 {
7803 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
7804 _global_pool = arg5;
7805 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
7806 }
7807 arg2 = &temp2;
7808 if ((argc < 2) || (argc > 4)) {
7809 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
7810 }
7811 {
7812 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_p_svn_txdelta_stream_t_p_void_p_apr_pool_t_p_apr_pool_t__p_svn_error_t);
7813 if (!SWIG_IsOK(res)) {
7814 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_txdelta_stream_open_func_t","svn_txdelta_invoke_stream_open_func", 1, argv[0] ));
7815 }
7816 }
7817 res3 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg3), 0, 0);
7818 if (!SWIG_IsOK(res3)) {
7819 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_txdelta_invoke_stream_open_func", 3, argv[1] ));
7820 }
7821 if (argc > 2) {
7822
7823 }
7824 if (argc > 3) {
7825
7826 }
7827 {
7828 result = (svn_error_t *)svn_txdelta_invoke_stream_open_func(arg1,arg2,arg3,arg4,arg5);
7829
7830
7831
7832 }
7833 {
7834 if (result) {
7835 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7836 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7837 svn_swig_rb_handle_svn_error(result);
7838 }
7839 vresult = Qnil;
7840 }
7841 {
7842 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_svn_txdelta_stream_t, 0));
7843 }
7844 {
7845 VALUE target;
7846 target = _global_vresult_address == &vresult ? self : vresult;
7847 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7848 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7849 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7850 }
7851 {
7852 VALUE target;
7853 target = _global_vresult_address == &vresult ? self : vresult;
7854 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7855 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7856 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7857 }
7858 return vresult;
7859 fail:
7860 {
7861 VALUE target;
7862 target = _global_vresult_address == &vresult ? self : vresult;
7863 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7864 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7865 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7866 }
7867 {
7868 VALUE target;
7869 target = _global_vresult_address == &vresult ? self : vresult;
7870 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7871 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7872 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7873 }
7874 return Qnil;
7875 }
7876
7877
7878 SWIGINTERN VALUE
_wrap_svn_delta_invoke_path_driver_cb_func2(int argc,VALUE * argv,VALUE self)7879 _wrap_svn_delta_invoke_path_driver_cb_func2(int argc, VALUE *argv, VALUE self) {
7880 svn_delta_path_driver_cb_func2_t arg1 = (svn_delta_path_driver_cb_func2_t) 0 ;
7881 void **arg2 = (void **) 0 ;
7882 svn_delta_editor_t *arg3 = (svn_delta_editor_t *) 0 ;
7883 void *arg4 = (void *) 0 ;
7884 void *arg5 = (void *) 0 ;
7885 void *arg6 = (void *) 0 ;
7886 char *arg7 = (char *) 0 ;
7887 apr_pool_t *arg8 = (apr_pool_t *) 0 ;
7888 VALUE _global_svn_swig_rb_pool ;
7889 apr_pool_t *_global_pool ;
7890 void *temp2 ;
7891 int res5 ;
7892 int res6 ;
7893 int res7 ;
7894 char *buf7 = 0 ;
7895 int alloc7 = 0 ;
7896 svn_error_t *result = 0 ;
7897 VALUE vresult = Qnil;
7898
7899 {
7900 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg8);
7901 _global_pool = arg8;
7902 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
7903 }
7904 arg2 = &temp2;
7905 if ((argc < 5) || (argc > 6)) {
7906 rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
7907 }
7908 {
7909 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_p_void_p_q_const__svn_delta_editor_t_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t);
7910 if (!SWIG_IsOK(res)) {
7911 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_delta_path_driver_cb_func2_t","svn_delta_invoke_path_driver_cb_func2", 1, argv[0] ));
7912 }
7913 }
7914 {
7915 if (RTEST(rb_obj_is_kind_of(argv[1],
7916 svn_swig_rb_svn_delta_editor()))) {
7917 arg3 = svn_swig_rb_to_swig_type(argv[1],
7918 "svn_delta_editor_t *",
7919 _global_pool);
7920 arg4 = svn_swig_rb_to_swig_type(rb_funcall(argv[1], rb_intern("baton"), 0),
7921 "void *", _global_pool);
7922 } else {
7923 svn_swig_rb_make_delta_editor(&arg3, &arg4, argv[1], _global_pool);
7924 }
7925 }
7926 res5 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg5), 0, 0);
7927 if (!SWIG_IsOK(res5)) {
7928 SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "void *","svn_delta_invoke_path_driver_cb_func2", 5, argv[2] ));
7929 }
7930 res6 = SWIG_ConvertPtr(argv[3],SWIG_as_voidptrptr(&arg6), 0, 0);
7931 if (!SWIG_IsOK(res6)) {
7932 SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "void *","svn_delta_invoke_path_driver_cb_func2", 6, argv[3] ));
7933 }
7934 res7 = SWIG_AsCharPtrAndSize(argv[4], &buf7, NULL, &alloc7);
7935 if (!SWIG_IsOK(res7)) {
7936 SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "char const *","svn_delta_invoke_path_driver_cb_func2", 7, argv[4] ));
7937 }
7938 arg7 = (char *)(buf7);
7939 if (argc > 5) {
7940
7941 }
7942 {
7943 result = (svn_error_t *)svn_delta_invoke_path_driver_cb_func2(arg1,arg2,(struct svn_delta_editor_t const *)arg3,arg4,arg5,arg6,(char const *)arg7,arg8);
7944
7945
7946
7947 }
7948 {
7949 if (result) {
7950 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7951 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7952 svn_swig_rb_handle_svn_error(result);
7953 }
7954 vresult = Qnil;
7955 }
7956 {
7957 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_void, 0));
7958 }
7959 if (alloc7 == SWIG_NEWOBJ) free((char*)buf7);
7960 {
7961 VALUE target;
7962 target = _global_vresult_address == &vresult ? self : vresult;
7963 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7964 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7965 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7966 }
7967 return vresult;
7968 fail:
7969 if (alloc7 == SWIG_NEWOBJ) free((char*)buf7);
7970 {
7971 VALUE target;
7972 target = _global_vresult_address == &vresult ? self : vresult;
7973 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
7974 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
7975 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
7976 }
7977 return Qnil;
7978 }
7979
7980
7981 SWIGINTERN VALUE
_wrap_svn_delta_invoke_path_driver_cb_func(int argc,VALUE * argv,VALUE self)7982 _wrap_svn_delta_invoke_path_driver_cb_func(int argc, VALUE *argv, VALUE self) {
7983 svn_delta_path_driver_cb_func_t arg1 = (svn_delta_path_driver_cb_func_t) 0 ;
7984 void **arg2 = (void **) 0 ;
7985 void *arg3 = (void *) 0 ;
7986 void *arg4 = (void *) 0 ;
7987 char *arg5 = (char *) 0 ;
7988 apr_pool_t *arg6 = (apr_pool_t *) 0 ;
7989 VALUE _global_svn_swig_rb_pool ;
7990 apr_pool_t *_global_pool ;
7991 void *temp2 ;
7992 int res3 ;
7993 int res4 ;
7994 int res5 ;
7995 char *buf5 = 0 ;
7996 int alloc5 = 0 ;
7997 svn_error_t *result = 0 ;
7998 VALUE vresult = Qnil;
7999
8000 {
8001 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg6);
8002 _global_pool = arg6;
8003 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
8004 }
8005 arg2 = &temp2;
8006 if ((argc < 4) || (argc > 5)) {
8007 rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
8008 }
8009 {
8010 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t);
8011 if (!SWIG_IsOK(res)) {
8012 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_delta_path_driver_cb_func_t","svn_delta_invoke_path_driver_cb_func", 1, argv[0] ));
8013 }
8014 }
8015 res3 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg3), 0, 0);
8016 if (!SWIG_IsOK(res3)) {
8017 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_delta_invoke_path_driver_cb_func", 3, argv[1] ));
8018 }
8019 res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
8020 if (!SWIG_IsOK(res4)) {
8021 SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","svn_delta_invoke_path_driver_cb_func", 4, argv[2] ));
8022 }
8023 res5 = SWIG_AsCharPtrAndSize(argv[3], &buf5, NULL, &alloc5);
8024 if (!SWIG_IsOK(res5)) {
8025 SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char const *","svn_delta_invoke_path_driver_cb_func", 5, argv[3] ));
8026 }
8027 arg5 = (char *)(buf5);
8028 if (argc > 4) {
8029
8030 }
8031 {
8032 result = (svn_error_t *)svn_delta_invoke_path_driver_cb_func(arg1,arg2,arg3,arg4,(char const *)arg5,arg6);
8033
8034
8035
8036 }
8037 {
8038 if (result) {
8039 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8040 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8041 svn_swig_rb_handle_svn_error(result);
8042 }
8043 vresult = Qnil;
8044 }
8045 {
8046 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg2, SWIGTYPE_p_void, 0));
8047 }
8048 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8049 {
8050 VALUE target;
8051 target = _global_vresult_address == &vresult ? self : vresult;
8052 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8053 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8054 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8055 }
8056 return vresult;
8057 fail:
8058 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8059 {
8060 VALUE target;
8061 target = _global_vresult_address == &vresult ? self : vresult;
8062 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8063 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8064 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8065 }
8066 return Qnil;
8067 }
8068
8069
8070 SWIGINTERN VALUE
_wrap_svn_file_invoke_rev_handler(int argc,VALUE * argv,VALUE self)8071 _wrap_svn_file_invoke_rev_handler(int argc, VALUE *argv, VALUE self) {
8072 svn_file_rev_handler_t arg1 = (svn_file_rev_handler_t) 0 ;
8073 void *arg2 = (void *) 0 ;
8074 char *arg3 = (char *) 0 ;
8075 svn_revnum_t arg4 ;
8076 apr_hash_t *arg5 = (apr_hash_t *) 0 ;
8077 svn_boolean_t arg6 ;
8078 svn_txdelta_window_handler_t *arg7 = (svn_txdelta_window_handler_t *) 0 ;
8079 void **arg8 = (void **) 0 ;
8080 apr_array_header_t *arg9 = (apr_array_header_t *) 0 ;
8081 apr_pool_t *arg10 = (apr_pool_t *) 0 ;
8082 VALUE _global_svn_swig_rb_pool ;
8083 apr_pool_t *_global_pool ;
8084 int res2 ;
8085 int res3 ;
8086 char *buf3 = 0 ;
8087 int alloc3 = 0 ;
8088 long val4 ;
8089 int ecode4 = 0 ;
8090 void *argp5 = 0 ;
8091 int res5 = 0 ;
8092 svn_txdelta_window_handler_t temp7 ;
8093 void *temp8 ;
8094 void *argp9 = 0 ;
8095 int res9 = 0 ;
8096 svn_error_t *result = 0 ;
8097 VALUE vresult = Qnil;
8098
8099 {
8100 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg10);
8101 _global_pool = arg10;
8102 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
8103 }
8104 arg7 = &temp7;
8105 arg8 = &temp8;
8106 if ((argc < 7) || (argc > 8)) {
8107 rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
8108 }
8109 {
8110 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t);
8111 if (!SWIG_IsOK(res)) {
8112 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_file_rev_handler_t","svn_file_invoke_rev_handler", 1, argv[0] ));
8113 }
8114 }
8115 res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
8116 if (!SWIG_IsOK(res2)) {
8117 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_file_invoke_rev_handler", 2, argv[1] ));
8118 }
8119 res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
8120 if (!SWIG_IsOK(res3)) {
8121 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","svn_file_invoke_rev_handler", 3, argv[2] ));
8122 }
8123 arg3 = (char *)(buf3);
8124 ecode4 = SWIG_AsVal_long(argv[3], &val4);
8125 if (!SWIG_IsOK(ecode4)) {
8126 SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "svn_revnum_t","svn_file_invoke_rev_handler", 4, argv[3] ));
8127 }
8128 arg4 = (svn_revnum_t)(val4);
8129 res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_apr_hash_t, 0 | 0 );
8130 if (!SWIG_IsOK(res5)) {
8131 SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "apr_hash_t *","svn_file_invoke_rev_handler", 5, argv[4] ));
8132 }
8133 arg5 = (apr_hash_t *)(argp5);
8134 arg6 = RTEST(argv[5]);
8135 res9 = SWIG_ConvertPtr(argv[6], &argp9,SWIGTYPE_p_apr_array_header_t, 0 | 0 );
8136 if (!SWIG_IsOK(res9)) {
8137 SWIG_exception_fail(SWIG_ArgError(res9), Ruby_Format_TypeError( "", "apr_array_header_t *","svn_file_invoke_rev_handler", 9, argv[6] ));
8138 }
8139 arg9 = (apr_array_header_t *)(argp9);
8140 if (argc > 7) {
8141
8142 }
8143 {
8144 result = (svn_error_t *)svn_file_invoke_rev_handler(arg1,arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
8145
8146
8147
8148 }
8149 {
8150 if (result) {
8151 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8152 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8153 svn_swig_rb_handle_svn_error(result);
8154 }
8155 vresult = Qnil;
8156 }
8157 {
8158 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg7, SWIGTYPE_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, 0));
8159 }
8160 {
8161 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg8, SWIGTYPE_p_void, 0));
8162 }
8163 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8164 {
8165 VALUE target;
8166 target = _global_vresult_address == &vresult ? self : vresult;
8167 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8168 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8169 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8170 }
8171 return vresult;
8172 fail:
8173 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8174 {
8175 VALUE target;
8176 target = _global_vresult_address == &vresult ? self : vresult;
8177 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8178 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8179 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8180 }
8181 return Qnil;
8182 }
8183
8184
8185 SWIGINTERN VALUE
_wrap_svn_file_invoke_rev_handler_old(int argc,VALUE * argv,VALUE self)8186 _wrap_svn_file_invoke_rev_handler_old(int argc, VALUE *argv, VALUE self) {
8187 svn_file_rev_handler_old_t arg1 = (svn_file_rev_handler_old_t) 0 ;
8188 void *arg2 = (void *) 0 ;
8189 char *arg3 = (char *) 0 ;
8190 svn_revnum_t arg4 ;
8191 apr_hash_t *arg5 = (apr_hash_t *) 0 ;
8192 svn_txdelta_window_handler_t *arg6 = (svn_txdelta_window_handler_t *) 0 ;
8193 void **arg7 = (void **) 0 ;
8194 apr_array_header_t *arg8 = (apr_array_header_t *) 0 ;
8195 apr_pool_t *arg9 = (apr_pool_t *) 0 ;
8196 VALUE _global_svn_swig_rb_pool ;
8197 apr_pool_t *_global_pool ;
8198 int res2 ;
8199 int res3 ;
8200 char *buf3 = 0 ;
8201 int alloc3 = 0 ;
8202 long val4 ;
8203 int ecode4 = 0 ;
8204 void *argp5 = 0 ;
8205 int res5 = 0 ;
8206 svn_txdelta_window_handler_t temp6 ;
8207 void *temp7 ;
8208 void *argp8 = 0 ;
8209 int res8 = 0 ;
8210 svn_error_t *result = 0 ;
8211 VALUE vresult = Qnil;
8212
8213 {
8214 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg9);
8215 _global_pool = arg9;
8216 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
8217 }
8218 arg6 = &temp6;
8219 arg7 = &temp7;
8220 if ((argc < 6) || (argc > 7)) {
8221 rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
8222 }
8223 {
8224 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t);
8225 if (!SWIG_IsOK(res)) {
8226 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_file_rev_handler_old_t","svn_file_invoke_rev_handler_old", 1, argv[0] ));
8227 }
8228 }
8229 res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
8230 if (!SWIG_IsOK(res2)) {
8231 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_file_invoke_rev_handler_old", 2, argv[1] ));
8232 }
8233 res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
8234 if (!SWIG_IsOK(res3)) {
8235 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","svn_file_invoke_rev_handler_old", 3, argv[2] ));
8236 }
8237 arg3 = (char *)(buf3);
8238 ecode4 = SWIG_AsVal_long(argv[3], &val4);
8239 if (!SWIG_IsOK(ecode4)) {
8240 SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "svn_revnum_t","svn_file_invoke_rev_handler_old", 4, argv[3] ));
8241 }
8242 arg4 = (svn_revnum_t)(val4);
8243 res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_apr_hash_t, 0 | 0 );
8244 if (!SWIG_IsOK(res5)) {
8245 SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "apr_hash_t *","svn_file_invoke_rev_handler_old", 5, argv[4] ));
8246 }
8247 arg5 = (apr_hash_t *)(argp5);
8248 res8 = SWIG_ConvertPtr(argv[5], &argp8,SWIGTYPE_p_apr_array_header_t, 0 | 0 );
8249 if (!SWIG_IsOK(res8)) {
8250 SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "apr_array_header_t *","svn_file_invoke_rev_handler_old", 8, argv[5] ));
8251 }
8252 arg8 = (apr_array_header_t *)(argp8);
8253 if (argc > 6) {
8254
8255 }
8256 {
8257 result = (svn_error_t *)svn_file_invoke_rev_handler_old(arg1,arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9);
8258
8259
8260
8261 }
8262 {
8263 if (result) {
8264 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8265 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8266 svn_swig_rb_handle_svn_error(result);
8267 }
8268 vresult = Qnil;
8269 }
8270 {
8271 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg6, SWIGTYPE_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, 0));
8272 }
8273 {
8274 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg7, SWIGTYPE_p_void, 0));
8275 }
8276 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8277 {
8278 VALUE target;
8279 target = _global_vresult_address == &vresult ? self : vresult;
8280 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8281 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8282 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8283 }
8284 return vresult;
8285 fail:
8286 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8287 {
8288 VALUE target;
8289 target = _global_vresult_address == &vresult ? self : vresult;
8290 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8291 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8292 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8293 }
8294 return Qnil;
8295 }
8296
8297
8298 SWIGINTERN VALUE
_wrap_svn_swig_rb_delta_editor_get_target_revision(int argc,VALUE * argv,VALUE self)8299 _wrap_svn_swig_rb_delta_editor_get_target_revision(int argc, VALUE *argv, VALUE self) {
8300 VALUE arg1 = (VALUE) 0 ;
8301 VALUE result;
8302 VALUE vresult = Qnil;
8303
8304 if ((argc < 1) || (argc > 1)) {
8305 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8306 }
8307 arg1 = argv[0];
8308 {
8309 result = (VALUE)svn_swig_rb_delta_editor_get_target_revision(arg1);
8310
8311
8312
8313 }
8314 vresult = result;
8315 return vresult;
8316 fail:
8317 return Qnil;
8318 }
8319
8320
8321 SWIGINTERN VALUE
_wrap_svn_swig_rb_txdelta_apply_instructions(int argc,VALUE * argv,VALUE self)8322 _wrap_svn_swig_rb_txdelta_apply_instructions(int argc, VALUE *argv, VALUE self) {
8323 svn_txdelta_window_t *arg1 = (svn_txdelta_window_t *) 0 ;
8324 char *arg2 = (char *) 0 ;
8325 void *argp1 = 0 ;
8326 int res1 = 0 ;
8327 int res2 ;
8328 char *buf2 = 0 ;
8329 int alloc2 = 0 ;
8330 VALUE result;
8331 VALUE vresult = Qnil;
8332
8333 if ((argc < 2) || (argc > 2)) {
8334 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
8335 }
8336 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
8337 if (!SWIG_IsOK(res1)) {
8338 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_txdelta_window_t *","svn_swig_rb_txdelta_apply_instructions", 1, argv[0] ));
8339 }
8340 arg1 = (svn_txdelta_window_t *)(argp1);
8341 res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
8342 if (!SWIG_IsOK(res2)) {
8343 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_swig_rb_txdelta_apply_instructions", 2, argv[1] ));
8344 }
8345 arg2 = (char *)(buf2);
8346 {
8347 result = (VALUE)svn_swig_rb_txdelta_apply_instructions(arg1,(char const *)arg2);
8348
8349
8350
8351 }
8352 vresult = result;
8353 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8354 return vresult;
8355 fail:
8356 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8357 return Qnil;
8358 }
8359
8360
8361 SWIGINTERN VALUE
_wrap_svn_txdelta_apply_wrapper(int argc,VALUE * argv,VALUE self)8362 _wrap_svn_txdelta_apply_wrapper(int argc, VALUE *argv, VALUE self) {
8363 svn_stream_t *arg1 = (svn_stream_t *) 0 ;
8364 svn_stream_t *arg2 = (svn_stream_t *) 0 ;
8365 unsigned char *arg3 = (unsigned char *) 0 ;
8366 char *arg4 = (char *) 0 ;
8367 svn_txdelta_window_handler_t *arg5 = (svn_txdelta_window_handler_t *) 0 ;
8368 void **arg6 = (void **) 0 ;
8369 apr_pool_t *arg7 = (apr_pool_t *) 0 ;
8370 VALUE _global_svn_swig_rb_pool ;
8371 apr_pool_t *_global_pool ;
8372 svn_txdelta_window_handler_t temp5 ;
8373 void *temp6 ;
8374 VALUE vresult = Qnil;
8375
8376 {
8377 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
8378 _global_pool = arg7;
8379 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
8380 }
8381 arg3 = NULL;
8382 arg5 = &temp5;
8383 arg6 = &temp6;
8384 if ((argc < 3) || (argc > 4)) {
8385 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
8386 }
8387 {
8388 arg1 = svn_swig_rb_make_stream(argv[0]);
8389 }
8390 {
8391 arg2 = svn_swig_rb_make_stream(argv[1]);
8392 }
8393 {
8394 if (NIL_P(argv[2])) {
8395 arg4 = NULL;
8396 } else {
8397 arg4 = StringValuePtr(argv[2]);
8398 }
8399 }
8400 if (argc > 3) {
8401
8402 }
8403 {
8404 svn_txdelta_apply_wrapper(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7);
8405
8406
8407
8408 }
8409 vresult = rb_ary_new();
8410 {
8411 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg5, SWIGTYPE_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, 0));
8412 }
8413 {
8414 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg6, SWIGTYPE_p_void, 0));
8415 }
8416 {
8417 VALUE target;
8418 target = _global_vresult_address == &vresult ? self : vresult;
8419 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8420 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8421 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8422 }
8423 return vresult;
8424 fail:
8425 {
8426 VALUE target;
8427 target = _global_vresult_address == &vresult ? self : vresult;
8428 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8429 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8430 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8431 }
8432 return Qnil;
8433 }
8434
8435
8436 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_open_root_wrapper(int argc,VALUE * argv,VALUE self)8437 _wrap_svn_delta_editor_invoke_open_root_wrapper(int argc, VALUE *argv, VALUE self) {
8438 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
8439 void *arg2 = (void *) 0 ;
8440 svn_revnum_t arg3 ;
8441 void **arg4 = (void **) 0 ;
8442 apr_pool_t *arg5 = (apr_pool_t *) 0 ;
8443 VALUE _global_svn_swig_rb_pool ;
8444 apr_pool_t *_global_pool ;
8445 void *argp1 = 0 ;
8446 int res1 = 0 ;
8447 int res2 ;
8448 long val3 ;
8449 int ecode3 = 0 ;
8450 void *temp4 ;
8451 svn_error_t *result = 0 ;
8452 VALUE vresult = Qnil;
8453
8454 {
8455 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg5);
8456 _global_pool = arg5;
8457 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
8458 }
8459 arg4 = &temp4;
8460 if ((argc < 3) || (argc > 4)) {
8461 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
8462 }
8463 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
8464 if (!SWIG_IsOK(res1)) {
8465 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_open_root_wrapper", 1, argv[0] ));
8466 }
8467 arg1 = (svn_delta_editor_t *)(argp1);
8468 res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
8469 if (!SWIG_IsOK(res2)) {
8470 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_open_root_wrapper", 2, argv[1] ));
8471 }
8472 ecode3 = SWIG_AsVal_long(argv[2], &val3);
8473 if (!SWIG_IsOK(ecode3)) {
8474 SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "svn_revnum_t","svn_delta_editor_invoke_open_root_wrapper", 3, argv[2] ));
8475 }
8476 arg3 = (svn_revnum_t)(val3);
8477 if (argc > 3) {
8478
8479 }
8480 {
8481 result = (svn_error_t *)svn_delta_editor_invoke_open_root_wrapper(arg1,arg2,arg3,arg4,arg5);
8482
8483
8484
8485 }
8486 {
8487 if (result) {
8488 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8489 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8490 svn_swig_rb_handle_svn_error(result);
8491 }
8492 vresult = Qnil;
8493 }
8494 {
8495 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg4, SWIGTYPE_p_void, 0));
8496 }
8497 {
8498 VALUE target;
8499 target = _global_vresult_address == &vresult ? self : vresult;
8500 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8501 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8502 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8503 }
8504 return vresult;
8505 fail:
8506 {
8507 VALUE target;
8508 target = _global_vresult_address == &vresult ? self : vresult;
8509 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8510 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8511 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8512 }
8513 return Qnil;
8514 }
8515
8516
8517 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_add_directory_wrapper(int argc,VALUE * argv,VALUE self)8518 _wrap_svn_delta_editor_invoke_add_directory_wrapper(int argc, VALUE *argv, VALUE self) {
8519 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
8520 char *arg2 = (char *) 0 ;
8521 void *arg3 = (void *) 0 ;
8522 char *arg4 = (char *) 0 ;
8523 svn_revnum_t arg5 ;
8524 void **arg6 = (void **) 0 ;
8525 apr_pool_t *arg7 = (apr_pool_t *) 0 ;
8526 VALUE _global_svn_swig_rb_pool ;
8527 apr_pool_t *_global_pool ;
8528 void *argp1 = 0 ;
8529 int res1 = 0 ;
8530 int res2 ;
8531 char *buf2 = 0 ;
8532 int alloc2 = 0 ;
8533 int res3 ;
8534 long val5 ;
8535 int ecode5 = 0 ;
8536 void *temp6 ;
8537 svn_error_t *result = 0 ;
8538 VALUE vresult = Qnil;
8539
8540 {
8541 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
8542 _global_pool = arg7;
8543 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
8544 }
8545 arg6 = &temp6;
8546 if ((argc < 5) || (argc > 6)) {
8547 rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
8548 }
8549 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
8550 if (!SWIG_IsOK(res1)) {
8551 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_add_directory_wrapper", 1, argv[0] ));
8552 }
8553 arg1 = (svn_delta_editor_t *)(argp1);
8554 res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
8555 if (!SWIG_IsOK(res2)) {
8556 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_delta_editor_invoke_add_directory_wrapper", 2, argv[1] ));
8557 }
8558 arg2 = (char *)(buf2);
8559 res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
8560 if (!SWIG_IsOK(res3)) {
8561 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_add_directory_wrapper", 3, argv[2] ));
8562 }
8563 {
8564 if (NIL_P(argv[3])) {
8565 arg4 = NULL;
8566 } else {
8567 arg4 = StringValuePtr(argv[3]);
8568 }
8569 }
8570 ecode5 = SWIG_AsVal_long(argv[4], &val5);
8571 if (!SWIG_IsOK(ecode5)) {
8572 SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "svn_revnum_t","svn_delta_editor_invoke_add_directory_wrapper", 5, argv[4] ));
8573 }
8574 arg5 = (svn_revnum_t)(val5);
8575 if (argc > 5) {
8576
8577 }
8578 {
8579 result = (svn_error_t *)svn_delta_editor_invoke_add_directory_wrapper(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,arg6,arg7);
8580
8581
8582
8583 }
8584 {
8585 if (result) {
8586 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8587 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8588 svn_swig_rb_handle_svn_error(result);
8589 }
8590 vresult = Qnil;
8591 }
8592 {
8593 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg6, SWIGTYPE_p_void, 0));
8594 }
8595 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8596 {
8597 VALUE target;
8598 target = _global_vresult_address == &vresult ? self : vresult;
8599 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8600 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8601 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8602 }
8603 return vresult;
8604 fail:
8605 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8606 {
8607 VALUE target;
8608 target = _global_vresult_address == &vresult ? self : vresult;
8609 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8610 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8611 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8612 }
8613 return Qnil;
8614 }
8615
8616
8617 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_open_directory_wrapper(int argc,VALUE * argv,VALUE self)8618 _wrap_svn_delta_editor_invoke_open_directory_wrapper(int argc, VALUE *argv, VALUE self) {
8619 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
8620 char *arg2 = (char *) 0 ;
8621 void *arg3 = (void *) 0 ;
8622 svn_revnum_t arg4 ;
8623 void **arg5 = (void **) 0 ;
8624 apr_pool_t *arg6 = (apr_pool_t *) 0 ;
8625 VALUE _global_svn_swig_rb_pool ;
8626 apr_pool_t *_global_pool ;
8627 void *argp1 = 0 ;
8628 int res1 = 0 ;
8629 int res2 ;
8630 char *buf2 = 0 ;
8631 int alloc2 = 0 ;
8632 int res3 ;
8633 long val4 ;
8634 int ecode4 = 0 ;
8635 void *temp5 ;
8636 svn_error_t *result = 0 ;
8637 VALUE vresult = Qnil;
8638
8639 {
8640 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg6);
8641 _global_pool = arg6;
8642 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
8643 }
8644 arg5 = &temp5;
8645 if ((argc < 4) || (argc > 5)) {
8646 rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
8647 }
8648 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
8649 if (!SWIG_IsOK(res1)) {
8650 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_open_directory_wrapper", 1, argv[0] ));
8651 }
8652 arg1 = (svn_delta_editor_t *)(argp1);
8653 res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
8654 if (!SWIG_IsOK(res2)) {
8655 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_delta_editor_invoke_open_directory_wrapper", 2, argv[1] ));
8656 }
8657 arg2 = (char *)(buf2);
8658 res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
8659 if (!SWIG_IsOK(res3)) {
8660 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_open_directory_wrapper", 3, argv[2] ));
8661 }
8662 ecode4 = SWIG_AsVal_long(argv[3], &val4);
8663 if (!SWIG_IsOK(ecode4)) {
8664 SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "svn_revnum_t","svn_delta_editor_invoke_open_directory_wrapper", 4, argv[3] ));
8665 }
8666 arg4 = (svn_revnum_t)(val4);
8667 if (argc > 4) {
8668
8669 }
8670 {
8671 result = (svn_error_t *)svn_delta_editor_invoke_open_directory_wrapper(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
8672
8673
8674
8675 }
8676 {
8677 if (result) {
8678 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8679 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8680 svn_swig_rb_handle_svn_error(result);
8681 }
8682 vresult = Qnil;
8683 }
8684 {
8685 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg5, SWIGTYPE_p_void, 0));
8686 }
8687 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8688 {
8689 VALUE target;
8690 target = _global_vresult_address == &vresult ? self : vresult;
8691 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8692 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8693 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8694 }
8695 return vresult;
8696 fail:
8697 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8698 {
8699 VALUE target;
8700 target = _global_vresult_address == &vresult ? self : vresult;
8701 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8702 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8703 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8704 }
8705 return Qnil;
8706 }
8707
8708
8709 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_add_file_wrapper(int argc,VALUE * argv,VALUE self)8710 _wrap_svn_delta_editor_invoke_add_file_wrapper(int argc, VALUE *argv, VALUE self) {
8711 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
8712 char *arg2 = (char *) 0 ;
8713 void *arg3 = (void *) 0 ;
8714 char *arg4 = (char *) 0 ;
8715 svn_revnum_t arg5 ;
8716 void **arg6 = (void **) 0 ;
8717 apr_pool_t *arg7 = (apr_pool_t *) 0 ;
8718 VALUE _global_svn_swig_rb_pool ;
8719 apr_pool_t *_global_pool ;
8720 void *argp1 = 0 ;
8721 int res1 = 0 ;
8722 int res2 ;
8723 char *buf2 = 0 ;
8724 int alloc2 = 0 ;
8725 int res3 ;
8726 long val5 ;
8727 int ecode5 = 0 ;
8728 void *temp6 ;
8729 svn_error_t *result = 0 ;
8730 VALUE vresult = Qnil;
8731
8732 {
8733 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
8734 _global_pool = arg7;
8735 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
8736 }
8737 arg6 = &temp6;
8738 if ((argc < 5) || (argc > 6)) {
8739 rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
8740 }
8741 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
8742 if (!SWIG_IsOK(res1)) {
8743 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_add_file_wrapper", 1, argv[0] ));
8744 }
8745 arg1 = (svn_delta_editor_t *)(argp1);
8746 res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
8747 if (!SWIG_IsOK(res2)) {
8748 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_delta_editor_invoke_add_file_wrapper", 2, argv[1] ));
8749 }
8750 arg2 = (char *)(buf2);
8751 res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
8752 if (!SWIG_IsOK(res3)) {
8753 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_add_file_wrapper", 3, argv[2] ));
8754 }
8755 {
8756 if (NIL_P(argv[3])) {
8757 arg4 = NULL;
8758 } else {
8759 arg4 = StringValuePtr(argv[3]);
8760 }
8761 }
8762 ecode5 = SWIG_AsVal_long(argv[4], &val5);
8763 if (!SWIG_IsOK(ecode5)) {
8764 SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "svn_revnum_t","svn_delta_editor_invoke_add_file_wrapper", 5, argv[4] ));
8765 }
8766 arg5 = (svn_revnum_t)(val5);
8767 if (argc > 5) {
8768
8769 }
8770 {
8771 result = (svn_error_t *)svn_delta_editor_invoke_add_file_wrapper(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,arg6,arg7);
8772
8773
8774
8775 }
8776 {
8777 if (result) {
8778 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8779 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8780 svn_swig_rb_handle_svn_error(result);
8781 }
8782 vresult = Qnil;
8783 }
8784 {
8785 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg6, SWIGTYPE_p_void, 0));
8786 }
8787 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8788 {
8789 VALUE target;
8790 target = _global_vresult_address == &vresult ? self : vresult;
8791 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8792 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8793 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8794 }
8795 return vresult;
8796 fail:
8797 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8798 {
8799 VALUE target;
8800 target = _global_vresult_address == &vresult ? self : vresult;
8801 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8802 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8803 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8804 }
8805 return Qnil;
8806 }
8807
8808
8809 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_open_file_wrapper(int argc,VALUE * argv,VALUE self)8810 _wrap_svn_delta_editor_invoke_open_file_wrapper(int argc, VALUE *argv, VALUE self) {
8811 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
8812 char *arg2 = (char *) 0 ;
8813 void *arg3 = (void *) 0 ;
8814 svn_revnum_t arg4 ;
8815 void **arg5 = (void **) 0 ;
8816 apr_pool_t *arg6 = (apr_pool_t *) 0 ;
8817 VALUE _global_svn_swig_rb_pool ;
8818 apr_pool_t *_global_pool ;
8819 void *argp1 = 0 ;
8820 int res1 = 0 ;
8821 int res2 ;
8822 char *buf2 = 0 ;
8823 int alloc2 = 0 ;
8824 int res3 ;
8825 long val4 ;
8826 int ecode4 = 0 ;
8827 void *temp5 ;
8828 svn_error_t *result = 0 ;
8829 VALUE vresult = Qnil;
8830
8831 {
8832 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg6);
8833 _global_pool = arg6;
8834 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
8835 }
8836 arg5 = &temp5;
8837 if ((argc < 4) || (argc > 5)) {
8838 rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
8839 }
8840 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
8841 if (!SWIG_IsOK(res1)) {
8842 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_open_file_wrapper", 1, argv[0] ));
8843 }
8844 arg1 = (svn_delta_editor_t *)(argp1);
8845 res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
8846 if (!SWIG_IsOK(res2)) {
8847 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_delta_editor_invoke_open_file_wrapper", 2, argv[1] ));
8848 }
8849 arg2 = (char *)(buf2);
8850 res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
8851 if (!SWIG_IsOK(res3)) {
8852 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_open_file_wrapper", 3, argv[2] ));
8853 }
8854 ecode4 = SWIG_AsVal_long(argv[3], &val4);
8855 if (!SWIG_IsOK(ecode4)) {
8856 SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "svn_revnum_t","svn_delta_editor_invoke_open_file_wrapper", 4, argv[3] ));
8857 }
8858 arg4 = (svn_revnum_t)(val4);
8859 if (argc > 4) {
8860
8861 }
8862 {
8863 result = (svn_error_t *)svn_delta_editor_invoke_open_file_wrapper(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
8864
8865
8866
8867 }
8868 {
8869 if (result) {
8870 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8871 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8872 svn_swig_rb_handle_svn_error(result);
8873 }
8874 vresult = Qnil;
8875 }
8876 {
8877 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg5, SWIGTYPE_p_void, 0));
8878 }
8879 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8880 {
8881 VALUE target;
8882 target = _global_vresult_address == &vresult ? self : vresult;
8883 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8884 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8885 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8886 }
8887 return vresult;
8888 fail:
8889 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8890 {
8891 VALUE target;
8892 target = _global_vresult_address == &vresult ? self : vresult;
8893 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8894 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8895 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8896 }
8897 return Qnil;
8898 }
8899
8900
8901 SWIGINTERN VALUE
_wrap_svn_delta_editor_invoke_apply_textdelta_wrapper(int argc,VALUE * argv,VALUE self)8902 _wrap_svn_delta_editor_invoke_apply_textdelta_wrapper(int argc, VALUE *argv, VALUE self) {
8903 svn_delta_editor_t *arg1 = (svn_delta_editor_t *) 0 ;
8904 void *arg2 = (void *) 0 ;
8905 char *arg3 = (char *) 0 ;
8906 svn_txdelta_window_handler_t *arg4 = (svn_txdelta_window_handler_t *) 0 ;
8907 void **arg5 = (void **) 0 ;
8908 apr_pool_t *arg6 = (apr_pool_t *) 0 ;
8909 VALUE _global_svn_swig_rb_pool ;
8910 apr_pool_t *_global_pool ;
8911 void *argp1 = 0 ;
8912 int res1 = 0 ;
8913 int res2 ;
8914 svn_txdelta_window_handler_t temp4 ;
8915 void *temp5 ;
8916 svn_error_t *result = 0 ;
8917 VALUE vresult = Qnil;
8918
8919 {
8920 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg6);
8921 _global_pool = arg6;
8922 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
8923 }
8924 arg4 = &temp4;
8925 arg5 = &temp5;
8926 if ((argc < 3) || (argc > 4)) {
8927 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
8928 }
8929 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_delta_editor_t, 0 | 0 );
8930 if (!SWIG_IsOK(res1)) {
8931 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_delta_editor_t *","svn_delta_editor_invoke_apply_textdelta_wrapper", 1, argv[0] ));
8932 }
8933 arg1 = (svn_delta_editor_t *)(argp1);
8934 res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
8935 if (!SWIG_IsOK(res2)) {
8936 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","svn_delta_editor_invoke_apply_textdelta_wrapper", 2, argv[1] ));
8937 }
8938 {
8939 if (NIL_P(argv[2])) {
8940 arg3 = NULL;
8941 } else {
8942 arg3 = StringValuePtr(argv[2]);
8943 }
8944 }
8945 if (argc > 3) {
8946
8947 }
8948 {
8949 result = (svn_error_t *)svn_delta_editor_invoke_apply_textdelta_wrapper(arg1,arg2,(char const *)arg3,arg4,arg5,arg6);
8950
8951
8952
8953 }
8954 {
8955 if (result) {
8956 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8957 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8958 svn_swig_rb_handle_svn_error(result);
8959 }
8960 vresult = Qnil;
8961 }
8962 {
8963 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg4, SWIGTYPE_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, 0));
8964 }
8965 {
8966 vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj(*arg5, SWIGTYPE_p_void, 0));
8967 }
8968 {
8969 VALUE target;
8970 target = _global_vresult_address == &vresult ? self : vresult;
8971 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8972 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8973 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8974 }
8975 return vresult;
8976 fail:
8977 {
8978 VALUE target;
8979 target = _global_vresult_address == &vresult ? self : vresult;
8980 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
8981 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
8982 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
8983 }
8984 return Qnil;
8985 }
8986
8987
8988 SWIGINTERN VALUE
_wrap_svn_txdelta_invoke_window_handler_wrapper(int argc,VALUE * argv,VALUE self)8989 _wrap_svn_txdelta_invoke_window_handler_wrapper(int argc, VALUE *argv, VALUE self) {
8990 VALUE arg1 = (VALUE) 0 ;
8991 svn_txdelta_window_t *arg2 = (svn_txdelta_window_t *) 0 ;
8992 apr_pool_t *arg3 = (apr_pool_t *) 0 ;
8993 VALUE _global_svn_swig_rb_pool ;
8994 apr_pool_t *_global_pool ;
8995 void *argp2 = 0 ;
8996 int res2 = 0 ;
8997 svn_error_t *result = 0 ;
8998 VALUE vresult = Qnil;
8999
9000 {
9001 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
9002 _global_pool = arg3;
9003 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
9004 }
9005 if ((argc < 2) || (argc > 3)) {
9006 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
9007 }
9008 arg1 = argv[0];
9009 res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
9010 if (!SWIG_IsOK(res2)) {
9011 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "svn_txdelta_window_t *","svn_txdelta_invoke_window_handler_wrapper", 2, argv[1] ));
9012 }
9013 arg2 = (svn_txdelta_window_t *)(argp2);
9014 if (argc > 2) {
9015
9016 }
9017 {
9018 result = (svn_error_t *)svn_txdelta_invoke_window_handler_wrapper(arg1,arg2,arg3);
9019
9020
9021
9022 }
9023 {
9024 if (result) {
9025 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
9026 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
9027 svn_swig_rb_handle_svn_error(result);
9028 }
9029 vresult = Qnil;
9030 }
9031 {
9032 VALUE target;
9033 target = _global_vresult_address == &vresult ? self : vresult;
9034 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
9035 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
9036 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
9037 }
9038 return vresult;
9039 fail:
9040 {
9041 VALUE target;
9042 target = _global_vresult_address == &vresult ? self : vresult;
9043 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
9044 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
9045 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
9046 }
9047 return Qnil;
9048 }
9049
9050
9051 SWIGINTERN VALUE
_wrap_svn_txdelta_editor_invoke_apply_textdelta_wrapper(int argc,VALUE * argv,VALUE self)9052 _wrap_svn_txdelta_editor_invoke_apply_textdelta_wrapper(int argc, VALUE *argv, VALUE self) {
9053 VALUE arg1 = (VALUE) 0 ;
9054 svn_txdelta_window_t *arg2 = (svn_txdelta_window_t *) 0 ;
9055 apr_pool_t *arg3 = (apr_pool_t *) 0 ;
9056 VALUE _global_svn_swig_rb_pool ;
9057 apr_pool_t *_global_pool ;
9058 void *argp2 = 0 ;
9059 int res2 = 0 ;
9060 svn_error_t *result = 0 ;
9061 VALUE vresult = Qnil;
9062
9063 {
9064 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
9065 _global_pool = arg3;
9066 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
9067 }
9068 if ((argc < 2) || (argc > 3)) {
9069 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
9070 }
9071 arg1 = argv[0];
9072 res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_svn_txdelta_window_t, 0 | 0 );
9073 if (!SWIG_IsOK(res2)) {
9074 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "svn_txdelta_window_t *","svn_txdelta_editor_invoke_apply_textdelta_wrapper", 2, argv[1] ));
9075 }
9076 arg2 = (svn_txdelta_window_t *)(argp2);
9077 if (argc > 2) {
9078
9079 }
9080 {
9081 result = (svn_error_t *)svn_txdelta_editor_invoke_apply_textdelta_wrapper(arg1,arg2,arg3);
9082
9083
9084
9085 }
9086 {
9087 if (result) {
9088 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
9089 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
9090 svn_swig_rb_handle_svn_error(result);
9091 }
9092 vresult = Qnil;
9093 }
9094 {
9095 VALUE target;
9096 target = _global_vresult_address == &vresult ? self : vresult;
9097 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
9098 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
9099 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
9100 }
9101 return vresult;
9102 fail:
9103 {
9104 VALUE target;
9105 target = _global_vresult_address == &vresult ? self : vresult;
9106 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
9107 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
9108 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
9109 }
9110 return Qnil;
9111 }
9112
9113
9114 SWIGINTERN VALUE
_wrap_svn_txdelta_md5_digest_as_cstring(int argc,VALUE * argv,VALUE self)9115 _wrap_svn_txdelta_md5_digest_as_cstring(int argc, VALUE *argv, VALUE self) {
9116 svn_txdelta_stream_t *arg1 = (svn_txdelta_stream_t *) 0 ;
9117 apr_pool_t *arg2 = (apr_pool_t *) 0 ;
9118 VALUE _global_svn_swig_rb_pool ;
9119 apr_pool_t *_global_pool ;
9120 void *argp1 = 0 ;
9121 int res1 = 0 ;
9122 char *result = 0 ;
9123 VALUE vresult = Qnil;
9124
9125 {
9126 svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg2);
9127 _global_pool = arg2;
9128 svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
9129 }
9130 if ((argc < 1) || (argc > 2)) {
9131 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9132 }
9133 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_txdelta_stream_t, 0 | 0 );
9134 if (!SWIG_IsOK(res1)) {
9135 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_txdelta_stream_t *","svn_txdelta_md5_digest_as_cstring", 1, argv[0] ));
9136 }
9137 arg1 = (svn_txdelta_stream_t *)(argp1);
9138 if (argc > 1) {
9139
9140 }
9141 {
9142 result = (char *)svn_txdelta_md5_digest_as_cstring(arg1,arg2);
9143
9144
9145
9146 }
9147 {
9148 if (result) {
9149 vresult = rb_str_new2(result);
9150 } else {
9151 vresult = Qnil;
9152 }
9153 }
9154 {
9155 VALUE target;
9156 target = _global_vresult_address == &vresult ? self : vresult;
9157 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
9158 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
9159 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
9160 }
9161 return vresult;
9162 fail:
9163 {
9164 VALUE target;
9165 target = _global_vresult_address == &vresult ? self : vresult;
9166 if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
9167 svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
9168 svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
9169 }
9170 return Qnil;
9171 }
9172
9173
9174
9175 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
9176
9177 static swig_type_info _swigt__p_apr_array_header_t = {"_p_apr_array_header_t", "apr_array_header_t *|svn_rangelist_t *", 0, 0, (void*)0, 0};
9178 static swig_type_info _swigt__p_apr_file_t = {"_p_apr_file_t", "apr_file_t *", 0, 0, (void*)0, 0};
9179 static swig_type_info _swigt__p_apr_hash_t = {"_p_apr_hash_t", "apr_hash_t *", 0, 0, (void*)0, 0};
9180 static swig_type_info _swigt__p_apr_int32_t = {"_p_apr_int32_t", "apr_int32_t *|time_t *", 0, 0, (void*)0, 0};
9181 static swig_type_info _swigt__p_apr_int64_t = {"_p_apr_int64_t", "apr_int64_t *|svn_filesize_t *|apr_time_t *", 0, 0, (void*)0, 0};
9182 static swig_type_info _swigt__p_apr_pool_t = {"_p_apr_pool_t", "apr_pool_t *", 0, 0, (void*)0, 0};
9183 static swig_type_info _swigt__p_apr_size_t = {"_p_apr_size_t", "apr_size_t *", 0, 0, (void*)0, 0};
9184 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
9185 static swig_type_info _swigt__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t", "svn_opt_subcommand_t *|svn_error_t *(*)(apr_getopt_t *,void *,apr_pool_t *)", 0, 0, (void*)0, 0};
9186 static swig_type_info _swigt__p_f_p_p_svn_txdelta_stream_t_p_void_p_apr_pool_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_p_svn_txdelta_stream_t_p_void_p_apr_pool_t_p_apr_pool_t__p_svn_error_t", "svn_error_t *(*)(svn_txdelta_stream_t **,void *,apr_pool_t *,apr_pool_t *)|svn_txdelta_stream_open_func_t", 0, 0, (void*)0, 0};
9187 static swig_type_info _swigt__p_f_p_p_svn_txdelta_window_t_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_p_svn_txdelta_window_t_p_void_p_apr_pool_t__p_svn_error_t", "svn_error_t *(*)(svn_txdelta_window_t **,void *,apr_pool_t *)|svn_txdelta_next_window_fn_t", 0, 0, (void*)0, 0};
9188 static swig_type_info _swigt__p_f_p_p_void_p_q_const__svn_delta_editor_t_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t = {"_p_f_p_p_void_p_q_const__svn_delta_editor_t_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t", "svn_delta_path_driver_cb_func2_t|svn_error_t *(*)(void **,svn_delta_editor_t const *,void *,void *,void *,char const *,apr_pool_t *)", 0, 0, (void*)0, 0};
9189 static swig_type_info _swigt__p_f_p_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t = {"_p_f_p_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t", "svn_delta_path_driver_cb_func_t|svn_error_t *(*)(void **,void *,void *,char const *,apr_pool_t *)", 0, 0, (void*)0, 0};
9190 static swig_type_info _swigt__p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t", "svn_error_t *(*)(char const *,void *,apr_pool_t *)", 0, 0, (void*)0, 0};
9191 static swig_type_info _swigt__p_f_p_q_const__char_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t = {"_p_f_p_q_const__char_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t", "svn_error_t *(*)(char const *,void *,char const *,svn_revnum_t,apr_pool_t *,void **)", 0, 0, (void*)0, 0};
9192 static swig_type_info _swigt__p_f_p_q_const__char_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t = {"_p_f_p_q_const__char_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t", "svn_error_t *(*)(char const *,void *,svn_revnum_t,apr_pool_t *,void **)", 0, 0, (void*)0, 0};
9193 static swig_type_info _swigt__p_f_p_q_const__char_svn_revnum_t_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_q_const__char_svn_revnum_t_p_void_p_apr_pool_t__p_svn_error_t", "svn_error_t *(*)(char const *,svn_revnum_t,void *,apr_pool_t *)", 0, 0, (void*)0, 0};
9194 static swig_type_info _swigt__p_f_p_q_const__struct_svn_delta_editor_t_p_void_p_q_const__char_svn_txdelta_stream_open_func_t_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_q_const__struct_svn_delta_editor_t_p_void_p_q_const__char_svn_txdelta_stream_open_func_t_p_void_p_apr_pool_t__p_svn_error_t", "svn_error_t *(*)(struct svn_delta_editor_t const *,void *,char const *,svn_txdelta_stream_open_func_t,void *,apr_pool_t *)", 0, 0, (void*)0, 0};
9195 static swig_type_info _swigt__p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t = {"_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t", "svn_error_t *(*)(svn_txdelta_window_t *,void *)|svn_txdelta_window_handler_t", 0, 0, (void*)0, 0};
9196 static swig_type_info _swigt__p_f_p_void__p_svn_error_t = {"_p_f_p_void__p_svn_error_t", "svn_cancel_func_t|svn_error_t *(*)(void *)", 0, 0, (void*)0, 0};
9197 static swig_type_info _swigt__p_f_p_void__p_unsigned_char = {"_p_f_p_void__p_unsigned_char", "unsigned char *(*)(void *)|svn_txdelta_md5_digest_fn_t", 0, 0, (void*)0, 0};
9198 static swig_type_info _swigt__p_f_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_apr_pool_t__p_svn_error_t", "svn_error_t *(*)(void *,apr_pool_t *)", 0, 0, (void*)0, 0};
9199 static swig_type_info _swigt__p_f_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t", "svn_error_t *(*)(void *,char const *,apr_pool_t *)", 0, 0, (void*)0, 0};
9200 static swig_type_info _swigt__p_f_p_void_p_q_const__char_p_apr_pool_t_p_svn_txdelta_window_handler_t_p_p_void__p_svn_error_t = {"_p_f_p_void_p_q_const__char_p_apr_pool_t_p_svn_txdelta_window_handler_t_p_p_void__p_svn_error_t", "svn_error_t *(*)(void *,char const *,apr_pool_t *,svn_txdelta_window_handler_t *,void **)", 0, 0, (void*)0, 0};
9201 static swig_type_info _swigt__p_f_p_void_p_q_const__char_p_q_const__svn_string_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_q_const__char_p_q_const__svn_string_t_p_apr_pool_t__p_svn_error_t", "svn_error_t *(*)(void *,char const *,svn_string_t const *,apr_pool_t *)", 0, 0, (void*)0, 0};
9202 static swig_type_info _swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t", "svn_file_rev_handler_old_t|svn_error_t *(*)(void *,char const *,svn_revnum_t,apr_hash_t *,svn_txdelta_window_handler_t *,void **,apr_array_header_t *,apr_pool_t *)", 0, 0, (void*)0, 0};
9203 static swig_type_info _swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t", "svn_error_t *(*)(void *,char const *,svn_revnum_t,apr_hash_t *,svn_boolean_t,svn_txdelta_window_handler_t *,void **,apr_array_header_t *,apr_pool_t *)|svn_file_rev_handler_t", 0, 0, (void*)0, 0};
9204 static swig_type_info _swigt__p_f_p_void_svn_revnum_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_svn_revnum_t_p_apr_pool_t__p_svn_error_t", "svn_error_t *(*)(void *,svn_revnum_t,apr_pool_t *)", 0, 0, (void*)0, 0};
9205 static swig_type_info _swigt__p_f_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t = {"_p_f_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t", "svn_error_t *(*)(void *,svn_revnum_t,apr_pool_t *,void **)", 0, 0, (void*)0, 0};
9206 static swig_type_info _swigt__p_int = {"_p_int", "int *|svn_boolean_t *|apr_status_t *", 0, 0, (void*)0, 0};
9207 static swig_type_info _swigt__p_long = {"_p_long", "long *|svn_revnum_t *", 0, 0, (void*)0, 0};
9208 static swig_type_info _swigt__p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t = {"_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t", "svn_error_t *(**)(svn_txdelta_window_t *,void *)|svn_txdelta_window_handler_t *", 0, 0, (void*)0, 0};
9209 static swig_type_info _swigt__p_p_svn_checksum_t = {"_p_p_svn_checksum_t", "struct svn_checksum_t **|svn_checksum_t **", 0, 0, (void*)0, 0};
9210 static swig_type_info _swigt__p_p_svn_delta_editor_t = {"_p_p_svn_delta_editor_t", "struct svn_delta_editor_t **|svn_delta_editor_t **", 0, 0, (void*)0, 0};
9211 static swig_type_info _swigt__p_p_svn_delta_path_driver_state_t = {"_p_p_svn_delta_path_driver_state_t", "struct svn_delta_path_driver_state_t **|svn_delta_path_driver_state_t **", 0, 0, (void*)0, 0};
9212 static swig_type_info _swigt__p_p_svn_txdelta_stream_t = {"_p_p_svn_txdelta_stream_t", "struct svn_txdelta_stream_t **|svn_txdelta_stream_t **", 0, 0, (void*)0, 0};
9213 static swig_type_info _swigt__p_p_svn_txdelta_window_t = {"_p_p_svn_txdelta_window_t", "struct svn_txdelta_window_t **|svn_txdelta_window_t **", 0, 0, (void*)0, 0};
9214 static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
9215 static swig_type_info _swigt__p_svn_auth_baton_t = {"_p_svn_auth_baton_t", "struct svn_auth_baton_t *|svn_auth_baton_t *", 0, 0, (void*)0, 0};
9216 static swig_type_info _swigt__p_svn_auth_cred_simple_t = {"_p_svn_auth_cred_simple_t", "struct svn_auth_cred_simple_t *|svn_auth_cred_simple_t *", 0, 0, (void*)0, 0};
9217 static swig_type_info _swigt__p_svn_auth_cred_ssl_client_cert_pw_t = {"_p_svn_auth_cred_ssl_client_cert_pw_t", "struct svn_auth_cred_ssl_client_cert_pw_t *|svn_auth_cred_ssl_client_cert_pw_t *", 0, 0, (void*)0, 0};
9218 static swig_type_info _swigt__p_svn_auth_cred_ssl_client_cert_t = {"_p_svn_auth_cred_ssl_client_cert_t", "struct svn_auth_cred_ssl_client_cert_t *|svn_auth_cred_ssl_client_cert_t *", 0, 0, (void*)0, 0};
9219 static swig_type_info _swigt__p_svn_auth_cred_ssl_server_trust_t = {"_p_svn_auth_cred_ssl_server_trust_t", "struct svn_auth_cred_ssl_server_trust_t *|svn_auth_cred_ssl_server_trust_t *", 0, 0, (void*)0, 0};
9220 static swig_type_info _swigt__p_svn_auth_cred_username_t = {"_p_svn_auth_cred_username_t", "struct svn_auth_cred_username_t *|svn_auth_cred_username_t *", 0, 0, (void*)0, 0};
9221 static swig_type_info _swigt__p_svn_auth_iterstate_t = {"_p_svn_auth_iterstate_t", "struct svn_auth_iterstate_t *|svn_auth_iterstate_t *", 0, 0, (void*)0, 0};
9222 static swig_type_info _swigt__p_svn_auth_provider_object_t = {"_p_svn_auth_provider_object_t", "struct svn_auth_provider_object_t *|svn_auth_provider_object_t *", 0, 0, (void*)0, 0};
9223 static swig_type_info _swigt__p_svn_auth_provider_t = {"_p_svn_auth_provider_t", "struct svn_auth_provider_t *|svn_auth_provider_t *", 0, 0, (void*)0, 0};
9224 static swig_type_info _swigt__p_svn_auth_ssl_server_cert_info_t = {"_p_svn_auth_ssl_server_cert_info_t", "struct svn_auth_ssl_server_cert_info_t *|svn_auth_ssl_server_cert_info_t *", 0, 0, (void*)0, 0};
9225 static swig_type_info _swigt__p_svn_cache_config_t = {"_p_svn_cache_config_t", "struct svn_cache_config_t *|svn_cache_config_t *", 0, 0, (void*)0, 0};
9226 static swig_type_info _swigt__p_svn_checksum_ctx_t = {"_p_svn_checksum_ctx_t", "struct svn_checksum_ctx_t *|svn_checksum_ctx_t *", 0, 0, (void*)0, 0};
9227 static swig_type_info _swigt__p_svn_checksum_kind_t = {"_p_svn_checksum_kind_t", "enum svn_checksum_kind_t *|svn_checksum_kind_t *", 0, 0, (void*)0, 0};
9228 static swig_type_info _swigt__p_svn_checksum_t = {"_p_svn_checksum_t", "struct svn_checksum_t *|svn_checksum_t *", 0, 0, (void*)0, 0};
9229 static swig_type_info _swigt__p_svn_commit_info_t = {"_p_svn_commit_info_t", "struct svn_commit_info_t *|svn_commit_info_t *", 0, 0, (void*)0, 0};
9230 static swig_type_info _swigt__p_svn_config_t = {"_p_svn_config_t", "struct svn_config_t *|svn_config_t *", 0, 0, (void*)0, 0};
9231 static swig_type_info _swigt__p_svn_delta_editor_t = {"_p_svn_delta_editor_t", "struct svn_delta_editor_t *|svn_delta_editor_t *", 0, 0, (void*)0, 0};
9232 static swig_type_info _swigt__p_svn_delta_path_driver_state_t = {"_p_svn_delta_path_driver_state_t", "struct svn_delta_path_driver_state_t *|svn_delta_path_driver_state_t *", 0, 0, (void*)0, 0};
9233 static swig_type_info _swigt__p_svn_depth_t = {"_p_svn_depth_t", "enum svn_depth_t *|svn_depth_t *", 0, 0, (void*)0, 0};
9234 static swig_type_info _swigt__p_svn_diff_binary_patch_t = {"_p_svn_diff_binary_patch_t", "struct svn_diff_binary_patch_t *|svn_diff_binary_patch_t *", 0, 0, (void*)0, 0};
9235 static swig_type_info _swigt__p_svn_diff_conflict_display_style_t = {"_p_svn_diff_conflict_display_style_t", "enum svn_diff_conflict_display_style_t *|svn_diff_conflict_display_style_t *", 0, 0, (void*)0, 0};
9236 static swig_type_info _swigt__p_svn_diff_datasource_e = {"_p_svn_diff_datasource_e", "enum svn_diff_datasource_e *|svn_diff_datasource_e *", 0, 0, (void*)0, 0};
9237 static swig_type_info _swigt__p_svn_diff_file_ignore_space_t = {"_p_svn_diff_file_ignore_space_t", "enum svn_diff_file_ignore_space_t *|svn_diff_file_ignore_space_t *", 0, 0, (void*)0, 0};
9238 static swig_type_info _swigt__p_svn_diff_file_options_t = {"_p_svn_diff_file_options_t", "struct svn_diff_file_options_t *|svn_diff_file_options_t *", 0, 0, (void*)0, 0};
9239 static swig_type_info _swigt__p_svn_diff_fns2_t = {"_p_svn_diff_fns2_t", "struct svn_diff_fns2_t *|svn_diff_fns2_t *", 0, 0, (void*)0, 0};
9240 static swig_type_info _swigt__p_svn_diff_fns_t = {"_p_svn_diff_fns_t", "struct svn_diff_fns_t *|svn_diff_fns_t *", 0, 0, (void*)0, 0};
9241 static swig_type_info _swigt__p_svn_diff_hunk_t = {"_p_svn_diff_hunk_t", "struct svn_diff_hunk_t *|svn_diff_hunk_t *", 0, 0, (void*)0, 0};
9242 static swig_type_info _swigt__p_svn_diff_operation_kind_e = {"_p_svn_diff_operation_kind_e", "svn_diff_operation_kind_t *|enum svn_diff_operation_kind_e *", 0, 0, (void*)0, 0};
9243 static swig_type_info _swigt__p_svn_diff_output_fns_t = {"_p_svn_diff_output_fns_t", "struct svn_diff_output_fns_t *|svn_diff_output_fns_t *", 0, 0, (void*)0, 0};
9244 static swig_type_info _swigt__p_svn_diff_t = {"_p_svn_diff_t", "struct svn_diff_t *|svn_diff_t *", 0, 0, (void*)0, 0};
9245 static swig_type_info _swigt__p_svn_dirent_t = {"_p_svn_dirent_t", "struct svn_dirent_t *|svn_dirent_t *", 0, 0, (void*)0, 0};
9246 static swig_type_info _swigt__p_svn_errno_t = {"_p_svn_errno_t", "enum svn_errno_t *|svn_errno_t *", 0, 0, (void*)0, 0};
9247 static swig_type_info _swigt__p_svn_error_t = {"_p_svn_error_t", "svn_error_t *", 0, 0, (void*)0, 0};
9248 static swig_type_info _swigt__p_svn_io_dirent2_t = {"_p_svn_io_dirent2_t", "struct svn_io_dirent2_t *|svn_io_dirent2_t *", 0, 0, (void*)0, 0};
9249 static swig_type_info _swigt__p_svn_io_dirent_t = {"_p_svn_io_dirent_t", "struct svn_io_dirent_t *|svn_io_dirent_t *", 0, 0, (void*)0, 0};
9250 static swig_type_info _swigt__p_svn_io_file_del_t = {"_p_svn_io_file_del_t", "enum svn_io_file_del_t *|svn_io_file_del_t *", 0, 0, (void*)0, 0};
9251 static swig_type_info _swigt__p_svn_location_segment_t = {"_p_svn_location_segment_t", "struct svn_location_segment_t *|svn_location_segment_t *", 0, 0, (void*)0, 0};
9252 static swig_type_info _swigt__p_svn_lock_t = {"_p_svn_lock_t", "struct svn_lock_t *|svn_lock_t *", 0, 0, (void*)0, 0};
9253 static swig_type_info _swigt__p_svn_log_changed_path2_t = {"_p_svn_log_changed_path2_t", "struct svn_log_changed_path2_t *|svn_log_changed_path2_t *", 0, 0, (void*)0, 0};
9254 static swig_type_info _swigt__p_svn_log_changed_path_t = {"_p_svn_log_changed_path_t", "struct svn_log_changed_path_t *|svn_log_changed_path_t *", 0, 0, (void*)0, 0};
9255 static swig_type_info _swigt__p_svn_log_entry_t = {"_p_svn_log_entry_t", "struct svn_log_entry_t *|svn_log_entry_t *", 0, 0, (void*)0, 0};
9256 static swig_type_info _swigt__p_svn_merge_range_t = {"_p_svn_merge_range_t", "struct svn_merge_range_t *|svn_merge_range_t *", 0, 0, (void*)0, 0};
9257 static swig_type_info _swigt__p_svn_mergeinfo_inheritance_t = {"_p_svn_mergeinfo_inheritance_t", "enum svn_mergeinfo_inheritance_t *|svn_mergeinfo_inheritance_t *", 0, 0, (void*)0, 0};
9258 static swig_type_info _swigt__p_svn_node_kind_t = {"_p_svn_node_kind_t", "enum svn_node_kind_t *|svn_node_kind_t *", 0, 0, (void*)0, 0};
9259 static swig_type_info _swigt__p_svn_opt_revision_range_t = {"_p_svn_opt_revision_range_t", "struct svn_opt_revision_range_t *|svn_opt_revision_range_t *", 0, 0, (void*)0, 0};
9260 static swig_type_info _swigt__p_svn_opt_revision_t = {"_p_svn_opt_revision_t", "struct svn_opt_revision_t *|svn_opt_revision_t *", 0, 0, (void*)0, 0};
9261 static swig_type_info _swigt__p_svn_opt_revision_value_t = {"_p_svn_opt_revision_value_t", "union svn_opt_revision_value_t *|svn_opt_revision_value_t *", 0, 0, (void*)0, 0};
9262 static swig_type_info _swigt__p_svn_opt_subcommand_desc2_t = {"_p_svn_opt_subcommand_desc2_t", "struct svn_opt_subcommand_desc2_t *|svn_opt_subcommand_desc2_t *", 0, 0, (void*)0, 0};
9263 static swig_type_info _swigt__p_svn_opt_subcommand_desc3_t = {"_p_svn_opt_subcommand_desc3_t", "struct svn_opt_subcommand_desc3_t *|svn_opt_subcommand_desc3_t *", 0, 0, (void*)0, 0};
9264 static swig_type_info _swigt__p_svn_opt_subcommand_desc_t = {"_p_svn_opt_subcommand_desc_t", "struct svn_opt_subcommand_desc_t *|svn_opt_subcommand_desc_t *", 0, 0, (void*)0, 0};
9265 static swig_type_info _swigt__p_svn_patch_file_t = {"_p_svn_patch_file_t", "struct svn_patch_file_t *|svn_patch_file_t *", 0, 0, (void*)0, 0};
9266 static swig_type_info _swigt__p_svn_patch_t = {"_p_svn_patch_t", "struct svn_patch_t *|svn_patch_t *", 0, 0, (void*)0, 0};
9267 static swig_type_info _swigt__p_svn_prop_inherited_item_t = {"_p_svn_prop_inherited_item_t", "struct svn_prop_inherited_item_t *|svn_prop_inherited_item_t *", 0, 0, (void*)0, 0};
9268 static swig_type_info _swigt__p_svn_prop_kind = {"_p_svn_prop_kind", "svn_prop_kind_t *|enum svn_prop_kind *", 0, 0, (void*)0, 0};
9269 static swig_type_info _swigt__p_svn_prop_patch_t = {"_p_svn_prop_patch_t", "struct svn_prop_patch_t *|svn_prop_patch_t *", 0, 0, (void*)0, 0};
9270 static swig_type_info _swigt__p_svn_stream_mark_t = {"_p_svn_stream_mark_t", "struct svn_stream_mark_t *|svn_stream_mark_t *", 0, 0, (void*)0, 0};
9271 static swig_type_info _swigt__p_svn_stream_t = {"_p_svn_stream_t", "struct svn_stream_t *|svn_stream_t *", 0, 0, (void*)0, 0};
9272 static swig_type_info _swigt__p_svn_string_t = {"_p_svn_string_t", "struct svn_string_t *|svn_string_t *", 0, 0, (void*)0, 0};
9273 static swig_type_info _swigt__p_svn_stringbuf_t = {"_p_svn_stringbuf_t", "struct svn_stringbuf_t *|svn_stringbuf_t *", 0, 0, (void*)0, 0};
9274 static swig_type_info _swigt__p_svn_tristate_t = {"_p_svn_tristate_t", "enum svn_tristate_t *|svn_tristate_t *", 0, 0, (void*)0, 0};
9275 static swig_type_info _swigt__p_svn_txdelta_op_t = {"_p_svn_txdelta_op_t", "struct svn_txdelta_op_t *|svn_txdelta_op_t *", 0, 0, (void*)0, 0};
9276 static swig_type_info _swigt__p_svn_txdelta_stream_t = {"_p_svn_txdelta_stream_t", "struct svn_txdelta_stream_t *|svn_txdelta_stream_t *", 0, 0, (void*)0, 0};
9277 static swig_type_info _swigt__p_svn_txdelta_window_t = {"_p_svn_txdelta_window_t", "struct svn_txdelta_window_t *|svn_txdelta_window_t *", 0, 0, (void*)0, 0};
9278 static swig_type_info _swigt__p_svn_version_checklist_t = {"_p_svn_version_checklist_t", "struct svn_version_checklist_t *|svn_version_checklist_t *", 0, 0, (void*)0, 0};
9279 static swig_type_info _swigt__p_svn_version_ext_linked_lib_t = {"_p_svn_version_ext_linked_lib_t", "struct svn_version_ext_linked_lib_t *|svn_version_ext_linked_lib_t *", 0, 0, (void*)0, 0};
9280 static swig_type_info _swigt__p_svn_version_ext_loaded_lib_t = {"_p_svn_version_ext_loaded_lib_t", "struct svn_version_ext_loaded_lib_t *|svn_version_ext_loaded_lib_t *", 0, 0, (void*)0, 0};
9281 static swig_type_info _swigt__p_svn_version_extended_t = {"_p_svn_version_extended_t", "struct svn_version_extended_t *|svn_version_extended_t *", 0, 0, (void*)0, 0};
9282 static swig_type_info _swigt__p_svn_version_t = {"_p_svn_version_t", "struct svn_version_t *|svn_version_t *", 0, 0, (void*)0, 0};
9283 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *", 0, 0, (void*)0, 0};
9284 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|svn_linenum_t *", 0, 0, (void*)0, 0};
9285 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
9286
9287 static swig_type_info *swig_type_initial[] = {
9288 &_swigt__p_apr_array_header_t,
9289 &_swigt__p_apr_file_t,
9290 &_swigt__p_apr_hash_t,
9291 &_swigt__p_apr_int32_t,
9292 &_swigt__p_apr_int64_t,
9293 &_swigt__p_apr_pool_t,
9294 &_swigt__p_apr_size_t,
9295 &_swigt__p_char,
9296 &_swigt__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t,
9297 &_swigt__p_f_p_p_svn_txdelta_stream_t_p_void_p_apr_pool_t_p_apr_pool_t__p_svn_error_t,
9298 &_swigt__p_f_p_p_svn_txdelta_window_t_p_void_p_apr_pool_t__p_svn_error_t,
9299 &_swigt__p_f_p_p_void_p_q_const__svn_delta_editor_t_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t,
9300 &_swigt__p_f_p_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t,
9301 &_swigt__p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t,
9302 &_swigt__p_f_p_q_const__char_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t,
9303 &_swigt__p_f_p_q_const__char_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t,
9304 &_swigt__p_f_p_q_const__char_svn_revnum_t_p_void_p_apr_pool_t__p_svn_error_t,
9305 &_swigt__p_f_p_q_const__struct_svn_delta_editor_t_p_void_p_q_const__char_svn_txdelta_stream_open_func_t_p_void_p_apr_pool_t__p_svn_error_t,
9306 &_swigt__p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
9307 &_swigt__p_f_p_void__p_svn_error_t,
9308 &_swigt__p_f_p_void__p_unsigned_char,
9309 &_swigt__p_f_p_void_p_apr_pool_t__p_svn_error_t,
9310 &_swigt__p_f_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t,
9311 &_swigt__p_f_p_void_p_q_const__char_p_apr_pool_t_p_svn_txdelta_window_handler_t_p_p_void__p_svn_error_t,
9312 &_swigt__p_f_p_void_p_q_const__char_p_q_const__svn_string_t_p_apr_pool_t__p_svn_error_t,
9313 &_swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t,
9314 &_swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t,
9315 &_swigt__p_f_p_void_svn_revnum_t_p_apr_pool_t__p_svn_error_t,
9316 &_swigt__p_f_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t,
9317 &_swigt__p_int,
9318 &_swigt__p_long,
9319 &_swigt__p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
9320 &_swigt__p_p_svn_checksum_t,
9321 &_swigt__p_p_svn_delta_editor_t,
9322 &_swigt__p_p_svn_delta_path_driver_state_t,
9323 &_swigt__p_p_svn_txdelta_stream_t,
9324 &_swigt__p_p_svn_txdelta_window_t,
9325 &_swigt__p_p_void,
9326 &_swigt__p_svn_auth_baton_t,
9327 &_swigt__p_svn_auth_cred_simple_t,
9328 &_swigt__p_svn_auth_cred_ssl_client_cert_pw_t,
9329 &_swigt__p_svn_auth_cred_ssl_client_cert_t,
9330 &_swigt__p_svn_auth_cred_ssl_server_trust_t,
9331 &_swigt__p_svn_auth_cred_username_t,
9332 &_swigt__p_svn_auth_iterstate_t,
9333 &_swigt__p_svn_auth_provider_object_t,
9334 &_swigt__p_svn_auth_provider_t,
9335 &_swigt__p_svn_auth_ssl_server_cert_info_t,
9336 &_swigt__p_svn_cache_config_t,
9337 &_swigt__p_svn_checksum_ctx_t,
9338 &_swigt__p_svn_checksum_kind_t,
9339 &_swigt__p_svn_checksum_t,
9340 &_swigt__p_svn_commit_info_t,
9341 &_swigt__p_svn_config_t,
9342 &_swigt__p_svn_delta_editor_t,
9343 &_swigt__p_svn_delta_path_driver_state_t,
9344 &_swigt__p_svn_depth_t,
9345 &_swigt__p_svn_diff_binary_patch_t,
9346 &_swigt__p_svn_diff_conflict_display_style_t,
9347 &_swigt__p_svn_diff_datasource_e,
9348 &_swigt__p_svn_diff_file_ignore_space_t,
9349 &_swigt__p_svn_diff_file_options_t,
9350 &_swigt__p_svn_diff_fns2_t,
9351 &_swigt__p_svn_diff_fns_t,
9352 &_swigt__p_svn_diff_hunk_t,
9353 &_swigt__p_svn_diff_operation_kind_e,
9354 &_swigt__p_svn_diff_output_fns_t,
9355 &_swigt__p_svn_diff_t,
9356 &_swigt__p_svn_dirent_t,
9357 &_swigt__p_svn_errno_t,
9358 &_swigt__p_svn_error_t,
9359 &_swigt__p_svn_io_dirent2_t,
9360 &_swigt__p_svn_io_dirent_t,
9361 &_swigt__p_svn_io_file_del_t,
9362 &_swigt__p_svn_location_segment_t,
9363 &_swigt__p_svn_lock_t,
9364 &_swigt__p_svn_log_changed_path2_t,
9365 &_swigt__p_svn_log_changed_path_t,
9366 &_swigt__p_svn_log_entry_t,
9367 &_swigt__p_svn_merge_range_t,
9368 &_swigt__p_svn_mergeinfo_inheritance_t,
9369 &_swigt__p_svn_node_kind_t,
9370 &_swigt__p_svn_opt_revision_range_t,
9371 &_swigt__p_svn_opt_revision_t,
9372 &_swigt__p_svn_opt_revision_value_t,
9373 &_swigt__p_svn_opt_subcommand_desc2_t,
9374 &_swigt__p_svn_opt_subcommand_desc3_t,
9375 &_swigt__p_svn_opt_subcommand_desc_t,
9376 &_swigt__p_svn_patch_file_t,
9377 &_swigt__p_svn_patch_t,
9378 &_swigt__p_svn_prop_inherited_item_t,
9379 &_swigt__p_svn_prop_kind,
9380 &_swigt__p_svn_prop_patch_t,
9381 &_swigt__p_svn_stream_mark_t,
9382 &_swigt__p_svn_stream_t,
9383 &_swigt__p_svn_string_t,
9384 &_swigt__p_svn_stringbuf_t,
9385 &_swigt__p_svn_tristate_t,
9386 &_swigt__p_svn_txdelta_op_t,
9387 &_swigt__p_svn_txdelta_stream_t,
9388 &_swigt__p_svn_txdelta_window_t,
9389 &_swigt__p_svn_version_checklist_t,
9390 &_swigt__p_svn_version_ext_linked_lib_t,
9391 &_swigt__p_svn_version_ext_loaded_lib_t,
9392 &_swigt__p_svn_version_extended_t,
9393 &_swigt__p_svn_version_t,
9394 &_swigt__p_unsigned_char,
9395 &_swigt__p_unsigned_long,
9396 &_swigt__p_void,
9397 };
9398
9399 static swig_cast_info _swigc__p_apr_array_header_t[] = { {&_swigt__p_apr_array_header_t, 0, 0, 0},{0, 0, 0, 0}};
9400 static swig_cast_info _swigc__p_apr_file_t[] = { {&_swigt__p_apr_file_t, 0, 0, 0},{0, 0, 0, 0}};
9401 static swig_cast_info _swigc__p_apr_hash_t[] = { {&_swigt__p_apr_hash_t, 0, 0, 0},{0, 0, 0, 0}};
9402 static swig_cast_info _swigc__p_apr_int32_t[] = { {&_swigt__p_apr_int32_t, 0, 0, 0},{0, 0, 0, 0}};
9403 static swig_cast_info _swigc__p_apr_int64_t[] = { {&_swigt__p_apr_int64_t, 0, 0, 0},{0, 0, 0, 0}};
9404 static swig_cast_info _swigc__p_apr_pool_t[] = { {&_swigt__p_apr_pool_t, 0, 0, 0},{0, 0, 0, 0}};
9405 static swig_cast_info _swigc__p_apr_size_t[] = { {&_swigt__p_apr_size_t, 0, 0, 0},{0, 0, 0, 0}};
9406 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
9407 static swig_cast_info _swigc__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9408 static swig_cast_info _swigc__p_f_p_p_svn_txdelta_stream_t_p_void_p_apr_pool_t_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_p_svn_txdelta_stream_t_p_void_p_apr_pool_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9409 static swig_cast_info _swigc__p_f_p_p_svn_txdelta_window_t_p_void_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_p_svn_txdelta_window_t_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9410 static swig_cast_info _swigc__p_f_p_p_void_p_q_const__svn_delta_editor_t_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_p_void_p_q_const__svn_delta_editor_t_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9411 static swig_cast_info _swigc__p_f_p_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9412 static swig_cast_info _swigc__p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9413 static swig_cast_info _swigc__p_f_p_q_const__char_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t[] = { {&_swigt__p_f_p_q_const__char_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9414 static swig_cast_info _swigc__p_f_p_q_const__char_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t[] = { {&_swigt__p_f_p_q_const__char_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9415 static swig_cast_info _swigc__p_f_p_q_const__char_svn_revnum_t_p_void_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_q_const__char_svn_revnum_t_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9416 static swig_cast_info _swigc__p_f_p_q_const__struct_svn_delta_editor_t_p_void_p_q_const__char_svn_txdelta_stream_open_func_t_p_void_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_q_const__struct_svn_delta_editor_t_p_void_p_q_const__char_svn_txdelta_stream_open_func_t_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9417 static swig_cast_info _swigc__p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t[] = { {&_swigt__p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9418 static swig_cast_info _swigc__p_f_p_void__p_svn_error_t[] = { {&_swigt__p_f_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9419 static swig_cast_info _swigc__p_f_p_void__p_unsigned_char[] = { {&_swigt__p_f_p_void__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
9420 static swig_cast_info _swigc__p_f_p_void_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9421 static swig_cast_info _swigc__p_f_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9422 static swig_cast_info _swigc__p_f_p_void_p_q_const__char_p_apr_pool_t_p_svn_txdelta_window_handler_t_p_p_void__p_svn_error_t[] = { {&_swigt__p_f_p_void_p_q_const__char_p_apr_pool_t_p_svn_txdelta_window_handler_t_p_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9423 static swig_cast_info _swigc__p_f_p_void_p_q_const__char_p_q_const__svn_string_t_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_void_p_q_const__char_p_q_const__svn_string_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9424 static swig_cast_info _swigc__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9425 static swig_cast_info _swigc__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9426 static swig_cast_info _swigc__p_f_p_void_svn_revnum_t_p_apr_pool_t__p_svn_error_t[] = { {&_swigt__p_f_p_void_svn_revnum_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9427 static swig_cast_info _swigc__p_f_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t[] = { {&_swigt__p_f_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9428 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
9429 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
9430 static swig_cast_info _swigc__p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t[] = { {&_swigt__p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9431 static swig_cast_info _swigc__p_p_svn_checksum_t[] = { {&_swigt__p_p_svn_checksum_t, 0, 0, 0},{0, 0, 0, 0}};
9432 static swig_cast_info _swigc__p_p_svn_delta_editor_t[] = { {&_swigt__p_p_svn_delta_editor_t, 0, 0, 0},{0, 0, 0, 0}};
9433 static swig_cast_info _swigc__p_p_svn_delta_path_driver_state_t[] = { {&_swigt__p_p_svn_delta_path_driver_state_t, 0, 0, 0},{0, 0, 0, 0}};
9434 static swig_cast_info _swigc__p_p_svn_txdelta_stream_t[] = { {&_swigt__p_p_svn_txdelta_stream_t, 0, 0, 0},{0, 0, 0, 0}};
9435 static swig_cast_info _swigc__p_p_svn_txdelta_window_t[] = { {&_swigt__p_p_svn_txdelta_window_t, 0, 0, 0},{0, 0, 0, 0}};
9436 static swig_cast_info _swigc__p_p_void[] = { {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
9437 static swig_cast_info _swigc__p_svn_auth_baton_t[] = { {&_swigt__p_svn_auth_baton_t, 0, 0, 0},{0, 0, 0, 0}};
9438 static swig_cast_info _swigc__p_svn_auth_cred_simple_t[] = { {&_swigt__p_svn_auth_cred_simple_t, 0, 0, 0},{0, 0, 0, 0}};
9439 static swig_cast_info _swigc__p_svn_auth_cred_ssl_client_cert_pw_t[] = { {&_swigt__p_svn_auth_cred_ssl_client_cert_pw_t, 0, 0, 0},{0, 0, 0, 0}};
9440 static swig_cast_info _swigc__p_svn_auth_cred_ssl_client_cert_t[] = { {&_swigt__p_svn_auth_cred_ssl_client_cert_t, 0, 0, 0},{0, 0, 0, 0}};
9441 static swig_cast_info _swigc__p_svn_auth_cred_ssl_server_trust_t[] = { {&_swigt__p_svn_auth_cred_ssl_server_trust_t, 0, 0, 0},{0, 0, 0, 0}};
9442 static swig_cast_info _swigc__p_svn_auth_cred_username_t[] = { {&_swigt__p_svn_auth_cred_username_t, 0, 0, 0},{0, 0, 0, 0}};
9443 static swig_cast_info _swigc__p_svn_auth_iterstate_t[] = { {&_swigt__p_svn_auth_iterstate_t, 0, 0, 0},{0, 0, 0, 0}};
9444 static swig_cast_info _swigc__p_svn_auth_provider_object_t[] = { {&_swigt__p_svn_auth_provider_object_t, 0, 0, 0},{0, 0, 0, 0}};
9445 static swig_cast_info _swigc__p_svn_auth_provider_t[] = { {&_swigt__p_svn_auth_provider_t, 0, 0, 0},{0, 0, 0, 0}};
9446 static swig_cast_info _swigc__p_svn_auth_ssl_server_cert_info_t[] = { {&_swigt__p_svn_auth_ssl_server_cert_info_t, 0, 0, 0},{0, 0, 0, 0}};
9447 static swig_cast_info _swigc__p_svn_cache_config_t[] = { {&_swigt__p_svn_cache_config_t, 0, 0, 0},{0, 0, 0, 0}};
9448 static swig_cast_info _swigc__p_svn_checksum_ctx_t[] = { {&_swigt__p_svn_checksum_ctx_t, 0, 0, 0},{0, 0, 0, 0}};
9449 static swig_cast_info _swigc__p_svn_checksum_kind_t[] = { {&_swigt__p_svn_checksum_kind_t, 0, 0, 0},{0, 0, 0, 0}};
9450 static swig_cast_info _swigc__p_svn_checksum_t[] = { {&_swigt__p_svn_checksum_t, 0, 0, 0},{0, 0, 0, 0}};
9451 static swig_cast_info _swigc__p_svn_commit_info_t[] = { {&_swigt__p_svn_commit_info_t, 0, 0, 0},{0, 0, 0, 0}};
9452 static swig_cast_info _swigc__p_svn_config_t[] = { {&_swigt__p_svn_config_t, 0, 0, 0},{0, 0, 0, 0}};
9453 static swig_cast_info _swigc__p_svn_delta_editor_t[] = { {&_swigt__p_svn_delta_editor_t, 0, 0, 0},{0, 0, 0, 0}};
9454 static swig_cast_info _swigc__p_svn_delta_path_driver_state_t[] = { {&_swigt__p_svn_delta_path_driver_state_t, 0, 0, 0},{0, 0, 0, 0}};
9455 static swig_cast_info _swigc__p_svn_depth_t[] = { {&_swigt__p_svn_depth_t, 0, 0, 0},{0, 0, 0, 0}};
9456 static swig_cast_info _swigc__p_svn_diff_binary_patch_t[] = { {&_swigt__p_svn_diff_binary_patch_t, 0, 0, 0},{0, 0, 0, 0}};
9457 static swig_cast_info _swigc__p_svn_diff_conflict_display_style_t[] = { {&_swigt__p_svn_diff_conflict_display_style_t, 0, 0, 0},{0, 0, 0, 0}};
9458 static swig_cast_info _swigc__p_svn_diff_datasource_e[] = { {&_swigt__p_svn_diff_datasource_e, 0, 0, 0},{0, 0, 0, 0}};
9459 static swig_cast_info _swigc__p_svn_diff_file_ignore_space_t[] = { {&_swigt__p_svn_diff_file_ignore_space_t, 0, 0, 0},{0, 0, 0, 0}};
9460 static swig_cast_info _swigc__p_svn_diff_file_options_t[] = { {&_swigt__p_svn_diff_file_options_t, 0, 0, 0},{0, 0, 0, 0}};
9461 static swig_cast_info _swigc__p_svn_diff_fns2_t[] = { {&_swigt__p_svn_diff_fns2_t, 0, 0, 0},{0, 0, 0, 0}};
9462 static swig_cast_info _swigc__p_svn_diff_fns_t[] = { {&_swigt__p_svn_diff_fns_t, 0, 0, 0},{0, 0, 0, 0}};
9463 static swig_cast_info _swigc__p_svn_diff_hunk_t[] = { {&_swigt__p_svn_diff_hunk_t, 0, 0, 0},{0, 0, 0, 0}};
9464 static swig_cast_info _swigc__p_svn_diff_operation_kind_e[] = { {&_swigt__p_svn_diff_operation_kind_e, 0, 0, 0},{0, 0, 0, 0}};
9465 static swig_cast_info _swigc__p_svn_diff_output_fns_t[] = { {&_swigt__p_svn_diff_output_fns_t, 0, 0, 0},{0, 0, 0, 0}};
9466 static swig_cast_info _swigc__p_svn_diff_t[] = { {&_swigt__p_svn_diff_t, 0, 0, 0},{0, 0, 0, 0}};
9467 static swig_cast_info _swigc__p_svn_dirent_t[] = { {&_swigt__p_svn_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
9468 static swig_cast_info _swigc__p_svn_errno_t[] = { {&_swigt__p_svn_errno_t, 0, 0, 0},{0, 0, 0, 0}};
9469 static swig_cast_info _swigc__p_svn_error_t[] = { {&_swigt__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
9470 static swig_cast_info _swigc__p_svn_io_dirent2_t[] = { {&_swigt__p_svn_io_dirent2_t, 0, 0, 0},{0, 0, 0, 0}};
9471 static swig_cast_info _swigc__p_svn_io_dirent_t[] = { {&_swigt__p_svn_io_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
9472 static swig_cast_info _swigc__p_svn_io_file_del_t[] = { {&_swigt__p_svn_io_file_del_t, 0, 0, 0},{0, 0, 0, 0}};
9473 static swig_cast_info _swigc__p_svn_location_segment_t[] = { {&_swigt__p_svn_location_segment_t, 0, 0, 0},{0, 0, 0, 0}};
9474 static swig_cast_info _swigc__p_svn_lock_t[] = { {&_swigt__p_svn_lock_t, 0, 0, 0},{0, 0, 0, 0}};
9475 static swig_cast_info _swigc__p_svn_log_changed_path2_t[] = { {&_swigt__p_svn_log_changed_path2_t, 0, 0, 0},{0, 0, 0, 0}};
9476 static swig_cast_info _swigc__p_svn_log_changed_path_t[] = { {&_swigt__p_svn_log_changed_path_t, 0, 0, 0},{0, 0, 0, 0}};
9477 static swig_cast_info _swigc__p_svn_log_entry_t[] = { {&_swigt__p_svn_log_entry_t, 0, 0, 0},{0, 0, 0, 0}};
9478 static swig_cast_info _swigc__p_svn_merge_range_t[] = { {&_swigt__p_svn_merge_range_t, 0, 0, 0},{0, 0, 0, 0}};
9479 static swig_cast_info _swigc__p_svn_mergeinfo_inheritance_t[] = { {&_swigt__p_svn_mergeinfo_inheritance_t, 0, 0, 0},{0, 0, 0, 0}};
9480 static swig_cast_info _swigc__p_svn_node_kind_t[] = { {&_swigt__p_svn_node_kind_t, 0, 0, 0},{0, 0, 0, 0}};
9481 static swig_cast_info _swigc__p_svn_opt_revision_range_t[] = { {&_swigt__p_svn_opt_revision_range_t, 0, 0, 0},{0, 0, 0, 0}};
9482 static swig_cast_info _swigc__p_svn_opt_revision_t[] = { {&_swigt__p_svn_opt_revision_t, 0, 0, 0},{0, 0, 0, 0}};
9483 static swig_cast_info _swigc__p_svn_opt_revision_value_t[] = { {&_swigt__p_svn_opt_revision_value_t, 0, 0, 0},{0, 0, 0, 0}};
9484 static swig_cast_info _swigc__p_svn_opt_subcommand_desc2_t[] = { {&_swigt__p_svn_opt_subcommand_desc2_t, 0, 0, 0},{0, 0, 0, 0}};
9485 static swig_cast_info _swigc__p_svn_opt_subcommand_desc3_t[] = { {&_swigt__p_svn_opt_subcommand_desc3_t, 0, 0, 0},{0, 0, 0, 0}};
9486 static swig_cast_info _swigc__p_svn_opt_subcommand_desc_t[] = { {&_swigt__p_svn_opt_subcommand_desc_t, 0, 0, 0},{0, 0, 0, 0}};
9487 static swig_cast_info _swigc__p_svn_patch_file_t[] = { {&_swigt__p_svn_patch_file_t, 0, 0, 0},{0, 0, 0, 0}};
9488 static swig_cast_info _swigc__p_svn_patch_t[] = { {&_swigt__p_svn_patch_t, 0, 0, 0},{0, 0, 0, 0}};
9489 static swig_cast_info _swigc__p_svn_prop_inherited_item_t[] = { {&_swigt__p_svn_prop_inherited_item_t, 0, 0, 0},{0, 0, 0, 0}};
9490 static swig_cast_info _swigc__p_svn_prop_kind[] = { {&_swigt__p_svn_prop_kind, 0, 0, 0},{0, 0, 0, 0}};
9491 static swig_cast_info _swigc__p_svn_prop_patch_t[] = { {&_swigt__p_svn_prop_patch_t, 0, 0, 0},{0, 0, 0, 0}};
9492 static swig_cast_info _swigc__p_svn_stream_mark_t[] = { {&_swigt__p_svn_stream_mark_t, 0, 0, 0},{0, 0, 0, 0}};
9493 static swig_cast_info _swigc__p_svn_stream_t[] = { {&_swigt__p_svn_stream_t, 0, 0, 0},{0, 0, 0, 0}};
9494 static swig_cast_info _swigc__p_svn_string_t[] = { {&_swigt__p_svn_string_t, 0, 0, 0},{0, 0, 0, 0}};
9495 static swig_cast_info _swigc__p_svn_stringbuf_t[] = { {&_swigt__p_svn_stringbuf_t, 0, 0, 0},{0, 0, 0, 0}};
9496 static swig_cast_info _swigc__p_svn_tristate_t[] = { {&_swigt__p_svn_tristate_t, 0, 0, 0},{0, 0, 0, 0}};
9497 static swig_cast_info _swigc__p_svn_txdelta_op_t[] = { {&_swigt__p_svn_txdelta_op_t, 0, 0, 0},{0, 0, 0, 0}};
9498 static swig_cast_info _swigc__p_svn_txdelta_stream_t[] = { {&_swigt__p_svn_txdelta_stream_t, 0, 0, 0},{0, 0, 0, 0}};
9499 static swig_cast_info _swigc__p_svn_txdelta_window_t[] = { {&_swigt__p_svn_txdelta_window_t, 0, 0, 0},{0, 0, 0, 0}};
9500 static swig_cast_info _swigc__p_svn_version_checklist_t[] = { {&_swigt__p_svn_version_checklist_t, 0, 0, 0},{0, 0, 0, 0}};
9501 static swig_cast_info _swigc__p_svn_version_ext_linked_lib_t[] = { {&_swigt__p_svn_version_ext_linked_lib_t, 0, 0, 0},{0, 0, 0, 0}};
9502 static swig_cast_info _swigc__p_svn_version_ext_loaded_lib_t[] = { {&_swigt__p_svn_version_ext_loaded_lib_t, 0, 0, 0},{0, 0, 0, 0}};
9503 static swig_cast_info _swigc__p_svn_version_extended_t[] = { {&_swigt__p_svn_version_extended_t, 0, 0, 0},{0, 0, 0, 0}};
9504 static swig_cast_info _swigc__p_svn_version_t[] = { {&_swigt__p_svn_version_t, 0, 0, 0},{0, 0, 0, 0}};
9505 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
9506 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
9507 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
9508
9509 static swig_cast_info *swig_cast_initial[] = {
9510 _swigc__p_apr_array_header_t,
9511 _swigc__p_apr_file_t,
9512 _swigc__p_apr_hash_t,
9513 _swigc__p_apr_int32_t,
9514 _swigc__p_apr_int64_t,
9515 _swigc__p_apr_pool_t,
9516 _swigc__p_apr_size_t,
9517 _swigc__p_char,
9518 _swigc__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t,
9519 _swigc__p_f_p_p_svn_txdelta_stream_t_p_void_p_apr_pool_t_p_apr_pool_t__p_svn_error_t,
9520 _swigc__p_f_p_p_svn_txdelta_window_t_p_void_p_apr_pool_t__p_svn_error_t,
9521 _swigc__p_f_p_p_void_p_q_const__svn_delta_editor_t_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t,
9522 _swigc__p_f_p_p_void_p_void_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t,
9523 _swigc__p_f_p_q_const__char_p_void_p_apr_pool_t__p_svn_error_t,
9524 _swigc__p_f_p_q_const__char_p_void_p_q_const__char_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t,
9525 _swigc__p_f_p_q_const__char_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t,
9526 _swigc__p_f_p_q_const__char_svn_revnum_t_p_void_p_apr_pool_t__p_svn_error_t,
9527 _swigc__p_f_p_q_const__struct_svn_delta_editor_t_p_void_p_q_const__char_svn_txdelta_stream_open_func_t_p_void_p_apr_pool_t__p_svn_error_t,
9528 _swigc__p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
9529 _swigc__p_f_p_void__p_svn_error_t,
9530 _swigc__p_f_p_void__p_unsigned_char,
9531 _swigc__p_f_p_void_p_apr_pool_t__p_svn_error_t,
9532 _swigc__p_f_p_void_p_q_const__char_p_apr_pool_t__p_svn_error_t,
9533 _swigc__p_f_p_void_p_q_const__char_p_apr_pool_t_p_svn_txdelta_window_handler_t_p_p_void__p_svn_error_t,
9534 _swigc__p_f_p_void_p_q_const__char_p_q_const__svn_string_t_p_apr_pool_t__p_svn_error_t,
9535 _swigc__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t,
9536 _swigc__p_f_p_void_p_q_const__char_svn_revnum_t_p_apr_hash_t_svn_boolean_t_p_svn_txdelta_window_handler_t_p_p_void_p_apr_array_header_t_p_apr_pool_t__p_svn_error_t,
9537 _swigc__p_f_p_void_svn_revnum_t_p_apr_pool_t__p_svn_error_t,
9538 _swigc__p_f_p_void_svn_revnum_t_p_apr_pool_t_p_p_void__p_svn_error_t,
9539 _swigc__p_int,
9540 _swigc__p_long,
9541 _swigc__p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
9542 _swigc__p_p_svn_checksum_t,
9543 _swigc__p_p_svn_delta_editor_t,
9544 _swigc__p_p_svn_delta_path_driver_state_t,
9545 _swigc__p_p_svn_txdelta_stream_t,
9546 _swigc__p_p_svn_txdelta_window_t,
9547 _swigc__p_p_void,
9548 _swigc__p_svn_auth_baton_t,
9549 _swigc__p_svn_auth_cred_simple_t,
9550 _swigc__p_svn_auth_cred_ssl_client_cert_pw_t,
9551 _swigc__p_svn_auth_cred_ssl_client_cert_t,
9552 _swigc__p_svn_auth_cred_ssl_server_trust_t,
9553 _swigc__p_svn_auth_cred_username_t,
9554 _swigc__p_svn_auth_iterstate_t,
9555 _swigc__p_svn_auth_provider_object_t,
9556 _swigc__p_svn_auth_provider_t,
9557 _swigc__p_svn_auth_ssl_server_cert_info_t,
9558 _swigc__p_svn_cache_config_t,
9559 _swigc__p_svn_checksum_ctx_t,
9560 _swigc__p_svn_checksum_kind_t,
9561 _swigc__p_svn_checksum_t,
9562 _swigc__p_svn_commit_info_t,
9563 _swigc__p_svn_config_t,
9564 _swigc__p_svn_delta_editor_t,
9565 _swigc__p_svn_delta_path_driver_state_t,
9566 _swigc__p_svn_depth_t,
9567 _swigc__p_svn_diff_binary_patch_t,
9568 _swigc__p_svn_diff_conflict_display_style_t,
9569 _swigc__p_svn_diff_datasource_e,
9570 _swigc__p_svn_diff_file_ignore_space_t,
9571 _swigc__p_svn_diff_file_options_t,
9572 _swigc__p_svn_diff_fns2_t,
9573 _swigc__p_svn_diff_fns_t,
9574 _swigc__p_svn_diff_hunk_t,
9575 _swigc__p_svn_diff_operation_kind_e,
9576 _swigc__p_svn_diff_output_fns_t,
9577 _swigc__p_svn_diff_t,
9578 _swigc__p_svn_dirent_t,
9579 _swigc__p_svn_errno_t,
9580 _swigc__p_svn_error_t,
9581 _swigc__p_svn_io_dirent2_t,
9582 _swigc__p_svn_io_dirent_t,
9583 _swigc__p_svn_io_file_del_t,
9584 _swigc__p_svn_location_segment_t,
9585 _swigc__p_svn_lock_t,
9586 _swigc__p_svn_log_changed_path2_t,
9587 _swigc__p_svn_log_changed_path_t,
9588 _swigc__p_svn_log_entry_t,
9589 _swigc__p_svn_merge_range_t,
9590 _swigc__p_svn_mergeinfo_inheritance_t,
9591 _swigc__p_svn_node_kind_t,
9592 _swigc__p_svn_opt_revision_range_t,
9593 _swigc__p_svn_opt_revision_t,
9594 _swigc__p_svn_opt_revision_value_t,
9595 _swigc__p_svn_opt_subcommand_desc2_t,
9596 _swigc__p_svn_opt_subcommand_desc3_t,
9597 _swigc__p_svn_opt_subcommand_desc_t,
9598 _swigc__p_svn_patch_file_t,
9599 _swigc__p_svn_patch_t,
9600 _swigc__p_svn_prop_inherited_item_t,
9601 _swigc__p_svn_prop_kind,
9602 _swigc__p_svn_prop_patch_t,
9603 _swigc__p_svn_stream_mark_t,
9604 _swigc__p_svn_stream_t,
9605 _swigc__p_svn_string_t,
9606 _swigc__p_svn_stringbuf_t,
9607 _swigc__p_svn_tristate_t,
9608 _swigc__p_svn_txdelta_op_t,
9609 _swigc__p_svn_txdelta_stream_t,
9610 _swigc__p_svn_txdelta_window_t,
9611 _swigc__p_svn_version_checklist_t,
9612 _swigc__p_svn_version_ext_linked_lib_t,
9613 _swigc__p_svn_version_ext_loaded_lib_t,
9614 _swigc__p_svn_version_extended_t,
9615 _swigc__p_svn_version_t,
9616 _swigc__p_unsigned_char,
9617 _swigc__p_unsigned_long,
9618 _swigc__p_void,
9619 };
9620
9621
9622 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
9623
9624 /* -----------------------------------------------------------------------------
9625 * Type initialization:
9626 * This problem is tough by the requirement that no dynamic
9627 * memory is used. Also, since swig_type_info structures store pointers to
9628 * swig_cast_info structures and swig_cast_info structures store pointers back
9629 * to swig_type_info structures, we need some lookup code at initialization.
9630 * The idea is that swig generates all the structures that are needed.
9631 * The runtime then collects these partially filled structures.
9632 * The SWIG_InitializeModule function takes these initial arrays out of
9633 * swig_module, and does all the lookup, filling in the swig_module.types
9634 * array with the correct data and linking the correct swig_cast_info
9635 * structures together.
9636 *
9637 * The generated swig_type_info structures are assigned statically to an initial
9638 * array. We just loop through that array, and handle each type individually.
9639 * First we lookup if this type has been already loaded, and if so, use the
9640 * loaded structure instead of the generated one. Then we have to fill in the
9641 * cast linked list. The cast data is initially stored in something like a
9642 * two-dimensional array. Each row corresponds to a type (there are the same
9643 * number of rows as there are in the swig_type_initial array). Each entry in
9644 * a column is one of the swig_cast_info structures for that type.
9645 * The cast_initial array is actually an array of arrays, because each row has
9646 * a variable number of columns. So to actually build the cast linked list,
9647 * we find the array of casts associated with the type, and loop through it
9648 * adding the casts to the list. The one last trick we need to do is making
9649 * sure the type pointer in the swig_cast_info struct is correct.
9650 *
9651 * First off, we lookup the cast->type name to see if it is already loaded.
9652 * There are three cases to handle:
9653 * 1) If the cast->type has already been loaded AND the type we are adding
9654 * casting info to has not been loaded (it is in this module), THEN we
9655 * replace the cast->type pointer with the type pointer that has already
9656 * been loaded.
9657 * 2) If BOTH types (the one we are adding casting info to, and the
9658 * cast->type) are loaded, THEN the cast info has already been loaded by
9659 * the previous module so we just ignore it.
9660 * 3) Finally, if cast->type has not already been loaded, then we add that
9661 * swig_cast_info to the linked list (because the cast->type) pointer will
9662 * be correct.
9663 * ----------------------------------------------------------------------------- */
9664
9665 #ifdef __cplusplus
9666 extern "C" {
9667 #if 0
9668 } /* c-mode */
9669 #endif
9670 #endif
9671
9672 #if 0
9673 #define SWIGRUNTIME_DEBUG
9674 #endif
9675
9676
9677 SWIGRUNTIME void
SWIG_InitializeModule(void * clientdata)9678 SWIG_InitializeModule(void *clientdata) {
9679 size_t i;
9680 swig_module_info *module_head, *iter;
9681 int init;
9682
9683 /* check to see if the circular list has been setup, if not, set it up */
9684 if (swig_module.next==0) {
9685 /* Initialize the swig_module */
9686 swig_module.type_initial = swig_type_initial;
9687 swig_module.cast_initial = swig_cast_initial;
9688 swig_module.next = &swig_module;
9689 init = 1;
9690 } else {
9691 init = 0;
9692 }
9693
9694 /* Try and load any already created modules */
9695 module_head = SWIG_GetModule(clientdata);
9696 if (!module_head) {
9697 /* This is the first module loaded for this interpreter */
9698 /* so set the swig module into the interpreter */
9699 SWIG_SetModule(clientdata, &swig_module);
9700 } else {
9701 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
9702 iter=module_head;
9703 do {
9704 if (iter==&swig_module) {
9705 /* Our module is already in the list, so there's nothing more to do. */
9706 return;
9707 }
9708 iter=iter->next;
9709 } while (iter!= module_head);
9710
9711 /* otherwise we must add our module into the list */
9712 swig_module.next = module_head->next;
9713 module_head->next = &swig_module;
9714 }
9715
9716 /* When multiple interpreters are used, a module could have already been initialized in
9717 a different interpreter, but not yet have a pointer in this interpreter.
9718 In this case, we do not want to continue adding types... everything should be
9719 set up already */
9720 if (init == 0) return;
9721
9722 /* Now work on filling in swig_module.types */
9723 #ifdef SWIGRUNTIME_DEBUG
9724 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
9725 #endif
9726 for (i = 0; i < swig_module.size; ++i) {
9727 swig_type_info *type = 0;
9728 swig_type_info *ret;
9729 swig_cast_info *cast;
9730
9731 #ifdef SWIGRUNTIME_DEBUG
9732 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
9733 #endif
9734
9735 /* if there is another module already loaded */
9736 if (swig_module.next != &swig_module) {
9737 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
9738 }
9739 if (type) {
9740 /* Overwrite clientdata field */
9741 #ifdef SWIGRUNTIME_DEBUG
9742 printf("SWIG_InitializeModule: found type %s\n", type->name);
9743 #endif
9744 if (swig_module.type_initial[i]->clientdata) {
9745 type->clientdata = swig_module.type_initial[i]->clientdata;
9746 #ifdef SWIGRUNTIME_DEBUG
9747 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
9748 #endif
9749 }
9750 } else {
9751 type = swig_module.type_initial[i];
9752 }
9753
9754 /* Insert casting types */
9755 cast = swig_module.cast_initial[i];
9756 while (cast->type) {
9757
9758 /* Don't need to add information already in the list */
9759 ret = 0;
9760 #ifdef SWIGRUNTIME_DEBUG
9761 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
9762 #endif
9763 if (swig_module.next != &swig_module) {
9764 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
9765 #ifdef SWIGRUNTIME_DEBUG
9766 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
9767 #endif
9768 }
9769 if (ret) {
9770 if (type == swig_module.type_initial[i]) {
9771 #ifdef SWIGRUNTIME_DEBUG
9772 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
9773 #endif
9774 cast->type = ret;
9775 ret = 0;
9776 } else {
9777 /* Check for casting already in the list */
9778 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
9779 #ifdef SWIGRUNTIME_DEBUG
9780 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
9781 #endif
9782 if (!ocast) ret = 0;
9783 }
9784 }
9785
9786 if (!ret) {
9787 #ifdef SWIGRUNTIME_DEBUG
9788 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
9789 #endif
9790 if (type->cast) {
9791 type->cast->prev = cast;
9792 cast->next = type->cast;
9793 }
9794 type->cast = cast;
9795 }
9796 cast++;
9797 }
9798 /* Set entry in modules->types array equal to the type */
9799 swig_module.types[i] = type;
9800 }
9801 swig_module.types[i] = 0;
9802
9803 #ifdef SWIGRUNTIME_DEBUG
9804 printf("**** SWIG_InitializeModule: Cast List ******\n");
9805 for (i = 0; i < swig_module.size; ++i) {
9806 int j = 0;
9807 swig_cast_info *cast = swig_module.cast_initial[i];
9808 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
9809 while (cast->type) {
9810 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
9811 cast++;
9812 ++j;
9813 }
9814 printf("---- Total casts: %d\n",j);
9815 }
9816 printf("**** SWIG_InitializeModule: Cast List ******\n");
9817 #endif
9818 }
9819
9820 /* This function will propagate the clientdata field of type to
9821 * any new swig_type_info structures that have been added into the list
9822 * of equivalent types. It is like calling
9823 * SWIG_TypeClientData(type, clientdata) a second time.
9824 */
9825 SWIGRUNTIME void
SWIG_PropagateClientData(void)9826 SWIG_PropagateClientData(void) {
9827 size_t i;
9828 swig_cast_info *equiv;
9829 static int init_run = 0;
9830
9831 if (init_run) return;
9832 init_run = 1;
9833
9834 for (i = 0; i < swig_module.size; i++) {
9835 if (swig_module.types[i]->clientdata) {
9836 equiv = swig_module.types[i]->cast;
9837 while (equiv) {
9838 if (!equiv->converter) {
9839 if (equiv->type && !equiv->type->clientdata)
9840 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
9841 }
9842 equiv = equiv->next;
9843 }
9844 }
9845 }
9846 }
9847
9848 #ifdef __cplusplus
9849 #if 0
9850 { /* c-mode */
9851 #endif
9852 }
9853 #endif
9854
9855 /*
9856
9857 */
9858 #ifdef __cplusplus
9859 extern "C"
9860 #endif
Init_delta(void)9861 SWIGEXPORT void Init_delta(void) {
9862 size_t i;
9863
9864 SWIG_InitRuntime();
9865 mDelta = rb_define_module("Svn");
9866 mDelta = rb_define_module_under(mDelta, "Ext");
9867 mDelta = rb_define_module_under(mDelta, "Delta");
9868
9869 SWIG_InitializeModule(0);
9870 for (i = 0; i < swig_module.size; i++) {
9871 SWIG_define_class(swig_module.types[i]);
9872 }
9873
9874 SWIG_RubyInitializeTrackings();
9875 rb_require("svn/ext/core");
9876 rb_define_module_function(mDelta, "svn_txdelta_window_t_ops_get", _wrap_svn_txdelta_window_t_ops_get, -1);
9877 rb_define_const(mDelta, "SVN_DELTA_COMPRESSION_LEVEL_NONE", SWIG_From_int((int)(0)));
9878 rb_define_const(mDelta, "SVN_DELTA_COMPRESSION_LEVEL_MAX", SWIG_From_int((int)(9)));
9879 rb_define_const(mDelta, "SVN_DELTA_COMPRESSION_LEVEL_DEFAULT", SWIG_From_int((int)(5)));
9880 rb_define_module_function(mDelta, "svn_delta_version", _wrap_svn_delta_version, -1);
9881 rb_define_const(mDelta, "Svn_txdelta_source", SWIG_From_int((int)(svn_txdelta_source)));
9882 rb_define_const(mDelta, "Svn_txdelta_target", SWIG_From_int((int)(svn_txdelta_target)));
9883 rb_define_const(mDelta, "Svn_txdelta_new", SWIG_From_int((int)(svn_txdelta_new)));
9884
9885 SwigClassSvn_txdelta_op_t.klass = rb_define_class_under(mDelta, "Svn_txdelta_op_t", rb_cObject);
9886 SWIG_TypeClientData(SWIGTYPE_p_svn_txdelta_op_t, (void *) &SwigClassSvn_txdelta_op_t);
9887 rb_define_alloc_func(SwigClassSvn_txdelta_op_t.klass, _wrap_svn_txdelta_op_t_allocate);
9888 rb_define_method(SwigClassSvn_txdelta_op_t.klass, "initialize", _wrap_new_svn_txdelta_op_t, -1);
9889 rb_define_method(SwigClassSvn_txdelta_op_t.klass, "action_code=", _wrap_svn_txdelta_op_t_action_code_set, -1);
9890 rb_define_method(SwigClassSvn_txdelta_op_t.klass, "action_code", _wrap_svn_txdelta_op_t_action_code_get, -1);
9891 rb_define_method(SwigClassSvn_txdelta_op_t.klass, "offset=", _wrap_svn_txdelta_op_t_offset_set, -1);
9892 rb_define_method(SwigClassSvn_txdelta_op_t.klass, "offset", _wrap_svn_txdelta_op_t_offset_get, -1);
9893 rb_define_method(SwigClassSvn_txdelta_op_t.klass, "length=", _wrap_svn_txdelta_op_t_length_set, -1);
9894 rb_define_method(SwigClassSvn_txdelta_op_t.klass, "length", _wrap_svn_txdelta_op_t_length_get, -1);
9895 SwigClassSvn_txdelta_op_t.mark = 0;
9896 SwigClassSvn_txdelta_op_t.destroy = (void (*)(void *)) free_svn_txdelta_op_t;
9897 SwigClassSvn_txdelta_op_t.trackObjects = 0;
9898
9899 SwigClassSvn_txdelta_window_t.klass = rb_define_class_under(mDelta, "Svn_txdelta_window_t", rb_cObject);
9900 SWIG_TypeClientData(SWIGTYPE_p_svn_txdelta_window_t, (void *) &SwigClassSvn_txdelta_window_t);
9901 rb_define_alloc_func(SwigClassSvn_txdelta_window_t.klass, _wrap_svn_txdelta_window_t_allocate);
9902 rb_define_method(SwigClassSvn_txdelta_window_t.klass, "initialize", _wrap_new_svn_txdelta_window_t, -1);
9903 rb_define_method(SwigClassSvn_txdelta_window_t.klass, "sview_offset=", _wrap_svn_txdelta_window_t_sview_offset_set, -1);
9904 rb_define_method(SwigClassSvn_txdelta_window_t.klass, "sview_offset", _wrap_svn_txdelta_window_t_sview_offset_get, -1);
9905 rb_define_method(SwigClassSvn_txdelta_window_t.klass, "sview_len=", _wrap_svn_txdelta_window_t_sview_len_set, -1);
9906 rb_define_method(SwigClassSvn_txdelta_window_t.klass, "sview_len", _wrap_svn_txdelta_window_t_sview_len_get, -1);
9907 rb_define_method(SwigClassSvn_txdelta_window_t.klass, "tview_len=", _wrap_svn_txdelta_window_t_tview_len_set, -1);
9908 rb_define_method(SwigClassSvn_txdelta_window_t.klass, "tview_len", _wrap_svn_txdelta_window_t_tview_len_get, -1);
9909 rb_define_method(SwigClassSvn_txdelta_window_t.klass, "num_ops=", _wrap_svn_txdelta_window_t_num_ops_set, -1);
9910 rb_define_method(SwigClassSvn_txdelta_window_t.klass, "num_ops", _wrap_svn_txdelta_window_t_num_ops_get, -1);
9911 rb_define_method(SwigClassSvn_txdelta_window_t.klass, "src_ops=", _wrap_svn_txdelta_window_t_src_ops_set, -1);
9912 rb_define_method(SwigClassSvn_txdelta_window_t.klass, "src_ops", _wrap_svn_txdelta_window_t_src_ops_get, -1);
9913 rb_define_method(SwigClassSvn_txdelta_window_t.klass, "new_data", _wrap_svn_txdelta_window_t_new_data_get, -1);
9914 SwigClassSvn_txdelta_window_t.mark = 0;
9915 SwigClassSvn_txdelta_window_t.destroy = (void (*)(void *)) free_svn_txdelta_window_t;
9916 SwigClassSvn_txdelta_window_t.trackObjects = 0;
9917 rb_define_module_function(mDelta, "svn_txdelta_window_dup", _wrap_svn_txdelta_window_dup, -1);
9918 rb_define_module_function(mDelta, "svn_txdelta_compose_windows", _wrap_svn_txdelta_compose_windows, -1);
9919 rb_define_module_function(mDelta, "svn_txdelta_apply_instructions", _wrap_svn_txdelta_apply_instructions, -1);
9920 rb_define_module_function(mDelta, "svn_txdelta_run", _wrap_svn_txdelta_run, -1);
9921 rb_define_module_function(mDelta, "svn_txdelta_stream_create", _wrap_svn_txdelta_stream_create, -1);
9922 rb_define_module_function(mDelta, "svn_txdelta_next_window", _wrap_svn_txdelta_next_window, -1);
9923 rb_define_module_function(mDelta, "svn_txdelta_md5_digest", _wrap_svn_txdelta_md5_digest, -1);
9924 rb_define_module_function(mDelta, "svn_txdelta2", _wrap_svn_txdelta2, -1);
9925 rb_define_module_function(mDelta, "svn_txdelta", _wrap_svn_txdelta, -1);
9926 rb_define_module_function(mDelta, "svn_txdelta_target_push", _wrap_svn_txdelta_target_push, -1);
9927 rb_define_module_function(mDelta, "svn_txdelta_send_string", _wrap_svn_txdelta_send_string, -1);
9928 rb_define_module_function(mDelta, "svn_txdelta_send_stream", _wrap_svn_txdelta_send_stream, -1);
9929 rb_define_module_function(mDelta, "svn_txdelta_send_txstream", _wrap_svn_txdelta_send_txstream, -1);
9930 rb_define_module_function(mDelta, "svn_txdelta_send_contents", _wrap_svn_txdelta_send_contents, -1);
9931 rb_define_module_function(mDelta, "svn_txdelta_apply", _wrap_svn_txdelta_apply, -1);
9932 rb_define_module_function(mDelta, "svn_txdelta_to_svndiff3", _wrap_svn_txdelta_to_svndiff3, -1);
9933 rb_define_module_function(mDelta, "svn_txdelta_to_svndiff2", _wrap_svn_txdelta_to_svndiff2, -1);
9934 rb_define_module_function(mDelta, "svn_txdelta_to_svndiff", _wrap_svn_txdelta_to_svndiff, -1);
9935 rb_define_module_function(mDelta, "svn_txdelta_to_svndiff_stream", _wrap_svn_txdelta_to_svndiff_stream, -1);
9936 rb_define_module_function(mDelta, "svn_txdelta_parse_svndiff", _wrap_svn_txdelta_parse_svndiff, -1);
9937 rb_define_module_function(mDelta, "svn_txdelta_read_svndiff_window", _wrap_svn_txdelta_read_svndiff_window, -1);
9938 rb_define_module_function(mDelta, "svn_txdelta_skip_svndiff_window", _wrap_svn_txdelta_skip_svndiff_window, -1);
9939
9940 SwigClassSvn_delta_editor_t.klass = rb_define_class_under(mDelta, "Svn_delta_editor_t", rb_cObject);
9941 SWIG_TypeClientData(SWIGTYPE_p_svn_delta_editor_t, (void *) &SwigClassSvn_delta_editor_t);
9942 rb_define_alloc_func(SwigClassSvn_delta_editor_t.klass, _wrap_svn_delta_editor_t_allocate);
9943 rb_define_method(SwigClassSvn_delta_editor_t.klass, "initialize", _wrap_new_svn_delta_editor_t, -1);
9944 rb_define_method(SwigClassSvn_delta_editor_t.klass, "set_target_revision=", _wrap_svn_delta_editor_t_set_target_revision_set, -1);
9945 rb_define_method(SwigClassSvn_delta_editor_t.klass, "set_target_revision", _wrap_svn_delta_editor_t_set_target_revision_get, -1);
9946 rb_define_method(SwigClassSvn_delta_editor_t.klass, "open_root=", _wrap_svn_delta_editor_t_open_root_set, -1);
9947 rb_define_method(SwigClassSvn_delta_editor_t.klass, "open_root", _wrap_svn_delta_editor_t_open_root_get, -1);
9948 rb_define_method(SwigClassSvn_delta_editor_t.klass, "delete_entry=", _wrap_svn_delta_editor_t_delete_entry_set, -1);
9949 rb_define_method(SwigClassSvn_delta_editor_t.klass, "delete_entry", _wrap_svn_delta_editor_t_delete_entry_get, -1);
9950 rb_define_method(SwigClassSvn_delta_editor_t.klass, "add_directory=", _wrap_svn_delta_editor_t_add_directory_set, -1);
9951 rb_define_method(SwigClassSvn_delta_editor_t.klass, "add_directory", _wrap_svn_delta_editor_t_add_directory_get, -1);
9952 rb_define_method(SwigClassSvn_delta_editor_t.klass, "open_directory=", _wrap_svn_delta_editor_t_open_directory_set, -1);
9953 rb_define_method(SwigClassSvn_delta_editor_t.klass, "open_directory", _wrap_svn_delta_editor_t_open_directory_get, -1);
9954 rb_define_method(SwigClassSvn_delta_editor_t.klass, "change_dir_prop=", _wrap_svn_delta_editor_t_change_dir_prop_set, -1);
9955 rb_define_method(SwigClassSvn_delta_editor_t.klass, "change_dir_prop", _wrap_svn_delta_editor_t_change_dir_prop_get, -1);
9956 rb_define_method(SwigClassSvn_delta_editor_t.klass, "close_directory=", _wrap_svn_delta_editor_t_close_directory_set, -1);
9957 rb_define_method(SwigClassSvn_delta_editor_t.klass, "close_directory", _wrap_svn_delta_editor_t_close_directory_get, -1);
9958 rb_define_method(SwigClassSvn_delta_editor_t.klass, "absent_directory=", _wrap_svn_delta_editor_t_absent_directory_set, -1);
9959 rb_define_method(SwigClassSvn_delta_editor_t.klass, "absent_directory", _wrap_svn_delta_editor_t_absent_directory_get, -1);
9960 rb_define_method(SwigClassSvn_delta_editor_t.klass, "add_file=", _wrap_svn_delta_editor_t_add_file_set, -1);
9961 rb_define_method(SwigClassSvn_delta_editor_t.klass, "add_file", _wrap_svn_delta_editor_t_add_file_get, -1);
9962 rb_define_method(SwigClassSvn_delta_editor_t.klass, "open_file=", _wrap_svn_delta_editor_t_open_file_set, -1);
9963 rb_define_method(SwigClassSvn_delta_editor_t.klass, "open_file", _wrap_svn_delta_editor_t_open_file_get, -1);
9964 rb_define_method(SwigClassSvn_delta_editor_t.klass, "apply_textdelta=", _wrap_svn_delta_editor_t_apply_textdelta_set, -1);
9965 rb_define_method(SwigClassSvn_delta_editor_t.klass, "apply_textdelta", _wrap_svn_delta_editor_t_apply_textdelta_get, -1);
9966 rb_define_method(SwigClassSvn_delta_editor_t.klass, "change_file_prop=", _wrap_svn_delta_editor_t_change_file_prop_set, -1);
9967 rb_define_method(SwigClassSvn_delta_editor_t.klass, "change_file_prop", _wrap_svn_delta_editor_t_change_file_prop_get, -1);
9968 rb_define_method(SwigClassSvn_delta_editor_t.klass, "close_file=", _wrap_svn_delta_editor_t_close_file_set, -1);
9969 rb_define_method(SwigClassSvn_delta_editor_t.klass, "close_file", _wrap_svn_delta_editor_t_close_file_get, -1);
9970 rb_define_method(SwigClassSvn_delta_editor_t.klass, "absent_file=", _wrap_svn_delta_editor_t_absent_file_set, -1);
9971 rb_define_method(SwigClassSvn_delta_editor_t.klass, "absent_file", _wrap_svn_delta_editor_t_absent_file_get, -1);
9972 rb_define_method(SwigClassSvn_delta_editor_t.klass, "close_edit=", _wrap_svn_delta_editor_t_close_edit_set, -1);
9973 rb_define_method(SwigClassSvn_delta_editor_t.klass, "close_edit", _wrap_svn_delta_editor_t_close_edit_get, -1);
9974 rb_define_method(SwigClassSvn_delta_editor_t.klass, "abort_edit=", _wrap_svn_delta_editor_t_abort_edit_set, -1);
9975 rb_define_method(SwigClassSvn_delta_editor_t.klass, "abort_edit", _wrap_svn_delta_editor_t_abort_edit_get, -1);
9976 rb_define_method(SwigClassSvn_delta_editor_t.klass, "apply_textdelta_stream=", _wrap_svn_delta_editor_t_apply_textdelta_stream_set, -1);
9977 rb_define_method(SwigClassSvn_delta_editor_t.klass, "apply_textdelta_stream", _wrap_svn_delta_editor_t_apply_textdelta_stream_get, -1);
9978 SwigClassSvn_delta_editor_t.mark = 0;
9979 SwigClassSvn_delta_editor_t.destroy = (void (*)(void *)) free_svn_delta_editor_t;
9980 SwigClassSvn_delta_editor_t.trackObjects = 0;
9981 rb_define_module_function(mDelta, "svn_delta_default_editor", _wrap_svn_delta_default_editor, -1);
9982 rb_define_module_function(mDelta, "svn_delta_noop_window_handler", _wrap_svn_delta_noop_window_handler, -1);
9983 rb_define_module_function(mDelta, "svn_delta_get_cancellation_editor", _wrap_svn_delta_get_cancellation_editor, -1);
9984 rb_define_module_function(mDelta, "svn_delta_depth_filter_editor", _wrap_svn_delta_depth_filter_editor, -1);
9985 rb_define_module_function(mDelta, "svn_delta_path_driver3", _wrap_svn_delta_path_driver3, -1);
9986 rb_define_module_function(mDelta, "svn_delta_path_driver2", _wrap_svn_delta_path_driver2, -1);
9987 rb_define_module_function(mDelta, "svn_delta_path_driver", _wrap_svn_delta_path_driver, -1);
9988 rb_define_module_function(mDelta, "svn_delta_path_driver_start", _wrap_svn_delta_path_driver_start, -1);
9989 rb_define_module_function(mDelta, "svn_delta_path_driver_step", _wrap_svn_delta_path_driver_step, -1);
9990 rb_define_module_function(mDelta, "svn_delta_path_driver_finish", _wrap_svn_delta_path_driver_finish, -1);
9991 rb_define_module_function(mDelta, "svn_delta_editor_invoke_set_target_revision", _wrap_svn_delta_editor_invoke_set_target_revision, -1);
9992 rb_define_module_function(mDelta, "svn_delta_editor_invoke_open_root", _wrap_svn_delta_editor_invoke_open_root, -1);
9993 rb_define_module_function(mDelta, "svn_delta_editor_invoke_delete_entry", _wrap_svn_delta_editor_invoke_delete_entry, -1);
9994 rb_define_module_function(mDelta, "svn_delta_editor_invoke_add_directory", _wrap_svn_delta_editor_invoke_add_directory, -1);
9995 rb_define_module_function(mDelta, "svn_delta_editor_invoke_open_directory", _wrap_svn_delta_editor_invoke_open_directory, -1);
9996 rb_define_module_function(mDelta, "svn_delta_editor_invoke_change_dir_prop", _wrap_svn_delta_editor_invoke_change_dir_prop, -1);
9997 rb_define_module_function(mDelta, "svn_delta_editor_invoke_close_directory", _wrap_svn_delta_editor_invoke_close_directory, -1);
9998 rb_define_module_function(mDelta, "svn_delta_editor_invoke_absent_directory", _wrap_svn_delta_editor_invoke_absent_directory, -1);
9999 rb_define_module_function(mDelta, "svn_delta_editor_invoke_add_file", _wrap_svn_delta_editor_invoke_add_file, -1);
10000 rb_define_module_function(mDelta, "svn_delta_editor_invoke_open_file", _wrap_svn_delta_editor_invoke_open_file, -1);
10001 rb_define_module_function(mDelta, "svn_delta_editor_invoke_apply_textdelta", _wrap_svn_delta_editor_invoke_apply_textdelta, -1);
10002 rb_define_module_function(mDelta, "svn_delta_editor_invoke_change_file_prop", _wrap_svn_delta_editor_invoke_change_file_prop, -1);
10003 rb_define_module_function(mDelta, "svn_delta_editor_invoke_close_file", _wrap_svn_delta_editor_invoke_close_file, -1);
10004 rb_define_module_function(mDelta, "svn_delta_editor_invoke_absent_file", _wrap_svn_delta_editor_invoke_absent_file, -1);
10005 rb_define_module_function(mDelta, "svn_delta_editor_invoke_close_edit", _wrap_svn_delta_editor_invoke_close_edit, -1);
10006 rb_define_module_function(mDelta, "svn_delta_editor_invoke_abort_edit", _wrap_svn_delta_editor_invoke_abort_edit, -1);
10007 rb_define_module_function(mDelta, "svn_delta_editor_invoke_apply_textdelta_stream", _wrap_svn_delta_editor_invoke_apply_textdelta_stream, -1);
10008 rb_define_module_function(mDelta, "svn_txdelta_invoke_window_handler", _wrap_svn_txdelta_invoke_window_handler, -1);
10009 rb_define_module_function(mDelta, "svn_txdelta_invoke_next_window_fn", _wrap_svn_txdelta_invoke_next_window_fn, -1);
10010 rb_define_module_function(mDelta, "svn_txdelta_invoke_md5_digest_fn", _wrap_svn_txdelta_invoke_md5_digest_fn, -1);
10011 rb_define_module_function(mDelta, "svn_txdelta_invoke_stream_open_func", _wrap_svn_txdelta_invoke_stream_open_func, -1);
10012 rb_define_module_function(mDelta, "svn_delta_invoke_path_driver_cb_func2", _wrap_svn_delta_invoke_path_driver_cb_func2, -1);
10013 rb_define_module_function(mDelta, "svn_delta_invoke_path_driver_cb_func", _wrap_svn_delta_invoke_path_driver_cb_func, -1);
10014 rb_define_module_function(mDelta, "svn_file_invoke_rev_handler", _wrap_svn_file_invoke_rev_handler, -1);
10015 rb_define_module_function(mDelta, "svn_file_invoke_rev_handler_old", _wrap_svn_file_invoke_rev_handler_old, -1);
10016 rb_define_module_function(mDelta, "svn_swig_rb_delta_editor_get_target_revision", _wrap_svn_swig_rb_delta_editor_get_target_revision, -1);
10017 rb_define_module_function(mDelta, "svn_swig_rb_txdelta_apply_instructions", _wrap_svn_swig_rb_txdelta_apply_instructions, -1);
10018 rb_define_module_function(mDelta, "svn_txdelta_apply_wrapper", _wrap_svn_txdelta_apply_wrapper, -1);
10019 rb_define_module_function(mDelta, "svn_delta_editor_invoke_open_root_wrapper", _wrap_svn_delta_editor_invoke_open_root_wrapper, -1);
10020 rb_define_module_function(mDelta, "svn_delta_editor_invoke_add_directory_wrapper", _wrap_svn_delta_editor_invoke_add_directory_wrapper, -1);
10021 rb_define_module_function(mDelta, "svn_delta_editor_invoke_open_directory_wrapper", _wrap_svn_delta_editor_invoke_open_directory_wrapper, -1);
10022 rb_define_module_function(mDelta, "svn_delta_editor_invoke_add_file_wrapper", _wrap_svn_delta_editor_invoke_add_file_wrapper, -1);
10023 rb_define_module_function(mDelta, "svn_delta_editor_invoke_open_file_wrapper", _wrap_svn_delta_editor_invoke_open_file_wrapper, -1);
10024 rb_define_module_function(mDelta, "svn_delta_editor_invoke_apply_textdelta_wrapper", _wrap_svn_delta_editor_invoke_apply_textdelta_wrapper, -1);
10025 rb_define_module_function(mDelta, "svn_txdelta_invoke_window_handler_wrapper", _wrap_svn_txdelta_invoke_window_handler_wrapper, -1);
10026 rb_define_module_function(mDelta, "svn_txdelta_editor_invoke_apply_textdelta_wrapper", _wrap_svn_txdelta_editor_invoke_apply_textdelta_wrapper, -1);
10027 rb_define_module_function(mDelta, "svn_txdelta_md5_digest_as_cstring", _wrap_svn_txdelta_md5_digest_as_cstring, -1);
10028 }
10029
10030