FILE * eio_create(char *fname) { FILE *fd; struct exo_term_t *exo; int target_big_endian; target_big_endian = (endian_host_byte_order() == endian_big); fd = gzopen(fname, "w"); if (!fd) fatal("unable to create EIO file `%s'", fname); /* emit EIO file header */ fprintf(fd, "%s\n", EIO_FILE_HEADER); fprintf(fd, "/* file_format: %d, file_version: %d, big_endian: %d */\n", MD_EIO_FILE_FORMAT, EIO_FILE_VERSION, ld_target_big_endian); exo = exo_new(ec_list, exo_new(ec_integer, (exo_integer_t)MD_EIO_FILE_FORMAT), exo_new(ec_integer, (exo_integer_t)EIO_FILE_VERSION), exo_new(ec_integer, (exo_integer_t)target_big_endian), NULL); exo_print(exo, fd); exo_delete(exo); fprintf(fd, "\n\n"); return fd; }
void main(int argc, char **argv) { /* build the command line options database */ odb = opt_new(/* no orphan fn */NULL); opt_reg_flag(odb, "-h", "print help message", &help_me, /* default */FALSE, /* !print */FALSE, NULL); opt_reg_flag(odb, "-defs", "make internal defs", &make_defs, /* default */FALSE, /* print */TRUE, NULL); opt_reg_string(odb, "-load", "load an EXO file", &load_file, /* default */NULL, /* print */TRUE, /* format */NULL); opt_reg_string(odb, "-save", "save an EXO file", &save_file, /* default */NULL, /* print */TRUE, /* format */NULL); opt_reg_flag(odb, "-print", "print the EXO DB to stdout", &print_db, /* default */FALSE, /* print */TRUE, /* format */NULL); /* process the command line options */ opt_process_options(odb, argc, argv); if (help_me) { /* print help message and exit */ usage(stderr, argc, argv); exit(1); } /* print options used */ opt_print_options(odb, stderr, /* short */TRUE, /* notes */TRUE); if (load_file) { ZFILE *exo_stream; struct exo_term_t *exo; exo_stream = myzfopen(load_file, "r"); if (!exo_stream) fatal("could not open EXO file `%s'", load_file); while ((exo = exo_read(exo_stream->fd)) != NULL) exo_db = exo_chain(exo_db, exo); myzfclose(exo_stream); } if (make_defs) { struct exo_term_t *list, *array, *a, *b, *c, *d, *e, *f, *g, *h, *i; char *data = "This is a test to see if blobs really work..."; char *data1 = "This is a test to see if blobs really work..." "This is a test to see if blobs really work..." "This is a test to see if blobs really work..." "This is a test to see if blobs really work..." "This is a test to see if blobs really work..." "This is a test to see if blobs really work..." "This is a test to see if blobs really work..." "This is a test to see if blobs really work..."; unsigned char data2[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; exo_db = exo_chain(exo_db, exo_new(ec_string, "** basic types tests **")); exo_db = exo_chain(exo_db, a = exo_new(ec_integer, (exo_integer_t)42)); exo_db = exo_chain(b = exo_new(ec_float, (exo_float_t)42.0), exo_db); exo_db = exo_chain(exo_db, c = exo_new(ec_char, (int)'x')); exo_db = exo_chain(exo_db, exo_new(ec_char, (int)'\n')); exo_db = exo_chain(exo_db, exo_new(ec_char, (int)'\b')); exo_db = exo_chain(exo_db, exo_new(ec_char, (int)'\x02')); exo_db = exo_chain(exo_db, exo_new(ec_char, (int)'\xab')); exo_db = exo_chain(exo_db, exo_new(ec_string, "this is a test...")); exo_db = exo_chain(exo_db, d = exo_new(ec_string, "this is\na test...\n")); exo_db = exo_chain(exo_db, exo_new(ec_string, "a test... <<\\\b>>\n")); exo_db = exo_chain(exo_db, exo_new(ec_string, "** deep copy tests **")); exo_db = exo_chain(exo_db, exo_deepcopy(d)); exo_db = exo_chain(exo_db, exo_deepcopy(c)); exo_db = exo_chain(exo_db, exo_deepcopy(b)); exo_db = exo_chain(exo_db, exo_deepcopy(a)); exo_db = exo_chain(exo_db, exo_new(ec_string, "** list tests **")); exo_db = exo_chain(exo_db, exo_new(ec_list, exo_deepcopy(d), exo_deepcopy(c), exo_deepcopy(b), exo_deepcopy(a), NULL)); exo_db = exo_chain(exo_db, exo_new(ec_list, NULL)); exo_db = exo_chain(exo_db, exo_new(ec_list, exo_new(ec_list, NULL), exo_new(ec_list, NULL), exo_new(ec_list, exo_deepcopy(a), NULL), NULL)); list = exo_deepcopy(a); list = exo_chain(list, exo_deepcopy(b)); list = exo_chain(list, exo_deepcopy(a)); list = exo_chain(list, exo_deepcopy(b)); list = exo_chain(exo_deepcopy(c), list); exo_db = exo_chain(exo_db, e = exo_new(ec_list, list, NULL)); exo_db = exo_chain(exo_db, exo_new(ec_list, exo_deepcopy(e), exo_new(ec_list, NULL), exo_deepcopy(e), exo_deepcopy(a), NULL)); exo_db = exo_chain(exo_db, exo_new(ec_string, "** array tests **")); exo_db = exo_chain(exo_db, exo_new(ec_array, 16, NULL)); f = array = exo_new(ec_array, 16, NULL); EXO_ARR(array, 2) = exo_deepcopy(e); EXO_ARR(array, 3) = exo_deepcopy(a); EXO_ARR(array, 4) = exo_deepcopy(c); EXO_ARR(array, 6) = exo_deepcopy(EXO_ARR(array, 2)); EXO_ARR(array, 7) = exo_deepcopy(EXO_ARR(array, 1)); exo_db = exo_chain(exo_db, array); exo_db = exo_chain(exo_db, exo_new(ec_array, 4, exo_deepcopy(a), exo_deepcopy(e), exo_deepcopy(c), exo_deepcopy(f), NULL)); exo_db = exo_chain(exo_db, exo_new(ec_string, "** token tests **")); #define SYM1 1 #define SYM2 2 exo_intern_as("sym1", SYM1); exo_intern_as("sym2", SYM2); g = exo_new(ec_token, "sym1"), exo_db = exo_chain(exo_db, exo_new(ec_list, g, exo_new(ec_integer, (exo_integer_t) g->as_token.ent->token), NULL)); h = exo_new(ec_token, "sym2"), exo_db = exo_chain(exo_db, exo_new(ec_list, h, exo_new(ec_integer, (exo_integer_t) h->as_token.ent->token), NULL)); i = exo_new(ec_token, "sym3"), exo_db = exo_chain(exo_db, exo_new(ec_list, i, exo_new(ec_integer, (exo_integer_t) i->as_token.ent->token), NULL)); /* das blobs */ exo_db = exo_chain(exo_db, exo_new(ec_blob, strlen(data), data)); exo_db = exo_chain(exo_db, exo_new(ec_blob, strlen(data1), data1)); exo_db = exo_chain(exo_db, exo_new(ec_blob, sizeof(data2), data2)); } if (print_db) { struct exo_term_t *exo; /* emit header comment */ fprintf(stdout, "\n/* EXO DB */\n\n"); fprintf(stdout, "/* EXO save file, file format version %d.%d */\n\n", EXO_FMT_MAJOR, EXO_FMT_MINOR); /* emit all defs */ for (exo=exo_db; exo != NULL; exo=exo->next) { exo_print(exo, stdout); fprintf(stdout, "\n\n"); } } if (save_file) { ZFILE *exo_stream; struct exo_term_t *exo; exo_stream = myzfopen(save_file, "w"); if (!exo_stream) fatal("could not open EXO file `%s'", save_file); /* emit header comment */ fprintf(exo_stream->fd, "/* EXO save file, file format version %d.%d */\n\n", EXO_FMT_MAJOR, EXO_FMT_MINOR); /* emit all defs */ for (exo=exo_db; exo != NULL; exo=exo->next) { exo_print(exo, exo_stream->fd); fprintf(exo_stream->fd, "\n\n"); } myzfclose(exo_stream); } }
/* print an EXO term */ void exo_print(struct exo_term_t *exo, FILE *stream) { if (!stream) stream = stderr; switch (exo->ec) { case ec_integer: if (sizeof(exo_integer_t) == 4) myfprintf(stream, "%u", exo->as_integer.val); else myfprintf(stream, "%lu", exo->as_integer.val); break; case ec_address: if (sizeof(exo_address_t) == 4) myfprintf(stream, "0x%x", exo->as_integer.val); else myfprintf(stream, "0x%lx", exo->as_integer.val); break; case ec_float: fprintf(stream, "%f", exo->as_float.val); break; case ec_char: fprintf(stream, "'"); print_char(exo->as_char.val, stream); fprintf(stream, "'"); break; case ec_string: fprintf(stream, "\""); print_string(exo->as_string.str, stream); fprintf(stream, "\""); break; case ec_list: { struct exo_term_t *ent; fprintf(stream, "("); for (ent=exo->as_list.head; ent != NULL; ent=ent->next) { exo_print(ent, stream); if (ent->next) fprintf(stream, ", "); } fprintf(stream, ")"); } break; case ec_array: { int i, last; /* search for last first non-NULL entry */ for (last=exo->as_array.size-1; last >= 0; last--) { if (EXO_ARR(exo, last) != NULL) break; } /* LAST == index of last non-NULL array entry */ fprintf(stream, "{%d}[", exo->as_array.size); for (i=0; i<exo->as_array.size && i <= last; i++) { if (exo->as_array.array[i] != NULL) exo_print(exo->as_array.array[i], stream); else fprintf(stream, " "); if (i != exo->as_array.size-1 && i != last) fprintf(stream, ", "); } fprintf(stream, "]"); } break; case ec_token: fprintf(stream, "%s", exo->as_token.ent->str); break; case ec_blob: { int i, cr; fprintf(stream, "{%d}<\n", exo->as_blob.size); for (i=0; i < exo->as_blob.size; i++) { cr = FALSE; if (i != 0 && (i % 38) == 0) { fprintf(stream, "\n"); cr = TRUE; } fprintf(stream, "%02x", exo->as_blob.data[i]); } if (!cr) fprintf(stream, "\n"); fprintf(stream, ">"); } break; default: panic("bogus EXO class"); } }
/* check point current architected state to stream FD, returns EIO transaction count (an EIO file pointer) */ counter_t eio_write_chkpt(struct regs_t *regs, /* regs to dump */ struct mem_t *mem, /* memory to dump */ FILE *fd) /* stream to write to */ { int i; struct exo_term_t *exo; struct mem_pte_t *pte; myfprintf(fd, "/* ** start checkpoint @ %n... */\n\n", eio_trans_icnt); myfprintf(fd, "/* EIO file pointer: %n... */\n", eio_trans_icnt); exo = exo_new(ec_integer, (exo_integer_t)eio_trans_icnt); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); /* dump misc regs: icnt, PC, NPC, etc... */ fprintf(fd, "/* misc regs icnt, PC, NPC, etc... */\n"); exo = MD_MISC_REGS_TO_EXO(regs); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); /* dump integer registers */ fprintf(fd, "/* integer regs */\n"); exo = exo_new(ec_list, NULL); for (i=0; i < MD_NUM_IREGS; i++) exo->as_list.head = exo_chain(exo->as_list.head, MD_IREG_TO_EXO(regs, i)); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); /* dump FP registers */ fprintf(fd, "/* FP regs (integer format) */\n"); exo = exo_new(ec_list, NULL); for (i=0; i < MD_NUM_FREGS; i++) exo->as_list.head = exo_chain(exo->as_list.head, MD_FREG_TO_EXO(regs, i)); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); fprintf(fd, "/* writing `%d' memory pages... */\n", (int)mem->page_count); exo = exo_new(ec_list, exo_new(ec_integer, (exo_integer_t)mem->page_count), exo_new(ec_address, (exo_integer_t)ld_brk_point), exo_new(ec_address, (exo_integer_t)ld_stack_min), NULL); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); fprintf(fd, "/* text segment specifiers (base & size) */\n"); exo = exo_new(ec_list, exo_new(ec_address, (exo_integer_t)ld_text_base), exo_new(ec_integer, (exo_integer_t)ld_text_size), NULL); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); fprintf(fd, "/* data segment specifiers (base & size) */\n"); exo = exo_new(ec_list, exo_new(ec_address, (exo_integer_t)ld_data_base), exo_new(ec_integer, (exo_integer_t)ld_data_size), NULL); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); fprintf(fd, "/* stack segment specifiers (base & size) */\n"); exo = exo_new(ec_list, exo_new(ec_address, (exo_integer_t)ld_stack_base), exo_new(ec_integer, (exo_integer_t)ld_stack_size), NULL); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); /* visit all active memory pages, and dump them to the checkpoint file */ MEM_FORALL(mem, i, pte) { /* dump this page... */ exo = exo_new(ec_list, exo_new(ec_address, (exo_integer_t)MEM_PTE_ADDR(pte, i)), exo_new(ec_blob, MD_PAGE_SIZE, pte->page), NULL); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); }