diff options
Diffstat (limited to 'Master/texmf-dist/tex/context/base/mkxl/core-env.lmt')
-rw-r--r-- | Master/texmf-dist/tex/context/base/mkxl/core-env.lmt | 213 |
1 files changed, 213 insertions, 0 deletions
diff --git a/Master/texmf-dist/tex/context/base/mkxl/core-env.lmt b/Master/texmf-dist/tex/context/base/mkxl/core-env.lmt new file mode 100644 index 00000000000..388e96787a0 --- /dev/null +++ b/Master/texmf-dist/tex/context/base/mkxl/core-env.lmt @@ -0,0 +1,213 @@ +if not modules then modules = { } end modules ['core-env'] = { + version = 1.001, + comment = "companion to core-env.mkiv", + author = "Hans Hagen, PRAGMA-ADE, Hasselt NL", + copyright = "PRAGMA ADE / ConTeXt Development Team", + license = "see context related readme files" +} + +-- maybe this will move to the context name space although the +-- plurals are unlikely to clash with future tex primitives +-- +-- if tex.modes['xxxx'] then .... else .... end + +local rawset = rawset + +local P, C, S, lpegmatch, patterns = lpeg.P, lpeg.C, lpeg.S, lpeg.match, lpeg.patterns + +local context = context +local ctxcore = context.core + +local texgetcount = tex.getcount +local texgetintegervalue = token.get_integer -- todo: in tex namespace + +local allocate = utilities.storage.allocate +local setmetatableindex = table.setmetatableindex +local setmetatablenewindex = table.setmetatablenewindex +local setmetatablecall = table.setmetatablecall + +local createtoken = token.create +local isdefined = tokens.isdefined + +texmodes = allocate { } tex.modes = texmodes +texsystemmodes = allocate { } tex.systemmodes = texsystemmodes +texconstants = allocate { } tex.constants = texconstants +texconditionals = allocate { } tex.conditionals = texconditionals +texifs = allocate { } tex.ifs = texifs +texisdefined = allocate { } tex.isdefined = texisdefined + +local modes = { } +local systemmodes = { } + +-- we could use the built-in tex.is[count|dimen|skip|toks] here but caching +-- at the lua end is not that bad (and we need more anyway) + +local cache = tokens.cache + +-- we can have a modes cache too + +local commandcodes = tokens.commands +local iftrue = cache["iftrue"].index + +-- local dimencode = cache["scratchdimen"] .command -- tokens.commands.register_dimen +-- local countcode = cache["scratchcounter"].command -- tokens.commands.register_int +-- local tokencode = cache["scratchtoks"] .command -- tokens.commands.register_toks +-- local skipcode = cache["scratchskip"] .command -- tokens.commands.register_glue +-- local muskipcode = cache["scratchmuskip"] .command -- tokens.commands.register_mu_glue +-- local conditioncode = cache["iftrue"] .command -- tokens.commands.if_test + +-- local types = { +-- [dimencode] = "dimen", +-- [countcode] = "count", +-- [tokencode] = "token", +-- [skipcode] = "skip", +-- [muskipcode] = "muskip", +-- -- [attributecode] = "attribute", +-- [conditioncode] = "condition" +-- } + +local dimencode = commandcodes.register_dimen -- cache["scratchdimen"] .command -- tokens.commands.register_dimen +local countcode = commandcodes.register_int -- cache["scratchcounter"].command -- tokens.commands.register_int +local tokencode = commandcodes.register_toks -- ["scratchtoks"] .command -- tokens.commands.register_toks +local skipcode = commandcodes.register_glue -- cache["scratchskip"] .command -- tokens.commands.register_glue +local muskipcode = commandcodes.register_mu_glue -- cache["scratchmuskip"] .command -- tokens.commands.register_mu_glue +local conditioncode = commandcodes.if_test -- cache["iftrue"] .command -- tokens.commands.if_test +local integercode = commandcodes.integer + +local types = { + [dimencode] = "dimen", + [countcode] = "count", + [tokencode] = "token", + [skipcode] = "skip", + [muskipcode] = "muskip", + -- [attributecode] = "attribute", + [conditioncode] = "condition", + [integercode] = "integer", +} + +setmetatableindex(texmodes, function(t,k) + local m = systemmodes[k] + if not m then + local n = "mode>" .. k + m = function() return texgetintegervalue(n) == 1 end + rawset(modes,k,m) + end + return m() +end) + +setmetatableindex(texsystemmodes, function(t,k) + local m = systemmodes[k] + if not m then + local n = "mode>*" .. k + m = function() return texgetintegervalue(n) == 1 end + rawset(modes,k,m) + end + return m() +end) + +-- also a call method + +context.settrialtypesettingmethod(function() return texsystemmodes.trialtypesetting end) + +setmetatablenewindex(texmodes, function(t,k) report_mode("you cannot set the %s named %a this way","mode", k) end) +setmetatablenewindex(texsystemmodes, function(t,k) report_mode("you cannot set the %s named %a this way","systemmode", k) end) +setmetatablenewindex(texconstants, function(t,k) report_mode("you cannot set the %s named %a this way","constant", k) end) +setmetatablenewindex(texconditionals, function(t,k) report_mode("you cannot set the %s named %a this way","conditional",k) end) +setmetatablenewindex(texifs, function(t,k) end) + +-- if we really need performance we can have a dedicated cache for each +-- kind of variable ... maybe we no longer have to cache anyway (in lmtx) + +setmetatableindex(texconstants, function(t,k) + -- return cache[k].command == countcode and texgetcount(k) or 0 + return cache[k].command == integercode and texgetintegervalue(k) or 0 +end) + +setmetatableindex(texconditionals, function(t,k) -- 0 == true + -- return cache[k].command == countcode and texgetcount(k) == 0 + return cache[k].command == integercode and texgetintegervalue(k) == 0 +end) + +setmetatableindex(texifs, function(t,k) + local c = cache[k] + return c.command == conditioncode and c.index == iftrue +end) + +tex.isdefined = isdefined + +function tex.isdimen(name) + local hit = cache[name] + return hit.command == dimencode and hit.index or true +end + +function tex.iscount(name) + local hit = cache[name] + return hit.command == countcode and hit.index or true +end + +function tex.istoken(name) + local hit = cache[name] + return hit.command == tokencode and hit.index or true +end + +function tex.isskip(name) + local hit = cache[name] + return hit.command == skipcode and hit.index or true +end + +function tex.ismuskip(name) + local hit = cache[name] + return hit.command == muskipcode and hit.index or true +end + +function tex.type(name) + return types[cache[name].command] or "macro" +end + +function context.setconditional(name,value) + if value then + ctxcore.settruevalue(name) + else + ctxcore.setfalsevalue(name) + end +end + +function context.setmode(name,value) + if value then + ctxcore.setmode(name) + else + ctxcore.resetmode(name) + end +end + +function context.setsystemmode(name,value) + if value then + ctxcore.setsystemmode(name) + else + ctxcore.resetsystemmode(name) + end +end + +context.modes = texmodes +context.systemmodes = texsystemmodes +context.conditionals = texconditionals +-------.constants = texconstants +-------.ifs = texifs + +local sep = S("), ") +local str = C((1-sep)^1) +local tag = P("(") * C((1-S(")" ))^1) * P(")") +local arg = P("(") * C((1-S("){"))^1) * P("{") * C((1-P("}"))^0) * P("}") * P(")") + +local pattern = ( + P("lua") * tag / ctxcore.luasetup + + P("xml") * arg / ctxcore.setupwithargument -- or xmlw as xmlsetup has swapped arguments + + (P("tex") * tag + str) / ctxcore.texsetup + + sep^1 +)^1 + +interfaces.implement { + name = "autosetups", + actions = function(str) lpegmatch(pattern,str) end, + arguments = "string" +} |