X-Git-Url: http://git.asbjorn.biz/?p=swftools.git;a=blobdiff_plain;f=lib%2Fas3%2Fpool.c;h=ce279a3428c5be57119c8e36e9e9a3d5e885cd05;hp=77f401eaab4108cdf7d278f756628aaf45c744a8;hb=d7367b3ec772ea163ebca6b7497639a0cb45c20c;hpb=b66793aae0b5e65b24c1799083787e635e2b485d

diff --git a/lib/as3/pool.c b/lib/as3/pool.c
index 77f401e..ce279a3 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 = {
@@ -133,7 +136,7 @@ char*escape_string(const char*str)
     if(!str)
         return strdup("NULL");
     int len=0;
-    unsigned const char*s=str;
+    unsigned const char*s=(unsigned const char*)str;
     while(*s) {
         if(*s<10) {
             len+=2; // \d
@@ -148,7 +151,7 @@ char*escape_string(const char*str)
     }
     char*newstr = malloc(len+1);
     char*dest = newstr;
-    s=str;
+    s=(unsigned const char*)str;
     while(*s) {
         if(*s<9) {
             dest+=sprintf(dest, "\\%d", *s);
@@ -172,7 +175,7 @@ char*escape_string(const char*str)
     return newstr;
 }
 
-char* namespace_to_string(namespace_t*ns)
+char* namespace_tostring(namespace_t*ns)
 {
     if(!ns)
         return strdup("NULL");
@@ -180,8 +183,13 @@ char* namespace_to_string(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);
-    int l = sprintf(string, "[%s]%s", access, s);
+    char*string = (char*)malloc(strlen(access)+strlen(s)+7);
+    if(!s)
+        sprintf(string, "[%s]NULL", access);
+    else if(!*s)
+        sprintf(string, "[%s]\"\"", access);
+    else 
+        sprintf(string, "[%s]%s", access, s);
     free(s);
     return string;
 }
@@ -201,7 +209,7 @@ namespace_t* namespace_fromstring(const char*name)
     namespace_t*ns = malloc(sizeof(namespace_t));
     memset(ns, 0, sizeof(namespace_t));
     if(name[0] == '[') {
-        U8 access;
+        U8 access = 0;
         char*n = strdup(name);
         char*bracket = strchr(n, ']');
         if(bracket) {
@@ -211,6 +219,7 @@ namespace_t* namespace_fromstring(const char*name)
             if(!strcmp(a, "")) access=0x16;
             else if(!strcmp(a, "undefined")) access=0x08; // public??
             else if(!strcmp(a, "package")) access=0x16;
+            else if(!strcmp(a, "public")) access=0x16;
             else if(!strcmp(a, "packageinternal")) access=0x17;
             else if(!strcmp(a, "protected")) access=0x18;
             else if(!strcmp(a, "explicit")) access=0x19;
@@ -241,7 +250,7 @@ namespace_t* namespace_new(U8 access, const char*name)
     ns->name = name?strdup(name):0;
     return ns;
 }
-namespace_t* namespace_new_undefined(const char*name) {
+namespace_t* namespace_new_namespace(const char*name) {
     return namespace_new(0x08, name); // public?
 }
 namespace_t* namespace_new_package(const char*name) {
@@ -266,7 +275,7 @@ namespace_t* namespace_new_private(const char*name) {
 void namespace_destroy(namespace_t*n)
 {
     if(n) {
-        free(n->name);n->name=0;
+        free((char*)n->name);n->name=0;
         n->access=0x00;
         free(n);
     }
@@ -335,7 +344,7 @@ namespace_set_t* namespace_set_new()
     set->namespaces = list_new();
     return set;
 }
-char* namespace_set_to_string(namespace_set_t*set)
+char* namespace_set_tostring(namespace_set_t*set)
 {
     if(!set)
         return strdup("NULL");
@@ -348,7 +357,7 @@ char* namespace_set_to_string(namespace_set_t*set)
     int l = 0;
     namespace_list_t*lns = set->namespaces;
     while(lns) {
-        char*s = namespace_to_string(lns->namespace);
+        char*s = namespace_tostring(lns->namespace);
         l += strlen(s)+1;
         free(s);
         lns = lns->next;
@@ -357,7 +366,7 @@ char* namespace_set_to_string(namespace_set_t*set)
     strcpy(desc, "{");
     lns = set->namespaces;
     while(lns) {
-        char*s = namespace_to_string(lns->namespace);
+        char*s = namespace_tostring(lns->namespace);
         strcat(desc, s);
         free(s);
         lns = lns->next;
@@ -444,7 +453,11 @@ multiname_t* multiname_new(namespace_t*ns, const char*name)
 {
     NEW(multiname_t,m);
     m->type = QNAME;
-    m->ns = namespace_clone(ns);
+    if(!ns) {
+        m->ns = namespace_new_packageinternal("");
+    } else {
+        m->ns = namespace_clone(ns);
+    }
     m->name = strdup(name);
     return m;
 }
@@ -467,13 +480,14 @@ multiname_t* multiname_clone(multiname_t*other)
 
 char* access2str(int type)
 {
-    if(type==0x08) return "access08";
-    else if(type==0x16) return "package";
+    if(type==0x08) return "namespace";
+    else if(type==0x16) return "public";
     else if(type==0x17) return "packageinternal";
     else if(type==0x18) return "protected";
     else if(type==0x19) return "explicit";
     else if(type==0x1A) return "staticprotected";
     else if(type==0x05) return "private";
+    else if(type==0x00) return "any";
     else {
         fprintf(stderr, "Undefined access type %02x\n", type);
         return "undefined";
@@ -497,7 +511,7 @@ char multiname_late_name(multiname_t*m)
            m->type==MULTINAMEL || m->type==MULTINAMELA;
 }
 
-char* multiname_to_string(multiname_t*m)
+char* multiname_tostring(multiname_t*m)
 {
     char*mname = 0;
     if(!m)
@@ -508,15 +522,18 @@ char* multiname_to_string(multiname_t*m)
     char*name = m->name?escape_string(m->name):strdup("*");
     int namelen = strlen(name);
 
-    if(m->type==QNAME || m->type==QNAMEA) {
-        char*nsname = escape_string(m->ns->name);
+    if(m->type==QNAME || m->type==QNAMEA || m->type==POSTFIXTYPE) {
+        char*nsname = m->ns?escape_string(m->ns->name):strdup("NULL");
         mname = malloc(strlen(nsname)+namelen+32);
         strcpy(mname, "<q");
         if(m->type == QNAMEA)
             strcat(mname, ",attr");
-        strcat(mname, ">[");
-        strcat(mname,access2str(m->ns->access));
-        strcat(mname, "]");
+	strcat(mname, ">");
+	if(m->ns) {
+	    strcat(mname,"[");
+	    strcat(mname,access2str(m->ns->access));
+	    strcat(mname, "]");
+	}
         strcat(mname, nsname);
         free(nsname);
         strcat(mname, "::");
@@ -533,7 +550,7 @@ char* multiname_to_string(multiname_t*m)
     } else if(m->type==RTQNAMELA) {
         mname = strdup("<rt,l,attr>");
     } else if(m->type==MULTINAME || m->type==MULTINAMEA) {
-        char*s = namespace_set_to_string(m->namespace_set);
+        char*s = namespace_set_tostring(m->namespace_set);
         mname = malloc(strlen(s)+namelen+16);
         if(m->type == MULTINAME)
             strcpy(mname,"<multi>");
@@ -544,7 +561,7 @@ char* multiname_to_string(multiname_t*m)
         strcat(mname, name);
         free(s);
     } else if(m->type==MULTINAMEL || m->type==MULTINAMELA) {
-        char*s = namespace_set_to_string(m->namespace_set);
+        char*s = namespace_set_tostring(m->namespace_set);
         mname = malloc(strlen(s)+16);
         if(m->type == MULTINAMEL)
             strcpy(mname,"<l,multi>");
@@ -553,7 +570,7 @@ char* multiname_to_string(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;
@@ -606,6 +623,7 @@ void multiname_destroy(multiname_t*m)
         if(m->namespace_set) {
             namespace_set_destroy(m->namespace_set);m->namespace_set = 0;
         }
+        m->type=0;
         free(m);
     }
 }
@@ -617,54 +635,288 @@ type_t multiname_type = {
     equals: (equals_func)multiname_equals
 };
 
+
+// ------------------------------- constants -------------------------------------
+
+#define UNIQUE_CONSTANT(x) ((x) == CONSTANT_TRUE || (x) == CONSTANT_FALSE || (x) == CONSTANT_NULL || (x) == CONSTANT_UNDEFINED)
+
+constant_t* constant_new_int(int i) 
+{
+    NEW(constant_t,c);
+    c->i = i;
+    c->type = CONSTANT_INT;
+    return c;
+}
+constant_t* constant_new_uint(unsigned int u)
+{
+    NEW(constant_t,c);
+    c->u = u;
+    c->type = CONSTANT_UINT;
+    return c;
+}
+constant_t* constant_new_float(double f)
+{
+    NEW(constant_t,c);
+    c->f = f;
+    c->type = CONSTANT_FLOAT;
+    return c;
+}
+constant_t* constant_new_string(const char*s)
+{
+    NEW(constant_t,c);
+    c->s = string_new4(s);
+    c->type = CONSTANT_STRING;
+    return c;
+}
+constant_t* constant_new_string2(const char*s, int len)
+{
+    NEW(constant_t,c);
+    c->s = string_new3(s, len);
+    c->type = CONSTANT_STRING;
+    return c;
+}
+constant_t* constant_new_namespace(namespace_t*ns)
+{
+    NEW(constant_t,c);
+    c->ns = namespace_clone(ns);
+    c->type = ns->access;
+    assert(NS_TYPE(c->type));
+    return c;
+}
+constant_t* constant_new_true()
+{
+    NEW(constant_t,c);
+    c->type = CONSTANT_TRUE;
+    return c;
+}
+constant_t* constant_new_false()
+{
+    NEW(constant_t,c);
+    c->type = CONSTANT_FALSE;
+    return c;
+}
+constant_t* constant_new_null()
+{
+    NEW(constant_t,c);
+    c->type = CONSTANT_NULL;
+    return c;
+}
+constant_t* constant_new_undefined()
+{
+    NEW(constant_t,c);
+    c->type = CONSTANT_UNDEFINED;
+    return c;
+}
+constant_t* constant_clone(constant_t*other)
+{
+    if(!other) return 0;
+    constant_t*c = malloc(sizeof(constant_t));
+    memcpy(c, other, sizeof(constant_t));
+    if(NS_TYPE(c->type)) {
+        c->ns = namespace_clone(other->ns);
+    } else if(c->type == CONSTANT_STRING) {
+        c->s = string_dup3(other->s);
+    }
+    return c;
+}
+constant_t* constant_fromindex(pool_t*pool, int index, int type)
+{
+    if(!index) {
+        /* even for nonvalued constants (like TRUE/FALSE etc.), a nonzero
+           index is present to indicate that a type is coming */
+        return 0;
+    } 
+    NEW(constant_t,c);
+    c->type = type;
+    if(NS_TYPE(c->type)) {
+        c->ns = namespace_clone(pool_lookup_namespace(pool, index));
+    } else if(c->type == CONSTANT_INT) {
+        c->i = pool_lookup_int(pool, index);
+    } else if(c->type == CONSTANT_UINT) {
+        c->u = pool_lookup_uint(pool, index);
+    } else if(c->type == CONSTANT_FLOAT) {
+        c->f = pool_lookup_float(pool, index);
+    } else if(c->type == CONSTANT_STRING) {
+        string_t s = pool_lookup_string2(pool, index);
+        c->s = string_dup3(&s);
+    } else if(UNIQUE_CONSTANT(c->type)) {
+        // ok
+    } else {
+        fprintf(stderr, "invalid constant type %02x\n", c->type);
+    }
+    return c;
+}
+char* constant_tostring(constant_t*c)
+{
+    if(!c)
+        return strdup("NULL");
+    char buf[32];
+    if(NS_TYPE(c->type)) {
+        return namespace_tostring(c->ns);
+    } else if(c->type == CONSTANT_INT) {
+        sprintf(buf, "%d", c->i);
+        return strdup(buf);
+    } else if(c->type == CONSTANT_UINT) {
+        sprintf(buf, "%u", c->u);
+        return strdup(buf);
+    } else if(c->type == CONSTANT_FLOAT) {
+        char buf[1024];
+        sprintf(buf, "%f", c->f);
+        return strdup(buf);
+    } else if(c->type == CONSTANT_STRING) {
+        /* should we escape the string? \0 bytes won't be printed */
+        return strdup_n(c->s->str,c->s->len);
+    } else if(c->type == CONSTANT_TRUE) {
+        return strdup("true");
+    } else if(c->type == CONSTANT_FALSE) {
+        return strdup("false");
+    } else if(c->type == CONSTANT_NULL) {
+        return strdup("null");
+    } else if(c->type == CONSTANT_UNDEFINED) {
+        return strdup("undefined");
+    } else {
+        fprintf(stderr, "invalid constant type %02x\n", c->type);
+        return 0;
+    }
+}
+char constant_has_index(constant_t*c) 
+{
+    if(!c)
+        return 0;
+    return !UNIQUE_CONSTANT(c->type);
+}
+int constant_get_index(pool_t*pool, constant_t*c)
+{
+    if(!c)
+        return 0;
+    if(NS_TYPE(c->type)) {
+        assert(c->ns);
+        /*if(c->type!=c->ns->access) {
+            printf("%02x<->%02x\n", c->type, c->ns->access);
+        }*/
+        assert(c->type == c->ns->access);
+        return pool_register_namespace(pool, c->ns);
+    } else if(c->type == CONSTANT_INT) {
+        return pool_register_int(pool, c->i);
+    } else if(c->type == CONSTANT_UINT) {
+        return pool_register_uint(pool, c->u);
+    } else if(c->type == CONSTANT_FLOAT) {
+        return pool_register_float(pool, c->f);
+    } else if(c->type == CONSTANT_STRING) {
+        return pool_register_string2(pool, c->s);
+    } else if(c->type == CONSTANT_UNDEFINED) {
+        /* write undefined with index 0 (and no type). Otherwise, the FlashPlayer 
+           seems to throw an "attempt to read out of bounds" exception */
+        return 0;
+    } else if(!constant_has_index(c)) {
+        return 1;
+    } else {
+        fprintf(stderr, "invalid constant type %02x\n", c->type);
+        return 0;
+    }
+}
+void constant_free(constant_t*c)
+{
+    if(!c)
+        return;
+    if(c->type == CONSTANT_STRING) {
+        string_free(c->s);
+    } else if (NS_TYPE(c->type)) {
+        namespace_destroy(c->ns);c->ns=0;
+    }
+    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;
 }
-int pool_register_string(pool_t*pool, const char*s)
+int pool_register_string(pool_t*pool, const char*str)
 {
-    if(!s) return 0;
-    int pos = array_append_if_new(pool->x_strings, s, 0);
+    if(!str) return 0;
+    string_t s = string_new2(str);
+    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_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);
-    assert(pos!=0);
+    int pos = array_append_or_increase(pool->x_namespaces, ns);
+    assert(pos!=0 || ns->access==ZERONAMESPACE);
     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);
-    if(pos==0) {
-        *(int*)0=0xdead;
-    }
+    int pos = array_append_or_increase(pool->x_multinames, n);
     assert(pos!=0);
     return pos;
 }
@@ -672,7 +924,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;
@@ -701,7 +953,7 @@ int pool_find_float(pool_t*pool, double x)
 {
     int i = array_find(pool->x_ints, &x);
     if(i<=0) {
-        fprintf(stderr, "Couldn't find int \"%d\" in constant pool\n", x);
+        fprintf(stderr, "Couldn't find int \"%f\" in constant pool\n", x);
         return 0;
     }
     return i;
@@ -711,9 +963,9 @@ int pool_find_namespace(pool_t*pool, namespace_t*ns)
     if(!ns)
         return 0;
     int i = array_find(pool->x_namespaces, ns);
-    if(i<=0) {
-        char*s = namespace_to_string(ns);
-        fprintf(stderr, "Couldn't find namespace \"%s\" %08x in constant pool\n", s, ns);
+    if(i<0) {
+        char*s = namespace_tostring(ns);
+        fprintf(stderr, "Couldn't find namespace \"%s\" %08x in constant pool\n", s, (int)ns);
         free(s);
         return 0;
     }
@@ -725,20 +977,21 @@ int pool_find_namespace_set(pool_t*pool, namespace_set_t*set)
         return 0;
     int i = array_find(pool->x_namespace_sets, set);
     if(i<=0) {
-        char*s = namespace_set_to_string(set);
+        char*s = namespace_set_tostring(set);
         fprintf(stderr, "Couldn't find namespace_set \"%s\" in constant pool\n", s);
         free(s);
         return 0;
     }
     return i;
 }
-int pool_find_string(pool_t*pool, const char*s)
+int pool_find_string(pool_t*pool, const char*str)
 {
-    if(!s)
+    if(!str)
         return 0;
-    int i = array_find(pool->x_strings, s);
+    string_t s = string_new2(str);
+    int i = array_find(pool->x_strings, &s);
     if(i<=0) {
-        fprintf(stderr, "Couldn't find string \"%s\" in constant pool\n", s);
+        fprintf(stderr, "Couldn't find string \"%s\" in constant pool\n", str);
         return 0;
     }
     return i;
@@ -749,7 +1002,7 @@ int pool_find_multiname(pool_t*pool, multiname_t*name)
         return 0;
     int i = array_find(pool->x_multinames, name);
     if(i<=0) {
-        char*s = multiname_to_string(name);
+        char*s = multiname_tostring(name);
         fprintf(stderr, "Couldn't find multiname \"%s\" in constant pool\n", s);
         free(s);
         return 0;
@@ -772,9 +1025,16 @@ double pool_lookup_float(pool_t*pool, int i)
     if(!i) return __builtin_nan("");
     return *(double*)array_getkey(pool->x_floats, i);
 }
-char*pool_lookup_string(pool_t*pool, int i)
+const char*pool_lookup_string(pool_t*pool, int i)
 {
-    return (char*)array_getkey(pool->x_strings, i);
+    string_t*s = array_getkey(pool->x_strings, i);
+    if(!s) return 0;
+    return s->str;
+}
+string_t pool_lookup_string2(pool_t*pool, int i)
+{
+    string_t*s = array_getkey(pool->x_strings, i);
+    return *s;
 }
 namespace_t*pool_lookup_namespace(pool_t*pool, int i)
 {
@@ -789,6 +1049,7 @@ multiname_t*pool_lookup_multiname(pool_t*pool, int i)
     return (multiname_t*)array_getkey(pool->x_multinames, i);
 }
 
+static namespace_t zeronamespace={ZERONAMESPACE,"*"};
 pool_t*pool_new()
 {
     NEW(pool_t, p);
@@ -796,7 +1057,7 @@ pool_t*pool_new()
     p->x_ints = array_new2(&uint_type);
     p->x_uints = array_new2(&uint_type);
     p->x_floats = array_new2(&float_type);
-    p->x_strings = array_new2(&charptr_type);
+    p->x_strings = array_new2(&stringstruct_type);
     p->x_namespaces = array_new2(&namespace_type);
     p->x_namespace_sets = array_new2(&namespace_set_type);
     p->x_multinames = array_new2(&multiname_type);
@@ -807,12 +1068,23 @@ pool_t*pool_new()
     array_append(p->x_uints, 0, 0);
     array_append(p->x_floats, 0, 0);
     array_append(p->x_strings, 0, 0);
-    array_append(p->x_namespaces, 0, 0);
+    array_append(p->x_namespaces, &zeronamespace, 0);
     array_append(p->x_namespace_sets, 0, 0);
     array_append(p->x_multinames, 0, 0);
     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
 
@@ -822,7 +1094,7 @@ void pool_read(pool_t*pool, TAG*tag)
     DEBUG printf("%d ints\n", num_ints);
     int t;
     for(t=1;t<num_ints;t++) {
-        S32 v = swf_GetS30(tag);
+        S32 v = swf_GetABCS32(tag);
         DEBUG printf("int %d) %d\n", t, v);
         array_append(pool->x_ints, &v, 0);
     }
@@ -830,7 +1102,7 @@ void pool_read(pool_t*pool, TAG*tag)
     int num_uints = swf_GetU30(tag);
     DEBUG printf("%d uints\n", num_uints);
     for(t=1;t<num_uints;t++) {
-        U32 v = swf_GetU30(tag);
+        U32 v = swf_GetABCU32(tag);
         DEBUG printf("uint %d) %d\n", t, v);
         array_append(pool->x_uints, &v, 0);
     }
@@ -847,24 +1119,22 @@ void pool_read(pool_t*pool, TAG*tag)
     DEBUG printf("%d strings\n", num_strings);
     for(t=1;t<num_strings;t++) {
 	int len = swf_GetU30(tag);
-	char*s = malloc(len+1);
-	swf_GetBlock(tag, s, len);
-	s[len] = 0;
-	array_append(pool->x_strings, s, 0);
-        free(s);
-	DEBUG printf("%d) \"%s\"\n", t, pool->x_strings->d[t].name);
+        string_t s = string_new((char*)&tag->data[tag->pos], len);
+	swf_GetBlock(tag, 0, len);
+	array_append(pool->x_strings, &s, 0);
+	DEBUG printf("%d) \"%s\"\n", t, ((string_t*)array_getkey(pool->x_strings, t))->str);
     }
     int num_namespaces = swf_GetU30(tag);
     DEBUG printf("%d namespaces\n", num_namespaces);
     for(t=1;t<num_namespaces;t++) {
 	U8 type = swf_GetU8(tag);
 	int namenr = swf_GetU30(tag);
-	const char*name = ""; 
-        if(namenr) //spec page 22: "a value of zero denotes an empty string"
-            name = array_getkey(pool->x_strings, namenr);
+	const char*name = 0; 
+        if(namenr)
+            name = pool_lookup_string(pool, namenr);
         namespace_t*ns = namespace_new(type, name);
 	array_append(pool->x_namespaces, ns, 0);
-	DEBUG printf("%d) %02x \"%s\"\n", t, type, namespace_to_string(ns));
+	DEBUG printf("%d) %02x \"%s\"\n", t, type, namespace_tostring(ns));
         namespace_destroy(ns);
     }
     int num_sets = swf_GetU30(tag);
@@ -882,7 +1152,7 @@ void pool_read(pool_t*pool, TAG*tag)
             list_append(nsset->namespaces, namespace_clone(ns));
         }
         array_append(pool->x_namespace_sets, nsset, 0);
-        DEBUG printf("set %d) %s\n", t, namespace_set_to_string(nsset));
+        DEBUG printf("set %d) %s\n", t, namespace_set_tostring(nsset));
         namespace_set_destroy(nsset);
     }
 
@@ -891,39 +1161,104 @@ 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);
             m.ns = (namespace_t*)array_getkey(pool->x_namespaces, namespace_index);
+	    if(!m.ns) {
+		fprintf(stderr, "Error: Illegal reference to namespace #%d in constant pool.\n", namespace_index);
+	    }
             int name_index = swf_GetU30(tag);
             if(name_index) // 0 = '*' (any)
-	        m.name = array_getkey(pool->x_strings, name_index);
+	        m.name = pool_lookup_string(pool, name_index);
 	} else if(m.type==0x0f || m.type==0x10) {
             int name_index = swf_GetU30(tag);
             if(name_index) // 0 = '*' (any name)
-	        m.name = array_getkey(pool->x_strings, name_index);
+	        m.name = pool_lookup_string(pool, name_index);
 	} else if(m.type==0x11 || m.type==0x12) {
 	} else if(m.type==0x09 || m.type==0x0e) {
             int name_index = swf_GetU30(tag);
             int namespace_set_index = swf_GetU30(tag);
             if(name_index)
-	        m.name = array_getkey(pool->x_strings, name_index);
+	        m.name = pool_lookup_string(pool, name_index);
 	    m.namespace_set = (namespace_set_t*)array_getkey(pool->x_namespace_sets, namespace_set_index);
         } 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); //multiname
+            int v2 = swf_GetU30(tag); //counter?
+            int v3 = swf_GetU30(tag); //multiname
+            // e.g. Vector<int> ... we only store the parent object
+            m = *(multiname_t*)array_getkey(pool->x_multinames, v1);
 	} else {
 	    printf("can't parse type %d multinames yet\n", m.type);
 	}
-        DEBUG printf("multiname %d) %s\n", t, multiname_to_string(&m));
+        DEBUG printf("multiname %d) %s\n", t, multiname_tostring(&m));
 	array_append(pool->x_multinames, &m, 0);
     }
-    printf("%d ints\n", num_ints);
-    printf("%d uints\n", num_uints);
-    printf("%d strings\n", num_strings);
-    printf("%d namespaces\n", num_namespaces);
-    printf("%d namespace sets\n", num_sets);
-    printf("%d multinames\n", num_multinames);
+} 
+
+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);
+        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);
+    for(t=1;t<pool->x_uints->num;t++) {
+        U32 val = *(unsigned int*)array_getkey(pool->x_uints, t);
+        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);
+    for(t=1;t<pool->x_floats->num;t++) {
+        double d = pool_lookup_float(pool, t);
+        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);
+    for(t=1;t<pool->x_strings->num;t++) {
+        string_t str = pool_lookup_string2(pool, 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");
+    }
+    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);
+        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);
+    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);
+        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);
+    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);
+        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);
+    }
 } 
 
 void pool_write(pool_t*pool, TAG*tag)
