File Coverage

XS.c

Criterion	Covered	Total	%
statement	627	768	81.6
branch	264	552	47.8
condition			n/a
subroutine			n/a
pod			n/a
total	891	1320	67.5

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

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

#include "ppport.h"

#include <stdlib.h>
#include <stdint.h>
#include <inttypes.h>

#include "xs_object_magic.h"
#include "common.h"
#include "buffer.c"
#include "memory_buffer.h"
#include "binary_protocol.h"

// Include the XS::Object::Magic code inline to simplify things
#include "Magic.c"

/* Detect Endianness using Perl's configuration */
#undef __LITTLE_ENDIAN
#undef __BIG_ENDIAN
#undef __BYTE_ORDER

#define __LITTLE_ENDIAN 1234
#define __BIG_ENDIAN    4321

#ifdef BYTEORDER
#  if (BYTEORDER == 0x1234 || BYTEORDER == 0x12345678)
#    define __BYTE_ORDER __LITTLE_ENDIAN
#  elif (BYTEORDER == 0x4321 || BYTEORDER == 0x87654321)
#    define __BYTE_ORDER __BIG_ENDIAN
#  endif
#endif

/* Fallback for common platforms if BYTEORDER is missing */
#ifndef __BYTE_ORDER
#  if defined(_WIN32) || defined(__i386__) || defined(__x86_64__) || defined(__alpha__)
#    define __BYTE_ORDER __LITTLE_ENDIAN
#  else
#    error "Cannot determine endianness. Please check your Perl configuration."
#  endif
#endif

/* Define a high-performance 64-bit byte swapper */
#ifndef bswap_64
#  if defined(_MSC_VER)
#    include <stdlib.h>
#    define bswap_64(n) _byteswap_uint64(n)
#  elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
#    define bswap_64(n) __builtin_bswap64(n)
#  else
#    define bswap_64(n) \
            ( (((n) & 0xff00000000000000ull) >> 56) \
            | (((n) & 0x00ff000000000000ull) >> 40) \
            | (((n) & 0x0000ff0000000000ull) >> 24) \
            | (((n) & 0x000000ff00000000ull) >> 8)  \
            | (((n) & 0x00000000ff000000ull) << 8)  \
            | (((n) & 0x0000000000ff0000ull) << 24) \
            | (((n) & 0x000000000000ff00ull) << 40) \
            | (((n) & 0x00000000000000ffull) << 56) )
#  endif
#endif

/* Define Host/Network macros */
#if __BYTE_ORDER == __BIG_ENDIAN
#  define ntohll(n)  (n)
#  define htonll(n)  (n)
#  define htolell(n) bswap_64(n)
#  define letohll(n) bswap_64(n)
#else
#  define ntohll(n)  bswap_64(n)
#  define htonll(n)  bswap_64(n)
#  define htolell(n) (n)
#  define letohll(n) (n)
#endif

#line 88 "XS.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(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

/* simple backcompat versions of the TARGx() macros with no optimisation */
#ifndef TARGi
#  define TARGi(iv, do_taint) sv_setiv_mg(TARG, iv)
#  define TARGu(uv, do_taint) sv_setuv_mg(TARG, uv)
#  define TARGn(nv, do_taint) sv_setnv_mg(TARG, nv)
#endif

#line 239 "XS.c"

/* INCLUDE:  Including 'MemoryBuffer.xs' from 'XS.xs' */


/* INCLUDE:  Including 'BinaryProtocol.xs' from 'MemoryBuffer.xs' */


/* INCLUDE:  Including 'CompactProtocol.xs' from 'BinaryProtocol.xs' */


