rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/re.lua

@@ -0,0 +1,248 @@
+-- $Id: re.lua,v 1.39 2010/11/04 19:44:18 roberto Exp $
+
+-- 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
+
+-- pattern's metatable 
+local mt = getmetatable(mm.P(0))
+
+
+
+-- No more global accesses after this point
+local version = _VERSION
+if version == "Lua 5.2" then _ENV = nil end
+
+
+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 getdef (id, Defs)
+  local c = Defs and Defs[id]
+  if not c then error("undefined name: " .. id) end
+  return c
+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 = (m.S(" \f\n\r\t\v") + "--" * (any - Predef.nl)^0)^0
+
+local name = m.R("AZ", "az") * m.R("AZ", "az", "__", "09")^0
+
+local arrow = S * "<-"
+
+local exp_follow = m.P"/" + ")" + "}" + ":}" + "~}" + (name * arrow) + -1
+
+name = m.C(name)
+
+
+-- identifiers only have meaning in a given environment
+local Identifier = name * m.Carg(1)
+
+local num = m.C(m.R"09"^1) * S / tonumber
+
+local String = "'" * m.C((any - "'")^0) * "'" +
+               '"' * m.C((any - '"')^0) * '"'
+
+
+local defined = "%" * Identifier / 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)
+
+local Class =
+    "["
+  * (m.C(m.P"^"^-1))    -- optional complement symbol
+  * m.Cf(item * (item - "]")^0, mt.__add) /
+                          function (c, p) return c == "^" and any - p or p end
+  * "]"
+
+local function adddef (t, k, Defs, exp)
+  if t[k] then
+    error("'"..k.."' already defined as a rule")
+  else
+    t[k] = exp
+  end
+  return t
+end
+
+local function firstdef (n, Defs, r) return adddef({n}, n, Defs, r) end
+
+
+
+local exp = m.P{ "Exp",
+  Exp = S * ( m.V"Grammar"
+            + m.Cf(m.V"Seq" * ("/" * S * m.V"Seq")^0, mt.__add) );
+  Seq = m.Cf(m.Cc(m.P"") * m.V"Prefix"^0 , mt.__mul)
+        * (#exp_follow + patt_error);
+  Prefix = "&" * S * m.V"Prefix" / mt.__len
+         + "!" * S * m.V"Prefix" / mt.__unm
+         + m.V"Suffix";
+  Suffix = m.Cf(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 * m.Cc(mt.__div))
+                         + m.P"{}" * m.Cc(nil, m.Ct)
+                         + m.Cg(Identifier / getdef * m.Cc(mt.__div))
+                         )
+            + "=>" * S * m.Cg(Identifier / getdef * m.Cc(m.Cmt))
+            ) * S
+          )^0, function (a,b,f) return f(a,b) end );
+  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.C
+            + m.P"." * m.Cc(any)
+            + name * -arrow / mm.V
+            + "<" * name * ">" / mm.V;
+  Definition = Identifier * arrow * m.V"Exp";
+  Grammar = m.Cf(m.V"Definition" / firstdef * m.Cg(m.V"Definition")^0, adddef) /
+                mm.P
+}
+
+local pattern = S * 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)
+    cp = mm.P{ mm.Cp() * cp + 1 * mm.V(1) }
+    fmem[p] = cp
+  end
+  return cp:match(s, i or 1)
+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

data/vendor/lua/lib/lua/serialize.lua

