X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fas3%2Fabc.c;h=91a70e64c92ea22d7c8aaff0480f9e93c413244e;hb=3f9b43eec2a339e1c60a4139556b6153f8b3cc65;hp=70e67ac6cb60740c8f7bf0f8d86341ed5184c5c3;hpb=7d0020111445248f91aa35e396dcd67d3fe80bc4;p=swftools.git

diff --git a/lib/as3/abc.c b/lib/as3/abc.c
index 70e67ac..91a70e6 100644
--- a/lib/as3/abc.c
+++ b/lib/as3/abc.c
@@ -40,43 +40,40 @@ int abc_RegisterPrivateNameSpace(abc_file_t*file, const char*name);
 /* TODO: switch to a datastructure with just values */
 #define NO_KEY ""
 
-static char* params_to_string(multiname_list_t*list)
+static char* params_tostring(multiname_list_t*list)
 {
     multiname_list_t*l;
-    int n;
-
-    l = list;
-    n = 0;
-    while(list) {
-        n++;list=list->next;
-    }
-
+    int n = list_length(list);
     char**names = (char**)malloc(sizeof(char*)*n);
     
     l = list;
     n = 0;
     int size = 0;
-    while(list) {
-        names[n] = multiname_to_string(list->multiname);
+    while(l) {
+        names[n] = multiname_tostring(l->multiname);
         size += strlen(names[n]) + 2;
-        n++;list=list->next;
+        n++;l=l->next;
     }
 
-    char* params = malloc(size+5);
+    char* params = malloc(size+15);
     params[0]='(';
     params[1]=0;
     l = list;
     int s=0;
     n = 0;
-    while(list) {
+    while(l) {
         if(s)
             strcat(params, ", ");
         strcat(params, names[n]);
         free(names[n]);
+        l = l->next;
         n++;
         s=1;
     }
     free(names);
+    /*char num[20];
+    sprintf(num, "[%d params]", n);
+    strcat(params, num);*/
     strcat(params, ")");
     int t;
     return params;
@@ -127,6 +124,7 @@ abc_file_t*abc_file_new()
     f->classes = array_new();
     f->scripts = array_new();
     f->method_bodies = array_new();
+    f->flags = ABCFILE_LAZY;
 
     return f;
 }
@@ -136,12 +134,12 @@ abc_file_t*abc_file_new()
 #define CLASS_INTERFACE 4
 #define CLASS_PROTECTED_NS 8
 
-abc_class_t* abc_class_new(abc_file_t*pool, multiname_t*classname, multiname_t*superclass) {
+abc_class_t* abc_class_new(abc_file_t*file, multiname_t*classname, multiname_t*superclass) {
     
     NEW(abc_class_t,c);
-    array_append(pool->classes, NO_KEY, c);
+    array_append(file->classes, NO_KEY, c);
 
-    c->pool = pool;
+    c->file = file;
     c->classname = classname;
     c->superclass = superclass;
     c->flags = 0;
@@ -177,24 +175,21 @@ void abc_class_add_interface(abc_class_t*c, multiname_t*interface)
     list_append(c->interfaces, interface);
 }
 
-abc_method_body_t* add_method(abc_file_t*pool, abc_class_t*cls, char*returntype, int num_params, va_list va)
+abc_method_body_t* add_method(abc_file_t*file, abc_class_t*cls, multiname_t*returntype, int num_params, va_list va)
 {
     /* construct code (method body) object */
     NEW(abc_method_body_t,c);
-    array_append(pool->method_bodies, NO_KEY, c);
-    c->pool = pool;
+    array_append(file->method_bodies, NO_KEY, c);
+    c->file = file;
     c->traits = list_new();
     c->code = 0;
 
     /* construct method object */
     NEW(abc_method_t,m);
-    array_append(pool->methods, NO_KEY, m);
+    array_append(file->methods, NO_KEY, m);
+
+    m->return_type = returntype;
 
-    if(returntype && strcmp(returntype, "void")) {
-	m->return_type = multiname_fromstring(returntype);
-    } else {
-	m->return_type = 0;
-    }
     int t;
     for(t=0;t<num_params;t++) {
 	const char*param = va_arg(va, const char*);
@@ -208,27 +203,27 @@ abc_method_body_t* add_method(abc_file_t*pool, abc_class_t*cls, char*returntype,
     return c;
 }
 
-abc_method_body_t* abc_class_constructor(abc_class_t*cls, char*returntype, int num_params, ...) 
+abc_method_body_t* abc_class_constructor(abc_class_t*cls, multiname_t*returntype, int num_params, ...) 
 {
     va_list va;
     va_start(va, num_params);
-    abc_method_body_t* c = add_method(cls->pool, cls, returntype, num_params, va);
+    abc_method_body_t* c = add_method(cls->file, cls, returntype, num_params, va);
     va_end(va);
     cls->constructor = c->method;
     return c;
 }
 
-abc_method_body_t* abc_class_staticconstructor(abc_class_t*cls, char*returntype, int num_params, ...) 
+abc_method_body_t* abc_class_staticconstructor(abc_class_t*cls, multiname_t*returntype, int num_params, ...) 
 {
     va_list va;
     va_start(va, num_params);
-    abc_method_body_t* c = add_method(cls->pool, cls, returntype, num_params, va);
+    abc_method_body_t* c = add_method(cls->file, cls, returntype, num_params, va);
     va_end(va);
     cls->static_constructor = c->method;
     return c;
 }
 
-trait_t*trait_new(int type, multiname_t*name, int data1, int data2, int vindex, int vkind)
+trait_t*trait_new(int type, multiname_t*name, int data1, int data2, constant_t*v)
 {
     trait_t*trait = malloc(sizeof(trait_t));
     memset(trait, 0, sizeof(trait_t));
@@ -237,8 +232,18 @@ trait_t*trait_new(int type, multiname_t*name, int data1, int data2, int vindex,
     trait->name = name;
     trait->data1 = data1;
     trait->data2 = data2;
-    trait->vindex = vindex;
-    trait->vkind = vkind;
+    trait->value = v;
+    return trait;
+}
+trait_t*trait_new_member(multiname_t*type, multiname_t*name,constant_t*v)
+{
+    int kind = TRAIT_SLOT;
+    trait_t*trait = malloc(sizeof(trait_t));
+    memset(trait, 0, sizeof(trait_t));
+    trait->kind = kind&0x0f;
+    trait->attributes = kind&0xf0;
+    trait->name = name;
+    trait->type_name = type;
     return trait;
 }
 trait_t*trait_new_method(multiname_t*name, abc_method_t*m)
@@ -253,69 +258,74 @@ trait_t*trait_new_method(multiname_t*name, abc_method_t*m)
     return trait;
 }
 
-abc_method_body_t* abc_class_method(abc_class_t*cls, char*returntype, char*name, int num_params, ...)
+abc_method_body_t* abc_class_method(abc_class_t*cls, multiname_t*returntype, char*name, int num_params, ...)
 {
-    abc_file_t*pool = cls->pool;
+    abc_file_t*file = cls->file;
     va_list va;
     va_start(va, num_params);
-    abc_method_body_t* c = add_method(cls->pool, cls, returntype, num_params, va);
+    abc_method_body_t* c = add_method(cls->file, cls, returntype, num_params, va);
     va_end(va);
     list_append(cls->traits, trait_new_method(multiname_fromstring(name), c->method));
     return c;
 }
 
-void abc_AddSlot(abc_class_t*cls, char*name, int slot, char*multiname)
+void abc_AddSlot(abc_class_t*cls, char*name, int slot, char*type)
 {
-    abc_file_t*pool = cls->pool;
-    multiname_t*m = multiname_fromstring(multiname);
-    list_append(cls->traits, trait_new(TRAIT_SLOT, m, slot, 0, 0, 0));
+    abc_file_t*file = cls->file;
+    multiname_t*m_name = multiname_fromstring(name);
+    multiname_t*m_type = multiname_fromstring(type);
+    trait_t*t = trait_new_member(m_type, m_name, 0);
+    t->slot_id = list_length(cls->traits);
+    list_append(cls->traits, t);
 }
 
 void abc_method_body_addClassTrait(abc_method_body_t*code, char*multiname, int slotid, abc_class_t*cls)
 {
-    abc_file_t*pool = code->pool;
+    abc_file_t*file = code->file;
     multiname_t*m = multiname_fromstring(multiname);
-    trait_t*trait = trait_new(TRAIT_CLASS, m, slotid, 0, 0, 0);
+    trait_t*trait = trait_new(TRAIT_CLASS, m, slotid, 0, 0);
     trait->cls = cls;
     list_append(code->traits, trait);
 }
 
 /* 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)
+int abc_initscript_addClassTrait(abc_script_t*script, multiname_t*multiname, abc_class_t*cls)
 {
-    abc_file_t*pool = script->pool;
-    multiname_t*m = multiname_fromstring(multiname);
-    trait_t*trait = trait_new(TRAIT_CLASS, m, slotid, 0, 0, 0);
+    abc_file_t*file = script->file;
+    multiname_t*m = multiname_clone(multiname);
+    int slotid = list_length(script->traits)+1;
+    trait_t*trait = trait_new(TRAIT_CLASS, m, slotid, 0, 0);
     trait->cls = cls;
     list_append(script->traits, trait);
+    return slotid;
 }
 
-abc_script_t* abc_initscript(abc_file_t*pool, char*returntype, int num_params, ...) 
+abc_script_t* abc_initscript(abc_file_t*file, multiname_t*returntype, int num_params, ...) 
 {
     va_list va;
     va_start(va, num_params);
-    abc_method_body_t* c = add_method(pool, 0, returntype, num_params, va);
+    abc_method_body_t* c = add_method(file, 0, returntype, num_params, va);
     abc_script_t* s = malloc(sizeof(abc_script_t));
     s->method = c->method;
     s->traits = list_new();
-    s->pool = pool;
-    array_append(pool->scripts, NO_KEY, s);
+    s->file = file;
+    array_append(file->scripts, NO_KEY, s);
     va_end(va);
     return s;
 }
 
-static void dump_traits(FILE*fo, const char*prefix, trait_list_t*traits, abc_file_t*file);
+static void traits_dump(FILE*fo, const char*prefix, trait_list_t*traits, abc_file_t*file);
 
 static void dump_method(FILE*fo, const char*prefix, const char*type, const char*name, abc_method_t*m, abc_file_t*file)
 {
     char*return_type = 0;
     if(m->return_type)
-        return_type = multiname_to_string(m->return_type);
+        return_type = multiname_tostring(m->return_type);
     else
         return_type = strdup("void");
-    char*paramstr = params_to_string(m->parameters);
-    fprintf(fo, "%s%s %s %s=%s %s\n", prefix, type, return_type, name, m->name, paramstr);
+    char*paramstr = params_tostring(m->parameters);
+    fprintf(fo, "%s%s %s %s=%s %s (%d params)\n", prefix, type, return_type, name, m->name, paramstr, list_length(m->parameters));
     free(paramstr);paramstr=0;
     free(return_type);return_type=0;
 
@@ -324,12 +334,12 @@ static void dump_method(FILE*fo, const char*prefix, const char*type, const char*
         return;
     }
     
-    fprintf(fo, "%s[%d %d %d %d %d]\n", prefix, c->max_stack, c->local_count, c->init_scope_depth, c->max_scope_depth, list_length(c->exceptions));
+    fprintf(fo, "%s[stack:%d locals:%d scope:%d-%d flags:%02x]\n", prefix, c->old.max_stack, c->old.local_count, c->old.init_scope_depth, c->old.max_scope_depth, c->method->flags);
 
     char prefix2[80];
     sprintf(prefix2, "%s    ", prefix);
     if(c->traits)
-        dump_traits(fo, prefix, c->traits, file);
+        traits_dump(fo, prefix, c->traits, file);
     fprintf(fo, "%s{\n", prefix);
     code_dump(c->code, c->exceptions, file, prefix2, fo);
     fprintf(fo, "%s}\n\n", prefix);
@@ -345,11 +355,20 @@ static void traits_free(trait_list_t*traits)
 	if(t->trait->kind == TRAIT_SLOT || t->trait->kind == TRAIT_CONST) {
             multiname_destroy(t->trait->type_name);
         }
+        if(t->trait->value) {
+            constant_free(t->trait->value);t->trait->value = 0;
+        }
         free(t->trait);t->trait = 0;
         t = t->next;
     }
     list_free(traits);
 }
+            
+static char trait_is_method(trait_t*trait)
+{
+    return (trait->kind == TRAIT_METHOD || trait->kind == TRAIT_GETTER || 
+            trait->kind == TRAIT_SETTER || trait->kind == TRAIT_FUNCTION);
+}
 
 static trait_list_t* traits_parse(TAG*tag, pool_t*pool, abc_file_t*file)
 {
@@ -361,14 +380,13 @@ static trait_list_t* traits_parse(TAG*tag, pool_t*pool, abc_file_t*file)
     }
     
     for(t=0;t<num_traits;t++) {
-	trait_t*trait = malloc(sizeof(trait_t));
-	memset(trait, 0, sizeof(trait_t));
+        NEW(trait_t,trait);
 	list_append(traits, trait);
 
 	trait->name = multiname_clone(pool_lookup_multiname(pool, swf_GetU30(tag))); // always a QName (ns,name)
 
 	const char*name = 0;
-	DEBUG name = multiname_to_string(trait->name);
+	DEBUG name = multiname_tostring(trait->name);
 	U8 kind = swf_GetU8(tag);
         U8 attributes = kind&0xf0;
         kind&=0x0f;
@@ -393,11 +411,12 @@ static trait_list_t* traits_parse(TAG*tag, pool_t*pool, abc_file_t*file)
              */
 	    trait->slot_id = swf_GetU30(tag);
             trait->type_name = multiname_clone(pool_lookup_multiname(pool, swf_GetU30(tag)));
-	    trait->vindex = swf_GetU30(tag);
-	    if(trait->vindex) {
-		trait->vkind = swf_GetU8(tag);
+	    int vindex = swf_GetU30(tag);
+	    if(vindex) {
+		int vkind = swf_GetU8(tag);
+                trait->value = constant_fromindex(pool, vindex, vkind);
 	    }
-	    DEBUG printf("  slot %s %d %s (vindex=%d)\n", name, trait->slot_id, trait->type_name->name, trait->vindex);
+	    DEBUG printf("  slot %s %d %s (%s)\n", name, trait->slot_id, trait->type_name->name, constant_tostring(trait->value));
 	} else {
 	    fprintf(stderr, "Can't parse trait type %d\n", kind);
 	}
@@ -468,9 +487,10 @@ static void traits_write(pool_t*pool, TAG*tag, trait_list_t*traits)
         }
 
 	if(trait->kind == TRAIT_SLOT || trait->kind == TRAIT_CONST) {
-	    swf_SetU30(tag, trait->vindex);
-	    if(trait->vindex) {
-		swf_SetU8(tag, trait->vkind);
+            int vindex = constant_get_index(pool, trait->value);
+	    swf_SetU30(tag, vindex);
+	    if(vindex) {
+		swf_SetU8(tag, trait->value->type);
 	    }
 	}
         if(trait->attributes&0x40) {
@@ -482,12 +502,12 @@ static void traits_write(pool_t*pool, TAG*tag, trait_list_t*traits)
 }
 
 
-static void dump_traits(FILE*fo, const char*prefix, trait_list_t*traits, abc_file_t*file)
+static void traits_dump(FILE*fo, const char*prefix, trait_list_t*traits, abc_file_t*file)
 {
     int t;
     while(traits) {
 	trait_t*trait = traits->trait;
-	char*name = multiname_to_string(trait->name);
+	char*name = multiname_tostring(trait->name);
 	U8 kind = trait->kind;
         U8 attributes = trait->attributes;
 	if(kind == TRAIT_METHOD) {
@@ -505,14 +525,18 @@ static void dump_traits(FILE*fo, const char*prefix, trait_list_t*traits, abc_fil
 	} else if(kind == TRAIT_CLASS) { // class
             abc_class_t*cls = trait->cls;
             if(!cls) {
-	        fprintf(fo, "%sslot %d: class %s=class%d\n", prefix, trait->slot_id, name);
+	        fprintf(fo, "%sslot %d: class %s=00000000\n", prefix, trait->slot_id, name);
             } else {
 	        fprintf(fo, "%sslot %d: class %s=%s\n", prefix, trait->slot_id, name, cls->classname->name);
             }
 	} else if(kind == TRAIT_SLOT || kind == TRAIT_CONST) { // slot, const
 	    int slot_id = trait->slot_id;
-	    char*type_name = multiname_to_string(trait->type_name);
-	    fprintf(fo, "%sslot %s %d %s (vindex=%d)\n", prefix, name, trait->slot_id, type_name, trait->vindex);
+	    char*type_name = multiname_tostring(trait->type_name);
+            char*value = constant_tostring(trait->value);
+	    fprintf(fo, "%sslot %d: %s%s %s %s %s\n", prefix, trait->slot_id, 
+                    kind==TRAIT_CONST?"const ":"", type_name, name, 
+                    value?"=":"", value);
+            if(value) free(value);
             free(type_name);
 	} else {
 	    fprintf(fo, "%s    can't dump trait type %d\n", prefix, kind);
@@ -554,23 +578,23 @@ void* swf_DumpABC(FILE*fo, void*code, char*prefix)
         if(cls->flags&2) fprintf(fo, "final ");
         if(cls->flags&4) fprintf(fo, "interface ");
         if(cls->flags&8) {
-            char*s = namespace_to_string(cls->protectedNS);
+            char*s = namespace_tostring(cls->protectedNS);
             fprintf(fo, "protectedNS(%s) ", s);
             free(s);
         }
 
-        char*classname = multiname_to_string(cls->classname);
+        char*classname = multiname_tostring(cls->classname);
 	fprintf(fo, "class %s", classname);
         free(classname);
         if(cls->superclass) {
-            char*supername = multiname_to_string(cls->superclass);
+            char*supername = multiname_tostring(cls->superclass);
             fprintf(fo, " extends %s", supername);
             free(supername);
             multiname_list_t*ilist = cls->interfaces;
             if(ilist)
                 fprintf(fo, " implements");
             while(ilist) {
-                char*s = multiname_to_string(ilist->multiname);
+                char*s = multiname_tostring(ilist->multiname);
                 fprintf(fo, " %s", s);
                 free(s);
                 ilist = ilist->next;
@@ -583,13 +607,13 @@ void* swf_DumpABC(FILE*fo, void*code, char*prefix)
 
         if(cls->static_constructor)
             dump_method(fo, prefix2,"staticconstructor", "", cls->static_constructor, file);
-        dump_traits(fo, prefix2, cls->static_constructor_traits, file);
+        traits_dump(fo, prefix2, cls->static_constructor_traits, file);
 	
-        char*n = multiname_to_string(cls->classname);
+        char*n = multiname_tostring(cls->classname);
         if(cls->constructor)
 	    dump_method(fo, prefix2, "constructor", n, cls->constructor, file);
         free(n);
-	dump_traits(fo, prefix2,cls->traits, file);
+	traits_dump(fo, prefix2,cls->traits, file);
         fprintf(fo, "%s}\n", prefix);
     }
     fprintf(fo, "%s\n", prefix);
@@ -597,7 +621,7 @@ void* swf_DumpABC(FILE*fo, void*code, char*prefix)
     for(t=0;t<file->scripts->num;t++) {
         abc_script_t*s = (abc_script_t*)array_getvalue(file->scripts, t);
         dump_method(fo, prefix,"initmethod", "init", s->method, file);
-        dump_traits(fo, prefix, s->traits, file);
+        traits_dump(fo, prefix, s->traits, file);
     }
     return file;
 }
@@ -613,7 +637,7 @@ void* swf_ReadABC(TAG*tag)
         U32 abcflags = swf_GetU32(tag);
         DEBUG printf("flags=%08x\n", abcflags);
         char*name= swf_GetString(tag);
-        file->name = name?strdup(name):0;
+        file->name = (name&&name[0])?strdup(name):0;
     }
     U32 version = swf_GetU32(tag);
     if(version!=0x002e0010) {
@@ -650,15 +674,18 @@ void* swf_ReadABC(TAG*tag)
 
 	m->flags = swf_GetU8(tag);
 	
-        DEBUG printf("method %d) %s flags=%02x\n", t, params_to_string(m->parameters), m->flags);
+        DEBUG printf("method %d) %s flags=%02x\n", t, params_tostring(m->parameters), m->flags);
 
         if(m->flags&0x08) {
             /* TODO optional parameters */
+            m->optional_parameters = list_new();
             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"
+                int vindex = swf_GetU30(tag);
+                U8 vkind = swf_GetU8(tag); // specifies index type for "val"
+                constant_t*c = constant_fromindex(pool, vindex, vkind);
+                list_append(m->optional_parameters, c);
             }
         }
 	if(m->flags&0x80) {
@@ -728,10 +755,12 @@ void* swf_ReadABC(TAG*tag)
 	abc_method_t*m = (abc_method_t*)array_getvalue(file->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);
+	c->old.max_stack = swf_GetU30(tag);
+	c->old.local_count = swf_GetU30(tag);
+	c->old.init_scope_depth = swf_GetU30(tag);
+	c->old.max_scope_depth = swf_GetU30(tag);
+
+        c->init_scope_depth = c->old.init_scope_depth;
 	int code_length = swf_GetU30(tag);
 
 	c->method = m;
@@ -810,10 +839,6 @@ void* swf_ReadABC(TAG*tag)
         s->method = m;
         s->traits = traits_parse(tag, pool, file);
         array_append(file->scripts, NO_KEY, s);
-        if(!s->traits) {
-	    fprintf(stderr, "Can't parse script traits\n");
-            return 0;
-        }
     }
 
     pool_destroy(pool);
@@ -840,12 +865,25 @@ void swf_WriteABC(TAG*abctag, void*code)
 
     abc_method_t*nullmethod = 0;
     if(need_null_method) {
-        nullmethod = malloc(sizeof(abc_method_t));
-        memset(nullmethod, 0, sizeof(abc_method_t));
+        NEW(abc_method_t,m);
+        nullmethod = m;
         /*TODO: might be more efficient to have this at the beginning */
         array_append(file->methods, NO_KEY, nullmethod);
+        
+        NEW(abc_method_body_t,body);
+        body->method = m;
+        m->body = body;
+        __ returnvoid(body);
+        array_append(file->method_bodies, NO_KEY, body);
     }
-   
+    for(t=0;t<file->classes->num;t++) {
+	abc_class_t*c = (abc_class_t*)array_getvalue(file->classes, t);
+        if(!c->constructor)
+            c->constructor = nullmethod;
+        if(!c->static_constructor)
+            c->static_constructor = nullmethod;
+    }
+
     swf_SetU30(tag, file->methods->num);
     /* enumerate classes, methods and method bodies */
     for(t=0;t<file->methods->num;t++) {
@@ -859,18 +897,49 @@ void swf_WriteABC(TAG*abctag, void*code)
     for(t=0;t<file->method_bodies->num;t++) {
         abc_method_body_t*m = (abc_method_body_t*)array_getvalue(file->method_bodies, t);
         m->index = t;
-        exception_list_t*ee = m->exceptions;
-        while(ee) {
-            exception_t*e=ee->exception;ee->exception=0;
-            e->from = e->to = e->target = 0;
-            multiname_destroy(e->exc_type);e->exc_type=0;
-            multiname_destroy(e->var_name);e->var_name=0;
-            free(e);
-            ee=ee->next;
+    }
+    
+    /* generate code statistics */
+    for(t=0;t<file->method_bodies->num;t++) {
+        abc_method_body_t*m = (abc_method_body_t*)array_getvalue(file->method_bodies, t);
+        m->stats = code_get_statistics(m->code, m->exceptions);
+    }
+    
+    /* level init scope depths: The init scope depth of a method is
+       always as least as high as the init scope depth of it's surrounding
+       class.
+       A method has it's own init_scope_depth if it's an init method 
+       (then its init scope depth is zero), or if it's used as a closure.
+
+       Not sure yet what to do with methods which are used at different
+       locations- e.g. the nullmethod is used all over the place.
+
+       Also, I have the strong suspicion that flash player uses only
+       the difference between max_scope_stack and init_scope_stack, anyway.
+     */
+    for(t=0;t<file->classes->num;t++) {
+	abc_class_t*c = (abc_class_t*)array_getvalue(file->classes, t);
+        trait_list_t*traits = c->traits;
+        if(c->constructor &&
+           c->constructor->body->init_scope_depth < c->init_scope_depth) {
+           c->constructor->body->init_scope_depth = c->init_scope_depth;
+        }
+        if(c->static_constructor &&
+           c->static_constructor->body->init_scope_depth < c->init_scope_depth) {
+           c->static_constructor->body->init_scope_depth = c->init_scope_depth;
+        }
+        while(traits) {
+            trait_t*trait = traits->trait;
+            if(trait_is_method(trait) && trait->method->body) {
+                abc_method_body_t*body = trait->method->body;
+	        if(body->init_scope_depth < c->init_scope_depth) {
+                   body->init_scope_depth = c->init_scope_depth;
+                }
+            }
+            traits = traits->next;
         }
-        list_free(m->exceptions);m->exceptions=0;
     }
-
+    
     for(t=0;t<file->methods->num;t++) {
 	abc_method_t*m = (abc_method_t*)array_getvalue(file->methods, t);
         int n = 0;
@@ -892,7 +961,23 @@ void swf_WriteABC(TAG*abctag, void*code)
 	    swf_SetU30(tag, 0);
         }
 
-	swf_SetU8(tag, 0); //flags
+        U8 flags = m->flags&(METHOD_NEED_REST|METHOD_NEED_ARGUMENTS);
+        if(m->optional_parameters)
+            flags |= METHOD_HAS_OPTIONAL;
+        if(m->body) {
+            flags |= m->body->stats->flags;
+        }
+
+	swf_SetU8(tag, flags);
+        if(flags&METHOD_HAS_OPTIONAL) {
+            swf_SetU30(tag, list_length(m->optional_parameters));
+            constant_list_t*l = m->optional_parameters;
+            while(l) {
+                swf_SetU30(tag, constant_get_index(pool, l->constant));
+                swf_SetU8(tag, l->constant->type);
+                l = l->next;
+            }
+        }
     }
    
     /* write metadata */
@@ -963,10 +1048,20 @@ void swf_WriteABC(TAG*abctag, void*code)
 	abc_method_body_t*c = (abc_method_body_t*)array_getvalue(file->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->old.max_stack);
+	//swf_SetU30(tag, c->old.local_count);
+	//swf_SetU30(tag, c->old.init_scope_depth);
+	//swf_SetU30(tag, c->old.max_scope_depth);
+
+	swf_SetU30(tag, c->stats->max_stack);
+        if(list_length(c->method->parameters)+1 <= c->stats->local_count)
+	    swf_SetU30(tag, c->stats->local_count);
+        else
+	    swf_SetU30(tag, list_length(c->method->parameters)+1);
 	swf_SetU30(tag, c->init_scope_depth);
-	swf_SetU30(tag, c->max_scope_depth);
+	swf_SetU30(tag, c->stats->max_scope_depth+
+                        c->init_scope_depth);
 
         code_write(tag, c->code, pool, file);
 
@@ -984,13 +1079,20 @@ void swf_WriteABC(TAG*abctag, void*code)
 
         traits_write(pool, tag, c->traits);
     }
+   
+    /* free temporary codestat data again. Notice: If we were to write this
+       file multiple times, this can also be shifted to abc_file_free() */
+    for(t=0;t<file->method_bodies->num;t++) {
+        abc_method_body_t*m = (abc_method_body_t*)array_getvalue(file->method_bodies, t);
+        codestats_free(m->stats);m->stats=0;
+    }
 
     // --- start to write real tag --
     
     tag = abctag;
 
     if(tag->id == ST_DOABC) {
-        swf_SetU32(tag, 1); // flags
+        swf_SetU32(tag, file->flags); // flags
         swf_SetString(tag, file->name);
     }
 
@@ -1007,7 +1109,6 @@ void swf_WriteABC(TAG*abctag, void*code)
 
 void abc_file_free(abc_file_t*file)
 {
-
     int t;
     for(t=0;t<file->metadata->num;t++) {
         array_t*items = (array_t*)array_getvalue(file->metadata, t);
@@ -1028,6 +1129,13 @@ void abc_file_free(abc_file_t*file)
             param = param->next;
         }
         list_free(m->parameters);m->parameters=0;
+       
+        constant_list_t*opt = m->optional_parameters;
+        while(opt) {
+            constant_free(opt->constant);opt->constant=0;
+            opt = opt->next;
+        }
+        list_free(m->optional_parameters);m->optional_parameters=0;
 
         if(m->name) {
             free((void*)m->name);m->name=0;
@@ -1076,6 +1184,18 @@ void abc_file_free(abc_file_t*file)
         abc_method_body_t*body = (abc_method_body_t*)array_getvalue(file->method_bodies, t);
         code_free(body->code);body->code=0;
 	traits_free(body->traits);body->traits=0;
+
+        exception_list_t*ee = body->exceptions;
+        while(ee) {
+            exception_t*e=ee->exception;ee->exception=0;
+            e->from = e->to = e->target = 0;
+            multiname_destroy(e->exc_type);e->exc_type=0;
+            multiname_destroy(e->var_name);e->var_name=0;
+            free(e);
+            ee=ee->next;
+        }
+        list_free(body->exceptions);body->exceptions=0;
+        
         free(body);
     }
     array_free(file->method_bodies);
@@ -1120,20 +1240,20 @@ void swf_AddButtonLinks(SWF*swf, char stop_each_frame, char events)
     swf_SetString(tag, "rfx.MainTimeline");
 
     c = abc_class_staticconstructor(cls, 0, 0);
-    c->max_stack = 1;
-    c->local_count = 1;
-    c->init_scope_depth = 9;
-    c->max_scope_depth = 10;
+    c->old.max_stack = 1;
+    c->old.local_count = 1;
+    c->old.init_scope_depth = 9;
+    c->old.max_scope_depth = 10;
 
     __ getlocal_0(c);
     __ pushscope(c);
     __ returnvoid(c);
 
     c = abc_class_constructor(cls, 0, 0);
-    c->max_stack = 3;
-    c->local_count = 1;
-    c->init_scope_depth = 10;
-    c->max_scope_depth = 11;
+    c->old.max_stack = 3;
+    c->old.local_count = 1;
+    c->old.init_scope_depth = 10;
+    c->old.max_scope_depth = 11;
     
     debugfile(c, "constructor.as");
 
@@ -1166,10 +1286,10 @@ void swf_AddButtonLinks(SWF*swf, char stop_each_frame, char events)
                 __ 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;
+                f->old.max_stack = 3;
+                f->old.local_count = 1;
+                f->old.init_scope_depth = 10;
+                f->old.max_scope_depth = 11;
                 __ debugfile(f, "framescript.as");
                 __ debugline(f, 1);
                 __ getlocal_0(f);
@@ -1193,11 +1313,11 @@ void swf_AddButtonLinks(SWF*swf, char stop_each_frame, char events)
                 needs_framescript = 1;
 
                 abc_method_body_t*h =
-                    abc_class_method(cls, "::void", functionname, 1, "flash.events::MouseEvent");
-                h->max_stack = 6;
-                h->local_count = 2;
-                h->init_scope_depth = 10;
-                h->max_scope_depth = 11;
+                    abc_class_method(cls, 0, functionname, 1, "flash.events::MouseEvent");
+                h->old.max_stack = 6;
+                h->old.local_count = 2;
+                h->old.init_scope_depth = 10;
+                h->old.max_scope_depth = 11;
                 __ getlocal_0(h);
                 __ pushscope(h);
 
@@ -1275,10 +1395,10 @@ void swf_AddButtonLinks(SWF*swf, char stop_each_frame, char events)
 
     abc_script_t*s = abc_initscript(file, 0, 0);
     c = s->method->body;
-    c->max_stack = 2;
-    c->local_count = 1;
-    c->init_scope_depth = 1;
-    c->max_scope_depth = 9;
+    c->old.max_stack = 2;
+    c->old.local_count = 1;
+    c->old.init_scope_depth = 1;
+    c->old.max_scope_depth = 9;
 
     __ getlocal_0(c);
     __ pushscope(c);
@@ -1310,7 +1430,9 @@ void swf_AddButtonLinks(SWF*swf, char stop_each_frame, char events)
     __ returnvoid(c);
 
     //abc_method_body_addClassTrait(c, "rfx:MainTimeline", 1, cls);
-    abc_initscript_addClassTrait(s, "rfx::MainTimeline", 1, cls);
+    multiname_t*classname = multiname_fromstring("rfx::MainTimeline");
+    abc_initscript_addClassTrait(s, classname, cls);
+    multiname_destroy(classname);
 
     swf_WriteABC(abctag, file);
 }