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

Removing end-of-line ":" and "(..)" for blocks (they just use

Browse Source 
indentation now).
This commit is contained in:
Bruce Hill 2018-04-25 16:30:49 -07:00
parent 50a092e4b5
commit 5d59d510cd
15 changed files with 225 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
core/collections.nom
View File

@ -9,18 +9,18 @@ use "core/operators.nom"
# List/dict functions: # List/dict functions:
# Indexing # Indexing
immediately: immediately
compile [..] compile [..]
%index st to last in %list, %index nd to last in %list, %index rd to last in %list %index st to last in %list, %index nd to last in %list, %index rd to last in %list
%index th to last in %list %index th to last in %list
..to: Lua value "utils.nth_to_last(\(%list as lua expr), \(%index as lua expr))" ..to: Lua value "utils.nth_to_last(\(%list as lua expr), \(%index as lua expr))"
immediately: immediately
parse [first in %list, first %list] as: 1 st in %list parse [first in %list, first %list] as: 1 st in %list
parse [last in %list, last %list] as: 1 st to last in %list parse [last in %list, last %list] as: 1 st to last in %list
# Membership testing # Membership testing
immediately: immediately
action [%item is in %list, %list contains %item, %list has %item] action [%item is in %list, %list contains %item, %list has %item]
for %key = %value in %list for %key = %value in %list
if (%key is %item): return (yes) if (%key is %item): return (yes)
@ -30,12 +30,12 @@ immediately:
%item isn't in %list, %item is not in %list %item isn't in %list, %item is not in %list
%list doesn't contain %item, %list does not contain %item %list doesn't contain %item, %list does not contain %item
%list doesn't have %item, %list does not have %item %list doesn't have %item, %list does not have %item
..: ..
for %key = %value in %list for %key = %value in %list
if (%key is %item): return (no) if (%key is %item): return (no)
return (yes) return (yes)
immediately: immediately
# Note: it's important to have the space after "[" to prevent confusion if %index is a string # Note: it's important to have the space after "[" to prevent confusion if %index is a string
compile [%list has key %index, %list has index %index] to compile [%list has key %index, %list has index %index] to
Lua value ".." Lua value ".."
@ -47,21 +47,21 @@ immediately:
%list doesn't have index %index, %list does not have index %index %list doesn't have index %index, %list does not have index %index
..to: Lua value "((\(%list as lua expr))[ \(%index as lua expr)] == nil)" ..to: Lua value "((\(%list as lua expr))[ \(%index as lua expr)] == nil)"
compile [number of keys in %list] to: compile [number of keys in %list] to
Lua value "utils.size(\(%list as lua expr))" Lua value "utils.size(\(%list as lua expr))"
compile [append %item to %list, add %item to %list, to %list add %item, to %list append %item] to: compile [append %item to %list, add %item to %list, to %list add %item, to %list append %item] to
Lua "table.insert(\(%list as lua expr), \(%item as lua expr))" Lua "table.insert(\(%list as lua expr), \(%item as lua expr))"
compile [pop from %list, remove last from %list] to: compile [pop from %list, remove last from %list] to
Lua "table.remove(\(%list as lua expr))" Lua "table.remove(\(%list as lua expr))"
compile [remove index %index from %list] to: compile [remove index %index from %list] to
Lua "table.remove(\(%list as lua expr), \(%index as lua expr))" Lua "table.remove(\(%list as lua expr), \(%index as lua expr))"
# List Comprehension # List Comprehension
immediately: immediately
compile [%expression for %item in %iterable] to: compile [%expression for %item in %iterable] to
assume (%item.type is "Var") or barf ".." assume (%item.type is "Var") or barf ".."
List comprehension has the wrong type for the loop variable. Expected Var, but got: \(%item.type) List comprehension has the wrong type for the loop variable. Expected Var, but got: \(%item.type)
return return
@ -78,7 +78,7 @@ immediately:
compile [..] compile [..]
%expression for %index from %start to %stop via %step %expression for %index from %start to %stop via %step
%expression for %index from %start to %stop by %step %expression for %index from %start to %stop by %step
..to: ..to
assume (%index.type is "Var") or barf ".." assume (%index.type is "Var") or barf ".."
List comprehension has the wrong type for the loop variable. Expected Var, but got: \(%index.type) List comprehension has the wrong type for the loop variable. Expected Var, but got: \(%index.type)
return return
@ -98,7 +98,7 @@ immediately:
..as: %expression for % from %start to %stop via %step ..as: %expression for % from %start to %stop via %step
parse [%expression for all %start to %stop] as: %expression for all %start to %stop via 1 parse [%expression for all %start to %stop] as: %expression for all %start to %stop via 1
compile [%expression for %key = %value in %iterable] to: compile [%expression for %key = %value in %iterable] to
assume (%key.type is "Var") or barf ".." assume (%key.type is "Var") or barf ".."
List comprehension has the wrong type for the key loop variable. Expected Var, but got: \(%key.type) List comprehension has the wrong type for the key loop variable. Expected Var, but got: \(%key.type)
assume (%value.type is "Var") or barf ".." assume (%value.type is "Var") or barf ".."
@ -114,8 +114,8 @@ immediately:
end)() end)()
# Dict comprehensions # Dict comprehensions
immediately: immediately
compile [%key = %value for %item in %iterable] to: compile [%key = %value for %item in %iterable] to
assume (%item.type is "Var") or barf ".." assume (%item.type is "Var") or barf ".."
Dict comprehension has the wrong type for the loop variable. Expected Var, but got: \(%item.type) Dict comprehension has the wrong type for the loop variable. Expected Var, but got: \(%item.type)
# Note: it's important to have the space after "[" to prevent confusion if %key is a string # Note: it's important to have the space after "[" to prevent confusion if %key is a string
@ -130,7 +130,7 @@ immediately:
end)() end)()
parse [%key = %value for all %iterable] as: %key = %value for % in %iterable parse [%key = %value for all %iterable] as: %key = %value for % in %iterable
compile [%key = %value for %src_key = %src_value in %iterable] to: compile [%key = %value for %src_key = %src_value in %iterable] to
assume (%src_key.type is "Var") or barf ".." assume (%src_key.type is "Var") or barf ".."
Dict comprehension has the wrong type for the key loop variable. Expected Var, but got: \(%src_key.type) Dict comprehension has the wrong type for the key loop variable. Expected Var, but got: \(%src_key.type)
assume (%src_value.type is "Var") or barf ".." assume (%src_value.type is "Var") or barf ".."
@ -146,11 +146,11 @@ immediately:
return comprehension; return comprehension;
end)() end)()
immediately: immediately
action [%lists flattened]: action [%lists flattened]
%flat <- [] %flat <- []
for %list in %lists: for %list in %lists
for %item in %list: for %item in %list
add %item to %flat add %item to %flat
return %flat return %flat
@ -158,8 +158,8 @@ immediately:
parse [keys in %dict] as: %k for %k = %v in %dict parse [keys in %dict] as: %k for %k = %v in %dict
parse [values in %dict] as: %v for %k = %v in %dict parse [values in %dict] as: %v for %k = %v in %dict
# Sorting: # Sorting
immediately: immediately
compile [sort %items] to: Lua "table.sort(\(%items as lua expr));" compile [sort %items] to: Lua "table.sort(\(%items as lua expr));"
compile [sort %items by %key_expr] to compile [sort %items by %key_expr] to
Lua ".." Lua ".."
@ -167,26 +167,26 @@ immediately:
return \(%key_expr as lua expr); return \(%key_expr as lua expr);
end); end);
immediately: immediately
action [%items sorted, sorted %items]: action [%items sorted, sorted %items]
%copy <- (% for all %items) %copy <- (% for all %items)
sort %copy sort %copy
return %copy return %copy
action [%items sorted by %key]: action [%items sorted by %key]
%copy <- (% for all %items) %copy <- (% for all %items)
sort %copy by %key sort %copy by %key
return %copy return %copy
action [unique %items]: action [unique %items]
%unique <- [] %unique <- []
%seen <- {} %seen <- {}
for all %items: for all %items
unless: % in %seen unless: % in %seen
add % to %unique add % to %unique
(% in %seen) <- (yes) (% in %seen) <- (yes)
return %unique return %unique
immediately: immediately
# Metatable stuff # Metatable stuff
compile [set %dict's metatable to %metatable] to compile [set %dict's metatable to %metatable] to
Lua "setmetatable(\(%dict as lua expr), \(%metatable as lua expr));" Lua "setmetatable(\(%dict as lua expr), \(%metatable as lua expr));"

126
core/control_flow.nom
View File

