   # tttttttttttttttttttt============

#   :           ": ccc H3sm.. ; " name/link ccc, set target 0, start
threader
THREAD_(colon,:)
                        # wipe branch-resolver stacks
OP(initresolve)
OP(header)
OP(link)
                        # stash newguy's CFA as target0
OP(target)
OP(drop)
OP(threadloop)
        Return


   # ttttttttttttttttttttttt============

#   &word               (P &HNC ||| )  append a word's CFA.
THREAD_(appendword,&word)
OP(pdup)
OP(TOcode)
OP(appendp)
OP(pdrop)
        Return

   # ttttttttttttttttttttttt============

#   initresolve init branch resolver stacks
NON_USER(initresolve,initresolve)
OP(branchstack)                 # (P &bs)
OP(bsi)                         # (P &bs &bsi)
OP(pstore)                      # (P &bs &bsi)
OP(twopdrop)
OP(targetstack)                 # (P &bs)
OP(tsi)                         # (P &bs &bsi)
OP(pstore)                      # (P &bs &bsi)
OP(twopdrop)
        Return

   # ttttttttttttttttttttttt============

#   link                !dp   !latest     link a word to the dictionary
THREAD_(link,link)
OP(Latest)              #       (P  &latest)
OP(pfetch)              #       (P  latest)
OP(appendp)             #       (P  latest)   !dp !HERE
OP(pdrop)               #       (P)
OP(pvar)
OP(pfetch)
OP(Latest)
OP(pstore)
OP(twopdrop)
        Return

   # ttttttttttttttttttttttt============

#   resolve_one resolve one branch in thread being threaded
NON_USER(resolve_one,resolve_one)
OP(bsi)                 # (P  &bsi)
OP(pfetch)              # (P  bsi )
OP(pminusc)             # (P  bsi-)
OP(pdup)                # (P  bsi-  bsi-)
OP(pfetch)              # (P  bsi-  targ.stck.addy)     pop
OP(pfetch)              # (P  bsi-  targ.addy)
OP(pswap)               # (P  targ.addy bsi-)
OP(pminusc)             # (P  targ.addy bsi--)
OP(pdup)                # (P  targ.addy bsi-- bsi--)
OP(pfetch)              # (P  targ.addy bsi-- poke.loc )
OP(pswap)               # (P targ.addy poke.loc bsi--)
OP(pTOr)                # (P targ.addy poke.loc bsi--) (R bsi--)
OP(pstore)              #  (P targ.addy poke.loc) (R bsi--) RESOLVED!
OP(twopdrop)            # (P ) (R bsi--)
OP(rTOp)                # (P bsi--)
OP(bsi)                 # (P bsi-- &bsi)
OP(pstore)
OP(twopdrop)
        Return

   # ttttttttttttttttttttttt============

#   resolve             (--- true) @bs @ts, thread all pending branches
THREADer #                      resolve uses bs decr.-pop style
THREADING(resolve,resolve)
lresolve:
        OP(branchstack)
        OP(bsi)                         # (P  &bs &bsi)
        OP(pfetch)                      # (P  &bs bsi )
        OP(gap)                         # (P  &bs bsi )  (gap)
        OP(twopdrop)                    # (gap)
        NO(             resovo)         # no branches pending
                                        # resolve a pending branch
        OP(resolve_one)                 # ()
ELL(                    lresolve)
resovo:
                Return


   # ttttttttttttttttttttttt============

#   ;           ( --- stop_THREADer) set a target, resolve, & a return.
THREADING(semicolon,;)
                                # (O) for to# = ;
OP(target)              # (P &dp)
OP(drop)                # (P dp)
                        # resolve branches
OP(resolve)
OP(pliteral)            # THREAD  a return
.byte 0xe8, 0, 0, 0xe8
OP(appendp)              # (P )
OP(pdrop)               SUSPECT
OP(false)               # tell : to stop threading
        Return


   # ttttttttttttttttttttttt============

#   threadtoken ( --- keep_going? )  called after "token"
NON_USER(threadtoken,threadtoken)
OP(ifword)                      # (P ---  &HNC|null) ( --- flag )
NO(     tenkru)
OP(ifthreader)                  # (P ---  &HNC) ( --- flag )
        YES(    tailoil)
OP(appendword)                  # (P ---  &HNC) ()
OP(true)                        # (P ---  &HNC) ( --- true)
OP(pdrop)                       # (P) ( --- true)
        Return                  # (P) ( --- true)
tenkru:
                                # (P;NULL)
OP(ifabbreviation)              #
NO(     tenflabo)               # no. not a word at all.
                                # yes, so it's a word.
OP(ifthreader)
YES(            tailoil)        # yes. go do it now.
                                # no. thread it.
OP(appendword)
OP(pdrop)
OP(true)
        Return
tenflabo:
        OP(ifhexnumber)
        NO(             fivvish)
        OP(hexnumber)
        OP(appendlit)
        OP(true)
                Return
                        # stub
 OP(iffile)
        NO(             fivvish)
 OP(H3m)
OP(true)
        Return
fivvish:
        OP(beep)
        OP(toklen)
        OP(fetch)
        OP(pdrop)
        OP(tb)
        OP(cr)
        OP(cr)
        OP(tab)
        OP(tab)
        OP(printstring)
        OP(cr)
        OP(cr)
        OP(cr)
        OP(pdrop)
                Return
tailoil:
                        # token is a threader word
OP(doHNC)
Return

   # ttttttttttttttttttttttt============

#   threadloop  called by :. Build the body of a thread. Stops after ;.
NON_USER(threadloop,threadloop)
threadtokens:
        OP(token)
        YES(            threadloopdone)
        OP(threadtoken)
        NO(             threadloopdone)         # if keep-going is false
ELL(                            threadtokens)
threadloopdone:
                        Return




