Added versioning system.
This commit is contained in:
Bruce Hill
parent
11800f6fc2
commit
dbf3de3d8e
43
Makefile
43
Makefile
@ -20,46 +20,61 @@ CORE_LUA_FILES= $(patsubst %.nom,%.lua,$(CORE_NOM_FILES))
|
||||
LIB_NOM_FILES= $(wildcard lib/*.nom)
|
||||
LIB_LUA_FILES= $(patsubst %.nom,%.lua,$(LIB_NOM_FILES))
|
||||
PEG_FILE= nomsu.peg
|
||||
|
||||
NOMSU_HEADER=\#!$(LUA_BIN)\npackage.path = [[$(NOMSU_LIB_DIR)/?.lua;]]..package.path\npackage.nomsupath = [[$(NOMSU_LIB_DIR)]]
|
||||
GET_VERSION= $(LUA_BIN) nomsu.lua --version
|
||||
|
||||
all: build optimize
|
||||
|
||||
.PHONY: test
|
||||
test: build optimize
|
||||
./nomsu tests
|
||||
./nomsu_latest tests
|
||||
|
||||
%.lua: %.moon
|
||||
@moonc $<
|
||||
|
||||
%.lua: %.nom
|
||||
@./nomsu -c $<
|
||||
@./nomsu_latest -c $<
|
||||
|
||||
.PHONY: check_header
|
||||
check_header:
|
||||
@if [ "`head -n 3 nomsu 2>/dev/null`" != "`echo '$(NOMSU_HEADER)'`" ]; then rm -f nomsu core/*.lua lib/*.lua; fi
|
||||
check_header: version
|
||||
@if [ -f nomsu_latest ]; then \
|
||||
NOMSU_HEADER="#!$(LUA_BIN)\\npackage.path = [[$(NOMSU_LIB_DIR)/$$(cat version)/?.lua;]]..package.path\\npackage.nomsupath = [[$(NOMSU_LIB_DIR)/$$(cat version)]]"; \
|
||||
if [ "`head -n 3 nomsu_latest 2>/dev/null`" != "`echo $$NOMSU_HEADER`" ]; then \
|
||||
rm -f nomsu_latest; \
|
||||
fi; \
|
||||
fi;
|
||||
|
||||
nomsu: nomsu.lua
|
||||
@echo '$(NOMSU_HEADER)' | cat - nomsu.lua > nomsu
|
||||
@chmod +x nomsu
|
||||
version: $(PEG_FILE) nomsu.lua $(CORE_NOM_FILES) $(LIB_NOM_FILES)
|
||||
@$(LUA_BIN) nomsu.lua --version > version
|
||||
|
||||
nomsu_latest: nomsu.lua
|
||||
@rm -f nomsu_latest
|
||||
@NOMSU_HEADER="#!$(LUA_BIN)\\npackage.path = [[$(NOMSU_LIB_DIR)/$$(cat version)/?.lua;]]..package.path\\npackage.nomsupath = [[$(NOMSU_LIB_DIR)/$$(cat version)]]"; \
|
||||
echo $$NOMSU_HEADER | cat - nomsu.lua > nomsu_latest
|
||||
@chmod +x nomsu_latest
|
||||
@mv -f nomsu_latest nomsu`./nomsu_latest --version`
|
||||
@ln -s nomsu`$(LUA_BIN) nomsu.lua --version` nomsu_latest
|
||||
@echo "Built nomsu binary"
|
||||
|
||||
build: $(LUA_FILES) check_header nomsu
|
||||
build: $(LUA_FILES) version check_header nomsu_latest
|
||||
|
||||
.PHONY: optimize
|
||||
optimize: build $(CORE_LUA_FILES) $(LIB_LUA_FILES)
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
rm -rf nomsu core/*.lua lib/*.lua
|
||||
@echo "Deleting..."
|
||||
@rm -rvf nomsu`./nomsu_latest --version 2>/dev/null` nomsu_latest core/*.lua lib/*.lua
|
||||
|
||||
.PHONY: install
|
||||
install: all
|
||||
mkdir -p $(NOMSU_BIN_DIR) && cp nomsu $(NOMSU_BIN_DIR)
|
||||
mkdir -p $(NOMSU_LIB_DIR) && cp -r $(LUA_FILES) $(PEG_FILE) core lib $(NOMSU_LIB_DIR)
|
||||
mkdir -pv $(NOMSU_BIN_DIR) && cp -v nomsu nomsu`./nomsu_latest --version` $(NOMSU_BIN_DIR)
|
||||
mkdir -pv $(NOMSU_LIB_DIR)/`./nomsu_latest --version` && cp -rv $(LUA_FILES) $(PEG_FILE) core lib $(NOMSU_LIB_DIR)/`./nomsu_latest --version`
|
||||
|
||||
.PHONY: uninstall
|
||||
uninstall: all
|
||||
rm -rf $(NOMSU_LIB_DIR) $(NOMSU_BIN_DIR)/nomsu
|
||||
@echo "Deleting..."
|
||||
@rm -rvf $(NOMSU_LIB_DIR)/`$(GET_VERSION)` $(NOMSU_BIN_DIR)/nomsu`$(GET_VERSION)`
|
||||
@if [ "`ls $(NOMSU_BIN_DIR)/nomsu*`" == "nomsu" ]; then rm -v $(NOMSU_BIN_DIR)/nomsu; fi
|
||||
@if [ "`ls $(NOMSU_LIB_DIR) 2>/dev/null`" == "" ]; then rm -rvf $(NOMSU_LIB_DIR); fi
|
||||
|
||||
# eof
|
||||
|
||||
14
README.md
14
README.md
@ -23,7 +23,8 @@ If you enjoy Nomsu so much that you'd like to tinker with it or have it in your
|
||||
|
||||
All `.moon` files have been precompiled into corresponding `.lua` files, so you don't need to have [Moonscript](http://moonscript.org/) installed to run the Nomsu compiler.
|
||||
|
||||
* `nomsu.moon` - The Nomsu command line runner. This handles launching the compiler and running the REPL.
|
||||
* `nomsu` - A shell script that selects between different installed versions of Nomsu (using the `-V` flag). You can use this script to, for example, run `nomsu -V 1.2 your_script.nom` to run with the latest version of Nomsu that matches `1.2.?.?`. All flags and arguments are passed along to whichever Nomsu compiler is chosen.
|
||||
* `nomsu.moon` - The source code for the Nomsu command line runner. This handles launching the compiler and running the REPL.
|
||||
* `nomsu.peg` - The [Parsing Expression Grammar](https://en.wikipedia.org/wiki/Parsing_expression_grammar) used to define Nomsu's syntax. The format of this file is a slightly modified version of the format accepted by LPEG's `re` module.
|
||||
* `nomsu_compiler.moon` - **The actual Nomsu compiler**. This file can be imported and used without going through the regular command line interface (e.g. for applications that want to embed the compiler).
|
||||
* `parser.moon` - The Nomsu parser. This file can also be imported and used directly for applications that only need to *parse* Nomsu, not compile it.
|
||||
@ -41,6 +42,17 @@ All `.moon` files have been precompiled into corresponding `.lua` files, so you
|
||||
* `LICENSE` - The software license (MIT).
|
||||
* `README.md` - This file.
|
||||
|
||||
## Versioning
|
||||
|
||||
Nomsu uses the following versioning scheme: `[syntax version].[core library API version].[compiler internal API version].[lib/ API version]`. Which means:
|
||||
|
||||
* Any code that parses on `Nomsu X.a.b.c.d` will also parse on Nomsu `X.p.w.r.s`
|
||||
* Any code that compiles on Nomsu `X.Y.a.b.c` will also compile on Nomsu `X.Y.p.q.r` and run without any differences, as long as it only depends on the behavior of the core library functions (i.e. stuff defined in `core/*.nom`), and doesn't mess with the compiler internals at all.
|
||||
* Any code that compiles on Nomsu `X.Y.Z.a.b` will also compile on Nomsu `X.Y.Z.p.q` and run without any differences, even if it messes with the compiler internals, as long as it doesn't use anything from `lib/*.nom`.
|
||||
* Any code that compiles on Nomsu `X.Y.Z.W` will also compile on any other Nomsu `X.Y.Z.W` and run without any differences, even if it uses stuff from `lib/*.nom`.
|
||||
|
||||
When Nomsu is istalled via `make install`, all of Nomsu's lua files and `core/*.nom` and `lib/*.nom` files are stored in `$PREFIX/lib/nomsu/$NOMSU_VERSION` and the Nomsu executable is installed to `$PREFIX/bin/nomsu$NOMSU_VERSION`, along with the file `nomsu` (the version-selection script), which goes to `$PREFIX/bin/nomsu`. When `make uninstall` is run, all those files are deleted (except for `nomsu`, if there are other versions installed).
|
||||
|
||||
## Extra
|
||||
|
||||
There is a vim plugin for the language available in the [Vim Nomsu repository](https://bitbucket.org/squidarms/vim-nomsu/src). It is usually kept relatively up-to-date with Nomsu, but occasionally lags behind.
|
||||
|
||||
@ -150,13 +150,14 @@ action [%items sorted, sorted %items]
|
||||
%copy <- (% for % in %items)
|
||||
sort %copy
|
||||
return %copy
|
||||
action [..]
|
||||
parse [..]
|
||||
%items sorted by %item = %key
|
||||
%items sorted by %item -> %key
|
||||
..
|
||||
%copy <- (% for % in %items)
|
||||
sort %copy by %item = %key
|
||||
return %copy
|
||||
..as
|
||||
result of
|
||||
%copy <- (% for % in %items)
|
||||
sort %copy by %item = %key
|
||||
return %copy
|
||||
|
||||
action [unique %items]
|
||||
%unique <- []
|
||||
|
||||
@ -2,6 +2,8 @@
|
||||
This File contains actions for making actions and compile-time actions and some helper
|
||||
functions to make that easier.
|
||||
|
||||
lua> "NOMSU_CORE_VERSION = 1"
|
||||
|
||||
lua> ".."
|
||||
nomsu.COMPILE_ACTIONS["% -> %"] = function(nomsu, tree, \%args, \%body)
|
||||
local lua = LuaCode.Value(tree.source, "function(")
|
||||
@ -52,6 +54,13 @@ lua> ".."
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
compile [call %fn with %args] to
|
||||
lua> ".."
|
||||
local lua = LuaCode.Value(tree.source, nomsu:compile(\%fn), "(")
|
||||
lua:concat_append(table.map(\%args, function(a) return nomsu:compile(a) end), ", ")
|
||||
lua:append(")")
|
||||
return lua
|
||||
|
||||
compile [using %defs compile %body] to
|
||||
lua> ".."
|
||||
local lua = LuaCode(tree.source)
|
||||
@ -124,8 +133,9 @@ compile [parse %actions as %body] to
|
||||
local \%new_body = LuaCode(\%body.source,
|
||||
"__MANGLE_INDEX = (__MANGLE_INDEX or 0) + 1",
|
||||
"\nlocal tree = ", make_tree(\%body),
|
||||
"\nreturn nomsu:compile(tree)")
|
||||
return \(compile as: compile %actions to %new_body)
|
||||
"\nlocal lua = nomsu:compile(tree); return lua")
|
||||
local ret = \(compile as: compile %actions to %new_body)
|
||||
return ret
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
@ -171,6 +181,15 @@ compile [%tree with %t -> %replacement] to
|
||||
\(%replacement as lua return)
|
||||
end)
|
||||
|
||||
compile [%tree with vars %v] to
|
||||
Lua value ".."
|
||||
\(%tree as lua expr):map(function(t)
|
||||
local replacements = \(%v as lua expr)
|
||||
if t.type == "Var" then
|
||||
return replacements[t[1]]
|
||||
end
|
||||
end)
|
||||
|
||||
compile [declare locals in %code] to
|
||||
Lua value "\(%code as lua expr):declare_locals()"
|
||||
|
||||
@ -190,7 +209,7 @@ compile [quote %s] to
|
||||
('"'..\(%s as lua expr):gsub("\\\\", "\\\\\\\\"):gsub("\n","\\\\n"):gsub('"', '\\\\"')..'"')
|
||||
compile [type of %obj] to: Lua value "type(\(%obj as lua expr))"
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
compile [parse %text] to
|
||||
Lua value ".."
|
||||
@ -201,11 +220,7 @@ compile [run %nomsu_code] to
|
||||
|
||||
action [run tree %tree, %tree as value]
|
||||
lua> ".."
|
||||
if \%tree.type == 'Text' and #\%tree == 1 and type(\%tree[1]) == 'string' then
|
||||
return \%tree[1]
|
||||
end
|
||||
local lua = LuaCode(\%tree.source, "return ",nomsu:compile(\%tree))
|
||||
return nomsu:run_lua(lua)
|
||||
return nomsu:run(\%tree)
|
||||
|
||||
compile [compile %block, compiled %block, %block compiled] to
|
||||
Lua value "nomsu:compile(\(%block as lua))"
|
||||
@ -219,4 +234,12 @@ compile [return %return_value] to: Lua "do return \(%return_value as lua expr);
|
||||
compile [yes] to: Lua value "true"
|
||||
compile [no] to: Lua value "false"
|
||||
compile [nothing, nil, null] to: Lua value "nil"
|
||||
compile [Nomsu syntax version] to: Lua value "NOMSU_SYNTAX_VERSION"
|
||||
compile [Nomsu compiler version] to: Lua value "NOMSU_COMPILER_VERSION"
|
||||
compile [core version] to: Lua value "NOMSU_CORE_VERSION"
|
||||
compile [lib version] to: Lua value "NOMSU_LIB_VERSION"
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
action [Nomsu version]
|
||||
use "lib/version.nom"
|
||||
return "\(Nomsu syntax version).\(Nomsu compiler version).\(core version).\(lib version)"
|
||||
|
||||
43
nomsu.lua
43
nomsu.lua
@ -1,7 +1,7 @@
|
||||
local EXIT_SUCCESS, EXIT_FAILURE = 0, 1
|
||||
local usage = [=[Nomsu Compiler
|
||||
|
||||
Usage: (lua nomsu.lua | moon nomsu.moon) [-i] [-O] [-v] [-c] [-f] [-s] [--help] [-p print_file] file1 file2... [-- nomsu args...]
|
||||
Usage: (lua nomsu.lua | moon nomsu.moon) [-V version] [-i] [-O] [-v] [-c] [-f] [-s] [--help] [--version] [-p print_file] file1 file2... [-- nomsu args...]
|
||||
|
||||
OPTIONS
|
||||
-i Run the compiler in interactive mode (REPL)
|
||||
@ -11,6 +11,8 @@ OPTIONS
|
||||
-f Auto-format the given Nomsu file and print the result.
|
||||
-s Check the program for syntax errors.
|
||||
-h/--help Print this message.
|
||||
--version Print the version number and exit.
|
||||
-V specify which Nomsu version is desired
|
||||
-p <file> Print to the specified file instead of stdout.
|
||||
<input> Input file can be "-" to use stdin.
|
||||
]=]
|
||||
@ -29,6 +31,8 @@ do
|
||||
local _obj_0 = require("code_obj")
|
||||
NomsuCode, LuaCode, Source = _obj_0.NomsuCode, _obj_0.LuaCode, _obj_0.Source
|
||||
end
|
||||
local repr
|
||||
repr = require("utils").repr
|
||||
local STDIN, STDOUT, STDERR = "/dev/fd/0", "/dev/fd/1", "/dev/fd/2"
|
||||
if not arg or debug.getinfo(2).func == require then
|
||||
return NomsuCompiler
|
||||
@ -43,20 +47,26 @@ local parser = re.compile([[ args <- {| (flag ";")* {:inputs: {| ({file} ";")
|
||||
/ {:compile: ("-c" -> true) :}
|
||||
/ {:verbose: ("-v" -> true) :}
|
||||
/ {:help: (("-h" / "--help") -> true) :}
|
||||
/ {:version: ("--version" -> true) :}
|
||||
/ {:requested_version: "-V" ((";")? {([0-9.])+})? :}
|
||||
file <- "-" / [^;]+
|
||||
]], {
|
||||
["true"] = function()
|
||||
return true
|
||||
end
|
||||
})
|
||||
local args = table.concat(arg, ";") .. ";"
|
||||
args = parser:match(args)
|
||||
local arg_string = table.concat(arg, ";") .. ";"
|
||||
local args = parser:match(arg_string)
|
||||
if not args or args.help then
|
||||
print(usage)
|
||||
os.exit(EXIT_FAILURE)
|
||||
end
|
||||
local nomsu = NomsuCompiler
|
||||
nomsu.arg = args.nomsu_args
|
||||
if args.version then
|
||||
nomsu:run('use "core"\nsay (Nomsu version)')
|
||||
os.exit(EXIT_SUCCESS)
|
||||
end
|
||||
FILE_CACHE = setmetatable({ }, {
|
||||
__index = function(self, filename)
|
||||
local file = io.open(filename)
|
||||
@ -194,7 +204,15 @@ run = function()
|
||||
to_run[f] = true
|
||||
end
|
||||
end
|
||||
nomsu.skip_precompiled = to_run
|
||||
nomsu.can_optimize = function(f)
|
||||
if not (args.optimized) then
|
||||
return false
|
||||
end
|
||||
if to_run[f] then
|
||||
return false
|
||||
end
|
||||
return true
|
||||
end
|
||||
if args.compile or args.verbose then
|
||||
nomsu.on_compile = function(code, from_file)
|
||||
if not (to_run[from_file]) then
|
||||
@ -253,11 +271,25 @@ run = function()
|
||||
os.exit(EXIT_SUCCESS)
|
||||
end
|
||||
if args.interactive then
|
||||
nomsu:run('say "\\n\\(bright)\\(underscore)Welcome to the Nomsu v\\(Nomsu version) interactive console!\\(reset color)\\n press \'enter\' twice to run a command\\n"')
|
||||
local ready_to_quit = false
|
||||
nomsu.A_quit = function()
|
||||
ready_to_quit = true
|
||||
return print("Goodbye!")
|
||||
end
|
||||
nomsu.A_exit = nomsu.A_quit
|
||||
nomsu.A_help = function()
|
||||
print("This is the Nomsu v" .. tostring(nomsu.A_Nomsu_version()) .. " interactive console.")
|
||||
print("You can type in Nomsu code here and hit 'enter' twice to run it.")
|
||||
return print("To exit, type 'exit' or 'quit' and hit enter twice")
|
||||
end
|
||||
for repl_line = 1, math.huge do
|
||||
io.write(colored.bright(colored.yellow(">> ")))
|
||||
local buff = { }
|
||||
while true do
|
||||
io.write(colors.bright)
|
||||
local line = io.read("*L")
|
||||
io.write(colors.reset)
|
||||
if line == "\n" or not line then
|
||||
if #buff > 0 then
|
||||
io.write("\027[1A\027[2K")
|
||||
@ -285,6 +317,9 @@ run = function()
|
||||
elseif not ok then
|
||||
Errhand.print_error(ret)
|
||||
end
|
||||
if ready_to_quit then
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
35
nomsu.moon
35
nomsu.moon
@ -4,7 +4,7 @@ EXIT_SUCCESS, EXIT_FAILURE = 0, 1
|
||||
usage = [=[
|
||||
Nomsu Compiler
|
||||
|
||||
Usage: (lua nomsu.lua | moon nomsu.moon) [-i] [-O] [-v] [-c] [-f] [-s] [--help] [-p print_file] file1 file2... [-- nomsu args...]
|
||||
Usage: (lua nomsu.lua | moon nomsu.moon) [-V version] [-i] [-O] [-v] [-c] [-f] [-s] [--help] [--version] [-p print_file] file1 file2... [-- nomsu args...]
|
||||
|
||||
OPTIONS
|
||||
-i Run the compiler in interactive mode (REPL)
|
||||
@ -14,6 +14,8 @@ OPTIONS
|
||||
-f Auto-format the given Nomsu file and print the result.
|
||||
-s Check the program for syntax errors.
|
||||
-h/--help Print this message.
|
||||
--version Print the version number and exit.
|
||||
-V specify which Nomsu version is desired
|
||||
-p <file> Print to the specified file instead of stdout.
|
||||
<input> Input file can be "-" to use stdin.
|
||||
]=]
|
||||
@ -28,6 +30,7 @@ if not ok
|
||||
Errhand = require "error_handling"
|
||||
NomsuCompiler = require "nomsu_compiler"
|
||||
{:NomsuCode, :LuaCode, :Source} = require "code_obj"
|
||||
{:repr} = require "utils"
|
||||
STDIN, STDOUT, STDERR = "/dev/fd/0", "/dev/fd/1", "/dev/fd/2"
|
||||
|
||||
-- If this file was reached via require(), then just return the Nomsu compiler
|
||||
@ -45,10 +48,12 @@ parser = re.compile([[
|
||||
/ {:compile: ("-c" -> true) :}
|
||||
/ {:verbose: ("-v" -> true) :}
|
||||
/ {:help: (("-h" / "--help") -> true) :}
|
||||
/ {:version: ("--version" -> true) :}
|
||||
/ {:requested_version: "-V" ((";")? {([0-9.])+})? :}
|
||||
file <- "-" / [^;]+
|
||||
]], {true: -> true})
|
||||
args = table.concat(arg, ";")..";"
|
||||
args = parser\match(args)
|
||||
arg_string = table.concat(arg, ";")..";"
|
||||
args = parser\match(arg_string)
|
||||
if not args or args.help
|
||||
print usage
|
||||
os.exit(EXIT_FAILURE)
|
||||
@ -56,6 +61,10 @@ if not args or args.help
|
||||
nomsu = NomsuCompiler
|
||||
nomsu.arg = args.nomsu_args
|
||||
|
||||
if args.version
|
||||
nomsu\run 'use "core"\nsay (Nomsu version)'
|
||||
os.exit(EXIT_SUCCESS)
|
||||
|
||||
export FILE_CACHE
|
||||
-- FILE_CACHE is a map from filename (string) -> string of file contents
|
||||
FILE_CACHE = setmetatable {}, {
|
||||
@ -154,7 +163,10 @@ run = ->
|
||||
input_files[#input_files+1] = f
|
||||
to_run[f] = true
|
||||
|
||||
nomsu.skip_precompiled = to_run
|
||||
nomsu.can_optimize = (f)->
|
||||
return false unless args.optimized
|
||||
return false if to_run[f]
|
||||
return true
|
||||
|
||||
if args.compile or args.verbose
|
||||
nomsu.on_compile = (code, from_file)->
|
||||
@ -206,11 +218,24 @@ run = ->
|
||||
|
||||
if args.interactive
|
||||
-- REPL
|
||||
nomsu\run 'say "\\n\\(bright)\\(underscore)Welcome to the Nomsu v\\(Nomsu version) interactive console!\\(reset color)\\n press \'enter\' twice to run a command\\n"'
|
||||
ready_to_quit = false
|
||||
nomsu.A_quit = ->
|
||||
export ready_to_quit
|
||||
ready_to_quit = true
|
||||
print("Goodbye!")
|
||||
nomsu.A_exit = nomsu.A_quit
|
||||
nomsu.A_help = ->
|
||||
print("This is the Nomsu v#{nomsu.A_Nomsu_version()} interactive console.")
|
||||
print("You can type in Nomsu code here and hit 'enter' twice to run it.")
|
||||
print("To exit, type 'exit' or 'quit' and hit enter twice")
|
||||
for repl_line=1,math.huge
|
||||
io.write(colored.bright colored.yellow ">> ")
|
||||
buff = {}
|
||||
while true
|
||||
io.write(colors.bright)
|
||||
line = io.read("*L")
|
||||
io.write(colors.reset)
|
||||
if line == "\n" or not line
|
||||
if #buff > 0
|
||||
io.write("\027[1A\027[2K")
|
||||
@ -231,6 +256,8 @@ run = ->
|
||||
print "= "..repr(ret)
|
||||
elseif not ok
|
||||
Errhand.print_error ret
|
||||
if ready_to_quit
|
||||
break
|
||||
|
||||
has_ldt, ldt = pcall(require,'ldt')
|
||||
if has_ldt
|
||||
|
||||
@ -1,3 +1,4 @@
|
||||
-- Nomsu version 1
|
||||
file:
|
||||
(ignored_line %nl)*
|
||||
(file_chunks / block / action / expression)?
|
||||
|
||||
@ -29,7 +29,7 @@ do
|
||||
NomsuCode, LuaCode, Source = _obj_0.NomsuCode, _obj_0.LuaCode, _obj_0.Source
|
||||
end
|
||||
local AST = require("nomsu_tree")
|
||||
local parse = require("parser")
|
||||
local Parser = require("parser")
|
||||
SOURCE_MAP = { }
|
||||
string.as_lua_id = function(str)
|
||||
local argnum = 0
|
||||
@ -169,6 +169,28 @@ local _list_mt = {
|
||||
end
|
||||
return _accum_0
|
||||
end)(), ", ") .. "]"
|
||||
end,
|
||||
__lt = function(self, other)
|
||||
assert(type(self) == 'table' and type(other) == 'table', "Incompatible types for comparison")
|
||||
for i = 1, math.max(#self, #other) do
|
||||
if self[i] < other[i] then
|
||||
return true
|
||||
elseif self[i] > other[i] then
|
||||
return false
|
||||
end
|
||||
end
|
||||
return false
|
||||
end,
|
||||
__le = function(self, other)
|
||||
assert(type(self) == 'table' and type(other) == 'table', "Incompatible types for comparison")
|
||||
for i = 1, math.max(#self, #other) do
|
||||
if self[i] < other[i] then
|
||||
return true
|
||||
elseif self[i] > other[i] then
|
||||
return false
|
||||
end
|
||||
end
|
||||
return true
|
||||
end
|
||||
}
|
||||
local list
|
||||
@ -207,10 +229,15 @@ local NomsuCompiler = setmetatable({ }, {
|
||||
end
|
||||
})
|
||||
do
|
||||
NomsuCompiler.NOMSU_COMPILER_VERSION = 1
|
||||
NomsuCompiler.NOMSU_SYNTAX_VERSION = Parser.version
|
||||
NomsuCompiler._ENV = NomsuCompiler
|
||||
NomsuCompiler.nomsu = NomsuCompiler
|
||||
NomsuCompiler.parse = function(self, ...)
|
||||
return parse(...)
|
||||
return Parser.parse(...)
|
||||
end
|
||||
NomsuCompiler.can_optimize = function()
|
||||
return false
|
||||
end
|
||||
local to_add = {
|
||||
repr = repr,
|
||||
@ -218,6 +245,7 @@ do
|
||||
utils = utils,
|
||||
lpeg = lpeg,
|
||||
re = re,
|
||||
all_files = all_files,
|
||||
next = next,
|
||||
unpack = unpack,
|
||||
setmetatable = setmetatable,
|
||||
@ -393,11 +421,15 @@ do
|
||||
if source == nil then
|
||||
source = nil
|
||||
end
|
||||
source = source or (to_run.source or Source(to_run, 1, #to_run))
|
||||
if not rawget(FILE_CACHE, source.filename) then
|
||||
FILE_CACHE[source.filename] = to_run
|
||||
end
|
||||
local tree
|
||||
if AST.is_syntax_tree(to_run) then
|
||||
tree = tree
|
||||
tree = to_run
|
||||
else
|
||||
tree = self:parse(to_run, source or to_run.source)
|
||||
tree = self:parse(to_run, source)
|
||||
end
|
||||
if tree == nil then
|
||||
return nil
|
||||
@ -407,22 +439,22 @@ do
|
||||
local all_lua = { }
|
||||
for _index_0 = 1, #tree do
|
||||
local chunk = tree[_index_0]
|
||||
local lua = self:compile(chunk):as_statements()
|
||||
local lua = self:compile(chunk):as_statements("return ")
|
||||
lua:declare_locals()
|
||||
lua:prepend("-- File: " .. tostring(chunk.source or "") .. "\n")
|
||||
lua:prepend("-- File: " .. tostring(source.filename:gsub("\n.*", "...")) .. "\n")
|
||||
insert(all_lua, tostring(lua))
|
||||
ret = self:run_lua(lua)
|
||||
end
|
||||
if self.on_compile then
|
||||
self.on_compile(concat(all_lua, "\n"), (source or to_run.source).filename)
|
||||
self.on_compile(concat(all_lua, "\n"), source.filename)
|
||||
end
|
||||
return ret
|
||||
else
|
||||
local lua = self:compile(tree, compile_actions):as_statements()
|
||||
local lua = self:compile(tree, compile_actions):as_statements("return ")
|
||||
lua:declare_locals()
|
||||
lua:prepend("-- File: " .. tostring(source or to_run.source or "") .. "\n")
|
||||
lua:prepend("-- File: " .. tostring(source.filename:gsub("\n.*", "...")) .. "\n")
|
||||
if self.on_compile then
|
||||
self.on_compile(lua, (source or to_run.source).filename)
|
||||
self.on_compile(lua, source.filename)
|
||||
end
|
||||
return self:run_lua(lua)
|
||||
end
|
||||
@ -465,7 +497,7 @@ do
|
||||
ret = self:run_lua(file, Source(filename, 1, #file))
|
||||
elseif match(filename, "%.nom$") or match(filename, "^/dev/fd/[012]$") then
|
||||
local ran_lua
|
||||
if not self.skip_precompiled or not self.skip_precompiled[filename] then
|
||||
if self.can_optimize(filename) then
|
||||
local lua_filename = gsub(filename, "%.nom$", ".lua")
|
||||
do
|
||||
local file = FILE_CACHE[lua_filename]
|
||||
|
||||
@ -22,7 +22,7 @@ unpack or= table.unpack
|
||||
{:match, :sub, :rep, :gsub, :format, :byte, :match, :find} = string
|
||||
{:NomsuCode, :LuaCode, :Source} = require "code_obj"
|
||||
AST = require "nomsu_tree"
|
||||
parse = require("parser")
|
||||
Parser = require("parser")
|
||||
-- Mapping from source string (e.g. "@core/metaprogramming.nom[1:100]") to a mapping
|
||||
-- from lua line number to nomsu line number
|
||||
export SOURCE_MAP
|
||||
@ -134,6 +134,19 @@ _list_mt =
|
||||
-- Could consider adding a __newindex to enforce list-ness, but would hurt performance
|
||||
__tostring: =>
|
||||
"["..concat([repr(b) for b in *@], ", ").."]"
|
||||
__lt: (other)=>
|
||||
assert type(@) == 'table' and type(other) == 'table', "Incompatible types for comparison"
|
||||
for i=1,math.max(#@, #other)
|
||||
if @[i] < other[i] then return true
|
||||
elseif @[i] > other[i] then return false
|
||||
return false
|
||||
__le: (other)=>
|
||||
assert type(@) == 'table' and type(other) == 'table', "Incompatible types for comparison"
|
||||
for i=1,math.max(#@, #other)
|
||||
if @[i] < other[i] then return true
|
||||
elseif @[i] > other[i] then return false
|
||||
return true
|
||||
|
||||
list = (t)-> setmetatable(t, _list_mt)
|
||||
|
||||
_dict_mt =
|
||||
@ -145,13 +158,16 @@ dict = (t)-> setmetatable(t, _dict_mt)
|
||||
MAX_LINE = 80 -- For beautification purposes, try not to make lines much longer than this value
|
||||
NomsuCompiler = setmetatable({}, {__index: (k)=> if _self = rawget(@, "self") then _self[k] else nil})
|
||||
with NomsuCompiler
|
||||
.NOMSU_COMPILER_VERSION = 1
|
||||
.NOMSU_SYNTAX_VERSION = Parser.version
|
||||
._ENV = NomsuCompiler
|
||||
.nomsu = NomsuCompiler
|
||||
.parse = (...)=> parse(...)
|
||||
.parse = (...)=> Parser.parse(...)
|
||||
.can_optimize = -> false
|
||||
|
||||
-- Discretionary/convenience stuff
|
||||
to_add = {
|
||||
repr:repr, stringify:stringify, utils:utils, lpeg:lpeg, re:re,
|
||||
repr:repr, stringify:stringify, utils:utils, lpeg:lpeg, re:re, all_files:all_files,
|
||||
-- Lua stuff:
|
||||
:next, :unpack, :setmetatable, :coroutine, :rawequal, :getmetatable, :pcall,
|
||||
:error, :package, :os, :require, :tonumber, :tostring, :string, :xpcall, :module,
|
||||
@ -272,7 +288,9 @@ with NomsuCompiler
|
||||
}
|
||||
|
||||
.run = (to_run, source=nil)=>
|
||||
tree = if AST.is_syntax_tree(to_run) then tree else @parse(to_run, source or to_run.source)
|
||||
source or= to_run.source or Source(to_run, 1, #to_run)
|
||||
if not rawget(FILE_CACHE,source.filename) then FILE_CACHE[source.filename] = to_run
|
||||
tree = if AST.is_syntax_tree(to_run) then to_run else @parse(to_run, source)
|
||||
if tree == nil -- Happens if pattern matches, but there are no captures, e.g. an empty string
|
||||
return nil
|
||||
if tree.type == "FileChunks"
|
||||
@ -282,20 +300,20 @@ with NomsuCompiler
|
||||
ret = nil
|
||||
all_lua = {}
|
||||
for chunk in *tree
|
||||
lua = @compile(chunk)\as_statements!
|
||||
lua = @compile(chunk)\as_statements("return ")
|
||||
lua\declare_locals!
|
||||
lua\prepend "-- File: #{chunk.source or ""}\n"
|
||||
lua\prepend "-- File: #{source.filename\gsub("\n.*", "...")}\n"
|
||||
insert all_lua, tostring(lua)
|
||||
ret = @run_lua(lua)
|
||||
if @on_compile
|
||||
self.on_compile(concat(all_lua, "\n"), (source or to_run.source).filename)
|
||||
self.on_compile(concat(all_lua, "\n"), source.filename)
|
||||
return ret
|
||||
else
|
||||
lua = @compile(tree, compile_actions)\as_statements!
|
||||
lua = @compile(tree, compile_actions)\as_statements("return ")
|
||||
lua\declare_locals!
|
||||
lua\prepend "-- File: #{source or to_run.source or ""}\n"
|
||||
lua\prepend "-- File: #{source.filename\gsub("\n.*", "...")}\n"
|
||||
if @on_compile
|
||||
self.on_compile(lua, (source or to_run.source).filename)
|
||||
self.on_compile(lua, source.filename)
|
||||
return @run_lua(lua)
|
||||
|
||||
_running_files = {} -- For detecting circular imports
|
||||
@ -319,7 +337,7 @@ with NomsuCompiler
|
||||
file = assert(FILE_CACHE[filename], "Could not find file: #{filename}")
|
||||
ret = @run_lua file, Source(filename, 1, #file)
|
||||
elseif match(filename, "%.nom$") or match(filename, "^/dev/fd/[012]$")
|
||||
ran_lua = if not @skip_precompiled or not @skip_precompiled[filename] -- Look for precompiled version
|
||||
ran_lua = if @.can_optimize(filename) -- Look for precompiled version
|
||||
lua_filename = gsub(filename, "%.nom$", ".lua")
|
||||
if file = FILE_CACHE[lua_filename]
|
||||
ret = @run_lua file, Source(lua_filename, 1, #file)
|
||||
|
||||
16
parser.lua
16
parser.lua
@ -72,7 +72,6 @@ do
|
||||
end
|
||||
local err_pos = start_pos
|
||||
local line_no = pos_to_line(src, err_pos)
|
||||
src = FILE_CACHE[userdata.source.filename]
|
||||
local line_starts = LINE_STARTS[src]
|
||||
local prev_line = line_no == 1 and "" or src:sub(line_starts[line_no - 1] or 1, line_starts[line_no] - 2)
|
||||
local err_line = src:sub(line_starts[line_no], (line_starts[line_no + 1] or 0) - 2)
|
||||
@ -116,9 +115,11 @@ setmetatable(NOMSU_DEFS, {
|
||||
return make_node
|
||||
end
|
||||
})
|
||||
local Parser = { }
|
||||
local NOMSU_PATTERN
|
||||
do
|
||||
local peg_tidier = re.compile([[ file <- {~ %nl* (def/comment) (%nl+ (def/comment))* %nl* ~}
|
||||
local peg_tidier = re.compile([[ file <- %nl* version? %nl* {~ (def/comment) (%nl+ (def/comment))* %nl* ~}
|
||||
version <- "--" (!"version" [^%nl])* "version" ([ ])* (([0-9])+ -> set_version) ([^%nl])*
|
||||
def <- anon_def / captured_def
|
||||
anon_def <- ({ident} (" "*) ":"
|
||||
{((%nl " "+ [^%nl]*)+) / ([^%nl]*)}) -> "%1 <- %2"
|
||||
@ -126,15 +127,18 @@ do
|
||||
{((%nl " "+ [^%nl]*)+) / ([^%nl]*)}) -> "%1 <- (({} %3 {} %%userdata) -> %2)"
|
||||
ident <- [a-zA-Z_][a-zA-Z0-9_]*
|
||||
comment <- "--" [^%nl]*
|
||||
]])
|
||||
]], {
|
||||
set_version = function(v)
|
||||
Parser.version = tonumber(v)
|
||||
end
|
||||
})
|
||||
local peg_file = io.open("nomsu.peg") or (package.nomsupath and io.open(package.nomsupath .. "/nomsu.peg"))
|
||||
assert(peg_file, "could not find nomsu.peg file")
|
||||
local nomsu_peg = peg_tidier:match(peg_file:read('*a'))
|
||||
peg_file:close()
|
||||
NOMSU_PATTERN = re.compile(nomsu_peg, NOMSU_DEFS)
|
||||
end
|
||||
local parse
|
||||
parse = function(nomsu_code, source)
|
||||
Parser.parse = function(nomsu_code, source)
|
||||
if source == nil then
|
||||
source = nil
|
||||
end
|
||||
@ -169,4 +173,4 @@ parse = function(nomsu_code, source)
|
||||
end
|
||||
return tree
|
||||
end
|
||||
return parse
|
||||
return Parser
|
||||
|
||||
12
parser.moon
12
parser.moon
@ -56,7 +56,7 @@ NOMSU_DEFS = with {}
|
||||
return #src+1
|
||||
err_pos = start_pos
|
||||
line_no = pos_to_line(src, err_pos)
|
||||
src = FILE_CACHE[userdata.source.filename]
|
||||
--src = FILE_CACHE[userdata.source.filename]
|
||||
line_starts = LINE_STARTS[src]
|
||||
prev_line = line_no == 1 and "" or src\sub(line_starts[line_no-1] or 1, line_starts[line_no]-2)
|
||||
err_line = src\sub(line_starts[line_no], (line_starts[line_no+1] or 0)-2)
|
||||
@ -85,11 +85,13 @@ setmetatable(NOMSU_DEFS, {__index:(key)=>
|
||||
return make_node
|
||||
})
|
||||
|
||||
Parser = {}
|
||||
NOMSU_PATTERN = do
|
||||
-- Just for cleanliness, I put the language spec in its own file using a slightly modified
|
||||
-- version of the lpeg.re syntax.
|
||||
peg_tidier = re.compile [[
|
||||
file <- {~ %nl* (def/comment) (%nl+ (def/comment))* %nl* ~}
|
||||
file <- %nl* version? %nl* {~ (def/comment) (%nl+ (def/comment))* %nl* ~}
|
||||
version <- "--" (!"version" [^%nl])* "version" ([ ])* (([0-9])+ -> set_version) ([^%nl])*
|
||||
def <- anon_def / captured_def
|
||||
anon_def <- ({ident} (" "*) ":"
|
||||
{((%nl " "+ [^%nl]*)+) / ([^%nl]*)}) -> "%1 <- %2"
|
||||
@ -97,14 +99,14 @@ NOMSU_PATTERN = do
|
||||
{((%nl " "+ [^%nl]*)+) / ([^%nl]*)}) -> "%1 <- (({} %3 {} %%userdata) -> %2)"
|
||||
ident <- [a-zA-Z_][a-zA-Z0-9_]*
|
||||
comment <- "--" [^%nl]*
|
||||
]]
|
||||
]], {set_version: (v) -> Parser.version = tonumber(v)}
|
||||
peg_file = io.open("nomsu.peg") or (package.nomsupath and io.open(package.nomsupath.."/nomsu.peg"))
|
||||
assert(peg_file, "could not find nomsu.peg file")
|
||||
nomsu_peg = peg_tidier\match(peg_file\read('*a'))
|
||||
peg_file\close!
|
||||
re.compile(nomsu_peg, NOMSU_DEFS)
|
||||
|
||||
parse = (nomsu_code, source=nil)->
|
||||
Parser.parse = (nomsu_code, source=nil)->
|
||||
nomsu_code = tostring(nomsu_code)
|
||||
userdata = {
|
||||
indent: "", errors: {}, :source
|
||||
@ -123,4 +125,4 @@ parse = (nomsu_code, source=nil)->
|
||||
|
||||
return tree
|
||||
|
||||
return parse
|
||||
return Parser
|
||||
|
||||
Loading…
Reference in New Issue
Block a user