263 lines
6.3 KiB
C
263 lines
6.3 KiB
C
#include <tvm/tvm_file.h>
|
|
#include <tvm/tvm_program.h>
|
|
#include <tvm/tvm_lexer.h>
|
|
|
|
const char* tvm_opcode_map[] = {"nop", "int", "mov", "push", "pop", "pushf", "popf", "inc", "dec", "add", "sub", "mul", "div", "mod", "rem",
|
|
"not", "xor", "or", "and", "shl", "shr", "cmp", "jmp", "call", "ret", "je", "jne", "jg", "jge", "jl", "jle", "prn", 0};
|
|
|
|
const char* tvm_register_map[] = {"eax", "ebx", "ecx", "edx", "esi", "edi", "esp", "ebp", "eip", "r08", "r09", "r10", "r11", "r12", "r13", "r14", "r15", 0};
|
|
|
|
static int parse_labels(tvm_program_t* p, const char*** tokens);
|
|
static int parse_instructions(tvm_program_t* p, const char*** tokens, tvm_memory_t* pMemory);
|
|
|
|
static int* token_to_register(const char* token, tvm_memory_t* pMemory);
|
|
static int instr_to_opcode(const char* instr);
|
|
|
|
tvm_program_t* create_program()
|
|
{
|
|
tvm_program_t* p = (tvm_program_t*)calloc(1, sizeof(tvm_program_t));
|
|
p->label_htab = create_htab();
|
|
|
|
return p;
|
|
}
|
|
|
|
void destroy_program(tvm_program_t* p)
|
|
{
|
|
int i = 0;
|
|
destroy_htab(p->label_htab);
|
|
|
|
if(p->values)
|
|
{
|
|
for(i = 0; i < p->num_values; i++) free(p->values[i]);
|
|
free(p->values);
|
|
}
|
|
|
|
if(p->args)
|
|
{
|
|
for(i = 0; p->args[i]; i++) free(p->args[i]);
|
|
free(p->args);
|
|
}
|
|
|
|
if(p->instr) free(p->instr);
|
|
free(p);
|
|
}
|
|
|
|
int interpret_program(tvm_program_t* p, char* filename, tvm_memory_t* pMemory)
|
|
{
|
|
int i;
|
|
FILE* pFile = NULL;
|
|
|
|
int source_length = 0;
|
|
char* source = NULL;
|
|
|
|
tvm_lexer_t* lexer = NULL;
|
|
|
|
/* Attempt to open the file. If the file cannot be opened, try once more. */
|
|
if(filename)
|
|
for(i = 0; i < 2; i++)
|
|
if(!pFile) pFile = tvm_fopen(filename, ".vm", "r");
|
|
|
|
if(!pFile)
|
|
{
|
|
printf("File was not found, or does not exist. Unable to interpret.\n");
|
|
return 1;
|
|
}
|
|
|
|
source_length = tvm_flength(pFile);
|
|
source = malloc(source_length);
|
|
|
|
tvm_fcopy(source, source_length, pFile);
|
|
|
|
lexer = lexer_create();
|
|
lex(lexer, source);
|
|
|
|
free(source);
|
|
fclose(pFile);
|
|
|
|
if(parse_labels(p, (const char***)lexer->tokens) != 0)
|
|
return 1;
|
|
|
|
if(parse_instructions(p, (const char***)lexer->tokens, pMemory) != 0)
|
|
return 1;
|
|
|
|
lexer_destroy(lexer);
|
|
return 0;
|
|
}
|
|
|
|
int parse_labels(tvm_program_t* p, const char*** tokens)
|
|
{
|
|
int i, num_instructions = 0;
|
|
for(i = 0; tokens[i]; i++)
|
|
{
|
|
int token_idx, valid_instruction = 0;
|
|
for(token_idx = 0; token_idx < MAX_TOKENS; token_idx++)
|
|
{
|
|
char* label_delimiter;
|
|
|
|
/* If the token is empty, or non-existent, skip it */
|
|
if(!tokens[i][token_idx]) continue;
|
|
|
|
/* Figure out if the source line we're on contains a valid instruction */
|
|
if(instr_to_opcode(tokens[i][token_idx]) != -1) valid_instruction = 1;
|
|
|
|
/* Figure out if the token we're dealing with has a label delimiter */
|
|
label_delimiter = strchr(tokens[i][token_idx], ':');
|
|
|
|
if(label_delimiter != NULL)
|
|
{
|
|
*label_delimiter = 0;
|
|
|
|
/* If the label is "start," set the program to begin there */
|
|
if(strcmp(tokens[i][token_idx], "start") == 0) p->start = num_instructions;
|
|
|
|
/* Check if the label already exists */
|
|
if(htab_find(p->label_htab, tokens[i][token_idx]) != -1)
|
|
{
|
|
printf("Label '%s' defined twice\n", tokens[i][token_idx]);
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
/* Add that fucker to the hash table with the corresponding instruction index */
|
|
htab_add(p->label_htab, tokens[i][token_idx], num_instructions);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if(valid_instruction) num_instructions++;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int parse_instructions(tvm_program_t* p, const char*** tokens, tvm_memory_t* pMemory)
|
|
{
|
|
int line_idx;
|
|
for(line_idx = 0; tokens[line_idx]; line_idx++)
|
|
{
|
|
p->instr = (int*)realloc(p->instr, sizeof(int) * (line_idx + 2));
|
|
p->instr[line_idx] = 0;
|
|
|
|
p->args = (int***)realloc(p->args, sizeof(int**) * (line_idx + 2));
|
|
p->args[line_idx] = (int**)calloc(MAX_ARGS, sizeof(int*));
|
|
|
|
int token_idx;
|
|
for(token_idx = 0; token_idx < MAX_TOKENS; token_idx++)
|
|
{
|
|
int opcode = 0;
|
|
|
|
/* Skip empty tokens */
|
|
if(!tokens[line_idx][token_idx]) continue;
|
|
|
|
opcode = instr_to_opcode(tokens[line_idx][token_idx]);
|
|
|
|
/* If it *is* an opcode, parse the arguments */
|
|
if(opcode != -1)
|
|
{
|
|
int i, instr_idx = 0, num_instr = p->num_instructions;
|
|
p->instr[p->num_instructions++] = opcode;
|
|
|
|
for(i = ++token_idx; i < (token_idx + 2); ++i)
|
|
{
|
|
char* newline;
|
|
if(!tokens[line_idx][i] || strlen(tokens[line_idx][i]) <= 0) continue;
|
|
|
|
newline = strchr(tokens[line_idx][i], '\n');
|
|
if(newline) *newline = 0;
|
|
|
|
/* Check to see if the token specifies a register */
|
|
int* pRegister = token_to_register(tokens[line_idx][i], pMemory);
|
|
if(pRegister)
|
|
{
|
|
p->args[num_instr][i - token_idx] = pRegister;
|
|
continue;
|
|
}
|
|
|
|
/* Check to see whether the token specifies an address */
|
|
if(tokens[line_idx][i][0] == '[')
|
|
{
|
|
char* end_symbol = strchr(tokens[line_idx][i], ']');
|
|
if(end_symbol)
|
|
{
|
|
*end_symbol = 0;
|
|
p->args[num_instr][i - token_idx] = &((int*)pMemory->mem_space)[tvm_parse_value(tokens[line_idx][i] + 1)];
|
|
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/* Check if the argument is a label */
|
|
instr_idx = htab_find(p->label_htab, tokens[line_idx][i]);
|
|
|
|
if(instr_idx >= 0)
|
|
{
|
|
p->args[num_instr][i - token_idx] = tvm_add_value(p, instr_idx);
|
|
continue;
|
|
}
|
|
|
|
/* Fuck it, parse it as a value */
|
|
p->args[num_instr][i - token_idx] = tvm_add_value(p, tvm_parse_value(tokens[line_idx][i]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
p->args[line_idx] = NULL;
|
|
p->instr[line_idx] = -0x1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int* token_to_register(const char* token, tvm_memory_t* pMemory)
|
|
{
|
|
int i = 0;
|
|
while(tvm_register_map[i])
|
|
{
|
|
if(strcmp(token, tvm_register_map[i]) == 0)
|
|
return &pMemory->registers[i].i32;
|
|
i++;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int instr_to_opcode(const char* instr)
|
|
{
|
|
int i;
|
|
for(i = 0; tvm_opcode_map[i]; i++)
|
|
if(strcmp(instr, tvm_opcode_map[i]) == 0)
|
|
return i;
|
|
|
|
return -1;
|
|
}
|
|
|
|
int* tvm_add_value(tvm_program_t* p, const int val)
|
|
{
|
|
p->values = realloc(p->values, sizeof(int*) * (p->num_values + 1));
|
|
p->values[p->num_values] = (int*)calloc(1, sizeof(int));
|
|
|
|
*p->values[p->num_values] = val;
|
|
|
|
return p->values[p->num_values++];
|
|
}
|
|
|
|
int tvm_parse_value(const char* str)
|
|
{
|
|
char* delimiter = strchr(str, '|'), base = 0;
|
|
|
|
if(delimiter)
|
|
{
|
|
char* identifier = delimiter + 1;
|
|
|
|
switch(*identifier)
|
|
{
|
|
case 'h': base = 16; break;
|
|
case 'b': base = 2; break;
|
|
default: base = 0; break;
|
|
}
|
|
}
|
|
|
|
return strtoul(str, NULL, base);
|
|
}
|