rufus-lua-win 5.1.5

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

@@ -0,0 +1,22 @@
+require 'metalua.walk.id'
+-{ extension 'log' }
+
+mlp.expr.prefix:add{ '!', prec = 5,
+   builder = function(_,x)
+                local v = mlp.gensym()
+                return `Stat{ +{ block:
+                                 local -{v} = -{x};
+                                 (-{v}).h_boundary=true },
+                              v }
+             end }
+
+mlp.stat:add{ '!', mlp.expr, builder = |x| +{stat: (-{x[1]}).h_boundary=true } }
+
+-- * if there's no boundary in it, is there a need to rename vars?
+--   ==> first pass to mark binders which contain boundaries,
+--       then 2nd pass only touched those which have a splice
+--       in them.
+
+return +{ require (-{ `String{ package.metalua_extension_prefix .. 'H-runtime' } }) }
+
+

data/vendor/lua/lib/lua/metalua/extension/anaphoric.mlua

@@ -0,0 +1,54 @@
+--------------------------------------------------------------------------------
+--
+-- Anaphoric macros.
+--
+-- This extension turns 'it' into a special variable, that's bound to
+-- an often used value:
+--
+-- * in an 'if' statement, 'it' is bound, in a block, to the condition
+--   that triggered the block's execution:
+--   > if 1234 then y=it end; assert (y == 1234)
+--
+-- * in a while loop, it's bound to the test:
+--   > while file:read "*a" do table.insert (lines, it) end
+--
+-- 'it' is bound the the most closely surrounding structure. If you wanted to
+-- use its content at a deeper position in the AST, you would have to save it
+-- in a temporary variable. But what you should really do in such a case is
+-- avoiding to use anaphoric macros: they're fine for one-liner, but they
+-- reduce readability for bigger functions.
+--------------------------------------------------------------------------------
+
+-- TODO: 'and' operator could, and maybe should, be anaphoric as well
+-- TODO: anaphoric functions would be cool for recursive functions, but
+--       recursive calls are always in an 'if' statement, so the pronoun
+--       used for functions must not be the same as for 'if'.
+
+require 'freevars'
+
+local function anaphoric_if(ast)
+   local it_found = false
+   for i=2, #ast do 
+      if freevars.block(ast[i])['it'] then
+         it_found = true
+         break
+      end
+   end
+   if it_found then
+      local cond = ast[1]
+      ast[1] = +{it}
+      return +{stat: do local it = -{cond}; -{ast} end }
+   end
+end
+
+local function anaphoric_while(ast)
+   local it_found = false
+   if freevars.block(ast[2])['it'] then
+      local cond = ast[1]
+      ast[1] = +{it}
+      return +{stat: do local it = -{cond}; -{ast} end }
+   end
+end
+
+mlp.stat:get'if'.transformers:add(anaphoric_if)
+mlp.stat:get'while'.transformers:add(anaphoric_while)

data/vendor/lua/lib/lua/metalua/extension/clist.mlua

