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

Initial pass on updating syntax.

Browse Source
This commit is contained in:
Bruce Hill 2018-12-18 19:30:01 -08:00
parent 8e52f1901b
commit a7d912a33a
17 changed files with 702 additions and 630 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
core/metaprogramming.nom
View File

@ -51,16 +51,6 @@ lua> "
compile.action["->"] = compile.action["1 ->"] compile.action["->"] = compile.action["1 ->"]
compile.action["for"] = compile.action["1 ->"]" compile.action["for"] = compile.action["1 ->"]"
lua> "
compile.action["what 1 compiles to"] = function(compile, \$action)
local lua = LuaCode("compile.action[", \$action.stub:as_lua(), "](")
local lua_args = table.map(\$action:get_args(), compile)
table.insert(lua_args, 1, "compile")
lua:concat_add(lua_args, ", ")
lua:add(")")
return lua
end"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test: test:
@ -90,7 +80,7 @@ lua> "
if \$body.type == "Text" then if \$body.type == "Text" then
\$body = SyntaxTree{source=\$body.source, type="Action", "Lua", \$body} \$body = SyntaxTree{source=\$body.source, type="Action", "Lua", \$body}
end end
return LuaCode("compile.action[", \$action.stub:as_lua(), return LuaCode("compile.action[", \$action:get_stub():as_lua(),
"] = ", \(\($args -> $body) as lua)) "] = ", \(\($args -> $body) as lua))
end" end"
@ -107,13 +97,13 @@ lua> "
for i=2,#\$actions do for i=2,#\$actions do
local alias = \$actions[i] local alias = \$actions[i]
local \$alias_args = List{\(\$compile), unpack(alias:get_args())} local \$alias_args = List{\(\$compile), unpack(alias:get_args())}
lua:add("\\ncompile.action[", alias.stub:as_lua(), "] = ") lua:add("\\ncompile.action[", alias:get_stub():as_lua(), "] = ")
if \$alias_args == \$args then if \$alias_args == \$args then
lua:add("compile.action[", \$actions[1].stub:as_lua(), "]") lua:add("compile.action[", \$actions[1]:get_stub():as_lua(), "]")
else else
lua:add("function(") lua:add("function(")
lua:concat_add(table.map(\$alias_args, compile), ", ") lua:concat_add(table.map(\$alias_args, compile), ", ")
lua:add(") return compile.action[", \$actions[1].stub:as_lua(), "](") lua:add(") return compile.action[", \$actions[1]:get_stub():as_lua(), "](")
lua:concat_add(\$compiled_args, ", ") lua:concat_add(\$compiled_args, ", ")
lua:add(") end") lua:add(") end")
end end
@ -138,10 +128,10 @@ test:
local lua = LuaCode() local lua = LuaCode()
if \$action.type == "MethodCall" then if \$action.type == "MethodCall" then
lua:add(compile(\$action[1]), ".", \$action[2].stub:as_lua_id()) lua:add(compile(\$action[1]), ".", \$action[2]:get_stub():as_lua_id())
elseif \$action.type == "Action" then elseif \$action.type == "Action" then
lua:add(\$action.stub:as_lua_id()) lua:add(\$action:get_stub():as_lua_id())
lua:add_free_vars({\$action.stub:as_lua_id()}) lua:add_free_vars({\$action:get_stub():as_lua_id()})
else else
compile_error_at(\$action, "Expected an action or method call here") compile_error_at(\$action, "Expected an action or method call here")
end end
@ -152,17 +142,17 @@ test:
lua> " lua> "
local lua = \(\($actions.1 means $body) as lua) local lua = \(\($actions.1 means $body) as lua)
local first_def = (\$actions[1].type == "MethodCall" local first_def = (\$actions[1].type == "MethodCall"
and LuaCode(compile(\$actions[1][1]), ".", \$actions[1].stub:as_lua_id()) and LuaCode(compile(\$actions[1][1]), ".", \$actions[1]:get_stub():as_lua_id())
or LuaCode(\$actions[1].stub:as_lua_id())) or LuaCode(\$actions[1]:get_stub():as_lua_id()))
local \$args = List(\$actions[1]:get_args()) local \$args = List(\$actions[1]:get_args())
for i=2,#\$actions do for i=2,#\$actions do
local alias = \$actions[i] local alias = \$actions[i]
local \$alias_args = List(alias:get_args()) local \$alias_args = List(alias:get_args())
lua:add("\\n") lua:add("\\n")
if alias.type == "MethodCall" then if alias.type == "MethodCall" then
lua:add(compile(alias[1]), ".", alias.stub:as_lua_id()) lua:add(compile(alias[1]), ".", alias:get_stub():as_lua_id())
else else
lua:add(alias.stub:as_lua_id()) lua:add(alias:get_stub():as_lua_id())
lua:add_free_vars({alias_name}) lua:add_free_vars({alias_name})
end end
if \$args == \$alias_args then if \$args == \$alias_args then
@ -185,19 +175,19 @@ test:
(externally $action means $body) compiles to: (externally $action means $body) compiles to:
lua> " lua> "
local lua = \(\($action means $body) as lua) local lua = \(\($action means $body) as lua)
lua:remove_free_vars({\$action.stub:as_lua_id()}) lua:remove_free_vars({\$action:get_stub():as_lua_id()})
return lua" return lua"
(externally $actions all mean $body) compiles to: (externally $actions all mean $body) compiles to:
lua> " lua> "
local lua = \(\($actions all mean $body) as lua) local lua = \(\($actions all mean $body) as lua)
lua:remove_free_vars(table.map(\$actions, function(a) return a.stub:as_lua_id() end)) lua:remove_free_vars(table.map(\$actions, function(a) return a:get_stub():as_lua_id() end))
return lua" return lua"
test: test:
assume (((say $)'s meaning) == (=lua "say")) assume (((say $)'s meaning) == (=lua "say"))
($action's meaning) compiles to (Lua ($action.stub|as lua id)) ($action's meaning) compiles to (Lua (($action|get stub)|as lua id))
test: test:
(swap $x and $y) parses as (..) (swap $x and $y) parses as (..)
do: do:
@ -330,7 +320,7 @@ externally ($tree with vars $replacements) means (..)
externally (match $tree with $patt) means: externally (match $tree with $patt) means:
lua> " 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.type == "Action" and \$patt:get_stub() ~= \$tree:get_stub() then return nil end
if #\$patt ~= #\$tree then return nil end if #\$patt ~= #\$tree then return nil end
local matches = Dict{} local matches = Dict{}
for \($i)=1,#\$patt do for \($i)=1,#\$patt do
@ -412,7 +402,7 @@ test:
(Nomsu compiler version) compiles to "NOMSU_COMPILER_VERSION" (Nomsu compiler version) compiles to "NOMSU_COMPILER_VERSION"
(core version) compiles to "NOMSU_CORE_VERSION" (core version) compiles to "NOMSU_CORE_VERSION"
(lib version) compiles to "NOMSU_LIB_VERSION" (lib version) compiles to "NOMSU_LIB_VERSION"
(command line args) compiles to "command_line_args" (command line args) compiles to "COMMAND_LINE_ARGS"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
core/operators.nom
View File

@ -68,7 +68,7 @@ test:
if \$var.type == 'Var' then if \$var.type == 'Var' then
lua:add_free_vars({var_lua:text()}) lua:add_free_vars({var_lua:text()})
end end
lua:add(' = ', \($value as lua expr), ';') lua:add(' = ', \($value as lua expr))
end end
return lua" return lua"

2
examples/how_do_i.nom
View File

@ -63,7 +63,7 @@ say "
..start the next line with two periods, like that. ..start the next line with two periods, like that.
Similarly, you can put a long interpolated indented value like: \(..) Similarly, you can put a long interpolated indented value like: \(..)
100 + 200 + 300 + 400 + 500 + 600 + 700 + 800 + 900 1000 + 2000 + 3000 + 4000 + 5000 + 6000 + 7000 + 8000 + 9000
..between a backslash and two periods." ..between a backslash and two periods."
say "Single-line text can contain escape sequences like \", \\, \000, and \n" say "Single-line text can contain escape sequences like \", \\, \000, and \n"

4
lib/object.nom
View File

@ -60,7 +60,7 @@ test:
local fn_name = \$actions[1].stub:as_lua_id() local fn_name = \$actions[1].stub:as_lua_id()
local \$args = List(\$actions[1]:get_args()) local \$args = List(\$actions[1]:get_args())
table.insert(\$args, 1, \(\$me)) table.insert(\$args, 1, \(\$me))
local lua = LuaCode("class.", fn_name, " = ", \(what ($args -> $body) compiles to)) local lua = LuaCode("class.", fn_name, " = ", \(\($args -> $body) as lua))
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()
@ -70,7 +70,7 @@ test:
if \$args == \$alias_args then if \$args == \$alias_args then
lua:add("class.", fn_name) lua:add("class.", fn_name)
else else
lua:add(\(what ($alias_args -> $actions.1) compiles to)) lua:add(\(\($alias_args -> $actions.1) as lua))
end end
end end
return lua" return lua"

110
nomsu.1.peg
View File

