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

Upgraded core code to latest Nomsu verison.

Browse Source
This commit is contained in:
Bruce Hill 2018-07-17 23:08:13 -07:00
parent 854b2a652f
commit ba639f2bd0
16 changed files with 779 additions and 699 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
compatibility/2.nom Normal file
View File

@ -0,0 +1,30 @@
#!/usr/bin/env nomsu -V2
use "core"
use "compatibility/compatibility.nom"
upgrade %tree to "2" as:
unless (%tree is "Action" syntax tree): return
if (all[%tree.stub is "if % % else %", not (%tree.3 is "Var" syntax tree), not (%tree.5 is "Var" syntax tree)]):
%true_body <- (%tree.3 upgraded from "1.2")
unless (%true_body is "Block" syntax tree):
%true_body <- (=lua "Block(\%true_body.source, \%true_body)")
%false_body <- (%tree.5 upgraded from "1.2")
unless (%false_body is "Block" syntax tree):
%false_body <- (=lua "Block(\%false_body.source, \%false_body)")
return (..)
\(if %cond %true_body else %false_body)
..with vars {..}
cond:%tree.2 upgraded from "1.2", true_body:%true_body, false_body:%false_body
%need_blocks <- [..]
"if % %", "unless % %", "for % in % %", "for % = % in % %", "repeat while % %"
"repeat % times %", "repeat %", "repeat until % %", "for % in % to % by % %",
"for % in % to % via % %", "for % in % to % %", "for % % in % %", "do %"
"for % in recursive % %", "test %", "with % %", "result of %"
for %n in %need_blocks:
if ((%tree.stub is %n) and (not ((last in %tree) is "Var" syntax tree))):
%bits <- (((% upgraded from "1.2") if (% is syntax tree) else %) for % in %tree)
unless ((last in %bits) is "Block" syntax tree):
%body <- (last in %bits)
%bits.(length of %bits) <- (=lua "Block(\%body.source, \%body)")
return (=lua "Action(\%tree.source, unpack(\%bits))")

234
core/collections.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V1 #!/usr/bin/env nomsu -V2.2.4.3
# #
This file contains code that supports manipulating and using collections like lists This file contains code that supports manipulating and using collections like lists
and dictionaries. and dictionaries.
@ -8,173 +8,165 @@ use "core/control_flow.nom"
use "core/operators.nom" use "core/operators.nom"
# List/dict functions: # List/dict functions:
# Indexing # Indexing
test: assume: (2nd to last in [1,2,3,4,5]) is 4 test: assume ((2 nd to last in [1, 2, 3, 4, 5]) is 4)
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))")
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
parse [last in %list] as: 1st to last in %list parse [last in %list] as (1 st to last in %list)
parse [first in %list] as: %list.1 parse [first in %list] as %list.1
# Membership testing # Membership testing
test: assume: 3 is in [1,2,3,4,5] test: assume (3 is in [1, 2, 3, 4, 5])
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)
return (no) return (no)
test: assume: 99 isn't in [1,2,3] test: assume (99 isn't in [1, 2, 3])
action [..] action [..]
%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 doesn't contain %item, %list does not 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: if (%key is %item): return (no)
for %key = %value in %list
if (%key is %item): return (no)
return (yes) return (yes)
test: assume: {x:no} has key "x" test: assume ({"x": no} has key "x")
parse [%list has key %index, %list has index %index] as parse [%list has key %index, %list has index %index] as (%list.%index != (nil))
%list.%index != (nil) test:
assume ({"x": no} doesn't have key "y")
assume (not ({"x": no} doesn't have key "x"))
test
assume: {x:no} doesn't have key "y"
assume: not: {x:no} doesn't have key "x"
parse [..] parse [..]
%list doesn't have key %index, %list does not have key %index %list doesn't have key %index, %list does not have key %index
%list doesn't have index %index, %list does not have index %index %list doesn't have index %index, %list does not have index %index
..as ..as (%list.%index = (nil))
%list.%index = (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))"
test test:
%list <- [1,2,3,4,5] %list <- [1, 2, 3, 4, 5]
append 6 to %list append 6 to %list
assume: (last in %list) is 6 assume ((last in %list) is 6)
pop from %list pop from %list
assume: (last in %list) is 5 assume ((last in %list) is 5)
remove index 1 from %list remove index 1 from %list
assume: (first in %list) is 2 assume ((first in %list) is 2)
compile [append %item to %list, add %item to %list, to %list add %item, to %list append %item] to compile [..]
Lua "table.insert(\(%list as lua expr), \(%item as lua expr))" 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))")
compile [pop from %list, remove last from %list] to compile [pop from %list, remove last from %list] to (..)
Lua value "table.remove(\(%list as lua expr))" Lua value "table.remove(\(%list as lua expr))"
compile [remove index %index from %list] to compile [remove index %index from %list] to (..)
Lua value "table.remove(\(%list as lua expr), \(%index as lua expr))" Lua value "table.remove(\(%list as lua expr), \(%index as lua expr))"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# List Comprehension # List Comprehension
test: assume: ((% * %) for % in [1,2,3]) = [1,4,9] test: assume (((% * %) for % in [1, 2, 3]) = [1, 4, 9])
parse [%expression for %item in %iterable] as parse [%expression for %item in %iterable] as (..)
result of result of:
%comprehension <- [] %comprehension <- []
for %item in %iterable for %item in %iterable: add %expression to %comprehension
add %expression to %comprehension
return %comprehension return %comprehension
parse [..] parse [..]
%expression for %index in %start to %stop via %step %expression for %index in %start to %stop via %step
%expression for %index in %start to %stop by %step %expression for %index in %start to %stop by %step
..as ..as (..)
result of result of:
%comprehension <- [] %comprehension <- []
for %index in %start to %stop via %step for %index in %start to %stop via %step: add %expression to %comprehension
add %expression to %comprehension
return %comprehension return %comprehension
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test: assume: ((% * %) for % in 1 to 3) = [1,4,9]
parse [%expression for %var in %start to %stop] as test: assume (((% * %) for % in 1 to 3) = [1, 4, 9])
parse [%expression for %var in %start to %stop] as (..)
%expression for %var in %start to %stop via 1 %expression for %var in %start to %stop via 1
test: assume: ("\%k,\%v" for %k = %v in {x:1}) = ["x,1"] test: assume (("\%k,\%v" for %k = %v in {"x": 1}) = ["x,1"])
parse [..] parse [..]
%expression for %key = %value in %iterable %expression for %key = %value in %iterable
%expression for (%key,%value) in %iterable %expression for %key %value in %iterable
..as ..as (..)
result of result of:
%comprehension <- [] %comprehension <- []
for %key = %value in %iterable for %key = %value in %iterable: add %expression to %comprehension
add %expression to %comprehension
return %comprehension return %comprehension
# Dict comprehensions # Dict comprehensions
test: assume: ((% * %) = % for % in [1,2,3]) = {1:1,4:2,9:3} test: assume (((% * %) = % for % in [1, 2, 3]) = {1: 1, 4: 2, 9: 3})
parse [..] parse [%key = %value for %item in %iterable, %key %value for %item in %iterable]
%key = %value for %item in %iterable ..as (..)
(%key,%value) for %item in %iterable result of:
..as
result of
%comprehension <- {} %comprehension <- {}
for %item in %iterable for %item in %iterable: %comprehension.%key <- %value
%comprehension.%key <- %value
return %comprehension return %comprehension
test: assume: (%k = (%v * %v) for %k = %v in {x:1,y:2,z:3}) = {x:1,y:4,z:9} test:
assume (..)
(%k = (%v * %v) for %k = %v in {"x": 1, "y": 2, "z": 3}) = {"x": 1, "y": 4, "z": 9}
parse [..] parse [..]
%key = %value for %src_key = %src_value in %iterable %key = %value for %src_key = %src_value in %iterable
(%key,%value) for (%src_key,%src_value) in %iterable %key %value for %src_key %src_value in %iterable
..as ..as (..)
result of result of:
%comprehension <- {} %comprehension <- {}
for %src_key = %src_value in %iterable for %src_key = %src_value in %iterable: %comprehension.%key <- %value
%comprehension.%key <- %value
return %comprehension return %comprehension
parse [..] parse [..]
%key = %value for %item in %start to %stop via %step %key = %value for %item in %start to %stop via %step
(%key,%value) for %item in %start to %stop via %step %key %value for %item in %start to %stop via %step
..as ..as (..)
result of result of:
%comprehension <- {} %comprehension <- {}
for %item in %start to %stop via %step for %item in %start to %stop via %step: %comprehension.%key <- %value
%comprehension.%key <- %value
return %comprehension return %comprehension
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test: assume: ((% * %) = % for % in 1 to 3) = {1:1,4:2,9:3} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test: assume (((% * %) = % for % in 1 to 3) = {1: 1, 4: 2, 9: 3})
parse [..] parse [..]
%key = %value for %item in %start to %stop %key = %value for %item in %start to %stop
(%key,%value) for %item in %start to %stop %key %value for %item in %start to %stop
..as: %key = %value for %item in %start to %stop via 1 ..as (%key = %value for %item in %start to %stop via 1)
test: assume: ([[1,2],[3,4]] flattened) = [1,2,3,4] test: assume (([[1, 2], [3, 4]] flattened) = [1, 2, 3, 4])
action [%lists flattened] action [%lists flattened]:
%flat <- [] %flat <- []
for %list in %lists for %list in %lists: for %item in %list: add %item to %flat
for %item in %list
add %item to %flat
return %flat return %flat
test: assume: (entries in {x:1}) = [{key:"x",value:1}] test: assume ((entries in {"x": 1}) = [{"key": "x", "value": 1}])
parse [entries in %dict] as: {key:%k, value:%v} for %k = %v in %dict parse [entries in %dict] as ({"key": %k, "value": %v} for %k = %v in %dict)
test: assume ((keys in {"x": 1}) = ["x"])
test: assume: (keys in {x:1}) = ["x"] parse [keys in %dict, keys of %dict] as (%k for %k = %v in %dict)
parse [keys in %dict, keys of %dict] as: %k for %k = %v in %dict test: assume ((values in {"x": 1}) = [1])
parse [values in %dict, values of %dict] as (%v for %k = %v in %dict)
test: assume: (values in {x:1}) = [1]
parse [values in %dict, values of %dict] as: %v for %k = %v in %dict
# Metatable stuff # Metatable stuff
test test:
%t <- {} %t <- {}
set %t's metatable to {__tostring:[%]->"XXX"} set %t 's metatable to {"__tostring": [%] -> "XXX"}
assume: "\%t" = "XXX" assume ("\%t" = "XXX")
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));"
test: assume: ({} with fallback % -> (% + 1)).10 = 11 test: assume (({} with fallback % -> (% + 1)).10 = 11)
compile [%dict with fallback %key -> %value] to compile [%dict with fallback %key -> %value] to (..)
Lua value ".." Lua value ".."
setmetatable(\(%dict as lua expr), {__index=function(self, \(%key as lua expr)) setmetatable(\(%dict as lua expr), {__index=function(self, \(%key as lua expr))
local value = \(%value as lua expr) local value = \(%value as lua expr)
@ -182,48 +174,44 @@ compile [%dict with fallback %key -> %value] to
return value return value
end}) end})
# Sorting # Sorting
test test:
%x <- [3,1,2] %x <- [3, 1, 2]
sort %x sort %x
assume: %x = [1,2,3] assume (%x = [1, 2, 3])
sort %x by % = (-%) sort %x by % = (- %)
assume: %x = [3,2,1] assume (%x = [3, 2, 1])
%keys <- {1:999,2:0,3:50} %keys <- {1: 999, 2: 0, 3: 50}
sort %x by % = %keys.% sort %x by % = %keys.%
assume: %x = [2,3,1] assume (%x = [2, 3, 1])
compile [sort %items] to: Lua "table.sort(\(%items as lua expr));"
parse [..] compile [sort %items] to (Lua "table.sort(\(%items as lua expr));")
sort %items by %item = %key_expr parse [sort %items by %item = %key_expr, sort %items by %item -> %key_expr] as (..)
sort %items by %item -> %key_expr do:
..as
do
%keys <- ({} with fallback %item -> %key_expr) %keys <- ({} with fallback %item -> %key_expr)
lua> "table.sort(\%items, function(x,y) return \%keys[x] < \%keys[y] end)" lua> "table.sort(\%items, function(x,y) return \%keys[x] < \%keys[y] end)"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test: assume: (sorted [3,1,2]) = [1,2,3] test: assume ((sorted [3, 1, 2]) = [1, 2, 3])
action [%items sorted, sorted %items] action [%items sorted, sorted %items]:
%copy <- (% for % in %items) %copy <- (% for % in %items)
sort %copy sort %copy
return %copy return %copy
parse [..]
%items sorted by %item = %key parse [%items sorted by %item = %key, %items sorted by %item -> %key] as (..)
%items sorted by %item -> %key result of:
..as
result of
%copy <- (% for % in %items) %copy <- (% for % in %items)
sort %copy by %item = %key sort %copy by %item = %key
return %copy return %copy
test: assume: (unique [1,2,1,3,2,3]) = [1,2,3] test: assume ((unique [1, 2, 1, 3, 2, 3]) = [1, 2, 3])
action [unique %items] action [unique %items]:
%unique <- [] %unique <- []
%seen <- {} %seen <- {}
for % in %items for % in %items:
unless: %seen.% unless %seen.%:
add % to %unique add % to %unique
%seen.% <- (yes) %seen.% <- (yes)
return %unique return %unique

