Модуль:Песочница/Pok: различия между версиями

---                                        ---

---    LOCAL ENVIRONMENT                  ---

-- Helper function for `string.gsub()` (for managing zero-padded numbers)

end

-- Helper function for `table.sort()` (for natural sorting)

end

-- Return a copy or a reference to a table

if refonly then return src end

newtab = {}

-- Remove numerical elements from a table, shifting everything to the left

local cache = {}

local tmp = idx + len - 1

-- Make a reduced copy of a table (shifting in both directions if necessary)

local ret = {}

local tmp = idx + len - 1

-- Make an expanded copy of a table (shifting in both directions if necessary)

local ret = {}

local tmp = idx + len - 1

return ret

end

-- Move a key from a table to another, but only if under a different name and

-- always parsing numerical strings as numbers

local realkey = tonumber(dkey) or dkey:match'^%s*(.-)%s*$'

if skey ~= realkey then

local mkeywords = {

['or'] = 0,

plain = 2,

strict = 3

--[[ Module's private environment ]]--

--------------------------------------

-- Create a new context

local ctx = {}

ctx.luaname = 'Module:Params' --[[ or `frame:getTitle()` ]]--

ctx.iterfunc = pairs

ctx.firstposonly = static_iface

ctx.n_available = maxfill

-- Move to the next action within the user-given list

local nextfn

if ctx.pipe[n_forward] ~= nil then

-- Main loop

local fn = start_with

repeat fn = fn(ctx) until not fn

local names

names[tonumber(tmp) or tmp:match'^%s*(.-)%s*$' or ''] =

src[pin + 2]

if tmp ~= nil then

if tmp < 0 then tmp = -1 end

for idx = pin + 1, pin + tmp do dest[idx + shf] = src[idx] end

if names ~= nil then

for key, val in pairs(names) do dest[key] = val end

end

end

end

end

end

tbl[key] = fn()

end

for key in pairs(tbl) do

margs[karg] = key

tbl[key] = fn()

end

tbl[key] = fn()

end

end

for key, val in pairs(tbl) do

steal_if_renamed(val, tbl, key, cache, fn())

end

for key, val in pairs(tbl) do

rargs[varg] = val

steal_if_renamed(val, tbl, key, cache, fn())

end

for key, val in pairs(tbl) do

steal_if_renamed(val, tbl, key, cache, fn())

end

for key, val in pairs(tbl) do

steal_if_renamed(val, tbl, key, cache, fn())

end

end

for key, val in pairs(cache) do tbl[key] = val end

end

-- keys from the table of options; non-numerical keys from the table of options

-- will prevail over colliding non-numerical keys from the table of parameters

local tbl = ctx.params

local size = table.maxn(ctx.pipe)

-- Flush the parameters by calling a custom function for each value (after this

-- function has been invoked `ctx.params` will be no longer usable)

local tbl = ctx.params

if ctx.subset == 1 then

for key, val in ipairs(tbl) do tbl[key] = nil end

end

local nums = {}

local words = {}

for key, val in pairs(tbl) do

if type(key) == 'number' then

else

end

end

table.sort(nums)

table.sort(words, natural_sort)

return

end

-- Syntax:  #invoke:params|sequential|pipe to

if ctx.subset == -1 then error(ctx.luaname ..

': The two directives ‘non-sequential’ and ‘sequential’ are in contradiction with each other', 0) end

ctx.iterfunc = ipairs

ctx.subset = 1

-- Syntax:  #invoke:params|non-sequential|pipe to

if ctx.subset == 1 then error(ctx.luaname ..

': The two directives ‘sequential’ and ‘non-sequential’ are in contradiction with each other', 0) end

if ctx.subset == 1 then error(ctx.luaname ..

': The ‘all_sorted’ directive is redundant after ‘sequential’', 0) end

return context_iterate(ctx, 1)

end

-- Syntax:  #invoke:params|setting|directives|...|pipe to

local opts = ctx.pipe

local cmd = opts[1]

vname = memoryslots[string.char(chr)]

if vname == nil then error(ctx.luaname ..

table.insert(dest, vname)

end

-- Syntax:  #invoke:params|squeezing|pipe to

local tbl = ctx.params

local store = {}

-- Syntax:  #invoke:params|filling_the_gaps|pipe to

local tbl = ctx.params

local nmin = 1

-- Syntax:  #invoke:params|clearing|pipe to

local tbl = ctx.params

local numericals = {}

-- Syntax:  #invoke:params|cutting|left cut|right cut|pipe to

local lcut = tonumber(ctx.pipe[1])

if lcut == nil then error(ctx.luaname ..

-- Syntax:  #invoke:params|cropping|left crop|right crop|pipe to

local lcut = tonumber(ctx.pipe[1])

if lcut == nil then error(ctx.luaname ..

-- Syntax:  #invoke:params|purging|start offset|length|pipe to

local idx = tonumber(ctx.pipe[1])

if idx == nil then error(ctx.luaname ..

-- Syntax:  #invoke:params|backpurging|start offset|length|pipe to

local last = tonumber(ctx.pipe[1])

if last == nil then error(ctx.luaname ..

-- Syntax:  #invoke:params|rotating|pipe to

local tbl = ctx.params

local numericals = {}

-- Syntax:  #invoke:params|pivoting|pipe to

--[[

local tbl = ctx.params

local shift = #tbl + 1

-- Syntax:  #invoke:params|mirroring|pipe to

--[[

local tbl = ctx.params

local numericals = {}

-- Syntax:  #invoke:params|swapping|pipe to

--[[

local tbl = ctx.params

local cache = {}

-- Syntax:  #invoke:params|sorting_sequential_values|[criterion]|pipe to

local sortfn

if ctx.pipe[1] ~= nil then sortfn = sortfunctions[ctx.pipe[1]] end

-- Syntax:  #invoke:params|inserting|position|how many|...|pipe to

--[[

-- NOTE: `ctx.params` might be the original metatable! As a modifier,

-- this function MUST create a copy of it before returning

-- Syntax:  #invoke:params|imposing|name|value|pipe to

if ctx.pipe[1] == nil then error(ctx.luaname ..

', ‘imposing’: Missing parameter name to impose', 0) end

local key = ctx.pipe[1]:match'^%s*(.-)%s*$'

ctx.params[tonumber(key) or key] = ctx.pipe[2]

return context_iterate(ctx, 3)

end

-- Syntax:  #invoke:params|discarding|name|[how many]|pipe to

if ctx.pipe[1] == nil then error(ctx.luaname ..

', ‘discarding’: Missing parameter name to discard', 0) end

--            N]|pipe to

local tbl = ctx.params

local nomatch

for key in pairs(tbl) do

nomatch = true

if not ptn[3] then

if string.find(key, ptn[1], 1, ptn[2]) then

--            flag N]|pipe to

local tbl = ctx.params

'with_name_not_matching')

local yesmatch

for key in pairs(tbl) do

yesmatch = true

if ptn[3] then

if key ~= ptn[1] then

--            N]|pipe to

local tbl = ctx.params

local nomatch

for key, val in pairs(tbl) do

nomatch = true

if ptn[3] then

if val == ptn[1] then

--            flag N]|pipe to

local tbl = ctx.params

'with_value_not_matching')

local yesmatch

for key, val in pairs(tbl) do

yesmatch = true

if ptn[3] then

if val ~= ptn[1] then

-- Syntax:  #invoke:params|trimming_values|pipe to

local tbl = ctx.params

for key, val in pairs(tbl) do tbl[key] = val:match'^%s*(.-)%s*$' end

--            style]|[let]|[...][number of additional parameters]|[parameter

--            1]|[parameter 2]|[...]|[parameter N]|pipe to

local opts = ctx.pipe

local tname

if tname == nil then error(ctx.luaname ..

', ‘mapping_by_calling’: No template name was provided', 0) end

mapping_styles.values_only)

local model = { title = tname, args = margs }

return ctx.frame:expandTemplate(model)

end)

--            name|[call style]|[let]|[...]|[number of additional

--            arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe to

local opts = ctx.pipe

local mname

if fname == nil then error(ctx.luaname ..

', ‘mapping_by_invoking’: No function name was provided', 0) end

mapping_styles.values_only)

local model = { title = 'Module:' .. mname, args = margs }

', ‘mapping_by_invoking’: The function ‘' .. fname ..

'’ does not exist', 0) end

return mfunc(ctx.frame:newChild(model))

end)

--            style]|[let]|[...][number of additional arguments]|[argument

--            1]|[argument 2]|[...]|[argument N]|pipe to

local opts = ctx.pipe

local magic

if magic == nil then error(ctx.luaname ..

', ‘mapping_by_magic’: No parser function was provided', 0) end

mapping_styles.values_only)

return ctx.frame:callParserFunction(magic, margs)

end)

--            style]|[let]|[...][number of additional parameters]|[parameter

--            1]|[parameter 2]|[...]|[parameter N]|pipe to

local opts = ctx.pipe

local tname

if tname == nil then error(ctx.luaname ..

', ‘renaming_by_calling’: No template name was provided', 0) end

mapping_styles.names_only)

