Lua works; narrator works

CMakeLists.txt

@@ -72,6 +72,7 @@ add_subdirectory(src/miniaudio)
 add_subdirectory(src/sound)
 add_subdirectory(audio/gui)
 add_subdirectory(tests)
+add_subdirectory(lua-scripts)
 
 # add the source files as usual
 add_executable(0_Bootstrap Bootstrap.cpp)
@@ -192,17 +193,6 @@ if(OGRE_STATIC)
 	target_link_libraries(Editor fix::assimp pugixml)
 endif()
 
-file(GLOB LUA_SCRIPTS_SRC ${CMAKE_SOURCE_DIR}/lua-scripts/*.lua)
-set(LUA_SCRIPTS_OUTPUT)
-foreach(LUA_SCRIPT_FILE ${LUA_SCRIPTS_SRC})
-	get_filename_component(FILE_NAME ${LUA_SCRIPT_FILE} NAME_WE)
-	set(LUA_SCRIPT_OUTPUT_FILE ${CMAKE_BINARY_DIR}/lua-scripts/${FILE_NAME}.lua)
-	add_custom_command(OUTPUT ${LUA_SCRIPT_OUTPUT_FILE}
-		COMMAND ${CMAKE_COMMAND} -E copy  ${LUA_SCRIPT_FILE} ${LUA_SCRIPT_OUTPUT_FILE}
-		DEPENDS ${LUA_SCRIPT_FILE})
-	list(APPEND LUA_SCRIPTS_OUTPUT ${LUA_SCRIPT_OUTPUT_FILE})
-endforeach()
-add_custom_target(stage_lua_scripts ALL DEPENDS ${LUA_SCRIPTS_OUTPUT})
 add_dependencies(TerrainTest stage_lua_scripts stage_files)
 
 add_custom_command(

Game.cpp

@@ -210,7 +210,6 @@ public:
 		bool updated = false;
 		if (isGuiEnabled())
 			return false;
-		std::cout << "GUI not enabled\n";
 		if (evt.keysym.sym == OgreBites::SDLK_ESCAPE) {
 			OgreAssert(ECS::get().has<ECS::GUI>(), "");
 			setGuiEnabled(true);
@@ -336,6 +335,11 @@ public:
 	{
 		Ogre::ResourceGroupManager::getSingleton().createResourceGroup(
 			"Water", true);
+		Ogre::ResourceGroupManager::getSingleton().createResourceGroup(
+			"LuaScripts", false);
+		Ogre::ResourceGroupManager::getSingleton().addResourceLocation(
+			"./lua-scripts", "FileSystem", "LuaScripts", true,
+			true);
 		OgreBites::ApplicationContext::locateResources();
 	}
 	void loadResources() override

lua-scripts/CMakeLists.txt

@@ -0,0 +1,24 @@
+project(lua-scripts)
+set(LUA_SCRIPTS_SRC
+data.lua
+)
+set(LUA_SCRIPTS_OUTPUT)
+set(LUA_PACKAGES narrator stories)
+foreach(LUA_SCRIPT_FILE ${LUA_SCRIPTS_SRC})
+	get_filename_component(FILE_NAME ${LUA_SCRIPT_FILE} NAME_WE)
+	set(LUA_SCRIPT_OUTPUT_FILE ${CMAKE_CURRENT_BINARY_DIR}/${FILE_NAME}.lua)
+	add_custom_command(OUTPUT ${LUA_SCRIPT_OUTPUT_FILE}
+		COMMAND ${CMAKE_COMMAND} -E copy  ${CMAKE_CURRENT_SOURCE_DIR}/${LUA_SCRIPT_FILE} ${LUA_SCRIPT_OUTPUT_FILE}
+		DEPENDS ${LUA_SCRIPT_FILE})
+	list(APPEND LUA_SCRIPTS_OUTPUT ${LUA_SCRIPT_OUTPUT_FILE})
+endforeach()
+set(LUA_PACKAGES_OUTPUT)
+foreach(LUA_PACKAGE ${LUA_PACKAGES})
+    add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${LUA_PACKAGE}
+        COMMAND ${CMAKE_COMMAND} -E copy_directory
+            ${CMAKE_CURRENT_SOURCE_DIR}/${LUA_PACKAGE}
+            ${CMAKE_CURRENT_BINARY_DIR}/${LUA_PACKAGE}
+        DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${LUA_PACKAGE})
+    list(APPEND LUA_PACKAGES_OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${LUA_PACKAGE})
+endforeach()
+add_custom_target(stage_lua_scripts ALL DEPENDS ${LUA_SCRIPTS_OUTPUT} ${LUA_PACKAGES_OUTPUT})

lua-scripts/data.lua

@@ -36,6 +36,7 @@ function foo()
 	end
 	v = Vector3(0, 1, 2)
 end
+--[[
 narration = {
 	position = 1,
 	narration_start = {
@@ -59,15 +60,74 @@ dropped you into the sea. Last thing you heard before you hit the water was happ
 		return ret
 	end,
 }
+]]--
+local narrator = require('narrator.narrator')
+
+-- Parse a book from the Ink file.
+local book = narrator.parse_file('stories.game')
+
+-- Init a story from the book
+local story = narrator.init_story(book)
+
+-- Begin the story
+story:begin()
+
+function dump(o)
+   if type(o) == 'table' then
+      local s = '{ '
+      for k,v in pairs(o) do
+         if type(k) ~= 'number' then k = '"'..k..'"' end
+         s = s .. '['..k..'] = ' .. dump(v) .. ','
+      end
+      return s .. '} '
+   else
+      return tostring(o)
+   end
+end
+
+function _narration()
+		local ret = ""
+		local choices = {}
+		if story:can_continue() then
+  			local paragraphs = story:continue()
+  			for _, paragraph in ipairs(paragraphs) do
+				local text = paragraph.text
+    				if paragraph.tags then
+					text = text .. ' #' .. table.concat(paragraph.tags, ' #')
+				end
+				ret = ret .. text
+			end
+			if story:can_choose() then
+				local ch = story:get_choices()
+				for i, choice in ipairs(ch) do
+					table.insert(choices, choice.text)
+					print(i, dump(choice))
+				end
+			end
+		end
+		if (#choices > 0) then
+			print("choices!!!")
+			narrate(ret, choices)
+		else
+			narrate(ret)
+		end
+end
+
 setup_handler(function(event)
 	print(event)
 	if event == "startup" then
 		main_menu()
 	elseif event == "narration_progress" then
-		narrate(narration:progress())
-
+		_narration()
+	elseif event == "narration_answered" then
+		local answer = narration_get_answer()
+		story:choose(answer)
+		_narration()
 	elseif event == "new_game" then
-		narrate(narration:progress())
+		local ret = ""
+		story = narrator.init_story(book)
+		story:begin()
+		_narration()
 	end
 end)
 

lua-scripts/narrator/annotations.lua

@@ -0,0 +1,37 @@
+---@class Narrator.Book.Version
+---@field engine number
+---@field tree number
+
+---@class Narrator.Book
+---@field version Narrator.Book.Version
+---@field inclusions string[]
+---@field lists table
+---@field constants table
+---@field variables table
+---@field params table
+---@field tree table
+
+---@class Narrator.ParsingParams
+---@field save boolean Save a parsed book to the lua file
+
+---@class Narrator.Paragraph
+---@field text string
+---@field tags string[]|nil
+
+---@class Narrator.Choice
+---@field text string
+---@field tags string[]|nil
+
+---@class Narrator.State
+---@field version number
+---@field temp table
+---@field seeds table
+---@field variables table
+---@field params table|nil
+---@field visits table
+---@field current_path table
+---@field paragraphs table
+---@field choices table
+---@field output table
+---@field tunnels table|nil
+---@field path table

lua-scripts/narrator/enums.lua

@@ -0,0 +1,32 @@
+local enums = {
+
+  ---Bump it when the state structure is changed
+  engine_version = 2,
+
+  ---@enum Narrator.ItemType
+  item = {
+    text = 1,
+    alts = 2,
+    choice = 3,
+    condition = 4,
+    variable = 5
+  },
+
+  ---@enum Narrator.Sequence
+  sequence = {
+    cycle = 1,
+    stopping = 2,
+    once = 3
+  },
+
+  ---@enum Narrator.ReadMode
+  read_mode = {
+    text = 1,
+    choices = 2,
+    gathers = 3,
+    quit = 4
+  }
+
+}
+
+return enums

lua-scripts/narrator/libs/classic.lua

@@ -0,0 +1,68 @@
+--
+-- classic
+--
+-- Copyright (c) 2014, rxi
+--
+-- This module is free software; you can redistribute it and/or modify it under
+-- the terms of the MIT license. See LICENSE for details.
+--
+
+
+local Object = {}
+Object.__index = Object
+
+
+function Object:new()
+end
+
+
+function Object:extend()
+  local cls = {}
+  for k, v in pairs(self) do
+    if k:find("__") == 1 then
+      cls[k] = v
+    end
+  end
+  cls.__index = cls
+  cls.super = self
+  setmetatable(cls, self)
+  return cls
+end
+
+
+function Object:implement(...)
+  for _, cls in pairs({...}) do
+    for k, v in pairs(cls) do
+      if self[k] == nil and type(v) == "function" then
+        self[k] = v
+      end
+    end
+  end
+end
+
+
+function Object:is(T)
+  local mt = getmetatable(self)
+  while mt do
+    if mt == T then
+      return true
+    end
+    mt = getmetatable(mt)
+  end
+  return false
+end
+
+
+function Object:__tostring()
+  return "Object"
+end
+
+
+function Object:__call(...)
+  local obj = setmetatable({}, self)
+  obj:new(...)
+  return obj
+end
+
+
+return Object

lua-scripts/narrator/libs/lume.lua

@@ -0,0 +1,780 @@
+--
+-- lume
+--
+-- Copyright (c) 2020 rxi
+--
+-- Permission is hereby granted, free of charge, to any person obtaining a copy of
+-- this software and associated documentation files (the "Software"), to deal in
+-- the Software without restriction, including without limitation the rights to
+-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+-- of the Software, and to permit persons to whom the Software is furnished to do
+-- so, subject to the following conditions:
+--
+-- The above copyright notice and this permission notice shall be included in all
+-- copies or substantial portions of the Software.
+--
+-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+-- SOFTWARE.
+--
+
+local lume = { _version = "2.3.0" }
+
+local pairs, ipairs = pairs, ipairs
+local type, assert, unpack = type, assert, unpack or table.unpack
+local tostring, tonumber = tostring, tonumber
+local math_floor = math.floor
+local math_ceil = math.ceil
+local math_atan2 = math.atan2 or math.atan
+local math_sqrt = math.sqrt
+local math_abs = math.abs
+
+local noop = function()
+end
+
+local identity = function(x)
+  return x
+end
+
+local patternescape = function(str)
+  return str:gsub("[%(%)%.%%%+%-%*%?%[%]%^%$]", "%%%1")
+end
+
+local absindex = function(len, i)
+  return i < 0 and (len + i + 1) or i
+end
+
+local iscallable = function(x)
+  if type(x) == "function" then return true end
+  local mt = getmetatable(x)
+  return mt and mt.__call ~= nil
+end
+
+local getiter = function(x)
+  if lume.isarray(x) then
+    return ipairs
+  elseif type(x) == "table" then
+    return pairs
+  end
+  error("expected table", 3)
+end
+
+local iteratee = function(x)
+  if x == nil then return identity end
+  if iscallable(x) then return x end
+  if type(x) == "table" then
+    return function(z)
+      for k, v in pairs(x) do
+        if z[k] ~= v then return false end
+      end
+      return true
+    end
+  end
+  return function(z) return z[x] end
+end
+
+
+
+function lume.clamp(x, min, max)
+  return x < min and min or (x > max and max or x)
+end
+
+
+function lume.round(x, increment)
+  if increment then return lume.round(x / increment) * increment end
+  return x >= 0 and math_floor(x + .5) or math_ceil(x - .5)
+end
+
+
+function lume.sign(x)
+  return x < 0 and -1 or 1
+end
+
+
+function lume.lerp(a, b, amount)
+  return a + (b - a) * lume.clamp(amount, 0, 1)
+end
+
+
+function lume.smooth(a, b, amount)
+  local t = lume.clamp(amount, 0, 1)
+  local m = t * t * (3 - 2 * t)
+  return a + (b - a) * m
+end
+
+
+function lume.pingpong(x)
+  return 1 - math_abs(1 - x % 2)
+end
+
+
+function lume.distance(x1, y1, x2, y2, squared)
+  local dx = x1 - x2
+  local dy = y1 - y2
+  local s = dx * dx + dy * dy
+  return squared and s or math_sqrt(s)
+end
+
+
+function lume.angle(x1, y1, x2, y2)
+  return math_atan2(y2 - y1, x2 - x1)
+end
+
+
+function lume.vector(angle, magnitude)
+  return math.cos(angle) * magnitude, math.sin(angle) * magnitude
+end
+
+
+function lume.random(a, b)
+  if not a then a, b = 0, 1 end
+  if not b then b = 0 end
+  return a + math.random() * (b - a)
+end
+
+
+function lume.randomchoice(t)
+  return t[math.random(#t)]
+end
+
+
+function lume.weightedchoice(t)
+  local sum = 0
+  for _, v in pairs(t) do
+    assert(v >= 0, "weight value less than zero")
+    sum = sum + v
+  end
+  assert(sum ~= 0, "all weights are zero")
+  local rnd = lume.random(sum)
+  for k, v in pairs(t) do
+    if rnd < v then return k end
+    rnd = rnd - v
+  end
+end
+
+
+function lume.isarray(x)
+  return type(x) == "table" and x[1] ~= nil
+end
+
+
+function lume.push(t, ...)
+  local n = select("#", ...)
+  for i = 1, n do
+    t[#t + 1] = select(i, ...)
+  end
+  return ...
+end
+
+
+function lume.remove(t, x)
+  local iter = getiter(t)
+  for i, v in iter(t) do
+    if v == x then
+      if lume.isarray(t) then
+        table.remove(t, i)
+        break
+      else
+        t[i] = nil
+        break
+      end
+    end
+  end
+  return x
+end
+
+
+function lume.clear(t)
+  local iter = getiter(t)
+  for k in iter(t) do
+    t[k] = nil
+  end
+  return t
+end
+
+
+function lume.extend(t, ...)
+  for i = 1, select("#", ...) do
+    local x = select(i, ...)
+    if x then
+      for k, v in pairs(x) do
+        t[k] = v
+      end
+    end
+  end
+  return t
+end
+
+
+function lume.shuffle(t)
+  local rtn = {}
+  for i = 1, #t do
+    local r = math.random(i)
+    if r ~= i then
+      rtn[i] = rtn[r]
+    end
+    rtn[r] = t[i]
+  end
+  return rtn
+end
+
+
+function lume.sort(t, comp)
+  local rtn = lume.clone(t)
+  if comp then
+    if type(comp) == "string" then
+      table.sort(rtn, function(a, b) return a[comp] < b[comp] end)
+    else
+      table.sort(rtn, comp)
+    end
+  else
+    table.sort(rtn)
+  end
+  return rtn
+end
+
+
+function lume.array(...)
+  local t = {}
+  for x in ... do t[#t + 1] = x end
+  return t
+end
+
+
+function lume.each(t, fn, ...)
+  local iter = getiter(t)
+  if type(fn) == "string" then
+    for _, v in iter(t) do v[fn](v, ...) end
+  else
+    for _, v in iter(t) do fn(v, ...) end
+  end
+  return t
+end
+
+
+function lume.map(t, fn)
+  fn = iteratee(fn)
+  local iter = getiter(t)
+  local rtn = {}
+  for k, v in iter(t) do rtn[k] = fn(v) end
+  return rtn
+end
+
+
+function lume.all(t, fn)
+  fn = iteratee(fn)
+  local iter = getiter(t)
+  for _, v in iter(t) do
+    if not fn(v) then return false end
+  end
+  return true
+end
+
+
+function lume.any(t, fn)
+  fn = iteratee(fn)
+  local iter = getiter(t)
+  for _, v in iter(t) do
+    if fn(v) then return true end
+  end
+  return false
+end
+
+
+function lume.reduce(t, fn, first)
+  local started = first ~= nil
+  local acc = first
+  local iter = getiter(t)
+  for _, v in iter(t) do
+    if started then
+      acc = fn(acc, v)
+    else
+      acc = v
+      started = true
+    end
+  end
+  assert(started, "reduce of an empty table with no first value")
+  return acc
+end
+
+
+function lume.unique(t)
+  local rtn = {}
+  for k in pairs(lume.invert(t)) do
+    rtn[#rtn + 1] = k
+  end
+  return rtn
+end
+
+
+function lume.filter(t, fn, retainkeys)
+  fn = iteratee(fn)
+  local iter = getiter(t)
+  local rtn = {}
+  if retainkeys then
+    for k, v in iter(t) do
+      if fn(v) then rtn[k] = v end
+    end
+  else
+    for _, v in iter(t) do
+      if fn(v) then rtn[#rtn + 1] = v end
+    end
+  end
+  return rtn
+end
+
+
+function lume.reject(t, fn, retainkeys)
+  fn = iteratee(fn)
+  local iter = getiter(t)
+  local rtn = {}
+  if retainkeys then
+    for k, v in iter(t) do
+      if not fn(v) then rtn[k] = v end
+    end
+  else
+    for _, v in iter(t) do
+      if not fn(v) then rtn[#rtn + 1] = v end
+    end
+  end
+  return rtn
+end
+
+
+function lume.merge(...)
+  local rtn = {}
+  for i = 1, select("#", ...) do
+    local t = select(i, ...)
+    local iter = getiter(t)
+    for k, v in iter(t) do
+      rtn[k] = v
+    end
+  end
+  return rtn
+end
+
+
+function lume.concat(...)
+  local rtn = {}
+  for i = 1, select("#", ...) do
+    local t = select(i, ...)
+    if t ~= nil then
+      local iter = getiter(t)
+      for _, v in iter(t) do
+        rtn[#rtn + 1] = v
+      end
+    end
+  end
+  return rtn
+end
+
+
+function lume.find(t, value)
+  local iter = getiter(t)
+  for k, v in iter(t) do
+    if v == value then return k end
+  end
+  return nil
+end
+
+
+function lume.match(t, fn)
+  fn = iteratee(fn)
+  local iter = getiter(t)
+  for k, v in iter(t) do
+    if fn(v) then return v, k end
+  end
+  return nil
+end
+
+
+function lume.count(t, fn)
+  local count = 0
+  local iter = getiter(t)
+  if fn then
+    fn = iteratee(fn)
+    for _, v in iter(t) do
+      if fn(v) then count = count + 1 end
+    end
+  else
+    if lume.isarray(t) then
+      return #t
+    end
+    for _ in iter(t) do count = count + 1 end
+  end
+  return count
+end
+
+
+function lume.slice(t, i, j)
+  i = i and absindex(#t, i) or 1
+  j = j and absindex(#t, j) or #t
+  local rtn = {}
+  for x = i < 1 and 1 or i, j > #t and #t or j do
+    rtn[#rtn + 1] = t[x]
+  end
+  return rtn
+end
+
+
+function lume.first(t, n)
+  if not n then return t[1] end
+  return lume.slice(t, 1, n)
+end
+
+
+function lume.last(t, n)
+  if not n then return t[#t] end
+  return lume.slice(t, -n, -1)
+end
+
+
+function lume.invert(t)
+  local rtn = {}
+  for k, v in pairs(t) do rtn[v] = k end
+  return rtn
+end
+
+
+function lume.pick(t, ...)
+  local rtn = {}
+  for i = 1, select("#", ...) do
+    local k = select(i, ...)
+    rtn[k] = t[k]
+  end
+  return rtn
+end
+
+
+function lume.keys(t)
+  local rtn = {}
+  local iter = getiter(t)
+  for k in iter(t) do rtn[#rtn + 1] = k end
+  return rtn
+end
+
+
+function lume.clone(t)
+  local rtn = {}
+  for k, v in pairs(t) do rtn[k] = v end
+  return rtn
+end
+
+
+function lume.fn(fn, ...)
+  assert(iscallable(fn), "expected a function as the first argument")
+  local args = { ... }
+  return function(...)
+    local a = lume.concat(args, { ... })
+    return fn(unpack(a))
+  end
+end
+
+
+function lume.once(fn, ...)
+  local f = lume.fn(fn, ...)
+  local done = false
+  return function(...)
+    if done then return end
+    done = true
+    return f(...)
+  end
+end
+
+
+local memoize_fnkey = {}
+local memoize_nil = {}
+
+function lume.memoize(fn)
+  local cache = {}
+  return function(...)
+    local c = cache
+    for i = 1, select("#", ...) do
+      local a = select(i, ...) or memoize_nil
+      c[a] = c[a] or {}
+      c = c[a]
+    end
+    c[memoize_fnkey] = c[memoize_fnkey] or {fn(...)}
+    return unpack(c[memoize_fnkey])
+  end
+end
+
+
+function lume.combine(...)
+  local n = select('#', ...)
+  if n == 0 then return noop end
+  if n == 1 then
+    local fn = select(1, ...)
+    if not fn then return noop end
+    assert(iscallable(fn), "expected a function or nil")
+    return fn
+  end
+  local funcs = {}
+  for i = 1, n do
+    local fn = select(i, ...)
+    if fn ~= nil then
+      assert(iscallable(fn), "expected a function or nil")
+      funcs[#funcs + 1] = fn
+    end
+  end
+  return function(...)
+    for _, f in ipairs(funcs) do f(...) end
+  end
+end
+
+
+function lume.call(fn, ...)
+  if fn then
+    return fn(...)
+  end
+end
+
+
+function lume.time(fn, ...)
+  local start = os.clock()
+  local rtn = {fn(...)}
+  return (os.clock() - start), unpack(rtn)
+end
+
+
+local lambda_cache = {}
+
+function lume.lambda(str)
+  if not lambda_cache[str] then
+    local args, body = str:match([[^([%w,_ ]-)%->(.-)$]])
+    assert(args and body, "bad string lambda")
+    local s = "return function(" .. args .. ")\nreturn " .. body .. "\nend"
+    lambda_cache[str] = lume.dostring(s)
+  end
+  return lambda_cache[str]
+end
+
+
+local serialize
+
+local serialize_map = {
+  [ "boolean" ] = tostring,
+  [ "nil"     ] = tostring,
+  [ "string"  ] = function(v) return string.format("%q", v) end,
+  [ "number"  ] = function(v)
+    if      v ~=  v     then return  "0/0"      --  nan
+    elseif  v ==  1 / 0 then return  "1/0"      --  inf
+    elseif  v == -1 / 0 then return "-1/0" end  -- -inf
+    return tostring(v)
+  end,
+  [ "table"   ] = function(t, stk)
+    stk = stk or {}
+    if stk[t] then error("circular reference") end
+    local rtn = {}
+    stk[t] = true
+    for k, v in pairs(t) do
+      rtn[#rtn + 1] = "[" .. serialize(k, stk) .. "]=" .. serialize(v, stk)
+    end
+    stk[t] = nil
+    return "{" .. table.concat(rtn, ",") .. "}"
+  end
+}
+
+setmetatable(serialize_map, {
+  __index = function(_, k) error("unsupported serialize type: " .. k) end
+})
+
+serialize = function(x, stk)
+  return serialize_map[type(x)](x, stk)
+end
+
+function lume.serialize(x)
+  return serialize(x)
+end
+
+
+function lume.deserialize(str)
+  return lume.dostring("return " .. str)
+end
+
+
+function lume.split(str, sep)
+  if not sep then
+    return lume.array(str:gmatch("([%S]+)"))
+  else
+    assert(sep ~= "", "empty separator")
+    local psep = patternescape(sep)
+    return lume.array((str..sep):gmatch("(.-)("..psep..")"))
+  end
+end
+
+
+function lume.trim(str, chars)
+  if not chars then return str:match("^[%s]*(.-)[%s]*$") end
+  chars = patternescape(chars)
+  return str:match("^[" .. chars .. "]*(.-)[" .. chars .. "]*$")
+end
+
+
+function lume.wordwrap(str, limit)
+  limit = limit or 72
+  local check
+  if type(limit) == "number" then
+    check = function(s) return #s >= limit end
+  else
+    check = limit
+  end
+  local rtn = {}
+  local line = ""
+  for word, spaces in str:gmatch("(%S+)(%s*)") do
+    local s = line .. word
+    if check(s) then
+      table.insert(rtn, line .. "\n")
+      line = word
+    else
+      line = s
+    end
+    for c in spaces:gmatch(".") do
+      if c == "\n" then
+        table.insert(rtn, line .. "\n")
+        line = ""
+      else
+        line = line .. c
+      end
+    end
+  end
+  table.insert(rtn, line)
+  return table.concat(rtn)
+end
+
+
+function lume.format(str, vars)
+  if not vars then return str end
+  local f = function(x)
+    return tostring(vars[x] or vars[tonumber(x)] or "{" .. x .. "}")
+  end
+  return (str:gsub("{(.-)}", f))
+end
+
+
+function lume.trace(...)
+  local info = debug.getinfo(2, "Sl")
+  local t = { info.short_src .. ":" .. info.currentline .. ":" }
+  for i = 1, select("#", ...) do
+    local x = select(i, ...)
+    if type(x) == "number" then
+      x = string.format("%g", lume.round(x, .01))
+    end
+    t[#t + 1] = tostring(x)
+  end
+  print(table.concat(t, " "))
+end
+
+
+function lume.dostring(str)
+  return assert((loadstring or load)(str))()
+end
+
+
+function lume.uuid()
+  local fn = function(x)
+    local r = math.random(16) - 1
+    r = (x == "x") and (r + 1) or (r % 4) + 9
+    return ("0123456789abcdef"):sub(r, r)
+  end
+  return (("xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"):gsub("[xy]", fn))
+end
+
+
+function lume.hotswap(modname)
+  local oldglobal = lume.clone(_G)
+  local updated = {}
+  local function update(old, new)
+    if updated[old] then return end
+    updated[old] = true
+    local oldmt, newmt = getmetatable(old), getmetatable(new)
+    if oldmt and newmt then update(oldmt, newmt) end
+    for k, v in pairs(new) do
+      if type(v) == "table" then update(old[k], v) else old[k] = v end
+    end
+  end
+  local err = nil
+  local function onerror(e)
+    for k in pairs(_G) do _G[k] = oldglobal[k] end
+    err = lume.trim(e)
+  end
+  local ok, oldmod = pcall(require, modname)
+  oldmod = ok and oldmod or nil
+  xpcall(function()
+    package.loaded[modname] = nil
+    local newmod = require(modname)
+    if type(oldmod) == "table" then update(oldmod, newmod) end
+    for k, v in pairs(oldglobal) do
+      if v ~= _G[k] and type(v) == "table" then
+        update(v, _G[k])
+        _G[k] = v
+      end
+    end
+  end, onerror)
+  package.loaded[modname] = oldmod
+  if err then return nil, err end
+  return oldmod
+end
+
+
+local ripairs_iter = function(t, i)
+  i = i - 1
+  local v = t[i]
+  if v ~= nil then
+    return i, v
+  end
+end
+
+function lume.ripairs(t)
+  return ripairs_iter, t, (#t + 1)
+end
+
+
+function lume.color(str, mul)
+  mul = mul or 1
+  local r, g, b, a
+  r, g, b = str:match("#(%x%x)(%x%x)(%x%x)")
+  if r then
+    r = tonumber(r, 16) / 0xff
+    g = tonumber(g, 16) / 0xff
+    b = tonumber(b, 16) / 0xff
+    a = 1
+  elseif str:match("rgba?%s*%([%d%s%.,]+%)") then
+    local f = str:gmatch("[%d.]+")
+    r = (f() or 0) / 0xff
+    g = (f() or 0) / 0xff
+    b = (f() or 0) / 0xff
+    a = f() or 1
+  else
+    error(("bad color string '%s'"):format(str))
+  end
+  return r * mul, g * mul, b * mul, a * mul
+end
+
+
+local chain_mt = {}
+chain_mt.__index = lume.map(lume.filter(lume, iscallable, true),
+  function(fn)
+    return function(self, ...)
+      self._value = fn(self._value, ...)
+      return self
+    end
+  end)
+chain_mt.__index.result = function(x) return x._value end
+
+function lume.chain(value)
+  return setmetatable({ _value = value }, chain_mt)
+end
+
+setmetatable(lume,  {
+  __call = function(_, ...)
+    return lume.chain(...)
+  end
+})
+
+
+return lume

lua-scripts/narrator/list/mt.lua

@@ -0,0 +1,401 @@
+--
+-- Dependencies
+
+local lume = require('narrator.libs.lume')
+
+--
+-- Metatable
+
+local mt = { lists = { } }
+
+function mt.__tostring(self)
+  local pool = { }
+
+  local list_keys = { }
+  for key, _ in pairs(self) do
+    table.insert(list_keys, key)
+  end
+  table.sort(list_keys)
+
+  for i = 1, #list_keys do
+    local list_name = list_keys[i]
+    local list_items = self[list_name]
+    for index = 1, #mt.lists[list_name] do
+      pool[index] = pool[index] or { }
+      local item_name = mt.lists[list_name][index]
+      if list_items[item_name] == true then
+        table.insert(pool[index], 1, item_name)
+      end
+    end
+  end
+
+  local items = { }
+
+  for _, titles in ipairs(pool) do
+    for _, title in ipairs(titles) do
+      table.insert(items, title)
+    end
+  end
+
+  return table.concat(items, ', ')
+end
+
+--
+-- Operators
+
+function mt.__add(lhs, rhs) -- +
+  if type(rhs) == 'table' then
+    return mt.__add_list(lhs, rhs)
+  elseif type(rhs) == 'number' then
+    return mt.__shift_by_number(lhs, rhs)
+  else
+    error('Attempt to sum the list with ' .. type(rhs))
+  end
+end
+
+function mt.__sub(lhs, rhs) -- -
+  if type(rhs) == 'table' then
+    return mt.__subList(lhs, rhs)
+  elseif type(rhs) == 'number' then
+    return mt.__shift_by_number(lhs, -rhs)
+  else
+    error('Attempt to sub the list with ' .. type(rhs))
+  end
+end
+
+function mt.__mod(lhs, rhs) -- % (contain)
+  if type(rhs) ~= 'table' then
+    error('Attempt to check content of the list for ' .. type(rhs))
+  end
+
+  for list_name, list_items in pairs(rhs) do
+    if lhs[list_name] == nil then return false end
+    for item_name, item_value in pairs(list_items) do
+      if (lhs[list_name][item_name] or false) ~= item_value then return false end
+    end
+  end
+
+  return true
+end
+
+function mt.__pow(lhs, rhs) -- ^ (intersection)
+  if type(rhs) ~= 'table' then
+    error('Attempt to interselect the list with ' .. type(rhs))
+  end
+
+  local intersection = { }
+
+  for list_name, list_items in pairs(lhs) do
+    for item_name, item_value in pairs(list_items) do
+      local left = lhs[list_name][item_name]
+      local right = (rhs[list_name] or { })[item_name]
+      if left == true and right == true then
+        intersection[list_name] = intersection[list_name] or { }
+        intersection[list_name][item_name] = true
+      end
+    end
+  end
+
+  setmetatable(intersection, mt)
+  return intersection
+end
+
+function mt.__len(self) -- #
+  local len = 0
+
+  for list_name, list_items in pairs(self) do
+    for item_name, item_value in pairs(list_items) do
+      if item_value == true then len = len + 1 end
+    end
+  end
+
+  return len
+end
+
+function mt.__eq(lhs, rhs) -- ==
+  if type(rhs) ~= 'table' then
+    error('Attempt to compare the list with ' .. type(rhs))
+  end
+
+  local function keys_count(object)
+    local count = 0
+    for _, _ in pairs(object) do
+      count = count + 1
+    end
+    return count
+  end
+
+  local left_lists_count = keys_count(lhs)
+  local right_lists_count = keys_count(rhs)
+  if left_lists_count ~= right_lists_count then
+    return false
+  end
+
+  for list_name, left_items in pairs(lhs) do
+    local right_items = rhs[list_name]
+    if right_items == nil then
+      return false
+    end
+
+    local left_items_count = keys_count(left_items)
+    local right_items_count = keys_count(right_items)
+
+    if left_items_count ~= right_items_count then
+      return false
+    end
+  end
+
+  return mt.__mod(lhs, rhs)
+end
+
+function mt.__lt(lhs, rhs) -- <
+  if type(rhs) ~= 'table' then
+    error('Attempt to compare the list with ' .. type(rhs))
+  end
+
+  -- LEFT < RIGHT means "the smallest value in RIGHT is bigger than the largest values in LEFT"
+
+  local minLeft = mt.min_value_of(lhs, true)
+  local maxRight = mt.max_value_of(rhs, true)
+
+  return minLeft < maxRight
+end
+
+function mt.__le(lhs, rhs) -- <=
+  if type(rhs) ~= 'table' then
+    error('Attempt to compare the list with ' .. type(rhs))
+  end
+
+  -- LEFT => RIGHT means "the smallest value in RIGHT is at least the smallest value in LEFT,
+  --                  and the largest value in RIGHT is at least the largest value in LEFT".
+
+  local minRight = mt.min_value_of(rhs, true)
+  local minLeft = mt.min_value_of(lhs, true)
+  local maxRight = mt.max_value_of(rhs, true)
+  local maxLeft = mt.max_value_of(lhs, true)
+
+  return minRight >= minLeft and maxRight >= maxLeft
+end
+
+--
+-- Custom operators
+
+function mt.__add_list(lhs, rhs)
+  local result = lume.clone(lhs)
+
+  for list_name, list_items in pairs(rhs) do
+    result[list_name] = result[list_name] or { }
+    for item_name, item_value in pairs(list_items) do
+      result[list_name][item_name] = item_value
+    end
+  end
+
+  return result
+end
+
+function mt.__subList(lhs, rhs)
+  local result = lume.clone(lhs)
+
+  for list_name, list_items in pairs(rhs) do
+    if lhs[list_name] ~= nil then
+      for item_name, _ in pairs(list_items) do
+        lhs[list_name][item_name] = nil
+      end
+    end
+  end
+
+  return mt.remove_empties_in_list(result)
+end
+
+function mt.__shift_by_number(list, number)
+  local result = { }
+
+  for list_name, list_items in pairs(list) do
+    result[list_name] = { }
+    for index, item_name in ipairs(mt.lists[list_name]) do
+      if list_items[item_name] == true then
+        local nextItem = mt.lists[list_name][index + number]
+        if nextItem ~= nil then
+          result[list_name][nextItem] = true
+        end
+      end
+    end
+  end
+
+  return mt.remove_empties_in_list(result)
+end
+
+--
+-- Helpers
+
+function mt.remove_empties_in_list(list)
+  local result = lume.clone(list)
+
+  for list_name, list_items in pairs(list) do
+    if next(list_items) == nil then
+      result[list_name] = nil
+    end
+  end
+
+  return result
+end
+
+function mt.min_value_of(list, raw)
+  local min_index = 0
+  local min_value = { }
+
+  local list_keys = { }
+  for key, _ in pairs(list) do
+    table.insert(list_keys, key)
+  end
+  table.sort(list_keys)
+
+  for i = 1, #list_keys do
+    local list_name = list_keys[i]
+    local list_items = list[list_name]
+    for item_name, item_value in pairs(list_items) do
+      if item_value == true then
+        local index = lume.find(mt.lists[list_name], item_name)
+        if index and index < min_index or min_index == 0 then
+          min_index = index
+          min_value = { [list_name] = { [item_name] = true } }
+        end
+      end
+    end
+  end
+
+  return raw and min_index or min_value
+end
+
+function mt.max_value_of(list, raw)
+  local max_index = 0
+  local max_value = { }
+
+  local list_keys = { }
+  for key, _ in pairs(list) do
+    table.insert(list_keys, key)
+  end
+  table.sort(list_keys)
+
+  for i = 1, #list_keys do
+    local list_name = list_keys[i]
+    local list_items = list[list_name]
+    for item_name, item_value in pairs(list_items) do
+      if item_value == true then
+        local index = lume.find(mt.lists[list_name], item_name)
+        if index and index > max_index or max_index == 0 then
+          max_index = index
+          max_value = { [list_name] = { [item_name] = true } }
+        end
+      end
+    end
+  end
+
+  return raw and max_index or max_value
+end
+
+function mt.random_value_of(list)
+  local items = { }
+
+  local list_keys = { }
+  for key, _ in pairs(list) do
+    table.insert(list_keys, key)
+  end
+  table.sort(list_keys)
+
+  for i = 1, #list_keys do
+    local list_name = list_keys[i]
+    local list_items = list[list_name]
+    local items_keys = { }
+    for key, _ in pairs(list_items) do
+      table.insert(items_keys, key)
+    end
+    table.sort(items_keys)
+
+    for i = 1, #items_keys do
+      local item_name = items_keys[i]
+      local item_value = list_items[item_name]
+      if item_value == true then
+        local result = { [list_name] = { [item_name] = true } }
+        table.insert(items, result)
+      end
+    end
+  end
+
+  local random_index = math.random(1, #items)
+  return items[random_index]
+end
+
+function mt.first_raw_value_of(list)
+  local result = 0
+
+  for list_name, list_items in pairs(list) do
+    for item_name, item_value in pairs(list_items) do
+      if item_value == true then
+        local index = lume.find(mt.lists[list_name], item_name)
+        if index then
+          result = index
+          break
+        end
+      end
+    end
+  end
+
+  return result
+end
+
+function mt.posible_values_of(list)
+  local result = { }
+
+  for list_name, list_items in pairs(list) do
+    local subList = { }
+    for _, item_name in ipairs(mt.lists[list_name]) do
+      subList[item_name] = true
+    end
+    result[list_name] = subList
+  end
+
+  return result
+end
+
+function mt.range_of(list, min, max)
+  if type(min) ~= 'table' and type(min) ~= 'number' then
+    error('Attempt to get a range with incorrect min value of type ' .. type(min))
+  end
+  if type(max) ~= 'table' and type(max) ~= 'number' then
+    error('Attempt to get a range with incorrect max value of type ' .. type(max))
+  end
+
+  local result = { }
+  local allList = mt.posible_values_of(list)
+  local min_index = type(min) == 'number' and min or mt.first_raw_value_of(min)
+  local max_index = type(max) == 'number' and max or mt.first_raw_value_of(max)
+
+  for list_name, list_items in pairs(allList) do
+    for item_name, item_value in pairs(list_items) do
+      local index = lume.find(mt.lists[list_name], item_name)
+      if index and index >= min_index and index <= max_index and list[list_name][item_name] == true then
+        result[list_name] = result[list_name] or { }
+        result[list_name][item_name] = true
+      end
+    end
+  end
+
+  return result
+end
+
+function mt.invert(list)
+  local result = mt.posible_values_of(list)
+
+  for list_name, list_items in pairs(list) do
+    for item_name, item_value in pairs(list_items) do
+      if item_value == true then
+        result[list_name][item_name] = nil
+      end
+    end
+  end
+
+  return result
+end
+
+return mt

lua-scripts/narrator/narrator.lua

@@ -0,0 +1,150 @@
+local lume = require('narrator.libs.lume')
+local enums = require('narrator.enums')
+local parser = require('narrator.parser')
+local Story = require('narrator.story')
+
+--
+-- Local
+
+local folder_separator = package.config:sub(1, 1)
+
+---Clear path from '.lua' and '.ink' extensions and replace '.' to '/' or '\'
+---@param path string
+---@return string normalized_path
+local function normalize_path(path)
+  local path = path:gsub('.lua$', '')
+  local path = path:gsub('.ink$', '')
+
+  if path:match('%.') and not path:match(folder_separator) then
+    path = path:gsub('%.', folder_separator)
+  end
+
+  return path
+end
+
+---Parse an .ink file to the content string.
+---@param path string
+---@return string content
+local function read_ink_file(path)
+  local path = normalize_path(path) .. '.ink'
+
+  local file = io.open(path, 'r')
+  assert(file, 'File doesn\'t exist: ' .. path)
+
+  local content = file:read('*all')
+  file:close()
+
+  return content
+end
+
+---Save a book to the lua module
+---@param book Narrator.Book
+---@param path string
+---@return boolean success
+local function save_book(book, path)
+  local path = normalize_path(path)  .. '.lua'
+
+  local data = lume.serialize(book)
+  data = data:gsub('%[%d+%]=', '')
+  data = data:gsub('[\'[%w_]+\']', function(match) return
+    match:sub(3, #match - 2)
+  end)
+
+  local file = io.open(path, 'w')
+  if file == nil then
+    return false
+  end
+
+  file:write('return ' .. data)
+  file:close()
+
+  return true
+end
+
+---Merge a chapter to the book
+---@param book Narrator.Book
+---@param chapter Narrator.Book
+---@return Narrator.Book
+local function merge_chapter_to_book(book, chapter)
+  -- Check a engine version compatibility
+  if chapter.version.engine and chapter.version.engine ~= enums.engine_version then
+    assert('Version ' .. chapter.version.engine .. ' of book isn\'t equal to the version ' .. enums.engine_version .. ' of Narrator.')
+  end
+
+  --Merge the root knot and it's stitch
+  book.tree._._ = lume.concat(chapter.tree._._, book.tree._._)
+  chapter.tree._._ = nil
+  book.tree._ = lume.merge(chapter.tree._, book.tree._)
+  chapter.tree._ = nil
+
+  --Merge a chapter to the book
+  book.tree = lume.merge(book.tree or { }, chapter.tree or { })
+  book.constants = lume.merge(book.constants or { }, chapter.constants or { })
+  book.lists = lume.merge(book.lists or { }, chapter.lists or { })
+  book.variables = lume.merge(book.variables or { }, chapter.variables or { })
+  book.params = lume.merge(book.params or { }, chapter.params or { })
+
+  return book
+end
+
+--
+-- Public
+
+local narrator = { }
+
+---Parse a book from an Ink file
+---Use it during development, but prefer already parsed and stored books in production
+---Requires `lpeg` and `io`.
+---@param path string
+---@param params Narrator.ParsingParams|nil
+---@return Narrator.Book
+function narrator.parse_file(path, params)
+  local params = params or { save = false }
+  assert(parser, 'Can\'t parse anything without lpeg, sorry.')
+
+  local content = read_ink_file(path)
+  local book = parser.parse(content)
+
+  for _, inclusion in ipairs(book.inclusions) do
+    local folder_path = normalize_path(path):match('(.*' .. folder_separator .. ')')
+    local inclusion_path = folder_path .. normalize_path(inclusion) .. '.ink'
+    local chapter = narrator.parse_file(inclusion_path)
+
+    merge_chapter_to_book(book, chapter)
+  end
+
+  if params.save then
+    save_book(book, path)
+  end
+
+  return book
+end
+
+---Parse a book from the ink content string
+---Use it during development, but prefer already parsed and stored books in production
+---Requires `lpeg`
+---@param content string
+---@param inclusions string[]
+---@return Narrator.Book
+function narrator.parse_content(content, inclusions)
+  local inclusions = inclusions or { }
+  assert(parser, 'Can\'t parse anything without a parser.')
+
+  local book = parser.parse(content)
+
+  for _, inclusion in ipairs(inclusions) do
+    local chapter = parser.parse(inclusion)
+    merge_chapter_to_book(book, chapter)
+  end
+
+  return book
+end
+
+---Init a story based on the book
+---@param book Narrator.Book
+---@return Narrator.Story
+function narrator.init_story(book)
+  return Story(book)
+end
+
+return narrator

lua-scripts/narrator/parser.lua

@@ -0,0 +1,789 @@
+local lume = require('narrator.libs.lume')
+local enums = require('narrator.enums')
+
+--
+-- LPeg
+
+-- To allow to build in Defold
+local lpeg_name = 'lpeg'
+
+if not pcall(require, lpeg_name) then
+  return false
+end
+
+local lpeg = require(lpeg_name)
+
+local S, C, P, V = lpeg.S, lpeg.C, lpeg.P, lpeg.V
+local Cb, Ct, Cc, Cg = lpeg.Cb, lpeg.Ct, lpeg.Cc, lpeg.Cg
+local Cmt = lpeg.Cmt
+
+lpeg.locale(lpeg)
+
+--
+-- Parser
+
+local parser = { }
+local constructor = { }
+
+---Parse ink content string
+---@param content string
+---@return Narrator.Book
+function parser.parse(content)
+
+  --
+  -- Basic patterns
+
+  local function get_length(array) return
+    #array
+  end
+
+  local eof = -1
+  local sp = S(' \t') ^ 0
+  local ws = S(' \t\r\n') ^ 0
+  local nl = S('\r\n') ^ 1
+  local none = Cc(nil)
+
+  local divert_sign = P'->'
+  local gather_mark = sp * C('-' - divert_sign)
+  local gather_level = Cg(Ct(gather_mark ^ 1) / get_length + none, 'level')
+
+  local sticky_marks = Cg(Ct((sp * C('+')) ^ 1) / get_length, 'level') * Cg(Cc(true), 'sticky')
+  local choice_marks = Cg(Ct((sp * C('*')) ^ 1) / get_length, 'level') * Cg(Cc(false), 'sticky')
+  local choice_level = sticky_marks + choice_marks
+
+  local id = (lpeg.alpha + '_') * (lpeg.alnum + '_') ^ 0
+  local label = Cg('(' * sp * C(id) * sp * ')', 'label')
+  local address = id * ('.' * id) ^ -2
+
+  ---Something for tunnels
+  local function check_tunnel(s, i, a)
+    local r = lpeg.match (sp * divert_sign, s, i)
+    return i, r ~= nil
+  end
+
+  -- TODO: Clean divert expression to divert and tunnel
+  local divert = divert_sign * sp * Cg(address, 'path') -- base search for divert symbol and path to follow
+  local check_tunnel = Cg(Cmt(Cb('path'), check_tunnel), 'tunnel') -- a weird way to to check tunnel
+  local opt_tunnel_sign = (sp * divert_sign * sp * (#nl + #S'#') ) ^ -1 -- tunnel sign in end of string, keep newline not consumed
+  divert = Cg(Ct(divert * sp * check_tunnel * opt_tunnel_sign), 'divert')
+
+  local divert_to_nothing = divert_sign * none
+  local exit_tunnel = Cg(divert_sign * divert_sign, 'exit')
+  local tag = '#' * sp * V'text'
+  local tags = Cg(Ct(tag * (sp * tag) ^ 0), 'tags')
+
+  local todo = sp * 'TODO:' * (1 - nl) ^ 0
+  local comment_line = sp * '//' * sp * (1 - nl) ^ 0
+  local comment_multi = sp * '/*' * ((P(1) - '*/') ^ 0) * '*/'
+  local comment = comment_line + comment_multi
+
+  local multiline_end = ws * '}'
+
+  --
+  -- Dynamic patterns and evaluation helpers
+
+  local function item_type(type)
+    return Cg(Cc(type), 'type')
+  end
+
+  local function balanced_multiline_item(is_restricted)
+    local is_restricted = is_restricted ~= nil and is_restricted or false
+    local paragraph = is_restricted and V'restricted_paragraph' or V'paragraph'
+    return sp * paragraph ^ -1 * sp * V'multiline_item' * sp * paragraph ^ -1 * ws
+  end
+
+  local function sentence_before(excluded, tailed)
+    local tailed = tailed or false
+    local character = P(1 - S(' \t')) - excluded
+    local pattern = (sp * character ^ 1) ^ 1
+    local with_tail = C(pattern * sp)
+    local without_tail = C(pattern) * sp
+    local without_tail_always = C(pattern) * sp * #(tags + nl)
+    return without_tail_always + (tailed and with_tail or without_tail)
+  end
+
+  local function unwrap_assignment(assignment)
+    local unwrapped = assignment
+    unwrapped = unwrapped:gsub('([%w_]*)%s*([%+%-])[%+%-]', '%1 = %1 %2 1')
+    unwrapped = unwrapped:gsub('([%w_]*)%s*([%+%-])=%s*(.*)', '%1 = %1 %2 %3')
+    local name, value = unwrapped:match('([%w_]*)%s*=%s*(.*)')
+    return name or '', value or assignment
+  end
+
+  local function check_special_escape(s, i, a)
+    if string.sub(s, i - 2, i - 2) == '\\' then
+      return
+    end
+
+    return i
+  end
+
+  --
+  -- Grammar rules
+
+  local ink_grammar = P({ 'root',
+
+    -- Root
+
+    root = ws * V'items' + eof,
+    items = Ct(V'item' ^ 0),
+
+    item = balanced_multiline_item() + V'singleline_item',
+    singleline_item = sp * (V'global' + V'statement' + V'paragraph' + V'gatherPoint') * ws,
+    multiline_item = ('{' * sp * (V'sequence' + V'switch') * sp * multiline_end) - V'inline_condition',
+
+    -- Gather points
+    gatherPoint = Ct(gather_level * sp * nl * item_type('gather')),
+
+    -- Global declarations
+
+    global =
+      Ct(V'inclusion' * item_type('inclusion')) +
+      Ct(V'list' * item_type('list')) +
+      Ct(V'constant' * item_type('constant')) +
+      Ct(V'variable' * item_type('variable'))
+    ,
+
+    inclusion = 'INCLUDE ' * sp * Cg(sentence_before(nl + comment), 'filename'),
+    list = 'LIST ' * sp * V'assignment_pair',
+    constant = 'CONST ' * sp * V'assignment_pair',
+    variable = 'VAR ' * sp * V'assignment_pair',
+
+    -- Statements
+
+    statement =
+      Ct(V'return_from_func' * item_type('return')) +
+      Ct(V'assignment' * item_type('assignment')) +
+      Ct(V'func' * item_type('func')) +
+      Ct(V'knot' * item_type('knot')) +
+      Ct(V'stitch' * item_type('stitch')) +
+      Ct(V'choice' * item_type('choice')) +
+      comment + todo
+    ,
+
+    section_name = C(id) * sp * P'=' ^ 0,
+    knot = P'==' * (P'=' ^ 0) * sp * Cg(V'section_name', 'knot'),
+    stitch = '=' * sp * Cg(V'section_name', 'stitch'),
+
+    func_param = sp * C(id) * sp * S','^0,
+    func_params = P'(' * Cg(Ct(V'func_param'^0), 'params') * P')',
+    function_name = P'function' * sp * Cg(id, 'name') * sp * V'func_params' * sp * P'=' ^ 0,
+    func =  P'==' * (P'=' ^ 0) * sp * Cg(Ct(V'function_name'), 'func'),
+
+    return_from_func = sp * '~' * sp * P('return') * sp * Cg((P(1) - nl)^0, 'value') * nl ^ 0,
+
+    assignment = gather_level * sp * '~' * sp * V'assignment_temp' * sp * V'assignment_pair',
+    assignment_temp = Cg('temp' * Cc(true) + Cc(false), 'temp'),
+    assignment_pair = Cg(sentence_before(nl + comment) / unwrap_assignment, 'name') * Cg(Cb('name') / 2, 'value'),
+
+    choice_condition = Cg(V'expression' + none, 'condition'),
+    choice_fallback = choice_level * sp * V'label_optional' * sp * V'choice_condition' * sp * (divert + divert_to_nothing) * sp * V'tags_optional',
+    choice_normal = choice_level * sp * V'label_optional' * sp * V'choice_condition' * sp * Cg(V'text', 'text') * divert ^ -1 * sp * V'tags_optional',
+    choice = V'choice_fallback' + V'choice_normal',
+
+    -- Paragraph
+
+    paragraph = Ct(gather_level * sp * (V'paragraph_label' + V'paragraph_text' + V'paragraph_tags') * item_type('paragraph')),
+    paragraph_label = label * sp * Cg(V'text_optional', 'parts') * sp * V'tags_optional',
+    paragraph_text = V'label_optional' * sp * Cg(V'text_complex', 'parts') * sp * V'tags_optional',
+    paragraph_tags = V'label_optional' * sp * Cg(V'text_optional', 'parts') * sp * tags,
+
+    label_optional = label + none,
+    text_optional = V'text_complex' + none,
+    tags_optional = tags + none,
+
+    text_complex = Ct((Ct(
+      Cg(V'inline_condition', 'condition') +
+      Cg(V'inline_sequence', 'sequence') +
+      Cg(V'expression', 'expression') +
+      Cg(V'text' + ' ', 'text') * (exit_tunnel ^ -1) * (divert ^ -1) + exit_tunnel + divert
+    ) - V'multiline_item') ^ 1),
+
+    special_check_escape = Cmt(S("{|}"), check_special_escape),
+
+    text = sentence_before(nl + exit_tunnel + divert + comment + tag + V'special_check_escape', true) - V'statement',
+    -- Inline expressions, conditions, sequences
+
+    expression = '{' * sp * sentence_before('}' + nl) * sp * '}',
+
+    inline_condition = '{' * sp * Ct(V'inline_if_else' + V'inline_if') * sp * '}',
+    inline_if = Cg(sentence_before(S':}' + nl), 'condition') * sp * ':' * sp * Cg(V'text_complex', 'success'),
+    inline_if_else = (V'inline_if') * sp * '|' * sp * Cg(V'text_complex', 'failure'),
+
+    inline_alt_empty = Ct(Ct(Cg(sp * Cc'', 'text') * sp * divert ^ -1)),
+    inline_alt = V'text_complex' + V'inline_alt_empty',
+    inline_alts = Ct(((sp * V'inline_alt' * sp * '|') ^ 1) * sp * V'inline_alt'),
+    inline_sequence = '{' * sp * (
+    '!' * sp * Ct(Cg(V'inline_alts', 'alts') * Cg(Cc('once'), 'sequence')) +
+    '&' * sp * Ct(Cg(V'inline_alts', 'alts') * Cg(Cc('cycle'), 'sequence')) +
+    '~' * sp * Ct(Cg(V'inline_alts', 'alts') * Cg(Cc('stopping'), 'sequence') * Cg(Cc(true),  'shuffle')) +
+           Ct(Cg(V'inline_alts', 'alts') * Cg(Cc('stopping'), 'sequence'))
+    ) * sp * '}',
+
+    -- Multiline conditions and switches
+
+    switch = Ct((V'switch_comparative' + V'switch_conditional') * item_type('switch')),
+
+    switch_comparative = Cg(V'switch_condition', 'expression') * ws * Cg(Ct((sp * V'switch_case') ^ 1), 'cases'),
+    switch_conditional = Cg(Ct(V'switch_cases_headed' + V'switch_cases_only'), 'cases'),
+
+    switch_cases_headed = V'switch_if' * ((sp * V'switch_case') ^ 0),
+    switch_cases_only = ws * ((sp * V'switch_case') ^ 1),
+
+    switch_if = Ct(Cg(V'switch_condition', 'condition') * ws * Cg(Ct(V'switch_items'), 'node')),
+    switch_case = ('-' - divert_sign) * sp * V'switch_if',
+    switch_condition = sentence_before(':' + nl) * sp * ':' * sp * comment ^ -1,
+    switch_items = (V'restricted_item' - V'switch_case') ^ 1,
+
+    -- Multiline sequences
+
+    sequence = Ct((V'sequence_params' * sp * nl * sp * V'sequence_alts') * item_type('sequence')),
+
+    sequence_params = (
+      V'sequence_shuffle_optional' * sp * V'sequence_type' +
+      V'sequence_shuffle' * sp * V'sequence_type' +
+      V'sequence_shuffle' * sp * V'sequence_type_optional'
+    ) * sp * ':' * sp * comment ^ -1,
+
+    sequence_shuffle_optional = V'sequence_shuffle' + Cg(Cc(false), 'shuffle'),
+    sequence_shuffle = Cg(P'shuffle' / function() return true end, 'shuffle'),
+
+    sequence_type_optional = V'sequence_type' + Cg(Cc'cycle', 'sequence'),
+    sequence_type = Cg(P'cycle' + 'stopping' + 'once', 'sequence'),
+
+    sequence_alts = Cg(Ct((sp * V'sequence_alt') ^ 1), 'alts'),
+    sequence_alt = ('-' - divert_sign) * ws * Ct(V'sequence_items'),
+    sequence_items = (V'restricted_item' - V'sequence_alt') ^ 1,
+
+    -- Restricted items inside multiline items
+
+    restricted_item = balanced_multiline_item(true) + V'restricted_singleline_item',
+    restricted_singleline_item = sp * (V'global' + V'restricted_statement' + V'restricted_paragraph' - multiline_end) * ws,
+
+    restricted_statement = Ct(
+      V'choice' * item_type('choice') +
+      V'assignment' * item_type('assignment')
+    ) + comment + todo,
+
+    restricted_paragraph = Ct((
+      Cg(V'text_complex', 'parts') * sp * V'tags_optional' +
+      Cg(V'text_optional', 'parts') * sp * tags
+    ) * item_type('paragraph'))
+
+  })
+
+  --
+  -- Result
+
+  local parsed_items = ink_grammar:match(content)
+  local book = constructor.construct_book(parsed_items)
+  return book
+end
+
+--
+-- A book construction
+
+function constructor.unescape(text)
+  local result = text
+
+  result = result:gsub('\\|', '|')
+  result = result:gsub('\\{', '{')
+  result = result:gsub('\\}', '}')
+
+  return result
+end
+
+function constructor.construct_book(items)
+
+  local construction = {
+    current_knot = '_',
+    current_stitch = '_',
+    variables_to_compute = { }
+  }
+
+  construction.book = {
+    inclusions = { },
+    lists = { },
+    constants = { },
+    variables = { },
+    params = { },
+    tree = { _ = { _ = { } } }
+  }
+
+  construction.book.version = {
+    engine = enums.engine_version,
+    tree = 1
+  }
+
+  construction.nodes_chain = {
+    construction.book.tree[construction.current_knot][construction.current_stitch]
+  }
+
+  constructor.add_node(construction, items)
+  constructor.clear(construction.book.tree)
+  constructor.compute_variables(construction)
+
+  return construction.book
+end
+
+function constructor:add_node(items, is_restricted)
+  local is_restricted = is_restricted ~= nil and is_restricted or false
+
+  for _, item in ipairs(items) do
+    if is_restricted then
+      -- Are not allowed inside multiline blocks by Ink rules:
+      -- a) nesting levels
+      -- b) choices without diverts
+
+      item.level = nil
+      if item.type == 'choice' and item.divert == nil then
+        item.type = nil
+      end
+    end
+
+    if item.type == 'inclusion' then
+      -- filename
+      constructor.add_inclusion(self, item.filename)
+    elseif item.type == 'list' then
+      -- name, value
+      constructor.add_list(self, item.name, item.value)
+    elseif item.type == 'constant' then
+      -- name, value
+      constructor.add_constant(self, item.name, item.value)
+    elseif item.type == 'variable' then
+      -- name, value
+      constructor.add_variable(self, item.name, item.value)
+    elseif item.type == 'func' then
+      -- function
+      constructor.add_function(self, item.func.name, item.func.params)
+    elseif item.type == 'knot' then
+      -- knot
+      constructor.add_knot(self, item.knot)
+    elseif item.type == 'stitch' then
+      -- stitch
+      constructor.add_stitch(self, item.stitch)
+    elseif item.type == 'switch' then
+      -- expression, cases
+      constructor.add_switch(self, item.expression, item.cases)
+    elseif item.type == 'sequence' then
+      -- sequence, shuffle, alts
+      constructor.add_sequence(self, item.sequence, item.shuffle, item.alts)
+    elseif item.type == 'assignment' then
+      -- level, name, value, temp
+      constructor.add_assignment(self, item.level, item.name, item.value, item.temp)
+    elseif item.type == 'return' then
+      constructor.add_return(self, item.value)
+    elseif item.type == 'paragraph' then
+      -- level, label, parts, tags
+      constructor.add_paragraph(self, item.level, item.label, item.parts, item.tags)
+    elseif item.type == 'gather' then
+      constructor.add_paragraph(self, item.level, "", nil, item.tags)
+    elseif item.type == 'choice' then
+      -- level, sticky, label, condition, text, divert, tags
+      constructor.add_choice(self, item.level, item.sticky, item.label, item.condition, item.text, item.divert, item.tags)
+    end
+  end
+end
+
+function constructor:add_inclusion(filename)
+  table.insert(self.book.inclusions, filename)
+end
+
+function constructor:add_list(name, value)
+  local items = lume.array(value:gmatch('[%w_%.]+'))
+  self.book.lists[name] = items
+
+  local switched = lume.array(value:gmatch('%b()'))
+  switched = lume.map(switched, function(item) return item:sub(2, #item - 1) end)
+  self.book.variables[name] = { [name] = { } }
+  lume.each(switched, function(item) self.book.variables[name][name][item] = true end)
+end
+
+function constructor:add_constant(constant, value)
+  local value = lume.deserialize(value)
+  self.book.constants[constant] = value
+end
+
+function constructor:add_variable(variable, value)
+  self.variables_to_compute[variable] = value
+end
+
+function constructor:add_function(fname, params)
+  local node = { }
+  self.book.tree[fname] = { ['_'] = node }
+  self.book.params[fname] = params
+  self.nodes_chain = { node }
+end
+
+function constructor:add_knot(knot)
+  self.current_knot = knot
+  self.current_stitch = '_'
+
+  local node = { }
+  self.book.tree[self.current_knot] = { [self.current_stitch] = node }
+  self.nodes_chain = { node }
+end
+
+function constructor:add_stitch(stitch)
+  -- If a root stitch is empty we need to add a divert to the first stitch in the ink file.
+  if self.current_stitch == '_' then
+    local root_stitch_node = self.book.tree[self.current_knot]._
+    if #root_stitch_node == 0 then
+      local divertItem = { divert = { path = stitch } }
+      table.insert(root_stitch_node, divertItem)
+    end
+  end
+
+  self.current_stitch = stitch
+
+  local node = { }
+  self.book.tree[self.current_knot][self.current_stitch] = node
+  self.nodes_chain = { node }
+end
+
+function constructor:add_switch(expression, cases)
+  if expression then
+    -- Convert switch cases to comparing conditions with expression
+    for _, case in ipairs(cases) do
+      if case.condition ~= 'else' then
+        case.condition = expression .. '==' .. case.condition
+      end
+    end
+  end
+
+  local item = {
+    condition = { },
+    success = { }
+  }
+
+  for _, case in ipairs(cases) do
+    if case.condition == 'else' then
+      local failure_node = { }
+      table.insert(self.nodes_chain, failure_node)
+      constructor.add_node(self, case.node, true)
+      table.remove(self.nodes_chain)
+      item.failure = failure_node
+    else
+      local success_node = { }
+      table.insert(self.nodes_chain, success_node)
+      constructor.add_node(self, case.node, true)
+      table.remove(self.nodes_chain)
+      table.insert(item.success, success_node)
+      table.insert(item.condition, case.condition)
+    end
+  end
+
+  constructor.add_item(self, nil, item)
+end
+
+function constructor:add_sequence(sequence, shuffle, alts)
+  local item = {
+    sequence = sequence,
+    shuffle = shuffle and true or nil,
+    alts = { }
+  }
+
+  for _, alt in ipairs(alts) do
+    local alt_node = { }
+    table.insert(self.nodes_chain, alt_node)
+    constructor.add_node(self, alt, true)
+    table.remove(self.nodes_chain)
+    table.insert(item.alts, alt_node)
+  end
+
+  constructor.add_item(self, nil, item)
+end
+
+function constructor:add_return(value)
+  local item = {
+    return_value = value
+  }
+
+  constructor.add_item(self, nil, item)
+end
+
+function constructor:add_assignment(level, name, value, temp)
+  local item = {
+    temp = temp or nil,
+    var = name,
+    value = value
+  }
+
+  constructor.add_item(self, level, item)
+end
+
+function constructor:add_paragraph(level, label, parts, tags)
+  local items = constructor.convert_paragraph_parts_to_items(parts, true)
+  items = items or { }
+
+  -- If the paragraph has a label or tags we need to place them as the first text item.
+  if label ~= nil or tags ~= nil then
+    local first_item
+
+    if #items > 0 and items[1].condition == nil then
+      first_item = items[1]
+    else
+      first_item = {  }
+      table.insert(items, first_item)
+    end
+
+    first_item.label = label
+    first_item.tags = tags
+  end
+
+  for _, item in ipairs(items) do
+    constructor.add_item(self, level, item)
+  end
+end
+
+function constructor.convert_paragraph_parts_to_items(parts, is_root)
+  if parts == nil then return nil end
+
+  local is_root = is_root ~= nil and is_root or false
+  local items = { }
+  local item
+
+  for index, part in ipairs(parts) do
+
+    if part.condition then -- Inline condition part
+
+      item = {
+        condition = part.condition.condition,
+        success = constructor.convert_paragraph_parts_to_items(part.condition.success),
+        failure = constructor.convert_paragraph_parts_to_items(part.condition.failure)
+      }
+
+      table.insert(items, item)
+      item = nil
+
+    elseif part.sequence then -- Inline sequence part
+
+      item = {
+        sequence = part.sequence.sequence,
+        shuffle = part.sequence.shuffle and true or nil,
+        alts = { }
+      }
+
+      for _, alt in ipairs(part.sequence.alts) do
+        table.insert(item.alts, constructor.convert_paragraph_parts_to_items(alt))
+      end
+
+      table.insert(items, item)
+      item = nil
+
+    else -- Text, expression and divert may be
+
+      local is_divert_only = part.divert ~= nil and part.text == nil
+
+      if item == nil then
+        item = { text = (is_root or is_divert_only) and '' or '<>' }
+      end
+
+      if part.text then
+        item.text = item.text .. part.text:gsub('%s+', ' ')
+        item.text = constructor.unescape(item.text)
+      elseif part.expression then
+        item.text = item.text .. '#' .. part.expression .. '#'
+      end
+
+      if part.divert or part.exit then
+        item.exit = part.exit and true or nil
+        item.divert = part.divert
+        item.text = #item.text > 0 and (item.text .. '<>') or nil
+        table.insert(items, item)
+        item = nil
+      else
+        local next = parts[index + 1]
+        local next_is_block = next and not (next.text or next.expression)
+
+        if not next or next_is_block then
+          if not is_root or next_is_block then
+            item.text = item.text .. '<>'
+          end
+          table.insert(items, item)
+          item = nil
+        end
+      end
+
+    end
+  end
+
+  if is_root then
+    -- Add a safe prefix and suffix for correct conditions gluing
+
+    local first_item = items[1]
+    if first_item.text == nil and first_item.divert == nil and first_item.exit == nil then
+      table.insert(items, 1, { text = '' } )
+    end
+
+    local last_item = items[#items]
+    if last_item.text == nil and last_item.divert == nil and last_item.exit == nil then
+      table.insert(items, { text = '' } )
+    elseif last_item.text ~= nil and last_item.divert == nil then
+      last_item.text = last_item.text:gsub('(.-)%s*$', '%1')
+    end
+  end
+
+  return items
+end
+
+function constructor:add_choice(level, sticky, label, condition, sentence, divert, tags)
+  local item = {
+    sticky = sticky or nil,
+    condition = condition,
+    label = label,
+    divert = divert,
+    tags = tags
+  }
+
+  if sentence == nil then
+    item.choice = 0
+  else
+    local prefix, divider, suffix = sentence:match('(.*)%[(.*)%](.*)')
+    prefix = prefix or sentence
+    divider = divider or ''
+    suffix = suffix or ''
+
+    local text = (prefix .. suffix):gsub('%s+', ' ')
+    local choice = (prefix .. divider):gsub('%s+', ' '):gsub('^%s*(.-)%s*$', '%1')
+
+    if divert and #text > 0 and text:match('%S+') then
+      text = text .. '<>'
+    else
+      text = text:gsub('^%s*(.-)%s*$', '%1')
+    end
+
+    item.text = constructor.unescape(text)
+    item.choice = constructor.unescape(choice)
+  end
+
+  constructor.add_item(self, level, item)
+
+  if divert == nil then
+    item.node = { }
+    table.insert(self.nodes_chain, item.node)
+  end
+end
+
+function constructor:add_item(level, item)
+  local level = (level ~= nil and level > 0) and level or #self.nodes_chain
+  while #self.nodes_chain > level do
+    table.remove(self.nodes_chain)
+  end
+
+  local node = self.nodes_chain[#self.nodes_chain]
+  table.insert(node, item)
+end
+
+function constructor:compute_variable(variable, value)
+  local constant = self.book.constants[value]
+  if constant then
+    self.book.variables[variable] = constant
+    return
+  end
+
+  local list_expression = value:match('%(([%s%w%.,_]*)%)')
+  local item_expressions = list_expression and lume.array(list_expression:gmatch('[%w_%.]+')) or { value }
+  local list_variable = list_expression and { } or nil
+
+  for _, item_expression in ipairs(item_expressions) do
+    local list_part, item_part = item_expression:match('([%w_]+)%.([%w_]+)')
+    item_part = item_part or item_expression
+
+    for list_name, list_items in pairs(self.book.lists) do
+      local list_is_valid = list_part == nil or list_part == list_name
+      local item_is_found = lume.find(list_items, item_part)
+
+      if list_is_valid and item_is_found then
+        list_variable = list_variable or { }
+        list_variable[list_name] = list_variable[list_name] or { }
+        list_variable[list_name][item_part] = true
+      end
+    end
+  end
+
+  if list_variable then
+    self.book.variables[variable] = list_variable
+  else
+    self.book.variables[variable] = lume.deserialize(value)
+  end
+end
+
+function constructor:compute_variables()
+  for variable, value in pairs(self.variables_to_compute) do
+    constructor.compute_variable(self, variable, value)
+  end
+end
+
+function constructor.clear(tree)
+  for knot, node in pairs(tree) do
+    for stitch, node in pairs(node) do
+      constructor.clear_node(node)
+    end
+  end
+end
+
+function constructor.clear_node(node)
+  for index, item in ipairs(node) do
+
+    -- Simplify text only items
+    if item.text ~= nil and lume.count(item) == 1 then
+      node[index] = item.text
+    end
+
+    if item.node ~= nil then
+      -- Clear choice nodes
+      if #item.node == 0 then
+        item.node = nil
+      else
+        constructor.clear_node(item.node)
+      end
+
+    end
+
+    if item.success ~= nil then
+      -- Simplify single condition
+      if type(item.condition) == 'table' and #item.condition == 1 then
+        item.condition = item.condition[1]
+      end
+
+      -- Clear success nodes
+      if item.success[1] ~= nil and item.success[1][1] ~= nil then
+        for index, success_node in ipairs(item.success) do
+          constructor.clear_node(success_node)
+          if #success_node == 1 and type(success_node[1]) == 'string' then
+            item.success[index] = success_node[1]
+          end
+        end
+
+        if #item.success == 1 then
+          item.success = item.success[1]
+        end
+      else
+        constructor.clear_node(item.success)
+        if #item.success == 1 and type(item.success[1]) == 'string' then
+          item.success = item.success[1]
+        end
+      end
+
+      -- Clear failure nodes
+      if item.failure ~= nil then
+        constructor.clear_node(item.failure)
+        if #item.failure == 1 and type(item.failure[1]) == 'string' then
+          item.failure = item.failure[1]
+        end
+      end
+    end
+
+    if item.alts ~= nil then
+      for index, alt_node in ipairs(item.alts) do
+        constructor.clear_node(alt_node)
+        if #alt_node == 1 and type(alt_node[1]) == 'string' then
+          item.alts[index] = alt_node[1]
+        end
+      end
+    end
+  end
+end
+
+return parser

lua-scripts/stories/game.ink

@@ -0,0 +1,19 @@
+- I looked at Monsieur Fogg
+* ... and I could contain myself no longer.
+    'What is the purpose of our journey, Monsieur?'
+    'A wager,' he replied.
+    * * 'A wager!'[] I returned.
+            He nodded.
+            * * * 'But surely that is foolishness!'
+            * * * 'A most serious matter then!'
+            - - - He nodded again.
+            * * * 'But can we win?'
+                        'That is what we will endeavour to find out,' he answered.
+            * * * 'A modest wager, I trust?'
+                        'Twenty thousand pounds,' he replied, quite flatly.
+            * * * I asked nothing further of him then[.], and after a final, polite cough, he offered nothing more to me. <>
+    * * 'Ah[.'],' I replied, uncertain what I thought.
+    - - After that, <>
+* ... but I said nothing[] and <>
+- we passed the day in silence.
+- -> END

lua-scripts/stories/game.lua

@@ -0,0 +1 @@
+return {inclusions={},constants={},version={tree=1,engine=1},tree={_={_={"I looked at Monsieur Fogg",{text="... and I could contain myself no longer.",choice="... and I could contain myself no longer.",node={"'What is the purpose of our journey, Monsieur?'","'A wager,' he replied.",{text="'A wager!' I returned.",choice="'A wager!'",node={"He nodded.",{text="'But surely that is foolishness!'",choice="'But surely that is foolishness!'"},{text="'A most serious matter then!'",choice="'A most serious matter then!'"},"He nodded again.",{text="'But can we win?'",choice="'But can we win?'",node={"'That is what we will endeavour to find out,' he answered."}},{text="'A modest wager, I trust?'",choice="'A modest wager, I trust?'",node={"'Twenty thousand pounds,' he replied, quite flatly."}},{text="I asked nothing further of him then, and after a final, polite cough, he offered nothing more to me. <>",choice="I asked nothing further of him then."}}},{text="'Ah,' I replied, uncertain what I thought.",choice="'Ah.'"},"After that, <>"}},{text="... but I said nothing and <>",choice="... but I said nothing"},"we passed the day in silence.",{divert="END"}}}},lists={},variables={}}

src/gamedata/CharacterModule.cpp

@@ -257,11 +257,11 @@ CharacterModule::CharacterModule(flecs::world &ecs)
 			if (anim.currentAnim ==
 			    AnimationControl::ANIM_SWIMMING) {
 				float h = Ogre::Math::Clamp(
-					0.2f - ch.mBodyNode->getPosition().y,
+					0.0f - ch.mBodyNode->getPosition().y,
 					0.0f, 2000.0f);
-				if (h > 0.2 && h < 2.0f)
-					gr.gvelocity.y += 1.2 * (h + 1.0f) * h *
-							  eng.delta;
+				if (h > 0.05 && h < 2.0f)
+					gr.gvelocity.y += 0.1f * (h + 1.0f) *
+							  h * eng.delta;
 			}
 		});
 	ecs.system<const EngineData, const CharacterBase, CharacterVelocity>(
@@ -279,7 +279,7 @@ CharacterModule::CharacterModule(flecs::world &ecs)
 			Ogre::Vector3 pos = ch.mBodyNode->getPosition();
 			Ogre::Vector3 boneMotion = ch.mBoneMotion;
 			v.velocity = rot * boneMotion / eng.delta;
-			if (eng.startupDelay < 0.0f)
+			if (eng.startupDelay <= 0.0f)
 				v.velocity += v.gvelocity;
 			v.velocity.y = Ogre::Math::Clamp(v.velocity.y, -10.5f,
 							 1000000.0f);
@@ -424,6 +424,57 @@ CharacterModule::CharacterModule(flecs::world &ecs)
 				}
 			}
 		});
