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

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

#include "uulib/fptools.h"
#include "uulib/uudeview.h"
#include "uulib/uuint.h"

static int
not_here (char *s)
{
  croak("%s not implemented", s);
  return -1;
}

static int
constant (char *name)
{
  errno = 0;
  switch (*name)
    {
      case 'A':
        if (strEQ(name, "ACT_COPYING")) return UUACT_COPYING;
        if (strEQ(name, "ACT_DECODING")) return UUACT_DECODING;
        if (strEQ(name, "ACT_ENCODING")) return UUACT_ENCODING;
        if (strEQ(name, "ACT_IDLE")) return UUACT_IDLE;
        if (strEQ(name, "ACT_SCANNING")) return UUACT_SCANNING;
      case 'F':
        if (strEQ(name, "FILE_DECODED")) return UUFILE_DECODED;
        if (strEQ(name, "FILE_ERROR")) return UUFILE_ERROR;
        if (strEQ(name, "FILE_MISPART")) return UUFILE_MISPART;
        if (strEQ(name, "FILE_NOBEGIN")) return UUFILE_NOBEGIN;
        if (strEQ(name, "FILE_NODATA")) return UUFILE_NODATA;
        if (strEQ(name, "FILE_NOEND")) return UUFILE_NOEND;
        if (strEQ(name, "FILE_OK")) return UUFILE_OK;
        if (strEQ(name, "FILE_READ")) return UUFILE_READ;
        if (strEQ(name, "FILE_TMPFILE")) return UUFILE_TMPFILE;
        break;
      case 'M':
        if (strEQ(name, "MSG_ERROR")) return UUMSG_ERROR;
        if (strEQ(name, "MSG_FATAL")) return UUMSG_FATAL;
        if (strEQ(name, "MSG_MESSAGE")) return UUMSG_MESSAGE;
        if (strEQ(name, "MSG_NOTE")) return UUMSG_NOTE;
        if (strEQ(name, "MSG_PANIC")) return UUMSG_PANIC;
        if (strEQ(name, "MSG_WARNING")) return UUMSG_WARNING;
      case 'O':
        if (strEQ(name, "OPT_VERSION")) return UUOPT_VERSION;
        if (strEQ(name, "OPT_FAST")) return UUOPT_FAST;
        if (strEQ(name, "OPT_DUMBNESS")) return UUOPT_DUMBNESS;
        if (strEQ(name, "OPT_BRACKPOL")) return UUOPT_BRACKPOL;
        if (strEQ(name, "OPT_VERBOSE")) return UUOPT_VERBOSE;
        if (strEQ(name, "OPT_DESPERATE")) return UUOPT_DESPERATE;
        if (strEQ(name, "OPT_IGNREPLY")) return UUOPT_IGNREPLY;
        if (strEQ(name, "OPT_OVERWRITE")) return UUOPT_OVERWRITE;
        if (strEQ(name, "OPT_SAVEPATH")) return UUOPT_SAVEPATH;
        if (strEQ(name, "OPT_IGNMODE")) return UUOPT_IGNMODE;
        if (strEQ(name, "OPT_DEBUG")) return UUOPT_DEBUG;
        if (strEQ(name, "OPT_ERRNO")) return UUOPT_ERRNO;
        if (strEQ(name, "OPT_PROGRESS")) return UUOPT_PROGRESS;
        if (strEQ(name, "OPT_USETEXT")) return UUOPT_USETEXT;
        if (strEQ(name, "OPT_PREAMB")) return UUOPT_PREAMB;
        if (strEQ(name, "OPT_TINYB64")) return UUOPT_TINYB64;
        if (strEQ(name, "OPT_ENCEXT")) return UUOPT_ENCEXT;
        if (strEQ(name, "OPT_REMOVE")) return UUOPT_REMOVE;
        if (strEQ(name, "OPT_MOREMIME")) return UUOPT_MOREMIME;
        if (strEQ(name, "OPT_DOTDOT")) return UUOPT_DOTDOT;
        if (strEQ(name, "OPT_RBUF")) return UUOPT_RBUF;
        if (strEQ(name, "OPT_WBUF")) return UUOPT_WBUF;
      case 'R':
        if (strEQ(name, "RET_CANCEL")) return UURET_CANCEL;
        if (strEQ(name, "RET_CONT")) return UURET_CONT;
        if (strEQ(name, "RET_EXISTS")) return UURET_EXISTS;
        if (strEQ(name, "RET_ILLVAL")) return UURET_ILLVAL;
        if (strEQ(name, "RET_IOERR")) return UURET_IOERR;
        if (strEQ(name, "RET_NODATA")) return UURET_NODATA;
        if (strEQ(name, "RET_NOEND")) return UURET_NOEND;
        if (strEQ(name, "RET_NOMEM")) return UURET_NOMEM;
        if (strEQ(name, "RET_OK")) return UURET_OK;
        if (strEQ(name, "RET_UNSUP")) return UURET_UNSUP;
      case 'B':
        if (strEQ(name, "B64_ENCODED")) return B64ENCODED;
        if (strEQ(name, "BH_ENCODED")) return BH_ENCODED;
      case 'P':
        if (strEQ(name, "PT_ENCODED")) return PT_ENCODED;
      case 'Q':
        if (strEQ(name, "QP_ENCODED")) return QP_ENCODED;
      case 'U':
        if (strEQ(name, "UU_ENCODED")) return UU_ENCODED;
      case 'X':
        if (strEQ(name, "XX_ENCODED")) return XX_ENCODED;
      case 'Y':
        if (strEQ(name, "YENC_ENCODED")) return YENC_ENCODED;
    }

  errno = EINVAL;
  return 0;
}

