normalize files before parsing and hashing

[swftools.git] / lib / as3 / pool.c

diff --git a/lib/as3/pool.c b/lib/as3/pool.c
index a17797f..54609d0 100644 (file)
--- a/lib/as3/pool.c
+++ b/lib/as3/pool.c
@@ -189,8 +189,7 @@ char* namespace_tostring(namespace_t*ns)
     else if(!*s)
         sprintf(string, "[%s]\"\"", access, s);
     else 
-        sprintf(string, "[%s]", access, s);
-
+        sprintf(string, "[%s]%s", access, s);
     free(s);
     return string;
 }
@@ -567,7 +566,7 @@ char* multiname_tostring(multiname_t*m)
         strcat(mname,s);
         free(s);
     } else {
-        fprintf(stderr, "Invalid multiname type: %02x\n", m->type);
+        return strdup("<invalid>");
     }
     free(name);
     return mname;
@@ -810,23 +809,61 @@ void constant_free(constant_t*c)
     }
     free(c);
 }
+// --------------------------- optimizing -----------------------------------
+
+static int array_append_or_increase(array_t*array, void*key)
+{
+    int pos = array_find(array, key);
+    if(pos>=0) {
+        array->d[pos].data++;
+        return pos;
+    } else {
+        return array_append(array, key, 0);
+    }
+}
+static int compare_arrayentry(const void*_c1, const void*_c2)
+{
+    const array_entry_t*c1 = _c1;
+    const array_entry_t*c2 = _c2;
+    return c2->data - c1->data;
+}
+
+static void* nodup(const void*o) {return (void*)o;}
+
+static void reshuffle_array(array_t*array)
+{
+    qsort(array->d+1, array->num-1, sizeof(array->d[0]), compare_arrayentry);
+    type_t* old_type = array->entry2pos->key_type;
+    type_t old_type_nodup = *old_type;
+    old_type_nodup.dup = nodup;
+    dict_t*d = dict_new2(&old_type_nodup);
+    dict_destroy_shallow(array->entry2pos);
+    array->entry2pos = d;
+    int t;
+    for(t=0;t<array->num;t++) {
+        dict_put(array->entry2pos, array->d[t].name, (void*)(ptroff_t)(t+1));
+    }
+    d->key_type = old_type;
+
+}
+
 // ------------------------------- pool -------------------------------------
 
 int pool_register_uint(pool_t*p, unsigned int i)
 {
-    int pos = array_append_if_new(p->x_uints, &i, 0);
+    int pos = array_append_or_increase(p->x_uints, &i);
     assert(pos!=0);
     return pos;
 }
 int pool_register_int(pool_t*p, int i)
 {
-    int pos = array_append_if_new(p->x_ints, &i, 0);
+    int pos = array_append_or_increase(p->x_ints, &i);
     assert(pos!=0);
     return pos;
 }
 int pool_register_float(pool_t*p, double d)
 {
-    int pos = array_append_if_new(p->x_floats, &d, 0);
+    int pos = array_append_or_increase(p->x_floats, &d);
     assert(pos!=0);
     return pos;
 }
@@ -834,35 +871,35 @@ int pool_register_string(pool_t*pool, const char*str)
 {
     if(!str) return 0;
     string_t s = string_new2(str);
-    int pos = array_append_if_new(pool->x_strings, &s, 0);
+    int pos = array_append_or_increase(pool->x_strings, &s);
     assert(pos!=0);
     return pos;
 }
 int pool_register_string2(pool_t*pool, string_t*s)
 {
     if(!s || !s->str) return 0;
-    int pos = array_append_if_new(pool->x_strings, s, 0);
+    int pos = array_append_or_increase(pool->x_strings, s);
     assert(pos!=0);
     return pos;
 }
 int pool_register_namespace(pool_t*pool, namespace_t*ns)
 {
     if(!ns) return 0;
-    int pos = array_append_if_new(pool->x_namespaces, ns, 0);
+    int pos = array_append_or_increase(pool->x_namespaces, ns);
     assert(pos!=0);
     return pos;
 }
 int pool_register_namespace_set(pool_t*pool, namespace_set_t*set)
 {
     if(!set) return 0;
-    int pos = array_append_if_new(pool->x_namespace_sets, set, 0);
+    int pos = array_append_or_increase(pool->x_namespace_sets, set);
     assert(pos!=0);
     return pos;
 }
 int pool_register_multiname(pool_t*pool, multiname_t*n)
 {
     if(!n) return 0;
-    int pos = array_append_if_new(pool->x_multinames, n, 0);
+    int pos = array_append_or_increase(pool->x_multinames, n);
     assert(pos!=0);
     return pos;
 }
@@ -870,7 +907,7 @@ int pool_register_multiname2(pool_t*pool, char*name)
 {
     if(!name) return 0;
     multiname_t*n = multiname_fromstring(name);
-    int pos = array_append_if_new(pool->x_multinames, n, 0);
+    int pos = array_append_or_increase(pool->x_multinames, n);
     multiname_destroy(n);
     assert(pos!=0);
     return pos;
@@ -1019,6 +1056,17 @@ pool_t*pool_new()
     return p;
 }
 
+void pool_optimize(pool_t*p)
+{
+    reshuffle_array(p->x_ints);
+    reshuffle_array(p->x_uints);
+    reshuffle_array(p->x_floats);
+    reshuffle_array(p->x_strings);
+    reshuffle_array(p->x_namespaces);
+    reshuffle_array(p->x_namespace_sets);
+    reshuffle_array(p->x_multinames);
+}
+
 #define DEBUG if(0)
 //#define DEBUG
 
