+ return c;
+}
+
+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_method_body_t* c = add_method(cls->pool, cls, returntype, num_params, va);
+ va_end(va);
+ cls->iinit = c->index;
+ return c;
+}
+
+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_method_body_t* c = add_method(cls->pool, cls, returntype, num_params, va);
+ va_end(va);
+ cls->static_constructor_index = c->index;
+ return c;
+}
+
+abc_trait_t*trait_new(int type, int name_index, int data1, int data2, int vindex, int vkind)
+{
+ abc_trait_t*trait = malloc(sizeof(abc_trait_t));
+ memset(trait, 0, sizeof(abc_trait_t));
+ trait->type = type;
+ trait->name_index = name_index;
+ trait->data1 = data1;
+ trait->data2 = data2;
+ trait->vindex = vindex;
+ trait->vkind = vkind;
+ return trait;
+}
+
+abc_method_body_t* abc_class_method(abc_class_t*cls, char*returntype, char*name, int num_params, ...)
+{
+ abc_file_t*pool = cls->pool;
+ va_list va;
+ va_start(va, num_params);
+ 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(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*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_method_body_addClassTrait(abc_method_body_t*code, char*multiname, int slotid, abc_class_t*cls)
+{
+ 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);
+}
+
+/* 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_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 s;
+}
+
+void swf_SetU30(TAG*tag, U32 u)
+{
+ do {
+ swf_SetU8(tag, (u&~0x7f?0x80:0) | (u&0x7F));
+ u>>=7;
+ } while(u);
+}
+void swf_SetU30String(TAG*tag, const char*str)
+{
+ int l = strlen(str);
+ swf_SetU30(tag, l);
+ swf_SetBlock(tag, (void*)str, l);
+}
+
+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;
+
+ for(s=0;s<traits->num;s++) {
+ abc_trait_t*trait = (abc_trait_t*)dict_getdata(traits, s);
+ swf_SetU30(tag, trait->name_index);
+ swf_SetU8(tag, trait->type);
+ swf_SetU30(tag, trait->data1);
+ swf_SetU30(tag, trait->data2);
+ if(trait->type == 0) { //slot
+ swf_SetU30(tag, trait->vindex);
+ if(trait->vindex) {
+ swf_SetU8(tag, trait->vkind);
+ }
+ }
+ }
+}
+
+int register_multiname(abc_file_t*pool, abc_multiname_t*n)
+{
+ if(!n)
+ return 0;
+ /* FIXME: might create duplicates */
+ return dict_append_if_new2(pool->multinames, n->name, n);
+}
+
+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);
+}
+
+static inline abc_multiname_t*multiname_lookup(abc_file_t*pool, int i)
+{
+ return (abc_multiname_t*)dict_getdata(pool->multinames, i);
+}
+
+void* swf_ReadABC(TAG*tag)
+{
+ abc_file_t* pool = abc_file_new();
+
+ swf_SetTagPos(tag, 0);
+ U32 abcflags = swf_GetU32(tag);
+ int t;
+ DEBUG printf("flags=%08x\n", abcflags);
+ char*classname = swf_GetString(tag);
+ U32 version = swf_GetU32(tag);
+ if(version!=0x002e0010) {
+ fprintf(stderr, "Warning: unknown AVM2 version %08x\n", version);
+ }
+
+ 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);
+ 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);
+ }
+
+ 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);
+ }
+
+ 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);