+}
+
+static void code_stats(const char *filename, const char *lnofile, code_t *code, prog_header_t *code_header) {
+ if (OPTS_OPTION_BOOL(OPTION_QUIET) ||
+ OPTS_OPTION_BOOL(OPTION_PP_ONLY))
+ return;
+
+ con_out("\nFile statistics:\n");
+ con_out(" dat:\n");
+ con_out(" name: %s\n", filename);
+ con_out(" size: %u (bytes)\n", code_size_binary(code, code_header));
+ con_out(" crc: 0x%04X\n", code->crc);
+
+ if (lnofile) {
+ con_out(" lno:\n");
+ con_out(" name: %s\n", lnofile);
+ con_out(" size: %u (bytes)\n", code_size_debug(code, code_header));
+ }
+
+ con_out("\n");
+}
+
+/*
+ * Same principle except this one allocates memory and writes the lno(optional) and the dat file
+ * directly out to allocated memory. Which is actually very useful for the future library support
+ * we're going to add.
+ */
+#if 0
+static bool code_write_memory(code_t *code, uint8_t **datmem, size_t *sizedat, uint8_t **lnomem, size_t *sizelno) GMQCC_UNUSED {
+ prog_header_t code_header;
+ uint32_t offset = 0;
+
+ if (!datmem)
+ return false;
+
+ code_create_header(code, &code_header, "<<memory>>", "<<memory>>");
+
+ #define WRITE_CHUNK(C,X,S) \
+ do { \
+ memcpy((void*)(&(*C)[offset]), (const void*)(X), (S)); \
+ offset += (S); \
+ } while (0)
+
+ /* Calculate size required to store entire file out to memory */
+ if (lnomem) {
+ uint32_t version = 1;
+
+ *sizelno = code_size_debug(code, &code_header);
+ *lnomem = (uint8_t*)mem_a(*sizelno);
+
+ WRITE_CHUNK(lnomem, "LNOF", 4);
+ WRITE_CHUNK(lnomem, &version, sizeof(version));
+ WRITE_CHUNK(lnomem, &code_header.defs.length, sizeof(code_header.defs.length));
+ WRITE_CHUNK(lnomem, &code_header.globals.length, sizeof(code_header.globals.length));
+ WRITE_CHUNK(lnomem, &code_header.fields.length, sizeof(code_header.fields.length));
+ WRITE_CHUNK(lnomem, &code_header.statements.length, sizeof(code_header.statements.length));
+
+ /* something went terribly wrong */
+ if (offset != *sizelno) {
+ mem_d(*lnomem);
+ *sizelno = 0;
+ return false;
+ }
+ offset = 0;
+ }
+
+ /* Write out the dat */
+ *sizedat = code_size_binary(code, &code_header);
+ *datmem = (uint8_t*)mem_a(*sizedat);
+
+ WRITE_CHUNK(datmem, &code_header, sizeof(prog_header_t));
+ WRITE_CHUNK(datmem, code->statements, sizeof(prog_section_statement_t) * vec_size(code->statements));
+ WRITE_CHUNK(datmem, code->defs, sizeof(prog_section_def_t) * vec_size(code->defs));
+ WRITE_CHUNK(datmem, code->fields, sizeof(prog_section_field_t) * vec_size(code->fields));
+ WRITE_CHUNK(datmem, code->functions, sizeof(prog_section_function_t) * vec_size(code->functions));
+ WRITE_CHUNK(datmem, code->globals, sizeof(int32_t) * vec_size(code->globals));
+ WRITE_CHUNK(datmem, code->chars, 1 * vec_size(code->chars));
+
+ vec_free(code->statements);
+ vec_free(code->linenums);
+ vec_free(code->columnnums);
+ vec_free(code->defs);
+ vec_free(code->fields);
+ vec_free(code->functions);
+ vec_free(code->globals);
+ vec_free(code->chars);
+
+ util_htdel(code->string_cache);
+ mem_d(code);
+ code_stats("<<memory>>", (lnomem) ? "<<memory>>" : NULL, code, &code_header);
+ return true;
+}
+#endif /*!#if 0 reenable when ready to be used */
+#undef WRITE_CHUNK
+
+bool code_write(code_t *code, const char *filename, const char *lnofile) {
+ prog_header_t code_header;
+ fs_file_t *fp = NULL;
+
+ code_create_header(code, &code_header, filename, lnofile);
+
+ if (lnofile) {
+ uint32_t version = 1;
+
+ fp = fs_file_open(lnofile, "wb");
+ if (!fp)
+ return false;
+
+ util_endianswap(&version, 1, sizeof(version));
+ util_endianswap(code->linenums, vec_size(code->linenums), sizeof(code->linenums[0]));
+ util_endianswap(code->columnnums, vec_size(code->columnnums), sizeof(code->columnnums[0]));
+
+ if (fs_file_write("LNOF", 4, 1, fp) != 1 ||
+ fs_file_write(&version, sizeof(version), 1, fp) != 1 ||
+ fs_file_write(&code_header.defs.length, sizeof(code_header.defs.length), 1, fp) != 1 ||
+ fs_file_write(&code_header.globals.length, sizeof(code_header.globals.length), 1, fp) != 1 ||
+ fs_file_write(&code_header.fields.length, sizeof(code_header.fields.length), 1, fp) != 1 ||
+ fs_file_write(&code_header.statements.length, sizeof(code_header.statements.length), 1, fp) != 1 ||
+ fs_file_write(code->linenums, sizeof(code->linenums[0]), vec_size(code->linenums), fp) != vec_size(code->linenums) ||
+ fs_file_write(code->columnnums, sizeof(code->columnnums[0]), vec_size(code->columnnums), fp) != vec_size(code->columnnums))
+ {
+ con_err("failed to write lno file\n");
+ }
+
+ fs_file_close(fp);
+ fp = NULL;
+ }
+
+ fp = fs_file_open(filename, "wb");
+ if (!fp)
+ return false;
+
+ if (1 != fs_file_write(&code_header, sizeof(prog_header_t) , 1 , fp) ||
+ vec_size(code->statements) != fs_file_write(code->statements, sizeof(prog_section_statement_t), vec_size(code->statements), fp) ||
+ vec_size(code->defs) != fs_file_write(code->defs, sizeof(prog_section_def_t) , vec_size(code->defs) , fp) ||
+ vec_size(code->fields) != fs_file_write(code->fields, sizeof(prog_section_field_t) , vec_size(code->fields) , fp) ||
+ vec_size(code->functions) != fs_file_write(code->functions, sizeof(prog_section_function_t) , vec_size(code->functions) , fp) ||
+ vec_size(code->globals) != fs_file_write(code->globals, sizeof(int32_t) , vec_size(code->globals) , fp) ||
+ vec_size(code->chars) != fs_file_write(code->chars, 1 , vec_size(code->chars) , fp))
+ {
+ fs_file_close(fp);
+ return false;
+ }
+
+ fs_file_close(fp);
+ code_stats(filename, lnofile, code, &code_header);
+ return true;
+}
+
+void code_cleanup(code_t *code) {
+ vec_free(code->statements);
+ vec_free(code->linenums);
+ vec_free(code->columnnums);
+ vec_free(code->defs);
+ vec_free(code->fields);
+ vec_free(code->functions);
+ vec_free(code->globals);
+ vec_free(code->chars);
+
+ util_htdel(code->string_cache);
+
+ mem_d(code);