@@ -1095,6 +1143,12 @@ void pool_read(pool_t*pool, TAG*tag)
     for(t=1;t<num_multinames;t++) {
         multiname_t m;
         memset(&m, 0, sizeof(multiname_t));
+        
+        /*int s;
+        for(s=0;s<8;s++)
+            printf("0x%02x ", tag->data[tag->pos+s]);
+        printf("\n");*/
+
        m.type = swf_GetU8(tag);
        if(m.type==0x07 || m.type==0x0d) {
            int namespace_index = swf_GetU30(tag);
@@ -1116,6 +1170,17 @@ void pool_read(pool_t*pool, TAG*tag)
         } else if(m.type==0x1b || m.type==0x1c) {
             int namespace_set_index = swf_GetU30(tag);
            m.namespace_set = (namespace_set_t*)array_getkey(pool->x_namespace_sets, namespace_set_index);
+        } else if(m.type==0x1d) {
+            int v1 = swf_GetU30(tag);
+            int v2 = swf_GetU30(tag);
+            int v3 = swf_GetU30(tag);
+            //printf("%02x %02x %02x\n", v1, v2, v3);
+            m.type = 0x07;
+            m.namespace_set = 0;
+            m.name = pool_lookup_string(pool, v1);
+            m.ns = pool_lookup_namespace(pool, v2);
+            /* not sure what to do with v3-
+               it's definitely not a namespace */
        } else {
            printf("can't parse type %d multinames yet\n", m.type);
        }
@@ -1127,48 +1192,55 @@ void pool_read(pool_t*pool, TAG*tag)
 void pool_dump(pool_t*pool, FILE*fo, char flags)
 {
     int t;
-    fprintf(fo, "%d integers:\n", pool->x_ints->num);
+    fprintf(fo, "%d integers\n", pool->x_ints->num);
     for(t=1;t<pool->x_ints->num;t++) {
         S32 val = *(int*)array_getkey(pool->x_ints, t);
-        if(flags&1) fprintf(fo, "%d) %d\n", t, val);
+        int freq = (int)(ptroff_t)array_getvalue(pool->x_ints, t);
+        if(flags&1) fprintf(fo, "%5d %d) %d\n", freq, t, val);
     }
-    fprintf(fo, "%d unsigned integers:\n", pool->x_uints->num);
+    fprintf(fo, "%d unsigned integers\n", pool->x_uints->num);
     for(t=1;t<pool->x_uints->num;t++) {
         U32 val = *(unsigned int*)array_getkey(pool->x_uints, t);
-        if(flags&1) fprintf(fo, "%d) %d\n", t, val);
+        int freq = (int)(ptroff_t)array_getvalue(pool->x_uints, t);
+        if(flags&1) fprintf(fo, "%5d %d) %d\n", freq, t, val);
     }
-    fprintf(fo, "%d floats:\n", pool->x_floats->num);
+    fprintf(fo, "%d floats\n", pool->x_floats->num);
     for(t=1;t<pool->x_floats->num;t++) {
         double d = pool_lookup_float(pool, t);
-        if(flags&2) fprintf(fo, "%d) %f\n", t, d);
+        int freq = (int)(ptroff_t)array_getvalue(pool->x_floats, t);
+        if(flags&2) fprintf(fo, "%5d %d) %f\n", freq, t, d);
     }
-    fprintf(fo, "%d strings:\n", pool->x_strings->num);
+    fprintf(fo, "%d strings\n", pool->x_strings->num);
     for(t=1;t<pool->x_strings->num;t++) {
         string_t str = pool_lookup_string2(pool, t);
-        if(flags&1) fprintf(fo, "%d) ", t);
+        int freq = (int)(ptroff_t)array_getvalue(pool->x_strings, t);
+        if(flags&1) fprintf(fo, "%5d %d) ", freq, t);
         if(flags&1) fwrite(str.str, str.len, 1, fo);
         if(flags&1) fprintf(fo, "\n", t);
     }
-    fprintf(fo, "%d namespaces:\n", pool->x_namespaces->num);
+    fprintf(fo, "%d namespaces\n", pool->x_namespaces->num);
     for(t=1;t<pool->x_namespaces->num;t++) {
        namespace_t*ns= (namespace_t*)array_getkey(pool->x_namespaces, t);
         char*s = namespace_tostring(ns);
-        if(flags&1) fprintf(fo, "%d) %s\n", t, s);
+        int freq = (int)(ptroff_t)array_getvalue(pool->x_namespaces, t);
+        if(flags&1) fprintf(fo, "%5d %d) %s\n", freq, t, s);
         free(s);
     }
-    fprintf(fo, "%d namespace sets:\n", pool->x_namespace_sets->num);
+    fprintf(fo, "%d namespace sets\n", pool->x_namespace_sets->num);
     for(t=1;t<pool->x_namespace_sets->num;t++) {
         namespace_set_t*set = (namespace_set_t*)array_getkey(pool->x_namespace_sets, t);
         char*s = namespace_set_tostring(set);
-        if(flags&1) fprintf(fo, "%d) %s\n", t, s);
+        int freq = (int)(ptroff_t)array_getvalue(pool->x_namespace_sets, t);
+        if(flags&1) fprintf(fo, "%5d %d) %s\n", freq, t, s);
         free(s);
     }
 
-    fprintf(fo, "%d multinames:\n", pool->x_multinames->num);
+    fprintf(fo, "%d multinames\n", pool->x_multinames->num);
     for(t=1;t<pool->x_multinames->num;t++) {
        multiname_t*m = (multiname_t*)array_getkey(pool->x_multinames, t);
         char*s = multiname_tostring(m);
-        if(flags&1) fprintf(fo, "%d) %s\n", t, s);
+        int freq = (int)(ptroff_t)array_getvalue(pool->x_multinames, t);
+        if(flags&1) fprintf(fo, "%5d %d) %s\n", freq, t, s);
         free(s);
     }
 }