/*

    Stream Replace - replaces sequences of bytes in FILE streams

    Copyright (C) 2007  Lluís Batlle i Rossell

    Please find the license in the provided COPYING file.

*/

#include <stdio.h>

#include <assert.h>

#include <string.h>

#include "sreplace.h"

enum {

  BUFFER_SIZE = 2048

};

static FILE * input, * output;

struct CmpState

{

  struct String *str;

  int matched;

};

struct String old_str;

struct String new_str;

struct CmpState cmp_state;

/* Buffer:

   [F] - read

   [F] - read_cmp

   [F]

   [F] - filled

   [ ]

   [ ]

   In the circular sense:

   read <= read_cmp < filled

*/

struct Buffer

{

  unsigned char *base;

  int filled;

  int read;

  int read_cmp;

  int size;

};

static int get_buffer_space(struct Buffer *b, int start, int end)

{

  int space;

  space = end - start + b->size;

  if (space > b->size)

    space -= b->size;

  return space;

}

static int min(int a, int b)

{

  if (a < b)

    return a;

  return b;

}

static int one_before(struct Buffer *b, int pos)

{

  if (pos == 0)

    return b->size - 1;

  return pos - 1;

}

/* This should be called without any exceeding size */

static int file_to_buffer(struct Buffer *b, int size)

{

  int blocksize;

  int res;

  blocksize = min(b->size - b->filled, size);

  if (blocksize > 0)

  {

    res = fread(b->base + b->filled, 1, blocksize, input);

    /*res = read(0, b->base + b->filled, blocksize);*/

    /*fprintf(stderr, "fread1 %i bytes (should %i).\n", res, blocksize);*/

    size -= res;

    b->filled = (b->filled + res) % b->size;

    /* Check EOF */

    if (res == 0)

      return 0;

  }

  if (size > 0 && res == blocksize)

  {

    blocksize = min(b->read - 1, size);

    res = fread(b->base, 1, blocksize, input);

    /*res = read(0, b->base, blocksize);*/

    /*fprintf(stderr, "fread2 %i bytes.\n", res);*/

    size -= res;

    b->filled = (b->filled + res) % b->size;

  }

  return 1;

}

static int file_read_more(struct Buffer *b)

{

  int can_read;

  int res;

  can_read = get_buffer_space(b, b->filled, b->read - 1);

  /*fprintf(stderr, "file_to_buffer %i\n", can_read);*/

  return file_to_buffer(b, can_read);

}

/* pos will be read or read_cmp, depending on

   what to read */

static int can_read_from_buffer(struct Buffer *b, int pos)

{

  /*

   In the circular sense:

   read <= read_cmp < filled

   */

  if (pos != b->filled)

    return 1;

  else

    return 0;

}

static int getc_real(struct Buffer *b)

{

  int a;

  if (!can_read_from_buffer(b, b->read))

    a = EOF;

  else

  {

    a = *(b->base + b->read);

    b->read += 1;

    if (b->read == b->size)

      b->read = 0;

  }

  /*fprintf(stderr, "getc_real %x\n", a);*/

  return a;

}

static int getc_cmp(struct Buffer *b)

{

  int a;

  if (!can_read_from_buffer(b, b->read_cmp))

    a = EOF;

  else

  {

    a = *(b->base + b->read_cmp);

    b->read_cmp += 1;

    if (b->read_cmp == b->size)

      b->read_cmp = 0;

  }

  /*fprintf(stderr, "getc_cmp %x\n", a);*/

  return a;

}

/* This will not be moved farer than read_cmp */

static void read_advance(struct Buffer *b, int adv)

{

  int i;

  for (i=0; i < adv; ++i)

    getc_real(b);

};

static void process_buffer(struct Buffer *b)

{

  int c;

  while (1)

  {

    c = getc_cmp(b);

    if (c == EOF)

      break;

    if (cmp_state.str->ptr[cmp_state.matched] == (char) c)

    {

      cmp_state.matched++;

      if (cmp_state.matched == cmp_state.str->length)

      {

        fwrite(new_str.ptr, 1, new_str.length, output);

        /*write(1, new_str.ptr, new_str.length);*/

        read_advance(b, cmp_state.matched);

        cmp_state.matched = 0;

      }

    } else

    {

      int c;

      c = getc_real(b); /* Will not be EOF. read_cmp is forwarder. */

      fputc(c, output);

      /*write(1, &c, 1);*/

      cmp_state.matched = 0;

      b->read_cmp = b->read;

    }

  }

}

static void end_buffer(struct Buffer *b)

{

  int c;

  while((c = getc_real(b)) != EOF)

      fputc(c, output);

      /*write(1, &c, 1);*/

}

static void loop()

{

  struct Buffer b;

  b.base = (unsigned char *) malloc(BUFFER_SIZE);

  b.read = 0;

  b.read_cmp = 0;

  b.filled = 0;

  b.size = BUFFER_SIZE;

  while(file_read_more(&b) > 0)

  {

    int c;

    process_buffer(&b);

  }

  end_buffer(&b);;

}

static void show_usage(const char *pname)

{

  printf("usage: %s OLD_STR NEW_STR\n", pname);

}

static void process_parameters(int argc, char **argv)

{

  if (argc != 3)

  {

    show_usage(argv[0]);

    exit(1);

  }

  old_str.ptr = argv[1];

  new_str.ptr = argv[2];

  old_str.length = parse_backslashes(old_str.ptr);

  fprintf(stderr, "OLD: ");

  print_hex(stderr, &old_str);

  fprintf(stderr, "\n");

  new_str.length = parse_backslashes(new_str.ptr);

  fprintf(stderr, "NEW: ");

  print_hex(stderr, &new_str);

  fprintf(stderr, "\n");

}

int main(int argc, char ** argv)

{

  process_parameters(argc, argv);

  cmp_state.str = &old_str;

  cmp_state.matched = 0;

  input = stdin;

  output = stdout;

  loop();

  return 0;

}