First commit.

datatypes.h

@@ -0,0 +1,185 @@
+#ifndef DATATYPES_H_PJJ035NT
+#define DATATYPES_H_PJJ035NT
+
+#include <stdint.h>
+#include <setjmp.h>
+
+#define THREAD_STATUS_ALIVE 0
+#define THREAD_STATUS_DEAD 1
+#define THREAD_STATUS_PENDING 2
+
+typedef enum Type {
+    TYPE_NIL = 0,
+    TYPE_NUMBER,
+    TYPE_BOOLEAN,
+    TYPE_STRING,
+    TYPE_SYMBOL,
+    TYPE_ARRAY,
+    TYPE_THREAD,
+    TYPE_FORM,
+    TYPE_BYTEBUFFER,
+    TYPE_FUNCTION,
+    TYPE_CFUNCTION,
+    TYPE_DICTIONARY,
+    TYPE_FUNCDEF,
+    TYPE_FUNCENV
+} Type;
+
+typedef double Number;
+typedef uint8_t Boolean;
+typedef struct VM VM;
+typedef struct Value Value;
+typedef Value (*CFunction)(VM * vm);
+typedef struct Func Func;
+typedef struct FuncDef FuncDef;
+typedef struct FuncEnv FuncEnv;
+typedef union ValueData ValueData;
+typedef struct DictBucket DictBucket;
+typedef struct Array Array;
+typedef struct Buffer Buffer;
+typedef struct Dictionary Dictionary;
+typedef struct DictionaryIterator DictionaryIterator;
+typedef struct GC GC;
+typedef struct Parser Parser;
+typedef struct ParseState ParseState;
+typedef struct Scope Scope;
+typedef struct Compiler Compiler;
+
+union ValueData {
+    Boolean boolean;
+    Number number;
+    uint8_t * string;
+    Array * array;
+    Buffer * buffer;
+    Dictionary * dict;
+    Func * func;
+    void * pointer;
+    FuncDef * funcdef;
+    FuncEnv * funcenv;
+    CFunction cfunction;
+    uint16_t u16[4];
+    uint8_t u8[8];
+} data;
+
+/* Use an Array to represent the stack. A Stack frame is 
+ * represented by a grouping of FRAME_SIZE values. */
+#define FRAME_SIZE 4
+
+#define ThreadStack(t)   ((t)->data + (t)->count)
+
+#define FrameMeta(t)     (ThreadStack(t)[-1])
+#define FrameReturn(t)   ((ThreadStack(t) - 1)->data.u16[0])
+#define FrameSize(t)     ((ThreadStack(t) - 1)->data.u16[1])
+#define FramePrevSize(t) ((ThreadStack(t) - 1)->data.u16[2])
+
+#define FrameCallee(t)   (ThreadStack(t)[-2])
+#define FrameEnvValue(t) (ThreadStack(t)[-3])
+#define FrameEnv(t)      ((ThreadStack(t) - 3)->data.funcenv)
+#define FramePCValue(t)  (ThreadStack(t)[-4])
+#define FramePC(t)       ((ThreadStack(t)[-1]).data.pointer)
+
+struct Array {
+    uint32_t count;
+    uint32_t capacity;
+    Value * data;
+};
+
+struct Buffer {
+    uint32_t count;
+    uint32_t capacity;
+    uint8_t * data;
+};
+
+struct Dictionary {
+    uint32_t count;
+    uint32_t capacity;
+    DictBucket ** buckets;
+};
+
+struct DictionaryIterator {
+    Dictionary * dict;
+    uint32_t index;
+    DictBucket * bucket;
+};
+
+struct FuncDef {
+    uint32_t locals;
+    uint32_t arity;
+    uint32_t literalsLen;
+    uint32_t byteCodeLen;
+    Value * literals; /* Contains strings, FuncDefs, etc. */
+    uint16_t * byteCode;
+};
+
+struct FuncEnv {
+    Array * thread; /* When nil, index the local values */
+    uint32_t stackOffset; /* Used as environment size when off stack */
+    Value * values;
+};
+
+struct Func {
+    FuncDef * def;
+    FuncEnv * env;
+    Func * parent;
+};
+
+struct Value {
+    Type type;
+    ValueData data;
+};
+
+struct DictBucket {
+    Value key;
+    Value value;
+    DictBucket * next;
+};
+
+struct GC {
+    void * blocks;
+    void * user;
+    void (*handleOutOfMemory)(GC * gc);
+    uint32_t memoryInterval;
+    uint32_t nextCollection;
+    uint32_t black : 1;
+};
+
+struct VM {
+    GC gc;
+    const char * error;
+    uint16_t * pc;
+    Array * thread;
+    Value * base;
+    jmp_buf jump;
+    Value tempRoot; /* Temporary GC root */
+};
+
+/* Parsing */
+
+#define PARSER_PENDING 0
+#define PARSER_FULL 1
+#define PARSER_ERROR -1
+
+struct Parser {
+    VM * vm;
+    const char * error;
+    ParseState * data;
+    Value value;
+    uint32_t count;
+    uint32_t cap;
+    uint32_t index;
+    uint32_t status;
+};
+
+/* Compiling */
+
+struct Compiler {
+    VM * vm;
+    const char * error;
+    jmp_buf onError;
+    Scope * root;
+    Scope * tail;
+    Array * env;
+    Buffer * buffer;
+};
+
+#endif /* end of include guard: DATATYPES_H_PJJ035NT */