/*
 * This file was generated automatically by ExtUtils::ParseXS version 2.18 from the
 * contents of XS.xs. Do not edit this file, edit XS.xs instead.
 *
 *	ANY CHANGES MADE HERE WILL BE LOST! 
 *
 */

#line 1 "XS.xs"
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include "ppport.h"

#include <memcache.h>

typedef struct memcache Memcache;
typedef struct memcache_req MemcacheReq;
typedef struct memcache_res MemcacheRes;

static void my_callback_func(MCM_CALLBACK_SIG);
static void
my_callback_func(MCM_CALLBACK_FUNC)
{
	struct my_struct *ptr = (struct my_struct *)MCM_CALLBACK_PTR;
	struct memcache_ctxt *ctxt = MCM_CALLBACK_CTXT;
	struct memcache_res *res = MCM_CALLBACK_RES;

	SV * resultsarrayref;
	AV * resultsarray;
	SV * resultshash1ref;
	HV * resultshash1;
	SV * resultshash2ref;
	HV * resultshash2;

	if (!(res->_flags & MCM_RES_FOUND))
		return;
	resultsarrayref = (SV*)ptr;
	if (!SvROK(resultsarrayref))
		return;
	resultsarray = (AV *)SvRV(resultsarrayref);
	if (SvTYPE(resultsarray) != SVt_PVAV)
		return;
	if (av_len(resultsarray) != 1)
		return;
	resultshash1ref = *av_fetch(resultsarray, 0, 0);
	resultshash2ref = *av_fetch(resultsarray, 1, 0);

	resultshash1 = (HV *)SvRV(resultshash1ref);
	if (SvTYPE(resultshash1) != SVt_PVHV)
		return;
	hv_store(resultshash1, res->key, res->len, newSVpvn(res->val,res->bytes), 0);

	resultshash2 = (HV *)SvRV(resultshash2ref);
	if (SvTYPE(resultshash2) != SVt_PVHV)
		return;
	hv_store(resultshash2, res->key, res->len, newSViv(res->flags), 0);
}

#ifndef PERL_UNUSED_VAR
#  define PERL_UNUSED_VAR(var) if (0) var = var
#endif

#line 66 "XS.c"

XS(XS_Cache__Memcached__XS_mc_new); /* prototype to pass -Wmissing-prototypes */
XS(XS_Cache__Memcached__XS_mc_new)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 0)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Cache::Memcached::XS::mc_new", "");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	Memcache *	RETVAL;
#line 57 "XS.xs"
		RETVAL = (Memcache *)mc_new();
#line 83 "XS.c"
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "MemcachePtr", (void*)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Cache__Memcached__XS_mc_server_add4); /* prototype to pass -Wmissing-prototypes */
XS(XS_Cache__Memcached__XS_mc_server_add4)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 2)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Cache::Memcached::XS::mc_server_add4", "mc, host");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	Memcache *	mc;
	char *	host = (char *)SvPV_nolen(ST(1));

	if (sv_derived_from(ST(0), "MemcachePtr")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    mc = INT2PTR(Memcache *,tmp);
	}
	else
	    Perl_croak(aTHX_ "mc is not of type MemcachePtr");

	mc_server_add4(mc, host);
    }
    XSRETURN_EMPTY;
}


XS(XS_Cache__Memcached__XS_mc_req_new); /* prototype to pass -Wmissing-prototypes */
XS(XS_Cache__Memcached__XS_mc_req_new)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 0)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Cache::Memcached::XS::mc_req_new", "");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	MemcacheReq *	RETVAL;
#line 69 "XS.xs"
		RETVAL = (MemcacheReq *)mc_req_new();
#line 134 "XS.c"
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "MemcacheReqPtr", (void*)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Cache__Memcached__XS_mc_req_add); /* prototype to pass -Wmissing-prototypes */
XS(XS_Cache__Memcached__XS_mc_req_add)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 2)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Cache::Memcached::XS::mc_req_add", "req, key");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	MemcacheReq *	req;
	char *	key = (char *)SvPV_nolen(ST(1));
	MemcacheRes *	RETVAL;

	if (sv_derived_from(ST(0), "MemcacheReqPtr")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    req = INT2PTR(MemcacheReq *,tmp);
	}
	else
	    Perl_croak(aTHX_ "req is not of type MemcacheReqPtr");
#line 78 "XS.xs"
		RETVAL = (MemcacheRes *)mc_req_add(req,key,strlen(key));
