{0x57, "newactivation", "", 0, 1, 0, OP_NEED_ACTIVATION},
{0x56, "newarray", "n", 0, 1, 0, OP_STACK_ARGS},
{0x5a, "newcatch", "u", 0, 1, 0, 0}, //u = index into exception_info
-#define OP_NEWCLASS 0x58
{0x58, "newclass", "c", -1, 1, 0, 0}, //c = index into class_info
-#define OP_NEWFUNCTION 0x40
{0x40, "newfunction", "m", 0, 1, 0, 0}, //i = index into method_info
{0x55, "newobject", "n", 0, 1, 0, OP_STACK_ARGS2},
{0x1e, "nextname", "", -2, 1, 0, 0},
{0xa7, "urshift", "", -2, 1, 0, 0},
/* opcodes not documented, but seen in the wild */
-//0x53: seen in builtin.abc- followed by 0x01 (might be the number of stack params)
-{0x53, "xxx1", "", -1, 0, 0, 0},
-{0x01, "xxx2", "", 0, 0, 0, 0},
+//0x53: seen in builtin.abc
+{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},
if(op->flags & OP_NEED_ACTIVATION)
stats->flags |= FLAGS_ACTIVATION;
- if(c->opcode == OP_NEWCLASS) {
+ if(c->opcode == OPCODE_NEWCLASS) {
abc_class_t*cls = (abc_class_t*)(c->data[0]);
if(scope > cls->init_scope_depth)
cls->init_scope_depth = scope;
}
- if(c->opcode == OP_NEWFUNCTION) {
+ if(c->opcode == OPCODE_NEWFUNCTION) {
abc_method_t*m = (abc_method_t*)(c->data[0]);
if(m->body && scope > m->body->init_scope_depth)
m->body->init_scope_depth = scope;
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' || *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)
+{
+ assert(!c->next);
+ code_t*prev = c->prev;
+ c->prev = 0;
+ 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;
+}
+
+