+#define TURN_SPEED 500.0f // character turning in degrees per second
+	ecs.system<const Input, const Camera, CharacterBase>("UpdateBody")
+		.kind(flecs::OnUpdate)
+		.with<Character>()
+		.with<Player>()
+		.each([](flecs::entity e, const Input &input,
+			 const Camera &camera, CharacterBase &ch) {
+			ch.mGoalDirection = Ogre::Vector3::ZERO;
+			float delta = e.world().delta_time();
+			if (!input.motion.zeroLength()) {
+				// calculate actually goal direction in world based on player's key directions
+				ch.mGoalDirection +=
+					input.motion.z *
+					camera.mCameraNode->getOrientation()
+						.zAxis();
+				ch.mGoalDirection +=
+					input.motion.x *
+					camera.mCameraNode->getOrientation()
+						.xAxis();
+				ch.mGoalDirection.y = 0;
+				ch.mGoalDirection.normalise();
+
+				Ogre::Quaternion toGoal =
+					ch.mBodyNode->getOrientation()
+						.zAxis()
+						.getRotationTo(
+							ch.mGoalDirection);
+				// calculate how much the character has to turn to face goal direction
+				Ogre::Real yawToGoal =
+					toGoal.getYaw().valueDegrees();
+				// this is how much the character CAN turn this frame
+				Ogre::Real yawAtSpeed =
+					yawToGoal / Ogre::Math::Abs(yawToGoal) *
+					delta * TURN_SPEED;
+				// reduce "turnability" if we're in midair
+				// if (mBaseAnimID == ANIM_JUMP_LOOP) yawAtSpeed *= 0.2f;
+				if (yawToGoal < 0)
+					yawToGoal = std::min<Ogre::Real>(
+						0,
+						std::max<Ogre::Real>(
+							yawToGoal,
+							yawAtSpeed)); //yawToGoal = Math::Clamp<Real>(yawToGoal, yawAtSpeed, 0);
+				else if (yawToGoal > 0)
+					yawToGoal = std::max<Ogre::Real>(
+						0,
+						std::min<Ogre::Real>(
+							yawToGoal,
+							yawAtSpeed)); //yawToGoal = Math::Clamp<Real>(yawToGoal, 0, yawAtSpeed);
+				ch.mBodyNode->yaw(Ogre::Degree(yawToGoal));
+			}
+		});
 	ecs.system<const EngineData, CharacterLocation, CharacterBase,
 		   CharacterBody>("UpdateCharacterBase")
 		.kind(flecs::OnUpdate)
