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

« back to all changes in this revision

Viewing changes to subversion/bindings/swig/perl/native/svn_diff.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
* 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:
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
 
1574
1563
#define SWIG_name   "SVN::_Diff::boot_SVN___Diff"
1575
1564
#define SWIG_prefix "SVN::_Diff::"
1576
1565
 
1577
 
#define SWIGVERSION 0x020009 
 
1566
#define SWIGVERSION 0x020012 
1578
1567
#define SWIG_VERSION SWIGVERSION
1579
1568
 
1580
1569
 
1935
1924
};
1936
1925
/* -----------------------------------------------------------------------------
1937
1926
 * Type initialization:
1938
 
 * This problem is tough by the requirement that no dynamic 
1939
 
 * memory is used. Also, since swig_type_info structures store pointers to 
 
1927
 * This problem is tough by the requirement that no dynamic
 
1928
 * memory is used. Also, since swig_type_info structures store pointers to
1940
1929
 * swig_cast_info structures and swig_cast_info structures store pointers back
1941
 
 * to swig_type_info structures, we need some lookup code at initialization. 
1942
 
 * The idea is that swig generates all the structures that are needed. 
1943
 
 * The runtime then collects these partially filled structures. 
1944
 
 * The SWIG_InitializeModule function takes these initial arrays out of 
 
1930
 * to swig_type_info structures, we need some lookup code at initialization.
 
1931
 * The idea is that swig generates all the structures that are needed.
 
1932
 * The runtime then collects these partially filled structures.
 
1933
 * The SWIG_InitializeModule function takes these initial arrays out of
1945
1934
 * swig_module, and does all the lookup, filling in the swig_module.types
1946
1935
 * array with the correct data and linking the correct swig_cast_info
1947
1936
 * structures together.
1948
1937
 *
1949
 
 * The generated swig_type_info structures are assigned staticly to an initial 
 
1938
 * The generated swig_type_info structures are assigned staticly to an initial
1950
1939
 * array. We just loop through that array, and handle each type individually.
1951
1940
 * First we lookup if this type has been already loaded, and if so, use the
1952
1941
 * loaded structure instead of the generated one. Then we have to fill in the
1956
1945
 * a column is one of the swig_cast_info structures for that type.
1957
1946
 * The cast_initial array is actually an array of arrays, because each row has
1958
1947
 * a variable number of columns. So to actually build the cast linked list,
1959
 
 * we find the array of casts associated with the type, and loop through it 
 
1948
 * we find the array of casts associated with the type, and loop through it
1960
1949
 * adding the casts to the list. The one last trick we need to do is making
1961
1950
 * sure the type pointer in the swig_cast_info struct is correct.
1962
1951
 *
1963
 
 * First off, we lookup the cast->type name to see if it is already loaded. 
 
1952
 * First off, we lookup the cast->type name to see if it is already loaded.
1964
1953
 * There are three cases to handle:
1965
1954
 *  1) If the cast->type has already been loaded AND the type we are adding
1966
1955
 *     casting info to has not been loaded (it is in this module), THEN we
1967
1956
 *     replace the cast->type pointer with the type pointer that has already
1968
1957
 *     been loaded.
1969
 
 *  2) If BOTH types (the one we are adding casting info to, and the 
 
1958
 *  2) If BOTH types (the one we are adding casting info to, and the
1970
1959
 *     cast->type) are loaded, THEN the cast info has already been loaded by
1971
1960
 *     the previous module so we just ignore it.
1972
1961
 *  3) Finally, if cast->type has not already been loaded, then we add that
2029
2018
    module_head->next = &swig_module;
2030
2019
  }
2031
2020
  
2032
 
  /* When multiple interpeters are used, a module could have already been initialized in
 
2021
  /* When multiple interpreters are used, a module could have already been initialized in
2033
2022
       a different interpreter, but not yet have a pointer in this interpreter.
2034
2023
       In this case, we do not want to continue adding types... everything should be
2035
2024
       set up already */