CPunch/Cosmo
1
0
Fork 0
mirror of https://github.com/CPunch/Cosmo.git synced 2025-05-05 09:20:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: CPunch:dcf6a09dae1d0ebddbfdf6fe93707aeb5d1c9809
Branches Tags
CPunch:main
CPunch:error-handling
..
compare: CPunch:861607d6a8815a68bed1b476022fab42a8f50dec
Branches Tags
CPunch:main
CPunch:error-handling

No commits in common. "dcf6a09dae1d0ebddbfdf6fe93707aeb5d1c9809" and "861607d6a8815a68bed1b476022fab42a8f50dec" have entirely different histories.
dcf6a09dae ... 861607d6a8

10 changed files with 637 additions and 697 deletions
Show Stats Expand all files Collapse all files

16
src/cdebug.c
View File

@ -9,53 +9,53 @@ void printIndent(int indent)
printf("\t");
}
static int simpleInstruction(const char *name, int offset)
int simpleInstruction(const char *name, int offset)
{
printf("%s", name);
return offset + 1; // consume opcode
}
static int u8OperandInstruction(const char *name, CChunk *chunk, int offset)
int u8OperandInstruction(const char *name, CChunk *chunk, int offset)
{
printf("%-16s [%03d]", name, readu8Chunk(chunk, offset + 1));
return offset + 2;
}
static int u16OperandInstruction(const char *name, CChunk *chunk, int offset)
int u16OperandInstruction(const char *name, CChunk *chunk, int offset)
{
printf("%-16s [%05d]", name, readu16Chunk(chunk, offset + 1));
return offset + 1 + (sizeof(uint16_t) / sizeof(INSTRUCTION));
}
static int JumpInstruction(const char *name, CChunk *chunk, int offset, int dir)
int JumpInstruction(const char *name, CChunk *chunk, int offset, int dir)
{
int jmp = ((int)readu16Chunk(chunk, offset + 1)) * dir;
printf("%-16s [%05d] - jumps to %04d", name, jmp, offset + 3 + jmp);
return offset + 1 + (sizeof(uint16_t) / sizeof(INSTRUCTION));
}
static int u8u8OperandInstruction(const char *name, CChunk *chunk, int offset)
int u8u8OperandInstruction(const char *name, CChunk *chunk, int offset)
{
printf("%-16s [%03d] [%03d]", name, readu8Chunk(chunk, offset + 1),
readu8Chunk(chunk, offset + 2));
return offset + 3; // op + u8 + u8
}
static int u8u16OperandInstruction(const char *name, CChunk *chunk, int offset)
int u8u16OperandInstruction(const char *name, CChunk *chunk, int offset)
{
printf("%-16s [%03d] [%05d]", name, readu8Chunk(chunk, offset + 1),
readu16Chunk(chunk, offset + 2));
return offset + 4; // op + u8 + u16
}
static int u8u8u16OperandInstruction(const char *name, CChunk *chunk, int offset)
int u8u8u16OperandInstruction(const char *name, CChunk *chunk, int offset)
{
printf("%-16s [%03d] [%03d] [%05d]", name, readu8Chunk(chunk, offset + 1),
readu8Chunk(chunk, offset + 2), readu16Chunk(chunk, offset + 3));
return offset + 5; // op + u8 + u8 + u16
}
static int constInstruction(const char *name, CChunk *chunk, int offset)
int constInstruction(const char *name, CChunk *chunk, int offset)
{
int index = readu16Chunk(chunk, offset + 1);
printf("%-16s [%05d] - ", name, index);

16
src/clex.c
View File

@ -150,7 +150,7 @@ static bool match(CLexState *state, char expected)
return true;
}
static char peek(CLexState *state)
char peek(CLexState *state)
{
return *state->currentChar;
}
@ -163,7 +163,7 @@ static char peekNext(CLexState *state)
return state->currentChar[1];
}
static char next(CLexState *state)
char next(CLexState *state)
{
if (isEnd(state))
return '\0'; // return a null terminator
@ -171,12 +171,12 @@ static char next(CLexState *state)
return state->currentChar[-1];
}
static bool isHex(char c)
bool isHex(char c)
{
return isNumerical(c) || ('A' <= c && 'F' >= c) || ('a' <= c && 'f' >= c);
}
static CTokenType identifierType(CLexState *state)
CTokenType identifierType(CLexState *state)
{
int length = state->currentChar - state->startChar;
@ -192,7 +192,7 @@ static CTokenType identifierType(CLexState *state)
return TOKEN_IDENTIFIER;
}
static void skipWhitespace(CLexState *state)
void skipWhitespace(CLexState *state)
{
while (true) {
char c = peek(state);
@ -235,7 +235,7 @@ static void skipWhitespace(CLexState *state)
}
}
static CToken parseString(CLexState *state)
CToken parseString(CLexState *state)
{
makeBuffer(state); // buffer mode
while (peek(state) != '"' && !isEnd(state)) {
@ -341,7 +341,7 @@ static CToken parseString(CLexState *state)
return makeToken(state, TOKEN_STRING);
}
static CToken parseNumber(CLexState *state)
CToken parseNumber(CLexState *state)
{
switch (peek(state)) {
case 'x': // hexadecimal number
@ -380,7 +380,7 @@ static CToken parseNumber(CLexState *state)
return makeToken(state, TOKEN_NUMBER);
}
static CToken parseIdentifier(CLexState *state)
CToken parseIdentifier(CLexState *state)
{
// read literal
while ((isAlpha(peek(state)) || isNumerical(peek(state))) && !isEnd(state))

2
src/clex.h
View File

@ -93,7 +93,7 @@ typedef struct
char *currentChar;
char *startChar;
char *buffer; // if non-NULL & bufCount > 0, token->start & token->length will be set to buffer
// & bufCount respectively. used exclusively for string literals
// & bufCount respectively
size_t bufCount;
size_t bufCap;
int line; // current line

24
src/cmem.c
View File

@ -51,10 +51,10 @@ COSMO_API bool cosmoM_checkGarbage(CState *state, size_t needed)
return false;
}
static void markObject(CState *state, CObj *obj);
static void markValue(CState *state, CValue val);
void markObject(CState *state, CObj *obj);
void markValue(CState *state, CValue val);
static void markTable(CState *state, CTable *tbl)
void markTable(CState *state, CTable *tbl)
{
if (tbl->table == NULL) // table is still being initialized
return;
@ -68,7 +68,7 @@ static void markTable(CState *state, CTable *tbl)
}
// frees white members from the table
static void tableRemoveWhite(CState *state, CTable *tbl)
void tableRemoveWhite(CState *state, CTable *tbl)
{
if (tbl->table == NULL) // table is still being initialized
return;
@ -86,7 +86,7 @@ static void tableRemoveWhite(CState *state, CTable *tbl)
cosmoT_checkShrink(state, tbl); // recovers the memory we're no longer using
}
static void markArray(CState *state, CValueArray *array)
void markArray(CState *state, CValueArray *array)
{
for (size_t i = 0; i < array->count; i++) {
markValue(state, array->values[i]);
@ -95,7 +95,7 @@ static void markArray(CState *state, CValueArray *array)
// mark all references associated with the object
// black = keep, white = discard
static void blackenObject(CState *state, CObj *obj)
void blackenObject(CState *state, CObj *obj)
{
markObject(state, (CObj *)obj->proto);
switch (obj->type) {
@ -161,7 +161,7 @@ static void blackenObject(CState *state, CObj *obj)
}
}
static void markObject(CState *state, CObj *obj)
void markObject(CState *state, CObj *obj)
{
if (obj == NULL || obj->isMarked) // skip if NULL or already marked
return;
@ -185,14 +185,14 @@ static void markObject(CState *state, CObj *obj)
state->grayStack.array[state->grayStack.count++] = obj;
}
static void markValue(CState *state, CValue val)
void markValue(CState *state, CValue val)
{
if (IS_REF(val))
markObject(state, cosmoV_readRef(val));
}
// trace our gray references
static void traceGrays(CState *state)
void traceGrays(CState *state)
{
while (state->grayStack.count > 0) {
CObj *obj = state->grayStack.array[--state->grayStack.count];
@ -200,7 +200,7 @@ static void traceGrays(CState *state)
}
}
static void sweep(CState *state)
void sweep(CState *state)
{
CObj *prev = NULL;
CObj *object = state->objects;
@ -224,7 +224,7 @@ static void sweep(CState *state)
}
}
static void markUserRoots(CState *state)
void markUserRoots(CState *state)
{
CObj *root = state->userRoots;
@ -235,7 +235,7 @@ static void markUserRoots(CState *state)
}
}
static void markRoots(CState *state)
void markRoots(CState *state)
{
// mark all values on the stack
for (StkPtr value = state->stack; value < state->top; value++) {

1
src/cmem.h
View File

@ -67,7 +67,6 @@ COSMO_API void cosmoM_collectGarbage(CState *state);
COSMO_API void cosmoM_updateThreshhold(CState *state);
// lets the VM know you are holding a reference to a CObj and to not free it
// NOTE: prefer to use the stack when possible
COSMO_API void cosmoM_addRoot(CState *state, CObj *newRoot);
// lets the VM know this root is no longer held in a reference and is able to be freed

2
src/coperators.h
View File

@ -64,7 +64,7 @@ typedef enum
OP_FALSE,
OP_NIL,
OP_RETURN,
OP_RETURN
} COPCODE; // there can be a max of 256 instructions
#endif

10
src/cosmo.h
View File

@ -14,15 +14,7 @@
performance, however this will produce undefined behavior as you reach the stack limit (and may
cause a seg fault!). It is recommended to keep this enabled.
*/
// #define SAFE_STACK
/*
NAN_BOXXED:
if undefined, the interpreter will use a tagged union to store values. This is the default.
Note that even though the sizeof(CValue) is 8 bytes for NAN_BOXXED (as opposed to 16 bytes for
the tagged union) no performance benefits were measured. I recommend keeping this undefined for
now.
*/
#define SAFE_STACK
// #define NAN_BOXXED
// forward declare *most* stuff so our headers are cleaner

13
src/ctable.c
View File

@ -11,7 +11,7 @@
#define MIN_TABLE_CAPACITY ARRAY_START
// bit-twiddling hacks, gets the next power of 2
static unsigned int nextPow2(unsigned int x)
unsigned int nextPow2(unsigned int x)
{
if (x <= ARRAY_START - 1)
return ARRAY_START; // sanity check
@ -46,14 +46,13 @@ void cosmoT_initTable(CState *state, CTable *tbl, int startCap)
void cosmoT_addTable(CState *state, CTable *from, CTable *to)
{
CTableEntry *entry;
int cap = from->capacityMask + 1;
for (int i = 0; i < cap; i++) {
entry = &from->table[i];
CTableEntry *entry = &from->table[i];
if (!(IS_NIL(entry->key))) {
*cosmoT_insert(state, to, entry->key) = entry->val;
CValue *newVal = cosmoT_insert(state, to, entry->key);
*newVal = entry->val;
}
}
}
@ -63,7 +62,7 @@ void cosmoT_clearTable(CState *state, CTable *tbl)
cosmoM_freearray(state, CTableEntry, tbl->table, (tbl->capacityMask + 1));
}
static uint32_t getObjectHash(CObj *obj)
uint32_t getObjectHash(CObj *obj)
{
switch (obj->type) {
case COBJ_STRING:
@ -73,7 +72,7 @@ static uint32_t getObjectHash(CObj *obj)
}
}
static uint32_t getValueHash(CValue *val)
uint32_t getValueHash(CValue *val)
{
switch (GET_TYPE(*val)) {
case COSMO_TREF:

391
src/cvm.c
View File

@ -672,62 +672,15 @@ int _tbl__next(CState *state, int nargs, CValue *args)
return -1; \
}
static inline uint8_t READBYTE(CCallFrame *frame)
{
return *frame->pc++;
}
static inline uint16_t READUINT(CCallFrame *frame)
{
frame->pc += 2;
return *(uint16_t *)(&frame->pc[-2]);
}
#ifdef VM_JUMPTABLE
# define DISPATCH goto *cosmoV_dispatchTable[READBYTE(frame)]
# define CASE(op) \
DISPATCH; \
JMP_##op
# define JMPLABEL(op) &&JMP_##op
# define SWITCH \
static void *cosmoV_dispatchTable[] = { \
JMPLABEL(OP_LOADCONST), JMPLABEL(OP_SETGLOBAL), JMPLABEL(OP_GETGLOBAL), \
JMPLABEL(OP_SETLOCAL), JMPLABEL(OP_GETLOCAL), JMPLABEL(OP_GETUPVAL), \
JMPLABEL(OP_SETUPVAL), JMPLABEL(OP_PEJMP), JMPLABEL(OP_EJMP), \
JMPLABEL(OP_JMP), JMPLABEL(OP_JMPBACK), JMPLABEL(OP_POP), \
JMPLABEL(OP_CALL), JMPLABEL(OP_CLOSURE), JMPLABEL(OP_CLOSE), \
JMPLABEL(OP_NEWTABLE), JMPLABEL(OP_NEWARRAY), JMPLABEL(OP_INDEX), \
JMPLABEL(OP_NEWINDEX), JMPLABEL(OP_NEWOBJECT), JMPLABEL(OP_SETOBJECT), \
JMPLABEL(OP_GETOBJECT), JMPLABEL(OP_GETMETHOD), JMPLABEL(OP_INVOKE), \
JMPLABEL(OP_ITER), JMPLABEL(OP_NEXT), JMPLABEL(OP_ADD), \
JMPLABEL(OP_SUB), JMPLABEL(OP_MULT), JMPLABEL(OP_DIV), \
JMPLABEL(OP_MOD), JMPLABEL(OP_POW), JMPLABEL(OP_NOT), \
JMPLABEL(OP_NEGATE), JMPLABEL(OP_COUNT), JMPLABEL(OP_CONCAT), \
JMPLABEL(OP_INCLOCAL), JMPLABEL(OP_INCGLOBAL), JMPLABEL(OP_INCUPVAL), \
JMPLABEL(OP_INCINDEX), JMPLABEL(OP_INCOBJECT), JMPLABEL(OP_EQUAL), \
JMPLABEL(OP_LESS), JMPLABEL(OP_GREATER), JMPLABEL(OP_LESS_EQUAL), \
JMPLABEL(OP_GREATER_EQUAL), JMPLABEL(OP_TRUE), JMPLABEL(OP_FALSE), \
JMPLABEL(OP_NIL), JMPLABEL(OP_RETURN), \
}; \
DISPATCH;
# define DEFAULT DISPATCH /* no-op */
#else
# define CASE(op) \
continue; \
case op
# define SWITCH switch (READBYTE(frame))
# define DEFAULT \
default: \
CERROR("unknown opcode!"); \
exit(0)
#endif
// returns -1 if panic
int cosmoV_execute(CState *state)
{
CCallFrame *frame = &state->callFrame[state->frameCount - 1]; // grabs the current frame
CValue *constants = frame->closure->function->chunk.constants.values; // cache the pointer :)
#define READBYTE() *frame->pc++
#define READUINT() (frame->pc += 2, *(uint16_t *)(&frame->pc[-2]))
while (!state->panic) {
#ifdef VM_DEBUG
cosmoV_printStack(state);
@ -735,98 +688,95 @@ int cosmoV_execute(CState *state)
frame->pc - frame->closure->function->chunk.buf, state->frameCount - 1);
printf("\n");
#endif
SWITCH
{
CASE(OP_LOADCONST) :
{ // push const[uint] to stack
uint16_t indx = READUINT(frame);
switch (READBYTE()) {
case OP_LOADCONST: { // push const[uint] to stack
uint16_t indx = READUINT();
cosmoV_pushValue(state, constants[indx]);
continue;
}
CASE(OP_SETGLOBAL) :
{
uint16_t indx = READUINT(frame);
case OP_SETGLOBAL: {
uint16_t indx = READUINT();
CValue ident = constants[indx]; // grabs identifier
CValue *val = cosmoT_insert(state, &state->globals->tbl, ident);
*val = *cosmoV_pop(state); // sets the value in the hash table
continue;
}
CASE(OP_GETGLOBAL) :
{
uint16_t indx = READUINT(frame);
case OP_GETGLOBAL: {
uint16_t indx = READUINT();
CValue ident = constants[indx]; // grabs identifier
CValue val; // to hold our value
cosmoT_get(state, &state->globals->tbl, ident, &val);
cosmoV_pushValue(state, val); // pushes the value to the stack
continue;
}
CASE(OP_SETLOCAL) :
{
uint8_t indx = READBYTE(frame);
case OP_SETLOCAL: {
uint8_t indx = READBYTE();
// set base to top of stack & pop
frame->base[indx] = *cosmoV_pop(state);
continue;
}
CASE(OP_GETLOCAL) :
{
uint8_t indx = READBYTE(frame);
case OP_GETLOCAL: {
uint8_t indx = READBYTE();
cosmoV_pushValue(state, frame->base[indx]);
continue;
}
CASE(OP_GETUPVAL) :
{
uint8_t indx = READBYTE(frame);
case OP_GETUPVAL: {
uint8_t indx = READBYTE();
cosmoV_pushValue(state, *frame->closure->upvalues[indx]->val);
continue;
}
CASE(OP_SETUPVAL) :
{
uint8_t indx = READBYTE(frame);
case OP_SETUPVAL: {
uint8_t indx = READBYTE();
*frame->closure->upvalues[indx]->val = *cosmoV_pop(state);
continue;
}
CASE(OP_PEJMP) :
{ // pop equality jump
uint16_t offset = READUINT(frame);
case OP_PEJMP: { // pop equality jump
uint16_t offset = READUINT();
if (isFalsey(cosmoV_pop(state))) { // pop, if the condition is false, jump!
frame->pc += offset;
}
continue;
}
CASE(OP_EJMP) :
{ // equality jump
uint16_t offset = READUINT(frame);
case OP_EJMP: { // equality jump
uint16_t offset = READUINT();
if (isFalsey(cosmoV_getTop(state, 0))) { // if the condition is false, jump!
frame->pc += offset;
}
continue;
}
CASE(OP_JMP) :
{ // jump
uint16_t offset = READUINT(frame);
case OP_JMP: { // jump
uint16_t offset = READUINT();
frame->pc += offset;
continue;
}
CASE(OP_JMPBACK) :
{
uint16_t offset = READUINT(frame);
case OP_JMPBACK: {
uint16_t offset = READUINT();
frame->pc -= offset;
continue;
}
CASE(OP_POP) :
{ // pops value off the stack
cosmoV_setTop(state, READBYTE(frame));
case OP_POP: { // pops value off the stack
cosmoV_setTop(state, READBYTE());
continue;
}
CASE(OP_CALL) :
{
uint8_t args = READBYTE(frame);
uint8_t nres = READBYTE(frame);
case OP_CALL: {
uint8_t args = READBYTE();
uint8_t nres = READBYTE();
if (cosmoV_call(state, args, nres) != COSMOVM_OK) {
return -1;
}
continue;
}
CASE(OP_CLOSURE) :
{
uint16_t index = READUINT(frame);
case OP_CLOSURE: {
uint16_t index = READUINT();
CObjFunction *func = cosmoV_readFunction(constants[index]);
CObjClosure *closure = cosmoO_newClosure(state, func);
cosmoV_pushRef(state, (CObj *)closure);
for (int i = 0; i < closure->upvalueCount; i++) {
uint8_t encoding = READBYTE(frame);
uint8_t index = READBYTE(frame);
uint8_t encoding = READBYTE();
uint8_t index = READBYTE();
if (encoding == OP_GETUPVAL) {
// capture upvalue from current frame's closure
closure->upvalues[i] = frame->closure->upvalues[index];
@ -835,20 +785,21 @@ int cosmoV_execute(CState *state)
closure->upvalues[i] = captureUpvalue(state, frame->base + index);
}
}
continue;
}
CASE(OP_CLOSE) :
{
case OP_CLOSE: {
closeUpvalues(state, state->top - 1);
cosmoV_pop(state);
continue;
}
CASE(OP_NEWTABLE) :
{
uint16_t pairs = READUINT(frame);
case OP_NEWTABLE: {
uint16_t pairs = READUINT();
cosmoV_makeTable(state, pairs);
continue;
}
CASE(OP_NEWARRAY) :
{
uint16_t pairs = READUINT(frame);
case OP_NEWARRAY: {
uint16_t pairs = READUINT();
StkPtr val;
CObjTable *newObj = cosmoO_newTable(state);
cosmoV_pushRef(state, (CObj *)newObj); // so our GC doesn't free our new table
@ -865,9 +816,9 @@ int cosmoV_execute(CState *state)
// once done, pop everything off the stack + push new table
cosmoV_setTop(state, pairs + 1); // + 1 for our table
cosmoV_pushRef(state, (CObj *)newObj);
continue;
}
CASE(OP_INDEX) :
{
case OP_INDEX: {
StkPtr key = cosmoV_getTop(state, 0); // key should be the top of the stack
StkPtr temp = cosmoV_getTop(state, 1); // after that should be the table
@ -898,9 +849,9 @@ int cosmoV_execute(CState *state)
cosmoV_setTop(state, 2); // pops the table & the key
cosmoV_pushValue(state, val); // pushes the field result
continue;
}
CASE(OP_NEWINDEX) :
{
case OP_NEWINDEX: {
StkPtr value = cosmoV_getTop(state, 0); // value is at the top of the stack
StkPtr key = cosmoV_getTop(state, 1);
StkPtr temp = cosmoV_getTop(state, 2); // table is after the key
@ -915,8 +866,7 @@ int cosmoV_execute(CState *state)
CObjObject *proto = cosmoO_grabProto(obj);
if (proto != NULL) {
if (!cosmoO_newIndexObject(
state, proto, *key,
if (!cosmoO_newIndexObject(state, proto, *key,
*value)) // if it returns false, cosmoV_error was called
return -1;
} else if (obj->type == COBJ_TABLE) {
@ -932,17 +882,17 @@ int cosmoV_execute(CState *state)
// pop everything off the stack
cosmoV_setTop(state, 3);
continue;
}
CASE(OP_NEWOBJECT) :
{
uint16_t pairs = READUINT(frame);
case OP_NEWOBJECT: {
uint16_t pairs = READUINT();
cosmoV_makeObject(state, pairs);
continue;
}
CASE(OP_SETOBJECT) :
{
case OP_SETOBJECT: {
StkPtr value = cosmoV_getTop(state, 0); // value is at the top of the stack
StkPtr temp = cosmoV_getTop(state, 1); // object is after the value
uint16_t ident = READUINT(frame); // use for the key
uint16_t ident = READUINT(); // use for the key
// sanity check
if (IS_REF(*temp)) {
@ -957,12 +907,12 @@ int cosmoV_execute(CState *state)
// pop everything off the stack
cosmoV_setTop(state, 2);
continue;
}
CASE(OP_GETOBJECT) :
{
case OP_GETOBJECT: {
CValue val; // to hold our value
StkPtr temp = cosmoV_getTop(state, 0); // that should be the object
uint16_t ident = READUINT(frame); // use for the key
uint16_t ident = READUINT(); // use for the key
// sanity check
if (IS_REF(*temp)) {
@ -977,15 +927,15 @@ int cosmoV_execute(CState *state)
cosmoV_setTop(state, 1); // pops the object
cosmoV_pushValue(state, val); // pushes the field result
continue;
}
CASE(OP_GETMETHOD) :
{
case OP_GETMETHOD: {
CValue val; // to hold our value
StkPtr temp = cosmoV_getTop(state, 0); // that should be the object
uint16_t ident = READUINT(frame); // use for the key
uint16_t ident = READUINT(); // use for the key
// this is almost identical to GETOBJECT, however cosmoV_getMethod is used instead
// of just cosmoV_get
// this is almost identical to GETOBJECT, however cosmoV_getMethod is used instead of
// just cosmoV_get
if (IS_REF(*temp)) {
if (!cosmoV_getMethod(state, cosmoV_readRef(*temp), constants[ident], &val))
return -1;
@ -998,12 +948,12 @@ int cosmoV_execute(CState *state)
cosmoV_setTop(state, 1); // pops the object
cosmoV_pushValue(state, val); // pushes the field result
continue;
}
CASE(OP_INVOKE) :
{
uint8_t args = READBYTE(frame);
uint8_t nres = READBYTE(frame);
uint16_t ident = READUINT(frame);
case OP_INVOKE: {
uint8_t args = READBYTE();
uint8_t nres = READBYTE();
uint16_t ident = READUINT();
StkPtr temp = cosmoV_getTop(state, args); // grabs object from stack
CValue val; // to hold our value
@ -1019,9 +969,10 @@ int cosmoV_execute(CState *state)
cosmoV_error(state, "Couldn't get from type %s!", cosmoV_typeStr(*temp));
return -1;
}
continue;
}
CASE(OP_ITER) :
{
case OP_ITER: {
StkPtr temp = cosmoV_getTop(state, 0); // should be the object/table
if (!IS_REF(*temp)) {
@ -1041,16 +992,15 @@ int cosmoV_execute(CState *state)
cosmoV_pushValue(state, val);
cosmoV_pushRef(state, (CObj *)obj);
if (cosmoV_call(state, 1, 1) !=
COSMOVM_OK) // we expect 1 return value on the stack, the iterable
// object
COSMOVM_OK) // we expect 1 return value on the stack, the iterable object
return -1;
StkPtr iObj = cosmoV_getTop(state, 0);
if (!IS_OBJECT(*iObj)) {
cosmoV_error(state,
"Expected iterable object! '__iter' returned %s, expected "
"<object>!",
cosmoV_error(
state,
"Expected iterable object! '__iter' returned %s, expected <object>!",
cosmoV_typeStr(*iObj));
return -1;
}
@ -1072,13 +1022,11 @@ int cosmoV_execute(CState *state)
CObjCFunction *tbl_next = cosmoO_newCFunction(state, _tbl__next);
cosmoV_pushRef(state, (CObj *)tbl_next); // value
CObjObject *obj =
cosmoV_makeObject(state, 2); // pushes the new object to the stack
CObjObject *obj = cosmoV_makeObject(state, 2); // pushes the new object to the stack
cosmoO_setUserI(obj, 0); // increment for iterator
// make our CObjMethod for OP_NEXT to call
CObjMethod *method =
cosmoO_newMethod(state, cosmoV_newRef(tbl_next), (CObj *)obj);
CObjMethod *method = cosmoO_newMethod(state, cosmoV_newRef(tbl_next), (CObj *)obj);
cosmoV_setTop(state, 2); // pops the object & the tbl
cosmoV_pushRef(state, (CObj *)method); // pushes the method for OP_NEXT
@ -1087,11 +1035,12 @@ int cosmoV_execute(CState *state)
cosmoO_typeStr(obj));
return -1;
}
continue;
}
CASE(OP_NEXT) :
{
uint8_t nresults = READBYTE(frame);
uint16_t jump = READUINT(frame);
case OP_NEXT: {
uint8_t nresults = READBYTE();
uint16_t jump = READUINT();
StkPtr temp = cosmoV_getTop(state, 0); // we don't actually pop this off the stack
if (!IS_METHOD(*temp)) {
@ -1109,29 +1058,25 @@ int cosmoV_execute(CState *state)
cosmoV_setTop(state, nresults); // pop the return values
frame->pc += jump;
}
continue;
}
CASE(OP_ADD) :
{
// pop 2 values off the stack & try to add them together
case OP_ADD: { // pop 2 values off the stack & try to add them together
NUMBEROP(cosmoV_newNumber, +);
continue;
}
CASE(OP_SUB) :
{
// pop 2 values off the stack & try to subtracts them
NUMBEROP(cosmoV_newNumber, -);
case OP_SUB: { // pop 2 values off the stack & try to subtracts them
NUMBEROP(cosmoV_newNumber, -)
continue;
}
CASE(OP_MULT) :
{
// pop 2 values off the stack & try to multiplies them together
NUMBEROP(cosmoV_newNumber, *);
case OP_MULT: { // pop 2 values off the stack & try to multiplies them together
NUMBEROP(cosmoV_newNumber, *)
continue;
}
CASE(OP_DIV) :
{
// pop 2 values off the stack & try to divides them
NUMBEROP(cosmoV_newNumber, /);
case OP_DIV: { // pop 2 values off the stack & try to divides them
NUMBEROP(cosmoV_newNumber, /)
continue;
}
CASE(OP_MOD) :
{
case OP_MOD: {
StkPtr valA = cosmoV_getTop(state, 1);
StkPtr valB = cosmoV_getTop(state, 0);
if (IS_NUMBER(*valA) && IS_NUMBER(*valB)) {
@ -1143,9 +1088,9 @@ int cosmoV_execute(CState *state)
cosmoV_typeStr(*valB));
return -1;
}
continue;
}
CASE(OP_POW) :
{
case OP_POW: {
StkPtr valA = cosmoV_getTop(state, 1);
StkPtr valB = cosmoV_getTop(state, 0);
if (IS_NUMBER(*valA) && IS_NUMBER(*valB)) {
@ -1157,13 +1102,13 @@ int cosmoV_execute(CState *state)
cosmoV_typeStr(*valB));
return -1;
}
continue;
}
CASE(OP_NOT) :
{
case OP_NOT: {
cosmoV_pushBoolean(state, isFalsey(cosmoV_pop(state)));
continue;
}
CASE(OP_NEGATE) :
{ // pop 1 value off the stack & try to negate
case OP_NEGATE: { // pop 1 value off the stack & try to negate
StkPtr val = cosmoV_getTop(state, 0);
if (IS_NUMBER(*val)) {
@ -1173,9 +1118,9 @@ int cosmoV_execute(CState *state)
cosmoV_error(state, "Expected number, got %s!", cosmoV_typeStr(*val));
return -1;
}
continue;
}
CASE(OP_COUNT) :
{
case OP_COUNT: {
StkPtr temp = cosmoV_getTop(state, 0);
if (!IS_REF(*temp)) {
@ -1187,16 +1132,16 @@ int cosmoV_execute(CState *state)
cosmoV_pop(state);
cosmoV_pushNumber(state, count); // pushes the count onto the stack
continue;
}
CASE(OP_CONCAT) :
{
uint8_t vals = READBYTE(frame);
case OP_CONCAT: {
uint8_t vals = READBYTE();
cosmoV_concat(state, vals);
continue;
}
CASE(OP_INCLOCAL) :
{ // this leaves the value on the stack
int8_t inc = READBYTE(frame) - 128; // amount we're incrementing by
uint8_t indx = READBYTE(frame);
case OP_INCLOCAL: { // this leaves the value on the stack
int8_t inc = READBYTE() - 128; // amount we're incrementing by
uint8_t indx = READBYTE();
StkPtr val = &frame->base[indx];
// check that it's a number value
@ -1207,11 +1152,12 @@ int cosmoV_execute(CState *state)
cosmoV_error(state, "Expected number, got %s!", cosmoV_typeStr(*val));
return -1;
}
continue;
}
CASE(OP_INCGLOBAL) :
{
int8_t inc = READBYTE(frame) - 128; // amount we're incrementing by
uint16_t indx = READUINT(frame);
case OP_INCGLOBAL: {
int8_t inc = READBYTE() - 128; // amount we're incrementing by
uint16_t indx = READUINT();
CValue ident = constants[indx]; // grabs identifier
CValue *val = cosmoT_insert(state, &state->globals->tbl, ident);
@ -1223,11 +1169,12 @@ int cosmoV_execute(CState *state)
cosmoV_error(state, "Expected number, got %s!", cosmoV_typeStr(*val));
return -1;
}
continue;
}
CASE(OP_INCUPVAL) :
{
int8_t inc = READBYTE(frame) - 128; // amount we're incrementing by
uint8_t indx = READBYTE(frame);
case OP_INCUPVAL: {
int8_t inc = READBYTE() - 128; // amount we're incrementing by
uint8_t indx = READBYTE();
CValue *val = frame->closure->upvalues[indx]->val;
// check that it's a number value
@ -1238,16 +1185,16 @@ int cosmoV_execute(CState *state)
cosmoV_error(state, "Expected number, got %s!", cosmoV_typeStr(*val));
return -1;
}
continue;
}
CASE(OP_INCINDEX) :
{
int8_t inc = READBYTE(frame) - 128; // amount we're incrementing by
case OP_INCINDEX: {
int8_t inc = READBYTE() - 128; // amount we're incrementing by
StkPtr temp = cosmoV_getTop(state, 1); // object should be above the key
StkPtr key = cosmoV_getTop(state, 0); // grabs key
if (!IS_REF(*temp)) {
cosmoV_error(state, "Couldn't index non-indexable type %s!",
cosmoV_typeStr(*temp));
cosmoV_error(state, "Couldn't index non-indexable type %s!", cosmoV_typeStr(*temp));
return -1;
}
@ -1289,11 +1236,12 @@ int cosmoV_execute(CState *state)
cosmoV_typeStr(*temp));
return -1;
}
continue;
}
CASE(OP_INCOBJECT) :
{
int8_t inc = READBYTE(frame) - 128; // amount we're incrementing by
uint16_t indx = READUINT(frame);
case OP_INCOBJECT: {
int8_t inc = READBYTE() - 128; // amount we're incrementing by
uint16_t indx = READUINT();
StkPtr temp = cosmoV_getTop(state, 0); // object should be at the top of the stack
CValue ident = constants[indx]; // grabs identifier
@ -1322,42 +1270,57 @@ int cosmoV_execute(CState *state)
cosmoV_error(state, "Couldn't set a field on type %s!", cosmoV_typeStr(*temp));
return -1;
}
continue;
}
CASE(OP_EQUAL) :
{
case OP_EQUAL: {
// pop vals
StkPtr valB = cosmoV_pop(state);
StkPtr valA = cosmoV_pop(state);
// compare & push
cosmoV_pushBoolean(state, cosmoV_equal(state, *valA, *valB));
continue;
}
CASE(OP_GREATER) :
{
NUMBEROP(cosmoV_newBoolean, >);
case OP_GREATER: {
NUMBEROP(cosmoV_newBoolean, >)
continue;
}
CASE(OP_LESS) :
{
NUMBEROP(cosmoV_newBoolean, <);
case OP_LESS: {
NUMBEROP(cosmoV_newBoolean, <)
continue;
}
CASE(OP_GREATER_EQUAL) :
{
NUMBEROP(cosmoV_newBoolean, >=);
case OP_GREATER_EQUAL: {
NUMBEROP(cosmoV_newBoolean, >=)
continue;
}
CASE(OP_LESS_EQUAL)
: {NUMBEROP(cosmoV_newBoolean, <=)} CASE(OP_TRUE) : cosmoV_pushBoolean(state, true);
CASE(OP_FALSE) : cosmoV_pushBoolean(state, false);
CASE(OP_NIL) : cosmoV_pushValue(state, cosmoV_newNil());
CASE(OP_RETURN) :
{
uint8_t res = READBYTE(frame);
case OP_LESS_EQUAL: {
NUMBEROP(cosmoV_newBoolean, <=)
continue;
}
case OP_TRUE:
cosmoV_pushBoolean(state, true);
continue;
case OP_FALSE:
cosmoV_pushBoolean(state, false);
continue;
case OP_NIL:
cosmoV_pushValue(state, cosmoV_newNil());
continue;
case OP_RETURN: {
uint8_t res = READBYTE();
return res;
}
DEFAULT;
default:
CERROR("unknown opcode!");
exit(0);
}
}
// we'll only reach this if state->panic is true
#undef READBYTE
#undef READUINT
// we'll only reach this is state->panic is true
return -1;
}

13
src/cvm.h
View File

@ -8,19 +8,6 @@
// #define VM_DEBUG
/*
if we're using GNUC or clang, we can use computed gotos which speeds up
cosmoV_execute by about 20% from benchmarking. of course, if you know
your compiler supports computed gotos, you can define VM_JUMPTABLE
BTW: be weary of maliciously crafted cosmo dumps!! it's very easy to crash
cosmo with this enabled and reading invalid opcodes due to us just using the
opcode as an index into the jump table
*/
#if defined(__GNUC__) || defined(__clang__)
# define VM_JUMPTABLE
#endif
typedef enum
{
COSMOVM_OK,