local model = { title = tname, args = rargs }

return ctx.frame:expandTemplate(model)

end)

--            name|[call style]|[let]|[...]|[number of additional

--            arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe to

local opts = ctx.pipe

local mname

if fname == nil then error(ctx.luaname ..

', ‘renaming_by_invoking’: No function name was provided', 0) end

mapping_styles.names_only)

local model = { title = 'Module:' .. mname, args = rargs }

', ‘renaming_by_invoking’: The function ‘' .. fname ..

'’ does not exist', 0) end

return mfunc(ctx.frame:newChild(model))

end)

return context_iterate(ctx, argc)

return context_iterate(ctx, argc)

end

-- Syntax:  #invoke:params|count

-- NOTE: `ctx.pipe` and `ctx.params` might be the original metatables!

local retval = 0

--            |[...]|[item n]|[named item 1=value 1]|[...]|[named item n=value

--            n]|[...]

-- NOTE: `ctx.params` might be the original metatable!

local opts = ctx.pipe

--            1]|[prepend 2]|[...]|[item n]|[named item 1=value 1]|[...]|[named

--            item n=value n]|[...]

-- NOTE: `ctx.params` might be the original metatable!

local opts = ctx.pipe

--            2]|[...]|[item n]|[named item 1=value 1]|[...]|[named item n=

--            value n]|[...]

