Added "%'s id" to use UUIDs and changed "% = %" to "set % = %" and some
other misc.
This commit is contained in:
Bruce Hill
parent
bfe66a70e6
commit
9d8c701441
@ -48,7 +48,7 @@ compile [length of %list, size of %list, size %list, number of %list, len %list]
|
||||
compile [%list ->* %indices] to:
|
||||
assert ((%indices's "type") == "List") ".."
|
||||
Expected List for chained lookup, not \(%indices's "type")
|
||||
%ret = "\(%list as lua)"
|
||||
set %ret = "\(%list as lua)"
|
||||
for %index in (%indices's "value"):
|
||||
%ret join= "[\(%index as lua)]"
|
||||
return "\%ret"
|
||||
@ -72,33 +72,23 @@ compile [remove index %index from %list] to:
|
||||
|
||||
|
||||
action [flatten %lists]:
|
||||
%flat = []
|
||||
set %flat = []
|
||||
for %list in %lists:
|
||||
for %item in %list:
|
||||
add %item to %flat
|
||||
return %flat
|
||||
|
||||
action [dict %items]:
|
||||
%dict = []
|
||||
for %pair in %items:
|
||||
%dict -> (%pair -> 1) = (%pair -> 2)
|
||||
return %dict
|
||||
{(%->1)=(%->2) for all %items}
|
||||
|
||||
action [entries in %dict]:
|
||||
%entries = []
|
||||
for %k = %v in %dict:
|
||||
add {key=%k, value=%v} to %entries
|
||||
return %entries
|
||||
[{key=%k, value=%v} for %k=%v in %dict]
|
||||
|
||||
action [keys in %dict]:
|
||||
%keys = []
|
||||
for %k = %v in %dict: add %k to %keys
|
||||
return %keys
|
||||
[%k for %k=%v in %dict]
|
||||
|
||||
action [values in %dict]:
|
||||
%values = []
|
||||
for %k = %v in %dict: add %v to %values
|
||||
return %values
|
||||
[%v for %k=%v in %dict]
|
||||
|
||||
# List Comprehension
|
||||
compile [%expression for %item in %iterable] to:
|
||||
|
||||
@ -55,9 +55,9 @@ immediately:
|
||||
compile [do next repeat-loop] to code: "goto continue_repeat;"
|
||||
compile [stop repeat-loop] to code: "goto stop_repeat;"
|
||||
compile [repeat while %condition %body] to code:
|
||||
%continue_labels = (..)
|
||||
set %continue_labels = (..)
|
||||
"\n::continue_repeat::;" if (tree %body has function call \(do next repeat-loop)) else ""
|
||||
%code = ".."
|
||||
set %code = ".."
|
||||
while \(%condition as lua) do
|
||||
\(%body as lua statements)\
|
||||
..\%continue_labels
|
||||
@ -92,19 +92,19 @@ immediately:
|
||||
for %var from %start to %stop via %step %body
|
||||
..to code:
|
||||
lua> "local \%continue_labels, \%code, \%stop_labels"
|
||||
%continue_labels = ""
|
||||
set %continue_labels = ""
|
||||
if (tree %body has function call \(do next for-loop)):
|
||||
%continue_labels join= "\n::continue_for::;"
|
||||
if (tree %body has function call (tree \(do next %) with {""=%var})):
|
||||
%continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;"
|
||||
# This trashes the loop variables, just like in Python.
|
||||
%code = ".."
|
||||
set %code = ".."
|
||||
for i=\(%start as lua),\(%stop as lua),\(%step as lua) do
|
||||
\(%var as lua) = i;
|
||||
\(%body as lua statements)\
|
||||
..\%continue_labels
|
||||
end --numeric for-loop
|
||||
%stop_labels = ""
|
||||
set %stop_labels = ""
|
||||
if (tree %body has function call \(stop for-loop)):
|
||||
%stop_labels join= "\n::stop_for::;"
|
||||
if (tree %body has function call (tree \(stop %) with {""=%var})):
|
||||
@ -128,25 +128,25 @@ immediately:
|
||||
immediately:
|
||||
compile [for %var in %iterable %body] to code:
|
||||
lua> "local \%continue_labels, \%stop_labels, \%code, \%stop_labels"
|
||||
%continue_labels = ""
|
||||
set %continue_labels = ""
|
||||
if (tree %body has function call \(do next for-loop)):
|
||||
%continue_labels join= "\n::continue_for::;"
|
||||
if (tree %body has function call (tree \(do next %) with {""=%var})):
|
||||
%continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;"
|
||||
# This trashes the loop variables, just like in Python.
|
||||
%code = ".."
|
||||
set %code = ".."
|
||||
for i,value in ipairs(\(%iterable as lua)) do
|
||||
\(%var as lua) = value;
|
||||
\(%body as lua statements)\
|
||||
..\%continue_labels
|
||||
end --foreach-loop
|
||||
%stop_labels = ""
|
||||
set %stop_labels = ""
|
||||
if (tree %body has function call \(stop for-loop)):
|
||||
%stop_labels join= "\n::stop_for::;"
|
||||
if (tree %body has function call (tree \(stop %) with {""=%var})):
|
||||
%stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%var])::;"
|
||||
if %stop_labels != "":
|
||||
%code = ".."
|
||||
set %code = ".."
|
||||
do --for-loop label scope
|
||||
\%code\%stop_labels
|
||||
end --for-loop label scope
|
||||
@ -156,7 +156,7 @@ immediately:
|
||||
# Dict iteration (lua's "pairs()")
|
||||
immediately:
|
||||
compile [for %key = %value in %iterable %body] to code:
|
||||
%continue_labels = ""
|
||||
set %continue_labels = ""
|
||||
if (tree %body has function call \(do next for-loop)):
|
||||
%continue_labels join= "\n::continue_for::;"
|
||||
if (tree %body has function call (tree \(do next %x) with {x=%key})):
|
||||
@ -164,13 +164,13 @@ immediately:
|
||||
if (tree %body has function call (tree \(do next %) with {""=%value})):
|
||||
%continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%value])::;"
|
||||
# This trashes the loop variables, just like in Python.
|
||||
%code = ".."
|
||||
set %code = ".."
|
||||
for key,value in ipairs(\(%iterable as lua)) do
|
||||
\(%key as lua), \(%value as lua) = key, value;
|
||||
\(%body as lua statements)\
|
||||
..\%continue_labels
|
||||
end --foreach-loop
|
||||
%stop_labels = ""
|
||||
set %stop_labels = ""
|
||||
if (tree %body has function call \(stop for-loop)):
|
||||
%stop_labels join= "\n::stop_for::;"
|
||||
if (tree %body has function call (tree \(stop %) with {""=%key})):
|
||||
@ -189,23 +189,23 @@ immediately:
|
||||
immediately:
|
||||
compile [when %body] to code:
|
||||
lua> "local \%result, \%fallthroughs, \%first"
|
||||
%result = ""
|
||||
%fallthroughs = []
|
||||
%first = (yes)
|
||||
set %result = ""
|
||||
set %fallthroughs = []
|
||||
set %first = (yes)
|
||||
for %func_call in (%body's "value"):
|
||||
lua> "local \%tokens, \%star, \%condition, \%action"
|
||||
assert ((%func_call's "type") == "FunctionCall") ".."
|
||||
Invalid format for 'when' statement. Only '*' blocks are allowed.
|
||||
%tokens = (%func_call's "value")
|
||||
%star = (%tokens -> 1)
|
||||
set %tokens = (%func_call's "value")
|
||||
set %star = (%tokens -> 1)
|
||||
assert (=lua "\%star and \%star.type == 'Word' and \%star.value == '*'") ".."
|
||||
Invalid format for 'when' statement. Lines must begin with '*'
|
||||
|
||||
%condition = (%tokens -> 2)
|
||||
set %condition = (%tokens -> 2)
|
||||
assert %condition ".."
|
||||
Invalid format for 'when' statement. Lines must begin with '*' and have a condition or the word "else"
|
||||
|
||||
%action = (%tokens -> 3)
|
||||
set %action = (%tokens -> 3)
|
||||
if (%action == (nil)):
|
||||
lua do> "table.insert(\%fallthroughs, \%condition)"
|
||||
do next %func_call
|
||||
@ -217,7 +217,7 @@ immediately:
|
||||
\(%action as lua statements)
|
||||
stop for-loop
|
||||
..else:
|
||||
%condition = (%condition as lua)
|
||||
set %condition = (%condition as lua)
|
||||
for all %fallthroughs:
|
||||
%condition join= " or \(% as lua)"
|
||||
%result join= ".."
|
||||
@ -225,8 +225,8 @@ immediately:
|
||||
\("if" if %first else "elseif") \%condition then
|
||||
\(%action as lua statements)
|
||||
|
||||
%fallthroughs = []
|
||||
%first = (no)
|
||||
set %fallthroughs = []
|
||||
set %first = (no)
|
||||
|
||||
if (%result != ""):
|
||||
%result join= "\nend"
|
||||
@ -235,22 +235,22 @@ immediately:
|
||||
# Switch statement
|
||||
immediately:
|
||||
compile [when %branch_value == ? %body] to code:
|
||||
%result = ""
|
||||
%fallthroughs = []
|
||||
%first = (yes)
|
||||
set %result = ""
|
||||
set %fallthroughs = []
|
||||
set %first = (yes)
|
||||
for %func_call in (%body's "value"):
|
||||
assert ((%func_call's "type") == "FunctionCall") ".."
|
||||
Invalid format for 'when' statement. Only '*' blocks are allowed.
|
||||
%tokens = (%func_call's "value")
|
||||
%star = (%tokens -> 1)
|
||||
set %tokens = (%func_call's "value")
|
||||
set %star = (%tokens -> 1)
|
||||
assert (=lua "\%star and \%star.type == 'Word' and \%star.value == '*'") ".."
|
||||
Invalid format for 'when' statement. Lines must begin with '*'
|
||||
|
||||
%condition = (%tokens -> 2)
|
||||
set %condition = (%tokens -> 2)
|
||||
assert %condition ".."
|
||||
Invalid format for 'when' statement. Lines must begin with '*' and have a condition or the word "else"
|
||||
|
||||
%action = (%tokens -> 3)
|
||||
set %action = (%tokens -> 3)
|
||||
if (%action == (nil)):
|
||||
lua> "table.insert(\%fallthroughs, \%condition)"
|
||||
do next %func_call
|
||||
@ -262,7 +262,7 @@ immediately:
|
||||
\(%action as lua statements)
|
||||
stop for-loop
|
||||
..else:
|
||||
%condition = "branch_value == (\(%condition as lua))"
|
||||
set %condition = "branch_value == (\(%condition as lua))"
|
||||
for all %fallthroughs:
|
||||
%condition join= " or (branch_value == \(% as lua))"
|
||||
%result join= ".."
|
||||
@ -270,11 +270,11 @@ immediately:
|
||||
\("if" if %first else "elseif") \%condition then
|
||||
\(%action as lua statements)
|
||||
|
||||
%fallthroughs = []
|
||||
%first = (no)
|
||||
set %fallthroughs = []
|
||||
set %first = (no)
|
||||
|
||||
if (%result != ""):
|
||||
%result = ".."
|
||||
set %result = ".."
|
||||
do --when == ?
|
||||
local branch_value = \(%branch_value as lua);\
|
||||
..\%result
|
||||
|
||||
@ -57,7 +57,7 @@ compile [%str |%start|] to: "\(%str as lua):sub(\(%start as lua), \(%start as lu
|
||||
compile [%str |%start - %stop|] to: "\(%str as lua):sub(\(%start as lua), \(%stop as lua))"
|
||||
|
||||
# Variable assignment operator, and += type versions
|
||||
compile [%var = %val] to code:
|
||||
compile [set %var = %val] to code:
|
||||
lua> ".."
|
||||
if \%var.type == 'List' and \%val.type == 'List' then
|
||||
local lhs = {};
|
||||
@ -92,11 +92,26 @@ compile [%x > %y] to: "(\(%x as lua) > \(%y as lua))"
|
||||
compile [%x <= %y] to: "(\(%x as lua) <= \(%y as lua))"
|
||||
compile [%x >= %y] to: "(\(%x as lua) >= \(%y as lua))"
|
||||
# == and != do equivalence checking, rather than identity checking
|
||||
compile [%a == %b] to: "nomsu.utils.equivalent(\(%a as lua), \(%b as lua))"
|
||||
compile [%a != %b] to: "(not nomsu.utils.equivalent(\(%a as lua), \(%b as lua)))"
|
||||
# For strict identity checking:
|
||||
compile [%x === %y] to: "(\(%x as lua) == \(%y as lua))"
|
||||
compile [%x !== %y] to: "(\(%x as lua) ~= \(%y as lua))"
|
||||
compile [%a is %b, %a = %b, %a == %b] to:
|
||||
lua> ".."
|
||||
local safe = {Text=true, Number=true};
|
||||
local a_lua, b_lua = nomsu:tree_to_lua(\%a).expr, nomsu:tree_to_lua(\%b).expr;
|
||||
if safe[\%a.type] or safe[\%b.type] then
|
||||
return "("..a_lua.." == "..b_lua..")";
|
||||
else
|
||||
return "nomsu.utils.equivalent("..a_lua..", "..b_lua..")";
|
||||
end
|
||||
compile [%a isn't %b, %a is not %b, %a != %b] to:
|
||||
lua> ".."
|
||||
local safe = {Text=true, Number=true};
|
||||
local a_lua, b_lua = nomsu:tree_to_lua(\%a).expr, nomsu:tree_to_lua(\%b).expr;
|
||||
if safe[\%a.type] or safe[\%b.type] then
|
||||
return "("..a_lua.." ~= "..b_lua..")";
|
||||
else
|
||||
return "(not nomsu.utils.equivalent("..a_lua..", "..b_lua.."))";
|
||||
end
|
||||
# For strict identity checking, use (%x's id) is (%y's id)
|
||||
compile [%'s id, id of %] to: "nomsu.ids[\(% as lua)]"
|
||||
|
||||
# 3-part chained comparisons
|
||||
# (uses a lambda to avoid re-evaluating middle value, while still being an expression)
|
||||
|
||||
@ -15,16 +15,16 @@ compile [do %action] to code:
|
||||
|
||||
# With statement
|
||||
compile [with %assignments %action] to code:
|
||||
%data = []
|
||||
set %data = []
|
||||
for %i = %assignment in (%assignments' "value"):
|
||||
%tokens = (%assignment's "value")
|
||||
%var = (%tokens -> 1)
|
||||
%eq = (%tokens -> 2)
|
||||
set %tokens = (%assignment's "value")
|
||||
set %var = (%tokens -> 1)
|
||||
set %eq = (%tokens -> 2)
|
||||
assert (=lua "\%eq and \%eq.type == 'Word' and \%eq.value == '='") ".."
|
||||
Invalid format for 'with' statement. List entries must have the form %var = (value)
|
||||
%value = (%tokens -> 3)
|
||||
set %value = (%tokens -> 3)
|
||||
add {i=%i, var=%var, value=%value} to %data
|
||||
%setup = (..)
|
||||
set %setup = (..)
|
||||
join (..)
|
||||
"local old_value\(%->"i") = \((%->"var") as lua); \((%->"var") as lua) = \((%->"value") as lua);"
|
||||
..for all %data
|
||||
|
||||
36
nomsu.lua
36
nomsu.lua
@ -1,6 +1,7 @@
|
||||
local re = require('re')
|
||||
local lpeg = require('lpeg')
|
||||
local utils = require('utils')
|
||||
local new_uuid = require('uuid')
|
||||
local repr, stringify, min, max, equivalent, set, is_list, sum
|
||||
repr, stringify, min, max, equivalent, set, is_list, sum = utils.repr, utils.stringify, utils.min, utils.max, utils.equivalent, utils.set, utils.is_list, utils.sum
|
||||
local colors = setmetatable({ }, {
|
||||
@ -427,7 +428,7 @@ do
|
||||
local tree = self:parse(src, filename)
|
||||
self:assert(tree, "Failed to parse: " .. tostring(src))
|
||||
self:assert(tree.type == "File", "Attempt to run non-file: " .. tostring(tree.type))
|
||||
local lua = self:tree_to_lua(tree, filename)
|
||||
local lua = self:tree_to_lua(tree)
|
||||
local lua_code = lua.statements or (lua.expr .. ";")
|
||||
lua_code = "-- File: " .. tostring(filename) .. "\n" .. lua_code
|
||||
local ret = self:run_lua(lua_code)
|
||||
@ -492,7 +493,7 @@ end]]):format(lua_code))
|
||||
return ret
|
||||
end,
|
||||
tree_to_value = function(self, tree, filename)
|
||||
local code = "return (function(nomsu)\nreturn " .. tostring(self:tree_to_lua(tree, filename).expr) .. ";\nend);"
|
||||
local code = "return (function(nomsu)\nreturn " .. tostring(self:tree_to_lua(tree).expr) .. ";\nend);"
|
||||
code = "-- Tree to value: " .. tostring(filename) .. "\n" .. code
|
||||
if self.debug then
|
||||
self:writeln(tostring(colored.bright("RUNNING LUA TO GET VALUE:")) .. "\n" .. tostring(colored.blue(colored.bright(code))))
|
||||
@ -695,7 +696,7 @@ end]]):format(lua_code))
|
||||
return error("Unsupported value_to_nomsu type: " .. tostring(type(value)))
|
||||
end
|
||||
end,
|
||||
tree_to_lua = function(self, tree, filename)
|
||||
tree_to_lua = function(self, tree)
|
||||
self:assert(tree, "No tree provided.")
|
||||
if not tree.type then
|
||||
self:error("Invalid tree: " .. tostring(repr(tree)))
|
||||
@ -703,13 +704,13 @@ end]]):format(lua_code))
|
||||
local _exp_0 = tree.type
|
||||
if "File" == _exp_0 then
|
||||
if #tree.value == 1 then
|
||||
return self:tree_to_lua(tree.value[1], filename)
|
||||
return self:tree_to_lua(tree.value[1])
|
||||
end
|
||||
local lua_bits = { }
|
||||
local _list_0 = tree.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local line = _list_0[_index_0]
|
||||
local lua = self:tree_to_lua(line, filename)
|
||||
local lua = self:tree_to_lua(line)
|
||||
if not lua then
|
||||
self:error("No lua produced by " .. tostring(repr(line)))
|
||||
end
|
||||
@ -732,7 +733,7 @@ end]]):format(lua_code))
|
||||
local _list_0 = tree.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local arg = _list_0[_index_0]
|
||||
local lua = self:tree_to_lua(arg, filename)
|
||||
local lua = self:tree_to_lua(arg)
|
||||
if #tree.value == 1 and lua.expr and not lua.statements then
|
||||
return {
|
||||
expr = lua.expr
|
||||
@ -781,7 +782,7 @@ end]]):format(lua_code))
|
||||
if tok.type == "Word" then
|
||||
insert(bits, tok.value)
|
||||
else
|
||||
local lua = self:tree_to_lua(tok, filename)
|
||||
local lua = self:tree_to_lua(tok)
|
||||
self:assert(lua.statements == nil, "non-expression value inside math expression")
|
||||
insert(bits, lua.expr)
|
||||
end
|
||||
@ -802,7 +803,7 @@ end]]):format(lua_code))
|
||||
_continue_0 = true
|
||||
break
|
||||
end
|
||||
local lua = self:tree_to_lua(tok, filename)
|
||||
local lua = self:tree_to_lua(tok)
|
||||
self:assert(lua.expr, "Cannot use " .. tostring(tok.src) .. " as an argument, since it's not an expression.")
|
||||
insert(args, lua.expr)
|
||||
_continue_0 = true
|
||||
@ -848,7 +849,7 @@ end]]):format(lua_code))
|
||||
insert(concat_parts, repr(string_buffer))
|
||||
string_buffer = ""
|
||||
end
|
||||
local lua = self:tree_to_lua(bit, filename)
|
||||
local lua = self:tree_to_lua(bit)
|
||||
if self.debug then
|
||||
self:writeln((colored.bright("INTERP:")))
|
||||
self:print_tree(bit)
|
||||
@ -885,7 +886,7 @@ end]]):format(lua_code))
|
||||
local _list_0 = tree.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local item = _list_0[_index_0]
|
||||
local lua = self:tree_to_lua(item, filename)
|
||||
local lua = self:tree_to_lua(item)
|
||||
if lua.statements then
|
||||
self:error("Cannot use [[" .. tostring(item.src) .. "]] as a list item, since it's not an expression.")
|
||||
end
|
||||
@ -905,12 +906,12 @@ end]]):format(lua_code))
|
||||
expr = repr(entry.dict_key.value)
|
||||
}
|
||||
else
|
||||
key_lua = self:tree_to_lua(entry.dict_key, filename)
|
||||
key_lua = self:tree_to_lua(entry.dict_key)
|
||||
end
|
||||
if key_lua.statements then
|
||||
self:error("Cannot use [[" .. tostring(entry.dict_key.src) .. "]] as a dict key, since it's not an expression.")
|
||||
end
|
||||
local value_lua = self:tree_to_lua(entry.dict_value, filename)
|
||||
local value_lua = self:tree_to_lua(entry.dict_value)
|
||||
if value_lua.statements then
|
||||
self:error("Cannot use [[" .. tostring(entry.dict_value.src) .. "]] as a dict value, since it's not an expression.")
|
||||
end
|
||||
@ -1163,7 +1164,7 @@ end]]):format(lua_code))
|
||||
if type(bit) == "string" then
|
||||
insert(concat_parts, bit)
|
||||
else
|
||||
local lua = self:tree_to_lua(bit, filename)
|
||||
local lua = self:tree_to_lua(bit)
|
||||
if lua.statements then
|
||||
self:error("Cannot use [[" .. tostring(bit.src) .. "]] as a string interpolation value, since it's not an expression.")
|
||||
end
|
||||
@ -1241,6 +1242,14 @@ end]]):format(lua_code))
|
||||
["#vars"] = { },
|
||||
["#loaded_files"] = { }
|
||||
}
|
||||
self.ids = setmetatable({ }, {
|
||||
__mode = "k",
|
||||
__index = function(self, key)
|
||||
local id = new_uuid()
|
||||
self[key] = id
|
||||
return id
|
||||
end
|
||||
})
|
||||
if parent then
|
||||
setmetatable(self.defs, {
|
||||
__index = parent.defs
|
||||
@ -1252,7 +1261,6 @@ end]]):format(lua_code))
|
||||
__index = parent["#loaded_files"]
|
||||
})
|
||||
end
|
||||
self.callstack = { }
|
||||
self.compilestack = { }
|
||||
self.debug = false
|
||||
self.utils = utils
|
||||
|
||||
35
nomsu.moon
35
nomsu.moon
@ -13,6 +13,7 @@
|
||||
re = require 're'
|
||||
lpeg = require 'lpeg'
|
||||
utils = require 'utils'
|
||||
new_uuid = require 'uuid'
|
||||
{:repr, :stringify, :min, :max, :equivalent, :set, :is_list, :sum} = utils
|
||||
colors = setmetatable({}, {__index:->""})
|
||||
colored = setmetatable({}, {__index:(_,color)-> ((msg)-> colors[color]..(msg or '')..colors.reset)})
|
||||
@ -147,11 +148,17 @@ class NomsuCompiler
|
||||
@write_err = (...)=> io.stderr\write(...)
|
||||
-- Use # to prevent someone from defining a function that has a namespace collision.
|
||||
@defs = {["#vars"]:{}, ["#loaded_files"]:{}}
|
||||
@ids = setmetatable({}, {
|
||||
__mode: "k"
|
||||
__index: (key)=>
|
||||
id = new_uuid!
|
||||
@[key] = id
|
||||
return id
|
||||
})
|
||||
if parent
|
||||
setmetatable(@defs, {__index:parent.defs})
|
||||
setmetatable(@defs["#vars"], {__index:parent["#vars"]})
|
||||
setmetatable(@defs["#loaded_files"], {__index:parent["#loaded_files"]})
|
||||
@callstack = {}
|
||||
@compilestack = {}
|
||||
@debug = false
|
||||
@utils = utils
|
||||
@ -281,7 +288,7 @@ class NomsuCompiler
|
||||
@assert tree, "Failed to parse: #{src}"
|
||||
@assert tree.type == "File", "Attempt to run non-file: #{tree.type}"
|
||||
|
||||
lua = @tree_to_lua(tree, filename)
|
||||
lua = @tree_to_lua(tree)
|
||||
lua_code = lua.statements or (lua.expr..";")
|
||||
lua_code = "-- File: #{filename}\n"..lua_code
|
||||
ret = @run_lua(lua_code)
|
||||
@ -335,7 +342,7 @@ end]]\format(lua_code))
|
||||
return ret
|
||||
|
||||
tree_to_value: (tree, filename)=>
|
||||
code = "return (function(nomsu)\nreturn #{@tree_to_lua(tree, filename).expr};\nend);"
|
||||
code = "return (function(nomsu)\nreturn #{@tree_to_lua(tree).expr};\nend);"
|
||||
code = "-- Tree to value: #{filename}\n"..code
|
||||
if @debug
|
||||
@writeln "#{colored.bright "RUNNING LUA TO GET VALUE:"}\n#{colored.blue colored.bright(code)}"
|
||||
@ -476,7 +483,7 @@ end]]\format(lua_code))
|
||||
error("Unsupported value_to_nomsu type: #{type(value)}")
|
||||
|
||||
@math_patt: re.compile [[ "%" (" " [*/^+-] " %")+ ]]
|
||||
tree_to_lua: (tree, filename)=>
|
||||
tree_to_lua: (tree)=>
|
||||
-- Return <lua code for value>, <additional lua code>
|
||||
@assert tree, "No tree provided."
|
||||
if not tree.type
|
||||
@ -485,10 +492,10 @@ end]]\format(lua_code))
|
||||
switch tree.type
|
||||
when "File"
|
||||
if #tree.value == 1
|
||||
return @tree_to_lua(tree.value[1], filename)
|
||||
return @tree_to_lua(tree.value[1])
|
||||
lua_bits = {}
|
||||
for line in *tree.value
|
||||
lua = @tree_to_lua line, filename
|
||||
lua = @tree_to_lua line
|
||||
if not lua
|
||||
@error "No lua produced by #{repr line}"
|
||||
if lua.statements then insert lua_bits, lua.statements
|
||||
@ -501,7 +508,7 @@ end]]\format(lua_code))
|
||||
when "Block"
|
||||
lua_bits = {}
|
||||
for arg in *tree.value
|
||||
lua = @tree_to_lua arg, filename
|
||||
lua = @tree_to_lua arg
|
||||
if #tree.value == 1 and lua.expr and not lua.statements
|
||||
return expr:lua.expr
|
||||
if lua.statements then insert lua_bits, lua.statements
|
||||
@ -529,7 +536,7 @@ end]]\format(lua_code))
|
||||
if tok.type == "Word"
|
||||
insert bits, tok.value
|
||||
else
|
||||
lua = @tree_to_lua(tok, filename)
|
||||
lua = @tree_to_lua(tok)
|
||||
@assert(lua.statements == nil, "non-expression value inside math expression")
|
||||
insert bits, lua.expr
|
||||
remove @compilestack
|
||||
@ -539,7 +546,7 @@ end]]\format(lua_code))
|
||||
args = {}
|
||||
for tok in *tree.value
|
||||
if tok.type == "Word" then continue
|
||||
lua = @tree_to_lua(tok, filename)
|
||||
lua = @tree_to_lua(tok)
|
||||
@assert(lua.expr, "Cannot use #{tok.src} as an argument, since it's not an expression.")
|
||||
insert args, lua.expr
|
||||
|
||||
@ -561,7 +568,7 @@ end]]\format(lua_code))
|
||||
if string_buffer ~= ""
|
||||
insert concat_parts, repr(string_buffer)
|
||||
string_buffer = ""
|
||||
lua = @tree_to_lua bit, filename
|
||||
lua = @tree_to_lua bit
|
||||
if @debug
|
||||
@writeln (colored.bright "INTERP:")
|
||||
@print_tree bit
|
||||
@ -582,7 +589,7 @@ end]]\format(lua_code))
|
||||
when "List"
|
||||
items = {}
|
||||
for item in *tree.value
|
||||
lua = @tree_to_lua item, filename
|
||||
lua = @tree_to_lua item
|
||||
if lua.statements
|
||||
@error "Cannot use [[#{item.src}]] as a list item, since it's not an expression."
|
||||
insert items, lua.expr
|
||||
@ -594,10 +601,10 @@ end]]\format(lua_code))
|
||||
key_lua = if entry.dict_key.type == "Word"
|
||||
{expr:repr(entry.dict_key.value)}
|
||||
else
|
||||
@tree_to_lua entry.dict_key, filename
|
||||
@tree_to_lua entry.dict_key
|
||||
if key_lua.statements
|
||||
@error "Cannot use [[#{entry.dict_key.src}]] as a dict key, since it's not an expression."
|
||||
value_lua = @tree_to_lua entry.dict_value, filename
|
||||
value_lua = @tree_to_lua entry.dict_value
|
||||
if value_lua.statements
|
||||
@error "Cannot use [[#{entry.dict_value.src}]] as a dict value, since it's not an expression."
|
||||
key_str = key_lua.expr\match([=[["']([a-zA-Z_][a-zA-Z0-9_]*)['"]]=])
|
||||
@ -755,7 +762,7 @@ end]]\format(lua_code))
|
||||
if type(bit) == "string"
|
||||
insert concat_parts, bit
|
||||
else
|
||||
lua = @tree_to_lua bit, filename
|
||||
lua = @tree_to_lua bit
|
||||
if lua.statements
|
||||
@error "Cannot use [[#{bit.src}]] as a string interpolation value, since it's not an expression."
|
||||
insert concat_parts, lua.expr
|
||||
|
||||
23
uuid.lua
Normal file
23
uuid.lua
Normal file
@ -0,0 +1,23 @@
|
||||
-- A simple UUID function based on RFC 4122: http://www.ietf.org/rfc/rfc4122.txt
|
||||
local function uuid()
|
||||
local r = math.random
|
||||
-- Set all the other bits to randomly (or pseudo-randomly) chosen values.
|
||||
local bytes = {
|
||||
r(2^(4*8)), --time-low
|
||||
r(2^(2*8)), --time-mid
|
||||
r(2^(2*8-4)), --time-high-and-version
|
||||
r(2^(1*8-2)), --clock-seq-and-reserved
|
||||
r(2^(1*8)), --clock-seq-low
|
||||
r(2^(3*8)), r(2^(3*8)), --node
|
||||
}
|
||||
-- Set the four most significant bits (bits 12 through 15) of the
|
||||
-- time_hi_and_version field to the 4-bit version number from
|
||||
-- Section 4.1.3.
|
||||
bytes[3] = bit32.bor(bytes[3], 0x4000)
|
||||
-- Set the two most significant bits (bits 6 and 7) of the
|
||||
-- clock_seq_hi_and_reserved to zero and one, respectively.
|
||||
bytes[4] = bit32.bor(bytes[4], 0xC0)
|
||||
return ("%08x-%04x-%04x-%02x%02x-%6x%6x"):format(unpack(bytes))
|
||||
end
|
||||
|
||||
return uuid
|
||||
Loading…
Reference in New Issue
Block a user