return newstr;
}
-char* namespace_to_string(namespace_t*ns)
+char* namespace_tostring(namespace_t*ns)
{
if(!ns)
return strdup("NULL");
if(!strcmp(a, "")) access=0x16;
else if(!strcmp(a, "undefined")) access=0x08; // public??
else if(!strcmp(a, "package")) access=0x16;
+ else if(!strcmp(a, "public")) access=0x16;
else if(!strcmp(a, "packageinternal")) access=0x17;
else if(!strcmp(a, "protected")) access=0x18;
else if(!strcmp(a, "explicit")) access=0x19;
set->namespaces = list_new();
return set;
}
-char* namespace_set_to_string(namespace_set_t*set)
+char* namespace_set_tostring(namespace_set_t*set)
{
if(!set)
return strdup("NULL");
int l = 0;
namespace_list_t*lns = set->namespaces;
while(lns) {
- char*s = namespace_to_string(lns->namespace);
+ char*s = namespace_tostring(lns->namespace);
l += strlen(s)+1;
free(s);
lns = lns->next;
strcpy(desc, "{");
lns = set->namespaces;
while(lns) {
- char*s = namespace_to_string(lns->namespace);
+ char*s = namespace_tostring(lns->namespace);
strcat(desc, s);
free(s);
lns = lns->next;
{
NEW(multiname_t,m);
m->type = QNAME;
- m->ns = namespace_clone(ns);
+ if(!ns) {
+ m->ns = namespace_new_packageinternal("");
+ } else {
+ m->ns = namespace_clone(ns);
+ }
m->name = strdup(name);
return m;
}
char* access2str(int type)
{
if(type==0x08) return "access08";
- else if(type==0x16) return "package";
+ else if(type==0x16) return "public";
else if(type==0x17) return "packageinternal";
else if(type==0x18) return "protected";
else if(type==0x19) return "explicit";
m->type==MULTINAMEL || m->type==MULTINAMELA;
}
-char* multiname_to_string(multiname_t*m)
+char* multiname_tostring(multiname_t*m)
{
char*mname = 0;
if(!m)
} else if(m->type==RTQNAMELA) {
mname = strdup("<rt,l,attr>");
} else if(m->type==MULTINAME || m->type==MULTINAMEA) {
- char*s = namespace_set_to_string(m->namespace_set);
+ char*s = namespace_set_tostring(m->namespace_set);
mname = malloc(strlen(s)+namelen+16);
if(m->type == MULTINAME)
strcpy(mname,"<multi>");
strcat(mname, name);
free(s);
} else if(m->type==MULTINAMEL || m->type==MULTINAMELA) {
- char*s = namespace_set_to_string(m->namespace_set);
+ char*s = namespace_set_tostring(m->namespace_set);
mname = malloc(strlen(s)+16);
if(m->type == MULTINAMEL)
strcpy(mname,"<l,multi>");
if(m->namespace_set) {
namespace_set_destroy(m->namespace_set);m->namespace_set = 0;
}
+ m->type=0;
free(m);
}
}
NEW(constant_t,c);
c->type = type;
if(NS_TYPE(c->type)) {
- c->ns = pool_lookup_namespace(pool, index);
+ c->ns = namespace_clone(pool_lookup_namespace(pool, index));
} else if(c->type == CONSTANT_INT) {
- c->i = pool_lookup_int(pool, index);
+ c->i = pool_lookup_int(pool, index);
} else if(c->type == CONSTANT_UINT) {
- c->u = pool_lookup_uint(pool, index);
+ c->u = pool_lookup_uint(pool, index);
} else if(c->type == CONSTANT_FLOAT) {
- c->f = pool_lookup_float(pool, index);
+ c->f = pool_lookup_float(pool, index);
} else if(c->type == CONSTANT_STRING) {
- c->s = pool_lookup_string(pool, index);
+ c->s = strdup(pool_lookup_string(pool, index));
} else if(UNIQUE_CONSTANT(c->type)) {
// ok
} else {
}
return c;
}
-char* constant_to_string(constant_t*c)
+char* constant_tostring(constant_t*c)
{
if(!c)
return 0;
- char buf[30];
+ char buf[32];
if(NS_TYPE(c->type)) {
- return namespace_to_string(c->ns);
+ return namespace_tostring(c->ns);
} else if(c->type == CONSTANT_INT) {
sprintf(buf, "%d", c->i);
return strdup(buf);
sprintf(buf, "%u", c->u);
return strdup(buf);
} else if(c->type == CONSTANT_FLOAT) {
+ char buf[1024];
sprintf(buf, "%f", c->f);
return strdup(buf);
} else if(c->type == CONSTANT_STRING) {
return 0;
if(NS_TYPE(c->type)) {
assert(c->ns);
+ /*if(c->type!=c->ns->access) {
+ printf("%02x<->%02x\n", c->type, c->ns->access);
+ }*/
assert(c->type == c->ns->access);
return pool_register_namespace(pool, c->ns);
} else if(c->type == CONSTANT_INT) {
int pool_register_string(pool_t*pool, const char*s)
{
if(!s) return 0;
- int pos = array_append_if_new(pool->x_strings, s, 0);
+ ptroff_t l = strlen(s);
+ int pos = array_append_if_new(pool->x_strings, s, (void*)l);
assert(pos!=0);
return pos;
}
{
if(!n) return 0;
int pos = array_append_if_new(pool->x_multinames, n, 0);
- if(pos==0) {
- *(int*)0=0xdead;
- }
assert(pos!=0);
return pos;
}
return 0;
int i = array_find(pool->x_namespaces, ns);
if(i<=0) {
- char*s = namespace_to_string(ns);
+ char*s = namespace_tostring(ns);
fprintf(stderr, "Couldn't find namespace \"%s\" %08x in constant pool\n", s, ns);
free(s);
return 0;
return 0;
int i = array_find(pool->x_namespace_sets, set);
if(i<=0) {
- char*s = namespace_set_to_string(set);
+ char*s = namespace_set_tostring(set);
fprintf(stderr, "Couldn't find namespace_set \"%s\" in constant pool\n", s);
free(s);
return 0;
return 0;
int i = array_find(pool->x_multinames, name);
if(i<=0) {
- char*s = multiname_to_string(name);
+ char*s = multiname_tostring(name);
fprintf(stderr, "Couldn't find multiname \"%s\" in constant pool\n", s);
free(s);
return 0;
{
return (char*)array_getkey(pool->x_strings, i);
}
+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);
+}
namespace_t*pool_lookup_namespace(pool_t*pool, int i)
{
return (namespace_t*)array_getkey(pool->x_namespaces, i);
DEBUG printf("%d ints\n", num_ints);
int t;
for(t=1;t<num_ints;t++) {
- S32 v = swf_GetS30(tag);
+ S32 v = swf_GetABCS32(tag);
DEBUG printf("int %d) %d\n", t, v);
array_append(pool->x_ints, &v, 0);
}
int num_uints = swf_GetU30(tag);
DEBUG printf("%d uints\n", num_uints);
for(t=1;t<num_uints;t++) {
- U32 v = swf_GetU30(tag);
+ U32 v = swf_GetABCU32(tag);
DEBUG printf("uint %d) %d\n", t, v);
array_append(pool->x_uints, &v, 0);
}
char*s = malloc(len+1);
swf_GetBlock(tag, s, len);
s[len] = 0;
- array_append(pool->x_strings, s, 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);
}
name = array_getkey(pool->x_strings, namenr);
namespace_t*ns = namespace_new(type, name);
array_append(pool->x_namespaces, ns, 0);
- DEBUG printf("%d) %02x \"%s\"\n", t, type, namespace_to_string(ns));
+ DEBUG printf("%d) %02x \"%s\"\n", t, type, namespace_tostring(ns));
namespace_destroy(ns);
}
int num_sets = swf_GetU30(tag);
list_append(nsset->namespaces, namespace_clone(ns));
}
array_append(pool->x_namespace_sets, nsset, 0);
- DEBUG printf("set %d) %s\n", t, namespace_set_to_string(nsset));
+ DEBUG printf("set %d) %s\n", t, namespace_set_tostring(nsset));
namespace_set_destroy(nsset);
}
} else {
printf("can't parse type %d multinames yet\n", m.type);
}
- DEBUG printf("multiname %d) %s\n", t, multiname_to_string(&m));
+ DEBUG printf("multiname %d) %s\n", t, multiname_tostring(&m));
array_append(pool->x_multinames, &m, 0);
}
}
However when actually using zero strings as empty namespaces, the
flash player breaks.*/
//if(ns->name && ns->name[0])
- array_append_if_new(pool->x_strings, ns->name, 0);
+ pool_register_string(pool, ns->name);
}
//pool_register_int(pool, 15);
swf_SetU30(tag, pool->x_ints->num>1?pool->x_ints->num:0);
for(t=1;t<pool->x_ints->num;t++) {
S32 val = *(int*)array_getkey(pool->x_ints, t);
- swf_SetS30(tag, val);
+ swf_SetABCS32(tag, val);
}
swf_SetU30(tag, pool->x_uints->num>1?pool->x_uints->num:0);
for(t=1;t<pool->x_uints->num;t++) {
- swf_SetU30(tag, *(unsigned int*)array_getkey(pool->x_uints, t));
+ swf_SetABCU32(tag, *(unsigned int*)array_getkey(pool->x_uints, t));
}
swf_SetU30(tag, pool->x_floats->num>1?pool->x_floats->num:0);
for(t=1;t<pool->x_floats->num;t++) {
}
swf_SetU30(tag, pool->x_strings->num>1?pool->x_strings->num:0);
for(t=1;t<pool->x_strings->num;t++) {
- swf_SetU30String(tag, array_getkey(pool->x_strings, t));
+ string_t str = pool_lookup_string2(pool, t);
+ swf_SetU30String(tag, str.str, str.len);
}
swf_SetU30(tag, pool->x_namespaces->num>1?pool->x_namespaces->num:0);
for(t=1;t<pool->x_namespaces->num;t++) {