#PYTHON name
#
#   forth.py
#
import sys, math
import hpprime
import graphic
import urandom

if sys.version > '3' : raw_input = input  # for both 2.7 and 3.0+

ds       = []          # The data stack
cStack   = []          # The control struct stack
heap     = [0]*2048      # The data heap
heapNext =  0          # Next avail slot in heap
words    = []          # The input stream of tokens
colour   = 0x0000ff
background = 0xffffff
initCode = """: cr 10 emit ; : abs dup 0 < if 0 swap - then ; : constant create , does> @ ; : variable create 1 allot ; : +! DUP @ ROT + SWAP ! ; 
: 2DUP OVER OVER ; : 2DROP DROP DROP ; : NIP SWAP DROP ; : 2NIP 2SWAP 2DROP ; : TUCK SWAP OVER ; 
 : BL 32 ; : CR 10 EMIT ; : SPACE BL EMIT ; : NEGATE 0 SWAP - ; : DNEGATE 0. 2SWAP D- ; : CELLS CELL * ; : TRUE -1 ; : FALSE 0 ;
 : 0= 0 = ; : 0< 0 < ; : 0> 0 > ; : <= > 0= ; : >= < 0= ; : 0<= 0 <= ; : 0>= 0 >= ; : 1- 1 - ; 
: 2+ 2 + ; : 2- 2 - ; : 2/ 2 / ; : 2* 2 * ; : MIN 2DUP < IF DROP ELSE NIP THEN ; : MAX 2DUP > IF DROP ELSE NIP THEN ; : D0= OR 0= ; 1 constant CELL
"""

def main() :
    global words, initCode
    if len(sys.argv) > 1 :
        initCode = open(sys.argv[1]).read()   # load start file
    hpprime.eval("PRINT") # clear terminal screen
    print("Prime FORTH 1.0")
    while True :
        pcode = compile()          # compile/run from user
        if pcode == None : print(""); return
        try:
            execute(pcode)
        except IndexError:
            print("Stack empty")

#============================== Lexical Parsing
        
def getWord (prompt="... ") :
    global words, initCode
    while not words : 
        try :
            if initCode : lin = initCode; initCode=""
            else        : 
                lin = raw_input(prompt)+" "
                print(lin)
        except : return None
        tokenizeWords(lin)
        
    word = words[0]
    if word == "bye" : return None
    words = words[1:]
    return word

def tokenizeWords(s) :
    global words                                          # clip comments, split to list of words
    words += s.lower().split()  # Use "#" for comment to end of line

#================================= Runtime operation

def execute (code) :
    p = 0
    while p < len(code) :
        func = code[p]
        p += 1
        newP = func(code,p)
        if newP != None : p = newP