-- NOTE: `ctx.params` might be the original metatable!

local opts = ctx.pipe

-- Syntax:  #invoke:params|value_of|parameter name

-- NOTE: `ctx.pipe` and `ctx.params` might be the original metatables!

local opts = ctx.pipe

-- Syntax:  #invoke:params|list

-- NOTE: `ctx.pipe` might be the original metatable!

local kvs = ctx.pairsep or ''

flush_params(

ctx,

ret[nss + 1] = pps

ret[nss + 2] = key

-- Syntax:  #invoke:params|list_values

-- NOTE: `ctx.pipe` might be the original metatable!

local pps = ctx.itersep or ''

flush_params(

ctx,

ret[nss + 1] = pps

ret[nss + 2] = val

-- Syntax:  #invoke:params|for_each|wikitext

-- NOTE: `ctx.pipe` might be the original metatable!

local txt = ctx.pipe[1] or ''

flush_params(

ctx,

ret[nss + 1] = pps

ret[nss + 2] = txt:gsub('%$#', key):gsub('%$@', val)

--            |[...]|[append n]|[named param 1=value 1]|[...]|[named param

--            n=value n]|[...]

local opts = ctx.pipe

local tname

flush_params(

ctx,

opts[1] = key

opts[2] = val

--            1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]

--            |[named param n=value n]|[...]

local opts = ctx.pipe

local mname

flush_params(

ctx,

opts[1] = key

opts[2] = val

--            |[...]|[append n]|[named param 1=value 1]|[...]|[named param

--            n=value n]|[...]

local opts = ctx.pipe

local magic

flush_params(

ctx,

opts[1] = key

opts[2] = val

--            2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param

--            n=value n]|[...]

local opts = ctx.pipe

local tname

flush_params(

ctx,

opts[1] = val

ret[nss + 1] = ccs

--            2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param

--            n=value n]|[...]

local opts = ctx.pipe

local mname

flush_params(

ctx,

opts[1] = val

ret[nss + 1] = ccs

--            |[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named

--            param n=value n]|[...]

local opts = ctx.pipe

local magic

flush_params(

ctx,

opts[1] = val

ret[nss + 1] = ccs

--            2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param

--            n=value n]|[...]

-- NOTE: `ctx.pipe` and `ctx.params` might be the original metatables!

local opts = ctx.pipe

local ccs = ctx.itersep or ''

local nss = 0

local ret = {}

opts = {}

end

ctx.pipe = opts

flush_params(

ctx,

for key, val in pairs(opts) do group[key] = val end

group[0] = gid

-- Syntax:  #invoke:params|new|pipe to

--[[

local ctx = context_new()

ctx.frame = frame:getParent()

--[[ First-position-only functions ]]--

---------------------------------------

-- Syntax:  #invoke:params|self

return frame:getParent():getTitle()

end

--[[ Public metatable of functions ]]--

---------------------------------------

return setmetatable(static_iface, {

local ctx = context_new()

local fname = _fname_:match'^%s*(.*%S)'

if library[fname] == nil then error(ctx.luaname ..

': The function ‘' .. fname .. '’ does not exist', 0) end

ctx.frame = frame:getParent()

main_loop(ctx, func)

return ctx.text