File Coverage

xs/main_xsgen.cc

Criterion	Covered	Total	%
statement	564	682	82.7
branch	408	1110	36.7
condition			n/a
subroutine			n/a
pod			n/a
total	972	1792	54.2

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

#line 1 "xs/main.xs"
#include
#include
#include
#include "private.h"

using namespace xs;
using namespace xs::date;
using namespace panda::time;
using panda::string;
using panda::string_view;

#line 22 "xs/main_xsgen.cc"
#ifndef PERL_UNUSED_VAR
#  define PERL_UNUSED_VAR(var) if (0) var = var
#endif

#ifndef dVAR
#  define dVAR		dNOOP
#endif


/* This stuff is not part of the API! You have been warned. */
#ifndef PERL_VERSION_DECIMAL
#  define PERL_VERSION_DECIMAL(r,v,s) (r*1000000 + v*1000 + s)
#endif
#ifndef PERL_DECIMAL_VERSION
#  define PERL_DECIMAL_VERSION \
	  PERL_VERSION_DECIMAL(PERL_REVISION,PERL_VERSION,PERL_SUBVERSION)
#endif
#ifndef PERL_VERSION_GE
#  define PERL_VERSION_GE(r,v,s) \
	  (PERL_DECIMAL_VERSION >= PERL_VERSION_DECIMAL(r,v,s))
#endif
#ifndef PERL_VERSION_LE
#  define PERL_VERSION_LE(r,v,s) \
	  (PERL_DECIMAL_VERSION <= PERL_VERSION_DECIMAL(r,v,s))
#endif

/* XS_INTERNAL is the explicit static-linkage variant of the default
 * XS macro.
 *
 * XS_EXTERNAL is the same as XS_INTERNAL except it does not include
 * "STATIC", ie. it exports XSUB symbols. You probably don't want that
 * for anything but the BOOT XSUB.
 *
 * See XSUB.h in core!
 */


/* TODO: This might be compatible further back than 5.10.0. */
#if PERL_VERSION_GE(5, 10, 0) && PERL_VERSION_LE(5, 15, 1)
#  undef XS_EXTERNAL
#  undef XS_INTERNAL
#  if defined(__CYGWIN__) && defined(USE_DYNAMIC_LOADING)
#    define XS_EXTERNAL(name) __declspec(dllexport) XSPROTO(name)
#    define XS_INTERNAL(name) STATIC XSPROTO(name)
#  endif
#  if defined(__SYMBIAN32__)
#    define XS_EXTERNAL(name) EXPORT_C XSPROTO(name)
#    define XS_INTERNAL(name) EXPORT_C STATIC XSPROTO(name)
#  endif
#  ifndef XS_EXTERNAL
#    if defined(HASATTRIBUTE_UNUSED) && !defined(__cplusplus)
#      define XS_EXTERNAL(name) void name(pTHX_ CV* cv __attribute__unused__)
#      define XS_INTERNAL(name) STATIC void name(pTHX_ CV* cv __attribute__unused__)
#    else
#      ifdef __cplusplus
#        define XS_EXTERNAL(name) extern "C" XSPROTO(name)
#        define XS_INTERNAL(name) static XSPROTO(name)
#      else
#        define XS_EXTERNAL(name) XSPROTO(name)
#        define XS_INTERNAL(name) STATIC XSPROTO(name)
#      endif
#    endif
#  endif
#endif

/* perl >= 5.10.0 && perl <= 5.15.1 */


/* The XS_EXTERNAL macro is used for functions that must not be static
 * like the boot XSUB of a module. If perl didn't have an XS_EXTERNAL
 * macro defined, the best we can do is assume XS is the same.
 * Dito for XS_INTERNAL.
 */
#ifndef XS_EXTERNAL
#  define XS_EXTERNAL(name) XS(name)
#endif
#ifndef XS_INTERNAL
#  define XS_INTERNAL(name) XS(name)
#endif

/* Now, finally, after all this mess, we want an ExtUtils::ParseXS
 * internal macro that we're free to redefine for varying linkage due
 * to the EXPORT_XSUB_SYMBOLS XS keyword. This is internal, use
 * XS_EXTERNAL(name) or XS_INTERNAL(name) in your code if you need to!
 */