@@ -955,28 +1290,36 @@ void pool_write(pool_t*pool, TAG*tag)
     }
     for(t=1;t<pool->x_namespaces->num;t++) {
 	namespace_t*ns= (namespace_t*)array_getkey(pool->x_namespaces, t);
-        if(ns->name && ns->name[0])
-            array_append_if_new(pool->x_strings, ns->name, 0);
+        /*  The spec says (page 22): "a value of zero denotes an empty string".
+            However when actually using zero strings as empty namespaces, the
+            flash player breaks.*/
+        //if(ns->name && ns->name[0])
+        pool_register_string(pool, ns->name);
     }
 
+    //pool_register_int(pool, 15);
+    //pool_register_int(pool, 1);
+    //pool_register_int(pool, 0);
+    
     /* write data */
     swf_SetU30(tag, pool->x_ints->num>1?pool->x_ints->num:0);
     for(t=1;t<pool->x_ints->num;t++) {
         S32 val = *(int*)array_getkey(pool->x_ints, t);
-        swf_SetS30(tag, val);
+        swf_SetABCS32(tag, val);
     }
     swf_SetU30(tag, pool->x_uints->num>1?pool->x_uints->num:0);
     for(t=1;t<pool->x_uints->num;t++) {
-        swf_SetU30(tag, *(unsigned int*)array_getkey(pool->x_uints, t));
+        swf_SetABCU32(tag, *(unsigned int*)array_getkey(pool->x_uints, t));
     }
     swf_SetU30(tag, pool->x_floats->num>1?pool->x_floats->num:0);
     for(t=1;t<pool->x_floats->num;t++) {
-        array_getvalue(pool->x_floats, t);
-        swf_SetD64(tag, 0.0); // fixme
+        double d = pool_lookup_float(pool, t);
+        swf_SetD64(tag, d);
     }
     swf_SetU30(tag, pool->x_strings->num>1?pool->x_strings->num:0);
     for(t=1;t<pool->x_strings->num;t++) {
-	swf_SetU30String(tag, array_getkey(pool->x_strings, t));
+        string_t str = pool_lookup_string2(pool, t);
+	swf_SetU30String(tag, str.str, str.len);
     }
     swf_SetU30(tag, pool->x_namespaces->num>1?pool->x_namespaces->num:0);
     for(t=1;t<pool->x_namespaces->num;t++) {
@@ -984,8 +1327,10 @@ void pool_write(pool_t*pool, TAG*tag)
 	swf_SetU8(tag, ns->access);
 	const char*name = ns->name;
 	int i = 0;
-        if(name && name[0])
-            i = pool_find_string(pool, name);
+        
+        //if(name && name[0])
+        i = pool_find_string(pool, name);
+
 	swf_SetU30(tag, i);
     }
     swf_SetU30(tag, pool->x_namespace_sets->num>1?pool->x_namespace_sets->num:0);
@@ -1014,13 +1359,17 @@ void pool_write(pool_t*pool, TAG*tag)
         } else {
             assert(m->type!=0x07 && m->type!=0x0d);
         }
+	
         if(m->name) {
             assert(m->type==0x09 || m->type==0x0e || m->type==0x07 || m->type==0x0d || m->type==0x0f || m->type==0x10);
 	    int i = pool_find_string(pool, m->name);
             if(i<0) fprintf(stderr, "internal error: unregistered name\n");
 	    swf_SetU30(tag, i);
         } else {
-            assert(m->type!=0x09 && m->type!=0x0e && m->type!=0x07 && m->type!=0x0d && m->type!=0x0f && m->type!=0x10);
+	    if(m->type == 0x09) {
+		swf_SetU30(tag, 0);
+	    }
+            assert(m->type!=0x0e && m->type!=0x07 && m->type!=0x0d && m->type!=0x0f && m->type!=0x10);
         }
         if(m->namespace_set) {
             assert(m->type==0x09 || m->type==0x0e || m->type==0x1c || m->type==0x1b);