628 lines
20 KiB
C
628 lines
20 KiB
C
#include "../../include/ground.h"
|
|
#include <stdio.h>
|
|
#include <inttypes.h>
|
|
#include <string.h>
|
|
|
|
/*
|
|
* Return values guide:
|
|
* -2: Exit program
|
|
* -1: Nothing
|
|
* 0-infinity: Jump to instruction number
|
|
*/
|
|
|
|
int64_t _GroundInstructionExecute(GroundInstruction* instruction, GroundValue* heap) {
|
|
|
|
static const void* jumpTable[] = {
|
|
&&IF, &&JUMP, &&END,
|
|
&&INPUT, &&PRINT, &&PRINTLN,
|
|
&&SET, &&GETTYPE, &&EXISTS,
|
|
&&SETLIST, &&SETLISTAT, &&GETLISTAT, &&GETLISTSIZE, &&LISTAPPEND,
|
|
&&GETSTRSIZE, &&GETSTRCHARAT,
|
|
&&ADD, &&SUBTRACT, &&MULTIPLY, &&DIVIDE,
|
|
&&EQUAL, &&INEQUAL, &&NOT, &&GREATER, &&LESSER,
|
|
&&AND, &&OR, &&XOR, &&NEG, &&SHIFT,
|
|
&&STOI, &&STOD, &&ITOC, &&CTOI, &&TOSTRING,
|
|
&&FUN, &&RETURN, &&ENDFUN, &&CALL, &&CALLMETHOD,
|
|
&&STRUCT, &&ENDSTRUCT, &&INIT, &&GETFIELD, &&SETFIELD,
|
|
&&USE, &&EXTERN, &&CREATELABEL,
|
|
&&PAUSE, &&DROP, &&LICENSE, &&ERRORCMD, &&THROW, &&CATCH
|
|
};
|
|
|
|
// Preprocess any ValueRefs
|
|
for (size_t i = 0; i < instruction->args.len; i++) {
|
|
if (instruction->args.at[i].type == GroundArg_ValueRef) {
|
|
size_t offset = instruction->args.at[i]._offset;
|
|
instruction->args.at[i] = Ground.New.Arg.Value(heap[offset]);
|
|
}
|
|
}
|
|
|
|
// Jump to the spot
|
|
goto *jumpTable[instruction->type];
|
|
|
|
IF: {
|
|
if (instruction->args.at[0].as.value.as.Bool) {
|
|
return instruction->args.at[1]._offset;
|
|
}
|
|
return -1;
|
|
}
|
|
JUMP: {
|
|
return instruction->args.at[0]._offset;
|
|
}
|
|
END: {
|
|
return -2;
|
|
}
|
|
INPUT: {
|
|
char input[2048];
|
|
fgets(input, sizeof(input) - 1, stdin);
|
|
input[2047] = '\0';
|
|
|
|
GroundString string = Ground.New.String(input);
|
|
GroundValue value = Ground.New.Value.String(string);
|
|
heap[instruction->args.at[0]._offset] = value;
|
|
return -1;
|
|
}
|
|
PRINT: {
|
|
for (size_t i = 0; i < instruction->args.len; i++) {
|
|
GroundValue* val = &instruction->args.at[i].as.value;
|
|
switch (val->type.type) {
|
|
case GroundType_Int:
|
|
printf("%" PRId64, val->as.Int);
|
|
break;
|
|
|
|
case GroundType_Double:
|
|
printf("%f", val->as.Double);
|
|
break;
|
|
|
|
case GroundType_Bool:
|
|
printf(val->as.Bool ? "true" : "false");
|
|
break;
|
|
|
|
case GroundType_Char:
|
|
printf("%c", val->as.Char);
|
|
break;
|
|
|
|
case GroundType_String:
|
|
printf("%s", val->as.String.cstr);
|
|
break;
|
|
|
|
default:
|
|
printf("<fixme>");
|
|
break;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
PRINTLN: {
|
|
for (size_t i = 0; i < instruction->args.len; i++) {
|
|
GroundValue* val = &instruction->args.at[i].as.value;
|
|
switch (val->type.type) {
|
|
case GroundType_Int:
|
|
printf("%" PRId64, val->as.Int);
|
|
break;
|
|
|
|
case GroundType_Double:
|
|
printf("%f", val->as.Double);
|
|
break;
|
|
|
|
case GroundType_Bool:
|
|
printf(val->as.Bool ? "true" : "false");
|
|
break;
|
|
|
|
case GroundType_Char:
|
|
printf("%c", val->as.Char);
|
|
break;
|
|
|
|
case GroundType_String:
|
|
printf("%s", val->as.String.cstr);
|
|
break;
|
|
|
|
default:
|
|
printf("<fixme>");
|
|
break;
|
|
}
|
|
}
|
|
printf("\n");
|
|
return -1;
|
|
}
|
|
SET: {
|
|
size_t offset = instruction->args.at[0]._offset;
|
|
heap[offset] = instruction->args.at[1].as.value;
|
|
return -1;
|
|
}
|
|
GETTYPE: {
|
|
Ground.Log.Warning("GETTYPE is deprecated");
|
|
return -1;
|
|
}
|
|
EXISTS: {
|
|
Ground.Log.Warning("EXISTS is deprecated");
|
|
return -1;
|
|
}
|
|
SETLIST: {
|
|
return -1;
|
|
}
|
|
SETLISTAT: {
|
|
return -1;
|
|
}
|
|
GETLISTAT: {
|
|
return -1;
|
|
}
|
|
GETLISTSIZE: {
|
|
return -1;
|
|
}
|
|
LISTAPPEND: {
|
|
return -1;
|
|
}
|
|
GETSTRSIZE: {
|
|
return -1;
|
|
}
|
|
GETSTRCHARAT: {
|
|
return -1;
|
|
}
|
|
ADD: {
|
|
GroundValue* final = &heap[instruction->args.at[2]._offset];
|
|
GroundValue* left = &instruction->args.at[0].as.value;
|
|
GroundValue* right = &instruction->args.at[1].as.value;
|
|
|
|
switch (left->type.type) {
|
|
case GroundType_Int: {
|
|
switch (right->type.type) {
|
|
case GroundType_Int: {
|
|
*final = Ground.New.Value.Int(left->as.Int + right->as.Int);
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
*final = Ground.New.Value.Double(left->as.Int + right->as.Double);
|
|
break;
|
|
}
|
|
default: {
|
|
Ground.Log.Error("invalid add operation in Ground.Instruction.execute()");
|
|
Ground.Flags.error = true;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
switch (right->type.type) {
|
|
case GroundType_Int: {
|
|
*final = Ground.New.Value.Double(left->as.Double + right->as.Int);
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
*final = Ground.New.Value.Double(left->as.Double + right->as.Double);
|
|
break;
|
|
}
|
|
default: {
|
|
Ground.Log.Error("invalid add operation in Ground.Instruction.execute()");
|
|
Ground.Flags.error = true;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GroundType_String: {
|
|
switch (right->type.type) {
|
|
case GroundType_String: {
|
|
char* buf = malloc(sizeof(char) * (left->as.String.len + right->as.String.len + 1));
|
|
if (buf == NULL) {
|
|
Ground.Log.Error("malloc failed (instruction ADD{string, string, dirref}) in Ground.Instruction.execute()");
|
|
Ground.Flags.error = true;
|
|
break;
|
|
}
|
|
sprintf(buf, "%s%s", left->as.String.cstr, right->as.String.cstr);
|
|
*final = Ground.New.Value.String(Ground.New.String(buf));
|
|
break;
|
|
}
|
|
default: {
|
|
Ground.Log.Error("invalid add operation in Ground.Instruction.execute()");
|
|
Ground.Flags.error = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
default: {
|
|
Ground.Log.Error("invalid add operation in Ground.Instruction.execute()");
|
|
Ground.Flags.error = true;
|
|
break;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
SUBTRACT: {
|
|
GroundValue* final = &heap[instruction->args.at[2]._offset];
|
|
GroundValue* left = &instruction->args.at[0].as.value;
|
|
GroundValue* right = &instruction->args.at[1].as.value;
|
|
|
|
switch (left->type.type) {
|
|
case GroundType_Int: {
|
|
switch (right->type.type) {
|
|
case GroundType_Int: {
|
|
*final = Ground.New.Value.Int(left->as.Int - right->as.Int);
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
*final = Ground.New.Value.Double(left->as.Int - right->as.Double);
|
|
break;
|
|
}
|
|
default: {
|
|
Ground.Log.Error("invalid subtract operation in Ground.Instruction.execute()");
|
|
Ground.Flags.error = true;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
switch (right->type.type) {
|
|
case GroundType_Int: {
|
|
*final = Ground.New.Value.Double(left->as.Double - right->as.Int);
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
*final = Ground.New.Value.Double(left->as.Double - right->as.Double);
|
|
break;
|
|
}
|
|
default: {
|
|
Ground.Log.Error("invalid subtract operation in Ground.Instruction.execute()");
|
|
Ground.Flags.error = true;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
Ground.Log.Error("invalid subtract operation in Ground.Instruction.execute()");
|
|
Ground.Flags.error = true;
|
|
break;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
MULTIPLY: {
|
|
GroundValue* final = &heap[instruction->args.at[2]._offset];
|
|
GroundValue* left = &instruction->args.at[0].as.value;
|
|
GroundValue* right = &instruction->args.at[1].as.value;
|
|
|
|
switch (left->type.type) {
|
|
case GroundType_Int: {
|
|
switch (right->type.type) {
|
|
case GroundType_Int: {
|
|
*final = Ground.New.Value.Int(left->as.Int * right->as.Int);
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
*final = Ground.New.Value.Double(left->as.Int * right->as.Double);
|
|
break;
|
|
}
|
|
default: {
|
|
Ground.Log.Error("invalid subtract operation in Ground.Instruction.execute()");
|
|
Ground.Flags.error = true;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
switch (right->type.type) {
|
|
case GroundType_Int: {
|
|
*final = Ground.New.Value.Double(left->as.Double * right->as.Int);
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
*final = Ground.New.Value.Double(left->as.Double * right->as.Double);
|
|
break;
|
|
}
|
|
default: {
|
|
Ground.Log.Error("invalid subtract operation in Ground.Instruction.execute()");
|
|
Ground.Flags.error = true;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
Ground.Log.Error("invalid subtract operation in Ground.Instruction.execute()");
|
|
Ground.Flags.error = true;
|
|
break;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
DIVIDE: {
|
|
GroundValue* final = &heap[instruction->args.at[2]._offset];
|
|
GroundValue* left = &instruction->args.at[0].as.value;
|
|
GroundValue* right = &instruction->args.at[1].as.value;
|
|
|
|
switch (left->type.type) {
|
|
case GroundType_Int: {
|
|
switch (right->type.type) {
|
|
case GroundType_Int: {
|
|
*final = Ground.New.Value.Int(left->as.Int / right->as.Int);
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
*final = Ground.New.Value.Double(left->as.Int / right->as.Double);
|
|
break;
|
|
}
|
|
default: {
|
|
Ground.Log.Error("invalid subtract operation in Ground.Instruction.execute()");
|
|
Ground.Flags.error = true;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
switch (right->type.type) {
|
|
case GroundType_Int: {
|
|
*final = Ground.New.Value.Double(left->as.Double / right->as.Int);
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
*final = Ground.New.Value.Double(left->as.Double / right->as.Double);
|
|
break;
|
|
}
|
|
default: {
|
|
Ground.Log.Error("invalid subtract operation in Ground.Instruction.execute()");
|
|
Ground.Flags.error = true;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
Ground.Log.Error("invalid subtract operation in Ground.Instruction.execute()");
|
|
Ground.Flags.error = true;
|
|
break;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
EQUAL: {
|
|
GroundValue* final = &heap[instruction->args.at[2]._offset];
|
|
GroundValue* left = &instruction->args.at[0].as.value;
|
|
GroundValue* right = &instruction->args.at[1].as.value;
|
|
|
|
switch (left->type.type) {
|
|
case GroundType_Int: {
|
|
switch (right->type.type) {
|
|
case GroundType_Int: {
|
|
*final = Ground.New.Value.Bool(left->as.Int == right->as.Int);
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
*final = Ground.New.Value.Bool(left->as.Int == right->as.Double);
|
|
break;
|
|
}
|
|
default: {
|
|
*final = Ground.New.Value.Bool(false);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
switch (right->type.type) {
|
|
case GroundType_Int: {
|
|
*final = Ground.New.Value.Bool(left->as.Double == right->as.Int);
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
*final = Ground.New.Value.Bool(left->as.Double == right->as.Double);
|
|
break;
|
|
}
|
|
default: {
|
|
*final = Ground.New.Value.Bool(false);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GroundType_Char: {
|
|
if (right->type.type == GroundType_Char) {
|
|
*final = Ground.New.Value.Bool(left->as.Char == right->as.Char);
|
|
} else {
|
|
*final = Ground.New.Value.Bool(false);
|
|
}
|
|
break;
|
|
}
|
|
case GroundType_Bool: {
|
|
if (right->type.type == GroundType_Bool) {
|
|
*final = Ground.New.Value.Bool(left->as.Bool == right->as.Bool);
|
|
} else {
|
|
*final = Ground.New.Value.Bool(false);
|
|
}
|
|
break;
|
|
}
|
|
case GroundType_String: {
|
|
if (right->type.type == GroundType_String) {
|
|
*final = Ground.New.Value.Bool(strcmp(left->as.String.cstr, right->as.String.cstr));
|
|
} else {
|
|
*final = Ground.New.Value.Bool(false);
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
// FIXME implement for complex types
|
|
*final = Ground.New.Value.Bool(false);
|
|
break;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
INEQUAL: {
|
|
GroundValue* final = &heap[instruction->args.at[2]._offset];
|
|
GroundValue* left = &instruction->args.at[0].as.value;
|
|
GroundValue* right = &instruction->args.at[1].as.value;
|
|
|
|
switch (left->type.type) {
|
|
case GroundType_Int: {
|
|
switch (right->type.type) {
|
|
case GroundType_Int: {
|
|
*final = Ground.New.Value.Bool(left->as.Int != right->as.Int);
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
*final = Ground.New.Value.Bool(left->as.Int != right->as.Double);
|
|
break;
|
|
}
|
|
default: {
|
|
*final = Ground.New.Value.Bool(true);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
switch (right->type.type) {
|
|
case GroundType_Int: {
|
|
*final = Ground.New.Value.Bool(left->as.Double != right->as.Int);
|
|
break;
|
|
}
|
|
case GroundType_Double: {
|
|
*final = Ground.New.Value.Bool(left->as.Double != right->as.Double);
|
|
break;
|
|
}
|
|
default: {
|
|
*final = Ground.New.Value.Bool(true);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GroundType_Char: {
|
|
if (right->type.type == GroundType_Char) {
|
|
*final = Ground.New.Value.Bool(left->as.Char != right->as.Char);
|
|
} else {
|
|
*final = Ground.New.Value.Bool(true);
|
|
}
|
|
break;
|
|
}
|
|
case GroundType_Bool: {
|
|
if (right->type.type == GroundType_Bool) {
|
|
*final = Ground.New.Value.Bool(left->as.Bool != right->as.Bool);
|
|
} else {
|
|
*final = Ground.New.Value.Bool(true);
|
|
}
|
|
break;
|
|
}
|
|
case GroundType_String: {
|
|
if (right->type.type == GroundType_String) {
|
|
*final = Ground.New.Value.Bool(!strcmp(left->as.String.cstr, right->as.String.cstr));
|
|
} else {
|
|
*final = Ground.New.Value.Bool(true);
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
// FIXME implement for complex types
|
|
*final = Ground.New.Value.Bool(false);
|
|
break;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
NOT: {
|
|
heap[instruction->args.at[1]._offset] = Ground.New.Value.Bool(!instruction->args.at[0].as.value.as.Bool);
|
|
return -1;
|
|
}
|
|
GREATER: {
|
|
return -1;
|
|
}
|
|
LESSER: {
|
|
return -1;
|
|
}
|
|
AND: {
|
|
return -1;
|
|
}
|
|
OR: {
|
|
return -1;
|
|
}
|
|
XOR: {
|
|
return -1;
|
|
}
|
|
NEG: {
|
|
return -1;
|
|
}
|
|
SHIFT: {
|
|
return -1;
|
|
}
|
|
STOI: {
|
|
return -1;
|
|
}
|
|
STOD: {
|
|
return -1;
|
|
}
|
|
ITOC: {
|
|
return -1;
|
|
}
|
|
CTOI: {
|
|
return -1;
|
|
}
|
|
TOSTRING: {
|
|
return -1;
|
|
}
|
|
FUN: {
|
|
return -1;
|
|
}
|
|
RETURN: {
|
|
return -1;
|
|
}
|
|
ENDFUN: {
|
|
return -1;
|
|
}
|
|
CALL: {
|
|
return -1;
|
|
}
|
|
CALLMETHOD: {
|
|
return -1;
|
|
}
|
|
STRUCT: {
|
|
return -1;
|
|
}
|
|
ENDSTRUCT: {
|
|
return -1;
|
|
}
|
|
INIT: {
|
|
return -1;
|
|
}
|
|
GETFIELD: {
|
|
return -1;
|
|
}
|
|
SETFIELD: {
|
|
return -1;
|
|
}
|
|
USE: {
|
|
return -1;
|
|
}
|
|
EXTERN: {
|
|
return -1;
|
|
}
|
|
CREATELABEL: {
|
|
return -1;
|
|
}
|
|
PAUSE: {
|
|
return -1;
|
|
}
|
|
DROP: {
|
|
return -1;
|
|
}
|
|
LICENSE: {
|
|
return -1;
|
|
}
|
|
ERRORCMD: {
|
|
return -1;
|
|
}
|
|
THROW: {
|
|
return -1;
|
|
}
|
|
CATCH: {
|
|
return -1;
|
|
}
|
|
|
|
Ground.Log.Error("operation fell through in Ground.Instruction.execute()");
|
|
Ground.Flags.error = true;
|
|
|
|
return -1;
|
|
}
|