context (22apr16)

git-svn-id: svn://tug.org/texlive/trunk@40691 c570f23f-e606-0410-a88d-b1316a301751

1 files changed, 1205 insertions, 0 deletions

diff --git a/Master/texmf-dist/tex/context/base/mkiv/anch-pos.lua b/Master/texmf-dist/tex/context/base/mkiv/anch-pos.lua
new file mode 100644
index 00000000000..c01e9017976
--- /dev/null
+++ b/Master/texmf-dist/tex/context/base/mkiv/anch-pos.lua
@@ -0,0 +1,1205 @@
+if not modules then modules = { } end modules ['anch-pos'] = {
+    version   = 1.001,
+    comment   = "companion to anch-pos.mkiv",
+    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
+    copyright = "PRAGMA ADE / ConTeXt Development Team",
+    license   = "see context related readme files"
+}
+
+--[[ldx--
+<p>We save positional information in the main utility table. Not only
+can we store much more information in <l n='lua'/> but it's also
+more efficient.</p>
+--ldx]]--
+
+-- plus (extra) is obsolete but we will keep it for a while
+
+-- context(new_latelua_node(f_enhance(tag)))
+--     =>
+-- context.lateluafunction(function() f_enhance(tag) end)
+
+-- maybe replace texsp by our own converter (stay at the lua end)
+-- eventually mp will have large numbers so we can use sp there too
+
+local tostring, next, rawget, setmetatable = tostring, next, rawget, setmetatable
+local sort = table.sort
+local format, gmatch, match = string.format, string.gmatch, string.match
+local rawget = rawget
+local lpegmatch = lpeg.match
+local insert, remove = table.insert, table.remove
+local allocate, mark = utilities.storage.allocate, utilities.storage.mark
+
+local scanners          = tokens.scanners
+local scanstring        = scanners.string
+local scaninteger       = scanners.integer
+local scandimen         = scanners.dimen
+
+local compilescanner    = tokens.compile
+local scanners          = interfaces.scanners
+
+local commands          = commands
+local context           = context
+
+local tex               = tex
+local texgetcount       = tex.getcount
+local texsetcount       = tex.setcount
+local texget            = tex.get
+local texsp             = tex.sp
+----- texsp             = string.todimen -- because we cache this is much faster but no rounding
+
+local pdf               = pdf -- h and v are variables
+
+local setmetatableindex = table.setmetatableindex
+
+local nuts              = nodes.nuts
+
+local getfield          = nuts.getfield
+local setfield          = nuts.setfield
+local setlink           = nuts.setlink
+local getlist           = nuts.getlist
+local setlist           = nuts.setlist
+local getbox            = nuts.getbox
+local getskip           = nuts.getskip
+
+local find_tail         = nuts.tail
+
+local new_latelua       = nuts.pool.latelua
+local new_latelua_node  = nodes.pool.latelua
+
+local variables         = interfaces.variables
+local v_text            = variables.text
+local v_column          = variables.column
+
+local pt                = number.dimenfactors.pt
+local pts               = number.pts
+local formatters        = string.formatters
+
+local collected         = allocate()
+local tobesaved         = allocate()
+
+local jobpositions = {
+    collected = collected,
+    tobesaved = tobesaved,
+}
+
+job.positions = jobpositions
+
+_plib_ = jobpositions -- might go
+
+local default = { -- not r and paragraphs etc
+    __index = {
+        x  = 0,     -- x position baseline
+        y  = 0,     -- y position baseline
+        w  = 0,     -- width
+        h  = 0,     -- height
+        d  = 0,     -- depth
+        p  = 0,     -- page
+        n  = 0,     -- paragraph
+        ls = 0,     -- leftskip
+        rs = 0,     -- rightskip
+        hi = 0,     -- hangindent
+        ha = 0,     -- hangafter
+        hs = 0,     -- hsize
+        pi = 0,     -- parindent
+        ps = false, -- parshape
+    }
+}
+
+local f_b_tag     = formatters["b:%s"]
+local f_e_tag     = formatters["e:%s"]
+local f_p_tag     = formatters["p:%s"]
+local f_w_tag     = formatters["w:%s"]
+
+local f_b_column  = formatters["_plib_.b_col(%q)"]
+local f_e_column  = formatters["_plib_.e_col()"]
+
+local f_enhance   = formatters["_plib_.enhance(%q)"]
+local f_region    = formatters["region:%s"]
+
+local f_b_region  = formatters["_plib_.b_region(%q)"]
+local f_e_region  = formatters["_plib_.e_region(%s)"]
+
+local f_tag_three = formatters["%s:%s:%s"]
+local f_tag_two   = formatters["%s:%s"]
+
+local function sorter(a,b)
+    return a.y > b.y
+end
+
+local nofusedregions    = 0
+local nofmissingregions = 0
+local nofregular        = 0
+
+jobpositions.used       = false
+
+-- todo: register subsets and count them indepently
+
+local function initializer()
+    tobesaved = jobpositions.tobesaved
+    collected = jobpositions.collected
+    -- add sparse regions
+    local pages = structures.pages.collected
+    if pages  then
+        local last = nil
+        for p=1,#pages do
+            local region = "page:" .. p
+            local data   = collected[region]
+            if data then
+                last   = data
+                last.p = nil -- no need for a page
+            elseif last then
+                collected[region] = last
+            end
+        end
+    end
+    -- enhance regions with paragraphs
+    for tag, data in next, collected do
+        local region = data.r
+        if region then
+            local r = collected[region]
+            if r then
+                local paragraphs = r.paragraphs
+                if not paragraphs then
+                    r.paragraphs = { data }
+                else
+                    paragraphs[#paragraphs+1] = data
+                end
+                nofusedregions = nofusedregions + 1
+            else
+                nofmissingregions = nofmissingregions + 1
+            end
+        else
+            nofregular = nofregular + 1
+        end
+        setmetatable(data,default)
+    end
+    -- add metatable
+ -- for tag, data in next, collected do
+ --     setmetatable(data,default)
+ -- end
+    -- sort this data
+    for tag, data in next, collected do
+        local region = data.r
+        if region then
+            local r = collected[region]
+            if r then
+                local paragraphs = r.paragraphs
+                if paragraphs and #paragraphs > 1 then
+                    sort(paragraphs,sorter)
+                end
+            end
+        end
+        -- so, we can be sparse and don't need 'or 0' code
+    end
+    jobpositions.used = next(collected)
+end
+
+job.register('job.positions.collected', tobesaved, initializer)
+
+local regions    = { }
+local nofregions = 0
+local region     = nil
+
+local columns    = { }
+local nofcolumns = 0
+local column     = nil
+
+local nofpages   = nil
+
+-- beware ... we're not sparse here as lua will reserve slots for the nilled
+
+local getpos  = function() getpos  = backends.codeinjections.getpos  return getpos () end
+local gethpos = function() gethpos = backends.codeinjections.gethpos return gethpos() end
+local getvpos = function() getvpos = backends.codeinjections.getvpos return getvpos() end
+
+local function setdim(name,w,h,d,extra) -- will be used when we move to sp allover
+    local x, y = getpos()
+    if x == 0 then x = nil end
+    if y == 0 then y = nil end
+    if w == 0 then w = nil end
+    if h == 0 then h = nil end
+    if d == 0 then d = nil end
+    if extra == "" then extra = nil end
+    -- todo: sparse
+    tobesaved[name] = {
+        p = texgetcount("realpageno"),
+        x = x,
+        y = y,
+        w = w,
+        h = h,
+        d = d,
+        e = extra,
+        r = region,
+        c = column,
+    }
+end
+
+local function setall(name,p,x,y,w,h,d,extra)
+    if x == 0 then x = nil end
+    if y == 0 then y = nil end
+    if w == 0 then w = nil end
+    if h == 0 then h = nil end
+    if d == 0 then d = nil end
+    if extra == "" then extra = nil end
+    -- todo: sparse
+    tobesaved[name] = {
+        p = p,
+        x = x,
+        y = y,
+        w = w,
+        h = h,
+        d = d,
+        e = extra,
+        r = region,
+        c = column,
+    }
+end
+
+local function enhance(data)
+    if not data then
+        return nil
+    end
+    if data.r == true then -- or ""
+        data.r = region
+    end
+    if data.x == true then
+        if data.y == true then
+            data.x, data.y = getpos()
+        else
+            data.x = gethpos()
+        end
+    elseif data.y == true then
+        data.y = getvpos()
+    end
+    if data.p == true then
+        data.p = texgetcount("realpageno")
+    end
+    if data.c == true then
+        data.c = column
+    end
+    if data.w == 0 then
+        data.w = nil
+    end
+    if data.h == 0 then
+        data.h = nil
+    end
+    if data.d == 0 then
+        data.d = nil
+    end
+    return data
+end
+
+-- analyze some files (with lots if margindata) and then when one key optionally
+-- use that one instead of a table (so, a 3rd / 4th argument: key, e.g. "x")
+
+local function set(name,index,val) -- ,key
+    local data = enhance(val or index)
+    if val then
+-- if data[key] and not next(next(data)) then
+--     data = data[key]
+-- end
+        container = tobesaved[name]
+        if not container then
+            tobesaved[name] = {
+                [index] = data
+            }
+        else
+            container[index] = data
+        end
+    else
+        tobesaved[name] = data
+    end
+end
+
+local function get(id,index)
+    if index then
+        local container = collected[id]
+        return container and container[index]
+    else
+        return collected[id]
+    end
+end
+
+jobpositions.setdim = setdim
+jobpositions.setall = setall
+jobpositions.set    = set
+jobpositions.get    = get
+
+-- scanners.setpos     = setall
+
+-- trackers.enable("tokens.compi*")
+
+-- something weird: the compiler fails us here
+
+scanners.dosaveposition = compilescanner {
+    actions   = setall, -- name p x y
+    arguments = { "string", "integer", "dimen", "dimen" }
+}
+
+scanners.dosavepositionwhd = compilescanner { -- somehow fails
+    actions   = setall, -- name p x y w h d
+    arguments = { "string", "integer", "dimen", "dimen", "dimen", "dimen", "dimen" }
+}
+
+scanners.dosavepositionplus = compilescanner {
+    actions   = setall,  -- name p x y w h d extra
+    arguments = { "string", "integer", "dimen", "dimen", "dimen", "dimen", "dimen", "string" }
+}
+
+-- will become private table (could also become attribute driven but too nasty
+-- as attributes can bleed e.g. in margin stuff)
+
+-- not much gain in keeping stack (inc/dec instead of insert/remove)
+
+function jobpositions.b_col(tag)
+    tobesaved[tag] = {
+        r = true,
+        x = gethpos(),
+        w = 0,
+    }
+    insert(columns,tag)
+    column = tag
+end
+
+function jobpositions.e_col(tag)
+    local t = tobesaved[column]
+    if not t then
+        -- something's wrong
+    else
+        t.w = gethpos() - t.x
+        t.r = region
+    end
+    remove(columns)
+    column = columns[#columns]
+end
+
+scanners.bposcolumn = function() -- tag
+    local tag = scanstring()
+    insert(columns,tag)
+    column = tag
+end
+
+scanners.bposcolumnregistered = function() -- tag
+    local tag = scanstring()
+    insert(columns,tag)
+    column = tag
+    context(new_latelua_node(f_b_column(tag)))
+end
+
+scanners.eposcolumn = function()
+    remove(columns)
+    column = columns[#columns]
+end
+
+scanners.eposcolumnregistered = function()
+    context(new_latelua_node(f_e_column()))
+    remove(columns)
+    column = columns[#columns]
+end
+
+-- regions
+
+function jobpositions.b_region(tag)
+    local last = tobesaved[tag]
+    last.x, last.y = getpos()
+    last.p = texgetcount("realpageno")
+    insert(regions,tag)
+    region = tag
+end
+
+function jobpositions.e_region(correct)
+    local last = tobesaved[region]
+    local v = getvpos()
+    if correct then
+        last.h = last.y - v
+    end
+    last.y = v
+    remove(regions)
+    region = regions[#regions]
+end
+
+local function setregionbox(n,tag)
+    if not tag or tag == "" then
+        nofregions = nofregions + 1
+        tag = f_region(nofregions)
+    end
+    local box = getbox(n)
+    local w = getfield(box,"width")
+    local h = getfield(box,"height")
+    local d = getfield(box,"depth")
+    tobesaved[tag] = {
+        p = true,
+        x = true,
+        y = getvpos(), -- true,
+        w = w ~= 0 and w or nil,
+        h = h ~= 0 and h or nil,
+        d = d ~= 0 and d or nil,
+    }
+    return tag, box
+end
+
+local function markregionbox(n,tag,correct)
+    local tag, box = setregionbox(n,tag)
+    local push = new_latelua(f_b_region(tag))
+    local pop  = new_latelua(f_e_region(tostring(correct))) -- todo: check if tostring is needed with formatter
+    -- maybe we should construct a hbox first (needs experimenting) so that we can avoid some at the tex end
+    local head = getlist(box)
+    if head then
+        local tail = find_tail(head)
+        setlink(push,head)
+        setlink(tail,pop)
+    else -- we can have a simple push/pop
+        setlink(push,pop)
+    end
+    setlist(box,push)
+end
+
+jobpositions.markregionbox = markregionbox
+jobpositions.setregionbox  = setregionbox
+
+function jobpositions.enhance(name)
+    enhance(tobesaved[name])
+end
+
+-- scanners.pos = function(name,t) -- name t
+--     local name = scanstring()
+--     tobesaved[name] = scanstring()
+--     context(new_latelua_node(f_enhance(name)))
+-- end
+
+local nofparagraphs = 0
+
+scanners.parpos = function() -- todo: relate to localpar (so this is an intermediate variant)
+    nofparagraphs = nofparagraphs + 1
+    texsetcount("global","c_anch_positions_paragraph",nofparagraphs)
+    local strutbox = getbox("strutbox")
+    local t = {
+        p  = true,
+        c  = true,
+        r  = true,
+        x  = true,
+        y  = true,
+        h  = getfield(strutbox,"height"),
+        d  = getfield(strutbox,"depth"),
+        hs = texget("hsize"),
+    }
+    local leftskip   = getfield(getskip("leftskip"),"width")
+    local rightskip  = getfield(getskip("rightskip"),"width")
+    local hangindent = texget("hangindent")
+    local hangafter  = texget("hangafter")
+    local parindent  = texget("parindent")
+    local parshape   = texget("parshape")
+    if leftskip ~= 0 then
+        t.ls = leftskip
+    end
+    if rightskip ~= 0 then
+        t.rs = rightskip
+    end
+    if hangindent ~= 0 then
+        t.hi = hangindent
+    end
+    if hangafter ~= 1 and hangafter ~= 0 then -- can not be zero .. so it needs to be 1 if zero
+        t.ha = hangafter
+    end
+    if parindent ~= 0 then
+        t.pi = parindent
+    end
+    if parshape and #parshape > 0 then
+        t.ps = parshape
+    end
+    local tag = f_p_tag(nofparagraphs)
+    tobesaved[tag] = t
+    context(new_latelua_node(f_enhance(tag)))
+end
+
+scanners.dosetposition = function() -- name
+    local name = scanstring()
+    tobesaved[name] = {
+        p = true,
+        c = column,
+        r = true,
+        x = true,
+        y = true,
+        n = nofparagraphs > 0 and nofparagraphs or nil,
+    }
+    context(new_latelua_node(f_enhance(name)))
+end
+
+scanners.dosetpositionwhd = function() -- name w h d extra
+    local name = scanstring()
+    tobesaved[name] = {
+        p = true,
+        c = column,
+        r = true,
+        x = true,
+        y = true,
+        w = scandimen(),
+        h = scandimen(),
+        d = scandimen(),
+        n = nofparagraphs > 0 and nofparagraphs or nil,
+    }
+    context(new_latelua_node(f_enhance(name)))
+end
+
+scanners.dosetpositionbox = function() -- name box
+    local name = scanstring()
+    local box  = getbox(scaninteger())
+    tobesaved[name] = {
+        p = true,
+        c = column,
+        r = true,
+        x = true,
+        y = true,
+        w = getfield(box,"width"),
+        h = getfield(box,"height"),
+        d = getfield(box,"depth"),
+        n = nofparagraphs > 0 and nofparagraphs or nil,
+    }
+    context(new_latelua_node(f_enhance(name)))
+end
+
+scanners.dosetpositionplus = function() -- name w h d extra
+    local name = scanstring()
+    tobesaved[name] = {
+        p = true,
+        c = column,
+        r = true,
+        x = true,
+        y = true,
+        w = scandimen(),
+        h = scandimen(),
+        d = scandimen(),
+        n = nofparagraphs > 0 and nofparagraphs or nil,
+        e = scanstring(),
+    }
+    context(new_latelua_node(f_enhance(name)))
+end
+
+scanners.dosetpositionstrut = function() -- name
+    local name = scanstring()
+    local strutbox = getbox("strutbox")
+    tobesaved[name] = {
+        p = true,
+        c = column,
+        r = true,
+        x = true,
+        y = true,
+        h = getfield(strutbox,"height"),
+        d = getfield(strutbox,"depth"),
+        n = nofparagraphs > 0 and nofparagraphs or nil,
+    }
+    context(new_latelua_node(f_enhance(name)))
+end
+
+function jobpositions.getreserved(tag,n)
+    if tag == v_column then
+        local fulltag = f_tag_three(tag,texgetcount("realpageno"),n or 1)
+        local data = collected[fulltag]
+        if data then
+            return data, fulltag
+        end
+        tag = v_text
+    end
+    if tag == v_text then
+        local fulltag = f_tag_two(tag,texgetcount("realpageno"))
+        return collected[fulltag] or false, fulltag
+    end
+    return collected[tag] or false, tag
+end
+
+function jobpositions.copy(target,source)
+    collected[target] = collected[source]
+end
+
+function jobpositions.replace(id,p,x,y,w,h,d)
+    collected[id] = { p = p, x = x, y = y, w = w, h = h, d = d } -- c g
+end
+
+function jobpositions.page(id)
+    local jpi = collected[id]
+    return jpi and jpi.p
+end
+
+function jobpositions.region(id)
+    local jpi = collected[id]
+    if jpi then
+        local r = jpi.r
+        if r then
+            return r
+        end
+        local p = jpi.p
+        if p then
+            return "page:" .. p
+        end
+    end
+    return false
+end
+
+function jobpositions.column(id)
+    local jpi = collected[id]
+    return jpi and jpi.c or false
+end
+
+function jobpositions.paragraph(id)
+    local jpi = collected[id]
+    return jpi and jpi.n
+end
+
+jobpositions.p = jobpositions.page
+jobpositions.r = jobpositions.region
+jobpositions.c = jobpositions.column
+jobpositions.n = jobpositions.paragraph
+
+function jobpositions.x(id)
+    local jpi = collected[id]
+    return jpi and jpi.x
+end
+
+function jobpositions.y(id)
+    local jpi = collected[id]
+    return jpi and jpi.y
+end
+
+function jobpositions.width(id)
+    local jpi = collected[id]
+    return jpi and jpi.w
+end
+
+function jobpositions.height(id)
+    local jpi = collected[id]
+    return jpi and jpi.h
+end
+
+function jobpositions.depth(id)
+    local jpi = collected[id]
+    return jpi and jpi.d
+end
+
+function jobpositions.leftskip(id)
+    local jpi = collected[id]
+    return jpi and jpi.ls
+end
+
+function jobpositions.rightskip(id)
+    local jpi = collected[id]
+    return jpi and jpi.rs
+end
+
+function jobpositions.hsize(id)
+    local jpi = collected[id]
+    return jpi and jpi.hs
+end
+
+function jobpositions.parindent(id)
+    local jpi = collected[id]
+    return jpi and jpi.pi
+end
+
+function jobpositions.hangindent(id)
+    local jpi = collected[id]
+    return jpi and jpi.hi
+end
+
+function jobpositions.hangafter(id)
+    local jpi = collected[id]
+    return jpi and jpi.ha or 1
+end
+
+function jobpositions.xy(id)
+    local jpi = collected[id]
+    if jpi then
+        return jpi.x, jpi.y
+    else
+        return 0, 0
+    end
+end
+
+function jobpositions.lowerleft(id)
+    local jpi = collected[id]
+    if jpi then
+        return jpi.x, jpi.y - jpi.d
+    else
+        return 0, 0
+    end
+end
+
+function jobpositions.lowerright(id)
+    local jpi = collected[id]
+    if jpi then
+        return jpi.x + jpi.w, jpi.y - jpi.d
+    else
+        return 0, 0
+    end
+end
+
+function jobpositions.upperright(id)
+    local jpi = collected[id]
+    if jpi then
+        return jpi.x + jpi.w, jpi.y + jpi.h
+    else
+        return 0, 0
+    end
+end
+
+function jobpositions.upperleft(id)
+    local jpi = collected[id]
+    if jpi then
+        return jpi.x, jpi.y + jpi.h
+    else
+        return 0, 0
+    end
+end
+
+function jobpositions.position(id)
+    local jpi = collected[id]
+    if jpi then
+        return jpi.p, jpi.x, jpi.y, jpi.w, jpi.h, jpi.d
+    else
+        return 0, 0, 0, 0, 0, 0
+    end
+end
+
+function jobpositions.extra(id,n,default) -- assume numbers
+    local jpi = collected[id]
+    if jpi then
+        local e = jpi.e
+        if e then
+            local split = jpi.split
+            if not split then
+                split = lpegmatch(splitter,jpi.e)
+                jpi.split = split
+            end
+            return texsp(split[n]) or default -- watch the texsp here
+        end
+    end
+    return default
+end
+
+local function overlapping(one,two,overlappingmargin) -- hm, strings so this is wrong .. texsp
+    one = collected[one]
+    two = collected[two]
+    if one and two and one.p == two.p then
+        if not overlappingmargin then
+            overlappingmargin = 2
+        end
+        local x_one = one.x
+        local x_two = two.x
+        local w_two = two.w
+        local llx_one = x_one         - overlappingmargin
+        local urx_two = x_two + w_two + overlappingmargin
+        if llx_one > urx_two then
+            return false
+        end
+        local w_one = one.w
+        local urx_one = x_one + w_one + overlappingmargin
+        local llx_two = x_two         - overlappingmargin
+        if urx_one < llx_two then
+            return false
+        end
+        local y_one = one.y
+        local y_two = two.y
+        local d_one = one.d
+        local h_two = two.h
+        local lly_one = y_one - d_one - overlappingmargin
+        local ury_two = y_two + h_two + overlappingmargin
+        if lly_one > ury_two then
+            return false
+        end
+        local h_one = one.h
+        local d_two = two.d
+        local ury_one = y_one + h_one + overlappingmargin
+        local lly_two = y_two - d_two - overlappingmargin
+        if ury_one < lly_two then
+            return false
+        end
+        return true
+    end
+end
+
+local function onsamepage(list,page)
+    for id in gmatch(list,"(, )") do
+        local jpi = collected[id]
+        if jpi then
+            local p = jpi.p
+            if not p then
+                return false
+            elseif not page then
+                page = p
+            elseif page ~= p then
+                return false
+            end
+        end
+    end
+    return page
+end
+
+jobpositions.overlapping = overlapping
+jobpositions.onsamepage  = onsamepage
+
+-- interface
+
+scanners.replacepospxywhd = function() -- name page x y w h d
+    collected[scanstring()] = {
+        p = scaninteger(),
+        x = scandimen(),
+        y = scandimen(),
+        w = scandimen(),
+        h = scandimen(),
+        d = scandimen(),
+    }
+end
+
+scanners.copyposition = function() -- target source
+    collected[scanstring()] = collected[scanstring()]
+end
+
+scanners.MPp = function() -- name
+    local jpi = collected[scanstring()]
+    if jpi then
+        local p = jpi.p
+        if p and p ~= true then
+            context(p)
+            return
+        end
+    end
+    context('0')
+end
+
+scanners.MPx = function() -- name
+    local jpi = collected[scanstring()]
+    if jpi then
+        local x = jpi.x
+        if x and x ~= true and x ~= 0 then
+            context("%.5Fpt",x*pt)
+            return
+        end
+    end
+    context('0pt')
+end
+
+scanners.MPy = function() -- name
+    local jpi = collected[scanstring()]
+    if jpi then
+        local y = jpi.y
+        if y and y ~= true and y ~= 0 then
+            context("%.5Fpt",y*pt)
+            return
+        end
+    end
+    context('0pt')
+end
+
+scanners.MPw = function() -- name
+    local jpi = collected[scanstring()]
+    if jpi then
+        local w = jpi.w
+        if w and w ~= 0 then
+            context("%.5Fpt",w*pt)
+            return
+        end
+    end
+    context('0pt')
+end
+
+scanners.MPh = function() -- name
+    local jpi = collected[scanstring()]
+    if jpi then
+        local h = jpi.h
+        if h and h ~= 0 then
+            context("%.5Fpt",h*pt)
+            return
+        end
+    end
+    context('0pt')
+end
+
+scanners.MPd = function() -- name
+    local jpi = collected[scanstring()]
+    if jpi then
+        local d = jpi.d
+        if d and d ~= 0 then
+            context("%.5Fpt",d*pt)
+            return
+        end
+    end
+    context('0pt')
+end
+
+scanners.MPxy = function() -- name
+    local jpi = collected[scanstring()]
+    if jpi then
+        context('(%.5Fpt,%.5Fpt)',
+            jpi.x*pt,
+            jpi.y*pt
+        )
+    else
+        context('(0,0)')
+    end
+end
+
+scanners.MPll = function() -- name
+    local jpi = collected[scanstring()]
+    if jpi then
+        context('(%.5Fpt,%.5Fpt)',
+             jpi.x       *pt,
+            (jpi.y-jpi.d)*pt
+        )
+    else
+        context('(0,0)') -- for mp only
+    end
+end
+
+scanners.MPlr = function() -- name
+    local jpi = collected[scanstring()]
+    if jpi then
+        context('(%.5Fpt,%.5Fpt)',
+            (jpi.x + jpi.w)*pt,
+            (jpi.y - jpi.d)*pt
+        )
+    else
+        context('(0,0)') -- for mp only
+    end
+end
+
+scanners.MPur = function() -- name
+    local jpi = collected[scanstring()]
+    if jpi then
+        context('(%.5Fpt,%.5Fpt)',
+            (jpi.x + jpi.w)*pt,
+            (jpi.y + jpi.h)*pt
+        )
+    else
+        context('(0,0)') -- for mp only
+    end
+end
+
+scanners.MPul = function() -- name
+    local jpi = collected[scanstring()]
+    if jpi then
+        context('(%.5Fpt,%.5Fpt)',
+             jpi.x         *pt,
+            (jpi.y + jpi.h)*pt
+        )
+    else
+        context('(0,0)') -- for mp only
+    end
+end
+
+local function MPpos(id)
+    local jpi = collected[id]
+    if jpi then
+        local p = jpi.p
+        if p then
+            context("%s,%.5Fpt,%.5Fpt,%.5Fpt,%.5Fpt,%.5Fpt",
+                p,
+                jpi.x*pt,
+                jpi.y*pt,
+                jpi.w*pt,
+                jpi.h*pt,
+                jpi.d*pt
+            )
+            return
+        end
+    end
+    context('0,0,0,0,0,0') -- for mp only
+end
+
+scanners.MPpos = function() -- name
+    MPpos(scanstring())
+end
+
+scanners.MPn = function() -- name
+    local jpi = collected[scanstring()]
+    if jpi then
+        local n = jpi.n
+        if n then
+            context(n)
+            return
+        end
+    end
+    context(0)
+end
+
+scanners.MPc = function() -- name
+    local jpi = collected[scanstring()]
+    if jpi then
+        local c = jpi.c
+        if c and c ~= true  then
+            context(c)
+            return
+        end
+    end
+    context('0') -- okay ?
+end
+
+scanners.MPr = function() -- name
+    local jpi = collected[scanstring()]
+    if jpi then
+        local r = jpi.r
+        if r and r ~= true  then
+            context(r)
+        end
+        local p = jpi.p
+        if p then
+            context("page:" .. p)
+        end
+    end
+end
+
+local function MPpardata(n)
+    local t = collected[n]
+    if not t then
+        local tag = f_p_tag(n)
+        t = collected[tag]
+    end
+    if t then
+        context("%.5Fpt,%.5Fpt,%.5Fpt,%.5Fpt,%s,%.5Fpt",
+            t.hs*pt,
+            t.ls*pt,
+            t.rs*pt,
+            t.hi*pt,
+            t.ha,
+            t.pi*pt
+        )
+    else
+        context("0,0,0,0,0,0") -- for mp only
+    end
+end
+
+scanners.MPpardata = function() -- name
+    MPpardata(scanstring())
+end
+
+scanners.MPposset = function() -- name (special helper, used in backgrounds)
+    local name = scanstring()
+    local b = f_b_tag(name)
+    local e = f_e_tag(name)
+    local w = f_w_tag(name)
+    local p = f_p_tag(jobpositions.n(b))
+    MPpos(b) context(",") MPpos(e) context(",") MPpos(w) context(",") MPpos(p) context(",") MPpardata(p)
+end
+
+scanners.MPls = function() -- name
+    local jpi = collected[scanstring()]
+    if jpi then
+        context("%.5Fpt",jpi.ls*pt)
+    else
+        context("0pt")
+    end
+end
+
+scanners.MPrs = function() -- name
+    local jpi = collected[scanstring()]
+    if jpi then
+        context("%.5Fpt",jpi.rs*pt)
+    else
+        context("0pt")
+    end
+end
+
+local splitter = lpeg.tsplitat(",")
+
+scanners.MPplus = function() -- name n default
+    local jpi     = collected[scanstring()]
+    local n       = scaninteger()
+    local default = scanstring()
+    if jpi then
+        local e = jpi.e
+        if e then
+            local split = jpi.split
+            if not split then
+                split = lpegmatch(splitter,jpi.e)
+                jpi.split = split
+            end
+            context(split[n] or default)
+            return
+        end
+    end
+    context(default)
+end
+
+scanners.MPrest = function() -- name default
+    local jpi     = collected[scanstring()]
+    local default = scanstring()
+    context(jpi and jpi.e or default)
+end
+
+scanners.MPxywhd = function() -- name
+    local jpi = collected[scanstring()]
+    if jpi then
+        context("%.5Fpt,%.5Fpt,%.5Fpt,%.5Fpt,%.5Fpt",
+            jpi.x*pt,
+            jpi.y*pt,
+            jpi.w*pt,
+            jpi.h*pt,
+            jpi.d*pt
+        )
+    else
+        context("0,0,0,0,0") -- for mp only
+    end
+end
+
+local doif     = commands.doif
+local doifelse = commands.doifelse
+
+scanners.doifelseposition = function() -- name
+    doifelse(collected[scanstring()])
+end
+
+scanners.doifposition = function() -- name
+    doif(collected[scanstring()])
+end
+
+scanners.doifelsepositiononpage = function() -- name page -- probably always realpageno
+    local c = collected[scanstring()]
+    local p = scaninteger()
+    doifelse(c and c.p == p)
+end
+
+scanners.doifelseoverlapping = function() -- one two
+    doifelse(overlapping(scanstring(),scanstring()))
+end
+
+scanners.doifelsepositionsonsamepage = function() -- list
+    doifelse(onsamepage(scanstring()))
+end
+
+scanners.doifelsepositionsonthispage = function() -- list
+    doifelse(onsamepage(scanstring(),tostring(texgetcount("realpageno"))))
+end
+
+scanners.doifelsepositionsused = function()
+    doifelse(next(collected))
+end
+
+scanners.markregionbox = function() -- box
+    markregionbox(scaninteger())
+end
+
+scanners.setregionbox = function() -- box
+    setregionbox(scaninteger())
+end
+
+scanners.markregionboxtagged = function() -- box tag
+    markregionbox(scaninteger(),scanstring())
+end
+
+scanners.setregionboxtagged = function() -- box tag
+    setregionbox(scaninteger(),scanstring())
+end
+
+scanners.markregionboxcorrected = function() -- box tag
+    markregionbox(scaninteger(),scanstring(),true)
+end
+
+-- statistics (at least for the moment, when testing)
+
+statistics.register("positions", function()
+    local total = nofregular + nofusedregions + nofmissingregions
+    if total > 0 then
+        return format("%s collected, %s regulars, %s regions, %s unresolved regions",
+            total, nofregular, nofusedregions, nofmissingregions)
+    else
+        return nil
+    end
+end)