370
core/control_flow.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V1 #!/usr/bin/env nomsu -V2.2.4.3
# #
This file contains compile-time actions that define basic control flow structures This file contains compile-time actions that define basic control flow structures
like "if" statements and loops. like "if" statements and loops.
@ -10,19 +10,21 @@ use "core/errors.nom"
# No-Op # No-Op
test: do nothing test: do nothing
compile [do nothing] to: Lua "" compile [do nothing] to (Lua "")
# Conditionals # Conditionals
test: if (no): barf "conditional fail" test: if (no): barf "conditional fail"
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
test: unless (yes): barf "conditional fail"
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 test: unless (yes): barf "conditional fail"
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 (..)
Lua ".." Lua ".."
if \(%condition as lua expr) then if \(%condition as lua expr) then
\(%if_body as lua statements) \(%if_body as lua statements)
@ -30,7 +32,7 @@ compile [if %condition %if_body else %else_body, unless %condition %else_body el
\(%else_body as lua statements) \(%else_body as lua statements)
end end
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Conditional expression (ternary operator) # Conditional expression (ternary operator)
# Note: this uses a function instead of "(condition and if_expr or else_expr)" # Note: this uses a function instead of "(condition and if_expr or else_expr)"
@ -40,18 +42,20 @@ compile [..]
%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: {Text:yes, List:yes, Dict:yes, Number:yes}.(%when_true_expr.type) if {"Text": yes, "List": yes, "Dict": yes, "Number": yes}.(%when_true_expr.type):
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
@ -61,19 +65,21 @@ compile [..]
end end
end)()) end)())
# GOTOs # GOTOs
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
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
#TODO: do "using % compile %" instead so it's actually a helper function #TODO: do "using % compile %" instead so it's actually a helper function
compile [%tree has subtree %subtree where %condition] to compile [%tree has subtree %subtree where %condition] to (..)
Lua value ".." Lua value ".."
(function() (function()
for \(%subtree as lua expr) in coroutine.wrap(function() \(%tree as lua expr):map(coroutine.yield) end) do for \(%subtree as lua expr) in coroutine.wrap(function() \(%tree as lua expr):map(coroutine.yield) end) do
@ -84,294 +90,271 @@ compile [%tree has subtree %subtree where %condition] to
return false return false
end)() end)()
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# While loops # While loops
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:
%lua <- %lua <- (..)
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: (%.type = "Action") and (%.stub is "do next repeat") if (..)
..:to %lua write "\n ::continue_repeat::" %body has subtree % where ((%.type = "Action") and (%.stub is "do next repeat"))
to %lua write "\nend --while-loop"
if
%body has subtree % where: (%.type = "Action") and (%.stub is "stop repeating")
..
%lua <-
Lua ".."
do -- scope of "stop repeating" label
\%lua
::stop_repeat::
end -- end of "stop repeating" label scope
return %lua
parse [repeat %body] as: repeat while (yes) %body
parse [repeat until %condition %body] as: repeat while (not %condition) %body
compile [..]
repeat %n times %body
..to
%lua <-
Lua ".."
for i=1,\(%n as lua expr) do
\(%body as lua statements)
if
%body has subtree % where: (%.type = "Action") and (%.stub is "do next repeat")
..: to %lua write "\n ::continue_repeat::" ..: to %lua write "\n ::continue_repeat::"
to %lua write "\nend --numeric for-loop"
if to %lua write "\nend --while-loop"
%body has subtree % where: (%.type = "Action") and (%.stub is "stop repeating") if (%body has subtree % where ((%.type = "Action") and (%.stub is "stop repeating"))):
.. %lua <- (..)
%lua <-
Lua ".." Lua ".."
do -- scope of "stop repeating" label do -- scope of "stop repeating" label
\%lua \%lua
::stop_repeat:: ::stop_repeat::
end -- end of "stop repeating" label scope end -- end of "stop repeating" label scope
return %lua return %lua
parse [repeat %body] as (repeat while (yes) %body)
parse [repeat until %condition %body] as (repeat while (not %condition) %body)
compile [repeat %n times %body] to:
%lua <- (Lua "for i=1,\(%n as lua expr) do\n \(%body as lua statements)")
if (%body has subtree % where ((%.type = "Action") and (%.stub is "do next repeat"))):
to %lua write "\n ::continue_repeat::"
to %lua write "\nend --numeric for-loop"
if (%body has subtree % where ((%.type = "Action") and (%.stub is "stop repeating"))):
%lua <- (..)
Lua ".."
do -- scope of "stop repeating" label
\%lua
::stop_repeat::
end -- end of "stop repeating" label scope
return %lua
# For loop control flow # For loop control flow
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 (Lua "goto continue_\(%var as lua identifier)")
compile [do next %var] to compile [===stop %var ===, ---stop %var ---, ***stop %var ***] to (..)
Lua "goto continue_\(%var as lua identifier)"
compile [=== stop %var ===, --- stop %var ---, *** stop %var ***] to
Lua "::stop_\(%var as lua identifier)::" Lua "::stop_\(%var as lua identifier)::"
compile [=== next %var ===, --- next %var ---, *** next %var ***] to
compile [===next %var ===, ---next %var ---, ***next %var ***] to (..)
Lua "::continue_\(%var as lua identifier)::" Lua "::continue_\(%var as lua identifier)::"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Numeric range for loops # Numeric range for loops
compile [..] compile [..]
for %var in %start to %stop by %step %body for %var in %start to %stop by %step %body
for %var in %start to %stop via %step %body for %var in %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" assume (%var.type is "Var") or barf "Loop expected variable, not: \%var"
%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 (..)
(%.type = "Action") and %body has subtree % where (..)
(%.stub is "do next %") and (%.type = "Action") and ((%.stub is "do next %") and (%.(3).1 = %var.1))
%.(3).1 = %var.1 ..: to %lua write "\n \(compile as (===next %var ===))"
..: to %lua write "\n \(compile as: === next %var ===)"
to %lua write "\nend --numeric for-loop" to %lua write "\nend --numeric for-loop"
if (..)
if %body has subtree % where (..)
%body has subtree % where (%.type = "Action") and ((%.stub is "stop %") and (%.(2).1 = %var.1))
(%.type = "Action") and ..:
(%.stub is "stop %") and %lua <- (..)
%.(2).1 = %var.1
..
%lua <-
Lua ".." Lua ".."
do -- scope for stopping for-loop do -- scope for stopping for-loop
\%lua \%lua
\(compile as: === stop %var ===) \(compile as (===stop %var ===))
end -- end of scope for stopping for-loop end -- end of scope for stopping for-loop
return %lua return %lua
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
parse [for %var in %start to %stop %body] as (..)
for %var in %start to %stop via 1 %body
parse [for %var in %start to %stop %body] as: for %var in %start to %stop via 1 %body
# For-each loop (lua's "ipairs()") # For-each loop (lua's "ipairs()")
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" assume (%var.type is "Var") or barf "Loop expected variable, not: \%var"
%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 (..)
(%.type = "Action") and %body has subtree % where (..)
(%.stub is "do next %") and (%.type = "Action") and ((%.stub is "do next %") and (%.(3).1 = %var.1))
%.3.(1) = %var.(1) ..: to %lua write (Lua "\n\(compile as (===next %var ===))")
..: to %lua write (Lua "\n\(compile as: === next %var ===)")
to %lua write "\nend --foreach-loop" to %lua write "\nend --foreach-loop"
if if (..)
%body has subtree % where %body has subtree % where (..)
(%.type = "Action") and (%.type = "Action") and ((%.stub is "stop %") and (%.(2).1 = %var.1))
(%.stub is "stop %") and ..:
%.2.(1) = %var.(1) %lua <- (..)
..
%lua <-
Lua ".." Lua ".."
do -- scope for stopping for-loop do -- scope for stopping for-loop
\%lua \%lua
\(compile as: === stop %var ===) \(compile as (===stop %var ===))
end -- end of scope for stopping for-loop end -- end of scope for stopping for-loop
return %lua return %lua
# Dict iteration (lua's "pairs()") # Dict iteration (lua's "pairs()")
compile [..] compile [for %key = %value in %iterable %body, for %key %value in %iterable %body] to:
for %key = %value in %iterable %body
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" assume (%key.type is "Var") or barf "Loop expected variable, not: \%key"
assume (%value.type is "Var") or barf "Loop expected variable, not: \%value" assume (%value.type is "Var") or barf "Loop expected variable, not: \%value"
%lua <- %lua <- (..)
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
(%.type = "Action") and
(%.stub is "do next %") and
%.3.(1) = %key.(1)
..: to %lua write (Lua "\n\(compile as: === next %key ===)")
if
%body has subtree % where
(%.type = "Action") and
(%.stub is "do next %") and
%.3.(1) = %value.(1)
..: to %lua write (Lua "\n\(compile as: === next %value ===)")
to %lua write "\nend --foreach-loop"
if (..)
%body has subtree % where (..)
(%.type = "Action") and ((%.stub is "do next %") and (%.(3).1 = %key.1))
..: to %lua write (Lua "\n\(compile as (===next %key ===))")
if (..)
%body has subtree % where (..)
(%.type = "Action") and ((%.stub is "do next %") and (%.(3).1 = %value.1))
..: to %lua write (Lua "\n\(compile as (===next %value ===))")
to %lua write "\nend --foreach-loop"
%stop_labels <- (Lua "") %stop_labels <- (Lua "")
if if (..)
%body has subtree % where %body has subtree % where (..)
(%.type = "Action") and (%.type = "Action") and ((%.stub is "stop %") and (%.(2).1 = %key.1))
(%.stub is "stop %") and ..: to %stop_labels write "\n\(compile as (===stop %key ===))"
%.2.(1) = %key.(1)
..: to %stop_labels write "\n\(compile as: === stop %key ===)" if (..)
%body has subtree % where (..)
if (%.type = "Action") and ((%.stub is "stop %") and (%.(2).1 = %value.1))
%body has subtree % where ..: to %stop_labels write "\n\(compile as (===stop %value ===))"
(%.type = "Action") and
(%.stub is "stop %") and if ((length of "\%stop_labels") > 0):
%.2.(1) = %value.(1) %lua <- (..)
..: to %stop_labels write "\n\(compile as: === stop %value ===)" Lua "do -- scope for stopping for % = % loop\n \%lua\%stop_labels\nend"
if: (length of "\%stop_labels") > 0
%lua <-
Lua ".."
do -- scope for stopping for % = % loop
\%lua\%stop_labels
end
return %lua return %lua
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Switch statement/multi-branch if # Switch statement/multi-branch if
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)
%branches <- %branches <- (%body if (%body.type = "Block") else [%body])
%body if (%body.type = "Block") else [%body] for %func_call in %branches:
for %func_call in %branches assume (%func_call.type is "Action") or barf "Invalid format for 'when' statement. Only '*' blocks are allowed."
assume (%func_call.type is "Action") or barf ".." with {%star: %func_call.1, %condition: %func_call.2, %action: %func_call.3}:
Invalid format for 'when' statement. Only '*' blocks are allowed. assume (%star = "*") or barf "Invalid format for 'when' statement. Lines must begin with '*'"
with {..}
%star: %func_call.1
%condition: %func_call.2
%action: %func_call.3
..
assume (%star = "*") or barf ".."
Invalid format for 'when' statement. Lines must begin with '*'
assume %condition or barf ".." assume %condition or barf ".."
Invalid format for 'when' statement. Lines must begin with '*' and have a condition or the word "else" Invalid format for 'when' statement. Lines must begin with '*' and have a condition \
if: %action is (nil) ..or the word "else"
if (%action is (nil)):
lua> "table.insert(\%fallthroughs, \(%condition as lua expr))" lua> "table.insert(\%fallthroughs, \(%condition as lua expr))"
do next %func_call do next %func_call
if: %condition = "else" if (%condition = "else"):
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)
%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 "
to %code write (%action as lua statements) to %code write (%action as lua statements)
%fallthroughs <- [] %fallthroughs <- []
%is_first <- (no) %is_first <- (no)
assume (%fallthroughs = []) or barf "Unfinished fallthrough conditions in 'when' block" assume (%fallthroughs = []) or barf "Unfinished fallthrough conditions in 'when' block"
assume ((length of "\%code") > 0) or barf "Empty body for 'when' block" assume ((length of "\%code") > 0) or barf "Empty body for 'when' block"
to %code write "\nend --when" to %code write "\nend --when"
return %code return %code
# Switch statement # Switch statement
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)
%branches <- %branches <- (%body if (%body.type = "Block") else [%body])
%body if (%body.type = "Block") else [%body] for %func_call in %branches:
for %func_call in %branches assume (%func_call.type is "Action") or barf "Invalid format for 'when' statement. Only '*' blocks are allowed."
assume (%func_call.type is "Action") or barf ".." with {%star: %func_call.1, %condition: %func_call.2, %action: %func_call.3}:
Invalid format for 'when' statement. Only '*' blocks are allowed. assume (%star = "*") or barf "Invalid format for 'when' statement. Lines must begin with '*'"
with {%star:%func_call.1, %condition:%func_call.2, %action:%func_call.3}
assume (%star = "*") or barf ".."
Invalid format for 'when' statement. Lines must begin with '*'
assume %condition or barf ".." assume %condition or barf ".."
Invalid format for 'when' statement. Lines must begin with '*' and have a condition or the word "else" Invalid format for 'when' statement. Lines must begin with '*' and have a condition \
if: %action is (nil) ..or the word "else"
if (%action is (nil)):
lua> "table.insert(\%fallthroughs, \(%condition as lua expr))" lua> "table.insert(\%fallthroughs, \(%condition as lua expr))"
do next %func_call do next %func_call
if: %condition = "else" if (%condition = "else"):
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))"
for %i = % in %fallthroughs for %i = % in %fallthroughs:
if: %i > 1 if (%i > 1): 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)
%fallthroughs <- [] %fallthroughs <- []
%is_first <- (no) %is_first <- (no)
assume (%fallthroughs = []) or barf "Unfinished fallthrough conditions in 'when' block" assume (%fallthroughs = []) or barf "Unfinished fallthrough conditions in 'when' block"
assume ((length of "\%code") > 0) or barf "No body for 'when % = ?' block!" assume ((length of "\%code") > 0) or barf "No body for 'when % = ?' block!"
to %code write "\nend" to %code write "\nend"
%code <- %code <- (..)
Lua ".." Lua ".."
do --when % = ? do --when % = ?
local branch_value = \(%branch_value as lua expr) local branch_value = \(%branch_value as lua expr)
\%code \%code
end --when % = ? end --when % = ?
return %code return %code
# Do/finally # Do/finally
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
@ -384,23 +367,24 @@ compile [do %action then always %final_action] to
if not fell_through then return ret end if not fell_through then return ret end
end end
# Inline thunk: # Inline thunk:
compile [result of %body] to compile [result of %body] to (Lua value "(\(compile as ([] -> %body)))()")
Lua value "(\(compile as: [] -> %body))()"
# Recurion control flow # Recurion control flow
compile [for %var in recursive %structure %body] to compile [for %var in recursive %structure %body] to (..)
with local compile actions with local compile actions:
compile [recurse %v on %x] to compile [recurse %v on %x] to (..)
Lua "table.insert(stack\(%v as lua id), \(%x as lua expr))" Lua "table.insert(stack\(%v as lua id), \(%x as lua expr))"
return
return (..)
Lua ".." Lua ".."
do do
local stack\(%var as lua id) = list{\(%structure as lua expr)} local stack\(%var as lua id) = list{\(%structure as lua expr)}
while #stack\(%var as lua id) > 0 do while #stack\(%var as lua id) > 0 do
\(%var as lua expr) = table.remove(stack\(%var as lua id), 1) \(%var as lua expr) = table.remove(stack\(%var as lua id), 1)
\(%body as lua statements) \(%body as lua statements)
\(compile as: === next %var ===) \(compile as (===next %var ===))
end end
\(compile as: === stop %var ===) \(compile as (===stop %var ===))
end end

