X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fas3%2Fcode.c;h=aef16ed5398569ae36a88ef2ed395e3f377ef7e1;hb=75d341a689529da3879676403e43667008ac5820;hp=2ca708211d8882def61fc68d5e6bd10f6aad7995;hpb=efd896238ad87db0f89b98f1c153c3df6e3d35c2;p=swftools.git

diff --git a/lib/as3/code.c b/lib/as3/code.c
index 2ca7082..aef16ed 100644
--- a/lib/as3/code.c
+++ b/lib/as3/code.c
@@ -200,7 +200,8 @@ opcode_t opcodes[]={
 {0x53, "applytype", "n",       -1, 1, 0, OP_STACK_ARGS},
 
 /* dummy instruction. Warning: this one is not actually supported by flash */
-{0xff, "__break__", "",             0, 0, 0, OP_RETURN},
+{0xfe, "__continue__", "s",           0, 0, 0, OP_RETURN},
+{0xff, "__break__", "s",            0, 0, 0, OP_RETURN},
 };
 
 static U8 op2index[256] = {254};
@@ -325,7 +326,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 +496,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 +928,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,13 +1049,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;
-    prev->next=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;
+}
+
+