326 lines
9.2 KiB
Lua
326 lines
9.2 KiB
Lua
-- Prototype for nel
|
|
require("nellie.parser")
|
|
|
|
function Bind(scope,abstract,callback)
|
|
for _,expression in pairs(Parse(abstract)) do
|
|
assert_meta(Expression)(expression)
|
|
scope:insert(Binding(
|
|
expression,
|
|
callback
|
|
))
|
|
end
|
|
end
|
|
function Run(scope,expression,chain,name)
|
|
name = name or "?"
|
|
assert_meta(Chain)(chain,"Arg 'chain' #3: %s")
|
|
assert_meta(Scope)(scope,"Arg 'scope' #1: %s")
|
|
assert_meta(Expression)(expression,"Arg 'expression' #2: %s")
|
|
local chain = Chain(expression:link(name)):from(chain)
|
|
return scope:run(expression,chain)
|
|
end
|
|
function Do(scope,expression,chain,name)
|
|
local latest
|
|
for index,item in pairs(expression.items) do
|
|
latest = Run(scope,item,chain,"do: "+tostring(index))
|
|
end
|
|
return latest
|
|
end
|
|
|
|
NelliScope = Scope()
|
|
local ns = NelliScope
|
|
--[[
|
|
-- Replace all :text() occurrences with ones in 'exp_map'
|
|
local function substitute(target,exp_map)
|
|
local text = target:text()
|
|
if text then -- Replace the parameter
|
|
local map = exp_map[text]
|
|
if map then
|
|
return Expression({map})
|
|
else
|
|
return target
|
|
end
|
|
else
|
|
local new = Expression()
|
|
for sub in iterate(target.items) do
|
|
local t = type_of(sub)
|
|
if t == "string" then
|
|
new:insert(sub)
|
|
elseif t == Expression then
|
|
new:insert(substitute(sub,exp_map))
|
|
end
|
|
end
|
|
return new
|
|
end
|
|
end
|
|
-- Iterate over all :text() occurrences
|
|
local function traverse(expression,callback)
|
|
for sub in iterate(expression.items) do
|
|
if type_of("sub") == Expression then
|
|
traverse(sub,callback)
|
|
else
|
|
callback(sub)
|
|
end
|
|
end
|
|
end
|
|
local function Bexpands(s,e,c)
|
|
local bound = {}
|
|
for sub in iterate(e.abstract.items) do
|
|
local t = type_of(sub)
|
|
if t == Expression then
|
|
local text = sub:text()
|
|
if not (
|
|
text:match("'.+'")
|
|
) then
|
|
--[[error(string.format(
|
|
"nel: Abstract parameter \"%s\" not in 'quotes'.",
|
|
text
|
|
))]]--[[
|
|
else
|
|
table.insert(bound,text)
|
|
end
|
|
end
|
|
end
|
|
return Binding(e.abstract,function(_s,_e,_c)
|
|
local map = {}
|
|
for binding in iterate(bound) do
|
|
map[binding] = _e[binding]
|
|
end
|
|
local expanded = substitute(e.expression,map)
|
|
return Run(_s,expanded,_c,"means: "..tostring(expanded))
|
|
end)
|
|
end]]
|
|
--[[Bind(ns,"(abstract) means (expression)",Bexpands)
|
|
local function Bevaluate(s,e,c)
|
|
return Binding(e.abstract,function(_s,_e,_c)
|
|
local scope = Scope()
|
|
scope.parent = s
|
|
for name,expression in pairs(_e.items) do
|
|
scope:insert(Binding(
|
|
Expression({name}),
|
|
Run(_s,_e,_c,string.format("expands: %s:",name))
|
|
))
|
|
end
|
|
return Run(scope,e,c,"evaluate: result")
|
|
end)
|
|
end
|
|
Bind(ns,"(abstract) becomes (expression)",Bevaluates)
|
|
Bind(ns,"(identifier) is (expression)",function(s,e,c)
|
|
if not e.identifier:text(s,e,c) then
|
|
error("nel: text-only expression expected.")
|
|
end
|
|
return Binding(e.identifier,Run())
|
|
end)
|
|
local function doAll(s,e,c)
|
|
local res
|
|
for item in iterate(e.items) do
|
|
if type_of(item) ~= Expression then
|
|
error(
|
|
string.format(
|
|
"Unexpected words '%s' in 'do' expression.",
|
|
tostring(item)
|
|
)
|
|
)
|
|
end
|
|
res = Run(s,item,c,"do: line")
|
|
end
|
|
return res
|
|
end
|
|
-- Note that do actually runs stuff in the same scope it was called
|
|
-- Otherwise we can't have easily multiple mutations to the parent scope
|
|
local function Bdo(s,e,c)
|
|
local scope
|
|
if e.scope then
|
|
scope = Run(s,e.scope,c,"do: scope")
|
|
else
|
|
scope = Scope()
|
|
scope.parent = s
|
|
end
|
|
return doAll(s,e.expression,c)
|
|
end
|
|
Bind(ns,"do (expression) in (scope)",Bdo)
|
|
Bind(ns,"do (expression)",Bdo)
|
|
Bind(ns,"(abstract) broken into (expressions) as do (results)",function(s,e,c)
|
|
return Binding(e.abstract,function(_s,_e,_c)
|
|
local params = List()
|
|
for index,item in pairs(_e) do
|
|
local expr = Object()
|
|
expr.identifier = index
|
|
expr.expression = item
|
|
table.insert(params,expr)
|
|
end
|
|
local expressions = e.expressions:text()
|
|
if not expressions then
|
|
error(
|
|
string.format(
|
|
"nel: binding: sub expressions: %s not text-only!",
|
|
e.expressions
|
|
)
|
|
)
|
|
end
|
|
local scope = Scope()
|
|
scope.parent = s
|
|
scope:insert(Binding(Expression{expressions},params))
|
|
return doAll(s,e.expressions,c)
|
|
end)
|
|
end)
|
|
local _list = {}
|
|
local function List()
|
|
return setmetatable(_list,{})
|
|
end
|
|
Bind(ns,"a new list",function(s,e,c)
|
|
return List()
|
|
end)
|
|
Bind(ns,"for each (item) in (list) do (expressions)",function(s,e,c)
|
|
local item = e.item:text()
|
|
if not property then
|
|
error(
|
|
string.format(
|
|
"nel: for each: item: '%s' not text only!",
|
|
e.property
|
|
)
|
|
)
|
|
end
|
|
local list = Run(s,e.list,c,"for each: list")
|
|
assert_meta(List)(list,"for each: list: %s")
|
|
for index,item in ipairs(list) do
|
|
local scope = Scope()
|
|
scope.parent = s
|
|
scope:insert(Binding(Expression{item}))
|
|
doAll(s,e.expressions,c)
|
|
end
|
|
end)
|
|
Bind(ns,"add (item) to (list)",function(s,e,c)
|
|
local item = Run(s,e.list,c,"")
|
|
local list = Run(s,e.list,c,"add: list")
|
|
assert_meta(List)(list,"add: list: %s")
|
|
table.insert(list,item)
|
|
end)
|
|
-- I even quite dislike these, they are prone to gumming things up
|
|
local _table = {}
|
|
Bind(ns,"a new table",function(s,e,c) return {} end)
|
|
Bind(ns,"set (index) of (table) to (value)",function(s,e,c)
|
|
local index = e.index:text()
|
|
if not index then
|
|
index = Run(s,e.index,c,"set: index")
|
|
end
|
|
local tab = Run(s,e.table,c,"set: table")
|
|
local val = Run(s,e.value,c,"set: value")
|
|
tab[index] = val
|
|
end)
|
|
Bind(ns,"get (index) of (table)",function(s,e,c)
|
|
local index = e.index:text()
|
|
if not index then
|
|
index = Run(s,e.index,c,"get: index")
|
|
end
|
|
local tab = Run(s,e.table,c,"get: table")
|
|
return tab[index]
|
|
end)
|
|
local _object = {}
|
|
local function Object()
|
|
return setmetatable(_object,{})
|
|
end
|
|
Bind(ns,"a new object",function(s,e,c)
|
|
return Object()
|
|
end)
|
|
Bind(ns,"(property) of (object) is (value)",function(s,e,c)
|
|
local property = e.property:text()
|
|
if not property then
|
|
error(
|
|
string.format(
|
|
"nel: property is: property: '%s' not text only!",
|
|
e.property
|
|
)
|
|
)
|
|
end
|
|
local object = Run(s,e.object,c,"property is: object")
|
|
assert_meta(Object)(object,"nel: property is: object: %s")
|
|
local value = Run(s,e.value,c,"property is: value")
|
|
object[property] = value
|
|
end)
|
|
Bind(ns,"(property) of (object)",function(s,e,c)
|
|
local property = e.property:text()
|
|
if not property then
|
|
error(
|
|
string.format(
|
|
"nel: property is: property: '%s' not text only!",
|
|
e.property
|
|
)
|
|
)
|
|
end
|
|
local object = Run(s,e.object,c,"property is: object")
|
|
assert_meta(Object)(object,"nel: property is: object: %s")
|
|
return object[property]
|
|
end)
|
|
Bind(ns,"error (text)",function(s,e,c)
|
|
error("nel: "..Run(s,e.text,c,"error: message"))
|
|
end)
|
|
Bind(ns,"this scope",function(s,e,c)
|
|
return s
|
|
end)
|
|
Bind(ns,"a new scope",function(s,e,c)
|
|
return Scope()
|
|
end)
|
|
-- Read a file in the current directly, more for compiling
|
|
Bind(ns,"read file (path)",function(s,e,c)
|
|
return read(Run(s,e.path,c,"read: path"))
|
|
end)
|
|
-- Take some text and interpret it into an expression
|
|
Bind(ns,"evaluate (text) in (scope)",function(s,e,c)
|
|
local scope = Run(s,e.scope,c,"evaluate: scope")
|
|
return Run(s,interpret(Run(scope,e.text,c,"include: source")),c,"include: result")
|
|
end)
|
|
Bind(ns,"text (literal)",function(s,e,c)
|
|
return e.literal:text()
|
|
end)
|
|
Bind(ns,"return (expression)",function(s,e,c)
|
|
return Run(s,e.expression,c,"return: result")
|
|
end)
|
|
Bind(ns,"let (binding) in (scope)",function(s,e,c)
|
|
|
|
end)
|
|
Bind(ns,"text (literal)",function(s,e,c) return e.literal:text() end)
|
|
Bind(ns,"let ((named (name)) be (value))",function(s,e,c) end)
|
|
Bind(ns,"new table",function(s,e,c) return {} end)
|
|
]]
|
|
|
|
Bind(ns,"(closed)",function(s,e,c) return Run(s,e.closed,c,"(...)") end)
|
|
Bind(ns,"log (text)",function(s,e,c) log(Run(s,e.text,c,"print: text")) end)
|
|
Bind(ns,"this scope",function(s,e,c) return s end)
|
|
Bind(ns,"new scope",function(s,e,c) return Scope() end) -- TODO: chains?!!?
|
|
Bind(ns,"index (table) with (key)",function(s,e,c) return Run(s,e,c,"") end)
|
|
Bind(ns,[[
|
|
(input) means do (output);
|
|
(input) in (input_scope) means do (output);
|
|
(input) means do (output) in (output_scope);
|
|
(input) in (input_scope) means do (output) in (output_scope)
|
|
]],function(s,e,c1) -- A substitution
|
|
local input_scope = s
|
|
if e.input_scope then input_scope = Run(s,e.input_scope,c1,"means: input scope") end
|
|
local output_scope = s
|
|
if e.output_scope then output_scope = Run(s,e.output_scope,c2,"means: output scope") end
|
|
Bind(e.input_scope,e.input,function(s,e,c2)
|
|
return Do(e.output_scope,e.output,c2) -- TODO: chains?!
|
|
end)
|
|
end)
|
|
Bind(ns,"do (stuff) in (scope); do (stuff)",function(s,e,c)
|
|
s = s or Scope()
|
|
return Do(s,e.stuff,c)
|
|
end)
|
|
Bind(ns,"new table",function(s,e,c) return {} end)
|
|
|
|
local Hpath = "nellie/helper.nel"
|
|
local Hchain = Chain("in internal: "..Hpath)
|
|
local success,result = Hchain:call(function(chain)
|
|
Run(NelliScope,Parse(read(Hpath),Hpath,chain),chain)
|
|
end)
|
|
|
|
--[[ Documentation:
|
|
(log (text)) -> Log text to the output stream (print?)
|
|
(a new scope) -> Becomes a created new scope
|
|
(this scope) -> Becomes the current scope
|
|
(macro) expands to (expansion) -> Becomes a binding which makes
|
|
(<macro>) become whatever (result) will become in place
|
|
(expression)
|
|
--]]
|
|
|
|
return ns |