Bruce/nomsu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Changed stub convention to (foo 1 baz 2) -> foo_1_baz instead of

Browse Source 
foo_1_baz_2, removed "smext", made some cleanup changes.
This commit is contained in:
Bruce Hill 2018-11-02 14:38:24 -07:00
parent d0c3c57f7b
commit 307dea1881
28 changed files with 359 additions and 381 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
code_obj.lua
View File

@ -78,7 +78,7 @@ do
local _class_0 local _class_0
local _base_0 = { local _base_0 = {
is_code = true, is_code = true,
as_smext = function(self) text = function(self)
if self.__str == nil then if self.__str == nil then
local buff, indent = { }, 0 local buff, indent = { }, 0
local match, gsub, rep local match, gsub, rep
@ -95,7 +95,7 @@ do
end end
end end
else else
b = b:as_smext() b = b:text()
if indent > 0 then if indent > 0 then
b = gsub(b, "\n", "\n" .. rep(" ", indent)) b = gsub(b, "\n", "\n" .. rep(" ", indent))
end end
@ -107,7 +107,7 @@ do
return self.__str return self.__str
end, end,
__tostring = function(self) __tostring = function(self)
return self:as_smext() return self:text()
end, end,
as_lua = function(self) as_lua = function(self)
return tostring(self.__class.__name) .. "(" .. tostring(concat({ return tostring(self.__class.__name) .. "(" .. tostring(concat({
@ -126,13 +126,13 @@ do
}, ", ")) .. ")" }, ", ")) .. ")"
end, end,
__len = function(self) __len = function(self)
return #self:as_smext() return #self:text()
end, end,
match = function(self, ...) match = function(self, ...)
return self:as_smext():match(...) return self:text():match(...)
end, end,
gmatch = function(self, ...) gmatch = function(self, ...)
return self:as_smext():gmatch(...) return self:text():gmatch(...)
end, end,
dirty = function(self) dirty = function(self)
self.__str = nil self.__str = nil
@ -169,7 +169,7 @@ do
end, end,
trailing_line_len = function(self) trailing_line_len = function(self)
if self._trailing_line_len == nil then if self._trailing_line_len == nil then
self._trailing_line_len = #self:as_smext():match("[^\n]*$") self._trailing_line_len = #self:text():match("[^\n]*$")
end end
return self._trailing_line_len return self._trailing_line_len
end, end,
@ -213,7 +213,7 @@ do
b.dirty = error b.dirty = error
end end
if not (type(b) == 'string') then if not (type(b) == 'string') then
b = b:as_smext() b = b:text()
end end
local line = match(b, "\n([^\n]*)$") local line = match(b, "\n([^\n]*)$")
if line then if line then
@ -400,7 +400,7 @@ do
end end
else else
walk(b, pos) walk(b, pos)
b = b:as_smext() b = b:text()
end end
pos = pos + #b pos = pos + #b
end end
@ -502,12 +502,7 @@ do
end end
NomsuCode = _class_0 NomsuCode = _class_0
end end
Code.__base.append_1 = assert(Code.__base.append) Code.__base.add_1_joined_with = assert(Code.__base.concat_append)
Code.__base.append_1_joined_by_2 = assert(Code.__base.concat_append)
Code.__base.prepend_1 = assert(Code.__base.prepend)
LuaCode.__base.declare_locals_1 = assert(LuaCode.__base.declare_locals)
LuaCode.__base.remove_free_vars_1 = assert(LuaCode.__base.remove_free_vars)
LuaCode.__base.add_free_vars_1 = assert(LuaCode.__base.add_free_vars)
return { return {
Code = Code, Code = Code,
NomsuCode = NomsuCode, NomsuCode = NomsuCode,

25
code_obj.moon
View File

@ -50,7 +50,7 @@ class Code
--assert(@source and Source\is_instance(@source), "Source has the wrong type") --assert(@source and Source\is_instance(@source), "Source has the wrong type")
@append(...) @append(...)
as_smext: => text: =>
if @__str == nil if @__str == nil
buff, indent = {}, 0 buff, indent = {}, 0
{:match, :gsub, :rep} = string {:match, :gsub, :rep} = string
@ -59,23 +59,23 @@ class Code
if spaces = match(b, "\n([ ]*)[^\n]*$") if spaces = match(b, "\n([ ]*)[^\n]*$")
indent = #spaces indent = #spaces
else else
b = b\as_smext! b = b\text!
if indent > 0 if indent > 0
b = gsub(b, "\n", "\n"..rep(" ", indent)) b = gsub(b, "\n", "\n"..rep(" ", indent))
buff[#buff+1] = b buff[#buff+1] = b
@__str = concat(buff, "") @__str = concat(buff, "")
return @__str return @__str
__tostring: => @as_smext! __tostring: => @text!
as_lua: => as_lua: =>
"#{@__class.__name}(#{concat {tostring(@source)\as_lua!, unpack([b\as_lua! for b in *@bits])}, ", "})" "#{@__class.__name}(#{concat {tostring(@source)\as_lua!, unpack([b\as_lua! for b in *@bits])}, ", "})"
__len: => #@as_smext! __len: => #@text!
match: (...)=> @as_smext!\match(...) match: (...)=> @text!\match(...)
gmatch: (...)=> @as_smext!\gmatch(...) gmatch: (...)=> @text!\gmatch(...)
dirty: => dirty: =>
@__str = nil @__str = nil
@ -100,7 +100,7 @@ class Code
trailing_line_len: => trailing_line_len: =>
if @_trailing_line_len == nil if @_trailing_line_len == nil
@_trailing_line_len = #@as_smext!\match("[^\n]*$") @_trailing_line_len = #@text!\match("[^\n]*$")
return @_trailing_line_len return @_trailing_line_len
is_multiline: => is_multiline: =>
@ -133,7 +133,7 @@ class Code
bits[#bits+1] = b bits[#bits+1] = b
b.dirty = error if b.is_code b.dirty = error if b.is_code
unless type(b) == 'string' unless type(b) == 'string'
b = b\as_smext! b = b\text!
line = match(b, "\n([^\n]*)$") line = match(b, "\n([^\n]*)$")
if line if line
line_len = #line line_len = #line
@ -240,7 +240,7 @@ class LuaCode extends Code
nomsu_to_lua[lua.source.start] = pos nomsu_to_lua[lua.source.start] = pos
else else
walk b, pos walk b, pos
b = b\as_smext! b = b\text!
pos += #b pos += #b
walk self, 1 walk self, 1
return { return {
@ -259,11 +259,6 @@ class NomsuCode extends Code
as_lua: Code.as_lua as_lua: Code.as_lua
__len: Code.__len __len: Code.__len
Code.__base.append_1 = assert Code.__base.append Code.__base.add_1_joined_with = assert Code.__base.concat_append
Code.__base.append_1_joined_by_2 = assert Code.__base.concat_append
Code.__base.prepend_1 = assert Code.__base.prepend
LuaCode.__base.declare_locals_1 = assert LuaCode.__base.declare_locals
LuaCode.__base.remove_free_vars_1 = assert LuaCode.__base.remove_free_vars
LuaCode.__base.add_free_vars_1 = assert LuaCode.__base.add_free_vars
return {:Code, :NomsuCode, :LuaCode, :Source} return {:Code, :NomsuCode, :LuaCode, :Source}

1
compatibility/4.8.10.nom
View File

@ -57,3 +57,4 @@ upgrade action "parse 1 as 2" to "4.8.10" via (..)
upgrade action (compile as %) to "4.8.10" as (what % compiles to) upgrade action (compile as %) to "4.8.10" as (what % compiles to)
upgrade action (action %) to "4.8.10" as (%'s meaning) upgrade action (action %) to "4.8.10" as (%'s meaning)
upgrade action (remove action %) to "4.8.10" as ((%'s meaning) = (nil))

2
compatibility/compatibility.nom
View File

@ -52,7 +52,7 @@ externally (upgrade action %stub to %version via %upgrade_fn) means:
%retval = (make tree %body) %retval = (make tree %body)
%lua::append (..) %lua::append (..)
Lua "\ Lua "\
..upgrade_action_1_to_2_via_3(\(quote %action.stub), \(%version as lua expr), function(\(..) ..upgrade_action_1_to_2_via(\(quote %action.stub), \(%version as lua expr), function(\(..)
\%tree as lua id \%tree as lua id
..) ..)
return \%retval return \%retval

50
containers.lua
View File

@ -134,15 +134,15 @@ local _list_mt = {
return ret return ret
end, end,
__index = { __index = {
add_1 = insert, add = insert,
append_1 = insert, append = insert,
add_1_at_index_2 = function(t, x, i) add_1_at_index = function(t, x, i)
return insert(t, i, x) return insert(t, i, x)
end, end,
at_index_1_add_2 = insert, at_index_1_add = insert,
pop = remove, pop = remove,
remove_last = remove, remove_last = remove,
remove_index_1 = remove, remove_index = remove,
last = (function(self) last = (function(self)
return self[#self] return self[#self]
end), end),
@ -165,7 +165,7 @@ local _list_mt = {
return _accum_0 return _accum_0
end)()) end)())
end, end,
joined_with_1 = function(self, glue) joined_with = function(self, glue)
return table.concat((function() return table.concat((function()
local _accum_0 = { } local _accum_0 = { }
local _len_0 = 1 local _len_0 = 1
@ -177,7 +177,7 @@ local _list_mt = {
return _accum_0 return _accum_0
end)(), glue) end)(), glue)
end, end,
has_1 = function(self, item) has = function(self, item)
for _index_0 = 1, #self do for _index_0 = 1, #self do
local x = self[_index_0] local x = self[_index_0]
if x == item then if x == item then
@ -186,14 +186,14 @@ local _list_mt = {
end end
return false return false
end, end,
remove_1 = function(self, item) remove = function(self, item)
for i, x in ipairs(self) do for i, x in ipairs(self) do
if x == item then if x == item then
remove(self, i) remove(self, i)
end end
end end
end, end,
index_of_1 = function(self, item) index_of = function(self, item)
for i, x in ipairs(self) do for i, x in ipairs(self) do
if x == item then if x == item then
return i return i
@ -201,7 +201,7 @@ local _list_mt = {
end end
return nil return nil
end, end,
from_1_to_2 = function(self, start, stop) from_1_to = function(self, start, stop)
local n = #self local n = #self
if n < 0 then if n < 0 then
start = (n + 1 - start) start = (n + 1 - start)
@ -383,20 +383,20 @@ do
local lines, line, line_at, as_lua_id, is_lua_id local lines, line, line_at, as_lua_id, is_lua_id
lines, line, line_at, as_lua_id, is_lua_id = string2.lines, string2.line, string2.line_at, string2.as_lua_id, string2.is_lua_id lines, line, line_at, as_lua_id, is_lua_id = string2.lines, string2.line, string2.line_at, string2.as_lua_id, string2.is_lua_id
local text_methods = { local text_methods = {
formatted_with_1 = format, formatted_with = format,
byte_1 = byte, byte = byte,
position_of_1 = find, position_of = find,
position_of_1_after_2 = find, position_of_1_after = find,
as_a_lua_identifier = as_lua_id, as_a_lua_identifier = as_lua_id,
is_a_lua_identifier = is_lua_id, is_a_lua_identifier = is_lua_id,
as_a_lua_id = as_lua_id, as_a_lua_id = as_lua_id,
is_a_lua_id = is_lua_id, is_a_lua_id = is_lua_id,
bytes_1_to_2 = function(self, start, stop) bytes_1_to = function(self, start, stop)
return List({ return List({
byte(tostring(self), start, stop) byte(tostring(self), start, stop)
}) })
end, end,
[as_lua_id("with 1 -> 2")] = gsub, [as_lua_id("with 1 ->")] = gsub,
bytes = function(self) bytes = function(self)
return List({ return List({
byte(tostring(self), 1, -1) byte(tostring(self), 1, -1)
@ -405,8 +405,8 @@ do
lines = function(self) lines = function(self)
return List(lines(self)) return List(lines(self))
end, end,
line_1 = line, line = line,
wrapped_to_1 = function(self, maxlen) wrapped_to = function(self, maxlen)
local _lines = { } local _lines = { }
local _list_0 = self:lines() local _list_0 = self:lines()
for _index_0 = 1, #_list_0 do for _index_0 = 1, #_list_0 do
@ -422,22 +422,22 @@ do
end end
return table.concat(_lines, "\n") return table.concat(_lines, "\n")
end, end,
line_at_1 = function(self, i) line_at = function(self, i)
return (line_at(self, i)) return (line_at(self, i))
end, end,
line_number_at_1 = function(self, i) line_number_at = function(self, i)
return select(2, line_at(self, i)) return select(2, line_at(self, i))
end, end,
line_position_at_1 = function(self, i) line_position_at = function(self, i)
return select(3, line_at(self, i)) return select(3, line_at(self, i))
end, end,
matches_1 = function(self, patt) matches = function(self, patt)
return match(self, patt) and true or false return match(self, patt) and true or false
end, end,
matching_1 = function(self, patt) matching = function(self, patt)
return (match(self, patt)) return (match(self, patt))
end, end,
matching_groups_1 = function(self, patt) matching_groups = function(self, patt)
return { return {
match(self, patt) match(self, patt)
} }
@ -445,7 +445,7 @@ do
[as_lua_id("* 1")] = function(self, n) [as_lua_id("* 1")] = function(self, n)
return rep(self, n) return rep(self, n)
end, end,
all_matches_of_1 = function(self, patt) all_matches_of = function(self, patt)
local result = { } local result = { }
local stepper, x, i = gmatch(self, patt) local stepper, x, i = gmatch(self, patt)
while true do while true do

42
containers.moon
View File

@ -58,31 +58,31 @@ _list_mt =
insert(ret, x) insert(ret, x)
return ret return ret
__index: __index:
add_1: insert, append_1: insert add: insert, append: insert
add_1_at_index_2: (t,x,i)-> insert(t,i,x) add_1_at_index: (t,x,i)-> insert(t,i,x)
at_index_1_add_2: insert at_index_1_add: insert
pop: remove, remove_last: remove, remove_index_1: remove pop: remove, remove_last: remove, remove_index: remove
last: (=> @[#@]), first: (=> @[1]) last: (=> @[#@]), first: (=> @[1])
_1_st_to_last:nth_to_last, _1_nd_to_last:nth_to_last _1_st_to_last:nth_to_last, _1_nd_to_last:nth_to_last
_1_rd_to_last:nth_to_last, _1_th_to_last:nth_to_last _1_rd_to_last:nth_to_last, _1_th_to_last:nth_to_last
-- TODO: use stringify() to allow joining misc. objects? -- TODO: use stringify() to allow joining misc. objects?
joined: => table.concat([tostring(x) for x in *@]), joined: => table.concat([tostring(x) for x in *@]),
joined_with_1: (glue)=> table.concat([tostring(x) for x in *@], glue), joined_with: (glue)=> table.concat([tostring(x) for x in *@], glue),
has_1: (item)=> has: (item)=>
for x in *@ for x in *@
if x == item if x == item
return true return true
return false return false
remove_1: (item)=> remove: (item)=>
for i,x in ipairs @ for i,x in ipairs @
if x == item if x == item
remove(@, i) remove(@, i)
index_of_1: (item)=> index_of: (item)=>
for i,x in ipairs @ for i,x in ipairs @
if x == item if x == item
return i return i
return nil return nil
from_1_to_2: (start, stop)=> from_1_to: (start, stop)=>
n = #@ n = #@
start = (n+1-start) if n < 0 start = (n+1-start) if n < 0
stop = (n+1-stop) if n < 0 stop = (n+1-stop) if n < 0
@ -149,15 +149,15 @@ do
string2 = require 'string2' string2 = require 'string2'
{:lines, :line, :line_at, :as_lua_id, :is_lua_id} = string2 {:lines, :line, :line_at, :as_lua_id, :is_lua_id} = string2
text_methods = text_methods =
formatted_with_1:format, byte_1:byte, position_of_1:find, position_of_1_after_2:find, formatted_with:format, byte:byte, position_of:find, position_of_1_after:find,
as_a_lua_identifier: as_lua_id, is_a_lua_identifier: is_lua_id, as_a_lua_identifier: as_lua_id, is_a_lua_identifier: is_lua_id,
as_a_lua_id: as_lua_id, is_a_lua_id: is_lua_id, as_a_lua_id: as_lua_id, is_a_lua_id: is_lua_id,
bytes_1_to_2: (start, stop)=> List{byte(tostring(@), start, stop)} bytes_1_to: (start, stop)=> List{byte(tostring(@), start, stop)}
[as_lua_id "with 1 -> 2"]: gsub [as_lua_id "with 1 ->"]: gsub
bytes: => List{byte(tostring(@), 1, -1)}, bytes: => List{byte(tostring(@), 1, -1)},
lines: => List(lines(@)) lines: => List(lines(@))
line_1: line line: line
wrapped_to_1: (maxlen)=> wrapped_to: (maxlen)=>
_lines = {} _lines = {}
for line in *@lines! for line in *@lines!
while #line > maxlen while #line > maxlen
@ -169,14 +169,14 @@ do
_lines[#_lines+1] = line _lines[#_lines+1] = line
return table.concat(_lines, "\n") return table.concat(_lines, "\n")
line_at_1: (i)=> (line_at(@, i)) line_at: (i)=> (line_at(@, i))
line_number_at_1: (i)=> select(2, line_at(@, i)) line_number_at: (i)=> select(2, line_at(@, i))
line_position_at_1: (i)=> select(3, line_at(@, i)) line_position_at: (i)=> select(3, line_at(@, i))
matches_1: (patt)=> match(@, patt) and true or false matches: (patt)=> match(@, patt) and true or false
matching_1: (patt)=> (match(@, patt)) matching: (patt)=> (match(@, patt))
matching_groups_1: (patt)=> {match(@, patt)} matching_groups: (patt)=> {match(@, patt)}
[as_lua_id "* 1"]: (n)=> rep(@, n) [as_lua_id "* 1"]: (n)=> rep(@, n)
all_matches_of_1: (patt)=> all_matches_of: (patt)=>
result = {} result = {}
stepper,x,i = gmatch(@, patt) stepper,x,i = gmatch(@, patt)
while true while true

32
core/control_flow.nom
View File

@ -102,8 +102,20 @@ test:
.." .."
# Basic loop control # Basic loop control
(do next) compiles to (Lua "goto continue") (stop %var) compiles to:
(stop) compiles to (Lua "break") if %var:
return (..)
Lua "goto stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)"
..else: return (Lua "break")
(do next %var) compiles to:
if %var:
return (..)
Lua "goto continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)"
..else: return (Lua "goto continue")
[===stop %var ===, ---stop %var ---, ***stop %var ***] all compile to (..)
Lua "::stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
[===next %var ===, ---next %var ---, ***next %var ***] all compile to (..)
Lua "::continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
# While loops # While loops
test: test:
@ -177,16 +189,6 @@ test:
return %lua return %lua
# For loop control flow
(stop %var) compiles to (..)
Lua "goto stop_\((%var.stub if (%var.type == "Action") else %var) as lua identifier)"
(do next %var) compiles to (..)
Lua "goto continue_\((%var.stub if (%var.type == "Action") else %var) as lua identifier)"
[===stop %var ===, ---stop %var ---, ***stop %var ***] all compile to (..)
Lua "::stop_\((%var.stub if (%var.type == "Action") else %var) as lua identifier)::"
[===next %var ===, ---next %var ---, ***next %var ***] all compile to (..)
Lua "::continue_\((%var.stub if (%var.type == "Action") else %var) as lua identifier)::"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test: test:
@ -365,7 +367,7 @@ test:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test: test:
if: when:
(1 == 2) (100 < 0): (1 == 2) (100 < 0):
barf "bad conditional" barf "bad conditional"
(1 == 0) (1 == 1) %not_a_variable.x: do nothing (1 == 0) (1 == 1) %not_a_variable.x: do nothing
@ -377,7 +379,7 @@ test:
barf "bad conditional" barf "bad conditional"
# Multi-branch conditional (if..elseif..else) # Multi-branch conditional (if..elseif..else)
[if %body, when %body] all compile to: (when %body) compiles to:
%code = (Lua "") %code = (Lua "")
%clause = "if" %clause = "if"
%else_allowed = (yes) %else_allowed = (yes)
@ -512,8 +514,6 @@ test:
%d.x = "bad" %d.x = "bad"
barf barf
..then always: %d.x = "good" ..then always: %d.x = "good"
..and if it barfs: do nothing
assume (%d.x == "good") assume (%d.x == "good")
(do %action then always %final_action) compiles to: (do %action then always %final_action) compiles to:
define mangler define mangler

22
core/errors.nom
View File

@ -4,8 +4,7 @@
use "core/metaprogramming.nom" use "core/metaprogramming.nom"
(barf) compiles to (Lua "error(nil, 0);") (barf %msg) compiles to (Lua "error(\(=lua "\%msg and \(%msg as lua expr) or 'nil'"), 0);")
(barf %msg) compiles to (Lua "error(\(%msg as lua expr), 0);")
(compile error at %tree %msg) compiles to (..) (compile error at %tree %msg) compiles to (..)
Lua "nomsu:compile_error(\(%tree as lua expr), \(%msg as lua expr))" Lua "nomsu:compile_error(\(%tree as lua expr), \(%msg as lua expr))"
(compile error at %tree %msg hint %hint) compiles to (..) (compile error at %tree %msg hint %hint) compiles to (..)
@ -66,9 +65,9 @@ test:
local ok, ret = xpcall(function() local ok, ret = xpcall(function()
\(%action as lua statements) \(%action as lua statements)
fell_through = true fell_through = true
end, function(\(%msg as lua expr)) end, function(\(=lua "\%fallback and \(%msg as lua expr) or ''"))
local ok, ret = pcall(function() local ok, ret = pcall(function()
\(%fallback as lua statements) \((=lua "\%fallback or \%msg") as lua statements)
end) end)
if not ok then err, erred = ret, true end if not ok then err, erred = ret, true end
end) end)
@ -84,18 +83,19 @@ test:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[..] #
try %action and if it succeeds %success or if it barfs %fallback [..]
try %action and if it barfs %fallback or if it succeeds %success try %action and if it succeeds %success or if it barfs %fallback
..all parse as (..) try %action and if it barfs %fallback or if it succeeds %success
try %action and if it succeeds %success or if it barfs (=lua "") %fallback ..all parse as (..)
try %action and if it succeeds %success or if it barfs (=lua "") %fallback
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
(try %action) parses as (..) (try %action) parses as (..)
try %action and if it succeeds (do nothing) or if it barfs (do nothing) try %action and if it succeeds (do nothing) or if it barfs (do nothing)
(try %action and if it barfs %fallback) parses as (..) #(try %action and if it barfs %fallback) parses as (..)
try %action and if it succeeds (do nothing) or if it barfs %fallback try %action and if it succeeds (do nothing) or if it barfs %fallback
(try %action and if it barfs %msg %fallback) parses as (..) (try %action and if it barfs %msg %fallback) parses as (..)

8
core/math.nom
View File

@ -80,21 +80,21 @@ externally (%n to the nearest %rounder) means (..)
[all of %items, all %items] all compile to: [all of %items, all %items] all compile to:
unless (%items.type is "List"): unless (%items.type is "List"):
return (Lua value "utils.all(\(%items as lua expr))") return (Lua value "utils.all(\(%items as lua expr))")
%clauses = (((% as lua expr)::as smext) for % in %items) %clauses = (((% as lua expr)::text) for % in %items)
return (Lua value "(\(%clauses::joined with " and "))") return (Lua value "(\(%clauses::joined with " and "))")
[not all of %items, not all %items] all parse as (not (all of %items)) [not all of %items, not all %items] all parse as (not (all of %items))
[any of %items, any %items] all compile to: [any of %items, any %items] all compile to:
unless (%items.type is "List"): unless (%items.type is "List"):
return (Lua value "utils.any(\(%items as lua expr))") return (Lua value "utils.any(\(%items as lua expr))")
%clauses = (((% as lua expr)::as smext) for % in %items) %clauses = (((% as lua expr)::text) for % in %items)
return (Lua value "(\(%clauses::joined with " or "))") return (Lua value "(\(%clauses::joined with " or "))")
[none of %items, none %items] all parse as (not (any of %items)) [none of %items, none %items] all parse as (not (any of %items))
[sum of %items, sum %items] all compile to: [sum of %items, sum %items] all compile to:
unless (%items.type is "List"): unless (%items.type is "List"):
return (Lua value "utils.sum(\(%items as lua expr))") return (Lua value "utils.sum(\(%items as lua expr))")
%clauses = (((% as lua expr)::as smext) for % in %items) %clauses = (((% as lua expr)::text) for % in %items)
return (Lua value "(\(%clauses::joined with " + "))") return (Lua value "(\(%clauses::joined with " + "))")
[if all of %items %body, if all of %items then %body] all parse as (..) [if all of %items %body, if all of %items then %body] all parse as (..)
@ -139,7 +139,7 @@ externally (%n to the nearest %rounder) means (..)
[product of %items, product %items] all compile to: [product of %items, product %items] all compile to:
unless (%items.type is "List"): unless (%items.type is "List"):
return (Lua value "utils.product(\(%items as lua expr))") return (Lua value "utils.product(\(%items as lua expr))")
%clauses = (((% as lua expr)::as smext) for % in %items) %clauses = (((% as lua expr)::text) for % in %items)
return (Lua value "(\(%clauses::joined with " * "))") return (Lua value "(\(%clauses::joined with " * "))")
externally [avg of %items, average of %items] all mean (..) externally [avg of %items, average of %items] all mean (..)

37
core/metaprogramming.nom
View File

@ -3,7 +3,7 @@
This File contains actions for making actions and compile-time actions and some helper This File contains actions for making actions and compile-time actions and some helper
functions to make that easier. functions to make that easier.
lua> "NOMSU_CORE_VERSION = 8" lua> "NOMSU_CORE_VERSION = 9"
lua> "\ lua> "\
..do ..do
local mangle_index = 0 local mangle_index = 0
@ -16,14 +16,14 @@ lua> "\
end end
end end
COMPILE_ACTIONS["define mangler"] = function(nomsu, tree) COMPILE_ACTIONS["define mangler"] = function(nomsu, tree)
return LuaCode(tree.source, "local mangle_1 = mangler()") return LuaCode(tree.source, "local mangle = mangler()")
end" end"
lua> "\ lua> "\
..COMPILE_ACTIONS["1 -> 2"] = function(nomsu, tree, \%args, \%body) ..COMPILE_ACTIONS["1 ->"] = function(nomsu, tree, \%args, \%body)
local lua = LuaCode.Value(tree.source, "(function(") local lua = LuaCode.Value(tree.source, "(function(")
if SyntaxTree:is_instance(\%args) and \%args.type == "Action" then \%args = \%args:get_args() end if SyntaxTree:is_instance(\%args) and \%args.type == "Action" then \%args = \%args:get_args() end
local lua_args = table.map(\%args, function(a) return SyntaxTree:is_instance(a) and nomsu:compile(a):as_smext() or a end) local lua_args = table.map(\%args, function(a) return SyntaxTree:is_instance(a) and nomsu:compile(a):text() or a end)
lua:concat_append(lua_args, ", ") lua:concat_append(lua_args, ", ")
local body_lua = SyntaxTree:is_instance(\%body) and nomsu:compile(\%body):as_statements("return ") or \%body local body_lua = SyntaxTree:is_instance(\%body) and nomsu:compile(\%body):as_statements("return ") or \%body
body_lua:remove_free_vars(lua_args) body_lua:remove_free_vars(lua_args)
@ -63,15 +63,15 @@ test:
asdf asdf
assume (%tmp is (nil)) or barf "compile to is leaking variables" assume (%tmp is (nil)) or barf "compile to is leaking variables"
lua> "\ lua> "\
..COMPILE_ACTIONS["1 compiles to 2"] = function(nomsu, tree, \%actions, \%body) ..COMPILE_ACTIONS["1 compiles to"] = function(nomsu, tree, \%actions, \%body)
if \%actions.type ~= "List" then \%actions = {\%actions, type="List"} end if \%actions.type ~= "List" then \%actions = {\%actions, type="List"} end
local \%args = {"nomsu", "tree", unpack(table.map(\%actions[1]:get_args(), function(a) return nomsu:compile(a):as_smext() end))} local \%args = {"nomsu", "tree", unpack(table.map(\%actions[1]:get_args(), function(a) return nomsu:compile(a):text() end))}
local lua = LuaCode(tree.source, "COMPILE_ACTIONS[", \%actions[1].stub:as_lua(), local lua = LuaCode(tree.source, "COMPILE_ACTIONS[", \%actions[1].stub:as_lua(),
"] = ", \(what (%args -> %body) compiles to)) "] = ", \(what (%args -> %body) compiles to))
for i=2,#\%actions do for i=2,#\%actions do
local alias = \%actions[i] local alias = \%actions[i]
local \%alias_args = {"nomsu", "tree", unpack(table.map(alias:get_args(), function(a) return nomsu:compile(a):as_\ local \%alias_args = {"nomsu", "tree", unpack(table.map(alias:get_args(), function(a) return nomsu:compile(a):text() \
..smext() end))} ..end))}
lua:append("\\nCOMPILE_ACTIONS[", alias.stub:as_lua(), "] = ") lua:append("\\nCOMPILE_ACTIONS[", alias.stub:as_lua(), "] = ")
if utils.equivalent(\%args, \%alias_args) then if utils.equivalent(\%args, \%alias_args) then
lua:append("COMPILE_ACTIONS[", \%actions[1].stub:as_lua(), "]") lua:append("COMPILE_ACTIONS[", \%actions[1].stub:as_lua(), "]")
@ -85,7 +85,7 @@ lua> "\
end end
return lua return lua
end end
COMPILE_ACTIONS["1 all compile to 2"] = COMPILE_ACTIONS["1 compiles to 2"]" COMPILE_ACTIONS["1 all compile to"] = COMPILE_ACTIONS["1 compiles to"]"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -116,14 +116,14 @@ test:
lua> "\ lua> "\
..if \%actions.type ~= "List" then \%actions = {\%actions, type="List"} end ..if \%actions.type ~= "List" then \%actions = {\%actions, type="List"} end
local fn_name = \%actions[1].stub:as_lua_id() local fn_name = \%actions[1].stub:as_lua_id()
local \%args = table.map(\%actions[1]:get_args(), function(a) return nomsu:compile(a):as_smext() end) local \%args = table.map(\%actions[1]:get_args(), function(a) return nomsu:compile(a):text() end)
local lua = LuaCode(tree.source, fn_name, " = ", \(what (%args -> %body) compiles to)) local lua = LuaCode(tree.source, fn_name, " = ", \(what (%args -> %body) compiles to))
lua:add_free_vars({fn_name}) lua:add_free_vars({fn_name})
for i=2,#\%actions do for i=2,#\%actions do
local alias = \%actions[i] local alias = \%actions[i]
local alias_name = alias.stub:as_lua_id() local alias_name = alias.stub:as_lua_id()
lua:add_free_vars({alias_name}) lua:add_free_vars({alias_name})
local \%alias_args = table.map(alias:get_args(), function(a) return nomsu:compile(a):as_smext() end) local \%alias_args = table.map(alias:get_args(), function(a) return nomsu:compile(a):text() end)
lua:append("\\n", alias_name, " = ") lua:append("\\n", alias_name, " = ")
if utils.equivalent(\%args, \%alias_args) then if utils.equivalent(\%args, \%alias_args) then
lua:append(fn_name) lua:append(fn_name)
@ -151,7 +151,7 @@ test:
return lua" return lua"
test: test:
assume (((say %)'s meaning) == (=lua "say_1")) assume (((say %)'s meaning) == (=lua "say"))
(%action's meaning) compiles to (Lua value (%action.stub as lua id)) (%action's meaning) compiles to (Lua value (%action.stub as lua id))
test: test:
@ -174,7 +174,7 @@ test:
..local replacements = {} ..local replacements = {}
if \%actions.type ~= "List" then \%actions = {\%actions, type="List"} end if \%actions.type ~= "List" then \%actions = {\%actions, type="List"} end
for i,arg in ipairs(\%actions[1]:get_args()) do for i,arg in ipairs(\%actions[1]:get_args()) do
replacements[arg[1]] = nomsu:compile(arg):as_smext() replacements[arg[1]] = nomsu:compile(arg):text()
end end
local function make_tree(t) local function make_tree(t)
if SyntaxTree:is_instance(t) and t.type == "Var" then if SyntaxTree:is_instance(t) and t.type == "Var" then
@ -192,14 +192,14 @@ test:
i = i + 1 i = i + 1
elseif k == "source" then elseif k == "source" then
ret[#ret+1] = k.."= "..tostring(v):as_lua() ret[#ret+1] = k.."= "..tostring(v):as_lua()
elseif lua_type_of_1(k) == 'string' and k:match("[_a-zA-Z][_a-zA-Z0-9]*") then elseif lua_type_of(k) == 'string' and k:match("[_a-zA-Z][_a-zA-Z0-9]*") then
ret[#ret+1] = k.."= "..make_tree(v) ret[#ret+1] = k.."= "..make_tree(v)
else else
ret[#ret+1] = "["..make_tree(k).."]= "..make_tree(v) ret[#ret+1] = "["..make_tree(k).."]= "..make_tree(v)
end end
end end
return "SyntaxTree{"..table.concat(ret, ", ").."}" return "SyntaxTree{"..table.concat(ret, ", ").."}"
elseif lua_type_of_1(t) == 'number' then elseif lua_type_of(t) == 'number' then
return tostring(t) return tostring(t)
else else
return t:as_lua() return t:as_lua()
@ -226,9 +226,6 @@ test:
(%tree as lua return) compiles to (..) (%tree as lua return) compiles to (..)
Lua value "nomsu:compile(\(%tree as lua expr)):as_statements('return ')" Lua value "nomsu:compile(\(%tree as lua expr)):as_statements('return ')"
(remove action %action) compiles to (..)
Lua "\(=lua "(\(%action.stub)):as_lua_id()") = nil"
test: test:
assume ("\(\(foo \%x) as nomsu)" == "foo %x") or barf "\ assume ("\(\(foo \%x) as nomsu)" == "foo %x") or barf "\
..action source code failed." ..action source code failed."
@ -240,11 +237,11 @@ test:
externally [%var as lua identifier, %var as lua id] all mean: externally [%var as lua identifier, %var as lua id] all mean:
lua> "\ lua> "\
..if lua_type_of_1(\%var) == 'string' then return \%var:as_lua_id() ..if lua_type_of(\%var) == 'string' then return \%var:as_lua_id()
elseif SyntaxTree:is_instance(\%var, 'Var') then return \%var[1]:as_lua_id() elseif SyntaxTree:is_instance(\%var, 'Var') then return \%var[1]:as_lua_id()
elseif SyntaxTree:is_instance(\%var) then elseif SyntaxTree:is_instance(\%var) then
local lua = \(%var as lua expr) local lua = \(%var as lua expr)
if not lua:as_smext():match("^[_a-zA-Z][_a-zA-Z0-9]*$") then if not lua:text():match("^[_a-zA-Z][_a-zA-Z0-9]*$") then
nomsu:compile_error(\%var, "This is not a valid Lua identifier.") nomsu:compile_error(\%var, "This is not a valid Lua identifier.")
end end
return lua return lua

8
core/operators.nom
View File

@ -34,7 +34,7 @@ test:
lua> "\ lua> "\
..local lua = LuaCode(tree.source, \%var_lua, ' = ', \%value_lua, ';') ..local lua = LuaCode(tree.source, \%var_lua, ' = ', \%value_lua, ';')
if \%var.type == 'Var' then if \%var.type == 'Var' then
lua:add_free_vars({nomsu:compile(\%var):as_smext()}) lua:add_free_vars({nomsu:compile(\%var):text()})
end end
return lua" return lua"
@ -66,7 +66,7 @@ test:
%value as text %value as text
..) end ..) end
if \%target.type == "Var" then if \%target.type == "Var" then
lhs:add_free_vars({target_lua:as_smext()}) lhs:add_free_vars({target_lua:text()})
end end
if i > 1 then if i > 1 then
lhs:append(", ") lhs:append(", ")
@ -107,7 +107,7 @@ test:
(with external %externs %body) compiles to: (with external %externs %body) compiles to:
%body_lua = (%body as lua statements) %body_lua = (%body as lua statements)
lua> "\ lua> "\
..\%body_lua:remove_free_vars(table.map(\%externs, function(v) return nomsu:compile(v):as_smext() end))" ..\%body_lua:remove_free_vars(table.map(\%externs, function(v) return nomsu:compile(v):text() end))"
return %body_lua return %body_lua
test: test:
@ -141,7 +141,7 @@ test:
lhs:append(target_lua) lhs:append(target_lua)
rhs:append(value_lua) rhs:append(value_lua)
if \%target.type == "Var" then if \%target.type == "Var" then
vars[i] = target_lua:as_smext() vars[i] = target_lua:text()
end end
end end
\%lua:remove_free_vars(vars) \%lua:remove_free_vars(vars)

2
files.lua
View File

@ -181,6 +181,8 @@ Files.walk = function(path, flush_cache)
files = { files = {
path path
} }
elseif path:match("^[~/]") or path:match("^%./") or path:match("^%.%./") then
files = browse(path)
else else
for nomsupath in package.nomsupath:gmatch("[^;]+") do for nomsupath in package.nomsupath:gmatch("[^;]+") do
do do

2
files.moon
View File

@ -104,6 +104,8 @@ Files.walk = (path, flush_cache=false)->
local files local files
if path == 'stdin' or _SPOOFED_FILES[path] if path == 'stdin' or _SPOOFED_FILES[path]
files = {path} files = {path}
elseif path\match("^[~/]") or path\match("^%./") or path\match("^%.%./")
files = browse(path)
else else
for nomsupath in package.nomsupath\gmatch("[^;]+") for nomsupath in package.nomsupath\gmatch("[^;]+")
if files = browse(nomsupath.."/"..path) then break if files = browse(nomsupath.."/"..path) then break

10
lib/consolecolor.nom
View File

@ -14,8 +14,10 @@ test:
for %name = %colornum in %colors: for %name = %colornum in %colors:
%colornum = "\%colornum" %colornum = "\%colornum"
(=lua "COMPILE_ACTIONS").%name = (..) #(=lua "COMPILE_ACTIONS").%name = (..)
[%nomsu, %tree] -> (Lua value "'\\027[\(%colornum)m'") [%nomsu, %tree] -> (Lua value "'\\027[\(%colornum)m'")
(=lua "COMPILE_ACTIONS")."\%name 1" = (..) (=lua "COMPILE_ACTIONS")."\%name" = (..)
[%nomsu, %tree, %text] -> (..) [%nomsu, %tree, %text] ->:
Lua value "('\\027[\(%colornum)m'..\(%text as lua expr)..'\\027[0m')" if %text:
return (Lua value "('\\027[\(%colornum)m'..\(%text as lua expr)..'\\027[0m')")
..else: return (Lua value "'\\027[\(%colornum)m'")

6
lib/object.nom
View File

@ -93,13 +93,13 @@ test:
__index=\(%parent as lua expr), __index=\(%parent as lua expr),
__tostring=function(cls) return cls.name end, __tostring=function(cls) return cls.name end,
__call=function(cls, inst) __call=function(cls, inst)
inst = setmetatable(inst or {}, cls) if inst == nil then return cls end
inst = setmetatable(inst, cls)
if inst.set_up then inst:set_up() end if inst.set_up then inst:set_up() end
return inst return inst
end, end,
}) })
nomsu.environment[(class.name.." 1"):as_lua_id()] = class nomsu.environment[class.name:as_lua_id()] = class
nomsu.environment[class.name:as_lua_id()] = function() return class end
class.__index = class class.__index = class
class.class = class class.class = class
class.__tostring = function(inst) class.__tostring = function(inst)

3
nomnom/ast.nom
View File

@ -32,7 +32,7 @@ object (Syntax Tree):
return %children return %children
my action [as lua] "\ my action [as lua] "\
..a_Syntax_Tree_with_1(\(call ({} 's metatable).as_lua with [%me]))" ..a_Syntax_Tree_with(\(call ({} 's metatable).as_lua with [%me]))"
my action [as nomsu] "\ my action [as nomsu] "\
..(a Syntax Tree with \(call ({} 's metatable).as_nomsu with [%me]))" ..(a Syntax Tree with \(call ({} 's metatable).as_nomsu with [%me]))"
my action [as text] "\ my action [as text] "\
@ -86,4 +86,3 @@ object (Syntax Tree):
unless ((% is text) or (%.type == "Comment")): %args::add % unless ((% is text) or (%.type == "Comment")): %args::add %
return %args return %args
(Syntax Tree).map = (Syntax Tree).map_1

257
nomnom/code_obj.nom
View File

@ -2,103 +2,89 @@
# This file contains objects that are used to track code positions and incrementally # This file contains objects that are used to track code positions and incrementally
build up generated code, while keeping track of where it came from, and managing build up generated code, while keeping track of where it came from, and managing
indentation levels. indentation levels.
use "lib/object.nom" use "lib/things.nom"
object (Hole): a (Code Buffer) is a thing:
externally (Hole from %lua) means: that can (set up) by:
return (Hole {lua:%lua}) assume %its.source
my action [as lua]: return %me.lua %old_bits = (%its.bits if (%its.bits is a "List") else [%its.bits])
my action [as nomsu]: %its.bits = []
return "(Hole {lua:\(%me.lua)})" if (type of %its.source) is:
my action [as text]: "Text":
barf "Not implemented" %its.source = (Source from text %its.source)
my action [as smext]: "Syntax Tree":
barf "Must fill in holes before smexting" %its.source = %its.source.source
object (Code): for % in %old_bits: %its::add %
my action [set up]:
assume %me.source
%old_bits = (%me.bits if (%me.bits is a "List") else [%me.bits])
%me.bits = []
if (%me.source is text):
%me.source = (Source from text %me.source)
for % in %old_bits: %me::add %
my action [as text]: whose (text) means:
barf "Not implemented" if (%its._text == (nil)):
my action [as smext]: %buff = []
if (%me.__str == (nil)): %indent = 0
set {%buff:[], %indent:0} for %bit in %its.bits:
for %bit in %me.bits:
if (%bit is text): if (%bit is text):
%spaces = (%bit::matching "\n([ ]*)[^\n]*$") %spaces = (%bit::matching "\n([ ]*)[^\n]*$")
if %spaces: %indent = (size of %spaces.1) if %spaces: %indent = (size of %spaces.1)
..else: ..else:
%bit = (%bit::as smext) %bit = (%bit::text)
if (%indent > 0): if (%indent > 0):
%bit = (%bit::with "\n" -> "\n\(" "::* %indent)") %bit = (%bit::with "\n" -> "\n\(" "::* %indent)")
%buff::add %bit %buff::add %bit
%its._text = (%buff::joined)
return %its._text
%me.__str = (%buff::joined) whose (lua code) means "\
..a_\(%its.class.name::as lua id)_with{source=\(..)
(%its.source::as lua) if %its.source else "nil"
.., \(%its.bits::as lua)}"
return %me.__str whose (nomsu code) means "\
..(a \(%its.class.name) with {source: \((%its.source::as nomsu) if %its.source else "(nil)"), bits: \(..)
%its.bits::as nomsu
..})"
my action [as lua]: whose (size) means (size of (%its::text))
barf
return "\
..\(%me.class.name::as lua id)_from_1_2(\(..)
(%me.source::as lua) if %me.source else "nil"
.., \(%me.bits::as lua))"
my action [as nomsu] "\ that can (mark as dirty) by:
..(\(%me.class.name) \((%me.source::as nomsu) if %me.source else "(nil)") \(..) %its._text = (nil)
%me.bits::as nomsu %its._trailing_line_len = (nil)
..)" %its._num_lines = (nil)
my action [size] (size of (%me::as smext)) that can (add %new_bits) by:
my action [mark as dirty]:
%me.__str = (nil)
%me._trailing_line_len = (nil)
%me._num_lines = (nil)
my action [add %new_bits]:
unless (%new_bits is a "List"): unless (%new_bits is a "List"):
%new_bits = [%new_bits] %new_bits = [%new_bits]
for % in %new_bits: for % in %new_bits:
if (% == ""): do next % if (% == ""): do next %
#if ((% isn't text) and (% isn't a (Code))): #if ((% isn't text) and (% isn't a (Code))):
% = (%::as lua) % = (%::as lua)
%me.bits::add % %its.bits::add %
%its::mark as dirty
%me::mark as dirty whose (trailing line length) means:
if (%its._trailing_line_len == (nil)):
%its._trailing_line_len = (size of ((%its::text)::matching "[^\n]*$"))
return %its._trailing_line_len
my action [trailing line length]: whose (number of lines) means:
if (%me._trailing_line_len == (nil)): unless %its._num_lines:
%me._trailing_line_len = (size of ((%me::as smext)::matching "[^\n]*$"))
return %me._trailing_line_len
my action [number of lines]:
unless %me._num_lines:
%num_lines = 1 %num_lines = 1
for % in %me: for % in %its:
if (% is text): if (% is text):
%num_lines += (size of (%::all matches of "\n")) %num_lines += (size of (%::all matches of "\n"))
..else: ..else:
%num_lines += ((%::number of lines) - 1) %num_lines += ((%::number of lines) - 1)
%me._num_lines = %num_lines %its._num_lines = %num_lines
return %me._num_lines return %its._num_lines
my action [is multiline, is multi-line] ((%me::number of lines) > 1) whose [is multiline, is multi-line] all mean ((%its::number of lines) > 1)
my action [is one line, is single line] ((%me::number of lines) == 1) whose [is one line, is single line] all mean ((%its::number of lines) == 1)
my action [add %values joined with %joiner]: that can (add %values joined with %joiner) by:
%me::add %values joined with %joiner or %joiner %its::add %values joined with %joiner or %joiner
my action [add %values joined with %joiner or %wrapping_joiner]: that can [add %values joined with %joiner or %wrapping_joiner] by:
%line_len = 0 %line_len = 0
%bits = %me.bits %bits = %its.bits
for %value in %values at %i: for %value in %values at %i:
if (%i > 1): if (%i > 1):
if (%line_len > 80): if (%line_len > 80):
@ -108,65 +94,71 @@ object (Code):
%bits::add %value %bits::add %value
unless (%value is text): unless (%value is text):
%value = (%value::as smext) %value = (%value::text)
%line = (%value::matching "\n([^\n]*)$") %line = (%value::matching "\n([^\n]*)$")
if %line: if %line:
%line_len = (size of %line) %line_len = (size of %line)
..else: ..else:
%line_len += (size of %value) %line_len += (size of %value)
%its::mark as dirty
%me::mark as dirty that can (prepend %) by:
#if ((% isn't text) and (% isn't a %its.__type)):
my action [prepend %]:
#if ((% isn't text) and (% isn't a %me.__type)):
% = (%::as lua) % = (%::as lua)
%me.bits::add % at index 1 %its.bits::add % at index 1
%me::mark as dirty %its::mark as dirty
my action [parenthesize]: that can (parenthesize) by:
%me.bits::add "(" at index 1 %its.bits::add "(" at index 1
%me.bits::add ")" %its.bits::add ")"
%me::mark as dirty %its::mark as dirty
object (Lua Code) extends (Code): a (Lua Buffer) is a thing:
my action [add free vars %vars]: that has [..]
text, lua code, nomsu code, trailing line length, size, number of lines,
is multiline, is multi-line, is one line, is single line,
..like a (Code Buffer)
that can [..]
set up, mark as dirty, add %, prepend %, parenthesize,
add % joined with %, add % joined with % or %,
..like a (Code Buffer)
that can (add free vars %vars) by:
if ((size of %vars) == 0): return if ((size of %vars) == 0): return
%seen = (%v = (yes) for %v in %me.free_vars) %seen = (%v = (yes) for %v in %its.free_vars)
for %var in %vars: for %var in %vars:
assume (%var is text) assume (%var is text)
unless %seen.%var: unless %seen.%var:
%me.free_vars::add %var %its.free_vars::add %var
%seen.%var = (yes) %seen.%var = (yes)
%me::mark as dirty %its::mark as dirty
my action [remove free vars %vars]: that can (remove free vars %vars) by:
if ((size of %vars) == 0): return if ((size of %vars) == 0): return
%removals = {} %removals = {}
for %var in %vars: for %var in %vars:
assume (%var is text) assume (%var is text)
%removals.%var = (yes) %removals.%var = (yes)
%stack = [%me] %stack = [%its]
repeat while ((size of %stack) > 0): repeat while ((size of %stack) > 0):
%lua = (%stack::pop) %lua = (%stack::pop)
for %i in (size of %lua.free_vars) to 1 by -1: for %i in (size of %lua.free_vars) to 1 by -1:
if %removals.(%lua.free_vars.%i): if %removals.(%lua.free_vars.%i):
lua> "table.remove(\%lua.free_vars, \%i)" %lua.free_vars::remove at index %i
#TODO: reinstate this
#%lua.free_vars::remove at index %i
for % in %lua.bits: for % in %lua.bits:
unless (% is text): %stack::add % unless (% is text): %stack::add %
%me::mark as dirty %its::mark as dirty
my action [declare locals] (%me::declare locals (nil)) that can (declare locals) by (%its::declare locals (nil))
my action [declare locals %to_declare]: that can (declare locals %to_declare) by:
unless %to_declare: unless %to_declare:
set {%to_declare:[], %seen:{}} %to_declare = []
for %lua in recursive %me: %seen = {}
for %lua in recursive %its:
for %var in %lua.free_vars: for %var in %lua.free_vars:
unless %seen.%var: unless %seen.%var:
%seen.%var = (yes) %seen.%var = (yes)
@ -176,70 +168,43 @@ object (Lua Code) extends (Code):
unless (% is text): recurse %lua on % unless (% is text): recurse %lua on %
if ((size of %to_declare) > 0): if ((size of %to_declare) > 0):
%me::remove free vars %to_declare %its::remove free vars %to_declare
%me::prepend "local \(%to_declare::joined with ", ");\n" %its::prepend "local \(%to_declare::joined with ", ");\n"
return %to_declare return %to_declare
my action [as statements] (%me::as statements "" ";") whose (as statements) means (%its::as statements with "")
my action [as statements %prefix] (%me::as statements %prefix ";") whose (as statements with %prefix) means:
my action [as statements %prefix %suffix]: unless %its.is_value: return %its
unless %me.is_value: return %me %statements = (a Lua Buffer with {source:%its.source})
%statements = (Lua Code from %me.source [])
if ((%prefix or "") != ""): if ((%prefix or "") != ""):
%statements::add %prefix %statements::add %prefix
%statements::add %me %statements::add %its
if (%suffix != ""): %statements::add ";"
%statements::add (%suffix or ";")
return %statements return %statements
my action [variables]: that can (mark as value) by:
%its.is_value = (yes)
that can (mark as variable) by:
%its.is_variable = (yes)
%its.is_value = (yes)
that can (variables) by:
%vars = [] %vars = []
for %code in recursive %me: for %code in recursive %its:
if %code.is_variable: if %code.is_variable:
%vars::add (%code::as smext) %vars::add (%code::text)
for % in %code.bits: for % in %code.bits:
unless (% is text): recurse %code on % unless (% is text): recurse %code on %
return %vars return %vars
externally (Lua Code from %source %bits) means: a (Nomsu Buffer) is a thing:
assume %source that has [..]
unless (%bits is a "List"): %bits = [%bits] text, lua code, nomsu code, trailing line length, size, number of lines,
if (%source is a "Syntax Tree"): is multiline, is multi-line, is one line, is single line,
%source = %source.source ..like a (Code Buffer)
return (Lua Code {source:%source, bits:%bits, is_value:no, free_vars:[]}) that can [..]
set up, mark as dirty, add %, prepend %, parenthesize,
externally (Lua Code from %source) means (Lua Code from %source []) add % joined with %, add % joined with % or %,
externally (Lua Value from %source %bits) means: ..like a (Code Buffer)
assume %source
unless (%bits is a "List"): %bits = [%bits]
if (%source is a "Syntax Tree"):
%source = %source.source
return (Lua Code {source:%source, bits:%bits, is_value:yes, free_vars:[]})
externally (Lua Value from %source) means (Lua Value from %source [])
externally (Lua Variable from %source) means (Lua Variable from %source [])
externally (Lua Variable from %source %bits) means:
assume %source
unless (%bits is a "List"): %bits = [%bits]
if (%source is a "Syntax Tree"):
%source = %source.source
return (..)
Lua Code {..}
source:%source, bits:%bits, is_value:yes, is_variable:yes, free_vars:[]
# TODO: remove this shim
(Lua Code).add_free_vars = (Lua Code).add_free_vars_1
(Lua Code).remove_free_vars = (Lua Code).remove_free_vars_1
(Lua Code).declare_locals = (Lua Code).declare_locals_1
(Lua Code).as_statements = (Lua Code).as_statements_1_2
object (Nomsu Code) extends (Code):
externally (Nomsu Code from %source %bits) means:
if (%bits is text): %bits = [%bits]
if (%source is a "Syntax Tree"):
%source = %source.source
return (Nomsu Code {source:%source, bits:%bits})
externally (Nomsu Code from %source) means (Nomsu Code from %source [])
externally (Nomsu Code %bits) means (Nomsu Code from (nil) %bits)
externally (Nomsu Code) means (Nomsu Code from (nil) [])

49
nomnom/compile.nom
View File

@ -45,7 +45,7 @@ externally (%tree compiled with %compile_actions) means:
# TODO: restore this: # TODO: restore this:
#%args = [%tree, %compile_actions] #%args = [%tree, %compile_actions]
%args = [%nomsu, %tree] %args = [%nomsu, %tree]
for % in (%tree::get args): %args::add % for % in (%tree::arguments): %args::add %
%result = (call %compile_action with %args) %result = (call %compile_action with %args)
if (%result == (nil)): if (%result == (nil)):
report compile error at %tree "\ report compile error at %tree "\
@ -64,13 +64,13 @@ externally (%tree compiled with %compile_actions) means:
return %result return %result
%lua = (Lua Value from %tree) %lua = (a Lua Buffer with {source:%tree})
if %tree.target: if %tree.target:
# Method call # Method call
%target_lua = (%tree.target compiled with %compile_actions) %target_lua = (%tree.target compiled with %compile_actions)
if (..) if (..)
((%target_lua::as smext)::matches "^%(.*%)$") or (..) ((%target_lua::text)::matches "^%(.*%)$") or (..)
(%target_lua::as smext)::matches "^[_a-zA-Z][_a-zA-Z0-9]*$" (%target_lua::text)::matches "^[_a-zA-Z][_a-zA-Z0-9]*$"
..: ..:
%lua::add [%target_lua, ":"] %lua::add [%target_lua, ":"]
..else: ..else:
@ -93,14 +93,14 @@ externally (%tree compiled with %compile_actions) means:
if ((size of %values) == 1): if ((size of %values) == 1):
%arg_lua = %values.1 %arg_lua = %values.1
..else: ..else:
%arg_lua = (Lua Value from %tok ["("]) %arg_lua = (a Lua Buffer with {source:%tok, is_value:yes, bits:["("]})
%arg_lua::add %values joined with " and nil or " %arg_lua::add %values joined with " and nil or "
%arg_lua::add ")" %arg_lua::add ")"
..else: ..else:
%arg_lua = (Lua Value from %tok ["((function()"]) %arg_lua = (a Lua Buffer with {source:%tok, is_value:yes, bits:["((function()"]})
for %v in %values at %i: for %v in %values at %i:
if %v.is_value: if %v.is_value:
%v = (%v::as statements ("return " if (%i == (size of %values) else ""))) %v = (%v::as statements with ("return " if (%i == (size of %values) else "")))
%arg_lua::add ["\n ", %v] %arg_lua::add ["\n ", %v]
%arg_lua::add "\nend)())" %arg_lua::add "\nend)())"
@ -124,8 +124,7 @@ externally (%tree compiled with %compile_actions) means:
return %lua return %lua
"EscapedNomsu": "EscapedNomsu":
#return (Lua Value from %tree ((%tree.1)::as lua)) %lua = (a Lua Buffer with {source:%tree, is_value:yes, bits:["a_Syntax_Tree_with{type=", quote %tree.(1).type]})
%lua = (Lua Value from %tree ["a_Syntax_Tree_with_1{type=", quote %tree.(1).type])
set {%needs_comma:no, %i:1} set {%needs_comma:no, %i:1}
(% as shmua) means: (% as shmua) means:
if (% is a "Lua number"): return "\%" if (% is a "Lua number"): return "\%"
@ -152,7 +151,7 @@ externally (%tree compiled with %compile_actions) means:
return %lua return %lua
"Block": "Block":
%lua = (Lua Code from %tree) %lua = (a Lua Buffer with {source:%tree})
%lua::add (..) %lua::add (..)
((%line compiled with %compile_actions)::as statements) for %line in %tree ((%line compiled with %compile_actions)::as statements) for %line in %tree
..joined with "\n" ..joined with "\n"
@ -160,7 +159,7 @@ externally (%tree compiled with %compile_actions) means:
return %lua return %lua
"Text": "Text":
%lua = (Lua Value from %tree) %lua = (a Lua Buffer with {source:%tree})
%lua_bits = [] %lua_bits = []
%string_buffer = "" %string_buffer = ""
for % in %tree: for % in %tree:
@ -178,7 +177,7 @@ externally (%tree compiled with %compile_actions) means:
..Can't use this as a string interpolation value, since it doesn't have a value." ..Can't use this as a string interpolation value, since it doesn't have a value."
if (%.type != "Text"): if (%.type != "Text"):
%bit_lua = (Lua Value from % ["tostring(", %bit_lua, ")"]) %bit_lua = (a Lua Buffer with {source:%, is_value:yes, bits:["tostring(", %bit_lua, ")"]})
%lua_bits::add %bit_lua %lua_bits::add %bit_lua
if ((%string_buffer != "") or ((size of %lua_bits) == 0)): if ((%string_buffer != "") or ((size of %lua_bits) == 0)):
@ -188,13 +187,13 @@ externally (%tree compiled with %compile_actions) means:
return %lua return %lua
"List": "List":
%lua = (Lua Value from %tree ["List{"]) %lua = (a Lua Buffer with {source:%tree, is_value:yes, bits:["List{"]})
%lua::add ((% compiled with %compile_actions) for % in %tree) joined with ", " or ",\n " %lua::add ((% compiled with %compile_actions) for % in %tree) joined with ", " or ",\n "
%lua::add "}" %lua::add "}"
return %lua return %lua
"Dict": "Dict":
%lua = (Lua Value from %tree ["Dict{"]) %lua = (a Lua Buffer with {source:%tree, is_value:yes, bits:["Dict{"]})
%lua::add ((% compiled with %compile_actions) for % in %tree) joined with ", " or ",\n " %lua::add ((% compiled with %compile_actions) for % in %tree) joined with ", " or ",\n "
%lua::add "}" %lua::add "}"
return %lua return %lua
@ -208,24 +207,24 @@ externally (%tree compiled with %compile_actions) means:
%value_lua = (..) %value_lua = (..)
(%value compiled with %compile_actions) if %value else (..) (%value compiled with %compile_actions) if %value else (..)
Lua Value from %key ["true"] a Lua Buffer with {source:%key, is_value:yes, bits:["true"]}
unless %value_lua.is_value: unless %value_lua.is_value:
report compile error at %tree.2 "\ report compile error at %tree.2 "\
..Can't use this as a dict value, since it's not an expression." ..Can't use this as a dict value, since it's not an expression."
%key_str = ((%key_lua::as smext)::matching "^[\"']([a-zA-Z_][a-zA-Z0-9_]*)['\"]$") %key_str = ((%key_lua::text)::matching "^[\"']([a-zA-Z_][a-zA-Z0-9_]*)['\"]$")
if: if:
%key_str: %key_str:
return (Lua Code from %tree [%key_str, "=", %value_lua]) return (a Lua Buffer with {source:%tree, bits:[%key_str, "=", %value_lua]})
((%key_lua::as smext).1 == "["): ((%key_lua::text).1 == "["):
# NOTE: this *must* use a space after the [ to avoid freaking out # NOTE: this *must* use a space after the [ to avoid freaking out
Lua's parser if the inner expression is a long string. Lua Lua's parser if the inner expression is a long string. Lua
parses x[[[y]]] as x("[y]"), not as x["y"] parses x[[[y]]] as x("[y]"), not as x["y"]
return (Lua Code from %tree ["[ ", %key_lua, "]=", %value_lua]) return (a Lua Buffer with {source:%tree, bits:["[ ", %key_lua, "]=", %value_lua]})
else: else:
return (Lua Code from %tree ["[", %key_lua, "]=", %value_lua]) return (a Lua Buffer with {source:%tree, bits:["[", %key_lua, "]=", %value_lua]})
"IndexChain": "IndexChain":
%lua = (%tree.1 compiled with %compile_actions) %lua = (%tree.1 compiled with %compile_actions)
@ -233,7 +232,7 @@ externally (%tree compiled with %compile_actions) means:
report compile error at %tree.1 "\ report compile error at %tree.1 "\
..Can't index into this, since it's not an expression." ..Can't index into this, since it's not an expression."
%first_char = (%lua::as smext).1 %first_char = (%lua::text).1
if (any of [%first_char == "{", %first_char == "\"", %first_char == "["]): if (any of [%first_char == "{", %first_char == "\"", %first_char == "["]):
%lua::parenthesize %lua::parenthesize
for %i in 2 to (size of %tree): for %i in 2 to (size of %tree):
@ -243,7 +242,7 @@ externally (%tree compiled with %compile_actions) means:
report compile error at %key "\ report compile error at %key "\
..Can't use this as an index, since it's not an expression." ..Can't use this as an index, since it's not an expression."
%key_lua_str = (%key_lua::as smext) %key_lua_str = (%key_lua::text)
%lua_id = (%key_lua_str::matching "^['\"]([a-zA-Z_][a-zA-Z0-9_]*)['\"]$") %lua_id = (%key_lua_str::matching "^['\"]([a-zA-Z_][a-zA-Z0-9_]*)['\"]$")
if: if:
%lua_id: %lua_id:
@ -260,16 +259,16 @@ externally (%tree compiled with %compile_actions) means:
return %lua return %lua
"Number": "Number":
return (Lua Value from %tree ["\(%tree.1)"]) return (a Lua Buffer with {source:%tree, is_value:yes, bits:["\(%tree.1)"]})
"Var": "Var":
return (Lua Variable from %tree [%tree.1::as lua id]) return (a Lua Buffer with {source:%tree, is_value:yes, is_variable:yes, bits:[%tree.1::as lua id]})
"FileChunks": "FileChunks":
barf "\ barf "\
..Can't convert FileChunks to a single block of lua, since each chunk's compilation depends on the earlier chunks" ..Can't convert FileChunks to a single block of lua, since each chunk's compilation depends on the earlier chunks"
"Comment": "Comment":
# TODO: de-implement? # TODO: de-implement?
return (Lua Code from %tree "-- \(%tree.1::with "\n" -> "\n-- ")") return (a Lua Buffer with {source:%tree, bits:["-- \(%tree.1::with "\n" -> "\n-- ")"]})
"Error": "Error":
barf (%tree as a pretty error) barf (%tree as a pretty error)

39
nomnom/decompile.nom
View File

@ -8,7 +8,7 @@ externally (%tree decompiled inline) means:
assume (%tree is a "Syntax Tree") assume (%tree is a "Syntax Tree")
if %tree.type is: if %tree.type is:
"Action": "Action":
%nomsu = (Nomsu Code from %tree) %nomsu = (a Nomsu Buffer with {source: %tree})
if %tree.target: if %tree.target:
%target_nomsu = (%tree.target decompiled inline) %target_nomsu = (%tree.target decompiled inline)
if %tree.target.type is: if %tree.target.type is:
@ -44,17 +44,17 @@ externally (%tree decompiled inline) means:
..: ..:
%inner_nomsu::parenthesize %inner_nomsu::parenthesize
%nomsu = (Nomsu Code from %tree ["\\", %inner_nomsu]) %nomsu = (a Nomsu Buffer with {source: %tree, bits: ["\\", %inner_nomsu]})
return %nomsu return %nomsu
"Block": "Block":
%nomsu = (Nomsu Code from %tree [":"]) %nomsu = (a Nomsu Buffer with {source: %tree, bits: [":"]})
for %line in %tree at %i: for %line in %tree at %i:
%nomsu::add [" " if (%i == 1) else "; ", %line decompiled inline] %nomsu::add [" " if (%i == 1) else "; ", %line decompiled inline]
return %nomsu return %nomsu
"Text": "Text":
%nomsu = (Nomsu Code from %tree []) %nomsu = (a Nomsu Buffer with {source: %tree, bits: []})
for %text in recursive %tree: for %text in recursive %tree:
for %bit in %text at %i: for %bit in %text at %i:
if (%bit is text): %nomsu::add %bit if (%bit is text): %nomsu::add %bit
@ -78,10 +78,10 @@ externally (%tree decompiled inline) means:
else: else:
%nomsu::add ["\\(", %bit decompiled inline, ")"] %nomsu::add ["\\(", %bit decompiled inline, ")"]
return (Nomsu Code from %tree ["\"", %nomsu, "\""]) return (a Nomsu Buffer with {source: %tree, bits: ["\"", %nomsu, "\""]})
"List" "Dict": "List" "Dict":
%nomsu = (Nomsu Code from %tree ["[" if (%tree.type == "List") else "{"]) %nomsu = (a Nomsu Buffer with {source: %tree, bits: ["[" if (%tree.type == "List") else "{"]})
for %item in %tree at %i: for %item in %tree at %i:
if (%i > 1): %nomsu::add ", " if (%i > 1): %nomsu::add ", "
%nomsu::add (%item decompiled inline) %nomsu::add (%item decompiled inline)
@ -94,7 +94,7 @@ externally (%tree decompiled inline) means:
if (..) if (..)
all of [%key.type == "Text", (size of %key) == 1, %key.1 is a nomsu identifier] all of [%key.type == "Text", (size of %key) == 1, %key.1 is a nomsu identifier]
..: ..:
%nomsu = (Nomsu Code from %key [%key.1]) %nomsu = (a Nomsu Buffer with {source: %key, bits: [%key.1]})
..else: ..else:
%nomsu = (%key decompiled inline) %nomsu = (%key decompiled inline)
@ -107,7 +107,7 @@ externally (%tree decompiled inline) means:
return %nomsu return %nomsu
"IndexChain": "IndexChain":
%nomsu = (Nomsu Code from %tree) %nomsu = (a Nomsu Buffer with {source: %tree})
for %bit in %tree at %i: for %bit in %tree at %i:
if (%i > 1): %nomsu::add "." if (%i > 1): %nomsu::add "."
if (..) if (..)
@ -128,9 +128,9 @@ externally (%tree decompiled inline) means:
return %nomsu return %nomsu
"Number": "Number":
return (Nomsu Code from %tree [(%tree.1 as hex) if %tree.hex else "\(%tree.1)"]) return (a Nomsu Buffer with {source: %tree, bits: [(%tree.1 as hex) if %tree.hex else "\(%tree.1)"]})
"Var": "Var":
return (Nomsu Code from %tree ["%\(%tree.1)"]) return (a Nomsu Buffer with {source: %tree, bits: ["%\(%tree.1)"]})
"Comment": return (nil) "Comment": return (nil)
"FileChunks": "FileChunks":
barf "Can't inline a FileChunks" barf "Can't inline a FileChunks"
@ -141,7 +141,7 @@ externally (%tree decompiled inline) means:
%MAX_LINE = 90 %MAX_LINE = 90
externally (%tree decompiled) means: externally (%tree decompiled) means:
%nomsu = (Nomsu Code from %tree) %nomsu = (a Nomsu Buffer with {source: %tree})
# For concision: # For concision:
(recurse on %t) means: (recurse on %t) means:
@ -167,8 +167,7 @@ externally (%tree decompiled) means:
%indented = (%t decompiled) %indented = (%t decompiled)
if (%t.type == "Action"): if (%t.type == "Action"):
%indented = (..) %indented = (..)
Nomsu Code from %t [..] a Nomsu Buffer with {source: %t, bits: ["(..)\n ", %indented]}
"(..)\n ", %indented
return %indented return %indented
@ -253,13 +252,12 @@ externally (%tree decompiled) means:
..else: %nomsu::add "\n" ..else: %nomsu::add "\n"
return (..) return (..)
Nomsu Code from %tree [..] a Nomsu Buffer with {source: %tree, bits: [":\n ", %nomsu]}
":\n ", %nomsu
"Text": "Text":
# Multi-line text has more generous wrap margins # Multi-line text has more generous wrap margins
%max_line = ((1.5 * %MAX_LINE) rounded down) %max_line = ((1.5 * %MAX_LINE) rounded down)
%nomsu = (Nomsu Code from %tree) %nomsu = (a Nomsu Buffer with {source: %tree})
(add text from %tree) means: (add text from %tree) means:
for %bit in %tree at %i: for %bit in %tree at %i:
if (%bit is text): if (%bit is text):
@ -301,8 +299,7 @@ externally (%tree decompiled) means:
add text from %tree add text from %tree
return (..) return (..)
Nomsu Code from %tree [..] a Nomsu Buffer with {source: %tree, bits: ["\"\\\n ..", %nomsu, "\""]}
"\"\\\n ..", %nomsu, "\""
"List" "Dict": "List" "Dict":
if ((size of %tree) == 0): if ((size of %tree) == 0):
@ -321,9 +318,9 @@ externally (%tree decompiled) means:
..else: %nomsu::add ", " ..else: %nomsu::add ", "
return (..) return (..)
Nomsu Code from %tree [..] a Nomsu Buffer with {..}
"[..]\n " if (%tree.type == "List") else "{..}\n " source: %tree, bits: [..]
%nomsu "[..]\n " if (%tree.type == "List") else "{..}\n ", %nomsu
"DictEntry": "DictEntry":
set {%key:%tree.1, %value:%tree.2} set {%key:%tree.1, %value:%tree.2}

2
nomnom/parser.nom
View File

@ -32,7 +32,7 @@ set {..}
%source = (..) %source = (..)
Source {filename:%userdata.filename, start:%t.start, stop:%t.stop} Source {filename:%userdata.filename, start:%t.start, stop:%t.stop}
set {%t.start: nil, %t.stop: nil, %t.source: %source} set {%t.start: nil, %t.stop: nil, %t.source: %source}
%t = (Syntax Tree %t) %t = (a Syntax Tree with %t)
(Syntax Tree).source_code_for_tree.%t = %userdata.source (Syntax Tree).source_code_for_tree.%t = %userdata.source
return %t return %t
..with fallback %key ->: ..with fallback %key ->:

1
nomsu.moon
View File

@ -212,6 +212,7 @@ say "\
buff = table.concat(buff) buff = table.concat(buff)
-- TODO: support local variables
pseudo_filename = "user input #"..repl_line pseudo_filename = "user input #"..repl_line
Files.spoof(pseudo_filename, buff) Files.spoof(pseudo_filename, buff)
err_hand = (error_message)-> err_hand = (error_message)->

35
nomsu_compiler.lua
View File

@ -151,7 +151,7 @@ do
return false return false
end end
NomsuCompiler.environment = { NomsuCompiler.environment = {
NOMSU_COMPILER_VERSION = 10, NOMSU_COMPILER_VERSION = 11,
NOMSU_SYNTAX_VERSION = max_parser_version, NOMSU_SYNTAX_VERSION = max_parser_version,
next = next, next = next,
unpack = unpack, unpack = unpack,
@ -180,7 +180,7 @@ do
assert = assert, assert = assert,
dofile = dofile, dofile = dofile,
loadstring = loadstring, loadstring = loadstring,
lua_type_of_1 = type, lua_type_of = type,
select = select, select = select,
math = math, math = math,
io = io, io = io,
@ -406,7 +406,7 @@ do
end end
return operate_on_text(code) return operate_on_text(code)
end end
local math_expression = re.compile([[ ([+-] " ")* [0-9]+ (" " [*/^+-] (" " [+-])* " " [0-9]+)+ !. ]]) local math_expression = re.compile([[ (([*/^+-] / [0-9]+) " ")* [*/^+-] !. ]])
local compile_math_expression local compile_math_expression
compile_math_expression = function(self, tree, ...) compile_math_expression = function(self, tree, ...)
local lua = LuaCode.Value(tree.source) local lua = LuaCode.Value(tree.source)
@ -431,34 +431,36 @@ do
end end
NomsuCompiler.environment.COMPILE_ACTIONS = setmetatable({ NomsuCompiler.environment.COMPILE_ACTIONS = setmetatable({
__imported = Dict({ }), __imported = Dict({ }),
["Lua 1"] = function(self, tree, code) ["Lua"] = function(self, tree, code)
return add_lua_string_bits(self, 'statements', code) return add_lua_string_bits(self, 'statements', code)
end, end,
["Lua value 1"] = function(self, tree, code) ["Lua value"] = function(self, tree, code)
return add_lua_string_bits(self, 'value', code) return add_lua_string_bits(self, 'value', code)
end, end,
["lua > 1"] = function(self, tree, code) ["lua >"] = function(self, tree, code)
if code.type ~= "Text" then if code.type ~= "Text" then
return LuaCode(tree.source, "nomsu:run_lua(", self:compile(code), ", nomsu);") return LuaCode(tree.source, "nomsu:run_lua(", self:compile(code), ", nomsu);")
end end
return add_lua_bits(self, "statements", code) return add_lua_bits(self, "statements", code)
end, end,
["= lua 1"] = function(self, tree, code) ["= lua"] = function(self, tree, code)
if code.type ~= "Text" then if code.type ~= "Text" then
return LuaCode.Value(tree.source, "nomsu:run_lua(", self:compile(code), ":as_statements('return '), nomsu)") return LuaCode.Value(tree.source, "nomsu:run_lua(", self:compile(code), ":as_statements('return '), nomsu)")
end end
return add_lua_bits(self, "value", code) return add_lua_bits(self, "value", code)
end, end,
["use 1"] = function(self, tree, path) ["use"] = function(self, tree, path)
if path.type == 'Text' and #path == 1 and type(path[1]) == 'string' then if path.type == 'Text' and #path == 1 and type(path[1]) == 'string' then
self:import_file(path[1]) if not (self:import_file(path[1])) then
self:compile_error(tree, "Could not find anything to import for " .. tostring(path))
end
end end
return LuaCode(tree.source, "nomsu:import_file(" .. tostring(self:compile(path)) .. ")") return LuaCode(tree.source, "nomsu:import_file(" .. tostring(self:compile(path)) .. ")")
end, end,
["tests"] = function(self, tree) ["tests"] = function(self, tree)
return LuaCode.Value(tree.source, "TESTS") return LuaCode.Value(tree.source, "TESTS")
end, end,
["test 1"] = function(self, tree, body) ["test"] = function(self, tree, body)
local test_str = table.concat((function() local test_str = table.concat((function()
local _accum_0 = { } local _accum_0 = { }
local _len_0 = 1 local _len_0 = 1
@ -516,11 +518,14 @@ do
end end
end end
NomsuCompiler.import_file = function(self, path) NomsuCompiler.import_file = function(self, path)
local found = false
for _, f in Files.walk(path) do for _, f in Files.walk(path) do
if match(f, "%.lua$") or match(f, "%.nom$") or match(f, "^/dev/fd/[012]$") then if match(f, "%.lua$") or match(f, "%.nom$") or match(f, "^/dev/fd/[012]$") then
found = true
self:import(self:run_file(f)) self:import(self:run_file(f))
end end
end end
return found
end end
NomsuCompiler.run = function(self, to_run, compile_actions) NomsuCompiler.run = function(self, to_run, compile_actions)
local source = to_run.source or Source(to_run, 1, #to_run) local source = to_run.source or Source(to_run, 1, #to_run)
@ -673,7 +678,7 @@ do
local get_version = self[("Nomsu version"):as_lua_id()] local get_version = self[("Nomsu version"):as_lua_id()]
if get_version then if get_version then
do do
local upgrade = self[("1 upgraded from 2 to 3"):as_lua_id()] local upgrade = self[("1 upgraded from 2 to"):as_lua_id()]
if upgrade then if upgrade then
tree = upgrade(tree, tree.version, get_version()) tree = upgrade(tree, tree.version, get_version())
end end
@ -1273,13 +1278,13 @@ do
local should_clump local should_clump
should_clump = function(prev_line, line) should_clump = function(prev_line, line)
if prev_line.type == "Action" and line.type == "Action" then if prev_line.type == "Action" and line.type == "Action" then
if prev_line.stub == "use 1" then if prev_line.stub == "use" then
return line.stub == "use 1" return line.stub == "use"
end end
if prev_line.stub == "test 1" then if prev_line.stub == "test" then
return true return true
end end
if line.stub == "test 1" then if line.stub == "test" then
return false return false
end end
end end

32
nomsu_compiler.moon
View File

@ -93,12 +93,12 @@ with NomsuCompiler
-- Discretionary/convenience stuff -- Discretionary/convenience stuff
.environment = { .environment = {
NOMSU_COMPILER_VERSION: 10, NOMSU_SYNTAX_VERSION: max_parser_version NOMSU_COMPILER_VERSION: 11, NOMSU_SYNTAX_VERSION: max_parser_version
-- Lua stuff: -- Lua stuff:
:next, :unpack, :setmetatable, :coroutine, :rawequal, :getmetatable, :pcall, :next, :unpack, :setmetatable, :coroutine, :rawequal, :getmetatable, :pcall,
:error, :package, :os, :require, :tonumber, :tostring, :string, :xpcall, :module, :error, :package, :os, :require, :tonumber, :tostring, :string, :xpcall, :module,
:print, :loadfile, :rawset, :_VERSION, :collectgarbage, :rawget, :rawlen, :print, :loadfile, :rawset, :_VERSION, :collectgarbage, :rawget, :rawlen,
:table, :assert, :dofile, :loadstring, lua_type_of_1:type, :select, :math, :io, :load, :table, :assert, :dofile, :loadstring, lua_type_of:type, :select, :math, :io, :load,
:pairs, :ipairs, :pairs, :ipairs,
-- Nomsu types: -- Nomsu types:
_List:List, _Dict:Dict, _List:List, _Dict:Dict,
@ -225,7 +225,7 @@ with NomsuCompiler
-- This is a bit of a hack, but this code handles arbitrarily complex -- This is a bit of a hack, but this code handles arbitrarily complex
-- math expressions like 2*x + 3^2 without having to define a single -- math expressions like 2*x + 3^2 without having to define a single
-- action for every possibility. -- action for every possibility.
math_expression = re.compile [[ ([+-] " ")* [0-9]+ (" " [*/^+-] (" " [+-])* " " [0-9]+)+ !. ]] math_expression = re.compile [[ (([*/^+-] / [0-9]+) " ")* [*/^+-] !. ]]
compile_math_expression = (tree, ...)=> compile_math_expression = (tree, ...)=>
lua = LuaCode.Value(tree.source) lua = LuaCode.Value(tree.source)
for i,tok in ipairs tree for i,tok in ipairs tree
@ -242,29 +242,30 @@ with NomsuCompiler
return lua return lua
.environment.COMPILE_ACTIONS = setmetatable({ .environment.COMPILE_ACTIONS = setmetatable({
__imported: Dict{} __imported: Dict{}
["Lua 1"]: (tree, code)=> ["Lua"]: (tree, code)=>
return add_lua_string_bits(@, 'statements', code) return add_lua_string_bits(@, 'statements', code)
["Lua value 1"]: (tree, code)=> ["Lua value"]: (tree, code)=>
return add_lua_string_bits(@, 'value', code) return add_lua_string_bits(@, 'value', code)
["lua > 1"]: (tree, code)=> ["lua >"]: (tree, code)=>
if code.type != "Text" if code.type != "Text"
return LuaCode tree.source, "nomsu:run_lua(", @compile(code), ", nomsu);" return LuaCode tree.source, "nomsu:run_lua(", @compile(code), ", nomsu);"
return add_lua_bits(@, "statements", code) return add_lua_bits(@, "statements", code)
["= lua 1"]: (tree, code)=> ["= lua"]: (tree, code)=>
if code.type != "Text" if code.type != "Text"
return LuaCode.Value tree.source, "nomsu:run_lua(", @compile(code), ":as_statements('return '), nomsu)" return LuaCode.Value tree.source, "nomsu:run_lua(", @compile(code), ":as_statements('return '), nomsu)"
return add_lua_bits(@, "value", code) return add_lua_bits(@, "value", code)
["use 1"]: (tree, path)=> ["use"]: (tree, path)=>
if path.type == 'Text' and #path == 1 and type(path[1]) == 'string' if path.type == 'Text' and #path == 1 and type(path[1]) == 'string'
@import_file(path[1]) unless @import_file(path[1])
@compile_error tree, "Could not find anything to import for #{path}"
return LuaCode(tree.source, "nomsu:import_file(#{@compile(path)})") return LuaCode(tree.source, "nomsu:import_file(#{@compile(path)})")
["tests"]: (tree)=> LuaCode.Value(tree.source, "TESTS") ["tests"]: (tree)=> LuaCode.Value(tree.source, "TESTS")
["test 1"]: (tree, body)=> ["test"]: (tree, body)=>
test_str = table.concat [tostring(@tree_to_nomsu(line)) for line in *body], "\n" test_str = table.concat [tostring(@tree_to_nomsu(line)) for line in *body], "\n"
LuaCode tree.source, "TESTS[#{tostring(tree.source)\as_lua!}] = ", test_str\as_lua! LuaCode tree.source, "TESTS[#{tostring(tree.source)\as_lua!}] = ", test_str\as_lua!
@ -290,9 +291,12 @@ with NomsuCompiler
@environment.COMPILE_ACTIONS.__imported[k] or= v @environment.COMPILE_ACTIONS.__imported[k] or= v
.import_file = (path)=> .import_file = (path)=>
found = false
for _,f in Files.walk(path) for _,f in Files.walk(path)
if match(f, "%.lua$") or match(f, "%.nom$") or match(f, "^/dev/fd/[012]$") if match(f, "%.lua$") or match(f, "%.nom$") or match(f, "^/dev/fd/[012]$")
found = true
@import(@run_file(f)) @import(@run_file(f))
return found
.run = (to_run, compile_actions)=> .run = (to_run, compile_actions)=>
source = to_run.source or Source(to_run, 1, #to_run) source = to_run.source or Source(to_run, 1, #to_run)
@ -394,7 +398,7 @@ with NomsuCompiler
compile_actions or= @environment.COMPILE_ACTIONS compile_actions or= @environment.COMPILE_ACTIONS
if tree.version if tree.version
if get_version = @[("Nomsu version")\as_lua_id!] if get_version = @[("Nomsu version")\as_lua_id!]
if upgrade = @[("1 upgraded from 2 to 3")\as_lua_id!] if upgrade = @[("1 upgraded from 2 to")\as_lua_id!]
tree = upgrade(tree, tree.version, get_version!) tree = upgrade(tree, tree.version, get_version!)
switch tree.type switch tree.type
when "Action" when "Action"
@ -787,9 +791,9 @@ with NomsuCompiler
nomsu = NomsuCode(tree.source, pop_comments(tree.source.start)) nomsu = NomsuCode(tree.source, pop_comments(tree.source.start))
should_clump = (prev_line, line)-> should_clump = (prev_line, line)->
if prev_line.type == "Action" and line.type == "Action" if prev_line.type == "Action" and line.type == "Action"
if prev_line.stub == "use 1" then return line.stub == "use 1" if prev_line.stub == "use" then return line.stub == "use"
if prev_line.stub == "test 1" then return true if prev_line.stub == "test" then return true
if line.stub == "test 1" then return false if line.stub == "test" then return false
return not recurse(prev_line)\is_multiline! return not recurse(prev_line)\is_multiline!
for chunk_no, chunk in ipairs tree for chunk_no, chunk in ipairs tree
nomsu\append "\n\n#{("~")\rep(80)}\n\n" if chunk_no > 1 nomsu\append "\n\n#{("~")\rep(80)}\n\n" if chunk_no > 1

17
string2.lua
View File

@ -78,6 +78,9 @@ local string2 = {
end end
return _accum_0 return _accum_0
end, end,
starts_with = function(self, s)
return sub(self, 1, #s) == s
end,
lines = function(self) lines = function(self)
local _accum_0 = { } local _accum_0 = { }
local _len_0 = 1 local _len_0 = 1
@ -114,10 +117,10 @@ local string2 = {
for _index_0 = 1, #_list_0 do for _index_0 = 1, #_list_0 do
local line = _list_0[_index_0] local line = _list_0[_index_0]
while #line > maxlen do while #line > maxlen do
local chunk = line:sub(1, maxlen) local chunk = sub(line, 1, maxlen)
local split = chunk:find(' ', maxlen - buffer, true) or maxlen local split = find(chunk, ' ', maxlen - buffer, true) or maxlen
chunk = line:sub(1, split) chunk = sub(line, 1, split)
line = line:sub(split + 1, -1) line = sub(line, split + 1, -1)
lines[#lines + 1] = chunk lines[#lines + 1] = chunk
end end
lines[#lines + 1] = line lines[#lines + 1] = line
@ -151,14 +154,14 @@ local string2 = {
return format("x%02X", byte(c)) return format("x%02X", byte(c))
end end
end) end)
if not (is_lua_id(str:match("^_*(.*)$"))) then if not (is_lua_id(match(str, "^_*(.*)$"))) then
str = "_" .. str str = "_" .. str
end end
return str return str
end, end,
from_lua_id = function(str) from_lua_id = function(str)
if not (is_lua_id(str:match("^_*(.*)$"))) then if not (is_lua_id(match(str, "^_*(.*)$"))) then
str = str:sub(2, -1) str = sub(str, 2, -1)
end end
str = gsub(str, "_", " ") str = gsub(str, "_", " ")
str = gsub(str, "x([0-9A-F][0-9A-F])", function(hex) str = gsub(str, "x([0-9A-F][0-9A-F])", function(hex)

15
string2.moon
View File

@ -26,6 +26,7 @@ string2 = {
capitalized: => gsub(@, '%l', upper, 1) capitalized: => gsub(@, '%l', upper, 1)
byte: byte, bytes: (i, j)=> {byte(@, i or 1, j or -1)} byte: byte, bytes: (i, j)=> {byte(@, i or 1, j or -1)}
split: (sep)=> [chunk for i,chunk in isplit(@, sep)] split: (sep)=> [chunk for i,chunk in isplit(@, sep)]
starts_with: (s)=> sub(@, 1, #s) == s
lines: => [line for i,line in isplit(@, '\n')] lines: => [line for i,line in isplit(@, '\n')]
line: (line_num)=> line: (line_num)=>
for i, line, start in isplit(@, '\n') for i, line, start in isplit(@, '\n')
@ -41,10 +42,10 @@ string2 = {
lines = {} lines = {}
for line in *@lines! for line in *@lines!
while #line > maxlen while #line > maxlen
chunk = line\sub(1, maxlen) chunk = sub(line, 1, maxlen)
split = chunk\find(' ', maxlen-buffer, true) or maxlen split = find(chunk, ' ', maxlen-buffer, true) or maxlen
chunk = line\sub(1, split) chunk = sub(line, 1, split)
line = line\sub(split+1, -1) line = sub(line, split+1, -1)
lines[#lines+1] = chunk lines[#lines+1] = chunk
lines[#lines+1] = line lines[#lines+1] = line
return table.concat(lines, "\n") return table.concat(lines, "\n")
@ -77,15 +78,15 @@ string2 = {
if c == ' ' then '_' if c == ' ' then '_'
else format("x%02X", byte(c)) else format("x%02X", byte(c))
unless is_lua_id(str\match("^_*(.*)$")) unless is_lua_id(match(str, "^_*(.*)$"))
str = "_"..str str = "_"..str
return str return str
-- from_lua_id(as_lua_id(str)) == str, but behavior is unspecified for inputs that -- from_lua_id(as_lua_id(str)) == str, but behavior is unspecified for inputs that
-- did not come from as_lua_id() -- did not come from as_lua_id()
from_lua_id: (str)-> from_lua_id: (str)->
unless is_lua_id(str\match("^_*(.*)$")) unless is_lua_id(match(str, "^_*(.*)$"))
str = str\sub(2,-1) str = sub(str,2,-1)
str = gsub(str, "_", " ") str = gsub(str, "_", " ")
str = gsub(str, "x([0-9A-F][0-9A-F])", (hex)-> char(tonumber(hex, 16))) str = gsub(str, "x([0-9A-F][0-9A-F])", (hex)-> char(tonumber(hex, 16)))
return str return str

5
syntax_tree.lua
View File

@ -160,10 +160,13 @@ do
if type(a) == 'string' then if type(a) == 'string' then
stub_bits[#stub_bits + 1] = a stub_bits[#stub_bits + 1] = a
else else
stub_bits[#stub_bits + 1] = tostring(arg_i) stub_bits[#stub_bits + 1] = arg_i
arg_i = arg_i + 1 arg_i = arg_i + 1
end end
end end
while type(stub_bits[#stub_bits]) == 'number' do
stub_bits[#stub_bits] = nil
end
return concat(stub_bits, " ") return concat(stub_bits, " ")
end end
} }

4
syntax_tree.moon
View File

@ -80,8 +80,10 @@ class SyntaxTree
if type(a) == 'string' if type(a) == 'string'
stub_bits[#stub_bits+1] = a stub_bits[#stub_bits+1] = a
else else
stub_bits[#stub_bits+1] = tostring(arg_i) stub_bits[#stub_bits+1] = arg_i
arg_i += 1 arg_i += 1
while type(stub_bits[#stub_bits]) == 'number'
stub_bits[#stub_bits] = nil
return concat stub_bits, " " return concat stub_bits, " "
@is_instance: (t)=> @is_instance: (t)=>

7
tools/find_action.nom
View File

@ -14,7 +14,12 @@ for %path in %files:
for file %filename in %path: for file %filename in %path:
unless (%filename::matches "%.nom$") (do next %filename) unless (%filename::matches "%.nom$") (do next %filename)
%file = (read file %filename) %file = (read file %filename)
%tree = (parse %file from %filename) try:
%tree = (parse %file from %filename)
..and if it barfs:
say (red "\%filename failed to parse")
%tree = (nil)
unless %tree: do next %filename
%results = [] %results = []
for %t in recursive %tree: for %t in recursive %tree:
if (%t is "Action" syntax tree): if (%t is "Action" syntax tree):