|
|
|
#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) {
|
|
|
|
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;
|
|
|
|
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.
|
|
|
|
|
|
|
|
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_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;
|
|
|
|
FILE *file;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct string_input_spec {
|
|
|
|
struct fh_input_spec_s spec;
|
|
|
|
const char *str;
|
|
|
|
size_t len;
|
|
|
|
size_t readpos;
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline uint8_t *inputbuf_at(struct fh_thread_s *fh, size_t pos)
|
|
|
|
{
|
|
|
|
return &fh->heap[INPUTBUF_ADDR + 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) {
|
|
|
|
//LOG("Refill, reuse %d bytes left in buffer", remains);
|
|
|
|
memmove(inputbuf_at(fh, 0), inputbuf_at(fh, fh->inputptr), remains);
|
|
|
|
fh->inputptr = 0;
|
|
|
|
fh->inputlen = remains;
|
|
|
|
} else {
|
|
|
|
//LOG("Refill, nothing reused (1)");
|
|
|
|
fh->inputptr = 0;
|
|
|
|
fh->inputlen = 0;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
//LOG("Refill, nothing reused (2)");
|
|
|
|
fh->inputptr = 0;
|
|
|
|
fh->inputlen = 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);
|
|
|
|
//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)
|
|
|
|
{
|
|
|
|
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 *fis = calloc(sizeof(struct file_input_spec), 1);
|
|
|
|
if (!fis) {
|
|
|
|
LOGE("Err alloc input spec struct");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
LOG("Input for FILE, cwd: %s", cwd);
|
|
|
|
fis->spec.free_self = free_filespec;
|
|
|
|
fis->spec.refill_input_buffer = file_refill;
|
|
|
|
fis->file = f;
|
|
|
|
if (cwd) {
|
|
|
|
fis->spec.cwd = strdup(cwd);
|
|
|
|
}
|
|
|
|
return (struct fh_input_spec_s*) fis;
|
|
|
|
}
|
|
|
|
|
|
|
|
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.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 *sis = calloc(sizeof(struct string_input_spec), 1);
|
|
|
|
if (!sis) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
LOG("Evaluating: \"%.*s\"", (int)len, str);
|
|
|
|
|
|
|
|
sis->spec.free_self = free_strspec;
|
|
|
|
sis->spec.refill_input_buffer = str_refill;
|
|
|
|
sis->str = str;
|
|
|
|
sis->readpos = 0;
|
|
|
|
sis->len = len;
|
|
|
|
sis->spec.cwd = cwd ? strdup(cwd) : NULL;
|
|
|
|
return (struct fh_input_spec_s*) sis;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|