XS_EUPXS(XS_Thrift__XS__CompactProtocol_resetState); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_resetState)
{
        dVAR; dXSARGS;
        if (items != 1)
              croak_xs_usage(cv,  "p");
        {
		TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
#line 9 "./CompactProtocol.xs"
{
    DEBUG_TRACE("resetState()\n");

    p->bool_type     = -1;
    p->bool_id       = -1;
    p->bool_value_id = -1;
    p->last_field_id = 0;

    // clear field queue
    struct field_entry *entry;
    while (!SIMPLEQ_EMPTY(p->last_fields)) {
        entry = SIMPLEQ_FIRST(p->last_fields);
        SIMPLEQ_REMOVE_HEAD(p->last_fields, entries);
        MEM_TRACE("free entry @ %p\n", entry);
        Safefree(entry);
    }
}
#line 277 "XS.c"
        }
        XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeMessageBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeMessageBegin)
{
        dVAR; dXSARGS;
        if (items != 4)
              croak_xs_usage(cv,  "p, name, type, seqid");
        {
		TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
		SV *	name = ST(1)
;
		int	type = (int)SvIV(ST(2))
;
		uint32_t	seqid = (uint32_t)SvUV(ST(3))
;
#line 30 "./CompactProtocol.xs"
{
    DEBUG_TRACE("writeMessageBegin()\n");

    SV *namecopy = sv_mortalcopy(name); // because we can't modify the original name
  sv_utf8_encode(namecopy);
  uint32_t namelen = sv_len(namecopy);
  SV *data = sv_2mortal(newSV(16 + namelen));
  char tmp[5]; // 5 required for varint32

  // byte protocol ID
  tmp[0] = PROTOCOL_ID;

  // byte version/type
  tmp[1] = (VERSION_N & VERSION_MASK_COMPACT) | ((type << TYPE_SHIFT_AMOUNT) & TYPE_MASK);

  sv_setpvn(data, tmp, 2);

  // varint32 seqid
  int varlen;
  UINT_TO_VARINT(varlen, tmp, seqid, 0);
  sv_catpvn(data, tmp, varlen);

  // varint32 len + string
  UINT_TO_VARINT(varlen, tmp, namelen, 0);
  sv_catpvn(data, tmp, varlen);
  sv_catsv(data, namecopy);

  WRITE_SV(p, data);
}
#line 328 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeStructBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeStructBegin)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, SV *");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
#line 65 "./CompactProtocol.xs"
{
  DEBUG_TRACE("writeStructBegin()\n");

  // No writing here, but we push last_field_id onto the fields stack
  // and reset last_field_id to 0
  struct field_entry *entry;
  New(0, entry, sizeof(struct field_entry), struct field_entry);
  MEM_TRACE("New entry @ %p\n", entry);
  entry->field_id = p->last_field_id;
  SIMPLEQ_INSERT_HEAD(p->last_fields, entry, entries);

  DEBUG_TRACE("writeStructBegin(), insert_head %d\n", entry->field_id);

  p->last_field_id = 0;
}
#line 359 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeStructEnd); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeStructEnd)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "p");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
#line 84 "./CompactProtocol.xs"
{
  DEBUG_TRACE("writeStructEnd()\n");

  // pop last field off the stack and save it in
  // last_field_id
  struct field_entry *entry = SIMPLEQ_FIRST(p->last_fields);
  p->last_field_id = entry->field_id;
  SIMPLEQ_REMOVE_HEAD(p->last_fields, entries);

  DEBUG_TRACE("writeStructEnd(), remove_head %d\n", entry->field_id);

  MEM_TRACE("free entry @ %p\n", entry);
  Safefree(entry);
}
#line 389 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeFieldBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeFieldBegin)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "p, name, type, id");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	name = ST(1)
;
	int	type = (int)SvIV(ST(2))
;
	int	id = (int)SvIV(ST(3))
;
#line 102 "./CompactProtocol.xs"
{
  DEBUG_TRACE("writeFieldBegin()\n");

  PERL_UNUSED_VAR(name);
  if (unlikely(type == T_BOOL)) {
    // Special case, save type/id for use later
    p->bool_type = type;
    p->bool_id = id;
  }
  else {
    write_field_begin_internal(p, type, id, -1);
  }
}
#line 424 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeMapBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeMapBegin)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "p, keytype, valtype, size");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	int	keytype = (int)SvIV(ST(1))
;
	int	valtype = (int)SvIV(ST(2))
;
	uint32_t	size = (uint32_t)SvUV(ST(3))
;
#line 123 "./CompactProtocol.xs"
{
  DEBUG_TRACE("writeMapBegin()\n");

  char data[6];

  if (size == 0) {
    data[0] = 0;
    WRITE(p, data, 1);
  }
  else {
    int varlen;
    UINT_TO_VARINT(varlen, data, size, 0);
    data[varlen] = (get_compact_type(keytype) << 4) | get_compact_type(valtype);
    WRITE(p, data, varlen + 1);
  }
}
#line 462 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeListBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeListBegin)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p, elemtype, size");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	int	elemtype = (int)SvIV(ST(1))
;
	int	size = (int)SvIV(ST(2))
;
#line 145 "./CompactProtocol.xs"
{
  DEBUG_TRACE("writeListBegin()\n");

  write_collection_begin_internal(p, elemtype, size);
}
#line 487 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeSetBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeSetBegin)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p, elemtype, size");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	int	elemtype = (int)SvIV(ST(1))
;
	int	size = (int)SvIV(ST(2))
;
#line 156 "./CompactProtocol.xs"
{
  DEBUG_TRACE("writeSetBegin()\n");

  write_collection_begin_internal(p, elemtype, size);
}
#line 512 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeBool); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeBool)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 167 "./CompactProtocol.xs"
{
  DEBUG_TRACE("writeBool()\n");

  if (unlikely(p->bool_type != -1)) {
    // we haven't written the field header yet
    write_field_begin_internal(p, p->bool_type, p->bool_id, SvTRUE(value) ? CTYPE_BOOLEAN_TRUE: CTYPE_BOOLEAN_FALSE);
    p->bool_type = -1;
    p->bool_id = -1;
  }
  else {
    // we're not part of a field, so just write the value.
    char data[1];
    data[0] = SvTRUE(value) ? 1 : 0;

    WRITE(p, data, 1);
  }
}
#line 547 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeI16); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeI16)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	int	value = (int)SvIV(ST(1))
;
#line 190 "./CompactProtocol.xs"
{
  DEBUG_TRACE("writeI16()\n");

  char data[3];
  int varlen;

  uint32_t uvalue = int_to_zigzag(value);
  UINT_TO_VARINT(varlen, data, uvalue, 0);
  WRITE(p, data, varlen);
}
#line 575 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeI32); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeI32)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	int	value = (int)SvIV(ST(1))
;
#line 204 "./CompactProtocol.xs"
{
  DEBUG_TRACE("writeI32()\n");

  char data[5];
  int varlen;

  uint32_t uvalue = int_to_zigzag(value);
  UINT_TO_VARINT(varlen, data, uvalue, 0);
  WRITE(p, data, varlen);
}
#line 603 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeI64); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeI64)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 218 "./CompactProtocol.xs"
{
  char data[10];
  int varlen = 0;

  // Stringify the value, then convert to an int64_t
  const char *str = SvPOK(value) ? SvPVX(value) : SvPV_nolen(value);
  int64_t i64 = (int64_t)strtoll(str, NULL, 10);

  DEBUG_TRACE("writeI64(%" PRId64 ")\n", i64);

  uint64_t uvalue = ll_to_zigzag(i64);
  UINT_TO_VARINT(varlen, data, uvalue, 0);
  WRITE(p, data, varlen);
}
#line 635 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeDouble); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeDouble)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 236 "./CompactProtocol.xs"
{
  DEBUG_TRACE("writeDouble()\n");

  char data[8];
  union {
    double d;
    int64_t i;
  } u;

  u.d = (double)SvNV(value);

  data[0] = u.i & 0xff;
  data[1] = (u.i >> 8) & 0xff;
  data[2] = (u.i >> 16) & 0xff;
  data[3] = (u.i >> 24) & 0xff;
  data[4] = (u.i >> 32) & 0xff;
  data[5] = (u.i >> 40) & 0xff;
  data[6] = (u.i >> 48) & 0xff;
  data[7] = (u.i >> 56) & 0xff;

  WRITE(p, data, 8);
}
#line 675 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeString); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_writeString)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 262 "./CompactProtocol.xs"
{
  DEBUG_TRACE("writeString()\n");

  SV *valuecopy = sv_mortalcopy(value);
  if (SvUTF8(value) != 0) {
    sv_utf8_encode(valuecopy);
  }
  int len = sv_len(valuecopy);
  SV *data = sv_2mortal(newSV(5 + len));
  char tmp[5];

  int varlen;
  UINT_TO_VARINT(varlen, tmp, len, 0);
  sv_setpvn(data, tmp, varlen);
  sv_catsv(data, valuecopy);

  WRITE_SV(p, data);
}
#line 711 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_readMessageBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_readMessageBegin)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "p, name, type, seqid");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	name = ST(1)
;
	SV *	type = ST(2)
;
	SV *	seqid = ST(3)
;
#line 284 "./CompactProtocol.xs"
{
  DEBUG_TRACE("readMessageBegin()\n");

  SV *tmp;
  char *tmps;
  uint32_t tmpui;

  // read protocol id, version, type
  READ_SV(p, tmp, 2);
  tmps = SvPVX(tmp);

  uint8_t protocol_id = (uint8_t) tmps[0];
  if (protocol_id != (uint8_t) PROTOCOL_ID) {
    THROW_SV("Thrift::TException", newSVpvf("Expected protocol id %d but got %d", PROTOCOL_ID, protocol_id));
  }

  uint8_t version_and_type = (uint8_t) tmps[1];
  uint8_t version = version_and_type & VERSION_MASK_COMPACT;
  if (version != VERSION_N) {
    THROW_SV("Thrift::TException", newSVpvf("Expected version id %d but got %d", VERSION_N, version));
  }

  // set type
  if (SvROK(type))
    sv_setiv(SvRV(type), (version_and_type >> TYPE_SHIFT_AMOUNT) & 0x03);

  // read/set seqid
    READ_VARINT(p, tmpui);
    if (SvROK(seqid))
        sv_setiv(SvRV(seqid), tmpui);

    // read/set name
    READ_VARINT(p, tmpui);
    if (tmpui) {
        READ_SV(p, tmp, tmpui);
        sv_utf8_decode(tmp);
        if (SvROK(name))
            sv_setsv(SvRV(name), tmp);
    }
    else {
        if (SvROK(name))
            sv_setpv(SvRV(name), "");
    }
}
#line 777 "XS.c"
        }
        XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_readStructBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_readStructBegin)
{
        dVAR; dXSARGS;
        if (items != 2)
              croak_xs_usage(cv,  "p, name");
        {
		TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
		SV *	name = ST(1)
;
#line 334 "./CompactProtocol.xs"
{
    DEBUG_TRACE("readStructBegin()\n");

    // No reading here, but we push last_field_id onto the fields stack
    struct field_entry *entry;
    New(0, entry, sizeof(struct field_entry), struct field_entry);
    MEM_TRACE("New entry @ %p\n", entry);
    entry->field_id = p->last_field_id;
    SIMPLEQ_INSERT_HEAD(p->last_fields, entry, entries);

    p->last_field_id = 0;

    if (SvROK(name))
        sv_setpv(SvRV(name), "");
}
#line 810 "XS.c"
        }
        XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_readStructEnd); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_readStructEnd)
{
        dVAR; dXSARGS;
        if (items != 1)
              croak_xs_usage(cv,  "p");
        {
		TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
#line 353 "./CompactProtocol.xs"
{
    DEBUG_TRACE("readStructEnd()\n");

    // pop last field off the stack
  struct field_entry *entry = SIMPLEQ_FIRST(p->last_fields);
  SIMPLEQ_REMOVE_HEAD(p->last_fields, entries);
  p->last_field_id = entry->field_id;

  MEM_TRACE("free entry @ %p\n", entry);
  Safefree(entry);
}
#line 837 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_readFieldBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_readFieldBegin)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "p, name, fieldtype, fieldid");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	name = ST(1)
;
	SV *	fieldtype = ST(2)
;
	SV *	fieldid = ST(3)
;
#line 368 "./CompactProtocol.xs"
{
  DEBUG_TRACE("readFieldBegin()\n");

  SV *tmp;
  char *tmps;

  PERL_UNUSED_VAR(name);
  // fieldtype byte
  READ_SV(p, tmp, 1);
  tmps = SvPVX(tmp);
  int type = tmps[0];

  if (SvROK(fieldtype))
    sv_setiv(SvRV(fieldtype), get_ttype(type & 0x0f));

  if (type == T_STOP) {
    if (SvROK(fieldid))
      sv_setiv(SvRV(fieldid), 0);
    XSRETURN_EMPTY;
  }

  // fieldid i16 varint
  int fid;

  // mask off the 4 MSB of the type header. it could contain a field id delta.
  uint8_t modifier = ((type & 0xf0) >> 4);
  if (modifier == 0) {
    // pop field
    struct field_entry *entry = SIMPLEQ_FIRST(p->last_fields);
    SIMPLEQ_REMOVE_HEAD(p->last_fields, entries);
    MEM_TRACE("free entry @ %p\n", entry);
    Safefree(entry);

    // not a delta. look ahead for the zigzag varint field id.
    READ_VARINT(p, fid);
    fid = zigzag_to_int(fid);
  }
  else {
    // has a delta. add the delta to the last read field id.
    // pop field
    struct field_entry *entry = SIMPLEQ_FIRST(p->last_fields);
    SIMPLEQ_REMOVE_HEAD(p->last_fields, entries);
    int last = entry->field_id;
    MEM_TRACE("free entry @ %p\n", entry);
    Safefree(entry);

    fid = last + modifier;
  }

  // if this happens to be a boolean field, the value is encoded in the type
  if (is_bool_type(type)) {
    // save the boolean value in a special instance variable.
    p->bool_value_id = (type & 0x0f) == CTYPE_BOOLEAN_TRUE ? 1 : 0;
  }

  // push the new field onto the field stack so we can keep the deltas going.
  struct field_entry *entry;
  New(0, entry, sizeof(struct field_entry), struct field_entry);
  MEM_TRACE("New entry @ %p\n", entry);
  entry->field_id = fid;
  SIMPLEQ_INSERT_HEAD(p->last_fields, entry, entries);

  if (SvROK(fieldid))
    sv_setiv(SvRV(fieldid), fid);
}
#line 924 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_readMapBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_readMapBegin)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "p, keytype, valtype, size");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	keytype = ST(1)
;
	SV *	valtype = ST(2)
;
	SV *	size = ST(3)
;
#line 439 "./CompactProtocol.xs"
{
  DEBUG_TRACE("readMapBegin()\n");

  SV *tmp;
  char *tmps;

  // size
  uint32_t isize;
  READ_VARINT(p, isize);
  if (SvROK(size))
    sv_setiv(SvRV(size), isize);

  // key and value type
  READ_SV(p, tmp, 1);
  tmps = SvPVX(tmp);

  // keytype byte
  if (SvROK(keytype))
    sv_setiv(SvRV(keytype), get_ttype((tmps[0] >> 4) & 0xf));

  // valtype byte
  if (SvROK(valtype))
    sv_setiv(SvRV(valtype), get_ttype(tmps[0] & 0xf));
}
#line 970 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_readListBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_readListBegin)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p, elemtype, size");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	elemtype = ST(1)
;
	SV *	size = ST(2)
;
#line 469 "./CompactProtocol.xs"
{
  DEBUG_TRACE("readListBegin()\n");

  SV *tmp;
  char *tmps;

  // size and type may be in the same byte
  READ_SV(p, tmp, 1);
  tmps = SvPVX(tmp);
  int isize = (tmps[0] >> 4) & 0x0f;
  if (isize == 15) {
    // size is in a varint
    READ_VARINT(p, isize);
  }
  int type = get_ttype(tmps[0] & 0x0f);

  // elemtype byte
  if (SvROK(elemtype))
    sv_setiv(SvRV(elemtype), type);

  // size
  if (SvROK(size))
    sv_setiv(SvRV(size), isize);
}
#line 1014 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_readSetBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_readSetBegin)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p, elemtype, size");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	elemtype = ST(1)
;
	SV *	size = ST(2)
;
#line 499 "./CompactProtocol.xs"
{
  DEBUG_TRACE("readSetBegin()\n");

  SV *tmp;
  char *tmps;

  // size and type may be in the same byte
  READ_SV(p, tmp, 1);
  tmps = SvPVX(tmp);
  int isize = (tmps[0] >> 4) & 0x0f;
  if (isize == 15) {
    // size is in a varint
    READ_VARINT(p, isize);
  }
  int type = get_ttype(tmps[0] & 0x0f);

  // elemtype byte
  if (SvROK(elemtype))
    sv_setiv(SvRV(elemtype), type);

  // size
  if (SvROK(size))
    sv_setiv(SvRV(size), isize);
}
#line 1058 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_readBool); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_readBool)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 529 "./CompactProtocol.xs"
{
  DEBUG_TRACE("readBool()\n");

  SV *tmp;
  char *tmps;

  // Check for bool_value encoded in the fieldBegin type
  if (p->bool_value_id != -1) {
    if (SvROK(value))
      sv_setiv(SvRV(value), p->bool_value_id);
    p->bool_value_id = -1;
  }
  else {
    READ_SV(p, tmp, 1);
    tmps = SvPVX(tmp);

    if (SvROK(value))
      sv_setiv(SvRV(value), tmps[0] ? 1 : 0);
  }
}
#line 1096 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_readI16); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_readI16)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 555 "./CompactProtocol.xs"
{
  DEBUG_TRACE("readI16()\n");

  uint32_t varint;
  READ_VARINT(p, varint);

  if (SvROK(value))
    sv_setiv(SvRV(value), zigzag_to_int(varint));
}
#line 1123 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_readI32); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_readI32)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 568 "./CompactProtocol.xs"
{
  DEBUG_TRACE("readI32()\n");

  uint32_t varint;
  READ_VARINT(p, varint);

  if (SvROK(value))
    sv_setiv(SvRV(value), zigzag_to_int(varint));
}
#line 1150 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_readI64); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_readI64)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 581 "./CompactProtocol.xs"
{
  uint64_t varint;
  READ_VARINT(p, varint);

  DEBUG_TRACE("readI64(%" PRId64 ") (from varint %" PRIu64 ")\n", zigzag_to_ll(varint), varint);

  // Store as a string so it works on 32-bit platforms
  if (SvROK(value)) {
    char string[25];
    STRLEN length;
    length = sprintf(string, "%" PRId64, zigzag_to_ll(varint));
    sv_setpvn(SvRV(value), string, length);
  }
}
#line 1182 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_readDouble); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_readDouble)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 599 "./CompactProtocol.xs"
{
  DEBUG_TRACE("readDouble()\n");

  SV *tmp;
  char *tmps;

  READ_SV(p, tmp, 8);
  tmps = SvPVX(tmp);

  uint32_t lo = (uint8_t)tmps[0] |
    ((uint8_t)tmps[1] << 8) |
    ((uint8_t)tmps[2] << 16) |
    ((uint8_t)tmps[3] << 24);
  uint64_t hi = (uint8_t)tmps[4] |
    ((uint8_t)tmps[5] << 8) |
    ((uint8_t)tmps[6] << 16) |
    ((uint8_t)tmps[7] << 24);

  union {
    double d;
    int64_t i;
  } u;
  u.i = (hi << 32) | lo;

  if (SvROK(value))
    sv_setnv(SvRV(value), u.d);
}
#line 1227 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__CompactProtocol_readString); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__CompactProtocol_readString)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 630 "./CompactProtocol.xs"
{
  DEBUG_TRACE("readString()\n");

  SV *tmp;

  uint64_t len;
  READ_VARINT(p, len);
  if (len) {
    READ_SV(p, tmp, len);
    sv_utf8_decode(tmp);
    if (SvROK(value))
      sv_setsv(SvRV(value), tmp);
  }
  else {
    if (SvROK(value))
      sv_setpv(SvRV(value), "");
  }
}
#line 1263 "XS.c"
    }
    XSRETURN_EMPTY;
}


