diff --git a/compiler/codegen.c b/compiler/codegen.c index 5c69937..15032b1 100644 --- a/compiler/codegen.c +++ b/compiler/codegen.c @@ -76,21 +76,6 @@ fix_labels(OpcodeBuf *ob) ob->code[i+1] = (SVM_Byte)(address >> 8); ob->code[i+2] = (SVM_Byte)(address &0xff); } - info = &svm_opcode_info[ob->code[i]]; - for (j = 0; info->parameter[j] != '\0'; j++) { - switch (info->parameter[j]) { - case 'b': - i++; - break; - case 's': - case 'p': - i += 2; - break; - default: - printf("param..%s, j..%d", info->parameter, j); - exit(1); - } - } } } @@ -123,7 +108,7 @@ fix_opcode_buf(OpcodeBuf *ob) { SVM_Byte *ret; - fix_labels(ob); + // fix_labels(ob); ret = realloc(ob->code, ob->size); free(ob->label_table); @@ -162,13 +147,9 @@ generate_builtin_code(OpcodeBuf *ob, SVM_Opcode *ops, int op_cnt) static void generate_code(OpcodeBuf *ob, SVM_Opcode code, ...) { - va_list ap; int i; char *param; int param_count; - int start_pc; - - va_start(ap, code); param = svm_opcode_info[(int)code].parameter; param_count = strlen(param); @@ -177,33 +158,8 @@ generate_code(OpcodeBuf *ob, SVM_Opcode code, ...) ob->alloc_size += OPCODE_ALLOC_SIZE; } - start_pc = ob->size; ob->code[ob->size] = code; ob->size++; - for (i = 0; param[i] != '\0'; i++) { - unsigned int value = va_arg(ap, int); - switch (param[i]) { - case 'b': /* byte */ - ob->code[ob->size] = (SVM_Byte)value; - ob->size++; - break; - case 's': /* short(2byte int) */ - ob->code[ob->size] = (SVM_Byte)(value >> 8); - ob->code[ob->size+1] = (SVM_Byte)(value & 0xff); - ob->size += 2; - break; - case 'p': /* constant pool index */ - ob->code[ob->size] = (SVM_Byte)(value >> 8); - ob->code[ob->size+1] = (SVM_Byte)(value & 0xff); - ob->size += 2; - break; - default: - printf("param..%s, i..%d", param, i); - exit(1); - } - } - - va_end(ap); } static void @@ -392,6 +348,7 @@ generate_initializer(SVM_Executable *exe, Block *current_block, Declaration *decl_stmt, OpcodeBuf *ob) { + generate_expression(exe, current_block, decl_stmt->initializer, ob); generate_pop_to_identifier(decl_stmt, ob); } @@ -419,6 +376,25 @@ generate_int_expression(SVM_Executable *cf, int value, } } +static void +generate_string_expression(SVM_Executable *cf, Expression *expr, + OpcodeBuf *ob) +{ + char *str = expr->u.str_value; + int len = strlen(str); + if (ob->alloc_size < ob->size + 1 + len) { + ob->code = realloc(ob->code, ob->alloc_size + OPCODE_ALLOC_SIZE); + ob->alloc_size += OPCODE_ALLOC_SIZE; + } + + generate_code(ob, OP_DATA_1 + len - 1); + + for (int i = 0; i < len; i++) { + ob->code[ob->size] = str[i]; + ob->size++; + } +} + // NOTE: no bvm ops for double type static void generate_double_expression(SVM_Executable *cf, Expression *expr, @@ -458,12 +434,20 @@ generate_identifier_expression(SVM_Executable *exe, Block *block, static void generate_push_argument(SVM_Executable *exe, Block *block, - ArgumentList *arg_list, OpcodeBuf *ob) + ArgumentList *arg_list, const char *name, OpcodeBuf *ob) { ArgumentList *arg_pos; for (arg_pos = arg_list; arg_pos; arg_pos = arg_pos->next) { + if (!strcmp(name, "lock") && arg_pos->expr->type->basic_type == AMOUNT_TYPE) { + generate_code(ob, OP_0); + } + generate_expression(exe, block, arg_pos->expr, ob); + + if (!strcmp(name, "lock") && arg_pos->expr->type->basic_type == ASSET_TYPE) { + generate_code(ob, OP_1); + } } } @@ -472,11 +456,11 @@ generate_function_call_expression(SVM_Executable *exe, Block *block, Expression *expr, OpcodeBuf *ob) { FuncCallExpression *fce = expr->u.func_call_expression; - generate_push_argument(exe, block, fce->argument_list, ob); - generate_expression(exe, block, fce->argument_list->expr, ob); - BuiltinFun *builtin_fun = expr->u.func_call_expression ->function->u.identifier->u.builtin_func; + generate_push_argument(exe, block, fce->argument_list, builtin_fun->name, ob); + generate_expression(exe, block, fce->argument_list->expr, ob); + generate_builtin_code(ob, builtin_fun->op_codes, builtin_fun->ops_count); } @@ -529,6 +513,9 @@ generate_expression(SVM_Executable *exe, Block *current_block, case DOUBLE_EXPRESSION: generate_double_expression(exe, expr, ob); break; + case STRING_EXPRESSION: + generate_string_expression(exe, expr, ob); + break; case IDENTIFIER_EXPRESSION: generate_identifier_expression(exe, current_block, expr, ob); @@ -623,8 +610,10 @@ generate_statement_list(SVM_Executable *exe, Block *current_block, { case ASSIGN_STATEMENT: generate_assign_statement(exe, current_block, pos->statement->u.assign_s, ob); + break; case BLOCK_STATEMENT: generate_block_statement(exe, current_block, pos->statement->u.block_s, ob); + break; case IF_STATEMENT: generate_if_statement(exe, current_block, pos->statement->u.if_s, ob); break; diff --git a/compiler/disassemble.c b/compiler/disassemble.c index 75c7a4f..1ea6146 100644 --- a/compiler/disassemble.c +++ b/compiler/disassemble.c @@ -95,23 +95,6 @@ svm_dump_instruction(FILE *fp, SVM_Byte *code, int index) info = &svm_opcode_info[code[index]]; fprintf(fp, "%4d %s ", index, info->mnemonic); - for (i = 0; info->parameter[i] != '\0'; i++) { - switch (info->parameter[i]) { - case 'b': - value = code[index+1]; - fprintf(fp, " %d", value); - index++; - break; - case 's': - case 'p': - value = (code[index+1] << 8) + code[index+2]; - fprintf(fp, " %d", value); - index += 2; - break; - default: - DBG_assert(0, ("param..%s, i..%d", info->parameter, i)); - } - } index++; return index; @@ -123,7 +106,19 @@ dump_opcode(int code_size, SVM_Byte *code) int index; for (index = 0; index < code_size; ) { - index = svm_dump_instruction(stdout, code, index); + if (code[index] >= OP_DATA_1 && code[index] <= OP_DATA_75) { + index = svm_dump_instruction(stdout, code, index); + printf("\n"); + + fprintf(stdout, "%4d ", index); + int len = code[index-1] - OP_DATA_1 + 1; + for (int i = 0; i < len; i++) { + fprintf(stdout, "%c", code[index + i]); + } + index += len; + } else { + index = svm_dump_instruction(stdout, code, index); + } printf("\n"); } }