anchor.diff:  : >body         definition ;
   : invert        invert, ;
   : ,             ,, ;
  +: nop           nop, ;
   
   host definitions
   
  
positive.code: : drop,         $6103 i, ;
  : !,            $6123 i, drop, ;
  : @,            $6C00 i, ;
  : dup,          $6081 i, ;
  : over,         $6181 i, ;
  
  
negative.code: 
  also target-primitives definitions previous
  
  0 [if]  NOTE:
          Due to how the J1 processor interacts with synchronous RAM,
          both @ and ! need to take two cycles to complete.  The timing
          for fetch is as follows:
  
                  J1                          RAM
                  -------------------------   ----------------------
          T0:     (something places           When T updates, RAM address
                  address in T)               changes.
  
          T1:     no-operation                RAM data outputs become valid
  
          T2:     "Fetch" latches data into   RAM address changes because T
                  T.                          changes.
  
          Hence, to properly implement @ for the J1, you need to wait a cycle
          before latching the data.  This can be achieved using a non-immediate
          word, like so:
  
          : @  @, ;
  
          The CALL to @ will delay the extra cycle needed for the synchronous
          RAMs to present valid data on the bus.  The @, ; sequence will latch
          the data and resume operation in a single cycle.  Thus, CALL @ will
          consume exactly two cycles.
  
          Stores work similarly, but their timing is on opposite clocks:
  
                  J1                          RAM
                  -------------------------   ----------------------
          T0:     (something places address   When T updates, RAM address
                  in T, data in S)            changes.  Likewise, when S
                                              changes, data input pins change.
  
          T1:     "Store" strobe asserted.    RAM latches data and writes it
                                              to the specified address
  
          T2:     2DROP or its equivalent
                  is executed to dispose of
                  the stack frame.
  
          Hence, ! is best implemented as an immediate word which compiles
          two DROPs as follows:
  
          : !  postpone drop_w  postpone drop ; immediate
  
          where drop_w is a primitive which combines DROP with the write
          strobe.  In doing this, we take two cycles to write a word to
          RAM.  Note that RAM doesn't actully update until time T2!
  [then]
  
  : defer         defer, ;
  : :             :, ;
  : +             +, ;
  : ;             ;, ;
  : dup           dup, ;
  : xor           xor, ;
  : over          over, ;
  : !             !, ;
  