← Back to branch summary

~ubuntu-branches/debian/sid/redland-bindings/sid

« back to all changes in this revision

Viewing changes to perl/CORE_wrap.c

  • Committer: Package Import Robot
  • Author(s): Dave Beckett
  • Date: 2013-01-22 16:03:44 UTC
  • mfrom: (0.1.10)
  • Revision ID: package-import@ubuntu.com-20130122160344-vxrnfl0xynfzbze7
Tags: 1.0.16.1-1
* New upstream release
* Add dpkg-buildflags to configure for hardening

Show diffs side-by-side

added added

removed removed

Lines of Context:
perl/CORE_wrap.c
1
1
/* ----------------------------------------------------------------------------
2
2
 * This file was automatically generated by SWIG (http://www.swig.org).
3
 
 * Version 1.3.40
 
3
 * Version 2.0.7
4
4
 * 
5
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
173
173
/* 
174
174
   Flags/methods for returning states.
175
175
   
176
 
   The SWIG conversion methods, as ConvertPtr, return and integer 
 
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
   
830
830
 
831
831
SWIGINTERN const char*
832
832
SWIG_Perl_ErrorType(int code) {
833
 
  const char* type = 0;
834
833
  switch(code) {
835
834
  case SWIG_MemoryError:
836
 
    type = "MemoryError";
837
 
    break;
 
835
    return "MemoryError";
838
836
  case SWIG_IOError:
839
 
    type = "IOError";
840
 
    break;
 
837
    return "IOError";
841
838
  case SWIG_RuntimeError:
842
 
    type = "RuntimeError";
843
 
    break;
 
839
    return "RuntimeError";
844
840
  case SWIG_IndexError:
845
 
    type = "IndexError";
846
 
    break;
 
841
    return "IndexError";
847
842
  case SWIG_TypeError:
848
 
    type = "TypeError";
849
 
    break;
 
843
    return "TypeError";
850
844
  case SWIG_DivisionByZero:
851
 
    type = "ZeroDivisionError";
852
 
    break;
 
845
    return "ZeroDivisionError";
853
846
  case SWIG_OverflowError:
854
 
    type = "OverflowError";
855
 
    break;
 
847
    return "OverflowError";
856
848
  case SWIG_SyntaxError:
857
 
    type = "SyntaxError";
858
 
    break;
 
849
    return "SyntaxError";
859
850
  case SWIG_ValueError:
860
 
    type = "ValueError";
861
 
    break;
 
851
    return "ValueError";
862
852
  case SWIG_SystemError:
863
 
    type = "SystemError";
864
 
    break;
 
853
    return "SystemError";
865
854
  case SWIG_AttributeError:
866
 
    type = "AttributeError";
867
 
    break;
 
855
    return "AttributeError";
868
856
  default:
869
 
    type = "RuntimeError";
 
857
    return "RuntimeError";
870
858
  }
871
 
  return type;
872
859
}
873
860
 
874
861
 
875
 
 
876
 
 
877
862
/* -----------------------------------------------------------------------------
878
863
 * perlrun.swg
879
864
 *
923
908
/* Error manipulation */
924
909
 
925
910
#define SWIG_ErrorType(code)                            SWIG_Perl_ErrorType(code)               
926
 
#define SWIG_Error(code, msg)                           sv_setpvf(GvSV(PL_errgv),"%s %s\n", SWIG_ErrorType(code), msg)
 
911
#define SWIG_Error(code, msg)                           sv_setpvf(get_sv("@", GV_ADD), "%s %s", SWIG_ErrorType(code), msg)
927
912
#define SWIG_fail                                       goto fail                                                   
928
913
 
929
914
/* Perl-specific SWIG API */
1017
1002
#endif /* MULTIPLICITY */
1018
1003
#endif /* PERL_OBJECT */
1019
1004
 
1020
 
/* Workaround for bug in perl 5.6.x croak and earlier */
1021
 
#if (PERL_VERSION < 8)
1022
1005
#  ifdef PERL_OBJECT
1023
1006
#    define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
1024
1007
static void SWIG_Perl_croak_null(CPerlObj *pPerl)
1026
1009
static void SWIG_croak_null()
1027
1010
#  endif
1028
1011
{
1029
 
  SV *err=ERRSV;
 
1012
  SV *err = get_sv("@", GV_ADD);
1030
1013
#  if (PERL_VERSION < 6)
1031
1014
  croak("%_", err);
1032
1015
#  else
1033
 
  if (SvOK(err) && !SvROK(err)) croak("%_", err);
1034
 
  croak(Nullch);
 
1016
  if (sv_isobject(err))
 
1017
    croak(0);
 
1018
  else
 
1019
    croak("%s", SvPV_nolen(err));
1035
1020
#  endif
1036
1021
}
1037
 
