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

/////////////////////////////////////////////////////////////////////////////
// Name:        ext/datetime/DateTime.xs
// Purpose:     XS for Wx::DateTime
// Author:      Mattia Barbon
// Modified by:
// Created:     22/09/2002
// RCS-ID:      $Id: DateTime.xs 2757 2010-01-17 10:26:27Z mbarbon $
// Copyright:   (c) 2002, 2006, 2008-2010 Mattia Barbon
// Licence:     This program is free software; you can redistribute it and/or
//              modify it under the same terms as Perl itself
/////////////////////////////////////////////////////////////////////////////

#define PERL_NO_GET_CONTEXT

#include "cpp/wxapi.h"

#undef THIS

#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


/* INCLUDE_COMMAND:  Including output of '/usr/bin/perl -MExtUtils::XSpp::Cmd -e xspp -- -t ../../typemap.xsp XS/DateTime.xsp' from 'DateTime.xs' */

#include <exception>

#undef  xsp_constructor_class
#define xsp_constructor_class(c) (c)
#include <wx/datetime.h>
#define wxDateTime__TimeZone wxDateTime::TimeZone
#define Month wxDateTime::Month
#define WeekDay wxDateTime::WeekDay
#define WeekFlags wxDateTime::WeekFlags
#define NameFlags wxDateTime::NameFlags
#define wxDateTime_t wxDateTime::wxDateTime_t
#define Monday_First wxDateTime::Monday_First
#define Name_Full wxDateTime::Name_Full
#define Name_Abbr wxDateTime::Name_Abbr
#define Calendar wxDateTime::Calendar
#define Gregorian wxDateTime::Gregorian
#define Inv_Year wxDateTime::Inv_Year
#define Inv_Month wxDateTime::Inv_Month
#define wxDefaultDateTimePtr (wxDateTime*)&wxDefaultDateTime
#if WXPERL_W_VERSION_LT( 2, 5, 4 )
#define wxDefaultDateTimeFormat _T("%c")
#endif
#undef  xsp_constructor_class
#define xsp_constructor_class(c) (CLASS)

XS_EUPXS(XS_Wx__DateTime_new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_new)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "CLASS");
    {
	char *	CLASS = (char *)SvPV_nolen(ST(0))
;
	wxDateTime *	RETVAL;
    try {
      RETVAL = new wxDateTime();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    wxPli_non_object_2_sv( aTHX_ RETVALSV, RETVAL, "Wx::DateTime" );
    wxPli_thread_sv_register( aTHX_ "Wx::DateTime", RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}

#undef  xsp_constructor_class
#define xsp_constructor_class(c) (c)
#undef  xsp_constructor_class
#define xsp_constructor_class(c) (CLASS)

XS_EUPXS(XS_Wx__DateTime_newFromTimeT); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_newFromTimeT)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "CLASS, time");
    {
	char *	CLASS = (char *)SvPV_nolen(ST(0))
;
	wxDateTime *	RETVAL;
	time_t	time = (time_t)SvNV(ST(1))
;
    try {
      RETVAL = new wxDateTime( time );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    wxPli_non_object_2_sv( aTHX_ RETVALSV, RETVAL, "Wx::DateTime" );
    wxPli_thread_sv_register( aTHX_ "Wx::DateTime", RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}

#undef  xsp_constructor_class
#define xsp_constructor_class(c) (c)
#undef  xsp_constructor_class
#define xsp_constructor_class(c) (CLASS)

XS_EUPXS(XS_Wx__DateTime_newFromDMY); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_newFromDMY)
{
    dVAR; dXSARGS;
    if (items < 2 || items > 8)
       croak_xs_usage(cv,  "CLASS, day, month= Inv_Month, year= Inv_Year, hour= 0, minute= 0, second= 0, millisec= 0");
    {
	char *	CLASS = (char *)SvPV_nolen(ST(0))
;
	wxDateTime *	RETVAL;
	wxDateTime_t	day = (wxDateTime_t)SvIV(ST(1))
;
	Month	month;
	int	year;
	wxDateTime_t	hour;
	wxDateTime_t	minute;
	wxDateTime_t	second;
	wxDateTime_t	millisec;

	if (items < 3)
	    month = Inv_Month;
	else {
	    month = (Month)SvIV(ST(2))
;
	}

	if (items < 4)
	    year = Inv_Year;
	else {
	    year = (int)SvIV(ST(3))
;
	}

	if (items < 5)
	    hour = 0;
	else {
	    hour = (wxDateTime_t)SvIV(ST(4))
;
	}

	if (items < 6)
	    minute = 0;
	else {
	    minute = (wxDateTime_t)SvIV(ST(5))
;
	}

	if (items < 7)
	    second = 0;
	else {
	    second = (wxDateTime_t)SvIV(ST(6))
;
	}

	if (items < 8)
	    millisec = 0;
	else {
	    millisec = (wxDateTime_t)SvIV(ST(7))
;
	}
    try {
      RETVAL = new wxDateTime( day, month, year, hour, minute, second, millisec );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    wxPli_non_object_2_sv( aTHX_ RETVALSV, RETVAL, "Wx::DateTime" );
    wxPli_thread_sv_register( aTHX_ "Wx::DateTime", RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}

#undef  xsp_constructor_class
#define xsp_constructor_class(c) (c)

XS_EUPXS(XS_Wx__DateTime_CLONE); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_CLONE)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "CLASS");
    {
	char *	CLASS = (char *)SvPV_nolen(ST(0))
;
    wxPli_thread_sv_clone( aTHX_ CLASS, (wxPliCloneSV)wxPli_detach_object );
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Wx__DateTime_DESTROY); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_DESTROY)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
     wxPli_thread_sv_unregister( aTHX_ "Wx::DateTime", THIS, ST(0) );
                delete THIS;
    }
    XSRETURN_EMPTY;
}

#define wxPL_DATETIME_FORMAT wxT("%c")

