| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2015, the Dartino project authors. Please see the AUTHORS file | |
| 2 // for details. All rights reserved. Use of this source code is governed by a | |
| 3 // BSD-style license that can be found in the LICENSE.md file. | |
| 4 | |
| 5 // WARNING: Generated file, do not edit! | |
| 6 | |
| 7 part of fletch.bytecodes; | |
| 8 | |
| 9 enum Opcode { | |
| 10 LoadLocal0, | |
| 11 LoadLocal1, | |
| 12 LoadLocal2, | |
| 13 LoadLocal3, | |
| 14 LoadLocal4, | |
| 15 LoadLocal5, | |
| 16 LoadLocal, | |
| 17 LoadLocalWide, | |
| 18 LoadBoxed, | |
| 19 LoadStatic, | |
| 20 LoadStaticInit, | |
| 21 LoadField, | |
| 22 LoadFieldWide, | |
| 23 StoreLocal, | |
| 24 StoreBoxed, | |
| 25 StoreStatic, | |
| 26 StoreField, | |
| 27 StoreFieldWide, | |
| 28 LoadLiteralNull, | |
| 29 LoadLiteralTrue, | |
| 30 LoadLiteralFalse, | |
| 31 LoadLiteral0, | |
| 32 LoadLiteral1, | |
| 33 LoadLiteral, | |
| 34 LoadLiteralWide, | |
| 35 InvokeMethod, | |
| 36 InvokeTest, | |
| 37 InvokeEq, | |
| 38 InvokeLt, | |
| 39 InvokeLe, | |
| 40 InvokeGt, | |
| 41 InvokeGe, | |
| 42 InvokeAdd, | |
| 43 InvokeSub, | |
| 44 InvokeMod, | |
| 45 InvokeMul, | |
| 46 InvokeTruncDiv, | |
| 47 InvokeBitNot, | |
| 48 InvokeBitAnd, | |
| 49 InvokeBitOr, | |
| 50 InvokeBitXor, | |
| 51 InvokeBitShr, | |
| 52 InvokeBitShl, | |
| 53 InvokeStatic, | |
| 54 InvokeFactory, | |
| 55 Allocate, | |
| 56 AllocateImmutable, | |
| 57 InvokeNoSuchMethod, | |
| 58 InvokeTestNoSuchMethod, | |
| 59 InvokeNative, | |
| 60 InvokeDetachableNative, | |
| 61 InvokeNativeYield, | |
| 62 InvokeSelector, | |
| 63 Pop, | |
| 64 Drop, | |
| 65 Return, | |
| 66 ReturnNull, | |
| 67 BranchWide, | |
| 68 BranchIfTrueWide, | |
| 69 BranchIfFalseWide, | |
| 70 BranchBack, | |
| 71 BranchBackIfTrue, | |
| 72 BranchBackIfFalse, | |
| 73 BranchBackWide, | |
| 74 BranchBackIfTrueWide, | |
| 75 BranchBackIfFalseWide, | |
| 76 PopAndBranchWide, | |
| 77 PopAndBranchBackWide, | |
| 78 AllocateBoxed, | |
| 79 Negate, | |
| 80 StackOverflowCheck, | |
| 81 Throw, | |
| 82 SubroutineCall, | |
| 83 SubroutineReturn, | |
| 84 ProcessYield, | |
| 85 CoroutineChange, | |
| 86 Identical, | |
| 87 IdenticalNonNumeric, | |
| 88 EnterNoSuchMethod, | |
| 89 ExitNoSuchMethod, | |
| 90 InvokeMethodUnfold, | |
| 91 InvokeTestUnfold, | |
| 92 InvokeEqUnfold, | |
| 93 InvokeLtUnfold, | |
| 94 InvokeLeUnfold, | |
| 95 InvokeGtUnfold, | |
| 96 InvokeGeUnfold, | |
| 97 InvokeAddUnfold, | |
| 98 InvokeSubUnfold, | |
| 99 InvokeModUnfold, | |
| 100 InvokeMulUnfold, | |
| 101 InvokeTruncDivUnfold, | |
| 102 InvokeBitNotUnfold, | |
| 103 InvokeBitAndUnfold, | |
| 104 InvokeBitOrUnfold, | |
| 105 InvokeBitXorUnfold, | |
| 106 InvokeBitShrUnfold, | |
| 107 InvokeBitShlUnfold, | |
| 108 LoadConst, | |
| 109 MethodEnd, | |
| 110 } | |
| 111 | |
| 112 class LoadLocal0 extends Bytecode { | |
| 113 const LoadLocal0() | |
| 114 : super(); | |
| 115 | |
| 116 Opcode get opcode => Opcode.LoadLocal0; | |
| 117 | |
| 118 String get name => 'LoadLocal0'; | |
| 119 | |
| 120 bool get isBranching => false; | |
| 121 | |
| 122 String get format => ''; | |
| 123 | |
| 124 int get size => 1; | |
| 125 | |
| 126 int get stackPointerDifference => 1; | |
| 127 | |
| 128 String get formatString => 'load local 0'; | |
| 129 | |
| 130 void addTo(Sink<List<int>> sink) { | |
| 131 new BytecodeBuffer() | |
| 132 ..addUint8(opcode.index) | |
| 133 ..sendOn(sink); | |
| 134 } | |
| 135 | |
| 136 String toString() => 'load local 0'; | |
| 137 } | |
| 138 | |
| 139 class LoadLocal1 extends Bytecode { | |
| 140 const LoadLocal1() | |
| 141 : super(); | |
| 142 | |
| 143 Opcode get opcode => Opcode.LoadLocal1; | |
| 144 | |
| 145 String get name => 'LoadLocal1'; | |
| 146 | |
| 147 bool get isBranching => false; | |
| 148 | |
| 149 String get format => ''; | |
| 150 | |
| 151 int get size => 1; | |
| 152 | |
| 153 int get stackPointerDifference => 1; | |
| 154 | |
| 155 String get formatString => 'load local 1'; | |
| 156 | |
| 157 void addTo(Sink<List<int>> sink) { | |
| 158 new BytecodeBuffer() | |
| 159 ..addUint8(opcode.index) | |
| 160 ..sendOn(sink); | |
| 161 } | |
| 162 | |
| 163 String toString() => 'load local 1'; | |
| 164 } | |
| 165 | |
| 166 class LoadLocal2 extends Bytecode { | |
| 167 const LoadLocal2() | |
| 168 : super(); | |
| 169 | |
| 170 Opcode get opcode => Opcode.LoadLocal2; | |
| 171 | |
| 172 String get name => 'LoadLocal2'; | |
| 173 | |
| 174 bool get isBranching => false; | |
| 175 | |
| 176 String get format => ''; | |
| 177 | |
| 178 int get size => 1; | |
| 179 | |
| 180 int get stackPointerDifference => 1; | |
| 181 | |
| 182 String get formatString => 'load local 2'; | |
| 183 | |
| 184 void addTo(Sink<List<int>> sink) { | |
| 185 new BytecodeBuffer() | |
| 186 ..addUint8(opcode.index) | |
| 187 ..sendOn(sink); | |
| 188 } | |
| 189 | |
| 190 String toString() => 'load local 2'; | |
| 191 } | |
| 192 | |
| 193 class LoadLocal3 extends Bytecode { | |
| 194 const LoadLocal3() | |
| 195 : super(); | |
| 196 | |
| 197 Opcode get opcode => Opcode.LoadLocal3; | |
| 198 | |
| 199 String get name => 'LoadLocal3'; | |
| 200 | |
| 201 bool get isBranching => false; | |
| 202 | |
| 203 String get format => ''; | |
| 204 | |
| 205 int get size => 1; | |
| 206 | |
| 207 int get stackPointerDifference => 1; | |
| 208 | |
| 209 String get formatString => 'load local 3'; | |
| 210 | |
| 211 void addTo(Sink<List<int>> sink) { | |
| 212 new BytecodeBuffer() | |
| 213 ..addUint8(opcode.index) | |
| 214 ..sendOn(sink); | |
| 215 } | |
| 216 | |
| 217 String toString() => 'load local 3'; | |
| 218 } | |
| 219 | |
| 220 class LoadLocal4 extends Bytecode { | |
| 221 const LoadLocal4() | |
| 222 : super(); | |
| 223 | |
| 224 Opcode get opcode => Opcode.LoadLocal4; | |
| 225 | |
| 226 String get name => 'LoadLocal4'; | |
| 227 | |
| 228 bool get isBranching => false; | |
| 229 | |
| 230 String get format => ''; | |
| 231 | |
| 232 int get size => 1; | |
| 233 | |
| 234 int get stackPointerDifference => 1; | |
| 235 | |
| 236 String get formatString => 'load local 4'; | |
| 237 | |
| 238 void addTo(Sink<List<int>> sink) { | |
| 239 new BytecodeBuffer() | |
| 240 ..addUint8(opcode.index) | |
| 241 ..sendOn(sink); | |
| 242 } | |
| 243 | |
| 244 String toString() => 'load local 4'; | |
| 245 } | |
| 246 | |
| 247 class LoadLocal5 extends Bytecode { | |
| 248 const LoadLocal5() | |
| 249 : super(); | |
| 250 | |
| 251 Opcode get opcode => Opcode.LoadLocal5; | |
| 252 | |
| 253 String get name => 'LoadLocal5'; | |
| 254 | |
| 255 bool get isBranching => false; | |
| 256 | |
| 257 String get format => ''; | |
| 258 | |
| 259 int get size => 1; | |
| 260 | |
| 261 int get stackPointerDifference => 1; | |
| 262 | |
| 263 String get formatString => 'load local 5'; | |
| 264 | |
| 265 void addTo(Sink<List<int>> sink) { | |
| 266 new BytecodeBuffer() | |
| 267 ..addUint8(opcode.index) | |
| 268 ..sendOn(sink); | |
| 269 } | |
| 270 | |
| 271 String toString() => 'load local 5'; | |
| 272 } | |
| 273 | |
| 274 class LoadLocal extends Bytecode { | |
| 275 final int uint8Argument0; | |
| 276 const LoadLocal(this.uint8Argument0) | |
| 277 : super(); | |
| 278 | |
| 279 Opcode get opcode => Opcode.LoadLocal; | |
| 280 | |
| 281 String get name => 'LoadLocal'; | |
| 282 | |
| 283 bool get isBranching => false; | |
| 284 | |
| 285 String get format => 'B'; | |
| 286 | |
| 287 int get size => 2; | |
| 288 | |
| 289 int get stackPointerDifference => 1; | |
| 290 | |
| 291 String get formatString => 'load local %d'; | |
| 292 | |
| 293 void addTo(Sink<List<int>> sink) { | |
| 294 new BytecodeBuffer() | |
| 295 ..addUint8(opcode.index) | |
| 296 ..addUint8(uint8Argument0) | |
| 297 ..sendOn(sink); | |
| 298 } | |
| 299 | |
| 300 String toString() => 'load local ${uint8Argument0}'; | |
| 301 | |
| 302 operator==(Bytecode other) { | |
| 303 if (!(super==(other))) return false; | |
| 304 LoadLocal rhs = other; | |
| 305 if (uint8Argument0 != rhs.uint8Argument0) return false; | |
| 306 return true; | |
| 307 } | |
| 308 | |
| 309 int get hashCode { | |
| 310 int value = super.hashCode; | |
| 311 value += uint8Argument0; | |
| 312 return value; | |
| 313 } | |
| 314 } | |
| 315 | |
| 316 class LoadLocalWide extends Bytecode { | |
| 317 final int uint32Argument0; | |
| 318 const LoadLocalWide(this.uint32Argument0) | |
| 319 : super(); | |
| 320 | |
| 321 Opcode get opcode => Opcode.LoadLocalWide; | |
| 322 | |
| 323 String get name => 'LoadLocalWide'; | |
| 324 | |
| 325 bool get isBranching => false; | |
| 326 | |
| 327 String get format => 'I'; | |
| 328 | |
| 329 int get size => 5; | |
| 330 | |
| 331 int get stackPointerDifference => 1; | |
| 332 | |
| 333 String get formatString => 'load local %d'; | |
| 334 | |
| 335 void addTo(Sink<List<int>> sink) { | |
| 336 new BytecodeBuffer() | |
| 337 ..addUint8(opcode.index) | |
| 338 ..addUint32(uint32Argument0) | |
| 339 ..sendOn(sink); | |
| 340 } | |
| 341 | |
| 342 String toString() => 'load local ${uint32Argument0}'; | |
| 343 | |
| 344 operator==(Bytecode other) { | |
| 345 if (!(super==(other))) return false; | |
| 346 LoadLocalWide rhs = other; | |
| 347 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 348 return true; | |
| 349 } | |
| 350 | |
| 351 int get hashCode { | |
| 352 int value = super.hashCode; | |
| 353 value += uint32Argument0; | |
| 354 return value; | |
| 355 } | |
| 356 } | |
| 357 | |
| 358 class LoadBoxed extends Bytecode { | |
| 359 final int uint8Argument0; | |
| 360 const LoadBoxed(this.uint8Argument0) | |
| 361 : super(); | |
| 362 | |
| 363 Opcode get opcode => Opcode.LoadBoxed; | |
| 364 | |
| 365 String get name => 'LoadBoxed'; | |
| 366 | |
| 367 bool get isBranching => false; | |
| 368 | |
| 369 String get format => 'B'; | |
| 370 | |
| 371 int get size => 2; | |
| 372 | |
| 373 int get stackPointerDifference => 1; | |
| 374 | |
| 375 String get formatString => 'load boxed %d'; | |
| 376 | |
| 377 void addTo(Sink<List<int>> sink) { | |
| 378 new BytecodeBuffer() | |
| 379 ..addUint8(opcode.index) | |
| 380 ..addUint8(uint8Argument0) | |
| 381 ..sendOn(sink); | |
| 382 } | |
| 383 | |
| 384 String toString() => 'load boxed ${uint8Argument0}'; | |
| 385 | |
| 386 operator==(Bytecode other) { | |
| 387 if (!(super==(other))) return false; | |
| 388 LoadBoxed rhs = other; | |
| 389 if (uint8Argument0 != rhs.uint8Argument0) return false; | |
| 390 return true; | |
| 391 } | |
| 392 | |
| 393 int get hashCode { | |
| 394 int value = super.hashCode; | |
| 395 value += uint8Argument0; | |
| 396 return value; | |
| 397 } | |
| 398 } | |
| 399 | |
| 400 class LoadStatic extends Bytecode { | |
| 401 final int uint32Argument0; | |
| 402 const LoadStatic(this.uint32Argument0) | |
| 403 : super(); | |
| 404 | |
| 405 Opcode get opcode => Opcode.LoadStatic; | |
| 406 | |
| 407 String get name => 'LoadStatic'; | |
| 408 | |
| 409 bool get isBranching => false; | |
| 410 | |
| 411 String get format => 'I'; | |
| 412 | |
| 413 int get size => 5; | |
| 414 | |
| 415 int get stackPointerDifference => 1; | |
| 416 | |
| 417 String get formatString => 'load static %d'; | |
| 418 | |
| 419 void addTo(Sink<List<int>> sink) { | |
| 420 new BytecodeBuffer() | |
| 421 ..addUint8(opcode.index) | |
| 422 ..addUint32(uint32Argument0) | |
| 423 ..sendOn(sink); | |
| 424 } | |
| 425 | |
| 426 String toString() => 'load static ${uint32Argument0}'; | |
| 427 | |
| 428 operator==(Bytecode other) { | |
| 429 if (!(super==(other))) return false; | |
| 430 LoadStatic rhs = other; | |
| 431 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 432 return true; | |
| 433 } | |
| 434 | |
| 435 int get hashCode { | |
| 436 int value = super.hashCode; | |
| 437 value += uint32Argument0; | |
| 438 return value; | |
| 439 } | |
| 440 } | |
| 441 | |
| 442 class LoadStaticInit extends Bytecode { | |
| 443 final int uint32Argument0; | |
| 444 const LoadStaticInit(this.uint32Argument0) | |
| 445 : super(); | |
| 446 | |
| 447 Opcode get opcode => Opcode.LoadStaticInit; | |
| 448 | |
| 449 String get name => 'LoadStaticInit'; | |
| 450 | |
| 451 bool get isBranching => false; | |
| 452 | |
| 453 String get format => 'I'; | |
| 454 | |
| 455 int get size => 5; | |
| 456 | |
| 457 int get stackPointerDifference => 1; | |
| 458 | |
| 459 String get formatString => 'load static init %d'; | |
| 460 | |
| 461 void addTo(Sink<List<int>> sink) { | |
| 462 new BytecodeBuffer() | |
| 463 ..addUint8(opcode.index) | |
| 464 ..addUint32(uint32Argument0) | |
| 465 ..sendOn(sink); | |
| 466 } | |
| 467 | |
| 468 String toString() => 'load static init ${uint32Argument0}'; | |
| 469 | |
| 470 operator==(Bytecode other) { | |
| 471 if (!(super==(other))) return false; | |
| 472 LoadStaticInit rhs = other; | |
| 473 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 474 return true; | |
| 475 } | |
| 476 | |
| 477 int get hashCode { | |
| 478 int value = super.hashCode; | |
| 479 value += uint32Argument0; | |
| 480 return value; | |
| 481 } | |
| 482 } | |
| 483 | |
| 484 class LoadField extends Bytecode { | |
| 485 final int uint8Argument0; | |
| 486 const LoadField(this.uint8Argument0) | |
| 487 : super(); | |
| 488 | |
| 489 Opcode get opcode => Opcode.LoadField; | |
| 490 | |
| 491 String get name => 'LoadField'; | |
| 492 | |
| 493 bool get isBranching => false; | |
| 494 | |
| 495 String get format => 'B'; | |
| 496 | |
| 497 int get size => 2; | |
| 498 | |
| 499 int get stackPointerDifference => 0; | |
| 500 | |
| 501 String get formatString => 'load field %d'; | |
| 502 | |
| 503 void addTo(Sink<List<int>> sink) { | |
| 504 new BytecodeBuffer() | |
| 505 ..addUint8(opcode.index) | |
| 506 ..addUint8(uint8Argument0) | |
| 507 ..sendOn(sink); | |
| 508 } | |
| 509 | |
| 510 String toString() => 'load field ${uint8Argument0}'; | |
| 511 | |
| 512 operator==(Bytecode other) { | |
| 513 if (!(super==(other))) return false; | |
| 514 LoadField rhs = other; | |
| 515 if (uint8Argument0 != rhs.uint8Argument0) return false; | |
| 516 return true; | |
| 517 } | |
| 518 | |
| 519 int get hashCode { | |
| 520 int value = super.hashCode; | |
| 521 value += uint8Argument0; | |
| 522 return value; | |
| 523 } | |
| 524 } | |
| 525 | |
| 526 class LoadFieldWide extends Bytecode { | |
| 527 final int uint32Argument0; | |
| 528 const LoadFieldWide(this.uint32Argument0) | |
| 529 : super(); | |
| 530 | |
| 531 Opcode get opcode => Opcode.LoadFieldWide; | |
| 532 | |
| 533 String get name => 'LoadFieldWide'; | |
| 534 | |
| 535 bool get isBranching => false; | |
| 536 | |
| 537 String get format => 'I'; | |
| 538 | |
| 539 int get size => 5; | |
| 540 | |
| 541 int get stackPointerDifference => 0; | |
| 542 | |
| 543 String get formatString => 'load field %d'; | |
| 544 | |
| 545 void addTo(Sink<List<int>> sink) { | |
| 546 new BytecodeBuffer() | |
| 547 ..addUint8(opcode.index) | |
| 548 ..addUint32(uint32Argument0) | |
| 549 ..sendOn(sink); | |
| 550 } | |
| 551 | |
| 552 String toString() => 'load field ${uint32Argument0}'; | |
| 553 | |
| 554 operator==(Bytecode other) { | |
| 555 if (!(super==(other))) return false; | |
| 556 LoadFieldWide rhs = other; | |
| 557 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 558 return true; | |
| 559 } | |
| 560 | |
| 561 int get hashCode { | |
| 562 int value = super.hashCode; | |
| 563 value += uint32Argument0; | |
| 564 return value; | |
| 565 } | |
| 566 } | |
| 567 | |
| 568 class StoreLocal extends Bytecode { | |
| 569 final int uint8Argument0; | |
| 570 const StoreLocal(this.uint8Argument0) | |
| 571 : super(); | |
| 572 | |
| 573 Opcode get opcode => Opcode.StoreLocal; | |
| 574 | |
| 575 String get name => 'StoreLocal'; | |
| 576 | |
| 577 bool get isBranching => false; | |
| 578 | |
| 579 String get format => 'B'; | |
| 580 | |
| 581 int get size => 2; | |
| 582 | |
| 583 int get stackPointerDifference => 0; | |
| 584 | |
| 585 String get formatString => 'store local %d'; | |
| 586 | |
| 587 void addTo(Sink<List<int>> sink) { | |
| 588 new BytecodeBuffer() | |
| 589 ..addUint8(opcode.index) | |
| 590 ..addUint8(uint8Argument0) | |
| 591 ..sendOn(sink); | |
| 592 } | |
| 593 | |
| 594 String toString() => 'store local ${uint8Argument0}'; | |
| 595 | |
| 596 operator==(Bytecode other) { | |
| 597 if (!(super==(other))) return false; | |
| 598 StoreLocal rhs = other; | |
| 599 if (uint8Argument0 != rhs.uint8Argument0) return false; | |
| 600 return true; | |
| 601 } | |
| 602 | |
| 603 int get hashCode { | |
| 604 int value = super.hashCode; | |
| 605 value += uint8Argument0; | |
| 606 return value; | |
| 607 } | |
| 608 } | |
| 609 | |
| 610 class StoreBoxed extends Bytecode { | |
| 611 final int uint8Argument0; | |
| 612 const StoreBoxed(this.uint8Argument0) | |
| 613 : super(); | |
| 614 | |
| 615 Opcode get opcode => Opcode.StoreBoxed; | |
| 616 | |
| 617 String get name => 'StoreBoxed'; | |
| 618 | |
| 619 bool get isBranching => false; | |
| 620 | |
| 621 String get format => 'B'; | |
| 622 | |
| 623 int get size => 2; | |
| 624 | |
| 625 int get stackPointerDifference => 0; | |
| 626 | |
| 627 String get formatString => 'store boxed %d'; | |
| 628 | |
| 629 void addTo(Sink<List<int>> sink) { | |
| 630 new BytecodeBuffer() | |
| 631 ..addUint8(opcode.index) | |
| 632 ..addUint8(uint8Argument0) | |
| 633 ..sendOn(sink); | |
| 634 } | |
| 635 | |
| 636 String toString() => 'store boxed ${uint8Argument0}'; | |
| 637 | |
| 638 operator==(Bytecode other) { | |
| 639 if (!(super==(other))) return false; | |
| 640 StoreBoxed rhs = other; | |
| 641 if (uint8Argument0 != rhs.uint8Argument0) return false; | |
| 642 return true; | |
| 643 } | |
| 644 | |
| 645 int get hashCode { | |
| 646 int value = super.hashCode; | |
| 647 value += uint8Argument0; | |
| 648 return value; | |
| 649 } | |
| 650 } | |
| 651 | |
| 652 class StoreStatic extends Bytecode { | |
| 653 final int uint32Argument0; | |
| 654 const StoreStatic(this.uint32Argument0) | |
| 655 : super(); | |
| 656 | |
| 657 Opcode get opcode => Opcode.StoreStatic; | |
| 658 | |
| 659 String get name => 'StoreStatic'; | |
| 660 | |
| 661 bool get isBranching => false; | |
| 662 | |
| 663 String get format => 'I'; | |
| 664 | |
| 665 int get size => 5; | |
| 666 | |
| 667 int get stackPointerDifference => 0; | |
| 668 | |
| 669 String get formatString => 'store static %d'; | |
| 670 | |
| 671 void addTo(Sink<List<int>> sink) { | |
| 672 new BytecodeBuffer() | |
| 673 ..addUint8(opcode.index) | |
| 674 ..addUint32(uint32Argument0) | |
| 675 ..sendOn(sink); | |
| 676 } | |
| 677 | |
| 678 String toString() => 'store static ${uint32Argument0}'; | |
| 679 | |
| 680 operator==(Bytecode other) { | |
| 681 if (!(super==(other))) return false; | |
| 682 StoreStatic rhs = other; | |
| 683 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 684 return true; | |
| 685 } | |
| 686 | |
| 687 int get hashCode { | |
| 688 int value = super.hashCode; | |
| 689 value += uint32Argument0; | |
| 690 return value; | |
| 691 } | |
| 692 } | |
| 693 | |
| 694 class StoreField extends Bytecode { | |
| 695 final int uint8Argument0; | |
| 696 const StoreField(this.uint8Argument0) | |
| 697 : super(); | |
| 698 | |
| 699 Opcode get opcode => Opcode.StoreField; | |
| 700 | |
| 701 String get name => 'StoreField'; | |
| 702 | |
| 703 bool get isBranching => false; | |
| 704 | |
| 705 String get format => 'B'; | |
| 706 | |
| 707 int get size => 2; | |
| 708 | |
| 709 int get stackPointerDifference => -1; | |
| 710 | |
| 711 String get formatString => 'store field %d'; | |
| 712 | |
| 713 void addTo(Sink<List<int>> sink) { | |
| 714 new BytecodeBuffer() | |
| 715 ..addUint8(opcode.index) | |
| 716 ..addUint8(uint8Argument0) | |
| 717 ..sendOn(sink); | |
| 718 } | |
| 719 | |
| 720 String toString() => 'store field ${uint8Argument0}'; | |
| 721 | |
| 722 operator==(Bytecode other) { | |
| 723 if (!(super==(other))) return false; | |
| 724 StoreField rhs = other; | |
| 725 if (uint8Argument0 != rhs.uint8Argument0) return false; | |
| 726 return true; | |
| 727 } | |
| 728 | |
| 729 int get hashCode { | |
| 730 int value = super.hashCode; | |
| 731 value += uint8Argument0; | |
| 732 return value; | |
| 733 } | |
| 734 } | |
| 735 | |
| 736 class StoreFieldWide extends Bytecode { | |
| 737 final int uint32Argument0; | |
| 738 const StoreFieldWide(this.uint32Argument0) | |
| 739 : super(); | |
| 740 | |
| 741 Opcode get opcode => Opcode.StoreFieldWide; | |
| 742 | |
| 743 String get name => 'StoreFieldWide'; | |
| 744 | |
| 745 bool get isBranching => false; | |
| 746 | |
| 747 String get format => 'I'; | |
| 748 | |
| 749 int get size => 5; | |
| 750 | |
| 751 int get stackPointerDifference => -1; | |
| 752 | |
| 753 String get formatString => 'store field %d'; | |
| 754 | |
| 755 void addTo(Sink<List<int>> sink) { | |
| 756 new BytecodeBuffer() | |
| 757 ..addUint8(opcode.index) | |
| 758 ..addUint32(uint32Argument0) | |
| 759 ..sendOn(sink); | |
| 760 } | |
| 761 | |
| 762 String toString() => 'store field ${uint32Argument0}'; | |
| 763 | |
| 764 operator==(Bytecode other) { | |
| 765 if (!(super==(other))) return false; | |
| 766 StoreFieldWide rhs = other; | |
| 767 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 768 return true; | |
| 769 } | |
| 770 | |
| 771 int get hashCode { | |
| 772 int value = super.hashCode; | |
| 773 value += uint32Argument0; | |
| 774 return value; | |
| 775 } | |
| 776 } | |
| 777 | |
| 778 class LoadLiteralNull extends Bytecode { | |
| 779 const LoadLiteralNull() | |
| 780 : super(); | |
| 781 | |
| 782 Opcode get opcode => Opcode.LoadLiteralNull; | |
| 783 | |
| 784 String get name => 'LoadLiteralNull'; | |
| 785 | |
| 786 bool get isBranching => false; | |
| 787 | |
| 788 String get format => ''; | |
| 789 | |
| 790 int get size => 1; | |
| 791 | |
| 792 int get stackPointerDifference => 1; | |
| 793 | |
| 794 String get formatString => 'load literal null'; | |
| 795 | |
| 796 void addTo(Sink<List<int>> sink) { | |
| 797 new BytecodeBuffer() | |
| 798 ..addUint8(opcode.index) | |
| 799 ..sendOn(sink); | |
| 800 } | |
| 801 | |
| 802 String toString() => 'load literal null'; | |
| 803 } | |
| 804 | |
| 805 class LoadLiteralTrue extends Bytecode { | |
| 806 const LoadLiteralTrue() | |
| 807 : super(); | |
| 808 | |
| 809 Opcode get opcode => Opcode.LoadLiteralTrue; | |
| 810 | |
| 811 String get name => 'LoadLiteralTrue'; | |
| 812 | |
| 813 bool get isBranching => false; | |
| 814 | |
| 815 String get format => ''; | |
| 816 | |
| 817 int get size => 1; | |
| 818 | |
| 819 int get stackPointerDifference => 1; | |
| 820 | |
| 821 String get formatString => 'load literal true'; | |
| 822 | |
| 823 void addTo(Sink<List<int>> sink) { | |
| 824 new BytecodeBuffer() | |
| 825 ..addUint8(opcode.index) | |
| 826 ..sendOn(sink); | |
| 827 } | |
| 828 | |
| 829 String toString() => 'load literal true'; | |
| 830 } | |
| 831 | |
| 832 class LoadLiteralFalse extends Bytecode { | |
| 833 const LoadLiteralFalse() | |
| 834 : super(); | |
| 835 | |
| 836 Opcode get opcode => Opcode.LoadLiteralFalse; | |
| 837 | |
| 838 String get name => 'LoadLiteralFalse'; | |
| 839 | |
| 840 bool get isBranching => false; | |
| 841 | |
| 842 String get format => ''; | |
| 843 | |
| 844 int get size => 1; | |
| 845 | |
| 846 int get stackPointerDifference => 1; | |
| 847 | |
| 848 String get formatString => 'load literal false'; | |
| 849 | |
| 850 void addTo(Sink<List<int>> sink) { | |
| 851 new BytecodeBuffer() | |
| 852 ..addUint8(opcode.index) | |
| 853 ..sendOn(sink); | |
| 854 } | |
| 855 | |
| 856 String toString() => 'load literal false'; | |
| 857 } | |
| 858 | |
| 859 class LoadLiteral0 extends Bytecode { | |
| 860 const LoadLiteral0() | |
| 861 : super(); | |
| 862 | |
| 863 Opcode get opcode => Opcode.LoadLiteral0; | |
| 864 | |
| 865 String get name => 'LoadLiteral0'; | |
| 866 | |
| 867 bool get isBranching => false; | |
| 868 | |
| 869 String get format => ''; | |
| 870 | |
| 871 int get size => 1; | |
| 872 | |
| 873 int get stackPointerDifference => 1; | |
| 874 | |
| 875 String get formatString => 'load literal 0'; | |
| 876 | |
| 877 void addTo(Sink<List<int>> sink) { | |
| 878 new BytecodeBuffer() | |
| 879 ..addUint8(opcode.index) | |
| 880 ..sendOn(sink); | |
| 881 } | |
| 882 | |
| 883 String toString() => 'load literal 0'; | |
| 884 } | |
| 885 | |
| 886 class LoadLiteral1 extends Bytecode { | |
| 887 const LoadLiteral1() | |
| 888 : super(); | |
| 889 | |
| 890 Opcode get opcode => Opcode.LoadLiteral1; | |
| 891 | |
| 892 String get name => 'LoadLiteral1'; | |
| 893 | |
| 894 bool get isBranching => false; | |
| 895 | |
| 896 String get format => ''; | |
| 897 | |
| 898 int get size => 1; | |
| 899 | |
| 900 int get stackPointerDifference => 1; | |
| 901 | |
| 902 String get formatString => 'load literal 1'; | |
| 903 | |
| 904 void addTo(Sink<List<int>> sink) { | |
| 905 new BytecodeBuffer() | |
| 906 ..addUint8(opcode.index) | |
| 907 ..sendOn(sink); | |
| 908 } | |
| 909 | |
| 910 String toString() => 'load literal 1'; | |
| 911 } | |
| 912 | |
| 913 class LoadLiteral extends Bytecode { | |
| 914 final int uint8Argument0; | |
| 915 const LoadLiteral(this.uint8Argument0) | |
| 916 : super(); | |
| 917 | |
| 918 Opcode get opcode => Opcode.LoadLiteral; | |
| 919 | |
| 920 String get name => 'LoadLiteral'; | |
| 921 | |
| 922 bool get isBranching => false; | |
| 923 | |
| 924 String get format => 'B'; | |
| 925 | |
| 926 int get size => 2; | |
| 927 | |
| 928 int get stackPointerDifference => 1; | |
| 929 | |
| 930 String get formatString => 'load literal %d'; | |
| 931 | |
| 932 void addTo(Sink<List<int>> sink) { | |
| 933 new BytecodeBuffer() | |
| 934 ..addUint8(opcode.index) | |
| 935 ..addUint8(uint8Argument0) | |
| 936 ..sendOn(sink); | |
| 937 } | |
| 938 | |
| 939 String toString() => 'load literal ${uint8Argument0}'; | |
| 940 | |
| 941 operator==(Bytecode other) { | |
| 942 if (!(super==(other))) return false; | |
| 943 LoadLiteral rhs = other; | |
| 944 if (uint8Argument0 != rhs.uint8Argument0) return false; | |
| 945 return true; | |
| 946 } | |
| 947 | |
| 948 int get hashCode { | |
| 949 int value = super.hashCode; | |
| 950 value += uint8Argument0; | |
| 951 return value; | |
| 952 } | |
| 953 } | |
| 954 | |
| 955 class LoadLiteralWide extends Bytecode { | |
| 956 final int uint32Argument0; | |
| 957 const LoadLiteralWide(this.uint32Argument0) | |
| 958 : super(); | |
| 959 | |
| 960 Opcode get opcode => Opcode.LoadLiteralWide; | |
| 961 | |
| 962 String get name => 'LoadLiteralWide'; | |
| 963 | |
| 964 bool get isBranching => false; | |
| 965 | |
| 966 String get format => 'I'; | |
| 967 | |
| 968 int get size => 5; | |
| 969 | |
| 970 int get stackPointerDifference => 1; | |
| 971 | |
| 972 String get formatString => 'load literal %d'; | |
| 973 | |
| 974 void addTo(Sink<List<int>> sink) { | |
| 975 new BytecodeBuffer() | |
| 976 ..addUint8(opcode.index) | |
| 977 ..addUint32(uint32Argument0) | |
| 978 ..sendOn(sink); | |
| 979 } | |
| 980 | |
| 981 String toString() => 'load literal ${uint32Argument0}'; | |
| 982 | |
| 983 operator==(Bytecode other) { | |
| 984 if (!(super==(other))) return false; | |
| 985 LoadLiteralWide rhs = other; | |
| 986 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 987 return true; | |
| 988 } | |
| 989 | |
| 990 int get hashCode { | |
| 991 int value = super.hashCode; | |
| 992 value += uint32Argument0; | |
| 993 return value; | |
| 994 } | |
| 995 } | |
| 996 | |
| 997 class InvokeMethod extends Bytecode { | |
| 998 final int uint32Argument0; | |
| 999 const InvokeMethod(this.uint32Argument0) | |
| 1000 : super(); | |
| 1001 | |
| 1002 Opcode get opcode => Opcode.InvokeMethod; | |
| 1003 | |
| 1004 String get name => 'InvokeMethod'; | |
| 1005 | |
| 1006 bool get isBranching => true; | |
| 1007 | |
| 1008 String get format => 'I'; | |
| 1009 | |
| 1010 int get size => 5; | |
| 1011 | |
| 1012 int get stackPointerDifference => VAR_DIFF; | |
| 1013 | |
| 1014 String get formatString => 'invoke method %d'; | |
| 1015 | |
| 1016 void addTo(Sink<List<int>> sink) { | |
| 1017 new BytecodeBuffer() | |
| 1018 ..addUint8(opcode.index) | |
| 1019 ..addUint32(uint32Argument0) | |
| 1020 ..sendOn(sink); | |
| 1021 } | |
| 1022 | |
| 1023 String toString() => 'invoke method ${uint32Argument0}'; | |
| 1024 | |
| 1025 operator==(Bytecode other) { | |
| 1026 if (!(super==(other))) return false; | |
| 1027 InvokeMethod rhs = other; | |
| 1028 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1029 return true; | |
| 1030 } | |
| 1031 | |
| 1032 int get hashCode { | |
| 1033 int value = super.hashCode; | |
| 1034 value += uint32Argument0; | |
| 1035 return value; | |
| 1036 } | |
| 1037 } | |
| 1038 | |
| 1039 class InvokeTest extends Bytecode { | |
| 1040 final int uint32Argument0; | |
| 1041 const InvokeTest(this.uint32Argument0) | |
| 1042 : super(); | |
| 1043 | |
| 1044 Opcode get opcode => Opcode.InvokeTest; | |
| 1045 | |
| 1046 String get name => 'InvokeTest'; | |
| 1047 | |
| 1048 bool get isBranching => true; | |
| 1049 | |
| 1050 String get format => 'I'; | |
| 1051 | |
| 1052 int get size => 5; | |
| 1053 | |
| 1054 int get stackPointerDifference => 0; | |
| 1055 | |
| 1056 String get formatString => 'invoke test %d'; | |
| 1057 | |
| 1058 void addTo(Sink<List<int>> sink) { | |
| 1059 new BytecodeBuffer() | |
| 1060 ..addUint8(opcode.index) | |
| 1061 ..addUint32(uint32Argument0) | |
| 1062 ..sendOn(sink); | |
| 1063 } | |
| 1064 | |
| 1065 String toString() => 'invoke test ${uint32Argument0}'; | |
| 1066 | |
| 1067 operator==(Bytecode other) { | |
| 1068 if (!(super==(other))) return false; | |
| 1069 InvokeTest rhs = other; | |
| 1070 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1071 return true; | |
| 1072 } | |
| 1073 | |
| 1074 int get hashCode { | |
| 1075 int value = super.hashCode; | |
| 1076 value += uint32Argument0; | |
| 1077 return value; | |
| 1078 } | |
| 1079 } | |
| 1080 | |
| 1081 class InvokeEq extends Bytecode { | |
| 1082 final int uint32Argument0; | |
| 1083 const InvokeEq(this.uint32Argument0) | |
| 1084 : super(); | |
| 1085 | |
| 1086 Opcode get opcode => Opcode.InvokeEq; | |
| 1087 | |
| 1088 String get name => 'InvokeEq'; | |
| 1089 | |
| 1090 bool get isBranching => true; | |
| 1091 | |
| 1092 String get format => 'I'; | |
| 1093 | |
| 1094 int get size => 5; | |
| 1095 | |
| 1096 int get stackPointerDifference => -1; | |
| 1097 | |
| 1098 String get formatString => 'invoke eq %d'; | |
| 1099 | |
| 1100 void addTo(Sink<List<int>> sink) { | |
| 1101 new BytecodeBuffer() | |
| 1102 ..addUint8(opcode.index) | |
| 1103 ..addUint32(uint32Argument0) | |
| 1104 ..sendOn(sink); | |
| 1105 } | |
| 1106 | |
| 1107 String toString() => 'invoke eq ${uint32Argument0}'; | |
| 1108 | |
| 1109 operator==(Bytecode other) { | |
| 1110 if (!(super==(other))) return false; | |
| 1111 InvokeEq rhs = other; | |
| 1112 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1113 return true; | |
| 1114 } | |
| 1115 | |
| 1116 int get hashCode { | |
| 1117 int value = super.hashCode; | |
| 1118 value += uint32Argument0; | |
| 1119 return value; | |
| 1120 } | |
| 1121 } | |
| 1122 | |
| 1123 class InvokeLt extends Bytecode { | |
| 1124 final int uint32Argument0; | |
| 1125 const InvokeLt(this.uint32Argument0) | |
| 1126 : super(); | |
| 1127 | |
| 1128 Opcode get opcode => Opcode.InvokeLt; | |
| 1129 | |
| 1130 String get name => 'InvokeLt'; | |
| 1131 | |
| 1132 bool get isBranching => true; | |
| 1133 | |
| 1134 String get format => 'I'; | |
| 1135 | |
| 1136 int get size => 5; | |
| 1137 | |
| 1138 int get stackPointerDifference => -1; | |
| 1139 | |
| 1140 String get formatString => 'invoke lt %d'; | |
| 1141 | |
| 1142 void addTo(Sink<List<int>> sink) { | |
| 1143 new BytecodeBuffer() | |
| 1144 ..addUint8(opcode.index) | |
| 1145 ..addUint32(uint32Argument0) | |
| 1146 ..sendOn(sink); | |
| 1147 } | |
| 1148 | |
| 1149 String toString() => 'invoke lt ${uint32Argument0}'; | |
| 1150 | |
| 1151 operator==(Bytecode other) { | |
| 1152 if (!(super==(other))) return false; | |
| 1153 InvokeLt rhs = other; | |
| 1154 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1155 return true; | |
| 1156 } | |
| 1157 | |
| 1158 int get hashCode { | |
| 1159 int value = super.hashCode; | |
| 1160 value += uint32Argument0; | |
| 1161 return value; | |
| 1162 } | |
| 1163 } | |
| 1164 | |
| 1165 class InvokeLe extends Bytecode { | |
| 1166 final int uint32Argument0; | |
| 1167 const InvokeLe(this.uint32Argument0) | |
| 1168 : super(); | |
| 1169 | |
| 1170 Opcode get opcode => Opcode.InvokeLe; | |
| 1171 | |
| 1172 String get name => 'InvokeLe'; | |
| 1173 | |
| 1174 bool get isBranching => true; | |
| 1175 | |
| 1176 String get format => 'I'; | |
| 1177 | |
| 1178 int get size => 5; | |
| 1179 | |
| 1180 int get stackPointerDifference => -1; | |
| 1181 | |
| 1182 String get formatString => 'invoke le %d'; | |
| 1183 | |
| 1184 void addTo(Sink<List<int>> sink) { | |
| 1185 new BytecodeBuffer() | |
| 1186 ..addUint8(opcode.index) | |
| 1187 ..addUint32(uint32Argument0) | |
| 1188 ..sendOn(sink); | |
| 1189 } | |
| 1190 | |
| 1191 String toString() => 'invoke le ${uint32Argument0}'; | |
| 1192 | |
| 1193 operator==(Bytecode other) { | |
| 1194 if (!(super==(other))) return false; | |
| 1195 InvokeLe rhs = other; | |
| 1196 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1197 return true; | |
| 1198 } | |
| 1199 | |
| 1200 int get hashCode { | |
| 1201 int value = super.hashCode; | |
| 1202 value += uint32Argument0; | |
| 1203 return value; | |
| 1204 } | |
| 1205 } | |
| 1206 | |
| 1207 class InvokeGt extends Bytecode { | |
| 1208 final int uint32Argument0; | |
| 1209 const InvokeGt(this.uint32Argument0) | |
| 1210 : super(); | |
| 1211 | |
| 1212 Opcode get opcode => Opcode.InvokeGt; | |
| 1213 | |
| 1214 String get name => 'InvokeGt'; | |
| 1215 | |
| 1216 bool get isBranching => true; | |
| 1217 | |
| 1218 String get format => 'I'; | |
| 1219 | |
| 1220 int get size => 5; | |
| 1221 | |
| 1222 int get stackPointerDifference => -1; | |
| 1223 | |
| 1224 String get formatString => 'invoke gt %d'; | |
| 1225 | |
| 1226 void addTo(Sink<List<int>> sink) { | |
| 1227 new BytecodeBuffer() | |
| 1228 ..addUint8(opcode.index) | |
| 1229 ..addUint32(uint32Argument0) | |
| 1230 ..sendOn(sink); | |
| 1231 } | |
| 1232 | |
| 1233 String toString() => 'invoke gt ${uint32Argument0}'; | |
| 1234 | |
| 1235 operator==(Bytecode other) { | |
| 1236 if (!(super==(other))) return false; | |
| 1237 InvokeGt rhs = other; | |
| 1238 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1239 return true; | |
| 1240 } | |
| 1241 | |
| 1242 int get hashCode { | |
| 1243 int value = super.hashCode; | |
| 1244 value += uint32Argument0; | |
| 1245 return value; | |
| 1246 } | |
| 1247 } | |
| 1248 | |
| 1249 class InvokeGe extends Bytecode { | |
| 1250 final int uint32Argument0; | |
| 1251 const InvokeGe(this.uint32Argument0) | |
| 1252 : super(); | |
| 1253 | |
| 1254 Opcode get opcode => Opcode.InvokeGe; | |
| 1255 | |
| 1256 String get name => 'InvokeGe'; | |
| 1257 | |
| 1258 bool get isBranching => true; | |
| 1259 | |
| 1260 String get format => 'I'; | |
| 1261 | |
| 1262 int get size => 5; | |
| 1263 | |
| 1264 int get stackPointerDifference => -1; | |
| 1265 | |
| 1266 String get formatString => 'invoke ge %d'; | |
| 1267 | |
| 1268 void addTo(Sink<List<int>> sink) { | |
| 1269 new BytecodeBuffer() | |
| 1270 ..addUint8(opcode.index) | |
| 1271 ..addUint32(uint32Argument0) | |
| 1272 ..sendOn(sink); | |
| 1273 } | |
| 1274 | |
| 1275 String toString() => 'invoke ge ${uint32Argument0}'; | |
| 1276 | |
| 1277 operator==(Bytecode other) { | |
| 1278 if (!(super==(other))) return false; | |
| 1279 InvokeGe rhs = other; | |
| 1280 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1281 return true; | |
| 1282 } | |
| 1283 | |
| 1284 int get hashCode { | |
| 1285 int value = super.hashCode; | |
| 1286 value += uint32Argument0; | |
| 1287 return value; | |
| 1288 } | |
| 1289 } | |
| 1290 | |
| 1291 class InvokeAdd extends Bytecode { | |
| 1292 final int uint32Argument0; | |
| 1293 const InvokeAdd(this.uint32Argument0) | |
| 1294 : super(); | |
| 1295 | |
| 1296 Opcode get opcode => Opcode.InvokeAdd; | |
| 1297 | |
| 1298 String get name => 'InvokeAdd'; | |
| 1299 | |
| 1300 bool get isBranching => true; | |
| 1301 | |
| 1302 String get format => 'I'; | |
| 1303 | |
| 1304 int get size => 5; | |
| 1305 | |
| 1306 int get stackPointerDifference => -1; | |
| 1307 | |
| 1308 String get formatString => 'invoke add %d'; | |
| 1309 | |
| 1310 void addTo(Sink<List<int>> sink) { | |
| 1311 new BytecodeBuffer() | |
| 1312 ..addUint8(opcode.index) | |
| 1313 ..addUint32(uint32Argument0) | |
| 1314 ..sendOn(sink); | |
| 1315 } | |
| 1316 | |
| 1317 String toString() => 'invoke add ${uint32Argument0}'; | |
| 1318 | |
| 1319 operator==(Bytecode other) { | |
| 1320 if (!(super==(other))) return false; | |
| 1321 InvokeAdd rhs = other; | |
| 1322 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1323 return true; | |
| 1324 } | |
| 1325 | |
| 1326 int get hashCode { | |
| 1327 int value = super.hashCode; | |
| 1328 value += uint32Argument0; | |
| 1329 return value; | |
| 1330 } | |
| 1331 } | |
| 1332 | |
| 1333 class InvokeSub extends Bytecode { | |
| 1334 final int uint32Argument0; | |
| 1335 const InvokeSub(this.uint32Argument0) | |
| 1336 : super(); | |
| 1337 | |
| 1338 Opcode get opcode => Opcode.InvokeSub; | |
| 1339 | |
| 1340 String get name => 'InvokeSub'; | |
| 1341 | |
| 1342 bool get isBranching => true; | |
| 1343 | |
| 1344 String get format => 'I'; | |
| 1345 | |
| 1346 int get size => 5; | |
| 1347 | |
| 1348 int get stackPointerDifference => -1; | |
| 1349 | |
| 1350 String get formatString => 'invoke sub %d'; | |
| 1351 | |
| 1352 void addTo(Sink<List<int>> sink) { | |
| 1353 new BytecodeBuffer() | |
| 1354 ..addUint8(opcode.index) | |
| 1355 ..addUint32(uint32Argument0) | |
| 1356 ..sendOn(sink); | |
| 1357 } | |
| 1358 | |
| 1359 String toString() => 'invoke sub ${uint32Argument0}'; | |
| 1360 | |
| 1361 operator==(Bytecode other) { | |
| 1362 if (!(super==(other))) return false; | |
| 1363 InvokeSub rhs = other; | |
| 1364 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1365 return true; | |
| 1366 } | |
| 1367 | |
| 1368 int get hashCode { | |
| 1369 int value = super.hashCode; | |
| 1370 value += uint32Argument0; | |
| 1371 return value; | |
| 1372 } | |
| 1373 } | |
| 1374 | |
| 1375 class InvokeMod extends Bytecode { | |
| 1376 final int uint32Argument0; | |
| 1377 const InvokeMod(this.uint32Argument0) | |
| 1378 : super(); | |
| 1379 | |
| 1380 Opcode get opcode => Opcode.InvokeMod; | |
| 1381 | |
| 1382 String get name => 'InvokeMod'; | |
| 1383 | |
| 1384 bool get isBranching => true; | |
| 1385 | |
| 1386 String get format => 'I'; | |
| 1387 | |
| 1388 int get size => 5; | |
| 1389 | |
| 1390 int get stackPointerDifference => -1; | |
| 1391 | |
| 1392 String get formatString => 'invoke mod %d'; | |
| 1393 | |
| 1394 void addTo(Sink<List<int>> sink) { | |
| 1395 new BytecodeBuffer() | |
| 1396 ..addUint8(opcode.index) | |
| 1397 ..addUint32(uint32Argument0) | |
| 1398 ..sendOn(sink); | |
| 1399 } | |
| 1400 | |
| 1401 String toString() => 'invoke mod ${uint32Argument0}'; | |
| 1402 | |
| 1403 operator==(Bytecode other) { | |
| 1404 if (!(super==(other))) return false; | |
| 1405 InvokeMod rhs = other; | |
| 1406 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1407 return true; | |
| 1408 } | |
| 1409 | |
| 1410 int get hashCode { | |
| 1411 int value = super.hashCode; | |
| 1412 value += uint32Argument0; | |
| 1413 return value; | |
| 1414 } | |
| 1415 } | |
| 1416 | |
| 1417 class InvokeMul extends Bytecode { | |
| 1418 final int uint32Argument0; | |
| 1419 const InvokeMul(this.uint32Argument0) | |
| 1420 : super(); | |
| 1421 | |
| 1422 Opcode get opcode => Opcode.InvokeMul; | |
| 1423 | |
| 1424 String get name => 'InvokeMul'; | |
| 1425 | |
| 1426 bool get isBranching => true; | |
| 1427 | |
| 1428 String get format => 'I'; | |
| 1429 | |
| 1430 int get size => 5; | |
| 1431 | |
| 1432 int get stackPointerDifference => -1; | |
| 1433 | |
| 1434 String get formatString => 'invoke mul %d'; | |
| 1435 | |
| 1436 void addTo(Sink<List<int>> sink) { | |
| 1437 new BytecodeBuffer() | |
| 1438 ..addUint8(opcode.index) | |
| 1439 ..addUint32(uint32Argument0) | |
| 1440 ..sendOn(sink); | |
| 1441 } | |
| 1442 | |
| 1443 String toString() => 'invoke mul ${uint32Argument0}'; | |
| 1444 | |
| 1445 operator==(Bytecode other) { | |
| 1446 if (!(super==(other))) return false; | |
| 1447 InvokeMul rhs = other; | |
| 1448 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1449 return true; | |
| 1450 } | |
| 1451 | |
| 1452 int get hashCode { | |
| 1453 int value = super.hashCode; | |
| 1454 value += uint32Argument0; | |
| 1455 return value; | |
| 1456 } | |
| 1457 } | |
| 1458 | |
| 1459 class InvokeTruncDiv extends Bytecode { | |
| 1460 final int uint32Argument0; | |
| 1461 const InvokeTruncDiv(this.uint32Argument0) | |
| 1462 : super(); | |
| 1463 | |
| 1464 Opcode get opcode => Opcode.InvokeTruncDiv; | |
| 1465 | |
| 1466 String get name => 'InvokeTruncDiv'; | |
| 1467 | |
| 1468 bool get isBranching => true; | |
| 1469 | |
| 1470 String get format => 'I'; | |
| 1471 | |
| 1472 int get size => 5; | |
| 1473 | |
| 1474 int get stackPointerDifference => -1; | |
| 1475 | |
| 1476 String get formatString => 'invoke trunc div %d'; | |
| 1477 | |
| 1478 void addTo(Sink<List<int>> sink) { | |
| 1479 new BytecodeBuffer() | |
| 1480 ..addUint8(opcode.index) | |
| 1481 ..addUint32(uint32Argument0) | |
| 1482 ..sendOn(sink); | |
| 1483 } | |
| 1484 | |
| 1485 String toString() => 'invoke trunc div ${uint32Argument0}'; | |
| 1486 | |
| 1487 operator==(Bytecode other) { | |
| 1488 if (!(super==(other))) return false; | |
| 1489 InvokeTruncDiv rhs = other; | |
| 1490 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1491 return true; | |
| 1492 } | |
| 1493 | |
| 1494 int get hashCode { | |
| 1495 int value = super.hashCode; | |
| 1496 value += uint32Argument0; | |
| 1497 return value; | |
| 1498 } | |
| 1499 } | |
| 1500 | |
| 1501 class InvokeBitNot extends Bytecode { | |
| 1502 final int uint32Argument0; | |
| 1503 const InvokeBitNot(this.uint32Argument0) | |
| 1504 : super(); | |
| 1505 | |
| 1506 Opcode get opcode => Opcode.InvokeBitNot; | |
| 1507 | |
| 1508 String get name => 'InvokeBitNot'; | |
| 1509 | |
| 1510 bool get isBranching => true; | |
| 1511 | |
| 1512 String get format => 'I'; | |
| 1513 | |
| 1514 int get size => 5; | |
| 1515 | |
| 1516 int get stackPointerDifference => 0; | |
| 1517 | |
| 1518 String get formatString => 'invoke bit not %d'; | |
| 1519 | |
| 1520 void addTo(Sink<List<int>> sink) { | |
| 1521 new BytecodeBuffer() | |
| 1522 ..addUint8(opcode.index) | |
| 1523 ..addUint32(uint32Argument0) | |
| 1524 ..sendOn(sink); | |
| 1525 } | |
| 1526 | |
| 1527 String toString() => 'invoke bit not ${uint32Argument0}'; | |
| 1528 | |
| 1529 operator==(Bytecode other) { | |
| 1530 if (!(super==(other))) return false; | |
| 1531 InvokeBitNot rhs = other; | |
| 1532 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1533 return true; | |
| 1534 } | |
| 1535 | |
| 1536 int get hashCode { | |
| 1537 int value = super.hashCode; | |
| 1538 value += uint32Argument0; | |
| 1539 return value; | |
| 1540 } | |
| 1541 } | |
| 1542 | |
| 1543 class InvokeBitAnd extends Bytecode { | |
| 1544 final int uint32Argument0; | |
| 1545 const InvokeBitAnd(this.uint32Argument0) | |
| 1546 : super(); | |
| 1547 | |
| 1548 Opcode get opcode => Opcode.InvokeBitAnd; | |
| 1549 | |
| 1550 String get name => 'InvokeBitAnd'; | |
| 1551 | |
| 1552 bool get isBranching => true; | |
| 1553 | |
| 1554 String get format => 'I'; | |
| 1555 | |
| 1556 int get size => 5; | |
| 1557 | |
| 1558 int get stackPointerDifference => -1; | |
| 1559 | |
| 1560 String get formatString => 'invoke bit and %d'; | |
| 1561 | |
| 1562 void addTo(Sink<List<int>> sink) { | |
| 1563 new BytecodeBuffer() | |
| 1564 ..addUint8(opcode.index) | |
| 1565 ..addUint32(uint32Argument0) | |
| 1566 ..sendOn(sink); | |
| 1567 } | |
| 1568 | |
| 1569 String toString() => 'invoke bit and ${uint32Argument0}'; | |
| 1570 | |
| 1571 operator==(Bytecode other) { | |
| 1572 if (!(super==(other))) return false; | |
| 1573 InvokeBitAnd rhs = other; | |
| 1574 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1575 return true; | |
| 1576 } | |
| 1577 | |
| 1578 int get hashCode { | |
| 1579 int value = super.hashCode; | |
| 1580 value += uint32Argument0; | |
| 1581 return value; | |
| 1582 } | |
| 1583 } | |
| 1584 | |
| 1585 class InvokeBitOr extends Bytecode { | |
| 1586 final int uint32Argument0; | |
| 1587 const InvokeBitOr(this.uint32Argument0) | |
| 1588 : super(); | |
| 1589 | |
| 1590 Opcode get opcode => Opcode.InvokeBitOr; | |
| 1591 | |
| 1592 String get name => 'InvokeBitOr'; | |
| 1593 | |
| 1594 bool get isBranching => true; | |
| 1595 | |
| 1596 String get format => 'I'; | |
| 1597 | |
| 1598 int get size => 5; | |
| 1599 | |
| 1600 int get stackPointerDifference => -1; | |
| 1601 | |
| 1602 String get formatString => 'invoke bit or %d'; | |
| 1603 | |
| 1604 void addTo(Sink<List<int>> sink) { | |
| 1605 new BytecodeBuffer() | |
| 1606 ..addUint8(opcode.index) | |
| 1607 ..addUint32(uint32Argument0) | |
| 1608 ..sendOn(sink); | |
| 1609 } | |
| 1610 | |
| 1611 String toString() => 'invoke bit or ${uint32Argument0}'; | |
| 1612 | |
| 1613 operator==(Bytecode other) { | |
| 1614 if (!(super==(other))) return false; | |
| 1615 InvokeBitOr rhs = other; | |
| 1616 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1617 return true; | |
| 1618 } | |
| 1619 | |
| 1620 int get hashCode { | |
| 1621 int value = super.hashCode; | |
| 1622 value += uint32Argument0; | |
| 1623 return value; | |
| 1624 } | |
| 1625 } | |
| 1626 | |
| 1627 class InvokeBitXor extends Bytecode { | |
| 1628 final int uint32Argument0; | |
| 1629 const InvokeBitXor(this.uint32Argument0) | |
| 1630 : super(); | |
| 1631 | |
| 1632 Opcode get opcode => Opcode.InvokeBitXor; | |
| 1633 | |
| 1634 String get name => 'InvokeBitXor'; | |
| 1635 | |
| 1636 bool get isBranching => true; | |
| 1637 | |
| 1638 String get format => 'I'; | |
| 1639 | |
| 1640 int get size => 5; | |
| 1641 | |
| 1642 int get stackPointerDifference => -1; | |
| 1643 | |
| 1644 String get formatString => 'invoke bit xor %d'; | |
| 1645 | |
| 1646 void addTo(Sink<List<int>> sink) { | |
| 1647 new BytecodeBuffer() | |
| 1648 ..addUint8(opcode.index) | |
| 1649 ..addUint32(uint32Argument0) | |
| 1650 ..sendOn(sink); | |
| 1651 } | |
| 1652 | |
| 1653 String toString() => 'invoke bit xor ${uint32Argument0}'; | |
| 1654 | |
| 1655 operator==(Bytecode other) { | |
| 1656 if (!(super==(other))) return false; | |
| 1657 InvokeBitXor rhs = other; | |
| 1658 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1659 return true; | |
| 1660 } | |
| 1661 | |
| 1662 int get hashCode { | |
| 1663 int value = super.hashCode; | |
| 1664 value += uint32Argument0; | |
| 1665 return value; | |
| 1666 } | |
| 1667 } | |
| 1668 | |
| 1669 class InvokeBitShr extends Bytecode { | |
| 1670 final int uint32Argument0; | |
| 1671 const InvokeBitShr(this.uint32Argument0) | |
| 1672 : super(); | |
| 1673 | |
| 1674 Opcode get opcode => Opcode.InvokeBitShr; | |
| 1675 | |
| 1676 String get name => 'InvokeBitShr'; | |
| 1677 | |
| 1678 bool get isBranching => true; | |
| 1679 | |
| 1680 String get format => 'I'; | |
| 1681 | |
| 1682 int get size => 5; | |
| 1683 | |
| 1684 int get stackPointerDifference => -1; | |
| 1685 | |
| 1686 String get formatString => 'invoke bit shr %d'; | |
| 1687 | |
| 1688 void addTo(Sink<List<int>> sink) { | |
| 1689 new BytecodeBuffer() | |
| 1690 ..addUint8(opcode.index) | |
| 1691 ..addUint32(uint32Argument0) | |
| 1692 ..sendOn(sink); | |
| 1693 } | |
| 1694 | |
| 1695 String toString() => 'invoke bit shr ${uint32Argument0}'; | |
| 1696 | |
| 1697 operator==(Bytecode other) { | |
| 1698 if (!(super==(other))) return false; | |
| 1699 InvokeBitShr rhs = other; | |
| 1700 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1701 return true; | |
| 1702 } | |
| 1703 | |
| 1704 int get hashCode { | |
| 1705 int value = super.hashCode; | |
| 1706 value += uint32Argument0; | |
| 1707 return value; | |
| 1708 } | |
| 1709 } | |
| 1710 | |
| 1711 class InvokeBitShl extends Bytecode { | |
| 1712 final int uint32Argument0; | |
| 1713 const InvokeBitShl(this.uint32Argument0) | |
| 1714 : super(); | |
| 1715 | |
| 1716 Opcode get opcode => Opcode.InvokeBitShl; | |
| 1717 | |
| 1718 String get name => 'InvokeBitShl'; | |
| 1719 | |
| 1720 bool get isBranching => true; | |
| 1721 | |
| 1722 String get format => 'I'; | |
| 1723 | |
| 1724 int get size => 5; | |
| 1725 | |
| 1726 int get stackPointerDifference => -1; | |
| 1727 | |
| 1728 String get formatString => 'invoke bit shl %d'; | |
| 1729 | |
| 1730 void addTo(Sink<List<int>> sink) { | |
| 1731 new BytecodeBuffer() | |
| 1732 ..addUint8(opcode.index) | |
| 1733 ..addUint32(uint32Argument0) | |
| 1734 ..sendOn(sink); | |
| 1735 } | |
| 1736 | |
| 1737 String toString() => 'invoke bit shl ${uint32Argument0}'; | |
| 1738 | |
| 1739 operator==(Bytecode other) { | |
| 1740 if (!(super==(other))) return false; | |
| 1741 InvokeBitShl rhs = other; | |
| 1742 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1743 return true; | |
| 1744 } | |
| 1745 | |
| 1746 int get hashCode { | |
| 1747 int value = super.hashCode; | |
| 1748 value += uint32Argument0; | |
| 1749 return value; | |
| 1750 } | |
| 1751 } | |
| 1752 | |
| 1753 class InvokeStatic extends Bytecode { | |
| 1754 final int uint32Argument0; | |
| 1755 const InvokeStatic(this.uint32Argument0) | |
| 1756 : super(); | |
| 1757 | |
| 1758 Opcode get opcode => Opcode.InvokeStatic; | |
| 1759 | |
| 1760 String get name => 'InvokeStatic'; | |
| 1761 | |
| 1762 bool get isBranching => true; | |
| 1763 | |
| 1764 String get format => 'I'; | |
| 1765 | |
| 1766 int get size => 5; | |
| 1767 | |
| 1768 int get stackPointerDifference => VAR_DIFF; | |
| 1769 | |
| 1770 String get formatString => 'invoke static %d'; | |
| 1771 | |
| 1772 void addTo(Sink<List<int>> sink) { | |
| 1773 new BytecodeBuffer() | |
| 1774 ..addUint8(opcode.index) | |
| 1775 ..addUint32(uint32Argument0) | |
| 1776 ..sendOn(sink); | |
| 1777 } | |
| 1778 | |
| 1779 String toString() => 'invoke static ${uint32Argument0}'; | |
| 1780 | |
| 1781 operator==(Bytecode other) { | |
| 1782 if (!(super==(other))) return false; | |
| 1783 InvokeStatic rhs = other; | |
| 1784 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1785 return true; | |
| 1786 } | |
| 1787 | |
| 1788 int get hashCode { | |
| 1789 int value = super.hashCode; | |
| 1790 value += uint32Argument0; | |
| 1791 return value; | |
| 1792 } | |
| 1793 } | |
| 1794 | |
| 1795 class InvokeFactory extends Bytecode { | |
| 1796 final int uint32Argument0; | |
| 1797 const InvokeFactory(this.uint32Argument0) | |
| 1798 : super(); | |
| 1799 | |
| 1800 Opcode get opcode => Opcode.InvokeFactory; | |
| 1801 | |
| 1802 String get name => 'InvokeFactory'; | |
| 1803 | |
| 1804 bool get isBranching => true; | |
| 1805 | |
| 1806 String get format => 'I'; | |
| 1807 | |
| 1808 int get size => 5; | |
| 1809 | |
| 1810 int get stackPointerDifference => VAR_DIFF; | |
| 1811 | |
| 1812 String get formatString => 'invoke factory %d'; | |
| 1813 | |
| 1814 void addTo(Sink<List<int>> sink) { | |
| 1815 new BytecodeBuffer() | |
| 1816 ..addUint8(opcode.index) | |
| 1817 ..addUint32(uint32Argument0) | |
| 1818 ..sendOn(sink); | |
| 1819 } | |
| 1820 | |
| 1821 String toString() => 'invoke factory ${uint32Argument0}'; | |
| 1822 | |
| 1823 operator==(Bytecode other) { | |
| 1824 if (!(super==(other))) return false; | |
| 1825 InvokeFactory rhs = other; | |
| 1826 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1827 return true; | |
| 1828 } | |
| 1829 | |
| 1830 int get hashCode { | |
| 1831 int value = super.hashCode; | |
| 1832 value += uint32Argument0; | |
| 1833 return value; | |
| 1834 } | |
| 1835 } | |
| 1836 | |
| 1837 class Allocate extends Bytecode { | |
| 1838 final int uint32Argument0; | |
| 1839 const Allocate(this.uint32Argument0) | |
| 1840 : super(); | |
| 1841 | |
| 1842 Opcode get opcode => Opcode.Allocate; | |
| 1843 | |
| 1844 String get name => 'Allocate'; | |
| 1845 | |
| 1846 bool get isBranching => false; | |
| 1847 | |
| 1848 String get format => 'I'; | |
| 1849 | |
| 1850 int get size => 5; | |
| 1851 | |
| 1852 int get stackPointerDifference => VAR_DIFF; | |
| 1853 | |
| 1854 String get formatString => 'allocate %d'; | |
| 1855 | |
| 1856 void addTo(Sink<List<int>> sink) { | |
| 1857 new BytecodeBuffer() | |
| 1858 ..addUint8(opcode.index) | |
| 1859 ..addUint32(uint32Argument0) | |
| 1860 ..sendOn(sink); | |
| 1861 } | |
| 1862 | |
| 1863 String toString() => 'allocate ${uint32Argument0}'; | |
| 1864 | |
| 1865 operator==(Bytecode other) { | |
| 1866 if (!(super==(other))) return false; | |
| 1867 Allocate rhs = other; | |
| 1868 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1869 return true; | |
| 1870 } | |
| 1871 | |
| 1872 int get hashCode { | |
| 1873 int value = super.hashCode; | |
| 1874 value += uint32Argument0; | |
| 1875 return value; | |
| 1876 } | |
| 1877 } | |
| 1878 | |
| 1879 class AllocateImmutable extends Bytecode { | |
| 1880 final int uint32Argument0; | |
| 1881 const AllocateImmutable(this.uint32Argument0) | |
| 1882 : super(); | |
| 1883 | |
| 1884 Opcode get opcode => Opcode.AllocateImmutable; | |
| 1885 | |
| 1886 String get name => 'AllocateImmutable'; | |
| 1887 | |
| 1888 bool get isBranching => false; | |
| 1889 | |
| 1890 String get format => 'I'; | |
| 1891 | |
| 1892 int get size => 5; | |
| 1893 | |
| 1894 int get stackPointerDifference => VAR_DIFF; | |
| 1895 | |
| 1896 String get formatString => 'allocateim %d'; | |
| 1897 | |
| 1898 void addTo(Sink<List<int>> sink) { | |
| 1899 new BytecodeBuffer() | |
| 1900 ..addUint8(opcode.index) | |
| 1901 ..addUint32(uint32Argument0) | |
| 1902 ..sendOn(sink); | |
| 1903 } | |
| 1904 | |
| 1905 String toString() => 'allocateim ${uint32Argument0}'; | |
| 1906 | |
| 1907 operator==(Bytecode other) { | |
| 1908 if (!(super==(other))) return false; | |
| 1909 AllocateImmutable rhs = other; | |
| 1910 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1911 return true; | |
| 1912 } | |
| 1913 | |
| 1914 int get hashCode { | |
| 1915 int value = super.hashCode; | |
| 1916 value += uint32Argument0; | |
| 1917 return value; | |
| 1918 } | |
| 1919 } | |
| 1920 | |
| 1921 class InvokeNoSuchMethod extends Bytecode { | |
| 1922 final int uint32Argument0; | |
| 1923 const InvokeNoSuchMethod(this.uint32Argument0) | |
| 1924 : super(); | |
| 1925 | |
| 1926 Opcode get opcode => Opcode.InvokeNoSuchMethod; | |
| 1927 | |
| 1928 String get name => 'InvokeNoSuchMethod'; | |
| 1929 | |
| 1930 bool get isBranching => true; | |
| 1931 | |
| 1932 String get format => 'I'; | |
| 1933 | |
| 1934 int get size => 5; | |
| 1935 | |
| 1936 int get stackPointerDifference => VAR_DIFF; | |
| 1937 | |
| 1938 String get formatString => 'invoke no such method %d'; | |
| 1939 | |
| 1940 void addTo(Sink<List<int>> sink) { | |
| 1941 new BytecodeBuffer() | |
| 1942 ..addUint8(opcode.index) | |
| 1943 ..addUint32(uint32Argument0) | |
| 1944 ..sendOn(sink); | |
| 1945 } | |
| 1946 | |
| 1947 String toString() => 'invoke no such method ${uint32Argument0}'; | |
| 1948 | |
| 1949 operator==(Bytecode other) { | |
| 1950 if (!(super==(other))) return false; | |
| 1951 InvokeNoSuchMethod rhs = other; | |
| 1952 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1953 return true; | |
| 1954 } | |
| 1955 | |
| 1956 int get hashCode { | |
| 1957 int value = super.hashCode; | |
| 1958 value += uint32Argument0; | |
| 1959 return value; | |
| 1960 } | |
| 1961 } | |
| 1962 | |
| 1963 class InvokeTestNoSuchMethod extends Bytecode { | |
| 1964 final int uint32Argument0; | |
| 1965 const InvokeTestNoSuchMethod(this.uint32Argument0) | |
| 1966 : super(); | |
| 1967 | |
| 1968 Opcode get opcode => Opcode.InvokeTestNoSuchMethod; | |
| 1969 | |
| 1970 String get name => 'InvokeTestNoSuchMethod'; | |
| 1971 | |
| 1972 bool get isBranching => true; | |
| 1973 | |
| 1974 String get format => 'I'; | |
| 1975 | |
| 1976 int get size => 5; | |
| 1977 | |
| 1978 int get stackPointerDifference => 0; | |
| 1979 | |
| 1980 String get formatString => 'invoke test no such method %d'; | |
| 1981 | |
| 1982 void addTo(Sink<List<int>> sink) { | |
| 1983 new BytecodeBuffer() | |
| 1984 ..addUint8(opcode.index) | |
| 1985 ..addUint32(uint32Argument0) | |
| 1986 ..sendOn(sink); | |
| 1987 } | |
| 1988 | |
| 1989 String toString() => 'invoke test no such method ${uint32Argument0}'; | |
| 1990 | |
| 1991 operator==(Bytecode other) { | |
| 1992 if (!(super==(other))) return false; | |
| 1993 InvokeTestNoSuchMethod rhs = other; | |
| 1994 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 1995 return true; | |
| 1996 } | |
| 1997 | |
| 1998 int get hashCode { | |
| 1999 int value = super.hashCode; | |
| 2000 value += uint32Argument0; | |
| 2001 return value; | |
| 2002 } | |
| 2003 } | |
| 2004 | |
| 2005 class InvokeNative extends Bytecode { | |
| 2006 final int uint8Argument0; | |
| 2007 final int uint8Argument1; | |
| 2008 const InvokeNative(this.uint8Argument0, this.uint8Argument1) | |
| 2009 : super(); | |
| 2010 | |
| 2011 Opcode get opcode => Opcode.InvokeNative; | |
| 2012 | |
| 2013 String get name => 'InvokeNative'; | |
| 2014 | |
| 2015 bool get isBranching => true; | |
| 2016 | |
| 2017 String get format => 'BB'; | |
| 2018 | |
| 2019 int get size => 3; | |
| 2020 | |
| 2021 int get stackPointerDifference => 1; | |
| 2022 | |
| 2023 String get formatString => 'invoke native %d %d'; | |
| 2024 | |
| 2025 void addTo(Sink<List<int>> sink) { | |
| 2026 new BytecodeBuffer() | |
| 2027 ..addUint8(opcode.index) | |
| 2028 ..addUint8(uint8Argument0) | |
| 2029 ..addUint8(uint8Argument1) | |
| 2030 ..sendOn(sink); | |
| 2031 } | |
| 2032 | |
| 2033 String toString() => 'invoke native ${uint8Argument0} ${uint8Argument1}'; | |
| 2034 | |
| 2035 operator==(Bytecode other) { | |
| 2036 if (!(super==(other))) return false; | |
| 2037 InvokeNative rhs = other; | |
| 2038 if (uint8Argument0 != rhs.uint8Argument0) return false; | |
| 2039 if (uint8Argument1 != rhs.uint8Argument1) return false; | |
| 2040 return true; | |
| 2041 } | |
| 2042 | |
| 2043 int get hashCode { | |
| 2044 int value = super.hashCode; | |
| 2045 value += uint8Argument0; | |
| 2046 value += uint8Argument1; | |
| 2047 return value; | |
| 2048 } | |
| 2049 } | |
| 2050 | |
| 2051 class InvokeDetachableNative extends Bytecode { | |
| 2052 final int uint8Argument0; | |
| 2053 final int uint8Argument1; | |
| 2054 const InvokeDetachableNative(this.uint8Argument0, this.uint8Argument1) | |
| 2055 : super(); | |
| 2056 | |
| 2057 Opcode get opcode => Opcode.InvokeDetachableNative; | |
| 2058 | |
| 2059 String get name => 'InvokeDetachableNative'; | |
| 2060 | |
| 2061 bool get isBranching => true; | |
| 2062 | |
| 2063 String get format => 'BB'; | |
| 2064 | |
| 2065 int get size => 3; | |
| 2066 | |
| 2067 int get stackPointerDifference => 1; | |
| 2068 | |
| 2069 String get formatString => 'invoke detachable native %d %d'; | |
| 2070 | |
| 2071 void addTo(Sink<List<int>> sink) { | |
| 2072 new BytecodeBuffer() | |
| 2073 ..addUint8(opcode.index) | |
| 2074 ..addUint8(uint8Argument0) | |
| 2075 ..addUint8(uint8Argument1) | |
| 2076 ..sendOn(sink); | |
| 2077 } | |
| 2078 | |
| 2079 String toString() => 'invoke detachable native ${uint8Argument0} ${uint8Argume
nt1}'; | |
| 2080 | |
| 2081 operator==(Bytecode other) { | |
| 2082 if (!(super==(other))) return false; | |
| 2083 InvokeDetachableNative rhs = other; | |
| 2084 if (uint8Argument0 != rhs.uint8Argument0) return false; | |
| 2085 if (uint8Argument1 != rhs.uint8Argument1) return false; | |
| 2086 return true; | |
| 2087 } | |
| 2088 | |
| 2089 int get hashCode { | |
| 2090 int value = super.hashCode; | |
| 2091 value += uint8Argument0; | |
| 2092 value += uint8Argument1; | |
| 2093 return value; | |
| 2094 } | |
| 2095 } | |
| 2096 | |
| 2097 class InvokeNativeYield extends Bytecode { | |
| 2098 final int uint8Argument0; | |
| 2099 final int uint8Argument1; | |
| 2100 const InvokeNativeYield(this.uint8Argument0, this.uint8Argument1) | |
| 2101 : super(); | |
| 2102 | |
| 2103 Opcode get opcode => Opcode.InvokeNativeYield; | |
| 2104 | |
| 2105 String get name => 'InvokeNativeYield'; | |
| 2106 | |
| 2107 bool get isBranching => true; | |
| 2108 | |
| 2109 String get format => 'BB'; | |
| 2110 | |
| 2111 int get size => 3; | |
| 2112 | |
| 2113 int get stackPointerDifference => 1; | |
| 2114 | |
| 2115 String get formatString => 'invoke native yield %d %d'; | |
| 2116 | |
| 2117 void addTo(Sink<List<int>> sink) { | |
| 2118 new BytecodeBuffer() | |
| 2119 ..addUint8(opcode.index) | |
| 2120 ..addUint8(uint8Argument0) | |
| 2121 ..addUint8(uint8Argument1) | |
| 2122 ..sendOn(sink); | |
| 2123 } | |
| 2124 | |
| 2125 String toString() => 'invoke native yield ${uint8Argument0} ${uint8Argument1}'
; | |
| 2126 | |
| 2127 operator==(Bytecode other) { | |
| 2128 if (!(super==(other))) return false; | |
| 2129 InvokeNativeYield rhs = other; | |
| 2130 if (uint8Argument0 != rhs.uint8Argument0) return false; | |
| 2131 if (uint8Argument1 != rhs.uint8Argument1) return false; | |
| 2132 return true; | |
| 2133 } | |
| 2134 | |
| 2135 int get hashCode { | |
| 2136 int value = super.hashCode; | |
| 2137 value += uint8Argument0; | |
| 2138 value += uint8Argument1; | |
| 2139 return value; | |
| 2140 } | |
| 2141 } | |
| 2142 | |
| 2143 class InvokeSelector extends Bytecode { | |
| 2144 final int uint32Argument0; | |
| 2145 const InvokeSelector(this.uint32Argument0) | |
| 2146 : super(); | |
| 2147 | |
| 2148 Opcode get opcode => Opcode.InvokeSelector; | |
| 2149 | |
| 2150 String get name => 'InvokeSelector'; | |
| 2151 | |
| 2152 bool get isBranching => true; | |
| 2153 | |
| 2154 String get format => 'I'; | |
| 2155 | |
| 2156 int get size => 5; | |
| 2157 | |
| 2158 int get stackPointerDifference => VAR_DIFF; | |
| 2159 | |
| 2160 String get formatString => 'invoke selector'; | |
| 2161 | |
| 2162 void addTo(Sink<List<int>> sink) { | |
| 2163 new BytecodeBuffer() | |
| 2164 ..addUint8(opcode.index) | |
| 2165 ..addUint32(uint32Argument0) | |
| 2166 ..sendOn(sink); | |
| 2167 } | |
| 2168 | |
| 2169 String toString() => 'invoke selector${uint32Argument0}'; | |
| 2170 | |
| 2171 operator==(Bytecode other) { | |
| 2172 if (!(super==(other))) return false; | |
| 2173 InvokeSelector rhs = other; | |
| 2174 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 2175 return true; | |
| 2176 } | |
| 2177 | |
| 2178 int get hashCode { | |
| 2179 int value = super.hashCode; | |
| 2180 value += uint32Argument0; | |
| 2181 return value; | |
| 2182 } | |
| 2183 } | |
| 2184 | |
| 2185 class Pop extends Bytecode { | |
| 2186 const Pop() | |
| 2187 : super(); | |
| 2188 | |
| 2189 Opcode get opcode => Opcode.Pop; | |
| 2190 | |
| 2191 String get name => 'Pop'; | |
| 2192 | |
| 2193 bool get isBranching => false; | |
| 2194 | |
| 2195 String get format => ''; | |
| 2196 | |
| 2197 int get size => 1; | |
| 2198 | |
| 2199 int get stackPointerDifference => -1; | |
| 2200 | |
| 2201 String get formatString => 'pop'; | |
| 2202 | |
| 2203 void addTo(Sink<List<int>> sink) { | |
| 2204 new BytecodeBuffer() | |
| 2205 ..addUint8(opcode.index) | |
| 2206 ..sendOn(sink); | |
| 2207 } | |
| 2208 | |
| 2209 String toString() => 'pop'; | |
| 2210 } | |
| 2211 | |
| 2212 class Drop extends Bytecode { | |
| 2213 final int uint8Argument0; | |
| 2214 const Drop(this.uint8Argument0) | |
| 2215 : super(); | |
| 2216 | |
| 2217 Opcode get opcode => Opcode.Drop; | |
| 2218 | |
| 2219 String get name => 'Drop'; | |
| 2220 | |
| 2221 bool get isBranching => false; | |
| 2222 | |
| 2223 String get format => 'B'; | |
| 2224 | |
| 2225 int get size => 2; | |
| 2226 | |
| 2227 int get stackPointerDifference => VAR_DIFF; | |
| 2228 | |
| 2229 String get formatString => 'drop %d'; | |
| 2230 | |
| 2231 void addTo(Sink<List<int>> sink) { | |
| 2232 new BytecodeBuffer() | |
| 2233 ..addUint8(opcode.index) | |
| 2234 ..addUint8(uint8Argument0) | |
| 2235 ..sendOn(sink); | |
| 2236 } | |
| 2237 | |
| 2238 String toString() => 'drop ${uint8Argument0}'; | |
| 2239 | |
| 2240 operator==(Bytecode other) { | |
| 2241 if (!(super==(other))) return false; | |
| 2242 Drop rhs = other; | |
| 2243 if (uint8Argument0 != rhs.uint8Argument0) return false; | |
| 2244 return true; | |
| 2245 } | |
| 2246 | |
| 2247 int get hashCode { | |
| 2248 int value = super.hashCode; | |
| 2249 value += uint8Argument0; | |
| 2250 return value; | |
| 2251 } | |
| 2252 } | |
| 2253 | |
| 2254 class Return extends Bytecode { | |
| 2255 const Return() | |
| 2256 : super(); | |
| 2257 | |
| 2258 Opcode get opcode => Opcode.Return; | |
| 2259 | |
| 2260 String get name => 'Return'; | |
| 2261 | |
| 2262 bool get isBranching => true; | |
| 2263 | |
| 2264 String get format => ''; | |
| 2265 | |
| 2266 int get size => 1; | |
| 2267 | |
| 2268 int get stackPointerDifference => -1; | |
| 2269 | |
| 2270 String get formatString => 'return'; | |
| 2271 | |
| 2272 void addTo(Sink<List<int>> sink) { | |
| 2273 new BytecodeBuffer() | |
| 2274 ..addUint8(opcode.index) | |
| 2275 ..sendOn(sink); | |
| 2276 } | |
| 2277 | |
| 2278 String toString() => 'return'; | |
| 2279 } | |
| 2280 | |
| 2281 class ReturnNull extends Bytecode { | |
| 2282 const ReturnNull() | |
| 2283 : super(); | |
| 2284 | |
| 2285 Opcode get opcode => Opcode.ReturnNull; | |
| 2286 | |
| 2287 String get name => 'ReturnNull'; | |
| 2288 | |
| 2289 bool get isBranching => true; | |
| 2290 | |
| 2291 String get format => ''; | |
| 2292 | |
| 2293 int get size => 1; | |
| 2294 | |
| 2295 int get stackPointerDifference => 0; | |
| 2296 | |
| 2297 String get formatString => 'return null'; | |
| 2298 | |
| 2299 void addTo(Sink<List<int>> sink) { | |
| 2300 new BytecodeBuffer() | |
| 2301 ..addUint8(opcode.index) | |
| 2302 ..sendOn(sink); | |
| 2303 } | |
| 2304 | |
| 2305 String toString() => 'return null'; | |
| 2306 } | |
| 2307 | |
| 2308 class BranchWide extends Bytecode { | |
| 2309 final int uint32Argument0; | |
| 2310 const BranchWide(this.uint32Argument0) | |
| 2311 : super(); | |
| 2312 | |
| 2313 Opcode get opcode => Opcode.BranchWide; | |
| 2314 | |
| 2315 String get name => 'BranchWide'; | |
| 2316 | |
| 2317 bool get isBranching => true; | |
| 2318 | |
| 2319 String get format => 'I'; | |
| 2320 | |
| 2321 int get size => 5; | |
| 2322 | |
| 2323 int get stackPointerDifference => 0; | |
| 2324 | |
| 2325 String get formatString => 'branch +%d'; | |
| 2326 | |
| 2327 void addTo(Sink<List<int>> sink) { | |
| 2328 new BytecodeBuffer() | |
| 2329 ..addUint8(opcode.index) | |
| 2330 ..addUint32(uint32Argument0) | |
| 2331 ..sendOn(sink); | |
| 2332 } | |
| 2333 | |
| 2334 String toString() => 'branch +${uint32Argument0}'; | |
| 2335 | |
| 2336 operator==(Bytecode other) { | |
| 2337 if (!(super==(other))) return false; | |
| 2338 BranchWide rhs = other; | |
| 2339 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 2340 return true; | |
| 2341 } | |
| 2342 | |
| 2343 int get hashCode { | |
| 2344 int value = super.hashCode; | |
| 2345 value += uint32Argument0; | |
| 2346 return value; | |
| 2347 } | |
| 2348 } | |
| 2349 | |
| 2350 class BranchIfTrueWide extends Bytecode { | |
| 2351 final int uint32Argument0; | |
| 2352 const BranchIfTrueWide(this.uint32Argument0) | |
| 2353 : super(); | |
| 2354 | |
| 2355 Opcode get opcode => Opcode.BranchIfTrueWide; | |
| 2356 | |
| 2357 String get name => 'BranchIfTrueWide'; | |
| 2358 | |
| 2359 bool get isBranching => true; | |
| 2360 | |
| 2361 String get format => 'I'; | |
| 2362 | |
| 2363 int get size => 5; | |
| 2364 | |
| 2365 int get stackPointerDifference => -1; | |
| 2366 | |
| 2367 String get formatString => 'branch if true +%d'; | |
| 2368 | |
| 2369 void addTo(Sink<List<int>> sink) { | |
| 2370 new BytecodeBuffer() | |
| 2371 ..addUint8(opcode.index) | |
| 2372 ..addUint32(uint32Argument0) | |
| 2373 ..sendOn(sink); | |
| 2374 } | |
| 2375 | |
| 2376 String toString() => 'branch if true +${uint32Argument0}'; | |
| 2377 | |
| 2378 operator==(Bytecode other) { | |
| 2379 if (!(super==(other))) return false; | |
| 2380 BranchIfTrueWide rhs = other; | |
| 2381 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 2382 return true; | |
| 2383 } | |
| 2384 | |
| 2385 int get hashCode { | |
| 2386 int value = super.hashCode; | |
| 2387 value += uint32Argument0; | |
| 2388 return value; | |
| 2389 } | |
| 2390 } | |
| 2391 | |
| 2392 class BranchIfFalseWide extends Bytecode { | |
| 2393 final int uint32Argument0; | |
| 2394 const BranchIfFalseWide(this.uint32Argument0) | |
| 2395 : super(); | |
| 2396 | |
| 2397 Opcode get opcode => Opcode.BranchIfFalseWide; | |
| 2398 | |
| 2399 String get name => 'BranchIfFalseWide'; | |
| 2400 | |
| 2401 bool get isBranching => true; | |
| 2402 | |
| 2403 String get format => 'I'; | |
| 2404 | |
| 2405 int get size => 5; | |
| 2406 | |
| 2407 int get stackPointerDifference => -1; | |
| 2408 | |
| 2409 String get formatString => 'branch if false +%d'; | |
| 2410 | |
| 2411 void addTo(Sink<List<int>> sink) { | |
| 2412 new BytecodeBuffer() | |
| 2413 ..addUint8(opcode.index) | |
| 2414 ..addUint32(uint32Argument0) | |
| 2415 ..sendOn(sink); | |
| 2416 } | |
| 2417 | |
| 2418 String toString() => 'branch if false +${uint32Argument0}'; | |
| 2419 | |
| 2420 operator==(Bytecode other) { | |
| 2421 if (!(super==(other))) return false; | |
| 2422 BranchIfFalseWide rhs = other; | |
| 2423 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 2424 return true; | |
| 2425 } | |
| 2426 | |
| 2427 int get hashCode { | |
| 2428 int value = super.hashCode; | |
| 2429 value += uint32Argument0; | |
| 2430 return value; | |
| 2431 } | |
| 2432 } | |
| 2433 | |
| 2434 class BranchBack extends Bytecode { | |
| 2435 final int uint8Argument0; | |
| 2436 const BranchBack(this.uint8Argument0) | |
| 2437 : super(); | |
| 2438 | |
| 2439 Opcode get opcode => Opcode.BranchBack; | |
| 2440 | |
| 2441 String get name => 'BranchBack'; | |
| 2442 | |
| 2443 bool get isBranching => true; | |
| 2444 | |
| 2445 String get format => 'B'; | |
| 2446 | |
| 2447 int get size => 2; | |
| 2448 | |
| 2449 int get stackPointerDifference => 0; | |
| 2450 | |
| 2451 String get formatString => 'branch -%d'; | |
| 2452 | |
| 2453 void addTo(Sink<List<int>> sink) { | |
| 2454 new BytecodeBuffer() | |
| 2455 ..addUint8(opcode.index) | |
| 2456 ..addUint8(uint8Argument0) | |
| 2457 ..sendOn(sink); | |
| 2458 } | |
| 2459 | |
| 2460 String toString() => 'branch -${uint8Argument0}'; | |
| 2461 | |
| 2462 operator==(Bytecode other) { | |
| 2463 if (!(super==(other))) return false; | |
| 2464 BranchBack rhs = other; | |
| 2465 if (uint8Argument0 != rhs.uint8Argument0) return false; | |
| 2466 return true; | |
| 2467 } | |
| 2468 | |
| 2469 int get hashCode { | |
| 2470 int value = super.hashCode; | |
| 2471 value += uint8Argument0; | |
| 2472 return value; | |
| 2473 } | |
| 2474 } | |
| 2475 | |
| 2476 class BranchBackIfTrue extends Bytecode { | |
| 2477 final int uint8Argument0; | |
| 2478 const BranchBackIfTrue(this.uint8Argument0) | |
| 2479 : super(); | |
| 2480 | |
| 2481 Opcode get opcode => Opcode.BranchBackIfTrue; | |
| 2482 | |
| 2483 String get name => 'BranchBackIfTrue'; | |
| 2484 | |
| 2485 bool get isBranching => true; | |
| 2486 | |
| 2487 String get format => 'B'; | |
| 2488 | |
| 2489 int get size => 2; | |
| 2490 | |
| 2491 int get stackPointerDifference => -1; | |
| 2492 | |
| 2493 String get formatString => 'branch if true -%d'; | |
| 2494 | |
| 2495 void addTo(Sink<List<int>> sink) { | |
| 2496 new BytecodeBuffer() | |
| 2497 ..addUint8(opcode.index) | |
| 2498 ..addUint8(uint8Argument0) | |
| 2499 ..sendOn(sink); | |
| 2500 } | |
| 2501 | |
| 2502 String toString() => 'branch if true -${uint8Argument0}'; | |
| 2503 | |
| 2504 operator==(Bytecode other) { | |
| 2505 if (!(super==(other))) return false; | |
| 2506 BranchBackIfTrue rhs = other; | |
| 2507 if (uint8Argument0 != rhs.uint8Argument0) return false; | |
| 2508 return true; | |
| 2509 } | |
| 2510 | |
| 2511 int get hashCode { | |
| 2512 int value = super.hashCode; | |
| 2513 value += uint8Argument0; | |
| 2514 return value; | |
| 2515 } | |
| 2516 } | |
| 2517 | |
| 2518 class BranchBackIfFalse extends Bytecode { | |
| 2519 final int uint8Argument0; | |
| 2520 const BranchBackIfFalse(this.uint8Argument0) | |
| 2521 : super(); | |
| 2522 | |
| 2523 Opcode get opcode => Opcode.BranchBackIfFalse; | |
| 2524 | |
| 2525 String get name => 'BranchBackIfFalse'; | |
| 2526 | |
| 2527 bool get isBranching => true; | |
| 2528 | |
| 2529 String get format => 'B'; | |
| 2530 | |
| 2531 int get size => 2; | |
| 2532 | |
| 2533 int get stackPointerDifference => -1; | |
| 2534 | |
| 2535 String get formatString => 'branch if false -%d'; | |
| 2536 | |
| 2537 void addTo(Sink<List<int>> sink) { | |
| 2538 new BytecodeBuffer() | |
| 2539 ..addUint8(opcode.index) | |
| 2540 ..addUint8(uint8Argument0) | |
| 2541 ..sendOn(sink); | |
| 2542 } | |
| 2543 | |
| 2544 String toString() => 'branch if false -${uint8Argument0}'; | |
| 2545 | |
| 2546 operator==(Bytecode other) { | |
| 2547 if (!(super==(other))) return false; | |
| 2548 BranchBackIfFalse rhs = other; | |
| 2549 if (uint8Argument0 != rhs.uint8Argument0) return false; | |
| 2550 return true; | |
| 2551 } | |
| 2552 | |
| 2553 int get hashCode { | |
| 2554 int value = super.hashCode; | |
| 2555 value += uint8Argument0; | |
| 2556 return value; | |
| 2557 } | |
| 2558 } | |
| 2559 | |
| 2560 class BranchBackWide extends Bytecode { | |
| 2561 final int uint32Argument0; | |
| 2562 const BranchBackWide(this.uint32Argument0) | |
| 2563 : super(); | |
| 2564 | |
| 2565 Opcode get opcode => Opcode.BranchBackWide; | |
| 2566 | |
| 2567 String get name => 'BranchBackWide'; | |
| 2568 | |
| 2569 bool get isBranching => true; | |
| 2570 | |
| 2571 String get format => 'I'; | |
| 2572 | |
| 2573 int get size => 5; | |
| 2574 | |
| 2575 int get stackPointerDifference => 0; | |
| 2576 | |
| 2577 String get formatString => 'branch -%d'; | |
| 2578 | |
| 2579 void addTo(Sink<List<int>> sink) { | |
| 2580 new BytecodeBuffer() | |
| 2581 ..addUint8(opcode.index) | |
| 2582 ..addUint32(uint32Argument0) | |
| 2583 ..sendOn(sink); | |
| 2584 } | |
| 2585 | |
| 2586 String toString() => 'branch -${uint32Argument0}'; | |
| 2587 | |
| 2588 operator==(Bytecode other) { | |
| 2589 if (!(super==(other))) return false; | |
| 2590 BranchBackWide rhs = other; | |
| 2591 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 2592 return true; | |
| 2593 } | |
| 2594 | |
| 2595 int get hashCode { | |
| 2596 int value = super.hashCode; | |
| 2597 value += uint32Argument0; | |
| 2598 return value; | |
| 2599 } | |
| 2600 } | |
| 2601 | |
| 2602 class BranchBackIfTrueWide extends Bytecode { | |
| 2603 final int uint32Argument0; | |
| 2604 const BranchBackIfTrueWide(this.uint32Argument0) | |
| 2605 : super(); | |
| 2606 | |
| 2607 Opcode get opcode => Opcode.BranchBackIfTrueWide; | |
| 2608 | |
| 2609 String get name => 'BranchBackIfTrueWide'; | |
| 2610 | |
| 2611 bool get isBranching => true; | |
| 2612 | |
| 2613 String get format => 'I'; | |
| 2614 | |
| 2615 int get size => 5; | |
| 2616 | |
| 2617 int get stackPointerDifference => -1; | |
| 2618 | |
| 2619 String get formatString => 'branch if true -%d'; | |
| 2620 | |
| 2621 void addTo(Sink<List<int>> sink) { | |
| 2622 new BytecodeBuffer() | |
| 2623 ..addUint8(opcode.index) | |
| 2624 ..addUint32(uint32Argument0) | |
| 2625 ..sendOn(sink); | |
| 2626 } | |
| 2627 | |
| 2628 String toString() => 'branch if true -${uint32Argument0}'; | |
| 2629 | |
| 2630 operator==(Bytecode other) { | |
| 2631 if (!(super==(other))) return false; | |
| 2632 BranchBackIfTrueWide rhs = other; | |
| 2633 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 2634 return true; | |
| 2635 } | |
| 2636 | |
| 2637 int get hashCode { | |
| 2638 int value = super.hashCode; | |
| 2639 value += uint32Argument0; | |
| 2640 return value; | |
| 2641 } | |
| 2642 } | |
| 2643 | |
| 2644 class BranchBackIfFalseWide extends Bytecode { | |
| 2645 final int uint32Argument0; | |
| 2646 const BranchBackIfFalseWide(this.uint32Argument0) | |
| 2647 : super(); | |
| 2648 | |
| 2649 Opcode get opcode => Opcode.BranchBackIfFalseWide; | |
| 2650 | |
| 2651 String get name => 'BranchBackIfFalseWide'; | |
| 2652 | |
| 2653 bool get isBranching => true; | |
| 2654 | |
| 2655 String get format => 'I'; | |
| 2656 | |
| 2657 int get size => 5; | |
| 2658 | |
| 2659 int get stackPointerDifference => -1; | |
| 2660 | |
| 2661 String get formatString => 'branch if false -%d'; | |
| 2662 | |
| 2663 void addTo(Sink<List<int>> sink) { | |
| 2664 new BytecodeBuffer() | |
| 2665 ..addUint8(opcode.index) | |
| 2666 ..addUint32(uint32Argument0) | |
| 2667 ..sendOn(sink); | |
| 2668 } | |
| 2669 | |
| 2670 String toString() => 'branch if false -${uint32Argument0}'; | |
| 2671 | |
| 2672 operator==(Bytecode other) { | |
| 2673 if (!(super==(other))) return false; | |
| 2674 BranchBackIfFalseWide rhs = other; | |
| 2675 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 2676 return true; | |
| 2677 } | |
| 2678 | |
| 2679 int get hashCode { | |
| 2680 int value = super.hashCode; | |
| 2681 value += uint32Argument0; | |
| 2682 return value; | |
| 2683 } | |
| 2684 } | |
| 2685 | |
| 2686 class PopAndBranchWide extends Bytecode { | |
| 2687 final int uint8Argument0; | |
| 2688 final int uint32Argument1; | |
| 2689 const PopAndBranchWide(this.uint8Argument0, this.uint32Argument1) | |
| 2690 : super(); | |
| 2691 | |
| 2692 Opcode get opcode => Opcode.PopAndBranchWide; | |
| 2693 | |
| 2694 String get name => 'PopAndBranchWide'; | |
| 2695 | |
| 2696 bool get isBranching => true; | |
| 2697 | |
| 2698 String get format => 'BI'; | |
| 2699 | |
| 2700 int get size => 6; | |
| 2701 | |
| 2702 int get stackPointerDifference => 0; | |
| 2703 | |
| 2704 String get formatString => 'pop %d and branch +%d'; | |
| 2705 | |
| 2706 void addTo(Sink<List<int>> sink) { | |
| 2707 new BytecodeBuffer() | |
| 2708 ..addUint8(opcode.index) | |
| 2709 ..addUint8(uint8Argument0) | |
| 2710 ..addUint32(uint32Argument1) | |
| 2711 ..sendOn(sink); | |
| 2712 } | |
| 2713 | |
| 2714 String toString() => 'pop ${uint8Argument0} and branch +${uint32Argument1}'; | |
| 2715 | |
| 2716 operator==(Bytecode other) { | |
| 2717 if (!(super==(other))) return false; | |
| 2718 PopAndBranchWide rhs = other; | |
| 2719 if (uint8Argument0 != rhs.uint8Argument0) return false; | |
| 2720 if (uint32Argument1 != rhs.uint32Argument1) return false; | |
| 2721 return true; | |
| 2722 } | |
| 2723 | |
| 2724 int get hashCode { | |
| 2725 int value = super.hashCode; | |
| 2726 value += uint8Argument0; | |
| 2727 value += uint32Argument1; | |
| 2728 return value; | |
| 2729 } | |
| 2730 } | |
| 2731 | |
| 2732 class PopAndBranchBackWide extends Bytecode { | |
| 2733 final int uint8Argument0; | |
| 2734 final int uint32Argument1; | |
| 2735 const PopAndBranchBackWide(this.uint8Argument0, this.uint32Argument1) | |
| 2736 : super(); | |
| 2737 | |
| 2738 Opcode get opcode => Opcode.PopAndBranchBackWide; | |
| 2739 | |
| 2740 String get name => 'PopAndBranchBackWide'; | |
| 2741 | |
| 2742 bool get isBranching => true; | |
| 2743 | |
| 2744 String get format => 'BI'; | |
| 2745 | |
| 2746 int get size => 6; | |
| 2747 | |
| 2748 int get stackPointerDifference => 0; | |
| 2749 | |
| 2750 String get formatString => 'pop %d and branch -%d'; | |
| 2751 | |
| 2752 void addTo(Sink<List<int>> sink) { | |
| 2753 new BytecodeBuffer() | |
| 2754 ..addUint8(opcode.index) | |
| 2755 ..addUint8(uint8Argument0) | |
| 2756 ..addUint32(uint32Argument1) | |
| 2757 ..sendOn(sink); | |
| 2758 } | |
| 2759 | |
| 2760 String toString() => 'pop ${uint8Argument0} and branch -${uint32Argument1}'; | |
| 2761 | |
| 2762 operator==(Bytecode other) { | |
| 2763 if (!(super==(other))) return false; | |
| 2764 PopAndBranchBackWide rhs = other; | |
| 2765 if (uint8Argument0 != rhs.uint8Argument0) return false; | |
| 2766 if (uint32Argument1 != rhs.uint32Argument1) return false; | |
| 2767 return true; | |
| 2768 } | |
| 2769 | |
| 2770 int get hashCode { | |
| 2771 int value = super.hashCode; | |
| 2772 value += uint8Argument0; | |
| 2773 value += uint32Argument1; | |
| 2774 return value; | |
| 2775 } | |
| 2776 } | |
| 2777 | |
| 2778 class AllocateBoxed extends Bytecode { | |
| 2779 const AllocateBoxed() | |
| 2780 : super(); | |
| 2781 | |
| 2782 Opcode get opcode => Opcode.AllocateBoxed; | |
| 2783 | |
| 2784 String get name => 'AllocateBoxed'; | |
| 2785 | |
| 2786 bool get isBranching => false; | |
| 2787 | |
| 2788 String get format => ''; | |
| 2789 | |
| 2790 int get size => 1; | |
| 2791 | |
| 2792 int get stackPointerDifference => 0; | |
| 2793 | |
| 2794 String get formatString => 'allocate boxed'; | |
| 2795 | |
| 2796 void addTo(Sink<List<int>> sink) { | |
| 2797 new BytecodeBuffer() | |
| 2798 ..addUint8(opcode.index) | |
| 2799 ..sendOn(sink); | |
| 2800 } | |
| 2801 | |
| 2802 String toString() => 'allocate boxed'; | |
| 2803 } | |
| 2804 | |
| 2805 class Negate extends Bytecode { | |
| 2806 const Negate() | |
| 2807 : super(); | |
| 2808 | |
| 2809 Opcode get opcode => Opcode.Negate; | |
| 2810 | |
| 2811 String get name => 'Negate'; | |
| 2812 | |
| 2813 bool get isBranching => false; | |
| 2814 | |
| 2815 String get format => ''; | |
| 2816 | |
| 2817 int get size => 1; | |
| 2818 | |
| 2819 int get stackPointerDifference => 0; | |
| 2820 | |
| 2821 String get formatString => 'negate'; | |
| 2822 | |
| 2823 void addTo(Sink<List<int>> sink) { | |
| 2824 new BytecodeBuffer() | |
| 2825 ..addUint8(opcode.index) | |
| 2826 ..sendOn(sink); | |
| 2827 } | |
| 2828 | |
| 2829 String toString() => 'negate'; | |
| 2830 } | |
| 2831 | |
| 2832 class StackOverflowCheck extends Bytecode { | |
| 2833 final int uint32Argument0; | |
| 2834 const StackOverflowCheck(this.uint32Argument0) | |
| 2835 : super(); | |
| 2836 | |
| 2837 Opcode get opcode => Opcode.StackOverflowCheck; | |
| 2838 | |
| 2839 String get name => 'StackOverflowCheck'; | |
| 2840 | |
| 2841 bool get isBranching => true; | |
| 2842 | |
| 2843 String get format => 'I'; | |
| 2844 | |
| 2845 int get size => 5; | |
| 2846 | |
| 2847 int get stackPointerDifference => 0; | |
| 2848 | |
| 2849 String get formatString => 'stack overflow check %d'; | |
| 2850 | |
| 2851 void addTo(Sink<List<int>> sink) { | |
| 2852 new BytecodeBuffer() | |
| 2853 ..addUint8(opcode.index) | |
| 2854 ..addUint32(uint32Argument0) | |
| 2855 ..sendOn(sink); | |
| 2856 } | |
| 2857 | |
| 2858 String toString() => 'stack overflow check ${uint32Argument0}'; | |
| 2859 | |
| 2860 operator==(Bytecode other) { | |
| 2861 if (!(super==(other))) return false; | |
| 2862 StackOverflowCheck rhs = other; | |
| 2863 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 2864 return true; | |
| 2865 } | |
| 2866 | |
| 2867 int get hashCode { | |
| 2868 int value = super.hashCode; | |
| 2869 value += uint32Argument0; | |
| 2870 return value; | |
| 2871 } | |
| 2872 } | |
| 2873 | |
| 2874 class Throw extends Bytecode { | |
| 2875 const Throw() | |
| 2876 : super(); | |
| 2877 | |
| 2878 Opcode get opcode => Opcode.Throw; | |
| 2879 | |
| 2880 String get name => 'Throw'; | |
| 2881 | |
| 2882 bool get isBranching => true; | |
| 2883 | |
| 2884 String get format => ''; | |
| 2885 | |
| 2886 int get size => 1; | |
| 2887 | |
| 2888 int get stackPointerDifference => 0; | |
| 2889 | |
| 2890 String get formatString => 'throw'; | |
| 2891 | |
| 2892 void addTo(Sink<List<int>> sink) { | |
| 2893 new BytecodeBuffer() | |
| 2894 ..addUint8(opcode.index) | |
| 2895 ..sendOn(sink); | |
| 2896 } | |
| 2897 | |
| 2898 String toString() => 'throw'; | |
| 2899 } | |
| 2900 | |
| 2901 class SubroutineCall extends Bytecode { | |
| 2902 final int uint32Argument0; | |
| 2903 final int uint32Argument1; | |
| 2904 const SubroutineCall(this.uint32Argument0, this.uint32Argument1) | |
| 2905 : super(); | |
| 2906 | |
| 2907 Opcode get opcode => Opcode.SubroutineCall; | |
| 2908 | |
| 2909 String get name => 'SubroutineCall'; | |
| 2910 | |
| 2911 bool get isBranching => true; | |
| 2912 | |
| 2913 String get format => 'II'; | |
| 2914 | |
| 2915 int get size => 9; | |
| 2916 | |
| 2917 int get stackPointerDifference => VAR_DIFF; | |
| 2918 | |
| 2919 String get formatString => 'subroutine call +%d -%d'; | |
| 2920 | |
| 2921 void addTo(Sink<List<int>> sink) { | |
| 2922 new BytecodeBuffer() | |
| 2923 ..addUint8(opcode.index) | |
| 2924 ..addUint32(uint32Argument0) | |
| 2925 ..addUint32(uint32Argument1) | |
| 2926 ..sendOn(sink); | |
| 2927 } | |
| 2928 | |
| 2929 String toString() => 'subroutine call +${uint32Argument0} -${uint32Argument1}'
; | |
| 2930 | |
| 2931 operator==(Bytecode other) { | |
| 2932 if (!(super==(other))) return false; | |
| 2933 SubroutineCall rhs = other; | |
| 2934 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 2935 if (uint32Argument1 != rhs.uint32Argument1) return false; | |
| 2936 return true; | |
| 2937 } | |
| 2938 | |
| 2939 int get hashCode { | |
| 2940 int value = super.hashCode; | |
| 2941 value += uint32Argument0; | |
| 2942 value += uint32Argument1; | |
| 2943 return value; | |
| 2944 } | |
| 2945 } | |
| 2946 | |
| 2947 class SubroutineReturn extends Bytecode { | |
| 2948 const SubroutineReturn() | |
| 2949 : super(); | |
| 2950 | |
| 2951 Opcode get opcode => Opcode.SubroutineReturn; | |
| 2952 | |
| 2953 String get name => 'SubroutineReturn'; | |
| 2954 | |
| 2955 bool get isBranching => true; | |
| 2956 | |
| 2957 String get format => ''; | |
| 2958 | |
| 2959 int get size => 1; | |
| 2960 | |
| 2961 int get stackPointerDifference => -1; | |
| 2962 | |
| 2963 String get formatString => 'subroutine return'; | |
| 2964 | |
| 2965 void addTo(Sink<List<int>> sink) { | |
| 2966 new BytecodeBuffer() | |
| 2967 ..addUint8(opcode.index) | |
| 2968 ..sendOn(sink); | |
| 2969 } | |
| 2970 | |
| 2971 String toString() => 'subroutine return'; | |
| 2972 } | |
| 2973 | |
| 2974 class ProcessYield extends Bytecode { | |
| 2975 const ProcessYield() | |
| 2976 : super(); | |
| 2977 | |
| 2978 Opcode get opcode => Opcode.ProcessYield; | |
| 2979 | |
| 2980 String get name => 'ProcessYield'; | |
| 2981 | |
| 2982 bool get isBranching => true; | |
| 2983 | |
| 2984 String get format => ''; | |
| 2985 | |
| 2986 int get size => 1; | |
| 2987 | |
| 2988 int get stackPointerDifference => 0; | |
| 2989 | |
| 2990 String get formatString => 'process yield'; | |
| 2991 | |
| 2992 void addTo(Sink<List<int>> sink) { | |
| 2993 new BytecodeBuffer() | |
| 2994 ..addUint8(opcode.index) | |
| 2995 ..sendOn(sink); | |
| 2996 } | |
| 2997 | |
| 2998 String toString() => 'process yield'; | |
| 2999 } | |
| 3000 | |
| 3001 class CoroutineChange extends Bytecode { | |
| 3002 const CoroutineChange() | |
| 3003 : super(); | |
| 3004 | |
| 3005 Opcode get opcode => Opcode.CoroutineChange; | |
| 3006 | |
| 3007 String get name => 'CoroutineChange'; | |
| 3008 | |
| 3009 bool get isBranching => true; | |
| 3010 | |
| 3011 String get format => ''; | |
| 3012 | |
| 3013 int get size => 1; | |
| 3014 | |
| 3015 int get stackPointerDifference => -1; | |
| 3016 | |
| 3017 String get formatString => 'coroutine change'; | |
| 3018 | |
| 3019 void addTo(Sink<List<int>> sink) { | |
| 3020 new BytecodeBuffer() | |
| 3021 ..addUint8(opcode.index) | |
| 3022 ..sendOn(sink); | |
| 3023 } | |
| 3024 | |
| 3025 String toString() => 'coroutine change'; | |
| 3026 } | |
| 3027 | |
| 3028 class Identical extends Bytecode { | |
| 3029 const Identical() | |
| 3030 : super(); | |
| 3031 | |
| 3032 Opcode get opcode => Opcode.Identical; | |
| 3033 | |
| 3034 String get name => 'Identical'; | |
| 3035 | |
| 3036 bool get isBranching => true; | |
| 3037 | |
| 3038 String get format => ''; | |
| 3039 | |
| 3040 int get size => 1; | |
| 3041 | |
| 3042 int get stackPointerDifference => -1; | |
| 3043 | |
| 3044 String get formatString => 'identical'; | |
| 3045 | |
| 3046 void addTo(Sink<List<int>> sink) { | |
| 3047 new BytecodeBuffer() | |
| 3048 ..addUint8(opcode.index) | |
| 3049 ..sendOn(sink); | |
| 3050 } | |
| 3051 | |
| 3052 String toString() => 'identical'; | |
| 3053 } | |
| 3054 | |
| 3055 class IdenticalNonNumeric extends Bytecode { | |
| 3056 const IdenticalNonNumeric() | |
| 3057 : super(); | |
| 3058 | |
| 3059 Opcode get opcode => Opcode.IdenticalNonNumeric; | |
| 3060 | |
| 3061 String get name => 'IdenticalNonNumeric'; | |
| 3062 | |
| 3063 bool get isBranching => true; | |
| 3064 | |
| 3065 String get format => ''; | |
| 3066 | |
| 3067 int get size => 1; | |
| 3068 | |
| 3069 int get stackPointerDifference => -1; | |
| 3070 | |
| 3071 String get formatString => 'identical non numeric'; | |
| 3072 | |
| 3073 void addTo(Sink<List<int>> sink) { | |
| 3074 new BytecodeBuffer() | |
| 3075 ..addUint8(opcode.index) | |
| 3076 ..sendOn(sink); | |
| 3077 } | |
| 3078 | |
| 3079 String toString() => 'identical non numeric'; | |
| 3080 } | |
| 3081 | |
| 3082 class EnterNoSuchMethod extends Bytecode { | |
| 3083 final int uint8Argument0; | |
| 3084 const EnterNoSuchMethod(this.uint8Argument0) | |
| 3085 : super(); | |
| 3086 | |
| 3087 Opcode get opcode => Opcode.EnterNoSuchMethod; | |
| 3088 | |
| 3089 String get name => 'EnterNoSuchMethod'; | |
| 3090 | |
| 3091 bool get isBranching => true; | |
| 3092 | |
| 3093 String get format => 'B'; | |
| 3094 | |
| 3095 int get size => 2; | |
| 3096 | |
| 3097 int get stackPointerDifference => VAR_DIFF; | |
| 3098 | |
| 3099 String get formatString => 'enter noSuchMethod +%d'; | |
| 3100 | |
| 3101 void addTo(Sink<List<int>> sink) { | |
| 3102 new BytecodeBuffer() | |
| 3103 ..addUint8(opcode.index) | |
| 3104 ..addUint8(uint8Argument0) | |
| 3105 ..sendOn(sink); | |
| 3106 } | |
| 3107 | |
| 3108 String toString() => 'enter noSuchMethod +${uint8Argument0}'; | |
| 3109 | |
| 3110 operator==(Bytecode other) { | |
| 3111 if (!(super==(other))) return false; | |
| 3112 EnterNoSuchMethod rhs = other; | |
| 3113 if (uint8Argument0 != rhs.uint8Argument0) return false; | |
| 3114 return true; | |
| 3115 } | |
| 3116 | |
| 3117 int get hashCode { | |
| 3118 int value = super.hashCode; | |
| 3119 value += uint8Argument0; | |
| 3120 return value; | |
| 3121 } | |
| 3122 } | |
| 3123 | |
| 3124 class ExitNoSuchMethod extends Bytecode { | |
| 3125 const ExitNoSuchMethod() | |
| 3126 : super(); | |
| 3127 | |
| 3128 Opcode get opcode => Opcode.ExitNoSuchMethod; | |
| 3129 | |
| 3130 String get name => 'ExitNoSuchMethod'; | |
| 3131 | |
| 3132 bool get isBranching => true; | |
| 3133 | |
| 3134 String get format => ''; | |
| 3135 | |
| 3136 int get size => 1; | |
| 3137 | |
| 3138 int get stackPointerDifference => -1; | |
| 3139 | |
| 3140 String get formatString => 'exit noSuchMethod'; | |
| 3141 | |
| 3142 void addTo(Sink<List<int>> sink) { | |
| 3143 new BytecodeBuffer() | |
| 3144 ..addUint8(opcode.index) | |
| 3145 ..sendOn(sink); | |
| 3146 } | |
| 3147 | |
| 3148 String toString() => 'exit noSuchMethod'; | |
| 3149 } | |
| 3150 | |
| 3151 class InvokeMethodUnfold extends Bytecode { | |
| 3152 final int uint32Argument0; | |
| 3153 const InvokeMethodUnfold(this.uint32Argument0) | |
| 3154 : super(); | |
| 3155 | |
| 3156 Opcode get opcode => Opcode.InvokeMethodUnfold; | |
| 3157 | |
| 3158 String get name => 'InvokeMethodUnfold'; | |
| 3159 | |
| 3160 bool get isBranching => true; | |
| 3161 | |
| 3162 String get format => 'I'; | |
| 3163 | |
| 3164 int get size => 5; | |
| 3165 | |
| 3166 int get stackPointerDifference => VAR_DIFF; | |
| 3167 | |
| 3168 String get formatString => 'invoke unfold method %d'; | |
| 3169 | |
| 3170 void addTo(Sink<List<int>> sink) { | |
| 3171 new BytecodeBuffer() | |
| 3172 ..addUint8(opcode.index) | |
| 3173 ..addUint32(uint32Argument0) | |
| 3174 ..sendOn(sink); | |
| 3175 } | |
| 3176 | |
| 3177 String toString() => 'invoke unfold method ${uint32Argument0}'; | |
| 3178 | |
| 3179 operator==(Bytecode other) { | |
| 3180 if (!(super==(other))) return false; | |
| 3181 InvokeMethodUnfold rhs = other; | |
| 3182 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3183 return true; | |
| 3184 } | |
| 3185 | |
| 3186 int get hashCode { | |
| 3187 int value = super.hashCode; | |
| 3188 value += uint32Argument0; | |
| 3189 return value; | |
| 3190 } | |
| 3191 } | |
| 3192 | |
| 3193 class InvokeTestUnfold extends Bytecode { | |
| 3194 final int uint32Argument0; | |
| 3195 const InvokeTestUnfold(this.uint32Argument0) | |
| 3196 : super(); | |
| 3197 | |
| 3198 Opcode get opcode => Opcode.InvokeTestUnfold; | |
| 3199 | |
| 3200 String get name => 'InvokeTestUnfold'; | |
| 3201 | |
| 3202 bool get isBranching => true; | |
| 3203 | |
| 3204 String get format => 'I'; | |
| 3205 | |
| 3206 int get size => 5; | |
| 3207 | |
| 3208 int get stackPointerDifference => 0; | |
| 3209 | |
| 3210 String get formatString => 'invoke unfold test %d'; | |
| 3211 | |
| 3212 void addTo(Sink<List<int>> sink) { | |
| 3213 new BytecodeBuffer() | |
| 3214 ..addUint8(opcode.index) | |
| 3215 ..addUint32(uint32Argument0) | |
| 3216 ..sendOn(sink); | |
| 3217 } | |
| 3218 | |
| 3219 String toString() => 'invoke unfold test ${uint32Argument0}'; | |
| 3220 | |
| 3221 operator==(Bytecode other) { | |
| 3222 if (!(super==(other))) return false; | |
| 3223 InvokeTestUnfold rhs = other; | |
| 3224 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3225 return true; | |
| 3226 } | |
| 3227 | |
| 3228 int get hashCode { | |
| 3229 int value = super.hashCode; | |
| 3230 value += uint32Argument0; | |
| 3231 return value; | |
| 3232 } | |
| 3233 } | |
| 3234 | |
| 3235 class InvokeEqUnfold extends Bytecode { | |
| 3236 final int uint32Argument0; | |
| 3237 const InvokeEqUnfold(this.uint32Argument0) | |
| 3238 : super(); | |
| 3239 | |
| 3240 Opcode get opcode => Opcode.InvokeEqUnfold; | |
| 3241 | |
| 3242 String get name => 'InvokeEqUnfold'; | |
| 3243 | |
| 3244 bool get isBranching => true; | |
| 3245 | |
| 3246 String get format => 'I'; | |
| 3247 | |
| 3248 int get size => 5; | |
| 3249 | |
| 3250 int get stackPointerDifference => -1; | |
| 3251 | |
| 3252 String get formatString => 'invoke unfold eq %d'; | |
| 3253 | |
| 3254 void addTo(Sink<List<int>> sink) { | |
| 3255 new BytecodeBuffer() | |
| 3256 ..addUint8(opcode.index) | |
| 3257 ..addUint32(uint32Argument0) | |
| 3258 ..sendOn(sink); | |
| 3259 } | |
| 3260 | |
| 3261 String toString() => 'invoke unfold eq ${uint32Argument0}'; | |
| 3262 | |
| 3263 operator==(Bytecode other) { | |
| 3264 if (!(super==(other))) return false; | |
| 3265 InvokeEqUnfold rhs = other; | |
| 3266 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3267 return true; | |
| 3268 } | |
| 3269 | |
| 3270 int get hashCode { | |
| 3271 int value = super.hashCode; | |
| 3272 value += uint32Argument0; | |
| 3273 return value; | |
| 3274 } | |
| 3275 } | |
| 3276 | |
| 3277 class InvokeLtUnfold extends Bytecode { | |
| 3278 final int uint32Argument0; | |
| 3279 const InvokeLtUnfold(this.uint32Argument0) | |
| 3280 : super(); | |
| 3281 | |
| 3282 Opcode get opcode => Opcode.InvokeLtUnfold; | |
| 3283 | |
| 3284 String get name => 'InvokeLtUnfold'; | |
| 3285 | |
| 3286 bool get isBranching => true; | |
| 3287 | |
| 3288 String get format => 'I'; | |
| 3289 | |
| 3290 int get size => 5; | |
| 3291 | |
| 3292 int get stackPointerDifference => -1; | |
| 3293 | |
| 3294 String get formatString => 'invoke unfold lt %d'; | |
| 3295 | |
| 3296 void addTo(Sink<List<int>> sink) { | |
| 3297 new BytecodeBuffer() | |
| 3298 ..addUint8(opcode.index) | |
| 3299 ..addUint32(uint32Argument0) | |
| 3300 ..sendOn(sink); | |
| 3301 } | |
| 3302 | |
| 3303 String toString() => 'invoke unfold lt ${uint32Argument0}'; | |
| 3304 | |
| 3305 operator==(Bytecode other) { | |
| 3306 if (!(super==(other))) return false; | |
| 3307 InvokeLtUnfold rhs = other; | |
| 3308 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3309 return true; | |
| 3310 } | |
| 3311 | |
| 3312 int get hashCode { | |
| 3313 int value = super.hashCode; | |
| 3314 value += uint32Argument0; | |
| 3315 return value; | |
| 3316 } | |
| 3317 } | |
| 3318 | |
| 3319 class InvokeLeUnfold extends Bytecode { | |
| 3320 final int uint32Argument0; | |
| 3321 const InvokeLeUnfold(this.uint32Argument0) | |
| 3322 : super(); | |
| 3323 | |
| 3324 Opcode get opcode => Opcode.InvokeLeUnfold; | |
| 3325 | |
| 3326 String get name => 'InvokeLeUnfold'; | |
| 3327 | |
| 3328 bool get isBranching => true; | |
| 3329 | |
| 3330 String get format => 'I'; | |
| 3331 | |
| 3332 int get size => 5; | |
| 3333 | |
| 3334 int get stackPointerDifference => -1; | |
| 3335 | |
| 3336 String get formatString => 'invoke unfold le %d'; | |
| 3337 | |
| 3338 void addTo(Sink<List<int>> sink) { | |
| 3339 new BytecodeBuffer() | |
| 3340 ..addUint8(opcode.index) | |
| 3341 ..addUint32(uint32Argument0) | |
| 3342 ..sendOn(sink); | |
| 3343 } | |
| 3344 | |
| 3345 String toString() => 'invoke unfold le ${uint32Argument0}'; | |
| 3346 | |
| 3347 operator==(Bytecode other) { | |
| 3348 if (!(super==(other))) return false; | |
| 3349 InvokeLeUnfold rhs = other; | |
| 3350 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3351 return true; | |
| 3352 } | |
| 3353 | |
| 3354 int get hashCode { | |
| 3355 int value = super.hashCode; | |
| 3356 value += uint32Argument0; | |
| 3357 return value; | |
| 3358 } | |
| 3359 } | |
| 3360 | |
| 3361 class InvokeGtUnfold extends Bytecode { | |
| 3362 final int uint32Argument0; | |
| 3363 const InvokeGtUnfold(this.uint32Argument0) | |
| 3364 : super(); | |
| 3365 | |
| 3366 Opcode get opcode => Opcode.InvokeGtUnfold; | |
| 3367 | |
| 3368 String get name => 'InvokeGtUnfold'; | |
| 3369 | |
| 3370 bool get isBranching => true; | |
| 3371 | |
| 3372 String get format => 'I'; | |
| 3373 | |
| 3374 int get size => 5; | |
| 3375 | |
| 3376 int get stackPointerDifference => -1; | |
| 3377 | |
| 3378 String get formatString => 'invoke unfold gt %d'; | |
| 3379 | |
| 3380 void addTo(Sink<List<int>> sink) { | |
| 3381 new BytecodeBuffer() | |
| 3382 ..addUint8(opcode.index) | |
| 3383 ..addUint32(uint32Argument0) | |
| 3384 ..sendOn(sink); | |
| 3385 } | |
| 3386 | |
| 3387 String toString() => 'invoke unfold gt ${uint32Argument0}'; | |
| 3388 | |
| 3389 operator==(Bytecode other) { | |
| 3390 if (!(super==(other))) return false; | |
| 3391 InvokeGtUnfold rhs = other; | |
| 3392 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3393 return true; | |
| 3394 } | |
| 3395 | |
| 3396 int get hashCode { | |
| 3397 int value = super.hashCode; | |
| 3398 value += uint32Argument0; | |
| 3399 return value; | |
| 3400 } | |
| 3401 } | |
| 3402 | |
| 3403 class InvokeGeUnfold extends Bytecode { | |
| 3404 final int uint32Argument0; | |
| 3405 const InvokeGeUnfold(this.uint32Argument0) | |
| 3406 : super(); | |
| 3407 | |
| 3408 Opcode get opcode => Opcode.InvokeGeUnfold; | |
| 3409 | |
| 3410 String get name => 'InvokeGeUnfold'; | |
| 3411 | |
| 3412 bool get isBranching => true; | |
| 3413 | |
| 3414 String get format => 'I'; | |
| 3415 | |
| 3416 int get size => 5; | |
| 3417 | |
| 3418 int get stackPointerDifference => -1; | |
| 3419 | |
| 3420 String get formatString => 'invoke unfold ge %d'; | |
| 3421 | |
| 3422 void addTo(Sink<List<int>> sink) { | |
| 3423 new BytecodeBuffer() | |
| 3424 ..addUint8(opcode.index) | |
| 3425 ..addUint32(uint32Argument0) | |
| 3426 ..sendOn(sink); | |
| 3427 } | |
| 3428 | |
| 3429 String toString() => 'invoke unfold ge ${uint32Argument0}'; | |
| 3430 | |
| 3431 operator==(Bytecode other) { | |
| 3432 if (!(super==(other))) return false; | |
| 3433 InvokeGeUnfold rhs = other; | |
| 3434 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3435 return true; | |
| 3436 } | |
| 3437 | |
| 3438 int get hashCode { | |
| 3439 int value = super.hashCode; | |
| 3440 value += uint32Argument0; | |
| 3441 return value; | |
| 3442 } | |
| 3443 } | |
| 3444 | |
| 3445 class InvokeAddUnfold extends Bytecode { | |
| 3446 final int uint32Argument0; | |
| 3447 const InvokeAddUnfold(this.uint32Argument0) | |
| 3448 : super(); | |
| 3449 | |
| 3450 Opcode get opcode => Opcode.InvokeAddUnfold; | |
| 3451 | |
| 3452 String get name => 'InvokeAddUnfold'; | |
| 3453 | |
| 3454 bool get isBranching => true; | |
| 3455 | |
| 3456 String get format => 'I'; | |
| 3457 | |
| 3458 int get size => 5; | |
| 3459 | |
| 3460 int get stackPointerDifference => -1; | |
| 3461 | |
| 3462 String get formatString => 'invoke unfold add %d'; | |
| 3463 | |
| 3464 void addTo(Sink<List<int>> sink) { | |
| 3465 new BytecodeBuffer() | |
| 3466 ..addUint8(opcode.index) | |
| 3467 ..addUint32(uint32Argument0) | |
| 3468 ..sendOn(sink); | |
| 3469 } | |
| 3470 | |
| 3471 String toString() => 'invoke unfold add ${uint32Argument0}'; | |
| 3472 | |
| 3473 operator==(Bytecode other) { | |
| 3474 if (!(super==(other))) return false; | |
| 3475 InvokeAddUnfold rhs = other; | |
| 3476 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3477 return true; | |
| 3478 } | |
| 3479 | |
| 3480 int get hashCode { | |
| 3481 int value = super.hashCode; | |
| 3482 value += uint32Argument0; | |
| 3483 return value; | |
| 3484 } | |
| 3485 } | |
| 3486 | |
| 3487 class InvokeSubUnfold extends Bytecode { | |
| 3488 final int uint32Argument0; | |
| 3489 const InvokeSubUnfold(this.uint32Argument0) | |
| 3490 : super(); | |
| 3491 | |
| 3492 Opcode get opcode => Opcode.InvokeSubUnfold; | |
| 3493 | |
| 3494 String get name => 'InvokeSubUnfold'; | |
| 3495 | |
| 3496 bool get isBranching => true; | |
| 3497 | |
| 3498 String get format => 'I'; | |
| 3499 | |
| 3500 int get size => 5; | |
| 3501 | |
| 3502 int get stackPointerDifference => -1; | |
| 3503 | |
| 3504 String get formatString => 'invoke unfold sub %d'; | |
| 3505 | |
| 3506 void addTo(Sink<List<int>> sink) { | |
| 3507 new BytecodeBuffer() | |
| 3508 ..addUint8(opcode.index) | |
| 3509 ..addUint32(uint32Argument0) | |
| 3510 ..sendOn(sink); | |
| 3511 } | |
| 3512 | |
| 3513 String toString() => 'invoke unfold sub ${uint32Argument0}'; | |
| 3514 | |
| 3515 operator==(Bytecode other) { | |
| 3516 if (!(super==(other))) return false; | |
| 3517 InvokeSubUnfold rhs = other; | |
| 3518 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3519 return true; | |
| 3520 } | |
| 3521 | |
| 3522 int get hashCode { | |
| 3523 int value = super.hashCode; | |
| 3524 value += uint32Argument0; | |
| 3525 return value; | |
| 3526 } | |
| 3527 } | |
| 3528 | |
| 3529 class InvokeModUnfold extends Bytecode { | |
| 3530 final int uint32Argument0; | |
| 3531 const InvokeModUnfold(this.uint32Argument0) | |
| 3532 : super(); | |
| 3533 | |
| 3534 Opcode get opcode => Opcode.InvokeModUnfold; | |
| 3535 | |
| 3536 String get name => 'InvokeModUnfold'; | |
| 3537 | |
| 3538 bool get isBranching => true; | |
| 3539 | |
| 3540 String get format => 'I'; | |
| 3541 | |
| 3542 int get size => 5; | |
| 3543 | |
| 3544 int get stackPointerDifference => -1; | |
| 3545 | |
| 3546 String get formatString => 'invoke unfold mod %d'; | |
| 3547 | |
| 3548 void addTo(Sink<List<int>> sink) { | |
| 3549 new BytecodeBuffer() | |
| 3550 ..addUint8(opcode.index) | |
| 3551 ..addUint32(uint32Argument0) | |
| 3552 ..sendOn(sink); | |
| 3553 } | |
| 3554 | |
| 3555 String toString() => 'invoke unfold mod ${uint32Argument0}'; | |
| 3556 | |
| 3557 operator==(Bytecode other) { | |
| 3558 if (!(super==(other))) return false; | |
| 3559 InvokeModUnfold rhs = other; | |
| 3560 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3561 return true; | |
| 3562 } | |
| 3563 | |
| 3564 int get hashCode { | |
| 3565 int value = super.hashCode; | |
| 3566 value += uint32Argument0; | |
| 3567 return value; | |
| 3568 } | |
| 3569 } | |
| 3570 | |
| 3571 class InvokeMulUnfold extends Bytecode { | |
| 3572 final int uint32Argument0; | |
| 3573 const InvokeMulUnfold(this.uint32Argument0) | |
| 3574 : super(); | |
| 3575 | |
| 3576 Opcode get opcode => Opcode.InvokeMulUnfold; | |
| 3577 | |
| 3578 String get name => 'InvokeMulUnfold'; | |
| 3579 | |
| 3580 bool get isBranching => true; | |
| 3581 | |
| 3582 String get format => 'I'; | |
| 3583 | |
| 3584 int get size => 5; | |
| 3585 | |
| 3586 int get stackPointerDifference => -1; | |
| 3587 | |
| 3588 String get formatString => 'invoke unfold mul %d'; | |
| 3589 | |
| 3590 void addTo(Sink<List<int>> sink) { | |
| 3591 new BytecodeBuffer() | |
| 3592 ..addUint8(opcode.index) | |
| 3593 ..addUint32(uint32Argument0) | |
| 3594 ..sendOn(sink); | |
| 3595 } | |
| 3596 | |
| 3597 String toString() => 'invoke unfold mul ${uint32Argument0}'; | |
| 3598 | |
| 3599 operator==(Bytecode other) { | |
| 3600 if (!(super==(other))) return false; | |
| 3601 InvokeMulUnfold rhs = other; | |
| 3602 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3603 return true; | |
| 3604 } | |
| 3605 | |
| 3606 int get hashCode { | |
| 3607 int value = super.hashCode; | |
| 3608 value += uint32Argument0; | |
| 3609 return value; | |
| 3610 } | |
| 3611 } | |
| 3612 | |
| 3613 class InvokeTruncDivUnfold extends Bytecode { | |
| 3614 final int uint32Argument0; | |
| 3615 const InvokeTruncDivUnfold(this.uint32Argument0) | |
| 3616 : super(); | |
| 3617 | |
| 3618 Opcode get opcode => Opcode.InvokeTruncDivUnfold; | |
| 3619 | |
| 3620 String get name => 'InvokeTruncDivUnfold'; | |
| 3621 | |
| 3622 bool get isBranching => true; | |
| 3623 | |
| 3624 String get format => 'I'; | |
| 3625 | |
| 3626 int get size => 5; | |
| 3627 | |
| 3628 int get stackPointerDifference => -1; | |
| 3629 | |
| 3630 String get formatString => 'invoke unfold trunc div %d'; | |
| 3631 | |
| 3632 void addTo(Sink<List<int>> sink) { | |
| 3633 new BytecodeBuffer() | |
| 3634 ..addUint8(opcode.index) | |
| 3635 ..addUint32(uint32Argument0) | |
| 3636 ..sendOn(sink); | |
| 3637 } | |
| 3638 | |
| 3639 String toString() => 'invoke unfold trunc div ${uint32Argument0}'; | |
| 3640 | |
| 3641 operator==(Bytecode other) { | |
| 3642 if (!(super==(other))) return false; | |
| 3643 InvokeTruncDivUnfold rhs = other; | |
| 3644 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3645 return true; | |
| 3646 } | |
| 3647 | |
| 3648 int get hashCode { | |
| 3649 int value = super.hashCode; | |
| 3650 value += uint32Argument0; | |
| 3651 return value; | |
| 3652 } | |
| 3653 } | |
| 3654 | |
| 3655 class InvokeBitNotUnfold extends Bytecode { | |
| 3656 final int uint32Argument0; | |
| 3657 const InvokeBitNotUnfold(this.uint32Argument0) | |
| 3658 : super(); | |
| 3659 | |
| 3660 Opcode get opcode => Opcode.InvokeBitNotUnfold; | |
| 3661 | |
| 3662 String get name => 'InvokeBitNotUnfold'; | |
| 3663 | |
| 3664 bool get isBranching => true; | |
| 3665 | |
| 3666 String get format => 'I'; | |
| 3667 | |
| 3668 int get size => 5; | |
| 3669 | |
| 3670 int get stackPointerDifference => 0; | |
| 3671 | |
| 3672 String get formatString => 'invoke unfold bit not %d'; | |
| 3673 | |
| 3674 void addTo(Sink<List<int>> sink) { | |
| 3675 new BytecodeBuffer() | |
| 3676 ..addUint8(opcode.index) | |
| 3677 ..addUint32(uint32Argument0) | |
| 3678 ..sendOn(sink); | |
| 3679 } | |
| 3680 | |
| 3681 String toString() => 'invoke unfold bit not ${uint32Argument0}'; | |
| 3682 | |
| 3683 operator==(Bytecode other) { | |
| 3684 if (!(super==(other))) return false; | |
| 3685 InvokeBitNotUnfold rhs = other; | |
| 3686 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3687 return true; | |
| 3688 } | |
| 3689 | |
| 3690 int get hashCode { | |
| 3691 int value = super.hashCode; | |
| 3692 value += uint32Argument0; | |
| 3693 return value; | |
| 3694 } | |
| 3695 } | |
| 3696 | |
| 3697 class InvokeBitAndUnfold extends Bytecode { | |
| 3698 final int uint32Argument0; | |
| 3699 const InvokeBitAndUnfold(this.uint32Argument0) | |
| 3700 : super(); | |
| 3701 | |
| 3702 Opcode get opcode => Opcode.InvokeBitAndUnfold; | |
| 3703 | |
| 3704 String get name => 'InvokeBitAndUnfold'; | |
| 3705 | |
| 3706 bool get isBranching => true; | |
| 3707 | |
| 3708 String get format => 'I'; | |
| 3709 | |
| 3710 int get size => 5; | |
| 3711 | |
| 3712 int get stackPointerDifference => -1; | |
| 3713 | |
| 3714 String get formatString => 'invoke unfold bit and %d'; | |
| 3715 | |
| 3716 void addTo(Sink<List<int>> sink) { | |
| 3717 new BytecodeBuffer() | |
| 3718 ..addUint8(opcode.index) | |
| 3719 ..addUint32(uint32Argument0) | |
| 3720 ..sendOn(sink); | |
| 3721 } | |
| 3722 | |
| 3723 String toString() => 'invoke unfold bit and ${uint32Argument0}'; | |
| 3724 | |
| 3725 operator==(Bytecode other) { | |
| 3726 if (!(super==(other))) return false; | |
| 3727 InvokeBitAndUnfold rhs = other; | |
| 3728 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3729 return true; | |
| 3730 } | |
| 3731 | |
| 3732 int get hashCode { | |
| 3733 int value = super.hashCode; | |
| 3734 value += uint32Argument0; | |
| 3735 return value; | |
| 3736 } | |
| 3737 } | |
| 3738 | |
| 3739 class InvokeBitOrUnfold extends Bytecode { | |
| 3740 final int uint32Argument0; | |
| 3741 const InvokeBitOrUnfold(this.uint32Argument0) | |
| 3742 : super(); | |
| 3743 | |
| 3744 Opcode get opcode => Opcode.InvokeBitOrUnfold; | |
| 3745 | |
| 3746 String get name => 'InvokeBitOrUnfold'; | |
| 3747 | |
| 3748 bool get isBranching => true; | |
| 3749 | |
| 3750 String get format => 'I'; | |
| 3751 | |
| 3752 int get size => 5; | |
| 3753 | |
| 3754 int get stackPointerDifference => -1; | |
| 3755 | |
| 3756 String get formatString => 'invoke unfold bit or %d'; | |
| 3757 | |
| 3758 void addTo(Sink<List<int>> sink) { | |
| 3759 new BytecodeBuffer() | |
| 3760 ..addUint8(opcode.index) | |
| 3761 ..addUint32(uint32Argument0) | |
| 3762 ..sendOn(sink); | |
| 3763 } | |
| 3764 | |
| 3765 String toString() => 'invoke unfold bit or ${uint32Argument0}'; | |
| 3766 | |
| 3767 operator==(Bytecode other) { | |
| 3768 if (!(super==(other))) return false; | |
| 3769 InvokeBitOrUnfold rhs = other; | |
| 3770 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3771 return true; | |
| 3772 } | |
| 3773 | |
| 3774 int get hashCode { | |
| 3775 int value = super.hashCode; | |
| 3776 value += uint32Argument0; | |
| 3777 return value; | |
| 3778 } | |
| 3779 } | |
| 3780 | |
| 3781 class InvokeBitXorUnfold extends Bytecode { | |
| 3782 final int uint32Argument0; | |
| 3783 const InvokeBitXorUnfold(this.uint32Argument0) | |
| 3784 : super(); | |
| 3785 | |
| 3786 Opcode get opcode => Opcode.InvokeBitXorUnfold; | |
| 3787 | |
| 3788 String get name => 'InvokeBitXorUnfold'; | |
| 3789 | |
| 3790 bool get isBranching => true; | |
| 3791 | |
| 3792 String get format => 'I'; | |
| 3793 | |
| 3794 int get size => 5; | |
| 3795 | |
| 3796 int get stackPointerDifference => -1; | |
| 3797 | |
| 3798 String get formatString => 'invoke unfold bit xor %d'; | |
| 3799 | |
| 3800 void addTo(Sink<List<int>> sink) { | |
| 3801 new BytecodeBuffer() | |
| 3802 ..addUint8(opcode.index) | |
| 3803 ..addUint32(uint32Argument0) | |
| 3804 ..sendOn(sink); | |
| 3805 } | |
| 3806 | |
| 3807 String toString() => 'invoke unfold bit xor ${uint32Argument0}'; | |
| 3808 | |
| 3809 operator==(Bytecode other) { | |
| 3810 if (!(super==(other))) return false; | |
| 3811 InvokeBitXorUnfold rhs = other; | |
| 3812 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3813 return true; | |
| 3814 } | |
| 3815 | |
| 3816 int get hashCode { | |
| 3817 int value = super.hashCode; | |
| 3818 value += uint32Argument0; | |
| 3819 return value; | |
| 3820 } | |
| 3821 } | |
| 3822 | |
| 3823 class InvokeBitShrUnfold extends Bytecode { | |
| 3824 final int uint32Argument0; | |
| 3825 const InvokeBitShrUnfold(this.uint32Argument0) | |
| 3826 : super(); | |
| 3827 | |
| 3828 Opcode get opcode => Opcode.InvokeBitShrUnfold; | |
| 3829 | |
| 3830 String get name => 'InvokeBitShrUnfold'; | |
| 3831 | |
| 3832 bool get isBranching => true; | |
| 3833 | |
| 3834 String get format => 'I'; | |
| 3835 | |
| 3836 int get size => 5; | |
| 3837 | |
| 3838 int get stackPointerDifference => -1; | |
| 3839 | |
| 3840 String get formatString => 'invoke unfold bit shr %d'; | |
| 3841 | |
| 3842 void addTo(Sink<List<int>> sink) { | |
| 3843 new BytecodeBuffer() | |
| 3844 ..addUint8(opcode.index) | |
| 3845 ..addUint32(uint32Argument0) | |
| 3846 ..sendOn(sink); | |
| 3847 } | |
| 3848 | |
| 3849 String toString() => 'invoke unfold bit shr ${uint32Argument0}'; | |
| 3850 | |
| 3851 operator==(Bytecode other) { | |
| 3852 if (!(super==(other))) return false; | |
| 3853 InvokeBitShrUnfold rhs = other; | |
| 3854 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3855 return true; | |
| 3856 } | |
| 3857 | |
| 3858 int get hashCode { | |
| 3859 int value = super.hashCode; | |
| 3860 value += uint32Argument0; | |
| 3861 return value; | |
| 3862 } | |
| 3863 } | |
| 3864 | |
| 3865 class InvokeBitShlUnfold extends Bytecode { | |
| 3866 final int uint32Argument0; | |
| 3867 const InvokeBitShlUnfold(this.uint32Argument0) | |
| 3868 : super(); | |
| 3869 | |
| 3870 Opcode get opcode => Opcode.InvokeBitShlUnfold; | |
| 3871 | |
| 3872 String get name => 'InvokeBitShlUnfold'; | |
| 3873 | |
| 3874 bool get isBranching => true; | |
| 3875 | |
| 3876 String get format => 'I'; | |
| 3877 | |
| 3878 int get size => 5; | |
| 3879 | |
| 3880 int get stackPointerDifference => -1; | |
| 3881 | |
| 3882 String get formatString => 'invoke unfold bit shl %d'; | |
| 3883 | |
| 3884 void addTo(Sink<List<int>> sink) { | |
| 3885 new BytecodeBuffer() | |
| 3886 ..addUint8(opcode.index) | |
| 3887 ..addUint32(uint32Argument0) | |
| 3888 ..sendOn(sink); | |
| 3889 } | |
| 3890 | |
| 3891 String toString() => 'invoke unfold bit shl ${uint32Argument0}'; | |
| 3892 | |
| 3893 operator==(Bytecode other) { | |
| 3894 if (!(super==(other))) return false; | |
| 3895 InvokeBitShlUnfold rhs = other; | |
| 3896 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3897 return true; | |
| 3898 } | |
| 3899 | |
| 3900 int get hashCode { | |
| 3901 int value = super.hashCode; | |
| 3902 value += uint32Argument0; | |
| 3903 return value; | |
| 3904 } | |
| 3905 } | |
| 3906 | |
| 3907 class LoadConst extends Bytecode { | |
| 3908 final int uint32Argument0; | |
| 3909 const LoadConst(this.uint32Argument0) | |
| 3910 : super(); | |
| 3911 | |
| 3912 Opcode get opcode => Opcode.LoadConst; | |
| 3913 | |
| 3914 String get name => 'LoadConst'; | |
| 3915 | |
| 3916 bool get isBranching => false; | |
| 3917 | |
| 3918 String get format => 'I'; | |
| 3919 | |
| 3920 int get size => 5; | |
| 3921 | |
| 3922 int get stackPointerDifference => 1; | |
| 3923 | |
| 3924 String get formatString => 'load const @%d'; | |
| 3925 | |
| 3926 void addTo(Sink<List<int>> sink) { | |
| 3927 new BytecodeBuffer() | |
| 3928 ..addUint8(opcode.index) | |
| 3929 ..addUint32(uint32Argument0) | |
| 3930 ..sendOn(sink); | |
| 3931 } | |
| 3932 | |
| 3933 String toString() => 'load const @${uint32Argument0}'; | |
| 3934 | |
| 3935 operator==(Bytecode other) { | |
| 3936 if (!(super==(other))) return false; | |
| 3937 LoadConst rhs = other; | |
| 3938 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3939 return true; | |
| 3940 } | |
| 3941 | |
| 3942 int get hashCode { | |
| 3943 int value = super.hashCode; | |
| 3944 value += uint32Argument0; | |
| 3945 return value; | |
| 3946 } | |
| 3947 } | |
| 3948 | |
| 3949 class MethodEnd extends Bytecode { | |
| 3950 final int uint32Argument0; | |
| 3951 const MethodEnd(this.uint32Argument0) | |
| 3952 : super(); | |
| 3953 | |
| 3954 Opcode get opcode => Opcode.MethodEnd; | |
| 3955 | |
| 3956 String get name => 'MethodEnd'; | |
| 3957 | |
| 3958 bool get isBranching => false; | |
| 3959 | |
| 3960 String get format => 'I'; | |
| 3961 | |
| 3962 int get size => 5; | |
| 3963 | |
| 3964 int get stackPointerDifference => 0; | |
| 3965 | |
| 3966 String get formatString => 'method end %d'; | |
| 3967 | |
| 3968 void addTo(Sink<List<int>> sink) { | |
| 3969 new BytecodeBuffer() | |
| 3970 ..addUint8(opcode.index) | |
| 3971 ..addUint32(uint32Argument0) | |
| 3972 ..sendOn(sink); | |
| 3973 } | |
| 3974 | |
| 3975 String toString() => 'method end ${uint32Argument0}'; | |
| 3976 | |
| 3977 operator==(Bytecode other) { | |
| 3978 if (!(super==(other))) return false; | |
| 3979 MethodEnd rhs = other; | |
| 3980 if (uint32Argument0 != rhs.uint32Argument0) return false; | |
| 3981 return true; | |
| 3982 } | |
| 3983 | |
| 3984 int get hashCode { | |
| 3985 int value = super.hashCode; | |
| 3986 value += uint32Argument0; | |
| 3987 return value; | |
| 3988 } | |
| 3989 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1659163007:
Rename fletch -> dartino (Closed)
Base URL: https://github.com/dartino/sdk.git@master