cse2410spring2014_team2

/*

 * This file was generated automatically by ExtUtils::ParseXS version 3.18 from the

 * contents of Conversation.xs. Do not edit this file, edit Conversation.xs instead.

 *

 *    ANY CHANGES MADE HERE WILL BE LOST!

 *

 */

#line 1 "Conversation.xs"

#include "module.h"

#line 13 "Conversation.c"

#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(pTHX_ const CV *const cv, const char *const params);

STATIC void

S_croak_xs_usage(pTHX_ 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(aTHX_ "Usage: %s::%s(%s)", hvname, gvname, params);

        else

            Perl_croak(aTHX_ "Usage: %s(%s)", gvname, params);

    } else {

        /* Pants. I don't think that it should be possible to get here. */

        Perl_croak(aTHX_ "Usage: CODE(0x%"UVxf")(%s)", PTR2UV(cv), params);

    }

}

#undef  PERL_ARGS_ASSERT_CROAK_XS_USAGE

#ifdef PERL_IMPLICIT_CONTEXT

#define croak_xs_usage(a,b)    S_croak_xs_usage(aTHX_ a,b)

#else

#define croak_xs_usage        S_croak_xs_usage

#endif

#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) */

#line 155 "Conversation.c"

XS_EUPXS(XS_Purple_get_ims); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple_get_ims)

{

    dVAR; dXSARGS;

    if (items != 0)

       croak_xs_usage(cv,  "");

    PERL_UNUSED_VAR(ax); /* -Wall */

    SP -= items;

    {

#line 97 "Conversation.xs"

        GList *l;

#line 168 "Conversation.c"

#line 99 "Conversation.xs"

        for (l = purple_get_ims(); l != NULL; l = l->next) {

                XPUSHs(sv_2mortal(purple_perl_bless_object(l->data, "Purple::Conversation")));

        }

#line 173 "Conversation.c"

        PUTBACK;

        return;

    }

}

XS_EUPXS(XS_Purple_get_conversations); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple_get_conversations)

{

    dVAR; dXSARGS;

    if (items != 0)

       croak_xs_usage(cv,  "");

    PERL_UNUSED_VAR(ax); /* -Wall */

    SP -= items;

    {

#line 106 "Conversation.xs"

        GList *l;

#line 191 "Conversation.c"

#line 108 "Conversation.xs"

        for (l = purple_get_conversations(); l != NULL; l = l->next) {

                XPUSHs(sv_2mortal(purple_perl_bless_object(l->data, "Purple::Conversation")));

        }

#line 196 "Conversation.c"

        PUTBACK;

        return;

    }

}

XS_EUPXS(XS_Purple_get_chats); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple_get_chats)

{

    dVAR; dXSARGS;

    if (items != 0)

       croak_xs_usage(cv,  "");

    PERL_UNUSED_VAR(ax); /* -Wall */

    SP -= items;

    {

#line 115 "Conversation.xs"

        GList *l;

#line 214 "Conversation.c"

#line 117 "Conversation.xs"

        for (l = purple_get_chats(); l != NULL; l = l->next) {

                XPUSHs(sv_2mortal(purple_perl_bless_object(l->data, "Purple::Conversation")));

        }

#line 219 "Conversation.c"

        PUTBACK;

        return;

    }

}

XS_EUPXS(XS_Purple_find_conversation_with_account); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple_find_conversation_with_account)

{

    dVAR; dXSARGS;

    if (items != 3)

       croak_xs_usage(cv,  "type, name, account");

    {

        Purple__ConversationType        type = (Purple__ConversationType)SvIV(ST(0))

;

        const char *        name = (const char *)SvPV_nolen(ST(1))

;

        Purple__Account        account = purple_perl_ref_object(ST(2))

;

        Purple__Conversation        RETVAL;

        RETVAL = purple_find_conversation_with_account(type, name, account);

        ST(0) = purple_perl_bless_object(RETVAL, "Purple::Conversation");

        sv_2mortal(ST(0));

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversations_get_handle); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversations_get_handle)