@ -7,19 +7,19 @@ use "core/text.nom"
use "core/operators.nom" use "core/operators.nom"
# No-Op # No-Op
immediately: immediately
compile [do nothing] to: Lua "" compile [do nothing] to: Lua ""
# Conditionals # Conditionals
immediately: immediately
compile [if %condition %if_body] to: compile [if %condition %if_body] to
Lua ".." Lua ".."
if \(%condition as lua expr) then if \(%condition as lua expr) then
\(%if_body as lua statements) \(%if_body as lua statements)
end end
parse [unless %condition %unless_body] as: if (not %condition) %unless_body parse [unless %condition %unless_body] as: if (not %condition) %unless_body
compile [if %condition %if_body else %else_body, unless %condition %else_body else %if_body] to: compile [if %condition %if_body else %else_body, unless %condition %else_body else %if_body] to
Lua ".." Lua ".."
if \(%condition as lua expr) then if \(%condition as lua expr) then
\(%if_body as lua statements) \(%if_body as lua statements)
@ -36,18 +36,18 @@ immediately
%when_true_expr if %condition otherwise %when_false_expr %when_true_expr if %condition otherwise %when_false_expr
%when_false_expr unless %condition else %when_true_expr %when_false_expr unless %condition else %when_true_expr
%when_false_expr unless %condition then %when_true_expr %when_false_expr unless %condition then %when_true_expr
..to: ..to
#.. If %when_true_expr is guaranteed to be truthy, we can use Lua's idiomatic #.. If %when_true_expr is guaranteed to be truthy, we can use Lua's idiomatic
equivalent of a conditional expression: (cond and if_true or if_false) equivalent of a conditional expression: (cond and if_true or if_false)
if: %when_true_expr.type in {Text:yes, List:yes, Dict:yes, Number:yes} if: %when_true_expr.type in {Text:yes, List:yes, Dict:yes, Number:yes}
return: return
Lua value ".." Lua value ".."
(\(%condition as lua expr) and \(%when_true_expr as lua expr) or \(%when_false_expr as lua expr)) (\(%condition as lua expr) and \(%when_true_expr as lua expr) or \(%when_false_expr as lua expr))
..else: ..else
#.. Otherwise, need to do an anonymous inline function (yuck, too bad lua #.. Otherwise, need to do an anonymous inline function (yuck, too bad lua
doesn't have a proper ternary operator!) doesn't have a proper ternary operator!)
To see why this is necessary consider: (random()<.5 and false or 99) To see why this is necessary consider: (random()<.5 and false or 99)
return: return
Lua value ".." Lua value ".."
(function() (function()
if \(%condition as lua expr) then if \(%condition as lua expr) then
@ -58,20 +58,20 @@ immediately
end)() end)()
# GOTOs # GOTOs
immediately: immediately
compile [=== %label ===, --- %label ---, *** %label ***] to compile [=== %label ===, --- %label ---, *** %label ***] to
Lua "::label_\(%label as lua identifier)::;" Lua "::label_\(%label as lua identifier)::;"
compile [go to %label] to compile [go to %label] to
Lua "goto label_\(%label as lua identifier);" Lua "goto label_\(%label as lua identifier);"
# Basic loop control # Basic loop control
immediately: immediately
compile [do next] to: Lua "continue;" compile [do next] to: Lua "continue;"
compile [stop] to: Lua "break;" compile [stop] to: Lua "break;"
# Helper function # Helper function
immediately: immediately
compile [if %tree has subtree %subtree where %condition %body] to: compile [if %tree has subtree %subtree where %condition %body] to
Lua ".." Lua ".."
for \(%subtree as lua expr) in coroutine.wrap(function() nomsu:walk_tree(\(%tree as lua expr)) end) do for \(%subtree as lua expr) in coroutine.wrap(function() nomsu:walk_tree(\(%tree as lua expr)) end) do
if Types.is_node(\(%subtree as lua expr)) then if Types.is_node(\(%subtree as lua expr)) then
@ -83,7 +83,7 @@ immediately:
end end
# While loops # While loops
immediately: immediately
compile [do next repeat] to: Lua "goto continue_repeat;" compile [do next repeat] to: Lua "goto continue_repeat;"
compile [stop repeating] to: Lua "goto stop_repeat;" compile [stop repeating] to: Lua "goto stop_repeat;"
compile [repeat while %condition %body] to compile [repeat while %condition %body] to
@ -91,14 +91,14 @@ immediately:
Lua ".." Lua ".."
while \(%condition as lua expr) do while \(%condition as lua expr) do
\(%body as lua statements) \(%body as lua statements)
if %body has subtree % where: if %body has subtree % where
(%.type = "Action") and ((%'s stub) is "do next repeat") (%.type = "Action") and ((%'s stub) is "do next repeat")
..: ..
to %lua write "\n ::continue_repeat::;" to %lua write "\n ::continue_repeat::;"
to %lua write "\nend --while-loop" to %lua write "\nend --while-loop"
if %body has subtree % where: if %body has subtree % where
(%.type = "Action") and ((%'s stub) is "stop repeating") (%.type = "Action") and ((%'s stub) is "stop repeating")
..: ..
%lua <- %lua <-
Lua ".." Lua ".."
do -- scope of "stop repeating" label do -- scope of "stop repeating" label
@ -111,7 +111,7 @@ immediately:
compile [..] compile [..]
repeat %n times %body repeat %n times %body
..to: ..to
%lua <- %lua <-
Lua ".." Lua ".."
for i=1,\(%n as lua expr) do for i=1,\(%n as lua expr) do
@ -120,10 +120,10 @@ immediately:
(%.type = "Action") and ((%'s stub) is "do next repeat") (%.type = "Action") and ((%'s stub) is "do next repeat")
..: to %lua write "\n ::continue_repeat::;" ..: to %lua write "\n ::continue_repeat::;"
to %lua write "\nend --numeric for-loop" to %lua write "\nend --numeric for-loop"
if %body has subtree % where: if %body has subtree % where
(%.type = "Action") and ((%'s stub) is "stop repeating") (%.type = "Action") and ((%'s stub) is "stop repeating")
..: ..
%lua <-: %lua <-
Lua ".." Lua ".."
do -- scope of "stop repeating" label do -- scope of "stop repeating" label
\%lua \%lua
@ -131,37 +131,37 @@ immediately:
end -- end of "stop repeating" label scope end -- end of "stop repeating" label scope
return %lua return %lua
# For loop control flow: # For loop control flow
immediately: immediately
compile [stop %var] to compile [stop %var] to
Lua "goto stop_\(%var as lua identifier);" Lua "goto stop_\(%var as lua identifier);"
compile [do next %var] to compile [do next %var] to
Lua "goto continue_\(%var as lua identifier);" Lua "goto continue_\(%var as lua identifier);"
# Numeric range for loops # Numeric range for loops
immediately: immediately
compile [..] compile [..]
for %var from %start to %stop by %step %body for %var from %start to %stop by %step %body
for %var from %start to %stop via %step %body for %var from %start to %stop via %step %body
..to: ..to
# This uses Lua's approach of only allowing loop-scoped variables in a loop # This uses Lua's approach of only allowing loop-scoped variables in a loop
assume (%var.type is "Var") or barf "Loop expected variable, not: \(%var's source code)" assume (%var.type is "Var") or barf "Loop expected variable, not: \(%var's source code)"
%lua <- %lua <-
Lua ".." Lua ".."
for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(%step as lua expr) do for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(%step as lua expr) do
\(%body as lua statements) \(%body as lua statements)
if %body has subtree % where: if %body has subtree % where
(%.type = "Action") and (%.type = "Action") and
((%'s stub) is "do next %") and ((%'s stub) is "do next %") and
%.value.3.value is %var.value %.value.3.value is %var.value
..: to %lua write "\n ::continue_\(%var as lua identifier)::;" ..: to %lua write "\n ::continue_\(%var as lua identifier)::;"
to %lua write "\nend --numeric for-loop" to %lua write "\nend --numeric for-loop"
if %body has subtree % where: if %body has subtree % where
(%.type = "Action") and: (%.type = "Action") and
((%'s stub) is "stop %") and: ((%'s stub) is "stop %") and
%.value.2.value is %var.value %.value.2.value is %var.value
..: ..
%lua <- %lua <-
Lua ".." Lua ".."
do -- scope for stopping for-loop do -- scope for stopping for-loop
@ -171,7 +171,7 @@ immediately:
return %lua return %lua
immediately: immediately
parse [for %var from %start to %stop %body] as: for %var from %start to %stop via 1 %body parse [for %var from %start to %stop %body] as: for %var from %start to %stop via 1 %body
parse [..] parse [..]
for all %start to %stop by %step %body for all %start to %stop by %step %body
@ -180,25 +180,25 @@ immediately:
parse [for all %start to %stop %body] as: for all %start to %stop via 1 %body parse [for all %start to %stop %body] as: for all %start to %stop via 1 %body
# For-each loop (lua's "ipairs()") # For-each loop (lua's "ipairs()")
immediately: immediately
compile [for %var in %iterable %body] to: compile [for %var in %iterable %body] to
# This uses Lua's approach of only allowing loop-scoped variables in a loop # This uses Lua's approach of only allowing loop-scoped variables in a loop
assume (%var.type is "Var") or barf "Loop expected variable, not: \(%var's source code)" assume (%var.type is "Var") or barf "Loop expected variable, not: \(%var's source code)"
%lua <- %lua <-
Lua ".." Lua ".."
for i,\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do for i,\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
\(%body as lua statements) \(%body as lua statements)
if %body has subtree % where: if %body has subtree % where
(%.type = "Action") and (%.type = "Action") and
((%'s stub) is "do next %") and ((%'s stub) is "do next %") and
%.value.3.value is %var.value %.value.3.value is %var.value
..: to %lua write (Lua "\n ::continue_\(%var as lua identifier)::;") ..: to %lua write (Lua "\n ::continue_\(%var as lua identifier)::;")
to %lua write "\nend --foreach-loop" to %lua write "\nend --foreach-loop"
if %body has subtree % where: if %body has subtree % where
(%.type = "Action") and (%.type = "Action") and
((%'s stub) is "stop %") and ((%'s stub) is "stop %") and
%.value.2.value is %var.value %.value.2.value is %var.value
..: ..
%lua <- %lua <-
Lua ".." Lua ".."
do -- scope for stopping for-loop do -- scope for stopping for-loop
@ -210,8 +210,8 @@ immediately:
parse [for all %iterable %body] as: for % in %iterable %body parse [for all %iterable %body] as: for % in %iterable %body
# Dict iteration (lua's "pairs()") # Dict iteration (lua's "pairs()")
immediately: immediately
compile [for %key = %value in %iterable %body] to: compile [for %key = %value in %iterable %body] to
# This uses Lua's approach of only allowing loop-scoped variables in a loop # This uses Lua's approach of only allowing loop-scoped variables in a loop
assume (%key.type is "Var") or barf "Loop expected variable, not: \(%key's source code)" assume (%key.type is "Var") or barf "Loop expected variable, not: \(%key's source code)"
assume (%value.type is "Var") or barf "Loop expected variable, not: \(%value's source code)" assume (%value.type is "Var") or barf "Loop expected variable, not: \(%value's source code)"
@ -219,13 +219,13 @@ immediately:
Lua ".." Lua ".."
for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(%iterable as lua expr)) do for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(%iterable as lua expr)) do
\(%body as lua statements) \(%body as lua statements)
if %body has subtree % where: if %body has subtree % where
(%.type = "Action") and (%.type = "Action") and
((%'s stub) is "do next %") and ((%'s stub) is "do next %") and
%.value.3.value is %key.value %.value.3.value is %key.value
..: to %lua write (Lua "\n ::continue_\(%key as lua identifier)::;") ..: to %lua write (Lua "\n ::continue_\(%key as lua identifier)::;")
if %body has subtree % where: if %body has subtree % where
(%.type = "Action") and (%.type = "Action") and
((%'s stub) is "do next %") and ((%'s stub) is "do next %") and
%.value.3.value is %value.value %.value.3.value is %value.value
@ -233,13 +233,13 @@ immediately:
to %lua write "\nend --foreach-loop" to %lua write "\nend --foreach-loop"
%stop_labels <- (Lua "") %stop_labels <- (Lua "")
if %body has subtree % where: if %body has subtree % where
(%.type = "Action") and (%.type = "Action") and
((%'s stub) is "stop %") and ((%'s stub) is "stop %") and
%.value.2.value is %key.value %.value.2.value is %key.value
..: to %stop_labels write "\n::stop_\(%key as lua identifier)::;" ..: to %stop_labels write "\n::stop_\(%key as lua identifier)::;"
if %body has subtree % where: if %body has subtree % where
(%.type = "Action") and (%.type = "Action") and
((%'s stub) is "stop %") and ((%'s stub) is "stop %") and
%.value.2.value is %value.value %.value.2.value is %value.value
@ -255,13 +255,13 @@ immediately:
return %lua return %lua
# Switch statement/multi-branch if # Switch statement/multi-branch if
immediately: immediately
compile [when %body] to: compile [when %body] to
%code <- (Lua "") %code <- (Lua "")
%fallthroughs <- [] %fallthroughs <- []
%is_first <- (yes) %is_first <- (yes)
%seen_else <- (no) %seen_else <- (no)
for %func_call in %body.value: for %func_call in %body.value
assume (%func_call.type is "Action") or barf ".." assume (%func_call.type is "Action") or barf ".."
Invalid format for 'when' statement. Only '*' blocks are allowed. Invalid format for 'when' statement. Only '*' blocks are allowed.
%tokens <- %func_call.value %tokens <- %func_call.value
@ -269,7 +269,7 @@ immediately:
%star: %tokens.1 %star: %tokens.1
%condition: %tokens.2 %condition: %tokens.2
%action: %tokens.3 %action: %tokens.3
..: ..
assume ((%star and (%star.type is "Word")) and (%star.value is "*")) or barf ".." assume ((%star and (%star.type is "Word")) and (%star.value is "*")) or barf ".."
Invalid format for 'when' statement. Lines must begin with '*' Invalid format for 'when' statement. Lines must begin with '*'
assume %condition or barf ".." assume %condition or barf ".."
@ -283,11 +283,11 @@ immediately:
to %code write "\nelse\n " to %code write "\nelse\n "
to %code write: %action as lua statements to %code write: %action as lua statements
%seen_else <- (yes) %seen_else <- (yes)
..else: ..else
assume (not %seen_else) or barf "'else' clause needs to be last in 'when' block" assume (not %seen_else) or barf "'else' clause needs to be last in 'when' block"
lua> "table.insert(\%fallthroughs, \(%condition as lua expr));" lua> "table.insert(\%fallthroughs, \(%condition as lua expr));"
to %code write "\("if" if %is_first else "\nelseif") " to %code write "\("if" if %is_first else "\nelseif") "
for %i=%condition in %fallthroughs: for %i=%condition in %fallthroughs
if (%i > 1): to %code write " or " if (%i > 1): to %code write " or "
to %code write %condition to %code write %condition
to %code write " then\n " to %code write " then\n "
@ -302,17 +302,17 @@ immediately:
return %code return %code
# Switch statement # Switch statement
immediately: immediately
compile [when %branch_value = ? %body, when %branch_value is ? %body] to: compile [when %branch_value = ? %body, when %branch_value is ? %body] to
%code <- (Lua "") %code <- (Lua "")
%fallthroughs <- [] %fallthroughs <- []
%is_first <- (yes) %is_first <- (yes)
%seen_else <- (no) %seen_else <- (no)
for %func_call in %body.value: for %func_call in %body.value
assume (%func_call.type is "Action") or barf ".." assume (%func_call.type is "Action") or barf ".."
Invalid format for 'when' statement. Only '*' blocks are allowed. Invalid format for 'when' statement. Only '*' blocks are allowed.
%tokens <- %func_call.value %tokens <- %func_call.value
with {%star:%tokens.1, %condition:%tokens.2, %action:%tokens.3}: with {%star:%tokens.1, %condition:%tokens.2, %action:%tokens.3}
assume ((%star and (%star.type is "Word")) and (%star.value is "*")) or barf ".." assume ((%star and (%star.type is "Word")) and (%star.value is "*")) or barf ".."
Invalid format for 'when' statement. Lines must begin with '*' Invalid format for 'when' statement. Lines must begin with '*'
assume %condition or barf ".." assume %condition or barf ".."
@ -325,7 +325,7 @@ immediately:
assume (not %is_first) or barf "'else' clause cannot be first in 'when % = ?' block" assume (not %is_first) or barf "'else' clause cannot be first in 'when % = ?' block"
to %code write "\nelse\n " to %code write "\nelse\n "
to %code write: %action as lua statements to %code write: %action as lua statements
..else: ..else
assume (not %seen_else) or barf "'else' clause needs to be last in 'when % = ?' block" assume (not %seen_else) or barf "'else' clause needs to be last in 'when % = ?' block"
to %code write "\("if" if %is_first else "\nelseif") " to %code write "\("if" if %is_first else "\nelseif") "
lua> "table.insert(\%fallthroughs, \(%condition as lua expr));" lua> "table.insert(\%fallthroughs, \(%condition as lua expr));"
@ -334,7 +334,7 @@ immediately:
to %code write " or " to %code write " or "
if: (%.type is "Text") or (%.type is "Number") if: (%.type is "Text") or (%.type is "Number")
to %code write "branch_value == \%" to %code write "branch_value == \%"
..else: ..else
to %code write "utils.equivalent(branch_value, \%)" to %code write "utils.equivalent(branch_value, \%)"
to %code write "then\n " to %code write "then\n "
to %code write (%action as lua statements) to %code write (%action as lua statements)
@ -354,11 +354,11 @@ immediately:
return %code return %code
# Try/except # Try/except
immediately: immediately
compile [..] compile [..]
try %action and if it succeeds %success or if it barfs %fallback try %action and if it succeeds %success or if it barfs %fallback
try %action and if it barfs %fallback or if it succeeds %success try %action and if it barfs %fallback or if it succeeds %success
..to: ..to
Lua ".." Lua ".."
do do
local fell_through = false; local fell_through = false;
@ -375,24 +375,24 @@ immediately:
return ret; return ret;
end end
end end
parse [try %action] as: parse [try %action] as
try %action and if it succeeds: do nothing try %action and if it succeeds: do nothing
..or if it barfs: do nothing ..or if it barfs: do nothing
parse [try %action and if it barfs %fallback] as: parse [try %action and if it barfs %fallback] as
try %action and if it succeeds: do nothing try %action and if it succeeds: do nothing
..or if it barfs %fallback ..or if it barfs %fallback
parse [try %action and if it succeeds %success] as: parse [try %action and if it succeeds %success] as
try %action and if it succeeds %success or if it barfs: do nothing try %action and if it succeeds %success or if it barfs: do nothing
# Do/finally: # Do/finally
immediately: immediately
compile [do %action] to: compile [do %action] to
Lua ".." Lua ".."
do do
\(%action as lua statements) \(%action as lua statements)
end --do end --do
compile [do %action then always %final_action] to: compile [do %action then always %final_action] to
Lua ".." Lua ".."
do do
local fell_through = false; local fell_through = false;

