module forth
-import Base.REPLCompletions
+import REPL.REPLCompletions, Base.invokelatest, Pkg
# VM mem size
size_mem = 1000000 # 1 mega-int
size_FIB = 1000 # File input buffer size
# Memory arrays
-mem = Array{Int64,1}(size_mem)
-primitives = Array{Function,1}()
-primNames = Array{AbstractString,1}()
+mem = Array{Int64,1}(undef,size_mem)
+primitives = Array{Function,1}(undef, 0)
+primNames = Array{AbstractString,1}(undef, 0)
# Memory geography and built-in variables
DICT = mem[H] # Save bottom of dictionary as constant
# VM registers
-type Reg
+mutable struct Reg
RSP::Int64 # Return stack pointer
PSP::Int64 # Parameter/data stack pointer
IP::Int64 # Instruction pointer
# Handy functions for adding/retrieving strings to/from memory.
-getString(addr::Int64, len::Int64) = AbstractString([Char(c) for c in mem[addr:(addr+len-1)]])
+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)
function defPrim(f::Function; name="nameless")
push!(primitives, f)
- push!(primNames, replace(name, "\004", "EOF"))
+ push!(primNames, replace(name, "\004" => "EOF"))
return -length(primitives)
end
if addr >=0 || -addr>length(primitives)
error("Attempted to execute non-existent primitive at address $addr.")
else
- primitives[-addr]()
+ invokelatest(primitives[-addr])
end
end
getPrimName(addr::Int64) = primNames[-addr]
XOR_CFA = defPrimWord("XOR", () -> begin
b = popPS()
a = popPS()
- pushPS(a $ b)
+ pushPS(xor(a, b))
return NEXT
end)
FAM_WO_CFA = defConst("W/O", FAM_WO)
function fileOpener(create::Bool)
+ fam = popPS()
fnameLen = popPS()
fnameAddr = popPS()
- fam = popPS()
fname = getString(fnameAddr, fnameLen)
mode = "w"
end
+ global nextFileID
openFiles[nextFileID] = open(fname, mode)
pushPS(nextFileID)
pushPS(0)
fid = popPS()
close(openFiles[fid])
delete!(openFiles, fid)
+
+ pushPS(0) # Result code 0
return NEXT
end)
end
empty!(openFiles)
+ pushPS(0) # Result code 0
return NEXT
end)
maxSize = popPS()
addr = popPS()
+ if !(fid in keys(openFiles))
+ error(string("Invalid FID ", fid, "."))
+ end
+
fh = openFiles[fid]
- line = readline(fh)
+ line = readline(fh, keep=true)
eofFlag = endswith(line, '\n') ? 0 : -1
line = chomp(line)
return NEXT
end)
+READ_FILE_CFA = defPrimWord("READ-FILE", () -> begin
+ fid = popPS()
+ size = popPS()
+ addr = popPS()
+
+ fh = openFiles[fid]
+
+ string = join(map(x -> Char(x), read(fh, size)), "")
+
+ eofFlag = length(string) == size ? 0 : -1 ;
+
+ putString(string, addr, length(string))
+
+ pushPS(length(string))
+ pushPS(eofFlag)
+
+ return NEXT
+end)
+
EMIT_CFA = defPrimWord("EMIT", () -> begin
print(Char(popPS()))
end)
function raw_mode!(mode::Bool)
- if ccall(:jl_tty_set_mode, Int32, (Ptr{Void}, Int32), STDIN.handle, mode) != 0
+ if ccall(:jl_tty_set_mode, Int32, (Ptr{Nothing}, 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]
+ byte = read(stdin, 1)[1]
raw_mode!(false)
if byte == 0x0d
function getFrag(s)
chars = collect(s)
- slashIdx = findlast(chars, '\\')
+ slashIdx = findlast(isequal('\\'), chars)
- if slashIdx > 0
+ if slashIdx != nothing
return join(chars[slashIdx:length(chars)])
else
return nothing
if key == '\n'
print(" ")
- return AbstractString(line)
+ return String(line)
elseif key == '\x04'
if isempty(line)
s = getString(wordAddr, wordLen)
- pushPS(parse(Int64, s, mem[BASE]))
+ pushPS(parse(Int64, s, base=mem[BASE]))
return NEXT
end)
TIB_CFA = defConst("TIB", TIB)
NUMTIB, NUMTIB_CFA = defNewVar("#TIB", 0)
-FIB_CFA = defConst("FIB", TIB)
+FIB_CFA = defConst("FIB", FIB)
NUMFIB, NUMFIB_CFA = defNewVar("#FIB", 0)
-TOIN, TOIN_CFA = defNewVar(">IN", 0)
-
-SOURCE_ID, SOURCE_ID_CFA = defNewVar("SOURCE-ID", 0)
+IB_CFA = defPrimWord("IB", () -> begin
+ pushPS(mem[SOURCE_ID_VAR] == 0 ? TIB : FIB)
+ return NEXT
+end)
-SOURCE_CFA = defPrimWord("SOURCE", () -> begin
- if mem[SOURCE_ID] == 0
- pushPS(TIB)
- pushPS(NUMTIB)
- else
- pushPS(FIB)
- pushPS(NUMFIB)
- end
+NUMIB_CFA = defPrimWord("#IB", () -> begin
+ pushPS(mem[SOURCE_ID_VAR] == 0 ? NUMTIB : NUMFIB)
return NEXT
end)
+TOIN, TOIN_CFA = defNewVar(">IN", 0)
+
+SOURCE_ID_VAR, SOURCE_ID_VAR_CFA = defNewVar("SOURCE-ID-VAR", 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])
+EOF_FLAG, EOF_FLAG_CFA = defNewVar("EOF-FLAG", 0)
+
+# ( 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, SWAP_CFA,
+ DROP_CFA, EOF_FLAG_CFA, STORE_CFA,
NUMFIB_CFA, STORE_CFA,
+ LIT_CFA, 0, TOIN_CFA, STORE_CFA,
EXIT_CFA])
WORD_CFA = defPrimWord("WORD", () -> begin
delim = popPS()
- callPrim(mem[SOURCE_CFA])
- sizeAddr = popPS()
- bufferAddr = popPS()
+ if mem[SOURCE_ID_VAR] == 0
+ bufferAddr = TIB
+ sizeAddr = NUMTIB
+ else
+ bufferAddr = FIB
+ sizeAddr = NUMFIB
+ end
# Chew up initial occurrences of delim
while (mem[TOIN]<mem[sizeAddr] && mem[bufferAddr+mem[TOIN]] == delim)
mem[countAddr] = count
pushPS(countAddr)
+ #println("Processing word: '$(getString(countAddr+1,mem[countAddr]))' (state $(mem[STATE]))")
+
return NEXT
end)
HIDDEN_CFA = defPrimWord("HIDDEN", () -> begin
lenAndFlagsAddr = mem[mem[CURRENT]+1] + 1
- mem[lenAndFlagsAddr] = mem[lenAndFlagsAddr] $ F_HIDDEN
+ mem[lenAndFlagsAddr] = xor(mem[lenAndFlagsAddr], F_HIDDEN)
return NEXT
end)
IMMEDIATE_CFA = defPrimWord("IMMEDIATE", () -> begin
lenAndFlagsAddr = mem[mem[CURRENT]+1] + 1
- mem[lenAndFlagsAddr] = mem[lenAndFlagsAddr] $ F_IMMED
+ mem[lenAndFlagsAddr] = xor(mem[lenAndFlagsAddr], F_IMMED)
return NEXT
end, flags=F_IMMED)
-CODE_CFA = defPrimWord("CODE", () -> begin
- pushPS(32)
- 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
-
- exprString = string(exprString, " ", thisWord)
- end
- exprString = string(exprString, "\nreturn NEXT\nend")
-
+# ( 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))
- dictWrite(defPrim(func))
+ pushPS(defPrim(func))
return NEXT
end)
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])
-
-INTERPRET_CFA = defWord("INTERPRET",
- [SOURCE_ID_CFA, FETCH_CFA, TOR_CFA, # Store current source on return stack
-
- LIT_CFA, 32, WORD_CFA, # Read next word from current input source
-
- FAM_RO_CFA, FILE_OPEN, DROP_CFA, # Open the file named by this word.
-
- DUP_CFA, SOURCE_ID_CFA, STORE_CFA, # Mark this as the current source
-
- DUP_CFA, QUERY_FILE_CFA, # Read line from file
-
- INTERPRET_CFA,
-
- BRANCH_CFA, -4]
+ [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, PSP0_CFA, PSPSTORE_CFA, QUIT_CFA])
+ [CLOSE_FILES_CFA, DROP_CFA, PSP0_CFA, PSPSTORE_CFA, QUIT_CFA])
BYE_CFA = defPrimWord("BYE", () -> begin
- println("\nBye!")
+ if mem[SOURCE_ID_VAR] == 0
+ println("\nBye!")
+ end
return 0
end)
return 0
end)
+### Library loading ###
+
+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 ####
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")
-end
+libFileName = "lib.4th"
+
+function run(fileName=nothing; initialize=true)
+
+ # Start with IP pointing to first instruction of outer interpreter
+ pushRS(QUIT_CFA+1)
-function run(;initialize=true)
+ # Include optional file
+ if fileName != nothing
+ putString(fileName, mem[H])
+ pushPS(mem[H])
+ mem[H] += length(fileName)
+ pushPS(length(fileName))
+ pushRS(INCLUDED_CFA+1)
- global initialized, initFileName
+ mem[SKIP_WELCOME] = -1
+ end
+
+ # Load library files
+ global initialized, libFileName
if !initialized && initialize
- if initFileName != nothing
- print("Including definitions from $initFileName...")
+ if libFileName != nothing
+ #print("Including definitions from $libFileName...")
- # TODO
+ putString(libFileName, mem[H])
+ pushPS(mem[H])
+ pushPS(length(libFileName))
+ pushRS(INCLUDED_LIB_CFA+1)
initialized = true
else
end
end
- # Start with IP pointing to first instruction of outer interpreter
- reg.IP = QUIT_CFA + 1
# Primitive processing loop.
# Everyting else is simply a consequence of this loop!
- jmp = NEXT
+ jmp = mem[EXIT_CFA]
while jmp != 0
try
- #println("Entering prim $(getPrimName(jmp))")
+ #print("Entering prim $(getPrimName(jmp)), PS: ")
+ #printPS()
+
jmp = callPrim(jmp)
catch ex
- showerror(STDOUT, ex)
+ println(string("Error in primitive '", getPrimName(jmp), "' at address ", jmp))
+ showerror(stdout, ex)
println()
# QUIT
end)
function dump(startAddr::Int64; count::Int64 = 100, cellsPerLine::Int64 = 10)
- chars = Array{Char,1}(cellsPerLine)
+ chars = Array{Char,1}(undef, cellsPerLine)
lineStartAddr = cellsPerLine*div((startAddr-1),cellsPerLine) + 1
endAddr = startAddr + count - 1
i += 1
end
- println("\t", AbstractString(chars))
+ println("\t", String(chars))
end
end
The Lambda Lab / projects / forth.jl.git / blobdiff