@@ -562,57 +613,6 @@ CharacterModule::CharacterModule(flecs::world &ecs)
 					Ogre::Node::TS_PARENT);
 			}
 		});
-#define TURN_SPEED 500.0f // character turning in degrees per second
-	ecs.system<const Input, const Camera, CharacterBase>("UpdateBody")
-		.kind(flecs::OnUpdate)
-		.with<Character>()
-		.with<Player>()
-		.each([](flecs::entity e, const Input &input,
-			 const Camera &camera, CharacterBase &ch) {
-			ch.mGoalDirection = Ogre::Vector3::ZERO;
-			float delta = e.world().delta_time();
-			if (!input.motion.zeroLength()) {
-				// calculate actually goal direction in world based on player's key directions
-				ch.mGoalDirection +=
-					input.motion.z *
-					camera.mCameraNode->getOrientation()
-						.zAxis();
-				ch.mGoalDirection +=
-					input.motion.x *
-					camera.mCameraNode->getOrientation()
-						.xAxis();
-				ch.mGoalDirection.y = 0;
-				ch.mGoalDirection.normalise();
-
-				Ogre::Quaternion toGoal =
-					ch.mBodyNode->getOrientation()
-						.zAxis()
-						.getRotationTo(
-							ch.mGoalDirection);
-				// calculate how much the character has to turn to face goal direction
-				Ogre::Real yawToGoal =
-					toGoal.getYaw().valueDegrees();
-				// this is how much the character CAN turn this frame
-				Ogre::Real yawAtSpeed =
-					yawToGoal / Ogre::Math::Abs(yawToGoal) *
-					delta * TURN_SPEED;
-				// reduce "turnability" if we're in midair
-				// if (mBaseAnimID == ANIM_JUMP_LOOP) yawAtSpeed *= 0.2f;
-				if (yawToGoal < 0)
-					yawToGoal = std::min<Ogre::Real>(
-						0,
-						std::max<Ogre::Real>(
-							yawToGoal,
-							yawAtSpeed)); //yawToGoal = Math::Clamp<Real>(yawToGoal, yawAtSpeed, 0);
-				else if (yawToGoal > 0)
-					yawToGoal = std::max<Ogre::Real>(
-						0,
-						std::min<Ogre::Real>(
-							yawToGoal,
-							yawAtSpeed)); //yawToGoal = Math::Clamp<Real>(yawToGoal, 0, yawAtSpeed);
-				ch.mBodyNode->yaw(Ogre::Degree(yawToGoal));
-			}
-		});
 	class ClosestNotMeRayResultCallback
 		: public btCollisionWorld::ClosestRayResultCallback {
 		btCollisionObject *mMe;

src/gamedata/GUIModule.cpp

@@ -243,12 +243,39 @@ struct GUIListener : public Ogre::RenderTargetListener {
 					"%s", ECS::get()
 						      .get<GUI>()
 						      .narrationText.c_str());
-				ImGui::SetCursorScreenPos(p);
-				if (ImGui::InvisibleButton(
-					    "Background",
-					    ImGui::GetWindowSize()))
-					ECS::get<LuaBase>().mLua->call_handler(
-						"narration_progress");
+				if (ECS::get().get<GUI>().choices.size() == 0) {
+					ImGui::SetCursorScreenPos(p);
+					if (ImGui::InvisibleButton(
+						    "Background",
+						    ImGui::GetWindowSize()))
+						ECS::get<LuaBase>().mLua->call_handler(
+							"narration_progress");
+				} else {
+					int i;
+					for (i = 0; i < ECS::get()
+								.get<GUI>()
+								.choices.size();
+					     i++) {
+						if (ImGui::Button(
+							    ECS::get()
+								    .get<GUI>()
+								    .choices[i]
+								    .c_str())) {
+							ECS::get()
+								.get_mut<GUI>()
+								.narration_answer =
+								i + 1;
+							std::cout << "answer: "
+								  << i + 1
+								  << std::endl;
+							ECS::modified<GUI>();
+							ECS::get<LuaBase>()
+								.mLua
+								->call_handler(
+									"narration_answered");
+						}
+					}
+				}
 				ImGui::Spacing();
 				ImGui::PopFont();
 				ImGui::End();
@@ -448,7 +475,7 @@ GUIModule::GUIModule(flecs::world &ecs)
 			priv.mGuiOverlay = nullptr;
 		})
 		.add(flecs::Singleton);
