\ forth.v4 -- the first words of the FORTH vocabulary: the ones that are
\ opcodes or short runs of them, and the variables that are in-line addresses.
\
\ Each is the definition DECOMPOSITION.md gives (sections 4, 5.1 - 5.5, 5.18).
\ A word flagged inline is copied into a definition in place of a call; the
\ ones that touch the return stack are compile-only as well.  Rests on core.v4
\ and compile.v4's loader constants.

\ ---- stack ----
header DUP inline       : DUP     dup ;
header DROP inline      : DROP    drop ;
header OVER inline      : OVER    over ;
header SWAP inline      : SWAP'   SWAP ;
header ROT inline       : ROT'    ROT ;
header -ROT inline      : -ROT    SWAP push SWAP pop ;
header ?DUP             : ?DUP    if Z  dup ;   Z: ;
header 2DUP inline      : 2DUP    over over ;
header 2DROP inline     : 2DROP   drop drop ;

\ ---- return stack: in line, and only inside a definition ----
header >R inline compile-only   : >R    push ;
header R> inline compile-only   : R>    pop ;
header R@ inline compile-only   : R@    pop dup push ;
header I inline compile-only    : I     pop dup push ;
header J inline compile-only    : J     pop pop  pop dup push a!  push push  a ;
header LEAVE inline compile-only    : LEAVE    pop pop drop dup push push ;
header UNLOOP inline compile-only   : UNLOOP   pop drop pop drop ;

\ ---- memory ----
header @ inline         : FETCH   a! @ ;
header ! inline         : STORE   a! ! ;
header +! inline        : +!      a! @ + ! ;
header CELLS inline     : CELLS   ;                    \ an address unit is a cell (D-1)

\ ---- arithmetic ----
header + inline         : PLUS    + ;
header - inline         : MINUS   - ;
\ The low cell of the product, by N steps of +* with nothing but the count on
\ the return stack.  UM* drop gives the same cell but needs two more return
\ entries, which a word inside two DO loops does not have (D-2).  The low
\ cell is exact: what +* loses at the top of T (D-3) takes N shifts to reach
\ the bit that moves into A, and the loop ends first.
header * : STAR    a!  0  N-1 FOR +* UNEXT  drop drop a ;
header NEGATE inline    : NEGATE' NEGATE ;
header 1+ inline        : 1+      1 + ;
header 1- inline        : 1-      -1 + ;
header 2+ inline        : 2+      2 + ;
header 2- inline        : 2-      -2 + ;
header 2* inline        : TWO*    2* ;
header 2/ inline        : TWO/    2/ ;

\ ---- logic and comparison ----
header AND inline       : AND     and ;
header XOR inline       : XOR     xor ;
header OR inline        : OR'     OR ;
header 0= : 0=    if L1  drop 0 ;   L1: drop -1 ;
header 0< : 0<    -if L1  drop -1 ;   L1: drop 0 ;
header NOT : NOT   jump 0=
header = : EQUALS  xor jump 0=
header < : LESS
  over over xor -if SAME  drop drop jump 0<
  SAME: drop - jump 0<
header > : GREATER   SWAP jump LESS

\ ---- in-line addresses and constants ----
header BL inline        : BL'     BL ;
header TIB inline       : TIB'    TIB ;
header >IN inline       : >IN'    >IN ;
header SPAN inline      : SPAN'   SPAN ;
header BASE inline      : BASE'   BASE ;
header PAD inline       : PAD'    PAD ;
header STATE inline     : STATE'  STATE ;