17
core/coroutines.nom
View File

@ -1,18 +1,15 @@
#!/usr/bin/env nomsu -V1 #!/usr/bin/env nomsu -V2.2.4.3
# #
This file defines the code that creates and manipulates coroutines This file defines the code that creates and manipulates coroutines
use "core/metaprogramming.nom" use "core/metaprogramming.nom"
compile [coroutine %body, generator %body] to (..)
Lua value "(function()\n \(%body as lua statements)\nend)"
compile [coroutine %body, generator %body] to compile [->] to (Lua value "coroutine.yield(true)")
Lua value ".." compile [-> %] to (Lua value "coroutine.yield(true, \(% as lua expr))")
(function() compile [for % in coroutine %co %body] to (..)
\(%body as lua statements)
end)
compile [->] to: Lua value "coroutine.yield(true)"
compile [-> %] to: Lua value "coroutine.yield(true, \(% as lua expr))"
compile [for % in coroutine %co %body] to
Lua ".." Lua ".."
for junk,\(% as lua expr) in coroutine.wrap(\(%co as lua expr)) do for junk,\(% as lua expr) in coroutine.wrap(\(%co as lua expr)) do
\(%body as lua statements) \(%body as lua statements)
end end

55
core/errors.nom
View File

@ -1,32 +1,34 @@
#!/usr/bin/env nomsu -V1 #!/usr/bin/env nomsu -V2.2.4.3
# #
This file contains basic error reporting code This file contains basic error reporting code
use "core/metaprogramming.nom" use "core/metaprogramming.nom"
compile [traceback] to (Lua value "debug.traceback()")
compile [traceback] to: Lua value "debug.traceback()" compile [traceback %] to (Lua value "debug.traceback('', \(% as lua expr))")
compile [traceback %] to: Lua value "debug.traceback('', \(% as lua expr))" 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> ".."
lua> "local \%assumption = 'Assumption failed: '..tostring(nomsu:tree_to_nomsu(\%condition))" local \%assumption = 'Assumption failed: '..tostring(nomsu:tree_to_nomsu(\%condition))
return
return (..)
Lua ".." Lua ".."
if not \(%condition as lua expr) then if not \(%condition as lua expr) then
error(\(quote "\%assumption"), 0) error(\(quote "\%assumption"), 0)
end end
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
# Try/except # Try/except
compile [..] compile [..]
try %action and if it succeeds %success or if it barfs %msg %fallback try %action and if it succeeds %success or if it barfs %msg %fallback
try %action and if it barfs %msg %fallback or if it succeeds %success try %action and if it barfs %msg %fallback or if it succeeds %success
..to ..to (..)
Lua ".." Lua ".."
do do
local fell_through = false local fell_through = false
@ -50,20 +52,23 @@ compile [..]
end end
end end
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
parse [..] parse [..]
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
..as: try %action and if it succeeds %success or if it barfs (=lua "") %fallback ..as (try %action and if it succeeds %success or if it barfs (=lua "") %fallback)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
parse [try %action] as ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
try %action and if it succeeds: do nothing
..or if it barfs: do nothing parse [try %action] as (..)
parse [try %action and if it barfs %fallback] as try %action and if it succeeds (do nothing) or if it barfs (do nothing)
try %action and if it succeeds: do nothing
..or if it barfs %fallback parse [try %action and if it barfs %fallback] as (..)
parse [try %action and if it barfs %msg %fallback] as try %action and if it succeeds (do nothing) or if it barfs %fallback
try %action and if it succeeds: do nothing
..or if it barfs %msg %fallback parse [try %action and if it barfs %msg %fallback] as (..)
parse [try %action and if it succeeds %success] as try %action and if it succeeds (do nothing) or if it barfs %msg %fallback
try %action and if it succeeds %success or if it barfs: do nothing
parse [try %action and if it succeeds %success] as (..)
try %action and if it succeeds %success or if it barfs (do nothing)

9
core/io.nom
View File

@ -1,10 +1,9 @@
#!/usr/bin/env nomsu -V1 #!/usr/bin/env nomsu -V2.2.4.3
# #
This file contains basic input/output code This file contains basic input/output code
use "core/metaprogramming.nom" use "core/metaprogramming.nom"
compile [say %message] to (..)
compile [say %message] to
lua> ".." lua> ".."
if \%message.type == "Text" then if \%message.type == "Text" then
return LuaCode(tree.source, "print(", \(%message as lua expr), ");"); return LuaCode(tree.source, "print(", \(%message as lua expr), ");");
@ -12,10 +11,10 @@ compile [say %message] to
return LuaCode(tree.source, "print(tostring(", \(%message as lua expr), "));"); return LuaCode(tree.source, "print(tostring(", \(%message as lua expr), "));");
end end
compile [ask %prompt] to compile [ask %prompt] to (..)
lua> ".." lua> ".."
if \%prompt.type == "Text" then if \%prompt.type == "Text" then
return LuaCode.Value(tree.source, "(io.write(", \(%prompt as lua expr), ") and io.read())"); return LuaCode.Value(tree.source, "(io.write(", \(%prompt as lua expr), ") and io.read())");
else else
return LuaCode.Value(tree.source, "(io.write(tostring(", \(%prompt as lua expr), ")) and io.read())"); return LuaCode.Value(tree.source, "(io.write(tostring(", \(%prompt as lua expr), ")) and io.read())");
end end

