lib/as3/opcodes.c

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