← Back to branch summary

~ubuntu-branches/debian/sid/subversion/sid

« back to all changes in this revision

Viewing changes to subversion/bindings/swig/perl/native/svn_delta.c

  • Committer: Package Import Robot
  • Author(s): James McCoy
  • Date: 2015-08-07 21:32:47 UTC
  • mfrom: (0.2.15) (4.1.7 experimental)
  • Revision ID: package-import@ubuntu.com-20150807213247-ozyewtmgsr6tkewl
Tags: 1.9.0-1
http://bugs.debian.org/791844
* Upload to unstable
* New upstream release.
  + Security fixes
    - CVE-2015-3184: Mixed anonymous/authenticated path-based authz with
      httpd 2.4
    - CVE-2015-3187: svn_repos_trace_node_locations() reveals paths hidden
      by authz
* Add >= 2.7 requirement for python-all-dev Build-Depends, needed to run
  tests.
* Remove Build-Conflicts against ruby-test-unit.  (Closes: #791844)
* Remove patches/apache_module_dependency in favor of expressing the
  dependencies in authz_svn.load/dav_svn.load.
* Build-Depend on apache2-dev (>= 2.4.16) to ensure ap_some_authn_required()
  is available when building mod_authz_svn and Depend on apache2-bin (>=
  2.4.16) for runtime support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
subversion/bindings/swig/perl/native/svn_delta.c
1
1
/* ----------------------------------------------------------------------------
2
2
 * This file was automatically generated by SWIG (http://www.swig.org).
3
 
 * Version 2.0.9
4
 
 * 
5
 
 * This file is not intended to be easily readable and contains a number of 
 
3
 * Version 2.0.12
 
4
 *
 
5
 * This file is not intended to be easily readable and contains a number of
6
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. 
 
7
 * changes to this file unless you know what you are doing--modify the SWIG
 
8
 * interface file instead.
9
9
 * ----------------------------------------------------------------------------- */
10
10
 
11
11
#define SWIGPERL
42
42
#ifndef SWIGUNUSED
43
43
# if defined(__GNUC__)
44
44
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
45
 
#     define SWIGUNUSED __attribute__ ((__unused__)) 
 
45
#     define SWIGUNUSED __attribute__ ((__unused__))
46
46
#   else
47
47
#     define SWIGUNUSED
48
48
#   endif
49
49
# elif defined(__ICC)
50
 
#   define SWIGUNUSED __attribute__ ((__unused__)) 
 
50
#   define SWIGUNUSED __attribute__ ((__unused__))
51
51
# else
52
 
#   define SWIGUNUSED 
 
52
#   define SWIGUNUSED
53
53
# endif
54
54
#endif
55
55
 
56
56
#ifndef SWIG_MSC_UNSUPPRESS_4505
57
57
# if defined(_MSC_VER)
58
58
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
59
 
# endif 
 
59
# endif
60
60
#endif
61
61
 
62
62
#ifndef SWIGUNUSEDPARM
63
63
# ifdef __cplusplus
64
64
#   define SWIGUNUSEDPARM(p)
65
65
# else
66
 
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
 
66
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
67
67
# endif
68
68
#endif
69
69
 
106
106
#   define SWIGSTDCALL __stdcall
107
107
# else
108
108
#   define SWIGSTDCALL
109
 
# endif 
 
109
# endif
110
110
#endif
111
111
 
112
112
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
144
144
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
145
145
  creating a static or dynamic library from the SWIG runtime code.
146
146
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
147
 
  
 
147
 
148
148
  But only do this if strictly necessary, ie, if you have problems
149
149
  with your compiler or suchlike.
150
150
*/
170
170
#define SWIG_POINTER_OWN           0x1
171
171
 
172
172
 
173
 
/* 
 
173
/*
174
174
   Flags/methods for returning states.
175
 
   
176
 
   The SWIG conversion methods, as ConvertPtr, return an integer 
 
175
 
 
176
   The SWIG conversion methods, as ConvertPtr, return an integer
177
177
   that tells if the conversion was successful or not. And if not,
178
178
   an error code can be returned (see swigerrors.swg for the codes).
179
 
   
 
179
 
180
180
   Use the following macros/flags to set or process the returning
181
181
   states.
182
 
   
 
182
 
183
183
   In old versions of SWIG, code such as the following was usually written:
184
184
 
185
185
     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
212
212
    } else {
213
213
      // fail code
214
214
    }
215
 
    
 
215
 
216
216
   I.e., now SWIG_ConvertPtr can return new objects and you can
217
217
   identify the case and take care of the deallocation. Of course that
218
218
   also requires SWIG_ConvertPtr to return new result values, such as
219
219
 
220
 
      int SWIG_ConvertPtr(obj, ptr,...) {         
221
 
        if (<obj is ok>) {                             
222
 
          if (<need new object>) {                     
223
 
            *ptr = <ptr to new allocated object>; 
224
 
            return SWIG_NEWOBJ;                
225
 
          } else {                                     
226
 
            *ptr = <ptr to old object>;        
227
 
            return SWIG_OLDOBJ;                
228
 
          }                                    
229
 
        } else {                                       
230
 
          return SWIG_BADOBJ;                  
231
 
        }                                              
 
220
      int SWIG_ConvertPtr(obj, ptr,...) {
 
221
        if (<obj is ok>) {
 
222
          if (<need new object>) {
 
223
            *ptr = <ptr to new allocated object>;
 
224
            return SWIG_NEWOBJ;
 
225
          } else {
 
226
            *ptr = <ptr to old object>;
 
227
            return SWIG_OLDOBJ;
 
228
          }
 
229
        } else {
 
230
          return SWIG_BADOBJ;
 
231
        }
232
232
      }
233
233
 
234
234
   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242
242
       int fooi(int);
243
243
 
244
244
   and you call
245
 
 
 
245
 
246
246
      food(1)   // cast rank '1'  (1 -> 1.0)
247
247
      fooi(1)   // cast rank '0'
248
248
 
249
249
   just use the SWIG_AddCast()/SWIG_CheckState()
250
250
*/
251
251
 
252
 
#define SWIG_OK                    (0) 
 
252
#define SWIG_OK                    (0)
253
253
#define SWIG_ERROR                 (-1)
254
254
#define SWIG_IsOK(r)               (r >= 0)
255
 
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
 
255
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
256
256
 
257
257
/* The CastRankLimit says how many bits are used for the cast rank */
258
258
#define SWIG_CASTRANKLIMIT         (1 << 8)
283
283
#  endif
284
284
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
285
285
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
286
 
SWIGINTERNINLINE int SWIG_AddCast(int r) { 
 
286
SWIGINTERNINLINE int SWIG_AddCast(int r) {
287
287
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
288
288
}
289
 
SWIGINTERNINLINE int SWIG_CheckState(int r) { 
290
 
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
 
289
SWIGINTERNINLINE int SWIG_CheckState(int r) {
 
290
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
291
291
}
292
292
#else /* no cast-rank mode */
293
 
#  define SWIG_AddCast
 
293
#  define SWIG_AddCast(r) (r)
294
294
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
295
295
#endif
296
296
 
334
334
  void                    *clientdata;          /* Language specific module data */
335
335
} swig_module_info;
336
336
 
337
 
/* 
 
337
/*
338
338
  Compare two type names skipping the space characters, therefore
339
339
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
340
340
 
354
354
 
355
355
/*
356
356
  Check type equivalence in a name list like <name1>|<name2>|...
 
357
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 
358
*/
 
359
SWIGRUNTIME int
 
360
SWIG_TypeCmp(const char *nb, const char *tb) {
 
361
  int equiv = 1;
 
362
  const char* te = tb + strlen(tb);
 
363
  const char* ne = nb;
 
364
  while (equiv != 0 && *ne) {
 
365
    for (nb = ne; *ne; ++ne) {
 
366
      if (*ne == '|') break;
 
367
    }
 
368
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
 
369
    if (*ne) ++ne;
 
370
  }
 
371
  return equiv;
 
372
}
 
373
 
 
374
/*
 
375
  Check type equivalence in a name list like <name1>|<name2>|...
357
376
  Return 0 if not equal, 1 if equal
358
377
*/
359
378
SWIGRUNTIME int
360
379
SWIG_TypeEquiv(const char *nb, const char *tb) {
361
 
  int equiv = 0;
362
 
  const char* te = tb + strlen(tb);
363
 
  const char* ne = nb;
364
 
  while (!equiv && *ne) {
365
 
    for (nb = ne; *ne; ++ne) {
366
 
      if (*ne == '|') break;
367
 
    }
368
 
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
369
 
    if (*ne) ++ne;
370
 
  }
371
 
  return equiv;
372
 
}
373
 
 
374
 
/*
375
 
  Check type equivalence in a name list like <name1>|<name2>|...
376
 
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
377
 
*/
378
 
SWIGRUNTIME int
379
 
SWIG_TypeCompare(const char *nb, const char *tb) {
380
 
  int equiv = 0;
381
 
  const char* te = tb + strlen(tb);
382
 
  const char* ne = nb;
383
 
  while (!equiv && *ne) {
384
 
    for (nb = ne; *ne; ++ne) {
385
 
      if (*ne == '|') break;
386
 
    }
387
 
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
388
 
    if (*ne) ++ne;
389
 
  }
390
 
  return equiv;
391
 
}
392
 
 
 
380
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
 
381
}
393
382
 
394
383
/*
395
384
  Check the typename
418
407
  return 0;
419
408
}
420
409
 
421
 
/* 
 
410
/*
422
411
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
423
412
*/
424
413
SWIGRUNTIME swig_cast_info *
453
442
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
454
443
}
455
444
 
