lib/as3/code.c

   1 #include <assert.h>
   2 #include "code.h"
   3
   4 #define OP_REGISTER 1
   5 #define OP_STACK_ARGS 2
   6 #define OP_STACK_NS 4
   7 #define OP_SET_DXNS 8
   8 #define OP_RETURN 16
   9 #define OP_THROW 32
  10 #define OP_BRANCH 32
  11 #define OP_JUMP 64
  12 #define OP_LABEL 128
  13 #define OP_SWITCH 256
  14 #define OP_NEED_ACTIVATION 512
  15 #define OP_STACK_ARGS2 1024
  16
  17 /* 2 = u30 index into multiname
  18    m = u30 index into method
  19    n = u30 number of params
  20    i = u30 index into method info
  21    b = byte
  22    s = short
  23    c = u30 index into class
  24    s = string (u30 index into strings)
  25    S = switch
  26    u = u30
  27    r = register
  28 */
  29 opcode_t opcodes[]={
  30 {0xa0, "add", "",              -2, 1, 0, 0},
  31 {0xc5, "add_i", "",            -2, 1, 0, 0},
  32 {0x86, "astype", "2",          -1, 1, 0, 0},
  33 {0x87, "astypelate", "",       -2, 1, 0, 0},
  34 {0xA8, "bitand", "",           -2, 1, 0, 0},
  35 {0x97, "bitnot", ""            -1, 1, 0, 0},
  36 {0xa9, "bitor", "",            -2, 1, 0, 0},
  37 {0xaa, "bitxor", ""            -2, 1, 0, 0},
  38 {0x41, "call", "n",            -2, 1, 0, OP_STACK_ARGS},
  39 {0x43, "callmethod", "mn",     -1, 1, 0, OP_STACK_ARGS},
  40 {0x4c, "callproplex", "2n",    -1, 1, 0, OP_STACK_ARGS|OP_STACK_NS},
  41 {0x46, "callproperty", "2n",   -1, 1, 0, OP_STACK_ARGS|OP_STACK_NS},
  42 {0x4f, "callpropvoid", "2n",   -1, 0, 0, OP_STACK_ARGS|OP_STACK_NS},
  43 {0x44, "callstatic", "in",     -1, 1, 0, OP_STACK_ARGS},
  44 {0x45, "callsuper", "2n",      -1, 1, 0, OP_STACK_ARGS|OP_STACK_NS},
  45 {0x4e, "callsupervoid", "2n",  -1, 0, 0, OP_STACK_ARGS|OP_STACK_NS},
  46 {0x78, "checkfilter", "",      -1, 1, 0, 0},
  47 {0x80, "coerce", "2",          -1, 1, 0, 0},
  48 {0x82, "coerce_a", "",         -1, 1, 0, 0},
  49 {0x85, "coerce_s", "",         -1, 1, 0, 0},
  50 {0x42, "construct", "n",       -1, 1, 0, OP_STACK_ARGS},
  51 {0x4a, "constructprop", "2n",  -1, 1, 0, OP_STACK_ARGS|OP_STACK_NS},
  52 {0x49, "constructsuper", "n",  -1, 1, 0, OP_STACK_ARGS},
  53 {0x76, "convert_b", "",        -1, 1, 0, 0},
  54 {0x73, "convert_i", "",        -1, 1, 0, 0},
  55 {0x75, "convert_d", "",        -1, 1, 0, 0},
  56 {0x77, "convert_o", "",        -1, 1, 0, 0},
  57 {0x74, "convert_u", "",        -1, 1, 0, 0},
  58 {0x70, "convert_s", "",        -1, 1, 0, 0},
  59 {0xef, "debug", "D",            0, 0, 0, 0},
  60 {0xf1, "debugfile", "s",        0, 0, 0, 0},
  61 {0xf0, "debugline", "u",        0, 0, 0, 0},
  62 {0x94, "declocal", "r",         0, 0, 0, OP_REGISTER},
  63 {0xc3, "declocal_i", "r",       0, 0, 0, OP_REGISTER},
  64 {0x93, "decrement", "",        -1, 1, 0, 0},
  65 {0xc1, "decrement_i", "",      -1, 1, 0, 0},
  66 {0x6a, "deleteproperty", "2",  -1, 1, 0, OP_STACK_NS},
  67 {0xa3, "divide", "",           -2, 1, 0, 0},
  68 {0x2a, "dup", "",              -1, 2, 0, 0},
  69 {0x06, "dxns", "s",             0, 0, 0, OP_SET_DXNS},
  70 {0x07, "dxnslate", "",         -1, 0, 0, OP_SET_DXNS},
  71 {0xab, "equals", "",           -2, 1, 0, 0},
  72 {0x72, "esc_xattr", "",        -1, 1, 0, 0},
  73 {0x71, "esc_xelem", "",        -1, 1, 0, 0},
  74 {0x5e, "findproperty", "2",     0, 1, 0, OP_STACK_NS},
  75 {0x5d, "findpropstrict", "2",   0, 1, 0, OP_STACK_NS},
  76 {0x59, "getdescendants", "2",  -1, 1, 0, OP_STACK_NS},
  77 {0x64, "getglobalscope", "",    0, 1, 0, 0},
  78 {0x6e, "getglobalslot", "u",    0, 1, 0, 0},
  79 {0x60, "getlex", "2",           0, 1, 0, 0}, //multiname may not be runtime
  80 {0x62, "getlocal", "r",         0, 1, 0, OP_REGISTER},
  81 {0xd0, "getlocal_0", "",        0, 1, 0, OP_REGISTER},
  82 {0xd1, "getlocal_1", "",        0, 1, 0, OP_REGISTER},
  83 {0xd2, "getlocal_2", "",        0, 1, 0, OP_REGISTER},
  84 {0xd3, "getlocal_3", "",        0, 1, 0, OP_REGISTER},
  85 {0x66, "getproperty", "2",     -1, 1, 0, OP_STACK_NS},
  86 {0x65, "getscopeobject", "u",   0, 1, 0, 0}, // u = index into scope stack
  87 {0x6c, "getslot", "u",         -1, 1, 0, 0},
  88 {0x04, "getsuper", "2",        -1, 1, 0, OP_STACK_NS},
  89 {0xaf, "greaterequals", "",    -2, 1, 0, 0},
  90 {0x1f, "hasnext", "",          -2, 1, 0, 0},
  91 {0x32, "hasnext2", "rr",        0, 1, 0, OP_REGISTER},
  92 {0x13, "ifeq", "j",            -2, 0, 0, OP_BRANCH},
  93 {0x12, "iffalse", "j",         -1, 0, 0, OP_BRANCH},
  94 {0x18, "ifge", "j",            -2, 0, 0, OP_BRANCH},
  95 {0x17, "ifgt", "j",            -2, 0, 0, OP_BRANCH},
  96 {0x16, "ifle", "j",            -2, 0, 0, OP_BRANCH},
  97 {0x15, "iflt", "j",            -2, 0, 0, OP_BRANCH},
  98 {0x0f, "ifnge", "j",           -2, 0, 0, OP_BRANCH},
  99 {0x0e, "ifngt", "j",           -2, 0, 0, OP_BRANCH},
 100 {0x0d, "ifnle", "j",           -2, 0, 0, OP_BRANCH},
 101 {0x0c, "ifnlt", "j",           -2, 0, 0, OP_BRANCH},
 102 {0x14, "ifne", "j",            -2, 0, 0, OP_BRANCH},
 103 {0x19, "ifstricteq", "j",      -2, 0, 0, OP_BRANCH},
 104 {0x1a, "ifstrictne", "j",      -2, 0, 0, OP_BRANCH},
 105 {0x11, "iftrue", "j",          -1, 0, 0, OP_BRANCH},
 106 {0xb4, "in", "",               -2, 1, 0, 0},
 107 {0x92, "inclocal", "r",         0, 0, 0, OP_REGISTER},
 108 {0xc2, "inclocal_i", "r",       0, 0, 0, OP_REGISTER},
 109 {0x91, "increment", "",        -1, 1, 0, 0},
 110 {0xc0, "increment_i", "",      -1, 1, 0, 0},
 111 {0x68, "initproperty", "2",    -1, 0, 0, OP_STACK_NS},
 112 {0xb1, "instanceof", "",       -2, 1, 0, 0},
 113 {0xb2, "istype", "2",          -1, 1, 0, 0}, // may not be a runtime multiname
 114 {0xb3, "istypelate", "",       -2, 1, 0, 0},
 115 {0x10, "jump", "j",             0, 0, 0, OP_JUMP},
 116 {0x08, "kill", "r",             0, 0, 0, OP_REGISTER},
 117 {0x09, "label", "",             0, 0, 0, OP_LABEL},
 118 {0xae, "lessequals", "",       -2, 1, 0, 0},
 119 {0xad, "lessthan", "",         -2, 1, 0, 0},
 120 {0x1b, "lookupswitch", "S",    -1, 0, 0, OP_SWITCH},
 121 {0xa5, "lshift", "",           -2, 1, 0, 0},
 122 {0xa4, "modulo", "",           -2, 1, 0, 0},
 123 {0xa2, "multiply", "",         -2, 1, 0, 0},
 124 {0xc7, "multiply_i", "",       -2, 1, 0, 0},
 125 {0x90, "negate", "",           -1, 1, 0, 0},
 126 {0xc4, "negate_i", "",         -1, 1, 0, 0},
 127 {0x57, "newactivation", "",     0, 1, 0, OP_NEED_ACTIVATION},
 128 {0x56, "newarray", "n",         0, 1, 0, OP_STACK_ARGS},
 129 {0x5a, "newcatch", "u",         0, 1, 0, 0}, //u = index into exception_info
 130 {0x58, "newclass", "c",        -1, 1, 0, 0}, //c = index into class_info
 131 {0x40, "newfunction", "m",      0, 1, 0, 0}, //i = index into method_info
 132 {0x55, "newobject", "n",        0, 1, 0, OP_STACK_ARGS2},
 133 {0x1e, "nextname", "",         -2, 1, 0, 0},
 134 {0x23, "nextvalue", "",        -2, 1, 0, 0},
 135 {0x02, "nop", "",               0, 0, 0, 0},
 136 {0x96, "not", "",              -1, 1, 0 ,0},
 137 {0x29, "pop", "",              -1, 0, 0, 0},
 138 {0x1d, "popscope", "",          0, 0,-1, 0},
 139 {0x24, "pushbyte", "b",         0, 1, 0, 0},
 140 {0x2f, "pushdouble", "u",       0, 1, 0, 0}, //index into floats
 141 {0x27, "pushfalse", "",         0, 1, 0, 0},
 142 {0x2d, "pushint", "u",          0, 1, 0, 0}, //index into ints
 143 {0x31, "pushnamespace", "u",    0, 1, 0, 0}, //index into namespace
 144 {0x28, "pushnan", "",           0, 1, 0, 0},
 145 {0x20, "pushnull", "",          0, 1, 0, 0},
 146 {0x30, "pushscope", "",        -1, 0, 1, 0},
 147 {0x25, "pushshort", "u",        0, 1, 0, 0},
 148 {0x2c, "pushstring", "s",       0, 1, 0, 0},
 149 {0x26, "pushtrue", "",          0, 1, 0, 0},
 150 {0x2e, "pushuint", "u",         0, 1, 0, 0}, //index into uints
 151 {0x21, "pushundefined", "",     0, 1, 0, 0},
 152 {0x1c, "pushwith", "",         -1, 0, 1, 0},
 153 {0x48, "returnvalue", "",      -1, 0, 0, OP_RETURN},
 154 {0x47, "returnvoid", "",        0, 0, 0, OP_RETURN},
 155 {0xa6, "rshift", "",           -2, 1, 0, 0},
 156 {0x63, "setlocal", "r",        -1, 0, 0, OP_REGISTER},
 157 {0xd4, "setlocal_0", "",       -1, 0, 0, OP_REGISTER},
 158 {0xd5, "setlocal_1", "",       -1, 0, 0, OP_REGISTER},
 159 {0xd6, "setlocal_2", "",       -1, 0, 0, OP_REGISTER},
 160 {0xd7, "setlocal_3", "",       -1, 0, 0, OP_REGISTER},
 161 {0x6f, "setglobalslot", "u",   -1, 0, 0, 0},
 162 {0x61, "setproperty", "2",     -2, 0, 0, OP_STACK_NS},
 163 {0x6d, "setslot", "2",         -2, 0, 0, 0},
 164 {0x05, "setsuper", "2",        -2, 0, 0, OP_STACK_NS},
 165 {0xac, "strictequals", "",     -2, 1, 0, 0},
 166 {0xa1, "subtract", "",         -2, 1, 0, 0},
 167 {0xc6, "subtract_i", "",       -2, 1, 0, 0},
 168 {0x2b, "swap", "",             -2, 2, 0, 0},
 169 {0x03, "throw", "",            -1, 0, 0, OP_THROW},
 170 {0x95, "typeof", "",           -1, 1, 0, 0},
 171 {0xa7, "urshift", "",          -2, 1, 0, 0},
 172 {0xb0, "xxx", "",               0, 0, 0, 0},
 173 };
 174
 175 static U8 op2index[256] = {254};
 176
 177 opcode_t* opcode_get(U8 op)
 178 {
 179     int t;
 180     if(op2index[0]==254) {
 181         memset(op2index, 255, sizeof(op2index));
 182         for(t=0;t<sizeof(opcodes)/sizeof(opcodes[0]);t++) {
 183             op2index[opcodes[t].opcode] = t;
 184         }
 185     }
 186     if(op2index[op]!=255)
 187         return &opcodes[op2index[op]];
 188     return 0;
 189 }
 190
 191 abc_code_t*code_parse(TAG*tag, int len, abc_file_t*file, pool_t*pool)
 192 {
 193     abc_code_t*head=0;
 194     abc_code_t*code=0;
 195     int start=tag->pos;
 196     int end=tag->pos+len;
 197     //printf("-->\n");fflush(stdout);
 198
 199     abc_code_t**bytepos = rfx_calloc(sizeof(abc_code_t*)*len);
 200
 201     while(tag->pos<end) {
 202         int codepos = tag->pos-start;
 203         U8 opcode = swf_GetU8(tag);
 204         opcode_t*op = opcode_get(opcode);
 205         if(!op) {
 206             fprintf(stderr, "Can't parse opcode %02x\n", opcode);
 207             return head;
 208         }
 209         //printf("%s\n", op->name);fflush(stdout);
 210         NEW(abc_code_t,c);
 211         c->pos = codepos;
 212
 213         bytepos[codepos] = c;
 214
 215         if(!head) {
 216             head = code = c;
 217         } else {
 218             code->next = c;
 219             code = c;
 220         }
 221
 222         c->opcode = opcode;
 223
 224         char*p = op->params;
 225         int pos = 0;
 226         while(*p) {
 227             void*data = 0;
 228             if(*p == 'n') { // number
 229                 data = (void*)(ptroff_t)swf_GetU30(tag);
 230             } else if(*p == '2') { //multiname
 231                 data = multiname_clone(pool_lookup_multiname(pool, swf_GetU30(tag)));
 232             } else if(*p == 'm') { //method
 233                 data = array_getvalue(file->methods, swf_GetU30(tag));
 234             } else if(*p == 'c') { //classinfo
 235                 data = array_getvalue(file->classes, swf_GetU30(tag));
 236             } else if(*p == 'i') {
 237                 data = array_getvalue(file->method_bodies, swf_GetU30(tag));
 238             } else if(*p == 'u') { // generic integer
 239                 data = (void*)(ptroff_t)swf_GetU30(tag);
 240             } else if(*p == 'r') { // local register
 241                 data = (void*)(ptroff_t)swf_GetU30(tag);
 242             } else if(*p == 'b') { // byte
 243                 data = (void*)(ptroff_t)swf_GetU8(tag);
 244             } else if(*p == 'j') { // jump
 245                 int j = swf_GetS24(tag);
 246                 data = (void*)(ptroff_t)j;
 247             } else if(*p == 's') { // string
 248                 data = strdup((char*)pool_lookup_string(pool, swf_GetU30(tag)));
 249             } else if(*p == 'D') { // debug
 250                 /*type, usually 1*/
 251                 U8 type = swf_GetU8(tag);
 252                 if(type!=1)
 253                     fprintf(stderr, "Unknown debug type: %02x\n", type);
 254                 /*register name*/
 255                 code->data[0] = strdup((char*)pool_lookup_string(pool, swf_GetU30(tag)));
 256                 /*register index*/
 257                 code->data[1] = (void*)(ptroff_t)swf_GetU8(tag);
 258                 /*unused*/
 259                 swf_GetU30(tag);
 260             } else if(*p == 'S') { // switch statement TODO
 261                 /* I hate these things */
 262                 swf_GetU24(tag); //default
 263                 int num = swf_GetU30(tag)+1;
 264                 int t;
 265                 for(t=0;t<num;t++)
 266                     swf_GetU24(tag);
 267                 data = 0;
 268             } else {
 269                 printf("Can't parse opcode param type \"%c\".\n", *p);
 270                 return 0;
 271             }
 272             if(data)
 273                 code->data[pos++] = data;
 274             p++;
 275         }
 276     }
 277
 278 //#define DEBUG_BYTES
 279 #ifdef DEBUG_BYTES
 280     int t;
 281     for(t=0;t<len;t++) {
 282         abc_code_t*c = bytepos[t];
 283         if(c) {
 284             opcode_t*op = opcode_get(c->opcode);
 285             if(op->flags & (OP_JUMP|OP_BRANCH)) {
 286                 printf("%5d) %02x %s %d\n", t, tag->data[start+t], op->name, c->data[0]);
 287             } else {
 288                 printf("%5d) %02x %s\n", t, tag->data[start+t], op->name);
 289             }
 290         } else {
 291             printf("%5d) %02x\n", t, tag->data[start+t]);
 292         }
 293     }
 294     printf("%5d) %02x\n", t, tag->data[start+t]);
 295 #endif
 296
 297     abc_code_t*c = head;
 298     while(c) {
 299         opcode_t*op = opcode_get(c->opcode);
 300         if(op->flags & (OP_JUMP|OP_BRANCH)) {
 301             int j = ((int)(ptroff_t)c->data[0]) + 4;
 302 #ifdef DEBUG_BYTES
 303             printf("%s %d %d\n", op->name, c->pos, j);
 304 #endif
 305             if(c->pos+j < 0 ||
 306                c->pos+j > len ||
 307               (c->pos+j!=len && !bytepos[c->pos+j])) {
 308                 /* flex likes to generate these. yuck. */
 309                 fprintf(stderr, "Invalid jump instruction \"%s\" from %d to %d (%d)\n", op->name, c->pos, c->pos+j, len);
 310                 code->branch = 0;
 311             } else {
 312                 if(c->pos==len)
 313                     code->branch = 0;
 314                 else
 315                     code->branch = bytepos[c->pos+j];
 316             }
 317         }
 318         c = c->next;
 319     }
 320     free(bytepos);
 321     return head;
 322 }
 323
 324 abc_code_t*code_find_start(abc_code_t*c)
 325 {
 326     while(c->prev)
 327         c=c->prev;
 328     return c;
 329 }
 330
 331 void code_free(abc_code_t*c)
 332 {
 333     c = code_find_start(c);
 334     while(c) {
 335         abc_code_t*next = c->next;
 336         opcode_t*op = opcode_get(c->opcode);
 337         char*p = op?op->params:"";
 338         int pos=0;
 339         while(*p) {
 340             void*data = c->data[pos];
 341             if(*p == '2') { //multiname
 342                 multiname_destroy(data);
 343             } else if(strchr("sD", *p)) {
 344                 free(data);
 345             }
 346             c->data[pos]=0;
 347             p++;pos++;
 348         }
 349         memset(c, 0, sizeof(c));
 350         free(c);
 351         c = next;
 352     }
 353 }
 354
 355 int code_dump(abc_code_t*c, abc_file_t*file, char*prefix, FILE*fo)
 356 {
 357     c = code_find_start(c);
 358     pool_t*pool = pool_new();
 359
 360     while(c) {
 361         U8 opcode = c->opcode;
 362         int t;
 363         char found = 0;
 364         opcode_t*op = opcode_get(opcode);
 365         if(!op) {
 366             fprintf(stderr, "Can't parse opcode %02x.\n", opcode);
 367             return 0;
 368         } else {
 369             fprintf(fo, "%s%s ", prefix, op->name);
 370             char*p = op->params;
 371             char first = 1;
 372             int pos=0;
 373             while(*p) {
 374                 void*data = c->data[pos];
 375                 if(pos>0)
 376                     printf(", ");
 377
 378                 if(*p == 'n') {
 379                     int n = (ptroff_t)data;
 380                     fprintf(fo, "%d params", n);
 381                 } else if(*p == '2') {
 382                     multiname_t*n = (multiname_t*)data;
 383                     char* m = multiname_to_string(n);
 384                     fprintf(fo, "%s", m);
 385                     free(m);
 386                 } else if(*p == 'm') {
 387                     abc_method_t*m = (abc_method_t*)data;
 388                     fprintf(fo, "[method %s]", m->name);
 389                 } else if(*p == 'c') {
 390                     abc_class_t*cls = (abc_class_t*)data;
 391                     char*classname = multiname_to_string(cls->classname);
 392                     fprintf(fo, "[classinfo %s]", classname);
 393                     free(classname);
 394                 } else if(*p == 'i') {
 395                     abc_method_body_t*b = (abc_method_body_t*)data;
 396                     fprintf(fo, "[methodbody]");
 397                 } else if(*p == 'u') {
 398                     int n = (ptroff_t)data;
 399                     fprintf(fo, "%d", n);
 400                 } else if(*p == 'r') {
 401                     int n = (ptroff_t)data;
 402                     fprintf(fo, "r%d", n);
 403                 } else if(*p == 'b') {
 404                     int b = (ptroff_t)data;
 405                     fprintf(fo, "%02x", b);
 406                 } else if(*p == 'j') {
 407                     int n = (ptroff_t)data;
 408                     fprintf(fo, "%d", n);
 409                 } else if(*p == 's') {
 410                     fprintf(fo, "\"%s\"", data);
 411                 } else if(*p == 'D') {
 412                     fprintf(fo, "[register %02x=%s]", (ptroff_t)c->data[1], (char*)c->data[0]);
 413                 } else if(*p == 'S') {
 414                     fprintf(fo, "[switch data]");
 415                 } else {
 416                     fprintf(stderr, "Can't parse opcode param type \"%c\"\n", *p);
 417                     return 0;
 418                 }
 419                 p++;
 420                 pos++;
 421                 first = 0;
 422             }
 423             fprintf(fo, "\n");
 424         }
 425         c = c->next;
 426     }
 427     return 1;
 428 }
 429
 430 static int opcode_write(TAG*tag, abc_code_t*code, pool_t*pool, abc_file_t*file)
 431 {
 432     opcode_t*op = opcode_get(code->opcode);
 433     char*p = op->params;
 434     int pos = 0;
 435     int len = 0;
 436
 437     if(tag)
 438         swf_SetU8(tag, code->opcode);
 439     len++;
 440
 441     while(*p) {
 442         void*data = code->data[pos++];
 443         assert(pos<=2);
 444         if(*p == 'n') { // number
 445             len += swf_SetU30(tag, (ptroff_t)data);
 446         } else if(*p == '2') { //multiname
 447             multiname_t*m = (multiname_t*)data;
 448             len += swf_SetU30(tag, pool_register_multiname(pool, m));
 449         } else if(*p == 'm') { //method
 450             abc_method_t*m = (abc_method_t*)data;
 451             len += swf_SetU30(tag, m->index);
 452         } else if(*p == 'c') { //classinfo
 453             abc_class_t*cls = (abc_class_t*)data;
 454             len += swf_SetU30(tag, cls->index);
 455         } else if(*p == 'i') { //methodbody
 456             abc_method_body_t*m = (abc_method_body_t*)data;
 457             len += swf_SetU30(tag, m->index);
 458         } else if(*p == 'u') { // integer
 459             len += swf_SetU30(tag, (ptroff_t)data);
 460         } else if(*p == 'r') { // integer
 461             len += swf_SetU30(tag, (ptroff_t)data);
 462         } else if(*p == 'b') { // byte
 463             if(tag)
 464                 swf_SetU8(tag, (ptroff_t)data);
 465             len++;
 466         } else if(*p == 'j') { // jump
 467             len += swf_SetS24(tag, (ptroff_t)data);
 468         } else if(*p == 's') { // string
 469             int index = pool_register_string(pool, data);
 470             len += swf_SetU30(tag, index);
 471         } else if(*p == 'D') { // debug statement
 472             if(tag)
 473                 swf_SetU8(tag, 1);
 474             len++;
 475             len+=swf_SetU30(tag, pool_register_string(pool,code->data[0]));
 476             if(tag)
 477                 swf_SetU8(tag, (ptroff_t)code->data[1]);
 478             len++;
 479             len+=swf_SetU30(tag, 0);
 480         } else if(*p == 'S') { // switch statement
 481             len+=swf_SetU24(tag, 0); //default
 482             len+=swf_SetU30(tag, 0); //nr-1
 483             len+=swf_SetU24(tag, 0); //first
 484         } else {
 485             printf("Can't parse opcode param type \"%c\"\n", *p);
 486         }
 487         p++;
 488     }
 489     return len;
 490 }
 491
 492 void code_write(TAG*tag, abc_code_t*code, pool_t*pool, abc_file_t*file)
 493 {
 494     code = code_find_start(code);
 495     int pos = 0;
 496     int length = 0;
 497     abc_code_t*c = code;
 498     while(c) {
 499         c->pos = pos;
 500         pos += opcode_write(0, c, pool, file);
 501         c = c->next;
 502     }
 503     length = pos;
 504     swf_SetU30(tag, pos);
 505     int start = tag->len;
 506     c = code;
 507     pos = 0;
 508     while(c) {
 509         opcode_t*op = opcode_get(code->opcode);
 510         if(op->flags&(OP_BRANCH|OP_JUMP)) {
 511             int skip = 0;
 512             if(c->branch)
 513                 skip = (c->branch->pos) - pos - 4;
 514             else
 515                 skip = length - pos - 4;
 516             c->data[0] = (void*)(ptroff_t)skip;
 517         }
 518         pos += opcode_write(tag, c, pool, file);
 519         c = c->next;
 520     }
 521     assert(tag->len - start == pos);
 522 }
 523
 524
 525 typedef struct {
 526     int stackpos;
 527     int scopepos;
 528     abc_code_t*code;
 529     char seen;
 530 } stackpos_t;
 531
 532 typedef struct {
 533     stackpos_t*stack;
 534     int num;
 535     int maxlocal;
 536     int maxstack;
 537     int maxscope;
 538 } currentstats_t;
 539
 540 static int stack_minus(abc_code_t*c)
 541 {
 542     opcode_t*op = opcode_get(c->opcode);
 543     assert(op->stack_minus<=0);
 544     int stack = op->stack_minus;
 545     if(op->flags&OP_STACK_NS) {
 546         multiname_t*m = (multiname_t*)c->data[0];
 547         stack--; //read namespace
 548         if(m->type == RTQNAMEL || m->type == RTQNAMELA) {
 549             stack--; //read name
 550         }
 551     }
 552     if(op->flags&OP_STACK_ARGS || op->flags&OP_STACK_ARGS2) {
 553         assert(strchr(op->params, 'n'));
 554         int nr = (ptroff_t)(op->params[0]=='n'?c->data[0]:c->data[1]);
 555         stack-=nr;
 556         if(op->flags&OP_STACK_ARGS2)
 557             stack-=nr;
 558     }
 559     return stack;
 560 }
 561 static void handleregister(currentstats_t*stats, int reg)
 562 {
 563     if(reg+1 > stats->maxlocal)
 564         stats->maxlocal = reg+1;
 565 }
 566
 567 static void callcode(currentstats_t*stats, int pos, int stack, int scope)
 568 {
 569     while(pos<stats->num) {
 570         if(stats->stack[pos].seen) {
 571             if(stats->stack[pos].stackpos != stack ||
 572                stats->stack[pos].scopepos != scope) {
 573                 fprintf(stderr, "Stack mismatch at pos %d\n", pos);
 574             }
 575             return;
 576         }
 577
 578         stats->stack[pos].seen = 1;
 579         stats->stack[pos].stackpos = stack;
 580         stats->stack[pos].scopepos = scope;
 581
 582         abc_code_t*c = stats->stack[pos].code;
 583         opcode_t*op = opcode_get(c->opcode);
 584
 585         printf("Walking %s at position %d, stack=%d, scope=%d\n", op->name, pos, stack, scope);
 586
 587         stack += stack_minus(c);
 588
 589         if(stack<0) {
 590             fprintf(stderr, "error: stack underflow at %d (%s)\n", pos, op->name);
 591             return;
 592         }
 593
 594         stack += op->stack_plus;
 595         scope += op->scope_stack_plus;
 596
 597         if(stack > stats->maxstack)
 598             stats->maxstack = stack;
 599         if(scope > stats->maxscope)
 600             stats->maxscope = scope;
 601
 602         if(op->flags & OP_REGISTER) {
 603             char*p = op->params;
 604             int pos = 0;
 605             char ok=0;
 606             while(*p) {
 607                 if(*p=='r') {
 608                     handleregister(stats, (ptroff_t)c->data[pos]);
 609                     ok = 1;
 610                 }
 611                 p++;
 612             }
 613             if(!ok) {
 614                 handleregister(stats, c->opcode&3);
 615             }
 616         }
 617         if(op->flags & (OP_THROW|OP_RETURN))
 618             return;
 619         if(op->flags & OP_JUMP) {
 620             c = c->branch;
 621             pos = c->pos;
 622             continue;
 623         }
 624         if(op->flags & OP_BRANCH) {
 625             int newpos = c->branch->pos;
 626             callcode(stats, newpos, stack, scope);
 627         }
 628
 629         pos++;
 630         if(pos<stats->num) {
 631             assert(c->next == stats->stack[pos].code);
 632         }
 633     }
 634 }
 635
 636 codestats_t code_get_statistics(abc_code_t*code)
 637 {
 638     code = code_find_start(code);
 639     int num = 0;
 640     abc_code_t*c = code;
 641     while(c) {
 642         num++;
 643         c = c->next;
 644     }
 645     currentstats_t current;
 646     current.stack = rfx_calloc(sizeof(stackpos_t)*num);
 647     current.maxlocal = 0;
 648     current.maxstack = 0;
 649     current.maxscope = 0;
 650     current.num = num;
 651
 652     num = 0;
 653     c = code;
 654     while(c) {
 655         //crosslink
 656         current.stack[num].code = c;
 657         c->pos = num;
 658         num++;
 659         c = c->next;
 660     }
 661     callcode(&current, 0, 0, 0);
 662
 663     free(current.stack);
 664
 665     codestats_t stats;
 666     stats.local_count = current.maxlocal;
 667     stats.max_stack = current.maxstack;
 668     stats.init_scope_depth = 0;
 669     stats.max_scope_depth = current.maxscope;
 670     return stats;
 671 }
 672 abc_code_t* add_opcode(abc_code_t*atag, U8 op)
 673 {
 674     abc_code_t*tmp = (abc_code_t*)malloc(sizeof(abc_code_t));
 675     tmp->opcode = op;
 676     tmp->next = 0;
 677     if(atag) {
 678         tmp->prev = atag;
 679         atag->next = tmp;
 680     } else {
 681         tmp->prev = 0;
 682     }
 683     return tmp;
 684 }
 685