X-Git-Url: https://thelambdalab.xyz/gitweb/index.cgi?p=forth.jl.git;a=blobdiff_plain;f=src%2Fforth.jl;h=d911e211b533a57d7268ce5c1f3264550007ba0c;hp=a233743809fa806017a4ce0313d8d454fc51114d;hb=0740fc602aa3b2013e43448228a5fecf401848c3;hpb=366db53c2e77d243c744c11f68b8bdeb575c86e6 diff --git a/src/forth.jl b/src/forth.jl index a233743..d911e21 100644 --- a/src/forth.jl +++ b/src/forth.jl @@ -1,5 +1,7 @@ module forth +import Base.REPLCompletions + # VM mem size size_mem = 1000000 # 1 mega-int @@ -7,47 +9,29 @@ size_mem = 1000000 # 1 mega-int size_RS = 1000 # Return stack size size_PS = 1000 # Parameter stack size size_TIB = 1000 # Terminal input buffer size +size_FIB = 1000 # File input buffer size -# The mem array constitutes the memory of the VM. It has the following geography: -# -# mem = +-----------------------+ -# | Built-in Variables | -# +-----------------------+ -# | Return Stack | -# +-----------------------+ -# | Parameter Stack | -# +-----------------------+ -# | Terminal Input Buffer | -# +-----------------------+ -# | Dictionary | -# +-----------------------+ -# -# Note that all words (user-defined, primitive, variables, etc) are included in -# the dictionary. -# -# Simple linear addressing is used with one exception: references to primitive code -# blocks, which are represented as anonymous functions, appear as negative indicies -# into the primitives array which contains these functions. - +# Memory arrays mem = Array{Int64,1}(size_mem) primitives = Array{Function,1}() -primNames = Array{ASCIIString,1}() +primNames = Array{AbstractString,1}() -# Built-in variables +# Memory geography and built-in variables nextVarAddr = 1 -RSP0 = nextVarAddr; nextVarAddr += 1 -PSP0 = nextVarAddr; nextVarAddr += 1 -HERE = nextVarAddr; nextVarAddr += 1 -LATEST = nextVarAddr; nextVarAddr += 1 +H = nextVarAddr; nextVarAddr += 1 # Next free memory address +FORTH_LATEST = nextVarAddr; nextVarAddr += 1 # FORTH dict latest +CURRENT = nextVarAddr; nextVarAddr += 1 # Current compilation dict -mem[RSP0] = nextVarAddr # bottom of RS -mem[PSP0] = mem[RSP0] + size_RS # bottom of PS -TIB = mem[PSP0] + size_PS # address of terminal input buffer -mem[HERE] = TIB + size_TIB # location of bottom of dictionary -mem[LATEST] = 0 # no previous definition +RSP0 = nextVarAddr # bottom of RS +PSP0 = RSP0 + size_RS # bottom of PS +TIB = PSP0 + size_PS # address of terminal input buffer +FIB = TIB + size_TIB # address of terminal input buffer +mem[H] = FIB + size_FIB # location of bottom of dictionary +mem[FORTH_LATEST] = 0 # zero FORTH dict latest (no previous def) +mem[CURRENT] = FORTH_LATEST-1 # Compile words to system dict initially -DICT = mem[HERE] # Save bottom of dictionary as constant +DICT = mem[H] # Save bottom of dictionary as constant # VM registers type Reg @@ -56,32 +40,36 @@ type Reg IP::Int64 # Instruction pointer W::Int64 # Working register end -reg = Reg(mem[RSP0], mem[PSP0], 0, 0) +reg = Reg(RSP0, PSP0, 0, 0) # Stack manipulation functions -type ParamStackUnderflow <: Exception end -type ReturnStackUnderflow <: Exception end - -Base.showerror(io::IO, ex::ParamStackUnderflow) = print(io, "Parameter stack underflow.") -Base.showerror(io::IO, ex::ReturnStackUnderflow) = print(io, "Return stack underflow.") - -getRSDepth() = reg.RSP - mem[RSP0] -getPSDepth() = reg.PSP - mem[PSP0] - function ensurePSDepth(depth::Int64) - if getPSDepth()= PSP0 + size_PS + error("Parameter stack overflow.") end end function ensureRSDepth(depth::Int64) - if getRSDepth()= RSP0 + size_RS + error("Return stack overflow.") end end function pushRS(val::Int64) + ensureRSCapacity(1) mem[reg.RSP+=1] = val end @@ -94,6 +82,8 @@ function popRS() end function pushPS(val::Int64) + ensurePSCapacity(1) + mem[reg.PSP += 1] = val end @@ -107,12 +97,15 @@ end # Handy functions for adding/retrieving strings to/from memory. -getString(addr::Int64, len::Int64) = ASCIIString([Char(c) for c in mem[addr:(addr+len-1)]]) +getString(addr::Int64, len::Int64) = AbstractString([Char(c) for c in mem[addr:(addr+len-1)]]) -function putString(str::ASCIIString, addr::Int64) - mem[addr:(addr+length(str)-1)] = [Int64(c) for c in str] +function putString(str::AbstractString, addr::Int64, maxLen::Int64) + len = min(length(str), maxLen) + mem[addr:(addr+len-1)] = [Int64(c) for c in str] end +stringAsInts(str::AbstractString) = [Int(c) for c in collect(str)] + # Primitive creation and calling functions function defPrim(f::Function; name="nameless") @@ -133,25 +126,32 @@ getPrimName(addr::Int64) = primNames[-addr] # Word creation functions -F_IMMED = 128 -F_HIDDEN = 256 -F_LENMASK = 127 +F_LENMASK = 31 +F_IMMED = 32 +F_HIDDEN = 64 +NFA_MARK = 128 + +function dictWrite(ints::Array{Int64,1}) + mem[mem[H]:(mem[H]+length(ints)-1)] = ints + mem[H] += length(ints) +end +dictWrite(int::Int64) = dictWrite([int]) +dictWriteString(string::AbstractString) = dictWrite([Int64(c) for c in string]) function createHeader(name::AbstractString, flags::Int64) - mem[mem[HERE]] = mem[LATEST] - mem[LATEST] = mem[HERE] - mem[HERE] += 1 + mem[mem[H]] = mem[mem[CURRENT]+1] + mem[mem[CURRENT]+1] = mem[H] + mem[H] += 1 - mem[mem[HERE]] = length(name) | flags; mem[HERE] += 1 - putString(name, mem[HERE]); mem[HERE] += length(name) + dictWrite(length(name) | flags | NFA_MARK) + dictWriteString(name) end function defPrimWord(name::AbstractString, f::Function; flags::Int64=0) createHeader(name, flags) - codeWordAddr = mem[HERE] - mem[codeWordAddr] = defPrim(f, name=name) - mem[HERE] += 1 + codeWordAddr = mem[H] + dictWrite(defPrim(f, name=name)) return codeWordAddr end @@ -159,14 +159,10 @@ end function defWord(name::AbstractString, wordAddrs::Array{Int64,1}; flags::Int64=0) createHeader(name, flags) - addr = mem[HERE] - mem[mem[HERE]] = DOCOL - mem[HERE] += 1 + addr = mem[H] + dictWrite(DOCOL) - for wordAddr in wordAddrs - mem[mem[HERE]] = wordAddr - mem[HERE] += 1 - end + dictWrite(wordAddrs) return addr end @@ -181,25 +177,28 @@ function defExistingVar(name::AbstractString, varAddr::Int64; flags::Int64=0) end))) end -function defNewVar(name::AbstractString, initial::Int64; flags::Int64=0) +function defNewVar(name::AbstractString, initial::Array{Int64,1}; flags::Int64=0) createHeader(name, flags) - codeWordAddr = mem[HERE] - varAddr = mem[HERE] + 1 + codeWordAddr = mem[H] + varAddr = mem[H] + 1 - mem[mem[HERE]] = DOVAR; mem[HERE] += 1 - mem[mem[HERE]] = initial; mem[HERE] += 1 + dictWrite(DOVAR) + dictWrite(initial) return varAddr, codeWordAddr end +defNewVar(name::AbstractString, initial::Int64; flags::Int64=0) = + defNewVar(name, [initial]; flags=flags) + function defConst(name::AbstractString, val::Int64; flags::Int64=0) createHeader(name, flags) - codeWordAddr = mem[HERE] + codeWordAddr = mem[H] - mem[mem[HERE]] = DOCON; mem[HERE] += 1 - mem[mem[HERE]] = val; mem[HERE] += 1 + dictWrite(DOCON) + dictWrite(val) return codeWordAddr end @@ -228,17 +227,17 @@ DOCON = defPrim(() -> begin return NEXT end, name="DOVAR") -EXIT = defPrimWord("EXIT", () -> begin +EXIT_CFA = defPrimWord("EXIT", () -> begin reg.IP = popRS() return NEXT end) # Dictionary entries for core built-in variables, constants -HERE_CFA = defExistingVar("HERE", HERE) -LATEST_CFA = defExistingVar("LATEST", LATEST) -PSP0_CFA = defExistingVar("PSP0", PSP0) -RSP0_CFA = defExistingVar("RSP0", RSP0) +H_CFA = defExistingVar("H", H) + +PSP0_CFA = defConst("PSP0", PSP0) +RSP0_CFA = defConst("RSP0", RSP0) defConst("DOCOL", DOCOL) defConst("DOCON", DOCON) @@ -250,15 +249,16 @@ defConst("MEMSIZE", size_mem) F_IMMED_CFA = defConst("F_IMMED", F_IMMED) F_HIDDEN_CFA = defConst("F_HIDDEN", F_HIDDEN) F_LENMASK_CFA = defConst("F_LENMASK", F_LENMASK) +NFA_MARK_CFA = defConst("NFA_MARK", NFA_MARK) # Basic forth primitives -DROP = defPrimWord("DROP", () -> begin +DROP_CFA = defPrimWord("DROP", () -> begin popPS() return NEXT end) -SWAP = defPrimWord("SWAP", () -> begin +SWAP_CFA = defPrimWord("SWAP", () -> begin a = popPS() b = popPS() pushPS(a) @@ -266,19 +266,19 @@ SWAP = defPrimWord("SWAP", () -> begin return NEXT end) -DUP = defPrimWord("DUP", () -> begin +DUP_CFA = defPrimWord("DUP", () -> begin ensurePSDepth(1) pushPS(mem[reg.PSP]) return NEXT end) -OVER = defPrimWord("OVER", () -> begin +OVER_CFA = defPrimWord("OVER", () -> begin ensurePSDepth(2) pushPS(mem[reg.PSP-1]) return NEXT end) -ROT = defPrimWord("ROT", () -> begin +ROT_CFA = defPrimWord("ROT", () -> begin a = popPS() b = popPS() c = popPS() @@ -288,7 +288,7 @@ ROT = defPrimWord("ROT", () -> begin return NEXT end) -NROT = defPrimWord("-ROT", () -> begin +NROT_CFA = defPrimWord("-ROT", () -> begin a = popPS() b = popPS() c = popPS() @@ -299,13 +299,13 @@ NROT = defPrimWord("-ROT", () -> begin end) -TWODROP = defPrimWord("2DROP", () -> begin +TWODROP_CFA = defPrimWord("2DROP", () -> begin popPS() popPS() return NEXT end) -TWODUP = defPrimWord("2DUP", () -> begin +TWODUP_CFA = defPrimWord("2DUP", () -> begin ensurePSDepth(2) a = mem[reg.PSP-1] b = mem[reg.PSP] @@ -314,7 +314,7 @@ TWODUP = defPrimWord("2DUP", () -> begin return NEXT end) -TWOSWAP = defPrimWord("2SWAP", () -> begin +TWOSWAP_CFA = defPrimWord("2SWAP", () -> begin a = popPS() b = popPS() c = popPS() @@ -326,7 +326,7 @@ TWOSWAP = defPrimWord("2SWAP", () -> begin return NEXT end) -TWOOVER = defPrimWord("2OVER", () -> begin +TWOOVER_CFA = defPrimWord("2OVER", () -> begin ensurePSDepth(4) a = mem[reg.PSP-3] b = mem[reg.PSP-2] @@ -335,7 +335,7 @@ TWOOVER = defPrimWord("2OVER", () -> begin return NEXT end) -QDUP = defPrimWord("?DUP", () -> begin +QDUP_CFA = defPrimWord("?DUP", () -> begin ensurePSDepth(1) val = mem[reg.PSP] if val != 0 @@ -344,52 +344,52 @@ QDUP = defPrimWord("?DUP", () -> begin return NEXT end) -INCR = defPrimWord("1+", () -> begin +INCR_CFA = defPrimWord("1+", () -> begin ensurePSDepth(1) mem[reg.PSP] += 1 return NEXT end) -DECR = defPrimWord("1-", () -> begin +DECR_CFA = defPrimWord("1-", () -> begin ensurePSDepth(1) mem[reg.PSP] -= 1 return NEXT end) -INCR2 = defPrimWord("2+", () -> begin +INCR2_CFA = defPrimWord("2+", () -> begin ensurePSDepth(1) mem[reg.PSP] += 2 return NEXT end) -DECR2 = defPrimWord("2-", () -> begin +DECR2_CFA = defPrimWord("2-", () -> begin ensurePSDepth(1) mem[reg.PSP] -= 2 return NEXT end) -ADD = defPrimWord("+", () -> begin +ADD_CFA = defPrimWord("+", () -> begin b = popPS() a = popPS() pushPS(a+b) return NEXT end) -SUB = defPrimWord("-", () -> begin +SUB_CFA = defPrimWord("-", () -> begin b = popPS() a = popPS() pushPS(a-b) return NEXT end) -MUL = defPrimWord("*", () -> begin +MUL_CFA = defPrimWord("*", () -> begin b = popPS() a = popPS() pushPS(a*b) return NEXT end) -DIVMOD = defPrimWord("/MOD", () -> begin +DIVMOD_CFA = defPrimWord("/MOD", () -> begin b = popPS() a = popPS() q,r = divrem(a,b) @@ -398,117 +398,117 @@ DIVMOD = defPrimWord("/MOD", () -> begin return NEXT end) -TWOMUL = defPrimWord("2*", () -> begin +TWOMUL_CFA = defPrimWord("2*", () -> begin pushPS(popPS() << 1) return NEXT end) -TWODIV = defPrimWord("2/", () -> begin +TWODIV_CFA = defPrimWord("2/", () -> begin pushPS(popPS() >> 1) return NEXT end) -EQ = defPrimWord("=", () -> begin +EQ_CFA = defPrimWord("=", () -> begin b = popPS() a = popPS() pushPS(a==b ? -1 : 0) return NEXT end) -NE = defPrimWord("<>", () -> begin +NE_CFA = defPrimWord("<>", () -> begin b = popPS() a = popPS() pushPS(a!=b ? -1 : 0) return NEXT end) -LT = defPrimWord("<", () -> begin +LT_CFA = defPrimWord("<", () -> begin b = popPS() a = popPS() pushPS(a", () -> begin +GT_CFA = defPrimWord(">", () -> begin b = popPS() a = popPS() pushPS(a>b ? -1 : 0) return NEXT end) -LE = defPrimWord("<=", () -> begin +LE_CFA = defPrimWord("<=", () -> begin b = popPS() a = popPS() pushPS(a<=b ? -1 : 0) return NEXT end) -GE = defPrimWord(">=", () -> begin +GE_CFA = defPrimWord(">=", () -> begin b = popPS() a = popPS() pushPS(a>=b ? -1 : 0) return NEXT end) -ZE = defPrimWord("0=", () -> begin +ZE_CFA = defPrimWord("0=", () -> begin pushPS(popPS() == 0 ? -1 : 0) return NEXT end) -ZNE = defPrimWord("0<>", () -> begin +ZNE_CFA = defPrimWord("0<>", () -> begin pushPS(popPS() != 0 ? -1 : 0) return NEXT end) -ZLT = defPrimWord("0<", () -> begin +ZLT_CFA = defPrimWord("0<", () -> begin pushPS(popPS() < 0 ? -1 : 0) return NEXT end) -ZGT = defPrimWord("0>", () -> begin +ZGT_CFA = defPrimWord("0>", () -> begin pushPS(popPS() > 0 ? -1 : 0) return NEXT end) -ZLE = defPrimWord("0<=", () -> begin +ZLE_CFA = defPrimWord("0<=", () -> begin pushPS(popPS() <= 0 ? -1 : 0) return NEXT end) -ZGE = defPrimWord("0>=", () -> begin +ZGE_CFA = defPrimWord("0>=", () -> begin pushPS(popPS() >= 0 ? -1 : 0) return NEXT end) -AND = defPrimWord("AND", () -> begin +AND_CFA = defPrimWord("AND", () -> begin b = popPS() a = popPS() pushPS(a & b) return NEXT end) -OR = defPrimWord("OR", () -> begin +OR_CFA = defPrimWord("OR", () -> begin b = popPS() a = popPS() pushPS(a | b) return NEXT end) -XOR = defPrimWord("XOR", () -> begin +XOR_CFA = defPrimWord("XOR", () -> begin b = popPS() a = popPS() pushPS(a $ b) return NEXT end) -INVERT = defPrimWord("INVERT", () -> begin +INVERT_CFA = defPrimWord("INVERT", () -> begin pushPS(~popPS()) return NEXT end) # Literals -LIT = defPrimWord("LIT", () -> begin +LIT_CFA = defPrimWord("LIT", () -> begin pushPS(mem[reg.IP]) reg.IP += 1 return NEXT @@ -516,27 +516,27 @@ end) # Memory primitives -STORE = defPrimWord("!", () -> begin +STORE_CFA = defPrimWord("!", () -> begin addr = popPS() dat = popPS() mem[addr] = dat return NEXT end) -FETCH = defPrimWord("@", () -> begin +FETCH_CFA = defPrimWord("@", () -> begin addr = popPS() pushPS(mem[addr]) return NEXT end) -ADDSTORE = defPrimWord("+!", () -> begin +ADDSTORE_CFA = defPrimWord("+!", () -> begin addr = popPS() toAdd = popPS() mem[addr] += toAdd return NEXT end) -SUBSTORE = defPrimWord("-!", () -> begin +SUBSTORE_CFA = defPrimWord("-!", () -> begin addr = popPS() toSub = popPS() mem[addr] -= toSub @@ -546,98 +546,245 @@ end) # Return Stack -TOR = defPrimWord(">R", () -> begin +TOR_CFA = defPrimWord(">R", () -> begin pushRS(popPS()) return NEXT end) -FROMR = defPrimWord("R>", () -> begin +FROMR_CFA = defPrimWord("R>", () -> begin pushPS(popRS()) return NEXT end) -RFETCH = defPrimWord("R@", () -> begin +RFETCH_CFA = defPrimWord("R@", () -> begin pushPS(mem[reg.RSP]) return NEXT end) -RSPFETCH = defPrimWord("RSP@", () -> begin +RSPFETCH_CFA = defPrimWord("RSP@", () -> begin pushPS(reg.RSP) return NEXT end) -RSPSTORE = defPrimWord("RSP!", () -> begin - RSP = popPS() +RSPSTORE_CFA = defPrimWord("RSP!", () -> begin + reg.RSP = popPS() return NEXT end) -RDROP = defPrimWord("RDROP", () -> begin +RDROP_CFA = defPrimWord("RDROP", () -> begin popRS() return NEXT end) # Parameter Stack -PSPFETCH = defPrimWord("PSP@", () -> begin +PSPFETCH_CFA = defPrimWord("PSP@", () -> begin pushPS(reg.PSP) return NEXT end) -PSPSTORE = defPrimWord("PSP!", () -> begin - PSP = popPS() +PSPSTORE_CFA = defPrimWord("PSP!", () -> begin + reg.PSP = popPS() return NEXT end) # Working Register -WFETCH = defPrimWord("W@", () -> begin +WFETCH_CFA = defPrimWord("W@", () -> begin pushPS(reg.W) return NEXT end) -WSTORE = defPrimWord("W!", () -> begin +WSTORE_CFA = defPrimWord("W!", () -> begin reg.W = popPS() return NEXT end) # I/O -sources = Array{Any,1}() -currentSource() = sources[length(sources)] +openFiles = Dict{Int64,IOStream}() +nextFileID = 1 + + +## File access modes +FAM_RO = 0 +FAM_WO = 1 +FAM_RO_CFA = defConst("R/O", FAM_RO) +FAM_WO_CFA = defConst("W/O", FAM_WO) -EOF = defPrimWord("\x04", () -> begin - close(pop!(sources)) - if !isempty(sources) +function fileOpener(create::Bool) + fnameLen = popPS() + fnameAddr = popPS() + fam = popPS() + + fname = getString(fnameAddr, fnameLen) + + if create && !isfile(fname) + pushPS(0) + pushPS(-1) # error return NEXT + end + + if (fam == FAM_RO) + mode = "r" else - return 0 + mode = "w" + end + + openFiles[nextFileID] = open(fname, mode) + pushPS(nextFileID) + pushPS(0) + + nextFileID += 1 +end + +OPEN_FILE_CFA = defPrimWord("OPEN-FILE", () -> begin + fileOpener(false) + return NEXT +end); + +CREATE_FILE_CFA = defPrimWord("CREATE-FILE", () -> begin + fileOpener(true) + return NEXT +end); + +CLOSE_FILE_CFA = defPrimWord("CLOSE-FILE", () -> begin + fid = popPS() + close(openFiles[fid]) + delete!(openFiles, fid) + return NEXT +end) + +CLOSE_FILES_CFA = defPrimWord("CLOSE-FILES", () -> begin + for fh in values(openFiles) + close(fh) end + empty!(openFiles) + + return NEXT +end) + +READ_LINE_CFA = defPrimWord("READ-LINE", () -> begin + return NEXT end) -EMIT = defPrimWord("EMIT", () -> begin + +EMIT_CFA = defPrimWord("EMIT", () -> begin print(Char(popPS())) return NEXT end) +function raw_mode!(mode::Bool) + if ccall(:jl_tty_set_mode, Int32, (Ptr{Void}, Int32), STDIN.handle, mode) != 0 + throw("FATAL: Terminal unable to enter raw mode.") + end +end + +function getKey() + raw_mode!(true) + byte = readbytes(STDIN, 1)[1] + raw_mode!(false) + + if byte == 0x0d + return 0x0a + elseif byte == 127 + return 0x08 + else + return byte + end +end + +KEY_CFA = defPrimWord("KEY", () -> begin + pushPS(Int(getKey())) + return NEXT +end) + +function getLineFromSTDIN() + + function getFrag(s) + chars = collect(s) + slashIdx = findlast(chars, '\\') + + if slashIdx > 0 + return join(chars[slashIdx:length(chars)]) + else + return nothing + end + end + + function backspaceStr(s, bsCount) + oldLen = length(s) + newLen = max(0, oldLen - bsCount) + return join(collect(s)[1:newLen]) + end + + line = "" + while true + key = Char(getKey()) + + if key == '\n' + print(" ") + return AbstractString(line) + + elseif key == '\x04' + if isempty(line) + return string("\x04") + end + + elseif key == '\b' + if !isempty(line) + print("\b\033[K") + line = backspaceStr(line, 1) + end + + elseif key == '\e' + # Strip ANSI escape sequence + nextKey = Char(getKey()) + if nextKey == '[' + while true + nextKey = Char(getKey()) + if nextKey >= '@' || nextKey <= '~' + break + end + end + end + + elseif key == '\t' + # Currently do nothing + + frag = getFrag(line) + if frag != nothing + if haskey(REPLCompletions.latex_symbols, frag) + print(repeat("\b", length(frag))) + print("\033[K") + comp = REPLCompletions.latex_symbols[frag] + line = string(backspaceStr(line, length(frag)), comp) + print(comp) + end + end + + else + print(key) + line = string(line, key) + end + end +end + SPAN, SPAN_CFA = defNewVar("SPAN", 0) -EXPECT = defPrimWord("EXPECT", () -> begin +EXPECT_CFA = defPrimWord("EXPECT", () -> begin maxLen = popPS() addr = popPS() - if !eof(currentSource()) - line = chomp(readline(currentSource())) - mem[SPAN] = min(length(line), maxLen) - putString(line[1:mem[SPAN]], addr) - else - mem[SPAN] = 1 - mem[addr] = 4 # eof - end + line = getLineFromSTDIN() + + mem[SPAN] = min(length(line), maxLen) + putString(line, addr, maxLen) return NEXT end) BASE, BASE_CFA = defNewVar("BASE", 10) -NUMBER = defPrimWord("NUMBER", () -> begin +NUMBER_CFA = defPrimWord("NUMBER", () -> begin wordAddr = popPS()+1 wordLen = mem[wordAddr-1] @@ -650,59 +797,114 @@ end) # Dictionary searches -FIND = defPrimWord("FIND", () -> begin +FROMLINK_CFA = defPrimWord("LINK>", () -> begin + + addr = popPS() + lenAndFlags = mem[addr+1] + len = lenAndFlags & F_LENMASK + + pushPS(addr + 2 + len) + + return NEXT +end) + +NUMCONTEXT, NUMCONTEXT_CFA = defNewVar("#CONTEXT", 1) + +createHeader("FORTH", 0) +FORTH_CFA = mem[H] +dictWrite(defPrim(() -> begin + mem[CONTEXT + mem[NUMCONTEXT] - 1] = reg.W + return NEXT +end, name="FORTH")) +dictWrite(0) # cell for latest + +CURRENT_CFA = defExistingVar("CURRENT", CURRENT) + +# Switch to new FORTH vocabulary cfa +mem[FORTH_CFA+1] = mem[mem[CURRENT]+1] +mem[CURRENT] = FORTH_CFA +CONTEXT, CONTEXT_CFA = defNewVar("CONTEXT", zeros(Int64, 10)) +mem[CONTEXT] = FORTH_CFA + +FINDVOCAB_CFA = defPrimWord("FINDVOCAB", () -> begin + vocabCFA = popPS() countedAddr = popPS() + wordAddr = countedAddr + 1 wordLen = mem[countedAddr] word = lowercase(getString(wordAddr, wordLen)) - latest = LATEST - - i = 0 - while (latest = mem[latest]) > 0 - lenAndFlags = mem[latest+1] + lfa = vocabCFA+1 + lenAndFlags = 0 + + while (lfa = mem[lfa]) > 0 + + lenAndFlags = mem[lfa+1] len = lenAndFlags & F_LENMASK hidden = (lenAndFlags & F_HIDDEN) == F_HIDDEN if hidden || len != wordLen continue end - - thisAddr = latest+2 - thisWord = lowercase(getString(thisAddr, len)) - if lowercase(thisWord) == lowercase(word) + thisWord = lowercase(getString(lfa+2, len)) + + if thisWord == word break end end - pushPS(latest) + if lfa > 0 + pushPS(lfa) + callPrim(mem[FROMLINK_CFA]) + if (lenAndFlags & F_IMMED) == F_IMMED + pushPS(1) + else + pushPS(-1) + end + else + pushPS(countedAddr) + pushPS(0) + end return NEXT end) -TOCFA = defPrimWord(">CFA", () -> begin +FIND_CFA = defPrimWord("FIND", () -> begin - addr = popPS() - lenAndFlags = mem[addr+1] - len = lenAndFlags & F_LENMASK + countedAddr = popPS() + context = mem[CONTEXT:(CONTEXT+mem[NUMCONTEXT]-1)] - pushPS(addr + 2 + len) + for vocabCFA in reverse(context) + pushPS(countedAddr) + pushPS(vocabCFA) + callPrim(mem[FINDVOCAB_CFA]) + + callPrim(mem[DUP_CFA]) + if popPS() != 0 + return NEXT + else + popPS() + popPS() + end + end + + pushPS(countedAddr) + pushPS(0) return NEXT end) -TOPFA = defWord(">PFA", [TOCFA, INCR, EXIT]) # Branching -BRANCH = defPrimWord("BRANCH", () -> begin +BRANCH_CFA = defPrimWord("BRANCH", () -> begin reg.IP += mem[reg.IP] return NEXT end) -ZBRANCH = defPrimWord("0BRANCH", () -> begin +ZBRANCH_CFA = defPrimWord("0BRANCH", () -> begin if (popPS() == 0) reg.IP += mem[reg.IP] else @@ -714,7 +916,7 @@ end) # Strings -LITSTRING = defPrimWord("LITSTRING", () -> begin +LITSTRING_CFA = defPrimWord("LITSTRING", () -> begin len = mem[reg.IP] reg.IP += 1 pushPS(reg.IP) @@ -724,7 +926,7 @@ LITSTRING = defPrimWord("LITSTRING", () -> begin return NEXT end) -TYPE = defPrimWord("TYPE", () -> begin +TYPE_CFA = defPrimWord("TYPE", () -> begin len = popPS() addr = popPS() str = getString(addr, len) @@ -732,58 +934,60 @@ TYPE = defPrimWord("TYPE", () -> begin return NEXT end) -# Outer interpreter +# Interpreter/Compiler-specific I/O -TRACE = defPrimWord("TRACE", () -> begin - println("reg.W: $(reg.W) reg.IP: $(reg.IP)") - print("PS: "); printPS() - print("RS: "); printRS() - print("[paused]") - readline() - - return NEXT -end) +TIB_CFA = defConst("TIB", TIB) +NUMTIB, NUMTIB_CFA = defNewVar("#TIB", 0) -COMMA = defPrimWord(",", () -> begin - mem[mem[HERE]] = popPS() - mem[HERE] += 1 +FIB_CFA = defConst("FIB", TIB) +NUMFIB, NUMFIB_CFA = defNewVar("#FIB", 0) - return NEXT -end) +TOIN, TOIN_CFA = defNewVar(">IN", 0) -BTICK = defWord("[']", - [FROMR, DUP, INCR, TOR, FETCH, EXIT]) +SOURCE_ID, SOURCE_ID_CFA = defNewVar("SOURCE-ID", 0) -EXECUTE = defPrimWord("EXECUTE", () -> begin - reg.W = popPS() - return mem[reg.W] +SOURCE_CFA = defPrimWord("SOURCE", () -> begin + if mem[SOURCE_ID] == 0 + pushPS(TIB) + pushPS(NUMTIB) + else + pushPS(FIB) + pushPS(NUMFIB) + end + return NEXT end) -TIB_CFA = defConst("TIB", TIB) -NUMTIB, NUMTIB_CFA = defNewVar("#TIB", 0) -TOIN, TOIN_CFA = defNewVar(">IN", 0) +QUERY_CFA = defWord("QUERY", + [TIB_CFA, LIT_CFA, 160, EXPECT_CFA, + SPAN_CFA, FETCH_CFA, NUMTIB_CFA, STORE_CFA, + LIT_CFA, 0, TOIN_CFA, STORE_CFA, + EXIT_CFA]) -QUERY = defWord("QUERY", - [TIB_CFA, LIT, 80, EXPECT, - SPAN_CFA, FETCH, NUMTIB_CFA, STORE, - LIT, 0, TOIN_CFA, STORE, - EXIT]) +QUERY_FILE_CFA = defWord("QUERY-FILE", + [FIB_CFA, LIT_CFA, 160, ROT_CFA, READ_LINE_CFA, + DROP_CFA, SWAP_CFA, + NUMFIB_CFA, STORE_CFA, + EXIT_CFA]) -WORD = defPrimWord("WORD", () -> begin +WORD_CFA = defPrimWord("WORD", () -> begin delim = popPS() + callPrim(mem[SOURCE_CFA]) + sizeAddr = popPS() + bufferAddr = popPS() + # Chew up initial occurrences of delim - while (mem[TOIN] begin return NEXT end) -PARSE = defPrimWord("PARSE", () -> begin - delim = popPS() +# Compilation - # Chew up initial occurrences of delim - addr = mem[HERE] +STATE, STATE_CFA = defNewVar("STATE", 0) - # Start reading input stream - count = 0 - while (mem[TOIN] begin + mem[mem[H]] = popPS() + mem[H] += 1 - if (mem[addr] == delim) - break - end + return NEXT +end) - count += 1 - addr += 1 - end +HERE_CFA = defWord("HERE", + [H_CFA, FETCH_CFA, EXIT_CFA]) + +HEADER_CFA = defPrimWord("HEADER", () -> begin + wordAddr = popPS()+1 + wordLen = mem[wordAddr-1] + word = getString(wordAddr, wordLen) - pushPS(addr) - pushPS(count) + createHeader(word, 0) return NEXT end) -BYE = defPrimWord("BYE", () -> begin - println("Bye!") - return 0 -end) - -STATE, STATE_CFA = defNewVar("STATE", 0) +CREATE_CFA = defWord("CREATE", + [LIT_CFA, 32, WORD_CFA, HEADER_CFA, + LIT_CFA, DOVAR, COMMA_CFA, + EXIT_CFA]) -INTERPRET = defWord("INTERPRET", - [LIT, 32, WORD, # Read next space-delimited word +DODOES = defPrim(() -> begin + pushRS(reg.IP) + reg.IP = popPS() + pushPS(reg.W + 1) + return NEXT +end, name="DODOES") - DUP, FETCH, ZE, ZBRANCH, 3, - DROP, EXIT, # Exit if TIB is exhausted +DOES_HELPER_CFA = defPrimWord("(DOES>)", () -> begin - STATE_CFA, FETCH, ZBRANCH, 31, - # Compiling - DUP, FIND, QDUP, ZBRANCH, 19, + pushPS(mem[mem[CURRENT]+1]) + callPrim(mem[FROMLINK_CFA]) + cfa = popPS() - # Found word. - SWAP, DROP, - DUP, TOCFA, SWAP, INCR, FETCH, LIT, F_IMMED, AND, ZBRANCH, 4, - # Immediate: Execute! - EXECUTE, BRANCH, -33, + runtimeAddr = popPS() - # Not immediate: Compile! - COMMA, BRANCH, -36, + mem[cfa] = defPrim(eval(:(() -> begin + pushPS($(runtimeAddr)) + return DODOES + end)), name="doesPrim") - # No word found, parse number - NUMBER, BTICK, LIT, COMMA, COMMA, BRANCH, -43, - - # Interpreting - DUP, FIND, QDUP, ZBRANCH, 7, + return NEXT +end, flags=F_IMMED | F_HIDDEN) - # Found word. Execute! - SWAP, DROP, TOCFA, EXECUTE, BRANCH, -54, +DOES_CFA = defWord("DOES>", + [LIT_CFA, LIT_CFA, COMMA_CFA, HERE_CFA, LIT_CFA, 3, ADD_CFA, COMMA_CFA, + LIT_CFA, DOES_HELPER_CFA, COMMA_CFA, LIT_CFA, EXIT_CFA, COMMA_CFA, EXIT_CFA], + flags=F_IMMED) - # No word found, parse number and leave on stack - NUMBER, BRANCH, -57, - EXIT] -) +LBRAC_CFA = defPrimWord("[", () -> begin + mem[STATE] = 0 + return NEXT +end, flags=F_IMMED) -PROMPT = defPrimWord("PROMPT", () -> begin - if (mem[STATE] == 0 && currentSource() == STDIN) - println(" ok") - end +RBRAC_CFA = defPrimWord("]", () -> begin + mem[STATE] = 1 + return NEXT +end, flags=F_IMMED) +HIDDEN_CFA = defPrimWord("HIDDEN", () -> begin + lenAndFlagsAddr = mem[mem[CURRENT]+1] + 1 + mem[lenAndFlagsAddr] = mem[lenAndFlagsAddr] $ F_HIDDEN return NEXT end) -QUIT = defWord("QUIT", - [RSP0_CFA, RSPSTORE, - QUERY, - INTERPRET, PROMPT, - BRANCH,-4]) +COLON_CFA = defWord(":", + [LIT_CFA, 32, WORD_CFA, + HEADER_CFA, + LIT_CFA, DOCOL, COMMA_CFA, + HIDDEN_CFA, + RBRAC_CFA, + EXIT_CFA]) + +SEMICOLON_CFA = defWord(";", + [LIT_CFA, EXIT_CFA, COMMA_CFA, + HIDDEN_CFA, + LBRAC_CFA, + EXIT_CFA], flags=F_IMMED) + +IMMEDIATE_CFA = defPrimWord("IMMEDIATE", () -> begin + lenAndFlagsAddr = mem[mem[CURRENT]+1] + 1 + mem[lenAndFlagsAddr] = mem[lenAndFlagsAddr] $ F_IMMED + return NEXT +end, flags=F_IMMED) -INCLUDE = defPrimWord("INCLUDE", () -> begin +CODE_CFA = defPrimWord("CODE", () -> begin pushPS(32) - callPrim(mem[WORD]) - wordAddr = popPS()+1 - wordLen = mem[wordAddr-1] - word = getString(wordAddr, wordLen) + callPrim(mem[WORD_CFA]) + callPrim(mem[HEADER_CFA]) + + exprString = "() -> begin\n" + while true + if mem[TOIN] >= mem[NUMTIB] + exprString = string(exprString, "\n") + if currentSource() == STDIN + println() + end + + pushPS(TIB) + pushPS(160) + callPrim(mem[EXPECT_CFA]) + mem[NUMTIB] = mem[SPAN] + mem[TOIN] = 0 + end + + pushPS(32) + callPrim(mem[WORD_CFA]) + cAddr = popPS() + thisWord = getString(cAddr+1, mem[cAddr]) + + if uppercase(thisWord) == "END-CODE" + break + end - push!(sources, open(word, "r")) + exprString = string(exprString, " ", thisWord) + end + exprString = string(exprString, "\nreturn NEXT\nend") - # Clear input buffer - mem[NUMTIB] = 0 + func = eval(parse(exprString)) + dictWrite(defPrim(func)) return NEXT end) -# Compilation +# Outer Interpreter -HEADER = defPrimWord("HEADER", () -> begin - wordAddr = popPS()+1 - wordLen = mem[wordAddr-1] - word = getString(wordAddr, wordLen) +EXECUTE_CFA = defPrimWord("EXECUTE", () -> begin + reg.W = popPS() + return mem[reg.W] +end) - createHeader(word, 0) +INTERPRET_CFA = defWord("INTERPRET", + [LIT_CFA, 32, WORD_CFA, # Read next space-delimited word - return NEXT -end) + DUP_CFA, FETCH_CFA, ZE_CFA, ZBRANCH_CFA, 3, + DROP_CFA, EXIT_CFA, # Exit if TIB is exhausted -LBRAC = defPrimWord("[", () -> begin - mem[STATE] = 0 - return NEXT -end, flags=F_IMMED) + STATE_CFA, FETCH_CFA, ZBRANCH_CFA, 24, + # Compiling + FIND_CFA, QDUP_CFA, ZBRANCH_CFA, 13, -RBRAC = defPrimWord("]", () -> begin - mem[STATE] = 1 - return NEXT -end, flags=F_IMMED) + # Found word. + LIT_CFA, -1, EQ_CFA, INVERT_CFA, ZBRANCH_CFA, 4, -HIDDEN = defPrimWord("HIDDEN", () -> begin - addr = popPS() + 1 - mem[addr] = mem[addr] $ F_HIDDEN - return NEXT -end) + # Immediate: Execute! + EXECUTE_CFA, BRANCH_CFA, -26, -HIDE = defWord("HIDE", - [LIT, 32, WORD, - FIND, - HIDDEN, - EXIT]) + # Not immediate: Compile! + COMMA_CFA, BRANCH_CFA, -29, -COLON = defWord(":", - [LIT, 32, WORD, - HEADER, - LIT, DOCOL, COMMA, - LATEST_CFA, FETCH, HIDDEN, - RBRAC, - EXIT]) + # No word found, parse number + NUMBER_CFA, LIT_CFA, LIT_CFA, COMMA_CFA, COMMA_CFA, BRANCH_CFA, -36, + + # Interpreting + FIND_CFA, QDUP_CFA, ZBRANCH_CFA, 5, -SEMICOLON = defWord(";", - [LIT, EXIT, COMMA, - LATEST_CFA, FETCH, HIDDEN, - LBRAC, - EXIT], flags=F_IMMED) + # Found word. Execute! + DROP_CFA, EXECUTE_CFA, BRANCH_CFA, -44, + + # No word found, parse number and leave on stack + NUMBER_CFA, BRANCH_CFA, -47, + EXIT_CFA]) + +PROMPT_CFA = defPrimWord("PROMPT", () -> begin + if mem[STATE] == 0 + print(" ok") + end + println() -IMMEDIATE = defPrimWord("IMMEDIATE", () -> begin - lenAndFlagsAddr = mem[LATEST] + 1 - mem[lenAndFlagsAddr] = mem[lenAndFlagsAddr] $ F_IMMED return NEXT -end, flags=F_IMMED) +end) + +QUIT_CFA = defWord("QUIT", + [LIT_CFA, 0, STATE_CFA, STORE_CFA, + LIT_CFA, 0, NUMTIB_CFA, STORE_CFA, + RSP0_CFA, RSPSTORE_CFA, + QUERY_CFA, + INTERPRET_CFA, PROMPT_CFA, + BRANCH_CFA,-4]) +ABORT_CFA = defWord("ABORT", + [CLOSE_FILES_CFA, PSP0_CFA, PSPSTORE_CFA, QUIT_CFA]) + +BYE_CFA = defPrimWord("BYE", () -> begin + println("\nBye!") + return 0 +end) #### VM loop #### @@ -957,19 +1207,19 @@ initialized = false initFileName = nothing if isfile("lib.4th") initFileName = "lib.4th" -elseif isfile(Pkg.dir("forth/src/lib.4th")) - initFileName = Pkg.dir("forth/src/lib.4th") +elseif isfile(Pkg.dir("forth","src", "lib.4th")) + initFileName = Pkg.dir("forth","src","lib.4th") end function run(;initialize=true) - # Begin with STDIN as source - push!(sources, STDIN) global initialized, initFileName if !initialized && initialize if initFileName != nothing print("Including definitions from $initFileName...") - push!(sources, open(initFileName, "r")) + + # TODO + initialized = true else println("No library file found. Only primitive words available.") @@ -977,34 +1227,22 @@ function run(;initialize=true) end # Start with IP pointing to first instruction of outer interpreter - reg.IP = QUIT + 1 + reg.IP = QUIT_CFA + 1 # Primitive processing loop. # Everyting else is simply a consequence of this loop! jmp = NEXT while jmp != 0 try -# println("Entering prim $(getPrimName(jmp))") + #println("Entering prim $(getPrimName(jmp))") jmp = callPrim(jmp) catch ex showerror(STDOUT, ex) println() - while !isempty(sources) && currentSource() != STDIN - close(pop!(sources)) - end - - # Want backtrace in here eventually - println("reg.W: $(reg.W) reg.IP: $(reg.IP)") - print("PS: "); printPS() - print("RS: "); printRS() - - mem[STATE] = 0 - mem[NUMTIB] = 0 - reg.PSP = mem[PSP0] - reg.RSP = mem[RSP0] - reg.IP = QUIT + 1 + # QUIT + reg.IP = ABORT_CFA + 1 jmp = NEXT end end @@ -1012,6 +1250,16 @@ end # Debugging tools +TRACE_CFA = defPrimWord("TRACE", () -> begin + println("reg.W: $(reg.W) reg.IP: $(reg.IP)") + print("PS: "); printPS() + print("RS: "); printRS() + print("[paused]") + readline() + + return NEXT +end) + function dump(startAddr::Int64; count::Int64 = 100, cellsPerLine::Int64 = 10) chars = Array{Char,1}(cellsPerLine) @@ -1041,16 +1289,16 @@ function dump(startAddr::Int64; count::Int64 = 100, cellsPerLine::Int64 = 10) i += 1 end - println("\t", ASCIIString(chars)) + println("\t", AbstractString(chars)) end end function printPS() - count = reg.PSP - mem[PSP0] + count = reg.PSP - PSP0 if count > 0 print("<$count>") - for i in (mem[PSP0]+1):reg.PSP + for i in (PSP0+1):reg.PSP print(" $(mem[i])") end println() @@ -1060,11 +1308,11 @@ function printPS() end function printRS() - count = reg.RSP - mem[RSP0] + count = reg.RSP - RSP0 if count > 0 print("<$count>") - for i in (mem[RSP0]+1):reg.RSP + for i in (RSP0+1):reg.RSP print(" $(mem[i])") end println() @@ -1077,6 +1325,7 @@ DUMP = defPrimWord("DUMP", () -> begin count = popPS() addr = popPS() + println() dump(addr, count=count) return NEXT