void free_ectx (ECTX vm)
{
/* FIXME: deal with stray mobiles */
tvm_ectx_release (vm);
free_bytecode (vm->priv.bytecode);
free (vm->priv.memory);
free (vm);
}
static void handle_free (ECTX ectx, void *data)
{
c_state_t *c = (c_state_t *) data;
if (c->type == C_T_BYTECODE) {
free_bytecode (c->data.bc);
} else if (c->type == C_T_VM_CTL) {
free_ectx (c->data.vm);
}
if (c->buffer != NULL)
free (c->buffer);
free (c);
}
bytecode_t *load_bytecode (const char *file)
{
bytecode_t *bc = (bytecode_t *) malloc (sizeof (bytecode_t));
bc->refcount = 1;
bc->source = strdup (file);
bc->data = NULL;
bc->ffi_table = NULL;
if (read_tbc_file (file, &(bc->data), &(bc->length)))
goto errout;
if ((bc->tbc = decode_tbc (bc->data, bc->length)) == NULL)
goto errout;
if (!build_ffi_table (bc))
goto errout;
return bc;
errout:
free_bytecode (bc);
return NULL;
}
int main(int argc, char *argv[])
{
printf("vm\n");
if(argc < 2) {
printf("usage: %s <vm-file>\n", argv[0]);
} else {
FILE *fp;
fp = fopen(argv[1], "rb");
if(fp == NULL) {
printf("can't open file %s\n", argv[1]);
} else {
printf("opened file\n");
struct fn_node fn_root;
struct vm_env env;
fn_root = load_bytecode(fp, &env);
fclose(fp);
printf("dump:\n\n");
dump_bytecode(fn_root);
eval_bc_fn(fn_root, &env, 0);
free_bytecode(fn_root);
}
}
return 0;
}
int main (int argc, char *argv[])
{
char *fn;
int f_ret, u_ret;
prog_name = argv[0];
tvm_argc = argc;
tvm_argv = argv;
if (argc < 2) {
usage (stderr);
return 1;
} else {
fn = argv[1];
}
init_vm ();
if (install_user_ctx (fn) < 0) {
error_out_no_errno ("failed to load user bytecode");
return 1;
}
if (install_firmware_ctx () < 0) {
error_out_no_errno ("failed to install firmware");
return 1;
}
kyb_channel = NOT_PROCESS_P;
scr_channel = NOT_PROCESS_P;
err_channel = NOT_PROCESS_P;
for (;;) {
f_ret = run_firmware ();
u_ret = run_user ();
if ((f_ret == ECTX_EMPTY || f_ret == ECTX_SLEEP) &&
(u_ret == ECTX_EMPTY || u_ret == ECTX_SLEEP)) {
if (firmware->fptr == NOT_PROCESS_P && user->fptr == NOT_PROCESS_P) {
tvm_sleep ();
}
} else if (f_ret == ECTX_ERROR || u_ret == ECTX_ERROR) {
break;
} else if (u_ret == ECTX_SHUTDOWN) {
/* Run firmware to clear buffers */
run_firmware ();
break;
}
}
if (u_ret == ECTX_ERROR) {
tbc_t *tbc = user->priv.bytecode->tbc;
if (tbc->debug) {
tbc_dbg_t *dbg = tbc->debug;
tbc_lnd_t *ln;
tenc_str_t *file;
int offset = user->iptr - tbc->bytecode;
int i = 0;
while (i < dbg->n_lnd) {
if (dbg->lnd[i].offset > offset) {
break;
}
i++;
}
ln = &(dbg->lnd[i - 1]);
file = dbg->files;
for (i = 0; i < ln->file; ++i) {
file = file->next;
}
fprintf (stderr,
"Error at %s:%d\n",
file->str, ln->line
);
}
/* FIXME: more debugging */
fprintf (stderr,
"Program failed, state = %c, eflags = %08x\n",
user->state, user->eflags
);
return 1;
}
free_ectx (firmware);
free_ectx (user);
free_bytecode (fw_bc);
free_bytecode (us_bc);
#ifdef TVM_PROFILING
output_profiling ();
#endif
return 0;
}
