v1/chuck_instr.h

   1 /*----------------------------------------------------------------------------
   2     ChucK Concurrent, On-the-fly Audio Programming Language
   3       Compiler and Virtual Machine
   4
   5     Copyright (c) 2004 Ge Wang and Perry R. Cook.  All rights reserved.
   6       http://chuck.cs.princeton.edu/
   7       http://soundlab.cs.princeton.edu/
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17     GNU General Public License for more details.
  18
  19     You should have received a copy of the GNU General Public License
  20     along with this program; if not, write to the Free Software
  21     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  22     U.S.A.
  23 -----------------------------------------------------------------------------*/
  24
  25 //-----------------------------------------------------------------------------
  26 // file: chuck_instr.h
  27 // desc: ...
  28 //
  29 // author: Ge Wang (gewang@cs.princeton.edu)
  30 //         Perry R. Cook (prc@cs.princeton.edu)
  31 // date: Autumn 2002
  32 //-----------------------------------------------------------------------------
  33 #ifndef __CHUCK_INSTR_H__
  34 #define __CHUCK_INSTR_H__
  35
  36 #include <stdio.h>
  37
  38
  39
  40
  41 // forward reference
  42 class Chuck_VM;
  43 class Chuck_VM_Shred;
  44
  45 // define
  46 #define sint long
  47 #define uint unsigned long
  48
  49
  50
  51
  52 //-----------------------------------------------------------------------------
  53 // name: class Chuck_Instr
  54 // desc: ...
  55 //-----------------------------------------------------------------------------
  56 class Chuck_Instr
  57 {
  58 public:
  59     virtual ~Chuck_Instr() { }
  60
  61 public:
  62     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred ) = 0;
  63
  64 public:
  65     virtual const char * name() const;
  66     virtual const char * params() const
  67     { return ""; }
  68 };
  69
  70
  71
  72
  73 //-----------------------------------------------------------------------------
  74 // name: class Chuck_Instr_Branch_Op
  75 // desc: ...
  76 //-----------------------------------------------------------------------------
  77 class Chuck_Instr_Branch_Op : public Chuck_Instr
  78 {
  79 public:
  80     inline void set( uint jmp ) { m_jmp = jmp; }
  81
  82 public:
  83     virtual const char * params() const
  84     { static char buffer[256]; sprintf( buffer, "%d", m_jmp ); return buffer; }
  85
  86 protected:
  87     uint m_jmp;
  88 };
  89
  90
  91
  92
  93 //-----------------------------------------------------------------------------
  94 // name: class Chuck_Instr_Unary_Op
  95 // desc: ...
  96 //-----------------------------------------------------------------------------
  97 class Chuck_Instr_Unary_Op : public Chuck_Instr
  98 {
  99 public:
 100     inline void set( uint val ) { m_val = val; }
 101     inline uint get() { return m_val; }
 102
 103 public:
 104     virtual const char * params() const
 105     { static char buffer[256]; sprintf( buffer, "%d", m_val ); return buffer; }
 106
 107 protected:
 108     uint m_val;
 109 };
 110
 111
 112
 113
 114 //-----------------------------------------------------------------------------
 115 // name: class Chuck_Instr_Unary_Op2
 116 // desc: ...
 117 //-----------------------------------------------------------------------------
 118 class Chuck_Instr_Unary_Op2 : public Chuck_Instr
 119 {
 120 public:
 121     inline void set( double val ) { m_val = val; }
 122     inline double get() { return m_val; }
 123
 124 public:
 125     virtual const char * params() const
 126     { static char buffer[256]; sprintf( buffer, "%.6f", m_val ); return buffer; }
 127
 128 protected:
 129     double m_val;
 130 };
 131
 132
 133
 134
 135 //-----------------------------------------------------------------------------
 136 // name: class Chuck_Instr_Binary_Op
 137 // desc: ...
 138 //-----------------------------------------------------------------------------
 139 class Chuck_Instr_Binary_Op : public Chuck_Instr
 140 { };
 141
 142
 143
 144
 145 //-----------------------------------------------------------------------------
 146 // name: class Chuck_Instr_Add_int
 147 // desc: ...
 148 //-----------------------------------------------------------------------------
 149 class Chuck_Instr_Add_int : public Chuck_Instr_Binary_Op
 150 {
 151 public:
 152     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 153 };
 154
 155
 156
 157
 158 //-----------------------------------------------------------------------------
 159 // name: class Chuck_Instr_Inc_int
 160 // desc: ...
 161 //-----------------------------------------------------------------------------
 162 class Chuck_Instr_Inc_int : public Chuck_Instr
 163 {
 164 public:
 165     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 166 };
 167
 168
 169
 170
 171
 172 //-----------------------------------------------------------------------------
 173 // name: class Chuck_Instr_Dec_int
 174 // desc: ...
 175 //-----------------------------------------------------------------------------
 176 class Chuck_Instr_Dec_int : public Chuck_Instr
 177 {
 178 public:
 179     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 180 };
 181
 182
 183
 184
 185 //-----------------------------------------------------------------------------
 186 // name: class Chuck_Instr_Complement_int
 187 // desc: ...
 188 //-----------------------------------------------------------------------------
 189 class Chuck_Instr_Complement_int : public Chuck_Instr
 190 {
 191 public:
 192     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 193 };
 194
 195
 196
 197
 198 //-----------------------------------------------------------------------------
 199 // name: class Chuck_Instr_Mod_int
 200 // desc: ...
 201 //-----------------------------------------------------------------------------
 202 class Chuck_Instr_Mod_int : public Chuck_Instr_Binary_Op
 203 {
 204 public:
 205     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 206 };
 207
 208
 209
 210
 211 //-----------------------------------------------------------------------------
 212 // name: class Chuck_Instr_Minus_int
 213 // desc: ...
 214 //-----------------------------------------------------------------------------
 215 class Chuck_Instr_Minus_int : public Chuck_Instr_Binary_Op
 216 {
 217 public:
 218     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 219 };
 220
 221
 222
 223
 224 //-----------------------------------------------------------------------------
 225 // name: class Chuck_Instr_Times_int
 226 // desc: ...
 227 //-----------------------------------------------------------------------------
 228 class Chuck_Instr_Times_int : public Chuck_Instr_Binary_Op
 229 {
 230 public:
 231     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 232 };
 233
 234
 235
 236
 237 //-----------------------------------------------------------------------------
 238 // name: class Chuck_Instr_Divide_int
 239 // desc: ...
 240 //-----------------------------------------------------------------------------
 241 class Chuck_Instr_Divide_int : public Chuck_Instr_Binary_Op
 242 {
 243 public:
 244     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 245 };
 246
 247
 248
 249
 250 //-----------------------------------------------------------------------------
 251 // name: class Chuck_Instr_Add_uint
 252 // desc: ...
 253 //-----------------------------------------------------------------------------
 254 class Chuck_Instr_Add_uint : public Chuck_Instr_Binary_Op
 255 {
 256 public:
 257     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 258 };
 259
 260
 261
 262
 263 //-----------------------------------------------------------------------------
 264 // name: class Chuck_Instr_Inc_uint
 265 // desc: ...
 266 //-----------------------------------------------------------------------------
 267 class Chuck_Instr_Inc_uint : public Chuck_Instr
 268 {
 269 public:
 270     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 271 };
 272
 273
 274
 275
 276
 277 //-----------------------------------------------------------------------------
 278 // name: class Chuck_Instr_Dec_uint
 279 // desc: ...
 280 //-----------------------------------------------------------------------------
 281 class Chuck_Instr_Dec_uint : public Chuck_Instr
 282 {
 283 public:
 284     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 285 };
 286
 287
 288
 289
 290 //-----------------------------------------------------------------------------
 291 // name: class Chuck_Instr_Complement_uint
 292 // desc: ...
 293 //-----------------------------------------------------------------------------
 294 class Chuck_Instr_Complement_uint : public Chuck_Instr
 295 {
 296 public:
 297     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 298 };
 299
 300
 301
 302
 303 //-----------------------------------------------------------------------------
 304 // name: class Chuck_Instr_Mod_uint
 305 // desc: ...
 306 //-----------------------------------------------------------------------------
 307 class Chuck_Instr_Mod_uint : public Chuck_Instr_Binary_Op
 308 {
 309 public:
 310     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 311 };
 312
 313
 314
 315
 316 //-----------------------------------------------------------------------------
 317 // name: class Chuck_Instr_Minus_uint
 318 // desc: ...
 319 //-----------------------------------------------------------------------------
 320 class Chuck_Instr_Minus_uint : public Chuck_Instr_Binary_Op
 321 {
 322 public:
 323     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 324 };
 325
 326
 327
 328
 329 //-----------------------------------------------------------------------------
 330 // name: class Chuck_Instr_Times_uint
 331 // desc: ...
 332 //-----------------------------------------------------------------------------
 333 class Chuck_Instr_Times_uint : public Chuck_Instr_Binary_Op
 334 {
 335 public:
 336     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 337 };
 338
 339
 340
 341
 342 //-----------------------------------------------------------------------------
 343 // name: class Chuck_Instr_Divide_uint
 344 // desc: ...
 345 //-----------------------------------------------------------------------------
 346 class Chuck_Instr_Divide_uint : public Chuck_Instr_Binary_Op
 347 {
 348 public:
 349     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 350 };
 351
 352
 353
 354
 355 //-----------------------------------------------------------------------------
 356 // name: class Chuck_Instr_Add_single
 357 // desc: ...
 358 //-----------------------------------------------------------------------------
 359 class Chuck_Instr_Add_single : public Chuck_Instr_Binary_Op
 360 {
 361 public:
 362     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 363 };
 364
 365
 366
 367
 368 //-----------------------------------------------------------------------------
 369 // name: class Chuck_Instr_Minus_single
 370 // desc: ...
 371 //-----------------------------------------------------------------------------
 372 class Chuck_Instr_Minus_single : public Chuck_Instr_Binary_Op
 373 {
 374 public:
 375     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 376 };
 377
 378
 379
 380
 381 //-----------------------------------------------------------------------------
 382 // name: class Chuck_Instr_Times_single
 383 // desc: ...
 384 //-----------------------------------------------------------------------------
 385 class Chuck_Instr_Times_single : public Chuck_Instr_Binary_Op
 386 {
 387 public:
 388     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 389 };
 390
 391
 392
 393
 394 //-----------------------------------------------------------------------------
 395 // name: class Chuck_Instr_Divide_single
 396 // desc: ...
 397 //-----------------------------------------------------------------------------
 398 class Chuck_Instr_Divide_single : public Chuck_Instr_Binary_Op
 399 {
 400 public:
 401     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 402 };
 403
 404
 405
 406
 407 //-----------------------------------------------------------------------------
 408 // name: class Chuck_Instr_Mod_single
 409 // desc: ...
 410 //-----------------------------------------------------------------------------
 411 class Chuck_Instr_Mod_single : public Chuck_Instr_Binary_Op
 412 {
 413 public:
 414     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 415 };
 416
 417
 418
 419
 420 //-----------------------------------------------------------------------------
 421 // name: class Chuck_Instr_Add_double
 422 // desc: ...
 423 //-----------------------------------------------------------------------------
 424 class Chuck_Instr_Add_double : public Chuck_Instr_Binary_Op
 425 {
 426 public:
 427     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 428 };
 429
 430
 431
 432
 433 //-----------------------------------------------------------------------------
 434 // name: class Chuck_Instr_Minus_double
 435 // desc: ...
 436 //-----------------------------------------------------------------------------
 437 class Chuck_Instr_Minus_double : public Chuck_Instr_Binary_Op
 438 {
 439 public:
 440     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 441 };
 442
 443
 444
 445
 446 //-----------------------------------------------------------------------------
 447 // name: class Chuck_Instr_Times_double
 448 // desc: ...
 449 //-----------------------------------------------------------------------------
 450 class Chuck_Instr_Times_double : public Chuck_Instr_Binary_Op
 451 {
 452 public:
 453     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 454 };
 455
 456
 457
 458
 459 //-----------------------------------------------------------------------------
 460 // name: class Chuck_Instr_Divide_double
 461 // desc: ...
 462 //-----------------------------------------------------------------------------
 463 class Chuck_Instr_Divide_double : public Chuck_Instr_Binary_Op
 464 {
 465 public:
 466     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 467 };
 468
 469
 470
 471
 472 //-----------------------------------------------------------------------------
 473 // name: class Chuck_Instr_Mod_double
 474 // desc: ...
 475 //-----------------------------------------------------------------------------
 476 class Chuck_Instr_Mod_double : public Chuck_Instr_Binary_Op
 477 {
 478 public:
 479     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 480 };
 481
 482
 483
 484
 485 //-----------------------------------------------------------------------------
 486 // name: class Chuck_Instr_Add_dur
 487 // desc: ...
 488 //-----------------------------------------------------------------------------
 489 class Chuck_Instr_Add_dur : public Chuck_Instr_Binary_Op
 490 {
 491 public:
 492     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 493 };
 494
 495
 496
 497
 498 //-----------------------------------------------------------------------------
 499 // name: class Chuck_Instr_Add_dur_time
 500 // desc: ...
 501 //-----------------------------------------------------------------------------
 502 class Chuck_Instr_Add_dur_time : public Chuck_Instr_Binary_Op
 503 {
 504 public:
 505     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 506 };
 507
 508
 509
 510
 511 //-----------------------------------------------------------------------------
 512 // name: class Chuck_Instr_Branch_Lt_int
 513 // desc: ...
 514 //-----------------------------------------------------------------------------
 515 class Chuck_Instr_Branch_Lt_int : public Chuck_Instr_Branch_Op
 516 {
 517 public:
 518     Chuck_Instr_Branch_Lt_int( uint jmp ) { this->set( jmp ); }
 519     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 520 };
 521
 522
 523
 524
 525 //-----------------------------------------------------------------------------
 526 // name: class Chuck_Instr_Branch_Gt_int
 527 // desc: ...
 528 //-----------------------------------------------------------------------------
 529 class Chuck_Instr_Branch_Gt_int : public Chuck_Instr_Branch_Op
 530 {
 531 public:
 532     Chuck_Instr_Branch_Gt_int( uint jmp ) { this->set( jmp ); }
 533     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 534 };
 535
 536
 537
 538
 539 //-----------------------------------------------------------------------------
 540 // name: class Chuck_Instr_Branch_Le_int
 541 // desc: ...
 542 //-----------------------------------------------------------------------------
 543 class Chuck_Instr_Branch_Le_int : public Chuck_Instr_Branch_Op
 544 {
 545 public:
 546     Chuck_Instr_Branch_Le_int( uint jmp ) { this->set( jmp ); }
 547     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 548 };
 549
 550
 551
 552
 553 //-----------------------------------------------------------------------------
 554 // name: class Chuck_Instr_Branch_Ge_int
 555 // desc: ...
 556 //-----------------------------------------------------------------------------
 557 class Chuck_Instr_Branch_Ge_int : public Chuck_Instr_Branch_Op
 558 {
 559 public:
 560     Chuck_Instr_Branch_Ge_int( uint jmp ) { this->set( jmp ); }
 561     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 562 };
 563
 564
 565
 566
 567 //-----------------------------------------------------------------------------
 568 // name: class Chuck_Instr_Branch_Eq_int
 569 // desc: ...
 570 //-----------------------------------------------------------------------------
 571 class Chuck_Instr_Branch_Eq_int : public Chuck_Instr_Branch_Op
 572 {
 573 public:
 574     Chuck_Instr_Branch_Eq_int( uint jmp ) { this->set( jmp ); }
 575     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 576 };
 577
 578
 579
 580
 581 //-----------------------------------------------------------------------------
 582 // name: class Chuck_Instr_Branch_Neq_int
 583 // desc: ...
 584 //-----------------------------------------------------------------------------
 585 class Chuck_Instr_Branch_Neq_int : public Chuck_Instr_Branch_Op
 586 {
 587 public:
 588     Chuck_Instr_Branch_Neq_int( uint jmp ) { this->set( jmp ); }
 589     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 590 };
 591
 592
 593
 594
 595 //-----------------------------------------------------------------------------
 596 // name: class Chuck_Instr_Branch_Lt_uint
 597 // desc: ...
 598 //-----------------------------------------------------------------------------
 599 class Chuck_Instr_Branch_Lt_uint : public Chuck_Instr_Branch_Op
 600 {
 601 public:
 602     Chuck_Instr_Branch_Lt_uint( uint jmp ) { this->set( jmp ); }
 603     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 604 };
 605
 606
 607
 608
 609 //-----------------------------------------------------------------------------
 610 // name: class Chuck_Instr_Branch_Gt_uint
 611 // desc: ...
 612 //-----------------------------------------------------------------------------
 613 class Chuck_Instr_Branch_Gt_uint : public Chuck_Instr_Branch_Op
 614 {
 615 public:
 616     Chuck_Instr_Branch_Gt_uint( uint jmp ) { this->set( jmp ); }
 617     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 618 };
 619
 620
 621
 622
 623 //-----------------------------------------------------------------------------
 624 // name: class Chuck_Instr_Branch_Le_uint
 625 // desc: ...
 626 //-----------------------------------------------------------------------------
 627 class Chuck_Instr_Branch_Le_uint : public Chuck_Instr_Branch_Op
 628 {
 629 public:
 630     Chuck_Instr_Branch_Le_uint( uint jmp ) { this->set( jmp ); }
 631     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 632 };
 633
 634
 635
 636
 637 //-----------------------------------------------------------------------------
 638 // name: class Chuck_Instr_Branch_Ge_uint
 639 // desc: ...
 640 //-----------------------------------------------------------------------------
 641 class Chuck_Instr_Branch_Ge_uint : public Chuck_Instr_Branch_Op
 642 {
 643 public:
 644     Chuck_Instr_Branch_Ge_uint( uint jmp ) { this->set( jmp ); }
 645     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 646 };
 647
 648
 649
 650
 651 //-----------------------------------------------------------------------------
 652 // name: class Chuck_Instr_Branch_Eq_uint
 653 // desc: ...
 654 //-----------------------------------------------------------------------------
 655 class Chuck_Instr_Branch_Eq_uint : public Chuck_Instr_Branch_Op
 656 {
 657 public:
 658     Chuck_Instr_Branch_Eq_uint( uint jmp ) { this->set( jmp ); }
 659     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 660 };
 661
 662
 663
 664
 665 //-----------------------------------------------------------------------------
 666 // name: class Chuck_Instr_Branch_Neq_uint
 667 // desc: ...
 668 //-----------------------------------------------------------------------------
 669 class Chuck_Instr_Branch_Neq_uint : public Chuck_Instr_Branch_Op
 670 {
 671 public:
 672     Chuck_Instr_Branch_Neq_uint( uint jmp ) { this->set( jmp ); }
 673     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 674 };
 675
 676
 677
 678
 679 //-----------------------------------------------------------------------------
 680 // name: class Chuck_Instr_Branch_Lt_single
 681 // desc: ...
 682 //-----------------------------------------------------------------------------
 683 class Chuck_Instr_Branch_Lt_single : public Chuck_Instr_Branch_Op
 684 {
 685 public:
 686     Chuck_Instr_Branch_Lt_single( uint jmp ) { this->set( jmp ); }
 687     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 688 };
 689
 690
 691
 692
 693 //-----------------------------------------------------------------------------
 694 // name: class Chuck_Instr_Branch_Gt_single
 695 // desc: ...
 696 //-----------------------------------------------------------------------------
 697 class Chuck_Instr_Branch_Gt_single : public Chuck_Instr_Branch_Op
 698 {
 699 public:
 700     Chuck_Instr_Branch_Gt_single( uint jmp ) { this->set( jmp ); }
 701     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 702 };
 703
 704
 705
 706
 707 //-----------------------------------------------------------------------------
 708 // name: class Chuck_Instr_Branch_Le_single
 709 // desc: ...
 710 //-----------------------------------------------------------------------------
 711 class Chuck_Instr_Branch_Le_single : public Chuck_Instr_Branch_Op
 712 {
 713 public:
 714     Chuck_Instr_Branch_Le_single( uint jmp ) { this->set( jmp ); }
 715     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 716 };
 717
 718
 719
 720
 721 //-----------------------------------------------------------------------------
 722 // name: class Chuck_Instr_Branch_Ge_single
 723 // desc: ...
 724 //-----------------------------------------------------------------------------
 725 class Chuck_Instr_Branch_Ge_single : public Chuck_Instr_Branch_Op
 726 {
 727 public:
 728     Chuck_Instr_Branch_Ge_single( uint jmp ) { this->set( jmp ); }
 729     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 730 };
 731
 732
 733
 734
 735 //-----------------------------------------------------------------------------
 736 // name: class Chuck_Instr_Branch_Eq_single
 737 // desc: ...
 738 //-----------------------------------------------------------------------------
 739 class Chuck_Instr_Branch_Eq_single : public Chuck_Instr_Branch_Op
 740 {
 741 public:
 742     Chuck_Instr_Branch_Eq_single( uint jmp ) { this->set( jmp ); }
 743     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 744 };
 745
 746
 747
 748
 749 //-----------------------------------------------------------------------------
 750 // name: class Chuck_Instr_Branch_Neq_single
 751 // desc: ...
 752 //-----------------------------------------------------------------------------
 753 class Chuck_Instr_Branch_Neq_single : public Chuck_Instr_Branch_Op
 754 {
 755 public:
 756     Chuck_Instr_Branch_Neq_single( uint jmp ) { this->set( jmp ); }
 757     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 758 };
 759
 760
 761
 762
 763 //-----------------------------------------------------------------------------
 764 // name: class Chuck_Instr_Branch_Lt_double
 765 // desc: ...
 766 //-----------------------------------------------------------------------------
 767 class Chuck_Instr_Branch_Lt_double : public Chuck_Instr_Branch_Op
 768 {
 769 public:
 770     Chuck_Instr_Branch_Lt_double( uint jmp ) { this->set( jmp ); }
 771     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 772 };
 773
 774
 775
 776
 777 //-----------------------------------------------------------------------------
 778 // name: class Chuck_Instr_Branch_Gt_double
 779 // desc: ...
 780 //-----------------------------------------------------------------------------
 781 class Chuck_Instr_Branch_Gt_double : public Chuck_Instr_Branch_Op
 782 {
 783 public:
 784     Chuck_Instr_Branch_Gt_double( uint jmp ) { this->set( jmp ); }
 785     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 786 };
 787
 788
 789
 790
 791 //-----------------------------------------------------------------------------
 792 // name: class Chuck_Instr_Branch_Le_double
 793 // desc: ...
 794 //-----------------------------------------------------------------------------
 795 class Chuck_Instr_Branch_Le_double : public Chuck_Instr_Branch_Op
 796 {
 797 public:
 798     Chuck_Instr_Branch_Le_double( uint jmp ) { this->set( jmp ); }
 799     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 800 };
 801
 802
 803
 804
 805 //-----------------------------------------------------------------------------
 806 // name: class Chuck_Instr_Branch_Ge_double
 807 // desc: ...
 808 //-----------------------------------------------------------------------------
 809 class Chuck_Instr_Branch_Ge_double : public Chuck_Instr_Branch_Op
 810 {
 811 public:
 812     Chuck_Instr_Branch_Ge_double( uint jmp ) { this->set( jmp ); }
 813     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 814 };
 815
 816
 817
 818
 819 //-----------------------------------------------------------------------------
 820 // name: class Chuck_Instr_Branch_Eq_double
 821 // desc: ...
 822 //-----------------------------------------------------------------------------
 823 class Chuck_Instr_Branch_Eq_double : public Chuck_Instr_Branch_Op
 824 {
 825 public:
 826     Chuck_Instr_Branch_Eq_double( uint jmp ) { this->set( jmp ); }
 827     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 828 };
 829
 830
 831
 832
 833 //-----------------------------------------------------------------------------
 834 // name: class Chuck_Instr_Branch_Neq_double
 835 // desc: ...
 836 //-----------------------------------------------------------------------------
 837 class Chuck_Instr_Branch_Neq_double : public Chuck_Instr_Branch_Op
 838 {
 839 public:
 840     Chuck_Instr_Branch_Neq_double( uint jmp ) { this->set( jmp ); }
 841     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 842 };
 843
 844
 845
 846
 847 //-----------------------------------------------------------------------------
 848 // name: class Chuck_Instr_Lt_int
 849 // desc: ...
 850 //-----------------------------------------------------------------------------
 851 class Chuck_Instr_Lt_int : public Chuck_Instr_Binary_Op
 852 {
 853 public:
 854     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 855 };
 856
 857
 858
 859
 860 //-----------------------------------------------------------------------------
 861 // name: class Chuck_Instr_Gt_int
 862 // desc: ...
 863 //-----------------------------------------------------------------------------
 864 class Chuck_Instr_Gt_int : public Chuck_Instr_Binary_Op
 865 {
 866 public:
 867     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 868 };
 869
 870
 871
 872
 873 //-----------------------------------------------------------------------------
 874 // name: class Chuck_Instr_Le_int
 875 // desc: ...
 876 //-----------------------------------------------------------------------------
 877 class Chuck_Instr_Le_int : public Chuck_Instr_Binary_Op
 878 {
 879 public:
 880     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 881 };
 882
 883
 884
 885
 886 //-----------------------------------------------------------------------------
 887 // name: class Chuck_Instr_Ge_int
 888 // desc: ...
 889 //-----------------------------------------------------------------------------
 890 class Chuck_Instr_Ge_int : public Chuck_Instr_Binary_Op
 891 {
 892 public:
 893     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 894 };
 895
 896
 897
 898
 899 //-----------------------------------------------------------------------------
 900 // name: class Chuck_Instr_Eq_int
 901 // desc: ...
 902 //-----------------------------------------------------------------------------
 903 class Chuck_Instr_Eq_int : public Chuck_Instr_Binary_Op
 904 {
 905 public:
 906     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 907 };
 908
 909
 910
 911
 912 //-----------------------------------------------------------------------------
 913 // name: class Chuck_Instr_Neq_int
 914 // desc: ...
 915 //-----------------------------------------------------------------------------
 916 class Chuck_Instr_Neq_int : public Chuck_Instr_Binary_Op
 917 {
 918 public:
 919     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 920 };
 921
 922
 923
 924
 925 //-----------------------------------------------------------------------------
 926 // name: class Chuck_Instr_Not_int
 927 // desc: ...
 928 //-----------------------------------------------------------------------------
 929 class Chuck_Instr_Not_int : public Chuck_Instr
 930 {
 931 public:
 932     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 933 };
 934
 935
 936
 937
 938 //-----------------------------------------------------------------------------
 939 // name: class Chuck_Instr_Negate_int
 940 // desc: ...
 941 //-----------------------------------------------------------------------------
 942 class Chuck_Instr_Negate_int : public Chuck_Instr
 943 {
 944 public:
 945     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 946 };
 947
 948
 949
 950
 951 //-----------------------------------------------------------------------------
 952 // name: class Chuck_Instr_Negate_uint
 953 // desc: ...
 954 //-----------------------------------------------------------------------------
 955 class Chuck_Instr_Negate_uint : public Chuck_Instr
 956 {
 957 public:
 958     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 959 };
 960
 961
 962
 963
 964 //-----------------------------------------------------------------------------
 965 // name: class Chuck_Instr_Negate_single
 966 // desc: ...
 967 //-----------------------------------------------------------------------------
 968 class Chuck_Instr_Negate_single : public Chuck_Instr
 969 {
 970 public:
 971     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 972 };
 973
 974
 975
 976
 977 //-----------------------------------------------------------------------------
 978 // name: class Chuck_Instr_Negate_double
 979 // desc: ...
 980 //-----------------------------------------------------------------------------
 981 class Chuck_Instr_Negate_double : public Chuck_Instr
 982 {
 983 public:
 984     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 985 };
 986
 987
 988
 989
 990 //-----------------------------------------------------------------------------
 991 // name: class Chuck_Instr_Lt_uint
 992 // desc: ...
 993 //-----------------------------------------------------------------------------
 994 class Chuck_Instr_Lt_uint : public Chuck_Instr_Binary_Op
 995 {
 996 public:
 997     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
 998 };
 999
