fileio.c

/* FILEIO.C
 *
 * The routines in this file read and write ASCII files from the disk. All of
 * the knowledge about files are here.
 *
 * modified by Petri Kutvonen
 */

#include<stdio.h>
#include"estruct.h"
#include"edef.h"
#include"efunc.h"

staticFILE*ffp; /* File pointer, all functions. */
staticinteofflag; /* end-of-file flag */

/*
 * Open a file for reading.
 */
intffropen(char*fn)
{
if ((ffp=fopen(fn, "r")) ==NULL)
returnFIOFNF;
eofflag= FALSE;
returnFIOSUC;
}

/*
 * Open a file for writing. Return TRUE if all is well, and FALSE on error
 * (cannot create).
 */
intffwopen(char*fn)
{
#ifVMS
intfd;

if ((fd=creat(fn, 0666, "rfm=var", "rat=cr")) <0
|| (ffp=fdopen(fd, "w")) ==NULL) {
#else
if ((ffp=fopen(fn, "w")) ==NULL) {
#endif
mlwrite("Cannot open file for writing");
returnFIOERR;
 }
returnFIOSUC;
}

/*
 * Close a file. Should look at the status in all systems.
 */
intffclose(void)
{
/* free this since we do not need it anymore */
if (fline) {
free(fline);
fline=NULL;
 }
eofflag= FALSE;

#ifMSDOS&CTRLZ
fputc(26, ffp); /* add a ^Z at the end of the file */
#endif

#ifV7 | USG | BSD | (MSDOS& (MSC | TURBO))
if (fclose(ffp) != FALSE) {
mlwrite("Error closing file");
returnFIOERR;
 }
returnFIOSUC;
#else
fclose(ffp);
returnFIOSUC;
#endif
}

/*
 * Write a line to the already opened file. The "buf" points to the buffer,
 * and the "nbuf" is its length, less the free newline. Return the status.
 * Check only at the newline.
 */
intffputline(char*buf, intnbuf)
{
inti;
#ifCRYPT
charc; /* character to translate */

if (cryptflag) {
for (i=0; i<nbuf; ++i) {
c=buf[i] &0xff;
myencrypt(&c, 1);
fputc(c, ffp);
 }
 } else
for (i=0; i<nbuf; ++i)
fputc(buf[i] &0xFF, ffp);
#else
for (i=0; i<nbuf; ++i)
fputc(buf[i] &0xFF, ffp);
#endif

fputc('\n', ffp);

if (ferror(ffp)) {
mlwrite("Write I/O error");
returnFIOERR;
 }

returnFIOSUC;
}

/*
 * Read a line from a file, and store the bytes in the supplied buffer. The
 * "nbuf" is the length of the buffer. Complain about long lines and lines
 * at the end of the file that don't have a newline present. Check for I/O
 * errors too. Return status.
 */
intffgetline(void)
{
intc; /* current character read */
inti; /* current index into fline */
char*tmpline; /* temp storage for expanding line */

/* if we are at the end...return it */
if (eofflag)
returnFIOEOF;

/* dump fline if it ended up too big */
if (flen>NSTRING) {
free(fline);
fline=NULL;
 }

/* if we don't have an fline, allocate one */
if (fline==NULL)
if ((fline=malloc(flen=NSTRING)) ==NULL)
returnFIOMEM;

/* read the line in */
#ifPKCODE
if (!nullflag) {
if (fgets(fline, NSTRING, ffp) == (char*) NULL) { /* EOF ? */
i=0;
c=EOF;
 } else {
i=strlen(fline);
c=0;
if (i>0) {
c=fline[i-1];
i--;
 }
 }
 } else {
i=0;
c=fgetc(ffp);
 }
while (c!=EOF&&c!='\n') {
#else
i=0;
while ((c=fgetc(ffp)) !=EOF&&c!='\n') {
#endif
#ifPKCODE
if (c) {
#endif
fline[i++] =c;
/* if it's longer, get more room */
if (i >= flen) {
if ((tmpline=
malloc(flen+NSTRING)) ==NULL)
returnFIOMEM;
strncpy(tmpline, fline, flen);
flen+=NSTRING;
free(fline);
fline=tmpline;
 }
#ifPKCODE
 }
c=fgetc(ffp);
#endif
 }

/* test for any errors that may have occured */
if (c==EOF) {
if (ferror(ffp)) {
mlwrite("File read error");
returnFIOERR;
 }

if (i!=0)
eofflag= TRUE;
else
returnFIOEOF;
 }

/* terminate and decrypt the string */
fline[i] =0;
#ifCRYPT
if (cryptflag)
myencrypt(fline, strlen(fline));
#endif
returnFIOSUC;
}

/*
 * does <fname> exist on disk?
 *
 * char *fname; file to check for existance
 */
intfexist(char*fname)
{
FILE*fp;

/* try to open the file for reading */
fp=fopen(fname, "r");

/* if it fails, just return false! */
if (fp==NULL)
return FALSE;

/* otherwise, close it and report true */
fclose(fp);
return TRUE;
}