X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fmodules%2Fswfabc.c;h=3fe48f481b003b518629d022a7fffa57b6fe8e14;hb=8361cd1de3449cf6bb9c357853c9637bf50e9ce2;hp=582174c6e08e2eedebb8c478483f1f2f52cf3cbe;hpb=b89b5adf6eb597170044ff49d3cd8b414ddc34d9;p=swftools.git

diff --git a/lib/modules/swfabc.c b/lib/modules/swfabc.c
index 582174c..3fe48f4 100644
--- a/lib/modules/swfabc.c
+++ b/lib/modules/swfabc.c
@@ -22,106 +22,11 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #include <stdarg.h>
+#include <assert.h>
 #include "../rfxswf.h"
+#include "swfabc.h"
 
-typedef struct _abc_method {
-    /* from method signature: */
-    const char*name;
-    char*paramstr;
-    int return_type_index;//index into multiname
-    int param_count;
-    int params[16]; // indexes into multiname
-    U8 flags;
-
-    int index;
-    int method_body_index;
-} abc_method_t;
-
-typedef struct _abc_multiname {
-    int namespace_index;
-    int name_index;
-} abc_multiname_t;
-
-typedef struct _dict_entry {
-    const char*name;
-    void*data;
-} dict_entry_t;
-
-typedef struct _dict {
-    int num;
-    int size;
-    dict_entry_t*d;
-} dict_t;
-
-typedef struct _abc_file_t {
-
-    // contant_pool
-
-    dict_t*ints;
-    dict_t*uints;
-    dict_t*floats;
-    dict_t*strings;
-    dict_t*namespaces;
-    dict_t*namespace_sets;
-    dict_t*sets;
-    dict_t*multinames;
-
-    // abc_file
-
-    dict_t*methods;
-    dict_t*classes;
-    dict_t*scripts;
-    dict_t*method_bodies;
-} abc_file_t;
-
-typedef struct _abc_trait {
-    unsigned char type;
-    int name_index;
-
-    union {
-        int disp_id;
-        int slot_id;
-        int data1;
-    };
-    union {
-        int nr;
-        int cls;
-        int type_index;
-        int data2;
-    };
-    int vindex;
-    int vkind;
-} abc_trait_t;
-
-typedef struct _abc_class {
-    int index;
-    abc_file_t*abc;
-    const char*name;
-    int classname_index;
-    int superclass_index;
-    int ns_index;
-    int iinit;
-    
-    int static_constructor_index;
-    dict_t*static_constructor_traits;
-
-    dict_t*traits;
-} abc_class_t;
-
-typedef struct _abc_code {
-    int index;
-    abc_file_t*abc;
-    //abc_class_t*cls;
-    abc_method_t*method;
-    TAG*tag;
-    int max_stack;
-    int local_count;
-    int init_scope_depth;
-    int max_scope_depth;
-    int exception_count;
-    dict_t*traits;
-} abc_code_t;
-
+char stringbuffer[2048];
 
 dict_t* dict_new() {
     dict_t*d = malloc(sizeof(dict_t));
@@ -177,7 +82,18 @@ int dict_find(dict_t*dict, const char*name)
     }
     return -1;
 }