-	ecs.set<GUI>({ false, true, false, false, false });
+	ecs.set<GUI>({ false, true, false, false, false, "", {}, -1 });
 	ecs.set<GUIData>({ nullptr, {}, nullptr });
 	ui_wait =
 		ecs.system<const RenderWindow, App, GUIData>("SetupGUI")

src/gamedata/GUIModule.h

@@ -13,6 +13,8 @@ struct GUI {
 	bool narrationBox;
 	bool mainMenu;
 	Ogre::String narrationText;
+	std::vector<Ogre::String> choices;
+	int narration_answer;
 	static void setWindowGrab(bool g = true)
 	{
 		ECS::GUI &gui = ECS::get().get_mut<ECS::GUI>();

src/gamedata/LuaData.cpp

@@ -1,7 +1,12 @@
+#include <OgreFileSystemLayer.h>
 #include "GameData.h"
 #include "Components.h"
 #include "GUIModule.h"
 #include "LuaData.h"
+
+extern "C" {
+int luaopen_lpeg(lua_State *L);
+}
 namespace ECS
 {
 
@@ -23,11 +28,100 @@ int LuaData::call_handler(const Ogre::String &event)
 	}
 	return 0;
 }
+
+int luaLibraryLoader(lua_State *L)
+{
+	int i;
+	if (!lua_isstring(L, 1)) {
+		luaL_error(
+			L,
+			"luaLibraryLoader: Expected string for first parameter");
+	}
+
+	std::string libraryFile = lua_tostring(L, 1);
+	std::cout << libraryFile << std::endl;
+	// In order to be compatible with the normal Lua file loader,
+	// translate '.' to the file system seperator character.
+	// In this case (An ogre resource) '/'
+	while (libraryFile.find('.') != std::string::npos)
+		libraryFile.replace(libraryFile.find('.'), 1, "/");
+
+	libraryFile += ".lua";
+	std::cout << libraryFile << std::endl;
+	Ogre::StringVectorPtr scripts =
+		Ogre::ResourceGroupManager::getSingleton().listResourceNames(
+			"LuaScripts", false);
+	std::vector<Ogre::String> &strings = *scripts;
+	for (i = 0; i < strings.size(); i++)
+		std::cout << strings[i] << std::endl;
+
+	if (0 && !Ogre::ResourceGroupManager::getSingleton()
+			  .resourceExistsInAnyGroup(libraryFile)) {
+		// Could not find the file.
+		std::string errMessage = "\n  no file '" + libraryFile +
+					 "' found in Ogre resource archives.";
+		lua_pushstring(L, errMessage.c_str());
+	} else {
+		Ogre::DataStreamList streams =
+			Ogre::ResourceGroupManager::getSingleton().openResources(
+				"*.lua", "LuaScripts");
+		Ogre::DataStreamPtr stream =
+			Ogre::ResourceGroupManager::getSingleton().openResource(
+				libraryFile, "LuaScripts");
+		Ogre::String script = stream->getAsString();
+		if (luaL_loadbuffer(L, script.c_str(), script.length(),
+				    libraryFile.c_str())) {
+			luaL_error(
+				L,
+				"Error loading library '%s' from resource archive.\n%s",
+				libraryFile.c_str(), lua_tostring(L, -1));
+		}
+	}
+	return 1;
+}
+
+static void installLibraryLoader(lua_State *L)
+{
+	// Insert the c++ func 'luaLibraryLoader' into package.loaders.
+	// Inserted at the start of the table in order to take precedence.
+	lua_getglobal(L, "table");
+	lua_getfield(L, -1, "insert");
+	lua_remove(L, -2); // table
+	lua_getglobal(L, "package");
+	lua_getfield(L, -1, "searchers");
+	lua_remove(L, -2); // package
+	lua_pushnumber(L, 1); // index where to insert into loaders table
+	lua_pushcfunction(L, luaLibraryLoader);
+	if (lua_pcall(L, 3, 0, 0))
+		Ogre::LogManager::getSingleton().stream() << lua_tostring(L, 1);
+}
+
 LuaData::LuaData()
 	: L(luaL_newstate())
 {
 	luaopen_base(L);
+	luaopen_table(L);
 	luaopen_package(L);
+	luaL_requiref(L, "table", luaopen_table, 1);
+	lua_pop(L, 1);
+	luaL_requiref(L, "math", luaopen_math, 1);
+	lua_pop(L, 1);
+	luaL_requiref(L, "package", luaopen_package, 1);
+	lua_pop(L, 1);
+	luaL_requiref(L, "string", luaopen_string, 1);
+	lua_pop(L, 1);
+	luaL_requiref(L, "io", luaopen_io, 1);
+	lua_pop(L, 1);
+	luaL_requiref(L, "lpeg", luaopen_lpeg, 1);
+	lua_pop(L, 1);
+#if 0
+	luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
+	lua_pushcfunction(L, luaopen_lpeg);
+	lua_setfield(L, -2, "lpeg");
+	lua_pop(L, 1); // remove PRELOAD table
+#endif
+	installLibraryLoader(L);
+	lua_pop(L, 1);
 	lua_pushcfunction(L, [](lua_State *L) -> int {
 		OgreAssert(false, "Crash function called");
 		return 0;
@@ -40,9 +134,24 @@ LuaData::LuaData()
 	});
 	lua_setglobal(L, "setup_handler");
 	lua_pushcfunction(L, [](lua_State *L) -> int {
+		int args = lua_gettop(L);
+		if (args < 1)
+			return 0;
+		ECS::get_mut<GUI>().choices.clear();
 		luaL_checktype(L, 1, LUA_TSTRING);
+		if (args > 1) {
+			luaL_checktype(L, 2, LUA_TTABLE);
+			lua_pushnil(L); /* first key */
+			while (lua_next(L, 2) != 0) {
+				Ogre::String s = lua_tostring(L, -1);
+				ECS::get_mut<GUI>().choices.push_back(s);
+				lua_pop(L, 1); /* remove value but keep key */
+			}
+		}
 		size_t len;
 		Ogre::String message(luaL_tolstring(L, 1, &len));
+		std::cout << "narrator message: " << message
+			  << " length: " << message.length() << std::endl;
 		if (message.length() == 0 && ECS::get_mut<GUI>().narrationBox) {
 			ECS::get_mut<GUI>().enabled = false;
 			ECS::get_mut<GUI>().grab = true;
@@ -50,12 +159,11 @@ LuaData::LuaData()
 			ECS::get_mut<GUI>().narrationText = message;
 			ECS::get_mut<GUI>().narrationBox = false;
 			ECS::modified<GUI>();
-		} else {
+			std::cout << "narration ended\n";
+		} else if (message.length() > 0) {
 			std::replace(message.begin(), message.end(), '\n', ' ');
 			std::replace(message.begin(), message.end(), '\r', ' ');
 
-			std::cout << "narrator message: " << message
-				  << std::endl;
 			ECS::get_mut<GUI>().enabled = true;
 			ECS::get_mut<GUI>().grab = false;
 			ECS::get_mut<GUI>().grabChanged = true;
@@ -67,6 +175,12 @@ LuaData::LuaData()
 		return 0;
 	});
 	lua_setglobal(L, "narrate");
+	lua_pushcfunction(L, [](lua_State *L) -> int {
+		//		ECS::get_mut<GUI>().mainMenu = true;
+		lua_pushinteger(L, ECS::get<GUI>().narration_answer);
+		return 1;
+	});
+	lua_setglobal(L, "narration_get_answer");
 	lua_pushcfunction(L, [](lua_State *L) -> int {
 		//		ECS::get_mut<GUI>().mainMenu = true;
 		ECS::get_mut<GUI>().enabled = true;

src/gamedata/TerrainModule.cpp

@@ -589,18 +589,19 @@ TerrainModule::TerrainModule(flecs::world &ecs)
 							     .position
 						  << std::endl;
 				}
+				flecs::entity player = ECS::player;
+				CharacterLocation &loc =
+					player.get_mut<CharacterLocation>();
+				height = get_height(terrain.mTerrainGroup,
+						    loc.position);
+				loc.position.y = height + 0.0f;
+				player.get<CharacterBase>()
+					.mBodyNode->setPosition(loc.position);
+				player.get<CharacterBase>()
+					.mBodyNode->setOrientation(
+						Ogre::Quaternion());
+				player.modified<CharacterLocation>();
 			}
-			flecs::entity player = ECS::player;
-			CharacterLocation &loc =
-				player.get_mut<CharacterLocation>();
-			float height =
-				get_height(terrain.mTerrainGroup, loc.position);
-			loc.position.y = height + 0.0f;
-			player.get<CharacterBase>().mBodyNode->setPosition(
-				loc.position);
-			player.get<CharacterBase>().mBodyNode->setOrientation(
-				Ogre::Quaternion());
-			player.modified<CharacterLocation>();
 		});
 }
 float TerrainModule::get_height(Ogre::TerrainGroup *group,

src/lua/CMakeLists.txt

@@ -14,17 +14,28 @@ set(LUA_OBJ
 	lmathlib.o loadlib.o loslib.o lstrlib.o ltablib.o
 	lutf8lib.o linit.o)
 set(LUA_SRC)
+set(LPEG_OBJ
+lpvm.o lpcap.o lptree.o lpcode.o lpprint.o lpcset.o
+)
+set(LPEG_SRC)
 foreach(LUA_FILE ${LUA_OBJ})
 	string(REPLACE ".o" ".c" LUA_SRC_ITEM ${LUA_FILE})
 	list(APPEND LUA_SRC lua-5.4.8/src/${LUA_SRC_ITEM})
 endforeach()
-add_library(lua ${LUA_SRC})
-target_include_directories(lua PUBLIC lua-5.4.8/src)
+foreach(LPEG_FILE ${LPEG_OBJ})
+	string(REPLACE ".o" ".c" LPEG_SRC_ITEM ${LPEG_FILE})
+	list(APPEND LPEG_SRC lpeg-1.1.0/${LPEG_SRC_ITEM})
+endforeach()
+add_library(lua ${LUA_SRC} ${LPEG_SRC})
+target_include_directories(lua PUBLIC lua-5.4.8/src lpeg-1.1.0)
 add_executable(luavm lua-5.4.8/src/lua.c)
 target_link_libraries(luavm lua m)
 target_include_directories(luavm PRIVATE lua-5.4.8/src)
-add_executable(luac lua-5.4.8/src/luac.c ${LUA_SRC})
+add_executable(luac lua-5.4.8/src/luac.c ${LUA_SRC} ${LPEG_SRC})
 target_link_libraries(luac m)
-target_include_directories(luac PRIVATE lua-5.4.8/src)
+target_include_directories(luac PRIVATE lua-5.4.8/src lpeg-1.1.0)
+add_executable(lualpegvm lua.c)
+target_link_libraries(lualpegvm lua m)
+target_include_directories(lualpegvm PRIVATE lua-5.4.8/src)
 
 

src/lua/lpeg-1.1.0/HISTORY

@@ -0,0 +1,109 @@
+HISTORY for LPeg 1.1.0
+
+* Changes from version 1.0.2 to 1.1.0
+  ---------------------------------
+  + accumulator capture
+  + UTF-8 ranges
+  + Larger limit for number of rules in a grammar
+  + Larger limit for number of captures in a match
+  + bug fixes
+  + other small improvements
+
+* Changes from version 1.0.1 to 1.0.2
+  ---------------------------------
+  + some bugs fixed
+
+* Changes from version 0.12 to 1.0.1
+  ---------------------------------
+  + group "names" can be any Lua value
+  + some bugs fixed
+  + other small improvements
+
+* Changes from version 0.11 to 0.12
+  ---------------------------------
+  + no "unsigned short" limit for pattern sizes
+  + mathtime captures considered nullable
+  + some bugs fixed
+
+* Changes from version 0.10 to 0.11
+  -------------------------------
+  + complete reimplementation of the code generator
+  + new syntax for table captures
+  + new functions in module 're'
+  + other small improvements
+
+* Changes from version 0.9 to 0.10
+  -------------------------------
+  + backtrack stack has configurable size
+  + better error messages
+  + Notation for non-terminals in 're' back to A instead o <A>
+  + experimental look-behind pattern
+  + support for external extensions
+  + works with Lua 5.2
+  + consumes less C stack
+
+  - "and" predicates do not keep captures
+
+* Changes from version 0.8 to 0.9
+  -------------------------------
+  + The accumulator capture was replaced by a fold capture;
+    programs that used the old 'lpeg.Ca' will need small changes.
+  + Some support for character classes from old C locales.
+  + A new named-group capture.
+
+* Changes from version 0.7 to 0.8
+  -------------------------------
+  + New "match-time" capture.
+  + New "argument capture" that allows passing arguments into the pattern.
+  + Better documentation for 're'.
+  + Several small improvements for 're'.
+  + The 're' module has an incompatibility with previous versions:
+    now, any use of a non-terminal must be enclosed in angle brackets
+    (like <B>).
+
+* Changes from version 0.6 to 0.7
+  -------------------------------
+  + Several improvements in module 're':
+    - better documentation;
+    - support for most captures (all but accumulator);
+    - limited repetitions p{n,m}.
+  + Small improvements in efficiency.
+  + Several small bugs corrected (special thanks to Hans Hagen
+    and Taco Hoekwater).
+
+* Changes from version 0.5 to 0.6
+  -------------------------------
+  + Support for non-numeric indices in grammars.
+  + Some bug fixes (thanks to the luatex team).
+  + Some new optimizations; (thanks to Mike Pall).
+  + A new page layout (thanks to Andre Carregal).
+  + Minimal documentation for module 're'.
+
+* Changes from version 0.4 to 0.5
+  -------------------------------
+  + Several optimizations.
+  + lpeg.P now accepts booleans.
+  + Some new examples.
+  + A proper license.
+  + Several small improvements.
+
+* Changes from version 0.3 to 0.4
+  -------------------------------
+  + Static check for loops in repetitions and grammars.
+  + Removed label option in captures.
+  + The implementation of captures uses less memory.
+
+* Changes from version 0.2 to 0.3
+  -------------------------------
+  + User-defined patterns in Lua.
+  + Several new captures.
+
+* Changes from version 0.1 to 0.2
+  -------------------------------
+  + Several small corrections.
+  + Handles embedded zeros like any other character.
+  + Capture "name" can be any Lua value.
+  + Unlimited number of captures.
+  + Match gets an optional initial position.
+
+(end of HISTORY)

src/lua/lpeg-1.1.0/README.md

@@ -0,0 +1,4 @@
+# LPeg - Parsing Expression Grammars For Lua
+
+For more information,
+see [Lpeg](//www.inf.puc-rio.br/~roberto/lpeg/).

src/lua/lpeg-1.1.0/lpcap.c

@@ -0,0 +1,612 @@
+
+#include "lua.h"
+#include "lauxlib.h"
+
+#include "lpcap.h"
+#include "lpprint.h"
+#include "lptypes.h"
+
+
+#define getfromktable(cs,v)	lua_rawgeti((cs)->L, ktableidx((cs)->ptop), v)
+
+#define pushluaval(cs)		getfromktable(cs, (cs)->cap->idx)
+
+
+
+#define skipclose(cs,head)  \
+	if (isopencap(head)) { assert(isclosecap(cs->cap)); cs->cap++; }
+
+
+/*
+** Return the size of capture 'cap'. If it is an open capture, 'close'
+** must be its corresponding close.
+*/
+static Index_t capsize (Capture *cap, Capture *close) {
+  if (isopencap(cap)) {
+    assert(isclosecap(close));
+    return close->index - cap->index;
+  }
+  else
+    return cap->siz - 1;
+}
+
+
+static Index_t closesize (CapState *cs, Capture *head) {
+  return capsize(head, cs->cap);
+}
+
+
+/*
+** Put at the cache for Lua values the value indexed by 'v' in ktable
+** of the running pattern (if it is not there yet); returns its index.
+*/
+static int updatecache (CapState *cs, int v) {
+  int idx = cs->ptop + 1;  /* stack index of cache for Lua values */
+  if (v != cs->valuecached) {  /* not there? */
+    getfromktable(cs, v);  /* get value from 'ktable' */
+    lua_replace(cs->L, idx);  /* put it at reserved stack position */
+    cs->valuecached = v;  /* keep track of what is there */
+  }
+  return idx;
+}
+
+
+static int pushcapture (CapState *cs);
+
+
+/*
+** Goes back in a list of captures looking for an open capture
+** corresponding to a close one.
+*/
+static Capture *findopen (Capture *cap) {
+  int n = 0;  /* number of closes waiting an open */
+  for (;;) {
+    cap--;
+    if (isclosecap(cap)) n++;  /* one more open to skip */
+    else if (isopencap(cap))
+      if (n-- == 0) return cap;
+  }
+}
+
+
+/*
+** Go to the next capture at the same level.
+*/
+static void nextcap (CapState *cs) {
+  Capture *cap = cs->cap;
+  if (isopencap(cap)) {  /* must look for a close? */
+    int n = 0;  /* number of opens waiting a close */
+    for (;;) {  /* look for corresponding close */
+      cap++;
+      if (isopencap(cap)) n++;
+      else if (isclosecap(cap))
+        if (n-- == 0) break;
+    }
+    cs->cap = cap + 1;  /* + 1 to skip last close */
+  }
+  else {
+    Capture *next;
+    for (next = cap + 1; capinside(cap, next); next++)
+      ;  /* skip captures inside current one */
+    cs->cap = next;
+  }
+}
+
+
+/*
+** Push on the Lua stack all values generated by nested captures inside
+** the current capture. Returns number of values pushed. 'addextra'
+** makes it push the entire match after all captured values. The
+** entire match is pushed also if there are no other nested values,
+** so the function never returns zero.
+*/
+static int pushnestedvalues (CapState *cs, int addextra) {
+  Capture *head = cs->cap++;  /* original capture */
+  int n = 0;  /* number of pushed subvalues */
+  /* repeat for all nested patterns */
+  while (capinside(head, cs->cap))
+    n += pushcapture(cs);
+  if (addextra || n == 0) {  /* need extra? */
+    lua_pushlstring(cs->L, cs->s + head->index, closesize(cs, head));
+    n++;
+  }
+  skipclose(cs, head);
+  return n;
+}
+
+
+/*
+** Push only the first value generated by nested captures
+*/
+static void pushonenestedvalue (CapState *cs) {
+  int n = pushnestedvalues(cs, 0);
+  if (n > 1)
+    lua_pop(cs->L, n - 1);  /* pop extra values */
+}
+
+
+/*
+** Checks whether group 'grp' is visible to 'ref', that is, 'grp' is
+** not nested inside a full capture that does not contain 'ref'.  (We
+** only need to care for full captures because the search at 'findback'
+** skips open-end blocks; so, if 'grp' is nested in a non-full capture,
+** 'ref' is also inside it.)  To check this, we search backward for the
+** inner full capture enclosing 'grp'.  A full capture cannot contain
+** non-full captures, so a close capture means we cannot be inside a
+** full capture anymore.
+*/
+static int capvisible (CapState *cs, Capture *grp, Capture *ref) {
+  Capture *cap = grp;
+  int i = MAXLOP;  /* maximum distance for an 'open' */
+  while (i-- > 0 && cap-- > cs->ocap) {
+    if (isclosecap(cap))
+      return 1;  /* can stop the search */
+    else if (grp->index - cap->index >= UCHAR_MAX)
+      return 1;  /* can stop the search */
+    else if (capinside(cap, grp))  /* is 'grp' inside cap? */
+      return capinside(cap, ref);  /* ok iff cap also contains 'ref' */
+  }
+  return 1;  /* 'grp' is not inside any capture */
+}
+
+
+/*
+** Try to find a named group capture with the name given at the top of
+** the stack; goes backward from 'ref'.
+*/
+static Capture *findback (CapState *cs, Capture *ref) {
+  lua_State *L = cs->L;
+  Capture *cap = ref;
+  while (cap-- > cs->ocap) {  /* repeat until end of list */
+    if (isclosecap(cap))
+      cap = findopen(cap);  /* skip nested captures */
+    else if (capinside(cap, ref))
+      continue;  /* enclosing captures are not visible to 'ref' */
+    if (captype(cap) == Cgroup && capvisible(cs, cap, ref)) {
+      getfromktable(cs, cap->idx);  /* get group name */
+      if (lp_equal(L, -2, -1)) {  /* right group? */
+        lua_pop(L, 2);  /* remove reference name and group name */
+        return cap;
+      }
+      else lua_pop(L, 1);  /* remove group name */
+    }
+  }
+  luaL_error(L, "back reference '%s' not found", lua_tostring(L, -1));
+  return NULL;  /* to avoid warnings */
+}
+
+
+/*
+** Back-reference capture. Return number of values pushed.
+*/
+static int backrefcap (CapState *cs) {
+  int n;
+  Capture *curr = cs->cap;
+  pushluaval(cs);  /* reference name */
+  cs->cap = findback(cs, curr);  /* find corresponding group */
+  n = pushnestedvalues(cs, 0);  /* push group's values */
+  cs->cap = curr + 1;
+  return n;
+}
+
+
+/*
+** Table capture: creates a new table and populates it with nested
+** captures.
+*/
+static int tablecap (CapState *cs) {
+  lua_State *L = cs->L;
+  Capture *head = cs->cap++;
+  int n = 0;
+  lua_newtable(L);
+  while (capinside(head, cs->cap)) {
+    if (captype(cs->cap) == Cgroup && cs->cap->idx != 0) {  /* named group? */
+      pushluaval(cs);  /* push group name */
+      pushonenestedvalue(cs);
+      lua_settable(L, -3);
+    }
+    else {  /* not a named group */
+      int i;
+      int k = pushcapture(cs);
+      for (i = k; i > 0; i--)  /* store all values into table */
+        lua_rawseti(L, -(i + 1), n + i);
+      n += k;
+    }
+  }
+  skipclose(cs, head);
+  return 1;  /* number of values pushed (only the table) */
+}
+
+
+/*
+** Table-query capture
+*/
+static int querycap (CapState *cs) {
+  int idx = cs->cap->idx;
+  pushonenestedvalue(cs);  /* get nested capture */
+  lua_gettable(cs->L, updatecache(cs, idx));  /* query cap. value at table */
+  if (!lua_isnil(cs->L, -1))
+    return 1;
+  else {  /* no value */
+    lua_pop(cs->L, 1);  /* remove nil */
+    return 0;
+  }
+}
+
+
+/*
+** Fold capture
+*/
+static int foldcap (CapState *cs) {
+  int n;
+  lua_State *L = cs->L;
+  Capture *head = cs->cap++;
+  int idx = head->idx;
+  if (isclosecap(cs->cap) ||  /* no nested captures (large subject)? */
+      (n = pushcapture(cs)) == 0)  /* nested captures with no values? */
+    return luaL_error(L, "no initial value for fold capture");
+  if (n > 1)
+    lua_pop(L, n - 1);  /* leave only one result for accumulator */
+  while (capinside(head, cs->cap)) {
+    lua_pushvalue(L, updatecache(cs, idx));  /* get folding function */
+    lua_insert(L, -2);  /* put it before accumulator */
+    n = pushcapture(cs);  /* get next capture's values */
+    lua_call(L, n + 1, 1);  /* call folding function */
+  }
+  skipclose(cs, head);
+  return 1;  /* only accumulator left on the stack */
+}
+
+
+/*
+** Function capture
+*/
+static int functioncap (CapState *cs) {
+  int n;
+  int top = lua_gettop(cs->L);
+  pushluaval(cs);  /* push function */
+  n = pushnestedvalues(cs, 0);  /* push nested captures */
+  lua_call(cs->L, n, LUA_MULTRET);  /* call function */
+  return lua_gettop(cs->L) - top;  /* return function's results */
+}
+
+
+/*
+** Accumulator capture
+*/
+static int accumulatorcap (CapState *cs) {
+  lua_State *L = cs->L;
+  int n;
+  if (lua_gettop(L) < cs->firstcap)
+    luaL_error(L, "no previous value for accumulator capture");
+  pushluaval(cs);  /* push function */
+  lua_insert(L, -2);  /* previous value becomes first argument */
+  n = pushnestedvalues(cs, 0);  /* push nested captures */
+  lua_call(L, n + 1, 1);  /* call function */
+  return 0;  /* did not add any extra value */
+}
+
+
+/*
+** Select capture
+*/
+static int numcap (CapState *cs) {
+  int idx = cs->cap->idx;  /* value to select */
+  if (idx == 0) {  /* no values? */
+    nextcap(cs);  /* skip entire capture */
+    return 0;  /* no value produced */
+  }
+  else {
+    int n = pushnestedvalues(cs, 0);
+    if (n < idx)  /* invalid index? */
+      return luaL_error(cs->L, "no capture '%d'", idx);
+    else {
+      lua_pushvalue(cs->L, -(n - idx + 1));  /* get selected capture */
+      lua_replace(cs->L, -(n + 1));  /* put it in place of 1st capture */
+      lua_pop(cs->L, n - 1);  /* remove other captures */
+      return 1;
+    }
+  }
+}
+
+
+/*
+** Return the stack index of the first runtime capture in the given
+** list of captures (or zero if no runtime captures)
+*/
+int finddyncap (Capture *cap, Capture *last) {
+  for (; cap < last; cap++) {
+    if (cap->kind == Cruntime)
+      return cap->idx;  /* stack position of first capture */
+  }
+  return 0;  /* no dynamic captures in this segment */
+}
+
+
+/*
+** Calls a runtime capture. Returns number of captures "removed" by the
+** call, that is, those inside the group capture. Captures to be added
+** are on the Lua stack.
+*/
+int runtimecap (CapState *cs, Capture *close, const char *s, int *rem) {
+  int n, id;
+  lua_State *L = cs->L;
+  int otop = lua_gettop(L);
+  Capture *open = findopen(close);  /* get open group capture */
+  assert(captype(open) == Cgroup);
+  id = finddyncap(open, close);  /* get first dynamic capture argument */
+  close->kind = Cclose;  /* closes the group */
+  close->index = s - cs->s;
+  cs->cap = open; cs->valuecached = 0;  /* prepare capture state */
+  luaL_checkstack(L, 4, "too many runtime captures");
+  pushluaval(cs);  /* push function to be called */
+  lua_pushvalue(L, SUBJIDX);  /* push original subject */
+  lua_pushinteger(L, s - cs->s + 1);  /* push current position */
+  n = pushnestedvalues(cs, 0);  /* push nested captures */
+  lua_call(L, n + 2, LUA_MULTRET);  /* call dynamic function */
+  if (id > 0) {  /* are there old dynamic captures to be removed? */
+    int i;
+    for (i = id; i <= otop; i++)
+      lua_remove(L, id);  /* remove old dynamic captures */
+    *rem = otop - id + 1;  /* total number of dynamic captures removed */
+  }
+  else
+    *rem = 0;  /* no dynamic captures removed */
+  return close - open - 1;  /* number of captures to be removed */
+}
+
+
+/*
+** Auxiliary structure for substitution and string captures: keep
+** information about nested captures for future use, avoiding to push
+** string results into Lua
+*/
+typedef struct StrAux {
+  int isstring;  /* whether capture is a string */
+  union {
+    Capture *cp;  /* if not a string, respective capture */
+    struct {  /* if it is a string... */
+      Index_t idx;  /* starts here */
+      Index_t siz;  /* with this size */
+    } s;
+  } u;
+} StrAux;
+
+#define MAXSTRCAPS	10
+
+/*
+** Collect values from current capture into array 'cps'. Current
+** capture must be Cstring (first call) or Csimple (recursive calls).
+** (In first call, fills %0 with whole match for Cstring.)
+** Returns number of elements in the array that were filled.
+*/
+static int getstrcaps (CapState *cs, StrAux *cps, int n) {
+  int k = n++;
+  Capture *head = cs->cap++;
+  cps[k].isstring = 1;  /* get string value */
+  cps[k].u.s.idx = head->index;  /* starts here */
+  while (capinside(head, cs->cap)) {
+    if (n >= MAXSTRCAPS)  /* too many captures? */
+      nextcap(cs);  /* skip extra captures (will not need them) */
+    else if (captype(cs->cap) == Csimple)  /* string? */
+      n = getstrcaps(cs, cps, n);  /* put info. into array */
+    else {
+      cps[n].isstring = 0;  /* not a string */
+      cps[n].u.cp = cs->cap;  /* keep original capture */
+      nextcap(cs);
+      n++;
+    }
+  }
+  cps[k].u.s.siz = closesize(cs, head);
+  skipclose(cs, head);
+  return n;
+}
+
+
+/*
+** add next capture value (which should be a string) to buffer 'b'
+*/
+static int addonestring (luaL_Buffer *b, CapState *cs, const char *what);
+
+
+/*
+** String capture: add result to buffer 'b' (instead of pushing
+** it into the stack)
+*/
+static void stringcap (luaL_Buffer *b, CapState *cs) {
+  StrAux cps[MAXSTRCAPS];
+  int n;
+  size_t len, i;
+  const char *fmt;  /* format string */
+  fmt = lua_tolstring(cs->L, updatecache(cs, cs->cap->idx), &len);
+  n = getstrcaps(cs, cps, 0) - 1;  /* collect nested captures */
+  for (i = 0; i < len; i++) {  /* traverse format string */
+    if (fmt[i] != '%')  /* not an escape? */
+      luaL_addchar(b, fmt[i]);  /* add it to buffer */
+    else if (fmt[++i] < '0' || fmt[i] > '9')  /* not followed by a digit? */
+      luaL_addchar(b, fmt[i]);  /* add to buffer */
+    else {
+      int l = fmt[i] - '0';  /* capture index */
+      if (l > n)
+        luaL_error(cs->L, "invalid capture index (%d)", l);
+      else if (cps[l].isstring)
+        luaL_addlstring(b, cs->s + cps[l].u.s.idx, cps[l].u.s.siz);
+      else {
+        Capture *curr = cs->cap;
+        cs->cap = cps[l].u.cp;  /* go back to evaluate that nested capture */
+        if (!addonestring(b, cs, "capture"))
+          luaL_error(cs->L, "no values in capture index %d", l);
+        cs->cap = curr;  /* continue from where it stopped */
+      }
+    }
+  }
+}
+
+
+/*
+** Substitution capture: add result to buffer 'b'
+*/
+static void substcap (luaL_Buffer *b, CapState *cs) {
+  const char *curr = cs->s + cs->cap->index;
+  Capture *head = cs->cap++;
+  while (capinside(head, cs->cap)) {
+    Capture *cap = cs->cap;
+    const char *caps = cs->s + cap->index;
+    luaL_addlstring(b, curr, caps - curr);  /* add text up to capture */
+    if (addonestring(b, cs, "replacement"))
+      curr = caps + capsize(cap, cs->cap - 1);  /* continue after match */
+    else  /* no capture value */
+      curr = caps;  /* keep original text in final result */
+  }
+  /* add last piece of text */
+  luaL_addlstring(b, curr, cs->s + head->index + closesize(cs, head) - curr);
+  skipclose(cs, head);
+}
+
+
+/*
+** Evaluates a capture and adds its first value to buffer 'b'; returns
+** whether there was a value
+*/
+static int addonestring (luaL_Buffer *b, CapState *cs, const char *what) {
+  switch (captype(cs->cap)) {
+    case Cstring:
+      stringcap(b, cs);  /* add capture directly to buffer */
+      return 1;
+    case Csubst:
+      substcap(b, cs);  /* add capture directly to buffer */
+      return 1;
+    case Cacc:  /* accumulator capture? */
+      return luaL_error(cs->L, "invalid context for an accumulator capture");
+    default: {
+      lua_State *L = cs->L;
+      int n = pushcapture(cs);
+      if (n > 0) {
+        if (n > 1) lua_pop(L, n - 1);  /* only one result */
+        if (!lua_isstring(L, -1))
+          return luaL_error(L, "invalid %s value (a %s)",
+                               what, luaL_typename(L, -1));
+        luaL_addvalue(b);
+      }
+      return n;
+    }
+  }
+}
+
+
+#if !defined(MAXRECLEVEL)
+#define MAXRECLEVEL	200
+#endif
+
+
+/*
+** Push all values of the current capture into the stack; returns
+** number of values pushed
+*/
+static int pushcapture (CapState *cs) {
+  lua_State *L = cs->L;
+  int res;
+  luaL_checkstack(L, 4, "too many captures");
+  if (cs->reclevel++ > MAXRECLEVEL)
+    return luaL_error(L, "subcapture nesting too deep");
+  switch (captype(cs->cap)) {
+    case Cposition: {
+      lua_pushinteger(L, cs->cap->index + 1);
+      cs->cap++;
+      res = 1;
+      break;
+    }
+    case Cconst: {
+      pushluaval(cs);
+      cs->cap++;
+      res = 1;
+      break;
+    }
+    case Carg: {
+      int arg = (cs->cap++)->idx;
+      if (arg + FIXEDARGS > cs->ptop)
+        return luaL_error(L, "reference to absent extra argument #%d", arg);
+      lua_pushvalue(L, arg + FIXEDARGS);
+      res = 1;
+      break;
+    }
+    case Csimple: {
+      int k = pushnestedvalues(cs, 1);
+      lua_insert(L, -k);  /* make whole match be first result */
+      res = k;
+      break;
+    }
+    case Cruntime: {
+      lua_pushvalue(L, (cs->cap++)->idx);  /* value is in the stack */
+      res = 1;
+      break;
+    }
+    case Cstring: {
+      luaL_Buffer b;
+      luaL_buffinit(L, &b);
+      stringcap(&b, cs);
+      luaL_pushresult(&b);
+      res = 1;
+      break;
+    }
+    case Csubst: {
+      luaL_Buffer b;
+      luaL_buffinit(L, &b);
+      substcap(&b, cs);
+      luaL_pushresult(&b);
+      res = 1;
+      break;
+    }
+    case Cgroup: {
+      if (cs->cap->idx == 0)  /* anonymous group? */
+        res = pushnestedvalues(cs, 0);  /* add all nested values */
+      else {  /* named group: add no values */
+        nextcap(cs);  /* skip capture */
+        res = 0;
+      }
+      break;
+    }
+    case Cbackref: res = backrefcap(cs); break;
+    case Ctable: res = tablecap(cs); break;
+    case Cfunction: res = functioncap(cs); break;
+    case Cacc: res = accumulatorcap(cs); break;
+    case Cnum: res = numcap(cs); break;
+    case Cquery: res = querycap(cs); break;
+    case Cfold: res = foldcap(cs); break;
+    default: assert(0); res = 0;
+  }
+  cs->reclevel--;
+  return res;
+}
+
+
+/*
+** Prepare a CapState structure and traverse the entire list of
+** captures in the stack pushing its results. 's' is the subject
+** string, 'r' is the final position of the match, and 'ptop'
+** the index in the stack where some useful values were pushed.
+** Returns the number of results pushed. (If the list produces no
+** results, push the final position of the match.)
+*/
+int getcaptures (lua_State *L, const char *s, const char *r, int ptop) {
+  Capture *capture = (Capture *)lua_touserdata(L, caplistidx(ptop));
+  int n = 0;
+  /* printcaplist(capture); */
+  if (!isclosecap(capture)) {  /* is there any capture? */
+    CapState cs;
+    cs.ocap = cs.cap = capture; cs.L = L; cs.reclevel = 0;
+    cs.s = s; cs.valuecached = 0; cs.ptop = ptop;
+    cs.firstcap = lua_gettop(L) + 1;  /* where first value (if any) will go */
+    do {  /* collect their values */
+      n += pushcapture(&cs);
+    } while (!isclosecap(cs.cap));
+    assert(lua_gettop(L) - cs.firstcap == n - 1);
+  }
+  if (n == 0) {  /* no capture values? */
+    lua_pushinteger(L, r - s + 1);  /* return only end position */
+    n = 1;
+  }
+  return n;
+}
+
+

src/lua/lpeg-1.1.0/lpcap.h

@@ -0,0 +1,86 @@
+
+#if !defined(lpcap_h)
+#define lpcap_h
+
+
+#include "lptypes.h"
+
+
+/* kinds of captures */
+typedef enum CapKind {
+  Cclose,  /* not used in trees */
+  Cposition,
+  Cconst,  /* ktable[key] is Lua constant */
+  Cbackref,  /* ktable[key] is "name" of group to get capture */
+  Carg,  /* 'key' is arg's number */
+  Csimple,  /* next node is pattern */
+  Ctable,  /* next node is pattern */
+  Cfunction,  /* ktable[key] is function; next node is pattern */
+  Cacc,  /* ktable[key] is function; next node is pattern */
+  Cquery,  /* ktable[key] is table; next node is pattern */
+  Cstring,  /* ktable[key] is string; next node is pattern */
+  Cnum,  /* numbered capture; 'key' is number of value to return */
+  Csubst,  /* substitution capture; next node is pattern */
+  Cfold,  /* ktable[key] is function; next node is pattern */
+  Cruntime,  /* not used in trees (is uses another type for tree) */
+  Cgroup  /* ktable[key] is group's "name" */
+} CapKind;
+
+
+/*
+** An unsigned integer large enough to index any subject entirely.
+** It can be size_t, but that will double the size of the array
+** of captures in a 64-bit machine.
+*/
+#if !defined(Index_t)
+typedef uint Index_t;
+#endif
+
+#define MAXINDT		(~(Index_t)0)
+
+
+typedef struct Capture {
+  Index_t index;  /* subject position */
+  unsigned short idx;  /* extra info (group name, arg index, etc.) */
+  byte kind;  /* kind of capture */
+  byte siz;  /* size of full capture + 1 (0 = not a full capture) */
+} Capture;
+
+
+typedef struct CapState {
+  Capture *cap;  /* current capture */
+  Capture *ocap;  /* (original) capture list */
+  lua_State *L;
+  int ptop;  /* stack index of last argument to 'match' */
+  int firstcap;  /* stack index of first capture pushed in the stack */
+  const char *s;  /* original string */
+  int valuecached;  /* value stored in cache slot */
+  int reclevel;  /* recursion level */
+} CapState;
+
+
+#define captype(cap)    ((cap)->kind)
+
+#define isclosecap(cap) (captype(cap) == Cclose)
+#define isopencap(cap)  ((cap)->siz == 0)
+
+/* true if c2 is (any number of levels) inside c1 */
+#define capinside(c1,c2)  \
+	(isopencap(c1) ? !isclosecap(c2) \
+                       : (c2)->index < (c1)->index + (c1)->siz - 1)
+
+
+/**
+** Maximum number of captures to visit when looking for an 'open'.
+*/
+#define MAXLOP		20
+
+
+
+int runtimecap (CapState *cs, Capture *close, const char *s, int *rem);
+int getcaptures (lua_State *L, const char *s, const char *r, int ptop);
+int finddyncap (Capture *cap, Capture *last);
+
+#endif
+
+

src/lua/lpeg-1.1.0/lpcode.h

@@ -0,0 +1,36 @@
+
+#if !defined(lpcode_h)
+#define lpcode_h
+
+#include "lua.h"
+
+#include "lptypes.h"
+#include "lptree.h"
+#include "lpvm.h"
+
+int checkaux (TTree *tree, int pred);
+int fixedlen (TTree *tree);
+int hascaptures (TTree *tree);
+int lp_gc (lua_State *L);
+Instruction *compile (lua_State *L, Pattern *p, uint size);
+void freecode (lua_State *L, Pattern *p);
+int sizei (const Instruction *i);
+
+
+#define PEnullable      0
+#define PEnofail        1
+
+/*
+** nofail(t) implies that 't' cannot fail with any input
+*/
+#define nofail(t)	checkaux(t, PEnofail)
+
+/*
+** (not nullable(t)) implies 't' cannot match without consuming
+** something
+*/
+#define nullable(t)	checkaux(t, PEnullable)
+
+
+
+#endif

src/lua/lpeg-1.1.0/lpcset.c

@@ -0,0 +1,110 @@
+
+#include "lptypes.h"
+#include "lpcset.h"
+
+
+/*
+** Add to 'c' the index of the (only) bit set in byte 'b'
+*/
+static int onlybit (int c, int b) {
+  if ((b & 0xF0) != 0) { c += 4; b >>= 4; }
+  if ((b & 0x0C) != 0) { c += 2; b >>= 2; }
+  if ((b & 0x02) != 0) { c += 1; }
+  return c;
+}
+
+
+/*
+** Check whether a charset is empty (returns IFail), singleton (IChar),
+** full (IAny), or none of those (ISet). When singleton, 'info.offset'
+** returns which character it is. When generic set, 'info' returns
+** information about its range.
+*/
+Opcode charsettype (const byte *cs, charsetinfo *info) {
+  int low0, low1, high0, high1;
+  for (low1 = 0; low1 < CHARSETSIZE && cs[low1] == 0; low1++)
+    /* find lowest byte with a 1-bit */;
+  if (low1 == CHARSETSIZE)
+    return IFail;  /* no characters in set */
+  for (high1 = CHARSETSIZE - 1; cs[high1] == 0; high1--)
+    /* find highest byte with a 1-bit; low1 is a sentinel */;
+  if (low1 == high1) {  /* only one byte with 1-bits? */
+    int b = cs[low1];
+    if ((b & (b - 1)) == 0) {  /* does byte has only one 1-bit? */
+      info->offset = onlybit(low1 * BITSPERCHAR, b);  /* get that bit */
+      return IChar;  /* single character */
+    }
+  }
+  for (low0 = 0; low0 < CHARSETSIZE && cs[low0] == 0xFF; low0++)
+    /* find lowest byte with a 0-bit */;
+  if (low0 == CHARSETSIZE)
+    return IAny;  /* set has all bits set */
+  for (high0 = CHARSETSIZE - 1; cs[high0] == 0xFF; high0--)
+    /* find highest byte with a 0-bit; low0 is a sentinel */;
+  if (high1 - low1 <= high0 - low0) {  /* range of 1s smaller than of 0s? */
+    info->offset = low1;
+    info->size = high1 - low1 + 1;
+    info->deflt = 0;  /* all discharged bits were 0 */
+  }
+  else {
+    info->offset = low0;
+    info->size = high0 - low0 + 1;
+    info->deflt = 0xFF;  /* all discharged bits were 1 */
+  }
+  info->cs = cs + info->offset;
+  return ISet;
+}
+
+
+/*
+** Get a byte from a compact charset. If index is inside the charset
+** range, get the byte from the supporting charset (correcting it
+** by the offset). Otherwise, return the default for the set.
+*/
+byte getbytefromcharset (const charsetinfo *info, int index) {
+  if (index < info->size)
+    return info->cs[index];
+  else return info->deflt;
+}
+
+
+/*
+** If 'tree' is a 'char' pattern (TSet, TChar, TAny, TFalse), convert it
+** into a charset and return 1; else return 0.
+*/
+int tocharset (TTree *tree, Charset *cs) {
+  switch (tree->tag) {
+    case TChar: {  /* only one char */
+      assert(0 <= tree->u.n && tree->u.n <= UCHAR_MAX);
+      clearset(cs->cs);  /* erase all chars */
+      setchar(cs->cs, tree->u.n);  /* add that one */
+      return 1;
+    }
+    case TAny: {
+      fillset(cs->cs, 0xFF);  /* add all characters to the set */
+      return 1;
+    }
+    case TFalse: {
+      clearset(cs->cs);  /* empty set */
+      return 1;
+    }
+    case TSet: {  /* fill set */
+      int i;
+      fillset(cs->cs, tree->u.set.deflt);
+      for (i = 0; i < tree->u.set.size; i++)
+        cs->cs[tree->u.set.offset + i] = treebuffer(tree)[i];
+      return 1;
+    }
+    default: return 0;
+  }
+}
+
+
+void tree2cset (TTree *tree, charsetinfo *info) {
+  assert(tree->tag == TSet);
+  info->offset = tree->u.set.offset;
+  info->size = tree->u.set.size;
+  info->deflt = tree->u.set.deflt;
+  info->cs = treebuffer(tree);
+}
+

src/lua/lpeg-1.1.0/lpcset.h

@@ -0,0 +1,30 @@
+
+#if !defined(lpset_h)
+#define lpset_h
+
+#include "lpcset.h"
+#include "lpcode.h"
+#include "lptree.h"
+
+
+/*
+** Extra information for the result of 'charsettype'.  When result is
+** IChar, 'offset' is the character.  When result is ISet, 'cs' is the
+** supporting bit array (with offset included), 'offset' is the offset
+** (in bytes), 'size' is the size (in bytes), and 'delt' is the default
+** value for bytes outside the set.
+*/
+typedef struct {
+  const byte *cs;
+  int offset;
+  int size;
+  int deflt;
+} charsetinfo;
+
+
+int tocharset (TTree *tree, Charset *cs);
+Opcode charsettype (const byte *cs, charsetinfo *info);
+byte getbytefromcharset (const charsetinfo *info, int index);
+void tree2cset (TTree *tree, charsetinfo *info);
+
+#endif

src/lua/lpeg-1.1.0/lpprint.c

@@ -0,0 +1,298 @@
+
+#include <ctype.h>
+#include <limits.h>
+#include <stdio.h>
+
+
+#include "lptypes.h"
+#include "lpprint.h"
+#include "lpcode.h"
+
+
+#if defined(LPEG_DEBUG)
+
+/*
+** {======================================================
+** Printing patterns (for debugging)
+** =======================================================
+*/
+
+
+void printcharset (const byte *st) {
+  int i;
+  printf("[");
+  for (i = 0; i <= UCHAR_MAX; i++) {
+    int first = i;
+    while (i <= UCHAR_MAX && testchar(st, i)) i++;
+    if (i - 1 == first)  /* unary range? */
+      printf("(%02x)", first);
+    else if (i - 1 > first)  /* non-empty range? */
+      printf("(%02x-%02x)", first, i - 1);
+  }
+  printf("]");
+}
+
+
+static void printIcharset (const Instruction *inst, const byte *buff) {
+  byte cs[CHARSETSIZE];
+  int i;
+  printf("(%02x-%d) ", inst->i.aux2.set.offset, inst->i.aux2.set.size);
+  clearset(cs);
+  for (i = 0; i < CHARSETSIZE * 8; i++) {
+    if (charinset(inst, buff, i))
+      setchar(cs, i);
+  }
+  printcharset(cs);
+}
+
+
+static void printTcharset (TTree *tree) {
+  byte cs[CHARSETSIZE];
+  int i;
+  printf("(%02x-%d) ", tree->u.set.offset, tree->u.set.size);
+  fillset(cs, tree->u.set.deflt);
+  for (i = 0; i < tree->u.set.size; i++)
+    cs[tree->u.set.offset + i] = treebuffer(tree)[i];
+  printcharset(cs);
+}
+
+
+static const char *capkind (int kind) {
+  const char *const modes[] = {
+    "close", "position", "constant", "backref",
+    "argument", "simple", "table", "function", "accumulator",
+    "query", "string", "num", "substitution", "fold",
+    "runtime", "group"};
+  return modes[kind];
+}
+
+
+static void printjmp (const Instruction *op, const Instruction *p) {
+  printf("-> %d", (int)(p + (p + 1)->offset - op));
+}
+
+
+void printinst (const Instruction *op, const Instruction *p) {
+  const char *const names[] = {
+    "any", "char", "set",
+    "testany", "testchar", "testset",
+    "span", "utf-range", "behind",
+    "ret", "end",
+    "choice", "jmp", "call", "open_call",
+    "commit", "partial_commit", "back_commit", "failtwice", "fail", "giveup",
+     "fullcapture", "opencapture", "closecapture", "closeruntime",
+     "--"
+  };
+  printf("%02ld: %s ", (long)(p - op), names[p->i.code]);
+  switch ((Opcode)p->i.code) {
+    case IChar: {
+      printf("'%c' (%02x)", p->i.aux1, p->i.aux1);
+      break;
+    }
+    case ITestChar: {
+      printf("'%c' (%02x)", p->i.aux1, p->i.aux1); printjmp(op, p);
+      break;
+    }
+    case IUTFR: {
+      printf("%d - %d", p[1].offset, utf_to(p));
+      break;
+    }
+    case IFullCapture: {
+      printf("%s (size = %d)  (idx = %d)",
+             capkind(getkind(p)), getoff(p), p->i.aux2.key);
+      break;
+    }
+    case IOpenCapture: {
+      printf("%s (idx = %d)", capkind(getkind(p)), p->i.aux2.key);
+      break;
+    }
+    case ISet: {
+      printIcharset(p, (p+1)->buff);
+      break;
+    }
+    case ITestSet: {
+      printIcharset(p, (p+2)->buff); printjmp(op, p);
+      break;
+    }
+    case ISpan: {
+      printIcharset(p, (p+1)->buff);
+      break;
+    }
+    case IOpenCall: {
+      printf("-> %d", (p + 1)->offset);
+      break;
+    }
+    case IBehind: {
+      printf("%d", p->i.aux1);
+      break;
+    }
+    case IJmp: case ICall: case ICommit: case IChoice:
+    case IPartialCommit: case IBackCommit: case ITestAny: {
+      printjmp(op, p);
+      break;
+    }
+    default: break;
+  }
+  printf("\n");
+}
+
+
+void printpatt (Instruction *p) {
+  Instruction *op = p;
+  uint n = op[-1].codesize - 1;
+  while (p < op + n) {
+    printinst(op, p);
+    p += sizei(p);
+  }
+}
+
+
+static void printcap (Capture *cap, int ident) {
+  while (ident--) printf(" ");
+  printf("%s (idx: %d - size: %d) -> %lu  (%p)\n",
+         capkind(cap->kind), cap->idx, cap->siz, (long)cap->index, (void*)cap);
+}
+
+
+/*
+** Print a capture and its nested captures
+*/
+static Capture *printcap2close (Capture *cap, int ident) {
+  Capture *head = cap++;
+  printcap(head, ident);  /* print head capture */
+  while (capinside(head, cap))
+    cap = printcap2close(cap, ident + 2);  /* print nested captures */
+  if (isopencap(head)) {
+    assert(isclosecap(cap));
+    printcap(cap++, ident);  /* print and skip close capture */
+  }
+  return cap;
+}
+
+
+void printcaplist (Capture *cap) {
+  {  /* for debugging, print first a raw list of captures */
+    Capture *c = cap;
+    while (c->index != MAXINDT) { printcap(c, 0); c++; }
+  }
+  printf(">======\n");
+  while (!isclosecap(cap))
+    cap = printcap2close(cap, 0);
+  printf("=======\n");
+}
+
+/* }====================================================== */
+
+
+/*
+** {======================================================
+** Printing trees (for debugging)
+** =======================================================
+*/
+
+static const char *tagnames[] = {
+  "char", "set", "any",
+  "true", "false", "utf8.range",
+  "rep",
+  "seq", "choice",
+  "not", "and",
+  "call", "opencall", "rule", "xinfo", "grammar",
+  "behind",
+  "capture", "run-time"
+};
+
+
+void printtree (TTree *tree, int ident) {
+  int i;
+  int sibs = numsiblings[tree->tag];
+  for (i = 0; i < ident; i++) printf(" ");
+  printf("%s", tagnames[tree->tag]);
+  switch (tree->tag) {
+    case TChar: {
+      int c = tree->u.n;
+      if (isprint(c))
+        printf(" '%c'\n", c);
+      else
+        printf(" (%02X)\n", c);
+      break;
+    }
+    case TSet: {
+      printTcharset(tree);
+      printf("\n");
+      break;
+    }
+    case TUTFR: {
+      assert(sib1(tree)->tag == TXInfo);
+      printf(" %d (%02x %d) - %d (%02x %d) \n",
+        tree->u.n, tree->key, tree->cap,
+        sib1(tree)->u.n, sib1(tree)->key, sib1(tree)->cap);
+      break;
+    }
+    case TOpenCall: case TCall: {
+      assert(sib1(sib2(tree))->tag == TXInfo);
+      printf(" key: %d  (rule: %d)\n", tree->key, sib1(sib2(tree))->u.n);
+      break;
+    }
+    case TBehind: {
+      printf(" %d\n", tree->u.n);
+      break;
+    }
+    case TCapture: {
+      printf(" kind: '%s'  key: %d\n", capkind(tree->cap), tree->key);
+      break;
+    }
+    case TRule: {
+      printf(" key: %d\n", tree->key);
+      sibs = 1;  /* do not print 'sib2' (next rule) as a sibling */
+      break;
+    }
+    case TXInfo: {
+      printf(" n: %d\n", tree->u.n);
+      break;
+    }
+    case TGrammar: {
+      TTree *rule = sib1(tree);
+      printf(" %d\n", tree->u.n);  /* number of rules */
+      for (i = 0; i < tree->u.n; i++) {
+        printtree(rule, ident + 2);
+        rule = sib2(rule);
+      }
+      assert(rule->tag == TTrue);  /* sentinel */
+      sibs = 0;  /* siblings already handled */
+      break;
+    }
+    default:
+      printf("\n");
+      break;
+  }
+  if (sibs >= 1) {
+    printtree(sib1(tree), ident + 2);
+    if (sibs >= 2)
+      printtree(sib2(tree), ident + 2);
+  }
+}
+
+
+void printktable (lua_State *L, int idx) {
+  int n, i;
+  lua_getuservalue(L, idx);
+  if (lua_isnil(L, -1))  /* no ktable? */
+    return;
+  n = lua_rawlen(L, -1);
+  printf("[");
+  for (i = 1; i <= n; i++) {
+    printf("%d = ", i);
+    lua_rawgeti(L, -1, i);
+    if (lua_isstring(L, -1))
+      printf("%s  ", lua_tostring(L, -1));
+    else
+      printf("%s  ", lua_typename(L, lua_type(L, -1)));
+    lua_pop(L, 1);
+  }
+  printf("]\n");
+  /* leave ktable at the stack */
+}
+
+/* }====================================================== */
+
+#endif

src/lua/lpeg-1.1.0/lpprint.h

@@ -0,0 +1,32 @@
+
+#if !defined(lpprint_h)
+#define lpprint_h
+
+
+#include "lptree.h"
+#include "lpvm.h"
+
+
+#if defined(LPEG_DEBUG)
+
+void printpatt (Instruction *p);
+void printtree (TTree *tree, int ident);
+void printktable (lua_State *L, int idx);
+void printcharset (const byte *st);
+void printcaplist (Capture *cap);
+void printinst (const Instruction *op, const Instruction *p);
+
+#else
+
+#define printktable(L,idx)  \
+	luaL_error(L, "function only implemented in debug mode")
+#define printtree(tree,i)  \
+	luaL_error(L, "function only implemented in debug mode")
+#define printpatt(p)  \
+	luaL_error(L, "function only implemented in debug mode")
+
+#endif
+
+
+#endif
+

src/lua/lpeg-1.1.0/lptree.h

@@ -0,0 +1,92 @@
+
+#if !defined(lptree_h)
+#define lptree_h
+
+
+#include "lptypes.h"
+
+
+/*
+** types of trees
+*/
+typedef enum TTag {
+  TChar = 0,  /* 'n' = char */
+  TSet,  /* the set is encoded in 'u.set' and the next 'u.set.size' bytes */
+  TAny,
+  TTrue,
+  TFalse,
+  TUTFR,  /* range of UTF-8 codepoints; 'n' has initial codepoint;
+             'cap' has length; 'key' has first byte;
+             extra info is similar for end codepoint */
+  TRep,  /* 'sib1'* */
+  TSeq,  /* 'sib1' 'sib2' */
+  TChoice,  /* 'sib1' / 'sib2' */
+  TNot,  /* !'sib1' */
+  TAnd,  /* &'sib1' */
+  TCall,  /* ktable[key] is rule's key; 'sib2' is rule being called */
+  TOpenCall,  /* ktable[key] is rule's key */
+  TRule,  /* ktable[key] is rule's key (but key == 0 for unused rules);
+             'sib1' is rule's pattern pre-rule; 'sib2' is next rule;
+             extra info 'n' is rule's sequential number */
+  TXInfo,  /* extra info */
+  TGrammar,  /* 'sib1' is initial (and first) rule */
+  TBehind,  /* 'sib1' is pattern, 'n' is how much to go back */
+  TCapture,  /* captures: 'cap' is kind of capture (enum 'CapKind');
+                ktable[key] is Lua value associated with capture;
+                'sib1' is capture body */
+  TRunTime  /* run-time capture: 'key' is Lua function;
+               'sib1' is capture body */
+} TTag;
+
+
+/*
+** Tree trees
+** The first child of a tree (if there is one) is immediately after
+** the tree.  A reference to a second child (ps) is its position
+** relative to the position of the tree itself.
+*/
+typedef struct TTree {
+  byte tag;
+  byte cap;  /* kind of capture (if it is a capture) */
+  unsigned short key;  /* key in ktable for Lua data (0 if no key) */
+  union {
+    int ps;  /* occasional second child */
+    int n;  /* occasional counter */
+    struct {
+      byte offset;  /* compact set offset (in bytes) */
+      byte size;  /* compact set size (in bytes) */
+      byte deflt;  /* default value */
+      byte bitmap[1];  /* bitmap (open array) */
+    } set;  /* for compact sets */
+  } u;
+} TTree;
+
+
+/* access to charset */
+#define treebuffer(t)      ((t)->u.set.bitmap)
+
+
+/*
+** A complete pattern has its tree plus, if already compiled,
+** its corresponding code
+*/
+typedef struct Pattern {
+  union Instruction *code;
+  TTree tree[1];
+} Pattern;
+
+
+/* number of children for each tree */
+extern const byte numsiblings[];
+
+/* access to children */
+#define sib1(t)         ((t) + 1)
+#define sib2(t)         ((t) + (t)->u.ps)
+
+
+
+
+
+
+#endif
+

src/lua/lpeg-1.1.0/lptypes.h

@@ -0,0 +1,150 @@
+/*
+** LPeg - PEG pattern matching for Lua
+** Copyright 2007-2023, Lua.org & PUC-Rio  (see 'lpeg.html' for license)
+** written by Roberto Ierusalimschy
+*/
+
+#if !defined(lptypes_h)
+#define lptypes_h
+
+
+#include <assert.h>
+#include <limits.h>
+#include <string.h>
+
+#include "lua.h"
+
+
+#define VERSION         "1.1.0"
+
+
+#define PATTERN_T	"lpeg-pattern"
+#define MAXSTACKIDX	"lpeg-maxstack"
+
+
+/*
+** compatibility with Lua 5.1
+*/
+#if (LUA_VERSION_NUM == 501)
+
+#define lp_equal	lua_equal
+
+#define lua_getuservalue	lua_getfenv
+#define lua_setuservalue	lua_setfenv
+
+#define lua_rawlen		lua_objlen
+
+#define luaL_setfuncs(L,f,n)	luaL_register(L,NULL,f)
+#define luaL_newlib(L,f)	luaL_register(L,"lpeg",f)
+
+typedef size_t lua_Unsigned;
+
+#endif
+
+
+#if !defined(lp_equal)
+#define lp_equal(L,idx1,idx2)  lua_compare(L,(idx1),(idx2),LUA_OPEQ)
+#endif
+
+
+/* default maximum size for call/backtrack stack */
+#if !defined(MAXBACK)
+#define MAXBACK         400
+#endif
+
+
+/* maximum number of rules in a grammar (limited by 'unsigned short') */
+#if !defined(MAXRULES)
+#define MAXRULES        1000
+#endif
+
+
+
+/* initial size for capture's list */
+#define INITCAPSIZE	32
+
+
+/* index, on Lua stack, for subject */
+#define SUBJIDX		2
+
+/* number of fixed arguments to 'match' (before capture arguments) */
+#define FIXEDARGS	3
+
+/* index, on Lua stack, for capture list */
+#define caplistidx(ptop)	((ptop) + 2)
+
+/* index, on Lua stack, for pattern's ktable */
+#define ktableidx(ptop)		((ptop) + 3)
+
+/* index, on Lua stack, for backtracking stack */
+#define stackidx(ptop)	((ptop) + 4)
+
+
+
+typedef unsigned char byte;
+
+typedef unsigned int uint;
+
+
+#define BITSPERCHAR		8
+
+#define CHARSETSIZE		((UCHAR_MAX/BITSPERCHAR) + 1)
+
+
+
+typedef struct Charset {
+  byte cs[CHARSETSIZE];
+} Charset;
+
+
+
+#define loopset(v,b)    { int v; for (v = 0; v < CHARSETSIZE; v++) {b;} }
+
+#define fillset(s,c)	memset(s,c,CHARSETSIZE)
+#define clearset(s)	fillset(s,0)
+
+/* number of slots needed for 'n' bytes */
+#define bytes2slots(n)  (((n) - 1u) / (uint)sizeof(TTree) + 1u)
+
+/* set 'b' bit in charset 'cs' */
+#define setchar(cs,b)   ((cs)[(b) >> 3] |= (1 << ((b) & 7)))
+
+
+/*
+** in capture instructions, 'kind' of capture and its offset are
+** packed in field 'aux', 4 bits for each
+*/
+#define getkind(op)		((op)->i.aux1 & 0xF)
+#define getoff(op)		(((op)->i.aux1 >> 4) & 0xF)
+#define joinkindoff(k,o)	((k) | ((o) << 4))
+
+#define MAXOFF		0xF
+#define MAXAUX		0xFF
+
+
+/* maximum number of bytes to look behind */
+#define MAXBEHIND	MAXAUX
+
+
+/* maximum size (in elements) for a pattern */
+#define MAXPATTSIZE	(SHRT_MAX - 10)
+
+
+/* size (in instructions) for l bytes (l > 0) */
+#define instsize(l) ((int)(((l) + (uint)sizeof(Instruction) - 1u) \
+			/ (uint)sizeof(Instruction)))
+
+
+/* size (in elements) for a ISet instruction */
+#define CHARSETINSTSIZE		(1 + instsize(CHARSETSIZE))
+
+/* size (in elements) for a IFunc instruction */
+#define funcinstsize(p)		((p)->i.aux + 2)
+
+
+
+#define testchar(st,c)	((((uint)(st)[((c) >> 3)]) >> ((c) & 7)) & 1)
+
+
+#endif
+

