Convert-UUlib/UUlib.xs

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include "uulib/fptools.h"
#include "uulib/uulib.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;
    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;
    }
    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 SV *uu_msg_sv, *uu_busy_sv, *uu_file_sv, *uu_fnamefilter_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));

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

Revision:	1.1
Committed:	Mon Jun 11 19:48:55 2001 UTC (22 years, 11 months ago) by root
Branch:	MAIN
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			#include "uulib/uulib.h"
7			#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			case 'R':
64			if (strEQ(name, "RET_CANCEL")) return UURET_CANCEL;
65			if (strEQ(name, "RET_CONT")) return UURET_CONT;
66			if (strEQ(name, "RET_EXISTS")) return UURET_EXISTS;
67			if (strEQ(name, "RET_ILLVAL")) return UURET_ILLVAL;
68			if (strEQ(name, "RET_IOERR")) return UURET_IOERR;
69			if (strEQ(name, "RET_NODATA")) return UURET_NODATA;
70			if (strEQ(name, "RET_NOEND")) return UURET_NOEND;
71			if (strEQ(name, "RET_NOMEM")) return UURET_NOMEM;
72			if (strEQ(name, "RET_OK")) return UURET_OK;
73			if (strEQ(name, "RET_UNSUP")) return UURET_UNSUP;
74			case 'B':
75			if (strEQ(name, "B64ENCODED")) return B64ENCODED;
76			if (strEQ(name, "BH_ENCODED")) return BH_ENCODED;
77			case 'P':
78			if (strEQ(name, "PT_ENCODED")) return PT_ENCODED;
79			case 'Q':
80			if (strEQ(name, "QP_ENCODED")) return QP_ENCODED;
81			case 'U':
82			if (strEQ(name, "UU_ENCODED")) return UU_ENCODED;
83			case 'X':
84			if (strEQ(name, "XX_ENCODED")) return XX_ENCODED;
85			}
86			errno = EINVAL;
87			return 0;
88			}
89
90			static void uu_msg_callback (void cb, char msg, int level)
91			{
92			dSP;
93
94			ENTER; SAVETMPS; PUSHMARK(SP); EXTEND(SP,2);
95
96			PUSHs(sv_2mortal(newSVpv(msg,0)));
97			PUSHs(sv_2mortal(newSViv(level)));
98
99			PUTBACK; (void) perl_call_sv ((SV *)cb, G_VOID\|G_DISCARD); SPAGAIN;
100			PUTBACK; FREETMPS; LEAVE;
101			}
102
103			static int uu_busy_callback (void cb, uuprogress uup)
104			{
105			dSP;
106			int count;
107			int retval;
108
109			ENTER; SAVETMPS; PUSHMARK(SP); EXTEND(SP,6);
110
111			PUSHs(sv_2mortal(newSViv(uup->action)));
112			PUSHs(sv_2mortal(newSVpv(uup->curfile,0)));
113			PUSHs(sv_2mortal(newSViv(uup->partno)));
114			PUSHs(sv_2mortal(newSViv(uup->numparts)));
115			PUSHs(sv_2mortal(newSViv(uup->fsize)));
116			PUSHs(sv_2mortal(newSViv(uup->percent)));
117
118			PUTBACK; count = perl_call_sv ((SV *)cb, G_SCALAR); SPAGAIN;
119
120			if (count != 1)
121			croak ("busycallback perl callback returned more than one argument");
122
123			retval = POPi;
124
125			PUTBACK; FREETMPS; LEAVE;
126
127			return retval;
128			}
129
130			static char uu_fnamefilter_callback (void cb, char *fname)
131			{
132			dSP;
133			int count;
134			static char *str;
135
136			ENTER; SAVETMPS; PUSHMARK(SP); EXTEND(SP,1);
137
138			PUSHs(sv_2mortal(newSVpv(fname,0)));
139
140			PUTBACK; count = perl_call_sv ((SV *)cb, G_SCALAR); SPAGAIN;
141
142			if (count != 1)
143			croak ("fnamefilter perl callback returned more than one argument");
144
145			FP_free(str); str = FP_strdup (POPp);
146
147			PUTBACK; FREETMPS; LEAVE;
148
149			return str;
150			}
151
152			static int uu_file_callback (void cb, char id, char *fname, int retrieve)
153			{
154			dSP;
155			int count;
156			int retval;
157			SV *xfname = newSVpv ("", 0);
158			STRLEN dc;
159
160			ENTER; SAVETMPS; PUSHMARK(SP); EXTEND(SP,3);
161
162			PUSHs(sv_2mortal(newSVpv(id,0)));
163			PUSHs(sv_2mortal(xfname));
164			PUSHs(sv_2mortal(newSViv(retrieve)));
165
166			PUTBACK; count = perl_call_sv ((SV *)cb, G_SCALAR); SPAGAIN;
167
168			if (count != 1)
169			croak ("filecallback perl callback returned more than one argument");
170
171			strcpy (fname, SvPV (xfname, dc));
172
173			retval = POPi;
174
175			PUTBACK; FREETMPS; LEAVE;
176
177			return retval;
178			}
179
180			static SV uu_msg_sv, uu_busy_sv, uu_file_sv, uu_fnamefilter_sv;
181
182			#define FUNC_CB(cb) (void *)(sv_setsv (cb ## _sv, func), cb ## _sv), func ? cb ## _callback : NULL
183
184			static int uu_info_file(void cb, char info)
185			{
186			dSP;
187			int count;
188			int retval;
189
190			ENTER; SAVETMPS; PUSHMARK(SP); EXTEND(SP,1);
191
192			PUSHs(sv_2mortal(newSVpv(info,0)));
193
194			PUTBACK; count = perl_call_sv ((SV *)cb, G_SCALAR); SPAGAIN;
195
196			if (count != 1)
197			croak ("info_file perl callback returned more than one argument");
198
199			retval = POPi;
200
201			PUTBACK; FREETMPS; LEAVE;
202
203			return retval;
204			}
205
206			static int
207			uu_opt_isstring (int opt)
208			{
209			switch (opt)
210			{
211			case UUOPT_VERSION:
212			case UUOPT_SAVEPATH:
213			case UUOPT_ENCEXT:
214			return 1;
215			default:
216			return 0;
217			}
218			}
219
220			static int uu_initialized;
221
222			MODULE = Convert::UUlib PACKAGE = Convert::UUlib PREFIX = UU
223
224			PROTOTYPES: ENABLE
225
226			int
227			constant(name)
228			char * name
229
230
231			void
232			UUInitialize()
233			CODE:
234			if (!uu_initialized)
235			{
236			int retval;
237
238			if ((retval = UUInitialize ()) != UURET_OK)
239			croak ("unable to initialize uudeview library (%s)", UUstrerror (retval));
240
241			uu_initialized = 1;
242			}
243
244			void
245			UUCleanUp()
246			CODE:
247			if (uu_initialized)
248			UUCleanUp ();
249
250			uu_initialized = 0;
251
252			SV *
253			UUGetOption(opt)
254			int opt
255			CODE:
256			{
257			if (opt == UUOPT_PROGRESS)
258			croak ("GetOption(UUOPT_PROGRESS) is not yet implemented");
259			else if (uu_opt_isstring (opt))
260			{
261			char cval[8192];
262
263			UUGetOption (opt, 0, cval, sizeof cval);
264			RETVAL = newSVpv (cval, 0);
265			}
266			else
267			{
268			RETVAL = newSViv (UUGetOption (opt, 0, 0, 0));
269			}
270			}
271			OUTPUT:
272			RETVAL
273
274			int
275			UUSetOption(opt,val)
276			int opt
277			SV * val
278			CODE:
279			{
280			STRLEN dc;
281
282			if (uu_opt_isstring (opt))
283			RETVAL = UUSetOption (opt, 0, SvPV (val, dc));
284			else
285			RETVAL = UUSetOption (opt, SvIV (val), (void *)0);
286			}
287			OUTPUT:
288			RETVAL
289
290			char *
291			UUstrerror(errcode)
292			int errcode
293
294			void
295			UUSetMsgCallback(func=0)
296			SV * func
297			CODE:
298			UUSetMsgCallback (FUNC_CB(uu_msg));
299
300			void
301			UUSetBusyCallback(func=0,msecs=1000)
302			SV * func
303			long msecs
304			CODE:
305			UUSetBusyCallback (FUNC_CB(uu_busy), msecs);
306
307			void
308			UUSetFileCallback(func=0)
309			SV * func
310			CODE:
311			UUSetFileCallback (FUNC_CB(uu_file));
312
313			void
314			UUSetFNameFilter(func=0)
315			SV * func
316			CODE:
317			UUSetFNameFilter (FUNC_CB(uu_fnamefilter));
318
319			char *
320			UUFNameFilter(fname)
321			char * fname
322
323			void
324			UULoadFile(fname,id=0,delflag=0)
325			char * fname
326			char * id
327			int delflag
328			PPCODE:
329			{
330			int count;
331
332			XPUSHs(sv_2mortal(newSViv(UULoadFile (fname, id, delflag, &count))));
333			if (GIMME_V == G_ARRAY)
334			XPUSHs(sv_2mortal(newSViv(count)));
335			}
336
337			int
338			UUSmerge(pass)
339			int pass
340
341			int
342			UUQuickDecode(datain,dataout,boundary,maxpos)
343			FILE * datain
344			FILE * dataout
345			char * boundary
346			long maxpos
347
348			int
349			UUEncodeMulti(outfile,infile,infname,encoding,outfname,mimetype,filemode)
350			FILE * outfile
351			FILE * infile
352			char * infname
353			int encoding
354			char * outfname
355			char * mimetype
356			int filemode
357
358			int
359			UUEncodePartial(outfile,infile,infname,encoding,outfname,mimetype,filemode,partno,linperfile)
360			FILE * outfile
361			FILE * infile
362			char * infname
363			int encoding
364			char * outfname
365			char * mimetype
366			int filemode
367			int partno
368			long linperfile
369
370			int
371			UUEncodeToStream(outfile,infile,infname,encoding,outfname,filemode)
372			FILE * outfile
373			FILE * infile
374			char * infname
375			int encoding
376			char * outfname
377			int filemode
378
379			int
380			UUEncodeToFile(infile,infname,encoding,outfname,diskname,linperfile)
381			FILE * infile
382			char * infname
383			int encoding
384			char * outfname
385			char * diskname
386			long linperfile
387
388			int
389			UUE_PrepSingle(outfile,infile,infname,encoding,outfname,filemode,destination,from,subject,isemail)
390			FILE * outfile
391			FILE * infile
392			char * infname
393			int encoding
394			char * outfname
395			int filemode
396			char * destination
397			char * from
398			char * subject
399			int isemail
400
401			int
402			UUE_PrepPartial(outfile,infile,infname,encoding,outfname,filemode,partno,linperfile,filesize,destination,from,subject,isemail)
403			FILE * outfile
404			FILE * infile
405			char * infname
406			int encoding
407			char * outfname
408			int filemode
409			int partno
410			long linperfile
411			long filesize
412			char * destination
413			char * from
414			char * subject
415			int isemail
416
417			uulist *
418			UUGetFileListItem(num)
419			int num
420
421			int
422			UURenameFile(item,newname)
423			uulist *item
424			char * newname
425			ALIAS:
426			Convert::UUlib::Item::rename = 1
427
428			int
429			UUDecodeToTemp(item)
430			uulist *item
431			ALIAS:
432			Convert::UUlib::Item::decode_temp = 1
433
434			int
435			UURemoveTemp(item)
436			uulist *item
437			ALIAS:
438			Convert::UUlib::Item::remove_temp = 1
439
440			int
441			UUDecodeFile(item,target=0)
442			uulist *item
443			char * target
444			ALIAS:
445			Convert::UUlib::Item::decode = 1
446
447			void
448			UUInfoFile(item,func)
449			uulist *item
450			SV * func
451			CODE:
452			UUInfoFile(item,(void *)func,uu_info_file);
453			ALIAS:
454			Convert::UUlib::Item::info = 1
455
456			MODULE = Convert::UUlib PACKAGE = Convert::UUlib::Item
457
458			short
459			state(li)
460			uulist *li
461			CODE:
462			RETVAL = li->state;
463			OUTPUT:
464			RETVAL
465
466			short
467			mode(li,newmode=0)
468			uulist *li
469			short newmode
470			CODE:
471			if (newmode)
472			li->mode = newmode;
473			RETVAL = li->mode;
474			OUTPUT:
475			RETVAL
476
477			short
478			uudet(li)
479			uulist *li
480			CODE:
481			RETVAL = li->uudet;
482			OUTPUT:
483			RETVAL
484
485			long
486			size(li)
487			uulist *li
488			CODE:
489			RETVAL = li->size;
490			OUTPUT:
491			RETVAL
492
493			char *
494			filename(li,newfilename=0)
495			uulist *li
496			char * newfilename
497			CODE:
498			if (newfilename)
499			{
500			FP_free (li->filename);
501			li->filename = FP_strdup (newfilename);
502			}
503			RETVAL = li->filename;
504			OUTPUT:
505			RETVAL
506
507			char *
508			subfname(li)
509			uulist *li
510			CODE:
511			RETVAL = li->subfname;
512			OUTPUT:
513			RETVAL
514
515			char *
516			mimeid(li)
517			uulist *li
518			CODE:
519			RETVAL = li->mimeid;
520			OUTPUT:
521			RETVAL
522
523			char *
524			mimetype(li)
525			uulist *li
526			CODE:
527			RETVAL = li->mimetype;
528			OUTPUT:
529			RETVAL
530
531			char *
532			binfile(li)
533			uulist *li
534			CODE:
535			RETVAL = li->binfile;
536			OUTPUT:
537			RETVAL
538
539			# functions accessing internal data(!)
540
541			void
542			parts(li)
543			uulist *li
544			PPCODE:
545			{
546			struct _uufile *p = li->thisfile;
547
548			while (p)
549			{
550			HV *pi = newHV ();
551
552			hv_store (pi, "partno" , 6, newSViv (p->partno) , 0);
553
554			if (p->filename)
555			hv_store (pi, "filename", 8, newSVpv (p->filename, 0) , 0);
556			if(p->subfname)
557			hv_store (pi, "subfname", 8, newSVpv (p->subfname, 0) , 0);
558			if(p->mimeid)
559			hv_store (pi, "mimeid" , 6, newSVpv (p->mimeid , 0) , 0);
560			if(p->mimetype)
561			hv_store (pi, "mimetype", 8, newSVpv (p->mimetype, 0) , 0);
562			if (p->data->subject)
563			hv_store (pi, "subject" , 7, newSVpv (p->data->subject,0), 0);
564			if (p->data->origin)
565			hv_store (pi, "origin" , 6, newSVpv (p->data->origin ,0), 0);
566			if (p->data->sfname)
567			hv_store (pi, "sfname" , 6, newSVpv (p->data->sfname ,0), 0);
568
569			XPUSHs (sv_2mortal (newRV_noinc ((SV *)pi)));
570
571			p = p->NEXT;
572			}
573			}
574
575			BOOT:
576			uu_msg_sv = newSVsv(&PL_sv_undef);
577			uu_busy_sv = newSVsv(&PL_sv_undef);
578			uu_file_sv = newSVsv(&PL_sv_undef);
579			uu_fnamefilter_sv = newSVsv(&PL_sv_undef);
580