176
core/math.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V1 #!/usr/bin/env nomsu -V2.2.4.3
# #
This file defines some common math literals and functions This file defines some common math literals and functions
@ -9,91 +9,119 @@ use "core/control_flow.nom"
use "core/collections.nom" use "core/collections.nom"
# Literals: # Literals:
compile [infinity, inf] to: Lua value "math.huge" compile [infinity, inf] to (Lua value "math.huge")
compile [not a number, NaN, nan] to: Lua value "(0/0)" compile [not a number, NaN, nan] to (Lua value "(0/0)")
compile [pi, Pi, PI] to: Lua value "math.pi" compile [pi, Pi, PI] to (Lua value "math.pi")
compile [tau, Tau, TAU] to: Lua value "(2*math.pi)" compile [tau, Tau, TAU] to (Lua value "(2*math.pi)")
compile [golden ratio] to: Lua value "((1+math.sqrt(5))/2)" compile [golden ratio] to (Lua value "((1+math.sqrt(5))/2)")
compile [e] to: Lua value "math.exp(1)" compile [e] to (Lua value "math.exp(1)")
# Functions: # Functions:
compile [% as a number, % as number] to: Lua value "tonumber(\(% as lua expr))" compile [% as a number, % as number] to (Lua value "tonumber(\(% as lua expr))")
compile [absolute value %, | % |, abs %] to: Lua value "math.abs(\(% as lua expr))" compile [absolute value %, | % |, abs %] to (..)
compile [square root %, square root of %, √%, sqrt %] to: Lua value "math.sqrt(\(% as lua expr))" Lua value "math.abs(\(% as lua expr))"
compile [sine %, sin %] to: Lua value "math.sin(\(% as lua expr))"
compile [cosine %, cos %] to: Lua value "math.cos(\(% as lua expr))" compile [square root %, square root of %, √ %, sqrt %] to (..)
compile [tangent %, tan %] to: Lua value "math.tan(\(% as lua expr))" Lua value "math.sqrt(\(% as lua expr))"
compile [arc sine %, asin %] to: Lua value "math.asin(\(% as lua expr))"
compile [arc cosine %, acos %] to: Lua value "math.acos(\(% as lua expr))" compile [sine %, sin %] to (Lua value "math.sin(\(% as lua expr))")
compile [arc tangent %, atan %] to: Lua value "math.atan(\(% as lua expr))" compile [cosine %, cos %] to (Lua value "math.cos(\(% as lua expr))")
compile [arc tangent %y / %x, atan2 %y %x] to: Lua value "math.atan2(\(%y as lua expr), \(%x as lua expr))" compile [tangent %, tan %] to (Lua value "math.tan(\(% as lua expr))")
compile [hyperbolic sine %, sinh %] to: Lua value "math.sinh(\(% as lua expr))" compile [arc sine %, asin %] to (Lua value "math.asin(\(% as lua expr))")
compile [hyperbolic cosine %, cosh %] to: Lua value "math.cosh(\(% as lua expr))" compile [arc cosine %, acos %] to (Lua value "math.acos(\(% as lua expr))")
compile [hyperbolic tangent %, tanh %] to: Lua value "math.tanh(\(% as lua expr))" compile [arc tangent %, atan %] to (Lua value "math.atan(\(% as lua expr))")
compile [e^%, exp %] to: Lua value "math.exp(\(% as lua expr))" compile [arc tangent %y / %x, atan2 %y %x] to (..)
compile [natural log %, ln %, log %] to: Lua value "math.log(\(% as lua expr))" Lua value "math.atan2(\(%y as lua expr), \(%x as lua expr))"
compile [log % base %base, log base %base of %] to: Lua value "math.log(\(% as lua expr), \(%base as lua expr))"
compile [floor %] to: Lua value "math.floor(\(% as lua expr))" compile [hyperbolic sine %, sinh %] to (Lua value "math.sinh(\(% as lua expr))")
compile [ceiling %, ceil %] to: Lua value "math.ceil(\(% as lua expr))" compile [hyperbolic cosine %, cosh %] to (..)
compile [round %, % rounded] to: Lua value "math.floor(\(% as lua expr) + .5)" Lua value "math.cosh(\(% as lua expr))"
action [%n to the nearest %rounder]
compile [hyperbolic tangent %, tanh %] to (..)
Lua value "math.tanh(\(% as lua expr))"
compile [e^ %, exp %] to (Lua value "math.exp(\(% as lua expr))")
compile [natural log %, ln %, log %] to (Lua value "math.log(\(% as lua expr))")
compile [log % base %base, log base %base of %] to (..)
Lua value "math.log(\(% as lua expr), \(%base 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 [round %, % rounded] to (Lua value "math.floor(\(% as lua expr) + .5)")
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 <- ((% as lua expr) for % in %items) %clauses <- ((% as lua expr) for % in %items)
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)
compile [any of %items, any %items] to parse [not all of %items, not all %items] as (not (all of %items))
unless: %items.type is "List" compile [any of %items, any %items] to:
return: Lua value "utils.any(\(%items as lua expr))" unless (%items.type is "List"):
return (Lua value "utils.any(\(%items as lua expr))")
%clauses <- ((% as lua expr) for % in %items) %clauses <- ((% as lua expr) for % in %items)
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)
compile [sum of %items, sum %items] to parse [none of %items, none %items] as (not (any of %items))
unless: %items.type is "List" compile [sum of %items, sum %items] to:
return: Lua value "utils.sum(\(%items as lua expr))" unless (%items.type is "List"):
return (Lua value "utils.sum(\(%items as lua expr))")
%clauses <- ((% as lua expr) for % in %items) %clauses <- ((% as lua expr) for % in %items)
return: Lua value "(\(%clauses joined with " + "))" return (Lua value "(\(%clauses joined with " + "))")
compile [product of %items, product %items] to
unless: %items.type is "List" compile [product of %items, product %items] to:
return: Lua value "utils.product(\(%items as lua expr))" unless (%items.type is "List"):
return (Lua value "utils.product(\(%items as lua expr))")
%clauses <- ((% as lua expr) for % in %items) %clauses <- ((% as lua expr) for % in %items)
return: Lua value "(\(%clauses joined with " * "))" return (Lua value "(\(%clauses joined with " * "))")
action [avg of %items, average of %items]
=lua "(utils.sum(\%items)/#\%items)" action [avg of %items, average of %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))"
compile [max of %items, biggest of %items, largest of %items, highest of %items] to
Lua value "utils.max(\(%items as lua expr))" compile [max of %items, biggest of %items, largest of %items, highest of %items]
parse [min of %items by %item = %value_expr] as ..to (Lua value "utils.max(\(%items as lua expr))")
result of
<- {%best:nil, %best_key:nil} parse [min of %items by %item = %value_expr] as (..)
for %item in %items result of:
<- {%best: nil, %best_key: nil}
for %item in %items:
%key <- %value_expr %key <- %value_expr
if: (%best = (nil)) or (%key < %best_key) if ((%best = (nil)) or (%key < %best_key)):
<- {%best:%item, %best_key:%key} <- {%best: %item, %best_key: %key}
return %best
parse [max of %items by %item = %value_expr] as
result of
<- {%best:nil, %best_key:nil}
for %item in %items
%key <- %value_expr
if: (%best = (nil)) or (%key > %best_key)
<- {%best:%item, %best_key:%key}
return %best return %best
parse [max of %items by %item = %value_expr] as (..)
result of:
<- {%best: nil, %best_key: nil}
for %item in %items:
%key <- %value_expr
if ((%best = (nil)) or (%key > %best_key)):
<- {%best: %item, %best_key: %key}
return %best
# Random functions # Random functions
action [seed random with %] action [seed random with %] (..)
lua> ".." lua> "math.randomseed(\%);\nfor i=1,20 do math.random(); end"
math.randomseed(\%);
for i=1,20 do math.random(); end parse [seed random] as (seed random with (=lua "os.time()"))
parse [seed random] as: seed random with (=lua "os.time()") compile [random number, random, rand] to (Lua value "math.random()")
compile [random number, random, rand] to: Lua value "math.random()" compile [random int %n, random integer %n, randint %n] to (..)
compile [random int %n, random integer %n, randint %n] to: Lua value "math.random(\(%n as lua expr))" Lua value "math.random(\(%n as lua expr))"
compile [random from %low to %high, random number from %low to %high, rand %low %high] to
Lua value "math.random(\(%low as lua expr), \(%high as lua expr))" compile [random from %low to %high, random number from %low to %high, rand %low %high]
action [random choice from %elements, random choice %elements, random %elements] ..to (Lua value "math.random(\(%low as lua expr), \(%high as lua expr))")
action [random choice from %elements, random choice %elements, random %elements] (..)
=lua "\%elements[math.random(#\%elements)]" =lua "\%elements[math.random(#\%elements)]"

150
core/metaprogramming.nom
View File

