forth/src/fh_input.c

#include "forth_internal.h"

enum fh_error fh_push_input(struct fh_thread_s *fh, struct fh_input_spec_s *newinput)
{
  LOG("--- Push input spec ---");

  if (newinput == NULL) {
    LOGE("push input with NULL");
    return FH_ERR_INTERNAL; // TODO IO
  }

  struct fh_input_spec_s *oldinput = fh->input;
  fh->input = NULL;

  if (NULL != oldinput) {
    oldinput->push_prepare(fh, oldinput);

//    memcpy(&oldinput->saved_buffer[0], &fh->heap[INPUTBUF_ADDR], INPUT_BUFFER_SIZE);
    oldinput->saved_inputlen = fh->inputlen;
    oldinput->saved_inputptr = fh->inputptr;
    oldinput->saved_execptr = fh->execptr;
    oldinput->saved_inputaddr = fh->inputaddr;
    newinput->previous = oldinput;
  }

  fh->execptr = MAGICADDR_EXEC_INTERACTIVE;
  fh->inputlen = 0;
  fh->inputptr = 0;

//  fh_setstate(fh, FH_STATE_INTERPRET, 0);
  fh->input = newinput;

  if (newinput->cwd) {
    LOG("CD to %s", newinput->cwd);
    chdir(newinput->cwd);
  }
  return FH_OK;
}

enum fh_error fh_pop_input(struct fh_thread_s *fh)
{
  LOG("--- Pop input spec ---");

  struct fh_input_spec_s *discarded = fh->input;
  fh->input = NULL;

  struct fh_input_spec_s *restored = discarded->previous;
  if (!restored) {
    return FH_OK; // topmost
  }
  fh->input = restored; // this can be NULL, that must be checked by caller.

  restored->pop_restore(fh, restored);

//  memcpy(&fh->heap[INPUTBUF_ADDR], &restored->saved_buffer[0], INPUT_BUFFER_SIZE);
  fh->inputlen = restored->saved_inputlen;
  fh->inputptr = restored->saved_inputptr;
  fh->execptr = restored->saved_execptr;
  fh->inputaddr = restored->saved_inputaddr;
//  fh_setstate(fh, restored->saved_state, 0);

  if (discarded->free_self) {
    discarded->free_self(discarded);
  }

  if (restored->cwd) {
    LOG("CD to %s", restored->cwd);
    chdir(restored->cwd);
  }
  return FH_OK;
}

struct file_input_spec {
  struct fh_input_spec_s spec;
  char saved_buffer[INPUT_BUFFER_SIZE];
  FILE *file;
};

struct string_input_spec {
  struct fh_input_spec_s spec;
  const char *str;
  size_t len;
};

static void file_push_prepare(struct fh_thread_s *fh, struct fh_input_spec_s *spec)
{
  struct file_input_spec *fspec = (void*) spec;
  memcpy(&fspec->saved_buffer[0], &fh->heap[INPUTBUF_ADDR], INPUT_BUFFER_SIZE);
}

static void file_pop_restore(struct fh_thread_s *fh, struct fh_input_spec_s *spec)
{
  struct file_input_spec *fspec = (void*) spec;
  memcpy(&fh->heap[INPUTBUF_ADDR], &fspec->saved_buffer[0], INPUT_BUFFER_SIZE);
}

static void str_push_prepare(struct fh_thread_s *fh, struct fh_input_spec_s *spec)
{
}

static void str_pop_restore(struct fh_thread_s *fh, struct fh_input_spec_s *spec)
{
}

static inline uint8_t *inputbuf_at(struct fh_thread_s *fh, size_t pos)
{
  return &fh->heap[fh->inputaddr + pos];
}

void fh_input_memmove_leftovers(struct fh_thread_s *fh)
{
  if (fh->inputptr < fh->inputlen) {
    // something is left
    uint32_t remains = fh->inputlen - fh->inputptr;
    if (remains > 0) {
      memmove(inputbuf_at(fh, 0), inputbuf_at(fh, fh->inputptr), remains);
      fh->inputptr = 0;
      fh->inputlen = remains;
    } else {
      fh->inputptr = 0;
      fh->inputlen = 0;
    }
  } else {
    fh->inputptr = 0;
    fh->inputlen = 0;
  }
}

static void file_start(struct fh_thread_s *fh, struct fh_input_spec_s *spec)
{
  fh->inputaddr = INPUTBUF_ADDR;
  //
}

static void str_start(struct fh_thread_s *fh, struct fh_input_spec_s *spec)
{
  struct string_input_spec *strspec = (struct string_input_spec *) spec;
  fh->inputaddr = (void*)strspec->str - (void*)&fh->heap[0]; // XXX this will explode if string is not in the internal heap!
  fh->inputlen = strspec->len;
  fh->inputptr = 0;
}