@@ -0,0 +1,149 @@
+----------------------------------------------------------------------
+-- Metalua samples:  $Id$
+--
+-- Summary: Lists by comprehension
+--
+----------------------------------------------------------------------
+--
+-- Copyright (c) 2006-2007, Fabien Fleutot <metalua@gmail.com>.
+--
+-- This software is released under the MIT Licence, see licence.txt
+-- for details.
+--
+--------------------------------------------------------------------------------
+--
+-- This extension implements list comprehensions, similar to Haskell and
+-- Python syntax, to easily describe lists.
+--
+--------------------------------------------------------------------------------
+
+-{ extension "match" }
+
+local function dots_builder (x) return `Dots{ x } end
+
+local function for_builder (x, h)
+   match x with
+   | `Comp{ _, acc } -> table.insert (acc, h[1]); return x
+   | `Pair{ _, _ }   -> error "No explicit key in a for list generator"
+   |  _              -> return `Comp{ x, {h[1]} }
+   end
+end
+
+local function if_builder (x, p)
+   match x with
+   | `Comp{ _, acc } -> table.insert (acc, `If{ p[1] }); return x
+   | `Pair{ _, _ }   -> error "No explicit key in a list guard"
+   |  _              -> return `Comp{ x, p[1] }
+   end
+end
+   
+local function comp_builder(core, list, no_unpack)
+   -- [ti] = temp var holding table.insert
+   -- [v]  = variable holding the table being built
+   -- [r]  = the core of the list being built
+   local ti, v, r = mlp.gensym "table_insert", mlp.gensym "table"
+
+   -----------------------------------------------------------------------------
+   -- 1 - Build the loop's core: if it has suffix "...", every elements of the
+   --     multi-return must be inserted, hence the extra [for] loop.
+   -----------------------------------------------------------------------------
+   match core with
+   | `Dots{ x } -> 
+      local w = mlp.gensym()
+      r = +{stat: for -{w} in values( -{x} ) do -{ `Call{ ti, v, w } } end }
+   | `Pair{ k, w } ->
+      r = `Set{ { `Index{ v, k } }, { w } }
+   |  _ -> r = `Call{ ti, v, core }
+   end
+
+   -----------------------------------------------------------------------------
+   -- 2 - Stack the if and for control structures, from outside to inside.
+   --     This is done in a destructive way for the elements of [list].
+   -----------------------------------------------------------------------------
+   for i = #list, 1, -1 do
+      table.insert (list[i], {r})
+      r = list[i]
+   end
+   if no_unpack then
+      return `Stat{ { `Local{ {ti, v}, { +{table.insert}, `Table} }, r }, v }
+   else
+      return +{ function() 
+                   local -{ti}, -{v} = table.insert, { }
+                   -{r}; return unpack(-{v}) 
+                end () }
+   end
+end
+
+local function table_content_builder (list)
+   match list with
+   | { `Comp{ y, acc } } -> return comp_builder( y, acc, "no unpack")
+   | _ ->
+      local tables = { `Table }
+      local ctable = tables[1]
+      local function flush() ctable=`Table; table.insert(tables, ctable) end
+      for x in values(list) do
+         match x with
+         | `Comp{ y, acc } -> table.insert(ctable, comp_builder(y, acc)); flush()
+         | `Dots{ y }      -> table.insert(ctable, y); flush()
+         |  _              -> table.insert (ctable, x); 
+         end
+      end
+      match tables with
+      | { x } | { x, { } } -> return x
+      | _ ->
+         if #tables[#tables]==0 then table.remove(tables) end --suppress empty table      
+         return `Call{ +{table.cat}, unpack(tables) }
+      end
+   end
+end
+
+mlp.table_field = gg.expr{ name="table cell",
+   primary = mlp.table_field,
+   suffix  = { name="table cell suffix",
+      { "...",                 builder = dots_builder },
+      { "for", mlp.for_header, builder = for_builder  },
+      { "if",  mlp.expr,       builder = if_builder   } } }
+
+mlp.table_content.builder = table_content_builder
+
+--[[
+mlp.stat:add{ "for", gg.expr {
+      primary = for_header,
+      suffix = {
+         { "for", mlp.for_header, builder = for_builder  },
+         { "if",  mlp.expr,       builder = if_builder   } } }, 
+   "do", mlp.block, "end", builder = for_stat_builder }
+--]]
+
+--------------------------------------------------------------------------------
+-- Back-end for improved index operator.
+--------------------------------------------------------------------------------
+local function index_builder(a, suffix)
+   match suffix[1] with
+   -- Single index, no range: keep the native semantics
+   | { { e, false } } -> return `Index{ a, e }
+   -- Either a range, or multiple indexes, or both
+   | ranges ->
+      local r = `Call{ +{table.isub}, a }
+      local function acc (x,y) table.insert (r,x); table.insert (r,y) end
+      for seq in ivalues (ranges) do
+         match seq with
+         | { e, false } -> acc(e,e)
+         | { e, f }     -> acc(e,f)
+         end
+      end
+      return r
+   end
+end
+
+--------------------------------------------------------------------------------
+-- Improved "[...]" index operator:
+--  * support for multi-indexes ("foo[bar, gnat]")
+--  * support for ranges ("foo[bar ... gnat]")
+--------------------------------------------------------------------------------
+mlp.expr.suffix:del '['
+mlp.expr.suffix:add{ name="table index/range",
+   "[", gg.list{
+      gg.sequence { mlp.expr, gg.onkeyword{ "...", mlp.expr } } , 
+      separators = { ",", ";" } }, 
+   "]", builder = index_builder }

data/vendor/lua/lib/lua/metalua/extension/continue.mlua

@@ -0,0 +1,53 @@
+require "metalua.walk"
+
+----------------------------------------------------------------------
+-- * [loop_tags] are the tags of statements which support continue.
+-- * [loop_keywords] are the initial keywords which trigger the parsing
+--   of these statements: they're indeed indexed by keyword in [mlp.stat].
+----------------------------------------------------------------------
+
+local loop_tags = table.transpose{ "Forin", "Fornum", "While", "Repeat" }
+local loop_keywords = { "for", "while", "repeat" }
+
+----------------------------------------------------------------------
+-- This function takes the AST of a continue-enabled loop, parse
+-- its body to find all instances of [`Continue]. If any of them
+-- is found ([label~=nil]), they're transformed in [`Goto{...}], and
+-- the corresponding label is added at the end of the loop's body.
+--
+-- Caveat: if a [continue] appears in the non-body part of a loop
+-- (and therefore is relative to some enclosing loop), it isn't
+-- handled, and therefore causes a compilation error. This could
+-- only happen due in a [`Stat{ }], however, since [`Function{ }]
+-- cuts the search for [`Continue].
+----------------------------------------------------------------------
+local function loop_transformer (ast)
+   local label
+   local cfg = { stat = { }; expr = { } }
+
+   function cfg.stat.down (x)
+      if loop_tags[x.tag] then return 'break'
+      elseif x.tag=='Continue' then
+         if not label then label = mlp.gensym 'continue' end
+         x <- `Goto{ label }
+      end
+   end
+
+   function cfg.expr.down (x)
+      return x.tag=='Function' and 'break'
+   end
+
+   local loop_body = ast.tag=="Repeat" and ast[1] or ast[#ast]
+   walk.block (cfg, loop_body)
+   if label then table.insert (loop_body, `Label{ label }) end
+end
+
+----------------------------------------------------------------------
+-- Register the transformer for each kind of loop:
+----------------------------------------------------------------------
+for keyword in values (loop_keywords) do
+   mlp.stat:get(keyword).transformers:add (loop_transformer)
+end
+
+mlp.lexer:add "continue"
+mlp.stat:add{ "continue", builder = ||`Continue }

data/vendor/lua/lib/lua/metalua/extension/localin.mlua

@@ -0,0 +1,2 @@
+mlp.expr:add{ "local", mlp.id, "=", mlp.expr, "in", mlp.expr,
+   builder=|x| `Stat{ { `Local{ { x[1] }, { x[2] } } }, x[3] } }

data/vendor/lua/lib/lua/metalua/extension/log.mlua

@@ -0,0 +1,39 @@
+require 'metalua.dollar'
+
+-{ extension 'match' }
+
+function dollar.log(...)
+   local args   = {...}
+   local ti     = table.insert
+   local code   = { }
+   local nohash = false
+   local width  = 80
+
+   local i=1
+   if args[i].tag=='String' then
+      ti(code, +{print(" [LOG] "..-{args[1]})})
+      i += 1
+   end
+
+   local xtra_args, names, vals = { }, { }, { }
+   for i=i, #args do
+      match args[i] with
+      | +{ 'nohash' } -> nohash = true
+      | `Number{ w }  -> width = w
+      --| `String{...} | `Number{...} -> ti (xtra_args, args[i])
+      | `Id{n} -> ti (names, n); ti (vals, args[i])
+      | x      -> ti (names, table.tostring(x, 'nohash')); ti (vals, x)
+      end
+   end
+
+   for i=1, #names do
+      local msg = string.format(" [LOG] %s = ", names[i])
+      local printer = `Call{ +{table.tostring},
+                              vals[i],
+                              `Number{ width },
+                              `Number{ #msg  } }
+      if nohash then ti(printer, +{'nohash'}) end
+      ti (code, `Call{ +{printf}, +{"%s%s"}, `String{ msg }, printer })
+   end
+   return code
+end

data/vendor/lua/lib/lua/metalua/extension/match.mlua

@@ -0,0 +1,374 @@
+----------------------------------------------------------------------
+-- Metalua samples:  $Id$
+--
+-- Summary: Structural pattern matching for metalua ADT.
+--
+----------------------------------------------------------------------
+--
+-- Copyright (c) 2006-2008, Fabien Fleutot <metalua@gmail.com>.
+--
+-- This software is released under the MIT Licence, see licence.txt
+-- for details.
+--
+--------------------------------------------------------------------------------
+--
+-- Glossary:
+--
+-- * term_seq: the tested stuff, a sequence of terms
+-- * pattern_element: might match one term of a term seq. Represented
+--   as expression ASTs.
+-- * pattern_seq: might match a term_seq
+-- * pattern_group: several pattern seqs, one of them might match
+--                  the term seq.
+-- * case: pattern_group * guard option * block
+-- * match_statement: tested term_seq * case list 
+--
+-- Hence a complete match statement is a:
+--
+-- { list(expr),  list{ list(list(expr)), expr or false, block } } 
+--
+-- Implementation hints
+-- ====================
+--
+-- The implementation is made as modular as possible, so that parts
+-- can be reused in other extensions. The priviledged way to share
+-- contextual information across functions is through the 'cfg' table
+-- argument. Its fields include:
+--
+-- * code: code generated from pattern. A pattern_(element|seq|group)
+--   is compiled as a sequence of instructions which will jump to
+--   label [cfg.on_failure] if the tested term doesn't match.
+--
+-- * on_failure: name of the label where the code will jump if the
+--   pattern doesn't match
+--
+-- * locals: names of local variables used by the pattern. This
+--   includes bound variables, and temporary variables used to
+--   destructure tables. Names are stored as keys of the table,
+--   values are meaningless.
+--
+-- * after_success: label where the code must jump after a pattern
+--   succeeded to capture a term, and the guard suceeded if there is
+--   any, and the conditional block has run.
+--
+-- * ntmp: number of temporary variables used to destructurate table
+--   in the current case.
+--
+-- Code generation is performed by acc_xxx() functions, which accumulate
+-- code in cfg.code:
+--
+-- * acc_test(test, cfg) will generate a jump to cfg.on_failure 
+--   *when the test returns TRUE*
+--
+-- * acc_stat accumulates a statement
+-- 
+-- * acc_assign accumulate an assignment statement, and makes sure that 
+--   the LHS variable the registered as local in cfg.locals.
+--   
+----------------------------------------------------------------------
+
+-- TODO: hygiene wrt type()
+-- TODO: cfg.ntmp isn't reset as often as it could. I'm not even sure
+--       the corresponding locals are declared.
+
+module ('spmatch', package.seeall)
+
+----------------------------------------------------------------------
+-- This would have been best done through library 'metalua.walk',
+-- but walk depends on match, so we have to break the dependency.
+-- It replaces all instances of `...' in `ast' with `term', unless
+-- it appears in a function.
+----------------------------------------------------------------------
+function replace_dots (ast, term)
+   local function rec (x)
+      if type(x) == 'table' then
+         if x.tag=='Dots' then 
+            if term=='ambiguous' then
+               error ("You can't use `...' on the right of a match case when it appears "..
+                      "more than once on the left")
+            else 
+               x <- term
+            end
+         elseif x.tag=='Function' then return
+         else for y in ivalues (x) do rec (y) end end
+      end
+   end
+   return rec (ast)
+end
+
+tmpvar_base = mlp.gensym 'submatch.' [1]
+function next_tmpvar(cfg)
+   assert (cfg.ntmp, "No cfg.ntmp imbrication level in the match compiler")
+   cfg.ntmp = cfg.ntmp+1
+   return `Id{ tmpvar_base .. cfg.ntmp }
+end
+
+-- Code accumulators
+acc_stat = |x,cfg| table.insert (cfg.code, x)
+acc_test = |x,cfg| acc_stat(+{stat: if -{x} then -{`Goto{cfg.on_failure}} end}, cfg)
+-- lhs :: `Id{ string }
+-- rhs :: expr
+function acc_assign (lhs, rhs, cfg)
+   assert(lhs.tag=='Id')
+   cfg.locals[lhs[1]] = true
+   acc_stat (`Set{ {lhs}, {rhs} }, cfg)
+end
+
+literal_tags = table.transpose{ 'String', 'Number', 'True', 'False', 'Nil' }
+
+-- pattern :: `Id{ string }
+-- term    :: expr
+function id_pattern_element_builder (pattern, term, cfg)
+   assert (pattern.tag == "Id")
+   if pattern[1] == "_" then 
+      -- "_" is used as a dummy var ==> no assignment, no == checking
+      cfg.locals._ = true
+   elseif cfg.locals[pattern[1]] then 
+      -- This var is already bound ==> test for equality
+      acc_test (+{ -{term} ~= -{pattern} }, cfg)
+   else
+      -- Free var ==> bind it, and remember it for latter linearity checking
+      acc_assign (pattern, term, cfg) 
+      cfg.locals[pattern[1]] = true
+   end
+end
+
+-- Concatenate code in [cfg.code], that will jump to label
+-- [cfg.on_failure] if [pattern] doesn't match [term]. [pattern]
+-- should be an identifier, or at least cheap to compute and
+-- side-effects free.
+--
+-- pattern :: pattern_element
+-- term    :: expr
+function pattern_element_builder (pattern, term, cfg)
+   if literal_tags[pattern.tag] then
+      acc_test (+{ -{term} ~= -{pattern} }, cfg)
+   elseif "Id" == pattern.tag then 
+      id_pattern_element_builder (pattern, term, cfg)
+   elseif "Op" == pattern.tag and "div" == pattern[1] then
+      regexp_pattern_element_builder (pattern, term, cfg)
+   elseif "Op" == pattern.tag and "eq" == pattern[1] then
+      eq_pattern_element_builder (pattern, term, cfg)
+   elseif "Table" == pattern.tag then
+      table_pattern_element_builder (pattern, term, cfg)
+   else 
+      error ("Invalid pattern: "..table.tostring(pattern, "nohash"))
+   end
+end
+
+function eq_pattern_element_builder (pattern, term, cfg)
+   local _, pat1, pat2 = unpack (pattern)
+   local ntmp_save = cfg.ntmp
+   pattern_element_builder (pat1, term, cfg)
+   cfg.ntmp = ntmp_save
+   pattern_element_builder (pat2, term, cfg)
+end
+
+-- pattern :: `Op{ 'div', string, list{`Id string} or `Id{ string }}
+-- term    :: expr
+function regexp_pattern_element_builder (pattern, term, cfg)
+   local op, regexp, sub_pattern = unpack(pattern)
+
+   -- Sanity checks --
+   assert (op=='div', "Don't know what to do with that op in a pattern")
+   assert (regexp.tag=="String", 
+           "Left hand side operand for '/' in a pattern must be "..
+           "a literal string representing a regular expression")
+   if sub_pattern.tag=="Table" then
+      for x in ivalues(sub_pattern) do
+	 assert (x.tag=="Id" or x.tag=='Dots',
+		 "Right hand side operand for '/' in a pattern must be "..
+		 "a list of identifiers")
+      end
+   else
+      assert (sub_pattern.tag=="Id",
+	      "Right hand side operand for '/' in a pattern must be "..
+              "an identifier or a list of identifiers")
+   end
+
+   -- Regexp patterns can only match strings
+   acc_test (+{ type(-{term}) ~= 'string' }, cfg)
+   -- put all captures in a list
+   local capt_list  = +{ { string.strmatch(-{term}, -{regexp}) } }
+   -- save them in a var_n for recursive decomposition
+   local v2 = next_tmpvar(cfg)
+   acc_stat (+{stat: local -{v2} = -{capt_list} }, cfg)
+   -- was capture successful?
+   acc_test (+{ not next (-{v2}) }, cfg)
+   pattern_element_builder (sub_pattern, v2, cfg)
+end
+
+-- pattern :: pattern and `Table{ }
+-- term    :: expr
+function table_pattern_element_builder (pattern, term, cfg)
+   local seen_dots, len = false, 0
+   acc_test (+{ type( -{term} ) ~= "table" }, cfg)
+   for i = 1, #pattern do
+      local key, sub_pattern
+      if pattern[i].tag=="Pair" then -- Explicit key/value pair
+         key, sub_pattern = unpack (pattern[i])
+         assert (literal_tags[key.tag], "Invalid key")
+      else -- Implicit key
+         len, key, sub_pattern = len+1, `Number{ len+1 }, pattern[i]
+      end
+      
+      -- '...' can only appear in final position
+      -- Could be fixed actually...
+      assert (not seen_dots, "Wrongly placed `...' ")
+
+      if sub_pattern.tag == "Id" then 
+         -- Optimization: save a useless [ v(n+1)=v(n).key ]
+         id_pattern_element_builder (sub_pattern, `Index{ term, key }, cfg)
+         if sub_pattern[1] ~= "_" then 
+            acc_test (+{ -{sub_pattern} == nil }, cfg)
+         end
+      elseif sub_pattern.tag == "Dots" then
+         -- Remember where the capture is, and thatt arity checking shouldn't occur
+         seen_dots = true
+      else
+         -- Business as usual:
+         local v2 = next_tmpvar(cfg)
+         acc_assign (v2, `Index{ term, key }, cfg)
+         pattern_element_builder (sub_pattern, v2, cfg)
+         -- TODO: restore ntmp?
+      end
+   end
+   if seen_dots then -- remember how to retrieve `...'
+      -- FIXME: check, but there might be cases where the variable -{term} 
+      -- will be overridden in contrieved tables.
+      -- ==> save it now, and clean the setting statement if unused
+      if cfg.dots_replacement then cfg.dots_replacement = 'ambiguous'
+      else cfg.dots_replacement = +{ select (-{`Number{len}}, unpack(-{term})) } end
+   else -- Check arity
+      acc_test (+{ #-{term} ~= -{`Number{len}} }, cfg)
+   end
+end
+
+-- Jumps to [cfg.on_faliure] if pattern_seq doesn't match
+-- term_seq.
+function pattern_seq_builder (pattern_seq, term_seq, cfg)
+   if #pattern_seq ~= #term_seq then error ("Bad seq arity") end
+   cfg.locals = { } -- reset bound variables between alternatives
+   for i=1, #pattern_seq do
+      cfg.ntmp = 1 -- reset the tmp var generator
+      pattern_element_builder(pattern_seq[i], term_seq[i], cfg)
+   end
+end
+
+--------------------------------------------------
+-- for each case i:
+--   pattern_seq_builder_i:
+--    * on failure, go to on_failure_i
+--    * on success, go to on_success
+--   label on_success:
+--   block
+--   goto after_success
+--   label on_failure_i
+--------------------------------------------------
+function case_builder (case, term_seq, cfg)
+   local patterns_group, guard, block = unpack(case)
+   local on_success = mlp.gensym 'on_success' [1]
+   for i = 1, #patterns_group do
+      local pattern_seq = patterns_group[i]
+      cfg.on_failure = mlp.gensym 'match_fail' [1]
+      cfg.dots_replacement = false
+      pattern_seq_builder (pattern_seq, term_seq, cfg)
+      if i<#patterns_group then
+         acc_stat (`Goto{on_success}, cfg)
+         acc_stat (`Label{cfg.on_failure}, cfg)
+      end
+   end
+   acc_stat (`Label{on_success}, cfg)
+   if guard then acc_test (+{not -{guard}}, cfg) end
+   if cfg.dots_replacement then
+      replace_dots (block, cfg.dots_replacement)
+   end
+   block.tag = 'Do'
+   acc_stat (block, cfg)
+   acc_stat (`Goto{cfg.after_success}, cfg)
+   acc_stat (`Label{cfg.on_failure}, cfg)
+end
+
+function match_builder (x)
+   local term_seq, cases = unpack(x)
+   local cfg = { 
+      code          = `Do{ },
+      after_success = mlp.gensym "_after_success" }
+
+
+   -- Some sharing issues occur when modifying term_seq,
+   -- so it's replaced by a copy new_term_seq.
+   -- TODO: clean that up, and re-suppress the useless copies
+   -- (cf. remarks about capture bug below).
+   local new_term_seq = { }
+
+   local match_locals
+
+   -- Make sure that all tested terms are variables or literals
+   for i=1, #term_seq do
+      local t = term_seq[i]
+      -- Capture problem: the following would compile wrongly:
+      --    `match x with x -> end'
+      -- Temporary workaround: suppress the condition, so that
+      -- all external variables are copied into unique names.
+      --if t.tag ~= 'Id' and not literal_tags[t.tag] then
+         local v = mlp.gensym 'v'
+         if not match_locals then match_locals = `Local{ {v}, {t} } else
+            table.insert(match_locals[1], v)
+            table.insert(match_locals[2], t)
+         end
+         new_term_seq[i] = v
+      --end
+   end
+   term_seq = new_term_seq
+   
+   if match_locals then acc_stat(match_locals, cfg) end
+
+   for i=1, #cases do
+      local case_cfg = { 
+         after_success    = cfg.after_success,
+         code             = `Do{ }
+         -- locals    = { } -- unnecessary, done by pattern_seq_builder
+      }
+      case_builder (cases[i], term_seq, case_cfg)
+      if next (case_cfg.locals) then
+         local case_locals = { }
+         table.insert (case_cfg.code, 1, `Local{ case_locals, { } })
+         for v in keys (case_cfg.locals) do
+            table.insert (case_locals, `Id{ v })
+         end
+      end
+      acc_stat(case_cfg.code, cfg)
+   end
+   acc_stat(+{error 'mismatch'}, cfg)
+   acc_stat(`Label{cfg.after_success}, cfg)
+   return cfg.code
+end
+
+----------------------------------------------------------------------
+-- Syntactical front-end
+----------------------------------------------------------------------
+
+mlp.lexer:add{ "match", "with", "->" }
+mlp.block.terminators:add "|"
+
+match_cases_list_parser = gg.list{ name = "match cases list",
+   gg.sequence{ name = "match case",
+      gg.list{ name  = "match case patterns list",
+         primary     = mlp.expr_list,
+         separators  = "|",
+         terminators = { "->", "if" } },
+      gg.onkeyword{ "if", mlp.expr, consume = true },
+      "->",
+      mlp.block },
+   separators  = "|",
+   terminators = "end" }
+
+mlp.stat:add{ name = "match statement",
+   "match", 
+   mlp.expr_list, 
+   "with", gg.optkeyword "|",
+   match_cases_list_parser,
+   "end",
+   builder = |x| match_builder{ x[1], x[3] } }
+