@ -1,5 +1,5 @@
-- Nomsu version 1 -- Nomsu version 1
file (FileChunks): file (FileChunks) <-
{:curr_indent: ' '* :} {:curr_indent: ' '* :}
("#!" (!"nomsu" [^%nl])* "nomsu" ws+ "-V" ws* {:version: [0-9.]+ :} [^%nl]*)? ("#!" (!"nomsu" [^%nl])* "nomsu" ws+ "-V" ws* {:version: [0-9.]+ :} [^%nl]*)?
comment? blank_lines? comment? blank_lines?
@ -8,108 +8,108 @@ file (FileChunks):
{:curr_indent: %nil :} {:curr_indent: %nil :}
!. !.
nodent: (unexpected_indent [^%nl]* / =curr_indent) nodent <- (unexpected_indent [^%nl]* / =curr_indent)
indent: =curr_indent " " indent <- =curr_indent " "
blank_lines: %nl ((nodent comment / ws*) %nl)* blank_lines <- %nl ((nodent comment / ws*) %nl)*
eol: ws* eol_comment? (!. / &%nl) eol <- ws* eol_comment? (!. / &%nl)
nl_nodent: blank_lines nodent nl_nodent <- blank_lines nodent
nl_indent: blank_lines {:curr_indent: indent :} (comment nl_nodent)* nl_indent <- blank_lines {:curr_indent: indent :} (comment nl_nodent)*
comment (Comment): comment (Comment) <-
"#" {~ [^%nl]* (%nl+ (indent -> '') [^%nl]*)* ~} "#" {~ [^%nl]* (%nl+ (indent -> '') [^%nl]*)* ~}
eol_comment (Comment): eol_comment (Comment) <-
"#" {[^%nl]*} "#" {[^%nl]*}
unexpected_code: ws* _unexpected_code unexpected_code <- ws* _unexpected_code
_unexpected_code (Error): _unexpected_code (Error) <-
{:error: {~ [^%nl]+ -> "Couldn't parse this code" ~} :} {:error: {~ [^%nl]+ -> "Couldn't parse this code" ~} :}
unexpected_indent (Error): unexpected_indent (Error) <-
{:error: {~ (=curr_indent ws+) -> "Messed up indentation" ~} :} {:error: {~ (=curr_indent ws+) -> "Messed up indentation" ~} :}
{:hint: {~ '' -> 'Either make sure this line is aligned with the one above it, or make sure the previous line ends with something that uses indentation, like ":" or "(..)"' ~} :} {:hint: {~ '' -> 'Either make sure this line is aligned with the one above it, or make sure the previous line ends with something that uses indentation, like ":" or "(..)"' ~} :}
missing_paren_err (Error): missing_paren_err (Error) <-
{:error: {~ eol -> 'Line ended without finding a closing )-parenthesis' ~} :} {:error: {~ eol -> 'Line ended without finding a closing )-parenthesis' ~} :}
{:hint: {~ '' -> 'Put a ")" here' ~} :} {:hint: {~ '' -> 'Put a ")" here' ~} :}
missing_quote_err (Error): missing_quote_err (Error) <-
{:error: {~ eol -> 'Line ended before finding a closing double quotation mark' ~} :} {:error: {~ eol -> 'Line ended before finding a closing double quotation mark' ~} :}
{:hint: {~ "" -> "Put a quotation mark here" ~} :} {:hint: {~ "" -> "Put a quotation mark here" ~} :}
missing_bracket_error (Error): missing_bracket_error (Error) <-
{:error: {~ eol -> "Line ended before finding a closing ]-bracket" ~} :} {:error: {~ eol -> "Line ended before finding a closing ]-bracket" ~} :}
{:hint: {~ '' -> 'Put a "]" here' ~} :} {:hint: {~ '' -> 'Put a "]" here' ~} :}
missing_brace_error (Error): missing_brace_error (Error) <-
{:error: {~ eol -> "Line ended before finding a closing }-brace" ~} :} {:error: {~ eol -> "Line ended before finding a closing }-brace" ~} :}
{:hint: {~ '' -> 'Put a "}" here' ~} :} {:hint: {~ '' -> 'Put a "}" here' ~} :}
missing_block_expr_error (Error): missing_block_expr_error (Error) <-
{:error: '' -> "Missing expression after the ':'" :} {:error: '' -> "Missing expression after the ':'" :}
chunk: block / action / expression chunk <- block / action / expression
chunk_delimeter: ("~")^+3 eol chunk_delimeter <- ("~")^+3 eol
inline_block (Block): inline_block (Block) <-
inline_statement (ws* ";" ws* inline_statement)+ inline_statement (ws* ";" ws* inline_statement)+
block (Block): block (Block) <-
statement (nl_nodent statement)+ statement (nl_nodent statement)+
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
{:curr_indent: %nil :} {:curr_indent: %nil :}
statement: (action / expression) (eol / unexpected_code) statement <- (action / expression) (eol / unexpected_code)
inline_statement: (inline_action / inline_expression) inline_statement <- (inline_action / inline_expression)
noindex_inline_expression: noindex_inline_expression <-
number / variable / inline_text / inline_list / inline_dict / inline_nomsu number / variable / inline_text / inline_list / inline_dict / inline_nomsu
/ ( "(" / ( "("
ws* (inline_block / inline_action / inline_expression) ws* ws* (inline_block / inline_action / inline_expression) ws*
(ws* ',' ws* (inline_block / inline_action / inline_expression) ws*)* (ws* ',' ws* (inline_block / inline_action / inline_expression) ws*)*
(")" / missing_paren_err / unexpected_code) (")" / missing_paren_err / unexpected_code)
) )
inline_expression: index_chain / noindex_inline_expression inline_expression <- index_chain / noindex_inline_expression
indented_expression: indented_expression <-
indented_text / indented_nomsu / indented_list / indented_dict / ({| indented_text / indented_nomsu / indented_list / indented_dict / ({|
("(..)")? nl_indent ("(..)")? nl_indent
(block / action / expression) (eol / unexpected_code) (block / action / expression) (eol / unexpected_code)
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
{:curr_indent: %nil :} {:curr_indent: %nil :}
|} -> unpack) |} -> unpack)
expression: expression <-
inline_expression inline_expression
/ (":" ws* / (":" ws*
(inline_block / inline_action / inline_expression / missing_block_expr_error)) (inline_block / inline_action / inline_expression / missing_block_expr_error))
/ indented_expression / indented_expression
inline_nomsu (EscapedNomsu): "\" inline_expression inline_nomsu (EscapedNomsu) <- "\" inline_expression
indented_nomsu (EscapedNomsu): indented_nomsu (EscapedNomsu) <-
"\" ( "\" (
noindex_inline_expression noindex_inline_expression
/ (":" ws* / (":" ws*
(inline_block / inline_action / inline_expression / missing_block_expr_error)) (inline_block / inline_action / inline_expression / missing_block_expr_error))
/ indented_expression) / indented_expression)
index_chain (IndexChain): index_chain (IndexChain) <-
noindex_inline_expression ("." (text_word / noindex_inline_expression))+ noindex_inline_expression ("." (text_word / noindex_inline_expression))+
-- Actions need either at least 1 word, or at least 2 tokens -- Actions need either at least 1 word, or at least 2 tokens
inline_action (Action): inline_action (Action) <-
!chunk_delimeter !chunk_delimeter
( (inline_expression (ws* (inline_expression / word))+) ( (inline_expression (ws* (inline_expression / word))+)
/ (word (ws* (inline_expression / word))*)) / (word (ws* (inline_expression / word))*))
(ws* ":" ws* (inline_block / inline_action / inline_expression (ws* ":" ws* (inline_block / inline_action / inline_expression
/ missing_block_expr_error))? / missing_block_expr_error))?
action (Action): action (Action) <-
!chunk_delimeter !chunk_delimeter
( (expression ((nl_nodent "..")? ws* (expression / word))+) ( (expression ((nl_nodent "..")? ws* (expression / word))+)
/ (word ((nl_nodent "..")? ws* (expression / word))*)) / (word ((nl_nodent "..")? ws* (expression / word))*))
word: !number { operator_char+ / ident_char+ } word <- !number { operator_char+ / ident_char+ }
text_word (Text): word text_word (Text) <- word
inline_text (Text): inline_text (Text) <-
!(indented_text) !(indented_text)
'"' '"'
({~ (('\"' -> '"') / ('\\' -> '\') / escaped_char / [^%nl\"])+ ~} ({~ (('\"' -> '"') / ('\\' -> '\') / escaped_char / [^%nl\"])+ ~}
/ inline_text_interpolation)* / inline_text_interpolation)*
('"' / missing_quote_err / unexpected_code) ('"' / missing_quote_err / unexpected_code)
inline_text_interpolation: inline_text_interpolation <-
"\" ( "\" (
variable / inline_list / inline_dict / inline_text variable / inline_list / inline_dict / inline_text
/ ("(" / ("("
@ -118,63 +118,63 @@ inline_text_interpolation:
(")" / missing_paren_err / unexpected_code)) (")" / missing_paren_err / unexpected_code))
) )
indented_text (Text): indented_text (Text) <-
'".."' eol %nl {%nl+}? {:curr_indent: indent :} '".."' eol %nl {%nl+}? {:curr_indent: indent :}
(indented_plain_text / text_interpolation / {~ %nl+ (=curr_indent -> "") ~})* (indented_plain_text / text_interpolation / {~ %nl+ (=curr_indent -> "") ~})*
unexpected_code? unexpected_code?
{:curr_indent: %nil :} {:curr_indent: %nil :}
indented_plain_text (Text): indented_plain_text (Text) <-
{~ (("\\" -> "\") / (("\" blank_lines =curr_indent "..") -> "") / (!text_interpolation "\") / [^%nl\]+)+ {~ (("\\" -> "\") / (("\" blank_lines =curr_indent "..") -> "") / (!text_interpolation "\") / [^%nl\]+)+
(%nl+ (=curr_indent -> ""))* ~} (%nl+ (=curr_indent -> ""))* ~}
text_interpolation: text_interpolation <-
inline_text_interpolation / ("\" indented_expression blank_lines =curr_indent "..") inline_text_interpolation / ("\" indented_expression blank_lines =curr_indent "..")
number (Number): (("-"? (([0-9]+ "." [0-9]+) / ("." [0-9]+) / ([0-9]+)))-> tonumber) number (Number) <- (("-"? (([0-9]+ "." [0-9]+) / ("." [0-9]+) / ([0-9]+)))-> tonumber)
-- Variables can be nameless (i.e. just %) and can't contain operators like apostrophe -- Variables can be nameless (i.e. just %) and can't contain operators like apostrophe
-- which is a hack to allow %'s to parse as "%" and "' s" separately -- which is a hack to allow %'s to parse as "%" and "' s" separately
variable (Var): "%" {(ident_char+ ((!"'" operator_char+) / ident_char+)*)?} variable (Var) <- "%" {(ident_char+ ((!"'" operator_char+) / ident_char+)*)?}
inline_list (List): inline_list (List) <-
!('[..]') !('[..]')
"[" ws* "[" ws*
(inline_list_item (ws* ',' ws* inline_list_item)* (ws* ',')?)? ws* (inline_list_item (ws* ',' ws* inline_list_item)* (ws* ',')?)? ws*
("]" / (","? (missing_bracket_error / unexpected_code))) ("]" / (","? (missing_bracket_error / unexpected_code)))
indented_list (List): indented_list (List) <-
"[..]" eol nl_indent "[..]" eol nl_indent
list_line (nl_nodent list_line)* list_line (nl_nodent list_line)*
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
(","? unexpected_code)? (","? unexpected_code)?
list_line: list_line <-
(inline_list_item ws* "," ws*)+ eol (inline_list_item ws* "," ws*)+ eol
/ (inline_list_item ws* "," ws*)* (action / expression) eol / (inline_list_item ws* "," ws*)* (action / expression) eol
inline_list_item: inline_block / inline_action / inline_expression inline_list_item <- inline_block / inline_action / inline_expression
inline_dict (Dict): inline_dict (Dict) <-
!('{..}') !('{..}')
"{" ws* "{" ws*
(inline_dict_entry (ws* ',' ws* inline_dict_entry)*)? ws* (inline_dict_entry (ws* ',' ws* inline_dict_entry)*)? ws*
("}" / (","? (missing_brace_error / unexpected_code))) ("}" / (","? (missing_brace_error / unexpected_code)))
indented_dict (Dict): indented_dict (Dict) <-
"{..}" eol nl_indent "{..}" eol nl_indent
dict_line (nl_nodent dict_line)* dict_line (nl_nodent dict_line)*
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
(","? unexpected_code)? (","? unexpected_code)?
dict_line: dict_line <-
(inline_dict_entry ws* "," ws*)+ eol (inline_dict_entry ws* "," ws*)+ eol
/ (inline_dict_entry ws* "," ws*)* dict_entry eol / (inline_dict_entry ws* "," ws*)* dict_entry eol
dict_entry(DictEntry): dict_entry(DictEntry) <-
dict_key (ws* ":" ws* (action / expression))? dict_key (ws* ":" ws* (action / expression))?
inline_dict_entry(DictEntry): inline_dict_entry(DictEntry) <-
dict_key (ws* ":" ws* (inline_block / inline_action / inline_expression)?)? dict_key (ws* ":" ws* (inline_block / inline_action / inline_expression)?)?
dict_key: dict_key <-
text_word / inline_expression text_word / inline_expression
operator_char: ['`~!@$^&*+=|<>?/-] operator_char <- ['`~!@$^&*+=|<>?/-]
ident_char: [a-zA-Z0-9_] / %utf8_char ident_char <- [a-zA-Z0-9_] / %utf8_char
ws: [ %tab] ws <- [ %tab]
escaped_char: escaped_char <-
("\"->'') ( ("\"->'') (
(([xX]->'') ((({[0-9a-fA-F]^2} %number_16) -> tonumber) -> tochar)) (([xX]->'') ((({[0-9a-fA-F]^2} %number_16) -> tonumber) -> tochar))
/ ((([0-9] [0-9]^-2) -> tonumber) -> tochar) / ((([0-9] [0-9]^-2) -> tonumber) -> tochar)

124
nomsu.2.peg
View File

@ -1,14 +1,14 @@
-- Nomsu version 2 -- Nomsu version 2
file: file <-
{:curr_indent: ' '* :} {:curr_indent: ' '* :}
(((action / expression / inline_block / indented_block) eol !.) (((action / expression / inline_block / indented_block) eol !.)
/ file_chunks / empty_block) / file_chunks / empty_block)
{:curr_indent: %nil :} {:curr_indent: %nil :}
!. !.
shebang: "#!" (!"nomsu" [^%nl])* "nomsu" ws+ "-V" ws* {:version: [0-9.]+ :} [^%nl]* shebang <- "#!" (!"nomsu" [^%nl])* "nomsu" ws+ "-V" ws* {:version: [0-9.]+ :} [^%nl]*
file_chunks (FileChunks): file_chunks (FileChunks) <-
{:curr_indent: ' '* :} {:curr_indent: ' '* :}
shebang? comment? blank_lines? shebang? comment? blank_lines?
(top_block (nl_nodent section_division top_block)*) (top_block (nl_nodent section_division top_block)*)
@ -16,115 +16,115 @@ file_chunks (FileChunks):
ws* unexpected_chunk? ws* unexpected_chunk?
{:curr_indent: %nil :} {:curr_indent: %nil :}
top_block (Block): top_block (Block) <-
{:curr_indent: ' '* :} {:curr_indent: ' '* :}
comment? blank_lines? statement (nl_nodent statement)* comment? blank_lines? statement (nl_nodent statement)*
{:curr_indent: %nil :} {:curr_indent: %nil :}
empty_block (Block): empty_block (Block) <-
{:curr_indent: ' '* :} {:curr_indent: ' '* :}
comment? blank_lines? comment? blank_lines?
{:curr_indent: %nil :} {:curr_indent: %nil :}
nodent: (unexpected_indent [^%nl]* / =curr_indent) nodent <- (unexpected_indent [^%nl]* / =curr_indent)
indent: =curr_indent " " indent <- =curr_indent " "
blank_lines: %nl ((nodent comment / ws*) %nl)* blank_lines <- %nl ((nodent comment / ws*) %nl)*
eol: ws* eol_comment? (!. / &%nl) eol <- ws* eol_comment? (!. / &%nl)
nl_nodent: blank_lines nodent nl_nodent <- blank_lines nodent
nl_indent: blank_lines {:curr_indent: indent :} (comment nl_nodent)* nl_indent <- blank_lines {:curr_indent: indent :} (comment nl_nodent)*
comment (Comment): comment (Comment) <-
"#" {~ [^%nl]* (%nl+ (indent -> '') [^%nl]*)* ~} "#" {~ [^%nl]* (%nl+ (indent -> '') [^%nl]*)* ~}
eol_comment (Comment): eol_comment (Comment) <-
"#" {[^%nl]*} "#" {[^%nl]*}
unexpected_code: ws* _unexpected_code unexpected_code <- ws* _unexpected_code
_unexpected_code (Error): _unexpected_code (Error) <-
{:error: {~ [^%nl]+ -> "Couldn't parse this code" ~} :} {:error: {~ [^%nl]+ -> "Couldn't parse this code" ~} :}
unexpected_chunk (Error): unexpected_chunk (Error) <-
{:error: {~ .+ -> "Couldn't parse this code" ~} :} {:error: {~ .+ -> "Couldn't parse this code" ~} :}
unexpected_indent (Error): unexpected_indent (Error) <-
{:error: {~ (=curr_indent ws+) -> "Messed up indentation" ~} :} {:error: {~ (=curr_indent ws+) -> "Messed up indentation" ~} :}
{:hint: {~ '' -> 'Either make sure this line is aligned with the one above it, or make sure the previous line ends with something that uses indentation, like ":" or "(..)"' ~} :} {:hint: {~ '' -> 'Either make sure this line is aligned with the one above it, or make sure the previous line ends with something that uses indentation, like ":" or "(..)"' ~} :}
missing_paren_err (Error): missing_paren_err (Error) <-
{:error: {~ eol -> 'Line ended without finding a closing )-parenthesis' ~} :} {:error: {~ eol -> 'Line ended without finding a closing )-parenthesis' ~} :}
{:hint: {~ '' -> 'Put a ")" here' ~} :} {:hint: {~ '' -> 'Put a ")" here' ~} :}
missing_quote_err (Error): missing_quote_err (Error) <-
{:error: {~ eol -> 'Line ended before finding a closing double quotation mark' ~} :} {:error: {~ eol -> 'Line ended before finding a closing double quotation mark' ~} :}
{:hint: {~ "" -> "Put a quotation mark here" ~} :} {:hint: {~ "" -> "Put a quotation mark here" ~} :}
missing_bracket_error (Error): missing_bracket_error (Error) <-
{:error: {~ eol -> "Line ended before finding a closing ]-bracket" ~} :} {:error: {~ eol -> "Line ended before finding a closing ]-bracket" ~} :}
{:hint: {~ '' -> 'Put a "]" here' ~} :} {:hint: {~ '' -> 'Put a "]" here' ~} :}
missing_brace_error (Error): missing_brace_error (Error) <-
{:error: {~ eol -> "Line ended before finding a closing }-brace" ~} :} {:error: {~ eol -> "Line ended before finding a closing }-brace" ~} :}
{:hint: {~ '' -> 'Put a "}" here' ~} :} {:hint: {~ '' -> 'Put a "}" here' ~} :}
section_division: ("~")^+3 eol section_division <- ("~")^+3 eol
inline_block: inline_block <-
"(" ws* inline_block ws* ")" / raw_inline_block "(" ws* inline_block ws* ")" / raw_inline_block
raw_inline_block (Block): raw_inline_block (Block) <-
":" ws* ((inline_statement (ws* ";" ws* inline_statement)*) / !(eol nl_indent)) ":" ws* ((inline_statement (ws* ";" ws* inline_statement)*) / !(eol nl_indent))
indented_block (Block): indented_block (Block) <-
":" eol nl_indent statement (nl_nodent statement)* ":" eol nl_indent statement (nl_nodent statement)*
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
{:curr_indent: %nil :} {:curr_indent: %nil :}
statement: statement <-
(action / expression) (eol / unexpected_code) (action / expression) (eol / unexpected_code)
inline_statement: (inline_action / inline_expression) inline_statement <- (inline_action / inline_expression)
noindex_inline_expression: noindex_inline_expression <-
number / variable / inline_text / inline_list / inline_dict / inline_nomsu number / variable / inline_text / inline_list / inline_dict / inline_nomsu
/ ( "(" / ( "("
ws* (inline_action / inline_expression) ws* ws* (inline_action / inline_expression) ws*
(ws* ',' ws* (inline_action / inline_expression) ws*)* (ws* ',' ws* (inline_action / inline_expression) ws*)*
(")" / missing_paren_err / unexpected_code) (")" / missing_paren_err / unexpected_code)
) )
inline_expression: index_chain / noindex_inline_expression inline_expression <- index_chain / noindex_inline_expression
indented_expression: indented_expression <-
indented_text / indented_nomsu / indented_list / indented_dict / ({| indented_text / indented_nomsu / indented_list / indented_dict / ({|
"(..)" nl_indent "(..)" nl_indent
(action / expression) (eol / unexpected_code) (action / expression) (eol / unexpected_code)
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
{:curr_indent: %nil :} {:curr_indent: %nil :}
|} -> unpack) |} -> unpack)
expression: expression <-
inline_expression / indented_expression inline_expression / indented_expression
inline_nomsu (EscapedNomsu): "\" (inline_expression / inline_block) inline_nomsu (EscapedNomsu) <- "\" (inline_expression / inline_block)
indented_nomsu (EscapedNomsu): indented_nomsu (EscapedNomsu) <-
"\" (noindex_inline_expression / inline_block / indented_expression / indented_block) "\" (noindex_inline_expression / inline_block / indented_expression / indented_block)
index_chain (IndexChain): index_chain (IndexChain) <-
noindex_inline_expression ("." (text_word / noindex_inline_expression))+ noindex_inline_expression ("." (text_word / noindex_inline_expression))+
-- Actions need either at least 1 word, or at least 2 tokens -- Actions need either at least 1 word, or at least 2 tokens
inline_action (Action): inline_action (Action) <-
!section_division !section_division
( (inline_arg (ws* (inline_arg / word))+) ( (inline_arg (ws* (inline_arg / word))+)
/ (word (ws* (inline_arg / word))*)) / (word (ws* (inline_arg / word))*))
(ws* inline_block)? (ws* inline_block)?
inline_arg: inline_expression / inline_block inline_arg <- inline_expression / inline_block
action (Action): action (Action) <-
!section_division !section_division
( (arg ((nl_nodent "..")? ws* (arg / word))+) ( (arg ((nl_nodent "..")? ws* (arg / word))+)
/ (word ((nl_nodent "..")? ws* (arg / word))*)) / (word ((nl_nodent "..")? ws* (arg / word))*))
arg: expression / inline_block / indented_block arg <- expression / inline_block / indented_block
word: !number { operator_char+ / ident_char+ } word <- !number { operator_char+ / ident_char+ }
text_word (Text): word text_word (Text) <- word
inline_text (Text): inline_text (Text) <-
!(indented_text) !(indented_text)
('"' _inline_text* ('"' / missing_quote_err / unexpected_code)) ('"' _inline_text* ('"' / missing_quote_err / unexpected_code))
_inline_text: _inline_text <-
{~ (('\"' -> '"') / ('\\' -> '\') / escaped_char / [^%nl\"]+)+ ~} {~ (('\"' -> '"') / ('\\' -> '\') / escaped_char / [^%nl\"]+)+ ~}
/ inline_text_interpolation / inline_text_interpolation
inline_text_interpolation: inline_text_interpolation <-
"\" ( "\" (
variable / inline_list / inline_dict / inline_text variable / inline_list / inline_dict / inline_text
/ ("(" / ("("
@ -133,64 +133,64 @@ inline_text_interpolation:
(")" / missing_paren_err / unexpected_code)) (")" / missing_paren_err / unexpected_code))
) )
indented_text (Text): indented_text (Text) <-
'".."' eol %nl {%nl+}? {:curr_indent: indent :} '".."' eol %nl {%nl+}? {:curr_indent: indent :}
(indented_plain_text / text_interpolation / {~ %nl+ (=curr_indent -> "") ~})* (indented_plain_text / text_interpolation / {~ %nl+ (=curr_indent -> "") ~})*
unexpected_code? unexpected_code?
{:curr_indent: %nil :} {:curr_indent: %nil :}
-- Tracking text-lines-within-indented-text as separate objects allows for better debugging line info -- Tracking text-lines-within-indented-text as separate objects allows for better debugging line info
indented_plain_text (Text): indented_plain_text (Text) <-
{~ (("\\" -> "\") / (("\" blank_lines =curr_indent "..") -> "") / (!text_interpolation "\") / [^%nl\]+)+ {~ (("\\" -> "\") / (("\" blank_lines =curr_indent "..") -> "") / (!text_interpolation "\") / [^%nl\]+)+
(%nl+ (=curr_indent -> ""))* ~} (%nl+ (=curr_indent -> ""))* ~}
text_interpolation: text_interpolation <-
inline_text_interpolation / ("\" indented_expression (blank_lines =curr_indent "..")?) inline_text_interpolation / ("\" indented_expression (blank_lines =curr_indent "..")?)
number (Number): (("-"? (([0-9]+ "." [0-9]+) / ("." [0-9]+) / "0x" [0-9a-fA-F]+ / ([0-9]+)))-> tonumber) number (Number) <- (("-"? (([0-9]+ "." [0-9]+) / ("." [0-9]+) / "0x" [0-9a-fA-F]+ / ([0-9]+)))-> tonumber)
-- Variables can be nameless (i.e. just %) and can only contain identifier chars. -- Variables can be nameless (i.e. just %) and can only contain identifier chars.
-- This ensures you don't get weird parsings of `%x+%y` or `%'s thing`. -- This ensures you don't get weird parsings of `%x+%y` or `%'s thing`.
variable (Var): "%" {ident_char*} variable (Var) <- "%" {ident_char*}
inline_list (List): inline_list (List) <-
!('[..]') !('[..]')
"[" ws* "[" ws*
(inline_list_item (ws* ',' ws* inline_list_item)* (ws* ',')?)? ws* (inline_list_item (ws* ',' ws* inline_list_item)* (ws* ',')?)? ws*
("]" / (","? (missing_bracket_error / unexpected_code))) ("]" / (","? (missing_bracket_error / unexpected_code)))
indented_list (List): indented_list (List) <-
"[..]" eol nl_indent "[..]" eol nl_indent
list_line (nl_nodent list_line)* list_line (nl_nodent list_line)*
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
(","? unexpected_code)? (","? unexpected_code)?
list_line: list_line <-
(inline_list_item ws* "," ws*)+ eol (inline_list_item ws* "," ws*)+ eol
/ (inline_list_item ws* "," ws*)* (action / expression) eol / (inline_list_item ws* "," ws*)* (action / expression) eol
inline_list_item: inline_action / inline_expression inline_list_item <- inline_action / inline_expression
inline_dict (Dict): inline_dict (Dict) <-
!('{..}') !('{..}')
"{" ws* "{" ws*
(inline_dict_entry (ws* ',' ws* inline_dict_entry)*)? ws* (inline_dict_entry (ws* ',' ws* inline_dict_entry)*)? ws*
("}" / (","? (missing_brace_error / unexpected_code))) ("}" / (","? (missing_brace_error / unexpected_code)))
indented_dict (Dict): indented_dict (Dict) <-
"{..}" eol nl_indent "{..}" eol nl_indent
dict_line (nl_nodent dict_line)* dict_line (nl_nodent dict_line)*
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
(","? unexpected_code)? (","? unexpected_code)?
dict_line: dict_line <-
(inline_dict_entry ws* "," ws*)+ eol (inline_dict_entry ws* "," ws*)+ eol
/ (inline_dict_entry ws* "," ws*)* dict_entry eol / (inline_dict_entry ws* "," ws*)* dict_entry eol
dict_entry(DictEntry): dict_entry(DictEntry) <-
dict_key (ws* ":" ws* (action / expression))? dict_key (ws* ":" ws* (action / expression))?
inline_dict_entry(DictEntry): inline_dict_entry(DictEntry) <-
dict_key (ws* ":" ws* (inline_action / inline_expression)?)? dict_key (ws* ":" ws* (inline_action / inline_expression)?)?
dict_key: dict_key <-
text_word / inline_expression text_word / inline_expression
operator_char: ['`~!@$^&*+=|<>?/-] operator_char <- ['`~!@$^&*+=|<>?/-]
ident_char: [a-zA-Z0-9_] / %utf8_char ident_char <- [a-zA-Z0-9_] / %utf8_char
ws: [ %tab] ws <- [ %tab]
escaped_char: escaped_char <-
("\"->'') ( ("\"->'') (
(([xX]->'') ((({[0-9a-fA-F]^2} %number_16) -> tonumber) -> tochar)) (([xX]->'') ((({[0-9a-fA-F]^2} %number_16) -> tonumber) -> tochar))
/ ((([0-9] [0-9]^-2) -> tonumber) -> tochar) / ((([0-9] [0-9]^-2) -> tonumber) -> tochar)

132
nomsu.3.peg
View File

@ -1,14 +1,14 @@
-- Nomsu version 3 -- Nomsu version 3
file: file <-
{:curr_indent: ' '* :} {:curr_indent: ' '* :}
(((action / expression / inline_block / indented_block) eol !.) (((action / expression / inline_block / indented_block) eol !.)
/ file_chunks / empty_block) / file_chunks / empty_block)
{:curr_indent: %nil :} {:curr_indent: %nil :}
!. !.
shebang: "#!" (!"nomsu" [^%nl])* "nomsu" ws+ "-V" ws* {:version: [0-9.]+ :} [^%nl]* shebang <- "#!" (!"nomsu" [^%nl])* "nomsu" ws+ "-V" ws* {:version: [0-9.]+ :} [^%nl]*
file_chunks (FileChunks): file_chunks (FileChunks) <-
{:curr_indent: ' '* :} {:curr_indent: ' '* :}
shebang? comment? blank_lines? shebang? comment? blank_lines?
(top_block (nl_nodent section_division top_block)*) (top_block (nl_nodent section_division top_block)*)
@ -16,122 +16,122 @@ file_chunks (FileChunks):
ws* unexpected_chunk? ws* unexpected_chunk?
{:curr_indent: %nil :} {:curr_indent: %nil :}
top_block (Block): top_block (Block) <-
{:curr_indent: ' '* :} {:curr_indent: ' '* :}
comment? blank_lines? statement (nl_nodent statement)* comment? blank_lines? statement (nl_nodent statement)*
{:curr_indent: %nil :} {:curr_indent: %nil :}
empty_block (Block): empty_block (Block) <-
{:curr_indent: ' '* :} {:curr_indent: ' '* :}
comment? blank_lines? comment? blank_lines?
{:curr_indent: %nil :} {:curr_indent: %nil :}
nodent: (unexpected_indent [^%nl]* / =curr_indent) nodent <- (unexpected_indent [^%nl]* / =curr_indent)
indent: =curr_indent " " indent <- =curr_indent " "
blank_lines: %nl ((nodent comment / ws*) %nl)* blank_lines <- %nl ((nodent comment / ws*) %nl)*
eol: ws* eol_comment? (!. / &%nl) eol <- ws* eol_comment? (!. / &%nl)
nl_nodent: blank_lines nodent nl_nodent <- blank_lines nodent
nl_indent: blank_lines {:curr_indent: indent :} (comment nl_nodent)* nl_indent <- blank_lines {:curr_indent: indent :} (comment nl_nodent)*
comment (Comment): comment (Comment) <-
"#" {~ [^%nl]* (%nl+ (indent -> '') [^%nl]*)* ~} "#" {~ [^%nl]* (%nl+ (indent -> '') [^%nl]*)* ~}
eol_comment (Comment): eol_comment (Comment) <-
"#" {[^%nl]*} "#" {[^%nl]*}
unexpected_code: ws* _unexpected_code unexpected_code <- ws* _unexpected_code
_unexpected_code (Error): _unexpected_code (Error) <-
{:error: {~ [^%nl]+ -> "Couldn't parse this code" ~} :} {:error: {~ [^%nl]+ -> "Couldn't parse this code" ~} :}
unexpected_chunk (Error): unexpected_chunk (Error) <-
{:error: {~ .+ -> "Couldn't parse this code" ~} :} {:error: {~ .+ -> "Couldn't parse this code" ~} :}
unexpected_indent (Error): unexpected_indent (Error) <-
{:error: {~ (=curr_indent ws+) -> "Messed up indentation" ~} :} {:error: {~ (=curr_indent ws+) -> "Messed up indentation" ~} :}
{:hint: {~ '' -> 'Either make sure this line is aligned with the one above it, or make sure the previous line ends with something that uses indentation, like ":" or "(..)"' ~} :} {:hint: {~ '' -> 'Either make sure this line is aligned with the one above it, or make sure the previous line ends with something that uses indentation, like ":" or "(..)"' ~} :}
missing_paren_err (Error): missing_paren_err (Error) <-
{:error: {~ eol -> 'Line ended without finding a closing )-parenthesis' ~} :} {:error: {~ eol -> 'Line ended without finding a closing )-parenthesis' ~} :}
{:hint: {~ '' -> 'Put a ")" here' ~} :} {:hint: {~ '' -> 'Put a ")" here' ~} :}
missing_quote_err (Error): missing_quote_err (Error) <-
{:error: {~ eol -> 'Line ended before finding a closing double quotation mark' ~} :} {:error: {~ eol -> 'Line ended before finding a closing double quotation mark' ~} :}
{:hint: {~ "" -> "Put a quotation mark here" ~} :} {:hint: {~ "" -> "Put a quotation mark here" ~} :}
missing_bracket_error (Error): missing_bracket_error (Error) <-
{:error: {~ eol -> "Line ended before finding a closing ]-bracket" ~} :} {:error: {~ eol -> "Line ended before finding a closing ]-bracket" ~} :}
{:hint: {~ '' -> 'Put a "]" here' ~} :} {:hint: {~ '' -> 'Put a "]" here' ~} :}
missing_brace_error (Error): missing_brace_error (Error) <-
{:error: {~ eol -> "Line ended before finding a closing }-brace" ~} :} {:error: {~ eol -> "Line ended before finding a closing }-brace" ~} :}
{:hint: {~ '' -> 'Put a "}" here' ~} :} {:hint: {~ '' -> 'Put a "}" here' ~} :}
section_division: ("~")^+3 eol section_division <- ("~")^+3 eol
inline_block: inline_block <-
"(" ws* inline_block ws* ")" / raw_inline_block "(" ws* inline_block ws* ")" / raw_inline_block
raw_inline_block (Block): raw_inline_block (Block) <-
(!"::") ":" ws* ((inline_statement (ws* ";" ws* inline_statement)*) / !(eol nl_indent)) (!"::") ":" ws* ((inline_statement (ws* ";" ws* inline_statement)*) / !(eol nl_indent))
indented_block (Block): indented_block (Block) <-
":" eol nl_indent statement (nl_nodent statement)* ":" eol nl_indent statement (nl_nodent statement)*
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
{:curr_indent: %nil :} {:curr_indent: %nil :}
statement: statement <-
(action / expression) (eol / unexpected_code) (action / expression) (eol / unexpected_code)
inline_statement: (inline_action / inline_expression) inline_statement <- (inline_action / inline_expression)
noindex_inline_expression: noindex_inline_expression <-
number / variable / inline_text / inline_list / inline_dict / inline_nomsu number / variable / inline_text / inline_list / inline_dict / inline_nomsu
/ ( "(" / ( "("
ws* (inline_action / inline_expression) ws* ws* (inline_action / inline_expression) ws*
(ws* ',' ws* (inline_action / inline_expression) ws*)* (ws* ',' ws* (inline_action / inline_expression) ws*)*
(")" / missing_paren_err / unexpected_code) (")" / missing_paren_err / unexpected_code)
) )
inline_expression: index_chain / noindex_inline_expression inline_expression <- index_chain / noindex_inline_expression
indented_expression: indented_expression <-
indented_text / indented_nomsu / indented_list / indented_dict / ({| indented_text / indented_nomsu / indented_list / indented_dict / ({|
"(..)" nl_indent "(..)" nl_indent
(action / expression) (eol / unexpected_code) (action / expression) (eol / unexpected_code)
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
{:curr_indent: %nil :} {:curr_indent: %nil :}
|} -> unpack) |} -> unpack)
expression: expression <-
inline_expression / indented_expression inline_expression / indented_expression
inline_nomsu (EscapedNomsu): "\" (inline_expression / inline_block) inline_nomsu (EscapedNomsu) <- "\" (inline_expression / inline_block)
indented_nomsu (EscapedNomsu): indented_nomsu (EscapedNomsu) <-
"\" (noindex_inline_expression / inline_block / indented_expression / indented_block) "\" (noindex_inline_expression / inline_block / indented_expression / indented_block)
index_chain (IndexChain): index_chain (IndexChain) <-
noindex_inline_expression ("." (text_word / noindex_inline_expression))+ noindex_inline_expression ("." (text_word / noindex_inline_expression))+
inline_action: inline_methodcall / _inline_action inline_action <- inline_methodcall / _inline_action
inline_methodcall: inline_methodcall <-
inline_arg ws* "::" ws* _inline_action inline_arg ws* "::" ws* _inline_action
-- Actions need either at least 1 word, or at least 2 tokens -- Actions need either at least 1 word, or at least 2 tokens
_inline_action (Action): _inline_action (Action) <-
!section_division !section_division
( (inline_arg (ws* (inline_arg / word))+) ( (inline_arg (ws* (inline_arg / word))+)
/ (word (ws* (inline_arg / word))*)) / (word (ws* (inline_arg / word))*))
(ws* inline_block)? (ws* inline_block)?
inline_arg: inline_expression / inline_block inline_arg <- inline_expression / inline_block
action: methodcall / _action action <- methodcall / _action
methodcall: methodcall <-
arg (nl_nodent "..")? ws* "::" (nl_nodent "..")? ws* _action arg (nl_nodent "..")? ws* "::" (nl_nodent "..")? ws* _action
_action (Action): _action (Action) <-
!section_division !section_division
( (arg ((nl_nodent "..")? ws* (arg / word))+) ( (arg ((nl_nodent "..")? ws* (arg / word))+)
/ (word ((nl_nodent "..")? ws* (arg / word))*)) / (word ((nl_nodent "..")? ws* (arg / word))*))
arg: expression / inline_block / indented_block arg <- expression / inline_block / indented_block
word: !number { operator_char+ / ident_char+ } word <- !number { operator_char+ / ident_char+ }
text_word (Text): word text_word (Text) <- word
inline_text (Text): inline_text (Text) <-
!(indented_text) !(indented_text)
('"' _inline_text* ('"' / missing_quote_err / unexpected_code)) ('"' _inline_text* ('"' / missing_quote_err / unexpected_code))
_inline_text: _inline_text <-
{~ (('\"' -> '"') / ('\\' -> '\') / escaped_char / [^%nl\"]+)+ ~} {~ (('\"' -> '"') / ('\\' -> '\') / escaped_char / [^%nl\"]+)+ ~}
/ inline_text_interpolation / inline_text_interpolation
inline_text_interpolation: inline_text_interpolation <-
"\" ( "\" (
variable / inline_list / inline_dict / inline_text variable / inline_list / inline_dict / inline_text
/ ("(" / ("("
@ -140,64 +140,64 @@ inline_text_interpolation:
(")" / missing_paren_err / unexpected_code)) (")" / missing_paren_err / unexpected_code))
) )
indented_text (Text): indented_text (Text) <-
'".."' eol %nl {%nl+}? {:curr_indent: indent :} '".."' eol %nl {%nl+}? {:curr_indent: indent :}
(indented_plain_text / text_interpolation / {~ %nl+ (=curr_indent -> "") ~})* (indented_plain_text / text_interpolation / {~ %nl+ (=curr_indent -> "") ~})*
unexpected_code? unexpected_code?
{:curr_indent: %nil :} {:curr_indent: %nil :}
-- Tracking text-lines-within-indented-text as separate objects allows for better debugging line info -- Tracking text-lines-within-indented-text as separate objects allows for better debugging line info
indented_plain_text (Text): indented_plain_text (Text) <-
{~ (("\\" -> "\") / (("\" blank_lines =curr_indent "..") -> "") / (!text_interpolation "\") / [^%nl\]+)+ {~ (("\\" -> "\") / (("\" blank_lines =curr_indent "..") -> "") / (!text_interpolation "\") / [^%nl\]+)+
(%nl+ (=curr_indent -> ""))* ~} (%nl+ (=curr_indent -> ""))* ~}
text_interpolation: text_interpolation <-
inline_text_interpolation / ("\" indented_expression (blank_lines =curr_indent "..")?) inline_text_interpolation / ("\" indented_expression (blank_lines =curr_indent "..")?)
number (Number): (("-"? (([0-9]+ "." [0-9]+) / ("." [0-9]+) / "0x" [0-9a-fA-F]+ / ([0-9]+)))-> tonumber) number (Number) <- (("-"? (([0-9]+ "." [0-9]+) / ("." [0-9]+) / "0x" [0-9a-fA-F]+ / ([0-9]+)))-> tonumber)
-- Variables can be nameless (i.e. just %) and can only contain identifier chars. -- Variables can be nameless (i.e. just %) and can only contain identifier chars.
-- This ensures you don't get weird parsings of `%x+%y` or `%'s thing`. -- This ensures you don't get weird parsings of `%x+%y` or `%'s thing`.
variable (Var): "%" {ident_char*} variable (Var) <- "%" {ident_char*}
inline_list (List): inline_list (List) <-
!('[..]') !('[..]')
"[" ws* "[" ws*
(inline_list_item (ws* ',' ws* inline_list_item)* (ws* ',')?)? ws* (inline_list_item (ws* ',' ws* inline_list_item)* (ws* ',')?)? ws*
("]" / (","? (missing_bracket_error / unexpected_code))) ("]" / (","? (missing_bracket_error / unexpected_code)))
indented_list (List): indented_list (List) <-
"[..]" eol nl_indent "[..]" eol nl_indent
list_line (nl_nodent list_line)* list_line (nl_nodent list_line)*
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
(","? unexpected_code)? (","? unexpected_code)?
list_line: list_line <-
(inline_list_item ws* "," ws*)+ eol (inline_list_item ws* "," ws*)+ eol
/ (inline_list_item ws* "," ws*)* (action / expression) eol / (inline_list_item ws* "," ws*)* (action / expression) eol
inline_list_item: inline_action / inline_expression inline_list_item <- inline_action / inline_expression
inline_dict (Dict): inline_dict (Dict) <-
!('{..}') !('{..}')
"{" ws* "{" ws*
(inline_dict_entry (ws* ',' ws* inline_dict_entry)*)? ws* (inline_dict_entry (ws* ',' ws* inline_dict_entry)*)? ws*
("}" / (","? (missing_brace_error / unexpected_code))) ("}" / (","? (missing_brace_error / unexpected_code)))
indented_dict (Dict): indented_dict (Dict) <-
"{..}" eol nl_indent "{..}" eol nl_indent
dict_line (nl_nodent dict_line)* dict_line (nl_nodent dict_line)*
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
(","? unexpected_code)? (","? unexpected_code)?
dict_line: dict_line <-
(inline_dict_entry ws* "," ws*)+ eol (inline_dict_entry ws* "," ws*)+ eol
/ (inline_dict_entry ws* "," ws*)* dict_entry eol / (inline_dict_entry ws* "," ws*)* dict_entry eol
dict_entry(DictEntry): dict_entry(DictEntry) <-
dict_key (ws* ":" ws* (action / expression))? dict_key (ws* ":" ws* (action / expression))?
inline_dict_entry(DictEntry): inline_dict_entry(DictEntry) <-
dict_key (ws* ":" ws* (inline_action / inline_expression)?)? dict_key (ws* ":" ws* (inline_action / inline_expression)?)?
dict_key: dict_key <-
text_word / inline_expression text_word / inline_expression
operator_char: ['`~!@$^&*+=|<>?/-] operator_char <- ['`~!@$^&*+=|<>?/-]
ident_char: [a-zA-Z0-9_] / %utf8_char ident_char <- [a-zA-Z0-9_] / %utf8_char
ws: [ %tab] ws <- [ %tab]
escaped_char: escaped_char <-
("\"->'') ( ("\"->'') (
(([xX]->'') ((({[0-9a-fA-F]^2} %number_16) -> tonumber) -> tochar)) (([xX]->'') ((({[0-9a-fA-F]^2} %number_16) -> tonumber) -> tochar))
/ ((([0-9] [0-9]^-2) -> tonumber) -> tochar) / ((([0-9] [0-9]^-2) -> tonumber) -> tochar)

148
nomsu.4.peg
View File

@ -1,16 +1,16 @@
-- Nomsu version 4 -- Nomsu version 4
file: file <-
{:curr_indent: ' '* :} {:curr_indent: ' '* :}
(((action / expression / inline_block / indented_block) eol !.) (((action / expression / inline_block / indented_block) eol !.)
/ file_chunks / empty_block) / file_chunks / empty_block)
{:curr_indent: %nil :} {:curr_indent: %nil :}
!. !.
shebang: "#!" (!"nomsu" [^%nl])* "nomsu" ws+ "-V" ws* [0-9.]+ [^%nl]* (%nl / !.) shebang <- "#!" (!"nomsu" [^%nl])* "nomsu" ws+ "-V" ws* [0-9.]+ [^%nl]* (%nl / !.)
eof: !. eof <- !.
file_chunks (FileChunks): file_chunks (FileChunks) <-
{:curr_indent: ' '* :} {:curr_indent: ' '* :}
{:shebang: shebang :}? {:shebang: shebang :}?
(top_block (nl_nodent section_division top_block)*) (top_block (nl_nodent section_division top_block)*)
@ -18,132 +18,132 @@ file_chunks (FileChunks):
ws* unexpected_chunk? ws* unexpected_chunk?
{:curr_indent: %nil :} {:curr_indent: %nil :}
top_block (Block): top_block (Block) <-
{:curr_indent: ' '* :} {:curr_indent: ' '* :}
comment? blank_lines? statement (nl_nodent statement)* comment? blank_lines? statement (nl_nodent statement)*
{:curr_indent: %nil :} {:curr_indent: %nil :}
empty_block (Block): empty_block (Block) <-
{:curr_indent: ' '* :} {:curr_indent: ' '* :}
comment? blank_lines? comment? blank_lines?
{:curr_indent: %nil :} {:curr_indent: %nil :}
nodent: (unexpected_indent [^%nl]* / =curr_indent) nodent <- (unexpected_indent [^%nl]* / =curr_indent)
indent: {~ =curr_indent (ws / (%tab -> ' '))+ ~} indent <- {~ =curr_indent (ws / (%tab -> ' '))+ ~}
blank_lines: %nl ((nodent comment / ws*) %nl)* blank_lines <- %nl ((nodent comment / ws*) %nl)*
eol: ws* eol_comment? (!. / &%nl) eol <- ws* eol_comment? (!. / &%nl)
nl_nodent: blank_lines nodent nl_nodent <- blank_lines nodent
nl_indent: blank_lines tab_error? {:curr_indent: indent :} (comment nl_nodent)* nl_indent <- blank_lines tab_error? {:curr_indent: indent :} (comment nl_nodent)*
comment (Comment): comment (Comment) <-
"#" {~ [^%nl]* (%nl+ (indent -> '') [^%nl]*)* (%nl &%nl)* ~} "#" {~ [^%nl]* (%nl+ (indent -> '') [^%nl]*)* (%nl &%nl)* ~}
eol_comment (Comment): eol_comment (Comment) <-
"#" {[^%nl]*} "#" {[^%nl]*}
unexpected_code: ws* _unexpected_code unexpected_code <- ws* _unexpected_code
_unexpected_code (Error): _unexpected_code (Error) <-
{:error: {~ [^%nl]+ -> "Couldn't parse this code" ~} :} {:error: {~ [^%nl]+ -> "Couldn't parse this code" ~} :}
unexpected_chunk (Error): unexpected_chunk (Error) <-
{:error: {~ .+ -> "Couldn't parse this code" ~} :} {:error: {~ .+ -> "Couldn't parse this code" ~} :}
unexpected_indent (Error): unexpected_indent (Error) <-
{:error: {~ (=curr_indent ws+) -> "Messed up indentation" ~} :} {:error: {~ (=curr_indent ws+) -> "Messed up indentation" ~} :}
{:hint: {~ '' -> 'Either make sure this line is aligned with the one above it, or make sure the previous line ends with something that uses indentation, like ":" or "(..)"' ~} :} {:hint: {~ '' -> 'Either make sure this line is aligned with the one above it, or make sure the previous line ends with something that uses indentation, like ":" or "(..)"' ~} :}
missing_paren_err (Error): missing_paren_err (Error) <-
{:error: {~ eol -> 'Line ended without finding a closing )-parenthesis' ~} :} {:error: {~ eol -> 'Line ended without finding a closing )-parenthesis' ~} :}
{:hint: {~ '' -> 'Put a ")" here' ~} :} {:hint: {~ '' -> 'Put a ")" here' ~} :}
missing_quote_err (Error): missing_quote_err (Error) <-
{:error: {~ eol -> 'Line ended before finding a closing double quotation mark' ~} :} {:error: {~ eol -> 'Line ended before finding a closing double quotation mark' ~} :}
{:hint: {~ "" -> "Put a quotation mark here" ~} :} {:hint: {~ "" -> "Put a quotation mark here" ~} :}
missing_bracket_error (Error): missing_bracket_error (Error) <-
{:error: {~ eol -> "Line ended before finding a closing ]-bracket" ~} :} {:error: {~ eol -> "Line ended before finding a closing ]-bracket" ~} :}
{:hint: {~ '' -> 'Put a "]" here' ~} :} {:hint: {~ '' -> 'Put a "]" here' ~} :}
missing_brace_error (Error): missing_brace_error (Error) <-
{:error: {~ eol -> "Line ended before finding a closing }-brace" ~} :} {:error: {~ eol -> "Line ended before finding a closing }-brace" ~} :}
{:hint: {~ '' -> 'Put a "}" here' ~} :} {:hint: {~ '' -> 'Put a "}" here' ~} :}
disallowed_interpolation (Error): disallowed_interpolation (Error) <-
{:error: {~ ("\" ('\:' / '(..)' / '[..]' / '{..}') (%nl (&(%nl) / =curr_indent ' ' [^%nl]*))*) -> {:error: {~ ("\" ('\:' / '(..)' / '[..]' / '{..}') (%nl (&(%nl) / =curr_indent ' ' [^%nl]*))*) ->
"Sorry, indented text interpolations are not currently supported on the first line of multi-line text." ~} :} "Sorry, indented text interpolations are not currently supported on the first line of multi-line text." ~} :}
{:hint: {~ '' -> 'Move the code for the first line of text to the next line by ending this line with "\" and starting the next line indented with "..", followed by the code for the first line.' ~} :} {:hint: {~ '' -> 'Move the code for the first line of text to the next line by ending this line with "\" and starting the next line indented with "..", followed by the code for the first line.' ~} :}
tab_error (Error): tab_error (Error) <-
&(=curr_indent %tab) &(=curr_indent %tab)
{:error: {~ '' -> 'Tabs are not allowed for indentation.' ~} :} {:error: {~ '' -> 'Tabs are not allowed for indentation.' ~} :}
{:hint: {~ '' -> 'Use spaces instead of tabs.' ~} :} {:hint: {~ '' -> 'Use spaces instead of tabs.' ~} :}
section_division: ("~")^+3 eol section_division <- ("~")^+3 eol
inline_block: inline_block <-
"(" ws* inline_block ws* (eof / ")") / raw_inline_block "(" ws* inline_block ws* (eof / ")") / raw_inline_block
raw_inline_block (Block): raw_inline_block (Block) <-
(!"::") ":" ws* ((inline_statement (ws* ";" ws* inline_statement)*) / !(eol nl_indent)) (!"::") ":" ws* ((inline_statement (ws* ";" ws* inline_statement)*) / !(eol nl_indent))
indented_block (Block): indented_block (Block) <-
":" eol nl_indent statement (nl_nodent statement)* ":" eol nl_indent statement (nl_nodent statement)*
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
{:curr_indent: %nil :} {:curr_indent: %nil :}
statement: statement <-
(action / expression) (eol / unexpected_code) (action / expression) (eol / unexpected_code)
inline_statement: (inline_action / inline_expression) inline_statement <- (inline_action / inline_expression)
noindex_inline_expression: noindex_inline_expression <-
number / variable / inline_text / inline_list / inline_dict / inline_nomsu number / variable / inline_text / inline_list / inline_dict / inline_nomsu
/ ( "(" / ( "("
ws* (inline_action / inline_expression) ws* ws* (inline_action / inline_expression) ws*
(ws* ',' ws* (inline_action / inline_expression) ws*)* (ws* ',' ws* (inline_action / inline_expression) ws*)*
(")" / eof / missing_paren_err / unexpected_code) (")" / eof / missing_paren_err / unexpected_code)
) )
inline_expression: index_chain / noindex_inline_expression inline_expression <- index_chain / noindex_inline_expression
indented_expression: indented_expression <-
indented_text / indented_nomsu / indented_list / indented_dict / ({| indented_text / indented_nomsu / indented_list / indented_dict / ({|
"(..)" eol nl_indent "(..)" eol nl_indent
(action / expression) (eol / unexpected_code) (action / expression) (eol / unexpected_code)
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
{:curr_indent: %nil :} {:curr_indent: %nil :}
|} -> unpack) |} -> unpack)
expression: expression <-
inline_expression / indented_expression inline_expression / indented_expression
inline_nomsu (EscapedNomsu): "\" (inline_expression / inline_block) inline_nomsu (EscapedNomsu) <- "\" (inline_expression / inline_block)
indented_nomsu (EscapedNomsu): indented_nomsu (EscapedNomsu) <-
"\" (noindex_inline_expression / inline_block / indented_expression / indented_block) "\" (noindex_inline_expression / inline_block / indented_expression / indented_block)
index_chain (IndexChain): index_chain (IndexChain) <-
noindex_inline_expression ("." (text_word / noindex_inline_expression))+ noindex_inline_expression ("." (text_word / noindex_inline_expression))+
inline_action: inline_methodcall / _inline_action inline_action <- inline_methodcall / _inline_action
inline_methodcall (MethodCall): inline_methodcall (MethodCall) <-
(inline_expression / "(" inline_block ")") ws* "::" ws* _inline_action (inline_expression / "(" inline_block ")") ws* "::" ws* _inline_action
-- Actions need either at least 1 word, or at least 2 tokens -- Actions need either at least 1 word, or at least 2 tokens
_inline_action (Action): _inline_action (Action) <-
!section_division !section_division
( (inline_arg (ws* (inline_arg / word))+) ( (inline_arg (ws* (inline_arg / word))+)
/ (word (ws* (inline_arg / word))*)) / (word (ws* (inline_arg / word))*))
(ws* inline_block)? (ws* inline_block)?
inline_arg: inline_expression / inline_block / "(" ws* ")" inline_arg <- inline_expression / inline_block / "(" ws* ")"
action: methodcall / _action action <- methodcall / _action
methodcall (MethodCall): methodcall (MethodCall) <-
(expression / "(" inline_block ")" / indented_block) (expression / "(" inline_block ")" / indented_block)
((ws* "\")? eol nl_nodent "..")? ws* "::" ((ws* "\")? eol nl_nodent "..")? ws* ((ws* "\")? eol nl_nodent "..")? ws* "::" ((ws* "\")? eol nl_nodent "..")? ws*
_action _action
_action (Action): _action (Action) <-
!section_division !section_division
( (arg (((ws* "\")? eol nl_nodent "..")? ws* (arg / word))+) ( (arg (((ws* "\")? eol nl_nodent "..")? ws* (arg / word))+)
/ (word (((ws* "\")? eol nl_nodent "..")? ws* (arg / word))*)) / (word (((ws* "\")? eol nl_nodent "..")? ws* (arg / word))*))
arg: expression / inline_block / indented_block / "(" ws* ")" arg <- expression / inline_block / indented_block / "(" ws* ")"
word: !number { operator_char+ / ident_char+ } word <- !number { operator_char+ / ident_char+ }
text_word (Text): word text_word (Text) <- word
inline_text (Text): inline_text (Text) <-
!(indented_text) !(indented_text)
'"' _inline_text* ('"' / eof / missing_quote_err / unexpected_code) '"' _inline_text* ('"' / eof / missing_quote_err / unexpected_code)
_inline_text: _inline_text <-
{~ (('\"' -> '"') / ('\\' -> '\') / escaped_char / text_char+)+ ~} {~ (('\"' -> '"') / ('\\' -> '\') / escaped_char / text_char+)+ ~}
/ inline_text_interpolation / illegal_char / inline_text_interpolation / illegal_char
inline_text_interpolation: inline_text_interpolation <-
"\" ( "\" (
variable / inline_list / inline_dict variable / inline_list / inline_dict
/ ("(" / ("("
@ -152,14 +152,14 @@ inline_text_interpolation:
(")" / eof / missing_paren_err / unexpected_code)) (")" / eof / missing_paren_err / unexpected_code))
) )
text_char: %utf8_char / !["\] %print / %tab text_char <- %utf8_char / !["\] %print / %tab
illegal_char (Error): illegal_char (Error) <-
{:error: {~ (!(%nl / %tab / %print) .) -> "Illegal unprintable character here (it may not be visible, but it's there)" ~} :} {:error: {~ (!(%nl / %tab / %print) .) -> "Illegal unprintable character here (it may not be visible, but it's there)" ~} :}
{:hint: {~ '' -> "This sort of thing can happen when copying and pasting code. Try deleting and retyping the code." ~} :} {:hint: {~ '' -> "This sort of thing can happen when copying and pasting code. Try deleting and retyping the code." ~} :}
nonterminal_quote: nonterminal_quote <-
'"' &([^%nl] / %nl+ =curr_indent) '"' &([^%nl] / %nl+ =curr_indent)
indented_text (Text): indented_text (Text) <-
'"' '"'
_inline_text* _inline_text*
(('\' %nl+ {:curr_indent: indent :} ('..')?) (('\' %nl+ {:curr_indent: indent :} ('..')?)
@ -168,68 +168,68 @@ indented_text (Text):
('"' eol / eof / missing_quote_err) ('"' eol / eof / missing_quote_err)
{:curr_indent: %nil :} {:curr_indent: %nil :}
-- Tracking text-lines-within-indented-text as separate objects allows for better debugging line info -- Tracking text-lines-within-indented-text as separate objects allows for better debugging line info
indented_plain_text (Text): indented_plain_text (Text) <-
{~ {~
((("\" blank_lines =curr_indent "..") -> "") / ('\\' -> '\') ((("\" blank_lines =curr_indent "..") -> "") / ('\\' -> '\')
/ (!text_interpolation (escaped_char / '\')) / (!text_interpolation (escaped_char / '\'))
/ (nonterminal_quote / text_char)+)+ / (nonterminal_quote / text_char)+)+
~} ~}
text_interpolation: text_interpolation <-
inline_text_interpolation / ("\" (indented_expression / indented_block) (blank_lines =curr_indent "..")?) inline_text_interpolation / ("\" (indented_expression / indented_block) (blank_lines =curr_indent "..")?)
number (Number): number (Number) <-
(&("-"? "0x" [0-9a-fA-F]+) {:hex: '' -> 'yes' :})? (&("-"? "0x" [0-9a-fA-F]+) {:hex: '' -> 'yes' :})?
(("-"? (([0-9]+ "." [0-9]+) / ("." [0-9]+) / "0x" [0-9a-fA-F]+ / ([0-9]+)))-> tonumber) (("-"? (([0-9]+ "." [0-9]+) / ("." [0-9]+) / "0x" [0-9a-fA-F]+ / ([0-9]+)))-> tonumber)
-- Variables can be nameless (i.e. just %) and can only contain identifier chars. -- Variables can be nameless (i.e. just %) and can only contain identifier chars.
-- This ensures you don't get weird parsings of `%x+%y` or `%'s thing`. -- This ensures you don't get weird parsings of `%x+%y` or `%'s thing`.
variable (Var): "%" {ident_char*} variable (Var) <- "%" {ident_char*}
inline_list (List): inline_list (List) <-
!('[..]') !('[..]')
"[" ws* "[" ws*
(inline_list_item (ws* ',' ws* inline_list_item)* (ws* ',')?)? ws* (inline_list_item (ws* ',' ws* inline_list_item)* (ws* ',')?)? ws*
("]" / eof / (","? (missing_bracket_error / unexpected_code))) ("]" / eof / (","? (missing_bracket_error / unexpected_code)))
indented_list (List): indented_list (List) <-
"[..]" eol nl_indent "[..]" eol nl_indent
list_line (nl_nodent list_line)* list_line (nl_nodent list_line)*
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
(","? unexpected_code)? (","? unexpected_code)?
list_line: list_line <-
(inline_list_item ws* "," ws*)+ eol (inline_list_item ws* "," ws*)+ eol
/ (inline_list_item ws* "," ws*)* (action / expression / inline_block / indented_block) eol / (inline_list_item ws* "," ws*)* (action / expression / inline_block / indented_block) eol
inline_list_item: inline_action / inline_expression / inline_block inline_list_item <- inline_action / inline_expression / inline_block
inline_dict (Dict): inline_dict (Dict) <-
!('{..}') !('{..}')
"{" ws* "{" ws*
(inline_dict_entry (ws* ',' ws* inline_dict_entry)*)? ws* (inline_dict_entry (ws* ',' ws* inline_dict_entry)*)? ws*
("}" / eof / (","? (missing_brace_error / unexpected_code))) ("}" / eof / (","? (missing_brace_error / unexpected_code)))
indented_dict (Dict): indented_dict (Dict) <-
"{..}" eol nl_indent "{..}" eol nl_indent
dict_line (nl_nodent dict_line)* dict_line (nl_nodent dict_line)*
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
(","? unexpected_code)? (","? unexpected_code)?
dict_line: dict_line <-
(inline_dict_entry ws* "," ws*)+ eol (inline_dict_entry ws* "," ws*)+ eol
/ (inline_dict_entry ws* "," ws*)* dict_entry eol / (inline_dict_entry ws* "," ws*)* dict_entry eol
_dict_entry(DictEntry): _dict_entry(DictEntry) <-
dict_key (ws* ":" ws* (action / expression))? dict_key (ws* ":" ws* (action / expression))?
dict_entry: dict_entry <-
_dict_entry / inline_block / indented_block _dict_entry / inline_block / indented_block
_inline_dict_entry(DictEntry): _inline_dict_entry(DictEntry) <-
dict_key (ws* ":" ws* (inline_action / inline_expression)?)? dict_key (ws* ":" ws* (inline_action / inline_expression)?)?
inline_dict_entry: inline_dict_entry <-
_inline_dict_entry / inline_block _inline_dict_entry / inline_block
dict_key: dict_key <-
text_word / inline_expression text_word / inline_expression
operator_char: ['`~!@$^&*+=|<>?/-] operator_char <- ['`~!@$^&*+=|<>?/-]
ident_char: [a-zA-Z0-9_] / %utf8_char ident_char <- [a-zA-Z0-9_] / %utf8_char
ws: " " ws <- " "
escaped_char: escaped_char <-
("\"->'') ( ("\"->'') (
(([xX]->'') ((({[0-9a-fA-F]^2} %number_16) -> tonumber) -> tochar)) (([xX]->'') ((({[0-9a-fA-F]^2} %number_16) -> tonumber) -> tochar))
/ ((([0-9] [0-9]^-2) -> tonumber) -> tochar) / ((([0-9] [0-9]^-2) -> tonumber) -> tochar)

156
nomsu.5.peg
View File

@ -1,16 +1,16 @@
-- Nomsu version 5 -- Nomsu version 5
file: file <-
{:curr_indent: ' '* :} {:curr_indent: ' '* :}
(((methodcall / action / expression / inline_block / indented_block) eol !.) (((methodcall / action / expression / inline_block / indented_block) eol !.)
/ file_chunks / empty_block) / file_chunks / empty_block)
{:curr_indent: %nil :} {:curr_indent: %nil :}
!. !.
shebang: "#!" (!"nomsu" [^%nl])* "nomsu" ws+ "-V" ws* [0-9.]+ [^%nl]* (%nl / !.) shebang <- "#!" (!"nomsu" [^%nl])* "nomsu" ws+ "-V" ws* [0-9.]+ [^%nl]* (%nl / !.)
eof: !. eof <- !.
file_chunks (FileChunks): file_chunks (FileChunks) <-
{:curr_indent: ' '* :} {:curr_indent: ' '* :}
{:shebang: shebang :}? {:shebang: shebang :}?
(top_block (nl_nodent section_division top_block)*) (top_block (nl_nodent section_division top_block)*)
@ -18,117 +18,117 @@ file_chunks (FileChunks):
ws* unexpected_chunk? ws* unexpected_chunk?
{:curr_indent: %nil :} {:curr_indent: %nil :}
top_block (Block): top_block (Block) <-
{:curr_indent: ' '* :} {:curr_indent: ' '* :}
comment? blank_lines? statement (nl_nodent statement)* comment? blank_lines? statement (nl_nodent statement)*
{:curr_indent: %nil :} {:curr_indent: %nil :}
empty_block (Block): empty_block (Block) <-
{:curr_indent: ' '* :} {:curr_indent: ' '* :}
comment? blank_lines? comment? blank_lines?
{:curr_indent: %nil :} {:curr_indent: %nil :}
nodent: (unexpected_indent [^%nl]* / =curr_indent) nodent <- (unexpected_indent [^%nl]* / =curr_indent)
indent: {~ =curr_indent (ws / (%tab -> ' '))+ ~} indent <- {~ =curr_indent (ws / (%tab -> ' '))+ ~}
blank_lines: %nl ((nodent comment / ws*) %nl)* blank_lines <- %nl ((nodent comment / ws*) %nl)*
eol: ws* (!. / &%nl) eol <- ws* (!. / &%nl)
nl_nodent: blank_lines nodent nl_nodent <- blank_lines nodent
nl_indent: blank_lines tab_error? {:curr_indent: indent :} (comment nl_nodent)* nl_indent <- blank_lines tab_error? {:curr_indent: indent :} (comment nl_nodent)*
comment (Comment): comment (Comment) <-
"#" {~ [^%nl]* (%nl+ (indent -> '') [^%nl]*)* (%nl &%nl)* ~} "#" {~ [^%nl]* (%nl+ (indent -> '') [^%nl]*)* (%nl &%nl)* ~}
unexpected_code: ws* _unexpected_code unexpected_code <- ws* _unexpected_code
_unexpected_code (Error): _unexpected_code (Error) <-
{:error: {~ [^%nl]+ -> "Couldn't parse this code" ~} :} {:error: {~ [^%nl]+ -> "Couldn't parse this code" ~} :}
unexpected_chunk (Error): unexpected_chunk (Error) <-
{:error: {~ .+ -> "Couldn't parse this code" ~} :} {:error: {~ .+ -> "Couldn't parse this code" ~} :}
unexpected_indent (Error): unexpected_indent (Error) <-
{:error: {~ (=curr_indent ws+) -> "Messed up indentation" ~} :} {:error: {~ (=curr_indent ws+) -> "Messed up indentation" ~} :}
{:hint: {~ '' -> 'Either make sure this line is aligned with the one above it, or make sure the previous line ends with something that uses indentation, like ":" or "(..)"' ~} :} {:hint: {~ '' -> 'Either make sure this line is aligned with the one above it, or make sure the previous line ends with something that uses indentation, like ":" or "(..)"' ~} :}
missing_paren_err (Error): missing_paren_err (Error) <-
{:error: {~ eol -> 'Line ended without finding a closing )-parenthesis' ~} :} {:error: {~ eol -> 'Line ended without finding a closing )-parenthesis' ~} :}
{:hint: {~ '' -> 'Put a ")" here' ~} :} {:hint: {~ '' -> 'Put a ")" here' ~} :}
missing_quote_err (Error): missing_quote_err (Error) <-
{:error: {~ eol -> "Line ended without finding a closing quotation mark." ~} :} {:error: {~ eol -> "Line ended without finding a closing quotation mark." ~} :}
{:hint: {~ "" -> "Put a quotation mark here." ~} :} {:hint: {~ "" -> "Put a quotation mark here." ~} :}
missing_indented_quote_err (Error): missing_indented_quote_err (Error) <-
{:error: {~ eol -> "This text doesn't have a closing quotation mark." ~} :} {:error: {~ eol -> "This text doesn't have a closing quotation mark." ~} :}
{:hint: {~ "" -> "Put a quotation mark here on its own line." ~} :} {:hint: {~ "" -> "Put a quotation mark here on its own line." ~} :}
missing_bracket_error (Error): missing_bracket_error (Error) <-
{:error: {~ eol -> "Line ended before finding a closing ]-bracket" ~} :} {:error: {~ eol -> "Line ended before finding a closing ]-bracket" ~} :}
{:hint: {~ '' -> 'Put a "]" here' ~} :} {:hint: {~ '' -> 'Put a "]" here' ~} :}
missing_brace_error (Error): missing_brace_error (Error) <-
{:error: {~ eol -> "Line ended before finding a closing }-brace" ~} :} {:error: {~ eol -> "Line ended before finding a closing }-brace" ~} :}
{:hint: {~ '' -> 'Put a "}" here' ~} :} {:hint: {~ '' -> 'Put a "}" here' ~} :}
tab_error (Error): tab_error (Error) <-
&(=curr_indent %tab) &(=curr_indent %tab)
{:error: {~ '' -> 'Tabs are not allowed for indentation.' ~} :} {:error: {~ '' -> 'Tabs are not allowed for indentation.' ~} :}
{:hint: {~ '' -> 'Use spaces instead of tabs.' ~} :} {:hint: {~ '' -> 'Use spaces instead of tabs.' ~} :}
section_division: ("~")^+3 eol section_division <- ("~")^+3 eol
inline_block: inline_block <-
"(" ws* inline_block ws* (eof / ")") / raw_inline_block "(" ws* inline_block ws* (eof / ")") / raw_inline_block
raw_inline_block (Block): raw_inline_block (Block) <-
(!"::") ":" ws* ((inline_statement (ws* ";" ws* inline_statement)*) / !(eol nl_indent)) (!"::") ":" ws* ((inline_statement (ws* ";" ws* inline_statement)*) / !(eol nl_indent))
indented_block (Block): indented_block (Block) <-
":" eol nl_indent statement (nl_nodent statement)* ":" eol nl_indent statement (nl_nodent statement)*
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
{:curr_indent: %nil :} {:curr_indent: %nil :}
statement: statement <-
(methodcall / action / expression) (eol / unexpected_code) (methodcall / action / expression) (eol / unexpected_code)
inline_statement: (inline_methodcall / inline_action / inline_expression) inline_statement <- (inline_methodcall / inline_action / inline_expression)
noindex_inline_expression: noindex_inline_expression <-
number / variable / inline_text / inline_list / inline_dict / inline_nomsu number / variable / inline_text / inline_list / inline_dict / inline_nomsu
/ ( "(" / ( "("
ws* (inline_methodcall / inline_action / inline_expression) ws* ws* (inline_methodcall / inline_action / inline_expression) ws*
(")" / eof / missing_paren_err / unexpected_code) (")" / eof / missing_paren_err / unexpected_code)
) )
inline_expression: index_chain / noindex_inline_expression inline_expression <- index_chain / noindex_inline_expression
indented_expression: indented_expression <-
indented_text / indented_nomsu / indented_list / indented_dict / ({| indented_text / indented_nomsu / indented_list / indented_dict / ({|
"(..)" eol nl_indent "(..)" eol nl_indent
(methodcall / action / expression) (eol / unexpected_code) (methodcall / action / expression) (eol / unexpected_code)
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
{:curr_indent: %nil :} {:curr_indent: %nil :}
|} -> unpack) |} -> unpack)
expression: expression <-
inline_expression / indented_expression inline_expression / indented_expression
inline_nomsu (EscapedNomsu): "\" (inline_expression / inline_block) inline_nomsu (EscapedNomsu) <- "\" (inline_expression / inline_block)
indented_nomsu (EscapedNomsu): indented_nomsu (EscapedNomsu) <-
"\" (noindex_inline_expression / inline_block / indented_expression / indented_block) "\" (noindex_inline_expression / inline_block / indented_expression / indented_block)
index_chain (IndexChain): index_chain (IndexChain) <-
noindex_inline_expression noindex_inline_expression
("." (hex_integer / integer / text_word / noindex_inline_expression))+ ("." (hex_integer / integer / text_word / noindex_inline_expression))+
index_chain_before_method (IndexChain): index_chain_before_method (IndexChain) <-
noindex_inline_expression noindex_inline_expression
("." (hex_integer / integer / text_word / noindex_inline_expression) &".")+ ("." (hex_integer / integer / text_word / noindex_inline_expression) &".")+
-- Actions need 1 argument and either another argument or a word. -- Actions need 1 argument and either another argument or a word.
inline_action (Action): inline_action (Action) <-
!section_division !section_division
( (word (ws* (inline_arg / word))*) ( (word (ws* (inline_arg / word))*)
/(inline_arg (ws* (inline_arg / word))+)) /(inline_arg (ws* (inline_arg / word))+))
inline_arg: inline_expression / inline_block inline_arg <- inline_expression / inline_block
inline_methodcall (MethodCall): inline_methodcall (MethodCall) <-
(index_chain / noindex_inline_expression / "(" inline_block ")") (index_chain / noindex_inline_expression / "(" inline_block ")")
"|" inline_action (ws* ";" ws* inline_action)* "|" inline_action (ws* ";" ws* inline_action)*
action (Action): action (Action) <-
!section_division !section_division
( (word ((linesplit / ws*) (arg / word))*) ( (word ((linesplit / ws*) (arg / word))*)
/(arg ((linesplit / ws*) (arg / word))+)) /(arg ((linesplit / ws*) (arg / word))+))
linesplit: (ws* "\")? eol nl_nodent ".." ws* linesplit <- (ws* "\")? eol nl_nodent ".." ws*
arg: expression / inline_block / indented_block arg <- expression / inline_block / indented_block
methodcall (MethodCall): methodcall (MethodCall) <-
(index_chain / noindex_inline_expression / indented_expression / "(" inline_block ")" / indented_block) (index_chain / noindex_inline_expression / indented_expression / "(" inline_block ")" / indented_block)
linesplit? "|" linesplit? "|"
((ws* inline_action ws* ";")* ws* action ((ws* inline_action ws* ";")* ws* action
@ -136,17 +136,17 @@ methodcall (MethodCall):
(action eol) (nl_nodent action eol)* (action eol) (nl_nodent action eol)*
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*) (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*)
word: !number { operator_char+ / ident_char+ } word <- !number { operator_char+ / ident_char+ }
text_word (Text): word text_word (Text) <- word
inline_text (Text): inline_text (Text) <-
!(indented_text) !(indented_text)
'"' _inline_text* ('"' / eof / missing_quote_err / unexpected_code) '"' _inline_text* ('"' / eof / missing_quote_err / unexpected_code)
_inline_text: _inline_text <-
{~ (('\"' -> '"') / ('\\' -> '\') / escaped_char / text_char+)+ ~} {~ (('\"' -> '"') / ('\\' -> '\') / escaped_char / text_char+)+ ~}
/ inline_text_interpolation / illegal_char / inline_text_interpolation / illegal_char
inline_text_interpolation: inline_text_interpolation <-
"\" ( "\" (
variable / inline_list / inline_dict variable / inline_list / inline_dict
/ ("(" / ("("
@ -154,91 +154,91 @@ inline_text_interpolation:
(")" / eof / missing_paren_err / unexpected_code)) (")" / eof / missing_paren_err / unexpected_code))
) )
text_char: %utf8_char / !["\] %print / %tab text_char <- %utf8_char / !["\] %print / %tab
illegal_char (Error): illegal_char (Error) <-
{:error: {~ (!(%nl / %tab / %print) .) -> "Illegal unprintable character here (it may not be visible, but it's there)" ~} :} {:error: {~ (!(%nl / %tab / %print) .) -> "Illegal unprintable character here (it may not be visible, but it's there)" ~} :}
{:hint: {~ '' -> "This sort of thing can happen when copying and pasting code. Try deleting and retyping the code." ~} :} {:hint: {~ '' -> "This sort of thing can happen when copying and pasting code. Try deleting and retyping the code." ~} :}
terminal_quote: '"' !([^%nl] / (%nl (ws* eol)?)+ =curr_indent [^%nl]) terminal_quote <- '"' !([^%nl] / (%nl (ws* eol)?)+ =curr_indent [^%nl])
nonterminal_quote: !terminal_quote '"' nonterminal_quote <- !terminal_quote '"'
indented_text (Text): indented_text (Text) <-
'"' %nl {%nl*} {:curr_indent: indent :} '"' %nl {%nl*} {:curr_indent: indent :}
(indented_plain_text / text_interpolation / illegal_char / blank_text_lines)* (indented_plain_text / text_interpolation / illegal_char / blank_text_lines)*
(terminal_quote eol / eof / missing_indented_quote_err) (terminal_quote eol / eof / missing_indented_quote_err)
{:curr_indent: %nil :} {:curr_indent: %nil :}
-- Tracking text-lines-within-indented-text as separate objects allows for better debugging line info -- Tracking text-lines-within-indented-text as separate objects allows for better debugging line info
indented_plain_text (Text): indented_plain_text (Text) <-
{~ {~
((("\" blank_lines =curr_indent "..") -> "") / ('\\' -> '\') ((("\" blank_lines =curr_indent "..") -> "") / ('\\' -> '\')
/ (!text_interpolation ((!("\n") escaped_char) / '\')) / (!text_interpolation ((!("\n") escaped_char) / '\'))
/ (nonterminal_quote / text_char)+)+ / (nonterminal_quote / text_char)+)+
blank_text_lines? blank_text_lines?
~} ~}
blank_text_lines: blank_text_lines <-
{~ (%nl ((ws* -> '') eol / (=curr_indent -> '') &[^%nl]))+ ~} {~ (%nl ((ws* -> '') eol / (=curr_indent -> '') &[^%nl]))+ ~}
text_interpolation: text_interpolation <-
("\" indented_expression (blank_lines =curr_indent "..")?) / inline_text_interpolation ("\" indented_expression (blank_lines =curr_indent "..")?) / inline_text_interpolation
number: number <-
hex_integer / real_number / integer hex_integer / real_number / integer
integer (Number): integer (Number) <-
(("-"? [0-9]+)-> tonumber) (("-"? [0-9]+)-> tonumber)
hex_integer (Number): hex_integer (Number) <-
(("-"? "0x" [0-9a-fA-F]+)-> tonumber) (("-"? "0x" [0-9a-fA-F]+)-> tonumber)
{:hex: '' -> 'yes' :} {:hex: '' -> 'yes' :}
real_number (Number): real_number (Number) <-
(("-"? ([0-9]+ "." [0-9]+) / ("." [0-9]+))-> tonumber) (("-"? ([0-9]+ "." [0-9]+) / ("." [0-9]+))-> tonumber)
variable (Var): "$" ({ident_char+} / "(" {(ws+ / operator_char+ / ident_char+)*} ")" / {''}) variable (Var) <- "$" ({ident_char+} / "(" {(ws+ / operator_char+ / ident_char+)*} ")" / {''})
inline_list (List): inline_list (List) <-
!('[..]') !('[..]')
"[" ws* "[" ws*
(inline_list_item (ws* ',' ws* inline_list_item)* (ws* ',')?)? ws* (inline_list_item (ws* ',' ws* inline_list_item)* (ws* ',')?)? ws*
("]" / eof / (","? (missing_bracket_error / unexpected_code))) ("]" / eof / (","? (missing_bracket_error / unexpected_code)))
indented_list (List): indented_list (List) <-
"[..]" eol nl_indent "[..]" eol nl_indent
list_line (nl_nodent list_line)* list_line (nl_nodent list_line)*
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
(","? unexpected_code)? (","? unexpected_code)?
list_line: list_line <-
(inline_list_item ws* "," ws*)+ eol (inline_list_item ws* "," ws*)+ eol
/ (inline_list_item ws* "," ws*)* (methodcall / action / expression / inline_block / indented_block) eol / (inline_list_item ws* "," ws*)* (methodcall / action / expression / inline_block / indented_block) eol
inline_list_item: inline_methodcall / inline_action / inline_expression / inline_block inline_list_item <- inline_methodcall / inline_action / inline_expression / inline_block
inline_dict (Dict): inline_dict (Dict) <-
!('{..}') !('{..}')
"{" ws* "{" ws*
(inline_dict_entry (ws* ',' ws* inline_dict_entry)*)? ws* (inline_dict_entry (ws* ',' ws* inline_dict_entry)*)? ws*
("}" / eof / (","? (missing_brace_error / unexpected_code))) ("}" / eof / (","? (missing_brace_error / unexpected_code)))
indented_dict (Dict): indented_dict (Dict) <-
"{..}" eol nl_indent "{..}" eol nl_indent
dict_line (nl_nodent dict_line)* dict_line (nl_nodent dict_line)*
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))* (%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
(","? unexpected_code)? (","? unexpected_code)?
dict_line: dict_line <-
(inline_dict_entry ws* "," ws*)+ eol (inline_dict_entry ws* "," ws*)+ eol
/ (inline_dict_entry ws* "," ws*)* dict_entry eol / (inline_dict_entry ws* "," ws*)* dict_entry eol
_dict_entry(DictEntry): _dict_entry(DictEntry) <-
dict_key (ws* ":" ws* (methodcall / action / expression))? dict_key (ws* ":" ws* (methodcall / action / expression))?
dict_entry: dict_entry <-
_dict_entry / inline_block / indented_block _dict_entry / inline_block / indented_block
_inline_dict_entry(DictEntry): _inline_dict_entry(DictEntry) <-
dict_key (ws* ":" ws* (inline_methodcall / inline_action / inline_expression)?)? dict_key (ws* ":" ws* (inline_methodcall / inline_action / inline_expression)?)?
inline_dict_entry: inline_dict_entry <-
_inline_dict_entry / inline_block _inline_dict_entry / inline_block
dict_key: dict_key <-
text_word / inline_expression text_word / inline_expression
operator_char: [#'`~@^&*+=|<>?/%!-] operator_char <- [#'`~@^&*+=|<>?/%!-]
ident_char: [a-zA-Z0-9_] / %utf8_char ident_char <- [a-zA-Z0-9_] / %utf8_char
ws: " " ws <- " "
escaped_char: escaped_char <-
("\"->'') ( ("\"->'') (
(([xX]->'') ((({[0-9a-fA-F]^2} %number_16) -> tonumber) -> tochar)) (([xX]->'') ((({[0-9a-fA-F]^2} %number_16) -> tonumber) -> tochar))
/ ((([0-9] [0-9]^-2) -> tonumber) -> tochar) / ((([0-9] [0-9]^-2) -> tonumber) -> tochar)

136
nomsu_compiler.lua
View File

@ -150,9 +150,6 @@ local compile = setmetatable({
["use 1 with prefix"] = function(compile, path, prefix) ["use 1 with prefix"] = function(compile, path, prefix)
return LuaCode("run_file_1_in(" .. tostring(compile(path)) .. ", _ENV, OPTIMIZATION, ", compile(prefix), ")") return LuaCode("run_file_1_in(" .. tostring(compile(path)) .. ", _ENV, OPTIMIZATION, ", compile(prefix), ")")
end, end,
["tests"] = function(compile)
return LuaCode("TESTS")
end,
["test"] = function(compile, body) ["test"] = function(compile, body)
if not (body.type == 'Block') then if not (body.type == 'Block') then
compile_error(body, "This should be a Block") compile_error(body, "This should be a Block")
@ -355,10 +352,12 @@ local compile = setmetatable({
string_buffer = "" string_buffer = ""
end end
local bit_lua = compile(bit) local bit_lua = compile(bit)
if bit.type == "Block" then if bit.type == "Block" and #bit == 1 then
bit_lua = LuaCode:from(bit.source, "(function()", "\n local _buffer = List{}", "\n local function add(bit) _buffer:add(bit) end", "\n local function join_with(glue) _buffer = _buffer:joined_with(glue) end", "\n ", bit_lua, "\n if lua_type_of(_buffer) == 'table' then _buffer = _buffer:joined() end", "\n return _buffer", "\nend)()") bit = bit[1]
end end
if bit.type ~= "Text" then if bit.type == "Block" then
bit_lua = LuaCode:from(bit.source, "List(function(add)", "\n ", bit_lua, "\nend):joined()")
elseif bit.type ~= "Text" and bit.type ~= "Number" then
bit_lua = LuaCode:from(bit.source, "tostring(", bit_lua, ")") bit_lua = LuaCode:from(bit.source, "tostring(", bit_lua, ")")
end end
add_bit(bit_lua) add_bit(bit_lua)
@ -382,82 +381,91 @@ local compile = setmetatable({
end end
return lua return lua
elseif "List" == _exp_0 or "Dict" == _exp_0 then elseif "List" == _exp_0 or "Dict" == _exp_0 then
if #tree == 0 then
return LuaCode:from(tree.source, tree.type, "{}")
end
local lua = LuaCode:from(tree.source) local lua = LuaCode:from(tree.source)
local chunks = 0
local i = 1 local i = 1
local sep = '' while tree[i] do
while i <= #tree do if tree[i].type == 'Block' then
local item = tree[i] if chunks > 0 then
if item.type == "Block" then lua:add(" + ")
break
end
lua:add(sep)
if item.type == "Comment" then
lua:add(compile(item), "\n")
sep = ''
else
local item_lua = compile(item)
lua:add(item_lua)
sep = ', '
end
i = i + 1
end
if lua:is_multiline() then
lua = LuaCode:from(tree.source, tostring(tree.type) .. "{\n ", lua, "\n}")
else
lua = LuaCode:from(tree.source, tostring(tree.type) .. "{", lua, "}")
end
if i <= #tree then
lua = LuaCode:from(tree.source, "(function()\n local comprehension = ", lua)
if tree.type == "List" then
lua:add("\n local function add(x) comprehension[#comprehension+1] = x end")
else
lua:add("\n local function " .. tostring(("add 1 ="):as_lua_id()) .. "(k, v) comprehension[k] = v end")
end
while i <= #tree do
lua:add("\n ")
if tree[i].type == 'Block' or tree[i].type == 'Comment' then
lua:add(compile(tree[i]))
elseif tree[i].type == "DictEntry" then
local entry_lua = compile(tree[i])
lua:add((entry_lua:text():sub(1, 1) == '[' and "comprehension" or "comprehension."), entry_lua)
else
lua:add("comprehension[#comprehension+1] = ", compile(tree[i]))
end end
lua:add(tree.type, "(function(", (tree.type == 'List' and "add" or ("add, " .. ("add 1 ="):as_lua_id())), ")")
lua:add("\n ", compile(tree[i]), "\nend)")
chunks = chunks + 1
i = i + 1 i = i + 1
else
if chunks > 0 then
lua:add(" + ")
end
local sep = ''
local items_lua = LuaCode:from(tree[i].source)
while tree[i] do
if tree[i].type == "Block" then
break
end
local item_lua = compile(tree[i])
if item_lua:text():match("^%.[a-zA-Z_]") then
item_lua = item_lua:text():sub(2)
end
if tree.type == 'Dict' and tree[i].type == 'Index' then
item_lua = LuaCode:from(tree[i].source, item_lua, "=true")
end
items_lua:add(sep, item_lua)
if tree[i].type == "Comment" then
items_lua:add("\n")
sep = ''
else
sep = ', '
end
i = i + 1
end
if items_lua:is_multiline() then
lua:add(LuaCode:from(items_lua.source, tree.type, "{\n ", items_lua, "\n}"))
else
lua:add(LuaCode:from(items_lua.source, tree.type, "{", items_lua, "}"))
end
chunks = chunks + 1
end end
lua:add("\n return comprehension\nend)()")
end end
return lua return lua
elseif "DictEntry" == _exp_0 then elseif "Index" == _exp_0 then
local key, value = tree[1], tree[2] local key_lua = compile(tree[1])
local key_lua = compile(key) local key_str = match(key_lua:text(), '^"([a-zA-Z_][a-zA-Z0-9_]*)"$')
local value_lua = value and compile(value) or LuaCode:from(key.source, "true")
local key_str = match(key_lua:text(), [=[^["']([a-zA-Z_][a-zA-Z0-9_]*)['"]$]=])
if key_str and key_str:is_lua_id() then if key_str and key_str:is_lua_id() then
return LuaCode:from(tree.source, key_str, "=", value_lua) return LuaCode:from(tree.source, ".", key_str)
elseif sub(key_lua:text(), 1, 1) == "[" then elseif sub(key_lua:text(), 1, 1) == "[" then
return LuaCode:from(tree.source, "[ ", key_lua, "]=", value_lua) return LuaCode:from(tree.source, "[ ", key_lua, "]")
else else
return LuaCode:from(tree.source, "[", key_lua, "]=", value_lua) return LuaCode:from(tree.source, "[", key_lua, "]")
end end
elseif "DictEntry" == _exp_0 then
local key = tree[1]
if key.type ~= "Index" then
key = SyntaxTree({
type = "Index",
source = key.source,
key
})
end
return LuaCode:from(tree.source, compile(key), "=", (tree[2] and compile(tree[2]) or "true"))
elseif "IndexChain" == _exp_0 then elseif "IndexChain" == _exp_0 then
local lua = compile(tree[1]) local lua = compile(tree[1])
local first_char = sub(lua:text(), 1, 1) if lua:text():match("['\"}]$") or lua:text():match("]=*]$") then
if first_char == "{" or first_char == '"' or first_char == "[" then
lua:parenthesize() lua:parenthesize()
end end
for i = 2, #tree do for i = 2, #tree do
local key = tree[i] local key = tree[i]
local key_lua = compile(key) if key.type ~= "Index" then
local key_lua_str = key_lua:text() key = SyntaxTree({
local lua_id = match(key_lua_str, "^['\"]([a-zA-Z_][a-zA-Z0-9_]*)['\"]$") type = "Index",
if lua_id and lua_id:is_lua_id() then source = key.source,
lua:add("." .. tostring(lua_id)) key
elseif sub(key_lua_str, 1, 1) == '[' then })
lua:add("[ ", key_lua, " ]")
else
lua:add("[", key_lua, "]")
end end
lua:add(compile(key))
end end
return lua return lua
elseif "Number" == _exp_0 then elseif "Number" == _exp_0 then

126
nomsu_compiler.moon
View File

@ -122,7 +122,6 @@ compile = setmetatable({
["use 1 with prefix"]: (compile, path, prefix)-> ["use 1 with prefix"]: (compile, path, prefix)->
LuaCode("run_file_1_in(#{compile(path)}, _ENV, OPTIMIZATION, ", compile(prefix), ")") LuaCode("run_file_1_in(#{compile(path)}, _ENV, OPTIMIZATION, ", compile(prefix), ")")
["tests"]: (compile)-> LuaCode("TESTS")
["test"]: (compile, body)-> ["test"]: (compile, body)->
unless body.type == 'Block' unless body.type == 'Block'
compile_error(body, "This should be a Block") compile_error(body, "This should be a Block")
@ -150,6 +149,7 @@ compile = setmetatable({
lua\add tok lua\add tok
else else
tok_lua = compile(tok) tok_lua = compile(tok)
-- TODO: this is overly eager, should be less aggressive
tok_lua\parenthesize! if tok.type == "Action" tok_lua\parenthesize! if tok.type == "Action"
lua\add tok_lua lua\add tok_lua
lua\add " " if i < #tree lua\add " " if i < #tree
@ -271,16 +271,13 @@ compile = setmetatable({
string_buffer = "" string_buffer = ""
bit_lua = compile(bit) bit_lua = compile(bit)
if bit.type == "Block" and #bit == 1
bit = bit[1]
if bit.type == "Block" if bit.type == "Block"
bit_lua = LuaCode\from bit.source, "(function()", bit_lua = LuaCode\from bit.source, "List(function(add)",
"\n local _buffer = List{}",
"\n local function add(bit) _buffer:add(bit) end",
"\n local function join_with(glue) _buffer = _buffer:joined_with(glue) end",
"\n ", bit_lua, "\n ", bit_lua,
"\n if lua_type_of(_buffer) == 'table' then _buffer = _buffer:joined() end", "\nend):joined()"
"\n return _buffer", elseif bit.type != "Text" and bit.type != "Number"
"\nend)()"
if bit.type != "Text"
bit_lua = LuaCode\from(bit.source, "tostring(",bit_lua,")") bit_lua = LuaCode\from(bit.source, "tostring(",bit_lua,")")
add_bit bit_lua add_bit bit_lua
@ -296,84 +293,75 @@ compile = setmetatable({
return lua return lua
when "List", "Dict" when "List", "Dict"
if #tree == 0
return LuaCode\from tree.source, tree.type, "{}"
lua = LuaCode\from tree.source lua = LuaCode\from tree.source
chunks = 0
i = 1 i = 1
sep = '' while tree[i]
while i <= #tree if tree[i].type == 'Block'
item = tree[i] lua\add " + " if chunks > 0
if item.type == "Block" lua\add tree.type, "(function(", (tree.type == 'List' and "add" or ("add, "..("add 1 =")\as_lua_id!)), ")"
break lua\add "\n ", compile(tree[i]), "\nend)"
lua\add sep chunks += 1
if item.type == "Comment"
lua\add compile(item), "\n"
sep = ''
else
item_lua = compile(item)
lua\add item_lua
sep = ', '
i += 1
if lua\is_multiline!
lua = LuaCode\from tree.source, "#{tree.type}{\n ", lua, "\n}"
else
lua = LuaCode\from tree.source, "#{tree.type}{", lua, "}"
-- List/dict comprehenstion
if i <= #tree
lua = LuaCode\from tree.source, "(function()\n local comprehension = ", lua
if tree.type == "List"
lua\add "\n local function add(x) comprehension[#comprehension+1] = x end"
else
lua\add "\n local function #{("add 1 =")\as_lua_id!}(k, v) comprehension[k] = v end"
while i <= #tree
lua\add "\n "
if tree[i].type == 'Block' or tree[i].type == 'Comment'
lua\add compile(tree[i])
elseif tree[i].type == "DictEntry"
entry_lua = compile(tree[i])
lua\add (entry_lua\text!\sub(1,1) == '[' and "comprehension" or "comprehension."), entry_lua
else
lua\add "comprehension[#comprehension+1] = ", compile(tree[i])
i += 1 i += 1
lua\add "\n return comprehension\nend)()" else
lua\add " + " if chunks > 0
sep = ''
items_lua = LuaCode\from tree[i].source
while tree[i]
if tree[i].type == "Block"
break
item_lua = compile tree[i]
if item_lua\text!\match("^%.[a-zA-Z_]")
item_lua = item_lua\text!\sub(2)
if tree.type == 'Dict' and tree[i].type == 'Index'
item_lua = LuaCode\from tree[i].source, item_lua, "=true"
items_lua\add sep, item_lua
if tree[i].type == "Comment"
items_lua\add "\n"
sep = ''
else
sep = ', '
i += 1
if items_lua\is_multiline!
lua\add LuaCode\from items_lua.source, tree.type, "{\n ", items_lua, "\n}"
else
lua\add LuaCode\from items_lua.source, tree.type, "{", items_lua, "}"
chunks += 1
return lua return lua
when "DictEntry" when "Index"
key, value = tree[1], tree[2] key_lua = compile(tree[1])
key_lua = compile(key) key_str = match(key_lua\text!, '^"([a-zA-Z_][a-zA-Z0-9_]*)"$')
value_lua = value and compile(value) or LuaCode\from(key.source, "true")
key_str = match(key_lua\text!, [=[^["']([a-zA-Z_][a-zA-Z0-9_]*)['"]$]=])
return if key_str and key_str\is_lua_id! return if key_str and key_str\is_lua_id!
LuaCode\from tree.source, key_str,"=",value_lua LuaCode\from tree.source, ".", key_str
elseif sub(key_lua\text!,1,1) == "[" elseif sub(key_lua\text!,1,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"]
LuaCode\from tree.source, "[ ",key_lua,"]=",value_lua LuaCode\from tree.source, "[ ",key_lua,"]"
else else
LuaCode\from tree.source, "[",key_lua,"]=",value_lua LuaCode\from tree.source, "[",key_lua,"]"
when "DictEntry"
key = tree[1]
if key.type != "Index"
key = SyntaxTree{type:"Index", source:key.source, key}
return LuaCode\from tree.source, compile(key),"=",(tree[2] and compile(tree[2]) or "true")
when "IndexChain" when "IndexChain"
lua = compile(tree[1]) lua = compile(tree[1])
first_char = sub(lua\text!,1,1) if lua\text!\match("['\"}]$") or lua\text!\match("]=*]$")
if first_char == "{" or first_char == '"' or first_char == "["
lua\parenthesize! lua\parenthesize!
for i=2,#tree for i=2,#tree
key = tree[i] key = tree[i]
key_lua = compile(key) -- TODO: remove this shim
key_lua_str = key_lua\text! if key.type != "Index"
lua_id = match(key_lua_str, "^['\"]([a-zA-Z_][a-zA-Z0-9_]*)['\"]$") key = SyntaxTree{type:"Index", source:key.source, key}
if lua_id and lua_id\is_lua_id! lua\add compile(key)
lua\add ".#{lua_id}"
elseif sub(key_lua_str,1,1) == '['
-- NOTE: this *must* use a space after the [ to avoid freaking out
-- Lua's parser if the inner expression is a long string. Lua
-- parses x[[[y]]] as x("[y]"), not as x["y"]
lua\add "[ ",key_lua," ]"
else
lua\add "[",key_lua,"]"
return lua return lua
when "Number" when "Number"

142
nomsu_decompiler.lua
View File

@ -14,7 +14,7 @@ local re = require('re')
local MAX_LINE = 80 local MAX_LINE = 80
local GOLDEN_RATIO = ((math.sqrt(5) - 1) / 2) local GOLDEN_RATIO = ((math.sqrt(5) - 1) / 2)
local utf8_char_patt = (R("\194\223") * R("\128\191") + R("\224\239") * R("\128\191") * R("\128\191") + R("\240\244") * R("\128\191") * R("\128\191") * R("\128\191")) local utf8_char_patt = (R("\194\223") * R("\128\191") + R("\224\239") * R("\128\191") * R("\128\191") + R("\240\244") * R("\128\191") * R("\128\191") * R("\128\191"))
local operator_patt = S("'`~!@$^&*+=|<>?/-") ^ 1 * -1 local operator_patt = S("'`~!@%#^&*+=|<>?/-") ^ 1 * -1
local identifier_patt = (R("az", "AZ", "09") + P("_") + utf8_char_patt) ^ 1 * -1 local identifier_patt = (R("az", "AZ", "09") + P("_") + utf8_char_patt) ^ 1 * -1
local is_operator local is_operator
is_operator = function(s) is_operator = function(s)
@ -73,11 +73,15 @@ tree_to_inline_nomsu = function(tree)
arg_nomsu:parenthesize() arg_nomsu:parenthesize()
end end
else else
if i > 1 then
nomsu:add(" ")
end
if bit.type == "Action" or bit.type == "MethodCall" then if bit.type == "Action" or bit.type == "MethodCall" then
if i > 1 then
nomsu:add(" ")
end
arg_nomsu:parenthesize() arg_nomsu:parenthesize()
else
if i > 1 then
nomsu:add(" ")
end
end end
end end
nomsu:add(arg_nomsu) nomsu:add(arg_nomsu)
@ -86,10 +90,10 @@ tree_to_inline_nomsu = function(tree)
return nomsu return nomsu
elseif "MethodCall" == _exp_0 then elseif "MethodCall" == _exp_0 then
local target_nomsu = tree_to_inline_nomsu(tree[1]) local target_nomsu = tree_to_inline_nomsu(tree[1])
if tree[1].type == "Action" or tree[1].type == "MethodCall" or tree[1].type == "Block" then if tree[1].type == "Block" then
target_nomsu:parenthesize() target_nomsu:parenthesize()
end end
local nomsu = NomsuCode:from(tree.source, target_nomsu, "|") local nomsu = NomsuCode:from(tree.source, target_nomsu, ", ")
for i = 2, #tree do for i = 2, #tree do
if i > 2 then if i > 2 then
nomsu:add("; ") nomsu:add("; ")
@ -142,30 +146,47 @@ tree_to_inline_nomsu = function(tree)
if i > 1 then if i > 1 then
nomsu:add(", ") nomsu:add(", ")
end end
nomsu:add(tree_to_inline_nomsu(item)) local item_nomsu = tree_to_inline_nomsu(item, true)
if item.type == "MethodCall" then
item_nomsu:parenthesize()
end
nomsu:add(item_nomsu)
end end
nomsu:add(tree.type == "List" and "]" or "}") nomsu:add(tree.type == "List" and "]" or "}")
return nomsu return nomsu
elseif "DictEntry" == _exp_0 then elseif "DictEntry" == _exp_0 then
local key, value = tree[1], tree[2] local key, value = tree[1], tree[2]
local nomsu local nomsu = NomsuCode:from(tree.source)
if key.type == "Text" and #key == 1 and is_identifier(key[1]) then if key.type ~= "Index" then
nomsu = NomsuCode:from(key.source, key[1]) key = {
else type = "Index",
nomsu = tree_to_inline_nomsu(key) source = key.source,
end key
if key.type == "Action" or key.type == "MethodCall" or key.type == "Block" then }
nomsu:parenthesize()
end end
nomsu:add(tree_to_inline_nomsu(key))
if value then if value then
nomsu:add(": ") nomsu:add(" = ")
local value_nomsu = tree_to_inline_nomsu(value) local value_nomsu = tree_to_inline_nomsu(value)
if value.type == "Block" then if value.type == "Block" or value.type == "Action" or value.type == "MethodCall" then
value_nomsu:parenthesize() value_nomsu:parenthesize()
end end
nomsu:add(value_nomsu) nomsu:add(value_nomsu)
end end
return nomsu return nomsu
elseif "Index" == _exp_0 then
local key = tree[1]
local nomsu = NomsuCode:from(key.source, ".")
local key_nomsu
if key.type == "Text" and #key == 1 and is_identifier(key[1]) then
key_nomsu = key[1]
else
key_nomsu = tree_to_inline_nomsu(key)
end
if key.type == "Block" or key.type == "Action" or key.type == "MethodCall" then
key_nomsu:parenthesize()
end
return NomsuCode:from(key.source, ".", key_nomsu)
elseif "IndexChain" == _exp_0 then elseif "IndexChain" == _exp_0 then
local nomsu = NomsuCode:from(tree.source) local nomsu = NomsuCode:from(tree.source)
for i, bit in ipairs(tree) do for i, bit in ipairs(tree) do
@ -240,7 +261,7 @@ tree_to_nomsu = function(tree)
if try_inline then if try_inline then
inline_nomsu = tree_to_inline_nomsu(t) inline_nomsu = tree_to_inline_nomsu(t)
if #inline_nomsu:text() <= space or #inline_nomsu:text() <= 8 then if #inline_nomsu:text() <= space or #inline_nomsu:text() <= 8 then
if t.type == "Action" or t.type == "MethodCall" then if (t.type == "Action" or t.type == "MethodCall") then
inline_nomsu:parenthesize() inline_nomsu:parenthesize()
end end
return inline_nomsu return inline_nomsu
@ -252,7 +273,7 @@ tree_to_nomsu = function(tree)
local indented = tree_to_nomsu(t) local indented = tree_to_nomsu(t)
if t.type == "Action" or t.type == "MethodCall" then if t.type == "Action" or t.type == "MethodCall" then
if indented:is_multiline() then if indented:is_multiline() then
return NomsuCode:from(t.source, "(..)\n ", indented) return NomsuCode:from(t.source, "(\n ", indented, "\n)")
else else
indented:parenthesize() indented:parenthesize()
end end
@ -300,7 +321,7 @@ tree_to_nomsu = function(tree)
local words = table.concat(word_buffer) local words = table.concat(word_buffer)
if next_space == " " then if next_space == " " then
if nomsu:trailing_line_len() + #words > MAX_LINE and nomsu:trailing_line_len() > 8 then if nomsu:trailing_line_len() + #words > MAX_LINE and nomsu:trailing_line_len() > 8 then
next_space = " \\\n.." next_space = "\n.."
elseif word_buffer[1] == "'" then elseif word_buffer[1] == "'" then
next_space = "" next_space = ""
end end
@ -311,23 +332,24 @@ tree_to_nomsu = function(tree)
end end
num_args = num_args + 1 num_args = num_args + 1
local bit_nomsu = recurse(bit) local bit_nomsu = recurse(bit)
if bit.type == "Block" and not bit_nomsu:is_multiline() then if bit.type == "Block" then
if #bit_nomsu:text() > nomsu:trailing_line_len() * GOLDEN_RATIO and #bit_nomsu:text() > 8 then if not bit_nomsu:is_multiline() and #bit_nomsu:text() > nomsu:trailing_line_len() * GOLDEN_RATIO and #bit_nomsu:text() > 8 then
bit_nomsu = tree_to_nomsu(bit)
end
elseif (not bit_nomsu:is_multiline() and nomsu:trailing_line_len() + #bit_nomsu:text() > MAX_LINE and nomsu:trailing_line_len() > 8) then
if next_space == " " and #bit_nomsu:text() < MAX_LINE then
next_space = "\n.."
elseif bit.type == 'Action' or bit.type == "MethodCall" then
bit_nomsu = NomsuCode:from(bit.source, "(\n ", tree_to_nomsu(bit), ")")
else
bit_nomsu = tree_to_nomsu(bit) bit_nomsu = tree_to_nomsu(bit)
end end
end end
if (next_space == " " and not bit_nomsu:is_multiline() and nomsu:trailing_line_len() + #bit_nomsu:text() > MAX_LINE and nomsu:trailing_line_len() > 8) then if not (next_space == " " and bit_nomsu:text():match("^:")) then
if bit.type == 'Action' or bit.type == "MethodCall" then
bit_nomsu = NomsuCode:from(bit.source, "(..)\n ", tree_to_nomsu(bit))
else
next_space = " \\\n.."
end
end
if not (next_space == " " and bit.type == "Block") then
nomsu:add(next_space) nomsu:add(next_space)
end end
nomsu:add(bit_nomsu) nomsu:add(bit_nomsu)
next_space = (bit_nomsu:is_multiline() or bit.type == 'Block') and "\n.." or " " next_space = (bit.type == 'Block' and bit_nomsu:is_multiline()) and "\n.." or " "
_continue_0 = true _continue_0 = true
until true until true
if not _continue_0 then if not _continue_0 then
@ -338,7 +360,7 @@ tree_to_nomsu = function(tree)
local words = table.concat(word_buffer) local words = table.concat(word_buffer)
if next_space == " " then if next_space == " " then
if nomsu:trailing_line_len() + #words > MAX_LINE and nomsu:trailing_line_len() > 8 then if nomsu:trailing_line_len() + #words > MAX_LINE and nomsu:trailing_line_len() > 8 then
next_space = " \\\n.." next_space = "\n.."
elseif word_buffer[1] == "'" then elseif word_buffer[1] == "'" then
next_space = "" next_space = ""
end end
@ -352,8 +374,7 @@ tree_to_nomsu = function(tree)
if tree[1].type == "Block" and not target_nomsu:is_multiline() then if tree[1].type == "Block" and not target_nomsu:is_multiline() then
target_nomsu:parenthesize() target_nomsu:parenthesize()
end end
nomsu:add(target_nomsu) nomsu:add(target_nomsu, ", ")
nomsu:add(target_nomsu:is_multiline() and "\n..|" or "|")
local inner_nomsu = NomsuCode() local inner_nomsu = NomsuCode()
for i = 2, #tree do for i = 2, #tree do
if i > 2 then if i > 2 then
@ -391,7 +412,7 @@ tree_to_nomsu = function(tree)
end end
return NomsuCode:from(tree.source, ":\n ", nomsu) return NomsuCode:from(tree.source, ":\n ", nomsu)
elseif "Text" == _exp_0 then elseif "Text" == _exp_0 then
local max_line = math.floor(1.25 * MAX_LINE) local max_line = MAX_LINE + 8
local add_text local add_text
add_text = function(tree) add_text = function(tree)
for i, bit in ipairs(tree) do for i, bit in ipairs(tree) do
@ -399,6 +420,9 @@ tree_to_nomsu = function(tree)
bit = escape(bit) bit = escape(bit)
for j, line in ipairs(bit:lines()) do for j, line in ipairs(bit:lines()) do
if j > 1 then if j > 1 then
if nomsu:text():match(" $") then
nomsu:add("\\;")
end
nomsu:add("\n") nomsu:add("\n")
elseif #line > 10 and nomsu:trailing_line_len() > max_line then elseif #line > 10 and nomsu:trailing_line_len() > max_line then
nomsu:add("\\\n..") nomsu:add("\\\n..")
@ -439,14 +463,17 @@ tree_to_nomsu = function(tree)
end end
end end
nomsu:add(interp_nomsu) nomsu:add(interp_nomsu)
if interp_nomsu:is_multiline() then if interp_nomsu:is_multiline() and bit.type == "Block" then
nomsu:add("\n..") nomsu:add("\n..")
end end
end end
end end
end end
add_text(tree) add_text(tree)
return NomsuCode:from(tree.source, '"\n ', nomsu, '"') if nomsu:text():match(" $") then
nomsu:add("\\;")
end
return NomsuCode:from(tree.source, '"\n ', nomsu, '\n"')
elseif "List" == _exp_0 or "Dict" == _exp_0 then elseif "List" == _exp_0 or "Dict" == _exp_0 then
if #tree == 0 then if #tree == 0 then
nomsu:add(tree.type == "List" and "[]" or "{}") nomsu:add(tree.type == "List" and "[]" or "{}")
@ -454,13 +481,19 @@ tree_to_nomsu = function(tree)
end end
local sep = '' local sep = ''
for i, item in ipairs(tree) do for i, item in ipairs(tree) do
local item_nomsu = tree_to_inline_nomsu(item) local item_nomsu
if #item_nomsu:text() > MAX_LINE then if item.type == 'MethodCall' then
item_nomsu = recurse(item) item_nomsu = recurse(item)
end elseif item.type == 'Comment' then
if item.type == 'Comment' then
sep = '\n'
item_nomsu = tree_to_nomsu(item) item_nomsu = tree_to_nomsu(item)
if i > 1 then
sep = '\n'
end
else
item_nomsu = tree_to_inline_nomsu(item)
if #item_nomsu:text() > MAX_LINE then
item_nomsu = recurse(item)
end
end end
nomsu:add(sep) nomsu:add(sep)
nomsu:add(item_nomsu) nomsu:add(item_nomsu)
@ -471,32 +504,33 @@ tree_to_nomsu = function(tree)
end end
end end
if tree.type == "List" then if tree.type == "List" then
return NomsuCode:from(tree.source, "[..]\n ", nomsu) return NomsuCode:from(tree.source, "[\n ", nomsu, "\n]")
else else
return NomsuCode:from(tree.source, "{..}\n ", nomsu) return NomsuCode:from(tree.source, "{\n ", nomsu, "\n}")
end end
elseif "DictEntry" == _exp_0 then elseif "DictEntry" == _exp_0 then
local key, value = tree[1], tree[2] local key, value = tree[1], tree[2]
if key.type == "Text" and #key == 1 and is_identifier(key[1]) then nomsu = NomsuCode:from(tree.source)
nomsu = NomsuCode:from(key.source, key[1]) if key.type ~= "Index" then
else key = {
nomsu = tree_to_inline_nomsu(key) type = "Index",
end source = key.source,
if key.type == "Block" then key
nomsu:parenthesize() }
end end
nomsu:add(tree_to_nomsu(key))
if value then if value then
local value_nomsu = tree_to_nomsu(value) local value_nomsu = tree_to_nomsu(value)
if (value.type == "Block" or value.type == "EscapedNomsu") and not value_nomsu:is_multiline() then if (value.type == "Block" or value.type == "Action" or value.type == "MethodCall") and not value_nomsu:is_multiline() then
value_nomsu:parenthesize() value_nomsu:parenthesize()
end end
nomsu:add(": ", value_nomsu) nomsu:add(" = ", value_nomsu)
end end
return nomsu return nomsu
elseif "Comment" == _exp_0 then elseif "Comment" == _exp_0 then
nomsu:add("#", (tree[1]:gsub("\n", "\n "))) nomsu:add("#", (tree[1]:gsub("\n", "\n ")))
return nomsu return nomsu
elseif "IndexChain" == _exp_0 or "Number" == _exp_0 or "Var" == _exp_0 or "Comment" == _exp_0 or "Error" == _exp_0 then elseif "IndexChain" == _exp_0 or "Index" == _exp_0 or "Number" == _exp_0 or "Var" == _exp_0 or "Comment" == _exp_0 or "Error" == _exp_0 then
return tree_to_inline_nomsu(tree) return tree_to_inline_nomsu(tree)
else else
return error("Unknown type: " .. tostring(tree.type)) return error("Unknown type: " .. tostring(tree.type))

117
nomsu_decompiler.moon
View File

@ -11,7 +11,7 @@ utf8_char_patt = (
R("\194\223")*R("\128\191") + R("\194\223")*R("\128\191") +
R("\224\239")*R("\128\191")*R("\128\191") + R("\224\239")*R("\128\191")*R("\128\191") +
R("\240\244")*R("\128\191")*R("\128\191")*R("\128\191")) R("\240\244")*R("\128\191")*R("\128\191")*R("\128\191"))
operator_patt = S("'`~!@$^&*+=|<>?/-")^1 * -1 operator_patt = S("'`~!@%#^&*+=|<>?/-")^1 * -1
identifier_patt = (R("az","AZ","09") + P("_") + utf8_char_patt)^1 * -1 identifier_patt = (R("az","AZ","09") + P("_") + utf8_char_patt)^1 * -1
is_operator = (s)-> is_operator = (s)->
@ -50,17 +50,19 @@ tree_to_inline_nomsu = (tree)->
unless i == #tree unless i == #tree
arg_nomsu\parenthesize! arg_nomsu\parenthesize!
else else
nomsu\add " " if i > 1
if bit.type == "Action" or bit.type == "MethodCall" if bit.type == "Action" or bit.type == "MethodCall"
nomsu\add " " if i > 1
arg_nomsu\parenthesize! arg_nomsu\parenthesize!
else
nomsu\add " " if i > 1
nomsu\add arg_nomsu nomsu\add arg_nomsu
return nomsu return nomsu
when "MethodCall" when "MethodCall"
target_nomsu = tree_to_inline_nomsu(tree[1]) target_nomsu = tree_to_inline_nomsu(tree[1])
if tree[1].type == "Action" or tree[1].type == "MethodCall" or tree[1].type == "Block" if tree[1].type == "Block"
target_nomsu\parenthesize! target_nomsu\parenthesize!
nomsu = NomsuCode\from(tree.source, target_nomsu, "|") nomsu = NomsuCode\from(tree.source, target_nomsu, ", ")
for i=2,#tree for i=2,#tree
nomsu\add "; " if i > 2 nomsu\add "; " if i > 2
nomsu\add tree_to_inline_nomsu(tree[i]) nomsu\add tree_to_inline_nomsu(tree[i])
@ -103,23 +105,39 @@ tree_to_inline_nomsu = (tree)->
nomsu = NomsuCode\from(tree.source, (tree.type == "List" and "[" or "{")) nomsu = NomsuCode\from(tree.source, (tree.type == "List" and "[" or "{"))
for i, item in ipairs tree for i, item in ipairs tree
nomsu\add ", " if i > 1 nomsu\add ", " if i > 1
nomsu\add tree_to_inline_nomsu(item) item_nomsu = tree_to_inline_nomsu(item, true)
--if item.type == "Block" or item.type == "Action" or item.type == "MethodCall"
-- item_nomsu\parenthesize!
if item.type == "MethodCall"
item_nomsu\parenthesize!
nomsu\add item_nomsu
nomsu\add(tree.type == "List" and "]" or "}") nomsu\add(tree.type == "List" and "]" or "}")
return nomsu return nomsu
when "DictEntry" when "DictEntry"
key, value = tree[1], tree[2] key, value = tree[1], tree[2]
nomsu = if key.type == "Text" and #key == 1 and is_identifier(key[1]) nomsu = NomsuCode\from(tree.source)
NomsuCode\from(key.source, key[1]) -- TODO: remove shim
else tree_to_inline_nomsu(key) if key.type != "Index"
nomsu\parenthesize! if key.type == "Action" or key.type == "MethodCall" or key.type == "Block" key = {type:"Index", source:key.source, key}
nomsu\add tree_to_inline_nomsu(key)
if value if value
nomsu\add ": " nomsu\add " = "
value_nomsu = tree_to_inline_nomsu(value) value_nomsu = tree_to_inline_nomsu(value)
value_nomsu\parenthesize! if value.type == "Block" value_nomsu\parenthesize! if value.type == "Block" or value.type == "Action" or value.type == "MethodCall"
nomsu\add value_nomsu nomsu\add value_nomsu
return nomsu return nomsu
when "Index"
key = tree[1]
nomsu = NomsuCode\from(key.source, ".")
key_nomsu = if key.type == "Text" and #key == 1 and is_identifier(key[1])
key[1]
else
tree_to_inline_nomsu(key)
key_nomsu\parenthesize! if key.type == "Block" or key.type == "Action" or key.type == "MethodCall"
return NomsuCode\from(key.source, ".", key_nomsu)
when "IndexChain" when "IndexChain"
nomsu = NomsuCode\from(tree.source) nomsu = NomsuCode\from(tree.source)
for i, bit in ipairs tree for i, bit in ipairs tree
@ -183,7 +201,7 @@ tree_to_nomsu = (tree)->
if try_inline if try_inline
inline_nomsu = tree_to_inline_nomsu(t) inline_nomsu = tree_to_inline_nomsu(t)
if #inline_nomsu\text! <= space or #inline_nomsu\text! <= 8 if #inline_nomsu\text! <= space or #inline_nomsu\text! <= 8
if t.type == "Action" or t.type == "MethodCall" if (t.type == "Action" or t.type == "MethodCall")
inline_nomsu\parenthesize! inline_nomsu\parenthesize!
return inline_nomsu return inline_nomsu
if t.type == "Text" and #inline_nomsu\text! + 2 < MAX_LINE if t.type == "Text" and #inline_nomsu\text! + 2 < MAX_LINE
@ -191,8 +209,9 @@ tree_to_nomsu = (tree)->
indented = tree_to_nomsu(t) indented = tree_to_nomsu(t)
if t.type == "Action" or t.type == "MethodCall" if t.type == "Action" or t.type == "MethodCall"
if indented\is_multiline! if indented\is_multiline!
return NomsuCode\from(t.source, "(..)\n ", indented) return NomsuCode\from(t.source, "(\n ", indented, "\n)")
else indented\parenthesize! else
indented\parenthesize!
if inline_nomsu and indented\text!\match("^[^\n]*\n[^\n]*$") and nomsu\trailing_line_len! <= 8 if inline_nomsu and indented\text!\match("^[^\n]*\n[^\n]*$") and nomsu\trailing_line_len! <= 8
return inline_nomsu return inline_nomsu
return indented return indented
@ -227,7 +246,7 @@ tree_to_nomsu = (tree)->
words = table.concat(word_buffer) words = table.concat(word_buffer)
if next_space == " " if next_space == " "
if nomsu\trailing_line_len! + #words > MAX_LINE and nomsu\trailing_line_len! > 8 if nomsu\trailing_line_len! + #words > MAX_LINE and nomsu\trailing_line_len! > 8
next_space = " \\\n.." next_space = "\n.."
elseif word_buffer[1] == "'" elseif word_buffer[1] == "'"
next_space = "" next_space = ""
nomsu\add next_space, words nomsu\add next_space, words
@ -236,30 +255,32 @@ tree_to_nomsu = (tree)->
num_args += 1 num_args += 1
bit_nomsu = recurse(bit) bit_nomsu = recurse(bit)
if bit.type == "Block" and not bit_nomsu\is_multiline! if bit.type == "Block"
-- Rule of thumb: nontrivial one-liner block arguments should be no more -- Rule of thumb: nontrivial one-liner block arguments should be no more
-- than golden ratio * the length of the proceeding part of the line -- than golden ratio * the length of the proceeding part of the line
if #bit_nomsu\text! > nomsu\trailing_line_len! * GOLDEN_RATIO and #bit_nomsu\text! > 8 if not bit_nomsu\is_multiline! and #bit_nomsu\text! > nomsu\trailing_line_len! * GOLDEN_RATIO and #bit_nomsu\text! > 8
bit_nomsu = tree_to_nomsu(bit) bit_nomsu = tree_to_nomsu(bit)
elseif (not bit_nomsu\is_multiline! and
if (next_space == " " and not bit_nomsu\is_multiline! and
nomsu\trailing_line_len! + #bit_nomsu\text! > MAX_LINE and nomsu\trailing_line_len! + #bit_nomsu\text! > MAX_LINE and
nomsu\trailing_line_len! > 8) nomsu\trailing_line_len! > 8)
if bit.type == 'Action' or bit.type == "MethodCall" if next_space == " " and #bit_nomsu\text! < MAX_LINE
bit_nomsu = NomsuCode\from bit.source, "(..)\n ", tree_to_nomsu(bit) next_space = "\n.."
elseif bit.type == 'Action' or bit.type == "MethodCall"
bit_nomsu = NomsuCode\from bit.source, "(\n ", tree_to_nomsu(bit), ")"
else else
next_space = " \\\n.." bit_nomsu = tree_to_nomsu(bit)
unless next_space == " " and bit.type == "Block"
unless next_space == " " and bit_nomsu\text!\match("^:")
nomsu\add next_space nomsu\add next_space
nomsu\add bit_nomsu nomsu\add bit_nomsu
next_space = (bit_nomsu\is_multiline! or bit.type == 'Block') and "\n.." or " " next_space = (bit.type == 'Block' and bit_nomsu\is_multiline!) and "\n.." or " "
if #word_buffer > 0 if #word_buffer > 0
words = table.concat(word_buffer) words = table.concat(word_buffer)
if next_space == " " if next_space == " "
if nomsu\trailing_line_len! + #words > MAX_LINE and nomsu\trailing_line_len! > 8 if nomsu\trailing_line_len! + #words > MAX_LINE and nomsu\trailing_line_len! > 8
next_space = " \\\n.." next_space = "\n.."
elseif word_buffer[1] == "'" elseif word_buffer[1] == "'"
next_space = "" next_space = ""
nomsu\add next_space, words nomsu\add next_space, words
@ -271,8 +292,7 @@ tree_to_nomsu = (tree)->
target_nomsu = recurse(tree[1]) target_nomsu = recurse(tree[1])
if tree[1].type == "Block" and not target_nomsu\is_multiline! if tree[1].type == "Block" and not target_nomsu\is_multiline!
target_nomsu\parenthesize! target_nomsu\parenthesize!
nomsu\add target_nomsu nomsu\add target_nomsu, ", "
nomsu\add(target_nomsu\is_multiline! and "\n..|" or "|")
inner_nomsu = NomsuCode! inner_nomsu = NomsuCode!
for i=2,#tree for i=2,#tree
inner_nomsu\add "\n" if i > 2 inner_nomsu\add "\n" if i > 2
@ -307,13 +327,15 @@ tree_to_nomsu = (tree)->
when "Text" when "Text"
-- Multi-line text has more generous wrap margins -- Multi-line text has more generous wrap margins
max_line = math.floor(1.25*MAX_LINE) max_line = MAX_LINE + 8
add_text = (tree)-> add_text = (tree)->
for i, bit in ipairs tree for i, bit in ipairs tree
if type(bit) == 'string' if type(bit) == 'string'
bit = escape(bit) bit = escape(bit)
for j, line in ipairs bit\lines! for j, line in ipairs bit\lines!
if j > 1 if j > 1
if nomsu\text!\match(" $")
nomsu\add "\\;"
nomsu\add "\n" nomsu\add "\n"
elseif #line > 10 and nomsu\trailing_line_len! > max_line elseif #line > 10 and nomsu\trailing_line_len! > max_line
nomsu\add "\\\n.." nomsu\add "\\\n.."
@ -343,10 +365,12 @@ tree_to_nomsu = (tree)->
elseif bit.type == "EscapedNomsu" or bit.type == "Block" or bit.type == "IndexChain" elseif bit.type == "EscapedNomsu" or bit.type == "Block" or bit.type == "IndexChain"
interp_nomsu\parenthesize! interp_nomsu\parenthesize!
nomsu\add interp_nomsu nomsu\add interp_nomsu
if interp_nomsu\is_multiline! if interp_nomsu\is_multiline! and bit.type == "Block"
nomsu\add "\n.." nomsu\add "\n.."
add_text(tree) add_text(tree)
return NomsuCode\from(tree.source, '"\n ', nomsu, '"') if nomsu\text!\match(" $")
nomsu\add "\\;"
return NomsuCode\from(tree.source, '"\n ', nomsu, '\n"')
when "List", "Dict" when "List", "Dict"
if #tree == 0 if #tree == 0
@ -354,12 +378,16 @@ tree_to_nomsu = (tree)->
return nomsu return nomsu
sep = '' sep = ''
for i, item in ipairs tree for i, item in ipairs tree
item_nomsu = tree_to_inline_nomsu(item) local item_nomsu
if #item_nomsu\text! > MAX_LINE if item.type == 'MethodCall'
item_nomsu = recurse(item) item_nomsu = recurse(item)
if item.type == 'Comment' elseif item.type == 'Comment'
sep = '\n'
item_nomsu = tree_to_nomsu(item) item_nomsu = tree_to_nomsu(item)
sep = '\n' if i > 1
else
item_nomsu = tree_to_inline_nomsu(item)
if #item_nomsu\text! > MAX_LINE
item_nomsu = recurse(item)
nomsu\add sep nomsu\add sep
nomsu\add item_nomsu nomsu\add item_nomsu
if item_nomsu\is_multiline! or item.type == 'Comment' or nomsu\trailing_line_len! + #tostring(item_nomsu) >= MAX_LINE if item_nomsu\is_multiline! or item.type == 'Comment' or nomsu\trailing_line_len! + #tostring(item_nomsu) >= MAX_LINE
@ -367,28 +395,29 @@ tree_to_nomsu = (tree)->
else else
sep = ', ' sep = ', '
return if tree.type == "List" then return if tree.type == "List" then
NomsuCode\from(tree.source, "[..]\n ", nomsu) NomsuCode\from(tree.source, "[\n ", nomsu, "\n]")
else else
NomsuCode\from(tree.source, "{..}\n ", nomsu) NomsuCode\from(tree.source, "{\n ", nomsu, "\n}")
when "DictEntry" when "DictEntry"
key, value = tree[1], tree[2] key, value = tree[1], tree[2]
nomsu = if key.type == "Text" and #key == 1 and is_identifier(key[1]) nomsu = NomsuCode\from(tree.source)
NomsuCode\from(key.source, key[1]) -- TODO: remove shim
else tree_to_inline_nomsu(key) if key.type != "Index"
nomsu\parenthesize! if key.type == "Block" key = {type:"Index", source:key.source, key}
nomsu\add tree_to_nomsu(key)
if value if value
value_nomsu = tree_to_nomsu(value) value_nomsu = tree_to_nomsu(value)
if (value.type == "Block" or value.type == "EscapedNomsu") and not value_nomsu\is_multiline! if (value.type == "Block" or value.type == "Action" or value.type == "MethodCall") and not value_nomsu\is_multiline!
value_nomsu\parenthesize! value_nomsu\parenthesize!
nomsu\add ": ", value_nomsu nomsu\add " = ", value_nomsu
return nomsu return nomsu
when "Comment" when "Comment"
nomsu\add "#", (tree[1]\gsub("\n", "\n ")) nomsu\add "#", (tree[1]\gsub("\n", "\n "))
return nomsu return nomsu
when "IndexChain", "Number", "Var", "Comment", "Error" when "IndexChain", "Index", "Number", "Var", "Comment", "Error"
return tree_to_inline_nomsu tree return tree_to_inline_nomsu tree
else else

32
parser.lua
View File

@ -3,6 +3,19 @@ local re = require('re')
lpeg.setmaxstack(20000) lpeg.setmaxstack(20000)
local P, R, S, C, Cmt, Carg, Cc local P, R, S, C, Cmt, Carg, Cc
P, R, S, C, Cmt, Carg, Cc = lpeg.P, lpeg.R, lpeg.S, lpeg.C, lpeg.Cmt, lpeg.Carg, lpeg.Cc P, R, S, C, Cmt, Carg, Cc = lpeg.P, lpeg.R, lpeg.S, lpeg.C, lpeg.Cmt, lpeg.Carg, lpeg.Cc
local foldr
foldr = function(...)
local inner = select(1, ...)
for i = 2, select('#', ...) do
assert(inner.type)
local outer = select(i, ...)
table.insert(outer, 1, inner)
inner.start = outer.start
inner = outer
end
assert(inner.type)
return inner
end
local DEFS local DEFS
do do
local _with_0 = { } local _with_0 = { }
@ -17,6 +30,7 @@ do
_with_0.Tree = function(t, userdata) _with_0.Tree = function(t, userdata)
return userdata.make_tree(t, userdata) return userdata.make_tree(t, userdata)
end end
_with_0.foldr = foldr
DEFS = _with_0 DEFS = _with_0
end end
setmetatable(DEFS, { setmetatable(DEFS, {
@ -40,16 +54,14 @@ setmetatable(DEFS, {
end end
end end
}) })
local peg_tidier = re.compile([[file <- %nl* {~ (def/comment) (%nl+ (def/comment))* %nl* ~} local peg_tidier = re.compile([[ file <- %nl* {~ (captured_def/line) (%nl+ (captured_def/line))* %nl* ~}
def <- anon_def / captured_def ident <- [a-zA-Z_][a-zA-Z0-9_]*
anon_def <- line <- [^%nl]*
({ident} (" "*) ":" {[^%nl]* (%nl+ " "+ [^%nl]*)*}) captured_def <-
-> "%1 <- %2" ({ident} (" "*) "(" {ident} ")" (" "*) "<-" {[^%nl]* (%nl+ " "+ [^%nl]*)*}) ->
captured_def <- "%1 <- ({| {:type:''->'%2':} {:start:{}:}
({ident} (" "*) "(" {ident} ")" (" "*) ":" {[^%nl]* (%nl+ " "+ [^%nl]*)*}) %3
-> "%1 <- ({| {:start:{}:} %3 {:stop:{}:} {:type: (''->'%2') :} |} %%userdata) -> Tree" {:stop:{}:} |} %%userdata) -> Tree"
ident <- [a-zA-Z_][a-zA-Z0-9_]*
comment <- "--" [^%nl]*
]]) ]])
local make_parser local make_parser
make_parser = function(peg, make_tree) make_parser = function(peg, make_tree)

35
parser.moon
View File

@ -4,6 +4,18 @@ re = require 're'
lpeg.setmaxstack 20000 lpeg.setmaxstack 20000
{:P,:R,:S,:C,:Cmt,:Carg,:Cc} = lpeg {:P,:R,:S,:C,:Cmt,:Carg,:Cc} = lpeg
-- foldr {A{a1,a2,...},B{b1,b2,...},C{c1,c2,...}} -> C{B{A{a1,a2,...},b1,b2...},c1,c2...}
foldr = (...)->
inner = select(1,...)
for i=2,select('#',...) do
assert inner.type
outer = select(i,...)
table.insert(outer, 1, inner)
inner.start = outer.start
inner = outer
assert inner.type
return inner
DEFS = with {} DEFS = with {}
-- Newline supports either windows-style CR+LF or unix-style LF -- Newline supports either windows-style CR+LF or unix-style LF
.nl = P("\r")^-1 * P("\n") .nl = P("\r")^-1 * P("\n")
@ -18,6 +30,7 @@ DEFS = with {}
R("\224\239")*R("\128\191")*R("\128\191") + R("\224\239")*R("\128\191")*R("\128\191") +
R("\240\244")*R("\128\191")*R("\128\191")*R("\128\191")) R("\240\244")*R("\128\191")*R("\128\191")*R("\128\191"))
.Tree = (t, userdata)-> userdata.make_tree(t, userdata) .Tree = (t, userdata)-> userdata.make_tree(t, userdata)
.foldr = foldr
setmetatable(DEFS, {__index:(key)=> setmetatable(DEFS, {__index:(key)=>
if i = key\match("^ascii_(%d+)$") if i = key\match("^ascii_(%d+)$")
@ -30,19 +43,17 @@ setmetatable(DEFS, {__index:(key)=>
return p return p
}) })
-- Just for cleanliness, I put the language spec in its own file using a slightly modified -- Just for cleanliness, I put the language spec in its own file using a slightly
-- version of the lpeg.re syntax. -- extended version of the lpeg.re syntax.
peg_tidier = re.compile [[ peg_tidier = re.compile [[
file <- %nl* {~ (def/comment) (%nl+ (def/comment))* %nl* ~} file <- %nl* {~ (captured_def/line) (%nl+ (captured_def/line))* %nl* ~}
def <- anon_def / captured_def ident <- [a-zA-Z_][a-zA-Z0-9_]*
anon_def <- line <- [^%nl]*
({ident} (" "*) ":" {[^%nl]* (%nl+ " "+ [^%nl]*)*}) captured_def <-
-> "%1 <- %2" ({ident} (" "*) "(" {ident} ")" (" "*) "<-" {[^%nl]* (%nl+ " "+ [^%nl]*)*}) ->
captured_def <- "%1 <- ({| {:type:''->'%2':} {:start:{}:}
({ident} (" "*) "(" {ident} ")" (" "*) ":" {[^%nl]* (%nl+ " "+ [^%nl]*)*}) %3
-> "%1 <- ({| {:start:{}:} %3 {:stop:{}:} {:type: (''->'%2') :} |} %%userdata) -> Tree" {:stop:{}:} |} %%userdata) -> Tree"
ident <- [a-zA-Z_][a-zA-Z0-9_]*
comment <- "--" [^%nl]*
]] ]]
make_parser = (peg, make_tree=nil)-> make_parser = (peg, make_tree=nil)->

12
syntax_tree.lua
View File

@ -38,17 +38,17 @@ do
local _len_0 = 1 local _len_0 = 1
for _index_0 = 1, #self do for _index_0 = 1, #self do
local b = self[_index_0] local b = self[_index_0]
_accum_0[_len_0] = tostring(b) _accum_0[_len_0] = type(b) == 'string' and b:as_lua() or tostring(b)
_len_0 = _len_0 + 1 _len_0 = _len_0 + 1
end end
bits = _accum_0 bits = _accum_0
end end
for k, v in pairs(self) do for k, v in pairs(self) do
if not (bits[k]) then if not (bits[k] or k == 'type' or k == 'source') then
table.insert(bits, "[ " .. tostring(tostring(k)) .. "]=" .. tostring(tostring(v))) table.insert(bits, tostring(k) .. "=" .. tostring(type(v) == 'string' and v:as_lua() or v))
end end
end end
return "SyntaxTree{" .. tostring(table.concat(bits, ", ")) .. "}" return tostring(self.type) .. "{" .. tostring(table.concat(bits, ", ")) .. "}"
end, end,
__eq = function(self, other) __eq = function(self, other)
if type(self) ~= type(other) or #self ~= #other or getmetatable(self) ~= getmetatable(other) then if type(self) ~= type(other) or #self ~= #other or getmetatable(self) ~= getmetatable(other) then
@ -146,6 +146,7 @@ do
assert(self.type == "Action" or self.type == "MethodCall", "Only actions and method calls have arguments") assert(self.type == "Action" or self.type == "MethodCall", "Only actions and method calls have arguments")
local args = { } local args = { }
if self.type == "MethodCall" then if self.type == "MethodCall" then
assert(#self == 2, "Can't get arguments for multiple method calls at once.")
args[1] = self[1] args[1] = self[1]
local _list_0 = self[2] local _list_0 = self[2]
for _index_0 = 1, #_list_0 do for _index_0 = 1, #_list_0 do
@ -166,6 +167,7 @@ do
end, end,
get_stub = function(self) get_stub = function(self)
if self.type == "MethodCall" then if self.type == "MethodCall" then
assert(#self == 2, "Can't get the stubs of multiple method calls at once.")
return self[2]:get_stub() return self[2]:get_stub()
end end
local stub_bits = { } local stub_bits = { }
@ -222,8 +224,6 @@ getmetatable(SyntaxTree).__call = function(self, t)
setmetatable(t, self.__base) setmetatable(t, self.__base)
if t.type == 'Action' then if t.type == 'Action' then
t.stub = t:get_stub() t.stub = t:get_stub()
elseif t.type == 'MethodCall' then
t.stub = t[2]:get_stub()
end end
return t return t
end end

12
syntax_tree.moon
View File

@ -19,11 +19,11 @@ class SyntaxTree
@__type: "Syntax Tree" @__type: "Syntax Tree"
__tostring: => __tostring: =>
bits = [tostring(b) for b in *@] bits = [type(b) == 'string' and b\as_lua! or tostring(b) for b in *@]
for k,v in pairs(@) for k,v in pairs(@)
unless bits[k] unless bits[k] or k == 'type' or k == 'source'
table.insert(bits, "[ #{tostring(k)}]=#{tostring(v)}") table.insert(bits, "#{k}=#{type(v) == 'string' and v\as_lua! or v}")
return "SyntaxTree{#{table.concat(bits, ", ")}}" return "#{@type}{#{table.concat(bits, ", ")}}"
__eq: (other)=> __eq: (other)=>
return false if type(@) != type(other) or #@ != #other or getmetatable(@) != getmetatable(other) return false if type(@) != type(other) or #@ != #other or getmetatable(@) != getmetatable(other)
@ -76,6 +76,7 @@ class SyntaxTree
assert(@type == "Action" or @type == "MethodCall", "Only actions and method calls have arguments") assert(@type == "Action" or @type == "MethodCall", "Only actions and method calls have arguments")
args = {} args = {}
if @type == "MethodCall" if @type == "MethodCall"
assert(#@ == 2, "Can't get arguments for multiple method calls at once.")
args[1] = @[1] args[1] = @[1]
for tok in *@[2] for tok in *@[2]
if type(tok) != 'string' then args[#args+1] = tok if type(tok) != 'string' then args[#args+1] = tok
@ -86,6 +87,7 @@ class SyntaxTree
get_stub: => get_stub: =>
if @type == "MethodCall" if @type == "MethodCall"
assert(#@ == 2, "Can't get the stubs of multiple method calls at once.")
return @[2]\get_stub! return @[2]\get_stub!
stub_bits = {} stub_bits = {}
arg_i = 1 arg_i = 1
@ -109,8 +111,6 @@ getmetatable(SyntaxTree).__call = (t)=>
setmetatable(t, @__base) setmetatable(t, @__base)
if t.type == 'Action' if t.type == 'Action'
t.stub = t\get_stub! t.stub = t\get_stub!
elseif t.type == 'MethodCall'
t.stub = t[2]\get_stub!
return t return t
return SyntaxTree return SyntaxTree