#line 166 "XS.c"
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "MemcacheResPtr", (void*)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Cache__Memcached__XS_mc_res_register_callback); /* prototype to pass -Wmissing-prototypes */
XS(XS_Cache__Memcached__XS_mc_res_register_callback)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 3)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Cache::Memcached::XS::mc_res_register_callback", "req, res, results");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	MemcacheReq *	req;
	MemcacheRes *	res;
	SV *	results = ST(2);

	if (sv_derived_from(ST(0), "MemcacheReqPtr")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    req = INT2PTR(MemcacheReq *,tmp);
	}
	else
	    Perl_croak(aTHX_ "req is not of type MemcacheReqPtr");

	if (sv_derived_from(ST(1), "MemcacheResPtr")) {
	    IV tmp = SvIV((SV*)SvRV(ST(1)));
	    res = INT2PTR(MemcacheRes *,tmp);
	}
	else
	    Perl_croak(aTHX_ "res is not of type MemcacheResPtr");
#line 88 "XS.xs"
		mc_res_register_fetch_cb(req,res,my_callback_func,results);
#line 205 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS(XS_Cache__Memcached__XS_mc_get); /* prototype to pass -Wmissing-prototypes */
XS(XS_Cache__Memcached__XS_mc_get)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 2)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Cache::Memcached::XS::mc_get", "mc, req");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	Memcache *	mc;
	MemcacheReq *	req;

	if (sv_derived_from(ST(0), "MemcachePtr")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    mc = INT2PTR(Memcache *,tmp);
	}
	else
	    Perl_croak(aTHX_ "mc is not of type MemcachePtr");

	if (sv_derived_from(ST(1), "MemcacheReqPtr")) {
	    IV tmp = SvIV((SV*)SvRV(ST(1)));
	    req = INT2PTR(MemcacheReq *,tmp);
	}
	else
	    Perl_croak(aTHX_ "req is not of type MemcacheReqPtr");

	mc_get(mc, req);
    }
    XSRETURN_EMPTY;
}


XS(XS_Cache__Memcached__XS_mc_set); /* prototype to pass -Wmissing-prototypes */
XS(XS_Cache__Memcached__XS_mc_set)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 5)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Cache::Memcached::XS::mc_set", "mc, key, val_sv, exp, flags");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	Memcache *	mc;
	char *	key = (char *)SvPV_nolen(ST(1));
	SV *	val_sv = ST(2);
	int	exp = (int)SvIV(ST(3));
	int	flags = (int)SvIV(ST(4));
	int	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "MemcachePtr")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    mc = INT2PTR(Memcache *,tmp);
	}
	else
	    Perl_croak(aTHX_ "mc is not of type MemcachePtr");
#line 103 "XS.xs"
		char *val;
		int len;
#line 275 "XS.c"
#line 106 "XS.xs"
		val = SvPV(val_sv,len);
		RETVAL = mc_set(mc,key,strlen(key),val,len,exp,flags);
#line 279 "XS.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Cache__Memcached__XS_mc_add); /* prototype to pass -Wmissing-prototypes */
XS(XS_Cache__Memcached__XS_mc_add)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 5)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Cache::Memcached::XS::mc_add", "mc, key, val_sv, exp, flags");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	Memcache *	mc;
	char *	key = (char *)SvPV_nolen(ST(1));
	SV *	val_sv = ST(2);
	int	exp = (int)SvIV(ST(3));
	int	flags = (int)SvIV(ST(4));
	int	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "MemcachePtr")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    mc = INT2PTR(Memcache *,tmp);
	}
	else
	    Perl_croak(aTHX_ "mc is not of type MemcachePtr");
#line 119 "XS.xs"
		char *val;
		int len;
#line 315 "XS.c"
#line 122 "XS.xs"
		val = SvPV(val_sv,len);
		RETVAL = mc_add(mc,key,strlen(key),val,len,exp,flags);
#line 319 "XS.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Cache__Memcached__XS_mc_replace); /* prototype to pass -Wmissing-prototypes */
XS(XS_Cache__Memcached__XS_mc_replace)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 5)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Cache::Memcached::XS::mc_replace", "mc, key, val_sv, exp, flags");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	Memcache *	mc;
	char *	key = (char *)SvPV_nolen(ST(1));
	SV *	val_sv = ST(2);
	int	exp = (int)SvIV(ST(3));
	int	flags = (int)SvIV(ST(4));
	int	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "MemcachePtr")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    mc = INT2PTR(Memcache *,tmp);
	}
	else
	    Perl_croak(aTHX_ "mc is not of type MemcachePtr");
#line 135 "XS.xs"
		char *val;
		int len;
#line 355 "XS.c"
#line 138 "XS.xs"
		val = SvPV(val_sv,len);
		RETVAL = mc_replace(mc,key,strlen(key),val,len,exp,flags);
#line 359 "XS.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Cache__Memcached__XS_mc_incr); /* prototype to pass -Wmissing-prototypes */
XS(XS_Cache__Memcached__XS_mc_incr)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 3)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Cache::Memcached::XS::mc_incr", "mc, key, val");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	Memcache *	mc;
	char *	key = (char *)SvPV_nolen(ST(1));
	int	val = (int)SvIV(ST(2));
	int	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "MemcachePtr")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    mc = INT2PTR(Memcache *,tmp);
	}
	else
	    Perl_croak(aTHX_ "mc is not of type MemcachePtr");