456
 
/* 
 
445
/*
457
446
   Dynamic pointer casting. Down an inheritance hierarchy
458
447
*/
459
448
SWIGRUNTIME swig_type_info *
497
486
    return type->name;
498
487
}
499
488
 
500
 
/* 
 
489
/*
501
490
   Set the clientdata field for a type
502
491
*/
503
492
SWIGRUNTIME void
505
494
  swig_cast_info *cast = ti->cast;
506
495
  /* if (ti->clientdata == clientdata) return; */
507
496
  ti->clientdata = clientdata;
508
 
  
 
497
 
509
498
  while (cast) {
510
499
    if (!cast->converter) {
511
500
      swig_type_info *tc = cast->type;
512
501
      if (!tc->clientdata) {
513
502
        SWIG_TypeClientData(tc, clientdata);
514
503
      }
515
 
    }    
 
504
    }
516
505
    cast = cast->next;
517
506
  }
518
507
}
521
510
  SWIG_TypeClientData(ti, clientdata);
522
511
  ti->owndata = 1;
523
512
}
524
 
  
 
513
 
525
514
/*
526
515
  Search for a swig_type_info structure only by mangled name
527
516
  Search is a O(log #types)
528
 
  
529
 
  We start searching at module start, and finish searching when start == end.  
 
517
 
 
518
  We start searching at module start, and finish searching when start == end.
530
519
  Note: if start == end at the beginning of the function, we go all the way around
531
520
  the circular list.
532
521
*/
533
522
SWIGRUNTIME swig_type_info *
534
 