{

    dVAR; dXSARGS;

    if (items != 0)

       croak_xs_usage(cv,  "");

    {

        Purple__Handle        RETVAL;

        RETVAL = purple_conversations_get_handle();

        ST(0) = purple_perl_bless_object(RETVAL, "Purple::Handle");

        sv_2mortal(ST(0));

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation_destroy); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_destroy)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "conv");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        purple_conversation_destroy(conv);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation_get_type); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_get_type)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "conv");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        Purple__ConversationType        RETVAL;

        dXSTARG;

        RETVAL = purple_conversation_get_type(conv);

        XSprePUSH; PUSHi((IV)RETVAL);

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation_get_account); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_get_account)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "conv");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        Purple__Account        RETVAL;

        RETVAL = purple_conversation_get_account(conv);

        ST(0) = purple_perl_bless_object(RETVAL, "Purple::Account");

        sv_2mortal(ST(0));

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation_get_gc); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_get_gc)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "conv");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        Purple__Connection        RETVAL;

        RETVAL = purple_conversation_get_gc(conv);

        ST(0) = purple_perl_bless_object(RETVAL, "Purple::Connection");

        sv_2mortal(ST(0));

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation_set_title); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_set_title)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "conv, title");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        const char *        title = (const char *)SvPV_nolen(ST(1))

;

        purple_conversation_set_title(conv, title);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation_get_title); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_get_title)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "conv");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        const char *        RETVAL;

        dXSTARG;

        RETVAL = purple_conversation_get_title(conv);

        sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation_autoset_title); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_autoset_title)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "conv");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        purple_conversation_autoset_title(conv);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation_set_name); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_set_name)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "conv, name");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        const char *        name = (const char *)SvPV_nolen(ST(1))

;

        purple_conversation_set_name(conv, name);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation_get_name); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_get_name)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "conv");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        const char *        RETVAL;

        dXSTARG;

        RETVAL = purple_conversation_get_name(conv);

        sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation_set_logging); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_set_logging)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "conv, log");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        gboolean        log = (bool)SvTRUE(ST(1))

;

        purple_conversation_set_logging(conv, log);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation_is_logging); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_is_logging)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "conv");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        gboolean        RETVAL;

        RETVAL = purple_conversation_is_logging(conv);

        ST(0) = sv_newmortal();

        ST(0) = boolSV(RETVAL);

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation_get_im_data); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_get_im_data)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "conv");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        Purple__Conversation__IM        RETVAL;

        RETVAL = purple_conversation_get_im_data(conv);

        ST(0) = purple_perl_bless_object(RETVAL, "Purple::Conversation::IM");

        sv_2mortal(ST(0));

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation_get_chat_data); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_get_chat_data)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "conv");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        Purple__Conversation__Chat        RETVAL;

        RETVAL = purple_conversation_get_chat_data(conv);

        ST(0) = purple_perl_bless_object(RETVAL, "Purple::Conversation::Chat");

        sv_2mortal(ST(0));

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation_get_data); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_get_data)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "conv, key");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        const char *        key = (const char *)SvPV_nolen(ST(1))

;

        gpointer        RETVAL;

        RETVAL = purple_conversation_get_data(conv, key);

        ST(0) = purple_perl_bless_object(RETVAL, "gpointer");

        sv_2mortal(ST(0));

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation_get_features); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_get_features)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "conv");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        Purple__ConnectionFlags        RETVAL;

        dXSTARG;

        RETVAL = purple_conversation_get_features(conv);

        XSprePUSH; PUSHi((IV)RETVAL);

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation_has_focus); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_has_focus)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "conv");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        gboolean        RETVAL;

        RETVAL = purple_conversation_has_focus(conv);

        ST(0) = sv_newmortal();

        ST(0) = boolSV(RETVAL);

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation_update); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_update)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "conv, type");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        Purple__ConvUpdateType        type = (Purple__ConvUpdateType)SvIV(ST(1))

;

        purple_conversation_update(conv, type);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation_new); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_new)

{

    dVAR; dXSARGS;

    if (items != 4)

       croak_xs_usage(cv,  "class, type, account, name");

    {

        Purple__ConversationType        type = (Purple__ConversationType)SvIV(ST(1))

;

        Purple__Account        account = purple_perl_ref_object(ST(2))

;

        const char *        name = (const char *)SvPV_nolen(ST(3))

;

        Purple__Conversation        RETVAL;

        RETVAL = purple_conversation_new(type, account, name);

        ST(0) = purple_perl_bless_object(RETVAL, "Purple::Conversation");

        sv_2mortal(ST(0));

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation_set_account); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_set_account)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "conv, account");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        Purple__Account        account = purple_perl_ref_object(ST(1))

