Reorganization

1 files changed, 159 insertions, 221 deletions

@@ -1,166 +1,29 @@
 --- lam.read
 
 local m = {}
-local t = require "type"
-local utf8 = require "utf8"
-local pop = require("util").pop
+local type = require("type")
+local port = require("port")
+local eof, input_port = port.eof, port.input_port
+local util = require("util")
+local constantly, error, pop = util.constantly, util.error, util.pop
 
--- TODO:
--- - string reading
--- - probably more
-
-m.eof = setmetatable({}, {
-                __type = "EOF",
-                __tostring = function () return "#<eof>" end,
-})
-
-local function inport_next_token (port)
-        local tok, toktype
-        while true do
-                if #port.line == 0 then
-                        if port.file then
-                                local ln = port.file:read()
-                                if ln == nil then return m.eof end
-                                port.line = m.tochars(ln)
-                        else
-                                return nil
-                        end
-                end
-                tok, toktype, port.line = m.scan(port.line)()
-                port.line = port.line or {}
-                if tok ~= nil then return tok, toktype end
-        end
-end
-
-function m.inport (source, kind)
-        -- KIND can be one of "file", "string"; defaults to "file"
-        -- SOURCE is the name of the file or the string to read, or nil; if nil,
-        -- read from standard input.
-        local f, l
-        local k = kind or "file"
-        if source then
-                if k == "file" then
-                        f = io.open(source, "r")
-                elseif k == "string" then
-                        l = m.tochars(source)
-                end
-        else
-                -- KIND is ignored here
-                f = io.input()
-        end
-        local t = {
-                file = f,
-                filename = source,
-                kind = kind,
-                line = l or {},
-                next_token = inport_next_token,
-        }
-        if t.file then t.close = function (self) self.file:close() end; end
-        local mt = {
-                __type = "port",
-                __tostring =
-                        function (self)
-                                return string.format("#<port %s>",
-                                        self.file or "(string)")
-                        end,
-        }
-        return setmetatable(t, mt)
-end
-
-function m.tochars (s)
-        local chars = {}
-        for _, code in utf8.codes(s) do
-                table.insert(chars, code)
-        end
-        return chars
-end
-
---- Consumers
--- These take a table of characters (cs) and return:
--- a token, its type, and the rest of the characters
-
-local token_separator = "[^%s#()\"'`,@;]"
+local token_separators = "[%s#()\"'`,@;]"
 
 local function consume_token (cs)
-        local token = {}
-        while #cs > 0 and cs[1]:match(token_separator) do
-                table.insert(token, pop(cs))
+        local tok = {}
+        while #cs > 0 and not cs[1]:match(token_separators) do
+                local c = pop(cs)
+                table.insert(tok, c)
         end
-        return table.concat(token), "symbol", cs
+        return table.concat(tok), cs
 end
 
