etlua.lua

local VERSION = "1.3.0"
local insert, concat
do
 local _obj_0 = table
 insert, concat = _obj_0.insert, _obj_0.concat
end
local load, setfenv, assert, type, error, tostring, tonumber, setmetatable
do
 local _obj_0 = _G
 load, setfenv, assert, type, error, tostring, tonumber, setmetatable = _obj_0.load, _obj_0.setfenv, _obj_0.assert, _obj_0.type, _obj_0.error, _obj_0.tostring, _obj_0.tonumber, _obj_0.setmetatable
end
setfenv = setfenv or function(fn, env)
 local name
 local i = 1
 while true do
 name = debug.getupvalue(fn, i)
 if not name or name == "_ENV" then
 break
 end
 i = i + 1
 end
 if name then
 debug.upvaluejoin(fn, i, (function()
 return env
 end), 1)
 end
 return fn
end
local html_escape_entities = {
 ['&'] = '&',
 ['<'] = '&lt;',
 ['>'] = '&gt;',
 ['"'] = '&quot;',
 ["'"] = '&#039;'
}
local html_escape
html_escape = function(str)
 return (str:gsub([=[["><'&]]=], html_escape_entities))
end
local get_line
get_line = function(str, line_num)
 for line in str:gmatch("([^\n]*)\n?") do
 if line_num == 1 then
 return line
 end
 line_num = line_num - 1
 end
end
local pos_to_line
pos_to_line = function(str, pos)
 local line = 1
 for _ in str:sub(1, pos):gmatch("\n") do
 line = line + 1
 end
 return line
end
local Compiler
do
 local _class_0
 local _base_0 = {
 html_escape = true,
 render = function(self)
 return table.concat(self.buffer)
 end,
 push = function(self, str, ...)
 local i = self.i + 1
 self.buffer[i] = str
 self.i = i
 if ... then
 return self:push(...)
 end
 end,
 header = function(self)
 return self:push("local _tostring, _escape, _b, _b_i = ...\n")
 end,
 footer = function(self)
 return self:push("return _b")
 end,
 increment = function(self)
 return self:push("_b_i = _b_i + 1\n")
 end,
 mark = function(self, pos)
 return self:push("--[[", tostring(pos), "]] ")
 end,
 assign = function(self, ...)
 self:push("_b[_b_i] = ", ...)
 if ... then
 return self:push("\n")
 end
 end,
 compile_chunks = function(self, chunks)
 self:header()
 for _index_0 = 1, #chunks do
 local chunk = chunks[_index_0]
 local t = type(chunk)
 if t == "table" then
 t = chunk[1]
 end
 local _exp_0 = t
 if "string" == _exp_0 then
 self:increment()
 self:assign(("%q"):format(chunk))
 elseif "code" == _exp_0 then
 self:mark(chunk[3])
 self:push(chunk[2], "\n")
 elseif "=" == _exp_0 or "-" == _exp_0 then
 self:increment()
 self:mark(chunk[3])
 self:assign()
 if t == "=" and self.html_escape then
 self:push("_escape(_tostring(", chunk[2], "))\n")
 else
 self:push("_tostring(", chunk[2], ")\n")
 end
 else
 error("unknown type " .. tostring(t))
 end
 end
 self:footer()
 return self:render()
 end
 }
 _base_0.__index = _base_0
 _class_0 = setmetatable({
 __init = function(self)
 self.buffer = { }
 self.i = 0
 end,
 __base = _base_0,
 __name = "Compiler"
 }, {
 __index = _base_0,
 __call = function(cls, ...)
 local _self_0 = setmetatable({}, _base_0)
 cls.__init(_self_0, ...)
 return _self_0
 end
 })
 _base_0.__class = _class_0
 Compiler = _class_0
end
local Parser
do
 local _class_0
 local _base_0 = {
 open_tag = "<%",
 close_tag = "%>",
 modifiers = "^[=-]",
 next_tag = function(self)
 local start, stop = self.str:find(self.open_tag, self.pos, true)
 if not (start) then
 self:push_raw(self.pos, #self.str)
 return false
 end
 if not (start == self.pos) then
 self:push_raw(self.pos, start - 1)
 end
 self.pos = stop + 1
 local modifier
 if self.str:match(self.modifiers, self.pos) then
 do
 local _with_0 = self.str:sub(self.pos, self.pos)
 self.pos = self.pos + 1
 modifier = _with_0
 end
 end
 local close_start, close_stop = self.str:find(self.close_tag, self.pos, true)
 if not (close_start) then
 return nil, self:error_for_pos(start, "failed to find closing tag")
 end
 while self:in_string(self.pos, close_start) do
 close_start, close_stop = self.str:find(self.close_tag, close_stop, true)
 if not (close_start) then
 return nil, self:error_for_pos(start, "failed to find string close")
 end
 end
 local trim_newline
 if "-" == self.str:sub(close_start - 1, close_start - 1) then
 close_start = close_start - 1
 trim_newline = true
 end
 self:push_code(modifier or "code", self.pos, close_start - 1)
 self.pos = close_stop + 1
 if trim_newline then
 do
 local match = self.str:match("^\n", self.pos)
 if match then
 self.pos = self.pos + #match
 end
 end
 end
 return true
 end,
 in_string = function(self, start, stop)
 local in_string = false
 local end_delim = nil
 local escape = false
 local pos = 0
 local skip_until = nil
 local chunk = self.str:sub(start, stop)
 for char in chunk:gmatch(".") do
 local _continue_0 = false
 repeat
 pos = pos + 1
 if skip_until then
 if pos <= skip_until then
 _continue_0 = true
 break
 end
 skip_until = nil
 end
 if end_delim then
 if end_delim == char and not escape then
 in_string = false
 end_delim = nil
 end
 else
 if char == "'" or char == '"' then
 end_delim = char
 in_string = true
 end
 if char == "[" then
 do
 local lstring = chunk:match("^%[=*%[", pos)
 if lstring then
 local lstring_end = lstring:gsub("%[", "]")
 local lstring_p1, lstring_p2 = chunk:find(lstring_end, pos, true)
 if not (lstring_p1) then
 return true
 end
 skip_until = lstring_p2
 end
 end
 end
 end
 escape = char == "\\"
 _continue_0 = true
 until true
 if not _continue_0 then
 break
 end
 end
 return in_string
 end,
 push_raw = function(self, start, stop)
 return insert(self.chunks, self.str:sub(start, stop))
 end,
 push_code = function(self, kind, start, stop)
 return insert(self.chunks, {
 kind,
 self.str:sub(start, stop),
 start
 })
 end,
 compile = function(self, str)
 local success, err = self:parse(str)
 if not (success) then
 return nil, err
 end
 local fn
 fn, err = self:load(self:chunks_to_lua())
 if not (fn) then
 return nil, err
 end
 return function(...)
 local buffer
 buffer, err = self:run(fn, ...)
 if buffer then
 return concat(buffer)
 else
 return nil, err
 end
 end
 end,
 parse = function(self, str)
 self.str = str
 assert(type(self.str) == "string", "expecting string for parse")
 self.pos = 1
 self.chunks = { }
 while true do
 local found, err = self:next_tag()
 if err then
 return nil, err
 end
 if not (found) then
 break
 end
 end
 return true
 end,
 parse_error = function(self, err, code)
 local line_no, err_msg = err:match("%[.-%]:(%d+): (.*)$")
 line_no = tonumber(line_no)
 if not (line_no) then
 return 
 end
 local line = get_line(code, line_no)
 local source_pos = tonumber(line:match("^%-%-%[%[(%d+)%]%]"))
 if not (source_pos) then
 return 
 end
 return self:error_for_pos(source_pos, err_msg)
 end,
 error_for_pos = function(self, source_pos, err_msg)
 local source_line_no = pos_to_line(self.str, source_pos)
 local source_line = get_line(self.str, source_line_no)
 return tostring(err_msg) .. " [" .. tostring(source_line_no) .. "]: " .. tostring(source_line)
 end,
 load = function(self, code, name)
 if name == nil then
 name = "etlua"
 end
 local code_fn
 do
 local code_ref = code
 code_fn = function()
 do
 local ret = code_ref
 code_ref = nil
 return ret
 end
 end
 end
 local fn, err = load(code_fn, name)
 if not (fn) then
 do
 local err_msg = self:parse_error(err, code)
 if err_msg then
 return nil, err_msg
 end
 end
 return nil, err
 end
 return fn
 end,
 run = function(self, fn, env, buffer, i, ...)
 if env == nil then
 env = { }
 end
 local combined_env = setmetatable({ }, {
 __index = function(self, name)
 local val = env[name]
 if val == nil then
 val = _G[name]
 end
 return val
 end
 })
 if not (buffer) then
 buffer = { }
 i = 0
 end
 setfenv(fn, combined_env)
 return fn(tostring, html_escape, buffer, i, ...)
 end,
 compile_to_lua = function(self, str, ...)
 local success, err = self:parse(str)
 if not (success) then
 return nil, err
 end
 return self:chunks_to_lua(...)
 end,
 chunks_to_lua = function(self, compiler_cls)
 if compiler_cls == nil then
 compiler_cls = Compiler
 end
 return compiler_cls():compile_chunks(self.chunks)
 end
 }
 _base_0.__index = _base_0
 _class_0 = setmetatable({
 __init = function() end,
 __base = _base_0,
 __name = "Parser"
 }, {
 __index = _base_0,
 __call = function(cls, ...)
 local _self_0 = setmetatable({}, _base_0)
 cls.__init(_self_0, ...)
 return _self_0
 end
 })
 _base_0.__class = _class_0
 Parser = _class_0
end
local compile
do
 local _base_0 = Parser()
 local _fn_0 = _base_0.compile
 compile = function(...)
 return _fn_0(_base_0, ...)
 end
end
local render
render = function(str, ...)
 local fn, err = compile(str)
 if fn then
 return fn(...)
 else
 return nil, err
 end
end
return {
 compile = compile,
 render = render,
 Parser = Parser,
 Compiler = Compiler,
 _version = VERSION
}