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