+ LuaMacro

1 files changed, 320 insertions, 0 deletions

diff --git a/Tools/LuaMacro/macro/Getter.lua b/Tools/LuaMacro/macro/Getter.lua
new file mode 100644
index 0000000..af58b3c
--- /dev/null
+++ b/Tools/LuaMacro/macro/Getter.lua
@@ -0,0 +1,320 @@
+--- Getter class. Used to get values from the token stream. The first
+-- argument `get` of a macro substitution function is of this type.
+--
+--    M.define ('\\',function(get,put)
+--        local args, body = get:idens('('), get:list()
+--        return put:keyword 'function' '(' : idens(args) ')' :
+--             keyword 'return' : list(body) : space() : keyword 'end'
+--    end)
+--
+-- The second argument `put` is a `TokenList` object.
+-- @see macro.TokenList
+-- @module macro.Getter
+
+local TokenList = require 'macro.TokenList'
+local append = table.insert
+local setmetatable = setmetatable
+
+local Getter = {
+    __call = function(self)
+        return self.fun()
+    end
+}
+local M = Getter
+
+Getter.__index = Getter;
+
+local scan_iter
+
+function Getter.new (get)
+    return setmetatable({fun=get},Getter)
+end
+
+function Getter.from_tl(tl)
+    return Getter.new(scan_iter(tl))
+end
+
+local Tok = {
+    __tostring = function(self)
+        return self[2]
+    end
+}
+
+local function tok_new (t)
+    return setmetatable(t,Tok)
+end
+
+-- create a token iterator out of a token list
+function Getter.scan_iter (tlist)
+    local i,n = 1,#tlist
+    return function(k)
+        if k ~= nil then
+            k = i + k
+            if k < 1 or k > n then return nil end
+            return tlist[k]
+        end
+        local tv = tlist[i]
+        if tv == nil then return nil end
+        i = i + 1
+        return tv[1],tv[2]
+    end
+end
+
+scan_iter = Getter.scan_iter
+
+--- get the next non-whitespace token.
+-- @return token type
+-- @return token value
+-- @function Getter.next
+function Getter.next(get)
+    local t,v = get()
+    while t == 'space' or t == 'comment' do
+        t,v = get()
+    end
+    return t,v
+end
+
+local TL,LTL = TokenList.new, TokenList.new_list
+
+
+local function tappend (tl,t,val)
+    val = val or t
+    append(tl,{t,val})
+end
+
+--- get a balanced block.
+-- Typically for grabbing up to an `end` keyword including any nested
+-- `if`, `do` or `function` blocks with their own `end` keywords.
+-- @param tok the token stream
+-- @param begintokens set of tokens requiring their own nested *endtokens*
+--   (default: `{['do']=true,['function']=true,['if']=true}`)
+-- @param endtokens set of tokens ending a block (default:`{['end']=true}`)
+-- @return list of tokens
+-- @return block end token in form `{type,value}`
+-- @usage
+--   -- copy a balanced table constructor
+--   get:expecting '{'
+--   put '{':tokens (get:block ({['{']=true}, {['}']=true}) '}')
+function Getter.block(tok,begintokens,endtokens)
+    begintokens = begintokens or {['do']=true,['function']=true,['if']=true}
+    endtokens = endtokens or {['end']=true}
+    local level = 1 -- used to count expected matching `endtokens`
+    local tl = TL()
+    local token,value
+    repeat
+        token,value = tok()
+        if not token then return nil,'unexpected end of block' end
+        if begintokens[value] then
+	    level = level + 1
+        elseif endtokens[value] then
+	    level = level - 1
+        end
+	if level > 0 then  -- final end token is returned separately
+            tappend(tl,token,value)
+	end
+    until level == 0
+    return tl,tok_new{token,value}
+end
+
+--- get a delimited list of token lists.
+-- Typically used for grabbing argument lists like ('hello',a+1,fred(c,d)); will count parens
+-- so that the delimiter (usually a comma) is ignored inside sub-expressions. You must have
+-- already read the start token of the list, e.g. open parentheses. It will eat the end token
+-- and return the list of TLs, plus the end token. Based on similar code in Penlight's
+-- `pl.lexer` module.
+-- @param tok the token stream
+-- @param endt the end token (default ')')
+-- @param delim the delimiter (default ',')
+-- @return list of token lists
+-- @return end token in form {type,value}
+function Getter.list(tok,endtoken,delim)
+    endtoken = endtoken or ')'
+    delim = delim or ','
+    local parm_values = LTL()
+    local level = 1 -- used to count ( and )
+    local tl = TL()
+    local is_end
+    if type(endtoken) == 'function' then
+        is_end = endtoken
+    elseif endtoken == '\n' then
+        is_end = function(t,val)
+            return t == 'space' and val:find '\n'
+        end
+    else
+        is_end = function (t)
+            return t == endtoken
+        end
+    end
+    local token,value = tok()
+    if is_end(token,value) then return parm_values end
+    if token == 'space' then
+        token,value = tok()
+    end
+    while true do
+        if not token then return nil,'unexpected end of list' end -- end of stream is an error!
+        if is_end(token,value) and level == 1 then
+            append(parm_values,tl)
+            break
+        elseif token == '(' then
+            level = level + 1
+            tappend(tl,'(')
+        elseif token == ')' then
+            level = level - 1
+            if level == 0 then -- finished with parm list
+                append(parm_values,tl)
+                break
+            else
+                tappend(tl,')')
+            end
+        elseif token == '{' then
+            level = level + 1
+            tappend(tl,'{')
+        elseif token == '}' then
+            level = level - 1
+            tappend(tl,'}')
+        elseif token == delim and level == 1 then
+            append(parm_values,tl) -- a new parm
+            tl = TL()
+        else
+            tappend(tl,token,value)
+        end
+        token,value=tok()
+    end
+    return parm_values,tok_new{token,value}
+end
+
+function Getter.upto_keywords (k1,k2)
+    return function(t,v)
+        return t == 'keyword' and (v == k1 or v == k2)
+    end,''
+end
+
+local tnext = Getter.next
+
+
+function Getter.upto(tok,k1,k2)
+    local endt = k1
+    if type(k1) == 'string' and k1:match '^%a+$' then
+        endt = Getter.upto_keywords(k1,k2)
+    end
+    local ltl,tok = tok:list(endt,'')
+    M.assert(ltl ~= nil and #ltl > 0,'failed to grab tokens')
+    return ltl[1],tok
+end
+
+function Getter.line(tok)
+    return tok:upto(function(t,v)
+        return (t=='space' and v:match '\n') or t == 'comment'
+    end)
+end
+
+
+local function prettyprint (t, v)
+    v = v:gsub ("\n", "\\n")
+    if t == "string" then
+        if #v > 16 then v = v:sub(1,12).."..."..v:sub(1,1) end
+        return t.." "..v
+    end
+    if #v > 16 then v = v:sub(1,12).."..." end
+    if t == "space" or t == "comment" or t == "keyword" then
+        return t.." '"..v.."'"
+    elseif t == v then
+        return "'"..v.."'"
+    else
+        return t.." "..v
+    end
+end
+
+--- get the next identifier token.
+-- (will be an error if the token has wrong type)
+-- @return identifier name
+function Getter.iden(tok)
+    local t,v = tnext(tok)
+    M.assert(t == 'iden','expecting identifier, got '..prettyprint(t,v))
+    return v
+end
+
+Getter.name = Getter.iden -- backwards compatibility!
+
+--- get the next number token.
+-- (will be an error if the token has wrong type)
+-- @return converted number
+function Getter.number(tok)
+    local t,v = tnext(tok)
+    M.assert(t == 'number','expecting number, got '..prettyprint(t,v))
+    return tonumber(v)
+end
+
+--- get a delimited list of identifiers.
+-- works like list.
+-- @param tok the token stream
+-- @param endt the end token (default ')')
+-- @param delim the delimiter (default ',')
+-- @see list
+function Getter.idens(tok,endt,delim)
+    local ltl,err = tok:list(endt,delim)
+    if not ltl then error('idens: '..err) end
+    local names = {}
+    -- list() will return {{}} for an empty list of tlists
+    for i = 1,#ltl do
+	local tl = ltl[i]
+        local tv = tl[1]
+        if tv then
+            if tv[1] == 'space' then tv = tl[2] end
+            names[i] = tv[2]
+        end
+    end
+    return names, err
+end
+
+Getter.names = Getter.idens -- backwards compatibility!
+
+--- get the next string token.
+-- (will be an error if the token has wrong type)
+-- @return string value (without quotes)
+function Getter.string(tok)
+    local t,v = tok:expecting("string")
+    return v:sub(2,-2)
+end
+
+--- assert that the next token has the given type. This will throw an
+-- error if the next non-whitespace token does not match.
+-- @param type a token type ('iden','string',etc)
+-- @param value a token value (optional)
+-- @usage  get:expecting '('
+-- @usage  get:expecting ('iden','bonzo')
+function Getter.expecting (tok,type,value)
+    local t,v = tnext(tok)
+    if t ~= type then M.error ("expected "..type.." got "..prettyprint(t,v)) end
+    if value then
+        if v ~= value then M.error("expected "..value.." got "..prettyprint(t,v)) end
+    end
+    return t,v
+end
+
+--- peek ahead or before in the token stream.
+-- @param k positive delta for looking ahead, negative for looking behind.
+-- @param dont_skip true if you want to check for whitespace
+-- @return the token type
+-- @return the token value
+-- @return the token offset
+-- @function Getter.peek
+
+--- peek ahead two tokens.
+-- @return first token type
+-- @return first token value
+-- @return second token type
+-- @return second token value
+-- @function Getter.peek2
+
+--- patch the token stream at the end.
+-- @param idx index in output table
+-- @param text to replace value at that index
+-- @function Getter.patch
+
+--- put out a placeholder for later patching.
+-- @param put a putter object
+-- @return an index into the output table
+-- @function Getter.placeholder
+
+return Getter