renamed code_dump() to code_dump2(), code_dump() only takes one argument

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

diff --git a/lib/as3/abc.c b/lib/as3/abc.c
index f99263e..623dc7c 100644 (file)
--- a/lib/as3/abc.c
+++ b/lib/as3/abc.c
@@ -170,7 +170,7 @@ void abc_class_add_interface(abc_class_t*c, multiname_t*interface)
     list_append(c->interfaces, multiname_clone(interface));
 }
 
-static abc_method_t* add_method(abc_file_t*file, abc_class_t*cls, multiname_t*returntype, char body)
+abc_method_t* abc_method_new(abc_file_t*file, multiname_t*returntype, char body)
 {
     /* construct method object */
     NEW(abc_method_t,m);
@@ -200,7 +200,7 @@ abc_method_t* abc_class_getconstructor(abc_class_t*cls, multiname_t*returntype)
     if(cls->constructor) {
         return cls->constructor;
     }
-    abc_method_t* m = add_method(cls->file, cls, returntype, 1);
+    abc_method_t* m = abc_method_new(cls->file, returntype, 1);
     cls->constructor = m;
     return m;
 }
@@ -210,7 +210,7 @@ abc_method_t* abc_class_getstaticconstructor(abc_class_t*cls, multiname_t*return
     if(cls->static_constructor) {
         return cls->static_constructor;
     }
-    abc_method_t* m = add_method(cls->file, cls, returntype, 1);
+    abc_method_t* m = abc_method_new(cls->file, returntype, 1);
     cls->static_constructor = m;
     return m;
 }
@@ -227,7 +227,8 @@ trait_t*trait_new(int type, multiname_t*name, int data1, int data2, constant_t*v
     trait->value = v;
     return trait;
 }
-trait_t*trait_new_member(multiname_t*type, multiname_t*name,constant_t*v)
+
+trait_t*trait_new_member(trait_list_t**traits, multiname_t*type, multiname_t*name,constant_t*v)
 {
     int kind = TRAIT_SLOT;
     trait_t*trait = malloc(sizeof(trait_t));
@@ -236,9 +237,13 @@ trait_t*trait_new_member(multiname_t*type, multiname_t*name,constant_t*v)
     trait->attributes = kind&0xf0;
     trait->name = name;
     trait->type_name = type;
+   
+    trait->slot_id = list_length(*traits)+1;
+    trait_list_t*l = *traits;
+    list_append_(traits, trait);
     return trait;
 }
-trait_t*trait_new_method(multiname_t*name, abc_method_t*m)
+trait_t*trait_new_method(trait_list_t**traits, multiname_t*name, abc_method_t*m)
 {
     int type = TRAIT_METHOD;
     trait_t*trait = malloc(sizeof(trait_t));
@@ -247,28 +252,27 @@ trait_t*trait_new_method(multiname_t*name, abc_method_t*m)
     trait->attributes = type&0xf0;
     trait->name = name;
     trait->method = m;
+    
+    /* start assigning traits at position #1.
+       Weird things happen when assigning slot 0- slot 0 and 1 seem
+       to be identical */
+    trait->slot_id = list_length(*traits)+1;
+    list_append_(traits, trait);
     return trait;
 }
 
 abc_method_t* abc_class_method(abc_class_t*cls, multiname_t*returntype, multiname_t*name)
 {
     abc_file_t*file = cls->file;
-    abc_method_t* m = add_method(cls->file, cls, returntype, !(cls->flags&CLASS_INTERFACE));
-    m->trait = trait_new_method(multiname_clone(name), m);
-    /* start assigning traits at position #1.
-       Weird things happen when assigning slot 0- slot 0 and 1 seem
-       to be identical */
-    m->trait->slot_id = list_length(cls->traits)+1;
-    list_append(cls->traits, m->trait);
+    abc_method_t* m = abc_method_new(cls->file, returntype, !(cls->flags&CLASS_INTERFACE));
+    m->trait = trait_new_method(&cls->traits, multiname_clone(name), m);
     return m;
 }
 abc_method_t* abc_class_staticmethod(abc_class_t*cls, multiname_t*returntype, multiname_t*name)
 {
     abc_file_t*file = cls->file;
-    abc_method_t* m = add_method(cls->file, cls, returntype, !(cls->flags&CLASS_INTERFACE));
-    m->trait = trait_new_method(multiname_clone(name), m);
-    m->trait->slot_id = list_length(cls->static_traits)+1;
-    list_append(cls->static_traits, m->trait);
+    abc_method_t* m = abc_method_new(cls->file, returntype, !(cls->flags&CLASS_INTERFACE));
+    m->trait = trait_new_method(&cls->static_traits, multiname_clone(name), m);
     return m;
 }
 
@@ -277,9 +281,7 @@ trait_t* abc_class_slot(abc_class_t*cls, multiname_t*name, multiname_t*type)
     abc_file_t*file = cls->file;
     multiname_t*m_name = multiname_clone(name);
     multiname_t*m_type = multiname_clone(type);
-    trait_t*t = trait_new_member(m_type, m_name, 0);
-    t->slot_id = list_length(cls->traits)+1;
-    list_append(cls->traits, t);
+    trait_t*t = trait_new_member(&cls->traits, m_type, m_name, 0);
     return t;
 }
 trait_t* abc_class_staticslot(abc_class_t*cls, multiname_t*name, multiname_t*type)