SWIG_MangledTypeQueryModule(swig_module_info *start, 
535
 
                            swig_module_info *end, 
 
523
SWIG_MangledTypeQueryModule(swig_module_info *start,
 
524
                            swig_module_info *end,
536
525
                            const char *name) {
537
526
  swig_module_info *iter = start;
538
527
  do {
541
530
      register size_t r = iter->size - 1;
542
531
      do {
543
532
        /* since l+r >= 0, we can (>> 1) instead (/ 2) */
544
 
        register size_t i = (l + r) >> 1; 
 
533
        register size_t i = (l + r) >> 1;
545
534
        const char *iname = iter->types[i]->name;
546
535
        if (iname) {
547
536
          register int compare = strcmp(name, iname);
548
 
          if (compare == 0) {       
 
537
          if (compare == 0) {
549
538
            return iter->types[i];
550
539
          } else if (compare < 0) {
551
540
            if (i) {
570
559
  Search for a swig_type_info structure for either a mangled name or a human readable name.
571
560
  It first searches the mangled names of the types, which is a O(log #types)
572
561
  If a type is not found it then searches the human readable names, which is O(#types).
573
 
  
574
 
  We start searching at module start, and finish searching when start == end.  
 
562
 
 
563
  We start searching at module start, and finish searching when start == end.
575
564
  Note: if start == end at the beginning of the function, we go all the way around
576
565
  the circular list.
577
566
*/
578
567
SWIGRUNTIME swig_type_info *
579
 
SWIG_TypeQueryModule(swig_module_info *start, 
580
 
                     swig_module_info *end, 
 
568
SWIG_TypeQueryModule(swig_module_info *start,
 
569
                     swig_module_info *end,
581
570
                     const char *name) {
582
571
  /* STEP 1: Search the name field using binary search */
583
572
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
596
585
      iter = iter->next;
597
586
    } while (iter != end);
598
587
  }
599
 
  
 
588
 
600
589
  /* neither found a match */
601
590
  return 0;
602
591
}
603
592
 
604
 
/* 
 
593
/*
605
594
   Pack binary data into a string
606
595
*/
607
596
SWIGRUNTIME char *
617
606
  return c;
618
607
}
619
608
 
620
 
/* 
 
609
/*
621
610
   Unpack binary data from a string
622
611
*/
623
612
SWIGRUNTIME const char *
631
620
      uu = ((d - '0') << 4);
632
621
    else if ((d >= 'a') && (d <= 'f'))
633
622
      uu = ((d - ('a'-10)) << 4);
634
 
    else 
 
623
    else
635
624
      return (char *) 0;
636
625
    d = *(c++);
637
626
    if ((d >= '0') && (d <= '9'))
638
627
      uu |= (d - '0');
639
628
    else if ((d >= 'a') && (d <= 'f'))
640
629
      uu |= (d - ('a'-10));
641
 
    else 
 
630
    else
642
631
      return (char *) 0;
643
632
    *u = uu;
644
633
  }
645
634
  return c;
646
635
}
647
636
 
648
 
/* 
 
637
/*
649
638
   Pack 'void *' into a string buffer.
650
639
*/
651
640
SWIGRUNTIME char *
705
694
#endif
706
695
 
707
696
/*  Errors in SWIG */
708
 
#define  SWIG_UnknownError         -1 
709
 
#define  SWIG_IOError              -2 
710
 
#define  SWIG_RuntimeError         -3 
711
 
#define  SWIG_IndexError           -4 
712
 
#define  SWIG_TypeError            -5 
713
 
#define  SWIG_DivisionByZero       -6 
714
 
#define  SWIG_OverflowError        -7 
715
 
#define  SWIG_SyntaxError          -8 
716
 
#define  SWIG_ValueError           -9 
 
697
#define  SWIG_UnknownError         -1
 
698
#define  SWIG_IOError              -2
 
699
#define  SWIG_RuntimeError         -3
 
700
#define  SWIG_IndexError           -4
 
701
#define  SWIG_TypeError            -5
 
702
#define  SWIG_DivisionByZero       -6
 
703
#define  SWIG_OverflowError        -7
 
704
#define  SWIG_SyntaxError          -8
 
705
#define  SWIG_ValueError           -9
717
706
#define  SWIG_SystemError          -10
718
707
#define  SWIG_AttributeError       -11
719
 
#define  SWIG_MemoryError          -12 
 
708
#define  SWIG_MemoryError          -12
720
709
#define  SWIG_NullReferenceError   -13
721
710
 
722
711
 
1608
1597
#define SWIG_name   "SVN::_Delta::boot_SVN___Delta"
1609
1598
#define SWIG_prefix "SVN::_Delta::"
1610
1599
 
1611
 
#define SWIGVERSION 0x020009 
 
1600
#define SWIGVERSION 0x020012 
1612
1601
#define SWIG_VERSION SWIGVERSION
1613
1602
 
1614
1603
 
2122
2111
#ifdef __cplusplus
2123
2112
extern "C" {
2124
2113
#endif
2125
 
XS(_wrap_svn_delta_wrap_window_handler) {
2126
 
  {
2127
 
    svn_txdelta_window_handler_t *arg1 = (svn_txdelta_window_handler_t *) 0 ;
2128
 
    void **arg2 = (void **) 0 ;
2129
 
    SV *arg3 = (SV *) 0 ;
2130
 
    apr_pool_t *arg4 = (apr_pool_t *) 0 ;
2131
 
    apr_pool_t *_global_pool ;
2132
 
    svn_txdelta_window_handler_t temp1 ;
2133
 
    void *temp2 ;
2134
 
    int argvi = 0;
2135
 
    dXSARGS;
2136
 
    
2137
 
    {
2138
 
      _global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
2139
 
    }
2140
 
    arg1 = &temp1;
2141
 
    arg2 = &temp2;
2142
 
    if ((items < 1) || (items > 2)) {
2143
 
      SWIG_croak("Usage: svn_delta_wrap_window_handler(callback,pool);");
2144
 
    }
2145
 
    arg3 = ST(0);
2146
 
    if (items > 1) {
2147
 
      
2148
 
    }
2149
 
    {
2150
 
      svn_delta_wrap_window_handler(arg1,arg2,arg3,arg4);
2151
 
      
2152
 
      
2153
 
      
2154
 
    }
2155
 
    ST(argvi) = sv_newmortal();
2156
 
    {
2157
 
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_NewPointerObj(*arg1, SWIGTYPE_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, 0); argvi++  ;
2158
 
    }
2159
 
    {
2160
 
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_NewPointerObj(*arg2, SWIGTYPE_p_void, 0); argvi++  ;
2161
 
    }
2162
 
    
2163
 
    
2164
 
    
2165
 
    
2166
 
    XSRETURN(argvi);
2167
 
  fail:
2168
 
    
2169
 
    
2170
 
    
2171
 
    
2172
 
    SWIG_croak_null();
2173
 
  }
2174
 
}
2175
 
 
2176
 
 
2177
2114
XS(_wrap_svn_delta_version) {
2178
2115
  {
2179
2116
    int argvi = 0;
2503
2440
    arg1 = (struct svn_txdelta_window_t *)(argp1);
2504
2441
    result =  ((arg1)->sview_offset);
2505
2442
    {
2506
 
      char temp[256];
 
2443
      char temp[30];
2507
2444
      sprintf(temp, "%" APR_INT64_T_FMT, (apr_int64_t) result);
2508
 
      ST(argvi) = sv_newmortal();
2509
 
      sv_setpv((SV*)ST(argvi++), temp);
 
2445
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = sv_2mortal(newSVpv(temp, 0)); argvi++  ;
2510
2446
    }
2511
2447
    
2512
2448
    XSRETURN(argvi);
3107
3043
    int val5 ;
3108
3044
    int ecode5 = 0 ;
3109
3045
    svn_checksum_t *temp6 ;
3110
 
    int res8 ;
3111
3046
    int argvi = 0;
3112
3047
    svn_error_t *result = 0 ;
3113
3048
    dXSARGS;
3119
3054
      _global_pool = arg10 = svn_swig_pl_make_pool (ST(items-1));
3120
3055
    }
3121
3056
    arg6 = &temp6;
3122
 
    if ((items < 7) || (items > 9)) {
 
3057
    if ((items < 6) || (items > 8)) {
3123
3058
      SWIG_croak("Usage: svn_txdelta_run(source,target,handler,handler_baton,checksum_kind,cancel_func,cancel_baton,result_pool,scratch_pool);");
3124
3059
    }
3125
3060
    {
3144
3079
    } 
3145
3080
    arg5 = (svn_checksum_kind_t)(val5);
3146
3081
    {
3147
 
      int res = SWIG_ConvertFunctionPtr(ST(5), (void**)(&arg7), SWIGTYPE_p_f_p_void__p_svn_error_t);
3148
 
      if (!SWIG_IsOK(res)) {
3149
 
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_txdelta_run" "', argument " "7"" of type '" "svn_cancel_func_t""'"); 
3150
 
      }
 
3082
      arg7 = (svn_cancel_func_t) svn_swig_pl_cancel_func;
 
3083
      arg8 = ST(5);
3151
3084
    }
3152
 
    res8 = SWIG_ConvertPtr(ST(6),SWIG_as_voidptrptr(&arg8), 0, 0);
3153
 
    if (!SWIG_IsOK(res8)) {
3154
 
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "svn_txdelta_run" "', argument " "8"" of type '" "void *""'"); 
 
3085
    if (items > 6) {
 
3086
      
3155
3087
    }
3156
3088
    if (items > 7) {
3157
3089
      
3158
3090
    }
3159
 
    if (items > 8) {
3160
 
      
3161
 
    }
3162
3091
    {
3163
3092
      result = (svn_error_t *)svn_txdelta_run(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
3164
3093
      
3198
3127
    
3199
3128
    
3200
3129
    
3201
 
    
3202
 
    
3203
3130
    XSRETURN(argvi);
3204
3131
  fail:
3205
3132
    
3210
3137
    
3211
3138
    
3212
3139
    
3213
 
    
3214
 
    
3215
3140
    SWIG_croak_null();
3216
3141
  }
3217
3142
}
3686
3611
      }
3687
3612
    }
3688
3613
    {
3689
 
      /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,59,%append_output@*/ if (argvi >= items) EXTEND(sp,1); /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,56,%set_output@*/ ST(argvi) = sv_2mortal(newSVpv(svn_md5_digest_to_cstring(arg4,
 
3614
      /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,59,%append_output@*/ if (argvi >= items) EXTEND(sp,1); /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,56,%set_output@*/ ST(argvi) = sv_2mortal(newSVpv(svn_md5_digest_to_cstring(arg4,
3690
3615
            _global_pool),
3691
3616
          0)); argvi++ /*@SWIG@*/
3692
3617
      
3922
3847
    }
3923
3848
    ST(argvi) = sv_newmortal();
3924
3849
    {
3925
 
      /* FIXME: This code is clearly buggy. The return value of sv_newmortal()
3926
 
           is immediately overwritten by the return value
3927
 
           of svn_swig_pl_from_md5(). */
3928
 
      ST(argvi) = sv_newmortal();
3929
 
      ST(argvi++) = svn_swig_pl_from_md5(arg3);
 
3850
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = svn_swig_pl_from_md5(arg3); argvi++  ;
3930
3851
    }
3931
3852
    {
3932
3853
      if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_NewPointerObj(*arg6, SWIGTYPE_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, 0); argvi++  ;
5524
5445
    void **arg6 = (void **) 0 ;
5525
5446
    apr_pool_t *arg7 = (apr_pool_t *) 0 ;
5526
5447
    apr_pool_t *_global_pool ;
5527
 
    int res2 ;
5528
5448
    void *argp3 = 0 ;
5529
5449
    int res3 = 0 ;
5530
5450
    int res4 ;
5539
5459
    }
5540
5460
    arg5 = &temp5;
5541
5461
    arg6 = &temp6;
5542
 
    if ((items < 4) || (items > 5)) {
 
5462
    if ((items < 3) || (items > 4)) {
5543
5463
      SWIG_croak("Usage: svn_delta_get_cancellation_editor(cancel_func,cancel_baton,wrapped_editor,wrapped_baton,pool);");
5544
5464
    }
5545
5465
    {
5546
 
      int res = SWIG_ConvertFunctionPtr(ST(0), (void**)(&arg1), SWIGTYPE_p_f_p_void__p_svn_error_t);
5547
 
      if (!SWIG_IsOK(res)) {
5548
 
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_delta_get_cancellation_editor" "', argument " "1"" of type '" "svn_cancel_func_t""'"); 
5549
 
      }
5550
 
    }
5551
 
    res2 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg2), 0, 0);
5552
 
    if (!SWIG_IsOK(res2)) {
5553
 
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_delta_get_cancellation_editor" "', argument " "2"" of type '" "void *""'"); 
5554
 
    }
5555
 
    res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_svn_delta_editor_t, 0 |  0 );
 
5466
      arg1 = (svn_cancel_func_t) svn_swig_pl_cancel_func;
 
5467
      arg2 = ST(0);
 
5468
    }
 
5469
    res3 = SWIG_ConvertPtr(ST(1), &argp3,SWIGTYPE_p_svn_delta_editor_t, 0 |  0 );
5556
5470
    if (!SWIG_IsOK(res3)) {
5557
5471
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_delta_get_cancellation_editor" "', argument " "3"" of type '" "svn_delta_editor_t const *""'"); 
5558
5472
    }
5559
5473
    arg3 = (svn_delta_editor_t *)(argp3);
5560
 
    res4 = SWIG_ConvertPtr(ST(3),SWIG_as_voidptrptr(&arg4), 0, 0);
 
5474
    res4 = SWIG_ConvertPtr(ST(2),SWIG_as_voidptrptr(&arg4), 0, 0);
5561
5475
    if (!SWIG_IsOK(res4)) {
5562
5476
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "svn_delta_get_cancellation_editor" "', argument " "4"" of type '" "void *""'"); 
5563
5477
    }
5564
 
    if (items > 4) {
 
5478
    if (items > 3) {
5565
5479
      
5566
5480
    }
5567
5481
    {
5597
5511
    
5598
5512
    
5599
5513
    
5600
 
    
5601
 
    
5602
5514
    XSRETURN(argvi);
5603
5515
  fail:
5604
5516
    
5606
5518
    
5607
5519
    
5608
5520
    
5609
 
    
5610
 
    
5611
5521
    SWIG_croak_null();
5612
5522
  }
5613
5523
}
5739
5649
      SWIG_croak("Usage: svn_delta_path_driver2(editor,edit_baton,paths,sort_paths,callback_func,callback_baton,scratch_pool);");
5740
5650
    }
5741
5651
    {
5742
 
      svn_delta_make_editor(&arg1, &arg2, ST(0), _global_pool);
 
5652
      svn_swig_pl_make_editor(&arg1, &arg2, ST(0), _global_pool);
5743
5653
    }
5744
5654
    {
5745
 
      arg3 = (apr_array_header_t *) svn_swig_pl_strings_to_array(ST(1),
 
5655
      arg3 = svn_swig_pl_strings_to_array(ST(1),
5746
5656
        _global_pool);
5747
5657
    }
5748
5658
    ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val4);
5826
5736
      SWIG_croak("Usage: svn_delta_path_driver(editor,edit_baton,revision,paths,callback_func,callback_baton,scratch_pool);");
5827
5737
    }
5828
5738
    {
5829
 
      svn_delta_make_editor(&arg1, &arg2, ST(0), _global_pool);
 
5739
      svn_swig_pl_make_editor(&arg1, &arg2, ST(0), _global_pool);
5830
5740
    }
5831
5741
    ecode3 = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(ST(1), &val3);
5832
5742
    if (!SWIG_IsOK(ecode3)) {
5834
5744
    } 
5835
5745
    arg3 = (svn_revnum_t)(val3);
5836
5746
    {
5837
 
      arg4 = (apr_array_header_t *) svn_swig_pl_strings_to_array(ST(2),
 
5747
      arg4 = svn_swig_pl_strings_to_array(ST(2),
5838
5748
        _global_pool);
5839
5749
    }
5840
5750
    {
8277
8187
{0,0,0,0}
8278
8188
};
8279
8189
static swig_command_info swig_commands[] = {
8280
 
{"SVN::_Delta::svn_delta_wrap_window_handler", _wrap_svn_delta_wrap_window_handler},
8281
8190
{"SVN::_Delta::svn_delta_version", _wrap_svn_delta_version},
8282
8191
{"SVN::_Delta::svn_txdelta_op_t_action_code_set", _wrap_svn_txdelta_op_t_action_code_set},
8283
8192
{"SVN::_Delta::svn_txdelta_op_t_action_code_get", _wrap_svn_txdelta_op_t_action_code_get},
8390
8299
};
8391
8300
/* -----------------------------------------------------------------------------
8392
8301
 * Type initialization:
8393
 
 * This problem is tough by the requirement that no dynamic 
8394
 
 * memory is used. Also, since swig_type_info structures store pointers to 
 
8302
 * This problem is tough by the requirement that no dynamic
 
8303
 * memory is used. Also, since swig_type_info structures store pointers to
8395
8304
 * swig_cast_info structures and swig_cast_info structures store pointers back
8396
 
 * to swig_type_info structures, we need some lookup code at initialization. 
8397
 
 * The idea is that swig generates all the structures that are needed. 
8398
 
 * The runtime then collects these partially filled structures. 
8399
 
 * The SWIG_InitializeModule function takes these initial arrays out of 
 
8305
 * to swig_type_info structures, we need some lookup code at initialization.
 
8306
 * The idea is that swig generates all the structures that are needed.
 
8307
 * The runtime then collects these partially filled structures.
 
8308
 * The SWIG_InitializeModule function takes these initial arrays out of
8400
8309
 * swig_module, and does all the lookup, filling in the swig_module.types
8401
8310
 * array with the correct data and linking the correct swig_cast_info
8402
8311
 * structures together.
8403
8312
 *
8404
 
 * The generated swig_type_info structures are assigned staticly to an initial 
 
8313
 * The generated swig_type_info structures are assigned staticly to an initial
8405
8314
 * array. We just loop through that array, and handle each type individually.
8406
8315
 * First we lookup if this type has been already loaded, and if so, use the
8407
8316
 * loaded structure instead of the generated one. Then we have to fill in the
8411
8320
 * a column is one of the swig_cast_info structures for that type.
8412
8321
 * The cast_initial array is actually an array of arrays, because each row has
8413
8322
 * a variable number of columns. So to actually build the cast linked list,
8414
 
 * we find the array of casts associated with the type, and loop through it 
 
8323
 * we find the array of casts associated with the type, and loop through it
8415
8324
 * adding the casts to the list. The one last trick we need to do is making
8416
8325
 * sure the type pointer in the swig_cast_info struct is correct.
8417
8326
 *
8418
 
 * First off, we lookup the cast->type name to see if it is already loaded. 
 
8327
 * First off, we lookup the cast->type name to see if it is already loaded.
8419
8328
 * There are three cases to handle:
8420
8329
 *  1) If the cast->type has already been loaded AND the type we are adding
8421
8330
 *     casting info to has not been loaded (it is in this module), THEN we
8422
8331
 *     replace the cast->type pointer with the type pointer that has already
8423
8332
 *     been loaded.
8424
 
 *  2) If BOTH types (the one we are adding casting info to, and the 
 
8333
 *  2) If BOTH types (the one we are adding casting info to, and the
8425
8334
 *     cast->type) are loaded, THEN the cast info has already been loaded by
8426
8335
 *     the previous module so we just ignore it.
8427
8336
 *  3) Finally, if cast->type has not already been loaded, then we add that
8484
8393
    module_head->next = &swig_module;
8485
8394
  }
8486
8395
  
8487
 
  /* When multiple interpeters are used, a module could have already been initialized in
 
8396
  /* When multiple interpreters are used, a module could have already been initialized in
8488
8397
       a different interpreter, but not yet have a pointer in this interpreter.
8489
8398
       In this case, we do not want to continue adding types... everything should be
8490
8399
       set up already */
8683
8592
    SvREADONLY_on(sv);
8684
8593
  }
8685
8594
  
8686
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
8595
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
8687
8596
    SV *sv = get_sv((char*) SWIG_prefix "SVN_DELTA_COMPRESSION_LEVEL_NONE", TRUE | 0x2 | GV_ADDMULTI);
8688
8597
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(0)));
8689
8598
    SvREADONLY_on(sv);
8690
8599
  } while(0) /*@SWIG@*/;
8691
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
8600
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
8692
8601
    SV *sv = get_sv((char*) SWIG_prefix "SVN_DELTA_COMPRESSION_LEVEL_MAX", TRUE | 0x2 | GV_ADDMULTI);
8693
8602
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(9)));
8694
8603
    SvREADONLY_on(sv);