static void
uu_msg_callback (void *cb, char *msg, int level)
{
  dSP;
  
  ENTER; SAVETMPS; PUSHMARK (SP); EXTEND (SP, 2);

  PUSHs (sv_2mortal (newSVpv (msg, 0)));
  PUSHs (sv_2mortal (newSViv (level)));

  PUTBACK; (void) perl_call_sv ((SV *)cb, G_VOID|G_DISCARD); SPAGAIN;
  PUTBACK; FREETMPS; LEAVE;
}

static int
uu_busy_callback (void *cb, uuprogress *uup)
{
  dSP;
  int count;
  int retval;
  
  ENTER; SAVETMPS; PUSHMARK (SP); EXTEND (SP, 6);

  PUSHs (sv_2mortal (newSViv (uup->action)));
  PUSHs (sv_2mortal (newSVpv (uup->curfile, 0)));
  PUSHs (sv_2mortal (newSViv (uup->partno)));
  PUSHs (sv_2mortal (newSViv (uup->numparts)));
  PUSHs (sv_2mortal (newSViv (uup->fsize)));
  PUSHs (sv_2mortal (newSViv (uup->percent)));

  PUTBACK; count = perl_call_sv ((SV *)cb, G_SCALAR); SPAGAIN;

  if (count != 1)
    croak ("busycallback perl callback returned more than one argument");

  retval = POPi;

  PUTBACK; FREETMPS; LEAVE;

  return retval;
}

static char *
uu_fnamefilter_callback (void *cb, char *fname)
{
  dSP;
  int count;
  static char *str;
  
  ENTER; SAVETMPS; PUSHMARK (SP); EXTEND (SP, 1);

  PUSHs (sv_2mortal (newSVpv (fname, 0)));

  PUTBACK; count = perl_call_sv ((SV *)cb, G_SCALAR); SPAGAIN;

  if (count != 1)
    croak ("fnamefilter perl callback MUST return a single filename exactly");

  _FP_free (str); str = _FP_strdup (SvPV_nolen (TOPs));

  PUTBACK; FREETMPS; LEAVE;

  return str;
}

static int
uu_file_callback (void *cb, char *id, char *fname, int retrieve)
{
  dSP;
  int count;
  int retval;
  SV *xfname = newSVpv ("", 0);
  
  ENTER; SAVETMPS; PUSHMARK (SP); EXTEND (SP, 3);

  PUSHs (sv_2mortal (newSVpv (id, 0)));
  PUSHs (sv_2mortal (xfname));
  PUSHs (sv_2mortal (newSViv (retrieve)));

  PUTBACK; count = perl_call_sv ((SV *)cb, G_SCALAR); SPAGAIN;

  if (count != 1)
    croak ("filecallback perl callback must return a single return status");

  strcpy (fname, SvPV_nolen (xfname));
  retval = POPi;

  PUTBACK; FREETMPS; LEAVE;

  return retval;
}

static char *
uu_filename_callback (void *cb, char *subject, char *filename)
{
  dSP;
  int count;
  
  ENTER; SAVETMPS; PUSHMARK (SP); EXTEND (SP, 2);

  PUSHs (sv_2mortal(newSVpv(subject, 0)));
  PUSHs (filename ? sv_2mortal(newSVpv(filename, 0)) : &PL_sv_undef);

  PUTBACK; count = perl_call_sv ((SV *)cb, G_ARRAY); SPAGAIN;

  if (count > 1)
    croak ("filenamecallback perl callback must return nothing or a single filename");

  if (count)
    {
      _FP_free (filename);

      filename = SvOK (TOPs)
         ? _FP_strdup (SvPV_nolen (TOPs))
         : 0;
    }

  PUTBACK; FREETMPS; LEAVE;

  return filename;
}

