MSP430-FORTH/TESTXASM.F

   1 \ -*- coding: utf-8 -*-
   2
   3 ; -----------------------------------------------------------------------
   4 ; TESTXASM.f
   5 ; -----------------------------------------------------------------------
   6 \
   7 \ TARGET SELECTION ( = the name of \INC\target.pat file without the extension)
   8 \ MSP_EXP430FR5969    MSP_EXP430FR5994    MSP_EXP430FR6989
   9 \ MSP_EXP430FR2355
  10 \ from scite editor : copy your target selection in (shift+F8) parameter 1:
  11 \
  12 \ OR
  13 \
  14 \ drag and drop this file onto SendSourceFileToTarget.bat
  15 \ then select your TARGET when asked.
  16 \
  17 \
  18 \ PUSHM order : PSP,TOS, IP,  S,  T,  W,  X,  Y, rEXIT,rDOVAR,rDOCON, rDODOES, R3, SR,RSP, PC
  19 \ PUSHM order : R15,R14,R13,R12,R11,R10, R9, R8,  R7  ,  R6  ,  R5  ,   R4   , R3, R2, R1, R0
  20 \
  21 \ example : PUSHM #6,IP pushes IP,S,T,W,X,Y registers to return stack
  22 \
  23 \ POPM  order :  PC,RSP, SR, R3, rDODOES,rDOCON,rDOVAR,rEXIT,  Y,  X,  W,  T,  S, IP,TOS,PSP
  24 \ POPM  order :  R0, R1, R2, R3,   R4   ,  R5  ,  R6  ,  R7 , R8, R9,R10,R11,R12,R13,R14,R15
  25 \
  26 \ example : POPM #6,IP   pop Y,X,W,T,S,IP registers from return stack
  27 \
  28 \ ASSEMBLER conditionnal usage after IF UNTIL WHILE : S< S>= U< U>= 0= 0<> 0>=
  29 \ ASSEMBLER conditionnal usage before ?JMP ?GOTO    : S< S>= U< U>= 0= 0<> 0<
  30 \
  31 \ FORTH conditionnal    : 0= 0< = < > U<
  32
  33     CODE ABORT_TEST_ASMX
  34     SUB #2,PSP
  35     MOV TOS,0(PSP)
  36     MOV &VERSION,TOS
  37     SUB #400,TOS        \ FastForth V4.0
  38     COLON
  39     'CR' EMIT            \ return to column 1 without 'LF'
  40     ABORT" FastForth V4.0 please!"
  41     RST_RET              \ remove ABORT_TEST_ASM definition before resuming
  42     ;
  43
  44     ABORT_TEST_ASMX      \ abort test
  45
  46     MARKER {TEST_ASMX}
  47
  48 \ https://forth-standard.org/standard/core/Plus
  49 \ +       n1/u1 n2/u2 -- n3/u3     add n1+n2
  50     [UNDEFINED] +
  51     [IF]
  52     CODE +
  53     ADD @PSP+,TOS
  54     MOV @IP+,PC
  55     ENDCODE
  56     [THEN]
  57
  58 \ https://forth-standard.org/standard/core/Minus
  59 \ -      n1/u1 n2/u2 -- n3/u3     n3 = n1-n2
  60     [UNDEFINED] -
  61     [IF]
  62     CODE -
  63     SUB @PSP+,TOS   \ 2  -- n2-n1 ( = -n3)
  64     XOR #-1,TOS     \ 1
  65     ADD #1,TOS      \ 1  -- n3 = -(n2-n1) = n1-n2
  66     MOV @IP+,PC
  67     ENDCODE
  68     [THEN]
  69
  70     [UNDEFINED] MAX
  71     [IF]    \ define MAX and MIN
  72     CODE MAX    \    n1 n2 -- n3       signed maximum
  73     CMP @PSP,TOS    \ n2-n1
  74     S<  ?GOTO FW1   \ n2<n1
  75 BW1 ADD #2,PSP
  76     MOV @IP+,PC
  77     ENDCODE
  78
  79     CODE MIN    \    n1 n2 -- n3       signed minimum
  80     CMP @PSP,TOS     \ n2-n1
  81     S<  ?GOTO BW1    \ n2<n1
  82 FW1 MOV @PSP+,TOS
  83     MOV @IP+,PC
  84     ENDCODE
  85     [THEN]
  86
  87 \ https://forth-standard.org/standard/core/CFetch
  88 \ C@     c-addr -- char   fetch char from memory
  89     [UNDEFINED] C@
  90     [IF]
  91     CODE C@
  92     MOV.B @TOS,TOS
  93     MOV @IP+,PC
  94     ENDCODE
  95     [THEN]
  96
  97 \ https://forth-standard.org/standard/core/CONSTANT
  98 \ CONSTANT <name>     n --                      define a Forth CONSTANT
  99     [UNDEFINED] CONSTANT
 100     [IF]
 101     : CONSTANT
 102     CREATE
 103     HI2LO
 104     MOV TOS,-2(W)           \   PFA = n
 105     MOV @PSP+,TOS
 106     MOV @RSP+,IP
 107     MOV @IP+,PC
 108     ENDCODE
 109     [THEN]
 110
 111 \ https://forth-standard.org/standard/core/SPACE
 112 \ SPACE   --               output a space
 113     [UNDEFINED] SPACE
 114     [IF]
 115     : SPACE
 116     $20 EMIT ;
 117     [THEN]
 118
 119 \ https://forth-standard.org/standard/core/SPACES
 120 \ SPACES   n --            output n spaces
 121     [UNDEFINED] SPACES
 122     [IF]
 123     CODE SPACES
 124     CMP #0,TOS
 125     0<> IF
 126         PUSH IP
 127         BEGIN
 128             LO2HI
 129             $20 EMIT
 130             HI2LO
 131             SUB #2,IP
 132             SUB #1,TOS
 133         0= UNTIL
 134         MOV @RSP+,IP
 135     THEN
 136     MOV @PSP+,TOS           \ --         drop n
 137     NEXT
 138     ENDCODE
 139     [THEN]
 140
 141 \ https://forth-standard.org/standard/core/OVER
 142 \ OVER    x1 x2 -- x1 x2 x1
 143     [UNDEFINED] OVER
 144     [IF]
 145     CODE OVER
 146     MOV TOS,-2(PSP)     \ 3 -- x1 (x2) x2
 147     MOV @PSP,TOS        \ 2 -- x1 (x2) x1
 148     SUB #2,PSP          \ 1 -- x1 x2 x1
 149     MOV @IP+,PC
 150     ENDCODE
 151     [THEN]
 152
 153 \ https://forth-standard.org/standard/core/SWAP
 154 \ SWAP     x1 x2 -- x2 x1    swap top two items
 155     [UNDEFINED] SWAP
 156     [IF]
 157     CODE SWAP
 158     MOV @PSP,W      \ 2
 159     MOV TOS,0(PSP)  \ 3
 160     MOV W,TOS       \ 1
 161     MOV @IP+,PC     \ 4
 162     ENDCODE
 163     [THEN]
 164
 165 \ https://forth-standard.org/standard/core/toR
 166 \ >R    x --   R: -- x   push to return stack
 167     [UNDEFINED] >R
 168     [IF]
 169     CODE >R
 170     PUSH TOS
 171     MOV @PSP+,TOS
 172     MOV @IP+,PC
 173     ENDCODE
 174     [THEN]
 175
 176 \ https://forth-standard.org/standard/core/Rfrom
 177 \ R>    -- x    R: x --   pop from return stack ; CALL #RFROM performs DOVAR
 178     [UNDEFINED] R>
 179     [IF]
 180     CODE R>
 181     SUB #2,PSP      \ 1
 182     MOV TOS,0(PSP)  \ 3
 183     MOV @RSP+,TOS   \ 2
 184     MOV @IP+,PC     \ 4
 185     ENDCODE
 186     [THEN]
 187
 188     [UNDEFINED] U.R
 189     [IF]        \ defined in {UTILITY}
 190     : U.R       \ u n --           display u unsigned in n width (n >= 2)
 191     >R  <# 0 # #S #>
 192     R> OVER - 0 MAX SPACES TYPE
 193     ;
 194     [THEN]
 195
 196     [UNDEFINED] DO
 197     [IF]     \ define DO LOOP +LOOP
 198
 199 \ https://forth-standard.org/standard/core/DO
 200 \ DO       -- DOadr   L: -- 0
 201     HDNCODE XDO         \ DO run time
 202     MOV #$8000,X        \ 2 compute 8000h-limit = "fudge factor"
 203     SUB @PSP+,X         \ 2
 204     MOV TOS,Y           \ 1 loop ctr = index+fudge
 205     ADD X,Y             \ 1 Y = INDEX
 206     PUSHM #2,X          \ 4 PUSHM X,Y, i.e. PUSHM LIMIT, INDEX
 207     MOV @PSP+,TOS       \ 2
 208     MOV @IP+,PC         \ 4
 209     ENDCODE
 210
 211     CODE DO
 212     SUB #2,PSP          \
 213     MOV TOS,0(PSP)      \
 214     ADD #2,&DP          \   make room to compile xdo
 215     MOV &DP,TOS         \ -- HERE+2
 216     MOV #XDO,-2(TOS)    \   compile xdo
 217     ADD #2,&LEAVEPTR    \ -- HERE+2     LEAVEPTR+2
 218     MOV &LEAVEPTR,W     \
 219     MOV #0,0(W)         \ -- HERE+2     L-- 0, init
 220     MOV @IP+,PC
 221     ENDCODE IMMEDIATE
 222
 223 \ https://forth-standard.org/standard/core/LOOP
 224 \ LOOP    DOadr --         L-- an an-1 .. a1 0
 225     HDNCODE XLOOP       \   LOOP run time
 226     ADD #1,0(RSP)       \ 4 increment INDEX
 227 BW1 BIT #$100,SR        \ 2 is overflow bit set?
 228     0= IF               \   branch if no overflow
 229         MOV @IP,IP
 230         MOV @IP+,PC
 231     THEN
 232     ADD #4,RSP          \ 1 empties RSP
 233     ADD #2,IP           \ 1 overflow = loop done, skip branch ofs
 234     MOV @IP+,PC         \ 4 14~ taken or not taken xloop/loop
 235     ENDCODE             \
 236
 237     CODE LOOP
 238     MOV #XLOOP,X
 239 BW2 ADD #4,&DP          \ make room to compile two words
 240     MOV &DP,W
 241     MOV X,-4(W)         \ xloop --> HERE
 242     MOV TOS,-2(W)       \ DOadr --> HERE+2
 243     BEGIN                   \ resolve all "leave" adr
 244         MOV &LEAVEPTR,TOS   \ -- Adr of top LeaveStack cell
 245         SUB #2,&LEAVEPTR    \ --
 246         MOV @TOS,TOS        \ -- first LeaveStack value
 247         CMP #0,TOS          \ -- = value left by DO ?
 248     0<> WHILE
 249         MOV W,0(TOS)        \ move adr after loop as UNLOOP adr
 250     REPEAT
 251     MOV @PSP+,TOS
 252     MOV @IP+,PC
 253     ENDCODE IMMEDIATE
 254
 255 \ https://forth-standard.org/standard/core/PlusLOOP
 256 \ +LOOP   adrs --   L-- an an-1 .. a1 0
 257     HDNCODE XPLOO   \   +LOOP run time
 258     ADD TOS,0(RSP)  \ 4 increment INDEX by TOS value
 259     MOV @PSP+,TOS   \ 2 get new TOS, doesn't change flags
 260     GOTO BW1        \ 2
 261     ENDCODE         \
 262
 263     CODE +LOOP
 264     MOV #XPLOO,X
 265     GOTO BW2
 266     ENDCODE IMMEDIATE
 267     [THEN]
 268
 269 \ https://forth-standard.org/standard/core/I
 270 \ I        -- n   R: sys1 sys2 -- sys1 sys2
 271 \                  get the innermost loop index
 272     [UNDEFINED] I
 273     [IF]
 274     CODE I
 275     SUB #2,PSP              \ 1 make room in TOS
 276     MOV TOS,0(PSP)          \ 3
 277     MOV @RSP,TOS            \ 2 index = loopctr - fudge
 278     SUB 2(RSP),TOS          \ 3
 279     MOV @IP+,PC             \ 4 13~
 280     ENDCODE
 281     [THEN]
 282
 283 \ https://forth-standard.org/standard/core/CR
 284 \ CR      --               send CR+LF to the output device
 285     [UNDEFINED] CR
 286     [IF]
 287 \    DEFER CR    \ DEFERed definition, by default executes that of :NONAME
 288 \ create a primary defered word, i.e. with its default runtime beginning at the >BODY of the definition
 289     CODE CR     \ part I : DEFERed definition of CR
 290     MOV #NEXT_ADR,PC                \ [PFA] = NEXT_ADR
 291     ENDCODE
 292
 293     :NONAME
 294     'CR' EMIT 'LF' EMIT
 295     ; IS CR
 296     [THEN]
 297
 298 \ https://forth-standard.org/standard/core/BASE
 299 \ BASE    -- a-addr       holds conversion radix
 300     [UNDEFINED] BASE
 301     [IF]
 302     BASEADR  CONSTANT BASE
 303     [THEN]
 304
 305 \ https://forth-standard.org/standard/tools/DUMP
 306     [UNDEFINED] DUMP
 307     [IF]       \ defined in {UTILITY}
 308     CODE DUMP                   \ adr n  --   dump memory
 309     PUSH IP
 310     PUSH &BASE                  \ save current base
 311     MOV #$10,&BASE              \ HEX base
 312     ADD @PSP,TOS                \ -- ORG END
 313     LO2HI
 314     SWAP                      \ -- END ORG
 315     DO  CR                    \ generate line
 316         I 4 U.R SPACE           \ generate address
 317         I 8 + I
 318         DO I C@ 3 U.R LOOP
 319         SPACE
 320         I $10 + I 8 +
 321         DO I C@ 3 U.R LOOP
 322         SPACE SPACE
 323         I $10 + I             \ display 16 chars
 324         DO I C@ $7E MIN $20 MAX EMIT LOOP
 325     $10 +LOOP
 326     R> BASE !               \ restore current base
 327     ;
 328     [THEN]
 329
 330     [UNDEFINED] HERE
 331     [IF]
 332     CODE HERE
 333     MOV #BEGIN,PC
 334     ENDCODE
 335     [THEN]
 336
 337     RST_SET
 338
 339
 340     ECHO
 341
 342 ; -----------------------------------------------------------------------------
 343 ; DTCforthMSP430FR5xxx ASSEMBLER: CALLA (without extended word)
 344 ; -----------------------------------------------------------------------------
 345 ; absolute and immediate instructs. must be written as $x.xxxx (DOUBLE numbers)
 346 ; indexed instructions must be written as $xxxx(REG) (single numbers)
 347 ; -----------------------------------------------------------------------------
 348
 349 HERE
 350 CODE TT
 351 CALLA W
 352 ENDCODE
 353 HERE OVER - DUMP
 354 ; you should see:       4A 13
 355 RST_RET
 356
 357 HERE
 358 CODE TT
 359 CALLA $3456(W)
 360 ENDCODE
 361 HERE OVER - DUMP
 362 ; you should see:       5A 13  56 34
 363 RST_RET
 364
 365 HERE
 366 CODE TT
 367 CALLA 0(PSP)
 368 ENDCODE
 369 HERE OVER - DUMP
 370 ; you should see:       5F 13  00 00
 371 RST_RET
 372
 373 HERE
 374 CODE TT
 375 CALLA @W
 376 ENDCODE
 377 HERE OVER - DUMP
 378 ; you should see:       6A 13
 379 RST_RET
 380
 381 HERE
 382 CODE TT
 383 CALLA @PSP
 384 ENDCODE
 385 HERE OVER - DUMP
 386 ; you should see:       6F 13
 387 RST_RET
 388
 389 HERE
 390 CODE TT
 391 CALLA @W+
 392 ENDCODE
 393 HERE OVER - DUMP
 394 ; you should see:       7A 13
 395 RST_RET
 396
 397 HERE
 398 CODE TT
 399 CALLA &$2.3456
 400 ENDCODE
 401 HERE OVER - DUMP
 402 ; you should see:       82 13  56 34
 403 RST_RET
 404
 405 HERE
 406 CODE TT
 407 CALLA #$5.6789
 408 ENDCODE
 409 HERE OVER - DUMP
 410 ; you should see:       B5 13  89 67
 411 RST_RET
 412
 413 ; -----------------------------------------------------------------------------
 414 ; DTCforthMSP430FR5xxx ASSEMBLER, OPCODES IV : Adda|Cmpa|Mova|Suba
 415 ; -----------------------------------------------------------------------------
 416 ; absolute and immediate instructs. must be written as $x.xxxx (DOUBLE numbers)
 417 ; indexed instructions must be written as $xxxx(REG) (single numbers)
 418 ; -----------------------------------------------------------------------------
 419
 420 HERE
 421 CODE TT
 422 MOVA @W,T
 423 ENDCODE
 424 HERE OVER - DUMP
 425 ; you should see:       0B 0A
 426 RST_RET
 427
 428 HERE
 429 CODE TT
 430 MOVA @T+,W
 431 ENDCODE
 432 HERE OVER - DUMP
 433 ; you should see:       1A 0B
 434 RST_RET
 435
 436 HERE
 437 CODE TT
 438 MOVA &$1.2345,T
 439 ENDCODE
 440 HERE OVER - DUMP
 441 ; you should see:       2B 01  45 23
 442 RST_RET
 443
 444 HERE
 445 CODE TT
 446 MOVA 2(PSP),TOS
 447 ENDCODE
 448 HERE OVER - DUMP
 449 ; you should see:       3E 0F  02 00
 450 RST_RET
 451
 452 HERE
 453 CODE TT
 454 MOVA $1234(W),S
 455 ENDCODE
 456 HERE OVER - DUMP
 457 ; you should see:       3C 0A  34 12
 458 RST_RET
 459
 460 HERE
 461 CODE TT
 462 MOVA T,&$1.2345
 463 ENDCODE
 464 HERE OVER - DUMP
 465 ; you should see:       61 0B  45 23
 466 RST_RET
 467
 468 HERE
 469 CODE TT
 470 MOVA TOS,0(PSP)
 471 ENDCODE
 472 HERE OVER - DUMP
 473 ; you should see:       7F 0E  00 00
 474 RST_RET
 475
 476 HERE
 477 CODE TT
 478 MOVA S,$1234(W)
 479 ENDCODE
 480 HERE OVER - DUMP
 481 ; you should see:       7A 0C  34 12
 482 RST_RET
 483
 484 HERE
 485 CODE TT
 486 MOVA #$.1,S
 487 ENDCODE
 488 HERE OVER - DUMP
 489 ; you should see:       8C 00  01 00
 490 RST_RET
 491
 492 HERE
 493 CODE TT
 494 CMPA #$1.2345,S
 495 ENDCODE
 496 HERE OVER - DUMP
 497 ; you should see:       9C 01  45 23
 498 RST_RET
 499
 500 HERE
 501 CODE TT
 502 ADDA #$2.3456,S
 503 ENDCODE
 504 HERE OVER - DUMP
 505 ; you should see:       AC 02  56 34
 506 RST_RET
 507
 508 HERE
 509 CODE TT
 510 SUBA #$3.4567,S
 511 ENDCODE
 512 HERE OVER - DUMP
 513 ; you should see:       BC 03  67 45
 514 RST_RET
 515
 516 HERE
 517 CODE TT
 518 MOVA W,T
 519 ENDCODE
 520 HERE OVER - DUMP
 521 ; you should see:       CB 0A
 522 RST_RET
 523
 524 HERE
 525 CODE TT
 526 CMPA W,T
 527 ENDCODE
 528 HERE OVER - DUMP
 529 ; you should see:       DB 0A
 530 RST_RET
 531
 532 HERE
 533 CODE TT
 534 ADDA W,T
 535 ENDCODE
 536 HERE OVER - DUMP
 537 ; you should see:       EB 0A
 538 RST_RET
 539
 540 HERE
 541 CODE TT
 542 SUBA W,T
 543 ENDCODE
 544 HERE OVER - DUMP
 545 ; you should see:       FB 0A
 546 RST_RET
 547
 548 ; -----------------------------------------------------------------------------
 549 ; DTCforthMSP430FR5xxx ASSEMBLER, OPCODES V extended double operand
 550 ; -----------------------------------------------------------------------------
 551 ; absolute and immediate instructs. must be written as $x.xxxx (DOUBLE numbers)
 552 ; indexed instructions must be written as $.xxxx(REG) (DOUBLE numbers)
 553 ; -----------------------------------------------------------------------------
 554
 555 HERE
 556 CODE TT
 557 MOV S,T
 558 MOVX S,T
 559 ENDCODE
 560 HERE OVER - DUMP
 561 ; you should see:       0B 4C  40 18 0B 4C
 562 RST_RET
 563
 564 HERE
 565 CODE TT
 566 ADD T,T
 567 ADDX.A T,T
 568 ENDCODE
 569 HERE OVER - DUMP
 570 ; you should see:       0B 5B  00 18 4B 5B
 571 RST_RET
 572
 573 HERE
 574 CODE TT
 575 ADD T,T
 576 RPT X
 577 ADDX.A T,T
 578 ENDCODE
 579 HERE OVER - DUMP
 580 ; you should see:       0B 5B  89 18 4B 5B
 581 RST_RET
 582
 583 HERE
 584 CODE TT
 585 ADD T,T
 586 RPT #8
 587 ADDX.A T,T
 588 ENDCODE
 589 HERE OVER - DUMP
 590 ; you should see:       0B 5B  07 18 4B 5B
 591 RST_RET
 592
 593 HERE
 594 CODE TT
 595 ADDC #$9876,T
 596 ADDCX.A #$5.9876,T
 597 ENDCODE
 598 HERE OVER - DUMP
 599 ; you should see:       3B 60  76 98 80 1A 7B 60 76 98
 600 RST_RET
 601
 602 HERE
 603 CODE TT
 604 ADDC &$9876,T
 605 ADDCX.A &$5.9876,T
 606 ENDCODE
 607 HERE OVER - DUMP
 608 ; you should see:       1B 62  76 98 80 1A 5B 62 76 98
 609 RST_RET
 610
 611 HERE
 612 CODE TT
 613 XOR.B $5432(S),T
 614 XORX.B $6.5432(S),T
 615 ENDCODE
 616 HERE OVER - DUMP
 617 ; you should see:       5B EC  32 54 46 18 5B EC 32 54
 618 RST_RET
 619
 620 HERE
 621 CODE TT
 622 SUBC T,$5432(S)
 623 SUBCX.A T,$6.5432(S)
 624 ENDCODE
 625 HERE OVER - DUMP
 626 ; you should see:       8C 7B  32 54 06 18 CC 7B 32 54
 627 RST_RET
 628
 629 HERE
 630 CODE TT
 631 XOR.B T,$5432(S)
 632 XORX.B T,$6.5432(S)
 633 ENDCODE
 634 HERE OVER - DUMP
 635 ; you should see:       CC EB  32 54 46 18 CC EB 32 54
 636 RST_RET
 637
 638 ; -----------------------------------------------------------------------------
 639 ; DTCforthMSP430FR5xxx ASSEMBLER, OPCODES VI extended single operand
 640 ; -----------------------------------------------------------------------------
 641 ; absolute and immediate instructs. must be written as $x.xxxx (DOUBLE numbers)
 642 ; indexed instructions must be written as $.xxxx(REG) (DOUBLE numbers)
 643 ; -----------------------------------------------------------------------------
 644
 645 HERE
 646 CODE TT
 647 RRA X
 648 RRAX X
 649 ENDCODE
 650 HERE OVER - DUMP
 651 ; you should see:       09 11  40 18 09 11
 652 RST_RET
 653
 654 HERE
 655 CODE TT
 656 RRC @X
 657 RRCX.A @X
 658 ENDCODE
 659 HERE OVER - DUMP
 660 ; you should see:       29 10  00 18 69 10
 661 RST_RET
 662
 663 HERE
 664 CODE TT
 665 RRC @S
 666 RRCX.A @S
 667 ENDCODE
 668 HERE OVER - DUMP
 669 ; you should see:       2C 10  00 18 6C 10
 670 RST_RET
 671
 672 HERE
 673 CODE TT
 674 RRC @X+
 675 RRUX.A @X+
 676 ENDCODE
 677 HERE OVER - DUMP
 678 ; you should see:       39 10  00 19 79 10
 679 RST_RET
 680
 681 HERE
 682 CODE TT
 683 RRC T
 684 RPT #9
 685 RRUX.A T
 686 ENDCODE
 687 HERE OVER - DUMP
 688 ; you should see:       0B 10  08 19 4B 10
 689 RST_RET
 690
 691 HERE
 692 CODE TT
 693 RRC T
 694 RPT X
 695 RRUX.A T
 696 ENDCODE
 697 HERE OVER - DUMP
 698 ; you should see:       0B 10  89 19 4B 10
 699 RST_RET
 700
 701 HERE
 702 CODE TT
 703 PUSH #$2345
 704 PUSHX #$0.2345
 705 ENDCODE
 706 HERE OVER - DUMP
 707 ; you should see:       30 12  45 23 40 18 30 12 45 23
 708 RST_RET
 709
 710 HERE
 711 CODE TT
 712 PUSH &$5678
 713 PUSHX.A &$4.5678
 714 ENDCODE
 715 HERE OVER - DUMP
 716 ; you should see:       12 12  78 56 00 1A 52 12 78 56
 717 RST_RET
 718
 719 HERE
 720 CODE TT
 721 PUSH.B &$33
 722 PUSHX.B &$.33
 723 ENDCODE
 724 HERE OVER - DUMP
 725 ; you should see:       52 12  33 00 40 18 52 12 33 00
 726 RST_RET
 727
 728 HERE
 729 CODE TT
 730 PUSH.B $3344(T)
 731 PUSHX.B $.3344(T)
 732 ENDCODE
 733 HERE OVER - DUMP
 734 ; you should see:       5B 12  44 33 40 18 5B 12 44 33
 735 RST_RET
 736
 737 \ https://forth-standard.org/standard/core/BASE
 738 \ BASE    -- a-addr       holds conversion radix
 739     [UNDEFINED] BASE
 740     [IF]
 741     ' # 2 +  CONSTANT BASE
 742     [THEN]
 743
 744
 745
 746 : %.
 747 BASE @ %10 BASE ! SWAP 8 EMIT . BASE !
 748 RST_RET
 749 ;
 750
 751 : %U.
 752 BASE @ %10 BASE ! SWAP 8 EMIT U. BASE !
 753 RST_RET
 754 ;
 755
 756 RST_SET
 757
 758 ; ================
 759 ; RRUX test
 760 ; ================
 761
 762
 763 CODE RRUX_T
 764 \ MOVX #$F0F0,Y \ don't forget decimal point with MOVX instruction !
 765 MOVX #$.F0F0,Y
 766 RRUX Y
 767 SUB #2,PSP
 768 MOV TOS,0(PSP)
 769 MOV Y,TOS
 770 MOV #%.,PC
 771 ENDCODE
 772
 773 RRUX_T ;            %
 774 ; you should see:   %111100001111000
 775
 776 ; ================
 777 ; RRUX repeat test
 778 ; ================
 779
 780
 781 CODE RRUX_T
 782 MOV #$F0F0,Y
 783 RPT #1
 784 RRUX Y
 785 SUB #2,PSP
 786 MOV TOS,0(PSP)
 787 MOV Y,TOS
 788 MOV #%.,PC
 789 ENDCODE
 790
 791 RRUX_T ;            %
 792 ; you should see:   %111100001111000
 793
 794 CODE RRUX_T
 795 MOV #$F0F0,Y
 796 RPT #4
 797 RRUX Y
 798 SUB #2,PSP
 799 MOV TOS,0(PSP)
 800 MOV Y,TOS
 801 MOV #%.,PC
 802 ENDCODE
 803
 804 RRUX_T ; -->        %
 805 ; you should see:   %111100001111
 806
 807 CODE RRUX_T
 808 MOV #$F0F0,Y
 809 RPT #8
 810 RRUX Y
 811 SUB #2,PSP
 812 MOV TOS,0(PSP)
 813 MOV Y,TOS
 814 MOV #%.,PC
 815 ENDCODE
 816
 817 RRUX_T ;            %
 818 ; you should see:   %11110000
 819
 820 ; ================
 821 ; RRCX test
 822 ; ================
 823
 824 CODE RRCX_T
 825 MOV #$8000,Y
 826 BIC #C,SR
 827 RRCX Y
 828 SUB #2,PSP
 829 MOV TOS,0(PSP)
 830 MOV Y,TOS
 831 MOV #%U.,PC
 832 ENDCODE
 833
 834 RRCX_T ;            %
 835 ; you should see:   %100000000000000
 836
 837 ; ================
 838 ; RRCX repeat test
 839 ; ================
 840
 841 CODE RRCX_T
 842 MOV #$8000,Y
 843 BIC #C,SR
 844 RPT #1
 845 RRCX Y
 846 SUB #2,PSP
 847 MOV TOS,0(PSP)
 848 MOV Y,TOS
 849 MOV #%U.,PC
 850 ENDCODE
 851
 852 RRCX_T ;            %
 853 ; you should see:   %100000000000000
 854
 855 CODE RRCX_T
 856 MOV #$8000,Y
 857 BIC #C,SR
 858 RPT #8
 859 RRCX Y
 860 SUB #2,PSP
 861 MOV TOS,0(PSP)
 862 MOV Y,TOS
 863 MOV #%U.,PC
 864 ENDCODE
 865
 866 RRCX_T ;            %
 867 ; you should see:   %10000000
 868
 869 ; ================
 870 ; RRAX test
 871 ; ================
 872
 873 CODE RRAX_T
 874 MOV #$8000,Y
 875 RRAX Y
 876 SUB #2,PSP
 877 MOV TOS,0(PSP)
 878 MOV Y,TOS
 879 MOV #%.,PC
 880 ENDCODE
 881
 882 RRAX_T ;            %
 883 ; you should see:   %-100000000000000
 884
 885 ; ================
 886 ; RRAX repeat test
 887 ; ================
 888
 889
 890 CODE RRAX_T
 891 MOV #$8000,Y
 892 RPT #1
 893 RRAX Y
 894 SUB #2,PSP
 895 MOV TOS,0(PSP)
 896 MOV Y,TOS
 897 MOV #%.,PC
 898 ENDCODE
 899
 900 RRAX_T ;            %
 901 ; you should see:   %-100000000000000
 902
 903 CODE RRAX_T
 904 MOV #$8000,Y
 905 RPT #2
 906 RRAX Y
 907 SUB #2,PSP
 908 MOV TOS,0(PSP)
 909 MOV Y,TOS
 910 MOV #%.,PC
 911 ENDCODE
 912
 913 RRAX_T ;            %
 914 ; you should see:   %-10000000000000
 915
 916 CODE RRAX_T
 917 MOV #$8000,Y
 918 RPT #3
 919 RRAX Y
 920 SUB #2,PSP
 921 MOV TOS,0(PSP)
 922 MOV Y,TOS
 923 MOV #%.,PC
 924 ENDCODE
 925
 926 RRAX_T ;            %
 927 ; you should see:   %-1000000000000
 928
 929 CODE RRAX_T
 930 MOV #$8000,Y
 931 RPT #7
 932 RRAX Y
 933 SUB #2,PSP
 934 MOV TOS,0(PSP)
 935 MOV Y,TOS
 936 MOV #%.,PC
 937 ENDCODE
 938
 939 RRAX_T ;            %
 940 ; you should see:   %-100000000
 941
 942 ; ================
 943 ; RLAX test
 944 ; ================
 945
 946
 947 CODE RLAX_T
 948 MOV #-1,Y
 949 ADDX Y,Y
 950 SUB #2,PSP
 951 MOV TOS,0(PSP)
 952 MOV Y,TOS
 953 MOV #.,PC   \ BRANCH to .
 954 ENDCODE
 955
 956 RLAX_T ; you should see -2 -->
 957
 958 ; ================
 959 ; RLAX repeat test
 960 ; ================
 961
 962
 963 CODE RLAX_T
 964 MOV #-1,Y
 965 RPT #1
 966 ADDX Y,Y
 967 SUB #2,PSP
 968 MOV TOS,0(PSP)
 969 MOV Y,TOS
 970 MOV #.,PC   \ BRANCH to .
 971 ENDCODE
 972
 973 RLAX_T ; you should see -2 -->
 974
 975 CODE RLAX_T
 976 MOV #-1,Y
 977 RPT #2
 978 ADDX Y,Y
 979 SUB #2,PSP
 980 MOV TOS,0(PSP)
 981 MOV Y,TOS
 982 MOV #.,PC   \ BRANCH to .
 983 ENDCODE
 984
 985 RLAX_T ; you should see -4 -->
 986
 987 CODE RLAX_T
 988 MOV #-1,Y
 989 RPT #3
 990 ADDX Y,Y
 991 SUB #2,PSP
 992 MOV TOS,0(PSP)
 993 MOV Y,TOS
 994 MOV #.,PC   \ BRANCH to .
 995 ENDCODE
 996
 997 RLAX_T ; you should see -8 -->
 998
 999 CODE RLAX_T
