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

Removed the mandatory "_" prefix for Nomsu variables, renamed "list" and

Browse Source 
"dict" to "List" and "Dict", or in Nomsu's environment, "_List" and
"_Dict", removed uuid.lua and replaced it with core/id.nom for handling
IDs.
This commit is contained in:
Bruce Hill 2018-09-06 12:46:39 -07:00
parent e1bc075bb5
commit a35d010dfe
18 changed files with 199 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -13,7 +13,7 @@ UNINSTALL_VERSION=
MOON_FILES= code_obj.moon error_handling.moon files.moon nomsu.moon nomsu_compiler.moon \
syntax_tree.moon parser.moon containers.moon bitops.moon
LUA_FILES= code_obj.lua consolecolors.lua error_handling.lua files.lua nomsu.lua nomsu_compiler.lua \
syntax_tree.lua parser.lua containers.lua bitops.lua utils.lua uuid.lua
syntax_tree.lua parser.lua containers.lua bitops.lua utils.lua
CORE_NOM_FILES= $(wildcard core/*.nom)
CORE_LUA_FILES= $(patsubst %.nom,%.lua,$(CORE_NOM_FILES))
LIB_NOM_FILES= $(wildcard lib/*.nom)

1
README.md
View File

@ -53,7 +53,6 @@ All `.moon` files have been precompiled into corresponding `.lua` files, so you
* [code\_obj.moon](code_obj.moon) - Datastructures used for incrementally building generated code, while preserving code origins.
* [error\_handling.moon](error_handling.moon) - The logic for producing good error messages within Lua that reference the Nomsu source code that led to them.
* [utils.lua](utils.lua) - A set of utility actions used by nomsu.moon.
* [uuid.lua](uuid.lua) - A simple Universally Unique Identifier implementation (RFC 4122) used internally to give each object a randomized unique ID.
* [consolecolors.lua](consolecolors.lua) - Lua module that defines ANSI color codes for colored console output (used internally in nomsu.moon).
* [examples/how\_do\_i.nom](examples/how_do_i.nom) - A simple walkthrough of some of the features of Nomsu, written in Nomsu code. **This is a good place to start.**
* [core/\*.nom](core) - Core language definitions of stuff like control flow, operators, and metaprogramming, broken down into different files.

26
containers.lua
View File

@ -8,7 +8,7 @@ do
local _obj_0 = require('utils')
repr, stringify, equivalent, nth_to_last, size = _obj_0.repr, _obj_0.stringify, _obj_0.equivalent, _obj_0.nth_to_last, _obj_0.size
end
local list, dict
local List, Dict
local _list_mt = {
__eq = equivalent,
__tostring = function(self)
@ -54,7 +54,7 @@ local _list_mt = {
return true
end,
__add = function(self, other)
local ret = list((function()
local ret = List((function()
local _accum_0 = { }
local _len_0 = 1
for _index_0 = 1, #self do
@ -113,7 +113,7 @@ local _list_mt = {
return rawset(self, k, v)
end
}
list = function(t)
List = function(t)
return setmetatable(t, _list_mt)
end
local walk_items
@ -122,7 +122,7 @@ walk_items = function(self, i)
local k, v = next(self.table, self.key)
if k ~= nil then
self.key = k
return i, dict({
return i, Dict({
key = k,
value = v
})
@ -149,7 +149,7 @@ local _dict_mt = {
}, 0
end,
__band = function(self, other)
return dict((function()
return Dict((function()
local _tbl_0 = { }
for k, v in pairs(self) do
if other[k] ~= nil then
@ -173,7 +173,7 @@ local _dict_mt = {
ret[k] = v
end
end
return dict(ret)
return Dict(ret)
end,
__bxor = function(self, other)
local ret
@ -191,7 +191,7 @@ local _dict_mt = {
ret[k] = nil
end
end
return dict(ret)
return Dict(ret)
end,
__add = function(self, other)
local ret
@ -209,7 +209,7 @@ local _dict_mt = {
ret[k] = ret[k] + v
end
end
return dict(ret)
return Dict(ret)
end,
__sub = function(self, other)
local ret
@ -227,18 +227,18 @@ local _dict_mt = {
ret[k] = ret[k] - v
end
end
return dict(ret)
return Dict(ret)
end
}
dict = function(t)
Dict = function(t)
return setmetatable(t, _dict_mt)
end
for i, entry in ipairs(dict({
for i, entry in ipairs(Dict({
x = 99
})) do
assert(i == 1 and entry.key == "x" and entry.value == 99, "ipairs compatibility issue")
end
return {
list = list,
dict = dict
List = List,
Dict = Dict
}

25
containers.moon
View File

@ -1,8 +1,9 @@
-- This file contains container classes, i.e. Lists, Dicts, and Sets
{:insert,:remove,:concat} = table
{:repr, :stringify, :equivalent, :nth_to_last, :size} = require 'utils'
local list, dict
local List, Dict
-- List and Dict classes to provide basic equality/tostring functionality for the tables
-- used in Nomsu. This way, they retain a notion of whether they were originally lists or dicts.
@ -28,7 +29,7 @@ _list_mt =
elseif @[i] > other[i] then return false
return true
__add: (other)=>
ret = list[x for x in *@]
ret = List[x for x in *@]
for x in *other
insert(ret, x)
return ret
@ -55,14 +56,14 @@ _list_mt =
assert type(k) == 'number', "List indices must be numbers"
rawset(@, k, v)
list = (t)-> setmetatable(t, _list_mt)
List = (t)-> setmetatable(t, _list_mt)
walk_items = (i)=>
i = i + 1
k, v = next(@table, @key)
if k != nil
@key = k
return i, dict{key:k, value:v}
return i, Dict{key:k, value:v}
_dict_mt =
__eq:equivalent
@ -71,33 +72,33 @@ _dict_mt =
"{"..concat(["#{repr(k)}: #{repr(v)}" for k,v in pairs @], ", ").."}"
__ipairs: => walk_items, {table:@, key:nil}, 0
__band: (other)=>
dict{k,v for k,v in pairs(@) when other[k] != nil}
Dict{k,v for k,v in pairs(@) when other[k] != nil}
__bor: (other)=>
ret = {k,v for k,v in pairs(@)}
for k,v in pairs(other)
if ret[k] == nil then ret[k] = v
return dict(ret)
return Dict(ret)
__bxor: (other)=>
ret = {k,v for k,v in pairs(@)}
for k,v in pairs(other)
if ret[k] == nil then ret[k] = v
else ret[k] = nil
return dict(ret)
return Dict(ret)
__add: (other)=>
ret = {k,v for k,v in pairs(@)}
for k,v in pairs(other)
if ret[k] == nil then ret[k] = v
else ret[k] += v
return dict(ret)
return Dict(ret)
__sub: (other)=>
ret = {k,v for k,v in pairs(@)}
for k,v in pairs(other)
if ret[k] == nil then ret[k] = -v
else ret[k] -= v
return dict(ret)
dict = (t)-> setmetatable(t, _dict_mt)
return Dict(ret)
Dict = (t)-> setmetatable(t, _dict_mt)
for i,entry in ipairs(dict({x:99}))
for i,entry in ipairs(Dict({x:99}))
assert(i == 1 and entry.key == "x" and entry.value == 99, "ipairs compatibility issue")
return {:list, :dict}
return {:List, :Dict}

34
core/control_flow.nom
View File

@ -139,9 +139,10 @@ test:
repeat 10 times: %x += 1
assume (%x == 10)
compile [repeat %n times %body] to:
define mangler
%lua = (..)
Lua ".."
for i=1,\(%n as lua expr) do
for \(mangle "i")=1,\(%n as lua expr) do
\(%body as lua statements)
if (%body has subtree \(do next)):
@ -242,9 +243,10 @@ compile [for %var in %iterable %body] to:
# This uses Lua's approach of only allowing loop-scoped variables in a loop
unless (%var.type is "Var"):
compile error at %var.source "Loop expected variable, not: %s"
define mangler
%lua = (..)
Lua ".."
for i,\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
for \(mangle "i"),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
\(%body as lua statements)
if (%body has subtree \(do next)):
@ -391,6 +393,7 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
%code = (Lua "")
%clause = "if"
%else_allowed = (yes)
define mangler
unless (%body.type is "Block"):
compile error at %body.source "'if' expected a Block, but got: %s"
for %line in %body:
@ -426,7 +429,7 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
if (%i > 1):
%code::append " or "
%code::append "branch_value == \(%line.%i as lua expr)"
%code::append "\(mangle "branch value") == \(%line.%i as lua expr)"
%code::append ".."
then
@ -440,7 +443,7 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
return (..)
Lua ".."
do --if % is
local branch_value = \(%branch_value as lua expr)
local \(mangle "branch value") = \(%branch_value as lua expr)
\%code
end --if % is
@ -461,17 +464,19 @@ test:
..and if it barfs: do nothing
assume (%d.x == "good")
compile [do %action then always %final_action] to (..)
compile [do %action then always %final_action] to:
define mangler
return (..)
Lua ".."
do
local fell_through = false
local ok, ret = pcall(function()
local \(mangle "fell_through") = false
local \(mangle "ok"), \(mangle "ret") = pcall(function()
\(%action as lua statements)
fell_through = true
\(mangle "fell_through") = true
end)
\(%final_action as lua statements)
if not ok then error(ret, 0) end
if not fell_through then return ret end
if not \(mangle "ok") then error(ret, 0) end
if not \(mangle "fell_through") then return ret end
end
test:
@ -493,14 +498,15 @@ test:
# Recurion control flow
compile [for %var in recursive %structure %body] to (..)
with local compile actions:
define mangler
compile [recurse %v on %x] to (..)
Lua "table.insert(stack\(%v as lua id), \(%x as lua expr))"
Lua "table.insert(\(mangle "stack \(%v.1)"), \(%x as lua expr))"
%lua = (..)
Lua ".."
do
local stack\(%var as lua id) = list{\(%structure as lua expr)}
while #stack\(%var as lua id) > 0 do
\(%var as lua expr) = table.remove(stack\(%var as lua id), 1)
local \(mangle "stack \(%var.1)") = _List{\(%structure as lua expr)}
while #\(mangle "stack \(%var.1)") > 0 do
\(%var as lua expr) = table.remove(\(mangle "stack \(%var.1)"), 1)
\(%body as lua statements)
if (%body has subtree \(do next)):

56
core/id.nom Normal file
View File

@ -0,0 +1,56 @@
#!/usr/bin/env nomsu -V3.7.5.6
#
A simple UUID function based on RFC 4122: http://www.ietf.org/rfc/rfc4122.txt
use "core/metaprogramming.nom"
use "core/math.nom"
use "core/collections.nom"
use "core/control_flow.nom"
%NaN_surrogate = {}
%nil_surrogate = {}
%obj_by_id = {}
set %obj_by_id's metatable to {__mode: "v"}
%id_by_obj = {}
set %id_by_obj's metatable to {..}
__mode: "k"
__index: (..)
[%self, %key] ->:
if (%key == (nil)): return %self.%nil_surrogate
if (%key != %key): return %self.%NaN_surrogate
--- %retry ---
%id = (uuid)
if (%obj_by_id.%id != (nil)): go to %retry
%self.%key = %id
%obj_by_id.%id = %key
return %id
local action [uuid]:
# Set all the other bits to randomly (or pseudo-randomly) chosen values.
%bytes = [..]
randint (2^(4*8)), # time-low
randint (2^(2*8)), # time-mid
randint (2^(2*8 - 4)), # time-high-and-version
randint (2^(1*8 - 2)), # clock-seq-and-reserved
randint (2^(1*8)), # clock-seq-low
randint (2^(3*8)), randint (2^(3*8)), # node
# Set the four most significant bits (bits 12 through 15) of the
# time_hi_and_version field to the 4-bit version number from
# Section 4.1.3.
%bytes.3 += 0x4000
# Set the two most significant bits (bits 6 and 7) of the
# clock_seq_hi_and_reserved to zero and one, respectively.
%bytes.4 += 0xC0
return (=lua "('%08x-%04x-%04x-%02x%02x-%6x%6x'):format(unpack(\%bytes))")
# For strict identity checking, use (%x's id) == (%y's id)
test:
assume (([] == []) and ((id of []) != (id of [])))
seed random with 0
%x = []
assume ((id of %x) == (id of %x))
seed random with 0
assume ((id of %x) != (id of []))
seed random
action [id of %, %'s id, %' id] %id_by_obj.%

29
core/metaprogramming.nom
View File

@ -4,6 +4,20 @@
functions to make that easier.
lua> "NOMSU_CORE_VERSION = 7"
lua> ".."
do
local mangle_index = 0
function mangler()
local my_mangle_index = mangle_index
mangle_index = mangle_index + 1
return function(varname)
return string.as_lua_id(varname..(("\\3%X"):format(my_mangle_index)))
end
end
end
COMPILE_ACTIONS["define mangler"] = function(nomsu, tree)
return LuaCode(tree.source, "local mangle_1 = mangler()")
end
lua> ".."
COMPILE_ACTIONS["1 -> 2"] = function(nomsu, tree, \%args, \%body)
local lua = LuaCode.Value(tree.source, "(function(")
@ -34,7 +48,7 @@ test:
compile [five] to (Lua value "5")
test:
assume ((five) == 5) or barf "Compile to expression failed."
compile [loc x] to (Lua "local _x = 99;")
compile [loc x] to (Lua "local x = 99;")
test:
lua> "do"
loc x
@ -158,7 +172,7 @@ compile [parse %actions as %body] to (..)
if replacements[t[1]] then
return replacements[t[1]]
else
return t.type.."{"..repr(t[1].." \\0").."..('%X'):format(__MANGLE_INDEX), source="..repr(tostring(t.source)).."}"
return t.type.."{mangle("..repr(t[1]).."), source="..repr(tostring(t.source)).."}"
end
elseif AST.is_syntax_tree(t) then
local ret = {}
@ -181,7 +195,7 @@ compile [parse %actions as %body] to (..)
end
end
local \%new_body = LuaCode(\%body.source,
"__MANGLE_INDEX = (__MANGLE_INDEX or 0) + 1",
"local mangle = mangler()",
"\\nlocal tree = ", make_tree(\%body),
"\\nlocal lua = nomsu:compile(tree)",
"\\nreturn lua")
@ -223,8 +237,9 @@ compile [%tree as inline nomsu] to (..)
action [%var as lua identifier, %var as lua id] (..)
lua> ".."
if type(\%var) == 'string' then return string.as_lua_id(\%var)
elseif \%var.type == 'Var' then return "_"..string.as_lua_id(\%var[1])
elseif \%var.type == 'Action' then return string.as_lua_id(\%var.stub)
elseif AST.is_syntax_tree(\%var, 'Var') then return string.as_lua_id(\%var[1])
elseif AST.is_syntax_tree(\%var, 'Action') then return string.as_lua_id(\%var.stub)
else error("Unknown type: "..tostring(\%var))
end
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -266,10 +281,10 @@ compile [%tree has subtree %match_tree] to (..)
action [match %tree with %patt]:
lua> ".."
if \%patt.type == "Var" then return dict{[\%patt[1]]=\%tree} end
if \%patt.type == "Var" then return _Dict{[\%patt[1]]=\%tree} end
if \%patt.type == "Action" and \%patt.stub ~= \%tree.stub then return nil end
if #\%patt ~= #\%tree then return nil end
local matches = dict{}
local matches = _Dict{}
for \%i=1,#\%patt do
if AST.is_syntax_tree(\%tree[\%i]) then
local submatch = \(match %tree.%i with %patt.%i)

22
core/operators.nom
View File

@ -19,28 +19,6 @@ compile [%a is %b, %a == %b] to (..)
compile [%a isn't %b, %a is not %b, %a not= %b, %a != %b] to (..)
Lua value "(\(%a as lua expr) ~= \(%b as lua expr))"
# For strict identity checking, use (%x's id) is (%y's id)
test:
assume (([] == []) and (([] 's id) != ([] 's id)))
lua> ".."
do
local new_uuid = require('uuid')
local NaN_surrogate = {}
local nil_surrogate = {}
IDS = setmetatable({}, {
__mode = "k",
__index = function(self, key)
if key == nil then return self[nil_surrogate]
elseif key ~= key then return self[NaN_surrogate] end
local id = new_uuid()
self[key] = id
return id
end
})
end
compile [% 's id, id of %] to (Lua value "IDS[\(% as lua expr)]")
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test:

6
core/text.nom
View File

@ -47,7 +47,7 @@ compile [byte %i of %text] to (..)
compile [bytes %start to %stop of %text] to (..)
Lua value ".."
list{(\(%text as lua expr)):byte(\(%start as lua expr), \(%stop as lua expr))}
_List{(\(%text as lua expr)):byte(\(%start as lua expr), \(%stop as lua expr))}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -82,7 +82,7 @@ test:
..== ["one", "two"]
action [lines in %text, lines of %text] (..)
lua> ".."
local result = list{}
local result = _List{}
for line in (\%text):gmatch('[^\\n]+') do
result[#result+1] = line
end
@ -99,7 +99,7 @@ compile [for %match in %text matching %patt %body] to (..)
compile [%expr for %match in %text matching %patt] to (..)
Lua value ".."
(function()
local ret = list{}
local ret = _List{}
for \(%match as lua expr) in (\(%text as lua expr)):gmatch(\(..)
%patt as lua expr
..) do

2
lib/object.nom
View File

@ -90,7 +90,7 @@ compile [object %classname extends %parent %class_body] to:
class.__index = class
class.class = class
class.__tostring = function(inst)
return inst.name..getmetatable(dict{}).__tostring(inst)
return inst.name..getmetatable(_Dict{}).__tostring(inst)
end
\(%class_body as lua statements)

2
lib/os.nom
View File

@ -32,7 +32,7 @@ compile [for file %f in %path %body] to (..)
compile [%expr for file %f in %path] to (..)
Lua value ".."
(function()
local ret = list{}
local ret = _List{}
for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
ret[#ret+1] = \(%expr as lua statements)
end

2
nomsu.lua
View File

@ -138,7 +138,7 @@ if not args or args.help then
os.exit(EXIT_FAILURE)
end
local nomsu = NomsuCompiler
nomsu.arg = NomsuCompiler.list(args.nomsu_args)
nomsu.arg = NomsuCompiler._List(args.nomsu_args)
if args.version then
nomsu:run([[use "core"
say (Nomsu version)]])

2
nomsu.moon
View File

@ -88,7 +88,7 @@ if not args or args.help
os.exit(EXIT_FAILURE)
nomsu = NomsuCompiler
nomsu.arg = NomsuCompiler.list(args.nomsu_args)
nomsu.arg = NomsuCompiler._List(args.nomsu_args)
if args.version
nomsu\run [[

61
nomsu_compiler.lua
View File

@ -4,10 +4,10 @@ local utils = require('utils')
local Files = require('files')
local repr, stringify, equivalent
repr, stringify, equivalent = utils.repr, utils.stringify, utils.equivalent
local list, dict
local List, Dict
do
local _obj_0 = require('containers')
list, dict = _obj_0.list, _obj_0.dict
List, Dict = _obj_0.List, _obj_0.Dict
end
colors = require('consolecolors')
colored = setmetatable({ }, {
@ -37,7 +37,7 @@ local AST = require("syntax_tree")
local Parser = require("parser")
SOURCE_MAP = { }
string.as_lua_id = function(str)
str = gsub(str, "^\0*$", "%1\0")
str = gsub(str, "^\3*$", "%1\3")
str = gsub(str, "x([0-9A-F][0-9A-F])", "x78%1")
str = gsub(str, "%W", function(c)
if c == ' ' then
@ -110,7 +110,7 @@ local NomsuCompiler = setmetatable({
end
})
do
NomsuCompiler.NOMSU_COMPILER_VERSION = 6
NomsuCompiler.NOMSU_COMPILER_VERSION = 7
NomsuCompiler.NOMSU_SYNTAX_VERSION = Parser.version
NomsuCompiler.nomsu = NomsuCompiler
NomsuCompiler.parse = function(self, ...)
@ -160,8 +160,8 @@ do
load = load,
pairs = pairs,
ipairs = ipairs,
list = list,
dict = dict
_List = List,
_Dict = Dict
}
if _VERSION == "Lua 5.4" then
to_add.ipairs = function(x)
@ -286,42 +286,41 @@ do
end
return lua
end,
["Lua 1"] = function(self, tree, _code)
return add_lua_string_bits(self, 'statements', _code)
["Lua 1"] = function(self, tree, code)
return add_lua_string_bits(self, 'statements', code)
end,
["Lua value 1"] = function(self, tree, _code)
return add_lua_string_bits(self, 'value', _code)
["Lua value 1"] = function(self, tree, code)
return add_lua_string_bits(self, 'value', code)
end,
["lua > 1"] = function(self, tree, _code)
if _code.type ~= "Text" then
return LuaCode(tree.source, "nomsu:run_lua(", self:compile(_code), ");")
["lua > 1"] = function(self, tree, code)
if code.type ~= "Text" then
return LuaCode(tree.source, "nomsu:run_lua(", self:compile(code), ");")
end
return add_lua_bits(self, "statements", _code)
return add_lua_bits(self, "statements", code)
end,
["= lua 1"] = function(self, tree, _code)
if _code.type ~= "Text" then
return LuaCode.Value(tree.source, "nomsu:run_lua(", self:compile(_code), ":as_statements('return '))")
["= lua 1"] = function(self, tree, code)
if code.type ~= "Text" then
return LuaCode.Value(tree.source, "nomsu:run_lua(", self:compile(code), ":as_statements('return '))")
end
return add_lua_bits(self, "value", _code)
return add_lua_bits(self, "value", code)
end,
["use 1"] = function(self, tree, _path)
if _path.type == 'Text' and #_path == 1 and type(_path[1]) == 'string' then
local path = _path[1]
for _, f in Files.walk(path) do
["use 1"] = function(self, tree, path)
if path.type == 'Text' and #path == 1 and type(path[1]) == 'string' then
for _, f in Files.walk(path[1]) do
self:run_file(f)
end
end
return LuaCode(tree.source, "for i,f in Files.walk(", self:compile(_path), ") do nomsu:run_file(f) end")
return LuaCode(tree.source, "for i,f in Files.walk(", self:compile(path), ") do nomsu:run_file(f) end")
end,
["tests"] = function(self, tree)
return LuaCode.Value(tree.source, "TESTS")
end,
["test 1"] = function(self, tree, _body)
["test 1"] = function(self, tree, body)
local test_str = table.concat((function()
local _accum_0 = { }
local _len_0 = 1
for _index_0 = 1, #_body do
local line = _body[_index_0]
for _index_0 = 1, #body do
local line = body[_index_0]
_accum_0[_len_0] = tostring(self:tree_to_nomsu(line))
_len_0 = _len_0 + 1
end
@ -329,10 +328,10 @@ do
end)(), "\n")
return LuaCode(tree.source, "TESTS[" .. tostring(repr(tostring(tree.source))) .. "] = ", repr(test_str))
end,
["is jit"] = function(self, tree, _code)
["is jit"] = function(self, tree, code)
return LuaCode.Value(tree.source, jit and "true" or "false")
end,
["Lua version"] = function(self, tree, _code)
["Lua version"] = function(self, tree, code)
return LuaCode.Value(tree.source, repr(_VERSION))
end
}, {
@ -646,7 +645,7 @@ do
end
return lua
elseif "List" == _exp_0 then
local lua = LuaCode.Value(tree.source, "list{")
local lua = LuaCode.Value(tree.source, "_List{")
lua:concat_append((function()
local _accum_0 = { }
local _len_0 = 1
@ -660,7 +659,7 @@ do
lua:append("}")
return lua
elseif "Dict" == _exp_0 then
local lua = LuaCode.Value(tree.source, "dict{")
local lua = LuaCode.Value(tree.source, "_Dict{")
lua:concat_append((function()
local _accum_0 = { }
local _len_0 = 1
@ -722,7 +721,7 @@ do
elseif "Number" == _exp_0 then
return LuaCode.Value(tree.source, tostring(tree[1]))
elseif "Var" == _exp_0 then
return LuaCode.Value(tree.source, "_", string.as_lua_id(tree[1]))
return LuaCode.Value(tree.source, string.as_lua_id(tree[1]))
elseif "FileChunks" == _exp_0 then
return error("Cannot convert FileChunks to a single block of lua, since each chunk's " .. "compilation depends on the earlier chunks")
else

59
nomsu_compiler.moon
View File

@ -14,7 +14,7 @@ re = require 're'
utils = require 'utils'
Files = require 'files'
{:repr, :stringify, :equivalent} = utils
{:list, :dict} = require 'containers'
{:List, :Dict} = require 'containers'
export colors, colored
colors = require 'consolecolors'
colored = setmetatable({}, {__index:(_,color)-> ((msg)-> colors[color]..tostring(msg or '')..colors.reset)})
@ -33,9 +33,9 @@ SOURCE_MAP = {}
-- but not idempotent, i.e. if (x != y) then (as_lua_id(x) != as_lua_id(y)),
-- but as_lua_id(x) is not necessarily equal to as_lua_id(as_lua_id(x))
string.as_lua_id = (str)->
-- Empty strings are not valid lua identifiers, so treat them like "\0",
-- and treat "\0" as "\0\0", etc. to preserve injectivity.
str = gsub str, "^\0*$", "%1\0"
-- Empty strings are not valid lua identifiers, so treat them like "\3",
-- and treat "\3" as "\3\3", etc. to preserve injectivity.
str = gsub str, "^\3*$", "%1\3"
-- Escape 'x' when it precedes something that looks like an uppercase hex sequence.
-- This way, all Lua IDs can be unambiguously reverse-engineered, but normal usage
-- of 'x' won't produce ugly Lua IDs.
@ -74,7 +74,7 @@ NomsuCompiler = setmetatable {name:"Nomsu"},
__index: (k)=> if _self = rawget(@, "self") then _self[k] else nil
__tostring: => @name
with NomsuCompiler
.NOMSU_COMPILER_VERSION = 6
.NOMSU_COMPILER_VERSION = 7
.NOMSU_SYNTAX_VERSION = Parser.version
.nomsu = NomsuCompiler
.parse = (...)=> Parser.parse(...)
@ -90,7 +90,7 @@ with NomsuCompiler
:table, :assert, :dofile, :loadstring, :type, :select, :math, :io, :load,
:pairs, :ipairs,
-- Nomsu types:
:list, :dict,
_List:List, _Dict:Dict,
}
if _VERSION == "Lua 5.4"
to_add.ipairs = (x)->
@ -187,38 +187,37 @@ with NomsuCompiler
lua\append " "
return lua
["Lua 1"]: (tree, _code)=>
return add_lua_string_bits(@, 'statements', _code)
["Lua 1"]: (tree, code)=>
return add_lua_string_bits(@, 'statements', code)
["Lua value 1"]: (tree, _code)=>
return add_lua_string_bits(@, 'value', _code)
["Lua value 1"]: (tree, code)=>
return add_lua_string_bits(@, 'value', code)
["lua > 1"]: (tree, _code)=>
if _code.type != "Text"
return LuaCode tree.source, "nomsu:run_lua(", @compile(_code), ");"
return add_lua_bits(@, "statements", _code)
["lua > 1"]: (tree, code)=>
if code.type != "Text"
return LuaCode tree.source, "nomsu:run_lua(", @compile(code), ");"
return add_lua_bits(@, "statements", code)
["= lua 1"]: (tree, _code)=>
if _code.type != "Text"
return LuaCode.Value tree.source, "nomsu:run_lua(", @compile(_code), ":as_statements('return '))"
return add_lua_bits(@, "value", _code)
["= lua 1"]: (tree, code)=>
if code.type != "Text"
return LuaCode.Value tree.source, "nomsu:run_lua(", @compile(code), ":as_statements('return '))"
return add_lua_bits(@, "value", code)
["use 1"]: (tree, _path)=>
if _path.type == 'Text' and #_path == 1 and type(_path[1]) == 'string'
path = _path[1]
for _,f in Files.walk(path)
["use 1"]: (tree, path)=>
if path.type == 'Text' and #path == 1 and type(path[1]) == 'string'
for _,f in Files.walk(path[1])
@run_file(f)
return LuaCode(tree.source, "for i,f in Files.walk(", @compile(_path), ") do nomsu:run_file(f) end")
return LuaCode(tree.source, "for i,f in Files.walk(", @compile(path), ") do nomsu:run_file(f) end")
["tests"]: (tree)=> LuaCode.Value(tree.source, "TESTS")
["test 1"]: (tree, _body)=>
test_str = table.concat [tostring(@tree_to_nomsu(line)) for line in *_body], "\n"
["test 1"]: (tree, body)=>
test_str = table.concat [tostring(@tree_to_nomsu(line)) for line in *body], "\n"
LuaCode tree.source, "TESTS[#{repr(tostring(tree.source))}] = ", repr(test_str)
["is jit"]: (tree, _code)=>
["is jit"]: (tree, code)=>
return LuaCode.Value(tree.source, jit and "true" or "false")
["Lua version"]: (tree, _code)=>
["Lua version"]: (tree, code)=>
return LuaCode.Value(tree.source, repr(_VERSION))
}, {
__index: (stub)=>
@ -417,13 +416,13 @@ with NomsuCompiler
return lua
when "List"
lua = LuaCode.Value tree.source, "list{"
lua = LuaCode.Value tree.source, "_List{"
lua\concat_append([@compile(e) for e in *tree], ", ", ",\n ")
lua\append "}"
return lua
when "Dict"
lua = LuaCode.Value tree.source, "dict{"
lua = LuaCode.Value tree.source, "_Dict{"
lua\concat_append([@compile(e) for e in *tree], ", ", ",\n ")
lua\append "}"
return lua
@ -481,7 +480,7 @@ with NomsuCompiler
return LuaCode.Value(tree.source, tostring(tree[1]))
when "Var"
return LuaCode.Value(tree.source, "_", string.as_lua_id(tree[1]))
return LuaCode.Value(tree.source, string.as_lua_id(tree[1]))
when "FileChunks"
error("Cannot convert FileChunks to a single block of lua, since each chunk's "..

2
parser.lua
View File

@ -1,6 +1,6 @@
local lpeg = require('lpeg')
local re = require('re')
lpeg.setmaxstack(10000)
lpeg.setmaxstack(20000)
local P, R, S, C, Cmt, Carg
P, R, S, C, Cmt, Carg = lpeg.P, lpeg.R, lpeg.S, lpeg.C, lpeg.Cmt, lpeg.Carg
local match, sub

2
parser.moon
View File

@ -1,7 +1,7 @@
-- This file contains the parser, which converts Nomsu text into abstract syntax trees
lpeg = require 'lpeg'
re = require 're'
lpeg.setmaxstack 10000
lpeg.setmaxstack 20000
{:P,:R,:S,:C,:Cmt,:Carg} = lpeg
{:match, :sub} = string
{:insert, :remove} = table

24
uuid.lua
View File

@ -1,24 +0,0 @@
-- A simple UUID function based on RFC 4122: http://www.ietf.org/rfc/rfc4122.txt
local unpack = unpack or table.unpack
local function uuid()
local r = math.random
-- Set all the other bits to randomly (or pseudo-randomly) chosen values.
local bytes = {
r(2^(4*8)), --time-low
r(2^(2*8)), --time-mid
r(2^(2*8-4)), --time-high-and-version
r(2^(1*8-2)), --clock-seq-and-reserved
r(2^(1*8)), --clock-seq-low
r(2^(3*8)), r(2^(3*8)), --node
}
-- Set the four most significant bits (bits 12 through 15) of the
-- time_hi_and_version field to the 4-bit version number from
-- Section 4.1.3.
bytes[3] = bytes[3] + 0x4000
-- Set the two most significant bits (bits 6 and 7) of the
-- clock_seq_hi_and_reserved to zero and one, respectively.
bytes[4] = bytes[4] + 0xC0
return ("%08x-%04x-%04x-%02x%02x-%6x%6x"):format(unpack(bytes))
end
return uuid