static SV *uu_msg_sv, *uu_busy_sv, *uu_file_sv, *uu_fnamefilter_sv, *uu_filename_sv;

#define FUNC_CB(cb) (void *)(sv_setsv (cb ## _sv, func), cb ## _sv), func ? cb ## _callback : NULL

static int
uu_info_file (void *cb, char *info)
{
  dSP;
  int count;
  int retval;
  
  ENTER; SAVETMPS; PUSHMARK(SP); EXTEND(SP,1);

  PUSHs(sv_2mortal(newSVpv(info,0)));

  PUTBACK; count = perl_call_sv ((SV *)cb, G_SCALAR); SPAGAIN;

  if (count != 1)
    croak ("info_file perl callback returned more than one argument");

  retval = POPi;

  PUTBACK; FREETMPS; LEAVE;

  return retval;
}

static int
uu_opt_isstring (int opt)
{
  switch (opt)
    {
      case UUOPT_VERSION:
      case UUOPT_SAVEPATH:
      case UUOPT_ENCEXT:
         return 1;
      default:
         return 0;
    }
}

static int uu_initialized;

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

#line 278 "UUlib.c"

XS(XS_Convert__UUlib_constant); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_constant)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::constant", "name");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	char *	name = (char *)SvPV_nolen(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = constant(name);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib_Initialize); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_Initialize)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 0)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::Initialize", "");
    PERL_UNUSED_VAR(cv); /* -W */
    {
#line 276 "UUlib.xs"
        if (!uu_initialized)
          {
            int retval;

            if ((retval = UUInitialize ()) != UURET_OK)
              croak ("unable to initialize uudeview library (%s)", UUstrerror (retval));

            uu_initialized = 1;
          }
#line 325 "UUlib.c"
    }
    XSRETURN_EMPTY;
}


XS(XS_Convert__UUlib_CleanUp); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_CleanUp)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 0)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::CleanUp", "");
    PERL_UNUSED_VAR(cv); /* -W */
    {
#line 289 "UUlib.xs"
       	if (uu_initialized)
          UUCleanUp ();

        uu_initialized = 0; 
#line 348 "UUlib.c"
    }
    XSRETURN_EMPTY;
}


XS(XS_Convert__UUlib_GetOption); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_GetOption)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::GetOption", "opt");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	opt = (int)SvIV(ST(0));
	SV *	RETVAL;
#line 298 "UUlib.xs"
	{
                if (opt == UUOPT_PROGRESS)
                  croak ("GetOption(UUOPT_PROGRESS) is not yet implemented");
                else if (uu_opt_isstring (opt))
                  {
        	    char cval[8192];

                    UUGetOption (opt, 0, cval, sizeof cval);
                    RETVAL = newSVpv (cval, 0);
                  }
                else
                  {
                    RETVAL = newSViv (UUGetOption (opt, 0, 0, 0));
                  }
	}
#line 384 "UUlib.c"
	ST(0) = RETVAL;
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib_SetOption); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_SetOption)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 2)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::SetOption", "opt, val");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	opt = (int)SvIV(ST(0));
	SV *	val = ST(1);
	int	RETVAL;
	dXSTARG;
#line 321 "UUlib.xs"
	{
                STRLEN dc;

                if (uu_opt_isstring (opt))
                  RETVAL = UUSetOption (opt, 0, SvPV (val, dc));
                else
                  RETVAL = UUSetOption (opt, SvIV (val), (void *)0);
	}
#line 417 "UUlib.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib_strerror); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_strerror)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::strerror", "errcode");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	errcode = (int)SvIV(ST(0));
	char *	RETVAL;
	dXSTARG;

	RETVAL = UUstrerror(errcode);
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib_SetMsgCallback); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_SetMsgCallback)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items < 0 || items > 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::SetMsgCallback", "func = 0");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	SV *	func;

	if (items < 1)
	    func = 0;
	else {
	    func = ST(0);
	}
#line 340 "UUlib.xs"
	UUSetMsgCallback (FUNC_CB (uu_msg));
#line 468 "UUlib.c"
    }
    XSRETURN_EMPTY;
}


XS(XS_Convert__UUlib_SetBusyCallback); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_SetBusyCallback)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items < 0 || items > 2)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::SetBusyCallback", "func = 0, msecs = 1000");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	SV *	func;
	long	msecs;

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

	if (items < 2)
	    msecs = 1000;
	else {
	    msecs = (long)SvIV(ST(1));
	}