@@ -0,0 +1,193 @@
+--------------------------------------------------------------------------------
+-- Metalua
+-- Summary: Table-to-source serializer
+--------------------------------------------------------------------------------
+--
+-- Copyright (c) 2008-2009, Fabien Fleutot <metalua@gmail.com>.
+--
+-- This software is released under the MIT Licence, see licence.txt
+-- for details.
+--
+--------------------------------------------------------------------------------
+--
+-- Serialize an object into a source code string. This string, when passed as
+-- an argument to loadstring()(), returns an object structurally identical
+-- to the original one. 
+--
+-- The following are supported:
+--
+-- * strings, numbers, booleans, nil
+--
+-- * functions without upvalues
+--
+-- * tables thereof. There is no restriction on keys; recursive and shared
+--   sub-tables are handled correctly.
+--
+-- Caveat: metatables and environments aren't saved; this might or might not
+--         be what you want.
+--------------------------------------------------------------------------------
+
+local no_identity = { number=1, boolean=1, string=1, ['nil']=1 }
+
+function serialize (x)
+   
+   local gensym_max =  0  -- index of the gensym() symbol generator
+   local seen_once  = { } -- element->true set of elements seen exactly once in the table
+   local multiple   = { } -- element->varname set of elements seen more than once
+   local nested     = { } -- transient, set of elements currently being traversed
+   local nest_points  = { }
+   local nest_patches = { }
+   
+   -- Generate fresh indexes to store new sub-tables:
+   local function gensym()
+      gensym_max = gensym_max + 1 ;  return gensym_max
+   end
+   
+   -----------------------------------------------------------------------------
+   -- `nest_points' are places where a (recursive) table appears within
+   -- itself, directly or not.  for instance, all of these chunks
+   -- create nest points in table `x':
+   --
+   -- "x = { }; x[x] = 1"
+   -- "x = { }; x[1] = x"
+   -- "x = { }; x[1] = { y = { x } }".
+   --
+   -- To handle those, two tables are created by `mark_nest_point()':
+   --
+   -- * `nest_points [parent]' associates all keys and values in table
+   --   parent which create a nest_point with boolean `true'
+   --
+   -- * `nest_patches' contains a list of `{ parent, key, value }'
+   --   tuples creating a nest point. They're all dumped after all the
+   --   other table operations have been performed.
+   --
+   -- `mark_nest_point (p, k, v)' fills tables `nest_points' and
+   -- `nest_patches' with informations required to remember that
+   -- key/value `(k,v)' creates a nest point in parent table `p'. It
+   -- also marks `p' as occuring multiple times, since several
+   -- references to it will be required in order to patch the nest
+   -- points.
+   -----------------------------------------------------------------------------
+   local function mark_nest_point (parent, k, v)
+      local nk, nv = nested[k], nested[v]
+      assert (not nk or seen_once[k] or multiple[k])
+      assert (not nv or seen_once[v] or multiple[v])
+      local mode = (nk and nv and "kv") or (nk and "k") or ("v")
+      local parent_np = nest_points [parent]
+      local pair = { k, v }
+      if not parent_np then parent_np = { }; nest_points [parent] = parent_np end
+      parent_np [k], parent_np [v] = nk, nv
+      table.insert (nest_patches, { parent, k, v })
+      seen_once [parent], multiple [parent]  = nil, true
+   end
+   
+   -----------------------------------------------------------------------------
+   -- 1st pass, list the tables and functions which appear more than once in `x'
+   -----------------------------------------------------------------------------
+   local function mark_multiple_occurences (x)
+      if no_identity [type(x)] then return end
+      if     seen_once [x]     then seen_once [x], multiple [x] = nil, true
+      elseif multiple  [x]     then -- pass
+      else   seen_once [x] = true end
+      
+      if type (x) == 'table' then
+         nested [x] = true
+         for k, v in pairs (x) do
+            if nested[k] or nested[v] then mark_nest_point (x, k, v) else
+               mark_multiple_occurences (k)
+               mark_multiple_occurences (v)
+            end
+         end
+         nested [x] = nil
+      end
+   end
+
+   local dumped    = { } -- multiply occuring values already dumped in localdefs
+   local localdefs = { } -- already dumped local definitions as source code lines
+
+
+   -- mutually recursive functions:
+   local dump_val, dump_or_ref_val
+
+   ------------------------------------------------------------------------------
+   -- if `x' occurs multiple times, dump the local var rather than the
+   -- value. If it's the first time it's dumped, also dump the content
+   -- in localdefs.
+   ------------------------------------------------------------------------------            
+   function dump_or_ref_val (x)
+      if nested[x] then return 'false' end -- placeholder for recursive reference
+      if not multiple[x] then return dump_val (x) end
+      local var = dumped [x]
+      if var then return "_[" .. var .. "]" end -- already referenced
+      local val = dump_val(x) -- first occurence, create and register reference
+      var = gensym()
+      table.insert(localdefs, "_["..var.."]="..val)
+      dumped [x] = var
+      return "_[" .. var .. "]"
+   end
+
+   -----------------------------------------------------------------------------
+   -- 2nd pass, dump the object; subparts occuring multiple times are dumped
+   -- in local variables, which can then be referenced multiple times;
+   -- care is taken to dump local vars in an order which repect dependencies.
+   -----------------------------------------------------------------------------
+   function dump_val(x)
+      local  t = type(x)
+      if     x==nil        then return 'nil'
+      elseif t=="number"   then return tostring(x)
+      elseif t=="string"   then return string.format("%q", x)
+      elseif t=="boolean"  then return x and "true" or "false"
+      elseif t=="function" then
+         return string.format ("loadstring(%q,'@serialized')", string.dump (x))
+      elseif t=="table" then
+
+         local acc        = { }
+         local idx_dumped = { }
+         local np         = nest_points [x]
+         for i, v in ipairs(x) do
+            if np and np[v] then
+               table.insert (acc, 'false') -- placeholder
+            else
+               table.insert (acc, dump_or_ref_val(v))
+            end
+            idx_dumped[i] = true
+         end
+         for k, v in pairs(x) do
+            if np and (np[k] or np[v]) then
+               --check_multiple(k); check_multiple(v) -- force dumps in localdefs
+            elseif not idx_dumped[k] then
+               table.insert (acc, "[" .. dump_or_ref_val(k) .. "] = " .. dump_or_ref_val(v))
+            end
+         end
+         return "{ "..table.concat(acc,", ").." }"
+      else
+         error ("Can't serialize data of type "..t)
+      end
+   end
+          
+   -- Patch the recursive table entries:
+   local function dump_nest_patches()
+      for _, entry in ipairs(nest_patches) do
+         local p, k, v = unpack (entry)
+         assert (multiple[p])
+         local set = dump_or_ref_val (p) .. "[" .. dump_or_ref_val (k) .. "] = " .. 
+            dump_or_ref_val (v) .. " -- rec "
+         table.insert (localdefs, set)
+      end
+   end
+   
+   mark_multiple_occurences (x)
+   local toplevel = dump_or_ref_val (x)
+   dump_nest_patches()
+
+   if next (localdefs) then
+      -- Dump local vars containing shared or recursive parts,
+      -- then the main table using them.
+      return "local _={ }\n" ..
+         table.concat (localdefs, "\n") .. 
+         "\nreturn " .. toplevel
+   else
+      -- No shared part, straightforward dump:
+      return "return " .. toplevel
+   end
+end