;

        purple_conversation_set_account(conv, account);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation_write); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_write)

{

    dVAR; dXSARGS;

    if (items != 5)

       croak_xs_usage(cv,  "conv, who, message, flags, mtime");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        const char *        who = (const char *)SvPV_nolen(ST(1))

;

        const char *        message = (const char *)SvPV_nolen(ST(2))

;

        Purple__MessageFlags        flags = (Purple__MessageFlags)SvIV(ST(3))

;

        time_t        mtime = (time_t)SvIV(ST(4))

;

        purple_conversation_write(conv, who, message, flags, mtime);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation_do_command); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_do_command)

{

    dVAR; dXSARGS;

    if (items != 4)

       croak_xs_usage(cv,  "conv, cmdline, markup, error");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        const char *        cmdline = (const char *)SvPV_nolen(ST(1))

;

        const char *        markup = (const char *)SvPV_nolen(ST(2))

;

        char **        error = INT2PTR(char **,SvIV(ST(3)))

;

        gboolean        RETVAL;

        RETVAL = purple_conversation_do_command(conv, cmdline, markup, error);

        ST(0) = sv_newmortal();

        ST(0) = boolSV(RETVAL);

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation__IM_get_conversation); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__IM_get_conversation)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "im");

    {

        Purple__Conversation__IM        im = purple_perl_ref_object(ST(0))

;

        Purple__Conversation        RETVAL;

        RETVAL = purple_conv_im_get_conversation(im);

        ST(0) = purple_perl_bless_object(RETVAL, "Purple::Conversation");

        sv_2mortal(ST(0));

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation__IM_set_icon); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__IM_set_icon)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "im, icon");

    {

        Purple__Conversation__IM        im = purple_perl_ref_object(ST(0))

;

        Purple__Buddy__Icon        icon = purple_perl_ref_object(ST(1))

;

        purple_conv_im_set_icon(im, icon);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation__IM_get_icon); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__IM_get_icon)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "im");

    {

        Purple__Conversation__IM        im = purple_perl_ref_object(ST(0))

;

        Purple__Buddy__Icon        RETVAL;

        RETVAL = purple_conv_im_get_icon(im);

        ST(0) = purple_perl_bless_object(RETVAL, "Purple::Buddy::Icon");

        sv_2mortal(ST(0));

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation__IM_set_typing_state); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__IM_set_typing_state)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "im, state");

    {

        Purple__Conversation__IM        im = purple_perl_ref_object(ST(0))

;

        Purple__TypingState        state = (Purple__TypingState)SvIV(ST(1))

;

        purple_conv_im_set_typing_state(im, state);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation__IM_get_typing_state); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__IM_get_typing_state)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "im");

    {

        Purple__Conversation__IM        im = purple_perl_ref_object(ST(0))

;

        Purple__TypingState        RETVAL;

        dXSTARG;

        RETVAL = purple_conv_im_get_typing_state(im);

        XSprePUSH; PUSHi((IV)RETVAL);

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation__IM_start_typing_timeout); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__IM_start_typing_timeout)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "im, timeout");

    {

        Purple__Conversation__IM        im = purple_perl_ref_object(ST(0))

;

        int        timeout = (int)SvIV(ST(1))

;

        purple_conv_im_start_typing_timeout(im, timeout);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation__IM_stop_typing_timeout); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__IM_stop_typing_timeout)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "im");

    {

        Purple__Conversation__IM        im = purple_perl_ref_object(ST(0))

;

        purple_conv_im_stop_typing_timeout(im);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation__IM_get_typing_timeout); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__IM_get_typing_timeout)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "im");

    {

        Purple__Conversation__IM        im = purple_perl_ref_object(ST(0))

;

        guint        RETVAL;

        dXSTARG;

        RETVAL = purple_conv_im_get_typing_timeout(im);

        XSprePUSH; PUSHi((IV)RETVAL);

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation__IM_set_type_again); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__IM_set_type_again)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "im, val");

    {

        Purple__Conversation__IM        im = purple_perl_ref_object(ST(0))

;

        time_t        val = (time_t)SvIV(ST(1))

;

        purple_conv_im_set_type_again(im, val);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation__IM_get_type_again); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__IM_get_type_again)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "im");

    {

        Purple__Conversation__IM        im = purple_perl_ref_object(ST(0))

;

        time_t        RETVAL;

        dXSTARG;

        RETVAL = purple_conv_im_get_type_again(im);

        XSprePUSH; PUSHi((IV)RETVAL);

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation__IM_start_send_typed_timeout); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__IM_start_send_typed_timeout)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "im");

    {

        Purple__Conversation__IM        im = purple_perl_ref_object(ST(0))

;

        purple_conv_im_start_send_typed_timeout(im);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation__IM_stop_send_typed_timeout); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__IM_stop_send_typed_timeout)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "im");

    {

        Purple__Conversation__IM        im = purple_perl_ref_object(ST(0))

;

        purple_conv_im_stop_send_typed_timeout(im);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation__IM_get_send_typed_timeout); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__IM_get_send_typed_timeout)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "im");

    {

        Purple__Conversation__IM        im = purple_perl_ref_object(ST(0))

;

        guint        RETVAL;

        dXSTARG;

        RETVAL = purple_conv_im_get_send_typed_timeout(im);

        XSprePUSH; PUSHi((IV)RETVAL);

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation__IM_update_typing); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__IM_update_typing)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "im");

    {

        Purple__Conversation__IM        im = purple_perl_ref_object(ST(0))

;

        purple_conv_im_update_typing(im);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation__IM_send); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__IM_send)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "im, message");

    {

        Purple__Conversation__IM        im = purple_perl_ref_object(ST(0))

;

        const char *        message = (const char *)SvPV_nolen(ST(1))

;

        purple_conv_im_send(im, message);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation__IM_send_with_flags); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__IM_send_with_flags)

