From f674f67572814639b77ef5337590d719bda36c3e Mon Sep 17 00:00:00 2001 From: kramm Date: Mon, 24 Nov 2008 16:12:33 +0000 Subject: [PATCH] replaced vindex/vkind fields with constant_t, do codestat calculation during writing --- lib/as3/abc.c | 196 +++++++++++++++++++++++++++++++++++++++------------------ lib/as3/abc.h | 14 ++++- 2 files changed, 146 insertions(+), 64 deletions(-) diff --git a/lib/as3/abc.c b/lib/as3/abc.c index b37dea8..5b2f91c 100644 --- a/lib/as3/abc.c +++ b/lib/as3/abc.c @@ -43,40 +43,37 @@ int abc_RegisterPrivateNameSpace(abc_file_t*file, const char*name); static char* params_to_string(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_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; @@ -228,7 +225,7 @@ abc_method_body_t* abc_class_staticconstructor(abc_class_t*cls, char*returntype, 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 +234,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) @@ -264,31 +271,36 @@ abc_method_body_t* abc_class_method(abc_class_t*cls, char*returntype, char*name, 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*file = cls->file; - multiname_t*m = multiname_fromstring(multiname); - list_append(cls->traits, trait_new(TRAIT_SLOT, m, slot, 0, 0, 0)); + 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*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*file = script->file; - multiname_t*m = multiname_fromstring(multiname); - trait_t*trait = trait_new(TRAIT_CLASS, m, slotid, 0, 0, 0); + 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*file, char*returntype, int num_params, ...) @@ -305,7 +317,7 @@ abc_script_t* abc_initscript(abc_file_t*file, char*returntype, int num_params, . 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) { @@ -315,7 +327,7 @@ static void dump_method(FILE*fo, const char*prefix, const char*type, const char* 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); + 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 +336,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->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) - 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,6 +357,9 @@ 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; } @@ -361,8 +376,7 @@ static trait_list_t* traits_parse(TAG*tag, pool_t*pool, abc_file_t*file) } for(t=0;tname = multiname_clone(pool_lookup_multiname(pool, swf_GetU30(tag))); // always a QName (ns,name) @@ -393,11 +407,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_to_string(trait->value)); } else { fprintf(stderr, "Can't parse trait type %d\n", kind); } @@ -468,9 +483,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,7 +498,7 @@ 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) { @@ -505,14 +521,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*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); @@ -583,13 +603,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); 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 +617,7 @@ void* swf_DumpABC(FILE*fo, void*code, char*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); - dump_traits(fo, prefix, s->traits, file); + traits_dump(fo, prefix, s->traits, file); } return file; } @@ -613,7 +633,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) { @@ -654,11 +674,14 @@ void* swf_ReadABC(TAG*tag) if(m->flags&0x08) { /* 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) { @@ -859,18 +882,14 @@ void swf_WriteABC(TAG*abctag, void*code) 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; - 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; - } - list_free(m->exceptions);m->exceptions=0; } - + + /* 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; @@ -892,7 +911,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 +998,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->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->stats->max_scope_depth+ + c->init_scope_depth); code_write(tag, c->code, pool, file); @@ -984,6 +1029,13 @@ 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;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 -- @@ -1007,7 +1059,6 @@ void swf_WriteABC(TAG*abctag, void*code) 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); @@ -1028,6 +1079,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 +1134,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); @@ -1310,7 +1380,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); } diff --git a/lib/as3/abc.h b/lib/as3/abc.h index f74a459..998f34a 100644 --- a/lib/as3/abc.h +++ b/lib/as3/abc.h @@ -40,9 +40,18 @@ DECLARE_LIST(exception); DECLARE(trait); + +#define METHOD_NEED_ARGUMENTS 1 +#define METHOD_NEED_ACTIVATION 2 +#define METHOD_NEED_REST 4 +#define METHOD_HAS_OPTIONAL 8 +#define METHOD_SET_DXNS 0x40 +#define METHOD_HAS_PARAM_NAMES 0x80 + struct _abc_method { multiname_t*return_type; multiname_list_t*parameters; + constant_list_t*optional_parameters; const char*name; U8 flags; abc_method_body_t*body; @@ -71,6 +80,7 @@ abc_file_t*abc_file_new(); #define TRAIT_FUNCTION 5 #define TRAIT_CONST 6 + struct _trait { unsigned char kind; unsigned char attributes; @@ -87,8 +97,7 @@ struct _trait { multiname_t*type_name; int data2; }; - int vindex; - int vkind; + constant_t*value; }; struct _abc_class { @@ -147,6 +156,7 @@ struct _abc_method_body { trait_list_t*traits; int index; // filled in during writing + codestats_t*stats; //filled in during writing }; typedef struct _abc_script { -- 1.7.10.4