#line 347 "UUlib.xs"
	UUSetBusyCallback (FUNC_CB (uu_busy), msecs);
#line 502 "UUlib.c"
    }
    XSRETURN_EMPTY;
}


XS(XS_Convert__UUlib_SetFileCallback); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_SetFileCallback)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items < 0 || items > 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::SetFileCallback", "func = 0");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	SV *	func;

	if (items < 1)
	    func = 0;
	else {
	    func = ST(0);
	}
#line 353 "UUlib.xs"
	UUSetFileCallback (FUNC_CB (uu_file));
#line 529 "UUlib.c"
    }
    XSRETURN_EMPTY;
}


XS(XS_Convert__UUlib_SetFNameFilter); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_SetFNameFilter)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items < 0 || items > 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::SetFNameFilter", "func = 0");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	SV *	func;

	if (items < 1)
	    func = 0;
	else {
	    func = ST(0);
	}
#line 359 "UUlib.xs"
	UUSetFNameFilter (FUNC_CB (uu_fnamefilter));
#line 556 "UUlib.c"
    }
    XSRETURN_EMPTY;
}


XS(XS_Convert__UUlib_SetFileNameCallback); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_SetFileNameCallback)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items < 0 || items > 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::SetFileNameCallback", "func = 0");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	SV *	func;

	if (items < 1)
	    func = 0;
	else {
	    func = ST(0);
	}
#line 365 "UUlib.xs"
	UUSetFileNameCallback (FUNC_CB (uu_filename));
#line 583 "UUlib.c"
    }
    XSRETURN_EMPTY;
}


XS(XS_Convert__UUlib_FNameFilter); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_FNameFilter)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::FNameFilter", "fname");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	char *	fname = (char *)SvPV_nolen(ST(0));
	char *	RETVAL;
	dXSTARG;

	RETVAL = UUFNameFilter(fname);
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib_LoadFile); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_LoadFile)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items < 1 || items > 4)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::LoadFile", "fname, id = 0, delflag = 0, partno = -1");
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	char *	fname = (char *)SvPV_nolen(ST(0));
	char *	id;
	int	delflag;
	int	partno;

	if (items < 2)
	    id = 0;
	else {
	    id = (char *)SvPV_nolen(ST(1));
	}

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

	if (items < 4)
	    partno = -1;
	else {
	    partno = (int)SvIV(ST(3));
	}
#line 378 "UUlib.xs"
	{	
	        int count;

	        XPUSHs (sv_2mortal (newSViv (UULoadFileWithPartNo (fname, id, delflag, partno, &count))));
                if (GIMME_V == G_ARRAY)
                  XPUSHs (sv_2mortal (newSViv (count)));
	}
#line 656 "UUlib.c"
	PUTBACK;
	return;
    }
}


