From cce8ae1ea3dadbeb1834cc4a70ab12dbf02a1854 Mon Sep 17 00:00:00 2001 From: Kayne Ruse Date: Mon, 14 Aug 2023 23:06:05 +1000 Subject: [PATCH] Added disassembler, thanks @hiperiondev, bumped minor version --- source/toy_common.h | 4 +- tools/disassembler/disassembler | Bin 0 -> 36144 bytes tools/disassembler/disassembler.c | 550 +++++++++++++++++++++ tools/disassembler/disassembler.h | 119 +++++ tools/disassembler/main.c | 8 + tools/disassembler/makefile | 27 + tools/{ => misc}/changing-of-the-guard.cpp | 0 tools/{ => misc}/mecha.cpp | 0 tools/{ => misc}/uptown.cpp | 0 9 files changed, 706 insertions(+), 2 deletions(-) create mode 100755 tools/disassembler/disassembler create mode 100644 tools/disassembler/disassembler.c create mode 100644 tools/disassembler/disassembler.h create mode 100644 tools/disassembler/main.c create mode 100644 tools/disassembler/makefile rename tools/{ => misc}/changing-of-the-guard.cpp (100%) rename tools/{ => misc}/mecha.cpp (100%) rename tools/{ => misc}/uptown.cpp (100%) diff --git a/source/toy_common.h b/source/toy_common.h index 2f9b239..e67704c 100644 --- a/source/toy_common.h +++ b/source/toy_common.h @@ -54,7 +54,7 @@ The current minor version of Toy. This value is embedded into the bytecode, and This value MUST fit into an unsigned char. !*/ -#define TOY_VERSION_MINOR 2 +#define TOY_VERSION_MINOR 3 /*! ### TOY_VERSION_PATCH @@ -64,7 +64,7 @@ The current patch version of Toy. This value is embedded into the bytecode. This value MUST fit into an unsigned char. !*/ -#define TOY_VERSION_PATCH 2 +#define TOY_VERSION_PATCH 0 /*! ### TOY_VERSION_BUILD diff --git a/tools/disassembler/disassembler b/tools/disassembler/disassembler new file mode 100755 index 0000000000000000000000000000000000000000..007905b66813606a8d3789f385ce167fc7f6d127 GIT binary patch literal 36144 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 +#include +#include +#include +#include + +#include "disassembler.h" + +#define SPC(n) printf("%.*s", n, "| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |"); +#define EP(x) [x] = #x + +const char *OP_STR[] = { + EP(DIS_OP_EOF), // + EP(DIS_OP_PASS), // + EP(DIS_OP_ASSERT), // + EP(DIS_OP_PRINT), // + EP(DIS_OP_LITERAL), // + EP(DIS_OP_LITERAL_LONG), // + EP(DIS_OP_LITERAL_RAW), // + EP(DIS_OP_NEGATE), // + EP(DIS_OP_ADDITION), // + EP(DIS_OP_SUBTRACTION), // + EP(DIS_OP_MULTIPLICATION), // + EP(DIS_OP_DIVISION), // + EP(DIS_OP_MODULO), // + EP(DIS_OP_GROUPING_BEGIN), // + EP(DIS_OP_GROUPING_END), // + EP(DIS_OP_SCOPE_BEGIN), // + EP(DIS_OP_SCOPE_END), // + EP(DIS_OP_TYPE_DECL_removed), // + EP(DIS_OP_TYPE_DECL_LONG_removed), // + EP(DIS_OP_VAR_DECL), // + EP(DIS_OP_VAR_DECL_LONG), // + EP(DIS_OP_FN_DECL), // + EP(DIS_OP_FN_DECL_LONG), // + EP(DIS_OP_VAR_ASSIGN), // + EP(DIS_OP_VAR_ADDITION_ASSIGN), // + EP(DIS_OP_VAR_SUBTRACTION_ASSIGN), // + EP(DIS_OP_VAR_MULTIPLICATION_ASSIGN), // + EP(DIS_OP_VAR_DIVISION_ASSIGN), // + EP(DIS_OP_VAR_MODULO_ASSIGN), // + EP(DIS_OP_TYPE_CAST), // + EP(DIS_OP_TYPE_OF), // + EP(DIS_OP_IMPORT), // + EP(DIS_OP_EXPORT_removed), // + EP(DIS_OP_INDEX), // + EP(DIS_OP_INDEX_ASSIGN), // + EP(DIS_OP_INDEX_ASSIGN_INTERMEDIATE), // + EP(DIS_OP_DOT), // + EP(DIS_OP_COMPARE_EQUAL), // + EP(DIS_OP_COMPARE_NOT_EQUAL), // + EP(DIS_OP_COMPARE_LESS), // + EP(DIS_OP_COMPARE_LESS_EQUAL), // + EP(DIS_OP_COMPARE_GREATER), // + EP(DIS_OP_COMPARE_GREATER_EQUAL), // + EP(DIS_OP_INVERT), // + EP(DIS_OP_AND), // + EP(DIS_OP_OR), // + EP(DIS_OP_JUMP), // + EP(DIS_OP_IF_FALSE_JUMP), // + EP(DIS_OP_FN_CALL), // + EP(DIS_OP_FN_RETURN), // + EP(DIS_OP_POP_STACK), // + EP(DIS_OP_TERNARY), // + EP(DIS_OP_FN_END), // + }; + +const char *LIT_STR[] = { + EP(DIS_LITERAL_NULL), // + EP(DIS_LITERAL_BOOLEAN), // + EP(DIS_LITERAL_INTEGER), // + EP(DIS_LITERAL_FLOAT), // + EP(DIS_LITERAL_STRING), // + EP(DIS_LITERAL_ARRAY), // + EP(DIS_LITERAL_DICTIONARY), // + EP(DIS_LITERAL_FUNCTION), // + EP(DIS_LITERAL_IDENTIFIER), // + EP(DIS_LITERAL_TYPE), // + EP(DIS_LITERAL_OPAQUE), // + EP(DIS_LITERAL_ANY), // + EP(DIS_LITERAL_TYPE_INTERMEDIATE), // + EP(DIS_LITERAL_ARRAY_INTERMEDIATE), // + EP(DIS_LITERAL_DICTIONARY_INTERMEDIATE), // + EP(DIS_LITERAL_FUNCTION_INTERMEDIATE), // + EP(DIS_LITERAL_FUNCTION_ARG_REST), // + EP(DIS_LITERAL_FUNCTION_NATIVE), // + EP(DIS_LITERAL_FUNCTION_HOOK), // + EP(DIS_LITERAL_INDEX_BLANK), // + }; + +enum DIS_ARG_TYPE { + DIS_ARG_NONE, // + DIS_ARG_BYTE, // + DIS_ARG_WORD, // + DIS_ARG_INTEGER, // + DIS_ARG_FLOAT, // + DIS_ARG_STRING // +}; + +const uint8_t OP_ARGS[DIS_OP_END_OPCODES][2] = { + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_EOF + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_PASS + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_ASSERT + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_PRINT + { DIS_ARG_BYTE, DIS_ARG_NONE }, // DIS_OP_LITERAL + { DIS_ARG_WORD, DIS_ARG_NONE }, // DIS_OP_LITERAL_LONG + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_LITERAL_RAW + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_NEGATE + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_ADDITION + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_SUBTRACTION + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_MULTIPLICATION + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_DIVISION + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_MODULO + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_GROUPING_BEGIN + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_GROUPING_END + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_SCOPE_BEGIN + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_SCOPE_END + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_TYPE_DECL_removed + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_TYPE_DECL_LONG_removed + { DIS_ARG_BYTE, DIS_ARG_BYTE }, // DIS_OP_VAR_DECL + { DIS_ARG_WORD, DIS_ARG_WORD }, // DIS_OP_VAR_DECL_LONG + { DIS_ARG_BYTE, DIS_ARG_BYTE }, // DIS_OP_FN_DECL + { DIS_ARG_WORD, DIS_ARG_WORD }, // DIS_OP_FN_DECL_LONG + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_VAR_ASSIGN + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_VAR_ADDITION_ASSIGN + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_VAR_SUBTRACTION_ASSIGN + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_VAR_MULTIPLICATION_ASSIGN + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_VAR_DIVISION_ASSIGN + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_VAR_MODULO_ASSIGN + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_TYPE_CAST + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_TYPE_OF + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_IMPORT + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_EXPORT_removed + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_INDEX + { DIS_ARG_BYTE, DIS_ARG_NONE }, // DIS_OP_INDEX_ASSIGN + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_INDEX_ASSIGN_INTERMEDIATE + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_DOT + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_COMPARE_EQUAL + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_COMPARE_NOT_EQUAL + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_COMPARE_LESS + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_COMPARE_LESS_EQUAL + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_COMPARE_GREATER + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_COMPARE_GREATER_EQUAL + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_INVERT + { DIS_ARG_WORD, DIS_ARG_NONE }, // DIS_OP_AND + { DIS_ARG_WORD, DIS_ARG_NONE }, // DIS_OP_OR + { DIS_ARG_WORD, DIS_ARG_NONE }, // DIS_OP_JUMP + { DIS_ARG_WORD, DIS_ARG_NONE }, // DIS_OP_IF_FALSE_JUMP + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_FN_CALL + { DIS_ARG_WORD, DIS_ARG_NONE }, // DIS_OP_FN_RETURN + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_POP_STACK + { DIS_ARG_NONE, DIS_ARG_NONE }, // DIS_OP_TERNARY +}; + +typedef struct dis_program_s { + uint8_t *program; + uint32_t len; + uint32_t pc; +} dis_program_t; + +typedef struct dis_func_op_s { + uint32_t start; + uint32_t end; +} dis_func_op_t; + +static void dis_print_opcode(uint8_t op); + +static uint8_t readByte(const uint8_t *tb, uint32_t *count) { + uint8_t ret = *(uint8_t*) (tb + *count); + *count += 1; + return ret; +} + +static uint16_t readWord(const uint8_t *tb, uint32_t *count) { + uint16_t ret = 0; + memcpy(&ret, tb + *count, 2); + *count += 2; + return ret; +} + +static int32_t readInt(const uint8_t *tb, uint32_t *count) { + int ret = 0; + memcpy(&ret, tb + *count, 4); + *count += 4; + return ret; +} + +static float readFloat(const uint8_t *tb, uint32_t *count) { + float ret = 0; + memcpy(&ret, tb + *count, 4); + *count += 4; + return ret; +} + +static char* readString(const uint8_t *tb, uint32_t *count) { + const unsigned char *ret = tb + *count; + *count += strlen((char*) ret) + 1; //+1 for null character + return (char*) ret; +} + +static void consumeByte(uint8_t byte, uint8_t *tb, uint32_t *count) { + if (byte != tb[*count]) { + printf("[internal] Failed to consume the correct byte (expected %u, found %u)\n", byte, tb[*count]); + exit(1); + } + + *count += 1; +} + +/////////////////////////////////////////////////////////////////////////////// + +static void dis_disassembler_init(dis_program_t **prg) { + (*prg) = malloc(sizeof(struct dis_program_s)); + (*prg)->len = 0; + (*prg)->pc = 0; +} + +static void dis_disassembler_deinit(dis_program_t **prg) { + free((*prg)->program); + free((*prg)); +} + +static uint8_t dis_load_file(const char *filename, dis_program_t **prg) { + FILE *f; + size_t fsize, bytes; + uint32_t count = 0; + uint8_t buf = 0; + + f = fopen(filename, "r"); + if (f == NULL) { + printf("Not able to open the file.\n"); + return 1; + } + + fseek(f, 0, SEEK_END); + fsize = ftell(f); + fseek(f, 0, SEEK_SET); + (*prg)->program = malloc(fsize * sizeof(uint8_t)); + + while ((bytes = fread(&buf, sizeof(uint8_t), 1, f)) == 1) + (*prg)->program[count++] = buf; + + (*prg)->len = fsize; + printf("\nFile: %s\nSize: %zu\n", filename, fsize); + + fclose(f); + return 0; +} + +static void dis_read_header(dis_program_t **prg) { + const unsigned char major = readByte((*prg)->program, &((*prg)->pc)); + const unsigned char minor = readByte((*prg)->program, &((*prg)->pc)); + const unsigned char patch = readByte((*prg)->program, &((*prg)->pc)); + const char *build = readString((*prg)->program, &((*prg)->pc)); + printf("[Header Version: %d.%d.%d (%s)]\n", major, minor, patch, build); +} + +static void dis_print_opcode(uint8_t op) { + if (op == 255) { + printf("SECTION_END"); + return; + } + + if (op < DIS_OP_END_OPCODES) + printf("%s", (OP_STR[op] + 7)); + else + printf("(OP UNKNOWN [%c])", op); +} + +/////////////////////////////////////////////////////////////////////////////// + +#define S_OP(n) \ + switch (OP_ARGS[opcode][n]) { \ + case DIS_ARG_NONE: \ + break; \ + case DIS_ARG_BYTE: \ + uint = readByte((*prg)->program, &pc); \ + printf(" b(%d)", uint); \ + break; \ + case DIS_ARG_WORD: \ + uint = readWord((*prg)->program, &pc);\ + printf(" w(%d)", uint); \ + break; \ + case DIS_ARG_INTEGER: \ + intg = readInt((*prg)->program, &pc); \ + printf(" i(%d)", intg); \ + break; \ + case DIS_ARG_FLOAT: \ + flt = readFloat((*prg)->program, &pc); \ + printf(" f(%f)", flt); \ + break; \ + case DIS_ARG_STRING: \ + str = readString((*prg)->program, &pc); \ + printf(" s(%s)", str); \ + break; \ + default: \ + printf("ERROR, unknown argument type\n"); \ + exit(1); \ + } + +static void dis_disassemble_section(dis_program_t **prg, uint32_t pc, uint32_t len, uint8_t spaces, bool is_function) { + uint8_t opcode; + uint32_t uint; + int32_t intg; + float flt; + char *str; + + //first 4 bytes of the program section within a function are actually specifying the parameter and return lists + if (is_function) { + printf("\n"); + uint16_t args = readWord((*prg)->program, &pc); + uint16_t rets = readWord((*prg)->program, &pc); + SPC(spaces); + printf("| [args literal %d, rets literal %d]", args, rets); + } + + while (pc < len) { + opcode = (*prg)->program[pc]; + printf("\n"); + SPC(spaces); + printf("| [ %05d ](%03d) ", pc++, opcode); + dis_print_opcode(opcode); + + if (opcode > DIS_OP_END_OPCODES) + continue; + + S_OP(0); + S_OP(1); + } +} + +#define LIT_ADD(a, b, c) b[c] = a; ++c; +static void dis_read_interpreter_sections(dis_program_t **prg, uint32_t *pc, uint8_t spaces) { + uint32_t literal_count = 0; + uint8_t literal_type[65536]; + + const unsigned short literalCount = readWord((*prg)->program, pc); + + printf("\n"); + SPC(spaces); + printf("| ( Reading %d literals )\n", literalCount); + + for (int i = 0; i < literalCount; i++) { + const unsigned char literalType = readByte((*prg)->program, pc); + + switch (literalType) { + case DIS_LITERAL_NULL: + LIT_ADD(DIS_LITERAL_NULL, literal_type, literal_count); + SPC(spaces); + printf("| | [%d] ( null )\n", i); + break; + + case DIS_LITERAL_BOOLEAN: { + const bool b = readByte((*prg)->program, pc); + LIT_ADD(DIS_LITERAL_BOOLEAN, literal_type, literal_count); + SPC(spaces); + printf("| | [%d] ( boolean %s )\n", i, b ? "true" : "false"); + } + break; + + case DIS_LITERAL_INTEGER: { + const int d = readInt((*prg)->program, pc); + LIT_ADD(DIS_LITERAL_INTEGER, literal_type, literal_count); + SPC(spaces); + printf("| | [%d] ( integer %d )\n", i, d); + } + break; + + case DIS_LITERAL_FLOAT: { + const float f = readFloat((*prg)->program, pc); + LIT_ADD(DIS_LITERAL_FLOAT, literal_type, literal_count); + SPC(spaces); + printf("| | [%d] ( float %f )\n", i, f); + } + break; + + case DIS_LITERAL_STRING: { + const char *s = readString((*prg)->program, pc); + LIT_ADD(DIS_LITERAL_STRING, literal_type, literal_count); + SPC(spaces); + printf("| | [%d] ( string \"%s\" )\n", i, s); + } + break; + + case DIS_LITERAL_ARRAY_INTERMEDIATE: + case DIS_LITERAL_ARRAY: { + unsigned short length = readWord((*prg)->program, pc); + SPC(spaces); + printf("| | [%d] ( array ", i); + for (int i = 0; i < length; i++) { + int index = readWord((*prg)->program, pc); + printf("%d ", index); + LIT_ADD(DIS_LITERAL_NULL, literal_type, literal_count); + if (!(i % 15) && i != 0) { + printf("\n"); + SPC(spaces); + printf("| | "); + } + } + printf(")\n"); + LIT_ADD(DIS_LITERAL_ARRAY, literal_type, literal_count); + } + break; + + case DIS_LITERAL_DICTIONARY_INTERMEDIATE: + case DIS_LITERAL_DICTIONARY: { + unsigned short length = readWord((*prg)->program, pc); + SPC(spaces); + printf("| | [%d] ( dictionary ", i); + for (int i = 0; i < length / 2; i++) { + int key = readWord((*prg)->program, pc); + int val = readWord((*prg)->program, pc); + printf("(key: %d, val:%d) ", key, val); + if(!(i % 5) && i != 0){ + printf("\n"); + SPC(spaces); + printf("| | "); + } + } + printf(")\n"); + LIT_ADD(DIS_LITERAL_DICTIONARY, literal_type, literal_count); + } + break; + + case DIS_LITERAL_FUNCTION: { + unsigned short index = readWord((*prg)->program, pc); + LIT_ADD(DIS_LITERAL_FUNCTION_INTERMEDIATE, literal_type, literal_count); + SPC(spaces); + printf("| | [%d] ( function index: %d )\n", i, index); + } + break; + + case DIS_LITERAL_IDENTIFIER: { + const char *str = readString((*prg)->program, pc); + LIT_ADD(DIS_LITERAL_IDENTIFIER, literal_type, literal_count); + SPC(spaces); + printf("| | [%d] ( identifier %s )\n", i, str); + } + break; + + case DIS_LITERAL_TYPE: + case DIS_LITERAL_TYPE_INTERMEDIATE: { + uint8_t literalType = readByte((*prg)->program, pc); + uint8_t constant = readByte((*prg)->program, pc); + SPC(spaces); + printf("| | [%d] ( type %s: %d)\n", i, (LIT_STR[literalType] + 12), constant); + if (literalType == DIS_LITERAL_ARRAY) { + uint16_t vt = readWord((*prg)->program, pc); + SPC(spaces); + printf("| | | ( subtype: %d)\n", vt); + } + + if (literalType == DIS_LITERAL_DICTIONARY) { + uint8_t kt = readWord((*prg)->program, pc); + uint8_t vt = readWord((*prg)->program, pc); + SPC(spaces); + printf("| | | ( subtype: [%d, %d] )\n", kt, vt); + } + LIT_ADD(literalType, literal_type, literal_count); + } + break; + + case DIS_LITERAL_INDEX_BLANK: + LIT_ADD(DIS_LITERAL_INDEX_BLANK, literal_type, literal_count); + SPC(spaces); + printf("| | [%d] ( blank )\n", i); + break; + } + } + + consumeByte(DIS_OP_SECTION_END, (*prg)->program, pc); + + int functionCount = readWord((*prg)->program, pc); + int functionSize = readWord((*prg)->program, pc); + + if (functionCount) { + SPC(spaces); + printf("| | \n"); + SPC(spaces); + printf("| | ( fun count: %d, total size: %d )\n", functionCount, functionSize); + + uint32_t fcnt = 0; + for (uint32_t i = 0; i < literal_count; i++) { + if (literal_type[i] == DIS_LITERAL_FUNCTION_INTERMEDIATE) { + size_t size = (size_t) readWord((*prg)->program, pc); + + uint32_t fpc_start = *pc; + uint32_t fpc_end = *pc + size - 1; + + SPC(spaces); + printf("| | |\n"); + SPC(spaces); + printf("| | | ( fun %d [ start: %d, end: %d ] )", fcnt, fpc_start, fpc_end); + if ((*prg)->program[*pc + size - 1] != DIS_OP_FN_END) { + printf("\nERROR: Failed to find function end\n"); + exit(1); + } + + dis_read_interpreter_sections(prg, &fpc_start, spaces + 4); + SPC(spaces); + printf("| | |\n"); + SPC(spaces + 4); + printf("| ------ CODE ------"); + dis_disassemble_section(prg, fpc_start, fpc_end, spaces + 4, true); + printf("\n"); + SPC(spaces + 4); + printf("| ---- END CODE ----\n"); + + fcnt++; + *pc += size; + } + } + } + + consumeByte(DIS_OP_SECTION_END, (*prg)->program, pc); +} + +/////////////////////////////////////////////////////////////////////////////// + +void disassemble(const char *filename) { + dis_program_t *prg; + + dis_disassembler_init(&prg); + if (dis_load_file(filename, &prg)) + exit(1); + + dis_read_header(&prg); + + consumeByte(DIS_OP_SECTION_END, prg->program, &(prg->pc)); + + printf("\n| ---- LITERALS ----"); + dis_read_interpreter_sections(&prg, &(prg->pc), 0); + printf("| -- END LITERALS --\n|"); + + printf("\n| ---- PROGRAM ----"); + dis_disassemble_section(&prg, prg->pc, prg->len, 0, false); + printf("\n| -- END PROGRAM --"); + + printf("\n\n"); + dis_disassembler_deinit(&prg); +} diff --git a/tools/disassembler/disassembler.h b/tools/disassembler/disassembler.h new file mode 100644 index 0000000..f1811dc --- /dev/null +++ b/tools/disassembler/disassembler.h @@ -0,0 +1,119 @@ +#ifndef DISASSEMBLER_H_ +#define DISASSEMBLER_H_ + +typedef enum DIS_OPCODES { + DIS_OP_EOF, // + + // do nothing + DIS_OP_PASS, // + + // basic statements + DIS_OP_ASSERT, // + DIS_OP_PRINT, // + + // data + DIS_OP_LITERAL, // + DIS_OP_LITERAL_LONG, // for more than 256 literals in a chunk + DIS_OP_LITERAL_RAW, // forcibly get the raw value of the literal + + // arithmetic operators + DIS_OP_NEGATE, // + DIS_OP_ADDITION, // + DIS_OP_SUBTRACTION, // + DIS_OP_MULTIPLICATION, // + DIS_OP_DIVISION, // + DIS_OP_MODULO, // + DIS_OP_GROUPING_BEGIN, // + DIS_OP_GROUPING_END, // + + // variable stuff + DIS_OP_SCOPE_BEGIN, // + DIS_OP_SCOPE_END, // + + DIS_OP_TYPE_DECL_removed, // deprecated + DIS_OP_TYPE_DECL_LONG_removed, // deprecated + + DIS_OP_VAR_DECL, // declare a variable to be used (as a literal) + DIS_OP_VAR_DECL_LONG, // declare a variable to be used (as a long literal) + + DIS_OP_FN_DECL, // declare a function to be used (as a literal) + DIS_OP_FN_DECL_LONG, // declare a function to be used (as a long literal) + + DIS_OP_VAR_ASSIGN, // assign to a literal + DIS_OP_VAR_ADDITION_ASSIGN, // + DIS_OP_VAR_SUBTRACTION_ASSIGN, // + DIS_OP_VAR_MULTIPLICATION_ASSIGN, // + DIS_OP_VAR_DIVISION_ASSIGN, // + DIS_OP_VAR_MODULO_ASSIGN, // + + DIS_OP_TYPE_CAST, // temporarily change a type of an atomic value + DIS_OP_TYPE_OF, // get the type of a variable + + DIS_OP_IMPORT, // + DIS_OP_EXPORT_removed, // deprecated + + // for indexing + DIS_OP_INDEX, // + DIS_OP_INDEX_ASSIGN, // + DIS_OP_INDEX_ASSIGN_INTERMEDIATE, // + DIS_OP_DOT, // + + // comparison of values + DIS_OP_COMPARE_EQUAL, // + DIS_OP_COMPARE_NOT_EQUAL, // + DIS_OP_COMPARE_LESS, // + DIS_OP_COMPARE_LESS_EQUAL, // + DIS_OP_COMPARE_GREATER, // + DIS_OP_COMPARE_GREATER_EQUAL, // + DIS_OP_INVERT, // for booleans + + // logical operators + DIS_OP_AND, // + DIS_OP_OR, // + + // jumps, and conditional jumps (absolute) + DIS_OP_JUMP, // + DIS_OP_IF_FALSE_JUMP, // + DIS_OP_FN_CALL, // + DIS_OP_FN_RETURN, // + + // pop the stack at the end of a complex statement + DIS_OP_POP_STACK, // + + //ternary shorthand + DIS_OP_TERNARY, // + + //meta + DIS_OP_FN_END, // different from SECTION_END + DIS_OP_END_OPCODES, // mark for end opcodes list. Not valid opcode + DIS_OP_SECTION_END = 255, +} dis_opcode_t; + +typedef enum DIS_LITERAL_TYPE { + DIS_LITERAL_NULL, // + DIS_LITERAL_BOOLEAN, // + DIS_LITERAL_INTEGER, // + DIS_LITERAL_FLOAT, // + DIS_LITERAL_STRING, // + DIS_LITERAL_ARRAY, // + DIS_LITERAL_DICTIONARY, // + DIS_LITERAL_FUNCTION, // + DIS_LITERAL_IDENTIFIER, // + DIS_LITERAL_TYPE, // + DIS_LITERAL_OPAQUE, // + DIS_LITERAL_ANY, // + + // these are meta-level types - not for general use + DIS_LITERAL_TYPE_INTERMEDIATE, // used to process types in the compiler only + DIS_LITERAL_ARRAY_INTERMEDIATE, // used to process arrays in the compiler only + DIS_LITERAL_DICTIONARY_INTERMEDIATE, // used to process dictionaries in the compiler only + DIS_LITERAL_FUNCTION_INTERMEDIATE, // used to process functions in the compiler only + DIS_LITERAL_FUNCTION_ARG_REST, // used to process function rest parameters only + DIS_LITERAL_FUNCTION_NATIVE, // for handling native functions only + DIS_LITERAL_FUNCTION_HOOK, // for handling hook functions within literals only + DIS_LITERAL_INDEX_BLANK, // for blank indexing i.e. arr[:] +} dis_literal_type_t; + +extern void disassemble(const char *filename); + +#endif /* DISASSEMBLER_H_ */ diff --git a/tools/disassembler/main.c b/tools/disassembler/main.c new file mode 100644 index 0000000..4028039 --- /dev/null +++ b/tools/disassembler/main.c @@ -0,0 +1,8 @@ +#include + +#include "disassembler.h" + +int main(int argc, const char* argv[]) { + disassemble(argv[1]); + return EXIT_SUCCESS; +} diff --git a/tools/disassembler/makefile b/tools/disassembler/makefile new file mode 100644 index 0000000..06e6b95 --- /dev/null +++ b/tools/disassembler/makefile @@ -0,0 +1,27 @@ +CC=gcc + +IDIR+=. +CFLAGS+=$(addprefix -I,$(IDIR)) -g -Wall -W -Wno-unused-parameter -Wno-unused-function -Wno-unused-variable +LIBS+= + +ODIR = obj +SRC = $(wildcard *.c) +OBJ = $(addprefix $(ODIR)/,$(SRC:.c=.o)) +OUTNAME= +OUT=disassembler + +all: $(OBJ) + $(CC) $(CFLAGS) -o $(OUT) $(OBJ) $(LIBS) + +$(OBJ): | $(ODIR) + +$(ODIR): + mkdir $(ODIR) + +$(ODIR)/%.o: %.c + $(CC) -c -o $@ $< $(CFLAGS) + +.PHONY: clean + +clean: + $(RM) -r $(ODIR) diff --git a/tools/changing-of-the-guard.cpp b/tools/misc/changing-of-the-guard.cpp similarity index 100% rename from tools/changing-of-the-guard.cpp rename to tools/misc/changing-of-the-guard.cpp diff --git a/tools/mecha.cpp b/tools/misc/mecha.cpp similarity index 100% rename from tools/mecha.cpp rename to tools/misc/mecha.cpp diff --git a/tools/uptown.cpp b/tools/misc/uptown.cpp similarity index 100% rename from tools/uptown.cpp rename to tools/misc/uptown.cpp