XS_EUPXS(XS_Wx__DateTime_Format); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_Format)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 3)
       croak_xs_usage(cv,  "THIS, format= wxPL_DATETIME_FORMAT, tz= wxDateTime::Local");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxString	RETVAL;
	const wxChar*	format;
	wxDateTime__TimeZone	tz;

	if (items < 2)
	    format = wxPL_DATETIME_FORMAT;
	else {
    WXCHAR_INPUT( format, wxChar*, ST(1) )
;
	}

	if (items < 3)
	    tz = wxDateTime::Local;
	else {
    tz = (wxDateTime::TZ)SvIV(ST(2))
;
	}
    try {
      RETVAL = THIS->Format( format, tz );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    WXSTRING_OUTPUT( RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_FormatDate); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_FormatDate)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxString	RETVAL;
    try {
      RETVAL = THIS->FormatDate();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    WXSTRING_OUTPUT( RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetYear); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetYear)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, tz= wxDateTime::Local");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	int	RETVAL;
	dXSTARG;
	wxDateTime__TimeZone	tz;

	if (items < 2)
	    tz = wxDateTime::Local;
	else {
    tz = (wxDateTime::TZ)SvIV(ST(1))
;
	}
    try {
      RETVAL = THIS->GetYear( tz );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetMonth); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetMonth)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, tz= wxDateTime::Local");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	Month	RETVAL;
	dXSTARG;
	wxDateTime__TimeZone	tz;

	if (items < 2)
	    tz = wxDateTime::Local;
	else {
    tz = (wxDateTime::TZ)SvIV(ST(1))
;
	}
    try {
      RETVAL = THIS->GetMonth( tz );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetDay); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetDay)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, tz= wxDateTime::Local");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxDateTime_t	RETVAL;
	dXSTARG;
	wxDateTime__TimeZone	tz;

	if (items < 2)
	    tz = wxDateTime::Local;
	else {
    tz = (wxDateTime::TZ)SvIV(ST(1))
;
	}
    try {
      RETVAL = THIS->GetDay( tz );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetWeekDay); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetWeekDay)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, tz= wxDateTime::Local");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	WeekDay	RETVAL;
	dXSTARG;
	wxDateTime__TimeZone	tz;

	if (items < 2)
	    tz = wxDateTime::Local;
	else {
    tz = (wxDateTime::TZ)SvIV(ST(1))
;
	}
    try {
      RETVAL = THIS->GetWeekDay( tz );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetHour); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetHour)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, tz= wxDateTime::Local");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxDateTime_t	RETVAL;
	dXSTARG;
	wxDateTime__TimeZone	tz;

	if (items < 2)
	    tz = wxDateTime::Local;
	else {
    tz = (wxDateTime::TZ)SvIV(ST(1))
;
	}
    try {
      RETVAL = THIS->GetHour( tz );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetMinute); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetMinute)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, tz= wxDateTime::Local");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxDateTime_t	RETVAL;
	dXSTARG;
	wxDateTime__TimeZone	tz;

	if (items < 2)
	    tz = wxDateTime::Local;
	else {
    tz = (wxDateTime::TZ)SvIV(ST(1))
;
	}
    try {
      RETVAL = THIS->GetMinute( tz );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetSecond); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetSecond)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, tz= wxDateTime::Local");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxDateTime_t	RETVAL;
	dXSTARG;
	wxDateTime__TimeZone	tz;

	if (items < 2)
	    tz = wxDateTime::Local;
	else {
    tz = (wxDateTime::TZ)SvIV(ST(1))
;
	}
    try {
      RETVAL = THIS->GetSecond( tz );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetMillisecond); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetMillisecond)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, tz= wxDateTime::Local");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxDateTime_t	RETVAL;
	dXSTARG;
	wxDateTime__TimeZone	tz;

	if (items < 2)
	    tz = wxDateTime::Local;
	else {
    tz = (wxDateTime::TZ)SvIV(ST(1))
;
	}
    try {
      RETVAL = THIS->GetMillisecond( tz );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetDayOfYear); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetDayOfYear)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, tz= wxDateTime::Local");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxDateTime_t	RETVAL;
	dXSTARG;
	wxDateTime__TimeZone	tz;

	if (items < 2)
	    tz = wxDateTime::Local;
	else {
    tz = (wxDateTime::TZ)SvIV(ST(1))
;
	}
    try {
      RETVAL = THIS->GetDayOfYear( tz );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetWeekOfYear); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetWeekOfYear)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 3)
       croak_xs_usage(cv,  "THIS, flags= Monday_First, tz= wxDateTime::Local");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxDateTime_t	RETVAL;
	dXSTARG;
	WeekFlags	flags;
	wxDateTime__TimeZone	tz;

	if (items < 2)
	    flags = Monday_First;
	else {
	    flags = (WeekFlags)SvIV(ST(1))
;
	}

	if (items < 3)
	    tz = wxDateTime::Local;
	else {
    tz = (wxDateTime::TZ)SvIV(ST(2))
;
	}
    try {
      RETVAL = THIS->GetWeekOfYear( flags, tz );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetWeekOfMonth); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetWeekOfMonth)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 3)
       croak_xs_usage(cv,  "THIS, flags= Monday_First, tz= wxDateTime::Local");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxDateTime_t	RETVAL;
	dXSTARG;
	WeekFlags	flags;
	wxDateTime__TimeZone	tz;

	if (items < 2)
	    flags = Monday_First;
	else {
	    flags = (WeekFlags)SvIV(ST(1))
;
	}

	if (items < 3)
	    tz = wxDateTime::Local;
	else {
    tz = (wxDateTime::TZ)SvIV(ST(2))
;
	}
    try {
      RETVAL = THIS->GetWeekOfMonth( flags, tz );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_SetTimeT); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_SetTimeT)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, time");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	SV *	RETVAL;
	time_t	time = (time_t)SvNV(ST(1))
;
    try {
      THIS->Set( time );
      RETVAL = ST(0); SvREFCNT_inc( ST(0) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_SetJDN); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_SetJDN)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, jdn");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	SV *	RETVAL;
	double	jdn = (double)SvNV(ST(1))