src/lua/lpeg-1.1.0/lpvm.c

@@ -0,0 +1,455 @@
+
+#include <limits.h>
+#include <string.h>
+
+
+#include "lua.h"
+#include "lauxlib.h"
+
+#include "lpcap.h"
+#include "lptypes.h"
+#include "lpvm.h"
+#include "lpprint.h"
+
+
+/* initial size for call/backtrack stack */
+#if !defined(INITBACK)
+#define INITBACK	MAXBACK
+#endif
+
+
+#define getoffset(p)	(((p) + 1)->offset)
+
+static const Instruction giveup = {{IGiveup, 0, {0}}};
+
+
+int charinset (const Instruction *i, const byte *buff, uint c) {
+  c -= i->i.aux2.set.offset;
+  if (c >= ((uint)i->i.aux2.set.size  /* size in instructions... */
+           * (uint)sizeof(Instruction)  /* in bytes... */
+           * 8u))  /* in bits */
+    return i->i.aux1;  /* out of range; return default value */
+  return testchar(buff, c);
+}
+
+
+/*
+** Decode one UTF-8 sequence, returning NULL if byte sequence is invalid.
+*/
+static const char *utf8_decode (const char *o, int *val) {
+  static const uint limits[] = {0xFF, 0x7F, 0x7FF, 0xFFFFu};
+  const unsigned char *s = (const unsigned char *)o;
+  uint c = s[0];  /* first byte */
+  uint res = 0;  /* final result */
+  if (c < 0x80)  /* ascii? */
+    res = c;
+  else {
+    int count = 0;  /* to count number of continuation bytes */
+    while (c & 0x40) {  /* still have continuation bytes? */
+      int cc = s[++count];  /* read next byte */
+      if ((cc & 0xC0) != 0x80)  /* not a continuation byte? */
+        return NULL;  /* invalid byte sequence */
+      res = (res << 6) | (cc & 0x3F);  /* add lower 6 bits from cont. byte */
+      c <<= 1;  /* to test next bit */
+    }
+    res |= (c & 0x7F) << (count * 5);  /* add first byte */
+    if (count > 3 || res > 0x10FFFFu || res <= limits[count])
+      return NULL;  /* invalid byte sequence */
+    s += count;  /* skip continuation bytes read */
+  }
+  *val = res;
+  return (const char *)s + 1;  /* +1 to include first byte */
+}
+
+
+/*
+** {======================================================
+** Virtual Machine
+** =======================================================
+*/
+
+
+typedef struct Stack {
+  const char *s;  /* saved position (or NULL for calls) */
+  const Instruction *p;  /* next instruction */
+  int caplevel;
+} Stack;
+
+
+#define getstackbase(L, ptop)	((Stack *)lua_touserdata(L, stackidx(ptop)))
+
+
+/*
+** Ensures the size of array 'capture' (with size '*capsize' and
+** 'captop' elements being used) is enough to accomodate 'n' extra
+** elements plus one.  (Because several opcodes add stuff to the capture
+** array, it is simpler to ensure the array always has at least one free
+** slot upfront and check its size later.)
+*/
+
+/* new size in number of elements cannot overflow integers, and new
+   size in bytes cannot overflow size_t. */
+#define MAXNEWSIZE  \
+    (((size_t)INT_MAX) <= (~(size_t)0 / sizeof(Capture)) ?  \
+     ((size_t)INT_MAX) : (~(size_t)0 / sizeof(Capture)))
+
+static Capture *growcap (lua_State *L, Capture *capture, int *capsize,
+                                       int captop, int n, int ptop) {
+  if (*capsize - captop > n)
+    return capture;  /* no need to grow array */
+  else {  /* must grow */
+    Capture *newc;
+    uint newsize = captop + n + 1;  /* minimum size needed */
+    if (newsize < (MAXNEWSIZE / 3) * 2)
+      newsize += newsize / 2;  /* 1.5 that size, if not too big */
+    else if (newsize < (MAXNEWSIZE / 9) * 8)
+      newsize += newsize / 8;  /* else, try 9/8 that size */
+    else
+      luaL_error(L, "too many captures");
+    newc = (Capture *)lua_newuserdata(L, newsize * sizeof(Capture));
+    memcpy(newc, capture, captop * sizeof(Capture));
+    *capsize = newsize;
+    lua_replace(L, caplistidx(ptop));
+    return newc;
+  }
+}
+
+
+/*
+** Double the size of the stack
+*/
+static Stack *doublestack (lua_State *L, Stack **stacklimit, int ptop) {
+  Stack *stack = getstackbase(L, ptop);
+  Stack *newstack;
+  int n = *stacklimit - stack;  /* current stack size */
+  int max, newn;
+  lua_getfield(L, LUA_REGISTRYINDEX, MAXSTACKIDX);
+  max = lua_tointeger(L, -1);  /* maximum allowed size */
+  lua_pop(L, 1);
+  if (n >= max)  /* already at maximum size? */
+    luaL_error(L, "backtrack stack overflow (current limit is %d)", max);
+  newn = 2 * n;  /* new size */
+  if (newn > max) newn = max;
+  newstack = (Stack *)lua_newuserdata(L, newn * sizeof(Stack));
+  memcpy(newstack, stack, n * sizeof(Stack));
+  lua_replace(L, stackidx(ptop));
+  *stacklimit = newstack + newn;
+  return newstack + n;  /* return next position */
+}
+
+
+/*
+** Interpret the result of a dynamic capture: false -> fail;
+** true -> keep current position; number -> next position.
+** Return new subject position. 'fr' is stack index where
+** is the result; 'curr' is current subject position; 'limit'
+** is subject's size.
+*/
+static int resdyncaptures (lua_State *L, int fr, int curr, int limit) {
+  lua_Integer res;
+  if (!lua_toboolean(L, fr)) {  /* false value? */
+    lua_settop(L, fr - 1);  /* remove results */
+    return -1;  /* and fail */
+  }
+  else if (lua_isboolean(L, fr))  /* true? */
+    res = curr;  /* keep current position */
+  else {
+    res = lua_tointeger(L, fr) - 1;  /* new position */
+    if (res < curr || res > limit)
+      luaL_error(L, "invalid position returned by match-time capture");
+  }
+  lua_remove(L, fr);  /* remove first result (offset) */
+  return res;
+}
+
+
+/*
+** Add capture values returned by a dynamic capture to the list
+** 'capture', nested inside a group. 'fd' indexes the first capture
+** value, 'n' is the number of values (at least 1). The open group
+** capture is already in 'capture', before the place for the new entries.
+*/
+static void adddyncaptures (Index_t index, Capture *capture, int n, int fd) {
+  int i;
+  assert(capture[-1].kind == Cgroup && capture[-1].siz == 0);
+  capture[-1].idx = 0;  /* make group capture an anonymous group */
+  for (i = 0; i < n; i++) {  /* add runtime captures */
+    capture[i].kind = Cruntime;
+    capture[i].siz = 1;  /* mark it as closed */
+    capture[i].idx = fd + i;  /* stack index of capture value */
+    capture[i].index = index;
+  }
+  capture[n].kind = Cclose;  /* close group */
+  capture[n].siz = 1;
+  capture[n].index = index;
+}
+
+
+/*
+** Remove dynamic captures from the Lua stack (called in case of failure)
+*/
+static int removedyncap (lua_State *L, Capture *capture,
+                         int level, int last) {
+  int id = finddyncap(capture + level, capture + last);  /* index of 1st cap. */
+  int top = lua_gettop(L);
+  if (id == 0) return 0;  /* no dynamic captures? */
+  lua_settop(L, id - 1);  /* remove captures */
+  return top - id + 1;  /* number of values removed */
+}
+
+
+/*
+** Find the corresponding 'open' capture before 'cap', when that capture
+** can become a full capture. If a full capture c1 is followed by an
+** empty capture c2, there is no way to know whether c2 is inside
+** c1. So, full captures can enclose only captures that start *before*
+** its end.
+*/
+static Capture *findopen (Capture *cap, Index_t currindex) {
+  int i;
+  cap--;  /* check last capture */
+  /* Must it be inside current one, but starts where current one ends? */
+  if (!isopencap(cap) && cap->index == currindex)
+    return NULL;  /* current one cannot be a full capture */
+  /* else, look for an 'open' capture */
+  for (i = 0; i < MAXLOP; i++, cap--) {
+    if (currindex - cap->index >= UCHAR_MAX)
+      return NULL;  /* capture too long for a full capture */
+    else if (isopencap(cap))  /* open capture? */
+      return cap;  /* that's the one to be closed */
+    else if (cap->kind == Cclose)
+      return NULL;  /* a full capture should not nest a non-full one */
+  }
+  return NULL;  /* not found within allowed search limit */
+}
+
+
+/*
+** Opcode interpreter
+*/
+const char *match (lua_State *L, const char *o, const char *s, const char *e,
+                   Instruction *op, Capture *capture, int ptop) {
+  Stack stackbase[INITBACK];
+  Stack *stacklimit = stackbase + INITBACK;
+  Stack *stack = stackbase;  /* point to first empty slot in stack */
+  int capsize = INITCAPSIZE;
+  int captop = 0;  /* point to first empty slot in captures */
+  int ndyncap = 0;  /* number of dynamic captures (in Lua stack) */
+  const Instruction *p = op;  /* current instruction */
+  stack->p = &giveup; stack->s = s; stack->caplevel = 0; stack++;
+  lua_pushlightuserdata(L, stackbase);
+  for (;;) {
+#if defined(DEBUG)
+      printf("-------------------------------------\n");
+      printcaplist(capture, capture + captop);
+      printf("s: |%s| stck:%d, dyncaps:%d, caps:%d  ",
+             s, (int)(stack - getstackbase(L, ptop)), ndyncap, captop);
+      printinst(op, p);
+#endif
+    assert(stackidx(ptop) + ndyncap == lua_gettop(L) && ndyncap <= captop);
+    switch ((Opcode)p->i.code) {
+      case IEnd: {
+        assert(stack == getstackbase(L, ptop) + 1);
+        capture[captop].kind = Cclose;
+        capture[captop].index = MAXINDT;
+        return s;
+      }
+      case IGiveup: {
+        assert(stack == getstackbase(L, ptop));
+        return NULL;
+      }
+      case IRet: {
+        assert(stack > getstackbase(L, ptop) && (stack - 1)->s == NULL);
+        p = (--stack)->p;
+        continue;
+      }
+      case IAny: {
+        if (s < e) { p++; s++; }
+        else goto fail;
+        continue;
+      }
+      case IUTFR: {
+        int codepoint;
+        if (s >= e)
+          goto fail;
+        s = utf8_decode (s, &codepoint);
+        if (s && p[1].offset <= codepoint && codepoint <= utf_to(p))
+          p += 2;
+        else
+          goto fail;
+        continue;
+      }
+      case ITestAny: {
+        if (s < e) p += 2;
+        else p += getoffset(p);
+        continue;
+      }
+      case IChar: {
+        if ((byte)*s == p->i.aux1 && s < e) { p++; s++; }
+        else goto fail;
+        continue;
+      }
+      case ITestChar: {
+        if ((byte)*s == p->i.aux1 && s < e) p += 2;
+        else p += getoffset(p);
+        continue;
+      }
+      case ISet: {
+        uint c = (byte)*s;
+        if (charinset(p, (p+1)->buff, c) && s < e)
+          { p += 1 + p->i.aux2.set.size; s++; }
+        else goto fail;
+        continue;
+      }
+      case ITestSet: {
+        uint c = (byte)*s;
+        if (charinset(p, (p + 2)->buff, c) && s < e)
+          p += 2 + p->i.aux2.set.size;
+        else p += getoffset(p);
+        continue;
+      }
+      case IBehind: {
+        int n = p->i.aux1;
+        if (n > s - o) goto fail;
+        s -= n; p++;
+        continue;
+      }
+      case ISpan: {
+        for (; s < e; s++) {
+          uint c = (byte)*s;
+          if (!charinset(p, (p+1)->buff, c)) break;
+        }
+        p += 1 + p->i.aux2.set.size;
+        continue;
+      }
+      case IJmp: {
+        p += getoffset(p);
+        continue;
+      }
+      case IChoice: {
+        if (stack == stacklimit)
+          stack = doublestack(L, &stacklimit, ptop);
+        stack->p = p + getoffset(p);
+        stack->s = s;
+        stack->caplevel = captop;
+        stack++;
+        p += 2;
+        continue;
+      }
+      case ICall: {
+        if (stack == stacklimit)
+          stack = doublestack(L, &stacklimit, ptop);
+        stack->s = NULL;
+        stack->p = p + 2;  /* save return address */
+        stack++;
+        p += getoffset(p);
+        continue;
+      }
+      case ICommit: {
+        assert(stack > getstackbase(L, ptop) && (stack - 1)->s != NULL);
+        stack--;
+        p += getoffset(p);
+        continue;
+      }
+      case IPartialCommit: {
+        assert(stack > getstackbase(L, ptop) && (stack - 1)->s != NULL);
+        (stack - 1)->s = s;
+        (stack - 1)->caplevel = captop;
+        p += getoffset(p);
+        continue;
+      }
+      case IBackCommit: {
+        assert(stack > getstackbase(L, ptop) && (stack - 1)->s != NULL);
+        s = (--stack)->s;
+        if (ndyncap > 0)  /* are there matchtime captures? */
+          ndyncap -= removedyncap(L, capture, stack->caplevel, captop);
+        captop = stack->caplevel;
+        p += getoffset(p);
+        continue;
+      }
+      case IFailTwice:
+        assert(stack > getstackbase(L, ptop));
+        stack--;
+        /* FALLTHROUGH */
+      case IFail:
+      fail: { /* pattern failed: try to backtrack */
+        do {  /* remove pending calls */
+          assert(stack > getstackbase(L, ptop));
+          s = (--stack)->s;
+        } while (s == NULL);
+        if (ndyncap > 0)  /* is there matchtime captures? */
+          ndyncap -= removedyncap(L, capture, stack->caplevel, captop);
+        captop = stack->caplevel;
+        p = stack->p;
+#if defined(DEBUG)
+        printf("**FAIL**\n");
+#endif
+        continue;
+      }
+      case ICloseRunTime: {
+        CapState cs;
+        int rem, res, n;
+        int fr = lua_gettop(L) + 1;  /* stack index of first result */
+        cs.reclevel = 0; cs.L = L;
+        cs.s = o; cs.ocap = capture; cs.ptop = ptop;
+        n = runtimecap(&cs, capture + captop, s, &rem);  /* call function */
+        captop -= n;  /* remove nested captures */
+        ndyncap -= rem;  /* update number of dynamic captures */
+        fr -= rem;  /* 'rem' items were popped from Lua stack */
+        res = resdyncaptures(L, fr, s - o, e - o);  /* get result */
+        if (res == -1)  /* fail? */
+          goto fail;
+        s = o + res;  /* else update current position */
+        n = lua_gettop(L) - fr + 1;  /* number of new captures */
+        ndyncap += n;  /* update number of dynamic captures */
+        if (n == 0)  /* no new captures? */
+          captop--;  /* remove open group */
+        else {  /* new captures; keep original open group */
+          if (fr + n >= SHRT_MAX)
+            luaL_error(L, "too many results in match-time capture");
+          /* add new captures + close group to 'capture' list */
+          capture = growcap(L, capture, &capsize, captop, n + 1, ptop);
+          adddyncaptures(s - o, capture + captop, n, fr);
+          captop += n + 1;  /* new captures + close group */
+        }
+        p++;
+        continue;
+      }
+      case ICloseCapture: {
+        Capture *open = findopen(capture + captop, s - o);
+        assert(captop > 0);
+        if (open) {  /* if possible, turn capture into a full capture */
+          open->siz = (s - o) - open->index + 1;
+          p++;
+          continue;
+        }
+        else {  /* must create a close capture */
+          capture[captop].siz = 1;  /* mark entry as closed */
+          capture[captop].index = s - o;
+          goto pushcapture;
+        }
+      }
+      case IOpenCapture:
+        capture[captop].siz = 0;  /* mark entry as open */
+        capture[captop].index = s - o;
+        goto pushcapture;
+      case IFullCapture:
+        capture[captop].siz = getoff(p) + 1;  /* save capture size */
+        capture[captop].index = s - o - getoff(p);
+        /* goto pushcapture; */
+      pushcapture: {
+        capture[captop].idx = p->i.aux2.key;
+        capture[captop].kind = getkind(p);
+        captop++;
+        capture = growcap(L, capture, &capsize, captop, 0, ptop);
+        p++;
+        continue;
+      }
+      default: assert(0); return NULL;
+    }
+  }
+}
+
+/* }====================================================== */
+
+

