X-Git-Url: http://git.asbjorn.biz/?p=swftools.git;a=blobdiff_plain;f=lib%2Fas3%2Fcode.c;h=541ebf55ba714d532b7a0697a0efe58a0016549a;hp=8a729d4464ef74e617ad92ad2d14055958e05b84;hb=2391d7ae5d8a145a250a8b80ab8c93ba74eba030;hpb=719f26744e38f9abbcadfc132b214dfd950a79fd

diff --git a/lib/as3/code.c b/lib/as3/code.c
index 8a729d4..541ebf5 100644
--- a/lib/as3/code.c
+++ b/lib/as3/code.c
@@ -45,6 +45,7 @@
    i = u30 index into method info
    b = byte
    c = u30 index into class
+   N = u30 index into namespaces
    s = string (u30 index into strings)
    S = switch
    u = u30
@@ -166,7 +167,7 @@ opcode_t opcodes[]={
 {0x2f, "pushdouble", "f",       0, 1, 0, 0}, //index into floats
 {0x27, "pushfalse", "",         0, 1, 0, 0},
 {0x2d, "pushint", "I",          0, 1, 0, 0}, //index into ints
-{0x31, "pushnamespace", "u",    0, 1, 0, 0}, //index into namespace TODO
+{0x31, "pushnamespace", "N",    0, 1, 0, 0}, //index into namespace
 {0x28, "pushnan", "",           0, 1, 0, 0},
 {0x20, "pushnull", "",          0, 1, 0, 0},
 {0x30, "pushscope", "",        -1, 0, 1, 0},
@@ -197,28 +198,28 @@ opcode_t opcodes[]={
 {0xa7, "urshift", "",          -2, 1, 0, 0},
 
 /* opcodes not documented, but seen in the wild */
-//0x53: seen in builtin.abc
-{0x53, "applytype", "n",       -1, 1, 0, OP_STACK_ARGS},
+{0x53, "applytype", "n",       -1, 1, 0, OP_STACK_ARGS}, //seen in builtin.abc
 
-/* dummy instruction. Warning: this one is not actually supported by flash */
-{0xfe, "__continue__", "s",           0, 0, 0, OP_RETURN|OP_INTERNAL},
+/* dummy instructions. Warning: these are not actually supported by flash */
+{0xfb, "__pushpackage__", "s",      0, 1, 0, OP_INTERNAL},
+{0xfc, "__rethrow__", "",           0, 0, 0, OP_THROW|OP_INTERNAL},
+{0xfd, "__fallthrough__", "s",      0, 0, 0, OP_INTERNAL},
+{0xfe, "__continue__", "s",         0, 0, 0, OP_RETURN|OP_INTERNAL},
 {0xff, "__break__", "s",            0, 0, 0, OP_RETURN|OP_INTERNAL},
 };
 
-static U8 op2index[256] = {254};
+static opcode_t* op2op[256] = {0,0,0};
 
-opcode_t* opcode_get(U8 op)
+static inline opcode_t* opcode_get(U8 op)
 {
     int t;
-    if(op2index[0]==254) {
-        memset(op2index, 255, sizeof(op2index));
+    if(!op2op[0x02]) {
+        memset(op2op, 0, sizeof(op2op));
         for(t=0;t<sizeof(opcodes)/sizeof(opcodes[0]);t++) {
-            op2index[opcodes[t].opcode] = t;
+            op2op[opcodes[t].opcode] = &opcodes[t];
         }
     }
-    if(op2index[op]!=255)
-        return &opcodes[op2index[op]];
-    return 0;
+    return op2op[op];
 }
 
 static code_t*pos2code(code_t**bytepos, code_t*c, int pos, int len)
@@ -254,10 +255,10 @@ code_t* code_atposition(codelookup_t*l, int pos)
 
 void lookupswitch_print(lookupswitch_t*l)
 {
-    printf("default: %08x\n", l->def);
+    printf("default: %08x\n", (int)l->def);
     code_list_t*t = l->targets;
     while(t) {
-        printf("target: %08x\n", t->code);
+        printf("target: %08x\n", (int)t->code);
         t = t->next;
     }
 }
@@ -290,6 +291,7 @@ code_t*code_parse(TAG*tag, int len, abc_file_t*file, pool_t*pool, codelookup_t**
             head = code = c;
         } else {
             code->next = c;
+            c->prev = code;
             code = c;
         }
 
@@ -303,6 +305,8 @@ code_t*code_parse(TAG*tag, int len, abc_file_t*file, pool_t*pool, codelookup_t**
                 data = (void*)(ptroff_t)swf_GetU30(tag);
             } else if(*p == '2') { //multiname
                 data = multiname_clone(pool_lookup_multiname(pool, swf_GetU30(tag)));
+            } else if(*p == 'N') { //namespace
+                data = namespace_clone(pool_lookup_namespace(pool, swf_GetU30(tag)));
             } else if(*p == 'U') { //uint
                 data = (void*)(ptroff_t)pool_lookup_uint(pool, swf_GetU30(tag));
             } else if(*p == 'I') { //int
@@ -367,15 +371,15 @@ code_t*code_parse(TAG*tag, int len, abc_file_t*file, pool_t*pool, codelookup_t**
         if(c) {
             opcode_t*op = opcode_get(c->opcode);
             if(op->flags & (OP_JUMP|OP_BRANCH)) {
-                printf("%5d) %02x %s %d\n", t, tag->data[start+t], op->name, c->data[0]);
+                printf("%50d) %02x %s %d\n", t, tag->data[start+t], op->name, c->data[0]);
             } else {
-                printf("%5d) %02x %s\n", t, tag->data[start+t], op->name);
+                printf("%50d) %02x %s\n", t, tag->data[start+t], op->name);
             }
         } else {
-            printf("%5d) %02x\n", t, tag->data[start+t]);
+            printf("%50d) %02x\n", t, tag->data[start+t]);
         }
     }
-    //printf("%5d) %02x\n", t, tag->data[start+t]);
+    //printf("%05d) %02x\n", t, tag->data[start+t]);
 #endif
 
     code_t*c = head;
@@ -414,16 +418,9 @@ void codelookup_free(codelookup_t*codelookup)
     free(codelookup);
 }
 
-code_t*code_find_start(code_t*c)
-{
-    while(c && c->prev) 
-        c=c->prev;
-    return c;
-}
-
 void code_free(code_t*c)
 {
-    c = code_find_start(c);
+    c = code_start(c);
     while(c) {
         code_t*next = c->next;
         opcode_t*op = opcode_get(c->opcode);
@@ -433,6 +430,8 @@ void code_free(code_t*c)
             void*data = c->data[pos];
             if(*p == '2') { //multiname
                 multiname_destroy(data);
+            } else if(*p == 'N') { //namespace
+                namespace_destroy(data);
             } else if(strchr("sDf", *p)) {
                 free(data);
             } else if(strchr("S", *p)) {
@@ -465,76 +464,112 @@ static int opcode_write(TAG*tag, code_t*c, pool_t*pool, abc_file_t*file, int len
            c->opcode == OPCODE___CONTINUE__) {
             fprintf(stderr, "Unresolved %s\n", op->name);
         } else {
-            fprintf(stderr, "Error: writing undefined internal opcode %s", op->name);
+            fprintf(stderr, "Error: writing undefined internal opcode %s\n", op->name);
         }
     }
 
     while(*p) {
         void*data = c->data[pos++];
         assert(pos<=2);
-        if(*p == 'n') { // number
-            len += swf_SetU30(tag, (ptroff_t)data);
-        } else if(*p == '2') { //multiname
-            multiname_t*m = (multiname_t*)data;
-            len += swf_SetU30(tag, pool_register_multiname(pool, m));
-        } else if(*p == 'm') { //method
-            abc_method_t*m = (abc_method_t*)data;
-            len += swf_SetU30(tag, m->index);
-        } else if(*p == 'c') { //classinfo 
-            abc_class_t*cls = (abc_class_t*)data;
-            len += swf_SetU30(tag, cls->index);
-        } else if(*p == 'i') { //methodbody
-            abc_method_body_t*m = (abc_method_body_t*)data;
-            len += swf_SetU30(tag, m->index);
-        } else if(*p == 'I') { // int
-            len += swf_SetU30(tag, pool_register_int(pool, (ptroff_t)data));
-        } else if(*p == 'U') { // uint
-            len += swf_SetU30(tag, pool_register_uint(pool, (ptroff_t)data));
-        } else if(*p == 'f') { //  float
-            len += swf_SetU30(tag, pool_register_float(pool, *(double*)data));
-        } else if(*p == 'u') { // integer
-            len += swf_SetU30(tag, (ptroff_t)data);
-        } else if(*p == 'r') { // integer
-            len += swf_SetU30(tag, (ptroff_t)data);
-        } else if(*p == 'b') { // byte
-            if(tag)
-                swf_SetU8(tag, (ptroff_t)data);
-            len++;
-        } else if(*p == 'j') { // jump
-            int skip = length-c->pos-4;
-            if(c->branch) 
-                skip = (c->branch->pos) - c->pos - 4;
-            len += swf_SetS24(tag, skip);
-        } else if(*p == 's') { // string
-            int index = pool_register_string2(pool, (string_t*)data);
-            len += swf_SetU30(tag, index);
-        } else if(*p == 'D') { // debug statement
-            if(tag)
-                swf_SetU8(tag, 1);
-            len++;
-            len+=swf_SetU30(tag, pool_register_string(pool,c->data[0]));
-            if(tag)
-                swf_SetU8(tag, (ptroff_t)c->data[1]);
-            len++;
-            len+=swf_SetU30(tag, 0);
-        } else if(*p == 'S') { // switch statement
-            lookupswitch_t*l = (lookupswitch_t*)data;
-            int offset = 0;
-            len+=swf_SetS24(tag, l->def->pos-c->pos+offset); //default
-            code_list_t*t = l->targets;
-            if(list_length(t)) {
-                len+=swf_SetU30(tag, list_length(t)-1); //nr-1
+        switch(*p) {
+            case 'n': { // number
+                len += swf_SetU30(tag, (ptroff_t)data);
+                break;
+            }
+            case '2': { //multiname
+                multiname_t*m = (multiname_t*)data;
+                len += swf_SetU30(tag, pool_register_multiname(pool, m));
+                break;
+            }
+            case 'N': { //namespace
+                namespace_t*ns = (namespace_t*)data;
+                len += swf_SetU30(tag, pool_register_namespace(pool, ns));
+                break;
+            }
+            case 'm': { //method
+                abc_method_t*m = (abc_method_t*)data;
+                len += swf_SetU30(tag, m->index);
+                break;
+            }
+            case 'c': { //classinfo 
+                abc_class_t*cls = (abc_class_t*)data;
+                len += swf_SetU30(tag, cls->index);
+                break;
+            }
+            case 'i': { //methodbody
+                abc_method_body_t*m = (abc_method_body_t*)data;
+                len += swf_SetU30(tag, m->index);
+                break;
+            }
+            case 'I': { // int
+                len += swf_SetU30(tag, pool_register_int(pool, (ptroff_t)data));
+                break;
+            }
+            case 'U': { // uint
+                len += swf_SetU30(tag, pool_register_uint(pool, (ptroff_t)data));
+                break;
+            }
+            case 'f': { //  float
+                len += swf_SetU30(tag, pool_register_float(pool, *(double*)data));
+                break;
+            }
+            case 'u': { // integer
+                len += swf_SetU30(tag, (ptroff_t)data);
+                break;
+            }
+            case 'r': { // integer
+                len += swf_SetU30(tag, (ptroff_t)data);
+                break;
+            }
+            case 'b': { // byte
+                if(tag)
+                    swf_SetU8(tag, (ptroff_t)data);
+                len++;
+                break;
+            }
+            case 'j': { // jump
+                int skip = length-c->pos-4;
+                if(c->branch) 
+                    skip = (c->branch->pos) - c->pos - 4;
+                len += swf_SetS24(tag, skip);
+                break;
+            }
+            case 's': { // string
+                int index = pool_register_string2(pool, (string_t*)data);
+                len += swf_SetU30(tag, index);
+                break;
+            }
+            case 'D': { // debug statement
+                if(tag)
+                    swf_SetU8(tag, 1);
+                len++;
+                len+=swf_SetU30(tag, pool_register_string(pool,c->data[0]));
+                if(tag)
+                    swf_SetU8(tag, (ptroff_t)c->data[1]);
+                len++;
+                len+=swf_SetU30(tag, 0);
+                break;
+            }
+            case 'S': { // switch statement
+                lookupswitch_t*l = (lookupswitch_t*)data;
+                int offset = 0;
+                len+=swf_SetS24(tag, l->def->pos-c->pos+offset); //default
                 code_list_t*t = l->targets;
-                while(t) {
-                    len+=swf_SetS24(tag, t->code->pos - c->pos+offset);
-                    t = t->next;
+                if(list_length(t)) {
+                    len+=swf_SetU30(tag, list_length(t)-1); //nr-1
+                    code_list_t*t = l->targets;
+                    while(t) {
+                        len+=swf_SetS24(tag, t->code->pos - c->pos+offset);
+                        t = t->next;
+                    }
+                } else {
+                    len+=swf_SetU30(tag, 0); //nr-1
+                    len+=swf_SetS24(tag, l->def->pos-c->pos+offset);
                 }
-            } else {
-                len+=swf_SetU30(tag, 0); //nr-1
-                len+=swf_SetS24(tag, l->def->pos-c->pos+offset);
+                break;
             }
-        } else {
-            printf("Can't parse opcode param type \"%c\"\n", *p);
+            default:
+                printf("Can't parse opcode param type \"%c\"\n", *p);
         }
         p++;
     }
@@ -543,7 +578,7 @@ static int opcode_write(TAG*tag, code_t*c, pool_t*pool, abc_file_t*file, int len
 
 void code_write(TAG*tag, code_t*code, pool_t*pool, abc_file_t*file)
 {
-    code = code_find_start(code);
+    code = code_start(code);
     int pos = 0;
     int length = 0;
     code_t*c = code;
@@ -623,7 +658,7 @@ static void dumpstack(currentstats_t*stats)
     for(t=0;t<stats->num;t++) {
         code_t*c = stats->stack[t].code;
         opcode_t*op = opcode_get(c->opcode);
-        printf("%5d) %c %d:%d %s", t, (stats->stack[t].flags&FLAG_SEEN)?'x':'|', 
+        printf("%05d) %c %d:%d %s", t, (stats->stack[t].flags&FLAG_SEEN)?'x':'|', 
                                stats->stack[t].stackpos,
                                stats->stack[t].scopepos,
                                op->name);
@@ -636,6 +671,8 @@ static void dumpstack(currentstats_t*stats)
         }
         if(op->params[0]=='2') {
             printf(" %s", multiname_tostring(c->data[0]));
+        } else if(op->params[0]=='N') {
+            printf(" %s", namespace_tostring(c->data[0]));
         }
         printf("\n");
     }
@@ -786,7 +823,7 @@ static char callcode(currentstats_t*stats, int pos, int stack, int scope)
 
 static currentstats_t* code_get_stats(code_t*code, abc_exception_list_t*exceptions) 
 {
-    code = code_find_start(code);
+    code = code_start(code);
     int num = 0;
     code_t*c = code;
     while(c) {
@@ -808,15 +845,17 @@ static currentstats_t* code_get_stats(code_t*code, abc_exception_list_t*exceptio
     for(t=0;t<num;t++) {
         opcode_t*op = opcode_get(c->opcode);
         if(op->flags & (OP_JUMP|OP_BRANCH)) {
-            printf("%5d) %s %08x\n", t, op->name, c->branch);
+            printf("%05d) %s %08x\n", t, op->name, c->branch);
         } else if(op->params[0]=='2') {
-            printf("%5d) %s %s\n", t, op->name, multiname_tostring(c->data[0]));
+            printf("%05d) %s %s\n", t, op->name, multiname_tostring(c->data[0]));
+        } else if(op->params[0]=='N') {
+            printf("%05d) %s %s\n", t, op->name, namespace_tostring(c->data[0]));
         } else {
-            printf("%5d) %s\n", t, op->name);
+            printf("%05d) %s\n", t, op->name);
         }
         c = c->next;
     }
-    //printf("%5d) %02x\n", t, tag->data[start+t]);
+    //printf("%05d) %02x\n", t, tag->data[start+t]);
 #endif
 
     num = 0;
@@ -851,10 +890,20 @@ void stats_free(currentstats_t*stats)
     }
 }
 
-int code_dump(code_t*c, abc_exception_list_t*exceptions, abc_file_t*file, char*prefix, FILE*fo)
+int code_dump(code_t*c)
+{
+    code_t*cc = code_start(c);
+    while(cc) {
+        assert(!cc->next || cc->next->prev == cc);
+        cc = cc->next;
+    }
+
+    return code_dump2(c, 0, 0, "", stdout);
+}
+int code_dump2(code_t*c, abc_exception_list_t*exceptions, abc_file_t*file, char*prefix, FILE*fo)
 {
     abc_exception_list_t*e = exceptions;
-    c = code_find_start(c);
+    c = code_start(c);
     currentstats_t*stats =  code_get_stats(c, exceptions);
 
     int pos = 0;
@@ -887,13 +936,13 @@ int code_dump(code_t*c, abc_exception_list_t*exceptions, abc_file_t*file, char*p
 
             if(stats) {
                 int f = stats->stack[c->pos].flags;
-                fprintf(fo, "%s%5d) %c %d:%d %s ", prefix, c->pos, 
+                fprintf(fo, "%s%05d) %c %d:%d %s ", prefix, c->pos, 
                                        (f&FLAG_ERROR)?'E':((f&FLAG_SEEN)?'+':'|'),
                                        stats->stack[c->pos].stackpos,
                                        stats->stack[c->pos].scopepos,
                                        op->name);
             } else {
-                fprintf(fo, "%s%5d) ? ?:? %s ", prefix, c->pos, op->name);
+                fprintf(fo, "%s%05d) ? ?:? %s ", prefix, c->pos, op->name);
             }
 
             while(*p) {
@@ -909,13 +958,18 @@ int code_dump(code_t*c, abc_exception_list_t*exceptions, abc_file_t*file, char*p
                     char* m = multiname_tostring(n);
                     fprintf(fo, "%s", m);
                     free(m);
+                } else if(*p == 'N') {
+                    namespace_t*ns = (namespace_t*)data;
+                    char* m = namespace_tostring(ns);
+                    fprintf(fo, "%s", m);
+                    free(m);
                 } else if(*p == 'm') {
                     abc_method_t*m = (abc_method_t*)data;
-                    fprintf(fo, "[method %s]", m->name);
+                    fprintf(fo, "[method %08x %s]", m->index, m->name);
                 } else if(*p == 'c') {
                     abc_class_t*cls = (abc_class_t*)data;
                     char*classname = multiname_tostring(cls->classname);
-                    fprintf(fo, "[classinfo %s]", classname);
+                    fprintf(fo, "[classinfo %08x %s]", cls->index, classname);
                     free(classname);
                 } else if(*p == 'i') {
                     abc_method_body_t*b = (abc_method_body_t*)data;
@@ -930,13 +984,13 @@ int code_dump(code_t*c, abc_exception_list_t*exceptions, abc_file_t*file, char*p
                     int n = (ptroff_t)data;
                     fprintf(fo, "r%d", n);
                 } else if(*p == 'b') {
-                    int b = (ptroff_t)data;
-                    fprintf(fo, "%02x", b);
+                    int b = (signed char)(ptroff_t)data;
+                    fprintf(fo, "%d", b);
                 } else if(*p == 'j') {
                     if(c->branch)
                         fprintf(fo, "->%d", c->branch->pos);
                     else
-                        fprintf(fo, "%08x", c->branch);
+                        fprintf(fo, "%08x", (unsigned int)c->branch);
                 } else if(*p == 's') {
                     char*s = string_escape((string_t*)data);
                     fprintf(fo, "\"%s\"", s);
@@ -949,7 +1003,7 @@ int code_dump(code_t*c, abc_exception_list_t*exceptions, abc_file_t*file, char*p
                     if(l->def)
                         fprintf(fo, "default->%d", l->def->pos);
                     else
-                        fprintf(fo, "default->00000000", l->def->pos);
+                        fprintf(fo, "default->00000000");
                     code_list_t*t = l->targets;
                     while(t) {
                         if(t->code)
@@ -1012,13 +1066,15 @@ code_t* add_opcode(code_t*atag, U8 op)
 {
     code_t*tmp = (code_t*)rfx_calloc(sizeof(code_t));
     tmp->opcode = op;
-    tmp->next = 0;
     if(atag) {
 	tmp->prev = atag;
         tmp->next = atag->next;
+        if(tmp->next)
+            tmp->next->prev = tmp;
 	atag->next = tmp;
     } else {
 	tmp->prev = 0;
+        tmp->next = 0;
     }
     return tmp;
 }
@@ -1038,6 +1094,14 @@ code_t* code_end(code_t*code)
         code = code->next;
     return code;
 }
+code_t* code_start(code_t*code)
+{
+    if(!code)
+        return 0;
+    while(code->prev)
+        code = code->prev;
+    return code;
+}
 
 code_t* code_append(code_t*code, code_t*toappend)
 {
@@ -1071,23 +1135,34 @@ code_t*code_dup(code_t*c)
 {
     if(!c) return 0;
 
-    while(c->prev) c = c->prev;
+    dict_t*pos2pos = dict_new2(&ptr_type);
 
     code_t*last = 0;
+    c = code_start(c);
+    code_t*start = 0;
+    char does_branch = 0;
     while(c) {
         NEW(code_t, n);
         memcpy(n, c, sizeof(code_t));
+        if(!start) 
+            start=n;
 
-        opcode_t*op = opcode_get(c->opcode);
+        if(c->opcode == OPCODE_LABEL || c->opcode == OPCODE_NOP) {
+            dict_put(pos2pos, c, n);
+        }
         if(c->branch) {
-            fprintf(stderr, "Error: Can't duplicate branching code\n");
-            return 0;
+            does_branch = 1;
         }
+
+        opcode_t*op = opcode_get(c->opcode);
+        
         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 == 'N') { //multiname
+                c->data[pos] = namespace_clone(c->data[pos]);
             } else if(*p == 's') {
                 c->data[pos] = string_dup3(c->data[pos]);
             } else if(*p == 'D') {
@@ -1109,23 +1184,63 @@ code_t*code_dup(code_t*c)
         last = n;
         c = c->next;
     }
+   
+    if(does_branch) {
+        c = start;
+        while(c) {
+            if(c->branch) {
+                code_t*target = dict_lookup(pos2pos, c->branch);
+                if(!target) {
+                    fprintf(stderr, "Error: Can't find branch target in code_dup\n");
+                    return 0;
+                }
+                c->branch = target;
+            }
+            c = c->next;
+        }
+    }
+    dict_destroy(pos2pos);
     return last;
 }
 
-code_t*code_cutlast(code_t*c)
+code_t*code_cut(code_t*c)
 {
     if(!c) return c;
-    assert(!c->next);
     code_t*prev = c->prev;
+    code_t*next = c->next;
     c->prev = 0;
-    if(prev)
-        prev->next=0;
+    c->next = 0;
+    if(prev) prev->next=next;
+    if(next) next->prev=prev;
     code_free(c);
-    return prev;
+
+    if(next) return code_end(next);
+    else     return prev;
+}
+
+code_t*code_cutlast(code_t*c)
+{
+    if(!c) return c;
+    assert(!c->next);
+    return code_cut(c);
+}
+
+char is_getlocal(code_t*c)
+{
+    if(!c) return 0;
+    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 1;
+    }
+    return 0;
 }
 
 code_t* cut_last_push(code_t*c)
 {
+    assert(!c->next);
     while(c) {
         if(!c) break;
         opcode_t*op = opcode_get(c->opcode);
@@ -1153,8 +1268,19 @@ code_t* cut_last_push(code_t*c)
         } else if(c->opcode == OPCODE_CALLSUPER) {
             c->opcode = OPCODE_CALLSUPERVOID;
             return c;
-        }
-        else
+        } else if((c->opcode == OPCODE_NEWOBJECT ||
+                   c->opcode == OPCODE_NEWARRAY) &&
+                   !c->data[0]) {
+            // we can discard these if they're not eating up stack parameters
+            return code_cutlast(c);
+        } else if(op->stack_minus ==0 && op->stack_plus == 0 && 
+                !(op->flags&~(OP_REGISTER|OP_SET_DXNS)) && c->prev) {
+            // trim code *before* the kill, inclocal, declocal, dxns
+            code_t*p = c->prev; 
+            p->next = 0;
+            c->prev = 0;
+            return code_append(cut_last_push(p), c);
+        } else
             break;
     }
     c = abc_pop(c);