@ -1,10 +1,9 @@
#!/usr/bin/env nomsu -V1 #!/usr/bin/env nomsu -V2.2.4.3
# #
This File contains actions for making actions and compile-time actions and some helper This File contains actions for making actions and compile-time actions and some helper
functions to make that easier. functions to make that easier.
lua> "NOMSU_CORE_VERSION = 2" lua> "NOMSU_CORE_VERSION = 2"
lua> ".." lua> ".."
nomsu.COMPILE_ACTIONS["% -> %"] = function(nomsu, tree, \%args, \%body) nomsu.COMPILE_ACTIONS["% -> %"] = function(nomsu, tree, \%args, \%body)
local lua = LuaCode.Value(tree.source, "function(") local lua = LuaCode.Value(tree.source, "function(")
@ -29,73 +28,71 @@ lua> ".."
return lua return lua
end end
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
lua> ".." lua> ".."
nomsu.COMPILE_ACTIONS["compile % to %"] = function(nomsu, tree, \%actions, \%body) nomsu.COMPILE_ACTIONS["compile % to %"] = function(nomsu, tree, \%actions, \%body)
local \%args = {"nomsu", "tree", unpack(table.map(\%actions[1]:get_args(), function(a) return tostring(nomsu:compile(a)) end))} local \%args = {"nomsu", "tree", unpack(table.map(\%actions[1]:get_args(), function(a) return tostring(nomsu:compile(a)) end))}
local lua = LuaCode(tree.source, "nomsu.COMPILE_ACTIONS[", repr(\%actions[1].stub), local lua = LuaCode(tree.source, "nomsu.COMPILE_ACTIONS[", repr(\%actions[1].stub),
"] = ", \(compile as: %args -> %body)) "] = ", \(compile as (%args -> %body)))
for i=2,#\%actions do for i=2,#\%actions do
local alias = \%actions[i] local alias = \%actions[i]
local \%alias_args = {"nomsu", "tree", unpack(table.map(alias:get_args(), function(a) return tostring(nomsu:compile(a)) end))} local \%alias_args = {"nomsu", "tree", unpack(table.map(alias:get_args(), function(a) return tostring(nomsu:compile(a)) end))}
lua:append("\nnomsu.COMPILE_ACTIONS[", repr(alias.stub), "] = ") lua:append("\\nnomsu.COMPILE_ACTIONS[", repr(alias.stub), "] = ")
if utils.equivalent(\%args, \%alias_args) then if utils.equivalent(\%args, \%alias_args) then
lua:append("nomsu.COMPILE_ACTIONS[", repr(\%actions[1].stub), "]") lua:append("nomsu.COMPILE_ACTIONS[", repr(\%actions[1].stub), "]")
else else
lua:append("function(") lua:append("function(")
lua:concat_append(\%alias_args, ", ") lua:concat_append(\%alias_args, ", ")
lua:append(")\n return nomsu.COMPILE_ACTIONS[", repr(\%actions[1].stub), "](") lua:append(")\\n return nomsu.COMPILE_ACTIONS[", repr(\%actions[1].stub), "](")
lua:concat_append(\%args, ", ") lua:concat_append(\%args, ", ")
lua:append(")\nend") lua:append(")\\nend")
end end
end end
return lua return lua
end end
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
compile [call %fn with %args] to compile [call %fn with %args] to (..)
lua> ".." lua> ".."
local lua = LuaCode.Value(tree.source, nomsu:compile(\%fn), "(") local lua = LuaCode.Value(tree.source, nomsu:compile(\%fn), "(")
lua:concat_append(table.map(\%args, function(a) return nomsu:compile(a) end), ", ") lua:concat_append(table.map(\%args, function(a) return nomsu:compile(a) end), ", ")
lua:append(")") lua:append(")")
return lua return lua
compile [local action %actions %body] to compile [local action %actions %body] to (..)
lua> ".." lua> ".."
local fn_name = "A"..string.as_lua_id(\%actions[1].stub) local fn_name = "A"..string.as_lua_id(\%actions[1].stub)
local \%args = table.map(\%actions[1]:get_args(), function(a) return tostring(nomsu:compile(a)) end) local \%args = table.map(\%actions[1]:get_args(), function(a) return tostring(nomsu:compile(a)) end)
local lua = LuaCode(tree.source, fn_name, " = ", \(compile as: %args -> %body)) local lua = LuaCode(tree.source, fn_name, " = ", \(compile as (%args -> %body)))
lua:add_free_vars({fn_name}) lua:add_free_vars({fn_name})
for i=2,#\%actions do for i=2,#\%actions do
local alias = \%actions[i] local alias = \%actions[i]
local alias_name = "A"..string.as_lua_id(alias.stub) local alias_name = "A"..string.as_lua_id(alias.stub)
lua:add_free_vars({alias_name}) lua:add_free_vars({alias_name})
local \%alias_args = table.map(alias:get_args(), function(a) return tostring(nomsu:compile(a)) end) local \%alias_args = table.map(alias:get_args(), function(a) return tostring(nomsu:compile(a)) end)
lua:append("\n", alias_name, " = ") lua:append("\\n", alias_name, " = ")
if utils.equivalent(\%args, \%alias_args) then if utils.equivalent(\%args, \%alias_args) then
lua:append(fn_name) lua:append(fn_name)
else else
lua:append("function(") lua:append("function(")
lua:concat_append(\%alias_args, ", ") lua:concat_append(\%alias_args, ", ")
lua:append(")\n return ", fn_name, "(") lua:append(")\\n return ", fn_name, "(")
lua:concat_append(\%args, ", ") lua:concat_append(\%args, ", ")
lua:append(")\nend") lua:append(")\\nend")
end end
end end
return lua return lua
compile [action %actions %body] to compile [action %actions %body] to (..)
lua> ".." lua> ".."
local lua = \(compile as: local action %actions %body) local lua = \(compile as (local action %actions %body))
lua:remove_free_vars(table.map(\%actions, function(a) return "A"..string.as_lua_id(a.stub) end)) lua:remove_free_vars(table.map(\%actions, function(a) return "A"..string.as_lua_id(a.stub) end))
return lua return lua
compile [action %action] to compile [action %action] to (Lua value "A\(%action.stub as lua id)")
Lua value "A\(%action.stub as lua id)" compile [parse %actions as %body] to (..)
compile [parse %actions as %body] to
lua> ".." lua> ".."
local replacements = {} local replacements = {}
for i,arg in ipairs(\%actions[1]:get_args()) do for i,arg in ipairs(\%actions[1]:get_args()) do
@ -115,56 +112,52 @@ compile [parse %actions as %body] to
end end
local \%new_body = LuaCode(\%body.source, local \%new_body = LuaCode(\%body.source,
"__MANGLE_INDEX = (__MANGLE_INDEX or 0) + 1", "__MANGLE_INDEX = (__MANGLE_INDEX or 0) + 1",
"\nlocal tree = ", make_tree(\%body), "\\nlocal tree = ", make_tree(\%body),
"\nlocal lua = nomsu:compile(tree); return lua") "\\nlocal lua = nomsu:compile(tree); return lua")
local ret = \(compile as: compile %actions to %new_body) local ret = \(compile as (compile %actions to %new_body))
return ret return ret
compile [%tree as lua expr] to compile [%tree as lua expr] to (..)
Lua value "nomsu:compile(\(=lua "nomsu:compile(\%tree):as_expr()")):as_expr()" Lua value "nomsu:compile(\(=lua "nomsu:compile(\%tree):as_expr()")):as_expr()"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
compile [%tree as lua] to
Lua value "nomsu:compile(\(%tree as lua expr))"
compile [%tree as lua statements] to compile [%tree as lua] to (Lua value "nomsu:compile(\(%tree as lua expr))")
compile [%tree as lua statements] to (..)
Lua value "nomsu:compile(\(%tree as lua expr)):as_statements()" Lua value "nomsu:compile(\(%tree as lua expr)):as_statements()"
compile [%tree as lua return] to compile [%tree as lua return] to (..)
Lua value "nomsu:compile(\(%tree as lua expr)):as_statements('return ')" Lua value "nomsu:compile(\(%tree as lua expr)):as_statements('return ')"
compile [remove action %action] to compile [remove action %action] to (..)
Lua ".." Lua "A\(=lua "string.as_lua_id(\(%action.stub))") = nil"
A\(=lua "string.as_lua_id(\(%action.stub))") = nil
compile [%tree as nomsu] to compile [%tree as nomsu] to (..)
Lua value "nomsu:tree_to_nomsu(\(%tree as lua expr))" Lua value "nomsu:tree_to_nomsu(\(%tree as lua expr))"
compile [%tree as inline nomsu] to compile [%tree as inline nomsu] to (..)
Lua value "nomsu:tree_to_nomsu(\(%tree as lua expr), true)" Lua value "nomsu:tree_to_nomsu(\(%tree as lua expr), true)"
action [%var as lua identifier, %var as lua id] action [%var as lua identifier, %var as lua id] (..)
lua> ".." lua> ".."
if type(\%var) == 'string' then return string.as_lua_id(\%var) if type(\%var) == 'string' then return string.as_lua_id(\%var)
elseif \%var.type == 'Var' then return string.as_lua_id(\%var[1]) elseif \%var.type == 'Var' then return string.as_lua_id(\%var[1])
elseif \%var.type == 'Action' then return "A"..string.as_lua_id(\%var.stub) elseif \%var.type == 'Action' then return "A"..string.as_lua_id(\%var.stub)
end end
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
compile [% is syntax tree] to ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Lua value "AST.is_syntax_tree(\(% as lua expr))"
compile [% is %kind syntax tree] to compile [% is syntax tree] to (Lua value "AST.is_syntax_tree(\(% as lua expr))")
compile [% is %kind syntax tree] to (..)
Lua value "AST.is_syntax_tree(\(% as lua expr), \(%kind as lua expr))" Lua value "AST.is_syntax_tree(\(% as lua expr), \(%kind as lua expr))"
compile [%tree with %t -> %replacement] to compile [%tree with %t -> %replacement] to (..)
Lua value ".." Lua value ".."
\(%tree as lua expr):map(function(\(%t as lua expr)) \(%tree as lua expr):map(function(\(%t as lua expr))
\(%replacement as lua return) \(%replacement as lua return)
end) end)
action [%tree with vars %replacements] action [%tree with vars %replacements] (..)
=lua ".." =lua ".."
\%tree:map(function(\%t) \%tree:map(function(\%t)
if \%t.type == "Var" then if \%t.type == "Var" then
@ -172,68 +165,69 @@ action [%tree with vars %replacements]
end end
end) end)
compile [declare locals in %code] to compile [declare locals in %code] to (..)
Lua value "\(%code as lua expr):declare_locals()" Lua value "\(%code as lua expr):declare_locals()"
compile [declare locals %locals in %code] to compile [declare locals %locals in %code] to (..)
Lua value "\(%code as lua expr):declare_locals(\(%locals as lua expr))" Lua value "\(%code as lua expr):declare_locals(\(%locals as lua expr))"
compile [add free vars %vars to %code] to compile [add free vars %vars to %code] to (..)
Lua "\(%code as lua expr):add_free_vars(\(%vars as lua expr));" Lua "\(%code as lua expr):add_free_vars(\(%vars as lua expr));"
compile [remove free vars %vars from %code] to compile [remove free vars %vars from %code] to (..)
Lua "\(%code as lua expr):remove_free_vars(\(%vars as lua expr));" Lua "\(%code as lua expr):remove_free_vars(\(%vars as lua expr));"
compile [%lua <-write %code, to %lua write %code] to: Lua "\(%lua as lua expr):append(\(%code as lua expr));" compile [%lua <-write %code, to %lua write %code] to (..)
Lua "\(%lua as lua expr):append(\(%code as lua expr));"
compile [to %lua write %code joined by %glue] to: Lua "\(%lua as lua expr):concat_append(\(%code as lua expr), \(%glue as lua expr));" compile [to %lua write %code joined by %glue] to (..)
Lua "\(%lua as lua expr):concat_append(\(%code as lua expr), \(%glue as lua expr));"
compile [quote %s] to compile [quote %s] to (Lua value "repr(\(%s as lua expr))")
Lua value ".." compile [type of %obj] to (Lua value "type(\(%obj as lua expr))")
repr(\(%s as lua expr)) compile [parse %text] to (..)
compile [type of %obj] to: Lua value "type(\(%obj as lua expr))" Lua value "nomsu:parse(NomsuCode(\"\(%text.source)\", \(%text as lua expr)))"
compile [parse %text] to compile [parse %text from %filename] to (..)
Lua value ".."
nomsu:parse(NomsuCode("\("\(%text.source)")", \(%text as lua expr)))
compile [parse %text from %filename] to
Lua value ".." Lua value ".."
nomsu:parse(NomsuCode(Source(\(%filename as lua expr), 1, #\(%text as lua expr)), \(%text as lua expr))) nomsu:parse(NomsuCode(Source(\(%filename as lua expr), 1, #\(%text as lua expr)), \(%text as lua expr)))
compile [run %nomsu_code] to compile [run %nomsu_code] to (..)
Lua value "nomsu:run(\(%nomsu_code as lua expr), \(=lua "repr(tostring(\(%nomsu_code.source)))"))" Lua value ".."
nomsu:run(\(%nomsu_code as lua expr), \(=lua "repr(tostring(\(%nomsu_code.source)))"))
action [run tree %tree, %tree as value] action [run tree %tree, %tree as value] (lua> "return nomsu:run(\%tree)")
lua> ".." compile [compile %block, compiled %block, %block compiled] to (..)
return nomsu:run(\%tree)
compile [compile %block, compiled %block, %block compiled] to
Lua value "nomsu:compile(\(%block as lua))" Lua value "nomsu:compile(\(%block as lua))"
# 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"
# Literals # Literals
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")
compile [Nomsu syntax version] to: Lua value "NOMSU_SYNTAX_VERSION" compile [Nomsu syntax version] to (Lua value "NOMSU_SYNTAX_VERSION")
compile [Nomsu compiler version] to: Lua value "NOMSU_COMPILER_VERSION" compile [Nomsu compiler version] to (Lua value "NOMSU_COMPILER_VERSION")
compile [core version] to: Lua value "NOMSU_CORE_VERSION" compile [core version] to (Lua value "NOMSU_CORE_VERSION")
compile [lib version] to: Lua value "NOMSU_LIB_VERSION" compile [lib version] to (Lua value "NOMSU_LIB_VERSION")
compile [command line args] to: Lua value "arg" compile [command line args] to (Lua value "arg")
~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
compile [with local compile actions %body] to
compile [with local compile actions %body] to (..)
Lua ".." Lua ".."
do do
local nomsu = table.fork(nomsu, {COMPILE_ACTIONS=table.fork(nomsu.COMPILE_ACTIONS)}) local nomsu = table.fork(nomsu, {COMPILE_ACTIONS=table.fork(nomsu.COMPILE_ACTIONS)})
\(%body as lua statements) \(%body as lua statements)
end end
action [Nomsu version] action [Nomsu version]:
use "lib/version.nom" use "lib/version.nom"
return "\(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)" return ".."
\(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)

136
core/operators.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V1 #!/usr/bin/env nomsu -V2.2.4.3
# #
This file contains definitions of operators like "+" and "and". This file contains definitions of operators like "+" and "and".
@ -6,14 +6,17 @@ use "core/metaprogramming.nom"
use "core/errors.nom" use "core/errors.nom"
# Comparison Operators # Comparison 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))")
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 [%a is %b, %a = %b, %a == %b] to compile [%a is %b, %a = %b, %a == %b] to (..)
Lua value "(\(%a as lua expr) == \(%b as lua expr))" Lua value "(\(%a as lua expr) == \(%b as lua expr))"
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 value "(\(%a as lua expr) ~= \(%b as lua expr))" Lua value "(\(%a as lua expr) ~= \(%b as lua expr))"
# For strict identity checking, use (%x's id) is (%y's id) # For strict identity checking, use (%x's id) is (%y's id)
lua> ".." lua> ".."
do do
@ -31,12 +34,13 @@ lua> ".."
end end
}) })
end end
compile [%'s id, id of %] to: Lua value "IDS[\(% as lua expr)]"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ compile [% 's id, id of %] to (Lua value "IDS[\(% as lua expr)]")
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Variable assignment operator # Variable assignment operator
compile [%var <- %value] to compile [%var <- %value] to:
lua> "local \%var_lua = \(%var as lua)" lua> "local \%var_lua = \(%var as lua)"
assume %var_lua.is_value or barf "Invalid target for assignment: \%var" assume %var_lua.is_value or barf "Invalid target for assignment: \%var"
lua> ".." lua> ".."
@ -46,7 +50,7 @@ compile [%var <- %value] to
end end
end) end)
local \%value_lua = \(%value as lua) local \%value_lua = \(%value as lua)
assume %value_lua.is_value or barf "Invalid value for assignment: \%value" assume %value_lua.is_value or barf "Invalid value for assignment: \%value"
lua> ".." lua> ".."
local lua = LuaCode(tree.source, \%var_lua, ' = ', \%value_lua, ';') local lua = LuaCode(tree.source, \%var_lua, ' = ', \%value_lua, ';')
@ -55,10 +59,12 @@ compile [%var <- %value] to
end end
return lua return lua
# Simultaneous mutli-assignments like: x,y,z = 1,x,3; # Simultaneous mutli-assignments like: x,y,z = 1,x,3;
compile [<- %assignments, assign %assignments] to compile [<- %assignments, assign %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 Expected a Dict for the assignments part of '<- %' statement, not \%assignments
lua> ".." lua> ".."
local lhs, rhs = LuaCode(tree.source), LuaCode(tree.source) local lhs, rhs = LuaCode(tree.source), LuaCode(tree.source)
for i, item in ipairs(\%assignments) do for i, item in ipairs(\%assignments) do
@ -84,21 +90,23 @@ compile [<- %assignments, assign %assignments] to
end end
return LuaCode(tree.source, lhs, " = ", rhs, ";") return LuaCode(tree.source, lhs, " = ", rhs, ";")
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
compile [external %var <- %value] to compile [external %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" assume %var_lua.is_value or barf "Invalid target for assignment: \%var"
%value_lua <- (%value as lua) %value_lua <- (%value as lua)
assume %value_lua.is_value or barf "Invalid value for assignment: \%value" assume %value_lua.is_value or barf "Invalid value for assignment: \%value"
return: Lua "\%var_lua = \%value_lua;" return (Lua "\%var_lua = \%value_lua;")
compile [with external %externs %body] to compile [with external %externs %body] to:
%body_lua <- (%body as lua statements) %body_lua <- (%body as lua statements)
lua> "\%body_lua:remove_free_vars(table.map(\%externs, function(v) return tostring(nomsu:compile(v)) end))" lua> ".."
\%body_lua:remove_free_vars(table.map(\%externs, function(v) return tostring(nomsu:compile(v)) end))
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 = LuaCode(tree.source), LuaCode(tree.source) local lhs, rhs = LuaCode(tree.source), LuaCode(tree.source)
@ -124,57 +132,79 @@ compile [with %assignments %body] to
end end
end end
\%lua:remove_free_vars(vars) \%lua:remove_free_vars(vars)
\%lua:prepend("local ", lhs, " = ", rhs, ";\n") \%lua:prepend("local ", lhs, " = ", rhs, ";\\n")
return
return (..)
Lua ".." Lua ".."
do do
\%lua \%lua
end -- 'with' block end -- 'with' block
# Math Operators # Math Operators
compile [%x wrapped around %y, %x mod %y] to: Lua value "(\(%x as lua expr) % \(%y as lua expr))" compile [%x wrapped around %y, %x mod %y] to (..)
Lua value "(\(%x as lua expr) % \(%y as lua expr))"
# 3-part chained comparisons # 3-part chained comparisons
# (uses a lambda to avoid re-evaluating middle value, while still being an expression) # (uses a lambda to avoid re-evaluating middle value, while still being an expression)
parse [%x < %y < %z] as: =lua "(function(x,y,z) return x < y and y < z; end)(\%x,\%y,\%z)" parse [%x < %y < %z] as (..)
parse [%x <= %y < %z] as: =lua "(function(x,y,z) return x <= y and y < z; end)(\%x,\%y,\%z)" =lua "(function(x,y,z) return x < y and y < z; end)(\%x,\%y,\%z)"
parse [%x < %y <= %z] as: =lua "(function(x,y,z) return x < y and y <= z; end)(\%x,\%y,\%z)" parse [%x <= %y < %z] as (..)
parse [%x <= %y <= %z] as: =lua "(function(x,y,z) return x <= y and y <= z; end)(\%x,\%y,\%z)" =lua "(function(x,y,z) return x <= y and y < z; end)(\%x,\%y,\%z)"
parse [%x > %y > %z] as: =lua "(function(x,y,z) return x > y and y > z; end)(\%x,\%y,\%z)" parse [%x < %y <= %z] as (..)
parse [%x >= %y > %z] as: =lua "(function(x,y,z) return x >= y and y > z; end)(\%x,\%y,\%z)" =lua "(function(x,y,z) return x < y and y <= z; end)(\%x,\%y,\%z)"
parse [%x > %y >= %z] as: =lua "(function(x,y,z) return x > y and y >= z; end)(\%x,\%y,\%z)" parse [%x <= %y <= %z] as (..)
parse [%x >= %y >= %z] as: =lua "(function(x,y,z) return x >= y and y >= z; end)(\%x,\%y,\%z)" =lua "(function(x,y,z) return x <= y and y <= z; end)(\%x,\%y,\%z)"
# TODO: optimize for common case where x,y,z are all either variables or number literals parse [%x > %y > %z] as (..)
=lua "(function(x,y,z) return x > y and y > z; end)(\%x,\%y,\%z)"
parse [%x >= %y > %z] as (..)
=lua "(function(x,y,z) return x >= y and y > z; end)(\%x,\%y,\%z)"
parse [%x > %y >= %z] as (..)
=lua "(function(x,y,z) return x > y and y >= z; end)(\%x,\%y,\%z)"
parse [%x >= %y >= %z] as (..)
=lua "(function(x,y,z) return x >= y and y >= z; end)(\%x,\%y,\%z)"
# TODO: optimize for common case where x,y,z are all either variables or number literals
# Boolean Operators # Boolean Operators
compile [%x and %y] to: Lua value "(\(%x as lua expr) and \(%y as lua expr))" compile [%x and %y] to (Lua value "(\(%x as lua expr) and \(%y as lua expr))")
compile [%x or %y] to: Lua value "(\(%x as lua expr) or \(%y as lua expr))" compile [%x or %y] to (Lua value "(\(%x as lua expr) or \(%y as lua expr))")
# Bitwise Operators # Bitwise Operators
# TODO: support bit.???() for luajit and bit32.??? for lua 5.2 # TODO: support bit.???() for luajit and bit32.??? for lua 5.2
compile [%a OR %b, %a | %b] to: Lua value "(\(%a as lua expr) | \(%b as lua expr))" compile [%a OR %b, %a | %b] to (..)
compile [%a XOR %b] to: Lua value "(\(%a as lua expr) ^ \(%b as lua expr))" Lua value "(\(%a as lua expr) | \(%b as lua expr))"
compile [%a AND %b, %a & %b] to: Lua value "(\(%a as lua expr) & \(%b as lua expr))"
compile [NOT %, ~ %] to: Lua value "~(\(% as lua expr))" compile [%a XOR %b] to (Lua value "(\(%a as lua expr) ^ \(%b as lua expr))")
compile [%x LSHIFT %shift, %x << %shift] to: Lua value "(\(%x as lua expr) << \(%shift as lua expr))" compile [%a AND %b, %a & %b] to (..)
compile [%x RSHIFT %shift, %x >>> %shift] to: Lua value "(\(%x as lua expr) >>> \(%shift as lua expr))" Lua value "(\(%a as lua expr) & \(%b as lua expr))"
compile [%x ARSHIFT %shift, %x >> %shift] to: Lua value "(\(%x as lua expr) >> \(%shift as lua expr))"
compile [NOT %, ~ %] to (Lua value "~(\(% as lua expr))")
compile [%x LSHIFT %shift, %x << %shift] to (..)
Lua value "(\(%x as lua expr) << \(%shift as lua expr))"
compile [%x RSHIFT %shift, %x >>> %shift] to (..)
Lua value "(\(%x as lua expr) >>> \(%shift as lua expr))"
compile [%x ARSHIFT %shift, %x >> %shift] to (..)
Lua value "(\(%x as lua expr) >> \(%shift as lua expr))"
# TODO: implement OR, XOR, AND for multiple operands? # TODO: implement OR, XOR, AND for multiple operands?
# Unary operators # Unary operators
compile [- %] to: Lua value "(- \(% as lua expr))" compile [- %] to (Lua value "(- \(% as lua expr))")
compile [not %] to: Lua value "(not \(% as lua expr))" compile [not %] to (Lua value "(not \(% as lua expr))")
test: assume: (length of [1,2,3]) = 3 test: assume ((length of [1, 2, 3]) = 3)
compile [length of %list, || %list ||] to: Lua value "(#\(%list as lua expr))" compile [length of %list, || %list ||] to (Lua value "(#\(%list as lua expr))")
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Update operators # Update operators
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 * %))
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 and <- %] as: %var <- (%var and %) parse [%var and<- %] as (%var <- (%var and %))
parse [%var or <- %] as: %var <- (%var or %) parse [%var or<- %] as (%var <- (%var or %))
parse [wrap %var around %] as: %var <- (%var wrapped around %) parse [wrap %var around %] as (%var <- (%var wrapped around %))