-int dict_update(dict_t*dict, char*name, void*data) {
+int dict_find2(dict_t*dict, const char*name, void*data)
+{
+    if(!name)
+	name = "";
+    int t;
+    for(t=0;t<dict->num;t++) {
+	if(dict->d[t].name && !strcmp(dict->d[t].name,name) && dict->d[t].data == data)
+	    return t;
+    }
+    return -1;
+}
+int dict_update(dict_t*dict, const char*name, void*data) {
     int pos = dict_find(dict, name);
     if(pos>=0) {
 	dict->d[pos].data = data;
@@ -185,12 +101,50 @@ int dict_update(dict_t*dict, char*name, void*data) {
     }
     return dict_append(dict, name, data);
 }
-int dict_append_if_new(dict_t*dict, char*name, void*data) {
+int dict_append_if_new(dict_t*dict, const char*name, void*data) {
     int pos = dict_find(dict, name);
     if(pos>=0)
 	return pos;
     return dict_append(dict, name, data);
 }
+int dict_append_if_new2(dict_t*dict, const char*name, void*data) {
+    int pos = dict_find2(dict, name, data);
+    if(pos>=0)
+	return pos;
+    return dict_append(dict, name, data);
+}
+
+typedef struct _commonlist {
+    void*entry;
+    struct _commonlist*next;
+    struct _commonlist*last[0];
+} commonlist_t;
+
+int list_length(void*_list)
+{
+    commonlist_t*l = (commonlist_t*)_list;
+    int n=0;
+    while(l) {
+        l = l->next;
+        n++;
+    }
+    return n;
+}
+void list_append(void*_list, void*entry)
+{
+    commonlist_t**list = (commonlist_t**)_list;
+    commonlist_t* n = 0;
+    if(!*list) {
+        n = malloc(sizeof(commonlist_t)+sizeof(commonlist_t*));
+        *list = n;
+    } else {
+        n = malloc(sizeof(commonlist_t));
+        (*list)->last[0]->next = n;
+    }
+    n->next = 0;
+    n->entry = entry;
+    (*list)->last[0] = n;
+}
 
 int swf_GetU30(TAG*tag)
 {
@@ -251,13 +205,13 @@ typedef struct _opcode
    S = switch
 */
 
-int abc_RegisterNameSpace(abc_file_t*file, char*name);
-int abc_RegisterPackageNameSpace(abc_file_t*file, char*name);
-int abc_RegisterPackageInternalNameSpace(abc_file_t*file, char*name);
-int abc_RegisterProtectedNameSpace(abc_file_t*file, char*name);
-int abc_RegisterExplicitNameSpace(abc_file_t*file, char*name);
-int abc_RegisterStaticProtectedNameSpace(abc_file_t*file, char*name);
-int abc_RegisterPrivateNameSpace(abc_file_t*file, char*name);
+int abc_RegisterNameSpace(abc_file_t*file, const char*name);
+int abc_RegisterPackageNameSpace(abc_file_t*file, const char*name);
+int abc_RegisterPackageInternalNameSpace(abc_file_t*file, const char*name);
+int abc_RegisterProtectedNameSpace(abc_file_t*file, const char*name);
+int abc_RegisterExplicitNameSpace(abc_file_t*file, const char*name);
+int abc_RegisterStaticProtectedNameSpace(abc_file_t*file, const char*name);
+int abc_RegisterPrivateNameSpace(abc_file_t*file, const char*name);
 
 
 opcode_t opcodes[]={
@@ -451,7 +405,7 @@ static int parse_code(TAG*tag, int len, abc_file_t*pool, char*prefix)
 		    } else if(*p == 'c') {
 			int n = swf_GetU30(tag);
                         abc_class_t*cls = (abc_class_t*)dict_getdata(pool->classes, n);
-			printf("[classinfo%d %s]", n, cls->name);
+			printf("[classinfo%d %s]", n, cls->classname);
 		    } else if(*p == 'i') {
 			int n = swf_GetU30(tag);
 			printf("[methodbody%d]", n);
@@ -496,6 +450,88 @@ static int parse_code(TAG*tag, int len, abc_file_t*pool, char*prefix)
     return 1;
 }
 
+static char* access2str(int type)
+{
+    if(type==0x08) return "";
+    else if(type==0x16) return "package";
+    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 return "undefined";
+}
+
+
+char* multiname_to_string(abc_multiname_t*m)
+{
+    char*mname = 0;
+    if(m->type==0x07 || m->type==0x0d) {
+        mname = malloc(strlen(m->ns->name)+strlen(m->name)+32);
+        sprintf(mname, "<%s>\0", access2str(m->ns->access));
+        strcat(mname, m->ns->name);
+        strcat(mname, "::");
+        strcat(mname, m->name);
+    } else if(m->type==0x0f || m->type==0x10) {
+        mname = strdup(m->name);
+    } else if(m->type==0x11 || m->type==0x12) {
+        mname = strdup("");
+    } else if(m->type==0x09 || m->type==0x0e) {
+        mname = malloc(strlen(m->namespace_set_name)+strlen(m->name)+16);
+        strcpy(mname, m->namespace_set_name);
+        strcat(mname, "::");
+        strcat(mname, m->name);
+    } else if(m->type==0x1b || m->type==0x1c) {
+        mname = strdup(m->namespace_set_name);
+    }
+    return mname;
+}
+
+
+static void dump_traits(const char*prefix, dict_t*traits, abc_file_t*pool);
+
+static char* params_to_string(abc_multiname_list_t*list)
+{
+    abc_multiname_list_t*l;
+    int n;
+
+    l = list;
+    n = 0;
+    while(list) {
+        n++;list=list->next;
+    }
+
+    char**names = (char**)malloc(sizeof(char*)*n);
+    
+    l = list;
+    n = 0;
+    int size = 0;
+    while(list) {
+        names[n] = multiname_to_string(list->abc_multiname);
+        size += strlen(names[n]) + 2;
+        n++;list=list->next;
+    }
+
+    char* params = malloc(size+5);
+    params[0]='(';
+    params[1]=0;
+    l = list;
+    int s=0;
+    n = 0;
+    while(list) {
+        if(s)
+            strcat(params, ", ");
+        strcat(params, names[n]);
+        free(names[n]);
+        n++;
+        s=1;
+    }
+    free(names);
+    strcat(params, ")");
+    int t;
+    return params;
+}
+
 static void dump_method(const char*prefix, const char*type, const char*name, int nr, abc_file_t*pool)
 {
     if(nr >= pool->methods->num) {
@@ -503,18 +539,27 @@ static void dump_method(const char*prefix, const char*type, const char*name, int
 	return;
     }
     abc_method_t*m = (abc_method_t*)dict_getdata(pool->methods, nr);
-    printf("%s%s %s %s%s\n", prefix, type, dict_getstr(pool->multinames,m->return_type_index), name, m->paramstr);
 
-    abc_code_t*c = (abc_code_t*)dict_getdata(pool->method_bodies, m->method_body_index);
+    const char*return_type = "";
+    if(m->return_type)
+        return_type = multiname_to_string(m->return_type);
+
+    char*paramstr = params_to_string(m->parameters);
+
+    printf("%s%s %s %s=%s %s\n", prefix, type, return_type, name, m->name, paramstr);
+
+    abc_method_body_t*c = (abc_method_body_t*)dict_getdata(pool->method_bodies, m->method_body_index);
     
     printf("%s[%d %d %d %d %d]\n", prefix, c->max_stack, c->local_count, c->init_scope_depth, c->max_scope_depth, c->exception_count);
 
     swf_SetTagPos(c->tag, 0);
     char prefix2[80];
     sprintf(prefix2, "%s    ", prefix);
+    if(c->traits)
+        dump_traits(prefix, c->traits, pool);
     printf("%s{\n", prefix);
     parse_code(c->tag, c->tag->len, pool,prefix2);
-    printf("%s}\n", prefix);
+    printf("%s}\n\n", prefix);
 }
 
 //#define DEBUG
@@ -577,6 +622,10 @@ static dict_t* traits_parse(TAG*tag, abc_file_t*pool)
 	    trait->cls = swf_GetU30(tag);
 	    DEBUG printf("  class %s %d %d\n", name, trait->slot_id, trait->cls);
 	} else if(kind == 0 || kind == 6) { // slot, const
+            /* a slot is a variable in a class that is shared amonst all instances
+               of the same type, but which has a unique location in each object 
+               (in other words, slots are non-static, traits are static)
+             */
 	    trait->slot_id = swf_GetU30(tag);
 	    const char*type_name = dict_getstr(pool->multinames, swf_GetU30(tag));
 	    trait->vindex = swf_GetU30(tag);
@@ -599,7 +648,7 @@ static dict_t* traits_parse(TAG*tag, abc_file_t*pool)
     return traits;
 }
 
-static void dump_traits(char*prefix, dict_t*traits, abc_file_t*pool)
+static void dump_traits(const char*prefix, dict_t*traits, abc_file_t*pool)
 {
     int num_traits = traits->num;
     int t;
@@ -610,7 +659,6 @@ static void dump_traits(char*prefix, dict_t*traits, abc_file_t*pool)
         U8 attributes = kind&0xf0;
         kind&=0x0f;
 	if(kind == TRAIT_METHOD) {
-	    printf("%s method %d %d %s\n", prefix, trait->nr, trait->disp_id, ((abc_method_t*)dict_getdata(pool->methods, trait->nr))->paramstr);
 	    dump_method(prefix, "method", name, trait->nr, pool);
 	} else if(kind == TRAIT_GETTER) {
 	    dump_method(prefix, "getter", name, trait->nr, pool);
@@ -623,12 +671,12 @@ static void dump_traits(char*prefix, dict_t*traits, abc_file_t*pool)
             if(!cls) {
 	        printf("%sslot %d: class %s=class%d %d\n", prefix, trait->slot_id, name, trait->cls);
             } else {
-	        printf("%sslot %d: class %s=%s\n", prefix, trait->slot_id, name, cls->name);
+	        printf("%sslot %d: class %s=%s\n", prefix, trait->slot_id, name, cls->classname);
             }
 	} else if(kind == TRAIT_SLOT || kind == TRAIT_CONST) { // slot, const
 	    int slot_id = trait->slot_id;
 	    const char*type_name = dict_getstr(pool->multinames, trait->type_index);
-	    printf("  %sslot %s %d %s (vindex=%d)\n", prefix, name, trait->slot_id, type_name, trait->vindex);
+	    printf("%sslot %s %d %s (vindex=%d)\n", prefix, name, trait->slot_id, type_name, trait->vindex);
 	} else {
 	    printf("    can't dump trait type %d\n", kind);
 	}
@@ -675,476 +723,167 @@ abc_file_t*abc_file_new()
     return f;
 }
 
-static char* access2str(int type)
-{
-    if(type==0x08) return "";
-    else if(type==0x16) return "package";
-    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 return "undefined";
-}
-
-void swf_DissassembleABC(TAG*tag)
+static abc_namespace_t* namespace_new(U8 access, const char*name)
 {
-    abc_file_t* pool = abc_file_new();
-
-    swf_SetTagPos(tag, 0);
-    U32 flags = swf_GetU32(tag);
-    int t;
-    DEBUG printf("flags=%08x\n", flags);
-    char*classname = swf_GetString(tag);
-    U32 version = swf_GetU32(tag);
-    if(version!=0x002e0010) {
-        fprintf(stderr, "Warning: unknown AVM2 version %08x\n", version);
-    }
+    abc_namespace_t*ns = malloc(sizeof(abc_namespace_t));
+    memset(ns, 0, sizeof(abc_namespace_t));
 
-    int num_ints = swf_GetU30(tag);
-    DEBUG printf("%d ints\n", num_ints);
-    for(t=1;t<num_ints;t++) {
-        S32 v = swf_GetU30(tag);
-        DEBUG printf("int %d) %d\n", t, v);
-        dict_append(pool->ints, 0, (void*)(ptroff_t)v);
-    }
-
-    int num_uints = swf_GetU30(tag);
-    DEBUG printf("%d uints\n", num_uints);
-    for(t=1;t<num_uints;t++) {
-        U32 v = swf_GetS30(tag);
-        DEBUG printf("uint %d) %d\n", t, v);
-        dict_append(pool->uints, 0, (void*)(ptroff_t)v);
-    }
-    
-    int num_floats = swf_GetU30(tag);
-    DEBUG printf("%d floats\n", num_floats);
-    for(t=1;t<num_floats;t++) {
-        double d = swf_GetD64(tag);
-        DEBUG printf("float %d) %f\n", t, d);
-        dict_append(pool->floats, 0, 0);
-    }
-    
-    int num_strings = swf_GetU30(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;
-	dict_append(pool->strings, s, 0);
-	DEBUG printf("%d) \"%s\"\n", t, pool->strings->d[t].name);
-    }
-    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 = dict_getstr(pool->strings, namenr);
-	dict_append(pool->namespaces, name, (void*)(ptroff_t)type);
-	int w = 0;
-	DEBUG w=1;
-	if(w) {
-	    if(type==0x08) printf("Namespace %s\n", name);
-	    else if(type==0x16) printf("PackageNamespace %s\n", name);
-	    else if(type==0x17) printf("PackageInternalNs %s\n", name);
-	    else if(type==0x18) printf("ProtectedNamespace %s\n", name);
-	    else if(type==0x19) printf("ExplicitNamespace %s\n", name);
-	    else if(type==0x1A) printf("StaticProtectedNs %s\n", name);
-	    else if(type==0x05) printf("PrivateNs %s\n", name);
-	    else {
-		printf("Undefined namespace type\n");
-		return;
+    if(access==0) { // autodetect access
+	char*n = strdup(name);
+	if(n[0] == '[') {
+	    char*bracket = strchr(n, ']');
+	    if(bracket) {
+		*bracket = 0;
+		char*a = n+1;
+		name += (bracket-n)+1;
+		if(!strcmp(a, "")) access=0x16;
+		else if(!strcmp(a, "package")) access=0x16;
+		else if(!strcmp(a, "packageinternal")) access=0x17;
+		else if(!strcmp(a, "protected")) access=0x18;
+		else if(!strcmp(a, "explicit")) access=0x19;
+		else if(!strcmp(a, "staticprotected")) access=0x1a;
+		else if(!strcmp(a, "private")) access=0x05;
+		else {
+		    fprintf(stderr, "Undefined access level: [%s]\n", a);
+                    return 0;
+		}
 	    }
+	} else {
+	    access = 0x16;
 	}
+	free(n);
     }
-    int num_sets = swf_GetU30(tag);
-    DEBUG printf("%d namespace sets\n", num_namespaces);
-    for(t=1;t<num_sets;t++) {
-        int count = swf_GetU30(tag);
-        int s;
-        const char**name = malloc(sizeof(const char*)*count);
-        int l = 0;
-        for(s=0;s<count;s++) {
-            int nsnr = swf_GetU30(tag);
-            name[s] = dict_getstr(pool->namespaces, nsnr);
-            l += strlen(name[s])+1;
+    ns->access = access;
+    ns->name = strdup(name);
+    return ns;
+}
+abc_namespace_t* abc_namespace(abc_file_t*file, const char*name) {
+    return namespace_new(0x08, name);
+}
+abc_namespace_t* abc_packagenamespace(abc_file_t*file, const char*name) {
+    return namespace_new(0x16 , name);
+}
+abc_namespace_t* abc_packageinternalnamespace(abc_file_t*file, const char*name) {
+    return namespace_new(0x17, name);
+}
+abc_namespace_t* abc_protectednamespace(abc_file_t*file, const char*name) {
+    return namespace_new(0x18, name);
+}
+abc_namespace_t* abc_explicitnamespace(abc_file_t*file, const char*name) {
+    return namespace_new(0x19, name);
+}
+abc_namespace_t* abc_staticprotectednamespace(abc_file_t*file, const char*name) {
+    return namespace_new(0x1a, name);
+}
+abc_namespace_t* abc_privatenamespace(abc_file_t*file, const char*name) {
+    return namespace_new(0x05, name);
+}
+
+static int multiname_index(abc_file_t*pool, const char*name2) 
+{
+    if(!name2)
+	name2 = "::";
+    int pos = dict_find(pool->multinames, name2);
+    if(pos>=0)
+	return pos;
+
+    char*n = strdup(name2);
+    char*p = strstr(n, "::");
+    char*namespace=0,*name=0;
+    if(!p) {
+        if(strchr(n, ':')) {
+            fprintf(stderr, "Error: single ':' in name\n");
         }
-        char*desc = malloc(l+16);
-        strcpy(desc, "{");
-        for(s=0;s<count;s++) {
-            strcat(desc, name[s]);
-            strcat(desc, ",");
+	namespace = "";
+	name = n;
+    } else {
+	*p = 0;
+	namespace = n;
+	name = p+2;
+        if(strchr(namespace, ':')) {
+            fprintf(stderr, "Error: single ':' in namespace\n");
+        }
+        if(strchr(name, ':')) {
+            fprintf(stderr, "Error: single ':' in qualified name\n");
         }
-        strcat(desc, "}");
-        dict_append(pool->namespace_sets, desc, 0);
-        DEBUG printf("set %d) %s\n", t, desc);
     }
 
-    int num_multinames = swf_GetU30(tag);
-    DEBUG printf("%d multinames\n", num_multinames);
-    for(t=1;t<num_multinames;t++) {
-	U8 type = swf_GetU8(tag);
-	char*mname = 0;
-	if(type==0x07 || type==0x0d) {
-	    int nr1 = swf_GetU30(tag);
-	    const char*namespace = dict_getstr(pool->namespaces, nr1);
-	    U8 access = (U8)(ptroff_t)dict_getdata(pool->namespaces, nr1);
-	    const char*methodname = dict_getstr(pool->strings, swf_GetU30(tag));
-	    DEBUG printf("multiname %d) <%s> %s:%s\n", t, access2str(access), namespace, methodname);
-	    mname = malloc(strlen(namespace)+strlen(methodname)+300);
-	    sprintf(mname, "[%s]\0", access2str(access));
-	    strcat(mname, namespace);
-	    strcat(mname, ":");
-	    strcat(mname, methodname);
-	} else if(type==0x0f || type==0x10) {
-	    const char*methodname = dict_getstr(pool->strings, swf_GetU30(tag));
-	    mname = strdup(methodname);
-	} else if(type==0x11 || type==0x12) {
-	    mname = strdup("");
-	} else if(type==0x09 || type==0x0e) {
-	    const char*methodname = dict_getstr(pool->strings, swf_GetU30(tag));
-	    const char*namespace = dict_getstr(pool->namespace_sets, swf_GetU30(tag));
-            DEBUG printf("multiname %d) %s:%s\n", t, namespace, methodname);
-	    mname = malloc(strlen(namespace)+strlen(methodname)+16);
-	    strcpy(mname, namespace);
-	    strcat(mname, ":");
-	    strcat(mname, methodname);
-        } else if(type==0x1b || type==0x1c) {
-	    const char*nsset = dict_getstr(pool->namespace_sets, swf_GetU30(tag));
-	    mname = strdup(nsset);
-	} else {
-	    printf("can't parse type %d multinames yet\n", type);
-	    return;
-	}
-	dict_append(pool->multinames, mname, 0);
-	free(mname);
-    }
-    
-    int num_methods = swf_GetU30(tag);
-    DEBUG printf("%d methods\n", num_methods);
-    for(t=0;t<num_methods;t++) {
-	abc_method_t*m = malloc(sizeof(abc_method_t));
-	memset(m, 0, sizeof(*m));
-	m->param_count = swf_GetU30(tag);
-	m->return_type_index = swf_GetU30(tag);
-	m->index = t;
-	int s;
-        int params_len = 256;
-	char* params = malloc(params_len);
-	params[0]='(';
-	params[1]=0;
-	for(s=0;s<m->param_count;s++) {
-	    int typenr = swf_GetU30(tag);
-	    if(s < sizeof(m->params)/sizeof(m->params[0]))
-		m->params[s] = typenr;
-	    const char*type = dict_getstr(pool->multinames, typenr);
-            while(strlen(type)+strlen(params)>params_len-4) {
-                params_len+=256;
-                params = realloc(params, params_len);
-            }
-	    if(s)
-		strcat(params, ", ");
-	    strcat(params, type);
-	}
-	strcat(params, ")");
-	int namenr = swf_GetU30(tag);
-	m->name = "";
-	if(namenr)
-	    m->name = dict_getstr(pool->strings, namenr);
-	m->paramstr=strdup(params);
-        free(params);params = 0;
+    abc_multiname_t*m = malloc(sizeof(abc_multiname_t));
+    memset(m, 0, sizeof(abc_multiname_t));
 
-	m->flags = swf_GetU8(tag);
-	
-        DEBUG printf("method %d) %s flags=%02x\n", t, m->paramstr, m->flags);
+    m->type = QNAME;
+    m->namespace_set_name = 0;
+    m->ns = namespace_new(0, namespace);
+    m->name = name;
+    return dict_append(pool->multinames, name2, m);
+}
+static abc_multiname_t* multiname_fromstring(abc_file_t*pool, const char*name)
+{
+    int i = multiname_index(pool, name);
+    return (abc_multiname_t*)dict_getdata(pool->multinames, i);
+}
 
-        if(m->flags&0x08) {
-            /* optional parameters */
-            int num = swf_GetU30(tag);
-            int s;
-            for(s=0;s<num;s++) {
-                int val = swf_GetU30(tag);
-                U8 kind = swf_GetU8(tag); // specifies index type for "val"
-            }
-        }
-	if(m->flags&0x80) {
-            /* debug information- not used by avm2 */
-	    for(s=0;s<m->param_count;s++) {
-	        m->name = dict_getstr(pool->strings, swf_GetU30(tag));
-            }
-	}
-	dict_append(pool->methods, m->name, m);
-    }
-            
-    parse_metadata(tag, pool);
-	
-    /* skip classes, and scripts for now, and do the real parsing later */
-    int num_classes = swf_GetU30(tag);
-    int classes_pos = tag->pos;
-    DEBUG printf("%d classes\n", num_classes);
-    for(t=0;t<num_classes;t++) {
-	abc_class_t*cls = malloc(sizeof(abc_class_t));
-	memset(cls, 0, sizeof(abc_class_t));
-	dict_append(pool->classes, 0, cls);
-	
-        DEBUG printf("class %d\n", t);
-	swf_GetU30(tag); //classname
-	swf_GetU30(tag); //supername
-	U8 flags = swf_GetU8(tag);
-	if(flags&8) 
-	    swf_GetU30(tag); //protectedNS
-	int inum = swf_GetU30(tag); //interface count
-        int s;
-        for(s=0;s<inum;s++) {
-            const char*interface = dict_getstr(pool->multinames, swf_GetU30(tag));
-            DEBUG printf("  class %d interface: %s\n", t, interface);
-        }
-	cls->iinit = swf_GetU30(tag);
-	cls->traits = traits_parse(tag, pool);
-    }
-    for(t=0;t<num_classes;t++) {
-        abc_class_t*cls = (abc_class_t*)dict_getdata(pool->classes, t);
-	cls->static_constructor_index = swf_GetU30(tag); // cinit
-	cls->static_constructor_traits = traits_parse(tag, pool);
-    }
-    int num_scripts = swf_GetU30(tag);
-    DEBUG printf("%d scripts\n", num_scripts);
-    for(t=0;t<num_scripts;t++) {
-	int init = swf_GetU30(tag);
-	dict_t*traits = traits_parse(tag, pool); //TODO: store
-    }
-
-    int num_method_bodies = swf_GetU30(tag);
-    DEBUG printf("%d method bodies\n", num_method_bodies);
-    for(t=0;t<num_method_bodies;t++) {
-	int methodnr = swf_GetU30(tag);
-	if(methodnr >= pool->methods->num) {
-	    printf("Invalid method number: %d\n", methodnr);
-	    return;
-	}
-	abc_method_t*m = (abc_method_t*)dict_getdata(pool->methods, methodnr);
-	abc_code_t*c = malloc(sizeof(abc_code_t));
-	memset(c, 0, sizeof(abc_code_t));
-	c->max_stack = swf_GetU30(tag);
-	c->local_count = swf_GetU30(tag);
-	c->init_scope_depth = swf_GetU30(tag);
-	c->max_scope_depth = swf_GetU30(tag);
-	int code_length = swf_GetU30(tag);
-	c->method = m;
-	m->method_body_index = t;
-
-	c->tag = swf_InsertTag(0,0);
-
-	swf_CopyData(c->tag, tag, code_length);
-
-	int exception_count = swf_GetU30(tag);
-        int s;
-        for(s=0;s<exception_count;s++) {
-            swf_GetU30(tag); //from
-            swf_GetU30(tag); //to
-            swf_GetU30(tag); //target
-            swf_GetU30(tag); //exc_type
-            swf_GetU30(tag); //var_name
-        }
-	c->traits = traits_parse(tag, pool);
-	if(!c->traits) {
-	    return;
-	}
-        dump_traits("<method body trait>", c->traits, pool);
-
-	DEBUG printf("method_body %d) (method %d), %d bytes of code", t, methodnr, code_length);
-	int r,l = code_length>32?32:code_length;
-	for(r=0;r<l;r++) {
-	    DEBUG printf("%02x ", c->tag->data[r]);
-	}
-	DEBUG printf("\n");
-
-	dict_append(pool->method_bodies, 0, c);
-    }
-    if(tag->len - tag->pos) {
-	printf("%d unparsed bytes remaining in ABC block\n", tag->len - tag->pos);
-	return;
-    }
-
-    swf_SetTagPos(tag, classes_pos);
-    for(t=0;t<num_classes;t++) {
-        abc_class_t*cls = (abc_class_t*)dict_getdata(pool->classes, t);
-
-	const char* classname = dict_getstr(pool->multinames, swf_GetU30(tag));
-	const char* supername = dict_getstr(pool->multinames, swf_GetU30(tag));
-	cls->name = classname;
-	U8 flags = swf_GetU8(tag);
-	const char*ns = "";
-	if(flags&8) {
-	    cls->ns_index = swf_GetU30(tag);
-	    ns = dict_getstr(pool->namespaces, cls->ns_index);
-	}
-	printf("class %s extends %s, %s, flags=%02x\n", classname, supername, ns, flags);
-	printf("{\n");
-	
-        int num_interfaces = swf_GetU30(tag); //interface count
-        int s;
-        for(s=0;s<num_interfaces;s++) {
-            swf_GetU30(tag); // multiname index TODO
-        }
-	cls->iinit = swf_GetU30(tag);
-	dump_method("    ","constructor", classname, cls->iinit, pool);
-	cls->traits = traits_parse(tag, pool);
-	if(!cls->traits) {
-	    return;
-	}
-	dump_traits("    ",cls->traits, pool);
-	
-	dump_method("    ","staticconstructor", "", cls->static_constructor_index, pool);
-        dump_traits("    ", cls->static_constructor_traits, pool);
-	
-        printf("}\n");
-    }
-    for(t=0;t<num_classes;t++) {
-        /* SKIP */
-	swf_GetU30(tag); // cindex
-	traits_parse(tag, pool); // TODO: free
-    }
-    int num_scripts2 = swf_GetU30(tag);
-    printf("\n");
-    for(t=0;t<num_scripts2;t++) {
-	int init = swf_GetU30(tag);
-	dump_method("","initmethod", "init", init, pool);
-        dict_t*traits = traits_parse(tag, pool);
-        if(!traits)
-            return;
-        dump_traits("", traits, pool);
-    }
-}
-
-static int registerNameSpace(abc_file_t*file, U8 access, char*name) {
-    if(access==0) { // autodetect access
-	char*n = strdup(name);
-	if(n[0] == '[') {
-	    char*bracket = strchr(n, ']');
-	    if(bracket) {
-		*bracket = 0;
-		char*a = n+1;
-		name += (bracket-n)+1;
-		if(!strcmp(a, "")) access=0x16;
-		else if(!strcmp(a, "package")) access=0x16;
-		else if(!strcmp(a, "packageinternal")) access=0x17;
-		else if(!strcmp(a, "protected")) access=0x18;
-		else if(!strcmp(a, "explicit")) access=0x19;
-		else if(!strcmp(a, "staticprotected")) access=0x1a;
-		else if(!strcmp(a, "private")) access=0x05;
-		else {
-		    fprintf(stderr, "Undefined access level: [%s]\n", a);
-		    return -1;
-		}
-	    }
-	} else {
-	    access = 0x16;
-	}
-	free(n);
-    }
-    int t;
-    for(t=0;t<file->namespaces->num;t++) {
-	const char*name2 = dict_getstr(file->namespaces, t);
-	U8 access2 = (U8)(ptroff_t)dict_getdata(file->namespaces, t);
-	if(access == access2 && !strcmp(name, name2)) {
-	    return t;
-	}
-    }
-    dict_update(file->strings, name, 0);
-    return dict_append(file->namespaces, name, (void*)(ptroff_t)access);
-}
-int abc_RegisterNameSpace(abc_file_t*file, char*name) {
-    return registerNameSpace(file, 0x08, name);
-}
-int abc_RegisterPackageNameSpace(abc_file_t*file, char*name) {
-    return registerNameSpace(file, 0x16 , name);
-}
-int abc_RegisterPackageInternalNameSpace(abc_file_t*file, char*name) {
-    return registerNameSpace(file, 0x17, name);
-}
-int abc_RegisterProtectedNameSpace(abc_file_t*file, char*name) {
-    return registerNameSpace(file, 0x18, name);
-}
-int abc_RegisterExplicitNameSpace(abc_file_t*file, char*name) {
-    return registerNameSpace(file, 0x19, name);
-}
-int abc_RegisterStaticProtectedNameSpace(abc_file_t*file, char*name) {
-    return registerNameSpace(file, 0x1a, name);
-}
-int abc_RegisterPrivateNameSpace(abc_file_t*file, char*name) {
-    return registerNameSpace(file, 0x05, name);
-}
-static int multiname_index(abc_file_t*abc, const char*name2) 
-{
-    if(!name2)
-	name2 = ":";
-    int pos = dict_find(abc->multinames, name2);
-    if(pos>=0)
-	return pos;
 
-    int access = 0x16;
-    char*n = strdup(name2);
-    char*p = strchr(n, ':');
-    char*namespace=0,*name=0;
-    if(!p) {
-	namespace = "";
-	name = n;
-    } else {
-	*p = 0;
-	namespace = n;
-	name = p+1;
-    }
-    abc_multiname_t*m = malloc(sizeof(abc_multiname_t));
-    m->namespace_index = registerNameSpace(abc, 0, namespace);
-    m->name_index = dict_append_if_new(abc->strings, name, 0);
-    return dict_append(abc->multinames, name2, m);
-}
+#define CLASS_SEALED 1
+#define CLASS_FINAL 2
+#define CLASS_INTERFACE 4
+#define CLASS_PROTECTED_NS 8
 
-abc_class_t* abc_NewClass(abc_file_t*abc, char*classname, char*superclass) {
+abc_class_t* abc_class_new(abc_file_t*pool, char*classname, char*superclass) {
     abc_class_t* c = malloc(sizeof(abc_class_t));
     memset(c, 0, sizeof(abc_class_t));
-    c->index = dict_append(abc->classes, 0, c);
-    c->abc = abc;
-    c->name = strdup(classname);
-    c->classname_index = multiname_index(abc, classname);
-    c->superclass_index = multiname_index(abc, superclass);
-    c->ns_index = abc_RegisterProtectedNameSpace(abc, classname);
+    c->index = dict_append(pool->classes, 0, c);
+    c->pool = pool;
+    c->classname = strdup(classname);
+    c->superclass = superclass?strdup(superclass):0;
+    c->flags = 0;
     c->iinit = -1;
     c->static_constructor_index = -1;
-
     c->traits = dict_new();
     return c;
 }
 
-abc_code_t* add_method(abc_file_t*abc, abc_class_t*cls, char*returntype, char*name, int num_params, va_list va)
+void abc_class_sealed(abc_class_t*c)
+{
+    c->flags |= CLASS_SEALED;
+}
+void abc_class_final(abc_class_t*c)
+{
+    c->flags |= CLASS_FINAL;
+}
+void abc_class_interface(abc_class_t*c)
+{
+    c->flags |= CLASS_INTERFACE;
+}
+void abc_class_protectedNS(abc_class_t*c, char*namespace)
+{
+    c->protectedNS = namespace;
+    c->flags |= CLASS_PROTECTED_NS;
+}
+
+abc_method_body_t* add_method(abc_file_t*pool, abc_class_t*cls, char*returntype, int num_params, va_list va)
 {
     /* construct code (method body) object */
-    abc_code_t* c = malloc(sizeof(abc_code_t));
-    memset(c, 0, sizeof(abc_code_t));
-    c->index = dict_append(abc->method_bodies, 0, c);
+    abc_method_body_t* c = malloc(sizeof(abc_method_body_t));
+    memset(c, 0, sizeof(abc_method_body_t));
+    c->index = dict_append(pool->method_bodies, 0, c);
     c->tag = swf_InsertTag(0,0);
-    c->abc = abc;
+    c->pool = pool;
     c->traits = dict_new();
 
     /* construct method object */
     abc_method_t* m = malloc(sizeof(abc_method_t));
     memset(m, 0, sizeof(abc_method_t));
-    m->param_count = num_params;
-    m->index = dict_append(abc->methods, 0, m);
-    if(returntype) 
-	m->return_type_index = multiname_index(abc, returntype);
-    else
-	m->return_type_index = 0;
-    if(num_params>sizeof(m->params)/sizeof(m->params[0])) {
-	fprintf(stderr, "abc: Too many parameters\n");
-	return 0;
+    m->index = dict_append(pool->methods, 0, m);
+    if(returntype && strcmp(returntype, "void")) {
+	m->return_type = multiname_fromstring(pool, returntype);
+    } else {
+	m->return_type = 0;
     }
     int t;
     for(t=0;t<num_params;t++) {
 	const char*param = va_arg(va, const char*);
-	m->params[t] = multiname_index(abc, param);
+	list_append(&m->parameters, multiname_fromstring(pool, param));
     }
 
     /* crosslink the two objects */
@@ -1154,21 +893,21 @@ abc_code_t* add_method(abc_file_t*abc, abc_class_t*cls, char*returntype, char*na
     return c;
 }
 
-abc_code_t* abc_AddConstructor(abc_class_t*cls, char*returntype, int num_params, ...) 
+abc_method_body_t* abc_class_constructor(abc_class_t*cls, char*returntype, int num_params, ...) 
 {
     va_list va;
     va_start(va, num_params);
-    abc_code_t* c = add_method(cls->abc, cls, returntype, 0, num_params, va);
+    abc_method_body_t* c = add_method(cls->pool, cls, returntype, num_params, va);
     va_end(va);
     cls->iinit = c->index;
     return c;
 }
 
-abc_code_t* abc_AddStaticConstructor(abc_class_t*cls, char*returntype, int num_params, ...) 
+abc_method_body_t* abc_class_staticconstructor(abc_class_t*cls, char*returntype, int num_params, ...) 
 {
     va_list va;
     va_start(va, num_params);
-    abc_code_t* c = add_method(cls->abc, cls, returntype, 0, num_params, va);
+    abc_method_body_t* c = add_method(cls->pool, cls, returntype, num_params, va);
     va_end(va);
     cls->static_constructor_index = c->index;
     return c;
@@ -1187,40 +926,54 @@ abc_trait_t*trait_new(int type, int name_index, int data1, int data2, int vindex
     return trait;
 }
 
-abc_code_t* abc_AddMethod(abc_class_t*cls, char*returntype, char*name, int num_params, ...) 
+abc_method_body_t* abc_class_method(abc_class_t*cls, char*returntype, char*name, int num_params, ...)
 {
-    abc_file_t*abc = cls->abc;
+    abc_file_t*pool = cls->pool;
     va_list va;
     va_start(va, num_params);
-    abc_code_t* c = add_method(cls->abc, cls, returntype, name, num_params, va);
+    abc_method_body_t* c = add_method(cls->pool, cls, returntype, num_params, va);
     va_end(va);
-    dict_append(cls->traits, 0, trait_new(TRAIT_METHOD, multiname_index(abc, name), 0, c->method->index, 0, 0));
+    dict_append(cls->traits, 0, trait_new(TRAIT_METHOD, multiname_index(pool, name), 0, c->method->index, 0, 0));
     return c;
 }
 
 void abc_AddSlot(abc_class_t*cls, char*name, int slot, char*multiname)
 {
-    abc_file_t*abc = cls->abc;
-    int i = multiname_index(abc, name);
-    dict_append(cls->traits, 0, trait_new(TRAIT_SLOT, i, slot, multiname_index(abc, multiname), 0, 0));
+    abc_file_t*pool = cls->pool;
+    int i = multiname_index(pool, name);
+    dict_append(cls->traits, 0, trait_new(TRAIT_SLOT, i, slot, multiname_index(pool, multiname), 0, 0));
 }
 
-void abc_code_addClassTrait(abc_code_t*code, char*multiname, int slotid, abc_class_t*cls)
+void abc_method_body_addClassTrait(abc_method_body_t*code, char*multiname, int slotid, abc_class_t*cls)
 {
-    abc_file_t*abc = code->abc;
-    int i = multiname_index(abc, multiname);
+    abc_file_t*pool = code->pool;
+    int i = multiname_index(pool, multiname);
     abc_trait_t*trait = trait_new(TRAIT_CLASS, i, slotid, cls->index, 0, 0);
     dict_append(code->traits, 0, trait);
 }
 
-abc_code_t* abc_AddInitScript(abc_file_t*abc, char*returntype, int num_params, ...) 
+/* notice: traits of a method (body) belonging to an init script
+   and traits of the init script are *not* the same thing */
+void abc_initscript_addClassTrait(abc_script_t*script, char*multiname, int slotid, abc_class_t*cls)
+{
+    abc_file_t*pool = script->pool;
+    int i = multiname_index(pool, multiname);
+    abc_trait_t*trait = trait_new(TRAIT_CLASS, i, slotid, cls->index, 0, 0);
+    dict_append(script->traits, 0, trait);
+}
+
+abc_script_t* abc_initscript(abc_file_t*pool, char*returntype, int num_params, ...) 
 {
     va_list va;
     va_start(va, num_params);
-    abc_code_t* c = add_method(abc, 0, returntype, 0, num_params, va);
-    dict_append(abc->scripts, 0, c);
+    abc_method_body_t* c = add_method(pool, 0, returntype, num_params, va);
+    abc_script_t* s = malloc(sizeof(abc_script_t));
+    s->method = c->method;
+    s->traits = dict_new();
+    s->pool = pool;
+    dict_append(pool->scripts, 0, s);
     va_end(va);
-    return c;
+    return s;
 }
 
 void swf_SetU30(TAG*tag, U32 u)
@@ -1237,8 +990,12 @@ void swf_SetU30String(TAG*tag, const char*str)
     swf_SetBlock(tag, (void*)str, l);
 }
 
-static void write_traits(abc_file_t*abc, TAG*tag, dict_t*traits)
+static void write_traits(abc_file_t*pool, TAG*tag, dict_t*traits)
 {
+    if(!traits) {
+        swf_SetU30(tag, 0);
+        return;
+    }
     swf_SetU30(tag, traits->num);
     int s;
 
@@ -1257,203 +1014,697 @@ static void write_traits(abc_file_t*abc, TAG*tag, dict_t*traits)
     }
 }
 
-void swf_WriteABC(TAG*tag, abc_file_t*abc)
+int register_multiname(abc_file_t*pool, abc_multiname_t*n)
 {
-    swf_SetU32(tag, 1);
-    swf_SetU8(tag, 0);
-    swf_SetU16(tag, 0x10);
-    swf_SetU16(tag, 0x2e);
-    swf_SetU30(tag, abc->ints->num>1?abc->ints->num:0);
-    // ...
-    swf_SetU30(tag, abc->uints->num>1?abc->uints->num:0);
-    // ...
-    swf_SetU30(tag, abc->floats->num>1?abc->floats->num:0);
-    // ...
-    swf_SetU30(tag, abc->strings->num>1?abc->strings->num:0);
-    int t;
-    for(t=1;t<abc->strings->num;t++) {
-	swf_SetU30String(tag, dict_getstr(abc->strings, t));
-    }
-    swf_SetU30(tag, abc->namespaces->num>1?abc->namespaces->num:0);
-    for(t=1;t<abc->namespaces->num;t++) {
-	U8 type = (U8)(ptroff_t)dict_getdata(abc->namespaces, t);
-	const char*name = dict_getstr(abc->namespaces, t);
-	int i = dict_find(abc->strings, name);
-	if(i<0) {
-	    fprintf(stderr, "Couldn't find namespace \"%s\" in constant pool\n", name);
-	    return;
-	}
-	swf_SetU8(tag, type);
-	swf_SetU30(tag, i);
-    }
-    swf_SetU30(tag, abc->sets->num>1?abc->sets->num:0);
-    // ...
-
-    swf_SetU30(tag, abc->multinames->num>1?abc->multinames->num:0);
-    // ...
-    for(t=1;t<abc->multinames->num;t++) {
-	abc_multiname_t*m = (abc_multiname_t*)dict_getdata(abc->multinames, t);
-	swf_SetU8(tag, 0x07);
-	swf_SetU30(tag, m->namespace_index);
-	swf_SetU30(tag, m->name_index);
-    }
-    
-    swf_SetU30(tag, abc->methods->num);
-    for(t=0;t<abc->methods->num;t++) {
-	abc_method_t*m = (abc_method_t*)dict_getdata(abc->methods, t);
-	swf_SetU30(tag, m->param_count);
-	swf_SetU30(tag, m->return_type_index);
-	int s;
-	for(s=0;s<m->param_count;s++) {
-	    swf_SetU30(tag, m->params[s]);
-	}
-	swf_SetU30(tag, 0); // name
-	swf_SetU8(tag, 0); //flags
-    }
-
-    swf_SetU30(tag, 0);//metadata
+    if(!n)
+        return 0;
+    /* FIXME: might create duplicates */
+    return dict_append_if_new2(pool->multinames, n->name, n);
+}
 
-    swf_SetU30(tag, abc->classes->num);
+int register_namespace(abc_file_t*pool, abc_namespace_t*ns)
+{
+    /* FIXME: might create duplicates */
+    return dict_append_if_new2(pool->namespaces, ns->name, ns);
+}
 
-    for(t=0;t<abc->classes->num;t++) {
-	abc_class_t*c = (abc_class_t*)dict_getdata(abc->classes, t);
-	swf_SetU30(tag, c->classname_index);
-	swf_SetU30(tag, c->superclass_index);
+static inline abc_multiname_t*multiname_lookup(abc_file_t*pool, int i)
+{
+    return (abc_multiname_t*)dict_getdata(pool->multinames, i);
+}
 
-	swf_SetU8(tag, 8); // flags
-	swf_SetU30(tag, c->ns_index);
+void* swf_ReadABC(TAG*tag)
+{
+    abc_file_t* pool = abc_file_new();
 
-	swf_SetU30(tag, 0); // no interfaces
-	if(c->iinit<0) {
-	    fprintf(stderr, "Error: Class %s has no constructor\n", c->name);
-	    return;
-	}
-	swf_SetU30(tag, c->iinit);
-	write_traits(abc, tag, c->traits);
+    swf_SetTagPos(tag, 0);
+    int t;
+    if(tag->id == ST_DOABC) {
+        /* the strange 72 tag from flex doesn't have abc flags */
+        U32 abcflags = swf_GetU32(tag);
+        DEBUG printf("flags=%08x\n", abcflags);
+        char*classname = swf_GetString(tag);
     }
-    for(t=0;t<abc->classes->num;t++) {
-	abc_class_t*c = (abc_class_t*)dict_getdata(abc->classes, t);
-	if(c->static_constructor_index<0) {
-	    fprintf(stderr, "Error: Class %s has no static constructor\n", c->name);
-	    return;
-	}
-	swf_SetU30(tag, c->static_constructor_index);
-        write_traits(abc, tag, c->static_constructor_traits);
+    U32 version = swf_GetU32(tag);
+    if(version!=0x002e0010) {
+        fprintf(stderr, "Warning: unknown AVM2 version %08x\n", version);
     }
 
-    swf_SetU30(tag, abc->scripts->num);
-    for(t=0;t<abc->scripts->num;t++) {
-	abc_code_t*c = (abc_code_t*)dict_getdata(abc->scripts, t);
-	swf_SetU30(tag, c->index); //!=t!
-	write_traits(abc, tag, c->traits);
+    int num_ints = swf_GetU30(tag);
+    DEBUG printf("%d ints\n", num_ints);
+    for(t=1;t<num_ints;t++) {
+        S32 v = swf_GetU30(tag);
+        DEBUG printf("int %d) %d\n", t, v);
+        dict_append(pool->ints, 0, (void*)(ptroff_t)v);
     }
 
-    swf_SetU30(tag, abc->method_bodies->num);
-    for(t=0;t<abc->method_bodies->num;t++) {
-	abc_code_t*c = (abc_code_t*)dict_getdata(abc->method_bodies, t);
-	abc_method_t*m = c->method;
-	swf_SetU30(tag, m->index);
-	swf_SetU30(tag, c->max_stack);
-	swf_SetU30(tag, c->local_count);
-	swf_SetU30(tag, c->init_scope_depth);
-	swf_SetU30(tag, c->max_scope_depth);
-	swf_SetU30(tag, c->tag->len);
-	swf_SetBlock(tag, c->tag->data, c->tag->len);
-	swf_SetU30(tag, c->exception_count);
-	swf_SetU8(tag, 0); // no traits
+    int num_uints = swf_GetU30(tag);
+    DEBUG printf("%d uints\n", num_uints);
+    for(t=1;t<num_uints;t++) {
+        U32 v = swf_GetS30(tag);
+        DEBUG printf("uint %d) %d\n", t, v);
+        dict_append(pool->uints, 0, (void*)(ptroff_t)v);
     }
-}
-
-#include "swfabc_ops.c"
-
-void swf_AddButtonLinks(TAG*tag)
-{
-    abc_file_t*abc = abc_file_new();
-    abc_code_t*c = 0;
     
-    abc_class_t*maintimeline = abc_NewClass(abc, "buttonmitlink_fla:MainTimeline", "flash.display:MovieClip");
+    int num_floats = swf_GetU30(tag);
+    DEBUG printf("%d floats\n", num_floats);
+    for(t=1;t<num_floats;t++) {
+        double d = swf_GetD64(tag);
+        DEBUG printf("float %d) %f\n", t, d);
+        dict_append(pool->floats, 0, 0);
+    }
     
-    c = abc_AddStaticConstructor(maintimeline, 0, 0);
-    c->max_stack = 1;
-    c->local_count = 1;
-    c->init_scope_depth = 9;
-    c->max_scope_depth = 10;
+    int num_strings = swf_GetU30(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;
+	dict_append(pool->strings, s, 0);
+	DEBUG printf("%d) \"%s\"\n", t, pool->strings->d[t].name);
+    }
+    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 = dict_getstr(pool->strings, namenr);
+        abc_namespace_t*ns = malloc(sizeof(abc_namespace_t));
+        memset(ns, 0, sizeof(abc_namespace_t));
+        ns->access = type;
+        ns->name = strdup(name);
+	dict_append(pool->namespaces, name, ns);
+	int w = 0;
+	DEBUG w=1;
+	if(w) {
+	    if(type==0x08) printf("Namespace %s\n", name);
+	    else if(type==0x16) printf("PackageNamespace %s\n", name);
+	    else if(type==0x17) printf("PackageInternalNs %s\n", name);
+	    else if(type==0x18) printf("ProtectedNamespace %s\n", name);
+	    else if(type==0x19) printf("ExplicitNamespace %s\n", name);
+	    else if(type==0x1A) printf("StaticProtectedNs %s\n", name);
+	    else if(type==0x05) printf("PrivateNs %s\n", name);
+	    else {
+		printf("Undefined namespace type\n");
+		return 0;
+	    }
+	}
+    }
+    int num_sets = swf_GetU30(tag);
+    DEBUG printf("%d namespace sets\n", num_sets);
+    for(t=1;t<num_sets;t++) {
+        int count = swf_GetU30(tag);
+        int s;
+        const char**name = malloc(sizeof(const char*)*count);
+        int l = 0;
+        for(s=0;s<count;s++) {
+            int nsnr = swf_GetU30(tag);
+            name[s] = dict_getstr(pool->namespaces, nsnr);
+            l += strlen(name[s])+1;
+        }
+        char*desc = malloc(l+16);
+        strcpy(desc, "{");
+        for(s=0;s<count;s++) {
+            strcat(desc, name[s]);
+            strcat(desc, ",");
+        }
+        strcat(desc, "}");
+        dict_append(pool->namespace_sets, desc, 0);
+        DEBUG printf("set %d) %s\n", t, desc);
+    }
 
-    abc_getlocal_0(c);
-    abc_pushscope(c);
-    abc_returnvoid(c);
+    int num_multinames = swf_GetU30(tag);
+    DEBUG printf("%d multinames\n", num_multinames);
+    for(t=1;t<num_multinames;t++) {
+        abc_multiname_t*m = malloc(sizeof(abc_multiname_t));
+        memset(m, 0, sizeof(abc_multiname_t));
+
+	m->type = swf_GetU8(tag);
+
+	if(m->type==0x07 || m->type==0x0d) {
+	    int nr1 = swf_GetU30(tag);
+            m->ns = (abc_namespace_t*)dict_getdata(pool->namespaces, nr1);
+            int name_index = swf_GetU30(tag);
+	    m->name = dict_getstr(pool->strings, name_index);
+	} else if(m->type==0x0f || m->type==0x10) {
+            int name_index = swf_GetU30(tag);
+	    m->name = dict_getstr(pool->strings, 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);
+	    m->name = dict_getstr(pool->strings, name_index);
+	    m->namespace_set_name = dict_getstr(pool->namespace_sets, namespace_set_index);
+        } else if(m->type==0x1b || m->type==0x1c) {
+            int namespace_set_index = swf_GetU30(tag);
+	    m->namespace_set_name = dict_getstr(pool->namespace_sets, namespace_set_index);
+	} else {
+	    printf("can't parse type %d multinames yet\n", m->type);
+	    return 0;
+	}
+	char*mname = multiname_to_string(m);
+        DEBUG printf("multiname %d) %s\n", t, mname);
+	dict_append(pool->multinames, mname, m);
+	free(mname);
+    }
     
-    c = abc_AddMethod(maintimeline, 0, "[packageinternal]buttonmitlink_fla:frame1", 0);
-    c->max_stack = 3;
+    int num_methods = swf_GetU30(tag);
+    DEBUG printf("%d methods\n", num_methods);
+    for(t=0;t<num_methods;t++) {
+	abc_method_t*m = malloc(sizeof(abc_method_t));
+	memset(m, 0, sizeof(*m));
+	int param_count = swf_GetU30(tag);
+	int return_type_index = swf_GetU30(tag);
+        m->return_type = multiname_lookup(pool, return_type_index);
+	m->index = t;
+
+	int s;
+	for(s=0;s<param_count;s++) {
+	    int type_index = swf_GetU30(tag);
+            list_append(&m->parameters, multiname_lookup(pool, type_index));
+        }
+
+	int namenr = swf_GetU30(tag);
+	m->name = "";
+	if(namenr)
+	    m->name = dict_getstr(pool->strings, namenr);
+
+	m->flags = swf_GetU8(tag);
+	
+        DEBUG printf("method %d) %s flags=%02x\n", t, params_to_string(m->parameters), m->flags);
+
+        if(m->flags&0x08) {
+            /* optional parameters */
+            int num = swf_GetU30(tag);
+            int s;
+            for(s=0;s<num;s++) {
+                int val = swf_GetU30(tag);
+                U8 kind = swf_GetU8(tag); // specifies index type for "val"
+            }
+        }
+	if(m->flags&0x80) {
+            /* debug information- not used by avm2 */
+            abc_multiname_list_t*l = m->parameters;
+            while(l) {
+	        m->name = dict_getstr(pool->strings, swf_GetU30(tag));
+                l = l->next;
+            }
+	}
+	dict_append(pool->methods, m->name, m);
+    }
+            
+    parse_metadata(tag, pool);
+	
+    /* skip classes, and scripts for now, and do the real parsing later */
+    int num_classes = swf_GetU30(tag);
+    int classes_pos = tag->pos;
+    DEBUG printf("%d classes\n", num_classes);
+    for(t=0;t<num_classes;t++) {
+	abc_class_t*cls = malloc(sizeof(abc_class_t));
+	memset(cls, 0, sizeof(abc_class_t));
+	dict_append(pool->classes, 0, cls);
+	
+        DEBUG printf("class %d\n", t);
+	swf_GetU30(tag); //classname
+	swf_GetU30(tag); //supername
+	cls->flags = swf_GetU8(tag);
+	if(cls->flags&8) 
+	    swf_GetU30(tag); //protectedNS
+        int s;
+	int inum = swf_GetU30(tag); //interface count
+        abc_multiname_list_t*list = 0;
+        for(s=0;s<inum;s++) {
+            int interface_index = swf_GetU30(tag);
+            const char*interface = dict_getstr(pool->multinames, interface_index);
+            abc_multiname_t* m = (abc_multiname_t*)dict_getdata(pool->multinames, interface_index);
+            list_append(&list, m);
+            DEBUG printf("  class %d interface: %s\n", t, interface);
+        }
+
+	cls->iinit = swf_GetU30(tag);
+	cls->traits = traits_parse(tag, pool);
+    }
+    for(t=0;t<num_classes;t++) {
+        abc_class_t*cls = (abc_class_t*)dict_getdata(pool->classes, t);
+	cls->static_constructor_index = swf_GetU30(tag); // cinit
+	cls->static_constructor_traits = traits_parse(tag, pool);
+    }
+    int num_scripts = swf_GetU30(tag);
+    DEBUG printf("%d scripts\n", num_scripts);
+    for(t=0;t<num_scripts;t++) {
+	int init = swf_GetU30(tag);
+	dict_t*traits = traits_parse(tag, pool); //TODO: store
+    }
+
+    int num_method_bodies = swf_GetU30(tag);
+    DEBUG printf("%d method bodies\n", num_method_bodies);
+    for(t=0;t<num_method_bodies;t++) {
+	int methodnr = swf_GetU30(tag);
+	if(methodnr >= pool->methods->num) {
+	    printf("Invalid method number: %d\n", methodnr);
+	    return 0;
+	}
+	abc_method_t*m = (abc_method_t*)dict_getdata(pool->methods, methodnr);
+	abc_method_body_t*c = malloc(sizeof(abc_method_body_t));
+	memset(c, 0, sizeof(abc_method_body_t));
+	c->max_stack = swf_GetU30(tag);
+	c->local_count = swf_GetU30(tag);
+	c->init_scope_depth = swf_GetU30(tag);
+	c->max_scope_depth = swf_GetU30(tag);
+	int code_length = swf_GetU30(tag);
+	c->method = m;
+	m->method_body_index = t;
+
+	c->tag = swf_InsertTag(0,0);
+
+	swf_CopyData(c->tag, tag, code_length);
+
+	int exception_count = swf_GetU30(tag);
+        int s;
+        for(s=0;s<exception_count;s++) {
+            swf_GetU30(tag); //from
+            swf_GetU30(tag); //to
+            swf_GetU30(tag); //target
+            swf_GetU30(tag); //exc_type
+            swf_GetU30(tag); //var_name
+        }
+	c->traits = traits_parse(tag, pool);
+	if(!c->traits) {
+	    fprintf(stderr, "Can't parse code traits\n");
+	    return 0;
+	}
+	DEBUG printf("method_body %d) (method %d), %d bytes of code", t, methodnr, code_length);
+	int r,l = code_length>32?32:code_length;
+	for(r=0;r<l;r++) {
+	    DEBUG printf("%02x ", c->tag->data[r]);
+	}
+	DEBUG printf("\n");
+
+	dict_append(pool->method_bodies, 0, c);
+    }
+    if(tag->len - tag->pos) {
+	fprintf(stderr, "%d unparsed bytes remaining in ABC block\n", tag->len - tag->pos);
+	return 0;
+    }
+
+    swf_SetTagPos(tag, classes_pos);
+    for(t=0;t<num_classes;t++) {
+        abc_class_t*cls = (abc_class_t*)dict_getdata(pool->classes, t);
+
+        int classname_index = swf_GetU30(tag);
+        int superclass_index = swf_GetU30(tag);
+	cls->classname = dict_getstr(pool->multinames, classname_index);
+	cls->superclass = dict_getstr(pool->multinames, superclass_index);
+	cls->flags = swf_GetU8(tag);
+	const char*ns = "";
+	if(cls->flags&8) {
+            int ns_index = swf_GetU30(tag);
+	    cls->protectedNS = dict_getstr(pool->namespaces, ns_index);
+	}
+        
+        if(cls->flags&1) printf("sealed ");
+        if(cls->flags&2) printf("final ");
+        if(cls->flags&4) printf("interface ");
+        if(cls->flags&8) {
+            printf("protectedNS<%s> ", cls->protectedNS);
+        }
+
+	printf("class %s", cls->classname);
+        if(cls->superclass && cls->superclass[0]) {
+            printf(" extends %s", cls->superclass);
+            abc_multiname_list_t*ilist = cls->interfaces;
+            if(ilist)
+                printf(" implements");
+            while(ilist) {
+                char*s = multiname_to_string(ilist->abc_multiname);
+                printf(" %d", s);
+                free(s);
+                ilist = ilist->next;
+            }
+            ilist->next;
+            
+        }
+        if(cls->flags&0xf0) 
+            printf("extra flags=%02x\n", cls->flags&0xf0);
+	printf("{\n");
+	
+        dump_method("    ","staticconstructor", "", cls->static_constructor_index, pool);
+        dump_traits("    ", cls->static_constructor_traits, pool);
+	
+        int num_interfaces = swf_GetU30(tag); //interface count
+        int s;
+        for(s=0;s<num_interfaces;s++) {
+            swf_GetU30(tag); // multiname index TODO
+        }
+	cls->iinit = swf_GetU30(tag);
+	dump_method("    ","constructor", cls->classname, cls->iinit, pool);
+	cls->traits = traits_parse(tag, pool);
+	if(!cls->traits) {
+	    fprintf(stderr, "Can't parse class traits\n");
+	    return 0;
+	}
+	dump_traits("    ",cls->traits, pool);
+	
+        printf("}\n");
+    }
+    for(t=0;t<num_classes;t++) {
+        /* SKIP */
+	swf_GetU30(tag); // cindex
+	traits_parse(tag, pool); // TODO: free
+    }
+    int num_scripts2 = swf_GetU30(tag);
+    printf("\n");
+    for(t=0;t<num_scripts2;t++) {
+	int init = swf_GetU30(tag);
+        abc_method_t*m = (abc_method_t*)dict_getdata(pool->methods, init);
+        
+        abc_script_t*s = malloc(sizeof(abc_script_t));
+        memset(s, 0, sizeof(abc_script_t));
+        s->method = m;
+        s->traits = traits_parse(tag, pool);
+        dict_append(pool->scripts, 0, s);
+        if(!s->traits) {
+	    fprintf(stderr, "Can't parse script traits\n");
+            return 0;
+        }
+        dump_method("","initmethod", "init", init, pool);
+        dump_traits("", s->traits, pool);
+    }
+    return pool;
+}
+
+void swf_WriteABC(TAG*abctag, void*code)
+{
+    abc_file_t*pool = (abc_file_t*)code;
+
+    TAG*tmp = swf_InsertTag(0,0);
+    TAG*tag = tmp;
+    int t;
+
+    swf_SetU30(tag, pool->methods->num);
+    for(t=0;t<pool->methods->num;t++) {
+	abc_method_t*m = (abc_method_t*)dict_getdata(pool->methods, t);
+        int n = 0;
+        abc_multiname_list_t*l = m->parameters;
+	swf_SetU30(tag, list_length(m->parameters));
+	swf_SetU30(tag, register_multiname(pool, m->return_type));
+	int s;
+        while(l) {
+	    swf_SetU30(tag, register_multiname(pool, l->abc_multiname));
+            l = l->next;
+	}
+	swf_SetU30(tag, 0); // name
+	swf_SetU8(tag, 0); //flags
+    }
+    
+    swf_SetU30(tag, 0);//metadata
+
+    swf_SetU30(tag, pool->classes->num);
+
+    for(t=0;t<pool->classes->num;t++) {
+	abc_class_t*c = (abc_class_t*)dict_getdata(pool->classes, t);
+   
+        int classname_index = multiname_index(pool, c->classname);
+        int superclass_index = multiname_index(pool, c->superclass);
+
+	swf_SetU30(tag, classname_index);
+	swf_SetU30(tag, superclass_index);
+
+	swf_SetU8(tag, c->flags); // flags
+        if(c->flags&0x08) {
+            abc_namespace_t*ns = abc_protectednamespace(pool, c->protectedNS);
+            int ns_index = register_namespace(pool, ns);
+	    swf_SetU30(tag, ns_index);
+        }
+
+	swf_SetU30(tag, 0); // no interfaces
+	if(c->iinit<0) {
+	    fprintf(stderr, "Error: Class %s has no constructor\n", c->classname);
+	    return;
+	}
+	swf_SetU30(tag, c->iinit);
+	write_traits(pool, tag, c->traits);
+    }
+    for(t=0;t<pool->classes->num;t++) {
+	abc_class_t*c = (abc_class_t*)dict_getdata(pool->classes, t);
+	if(c->static_constructor_index<0) {
+	    fprintf(stderr, "Error: Class %s has no static constructor\n", c->classname);
+	    return;
+	}
+	swf_SetU30(tag, c->static_constructor_index);
+        write_traits(pool, tag, c->static_constructor_traits);
+    }
+
+    swf_SetU30(tag, pool->scripts->num);
+    for(t=0;t<pool->scripts->num;t++) {
+	abc_script_t*s = (abc_script_t*)dict_getdata(pool->scripts, t);
+	swf_SetU30(tag, s->method->index); //!=t!
+	write_traits(pool, tag, s->traits);
+    }
+
+    swf_SetU30(tag, pool->method_bodies->num);
+    for(t=0;t<pool->method_bodies->num;t++) {
+	abc_method_body_t*c = (abc_method_body_t*)dict_getdata(pool->method_bodies, t);
+	abc_method_t*m = c->method;
+	swf_SetU30(tag, m->index);
+	swf_SetU30(tag, c->max_stack);
+	swf_SetU30(tag, c->local_count);
+	swf_SetU30(tag, c->init_scope_depth);
+	swf_SetU30(tag, c->max_scope_depth);
+	swf_SetU30(tag, c->tag->len);
+	swf_SetBlock(tag, c->tag->data, c->tag->len);
+	swf_SetU30(tag, c->exception_count);
+        write_traits(pool, tag, c->traits);
+    }
+
+    // --- start to write real tag --
+    
+    tag = abctag;
+
+    for(t=1;t<pool->multinames->num;t++) {
+        abc_multiname_t*m = (abc_multiname_t*)dict_getdata(pool->multinames, t);
+        if(m->ns) {
+            register_namespace(pool, m->ns);
+        }
+        if(m->namespace_set_name) {
+            // FIXME
+        }
+        if(m->name)
+            dict_append_if_new(pool->strings, m->name, 0);
+    }
+    for(t=1;t<pool->namespaces->num;t++) {
+        char*namespace_name = (char*)dict_getstr(pool->namespaces, t);
+        dict_append_if_new(pool->strings, namespace_name, 0);
+    }
+
+    swf_SetU32(tag, 1); // flags
+    swf_SetU8(tag, 0); //classname
+
+    swf_SetU16(tag, 0x10); //version
+    swf_SetU16(tag, 0x2e);
+
+    swf_SetU30(tag, pool->ints->num>1?pool->ints->num:0);
+    // ...
+    swf_SetU30(tag, pool->uints->num>1?pool->uints->num:0);
+    // ...
+    swf_SetU30(tag, pool->floats->num>1?pool->floats->num:0);
+    // ...
+    swf_SetU30(tag, pool->strings->num>1?pool->strings->num:0);
+    for(t=1;t<pool->strings->num;t++) {
+	swf_SetU30String(tag, dict_getstr(pool->strings, t));
+    }
+    swf_SetU30(tag, pool->namespaces->num>1?pool->namespaces->num:0);
+    for(t=1;t<pool->namespaces->num;t++) {
+	abc_namespace_t*ns= (abc_namespace_t*)dict_getdata(pool->namespaces, t);
+	const char*name = ns->name;
+	int i = dict_find(pool->strings, name);
+	if(i<0) {
+	    fprintf(stderr, "Couldn't find namespace \"%s\" in constant pool\n", name);
+	    return;
+	}
+	swf_SetU8(tag, ns->access);
+	swf_SetU30(tag, i);
+    }
+    swf_SetU30(tag, pool->sets->num>1?pool->sets->num:0);
+    // ...
+
+    swf_SetU30(tag, pool->multinames->num>1?pool->multinames->num:0);
+    // ...
+    for(t=1;t<pool->multinames->num;t++) {
+	abc_multiname_t*m = (abc_multiname_t*)dict_getdata(pool->multinames, t);
+	swf_SetU8(tag, m->type);
+
+        if(m->ns) {
+            assert(m->type==0x07 || m->type==0x0d);
+            /* fixme: might find wrong version */
+	    int i = dict_find2(pool->namespaces, m->ns->name, (void*)(ptroff_t)m->ns);
+            if(i<0) fprintf(stderr, "internal error: unregistered namespace %02x %s %s\n", m->ns->access, access2str(m->ns->access), m->ns->name);
+	    swf_SetU30(tag, i);
+        }
+        if(m->namespace_set_name) {
+            assert(m->type==0x09 || m->type==0x0e || m->type==0x1c || m->type==0x1b);
+	    int i = dict_find(pool->namespace_sets, m->namespace_set_name);
+            if(i<0) fprintf(stderr, "internal error: unregistered namespace set\n");
+	    swf_SetU30(tag, i);
+        }
+        if(m->name) {
+            assert(m->type==0x09 || m->type==0x0e || m->type==0x07 || m->type==0x0d || m->type==0x0f || m->type==0x10);
+	    int i = dict_find(pool->strings, m->name);
+            if(i<0) fprintf(stderr, "internal error: unregistered name\n");
+	    swf_SetU30(tag, i);
+        }
+    }
+
+    swf_SetBlock(tag, tmp->data, tmp->len);
+
+    swf_DeleteTag(0, tmp);
+}
+
+#include "swfabc_ops.c"
+
+void swf_AddButtonLinks(SWF*swf, char stop_each_frame)
+{
+    int num_frames = 0;
+    int has_buttons = 0;
+    TAG*tag=swf->firstTag;
+    while(tag) {
+        if(tag->id == ST_SHOWFRAME)
+            num_frames++;
+        if(tag->id == ST_DEFINEBUTTON || tag->id == ST_DEFINEBUTTON2)
+            has_buttons = 1;
+        tag = tag->next;
+    }
+
+    abc_file_t*file = abc_file_new();
+    abc_method_body_t*c = 0;
+   
+    abc_class_t*cls = abc_class_new(file, "rfx::MainTimeline", "flash.display::MovieClip");
+    abc_class_protectedNS(cls, "rfx:MainTimeline");
+  
+    TAG*abctag = swf_InsertTagBefore(swf, swf->firstTag, ST_DOABC);
+    
+    tag = swf_InsertTag(abctag, ST_SYMBOLCLASS);
+    swf_SetU16(tag, 1);
+    swf_SetU16(tag, 0);
+    swf_SetString(tag, "rfx.MainTimeline");
+
+    c = abc_class_staticconstructor(cls, 0, 0);
+    c->max_stack = 1;
     c->local_count = 1;
-    c->init_scope_depth = 10;
-    c->max_scope_depth = 11;
+    c->init_scope_depth = 9;
+    c->max_scope_depth = 10;
+
     abc_getlocal_0(c);
     abc_pushscope(c);
     abc_returnvoid(c);
-    
-    abc_AddSlot(maintimeline, ":MyButton1", 0, "flash.display:SimpleButton");
-    abc_AddSlot(maintimeline, ":MyButton2", 0, "flash.display:SimpleButton");
 
-    c = abc_AddMethod(maintimeline, ":void", ":gotoPage2", 1, "flash.events:MouseEvent");
+    c = abc_class_constructor(cls, 0, 0);
     c->max_stack = 3;
-    c->local_count = 2;
+    c->local_count = 1;
     c->init_scope_depth = 10;
     c->max_scope_depth = 11;
+    
+    abc_debugfile(c, "constructor.as");
+
     abc_getlocal_0(c);
     abc_pushscope(c);
-    abc_findpropstrict(c, "flash.net:navigateToURL");
-    abc_findpropstrict(c, "flash.net:URLRequest");
-    abc_pushstring(c, "http://www.quiss.org");
-    abc_constructprop(c, "flash.net:URLRequest", 1);
-    abc_callpropvoid(c, "flash.net:navigateToURL", 1);
-    abc_returnvoid(c);
+
+    abc_getlocal_0(c);
+    abc_constructsuper(c,0);
+
+    abc_getlex(c, "[package]flash.system::Security");
+    abc_pushstring(c, "*");
+    abc_callpropvoid(c, "[package]::allowDomain", 1);
     
-    c = abc_AddMethod(maintimeline, ":void", ":gotoPage1", 1, "flash.events:MouseEvent");
+    if(stop_each_frame || has_buttons) {
+        int frame = 0;
+        tag = swf->firstTag;
+        abc_method_body_t*f = 0; //frame script
+        while(tag && tag->id!=ST_END) {
+            char framename[80];
+            char needs_framescript=0;
+            char buttonname[80];
+            char functionname[80];
+            sprintf(framename, "[packageinternal]rfx::frame%d", frame);
+            
+            if(!f && (tag->id == ST_DEFINEBUTTON || tag->id == ST_DEFINEBUTTON2 || stop_each_frame)) {
+                /* make the contructor add a frame script */
+                abc_findpropstrict(c,"[package]::addFrameScript");
+                abc_pushbyte(c,frame);
+                abc_getlex(c,framename);
+                abc_callpropvoid(c,"[package]::addFrameScript",2);
+
+                f = abc_class_method(cls, 0, framename, 0);
+                f->max_stack = 3;
+                f->local_count = 1;
+                f->init_scope_depth = 10;
+                f->max_scope_depth = 11;
+                abc_debugfile(f, "framescript.as");
+                abc_debugline(f, 1);
+                abc_getlocal_0(f);
+                abc_pushscope(f);
+            }
+
+            if(tag->id == ST_DEFINEBUTTON || tag->id == ST_DEFINEBUTTON2) {
+                U16 id = swf_GetDefineID(tag);
+                sprintf(buttonname, "::button%d", swf_GetDefineID(tag));
+                abc_getlex(f,buttonname);
+                abc_getlex(f,"flash.events::MouseEvent");
+                abc_getproperty(f, "::CLICK");
+                sprintf(functionname, "::clickLink1");
+                abc_getlex(f,functionname);
+                abc_callpropvoid(f, "::addEventListener" ,2);
+
+                if(stop_each_frame) {
+                    abc_findpropstrict(f, "[package]::stop");
+                    abc_callpropvoid(f, "[package]::stop", 0);
+                }
+                needs_framescript = 1;
+            }
+            if(tag->id == ST_SHOWFRAME) {
+                if(f) {
+                    abc_returnvoid(f);
+                    f = 0;
+                }
+                frame++;
+            }
+            tag = tag->next;
+        }
+        if(f) {
+            abc_returnvoid(f);
+        }
+    }
+    abc_returnvoid(c);
+
+    tag = swf->firstTag;
+    while(tag) {
+        if(tag->id == ST_DEFINEBUTTON || tag->id == ST_DEFINEBUTTON2) {
+            char buttonname[80];
+            sprintf(buttonname, "::button%d", swf_GetDefineID(tag));
+            abc_AddSlot(cls, buttonname, 0, "flash.display::SimpleButton");
+        }
+        tag = tag->next;
+    }
+
+    c = abc_class_method(cls, "::void", "::clickLink1", 1, "flash.events::MouseEvent");
     c->max_stack = 3;
     c->local_count = 2;
     c->init_scope_depth = 10;
     c->max_scope_depth = 11;
     abc_getlocal_0(c);
     abc_pushscope(c);
-    abc_findpropstrict(c,"flash.net:navigateToURL");
-    abc_findpropstrict(c,"flash.net:URLRequest");
-    abc_pushstring(c,"http://www.google.com/");
-    abc_constructprop(c,"flash.net:URLRequest", 1);
-    abc_callpropvoid(c,"flash.net:navigateToURL", 1);
+    abc_findpropstrict(c,"flash.net::navigateToURL");
+    abc_findpropstrict(c,"flash.net::URLRequest");
+    abc_pushstring(c,"http://www.quiss.org/");
+    //abc_pushstring(c,"file:///home/kramm/c/swftools/lib/modules/test2.html");
+    abc_constructprop(c,"flash.net::URLRequest", 1);
+    abc_callpropvoid(c,"flash.net::navigateToURL", 1);
     abc_returnvoid(c);
-    
-    c = abc_AddConstructor(maintimeline, 0, 0);
-    c->max_stack = 3;
-    c->local_count = 1;
-    c->init_scope_depth = 10;
-    c->max_scope_depth = 11;
-
-    abc_getlocal_0(c);
-    abc_pushscope(c);
+  
 
-    abc_getlocal_0(c);
-    abc_constructsuper(c,0);
-    abc_findpropstrict(c,":addFrameScript");
-    abc_pushbyte(c,0x00);
-    abc_getlex(c,"[packageinternal]buttonmitlink_fla:frame1");
-    abc_callpropvoid(c,":addFrameScript",2);
-
-    abc_getlex(c,":MyButton1");
-    abc_getlex(c,"flash.events:MouseEvent");
-    abc_getproperty(c, ":CLICK");
-    abc_getlex(c, ":gotoPage1");
-    abc_callpropvoid(c, ":addEventListener" ,2);
-
-    abc_getlex(c,":MyButton2");
-    abc_getlex(c,"flash.events:MouseEvent");
-    abc_getproperty(c, ":CLICK");
-    abc_getlex(c,":gotoPage2");
-    abc_callpropvoid(c,":addEventListener",2);
-
-    abc_returnvoid(c);
-    
-    c = abc_AddInitScript(abc, 0, 0);
+    abc_script_t*s = abc_initscript(file, 0, 0);
+    c = (abc_method_body_t*)dict_getdata(file->method_bodies, s->method->method_body_index);
     c->max_stack = 2;
     c->local_count = 1;
     c->init_scope_depth = 1;
@@ -1461,22 +1712,22 @@ void swf_AddButtonLinks(TAG*tag)
     abc_getlocal_0(c);
     abc_pushscope(c);
     abc_getscopeobject(c, 0);
-    abc_getlex(c,":Object");
+    abc_getlex(c,"::Object");
     abc_pushscope(c);
-    abc_getlex(c,"flash.events:EventDispatcher");
+    abc_getlex(c,"flash.events::EventDispatcher");
     abc_pushscope(c);
-    abc_getlex(c,"flash.display:DisplayObject");
+    abc_getlex(c,"flash.display::DisplayObject");
     abc_pushscope(c);
-    abc_getlex(c,"flash.display:InteractiveObject");
+    abc_getlex(c,"flash.display::InteractiveObject");
     abc_pushscope(c);
-    abc_getlex(c,"flash.display:DisplayObjectContainer");
+    abc_getlex(c,"flash.display::DisplayObjectContainer");
     abc_pushscope(c);
-    abc_getlex(c,"flash.display:Sprite");
+    abc_getlex(c,"flash.display::Sprite");
     abc_pushscope(c);
-    abc_getlex(c,"flash.display:MovieClip");
+    abc_getlex(c,"flash.display::MovieClip");
     abc_pushscope(c);
-    abc_getlex(c,"flash.display:MovieClip");
-    abc_newclass(c,maintimeline);
+    abc_getlex(c,"flash.display::MovieClip");
+    abc_newclass(c,cls);
     abc_popscope(c);
     abc_popscope(c);
     abc_popscope(c);
@@ -1484,11 +1735,12 @@ void swf_AddButtonLinks(TAG*tag)
     abc_popscope(c);
     abc_popscope(c);
     abc_popscope(c);
-    abc_initproperty(c,"buttonmitlink_fla:MainTimeline");
+    abc_initproperty(c,"rfx::MainTimeline");
     abc_returnvoid(c);
 
-    abc_code_addClassTrait(c, "buttonmitlink_fla:MainTimeline", 1, maintimeline);
+    //abc_method_body_addClassTrait(c, "rfx:MainTimeline", 1, cls);
+    abc_initscript_addClassTrait(s, "rfx::MainTimeline", 1, cls);
 
-    swf_WriteABC(tag, abc);
+    swf_WriteABC(abctag, file);
 }