mirror of
https://github.com/krgamestudios/Toy.git
synced 2026-04-20 01:04:08 +10:00
380 lines
12 KiB
C
380 lines
12 KiB
C
#include "bytecode_inspector.h"
|
|
#include "toy_console_colors.h"
|
|
#include "toy_opcodes.h"
|
|
#include "toy_value.h"
|
|
#include "toy_string.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <ctype.h>
|
|
|
|
int inspect_instruction(unsigned char* bytecode, unsigned int pc, unsigned int jumps_addr, unsigned int data_addr);
|
|
int inspect_read(unsigned char* bytecode, unsigned int pc, unsigned int jumps_addr, unsigned int data_addr);
|
|
|
|
// void inspect_jumps(unsigned char* bytecode, unsigned int pc, unsigned int size);
|
|
// void inspect_param(unsigned char* bytecode, unsigned int pc, unsigned int size);
|
|
// void inspect_data(unsigned char* bytecode, unsigned int pc, unsigned int size);
|
|
// void inspect_subs(unsigned char* bytecode, unsigned int pc, unsigned int size);
|
|
|
|
#define ISPRINT_SANITIZE(x) (isprint((int)x) > 0 ? (x) : '_')
|
|
|
|
#define MARKER_VALUE(pc, type) \
|
|
(pc * sizeof(type))
|
|
|
|
#define MARKER "\t\033[" TOY_CC_FONT_BLACK "m" " %lu\t" TOY_CC_RESET
|
|
#define FONT_BLACK "\033[" TOY_CC_FONT_BLACK "m"
|
|
|
|
//exposed functions
|
|
int inspect_bytecode(unsigned char* bytecode) {
|
|
//TODO: handle version info
|
|
|
|
unsigned int const bytecodeSize = ((unsigned int*)(bytecode))[0];
|
|
unsigned int const jumpsSize = ((unsigned int*)(bytecode))[1];
|
|
unsigned int const paramSize = ((unsigned int*)(bytecode))[2];
|
|
unsigned int const dataSize = ((unsigned int*)(bytecode))[3];
|
|
unsigned int const subsSize = ((unsigned int*)(bytecode))[4];
|
|
|
|
printf(FONT_BLACK ".header:\r" TOY_CC_RESET);
|
|
|
|
//bytecode size
|
|
printf(MARKER TOY_CC_NOTICE "Bytecode Size: \t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(0, unsigned int), bytecodeSize);
|
|
|
|
//header counts
|
|
printf(MARKER TOY_CC_NOTICE "Jumps Size:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(1, unsigned int), jumpsSize);
|
|
printf(MARKER TOY_CC_NOTICE "Param Size:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(2, unsigned int), paramSize);
|
|
printf(MARKER TOY_CC_NOTICE "Data Size:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(3, unsigned int), dataSize);
|
|
printf(MARKER TOY_CC_NOTICE "Subs Size:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(4, unsigned int), subsSize);
|
|
|
|
//some addresses may be absent
|
|
unsigned int addr_pc = 4;
|
|
unsigned int code_addr = 0;
|
|
unsigned int jumps_addr = 0;
|
|
unsigned int param_addr = 0;
|
|
unsigned int data_addr = 0;
|
|
unsigned int subs_addr = 0;
|
|
|
|
//bugfix
|
|
unsigned int code_end = 0;
|
|
|
|
//header addresses
|
|
if (true) {
|
|
addr_pc++;
|
|
printf(MARKER TOY_CC_NOTICE "Code Address:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(addr_pc, unsigned int), ((unsigned int*)(bytecode))[addr_pc]);
|
|
code_addr = ((unsigned int*)(bytecode))[addr_pc];
|
|
}
|
|
|
|
if (jumpsSize > 0) {
|
|
addr_pc++;
|
|
printf(MARKER TOY_CC_NOTICE "Jumps Address:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(addr_pc, unsigned int), ((unsigned int*)(bytecode))[addr_pc]);
|
|
jumps_addr = ((unsigned int*)(bytecode))[addr_pc];
|
|
if (code_end == 0) code_end = jumps_addr;
|
|
}
|
|
|
|
if (paramSize > 0) {
|
|
addr_pc++;
|
|
printf(MARKER TOY_CC_NOTICE "Param Address:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(addr_pc, unsigned int), ((unsigned int*)(bytecode))[addr_pc]);
|
|
param_addr = ((unsigned int*)(bytecode))[addr_pc];
|
|
if (code_end == 0) code_end = param_addr;
|
|
}
|
|
|
|
if (dataSize > 0) {
|
|
addr_pc++;
|
|
printf(MARKER TOY_CC_NOTICE "Data Address:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(addr_pc, unsigned int), ((unsigned int*)(bytecode))[addr_pc]);
|
|
data_addr = ((unsigned int*)(bytecode))[addr_pc];
|
|
if (code_end == 0) code_end = data_addr;
|
|
}
|
|
|
|
if (subsSize > 0) {
|
|
addr_pc++;
|
|
printf(MARKER TOY_CC_NOTICE "Subs Address:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(addr_pc, unsigned int), ((unsigned int*)(bytecode))[addr_pc]);
|
|
subs_addr = ((unsigned int*)(bytecode))[addr_pc];
|
|
if (code_end == 0) code_end = subs_addr;
|
|
}
|
|
|
|
if (code_end == 0) code_end = bytecodeSize; //very hacky
|
|
|
|
printf(FONT_BLACK ".code:\r" TOY_CC_RESET);
|
|
|
|
unsigned int pc = code_addr;
|
|
while(pc < code_end) {
|
|
pc += inspect_instruction(bytecode, pc, jumps_addr, data_addr);
|
|
}
|
|
|
|
//jumps
|
|
if (jumpsSize > 0) {
|
|
printf(FONT_BLACK ".jumps:\r" TOY_CC_RESET);
|
|
|
|
for (unsigned int i = 0; (i*4) < jumpsSize; i++) {
|
|
printf(MARKER TOY_CC_NOTICE "%u (data %u)" TOY_CC_RESET "\n", MARKER_VALUE(jumps_addr + i, unsigned int),
|
|
i,
|
|
((unsigned int*)(bytecode + jumps_addr))[i] + data_addr
|
|
);
|
|
}
|
|
}
|
|
|
|
//param
|
|
if (paramSize > 0) {
|
|
printf(FONT_BLACK ".param:\r" TOY_CC_RESET);
|
|
|
|
for (unsigned int i = 0; (i*4) < paramSize; i += 2) {
|
|
printf(MARKER TOY_CC_NOTICE "%u (type %s, data %u)" TOY_CC_RESET "\n", MARKER_VALUE(param_addr + i, unsigned int),
|
|
i,
|
|
Toy_private_getValueTypeAsCString(((unsigned int*)(bytecode + param_addr))[i + 1]),
|
|
((unsigned int*)(bytecode + param_addr))[i] + data_addr
|
|
);
|
|
}
|
|
}
|
|
|
|
//data; assume there's only strings for now
|
|
if (dataSize > 0) {
|
|
printf(FONT_BLACK ".data:\r" TOY_CC_RESET);
|
|
|
|
for (unsigned int i = 0; (i*4) < dataSize; i++) {
|
|
printf(MARKER TOY_CC_NOTICE "%c %c %c %c" TOY_CC_RESET "\n", MARKER_VALUE(data_addr + i, unsigned int),
|
|
ISPRINT_SANITIZE(((char*)(bytecode + data_addr + (i*4)))[0]),
|
|
ISPRINT_SANITIZE(((char*)(bytecode + data_addr + (i*4)))[1]),
|
|
ISPRINT_SANITIZE(((char*)(bytecode + data_addr + (i*4)))[2]),
|
|
ISPRINT_SANITIZE(((char*)(bytecode + data_addr + (i*4)))[3])
|
|
);
|
|
}
|
|
}
|
|
|
|
//subs
|
|
if (subsSize > 0) {
|
|
printf(FONT_BLACK ".subs:\n" TOY_CC_RESET);
|
|
|
|
unsigned int i = 0;
|
|
while (i < subsSize) {
|
|
i += inspect_bytecode(bytecode + subs_addr + i);
|
|
}
|
|
}
|
|
|
|
return bytecodeSize;
|
|
}
|
|
|
|
int inspect_instruction(unsigned char* bytecode, unsigned int pc, unsigned int jumps_addr, unsigned int data_addr) {
|
|
//read and print the opcode instruction at 'pc'
|
|
|
|
Toy_OpcodeType opcode = bytecode[pc];
|
|
|
|
switch(opcode) {
|
|
case TOY_OPCODE_READ:
|
|
return inspect_read(bytecode, pc, jumps_addr, data_addr);
|
|
|
|
case TOY_OPCODE_DECLARE: {
|
|
unsigned int indexValue = *((unsigned int*)(bytecode + pc + 4));
|
|
unsigned int jumpValue = *((unsigned int*)(bytecode + jumps_addr + indexValue));
|
|
char* cstr = ((char*)(bytecode + data_addr + jumpValue));
|
|
printf(MARKER "DECLARE %s: %s%s\n", MARKER_VALUE(pc, unsigned char),
|
|
cstr,
|
|
Toy_private_getValueTypeAsCString(bytecode[pc + 1]),
|
|
bytecode[pc + 3] ? " const" : ""
|
|
);
|
|
return 8;
|
|
}
|
|
|
|
case TOY_OPCODE_ASSIGN:
|
|
printf(MARKER "ASSIGN %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] ? "(chained)" : "");
|
|
return 4;
|
|
|
|
case TOY_OPCODE_ASSIGN_COMPOUND:
|
|
printf(MARKER "ASSIGN COMPOUND %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] ? "(chained)" : "");
|
|
return 4;
|
|
|
|
case TOY_OPCODE_ACCESS:
|
|
printf(MARKER "ACCESS\n", MARKER_VALUE(pc, unsigned char));
|
|
return 4;
|
|
|
|
case TOY_OPCODE_INVOKE:
|
|
printf(MARKER "INVOKE as '%s' (%d parameters)\n", MARKER_VALUE(pc, unsigned char),
|
|
Toy_private_getValueTypeAsCString(bytecode[pc + 1]),
|
|
bytecode[pc + 2]);
|
|
return 4;
|
|
|
|
case TOY_OPCODE_DUPLICATE:
|
|
printf(MARKER "DUPLICATE %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] ? "and ACCESS" : "");
|
|
return 4;
|
|
|
|
case TOY_OPCODE_ELIMINATE:
|
|
printf(MARKER "ELIMINATE\n", MARKER_VALUE(pc, unsigned char));
|
|
return 4;
|
|
|
|
case TOY_OPCODE_ADD:
|
|
printf(MARKER "ADD %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] == TOY_OPCODE_ASSIGN ? "and ASSIGN" : "");
|
|
return 4;
|
|
|
|
case TOY_OPCODE_SUBTRACT:
|
|
printf(MARKER "SUBTRACT %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] == TOY_OPCODE_ASSIGN ? "and ASSIGN" : "");
|
|
return 4;
|
|
|
|
case TOY_OPCODE_MULTIPLY:
|
|
printf(MARKER "MULTIPLY %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] == TOY_OPCODE_ASSIGN ? "and ASSIGN" : "");
|
|
return 4;
|
|
|
|
case TOY_OPCODE_DIVIDE:
|
|
printf(MARKER "DIVIDE %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] == TOY_OPCODE_ASSIGN ? "and ASSIGN" : "");
|
|
return 4;
|
|
|
|
case TOY_OPCODE_MODULO:
|
|
printf(MARKER "MODULO %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] == TOY_OPCODE_ASSIGN ? "and ASSIGN" : "");
|
|
return 4;
|
|
|
|
case TOY_OPCODE_COMPARE_EQUAL:
|
|
printf(MARKER "COMPARE %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] != TOY_OPCODE_NEGATE ? "==" : "!=");
|
|
return 4;
|
|
|
|
case TOY_OPCODE_COMPARE_LESS:
|
|
printf(MARKER "COMPARE '<'\n", MARKER_VALUE(pc, unsigned char));
|
|
return 4;
|
|
|
|
case TOY_OPCODE_COMPARE_LESS_EQUAL:
|
|
printf(MARKER "COMPARE '<='\n", MARKER_VALUE(pc, unsigned char));
|
|
return 4;
|
|
|
|
case TOY_OPCODE_COMPARE_GREATER:
|
|
printf(MARKER "COMPARE '>'\n", MARKER_VALUE(pc, unsigned char));
|
|
return 4;
|
|
|
|
case TOY_OPCODE_COMPARE_GREATER_EQUAL:
|
|
printf(MARKER "COMPARE '>='\n", MARKER_VALUE(pc, unsigned char));
|
|
return 4;
|
|
|
|
case TOY_OPCODE_AND:
|
|
printf(MARKER "LOGICAL '&&'\n", MARKER_VALUE(pc, unsigned char));
|
|
return 4;
|
|
|
|
case TOY_OPCODE_OR:
|
|
printf(MARKER "LOGICAL '||'\n", MARKER_VALUE(pc, unsigned char));
|
|
return 4;
|
|
|
|
case TOY_OPCODE_TRUTHY:
|
|
printf(MARKER "LOGICAL TRUTHY\n", MARKER_VALUE(pc, unsigned char));
|
|
return 4;
|
|
|
|
case TOY_OPCODE_NEGATE:
|
|
printf(MARKER "LOGICAL NEGATE\n", MARKER_VALUE(pc, unsigned char));
|
|
return 4;
|
|
|
|
case TOY_OPCODE_RETURN:
|
|
printf(MARKER "Keyword RETURN (%u)\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1]);
|
|
return 4;
|
|
|
|
case TOY_OPCODE_JUMP:
|
|
printf(MARKER TOY_CC_DEBUG "JUMP %s%s (%s%d) (GOTO %u)\n" TOY_CC_RESET, MARKER_VALUE(pc, unsigned char),
|
|
bytecode[pc + 1] == TOY_OP_PARAM_JUMP_ABSOLUTE ? "absolute" : "relative",
|
|
bytecode[pc + 2] == TOY_OP_PARAM_JUMP_ALWAYS ? "" :
|
|
bytecode[pc + 2] == TOY_OP_PARAM_JUMP_IF_TRUE ? " if true" : " if false",
|
|
bytecode[pc + 4] > 0 ? "+" : "", //show a + sign when positive
|
|
bytecode[pc + 4],
|
|
bytecode[pc + 4] + pc + 8
|
|
);
|
|
return 8;
|
|
|
|
case TOY_OPCODE_ESCAPE:
|
|
printf(MARKER TOY_CC_DEBUG "ESCAPE relative %s%d (GOTO %u) and pop %d\n" TOY_CC_RESET, MARKER_VALUE(pc, unsigned char),
|
|
bytecode[pc + 4] > 0 ? "+" : "", //show a + sign when positive
|
|
bytecode[pc + 4],
|
|
bytecode[pc + 4] + pc + 12,
|
|
bytecode[pc + 8]
|
|
);
|
|
return 12;
|
|
|
|
case TOY_OPCODE_SCOPE_PUSH:
|
|
printf(MARKER "SCOPE PUSH\n", MARKER_VALUE(pc, unsigned char));
|
|
return 4;
|
|
|
|
case TOY_OPCODE_SCOPE_POP:
|
|
printf(MARKER "SCOPE POP\n", MARKER_VALUE(pc, unsigned char));
|
|
return 4;
|
|
|
|
case TOY_OPCODE_ASSERT:
|
|
printf(MARKER TOY_CC_WARN "Keyword ASSERT (cond%s)\n" TOY_CC_RESET, MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] > 1 ? ",msg" : "");
|
|
return 4;
|
|
|
|
case TOY_OPCODE_PRINT:
|
|
printf(MARKER TOY_CC_NOTICE "Keyword PRINT\n" TOY_CC_RESET, MARKER_VALUE(pc, unsigned char));
|
|
return 4;
|
|
|
|
case TOY_OPCODE_CONCAT:
|
|
printf(MARKER "CONCATENATE strings\n", MARKER_VALUE(pc, unsigned char));
|
|
return 4;
|
|
|
|
case TOY_OPCODE_INDEX:
|
|
printf(MARKER "INDEX (%d elements)\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1]);
|
|
return 4;
|
|
|
|
// case TOY_OPCODE_UNUSED:
|
|
// case TOY_OPCODE_PASS:
|
|
// case TOY_OPCODE_ERROR:
|
|
// case TOY_OPCODE_EOF:
|
|
|
|
default:
|
|
printf(MARKER TOY_CC_WARN "Unknown Word: [%u, %u, %u, %u]" TOY_CC_RESET "\n", MARKER_VALUE(pc, unsigned char), bytecode[pc], bytecode[pc+1], bytecode[pc+2], bytecode[pc+3]);
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
int inspect_read(unsigned char* bytecode, unsigned int pc, unsigned int jumps_addr, unsigned int data_addr) {
|
|
Toy_ValueType type = bytecode[pc + 1];
|
|
|
|
switch(type) {
|
|
case TOY_VALUE_NULL: {
|
|
printf(MARKER "READ NULL\n", MARKER_VALUE(pc, unsigned char));
|
|
return 4;
|
|
}
|
|
|
|
case TOY_VALUE_BOOLEAN: {
|
|
if (bytecode[pc + 2]) {
|
|
printf(MARKER "READ BOOL true\n", MARKER_VALUE(pc, unsigned char));
|
|
}
|
|
else {
|
|
|
|
}
|
|
return 4;
|
|
}
|
|
|
|
case TOY_VALUE_INTEGER: {
|
|
int i = *(int*)(bytecode + pc + 4);
|
|
printf(MARKER "READ INTEGER %d\n", MARKER_VALUE(pc, unsigned char), i);
|
|
return 8;
|
|
}
|
|
|
|
case TOY_VALUE_FLOAT: {
|
|
float i = *(float*)(bytecode + pc + 4);
|
|
printf(MARKER "READ FLOAT %f\n", MARKER_VALUE(pc, unsigned char), i);
|
|
return 8;
|
|
}
|
|
|
|
case TOY_VALUE_STRING: {
|
|
Toy_StringType stringType = (Toy_StringType)(*(bytecode + pc + 2)); //Probably not needed
|
|
int len = bytecode[pc + 3]; //only used for names?
|
|
(void)len;
|
|
|
|
(void)stringType;
|
|
|
|
unsigned int indexValue = *((unsigned int*)(bytecode + pc + 4));
|
|
unsigned int jumpValue = *((unsigned int*)(bytecode + jumps_addr + indexValue));
|
|
char* cstr = ((char*)(bytecode + data_addr + jumpValue));
|
|
|
|
printf(MARKER "READ STRING %u '%s'\n", MARKER_VALUE(pc, unsigned char), indexValue, cstr);
|
|
|
|
return 8;
|
|
}
|
|
|
|
case TOY_VALUE_FUNCTION:
|
|
printf(MARKER "READ FUNCTION '%u' (%d params)\n", MARKER_VALUE(pc, unsigned char), *((unsigned int*)(bytecode + pc + 4)), bytecode[pc + 2]);
|
|
return 8;
|
|
|
|
case TOY_VALUE_ARRAY:
|
|
case TOY_VALUE_TABLE:
|
|
case TOY_VALUE_OPAQUE:
|
|
case TOY_VALUE_ANY:
|
|
case TOY_VALUE_UNKNOWN:
|
|
default: {
|
|
printf(MARKER "READ %s (unhandled by inspector)\n", MARKER_VALUE(pc, unsigned char), Toy_private_getValueTypeAsCString(type));
|
|
return 4;
|
|
}
|
|
}
|
|
}
|
|
|
|
//TODO: Check if strings are reused in the bytecode
|