def rAdd (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(a+b)
def rFloor (cod,p) : a=ds.pop(); ds.append(math.floor(a))
def rMod (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(a%b)
def rOneplus (cod,p) : a=ds.pop(); ds.append(a+1)
def rOr (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(a|b)
def rAnd (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(a&b)
def rMul (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(a*b)
def rSub (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(a-b)
def rDiv (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(a/b)
def rEq  (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(int(a==b))
def rPixon (cod,p) : y=ds.pop(); x=ds.pop(); hpprime.pixon(0,x,y,colour)
def rPixon2 (cod,p) :
    y=ds.pop();
    if y > 0 : y = y * 2 + 1
    x=ds.pop()
    if x > 0 : x = x * 2 + 1
    hpprime.pixon(0,x,y,colour);
    hpprime.pixon(0,x+1,y,colour);
    hpprime.pixon(0,x,y+1,colour);
    hpprime.pixon(0,x+1,y+1,colour)

def rPixon4 (cod,p) :
    y=ds.pop();
    if y > 0 : y = y * 4 + 1
    x=ds.pop()
    if x > 0 : x = x * 4 + 1
    hpprime.fillrect(0,x,y,4, 4, colour, colour);

def rGetpix (cod,p) : y=ds.pop(); x=ds.pop(); ds.append(hpprime.eval("getpix_p({},{})".format(x,y)))

def rGetpix2 (cod,p) :
    y=ds.pop();
    if y > 0 : y = y * 2 + 1
    x=ds.pop()
    if x > 0 : x = x * 2 + 1
    ds.append(hpprime.eval("getpix_p({},{})".format(x,y)))

def rGetpix4 (cod,p) :
    y=ds.pop();
    if y > 0 : y = y * 4 + 1
    x=ds.pop()
    if x > 0 : x = x * 4 + 1
    ds.append(hpprime.eval("getpix_p({},{})".format(x,y)))

def rLastkey (cod,p) : ds.append(int(hpprime.eval("getkey")))

def rKey (cod,p) :
    while 1:
        k = hpprime.eval("getkey")
        if k != -1 : break

    ds.append(int(k))

def rInt (cod,p) : ds.append(int(ds.pop()))
def rTicks (cod,p) : ds.append(int(hpprime.eval("ticks")))
def rLine (cod,p) : y2=ds.pop(); x2=ds.pop(); y1=ds.pop(); x1=ds.pop(); hpprime.line(0,x1,y1,x2, y2, colour)
def rRect (cod,p) : h=ds.pop(); w=ds.pop(); y=ds.pop(); x=ds.pop(); hpprime.rect(0,x,y,w, h, colour)
def rFillrect (cod,p) : h=ds.pop(); w=ds.pop(); y=ds.pop(); x=ds.pop(); hpprime.fillrect(0,x,y,w, h, colour, colour)
def rCircle (cod,p) : rad=ds.pop(); y=ds.pop(); x=ds.pop(); hpprime.circle(0,x,y,rad, colour)
def rCol (cod,p) : global colour ; colour = ds.pop()
def rGetcol (cod,p) : global colour; ds.append(colour)
def rBg (cod,p) : global background; background = ds.pop()
def rShow (cod,p) : graphic.show()
def rList (cod,p) : 
    fname = getWord()+".fth";
    try: 
        f = open(fname, "r")
        print(f.read(), end=''); f.close()
    except:
        print(fname+": does not exist")

def rLoad (cod,p) :
    global initCode
    fname = getWord()+".fth"
    try:
        f = open(fname, "r")
        initCode = f.read()
        f.close()
    except:
        print(fname+": does not exist")

def rSleep (cod,p) : a=ds.pop()/1000; hpprime.eval("wait({})".format(a))
def rNeq  (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(int(a!=b))
def rGt  (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(int(a>b))
def rLt  (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(int(a<b))
def rLtE (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(int(a<=b))
def rSqr (cod,p) : a=ds.pop(); ds.append(math.sqrt(a))
def rCos (cod,p) : a=ds.pop(); ds.append(math.cos(a))
def rRandom (cod,p) : a=ds.pop(); ds.append(urandom.randint(0,a-1))
def rSwap(cod,p) : a=ds.pop(); b=ds.pop(); ds.append(a); ds.append(b)
def rRot(cod,p) : a=ds.pop(); b=ds.pop(); c=ds.pop(); ds.append(b); ds.append(a); ds.append(c)
def rDup (cod,p) : ds.append(ds[-1])
def rDrop(cod,p) : ds.pop()
def rOver(cod,p) : ds.append(ds[-2])
def rDump(cod,p) : print("ds = %s" % ds)
def rDdump(cod,p) : print(rDict)
def rIdump(cod,p) : print(imDict)
def rDot (cod,p) : print(ds.pop(),end=' ')
def rEmit (cod,p) : print(chr(ds.pop()&255),end='')
def rHere(cod,p) : ds.append(heapNext)
def rJmp (cod,p) : return cod[p]
def rJnz (cod,p) : return (cod[p],p+1)[ds.pop()]
def rJz  (cod,p) : return (p+1,cod[p])[ds.pop()==0]
def rRun (cod,p) : 
    if cod[p] in rDict:
        execute(rDict[cod[p]])
    else:
        print(cod[p]," unknown")
    return p+1

def rPush(cod,p) : ds.append(cod[p])     ; return p+1
def rCls(cod,p) : graphic.clear_screen(background); hpprime.eval("print")
def rSin(cod,p) : a=ds.pop(); ds.append(math.sin(a))
def rCos(cod,p) : a=ds.pop(); ds.append(math.cos(a))
def rTan(cod,p) : a=ds.pop(); ds.append(math.tan(a))
def rAsin(cod,p) : a=ds.pop(); ds.append(math.asin(a))
def rAcos(cod,p) : a=ds.pop(); ds.append(math.acos(a))
def rAtan(cod,p) : a=ds.pop(); ds.append(math.atan(a))
def rSqrt(cod,p) : a=ds.pop(); ds.append(math.sqrt(a))

def rgtR(cod,p) :
    a=ds.pop()
    cStack.append(("NUMBER",a))

def rRgt(cod,p) :
    name,value=cStack.pop()
    ds.append(value)

def rRat(cod,p) :
    name,value = cStack.pop()
    cStack.append((name,value))
    ds.append(value)

def rJ (cod,p) :
    c1,t1 = cStack.pop()
    c2,t2 = cStack.pop()
    c3,t3 = cStack.pop()
    cStack.append((c3,t3))
    cStack.append((c2,t2))
    cStack.append((c1,t1))
    ds.append(t3)

def rWord (cod,p) :
    word=getWord()
    for c in word :
        ds.append(ord(c))
    ds.append(len(word))

def rType (cod,p) :
    len = ds.pop()
    addr = ds.pop()
    print("addr ",addr,len)
    for i in range(0, len) :
        print(chr(heap[addr+i]&0x7f),end="")

def rImmediate(cod,p) :
    imDict[list(rDict.keys())[-1]] = 1

def rWords(cod,p) :
    for k in sorted(list(rDict.keys())+list(cDict.keys())): print(k,end=' ')

def rCreate (pcode,p) :
    global heapNext, lastCreate
    lastCreate = label = getWord()      # match next word (input) to next heap address
    rDict[label] = [rPush, heapNext]    # when created word is run, pushes its address

def rDoes (cod,p) :
    rDict[lastCreate] += cod[p:]        # rest of words belong to created words runtime
    return len(cod)                     # jump p over these

def rAllot (cod,p) :
    global heapNext
    heapNext += ds.pop()                # reserve n words for last create

def rAt  (cod,p) : ds.append(heap[ds.pop()])       # get heap @ address
def rBang(cod,p) : a=ds.pop(); heap[a] = ds.pop()  # set heap @ address
def rComa(cod,p) :                                 # push tos into heap
    global heapNext
    heap[heapNext]=ds.pop()
    heapNext += 1

rDict = {
  '+'  : rAdd, '-'   : rSub, '/' : rDiv, '*'    : rMul,   'over': rOver,
  'dup': rDup, 'swap': rSwap, '.': rDot, 'dump' : rDump,  'drop': rDrop,
  '='  : rEq,  '>'   : rGt,   '<': rLt,
  ','  : rComa,'@'   : rAt, '!'  : rBang,'allot': rAllot,

  'create': rCreate, 'does>': rDoes,
'or' : rOr,
'and' : rAnd,
'emit' : rEmit,
'<>' : rNeq,
'here' : rHere,
'rot' : rRot,
'pixon' : rPixon,
'pixon2' : rPixon2,
'pixon4' : rPixon4,
'getpix' : rGetpix,
'getpix2' : rGetpix2,
'getpix4' : rGetpix4,
'key' : rKey,
'lastkey' : rLastkey,
'int' : rInt,
'ticks' : rTicks,
'line' : rLine,
'rect' : rRect,
'fillrect' : rFillrect,
'circle' : rCircle,
'sleep' : rSleep,
'cls' : rCls,
'col' : rCol,
'getcol' : rGetcol,
'bg' : rBg,
'show' : rShow,
'list' : rList,
'load' : rLoad,
'<>' : rNeq,
'here' : rHere,
'rot' : rRot,
'sin' : rSin,
'cos' : rCos,
'random' : rRandom,
'tan' : rTan,
'asin' : rAsin,
'acos' : rAcos,
'atan' : rAtan,
'sqrt' : rSqrt,
'words' : rWords,
'R@' : rRat,
'1+' : rOneplus,
'>r' : rgtR,
'r>' : rRgt,
'type' : rType,
'word' : rWord,
'ddump' : rDdump,
'idump' : rIdump,
'immediate' : rImmediate,
'lte' : rLtE,
}
#================================= Compile time 

def compile() :
    global ds
    pcode = []; prompt = "Ok " if len(ds)==0 else "Ok: "
    while 1 :
        word = getWord(prompt)  # get next word
        if word == None : return None
        cAct = cDict.get(word)  # Is there a compile time action ?
        rAct = rDict.get(word)  # Is there a runtime action ?

        if cAct : cAct(pcode)   # run at compile time
        elif rAct :
            if type(rAct) == type([]) :
                pcode.append(rRun)     # Compiled word.
                pcode.append(word)     # for now do dynamic lookup
            else : pcode.append(rAct)  # push builtin for runtime
        else :
            # Number to be pushed onto ds at runtime
            pcode.append(rPush)
            try : pcode.append(int(word))
            except :
                try: pcode.append(float(word))
                except : 
                    pcode[-1] = rRun     # Change rPush to rRun
                    pcode.append(word)   # Assume word will be defined
        if not cStack : return pcode
        prompt = "...    "
    
def fatal (mesg) : raise mesg

def cColon (pcode) :
    if cStack : fatal(": inside Control stack: %s" % cStack)
    label = getWord()
    cStack.append(("COLON",label))  # flag for following ";"

def cSemi (pcode) :
    if not cStack : fatal("No : for ; to match")
    code,label = cStack.pop()
    if code != "COLON" : fatal(": not balanced with ;")
    rDict[label] = pcode[:]       # Save word definition in rDict
    while pcode : pcode.pop()

def cBegin (pcode) :
    cStack.append(("BEGIN",len(pcode)))  # flag for following UNTIL

def cUntil (pcode) :
    if not cStack : fatal("No BEGIN for UNTIL to match")
    code,slot = cStack.pop()
    if code != "BEGIN" : fatal("UNTIL preceded by %s (not BEGIN)" % code)
    pcode.append(rJz)
    pcode.append(slot)

def cWhile (pcode) :
    if not cStack : fatal("No BEGIN for WHILE to match")
    pcode.append(rJz)

def cRepeat (pcode) :
    if not cStack : fatal("No BEGIN for REPEAT to match")

def cDo (pcode) :
    cStack.append(("DO",len(pcode)))  # flag for following UNTIL
    pcode.append(rSwap)
    pcode.append(rgtR)
    pcode.append(rgtR)

def cLoop (pcode) :
    if not cStack : fatal("No DO for LOOP to match")
    code,slot = cStack.pop()
    if code != "DO" : fatal("LOOP preceded by %s (not DO)" % code)
    pcode.append(rRgt)
    pcode.append(rRgt)
    pcode.append(rSwap)
    pcode.append(rOneplus)
    pcode.append(rOver)
    pcode.append(rOver)
    pcode.append(rEq)
    pcode.append(rJz)
    pcode.append(slot)
    pcode.append(rDrop)
    pcode.append(rDrop)

def cLoopPlus (pcode) :
    if not cStack : fatal("No DO for LOOP to match")
    code,slot = cStack.pop()
    if code != "DO" : fatal("+LOOP preceded by %s (not DO)" % code)
    pcode.append(rRgt)
    pcode.append(rRgt)
    pcode.append(rSwap)
    pcode.append(rRot)
    pcode.append(rAdd)
    pcode.append(rOver)
    pcode.append(rOver)
    pcode.append(rSwap)
    pcode.append(rLt)
    pcode.append(rJz)
    pcode.append(slot)
    pcode.append(rDrop)
    pcode.append(rDrop)

def cI (pcode) :
    pcode.append(rRat)

def cJ (pcode) :
    pcode.append(rRgt)
    pcode.append(rRgt)
    pcode.append(rRgt)
    pcode.append(rDup)
    pcode.append(rgtR)
    pcode.append(rSwap)
    pcode.append(rgtR)
    pcode.append(rSwap)
    pcode.append(rgtR)

def cIf (pcode) :
    pcode.append(rJz)
    cStack.append(("IF",len(pcode)))  # flag for following Then or Else
    pcode.append(0)                   # slot to be filled in

def cElse (pcode) :
    if not cStack : fatal("No IF for ELSE to match")
    code,slot = cStack.pop()
    if code != "IF" : fatal("ELSE preceded by %s (not IF)" % code)
    pcode.append(rJmp)
    cStack.append(("ELSE",len(pcode)))  # flag for following THEN
    pcode.append(0)                     # slot to be filled in
    pcode[slot] = len(pcode)            # close JZ for IF

def cThen (pcode) :
    if not cStack : fatal("No IF or ELSE for THEN to match")
    code,slot = cStack.pop()
    if code not in ("IF","ELSE") : fatal("THEN preceded by %s (not IF or ELSE)" % code)
    pcode[slot] = len(pcode)             # close JZ for IF or JMP for ELSE

cDict = {
  ':'    : cColon, ';'    : cSemi, 'if': cIf, 'else': cElse, 'then': cThen,
  'begin': cBegin, 'until': cUntil,
'do': cDo, 'loop': cLoop, '+loop' : cLoopPlus, 'i' : cI , 'j' : cJ , 'while' : cWhile, 'repeat' : cRepeat,
}
  
if __name__ == "__main__" : main()
#END
EXPORT FORTH()
BEGIN
PYTHON(name);
END;