#else
1038
 
#  define SWIG_croak_null() croak(Nullch)
1039
 
#endif
1040
1022
 
1041
1023
 
1042
1024
/* 
1088
1070
  if (ty) {
1089
1071
    swig_cast_info *iter = ty->cast;
1090
1072
    while (iter) {
1091
 
      if ( (!iter->type->clientdata && (strcmp(iter->type->name, c) == 0)) ||
1092
 
            (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0)) ) {
 
1073
      if (strcmp(SWIG_Perl_TypeProxyName(iter->type), c) == 0) {
1093
1074
        if (iter == ty->cast)
1094
1075
          return iter;
1095
1076
        /* Move iter to the top of the linked list */
1150
1131
    return SWIG_OK;
1151
1132
  } else if (SvTYPE(sv) == SVt_RV) {  /* Check for NULL pointer */
1152
1133
    if (!SvROK(sv)) {
1153
 
      *(ptr) = (void *) 0;
1154
 
      return SWIG_OK;
 
1134
      /* In Perl 5.12 and later, SVt_RV == SVt_IV, so sv could be a valid integer value.  */
 
1135
      if (SvIOK(sv)) {
 
1136
        return SWIG_ERROR;
 
1137
      } else {
 
1138
        /* NULL pointer (reference to undef). */
 
1139
        *(ptr) = (void *) 0;
 
1140
        return SWIG_OK;
 
1141
      }
1155
1142
    } else {
1156
1143
      return SWIG_ERROR;
1157
1144
    }
1169
1156
      int newmemory = 0;
1170
1157
      *ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
1171
1158
      if (newmemory == SWIG_CAST_NEW_MEMORY) {
1172
 
        assert(own);
 
1159
        assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1173
1160
        if (own)
1174
1161
          *own = *own | SWIG_CAST_NEW_MEMORY;
1175
1162
      }
1187
1174
     */
1188
1175
    SV *obj = sv;
1189
1176
    HV *stash = SvSTASH(SvRV(obj));
1190
 
    GV *gv = *(GV**) hv_fetch(stash, "OWNER", 5, TRUE);
 
1177
    GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1191
1178
    if (isGV(gv)) {
1192
1179
      HV *hv = GvHVn(gv);
1193
1180
      /*
1214
1201
    SV *obj=newSV(0);
1215
1202
    HV *hash=newHV();
1216
1203
    HV *stash;
1217
 
    sv_setref_pv(obj, (char *) SWIG_Perl_TypeProxyName(t), ptr);
 
1204
    sv_setref_pv(obj, SWIG_Perl_TypeProxyName(t), ptr);
1218
1205
    stash=SvSTASH(SvRV(obj));
1219
1206
    if (flags & SWIG_POINTER_OWN) {
1220
1207
      HV *hv;
1221
 
      GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
 
1208
      GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1222
1209
      if (!isGV(gv))
1223
1210
        gv_init(gv, stash, "OWNER", 5, FALSE);
1224
1211
      hv=GvHVn(gv);
1232
1219
    sv_bless(sv, stash);
1233
1220
  }
1234
1221
  else {
1235
 
    sv_setref_pv(sv, (char *) SWIG_Perl_TypeProxyName(t), ptr);
 
1222
    sv_setref_pv(sv, SWIG_Perl_TypeProxyName(t), ptr);
1236
1223
  }
1237
1224
}
1238
1225
 
1323
1310
 
1324
1311
/* Magic variable code */
1325
1312
#ifndef PERL_OBJECT
1326
 
#define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
1327
 
  #ifndef MULTIPLICITY
1328
 
     SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *)) 
1329
 
  #else
1330
 
     SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *)) 
1331
 
  #endif
 
1313
# ifdef __cplusplus
 
1314
#  define swig_create_magic(s,a,b,c) _swig_create_magic(s,const_cast<char*>(a),b,c)
 
1315
# else
 
1316
#  define swig_create_magic(s,a,b,c) _swig_create_magic(s,(char*)(a),b,c)
 
1317
# endif
 
1318
# ifndef MULTIPLICITY
 
1319
SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *)) 
 
1320
# else
 
1321
SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *)) 
 