src/lua/lpeg-1.1.0/lpvm.h

@@ -0,0 +1,79 @@
+
+#if !defined(lpvm_h)
+#define lpvm_h
+
+#include "lpcap.h"
+
+
+/*
+** About Character sets in instructions: a set is a bit map with an
+** initial offset, in bits, and a size, in number of instructions.
+** aux1 has the default value for the bits outsize that range.
+*/
+
+
+/* Virtual Machine's instructions */
+typedef enum Opcode {
+  IAny, /* if no char, fail */
+  IChar,  /* if char != aux1, fail */
+  ISet,  /* if char not in set, fail */
+  ITestAny,  /* in no char, jump to 'offset' */
+  ITestChar,  /* if char != aux1, jump to 'offset' */
+  ITestSet,  /* if char not in set, jump to 'offset' */
+  ISpan,  /* read a span of chars in set */
+  IUTFR,  /* if codepoint not in range [offset, utf_to], fail */
+  IBehind,  /* walk back 'aux1' characters (fail if not possible) */
+  IRet,  /* return from a rule */
+  IEnd,  /* end of pattern */
+  IChoice,  /* stack a choice; next fail will jump to 'offset' */
+  IJmp,  /* jump to 'offset' */
+  ICall,  /* call rule at 'offset' */
+  IOpenCall,  /* call rule number 'key' (must be closed to a ICall) */
+  ICommit,  /* pop choice and jump to 'offset' */
+  IPartialCommit,  /* update top choice to current position and jump */
+  IBackCommit,  /* backtrack like "fail" but jump to its own 'offset' */
+  IFailTwice,  /* pop one choice and then fail */
+  IFail,  /* go back to saved state on choice and jump to saved offset */
+  IGiveup,  /* internal use */
+  IFullCapture,  /* complete capture of last 'off' chars */
+  IOpenCapture,  /* start a capture */
+  ICloseCapture,
+  ICloseRunTime,
+  IEmpty  /* to fill empty slots left by optimizations */
+} Opcode;
+
+
+/*
+** All array of instructions has a 'codesize' as its first element
+** and is referred by a pointer to its second element, which is the
+** first actual opcode.
+*/
+typedef union Instruction {
+  struct Inst {
+    byte code;
+    byte aux1;
+    union {
+      short key;
+      struct {
+        byte offset;
+        byte size;
+      } set;
+    } aux2;
+  } i;
+  int offset;
+  uint codesize;
+  byte buff[1];
+} Instruction;
+
+
+/* extract 24-bit value from an instruction */
+#define utf_to(inst)	(((inst)->i.aux2.key << 8) | (inst)->i.aux1)
+
+
+int charinset (const Instruction *i, const byte *buff, uint c);
+const char *match (lua_State *L, const char *o, const char *s, const char *e,
+                   Instruction *op, Capture *capture, int ptop);
+
+
+#endif
+

