subsystems/ntvdm/registers.c

   1 /*
   2  * COPYRIGHT:       GPL - See COPYING in the top level directory
   3  * PROJECT:         ReactOS Virtual DOS Machine
   4  * FILE:            registers.c
   5  * PURPOSE:         Exported functions for manipulating registers
   6  * PROGRAMMERS:     Hermes Belusca-Maito (hermes.belusca@sfr.fr)
   7  */
   8
   9 /* INCLUDES *******************************************************************/
  10
  11 #define NDEBUG
  12
  13 #include "emulator.h"
  14
  15 /* PUBLIC FUNCTIONS ***********************************************************/
  16
  17 ULONG
  18 CDECL
  19 getEAX(VOID)
  20 {
  21 #ifndef NEW_EMULATOR
  22     return EmulatorContext.state->general_reg[EMULATOR_REG_AX].val;
  23 #else
  24     return EmulatorContext.GeneralRegs[EMULATOR_REG_AX].Long;
  25 #endif
  26 }
  27
  28 VOID
  29 CDECL
  30 setEAX(ULONG Value)
  31 {
  32 #ifndef NEW_EMULATOR
  33     EmulatorContext.state->general_reg[EMULATOR_REG_AX].val = Value;
  34 #else
  35     EmulatorContext.GeneralRegs[EMULATOR_REG_AX].Long = Value;
  36 #endif
  37 }
  38
  39 USHORT
  40 CDECL
  41 getAX(VOID)
  42 {
  43 #ifndef NEW_EMULATOR
  44     return EmulatorContext.state->general_reg[EMULATOR_REG_AX].w.lo;
  45 #else
  46     return EmulatorContext.GeneralRegs[EMULATOR_REG_AX].LowWord;
  47 #endif
  48 }
  49
  50 VOID
  51 CDECL
  52 setAX(USHORT Value)
  53 {
  54 #ifndef NEW_EMULATOR
  55     EmulatorContext.state->general_reg[EMULATOR_REG_AX].w.lo = Value;
  56 #else
  57     EmulatorContext.GeneralRegs[EMULATOR_REG_AX].LowWord = Value;
  58 #endif
  59 }
  60
  61 UCHAR
  62 CDECL
  63 getAH(VOID)
  64 {
  65 #ifndef NEW_EMULATOR
  66     return EmulatorContext.state->general_reg[EMULATOR_REG_AX].b.hi;
  67 #else
  68     return EmulatorContext.GeneralRegs[EMULATOR_REG_AX].HighByte;
  69 #endif
  70 }
  71
  72 VOID
  73 CDECL
  74 setAH(UCHAR Value)
  75 {
  76 #ifndef NEW_EMULATOR
  77     EmulatorContext.state->general_reg[EMULATOR_REG_AX].b.hi = Value;
  78 #else
  79     EmulatorContext.GeneralRegs[EMULATOR_REG_AX].HighByte = Value;
  80 #endif
  81 }
  82
  83 UCHAR
  84 CDECL
  85 getAL(VOID)
  86 {
  87 #ifndef NEW_EMULATOR
  88     return EmulatorContext.state->general_reg[EMULATOR_REG_AX].b.lo;
  89 #else
  90     return EmulatorContext.GeneralRegs[EMULATOR_REG_AX].LowByte;
  91 #endif
  92 }
  93
  94 VOID
  95 CDECL
  96 setAL(UCHAR Value)
  97 {
  98 #ifndef NEW_EMULATOR
  99     EmulatorContext.state->general_reg[EMULATOR_REG_AX].b.lo = Value;
 100 #else
 101     EmulatorContext.GeneralRegs[EMULATOR_REG_AX].LowByte = Value;
 102 #endif
 103 }
 104
 105 ULONG
 106 CDECL
 107 getEBX(VOID)
 108 {
 109 #ifndef NEW_EMULATOR
 110     return EmulatorContext.state->general_reg[EMULATOR_REG_BX].val;
 111 #else
 112     return EmulatorContext.GeneralRegs[EMULATOR_REG_BX].Long;
 113 #endif
 114 }
 115
 116 VOID
 117 CDECL
 118 setEBX(ULONG Value)
 119 {
 120 #ifndef NEW_EMULATOR
 121     EmulatorContext.state->general_reg[EMULATOR_REG_BX].val = Value;
 122 #else
 123     EmulatorContext.GeneralRegs[EMULATOR_REG_BX].Long = Value;
 124 #endif
 125 }
 126
 127 USHORT
 128 CDECL
 129 getBX(VOID)
 130 {
 131 #ifndef NEW_EMULATOR
 132     return EmulatorContext.state->general_reg[EMULATOR_REG_BX].w.lo;
 133 #else
 134     return EmulatorContext.GeneralRegs[EMULATOR_REG_BX].LowWord;
 135 #endif
 136 }
 137
 138 VOID
 139 CDECL
 140 setBX(USHORT Value)
 141 {
 142 #ifndef NEW_EMULATOR
 143     EmulatorContext.state->general_reg[EMULATOR_REG_BX].w.lo = Value;
 144 #else
 145     EmulatorContext.GeneralRegs[EMULATOR_REG_BX].LowWord = Value;
 146 #endif
 147 }
 148
 149 UCHAR
 150 CDECL
 151 getBH(VOID)
 152 {
 153 #ifndef NEW_EMULATOR
 154     return EmulatorContext.state->general_reg[EMULATOR_REG_BX].b.hi;
 155 #else
 156     return EmulatorContext.GeneralRegs[EMULATOR_REG_BX].HighByte;
 157 #endif
 158 }
 159
 160 VOID
 161 CDECL
 162 setBH(UCHAR Value)
 163 {
 164 #ifndef NEW_EMULATOR
 165     EmulatorContext.state->general_reg[EMULATOR_REG_BX].b.hi = Value;
 166 #else
 167     EmulatorContext.GeneralRegs[EMULATOR_REG_BX].HighByte = Value;
 168 #endif
 169 }
 170
 171 UCHAR
 172 CDECL
 173 getBL(VOID)
 174 {
 175 #ifndef NEW_EMULATOR
 176     return EmulatorContext.state->general_reg[EMULATOR_REG_BX].b.lo;
 177 #else
 178     return EmulatorContext.GeneralRegs[EMULATOR_REG_BX].LowByte;
 179 #endif
 180 }
 181
 182 VOID
 183 CDECL
 184 setBL(UCHAR Value)
 185 {
 186 #ifndef NEW_EMULATOR
 187     EmulatorContext.state->general_reg[EMULATOR_REG_BX].b.lo = Value;
 188 #else
 189     EmulatorContext.GeneralRegs[EMULATOR_REG_BX].LowByte = Value;
 190 #endif
 191 }
 192
 193
 194
 195 ULONG
 196 CDECL
 197 getECX(VOID)
 198 {
 199 #ifndef NEW_EMULATOR
 200     return EmulatorContext.state->general_reg[EMULATOR_REG_CX].val;
 201 #else
 202     return EmulatorContext.GeneralRegs[EMULATOR_REG_CX].Long;
 203 #endif
 204 }
 205
 206 VOID
 207 CDECL
 208 setECX(ULONG Value)
 209 {
 210 #ifndef NEW_EMULATOR
 211     EmulatorContext.state->general_reg[EMULATOR_REG_CX].val = Value;
 212 #else
 213     EmulatorContext.GeneralRegs[EMULATOR_REG_CX].Long = Value;
 214 #endif
 215 }
 216
 217 USHORT
 218 CDECL
 219 getCX(VOID)
 220 {
 221 #ifndef NEW_EMULATOR
 222     return EmulatorContext.state->general_reg[EMULATOR_REG_CX].w.lo;
 223 #else
 224     return EmulatorContext.GeneralRegs[EMULATOR_REG_CX].LowWord;
 225 #endif
 226 }
 227
 228 VOID
 229 CDECL
 230 setCX(USHORT Value)
 231 {
 232 #ifndef NEW_EMULATOR
 233     EmulatorContext.state->general_reg[EMULATOR_REG_CX].w.lo = Value;
 234 #else
 235     EmulatorContext.GeneralRegs[EMULATOR_REG_CX].LowWord = Value;
 236 #endif
 237 }
 238
 239 UCHAR
 240 CDECL
 241 getCH(VOID)
 242 {
 243 #ifndef NEW_EMULATOR
 244     return EmulatorContext.state->general_reg[EMULATOR_REG_CX].b.hi;
 245 #else
 246     return EmulatorContext.GeneralRegs[EMULATOR_REG_CX].HighByte;
 247 #endif
 248 }
 249
 250 VOID
 251 CDECL
 252 setCH(UCHAR Value)
 253 {
 254 #ifndef NEW_EMULATOR
 255     EmulatorContext.state->general_reg[EMULATOR_REG_CX].b.hi = Value;
 256 #else
 257     EmulatorContext.GeneralRegs[EMULATOR_REG_CX].HighByte = Value;
 258 #endif
 259 }
 260
 261 UCHAR
 262 CDECL
 263 getCL(VOID)
 264 {
 265 #ifndef NEW_EMULATOR
 266     return EmulatorContext.state->general_reg[EMULATOR_REG_CX].b.lo;
 267 #else
 268     return EmulatorContext.GeneralRegs[EMULATOR_REG_CX].LowByte;
 269 #endif
 270 }
 271
 272 VOID
 273 CDECL
 274 setCL(UCHAR Value)
 275 {
 276 #ifndef NEW_EMULATOR
 277     EmulatorContext.state->general_reg[EMULATOR_REG_CX].b.lo = Value;
 278 #else
 279     EmulatorContext.GeneralRegs[EMULATOR_REG_CX].LowByte = Value;
 280 #endif
 281 }
 282
 283
 284
 285 ULONG
 286 CDECL
 287 getEDX(VOID)
 288 {
 289 #ifndef NEW_EMULATOR
 290     return EmulatorContext.state->general_reg[EMULATOR_REG_DX].val;
 291 #else
 292     return EmulatorContext.GeneralRegs[EMULATOR_REG_DX].Long;
 293 #endif
 294 }
 295
 296 VOID
 297 CDECL
 298 setEDX(ULONG Value)
 299 {
 300 #ifndef NEW_EMULATOR
 301     EmulatorContext.state->general_reg[EMULATOR_REG_DX].val = Value;
 302 #else
 303     EmulatorContext.GeneralRegs[EMULATOR_REG_DX].Long = Value;
 304 #endif
 305 }
 306
 307 USHORT
 308 CDECL
 309 getDX(VOID)
 310 {
 311 #ifndef NEW_EMULATOR
 312     return EmulatorContext.state->general_reg[EMULATOR_REG_DX].w.lo;
 313 #else
 314     return EmulatorContext.GeneralRegs[EMULATOR_REG_DX].LowWord;
 315 #endif
 316 }
 317
 318 VOID
 319 CDECL
 320 setDX(USHORT Value)
 321 {
 322 #ifndef NEW_EMULATOR
 323     EmulatorContext.state->general_reg[EMULATOR_REG_DX].w.lo = Value;
 324 #else
 325     EmulatorContext.GeneralRegs[EMULATOR_REG_DX].LowWord = Value;
 326 #endif
 327 }
 328
 329 UCHAR
 330 CDECL
 331 getDH(VOID)
 332 {
 333 #ifndef NEW_EMULATOR
 334     return EmulatorContext.state->general_reg[EMULATOR_REG_DX].b.hi;
 335 #else
 336     return EmulatorContext.GeneralRegs[EMULATOR_REG_DX].HighByte;
 337 #endif
 338 }
 339
 340 VOID
 341 CDECL
 342 setDH(UCHAR Value)
 343 {
 344 #ifndef NEW_EMULATOR
 345     EmulatorContext.state->general_reg[EMULATOR_REG_DX].b.hi = Value;
 346 #else
 347     EmulatorContext.GeneralRegs[EMULATOR_REG_DX].HighByte = Value;
 348 #endif
 349 }
 350
 351 UCHAR
 352 CDECL
 353 getDL(VOID)
 354 {
 355 #ifndef NEW_EMULATOR
 356     return EmulatorContext.state->general_reg[EMULATOR_REG_DX].b.lo;
 357 #else
 358     return EmulatorContext.GeneralRegs[EMULATOR_REG_DX].LowByte;
 359 #endif
 360 }
 361
 362 VOID
 363 CDECL
 364 setDL(UCHAR Value)
 365 {
 366 #ifndef NEW_EMULATOR
 367     EmulatorContext.state->general_reg[EMULATOR_REG_DX].b.lo = Value;
 368 #else
 369     EmulatorContext.GeneralRegs[EMULATOR_REG_DX].LowByte = Value;
 370 #endif
 371 }
 372
 373
 374
 375 ULONG
 376 CDECL
 377 getESP(VOID)
 378 {
 379     return EmulatorGetRegister(EMULATOR_REG_SP);
 380 }
 381
 382 VOID
 383 CDECL
 384 setESP(ULONG Value)
 385 {
 386     EmulatorSetStack(EmulatorGetRegister(EMULATOR_REG_SS), Value);
 387 }
 388
 389 USHORT
 390 CDECL
 391 getSP(VOID)
 392 {
 393     return LOWORD(EmulatorGetRegister(EMULATOR_REG_SP));
 394 }
 395
 396 VOID
 397 CDECL
 398 setSP(USHORT Value)
 399 {
 400     EmulatorSetStack(EmulatorGetRegister(EMULATOR_REG_SS), Value);
 401 }
 402
 403
 404
 405 ULONG
 406 CDECL
 407 getEBP(VOID)
 408 {
 409 #ifndef NEW_EMULATOR
 410     return EmulatorContext.state->general_reg[EMULATOR_REG_BP].val;
 411 #else
 412     return EmulatorContext.GeneralRegs[EMULATOR_REG_BP].Long;
 413 #endif
 414 }
 415
 416 VOID
 417 CDECL
 418 setEBP(ULONG Value)
 419 {
 420 #ifndef NEW_EMULATOR
 421     EmulatorContext.state->general_reg[EMULATOR_REG_BP].val = Value;
 422 #else
 423     EmulatorContext.GeneralRegs[EMULATOR_REG_BP].Long = Value;
 424 #endif
 425 }
 426
 427 USHORT
 428 CDECL
 429 getBP(VOID)
 430 {
 431 #ifndef NEW_EMULATOR
 432     return EmulatorContext.state->general_reg[EMULATOR_REG_BP].w.lo;
 433 #else
 434     return EmulatorContext.GeneralRegs[EMULATOR_REG_BP].LowWord;
 435 #endif
 436 }
 437
 438 VOID
 439 CDECL
 440 setBP(USHORT Value)
 441 {
 442 #ifndef NEW_EMULATOR
 443     EmulatorContext.state->general_reg[EMULATOR_REG_BP].w.lo = Value;
 444 #else
 445     EmulatorContext.GeneralRegs[EMULATOR_REG_BP].LowWord = Value;
 446 #endif
 447 }
 448
 449
 450
 451 ULONG
 452 CDECL
 453 getESI(VOID)
 454 {
 455 #ifndef NEW_EMULATOR
 456     return EmulatorContext.state->general_reg[EMULATOR_REG_SI].val;
 457 #else
 458     return EmulatorContext.GeneralRegs[EMULATOR_REG_SI].Long;
 459 #endif
 460 }
 461
 462 VOID
 463 CDECL
 464 setESI(ULONG Value)
 465 {
 466 #ifndef NEW_EMULATOR
 467     EmulatorContext.state->general_reg[EMULATOR_REG_SI].val = Value;
 468 #else
 469     EmulatorContext.GeneralRegs[EMULATOR_REG_SI].Long = Value;
 470 #endif
 471 }
 472
 473 USHORT
 474 CDECL
 475 getSI(VOID)
 476 {
 477 #ifndef NEW_EMULATOR
 478     return EmulatorContext.state->general_reg[EMULATOR_REG_SI].w.lo;
 479 #else
 480     return EmulatorContext.GeneralRegs[EMULATOR_REG_SI].LowWord;
 481 #endif
 482 }
 483
 484 VOID
 485 CDECL
 486 setSI(USHORT Value)
 487 {
 488 #ifndef NEW_EMULATOR
 489     EmulatorContext.state->general_reg[EMULATOR_REG_SI].w.lo = Value;
 490 #else
 491     EmulatorContext.GeneralRegs[EMULATOR_REG_SI].LowWord = Value;
 492 #endif
 493 }
 494
 495
 496
 497 ULONG
 498 CDECL
 499 getEDI(VOID)
 500 {
 501 #ifndef NEW_EMULATOR
 502     return EmulatorContext.state->general_reg[EMULATOR_REG_DI].val;
 503 #else
 504     return EmulatorContext.GeneralRegs[EMULATOR_REG_DI].Long;
 505 #endif
 506 }
 507
 508 VOID
 509 CDECL
 510 setEDI(ULONG Value)
 511 {
 512 #ifndef NEW_EMULATOR
 513     EmulatorContext.state->general_reg[EMULATOR_REG_DI].val = Value;
 514 #else
 515     EmulatorContext.GeneralRegs[EMULATOR_REG_DI].Long = Value;
 516 #endif
 517 }
 518
 519 USHORT
 520 CDECL
 521 getDI(VOID)
 522 {
 523 #ifndef NEW_EMULATOR
 524     return EmulatorContext.state->general_reg[EMULATOR_REG_DI].w.lo;
 525 #else
 526     return EmulatorContext.GeneralRegs[EMULATOR_REG_DI].LowWord;
 527 #endif
 528 }
 529
 530 VOID
 531 CDECL
 532 setDI(USHORT Value)
 533 {
 534 #ifndef NEW_EMULATOR
 535     EmulatorContext.state->general_reg[EMULATOR_REG_DI].w.lo = Value;
 536 #else
 537     EmulatorContext.GeneralRegs[EMULATOR_REG_DI].LowWord = Value;
 538 #endif
 539 }
 540
 541
 542
 543 ULONG
 544 CDECL
 545 getEIP(VOID)
 546 {
 547     return EmulatorGetProgramCounter();
 548 }
 549
 550 VOID
 551 CDECL
 552 setEIP(ULONG Value)
 553 {
 554     EmulatorExecute(EmulatorGetRegister(EMULATOR_REG_CS), Value);
 555 }
 556
 557 USHORT
 558 CDECL
 559 getIP(VOID)
 560 {
 561     return LOWORD(EmulatorGetProgramCounter());
 562 }
 563
 564 VOID
 565 CDECL
 566 setIP(USHORT Value)
 567 {
 568     EmulatorExecute(EmulatorGetRegister(EMULATOR_REG_CS), Value);
 569 }
 570
 571
 572
 573 USHORT
 574 CDECL
 575 getCS(VOID)
 576 {
 577     return EmulatorGetRegister(EMULATOR_REG_CS);
 578 }
 579
 580 VOID
 581 CDECL
 582 setCS(USHORT Value)
 583 {
 584     EmulatorSetRegister(EMULATOR_REG_CS, Value);
 585 }
 586
 587 USHORT
 588 CDECL
 589 getSS(VOID)
 590 {
 591     return EmulatorGetRegister(EMULATOR_REG_SS);
 592 }
 593
 594 VOID
 595 CDECL
 596 setSS(USHORT Value)
 597 {
 598     EmulatorSetRegister(EMULATOR_REG_SS, Value);
 599 }
 600
 601 USHORT
 602 CDECL
 603 getDS(VOID)
 604 {
 605     return EmulatorGetRegister(EMULATOR_REG_DS);
 606 }
 607
 608 VOID
 609 CDECL
 610 setDS(USHORT Value)
 611 {
 612     EmulatorSetRegister(EMULATOR_REG_DS, Value);
 613 }
 614
 615 USHORT
 616 CDECL
 617 getES(VOID)
 618 {
 619     return EmulatorGetRegister(EMULATOR_REG_ES);
 620 }
 621
 622 VOID
 623 CDECL
 624 setES(USHORT Value)
 625 {
 626     EmulatorSetRegister(EMULATOR_REG_ES, Value);
 627 }
 628
 629 USHORT
 630 CDECL
 631 getFS(VOID)
 632 {
 633     return EmulatorGetRegister(EMULATOR_REG_FS);
 634 }
 635
 636 VOID
 637 CDECL
 638 setFS(USHORT Value)
 639 {
 640     EmulatorSetRegister(EMULATOR_REG_FS, Value);
 641 }
 642
 643 USHORT
 644 CDECL
 645 getGS(VOID)
 646 {
 647     return EmulatorGetRegister(EMULATOR_REG_GS);
 648 }
 649
 650 VOID
 651 CDECL
 652 setGS(USHORT Value)
 653 {
 654     EmulatorSetRegister(EMULATOR_REG_GS, Value);
 655 }
 656
 657
 658
 659 ULONG
 660 CDECL
 661 getCF(VOID)
 662 {
 663     return EmulatorGetFlag(EMULATOR_FLAG_CF);
 664 }
 665
 666 VOID
 667 CDECL
 668 setCF(ULONG Flag)
 669 {
 670     if (Flag & 1)
 671         EmulatorSetFlag(EMULATOR_FLAG_CF);
 672     else
 673         EmulatorClearFlag(EMULATOR_FLAG_CF);
 674 }
 675
 676 ULONG
 677 CDECL
 678 getPF(VOID)
 679 {
 680     return EmulatorGetFlag(EMULATOR_FLAG_PF);
 681 }
 682
 683 VOID
 684 CDECL
 685 setPF(ULONG Flag)
 686 {
 687     if (Flag & 1)
 688         EmulatorSetFlag(EMULATOR_FLAG_PF);
 689     else
 690         EmulatorClearFlag(EMULATOR_FLAG_PF);
 691 }
 692
 693 ULONG
 694 CDECL
 695 getAF(VOID)
 696 {
 697     return EmulatorGetFlag(EMULATOR_FLAG_AF);
 698 }
 699
 700 VOID
 701 CDECL
 702 setAF(ULONG Flag)
 703 {
 704     if (Flag & 1)
 705         EmulatorSetFlag(EMULATOR_FLAG_AF);
 706     else
 707         EmulatorClearFlag(EMULATOR_FLAG_AF);
 708 }
 709
 710 ULONG
 711 CDECL
 712 getZF(VOID)
 713 {
 714     return EmulatorGetFlag(EMULATOR_FLAG_ZF);
 715 }
 716
 717 VOID
 718 CDECL
 719 setZF(ULONG Flag)
 720 {
 721     if (Flag & 1)
 722         EmulatorSetFlag(EMULATOR_FLAG_ZF);
 723     else
 724         EmulatorClearFlag(EMULATOR_FLAG_ZF);
 725 }
 726
 727 ULONG
 728 CDECL
 729 getSF(VOID)
 730 {
 731     return EmulatorGetFlag(EMULATOR_FLAG_SF);
 732 }
 733
 734 VOID
 735 CDECL
 736 setSF(ULONG Flag)
 737 {
 738     if (Flag & 1)
 739         EmulatorSetFlag(EMULATOR_FLAG_SF);
 740     else
 741         EmulatorClearFlag(EMULATOR_FLAG_SF);
 742 }
 743
 744 ULONG
 745 CDECL
 746 getIF(VOID)
 747 {
 748     return EmulatorGetFlag(EMULATOR_FLAG_IF);
 749 }
 750
 751 VOID
 752 CDECL
 753 setIF(ULONG Flag)
 754 {
 755     if (Flag & 1)
 756         EmulatorSetFlag(EMULATOR_FLAG_IF);
 757     else
 758         EmulatorClearFlag(EMULATOR_FLAG_IF);
 759 }
 760
 761 ULONG
 762 CDECL
 763 getDF(VOID)
 764 {
 765     return EmulatorGetFlag(EMULATOR_FLAG_DF);
 766 }
 767
 768 VOID
 769 CDECL
 770 setDF(ULONG Flag)
 771 {
 772     if (Flag & 1)
 773         EmulatorSetFlag(EMULATOR_FLAG_DF);
 774     else
 775         EmulatorClearFlag(EMULATOR_FLAG_DF);
 776 }
 777
 778 ULONG
 779 CDECL
 780 getOF(VOID)
 781 {
 782     return EmulatorGetFlag(EMULATOR_FLAG_OF);
 783 }
 784
 785 VOID
 786 CDECL
 787 setOF(ULONG Flag)
 788 {
 789     if (Flag & 1)
 790         EmulatorSetFlag(EMULATOR_FLAG_OF);
 791     else
 792         EmulatorClearFlag(EMULATOR_FLAG_OF);
 793 }
 794
 795
 796
 797 USHORT
 798 CDECL
 799 getMSW(VOID)
 800 {
 801     return 0; // UNIMPLEMENTED
 802 }
 803
 804 VOID
 805 CDECL
 806 setMSW(USHORT Value)
 807 {
 808     // UNIMPLEMENTED
 809 }
 810
 811 /* EOF */