16
core/math.nom
View File

@ -34,37 +34,37 @@ compile [log % base %base, log_%base %, log base %base %] to: Lua value "math.lo
compile [floor %] to: Lua value "math.floor(\(% as lua expr))" compile [floor %] to: Lua value "math.floor(\(% as lua expr))"
compile [ceiling %, ceil %] to: Lua value "math.ceil(\(% as lua expr))" compile [ceiling %, ceil %] to: Lua value "math.ceil(\(% as lua expr))"
compile [round %, % rounded] to: Lua value "math.floor(\(% as lua expr) + .5)" compile [round %, % rounded] to: Lua value "math.floor(\(% as lua expr) + .5)"
action [%n to the nearest %rounder]: action [%n to the nearest %rounder]
=lua "(\%rounder)*math.floor((\%n / \%rounder) + .5)" =lua "(\%rounder)*math.floor((\%n / \%rounder) + .5)"
# Any/all/none # Any/all/none
compile [all of %items, all %items] to: compile [all of %items, all %items] to
unless: (%items' "type") is "List" unless: (%items' "type") is "List"
return: Lua value "utils.all(\(%items as lua expr))" return: Lua value "utils.all(\(%items as lua expr))"
%clauses <- [] %clauses <- []
for all (%items' "value"): lua> "table.insert(\%clauses, \(% as lua expr));" for all (%items' "value"): lua> "table.insert(\%clauses, \(% as lua expr));"
return: Lua value "(\(%clauses joined with " and "))" return: Lua value "(\(%clauses joined with " and "))"
parse [not all of %items, not all %items] as: not (all of %items) parse [not all of %items, not all %items] as: not (all of %items)
compile [any of %items, any %items] to: compile [any of %items, any %items] to
unless: (%items' "type") is "List" unless: (%items' "type") is "List"
return: Lua value "utils.any(\(%items as lua expr))" return: Lua value "utils.any(\(%items as lua expr))"
%clauses <- [] %clauses <- []
for all (%items' "value"): lua> "table.insert(\%clauses, \(% as lua expr));" for all (%items' "value"): lua> "table.insert(\%clauses, \(% as lua expr));"
return: Lua value "(\(%clauses joined with " or "))" return: Lua value "(\(%clauses joined with " or "))"
parse [none of %items, none %items] as: not (any of %items) parse [none of %items, none %items] as: not (any of %items)
compile [sum of %items, sum %items] to: compile [sum of %items, sum %items] to
unless: (%items' "type") is "List" unless: (%items' "type") is "List"
return: Lua value "utils.sum(\(%items as lua expr))" return: Lua value "utils.sum(\(%items as lua expr))"
%clauses <- [] %clauses <- []
for all (%items' "value"): lua> "table.insert(\%clauses, \(% as lua expr));" for all (%items' "value"): lua> "table.insert(\%clauses, \(% as lua expr));"
return: Lua value "(\(%clauses joined with " + "))" return: Lua value "(\(%clauses joined with " + "))"
compile [product of %items, product %items] to: compile [product of %items, product %items] to
unless: (%items' "type") is "List" unless: (%items' "type") is "List"
return: Lua value "utils.product(\(%items as lua expr))" return: Lua value "utils.product(\(%items as lua expr))"
%clauses <- [] %clauses <- []
for all (%items' "value"): lua> "table.insert(\%clauses, \(% as lua expr));" for all (%items' "value"): lua> "table.insert(\%clauses, \(% as lua expr));"
return: Lua value "(\(%clauses joined with " * "))" return: Lua value "(\(%clauses joined with " * "))"
action [avg of %items, average of %items]: action [avg of %items, average of %items]
=lua "(utils.sum(\%items)/#\%items)" =lua "(utils.sum(\%items)/#\%items)"
compile [min of %items, smallest of %items, lowest of %items] to compile [min of %items, smallest of %items, lowest of %items] to
Lua value "utils.min(\(%items as lua expr))" Lua value "utils.min(\(%items as lua expr))"
@ -82,7 +82,7 @@ compile [max of %items by %value_expr] to
end) end)
# Random functions # Random functions
action [seed random with %]: action [seed random with %]
lua> ".." lua> ".."
math.randomseed(\%); math.randomseed(\%);
for i=1,20 do math.random(); end for i=1,20 do math.random(); end
@ -91,5 +91,5 @@ compile [random number, random, rand] to: Lua value "math.random()"
compile [random int %n, random integer %n, randint %n] to: Lua value "math.random(\(%n as lua expr))" compile [random int %n, random integer %n, randint %n] to: Lua value "math.random(\(%n as lua expr))"
compile [random from %low to %high, random number from %low to %high, rand %low %high] to compile [random from %low to %high, random number from %low to %high, rand %low %high] to
"math.random(\(%low as lua expr), \(%high as lua expr))" "math.random(\(%low as lua expr), \(%high as lua expr))"
action [random choice from %elements, random choice %elements, random %elements]: action [random choice from %elements, random choice %elements, random %elements]
=lua "\%elements[math.random(#\%elements)]" =lua "\%elements[math.random(#\%elements)]"