XS(XS_Convert__UUlib_Smerge); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_Smerge)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::Smerge", "pass");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	pass = (int)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = UUSmerge(pass);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib_QuickDecode); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_QuickDecode)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 4)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::QuickDecode", "datain, dataout, boundary, maxpos");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	FILE *	datain = PerlIO_findFILE(IoIFP(sv_2io(ST(0))));
	FILE *	dataout = PerlIO_findFILE(IoIFP(sv_2io(ST(1))));
	char *	boundary = (char *)SvPV_nolen(ST(2));
	long	maxpos = (long)SvIV(ST(3));
	int	RETVAL;
	dXSTARG;

	RETVAL = UUQuickDecode(datain, dataout, boundary, maxpos);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib_EncodeMulti); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_EncodeMulti)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 7)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::EncodeMulti", "outfile, infile, infname, encoding, outfname, mimetype, filemode");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	FILE *	outfile = PerlIO_findFILE(IoIFP(sv_2io(ST(0))));
	FILE *	infile = PerlIO_findFILE(IoIFP(sv_2io(ST(1))));
	char *	infname = (char *)SvPV_nolen(ST(2));
	int	encoding = (int)SvIV(ST(3));
	char *	outfname = (char *)SvPV_nolen(ST(4));
	char *	mimetype = (char *)SvPV_nolen(ST(5));
	int	filemode = (int)SvIV(ST(6));
	int	RETVAL;
	dXSTARG;

	RETVAL = UUEncodeMulti(outfile, infile, infname, encoding, outfname, mimetype, filemode);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib_EncodePartial); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_EncodePartial)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 9)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::EncodePartial", "outfile, infile, infname, encoding, outfname, mimetype, filemode, partno, linperfile");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	FILE *	outfile = PerlIO_findFILE(IoIFP(sv_2io(ST(0))));
	FILE *	infile = PerlIO_findFILE(IoIFP(sv_2io(ST(1))));
	char *	infname = (char *)SvPV_nolen(ST(2));
	int	encoding = (int)SvIV(ST(3));
	char *	outfname = (char *)SvPV_nolen(ST(4));
	char *	mimetype = (char *)SvPV_nolen(ST(5));
	int	filemode = (int)SvIV(ST(6));
	int	partno = (int)SvIV(ST(7));
	long	linperfile = (long)SvIV(ST(8));
	int	RETVAL;
	dXSTARG;

	RETVAL = UUEncodePartial(outfile, infile, infname, encoding, outfname, mimetype, filemode, partno, linperfile);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib_EncodeToStream); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_EncodeToStream)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 6)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::EncodeToStream", "outfile, infile, infname, encoding, outfname, filemode");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	FILE *	outfile = PerlIO_findFILE(IoIFP(sv_2io(ST(0))));
	FILE *	infile = PerlIO_findFILE(IoIFP(sv_2io(ST(1))));
	char *	infname = (char *)SvPV_nolen(ST(2));
	int	encoding = (int)SvIV(ST(3));
	char *	outfname = (char *)SvPV_nolen(ST(4));
	int	filemode = (int)SvIV(ST(5));
	int	RETVAL;
	dXSTARG;

	RETVAL = UUEncodeToStream(outfile, infile, infname, encoding, outfname, filemode);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib_EncodeToFile); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_EncodeToFile)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 6)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::EncodeToFile", "infile, infname, encoding, outfname, diskname, linperfile");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	FILE *	infile = PerlIO_findFILE(IoIFP(sv_2io(ST(0))));
	char *	infname = (char *)SvPV_nolen(ST(1));
	int	encoding = (int)SvIV(ST(2));
	char *	outfname = (char *)SvPV_nolen(ST(3));
	char *	diskname = (char *)SvPV_nolen(ST(4));
	long	linperfile = (long)SvIV(ST(5));
	int	RETVAL;
	dXSTARG;

	RETVAL = UUEncodeToFile(infile, infname, encoding, outfname, diskname, linperfile);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib_E_PrepSingle); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_E_PrepSingle)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 10)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::E_PrepSingle", "outfile, infile, infname, encoding, outfname, filemode, destination, from, subject, isemail");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	FILE *	outfile = PerlIO_findFILE(IoIFP(sv_2io(ST(0))));
	FILE *	infile = PerlIO_findFILE(IoIFP(sv_2io(ST(1))));
	char *	infname = (char *)SvPV_nolen(ST(2));
	int	encoding = (int)SvIV(ST(3));
	char *	outfname = (char *)SvPV_nolen(ST(4));
	int	filemode = (int)SvIV(ST(5));
	char *	destination = (char *)SvPV_nolen(ST(6));
	char *	from = (char *)SvPV_nolen(ST(7));
	char *	subject = (char *)SvPV_nolen(ST(8));
	int	isemail = (int)SvIV(ST(9));
	int	RETVAL;
	dXSTARG;

	RETVAL = UUE_PrepSingle(outfile, infile, infname, encoding, outfname, filemode, destination, from, subject, isemail);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib_E_PrepPartial); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_E_PrepPartial)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 13)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::E_PrepPartial", "outfile, infile, infname, encoding, outfname, filemode, partno, linperfile, filesize, destination, from, subject, isemail");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	FILE *	outfile = PerlIO_findFILE(IoIFP(sv_2io(ST(0))));
	FILE *	infile = PerlIO_findFILE(IoIFP(sv_2io(ST(1))));
	char *	infname = (char *)SvPV_nolen(ST(2));
	int	encoding = (int)SvIV(ST(3));
	char *	outfname = (char *)SvPV_nolen(ST(4));
	int	filemode = (int)SvIV(ST(5));
	int	partno = (int)SvIV(ST(6));
	long	linperfile = (long)SvIV(ST(7));
	long	filesize = (long)SvIV(ST(8));
	char *	destination = (char *)SvPV_nolen(ST(9));
	char *	from = (char *)SvPV_nolen(ST(10));
	char *	subject = (char *)SvPV_nolen(ST(11));
	int	isemail = (int)SvIV(ST(12));
	int	RETVAL;
	dXSTARG;

	RETVAL = UUE_PrepPartial(outfile, infile, infname, encoding, outfname, filemode, partno, linperfile, filesize, destination, from, subject, isemail);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib_GetFileListItem); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib_GetFileListItem)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::GetFileListItem", "num");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	num = (int)SvIV(ST(0));
	uulist *	RETVAL;

	RETVAL = UUGetFileListItem(num);
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Convert::UUlib::Item", (void*)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib__Item_rename); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib__Item_rename)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 2)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::Item::rename", "item, newname");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	uulist *	item;
	char *	newname = (char *)SvPV_nolen(ST(1));
	int	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "Convert::UUlib::Item")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    item = (uulist *) tmp;
	}
	else
	    croak("item is not of type Convert::UUlib::Item");