1000 MOV #-1,Y
1001 RPT #8
1002 ADDX Y,Y
1003 SUB #2,PSP
1004 MOV TOS,0(PSP)
1005 MOV Y,TOS
1006 MOV #.,PC   \ BRANCH to .
1007 ENDCODE
1008
1009 RLAX_T ; you should see -256 -->
1010
1011 ; ================
1012 ; ADDX test
1013 ; ================
1014
1015
1016 CODE ADDX_T
1017 MOV #0,Y
1018 MOV #-1,X
1019 ADDX X,Y
1020 SUB #2,PSP
1021 MOV TOS,0(PSP)
1022 MOV Y,TOS
1023 MOV #.,PC   \ BRANCH to .
1024 ENDCODE
1025
1026 ADDX_T ; you should see -1 -->
1027
1028 ; ================
1029 ; ADDX repeat test
1030 ; ================
1031
1032
1033 CODE ADDX_T
1034 MOV #0,Y
1035 MOV #-1,X
1036 RPT #1
1037 ADDX X,Y
1038 SUB #2,PSP
1039 MOV TOS,0(PSP)
1040 MOV Y,TOS
1041 MOV #.,PC   \ BRANCH to .
1042 ENDCODE
1043
1044 ADDX_T ; you should see -1 -->
1045
1046 CODE ADDX_T
1047 MOV #0,Y
1048 MOV #-1,X
1049 RPT #2
1050 ADDX X,Y
1051 SUB #2,PSP
1052 MOV TOS,0(PSP)
1053 MOV Y,TOS
1054 MOV #.,PC   \ BRANCH to .
1055 ENDCODE
1056
1057 ADDX_T ; you should see -2 -->
1058
1059 CODE ADDX_T
1060 MOV #0,Y
1061 MOV #-1,X
1062 RPT #8
1063 ADDX X,Y
1064 SUB #2,PSP
1065 MOV TOS,0(PSP)
1066 MOV Y,TOS
1067 MOV #.,PC   \ BRANCH to .
1068 ENDCODE
1069
1070 ADDX_T ; you should see -8 -->
1071
1072 ; ================
1073 ; SUBX test
1074 ; ================
1075
1076
1077 CODE SUBX_T
1078 MOV #0,Y
1079 MOV #-1,X
1080 SUBX X,Y
1081 SUB #2,PSP
1082 MOV TOS,0(PSP)
1083 MOV Y,TOS
1084 MOV #.,PC   \ BRANCH to .
1085 ENDCODE
1086
1087 SUBX_T ; you should see 1 -->
1088
1089 ; ================
1090 ; SUBX repeat test
1091 ; ================
1092
1093
1094 CODE SUBX_T
1095 MOV #0,Y
1096 MOV #-1,X
1097 RPT #1
1098 SUBX X,Y
1099 SUB #2,PSP
1100 MOV TOS,0(PSP)
1101 MOV Y,TOS
1102 MOV #.,PC   \ BRANCH to .
1103 ENDCODE
1104
1105 SUBX_T ; you should see 1 -->
1106
1107 CODE SUBX_T
1108 MOV #0,Y
1109 MOV #-1,X
1110 RPT #2
1111 SUBX X,Y
1112 SUB #2,PSP
1113 MOV TOS,0(PSP)
1114 MOV Y,TOS
1115 MOV #.,PC   \ BRANCH to .
1116 ENDCODE
1117
1118 SUBX_T ; you should see 2 -->
1119
1120 CODE SUBX_T
1121 MOV #0,Y
1122 MOV #-1,X
1123 RPT #8
1124 SUBX X,Y
1125 SUB #2,PSP
1126 MOV TOS,0(PSP)
1127 MOV Y,TOS
1128 MOV #.,PC   \ BRANCH to .
1129 ENDCODE
1130
1131 SUBX_T ; you should see 8 -->
1132
1133 CODE SUBX_T     \ W register = R10
1134 MOV #15,W       \ RPT [W] times, modulo 16 <--> RPT #16
1135 MOV #0,Y
1136 MOV #-1,X
1137 RPT W
1138 SUBX X,Y
1139 SUB #2,PSP
1140 MOV TOS,0(PSP)
1141 MOV Y,TOS
1142 MOV #.,PC   \ BRANCH to .
1143 ENDCODE
1144
1145 SUBX_T ; you should see 16 -->
1146
1147 CODE SUBX_T
1148 MOV #32,W       \ RPT [W] times, modulo 16 <--> RPT #1
1149 MOV #0,Y
1150 MOV #-1,X
1151 RPT W
1152 SUBX X,Y
1153 SUB #2,PSP
1154 MOV TOS,0(PSP)
1155 MOV Y,TOS
1156 MOV #.,PC   \ BRANCH to .
1157 ENDCODE
1158
1159 SUBX_T ; you should see 1 -->
1160
1161 CODE SUBX_T
1162 MOV #33,W       \ RPT [W] times, modulo 16 <--> RPT #2
1163 MOV #0,Y
1164 MOV #-1,X
1165 RPT W
1166 SUBX X,Y
1167 SUB #2,PSP
1168 MOV TOS,0(PSP)
1169 MOV Y,TOS
1170 MOV #.,PC   \ BRANCH to .
1171 ENDCODE
1172
1173 SUBX_T ; you should see 2 -->
1174
1175 {TEST_ASMX}