rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/metalua/base.lua

@@ -0,0 +1,104 @@
+----------------------------------------------------------------------
+----------------------------------------------------------------------
+--
+-- Base library extension
+--
+----------------------------------------------------------------------
+----------------------------------------------------------------------
+
+if not metalua then rawset(getfenv(), 'metalua', { }) end
+metalua.version             = "v-0.5"
+
+if not rawpairs then
+   rawpairs, rawipairs, rawtype = pairs, ipairs, type
+end
+
+function pairs(x)
+   assert(type(x)=='table', 'pairs() expects a table')
+   local mt = getmetatable(x)
+   if mt then
+      local mtp = mt.__pairs
+      if mtp then return mtp(x) end
+   end
+   return rawpairs(x)
+end
+
+function ipairs(x)
+   assert(type(x)=='table', 'ipairs() expects a table')
+   local mt = getmetatable(x)
+   if mt then
+      local mti = mt.__ipairs
+      if mti then return mti(x) end
+   end
+   return rawipairs(x)
+end
+
+--[[
+function type(x)
+   local mt = getmetatable(x)
+   if mt then
+      local mtt = mt.__type
+      if mtt then return mtt end
+   end
+   return rawtype(x)
+end
+]]
+
+function min (a, ...)
+   for n in values{...} do if n<a then a=n end end
+   return a
+end
+
+function max (a, ...)
+   for n in values{...} do if n>a then a=n end end
+   return a
+end
+
+function o (...)
+   local args = {...}
+   local function g (...)
+      local result = {...}
+      for i=#args, 1, -1 do result = {args[i](unpack(result))} end
+      return unpack (result)
+   end
+   return g
+end
+
+function id (...) return ... end
+function const (k) return function () return k end end
+
+function printf(...) return print(string.format(...)) end
+function eprintf(...) 
+   io.stderr:write(string.format(...).."\n") 
+end
+
+function ivalues (x)
+   assert(type(x)=='table', 'ivalues() expects a table')
+   local i = 1
+   local function iterator ()
+      local r = x[i]; i=i+1; return r
+   end
+   return iterator
+end
+
+
+function values (x)
+   assert(type(x)=='table', 'values() expects a table')
+   local function iterator (state)
+      local it
+      state.content, it = next(state.list, state.content)
+      return it
+   end
+   return iterator, { list = x }
+end
+
+function keys (x)
+   assert(type(x)=='table', 'keys() expects a table')
+   local function iterator (state)
+      local it = next(state.list, state.content)
+      state.content = it
+      return it
+   end
+   return iterator, { list = x }
+end
+

data/vendor/lua/lib/lua/metalua/clopts.mlua