#line 477 "UUlib.xs"
        RETVAL = UURenameFile (item, newname);
#line 943 "UUlib.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib__Item_decode_temp); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib__Item_decode_temp)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::Item::decode_temp", "item");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	uulist *	item;
	int	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "Convert::UUlib::Item")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    item = (uulist *) tmp;
	}
	else
	    croak("item is not of type Convert::UUlib::Item");
#line 485 "UUlib.xs"
        RETVAL = UUDecodeToTemp (item);
#line 974 "UUlib.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib__Item_remove_temp); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib__Item_remove_temp)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::Item::remove_temp", "item");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	uulist *	item;
	int	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "Convert::UUlib::Item")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    item = (uulist *) tmp;
	}
	else
	    croak("item is not of type Convert::UUlib::Item");
#line 493 "UUlib.xs"
        RETVAL = UURemoveTemp (item);
#line 1005 "UUlib.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib__Item_decode); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib__Item_decode)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items < 1 || items > 2)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::Item::decode", "item, target = 0");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	uulist *	item;
	char *	target;
	int	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "Convert::UUlib::Item")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    item = (uulist *) tmp;
	}
	else
	    croak("item is not of type Convert::UUlib::Item");

	if (items < 2)
	    target = 0;
	else {
	    target = (char *)SvPV_nolen(ST(1));
	}
#line 502 "UUlib.xs"
        RETVAL = UUDecodeFile (item, target);
#line 1043 "UUlib.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib__Item_info); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib__Item_info)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 2)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::Item::info", "item, func");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	uulist *	item;
	SV *	func = ST(1);

	if (sv_derived_from(ST(0), "Convert::UUlib::Item")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    item = (uulist *) tmp;
	}
	else
	    croak("item is not of type Convert::UUlib::Item");
#line 511 "UUlib.xs"
        UUInfoFile (item,(void *)func, uu_info_file);
#line 1073 "UUlib.c"
    }
    XSRETURN_EMPTY;
}


XS(XS_Convert__UUlib__Item_state); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib__Item_state)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::Item::state", "li");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	uulist *	li;
	short	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "Convert::UUlib::Item")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    li = (uulist *) tmp;
	}
	else
	    croak("li is not of type Convert::UUlib::Item");
#line 517 "UUlib.xs"
        RETVAL = li->state;
#line 1103 "UUlib.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib__Item_mode); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib__Item_mode)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items < 1 || items > 2)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::Item::mode", "li, newmode=0");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	uulist *	li;
	short	newmode;
	short	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "Convert::UUlib::Item")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    li = (uulist *) tmp;
	}
	else
	    croak("li is not of type Convert::UUlib::Item");

	if (items < 2)
	    newmode = 0;
	else {
	    newmode = (short)SvIV(ST(1));
	}
#line 526 "UUlib.xs"
        if (newmode)
	  li->mode = newmode;
        RETVAL = li->mode;
#line 1143 "UUlib.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib__Item_uudet); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib__Item_uudet)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::Item::uudet", "li");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	uulist *	li;
	short	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "Convert::UUlib::Item")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    li = (uulist *) tmp;
	}
	else
	    croak("li is not of type Convert::UUlib::Item");
#line 536 "UUlib.xs"
        RETVAL = li->uudet;
#line 1174 "UUlib.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib__Item_size); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib__Item_size)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::Item::size", "li");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	uulist *	li;
	long	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "Convert::UUlib::Item")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    li = (uulist *) tmp;
	}
	else
	    croak("li is not of type Convert::UUlib::Item");
#line 544 "UUlib.xs"
        RETVAL = li->size;
#line 1205 "UUlib.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib__Item_filename); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib__Item_filename)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items < 1 || items > 2)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::Item::filename", "li, newfilename = 0");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	uulist *	li;
	char *	newfilename;
	char *	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "Convert::UUlib::Item")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    li = (uulist *) tmp;
	}
	else
	    croak("li is not of type Convert::UUlib::Item");

	if (items < 2)
	    newfilename = 0;
	else {
	    newfilename = (char *)SvPV_nolen(ST(1));
	}
