pforth.h

Go to the documentation of this file.

#pragma once
#include <stdint.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>


#ifdef DEBUG
#define DBG(fmt, ...) fprintf(stderr, "%s:%d: " fmt, __FILE__, __LINE__, __VA_ARGS__);
#else
#define DBG(fmt, ...) {}
#endif

#define PRINT(fmt, ...) fprintf(stdout, fmt, __VA_ARGS__);

#define LO(x) ((unsigned char) ((x) & 0xFF))
#define HI(x) ((unsigned char) (((x) >> 8) & 0xFF))

#define FORTH_DICT_SIZE 1000

#define MAX_DO_LOOP_DEPTH 3

#define MAX_BEGIN_LOOP_DEPTH 5

#define FORTH_TYPE int32_t

#define POINTER_TYPE void *

#define INT_TYPE_LIST FORTH_TYPE

typedef void (* word_function)();

struct _pforth_word {
  char* text_code;
  uint8_t size;               
  union {
    void* location;           
    word_function function;   
  };
};

typedef struct _pforth_word pforth_word;
typedef pforth_word * pforth_word_ptr;

#define WORD_IS_VARIABLE (w) (w.text_code[0] == 0x01)
#define WORD_IS_CONSTANT (w) (w.text_code[1] & 0x01)
#define WORD_IS_ARRAY (w) (w.text_code[1] & 0x02)

extern uint8_t* data_stack_top;
extern void* return_stack_top;
uint8_t* data_stack_bottom();
uint8_t* return_stack_bottom();

struct _dict_entry {
  char* key;
  pforth_word_ptr word;
  struct _dict_entry* next;
};

typedef struct _dict_entry dict_entry;

struct dict_s {
  int size;
  struct _dict_entry** table;
};

typedef struct dict_s dict_t;

dict_t* dict_create(uint32_t size);
void dict_free(dict_t* dict, uint32_t size);
pforth_word_ptr dict_set(dict_t* dict, const char* key, const pforth_word_ptr value);
pforth_word_ptr dict_get(dict_t* dict, const char* key);

extern dict_t* forth_dict;

void pforth_init();

void pforth_deinit();

pforth_word_ptr pforth_word_copy(const pforth_word_ptr dest, const pforth_word_ptr src);

pforth_word_ptr pforth_word_dup(const pforth_word_ptr src);

pforth_word_ptr pforth_word_alloc();

void pforth_word_free(const pforth_word_ptr word);

#define PFORTH_WORD_RUN(w) { word_function f = *(word->function); f(); }

int preprocess(char* line);

void eval(dict_t* dict, const char* line, const char* line_end);

void register_native(const char* op, word_function f);

void dump_stack();

#include "words.h"