static bool file_refill(struct fh_thread_s *fh, struct fh_input_spec_s *spec)
{
  struct file_input_spec *fis = (struct file_input_spec *) spec;
  fh_input_memmove_leftovers(fh);
  uint32_t space_left = INPUT_BUFFER_SIZE - fh->inputlen - 1;
  char *wp = (char *) inputbuf_at(fh, fh->inputptr);
  //LOG("spec %p, fgets %d", spec, space_left);
  if (fgets(wp, (int) space_left, fis->file)) {
    spec->linenum++;
    fh->inputlen = strnlen(wp, INPUT_BUFFER_SIZE);
    wp[fh->inputlen] = 0;
    //LOG("read %d bytes from file", fh->inputlen);
    return true;
  } else {
    return fh->inputptr > fh->inputlen; // return false only if there is nothing left
  }
}

static bool str_refill(struct fh_thread_s *fh, struct fh_input_spec_s *spec)
{
  return fh->inputptr < fh->inputlen;
//  struct string_input_spec *fis = (struct string_input_spec *) spec;
//  fh_input_memmove_leftovers(fh);
//  uint32_t space_left = INPUT_BUFFER_SIZE - fh->inputlen - 1;
//  char *wp = (char *) inputbuf_at(fh, fh->inputptr);
//
//  uint32_t chars_remaining_in_string = fis->len - fis->readpos;
//  if (chars_remaining_in_string > 0) {
//    if (chars_remaining_in_string < space_left) {
//      space_left = chars_remaining_in_string;
//    }
//
//    memcpy(wp, &fis->str[fis->readpos], space_left);
//    *(wp + space_left) = 0;
//    fis->readpos += space_left;
//    fh->inputlen += space_left;
//    return true;
//  } else {
//    return false;
//  }
}

static void free_filespec(void *p)
{
  struct file_input_spec *fis = (struct file_input_spec *) p;
  if (fis->file != stdin) {
    fclose(fis->file);
    fis->file = NULL;
  }
  if (fis->spec.cwd) {
    free(fis->spec.cwd);
    fis->spec.cwd = NULL;
  }
  free(fis);
}

static void free_strspec(void *p)
{
  struct string_input_spec *sis = (struct string_input_spec *) p;
  if (sis->spec.cwd) {
    free(sis->spec.cwd);
    sis->spec.cwd = NULL;
  }
  free(sis);
}

struct fh_input_spec_s *fh_create_input_from_filestruct(FILE *f, const char *cwd)
{
  struct file_input_spec *spec = calloc(sizeof(struct file_input_spec), 1);
  if (!spec) {
    LOGE("Err alloc input spec struct");
    return NULL;
  }

  LOG("Input for FILE, cwd: %s", cwd);
  spec->spec.free_self = free_filespec;
  spec->spec.start = file_start;
  spec->spec.push_prepare = file_push_prepare;
  spec->spec.pop_restore = file_pop_restore;
  spec->spec.refill_input_buffer = file_refill;
  spec->file = f;
  if (cwd) {
    spec->spec.cwd = strdup(cwd);
  }
  return (struct fh_input_spec_s*) spec;
}

struct fh_input_spec_s *fh_create_input_from_filename(char *path)
{
  struct file_input_spec *spec = calloc(sizeof(struct file_input_spec), 1);
  if (!spec) {
    LOGE("Err alloc input spec struct");
    return NULL;
  }

  FILE *f = fopen(path, "r");
  if (!f) {
    LOGE("Err open file \"%s\"", path);
    free(spec);
    return NULL;
  }

  spec->spec.free_self = free_filespec;
  spec->spec.start = file_start;
  spec->spec.push_prepare = file_push_prepare;
  spec->spec.pop_restore = file_pop_restore;
  spec->spec.refill_input_buffer = file_refill;
  spec->file = f;

  char pwd[PATH_MAX+1];
  realpath(path, pwd);
  char *end = strrchr(pwd, '/');
  if (end) {
    // add terminator
    *end = 0;
  }
  spec->spec.cwd = strdup(pwd);
  LOG("Input for file %s, path %s\n", path, pwd);
  return (struct fh_input_spec_s*) spec;
}

struct fh_input_spec_s *fh_create_input_from_string(char *str, size_t len, const char *cwd)
{
  struct string_input_spec *spec = calloc(sizeof(struct string_input_spec), 1);
  if (!spec) {
    return NULL;
  }

  LOG("Evaluating: \"%.*s\"", (int)len, str);

  spec->spec.free_self = free_strspec;
  spec->spec.refill_input_buffer = str_refill;
  spec->spec.push_prepare = str_push_prepare;
  spec->spec.pop_restore = str_pop_restore;
  spec->spec.start = str_start;
  spec->str = str;
  spec->len = len;
  spec->spec.cwd = cwd ? strdup(cwd) : NULL;
  return (struct fh_input_spec_s*) spec;
}

void fh_input_teardown(struct fh_thread_s *fh)
{
  struct fh_input_spec_s *s = fh->input;
  if (!s) return;

  while (s) {
    struct fh_input_spec_s *prev = s->previous;
    if (s->free_self) {
      s->free_self(s);
    }
    s = prev;
  }
}