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 = {
U8 type = ns->access;
access = access2str(type);
char*s = escape_string(ns->name);
- char*string = (char*)malloc(strlen(access)+strlen(s)+3);
- int l = sprintf(string, "[%s]%s", access, s);
+ char*string = (char*)malloc(strlen(access)+strlen(s)+7);
+ if(!s)
+ sprintf(string, "[%s]NULL", access, s);
+ else if(!*s)
+ sprintf(string, "[%s]\"\"", access, s);
+ else
+ sprintf(string, "[%s]", access, s);
+
free(s);
return string;
}
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";
if(m->namespace_set) {
namespace_set_destroy(m->namespace_set);m->namespace_set = 0;
}
+ m->type=0;
free(m);
}
}
constant_t* constant_new_string(char*s)
{
NEW(constant_t,c);
- c->s = strdup(s);
+ c->s = string_new4(s);
+ c->type = CONSTANT_STRING;
+ return c;
+}
+constant_t* constant_new_string2(const char*s, int len)
+{
+ NEW(constant_t,c);
+ c->s = string_new3(s, len);
c->type = CONSTANT_STRING;
return c;
}
} else if(c->type == CONSTANT_FLOAT) {
c->f = pool_lookup_float(pool, index);
} else if(c->type == CONSTANT_STRING) {
- c->s = strdup(pool_lookup_string(pool, index));
+ string_t s = pool_lookup_string2(pool, index);
+ c->s = string_dup3(&s);
} else if(UNIQUE_CONSTANT(c->type)) {
// ok
} else {
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);
sprintf(buf, "%f", c->f);
return strdup(buf);
} else if(c->type == CONSTANT_STRING) {
- return strdup(c->s);
+ /* should we escape the string? \0 bytes won't be printed */
+ return strdup_n(c->s->str,c->s->len);
} else if(c->type == CONSTANT_TRUE) {
return strdup("true");
} else if(c->type == CONSTANT_FALSE) {
} else if(c->type == CONSTANT_FLOAT) {
return pool_register_float(pool, c->f);
} else if(c->type == CONSTANT_STRING) {
- return pool_register_string(pool, c->s);
+ return pool_register_string2(pool, c->s);
} else if(!constant_has_index(c)) {
return 1;
} else {
if(!c)
return;
if(c->type == CONSTANT_STRING) {
- free(c->s);c->s=0;
+ string_free(c->s);
} else if (NS_TYPE(c->type)) {
namespace_destroy(c->ns);c->ns=0;
}
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 c1->data - c2->data;
+}
+static void reshuffle_array(array_t*array)
+{
+ qsort(array->d, array->num, sizeof(array->d[0]), compare_arrayentry);
+ dict_destroy(array->entry2pos);
+ array->entry2pos = dict_new();
+ int t;
+ for(t=0;t<array->num;t++) {
+ dict_put(array->entry2pos, array->d[t].name, (void*)(ptroff_t)(t+1));
+ }
+}
+
// ------------------------------- 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;
}
-int pool_register_string(pool_t*pool, const char*s)
+int pool_register_string(pool_t*pool, const char*str)
{
- if(!s) return 0;
- ptroff_t l = strlen(s);
- int pos = array_append_if_new(pool->x_strings, s, (void*)l);
+ if(!str) return 0;
+ string_t s = string_new2(str);
+ 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_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 i;
}
-int pool_find_string(pool_t*pool, const char*s)
+int pool_find_string(pool_t*pool, const char*str)
{
- if(!s)
+ if(!str)
return 0;
- int i = array_find(pool->x_strings, s);
+ string_t s = string_new2(str);
+ int i = array_find(pool->x_strings, &s);
if(i<=0) {
fprintf(stderr, "Couldn't find string \"%s\" in constant pool\n", s);
return 0;
if(!i) return __builtin_nan("");
return *(double*)array_getkey(pool->x_floats, i);
}
-char*pool_lookup_string(pool_t*pool, int i)
+const char*pool_lookup_string(pool_t*pool, int i)
{
- return (char*)array_getkey(pool->x_strings, i);
+ string_t*s = array_getkey(pool->x_strings, i);
+ if(!s) return 0;
+ return s->str;
}
string_t pool_lookup_string2(pool_t*pool, int i)
{
- char*s = (char*)array_getkey(pool->x_strings, i);
- int len = (int)(ptroff_t)array_getvalue(pool->x_strings, i);
- return string_new(s,len);
+ string_t*s = array_getkey(pool->x_strings, i);
+ return *s;
}
namespace_t*pool_lookup_namespace(pool_t*pool, int i)
{
p->x_ints = array_new2(&uint_type);
p->x_uints = array_new2(&uint_type);
p->x_floats = array_new2(&float_type);
- p->x_strings = array_new2(&charptr_type);
+ p->x_strings = array_new2(&stringstruct_type);
p->x_namespaces = array_new2(&namespace_type);
p->x_namespace_sets = array_new2(&namespace_set_type);
p->x_multinames = array_new2(&multiname_type);
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
DEBUG printf("%d strings\n", num_strings);
for(t=1;t<num_strings;t++) {
int len = swf_GetU30(tag);
- char*s = malloc(len+1);
- swf_GetBlock(tag, s, len);
- s[len] = 0;
- array_append(pool->x_strings, s, (void*)(ptroff_t)len);
- free(s);
- DEBUG printf("%d) \"%s\"\n", t, pool->x_strings->d[t].name);
+ string_t s = string_new(&tag->data[tag->pos], len);
+ swf_GetBlock(tag, 0, len);
+ array_append(pool->x_strings, &s, 0);
+ DEBUG printf("%d) \"%s\"\n", t, ((string_t*)array_getkey(pool->x_strings, t))->str);
}
int num_namespaces = swf_GetU30(tag);
DEBUG printf("%d namespaces\n", num_namespaces);
int namenr = swf_GetU30(tag);
const char*name = 0;
if(namenr)
- name = array_getkey(pool->x_strings, namenr);
+ name = pool_lookup_string(pool, namenr);
namespace_t*ns = namespace_new(type, name);
array_append(pool->x_namespaces, ns, 0);
DEBUG printf("%d) %02x \"%s\"\n", t, type, namespace_tostring(ns));
m.ns = (namespace_t*)array_getkey(pool->x_namespaces, namespace_index);
int name_index = swf_GetU30(tag);
if(name_index) // 0 = '*' (any)
- m.name = array_getkey(pool->x_strings, name_index);
+ m.name = pool_lookup_string(pool, name_index);
} else if(m.type==0x0f || m.type==0x10) {
int name_index = swf_GetU30(tag);
if(name_index) // 0 = '*' (any name)
- m.name = array_getkey(pool->x_strings, name_index);
+ m.name = pool_lookup_string(pool, 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);
if(name_index)
- m.name = array_getkey(pool->x_strings, name_index);
+ m.name = pool_lookup_string(pool, name_index);
m.namespace_set = (namespace_set_t*)array_getkey(pool->x_namespace_sets, namespace_set_index);
} else if(m.type==0x1b || m.type==0x1c) {
int namespace_set_index = swf_GetU30(tag);
}
}
+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);
+ if(flags&1) fprintf(fo, "%d) %d\n", 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);
+ if(flags&1) fprintf(fo, "%d) %d\n", 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);
+ if(flags&2) fprintf(fo, "%d) %f\n", 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);
+ if(flags&1) fprintf(fo, "%d) ", 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);
+ if(flags&1) fprintf(fo, "%d) %s\n", 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);
+ if(flags&1) fprintf(fo, "%d) %s\n", 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);
+ if(flags&1) fprintf(fo, "%d) %s\n", t, s);
+ free(s);
+ }
+}
+
void pool_write(pool_t*pool, TAG*tag)
{
int t;
git.asbjorn.biz / swftools.git / blobdiff