/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.35
+ * Version 2.0.4
*
* This file is not intended to be easily readable and contains a number of
* coding conventions designed to improve portability and efficiency. Do not make
* interface file instead.
* ----------------------------------------------------------------------------- */
+#include "../config/config.h"
+
+
#define SWIGPERL
#define SWIG_CASTRANK_MODE
+
/* -----------------------------------------------------------------------------
* This section contains generic SWIG labels for method/variable
* declarations/attributes, and other compiler dependent labels.
# endif
#endif
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+# pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
/* -----------------------------------------------------------------------------
* swigrun.swg
*
- * This file contains generic CAPI SWIG runtime support for pointer
+ * This file contains generic C API SWIG runtime support for pointer
* type checking.
* ----------------------------------------------------------------------------- */
/*
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
- creating a static or dynamic library from the swig runtime code.
- In 99.9% of the cases, swig just needs to declare them as 'static'.
+ creating a static or dynamic library from the SWIG runtime code.
+ In 99.9% of the cases, SWIG just needs to declare them as 'static'.
- But only do this if is strictly necessary, ie, if you have problems
- with your compiler or so.
+ But only do this if strictly necessary, ie, if you have problems
+ with your compiler or suchlike.
*/
#ifndef SWIGRUNTIME
/*
Flags/methods for returning states.
- The swig conversion methods, as ConvertPtr, return and integer
+ The SWIG conversion methods, as ConvertPtr, return an integer
that tells if the conversion was successful or not. And if not,
an error code can be returned (see swigerrors.swg for the codes).
Use the following macros/flags to set or process the returning
states.
- In old swig versions, you usually write code as:
+ In old versions of SWIG, code such as the following was usually written:
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
// success code
//fail code
}
- Now you can be more explicit as:
+ Now you can be more explicit:
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
if (SWIG_IsOK(res)) {
// fail code
}
- that seems to be the same, but now you can also do
+ which is the same really, but now you can also do
Type *ptr;
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
I.e., now SWIG_ConvertPtr can return new objects and you can
identify the case and take care of the deallocation. Of course that
- requires also to SWIG_ConvertPtr to return new result values, as
+ also requires SWIG_ConvertPtr to return new result values, such as
int SWIG_ConvertPtr(obj, ptr,...) {
if (<obj is ok>) {
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
- swig errors code.
+ SWIG errors code.
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
allows to return the 'cast rank', for example, if you have this
fooi(1) // cast rank '0'
just use the SWIG_AddCast()/SWIG_CheckState()
+*/
-
- */
#define SWIG_OK (0)
#define SWIG_ERROR (-1)
#define SWIG_IsOK(r) (r >= 0)
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
-
/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
# ifndef SWIG_TypeRank
#endif
-
-
#include <string.h>
#ifdef __cplusplus
}
-/* think of this as a c++ template<> or a scheme macro */
-#define SWIG_TypeCheck_Template(comparison, ty) \
- if (ty) { \
- swig_cast_info *iter = ty->cast; \
- while (iter) { \
- if (comparison) { \
- if (iter == ty->cast) return iter; \
- /* Move iter to the top of the linked list */ \
- iter->prev->next = iter->next; \
- if (iter->next) \
- iter->next->prev = iter->prev; \
- iter->next = ty->cast; \
- iter->prev = 0; \
- if (ty->cast) ty->cast->prev = iter; \
- ty->cast = iter; \
- return iter; \
- } \
- iter = iter->next; \
- } \
- } \
- return 0
-
/*
Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
- SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
+ if (ty) {
+ swig_cast_info *iter = ty->cast;
+ while (iter) {
+ if (strcmp(iter->type->name, c) == 0) {
+ if (iter == ty->cast)
+ return iter;
+ /* Move iter to the top of the linked list */
+ iter->prev->next = iter->next;
+ if (iter->next)
+ iter->next->prev = iter->prev;
+ iter->next = ty->cast;
+ iter->prev = 0;
+ if (ty->cast) ty->cast->prev = iter;
+ ty->cast = iter;
+ return iter;
+ }
+ iter = iter->next;
+ }
+ }
+ return 0;
}
-/* Same as previous function, except strcmp is replaced with a pointer comparison */
+/*
+ Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
SWIGRUNTIME swig_cast_info *
-SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
- SWIG_TypeCheck_Template(iter->type == from, into);
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+ if (ty) {
+ swig_cast_info *iter = ty->cast;
+ while (iter) {
+ if (iter->type == from) {
+ if (iter == ty->cast)
+ return iter;
+ /* Move iter to the top of the linked list */
+ iter->prev->next = iter->next;
+ if (iter->next)
+ iter->next->prev = iter->prev;
+ iter->next = ty->cast;
+ iter->prev = 0;
+ if (ty->cast) ty->cast->prev = iter;
+ ty->cast = iter;
+ return iter;
+ }
+ iter = iter->next;
+ }
+ }
+ return 0;
}
/*
/* for raw pointers */
#define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
+#define SWIG_ConvertPtrAndOwn(obj, pp, type, flags,own) SWIG_Perl_ConvertPtrAndOwn(SWIG_PERL_OBJECT_CALL obj, pp, type, flags, own)
#define SWIG_NewPointerObj(p, type, flags) SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
/* for raw packed data */
}
}
+/* Identical to SWIG_TypeCheck, except for strcmp comparison */
SWIGRUNTIME swig_cast_info *
SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
- SWIG_TypeCheck_Template(( (!iter->type->clientdata && (strcmp(iter->type->name, c) == 0))
- || (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0))), ty);
+ if (ty) {
+ swig_cast_info *iter = ty->cast;
+ while (iter) {
+ if ( (!iter->type->clientdata && (strcmp(iter->type->name, c) == 0)) ||
+ (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0)) ) {
+ if (iter == ty->cast)
+ return iter;
+ /* Move iter to the top of the linked list */
+ iter->prev->next = iter->next;
+ if (iter->next)
+ iter->next->prev = iter->prev;
+ iter->next = ty->cast;
+ iter->prev = 0;
+ if (ty->cast) ty->cast->prev = iter;
+ ty->cast = iter;
+ return iter;
+ }
+ iter = iter->next;
+ }
+ }
+ return 0;
}
-
/* Function for getting a pointer value */
SWIGRUNTIME int
-SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
+SWIG_Perl_ConvertPtrAndOwn(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags, int *own) {
swig_cast_info *tc;
void *voidptr = (void *)0;
SV *tsv = 0;
+
+ if (own)
+ *own = 0;
+
/* If magical, apply more magic */
if (SvGMAGICAL(sv))
mg_get(sv);
return SWIG_OK;
} else if (SvTYPE(sv) == SVt_RV) { /* Check for NULL pointer */
if (!SvROK(sv)) {
- *(ptr) = (void *) 0;
- return SWIG_OK;
+ /* In Perl 5.12 and later, SVt_RV == SVt_IV, so sv could be a valid integer value. */
+ if (SvIOK(sv)) {
+ return SWIG_ERROR;
+ } else {
+ /* NULL pointer (reference to undef). */
+ *(ptr) = (void *) 0;
+ return SWIG_OK;
+ }
} else {
return SWIG_ERROR;
}
{
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
- assert(!newmemory); /* newmemory handling not yet implemented */
+ if (newmemory == SWIG_CAST_NEW_MEMORY) {
+ assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+ if (own)
+ *own = *own | SWIG_CAST_NEW_MEMORY;
+ }
}
} else {
*ptr = voidptr;
*/
SV *obj = sv;
HV *stash = SvSTASH(SvRV(obj));
- GV *gv = *(GV**) hv_fetch(stash, "OWNER", 5, TRUE);
+ GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
if (isGV(gv)) {
HV *hv = GvHVn(gv);
/*
return SWIG_OK;
}
+SWIGRUNTIME int
+SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
+ return SWIG_Perl_ConvertPtrAndOwn(sv, ptr, _t, flags, 0);
+}
+
SWIGRUNTIME void
SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
- if (ptr && (flags & SWIG_SHADOW)) {
+ if (ptr && (flags & (SWIG_SHADOW | SWIG_POINTER_OWN))) {
SV *self;
SV *obj=newSV(0);
HV *hash=newHV();
stash=SvSTASH(SvRV(obj));
if (flags & SWIG_POINTER_OWN) {
HV *hv;
- GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
+ GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
if (!isGV(gv))
gv_init(gv, stash, "OWNER", 5, FALSE);
hv=GvHVn(gv);
#ifdef do_close
#undef do_close
#endif
+#ifdef do_exec
+ #undef do_exec
+#endif
#ifdef scalar
#undef scalar
#endif
#ifdef open
#undef open
#endif
+#ifdef readdir
+ #undef readdir
+#endif
+#ifdef bind
+ #undef bind
+#endif
+#ifdef access
+ #undef access
+#endif
+#ifdef stat
+ #undef stat
+#endif
/* -------- TYPES TABLE (BEGIN) -------- */
-#define SWIGTYPE_p_a_STRMAX__char swig_types[0]
-#define SWIGTYPE_p_char swig_types[1]
-#define SWIGTYPE_p_double swig_types[2]
-#define SWIGTYPE_p_float swig_types[3]
-#define SWIGTYPE_p_gint16 swig_types[4]
-#define SWIGTYPE_p_gint32 swig_types[5]
-#define SWIGTYPE_p_gint64 swig_types[6]
-#define SWIGTYPE_p_gint8 swig_types[7]
-#define SWIGTYPE_p_guint16 swig_types[8]
-#define SWIGTYPE_p_guint32 swig_types[9]
-#define SWIGTYPE_p_guint64 swig_types[10]
-#define SWIGTYPE_p_guint8 swig_types[11]
-#define SWIGTYPE_p_int swig_types[12]
-#define SWIGTYPE_p_unsigned_char swig_types[13]
-static swig_type_info *swig_types[15];
-static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
+#define SWIGTYPE_p_char swig_types[0]
+#define SWIGTYPE_p_double swig_types[1]
+#define SWIGTYPE_p_float swig_types[2]
+#define SWIGTYPE_p_gint16 swig_types[3]
+#define SWIGTYPE_p_gint32 swig_types[4]
+#define SWIGTYPE_p_gint64 swig_types[5]
+#define SWIGTYPE_p_gint8 swig_types[6]
+#define SWIGTYPE_p_guint16 swig_types[7]
+#define SWIGTYPE_p_guint32 swig_types[8]
+#define SWIGTYPE_p_guint64 swig_types[9]
+#define SWIGTYPE_p_guint8 swig_types[10]
+#define SWIGTYPE_p_int swig_types[11]
+#define SWIGTYPE_p_unsigned_char swig_types[12]
+static swig_type_info *swig_types[14];
+static swig_module_info swig_module = {swig_types, 13, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_name "Amanda::Testsc::boot_Amanda__Tests"
#define SWIG_prefix "Amanda::Testsc::"
-#define SWIGVERSION 0x010335
+#define SWIGVERSION 0x020004
#define SWIG_VERSION SWIGVERSION
SWIGINTERN int
SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
{
+ if (SvMAGICAL(obj)) {
+ SV *tmp = sv_newmortal();
+ SvSetSV(tmp, obj);
+ obj = tmp;
+ }
if (SvPOK(obj)) {
STRLEN len = 0;
char *cstr = SvPV(obj, len);
}
-
SWIGINTERN int
SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
{
const char *nptr = SvPV_nolen(obj);
if (nptr) {
char *endptr;
- double v = strtod(nptr, &endptr);
+ double v;
+ errno = 0;
+ v = strtod(nptr, &endptr);
if (errno == ERANGE) {
errno = 0;
return SWIG_OverflowError;
return res;
}
+
+static gpointer
+thread_fn(gpointer data)
+{
+ guint *d = data;
+ *d = 1;
+ return NULL;
+}
+
+
+void
+try_threads(void)
+{
+ guint data = 0;
+ GThread *thd;
+
+ glib_init();
+
+ thd = g_thread_create(thread_fn, (gpointer)&data, TRUE, NULL);
+ g_thread_join(thd);
+ g_assert(data == 1);
+}
+
#ifdef __cplusplus
extern "C" {
#endif
#ifdef PERL_OBJECT
-#define MAGIC_CLASS _wrap_Amanda::Tests_var::
-class _wrap_Amanda::Tests_var : public CPerlObj {
+#define MAGIC_CLASS _wrap_Amanda__Tests_var::
+class _wrap_Amanda__Tests_var : public CPerlObj {
public:
#else
#define MAGIC_CLASS
XS(_wrap_take_guint64) {
{
guint64 arg1 ;
- char *result = 0 ;
int argvi = 0;
+ char *result = 0 ;
dXSARGS;
if ((items < 1) || (items > 1)) {
XS(_wrap_take_gint64) {
{
gint64 arg1 ;
- char *result = 0 ;
int argvi = 0;
+ char *result = 0 ;
dXSARGS;
if ((items < 1) || (items > 1)) {
XS(_wrap_take_guint32) {
{
guint32 arg1 ;
- char *result = 0 ;
int argvi = 0;
+ char *result = 0 ;
dXSARGS;
if ((items < 1) || (items > 1)) {
XS(_wrap_take_gint32) {
{
gint32 arg1 ;
- char *result = 0 ;
int argvi = 0;
+ char *result = 0 ;
dXSARGS;
if ((items < 1) || (items > 1)) {
XS(_wrap_take_guint16) {
{
guint16 arg1 ;
- char *result = 0 ;
int argvi = 0;
+ char *result = 0 ;
dXSARGS;
if ((items < 1) || (items > 1)) {
XS(_wrap_take_gint16) {
{
gint16 arg1 ;
- char *result = 0 ;
int argvi = 0;
+ char *result = 0 ;
dXSARGS;
if ((items < 1) || (items > 1)) {
XS(_wrap_take_guint8) {
{
guint8 arg1 ;
- char *result = 0 ;
int argvi = 0;
+ char *result = 0 ;
dXSARGS;
if ((items < 1) || (items > 1)) {
XS(_wrap_take_gint8) {
{
gint8 arg1 ;
- char *result = 0 ;
int argvi = 0;
+ char *result = 0 ;
dXSARGS;
if ((items < 1) || (items > 1)) {
XS(_wrap_give_guint64) {
{
char *arg1 = (char *) 0 ;
- guint64 result;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int argvi = 0;
+ guint64 result;
dXSARGS;
if ((items < 1) || (items > 1)) {
arg1 = (char *)(buf1);
result = give_guint64(arg1);
{
- ST(argvi) = sv_2mortal(amglue_newSVu64(result));
+ SV *for_stack;
+ SP += argvi; PUTBACK;
+ for_stack = sv_2mortal(amglue_newSVu64(result));
+ SPAGAIN; SP -= argvi;
+ ST(argvi) = for_stack;
argvi++;
}
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
XS(_wrap_give_gint64) {
{
char *arg1 = (char *) 0 ;
- gint64 result;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int argvi = 0;
+ gint64 result;
dXSARGS;
if ((items < 1) || (items > 1)) {
arg1 = (char *)(buf1);
result = give_gint64(arg1);
{
- ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+ SV *for_stack;
+ SP += argvi; PUTBACK;
+ for_stack = sv_2mortal(amglue_newSVi64(result));
+ SPAGAIN; SP -= argvi;
+ ST(argvi) = for_stack;
argvi++;
}
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
XS(_wrap_give_guint32) {
{
char *arg1 = (char *) 0 ;
- guint32 result;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int argvi = 0;
+ guint32 result;
dXSARGS;
if ((items < 1) || (items > 1)) {
arg1 = (char *)(buf1);
result = give_guint32(arg1);
{
- ST(argvi) = sv_2mortal(amglue_newSVu64(result));
+ SV *for_stack;
+ SP += argvi; PUTBACK;
+ for_stack = sv_2mortal(amglue_newSVu64(result));
+ SPAGAIN; SP -= argvi;
+ ST(argvi) = for_stack;
argvi++;
}
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
XS(_wrap_give_gint32) {
{
char *arg1 = (char *) 0 ;
- gint32 result;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int argvi = 0;
+ gint32 result;
dXSARGS;
if ((items < 1) || (items > 1)) {
arg1 = (char *)(buf1);
result = give_gint32(arg1);
{
- ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+ SV *for_stack;
+ SP += argvi; PUTBACK;
+ for_stack = sv_2mortal(amglue_newSVi64(result));
+ SPAGAIN; SP -= argvi;
+ ST(argvi) = for_stack;
argvi++;
}
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
XS(_wrap_give_guint16) {
{
char *arg1 = (char *) 0 ;
- guint16 result;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int argvi = 0;
+ guint16 result;
dXSARGS;
if ((items < 1) || (items > 1)) {
arg1 = (char *)(buf1);
result = give_guint16(arg1);
{
- ST(argvi) = sv_2mortal(amglue_newSVu64(result));
+ SV *for_stack;
+ SP += argvi; PUTBACK;
+ for_stack = sv_2mortal(amglue_newSVu64(result));
+ SPAGAIN; SP -= argvi;
+ ST(argvi) = for_stack;
argvi++;
}
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
XS(_wrap_give_gint16) {
{
char *arg1 = (char *) 0 ;
- gint16 result;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int argvi = 0;
+ gint16 result;
dXSARGS;
if ((items < 1) || (items > 1)) {
arg1 = (char *)(buf1);
result = give_gint16(arg1);
{
- ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+ SV *for_stack;
+ SP += argvi; PUTBACK;
+ for_stack = sv_2mortal(amglue_newSVi64(result));
+ SPAGAIN; SP -= argvi;
+ ST(argvi) = for_stack;
argvi++;
}
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
XS(_wrap_give_guint8) {
{
char *arg1 = (char *) 0 ;
- guint8 result;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int argvi = 0;
+ guint8 result;
dXSARGS;
if ((items < 1) || (items > 1)) {
arg1 = (char *)(buf1);
result = give_guint8(arg1);
{
- ST(argvi) = sv_2mortal(amglue_newSVu64(result));
+ SV *for_stack;
+ SP += argvi; PUTBACK;
+ for_stack = sv_2mortal(amglue_newSVu64(result));
+ SPAGAIN; SP -= argvi;
+ ST(argvi) = for_stack;
argvi++;
}
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
XS(_wrap_give_gint8) {
{
char *arg1 = (char *) 0 ;
- gint8 result;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int argvi = 0;
+ gint8 result;
dXSARGS;
if ((items < 1) || (items > 1)) {
arg1 = (char *)(buf1);
result = give_gint8(arg1);
{
- ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+ SV *for_stack;
+ SP += argvi; PUTBACK;
+ for_stack = sv_2mortal(amglue_newSVi64(result));
+ SPAGAIN; SP -= argvi;
+ ST(argvi) = for_stack;
argvi++;
}
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
XS(_wrap_sizeof_size_t) {
{
- int result;
int argvi = 0;
+ int result;
dXSARGS;
if ((items < 0) || (items > 0)) {
}
result = (int)sizeof_size_t();
{
- ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+ SV *for_stack;
+ SP += argvi; PUTBACK;
+ for_stack = sv_2mortal(amglue_newSVi64(result));
+ SPAGAIN; SP -= argvi;
+ ST(argvi) = for_stack;
argvi++;
}
XSRETURN(argvi);
}
arg3 = (char *)(buf3);
write_random_file(arg1,arg2,arg3);
-
+ ST(argvi) = sv_newmortal();
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
XSRETURN(argvi);
size_t arg2 ;
char *arg3 = (char *) 0 ;
gboolean arg4 ;
- gboolean result;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int argvi = 0;
+ gboolean result;
dXSARGS;
if ((items < 4) || (items > 4)) {
}
arg3 = (char *)(buf3);
{
- if (sizeof(signed int) == 1) {
- arg4 = amglue_SvI8(ST(3));
- } else if (sizeof(signed int) == 2) {
- arg4 = amglue_SvI16(ST(3));
- } else if (sizeof(signed int) == 4) {
- arg4 = amglue_SvI32(ST(3));
- } else if (sizeof(signed int) == 8) {
- arg4 = amglue_SvI64(ST(3));
- } else {
- g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
- }
+ arg4 = SvTRUE(ST(3));
}
result = (gboolean)verify_random_file(arg1,arg2,arg3,arg4);
{
- ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+ if (result)
+ ST(argvi) = &PL_sv_yes;
+ else
+ ST(argvi) = &PL_sv_no;
argvi++;
}
}
+XS(_wrap_try_threads) {
+ {
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: try_threads();");
+ }
+ try_threads();
+ ST(argvi) = sv_newmortal();
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
-static swig_type_info _swigt__p_a_STRMAX__char = {"_p_a_STRMAX__char", "char (*)[STRMAX]|string_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "gchar *|char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "double *|gdouble *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_float = {"_p_float", "float *|gfloat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_guint32 = {"_p_guint32", "guint32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_guint64 = {"_p_guint64", "guint64 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_guint8 = {"_p_guint8", "guint8 *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_int = {"_p_int", "int *|filetype_t *|gboolean *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "int *|gboolean *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "guchar *|unsigned char *", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
- &_swigt__p_a_STRMAX__char,
&_swigt__p_char,
&_swigt__p_double,
&_swigt__p_float,
&_swigt__p_unsigned_char,
};
-static swig_cast_info _swigc__p_a_STRMAX__char[] = { {&_swigt__p_a_STRMAX__char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
- _swigc__p_a_STRMAX__char,
_swigc__p_char,
_swigc__p_double,
_swigc__p_float,
{"Amanda::Testsc::sizeof_size_t", _wrap_sizeof_size_t},
{"Amanda::Testsc::write_random_file", _wrap_write_random_file},
{"Amanda::Testsc::verify_random_file", _wrap_verify_random_file},
+{"Amanda::Testsc::try_threads", _wrap_try_threads},
{0,0}
};
/* -----------------------------------------------------------------------------
projects / debian / amanda / blobdiff