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_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_body_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* name)
 229 {
 230     code_t*self = add_opcode(prev, 0xf1);
 231     self->data[0] = string_new4(name);
 232     return self;
 233 }
 234 code_t* abc_debugfile2(code_t*prev, string_t* s)
 235 {
 236     code_t*self = add_opcode(prev, 0xf1);
 237     self->data[0] = string_dup3(s);
 238     return self;
 239 }
 240 code_t* abc_debugline(code_t*prev, int v)
 241 {
 242     code_t*self = add_opcode(prev, 0xf0);
 243     self->data[0] = (void*)(ptroff_t)v;
 244     return self;
 245 }
 246 code_t* abc_declocal(code_t*prev, int reg)
 247 {
 248     code_t*self = add_opcode(prev, 0x94);
 249     self->data[0] = (void*)(ptroff_t)reg;
 250     return self;
 251 }
 252 code_t* abc_declocal_i(code_t*prev, int reg)
 253 {
 254     code_t*self = add_opcode(prev, 0xc3);
 255     self->data[0] = (void*)(ptroff_t)reg;
 256     return self;
 257 }
 258 code_t* abc_decrement(code_t*prev)
 259 {
 260     code_t*self = add_opcode(prev, 0x93);
 261     return self;
 262 }
 263 code_t* abc_decrement_i(code_t*prev)
 264 {
 265     code_t*self = add_opcode(prev, 0xc1);
 266     return self;
 267 }
 268 code_t* abc_deleteproperty(code_t*prev, char* name)
 269 {
 270     code_t*self = add_opcode(prev, 0x6a);
 271     self->data[0] = multiname_fromstring(name);
 272     return self;
 273 }
 274 code_t* abc_deleteproperty2(code_t*prev, multiname_t* name)
 275 {
 276     code_t*self = add_opcode(prev, 0x6a);
 277     self->data[0] = multiname_clone(name);
 278     return self;
 279 }
 280 code_t* abc_divide(code_t*prev)
 281 {
 282     code_t*self = add_opcode(prev, 0xa3);
 283     return self;
 284 }
 285 code_t* abc_dup(code_t*prev)
 286 {
 287     code_t*self = add_opcode(prev, 0x2a);
 288     return self;
 289 }
 290 code_t* abc_dxns(code_t*prev, char* name)
 291 {
 292     code_t*self = add_opcode(prev, 0x06);
 293     self->data[0] = string_new4(name);
 294     return self;
 295 }
 296 code_t* abc_dxns2(code_t*prev, string_t* s)
 297 {
 298     code_t*self = add_opcode(prev, 0x06);
 299     self->data[0] = string_dup3(s);
 300     return self;
 301 }
 302 code_t* abc_dxnslate(code_t*prev)
 303 {
 304     code_t*self = add_opcode(prev, 0x07);
 305     return self;
 306 }
 307 code_t* abc_equals(code_t*prev)
 308 {
 309     code_t*self = add_opcode(prev, 0xab);
 310     return self;
 311 }
 312 code_t* abc_esc_xattr(code_t*prev)
 313 {
 314     code_t*self = add_opcode(prev, 0x72);
 315     return self;
 316 }
 317 code_t* abc_esc_xelem(code_t*prev)
 318 {
 319     code_t*self = add_opcode(prev, 0x71);
 320     return self;
 321 }
 322 code_t* abc_findproperty(code_t*prev, char* name)
 323 {
 324     code_t*self = add_opcode(prev, 0x5e);
 325     self->data[0] = multiname_fromstring(name);
 326     return self;
 327 }
 328 code_t* abc_findproperty2(code_t*prev, multiname_t* name)
 329 {
 330     code_t*self = add_opcode(prev, 0x5e);
 331     self->data[0] = multiname_clone(name);
 332     return self;
 333 }
 334 code_t* abc_findpropstrict(code_t*prev, char* name)
 335 {
 336     code_t*self = add_opcode(prev, 0x5d);
 337     self->data[0] = multiname_fromstring(name);
 338     return self;
 339 }
 340 code_t* abc_findpropstrict2(code_t*prev, multiname_t* name)
 341 {
 342     code_t*self = add_opcode(prev, 0x5d);
 343     self->data[0] = multiname_clone(name);
 344     return self;
 345 }
 346 code_t* abc_getdescendants(code_t*prev, char* name)
 347 {
 348     code_t*self = add_opcode(prev, 0x59);
 349     self->data[0] = multiname_fromstring(name);
 350     return self;
 351 }
 352 code_t* abc_getdescendants2(code_t*prev, multiname_t* name)
 353 {
 354     code_t*self = add_opcode(prev, 0x59);
 355     self->data[0] = multiname_clone(name);
 356     return self;
 357 }
 358 code_t* abc_getglobalscope(code_t*prev)
 359 {
 360     code_t*self = add_opcode(prev, 0x64);
 361     return self;
 362 }
 363 code_t* abc_getglobalslot(code_t*prev, int v)
 364 {
 365     code_t*self = add_opcode(prev, 0x6e);
 366     self->data[0] = (void*)(ptroff_t)v;
 367     return self;
 368 }
 369 code_t* abc_getlex(code_t*prev, char* name)
 370 {
 371     code_t*self = add_opcode(prev, 0x60);
 372     self->data[0] = multiname_fromstring(name);
 373     return self;
 374 }
 375 code_t* abc_getlex2(code_t*prev, multiname_t* name)
 376 {
 377     code_t*self = add_opcode(prev, 0x60);
 378     self->data[0] = multiname_clone(name);
 379     return self;
 380 }
 381 code_t* abc_getlocal(code_t*prev, int reg)
 382 {
 383     code_t*self = add_opcode(prev, 0x62);
 384     self->data[0] = (void*)(ptroff_t)reg;
 385     return self;
 386 }
 387 code_t* abc_getlocal_0(code_t*prev)
 388 {
 389     code_t*self = add_opcode(prev, 0xd0);
 390     return self;
 391 }
 392 code_t* abc_getlocal_1(code_t*prev)
 393 {
 394     code_t*self = add_opcode(prev, 0xd1);
 395     return self;
 396 }
 397 code_t* abc_getlocal_2(code_t*prev)
 398 {
 399     code_t*self = add_opcode(prev, 0xd2);
 400     return self;
 401 }
 402 code_t* abc_getlocal_3(code_t*prev)
 403 {
 404     code_t*self = add_opcode(prev, 0xd3);
 405     return self;
 406 }
 407 code_t* abc_getproperty(code_t*prev, char* name)
 408 {
 409     code_t*self = add_opcode(prev, 0x66);
 410     self->data[0] = multiname_fromstring(name);
 411     return self;
 412 }
 413 code_t* abc_getproperty2(code_t*prev, multiname_t* name)
 414 {
 415     code_t*self = add_opcode(prev, 0x66);
 416     self->data[0] = multiname_clone(name);
 417     return self;
 418 }
 419 code_t* abc_getscopeobject(code_t*prev, int v)
 420 {
 421     code_t*self = add_opcode(prev, 0x65);
 422     self->data[0] = (void*)(ptroff_t)v;
 423     return self;
 424 }
 425 code_t* abc_getslot(code_t*prev, int v)
 426 {
 427     code_t*self = add_opcode(prev, 0x6c);
 428     self->data[0] = (void*)(ptroff_t)v;
 429     return self;
 430 }
 431 code_t* abc_getsuper(code_t*prev, char* name)
 432 {
 433     code_t*self = add_opcode(prev, 0x04);
 434     self->data[0] = multiname_fromstring(name);
 435     return self;
 436 }
 437 code_t* abc_getsuper2(code_t*prev, multiname_t* name)
 438 {
 439     code_t*self = add_opcode(prev, 0x04);
 440     self->data[0] = multiname_clone(name);
 441     return self;
 442 }
 443 code_t* abc_greaterthan(code_t*prev)
 444 {
 445     code_t*self = add_opcode(prev, 0xaf);
 446     return self;
 447 }
 448 code_t* abc_greaterequals(code_t*prev)
 449 {
 450     code_t*self = add_opcode(prev, 0xb0);
 451     return self;
 452 }
 453 code_t* abc_hasnext(code_t*prev)
 454 {
 455     code_t*self = add_opcode(prev, 0x1f);
 456     return self;
 457 }
 458 code_t* abc_hasnext2(code_t*prev, int reg, int reg2)
 459 {
 460     code_t*self = add_opcode(prev, 0x32);
 461     self->data[0] = (void*)(ptroff_t)reg;
 462     self->data[1] = (void*)(ptroff_t)reg2;
 463     return self;
 464 }
 465 code_t* abc_ifeq(code_t*prev, code_t* label)
 466 {
 467     code_t*self = add_opcode(prev, 0x13);
 468     self->data[0] = 0; //placeholder
 469     self->branch = label;
 470     return self;
 471 }
 472 code_t* abc_iffalse(code_t*prev, code_t* label)
 473 {
 474     code_t*self = add_opcode(prev, 0x12);
 475     self->data[0] = 0; //placeholder
 476     self->branch = label;
 477     return self;
 478 }
 479 code_t* abc_ifge(code_t*prev, code_t* label)
 480 {
 481     code_t*self = add_opcode(prev, 0x18);
 482     self->data[0] = 0; //placeholder
 483     self->branch = label;
 484     return self;
 485 }
 486 code_t* abc_ifgt(code_t*prev, code_t* label)
 487 {
 488     code_t*self = add_opcode(prev, 0x17);
 489     self->data[0] = 0; //placeholder
 490     self->branch = label;
 491     return self;
 492 }
 493 code_t* abc_ifle(code_t*prev, code_t* label)
 494 {
 495     code_t*self = add_opcode(prev, 0x16);
 496     self->data[0] = 0; //placeholder
 497     self->branch = label;
 498     return self;
 499 }
 500 code_t* abc_iflt(code_t*prev, code_t* label)
 501 {
 502     code_t*self = add_opcode(prev, 0x15);
 503     self->data[0] = 0; //placeholder
 504     self->branch = label;
 505     return self;
 506 }
 507 code_t* abc_ifnge(code_t*prev, code_t* label)
 508 {
 509     code_t*self = add_opcode(prev, 0x0f);
 510     self->data[0] = 0; //placeholder
 511     self->branch = label;
 512     return self;
 513 }
 514 code_t* abc_ifngt(code_t*prev, code_t* label)
 515 {
 516     code_t*self = add_opcode(prev, 0x0e);
 517     self->data[0] = 0; //placeholder
 518     self->branch = label;
 519     return self;
 520 }
 521 code_t* abc_ifnle(code_t*prev, code_t* label)
 522 {
 523     code_t*self = add_opcode(prev, 0x0d);
 524     self->data[0] = 0; //placeholder
 525     self->branch = label;
 526     return self;
 527 }
 528 code_t* abc_ifnlt(code_t*prev, code_t* label)
 529 {
 530     code_t*self = add_opcode(prev, 0x0c);
 531     self->data[0] = 0; //placeholder
 532     self->branch = label;
 533     return self;
 534 }
 535 code_t* abc_ifne(code_t*prev, code_t* label)
 536 {
 537     code_t*self = add_opcode(prev, 0x14);
 538     self->data[0] = 0; //placeholder
 539     self->branch = label;
 540     return self;
 541 }
 542 code_t* abc_ifstricteq(code_t*prev, code_t* label)
 543 {
 544     code_t*self = add_opcode(prev, 0x19);
 545     self->data[0] = 0; //placeholder
 546     self->branch = label;
 547     return self;
 548 }
 549 code_t* abc_ifstrictne(code_t*prev, code_t* label)
 550 {
 551     code_t*self = add_opcode(prev, 0x1a);
 552     self->data[0] = 0; //placeholder
 553     self->branch = label;
 554     return self;
 555 }
 556 code_t* abc_iftrue(code_t*prev, code_t* label)
 557 {
 558     code_t*self = add_opcode(prev, 0x11);
 559     self->data[0] = 0; //placeholder
 560     self->branch = label;
 561     return self;
 562 }
 563 code_t* abc_in(code_t*prev)
 564 {
 565     code_t*self = add_opcode(prev, 0xb4);
 566     return self;
 567 }
 568 code_t* abc_inclocal(code_t*prev, int reg)
 569 {
 570     code_t*self = add_opcode(prev, 0x92);
 571     self->data[0] = (void*)(ptroff_t)reg;
 572     return self;
 573 }
 574 code_t* abc_inclocal_i(code_t*prev, int reg)
 575 {
 576     code_t*self = add_opcode(prev, 0xc2);
 577     self->data[0] = (void*)(ptroff_t)reg;
 578     return self;
 579 }
 580 code_t* abc_increment(code_t*prev)
 581 {
 582     code_t*self = add_opcode(prev, 0x91);
 583     return self;
 584 }
 585 code_t* abc_increment_i(code_t*prev)
 586 {
 587     code_t*self = add_opcode(prev, 0xc0);
 588     return self;
 589 }
 590 code_t* abc_initproperty(code_t*prev, char* name)
 591 {
 592     code_t*self = add_opcode(prev, 0x68);
 593     self->data[0] = multiname_fromstring(name);
 594     return self;
 595 }
 596 code_t* abc_initproperty2(code_t*prev, multiname_t* name)
 597 {
 598     code_t*self = add_opcode(prev, 0x68);
 599     self->data[0] = multiname_clone(name);
 600     return self;
 601 }
 602 code_t* abc_instanceof(code_t*prev)
 603 {
 604     code_t*self = add_opcode(prev, 0xb1);
 605     return self;
 606 }
 607 code_t* abc_istype(code_t*prev, char* name)
 608 {
 609     code_t*self = add_opcode(prev, 0xb2);
 610     self->data[0] = multiname_fromstring(name);
 611     return self;
 612 }
 613 code_t* abc_istype2(code_t*prev, multiname_t* name)
 614 {
 615     code_t*self = add_opcode(prev, 0xb2);
 616     self->data[0] = multiname_clone(name);
 617     return self;
 618 }
 619 code_t* abc_istypelate(code_t*prev)
 620 {
 621     code_t*self = add_opcode(prev, 0xb3);
 622     return self;
 623 }
 624 code_t* abc_jump(code_t*prev, code_t* label)
 625 {
 626     code_t*self = add_opcode(prev, 0x10);
 627     self->data[0] = 0; //placeholder
 628     self->branch = label;
 629     return self;
 630 }
 631 code_t* abc_kill(code_t*prev, int reg)
 632 {
 633     code_t*self = add_opcode(prev, 0x08);
 634     self->data[0] = (void*)(ptroff_t)reg;
 635     return self;
 636 }
 637 code_t* abc_label(code_t*prev)
 638 {
 639     code_t*self = add_opcode(prev, 0x09);
 640     return self;
 641 }
 642 code_t* abc_lessequals(code_t*prev)
 643 {
 644     code_t*self = add_opcode(prev, 0xae);
 645     return self;
 646 }
 647 code_t* abc_lessthan(code_t*prev)
 648 {
 649     code_t*self = add_opcode(prev, 0xad);
 650     return self;
 651 }
 652 code_t* abc_lookupswitch(code_t*prev, lookupswitch_t* l)
 653 {
 654     code_t*self = add_opcode(prev, 0x1b);
 655     self->data[0] = l;
 656     return self;
 657 }
 658 code_t* abc_lshift(code_t*prev)
 659 {
 660     code_t*self = add_opcode(prev, 0xa5);
 661     return self;
 662 }
 663 code_t* abc_modulo(code_t*prev)
 664 {
 665     code_t*self = add_opcode(prev, 0xa4);
 666     return self;
 667 }
 668 code_t* abc_multiply(code_t*prev)
 669 {
 670     code_t*self = add_opcode(prev, 0xa2);
 671     return self;
 672 }
 673 code_t* abc_multiply_i(code_t*prev)
 674 {
 675     code_t*self = add_opcode(prev, 0xc7);
 676     return self;
 677 }
 678 code_t* abc_negate(code_t*prev)
 679 {
 680     code_t*self = add_opcode(prev, 0x90);
 681     return self;
 682 }
 683 code_t* abc_negate_i(code_t*prev)
 684 {
 685     code_t*self = add_opcode(prev, 0xc4);
 686     return self;
 687 }
 688 code_t* abc_newactivation(code_t*prev)
 689 {
 690     code_t*self = add_opcode(prev, 0x57);
 691     return self;
 692 }
 693 code_t* abc_newarray(code_t*prev, int v)
 694 {
 695     code_t*self = add_opcode(prev, 0x56);
 696     self->data[0] = (void*)(ptroff_t)v;
 697     return self;
 698 }
 699 code_t* abc_newcatch(code_t*prev, int v)
 700 {
 701     code_t*self = add_opcode(prev, 0x5a);
 702     self->data[0] = (void*)(ptroff_t)v;
 703     return self;
 704 }
 705 code_t* abc_newclass(code_t*prev, abc_class_t* m)
 706 {
 707     code_t*self = add_opcode(prev, 0x58);
 708     self->data[0] = m;
 709     return self;
 710 }
 711 code_t* abc_newfunction(code_t*prev, abc_method_t* m)
 712 {
 713     code_t*self = add_opcode(prev, 0x40);
 714     self->data[0] = m;
 715     return self;
 716 }
 717 code_t* abc_newobject(code_t*prev, int v)
 718 {
 719     code_t*self = add_opcode(prev, 0x55);
 720     self->data[0] = (void*)(ptroff_t)v;
 721     return self;
 722 }
 723 code_t* abc_nextname(code_t*prev)
 724 {
 725     code_t*self = add_opcode(prev, 0x1e);
 726     return self;
 727 }
 728 code_t* abc_nextvalue(code_t*prev)
 729 {
 730     code_t*self = add_opcode(prev, 0x23);
 731     return self;
 732 }
 733 code_t* abc_nop(code_t*prev)
 734 {
 735     code_t*self = add_opcode(prev, 0x02);
 736     return self;
 737 }
 738 code_t* abc_not(code_t*prev)
 739 {
 740     code_t*self = add_opcode(prev, 0x96);
 741     return self;
 742 }
 743 code_t* abc_pop(code_t*prev)
 744 {
 745     code_t*self = add_opcode(prev, 0x29);
 746     return self;
 747 }
 748 code_t* abc_popscope(code_t*prev)
 749 {
 750     code_t*self = add_opcode(prev, 0x1d);
 751     return self;
 752 }
 753 code_t* abc_pushbyte(code_t*prev, int v)
 754 {
 755     code_t*self = add_opcode(prev, 0x24);
 756     self->data[0] = (void*)(ptroff_t)v;
 757     return self;
 758 }
 759 code_t* abc_pushdouble(code_t*prev, double f)
 760 {
 761     code_t*self = add_opcode(prev, 0x2f);
 762     double*fp = malloc(sizeof(double));
 763     *fp = f;
 764     self->data[0] = fp;
 765     return self;
 766 }
 767 code_t* abc_pushfalse(code_t*prev)
 768 {
 769     code_t*self = add_opcode(prev, 0x27);
 770     return self;
 771 }
 772 code_t* abc_pushint(code_t*prev, int i)
 773 {
 774     code_t*self = add_opcode(prev, 0x2d);
 775     self->data[0] = (void*)(ptroff_t)i;
 776     return self;
 777 }
 778 code_t* abc_pushnamespace(code_t*prev, int v)
 779 {
 780     code_t*self = add_opcode(prev, 0x31);
 781     self->data[0] = (void*)(ptroff_t)v;
 782     return self;
 783 }
 784 code_t* abc_pushnan(code_t*prev)
 785 {
 786     code_t*self = add_opcode(prev, 0x28);
 787     return self;
 788 }
 789 code_t* abc_pushnull(code_t*prev)
 790 {
 791     code_t*self = add_opcode(prev, 0x20);
 792     return self;
 793 }
 794 code_t* abc_pushscope(code_t*prev)
 795 {
 796     code_t*self = add_opcode(prev, 0x30);
 797     return self;
 798 }
 799 code_t* abc_pushshort(code_t*prev, int v)
 800 {
 801     code_t*self = add_opcode(prev, 0x25);
 802     self->data[0] = (void*)(ptroff_t)v;
 803     return self;
 804 }
 805 code_t* abc_pushstring(code_t*prev, char* name)
 806 {
 807     code_t*self = add_opcode(prev, 0x2c);
 808     self->data[0] = string_new4(name);
 809     return self;
 810 }
 811 code_t* abc_pushstring2(code_t*prev, string_t* s)
 812 {
 813     code_t*self = add_opcode(prev, 0x2c);
 814     self->data[0] = string_dup3(s);
 815     return self;
 816 }
 817 code_t* abc_pushtrue(code_t*prev)
 818 {
 819     code_t*self = add_opcode(prev, 0x26);
 820     return self;
 821 }
 822 code_t* abc_pushuint(code_t*prev, unsigned int u)
 823 {
 824     code_t*self = add_opcode(prev, 0x2e);
 825     self->data[0] = (void*)(ptroff_t)u;
 826     return self;
 827 }
 828 code_t* abc_pushundefined(code_t*prev)
 829 {
 830     code_t*self = add_opcode(prev, 0x21);
 831     return self;
 832 }
 833 code_t* abc_pushwith(code_t*prev)
 834 {
 835     code_t*self = add_opcode(prev, 0x1c);
 836     return self;
 837 }
 838 code_t* abc_returnvalue(code_t*prev)
 839 {
 840     code_t*self = add_opcode(prev, 0x48);
 841     return self;
 842 }
 843 code_t* abc_returnvoid(code_t*prev)
 844 {
 845     code_t*self = add_opcode(prev, 0x47);
 846     return self;
 847 }
 848 code_t* abc_rshift(code_t*prev)
 849 {
 850     code_t*self = add_opcode(prev, 0xa6);
 851     return self;
 852 }
 853 code_t* abc_setlocal(code_t*prev, int reg)
 854 {
 855     code_t*self = add_opcode(prev, 0x63);
 856     self->data[0] = (void*)(ptroff_t)reg;
 857     return self;
 858 }
 859 code_t* abc_setlocal_0(code_t*prev)
 860 {
 861     code_t*self = add_opcode(prev, 0xd4);
 862     return self;
 863 }
 864 code_t* abc_setlocal_1(code_t*prev)
 865 {
 866     code_t*self = add_opcode(prev, 0xd5);
 867     return self;
 868 }
 869 code_t* abc_setlocal_2(code_t*prev)
 870 {
 871     code_t*self = add_opcode(prev, 0xd6);
 872     return self;
 873 }
 874 code_t* abc_setlocal_3(code_t*prev)
 875 {
 876     code_t*self = add_opcode(prev, 0xd7);
 877     return self;
 878 }
 879 code_t* abc_setglobalslot(code_t*prev, int v)
 880 {
 881     code_t*self = add_opcode(prev, 0x6f);
 882     self->data[0] = (void*)(ptroff_t)v;
 883     return self;
 884 }
 885 code_t* abc_setproperty(code_t*prev, char* name)
 886 {
 887     code_t*self = add_opcode(prev, 0x61);
 888     self->data[0] = multiname_fromstring(name);
 889     return self;
 890 }
 891 code_t* abc_setproperty2(code_t*prev, multiname_t* name)
 892 {
 893     code_t*self = add_opcode(prev, 0x61);
 894     self->data[0] = multiname_clone(name);
 895     return self;
 896 }
 897 code_t* abc_setslot(code_t*prev, int v)
 898 {
 899     code_t*self = add_opcode(prev, 0x6d);
 900     self->data[0] = (void*)(ptroff_t)v;
 901     return self;
 902 }
 903 code_t* abc_setsuper(code_t*prev, char* name)
 904 {
 905     code_t*self = add_opcode(prev, 0x05);
 906     self->data[0] = multiname_fromstring(name);
 907     return self;
 908 }
 909 code_t* abc_setsuper2(code_t*prev, multiname_t* name)
 910 {
 911     code_t*self = add_opcode(prev, 0x05);
 912     self->data[0] = multiname_clone(name);
 913     return self;
 914 }
 915 code_t* abc_strictequals(code_t*prev)
 916 {
 917     code_t*self = add_opcode(prev, 0xac);
 918     return self;
 919 }
 920 code_t* abc_subtract(code_t*prev)
 921 {
 922     code_t*self = add_opcode(prev, 0xa1);
 923     return self;
 924 }
 925 code_t* abc_subtract_i(code_t*prev)
 926 {
 927     code_t*self = add_opcode(prev, 0xc6);
 928     return self;
 929 }
 930 code_t* abc_swap(code_t*prev)
 931 {
 932     code_t*self = add_opcode(prev, 0x2b);
 933     return self;
 934 }
 935 code_t* abc_throw(code_t*prev)
 936 {
 937     code_t*self = add_opcode(prev, 0x03);
 938     return self;
 939 }
 940 code_t* abc_typeof(code_t*prev)
 941 {
 942     code_t*self = add_opcode(prev, 0x95);
 943     return self;
 944 }
 945 code_t* abc_urshift(code_t*prev)
 946 {
 947     code_t*self = add_opcode(prev, 0xa7);
 948     return self;
 949 }
 950 code_t* abc_applytype(code_t*prev, int v)
 951 {
 952     code_t*self = add_opcode(prev, 0x53);
 953     self->data[0] = (void*)(ptroff_t)v;
 954     return self;
 955 }
 956 code_t* abc___rethrow__(code_t*prev)
 957 {
 958     code_t*self = add_opcode(prev, 0xfc);
 959     return self;
 960 }
 961 code_t* abc___fallthrough__(code_t*prev, char* name)
 962 {
 963     code_t*self = add_opcode(prev, 0xfd);
 964     self->data[0] = string_new4(name);
 965     return self;
 966 }
 967 code_t* abc___fallthrough__2(code_t*prev, string_t* s)
 968 {
 969     code_t*self = add_opcode(prev, 0xfd);
 970     self->data[0] = string_dup3(s);
 971     return self;
 972 }
 973 code_t* abc___continue__(code_t*prev, char* name)
 974 {
 975     code_t*self = add_opcode(prev, 0xfe);
 976     self->data[0] = string_new4(name);
 977     return self;
 978 }
 979 code_t* abc___continue__2(code_t*prev, string_t* s)
 980 {
 981     code_t*self = add_opcode(prev, 0xfe);
 982     self->data[0] = string_dup3(s);
 983     return self;
 984 }
 985 code_t* abc___break__(code_t*prev, char* name)
 986 {
 987     code_t*self = add_opcode(prev, 0xff);
 988     self->data[0] = string_new4(name);
 989     return self;
 990 }
 991 code_t* abc___break__2(code_t*prev, string_t* s)
 992 {
 993     code_t*self = add_opcode(prev, 0xff);
 994     self->data[0] = string_dup3(s);
 995     return self;
 996 }