CoreHelpers.tl

@@ -115,83 +115,16 @@ function CoreHelpers.makeCall(body: {function(Environment)}): function(Environme
 end
 
 
-function CoreHelpers.compile(env: Environment)
-	local stack = env.activeDataStack
-	local f = stack:pop() as function(Environment)
-	table.insert(env.currentDefinition, f)
-end
-function CoreHelpers.literal(env: Environment)
-	local stack = env.activeDataStack
-	local val = stack:pop()
-	local f = function(e: Environment)
-		local s = e.activeDataStack
-		s:push(val)
-	end
-	table.insert(env.currentDefinition, f)
-end
-function CoreHelpers.noop(_: Environment)
-	return
-end
-function CoreHelpers.postpone(e: Environment)
-	CoreHelpers.noop(e)
-end
-function CoreHelpers.execute(env: Environment)
-	local stack = CoreHelpers.getActiveDataStack(env)
-	local func: function(Environment) = stack:pop() as function(Environment)
-	func(env)
-end
-
 
 function CoreHelpers.recNumber(env: Environment)
 	local dataStack = CoreHelpers.getActiveDataStack(env)
 	local token = dataStack:pop() as string
 	if CoreHelpers.isNumber(token) then
-		-- number
+		-- push the XTs onto the stack
-		dataStack:push(tonumber(token))
-		-- interpret
-		dataStack:push(CoreHelpers.noop)
-		-- compile
-		dataStack:push(CoreHelpers.literal)
-		-- immediate
-		dataStack:push(CoreHelpers.literal)
-		-- return success
 		dataStack:push(true)
-		return
 	end
-	dataStack:push(token)
-	dataStack:push(false)
-end
-function CoreHelpers.recWord(env: Environment)
-	local dataStack = CoreHelpers.getActiveDataStack(env)
-	local token = dataStack:pop() as string
-	for _, dictionary in ipairs(env.dictionaries) do
-		local wordinfo = dictionary:lookup(token)
-		if wordinfo then
-			-- XT
-			dataStack:push((wordinfo as WordInfo).func)
-				
-			-- interpret
-			dataStack:push(CoreHelpers.execute)
-			-- compile
-			if (wordinfo as WordInfo).immediate then
-				dataStack:push(CoreHelpers.execute)
-			else
-				dataStack:push(CoreHelpers.compile)
-			end
-			-- immediate
-			dataStack:push(CoreHelpers.postpone)
-			-- return success
-			dataStack:push(true)
-			return
-		end
-	end
-	dataStack:push(token)
-	dataStack:push(false)
 end
 
-function CoreHelpers.ack(e: Environment)
-	io.write("ok\n")
-end
 
 return CoreHelpers
 

CoreWords.tl

@@ -7,9 +7,6 @@ local popTwoOperands = helpers.popTwoOperands
 local defineWord = helpers.defineWord
 local ret = helpers.ret
 local makeCall = helpers.makeCall
-
-local literal = helpers.literal
-local compile = helpers.compile
 -- Mathematical operations
 local function add(env: Environment)
   local a, b = popTwoOperands(env)
@@ -164,29 +161,26 @@ local function exitCompileMode(e: Environment)
   e.compileState = false
 end
 
-local function colon(e: Environment)
+local function compile(env: Environment)
-  skipWhitespace(e)
+  local stack = env.activeDataStack
-  local name: string | nil = parseToken(e)
+  local f = stack:pop() as function(Environment)
-  if not name then
+  table.insert(env.currentDefinition, f)
-    e.running = false
+end
-    return
+local function literal(env: Environment)
+  local stack = env.activeDataStack
+  local val = stack:pop()
+  local fun =  function(e: Environment)
+    local s = e.activeDataStack
+    s:push(val)
   end
-  e.currentDefinitionName = name as string
+  table.insert(env.currentDefinition, fun)
-  enterCompileMode(e)
 end
 
-local function semicolon(e: Environment)
+local function postpone(env: Environment)
-  table.insert(e.currentDefinition, helpers.ret)
-  local instrs = e.currentDefinition
-  local call = helpers.makeCall(instrs)
-  local dict = e.dictionaries[1]
-  defineWord(dict, e.currentDefinitionName, call, false)
-  e.currentDefinitionName = nil
-  e.currentDefinition = {}
-  exitCompileMode(e)
-end
 
 
+end
+
 local CoreWords = Dictionary:new()
 local addInfo = WordInfo:new(add, false)
 local subInfo = WordInfo:new(sub, false)
@@ -211,8 +205,7 @@ defineWord(CoreWords, "[", exitCompileMode, true)
 defineWord(CoreWords, "]", enterCompileMode, false)
 defineWord(CoreWords, "COMPILE,", compile, true)
 defineWord(CoreWords, "LITERAL", literal, true)
-defineWord(CoreWords, ":", colon, true)
+
-defineWord(CoreWords, ";", semicolon, true)
 
 CoreWords:define("+", addInfo)
 CoreWords:define("-", subInfo)

DataStructures.tl

@@ -17,7 +17,7 @@ local type DataStructures = record
     define: function(Dictionary, string, WordInfo)
   end
   record WordInfo
-    func: function(Environment)
+    func: function(Environment, ...: any)
     immediate: boolean
     new: function(WordInfo, function(Environment), boolean): WordInfo
   end
@@ -46,7 +46,7 @@ local type DataStructures = record
     recognizers: {function(Environment)} 
     instructionPointer: Pointer
     running: boolean
-    currentDefinitionName: string | nil
+
     currentDefinition: {function(Environment)}
   end
 
@@ -71,11 +71,8 @@ function Environment:new(input: InputStream, dict: {Dictionary} ): Environment
       returnStack = Stack:new(),
       dictionaries = dicts,
       activeInputStream = input,
-      running = true,
+      running = true
-      recognizers = {},
+    } as Environment, 
-      compileState = false,
-      currentDefinition = {}
-    } as Environment,
     state_mt)
 end
  

