Convert-UUlib/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 on this architecture", 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_BRACKPOL")) return UUOPT_BRACKPOL;
        if (strEQ(name, "OPT_DEBUG")) return UUOPT_DEBUG;
        if (strEQ(name, "OPT_DESPERATE")) return UUOPT_DESPERATE;
        if (strEQ(name, "OPT_DUMBNESS")) return UUOPT_DUMBNESS;
        if (strEQ(name, "OPT_ENCEXT")) return UUOPT_ENCEXT;
        if (strEQ(name, "OPT_ERRNO")) return UUOPT_ERRNO;
        if (strEQ(name, "OPT_FAST")) return UUOPT_FAST;
        if (strEQ(name, "OPT_IGNMODE")) return UUOPT_IGNMODE;
        if (strEQ(name, "OPT_IGNREPLY")) return UUOPT_IGNREPLY;
        if (strEQ(name, "OPT_OVERWRITE")) return UUOPT_OVERWRITE;
        if (strEQ(name, "OPT_PREAMB")) return UUOPT_PREAMB;
        if (strEQ(name, "OPT_PROGRESS")) return UUOPT_PROGRESS;
        if (strEQ(name, "OPT_SAVEPATH")) return UUOPT_SAVEPATH;
        if (strEQ(name, "OPT_TINYB64")) return UUOPT_TINYB64;
        if (strEQ(name, "OPT_USETEXT")) return UUOPT_USETEXT;
        if (strEQ(name, "OPT_VERBOSE")) return UUOPT_VERBOSE;
        if (strEQ(name, "OPT_VERSION")) return UUOPT_VERSION;
        if (strEQ(name, "OPT_REMOVE")) return UUOPT_REMOVE;
        if (strEQ(name, "OPT_MOREMIME")) return UUOPT_MOREMIME;
    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, "B64ENCODED")) 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 returned more than one argument");

  _FP_free(str); str = _FP_strdup (POPp);

  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);
  STRLEN dc;
  
  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 returned more than one argument");

  strcpy (fname, SvPV (xfname, dc));

  retval = POPi;

  PUTBACK; FREETMPS; LEAVE;

  return retval;
}

static char *uu_filename_callback (void *cb, char *subject, char *filename)
{
  dSP;
  int count;
  SV *retval;
  STRLEN dc;
  
  ENTER; SAVETMPS; PUSHMARK(SP); EXTEND(SP,3);

  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 returned more than one argument");

  if (count)
    {
      _FP_free (filename);

      retval = POPs;

      if (SvOK (retval))
        {
          STRLEN len;
          char *fn = SvPV (retval, len);

          filename = malloc (len + 1);

          if (filename)
            {
              memcpy (filename, fn, len);
              filename[len] = 0;
            }
        }
      else
        filename = 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;

MODULE = Convert::UUlib         PACKAGE = Convert::UUlib                PREFIX = UU

PROTOTYPES: ENABLE

int
constant(name)
        char *          name


void
UUInitialize()
        CODE:
        if (!uu_initialized)
          {
            int retval;
            
            if ((retval = UUInitialize ()) != UURET_OK)
              croak ("unable to initialize uudeview library (%s)", UUstrerror (retval));
 
            uu_initialized = 1;
          }

void
UUCleanUp()
        CODE:
        if (uu_initialized)
          UUCleanUp ();

        uu_initialized = 0; 

SV *
UUGetOption(opt)
        int     opt
        CODE:
        {
                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));
                  }
        }
        OUTPUT:
        RETVAL

int
UUSetOption(opt,val)
        int     opt
        SV *    val
        CODE:
        {
                STRLEN dc;

                if (uu_opt_isstring (opt))
                  RETVAL = UUSetOption (opt, 0, SvPV (val, dc));
                else
                  RETVAL = UUSetOption (opt, SvIV (val), (void *)0);
        }
        OUTPUT:
        RETVAL

char *
UUstrerror(errcode)
        int     errcode

void
UUSetMsgCallback(func=0)
        SV *    func
        CODE:
        UUSetMsgCallback (FUNC_CB(uu_msg));

void
UUSetBusyCallback(func=0,msecs=1000)
        SV *    func
        long    msecs
        CODE:
        UUSetBusyCallback (FUNC_CB(uu_busy), msecs);

void
UUSetFileCallback(func=0)
        SV *    func
        CODE:
        UUSetFileCallback (FUNC_CB(uu_file));