1000
1001
1002
1003 //-----------------------------------------------------------------------------
1004 // name: class Chuck_Instr_Gt_uint
1005 // desc: ...
1006 //-----------------------------------------------------------------------------
1007 class Chuck_Instr_Gt_uint : public Chuck_Instr_Binary_Op
1008 {
1009 public:
1010     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1011 };
1012
1013
1014
1015
1016 //-----------------------------------------------------------------------------
1017 // name: class Chuck_Instr_Le_uint
1018 // desc: ...
1019 //-----------------------------------------------------------------------------
1020 class Chuck_Instr_Le_uint : public Chuck_Instr_Binary_Op
1021 {
1022 public:
1023     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1024 };
1025
1026
1027
1028
1029 //-----------------------------------------------------------------------------
1030 // name: class Chuck_Instr_Ge_uint
1031 // desc: ...
1032 //-----------------------------------------------------------------------------
1033 class Chuck_Instr_Ge_uint : public Chuck_Instr_Binary_Op
1034 {
1035 public:
1036     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1037 };
1038
1039
1040
1041
1042 //-----------------------------------------------------------------------------
1043 // name: class Chuck_Instr_Eq_uint
1044 // desc: ...
1045 //-----------------------------------------------------------------------------
1046 class Chuck_Instr_Eq_uint : public Chuck_Instr_Binary_Op
1047 {
1048 public:
1049     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1050 };
1051
1052
1053
1054
1055 //-----------------------------------------------------------------------------
1056 // name: class Chuck_Instr_Neq_uint
1057 // desc: ...
1058 //-----------------------------------------------------------------------------
1059 class Chuck_Instr_Neq_uint : public Chuck_Instr_Binary_Op
1060 {
1061 public:
1062     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1063 };
1064
1065
1066
1067
1068 //-----------------------------------------------------------------------------
1069 // name: class Chuck_Instr_Lt_single
1070 // desc: ...
1071 //-----------------------------------------------------------------------------
1072 class Chuck_Instr_Lt_single : public Chuck_Instr_Binary_Op
1073 {
1074 public:
1075     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1076 };
1077
1078
1079
1080
1081 //-----------------------------------------------------------------------------
1082 // name: class Chuck_Instr_Gt_single
1083 // desc: ...
1084 //-----------------------------------------------------------------------------
1085 class Chuck_Instr_Gt_single : public Chuck_Instr_Binary_Op
1086 {
1087 public:
1088     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1089 };
1090
1091
1092
1093
1094 //-----------------------------------------------------------------------------
1095 // name: class Chuck_Instr_Le_single
1096 // desc: ...
1097 //-----------------------------------------------------------------------------
1098 class Chuck_Instr_Le_single : public Chuck_Instr_Binary_Op
1099 {
1100 public:
1101     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1102 };
1103
1104
1105
1106
1107 //-----------------------------------------------------------------------------
1108 // name: class Chuck_Instr_Ge_single
1109 // desc: ...
1110 //-----------------------------------------------------------------------------
1111 class Chuck_Instr_Ge_single : public Chuck_Instr_Binary_Op
1112 {
1113 public:
1114     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1115 };
1116
1117
1118
1119
1120 //-----------------------------------------------------------------------------
1121 // name: class Chuck_Instr_Eq_single
1122 // desc: ...
1123 //-----------------------------------------------------------------------------
1124 class Chuck_Instr_Eq_single : public Chuck_Instr_Binary_Op
1125 {
1126 public:
1127     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1128 };
1129
1130
1131
1132
1133 //-----------------------------------------------------------------------------
1134 // name: class Chuck_Instr_Neq_single
1135 // desc: ...
1136 //-----------------------------------------------------------------------------
1137 class Chuck_Instr_Neq_single : public Chuck_Instr_Binary_Op
1138 {
1139 public:
1140     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1141 };
1142
1143
1144
1145
1146 //-----------------------------------------------------------------------------
1147 // name: class Chuck_Instr_Lt_double
1148 // desc: ...
1149 //-----------------------------------------------------------------------------
1150 class Chuck_Instr_Lt_double : public Chuck_Instr_Binary_Op
1151 {
1152 public:
1153     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1154 };
1155
1156
1157
1158
1159 //-----------------------------------------------------------------------------
1160 // name: class Chuck_Instr_Gt_double
1161 // desc: ...
1162 //-----------------------------------------------------------------------------
1163 class Chuck_Instr_Gt_double : public Chuck_Instr_Binary_Op
1164 {
1165 public:
1166     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1167 };
1168
1169
1170
1171
1172 //-----------------------------------------------------------------------------
1173 // name: class Chuck_Instr_Le_double
1174 // desc: ...
1175 //-----------------------------------------------------------------------------
1176 class Chuck_Instr_Le_double : public Chuck_Instr_Binary_Op
1177 {
1178 public:
1179     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1180 };
1181
1182
1183
1184
1185 //-----------------------------------------------------------------------------
1186 // name: class Chuck_Instr_Ge_double
1187 // desc: ...
1188 //-----------------------------------------------------------------------------
1189 class Chuck_Instr_Ge_double : public Chuck_Instr_Binary_Op
1190 {
1191 public:
1192     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1193 };
1194
1195
1196
1197
1198 //-----------------------------------------------------------------------------
1199 // name: class Chuck_Instr_Eq_double
1200 // desc: ...
1201 //-----------------------------------------------------------------------------
1202 class Chuck_Instr_Eq_double : public Chuck_Instr_Binary_Op
1203 {
1204 public:
1205     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1206 };
1207
1208
1209
1210
1211 //-----------------------------------------------------------------------------
1212 // name: class Chuck_Instr_Neq_double
1213 // desc: ...
1214 //-----------------------------------------------------------------------------
1215 class Chuck_Instr_Neq_double : public Chuck_Instr_Binary_Op
1216 {
1217 public:
1218     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1219 };
1220
1221
1222
1223
1224 //-----------------------------------------------------------------------------
1225 // name: class Chuck_Instr_Binary_And
1226 // desc: ...
1227 //-----------------------------------------------------------------------------
1228 class Chuck_Instr_Binary_And : public Chuck_Instr_Binary_Op
1229 {
1230 public:
1231     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1232 };
1233
1234
1235
1236
1237 //-----------------------------------------------------------------------------
1238 // name: class Chuck_Instr_Binary_Or
1239 // desc: ...
1240 //-----------------------------------------------------------------------------
1241 class Chuck_Instr_Binary_Or : public Chuck_Instr_Binary_Op
1242 {
1243 public:
1244     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1245 };
1246
1247
1248
1249
1250 //-----------------------------------------------------------------------------
1251 // name: class Chuck_Instr_Binary_Xor
1252 // desc: ...
1253 //-----------------------------------------------------------------------------
1254 class Chuck_Instr_Binary_Xor : public Chuck_Instr_Binary_Op
1255 {
1256 public:
1257     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1258 };
1259
1260
1261
1262
1263 //-----------------------------------------------------------------------------
1264 // name: class Chuck_Instr_Binary_Shift_Right
1265 // desc: ...
1266 //-----------------------------------------------------------------------------
1267 class Chuck_Instr_Binary_Shift_Right : public Chuck_Instr_Binary_Op
1268 {
1269 public:
1270     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1271 };
1272
1273
1274
1275
1276 //-----------------------------------------------------------------------------
1277 // name: class Chuck_Instr_Binary_Shift_Left
1278 // desc: ...
1279 //-----------------------------------------------------------------------------
1280 class Chuck_Instr_Binary_Shift_Left : public Chuck_Instr_Binary_Op
1281 {
1282 public:
1283     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1284 };
1285
1286
1287
1288
1289 //-----------------------------------------------------------------------------
1290 // name: class Chuck_Instr_And
1291 // desc: ...
1292 //-----------------------------------------------------------------------------
1293 class Chuck_Instr_And : public Chuck_Instr_Binary_Op
1294 {
1295 public:
1296     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1297 };
1298
1299
1300
1301
1302 //-----------------------------------------------------------------------------
1303 // name: class Chuck_Instr_Or
1304 // desc: ...
1305 //-----------------------------------------------------------------------------
1306 class Chuck_Instr_Or : public Chuck_Instr_Binary_Op
1307 {
1308 public:
1309     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1310 };
1311
1312
1313
1314
1315 //-----------------------------------------------------------------------------
1316 // name: class Chuck_Instr_Goto
1317 // desc: ...
1318 //-----------------------------------------------------------------------------
1319 class Chuck_Instr_Goto : public Chuck_Instr_Branch_Op
1320 {
1321 public:
1322     Chuck_Instr_Goto( uint jmp ) { this->set( jmp ); }
1323     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1324 };
1325
1326
1327
1328
1329 //-----------------------------------------------------------------------------
1330 // name: class Chuck_Instr_Reg_Pop_Word
1331 // desc: pop word from reg stack
1332 //-----------------------------------------------------------------------------
1333 class Chuck_Instr_Reg_Pop_Word : public Chuck_Instr
1334 {
1335 public:
1336     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1337 };
1338
1339
1340
1341
1342 //-----------------------------------------------------------------------------
1343 // name: class Chuck_Instr_Reg_Pop_Word2
1344 // desc: pop double word from reg stack
1345 //-----------------------------------------------------------------------------
1346 class Chuck_Instr_Reg_Pop_Word2 : public Chuck_Instr
1347 {
1348 public:
1349     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1350 };
1351
1352
1353
1354
1355 //-----------------------------------------------------------------------------
1356 // name: class Chuck_Instr_Reg_Pop_Mem
1357 // desc: pop word, and copy it to the mem stack
1358 //-----------------------------------------------------------------------------
1359 class Chuck_Instr_Reg_Pop_Mem: public Chuck_Instr_Unary_Op
1360 {
1361 public:
1362     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1363 };
1364
1365
1366
1367
1368 //-----------------------------------------------------------------------------
1369 // name: class Chuck_Instr_Reg_Pop_Mem2
1370 // desc: pop double word, and copy it to the mem stack
1371 //-----------------------------------------------------------------------------
1372 class Chuck_Instr_Reg_Pop_Mem2: public Chuck_Instr_Unary_Op
1373 {
1374 public:
1375     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1376 };
1377
1378
1379
1380
1381 //-----------------------------------------------------------------------------
1382 // name: class Chuck_Instr_Reg_Push_Imm
1383 // desc: push immediate to reg stack
1384 //-----------------------------------------------------------------------------
1385 class Chuck_Instr_Reg_Push_Imm : public Chuck_Instr_Unary_Op
1386 {
1387 public:
1388     Chuck_Instr_Reg_Push_Imm( uint val )
1389     { this->set( val ); }
1390
1391 public:
1392     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1393 };
1394
1395
1396
1397
1398 //-----------------------------------------------------------------------------
1399 // name: class Chuck_Instr_Reg_Push_Imm2
1400 // desc: push double immediate to reg stack
1401 //-----------------------------------------------------------------------------
1402 class Chuck_Instr_Reg_Push_Imm2 : public Chuck_Instr_Unary_Op2
1403 {
1404 public:
1405     Chuck_Instr_Reg_Push_Imm2( double val )
1406     { this->set( val ); }
1407
1408 public:
1409     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1410 };
1411
1412
1413
1414
1415 //-----------------------------------------------------------------------------
1416 // name: class Chuck_Instr_Reg_Push_Now
1417 // desc: push value of now to reg stack
1418 //-----------------------------------------------------------------------------
1419 class Chuck_Instr_Reg_Push_Now : public Chuck_Instr
1420 {
1421 public:
1422     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1423 };
1424
1425
1426
1427
1428 //-----------------------------------------------------------------------------
1429 // name: class Chuck_Instr_Reg_Push_Start
1430 // desc: push value of start to reg stack
1431 //-----------------------------------------------------------------------------
1432 class Chuck_Instr_Reg_Push_Start : public Chuck_Instr
1433 {
1434 public:
1435     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1436 };
1437
1438
1439
1440
1441 //-----------------------------------------------------------------------------
1442 // name: class Chuck_Instr_Reg_Push_Maybe
1443 // desc: push immediate to reg stack
1444 //-----------------------------------------------------------------------------
1445 class Chuck_Instr_Reg_Push_Maybe : public Chuck_Instr_Unary_Op
1446 {
1447 public:
1448     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1449 };
1450
1451
1452
1453
1454 //-----------------------------------------------------------------------------
1455 // name: class Chuck_Instr_Reg_Push_Mem
1456 // desc: push a variable from mem stack to reg stack
1457 //-----------------------------------------------------------------------------
1458 class Chuck_Instr_Reg_Push_Mem : public Chuck_Instr_Unary_Op
1459 {
1460 public:
1461     Chuck_Instr_Reg_Push_Mem( uint src )
1462     { this->set( src ); }
1463
1464 public:
1465     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1466 };
1467
1468
1469
1470
1471 //-----------------------------------------------------------------------------
1472 // name: class Chuck_Instr_Reg_Push_Mem2
1473 // desc: push a double variable from mem stack to reg stack
1474 //-----------------------------------------------------------------------------
1475 class Chuck_Instr_Reg_Push_Mem2 : public Chuck_Instr_Unary_Op
1476 {
1477 public:
1478     Chuck_Instr_Reg_Push_Mem2( uint src )
1479     { this->set( src ); }
1480
1481 public:
1482     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1483 };
1484
1485
1486
1487
1488 //-----------------------------------------------------------------------------
1489 // name: class Chuck_Instr_Reg_Push_Deref
1490 // desc: push a double variable from main memory to reg stack
1491 //-----------------------------------------------------------------------------
1492 class Chuck_Instr_Reg_Push_Deref : public Chuck_Instr_Unary_Op
1493 {
1494 public:
1495     Chuck_Instr_Reg_Push_Deref( uint src, uint size )
1496     { this->set( src ); m_size = size; }
1497
1498 public:
1499     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1500     uint m_size;
1501 };
1502
1503
1504
1505
1506 //-----------------------------------------------------------------------------
1507 // name: class Chuck_Instr_Reg_Push_Deref
1508 // desc: push a double variable from main memory to reg stack
1509 //-----------------------------------------------------------------------------
1510 class Chuck_Instr_Reg_Push_Deref2 : public Chuck_Instr_Unary_Op2
1511 {
1512 public:
1513     Chuck_Instr_Reg_Push_Deref2( double src )
1514     { this->set( src ); }
1515
1516 public:
1517     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1518 };
1519
1520
1521
1522
1523 //-----------------------------------------------------------------------------
1524 // name: class Chuck_Instr_Mem_Push_Imm
1525 // desc: push a value unto mem stack
1526 //-----------------------------------------------------------------------------
1527 class Chuck_Instr_Mem_Push_Imm : public Chuck_Instr_Unary_Op
1528 {
1529 public:
1530     Chuck_Instr_Mem_Push_Imm( uint src )
1531     { this->set( src ); }
1532
1533 public:
1534     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1535 };
1536
1537
1538
1539 //-----------------------------------------------------------------------------
1540 // name: class Chuck_Instr_Mem_Push_Imm2
1541 // desc: push a double value unto mem stack
1542 //-----------------------------------------------------------------------------
1543 class Chuck_Instr_Mem_Push_Imm2 : public Chuck_Instr_Unary_Op2
1544 {
1545 public:
1546     Chuck_Instr_Mem_Push_Imm2( double src )
1547     { this->set( src ); }
1548
1549 public:
1550     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1551 };
1552
1553
1554
1555 //-----------------------------------------------------------------------------
1556 // name: class Chuck_Instr_Mem_Pop_Word
1557 // desc: pop a value from mem stack
1558 //-----------------------------------------------------------------------------
1559 class Chuck_Instr_Mem_Pop_Word : public Chuck_Instr
1560 {
1561 public:
1562     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1563 };
1564
1565
1566
1567
1568 //-----------------------------------------------------------------------------
1569 // name: class Chuck_Instr_Mem_Pop_Word2
1570 // desc: pop a value from mem stack
1571 //-----------------------------------------------------------------------------
1572 class Chuck_Instr_Mem_Pop_Word2 : public Chuck_Instr
1573 {
1574 public:
1575     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1576 };
1577
1578
1579
1580
1581 //-----------------------------------------------------------------------------
1582 // name: class Chuck_Instr_Nop
1583 // desc: no op
1584 //-----------------------------------------------------------------------------
1585 class Chuck_Instr_Nop : public Chuck_Instr
1586 {
1587 public:
1588     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1589 };
1590
1591
1592
1593
1594 //-----------------------------------------------------------------------------
1595 // name: class Chuck_Instr_EOC
1596 // desc: ...
1597 //-----------------------------------------------------------------------------
1598 class Chuck_Instr_EOC : public Chuck_Instr
1599 {
1600 public:
1601     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1602 };
1603
1604
1605
1606
1607 //-----------------------------------------------------------------------------
1608 // name: class Chuck_Instr_Chuck_Assign
1609 // desc: ...
1610 //-----------------------------------------------------------------------------
1611 class Chuck_Instr_Chuck_Assign : public Chuck_Instr
1612 {
1613 public:
1614     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1615 };
1616
1617
1618
1619
1620 //-----------------------------------------------------------------------------
1621 // name: class Chuck_Instr_Chuck_Assign
1622 // desc: ...
1623 //-----------------------------------------------------------------------------
1624 class Chuck_Instr_Chuck_Assign2 : public Chuck_Instr
1625 {
1626 public:
1627     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1628 };
1629
1630
1631
1632
1633 //-----------------------------------------------------------------------------
1634 // name: class Chuck_Instr_Chuck_Assign_Deref
1635 // desc: ...
1636 //-----------------------------------------------------------------------------
1637 class Chuck_Instr_Chuck_Assign_Deref : public Chuck_Instr
1638 {
1639 public:
1640     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1641 };
1642
1643
1644
1645
1646 //-----------------------------------------------------------------------------
1647 // name: class Chuck_Instr_Chuck_Assign_Deref2
1648 // desc: ...
1649 //-----------------------------------------------------------------------------
1650 class Chuck_Instr_Chuck_Assign_Deref2 : public Chuck_Instr
1651 {
1652 public:
1653     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1654 };
1655
1656
1657
1658
1659 //-----------------------------------------------------------------------------
1660 // name: class Chuck_Instr_Chuck_Assign_Object
1661 // desc: ...
1662 //-----------------------------------------------------------------------------
1663 class Chuck_Instr_Chuck_Assign_Object : public Chuck_Instr
1664 {
1665 public:
1666     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1667 };
1668
1669
1670
1671
1672 //-----------------------------------------------------------------------------
1673 // name: class Chuck_Instr_Chuck_Assign_Object_Deref
1674 // desc: ...
1675 //-----------------------------------------------------------------------------
1676 class Chuck_Instr_Chuck_Assign_Object_Deref : public Chuck_Instr
1677 {
1678 public:
1679     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1680 };
1681
1682
1683
1684
1685 //-----------------------------------------------------------------------------
1686 // name: class Chuck_Instr_Chuck_Assign_Object2
1687 // desc: ...
1688 //-----------------------------------------------------------------------------
1689 class Chuck_Instr_Chuck_Assign_Object2 : public Chuck_Instr
1690 {
1691 public:
1692     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1693 };
1694
1695
1696
1697
1698 //-----------------------------------------------------------------------------
1699 // name: class Chuck_Instr_Chuck_Release_Object
1700 // desc: ...
1701 //-----------------------------------------------------------------------------
1702 class Chuck_Instr_Chuck_Release_Object : public Chuck_Instr
1703 {
1704 public:
1705     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1706 };
1707
1708
1709
1710
1711 //-----------------------------------------------------------------------------
1712 // name: class Chuck_Instr_Func_Call
1713 // desc: ...
1714 //-----------------------------------------------------------------------------
1715 class Chuck_Instr_Func_Call : public Chuck_Instr
1716 {
1717 public:
1718     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1719 };
1720
1721
1722
1723
1724 //-----------------------------------------------------------------------------
1725 // name: class Chuck_Instr_Func_Call2
1726 // desc: ...
1727 //-----------------------------------------------------------------------------
1728 class Chuck_Instr_Func_Call2 : public Chuck_Instr
1729 {
1730 public:
1731     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1732 };
1733
1734
1735
1736
1737 //-----------------------------------------------------------------------------
1738 // name: class Chuck_Instr_Func_Call3
1739 // desc: ...
1740 //-----------------------------------------------------------------------------
1741 class Chuck_Instr_Func_Call3 : public Chuck_Instr
1742 {
1743 public:
1744     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1745 };
1746
1747
1748
1749
1750 //-----------------------------------------------------------------------------
1751 // name: class Chuck_Instr_Func_Call0
1752 // desc: ...
1753 //-----------------------------------------------------------------------------
1754 class Chuck_Instr_Func_Call0 : public Chuck_Instr
1755 {
1756 public:
1757     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1758 };
1759
1760
1761
1762
1763 //-----------------------------------------------------------------------------
1764 // name: class Chuck_Instr_Func_Return
1765 // desc: ...
1766 //-----------------------------------------------------------------------------
1767 class Chuck_Instr_Func_Return : public Chuck_Instr
1768 {
1769 public:
1770     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1771 };
1772
1773
1774
1775
1776 //-----------------------------------------------------------------------------
1777 // name: class Chuck_Instr_Spork
1778 // desc: ...
1779 //-----------------------------------------------------------------------------
1780 class Chuck_Instr_Spork : public Chuck_Instr_Unary_Op
1781 {
1782 public:
1783     Chuck_Instr_Spork( uint v = 0 ) { this->set( v ); }
1784 public:
1785     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1786 };
1787
1788
1789
1790
1791 //-----------------------------------------------------------------------------
1792 // name: enum CI_PrintTypeEnum
1793 // desc: ...
1794 //-----------------------------------------------------------------------------
1795 enum CI_PrintTypeEnum
1796 {
1797     cip_int = 1,
1798     cip_uint,
1799     cip_float,
1800     cip_double,
1801     cip_single,
1802     cip_string,
1803     cip_dur,
1804     cip_time,
1805     cip_object
1806 };
1807
1808
1809
1810
1811 //-----------------------------------------------------------------------------
1812 // name: class Chuck_Instr_Print_Console
1813 // desc: ...
1814 //-----------------------------------------------------------------------------
1815 class Chuck_Instr_Print_Console : public Chuck_Instr
1816 {
1817 public:
1818     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1819 };
1820
1821
1822
1823
1824 //-----------------------------------------------------------------------------
1825 // name: class Chuck_Instr_Print_Console2
1826 // desc: ..
1827 //-----------------------------------------------------------------------------
1828 class Chuck_Instr_Print_Console2 : public Chuck_Instr
1829 {
1830 public:
1831     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1832 };
1833
1834
1835
1836
1837 //-----------------------------------------------------------------------------
1838 // name: class Chuck_Instr_Time_Advance
1839 // desc: ...
1840 //-----------------------------------------------------------------------------
1841 class Chuck_Instr_Time_Advance : public Chuck_Instr
1842 {
1843 public:
1844     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1845 };
1846
1847
1848
1849
1850 //-----------------------------------------------------------------------------
1851 // name: class Chuck_Instr_Midi_Out
1852 // desc: ...
1853 //-----------------------------------------------------------------------------
1854 class Chuck_Instr_Midi_Out : public Chuck_Instr_Unary_Op
1855 {
1856 public:
1857     Chuck_Instr_Midi_Out( uint mode )
1858     { this->set(mode); }
1859
1860 public:
1861     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1862 };
1863
1864
1865
1866
1867 //-----------------------------------------------------------------------------
1868 // name: class Chuck_Instr_Midi_Out_Go
1869 // desc: ...
1870 //-----------------------------------------------------------------------------
1871 class Chuck_Instr_Midi_Out_Go : public Chuck_Instr_Unary_Op
1872 {
1873 public:
1874     Chuck_Instr_Midi_Out_Go( uint mode )
1875     { this->set( mode ); }
1876
1877 public:
1878     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1879 };
1880
1881
1882
1883
1884 //-----------------------------------------------------------------------------
1885 // name: class Chuck_Instr_Midi_In
1886 // desc: ...
1887 //-----------------------------------------------------------------------------
1888 class Chuck_Instr_Midi_In : public Chuck_Instr_Unary_Op
1889 {
1890 public:
1891     Chuck_Instr_Midi_In( uint mode )
1892     { this->set(mode); }
1893
1894 public:
1895     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1896 };
1897
1898
1899
1900
1901 //-----------------------------------------------------------------------------
1902 // name: class Chuck_Instr_Midi_In_Go
1903 // desc: ...
1904 //-----------------------------------------------------------------------------
1905 class Chuck_Instr_Midi_In_Go : public Chuck_Instr_Unary_Op
1906 {
1907 public:
1908     Chuck_Instr_Midi_In_Go( uint mode )
1909     { this->set( mode ); }
1910
1911 public:
1912     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1913 };
1914
1915
1916
1917
1918 //-----------------------------------------------------------------------------
1919 // name: class Chuck_Instr_ADC
1920 // desc: ...
1921 //-----------------------------------------------------------------------------
1922 class Chuck_Instr_ADC : public Chuck_Instr
1923 {
1924 public:
1925     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1926 };
1927
1928
1929
1930
1931 //-----------------------------------------------------------------------------
1932 // name: class Chuck_Instr_DAC
1933 // desc: ...
1934 //-----------------------------------------------------------------------------
1935 class Chuck_Instr_DAC : public Chuck_Instr
1936 {
1937 public:
1938     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1939 };
1940
1941
1942
1943
1944 //-----------------------------------------------------------------------------
1945 // name: class Chuck_Instr_Bunghole
1946 // desc: ...
1947 //-----------------------------------------------------------------------------
1948 class Chuck_Instr_Bunghole : public Chuck_Instr
1949 {
1950 public:
1951     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1952 };
1953
1954
1955
1956
1957 //-----------------------------------------------------------------------------
1958 // name: class Chuck_Instr_UGen_Link
1959 // desc: ...
1960 //-----------------------------------------------------------------------------
1961 class Chuck_Instr_UGen_Link : public Chuck_Instr
1962 {
1963 public:
1964     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1965 };
1966
1967
1968
1969
1970 //-----------------------------------------------------------------------------
1971 // name: class Chuck_Instr_UGen_UnLink
1972 // desc: ...
1973 //-----------------------------------------------------------------------------
1974 class Chuck_Instr_UGen_UnLink : public Chuck_Instr
1975 {
1976 public:
1977     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1978 };
1979
1980
1981
1982
1983 //-----------------------------------------------------------------------------
1984 // name: class Chuck_Instr_UGen_Alloc
1985 // desc: ...
1986 //-----------------------------------------------------------------------------
1987 class Chuck_Instr_UGen_Alloc : public Chuck_Instr
1988 {
1989 public:
1990     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
1991 };
1992
1993
1994
1995
1996 //-----------------------------------------------------------------------------
1997 // name: class Chuck_Instr_UGen_DeAlloc
1998 // desc: ...
1999 //-----------------------------------------------------------------------------
2000 class Chuck_Instr_UGen_DeAlloc : public Chuck_Instr
2001 {
2002 public:
2003     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2004 };
2005
2006
2007
2008
2009 //-----------------------------------------------------------------------------
2010 // name: class Chuck_Instr_UGen_Ctrl
2011 // desc: ...
2012 //-----------------------------------------------------------------------------
2013 class Chuck_Instr_UGen_Ctrl : public Chuck_Instr
2014 {
2015 public:
2016     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2017 };
2018
2019
2020
2021
2022 //-----------------------------------------------------------------------------
2023 // name: class Chuck_Instr_UGen_CGet
2024 // desc: ...
2025 //-----------------------------------------------------------------------------
2026 class Chuck_Instr_UGen_CGet : public Chuck_Instr
2027 {
2028 public:
2029     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2030 };
2031
2032
2033
2034
2035 //-----------------------------------------------------------------------------
2036 // name: class Chuck_Instr_UGen_Ctrl2
2037 // desc: ...
2038 //-----------------------------------------------------------------------------
2039 class Chuck_Instr_UGen_Ctrl2 : public Chuck_Instr
2040 {
2041 public:
2042     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2043 };
2044
2045
2046
2047
2048 //-----------------------------------------------------------------------------
2049 // name: class Chuck_Instr_UGen_CGet2
2050 // desc: ...
2051 //-----------------------------------------------------------------------------
2052 class Chuck_Instr_UGen_CGet2 : public Chuck_Instr
2053 {
2054 public:
2055     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2056 };
2057
2058
2059
2060
2061 //-----------------------------------------------------------------------------
2062 // name: class Chuck_Instr_UGen_PMsg
2063 // desc: ...
2064 //-----------------------------------------------------------------------------
2065 class Chuck_Instr_UGen_PMsg : public Chuck_Instr
2066 {
2067 public:
2068     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2069 };
2070
2071
2072
2073
2074 //-----------------------------------------------------------------------------
2075 // name: class Chuck_Instr_UGen_Ctrl_Op
2076 // desc: ...
2077 //-----------------------------------------------------------------------------
2078 class Chuck_Instr_UGen_Ctrl_Op : public Chuck_Instr
2079 {
2080 public:
2081     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2082 };
2083
2084
2085
2086
2087 //-----------------------------------------------------------------------------
2088 // name: class Chuck_Instr_UGen_CGet_Op
2089 // desc: ...
2090 //-----------------------------------------------------------------------------
2091 class Chuck_Instr_UGen_CGet_Op : public Chuck_Instr
2092 {
2093 public:
2094     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2095 };
2096
2097
2098
2099
2100 //-----------------------------------------------------------------------------
2101 // name: class Chuck_Instr_UGen_CGet_Gain
2102 // desc: ...
2103 //-----------------------------------------------------------------------------
2104 class Chuck_Instr_UGen_CGet_Gain : public Chuck_Instr
2105 {
2106 public:
2107     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2108 };
2109
2110
2111
2112
2113 //-----------------------------------------------------------------------------
2114 // name: class Chuck_Instr_UGen_Ctrl_Gain
2115 // desc: ...
2116 //-----------------------------------------------------------------------------
2117 class Chuck_Instr_UGen_Ctrl_Gain : public Chuck_Instr
2118 {
2119 public:
2120     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2121 };
2122
2123
2124
2125
2126 //-----------------------------------------------------------------------------
2127 // name: class Chuck_Instr_UGen_CGet_Last
2128 // desc: ...
2129 //-----------------------------------------------------------------------------
2130 class Chuck_Instr_UGen_CGet_Last : public Chuck_Instr
2131 {
2132 public:
2133     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2134 };
2135
2136
2137
2138
2139 //-----------------------------------------------------------------------------
2140 // name: class Chuck_Instr_DLL_Load
2141 // desc: ...
2142 //-----------------------------------------------------------------------------
2143 class Chuck_Instr_DLL_Load : public Chuck_Instr
2144 {
2145 public:
2146     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2147 };
2148
2149
2150
2151
2152 //-----------------------------------------------------------------------------
2153 // name: class Chuck_Instr_DLL_Unload
2154 // desc: ...
2155 //-----------------------------------------------------------------------------
2156 class Chuck_Instr_DLL_Unload : public Chuck_Instr
2157 {
2158 public:
2159     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2160 };
2161
2162
2163
2164
2165 //-----------------------------------------------------------------------------
2166 // name: class Chuck_Instr_Cast_single2int
2167 // desc: ...
2168 //-----------------------------------------------------------------------------
2169 class Chuck_Instr_Cast_single2int : public Chuck_Instr
2170 {
2171 public:
2172     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2173 };
2174
2175
2176
2177
2178 //-----------------------------------------------------------------------------
2179 // name: class Chuck_Instr_Cast_int2single
2180 // desc: ...
2181 //-----------------------------------------------------------------------------
2182 class Chuck_Instr_Cast_int2single : public Chuck_Instr
2183 {
2184 public:
2185     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2186 };
2187
2188
2189
2190
2191 //-----------------------------------------------------------------------------
2192 // name: class Chuck_Instr_Cast_double2int
2193 // desc: ...
2194 //-----------------------------------------------------------------------------
2195 class Chuck_Instr_Cast_double2int : public Chuck_Instr
2196 {
2197 public:
2198     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2199 };
2200
2201
2202
2203
2204 //-----------------------------------------------------------------------------
2205 // name: class Chuck_Instr_Cast_int2double
2206 // desc: ...
2207 //-----------------------------------------------------------------------------
2208 class Chuck_Instr_Cast_int2double : public Chuck_Instr
2209 {
2210 public:
2211     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2212 };
2213
2214
2215
2216
2217 //-----------------------------------------------------------------------------
2218 // name: class Chuck_Instr_Cast_single2double
2219 // desc: ...
2220 //-----------------------------------------------------------------------------
2221 class Chuck_Instr_Cast_single2double : public Chuck_Instr
2222 {
2223 public:
2224     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2225 };
2226
2227
2228
2229
2230 //-----------------------------------------------------------------------------
2231 // name: class Chuck_Instr_Cast_double2single
2232 // desc: ...
2233 //-----------------------------------------------------------------------------
2234 class Chuck_Instr_Cast_double2single : public Chuck_Instr
2235 {
2236 public:
2237     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
2238 };
2239
2240
2241
2242
2243 #endif