Some statistics as Samual wanted.
authorDale Weiler <killfieldengine@gmail.com>
Wed, 14 Aug 2013 04:08:00 +0000 (04:08 +0000)
committerDale Weiler <killfieldengine@gmail.com>
Wed, 14 Aug 2013 04:08:00 +0000 (04:08 +0000)
code.c
gmqcc.h
ir.c
main.c
util.c

diff --git a/code.c b/code.c
index a763ee6681b14940eb7e66be793c2e298fc36332..42b46a4e93b28832da1b6e13296731ef3eac6e8d 100644 (file)
--- a/code.c
+++ b/code.c
@@ -128,7 +128,34 @@ qcint_t code_alloc_field (code_t *code, size_t qcsize)
     return pos;
 }
 
-static void code_create_header(code_t *code, prog_header_t *code_header) {
+static size_t code_size_generic(code_t *code, prog_header_t *code_header, bool lno) {
+    size_t size = 0;
+    if (lno) {
+        size += 4;  /* LNOF */
+        size += sizeof(uint32_t); /* version */
+        size += sizeof(code_header->defs.length);
+        size += sizeof(code_header->globals.length);
+        size += sizeof(code_header->fields.length);
+        size += sizeof(code_header->statements.length);
+        size += sizeof(code->linenums[0]) * vec_size(code->linenums);
+    } else {
+        size += sizeof(prog_header_t);
+        size += sizeof(prog_section_statement_t) * vec_size(code->statements);
+        size += sizeof(prog_section_def_t)       * vec_size(code->defs);
+        size += sizeof(prog_section_field_t)     * vec_size(code->fields);
+        size += sizeof(prog_section_function_t)  * vec_size(code->functions);
+        size += sizeof(int32_t)                  * vec_size(code->globals);
+        size += 1                                * vec_size(code->chars);
+    }
+    return size;
+}
+
+#define code_size_binary(C, H) code_size_generic((C), (H), false)
+#define code_size_debug(C, H)  code_size_generic((C), (H), true)
+
+static void code_create_header(code_t *code, prog_header_t *code_header, const char *filename, const char *lnofile) {
+    size_t i;
+
     code_header->statements.offset = sizeof(prog_header_t);
     code_header->statements.length = vec_size(code->statements);
     code_header->defs.offset       = code_header->statements.offset + (sizeof(prog_section_statement_t) * vec_size(code->statements));
@@ -179,6 +206,49 @@ static void code_create_header(code_t *code, prog_header_t *code_header) {
     util_endianswap(code->fields,     vec_size(code->fields),     sizeof(prog_section_field_t));
     util_endianswap(code->functions,  vec_size(code->functions),  sizeof(prog_section_function_t));
     util_endianswap(code->globals,    vec_size(code->globals),    sizeof(int32_t));
+
+
+    if (!OPTS_OPTION_BOOL(OPTION_QUIET)) {
+        if (lnofile)
+            con_out("writing '%s' and '%s'...\n", filename, lnofile);
+        else
+            con_out("writing '%s'\n", filename);
+    }
+
+    if (!OPTS_OPTION_BOOL(OPTION_QUIET) &&
+        !OPTS_OPTION_BOOL(OPTION_PP_ONLY))
+    {
+        char buffer[1024];
+        con_out("\nOptimizations:\n");
+        for (i = 0; i < COUNT_OPTIMIZATIONS; ++i) {
+            if (opts_optimizationcount[i]) {
+                util_optimizationtostr(opts_opt_list[i].name, buffer, sizeof(buffer));
+                con_out(
+                    "    %s: %u\n",
+                    buffer,
+                    (unsigned int)opts_optimizationcount[i]
+                );
+            }
+        }
+    }
+}
+
+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));
+    }
 }
 
 /*
@@ -193,7 +263,7 @@ bool code_write_memory(code_t *code, uint8_t **datmem, size_t *sizedat, uint8_t
     if (!datmem)
         return false;
 
-    code_create_header(code, &code_header);
+    code_create_header(code, &code_header, "<<memory>>", "<<memory>>");
 
     #define WRITE_CHUNK(C,X,S)                                     \
         do {                                                       \
@@ -205,15 +275,8 @@ bool code_write_memory(code_t *code, uint8_t **datmem, size_t *sizedat, uint8_t
     if (lnomem) {
         uint32_t version = 1;
 
-        *sizelno += 4;               /* LNOF */
-        *sizelno += sizeof(version);
-        *sizelno += sizeof(code_header.defs.length);
-        *sizelno += sizeof(code_header.globals.length);
-        *sizelno += sizeof(code_header.fields.length);
-        *sizelno += sizeof(code_header.statements.length);
-        *sizelno += sizeof(code->linenums[0]) * vec_size(code->linenums);
-
-        *lnomem   = (uint8_t*)mem_a(*sizelno);
+        *sizelno = code_size_debug(code, &code_header);
+        *lnomem  = (uint8_t*)mem_a(*sizelno);
 
         WRITE_CHUNK(lnomem, "LNOF",                         4);
         WRITE_CHUNK(lnomem, &version,                       sizeof(version));
@@ -232,15 +295,8 @@ bool code_write_memory(code_t *code, uint8_t **datmem, size_t *sizedat, uint8_t
     }
 
     /* Write out the dat */