void
UUSetFNameFilter(func=0)
        SV *    func
        CODE:
        UUSetFNameFilter (FUNC_CB(uu_fnamefilter));

void
UUSetFileNameCallback(func=0)
        SV *    func
        CODE:
        UUSetFileNameCallback (FUNC_CB(uu_filename));

char *
UUFNameFilter(fname)
        char *  fname

void
UULoadFile(fname,id=0,delflag=0)
        char *  fname
        char *  id
        int     delflag
        PPCODE:
        {       
                int count;
                
                XPUSHs(sv_2mortal(newSViv(UULoadFile (fname, id, delflag, &count))));
                if (GIMME_V == G_ARRAY)
                  XPUSHs(sv_2mortal(newSViv(count)));
        }

int
UUSmerge(pass)
        int     pass

int
UUQuickDecode(datain,dataout,boundary,maxpos)
        FILE *  datain
        FILE *  dataout
        char *  boundary
        long    maxpos

int
UUEncodeMulti(outfile,infile,infname,encoding,outfname,mimetype,filemode)
        FILE *  outfile
        FILE *  infile
        char *  infname
        int     encoding
        char *  outfname
        char *  mimetype
        int     filemode

int
UUEncodePartial(outfile,infile,infname,encoding,outfname,mimetype,filemode,partno,linperfile)
        FILE *  outfile
        FILE *  infile
        char *  infname
        int     encoding
        char *  outfname
        char *  mimetype
        int     filemode
        int     partno
        long    linperfile

int
UUEncodeToStream(outfile,infile,infname,encoding,outfname,filemode)
        FILE *  outfile
        FILE *  infile
        char *  infname
        int     encoding
        char *  outfname
        int     filemode

int
UUEncodeToFile(infile,infname,encoding,outfname,diskname,linperfile)
        FILE *  infile
        char *  infname
        int     encoding
        char *  outfname
        char *  diskname
        long    linperfile

int
UUE_PrepSingle(outfile,infile,infname,encoding,outfname,filemode,destination,from,subject,isemail)
        FILE *  outfile
        FILE *  infile
        char *  infname
        int     encoding
        char *  outfname
        int     filemode
        char *  destination
        char *  from
        char *  subject
        int     isemail

int
UUE_PrepPartial(outfile,infile,infname,encoding,outfname,filemode,partno,linperfile,filesize,destination,from,subject,isemail)
        FILE *  outfile
        FILE *  infile
        char *  infname
        int     encoding
        char *  outfname
        int     filemode
        int     partno
        long    linperfile
        long    filesize
        char *  destination
        char *  from
        char *  subject
        int     isemail

uulist *
UUGetFileListItem(num)
        int     num

int
UURenameFile(item,newname)
        uulist *item
        char *  newname
        ALIAS:
        Convert::UUlib::Item::rename = 1

int
UUDecodeToTemp(item)
        uulist *item
        ALIAS:
        Convert::UUlib::Item::decode_temp = 1

int
UURemoveTemp(item)
        uulist *item
        ALIAS:
        Convert::UUlib::Item::remove_temp = 1

int
UUDecodeFile(item,target=0)
        uulist *item
        char *  target
        ALIAS:
        Convert::UUlib::Item::decode = 1

void
UUInfoFile(item,func)
        uulist *item
        SV *    func
        CODE:
        UUInfoFile(item,(void *)func,uu_info_file);
        ALIAS:
        Convert::UUlib::Item::info = 1

MODULE = Convert::UUlib         PACKAGE = Convert::UUlib::Item

short
state(li)
        uulist *li
        CODE:
        RETVAL = li->state;
        OUTPUT:
        RETVAL

short
mode(li,newmode=0)
        uulist *li
        short   newmode
        CODE:
        if (newmode)
          li->mode = newmode;
        RETVAL = li->mode;
        OUTPUT:
        RETVAL

short
uudet(li)
        uulist *li
        CODE:
        RETVAL = li->uudet;
        OUTPUT:
        RETVAL

long
size(li)
        uulist *li
        CODE:
        RETVAL = li->size;
        OUTPUT:
        RETVAL

char *
filename(li,newfilename=0)
        uulist *li
        char *  newfilename
        CODE:
        if (newfilename)
          {
            _FP_free (li->filename);
            li->filename = _FP_strdup (newfilename);
          }
        RETVAL = li->filename;
        OUTPUT:
        RETVAL