72
core/metaprogramming.nom
View File

@ -3,7 +3,7 @@
functions to make that easier. functions to make that easier.
# Compile-time action to make compile-time actions: # Compile-time action to make compile-time actions:
immediately: immediately
lua> ".." lua> ".."
nomsu:define_compile_action("compile %actions to %lua", \(!! code location !!), function(tree, \%actions, \%lua) nomsu:define_compile_action("compile %actions to %lua", \(!! code location !!), function(tree, \%actions, \%lua)
local lua = Lua(tree.source, "nomsu:define_compile_action("); local lua = Lua(tree.source, "nomsu:define_compile_action(");
@ -31,15 +31,15 @@ immediately:
end end
local body_lua = \%lua:as_lua(nomsu); local body_lua = \%lua:as_lua(nomsu);
body_lua:convert_to_statements("return "); body_lua:convert_to_statements("return ");
body_lua:remove_free_vars(args); body_lua:remove_free_vars(unpack(args));
body_lua:declare_locals(); body_lua:declare_locals();
lua:append(")\\n ", body_lua, "\\nend);"); lua:append(")\\n ", body_lua, "\\nend);");
return lua; return lua;
end); end);
# Compile-time action to make actions # Compile-time action to make actions
immediately: immediately
compile [action %actions %body] to: compile [action %actions %body] to
lua> ".." lua> ".."
local lua = Lua(tree.source, "nomsu:define_action("); local lua = Lua(tree.source, "nomsu:define_action(");
local stubs = {}; local stubs = {};
@ -63,14 +63,14 @@ immediately:
end end
local body_lua = \%body:as_lua(nomsu); local body_lua = \%body:as_lua(nomsu);
body_lua:convert_to_statements("return "); body_lua:convert_to_statements("return ");
body_lua:remove_free_vars(args); body_lua:remove_free_vars(unpack(args));
body_lua:declare_locals(); body_lua:declare_locals();
lua:append(")\\n ", body_lua, "\\nend);") lua:append(")\\n ", body_lua, "\\nend);")
return lua; return lua;
# Macro to make nomsu macros: # Macro to make nomsu macros
immediately: immediately
compile [parse %shorthand as %longhand] to: compile [parse %shorthand as %longhand] to
lua> ".." lua> ".."
local lua = Lua(tree.source, "nomsu:define_compile_action("); local lua = Lua(tree.source, "nomsu:define_compile_action(");
local stubs = {}; local stubs = {};
@ -104,7 +104,7 @@ immediately:
]]); ]]);
return lua; return lua;
action [remove action %stub]: action [remove action %stub]
lua> ".." lua> ".."
local fn = ACTIONS[\%stub]; local fn = ACTIONS[\%stub];
local metadata = nomsu.action_metadata[fn]; local metadata = nomsu.action_metadata[fn];
@ -114,11 +114,11 @@ action [remove action %stub]:
end end
ACTIONS[\%stub] = nil; ACTIONS[\%stub] = nil;
immediately: immediately
action [%tree as lua]: action [%tree as lua]
=lua "\%tree:as_lua(nomsu)" =lua "\%tree:as_lua(nomsu)"
action [%tree as lua expr]: action [%tree as lua expr]
lua> ".." lua> ".."
local lua = \%tree:as_lua(nomsu); local lua = \%tree:as_lua(nomsu);
if not lua.is_value then if not lua.is_value then
@ -126,7 +126,7 @@ immediately:
end end
return lua; return lua;
action [%tree as lua statements]: action [%tree as lua statements]
lua> ".." lua> ".."
local lua = \%tree:as_lua(nomsu); local lua = \%tree:as_lua(nomsu);
lua:convert_to_statements(); lua:convert_to_statements();
@ -138,37 +138,37 @@ immediately:
compile [declare locals %locals in %tree] to compile [declare locals %locals in %tree] to
Lua "\(%tree as lua expr):declare_locals(\(%locals as lua expr));" Lua "\(%tree as lua expr):declare_locals(\(%locals as lua expr));"
compile [remove free vars %vars from %tree] to: compile [remove free vars %vars from %tree] to
Lua "\(%tree as lua expr):remove_free_vars(unpack(\(%vars as lua expr)));" Lua "\(%tree as lua expr):remove_free_vars(unpack(\(%vars as lua expr)));"
action [%tree as value]: action [%tree as value]
=lua "nomsu:tree_to_value(\%tree)" =lua "nomsu:tree_to_value(\%tree)"
action [%tree's stub]: action [%tree's stub]
=lua "nomsu:tree_to_stub(\%tree)" =lua "nomsu:tree_to_stub(\%tree)"
immediately: immediately
parse [%var <-write %code] as: lua> "\%var:append(\%code);" parse [%var <-write %code] as: lua> "\%var:append(\%code);"
parse [to %var write %code] as: lua> "\%var:append(\%code);" parse [to %var write %code] as: lua> "\%var:append(\%code);"
immediately: immediately
action [%tree's source code, %tree' source code]: action [%tree's source code, %tree' source code]
=lua "\%tree.source:get_text()" =lua "\%tree.source:get_text()"
compile [repr %obj] to: Lua value "repr(\(%obj as lua expr))" compile [repr %obj] to: Lua value "repr(\(%obj as lua expr))"
compile [%obj as text] to: Lua value "tostring(\(%obj as lua expr))" compile [%obj as text] to: Lua value "tostring(\(%obj as lua expr))"
compile [type of %obj] to: Lua value "type(\(%obj as lua expr))" compile [type of %obj] to: Lua value "type(\(%obj as lua expr))"
immediately: immediately
compile [nomsu] to: Lua value "nomsu" compile [nomsu] to: Lua value "nomsu"
compile [%var as lua identifier] to: Lua value "nomsu:var_to_lua_identifier(\(%var as lua expr))" compile [%var as lua identifier] to: Lua value "nomsu:var_to_lua_identifier(\(%var as lua expr))"
action [action %names metadata]: action [action %names metadata]
=lua "nomsu.action_metadata[ACTIONS[\%names]]" =lua "nomsu.action_metadata[ACTIONS[\%names]]"
# Get the source code for a function # Get the source code for a function
action [help %action]: action [help %action]
lua> ".." lua> ".."
local metadata = \(action %action metadata); local metadata = \(action %action metadata);
if not metadata then if not metadata then
@ -178,20 +178,20 @@ action [help %action]:
end end
# Compiler tools # Compiler tools
immediately: immediately
compile [run %code] to: compile [run %code] to
Lua value "nomsu:run(Nomsu(\(=lua "tostring(tree.source)"), \(%code as lua expr)))" Lua value "nomsu:run(Nomsu(\(=lua "tostring(tree.source)"), \(%code as lua expr)))"
parse [enable debugging] as: lua> "nomsu.debug = true;" parse [enable debugging] as: lua> "nomsu.debug = true;"
parse [disable debugging] as: lua> "nomsu.debug = false;" parse [disable debugging] as: lua> "nomsu.debug = false;"
immediately: immediately
compile [show lua %block] to: compile [show lua %block] to
lua> ".." lua> ".."
local \%lua = \%block:as_lua(nomsu); local \%lua = \%block:as_lua(nomsu);
return Lua(\%block.source, "print(", repr(tostring(\%lua)), ");"); return Lua(\%block.source, "print(", repr(tostring(\%lua)), ");");
immediately: immediately
compile [say %message] to: compile [say %message] to
lua> ".." lua> ".."
if \%message.type == "Text" then if \%message.type == "Text" then
return Lua(tree.source, "print(", \(%message as lua expr), ");"); return Lua(tree.source, "print(", \(%message as lua expr), ");");
@ -199,42 +199,42 @@ immediately:
return Lua(tree.source, "print(stringify(", \(%message as lua expr), "));"); return Lua(tree.source, "print(stringify(", \(%message as lua expr), "));");
end end
immediately: immediately
compile [source] to: Lua value (=lua "tree.source") "tree.source" compile [source] to: Lua value (=lua "tree.source") "tree.source"
#.. #..
immediately: immediately
action [Lua %]: Lua (=lua "tree.source") % action [Lua %]: Lua (=lua "tree.source") %
action [Lua value %]: Lua value (=lua "tree.source") % action [Lua value %]: Lua value (=lua "tree.source") %
# Return # Return
immediately: immediately
#.. Return statement is wrapped in a do..end block because Lua is unhappy if you #.. Return statement is wrapped in a do..end block because Lua is unhappy if you
put code after a return statement, unless you wrap it in a block. put code after a return statement, unless you wrap it in a block.
compile [return] to: Lua "do return; end" compile [return] to: Lua "do return; end"
compile [return %return_value] to: Lua "do return \(%return_value as lua expr); end" compile [return %return_value] to: Lua "do return \(%return_value as lua expr); end"
# Error functions # Error functions
immediately: immediately
compile [barf] to: Lua "error(nil, 0);" compile [barf] to: Lua "error(nil, 0);"
compile [barf %msg] to: Lua "error(\(%msg as lua expr), 0);" compile [barf %msg] to: Lua "error(\(%msg as lua expr), 0);"
compile [assume %condition] to: compile [assume %condition] to
lua> "local \%assumption = 'Assumption failed: '..tostring(\%condition.source:get_text());" lua> "local \%assumption = 'Assumption failed: '..tostring(\%condition.source:get_text());"
return: return
Lua ".." Lua ".."
if not \(%condition as lua expr) then if not \(%condition as lua expr) then
error(\(repr %assumption), 0); error(\(repr %assumption), 0);
end end
# TODO: factor this out and replace with "unless %condition: barf %message" # TODO: factor this out and replace with "unless %condition: barf %message"
compile [assume %condition or barf %message] to: compile [assume %condition or barf %message] to
Lua ".." Lua ".."
if not \(%condition as lua expr) then if not \(%condition as lua expr) then
error(\(%message as lua expr), 0); error(\(%message as lua expr), 0);
end end
# Literals # Literals
immediately: immediately
compile [yes] to: Lua value "true" compile [yes] to: Lua value "true"
compile [no] to: Lua value "false" compile [no] to: Lua value "false"
compile [nothing, nil, null] to: Lua value "nil" compile [nothing, nil, null] to: Lua value "nil"