8695
8604
  } while(0) /*@SWIG@*/;
8696
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
8605
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
8697
8606
    SV *sv = get_sv((char*) SWIG_prefix "SVN_DELTA_COMPRESSION_LEVEL_DEFAULT", TRUE | 0x2 | GV_ADDMULTI);
8698
8607
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(5)));
8699
8608
    SvREADONLY_on(sv);
8700
8609
  } while(0) /*@SWIG@*/;
8701
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
8610
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
8702
8611
    SV *sv = get_sv((char*) SWIG_prefix "svn_txdelta_source", TRUE | 0x2 | GV_ADDMULTI);
8703
8612
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_txdelta_source)));
8704
8613
    SvREADONLY_on(sv);
8705
8614
  } while(0) /*@SWIG@*/;
8706
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
8615
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
8707
8616
    SV *sv = get_sv((char*) SWIG_prefix "svn_txdelta_target", TRUE | 0x2 | GV_ADDMULTI);
8708
8617
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_txdelta_target)));
8709
8618
    SvREADONLY_on(sv);
8710
8619
  } while(0) /*@SWIG@*/;
8711
 
  /*@SWIG:/tmp/svnrm/prefix/share/swig/2.0.9/perl5/perltypemaps.swg,65,%set_constant@*/ do {
 
8620
  /*@SWIG:/opt/svnrm/prefix/share/swig/2.0.12/perl5/perltypemaps.swg,65,%set_constant@*/ do {
8712
8621
    SV *sv = get_sv((char*) SWIG_prefix "svn_txdelta_new", TRUE | 0x2 | GV_ADDMULTI);
8713
8622
    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(svn_txdelta_new)));
8714
8623
    SvREADONLY_on(sv);