{

    dVAR; dXSARGS;

    if (items != 3)

       croak_xs_usage(cv,  "im, message, flags");

    {

        Purple__Conversation__IM        im = purple_perl_ref_object(ST(0))

;

        const char *        message = (const char *)SvPV_nolen(ST(1))

;

        Purple__MessageFlags        flags = (Purple__MessageFlags)SvIV(ST(2))

;

        purple_conv_im_send_with_flags(im, message, flags);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation__IM_write); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__IM_write)

{

    dVAR; dXSARGS;

    if (items != 5)

       croak_xs_usage(cv,  "im, who, message, flags, mtime");

    {

        Purple__Conversation__IM        im = purple_perl_ref_object(ST(0))

;

        const char *        who = (const char *)SvPV_nolen(ST(1))

;

        const char *        message = (const char *)SvPV_nolen(ST(2))

;

        Purple__MessageFlags        flags = (Purple__MessageFlags)SvIV(ST(3))

;

        time_t        mtime = (time_t)SvIV(ST(4))

;

        purple_conv_im_write(im, who, message, flags, mtime);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation_present_error); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_present_error)

{

    dVAR; dXSARGS;

    if (items != 3)

       croak_xs_usage(cv,  "who, account, what");

    {

        const char *        who = (const char *)SvPV_nolen(ST(0))

;

        Purple__Account        account = purple_perl_ref_object(ST(1))

;

        const char *        what = (const char *)SvPV_nolen(ST(2))

;

        gboolean        RETVAL;

        RETVAL = purple_conv_present_error(who, account, what);

        ST(0) = sv_newmortal();

        ST(0) = boolSV(RETVAL);

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation_custom_smiley_close); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation_custom_smiley_close)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "conv, smile");

    {

        Purple__Conversation        conv = purple_perl_ref_object(ST(0))

;

        const char *        smile = (const char *)SvPV_nolen(ST(1))

;

        purple_conv_custom_smiley_close(conv, smile);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation__Chat_get_conversation); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__Chat_get_conversation)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "chat");

    {

        Purple__Conversation__Chat        chat = purple_perl_ref_object(ST(0))

;

        Purple__Conversation        RETVAL;

        RETVAL = purple_conv_chat_get_conversation(chat);

        ST(0) = purple_perl_bless_object(RETVAL, "Purple::Conversation");

        sv_2mortal(ST(0));

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation__Chat_set_users); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__Chat_set_users)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "chat, users");

    PERL_UNUSED_VAR(ax); /* -Wall */

    SP -= items;

    {

        Purple__Conversation__Chat        chat = purple_perl_ref_object(ST(0))

;

        SV *        users = ST(1)

;

#line 345 "Conversation.xs"

        GList *l, *t_GL;

        int i, t_len;

#line 1059 "Conversation.c"

#line 348 "Conversation.xs"

        t_GL = NULL;

        t_len = av_len((AV *)SvRV(users));

        for (i = 0; i <= t_len; i++)

                t_GL = g_list_append(t_GL, SvPVutf8_nolen(*av_fetch((AV *)SvRV(users), i, 0)));

        for (l = purple_conv_chat_set_users(chat, t_GL); l != NULL; l = l->next) {

                XPUSHs(sv_2mortal(purple_perl_bless_object(l->data, "Purple::ListEntry")));

        }

#line 1070 "Conversation.c"

        PUTBACK;

        return;

    }

}

