lib/as3/opcodes.c

   1 #include "opcodes.h"
   2 code_t* abc_add(code_t*prev)
   3 {
   4     code_t*self = add_opcode(prev, 0xa0);
   5     return self;
   6 }
   7 code_t* abc_add_i(code_t*prev)
   8 {
   9     code_t*self = add_opcode(prev, 0xc5);
  10     return self;
  11 }
  12 code_t* abc_astype(code_t*prev, char* name)
  13 {
  14     code_t*self = add_opcode(prev, 0x86);
  15     self->data[0] = multiname_fromstring(name);
  16     return self;
  17 }
  18 code_t* abc_astype2(code_t*prev, multiname_t* name)
  19 {
  20     code_t*self = add_opcode(prev, 0x86);
  21     self->data[0] = multiname_clone(name);
  22     return self;
  23 }
  24 code_t* abc_astypelate(code_t*prev)
  25 {
  26     code_t*self = add_opcode(prev, 0x87);
  27     return self;
  28 }
  29 code_t* abc_bitand(code_t*prev)
  30 {
  31     code_t*self = add_opcode(prev, 0xA8);
  32     return self;
  33 }
  34 code_t* abc_bitnot(code_t*prev)
  35 {
  36     code_t*self = add_opcode(prev, 0x97);
  37     return self;
  38 }
  39 code_t* abc_bitor(code_t*prev)
  40 {
  41     code_t*self = add_opcode(prev, 0xa9);
  42     return self;
  43 }
  44 code_t* abc_bitxor(code_t*prev)
  45 {
  46     code_t*self = add_opcode(prev, 0xaa);
  47     return self;
  48 }
  49 code_t* abc_call(code_t*prev, int v)
  50 {
  51     code_t*self = add_opcode(prev, 0x41);
  52     self->data[0] = (void*)(ptroff_t)v;
  53     return self;
  54 }
  55 code_t* abc_callmethod(code_t*prev, abc_method_body_t* m, int v)
  56 {
  57     code_t*self = add_opcode(prev, 0x43);
  58     self->data[0] = m;
  59     self->data[1] = (void*)(ptroff_t)v;
  60     return self;
  61 }
  62 code_t* abc_callproplex(code_t*prev, char* name, int v)
  63 {
  64     code_t*self = add_opcode(prev, 0x4c);
  65     self->data[0] = multiname_fromstring(name);
  66     self->data[1] = (void*)(ptroff_t)v;
  67     return self;
  68 }
  69 code_t* abc_callproplex2(code_t*prev, multiname_t* name, int v)
  70 {
  71     code_t*self = add_opcode(prev, 0x4c);
  72     self->data[0] = multiname_clone(name);
  73     self->data[1] = (void*)(ptroff_t)v;
  74     return self;
  75 }
  76 code_t* abc_callproperty(code_t*prev, char* name, int v)
  77 {
  78     code_t*self = add_opcode(prev, 0x46);
  79     self->data[0] = multiname_fromstring(name);
  80     self->data[1] = (void*)(ptroff_t)v;
  81     return self;
  82 }
  83 code_t* abc_callproperty2(code_t*prev, multiname_t* name, int v)
  84 {
  85     code_t*self = add_opcode(prev, 0x46);
  86     self->data[0] = multiname_clone(name);
  87     self->data[1] = (void*)(ptroff_t)v;
  88     return self;
  89 }
  90 code_t* abc_callpropvoid(code_t*prev, char* name, int v)
  91 {
  92     code_t*self = add_opcode(prev, 0x4f);
  93     self->data[0] = multiname_fromstring(name);
  94     self->data[1] = (void*)(ptroff_t)v;
  95     return self;
  96 }
  97 code_t* abc_callpropvoid2(code_t*prev, multiname_t* name, int v)
  98 {
  99     code_t*self = add_opcode(prev, 0x4f);
 100     self->data[0] = multiname_clone(name);
 101     self->data[1] = (void*)(ptroff_t)v;
 102     return self;
 103 }
 104 code_t* abc_callstatic(code_t*prev, abc_method_t* m, int v)
 105 {
 106     code_t*self = add_opcode(prev, 0x44);
 107     self->data[0] = m;
 108     self->data[1] = (void*)(ptroff_t)v;
 109     return self;
 110 }
 111 code_t* abc_callsuper(code_t*prev, char* name, int v)
 112 {
 113     code_t*self = add_opcode(prev, 0x45);
 114     self->data[0] = multiname_fromstring(name);
 115     self->data[1] = (void*)(ptroff_t)v;
 116     return self;
 117 }
 118 code_t* abc_callsuper2(code_t*prev, multiname_t* name, int v)
 119 {
 120     code_t*self = add_opcode(prev, 0x45);
 121     self->data[0] = multiname_clone(name);
 122     self->data[1] = (void*)(ptroff_t)v;
 123     return self;
 124 }
 125 code_t* abc_callsupervoid(code_t*prev, char* name, int v)
 126 {
 127     code_t*self = add_opcode(prev, 0x4e);
 128     self->data[0] = multiname_fromstring(name);
 129     self->data[1] = (void*)(ptroff_t)v;
 130     return self;
 131 }
 132 code_t* abc_callsupervoid2(code_t*prev, multiname_t* name, int v)
 133 {
 134     code_t*self = add_opcode(prev, 0x4e);
 135     self->data[0] = multiname_clone(name);
 136     self->data[1] = (void*)(ptroff_t)v;
 137     return self;
 138 }
 139 code_t* abc_checkfilter(code_t*prev)
 140 {
 141     code_t*self = add_opcode(prev, 0x78);
 142     return self;
 143 }
 144 code_t* abc_coerce(code_t*prev, char* name)
 145 {
 146     code_t*self = add_opcode(prev, 0x80);
 147     self->data[0] = multiname_fromstring(name);
 148     return self;
 149 }
 150 code_t* abc_coerce2(code_t*prev, multiname_t* name)
 151 {
 152     code_t*self = add_opcode(prev, 0x80);
 153     self->data[0] = multiname_clone(name);
 154     return self;
 155 }
 156 code_t* abc_coerce_a(code_t*prev)
 157 {
 158     code_t*self = add_opcode(prev, 0x82);
 159     return self;
 160 }
 161 code_t* abc_coerce_s(code_t*prev)
 162 {
 163     code_t*self = add_opcode(prev, 0x85);
 164     return self;
 165 }
 166 code_t* abc_construct(code_t*prev, int v)
 167 {
 168     code_t*self = add_opcode(prev, 0x42);
 169     self->data[0] = (void*)(ptroff_t)v;
 170     return self;
 171 }
 172 code_t* abc_constructprop(code_t*prev, char* name, int v)
 173 {
 174     code_t*self = add_opcode(prev, 0x4a);
 175     self->data[0] = multiname_fromstring(name);
 176     self->data[1] = (void*)(ptroff_t)v;
 177     return self;
 178 }
 179 code_t* abc_constructprop2(code_t*prev, multiname_t* name, int v)
 180 {
 181     code_t*self = add_opcode(prev, 0x4a);
 182     self->data[0] = multiname_clone(name);
 183     self->data[1] = (void*)(ptroff_t)v;
 184     return self;
 185 }
 186 code_t* abc_constructsuper(code_t*prev, int v)
 187 {
 188     code_t*self = add_opcode(prev, 0x49);
 189     self->data[0] = (void*)(ptroff_t)v;
 190     return self;
 191 }
 192 code_t* abc_convert_b(code_t*prev)
 193 {
 194     code_t*self = add_opcode(prev, 0x76);
 195     return self;
 196 }
 197 code_t* abc_convert_i(code_t*prev)
 198 {
 199     code_t*self = add_opcode(prev, 0x73);
 200     return self;
 201 }
 202 code_t* abc_convert_d(code_t*prev)
 203 {
 204     code_t*self = add_opcode(prev, 0x75);
 205     return self;
 206 }
 207 code_t* abc_convert_o(code_t*prev)
 208 {
 209     code_t*self = add_opcode(prev, 0x77);
 210     return self;
 211 }
 212 code_t* abc_convert_u(code_t*prev)
 213 {
 214     code_t*self = add_opcode(prev, 0x74);
 215     return self;
 216 }
 217 code_t* abc_convert_s(code_t*prev)
 218 {
 219     code_t*self = add_opcode(prev, 0x70);
 220     return self;
 221 }
 222 code_t* abc_debug(code_t*prev, void* debuginfo)
 223 {
 224     code_t*self = add_opcode(prev, 0xef);
 225     /* FIXME: write debuginfo debuginfo */
 226     return self;
 227 }
 228 code_t* abc_debugfile(code_t*prev, char* s)
 229 {
 230     code_t*self = add_opcode(prev, 0xf1);
 231     self->data[0] = strdup(s);
 232     return self;
 233 }
 234 code_t* abc_debugline(code_t*prev, int v)
 235 {
 236     code_t*self = add_opcode(prev, 0xf0);
 237     self->data[0] = (void*)(ptroff_t)v;
 238     return self;
 239 }
 240 code_t* abc_declocal(code_t*prev, int reg)
 241 {
 242     code_t*self = add_opcode(prev, 0x94);
 243     self->data[0] = (void*)(ptroff_t)reg;
 244     return self;
 245 }
 246 code_t* abc_declocal_i(code_t*prev, int reg)
 247 {
 248     code_t*self = add_opcode(prev, 0xc3);
 249     self->data[0] = (void*)(ptroff_t)reg;
 250     return self;
 251 }
 252 code_t* abc_decrement(code_t*prev)
 253 {
 254     code_t*self = add_opcode(prev, 0x93);
 255     return self;
 256 }
 257 code_t* abc_decrement_i(code_t*prev)
 258 {
 259     code_t*self = add_opcode(prev, 0xc1);
 260     return self;
 261 }
 262 code_t* abc_deleteproperty(code_t*prev, char* name)
 263 {
 264     code_t*self = add_opcode(prev, 0x6a);
 265     self->data[0] = multiname_fromstring(name);
 266     return self;
 267 }
 268 code_t* abc_deleteproperty2(code_t*prev, multiname_t* name)
 269 {
 270     code_t*self = add_opcode(prev, 0x6a);
 271     self->data[0] = multiname_clone(name);
 272     return self;
 273 }
 274 code_t* abc_divide(code_t*prev)
 275 {
 276     code_t*self = add_opcode(prev, 0xa3);
 277     return self;
 278 }
 279 code_t* abc_dup(code_t*prev)
 280 {
 281     code_t*self = add_opcode(prev, 0x2a);
 282     return self;
 283 }
 284 code_t* abc_dxns(code_t*prev, char* s)
 285 {
 286     code_t*self = add_opcode(prev, 0x06);
 287     self->data[0] = strdup(s);
 288     return self;
 289 }
 290 code_t* abc_dxnslate(code_t*prev)
 291 {
 292     code_t*self = add_opcode(prev, 0x07);
 293     return self;
 294 }
 295 code_t* abc_equals(code_t*prev)
 296 {
 297     code_t*self = add_opcode(prev, 0xab);
 298     return self;
 299 }
 300 code_t* abc_esc_xattr(code_t*prev)
 301 {
 302     code_t*self = add_opcode(prev, 0x72);
 303     return self;
 304 }
 305 code_t* abc_esc_xelem(code_t*prev)
 306 {
 307     code_t*self = add_opcode(prev, 0x71);
 308     return self;
 309 }
 310 code_t* abc_findproperty(code_t*prev, char* name)
 311 {
 312     code_t*self = add_opcode(prev, 0x5e);
 313     self->data[0] = multiname_fromstring(name);
 314     return self;
 315 }
 316 code_t* abc_findproperty2(code_t*prev, multiname_t* name)
 317 {
 318     code_t*self = add_opcode(prev, 0x5e);
 319     self->data[0] = multiname_clone(name);
 320     return self;
 321 }
 322 code_t* abc_findpropstrict(code_t*prev, char* name)
 323 {
 324     code_t*self = add_opcode(prev, 0x5d);
 325     self->data[0] = multiname_fromstring(name);
 326     return self;
 327 }
 328 code_t* abc_findpropstrict2(code_t*prev, multiname_t* name)
 329 {
 330     code_t*self = add_opcode(prev, 0x5d);
 331     self->data[0] = multiname_clone(name);
 332     return self;
 333 }
 334 code_t* abc_getdescendants(code_t*prev, char* name)
 335 {
 336     code_t*self = add_opcode(prev, 0x59);
 337     self->data[0] = multiname_fromstring(name);
 338     return self;
 339 }
 340 code_t* abc_getdescendants2(code_t*prev, multiname_t* name)
 341 {
 342     code_t*self = add_opcode(prev, 0x59);
 343     self->data[0] = multiname_clone(name);
 344     return self;
 345 }
 346 code_t* abc_getglobalscope(code_t*prev)
 347 {
 348     code_t*self = add_opcode(prev, 0x64);
 349     return self;
 350 }
 351 code_t* abc_getglobalslot(code_t*prev, int v)
 352 {
 353     code_t*self = add_opcode(prev, 0x6e);
 354     self->data[0] = (void*)(ptroff_t)v;
 355     return self;
 356 }
 357 code_t* abc_getlex(code_t*prev, char* name)
 358 {
 359     code_t*self = add_opcode(prev, 0x60);
 360     self->data[0] = multiname_fromstring(name);
 361     return self;
 362 }
 363 code_t* abc_getlex2(code_t*prev, multiname_t* name)
 364 {
 365     code_t*self = add_opcode(prev, 0x60);
 366     self->data[0] = multiname_clone(name);
 367     return self;
 368 }
 369 code_t* abc_getlocal(code_t*prev, int reg)
 370 {
 371     code_t*self = add_opcode(prev, 0x62);
 372     self->data[0] = (void*)(ptroff_t)reg;
 373     return self;
 374 }
 375 code_t* abc_getlocal_0(code_t*prev)
 376 {
 377     code_t*self = add_opcode(prev, 0xd0);
 378     return self;
 379 }
 380 code_t* abc_getlocal_1(code_t*prev)
 381 {
 382     code_t*self = add_opcode(prev, 0xd1);
 383     return self;
 384 }
 385 code_t* abc_getlocal_2(code_t*prev)
 386 {
 387     code_t*self = add_opcode(prev, 0xd2);
 388     return self;
 389 }
 390 code_t* abc_getlocal_3(code_t*prev)
 391 {
 392     code_t*self = add_opcode(prev, 0xd3);
 393     return self;
 394 }
 395 code_t* abc_getproperty(code_t*prev, char* name)
 396 {
 397     code_t*self = add_opcode(prev, 0x66);
 398     self->data[0] = multiname_fromstring(name);
 399     return self;
 400 }
 401 code_t* abc_getproperty2(code_t*prev, multiname_t* name)
 402 {
 403     code_t*self = add_opcode(prev, 0x66);
 404     self->data[0] = multiname_clone(name);
 405     return self;
 406 }
 407 code_t* abc_getscopeobject(code_t*prev, int v)
 408 {
 409     code_t*self = add_opcode(prev, 0x65);
 410     self->data[0] = (void*)(ptroff_t)v;
 411     return self;
 412 }
 413 code_t* abc_getslot(code_t*prev, int v)
 414 {
 415     code_t*self = add_opcode(prev, 0x6c);
 416     self->data[0] = (void*)(ptroff_t)v;
 417     return self;
 418 }
 419 code_t* abc_getsuper(code_t*prev, char* name)
 420 {
 421     code_t*self = add_opcode(prev, 0x04);
 422     self->data[0] = multiname_fromstring(name);
 423     return self;
 424 }
 425 code_t* abc_getsuper2(code_t*prev, multiname_t* name)
 426 {
 427     code_t*self = add_opcode(prev, 0x04);
 428     self->data[0] = multiname_clone(name);
 429     return self;
 430 }
 431 code_t* abc_greaterthan(code_t*prev)
 432 {
 433     code_t*self = add_opcode(prev, 0xaf);
 434     return self;
 435 }
 436 code_t* abc_greaterequals(code_t*prev)
 437 {
 438     code_t*self = add_opcode(prev, 0xb0);
 439     return self;
 440 }
 441 code_t* abc_hasnext(code_t*prev)
 442 {
 443     code_t*self = add_opcode(prev, 0x1f);
 444     return self;
 445 }
 446 code_t* abc_hasnext2(code_t*prev, int reg, int reg2)
 447 {
 448     code_t*self = add_opcode(prev, 0x32);
 449     self->data[0] = (void*)(ptroff_t)reg;
 450     self->data[1] = (void*)(ptroff_t)reg2;
 451     return self;
 452 }
 453 code_t* abc_ifeq(code_t*prev, code_t* label)
 454 {
 455     code_t*self = add_opcode(prev, 0x13);
 456     self->data[0] = 0; //placeholder
 457     self->branch = label;
 458     return self;
 459 }
 460 code_t* abc_iffalse(code_t*prev, code_t* label)
 461 {
 462     code_t*self = add_opcode(prev, 0x12);
 463     self->data[0] = 0; //placeholder
 464     self->branch = label;
 465     return self;
 466 }
 467 code_t* abc_ifge(code_t*prev, code_t* label)
 468 {
 469     code_t*self = add_opcode(prev, 0x18);
 470     self->data[0] = 0; //placeholder
 471     self->branch = label;
 472     return self;
 473 }
 474 code_t* abc_ifgt(code_t*prev, code_t* label)
 475 {
 476     code_t*self = add_opcode(prev, 0x17);
 477     self->data[0] = 0; //placeholder
 478     self->branch = label;
 479     return self;
 480 }
 481 code_t* abc_ifle(code_t*prev, code_t* label)
 482 {
 483     code_t*self = add_opcode(prev, 0x16);
 484     self->data[0] = 0; //placeholder
 485     self->branch = label;
 486     return self;
 487 }
 488 code_t* abc_iflt(code_t*prev, code_t* label)
 489 {
 490     code_t*self = add_opcode(prev, 0x15);
 491     self->data[0] = 0; //placeholder
 492     self->branch = label;
 493     return self;
 494 }
 495 code_t* abc_ifnge(code_t*prev, code_t* label)
 496 {
 497     code_t*self = add_opcode(prev, 0x0f);
 498     self->data[0] = 0; //placeholder
 499     self->branch = label;
 500     return self;
 501 }
 502 code_t* abc_ifngt(code_t*prev, code_t* label)
 503 {
 504     code_t*self = add_opcode(prev, 0x0e);
 505     self->data[0] = 0; //placeholder
 506     self->branch = label;
 507     return self;
 508 }
 509 code_t* abc_ifnle(code_t*prev, code_t* label)
 510 {
 511     code_t*self = add_opcode(prev, 0x0d);
 512     self->data[0] = 0; //placeholder
 513     self->branch = label;
 514     return self;
 515 }
 516 code_t* abc_ifnlt(code_t*prev, code_t* label)
 517 {
 518     code_t*self = add_opcode(prev, 0x0c);
 519     self->data[0] = 0; //placeholder
 520     self->branch = label;
 521     return self;
 522 }
 523 code_t* abc_ifne(code_t*prev, code_t* label)
 524 {
 525     code_t*self = add_opcode(prev, 0x14);
 526     self->data[0] = 0; //placeholder
 527     self->branch = label;
 528     return self;
 529 }
 530 code_t* abc_ifstricteq(code_t*prev, code_t* label)
 531 {
 532     code_t*self = add_opcode(prev, 0x19);
 533     self->data[0] = 0; //placeholder
 534     self->branch = label;
 535     return self;
 536 }
 537 code_t* abc_ifstrictne(code_t*prev, code_t* label)
 538 {
 539     code_t*self = add_opcode(prev, 0x1a);
 540     self->data[0] = 0; //placeholder
 541     self->branch = label;
 542     return self;
 543 }
 544 code_t* abc_iftrue(code_t*prev, code_t* label)
 545 {
 546     code_t*self = add_opcode(prev, 0x11);
 547     self->data[0] = 0; //placeholder
 548     self->branch = label;
 549     return self;
 550 }
 551 code_t* abc_in(code_t*prev)
 552 {
 553     code_t*self = add_opcode(prev, 0xb4);
 554     return self;
 555 }
 556 code_t* abc_inclocal(code_t*prev, int reg)
 557 {
 558     code_t*self = add_opcode(prev, 0x92);
 559     self->data[0] = (void*)(ptroff_t)reg;
 560     return self;
 561 }
 562 code_t* abc_inclocal_i(code_t*prev, int reg)
 563 {
 564     code_t*self = add_opcode(prev, 0xc2);
 565     self->data[0] = (void*)(ptroff_t)reg;
 566     return self;
 567 }
 568 code_t* abc_increment(code_t*prev)
 569 {
 570     code_t*self = add_opcode(prev, 0x91);
 571     return self;
 572 }
 573 code_t* abc_increment_i(code_t*prev)
 574 {
 575     code_t*self = add_opcode(prev, 0xc0);
 576     return self;
 577 }
 578 code_t* abc_initproperty(code_t*prev, char* name)
 579 {
 580     code_t*self = add_opcode(prev, 0x68);
 581     self->data[0] = multiname_fromstring(name);
 582     return self;
 583 }
 584 code_t* abc_initproperty2(code_t*prev, multiname_t* name)
 585 {
 586     code_t*self = add_opcode(prev, 0x68);
 587     self->data[0] = multiname_clone(name);
 588     return self;
 589 }
 590 code_t* abc_instanceof(code_t*prev)
 591 {
 592     code_t*self = add_opcode(prev, 0xb1);
 593     return self;
 594 }
 595 code_t* abc_istype(code_t*prev, char* name)
 596 {
 597     code_t*self = add_opcode(prev, 0xb2);
 598     self->data[0] = multiname_fromstring(name);
 599     return self;
 600 }
 601 code_t* abc_istype2(code_t*prev, multiname_t* name)
 602 {
 603     code_t*self = add_opcode(prev, 0xb2);
 604     self->data[0] = multiname_clone(name);
 605     return self;
 606 }
 607 code_t* abc_istypelate(code_t*prev)
 608 {
 609     code_t*self = add_opcode(prev, 0xb3);
 610     return self;
 611 }
 612 code_t* abc_jump(code_t*prev, code_t* label)
 613 {
 614     code_t*self = add_opcode(prev, 0x10);
 615     self->data[0] = 0; //placeholder
 616     self->branch = label;
 617     return self;
 618 }
 619 code_t* abc_kill(code_t*prev, int reg)
 620 {
 621     code_t*self = add_opcode(prev, 0x08);
 622     self->data[0] = (void*)(ptroff_t)reg;
 623     return self;
 624 }
 625 code_t* abc_label(code_t*prev)
 626 {
 627     code_t*self = add_opcode(prev, 0x09);
 628     return self;
 629 }
 630 code_t* abc_lessequals(code_t*prev)
 631 {
 632     code_t*self = add_opcode(prev, 0xae);
 633     return self;
 634 }
 635 code_t* abc_lessthan(code_t*prev)
 636 {
 637     code_t*self = add_opcode(prev, 0xad);
 638     return self;
 639 }
 640 code_t* abc_lookupswitch(code_t*prev, lookupswitch_t* l)
 641 {
 642     code_t*self = add_opcode(prev, 0x1b);
 643     self->data[0] = l;
 644     return self;
 645 }
 646 code_t* abc_lshift(code_t*prev)
 647 {
 648     code_t*self = add_opcode(prev, 0xa5);
 649     return self;
 650 }
 651 code_t* abc_modulo(code_t*prev)
 652 {
 653     code_t*self = add_opcode(prev, 0xa4);
 654     return self;
 655 }
 656 code_t* abc_multiply(code_t*prev)
 657 {
 658     code_t*self = add_opcode(prev, 0xa2);
 659     return self;
 660 }
 661 code_t* abc_multiply_i(code_t*prev)
 662 {
 663     code_t*self = add_opcode(prev, 0xc7);
 664     return self;
 665 }
 666 code_t* abc_negate(code_t*prev)
 667 {
 668     code_t*self = add_opcode(prev, 0x90);
 669     return self;
 670 }
 671 code_t* abc_negate_i(code_t*prev)
 672 {
 673     code_t*self = add_opcode(prev, 0xc4);
 674     return self;
 675 }
 676 code_t* abc_newactivation(code_t*prev)
 677 {
 678     code_t*self = add_opcode(prev, 0x57);
 679     return self;
 680 }
 681 code_t* abc_newarray(code_t*prev, int v)
 682 {
 683     code_t*self = add_opcode(prev, 0x56);
 684     self->data[0] = (void*)(ptroff_t)v;
 685     return self;
 686 }
 687 code_t* abc_newcatch(code_t*prev, int v)
 688 {
 689     code_t*self = add_opcode(prev, 0x5a);
 690     self->data[0] = (void*)(ptroff_t)v;
 691     return self;
 692 }
 693 code_t* abc_newclass(code_t*prev, abc_class_t* m)
 694 {
 695     code_t*self = add_opcode(prev, 0x58);
 696     self->data[0] = m;
 697     return self;
 698 }
 699 code_t* abc_newfunction(code_t*prev, abc_method_body_t* m)
 700 {
 701     code_t*self = add_opcode(prev, 0x40);
 702     self->data[0] = m;
 703     return self;
 704 }
 705 code_t* abc_newobject(code_t*prev, int v)
 706 {
 707     code_t*self = add_opcode(prev, 0x55);
 708     self->data[0] = (void*)(ptroff_t)v;
 709     return self;
 710 }
 711 code_t* abc_nextname(code_t*prev)
 712 {
 713     code_t*self = add_opcode(prev, 0x1e);
 714     return self;
 715 }
 716 code_t* abc_nextvalue(code_t*prev)
 717 {
 718     code_t*self = add_opcode(prev, 0x23);
 719     return self;
 720 }
 721 code_t* abc_nop(code_t*prev)
 722 {
 723     code_t*self = add_opcode(prev, 0x02);
 724     return self;
 725 }
 726 code_t* abc_not(code_t*prev)
 727 {
 728     code_t*self = add_opcode(prev, 0x96);
 729     return self;
 730 }
 731 code_t* abc_pop(code_t*prev)
 732 {
 733     code_t*self = add_opcode(prev, 0x29);
 734     return self;
 735 }
 736 code_t* abc_popscope(code_t*prev)
 737 {
 738     code_t*self = add_opcode(prev, 0x1d);
 739     return self;
 740 }
 741 code_t* abc_pushbyte(code_t*prev, int v)
 742 {
 743     code_t*self = add_opcode(prev, 0x24);
 744     self->data[0] = (void*)(ptroff_t)v;
 745     return self;
 746 }
 747 code_t* abc_pushdouble(code_t*prev, double f)
 748 {
 749     code_t*self = add_opcode(prev, 0x2f);
 750     double*fp = malloc(sizeof(double));
 751     *fp = f;
 752     self->data[0] = fp;
 753     return self;
 754 }
 755 code_t* abc_pushfalse(code_t*prev)
 756 {
 757     code_t*self = add_opcode(prev, 0x27);
 758     return self;
 759 }
 760 code_t* abc_pushint(code_t*prev, int i)
 761 {
 762     code_t*self = add_opcode(prev, 0x2d);
 763     self->data[0] = (void*)(ptroff_t)i;
 764     return self;
 765 }
 766 code_t* abc_pushnamespace(code_t*prev, int v)
 767 {
 768     code_t*self = add_opcode(prev, 0x31);
 769     self->data[0] = (void*)(ptroff_t)v;
 770     return self;
 771 }
 772 code_t* abc_pushnan(code_t*prev)
 773 {
 774     code_t*self = add_opcode(prev, 0x28);
 775     return self;
 776 }
 777 code_t* abc_pushnull(code_t*prev)
 778 {
 779     code_t*self = add_opcode(prev, 0x20);
 780     return self;
 781 }
 782 code_t* abc_pushscope(code_t*prev)
 783 {
 784     code_t*self = add_opcode(prev, 0x30);
 785     return self;
 786 }
 787 code_t* abc_pushshort(code_t*prev, int v)
 788 {
 789     code_t*self = add_opcode(prev, 0x25);
 790     self->data[0] = (void*)(ptroff_t)v;
 791     return self;
 792 }
 793 code_t* abc_pushstring(code_t*prev, char* s)
 794 {
 795     code_t*self = add_opcode(prev, 0x2c);
 796     self->data[0] = strdup(s);
 797     return self;
 798 }
 799 code_t* abc_pushtrue(code_t*prev)
 800 {
 801     code_t*self = add_opcode(prev, 0x26);
 802     return self;
 803 }
 804 code_t* abc_pushuint(code_t*prev, unsigned int u)
 805 {
 806     code_t*self = add_opcode(prev, 0x2e);
 807     self->data[0] = (void*)(ptroff_t)u;
 808     return self;
 809 }
 810 code_t* abc_pushundefined(code_t*prev)
 811 {
 812     code_t*self = add_opcode(prev, 0x21);
 813     return self;
 814 }
 815 code_t* abc_pushwith(code_t*prev)
 816 {
 817     code_t*self = add_opcode(prev, 0x1c);
 818     return self;
 819 }
 820 code_t* abc_returnvalue(code_t*prev)
 821 {
 822     code_t*self = add_opcode(prev, 0x48);
 823     return self;
 824 }
 825 code_t* abc_returnvoid(code_t*prev)
 826 {
 827     code_t*self = add_opcode(prev, 0x47);
 828     return self;
 829 }
 830 code_t* abc_rshift(code_t*prev)
 831 {
 832     code_t*self = add_opcode(prev, 0xa6);
 833     return self;
 834 }
 835 code_t* abc_setlocal(code_t*prev, int reg)
 836 {
 837     code_t*self = add_opcode(prev, 0x63);
 838     self->data[0] = (void*)(ptroff_t)reg;
 839     return self;
 840 }
 841 code_t* abc_setlocal_0(code_t*prev)
 842 {
 843     code_t*self = add_opcode(prev, 0xd4);
 844     return self;
 845 }
 846 code_t* abc_setlocal_1(code_t*prev)
 847 {
 848     code_t*self = add_opcode(prev, 0xd5);
 849     return self;
 850 }
 851 code_t* abc_setlocal_2(code_t*prev)
 852 {
 853     code_t*self = add_opcode(prev, 0xd6);
 854     return self;
 855 }
 856 code_t* abc_setlocal_3(code_t*prev)
 857 {
 858     code_t*self = add_opcode(prev, 0xd7);
 859     return self;
 860 }
 861 code_t* abc_setglobalslot(code_t*prev, int v)
 862 {
 863     code_t*self = add_opcode(prev, 0x6f);
 864     self->data[0] = (void*)(ptroff_t)v;
 865     return self;
 866 }
 867 code_t* abc_setproperty(code_t*prev, char* name)
 868 {
 869     code_t*self = add_opcode(prev, 0x61);
 870     self->data[0] = multiname_fromstring(name);
 871     return self;
 872 }
 873 code_t* abc_setproperty2(code_t*prev, multiname_t* name)
 874 {
 875     code_t*self = add_opcode(prev, 0x61);
 876     self->data[0] = multiname_clone(name);
 877     return self;
 878 }
 879 code_t* abc_setslot(code_t*prev, int v)
 880 {
 881     code_t*self = add_opcode(prev, 0x6d);
 882     self->data[0] = (void*)(ptroff_t)v;
 883     return self;
 884 }
 885 code_t* abc_setsuper(code_t*prev, char* name)
 886 {
 887     code_t*self = add_opcode(prev, 0x05);
 888     self->data[0] = multiname_fromstring(name);
 889     return self;
 890 }
 891 code_t* abc_setsuper2(code_t*prev, multiname_t* name)
 892 {
 893     code_t*self = add_opcode(prev, 0x05);
 894     self->data[0] = multiname_clone(name);
 895     return self;
 896 }
 897 code_t* abc_strictequals(code_t*prev)
 898 {
 899     code_t*self = add_opcode(prev, 0xac);
 900     return self;
 901 }
 902 code_t* abc_subtract(code_t*prev)
 903 {
 904     code_t*self = add_opcode(prev, 0xa1);
 905     return self;
 906 }
 907 code_t* abc_subtract_i(code_t*prev)
 908 {
 909     code_t*self = add_opcode(prev, 0xc6);
 910     return self;
 911 }
 912 code_t* abc_swap(code_t*prev)
 913 {
 914     code_t*self = add_opcode(prev, 0x2b);
 915     return self;
 916 }
 917 code_t* abc_throw(code_t*prev)
 918 {
 919     code_t*self = add_opcode(prev, 0x03);
 920     return self;
 921 }
 922 code_t* abc_typeof(code_t*prev)
 923 {
 924     code_t*self = add_opcode(prev, 0x95);
 925     return self;
 926 }
 927 code_t* abc_urshift(code_t*prev)
 928 {
 929     code_t*self = add_opcode(prev, 0xa7);
 930     return self;
 931 }
 932 code_t* abc_applytype(code_t*prev, int v)
 933 {
 934     code_t*self = add_opcode(prev, 0x53);
 935     self->data[0] = (void*)(ptroff_t)v;
 936     return self;
 937 }
 938 code_t* abc___break__(code_t*prev)
 939 {
 940     code_t*self = add_opcode(prev, 0xff);
 941     return self;
 942 }