#undef XS_EUPXS
#if defined(PERL_EUPXS_ALWAYS_EXPORT)
#  define XS_EUPXS(name) XS_EXTERNAL(name)
#else
   /* default to internal */
#  define XS_EUPXS(name) XS_INTERNAL(name)
#endif

#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE
#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params)

/* prototype to pass -Wmissing-prototypes */
STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params);

STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params)
{
    const GV *const gv = CvGV(cv);

    PERL_ARGS_ASSERT_CROAK_XS_USAGE;

    if (gv) {
        const char *const gvname = GvNAME(gv);
        const HV *const stash = GvSTASH(gv);
        const char *const hvname = stash ? HvNAME(stash) : NULL;

        if (hvname)
	    Perl_croak_nocontext("Usage: %s::%s(%s)", hvname, gvname, params);
        else
	    Perl_croak_nocontext("Usage: %s(%s)", gvname, params);
    } else {
        /* Pants. I don't think that it should be possible to get here. */
	Perl_croak_nocontext("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params);
    }
}
#undef  PERL_ARGS_ASSERT_CROAK_XS_USAGE

#define croak_xs_usage        S_croak_xs_usage

#endif

/* NOTE: the prototype of newXSproto() is different in versions of perls,
 * so we define a portable version of newXSproto()
 */
#ifdef newXS_flags
#define newXSproto_portable(name, c_impl, file, proto) newXS_flags(name, c_impl, file, proto, 0)
#else
#define newXSproto_portable(name, c_impl, file, proto) (PL_Sv=(SV*)newXS(name, c_impl, file), sv_setpv(PL_Sv, proto), (CV*)PL_Sv)
#endif /* !defined(newXS_flags) */

#if PERL_VERSION_LE(5, 21, 5)
#  define newXS_deffile(a,b) Perl_newXS(aTHX_ a,b,file)
#else
#  define newXS_deffile(a,b) Perl_newXS_deffile(aTHX_ a,b)
#endif

#line 166 "xs/main_xsgen.cc"


XS_EUPXS(XS_Date__strict_import) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV*");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 23 "xs/main.xs"
    Scope::Hints::set(strict_hint_name, Simple(1));
#line 179 "xs/main_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Date__strict_unimport) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV*");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 27 "xs/main.xs"
    Scope::Hints::remove(strict_hint_name);
#line 197 "xs/main_xsgen.cc"
	PUTBACK;
	return;
    }
}); }


/* INCLUDE:  Including 'DateRel.xsi' from 'main.xs' */

#include "private.h"
static inline DateRel xs_daterel_ctor (SV* arg, SV* till) {
    return till ? DateRel(sv2date(arg), sv2date(till)) : sv2daterel(arg);
}
static inline DateRel xs_daterel_ymd (SV** args, I32 items) {
    ptime_t vals[8] = {0, 0, 0, 0, 0, 0, 0, 0};
    list2vals(args, items, vals);
    return DateRel(vals[0], vals[1], vals[2], vals[3], vals[4], vals[5]);
}


