X-Git-Url: https://thelambdalab.xyz/gitweb/index.cgi?p=forth.jl.git;a=blobdiff_plain;f=src%2Fforth.jl;h=4c81dc35b59f305078a7a2a08f4e95927b640b8b;hp=1ed96c85458612623a8faffc22372f1c5cdaba22;hb=2de79279a0f7157a41c0f32674ba96f56cb1b02f;hpb=3502b666bc5c477f928d71f84049b7e5ef43ca0d diff --git a/src/forth.jl b/src/forth.jl index 1ed96c8..4c81dc3 100644 --- a/src/forth.jl +++ b/src/forth.jl @@ -1,53 +1,37 @@ module forth +import Base.REPLCompletions, Base.invokelatest + # VM mem size -size_mem = 640*1024 +size_mem = 1000000 # 1 mega-int # Buffer sizes -size_RS = 1024 # Return stack size -size_PS = 1024 # Parameter stack size -size_TIB = 1096 # Terminal 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. +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 +# 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 @@ -55,31 +39,37 @@ type Reg PSP::Int64 # Parameter/data stack pointer IP::Int64 # Instruction pointer W::Int64 # Working register - - source::Any # Input stream in use end -reg = Reg(mem[RSP0], mem[PSP0], 0, 0, STDIN) +reg = Reg(RSP0, PSP0, 0, 0) # Stack manipulation functions -type StackUnderflow <: Exception end - -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 @@ -92,6 +82,8 @@ function popRS() end function pushPS(val::Int64) + ensurePSCapacity(1) + mem[reg.PSP += 1] = val end @@ -105,39 +97,65 @@ 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)]]) -function putString(str::ASCIIString, addr::Int64) +getString(addr::Int64, len::Int64) = String([Char(c) for c in mem[addr:(addr+len-1)]]) + +function putString(str::AbstractString, addr::Int64) mem[addr:(addr+length(str)-1)] = [Int64(c) for c in str] end +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") push!(primitives, f) - push!(primNames, name) + push!(primNames, replace(name, "\004", "EOF")) return -length(primitives) end -callPrim(addr::Int64) = primitives[-addr]() +function callPrim(addr::Int64) + if addr >=0 || -addr>length(primitives) + error("Attempted to execute non-existent primitive at address $addr.") + else + invokelatest(primitives[-addr]) + end +end +getPrimName(addr::Int64) = primNames[-addr] + +# Word creation functions -# Word creation +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 @@ -145,19 +163,15 @@ 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 -# Variable creation +# Variable creation functions function defExistingVar(name::AbstractString, varAddr::Int64; flags::Int64=0) @@ -167,30 +181,30 @@ 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 - f = eval(:(() -> begin - pushPS($(varAddr)) - return NEXT - end)) - - mem[mem[HERE]] = defPrim(f, name=name); 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) - defPrimWord(name, eval(:(() -> begin - pushPS($(val)) - return NEXT - end))) + createHeader(name, flags) - return val + codeWordAddr = mem[H] + + dictWrite(DOCON) + dictWrite(val) + + return codeWordAddr end # Threading Primitives (inner interpreter) @@ -207,19 +221,48 @@ DOCOL = defPrim(() -> begin return NEXT end, name="DOCOL") -EXIT = defPrimWord("EXIT", () -> begin +DOVAR = defPrim(() -> begin + pushPS(reg.W + 1) + return NEXT +end, name="DOVAR") + +DOCON = defPrim(() -> begin + pushPS(mem[reg.W + 1]) + return NEXT +end, name="DOVAR") + +EXIT_CFA = defPrimWord("EXIT", () -> begin reg.IP = popRS() return NEXT end) +# Dictionary entries for core built-in variables, constants + +H_CFA = defExistingVar("H", H) + +PSP0_CFA = defConst("PSP0", PSP0) +RSP0_CFA = defConst("RSP0", RSP0) + +defConst("DOCOL", DOCOL) +defConst("DOCON", DOCON) +defConst("DOVAR", DOVAR) + +defConst("DICT", DICT) +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) @@ -227,44 +270,46 @@ 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() + pushPS(b) pushPS(a) pushPS(c) - pushPS(b) return NEXT end) -NROT = defPrimWord("-ROT", () -> begin +NROT_CFA = defPrimWord("-ROT", () -> begin a = popPS() b = popPS() c = popPS() - pushPS(b) pushPS(a) pushPS(c) + pushPS(b) return NEXT 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] @@ -273,19 +318,28 @@ TWODUP = defPrimWord("2DUP", () -> begin return NEXT end) -TWOSWAP = defPrimWord("2SWAP", () -> begin +TWOSWAP_CFA = defPrimWord("2SWAP", () -> begin a = popPS() b = popPS() c = popPS() d = popPS() pushPS(b) pushPS(a) - pushPS(c) pushPS(d) + pushPS(c) + return NEXT +end) + +TWOOVER_CFA = defPrimWord("2OVER", () -> begin + ensurePSDepth(4) + a = mem[reg.PSP-3] + b = mem[reg.PSP-2] + pushPS(a) + pushPS(b) return NEXT end) -QDUP = defPrimWord("?DUP", () -> begin +QDUP_CFA = defPrimWord("?DUP", () -> begin ensurePSDepth(1) val = mem[reg.PSP] if val != 0 @@ -294,52 +348,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) @@ -348,107 +402,117 @@ DIVMOD = defPrimWord("/MOD", () -> begin return NEXT end) -EQU = defPrimWord("=", () -> begin +TWOMUL_CFA = defPrimWord("2*", () -> begin + pushPS(popPS() << 1) + return NEXT +end) + +TWODIV_CFA = defPrimWord("2/", () -> begin + pushPS(popPS() >> 1) + return NEXT +end) + +EQ_CFA = defPrimWord("=", () -> begin b = popPS() a = popPS() pushPS(a==b ? -1 : 0) return NEXT end) -NEQU = 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) -ZEQU = defPrimWord("0=", () -> begin +ZE_CFA = defPrimWord("0=", () -> begin pushPS(popPS() == 0 ? -1 : 0) return NEXT end) -ZNEQU = 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) + pushPS(xor(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 @@ -456,27 +520,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 @@ -484,222 +548,299 @@ SUBSTORE = defPrimWord("-!", () -> begin end) -# Built-in variables - -HERE_CFA = defExistingVar("HERE", HERE) -LATEST_CFA = defExistingVar("LATEST", LATEST) -PSP0_CFA = defExistingVar("PSP0", PSP0) -RSP0_CFA = defExistingVar("RSP0", RSP0) -STATE, STATE_CFA = defNewVar("STATE", 0) -BASE, BASE_CFA = defNewVar("BASE", 10) - -# Constants - -defConst("VERSION", 1) -defConst("DOCOL", DOCOL) -defConst("DICT", DICT) -F_IMMED = defConst("F_IMMED", 128) -F_HIDDEN = defConst("F_HIDDEN", 256) -F_LENMASK = defConst("F_LENMASK", 127) - # 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) -RSPFETCH = defPrimWord("RSP@", () -> begin +RFETCH_CFA = defPrimWord("R@", () -> begin + pushPS(mem[reg.RSP]) + return NEXT +end) + +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 -defConst("TIB", TIB) -NUMTIB, NUMTIB_CFA = defNewVar("#TIB", 0) -TOIN, TOIN_CFA = defNewVar(">IN", 0) -EOF = defConst("EOF", 4) +openFiles = Dict{Int64,IOStream}() +nextFileID = 1 -KEY = defPrimWord("KEY", () -> begin - if mem[TOIN] >= mem[NUMTIB] - mem[TOIN] = 0 - if !eof(reg.source) - line = readline(reg.source) - mem[NUMTIB] = length(line) - putString(line, TIB) - else - mem[NUMTIB] = 1 - mem[TIB] = EOF - end +## 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) + +function fileOpener(create::Bool) + fam = popPS() + fnameLen = popPS() + fnameAddr = popPS() + + fname = getString(fnameAddr, fnameLen) + + if create && !isfile(fname) + pushPS(0) + pushPS(-1) # error + return NEXT end - pushPS(mem[TIB + mem[TOIN]]) - mem[TOIN] += 1 + if (fam == FAM_RO) + mode = "r" + else + mode = "w" + end + global nextFileID + 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) + + pushPS(0) # Result code 0 return NEXT end) -EMIT = defPrimWord("EMIT", () -> begin - print(Char(popPS())) +CLOSE_FILES_CFA = defPrimWord("CLOSE-FILES", () -> begin + for fh in values(openFiles) + close(fh) + end + empty!(openFiles) + + pushPS(0) # Result code 0 return NEXT end) -WORD = defPrimWord("WORD", () -> begin +READ_LINE_CFA = defPrimWord("READ-LINE", () -> begin + fid = popPS() + maxSize = popPS() + addr = popPS() - eof_char = Char(EOF) - c = eof_char + fh = openFiles[fid] + line = readline(fh, chomp=false) - skip_to_end = false - while true + eofFlag = endswith(line, '\n') ? 0 : -1 + line = chomp(line) - callPrim(mem[KEY]) - c = Char(popPS()) + putString(line, addr, maxSize) - if c == '\\' - skip_to_end = true - continue - end + pushPS(length(line)) + pushPS(eofFlag) + pushPS(0) - if skip_to_end - if c == '\n' || c == eof_char - skip_to_end = false - end - continue - end + return NEXT +end) - if c == ' ' || c == '\t' - continue - end +READ_FILE_CFA = defPrimWord("READ-FILE", () -> begin + fid = popPS() + size = popPS() + addr = popPS() - break - end + fh = openFiles[fid] - wordAddr = mem[HERE] - offset = 0 + string = join(map(x -> Char(x), read(fh, size)), "") - if c == '\n' || c == eof_char - # Treat newline as a special word + eofFlag = length(string) == size ? 0 : -1 ; - mem[wordAddr + offset] = Int64(c) - pushPS(wordAddr) - pushPS(1) - return NEXT - end + putString(string, addr, length(string)) - while true - mem[wordAddr + offset] = Int64(c) - offset += 1 + pushPS(length(string)) + pushPS(eofFlag) - callPrim(mem[KEY]) - c = Char(popPS()) + return NEXT +end) - if c == ' ' || c == '\t' || c == '\n' || c == eof_char - # Rewind KEY - mem[TOIN] -= 1 - break - end + +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 - wordLen = offset +function getKey() + raw_mode!(true) + byte = read(STDIN, 1)[1] + raw_mode!(false) - pushPS(wordAddr) - pushPS(wordLen) + 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) -NUMBER = defPrimWord("NUMBER", () -> begin +function getLineFromSTDIN() - wordLen = popPS() - wordAddr = popPS() + function getFrag(s) + chars = collect(s) + slashIdx = findlast(chars, '\\') - s = getString(wordAddr, wordLen) + if slashIdx > 0 + return join(chars[slashIdx:length(chars)]) + else + return nothing + end + end - try - pushPS(parse(Int64, s, mem[BASE])) - pushPS(0) - catch - pushPS(1) # Error indication + function backspaceStr(s, bsCount) + oldLen = length(s) + newLen = max(0, oldLen - bsCount) + return join(collect(s)[1:newLen]) end - return NEXT -end) + line = "" + while true + key = Char(getKey()) -# Dictionary searches + if key == '\n' + print(" ") + return String(line) -FIND = defPrimWord("FIND", () -> begin + elseif key == '\x04' + if isempty(line) + return string("\x04") + end - wordLen = popPS() - wordAddr = popPS() - word = lowercase(getString(wordAddr, wordLen)) + elseif key == '\b' + if !isempty(line) + print("\b\033[K") + line = backspaceStr(line, 1) + end - latest = LATEST - - i = 0 - while (latest = mem[latest]) > 0 - lenAndFlags = mem[latest+1] - len = lenAndFlags & F_LENMASK - hidden = (lenAndFlags & F_HIDDEN) == F_HIDDEN + elseif key == '\e' + # Strip ANSI escape sequence + nextKey = Char(getKey()) + if nextKey == '[' + while true + nextKey = Char(getKey()) + if nextKey >= '@' || nextKey <= '~' + break + end + end + end - if hidden || len != wordLen - continue - end - - thisAddr = latest+2 - thisWord = lowercase(getString(thisAddr, len)) + 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 - if lowercase(thisWord) == lowercase(word) - break + else + print(key) + line = string(line, key) end end +end + +SPAN, SPAN_CFA = defNewVar("SPAN", 0) +EXPECT_CFA = defPrimWord("EXPECT", () -> begin + maxLen = popPS() + addr = popPS() + + line = getLineFromSTDIN() - pushPS(latest) + mem[SPAN] = min(length(line), maxLen) + putString(line, addr, maxLen) return NEXT end) -TOCFA = defPrimWord(">CFA", () -> begin +BASE, BASE_CFA = defNewVar("BASE", 10) +NUMBER_CFA = defPrimWord("NUMBER", () -> begin + wordAddr = popPS()+1 + wordLen = mem[wordAddr-1] + + s = getString(wordAddr, wordLen) + + pushPS(parse(Int64, s, mem[BASE])) + + return NEXT +end) + +# Dictionary searches + +FROMLINK_CFA = defPrimWord("LINK>", () -> begin addr = popPS() lenAndFlags = mem[addr+1] @@ -710,80 +851,103 @@ TOCFA = defPrimWord(">CFA", () -> begin return NEXT end) -TODFA = defWord(">DFA", [TOCFA, INCR, EXIT]) +NUMCONTEXT, NUMCONTEXT_CFA = defNewVar("#CONTEXT", 1) -# Compilation +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 -CREATE = defPrimWord("CREATE", () -> begin +CURRENT_CFA = defExistingVar("CURRENT", CURRENT) - wordLen = popPS() - wordAddr = popPS() - word = getString(wordAddr, wordLen) +# Switch to new FORTH vocabulary cfa +mem[FORTH_CFA+1] = mem[mem[CURRENT]+1] +mem[CURRENT] = FORTH_CFA - createHeader(word, 0) +CONTEXT, CONTEXT_CFA = defNewVar("CONTEXT", zeros(Int64, 10)) +mem[CONTEXT] = FORTH_CFA - return NEXT -end) +FINDVOCAB_CFA = defPrimWord("FINDVOCAB", () -> begin + vocabCFA = popPS() + countedAddr = popPS() -COMMA = defPrimWord(",", () -> begin - mem[mem[HERE]] = popPS() - mem[HERE] += 1 + wordAddr = countedAddr + 1 + wordLen = mem[countedAddr] + word = lowercase(getString(wordAddr, wordLen)) - return NEXT -end) + lfa = vocabCFA+1 + lenAndFlags = 0 -LBRAC = defPrimWord("[", () -> begin - mem[STATE] = 0 - return NEXT -end, flags=F_IMMED) + while (lfa = mem[lfa]) > 0 -RBRAC = defPrimWord("]", () -> begin - mem[STATE] = 1 - return NEXT -end, flags=F_IMMED) + lenAndFlags = mem[lfa+1] + len = lenAndFlags & F_LENMASK + hidden = (lenAndFlags & F_HIDDEN) == F_HIDDEN + + if hidden || len != wordLen + continue + end + + thisWord = lowercase(getString(lfa+2, len)) + + if thisWord == word + break + end + end + + 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 -HIDDEN = defPrimWord("HIDDEN", () -> begin - addr = popPS() + 1 - mem[addr] = mem[addr] $ F_HIDDEN return NEXT end) -HIDE = defWord("HIDE", - [WORD, - FIND, - HIDDEN, - EXIT]) +FIND_CFA = defPrimWord("FIND", () -> begin + + countedAddr = popPS() + context = mem[CONTEXT:(CONTEXT+mem[NUMCONTEXT]-1)] + + for vocabCFA in reverse(context) + pushPS(countedAddr) + pushPS(vocabCFA) + callPrim(mem[FINDVOCAB_CFA]) -COLON = defWord(":", - [WORD, - CREATE, - LIT, DOCOL, COMMA, - LATEST_CFA, FETCH, HIDDEN, - RBRAC, - EXIT]) + callPrim(mem[DUP_CFA]) + if popPS() != 0 + return NEXT + else + popPS() + popPS() + end + end -SEMICOLON = defWord(";", - [LIT, EXIT, COMMA, - LATEST_CFA, FETCH, HIDDEN, - LBRAC, - EXIT], flags=F_IMMED) + pushPS(countedAddr) + pushPS(0) -IMMEDIATE = defPrimWord("IMMEDIATE", () -> begin - lenAndFlagsAddr = mem[LATEST] + 1 - mem[lenAndFlagsAddr] = mem[lenAndFlagsAddr] $ F_IMMED return NEXT -end, flags=F_IMMED) +end) -TICK = defWord("'", [WORD, FIND, TOCFA, 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 @@ -795,7 +959,7 @@ end) # Strings -LITSTRING = defPrimWord("LITSTRING", () -> begin +LITSTRING_CFA = defPrimWord("LITSTRING", () -> begin len = mem[reg.IP] reg.IP += 1 pushPS(reg.IP) @@ -805,7 +969,7 @@ LITSTRING = defPrimWord("LITSTRING", () -> begin return NEXT end) -TELL = defPrimWord("TELL", () -> begin +TYPE_CFA = defPrimWord("TYPE", () -> begin len = popPS() addr = popPS() str = getString(addr, len) @@ -813,136 +977,387 @@ TELL = defPrimWord("TELL", () -> begin return NEXT end) -# Outer interpreter +# Interpreter/Compiler-specific I/O -EXECUTE = defPrimWord("EXECUTE", () -> begin - reg.W = popPS() - return mem[reg.W] -end) +TIB_CFA = defConst("TIB", TIB) +NUMTIB, NUMTIB_CFA = defNewVar("#TIB", 0) -INTERPRET = defPrimWord("INTERPRET", () -> begin +FIB_CFA = defConst("FIB", FIB) +NUMFIB, NUMFIB_CFA = defNewVar("#FIB", 0) - callPrim(mem[WORD]) +IB_CFA = defPrimWord("IB", () -> begin + pushPS(mem[SOURCE_ID_VAR] == 0 ? TIB : FIB) + return NEXT +end) - wordName = getString(mem[reg.PSP-1], mem[reg.PSP]) - #println("... ", replace(wordName, "\n", "\\n"), " ...") +NUMIB_CFA = defPrimWord("#IB", () -> begin + pushPS(mem[SOURCE_ID_VAR] == 0 ? NUMTIB : NUMFIB) + return NEXT +end) - callPrim(mem[TWODUP]) - callPrim(mem[FIND]) +TOIN, TOIN_CFA = defNewVar(">IN", 0) - wordAddr = mem[reg.PSP] +SOURCE_ID_VAR, SOURCE_ID_VAR_CFA = defNewVar("SOURCE-ID-VAR", 0) - if wordAddr>0 - # Word in dictionary +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]) - isImmediate = (mem[wordAddr+1] & F_IMMED) != 0 - callPrim(mem[TOCFA]) +EOF_FLAG, EOF_FLAG_CFA = defNewVar("EOF-FLAG", 0) - callPrim(mem[ROT]) # get rid of extra copy of word string details - popPS() - popPS() +# ( fid -- ) +# EOF-FLAG set to true if EOF is reached +QUERY_FILE_CFA = defWord("QUERY-FILE", + [FIB_CFA, LIT_CFA, 160, ROT_CFA, READ_LINE_CFA, + DROP_CFA, EOF_FLAG_CFA, STORE_CFA, + NUMFIB_CFA, STORE_CFA, + LIT_CFA, 0, TOIN_CFA, STORE_CFA, + EXIT_CFA]) - if mem[STATE] == 0 || isImmediate - # Execute! - #println("Executing CFA at $(mem[reg.PSP])") - return callPrim(mem[EXECUTE]) - else - # Append CFA to dictionary - callPrim(mem[COMMA]) - end +WORD_CFA = defPrimWord("WORD", () -> begin + delim = popPS() + + if mem[SOURCE_ID_VAR] == 0 + bufferAddr = TIB + sizeAddr = NUMTIB else - # Not in dictionary, assume number + bufferAddr = FIB + sizeAddr = NUMFIB + end - popPS() + # Chew up initial occurrences of delim + while (mem[TOIN] begin - return 0 +STATE, STATE_CFA = defNewVar("STATE", 0) + +COMMA_CFA = defPrimWord(",", () -> begin + mem[mem[H]] = popPS() + mem[H] += 1 + + return NEXT end) -NL = defPrimWord("\n", () -> begin - if mem[STATE] == 0 && reg.source == STDIN - println(" ok") - 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) + + createHeader(word, 0) + + return NEXT +end) + +CREATE_CFA = defWord("CREATE", + [LIT_CFA, 32, WORD_CFA, HEADER_CFA, + LIT_CFA, DOVAR, COMMA_CFA, + EXIT_CFA]) + +DODOES = defPrim(() -> begin + pushRS(reg.IP) + reg.IP = popPS() + pushPS(reg.W + 1) + return NEXT +end, name="DODOES") + +DOES_HELPER_CFA = defPrimWord("(DOES>)", () -> begin + + pushPS(mem[mem[CURRENT]+1]) + callPrim(mem[FROMLINK_CFA]) + cfa = popPS() + + runtimeAddr = popPS() + + mem[cfa] = defPrim(eval(:(() -> begin + pushPS($(runtimeAddr)) + return DODOES + end)), name="doesPrim") + + return NEXT +end, flags=F_IMMED | F_HIDDEN) + +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) + +LBRAC_CFA = defPrimWord("[", () -> begin + mem[STATE] = 0 return NEXT end, flags=F_IMMED) -INCLUDE = defPrimWord("INCLUDE", () -> begin +RBRAC_CFA = defPrimWord("]", () -> begin + mem[STATE] = 1 + return NEXT +end, flags=F_IMMED) - callPrim(mem[WORD]) - wordLen = popPS() - wordAddr = popPS() - word = getString(wordAddr, wordLen) +HIDDEN_CFA = defPrimWord("HIDDEN", () -> begin + lenAndFlagsAddr = mem[mem[CURRENT]+1] + 1 + mem[lenAndFlagsAddr] = xor(mem[lenAndFlagsAddr], F_HIDDEN) + return NEXT +end) - reg.source = open(word, "r") +COLON_CFA = defWord(":", + [LIT_CFA, 32, WORD_CFA, + HEADER_CFA, + LIT_CFA, DOCOL, COMMA_CFA, + HIDDEN_CFA, + RBRAC_CFA, + EXIT_CFA]) - # Clear input buffer - mem[NUMTIB] = 0 +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] = xor(mem[lenAndFlagsAddr], F_IMMED) + return NEXT +end, flags=F_IMMED) + +# ( addr n -- primAddr ) +CREATE_PRIM_CFA = defPrimWord("CREATE-PRIM", () -> begin + len = popPS() + addr = popPS() + + exprString = string("() -> begin\n", + getString(addr, len), "\n", + "return NEXT\n", + "end") + func = eval(parse(exprString)) + + pushPS(defPrim(func)) return NEXT end) -EOF_WORD = defPrimWord("\x04", () -> begin - if reg.source == STDIN - return 0 - else - close(reg.source) - reg.source = STDIN - return NEXT +# Outer Interpreter + +EXECUTE_CFA = defPrimWord("EXECUTE", () -> begin + reg.W = popPS() + return mem[reg.W] +end) + +INTERPRET_CFA = defWord("INTERPRET", + [LIT_CFA, 32, WORD_CFA, # Read next space-delimited word + + DUP_CFA, FETCH_CFA, ZE_CFA, ZBRANCH_CFA, 3, + DROP_CFA, EXIT_CFA, # Exit if input buffer is exhausted + + STATE_CFA, FETCH_CFA, ZBRANCH_CFA, 24, + # Compiling + FIND_CFA, QDUP_CFA, ZBRANCH_CFA, 13, + + # Found word. + LIT_CFA, -1, EQ_CFA, INVERT_CFA, ZBRANCH_CFA, 4, + + # Immediate: Execute! + EXECUTE_CFA, BRANCH_CFA, -26, + + # Not immediate: Compile! + COMMA_CFA, BRANCH_CFA, -29, + + # 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, + + # 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 -end, flags=F_IMMED) + println() + + return NEXT +end) + +QUIT_CFA = defWord("QUIT", + [LIT_CFA, 0, STATE_CFA, STORE_CFA, # Set mode to interpret + LIT_CFA, 0, SOURCE_ID_VAR_CFA, STORE_CFA, # Set terminal as input stream + LIT_CFA, 0, NUMTIB_CFA, STORE_CFA, # Clear the input buffer + RSP0_CFA, RSPSTORE_CFA, # Clear the return stack + QUERY_CFA, # Read line of input + INTERPRET_CFA, PROMPT_CFA, # Interpret line + BRANCH_CFA,-4]) # Loop + +INCLUDED_CFA = defWord("INCLUDED", + [LIT_CFA, 0, STATE_CFA, STORE_CFA, # Set mode to interpret + FAM_RO_CFA, OPEN_FILE_CFA, DROP_CFA, # Open the file + SOURCE_ID_VAR_CFA, FETCH_CFA, SWAP_CFA, # Store current source on stack + SOURCE_ID_VAR_CFA, STORE_CFA, # Mark this as the current source + SOURCE_ID_VAR_CFA, FETCH_CFA, QUERY_FILE_CFA, # Read line from file + EOF_FLAG_CFA, FETCH_CFA, + NUMFIB_CFA, FETCH_CFA, ZE_CFA, AND_CFA, # Test for EOF and empty line + INVERT_CFA, ZBRANCH_CFA, 4, # Break out if EOF + INTERPRET_CFA, # Interpret line + BRANCH_CFA, -14, # Loop + SOURCE_ID_VAR_CFA, FETCH_CFA, + CLOSE_FILE_CFA, DROP_CFA, # Close file + SOURCE_ID_VAR_CFA, STORE_CFA, # Restore input source + LIT_CFA, 0, NUMIB_CFA, STORE_CFA, # Zero #IB + LIT_CFA, 0, TOIN_CFA, STORE_CFA, # Zero >IN + EXIT_CFA]) + +INCLUDE_CFA = defWord("INCLUDE", [LIT_CFA, 32, WORD_CFA, + DUP_CFA, INCR_CFA, + SWAP_CFA, FETCH_CFA, + INCLUDED_CFA, EXIT_CFA]); + +ABORT_CFA = defWord("ABORT", + [CLOSE_FILES_CFA, DROP_CFA, PSP0_CFA, PSPSTORE_CFA, QUIT_CFA]) + +BYE_CFA = defPrimWord("BYE", () -> begin + if mem[SOURCE_ID_VAR] == 0 + println("\nBye!") + end + return 0 +end) + +EOF_CFA = defPrimWord("\x04", () -> begin + return 0 +end) -# Odds and Ends +### Library loading ### -CHAR = defPrimWord("CHAR", () -> begin - callPrim(mem[WORD]) - wordLen = popPS() - wordAddr = popPS() - word = getString(wordAddr, wordLen) - pushPS(Int64(word[1])) +oldCWD = "" +SETLIBCWD_CFA = defPrimWord("SETLIBCWD", () -> begin + global oldCWD = pwd() + if !isfile("lib.4th") # Exception for debugging. + cd(Pkg.dir("forth","src")) + end + return NEXT +end) +RESTORECWD_CFA = defPrimWord("RESTORECWD", () -> begin + cd(oldCWD) return NEXT end) +INCLUDED_LIB_CFA = defWord("INCLUDED-LIB", + [SETLIBCWD_CFA, INCLUDED_CFA, RESTORECWD_CFA, EXIT_CFA]) + +INCLUDE_LIB_CFA = defWord("INCLUDE-LIB", [LIT_CFA, 32, WORD_CFA, + DUP_CFA, INCR_CFA, + SWAP_CFA, FETCH_CFA, + INCLUDED_LIB_CFA, EXIT_CFA]); + +SKIP_WELCOME, SKIP_WELCOME_CFA = defNewVar("SKIP-WELCOME", 0) + #### VM loop #### -function run() + +initialized = false +libFileName = "lib.4th" + +function run(fileName=nothing; initialize=true) + # Start with IP pointing to first instruction of outer interpreter - reg.IP = QUIT + 1 + pushRS(QUIT_CFA+1) + + # Include optional file + if fileName != nothing + putString(fileName, mem[H]) + pushPS(mem[H]) + mem[H] += length(fileName) + pushPS(length(fileName)) + pushRS(INCLUDED_CFA+1) + + mem[SKIP_WELCOME] = -1 + end + + # Load library files + global initialized, libFileName + if !initialized && initialize + if libFileName != nothing + #print("Including definitions from $libFileName...") + + putString(libFileName, mem[H]) + pushPS(mem[H]) + pushPS(length(libFileName)) + pushRS(INCLUDED_LIB_CFA+1) + + initialized = true + else + println("No library file found. Only primitive words available.") + end + end + # Primitive processing loop. # Everyting else is simply a consequence of this loop! - jmp = NEXT - while (jmp = callPrim(jmp)) != 0 - #println("Evaluating prim $jmp [$(primNames[-jmp])]") + jmp = mem[EXIT_CFA] + while jmp != 0 + try + #print("Entering prim $(getPrimName(jmp)), PS: ") + #printPS() + + jmp = callPrim(jmp) + + catch ex + showerror(STDOUT, ex) + println() + + # QUIT + reg.IP = ABORT_CFA + 1 + jmp = NEXT + end end 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) @@ -972,16 +1387,16 @@ function dump(startAddr::Int64; count::Int64 = 100, cellsPerLine::Int64 = 10) i += 1 end - println("\t", ASCIIString(chars)) + println("\t", String(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() @@ -991,11 +1406,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() @@ -1004,4 +1419,14 @@ function printRS() end end +DUMP = defPrimWord("DUMP", () -> begin + count = popPS() + addr = popPS() + + println() + dump(addr, count=count) + + return NEXT +end) + end