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]%s", access, s);
free(s);
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, "::");
// ------------------------------- 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 {
{
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);
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);
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);
- int v2 = swf_GetU30(tag);
- int v3 = swf_GetU30(tag);
- //printf("%02x %02x %02x\n", v1, v2, v3);
- m.type = 0x07;
- m.namespace_set = 0;
- m.name = pool_lookup_string(pool, v1);
- m.ns = pool_lookup_namespace(pool, v2);
- /* not sure what to do with v3-
- it's definitely not a namespace */
+ 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++) {
} else {
assert(m->type!=0x07 && m->type!=0x0d);
}
+
if(m->name) {
assert(m->type==0x09 || m->type==0x0e || m->type==0x07 || m->type==0x0d || m->type==0x0f || m->type==0x10);
int i = pool_find_string(pool, m->name);
if(i<0) fprintf(stderr, "internal error: unregistered name\n");
swf_SetU30(tag, i);
} else {
- assert(m->type!=0x09 && m->type!=0x0e && m->type!=0x07 && m->type!=0x0d && m->type!=0x0f && m->type!=0x10);
+ if(m->type == 0x09) {
+ swf_SetU30(tag, 0);
+ }
+ assert(m->type!=0x0e && m->type!=0x07 && m->type!=0x0d && m->type!=0x0f && m->type!=0x10);
}
if(m->namespace_set) {
assert(m->type==0x09 || m->type==0x0e || m->type==0x1c || m->type==0x1b);