@@ -0,0 +1,204 @@
+--------------------------------------------------------------------------------
+-- Command Line OPTionS handler
+-- ============================
+--
+-- This lib generates parsers for command-line options. It encourages
+-- the following of some common idioms: I'm pissed off by Unix tools
+-- which sometimes will let you concatenate single letters options,
+-- sometimes won't, will prefix long name options with simple dashes
+-- instead of doubles, etc.
+--
+--------------------------------------------------------------------------------
+
+-- TODO:
+-- * add a generic way to unparse options ('grab everything')
+-- * doc
+-- * when a short options that takes a param isn't the last element of a series
+--   of shorts, take the remaining of the sequence as that param, e.g. -Ifoo
+-- * let unset strings/numbers with +
+-- * add a ++ long counterpart to +
+--
+
+-{ extension 'match' }
+
+function clopts(cfg)
+   local short, long, param_func = { }, { }
+   local legal_types = table.transpose{ 
+      'boolean','string','number','string*','number*','nil', '*' }
+
+   -----------------------------------------------------------------------------
+   -- Fill short and long name indexes, and check its validity
+   -----------------------------------------------------------------------------
+   for x in ivalues(cfg) do
+      local xtype = type(x)
+      if xtype=='table' then
+         if not x.type then x.type='nil' end
+         if not legal_types[x.type] then error ("Invalid type name "..x.type) end
+         if x.short then
+            if short[x.short] then error ("multiple definitions for option "..x.short) 
+            else short[x.short] = x end
+         end
+         if x.long then
+            if long[x.long] then error ("multiple definitions for option "..x.long) 
+            else long[x.long] = x end
+         end
+      elseif xtype=='function' then
+         if param_func then error "multiple parameters handler in clopts"
+         else param_func=x end
+      end
+   end
+
+   -----------------------------------------------------------------------------
+   -- Print a help message, summarizing how to use the command line
+   -----------------------------------------------------------------------------
+   local function print_usage(msg)
+      if msg then print(msg,'\n') end
+      print(cfg.usage or "Options:\n")
+      for x in values(cfg) do
+         if type(x) == 'table' then
+            local opts = { }
+            if x.type=='boolean' then 
+               if x.short then opts = { '-'..x.short..'/+'..x.short } end
+               if x.long  then table.insert (opts, '--'..x.long..'/++'..x.long) end
+            else
+               if x.short then opts = { '-'..x.short..' <'..x.type..'>' } end
+               if x.long  then table.insert (opts,  '--'..x.long..' <'..x.type..'>' ) end
+            end
+            printf("  %s: %s", table.concat(opts,', '), x.usage or '<undocumented>')
+         end
+      end
+      print''
+   end
+
+   -- Unless overridden, -h and --help display the help msg
+   local default_help = { action = | | print_usage() or os.exit(0);
+                          long='help';short='h';type='nil'}
+   if not short.h   then short.h   = default_help end
+   if not long.help then long.help = default_help end
+
+   -----------------------------------------------------------------------------
+   -- Helper function for options parsing. Execute the attached action and/or
+   -- register the config in cfg.
+   --
+   -- * cfg  is the table which registers the options
+   -- * dict the name->config entry hash table that describes options
+   -- * flag is the prefix '-', '--' or '+'
+   -- * opt  is the option name
+   -- * i    the current index in the arguments list
+   -- * args is the arguments list
+   -----------------------------------------------------------------------------
+   local function actionate(cfg, dict, flag, opt, i, args)
+      local entry = dict[opt]
+      if not entry then print_usage ("invalid option "..flag..opt); return false; end
+      local etype, name = entry.type, entry.name or entry.long or entry.short
+      match etype with
+      | 'string' | 'number' | 'string*' | 'number*' -> 
+         if flag=='+' or flag=='++' then 
+            print_usage ("flag "..flag.." is reserved for boolean options, not for "..opt)
+            return false
+         end
+         local arg = args[i+1]
+         if not arg then 
+            print_usage ("missing parameter for option "..flag..opt)
+            return false
+         end
+         if etype:strmatch '^number' then 
+            arg = tonumber(arg)
+            if not arg then 
+               print_usage ("option "..flag..opt.." expects a number argument")
+            end
+         end
+         if etype:strmatch '%*$' then 
+            if not cfg[name] then cfg[name]={ } end
+            table.insert(cfg[name], arg)
+         else cfg[name] = arg end
+         if entry.action then entry.action(arg) end
+         return i+2
+      | 'boolean' -> 
+         local arg = flag=='-' or flag=='--'
+         cfg[name] = arg
+         if entry.action then entry.action(arg) end
+         return i+1
+      | 'nil' -> 
+         cfg[name] = true;
+         if entry.action then entry.action() end
+         return i+1
+      | '*' -> 
+         local arg = table.isub(args, i+1, #args)
+         cfg[name] = arg
+         if entry.action then entry.action(arg) end
+         return #args+1
+      |  _ -> assert( false, 'undetected bad type for clopts action')
+      end
+   end
+
+   -----------------------------------------------------------------------------
+   -- Parse a list of commands: the resulting function
+   -----------------------------------------------------------------------------
+   local function parse(...)
+      local cfg = { }
+      if not ... then return cfg end
+      local args = type(...)=='table' and ... or {...}
+      local i, i_max = 1, #args
+      while i <= i_max do         
+         local arg, flag, opt, opts = args[i]
+         --printf('beginning of loop: i=%i/%i, arg=%q', i, i_max, arg)
+         if arg=='-' then
+            i=actionate (cfg, short, '-', '', i, args)
+            -{ `Goto 'continue' }
+         end
+
+         -----------------------------------------------------------------------
+         -- double dash option
+         -----------------------------------------------------------------------
+         flag, opt = arg:strmatch "^(%-%-)(.*)"
+         if opt then
+            i=actionate (cfg, long, flag, opt, i, args)
+            -{ `Goto 'continue' }
+         end
+
+         -----------------------------------------------------------------------
+         -- double plus option
+         -----------------------------------------------------------------------
+         flag, opt = arg:strmatch "^(%+%+)(.*)"
+         if opt then
+            i=actionate (cfg, long, flag, opt, i, args)
+            -{ `Goto 'continue' }
+         end
+
+         -----------------------------------------------------------------------
+         -- single plus or single dash series of short options
+         -----------------------------------------------------------------------
+         flag, opts = arg:strmatch "^([+-])(.+)"
+         if opts then 
+            local j_max, i2 = opts:len()
+            for j = 1, j_max do
+               opt = opts:sub(j,j)
+               --printf ('parsing short opt %q', opt)               
+               i2 = actionate (cfg, short, flag, opt, i, args)
+               if i2 ~= i+1 and j < j_max then 
+                  error ('short option '..opt..' needs a param of type '..short[opt])
+               end               
+            end
+            i=i2 
+            -{ `Goto 'continue' }
+         end
+
+         -----------------------------------------------------------------------
+         -- handler for non-option parameter
+         -----------------------------------------------------------------------         
+         if param_func then param_func(args[i]) end
+         if cfg.params then table.insert(cfg.params, args[i])
+         else cfg.params = { args[i] } end
+         i=i+1
+
+         -{ `Label 'continue' }
+         if not i then return false end
+      end -- </while>
+      return cfg
+   end
+
+   return parse
+end
+
+

data/vendor/lua/lib/lua/metalua/compiler.lua

@@ -0,0 +1,3 @@
+require 'metalua.runtime'
+require 'metalua.mlc'
+require 'metalua.package2'

data/vendor/lua/lib/lua/metalua/dollar.mlua

@@ -0,0 +1,24 @@
+-- TODO: support modules as macros?
+--       does it make sense to store a constant AST as a macro?
+
+-{ extension 'match' }
+
+dollar = rawget(getfenv(), 'dollar') or { }
+
+local function dollar_builder(call)
+   match call with
+   | `Call{ `Id{name}, ... } -> return dollar[name](select(2, unpack(call)))
+   | `Id{name} -> 
+      local m = dollar[name]
+      match type(m) with
+      | 'function' -> return m()
+      | 'table'    -> return m
+      | 'nil'      -> error "No such macro registered"
+      | t          -> error ("Invalid macro type "..t)
+      end
+   | _ -> error "Invalid $macro, '$' should be followed by an identifier or function call"
+   end
+end   
+
+mlp.expr.prefix:add{ '$', prec = 100, builder = |_, x| dollar_builder(x) }
+mlp.stat:add{ '$', mlp.expr, builder = |x| dollar_builder(x[1]) }

data/vendor/lua/lib/lua/metalua/extension/H-runtime.mlua

@@ -0,0 +1,216 @@
+require 'metalua.walk.id'
+-{ extension 'log' }
+
+--------------------------------------------------------------------------------
+--
+-- H params:
+-- * H.alpha is the `Local{ } (or `Set{ }) statement which will
+--   receive the alpha-conversions required to restore the free
+--   variables of the transformed term. For instance,
+--   H+{print(1)} will be transformed into +{.1.X.print(1)},
+--   and alpha will contain +{local -{`Id '.1.X.print} = print }.
+--   alpha is reused and augmented by successive calls to H().
+--
+-- * H.side contains 'inside', 'outside', 'both' or nil (equivalent to
+--   'both'). It indicates the kind of hygienization that's to be
+--   performed.
+--
+-- * H.keep contain a set of free variable names which must not be
+--   renamed.
+--
+-- * H.kind is the kind of walker that must be used ('expr', 'stat',
+--   'block'...) and defaults to 'guess'.
+--
+-- * H:set (field, val) sets a field in H and returns H, so that calls
+--   can be chained, e.g.:
+--   > H:set(keep, {'print'}):set('side', outside)+{print(x)}
+--
+-- * H:reset(field) sets a field to nil, and returns the value of that
+--   field prior to nilification.
+--------------------------------------------------------------------------------
+
+H = { } --setmetatable(H, H)
+H.__index=H
+H.template = { alpha = { } }
+
+--------------------------------------------------------------------------------
+--
+--------------------------------------------------------------------------------
+function H:new(x)
+   local instance = table.deep_copy(self.template)
+   if x then instance <- x end
+   setmetatable(instance, self)
+   return instance
+end
+
+--------------------------------------------------------------------------------
+--
+--------------------------------------------------------------------------------
+function H:__call (ast)
+   assert (type(ast)=='table', "H expects an AST")
+
+   local local_renames -- only set if inside hygienization's required
+
+   -----------------------------------------------------------------------------
+   -- kind of hygienization(s) to perform: h_inseide and/or h_outside
+   -----------------------------------------------------------------------------
+   local h_inside, h_outside do
+      local side = self.side or 'both'
+      h_inside   = side=='inside'  or side=='both'
+      h_outside  = side=='outside' or side=='both'
+   end
+
+   -----------------------------------------------------------------------------
+   -- Initialize self.keep:
+   -- self.keep is a dictionary of free var names to be protected from capture
+   -----------------------------------------------------------------------------
+   do
+      local k = self.keep
+      -- If there's no self.keep, that's an empty dictionary
+      if not k then k = { }; self.keep = k
+      -- If it's a string, consider it as a single-element dictionary
+      elseif type(k)=='string' then k = { [k] = true }; self.keep=k
+      -- If there's a list-part in self.keep, transpose it:
+      else for i, v in ipairs(k) do k[v], k[i] = true, nil end end
+   end
+
+   -----------------------------------------------------------------------------
+   -- Config skeleton for the id walker
+   -----------------------------------------------------------------------------
+   local cfg = { expr = { }, stat = { }, id = { } }
+
+   -----------------------------------------------------------------------------
+   -- Outside hygienization: all free variables are renamed to fresh ones,
+   -- and self.alpha is updated to contain the assignments required to keep
+   -- the AST's semantics.
+   -----------------------------------------------------------------------------
+   if h_outside then
+      local alpha = self.alpha
+
+      -- free_vars is an old_name -> new_name dictionary computed from alpha:
+      -- self.alpha is not an efficient representation for searching.
+      if not alpha then alpha = { }; self.alpha = alpha end
+      -- FIXME: alpha should only be overridden when there actually are some
+      -- globals renamed.
+      if #alpha==0 then alpha <- `Local{ { }, { } } end
+      local new, old = unpack(alpha)
+      local free_vars  = { }
+
+      assert (#new==#old, "Invalid alpha list")
+      for i = 1, #new do
+         assert (old[i].tag=='Id' and #old[i]==1, "Invalid lhs in alpha list")
+         assert (new[i].tag=='Id' and #new[i]==1, "Invalid rhs in alpha list")
+         free_vars[old[i][1]] = new[i][1]
+      end
+
+      -- Rename free variables that are not supposed to be captured.
+      function cfg.id.free (id)
+         local old_name = id[1]
+         if self.keep[old_name] then return end
+         local new_name = free_vars[old_name]
+         if not new_name then
+            new_name = mlp.gensym('X.'..old_name)[1]
+            free_vars[old_name] = new_name
+            table.insert(alpha[1], `Id{new_name})
+            table.insert(alpha[2], `Id{old_name})
+         end
+         id[1] = new_name
+      end
+   end
+
+   -----------------------------------------------------------------------------
+   -- Inside hygienization: rename all local variables and their ocurrences.
+   -----------------------------------------------------------------------------
+   if h_inside then
+
+      ----------------------------------------------------------------
+      -- Renamings can't performed on-the-spot, as it would
+      -- transiently break the link between binders and bound vars,
+      -- thus preventing the algo to work. They're therefore stored
+      -- in local_renames, and performed after the whole tree has been
+      -- walked.
+      ----------------------------------------------------------------
+
+      local_renames = { }    -- `Id{ old_name } -> new_name
+      local bound_vars = { } -- binding statement -> old_name -> new_name
+
+      ----------------------------------------------------------------
+      -- Give a new name to newly created local vars, store it in
+      -- bound_vars
+      ----------------------------------------------------------------
+      function cfg.binder (id, binder)
+         if id.h_boundary then return end
+         local old_name = id[1]
+         local binder_table = bound_vars[binder]
+         if not binder_table then
+            binder_table = { }
+            bound_vars[binder] = binder_table
+         end
+         local new_name = mlp.gensym('L.'..old_name)[1]
+         binder_table[old_name] = new_name
+         local_renames[id] = new_name
+      end
+
+      ----------------------------------------------------------------
+      -- List a bound var for renaming.  The new name has already been
+      -- chosen and put in bound_vars by cfg.binder().
+      ----------------------------------------------------------------
+      function cfg.id.bound (id, binder)
+         if id.h_boundary then return end
+         local old_name = id[1]
+         local new_name = bound_vars[binder][old_name]
+         --.log(bound_vars[binder])
+         assert(new_name, "no alpha conversion for a bound var?!")
+         local_renames[id] = new_name
+      end
+   end
+
+   -----------------------------------------------------------------------------
+   -- Don't traverse subtrees marked by '!'
+   -----------------------------------------------------------------------------
+   local cut_boundaries = |x| x.h_boundary and 'break' or nil
+   cfg.stat.down, cfg.expr.down = cut_boundaries, cut_boundaries
+
+   -----------------------------------------------------------------------------
+   -- The walker's config is ready, let's go.
+   -- After that, ids are renamed in ast, free_vars and bound_vars are set.
+   -----------------------------------------------------------------------------
+   walk_id [self.kind or 'guess'] (cfg, ast)
+
+   if h_inside then -- Apply local name changes
+      for id, new_name in pairs(local_renames) do id[1] = new_name end
+   end
+
+   return ast
+end
+
+--------------------------------------------------------------------------------
+-- Return H to allow call chainings
+--------------------------------------------------------------------------------
+function H:set(field, val)
+   local t = type(field)
+   if t=='string' then self[field]=val
+   elseif t=='table' then self <- field
+   else error("Can't set H, field arg can't be of type "..t) end
+   return self
+end
+
+--------------------------------------------------------------------------------
+-- Return the value before reset
+--------------------------------------------------------------------------------
+function H:reset(field)
+   if type(field) ~= 'string' then error "Can only reset H string fields" end
+   local r = H[field]
+   H[field] = nil
+   return r
+end
+
+-- local function commit_locals_to_chunk(x)
+--    local alpha = H:reset 'alpha'
+--    --$log ('commit locals', x, alpha, 'nohash')
+--    if not alpha or not alpha[1][1] then return end
+--    if not x then return alpha end
+--    table.insert(x, 1, alpha)
+-- end
+
+-- mlp.chunk.transformers:add (commit_locals_to_chunk)