Module:User:Cscott/mlua

return (function()

local builders = {}

local function register(name, f)

builders[name] = f

end

--[[

This grammar is based on Lua 5.4

As seen in https://www.lua.org/manual/5.4/manual.html#9

]]

local Grammar = [==[

chunk <-- SHEBANG? SKIP Block (!.)^UnexpectedSyntax

Block <== ( Label / Return / Break / Goto / Do / While / Repeat / If / ForNum / ForIn

/ FuncDef / FuncDecl / VarDecl / Assign / call / `;`)*

Label <== `::` @NAME @`::`

Return <== `return` exprlist?

Break <== `break`

Goto <== `goto` @NAME

Do <== `do` Block p2 @`end`

While <== `while` @expr p2 @`do` Block p3 @`end`

Repeat <== `repeat` Block p2 @`until` @expr

If <== `if` @expr p2 @`then` Block (`elseif` @expr @`then` Block)* (`else` Block)? p3 @`end`

ForNum <== `for` Id `=` @expr @`,` @expr ((`,` @expr) / $false) p2 (ForWith / $false) p3 @ForBody

ForIn <== `for` @idlist `in` @exprlist p2 (ForWith / $false) p3 @ForBody

ForWith <== `with` @Id @`,` @Id

ForBody <== `do` Block p2 (`then` Block p3 / $false) (`else` Block p4 / $false) @`end`

FuncDef <== `function` @funcname funcbody

FuncDecl <== `local` `function` @Id funcbody

VarDecl <== `local` @iddecllist (p2 `=` @exprlist)?

Assign <== varlist p2 `=` @exprlist

Number <== NUMBER->tonumber SKIP

String <== STRING SKIP

Boolean <== `false`->tofalse / `true`->totrue

Nil <== `nil`

Varargs <== `...`

Id <== NAME

IdDecl <== NAME (`<` @NAME @`>`)?

Function <== `function` $false funcbody

Table <== `{` (field (fieldsep field)* fieldsep?)? p2 @`}`

Paren <== `(` @expr p2 @`)`

Pair <== `[` @expr @`]` p2 @`=` @expr / NAME p2 `=` @expr

Call <== $false callargs

CallMethod <== `:` @NAME @callargs

DotIndex <== `.` @NAME

ColonIndex <== `:` @NAME

KeyIndex <== `[` @expr p2 @`]`

indexsuffix <-- DotIndex / KeyIndex

callsuffix <-- Call / CallMethod

p2 <-- {:p2:{}:}

p3 <-- {:p3:{}:}

p4 <-- {:p4:{}:}

var <-- (exprprimary (callsuffix+ indexsuffix / indexsuffix)+)~>rfoldright / Id

call <-- (exprprimary (indexsuffix+ callsuffix / callsuffix)+)~>rfoldright

exprsuffixed <-- (exprprimary (indexsuffix / callsuffix)*)~>rfoldright

funcname <-- (Id DotIndex* ColonIndex?)~>rfoldright

funcbody <-- @`(` funcargs p2 @`)` Block p3 @`end`

field <-- Pair / expr

fieldsep <-- `,` / `;`

callargs <-| `(` (expr (`,` @expr)*)? p2 @`)` / Table / String

idlist <-| Id (`,` @Id)*

iddecllist <-| IdDecl (`,` @IdDecl)*

funcargs <-| (Id (`,` Id)* (`,` Varargs)? / Varargs)?

exprlist <-| expr (`,` @expr)*

varlist <-| var (`,` @var)*

opor :BinaryOp <== `or`->'or' @exprand

opand :BinaryOp <== `and`->'and' @exprcmp

opcmp :BinaryOp <== (`==`->'eq' / `~=`->'ne' / `<=`->'le' / `>=`->'ge' / `<`->'lt' / `>`->'gt') @exprbor

opbor :BinaryOp <== `|`->'bor' @exprbxor

opbxor :BinaryOp <== `~`->'bxor' @exprband

opband :BinaryOp <== `&`->'band' @exprbshift

opbshift :BinaryOp <== (`<<`->'shl' / `>>`->'shr') @exprconcat

opconcat :BinaryOp <== `..`->'concat' @exprconcat

oparit :BinaryOp <== (`+`->'add' / `-`->'sub') @exprfact

opfact :BinaryOp <== (`*`->'mul' / `//`->'idiv' / `/`->'div' / `%`->'mod') @exprunary

oppow :BinaryOp <== `^`->'pow' @exprunary

opunary :UnaryOp <== (`not`->'not' / `#`->'len' / `-`->'unm' / `~`->'bnot') @exprunary

expr <-- expror

expror <-- (exprand opor*)~>foldleft

exprand <-- (exprcmp opand*)~>foldleft

exprcmp <-- (exprbor opcmp*)~>foldleft

exprbor <-- (exprbxor opbor*)~>foldleft

exprbxor <-- (exprband opbxor*)~>foldleft

exprband <-- (exprbshift opband*)~>foldleft

exprbshift <-- (exprconcat opbshift*)~>foldleft

exprconcat <-- (exprarit opconcat*)~>foldleft

exprarit <-- (exprfact oparit*)~>foldleft

exprfact <-- (exprunary opfact*)~>foldleft

exprunary <-- opunary / exprpow

exprpow <-- (exprsimple oppow*)~>foldleft

exprsimple <-- Nil / Boolean / Number / String / Varargs / Function / Table / exprsuffixed

exprprimary <-- Id / Paren

STRING <-- STRING_SHRT / STRING_LONG

STRING_LONG <-- {:LONG_OPEN {LONG_CONTENT} @LONG_CLOSE:}

STRING_SHRT <-- {:QUOTE_OPEN {~QUOTE_CONTENT~} @QUOTE_CLOSE:}

QUOTE_OPEN <-- {:qe: ['"] :} / '«' {:qe: -> '»' :} / '‹' {:qe: -> '›' :}

QUOTE_CONTENT <-- (ESCAPE_SEQ / !(QUOTE_CLOSE / LINEBREAK) .)*

QUOTE_CLOSE <-- =qe

ESCAPE_SEQ <-- '\'->'' @ESCAPE

ESCAPE <-- [\'"»] /

('n' $10 / 't' $9 / 'r' $13 / 'a' $7 / 'b' $8 / 'v' $11 / 'f' $12)->tochar /

('x' {HEX_DIGIT^2} $16)->tochar /

('u' '{' {HEX_DIGIT^+1} '}' $16)->toutf8char /

('z' SPACE*)->'' /

(DEC_DIGIT DEC_DIGIT^-1 !DEC_DIGIT / [012] DEC_DIGIT^2)->tochar /

(LINEBREAK $10)->tochar

NUMBER <-- {HEX_NUMBER / DEC_NUMBER}

HEX_NUMBER <-- '0' [xX] @HEX_PREFIX ([pP] @EXP_DIGITS)?

DEC_NUMBER <-- DEC_PREFIX ([eE] @EXP_DIGITS)?

HEX_PREFIX <-- HEX_DIGIT+ ('.' HEX_DIGIT*)? / '.' HEX_DIGIT+

DEC_PREFIX <-- DEC_DIGIT+ ('.' DEC_DIGIT*)? / '.' DEC_DIGIT+

EXP_DIGITS <-- [+-]? DEC_DIGIT+

COMMENT <-- '--' (COMMENT_LONG / COMMENT_SHRT)

COMMENT_LONG <-- (LONG_OPEN LONG_CONTENT @LONG_CLOSE)->0

COMMENT_SHRT <-- (!LINEBREAK .)*

LONG_CONTENT <-- (!LONG_CLOSE .)*

LONG_OPEN <-- '[' {:eq: '='*:} '[' LINEBREAK?

LONG_CLOSE <-- ']' =eq ']'

NAME <-- !KEYWORD {NAME_PREFIX NAME_SUFFIX?} SKIP

-- We should really accept a proper unicode set here for name characters,

-- but for the time being hack in some ISO-8859-1 characters

NAME_PREFIX <-- [_a-zA-ZÀ-ÿ]

NAME_SUFFIX <-- [_a-zA-Z0-9À-ÿ]+

SHEBANG <-- '#!' (!LINEBREAK .)* LINEBREAK?

SKIP <-- (SPACE+ / COMMENT)*

LINEBREAK <-- %cn %cr / %cr %cn / %cn / %cr

SPACE <-- %sp

HEX_DIGIT <-- [0-9a-fA-F]

DEC_DIGIT <-- [0-9]

EXTRA_TOKENS <-- `[[` `[=` `--` -- unused rule, here just to force defining these tokens

]==]

-- List of syntax errors

local SyntaxErrorLabels = {

["Expected_::"] = "unclosed label, did you forget `::`?",

["Expected_)"] = "unclosed parenthesis, did you forget a `)`?",

["Expected_>"] = "unclosed angle bracket, did you forget a `>`?",

["Expected_]"] = "unclosed square bracket, did you forget a `]`?",

["Expected_}"] = "unclosed curly brace, did you forget a `}`?",

["Expected_LONG_CLOSE"] = "unclosed long string or comment, did your forget a ']]'?",

["Expected_QUOTE_CLOSE"]= "unclosed short string or comment, did your forget a quote?",

["Expected_("] = "expected parenthesis token `(`",

["Expected_,"] = "expected comma token `,`",

["Expected_="] = "expected equals token `=`",

["Expected_callargs"] = "expected arguments",

["Expected_expr"] = "expected an expression",

["Expected_exprand"] = "expected an expression after operator",

["Expected_exprcmp"] = "expected an expression after operator",

["Expected_exprbor"] = "expected an expression after operator",

["Expected_exprbxor"] = "expected an expression after operator",

["Expected_exprband"] = "expected an expression after operator",

["Expected_exprbshift"] = "expected an expression after operator",

["Expected_exprconcat"] = "expected an expression after operator",

["Expected_exprfact"] = "expected an expression after operator",

["Expected_exprunary"] = "expected an expression after operator",

["Expected_exprlist"] = "expected expressions",

["Expected_funcname"] = "expected a function name",

["Expected_do"] = "expected `do` keyword to begin a statement block",

["Expected_end"] = "expected `end` keyword to close a statement block",

["Expected_then"] = "expected `then` keyword to begin a statement block",

["Expected_until"] = "expected `until` keyword to close repeat statement",

["Expected_ESCAPE"] = "malformed escape sequence",

["Expected_EXP_DIGITS"] = "malformed exponential number",

["Expected_HEX_PREFIX"] = "malformed hexadecimal number",

["Expected_Id"] = "expected an identifier name",

["Expected_NAME"] = "expected an identifier name",

["Expected_IdDecl"] = "expected an identifier name declaration",

["Expected_iddecllist"] = "expected identifiers names declaration",

["Expected_idlist"] = "expected identifiers names",

["Expected_var"] = "expected a variable",

["Expected_ForBody"] = "expected `with`, `do` or `if` keyword to begin a for-loop body",

["UnexpectedSyntax"] = "unexpected syntax",

}

-- Compile grammar

local lpegrex = myrequire('llpeg.lpegrex')

local function make_parse(defs)

local patt = lpegrex.compile(Grammar, defs)

-- Parse Lua source into an AST.

local function parse(source, name)

local ast, errlabel, errpos = patt:match(source)

if not ast then

name = name or ''

local lineno, colno, line = lpegrex.calcline(source, errpos)

local colhelp = string.rep(' ', colno-1)..'^'

local errmsg = SyntaxErrorLabels[errlabel] or errlabel

error('syntax error: '..name..':'..lineno..':'..colno..': '..errmsg..

'\n'..line..'\n'..colhelp)

end

return ast

end

return parse

end

return {

make_parse = make_parse,

--parse = make_parse(),

}

end)

-- Parent class for expression nodes

local Expr = {}

Expr.__index = Expr

-- Parent class for literal expression nodes

local LiteralExpr = {}

LiteralExpr.__index = LiteralExpr

-- Parent class for statement nodes

local Stmt = {}

Stmt.__index = Stmt

-- Parent class for nodes which encode syntax (not an expression or statement)

local Syntax = {}

Syntax.__index = Syntax

-- Define node types and map to their parent class

local Node = {

Block = Stmt,

Label = Stmt,

Return = Stmt,

Break = Stmt,

Goto = Stmt,

Do = Stmt,

While = Stmt,

Repeat = Stmt,

If = Stmt,

ForNum = Stmt,

ForIn = Stmt,

ForWith = Syntax,

ForBody = Syntax,

FuncDef = Stmt,

FuncDecl = Stmt,

Function = Expr,

VarDecl = Stmt,

Assign = Stmt,

Number = LiteralExpr,

String = LiteralExpr,

Boolean = LiteralExpr,

Nil = LiteralExpr,

Varargs = Expr,

Id = Expr,

IdDecl = Syntax,

Table = Expr,

Paren = Expr,

Pair = Syntax,

Call = Expr,

CallMethod = Expr,

DotIndex = Expr,

ColonIndex = Syntax,

KeyIndex = Expr,

BinaryOp = Expr,

UnaryOp = Expr,

}

Node.__index = Node

setmetatable(Syntax, Node)

setmetatable(Stmt, Node)

setmetatable(Expr, Node)

setmetatable(LiteralExpr, Expr)

for tag, parent in pairs(Node) do

local val = {}

val.__index = val

setmetatable(val, parent)

val.__tostring = function(self)

local result = { tag, '{ ' }

for i,v in ipairs(self) do

if type(v) ~= 'table' or v.tag ~= nil then

table.insert(result, tostring(v))

else

table.insert(result, '{ ')

for j,vv in ipairs(v) do

table.insert(result, tostring(vv))

if v[j+1] ~= nil then

table.insert(result, ", ")

end

table.insert(result, ' }')

end

if self[i+1] ~= nil then

table.insert(result, ", ")

end

table.insert(result, ' }')

return table.concat(result)

end

Node[tag] = val

end

Node.__index = Node

Node.LiteralExpr = LiteralExpr

Node.Expr = Expr

Node.Syntax = Syntax

Node.Stmt = Stmt

local function make_node(tag, node)

setmetatable(node, Node[tag])

node.tag = tag

return node

end

return {

Node = Node,

make_node = make_node,

}

end)

-- Human-friendly names for functions, for easier debugging/tracing.

local M = {}

local function_name_registry = {}

function M.register_fname(name, f)

assert(type(name) == "string")

assert(type(f) == "function")

function_name_registry[f] = name

end

local function report_ferror(f, msg)

local fname = function_name_registry[f]

if fname ~= nil then

msg = fname .. ": " .. msg

end

error(msg)

end

-- helper for visitor pattern definitions

function M.define(dispatch, which, f)

for _,v in pairs(which) do

assert(v ~= nil) -- catch typos

dispatch[v] = f

end

function M.define_ast(obj, funcname, tbl)

for keys,func in pairs(tbl) do

if type(keys) ~= "table" then

keys = { keys }

end

for _,v in pairs(keys) do

obj[v][funcname] = func

end

function M.define_ast_visitor(tbl)

local dispatch = {}

for keys,func in pairs(tbl) do

if type(keys) ~= "table" then

keys = { keys }

end

M.define(dispatch, keys, func)

end

local visit

visit = function(node, ...)

if node == nil then report_ferror(visit, "nil node") end

local a = dispatch["assert"]

if a ~= nil then a(node, ...) end -- assert preconditions

local f = dispatch[node.tag]

if f ~= nil then return f(node, ...) end

f = dispatch.default

if f == nil then

report_ferror(visit, "no default for " .. node.tag)

end

return f(node, ...)

end

return visit

end

return M

end)

local L = myrequire('mlua.node').Node

local make_node = myrequire('mlua.node').make_node

local compat = myrequire('advent.compat')

local define = myrequire('mlua.define').define

local hasBit32, bit32 = pcall(require, 'bit32')

if not hasBit32 then bit32 = {} end

-- debugging options --

-- when true, show char position of each statement executed

local TRACE=false

-- set false when testing to ensure general case of multires args handled

-- properly; the optimizations might otherwise cause the general case not

-- to be reached during testing.

local MULTIRES_OPT=true

local function ripairs(val)

local i = 1

while val[i] ~= nil do

i = i + 1

end

local f = function(_, i)

i = i - 1

if i == 0 then return nil end

return i, val[i]

end

return f, nil, i

end

local function makePushEnv(cont)

return function(env) return cont({ parent=env }) end

end

local function makePopEnv(cont)

return function(env) return cont(env.parent) end

end

local State = {}

State.__index = State

function State:new(parent)

local s = setmetatable({ labels={}, locals={}, oldLocals={}, localCount = 0, parent = parent }, self)

if parent == nil then

s.depth = 0

else

s.depth = 1 + parent.depth

end

if parent == nil then

s:defineLocal("_ENV") -- first top-level local is always for _ENV

elseif parent.breakCont ~= nil then

s.breakCont = makePopEnv(parent.breakCont)

end

return s

end

function State:newBlockState()

return State:new(self)

end

function State:pushLabel(name, cont)

self.labels[name] = cont

end

function State:lookupLabel(name)

local f = nil -- cache

local labels = self.labels

return function(env)

if f == nil then

-- deferred lookup of label, since it isn't yet defined when the

-- goto is compiled. But cache the result to reuse it next time.

f = labels[name]

labels = nil -- free up some memory

end

return f(env)

end

function State:setBreak(cont)

local old = self.breakCont

self.breakCont = cont

end

function State:lookupLocal(name)

local i = 0

local s = self

while s ~= nil do

local id = s.locals[name]

if id ~= nil then return i, id end

i = i + 1

s = s.parent

end

return nil, nil -- not found

end

function State:defineInvisibleLocal(undef)

if undef == nil then

self.localCount = self.localCount + 1

else

self.localCount = self.localCount - 1

end

return self.localCount

end

function State:defineLocal(name, undef)

if undef == nil then

self.localCount = self.localCount + 1

self.oldLocals[self.localCount] = self.locals[name] -- usually nil

self.locals[name] = self.localCount

else

assert(self.locals[name] == self.localCount)

self.locals[name] = self.oldLocals[self.localCount] -- usually nil

self.localCount = self.localCount - 1

end

return self.localCount

end

local Env = {}

Env.__index = Env

function Env:new()

return setmetatable({}, self)

end

function L:defineLocals()

error("missing defineLocals case for "..self.tag)

end

function L.Stmt:defineLocals()

-- we don't recurse into inner blocks; hence do nothing by default

end

function L.Expr:defineLocals()

-- expressions don't have declarations

end

function L.ForWith:defineLocals(state, undef)

if undef == nil then

for _,v in ipairs(self) do v:defineLocals(state, undef) end

return state.locals[self[1][1]], state.locals[self[2][1]]

else

for _,v in ripairs(self) do v:defineLocals(state, undef) end

end

function L.FuncDecl:defineLocals(state, undef)

self[1]:defineLocals(state, undef)

end

function L.VarDecl:defineLocals(state, undef)

if undef == nil then

for _,v in ipairs(self[1]) do v:defineLocals(state, undef) end

else

for _,v in ripairs(self[1]) do v:defineLocals(state, undef) end

end

function L.Id:defineLocals(state, undef)

state:defineLocal(self[1], undef)

end

function L.IdDecl:defineLocals(state, undef)

local name,attrib = self[1], self[2]

-- if attrib ~= nil then error("attributes unimplemented") end

state:defineLocal(name, undef)

end

function L:compile(state, cont)

error("Missing compiler for "..self.tag)

end

function L:compileExpr(state)

error("Missing expression compiler for "..self.tag)

end

function L:compileLhs(state)

error("Missing left-hand-side compiler for "..self.tag)

end

local withNewBlock = function(f)

return function(self, state, cont)

state = state:newBlockState()

return makePushEnv(f(self, state, makePopEnv(cont)))

end

function L.Block:compileInSameBlock(state, cont)

-- define all the locals in a forward pass

for _,node in ipairs(self) do

node:defineLocals(state)

end

-- XXX create continuation that clears/closes all these locals

-- create continuations in a backward pass

for _,node in ripairs(self) do

cont = node:compile(state, cont)

node:defineLocals(state, 'undef')

if TRACE then

local pos = node.pos

local cont2 = cont

cont = function(env)

if _G.mw and _G.mw.log then

_G.mw.log("Pos "..pos)

else

print("Pos", pos)

end

return cont2(env)

end

return cont

end

L.Block.compile = withNewBlock(L.Block.compileInSameBlock)

function L.Label:compile(state, cont)

state.pushLabel(self[1], cont)

return cont

end

function L.Return:compile(state, cont)

if self[1] == nil or #self[1] == 0 then

return function() return end -- ignore continuation, finally return

end

local t = {}

for _,v in ipairs(self[1]) do

table.insert(t, v:compileExpr(state))

end

-- special case for tail call

if #t == 1 then

-- tail call to expression evaluator, which ought to be a tail call to

-- the function being called; see Call:compileExpr()

return t[1]

elseif #t == 2 and MULTIRES_OPT then

-- fast path, uses lua itself to handle multires case of t2

local t1, t2 = t[1], t[2]

return function(env) return t1(env), t2(env) end

end

return function(env)

local r,n = {}, #t

for i=1,n-1 do

r[i] = t[i](env) -- evaluate each expression in order

end

-- handle multires expressions (n==0 case already handled above)

local last = compat.pack(t[n](env))

n = n - 1 -- we haven't stored the last item yet

for i=1,last.n do

n = n + 1

r[n] = last[i]

end

-- we use n instead of #r in case some of the values are null

return compat.unpack(r, 1, n) -- ignore continuation, return

end

function L.Break:compile(state, cont)

-- ignore continuation, execute from 'breakCont'

return state.breakCont

end

function L.Goto:compile(state, cont)

return state.lookupLabel(self[1]) -- use a different continuation

end

function L.Do:compile(state, cont)

return self[1]:compile(state, cont)

end

function L.While:compile(state, cont)

local expr = self[1]:compileExpr(state)

local body

local loop = function(env)

if expr(env) then return body(env) end

return cont(env)

end

local oldBreak = state:setBreak(cont)

body = self[2]:compile(state, loop)

state:setBreak(oldBreak)

return loop

end

function L.Repeat:compile(state, cont)

-- the test is executed in the same new block as the body

local condAst = make_node('If', { self[2], make_node("Break", {}) })

local oldBody = self[1]

assert(oldBody.tag == 'Block')

local newBody = make_node('Block', { pos=oldBody.pos, endpos=oldBody.endpos })

for i,v in ipairs(oldBody) do

newBody[i] = v

end

newBody[#newBody+1] = condAst

local body

local loop = function(env) return body(env) end

local oldBreak = state:setBreak(cont)

body = newBody:compile(state, loop)

state:setBreak(oldBreak)

return body

end

function L.If:compile(state, cont)

-- 1,2 = if/then

-- 1,2,3 = if/then/else

-- 1,2,3,4 = if/then/elseif/then

-- 1,2,3,4,5 = if/then/elseif/then/else

local n = 1

while self[n] ~= nil do

n = n + 2

end

local ifRest = cont

for i=n-2,1,-2 do

if self[i+1] == nil then -- final else clause

ifRest = self[i]:compile(state, cont)

else

local test = self[i]:compileExpr(state)

local thenStmt = self[i+1]:compile(state, cont)

local rest = ifRest;

ifRest = function(env)

if test(env) then return thenStmt(env) else return rest(env) end

end

return ifRest

end

-- If only 'then' is present, it executes after any normal completion

-- Otherwise, if 'else' is present, then 'then' only executes after

-- one (or more) successful iterations of the loop body

function makeFinalize(thenAst, elseAst, state, cont, first, idlist, idlistShadow)

if thenAst == false and elseAst == false then

return cont

end

local thenAssign = make_node("VarDecl", { idlist, idlistShadow })

local elseAssign = make_node("VarDecl", { idlist }) -- will nil out

-- only declare the idlist variables in a then block (including a

-- combined then/else block)

local thenFunc, elseFunc

if thenAst ~= false then

local thenState = state:newBlockState()

thenAssign:defineLocals(thenState)

local thenFuncCont = thenAst:compileInSameBlock(thenState, makePopEnv(cont))

thenFunc = thenAssign:compile(thenState, thenFuncCont)

-- this else func will be overwritten if actual else clause present

elseFunc = elseAssign:compile(thenState, thenFuncCont)

end

if elseAst ~= false then

local elseState = state:newBlockState()

elseFunc = elseAst:compileInSameBlock(elseState, makePopEnv(cont))

end

return function(env)

local nenv = { parent=env }

if env[first] == true then

return elseFunc(nenv)

elseif thenFunc ~= nil then

return thenFunc(nenv)

else

return cont(env)

end

function L.ForNum:compile(state, cont)

local name,start,stop,optStep,optWith,forBody = self[1],self[2],self[3],self[4],self[5],self[6]

local bodyAst, thenAst, elseAst = forBody[1], forBody[2], forBody[3]

local var, varExpr = state:defineInvisibleLocal(), start:compileExpr(state)

local limit, limitExpr = state:defineInvisibleLocal(), stop:compileExpr(state)

local step, stepExpr = state:defineInvisibleLocal(), function() return 1 end

local first = state:defineInvisibleLocal()

local last = state:defineInvisibleLocal()

local lastVarAst = make_node("Id", { "0var" }) -- see ForIn below

local lastVar = state:defineLocal("0var")

if optStep ~= false then

stepExpr = optStep:compileExpr(state)

end

local nstate = state:newBlockState()

local id = nstate:defineLocal(name[1])

local firstId, lastId

if optWith ~= false then

firstId, lastId = optWith:defineLocals(nstate)

end

local finalize = makeFinalize(thenAst, elseAst, state, cont, first,

{ name }, { lastVarAst })

local body

local loop = function(env)

if (env[step] > 0 and env[var] <= env[limit]) or (env[step] <= 0 and env[var] >= env[limit]) then

local nenv = { parent=env }

nenv[id] = env[var]

if env[step] > 0 then

env[last] = env[var] + env[step] > env[limit]

else

env[last] = env[var] + env[step] < env[limit]

end

if firstId ~= nil then nenv[firstId] = env[first] end

if lastId ~= nil then nenv[lastId] = env[last] end

return body(nenv)

end

return finalize(env)

end

local init = function(env)

env[var] = tonumber(varExpr(env))

env[limit] = tonumber(limitExpr(env))

env[step] = tonumber(stepExpr(env))

env[first] = true

if not (env[var] and env[limit] and env[step]) then error() end

return loop(env)

end

local incr = function(env)

env[lastVar] = env[var]

env[var] = env[var] + env[step]

env[first] = false

return loop(env)

end

local oldBreak = nstate:setBreak(makePopEnv(cont))

body = bodyAst:compileInSameBlock(nstate, makePopEnv(incr))

nstate:setBreak(oldBreak)

-- okay, now pop all those local vars off

if optWith ~= false then

optWith:defineLocals(nstate, "undef")

end

nstate:defineLocal(name[1], "undef")

state:defineLocal("0var", "undef") -- lastVar

state:defineInvisibleLocal("undef") -- last

state:defineInvisibleLocal("undef") -- first

state:defineInvisibleLocal("undef") -- step

state:defineInvisibleLocal("undef") -- limit

state:defineInvisibleLocal("undef") -- var

return init

end

--[[

To guide understanding of this method, here is the equivalent code for

for-in loop execution:

** WITHOUT A WITH CLAUSE **

-- init

local f', s', var_1', cl' = explist -- initAst / initFunc

first' = true

-- goto loop

while true do

-- loop:

local var_1, ···, var_n = f'(s', var_1') -- loopStart

if var_1 == nil then break end

var_1', ..., var_n' = var_1, ..., var_n -- save for then clause

block

-- goto loop

end

** WITH A WITH CLAUSE (maintaining 'last') **

-- init

local f', s', var_1', cl' = explist -- initAst / initFunc

local var_1', ···, var_n' = f'(s', var_1')

local first' = true

local last' = (var_1' == nil)

-- goto loop

-- loop:

while not last' do

first = first'

first' = false

var_1, ..., var_n = var_1', ..., var_n'

var_1', ···, var_n' = f'(s', var_1')

last' = (var_1' == nil)

last = last'

if last' then

var_1', ···, var_n' = var_1, ..., var_n -- save for 'then' clause

end

block

-- goto loop

end

]]--

