/*
 * file.c
 *
 * $Id: file.c,v 1.3 1996/03/29 16:51:01 athan Exp $
 *
 * $Log: file.c,v $
 * Revision 1.3  1996/03/29 16:51:01  athan
 * Cleanups
 * Fixed bug with free()'ing wrong variable
 *
 * Revision 1.2  1996/03/28 20:02:07  athan
 * General cleanups
 *
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <fcntl.h>

#include "file.h"

/* Extern Function Prototypes */

/* Extern Variables */

extern int verbose;
extern struct afile thefile;

/* Local Function Prototypes */

void load_file(char *fn, struct afile *it);

/* Local Variables */


/* Load a file. Not quite as simple as it seems, seeing as we convert
 * any '\n' we find to '\n\r'. To achieve this we load it into one buffer,
 * which is the size of the file read, then copy it into a second buffer
 * a character at a time. This second buffer is twice the length of the
 * first to  allow for the worse case scenario of the file being completely
 * full of '\n' characters.
 * Once this is achieved we allocate memory for the ACTUAL size of the
 * processed file, and copy it into this buffer, pointed to by the 'what'
 * part of the it struct passed to us.
 */

void load_file(char *fn, struct afile *it)
{
   int d;
   int len;
   char *buf, *startbuf;
   char *processed, *startprocessed;
   
   d = open(fn, O_RDONLY);
   if (d < 0)
   {
      fprintf(stderr, "Couldn't open file \'%s\'\n", fn);
      exit(-1);
   }
   len = lseek(d, 0, SEEK_END);
   lseek(d, 0, SEEK_SET);
   if (NULL == (startbuf = buf = (char *)malloc(len + 1)))
   {
      fprintf(stderr, "Failed to malloc(%d)\n", len + 1);
      exit(-1);
   }
   memset(buf, 0, len + 1);
   if (NULL == (startprocessed = processed = (char *)malloc((2 * len) + 1)))
   {
      fprintf(stderr, "Failed to malloc(%d)\n", (2 * len) + 1);
      exit(-1);
   }
   memset(processed, 0, (2 * len) + 1);
   if (-1 == (read(d, buf, len)))
   {
      fprintf(stderr, "Error reading file \'%s\'\n", fn);
      exit(-1);
   }
   close(d);
   while (*buf)
   {
      switch (*buf)
      {
         case '\n':
	    *processed++ = *buf++;
	    *processed++ = '\r';
	    break;
	 default:
	    *processed++ = *buf++;
      }
   }
   free(startbuf);
   if (it->what)
   {
      free(it->what);
   }
   it->len = (size_t) (processed - startprocessed);
   if (NULL == (it->what = (char *) malloc(it->len + 1)))
   {
      fprintf(stderr, "Failed to malloc(%d)\n", it->len + 1);
      exit(-1);
   }
   memcpy(it->what, startprocessed, it->len);
   it->what[it->len] = '\0';
   free(startprocessed);
}