#line 553 "UUlib.xs"
        if (newfilename)
	  {
            _FP_free (li->filename);
	    li->filename = _FP_strdup (newfilename);
          }
        RETVAL = li->filename;
#line 1248 "UUlib.c"
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib__Item_subfname); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib__Item_subfname)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::Item::subfname", "li");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	uulist *	li;
	char *	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "Convert::UUlib::Item")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    li = (uulist *) tmp;
	}
	else
	    croak("li is not of type Convert::UUlib::Item");
#line 566 "UUlib.xs"
        RETVAL = li->subfname;
#line 1279 "UUlib.c"
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib__Item_mimeid); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib__Item_mimeid)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::Item::mimeid", "li");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	uulist *	li;
	char *	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "Convert::UUlib::Item")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    li = (uulist *) tmp;
	}
	else
	    croak("li is not of type Convert::UUlib::Item");
#line 574 "UUlib.xs"
        RETVAL = li->mimeid;
#line 1310 "UUlib.c"
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib__Item_mimetype); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib__Item_mimetype)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::Item::mimetype", "li");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	uulist *	li;
	char *	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "Convert::UUlib::Item")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    li = (uulist *) tmp;
	}
	else
	    croak("li is not of type Convert::UUlib::Item");
#line 582 "UUlib.xs"
        RETVAL = li->mimetype;
#line 1341 "UUlib.c"
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib__Item_binfile); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib__Item_binfile)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::Item::binfile", "li");
    PERL_UNUSED_VAR(cv); /* -W */
    {
	uulist *	li;
	char *	RETVAL;
	dXSTARG;

	if (sv_derived_from(ST(0), "Convert::UUlib::Item")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    li = (uulist *) tmp;
	}
	else
	    croak("li is not of type Convert::UUlib::Item");
#line 590 "UUlib.xs"
        RETVAL = li->binfile;
#line 1372 "UUlib.c"
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}