1322
# endif
1332
1323
#else
1333
1324
#  define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
1334
1325
SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *)) 
1335
1326
#endif
1336
1327
{
1337
1328
  MAGIC *mg;
1338
 
  sv_magic(sv,sv,'U',(char *) name,strlen(name));
 
1329
  sv_magic(sv,sv,'U',name,strlen(name));
1339
1330
  mg = mg_find(sv,'U');
1340
1331
  mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
1341
1332
  mg->mg_virtual->svt_get = (SwigMagicFunc) get;
1477
1468
#ifdef bind
1478
1469
  #undef bind
1479
1470
#endif
 
1471
#ifdef access
 
1472
  #undef access
 
1473
#endif
 
1474
#ifdef stat
 
1475
  #undef stat
 
1476
#endif
1480
1477
 
1481
1478
 
1482
1479
 
1519
1516
#define SWIG_name   "RDF::Redland::COREc::boot_RDF__Redland__CORE"
1520
1517
#define SWIG_prefix "RDF::Redland::COREc::"
1521
1518
 
1522
 
#define SWIGVERSION 0x010340 
 
1519
#define SWIGVERSION 0x020007 
1523
1520
#define SWIG_VERSION SWIGVERSION
1524
1521
 
1525
1522
 
1666
1663
    const char *nptr = SvPV_nolen(obj);
1667
1664
    if (nptr) {
1668
1665
      char *endptr;
1669
 
      double v = strtod(nptr, &endptr);
 
1666
      double v;
 
1667
      errno = 0;
 
1668
      v = strtod(nptr, &endptr);
1670
1669
      if (errno == ERANGE) {
1671
1670
        errno = 0;
1672
1671
        return SWIG_OverflowError;
1722
1721
SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val) 
1723
1722
{
1724
1723
  if (SvUOK(obj)) {
1725
 
    if (val) *val = SvUV(obj);
1726
 
    return SWIG_OK;
1727
 
  } else  if (SvIOK(obj)) {
1728
 
    long v = SvIV(obj);
1729
 
    if (v >= 0) {
1730
 
      if (val) *val = v;
1731
 
      return SWIG_OK;
1732
 
    } else {
1733
 
      return SWIG_OverflowError;
1734
 
    }
 
1724
    UV v = SvUV(obj);
 
1725
    if (v <= ULONG_MAX) {
 
1726
      if (val) *val = v;
 
1727
      return SWIG_OK;
 
1728
    }
 
1729
    return SWIG_OverflowError;
 
1730
  } else if (SvIOK(obj)) {
 
1731
    IV v = SvIV(obj);
 
1732
    if (v >= 0 && v <= ULONG_MAX) {
 
1733
      if (val) *val = v;
 
1734
      return SWIG_OK;
 
1735
    }
 
1736
    return SWIG_OverflowError;
1735
1737
  } else {
1736
1738
    int dispatch = 0;
1737
1739
    const char *nptr = SvPV_nolen(obj);
1795
1797
 
1796
1798
SWIGINTERNINLINE SV *
1797
1799
SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
1798
 
{    
1799
 
  SV *obj = sv_newmortal();
1800
 
  sv_setiv(obj, (IV) value);
1801
 
  return obj;
 
1800
{
 
1801
  SV *sv;
 
1802
  if (value >= IV_MIN && value <= IV_MAX)
 
1803
    sv = newSViv(value);
 
1804
  else
 
1805
    sv = newSVpvf("%ld", value);
 
1806
  return sv_2mortal(sv);
1802
1807
}
1803
1808
 
1804
1809
 
1822
1827
SWIGINTERN int
1823
1828
SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1824
1829
{
1825
 
  if (SvIOK(obj)) {
1826
 
    if (val) *val = SvIV(obj);
1827
 
    return SWIG_OK;
 
1830
  if (SvUOK(obj)) {
 
1831
    UV v = SvUV(obj);
 
1832
    if (v <= LONG_MAX) {
 
1833
      if (val) *val = v;
 
1834
      return SWIG_OK;
 
1835
    }
 
1836
    return SWIG_OverflowError;
 
1837
  } else if (SvIOK(obj)) {
 
1838
    IV v = SvIV(obj);
 
1839
    if (v >= LONG_MIN && v <= LONG_MAX) {
 
1840
      if(val) *val = v;
 
1841
      return SWIG_OK;
 
1842
    }
 
1843
    return SWIG_OverflowError;
1828
1844
  } else {
1829
1845
    int dispatch = 0;
1830
1846
    const char *nptr = SvPV_nolen(obj);
1874
1890
 
1875
1891
SWIGINTERNINLINE SV *
1876
1892
SWIG_From_unsigned_SS_long  SWIG_PERL_DECL_ARGS_1(unsigned long value)
1877
 
{    
1878
 
  SV *obj = sv_newmortal();
1879
 
  sv_setuv(obj, (UV) value);
1880
 
  return obj;
 
1893
{
 
1894
  SV *sv;
 
1895
  if (value <= UV_MAX)
 
1896
    sv = newSVuv(value);
 
1897
  else
 
1898
    sv = newSVpvf("%lu", value);
 
1899
  return sv_2mortal(sv);
1881
1900
}
1882
1901
 
1883
1902
 
2270
2289
}
2271
2290
 
2272
2291
 
 
2292
XS(_wrap_librdf_new_hash) {
 
2293
  {
 
2294
    librdf_world *arg1 = (librdf_world *) 0 ;
 
2295
    char *arg2 = (char *) 0 ;
 
2296
    void *argp1 = 0 ;
 
2297
    int res1 = 0 ;
 
2298
    int res2 ;
 
2299
    char *buf2 = 0 ;
 
2300
    int alloc2 = 0 ;
 
2301
    int argvi = 0;
 
2302
    librdf_hash *result = 0 ;
 
2303
    dXSARGS;
 
2304
    
 
2305
    if ((items < 2) || (items > 2)) {
 
2306
      SWIG_croak("Usage: librdf_new_hash(world,name);");
 
2307
    }
 
2308
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
 
2309
    if (!SWIG_IsOK(res1)) {
 
2310
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_hash" "', argument " "1"" of type '" "librdf_world *""'"); 
 
2311
    }
 
2312
    arg1 = (librdf_world *)(argp1);
 
2313
    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
 
2314
    if (!SWIG_IsOK(res2)) {
 
2315
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_hash" "', argument " "2"" of type '" "char const *""'");
 
2316
    }
 
2317
    arg2 = (char *)(buf2);
 
2318
    result = (librdf_hash *)librdf_new_hash(arg1,(char const *)arg2);
 
2319
    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_hash_s, SWIG_OWNER | 0); argvi++ ;
 
2320
    
 
2321
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
2322
    XSRETURN(argvi);
 
2323
  fail:
 
2324
    
 
2325
    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
 
2326
    SWIG_croak_null();
 
2327
  }
 
2328
}
 
2329
 
 
2330
 
2273
2331
XS(_wrap_librdf_new_hash_from_string) {
2274
2332
  {
2275
2333
    librdf_world *arg1 = (librdf_world *) 0 ;
9135
9193
{"RDF::Redland::COREc::librdf_digest_update_string", _wrap_librdf_digest_update_string},
9136
9194
{"RDF::Redland::COREc::librdf_digest_final", _wrap_librdf_digest_final},
9137
9195
{"RDF::Redland::COREc::librdf_digest_to_string", _wrap_librdf_digest_to_string},
 
9196
{"RDF::Redland::COREc::librdf_new_hash", _wrap_librdf_new_hash},
9138
9197
{"RDF::Redland::COREc::librdf_new_hash_from_string", _wrap_librdf_new_hash_from_string},
9139
9198
{"RDF::Redland::COREc::librdf_new_hash_from_array_of_strings", _wrap_librdf_new_hash_from_array_of_strings},
9140
9199
{"RDF::Redland::COREc::librdf_hash_to_string", _wrap_librdf_hash_to_string},
9564
9623
  
9565
9624
  /* Install commands */
9566
9625
  for (i = 0; swig_commands[i].name; i++) {
9567
 
    newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
 
9626
    // Casts only needed for Perl < 5.10.
 
9627
#ifdef __cplusplus
 
9628
    newXS(const_cast<char*>(swig_commands[i].name), swig_commands[i].wrapper, const_cast<char*>(__FILE__));
 
9629
#else
 
9630
    newXS((char*)swig_commands[i].name, swig_commands[i].wrapper, (char*)__FILE__);
 
9631
#endif
9568
9632
  }
9569
9633
  
9570
9634
  /* Install variables */
9571
9635
  for (i = 0; swig_variables[i].name; i++) {
9572
9636
    SV *sv;
9573
 
    sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
 
9637
    sv = get_sv(swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
9574
9638
    if (swig_variables[i].type) {
9575
9639
      SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
9576
9640
    } else {
9577
9641
      sv_setiv(sv,(IV) 0);
9578
9642
    }
9579
 
    swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get); 
 
9643
    swig_create_magic(sv, swig_variables[i].name, swig_variables[i].set, swig_variables[i].get); 
9580
9644
  }
9581
9645
  
9582
9646
  /* Install constant */
9583
9647
  for (i = 0; swig_constants[i].type; i++) {
9584
9648
    SV *sv;
9585
 
    sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
 
9649
    sv = get_sv(swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
9586
9650
    switch(swig_constants[i].type) {
9587
9651
    case SWIG_INT:
9588
9652
      sv_setiv(sv, (IV) swig_constants[i].lvalue);
9591
9655
      sv_setnv(sv, (double) swig_constants[i].dvalue);
9592
9656
      break;
9593
9657
    case SWIG_STRING:
9594
 
      sv_setpv(sv, (char *) swig_constants[i].pvalue);
 
9658
      sv_setpv(sv, (const char *) swig_constants[i].pvalue);
9595
9659
      break;
9596
9660
    case SWIG_POINTER:
9597
9661
      SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);