33
core/scopes.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V1 #!/usr/bin/env nomsu -V2.2.4.3
# #
This file contains definitions pertaining to variable scoping This file contains definitions pertaining to variable scoping
@ -6,28 +6,21 @@ use "core/metaprogramming.nom"
use "core/operators.nom" use "core/operators.nom"
use "core/collections.nom" use "core/collections.nom"
use "core/control_flow.nom" use "core/control_flow.nom"
compile [with local %locals %body, with local %locals do %body] to:
compile [with local %locals %body, with local %locals do %body] to
%body_lua <- (%body as lua statements) %body_lua <- (%body as lua statements)
when %locals.type = ? when %locals.type = ?:
* "Dict" * "Dict":
%body_lua <- %body_lua <- (Lua "\(compile as (<- %locals))\n\%body_lua")
Lua ".." declare locals ("\(%.1 as lua)" for % in %locals) in %body_lua
\(compile as: <- %locals)
\%body_lua * "List":
declare locals declare locals ("\(% as lua)" for % in %locals) in %body_lua
"\(%.1 as lua)" for % in %locals
.. in %body_lua
* "List"
declare locals
"\(% as lua)" for % in %locals
.. in %body_lua
* "Var" * "Var"
* "Action" * "Action":
declare locals ["\(%locals as lua)"] in %body_lua declare locals ["\(%locals as lua)"] in %body_lua
* else *else (barf "Unexpected local: \(%locals as nomsu)")
barf "Unexpected local: \(%locals as nomsu)"
return return (..)
Lua ".." Lua ".."
do do
\%body_lua \%body_lua