Interpreters.tl

@@ -15,8 +15,6 @@ function Interpreters.start(env: Environment)
 	local interpreterInstructions = {}
 	table.insert(interpreterInstructions, Interpreters.outer)
 	table.insert(interpreterInstructions, helpers.reset)
-	table.insert(env.recognizers, helpers.recNumber)
-	table.insert(env.recognizers, helpers.recWord)
 	local startPointer = Pointer:new()
 	startPointer.referant = interpreterInstructions
 	env.instructionPointer = startPointer
@@ -24,46 +22,29 @@ function Interpreters.start(env: Environment)
 end
 
 
-function selectRecXT(env: Environment): function(Environment)
-	local dataStack = env.activeDataStack
-	if env.compileState then
-		dataStack:pop()
-		local selected = dataStack:pop()
-		dataStack:pop()
-		return selected as function(Environment)
-	else
-		dataStack:pop()
-		dataStack:pop()
-		return dataStack:pop() as function(Environment)
-	end
-end
-
 
 function Interpreters.outer(env: Environment)
-	local dataStack = env.activeDataStack
 	skipWhitespace(env)
 	local token: string | nil = parseToken(env)
 	if not token then
 		env.running = false
 		return
 	end
-	for _, rec in ipairs(env.recognizers) do
+	if isNumber(token) then
-		dataStack:push(token)
+		env.activeDataStack:push(tonumber(token))
-		rec(env)
+	else
-		local result = dataStack:pop() as boolean
+		for _, dictionary in ipairs(env.dictionaries) do
-		if not result then
+			local wordinfo = dictionary:lookup(token)
-			token = dataStack:pop() as string
+			if wordinfo then
-		end
+				(wordinfo as WordInfo).func(env)
-		if result then
+				goto continue
-			(selectRecXT(env))(env)
+			end
-			return
 		end
+		print(string.format('%q ?', token))
+		::continue::
 	end
-	
-	-- We did not recognize the token.
-	io.write("\""..token.."\"?\n")
 end
-			
+
 function Interpreters.inner(env: Environment)
 	while(env.running) do
 		env.instructionPointer:deref() as function(Environment)(env)

tests.lua

@@ -231,11 +231,6 @@ describe("Interpreter tests", function()
             assert.are.same(expectedResult,testEnv.activeDataStack.contents[1])
          end
       end)
-      it("does not push anything when a garbage input is given", function()
-         local testEnv = buildEnvironment("BOGUS")
-         interpreters.start(testEnv)
-         assert.are.same({}, testEnv.activeDataStack.contents)
-      end)
    end)
    describe("Core word tests", function()
       describe("DUP tests", function()