;
    try {
      THIS->Set( jdn );
      RETVAL = ST(0); SvREFCNT_inc( ST(0) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_SetHMS); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_SetHMS)
{
    dVAR; dXSARGS;
    if (items < 2 || items > 5)
       croak_xs_usage(cv,  "THIS, hour, minute= 0, second= 0, msec= 0");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	SV *	RETVAL;
	wxDateTime_t	hour = (wxDateTime_t)SvIV(ST(1))
;
	wxDateTime_t	minute;
	wxDateTime_t	second;
	wxDateTime_t	msec;

	if (items < 3)
	    minute = 0;
	else {
	    minute = (wxDateTime_t)SvIV(ST(2))
;
	}

	if (items < 4)
	    second = 0;
	else {
	    second = (wxDateTime_t)SvIV(ST(3))
;
	}

	if (items < 5)
	    msec = 0;
	else {
	    msec = (wxDateTime_t)SvIV(ST(4))
;
	}
    try {
      THIS->Set( hour, minute, second, msec );
      RETVAL = ST(0); SvREFCNT_inc( ST(0) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_Set); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_Set)
{
    dVAR; dXSARGS;
    if (items < 3 || items > 8)
       croak_xs_usage(cv,  "THIS, day, month= Inv_Month, year= Inv_Year, hour, minute= 0, second= 0, msec= 0");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	SV *	RETVAL;
	wxDateTime_t	day = (wxDateTime_t)SvIV(ST(1))
;
	Month	month;
	int	year;
	wxDateTime_t	hour = (wxDateTime_t)SvIV(ST(4))
;
	wxDateTime_t	minute;
	wxDateTime_t	second;
	wxDateTime_t	msec;

	if (items < 3)
	    month = Inv_Month;
	else {
	    month = (Month)SvIV(ST(2))
;
	}

	if (items < 4)
	    year = Inv_Year;
	else {
	    year = (int)SvIV(ST(3))
;
	}

	if (items < 6)
	    minute = 0;
	else {
	    minute = (wxDateTime_t)SvIV(ST(5))
;
	}

	if (items < 7)
	    second = 0;
	else {
	    second = (wxDateTime_t)SvIV(ST(6))
;
	}

	if (items < 8)
	    msec = 0;
	else {
	    msec = (wxDateTime_t)SvIV(ST(7))
;
	}
    try {
      THIS->Set( day, month, year, hour, minute, second, msec );
      RETVAL = ST(0); SvREFCNT_inc( ST(0) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_SetYear); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_SetYear)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, year");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	SV *	RETVAL;
	int	year = (int)SvIV(ST(1))
;
    try {
      THIS->SetYear( year );
      RETVAL = ST(0); SvREFCNT_inc( ST(0) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_SetMonth); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_SetMonth)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, month");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	SV *	RETVAL;
	Month	month = (Month)SvIV(ST(1))
;
    try {
      THIS->SetMonth( month );
      RETVAL = ST(0); SvREFCNT_inc( ST(0) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_SetDay); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_SetDay)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, day");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	SV *	RETVAL;
	wxDateTime_t	day = (wxDateTime_t)SvIV(ST(1))
;
    try {
      THIS->SetDay( day );
      RETVAL = ST(0); SvREFCNT_inc( ST(0) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_SetHour); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_SetHour)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, hour");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	SV *	RETVAL;
	wxDateTime_t	hour = (wxDateTime_t)SvIV(ST(1))
;
    try {
      THIS->SetHour( hour );
      RETVAL = ST(0); SvREFCNT_inc( ST(0) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_SetMinute); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_SetMinute)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, minute");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	SV *	RETVAL;
	wxDateTime_t	minute = (wxDateTime_t)SvIV(ST(1))
;
    try {
      THIS->SetMinute( minute );
      RETVAL = ST(0); SvREFCNT_inc( ST(0) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_SetSecond); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_SetSecond)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, second");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	SV *	RETVAL;
	wxDateTime_t	second = (wxDateTime_t)SvIV(ST(1))
;
    try {
      THIS->SetSecond( second );
      RETVAL = ST(0); SvREFCNT_inc( ST(0) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_SetMillisecond); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_SetMillisecond)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, millisecond");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	SV *	RETVAL;
	wxDateTime_t	millisecond = (wxDateTime_t)SvIV(ST(1))
;
    try {
      THIS->SetMillisecond( millisecond );
      RETVAL = ST(0); SvREFCNT_inc( ST(0) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_FormatISODate); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_FormatISODate)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxString	RETVAL;
    try {
      RETVAL = THIS->FormatISODate();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    WXSTRING_OUTPUT( RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_FormatTime); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_FormatTime)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxString	RETVAL;
    try {
      RETVAL = THIS->FormatTime();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    WXSTRING_OUTPUT( RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_FormatISOTime); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_FormatISOTime)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxString	RETVAL;
    try {
      RETVAL = THIS->FormatISOTime();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    WXSTRING_OUTPUT( RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}

#if WXPERL_W_VERSION_LT( 2, 9, 0 )
#define XSpp_dd8f2889_044633
#define XSubPPtmpAAAA 1


XS_EUPXS(XS_Wx__DateTime_ParseFormat); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_ParseFormat)
{
    dVAR; dXSARGS;
    if (items < 2 || items > 4)
       croak_xs_usage(cv,  "THIS, date, format= wxDefaultDateTimeFormat, dateDef= wxDefaultDateTimePtr");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxString	RETVAL;
	wxString	date;
	wxString	format;
	wxDateTime*	dateDef;

    WXSTRING_INPUT( date, wxString, ST(1) )
;

	if (items < 3)
	    format = wxDefaultDateTimeFormat;
	else {
    WXSTRING_INPUT( format, wxString, ST(2) )
;
	}

	if (items < 4)
	    dateDef = wxDefaultDateTimePtr;
	else {
    dateDef = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(3), "Wx::DateTime" )
;
	}
    try {
      RETVAL = THIS->ParseFormat( date, format, *( dateDef ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    WXSTRING_OUTPUT( RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_ParseDate); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_ParseDate)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, date");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxString	RETVAL;
	wxString	date;

    WXSTRING_INPUT( date, wxString, ST(1) )
;
    try {
      RETVAL = THIS->ParseDate( date );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    WXSTRING_OUTPUT( RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_ParseDateTime); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_ParseDateTime)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, date");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxString	RETVAL;
	wxString	date;

    WXSTRING_INPUT( date, wxString, ST(1) )
;
    try {
      RETVAL = THIS->ParseDateTime( date );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    WXSTRING_OUTPUT( RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_ParseTime); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_ParseTime)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, date");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxString	RETVAL;
	wxString	date;

    WXSTRING_INPUT( date, wxString, ST(1) )
;
    try {
      RETVAL = THIS->ParseTime( date );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    WXSTRING_OUTPUT( RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_ParseRfc822Date); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_ParseRfc822Date)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, date");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	wxString	RETVAL;
	wxString	date;

    WXSTRING_INPUT( date, wxString, ST(1) )
;
    try {
      RETVAL = THIS->ParseRfc822Date( date );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    WXSTRING_OUTPUT( RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}

#endif

XS_EUPXS(XS_Wx__DateTime_SetToCurrent); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_SetToCurrent)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	SV *	RETVAL;
    try {
      THIS->SetToCurrent();
      RETVAL = ST(0); SvREFCNT_inc( ST(0) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_ResetTime); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_ResetTime)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	SV *	RETVAL;
    try {
      THIS->ResetTime();
      RETVAL = ST(0); SvREFCNT_inc( ST(0) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_IsEqualTo); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_IsEqualTo)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, dt");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	bool	RETVAL;
	wxDateTime*    dt = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(1), "Wx::DateTime" )
;
    try {
      RETVAL = THIS->IsEqualTo( *( dt ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_IsEarlierThan); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_IsEarlierThan)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, dt");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	bool	RETVAL;
	wxDateTime*    dt = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(1), "Wx::DateTime" )
;
    try {
      RETVAL = THIS->IsEarlierThan( *( dt ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_IsLaterThan); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_IsLaterThan)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, dt");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	bool	RETVAL;
	wxDateTime*    dt = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(1), "Wx::DateTime" )
;
    try {
      RETVAL = THIS->IsLaterThan( *( dt ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_IsBetween); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_IsBetween)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, dt1, dt2");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	bool	RETVAL;
	wxDateTime*    dt1 = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(1), "Wx::DateTime" )
;
	wxDateTime*    dt2 = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(2), "Wx::DateTime" )
;
    try {
      RETVAL = THIS->IsBetween( *( dt1 ), *( dt2 ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_IsStrictlyBetween); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_IsStrictlyBetween)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, dt1, dt2");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	bool	RETVAL;
	wxDateTime*    dt1 = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(1), "Wx::DateTime" )
;
	wxDateTime*    dt2 = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(2), "Wx::DateTime" )
;
    try {
      RETVAL = THIS->IsStrictlyBetween( *( dt1 ), *( dt2 ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_IsSameDate); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_IsSameDate)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, dt");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	bool	RETVAL;
	wxDateTime*    dt = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(1), "Wx::DateTime" )
;
    try {
      RETVAL = THIS->IsSameDate( *( dt ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_IsSameTime); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_IsSameTime)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, dt");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	bool	RETVAL;
	wxDateTime*    dt = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(1), "Wx::DateTime" )
;
    try {
      RETVAL = THIS->IsSameTime( *( dt ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_IsValid); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_IsValid)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	bool	RETVAL;
    try {
      RETVAL = THIS->IsValid();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_AddDate); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_AddDate)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, ds");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	SV *	RETVAL;
	wxDateSpan*    ds = (wxDateSpan *) wxPli_sv_2_object( aTHX_ ST(1), "Wx::DateSpan" )
;
    try {
      THIS->Add( *( ds ) );
      RETVAL = ST(0); SvREFCNT_inc( ST(0) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_AddTime); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_AddTime)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, ds");
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
	SV *	RETVAL;
	wxTimeSpan*    ds = (wxTimeSpan *) wxPli_sv_2_object( aTHX_ ST(1), "Wx::TimeSpan" )
;
    try {
      THIS->Add( *( ds ) );
      RETVAL = ST(0); SvREFCNT_inc( ST(0) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetAmPmStrings); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetAmPmStrings)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	wxDateTime *    THIS = (wxDateTime *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateTime" )
;
    wxString am, pm;
    THIS->GetAmPmStrings( &am, &pm );
    SV* ams = wxPli_wxString_2_sv( aTHX_ am, sv_newmortal() ),
      * pms = wxPli_wxString_2_sv( aTHX_ pm, sv_newmortal() );
    EXTEND( SP, 2 );
    PUSHs( ams );
    PUSHs( pms );    
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Wx__DateTime_Today); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_Today)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	wxDateTime *	RETVAL;
    RETVAL = new wxDateTime( wxDateTime::Today() );
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    wxPli_non_object_2_sv( aTHX_ RETVALSV, RETVAL, "Wx::DateTime" );
    wxPli_thread_sv_register( aTHX_ "Wx::DateTime", RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_Now); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_Now)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	wxDateTime *	RETVAL;
    RETVAL = new wxDateTime( wxDateTime::Now() );
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    wxPli_non_object_2_sv( aTHX_ RETVALSV, RETVAL, "Wx::DateTime" );
    wxPli_thread_sv_register( aTHX_ "Wx::DateTime", RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_UNow); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_UNow)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	wxDateTime *	RETVAL;
    RETVAL = new wxDateTime( wxDateTime::UNow() );
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    wxPli_non_object_2_sv( aTHX_ RETVALSV, RETVAL, "Wx::DateTime" );
    wxPli_thread_sv_register( aTHX_ "Wx::DateTime", RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_IsLeapYear); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_IsLeapYear)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "year, cal= Gregorian");
    {
	bool	RETVAL;
	int	year = (int)SvIV(ST(0))
;
	Calendar	cal;

	if (items < 2)
	    cal = Gregorian;
	else {
	    cal = (Calendar)SvIV(ST(1))
;
	}
    RETVAL = wxDateTime::IsLeapYear( year, cal );
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetMonthName); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetMonthName)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "month, flags= Name_Full");
    {
	wxString	RETVAL;
	Month	month = (Month)SvIV(ST(0))
;
	NameFlags	flags;

	if (items < 2)
	    flags = Name_Full;
	else {
	    flags = (NameFlags)SvIV(ST(1))
;
	}
    RETVAL = wxDateTime::GetMonthName( month, flags );
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    WXSTRING_OUTPUT( RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetWeekDayName); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetWeekDayName)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "weekday, flags= Name_Full");
    {
	wxString	RETVAL;
	WeekDay	weekday = (WeekDay)SvIV(ST(0))
;
	NameFlags	flags;

	if (items < 2)
	    flags = Name_Full;
	else {
	    flags = (NameFlags)SvIV(ST(1))
;
	}
    RETVAL = wxDateTime::GetWeekDayName( weekday, flags );
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    WXSTRING_OUTPUT( RETVAL, RETVALSV );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetNumberOfDaysInYear); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetNumberOfDaysInYear)
{
    dVAR; dXSARGS;
    if (items < 0 || items > 2)
       croak_xs_usage(cv,  "year= Inv_Year, cal= Gregorian");
    {
	wxDateTime_t	RETVAL;
	dXSTARG;
	int	year;
	Calendar	cal;

	if (items < 1)
	    year = Inv_Year;
	else {
	    year = (int)SvIV(ST(0))
;
	}

	if (items < 2)
	    cal = Gregorian;
	else {
	    cal = (Calendar)SvIV(ST(1))
;
	}
    RETVAL = wxDateTime::GetNumberOfDays( year, cal );
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetNumberOfDaysInMonth); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetNumberOfDaysInMonth)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 3)
       croak_xs_usage(cv,  "month, year= Inv_Year, cal= Gregorian");
    {
	wxDateTime_t	RETVAL;
	dXSTARG;
	Month	month = (Month)SvIV(ST(0))
;
	int	year;
	Calendar	cal;

	if (items < 2)
	    year = Inv_Year;
	else {
	    year = (int)SvIV(ST(1))
;
	}

	if (items < 3)
	    cal = Gregorian;
	else {
	    cal = (Calendar)SvIV(ST(2))
;
	}
    RETVAL = wxDateTime::GetNumberOfDays( month, year, cal );
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetCentury); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetCentury)
{
    dVAR; dXSARGS;
    if (items < 0 || items > 1)
       croak_xs_usage(cv,  "year= Inv_Year");
    {
	int	RETVAL;
	dXSTARG;
	int	year;

	if (items < 1)
	    year = Inv_Year;
	else {
	    year = (int)SvIV(ST(0))
;
	}
    RETVAL = wxDateTime::GetCentury( year );
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetCurrentYear); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetCurrentYear)
{
    dVAR; dXSARGS;
    if (items < 0 || items > 1)
       croak_xs_usage(cv,  "cal= Gregorian");
    {
	int	RETVAL;
	dXSTARG;
	Calendar	cal;

	if (items < 1)
	    cal = Gregorian;
	else {
	    cal = (Calendar)SvIV(ST(0))
;
	}
    RETVAL = wxDateTime::GetCurrentYear( cal );
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateTime_GetCurrentMonth); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateTime_GetCurrentMonth)
{
    dVAR; dXSARGS;
    if (items < 0 || items > 1)
       croak_xs_usage(cv,  "cal= Gregorian");
    {
	int	RETVAL;
	dXSTARG;
	Calendar	cal;

	if (items < 1)
	    cal = Gregorian;
	else {
	    cal = (Calendar)SvIV(ST(0))
;
	}
    RETVAL = wxDateTime::GetCurrentMonth( cal );
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


/* INCLUDE: Returning to 'DateTime.xs' from '/usr/bin/perl -MExtUtils::XSpp::Cmd -e xspp -- -t ../../typemap.xsp XS/DateTime.xsp' */


/* INCLUDE_COMMAND:  Including output of '/usr/bin/perl -MExtUtils::XSpp::Cmd -e xspp -- -t ../../typemap.xsp XS/DateSpan.xsp' from 'DateTime.xs' */

#include <exception>

#undef  xsp_constructor_class
#define xsp_constructor_class(c) (c)
#include <wx/datetime.h>
#undef  xsp_constructor_class
#define xsp_constructor_class(c) (CLASS)

XS_EUPXS(XS_Wx__DateSpan_new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateSpan_new)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 5)
       croak_xs_usage(cv,  "CLASS, year= 0, month= 0, week= 0, day= 0");
    {
	char *	CLASS = (char *)SvPV_nolen(ST(0))
;
	wxDateSpan *	RETVAL;
	int	year;
	int	month;
	int	week;
	int	day;

	if (items < 2)
	    year = 0;
	else {
	    year = (int)SvIV(ST(1))
;
	}

	if (items < 3)
	    month = 0;
	else {
	    month = (int)SvIV(ST(2))
;
	}

	if (items < 4)
	    week = 0;
	else {
	    week = (int)SvIV(ST(3))
;
	}

	if (items < 5)
	    day = 0;
	else {
	    day = (int)SvIV(ST(4))
;
	}
    try {
      RETVAL = new wxDateSpan( year, month, week, day );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    wxPli_non_object_2_sv( aTHX_ RETVALSV, RETVAL, "Wx::DateSpan" );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}

#undef  xsp_constructor_class
#define xsp_constructor_class(c) (c)

XS_EUPXS(XS_Wx__DateSpan_GetDays); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateSpan_GetDays)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxDateSpan *    THIS = (wxDateSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateSpan" )
;
	int	RETVAL;
	dXSTARG;
    try {
      RETVAL = THIS->GetDays();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateSpan_GetMonths); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateSpan_GetMonths)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxDateSpan *    THIS = (wxDateSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateSpan" )
;
	int	RETVAL;
	dXSTARG;
    try {
      RETVAL = THIS->GetMonths();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateSpan_GetTotalDays); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateSpan_GetTotalDays)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxDateSpan *    THIS = (wxDateSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateSpan" )
;
	int	RETVAL;
	dXSTARG;
    try {
      RETVAL = THIS->GetTotalDays();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateSpan_GetWeeks); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateSpan_GetWeeks)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxDateSpan *    THIS = (wxDateSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateSpan" )
;
	int	RETVAL;
	dXSTARG;
    try {
      RETVAL = THIS->GetWeeks();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateSpan_GetYears); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateSpan_GetYears)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxDateSpan *    THIS = (wxDateSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateSpan" )
;
	int	RETVAL;
	dXSTARG;
    try {
      RETVAL = THIS->GetYears();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateSpan_Add); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateSpan_Add)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, ds");
    {
	wxDateSpan *    THIS = (wxDateSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateSpan" )
;
	wxDateSpan *	RETVAL;
	wxDateSpan*    ds = (wxDateSpan *) wxPli_sv_2_object( aTHX_ ST(1), "Wx::DateSpan" )
;
    try {
      RETVAL = new wxDateSpan( THIS->Add( *( ds ) ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    wxPli_non_object_2_sv( aTHX_ RETVALSV, RETVAL, "Wx::DateSpan" );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateSpan_Multiply); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateSpan_Multiply)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, factor");
    {
	wxDateSpan *    THIS = (wxDateSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateSpan" )
;
	wxDateSpan *	RETVAL;
	int	factor = (int)SvIV(ST(1))
;
    try {
      RETVAL = new wxDateSpan( THIS->Multiply( factor ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    wxPli_non_object_2_sv( aTHX_ RETVALSV, RETVAL, "Wx::DateSpan" );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateSpan_Neg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateSpan_Neg)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxDateSpan *    THIS = (wxDateSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateSpan" )
;
	wxDateSpan *	RETVAL;
    try {
      RETVAL = new wxDateSpan( THIS->Neg() );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    wxPli_non_object_2_sv( aTHX_ RETVALSV, RETVAL, "Wx::DateSpan" );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateSpan_SetDays); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateSpan_SetDays)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, n");
    {
	wxDateSpan *    THIS = (wxDateSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateSpan" )
;
	wxDateSpan *	RETVAL;
	int	n = (int)SvIV(ST(1))
;
    try {
      RETVAL = new wxDateSpan( THIS->SetDays( n ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    wxPli_non_object_2_sv( aTHX_ RETVALSV, RETVAL, "Wx::DateSpan" );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateSpan_SetYears); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateSpan_SetYears)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, n");
    {
	wxDateSpan *    THIS = (wxDateSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateSpan" )
;
	wxDateSpan *	RETVAL;
	int	n = (int)SvIV(ST(1))
;
    try {
      RETVAL = new wxDateSpan( THIS->SetYears( n ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    wxPli_non_object_2_sv( aTHX_ RETVALSV, RETVAL, "Wx::DateSpan" );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateSpan_SetMonths); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateSpan_SetMonths)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, n");
    {
	wxDateSpan *    THIS = (wxDateSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateSpan" )
;
	wxDateSpan *	RETVAL;
	int	n = (int)SvIV(ST(1))
;
    try {
      RETVAL = new wxDateSpan( THIS->SetMonths( n ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    wxPli_non_object_2_sv( aTHX_ RETVALSV, RETVAL, "Wx::DateSpan" );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateSpan_SetWeeks); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateSpan_SetWeeks)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, n");
    {
	wxDateSpan *    THIS = (wxDateSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateSpan" )
;
	wxDateSpan *	RETVAL;
	int	n = (int)SvIV(ST(1))
;
    try {
      RETVAL = new wxDateSpan( THIS->SetWeeks( n ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    wxPli_non_object_2_sv( aTHX_ RETVALSV, RETVAL, "Wx::DateSpan" );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__DateSpan_Subtract); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__DateSpan_Subtract)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, ds");
    {
	wxDateSpan *    THIS = (wxDateSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::DateSpan" )
;
	wxDateSpan *	RETVAL;
	wxDateSpan*    ds = (wxDateSpan *) wxPli_sv_2_object( aTHX_ ST(1), "Wx::DateSpan" )
;
    try {
      RETVAL = new wxDateSpan( THIS->Subtract( *( ds ) ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    wxPli_non_object_2_sv( aTHX_ RETVALSV, RETVAL, "Wx::DateSpan" );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}


/* INCLUDE: Returning to 'DateTime.xs' from '/usr/bin/perl -MExtUtils::XSpp::Cmd -e xspp -- -t ../../typemap.xsp XS/DateSpan.xsp' */


/* INCLUDE_COMMAND:  Including output of '/usr/bin/perl -MExtUtils::XSpp::Cmd -e xspp -- -t ../../typemap.xsp XS/TimeSpan.xsp' from 'DateTime.xs' */

#include <exception>

#undef  xsp_constructor_class
#define xsp_constructor_class(c) (c)
#include <wx/datetime.h>
#undef  xsp_constructor_class
#define xsp_constructor_class(c) (CLASS)

XS_EUPXS(XS_Wx__TimeSpan_new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__TimeSpan_new)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "CLASS");
    {
	char *	CLASS = (char *)SvPV_nolen(ST(0))
;
	wxTimeSpan *	RETVAL;
    try {
      RETVAL = new wxTimeSpan();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    wxPli_non_object_2_sv( aTHX_ RETVALSV, RETVAL, "Wx::TimeSpan" );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}

#undef  xsp_constructor_class
#define xsp_constructor_class(c) (c)
#undef  xsp_constructor_class
#define xsp_constructor_class(c) (CLASS)

XS_EUPXS(XS_Wx__TimeSpan_newFromHMS); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__TimeSpan_newFromHMS)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 5)
       croak_xs_usage(cv,  "CLASS, hour= 0, minute= 0, second= 0, millisec= 0");
    {
	char *	CLASS = (char *)SvPV_nolen(ST(0))
;
	wxTimeSpan *	RETVAL;
	long	hour;
	long	minute;
	long	second;
	long	millisec;

	if (items < 2)
	    hour = 0;
	else {
	    hour = (long)SvIV(ST(1))
;
	}

	if (items < 3)
	    minute = 0;
	else {
	    minute = (long)SvIV(ST(2))
;
	}

	if (items < 4)
	    second = 0;
	else {
	    second = (long)SvIV(ST(3))
;
	}

	if (items < 5)
	    millisec = 0;
	else {
	    millisec = (long)SvIV(ST(4))
;
	}
    try {
      RETVAL = new wxTimeSpan( hour, minute, second, millisec );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
    wxPli_non_object_2_sv( aTHX_ RETVALSV, RETVAL, "Wx::TimeSpan" );
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}

#undef  xsp_constructor_class
#define xsp_constructor_class(c) (c)

XS_EUPXS(XS_Wx__TimeSpan_GetHours); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__TimeSpan_GetHours)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxTimeSpan *    THIS = (wxTimeSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::TimeSpan" )
;
	int	RETVAL;
	dXSTARG;
    try {
      RETVAL = THIS->GetHours();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__TimeSpan_GetDays); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__TimeSpan_GetDays)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxTimeSpan *    THIS = (wxTimeSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::TimeSpan" )
;
	int	RETVAL;
	dXSTARG;
    try {
      RETVAL = THIS->GetDays();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__TimeSpan_GetWeeks); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__TimeSpan_GetWeeks)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxTimeSpan *    THIS = (wxTimeSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::TimeSpan" )
;
	int	RETVAL;
	dXSTARG;
    try {
      RETVAL = THIS->GetWeeks();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__TimeSpan_IsNull); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__TimeSpan_IsNull)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxTimeSpan *    THIS = (wxTimeSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::TimeSpan" )
;
	bool	RETVAL;
    try {
      RETVAL = THIS->IsNull();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__TimeSpan_IsPositive); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__TimeSpan_IsPositive)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxTimeSpan *    THIS = (wxTimeSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::TimeSpan" )
;
	bool	RETVAL;
    try {
      RETVAL = THIS->IsPositive();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__TimeSpan_IsNegative); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__TimeSpan_IsNegative)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	wxTimeSpan *    THIS = (wxTimeSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::TimeSpan" )
;
	bool	RETVAL;
    try {
      RETVAL = THIS->IsNegative();
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__TimeSpan_IsEqualTo); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__TimeSpan_IsEqualTo)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, ts");
    {
	wxTimeSpan *    THIS = (wxTimeSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::TimeSpan" )
;
	bool	RETVAL;
	wxTimeSpan*    ts = (wxTimeSpan *) wxPli_sv_2_object( aTHX_ ST(1), "Wx::TimeSpan" )
;
    try {
      RETVAL = THIS->IsEqualTo( *( ts ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__TimeSpan_IsLongerThan); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__TimeSpan_IsLongerThan)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, ts");
    {
	wxTimeSpan *    THIS = (wxTimeSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::TimeSpan" )
;
	bool	RETVAL;
	wxTimeSpan*    ts = (wxTimeSpan *) wxPli_sv_2_object( aTHX_ ST(1), "Wx::TimeSpan" )
;
    try {
      RETVAL = THIS->IsLongerThan( *( ts ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Wx__TimeSpan_IsShorterThan); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Wx__TimeSpan_IsShorterThan)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, ts");
    {
	wxTimeSpan *    THIS = (wxTimeSpan *) wxPli_sv_2_object( aTHX_ ST(0), "Wx::TimeSpan" )
;
	bool	RETVAL;
	wxTimeSpan*    ts = (wxTimeSpan *) wxPli_sv_2_object( aTHX_ ST(1), "Wx::TimeSpan" )
;
    try {
      RETVAL = THIS->IsShorterThan( *( ts ) );
    }
    catch (std::exception& e) {
      croak("Caught C++ exception of type or derived from 'std::exception': %s", e.what());
    }
    catch (...) {
      croak("Caught C++ exception of unknown type");
    }
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


/* INCLUDE: Returning to 'DateTime.xs' from '/usr/bin/perl -MExtUtils::XSpp::Cmd -e xspp -- -t ../../typemap.xsp XS/TimeSpan.xsp' */

#if defined(__WXMSW__)
#undef XS
#define XS( name ) WXXS( name )
#endif
#ifdef __cplusplus
extern "C"
#endif
XS_EXTERNAL(boot_Wx__DateTime); /* prototype to pass -Wmissing-prototypes */
XS_EXTERNAL(boot_Wx__DateTime)
{
#if PERL_VERSION_LE(5, 21, 5)
    dVAR; dXSARGS;
#else
    dVAR; dXSBOOTARGSXSAPIVERCHK;
#endif
#if PERL_VERSION_LE(5, 8, 999) /* PERL_VERSION_LT is 5.33+ */
    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("Wx::DateTime::new", XS_Wx__DateTime_new);
        newXS_deffile("Wx::DateTime::newFromTimeT", XS_Wx__DateTime_newFromTimeT);
        newXS_deffile("Wx::DateTime::newFromDMY", XS_Wx__DateTime_newFromDMY);
        newXS_deffile("Wx::DateTime::CLONE", XS_Wx__DateTime_CLONE);
        newXS_deffile("Wx::DateTime::DESTROY", XS_Wx__DateTime_DESTROY);
        newXS_deffile("Wx::DateTime::Format", XS_Wx__DateTime_Format);
        newXS_deffile("Wx::DateTime::FormatDate", XS_Wx__DateTime_FormatDate);
        newXS_deffile("Wx::DateTime::GetYear", XS_Wx__DateTime_GetYear);
        newXS_deffile("Wx::DateTime::GetMonth", XS_Wx__DateTime_GetMonth);
        newXS_deffile("Wx::DateTime::GetDay", XS_Wx__DateTime_GetDay);
        newXS_deffile("Wx::DateTime::GetWeekDay", XS_Wx__DateTime_GetWeekDay);
        newXS_deffile("Wx::DateTime::GetHour", XS_Wx__DateTime_GetHour);
        newXS_deffile("Wx::DateTime::GetMinute", XS_Wx__DateTime_GetMinute);
        newXS_deffile("Wx::DateTime::GetSecond", XS_Wx__DateTime_GetSecond);
        newXS_deffile("Wx::DateTime::GetMillisecond", XS_Wx__DateTime_GetMillisecond);
        newXS_deffile("Wx::DateTime::GetDayOfYear", XS_Wx__DateTime_GetDayOfYear);
        newXS_deffile("Wx::DateTime::GetWeekOfYear", XS_Wx__DateTime_GetWeekOfYear);
        newXS_deffile("Wx::DateTime::GetWeekOfMonth", XS_Wx__DateTime_GetWeekOfMonth);
        newXS_deffile("Wx::DateTime::SetTimeT", XS_Wx__DateTime_SetTimeT);
        newXS_deffile("Wx::DateTime::SetJDN", XS_Wx__DateTime_SetJDN);
        newXS_deffile("Wx::DateTime::SetHMS", XS_Wx__DateTime_SetHMS);
        newXS_deffile("Wx::DateTime::Set", XS_Wx__DateTime_Set);
        newXS_deffile("Wx::DateTime::SetYear", XS_Wx__DateTime_SetYear);
        newXS_deffile("Wx::DateTime::SetMonth", XS_Wx__DateTime_SetMonth);
        newXS_deffile("Wx::DateTime::SetDay", XS_Wx__DateTime_SetDay);
        newXS_deffile("Wx::DateTime::SetHour", XS_Wx__DateTime_SetHour);
        newXS_deffile("Wx::DateTime::SetMinute", XS_Wx__DateTime_SetMinute);
        newXS_deffile("Wx::DateTime::SetSecond", XS_Wx__DateTime_SetSecond);
        newXS_deffile("Wx::DateTime::SetMillisecond", XS_Wx__DateTime_SetMillisecond);
        newXS_deffile("Wx::DateTime::FormatISODate", XS_Wx__DateTime_FormatISODate);
        newXS_deffile("Wx::DateTime::FormatTime", XS_Wx__DateTime_FormatTime);
        newXS_deffile("Wx::DateTime::FormatISOTime", XS_Wx__DateTime_FormatISOTime);
#if XSubPPtmpAAAA
        newXS_deffile("Wx::DateTime::ParseFormat", XS_Wx__DateTime_ParseFormat);
        newXS_deffile("Wx::DateTime::ParseDate", XS_Wx__DateTime_ParseDate);
        newXS_deffile("Wx::DateTime::ParseDateTime", XS_Wx__DateTime_ParseDateTime);
        newXS_deffile("Wx::DateTime::ParseTime", XS_Wx__DateTime_ParseTime);
        newXS_deffile("Wx::DateTime::ParseRfc822Date", XS_Wx__DateTime_ParseRfc822Date);
#endif
        newXS_deffile("Wx::DateTime::SetToCurrent", XS_Wx__DateTime_SetToCurrent);
        newXS_deffile("Wx::DateTime::ResetTime", XS_Wx__DateTime_ResetTime);
        newXS_deffile("Wx::DateTime::IsEqualTo", XS_Wx__DateTime_IsEqualTo);
        newXS_deffile("Wx::DateTime::IsEarlierThan", XS_Wx__DateTime_IsEarlierThan);
        newXS_deffile("Wx::DateTime::IsLaterThan", XS_Wx__DateTime_IsLaterThan);
        newXS_deffile("Wx::DateTime::IsBetween", XS_Wx__DateTime_IsBetween);
        newXS_deffile("Wx::DateTime::IsStrictlyBetween", XS_Wx__DateTime_IsStrictlyBetween);
        newXS_deffile("Wx::DateTime::IsSameDate", XS_Wx__DateTime_IsSameDate);
        newXS_deffile("Wx::DateTime::IsSameTime", XS_Wx__DateTime_IsSameTime);
        newXS_deffile("Wx::DateTime::IsValid", XS_Wx__DateTime_IsValid);
        newXS_deffile("Wx::DateTime::AddDate", XS_Wx__DateTime_AddDate);
        newXS_deffile("Wx::DateTime::AddTime", XS_Wx__DateTime_AddTime);
        newXS_deffile("Wx::DateTime::GetAmPmStrings", XS_Wx__DateTime_GetAmPmStrings);
        newXS_deffile("Wx::DateTime::Today", XS_Wx__DateTime_Today);
        newXS_deffile("Wx::DateTime::Now", XS_Wx__DateTime_Now);
        newXS_deffile("Wx::DateTime::UNow", XS_Wx__DateTime_UNow);
        newXS_deffile("Wx::DateTime::IsLeapYear", XS_Wx__DateTime_IsLeapYear);
        newXS_deffile("Wx::DateTime::GetMonthName", XS_Wx__DateTime_GetMonthName);
        newXS_deffile("Wx::DateTime::GetWeekDayName", XS_Wx__DateTime_GetWeekDayName);
        newXS_deffile("Wx::DateTime::GetNumberOfDaysInYear", XS_Wx__DateTime_GetNumberOfDaysInYear);
        newXS_deffile("Wx::DateTime::GetNumberOfDaysInMonth", XS_Wx__DateTime_GetNumberOfDaysInMonth);
        newXS_deffile("Wx::DateTime::GetCentury", XS_Wx__DateTime_GetCentury);
        newXS_deffile("Wx::DateTime::GetCurrentYear", XS_Wx__DateTime_GetCurrentYear);
        newXS_deffile("Wx::DateTime::GetCurrentMonth", XS_Wx__DateTime_GetCurrentMonth);
        newXS_deffile("Wx::DateSpan::new", XS_Wx__DateSpan_new);
        newXS_deffile("Wx::DateSpan::GetDays", XS_Wx__DateSpan_GetDays);
        newXS_deffile("Wx::DateSpan::GetMonths", XS_Wx__DateSpan_GetMonths);
        newXS_deffile("Wx::DateSpan::GetTotalDays", XS_Wx__DateSpan_GetTotalDays);
        newXS_deffile("Wx::DateSpan::GetWeeks", XS_Wx__DateSpan_GetWeeks);
        newXS_deffile("Wx::DateSpan::GetYears", XS_Wx__DateSpan_GetYears);
        newXS_deffile("Wx::DateSpan::Add", XS_Wx__DateSpan_Add);
        newXS_deffile("Wx::DateSpan::Multiply", XS_Wx__DateSpan_Multiply);
        newXS_deffile("Wx::DateSpan::Neg", XS_Wx__DateSpan_Neg);
        newXS_deffile("Wx::DateSpan::SetDays", XS_Wx__DateSpan_SetDays);
        newXS_deffile("Wx::DateSpan::SetYears", XS_Wx__DateSpan_SetYears);
        newXS_deffile("Wx::DateSpan::SetMonths", XS_Wx__DateSpan_SetMonths);
        newXS_deffile("Wx::DateSpan::SetWeeks", XS_Wx__DateSpan_SetWeeks);
        newXS_deffile("Wx::DateSpan::Subtract", XS_Wx__DateSpan_Subtract);
        newXS_deffile("Wx::TimeSpan::new", XS_Wx__TimeSpan_new);
        newXS_deffile("Wx::TimeSpan::newFromHMS", XS_Wx__TimeSpan_newFromHMS);
        newXS_deffile("Wx::TimeSpan::GetHours", XS_Wx__TimeSpan_GetHours);
        newXS_deffile("Wx::TimeSpan::GetDays", XS_Wx__TimeSpan_GetDays);
        newXS_deffile("Wx::TimeSpan::GetWeeks", XS_Wx__TimeSpan_GetWeeks);
        newXS_deffile("Wx::TimeSpan::IsNull", XS_Wx__TimeSpan_IsNull);
        newXS_deffile("Wx::TimeSpan::IsPositive", XS_Wx__TimeSpan_IsPositive);
        newXS_deffile("Wx::TimeSpan::IsNegative", XS_Wx__TimeSpan_IsNegative);
        newXS_deffile("Wx::TimeSpan::IsEqualTo", XS_Wx__TimeSpan_IsEqualTo);
        newXS_deffile("Wx::TimeSpan::IsLongerThan", XS_Wx__TimeSpan_IsLongerThan);
        newXS_deffile("Wx::TimeSpan::IsShorterThan", XS_Wx__TimeSpan_IsShorterThan);

    /* Initialisation Section */

  INIT_PLI_HELPERS( wx_pli_helpers );

#if XSubPPtmpAAAA
#endif

    /* 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
}