XS_EUPXS(XS_Purple__Conversation__Chat_get_users); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__Chat_get_users)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "chat");

    PERL_UNUSED_VAR(ax); /* -Wall */

    SP -= items;

    {

        Purple__Conversation__Chat        chat = purple_perl_ref_object(ST(0))

;

#line 362 "Conversation.xs"

        GList *l;

#line 1090 "Conversation.c"

#line 364 "Conversation.xs"

        for (l = purple_conv_chat_get_users(chat); l != NULL; l = l->next) {

                XPUSHs(sv_2mortal(purple_perl_bless_object(l->data, "Purple::ListEntry")));

        }

#line 1095 "Conversation.c"

        PUTBACK;

        return;

    }

}

XS_EUPXS(XS_Purple__Conversation__Chat_ignore); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__Chat_ignore)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "chat, name");

    {

        Purple__Conversation__Chat        chat = purple_perl_ref_object(ST(0))

;

        const char *        name = (const char *)SvPV_nolen(ST(1))

;

        purple_conv_chat_ignore(chat, name);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation__Chat_unignore); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__Chat_unignore)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "chat, name");

    {

        Purple__Conversation__Chat        chat = purple_perl_ref_object(ST(0))

;

        const char *        name = (const char *)SvPV_nolen(ST(1))

;

        purple_conv_chat_unignore(chat, name);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation__Chat_set_ignored); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__Chat_set_ignored)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "chat, ignored");

    PERL_UNUSED_VAR(ax); /* -Wall */

    SP -= items;

    {

        Purple__Conversation__Chat        chat = purple_perl_ref_object(ST(0))

;

        SV *        ignored = ST(1)

;

#line 383 "Conversation.xs"

        GList *l, *t_GL;

        int i, t_len;

#line 1154 "Conversation.c"

#line 386 "Conversation.xs"

        t_GL = NULL;

        t_len = av_len((AV *)SvRV(ignored));

        for (i = 0; i <= t_len; i++)

                t_GL = g_list_append(t_GL, SvPVutf8_nolen(*av_fetch((AV *)SvRV(ignored), i, 0)));

        for (l = purple_conv_chat_set_ignored(chat, t_GL); l != NULL; l = l->next) {

                XPUSHs(sv_2mortal(purple_perl_bless_object(l->data, "Purple::ListEntry")));

        }

#line 1165 "Conversation.c"

        PUTBACK;

        return;

    }

}

XS_EUPXS(XS_Purple__Conversation__Chat_get_ignored); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__Chat_get_ignored)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "chat");

    PERL_UNUSED_VAR(ax); /* -Wall */

    SP -= items;

    {

        Purple__Conversation__Chat        chat = purple_perl_ref_object(ST(0))

;

#line 400 "Conversation.xs"

        GList *l;

#line 1185 "Conversation.c"

#line 402 "Conversation.xs"

        for (l = purple_conv_chat_get_ignored(chat); l != NULL; l = l->next) {

                XPUSHs(sv_2mortal(purple_perl_bless_object(l->data, "Purple::ListEntry")));

        }

#line 1190 "Conversation.c"

        PUTBACK;

        return;

    }

}