-local function consume_whitespace (cs)
-        while #cs > 0 and cs[1]:match("%s") do pop(cs) end
-        return nil, nil, cs
-end
-
-local function consume_comment (cs)
-        local comment = {}
-        repeat table.insert(comment, pop(cs))
-        until #cs == 0 or cs[1]:match("\n")
-        return table.concat(comment), "comment", cs
-end
-
-local function idf (x)
-        return function () return x end
-end
-
-local function numf (base)
-        return function (token)
-                local n = tonumber(token:sub(3), base)
-                assert(n, "Can't read number: " .. token)
-                return n
-        end
-end
-
-local literals = {
-        literal = {
-                ["#t"] = idf(true),
-                ["#true"] = idf(true),
-                ["#f"] = idf(false),
-                ["#false"] = idf(false),
-                ["#\\space"] = idf(t.character(" ")),
-                ["#\\tab"] = idf(t.character("\t")),
-                ["#\\newline"] = idf(t.character("\n")),
-        },
-        match = {
-                ["^#b"] = numf(2),
-                ["^#o"] = numf(8),
-                ["^#d"] = numf(10),
-                ["^#x"] = numf(16),
-                ["^#\\"] = function (tok) return t.character(tok:sub(3)) end,
-        }
-}
-
-local function consume_literal (cs)
-        -- whitespace and parantheses character literals.
-        -- reverse the match test b/c it's already a complement
-        if cs[2] == "\\" and not cs[3]:match(token_separator) then
-                return type.character(cs[3])
-        end
-        pop(cs) -- discard '#'
-        local token, value, cs = consume_token(cs) -- todo: vectors #(...)
-        token = "#" .. token -- put '#' back
-
-        if literals.literal[token] then
-                value = literals.literal[token]()
-        else
-                for re, fn in pairs(literals.match) do
-                        if token:match(re) then
-                                value = fn(token)
-                        end
-                end
-        end
-        -- TODO : if `nil' is to be a value in lam i'm going to have to figure
-        -- out some kind of 'lam nil' and 'lua nil' or something..
-        assert(value~=nil, "Can't read literal: " .. token)
-
-        return value, "literal", cs
-end
+---[[ READ TABLE ]]---
 
---- Reading from a port
-
-m.readtable = {
+-- each function should take a list of characters and return the token, its
+-- type, and the rest of the characters
+m.readtable = {}
+m.readtable.chars = {
         ["("] = function (cs) return pop(cs), "open", cs end,
         [")"] = function (cs) return pop(cs), "close", cs end,
         ["'"] = function (cs) return pop(cs), "quote", cs end,
@@ -175,109 +38,184 @@ m.readtable = {
                                 return ",", "quote", cs
                         end
                 end,
-        [";"] = consume_comment,
-        ["#"] = consume_literal,
-}
+        [";"] = -- comment
+                function (cs)
+                        local comment = {}
+                        while #cs > 0 and not cs[1]:match("\n") do
+                                table.insert(comment, pop(cs))
+                        end
+                        return table.concat(comment), "comment", cs
+                end,
+        ["#"] = -- literal
+                function (cs)
+                        local tok
+                        -- bail on just '#\'
+                        if not (cs[2] and cs[3]) then
+                                cs = {}
+                                error("bad literal", "#\\")
+                        end
 
---- TODO: Figure out how to read #f and #n properly
+                        -- read '#\ ' and such correctly
+                        if cs[2] == "\\" and cs[3]:match(token_separators) then
+                                pop(cs) -- remove '\'
+                                pop(cs) -- remove next character
+                                return type.character(cs[1])
+                        end
 
--- Return an iterator over a character table, so you can do:
--- for token, chars in scan(cs) do ... end
-function m.scan (cs)
-        local cs = cs
-        return function ()
-                if not next(cs) then return nil end
-                local token, toktype
-                while true do
-                        if m.readtable[cs[1]] then
-                                token, toktype, cs = m.readtable[cs[1]](cs)
-                                return token, toktype, cs
-                        elseif cs[1]:match("%s") then
-                                --- should this just continue the loop?
-                                -- i.e., remove `return'
-                                return consume_whitespace(cs)
-                        elseif cs[1]:match("[%d.+-]") then
-                                -- numbers, +, -, ., ...
-                                local token, _, cs = consume_token(cs)
-                                if token:match("[-+]") or token == "..." then
-                                        return token, "symbol", cs
-                                elseif token == "." then
-                                        return token, "dot", cs
-                                else
-                                        local n = tonumber(token)
-                                        assert (n ~= nil, "Bad number: "..n)
-                                        return n, "number", cs
-                                end
+                        pop(cs) -- discard '#' ...
+                        tok, cs = consume_token(cs)
+                        tok = "#" .. tok -- ... then put it back
+
+                        local val
+                        if m.readtable.literals.lit[tok] then
+                                val = m.readtable.literals.lit[tok]
                         else
-                                return consume_token(cs)
+                                for re, fn in pairs(m.readtable.literals.regex)
+                                do
+                                        if tok:match(re) then
+                                                val = fn(tok)
+                                        end
+                                end
+                        end
+
+                        if val == nil then
+                                error("bad literal", tok)
+                        end
+                        return val, "literal", cs
+                end,
+}
+m.readtable.regex = {
+        ["%s"] = -- whitespace
+                function (cs)
+                        while #cs > 0 and cs[1]:match("%s") do
+                                pop(cs)
+                        end
+                        return false, nil, cs
+                end,
+        ["[%d.+-]"] = -- numbers and symbols +, -, ., and ...
+                function (cs)
+                        local tok
+                        tok, cs = consume_token(cs)
+                        if tok:match("^[-+]$") or tok == "..." then
+                                return tok, "symbol", cs
+                        elseif tok == "." then
+                                return tok, "dot", cs
+                        else -- number
+                                local n = tonumber(tok)
+                                if not n then
+                                        error("bad number", n)
+                                end
+                                return n, "number", cs
                         end
+                end,
+}
+m.readtable.default = -- default action if nothing else matches
+        function (cs)
+                local tok, cs = consume_token(cs)
+                return tok, "symbol", cs
+        end
+
+-- convenience function to make writing the regexen rules easier below
+local function based_num (base)
+        return function (token)
+                local n = tonumber(token:sub(3), base)
+                if not n then
+                        error("bad number", token)
                 end
