if(!str)
return strdup("NULL");
int len=0;
- unsigned const char*s=str;
+ unsigned const char*s=(unsigned const char*)str;
while(*s) {
if(*s<10) {
len+=2; // \d
}
char*newstr = malloc(len+1);
char*dest = newstr;
- s=str;
+ s=(unsigned const char*)str;
while(*s) {
if(*s<9) {
dest+=sprintf(dest, "\\%d", *s);
char*s = escape_string(ns->name);
char*string = (char*)malloc(strlen(access)+strlen(s)+7);
if(!s)
- sprintf(string, "[%s]NULL", access, s);
+ sprintf(string, "[%s]NULL", access);
else if(!*s)
- sprintf(string, "[%s]\"\"", access, s);
+ sprintf(string, "[%s]\"\"", access);
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);
}
else if(type==0x19) return "explicit";
else if(type==0x1A) return "staticprotected";
else if(type==0x05) return "private";
+ else if(type==0x00) return "any";
else {
fprintf(stderr, "Undefined access type %02x\n", type);
return "undefined";
char*name = m->name?escape_string(m->name):strdup("*");
int namelen = strlen(name);
- if(m->type==QNAME || m->type==QNAMEA) {
- char*nsname = escape_string(m->ns->name);
+ if(m->type==QNAME || m->type==QNAMEA || m->type==POSTFIXTYPE) {
+ char*nsname = m->ns?escape_string(m->ns->name):strdup("NULL");
mname = malloc(strlen(nsname)+namelen+32);
strcpy(mname, "<q");
if(m->type == QNAMEA)
strcat(mname, ",attr");
- strcat(mname, ">[");
- strcat(mname,access2str(m->ns->access));
- strcat(mname, "]");
+ strcat(mname, ">");
+ if(m->ns) {
+ strcat(mname,"[");
+ strcat(mname,access2str(m->ns->access));
+ strcat(mname, "]");
+ }
strcat(mname, nsname);
free(nsname);
strcat(mname, "::");
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) {
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 {
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);
- dict_t*d = dict_new2(array->entry2pos->key_type);
+ 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 -------------------------------------
{
if(!ns) return 0;
int pos = array_append_or_increase(pool->x_namespaces, ns);
- assert(pos!=0);
+ assert(pos!=0 || ns->access==ZERONAMESPACE);
return pos;
}
int pool_register_namespace_set(pool_t*pool, namespace_set_t*set)
{
int i = array_find(pool->x_ints, &x);
if(i<=0) {
- fprintf(stderr, "Couldn't find int \"%d\" in constant pool\n", x);
+ fprintf(stderr, "Couldn't find int \"%f\" in constant pool\n", x);
return 0;
}
return i;
if(!ns)
return 0;
int i = array_find(pool->x_namespaces, ns);
- if(i<=0) {
+ if(i<0) {
char*s = namespace_tostring(ns);
- fprintf(stderr, "Couldn't find namespace \"%s\" %08x in constant pool\n", s, ns);
+ fprintf(stderr, "Couldn't find namespace \"%s\" %08x in constant pool\n", s, (int)ns);
free(s);
return 0;
}
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);
+ fprintf(stderr, "Couldn't find string \"%s\" in constant pool\n", str);
return 0;
}
return i;
return (multiname_t*)array_getkey(pool->x_multinames, i);
}
+static namespace_t zeronamespace={ZERONAMESPACE,"*"};
pool_t*pool_new()
{
NEW(pool_t, p);
array_append(p->x_uints, 0, 0);
array_append(p->x_floats, 0, 0);
array_append(p->x_strings, 0, 0);
- array_append(p->x_namespaces, 0, 0);
+ array_append(p->x_namespaces, &zeronamespace, 0);
array_append(p->x_namespace_sets, 0, 0);
array_append(p->x_multinames, 0, 0);
return p;
DEBUG printf("%d strings\n", num_strings);
for(t=1;t<num_strings;t++) {
int len = swf_GetU30(tag);
- string_t s = string_new(&tag->data[tag->pos], len);
+ string_t s = string_new((char*)&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);
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);
m.ns = (namespace_t*)array_getkey(pool->x_namespaces, namespace_index);
+ if(!m.ns) {
+ fprintf(stderr, "Error: Illegal reference to namespace #%d in constant pool.\n", namespace_index);
+ }
int name_index = swf_GetU30(tag);
if(name_index) // 0 = '*' (any)
m.name = pool_lookup_string(pool, name_index);
} 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);
}
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);
+ if(flags&1) fprintf(fo, "\n");
}
fprintf(fo, "%d namespaces\n", pool->x_namespaces->num);
for(t=1;t<pool->x_namespaces->num;t++) {