const double*v2=_v2;
if(!v1 || !v2)
return v1==v2;
- return *v1==*v2;
+
+ if(*v1==*v2) return 1;
+ if(*v1!=*v1 && *v2!=*v2) return 1; //both values are NaN
+ return 0;
}
type_t float_type = {
else if(!*s)
sprintf(string, "[%s]\"\"", access, s);
else
- sprintf(string, "[%s]", access, s);
-
+ sprintf(string, "[%s]%s", access, s);
free(s);
return string;
}
ns->name = name?strdup(name):0;
return ns;
}
-namespace_t* namespace_new_undefined(const char*name) {
+namespace_t* namespace_new_namespace(const char*name) {
return namespace_new(0x08, name); // public?
}
namespace_t* namespace_new_package(const char*name) {
void namespace_destroy(namespace_t*n)
{
if(n) {
- free(n->name);n->name=0;
+ free((char*)n->name);n->name=0;
n->access=0x00;
free(n);
}
char* access2str(int type)
{
- if(type==0x08) return "access08";
+ if(type==0x08) return "namespace";
else if(type==0x16) return "public";
else if(type==0x17) return "packageinternal";
else if(type==0x18) return "protected";
char*name = m->name?escape_string(m->name):strdup("*");
int namelen = strlen(name);
- if(m->type==QNAME || m->type==QNAMEA) {
+ if(m->type==QNAME || m->type==QNAMEA || m->type==POSTFIXTYPE) {
char*nsname = escape_string(m->ns->name);
mname = malloc(strlen(nsname)+namelen+32);
strcpy(mname, "<q");
strcat(mname,s);
free(s);
} else {
- fprintf(stderr, "Invalid multiname type: %02x\n", m->type);
+ return strdup("<invalid>");
}
free(name);
return mname;
// ------------------------------- constants -------------------------------------
-#define NS_TYPE(x) ((x) == 0x08 || (x) == 0x16 || (x) == 0x17 || (x) == 0x18 || \
- (x) == 0x19 || (x) == 0x1a || (x) == 0x05)
-
#define UNIQUE_CONSTANT(x) ((x) == CONSTANT_TRUE || (x) == CONSTANT_FALSE || (x) == CONSTANT_NULL || (x) == CONSTANT_UNDEFINED)
constant_t* constant_new_int(int i)
c->type = CONSTANT_FLOAT;
return c;
}
-constant_t* constant_new_string(char*s)
+constant_t* constant_new_string(const char*s)
{
NEW(constant_t,c);
c->s = string_new4(s);
c->type = CONSTANT_UNDEFINED;
return c;
}
+constant_t* constant_clone(constant_t*other)
+{
+ if(!other) return 0;
+ constant_t*c = malloc(sizeof(constant_t));
+ memcpy(c, other, sizeof(constant_t));
+ if(NS_TYPE(c->type)) {
+ c->ns = namespace_clone(other->ns);
+ } else if(c->type == CONSTANT_STRING) {
+ c->s = string_dup3(other->s);
+ }
+ return c;
+}
constant_t* constant_fromindex(pool_t*pool, int index, int type)
{
if(!index) {
char* constant_tostring(constant_t*c)
{
if(!c)
- return 0;
+ return strdup("NULL");
char buf[32];
if(NS_TYPE(c->type)) {
return namespace_tostring(c->ns);
return pool_register_float(pool, c->f);
} else if(c->type == CONSTANT_STRING) {
return pool_register_string2(pool, c->s);
+ } else if(c->type == CONSTANT_UNDEFINED) {
+ /* write undefined with index 0 (and no type). Otherwise, the FlashPlayer
+ seems to throw an "attempt to read out of bounds" exception */
+ return 0;
} else if(!constant_has_index(c)) {
return 1;
} else {
}
free(c);
}
+// --------------------------- optimizing -----------------------------------
+
+static int array_append_or_increase(array_t*array, void*key)
+{
+ int pos = array_find(array, key);
+ if(pos>=0) {
+ array->d[pos].data++;
+ return pos;
+ } else {
+ return array_append(array, key, 0);
+ }
+}
+static int compare_arrayentry(const void*_c1, const void*_c2)
+{
+ const array_entry_t*c1 = _c1;
+ const array_entry_t*c2 = _c2;
+ return c2->data - c1->data;
+}
+
+static void* nodup(const void*o) {return (void*)o;}
+
+static void reshuffle_array(array_t*array)
+{
+ qsort(array->d+1, array->num-1, sizeof(array->d[0]), compare_arrayentry);
+ type_t* old_type = array->entry2pos->key_type;
+ type_t old_type_nodup = *old_type;
+ old_type_nodup.dup = nodup;
+ dict_t*d = dict_new2(&old_type_nodup);
+ dict_destroy_shallow(array->entry2pos);
+ array->entry2pos = d;
+ int t;
+ for(t=0;t<array->num;t++) {
+ dict_put(array->entry2pos, array->d[t].name, (void*)(ptroff_t)(t+1));
+ }
+ d->key_type = old_type;
+
+}
+
// ------------------------------- pool -------------------------------------
int pool_register_uint(pool_t*p, unsigned int i)
{
- int pos = array_append_if_new(p->x_uints, &i, 0);
+ int pos = array_append_or_increase(p->x_uints, &i);
assert(pos!=0);
return pos;
}
int pool_register_int(pool_t*p, int i)
{
- int pos = array_append_if_new(p->x_ints, &i, 0);
+ int pos = array_append_or_increase(p->x_ints, &i);
assert(pos!=0);
return pos;
}
int pool_register_float(pool_t*p, double d)
{
- int pos = array_append_if_new(p->x_floats, &d, 0);
+ int pos = array_append_or_increase(p->x_floats, &d);
assert(pos!=0);
return pos;
}
{
if(!str) return 0;
string_t s = string_new2(str);
- int pos = array_append_if_new(pool->x_strings, &s, 0);
+ int pos = array_append_or_increase(pool->x_strings, &s);
assert(pos!=0);
return pos;
}
int pool_register_string2(pool_t*pool, string_t*s)
{
if(!s || !s->str) return 0;
- int pos = array_append_if_new(pool->x_strings, s, 0);
+ int pos = array_append_or_increase(pool->x_strings, s);
assert(pos!=0);
return pos;
}
int pool_register_namespace(pool_t*pool, namespace_t*ns)
{
if(!ns) return 0;
- int pos = array_append_if_new(pool->x_namespaces, ns, 0);
+ int pos = array_append_or_increase(pool->x_namespaces, ns);
assert(pos!=0);
return pos;
}
int pool_register_namespace_set(pool_t*pool, namespace_set_t*set)
{
if(!set) return 0;
- int pos = array_append_if_new(pool->x_namespace_sets, set, 0);
+ int pos = array_append_or_increase(pool->x_namespace_sets, set);
assert(pos!=0);
return pos;
}
int pool_register_multiname(pool_t*pool, multiname_t*n)
{
if(!n) return 0;
- int pos = array_append_if_new(pool->x_multinames, n, 0);
+ int pos = array_append_or_increase(pool->x_multinames, n);
assert(pos!=0);
return pos;
}
{
if(!name) return 0;
multiname_t*n = multiname_fromstring(name);
- int pos = array_append_if_new(pool->x_multinames, n, 0);
+ int pos = array_append_or_increase(pool->x_multinames, n);
multiname_destroy(n);
assert(pos!=0);
return pos;
return p;
}
+void pool_optimize(pool_t*p)
+{
+ reshuffle_array(p->x_ints);
+ reshuffle_array(p->x_uints);
+ reshuffle_array(p->x_floats);
+ reshuffle_array(p->x_strings);
+ reshuffle_array(p->x_namespaces);
+ reshuffle_array(p->x_namespace_sets);
+ reshuffle_array(p->x_multinames);
+}
+
#define DEBUG if(0)
//#define DEBUG
for(t=1;t<num_multinames;t++) {
multiname_t m;
memset(&m, 0, sizeof(multiname_t));
+
+ /*int s;
+ for(s=0;s<8;s++)
+ printf("0x%02x ", tag->data[tag->pos+s]);
+ printf("\n");*/
+
m.type = swf_GetU8(tag);
if(m.type==0x07 || m.type==0x0d) {
int namespace_index = swf_GetU30(tag);
} else if(m.type==0x1b || m.type==0x1c) {
int namespace_set_index = swf_GetU30(tag);
m.namespace_set = (namespace_set_t*)array_getkey(pool->x_namespace_sets, namespace_set_index);
+ } else if(m.type==0x1d) {
+ int v1 = swf_GetU30(tag); //multiname
+ int v2 = swf_GetU30(tag); //counter?
+ int v3 = swf_GetU30(tag); //multiname
+ // e.g. Vector<int> ... we only store the parent object
+ m = *(multiname_t*)array_getkey(pool->x_multinames, v1);
} else {
printf("can't parse type %d multinames yet\n", m.type);
}
}
}
+void pool_dump(pool_t*pool, FILE*fo, char flags)
+{
+ int t;
+ fprintf(fo, "%d integers\n", pool->x_ints->num);
+ for(t=1;t<pool->x_ints->num;t++) {
+ S32 val = *(int*)array_getkey(pool->x_ints, t);
+ int freq = (int)(ptroff_t)array_getvalue(pool->x_ints, t);
+ if(flags&1) fprintf(fo, "%5d %d) %d\n", freq, t, val);
+ }
+ fprintf(fo, "%d unsigned integers\n", pool->x_uints->num);
+ for(t=1;t<pool->x_uints->num;t++) {
+ U32 val = *(unsigned int*)array_getkey(pool->x_uints, t);
+ int freq = (int)(ptroff_t)array_getvalue(pool->x_uints, t);
+ if(flags&1) fprintf(fo, "%5d %d) %d\n", freq, t, val);
+ }
+ fprintf(fo, "%d floats\n", pool->x_floats->num);
+ for(t=1;t<pool->x_floats->num;t++) {
+ double d = pool_lookup_float(pool, t);
+ int freq = (int)(ptroff_t)array_getvalue(pool->x_floats, t);
+ if(flags&2) fprintf(fo, "%5d %d) %f\n", freq, t, d);
+ }
+ fprintf(fo, "%d strings\n", pool->x_strings->num);
+ for(t=1;t<pool->x_strings->num;t++) {
+ string_t str = pool_lookup_string2(pool, t);
+ int freq = (int)(ptroff_t)array_getvalue(pool->x_strings, t);
+ if(flags&1) fprintf(fo, "%5d %d) ", freq, t);
+ if(flags&1) fwrite(str.str, str.len, 1, fo);
+ if(flags&1) fprintf(fo, "\n", t);
+ }
+ fprintf(fo, "%d namespaces\n", pool->x_namespaces->num);
+ for(t=1;t<pool->x_namespaces->num;t++) {
+ namespace_t*ns= (namespace_t*)array_getkey(pool->x_namespaces, t);
+ char*s = namespace_tostring(ns);
+ int freq = (int)(ptroff_t)array_getvalue(pool->x_namespaces, t);
+ if(flags&1) fprintf(fo, "%5d %d) %s\n", freq, t, s);
+ free(s);
+ }
+ fprintf(fo, "%d namespace sets\n", pool->x_namespace_sets->num);
+ for(t=1;t<pool->x_namespace_sets->num;t++) {
+ namespace_set_t*set = (namespace_set_t*)array_getkey(pool->x_namespace_sets, t);
+ char*s = namespace_set_tostring(set);
+ int freq = (int)(ptroff_t)array_getvalue(pool->x_namespace_sets, t);
+ if(flags&1) fprintf(fo, "%5d %d) %s\n", freq, t, s);
+ free(s);
+ }
+
+ fprintf(fo, "%d multinames\n", pool->x_multinames->num);
+ for(t=1;t<pool->x_multinames->num;t++) {
+ multiname_t*m = (multiname_t*)array_getkey(pool->x_multinames, t);
+ char*s = multiname_tostring(m);
+ int freq = (int)(ptroff_t)array_getvalue(pool->x_multinames, t);
+ if(flags&1) fprintf(fo, "%5d %d) %s\n", freq, t, s);
+ free(s);
+ }
+}
+
void pool_write(pool_t*pool, TAG*tag)
{
int t;