/* INCLUDE: Returning to 'BinaryProtocol.xs' from 'CompactProtocol.xs' */


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_new)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "klass, transport");
    {
	SV *	RETVAL;
	char *	klass = (char *)SvPV_nolen(ST(0))
;
	SV *	transport = ST(1)
;
#line 6 "./BinaryProtocol.xs"
{
  TBinaryProtocol *p;
  New(0, p, sizeof(TBinaryProtocol), TBinaryProtocol);
  New(0, p->last_fields, sizeof(struct fieldq), struct fieldq);

  MEM_TRACE("new()\n");
  MEM_TRACE("  New p @ %p\n", p);
  MEM_TRACE("  New last_fields @ %p\n", p->last_fields);

  if (sv_isa(transport, "Thrift::XS::MemoryBuffer"))
    p->mbuf = (TMemoryBuffer *)xs_object_magic_get_struct_rv_pretty(aTHX_ transport, "mbuf");
  else
    p->mbuf = NULL;

  p->transport = transport;

  p->bool_type     = -1;
  p->bool_id       = -1;
  p->bool_value_id = -1;
  p->last_field_id = 0;

  SIMPLEQ_INIT(p->last_fields);

  RETVAL = xs_object_magic_create(
    aTHX_
    (void *)p,
    gv_stashpv(klass, 0)
  );
}
#line 1314 "XS.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_DESTROY); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_DESTROY)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "p");
    {
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
#line 41 "./BinaryProtocol.xs"
{
  MEM_TRACE("DESTROY()\n");

  // clear field queue
  struct field_entry *entry;
  while (!SIMPLEQ_EMPTY(p->last_fields)) {
    entry = SIMPLEQ_FIRST(p->last_fields);
    SIMPLEQ_REMOVE_HEAD(p->last_fields, entries);
    MEM_TRACE("  free entry @ %p\n", entry);
    Safefree(entry);
  }

  MEM_TRACE("  free last_fields @ %p\n", p->last_fields);
  Safefree(p->last_fields);
  MEM_TRACE("  free p @ %p\n", p);
  Safefree(p);
}
#line 1349 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_getTransport); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_getTransport)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "p");
    {
	SV *	RETVAL;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
#line 62 "./BinaryProtocol.xs"
{
  SvREFCNT_inc(p->transport);
  RETVAL = p->transport;
}
#line 1370 "XS.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeMessageBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeMessageBegin)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "p, name, type, seqid");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	name = ST(1)
;
	int	type = (int)SvIV(ST(2))
;
	int	seqid = (int)SvIV(ST(3))
;
#line 72 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("writeMessageBegin()\n");
  RETVAL = 0;

  SV *namecopy = sv_mortalcopy(name); // because we can't modify the original name
  sv_utf8_encode(namecopy);
  int namelen = sv_len(namecopy);
  SV *data = sv_2mortal(newSV(8 + 4+namelen));
  char i32[4];

  // i32 type
  type = VERSION_1 | type;
  INT_TO_I32(i32, type, 0);
  sv_setpvn(data, i32, 4);
  RETVAL += 4;

  // i32 len + string
  INT_TO_I32(i32, namelen, 0);
  sv_catpvn(data, i32, 4);
  sv_catsv(data, namecopy);
  RETVAL += 4 + namelen;

  // i32 seqid
  INT_TO_I32(i32, seqid, 0);
  sv_catpvn(data, i32, 4);
  RETVAL += 4;

  WRITE_SV(p, data);
}
#line 1425 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeMessageEnd); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeMessageEnd)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV *");
    {
	int	RETVAL;
	dXSTARG;
#line 107 "./BinaryProtocol.xs"
{
  RETVAL = 0;
}
#line 1446 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeStructBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeStructBegin)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "SV *, SV *");
    {
	int	RETVAL;
	dXSTARG;
#line 116 "./BinaryProtocol.xs"
{
  RETVAL = 0;
}
#line 1467 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeStructEnd); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeStructEnd)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV *");
    {
	int	RETVAL;
	dXSTARG;
#line 125 "./BinaryProtocol.xs"
{
  RETVAL = 0;
}
#line 1488 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeFieldBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeFieldBegin)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "p, name, type, id");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	name = ST(1)
;
	int	type = (int)SvIV(ST(2))
;
	int	id = (int)SvIV(ST(3))
;
#line 134 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("writeFieldBegin(type %d, id %d)\n", type, id);
  char data[3];
  RETVAL = 0;

  PERL_UNUSED_VAR(name);
  data[0] = type & 0xff;      // byte
  data[1] = (id >> 8) & 0xff; // i16
  data[2] = id & 0xff;

  WRITE(p, data, 3);
  RETVAL += 3;
}
#line 1527 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeFieldEnd); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeFieldEnd)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV *");
    {
	int	RETVAL;
	dXSTARG;
#line 153 "./BinaryProtocol.xs"
{
  RETVAL = 0;
}
#line 1548 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeFieldStop); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeFieldStop)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "p");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
#line 162 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("writeFieldStop()\n");
  RETVAL = 0;

  char data[1];
  data[0] = T_STOP;

  WRITE(p, data, 1);
  RETVAL += 1;
}
#line 1578 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeMapBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeMapBegin)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "p, keytype, valtype, size");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	int	keytype = (int)SvIV(ST(1))
;
	int	valtype = (int)SvIV(ST(2))
;
	int	size = (int)SvIV(ST(3))
;
#line 178 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("writeMapBegin(keytype %d, valtype %d, size %d)\n", keytype, valtype, size);
  char data[6];
  RETVAL = 0;

  data[0] = keytype & 0xff;
  data[1] = valtype & 0xff;
  INT_TO_I32(data, size, 2);

  WRITE(p, data, 6);
  RETVAL += 6;
}
#line 1616 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeMapEnd); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeMapEnd)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV *");
    {
	int	RETVAL;
	dXSTARG;
#line 196 "./BinaryProtocol.xs"
{
  RETVAL = 0;
}
#line 1637 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeListBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeListBegin)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p, elemtype, size");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	int	elemtype = (int)SvIV(ST(1))
;
	int	size = (int)SvIV(ST(2))
;
#line 205 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("writeListBegin(elemtype %d, size %d)\n", elemtype, size);
  char data[5];
  RETVAL = 0;

  data[0] = elemtype & 0xff;
  INT_TO_I32(data, size, 1);

  WRITE(p, data, 5);
  RETVAL += 5;
}
#line 1672 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeListEnd); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeListEnd)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV *");
    {
	int	RETVAL;
	dXSTARG;
#line 222 "./BinaryProtocol.xs"
{
  RETVAL = 0;
}
#line 1693 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeSetBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeSetBegin)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p, elemtype, size");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	int	elemtype = (int)SvIV(ST(1))
;
	int	size = (int)SvIV(ST(2))
;
#line 231 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("writeSetBegin(elemtype %d, size %d)\n", elemtype, size);
  char data[5];
  RETVAL = 0;

  data[0] = elemtype & 0xff;
  INT_TO_I32(data, size, 1);

  WRITE(p, data, 5);
  RETVAL += 5;
}
#line 1728 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeSetEnd); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeSetEnd)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV *");
    {
	int	RETVAL;
	dXSTARG;
#line 248 "./BinaryProtocol.xs"
{
  RETVAL = 0;
}
#line 1749 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeBool); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeBool)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 257 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("writeBool(%d)\n", SvTRUE(value) ? 1 : 0);
  char data[1];
  RETVAL = 0;

  data[0] = SvTRUE(value) ? 1 : 0;

  WRITE(p, data, 1);
  RETVAL += 1;
}
#line 1781 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeByte); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeByte)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 273 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("writeByte(%ld)\n", SvIV(value) & 0xff);
  char data[1];
  RETVAL = 0;

  data[0] = SvIV(value) & 0xff;

  WRITE(p, data, 1);
  RETVAL += 1;
}
#line 1813 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeI16); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeI16)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	int	value = (int)SvIV(ST(1))
;
#line 289 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("writeI16(%d)\n", value);
  char data[2];
  RETVAL = 0;

  INT_TO_I16(data, value, 0);

  WRITE(p, data, 2);
  RETVAL += 2;
}
#line 1845 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeI32); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeI32)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	int	value = (int)SvIV(ST(1))
;
#line 305 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("writeI32(%d)\n", value);
  char data[4];
  RETVAL = 0;

  INT_TO_I32(data, value, 0);

  WRITE(p, data, 4);
  RETVAL += 4;
}
#line 1877 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeI64); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeI64)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 321 "./BinaryProtocol.xs"
{
  char data[8];
  RETVAL = 0;

  // Stringify the value, then convert to an int64_t
  const char *str = SvPOK(value) ? SvPVX(value) : SvPV_nolen(value);
  int64_t i64 = (int64_t)strtoll(str, NULL, 10);

  DEBUG_TRACE("writeI64(%" PRId64 ") (from string %s)\n", i64, str);

  data[7] = i64 & 0xff;
  data[6] = (i64 >> 8) & 0xff;
  data[5] = (i64 >> 16) & 0xff;
  data[4] = (i64 >> 24) & 0xff;
  data[3] = (i64 >> 32) & 0xff;
  data[2] = (i64 >> 40) & 0xff;
  data[1] = (i64 >> 48) & 0xff;
  data[0] = (i64 >> 56) & 0xff;

  WRITE(p, data, 8);
  RETVAL += 8;
}
#line 1921 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeDouble); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeDouble)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 349 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("writeDouble(%f)\n", (double)SvNV(value));
  char data[8];
  union {
    double from;
    uint64_t to;
  } u;
  RETVAL = 0;

  u.from = (double)SvNV(value);
  uint64_t bits = u.to;
  bits = htonll(bits);

  memcpy(&data, (uint8_t *)&bits, 8);

  WRITE(p, data, 8);
  RETVAL += 8;
}
#line 1961 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeString); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_writeString)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 373 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("writeString(%s)\n", SvPVX(value));
  RETVAL = 0;

  SV *valuecopy = sv_mortalcopy(value);
  if (SvUTF8(value) != 0) {
    sv_utf8_encode(valuecopy);
  }
  int len = sv_len(valuecopy);
  SV *data = sv_2mortal(newSV(4 + len));
  char i32[4];

  INT_TO_I32(i32, len, 0);
  sv_setpvn(data, i32, 4);
  RETVAL += 4;
  sv_catsv(data, valuecopy);
  RETVAL += len;

  WRITE_SV(p, data);
}
#line 2003 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readMessageBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readMessageBegin)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "p, name, type, seqid");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	name = ST(1)
;
	SV *	type = ST(2)
