X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fas3%2Fpool.c;h=167393bec189b81c441221c029a8a71b967dcc92;hb=876cadced9adaae335e18d8d0bb5288eec53570a;hp=7305bd9931be1535572dfecc293a8879788bc6d3;hpb=0e8c813526759f04f0fda2e29c4ce1656eafbe2b;p=swftools.git

diff --git a/lib/as3/pool.c b/lib/as3/pool.c
index 7305bd9..167393b 100644
--- a/lib/as3/pool.c
+++ b/lib/as3/pool.c
@@ -55,7 +55,10 @@ char float_equals(const void*_v1, const void*_v2) {
     const double*v2=_v2;
     if(!v1 || !v2) 
         return v1==v2;
-    return *v1==*v2;
+    
+    if(*v1==*v2) return 1;
+    if(*v1!=*v1 && *v2!=*v2) return 1; //both values are NaN
+    return 0;
 }
 
 type_t float_type = {
@@ -180,7 +183,7 @@ char* namespace_tostring(namespace_t*ns)
     U8 type = ns->access;
     access = access2str(type);
     char*s = escape_string(ns->name);
-    char*string = (char*)malloc(strlen(access)+strlen(s)+3);
+    char*string = (char*)malloc(strlen(access)+strlen(s)+7);
     if(!s)
         sprintf(string, "[%s]NULL", access, s);
     else if(!*s)
@@ -478,7 +481,7 @@ multiname_t* multiname_clone(multiname_t*other)
 
 char* access2str(int type)
 {
-    if(type==0x08) return "access08";
+    if(type==0x08) return "namespace";
     else if(type==0x16) return "public";
     else if(type==0x17) return "packageinternal";
     else if(type==0x18) return "protected";
@@ -734,7 +737,7 @@ constant_t* constant_fromindex(pool_t*pool, int index, int type)
 char* constant_tostring(constant_t*c)
 {
     if(!c)
-        return 0;
+        return strdup("NULL");
     char buf[32];
     if(NS_TYPE(c->type)) {
         return namespace_tostring(c->ns);
@@ -807,23 +810,52 @@ 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 c1->data - c2->data;
+}
+static void reshuffle_array(array_t*array)
+{
+    qsort(array->d, array->num, sizeof(array->d[0]), compare_arrayentry);
+    dict_destroy(array->entry2pos);
+    array->entry2pos = dict_new();
+    int t;
+    for(t=0;t<array->num;t++) {
+        dict_put(array->entry2pos, array->d[t].name, (void*)(ptroff_t)(t+1));
+    }
+}
+
 // ------------------------------- 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;
 }
@@ -831,35 +863,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;
 }
@@ -867,7 +899,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;
@@ -1016,6 +1048,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
 
@@ -1121,6 +1164,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);
+    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);
+    }
+    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);
+    }
+    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);
+    }
+    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);
+        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);
+    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);
+        free(s);
+    }
+    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);
+        free(s);
+    }
+
+    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);
+        free(s);
+    }
+} 
+
 void pool_write(pool_t*pool, TAG*tag)
 {
     int t;