30
core/operators.nom
View File

@ -3,8 +3,8 @@
use "core/metaprogramming.nom" use "core/metaprogramming.nom"
# Indexing: # Indexing
immediately: immediately
#.. NOTE!!! It's critical that there are spaces around %key if it's a string, #.. NOTE!!! It's critical that there are spaces around %key if it's a string,
otherwise, Lua will get confused and interpret %obj[[[foo]]] as %obj("[foo]") otherwise, Lua will get confused and interpret %obj[[[foo]]] as %obj("[foo]")
instead of %obj[ "foo" ]. instead of %obj[ "foo" ].
@ -17,13 +17,13 @@ immediately:
..as: %obj.%key ..as: %obj.%key
# Comparison Operators # Comparison Operators
immediately: immediately
compile [%x < %y] to: Lua value "(\(%x as lua expr) < \(%y as lua expr))" compile [%x < %y] to: Lua value "(\(%x as lua expr) < \(%y as lua expr))"
compile [%x > %y] to: Lua value "(\(%x as lua expr) > \(%y as lua expr))" compile [%x > %y] to: Lua value "(\(%x as lua expr) > \(%y as lua expr))"
compile [%x <= %y] to: Lua value "(\(%x as lua expr) <= \(%y as lua expr))" compile [%x <= %y] to: Lua value "(\(%x as lua expr) <= \(%y as lua expr))"
compile [%x >= %y] to: Lua value "(\(%x as lua expr) >= \(%y as lua expr))" compile [%x >= %y] to: Lua value "(\(%x as lua expr) >= \(%y as lua expr))"
# TODO: optimize case of [%x,%y] = [1,2] # TODO: optimize case of [%x,%y] = [1,2]
compile [%a is %b, %a = %b, %a == %b] to: compile [%a is %b, %a = %b, %a == %b] to
lua> ".." lua> ".."
local safe = {Text=true, Number=true}; local safe = {Text=true, Number=true};
local a_lua, b_lua = \%a:as_lua(nomsu), \%b:as_lua(nomsu); local a_lua, b_lua = \%a:as_lua(nomsu), \%b:as_lua(nomsu);
@ -32,7 +32,7 @@ immediately:
else else
return Lua.Value(tree.source, "utils.equivalent(", a_lua, ", ", b_lua, ")"); return Lua.Value(tree.source, "utils.equivalent(", a_lua, ", ", b_lua, ")");
end end
compile [%a isn't %b, %a is not %b, %a not= %b, %a != %b] to: compile [%a isn't %b, %a is not %b, %a not= %b, %a != %b] to
lua> ".." lua> ".."
local safe = {Text=true, Number=true}; local safe = {Text=true, Number=true};
local a_lua, b_lua = \%a:as_lua(nomsu), \%b:as_lua(nomsu); local a_lua, b_lua = \%a:as_lua(nomsu), \%b:as_lua(nomsu);
@ -45,8 +45,8 @@ immediately:
compile [%'s id, id of %] to: Lua value "nomsu.ids[\(% as lua expr)]" compile [%'s id, id of %] to: Lua value "nomsu.ids[\(% as lua expr)]"
# Variable assignment operator # Variable assignment operator
immediately: immediately
compile [%var <- %value] to: compile [%var <- %value] to
lua> "local \%var_lua = \%var:as_lua(nomsu);" lua> "local \%var_lua = \%var:as_lua(nomsu);"
assume %var_lua.is_value or barf "Invalid target for assignment: \(%var's source code)" assume %var_lua.is_value or barf "Invalid target for assignment: \(%var's source code)"
lua> "local \%value_lua = \%value:as_lua(nomsu);" lua> "local \%value_lua = \%value:as_lua(nomsu);"
@ -58,9 +58,9 @@ immediately:
end end
return lua; return lua;
immediately: immediately
# Simultaneous mutli-assignments like: x,y,z = 1,x,3; # Simultaneous mutli-assignments like: x,y,z = 1,x,3;
compile [<- %assignments] to: compile [<- %assignments] to
assume ((%assignments' "type") is "Dict") or barf ".." assume ((%assignments' "type") is "Dict") or barf ".."
Expected a Dict for the assignments part of '<- %' statement, not \(%assignments' source code) Expected a Dict for the assignments part of '<- %' statement, not \(%assignments' source code)
lua> ".." lua> ".."
@ -83,20 +83,20 @@ immediately:
end end
return Lua(tree.source, lhs, " = ", rhs, ";"); return Lua(tree.source, lhs, " = ", rhs, ";");
immediately: immediately
compile [export %var <- %value] to: compile [export %var <- %value] to
%var_lua <- (%var as lua) %var_lua <- (%var as lua)
assume %var_lua.is_value or barf "Invalid target for assignment: \(%var's source code)" assume %var_lua.is_value or barf "Invalid target for assignment: \(%var's source code)"
%value_lua <- (%value as lua) %value_lua <- (%value as lua)
assume %value_lua.is_value or barf "Invalid value for assignment: \(%value's source code)" assume %value_lua.is_value or barf "Invalid value for assignment: \(%value's source code)"
return: Lua "\(%var_lua) = \(%value_lua);" return: Lua "\(%var_lua) = \(%value_lua);"
compile [exporting %exported %body] to: compile [exporting %exported %body] to
%body_lua <- (%body as lua statements) %body_lua <- (%body as lua statements)
lua> "\%body_lua:remove_free_vars(unpack(\(%exported.value)));" lua> "\%body_lua:remove_free_vars(unpack(\(%exported.value)));"
return %body_lua return %body_lua
compile [with %assignments %body] to: compile [with %assignments %body] to
%lua <- (%body as lua statements) %lua <- (%body as lua statements)
lua> ".." lua> ".."
local lhs, rhs = Lua(tree.source), Lua(\%assignments.source); local lhs, rhs = Lua(tree.source), Lua(\%assignments.source);
@ -130,7 +130,7 @@ immediately:
\%lua \%lua
end -- 'with' block end -- 'with' block
immediately: immediately
# Math Operators # Math Operators
compile [%x + %y] to: Lua value "(\(%x as lua expr) + \(%y as lua expr))" compile [%x + %y] to: Lua value "(\(%x as lua expr) + \(%y as lua expr))"
compile [%x - %y] to: Lua value "(\(%x as lua expr) - \(%y as lua expr))" compile [%x - %y] to: Lua value "(\(%x as lua expr) - \(%y as lua expr))"
@ -171,7 +171,7 @@ immediately:
compile [length of %list] to: Lua value "(#\(%list as lua expr))" compile [length of %list] to: Lua value "(#\(%list as lua expr))"
# Update operators # Update operators
immediately: immediately
parse [%var + <- %, %var +<- %] as: %var <- (%var + %) parse [%var + <- %, %var +<- %] as: %var <- (%var + %)
parse [%var - <- %, %var -<- %] as: %var <- (%var - %) parse [%var - <- %, %var -<- %] as: %var <- (%var - %)
parse [%var * <- %, %var *<- %] as: %var <- (%var * %) parse [%var * <- %, %var *<- %] as: %var <- (%var * %)