function L.ForIn:compile(state, cont)

local nstate = state:newBlockState() -- inner block

local idlist,exprlist,optWith,forBody = self[1],self[2],self[3],self[4]

local bodyAst, thenAst, elseAst = forBody[1], forBody[2], forBody[3]

-- this is a "shadow" copy of the idlist, used for 'last' and then clauses

local idlist2 = {}

for i,_ in ipairs(idlist) do

local node = make_node("Id", { "0" .. i })

table.insert(idlist2, node)

end

-- use names starting with a number to ensure they don't conflict w/

-- any user locals (this is an alternative to :defineInvisibleLocal()

local fAst = make_node("Id", { "0f" })

local sAst = make_node("Id", { "0s" })

local varAst = idlist2[1]

local clAst = make_node("Id", { "0cl" })

-- this is used to save iteration variables to their shadows for the then block

local assignBackAst = make_node("Assign", { idlist2, idlist })

local loopidlist = idlist

local assignAst

if optWith ~= false then

assignAst = make_node("Assign", { idlist, idlist2 })

loopidlist = idlist2

end

local declareAst = make_node("VarDecl", {

-- declare all of our shadow variables

compat.move(idlist2, 1, #idlist2, 4, { fAst, sAst, clAst})

})

local innerDeclareAst = make_node("VarDecl", { idlist } )

local initAst = make_node("Assign", { { fAst, sAst, varAst, clAst }, exprlist })

local loopStart = make_node("Assign", { loopidlist, { make_node("Call", { false, { sAst, varAst }, fAst }) } })

-- outer block:

declareAst:defineLocals(state)

local _,varId = state:lookupLocal(idlist2[1][1])

local _, clId = state:lookupLocal("0cl")

-- inner block:

innerDeclareAst:defineLocals(nstate)

local _,var1Id = nstate:lookupLocal(idlist[1][1])

-- optional 'with'

local first, last, firstId, lastId

first = state:defineLocal("0first")

if optWith ~= false then

last = state:defineLocal("0last")

firstId, lastId = optWith:defineLocals(nstate)

end

local finalize = makeFinalize(thenAst, elseAst, state, cont, first, idlist, idlist2)

-- loop starts in outer block and enters inner block

-- body is executed in inner block

-- finalize is executed in outer block, so must pop first when breaking from inner

local body, loop, init, saveAndExecBody

if optWith == false then

loop = makePushEnv(loopStart:compile(nstate, function(env)

if env[var1Id] == nil then return finalize(env.parent) end -- break

env.parent[first] = false

return saveAndExecBody(env)

end))

else

local loopMid

loop = makePushEnv(function(env)

if env.parent[last] then return finalize(env.parent) end -- break

env[firstId] = env.parent[first]

env.parent[first] = false

return loopMid(env)

end)

loopMid = assignAst:compile(nstate, loopStart:compile(nstate, function(env)

env.parent[last] = (env.parent[varId] == nil)

env[lastId] = env.parent[last]

if env[lastId] then

return saveAndExecBody(env)

else

return body(env)

end

end))

end

saveAndExecBody = assignBackAst:compile(nstate, function(env)

return body(env)

end)

-- init is executed in the outer block

local function checkClosure(cont)

return function(env)

if env[clId] ~= nil then

error("Closures not yet supported")

end

env[first] = true

return cont(env)

end

local init

if optWith == false then

init = initAst:compile(

state, checkClosure(loop)

)

else

init = initAst:compile(

state, checkClosure(loopStart:compile(state, function(env)

env[last] = (env[varId] == nil)

return loop(env)

end)))

end

local oldBreak = nstate:setBreak(makePopEnv(cont))

body = bodyAst:compileInSameBlock(nstate, makePopEnv(loop))

nstate:setBreak(oldBreak)

-- okay, now pop all those local vars off

if optWith ~= false then

state:defineLocal("0last", "undef")

optWith:defineLocals(nstate, "undef")

end

state:defineLocal("0first", "undef")

innerDeclareAst:defineLocals(nstate, "undef")

declareAst:defineLocals(state, "undef")

return init

end

function L.FuncDecl:compile(state, cont)

local level, id = state:lookupLocal(self[1][1])

local func = L.Function.compileExpr(self, state)

assert(level == 0)

return function(env)

env[id] = func(env)

return cont(env)

end

function L.FuncDef:compile(state, cont)

local name, args, body = self[1], self[2], self[3]

local lhs, func

local addSelf = false

if name.tag ~= "ColonIndex" then

lhs = name:compileLhs(state)

func = L.Function.compileExpr(self, state)

else

-- compile it as a dot index

lhs = L.DotIndex.compileLhs(name, state)

-- but add an implicit 'self' argument

local nargs = { make_node("Id", { "self" } ) }

for i,v in ipairs(args) do

nargs[i+1] = v

end

func = make_node("Function", { false, nargs, body }):compileExpr(state)

end

return function(env)

lhs(env, func(env))

return cont(env)

end

function L.VarDecl:compile(state, cont)

local iddecllist, exprlist = self[1], (self[2] or {})

local lhs = {}

for i,v in ipairs(iddecllist) do

local name,attrib = v[1],v[2]

local level, id = state:lookupLocal(name)

assert(level == 0)

table.insert(lhs, id)

end

local rhs = {}

for i,v in ipairs(exprlist) do

table.insert(rhs, v:compileExpr(state))

end

local n = #exprlist

if #lhs == 1 and #rhs == 1 then -- fast path

local l,r = lhs[1], rhs[1]

return function(env)

env[l] = r(env)

return cont(env)

end

return function(env)

-- evaluate all expressions on the right hand side

local r = {}

for i=1,#rhs-1 do

r[i] = rhs[i](env)

end

-- "if the list of expressions ends with a function call, then all

-- values returned by that call enter the list of values" thus:

-- unpack last argument into remaining values

if #rhs > 0 then

local last = compat.pack(rhs[#rhs](env))

for i=1,last.n do

r[#rhs+i-1] = last[i]

end

-- perform all assignments

for i=1,#lhs do

env[lhs[i]] = r[i]

end

return cont(env)

end

function L.Assign:compile(state, cont)

local varlist, exprlist = self[1], self[2]

local rhs = {}

for _,e in ipairs(exprlist) do

table.insert(rhs, e:compileExpr(state))

end

local lhs = {}

for _,v in ipairs(varlist) do

table.insert(lhs, v:compileLhs(state))

end

if #rhs == 1 and #lhs == 1 then -- fast path

local l,r = lhs[1], rhs[1]

return function(env)

l(env, r(env))

return cont(env)

end

return function(env)

-- evaluate all expressions on the right hand side

local r = {}

for i=1,#rhs-1 do

r[i] = rhs[i](env)

end

-- "if the list of expressions ends with a function call, then all

-- values returned by that call enter the list of values" thus:

-- unpack last argument into remaining values

if #rhs > 0 then

local last = compat.pack(rhs[#rhs](env))

for i=1,last.n do

r[#rhs+i-1] = last[i]

end

-- perform all assignments

for i=1,#lhs do

lhs[i](env, r[i])

end

return cont(env)

end

function L.Function:compileExpr(state)

local args, body = self[2], self[3]

local nargs = #args

-- create a new state for this function

local ns = state:newBlockState()

-- define new local variables corresponding to the function arguments

local seenVarargs = false

for _,v in ipairs(args) do

if v.tag == 'Id' and not seenVarargs then

ns:defineLocal(v[1])

elseif v.tag == 'Varargs' and not seenVarargs then

seenVarargs = true

ns:defineLocal("0varargs") -- hidden local

nargs = nargs - 1

else

error("unknown argument type")

end

-- compile body in this new state

local f = body:compileInSameBlock(ns, function() return end)

-- return a value!

return function(env)

return function(...)

-- create a new environment with arguments appropriately set

local nenv = { parent = env }

for i=1,nargs do

nenv[i] = select(i, ...)

end

if seenVarargs then

nenv[nargs+1] = compat.pack(select(nargs+1, ...))

end

return f(nenv)

end

function L.Expr:compile(state, cont)

-- evaluate expression for side effects, throw value away, invoke continuation

local f = self:compileExpr(state)

return function(env)

f(env) -- throw result away

return cont(env) -- continue with next statement

end

function L.LiteralExpr:compileExpr(state)

local n = self[1]

return function() return n end

end

function L.Nil:compileExpr(state)

return function() return nil end

end

function L.Varargs:compileExpr(state)

local getter = make_node("Id", { "0varargs" }):compileExpr(state)

return function(env)

local varargs = getter(env)

return compat.unpack(varargs, 1, varargs.n)

end

function L.Id:compileLhs(state)

local level, id = state:lookupLocal(self[1])

if id ~= nil then

if level == 0 then

-- bound local variable in this environment

return function(env, val) env[id] = val end

else

return function(env,val)

local p = env

for i=1,level do p = p.parent end

p[id] = val

end

-- free name

local level,_env = state:lookupLocal('_ENV')

id = self[1]

return function(env, val)

local p = env

for i=1,level do p = p.parent end

p[_env][id] = val

end

function L.Id:compileExpr(state)

local level, id = state:lookupLocal(self[1])

if id ~= nil then

if level == 0 then

-- bound local variable in this environment

return function(env) return env[id] end

else

return function(env)

local p = env

for i=1,level do p = p.parent end

return p[id]

end

-- free name

local level,_env = state:lookupLocal('_ENV')

id = self[1]

return function(env)

local p = env

for i=1,level do p = p.parent end

return p[_env][id]

end

function L.Table:compileExpr(state)

local i = 1

local keys = {}

for j,v in ipairs(self) do

keys[j] = i

if v.tag ~= 'Pair' then

i = i + 1

end

if #self == 0 then

-- fast path, empty table

return function() return {} end

elseif #self == 1 and self[1].tag ~= 'Pair' and MULTIRES_OPT then

-- fast path, let lua handle multires internally

local f = self[1]:compileExpr(state)

return function(env) return { f(env) } end

end

local initialize = function(env, t) return t end

local last = true

for j,v in ripairs(self) do

initialize = v:compileTableInit(state, initialize, keys[j], last)

last = false

end

return function(env)

return initialize(env, {})

end

function L.Pair:compileTableInit(state, initialize)

local left, right = self[1], self[2]:compileExpr(state)

if type(left) == 'string' then

return function(env, t)

t[left] = right(env)

return initialize(env, t)

end

left = left:compileExpr(state)

return function(env, t)

t[left(env)] = right(env)

return initialize(env, t)

end

function L.Expr:compileTableInit(state, initialize, idx, last)

local f = self:compileExpr(state)

if not last then

return function(env, t)

t[idx] = f(env)

return initialize(env, t)

end

-- multires expression as final table initializer

return function(env, t)

local r = compat.pack(f(env))

for i=1,r.n do

t[idx+i-1] = r[i]

end

return initialize(env, t)

end

function L.Paren:compileExpr(state)

-- this is not entirely a no-op, it down-selects multires expressions to

-- a single result.

local f = self[1]:compileExpr(state)

return function(env)

return (f(env)) -- select just a single value

end

function L.Call:compileExpr(state)

local _,args,name = self[1],self[2],self[3]

local f = name:compileExpr(state)

local t = {}

for _,v in ipairs(args) do

table.insert(t, v:compileExpr(state))

end

-- fast cases for small # of args; this lets lua handle the multires

-- argument handling internally

if #args == 0 then

return function(env) return f(env)() end

elseif #args == 1 and MULTIRES_OPT then

local t1 = t[1]

return function(env) return f(env)(t1(env)) end

elseif #args == 2 and MULTIRES_OPT then

local t1,t2 = t[1],t[2]

return function(env) return f(env)(t1(env),t2(env)) end

elseif #args == 3 and MULTIRES_OPT then

local t1,t2,t3 = t[1],t[2],t[3]

return function(env) return f(env)(t1(env),t2(env),t3(env)) end

end

-- ok, the slightly-slower case for an arbitrary # of arguments

return function(env)

local func = f(env)

local args = {}

local n = #t

for i=1,n-1 do

args[i] = t[i](env) -- evaluate each argument expression in order

end

-- handle multires expressions; the n==0 case was already handled above

local last = compat.pack(t[n](env))

n = n - 1 -- we haven't stored the last item yet

for i=1,last.n do

n = n + 1

args[n] = last[i]

end

-- we use n instead of #r in case some of the values are null

return func(compat.unpack(args, 1, n))

end

function L.CallMethod:compileExpr(state)

local method,args,recv = self[1],self[2],self[3]

local f = recv:compileExpr(state)

local t = {}

for _,v in ipairs(args) do

table.insert(t, v:compileExpr(state))

end

if #args == 0 then

-- fast path for no arguments (except implicit receiver)

return function(env)

local recv = f(env)

return recv[method](recv)

end

elseif #args == 1 and MULTIRES_OPT then

-- fast path: let lua handle multires case

local t1 = t[1]

return function(env)

local recv = f(env)

return recv[method](recv, t1(env))

end

-- slightly slower case to handle arbitrary # arguments

return function(env)

local recv = f(env)

local func = recv[method]

local args = { recv }

local n = #t

for i=1,n-1 do

args[i + 1] = t[i](env) -- evaluate each argument expression in order

end

-- handle multires expressions (n==0 case already handled above)

local last = compat.pack(t[n](env))

n = n - 1 -- we haven't stored the last item yet

for i=1,last.n do

n = n + 1

args[n + 1] = last[i]

end

-- we use n instead of #r in case some of the values are null

return func(compat.unpack(args, 1, 1+n))

end

function L.DotIndex:compileLhs(state)

local left,right = self[2],self[1]

left = left:compileExpr(state)

return function(env, val)

left(env)[right] = val

end

function L.DotIndex:compileExpr(state)

local left,right = self[2],self[1]

left = left:compileExpr(state)

return function(env)

return left(env)[right]

end

function L.KeyIndex:compileLhs(state)

local left,right = self[2],self[1]

left, right = left:compileExpr(state), right:compileExpr(state)

return function(env, val)

left(env)[right(env)] = val

end

function L.KeyIndex:compileExpr(state)

local left,right = self[2],self[1]

left, right = left:compileExpr(state), right:compileExpr(state)

return function(env)

return left(env)[right(env)]

end

local function trymt(name,f)

return function(l,r)

-- if both arguments are numbers, don't use a metamethod

if type(l)=='number' and type(r)=='number' then return f(l,r) end

local op = nil

local mt = getmetatable(l)

if mt ~= nil then op = mt[name] end

if op == nil then

mt = getmetatable(r)

if mt ~= nil then op = mt[name] end

end

if op ~= nil then

local result = op(l,r) -- adjusted to one value

return result

end

return f(l,r)

end

local optable = {

['or'] = function(l,r) return l or r end, -- no metamethod

['and'] = function(l,r) return l and r end, -- no metamethod

eq = function(l,r) return l == r end,

ne = function(l,r) return l ~= r end,

le = function(l,r) return l <= r end,

ge = function(l,r) return l >= r end,

lt = function(l,r) return l < r end,

gt = function(l,r) return l > r end,

bor = trymt('__bor', bit32.bor),

bxor = trymt('__bxor', bit32.bxor),

band = trymt('__band', bit32.band),

shl = trymt('__shl', bit32.lshift),

shr = trymt('__shr', bit32.rshift),

concat = function(l,r) return l .. r end,

add = function(l,r) return l + r end,

sub = function(l,r) return l - r end,

mul = function(l,r) return l * r end,

idiv = trymt('__idiv', function(l,r) return math.floor(l / r) end),

div = function(l,r) return l / r end,

mod = function(l,r) return l % r end,

pow = function(l,r) return l ^ r end,

['not'] = function(r) return not r end,

len = function(r)

-- support for lua 5.4 __len metamethod on tables

-- (lua 5.1 always used primitive length on tables)

if type(r) == 'table' then

local mt = getmetatable(r)

if mt ~= nil then

local len = mt.__len

if len ~= nil then

local l = len(r) -- adjust to one value

return l

end

return #r

end,

unm = function(r) return -r end,

bnot = trymt('__bnot', bit32.bnot),

}

-- This could be optimized: for example we could specialize for constants,

-- We could fold in the function call that evaluates l and r, etc.

function L.BinaryOp:compileExpr(state)

local left,op,right = self[1],self[2],self[3]

left, right = left:compileExpr(state), right:compileExpr(state)

if op == 'or' then

-- short cut evaluation

return function(env)

return left(env) or right(env)

end

elseif op == 'and' then

-- short cut evaluation

return function(env)

return left(env) and right(env)

end

else

op = optable[op]

return function(env)

return op(left(env), right(env))

end

function L.UnaryOp:compileExpr(state)

local op,right = self[1],self[2]

op, right = optable[op], right:compileExpr(state)

return function(env)

return op(right(env))

end

local function compile(ast)

local state = State:new()

return ast:compile(state, function() return end)

end

local function eval(ast)

-- xxx create an appropriate environment

local GLOBALS = {

['assert']=assert, -- XXX might want to customize to give debugging info

['error']=error, -- XXX might want to customize to give debugging info

['getmetatable']=getmetatable,

['ipairs']=ipairs,

['math']=math,

['next']=next,

['pairs']=pairs,

['pcall']=pcall,

['rawequal']=rawequal,

['rawget']=rawget,

['rawset']=rawset,

['require']=require, -- could add support for sideloading l18n?

['select']=select,

['setmetatable']=setmetatable,

['string']=string, -- might want some compatibility thunks here

['table']={

concat = function(list, sep, i, j)

if sep == nil then sep = "" end

if i == nil then i = 1 end

if j == nil then j = compat.len(list) end

return table.concat(list, sep, i, j)

end,

insert = function(list, pos, val)

if val == nil then val = pos ; pos = nil end

if pos == nil then pos = compat.len(list) + 1 end

return table.insert(list, pos, val)

end,

maxn = function() error("not in Lua 5.4") end,

move = compat.move, -- not in Lua 5.1

pack = compat.pack, -- not in Lua 5.1

remove = function(l,p)

if p == nil then p = compat.len(l) end

return table.remove(l, p)

end,

sort = table.sort, -- might have issues with table length in Lua 5.1

unpack = compat.unpack, -- not in Lua 5.1

['tonumber']=tonumber,

['tostring']=tostring,

['type']=type,

-- add utf8?

['_VERSION']="Lua 5.4", -- that's what we support!

-- add warn? (not present in Lua 5.3, etc)

['xpcall']=xpcall,

}

GLOBALS._G = GLOBALS

-- Lua 5.1 support

if rawget(_G, "rawlen") then GLOBALS.rawlen = _G.rawlen end

-- Scribunto support

if rawget(_G, "mw") ~= nil then GLOBALS.mw = _G.mw end

-- CLI support

if rawget(_G, 'print') then GLOBALS.print = _G.print end

if rawget(_G, 'io') then GLOBALS.io = _G.io end

local env = { GLOBALS }

local f = compile(ast)

return f(env)

end

return {

compile = compile,

eval = eval,

}

end)

local lua = myrequire('mlua.lua')

local node = myrequire('mlua.node')

-- Translation table

local french = {

['and'] = 'et',

['break'] = 'arrêter',

['do'] = 'faire',

['else'] = 'sinon',

['elseif'] = 'sinonsi',

['end'] = 'fin',

['false'] = 'faux',

['for'] = 'pour',

['function'] = 'fonction',

['goto'] = 'allerà',

['if'] = 'si',

['in'] = 'de',

['local'] = 'locale',

['nil'] = 'nulle',

['not'] = 'pas',

['or'] = 'ou',

['repeat'] = 'répéter',

['return'] = 'renvoyer',

['then'] = 'alors',

['true'] = 'vrai',

['until'] = "jusqu’à", -- fun

['while'] = 'tant que', -- also fun

-- Bartosz' addition

['with'] = 'avec',

}

local function cli(filename, to_or_from)

local pprint = require "mlua.pprint" -- hide this from make_one_file

-- Read input file contents

local file = io.open(filename)

if not file then

print('failed to open file: '..filename)

os.exit(false)

end

local source = file:read('*a')

file:close()

if to_or_from == nil then

to_or_from = "to"

end

if to_or_from == "to" then

-- To french:

local p = lua.make_parse({

__options = {

tag = node.make_node,

}

})

local ast = p(source, filename)

print(pprint.print_ast(source, ast, french))

else

-- From french:

local p = lua.make_parse({

__options = {

kw = function(s) return french[s] or s end,

tag = node.make_node,

}

})

local ast = p(source, filename)

if to_or_from == 'from' then

print(pprint.print_ast(source, ast))

else

-- execute!

local eval = myrequire('mlua.eval').eval

print(eval(ast))

end

--cli(arg[1], arg[2])

return french

end)

--[[

a Scribunto module to evaluate a given module, but with our interpreter

]]--

local lua = myrequire('mlua.lua')

local make_node = myrequire('mlua.node').make_node

local eval = myrequire('mlua.eval').eval

local french = myrequire('mlua.french')

-- This could include language-specific options.

local parse

local function get_parse()

if parse == nil then

parse = lua.make_parse{

__options = { tag = make_node },

}

end

return parse

end

local parse_fr

local function get_parse_fr()

if parse_fr == nil then

parse_fr = lua.make_parse{

__options = {

kw = function(s) return french[s] or s end,

tag = make_node,

}

end

return parse_fr

end

local function get_source(frame, default_to_module)

local title = frame.args[1]

if string.find(title, "^Module:") == nil and default_to_module then

title = mw.title.makeTitle("Module", title)

else

title = mw.title.new(title)

end

local source = title:getContent()

if source == nil then

error("Can't find title " .. tostring(title))

end

-- strip syntaxhighlight tags if present

source = source:gsub("^%s*]*>", "", 1)

source = source:gsub("]*>%s*$", "", 1)

return title, source

end

local function invoke_from_ast(frame, ast)

local M = eval(ast)

local f = M[frame.args[2]]

-- now pop the first two arguments off and invoke the function

-- this is harder than it should be, since frame.args isn't a

-- real table.

-- XXX should also hook frame:getArgument, frame.args.__pairs,

-- frame.args.__ipairs, etc. and also be more careful w/r/t

-- string/number.

local args_proxy = function(_,v)

if type(v) == 'number' then

return frame.args[v+2]

else

return frame.args[v]

end

local nargs = setmetatable({}, {__index = args_proxy})

local nframe = {}

local frame_proxy = function(_,v)

if v == 'args' then return nargs end

local res = frame[v]

if type(res) == 'function' then

return function(...)

if select(1, ...) == nframe then

-- substitute in the proper receiver

return res(frame, select(2, ...))

end

return res(...)

end

return res

end

setmetatable(nframe, {__index = frame_proxy})

return f(nframe)

end

return {

get_parse = get_parse,

get_parse_fr = get_parse_fr,

eval = function(frame, ...)

if type(frame)=='string' then

frame = { args = { frame, ... } }

end

local source = frame.args[1]

local lang = frame.args[2] or 'en'

local parse

if lang == 'fr' then

parse = get_parse_fr()

else

parse = get_parse()

end

local ast = parse(source, "")

return eval(ast)

end,

invoke = function(frame, ...)

if type(frame)=='string' then

frame = { args = { frame, ... } }

end

local title, source = get_source(frame, true)

local parse = get_parse()

local ast = parse(source, title.fullText)

return invoke_from_ast(frame, ast)

end,

invokeUser = function(frame, ...)

if type(frame)=='string' then

frame = { args = { frame, ... } }

end

-- If we're using Bartosz' for-loop syntax,

-- we can't get source from module space because this isn't

-- "syntax-error-free lua"

local title, source = get_source(frame)

local parse = get_parse()

local ast = parse(source, title.fullText)

return invoke_from_ast(frame, ast)

end,

invokeFr = function(frame, ...)

if type(frame)=='string' then

frame = { args = { frame, ... } }

end

-- we can't get source from module space because this isn't

-- "syntax-error-free lua"

local title, source = get_source(frame)

local parse = get_parse_fr()

local ast = parse(source, title.fullText)

return invoke_from_ast(frame, ast)

end

}

end)

local modules = {}

modules['bit32'] = require('bit32')

modules['string'] = require('string')

modules['strict'] = {}

modules['table'] = require('table')

local function myrequire(name)

if modules[name] == nil then

modules[name] = true

modules[name] = (builders[name])(myrequire)

end

return modules[name]

end

return myrequire('mlua.wiki')

end)()