X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fas3%2Fabc.c;h=5b2f91cea7a8da9a6c8cc3c29828ac8567a28926;hb=f674f67572814639b77ef5337590d719bda36c3e;hp=27c43319e1ab7ab62e58e0aabcd51b66fb3aa27b;hpb=4e990c50e8224621ac557f21ed3bd937ba0bbff3;p=swftools.git diff --git a/lib/as3/abc.c b/lib/as3/abc.c index 27c4331..5b2f91c 100644 --- a/lib/as3/abc.c +++ b/lib/as3/abc.c @@ -24,187 +24,11 @@ #include #include #include "../rfxswf.h" +#include "../q.h" #include "abc.h" char stringbuffer[2048]; -dict_t* dict_new() { - dict_t*d = malloc(sizeof(dict_t)); - memset(d, 0, sizeof(dict_t)); - return d; -} - -void dict_free(dict_t*dict) { - if(dict->d) - free(dict->d);dict->d = 0; - free(dict); -} - -const char*dict_getstr(dict_t*dict, int nr) { - if(nr > dict->num || nr<0) { - printf("error: reference to string %d in dict\n"); - return 0; - } - return dict->d[nr].name; -} -char*dict_getdata(dict_t*dict, int nr) { - if(nr > dict->num || nr<0) { - printf("error: reference to string %d in dict\n"); - return 0; - } - return dict->d[nr].data; -} -int dict_append(dict_t*dict, const char*name, void*data) { - while(dict->size <= dict->num) { - dict->size += 64; - if(!dict->d) { - dict->d = malloc(sizeof(dict_entry_t)*dict->size); - } else { - dict->d = realloc(dict->d, sizeof(dict_entry_t)*dict->size); - } - } - if(name) { - dict->d[dict->num].name = strdup(name); - } else { - dict->d[dict->num].name = 0; - } - dict->d[dict->num].data = data; - return dict->num++; -} -int dict_find(dict_t*dict, const char*name) -{ - if(!name) - name = ""; - int t; - for(t=0;tnum;t++) { - if(dict->d[t].name && !strcmp(dict->d[t].name,name)) - return t; - } - return -1; -} -int dict_find2(dict_t*dict, const char*name, void*data) -{ - if(!name) - name = ""; - int t; - for(t=0;tnum;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; - return pos; - } - return dict_append(dict, name, 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) -{ - U32 shift = 0; - U32 s = 0; - while(1) { - U8 b = swf_GetU8(tag); - s|=(b&127)<data[tag->pos]; - swf_GetU32(tag); - swf_GetU32(tag); - return value; -} - - -typedef struct _opcode -{ - unsigned char opcode; - char*name; - char*params; -} opcode_t; - -/* 2 = multiname - m = method - n = number of params - i = method info - b = byte - s = short - c = class - s = string - S = switch -*/ - 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); @@ -213,473 +37,72 @@ 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); +/* TODO: switch to a datastructure with just values */ +#define NO_KEY "" -opcode_t opcodes[]={ -{0xa0, "add", ""}, -{0xc5, "add_i", ""}, -{0x86, "atype", "2"}, -{0x87, "astypelate", ""}, -{0xA8, "bitand", ""}, -{0x97, "bitnot", ""}, -{0xa9, "bitor", ""}, -{0xaa, "bitxor", ""}, -{0x41, "call", "n"}, -{0x43, "callmethod", "mn"}, -{0x4c, "callproplex", "2n"}, -{0x46, "callproperty", "2n"}, -{0x4f, "callpropvoid", "2n"}, -{0x44, "callstatic", "in"}, -{0x45, "callsuper", "2n"}, -{0x4e, "callsupervoid", "2n"}, -{0x78, "checkfilter", ""}, -{0x80, "coerce", "m"}, -{0x82, "coerce_a", ""}, -{0x85, "coerce_s", ""}, -{0x42, "construct", "n"}, -{0x4a, "constructprop", "2n"}, -{0x49, "constructsuper", "n"}, -{0x76, "convert_b", ""}, -{0x73, "convert_i", ""}, -{0x75, "convert_d", ""}, -{0x77, "convert_o", ""}, -{0x74, "convert_u", ""}, -{0x70, "convert_s", ""}, -{0xef, "debug", "bsbu"}, -{0xf1, "debugfile", "s"}, -{0xf0, "debugline", "u"}, -{0x94, "declocal", "u"}, -{0xc3, "declocal_i", "u"}, -{0x93, "decrement", ""}, -{0xc1, "decrement_i", ""}, -{0x6a, "deleteproperty", "2"}, -{0xa3, "divide", ""}, -{0x2a, "dup", ""}, -{0x06, "dxns", "s"}, -{0x07, "dxnslate", ""}, -{0xab, "equals", ""}, -{0x72, "esc_xattr", ""}, -{0x71, "esc_xelem", ""}, -{0x5e, "findproperty", "2"}, -{0x5d, "findpropstrict", "2"}, -{0x59, "getdescendants", "2"}, -{0x64, "getglobalscope", ""}, -{0x6e, "getglobalslot", "u"}, -{0x60, "getlex", "2"}, -{0x62, "getlocal", "u"}, -{0xd0, "getlocal_0", ""}, -{0xd1, "getlocal_1", ""}, -{0xd2, "getlocal_2", ""}, -{0xd3, "getlocal_3", ""}, -{0x66, "getproperty", "2"}, -{0x65, "getscopeobject", "u"}, -{0x6c, "getslot", "u"}, -{0x04, "getsuper", "2"}, -{0xaf, "greaterequals", ""}, -{0x1f, "hasnext", ""}, -{0x32, "hasnext2", "uu"}, -{0x13, "ifeq", "j"}, -{0x12, "iffalse", "j"}, -{0x18, "ifge", "j"}, -{0x17, "ifgt", "j"}, -{0x16, "ifle", "j"}, -{0x15, "iflt", "j"}, -{0x0f, "ifnge", "j"}, -{0x0e, "ifngt", "j"}, -{0x0d, "ifnle", "j"}, -{0x0c, "ifnlt", "j"}, -{0x14, "ifne", "j"}, -{0x19, "ifstricteq", "j"}, -{0x1a, "ifstrictne", "j"}, -{0x11, "iftrue", "j"}, -{0xb4, "in", ""}, -{0x92, "inclocal", "u"}, -{0xc2, "inclocal_i", "u"}, -{0x91, "increment", ""}, -{0xc0, "increment_i", ""}, -{0x68, "initproperty", "2"}, -{0xb1, "instanceof", ""}, -{0xb2, "istype", "2"}, -{0xb3, "istypelate", ""}, -{0x10, "jump", "j"}, -{0x08, "kill", "u"}, -{0x09, "label", ""}, -{0xae, "lessequals", ""}, -{0xad, "lessthan", ""}, -{0x1b, "lookupswitch", "S"}, -{0xa5, "lshift", ""}, -{0xa4, "modulo", ""}, -{0xa2, "multiply", ""}, -{0xc7, "multiply_i", ""}, -{0x90, "negate", ""}, -{0xc4, "negate_i", ""}, -{0x57, "newactivation", ""}, -{0x56, "newarray", "u"}, -{0x5a, "newcatch", "u"}, //index into exception_info -{0x58, "newclass", "c"}, //index into class_info -{0x40, "newfunction", "u"}, //index into method_info -{0x55, "newobject", "u"}, -{0x1e, "nextname", ""}, -{0x23, "nextvalue", ""}, -{0x02, "nop", ""}, -{0x96, "not", ""}, -{0x29, "pop", ""}, -{0x1d, "popscope", ""}, -{0x24, "pushbyte", "b"}, -{0x2f, "pushdouble", "u"}, //index into floats -{0x27, "pushfalse", ""}, -{0x2d, "pushint", "u"}, //index into ints -{0x31, "pushnamespace", "u"}, //index into namespace -{0x28, "pushnan", ""}, -{0x20, "pushnull", ""}, -{0x30, "pushscope", ""}, -{0x25, "pushshort", "u"}, -{0x2c, "pushstring", "s"}, -{0x26, "pushtrue", ""}, -{0x2e, "pushuint", "u"}, //index into uints -{0x21, "pushundefined", ""}, -{0x1c, "pushwith", ""}, -{0x48, "returnvalue", ""}, -{0x47, "returnvoid", ""}, -{0xa6, "rshift", ""}, -{0x63, "setlocal", "u"}, -{0xd4, "setlocal_0", ""}, -{0xd5, "setlocal_1", ""}, -{0xd6, "setlocal_2", ""}, -{0xd7, "setlocal_3", ""}, -{0x6f, "setglobalshot", "u"}, -{0x61, "setproperty", "2"}, -{0x6d, "setslot", "u"}, -{0x05, "setsuper", "2"}, -{0xac, "strictequals", ""}, -{0xa1, "subtract", ""}, -{0xc6, "subtract_i", ""}, -{0x2b, "swap", ""}, -{0x03, "throw", ""}, -{0x95, "typeof", ""}, -{0xa7, "urshift", ""}, -{0xb0, "xxx", ""}, -}; - -int swf_GetU24(TAG*tag) -{ - int b1 = swf_GetU8(tag); - int b2 = swf_GetU8(tag); - int b3 = swf_GetU8(tag); - return b3<<16|b2<<8|b1; -} -int swf_GetS24(TAG*tag) -{ - int b1 = swf_GetU8(tag); - int b2 = swf_GetU8(tag); - int b3 = swf_GetU8(tag); - if(b3&0x80) { - return -1-((b3<<16|b2<<8|b1)^0xffffff); - } else { - return b3<<16|b2<<8|b1; - } -} -static int parse_code(TAG*tag, int len, abc_file_t*pool, char*prefix) +static char* params_to_string(multiname_list_t*list) { - int end=tag->pos+len; - while(tag->posmultinames, swf_GetU30(tag)); - printf("%s", m); - } else if(*p == 'm') { - int n = swf_GetU30(tag); - printf("[method%d]", n); - } 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->classname); - } else if(*p == 'i') { - int n = swf_GetU30(tag); - printf("[methodbody%d]", n); - } else if(*p == 'u') { - int n = swf_GetU30(tag); - printf("%d", n); - } else if(*p == 'b') { - int b = swf_GetU8(tag); - printf("%02x", b); - } else if(*p == 'j') { - printf("%d", swf_GetS24(tag)); - } else if(*p == 's') { - const char*s = dict_getstr(pool->strings, swf_GetU30(tag)); - printf("\"%s\"", s); - } else if(*p == 'S') { - swf_GetU24(tag); //default - int num = swf_GetU30(tag)+1; - int t; - for(t=0;tpos!=end) { - printf("Read beyond end of ABC Bytecode\n"); - return 0; - } - 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; - } - + multiname_list_t*l; + 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->abc_multiname); + while(l) { + names[n] = multiname_to_string(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; } -static void dump_method(const char*prefix, const char*type, const char*name, int nr, abc_file_t*pool) -{ - if(nr >= pool->methods->num) { - printf("Invalid method number: %d\n", nr); - return; - } - abc_method_t*m = (abc_method_t*)dict_getdata(pool->methods, nr); - - 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\n", prefix); -} - //#define DEBUG #define DEBUG if(0) -static void parse_metadata(TAG*tag, abc_file_t*pool) +static void parse_metadata(TAG*tag, abc_file_t*file, pool_t*pool) { int t; int num_metadata = swf_GetU30(tag); + DEBUG printf("%d metadata\n"); for(t=0;tstrings, swf_GetU30(tag)); + const char*entry_name = pool_lookup_string(pool, swf_GetU30(tag)); int num = swf_GetU30(tag); int s; - DEBUG printf(" %s\n", name); + DEBUG printf(" %s\n", entry_name); + array_t*items = array_new(); for(s=0;sstrings, swf_GetU30(tag)); - const char*value = dict_getstr(pool->strings, swf_GetU30(tag)); + int i1 = swf_GetU30(tag); + int i2 = swf_GetU30(tag); + char*key = i1?pool_lookup_string(pool, i1):""; + char*value = i2?pool_lookup_string(pool, i2):""; DEBUG printf(" %s=%s\n", key, value); + array_append(items, key, strdup(value)); } - } -} - -#define TRAIT_SLOT 0 -#define TRAIT_METHOD 1 -#define TRAIT_GETTER 2 -#define TRAIT_SETTER 3 -#define TRAIT_CLASS 4 -#define TRAIT_FUNCTION 5 -#define TRAIT_CONST 6 - -static dict_t* traits_parse(TAG*tag, abc_file_t*pool) -{ - int num_traits = swf_GetU30(tag); - dict_t*traits = dict_new(); - int t; - if(num_traits) { - DEBUG printf("%d traits\n", num_traits); - } - - for(t=0;tname_index = swf_GetU30(tag); - const char*name = dict_getstr(pool->multinames, trait->name_index); - U8 kind = trait->type = swf_GetU8(tag); - U8 attributes = kind&0xf0; - kind&=0x0f; - DEBUG printf(" trait %d) %s type=%02x\n", t, name, kind); - if(kind == 1 || kind == 2 || kind == 3) { // method / getter / setter - trait->disp_id = swf_GetU30(tag); - trait->nr = swf_GetU30(tag); - DEBUG printf(" method/getter/setter\n"); - } else if(kind == 5) { // function - trait->slot_id = swf_GetU30(tag); - trait->nr = swf_GetU30(tag); - } else if(kind == 4) { // class - trait->slot_id = swf_GetU30(tag); - 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); - if(trait->vindex) { - trait->vkind = swf_GetU8(tag); - } - DEBUG printf(" slot %s %d %s (vindex=%d)\n", name, trait->slot_id, type_name, trait->vindex); - } else { - printf(" can't parse trait type %d\n", kind); - return 0; - } - if(attributes&0x40) { - int num = swf_GetU30(tag); - int s; - for(s=0;snum; - int t; - for(t=0;tmultinames, trait->name_index); - U8 kind = trait->type; - U8 attributes = kind&0xf0; - kind&=0x0f; - if(kind == TRAIT_METHOD) { - dump_method(prefix, "method", name, trait->nr, pool); - } else if(kind == TRAIT_GETTER) { - dump_method(prefix, "getter", name, trait->nr, pool); - } else if(kind == TRAIT_SETTER) { - dump_method(prefix, "setter", name, trait->nr, pool); - } else if(kind == TRAIT_FUNCTION) { // function - dump_method(prefix, "function", name, trait->nr, pool); - } else if(kind == TRAIT_CLASS) { // class - abc_class_t*cls = (abc_class_t*)dict_getdata(pool->classes, trait->cls); - 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->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); - } else { - printf(" can't dump trait type %d\n", kind); - } + array_append(file->metadata, entry_name, items); } } @@ -695,153 +118,39 @@ abc_file_t*abc_file_new() { abc_file_t*f = malloc(sizeof(abc_file_t)); memset(f, 0, sizeof(abc_file_t)); + f->metadata = array_new(); - f->ints = dict_new(); - dict_append(f->ints, 0, (void*)(ptroff_t)0); - f->uints = dict_new(); - dict_append(f->uints, 0, (void*)(ptroff_t)0); - f->floats = dict_new(); - dict_append(f->floats, 0, 0); - f->strings = dict_new(); - dict_append(f->strings, "----", 0); - f->namespaces = dict_new(); - dict_append(f->namespaces, "----", 0); - f->namespace_sets = dict_new(); - dict_append(f->namespace_sets, "----", 0); - f->sets = dict_new(); - dict_append(f->sets, "----", 0); - f->multinames = dict_new(); - dict_append(f->multinames, "----", 0); - - // abc_file - - f->methods = dict_new(); - f->classes = dict_new(); - f->scripts = dict_new(); - f->method_bodies = dict_new(); + f->methods = array_new(); + f->classes = array_new(); + f->scripts = array_new(); + f->method_bodies = array_new(); return f; } -static abc_namespace_t* namespace_new(U8 access, const char*name) -{ - abc_namespace_t*ns = malloc(sizeof(abc_namespace_t)); - memset(ns, 0, sizeof(abc_namespace_t)); - - 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); - } - 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"); - } - 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"); - } - } - - abc_multiname_t*m = malloc(sizeof(abc_multiname_t)); - memset(m, 0, sizeof(abc_multiname_t)); - - 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); -} - - #define CLASS_SEALED 1 #define CLASS_FINAL 2 #define CLASS_INTERFACE 4 #define CLASS_PROTECTED_NS 8 -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(pool->classes, 0, c); - c->pool = pool; - c->classname = strdup(classname); - c->superclass = superclass?strdup(superclass):0; +abc_class_t* abc_class_new(abc_file_t*file, multiname_t*classname, multiname_t*superclass) { + + NEW(abc_class_t,c); + array_append(file->classes, NO_KEY, c); + + c->file = file; + c->classname = classname; + c->superclass = superclass; c->flags = 0; - c->iinit = -1; - c->static_constructor_index = -1; - c->traits = dict_new(); + c->constructor = 0; + c->static_constructor = 0; + c->traits = list_new(); return c; } +abc_class_t* abc_class_new2(abc_file_t*pool, char*classname, char*superclass) +{ + return abc_class_new(pool, multiname_fromstring(classname), multiname_fromstring(superclass)); +} void abc_class_sealed(abc_class_t*c) { @@ -857,37 +166,40 @@ void abc_class_interface(abc_class_t*c) } void abc_class_protectedNS(abc_class_t*c, char*namespace) { - c->protectedNS = namespace; + c->protectedNS = namespace_new_protected(namespace); c->flags |= CLASS_PROTECTED_NS; } +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, char*returntype, int num_params, va_list va) { /* construct code (method body) object */ - 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->pool = pool; - c->traits = dict_new(); + NEW(abc_method_body_t,c); + array_append(file->method_bodies, NO_KEY, c); + c->file = file; + c->traits = list_new(); + c->code = 0; /* construct method object */ - abc_method_t* m = malloc(sizeof(abc_method_t)); - memset(m, 0, sizeof(abc_method_t)); - m->index = dict_append(pool->methods, 0, m); + NEW(abc_method_t,m); + array_append(file->methods, NO_KEY, m); + if(returntype && strcmp(returntype, "void")) { - m->return_type = multiname_fromstring(pool, returntype); + m->return_type = multiname_fromstring(returntype); } else { m->return_type = 0; } int t; for(t=0;tparameters, multiname_fromstring(pool, param)); + list_append(m->parameters, multiname_fromstring(param)); } /* crosslink the two objects */ - m->method_body_index = c->index; + m->body = c; c->method = m; return c; @@ -897,9 +209,9 @@ abc_method_body_t* abc_class_constructor(abc_class_t*cls, char*returntype, int n { 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->iinit = c->index; + cls->constructor = c->method; return c; } @@ -907,135 +219,413 @@ abc_method_body_t* abc_class_staticconstructor(abc_class_t*cls, char*returntype, { 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_index = c->index; + cls->static_constructor = c->method; return c; } -abc_trait_t*trait_new(int type, int name_index, int data1, int data2, int vindex, int vkind) +trait_t*trait_new(int type, multiname_t*name, int data1, int data2, constant_t*v) { - 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_t*trait = malloc(sizeof(trait_t)); + memset(trait, 0, sizeof(trait_t)); + trait->kind = type&0x0f; + trait->attributes = type&0xf0; + 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) +{ + int type = TRAIT_METHOD; + trait_t*trait = malloc(sizeof(trait_t)); + memset(trait, 0, sizeof(trait_t)); + trait->kind = type&0x0f; + trait->attributes = type&0xf0; + trait->name = name; + trait->method = m; 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; + 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); - dict_append(cls->traits, 0, trait_new(TRAIT_METHOD, multiname_index(pool, name), 0, c->method->index, 0, 0)); + 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; - int i = multiname_index(pool, name); - dict_append(cls->traits, 0, trait_new(TRAIT_SLOT, i, slot, multiname_index(pool, multiname), 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; - 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_file_t*file = code->file; + multiname_t*m = multiname_fromstring(multiname); + 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; - 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_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, 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_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 = dict_new(); - s->pool = pool; - dict_append(pool->scripts, 0, s); + s->traits = list_new(); + s->file = file; + array_append(file->scripts, NO_KEY, s); va_end(va); return s; } -void swf_SetU30(TAG*tag, U32 u) +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) { - do { - swf_SetU8(tag, (u&~0x7f?0x80:0) | (u&0x7F)); - u>>=7; - } while(u); + char*return_type = 0; + if(m->return_type) + return_type = multiname_to_string(m->return_type); + else + return_type = strdup("void"); + char*paramstr = params_to_string(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; + + abc_method_body_t*c = m->body; + if(!c) { + return; + } + + fprintf(fo, "%s[stack:%d locals:%d scope:%d-%d flags:%02x]\n", prefix, c->max_stack, c->local_count, c->init_scope_depth, c->max_scope_depth, c->method->flags); + + char prefix2[80]; + sprintf(prefix2, "%s ", prefix); + if(c->traits) + 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); } -void swf_SetU30String(TAG*tag, const char*str) + +static void traits_free(trait_list_t*traits) { - int l = strlen(str); - swf_SetU30(tag, l); - swf_SetBlock(tag, (void*)str, l); + trait_list_t*t = traits; + while(t) { + if(t->trait->name) { + multiname_destroy(t->trait->name);t->trait->name = 0; + } + 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 void write_traits(abc_file_t*pool, TAG*tag, dict_t*traits) +static trait_list_t* traits_parse(TAG*tag, pool_t*pool, abc_file_t*file) +{ + int num_traits = swf_GetU30(tag); + trait_list_t*traits = list_new(); + int t; + if(num_traits) { + DEBUG printf("%d traits\n", num_traits); + } + + for(t=0;tname = 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); + U8 kind = swf_GetU8(tag); + U8 attributes = kind&0xf0; + kind&=0x0f; + trait->kind = kind; + trait->attributes = attributes; + DEBUG printf(" trait %d) %s type=%02x\n", t, name, kind); + if(kind == TRAIT_METHOD || kind == TRAIT_GETTER || kind == TRAIT_SETTER) { // method / getter / setter + trait->disp_id = swf_GetU30(tag); + trait->method = (abc_method_t*)array_getvalue(file->methods, swf_GetU30(tag)); + DEBUG printf(" method/getter/setter\n"); + } else if(kind == TRAIT_FUNCTION) { // function + trait->slot_id = swf_GetU30(tag); + trait->method = (abc_method_t*)array_getvalue(file->methods, swf_GetU30(tag)); + } else if(kind == TRAIT_CLASS) { // class + trait->slot_id = swf_GetU30(tag); + 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); + if(vindex) { + int vkind = swf_GetU8(tag); + trait->value = constant_fromindex(pool, vindex, vkind); + } + DEBUG printf(" slot %s %d %s (%s)\n", name, trait->slot_id, trait->type_name->name, constant_to_string(trait->value)); + } else { + fprintf(stderr, "Can't parse trait type %d\n", kind); + } + if(attributes&0x40) { + int num = swf_GetU30(tag); + int s; + for(s=0;sTRAIT_CONST) { + fprintf(stderr, "Can't parse trait type %d\n", kind); + } + if(attributes&0x40) { + int s, num = swf_GetU30(tag); + for(s=0;snum); + swf_SetU30(tag, list_length(traits)); int s; - for(s=0;snum;s++) { - abc_trait_t*trait = (abc_trait_t*)dict_getdata(traits, s); - swf_SetU30(tag, trait->name_index); - swf_SetU8(tag, trait->type); + while(traits) { + trait_t*trait = traits->trait; + + swf_SetU30(tag, pool_register_multiname(pool, trait->name)); + swf_SetU8(tag, trait->kind|trait->attributes); + 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); + + if(trait->kind == TRAIT_CLASS) { + swf_SetU30(tag, trait->cls->index); + } else if(trait->kind == TRAIT_GETTER || + trait->kind == TRAIT_SETTER || + trait->kind == TRAIT_METHOD) { + swf_SetU30(tag, trait->method->index); + } else if(trait->kind == TRAIT_SLOT || + trait->kind == TRAIT_CONST) { + int index = pool_register_multiname(pool, trait->type_name); + swf_SetU30(tag, index); + } else { + swf_SetU30(tag, trait->data2); + } + + if(trait->kind == TRAIT_SLOT || trait->kind == TRAIT_CONST) { + int vindex = constant_get_index(pool, trait->value); + swf_SetU30(tag, vindex); + if(vindex) { + swf_SetU8(tag, trait->value->type); } } + if(trait->attributes&0x40) { + // metadata + swf_SetU30(tag, 0); + } + traits = traits->next; } } -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) +static void traits_dump(FILE*fo, const char*prefix, trait_list_t*traits, abc_file_t*file) { - /* FIXME: might create duplicates */ - return dict_append_if_new2(pool->namespaces, ns->name, ns); + int t; + while(traits) { + trait_t*trait = traits->trait; + char*name = multiname_to_string(trait->name); + U8 kind = trait->kind; + U8 attributes = trait->attributes; + if(kind == TRAIT_METHOD) { + abc_method_t*m = trait->method; + dump_method(fo, prefix, "method", name, m, file); + } else if(kind == TRAIT_GETTER) { + abc_method_t*m = trait->method; + dump_method(fo, prefix, "getter", name, m, file); + } else if(kind == TRAIT_SETTER) { + abc_method_t*m = trait->method; + dump_method(fo, prefix, "setter", name, m, file); + } else if(kind == TRAIT_FUNCTION) { // function + abc_method_t*m = trait->method; + dump_method(fo, prefix, "function", name, m, file); + } else if(kind == TRAIT_CLASS) { // class + abc_class_t*cls = trait->cls; + if(!cls) { + 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); + char*value = constant_to_string(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); + } + free(name); + traits=traits->next; + } } -static inline abc_multiname_t*multiname_lookup(abc_file_t*pool, int i) +void* swf_DumpABC(FILE*fo, void*code, char*prefix) { - return (abc_multiname_t*)dict_getdata(pool->multinames, i); + abc_file_t* file = (abc_file_t*)code; + + if(file->name) { + fprintf(fo, "%s#\n", prefix); + fprintf(fo, "%s#name: %s\n", prefix, file->name); + fprintf(fo, "%s#\n", prefix); + } + + int t; + for(t=0;tmetadata->num;t++) { + const char*entry_name = array_getkey(file->metadata, t); + fprintf(fo, "%s#Metadata \"%s\":\n", prefix, entry_name); + int s; + array_t*items = (array_t*)array_getvalue(file->metadata, t); + for(s=0;snum;s++) { + fprintf(fo, "%s# %s=%s\n", prefix, array_getkey(items, s), array_getvalue(items,s)); + } + fprintf(fo, "%s#\n", prefix); + } + + for(t=0;tclasses->num;t++) { + abc_class_t*cls = (abc_class_t*)array_getvalue(file->classes, t); + char prefix2[80]; + sprintf(prefix2, "%s ", prefix); + + fprintf(fo, "%s", prefix); + if(cls->flags&1) fprintf(fo, "sealed "); + 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); + fprintf(fo, "protectedNS(%s) ", s); + free(s); + } + + char*classname = multiname_to_string(cls->classname); + fprintf(fo, "class %s", classname); + free(classname); + if(cls->superclass) { + char*supername = multiname_to_string(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); + fprintf(fo, " %s", s); + free(s); + ilist = ilist->next; + } + ilist->next; + } + if(cls->flags&0xf0) + fprintf(fo, "extra flags=%02x\n", cls->flags&0xf0); + fprintf(fo, "%s{\n", prefix); + + if(cls->static_constructor) + dump_method(fo, prefix2,"staticconstructor", "", cls->static_constructor, file); + traits_dump(fo, prefix2, cls->static_constructor_traits, file); + + char*n = multiname_to_string(cls->classname); + if(cls->constructor) + dump_method(fo, prefix2, "constructor", n, cls->constructor, file); + free(n); + traits_dump(fo, prefix2,cls->traits, file); + fprintf(fo, "%s}\n", prefix); + } + fprintf(fo, "%s\n", prefix); + + for(t=0;tscripts->num;t++) { + abc_script_t*s = (abc_script_t*)array_getvalue(file->scripts, t); + dump_method(fo, prefix,"initmethod", "init", s->method, file); + traits_dump(fo, prefix, s->traits, file); + } + return file; } void* swf_ReadABC(TAG*tag) { - abc_file_t* pool = abc_file_new(); + abc_file_t* file = abc_file_new(); + pool_t*pool = pool_new(); swf_SetTagPos(tag, 0); int t; @@ -1043,179 +633,69 @@ void* swf_ReadABC(TAG*tag) U32 abcflags = swf_GetU32(tag); DEBUG printf("flags=%08x\n", abcflags); char*name= swf_GetString(tag); - if(*name) - printf("#name: %s\n", name); + file->name = (name&&name[0])?strdup(name):0; } 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;tints, 0, (void*)(ptroff_t)v); - } - - int num_uints = swf_GetU30(tag); - DEBUG printf("%d uints\n", num_uints); - for(t=1;tuints, 0, (void*)(ptroff_t)v); - } - - int num_floats = swf_GetU30(tag); - DEBUG printf("%d floats\n", num_floats); - for(t=1;tfloats, 0, 0); - } - - int num_strings = swf_GetU30(tag); - DEBUG printf("%d strings\n", num_strings); - for(t=1;tstrings, 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;tstrings, 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;tnamespaces, nsnr); - l += strlen(name[s])+1; - } - char*desc = malloc(l+16); - strcpy(desc, "{"); - for(s=0;snamespace_sets, desc, 0); - DEBUG printf("set %d) %s\n", t, desc); - } + pool_read(pool, tag); - int num_multinames = swf_GetU30(tag); - DEBUG printf("%d multinames\n", num_multinames); - for(t=1;ttype = 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;treturn_type = multiname_lookup(pool, return_type_index); - m->index = t; + if(return_type_index) + m->return_type = multiname_clone(pool_lookup_multiname(pool, return_type_index)); + else + m->return_type = 0; int s; for(s=0;sparameters, multiname_lookup(pool, type_index)); + + /* type_index might be 0, which probably means "..." (varargs) */ + multiname_t*param = type_index?multiname_clone(pool_lookup_multiname(pool, type_index)):0; + list_append(m->parameters, param); } int namenr = swf_GetU30(tag); - m->name = ""; if(namenr) - m->name = dict_getstr(pool->strings, namenr); + m->name = strdup(pool_lookup_string(pool, namenr)); + else + m->name = strdup(""); 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 */ + /* TODO optional parameters */ + m->optional_parameters = list_new(); int num = swf_GetU30(tag); int s; for(s=0;soptional_parameters, c); } } if(m->flags&0x80) { /* debug information- not used by avm2 */ - abc_multiname_list_t*l = m->parameters; + multiname_list_t*l = m->parameters; while(l) { - m->name = dict_getstr(pool->strings, swf_GetU30(tag)); + char*name = pool_lookup_string(pool, swf_GetU30(tag)); l = l->next; } } - dict_append(pool->methods, m->name, m); + array_append(file->methods, NO_KEY, m); } - parse_metadata(tag, pool); + parse_metadata(tag, file, pool); /* skip classes, and scripts for now, and do the real parsing later */ int num_classes = swf_GetU30(tag); @@ -1224,49 +704,51 @@ void* swf_ReadABC(TAG*tag) for(t=0;tclasses, 0, cls); DEBUG printf("class %d\n", t); swf_GetU30(tag); //classname swf_GetU30(tag); //supername + + array_append(file->classes, NO_KEY, cls); + 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; + cls->interfaces = 0; for(s=0;smultinames, 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); + multiname_t* m = multiname_clone(pool_lookup_multiname(pool, interface_index)); + list_append(cls->interfaces, m); + DEBUG printf(" class %d interface: %s\n", t, m->name); } - cls->iinit = swf_GetU30(tag); - cls->traits = traits_parse(tag, pool); + swf_GetU30(tag); //iinit + traits_skip(tag); } for(t=0;tclasses, t); - cls->static_constructor_index = swf_GetU30(tag); // cinit - cls->static_constructor_traits = traits_parse(tag, pool); + abc_class_t*cls = (abc_class_t*)array_getvalue(file->classes, t); + int cinit = swf_GetU30(tag); + cls->static_constructor = (abc_method_t*)array_getvalue(file->methods, cinit); + traits_skip(tag); } int num_scripts = swf_GetU30(tag); DEBUG printf("%d scripts\n", num_scripts); for(t=0;t= pool->methods->num) { + if(methodnr >= file->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_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); @@ -1274,35 +756,37 @@ void* swf_ReadABC(TAG*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); + c->method = m; + m->body = c; - swf_CopyData(c->tag, tag, code_length); + int pos = tag->pos + code_length; + codelookup_t*codelookup = 0; + c->code = code_parse(tag, code_length, file, pool, &codelookup); + tag->pos = pos; int exception_count = swf_GetU30(tag); int s; + c->exceptions = list_new(); for(s=0;sfrom = code_atposition(codelookup, swf_GetU30(tag)); + e->to = code_atposition(codelookup, swf_GetU30(tag)); + e->target = code_atposition(codelookup, swf_GetU30(tag)); + + e->exc_type = multiname_clone(pool_lookup_multiname(pool, swf_GetU30(tag))); + e->var_name = multiname_clone(pool_lookup_multiname(pool, swf_GetU30(tag))); + //e->var_name = pool_lookup_string(pool, swf_GetU30(tag)); + //if(e->var_name) e->var_name = strdup(e->var_name); + list_append(c->exceptions, e); } - c->traits = traits_parse(tag, pool); - if(!c->traits) { - fprintf(stderr, "Can't parse code traits\n"); - return 0; - } + codelookup_free(codelookup); + c->traits = traits_parse(tag, pool, file); + 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;rtag->data[r]); - } - DEBUG printf("\n"); - dict_append(pool->method_bodies, 0, c); + array_append(file->method_bodies, NO_KEY, c); } if(tag->len - tag->pos) { fprintf(stderr, "%d unparsed bytes remaining in ABC block\n", tag->len - tag->pos); @@ -1311,258 +795,373 @@ void* swf_ReadABC(TAG*tag) swf_SetTagPos(tag, classes_pos); for(t=0;tclasses, t); + abc_class_t*cls = (abc_class_t*)array_getvalue(file->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->classname = multiname_clone(pool_lookup_multiname(pool, classname_index)); + cls->superclass = multiname_clone(pool_lookup_multiname(pool, 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); + cls->protectedNS = namespace_clone(pool_lookup_namespace(pool, 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;siinit = 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"); + int iinit = swf_GetU30(tag); + cls->constructor = (abc_method_t*)array_getvalue(file->methods, iinit); + cls->traits = traits_parse(tag, pool, file); } for(t=0;tclasses, t); /* SKIP */ swf_GetU30(tag); // cindex - traits_parse(tag, pool); // TODO: free + cls->static_constructor_traits = traits_parse(tag, pool, file); } int num_scripts2 = swf_GetU30(tag); - printf("\n"); for(t=0;tmethods, init); + abc_method_t*m = (abc_method_t*)array_getvalue(file->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); + 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; } - dump_method("","initmethod", "init", init, pool); - dump_traits("", s->traits, pool); } - return pool; + + pool_destroy(pool); + return file; } void swf_WriteABC(TAG*abctag, void*code) { - abc_file_t*pool = (abc_file_t*)code; + abc_file_t*file = (abc_file_t*)code; + pool_t*pool = pool_new(); TAG*tmp = swf_InsertTag(0,0); TAG*tag = tmp; int t; + + char need_null_method=0; + for(t=0;tclasses->num;t++) { + abc_class_t*c = (abc_class_t*)array_getvalue(file->classes, t); + if(!c->constructor || !c->static_constructor) { + need_null_method=1; + break; + } + } - swf_SetU30(tag, pool->methods->num); - for(t=0;tmethods->num;t++) { - abc_method_t*m = (abc_method_t*)dict_getdata(pool->methods, t); + abc_method_t*nullmethod = 0; + if(need_null_method) { + nullmethod = malloc(sizeof(abc_method_t)); + memset(nullmethod, 0, sizeof(abc_method_t)); + /*TODO: might be more efficient to have this at the beginning */ + array_append(file->methods, NO_KEY, nullmethod); + } + + swf_SetU30(tag, file->methods->num); + /* enumerate classes, methods and method bodies */ + for(t=0;tmethods->num;t++) { + abc_method_t*m = (abc_method_t*)array_getvalue(file->methods, t); + m->index = t; + } + for(t=0;tclasses->num;t++) { + abc_class_t*c = (abc_class_t*)array_getvalue(file->classes, t); + c->index = t; + } + for(t=0;tmethod_bodies->num;t++) { + abc_method_body_t*m = (abc_method_body_t*)array_getvalue(file->method_bodies, t); + m->index = t; + } + + /* generate code statistics */ + for(t=0;tmethod_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); + } + + for(t=0;tmethods->num;t++) { + abc_method_t*m = (abc_method_t*)array_getvalue(file->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)); + multiname_list_t*l = m->parameters; + int num_params = list_length(m->parameters); + swf_SetU30(tag, num_params); + if(m->return_type) + swf_SetU30(tag, pool_register_multiname(pool, m->return_type)); + else + swf_SetU30(tag, 0); int s; while(l) { - swf_SetU30(tag, register_multiname(pool, l->abc_multiname)); + swf_SetU30(tag, pool_register_multiname(pool, l->multiname)); l = l->next; } - swf_SetU30(tag, 0); // name - swf_SetU8(tag, 0); //flags - } - - swf_SetU30(tag, 0);//metadata + if(m->name) { + swf_SetU30(tag, pool_register_string(pool, m->name)); + } else { + swf_SetU30(tag, 0); + } + + 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_SetU30(tag, pool->classes->num); + 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 */ + swf_SetU30(tag, file->metadata->num); + for(t=0;tmetadata->num;t++) { + const char*entry_name = array_getkey(file->metadata, t); + swf_SetU30(tag, pool_register_string(pool, entry_name)); + array_t*items = (array_t*)array_getvalue(file->metadata, t); + swf_SetU30(tag, items->num); + int s; + for(s=0;snum;s++) { + int i1 = pool_register_string(pool, array_getkey(items, s)); + int i2 = pool_register_string(pool, array_getvalue(items, s)); + swf_SetU30(tag, i1); + swf_SetU30(tag, i2); + } + } - for(t=0;tclasses->num;t++) { - abc_class_t*c = (abc_class_t*)dict_getdata(pool->classes, t); + swf_SetU30(tag, file->classes->num); + for(t=0;tclasses->num;t++) { + abc_class_t*c = (abc_class_t*)array_getvalue(file->classes, t); - int classname_index = multiname_index(pool, c->classname); - int superclass_index = multiname_index(pool, c->superclass); + int classname_index = pool_register_multiname(pool, c->classname); + int superclass_index = pool_register_multiname(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); + int ns_index = pool_register_namespace(pool, c->protectedNS); 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); + swf_SetU30(tag, list_length(c->interfaces)); + multiname_list_t*interface= c->interfaces; + while(interface) { + swf_SetU30(tag, pool_register_multiname(pool, interface->multiname)); + interface = interface->next; + } + + if(!c->constructor) { + swf_SetU30(tag, nullmethod->index); + } else { + swf_SetU30(tag, c->constructor->index); + } + traits_write(pool, tag, c->traits); } - for(t=0;tclasses->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); + for(t=0;tclasses->num;t++) { + abc_class_t*c = (abc_class_t*)array_getvalue(file->classes, t); + if(!c->static_constructor) { + swf_SetU30(tag, nullmethod->index); + } else { + swf_SetU30(tag, c->static_constructor->index); + } + traits_write(pool, tag, c->static_constructor_traits); } - swf_SetU30(tag, pool->scripts->num); - for(t=0;tscripts->num;t++) { - abc_script_t*s = (abc_script_t*)dict_getdata(pool->scripts, t); + swf_SetU30(tag, file->scripts->num); + for(t=0;tscripts->num;t++) { + abc_script_t*s = (abc_script_t*)array_getvalue(file->scripts, t); swf_SetU30(tag, s->method->index); //!=t! - write_traits(pool, tag, s->traits); + traits_write(pool, tag, s->traits); } - swf_SetU30(tag, pool->method_bodies->num); - for(t=0;tmethod_bodies->num;t++) { - abc_method_body_t*c = (abc_method_body_t*)dict_getdata(pool->method_bodies, t); + swf_SetU30(tag, file->method_bodies->num); + for(t=0;tmethod_bodies->num;t++) { + 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->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->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->tag->len); - swf_SetBlock(tag, c->tag->data, c->tag->len); - swf_SetU30(tag, c->exception_count); - write_traits(pool, tag, c->traits); + swf_SetU30(tag, c->stats->max_scope_depth+ + c->init_scope_depth); + + code_write(tag, c->code, pool, file); + + swf_SetU30(tag, list_length(c->exceptions)); + exception_list_t*l = c->exceptions; + while(l) { + // warning: assumes "pos" in each code_t is up-to-date + swf_SetU30(tag, l->exception->from->pos); + swf_SetU30(tag, l->exception->to->pos); + swf_SetU30(tag, l->exception->target->pos); + swf_SetU30(tag, pool_register_multiname(pool, l->exception->exc_type)); + swf_SetU30(tag, pool_register_multiname(pool, l->exception->var_name)); + l = l->next; + } + + 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;tmethod_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; - for(t=1;tmultinames->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;tnamespaces->num;t++) { - char*namespace_name = (char*)dict_getstr(pool->namespaces, t); - dict_append_if_new(pool->strings, namespace_name, 0); + if(tag->id == ST_DOABC) { + swf_SetU32(tag, 1); // flags + swf_SetString(tag, file->name); } - swf_SetU32(tag, 1); // flags - swf_SetU8(tag, 0); //classname - swf_SetU16(tag, 0x10); //version swf_SetU16(tag, 0x2e); + + pool_write(pool, tag); + + swf_SetBlock(tag, tmp->data, tmp->len); - 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;tstrings->num;t++) { - swf_SetU30String(tag, dict_getstr(pool->strings, t)); - } - swf_SetU30(tag, pool->namespaces->num>1?pool->namespaces->num:0); - for(t=1;tnamespaces->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_DeleteTag(0, tmp); + pool_destroy(pool); +} + +void abc_file_free(abc_file_t*file) +{ + int t; + for(t=0;tmetadata->num;t++) { + array_t*items = (array_t*)array_getvalue(file->metadata, t); + int s; + for(s=0;snum;s++) { + free(array_getvalue(items, s)); + } + array_free(items); } - 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;tmultinames->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); + array_free(file->metadata); + + for(t=0;tmethods->num;t++) { + abc_method_t*m = (abc_method_t*)array_getvalue(file->methods, t); + + multiname_list_t*param = m->parameters; + while(param) { + multiname_destroy(param->multiname);param->multiname=0; + param = param->next; } - 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); + 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) { - 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); + free((void*)m->name);m->name=0; } + if(m->return_type) { + multiname_destroy(m->return_type); + } + free(m); } + array_free(file->methods); - swf_SetBlock(tag, tmp->data, tmp->len); + for(t=0;tclasses->num;t++) { + abc_class_t*cls = (abc_class_t*)array_getvalue(file->classes, t); + traits_free(cls->traits);cls->traits=0; + traits_free(cls->static_constructor_traits);cls->static_constructor_traits=0; - swf_DeleteTag(0, tmp); + if(cls->classname) { + multiname_destroy(cls->classname); + } + if(cls->superclass) { + multiname_destroy(cls->superclass); + } + + multiname_list_t*i = cls->interfaces; + while(i) { + multiname_destroy(i->multiname);i->multiname=0; + i = i->next; + } + list_free(cls->interfaces);cls->interfaces=0; + + if(cls->protectedNS) { + namespace_destroy(cls->protectedNS); + } + free(cls); + } + array_free(file->classes); + + for(t=0;tscripts->num;t++) { + abc_script_t*s = (abc_script_t*)array_getvalue(file->scripts, t); + traits_free(s->traits);s->traits=0; + free(s); + } + array_free(file->scripts); + + for(t=0;tmethod_bodies->num;t++) { + 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); + + if(file->name) { + free((void*)file->name);file->name=0; + } + + free(file); } -#include "abc_ops.c" +void swf_FreeABC(void*code) +{ + abc_file_t*file= (abc_file_t*)code; + abc_file_free(file); +} void swf_AddButtonLinks(SWF*swf, char stop_each_frame, char events) { @@ -1580,7 +1179,7 @@ void swf_AddButtonLinks(SWF*swf, char stop_each_frame, char events) 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_t*cls = abc_class_new2(file, "rfx::MainTimeline", "flash.display::MovieClip"); abc_class_protectedNS(cls, "rfx:MainTimeline"); TAG*abctag = swf_InsertTagBefore(swf, swf->firstTag, ST_DOABC); @@ -1596,9 +1195,9 @@ void swf_AddButtonLinks(SWF*swf, char stop_each_frame, char events) c->init_scope_depth = 9; c->max_scope_depth = 10; - abc_getlocal_0(c); - abc_pushscope(c); - abc_returnvoid(c); + __ getlocal_0(c); + __ pushscope(c); + __ returnvoid(c); c = abc_class_constructor(cls, 0, 0); c->max_stack = 3; @@ -1606,17 +1205,17 @@ void swf_AddButtonLinks(SWF*swf, char stop_each_frame, char events) c->init_scope_depth = 10; c->max_scope_depth = 11; - abc_debugfile(c, "constructor.as"); + debugfile(c, "constructor.as"); - abc_getlocal_0(c); - abc_pushscope(c); + __ getlocal_0(c); + __ pushscope(c); - abc_getlocal_0(c); - abc_constructsuper(c,0); + __ getlocal_0(c); + __ constructsuper(c,0); - abc_getlex(c, "[package]flash.system::Security"); - abc_pushstring(c, "*"); - abc_callpropvoid(c, "[package]::allowDomain", 1); + __ getlex(c, "[package]flash.system::Security"); + __ pushstring(c, "*"); + __ callpropvoid(c, "[package]::allowDomain", 1); if(stop_each_frame || has_buttons) { int frame = 0; @@ -1631,35 +1230,35 @@ void swf_AddButtonLinks(SWF*swf, char stop_each_frame, char events) 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); + __ findpropstrict(c,"[package]::addFrameScript"); + __ pushbyte(c,frame); + __ getlex(c,framename); + __ 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); + __ debugfile(f, "framescript.as"); + __ debugline(f, 1); + __ getlocal_0(f); + __ 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"); + __ getlex(f,buttonname); + __ getlex(f,"flash.events::MouseEvent"); + __ getproperty(f, "::CLICK"); sprintf(functionname, "::clickbutton%d", swf_GetDefineID(tag)); - abc_getlex(f,functionname); - abc_callpropvoid(f, "::addEventListener" ,2); + __ getlex(f,functionname); + __ callpropvoid(f, "::addEventListener" ,2); if(stop_each_frame) { - abc_findpropstrict(f, "[package]::stop"); - abc_callpropvoid(f, "[package]::stop", 0); + __ findpropstrict(f, "[package]::stop"); + __ callpropvoid(f, "[package]::stop", 0); } needs_framescript = 1; @@ -1669,8 +1268,8 @@ void swf_AddButtonLinks(SWF*swf, char stop_each_frame, char events) h->local_count = 2; h->init_scope_depth = 10; h->max_scope_depth = 11; - abc_getlocal_0(h); - abc_pushscope(h); + __ getlocal_0(h); + __ pushscope(h); ActionTAG*oldaction = swf_ButtonGetAction(tag); if(oldaction && oldaction->op == ACTION__GOTOFRAME) { @@ -1679,47 +1278,48 @@ void swf_AddButtonLinks(SWF*swf, char stop_each_frame, char events) fprintf(stderr, "Warning: Couldn't translate jump to frame %d to flash 9 actionscript\n", framenr); } if(!events) { - abc_findpropstrict(h,"[package]::gotoAndStop"); - abc_pushbyte(h,framenr+1); - abc_callpropvoid(h,"[package]::gotoAndStop", 1); + __ findpropstrict(h,"[package]::gotoAndStop"); + __ pushbyte(h,framenr+1); + __ callpropvoid(h,"[package]::gotoAndStop", 1); } else { char framename[80]; sprintf(framename, "frame%d", framenr); - abc_getlocal_0(h); //this - abc_findpropstrict(h, "[package]flash.events::TextEvent"); - abc_pushstring(h, "link"); - abc_pushtrue(h); - abc_pushtrue(h); - abc_pushstring(h, framename); - abc_constructprop(h,"[package]flash.events::TextEvent", 4); - abc_callpropvoid(h,"[package]::dispatchEvent", 1); + __ getlocal_0(h); //this + __ findpropstrict(h, "[package]flash.events::TextEvent"); + __ pushstring(h, "link"); + __ pushtrue(h); + __ pushtrue(h); + __ pushstring(h, framename); + __ constructprop(h,"[package]flash.events::TextEvent", 4); + __ callpropvoid(h,"[package]::dispatchEvent", 1); } } else if(oldaction && oldaction->op == ACTION__GETURL) { if(!events) { - abc_findpropstrict(h,"flash.net::navigateToURL"); - abc_findpropstrict(h,"flash.net::URLRequest"); - abc_pushstring(h,oldaction->data); //url - abc_constructprop(h,"flash.net::URLRequest", 1); - abc_callpropvoid(h,"flash.net::navigateToURL", 1); + __ findpropstrict(h,"flash.net::navigateToURL"); + __ findpropstrict(h,"flash.net::URLRequest"); + // TODO: target _blank + __ pushstring(h,oldaction->data); //url + __ constructprop(h,"flash.net::URLRequest", 1); + __ callpropvoid(h,"flash.net::navigateToURL", 1); } else { - abc_getlocal_0(h); //this - abc_findpropstrict(h, "[package]flash.events::TextEvent"); - abc_pushstring(h, "link"); - abc_pushtrue(h); - abc_pushtrue(h); - abc_pushstring(h,oldaction->data); //url - abc_constructprop(h,"[package]flash.events::TextEvent", 4); - abc_callpropvoid(h,"[package]::dispatchEvent", 1); + __ getlocal_0(h); //this + __ findpropstrict(h, "[package]flash.events::TextEvent"); + __ pushstring(h, "link"); + __ pushtrue(h); + __ pushtrue(h); + __ pushstring(h,oldaction->data); //url + __ constructprop(h,"[package]flash.events::TextEvent", 4); + __ callpropvoid(h,"[package]::dispatchEvent", 1); } } else if(oldaction) { fprintf(stderr, "Warning: Couldn't translate button code of button %d to flash 9 abc action\n", id); } - abc_returnvoid(h); + __ returnvoid(h); swf_ActionFree(oldaction); } if(tag->id == ST_SHOWFRAME) { if(f) { - abc_returnvoid(f); + __ returnvoid(f); f = 0; } frame++; @@ -1727,10 +1327,10 @@ void swf_AddButtonLinks(SWF*swf, char stop_each_frame, char events) tag = tag->next; } if(f) { - abc_returnvoid(f); + __ returnvoid(f); } } - abc_returnvoid(c); + __ returnvoid(c); tag = swf->firstTag; while(tag) { @@ -1744,42 +1344,45 @@ void swf_AddButtonLinks(SWF*swf, char stop_each_frame, char events) 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 = s->method->body; c->max_stack = 2; c->local_count = 1; c->init_scope_depth = 1; c->max_scope_depth = 9; - abc_getlocal_0(c); - abc_pushscope(c); - abc_getscopeobject(c, 0); - abc_getlex(c,"::Object"); - abc_pushscope(c); - abc_getlex(c,"flash.events::EventDispatcher"); - abc_pushscope(c); - abc_getlex(c,"flash.display::DisplayObject"); - abc_pushscope(c); - abc_getlex(c,"flash.display::InteractiveObject"); - abc_pushscope(c); - abc_getlex(c,"flash.display::DisplayObjectContainer"); - abc_pushscope(c); - abc_getlex(c,"flash.display::Sprite"); - abc_pushscope(c); - abc_getlex(c,"flash.display::MovieClip"); - abc_pushscope(c); - abc_getlex(c,"flash.display::MovieClip"); - abc_newclass(c,cls); - abc_popscope(c); - abc_popscope(c); - abc_popscope(c); - abc_popscope(c); - abc_popscope(c); - abc_popscope(c); - abc_popscope(c); - abc_initproperty(c,"rfx::MainTimeline"); - abc_returnvoid(c); + + __ getlocal_0(c); + __ pushscope(c); + __ getscopeobject(c, 0); + __ getlex(c,"::Object"); + __ pushscope(c); + __ getlex(c,"flash.events::EventDispatcher"); + __ pushscope(c); + __ getlex(c,"flash.display::DisplayObject"); + __ pushscope(c); + __ getlex(c,"flash.display::InteractiveObject"); + __ pushscope(c); + __ getlex(c,"flash.display::DisplayObjectContainer"); + __ pushscope(c); + __ getlex(c,"flash.display::Sprite"); + __ pushscope(c); + __ getlex(c,"flash.display::MovieClip"); + __ pushscope(c); + __ getlex(c,"flash.display::MovieClip"); + __ newclass(c,cls); + __ popscope(c); + __ popscope(c); + __ popscope(c); + __ popscope(c); + __ popscope(c); + __ popscope(c); + __ popscope(c); + __ initproperty(c,"rfx::MainTimeline"); + __ 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); }