2
core/text.nom
View File

@ -5,7 +5,7 @@
use "core/metaprogramming.nom" use "core/metaprogramming.nom"
# Text functions # Text functions
action [%texts joined with %glue]: action [%texts joined with %glue]
lua> ".." lua> ".."
local text_bits = {} local text_bits = {}
for i,bit in ipairs(\%texts) do text_bits[i] = stringify(bit) end for i,bit in ipairs(\%texts) do text_bits[i] = stringify(bit) end

6
lib/file_hash.nom
View File

@ -28,15 +28,15 @@ lua> ".."
end end
attrdir("."); attrdir(".");
action [sha1 %]: action [sha1 %]
lua> "return sha1(\%);" lua> "return sha1(\%);"
action [file with hash %hash]: action [file with hash %hash]
%file <- (%hash in %hash_to_filename) %file <- (%hash in %hash_to_filename)
assume %file or barf "File with SHA1 hash \%hash not found!" assume %file or barf "File with SHA1 hash \%hash not found!"
return %file return %file
action [hash of file %filename]: action [hash of file %filename]
lua> ".." lua> ".."
local f = io.open(\%filename); local f = io.open(\%filename);
local hash = sha1(f:read("*a")); local hash = sha1(f:read("*a"));

14
lib/object.nom
View File

