fixed code_cutlast if there's only one opcode

[swftools.git] / lib / as3 / code.c

diff --git a/lib/as3/code.c b/lib/as3/code.c
index 5ce450c..628f4d8 100644 (file)
--- a/lib/as3/code.c
+++ b/lib/as3/code.c
@@ -325,7 +325,8 @@ code_t*code_parse(TAG*tag, int len, abc_file_t*file, pool_t*pool, codelookup_t**
                 int j = swf_GetS24(tag);
                 data = (void*)(ptroff_t)j;
             } else if(*p == 's') { // string
-                data = strdup((char*)pool_lookup_string(pool, swf_GetU30(tag)));
+                string_t s = pool_lookup_string2(pool, swf_GetU30(tag));
+                data = string_dup3(&s);
             } else if(*p == 'D') { // debug
                 /*type, usually 1*/
                 U8 type = swf_GetU8(tag);
@@ -494,7 +495,7 @@ static int opcode_write(TAG*tag, code_t*c, pool_t*pool, abc_file_t*file, int len
                 skip = (c->branch->pos) - c->pos - 4;
             len += swf_SetS24(tag, skip);
         } else if(*p == 's') { // string
-            int index = pool_register_string(pool, data);
+            int index = pool_register_string2(pool, (string_t*)data);
             len += swf_SetU30(tag, index);
         } else if(*p == 'D') { // debug statement
             if(tag)
@@ -926,7 +927,9 @@ int code_dump(code_t*c, abc_exception_list_t*exceptions, abc_file_t*file, char*p
                     else
                         fprintf(fo, "%08x", c->branch);
                 } else if(*p == 's') {
-                    fprintf(fo, "\"%s\"", data);
+                    char*s = string_escape((string_t*)data);
+                    fprintf(fo, "\"%s\"", s);
+                    free(s);
                 } else if(*p == 'D') {
                     fprintf(fo, "[register %02x=%s]", (ptroff_t)c->data[1], (char*)c->data[0]);
                 } else if(*p == 'S') {
@@ -1045,3 +1048,106 @@ code_t* code_append(code_t*code, code_t*toappend)
     return code_end(toappend);
 }
 
+lookupswitch_t*lookupswitch_dup(lookupswitch_t*l)
+{
+    lookupswitch_t*n = malloc(sizeof(lookupswitch_t));
+    fprintf(stderr, "Error: lookupswitch dupping not supported yet\n");
+    n->targets = list_clone(l->targets);
+    return 0;
+}
+
+code_t*code_dup(code_t*c)
+{
+    if(!c) return 0;
+
+    while(c->prev) c = c->prev;
+
+    code_t*last = 0;
+    while(c) {
+        NEW(code_t, n);
+        memcpy(n, c, sizeof(code_t));
+
+        opcode_t*op = opcode_get(c->opcode);
+        if(c->branch) {
+            fprintf(stderr, "Error: Can't duplicate branching code\n");
+            return 0;
+        }
+        char*p = op?op->params:"";
+        int pos=0;
+        while(*p) {
+            if(*p == '2') { //multiname
+                c->data[pos] = multiname_clone(c->data[pos]);
+            } else if(*p == 's') {
+                c->data[pos] = string_dup3(c->data[pos]);
+            } else if(*p == 'D') {
+                c->data[pos] = strdup(c->data[pos]);
+            } else if(*p == 'f') {
+                double old = *(double*)c->data[pos];
+                c->data[pos] = malloc(sizeof(double));
+                *(double*)c->data[pos] = old;
+            } else if(strchr("S", *p)) {
+                c->data[pos] = lookupswitch_dup(c->data[pos]);
+            }
+            p++;pos++;
+        }
+
+        n->prev = last;
+        if(last) {
+            last->next = n;
+        }
+        last = n;
+        c = c->next;
+    }
+    return last;
+}
+
+code_t*code_cutlast(code_t*c)
+{
+    if(!c) return c;
+    assert(!c->next);
+    code_t*prev = c->prev;
+    c->prev = 0;
+    if(prev)
+        prev->next=0;
+    code_free(c);
+    return prev;
+}
+
+code_t* cut_last_push(code_t*c)
+{
+    while(c) {
+        if(!c) break;
+        opcode_t*op = opcode_get(c->opcode);
+        /* cut conversion type operations */
+        if(op->stack_minus == -1 && op->stack_plus == 1 && !(op->flags)) {
+            c = code_cutlast(c);
+            continue;
+        }
+        /* cut any type of push */
+        else if(op->stack_minus == 0 && op->stack_plus == 1 && !(op->flags)) {
+            return code_cutlast(c);
+        }
+        /* cut register lookups */
+        else if(c->opcode == OPCODE_GETLOCAL ||
+           c->opcode == OPCODE_GETLOCAL_0 ||
+           c->opcode == OPCODE_GETLOCAL_1 ||
+           c->opcode == OPCODE_GETLOCAL_2 ||
+           c->opcode == OPCODE_GETLOCAL_3) {
+            return code_cutlast(c);
+        }
+        /* discard function call values */
+        else if(c->opcode == OPCODE_CALLPROPERTY) {
+            c->opcode = OPCODE_CALLPROPVOID;
+            return c;
+        } else if(c->opcode == OPCODE_CALLSUPER) {
+            c->opcode = OPCODE_CALLSUPERVOID;
+            return c;
+        }
+        else
+            break;
+    }
+    c = abc_pop(c);
+    return c;
+}
+
+