XS_EUPXS(XS_Date_rdate) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 0 || items > 2)
       croak_xs_usage(cv,  "from= {}, till= {}");
    {
	DateRel *	RETVAL;
	SV*	from;
	SV*	till;

	if (items < 1)
	    from = {};
	else {
	    from = ST(0)
;
	}

	if (items < 2)
	    till = {};
	else {
	    till = ST(1)
;
	}
#line 37 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new DateRel(xs_daterel_ctor(from, till));
#line 243 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date_rdate_ymd) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	DateRel *	RETVAL;
#line 41 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new DateRel(xs_daterel_ymd(&ST(0), items));
#line 265 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date_rdate_const) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 0 || items > 2)
       croak_xs_usage(cv,  "from= {}, till= {}");
    {
	const DateRel *	RETVAL;
	SV*	from;
	SV*	till;

	if (items < 1)
	    from = {};
	else {
	    from = ST(0)
;
	}

	if (items < 2)
	    till = {};
	else {
	    till = ST(1)
;
	}
#line 45 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new DateRel(xs_daterel_ctor(from, till));
#line 304 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date_rdate_ymd_const) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	const DateRel *	RETVAL;
#line 49 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new DateRel(xs_daterel_ymd(&ST(0), items));
#line 326 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 3)
       croak_xs_usage(cv,  "SV*, from= {}, till= {}");
    {
	DateRel *	RETVAL;
	SV*	from;
	SV*	till;

	if (items < 2)
	    from = {};
	else {
	    from = ST(1)
;
	}

	if (items < 3)
	    till = {};
	else {
	    till = ST(2)
;
	}
#line 57 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new DateRel(xs_daterel_ctor(from, till));
#line 365 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_new_ymd) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	DateRel *	RETVAL;
#line 61 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new DateRel(xs_daterel_ymd(&ST(1), items - 1));
#line 387 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_set) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "THIS, from, till= {}");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	from = ST(1)
;
	SV*	till;

	if (items < 3)
	    till = {};
	else {
	    till = ST(2)
;
	}
#line 65 "xs/DateRel.xsi"
    *THIS = xs_daterel_ctor(from, till);
#line 422 "xs/main_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Date__Rel_set_ymd) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "THIS, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 69 "xs/DateRel.xsi"
    *THIS = xs_daterel_ymd(&ST(1), items - 1);
#line 442 "xs/main_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Date__Rel_error) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	std::error_code	RETVAL;
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 72 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
        RETVAL = THIS->error();
#line 462 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_sec) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, newval= NULL");
    {
	ptime_t	RETVAL;
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	newval;

	if (items < 2)
	    newval = NULL;
	else {
	    newval = ST(1)
;
	}
#line 75 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (newval) {
        THIS->sec(xs::in(newval));
    }
    RETVAL = THIS->sec();
#line 498 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_min) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, newval= NULL");
    {
	ptime_t	RETVAL;
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	newval;

	if (items < 2)
	    newval = NULL;
	else {
	    newval = ST(1)
;
	}
#line 82 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (newval) THIS->min(xs::in(newval));
    RETVAL = THIS->min();
#line 532 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_hour) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, newval= NULL");
    {
	ptime_t	RETVAL;
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	newval;

	if (items < 2)
	    newval = NULL;
	else {
	    newval = ST(1)
;
	}
#line 87 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (newval) {
        THIS->hour(xs::in(newval));
    }
    RETVAL = THIS->hour();
#line 568 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_day) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, newval= NULL");
    {
	ptime_t	RETVAL;
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	newval;

	if (items < 2)
	    newval = NULL;
	else {
	    newval = ST(1)
;
	}
#line 94 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (newval) {
        THIS->day(xs::in(newval));
    }
    RETVAL = THIS->day();
#line 604 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_month) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, newval= NULL");
    {
	ptime_t	RETVAL;
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	newval;

	if (items < 2)
	    newval = NULL;
	else {
	    newval = ST(1)
;
	}
#line 101 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (newval) {
        THIS->month(xs::in(newval));
    }
    RETVAL = THIS->month();
#line 640 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_year) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, newval= NULL");
    {
	ptime_t	RETVAL;
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	newval;

	if (items < 2)
	    newval = NULL;
	else {
	    newval = ST(1)
;
	}
#line 108 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (newval) {
        THIS->year(xs::in(newval));
    }
    RETVAL = THIS->year();
#line 676 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_from) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, fromSV= NULL");
    {
	Date *	RETVAL;
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	fromSV;

	if (items < 2)
	    fromSV = NULL;
	else {
	    fromSV = ST(1)
;
	}
#line 115 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (fromSV) {
        THIS->from(sv2date(fromSV));
        XSRETURN_UNDEF;
    }
    if (!THIS->from()) XSRETURN_UNDEF;
    RETVAL = new Date(*(THIS->from()));
#line 714 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_till) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Date *	RETVAL;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 124 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    auto till = THIS->till();
    if (!till) XSRETURN_UNDEF;
    RETVAL = new Date(*till);
#line 741 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_to_secs) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    dXSI32;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	ptime_t	RETVAL;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 130 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    PERL_UNUSED_VAR(ix);
    RETVAL = THIS->to_secs();
#line 768 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_to_mins) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 134 "xs/DateRel.xsi"
        RETVAL = THIS->to_mins();
#line 793 "xs/main_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_to_hours) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 136 "xs/DateRel.xsi"
        RETVAL = THIS->to_hours();
#line 813 "xs/main_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_to_days) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 138 "xs/DateRel.xsi"
        RETVAL = THIS->to_days();
#line 833 "xs/main_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_to_months) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 140 "xs/DateRel.xsi"
        RETVAL = THIS->to_months();
#line 853 "xs/main_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_to_years) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 142 "xs/DateRel.xsi"
        RETVAL = THIS->to_years();
#line 873 "xs/main_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_to_string) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, format= (int)DateRel::Format::simple");
    {
	string	RETVAL;
	dXSTARG;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	format;

	if (items < 2)
	    format = (int)DateRel::Format::simple;
	else {
	    format = (int)SvIV(ST(1))
;
	}
#line 145 "xs/DateRel.xsi"
    RETVAL = THIS->to_string((DateRel::Format)format);
#line 901 "xs/main_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel__op_str) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "THIS, ...");
    {
	string	RETVAL;
	dXSTARG;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 149 "xs/DateRel.xsi"
    RETVAL = THIS->to_string();
#line 921 "xs/main_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_to_bool) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "THIS, ...");
    {
	bool	RETVAL;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 153 "xs/DateRel.xsi"
    RETVAL = THIS->duration();
#line 940 "xs/main_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_to_number) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "THIS, ...");
    {
	ptime_t	RETVAL;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 157 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = THIS->duration();
#line 960 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_sum) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "THIS, arg, ...");
    {
	Sv	RETVAL;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Sv    arg = ST(1)
;
#line 161 "xs/DateRel.xsi"
    if (arg.is_object_ref()) {
        Stash s = Object(arg).stash();
        if (s.name() == "Date") RETVAL = xs::out(new Date(*xs::in(arg) + *THIS));
        else                    RETVAL = xs::out(new DateRel(*THIS + *xs::in(arg)), Object(ST(0)).stash());
    }
    else RETVAL = xs::out(new DateRel(*THIS + sv2daterel(arg)), Object(ST(0)).stash());
#line 991 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_add) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "THIS, arg, ...");
    {
	SV *	RETVAL;
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Sv    arg = ST(1)
;
#line 170 "xs/DateRel.xsi"
    *THIS += sv2daterel(arg);
    XSRETURN(1);
#line 1029 "xs/main_xsgen.cc"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_difference) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "THIS, arg, reverse= false");
    {
	DateRel *	RETVAL;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Sv    arg = ST(1)
;
	bool	reverse;

	if (items < 3)
	    reverse = false;
	else {
	    reverse = (bool)SvTRUE(ST(2))
;
	}
#line 175 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    auto op = sv2daterel(arg);
    RETVAL = new DateRel(reverse ? (op - *THIS) : (*THIS - op));
    PROTO = Object(ST(0)).stash();
#line 1062 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_subtract) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "THIS, arg, ...");
    {
	SV *	RETVAL;
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Sv    arg = ST(1)
;
#line 181 "xs/DateRel.xsi"
    *THIS -= sv2daterel(arg);
    XSRETURN(1);
#line 1089 "xs/main_xsgen.cc"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_product) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "THIS, arg, ...");
    {
	DateRel *	RETVAL;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg = ST(1)
;
#line 186 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new DateRel(*THIS * SvNV(arg));
    PROTO = Object(ST(0)).stash();
#line 1113 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_multiply) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "THIS, arg, ...");
    {
	SV *	RETVAL;
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg = ST(1)
;
#line 191 "xs/DateRel.xsi"
    *THIS *= SvNV(arg);
    XSRETURN(1);
#line 1140 "xs/main_xsgen.cc"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_quotient) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "THIS, arg, reverse= false");
    {
	DateRel *	RETVAL;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg = ST(1)
;
	bool	reverse;

	if (items < 3)
	    reverse = false;
	else {
	    reverse = (bool)SvTRUE(ST(2))
;
	}
#line 196 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (reverse) throw "Date: illegal divison $num/$reldate";
    RETVAL = new DateRel(*THIS / SvNV(arg));
    PROTO = Object(ST(0)).stash();
#line 1173 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_divide) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "THIS, arg, reverse= false");
    {
	SV *	RETVAL;
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg = ST(1)
;
	bool	reverse;

	if (items < 3)
	    reverse = false;
	else {
	    reverse = (bool)SvTRUE(ST(2))
;
	}
#line 202 "xs/DateRel.xsi"
    if (reverse) throw "Date: illegal divison $num/$reldate";
    *THIS /= SvNV(arg);
    XSRETURN(1);
#line 1209 "xs/main_xsgen.cc"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_negated) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "THIS, ...");
    {
	DateRel *	RETVAL;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 208 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new DateRel(THIS->negated());
    PROTO = Object(ST(0)).stash();
#line 1231 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_negate) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	SV *	RETVAL;
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 213 "xs/DateRel.xsi"
    THIS->negate();
    XSRETURN(1);
#line 1256 "xs/main_xsgen.cc"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_compare) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, arg, reverse");
    {
	int	RETVAL;
	dXSTARG;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Sv    arg = ST(1)
;
	bool	reverse = (bool)SvTRUE(ST(2))
;
#line 218 "xs/DateRel.xsi"
    RETVAL = THIS->compare(sv2daterel(arg));
    if (reverse) RETVAL = -RETVAL;
    if      (RETVAL < 0) RETVAL = -1;
    else if (RETVAL > 0) RETVAL = 1;
#line 1284 "xs/main_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_is_same) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "THIS, arg, ...");
    {
	bool	RETVAL;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Sv    arg = ST(1)
;
#line 225 "xs/DateRel.xsi"
    RETVAL = THIS->is_same(sv2daterel(arg));
#line 1305 "xs/main_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_includes) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, arg");
    {
	int	RETVAL;
	dXSTARG;
	const DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Sv    arg = ST(1)
;
#line 229 "xs/DateRel.xsi"
    RETVAL = THIS->includes(sv2date(arg));
#line 1327 "xs/main_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_clone) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	DateRel *	RETVAL;
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 233 "xs/DateRel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new DateRel(*THIS);
    PROTO = Object(ST(0)).stash();
#line 1348 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'main.xs' from 'DateRel.xsi' */


/* INCLUDE:  Including 'serialize.xsi' from 'main.xs' */

#include
static inline size_t date_freeze_len (const Date& date) {
    if (date.timezone()->is_local) return sizeof(ptime_t);
    return sizeof(ptime_t) + date.timezone()->name.length();
}
static inline void date_freeze (const Date& date, char* buf) {
    if (sizeof(ptime_t) == 8) *((ptime_t*)buf) = panda::h2be64(date.epoch());
    else                      *((ptime_t*)buf) = panda::h2be32(date.epoch());
    buf += sizeof(ptime_t);

    if (date.timezone()->is_local) *buf = 0;
    else {
        auto len = date.timezone()->name.length();
        std::memcpy(buf, date.timezone()->name.data(), len);
        buf[len] = 0;
    }
}
static inline const char* date_thaw (ptime_t* epoch, const Timezone** zone, const char* ptr, size_t len) {
    if (len < sizeof(ptime_t)) throw "Date: cannot 'thaw' - corrupted data";
    if (sizeof(ptime_t) == 8) *epoch = panda::be2h64(*((ptime_t*)ptr));
    else                      *epoch = panda::be2h32(*((ptime_t*)ptr));
    ptr += sizeof(ptime_t);
    if (*ptr == 0) {
        *zone = NULL;
        return ptr;
    }
    size_t znlen = strlen(ptr);
    if (znlen) *zone = tzget(ptr);
    return ptr + znlen;
}


XS_EUPXS(XS_Date_HOOK_CLONE) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Date *	RETVAL;
	Date*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 40 "xs/serialize.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new Date(*THIS);
    PROTO = Object(ST(0)).stash();
#line 1410 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date_STORABLE_freeze) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, bool");
    {
	SV *	RETVAL;
	Date*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 45 "xs/serialize.xsi"
    size_t len = date_freeze_len(*THIS);
    RETVAL = newSV(len);
    SvPOK_on(RETVAL);
    char* buf = SvPVX(RETVAL);
    date_freeze(*THIS, buf);
    SvCUR_set(RETVAL, len);
#line 1439 "xs/main_xsgen.cc"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date_STORABLE_attach) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "CLASS, bool, serialized");
    {
	Date *	RETVAL;
	SV*	CLASS = ST(0)
;
	SV*	serialized = ST(2)
;
#line 54 "xs/serialize.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    STRLEN len;
    const char* str = SvPV(serialized, len);
    ptime_t epoch;
    const Timezone* zone = nullptr;
    date_thaw(&epoch, &zone, str, len);
    RETVAL = new Date(epoch, zone);
    PROTO = CLASS;
#line 1468 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date_TO_JSON) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	ptime_t	RETVAL;
	Date*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 64 "xs/serialize.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = THIS->epoch();
#line 1493 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_HOOK_CLONE) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	DateRel *	RETVAL;
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 71 "xs/serialize.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new DateRel(*THIS);
    PROTO = Object(ST(0)).stash();
#line 1519 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_STORABLE_freeze) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, bool");
    {
	string	RETVAL;
	dXSTARG;
	DateRel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 76 "xs/serialize.xsi"
    RETVAL = THIS->from() ? THIS->to_string(DateRel::Format::iso8601i) : THIS->to_string();
#line 1544 "xs/main_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Rel_STORABLE_attach) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "CLASS, bool, serialized");
    {
	DateRel *	RETVAL;
	SV*	CLASS = ST(0)
;
	string_view	serialized;

  { STRLEN __serialized_len;
    const char* __serialized_buf = SvPV(ST(2), __serialized_len);
    serialized = decltype(serialized)(__serialized_buf, __serialized_len); }
;
#line 80 "xs/serialize.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new DateRel(serialized);
    PROTO = CLASS;
#line 1571 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'main.xs' from 'serialize.xsi' */


/* INCLUDE:  Including 'Timezone.xsi' from 'main.xs' */

static inline Hash export_transition (const Timezone::Transition& trans, bool is_past) {
    auto hash = Hash::create();
    hash.store("offset", Simple(trans.offset));
    hash.store("abbrev", Simple(trans.abbrev));
    if (!is_past) {
        hash.store("start",      Simple(trans.start));
        hash.store("isdst",      Simple(trans.isdst));
        hash.store("gmt_offset", Simple(trans.gmt_offset));
        hash.store("leap_corr",  Simple(trans.leap_corr));
        hash.store("leap_delta", Simple(trans.leap_delta));
    }
    return hash;
}


XS_EUPXS(XS_Date__Timezone_name) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	string	RETVAL;
	dXSTARG;
	const Timezone*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 21 "xs/Timezone.xsi"
    RETVAL = THIS->name;
#line 1615 "xs/main_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Timezone_is_local) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	const Timezone*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 25 "xs/Timezone.xsi"
    RETVAL = THIS->is_local;
#line 1634 "xs/main_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Date__Timezone_export) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Hash	RETVAL;
	const Timezone*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 29 "xs/Timezone.xsi"
    RETVAL = Hash::create();

    RETVAL.store("name", Simple(string_view(THIS->name.data(), THIS->name.length())));
    RETVAL.store("is_local", Simple(THIS->is_local ? 1 : 0));

    auto future = Hash::create();
    future.store("hasdst", Simple(THIS->future.hasdst ? 1 : 0));

    auto outer = Hash::create();
    outer.store("abbrev",     Simple(string_view(THIS->future.outer.abbrev, strlen(THIS->future.outer.abbrev))));
    outer.store("offset",     Simple(THIS->future.outer.offset));
    outer.store("gmt_offset", Simple(THIS->future.outer.gmt_offset));
    outer.store("isdst",      Simple(THIS->future.outer.isdst));
    future.store("outer", Ref::create(outer));

    if (THIS->future.hasdst) {
        auto outer_end = Hash::create();
        outer_end.store("mon",  Simple(THIS->future.outer.end.mon));
        outer_end.store("week", Simple(THIS->future.outer.end.yday));
        outer_end.store("day",  Simple(THIS->future.outer.end.wday));
        outer_end.store("hour", Simple(THIS->future.outer.end.hour));
        outer_end.store("min",  Simple(THIS->future.outer.end.min));
        outer_end.store("sec",  Simple(THIS->future.outer.end.sec));
        outer.store("end", Ref::create(outer_end));

        auto inner = Hash::create();
        inner.store("abbrev",     Simple(string_view(THIS->future.inner.abbrev, strlen(THIS->future.inner.abbrev))));
        inner.store("offset",     Simple(THIS->future.inner.offset));
        inner.store("gmt_offset", Simple(THIS->future.inner.gmt_offset));
        inner.store("isdst",      Simple(THIS->future.inner.isdst));

        auto inner_end = Hash::create();
        inner_end.store("mon",  Simple(THIS->future.inner.end.mon));
        inner_end.store("week", Simple(THIS->future.inner.end.yday));
        inner_end.store("day",  Simple(THIS->future.inner.end.wday));
        inner_end.store("hour", Simple(THIS->future.inner.end.hour));
        inner_end.store("min",  Simple(THIS->future.inner.end.min));
        inner_end.store("sec",  Simple(THIS->future.inner.end.sec));
        inner.store("end", Ref::create(inner_end));

        future.store("inner", Ref::create(inner));
    }
    RETVAL.store("future", Ref::create(future));

    auto trans = Array::create();
    for (uint32_t i = 0; i < THIS->trans_cnt; ++i) trans.push(Ref::create(export_transition(THIS->trans[i], false)));
    RETVAL.store("transitions", Ref::create(trans));

    RETVAL.store("past", Ref::create(export_transition(THIS->trans[0], true)));
#line 1701 "xs/main_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    RETVALSV = newRV_noinc(RETVAL.detach());
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'main.xs' from 'Timezone.xsi' */

#ifdef __cplusplus
extern "C"
#endif

XS_EXTERNAL(boot_Date) { xs::throw_guard(cv, [=]() mutable
{
#if PERL_VERSION_LE(5, 21, 5)
    dVAR; dXSARGS;
#else
    dVAR; dXSBOOTARGSXSAPIVERCHK;
#endif
#if (PERL_REVISION == 5 && PERL_VERSION < 9)
    char* file = __FILE__;
#else
    const char* file = __FILE__;
#endif

    PERL_UNUSED_VAR(file);

    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
#if PERL_VERSION_LE(5, 21, 5)
    XS_VERSION_BOOTCHECK;
#  ifdef XS_APIVERSION_BOOTCHECK
    XS_APIVERSION_BOOTCHECK;
#  endif
#endif

        newXS_deffile("Date::strict::import", XS_Date__strict_import);
        newXS_deffile("Date::strict::unimport", XS_Date__strict_unimport);
        newXS_deffile("Date::rdate", XS_Date_rdate);
        newXS_deffile("Date::rdate_ymd", XS_Date_rdate_ymd);
        newXS_deffile("Date::rdate_const", XS_Date_rdate_const);
        newXS_deffile("Date::rdate_ymd_const", XS_Date_rdate_ymd_const);
        newXS_deffile("Date::Rel::new", XS_Date__Rel_new);
        newXS_deffile("Date::Rel::new_ymd", XS_Date__Rel_new_ymd);
        newXS_deffile("Date::Rel::set", XS_Date__Rel_set);
        newXS_deffile("Date::Rel::set_ymd", XS_Date__Rel_set_ymd);
        newXS_deffile("Date::Rel::error", XS_Date__Rel_error);
        newXS_deffile("Date::Rel::sec", XS_Date__Rel_sec);
        newXS_deffile("Date::Rel::min", XS_Date__Rel_min);
        newXS_deffile("Date::Rel::hour", XS_Date__Rel_hour);
        newXS_deffile("Date::Rel::day", XS_Date__Rel_day);
        newXS_deffile("Date::Rel::month", XS_Date__Rel_month);
        newXS_deffile("Date::Rel::year", XS_Date__Rel_year);
        newXS_deffile("Date::Rel::from", XS_Date__Rel_from);
        newXS_deffile("Date::Rel::till", XS_Date__Rel_till);
        cv = newXS_deffile("Date::Rel::duration", XS_Date__Rel_to_secs);
        XSANY.any_i32 = 1;
        cv = newXS_deffile("Date::Rel::to_secs", XS_Date__Rel_to_secs);
        XSANY.any_i32 = 0;
        newXS_deffile("Date::Rel::to_mins", XS_Date__Rel_to_mins);
        newXS_deffile("Date::Rel::to_hours", XS_Date__Rel_to_hours);
        newXS_deffile("Date::Rel::to_days", XS_Date__Rel_to_days);
        newXS_deffile("Date::Rel::to_months", XS_Date__Rel_to_months);
        newXS_deffile("Date::Rel::to_years", XS_Date__Rel_to_years);
        newXS_deffile("Date::Rel::to_string", XS_Date__Rel_to_string);
        newXS_deffile("Date::Rel::_op_str", XS_Date__Rel__op_str);
        newXS_deffile("Date::Rel::to_bool", XS_Date__Rel_to_bool);
        newXS_deffile("Date::Rel::to_number", XS_Date__Rel_to_number);
        newXS_deffile("Date::Rel::sum", XS_Date__Rel_sum);
        newXS_deffile("Date::Rel::add", XS_Date__Rel_add);
        newXS_deffile("Date::Rel::difference", XS_Date__Rel_difference);
        newXS_deffile("Date::Rel::subtract", XS_Date__Rel_subtract);
        newXS_deffile("Date::Rel::product", XS_Date__Rel_product);
        newXS_deffile("Date::Rel::multiply", XS_Date__Rel_multiply);
        newXS_deffile("Date::Rel::quotient", XS_Date__Rel_quotient);
        newXS_deffile("Date::Rel::divide", XS_Date__Rel_divide);
        newXS_deffile("Date::Rel::negated", XS_Date__Rel_negated);
        newXS_deffile("Date::Rel::negate", XS_Date__Rel_negate);
        newXS_deffile("Date::Rel::compare", XS_Date__Rel_compare);
        newXS_deffile("Date::Rel::is_same", XS_Date__Rel_is_same);
        newXS_deffile("Date::Rel::includes", XS_Date__Rel_includes);
        newXS_deffile("Date::Rel::clone", XS_Date__Rel_clone);
        newXS_deffile("Date::HOOK_CLONE", XS_Date_HOOK_CLONE);
        newXS_deffile("Date::STORABLE_freeze", XS_Date_STORABLE_freeze);
        newXS_deffile("Date::STORABLE_attach", XS_Date_STORABLE_attach);
        newXS_deffile("Date::TO_JSON", XS_Date_TO_JSON);
        newXS_deffile("Date::Rel::HOOK_CLONE", XS_Date__Rel_HOOK_CLONE);
        newXS_deffile("Date::Rel::STORABLE_freeze", XS_Date__Rel_STORABLE_freeze);
        newXS_deffile("Date::Rel::STORABLE_attach", XS_Date__Rel_STORABLE_attach);
        newXS_deffile("Date::Timezone::name", XS_Date__Timezone_name);
        newXS_deffile("Date::Timezone::is_local", XS_Date__Timezone_is_local);
        newXS_deffile("Date::Timezone::export", XS_Date__Timezone_export);

    /* Initialisation Section */

#line 15 "xs/main.xs"
    {
    XS_BOOT(Date__Date);
    }

#line 18 "xs/DateRel.xsi"
    {
    Stash stash("Date::Rel", GV_ADD);

    xs::exp::create_constants(stash, {
        {"FORMAT_SIMPLE",   (int)DateRel::Format::simple},
        {"FORMAT_ISO8601D", (int)DateRel::Format::iso8601d},
        {"FORMAT_ISO8601I", (int)DateRel::Format::iso8601i},

        {"INPUT_FORMAT_ALL",      DateRel::InputFormat::all},
        {"INPUT_FORMAT_SIMPLE",   DateRel::InputFormat::simple},
        {"INPUT_FORMAT_ISO8601",  DateRel::InputFormat::iso8601},
        {"INPUT_FORMAT_ISO8601D", DateRel::InputFormat::iso8601d},
        {"INPUT_FORMAT_ISO8601I", DateRel::InputFormat::iso8601i},
    });
    }

#line 1826 "xs/main_xsgen.cc"

    /* End of Initialisation Section */

#if PERL_VERSION_LE(5, 21, 5)
#  if PERL_VERSION_GE(5, 9, 0)
    if (PL_unitcheckav)
        call_list(PL_scopestack_ix, PL_unitcheckav);
#  endif
    XSRETURN_YES;
#else
    Perl_xs_boot_epilog(aTHX_ ax);
#endif
}); }