@ -1,6 +1,6 @@
use "core" use "core"
compile [@%var] to: compile [@%var] to
lua> ".." lua> ".."
local key_lua = repr(\%var.value); local key_lua = repr(\%var.value);
local key_attr = (key_lua:match("'([a-zA-Z][a-zA-Z0-9]*)'") local key_attr = (key_lua:match("'([a-zA-Z][a-zA-Z0-9]*)'")
@ -12,7 +12,7 @@ compile [@%var] to:
end end
return {expr="_me["..key_lua.."]"}; return {expr="_me["..key_lua.."]"};
compile [@%var <- %val] to: compile [@%var <- %val] to
lua> ".." lua> ".."
local val_lua = \(%val as lua expr); local val_lua = \(%val as lua expr);
local key_lua = repr(\%var.value); local key_lua = repr(\%var.value);
@ -25,12 +25,12 @@ compile [@%var <- %val] to:
end end
return {statements="_me["..key_lua.."] = "..val_lua..";"}; return {statements="_me["..key_lua.."] = "..val_lua..";"};
compile [define object %classname %class_body] to: compile [define object %classname %class_body] to
%class_identifier <- (=lua "nomsu:var_to_lua_identifier(\(%classname as value)):sub(2,-1)") %class_identifier <- (=lua "nomsu:var_to_lua_identifier(\(%classname as value)):sub(2,-1)")
if: %class_identifier is "" if: %class_identifier is ""
%class_identifier <- "class" %class_identifier <- "class"
%methods <- [] %methods <- []
for %line in (%class_body's "value"): for %line in (%class_body's "value")
if: (%line's "type") is "Comment" if: (%line's "type") is "Comment"
do next %line do next %line
assume (((%line's "type") == "FunctionCall") and ((%line's stub) == "action % %")) assume (((%line's "type") == "FunctionCall") and ((%line's stub) == "action % %"))
@ -86,7 +86,7 @@ compile [define object %classname %class_body] to:
return {..} return {..}
statements:".." statements:".."
do -- \%class_identifier do -- \%class_identifier
-- Create the class object: -- Create the class object
local \%class_identifier = setmetatable({ local \%class_identifier = setmetatable({
name=\(%classname as lua expr), instances=setmetatable({}, {__mode="k"}), name=\(%classname as lua expr), instances=setmetatable({}, {__mode="k"}),
}, { }, {
@ -104,10 +104,10 @@ compile [define object %classname %class_body] to:
}); });
\%class_identifier.class = \%class_identifier; \%class_identifier.class = \%class_identifier;
-- Define the methods: -- Define the methods
\(%methods joined with "\n") \(%methods joined with "\n")
-- Define class methods for instantiating and accessing instances: -- Define class methods for instantiating and accessing instances
\%class_identifier.instance_metatable = { \%class_identifier.instance_metatable = {
__index=\%class_identifier, __index=\%class_identifier,
__tostring=\%class_identifier['% as text'] or function(inst) __tostring=\%class_identifier['% as text'] or function(inst)

18
lib/object2.nom
View File

@ -2,7 +2,7 @@ use "core"
compile [@] to: Lua value "self" compile [@] to: Lua value "self"
compile [@%var] to: compile [@%var] to
lua> ".." lua> ".."
local key_lua = repr(\%var.value); local key_lua = repr(\%var.value);
local key_attr = (key_lua:match("'([a-zA-Z][a-zA-Z0-9]*)'") local key_attr = (key_lua:match("'([a-zA-Z][a-zA-Z0-9]*)'")
@ -14,7 +14,7 @@ compile [@%var] to:
end end
return Lua.Value(tree.source, "self["..key_lua.."]"); return Lua.Value(tree.source, "self["..key_lua.."]");
compile [@%var <- %val] to: compile [@%var <- %val] to
lua> ".." lua> ".."
local val_lua = \(%val as lua expr); local val_lua = \(%val as lua expr);
local key_lua = repr(\%var.value); local key_lua = repr(\%var.value);
@ -27,7 +27,7 @@ compile [@%var <- %val] to:
end end
return Lua(tree.source, "self[", key_lua, "] = ", val_lua, ";"); return Lua(tree.source, "self[", key_lua, "] = ", val_lua, ";");
compile [as %instance %body] to: compile [as %instance %body] to
%body_lua <- (%body as lua) %body_lua <- (%body as lua)
lua> "\%body_lua:convert_to_statements();" lua> "\%body_lua:convert_to_statements();"
return return
@ -43,21 +43,21 @@ compile [as %instance %body] to:
\%body_lua \%body_lua
end end
compile [define object %classname %class_body] to: compile [define object %classname %class_body] to
%class_identifier <- (=lua "nomsu:var_to_lua_identifier(\(%classname as value)):sub(2,-1)") %class_identifier <- (=lua "nomsu:var_to_lua_identifier(\(%classname as value)):sub(2,-1)")
if: %class_identifier is "" if: %class_identifier is ""
%class_identifier <- "class" %class_identifier <- "class"
%methods <- [] %methods <- []
%__index <- %class_identifier %__index <- %class_identifier
%__newindex <- "nil" %__newindex <- "nil"
for %line in (%class_body's "value"): for %line in (%class_body's "value")
if: (%line's "type") is "Comment" if: (%line's "type") is "Comment"
do next %line do next %line
if: ((%line's "type") is "FunctionCall") and ((%line's stub) is "slots %") if: ((%line's "type") is "FunctionCall") and ((%line's stub) is "slots %")
%slot_index_clauses <- [] %slot_index_clauses <- []
%slot_newindex_clauses <- [] %slot_newindex_clauses <- []
%slots <- %line.value.2.value %slots <- %line.value.2.value
for %slot_index = %slot_var in %slots: for %slot_index = %slot_var in %slots
to %slot_index_clauses add ".." to %slot_index_clauses add ".."
if key == \(repr (%slot_var's "value")) or key == \(repr (%slot_var as lua expr)) then if key == \(repr (%slot_var's "value")) or key == \(repr (%slot_var as lua expr)) then
return rawget(self, \%slot_index); return rawget(self, \%slot_index);
@ -115,7 +115,7 @@ compile [define object %classname %class_body] to:
return return
Lua ".." Lua ".."
do -- \%class_identifier do -- \%class_identifier
-- Create the class object: -- Create the class object
local \%class_identifier = setmetatable({ local \%class_identifier = setmetatable({
name=\(%classname as lua expr), instances=setmetatable({}, {__mode="k"}), name=\(%classname as lua expr), instances=setmetatable({}, {__mode="k"}),
}, { }, {
@ -132,10 +132,10 @@ compile [define object %classname %class_body] to:
}); });
\%class_identifier.class = \%class_identifier; \%class_identifier.class = \%class_identifier;
-- Define the methods: -- Define the methods
\(%methods joined with "\n") \(%methods joined with "\n")
-- Define class methods for instantiating and accessing instances: -- Define class methods for instantiating and accessing instances
\%class_identifier.instance_metatable = { \%class_identifier.instance_metatable = {
__index=\%__index, __index=\%__index,
__newindex=\%__newindex, __newindex=\%__newindex,

30
lib/training_wheels.nom
View File

@ -26,19 +26,19 @@ parse [error!, panic!, fail!, abort!] as: barf!
parse [error %, panic %, fail %, abort %] as: barf % parse [error %, panic %, fail %, abort %] as: barf %
parse [assert %condition %message] as: assume %condition or barf %message parse [assert %condition %message] as: assume %condition or barf %message
parse [%cond ? %if_true %if_false] as: %if_true if %cond else %if_false parse [%cond ? %if_true %if_false] as: %if_true if %cond else %if_false
compile [function %args %body, lambda %args %body] to: compile [function %args %body, lambda %args %body] to
%body_lua <- (%body as lua) %lua <-: Lua value "(function("
%statements <- ((%body_lua's "statements") or "return \(%body_lua's "expr");") for %i = %arg in %args.value
%locals <- (% for all ((%body_lua's "locals") or [])) if: %i > 1
for all (%args's "value"): to %lua write ", "
lua> "utils.remove_from_list(\%locals, \(% as lua expr));" to %lua write: %arg as lua expr
if: (size of %locals) > 0 to %lua write ")\n "
%statements <- "local \(%locals joined with ", ");\n\%statements" %body <-: %body as lua
lua> "\%body:convert_to_statements('return ');"
return {..} for all %args.value: lua> "\%body:remove_free_vars(\%);"
expr: ".." to %lua write %body
(function(\(((% as lua expr) for all (%args's "value")) joined with ", ")) to %lua write "\nend)"
\%statements return %lua
end)
parse [function %name %args %body] as: %name <- (function %args %body) parse [function %name %args %body] as: %name <- (function %args %body)
compile [call %fn %args] to {expr:"\(%fn as lua expr)(unpack(\(%args as lua expr)))"} compile [call %fn %args] to
Lua value "\(%fn as lua expr)(unpack(\(%args as lua expr)))"

2
nomsu.peg
View File

@ -10,7 +10,7 @@ shebang: "#!" [^%nl]* (!. / %nl)
statement: action / expression statement: action / expression
indented_block (Block): indented_block (Block):
{| (":" / "(..)")? indent {| indent
statement (nodent statement)* statement (nodent statement)*
(dedent / (("" -> "Error while parsing block") => error)) (dedent / (("" -> "Error while parsing block") => error))
|} -> Tuple |} -> Tuple

30
nomsu_tree.lua
View File

@ -14,6 +14,7 @@ do
local _obj_0 = require("lua_obj") local _obj_0 = require("lua_obj")
Lua, Nomsu, Location = _obj_0.Lua, _obj_0.Nomsu, _obj_0.Location Lua, Nomsu, Location = _obj_0.Lua, _obj_0.Nomsu, _obj_0.Location
end end
local MAX_LINE = 80
local Types = { } local Types = { }
Types.DictEntry = immutable({ Types.DictEntry = immutable({
"key", "key",
@ -307,21 +308,24 @@ Tree("Action", {
return nomsu return nomsu
else else
local inline_version = self:as_nomsu(true) local inline_version = self:as_nomsu(true)
if inline_version and #inline_version <= 80 then if inline_version and #inline_version <= MAX_LINE then
return inline_version return inline_version
end end
local nomsu = Nomsu(self.source) local nomsu = Nomsu(self.source)
local spacer = nil local spacer = nil
for i, bit in ipairs(self.value) do for i, bit in ipairs(self.value) do
if spacer then
nomsu:append(spacer)
end
if bit.type == "Word" then if bit.type == "Word" then
if spacer then
nomsu:append(spacer)
end
nomsu:append(bit.value) nomsu:append(bit.value)
spacer = " " spacer = " "
else else
local arg_nomsu = bit:as_nomsu(true) local arg_nomsu = bit:as_nomsu(true)
if arg_nomsu and #arg_nomsu < 80 then if arg_nomsu and #arg_nomsu < MAX_LINE then
if spacer then
nomsu:append(spacer)
end
if bit.type == "Action" or bit.type == "Block" then if bit.type == "Action" or bit.type == "Block" then
arg_nomsu:parenthesize() arg_nomsu:parenthesize()
end end
@ -333,6 +337,10 @@ Tree("Action", {
end end
if bit.type == "Action" or bit.type == "Block" then if bit.type == "Action" or bit.type == "Block" then
nomsu:append("\n ") nomsu:append("\n ")
else
if spacer then
nomsu:append(spacer)
end
end end
spacer = "\n.." spacer = "\n.."
end end
@ -423,7 +431,7 @@ Tree("Text", {
return nomsu return nomsu
else else
local inline_version = self:as_nomsu(true) local inline_version = self:as_nomsu(true)
if inline_version and #inline_version <= 80 then if inline_version and #inline_version <= MAX_LINE then
return inline_version return inline_version
end end
local nomsu = Nomsu(self.source, '".."\n ') local nomsu = Nomsu(self.source, '".."\n ')
@ -472,7 +480,7 @@ Tree("List", {
line_length = line_length + #last_line line_length = line_length + #last_line
end end
if i < #self.value then if i < #self.value then
if line_length >= 80 then if line_length >= MAX_LINE then
lua:append(",\n") lua:append(",\n")
line_length = 0 line_length = 0
else else
@ -504,7 +512,7 @@ Tree("List", {
return nomsu return nomsu
else else
local inline_version = self:as_nomsu(true) local inline_version = self:as_nomsu(true)
if inline_version and #inline_version <= 80 then if inline_version and #inline_version <= MAX_LINE then
return inline_version return inline_version
end end
local nomsu = Nomsu(self.source, "[..]") local nomsu = Nomsu(self.source, "[..]")
@ -513,7 +521,7 @@ Tree("List", {
for _index_0 = 1, #_list_0 do for _index_0 = 1, #_list_0 do
local item = _list_0[_index_0] local item = _list_0[_index_0]
local item_nomsu = item:as_nomsu(true) local item_nomsu = item:as_nomsu(true)
if item_nomsu and #line + #", " + #item_nomsu <= 80 then if item_nomsu and #line + #", " + #item_nomsu <= MAX_LINE then
if #line.bits > 1 then if #line.bits > 1 then
line:append(", ") line:append(", ")
end end
@ -569,7 +577,7 @@ Tree("Dict", {
line_length = line_length + #last_line line_length = line_length + #last_line
end end
if i < #self.value then if i < #self.value then
if line_length >= 80 then if line_length >= MAX_LINE then
lua:append(",\n") lua:append(",\n")
line_length = 0 line_length = 0
else else
@ -624,7 +632,7 @@ Tree("Dict", {
key_nomsu:parenthesize() key_nomsu:parenthesize()
end end
local value_nomsu = entry.value:as_nomsu(true) local value_nomsu = entry.value:as_nomsu(true)
if value_nomsu and #line + #", " + #key_nomsu + #":" + #value_nomsu <= 80 then if value_nomsu and #line + #", " + #key_nomsu + #":" + #value_nomsu <= MAX_LINE then
if #line.bits > 1 then if #line.bits > 1 then
line:append(", ") line:append(", ")
end end

24
nomsu_tree.moon
View File

@ -8,6 +8,7 @@ immutable = require 'immutable'
{:insert, :remove, :concat} = table {:insert, :remove, :concat} = table
{:Lua, :Nomsu, :Location} = require "lua_obj" {:Lua, :Nomsu, :Location} = require "lua_obj"
MAX_LINE = 80 -- For beautification purposes, try not to make lines much longer than this value
Types = {} Types = {}
Types.DictEntry = immutable({"key","value"}, {name:"DictEntry"}) Types.DictEntry = immutable({"key","value"}, {name:"DictEntry"})
@ -177,20 +178,19 @@ Tree "Action",
return nomsu return nomsu
else else
inline_version = @as_nomsu(true) inline_version = @as_nomsu(true)
if inline_version and #inline_version <= 80 if inline_version and #inline_version <= MAX_LINE
return inline_version return inline_version
nomsu = Nomsu(@source) nomsu = Nomsu(@source)
spacer = nil spacer = nil
for i,bit in ipairs @value for i,bit in ipairs @value
if spacer
nomsu\append spacer
if bit.type == "Word" if bit.type == "Word"
if spacer then nomsu\append spacer
nomsu\append bit.value nomsu\append bit.value
spacer = " " spacer = " "
else else
arg_nomsu = bit\as_nomsu(true) arg_nomsu = bit\as_nomsu(true)
if arg_nomsu and #arg_nomsu < 80 if arg_nomsu and #arg_nomsu < MAX_LINE
if spacer then nomsu\append spacer
if bit.type == "Action" or bit.type == "Block" if bit.type == "Action" or bit.type == "Block"
arg_nomsu\parenthesize! arg_nomsu\parenthesize!
spacer = " " spacer = " "
@ -199,6 +199,8 @@ Tree "Action",
return nil unless nomsu return nil unless nomsu
if bit.type == "Action" or bit.type == "Block" if bit.type == "Action" or bit.type == "Block"
nomsu\append "\n " nomsu\append "\n "
else
if spacer then nomsu\append spacer
spacer = "\n.." spacer = "\n.."
nomsu\append arg_nomsu nomsu\append arg_nomsu
return nomsu return nomsu
@ -253,7 +255,7 @@ Tree "Text",
return nomsu return nomsu
else else
inline_version = @as_nomsu(true) inline_version = @as_nomsu(true)
if inline_version and #inline_version <= 80 if inline_version and #inline_version <= MAX_LINE
return inline_version return inline_version
nomsu = Nomsu(@source, '".."\n ') nomsu = Nomsu(@source, '".."\n ')
for i, bit in ipairs @value for i, bit in ipairs @value
@ -290,7 +292,7 @@ Tree "List",
else else
line_length += #last_line line_length += #last_line
if i < #@value if i < #@value
if line_length >= 80 if line_length >= MAX_LINE
lua\append ",\n" lua\append ",\n"
line_length = 0 line_length = 0
else else
@ -312,13 +314,13 @@ Tree "List",
return nomsu return nomsu
else else
inline_version = @as_nomsu(true) inline_version = @as_nomsu(true)
if inline_version and #inline_version <= 80 if inline_version and #inline_version <= MAX_LINE
return inline_version return inline_version
nomsu = Nomsu(@source, "[..]") nomsu = Nomsu(@source, "[..]")
line = Nomsu(@source, "\n ") line = Nomsu(@source, "\n ")
for item in *@value for item in *@value
item_nomsu = item\as_nomsu(true) item_nomsu = item\as_nomsu(true)
if item_nomsu and #line + #", " + #item_nomsu <= 80 if item_nomsu and #line + #", " + #item_nomsu <= MAX_LINE
if #line.bits > 1 if #line.bits > 1
line\append ", " line\append ", "
line\append item_nomsu line\append item_nomsu
@ -365,7 +367,7 @@ Tree "Dict",
else else
line_length += #last_line line_length += #last_line
if i < #@value if i < #@value
if line_length >= 80 if line_length >= MAX_LINE
lua\append ",\n" lua\append ",\n"
line_length = 0 line_length = 0
else else
@ -400,7 +402,7 @@ Tree "Dict",
if entry.key.type == "Action" or entry.key.type == "Block" if entry.key.type == "Action" or entry.key.type == "Block"
key_nomsu\parenthesize! key_nomsu\parenthesize!
value_nomsu = entry.value\as_nomsu(true) value_nomsu = entry.value\as_nomsu(true)
if value_nomsu and #line + #", " + #key_nomsu + #":" + #value_nomsu <= 80 if value_nomsu and #line + #", " + #key_nomsu + #":" + #value_nomsu <= MAX_LINE
if #line.bits > 1 if #line.bits > 1
line\append ", " line\append ", "
line\append key_nomsu,":",value_nomsu line\append key_nomsu,":",value_nomsu

10
tests/object.nom
View File

@ -2,16 +2,16 @@ use "core"
use "lib/object2.nom" use "lib/object2.nom"
#.. #..
immediately: immediately
define object "Dog": define object "Dog"
action [bark]: action [bark]
%barks <- ("Bark!" for all 1 to (@%barks)) %barks <- ("Bark!" for all 1 to (@%barks))
return (%barks joined with " ") return (%barks joined with " ")
action [get pissed off]: action [get pissed off]
(@%barks) +<- 1 (@%barks) +<- 1
%d <- (new Dog {barks:2}) %d <- (new Dog {barks:2})
as %d: as %d
assume ((@) = %d) assume ((@) = %d)
assume ((@%barks) = 2) assume ((@%barks) = 2)
assume ((bark) = "Bark! Bark!") assume ((bark) = "Bark! Bark!")

4
tests/text.nom
View File

@ -14,11 +14,11 @@ assume (("x" + "y") = "xy")
say "Text test passed." say "Text test passed."
immediately: immediately
parse [アクション %spec %body] as: action %spec %body parse [アクション %spec %body] as: action %spec %body
%こんにちは <- "こんにちは" %こんにちは <- "こんにちは"
アクション [% と言う]: アクション [% と言う]
"\(%)世界" "\(%)世界"
assume ((%こんにちは と言う) = "こんにちは世界") or barf "Unicode doesn't work" assume ((%こんにちは と言う) = "こんにちは世界") or barf "Unicode doesn't work"