src/lua/lpeg-1.1.0/makefile

@@ -0,0 +1,59 @@
+LIBNAME = lpeg
+LUADIR = ./lua/
+
+COPT = -O2 -DNDEBUG
+# COPT = -O0 -DLPEG_DEBUG -g
+
+CWARNS = -Wall -Wextra -pedantic \
+	-Waggregate-return \
+	-Wcast-align \
+	-Wcast-qual \
+	-Wdisabled-optimization \
+	-Wpointer-arith \
+	-Wshadow \
+	-Wredundant-decls \
+	-Wsign-compare \
+	-Wundef \
+	-Wwrite-strings \
+	-Wbad-function-cast \
+	-Wdeclaration-after-statement \
+	-Wmissing-prototypes \
+	-Wmissing-declarations \
+	-Wnested-externs \
+	-Wstrict-prototypes \
+	-Wc++-compat \
+# -Wunreachable-code \
+
+
+CFLAGS = $(CWARNS) $(COPT) -std=c99 -I$(LUADIR) -fPIC
+CC = gcc
+
+FILES = lpvm.o lpcap.o lptree.o lpcode.o lpprint.o lpcset.o
+
+# For Linux
+linux:
+	$(MAKE) lpeg.so "DLLFLAGS = -shared -fPIC"
+
+# For Mac OS
+macosx:
+	$(MAKE) lpeg.so "DLLFLAGS = -bundle -undefined dynamic_lookup"
+
+lpeg.so: $(FILES)
+	env $(CC) $(DLLFLAGS) $(FILES) -o lpeg.so
+
+$(FILES): makefile
+
+test: test.lua re.lua lpeg.so
+	./test.lua
+
+clean:
+	rm -f $(FILES) lpeg.so
+
+
+lpcap.o: lpcap.c lpcap.h lptypes.h
+lpcode.o: lpcode.c lptypes.h lpcode.h lptree.h lpvm.h lpcap.h lpcset.h
+lpcset.o: lpcset.c lptypes.h lpcset.h lpcode.h lptree.h lpvm.h lpcap.h
+lpprint.o: lpprint.c lptypes.h lpprint.h lptree.h lpvm.h lpcap.h lpcode.h
+lptree.o: lptree.c lptypes.h lpcap.h lpcode.h lptree.h lpvm.h lpprint.h \
+ lpcset.h
+lpvm.o: lpvm.c lpcap.h lptypes.h lpvm.h lpprint.h lptree.h

src/lua/lpeg-1.1.0/re.html

