Read from ports now

1 files changed, 129 insertions, 189 deletions

@@ -1,230 +1,170 @@
 --- lam.read
 
-local read = {}
-local type = require "type"
+local m = {}
+local t = require "type"
 local utf8 = require "utf8"
-local util = require "util"
-local pop = util.pop
-local unpack = table.unpack or unpack
-
-local function program_characters (program)
-        local chars = {}
-        for pos, code in utf8.codes(program) do
-                table.insert(chars, code)
-        end
-        return chars
-end
-
-local function consume_string_whitespace (chars)
-        -- \<intraline ws>*<line ending> <intraline ws>* : nothing
-        local s = {"\\"}
-        while chars[1]:match("[ \t]") do
-                table.insert(s, pop(chars))
-        end
-        if chars[1] ~= "\n" then
-                table.insert(s, chars[1])
-                return table.concat(s), chars
-        end
-        while chars[1]:match("%s") do
-                pop(chars)
+local pop = require("util").pop
+
+local pp = require("pp").pp
+
+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 kind == "file" then
+                        f = io.open(source, "r")
+                elseif kind == "string" then
+                        l = m.tochars(source)
+                end
+        else
+                -- KIND is ignored here
+                f = io.input()
         end
-        return chars[1], chars
-end
-
-local function consume_string_hexvalue (chars)
-        -- \x<hex scalar value>; : specified character
-        local u8ch = {}
-        repeat
-                local c = pop(chars)
-                table.insert(u8ch, c)
-        until c == ";"
-        table.remove(u8ch) -- remove semicolon
-        return utf8.char(tonumber(table.concat(u8ch), 16)), chars
-end
-
-local function consume_string (chars)
-        local str = {}
-        local backslash = {
-                a = "\a",
-                b = "\b",
-                t = "\t",
-                n = "\n",
-                r = "\r",
-                ["\""] = "\"",
-                ["\\"] = "\\",
-                ["|"] = "|",
-                [" "] = consume_string_whitespace,
-                ["\t"] = consume_string_whitespace,
-                ["\n"] = consume_string_whitespace,
-                x = consume_string_hexvalue,
-        }
-        pop(chars) -- throw initial " away
-        repeat
-                local c = pop(chars)
-                if c == [[\]] then
-                        c = chars[1]
-                        if backlash[c] then
-                                if type(backslash[c]) == "function" then
-                                        c, chars = backslash[c](chars)
-                                        table.insert(str, c)
-                                else
-                                        table.insert(str, backlash[c])
+        local t = {
+                file = f,
+                line = l or {},
+                next_token =
+                        function (self)
+                                local tok, toktype
+                                while true do
+                                        if #self.line == 0 and self.file then
+                                                self.line = m.tochars(
+                                                        self.file:read("*l"))
+                                        end
+                                        if not self.line or #self.line == 0 then
+                                                return nil
+                                        end
+                                        tok, toktype, self.line =
+                                                m.scan(self.line)()
+                                        if tok then return tok, toktype end
                                 end
-                        else
-                                table.insert(str, "\\"..c)
-                        end
-                        pop(chars)
-                elseif c == [["]] then
-                        break
-                else
-                        table.insert(str, c)
-                end
-        until #chars == 0
-        return table.concat(str), "string", chars
+                        end,
+        }
+        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
 
-local function consume_token (chars)
-        local tok = {}
-        while #chars>0 and chars[1]:match("[^%s()\"#'`,@;]") do
-                table.insert(tok, pop(chars))
+function m.tochars (s)
+        local chars = {}
+        for _, code in utf8.codes(s) do
+                table.insert(chars, code)
         end
-        return table.concat(tok), chars
+        return chars
 end
 
-local consume_symbol = consume_token
+--- Consumers
+-- These take a table of characters (cs) and return a token and the rest of the
+-- chars
 
-local function consume_number (chars)
-        local digits, chars = consume_token(chars)
-        -- The signs by themselves are symbols, as well as '...'
-        if digits:match("[-+.]") or digits == "..." then
-                return digits, chars
+local function consume_token (cs)
+        local token = {}
+        while #cs > 0 and cs[1]:match("[^%s()\"#'`,@;]") do
+                table.insert(token, pop(cs))
         end
-        -- Otherwise try converting the digits to a number
-        local num = tonumber(digits)
-        if num == nil then error("Bad number: " .. num) end
-        return num, chars
+        return table.concat(token), cs
 end
 
-local function consume_whitespace (chars)
-        while #chars>0 and chars[1]:match("%s") do pop(chars) end
-        return chars
+local function consume_whitespace (cs)
+        while #cs > 0 and cs[1]:match("%s") do pop(cs) end
+        return nil, cs
 end
 
-local function consume_comment (chars)
-        local comment = {}
-        repeat
-                table.insert(comment, pop(chars))
-        until #chars == 0 or chars[1]:match("\n")
-        return table.concat(comment), "comment", chars
-end
+--- Reading from a port
 
---- API
-
-read.readtable = {
-        ["("] = function(chars) return pop(chars), "open", chars end,
-        [")"] = function(chars) return pop(chars), "close", chars end,
-        ["'"] = function(chars) return pop(chars), "quote", chars end,
-        ["`"] = function(chars) return pop(chars), "quote", chars end,
-        [","] = function(chars) return pop(chars), "quote", chars end,
-        ["\""] = consume_string,
-        [";"] = consume_comment,
-        -- ["#"] = ...,
+m.readtable = {
+        ["("] = function (cs) return pop(cs), "open", cs end,
+        [")"] = function (cs) return pop(cs), "close", cs end,
 }
 
-function read.scan (chars)
-        local chars = chars
+-- 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(chars) then return nil end
-                local token, toktype = "", nil
+                if not next(cs) then return nil end
+                local token, toktype
                 while true do
-                        if read.readtable[chars[1]] then
-                                token, toktype, chars =
-                                        read.readtable[chars[1]](chars)
-                                return token, toktype
-                        elseif chars[1]:match("%s") then
-                                chars = consume_whitespace(chars)
-                        elseif chars[1]:match("%d") then
-                                token, chars = consume_number(chars)
-                                return token, "number"
-                        elseif chars[1]:match("[.+-]") then
-                                -- special casing for ., ..., +, -
-                                token, chars = consume_number(chars)
-                                if token == "." then
-                                        return token, "dot"
-                                elseif token == "..." then
-                                        return token, "symbol"
+                        if m.readtable[cs[1]] then
+                                token, toktype, cs = m.readtable[cs[1]](cs)
+                                -- return { v = token, u = toktype }, cs
+                                return token, toktype, cs
+                        elseif cs[1]:match("%s") then
+                                _, cs = consume_whitespace(cs)
+                                return nil, nil, cs
+                                -- return nil, cs
+                        elseif cs[1]:match("[%d.+-]") then
+                                -- numbers, +, -, ., ...
+                                local token, cs = consume_token(cs)
+                                if token:match("[-+]") or token == "..." then
+                                        return token, "symbol", cs
+                                        -- return { v = token, u = "symbol" }, cs
+                                elseif token == "." then
+                                        return token, "dot", cs
+                                        -- return { v = token, u = "dot" }, cs
                                 else
-                                        return token, "number"
+                                        local n = tonumber(token)
+                                        assert (n ~= nil, "Bad number: "..n)
+                                        return n, "number", cs
+                                        -- return { v = n, u = "number" }, cs
                                 end
                         else
-                                token, chars = consume_symbol(chars)
-                                return token, "symbol"
+                                token, cs = consume_token(cs)
+                                return token, "symbol", cs
+                                -- return { v = token, u = "symbol" }, cs
                         end
-                        if #chars == 0 then return nil end
                 end
         end
 end
 
-function read.tokenize (program)
-        if not program or #program == 0 then return nil end
-        local tokens = {}
-        for token, toktype in read.scan(program_characters(program)) do
-                table.insert(tokens, {type = toktype, value = token})
+function m.readchar (port)
+        if #port.line > 0 then
+                local ch = pop(port.line)
+                return ch
+        else
+                return port.file.read(1)
         end
-        return tokens
 end
 
-read.readmacros = {
-        open =
-                function (token, tokens)
-                        local L, lt = {}, nil
-                        while tokens[1].type ~= "close" do
-                                local nt = read.parse(tokens)
-                                -- this isn't .. my /favorite/ implementation,
-                                -- but it works
-                                if nt == "." then
-                                        lt = read.parse(tokens)
-                                        break
+function m.read (port)
+        local function read_ahead (tok, toktype)
+                if not tok then error("Unexpected EOF") end
+                if toktype == "open" then
+                        local L = {}
+                        while true do
+                                local tok, toktype = port:next_token()
+                                if toktype == "close" then
+                                        return t.list(L)
                                 else
-                                        table.insert(L, nt)
+                                        table.insert(L,
+                                                read_ahead(tok, toktype))
                                 end
-                                assert(tokens[1], "Unexpected EOF")
                         end
-                        pop(tokens)     -- remove final ")"
-                        return type.List(L, lt)
-                end,
-        close =
-                function (token, tokens)
-                        error ("Unexpected '" .. token.value .. "'")
-                end,
-        quote =
-                function (token, tokens)
-                        local Q
-                        if token.value == "'" then
-                                Q = {"quote"}
-                        elseif token.value == "`" then
-                                Q = {"quasiquote"}
-                        elseif token.value == "," then
-                                Q = {"unquote"}
-                        end
-                        table.insert(Q, read.parse(tokens))
-                        return type.List(Q)
-                end,
-}
-
-function read.parse (tokens)
-        if not next(tokens) then return nil end
-        local token = pop(tokens)
-        if read.readmacros[token.type] then
-                return read.readmacros[token.type](token, tokens)
-        else
-                return token.value
+                elseif toktype == "close" then
+                        error("Unexpected ')'")
+                else return tok
+                end
+        end
+        -- body of read
+        local tok1, toktype1 = port:next_token()
+        if not tok1 then return nil
+        else return read_ahead(tok1, toktype1)
         end
 end
 
-function read.read (program)
-        return read.parse(read.tokenize(program))
+function m.read_string (str)
+        return m.read(m.inport(str, "string"))
 end
 
 ---
-return read
+return m