XS_EUPXS(XS_Purple__Conversation__Chat_get_topic); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__Chat_get_topic)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "chat");

    {

        Purple__Conversation__Chat        chat = purple_perl_ref_object(ST(0))

;

        const char *        RETVAL;

        dXSTARG;

        RETVAL = purple_conv_chat_get_topic(chat);

        sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation__Chat_set_id); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__Chat_set_id)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "chat, id");

    {

        Purple__Conversation__Chat        chat = purple_perl_ref_object(ST(0))

;

        int        id = (int)SvIV(ST(1))

;

        purple_conv_chat_set_id(chat, id);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation__Chat_get_id); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__Chat_get_id)

{

    dVAR; dXSARGS;

    if (items != 1)

       croak_xs_usage(cv,  "chat");

    {

        Purple__Conversation__Chat        chat = purple_perl_ref_object(ST(0))

;

        int        RETVAL;

        dXSTARG;

        RETVAL = purple_conv_chat_get_id(chat);

        XSprePUSH; PUSHi((IV)RETVAL);

    }

    XSRETURN(1);

}

XS_EUPXS(XS_Purple__Conversation__Chat_send); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__Chat_send)

{

    dVAR; dXSARGS;

    if (items != 2)

       croak_xs_usage(cv,  "chat, message");

    {

        Purple__Conversation__Chat        chat = purple_perl_ref_object(ST(0))

;

        const char *        message = (const char *)SvPV_nolen(ST(1))

;

        purple_conv_chat_send(chat, message);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation__Chat_send_with_flags); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__Chat_send_with_flags)

{

    dVAR; dXSARGS;

    if (items != 3)

       croak_xs_usage(cv,  "chat, message, flags");

    {

        Purple__Conversation__Chat        chat = purple_perl_ref_object(ST(0))

;

        const char *        message = (const char *)SvPV_nolen(ST(1))

;

        Purple__MessageFlags        flags = (Purple__MessageFlags)SvIV(ST(2))

;

        purple_conv_chat_send_with_flags(chat, message, flags);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation__Chat_write); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__Chat_write)

{

    dVAR; dXSARGS;

    if (items != 5)

       croak_xs_usage(cv,  "chat, who, message, flags, mtime");

    {

        Purple__Conversation__Chat        chat = purple_perl_ref_object(ST(0))

;

        const char *        who = (const char *)SvPV_nolen(ST(1))

;

        const char *        message = (const char *)SvPV_nolen(ST(2))

;

        Purple__MessageFlags        flags = (Purple__MessageFlags)SvIV(ST(3))

;

        time_t        mtime = (time_t)SvIV(ST(4))

;

        purple_conv_chat_write(chat, who, message, flags, mtime);

    }

    XSRETURN_EMPTY;

}

XS_EUPXS(XS_Purple__Conversation__Chat_add_users); /* prototype to pass -Wmissing-prototypes */

XS_EUPXS(XS_Purple__Conversation__Chat_add_users)

{

    dVAR; dXSARGS;

    if (items != 5)

       croak_xs_usage(cv,  "chat, users, extra_msgs, flags, new_arrivals");

    PERL_UNUSED_VAR(ax); /* -Wall */

    SP -= items;

    {

        Purple__Conversation__Chat        chat = purple_perl_ref_object(ST(0))

;

        SV *        users = ST(1)

;

        SV *        extra_msgs = ST(2)

;

        SV *        flags = ST(3)

;

        gboolean        new_arrivals = (bool)SvTRUE(ST(4))

;

#line 446 "Conversation.xs"

        GList *t_GL_users, *t_GL_extra_msgs, *t_GL_flags;

        int i, t_len;

#line 1337 "Conversation.c"

#line 449 "Conversation.xs"

        t_GL_users = NULL;

        t_len = av_len((AV *)SvRV(users));

        for (i = 0; i <= t_len; i++)

                t_GL_users = g_list_append(t_GL_users, SvPVutf8_nolen(*av_fetch((AV *)SvRV(users), i, 0)));

        t_GL_flags = NULL;

        t_len = av_len((AV *)SvRV(flags));

        for (i = 0; i <= t_len; i++)

                t_GL_flags = g_list_append(t_GL_flags, SvPVutf8_nolen(*av_fetch((AV *)SvRV(flags), i, 0)));

        t_GL_extra_msgs = NULL;

        t_len = av_len((AV *)SvRV(extra_msgs));