#line 149 "XS.xs"
		RETVAL = mc_incr(mc,key,strlen(key),val);
#line 392 "XS.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Cache__Memcached__XS_mc_decr); /* prototype to pass -Wmissing-prototypes */
XS(XS_Cache__Memcached__XS_mc_decr)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 3)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Cache::Memcached::XS::mc_decr", "mc, key, val");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	Memcache *	mc;
	char *	key = (char *)SvPV_nolen(ST(1));
	int	val = (int)SvIV(ST(2));
	int	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "MemcachePtr")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    mc = INT2PTR(Memcache *,tmp);
	}
	else
	    Perl_croak(aTHX_ "mc is not of type MemcachePtr");
#line 159 "XS.xs"
		RETVAL = mc_decr(mc,key,strlen(key),val);
#line 425 "XS.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Cache__Memcached__XS_mc_delete); /* prototype to pass -Wmissing-prototypes */
XS(XS_Cache__Memcached__XS_mc_delete)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 3)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Cache::Memcached::XS::mc_delete", "mc, key, hold");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	Memcache *	mc;
	char *	key = (char *)SvPV_nolen(ST(1));
	int	hold = (int)SvIV(ST(2));
	int	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "MemcachePtr")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    mc = INT2PTR(Memcache *,tmp);
	}
	else
	    Perl_croak(aTHX_ "mc is not of type MemcachePtr");
#line 169 "XS.xs"
		RETVAL = mc_delete(mc,key,strlen(key),hold);
#line 458 "XS.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_MemcachePtr_DESTROY); /* prototype to pass -Wmissing-prototypes */
XS(XS_MemcachePtr_DESTROY)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "MemcachePtr::DESTROY", "mc");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	Memcache *	mc;

	if (SvROK(ST(0))) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    mc = INT2PTR(Memcache *,tmp);
	}
	else
	    Perl_croak(aTHX_ "mc is not a reference");
#line 179 "XS.xs"
		mc_free(mc);
#line 487 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS(XS_MemcacheReqPtr_DESTROY); /* prototype to pass -Wmissing-prototypes */
XS(XS_MemcacheReqPtr_DESTROY)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "MemcacheReqPtr::DESTROY", "req");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	MemcacheReq *	req;

	if (SvROK(ST(0))) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    req = INT2PTR(MemcacheReq *,tmp);
	}
	else
	    Perl_croak(aTHX_ "req is not a reference");
#line 187 "XS.xs"
		mc_req_free(req);
#line 515 "XS.c"
    }
    XSRETURN_EMPTY;
}

#ifdef __cplusplus
extern "C"
#endif
XS(boot_Cache__Memcached__XS); /* prototype to pass -Wmissing-prototypes */
XS(boot_Cache__Memcached__XS)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    char* file = __FILE__;

    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    XS_VERSION_BOOTCHECK ;

        newXS("Cache::Memcached::XS::mc_new", XS_Cache__Memcached__XS_mc_new, file);
        newXS("Cache::Memcached::XS::mc_server_add4", XS_Cache__Memcached__XS_mc_server_add4, file);
        newXS("Cache::Memcached::XS::mc_req_new", XS_Cache__Memcached__XS_mc_req_new, file);
        newXS("Cache::Memcached::XS::mc_req_add", XS_Cache__Memcached__XS_mc_req_add, file);
        newXS("Cache::Memcached::XS::mc_res_register_callback", XS_Cache__Memcached__XS_mc_res_register_callback, file);
        newXS("Cache::Memcached::XS::mc_get", XS_Cache__Memcached__XS_mc_get, file);
        newXS("Cache::Memcached::XS::mc_set", XS_Cache__Memcached__XS_mc_set, file);
        newXS("Cache::Memcached::XS::mc_add", XS_Cache__Memcached__XS_mc_add, file);
        newXS("Cache::Memcached::XS::mc_replace", XS_Cache__Memcached__XS_mc_replace, file);
        newXS("Cache::Memcached::XS::mc_incr", XS_Cache__Memcached__XS_mc_incr, file);
        newXS("Cache::Memcached::XS::mc_decr", XS_Cache__Memcached__XS_mc_decr, file);
        newXS("Cache::Memcached::XS::mc_delete", XS_Cache__Memcached__XS_mc_delete, file);
        newXS("MemcachePtr::DESTROY", XS_MemcachePtr_DESTROY, file);
        newXS("MemcacheReqPtr::DESTROY", XS_MemcacheReqPtr_DESTROY, file);
    XSRETURN_YES;
}