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