char *
subfname(li)
        uulist *li
        CODE:
        RETVAL = li->subfname;
        OUTPUT:
        RETVAL

char *
mimeid(li)
        uulist *li
        CODE:
        RETVAL = li->mimeid;
        OUTPUT:
        RETVAL

char *
mimetype(li)
        uulist *li
        CODE:
        RETVAL = li->mimetype;
        OUTPUT:
        RETVAL

char *
binfile(li)
        uulist *li
        CODE:
        RETVAL = li->binfile;
        OUTPUT:
        RETVAL

# functions accessing internal data(!)

void
parts(li)
        uulist *li
        PPCODE:
        {
                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;
                  }
        }

BOOT:
  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);

Revision:	1.5
Committed:	Sun Mar 31 21:42:35 2002 UTC (22 years, 1 month ago) by root
Branch:	MAIN
Changes since 1.4:	+57 -5 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	#include "EXTERN.h"
2			#include "perl.h"
3			#include "XSUB.h"
4
5			#include "uulib/fptools.h"
6	root	1.2	#include "uulib/uudeview.h"
7	root	1.1	#include "uulib/uuint.h"
8
9			static int
10			not_here(char *s)
11			{
12			croak("%s not implemented on this architecture", s);
13			return -1;
14			}
15
16			static int
17			constant(char *name)
18			{
19			errno = 0;
20			switch (*name) {
21			case 'A':
22			if (strEQ(name, "ACT_COPYING")) return UUACT_COPYING;
23			if (strEQ(name, "ACT_DECODING")) return UUACT_DECODING;
24			if (strEQ(name, "ACT_ENCODING")) return UUACT_ENCODING;
25			if (strEQ(name, "ACT_IDLE")) return UUACT_IDLE;
26			if (strEQ(name, "ACT_SCANNING")) return UUACT_SCANNING;
27			case 'F':
28			if (strEQ(name, "FILE_DECODED")) return UUFILE_DECODED;
29			if (strEQ(name, "FILE_ERROR")) return UUFILE_ERROR;
30			if (strEQ(name, "FILE_MISPART")) return UUFILE_MISPART;
31			if (strEQ(name, "FILE_NOBEGIN")) return UUFILE_NOBEGIN;
32			if (strEQ(name, "FILE_NODATA")) return UUFILE_NODATA;
33			if (strEQ(name, "FILE_NOEND")) return UUFILE_NOEND;
34			if (strEQ(name, "FILE_OK")) return UUFILE_OK;
35			if (strEQ(name, "FILE_READ")) return UUFILE_READ;
36			if (strEQ(name, "FILE_TMPFILE")) return UUFILE_TMPFILE;
37			break;
38			case 'M':
39			if (strEQ(name, "MSG_ERROR")) return UUMSG_ERROR;
40			if (strEQ(name, "MSG_FATAL")) return UUMSG_FATAL;
41			if (strEQ(name, "MSG_MESSAGE")) return UUMSG_MESSAGE;
42			if (strEQ(name, "MSG_NOTE")) return UUMSG_NOTE;
43			if (strEQ(name, "MSG_PANIC")) return UUMSG_PANIC;
44			if (strEQ(name, "MSG_WARNING")) return UUMSG_WARNING;
45			case 'O':
46			if (strEQ(name, "OPT_BRACKPOL")) return UUOPT_BRACKPOL;
47			if (strEQ(name, "OPT_DEBUG")) return UUOPT_DEBUG;
48			if (strEQ(name, "OPT_DESPERATE")) return UUOPT_DESPERATE;
49			if (strEQ(name, "OPT_DUMBNESS")) return UUOPT_DUMBNESS;
50			if (strEQ(name, "OPT_ENCEXT")) return UUOPT_ENCEXT;
51			if (strEQ(name, "OPT_ERRNO")) return UUOPT_ERRNO;
52			if (strEQ(name, "OPT_FAST")) return UUOPT_FAST;
53			if (strEQ(name, "OPT_IGNMODE")) return UUOPT_IGNMODE;
54			if (strEQ(name, "OPT_IGNREPLY")) return UUOPT_IGNREPLY;
55			if (strEQ(name, "OPT_OVERWRITE")) return UUOPT_OVERWRITE;
56			if (strEQ(name, "OPT_PREAMB")) return UUOPT_PREAMB;
57			if (strEQ(name, "OPT_PROGRESS")) return UUOPT_PROGRESS;
58			if (strEQ(name, "OPT_SAVEPATH")) return UUOPT_SAVEPATH;
59			if (strEQ(name, "OPT_TINYB64")) return UUOPT_TINYB64;
60			if (strEQ(name, "OPT_USETEXT")) return UUOPT_USETEXT;
61			if (strEQ(name, "OPT_VERBOSE")) return UUOPT_VERBOSE;
62			if (strEQ(name, "OPT_VERSION")) return UUOPT_VERSION;
63	root	1.2	if (strEQ(name, "OPT_REMOVE")) return UUOPT_REMOVE;
64			if (strEQ(name, "OPT_MOREMIME")) return UUOPT_MOREMIME;
65	root	1.1	case 'R':
66			if (strEQ(name, "RET_CANCEL")) return UURET_CANCEL;
67			if (strEQ(name, "RET_CONT")) return UURET_CONT;
68			if (strEQ(name, "RET_EXISTS")) return UURET_EXISTS;
69			if (strEQ(name, "RET_ILLVAL")) return UURET_ILLVAL;
70			if (strEQ(name, "RET_IOERR")) return UURET_IOERR;
71			if (strEQ(name, "RET_NODATA")) return UURET_NODATA;
72			if (strEQ(name, "RET_NOEND")) return UURET_NOEND;
73			if (strEQ(name, "RET_NOMEM")) return UURET_NOMEM;
74			if (strEQ(name, "RET_OK")) return UURET_OK;
75			if (strEQ(name, "RET_UNSUP")) return UURET_UNSUP;
76			case 'B':
77			if (strEQ(name, "B64ENCODED")) return B64ENCODED;
78			if (strEQ(name, "BH_ENCODED")) return BH_ENCODED;
79			case 'P':
80			if (strEQ(name, "PT_ENCODED")) return PT_ENCODED;
81			case 'Q':
82			if (strEQ(name, "QP_ENCODED")) return QP_ENCODED;
83			case 'U':
84			if (strEQ(name, "UU_ENCODED")) return UU_ENCODED;
85			case 'X':
86			if (strEQ(name, "XX_ENCODED")) return XX_ENCODED;
87	root	1.3	case 'Y':
88			if (strEQ(name, "YENC_ENCODED")) return YENC_ENCODED;
89	root	1.1	}
90			errno = EINVAL;
91			return 0;
92			}
93
94			static void uu_msg_callback (void cb, char msg, int level)
95			{
96			dSP;
97
98			ENTER; SAVETMPS; PUSHMARK(SP); EXTEND(SP,2);
99
100			PUSHs(sv_2mortal(newSVpv(msg,0)));
101			PUSHs(sv_2mortal(newSViv(level)));
102
103			PUTBACK; (void) perl_call_sv ((SV *)cb, G_VOID\|G_DISCARD); SPAGAIN;
104			PUTBACK; FREETMPS; LEAVE;
105			}
106
107			static int uu_busy_callback (void cb, uuprogress uup)
108			{
109			dSP;
110			int count;
111			int retval;
112
113			ENTER; SAVETMPS; PUSHMARK(SP); EXTEND(SP,6);
114
115			PUSHs(sv_2mortal(newSViv(uup->action)));
116			PUSHs(sv_2mortal(newSVpv(uup->curfile,0)));
117			PUSHs(sv_2mortal(newSViv(uup->partno)));
118			PUSHs(sv_2mortal(newSViv(uup->numparts)));
119			PUSHs(sv_2mortal(newSViv(uup->fsize)));
120			PUSHs(sv_2mortal(newSViv(uup->percent)));
121
122			PUTBACK; count = perl_call_sv ((SV *)cb, G_SCALAR); SPAGAIN;
123
124			if (count != 1)
125			croak ("busycallback perl callback returned more than one argument");
126
127			retval = POPi;
128
129			PUTBACK; FREETMPS; LEAVE;
130
131			return retval;
132			}
133
134			static char uu_fnamefilter_callback (void cb, char *fname)
135			{
136			dSP;
137			int count;
138			static char *str;
139
140			ENTER; SAVETMPS; PUSHMARK(SP); EXTEND(SP,1);
141
142			PUSHs(sv_2mortal(newSVpv(fname,0)));
143
144			PUTBACK; count = perl_call_sv ((SV *)cb, G_SCALAR); SPAGAIN;
145
146			if (count != 1)
147			croak ("fnamefilter perl callback returned more than one argument");
148
149	root	1.4	_FP_free(str); str = _FP_strdup (POPp);
150	root	1.1
151			PUTBACK; FREETMPS; LEAVE;
152
153			return str;
154			}
155
156			static int uu_file_callback (void cb, char id, char *fname, int retrieve)
157			{
158			dSP;
159			int count;
160			int retval;
161			SV *xfname = newSVpv ("", 0);
162			STRLEN dc;
163
164			ENTER; SAVETMPS; PUSHMARK(SP); EXTEND(SP,3);
165
166			PUSHs(sv_2mortal(newSVpv(id,0)));
167			PUSHs(sv_2mortal(xfname));
168			PUSHs(sv_2mortal(newSViv(retrieve)));
169
170			PUTBACK; count = perl_call_sv ((SV *)cb, G_SCALAR); SPAGAIN;
171
172			if (count != 1)
173			croak ("filecallback perl callback returned more than one argument");
174
175			strcpy (fname, SvPV (xfname, dc));
176
177			retval = POPi;
178
179			PUTBACK; FREETMPS; LEAVE;
180
181			return retval;
182			}
183
184	root	1.5	static char uu_filename_callback (void cb, char subject, char filename)
185			{
186			dSP;
187			int count;
188			SV *retval;
189			STRLEN dc;
190
191			ENTER; SAVETMPS; PUSHMARK(SP); EXTEND(SP,3);
192
193			PUSHs(sv_2mortal(newSVpv(subject, 0)));
194			PUSHs(filename ? sv_2mortal(newSVpv(filename, 0)) : &PL_sv_undef);
195
196			PUTBACK; count = perl_call_sv ((SV *)cb, G_ARRAY); SPAGAIN;
197
198			if (count > 1)
199			croak ("filenamecallback perl callback returned more than one argument");
200
201			if (count)
202			{
203			_FP_free (filename);
204
205			retval = POPs;
206
207			if (SvOK (retval))
208			{
209			STRLEN len;
210			char *fn = SvPV (retval, len);
211
212			filename = malloc (len + 1);
213
214			if (filename)
215			{
216			memcpy (filename, fn, len);
217			filename[len] = 0;
218			}
219			}
220			else
221			filename = 0;
222			}
223
224			PUTBACK; FREETMPS; LEAVE;
225
226			return filename;
227			}
228
229			static SV uu_msg_sv, uu_busy_sv, uu_file_sv, uu_fnamefilter_sv, *uu_filename_sv;
230	root	1.1
231			#define FUNC_CB(cb) (void *)(sv_setsv (cb ## _sv, func), cb ## _sv), func ? cb ## _callback : NULL
232
233			static int uu_info_file(void cb, char info)
234			{
235			dSP;
236			int count;
237			int retval;
238
239			ENTER; SAVETMPS; PUSHMARK(SP); EXTEND(SP,1);
240
241			PUSHs(sv_2mortal(newSVpv(info,0)));
242
243			PUTBACK; count = perl_call_sv ((SV *)cb, G_SCALAR); SPAGAIN;
244
245			if (count != 1)
246			croak ("info_file perl callback returned more than one argument");
247
248			retval = POPi;
249
250			PUTBACK; FREETMPS; LEAVE;
251
252			return retval;
253			}
254
255			static int
256			uu_opt_isstring (int opt)
257			{
258			switch (opt)
259			{
260			case UUOPT_VERSION:
261			case UUOPT_SAVEPATH:
262			case UUOPT_ENCEXT:
263			return 1;
264			default:
265			return 0;
266			}
267			}
268
269			static int uu_initialized;
270
271			MODULE = Convert::UUlib PACKAGE = Convert::UUlib PREFIX = UU
272
273			PROTOTYPES: ENABLE
274
275			int
276			constant(name)
277			char * name
278
279
280			void
281			UUInitialize()
282			CODE:
283			if (!uu_initialized)
284			{
285			int retval;
286
287			if ((retval = UUInitialize ()) != UURET_OK)
288			croak ("unable to initialize uudeview library (%s)", UUstrerror (retval));
289
290			uu_initialized = 1;
291			}
292
293			void
294			UUCleanUp()
295			CODE:
296			if (uu_initialized)
297			UUCleanUp ();
298
299			uu_initialized = 0;
300
301			SV *
302			UUGetOption(opt)
303			int opt
304			CODE:
305			{
306			if (opt == UUOPT_PROGRESS)
307			croak ("GetOption(UUOPT_PROGRESS) is not yet implemented");
308			else if (uu_opt_isstring (opt))
309			{
310			char cval[8192];
311
312			UUGetOption (opt, 0, cval, sizeof cval);
313			RETVAL = newSVpv (cval, 0);
314			}
315			else
316			{
317			RETVAL = newSViv (UUGetOption (opt, 0, 0, 0));
318			}
319			}
320			OUTPUT:
321			RETVAL
322
323			int
324			UUSetOption(opt,val)
325			int opt
326			SV * val
327			CODE:
328			{
329			STRLEN dc;
330
331			if (uu_opt_isstring (opt))
332			RETVAL = UUSetOption (opt, 0, SvPV (val, dc));
333			else
334			RETVAL = UUSetOption (opt, SvIV (val), (void *)0);
335			}
336			OUTPUT:
337			RETVAL
338
339			char *
340			UUstrerror(errcode)
341			int errcode
342
343			void
344			UUSetMsgCallback(func=0)
345			SV * func
346			CODE:
347			UUSetMsgCallback (FUNC_CB(uu_msg));
348
349			void
350			UUSetBusyCallback(func=0,msecs=1000)
351			SV * func
352			long msecs
353			CODE:
354			UUSetBusyCallback (FUNC_CB(uu_busy), msecs);
355
356			void
357			UUSetFileCallback(func=0)
358			SV * func
359			CODE:
360			UUSetFileCallback (FUNC_CB(uu_file));
361
362			void
363			UUSetFNameFilter(func=0)
364			SV * func
365			CODE:
366			UUSetFNameFilter (FUNC_CB(uu_fnamefilter));
367
368	root	1.5	void
369			UUSetFileNameCallback(func=0)
370			SV * func
371			CODE:
372			UUSetFileNameCallback (FUNC_CB(uu_filename));
373
374	root	1.1	char *
375			UUFNameFilter(fname)
376			char * fname
377
378			void
379			UULoadFile(fname,id=0,delflag=0)
380			char * fname
381			char * id
382			int delflag
383			PPCODE:
384			{
385			int count;
386
387			XPUSHs(sv_2mortal(newSViv(UULoadFile (fname, id, delflag, &count))));
388			if (GIMME_V == G_ARRAY)
389			XPUSHs(sv_2mortal(newSViv(count)));
390			}
391
392			int
393			UUSmerge(pass)
394			int pass
395
396			int
397			UUQuickDecode(datain,dataout,boundary,maxpos)
398			FILE * datain
399			FILE * dataout
400			char * boundary
401			long maxpos
402
403			int
404			UUEncodeMulti(outfile,infile,infname,encoding,outfname,mimetype,filemode)
405			FILE * outfile
406			FILE * infile
407			char * infname
408			int encoding
409			char * outfname
410			char * mimetype
411			int filemode
412
413			int
414			UUEncodePartial(outfile,infile,infname,encoding,outfname,mimetype,filemode,partno,linperfile)
415			FILE * outfile
416			FILE * infile
417			char * infname
418			int encoding
419			char * outfname
420			char * mimetype
421			int filemode
422			int partno
423			long linperfile
424
425			int
426			UUEncodeToStream(outfile,infile,infname,encoding,outfname,filemode)
427			FILE * outfile
428			FILE * infile
429			char * infname
430			int encoding
431			char * outfname
432			int filemode
433
434			int
435			UUEncodeToFile(infile,infname,encoding,outfname,diskname,linperfile)
436			FILE * infile
437			char * infname
438			int encoding
439			char * outfname
440			char * diskname
441			long linperfile
442
443			int
444			UUE_PrepSingle(outfile,infile,infname,encoding,outfname,filemode,destination,from,subject,isemail)
445			FILE * outfile
446			FILE * infile
447			char * infname
448			int encoding
449			char * outfname
450			int filemode
451			char * destination
452			char * from
453			char * subject
454			int isemail
455
456			int
457			UUE_PrepPartial(outfile,infile,infname,encoding,outfname,filemode,partno,linperfile,filesize,destination,from,subject,isemail)
458			FILE * outfile
459			FILE * infile
460			char * infname
461			int encoding
462			char * outfname
463			int filemode
464			int partno
465			long linperfile
466			long filesize
467			char * destination
468			char * from
469			char * subject
470			int isemail
471
472			uulist *
473			UUGetFileListItem(num)
474			int num
475
476			int
477			UURenameFile(item,newname)
478			uulist *item
479			char * newname
480			ALIAS:
481			Convert::UUlib::Item::rename = 1
482
483			int
484			UUDecodeToTemp(item)
485			uulist *item
486			ALIAS:
487			Convert::UUlib::Item::decode_temp = 1
488
489			int
490			UURemoveTemp(item)
491			uulist *item
492			ALIAS:
493			Convert::UUlib::Item::remove_temp = 1
494
495			int
496			UUDecodeFile(item,target=0)
497			uulist *item
498			char * target
499			ALIAS:
500			Convert::UUlib::Item::decode = 1
501
502			void
503			UUInfoFile(item,func)
504			uulist *item
505			SV * func
506			CODE:
507			UUInfoFile(item,(void *)func,uu_info_file);
508			ALIAS:
509			Convert::UUlib::Item::info = 1
510
511			MODULE = Convert::UUlib PACKAGE = Convert::UUlib::Item
512
513			short
514			state(li)
515			uulist *li
516			CODE:
517			RETVAL = li->state;
518			OUTPUT:
519			RETVAL
520
521			short
522			mode(li,newmode=0)
523			uulist *li
524			short newmode
525			CODE:
526			if (newmode)
527			li->mode = newmode;
528			RETVAL = li->mode;
529			OUTPUT:
530			RETVAL
531
532			short
533			uudet(li)
534			uulist *li
535			CODE:
536			RETVAL = li->uudet;
537			OUTPUT:
538			RETVAL
539
540			long
541			size(li)
542			uulist *li
543			CODE:
544			RETVAL = li->size;
545			OUTPUT:
546			RETVAL
547
548			char *
549			filename(li,newfilename=0)
550			uulist *li
551			char * newfilename
552			CODE:
553			if (newfilename)
554			{
555	root	1.4	_FP_free (li->filename);
556			li->filename = _FP_strdup (newfilename);
557	root	1.1	}
558			RETVAL = li->filename;
559			OUTPUT:
560			RETVAL
561
562			char *
563			subfname(li)
564			uulist *li
565			CODE:
566			RETVAL = li->subfname;
567			OUTPUT:
568			RETVAL
569
570			char *
571			mimeid(li)
572			uulist *li
573			CODE:
574			RETVAL = li->mimeid;
575			OUTPUT:
576			RETVAL
577
578			char *
579			mimetype(li)
580			uulist *li
581			CODE:
582			RETVAL = li->mimetype;
583			OUTPUT:
584			RETVAL
585
586			char *
587			binfile(li)
588			uulist *li
589			CODE:
590			RETVAL = li->binfile;
591			OUTPUT:
592			RETVAL
593
594			# functions accessing internal data(!)
595
596			void
597			parts(li)
598			uulist *li
599			PPCODE:
600			{
601			struct _uufile *p = li->thisfile;
602
603			while (p)
604			{
605			HV *pi = newHV ();
606
607			hv_store (pi, "partno" , 6, newSViv (p->partno) , 0);
608
609			if (p->filename)
610			hv_store (pi, "filename", 8, newSVpv (p->filename, 0) , 0);
611			if(p->subfname)
612			hv_store (pi, "subfname", 8, newSVpv (p->subfname, 0) , 0);
613			if(p->mimeid)
614			hv_store (pi, "mimeid" , 6, newSVpv (p->mimeid , 0) , 0);
615			if(p->mimetype)
616			hv_store (pi, "mimetype", 8, newSVpv (p->mimetype, 0) , 0);
617			if (p->data->subject)
618			hv_store (pi, "subject" , 7, newSVpv (p->data->subject,0), 0);
619			if (p->data->origin)
620			hv_store (pi, "origin" , 6, newSVpv (p->data->origin ,0), 0);
621			if (p->data->sfname)
622			hv_store (pi, "sfname" , 6, newSVpv (p->data->sfname ,0), 0);
623
624			XPUSHs (sv_2mortal (newRV_noinc ((SV *)pi)));
625
626			p = p->NEXT;
627			}
628			}
629
630			BOOT:
631	root	1.5	uu_msg_sv = newSVsv(&PL_sv_undef);
632			uu_busy_sv = newSVsv(&PL_sv_undef);
633			uu_file_sv = newSVsv(&PL_sv_undef);
634			uu_fnamefilter_sv = newSVsv(&PL_sv_undef);
635			uu_filename_sv = newSVsv(&PL_sv_undef);
636	root	1.1