home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga Elysian Archive
/
AmigaElysianArchive.iso
/
comm
/
term23_2.lha
/
Source_Code
/
XPRAscii
/
xprascii.c
< prev
next >
Wrap
C/C++ Source or Header
|
1992-05-09
|
19KB
|
976 lines
#include "csource/xprascii.h"
STATIC BOOL test(struct XPR_IO *io);
STATIC BOOL setup(struct XPR_IO *io);
STATIC VOID ParseConfigString(struct XPR_IO *io, char *buf);
STATIC UBYTE *FindOption(UBYTE *buf, UBYTE option);
STATIC LONG AtoL(UBYTE *);
VOID myGetSysTime(ULONG *);
VOID myGetDate(BPTR);
LONG __saveds __asm XProtocolCleanup(register __a0 struct XPR_IO *io)
{
struct XProtocolData *xdata = (struct XProtocolData *)io->xpr_data;
if(xdata)
{
FreeMem(xdata, sizeof(struct XProtocolData));
io->xpr_data = NULL;
}
return(XPRS_SUCCESS);
}
LONG __saveds __asm XProtocolSetup(register __a0 struct XPR_IO *io)
{
struct XProtocolData *xdata;
if(test(io) == FALSE)
return(XPRS_FAILURE);
if(io->xpr_data == NULL)
{
if(setup(io) == FALSE)
return(XPRS_FAILURE);
}
xdata = (struct XProtocolData *)io->xpr_data;
/* If setup string isn't handed to us, ask questions */
if(io->xpr_filename == NULL)
{
if(io->xpr_options != NULL)
{
enum { OPT_HEADER=0, OPT_CHARDELAY, OPT_LINEDELAY, OPT_LF_CONVERT,
OPT_CR_CONVERT, OPT_PROMPTCHAR, OPT_EXPANDBLANKS,
/* OPT_UU_MODE,*/ OPT_STRIPHIBIT };
ULONG numopts;
struct xpr_option {
char *xpro_description; /* description of the option */
long xpro_type; /* type of option */
char *xpro_value; /* pointer to a buffer with the current value */
long xpro_length; /* buffer size */
};
struct xpr_option *opti[10];
UBYTE charbuf[LONGLEN], linebuf[LONGLEN], lfbuf[CHARLEN],
crbuf[CHARLEN], stripbuf[STRINGLEN], uubuf[STRINGLEN],
expandbuf[STRINGLEN];
struct xpr_option opt0;
struct xpr_option opt1;
struct xpr_option opt2;
struct xpr_option opt3;
struct xpr_option opt4;
struct xpr_option opt5;
struct xpr_option opt6;
struct xpr_option opt7;
struct xpr_option opt8;
struct xpr_option opt9;
opti[0] = &opt0;
opti[1] = &opt1;
opti[2] = &opt2;
opti[3] = &opt3;
opti[4] = &opt4;
opti[5] = &opt5;
opti[6] = &opt6;
opti[7] = &opt7;
opti[8] = &opt8;
opti[9] = &opt9;
numopts = 0;
opti[OPT_HEADER]->xpro_description = "ASCII Options:";
opti[OPT_HEADER]->xpro_type = XPRO_HEADER;
opti[OPT_HEADER]->xpro_value = NULL;
opti[OPT_HEADER]->xpro_length = NULL;
/* */
numopts++;
opti[OPT_CHARDELAY]->xpro_description = "Char Delay (ticks):";
opti[OPT_CHARDELAY]->xpro_type = XPRO_LONG;
sprintf(charbuf, "%ld", xdata->CharDelay);
opti[OPT_CHARDELAY]->xpro_value = charbuf;
opti[OPT_CHARDELAY]->xpro_length = LONGLEN;
/* */
numopts++;
opti[OPT_LINEDELAY]->xpro_description = "Line Delay (ticks):";
opti[OPT_LINEDELAY]->xpro_type = XPRO_LONG;
sprintf(linebuf, "%ld", xdata->LineDelay);
opti[OPT_LINEDELAY]->xpro_value = linebuf;
opti[OPT_LINEDELAY]->xpro_length = LONGLEN;
/* */
numopts++;
switch(xdata->LF_Mode)
{
case STRIP_MODE:
lfbuf[0] = 'S';
break;
case ADD_MODE:
lfbuf[0] = 'A';
break;
case EXCHANGE_MODE:
lfbuf[0] = 'X';
break;
default:
lfbuf[0] = 'N';
break;
}
lfbuf[1] = '\0';
opti[OPT_LF_CONVERT]->xpro_description = "Convert `LF' (N,S,A,X)";
opti[OPT_LF_CONVERT]->xpro_type = XPRO_STRING;
opti[OPT_LF_CONVERT]->xpro_value = lfbuf;
opti[OPT_LF_CONVERT]->xpro_length = CHARLEN;
/* */
numopts++;
switch(xdata->CR_Mode)
{
case STRIP_MODE:
crbuf[0] = 'S';
break;
case ADD_MODE:
crbuf[0] = 'A';
break;
case EXCHANGE_MODE:
crbuf[0] = 'X';
break;
default:
crbuf[0] = 'N';
break;
}
crbuf[1] = '\0';
opti[OPT_CR_CONVERT]->xpro_description = "Convert `CR' (N,S,A,X)";
opti[OPT_CR_CONVERT]->xpro_type = XPRO_STRING;
opti[OPT_CR_CONVERT]->xpro_value = crbuf;
opti[OPT_CR_CONVERT]->xpro_length = CHARLEN;
/* */
numopts++;
opti[OPT_PROMPTCHAR]->xpro_description = "Prompt Char:";
opti[OPT_PROMPTCHAR]->xpro_type = XPRO_STRING;
opti[OPT_PROMPTCHAR]->xpro_value = &xdata->PromptChar;
opti[OPT_PROMPTCHAR]->xpro_length = CHARLEN;
/* */
/*
** numopts++;
** if(xdata->UU_Mode)
** strcpy(uubuf, "on");
** else
** strcpy(uubuf, "off");
** opti[OPT_UU_MODE]->xpro_description = "Use uuencode & decode:";
** opti[OPT_UU_MODE]->xpro_type = XPRO_BOOLEAN;
** opti[OPT_UU_MODE]->xpro_value = uubuf;
** opti[OPT_UU_MODE]->xpro_length = STRINGLEN;
*/
/* */
numopts++;
if(xdata->ExpandBlanks)
strcpy(expandbuf, "on");
else
strcpy(expandbuf, "off");
opti[OPT_EXPANDBLANKS]->xpro_description = "Expand Blank Lines:";
opti[OPT_EXPANDBLANKS]->xpro_type = XPRO_BOOLEAN;
opti[OPT_EXPANDBLANKS]->xpro_value = expandbuf;
opti[OPT_EXPANDBLANKS]->xpro_length = STRINGLEN;
/* */
numopts++;
if(xdata->StripHiBit)
strcpy(stripbuf, "on");
else
strcpy(stripbuf, "off");
opti[OPT_STRIPHIBIT]->xpro_description = "Strip High Bit:";
opti[OPT_STRIPHIBIT]->xpro_type = XPRO_BOOLEAN;
opti[OPT_STRIPHIBIT]->xpro_value = stripbuf;
opti[OPT_STRIPHIBIT]->xpro_length = STRINGLEN;
io->xpr_options(++numopts, opti);
xdata->CharDelay = AtoL(charbuf);
if(xdata->CharDelay > 500)
xdata->CharDelay = 500;
xdata->LineDelay = AtoL(linebuf);
if(xdata->LineDelay > 500)
xdata->LineDelay = 500;
switch(*lfbuf)
{
case 's':
case 'S': /* Strip LF */
xdata->LF_Mode = STRIP_MODE;
break;
case 'a':
case 'A': /* Add CR */
xdata->LF_Mode = ADD_MODE;
break;
case 'x':
case 'X': /* LF -> CR */
xdata->LF_Mode = EXCHANGE_MODE;
break;
default: /* None */
xdata->LF_Mode = NONE_MODE;
break;
}
switch(*crbuf)
{
case 's':
case 'S': /* Strip CR */
xdata->CR_Mode = STRIP_MODE;
break;
case 'a':
case 'A': /* Add LF */
xdata->CR_Mode = ADD_MODE;
break;
case 'x':
case 'X': /* CR -> LF */
xdata->CR_Mode = EXCHANGE_MODE;
break;
default: /* None */
xdata->CR_Mode = NONE_MODE;
break;
}
xdata->ExpandBlanks = (!stricmp(expandbuf, "yes") ||
!stricmp(expandbuf, "on"));
/*
** xdata->UU_Mode = (!stricmp(uubuf, "yes") ||
** !stricmp(uubuf, "on"));
*/
xdata->StripHiBit = (!stricmp(stripbuf, "yes") ||
!stricmp(stripbuf, "on"));
/* xdata->PromptChar updated sich selbst */
}
else
{
if(io->xpr_gets != NULL)
{
UWORD expand, strip;
UBYTE lf, cr, buffy[128];
expand = (xdata->ExpandBlanks) ? 1 : 0;
strip = (xdata->StripHiBit) ? 1 : 0;
switch(xdata->LF_Mode)
{
case STRIP_MODE:
lf = 'S';
break;
case ADD_MODE:
lf = 'A';
break;
case EXCHANGE_MODE:
lf = 'X';
break;
default:
lf = 'N';
break;
}
switch(xdata->CR_Mode)
{
case STRIP_MODE:
cr = 'S';
break;
case ADD_MODE:
cr = 'A';
break;
case EXCHANGE_MODE:
cr = 'X';
break;
default:
cr = 'N';
break;
}
sprintf(buffy, "C%ld,L%ld,F%lc,R%lc,E%ld,S%ld,P%lc", xdata->CharDelay, xdata->LineDelay, lf, cr, expand, strip, xdata->PromptChar);
if(io->xpr_gets("ASCII Options", buffy))
ParseConfigString(io, buffy);
}
}
}
else
ParseConfigString(io, io->xpr_filename);
return(XPRS_SUCCESS);
}
STATIC VOID WaitForPrompt(struct XPR_IO *io)
{
struct XProtocolData *xdata = (struct XProtocolData *)io->xpr_data;
UWORD data;
if(data = io->xpr_sread(xdata->SerBuf, 1, 0) > 0)
{
UWORD i;
for(i=0; i<data; i++)
{
if(xdata->SerBuf[i] == xdata->PromptChar)
return;
}
}
for(;;)
{
if(io->xpr_sread(xdata->SerBuf, 1, 10000000) > 0)
{
if(xdata->SerBuf[0] == xdata->PromptChar)
break;
}
else
break;
}
}
STATIC BOOL SendAsciiPacket(struct XPR_IO *io, UBYTE *filebuf, ULONG datalen)
{
struct XProtocolData *xdata = (struct XProtocolData *)io->xpr_data;
UWORD i, out;
UBYTE *ptr;
ptr = filebuf;
for(i=0, out=0; i<datalen; i++, ptr++)
{
if(*ptr == '\n')
{
switch(xdata->LF_Mode)
{
case STRIP_MODE:
;
continue;
case ADD_MODE:
xdata->SerBuf[out++] = '\r';
break;
case EXCHANGE_MODE:
*ptr = '\r';
break;
}
}
if(*ptr == '\r')
{
switch(xdata->CR_Mode)
{
case STRIP_MODE:
;
continue;
case ADD_MODE:
xdata->SerBuf[out++] = '\n';
xdata->SerBuf[out++] = '\r';
continue;
case EXCHANGE_MODE:
*ptr = '\n';
break;
}
}
xdata->SerBuf[out++] = *ptr;
}
if(xdata->ExpandBlanks && (xdata->SerBuf[0] == '\n' || xdata->SerBuf[0] == '\r'))
io->xpr_swrite(" ", 1);
if(xdata->CharDelay) /* writin' in slo'-motion..(-: */
{
ptr = xdata->SerBuf;
for(i=0; i<out; i++, ptr++)
{
io->xpr_swrite(ptr, 1);
Delay(xdata->CharDelay);
}
}
else
io->xpr_swrite(xdata->SerBuf, out); /* BLAST IT..!! */
if(xdata->LineDelay)
Delay(xdata->LineDelay);
if(xdata->PromptChar && xdata->PromptChar != ' ')
WaitForPrompt(io);
io->xpr_sflush();
return(io->xpr_chkabort());
}
/*
**STATIC BOOL uudecode(struct XPR_IO *io)
**{
** struct XProtocolData *xdata = (struct XProtocolData *)io->xpr_data;
** BPTR fh;
** ULONG systemtags[] = { SYS_Output, 0, TAG_DONE };
** BOOL success;
**
** if((fh = Open("T:uudecode.log", MODE_OLDFILE)) == NULL)
** fh = Open("T:uudecode.log", MODE_NEWFILE);
** else
** Seek(fh, 0, OFFSET_END);
**
** sprintf(&xdata->FileBuf[511], "uudecode %s", xdata->FileBuf);
** if(fh)
** {
** fprintf(fh, "-------------------------------\n");
** myGetDate(fh);
** fprintf(fh, "System(\"%s\")\n", &xdata->FileBuf[511]);
** }
**
** systemtags[1] = fh;
** success = (System(&xdata->FileBuf[511], (APTR)&systemtags[0]) != -1);
**
** if(fh)
** Close(fh);
**
** return(success);
**}
**
**
**STATIC VOID *uuencode(struct XPR_IO *io, VOID *fp)
**{
** struct XProtocolData *xdata = (struct XProtocolData *)io->xpr_data;
** VOID *tmp_fp=NULL;
** BPTR fh;
** ULONG sys_time;
** ULONG systemtags[] = { SYS_Output, 0, TAG_DONE };
** UBYTE tmp_file[24];
**
** if((fh = Open("T:uuencode.log", MODE_OLDFILE)) == NULL)
** fh = Open("T:uuencode.log", MODE_NEWFILE);
** else
** Seek(fh, 0, OFFSET_END);
**
** myGetSysTime(&sys_time);
** sprintf(tmp_file, "T:%ld.uue", sys_time);
** sprintf(xdata->FileBuf, "uuencode %s %s", io->xpr_filename, tmp_file);
** if(fh)
** {
** fprintf(fh, "-------------------------------\n");
** myGetDate(fh);
** fprintf(fh, "System(\"%s\")\n", xdata->FileBuf);
** }
**
** systemtags[1] = fh;
** if(System(xdata->FileBuf, (APTR)&systemtags[0]) != -1)
** tmp_fp = io->xpr_fopen(tmp_file, "r");
**
** if(fh)
** Close(fh);
**
** return(tmp_fp);
**}
*/
LONG __saveds __asm XProtocolSend(register __a0 struct XPR_IO *io)
{
struct XPR_UPDATE xpru;
struct XProtocolData *xdata;
VOID *fp;
LONG read;
BOOL brkflag;
if(test(io) == FALSE)
return(XPRS_FAILURE);
if(io->xpr_data == NULL)
{
if(setup(io) == FALSE)
{
xpru.xpru_updatemask = XPRU_ERRORMSG;
xpru.xpru_errormsg = "Ran out of memory!";
io->xpr_update(&xpru);
return(XPRS_FAILURE);
}
}
xdata = (struct XProtocolData *)io->xpr_data;
xpru.xpru_updatemask = XPRU_FILENAME;
xpru.xpru_filename = io->xpr_filename;
io->xpr_update(&xpru);
fp = io->xpr_fopen(io->xpr_filename, "r");
if(fp == NULL)
{
xpru.xpru_updatemask = XPRU_ERRORMSG;
xpru.xpru_errormsg = "Failed to open input file";
io->xpr_update(&xpru);
return(XPRS_FAILURE);
}
/*
** if(xdata->UU_Mode)
** {
** VOID *tmp_fp;
**
** if(tmp_fp = uuencode(io, fp))
** {
** io->xpr_fclose(fp);
** fp = tmp_fp;
** }
** else
** {
** io->xpr_fclose(fp);
** xpru.xpru_updatemask = XPRU_ERRORMSG;
** xpru.xpru_errormsg = "Failed to create uuencoded file";
** io->xpr_update(&xpru);
** return(XPRS_FAILURE);
** }
** }
*/
xpru.xpru_updatemask = XPRU_PACKETDELAY | XPRU_CHARDELAY | XPRU_MSG;
xpru.xpru_packetdelay= xdata->LineDelay * 20; /* msec! */
xpru.xpru_chardelay = xdata->CharDelay * 20; /* msec! */
/*
** xpru.xpru_msg = (xdata->UU_Mode) ? "Sending uuencoded File" :
** "Starting ASCII Send";
*/
xpru.xpru_msg = "Starting ASCII Send";
io->xpr_update(&xpru);
xpru.xpru_bytes = 0;
xpru.xpru_blocks = 0;
xpru.xpru_blocksize = 0;
while(read = io->xpr_fread(xdata->FileBuf, 1, FILEBUF, fp))
{
WORD send, sent;
UBYTE *buf;
for(send=read, buf=xdata->FileBuf; send>0; buf+=sent, send-=sent)
{
sent = strcspn(buf, "\r\n");
sent++;
xpru.xpru_updatemask = XPRU_BYTES | XPRU_BLOCKS | XPRU_BLOCKSIZE;
xpru.xpru_blocks++;
xpru.xpru_bytes += sent;
xpru.xpru_blocksize = sent;
io->xpr_update(&xpru);
if(brkflag = SendAsciiPacket(io, buf, sent))
goto bibi;
}
}
bibi:
io->xpr_fclose(fp);
xpru.xpru_updatemask = XPRU_MSG;
xpru.xpru_msg = (brkflag) ? "Aborted" : "Done";
io->xpr_update(&xpru);
return((brkflag) ? XPRS_SUCCESS : XPRS_FAILURE);
}
LONG __saveds __asm XProtocolReceive(register __a0 struct XPR_IO *io)
{
struct XPR_UPDATE xpru;
struct XProtocolData *xdata;
VOID *fp;
LONG read;
BOOL brkflag=FALSE;
if(test(io) == FALSE)
return(XPRS_FAILURE);
if(io->xpr_data == NULL)
{
if(setup(io) == FALSE)
{
xpru.xpru_updatemask = XPRU_ERRORMSG;
xpru.xpru_errormsg = "Ran out of memory!";
io->xpr_update(&xpru);
return(XPRS_FAILURE);
}
}
xdata = (struct XProtocolData *)io->xpr_data;
fp = io->xpr_fopen(io->xpr_filename, "w");
if(fp == NULL)
{
xpru.xpru_updatemask = XPRU_ERRORMSG | XPRU_FILENAME;
xpru.xpru_errormsg = "Failed to open output file";
xpru.xpru_filename = xdata->FileBuf;
io->xpr_update(&xpru);
return(XPRS_FAILURE);
}
xpru.xpru_updatemask = XPRU_MSG | XPRU_FILENAME;
xpru.xpru_msg = "Starting ASCII Receive";
xpru.xpru_filename = xdata->FileBuf;
io->xpr_update(&xpru);
xpru.xpru_bytes = 0;
xpru.xpru_blocks = 0;
xpru.xpru_blocksize = 0;
while((read = io->xpr_sread(xdata->SerBuf, 80, 5000000)) > 0)
{
if(xdata->StripHiBit)
{
UWORD i;
for(i=0; i<read; i++)
xdata->SerBuf[i] &= 0x7f;
}
xpru.xpru_updatemask = XPRU_BYTES | XPRU_BLOCKS | XPRU_BLOCKSIZE;
xpru.xpru_bytes += read;
xpru.xpru_blocks++;
xpru.xpru_blocksize = read;
io->xpr_update(&xpru);
io->xpr_fwrite(xdata->SerBuf, 1, read, fp);
if(brkflag = io->xpr_chkabort())
break;
}
io->xpr_fclose(fp);
fp = NULL;
/*
** if(xdata->UU_Mode)
** {
** uudecode(io);
** }
*/
xpru.xpru_updatemask = XPRU_MSG;
xpru.xpru_msg = (brkflag) ? "Aborted" : "Done";
io->xpr_update(&xpru);
return((brkflag) ? XPRS_SUCCESS : XPRS_FAILURE);
}
LONG __saveds __asm XProtocolHostMon(register __a0 struct XPR_IO *io, register __a1 UBYTE *serbuff, register __d0 LONG actual, register __d1 LONG maxsize)
{
return(actual);
}
LONG __saveds __asm XProtocolUserMon(register __a0 struct XPR_IO *io, register __a1 UBYTE *serbuff, register __d0 LONG actual, register __d1 LONG maxsize)
{
return(actual);
}
STATIC BOOL test(struct XPR_IO *io)
{
/* all we need..(-: */
if(io->xpr_swrite == NULL)
return(FALSE);
if(io->xpr_sread == NULL)
return(FALSE);
if(io->xpr_sflush == NULL)
return(FALSE);
if(io->xpr_fopen == NULL)
return(FALSE);
if(io->xpr_fwrite == NULL)
return(FALSE);
if(io->xpr_fread == NULL)
return(FALSE);
if(io->xpr_fclose == NULL)
return(FALSE);
if(io->xpr_update == NULL)
return(FALSE);
if(io->xpr_chkabort == NULL)
return(FALSE);
return(TRUE);
}
STATIC BOOL setup(struct XPR_IO *io)
{
struct XProtocolData *xdata = (struct XProtocolData *)io->xpr_data;
xdata = io->xpr_data = AllocMem(sizeof(struct XProtocolData), MEMF_PUBLIC | MEMF_CLEAR);
if(io->xpr_data == NULL)
return(FALSE);
/* some good settings.. */
xdata->CharDelay = 0;
xdata->LineDelay = 0;
xdata->PromptChar = ' ';
xdata->ExpandBlanks = TRUE;
xdata->StripHiBit = FALSE;
/* xdata->UU_Mode = FALSE;*/
xdata->LF_Mode = NONE_MODE;
xdata->CR_Mode = NONE_MODE;
return(TRUE);
}
/* Search for specified option setting in string */
STATIC UBYTE *FindOption(UBYTE *buf, UBYTE option)
{
while(*buf)
{
buf += strspn(buf," ,\t\r\n");
if(*buf == option)
return(++buf);
buf += strcspn(buf," ,\t\r\n");
}
return(NULL);
}
STATIC VOID ParseConfigString(struct XPR_IO *io, char *buf)
{
struct XProtocolData *xdata = (struct XProtocolData *)io->xpr_data;
UBYTE *p;
if(p = FindOption(buf, 'P'))
xdata->PromptChar = *p;
else
{
if(p = FindOption(buf, 'p'))
xdata->PromptChar = *p;
}
strupr(buf);
if(p = FindOption(buf, 'C'))
{
xdata->CharDelay = AtoL(p);
if(xdata->CharDelay > 500)
xdata->CharDelay = 500;
}
if(p = FindOption(buf, 'L'))
{
xdata->LineDelay = AtoL(p);
if(xdata->LineDelay > 500)
xdata->LineDelay = 500;
}
if(p = FindOption(buf, 'F'))
{
switch(*p)
{
case 'A':
xdata->LF_Mode = ADD_MODE;
break;
case 'S':
xdata->LF_Mode = STRIP_MODE;
break;
case 'X':
xdata->LF_Mode = EXCHANGE_MODE;
break;
default:
xdata->LF_Mode = NONE_MODE;
break;
}
}
if(p = FindOption(buf, 'R'))
{
switch(*p)
{
case 'A':
xdata->CR_Mode = ADD_MODE;
break;
case 'S':
xdata->CR_Mode = STRIP_MODE;
break;
case 'X': /* LF -> CR */
xdata->CR_Mode = EXCHANGE_MODE;
break;
default:
xdata->CR_Mode = NONE_MODE;
break;
}
}
if(p = FindOption(buf, 'E'))
xdata->ExpandBlanks = (*p == '1');
/*
** if(p = FindOption(buf, 'U'))
** xdata->UU_Mode = (*p == '1');
*/
if(p = FindOption(buf, 'S'))
xdata->StripHiBit = (*p == '1');
}
STATIC LONG AtoL(UBYTE *str)
{
LONG cnt=0, help;
while(*str <= ' ') /* skip white spaces.. */
{
if(*str == '\0')
return(0);
str++;
}
if(*str == '-')
{
help = -1;
str++;
}
else
{
if(*str == '+')
str++;
help = 1;
}
for(;;)
{
if(*str >= '0' && *str <= '9')
{
cnt *= 10;
cnt += *str - '0';
}
else
break;
if(!(*str))
break;
str++;
}
return(cnt * help);
}
/**********************************************************
* ULONG getsystime(struct timeval *tv)
*
* This function was rewritten using DateStamp() to
* eliminate the opening and closing of the timer.device
* that was occurring everytime this function was called.
* An attempt to save some processing time. -WMP-
**********************************************************/
VOID myGetSysTime(ULONG *secs)
{
struct DateStamp ds;
DateStamp(&ds);
*secs = (ds.ds_Days * 86400) + (ds.ds_Minute * 60 + (ds.ds_Tick / TICKS_PER_SECOND));
}
VOID myGetDate(BPTR fh)
{
struct DateTime dt;
UBYTE time[12];
UBYTE date[12];
UBYTE day[12];
DateStamp(&dt.dat_Stamp);
dt.dat_Format = FORMAT_DOS;
dt.dat_Flags = 0;
dt.dat_StrDay = day;
dt.dat_StrDate = date;
dt.dat_StrTime = time;
DateToStr(&dt);
fprintf(fh, "%s %s %s\n", day, date, time);
}
/* end of source-code */