-    *sizedat += sizeof(prog_header_t);
-    *sizedat += sizeof(prog_section_statement_t) * vec_size(code->statements);
-    *sizedat += sizeof(prog_section_def_t)       * vec_size(code->defs);
-    *sizedat += sizeof(prog_section_field_t)     * vec_size(code->fields);
-    *sizedat += sizeof(prog_section_function_t)  * vec_size(code->functions);
-    *sizedat += sizeof(int32_t)                  * vec_size(code->globals);
-    *sizedat += 1                                * vec_size(code->chars);
-
-    *datmem = (uint8_t*)mem_a(*sizedat);
+    *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));
@@ -250,8 +306,6 @@ bool code_write_memory(code_t *code, uint8_t **datmem, size_t *sizedat, uint8_t
     WRITE_CHUNK(datmem, code->globals,    sizeof(int32_t)                  * vec_size(code->globals));
     WRITE_CHUNK(datmem, code->chars,      1                                * vec_size(code->chars));
 
-    #undef WRITE_CHUNK
-
     vec_free(code->statements);
     vec_free(code->linenums);
     vec_free(code->defs);
@@ -262,16 +316,17 @@ bool code_write_memory(code_t *code, uint8_t **datmem, size_t *sizedat, uint8_t
 
     util_htdel(code->string_cache);
     mem_d(code);
-
+    code_stats("<<memory>>", (lnomem) ? "<<memory>>" : NULL, code, &code_header);
     return true;
 }
+#undef WRITE_CHUNK
 
 bool code_write(code_t *code, const char *filename, const char *lnofile) {
     prog_header_t  code_header;
     FILE          *fp           = NULL;
     size_t         it           = 2;
 
-    code_create_header(code, &code_header);
+    code_create_header(code, &code_header, filename, lnofile);
 
     if (lnofile) {
         uint32_t version = 1;
@@ -370,6 +425,7 @@ bool code_write(code_t *code, const char *filename, const char *lnofile) {
     }
 
     fs_file_close(fp);
+    code_stats(filename, lnofile, code, &code_header);
     return true;
 }
 
diff --git a/gmqcc.h b/gmqcc.h
index d0cd85edf6b6c62db8d611375bea93870150dd5c..367b74f23e0ceaff738580b9cce4cc5b6aee003f 100644 (file)
--- a/gmqcc.h
+++ b/gmqcc.h
@@ -325,8 +325,9 @@ bool  util_strdigit      (const char *);
 void  util_debug         (const char *, const char *, ...);
 void  util_endianswap    (void *,  size_t, unsigned int);
 
-size_t util_strtocmd    (const char *, char *, size_t);
-size_t util_strtononcmd (const char *, char *, size_t);
+size_t util_strtocmd         (const char *, char *, size_t);
+size_t util_strtononcmd      (const char *, char *, size_t);
+size_t util_optimizationtostr(const char *, char *, size_t);
 
 uint16_t util_crc16(uint16_t crc, const char *data, size_t len);
 
diff --git a/ir.c b/ir.c
index 4f53533887bdd0e73feef89352f7ece84bd39856..2d55ce0ea410213f31ba822e0f38c5320cb9c2e0 100644 (file)
--- a/ir.c
+++ b/ir.c
@@ -3709,16 +3709,11 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
         memcpy(vec_add(lnofile, 5), ".lno", 5);
     }
 
-    if (!OPTS_OPTION_BOOL(OPTION_QUIET)) {
-        if (lnofile)
-            con_out("writing '%s' and '%s'...\n", filename, lnofile);
-        else
-            con_out("writing '%s'\n", filename);
-    }
     if (!code_write(self->code, filename, lnofile)) {
         vec_free(lnofile);
         return false;
     }
+
     vec_free(lnofile);
     return true;
 }
diff --git a/main.c b/main.c
index 2450e6a63ae8ac67bd1c0a5f50a51132857f87e1..1718e32972ec7e4e90c0be79bdb03fe3f5a91652 100644 (file)
--- a/main.c
+++ b/main.c
@@ -766,17 +766,6 @@ int main(int argc, char **argv) {
         }
     }
 
-    /* stuff */
-    if (!OPTS_OPTION_BOOL(OPTION_QUIET) &&
-        !OPTS_OPTION_BOOL(OPTION_PP_ONLY))
-    {
-        for (itr = 0; itr < COUNT_OPTIMIZATIONS; ++itr) {
-            if (opts_optimizationcount[itr]) {
-                con_out("%s: %u\n", opts_opt_list[itr].name, (unsigned int)opts_optimizationcount[itr]);
-            }
-        }
-    }
-
 cleanup:
     util_debug("COM", "cleaning ...\n");
     if (ftepp)
diff --git a/util.c b/util.c
index 247830435351b2e14b376bf110c2b5380d6afbfb..69f805c4e985af0b277d35145514890e9bc68523 100644 (file)
--- a/util.c
+++ b/util.c
@@ -241,6 +241,14 @@ size_t util_strtononcmd(const char *in, char *out, size_t outsz) {
     return sz-1;
 }
 
+size_t util_optimizationtostr(const char *in, char *out, size_t outsz) {
+    size_t sz = 1;
+    for (; *in && sz < outsz; ++in, ++out, ++sz)
+        *out = (*in == '_') ? ' ' : (util_isalpha(*in) && util_isupper(*in)) ? *in + 'a' - 'A' : *in;
+    *out = 0;
+    return sz-1;
+}
+
 /*
  * Portable implementation of vasprintf/asprintf. Assumes vsnprintf
  * exists, otherwise compiler error.