@@ -287,9 +289,7 @@ trait_t* abc_class_staticslot(abc_class_t*cls, multiname_t*name, multiname_t*typ
     abc_file_t*file = cls->file;
     multiname_t*m_name = multiname_clone(name);
     multiname_t*m_type = multiname_clone(type);
-    trait_t*t = trait_new_member(m_type, m_name, 0);
-    t->slot_id = list_length(cls->static_traits)+1;
-    list_append(cls->static_traits, t);
+    trait_t*t = trait_new_member(&cls->static_traits, m_type, m_name, 0);
     return t;
 }
 
@@ -329,9 +329,9 @@ int abc_initscript_addClassTrait(abc_script_t*script, multiname_t*multiname, abc
     return slotid;
 }
 
-abc_script_t* abc_initscript(abc_file_t*file, multiname_t*returntype)
+abc_script_t* abc_initscript(abc_file_t*file)
 {
-    abc_method_t*m = add_method(file, 0, returntype, 1);
+    abc_method_t*m = abc_method_new(file, 0, 1);
     abc_script_t* s = malloc(sizeof(abc_script_t));
     s->method = m;
     s->traits = list_new();
@@ -395,7 +395,7 @@ static void dump_method(FILE*fo, const char*prefix,
     if(c->traits)
         traits_dump(fo, prefix, c->traits, file, methods_seen);
     fprintf(fo, "%s{\n", prefix);
-    code_dump(c->code, c->exceptions, file, prefix2, fo);
+    code_dump2(c->code, c->exceptions, file, prefix2, fo);
     fprintf(fo, "%s}\n\n", prefix);
 }
 
@@ -461,10 +461,6 @@ static trait_list_t* traits_parse(TAG*tag, pool_t*pool, abc_file_t*file)
            trait->cls = (abc_class_t*)array_getvalue(file->classes, swf_GetU30(tag));
            DEBUG printf("  class %s %d %d\n", name, trait->slot_id, trait->cls);
        } else if(kind == TRAIT_SLOT || kind == TRAIT_CONST) { // 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);
             trait->type_name = multiname_clone(pool_lookup_multiname(pool, swf_GetU30(tag)));
            int vindex = swf_GetU30(tag);
@@ -602,9 +598,9 @@ static void traits_dump(FILE*fo, const char*prefix, trait_list_t*traits, abc_fil
            int slot_id = trait->slot_id;
            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);
+           fprintf(fo, "%sslot %d: %s %s:%s %s %s\n", prefix, trait->slot_id, 
+                    kind==TRAIT_CONST?"const":"var", name, type_name, 
+                    value?"=":"", value?value:"");
             if(value) free(value);
             free(type_name);
        } else {
@@ -1484,13 +1480,15 @@ void swf_AddButtonLinks(SWF*swf, char stop_each_frame, char events)
             char buttonname[80];
             sprintf(buttonname, "::button%d", swf_GetDefineID(tag));
             multiname_t*s = multiname_fromstring(buttonname);
-            abc_class_slot(cls, multiname_fromstring(buttonname), s);
+            //abc_class_slot(cls, multiname_fromstring(buttonname), s);
+            abc_class_slot(cls, multiname_fromstring(buttonname), 
+                                multiname_fromstring("flash.display::SimpleButton"));
         }
         tag = tag->next;
     }
 
 
-    abc_script_t*s = abc_initscript(file, 0);
+    abc_script_t*s = abc_initscript(file);
     c = s->method->body;
     c->old.max_stack = 2;
     c->old.local_count = 1;
@@ -1534,3 +1532,39 @@ void swf_AddButtonLinks(SWF*swf, char stop_each_frame, char events)
     swf_WriteABC(abctag, file);
 }
 
+TAG*swf_AddAS3FontDefine(TAG*tag, U16 id, char*fontname)
+{
+    tag = swf_InsertTag(tag, ST_DOABC);
+    abc_file_t*file = abc_file_new();
+
+    //abc_class_t*cls = abc_class_new2(file, fontname, "flash.display::MovieClip");
+    //abc_class_slot(cls, multiname_fromstring(fontname), multiname_fromstring("flash.text::Font"));
+
+    abc_class_t*cls = abc_class_new2(file, fontname, "flash.text::Font");
+
+    abc_script_t*s = abc_initscript(file);
+    code_t*c = s->method->body->code;
+    c = abc_getlocal_0(c);
+    c = abc_pushscope(c);
+    c = abc_getscopeobject(c, 0);
+    c = abc_getlex(c,"flash.text::Font");
+    c = abc_pushscope(c);
+    c = abc_getlex(c,"flash.text::Font");
+    c = abc_newclass(c,cls);
+    c = abc_popscope(c);
+    c = abc_initproperty(c, fontname);
+    c = abc_returnvoid(c);
+    s->method->body->code = c;
+
+    abc_initscript_addClassTrait(s, multiname_fromstring(fontname), cls);
+    swf_WriteABC(tag, file);
+       
+    tag = swf_InsertTag(tag, ST_SYMBOLCLASS);
+    swf_SetU16(tag, 1);
+    swf_SetU16(tag, id);
+    swf_SetString(tag, fontname);
+
+    return tag;
+}
+
+