364 lines
9.4 KiB
Lua
364 lines
9.4 KiB
Lua
local insert, remove, concat
|
|
do
|
|
local _obj_0 = table
|
|
insert, remove, concat = _obj_0.insert, _obj_0.remove, _obj_0.concat
|
|
end
|
|
local Source
|
|
Source = require("code_obj").Source
|
|
local List, Dict
|
|
do
|
|
local _obj_0 = require('containers')
|
|
List, Dict = _obj_0.List, _obj_0.Dict
|
|
end
|
|
local Files = require('files')
|
|
local unpack = unpack or table.unpack
|
|
local as_lua
|
|
as_lua = function(self)
|
|
if type(self) == 'number' then
|
|
return tostring(self)
|
|
end
|
|
do
|
|
local mt = getmetatable(self)
|
|
if mt then
|
|
do
|
|
local _as_lua = mt.as_lua
|
|
if _as_lua then
|
|
return _as_lua(self)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if self.as_lua then
|
|
return self:as_lua()
|
|
end
|
|
return error("Not supported: " .. tostring(self))
|
|
end
|
|
local SyntaxTree
|
|
do
|
|
local _class_0
|
|
local _base_0 = {
|
|
__tostring = function(self)
|
|
local bits
|
|
do
|
|
local _accum_0 = { }
|
|
local _len_0 = 1
|
|
for _index_0 = 1, #self do
|
|
local b = self[_index_0]
|
|
_accum_0[_len_0] = type(b) == 'string' and b:as_lua() or tostring(b)
|
|
_len_0 = _len_0 + 1
|
|
end
|
|
bits = _accum_0
|
|
end
|
|
for k, v in pairs(self) do
|
|
if not (bits[k] or k == 'type' or k == 'source') then
|
|
table.insert(bits, tostring(k) .. "=" .. tostring(type(v) == 'string' and v:as_lua() or v))
|
|
end
|
|
end
|
|
return tostring(self.type) .. "{" .. tostring(table.concat(bits, ", ")) .. "}"
|
|
end,
|
|
__eq = function(self, other)
|
|
if type(self) ~= type(other) or #self ~= #other or getmetatable(self) ~= getmetatable(other) then
|
|
return false
|
|
end
|
|
if self.type ~= other.type then
|
|
return false
|
|
end
|
|
for i = 1, #self do
|
|
if self[i] ~= other[i] then
|
|
return false
|
|
end
|
|
end
|
|
return true
|
|
end,
|
|
as_lua = function(self)
|
|
local bits
|
|
do
|
|
local _accum_0 = { }
|
|
local _len_0 = 1
|
|
for _index_0 = 1, #self do
|
|
local b = self[_index_0]
|
|
_accum_0[_len_0] = as_lua(b)
|
|
_len_0 = _len_0 + 1
|
|
end
|
|
bits = _accum_0
|
|
end
|
|
for k, v in pairs(self) do
|
|
if not (bits[k]) then
|
|
table.insert(bits, "[ " .. tostring(as_lua(k)) .. "]=" .. tostring(as_lua(v)))
|
|
end
|
|
end
|
|
return "SyntaxTree{" .. tostring(table.concat(bits, ", ")) .. "}"
|
|
end,
|
|
get_source_file = function(self)
|
|
return self.__class.source_code_for_tree[self]
|
|
end,
|
|
get_source_code = function(self)
|
|
return self.__class.source_code_for_tree[self]:sub(self.source.start, self.source.stop - 1)
|
|
end,
|
|
add = function(self, ...)
|
|
local n = #self
|
|
for i = 1, select('#', ...) do
|
|
self[n + i] = select(i, ...)
|
|
end
|
|
self.stub = nil
|
|
end,
|
|
with = function(self, fn)
|
|
if type(fn) == 'table' then
|
|
local replacements = fn
|
|
fn = function(t)
|
|
if t.type == "Var" then
|
|
do
|
|
local r = replacements[t:as_var()]
|
|
if r then
|
|
return r
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
local replacement = fn(self)
|
|
if replacement == false then
|
|
return nil
|
|
end
|
|
if replacement then
|
|
if SyntaxTree:is_instance(replacement) then
|
|
do
|
|
local _tbl_0 = { }
|
|
for k, v in pairs(replacement) do
|
|
_tbl_0[k] = v
|
|
end
|
|
replacement = _tbl_0
|
|
end
|
|
replacement.source = self.source
|
|
if self.comments then
|
|
replacement.comments = {
|
|
unpack(self.comments)
|
|
}
|
|
end
|
|
replacement = SyntaxTree(replacement)
|
|
end
|
|
else
|
|
replacement = {
|
|
source = self.source,
|
|
comments = self.comments and {
|
|
unpack(self.comments)
|
|
}
|
|
}
|
|
local changes = false
|
|
for k, v in pairs(self) do
|
|
local _continue_0 = false
|
|
repeat
|
|
replacement[k] = v
|
|
if SyntaxTree:is_instance(v) then
|
|
local r = v:with(fn)
|
|
if r == v or r == nil then
|
|
_continue_0 = true
|
|
break
|
|
end
|
|
changes = true
|
|
replacement[k] = r
|
|
end
|
|
_continue_0 = true
|
|
until true
|
|
if not _continue_0 then
|
|
break
|
|
end
|
|
end
|
|
if not (changes) then
|
|
return self
|
|
end
|
|
replacement = SyntaxTree(replacement)
|
|
end
|
|
return replacement
|
|
end,
|
|
contains = function(self, subtree)
|
|
if subtree == self then
|
|
return true
|
|
end
|
|
for k, v in pairs(self) do
|
|
if SyntaxTree:is_instance(v) then
|
|
if v:contains(subtree) then
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end,
|
|
get_args = function(self)
|
|
assert(self.type == "Action" or self.type == "MethodCall", "Only actions and method calls have arguments")
|
|
local args = { }
|
|
if self.type == "MethodCall" then
|
|
args[1] = self[1]
|
|
for i = 2, #self do
|
|
local _list_0 = self[i]
|
|
for _index_0 = 1, #_list_0 do
|
|
local tok = _list_0[_index_0]
|
|
if type(tok) ~= 'string' then
|
|
args[#args + 1] = tok
|
|
end
|
|
end
|
|
end
|
|
else
|
|
for _index_0 = 1, #self do
|
|
local tok = self[_index_0]
|
|
if type(tok) ~= 'string' then
|
|
args[#args + 1] = tok
|
|
end
|
|
end
|
|
end
|
|
return args
|
|
end,
|
|
get_stub = function(self)
|
|
local _exp_0 = self.type
|
|
if "Action" == _exp_0 then
|
|
local stub_bits = { }
|
|
local arg_i = 1
|
|
for _index_0 = 1, #self do
|
|
local a = self[_index_0]
|
|
if type(a) == 'string' then
|
|
stub_bits[#stub_bits + 1] = a
|
|
else
|
|
stub_bits[#stub_bits + 1] = arg_i
|
|
arg_i = arg_i + 1
|
|
end
|
|
end
|
|
while type(stub_bits[#stub_bits]) == 'number' do
|
|
stub_bits[#stub_bits] = nil
|
|
end
|
|
return concat(stub_bits, " ")
|
|
elseif "MethodCall" == _exp_0 then
|
|
return "0, " .. table.concat((function()
|
|
local _accum_0 = { }
|
|
local _len_0 = 1
|
|
for i = 2, #self do
|
|
_accum_0[_len_0] = self[i]:get_stub()
|
|
_len_0 = _len_0 + 1
|
|
end
|
|
return _accum_0
|
|
end)(), "; ")
|
|
else
|
|
return error(tostring(self.type) .. "s do not have stubs")
|
|
end
|
|
end,
|
|
as_var = function(self)
|
|
assert(self.type == "Var")
|
|
if type(self[1]) == 'string' then
|
|
return self[1]
|
|
else
|
|
return self[1]:get_stub()
|
|
end
|
|
end,
|
|
matching = function(self, patt)
|
|
if patt.type == "Var" then
|
|
return {
|
|
[patt:as_var()] = self
|
|
}
|
|
end
|
|
if patt.type ~= self.type then
|
|
return nil
|
|
end
|
|
if patt.type == "Action" and patt:get_stub() ~= self:get_stub() then
|
|
return nil
|
|
end
|
|
if #self ~= #patt then
|
|
return nil
|
|
end
|
|
local match = { }
|
|
for i = 1, #self do
|
|
local v = self[i]
|
|
local pv = patt[i]
|
|
if type(v) ~= type(pv) then
|
|
return nil
|
|
end
|
|
if type(v) ~= 'table' then
|
|
if not (v == pv) then
|
|
return nil
|
|
end
|
|
else
|
|
local m = v:matching(pv)
|
|
if not (m) then
|
|
return nil
|
|
end
|
|
for mk, mv in pairs(m) do
|
|
if match[mk] and match[mk] ~= mv then
|
|
return nil
|
|
end
|
|
match[mk] = mv
|
|
end
|
|
end
|
|
end
|
|
return Dict(match)
|
|
end,
|
|
_breadth_first = function(self)
|
|
coroutine.yield(self)
|
|
for _index_0 = 1, #self do
|
|
local child = self[_index_0]
|
|
if getmetatable(child) == SyntaxTree.__base then
|
|
child:_breadth_first()
|
|
end
|
|
end
|
|
end,
|
|
breadth_first = function(self)
|
|
return coroutine.create(function()
|
|
return self:_breadth_first()
|
|
end)
|
|
end,
|
|
_depth_first = function(self)
|
|
coroutine.yield(self)
|
|
for _index_0 = 1, #self do
|
|
local child = self[_index_0]
|
|
if getmetatable(child) == SyntaxTree.__base then
|
|
child:_depth_first()
|
|
end
|
|
end
|
|
end,
|
|
depth_first = function(self)
|
|
return coroutine.create(function()
|
|
return self:_depth_first()
|
|
end)
|
|
end
|
|
}
|
|
_base_0.__index = _base_0
|
|
_class_0 = setmetatable({
|
|
__init = function() end,
|
|
__base = _base_0,
|
|
__name = "SyntaxTree"
|
|
}, {
|
|
__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
|
|
local self = _class_0
|
|
self.source_code_for_tree = setmetatable({ }, {
|
|
__index = function(self, t)
|
|
local s = t.source
|
|
local f = Files.read(s.filename)
|
|
return f
|
|
end,
|
|
__mode = "k"
|
|
})
|
|
self.is_instance = function(self, t)
|
|
return type(t) == 'table' and getmetatable(t) == self.__base
|
|
end
|
|
SyntaxTree = _class_0
|
|
end
|
|
SyntaxTree.__base.__type = "a Syntax Tree"
|
|
getmetatable(SyntaxTree).__call = function(self, t, ...)
|
|
if type(t.source) == 'string' then
|
|
t.source = Source:from_string(t.source)
|
|
end
|
|
setmetatable(t, self.__base)
|
|
for i = 1, select("#", ...) do
|
|
t[i] = select(i, ...)
|
|
end
|
|
if t.type == 'Action' then
|
|
t.stub = t:get_stub()
|
|
end
|
|
return t
|
|
end
|
|
return SyntaxTree
|