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