+                return n
         end
 end
 
-function m.readchar (port)
-        if #port.line > 0 then
-                local ch = pop(port.line)
-                return ch
-        else
-                return port.file and port.file.read(1)
-        end
+m.readtable.literals = {
+        lit = {
+                ["#t"] = true,
+                ["#true"] = true,
+                ["#f"] = false,
+                ["#false"] = false,
+        },
+        regex = {
+                ["^#b"] = based_num(2),
+                ["^#o"] = based_num(8),
+                ["^#d"] = based_num(10),
+                ["^#x"] = based_num(16),
+                ["^#\\."] =
+                        function (tok)
+                                return type.character(tok:sub(3))
+                        end,
+        },
+}
+-- add named characters
+for char, name in pairs(type.character_names) do
+        m.readtable.literals.lit["#\\"..name] = type.character(char)
 end
 
+---[[ READER MACROS ]]---
+-- Each of these are named after the type of the token read and contain
+-- function taking (TOKEN, TYPE, PORT) and returning a lisp object
+
 m.readmacros = {
+        close =
+                function (token, _, _)
+                        error("unexpected", token)
+                end,
         quote =
-                function (tok, toktype, port)
+                function (token, _, port)
                         local qs = {
                                 ["'"] = "quote",
                                 ["`"] = "quasiquote",
                                 [","] = "unquote",
                                 [",@"] = "unquote-splicing",
                         }
-                        if not qs[tok] then
-                                error(string.format("Bad quote: '%s'\n", tok))
+                        if not qs[token] then
+                                error("bad quote", token)
                         end
-                        local Q = {qs[tok]}
+                        local Q = {qs[token]}
                         table.insert(Q, m.read(port))
-                        return t.list(Q)
+                        return type.list(Q)
                 end,
-        comment = idf(nil)
+        comment = constantly(nil), -- throw comments away
 }
 
+---[[ READ ]]---
+
 function m.read (port)
-        local function read_ahead (tok, toktype)
-                if tok == m.eof then error("Unexpected EOF") end
-                if toktype == "open" then
+        local function read_ahead(token, token_type)
+                if token == eof then error("unexpected", token) end
+                if token_type == "open" then
+                        -- this must be defined here because it calls read_ahead
+                        -- recursively.
                         local L = {}
-                        while true do
-                                local tok, toktype = port:next_token()
-                                if toktype == "close" then
-                                        return t.list(L)
-                                elseif toktype == "dot" then
+                        repeat
+                                token, token_type = port:next(m.readtable)
+                                if token_type == "close" then
+                                        return type.list(L)
+                                elseif token_type == "dot" then
                                         local fin = m.read(port)
-                                        port:next_token() -- throw away ')'
-                                        return t.list(L, fin)
+                                        port:next(m.readtable) -- discard ')'
+                                        return type.list(L, fin)
                                 else
                                         table.insert(L,
-                                                read_ahead(tok, toktype))
+                                                read_ahead(token, token_type))
                                 end
-                        end
-                elseif toktype == "close" then
-                        error("Unexpected ')'")
-                elseif m.readmacros[toktype] then
-                        return m.readmacros[toktype](tok, toktype, port)
-                else return tok
+                        until nil
+                elseif m.readmacros[token_type] then
+                        return m.readmacros[token_type](token, token_type, port)
+                else
+                        return token
                 end
         end
-        -- body of read
-        local tok1, toktype1 = port:next_token()
-        if tok1 == m.eof then return m.eof
-        else return read_ahead(tok1, toktype1)
+        ---
+        local token1, type1 = port:next(m.readtable)
+        if token1 == eof then
+                return eof
+        else
+                return read_ahead(token1, type1)
         end
 end
 
 function m.read_string (str)
-        return m.read(m.inport(str, "string"))
+        return m.read(input_port(str, "string"))
 end
 
----
+--------
 return m