summaryrefslogtreecommitdiff
path: root/Master/texmf-dist/tex/context/base/mkxl/syst-aux.lmt
diff options
context:
space:
mode:
Diffstat (limited to 'Master/texmf-dist/tex/context/base/mkxl/syst-aux.lmt')
-rw-r--r--Master/texmf-dist/tex/context/base/mkxl/syst-aux.lmt782
1 files changed, 782 insertions, 0 deletions
diff --git a/Master/texmf-dist/tex/context/base/mkxl/syst-aux.lmt b/Master/texmf-dist/tex/context/base/mkxl/syst-aux.lmt
new file mode 100644
index 00000000000..726fd4d326a
--- /dev/null
+++ b/Master/texmf-dist/tex/context/base/mkxl/syst-aux.lmt
@@ -0,0 +1,782 @@
+ if not modules then modules = { } end modules ['syst-aux'] = {
+ version = 1.001,
+ comment = "companion to syst-aux.mkiv",
+ author = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
+ copyright = "PRAGMA ADE / ConTeXt Development Team",
+ license = "see context related readme files"
+}
+
+-- slower than lpeg:
+--
+-- utfmatch(str,"(.?)(.*)$")
+-- utf.sub(str,1,1)
+
+local tonumber, next, type = tonumber, next, type
+local utfsub = utf.sub
+local P, S, R, C, Cc, Cs, Carg, lpegmatch = lpeg.P, lpeg.S, lpeg.R, lpeg.C, lpeg.Cc, lpeg.Cs, lpeg.Carg, lpeg.match
+local find, formatters = string.find, string.formatters
+
+local context = context
+local implement = interfaces.implement
+local setmacro = interfaces.setmacro
+local setcatcode = tex.setcatcode
+local texget = tex.get
+local utf8character = lpeg.patterns.utf8character
+local settings_to_array = utilities.parsers.settings_to_array
+local settings_to_set = utilities.parsers.settings_to_set
+
+local pattern = C(utf8character^-1) * C(P(1)^0)
+
+implement {
+ name = "getfirstcharacter",
+ arguments = "string",
+ actions = function(str)
+ local first, rest = lpegmatch(pattern,str)
+ setmacro("firstcharacter",first)
+ setmacro("remainingcharacters",rest)
+ end
+}
+
+implement {
+ name = "thefirstcharacter",
+ arguments = "string",
+ actions = function(str)
+ local first, rest = lpegmatch(pattern,str)
+ context(first)
+ end
+}
+
+implement {
+ name = "theremainingcharacters",
+ arguments = "string",
+ actions = function(str)
+ local first, rest = lpegmatch(pattern,str)
+ context(rest)
+ end
+}
+
+local pattern = C(utf8character^-1)
+local ctx_doifelse = commands.doifelse
+
+implement {
+ name = "doifelsefirstchar",
+ arguments = "2 strings",
+ actions = function(str,chr)
+ ctx_doifelse(lpegmatch(pattern,str) == chr)
+ end
+}
+
+implement {
+ name = "getsubstring",
+ arguments = "3 strings",
+ actions = function(str,first,last)
+ context(utfsub(str,tonumber(first),tonumber(last)))
+ end
+}
+
+-- function commands.addtocommalist(list,item)
+-- if list == "" then
+-- context(item)
+-- else
+-- context("%s,%s",list,item) -- using tex.print is some 10% faster
+-- end
+-- end
+--
+-- function commands.removefromcommalist(list,item)
+-- if list == "" then
+-- context(item)
+-- else
+-- -- okay, using a proper lpeg is probably faster
+-- -- we could also check for #l = 1
+-- local l = settings_to_array(list)
+-- local t, n = { }
+-- for i=1,#l do
+-- if l[i] ~= item then
+-- n = n + 1
+-- t[n] = item
+-- end
+-- end
+-- if n == 0 then
+-- context(item)
+-- else
+-- context(concat(list,","))
+-- end
+-- end
+-- end
+
+local pattern = (C((1-P("%"))^1) * Carg(1)) / function(n,d)
+ return formatters["%.0fsp"](d * tonumber(n)/100) end * P("%") * P(-1) -- .0 ?
+
+-- percentageof("10%",65536*10)
+
+implement {
+ name = "percentageof",
+ arguments = { "string", "dimen" },
+ actions = function(str,dim)
+ context(lpegmatch(pattern,str,1,dim) or str)
+ end
+}
+
+-- \gdef\setpercentdimen#1#2%
+-- {#1=\ctxcommand{percentageof("#2",\number#1)}\relax}
+
+local space = P(" ") / ""
+local spaces = P(" ")^0 / ""
+local nohash = 1 - P("#")
+local digit = R("09")
+local double = P("##") / "#"
+local single = P("#")
+local sentinel = spaces * (nohash^1 / "\\%0")
+local whatever = S("+-/*_^=:") + digit
+local sargument = (single * digit)^1
+local dargument = (double * digit)^1
+local swhatever = (single * whatever)^1
+local dwhatever = (double * whatever)^1
+
+-- different ones:
+
+local space = P(" ")
+local spaces = space^0
+
+-- see syst-aux.lua for historic variants
+
+local global = nil
+local protected = nil
+local permanent = nil
+local expanded = nil
+local mutable = nil
+local immutable = nil
+local optional = nil
+local tolerant = nil
+local instance = nil
+local frozen = nil
+local csname = nil
+local rest = nil
+
+local function catcodes_s()
+ setcatcode(32,10) -- space
+ setcatcode(13, 5) -- endofline
+end
+
+local function catcodes_n()
+ setcatcode(32, 9) -- ignore
+ setcatcode(13, 9) -- ignore
+end
+
+local function oldoption(s)
+ if optional > 1 then
+ optional = optional - 1
+ return s .. "#*"
+ else
+ return s
+ end
+end
+
+local option = (
+ P("single") * Cc(1)
+ + P("double") * Cc(2)
+ + P("triple") * Cc(3)
+ + P("quadruple") * Cc(4)
+ + P("quintuple") * Cc(5)
+ + P("sixtuple")
+ ) * (P("empty") + P("argument"))
+
+local pattern = (
+ (
+ spaces * (
+ ( P("spaces") * space / catcodes_s )
+ + ( P("nospaces") * space / catcodes_n )
+ + ( P("global") * space / function() global = true end)
+ + ( P("protected") * space / function() protected = true end)
+ + ( P("permanent") * space / function() permanent = true end)
+ + ( P("expanded") * space / function() expanded = true end)
+ + ( P("tolerant") * space / function() tolerant = true end)
+ + ( P("instance") * space / function() instance = true end)
+ + ( P("frozen") * space / function() frozen = true end)
+ + ( P("mutable") * space / function() mutable = true end)
+ + ( P("immutable") * space / function() immutable = true end)
+ + ( P("unexpanded") * space / function() protected = true end)
+ + ( option * space / function(s) tolerant = true
+ optional = s end)
+ )
+ )^0
+ * spaces * ( C((1-S(" #["))^1) )
+ * spaces * Cs(
+ (Cs(P("[") * dargument * P("]")) / oldoption + dwhatever)^1 * sentinel^-1 * double^-1
+ + (Cs(P("[") * sargument * P("]")) / oldoption + swhatever)^1 * sentinel^-1 * single^-1
+ + sentinel^-1 * (double+single)^-1
+ )
+)
+
+local ctx_dostarttexdefinition = context.dostarttexdefinition
+
+local function texdefinition_one(str)
+ global = false
+ protected = false
+ permanent = false
+ expanded = false
+ mutable = false
+ immutable = false
+ optional = 0
+ tolerant = false
+ instance = false
+ frozen = false
+ csname, rest = lpegmatch(pattern,str)
+ ctx_dostarttexdefinition()
+end
+
+local function texdefinition_two()
+ context (
+ (tolerant and [[\tolerant]] or "") ..
+ (frozen and [[\frozen]] or "") ..
+ (protected and [[\protected]] or "") ..
+ (permanent and [[\permanent]] or "") ..
+ (instance and [[\instance]] or "") ..
+ (mutable and [[\mutable]] or "") ..
+ (immutable and [[\immutable]] or "") ..
+-- [[\expandafter]] .. (global and (expanded and [[\xdef]] or [[\gdef]]) or (expanded and [[\edef]] or [[\def]])) ..
+-- [[\csname ]] .. csname .. [[\endcsname ]] ..
+ (global and (expanded and [[\xdefcsname ]] or [[\gdefcsname ]]) or (expanded and [[\edefcsname ]] or [[\defcsname ]])) ..
+ csname .. [[\endcsname ]] ..
+ rest
+ )
+end
+
+implement { name = "texdefinition_one", actions = texdefinition_one, scope = "private", arguments = "string" }
+implement { name = "texdefinition_two", actions = texdefinition_two, scope = "private" }
+
+do
+
+ -- Quite probably we don't yet have characters loaded so we delay some
+ -- aliases.
+
+ local _lower_, _upper_, _strip_
+
+ _lower_ = function(s)
+ if characters and characters.lower then
+ _lower_ = characters.lower
+ return _lower_(s)
+ end
+ return string.lower(s)
+ end
+
+ _upper_ = function(s)
+ if characters and characters.upper then
+ _upper_ = characters.upper
+ return _upper_(s)
+ end
+ return string.upper(s)
+ end
+
+ _strip_ = function(s)
+ -- or utf.strip
+ if string.strip then
+ _strip_ = string.strip
+ return _strip_(s)
+ end
+ return s
+ end
+
+ local function lower(s) context(_lower_(s)) end
+ local function upper(s) context(_upper_(s)) end
+ local function strip(s) context(_strip_(s)) end
+
+ implement { name = "upper", arguments = "string", actions = upper }
+ implement { name = "lower", arguments = "string", actions = lower }
+ implement { name = "strip", arguments = "string", actions = strip }
+
+end
+
+implement {
+ name = "converteddimen",
+ arguments = { "dimen", "string" },
+ actions = function(dimen,unit)
+ context(number.todimen(dimen,unit or "pt","%0.5f")) -- no unit appended (%F)
+ end
+}
+
+-- where, not really the best spot for this:
+
+implement {
+ name = "immediatemessage",
+ public = true,
+ arguments = { "'message'", "string" },
+ actions = logs.status
+}
+
+implement {
+ name = "writestring",
+ public = true,
+ protected = true,
+ arguments = "string",
+ actions = function (s)
+ logs.writer(s,"\n")
+ end,
+}
+
+implement {
+ name = "writeline",
+ public = true,
+ protected = true,
+ actions = logs.newline,
+}
+
+implement {
+ name = "resettimer",
+ actions = function()
+ statistics.resettiming("whatever")
+ statistics.starttiming("whatever")
+ end
+}
+
+implement {
+ name = "benchmarktimer",
+ actions = function()
+ statistics.benchmarktimer("whatever")
+ end
+}
+
+implement {
+ name = "elapsedtime",
+ actions = function()
+ statistics.stoptiming("whatever")
+ context(statistics.elapsedtime("whatever"))
+ end
+}
+
+implement {
+ name = "elapsedsteptime",
+ arguments = "integer",
+ actions = function(n)
+ statistics.stoptiming("whatever")
+ local t = statistics.elapsed("whatever")/(n > 0 and n or 1)
+ if t > 0 then
+ context("%0.9f",t)
+ else
+ context(0)
+ end
+ end
+}
+
+local accuracy = table.setmetatableindex(function(t,k)
+ local v = formatters["%0." ..k .. "f"]
+ t[k] = v
+ return v
+end)
+
+implement {
+ name = "rounded",
+ arguments = "integer",
+ actions = function(n,m) context(accuracy[n](m)) end
+}
+
+-- not faster but just less tracing:
+
+local ctx_protected_cs = context.protected.cs -- more efficient
+
+local ctx_firstoftwoarguments = ctx_protected_cs.firstoftwoarguments
+local ctx_secondoftwoarguments = ctx_protected_cs.secondoftwoarguments
+local ctx_firstofoneargument = ctx_protected_cs.firstofoneargument
+local ctx_gobbleoneargument = ctx_protected_cs.gobbleoneargument
+
+context.firstoftwoarguments = ctx_firstoftwoarguments
+context.secondoftwoarguments = ctx_secondoftwoarguments
+context.firstofoneargument = ctx_firstofoneargument
+context.gobbleoneargument = ctx_gobbleoneargument
+
+local ctx_iftrue = context.iftrue
+local ctx_iffalse = context.iffalse
+
+local hash = utilities.parsers.hashes.settings_to_set
+
+local function doifelsecommon(a,b)
+ if a == b then
+ setmacro("commalistelement",a)
+ if a == "" then
+ ctx_secondoftwoarguments()
+ else
+ ctx_firstoftwoarguments()
+ end
+ return
+ end
+ local ba = find(a,",",1,true)
+ local bb = find(b,",",1,true)
+ if ba and bb then
+ local ha = hash[a]
+ local hb = hash[b]
+ -- local ha = settings_to_set(a)
+ -- local hb = settings_to_set(b)
+ for k in next, ha do
+ if hb[k] then
+ setmacro("commalistelement",k)
+ ctx_firstoftwoarguments()
+ return
+ end
+ end
+ elseif ba then
+ if hash[a][b] then
+ -- if settings_to_set(a)[b] then
+ setmacro("commalistelement",b)
+ ctx_firstoftwoarguments()
+ return
+ end
+ elseif bb then
+ if hash[b][a] then
+ -- if settings_to_set(b)[a] then
+ setmacro("commalistelement",a)
+ ctx_firstoftwoarguments()
+ return
+ end
+ end
+ setmacro("commalistelement","")
+ ctx_secondoftwoarguments()
+end
+
+local function doifcommon(a,b)
+ if a == b then
+ setmacro("commalistelement",a)
+ if a == "" then
+ ctx_gobbleoneargument()
+ else
+ ctx_firstofoneargument()
+ end
+ return
+ end
+ local ba = find(a,",",1,true)
+ local bb = find(b,",",1,true)
+ if ba and bb then
+ local ha = hash[a]
+ local hb = hash[b]
+ -- local ha = settings_to_set(a)
+ -- local hb = settings_to_set(b)
+ for k in next, ha do
+ if hb[k] then
+ setmacro("commalistelement",k)
+ ctx_firstofoneargument()
+ return
+ end
+ end
+ elseif ba then
+ if hash[a][b] then
+ -- if settings_to_set(a)[b] then
+ setmacro("commalistelement",b)
+ ctx_firstofoneargument()
+ return
+ end
+ elseif bb then
+ if hash[b][a] then
+ -- if settings_to_set(b)[a] then
+ setmacro("commalistelement",a)
+ ctx_firstofoneargument()
+ return
+ end
+ end
+ setmacro("commalistelement","")
+ ctx_gobbleoneargument()
+end
+
+local function doifnotcommon(a,b)
+ if a == b then
+ setmacro("commalistelement",a)
+ if a == "" then
+ ctx_firstofoneargument()
+ else
+ ctx_gobbleoneargument()
+ end
+ return
+ end
+ local ba = find(a,",",1,true)
+ local bb = find(b,",",1,true)
+ if ba and bb then
+ local ha = hash[a]
+ local hb = hash[b]
+ -- local ha = settings_to_set(a)
+ -- local hb = settings_to_set(b)
+ for k in next, ha do
+ if hb[k] then
+ setmacro("commalistelement",k)
+ ctx_gobbleoneargument()
+ return
+ end
+ end
+ elseif ba then
+ if hash[a][b] then
+ -- if settings_to_set(a)[b] then
+ setmacro("commalistelement",b)
+ ctx_gobbleoneargument()
+ return
+ end
+ elseif bb then
+ if hash[b][a] then
+ -- if settings_to_set(b)[a] then
+ setmacro("commalistelement",a)
+ ctx_gobbleoneargument()
+ return
+ end
+ end
+ setmacro("commalistelement","")
+ ctx_firstofoneargument()
+end
+
+-- local function hascommonargumentcondition(a,b)
+-- if a == b then
+-- setmacro("commalistelement",a)
+-- if a == "" then
+-- ctx_iffalse()
+-- else
+-- ctx_iftrue()
+-- end
+-- return
+-- end
+-- local ba = find(a,",",1,true)
+-- local bb = find(b,",",1,true)
+-- if ba and bb then
+-- local ha = hash[a]
+-- local hb = hash[b]
+-- for k in next, ha do
+-- if hb[k] then
+-- setmacro("commalistelement",k)
+-- ctx_iftrue()
+-- return
+-- end
+-- end
+-- elseif ba then
+-- if hash[a][b] then
+-- setmacro("commalistelement",b)
+-- ctx_iftrue()
+-- return
+-- end
+-- elseif bb then
+-- if hash[b][a] then
+-- setmacro("commalistelement",a)
+-- ctx_iftrue()
+-- return
+-- end
+-- end
+-- setmacro("commalistelement","")
+-- ctx_iffalse()
+-- end
+
+local function doifelseinset(a,b)
+ if a == b then
+ setmacro("commalistelement",a)
+ if a == "" then
+ ctx_secondoftwoarguments()
+ else
+ ctx_firstoftwoarguments()
+ end
+ return
+ end
+ local bb = find(b,",",1,true)
+ if bb then
+ if hash[b][a] then
+ -- if settings_to_set(b)[a] then
+ setmacro("commalistelement",a)
+ ctx_firstoftwoarguments()
+ return
+ end
+ end
+ setmacro("commalistelement","")
+ ctx_secondoftwoarguments()
+end
+
+local function doifinset(a,b)
+ if a == b then
+ setmacro("commalistelement",a)
+ if a == "" then
+ ctx_gobbleoneargument()
+ else
+ ctx_firstofoneargument()
+ end
+ return
+ end
+ local bb = find(b,",",1,true)
+ if bb then
+ if hash[b][a] then
+ -- if settings_to_set(b)[a] then
+ setmacro("commalistelement",a)
+ ctx_firstofoneargument()
+ return
+ end
+ end
+ setmacro("commalistelement","")
+ ctx_gobbleoneargument()
+end
+
+local function doifnotinset(a,b)
+ if a == b then
+ setmacro("commalistelement",a)
+ if a == "" then
+ ctx_firstofoneargument()
+ else
+ ctx_gobbleoneargument()
+ end
+ return
+ end
+ local bb = find(b,",",1,true)
+ if bb then
+ if hash[b][a] then
+ -- if settings_to_set(b)[a] then
+ setmacro("commalistelement",a)
+ ctx_gobbleoneargument()
+ return
+ end
+ end
+ setmacro("commalistelement","")
+ ctx_firstofoneargument()
+end
+
+implement {
+ name = "doifelsecommon",
+ actions = doifelsecommon,
+ arguments = "2 strings",
+}
+
+implement {
+ name = "doifcommon",
+ actions = doifcommon,
+ arguments = "2 strings",
+}
+
+implement {
+ name = "doifnotcommon",
+ actions = doifnotcommon,
+ arguments = "2 strings",
+}
+
+-- implement {
+-- name = "hascommonargumentcondition",
+-- actions = hascommonargumentcondition,
+-- arguments = "2 strings",
+-- arguments = { "argument", "argument" },
+-- }
+
+implement {
+ name = "doifelseinset",
+ actions = doifelseinset,
+ arguments = "2 strings",
+-- arguments = { "argument", "argument" },
+}
+
+implement {
+ name = "doifinset",
+ actions = doifinset,
+ arguments = "2 strings",
+}
+
+implement {
+ name = "doifnotinset",
+ actions = doifnotinset,
+ arguments = "2 strings",
+}
+
+-- done elsewhere:
+--
+-- local function firstinset(a)
+-- local aa = hash[a]
+-- context(aa and aa[1] or a)
+-- end
+--
+-- implement {
+-- name = "firstinset",
+-- actions = firstinset,
+-- arguments = "string",
+-- private = false,
+-- }
+
+-- implement {
+-- name = "stringcompare",
+-- arguments = "2 strings",
+-- actions = function(a,b)
+-- context((a == b and 0) or (a > b and 1) or -1)
+-- end
+-- }
+--
+-- implement {
+-- name = "doifelsestringafter",
+-- arguments = "2 strings",
+-- actions = function(a,b)
+-- ctx_doifelse((a == b and 0) or (a > b and 1) or -1)
+-- end
+-- }
+--
+-- implement {
+-- name = "doifelsestringbefore",
+-- arguments = "2 strings",
+-- actions = function(a,b)
+-- ctx_doifelse((a == b and 0) or (a < b and -1) or 1)
+-- end
+-- }
+
+-- implement { -- not faster than addtocommalist
+-- name = "additemtolist", -- unique
+-- arguments = "2 strings",
+-- actions = function(l,s)
+-- if l == "" or s == l then
+-- -- s = s
+-- elseif find("," .. l .. ",","," .. s .. ",") then
+-- s = l
+-- else
+-- s = l .. "," .. s
+-- end
+-- context(s)
+-- end
+-- }
+
+local bp = number.dimenfactors.bp
+
+implement {
+ name = "tobigpoints",
+ actions = function(d) context("%.5F",bp * d) end,
+ arguments = "dimension",
+}
+
+implement {
+ name = "towholebigpoints",
+ actions = function(d) context("%r",bp * d) end,
+ arguments = "dimension",
+}
+
+-- for now here:
+
+local function getshape(s)
+ local t = texget(s)
+ local n = t and #t or 0
+ context(n)
+ if n > 0 then
+ for i=1,n do
+ local ti = t[i]
+ if type(ti) == "table" then
+ context(" %isp %isp",ti[1],ti[2])
+ else
+ context(" %i",ti)
+ end
+ end
+ end
+end
+
+implement {
+ name = "getparshape",
+ public = true,
+ actions = function() getshape("parshape") end,
+}
+implement {
+ name = "getclubpenalties",
+ public = true,
+ actions = function() getshape("clubpenalties") end,
+}
+implement {
+ name = "getinterlinepenalties",
+ public = true,
+ actions = function() getshape("interlinepenalties") end,
+ }
+implement {
+ name = "getdisplaywidowpenalties",
+ public = true,
+ actions = function() getshape("displaywidowpenalties") end,
+}
+implement {
+ name = "getwidowpenalties",
+ public = true,
+ actions = function() getshape("widowpenalties") end,
+}