XS(XS_Convert__UUlib__Item_parts); /* prototype to pass -Wmissing-prototypes */
XS(XS_Convert__UUlib__Item_parts)
{
#ifdef dVAR
    dVAR; dXSARGS;
#else
    dXSARGS;
#endif
    if (items != 1)
       Perl_croak(aTHX_ "Usage: %s(%s)", "Convert::UUlib::Item::parts", "li");
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	uulist *	li;

	if (sv_derived_from(ST(0), "Convert::UUlib::Item")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    li = (uulist *) tmp;
	}
	else
	    croak("li is not of type Convert::UUlib::Item");
#line 600 "UUlib.xs"
	{
        	struct _uufile *p = li->thisfile;

                while (p)
                  {
                    HV *pi = newHV ();

                    hv_store (pi, "partno"  , 6, newSViv (p->partno)         , 0);

                    if (p->filename)
                      hv_store (pi, "filename", 8, newSVpv (p->filename, 0)    , 0);
                    if(p->subfname)
                      hv_store (pi, "subfname", 8, newSVpv (p->subfname, 0)    , 0);
                    if(p->mimeid)
                      hv_store (pi, "mimeid"  , 6, newSVpv (p->mimeid  , 0)    , 0);
                    if(p->mimetype)
                      hv_store (pi, "mimetype", 8, newSVpv (p->mimetype, 0)    , 0);
                    if (p->data->subject)
                      hv_store (pi, "subject" , 7, newSVpv (p->data->subject,0), 0);
                    if (p->data->origin)
                      hv_store (pi, "origin"  , 6, newSVpv (p->data->origin ,0), 0);
                    if (p->data->sfname)
                      hv_store (pi, "sfname"  , 6, newSVpv (p->data->sfname ,0), 0);

                    XPUSHs (sv_2mortal (newRV_noinc ((SV *)pi)));

                    p = p->NEXT;
                  }
        }
#line 1431 "UUlib.c"
	PUTBACK;
	return;
    }
}

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

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

        newXSproto("Convert::UUlib::constant", XS_Convert__UUlib_constant, file, "$");
        newXSproto("Convert::UUlib::Initialize", XS_Convert__UUlib_Initialize, file, "");
        newXSproto("Convert::UUlib::CleanUp", XS_Convert__UUlib_CleanUp, file, "");
        newXSproto("Convert::UUlib::GetOption", XS_Convert__UUlib_GetOption, file, "$");
        newXSproto("Convert::UUlib::SetOption", XS_Convert__UUlib_SetOption, file, "$$");
        newXSproto("Convert::UUlib::strerror", XS_Convert__UUlib_strerror, file, "$");
        newXSproto("Convert::UUlib::SetMsgCallback", XS_Convert__UUlib_SetMsgCallback, file, ";$");
        newXSproto("Convert::UUlib::SetBusyCallback", XS_Convert__UUlib_SetBusyCallback, file, ";$$");
        newXSproto("Convert::UUlib::SetFileCallback", XS_Convert__UUlib_SetFileCallback, file, ";$");
        newXSproto("Convert::UUlib::SetFNameFilter", XS_Convert__UUlib_SetFNameFilter, file, ";$");
        newXSproto("Convert::UUlib::SetFileNameCallback", XS_Convert__UUlib_SetFileNameCallback, file, ";$");
        newXSproto("Convert::UUlib::FNameFilter", XS_Convert__UUlib_FNameFilter, file, "$");
        newXSproto("Convert::UUlib::LoadFile", XS_Convert__UUlib_LoadFile, file, "$;$$$");
        newXSproto("Convert::UUlib::Smerge", XS_Convert__UUlib_Smerge, file, "$");
        newXSproto("Convert::UUlib::QuickDecode", XS_Convert__UUlib_QuickDecode, file, "$$$$");
        newXSproto("Convert::UUlib::EncodeMulti", XS_Convert__UUlib_EncodeMulti, file, "$$$$$$$");
        newXSproto("Convert::UUlib::EncodePartial", XS_Convert__UUlib_EncodePartial, file, "$$$$$$$$$");
        newXSproto("Convert::UUlib::EncodeToStream", XS_Convert__UUlib_EncodeToStream, file, "$$$$$$");
        newXSproto("Convert::UUlib::EncodeToFile", XS_Convert__UUlib_EncodeToFile, file, "$$$$$$");
        newXSproto("Convert::UUlib::E_PrepSingle", XS_Convert__UUlib_E_PrepSingle, file, "$$$$$$$$$$");
        newXSproto("Convert::UUlib::E_PrepPartial", XS_Convert__UUlib_E_PrepPartial, file, "$$$$$$$$$$$$$");
        newXSproto("Convert::UUlib::GetFileListItem", XS_Convert__UUlib_GetFileListItem, file, "$");
        newXSproto("Convert::UUlib::Item::rename", XS_Convert__UUlib__Item_rename, file, "$$");
        newXSproto("Convert::UUlib::Item::decode_temp", XS_Convert__UUlib__Item_decode_temp, file, "$");
        newXSproto("Convert::UUlib::Item::remove_temp", XS_Convert__UUlib__Item_remove_temp, file, "$");
        newXSproto("Convert::UUlib::Item::decode", XS_Convert__UUlib__Item_decode, file, "$;$");
        newXSproto("Convert::UUlib::Item::info", XS_Convert__UUlib__Item_info, file, "$$");
        newXSproto("Convert::UUlib::Item::state", XS_Convert__UUlib__Item_state, file, "$");
        newXSproto("Convert::UUlib::Item::mode", XS_Convert__UUlib__Item_mode, file, "$;$");
        newXSproto("Convert::UUlib::Item::uudet", XS_Convert__UUlib__Item_uudet, file, "$");
        newXSproto("Convert::UUlib::Item::size", XS_Convert__UUlib__Item_size, file, "$");
        newXSproto("Convert::UUlib::Item::filename", XS_Convert__UUlib__Item_filename, file, "$;$");
        newXSproto("Convert::UUlib::Item::subfname", XS_Convert__UUlib__Item_subfname, file, "$");
        newXSproto("Convert::UUlib::Item::mimeid", XS_Convert__UUlib__Item_mimeid, file, "$");
        newXSproto("Convert::UUlib::Item::mimetype", XS_Convert__UUlib__Item_mimetype, file, "$");
        newXSproto("Convert::UUlib::Item::binfile", XS_Convert__UUlib__Item_binfile, file, "$");
        newXSproto("Convert::UUlib::Item::parts", XS_Convert__UUlib__Item_parts, file, "$");

    /* Initialisation Section */

#line 631 "UUlib.xs"
  uu_msg_sv		= newSVsv (&PL_sv_undef);
  uu_busy_sv		= newSVsv (&PL_sv_undef);
  uu_file_sv		= newSVsv (&PL_sv_undef);
  uu_fnamefilter_sv	= newSVsv (&PL_sv_undef);
  uu_filename_sv	= newSVsv (&PL_sv_undef);

#line 1501 "UUlib.c"

    /* End of Initialisation Section */

    XSRETURN_YES;
}