@@ -0,0 +1,472 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+   "//www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html>
+<head>
+    <title>LPeg.re - Regex syntax for LPEG</title>
+    <link rel="stylesheet"
+          href="//www.inf.puc-rio.br/~roberto/lpeg/doc.css"
+          type="text/css"/>
+	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
+</head>
+<body>
+
+
+<div id="container">
+	
+<div id="product">
+  <div id="product_logo">
+    <a href="//www.inf.puc-rio.br/~roberto/lpeg/">
+    <img alt="LPeg logo" src="lpeg-128.gif"/>
+    </a>
+  </div>
+  <div id="product_name"><big><strong>LPeg.re</strong></big></div>
+  <div id="product_description">
+     Regex syntax for LPEG
+  </div>
+</div> <!-- id="product" -->
+
+<div id="main">
+	
+<div id="navigation">
+<h1>re</h1>
+
+<ul>
+  <li><a href="#basic">Basic Constructions</a></li>
+  <li><a href="#func">Functions</a></li>
+  <li><a href="#ex">Some Examples</a></li>
+  <li><a href="#license">License</a></li>
+  </ul>
+  </li>
+</ul>
+</div> <!-- id="navigation" -->
+
+<div id="content">
+
+<h2><a name="basic"></a>The <code>re</code> Module</h2>
+
+<p>
+The <code>re</code> module
+(provided by file <code>re.lua</code> in the distribution)
+supports a somewhat conventional regex syntax
+for pattern usage within <a href="lpeg.html">LPeg</a>.
+</p>
+
+<p>
+The next table summarizes <code>re</code>'s syntax.
+A <code>p</code> represents an arbitrary pattern;
+<code>num</code> represents a number (<code>[0-9]+</code>);
+<code>name</code> represents an identifier
+(<code>[a-zA-Z][a-zA-Z0-9_]*</code>).
+Constructions are listed in order of decreasing precedence.
+<table border="1">
+<tbody><tr><td><b>Syntax</b></td><td><b>Description</b></td></tr>
+<tr><td><code>( p )</code></td> <td>grouping</td></tr>
+<tr><td><code>&amp; p</code></td> <td>and predicate</td></tr>
+<tr><td><code>! p</code></td> <td>not predicate</td></tr>
+<tr><td><code>p1 p2</code></td> <td>concatenation</td></tr>
+<tr><td><code>p1 / p2</code></td> <td>ordered choice</td></tr>
+<tr><td><code>p ?</code></td> <td>optional match</td></tr>
+<tr><td><code>p *</code></td> <td>zero or more repetitions</td></tr>
+<tr><td><code>p +</code></td> <td>one or more repetitions</td></tr>
+<tr><td><code>p^num</code></td>
+      <td>exactly <code>num</code> repetitions</td></tr>
+<tr><td><code>p^+num</code></td>
+      <td>at least <code>num</code> repetitions</td></tr>
+<tr><td><code>p^-num</code></td>
+      <td>at most <code>num</code> repetitions</td></tr>
+<tr><td>(<code>name &lt;- p</code>)<sup>+</sup></td> <td>grammar</td></tr>
+<tr><td><code>'string'</code></td> <td>literal string</td></tr>
+<tr><td><code>"string"</code></td> <td>literal string</td></tr>
+<tr><td><code>[class]</code></td> <td>character class</td></tr>
+<tr><td><code>.</code></td> <td>any character</td></tr>
+<tr><td><code>%name</code></td>
+  <td>pattern <code>defs[name]</code> or a pre-defined pattern</td></tr>
+<tr><td><code>name</code></td><td>non terminal</td></tr>
+<tr><td><code>&lt;name&gt;</code></td><td>non terminal</td></tr>
+
+<tr><td><code>{}</code></td> <td>position capture</td></tr>
+<tr><td><code>{ p }</code></td> <td>simple capture</td></tr>
+<tr><td><code>{: p :}</code></td> <td>anonymous group capture</td></tr>
+<tr><td><code>{:name: p :}</code></td> <td>named group capture</td></tr>
+<tr><td><code>{~ p ~}</code></td> <td>substitution capture</td></tr>
+<tr><td><code>{| p |}</code></td> <td>table capture</td></tr>
+<tr><td><code>=name</code></td> <td>back reference</td></tr>
+
+<tr><td><code>p -&gt; 'string'</code></td> <td>string capture</td></tr>
+<tr><td><code>p -&gt; "string"</code></td> <td>string capture</td></tr>
+<tr><td><code>p -&gt; num</code></td> <td>numbered capture</td></tr>
+<tr><td><code>p -&gt; name</code></td> <td>function/query/string capture
+equivalent to <code>p / defs[name]</code></td></tr>
+<tr><td><code>p =&gt; name</code></td> <td>match-time capture
+equivalent to <code>lpeg.Cmt(p, defs[name])</code></td></tr>
+<tr><td><code>p ~&gt; name</code></td> <td>fold capture
+(deprecated)</td></tr>
+<tr><td><code>p &gt;&gt; name</code></td> <td>accumulator capture
+equivalent to <code>(p % defs[name])</code></td></tr>
+</tbody></table>
+<p>
+Any space appearing in a syntax description can be
+replaced by zero or more space characters and Lua-style short comments
+(<code>--</code> until end of line).
+</p>
+
+<p>
+Character classes define sets of characters.
+An initial <code>^</code> complements the resulting set.
+A range <em>x</em><code>-</code><em>y</em> includes in the set
+all characters with codes between the codes of <em>x</em> and <em>y</em>.
+A pre-defined class <code>%</code><em>name</em> includes all
+characters of that class.
+A simple character includes itself in the set.
+The only special characters inside a class are <code>^</code>
+(special only if it is the first character);
+<code>]</code>
+(can be included in the set as the first character,
+after the optional <code>^</code>);
+<code>%</code> (special only if followed by a letter);
+and <code>-</code>
+(can be included in the set as the first or the last character).
+</p>
+
+<p>
+Currently the pre-defined classes are similar to those from the
+Lua's string library
+(<code>%a</code> for letters,
+<code>%A</code> for non letters, etc.).
+There is also a class <code>%nl</code>
+containing only the newline character,
+which is particularly handy for grammars written inside long strings,
+as long strings do not interpret escape sequences like <code>\n</code>.
+</p>
+
+
+<h2><a name="func">Functions</a></h2>
+
+<h3><code>re.compile (string, [, defs])</code></h3>
+<p>
+Compiles the given string and
+returns an equivalent LPeg pattern.
+The given string may define either an expression or a grammar.
+The optional <code>defs</code> table provides extra Lua values
+to be used by the pattern.
+</p>
+
+<h3><code>re.find (subject, pattern [, init])</code></h3>
+<p>
+Searches the given pattern in the given subject.
+If it finds a match,
+returns the index where this occurrence starts and
+the index where it ends.
+Otherwise, returns nil.
+</p>
+
+<p>
+An optional numeric argument <code>init</code> makes the search
+starts at that position in the subject string.
+As usual in Lua libraries,
+a negative value counts from the end.
+</p>
+
+<h3><code>re.gsub (subject, pattern, replacement)</code></h3>
+<p>
+Does a <em>global substitution</em>,
+replacing all occurrences of <code>pattern</code>
+in the given <code>subject</code> by <code>replacement</code>.
+
+<h3><code>re.match (subject, pattern)</code></h3>
+<p>
+Matches the given pattern against the given subject,
+returning all captures.
+</p>
+
+<h3><code>re.updatelocale ()</code></h3>
+<p>
+Updates the pre-defined character classes to the current locale.
+</p>
+
+
+<h2><a name="ex">Some Examples</a></h2>
+
+<h3>A complete simple program</h3>
+<p>
+The next code shows a simple complete Lua program using
+the <code>re</code> module:
+</p>
+<pre class="example">
+local re = require"re"
+
+-- find the position of the first numeral in a string
+print(re.find("the number 423 is odd", "[0-9]+"))  --&gt; 12    14
+
+-- returns all words in a string
+print(re.match("the number 423 is odd", "({%a+} / .)*"))
+--&gt; the    number    is    odd
+
+-- returns the first numeral in a string
+print(re.match("the number 423 is odd", "s &lt;- {%d+} / . s"))
+--&gt; 423
+
+-- substitutes a dot for each vowel in a string
+print(re.gsub("hello World", "[aeiou]", "."))
+--&gt; h.ll. W.rld
+</pre>
+
+
+<h3>Balanced parentheses</h3>
+<p>
+The following call will produce the same pattern produced by the
+Lua expression in the
+<a href="lpeg.html#balanced">balanced parentheses</a> example:
+</p>
+<pre class="example">
+b = re.compile[[  balanced &lt;- "(" ([^()] / balanced)* ")"  ]]
+</pre>
+
+<h3>String reversal</h3>
+<p>
+The next example reverses a string:
+</p>
+<pre class="example">
+rev = re.compile[[ R &lt;- (!.) -&gt; '' / ({.} R) -&gt; '%2%1']]
+print(rev:match"0123456789")   --&gt; 9876543210
+</pre>
+
+<h3>CSV decoder</h3>
+<p>
+The next example replicates the <a href="lpeg.html#CSV">CSV decoder</a>:
+</p>
+<pre class="example">
+record = re.compile[[
+  record &lt;- {| field (',' field)* |} (%nl / !.)
+  field &lt;- escaped / nonescaped
+  nonescaped &lt;- { [^,"%nl]* }
+  escaped &lt;- '"' {~ ([^"] / '""' -&gt; '"')* ~} '"'
+]]
+</pre>
+
+<h3>Lua's long strings</h3>
+<p>
+The next example matches Lua long strings:
+</p>
+<pre class="example">
+c = re.compile([[
+  longstring &lt;- ('[' {:eq: '='* :} '[' close)
+  close &lt;- ']' =eq ']' / . close
+]])
+
+print(c:match'[==[]]===]]]]==]===[]')   --&gt; 17
+</pre>
+
+<h3>Abstract Syntax Trees</h3>
+<p>
+This example shows a simple way to build an
+abstract syntax tree (AST) for a given grammar.
+To keep our example simple,
+let us consider the following grammar
+for lists of names:
+</p>
+<pre class="example">
+p = re.compile[[
+      listname &lt;- (name s)*
+      name &lt;- [a-z][a-z]*
+      s &lt;- %s*
+]]
+</pre>
+<p>
+Now, we will add captures to build a corresponding AST.
+As a first step, the pattern will build a table to
+represent each non terminal;
+terminals will be represented by their corresponding strings:
+</p>
+<pre class="example">
+c = re.compile[[
+      listname &lt;- {| (name s)* |}
+      name &lt;- {| {[a-z][a-z]*} |}
+      s &lt;- %s*
+]]
+</pre>
+<p>
+Now, a match against <code>"hi hello bye"</code>
+results in the table
+<code>{{"hi"}, {"hello"}, {"bye"}}</code>.
+</p>
+<p>
+For such a simple grammar,
+this AST is more than enough;
+actually, the tables around each single name
+are already overkilling.
+More complex grammars,
+however, may need some more structure.
+Specifically,
+it would be useful if each table had
+a <code>tag</code> field telling what non terminal
+that table represents.
+We can add such a tag using
+<a href="lpeg.html#cap-g">named group captures</a>:
+</p>
+<pre class="example">
+x = re.compile[[
+      listname <- {| {:tag: '' -> 'list':} (name s)* |}
+      name <- {| {:tag: '' -> 'id':} {[a-z][a-z]*} |}
+      s <- ' '*
+]]
+</pre>
+<p>
+With these group captures,
+a match against <code>"hi hello bye"</code>
+results in the following table:
+</p>
+<pre class="example">
+{tag="list",
+  {tag="id", "hi"},
+  {tag="id", "hello"},
+  {tag="id", "bye"}
+}
+</pre>
+
+
+<h3>Indented blocks</h3>
+<p>
+This example breaks indented blocks into tables,
+respecting the indentation:
+</p>
+<pre class="example">
+p = re.compile[[
+  block &lt;- {| {:ident:' '*:} line
+           ((=ident !' ' line) / &amp;(=ident ' ') block)* |}
+  line &lt;- {[^%nl]*} %nl
+]]
+</pre>
+<p>
+As an example,
+consider the following text:
+</p>
+<pre class="example">
+t = p:match[[
+first line
+  subline 1
+  subline 2
+second line
+third line
+  subline 3.1
+    subline 3.1.1
+  subline 3.2
+]]
+</pre>
+<p>
+The resulting table <code>t</code> will be like this:
+</p>
+<pre class="example">
+   {'first line'; {'subline 1'; 'subline 2'; ident = '  '};
+    'second line';
+    'third line'; { 'subline 3.1'; {'subline 3.1.1'; ident = '    '};
+                    'subline 3.2'; ident = '  '};
+    ident = ''}
+</pre>
+
+<h3>Macro expander</h3>
+<p>
+This example implements a simple macro expander.
+Macros must be defined as part of the pattern,
+following some simple rules:
+</p>
+<pre class="example">
+p = re.compile[[
+      text &lt;- {~ item* ~}
+      item &lt;- macro / [^()] / '(' item* ')'
+      arg &lt;- ' '* {~ (!',' item)* ~}
+      args &lt;- '(' arg (',' arg)* ')'
+      -- now we define some macros
+      macro &lt;- ('apply' args) -&gt; '%1(%2)'
+             / ('add' args) -&gt; '%1 + %2'
+             / ('mul' args) -&gt; '%1 * %2'
+]]
+
+print(p:match"add(mul(a,b), apply(f,x))")   --&gt; a * b + f(x)
+</pre>
+<p>
+A <code>text</code> is a sequence of items,
+wherein we apply a substitution capture to expand any macros.
+An <code>item</code> is either a macro,
+any character different from parentheses,
+or a parenthesized expression.
+A macro argument (<code>arg</code>) is a sequence
+of items different from a comma.
+(Note that a comma may appear inside an item,
+e.g., inside a parenthesized expression.)
+Again we do a substitution capture to expand any macro
+in the argument before expanding the outer macro.
+<code>args</code> is a list of arguments separated by commas.
+Finally we define the macros.
+Each macro is a string substitution;
+it replaces the macro name and its arguments by its corresponding string,
+with each <code>%</code><em>n</em> replaced by the <em>n</em>-th argument.
+</p>
+
+<h3>Patterns</h3>
+<p>
+This example shows the complete syntax
+of patterns accepted by <code>re</code>.
+</p>
+<pre class="example">
+p = [=[
+
+pattern         &lt;- exp !.
+exp             &lt;- S (grammar / alternative)
+
+alternative     &lt;- seq ('/' S seq)*
+seq             &lt;- prefix*
+prefix          &lt;- '&amp;' S prefix / '!' S prefix / suffix
+suffix          &lt;- primary S (([+*?]
+                            / '^' [+-]? num
+                            / '-&gt;' S (string / '{}' / name)
+                            / '&gt&gt;' S name
+                            / '=&gt;' S name) S)*
+
+primary         &lt;- '(' exp ')' / string / class / defined
+                 / '{:' (name ':')? exp ':}'
+                 / '=' name
+                 / '{}'
+                 / '{~' exp '~}'
+                 / '{|' exp '|}'
+                 / '{' exp '}'
+                 / '.'
+                 / name S !arrow
+                 / '&lt;' name '&gt;'          -- old-style non terminals
+
+grammar         &lt;- definition+
+definition      &lt;- name S arrow exp
+
+class           &lt;- '[' '^'? item (!']' item)* ']'
+item            &lt;- defined / range / .
+range           &lt;- . '-' [^]]
+
+S               &lt;- (%s / '--' [^%nl]*)*   -- spaces and comments
+name            &lt;- [A-Za-z_][A-Za-z0-9_]*
+arrow           &lt;- '&lt;-'
+num             &lt;- [0-9]+
+string          &lt;- '"' [^"]* '"' / "'" [^']* "'"
+defined         &lt;- '%' name
+
+]=]
+
+print(re.match(p, p))   -- a self description must match itself
+</pre>
+
+
+
+<h2><a name="license">License</a></h2>
+
+<p>
+This module is part of the <a href="lpeg.html">LPeg</a> package and shares
+its <a href="lpeg.html#license">license</a>.
+
+
+</div> <!-- id="content" -->
+
+</div> <!-- id="main" -->
+
+</div> <!-- id="container" -->
+
+</body>
+</html> 

src/lua/lpeg-1.1.0/re.lua

@@ -0,0 +1,270 @@
+--
+-- Copyright 2007-2023, Lua.org & PUC-Rio  (see 'lpeg.html' for license)
+-- written by Roberto Ierusalimschy
+--
+
+-- imported functions and modules
+local tonumber, type, print, error = tonumber, type, print, error
+local setmetatable = setmetatable
+local m = require"lpeg"
+
+-- 'm' will be used to parse expressions, and 'mm' will be used to
+-- create expressions; that is, 're' runs on 'm', creating patterns
+-- on 'mm'
+local mm = m
+
+-- patterns' metatable
+local mt = getmetatable(mm.P(0))
+
+
+local version = _VERSION
+
+-- No more global accesses after this point
+_ENV = nil     -- does no harm in Lua 5.1
+
+
+local any = m.P(1)
+
+
+-- Pre-defined names
+local Predef = { nl = m.P"\n" }
+
+
+local mem
+local fmem
+local gmem
+
+
+local function updatelocale ()
+  mm.locale(Predef)
+  Predef.a = Predef.alpha
+  Predef.c = Predef.cntrl
+  Predef.d = Predef.digit
+  Predef.g = Predef.graph
+  Predef.l = Predef.lower
+  Predef.p = Predef.punct
+  Predef.s = Predef.space
+  Predef.u = Predef.upper
+  Predef.w = Predef.alnum
+  Predef.x = Predef.xdigit
+  Predef.A = any - Predef.a
+  Predef.C = any - Predef.c
+  Predef.D = any - Predef.d
+  Predef.G = any - Predef.g
+  Predef.L = any - Predef.l
+  Predef.P = any - Predef.p
+  Predef.S = any - Predef.s
+  Predef.U = any - Predef.u
+  Predef.W = any - Predef.w
+  Predef.X = any - Predef.x
+  mem = {}    -- restart memoization
+  fmem = {}
+  gmem = {}
+  local mt = {__mode = "v"}
+  setmetatable(mem, mt)
+  setmetatable(fmem, mt)
+  setmetatable(gmem, mt)
+end
+
+
+updatelocale()
+
+
+
+local I = m.P(function (s,i) print(i, s:sub(1, i-1)); return i end)
+
+
+local function patt_error (s, i)
+  local msg = (#s < i + 20) and s:sub(i)
+                             or s:sub(i,i+20) .. "..."
+  msg = ("pattern error near '%s'"):format(msg)
+  error(msg, 2)
+end
+
+local function mult (p, n)
+  local np = mm.P(true)
+  while n >= 1 do
+    if n%2 >= 1 then np = np * p end
+    p = p * p
+    n = n/2
+  end
+  return np
+end
+
+local function equalcap (s, i, c)
+  if type(c) ~= "string" then return nil end
+  local e = #c + i
+  if s:sub(i, e - 1) == c then return e else return nil end
+end
+
+
+local S = (Predef.space + "--" * (any - Predef.nl)^0)^0
+
+local name = m.R("AZ", "az", "__") * m.R("AZ", "az", "__", "09")^0
+
+local arrow = S * "<-"
+
+local seq_follow = m.P"/" + ")" + "}" + ":}" + "~}" + "|}" + (name * arrow) + -1
+
+name = m.C(name)
+
+
+-- a defined name only have meaning in a given environment
+local Def = name * m.Carg(1)
+
+
+local function getdef (id, defs)
+  local c = defs and defs[id]
+  if not c then error("undefined name: " .. id) end
+  return c
+end
+
+-- match a name and return a group of its corresponding definition
+-- and 'f' (to be folded in 'Suffix')
+local function defwithfunc (f)
+  return m.Cg(Def / getdef * m.Cc(f))
+end
+
+
+local num = m.C(m.R"09"^1) * S / tonumber
+
+local String = "'" * m.C((any - "'")^0) * "'" +
+               '"' * m.C((any - '"')^0) * '"'
+
+
+local defined = "%" * Def / function (c,Defs)
+  local cat =  Defs and Defs[c] or Predef[c]
+  if not cat then error ("name '" .. c .. "' undefined") end
+  return cat
+end
+
+local Range = m.Cs(any * (m.P"-"/"") * (any - "]")) / mm.R
+
+local item = (defined + Range + m.C(any)) / m.P
+
+local Class =
+    "["
+  * (m.C(m.P"^"^-1))    -- optional complement symbol
+  * (item * ((item % mt.__add) - "]")^0) /
+                          function (c, p) return c == "^" and any - p or p end
+  * "]"
+
+local function adddef (t, k, exp)
+  if t[k] then
+    error("'"..k.."' already defined as a rule")
+  else
+    t[k] = exp
+  end
+  return t
+end
+
+local function firstdef (n, r) return adddef({n}, n, r) end
+
+
+local function NT (n, b)
+  if not b then
+    error("rule '"..n.."' used outside a grammar")
+  else return mm.V(n)
+  end
+end
+
+
+local exp = m.P{ "Exp",
+  Exp = S * ( m.V"Grammar"
+            + m.V"Seq" * ("/" * S * m.V"Seq" % mt.__add)^0 );
+  Seq = (m.Cc(m.P"") * (m.V"Prefix" % mt.__mul)^0)
+        * (#seq_follow + patt_error);
+  Prefix = "&" * S * m.V"Prefix" / mt.__len
+         + "!" * S * m.V"Prefix" / mt.__unm
+         + m.V"Suffix";
+  Suffix = m.V"Primary" * S *
+          ( ( m.P"+" * m.Cc(1, mt.__pow)
+            + m.P"*" * m.Cc(0, mt.__pow)
+            + m.P"?" * m.Cc(-1, mt.__pow)
+            + "^" * ( m.Cg(num * m.Cc(mult))
+                    + m.Cg(m.C(m.S"+-" * m.R"09"^1) * m.Cc(mt.__pow))
+                    )
+            + "->" * S * ( m.Cg((String + num) * m.Cc(mt.__div))
+                         + m.P"{}" * m.Cc(nil, m.Ct)
+                         + defwithfunc(mt.__div)
+                         )
+            + "=>" * S * defwithfunc(mm.Cmt)
+            + ">>" * S * defwithfunc(mt.__mod)
+            + "~>" * S * defwithfunc(mm.Cf)
+            ) % function (a,b,f) return f(a,b) end * S
+          )^0;
+  Primary = "(" * m.V"Exp" * ")"
+            + String / mm.P
+            + Class
+            + defined
+            + "{:" * (name * ":" + m.Cc(nil)) * m.V"Exp" * ":}" /
+                     function (n, p) return mm.Cg(p, n) end
+            + "=" * name / function (n) return mm.Cmt(mm.Cb(n), equalcap) end
+            + m.P"{}" / mm.Cp
+            + "{~" * m.V"Exp" * "~}" / mm.Cs
+            + "{|" * m.V"Exp" * "|}" / mm.Ct
+            + "{" * m.V"Exp" * "}" / mm.C
+            + m.P"." * m.Cc(any)
+            + (name * -arrow + "<" * name * ">") * m.Cb("G") / NT;
+  Definition = name * arrow * m.V"Exp";
+  Grammar = m.Cg(m.Cc(true), "G") *
+            ((m.V"Definition" / firstdef) * (m.V"Definition" % adddef)^0) / mm.P
+}
+
+local pattern = S * m.Cg(m.Cc(false), "G") * exp / mm.P * (-any + patt_error)
+
+
+local function compile (p, defs)
+  if mm.type(p) == "pattern" then return p end   -- already compiled
+  local cp = pattern:match(p, 1, defs)
+  if not cp then error("incorrect pattern", 3) end
+  return cp
+end
+
+local function match (s, p, i)
+  local cp = mem[p]
+  if not cp then
+    cp = compile(p)
+    mem[p] = cp
+  end
+  return cp:match(s, i or 1)
+end
+
+local function find (s, p, i)
+  local cp = fmem[p]
+  if not cp then
+    cp = compile(p) / 0
+    cp = mm.P{ mm.Cp() * cp * mm.Cp() + 1 * mm.V(1) }
+    fmem[p] = cp
+  end
+  local i, e = cp:match(s, i or 1)
+  if i then return i, e - 1
+  else return i
+  end
+end
+
+local function gsub (s, p, rep)
+  local g = gmem[p] or {}   -- ensure gmem[p] is not collected while here
+  gmem[p] = g
+  local cp = g[rep]
+  if not cp then
+    cp = compile(p)
+    cp = mm.Cs((cp / rep + 1)^0)
+    g[rep] = cp
+  end
+  return cp:match(s)
+end
+
+
+-- exported names
+local re = {
+  compile = compile,
+  match = match,
+  find = find,
+  gsub = gsub,
+  updatelocale = updatelocale,
+}
+
+if version == "Lua 5.1" then _G.re = re end
+
+return re

src/lua/lua.c

@@ -0,0 +1,694 @@
+/*
+** $Id: lua.c $
+** Lua stand-alone interpreter
+** See Copyright Notice in lua.h
+*/
+
+#define lua_c
+
+#include "lprefix.h"
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <signal.h>
+
+#include "lua.h"
+
+#include "lauxlib.h"
+#include "lualib.h"
+
+
+#if !defined(LUA_PROGNAME)
+#define LUA_PROGNAME		"lua"
+#endif
+
+#if !defined(LUA_INIT_VAR)
+#define LUA_INIT_VAR		"LUA_INIT"
+#endif
+
+#define LUA_INITVARVERSION	LUA_INIT_VAR LUA_VERSUFFIX
+
+
+static lua_State *globalL = NULL;
+
+static const char *progname = LUA_PROGNAME;
+
+
+#if defined(LUA_USE_POSIX)   /* { */
+
+/*
+** Use 'sigaction' when available.
+*/
+static void setsignal (int sig, void (*handler)(int)) {
+  struct sigaction sa;
+  sa.sa_handler = handler;
+  sa.sa_flags = 0;
+  sigemptyset(&sa.sa_mask);  /* do not mask any signal */
+  sigaction(sig, &sa, NULL);
+}
+
+#else           /* }{ */
+
+#define setsignal            signal
+
+#endif                               /* } */
+
+
+/*
+** Hook set by signal function to stop the interpreter.
+*/
+static void lstop (lua_State *L, lua_Debug *ar) {
+  (void)ar;  /* unused arg. */
+  lua_sethook(L, NULL, 0, 0);  /* reset hook */
+  luaL_error(L, "interrupted!");
+}
+
+
+/*
+** Function to be called at a C signal. Because a C signal cannot
+** just change a Lua state (as there is no proper synchronization),
+** this function only sets a hook that, when called, will stop the
+** interpreter.
+*/
+static void laction (int i) {
+  int flag = LUA_MASKCALL | LUA_MASKRET | LUA_MASKLINE | LUA_MASKCOUNT;
+  setsignal(i, SIG_DFL); /* if another SIGINT happens, terminate process */
+  lua_sethook(globalL, lstop, flag, 1);
+}
+
+
+static void print_usage (const char *badoption) {
+  lua_writestringerror("%s: ", progname);
+  if (badoption[1] == 'e' || badoption[1] == 'l')
+    lua_writestringerror("'%s' needs argument\n", badoption);
+  else
+    lua_writestringerror("unrecognized option '%s'\n", badoption);
+  lua_writestringerror(
+  "usage: %s [options] [script [args]]\n"
+  "Available options are:\n"
+  "  -e stat   execute string 'stat'\n"
+  "  -i        enter interactive mode after executing 'script'\n"
+  "  -l mod    require library 'mod' into global 'mod'\n"
+  "  -l g=mod  require library 'mod' into global 'g'\n"
+  "  -v        show version information\n"
+  "  -E        ignore environment variables\n"
+  "  -W        turn warnings on\n"
+  "  --        stop handling options\n"
+  "  -         stop handling options and execute stdin\n"
+  ,
+  progname);
+}
+
+
+/*
+** Prints an error message, adding the program name in front of it
+** (if present)
+*/
+static void l_message (const char *pname, const char *msg) {
+  if (pname) lua_writestringerror("%s: ", pname);
+  lua_writestringerror("%s\n", msg);
+}
+
+
+/*
+** Check whether 'status' is not OK and, if so, prints the error
+** message on the top of the stack.
+*/
+static int report (lua_State *L, int status) {
+  if (status != LUA_OK) {
+    const char *msg = lua_tostring(L, -1);
+    if (msg == NULL)
+      msg = "(error message not a string)";
+    l_message(progname, msg);
+    lua_pop(L, 1);  /* remove message */
+  }
+  return status;
+}
+
+
+/*
+** Message handler used to run all chunks
+*/
+static int msghandler (lua_State *L) {
+  const char *msg = lua_tostring(L, 1);
+  if (msg == NULL) {  /* is error object not a string? */
+    if (luaL_callmeta(L, 1, "__tostring") &&  /* does it have a metamethod */
+        lua_type(L, -1) == LUA_TSTRING)  /* that produces a string? */
+      return 1;  /* that is the message */
+    else
+      msg = lua_pushfstring(L, "(error object is a %s value)",
+                               luaL_typename(L, 1));
+  }
+  luaL_traceback(L, L, msg, 1);  /* append a standard traceback */
+  return 1;  /* return the traceback */
+}
+
+
+/*
+** Interface to 'lua_pcall', which sets appropriate message function
+** and C-signal handler. Used to run all chunks.
+*/
+static int docall (lua_State *L, int narg, int nres) {
+  int status;
+  int base = lua_gettop(L) - narg;  /* function index */
+  lua_pushcfunction(L, msghandler);  /* push message handler */
+  lua_insert(L, base);  /* put it under function and args */
+  globalL = L;  /* to be available to 'laction' */
+  setsignal(SIGINT, laction);  /* set C-signal handler */
+  status = lua_pcall(L, narg, nres, base);
+  setsignal(SIGINT, SIG_DFL); /* reset C-signal handler */
+  lua_remove(L, base);  /* remove message handler from the stack */
+  return status;
+}
+
+
+static void print_version (void) {
+  lua_writestring(LUA_COPYRIGHT, strlen(LUA_COPYRIGHT));
+  lua_writeline();
+}
+
+
+/*
+** Create the 'arg' table, which stores all arguments from the
+** command line ('argv'). It should be aligned so that, at index 0,
+** it has 'argv[script]', which is the script name. The arguments
+** to the script (everything after 'script') go to positive indices;
+** other arguments (before the script name) go to negative indices.
+** If there is no script name, assume interpreter's name as base.
+** (If there is no interpreter's name either, 'script' is -1, so
+** table sizes are zero.)
+*/
+static void createargtable (lua_State *L, char **argv, int argc, int script) {
+  int i, narg;
+  narg = argc - (script + 1);  /* number of positive indices */
+  lua_createtable(L, narg, script + 1);
+  for (i = 0; i < argc; i++) {
+    lua_pushstring(L, argv[i]);
+    lua_rawseti(L, -2, i - script);
+  }
+  lua_setglobal(L, "arg");
+}
+
+
+static int dochunk (lua_State *L, int status) {
+  if (status == LUA_OK) status = docall(L, 0, 0);
+  return report(L, status);
+}
+
+
+static int dofile (lua_State *L, const char *name) {
+  return dochunk(L, luaL_loadfile(L, name));
+}
+
+
+static int dostring (lua_State *L, const char *s, const char *name) {
+  return dochunk(L, luaL_loadbuffer(L, s, strlen(s), name));
+}
+
+
+/*
+** Receives 'globname[=modname]' and runs 'globname = require(modname)'.
+** If there is no explicit modname and globname contains a '-', cut
+** the suffix after '-' (the "version") to make the global name.
+*/
+static int dolibrary (lua_State *L, char *globname) {
+  int status;
+  char *suffix = NULL;
+  char *modname = strchr(globname, '=');
+  if (modname == NULL) {  /* no explicit name? */
+    modname = globname;  /* module name is equal to global name */
+    suffix = strchr(modname, *LUA_IGMARK);  /* look for a suffix mark */
+  }
+  else {
+    *modname = '\0';  /* global name ends here */
+    modname++;  /* module name starts after the '=' */
+  }
+  lua_getglobal(L, "require");
+  lua_pushstring(L, modname);
+  status = docall(L, 1, 1);  /* call 'require(modname)' */
+  if (status == LUA_OK) {
+    if (suffix != NULL)  /* is there a suffix mark? */
+      *suffix = '\0';  /* remove suffix from global name */
+    lua_setglobal(L, globname);  /* globname = require(modname) */
+  }
+  return report(L, status);
+}
+
+
+/*
+** Push on the stack the contents of table 'arg' from 1 to #arg
+*/
+static int pushargs (lua_State *L) {
+  int i, n;
+  if (lua_getglobal(L, "arg") != LUA_TTABLE)
+    luaL_error(L, "'arg' is not a table");
+  n = (int)luaL_len(L, -1);
+  luaL_checkstack(L, n + 3, "too many arguments to script");
+  for (i = 1; i <= n; i++)
+    lua_rawgeti(L, -i, i);
+  lua_remove(L, -i);  /* remove table from the stack */
+  return n;
+}
+
+
+static int handle_script (lua_State *L, char **argv) {
+  int status;
+  const char *fname = argv[0];
+  if (strcmp(fname, "-") == 0 && strcmp(argv[-1], "--") != 0)
+    fname = NULL;  /* stdin */
+  status = luaL_loadfile(L, fname);
+  if (status == LUA_OK) {
+    int n = pushargs(L);  /* push arguments to script */
+    status = docall(L, n, LUA_MULTRET);
+  }
+  return report(L, status);
+}
+
+
+/* bits of various argument indicators in 'args' */
+#define has_error	1	/* bad option */
+#define has_i		2	/* -i */
+#define has_v		4	/* -v */
+#define has_e		8	/* -e */
+#define has_E		16	/* -E */
+
+
+/*
+** Traverses all arguments from 'argv', returning a mask with those
+** needed before running any Lua code or an error code if it finds any
+** invalid argument. In case of error, 'first' is the index of the bad
+** argument.  Otherwise, 'first' is -1 if there is no program name,
+** 0 if there is no script name, or the index of the script name.
+*/
+static int collectargs (char **argv, int *first) {
+  int args = 0;
+  int i;
+  if (argv[0] != NULL) {  /* is there a program name? */
+    if (argv[0][0])  /* not empty? */
+      progname = argv[0];  /* save it */
+  }
+  else {  /* no program name */
+    *first = -1;
+    return 0;
+  }
+  for (i = 1; argv[i] != NULL; i++) {  /* handle arguments */
+    *first = i;
+    if (argv[i][0] != '-')  /* not an option? */
+        return args;  /* stop handling options */
+    switch (argv[i][1]) {  /* else check option */
+      case '-':  /* '--' */
+        if (argv[i][2] != '\0')  /* extra characters after '--'? */
+          return has_error;  /* invalid option */
+        *first = i + 1;
+        return args;
+      case '\0':  /* '-' */
+        return args;  /* script "name" is '-' */
+      case 'E':
+        if (argv[i][2] != '\0')  /* extra characters? */
+          return has_error;  /* invalid option */
+        args |= has_E;
+        break;
+      case 'W':
+        if (argv[i][2] != '\0')  /* extra characters? */
+          return has_error;  /* invalid option */
+        break;
+      case 'i':
+        args |= has_i;  /* (-i implies -v) *//* FALLTHROUGH */
+      case 'v':
+        if (argv[i][2] != '\0')  /* extra characters? */
+          return has_error;  /* invalid option */
+        args |= has_v;
+        break;
+      case 'e':
+        args |= has_e;  /* FALLTHROUGH */
+      case 'l':  /* both options need an argument */
+        if (argv[i][2] == '\0') {  /* no concatenated argument? */
+          i++;  /* try next 'argv' */
+          if (argv[i] == NULL || argv[i][0] == '-')
+            return has_error;  /* no next argument or it is another option */
+        }
+        break;
+      default:  /* invalid option */
+        return has_error;
+    }
+  }
+  *first = 0;  /* no script name */
+  return args;
+}
+
+
+/*
+** Processes options 'e' and 'l', which involve running Lua code, and
+** 'W', which also affects the state.
+** Returns 0 if some code raises an error.
+*/
+static int runargs (lua_State *L, char **argv, int n) {
+  int i;
+  for (i = 1; i < n; i++) {
+    int option = argv[i][1];
+    lua_assert(argv[i][0] == '-');  /* already checked */
+    switch (option) {
+      case 'e':  case 'l': {
+        int status;
+        char *extra = argv[i] + 2;  /* both options need an argument */
+        if (*extra == '\0') extra = argv[++i];
+        lua_assert(extra != NULL);
+        status = (option == 'e')
+                 ? dostring(L, extra, "=(command line)")
+                 : dolibrary(L, extra);
+        if (status != LUA_OK) return 0;
+        break;
+      }
+      case 'W':
+        lua_warning(L, "@on", 0);  /* warnings on */
+        break;
+    }
+  }
+  return 1;
+}
+
+
+static int handle_luainit (lua_State *L) {
+  const char *name = "=" LUA_INITVARVERSION;
+  const char *init = getenv(name + 1);
+  if (init == NULL) {
+    name = "=" LUA_INIT_VAR;
+    init = getenv(name + 1);  /* try alternative name */
+  }
+  if (init == NULL) return LUA_OK;
+  else if (init[0] == '@')
+    return dofile(L, init+1);
+  else
+    return dostring(L, init, name);
+}
+
+
+/*
+** {==================================================================
+** Read-Eval-Print Loop (REPL)
+** ===================================================================
+*/
+
+#if !defined(LUA_PROMPT)
+#define LUA_PROMPT		"> "
+#define LUA_PROMPT2		">> "
+#endif
+
+#if !defined(LUA_MAXINPUT)
+#define LUA_MAXINPUT		512
+#endif
+
+
+/*
+** lua_stdin_is_tty detects whether the standard input is a 'tty' (that
+** is, whether we're running lua interactively).
+*/
+#if !defined(lua_stdin_is_tty)	/* { */
+
+#if defined(LUA_USE_POSIX)	/* { */
+
+#include <unistd.h>
+#define lua_stdin_is_tty()	isatty(0)
+
+#elif defined(LUA_USE_WINDOWS)	/* }{ */
+
+#include <io.h>
+#include <windows.h>
+
+#define lua_stdin_is_tty()	_isatty(_fileno(stdin))
+
+#else				/* }{ */
+
+/* ISO C definition */
+#define lua_stdin_is_tty()	1  /* assume stdin is a tty */
+
+#endif				/* } */
+
+#endif				/* } */
+
+
+/*
+** lua_readline defines how to show a prompt and then read a line from
+** the standard input.
+** lua_saveline defines how to "save" a read line in a "history".
+** lua_freeline defines how to free a line read by lua_readline.
+*/
+#if !defined(lua_readline)	/* { */
+
+#if defined(LUA_USE_READLINE)	/* { */
+
+#include <readline/readline.h>
+#include <readline/history.h>
+#define lua_initreadline(L)	((void)L, rl_readline_name="lua")
+#define lua_readline(L,b,p)	((void)L, ((b)=readline(p)) != NULL)
+#define lua_saveline(L,line)	((void)L, add_history(line))
+#define lua_freeline(L,b)	((void)L, free(b))
+
+#else				/* }{ */
+
+#define lua_initreadline(L)  ((void)L)
+#define lua_readline(L,b,p) \
+        ((void)L, fputs(p, stdout), fflush(stdout),  /* show prompt */ \
+        fgets(b, LUA_MAXINPUT, stdin) != NULL)  /* get line */
+#define lua_saveline(L,line)	{ (void)L; (void)line; }
+#define lua_freeline(L,b)	{ (void)L; (void)b; }
+
+#endif				/* } */
+
+#endif				/* } */
+
+
+/*
+** Return the string to be used as a prompt by the interpreter. Leave
+** the string (or nil, if using the default value) on the stack, to keep
+** it anchored.
+*/
+static const char *get_prompt (lua_State *L, int firstline) {
+  if (lua_getglobal(L, firstline ? "_PROMPT" : "_PROMPT2") == LUA_TNIL)
+    return (firstline ? LUA_PROMPT : LUA_PROMPT2);  /* use the default */
+  else {  /* apply 'tostring' over the value */
+    const char *p = luaL_tolstring(L, -1, NULL);
+    lua_remove(L, -2);  /* remove original value */
+    return p;
+  }
+}
+
+/* mark in error messages for incomplete statements */
+#define EOFMARK		"<eof>"
+#define marklen		(sizeof(EOFMARK)/sizeof(char) - 1)
+
+
+/*
+** Check whether 'status' signals a syntax error and the error
+** message at the top of the stack ends with the above mark for
+** incomplete statements.
+*/
+static int incomplete (lua_State *L, int status) {
+  if (status == LUA_ERRSYNTAX) {
+    size_t lmsg;
+    const char *msg = lua_tolstring(L, -1, &lmsg);
+    if (lmsg >= marklen && strcmp(msg + lmsg - marklen, EOFMARK) == 0)
+      return 1;
+  }
+  return 0;  /* else... */
+}
+
+
+/*
+** Prompt the user, read a line, and push it into the Lua stack.
+*/
+static int pushline (lua_State *L, int firstline) {
+  char buffer[LUA_MAXINPUT];
+  char *b = buffer;
+  size_t l;
+  const char *prmt = get_prompt(L, firstline);
+  int readstatus = lua_readline(L, b, prmt);
+  lua_pop(L, 1);  /* remove prompt */
+  if (readstatus == 0)
+    return 0;  /* no input */
+  l = strlen(b);
+  if (l > 0 && b[l-1] == '\n')  /* line ends with newline? */
+    b[--l] = '\0';  /* remove it */
+  if (firstline && b[0] == '=')  /* for compatibility with 5.2, ... */
+    lua_pushfstring(L, "return %s", b + 1);  /* change '=' to 'return' */
+  else
+    lua_pushlstring(L, b, l);
+  lua_freeline(L, b);
+  return 1;
+}
+
+
+/*
+** Try to compile line on the stack as 'return <line>;'; on return, stack
+** has either compiled chunk or original line (if compilation failed).
+*/
+static int addreturn (lua_State *L) {
+  const char *line = lua_tostring(L, -1);  /* original line */
+  const char *retline = lua_pushfstring(L, "return %s;", line);
+  int status = luaL_loadbuffer(L, retline, strlen(retline), "=stdin");
+  if (status == LUA_OK) {
+    lua_remove(L, -2);  /* remove modified line */
+    if (line[0] != '\0')  /* non empty? */
+      lua_saveline(L, line);  /* keep history */
+  }
+  else
+    lua_pop(L, 2);  /* pop result from 'luaL_loadbuffer' and modified line */
+  return status;
+}
+
+
+/*
+** Read multiple lines until a complete Lua statement
+*/
+static int multiline (lua_State *L) {
+  for (;;) {  /* repeat until gets a complete statement */
+    size_t len;
+    const char *line = lua_tolstring(L, 1, &len);  /* get what it has */
+    int status = luaL_loadbuffer(L, line, len, "=stdin");  /* try it */
+    if (!incomplete(L, status) || !pushline(L, 0)) {
+      lua_saveline(L, line);  /* keep history */
+      return status;  /* should not or cannot try to add continuation line */
+    }
+    lua_remove(L, -2);  /* remove error message (from incomplete line) */
+    lua_pushliteral(L, "\n");  /* add newline... */
+    lua_insert(L, -2);  /* ...between the two lines */
+    lua_concat(L, 3);  /* join them */
+  }
+}
+
+
+/*
+** Read a line and try to load (compile) it first as an expression (by
+** adding "return " in front of it) and second as a statement. Return
+** the final status of load/call with the resulting function (if any)
+** in the top of the stack.
+*/
+static int loadline (lua_State *L) {
+  int status;
+  lua_settop(L, 0);
+  if (!pushline(L, 1))
+    return -1;  /* no input */
+  if ((status = addreturn(L)) != LUA_OK)  /* 'return ...' did not work? */
+    status = multiline(L);  /* try as command, maybe with continuation lines */
+  lua_remove(L, 1);  /* remove line from the stack */
+  lua_assert(lua_gettop(L) == 1);
+  return status;
+}
+
+
+/*
+** Prints (calling the Lua 'print' function) any values on the stack
+*/
+static void l_print (lua_State *L) {
+  int n = lua_gettop(L);
+  if (n > 0) {  /* any result to be printed? */
+    luaL_checkstack(L, LUA_MINSTACK, "too many results to print");
+    lua_getglobal(L, "print");
+    lua_insert(L, 1);
+    if (lua_pcall(L, n, 0, 0) != LUA_OK)
+      l_message(progname, lua_pushfstring(L, "error calling 'print' (%s)",
+                                             lua_tostring(L, -1)));
+  }
+}
+
+
+/*
+** Do the REPL: repeatedly read (load) a line, evaluate (call) it, and
+** print any results.
+*/
+static void doREPL (lua_State *L) {
+  int status;
+  const char *oldprogname = progname;
+  progname = NULL;  /* no 'progname' on errors in interactive mode */
+  lua_initreadline(L);
+  while ((status = loadline(L)) != -1) {
+    if (status == LUA_OK)
+      status = docall(L, 0, LUA_MULTRET);
+    if (status == LUA_OK) l_print(L);
+    else report(L, status);
+  }
+  lua_settop(L, 0);  /* clear stack */
+  lua_writeline();
+  progname = oldprogname;
+}
+
+/* }================================================================== */
+
+
+/*
+** Main body of stand-alone interpreter (to be called in protected mode).
+** Reads the options and handles them all.
+*/
+extern int luaopen_lpeg(lua_State *L);
+static int pmain (lua_State *L) {
+  int argc = (int)lua_tointeger(L, 1);
+  char **argv = (char **)lua_touserdata(L, 2);
+  int script;
+  int args = collectargs(argv, &script);
+  int optlim = (script > 0) ? script : argc; /* first argv not an option */
+  luaL_checkversion(L);  /* check that interpreter has correct version */
+  if (args == has_error) {  /* bad arg? */
+    print_usage(argv[script]);  /* 'script' has index of bad arg. */
+    return 0;
+  }
+  if (args & has_v)  /* option '-v'? */
+    print_version();
+  if (args & has_E) {  /* option '-E'? */
+    lua_pushboolean(L, 1);  /* signal for libraries to ignore env. vars. */
+    lua_setfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
+  }
+  luaL_openlibs(L);  /* open standard libraries */
+  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
+  lua_pushcfunction(L, luaopen_lpeg);
+  lua_setfield(L, -2, "lpeg");
+  lua_pop(L, 1);  // remove PRELOAD table
+
+  createargtable(L, argv, argc, script);  /* create table 'arg' */
+  lua_gc(L, LUA_GCRESTART);  /* start GC... */
+  lua_gc(L, LUA_GCGEN, 0, 0);  /* ...in generational mode */
+  if (!(args & has_E)) {  /* no option '-E'? */
+    if (handle_luainit(L) != LUA_OK)  /* run LUA_INIT */
+      return 0;  /* error running LUA_INIT */
+  }
+  if (!runargs(L, argv, optlim))  /* execute arguments -e and -l */
+    return 0;  /* something failed */
+  if (script > 0) {  /* execute main script (if there is one) */
+    if (handle_script(L, argv + script) != LUA_OK)
+      return 0;  /* interrupt in case of error */
+  }
+  if (args & has_i)  /* -i option? */
+    doREPL(L);  /* do read-eval-print loop */
+  else if (script < 1 && !(args & (has_e | has_v))) { /* no active option? */
+    if (lua_stdin_is_tty()) {  /* running in interactive mode? */
+      print_version();
+      doREPL(L);  /* do read-eval-print loop */
+    }
+    else dofile(L, NULL);  /* executes stdin as a file */
+  }
+  lua_pushboolean(L, 1);  /* signal no errors */
+  return 1;
+}
+
+
+
+int main (int argc, char **argv) {
+  int status, result;
+  lua_State *L = luaL_newstate();  /* create state */
+  if (L == NULL) {
+    l_message(argv[0], "cannot create state: not enough memory");
+    return EXIT_FAILURE;
+  }
+  lua_gc(L, LUA_GCSTOP);  /* stop GC while building state */
+  lua_pushcfunction(L, &pmain);  /* to call 'pmain' in protected mode */
+  lua_pushinteger(L, argc);  /* 1st argument */
+  lua_pushlightuserdata(L, argv); /* 2nd argument */
+  status = lua_pcall(L, 2, 1, 0);  /* do the call */
+  result = lua_toboolean(L, -1);  /* get result */
+  report(L, status);
+  lua_close(L);
+  return (result && status == LUA_OK) ? EXIT_SUCCESS : EXIT_FAILURE;
+}
+