;
	SV *	seqid = ST(3)
;
#line 399 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("readMessageBegin()\n");
  RETVAL = 0;

  SV *tmp;
  int version;
  char *tmps;

  // read version + type
  READ_SV(p, tmp, 4);
  tmps = SvPVX(tmp);
  I32_TO_INT(version, tmps, 0);
  RETVAL += 4;

  if (version < 0) {
    if ((version & VERSION_MASK) != VERSION_1) {
      THROW("Thrift::TException", "Missing version identifier");
    }
    // set type
    if (SvROK(type))
      sv_setiv(SvRV(type), version & 0x000000ff);

    // read string
    {
      uint32_t len;
      READ_SV(p, tmp, 4);
      tmps = SvPVX(tmp);
      I32_TO_INT(len, tmps, 0);
      RETVAL += 4;
      if (len) {
        READ_SV(p, tmp, len);
        sv_utf8_decode(tmp);
        RETVAL += len;
        if (SvROK(name))
          sv_setsv(SvRV(name), tmp);
      }
      else {
        if (SvROK(name))
          sv_setpv(SvRV(name), "");
      }
    }

    // read seqid
    {
      int s;
            READ_SV(p, tmp, 4);
            tmps = SvPVX(tmp);
      I32_TO_INT(s, tmps, 0);
            RETVAL += 4;
            if (SvROK(seqid))
                sv_setiv(SvRV(seqid), s);
        }
    }
    else {
        THROW("Thrift::TException", "Missing version identifier");
    }
}
#line 2086 "XS.c"
		TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readMessageEnd); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readMessageEnd)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV *");
    {
	int	RETVAL;
	dXSTARG;
#line 462 "./BinaryProtocol.xs"
{
  RETVAL = 0;
}
#line 2107 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readStructBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readStructBegin)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "SV *, name");
    {
	int	RETVAL;
	dXSTARG;
	SV *	name = ST(1)
;
#line 471 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("readStructBegin()\n");
  RETVAL = 0;

  if (SvROK(name))
    sv_setpv(SvRV(name), "");
}
#line 2134 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readStructEnd); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readStructEnd)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV *");
    {
	int	RETVAL;
	dXSTARG;
#line 484 "./BinaryProtocol.xs"
{
  RETVAL = 0;
}
#line 2155 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readFieldBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readFieldBegin)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "p, name, fieldtype, fieldid");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	name = ST(1)
;
	SV *	fieldtype = ST(2)
;
	SV *	fieldid = ST(3)
;
#line 493 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("readFieldBegin()\n");
  SV *tmp;
  char *tmps;
  RETVAL = 0;

  PERL_UNUSED_VAR(name);
  READ_SV(p, tmp, 1);
  tmps = SvPVX(tmp);
  RETVAL += 1;

  // fieldtype byte
  if (SvROK(fieldtype))
    sv_setiv(SvRV(fieldtype), tmps[0]);

  if (tmps[0] == T_STOP) {
    if (SvROK(fieldid))
      sv_setiv(SvRV(fieldid), 0);
  }
  else {
    // fieldid i16
    READ_SV(p, tmp, 2);
    tmps = SvPVX(tmp);
    int fid;
    I16_TO_INT(fid, tmps, 0);
    RETVAL += 2;
    if (SvROK(fieldid))
      sv_setiv(SvRV(fieldid), fid);
  }
}
#line 2211 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readFieldEnd); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readFieldEnd)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV *");
    {
	int	RETVAL;
	dXSTARG;
#line 529 "./BinaryProtocol.xs"
{
  RETVAL = 0;
}
#line 2232 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readMapBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readMapBegin)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "p, keytype, valtype, size");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	keytype = ST(1)
;
	SV *	valtype = ST(2)
;
	SV *	size = ST(3)
;
#line 538 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("readMapBegin()\n");
  SV *tmp;
  char *tmps;
  RETVAL = 0;

  READ_SV(p, tmp, 6);
  tmps = SvPVX(tmp);
  RETVAL += 6;

  // keytype byte
  if (SvROK(keytype))
    sv_setiv(SvRV(keytype), tmps[0]);

  // valtype byte
  if (SvROK(valtype))
    sv_setiv(SvRV(valtype), tmps[1]);

  // size i32
  int isize;
  I32_TO_INT(isize, tmps, 2);
  if (SvROK(size))
    sv_setiv(SvRV(size), isize);
}
#line 2282 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readMapEnd); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readMapEnd)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV *");
    {
	int	RETVAL;
	dXSTARG;
#line 568 "./BinaryProtocol.xs"
{
  RETVAL = 0;
}
#line 2303 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readListBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readListBegin)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p, elemtype, size");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	elemtype = ST(1)
;
	SV *	size = ST(2)
;
#line 577 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("readListBegin()\n");
  SV *tmp;
  char *tmps;
  RETVAL = 0;

  READ_SV(p, tmp, 5);
  tmps = SvPVX(tmp);
  RETVAL += 5;

  // elemtype byte
  if (SvROK(elemtype))
    sv_setiv(SvRV(elemtype), tmps[0]);

  // size i32
  int isize;
  I32_TO_INT(isize, tmps, 1);
  if (SvROK(size))
    sv_setiv(SvRV(size), isize);
}
#line 2347 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readListEnd); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readListEnd)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV *");
    {
	int	RETVAL;
	dXSTARG;
#line 603 "./BinaryProtocol.xs"
{
  RETVAL = 0;
}
#line 2368 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readSetBegin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readSetBegin)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p, elemtype, size");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	elemtype = ST(1)
;
	SV *	size = ST(2)
;
#line 612 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("readSetBegin()\n");
  SV *tmp;
  char *tmps;
  RETVAL = 0;

  READ_SV(p, tmp, 5);
  tmps = SvPVX(tmp);
  RETVAL += 5;

  // elemtype byte
  if (SvROK(elemtype))
    sv_setiv(SvRV(elemtype), tmps[0]);

  // size i32
  int isize;
  I32_TO_INT(isize, tmps, 1);
  if (SvROK(size))
    sv_setiv(SvRV(size), isize);
}
#line 2412 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readSetEnd); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readSetEnd)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV *");
    {
	int	RETVAL;
	dXSTARG;
#line 638 "./BinaryProtocol.xs"
{
  RETVAL = 0;
}
#line 2433 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readBool); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readBool)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 647 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("readBool()\n");
  SV *tmp;
  char *tmps;
  RETVAL = 0;

  READ_SV(p, tmp, 1);
  tmps = SvPVX(tmp);
  RETVAL += 1;

  if (SvROK(value))
    sv_setiv(SvRV(value), tmps[0] ? 1 : 0);
}
#line 2468 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readByte); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readByte)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 666 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("readByte()\n");
  SV *tmp;
  char *tmps;
  RETVAL = 0;

  READ_SV(p, tmp, 1);
  tmps = SvPVX(tmp);
  RETVAL += 1;

  if (SvROK(value))
    sv_setiv(SvRV(value), tmps[0]);
}
#line 2503 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readI16); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readI16)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 685 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("readI16()\n");
  SV *tmp;
  char *tmps;
  RETVAL = 0;

  READ_SV(p, tmp, 2);
  tmps = SvPVX(tmp);
  RETVAL += 2;

  int v;
  I16_TO_INT(v, tmps, 0);
  if (SvROK(value))
    sv_setiv(SvRV(value), v);
}
#line 2540 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readI32); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readI32)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 706 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("readI32()\n");
  SV *tmp;
  char *tmps;
  RETVAL = 0;

  READ_SV(p, tmp, 4);
  tmps = SvPVX(tmp);
  RETVAL += 4;

  int v;
  I32_TO_INT(v, tmps, 0);
  if (SvROK(value))
    sv_setiv(SvRV(value), v);
}
#line 2577 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readI64); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readI64)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 727 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("readI64()\n");
  SV *tmp;
  char *tmps;
  RETVAL = 0;

  READ_SV(p, tmp, 8);
  tmps = SvPVX(tmp);
  RETVAL += 8;

  int64_t hi;
  uint32_t lo;
  I32_TO_INT(hi, tmps, 0);
  I32_TO_INT(lo, tmps, 4);

  if (SvROK(value)) {
    char string[25];
    STRLEN length;
    length = sprintf(string, "%" PRId64, (int64_t)(hi << 32) | lo);
    sv_setpvn(SvRV(value), string, length);
  }
}
#line 2621 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readDouble); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readDouble)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 755 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("readDouble()\n");
  SV *tmp;
  char *tmps;
  uint64_t bits;
  RETVAL = 0;

  READ_SV(p, tmp, 8);
  tmps = SvPVX(tmp);
  RETVAL += 8;

  bits = *(uint64_t *)tmps;
  bits = ntohll(bits);

  union {
    uint64_t from;
    double to;
  } u;
  u.from = bits;

  if (SvROK(value))
    sv_setnv(SvRV(value), u.to);
}
#line 2666 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readString); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readString)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, value");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
#line 784 "./BinaryProtocol.xs"
{
  DEBUG_TRACE("readString()\n");
  SV *tmp;
  char *tmps;
  RETVAL = 0;

  uint32_t len;
  READ_SV(p, tmp, 4);
  tmps = SvPVX(tmp);
  I32_TO_INT(len, tmps, 0);
  RETVAL += 4;
  if (len) {
    READ_SV(p, tmp, len);
    sv_utf8_decode(tmp);
    RETVAL += len;
    if (SvROK(value))
      sv_setsv(SvRV(value), tmp);
  }
  else {
    if (SvROK(value))
      sv_setpv(SvRV(value), "");
  }
}
#line 2711 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readStringBody); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__BinaryProtocol_readStringBody)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p, value, len");
    {
	int	RETVAL;
	dXSTARG;
	TBinaryProtocol *	p = (TBinaryProtocol *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "p")
;
	SV *	value = ST(1)
;
	uint32_t	len = (uint32_t)SvUV(ST(2))
;
#line 813 "./BinaryProtocol.xs"
{
  // This method is never used but is here for compat
  SV *tmp;
  RETVAL = 0;

  if (len) {
    READ_SV(p, tmp, len);
    sv_utf8_decode(tmp);
    RETVAL += len;
    if (SvROK(value))
      sv_setsv(SvRV(value), tmp);
  }
  else {
    if (SvROK(value))
      sv_setpv(SvRV(value), "");
  }
}
#line 2752 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


/* INCLUDE: Returning to 'MemoryBuffer.xs' from 'BinaryProtocol.xs' */


XS_EUPXS(XS_Thrift__XS__MemoryBuffer_new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__MemoryBuffer_new)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "klass, ...");
    {
	SV *	RETVAL;
	char *	klass = (char *)SvPV_nolen(ST(0))
;
#line 6 "./MemoryBuffer.xs"
{
  int bufsize = 8192;
  TMemoryBuffer *mbuf;
  New(0, mbuf, sizeof(TMemoryBuffer), TMemoryBuffer);
  New(0, mbuf->buffer, sizeof(Buffer), Buffer);

  MEM_TRACE("new()\n");
  MEM_TRACE("  New mbuf @ %p\n", mbuf);
  MEM_TRACE("  New buffer @ %p\n", mbuf->buffer);

  if (items > 1 && SvIOK_UV(ST(1)))
    bufsize = SvIV(ST(1));

  buffer_init(mbuf->buffer, bufsize);

  RETVAL = xs_object_magic_create(
    aTHX_
    (void *)mbuf,
    gv_stashpv(klass, 0)
  );
}
#line 2795 "XS.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__MemoryBuffer_isOpen); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__MemoryBuffer_isOpen)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV *");
    {
	int	RETVAL;
	dXSTARG;
#line 33 "./MemoryBuffer.xs"
{
  RETVAL = 1;
}
#line 2816 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__MemoryBuffer_open); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__MemoryBuffer_open)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV *");
    {
#line 42 "./MemoryBuffer.xs"
{ }
#line 2833 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__MemoryBuffer_close); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__MemoryBuffer_close)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV *");
    {
#line 47 "./MemoryBuffer.xs"
{ }
#line 2848 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__MemoryBuffer_flush); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__MemoryBuffer_flush)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV *");
    {
#line 52 "./MemoryBuffer.xs"
{ }
#line 2863 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__MemoryBuffer_available); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__MemoryBuffer_available)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "mbuf");
    {
	int	RETVAL;
	dXSTARG;
	TMemoryBuffer *	mbuf = (TMemoryBuffer *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "mbuf")
;
#line 57 "./MemoryBuffer.xs"
{
  RETVAL = buffer_len(mbuf->buffer);
}
#line 2884 "XS.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__MemoryBuffer_read); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__MemoryBuffer_read)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "mbuf, len");
    {
	SV *	RETVAL;
	TMemoryBuffer *	mbuf = (TMemoryBuffer *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "mbuf")
;
	int	len = (int)SvIV(ST(1))
;
#line 66 "./MemoryBuffer.xs"
{
  int avail = buffer_len(mbuf->buffer);

  if (avail == 0) {
    RETVAL = newSVpvn("", 0);
  }
  else {
    if (avail < len)
      len = avail;

    DEBUG_TRACE("read(%d)\n", len);
    RETVAL = newSVpvn( buffer_ptr(mbuf->buffer), len );
    buffer_consume(mbuf->buffer, len);
  }
}
#line 2920 "XS.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__MemoryBuffer_readAll); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__MemoryBuffer_readAll)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "mbuf, len");
    {
	SV *	RETVAL;
	TMemoryBuffer *	mbuf = (TMemoryBuffer *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "mbuf")
;
	int	len = (int)SvIV(ST(1))
;
#line 87 "./MemoryBuffer.xs"
{
  int avail = buffer_len(mbuf->buffer);

  if (avail < len) {
    THROW_SV("Thrift::TTransportException", newSVpvf("Attempt to readAll(%d) found only %d available", len, avail));
  }

  DEBUG_TRACE("readAll(%d)\n", len);
#ifdef XS_DEBUG
  //buffer_dump(mbuf->buffer, len);
#endif

  RETVAL = newSVpvn( buffer_ptr(mbuf->buffer), len );
  buffer_consume(mbuf->buffer, len);
}
#line 2956 "XS.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Thrift__XS__MemoryBuffer_write); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__MemoryBuffer_write)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "mbuf, buf, ...");
    {
	TMemoryBuffer *	mbuf = (TMemoryBuffer *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "mbuf")
;
	SV *	buf = ST(1)
;
#line 108 "./MemoryBuffer.xs"
{
  int len;

  if (items > 2)
    len = SvIV(ST(2));
  else
    len = sv_len(buf);

  buffer_append(mbuf->buffer, (void *)SvPVX(buf), len);

  DEBUG_TRACE("write(%d)\n", len);
#ifdef XS_DEBUG
  //buffer_dump(mbuf->buffer, 0);
#endif
}
#line 2991 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Thrift__XS__MemoryBuffer_DESTROY); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Thrift__XS__MemoryBuffer_DESTROY)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "mbuf");
    {
	TMemoryBuffer *	mbuf = (TMemoryBuffer *)xs_object_magic_get_struct_rv_pretty(aTHX_ ST(0), "mbuf")
;
#line 127 "./MemoryBuffer.xs"
{
  MEM_TRACE("DESTROY()\n");
  MEM_TRACE("  free buffer @ %p\n", mbuf->buffer);
  MEM_TRACE("  free mbuf @ %p\n", mbuf);

  buffer_free(mbuf->buffer);
  Safefree(mbuf->buffer);
  Safefree(mbuf);
}
#line 3016 "XS.c"
    }
    XSRETURN_EMPTY;
}


/* INCLUDE: Returning to 'XS.xs' from 'MemoryBuffer.xs' */

#ifdef __cplusplus
extern "C" {
#endif
XS_EXTERNAL(boot_Thrift__XS); /* prototype to pass -Wmissing-prototypes */
XS_EXTERNAL(boot_Thrift__XS)
{
#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

        (void)newXSproto_portable("Thrift::XS::CompactProtocol::resetState", XS_Thrift__XS__CompactProtocol_resetState, file, "$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::writeMessageBegin", XS_Thrift__XS__CompactProtocol_writeMessageBegin, file, "$$$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::writeStructBegin", XS_Thrift__XS__CompactProtocol_writeStructBegin, file, "$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::writeStructEnd", XS_Thrift__XS__CompactProtocol_writeStructEnd, file, "$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::writeFieldBegin", XS_Thrift__XS__CompactProtocol_writeFieldBegin, file, "$$$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::writeMapBegin", XS_Thrift__XS__CompactProtocol_writeMapBegin, file, "$$$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::writeListBegin", XS_Thrift__XS__CompactProtocol_writeListBegin, file, "$$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::writeSetBegin", XS_Thrift__XS__CompactProtocol_writeSetBegin, file, "$$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::writeBool", XS_Thrift__XS__CompactProtocol_writeBool, file, "$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::writeI16", XS_Thrift__XS__CompactProtocol_writeI16, file, "$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::writeI32", XS_Thrift__XS__CompactProtocol_writeI32, file, "$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::writeI64", XS_Thrift__XS__CompactProtocol_writeI64, file, "$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::writeDouble", XS_Thrift__XS__CompactProtocol_writeDouble, file, "$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::writeString", XS_Thrift__XS__CompactProtocol_writeString, file, "$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::readMessageBegin", XS_Thrift__XS__CompactProtocol_readMessageBegin, file, "$$$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::readStructBegin", XS_Thrift__XS__CompactProtocol_readStructBegin, file, "$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::readStructEnd", XS_Thrift__XS__CompactProtocol_readStructEnd, file, "$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::readFieldBegin", XS_Thrift__XS__CompactProtocol_readFieldBegin, file, "$$$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::readMapBegin", XS_Thrift__XS__CompactProtocol_readMapBegin, file, "$$$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::readListBegin", XS_Thrift__XS__CompactProtocol_readListBegin, file, "$$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::readSetBegin", XS_Thrift__XS__CompactProtocol_readSetBegin, file, "$$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::readBool", XS_Thrift__XS__CompactProtocol_readBool, file, "$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::readI16", XS_Thrift__XS__CompactProtocol_readI16, file, "$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::readI32", XS_Thrift__XS__CompactProtocol_readI32, file, "$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::readI64", XS_Thrift__XS__CompactProtocol_readI64, file, "$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::readDouble", XS_Thrift__XS__CompactProtocol_readDouble, file, "$$");
        (void)newXSproto_portable("Thrift::XS::CompactProtocol::readString", XS_Thrift__XS__CompactProtocol_readString, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::new", XS_Thrift__XS__BinaryProtocol_new, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::DESTROY", XS_Thrift__XS__BinaryProtocol_DESTROY, file, "$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::getTransport", XS_Thrift__XS__BinaryProtocol_getTransport, file, "$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeMessageBegin", XS_Thrift__XS__BinaryProtocol_writeMessageBegin, file, "$$$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeMessageEnd", XS_Thrift__XS__BinaryProtocol_writeMessageEnd, file, "$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeStructBegin", XS_Thrift__XS__BinaryProtocol_writeStructBegin, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeStructEnd", XS_Thrift__XS__BinaryProtocol_writeStructEnd, file, "$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeFieldBegin", XS_Thrift__XS__BinaryProtocol_writeFieldBegin, file, "$$$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeFieldEnd", XS_Thrift__XS__BinaryProtocol_writeFieldEnd, file, "$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeFieldStop", XS_Thrift__XS__BinaryProtocol_writeFieldStop, file, "$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeMapBegin", XS_Thrift__XS__BinaryProtocol_writeMapBegin, file, "$$$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeMapEnd", XS_Thrift__XS__BinaryProtocol_writeMapEnd, file, "$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeListBegin", XS_Thrift__XS__BinaryProtocol_writeListBegin, file, "$$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeListEnd", XS_Thrift__XS__BinaryProtocol_writeListEnd, file, "$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeSetBegin", XS_Thrift__XS__BinaryProtocol_writeSetBegin, file, "$$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeSetEnd", XS_Thrift__XS__BinaryProtocol_writeSetEnd, file, "$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeBool", XS_Thrift__XS__BinaryProtocol_writeBool, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeByte", XS_Thrift__XS__BinaryProtocol_writeByte, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeI16", XS_Thrift__XS__BinaryProtocol_writeI16, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeI32", XS_Thrift__XS__BinaryProtocol_writeI32, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeI64", XS_Thrift__XS__BinaryProtocol_writeI64, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeDouble", XS_Thrift__XS__BinaryProtocol_writeDouble, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::writeString", XS_Thrift__XS__BinaryProtocol_writeString, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readMessageBegin", XS_Thrift__XS__BinaryProtocol_readMessageBegin, file, "$$$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readMessageEnd", XS_Thrift__XS__BinaryProtocol_readMessageEnd, file, "$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readStructBegin", XS_Thrift__XS__BinaryProtocol_readStructBegin, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readStructEnd", XS_Thrift__XS__BinaryProtocol_readStructEnd, file, "$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readFieldBegin", XS_Thrift__XS__BinaryProtocol_readFieldBegin, file, "$$$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readFieldEnd", XS_Thrift__XS__BinaryProtocol_readFieldEnd, file, "$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readMapBegin", XS_Thrift__XS__BinaryProtocol_readMapBegin, file, "$$$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readMapEnd", XS_Thrift__XS__BinaryProtocol_readMapEnd, file, "$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readListBegin", XS_Thrift__XS__BinaryProtocol_readListBegin, file, "$$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readListEnd", XS_Thrift__XS__BinaryProtocol_readListEnd, file, "$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readSetBegin", XS_Thrift__XS__BinaryProtocol_readSetBegin, file, "$$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readSetEnd", XS_Thrift__XS__BinaryProtocol_readSetEnd, file, "$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readBool", XS_Thrift__XS__BinaryProtocol_readBool, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readByte", XS_Thrift__XS__BinaryProtocol_readByte, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readI16", XS_Thrift__XS__BinaryProtocol_readI16, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readI32", XS_Thrift__XS__BinaryProtocol_readI32, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readI64", XS_Thrift__XS__BinaryProtocol_readI64, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readDouble", XS_Thrift__XS__BinaryProtocol_readDouble, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readString", XS_Thrift__XS__BinaryProtocol_readString, file, "$$");
        (void)newXSproto_portable("Thrift::XS::BinaryProtocol::readStringBody", XS_Thrift__XS__BinaryProtocol_readStringBody, file, "$$$");
        (void)newXSproto_portable("Thrift::XS::MemoryBuffer::new", XS_Thrift__XS__MemoryBuffer_new, file, "$;@");
        (void)newXSproto_portable("Thrift::XS::MemoryBuffer::isOpen", XS_Thrift__XS__MemoryBuffer_isOpen, file, "$");
        (void)newXSproto_portable("Thrift::XS::MemoryBuffer::open", XS_Thrift__XS__MemoryBuffer_open, file, "$");
        (void)newXSproto_portable("Thrift::XS::MemoryBuffer::close", XS_Thrift__XS__MemoryBuffer_close, file, "$");
        (void)newXSproto_portable("Thrift::XS::MemoryBuffer::flush", XS_Thrift__XS__MemoryBuffer_flush, file, "$");
        (void)newXSproto_portable("Thrift::XS::MemoryBuffer::available", XS_Thrift__XS__MemoryBuffer_available, file, "$");
        (void)newXSproto_portable("Thrift::XS::MemoryBuffer::read", XS_Thrift__XS__MemoryBuffer_read, file, "$$");
        (void)newXSproto_portable("Thrift::XS::MemoryBuffer::readAll", XS_Thrift__XS__MemoryBuffer_readAll, file, "$$");
        (void)newXSproto_portable("Thrift::XS::MemoryBuffer::write", XS_Thrift__XS__MemoryBuffer_write, file, "$$;@");
        (void)newXSproto_portable("Thrift::XS::MemoryBuffer::DESTROY", XS_Thrift__XS__MemoryBuffer_DESTROY, file, "$");
#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
}

#ifdef __cplusplus
}
#endif