mirrors
/
janet
mirror of https://github.com/janet-lang/janet
1
0
Fork 0
Code Issues 1 Releases Wiki Activity
janet/compile.c

1212 lines
42 KiB
C
Raw Blame History

#include "compile.h"
#include "ds.h"
#include "value.h"
#include "vm.h"
#include <string.h>
/* During compilation, FormOptions are passed to ASTs
* as configuration options to allow for some optimizations. */
typedef struct FormOptions FormOptions;
struct FormOptions {
/* The location the returned Slot must be in. Can be ignored
* if either canDrop or canChoose is true */
uint16_t target;
/* If the result of the value being compiled is not going to
* be used, some forms can simply return a nil slot and save
* copmutation */
uint16_t resultUnused : 1;
/* Allows the sub expression to evaluate into a
* temporary slot of it's choice. A temporary Slot
* can be allocated with CompilerGetLocal. */
uint16_t canChoose : 1;
/* True if the form is in the tail position. This allows
* for tail call optimization. If a helper receives this
* flag, it is free to return a returned slot and generate bytecode
* for a return, including tail calls. */
uint16_t isTail : 1;
};
/* A Slot represent a location of a local variable
* on the stack. Also contains some meta information. */
typedef struct Slot Slot;
struct Slot {
/* The index of the Slot on the stack. */
uint16_t index;
/* A nil Slot should not be expected to contain real data. (ignore index).
* Forms that have side effects but don't evaulate to
* anything will try to return bil slots. */
uint16_t isNil : 1;
/* A temp Slot is a Slot on the stack that does not
* belong to a named local. They can be freed whenever,
* and so are used in intermediate calculations. */
uint16_t isTemp : 1;
/* Flag indicating if byteCode for returning this slot
* has been written to the buffer. Should only ever be true
* when the isTail option is passed */
uint16_t hasReturned : 1;
};
/* A SlotTracker provides a handy way to keep track of
* Slots on the stack and free them in bulk. */
typedef struct SlotTracker SlotTracker;
struct SlotTracker {
Slot * slots;
uint32_t count;
uint32_t capacity;
};
/* A Scope is a lexical scope in the program. It is
* responsible for aliasing programmer facing names to
* Slots and for keeping track of literals. It also
* points to the parent Scope, and its current child
* Scope. */
struct Scope {
uint32_t level;
uint16_t nextLocal;
uint16_t frameSize;
uint32_t heapCapacity;
uint32_t heapSize;
uint16_t * freeHeap;
Dictionary * literals;
Array * literalsArray;
Dictionary * locals;
Scope * parent;
};
/* Provides default FormOptions */
static FormOptions FormOptionsDefault() {
FormOptions opts;
opts.canChoose = 1;
opts.isTail = 0;
opts.resultUnused = 0;
opts.target = 0;
return opts;
}
/* Create some helpers that allows us to push more than just raw bytes
* to the byte buffer. This helps us create the byte code for the compiled
* functions. */
BufferDefine(UInt32, uint32_t)
BufferDefine(Int32, int32_t)
BufferDefine(Number, Number)
BufferDefine(UInt16, uint16_t)
BufferDefine(Int16, int16_t)
/* If there is an error during compilation,
* jump back to start */
static void CError(Compiler * c, const char * e) {
c->error = e;
longjmp(c->onError, 1);
}
/* Push a new scope in the compiler and return
* a pointer to it for configuration. There is
* more configuration that needs to be done if
* the new scope is a function declaration. */
static Scope * CompilerPushScope(Compiler * c, int sameFunction) {
Scope * scope = VMAlloc(c->vm, sizeof(Scope));
scope->locals = DictNew(c->vm, 10);
scope->freeHeap = VMAlloc(c->vm, 10 * sizeof(uint16_t));
scope->heapSize = 0;
scope->heapCapacity = 10;
scope->parent = c->tail;
scope->frameSize = 0;
if (c->tail) {
scope->level = c->tail->level + (sameFunction ? 0 : 1);
} else {
scope->level = 0;
}
if (sameFunction) {
if (!c->tail) {
CError(c, "Cannot inherit scope when root scope");
}
scope->nextLocal = c->tail->nextLocal;
scope->literals = c->tail->literals;
scope->literalsArray = c->tail->literalsArray;
} else {
scope->nextLocal = 0;
scope->literals = DictNew(c->vm, 10);
scope->literalsArray = ArrayNew(c->vm, 10);
}
c->tail = scope;
return scope;
}
/* Remove the inner most scope from the compiler stack */
static void CompilerPopScope(Compiler * c) {
Scope * last = c->tail;
if (last == NULL) {
CError(c, "No scope to pop.");
} else {
if (last->nextLocal > last->frameSize) {
last->frameSize = last->nextLocal;
}
c->tail = last->parent;
if (c->tail) {
if (last->frameSize > c->tail->frameSize) {
c->tail->frameSize = last->frameSize;
}
}
}
}
/* Get the next stack position that is open for
* a variable */
static uint16_t CompilerGetLocal(Compiler * c, Scope * scope) {
if (scope->heapSize == 0) {
if (scope->nextLocal + 1 == 0) {
CError(c, "Too many local variables. Try splitting up your functions :)");
}
return scope->nextLocal++;
} else {
return scope->freeHeap[--scope->heapSize];
}
return 0;
}
/* Free a slot on the stack for other locals and/or
* intermediate values */
static void CompilerFreeLocal(Compiler * c, Scope * scope, uint16_t slot) {
/* Ensure heap has space */
if (scope->heapSize >= scope->heapCapacity) {
uint32_t newCap = 2 * scope->heapSize;
uint16_t * newData = VMAlloc(c->vm, newCap * sizeof(uint16_t));
memcpy(newData, scope->freeHeap, scope->heapSize * sizeof(uint16_t));
scope->freeHeap = newData;
scope->heapCapacity = newCap;
}
scope->freeHeap[scope->heapSize++] = slot;
}
/* Initializes a SlotTracker. SlotTrackers
* are used during compilation to free up slots on the stack
* after they are no longer needed. */
static void CompilerTrackerInit(Compiler * c, SlotTracker * tracker) {
tracker->slots = VMAlloc(c->vm, 10 * sizeof(Slot));
tracker->count = 0;
tracker->capacity = 10;
}
/* Free up a slot if it is a temporary slot (does not
* belong to a named local). If the slot does belong
* to a named variable, does nothing. */
static void CompilerDropSlot(Compiler * c, Scope * scope, Slot slot) {
if (!slot.isNil && slot.isTemp) {
CompilerFreeLocal(c, scope, slot.index);
}
}
/* Helper function to return a slot. Useful for compiling things that return
* nil. (set, while, etc.). Use this to wrap compilation calls that need
* to return things. */
static Slot CompilerReturn(Compiler * c, Slot slot) {
Slot ret;
ret.hasReturned = 1;
ret.isNil = 1;
if (slot.hasReturned) {
/* Do nothing */
} else if (slot.isNil) {
/* Return nil */
BufferPushUInt16(c->vm, c->buffer, VM_OP_RTN);
} else {
/* Return normal value */
BufferPushUInt16(c->vm, c->buffer, VM_OP_RET);
BufferPushUInt16(c->vm, c->buffer, slot.index);
}
return ret;
}
/* Gets a temporary slot for the bottom-most scope. */
static Slot CompilerGetTemp(Compiler * c) {
Scope * scope = c->tail;
Slot ret;
ret.isTemp = 1;
ret.isNil = 0;
ret.hasReturned = 0;
ret.index = CompilerGetLocal(c, scope);
return ret;
}
/* Return a slot that is the target Slot given some FormOptions. Will
* Create a temporary slot if needed, so be sure to drop the slot after use. */
static Slot CompilerGetTarget(Compiler * c, FormOptions opts) {
if (opts.canChoose) {
return CompilerGetTemp(c);
} else {
Slot ret;
ret.isTemp = 0;
ret.isNil = 0;
ret.hasReturned = 0;
ret.index = opts.target;
return ret;
}
}
/* If a slot is a nil slot, create a slot that has
* an actual location on the stack. */
static Slot CompilerRealizeSlot(Compiler * c, Slot slot) {
if (slot.isNil) {
slot = CompilerGetTemp(c);
BufferPushUInt16(c->vm, c->buffer, VM_OP_NIL);
BufferPushUInt16(c->vm, c->buffer, slot.index);
}
return slot;
}
/* Helper to get a nil slot */
static Slot NilSlot() { Slot ret; ret.isNil = 1; return ret; }
/* Writes all of the slots in the tracker to the compiler */
static void CompilerTrackerWrite(Compiler * c, SlotTracker * tracker, int reverse) {
uint32_t i;
Buffer * buffer = c->buffer;
for (i = 0; i < tracker->count; ++i) {
Slot s;
if (reverse)
s = tracker->slots[tracker->count - 1 - i];
else
s = tracker->slots[i];
if (s.isNil)
CError(c, "Trying to write nil slot.");
BufferPushUInt16(c->vm, buffer, s.index);
}
}
/* Free the tracker after creation. This unlocks the memory
* that was allocated by the GC an allows it to be collected. Also
* frees slots that were tracked by this tracker in the given scope. */
static void CompilerTrackerFree(Compiler * c, Scope * scope, SlotTracker * tracker) {
uint32_t i;
/* Free in reverse order */
for (i = tracker->count - 1; i < tracker->count; --i) {
CompilerDropSlot(c, scope, tracker->slots[i]);
}
}
/* Add a new Slot to a slot tracker. */
static void CompilerTrackerPush(Compiler * c, SlotTracker * tracker, Slot slot) {
if (tracker->count >= tracker->capacity) {
uint32_t newCap = 2 * tracker->count;
Slot * newData = VMAlloc(c->vm, newCap * sizeof(Slot));
memcpy(newData, tracker->slots, tracker->count * sizeof(Slot));
tracker->slots = newData;
tracker->capacity = newCap;
}
tracker->slots[tracker->count++] = slot;
}
/* Registers a literal in the given scope. If an equal literal is found, uses
* that one instead of creating a new literal. This allows for some reuse
* of things like string constants.*/
static uint16_t CompilerAddLiteral(Compiler * c, Scope * scope, Value x) {
Value checkDup = DictGet(scope->literals, x);
uint16_t literalIndex = 0;
if (checkDup.type != TYPE_NIL) {
/* An equal literal is already registered in the current scope */
return (uint16_t) checkDup.data.number;
} else {
/* Add our literal for tracking */
Value valIndex;
valIndex.type = TYPE_NUMBER;
literalIndex = scope->literalsArray->count;
valIndex.data.number = literalIndex;
DictPut(c->vm, scope->literals, x, valIndex);
ArrayPush(c->vm, scope->literalsArray, x);
}
return literalIndex;
}
/* Declare a symbol in a given scope. */
static uint16_t CompilerDeclareSymbol(Compiler * c, Scope * scope, Value sym) {
if (sym.type != TYPE_STRING) {
CError(c, "Expected symbol");
}
Value x;
uint16_t target = CompilerGetLocal(c, scope);
x.type = TYPE_NUMBER;
x.data.number = target;
DictPut(c->vm, scope->locals, sym, x);
return target;
}
/* Try to resolve a symbol. If the symbol can be resovled, return true and
* pass back the level and index by reference. */
static int ScopeSymbolResolve(Scope * scope, Value x,
uint16_t * level, uint16_t * index) {
uint32_t currentLevel = scope->level;
while (scope) {
Value check = DictGet(scope->locals, x);
if (check.type != TYPE_NIL) {
*level = currentLevel - scope->level;
*index = (uint16_t) check.data.number;
return 1;
}
scope = scope->parent;
}
return 0;
}
/* Forward declaration */
/* Compile a value and return it stack location after loading.
* If a target > 0 is passed, the returned value must be equal
* to the targtet. If target < 0, the Compiler can choose whatever
* slot location it likes. If, for example, a symbol resolves to
* whatever is in a given slot, it makes sense to use that location
* to 'return' the value. For other expressions, like function
* calls, the compiler will just pick the lowest free slot
* as the location on the stack. */
static Slot CompileValue(Compiler * c, FormOptions opts, Value x);
/* Compile a structure that evaluates to a literal value. Useful
* for objects like strings, or anything else that cannot be instatiated else {
break;
}
* from bytecode and doesn't do anything in the AST. */
static Slot CompileLiteral(Compiler * c, FormOptions opts, Value x) {
Scope * scope = c->tail;
Buffer * buffer = c->buffer;
Slot ret;
uint16_t literalIndex;
if (opts.resultUnused) return NilSlot();
ret = CompilerGetTarget(c, opts);
literalIndex = CompilerAddLiteral(c, scope, x);
BufferPushUInt16(c->vm, buffer, VM_OP_CST);
BufferPushUInt16(c->vm, buffer, ret.index);
BufferPushUInt16(c->vm, buffer, literalIndex);
return ret;
}
/* Compile boolean, nil, and number values. */
static Slot CompileNonReferenceType(Compiler * c, FormOptions opts, Value x) {
Buffer * buffer = c->buffer;
Slot ret;
if (opts.resultUnused) return NilSlot();
ret = CompilerGetTarget(c, opts);
if (x.type == TYPE_NIL) {
BufferPushUInt16(c->vm, buffer, VM_OP_NIL);
BufferPushUInt16(c->vm, buffer, ret.index);
} else if (x.type == TYPE_BOOLEAN) {
BufferPushUInt16(c->vm, buffer, x.data.boolean ? VM_OP_TRU : VM_OP_FLS);
BufferPushUInt16(c->vm, buffer, ret.index);
} else if (x.type == TYPE_NUMBER) {
Number number = x.data.number;
int32_t int32Num = (int32_t) number;
if (number == (Number) int32Num) {
if (int32Num <= 32767 && int32Num >= -32768) {
int16_t int16Num = (int16_t) number;
BufferPushUInt16(c->vm, buffer, VM_OP_I16);
BufferPushUInt16(c->vm, buffer, ret.index);
BufferPushInt16(c->vm, buffer, int16Num);
} else {
BufferPushUInt16(c->vm, buffer, VM_OP_I32);
BufferPushUInt16(c->vm, buffer, ret.index);
BufferPushInt32(c->vm, buffer, int32Num);
}
} else {
BufferPushUInt16(c->vm, buffer, VM_OP_F64);
BufferPushUInt16(c->vm, buffer, ret.index);
BufferPushNumber(c->vm, buffer, number);
}
} else {
CError(c, "Expected boolean, nil, or number type.");
}
return ret;
}
/* Compile a symbol. Resolves any kind of symbol. */
static Slot CompileSymbol(Compiler * c, FormOptions opts, Value sym) {
Buffer * buffer = c->buffer;
Scope * scope = c->tail;
uint16_t index = 0;
uint16_t level = 0;
Slot ret;
if (opts.resultUnused) return NilSlot();
if (!ScopeSymbolResolve(scope, sym, &level, &index))
CError(c, "Undefined symbol");
if (level > 0) {
/* We have an upvalue */
ret = CompilerGetTarget(c, opts);
BufferPushUInt16(c->vm, buffer, VM_OP_UPV);
BufferPushUInt16(c->vm, buffer, ret.index);
BufferPushUInt16(c->vm, buffer, level);
BufferPushUInt16(c->vm, buffer, index);
} else {
/* Local variable on stack */
ret.isTemp = 0;
ret.isNil = 0;
ret.hasReturned = 0;
if (opts.canChoose) {
ret.index = index;
} else {
/* We need to move the variable. This
* would occur in a simple assignment like a = b. */
ret.index = opts.target;
BufferPushUInt16(c->vm, buffer, VM_OP_MOV);
BufferPushUInt16(c->vm, buffer, ret.index);
BufferPushUInt16(c->vm, buffer, index);
}
}
return ret;
}
/* Compile values in an array sequentail and track the returned slots.
* If the result is unused, immediately drop slots we don't need. Can
* also ignore the end of an array. */
static void CompilerTrackerInitArray(Compiler * c, FormOptions opts,
SlotTracker * tracker, Array * array, uint32_t start, uint32_t fromEnd) {
Scope * scope = c->tail;
FormOptions subOpts = FormOptionsDefault();
uint32_t i;
/* Calculate sub flags */
subOpts.resultUnused = opts.resultUnused;
/* Compile all of the arguments */
CompilerTrackerInit(c, tracker);
/* Nothing to compile */
if (array->count <= fromEnd) return;
/* Compile body of array */
for (i = start; i < (array->count - fromEnd); ++i) {
Slot slot = CompileValue(c, subOpts, array->data[i]);
if (subOpts.resultUnused)
CompilerDropSlot(c, scope, slot);
else
CompilerTrackerPush(c, tracker, CompilerRealizeSlot(c, slot));
}
}
/* Compile a special form in the form of an operator. There
* are four choices for opcodes - when the operator is called
* with 0, 1, 2, or n arguments. When the operator form is
* called with n arguments, the number of arguments is written
* after the op code, followed by those arguments.
*
* This makes a few assumptions about the operators. One, no side
* effects. With this assumptions, if the result of the operator
* is unused, it's calculation can be ignored (the evaluation of
* its argument is still carried out, but their results can
* also be ignored). */
static Slot CompileOperator(Compiler * c, FormOptions opts, Array * form,
int16_t op0, int16_t op1, int16_t op2, int16_t opn, int reverseOperands) {
Scope * scope = c->tail;
Buffer * buffer = c->buffer;
Slot ret;
SlotTracker tracker;
/* Compile operands */
CompilerTrackerInitArray(c, opts, &tracker, form, 1, 0);
/* Free up space */
CompilerTrackerFree(c, scope, &tracker);
if (opts.resultUnused) {
ret = NilSlot();
} else {
ret = CompilerGetTarget(c, opts);
/* Write the correct opcode */
if (form->count < 2) {
if (op0 < 0) {
if (opn < 0) CError(c, "This operator does not take 0 arguments.");
goto opn;
} else {
BufferPushUInt16(c->vm, buffer, op0);
BufferPushUInt16(c->vm, buffer, ret.index);
}
} else if (form->count == 2) {
if (op1 < 0) {
if (opn < 0) CError(c, "This operator does not take 1 argument.");
goto opn;
} else {
BufferPushUInt16(c->vm, buffer, op1);
BufferPushUInt16(c->vm, buffer, ret.index);
}
} else if (form->count == 3) {
if (op2 < 0) {
if (opn < 0) CError(c, "This operator does not take 2 arguments.");
goto opn;
} else {
BufferPushUInt16(c->vm, buffer, op2);
BufferPushUInt16(c->vm, buffer, ret.index);
}
} else {
opn:
if (opn < 0) CError(c, "This operator does not take n arguments.");
BufferPushUInt16(c->vm, buffer, opn);
BufferPushUInt16(c->vm, buffer, ret.index);
BufferPushUInt16(c->vm, buffer, form->count - 1);
}
}
/* Write the location of all of the arguments */
CompilerTrackerWrite(c, &tracker, reverseOperands);
return ret;
}
/* Math specials */
static Slot CompileAddition(Compiler * c, FormOptions opts, Array * form) {
return CompileOperator(c, opts, form, VM_OP_LD0, -1, VM_OP_ADD, VM_OP_ADM, 0);
}
static Slot CompileSubtraction(Compiler * c, FormOptions opts, Array * form) {
return CompileOperator(c, opts, form, VM_OP_LD0, -1, VM_OP_SUB, VM_OP_SBM, 0);
}
static Slot CompileMultiplication(Compiler * c, FormOptions opts, Array * form) {
return CompileOperator(c, opts, form, VM_OP_LD1, -1, VM_OP_MUL, VM_OP_MUM, 0);
}
static Slot CompileDivision(Compiler * c, FormOptions opts, Array * form) {
return CompileOperator(c, opts, form, VM_OP_LD1, -1, VM_OP_DIV, VM_OP_DVM, 0);
}
static Slot CompileEquals(Compiler * c, FormOptions opts, Array * form) {
return CompileOperator(c, opts, form, VM_OP_TRU, VM_OP_TRU, VM_OP_EQL, -1, 0);
}
static Slot CompileLessThan(Compiler * c, FormOptions opts, Array * form) {
return CompileOperator(c, opts, form, VM_OP_TRU, VM_OP_TRU, VM_OP_LTN, -1, 0);
}
static Slot CompileLessThanOrEqual(Compiler * c, FormOptions opts, Array * form) {
return CompileOperator(c, opts, form, VM_OP_TRU, VM_OP_TRU, VM_OP_LTE, -1, 0);
}
static Slot CompileGreaterThan(Compiler * c, FormOptions opts, Array * form) {
return CompileOperator(c, opts, form, VM_OP_TRU, VM_OP_TRU, VM_OP_LTN, -1, 1);
}
static Slot CompileGreaterThanOrEqual(Compiler * c, FormOptions opts, Array * form) {
return CompileOperator(c, opts, form, VM_OP_TRU, VM_OP_TRU, VM_OP_LTE, -1, 1);
}
static Slot CompileNot(Compiler * c, FormOptions opts, Array * form) {
return CompileOperator(c, opts, form, VM_OP_FLS, VM_OP_NOT, -1, -1, 0);
}
static Slot CompileGet(Compiler * c, FormOptions opts, Array * form) {
return CompileOperator(c, opts, form, -1, -1, VM_OP_GET, -1, 0);
}
static Slot CompileArray(Compiler * c, FormOptions opts, Array * form) {
return CompileOperator(c, opts, form, -1, -1, -1, VM_OP_ARR, 0);
}
static Slot CompileDict(Compiler * c, FormOptions opts, Array * form) {
if ((form->count % 2) == 0) {
CError(c, "Dictionary literal requires an even number of arguments");
return NilSlot();
} else {
return CompileOperator(c, opts, form, -1, -1, -1, VM_OP_DIC, 0);
}
}
/* Associative set */
static Slot CompileSet(Compiler * c, FormOptions opts, Array * form) {
Buffer * buffer = c->buffer;
FormOptions subOpts = FormOptionsDefault();
Slot ds, key, val;
if (form->count != 4) CError(c, "Set expects 4 arguments");
if (opts.resultUnused) {
ds = CompilerRealizeSlot(c, CompileValue(c, subOpts, form->data[1]));
} else {
subOpts = opts;
subOpts.isTail = 0;
ds = CompilerRealizeSlot(c, CompileValue(c, subOpts, form->data[1]));
subOpts = FormOptionsDefault();
}
key = CompilerRealizeSlot(c, CompileValue(c, subOpts, form->data[2]));
val = CompilerRealizeSlot(c, CompileValue(c, subOpts, form->data[3]));
BufferPushUInt16(c->vm, buffer, VM_OP_SET);
BufferPushUInt16(c->vm, buffer, ds.index);
BufferPushUInt16(c->vm, buffer, key.index);
BufferPushUInt16(c->vm, buffer, val.index);
CompilerDropSlot(c, c->tail, key);
CompilerDropSlot(c, c->tail, val);
if (opts.resultUnused) {
CompilerDropSlot(c, c->tail, ds);
return NilSlot();
} else {
return ds;
}
}
/* Compile an assignment operation */
static Slot CompileAssign(Compiler * c, FormOptions opts, Value left, Value right) {
Scope * scope = c->tail;
Buffer * buffer = c->buffer;
FormOptions subOpts;
uint16_t target = 0;
uint16_t level = 0;
Slot slot;
subOpts.isTail = 0;
subOpts.resultUnused = 0;
if (ScopeSymbolResolve(scope, left, &level, &target)) {
/* Check if we have an up value. Otherwise, it's just a normal
* local variable */
if (level != 0) {
subOpts.canChoose = 1;
/* Evaluate the right hand side */
slot = CompilerRealizeSlot(c, CompileValue(c, subOpts, right));
/* Set the up value */
BufferPushUInt16(c->vm, buffer, VM_OP_SUV);
BufferPushUInt16(c->vm, buffer, slot.index);
BufferPushUInt16(c->vm, buffer, level);
BufferPushUInt16(c->vm, buffer, target);
} else {
/* Local variable */
subOpts.canChoose = 0;
subOpts.target = target;
slot = CompileValue(c, subOpts, right);
}
} else {
/* We need to declare a new symbol */
subOpts.target = CompilerDeclareSymbol(c, scope, left);
subOpts.canChoose = 0;
slot = CompileValue(c, subOpts, right);
}
if (opts.resultUnused) {
CompilerDropSlot(c, scope, slot);
return NilSlot();
} else {
return slot;
}
}
/* Compile series of expressions. This compiles the meat of
* function definitions and the inside of do forms. */
static Slot CompileBlock(Compiler * c, FormOptions opts, Array * form, uint32_t startIndex) {
Scope * scope = c->tail;
FormOptions subOpts = FormOptionsDefault();
uint32_t current = startIndex;
/* Check for empty body */
if (form->count <= startIndex) return NilSlot();
/* Compile the body */
subOpts.resultUnused = 1;
subOpts.isTail = 0;
subOpts.canChoose = 1;
while (current < form->count - 1) {
CompilerDropSlot(c, scope, CompileValue(c, subOpts, form->data[current]));
++current;
}
/* Compile the last expression in the body */
return CompileValue(c, opts, form->data[form->count - 1]);
}
/* Extract the last n bytes from the buffer and use them to construct
* a function definition. */
static FuncDef * CompilerGenFuncDef(Compiler * c, uint32_t lastNBytes, uint32_t arity) {
Scope * scope = c->tail;
Buffer * buffer = c->buffer;
FuncDef * def = VMAlloc(c->vm, sizeof(FuncDef));
/* Create enough space for the new byteCode */
if (lastNBytes > buffer->count)
CError(c, "Trying to extract more bytes from buffer than in buffer.");
uint8_t * byteCode = VMAlloc(c->vm, lastNBytes);
def->byteCode = (uint16_t *) byteCode;
def->byteCodeLen = lastNBytes / 2;
/* Copy the last chunk of bytes in the buffer into the new
* memory for the function's byteCOde */
memcpy(byteCode, buffer->data + buffer->count - lastNBytes, lastNBytes);
/* Remove the byteCode from the end of the buffer */
buffer->count -= lastNBytes;
/* Create the literals used by this function */
if (scope->literalsArray->count) {
def->literals = VMAlloc(c->vm, scope->literalsArray->count * sizeof(Value));
memcpy(def->literals, scope->literalsArray->data,
scope->literalsArray->count * sizeof(Value));
} else {
def->literals = NULL;
}
def->literalsLen = scope->literalsArray->count;
/* Delete the sub scope */
CompilerPopScope(c);
/* Initialize the new FuncDef */
def->locals = scope->frameSize;
def->arity = arity;
return def;
}
/* Compile a function from a function literal */
static Slot CompileFunction(Compiler * c, FormOptions opts, Array * form) {
Scope * scope = c->tail;
Buffer * buffer = c->buffer;
uint32_t current = 1;
uint32_t i;
uint32_t sizeBefore; /* Size of buffer before compiling function */
Scope * subScope;
Array * params;
FormOptions subOpts = FormOptionsDefault();
Slot ret;
if (opts.resultUnused) return NilSlot();
ret = CompilerGetTarget(c, opts);
subScope = CompilerPushScope(c, 0);
/* Check for function documentation - for now just ignore. */
if (form->data[current].type == TYPE_STRING)
++current;
/* Define the function parameters */
if (form->data[current].type != TYPE_ARRAY)
CError(c, "Expected function arguments");
params = form->data[current++].data.array;
for (i = 0; i < params->count; ++i) {
Value param = params->data[i];
if (param.type != TYPE_STRING)
CError(c, "Function parameters should be symbols");
/* The compiler puts the parameter locals
* in the right place by default - at the beginning
* of the stack frame. */
CompilerDeclareSymbol(c, subScope, param);
}
/* Mark where we are on the stack so we can
* return to it later. */
sizeBefore = buffer->count;
/* Compile the body in the subscope */
subOpts.isTail = 1;
CompilerReturn(c, CompileBlock(c, subOpts, form, current));
/* Create a new FuncDef as a constant in original scope by splicing
* out the relevant code from the buffer. */
{
Value newVal;
uint16_t literalIndex;
FuncDef * def = CompilerGenFuncDef(c, buffer->count - sizeBefore, params->count);
/* Add this FuncDef as a literal in the outer scope */
newVal.type = TYPE_NIL;
newVal.data.pointer = def;
literalIndex = CompilerAddLiteral(c, scope, newVal);
BufferPushUInt16(c->vm, buffer, VM_OP_CLN);
BufferPushUInt16(c->vm, buffer, ret.index);
BufferPushUInt16(c->vm, buffer, literalIndex);
}
return ret;
}
/* Branching special */
static Slot CompileIf(Compiler * c, FormOptions opts, Array * form) {
Scope * scope = c->tail;
Buffer * buffer = c->buffer;
FormOptions condOpts = opts;
FormOptions branchOpts = opts;
Slot left, right, condition;
uint32_t countAtJumpIf;
uint32_t countAtJump;
uint32_t countAfterFirstBranch;
/* Check argument count */
if (form->count < 3 || form->count > 4)
CError(c, "if takes either 2 or 3 arguments");
/* Compile the condition */
condOpts.isTail = 0;
condOpts.resultUnused = 0;
condition = CompileValue(c, condOpts, form->data[1]);
/* If the condition is nil, just compile false path */
if (condition.isNil) {
if (form->count == 4) {
return CompileValue(c, opts, form->data[3]);
}
return condition;
}
/* Mark where the buffer is now so we can write the jump
* length later */
countAtJumpIf = buffer->count;
/* Write jump instruction. Will later be replaced with correct index. */
BufferPushUInt16(c->vm, buffer, VM_OP_JIF);
BufferPushUInt16(c->vm, buffer, condition.index);
BufferPushUInt32(c->vm, buffer, 0);
/* Configure branch form options */
branchOpts.canChoose = 0;
branchOpts.target = condition.index;
/* Compile true path */
left = CompileValue(c, branchOpts, form->data[2]);
if (opts.isTail) {
CompilerReturn(c, left);
} else {
/* If we need to jump again, do so */
if (form->count == 4) {
countAtJump = buffer->count;
BufferPushUInt16(c->vm, buffer, VM_OP_JMP);
BufferPushUInt32(c->vm, buffer, 0);
}
}
CompilerDropSlot(c, scope, left);
/* Reinsert jump with correct index */
countAfterFirstBranch = buffer->count;
buffer->count = countAtJumpIf;
BufferPushUInt16(c->vm, buffer, VM_OP_JIF);
BufferPushUInt16(c->vm, buffer, condition.index);
BufferPushUInt32(c->vm, buffer, (countAfterFirstBranch - countAtJumpIf) / 2);
buffer->count = countAfterFirstBranch;
/* Compile false path */
if (form->count == 4) {
right = CompileValue(c, branchOpts, form->data[3]);
if (opts.isTail) CompilerReturn(c, right);
CompilerDropSlot(c, scope, right);
} else if (opts.isTail) {
CompilerReturn(c, condition);
}
/* Reset the second jump length */
if (!opts.isTail && form->count == 4) {
countAfterFirstBranch = buffer->count;
buffer->count = countAtJump;
BufferPushUInt16(c->vm, buffer, VM_OP_JMP);
BufferPushUInt32(c->vm, buffer, (countAfterFirstBranch - countAtJump) / 2);
buffer->count = countAfterFirstBranch;
}
if (opts.isTail)
condition.hasReturned = 1;
return condition;
}
/* While special */
static Slot CompileWhile(Compiler * c, FormOptions opts, Array * form) {
Slot cond;
uint32_t countAtStart = c->buffer->count;
uint32_t countAtJumpDelta;
uint32_t countAtFinish;
FormOptions defaultOpts = FormOptionsDefault();
CompilerPushScope(c, 1);
/* Compile condition */
cond = CompileValue(c, defaultOpts, form->data[1]);
/* Assert that cond is a real value - otherwise do nothing (nil is false,
* so loop never runs.) */
if (cond.isNil) return cond;
/* Leave space for jump later */
countAtJumpDelta = c->buffer->count;
c->buffer->count += sizeof(uint16_t) * 2 + sizeof(int32_t);
/* Compile loop body */
defaultOpts.resultUnused = 1;
CompilerDropSlot(c, c->tail, CompileBlock(c, defaultOpts, form, 2));
/* Jump back to the loop start */
countAtFinish = c->buffer->count;
BufferPushUInt16(c->vm, c->buffer, VM_OP_JMP);
BufferPushInt32(c->vm, c->buffer, (int32_t)(countAtFinish - countAtStart) / -2);
countAtFinish = c->buffer->count;
/* Set the jump to the correct length */
c->buffer->count = countAtJumpDelta;
BufferPushUInt16(c->vm, c->buffer, VM_OP_JIF);
BufferPushUInt16(c->vm, c->buffer, cond.index);
BufferPushInt32(c->vm, c->buffer, (int32_t)(countAtFinish - countAtJumpDelta) / 2);
/* Pop scope */
c->buffer->count = countAtFinish;
CompilerPopScope(c);
/* Return nil */
if (opts.resultUnused)
return NilSlot();
else
return cond;
}
/* Do special */
static Slot CompileDo(Compiler * c, FormOptions opts, Array * form) {
Slot ret;
CompilerPushScope(c, 1);
ret = CompileBlock(c, opts, form, 1);
CompilerPopScope(c);
return ret;
}
/* Quote special - returns its argument as is. */
static Slot CompileQuote(Compiler * c, FormOptions opts, Array * form) {
Scope * scope = c->tail;
Buffer * buffer = c->buffer;
Slot ret;
uint16_t literalIndex;
if (form->count != 2)
CError(c, "Quote takes exactly 1 argument.");
Value x = form->data[1];
if (x.type == TYPE_NIL ||
x.type == TYPE_BOOLEAN ||
x.type == TYPE_NUMBER) {
return CompileNonReferenceType(c, opts, x);
}
if (opts.resultUnused) return NilSlot();
ret = CompilerGetTarget(c, opts);
literalIndex = CompilerAddLiteral(c, scope, x);
BufferPushUInt16(c->vm, buffer, VM_OP_CST);
BufferPushUInt16(c->vm, buffer, ret.index);
BufferPushUInt16(c->vm, buffer, literalIndex);
return ret;
}
/* Assignment special */
static Slot CompileVar(Compiler * c, FormOptions opts, Array * form) {
if (form->count != 3)
CError(c, "Assignment expects 2 arguments");
return CompileAssign(c, opts, form->data[1], form->data[2]);
}
/* Define a function type for Special Form helpers */
typedef Slot (*SpecialFormHelper) (Compiler * c, FormOptions opts, Array * form);
/* Dispatch to a special form */
static SpecialFormHelper GetSpecial(Array * form) {
uint8_t * name;
if (form->count < 1 || form->data[0].type != TYPE_STRING)
return NULL;
name = form->data[0].data.string;
/* If we have a symbol with a zero length name, we have other
* problems. */
if (VStringSize(name) == 0)
return NULL;
/* One character specials. Mostly math. */
if (VStringSize(name) == 1) {
switch(name[0]) {
case '+': return CompileAddition;
case '-': return CompileSubtraction;
case '*': return CompileMultiplication;
case '/': return CompileDivision;
case '>': return CompileGreaterThan;
case '<': return CompileLessThan;
case '=': return CompileEquals;
default:
break;
}
}
/* Multi character specials. Mostly control flow. */
switch (name[0]) {
case '>':
{
if (VStringSize(name) == 2 &&
name[1] == '=') {
return CompileGreaterThanOrEqual;
}
}
break;
case '<':
{
if (VStringSize(name) == 2 &&
name[1] == '=') {
return CompileLessThanOrEqual;
}
}
break;
case 'a':
{
if (VStringSize(name) == 5 &&
name[1] == 'r' &&
name[2] == 'r' &&
name[3] == 'a' &&
name[4] == 'y') {
return CompileArray;
}
}
case 'g':
{
if (VStringSize(name) == 3 &&
name[1] == 'e' &&
name[2] == 't') {
return CompileGet;
}
}
case 'd':
{
if (VStringSize(name) == 2 &&
name[1] == 'o') {
return CompileDo;
} else if (VStringSize(name) == 4 &&
name[1] == 'i' &&
name[2] == 'c' &&
name[3] == 't') {
return CompileDict;
}
}
break;
case 'i':
{
if (VStringSize(name) == 2 &&
name[1] == 'f') {
return CompileIf;
}
}
break;
case 'f':
{
if (VStringSize(name) == 2 &&
name[1] == 'n') {
return CompileFunction;
}
}
break;
case 'n':
{
if (VStringSize(name) == 3 &&
name[1] == 'o' &&
name[2] == 't') {
return CompileNot;
}
}
case 'q':
{
if (VStringSize(name) == 5 &&
name[1] == 'u' &&
name[2] == 'o' &&
name[3] == 't' &&
name[4] == 'e') {
return CompileQuote;
}
}
break;
case 's':
{
if (VStringSize(name) == 3 &&
name[1] == 'e' &&
name[2] == 't') {
return CompileSet;
}
}
break;
case 'w':
{
if (VStringSize(name) == 5 &&
name[1] == 'h' &&
name[2] == 'i' &&
name[3] == 'l' &&
name[4] == 'e') {
return CompileWhile;
}
}
break;
case ':':
{
if (VStringSize(name) == 2 &&
name[1] == '=') {
return CompileVar;
}
}
break;
default:
break;
}
return NULL;
}
/* Compile a form. Checks for special forms and macros. */
static Slot CompileForm(Compiler * c, FormOptions opts, Array * form) {
Scope * scope = c->tail;
Buffer * buffer = c->buffer;
SpecialFormHelper helper;
/* Empty forms evaluate to nil. */
if (form->count == 0) {
Value temp;
temp.type = TYPE_NIL;
return CompileNonReferenceType(c, opts, temp);
}
/* Check and handle special forms */
helper = GetSpecial(form);
if (helper != NULL) {
return helper(c, opts, form);
} else {
Slot ret, callee;
SlotTracker tracker;
FormOptions subOpts = FormOptionsDefault();
uint32_t i;
CompilerTrackerInit(c, &tracker);
/* Compile function to be called */
callee = CompilerRealizeSlot(c, CompileValue(c, subOpts, form->data[0]));
/* Compile all of the arguments */
for (i = 1; i < form->count; ++i) {
Slot slot = CompileValue(c, subOpts, form->data[i]);
CompilerTrackerPush(c, &tracker, slot);
}
/* Free up some slots */
CompilerDropSlot(c, scope, callee);
CompilerTrackerFree(c, scope, &tracker);
/* If this is in tail position do a tail call. */
if (opts.isTail) {
BufferPushUInt16(c->vm, buffer, VM_OP_TCL);
BufferPushUInt16(c->vm, buffer, callee.index);
ret.hasReturned = 1;
ret.isNil = 1;
} else {
ret = CompilerGetTarget(c, opts);
BufferPushUInt16(c->vm, buffer, VM_OP_CAL);
BufferPushUInt16(c->vm, buffer, callee.index);
BufferPushUInt16(c->vm, buffer, ret.index);
}
BufferPushUInt16(c->vm, buffer, form->count - 1);
/* Write the location of all of the arguments */
CompilerTrackerWrite(c, &tracker, 0);
return ret;
}
}
/* Recursively compile any value or form */
static Slot CompileValue(Compiler * c, FormOptions opts, Value x) {
switch (x.type) {
case TYPE_NIL:
case TYPE_BOOLEAN:
case TYPE_NUMBER:
return CompileNonReferenceType(c, opts, x);
case TYPE_STRING:
return CompileSymbol(c, opts, x);
case TYPE_ARRAY:
return CompileForm(c, opts, x.data.array);
default:
return CompileLiteral(c, opts, x);
}
}
/* Initialize a Compiler struct */
void CompilerInit(Compiler * c, VM * vm) {
c->vm = vm;
c->buffer = BufferNew(vm, 128);
c->env = ArrayNew(vm, 10);
c->tail = NULL;
c->error = NULL;
CompilerPushScope(c, 0);
}
/* Register a global for the compilation environment. */
void CompilerAddGlobal(Compiler * c, const char * name, Value x) {
Value sym = ValueLoadCString(c->vm, name);
sym.type = TYPE_STRING;
CompilerDeclareSymbol(c, c->tail, sym);
ArrayPush(c->vm, c->env, x);
}
/* Register a global c function for the compilation environment. */
void CompilerAddGlobalCFunc(Compiler * c, const char * name, CFunction f) {
Value func;
func.type = TYPE_CFUNCTION;
func.data.cfunction = f;
CompilerAddGlobal(c, name, func);
}
/* Compile interface. Returns a function that evaluates the
* given AST. Returns NULL if there was an error during compilation. */
Func * CompilerCompile(Compiler * c, Value form) {
FormOptions opts = FormOptionsDefault();
FuncDef * def;
if (setjmp(c->onError)) {
/* Clear all but root scope */
if (c->tail)
c->tail->parent = NULL;
return NULL;
}
/* Create a scope */
opts.isTail = 1;
CompilerPushScope(c, 0);
CompilerReturn(c, CompileValue(c, opts, form));
def = CompilerGenFuncDef(c, c->buffer->count, 0);
{
uint32_t envSize = c->env->count;
FuncEnv * env = VMAlloc(c->vm, sizeof(FuncEnv));
Func * func = VMAlloc(c->vm, sizeof(Func));
if (envSize) {
env->values = VMAlloc(c->vm, sizeof(Value) * envSize);
memcpy(env->values, c->env->data, envSize * sizeof(Value));
} else {
env->values = NULL;
}
env->stackOffset = envSize;
env->thread = NULL;
func->parent = NULL;
func->def = def;
func->env = env;
return func;
}
}
/* Macro expansion. Macro expansion happens prior to the compilation process
* and is completely separate. This allows the compilation to not have to worry
* about garbage collection and other issues that would complicate both the
* runtime and the compilation. */
int CompileMacroExpand(VM * vm, Value x, Dictionary * macros, Value * out) {
while (x.type == TYPE_ARRAY) {
Array * form = x.data.array;
Value sym, macroFn;
if (form->count == 0) break;
sym = form->data[0];
macroFn = DictGet(macros, sym);
if (macroFn.type != TYPE_FUNCTION && macroFn.type != TYPE_CFUNCTION) break;
VMLoad(vm, macroFn);
if (VMStart(vm)) {
/* We encountered an error during parsing */
return 1;
} else {
x = vm->ret;
}
}
*out = x;
return 0;
}
Reference in New Issue View Git Blame Copy Permalink