38
core/text.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V1 #!/usr/bin/env nomsu -V2.2.4.3
# #
This file contains some definitions of text escape sequences, including ANSI console This file contains some definitions of text escape sequences, including ANSI console
color codes. color codes.
@ -6,36 +6,39 @@
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
return table.concat(text_bits, \%glue) return table.concat(text_bits, \%glue)
parse [joined %texts, %texts joined] as: %texts joined with ""
compile [capitalized %text, %text capitalized] to parse [joined %texts, %texts joined] as (%texts joined with "")
compile [capitalized %text, %text capitalized] to (..)
Lua value "((\(%text as lua expr)):gsub('%l', string.upper, 1))" Lua value "((\(%text as lua expr)):gsub('%l', string.upper, 1))"
compile [%text with %sub instead of %patt, %text with %patt replaced by %sub, %text s/%patt / %sub] to compile [..]
%text with %sub instead of %patt, %text with %patt replaced by %sub
%text s/ %patt / %sub
..to (..)
Lua value "((\(%text as lua expr)):gsub(\(%patt as lua expr), \(%sub as lua expr)))" Lua value "((\(%text as lua expr)):gsub(\(%patt as lua expr), \(%sub as lua expr)))"
action [lines in %text, lines of %text] action [lines in %text, lines of %text] (..)
lua> ".." lua> ".."
local result = list{} local result = list{}
for line in (\%text):gmatch('[^\n]+') do for line in (\%text):gmatch('[^\\n]+') do
result[#result+1] = line result[#result+1] = line
end end
return result return result
compile [for %match where %text matches %patt %body] to compile [for %match where %text matches %patt %body] to (..)
Lua ".." Lua ".."
for \(%match as lua expr) in \(%text as lua expr):gmatch(\(%patt as lua expr)) do for \(%match as lua expr) in \(%text as lua expr):gmatch(\(%patt as lua expr)) do
\(%body as lua statements) \(%body as lua statements)
\(compile as: === next %match ===) \(compile as (===next %match ===))
end end
\(compile as: === stop %match ===) \(compile as (===stop %match ===))
compile [%expr for %match where %text matches %patt] to compile [%expr for %match where %text matches %patt] to (..)
Lua value ".." Lua value ".."
(function() (function()
local ret = list{} local ret = list{}
@ -45,19 +48,22 @@ compile [%expr for %match where %text matches %patt] to
return ret return ret
end)() end)()
compile [%text matches %pattern] to compile [%text matches %pattern] to (..)
Lua value "(\(%text as lua expr):match(\(%pattern as lua expr)) and true or false)" Lua value "(\(%text as lua expr):match(\(%pattern as lua expr)) and true or false)"
# Text literals # Text literals
lua> ".." lua> ".."
do do
local escapes = { local escapes = {
nl="\\\\n", newline="\\\\n", tab="\\\\t", bell="\\\\a", cr="\\\\r", ["carriage return"]="\\\\r", nl="\\\\n", newline="\\\\n", tab="\\\\t", bell="\\\\a", cr="\\\\r",
backspace="\\\\b", ["form feed"]="\\\\f", formfeed="\\\\f", ["vertical tab"]="\\\\v", ["carriage return"]="\\\\r", backspace="\\\\b", ["form feed"]="\\\\f",
formfeed="\\\\f", ["vertical tab"]="\\\\v",
}; };
for name, e in pairs(escapes) do for name, e in pairs(escapes) do
local lua = "'"..e.."'" local lua = "'"..e.."'"
nomsu.COMPILE_ACTIONS[name] = (function(nomsu, tree) return LuaCode.Value(tree.source, lua) end) nomsu.COMPILE_ACTIONS[name] = function(nomsu, tree)
return LuaCode.Value(tree.source, lua)
end
end end
end end

197
examples/how_do_i.nom
View File

@ -1,13 +1,11 @@
#!/usr/bin/env nomsu -V1 #!/usr/bin/env nomsu -V2.2.4.3
# How do I... # How do I...
# Write a comment? Put a # and go till the end of the line # Write a comment? Put a # and go till the end of the line
# How do I write a multi-line comment? # How do I write a multi-line comment?
After a comment line, any indented text After a comment line, any indented text
is considered part of the comment is considered part of the comment
(including any deeper-level indented text) (including any deeper-level indented text)
The comment ends when the indentation ends The comment ends when the indentation ends
# How do I import a file? # How do I import a file?
use "core/control_flow.nom" use "core/control_flow.nom"
@ -20,6 +18,7 @@ say "Hello world!"
# How do I set a variable? # How do I set a variable?
%foobar <- 1 %foobar <- 1
%text <- "Hello world" %text <- "Hello world"
# Expressions that are more than just literal values require parentheses: # Expressions that are more than just literal values require parentheses:
%foobar <- (2 + 3) %foobar <- (2 + 3)
%one-two <- 12 %one-two <- 12
@ -27,6 +26,7 @@ say %one-two
# How do I modify a variable? # How do I modify a variable?
%foobar <- (%foobar + 1) %foobar <- (%foobar + 1)
# Or, as a shorthand, you can do this to increment a variable: # Or, as a shorthand, you can do this to increment a variable:
%foobar +<- 1 %foobar +<- 1
@ -38,46 +38,50 @@ say %one-two
to the "..". to the "..".
<- E.g. the 2 spaces here will be included as part of the text. <- E.g. the 2 spaces here will be included as part of the text.
But this line will have no leading spaces. But this line will have no leading spaces.
The text will continue until the indentation ends, skipping trailing newlines. The text will continue until the indentation ends, skipping trailing newlines.
# How do I put values inside text? (AKA string formatting, string interpolation) # How do I put values inside text? (AKA string formatting, string interpolation)
say ".." say ".."
Text can contain a backslash followed by a variable, list, dict, or parenthesized Text can contain a backslash followed by a variable, list, dict, or parenthesized
expression. This escaped value will be converted to readable text, like so: expression. This escaped value will be converted to readable text, like so:
The value of %foobar is \%foobar, isn't that nice? The value of %foobar is \%foobar, isn't that nice?
These are some numbers: \[1+1, 2+1, 3+1] These are some numbers: \[1 + 1, 2 + 1, 3 + 1]
The sum of 2 and 4 is \(2 + 4). The sum of 2 and 4 is \(2 + 4).
A backslash not followed by any of these, and not at the end of a line A backslash not followed by any of these, and not at the end of a line
like this: \ will just be treated as a backslash. like this: \\ will just be treated as a backslash.
Or, two backlashes will be treated as a single backslash, no matter what follows, Or, two backlashes will be treated as a single backslash, no matter what follows,
like this: \\%foobar <- won't insert any values like this: \\%foobar <- won't insert any values
If you need to split a long line without inserting a newline, you can \ If you need to split a long line without inserting a newline, you can end a line \
..end a line with backslash and start the next line with two periods, like that. ..with backslash and 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: \(..)
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9
.. between a backslash and two periods. .. between a backslash and two periods.
say "Single-line text can contain escape sequences like \", \\, \n, \065, and \x0A" say "Single-line text can contain escape sequences like \", \\, \n, \065, and \x0A"
# How do I define a list? # How do I define a list?
%my-list <- [1,2,"hello"] %my-list <- [1, 2, "hello"]
# Really long lists can use [..] followed by a bunch of indented values delimited # Really long lists can use [..] followed by a bunch of indented values delimited
by commas and/or newlines by commas and/or newlines
%my-really-long-list <- [..] %my-really-long-list <- [..]
1,2,3,4 1, 2, 3, 4
5,6 5, 6
7 7
8,9,10 8, 9, 10
# How do I use a list? # How do I use a list?
%my-list <- ["first item", "second item", "third item"] %my-list <- ["first item", "second item", "third item"]
# Lists are 1-indexed because they're implemented as Lua tables, so this prints "first item" # Lists are 1-indexed because they're implemented as Lua tables, so this prints "first item"
say %my-list.1 say %my-list.1
# List entries can be modified like this: # List entries can be modified like this:
%my-list.1 <- "ONE!!!" %my-list.1 <- "ONE!!!"
say (length of %my-list) say (length of %my-list)
@ -95,99 +99,105 @@ say %my-dict.x
%my-dict.x <- 9999 %my-dict.x <- 9999
# How do I do conditional branching? # How do I do conditional branching?
if: 1 < 10 if (1 < 10):
say "1 is indeed < 10" say "1 is indeed < 10"
if (1 > 10):
if: 1 > 10
say "this won't print" say "this won't print"
..else ..else:
say "this will print" say "this will print"
# There's no "elseif", so for longer conditionals, a "when" branch is the best option # There's no "elseif", so for longer conditionals, a "when" branch is the best option
when when:
* (3 > 6) * (3 > 6)
* (3 > 5) * (3 > 5)
* (3 > 4) * (3 > 4):
say "this won't print" say "this won't print"
* (3 > 3) * (3 > 3):
say "this won't print" say "this won't print"
* (3 > 2) * (3 > 2):
say "this will print" say "this will print"
* else *else:
say "this is the default case" say "this is the default case"
# How do I do a switch statement? # How do I do a switch statement?
when 3 = ? when 3 = ?:
* 0 * 0
* 1 * 1
* 2 * 2:
say "this won't print" say "this won't print"
* 3 * 3:
say "this will print" say "this will print"
* else *else:
say "this won't print" say "this won't print"
# How do I loop over a list (a foreach loop)? # How do I loop over a list (a foreach loop)?
%list <- [1,2,3] %list <- [1, 2, 3]
for %x in %list for %x in %list:
say "For %x loop #\%x" say "For %x loop #\%x"
# How do I loop over a number range? # How do I loop over a number range?
# This is inclusive, so it will loop over 1,2, and 3 # This is inclusive, so it will loop over 1,2, and 3
for %i in 1 to 3 for %i in 1 to 3:
say "For %i in 1 to 3 loop #\%i" say "For %i in 1 to 3 loop #\%i"
# This will print 0,2, and 4 # This will print 0,2, and 4
for %even in 0 to 5 by 2 for %even in 0 to 5 by 2:
say "Even #\%even" say "Even #\%even"
for %backwards in 3 to 1 by -1 for %backwards in 3 to 1 by -1:
say "Backwards #\%backwards" say "Backwards #\%backwards"
# How do I do a 'while' loop? # How do I do a 'while' loop?
%x <- 1 %x <- 1
repeat while: %x <= 3 repeat while (%x <= 3):
say "repeat while loop #\%x" say "repeat while loop #\%x"
%x +<- 1 %x +<- 1
%x <- 1 %x <- 1
repeat until: %x > 3 repeat until (%x > 3):
say "repeat until loop #\%x" say "repeat until loop #\%x"
%x +<- 1 %x +<- 1
# How do I do an infinite loop? # How do I do an infinite loop?
%x <- 1 %x <- 1
repeat repeat:
say "repeat loop #\%x" say "repeat loop #\%x"
%x +<- 1 %x +<- 1
if: %x > 3 if (%x > 3):
stop repeating stop repeating
# How do I do a 'goto'? # How do I do a 'goto'?
do do:
%x <- 1 %x <- 1
=== %again === === %again ===
say "GOTO loop #\%x" say "GOTO loop #\%x"
%x +<- 1 %x +<- 1
if: %x <= 3 if (%x <= 3):
go to %again go to %again
say "finished going to" say "finished going to"
# How do I define a function/method/procedure? # How do I define a function/method/procedure?
# In nomsu, they're called "action"s, and they can be declared like this: # In nomsu, they're called "action"s, and they can be declared like this:
action [say both %first and also %second] action [say both %first and also %second]:
say %first say %first
# Function arguments are accessed just like variables # Function arguments are accessed just like variables
say %second say %second
# Actions can use "return" to return a value early # Actions can use "return" to return a value early
action [first fibonacci above %n] action [first fibonacci above %n]:
%f1 <- 0 %f1 <- 0
%f2 <- 1 %f2 <- 1
repeat repeat:
%tmp <- (%f1 + %f2) %tmp <- (%f1 + %f2)
%f1 <- %f2 %f1 <- %f2
%f2 <- %tmp %f2 <- %tmp
if: %f2 > %n if (%f2 > %n):
return %f2 return %f2
say (first fibonacci above 10) say (first fibonacci above 10)
@ -197,19 +207,18 @@ action [..]
I hate %worse-things more than %better-things I hate %worse-things more than %better-things
I think %worse-things are worse than %better-things I think %worse-things are worse than %better-things
I like %better-things more than %worse-things I like %better-things more than %worse-things
.. ..:
say "\(%better-things capitalized) rule and \%worse-things drool!" say "\(%better-things capitalized) rule and \%worse-things drool!"
I like "dogs" more than "cats" I like "dogs" more than "cats"
I think "chihuahuas" are worse than "corgis" I think "chihuahuas" are worse than "corgis"
# Actions can have parts of the action's name spread throughout. # Actions can have parts of the action's name spread throughout.
Everything that's not a literal value is treated as part of the action's name Everything that's not a literal value is treated as part of the action's name
say both "Hello" and also "again!" say both "Hello" and also "again!"
# Actions can even start with a parameter # Actions can even start with a parameter
action [%what-she-said is what she said] action [%what-she-said is what she said]:
say %what-she-said say %what-she-said
say "-- she said" say "-- she said"
@ -217,122 +226,123 @@ action [%what-she-said is what she said]
# The language only reserves []{}().,:;% as special characters, so actions # The language only reserves []{}().,:;% as special characters, so actions
can have really funky names! can have really funky names!
action [>> %foo-bar $$$^ --> % @& _~-^-~_~-^ %1 !] action [>> %foo-bar $$$^ --> % @&_~-^-~_~-^ %1 !]:
say %foo-bar say %foo-bar
say % say %
say %1 say %1
>> "wow" $$$^ --> "so flexible!" @& _~-^-~_~-^ "even numbers can be variables!" ! >> "wow" $$$^ --> "so flexible!" @&_~-^-~_~-^ "even numbers can be variables!" !
# There's also full unicode support # There's also full unicode support
%こんにちは <- "こんにちは" %こんにちは <- "こんにちは"
action [% と言う] action [% と言う] "\%世界"
"\(%)世界"
say (%こんにちは と言う) say (%こんにちは と言う)
# Math and logic operations are just treated the same as actions in the syntax # Math and logic operations are just treated the same as actions in the syntax
say (2 + 3) say (2 + 3)
# So you can define your own operators, although they will need to be parenthesized to # So you can define your own operators, although they will need to be parenthesized to
play nicely with other operators play nicely with other operators
action [%a ++ %b] action [%a ++ %b] (2 * (%a + %b))
2 * (%a + %b)
say (1 ++ (2 * 3)) say (1 ++ (2 * 3))
# How do I do grouping? # How do I do grouping?
# Expressions can be grouped by enclosing parentheses: # Expressions can be grouped by enclosing parentheses:
say (2 + 3) say (2 + 3)
# Or by an indented region
say # Or by (..) followed by an indented region
say (..)
2 + 3 2 + 3
# Or by ":" until the end of the line
say: 2 + 3
# If you need to keep going after an indented region, you can start the next line with ".." # If you need to keep going after an indented region, you can start the next line with ".."
say both say both "Very long first argument that needs its own line"
"Very long first argument that needs its own line"
..and also "short second arg" ..and also "short second arg"
action [my favorite number]: 21 + 2 action [my favorite number] (21 + 2)
# This can be nested: # This can be nested:
say both say both (..)
my favorite my favorite
..number ..number
..and also "foo" ..and also "foo"
# Macros: # Macros:
# The "lua> %" and "=lua %" macros can be used to write raw lua code: # The "lua> %" and "=lua %" macros can be used to write raw lua code:
action [say the time] action [say the time] (..)
lua> ".." lua> ".."
io.write("The OS time is: "..os.time().."\n"); io.write("The OS time is: ", os.time(), "\\n");
say the time say the time
say "Math expression result is: \(=lua "(1 + 2*3 + 3*4)^2")" say "Math expression result is: \(=lua "(1 + 2*3 + 3*4)^2")"
# Variables can be accessed via \%varname # Variables can be accessed via \%varname
action [square root of %n] action [square root of %n] (=lua "math.sqrt(\%n)")
=lua "math.sqrt(\%n)"
say "The square root of 2 is \(square root of 2)" say "The square root of 2 is \(square root of 2)"
# Macros can be defined to transform one bit of nomsu code into another using "parse % as %": # Macros can be defined to transform one bit of nomsu code into another using "parse % as %":
parse [if %condition is untrue %body] as parse [if %condition is untrue %body] as (..)
if (not %condition) %body if (not %condition) %body
# Or to transform nomsu code into custom lua code using "compile % to %" # Or to transform nomsu code into custom lua code using "compile % to %"
compile [if %condition on opposite day %body] to compile [if %condition on opposite day %body] to (..)
Lua ".." Lua ".."
if not \(%condition as lua expr) then if not \(%condition as lua expr) then
\(%body as lua statements) \(%body as lua statements)
end end
# Constants can be defined as macros # Constants can be defined as macros
parse [TWENTY] as: 20 parse [TWENTY] as 20
# When they're invoked, they'll need parentheses just like a function call # When they're invoked, they'll need parentheses just like a function call
parse [TWENTY ONE] as: 21 parse [TWENTY ONE] as 21
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# If you need to use compile-time actions in the same file that they're defined in, you # If you need to use compile-time actions in the same file that they're defined in, you
can add a line of tildes (3 or more), and the file will be split into chunks, and each can add a line of tildes (3 or more), and the file will be split into chunks, and each
chunk will run before the next one compiles. (note that each chunk has its own scope) chunk will run before the next one compiles. (note that each chunk has its own scope)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ if (1 > (TWENTY)) is untrue:
if (1 > (TWENTY)) is untrue
say "Nomsu parsing macros work!" say "Nomsu parsing macros work!"
say "It looks like a keyword, but there's no magic here!" say "It looks like a keyword, but there's no magic here!"
if (1 > (TWENTY)) on opposite day if (1 > (TWENTY)) on opposite day:
say "Lua compiling macros work!" say "Lua compiling macros work!"
say "It looks like a keyword, but there's no magic here!" say "It looks like a keyword, but there's no magic here!"
# How do I use an action as a value? # How do I use an action as a value?
# Well... it's always *possible* to fall back to Lua behavior for something like this: # Well... it's always *possible* to fall back to Lua behavior for something like this:
action [best of %items according to %key-fn] action [best of %items according to %key-fn]:
<- {%best:nil, %best-key:nil} <- {%best: nil, %best-key: nil}
for %item in %items for %item in %items:
%key <- (=lua "\%key-fn(\%item)") %key <- (=lua "\%key-fn(\%item)")
if: (%best is (nil)) or (%key > %best-key) if ((%best is (nil)) or (%key > %best-key)):
<- {%best:%item, %best-key:%key} <- {%best: %item, %best-key: %key}
return %best return %best
say: best of [2,-3,4,-8] according to ([%x] -> (%x * %x)) say (best of [2, -3, 4, -8] according to ([%x] -> (%x * %x)))
# But nomsu was mostly designed so that you don't *need* to. Instead of creating a # But nomsu was mostly designed so that you don't *need* to. Instead of creating a
one-off function to pass to another function and get called a bunch of times, you one-off function to pass to another function and get called a bunch of times, you
could use a macro to generate a single block of code that inlines the expression you could use a macro to generate a single block of code that inlines the expression you
want to use: want to use:
parse [best of %items where %item-var has score %key-expr] as parse [best of %items where %item-var has score %key-expr] as (..)
result of result of:
<- {%best:nil, %best-key:nil} <- {%best: nil, %best-key: nil}
for %item-var in %items for %item-var in %items:
%key <- %key-expr %key <- %key-expr
if: (%best is (nil)) or (%key > %best-key) if ((%best is (nil)) or (%key > %best-key)):
<- {%best:%item-var, %best-key:%key} <- {%best: %item-var, %best-key: %key}
return %best return %best
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
say: best of [2,-3,4,-8] where %x has score (%x * %x)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
say (best of [2, -3, 4, -8] where %x has score (%x * %x))
# The first example generates code that looks like: # The first example generates code that looks like:
A_best_of_1_according_to_2 = function(items, key_fn) A_best_of_1_according_to_2 = function(items, key_fn)
local best, best_key = nil, nil local best, best_key = nil, nil
for _, item in ipairs(items) do for _, item in ipairs(items) do
@ -346,9 +356,9 @@ say: best of [2,-3,4,-8] where %x has score (%x * %x)
print(A_best_of_1_according_to_2({2,-3,4,-8}, function(x) print(A_best_of_1_according_to_2({2,-3,4,-8}, function(x)
return x * x return x * x
end)) end))
But the second example produces something more like: But the second example produces something more like:
print((function() print((function()
local best, best_key = nil, nil local best, best_key = nil, nil
for _, x in ipairs({1,-2,3,-4}) do for _, x in ipairs({1,-2,3,-4}) do
@ -364,4 +374,3 @@ say: best of [2,-3,4,-8] where %x has score (%x * %x)
the code only has to do a multiplication, instead of calling a function that does the the code only has to do a multiplication, instead of calling a function that does the
multiplication. In addition to being more efficient, it's also more powerful and multiplication. In addition to being more efficient, it's also more powerful and
flexible for the language to allow you to define syntax that manipulates expressions. flexible for the language to allow you to define syntax that manipulates expressions.

2
lib/os.nom
View File

@ -37,7 +37,7 @@ compile [%expr for file %f in %path] to
return ret return ret
end)() end)()
action [write to file %filename %text, to file %filename write %text] action [write to file %filename %text, to file %filename write %text, write %text to file %filename]
lua> ".." lua> ".."
local file = io.open(\%filename, 'w') local file = io.open(\%filename, 'w')
file:write(\%text) file:write(\%text)

11
nomsu_compiler.lua
View File

@ -508,9 +508,14 @@ do
NomsuCompiler.compile = function(self, tree) NomsuCompiler.compile = function(self, tree)
if tree.version then if tree.version then
do do
local upgrade = self['A' .. string.as_lua_id("upgrade 1 from 2")] local get_version = self['A' .. string.as_lua_id("Nomsu version")]
if upgrade then if get_version then
tree = upgrade(tree, tree.version) do
local upgrade = self['A' .. string.as_lua_id("1 upgraded from 2 to 3")]
if upgrade then
tree = upgrade(tree, tree.version, get_version())
end
end
end end
end end
end end

5
nomsu_compiler.moon
View File

@ -328,8 +328,9 @@ with NomsuCompiler
.compile = (tree)=> .compile = (tree)=>
if tree.version if tree.version
if upgrade = @['A'..string.as_lua_id("upgrade 1 from 2")] if get_version = @['A'..string.as_lua_id("Nomsu version")]
tree = upgrade(tree, tree.version) if upgrade = @['A'..string.as_lua_id("1 upgraded from 2 to 3")]
tree = upgrade(tree, tree.version, get_version!)
switch tree.type switch tree.type
when "Action" when "Action"
stub = tree.stub stub = tree.stub

15
tools/upgrade.nom
View File

@ -1,10 +1,21 @@
#!/usr/bin/env Nomsu -V 2.2.4.3
use "core" use "core"
use "compatibility" use "compatibility"
use "lib/os.nom" use "lib/os.nom"
for %path in (=lua "arg"): %args <- (command line args)
%inplace <- (no)
if (%args.1 is "-i"):
%inplace <- (yes)
remove index 1 from %args
for %path in %args:
if (%path is "-i"): %inplace <- (yes)
for file %filename in %path: for file %filename in %path:
%tree <- (parse (read file %filename) from %filename) %tree <- (parse (read file %filename) from %filename)
%tree <- (%tree upgraded from %tree.version to (Nomsu version)) %tree <- (%tree upgraded from %tree.version to (Nomsu version))
say "#!/usr/bin/env nomsu -V\(Nomsu version)\n\(%tree as nomsu)" %text <- "#!/usr/bin/env nomsu -V\(Nomsu version)\n\(%tree as nomsu)"
if %inplace:
write %text to file %filename
..else:
say %text