From f46fe99c7c361a66c68987b22d235fe9f793fad6 Mon Sep 17 00:00:00 2001 From: Hans Hagen Date: Wed, 17 Jun 2020 19:59:19 +0200 Subject: 2020-06-17 18:59:00 --- .../lexers/data/scite-context-data-context.lua | 2 +- .../context/scite-context-data-context.properties | 3 +- .../context/data/scite-context-data-context.lua | 2 +- .../context/syntaxes/context-syntax-tex.json | 2 +- doc/context/documents/general/manuals/evenmore.pdf | Bin 1509228 -> 1607905 bytes .../documents/general/manuals/luametatex.pdf | Bin 1229180 -> 1229175 bytes .../general/manuals/evenmore/evenmore-parsing.tex | 425 +++++++++++++++++++ .../general/manuals/evenmore/evenmore-tokens.tex | 460 +++++++++++++++++++++ .../sources/general/manuals/evenmore/evenmore.tex | 5 +- .../general/manuals/luametatex/luametatex-tex.tex | 13 + .../general/manuals/luametatex/luametatex.tex | 7 - tex/context/base/mkii/cont-new.mkii | 2 +- tex/context/base/mkii/context.mkii | 2 +- tex/context/base/mkiv/cont-new.mkiv | 2 +- tex/context/base/mkiv/context.mkiv | 2 +- tex/context/base/mkiv/context.mkxl | 2 +- tex/context/base/mkiv/driv-shp.lua | 8 +- tex/context/base/mkiv/file-ini.mkvi | 54 ++- tex/context/base/mkiv/lxml-ini.lua | 230 ++++++----- tex/context/base/mkiv/lxml-ini.mkiv | 197 ++++----- tex/context/base/mkiv/lxml-tex.lua | 10 +- tex/context/base/mkiv/math-ali.mkiv | 4 +- tex/context/base/mkiv/mult-low.lua | 2 +- tex/context/base/mkiv/pack-rul.mkxl | 30 -- tex/context/base/mkiv/spac-flr.mkiv | 17 + tex/context/base/mkiv/status-files.pdf | Bin 0 -> 27767 bytes tex/context/base/mkiv/status-lua.pdf | Bin 0 -> 253280 bytes tex/context/base/mkiv/syst-aux.mkiv | 4 +- tex/context/base/mkiv/syst-aux.mkxl | 4 + tex/context/base/mkiv/syst-fnt.mkiv | 7 +- tex/context/base/mkiv/toks-ini.lua | 2 +- tex/context/base/mkiv/trac-vis.lua | 8 +- tex/context/base/mkiv/type-ini.mklx | 7 + tex/generic/context/luatex/luatex-fonts-merged.lua | 2 +- 34 files changed, 1202 insertions(+), 313 deletions(-) create mode 100644 doc/context/sources/general/manuals/evenmore/evenmore-parsing.tex create mode 100644 doc/context/sources/general/manuals/evenmore/evenmore-tokens.tex create mode 100644 tex/context/base/mkiv/status-files.pdf create mode 100644 tex/context/base/mkiv/status-lua.pdf diff --git a/context/data/scite/context/lexers/data/scite-context-data-context.lua b/context/data/scite/context/lexers/data/scite-context-data-context.lua index bec15067d..3e243b290 100644 --- a/context/data/scite/context/lexers/data/scite-context-data-context.lua +++ b/context/data/scite/context/lexers/data/scite-context-data-context.lua @@ -1,4 +1,4 @@ return { - ["constants"]={ "zerocount", "minusone", "minustwo", "plusone", "plustwo", "plusthree", "plusfour", "plusfive", "plussix", "plusseven", "pluseight", "plusnine", "plusten", "plussixteen", "plusfifty", "plushundred", "plusonehundred", "plustwohundred", "plusfivehundred", "plusthousand", "plustenthousand", "plustwentythousand", "medcard", "maxcard", "maxcardminusone", "zeropoint", "onepoint", "halfapoint", "onebasepoint", "maxcount", "maxdimen", "scaledpoint", "thousandpoint", "points", "halfpoint", "zeroskip", "zeromuskip", "onemuskip", "pluscxxvii", "pluscxxviii", "pluscclv", "pluscclvi", "normalpagebox", "directionlefttoright", "directionrighttoleft", "endoflinetoken", "outputnewlinechar", "emptytoks", "empty", "undefined", "voidbox", "emptybox", "emptyvbox", "emptyhbox", "bigskipamount", "medskipamount", "smallskipamount", "fmtname", "fmtversion", "texengine", "texenginename", "texengineversion", "texenginefunctionality", "luatexengine", "pdftexengine", "xetexengine", "unknownengine", "contextformat", "contextversion", "contextkind", "contextlmtxmode", "contextmark", "mksuffix", "activecatcode", "bgroup", "egroup", "endline", "conditionaltrue", "conditionalfalse", "attributeunsetvalue", "uprotationangle", "rightrotationangle", "downrotationangle", "leftrotationangle", "inicatcodes", "ctxcatcodes", "texcatcodes", "notcatcodes", "txtcatcodes", "vrbcatcodes", "prtcatcodes", "nilcatcodes", "luacatcodes", "tpacatcodes", "tpbcatcodes", "xmlcatcodes", "ctdcatcodes", "escapecatcode", "begingroupcatcode", "endgroupcatcode", "mathshiftcatcode", "alignmentcatcode", "endoflinecatcode", "parametercatcode", "superscriptcatcode", "subscriptcatcode", "ignorecatcode", "spacecatcode", "lettercatcode", "othercatcode", "activecatcode", "commentcatcode", "invalidcatcode", "tabasciicode", "newlineasciicode", "formfeedasciicode", "endoflineasciicode", "endoffileasciicode", "commaasciicode", "spaceasciicode", "periodasciicode", "hashasciicode", "dollarasciicode", "commentasciicode", "ampersandasciicode", "colonasciicode", "backslashasciicode", "circumflexasciicode", "underscoreasciicode", "leftbraceasciicode", "barasciicode", "rightbraceasciicode", "tildeasciicode", "delasciicode", "leftparentasciicode", "rightparentasciicode", "lessthanasciicode", "morethanasciicode", "doublecommentsignal", "atsignasciicode", "exclamationmarkasciicode", "questionmarkasciicode", "doublequoteasciicode", "singlequoteasciicode", "forwardslashasciicode", "primeasciicode", "hyphenasciicode", "activemathcharcode", "activetabtoken", "activeformfeedtoken", "activeendoflinetoken", "batchmodecode", "nonstopmodecode", "scrollmodecode", "errorstopmodecode", "bottomlevelgroupcode", "simplegroupcode", "hboxgroupcode", "adjustedhboxgroupcode", "vboxgroupcode", "vtopgroupcode", "aligngroupcode", "noaligngroupcode", "outputgroupcode", "mathgroupcode", "discretionarygroupcode", "insertgroupcode", "vcentergroupcode", "mathabovegroupcode", "mathchoicegroupcode", "semisimplegroupcode", "mathshiftgroupcode", "mathleftgroupcode", "vadjustgroupcode", "charnodecode", "hlistnodecode", "vlistnodecode", "rulenodecode", "insertnodecode", "marknodecode", "adjustnodecode", "ligaturenodecode", "discretionarynodecode", "whatsitnodecode", "mathnodecode", "gluenodecode", "kernnodecode", "penaltynodecode", "unsetnodecode", "mathsnodecode", "charifcode", "catifcode", "numifcode", "dimifcode", "oddifcode", "vmodeifcode", "hmodeifcode", "mmodeifcode", "innerifcode", "voidifcode", "hboxifcode", "vboxifcode", "xifcode", "eofifcode", "trueifcode", "falseifcode", "caseifcode", "definedifcode", "csnameifcode", "fontcharifcode", "fontslantperpoint", "fontinterwordspace", "fontinterwordstretch", "fontinterwordshrink", "fontexheight", "fontemwidth", "fontextraspace", "slantperpoint", "mathexheight", "mathemwidth", "interwordspace", "interwordstretch", "interwordshrink", "exheight", "emwidth", "extraspace", "mathsupdisplay", "mathsupnormal", "mathsupcramped", "mathsubnormal", "mathsubcombined", "mathaxisheight", "muquad", "startmode", "stopmode", "startnotmode", "stopnotmode", "startmodeset", "stopmodeset", "doifmode", "doifelsemode", "doifmodeelse", "doifnotmode", "startmodeset", "stopmodeset", "startallmodes", "stopallmodes", "startnotallmodes", "stopnotallmodes", "doifallmodes", "doifelseallmodes", "doifallmodeselse", "doifnotallmodes", "startenvironment", "stopenvironment", "environment", "startcomponent", "stopcomponent", "component", "startproduct", "stopproduct", "product", "startproject", "stopproject", "project", "starttext", "stoptext", "startnotext", "stopnotext", "startdocument", "stopdocument", "documentvariable", "unexpandeddocumentvariable", "setupdocument", "presetdocument", "doifelsedocumentvariable", "doifdocumentvariableelse", "doifdocumentvariable", "doifnotdocumentvariable", "startmodule", "stopmodule", "usemodule", "usetexmodule", "useluamodule", "setupmodule", "currentmoduleparameter", "moduleparameter", "everystarttext", "everystoptext", "startTEXpage", "stopTEXpage", "enablemode", "disablemode", "preventmode", "definemode", "globalenablemode", "globaldisablemode", "globalpreventmode", "pushmode", "popmode", "typescriptone", "typescripttwo", "typescriptthree", "mathsizesuffix", "mathordcode", "mathopcode", "mathbincode", "mathrelcode", "mathopencode", "mathclosecode", "mathpunctcode", "mathalphacode", "mathinnercode", "mathnothingcode", "mathlimopcode", "mathnolopcode", "mathboxcode", "mathchoicecode", "mathaccentcode", "mathradicalcode", "constantnumber", "constantnumberargument", "constantdimen", "constantdimenargument", "constantemptyargument", "continueifinputfile", "luastringsep", "!!bs", "!!es", "lefttorightmark", "righttoleftmark", "lrm", "rlm", "bidilre", "bidirle", "bidipop", "bidilro", "bidirlo", "breakablethinspace", "nobreakspace", "nonbreakablespace", "narrownobreakspace", "zerowidthnobreakspace", "ideographicspace", "ideographichalffillspace", "twoperemspace", "threeperemspace", "fourperemspace", "fiveperemspace", "sixperemspace", "figurespace", "punctuationspace", "hairspace", "enquad", "emquad", "zerowidthspace", "zerowidthnonjoiner", "zerowidthjoiner", "zwnj", "zwj", "optionalspace", "asciispacechar", "softhyphen", "Ux", "eUx", "Umathaccents", "parfillleftskip", "parfillrightskip", "startlmtxmode", "stoplmtxmode", "startmkivmode", "stopmkivmode", "wildcardsymbol" }, + ["constants"]={ "zerocount", "minusone", "minustwo", "plusone", "plustwo", "plusthree", "plusfour", "plusfive", "plussix", "plusseven", "pluseight", "plusnine", "plusten", "plussixteen", "plusfifty", "plushundred", "plusonehundred", "plustwohundred", "plusfivehundred", "plusthousand", "plustenthousand", "plustwentythousand", "medcard", "maxcard", "maxcardminusone", "zeropoint", "onepoint", "halfapoint", "onebasepoint", "maxcount", "maxdimen", "scaledpoint", "thousandpoint", "points", "halfpoint", "zeroskip", "zeromuskip", "onemuskip", "pluscxxvii", "pluscxxviii", "pluscclv", "pluscclvi", "normalpagebox", "directionlefttoright", "directionrighttoleft", "endoflinetoken", "outputnewlinechar", "emptytoks", "empty", "undefined", "voidbox", "emptybox", "emptyvbox", "emptyhbox", "bigskipamount", "medskipamount", "smallskipamount", "fmtname", "fmtversion", "texengine", "texenginename", "texengineversion", "texenginefunctionality", "luatexengine", "pdftexengine", "xetexengine", "unknownengine", "contextformat", "contextversion", "contextkind", "contextlmtxmode", "contextmark", "mksuffix", "activecatcode", "bgroup", "egroup", "endline", "conditionaltrue", "conditionalfalse", "attributeunsetvalue", "uprotationangle", "rightrotationangle", "downrotationangle", "leftrotationangle", "inicatcodes", "ctxcatcodes", "texcatcodes", "notcatcodes", "txtcatcodes", "vrbcatcodes", "prtcatcodes", "nilcatcodes", "luacatcodes", "tpacatcodes", "tpbcatcodes", "xmlcatcodes", "ctdcatcodes", "escapecatcode", "begingroupcatcode", "endgroupcatcode", "mathshiftcatcode", "alignmentcatcode", "endoflinecatcode", "parametercatcode", "superscriptcatcode", "subscriptcatcode", "ignorecatcode", "spacecatcode", "lettercatcode", "othercatcode", "activecatcode", "commentcatcode", "invalidcatcode", "tabasciicode", "newlineasciicode", "formfeedasciicode", "endoflineasciicode", "endoffileasciicode", "commaasciicode", "spaceasciicode", "periodasciicode", "hashasciicode", "dollarasciicode", "commentasciicode", "ampersandasciicode", "colonasciicode", "backslashasciicode", "circumflexasciicode", "underscoreasciicode", "leftbraceasciicode", "barasciicode", "rightbraceasciicode", "tildeasciicode", "delasciicode", "leftparentasciicode", "rightparentasciicode", "lessthanasciicode", "morethanasciicode", "doublecommentsignal", "atsignasciicode", "exclamationmarkasciicode", "questionmarkasciicode", "doublequoteasciicode", "singlequoteasciicode", "forwardslashasciicode", "primeasciicode", "hyphenasciicode", "activemathcharcode", "activetabtoken", "activeformfeedtoken", "activeendoflinetoken", "batchmodecode", "nonstopmodecode", "scrollmodecode", "errorstopmodecode", "bottomlevelgroupcode", "simplegroupcode", "hboxgroupcode", "adjustedhboxgroupcode", "vboxgroupcode", "vtopgroupcode", "aligngroupcode", "noaligngroupcode", "outputgroupcode", "mathgroupcode", "discretionarygroupcode", "insertgroupcode", "vcentergroupcode", "mathabovegroupcode", "mathchoicegroupcode", "semisimplegroupcode", "mathshiftgroupcode", "mathleftgroupcode", "vadjustgroupcode", "charnodecode", "hlistnodecode", "vlistnodecode", "rulenodecode", "insertnodecode", "marknodecode", "adjustnodecode", "ligaturenodecode", "discretionarynodecode", "whatsitnodecode", "mathnodecode", "gluenodecode", "kernnodecode", "penaltynodecode", "unsetnodecode", "mathsnodecode", "charifcode", "catifcode", "numifcode", "dimifcode", "oddifcode", "vmodeifcode", "hmodeifcode", "mmodeifcode", "innerifcode", "voidifcode", "hboxifcode", "vboxifcode", "xifcode", "eofifcode", "trueifcode", "falseifcode", "caseifcode", "definedifcode", "csnameifcode", "fontcharifcode", "fontslantperpoint", "fontinterwordspace", "fontinterwordstretch", "fontinterwordshrink", "fontexheight", "fontemwidth", "fontextraspace", "slantperpoint", "mathexheight", "mathemwidth", "interwordspace", "interwordstretch", "interwordshrink", "exheight", "emwidth", "extraspace", "mathaxisheight", "muquad", "startmode", "stopmode", "startnotmode", "stopnotmode", "startmodeset", "stopmodeset", "doifmode", "doifelsemode", "doifmodeelse", "doifnotmode", "startmodeset", "stopmodeset", "startallmodes", "stopallmodes", "startnotallmodes", "stopnotallmodes", "doifallmodes", "doifelseallmodes", "doifallmodeselse", "doifnotallmodes", "startenvironment", "stopenvironment", "environment", "startcomponent", "stopcomponent", "component", "startproduct", "stopproduct", "product", "startproject", "stopproject", "project", "starttext", "stoptext", "startnotext", "stopnotext", "startdocument", "stopdocument", "documentvariable", "unexpandeddocumentvariable", "setupdocument", "presetdocument", "doifelsedocumentvariable", "doifdocumentvariableelse", "doifdocumentvariable", "doifnotdocumentvariable", "startmodule", "stopmodule", "usemodule", "usetexmodule", "useluamodule", "setupmodule", "currentmoduleparameter", "moduleparameter", "everystarttext", "everystoptext", "startTEXpage", "stopTEXpage", "enablemode", "disablemode", "preventmode", "definemode", "globalenablemode", "globaldisablemode", "globalpreventmode", "pushmode", "popmode", "typescriptone", "typescripttwo", "typescriptthree", "mathsizesuffix", "mathordcode", "mathopcode", "mathbincode", "mathrelcode", "mathopencode", "mathclosecode", "mathpunctcode", "mathalphacode", "mathinnercode", "mathnothingcode", "mathlimopcode", "mathnolopcode", "mathboxcode", "mathchoicecode", "mathaccentcode", "mathradicalcode", "constantnumber", "constantnumberargument", "constantdimen", "constantdimenargument", "constantemptyargument", "continueifinputfile", "luastringsep", "!!bs", "!!es", "lefttorightmark", "righttoleftmark", "lrm", "rlm", "bidilre", "bidirle", "bidipop", "bidilro", "bidirlo", "breakablethinspace", "nobreakspace", "nonbreakablespace", "narrownobreakspace", "zerowidthnobreakspace", "ideographicspace", "ideographichalffillspace", "twoperemspace", "threeperemspace", "fourperemspace", "fiveperemspace", "sixperemspace", "figurespace", "punctuationspace", "hairspace", "enquad", "emquad", "zerowidthspace", "zerowidthnonjoiner", "zerowidthjoiner", "zwnj", "zwj", "optionalspace", "asciispacechar", "softhyphen", "Ux", "eUx", "Umathaccents", "parfillleftskip", "parfillrightskip", "startlmtxmode", "stoplmtxmode", "startmkivmode", "stopmkivmode", "wildcardsymbol" }, ["helpers"]={ "startsetups", "stopsetups", "startxmlsetups", "stopxmlsetups", "startluasetups", "stopluasetups", "starttexsetups", "stoptexsetups", "startrawsetups", "stoprawsetups", "startlocalsetups", "stoplocalsetups", "starttexdefinition", "stoptexdefinition", "starttexcode", "stoptexcode", "startcontextcode", "stopcontextcode", "startcontextdefinitioncode", "stopcontextdefinitioncode", "texdefinition", "doifelsesetups", "doifsetupselse", "doifsetups", "doifnotsetups", "setup", "setups", "texsetup", "xmlsetup", "luasetup", "directsetup", "fastsetup", "copysetups", "resetsetups", "doifelsecommandhandler", "doifcommandhandlerelse", "doifnotcommandhandler", "doifcommandhandler", "newmode", "setmode", "resetmode", "newsystemmode", "setsystemmode", "resetsystemmode", "pushsystemmode", "popsystemmode", "globalsetmode", "globalresetmode", "globalsetsystemmode", "globalresetsystemmode", "booleanmodevalue", "newcount", "newdimen", "newskip", "newmuskip", "newbox", "newtoks", "newread", "newwrite", "newmarks", "newinsert", "newattribute", "newif", "newlanguage", "newfamily", "newfam", "newhelp", "then", "begcsname", "autorule", "strippedcsname", "checkedstrippedcsname", "firstargumentfalse", "firstargumenttrue", "secondargumentfalse", "secondargumenttrue", "thirdargumentfalse", "thirdargumenttrue", "fourthargumentfalse", "fourthargumenttrue", "fifthargumentfalse", "fifthargumenttrue", "sixthargumentfalse", "sixthargumenttrue", "seventhargumentfalse", "seventhargumenttrue", "vkern", "hkern", "doglobal", "dodoglobal", "redoglobal", "resetglobal", "donothing", "dontcomplain", "forgetall", "donetrue", "donefalse", "foundtrue", "foundfalse", "inlineordisplaymath", "indisplaymath", "forcedisplaymath", "startforceddisplaymath", "stopforceddisplaymath", "startpickupmath", "stoppickupmath", "reqno", "mathortext", "htdp", "unvoidbox", "hfilll", "vfilll", "mathbox", "mathlimop", "mathnolop", "mathnothing", "mathalpha", "currentcatcodetable", "defaultcatcodetable", "catcodetablename", "newcatcodetable", "startcatcodetable", "stopcatcodetable", "startextendcatcodetable", "stopextendcatcodetable", "pushcatcodetable", "popcatcodetable", "restorecatcodes", "setcatcodetable", "letcatcodecommand", "defcatcodecommand", "uedcatcodecommand", "hglue", "vglue", "hfillneg", "vfillneg", "hfilllneg", "vfilllneg", "ruledhss", "ruledhfil", "ruledhfill", "ruledhfilll", "ruledhfilneg", "ruledhfillneg", "normalhfillneg", "normalhfilllneg", "ruledvss", "ruledvfil", "ruledvfill", "ruledvfilll", "ruledvfilneg", "ruledvfillneg", "normalvfillneg", "normalvfilllneg", "ruledhbox", "ruledvbox", "ruledvtop", "ruledvcenter", "ruledmbox", "ruledhpack", "ruledvpack", "ruledtpack", "ruledhskip", "ruledvskip", "ruledkern", "ruledmskip", "ruledmkern", "ruledhglue", "ruledvglue", "normalhglue", "normalvglue", "ruledpenalty", "filledhboxb", "filledhboxr", "filledhboxg", "filledhboxc", "filledhboxm", "filledhboxy", "filledhboxk", "scratchcounter", "globalscratchcounter", "privatescratchcounter", "scratchdimen", "globalscratchdimen", "privatescratchdimen", "scratchskip", "globalscratchskip", "privatescratchskip", "scratchmuskip", "globalscratchmuskip", "privatescratchmuskip", "scratchtoks", "globalscratchtoks", "privatescratchtoks", "scratchbox", "globalscratchbox", "privatescratchbox", "globalscratchcounterone", "globalscratchcountertwo", "globalscratchcounterthree", "groupedcommand", "groupedcommandcs", "triggergroupedcommand", "triggergroupedcommandcs", "simplegroupedcommand", "pickupgroupedcommand", "normalbaselineskip", "normallineskip", "normallineskiplimit", "availablehsize", "localhsize", "setlocalhsize", "distributedhsize", "hsizefraction", "next", "nexttoken", "nextbox", "dowithnextbox", "dowithnextboxcs", "dowithnextboxcontent", "dowithnextboxcontentcs", "flushnextbox", "boxisempty", "givenwidth", "givenheight", "givendepth", "scangivendimensions", "scratchwidth", "scratchheight", "scratchdepth", "scratchoffset", "scratchdistance", "scratchtotal", "scratchhsize", "scratchvsize", "scratchxoffset", "scratchyoffset", "scratchhoffset", "scratchvoffset", "scratchxposition", "scratchyposition", "scratchtopoffset", "scratchbottomoffset", "scratchleftoffset", "scratchrightoffset", "scratchcounterone", "scratchcountertwo", "scratchcounterthree", "scratchcounterfour", "scratchcounterfive", "scratchcountersix", "scratchdimenone", "scratchdimentwo", "scratchdimenthree", "scratchdimenfour", "scratchdimenfive", "scratchdimensix", "scratchskipone", "scratchskiptwo", "scratchskipthree", "scratchskipfour", "scratchskipfive", "scratchskipsix", "scratchmuskipone", "scratchmuskiptwo", "scratchmuskipthree", "scratchmuskipfour", "scratchmuskipfive", "scratchmuskipsix", "scratchtoksone", "scratchtokstwo", "scratchtoksthree", "scratchtoksfour", "scratchtoksfive", "scratchtokssix", "scratchboxone", "scratchboxtwo", "scratchboxthree", "scratchboxfour", "scratchboxfive", "scratchboxsix", "scratchnx", "scratchny", "scratchmx", "scratchmy", "scratchunicode", "scratchmin", "scratchmax", "scratchleftskip", "scratchrightskip", "scratchtopskip", "scratchbottomskip", "doif", "doifnot", "doifelse", "firstinset", "doifinset", "doifnotinset", "doifelseinset", "doifinsetelse", "doifelsenextchar", "doifnextcharelse", "doifelsenextcharcs", "doifnextcharcselse", "doifelsenextoptional", "doifnextoptionalelse", "doifelsenextoptionalcs", "doifnextoptionalcselse", "doifelsefastoptionalcheck", "doiffastoptionalcheckelse", "doifelsefastoptionalcheckcs", "doiffastoptionalcheckcselse", "doifelsenextbgroup", "doifnextbgroupelse", "doifelsenextbgroupcs", "doifnextbgroupcselse", "doifelsenextparenthesis", "doifnextparenthesiselse", "doifelseundefined", "doifundefinedelse", "doifelsedefined", "doifdefinedelse", "doifundefined", "doifdefined", "doifelsevalue", "doifvalue", "doifnotvalue", "doifnothing", "doifsomething", "doifelsenothing", "doifnothingelse", "doifelsesomething", "doifsomethingelse", "doifvaluenothing", "doifvaluesomething", "doifelsevaluenothing", "doifvaluenothingelse", "doifelsedimension", "doifdimensionelse", "doifelsenumber", "doifnumberelse", "doifnumber", "doifnotnumber", "doifelsecommon", "doifcommonelse", "doifcommon", "doifnotcommon", "doifinstring", "doifnotinstring", "doifelseinstring", "doifinstringelse", "doifelseassignment", "doifassignmentelse", "docheckassignment", "doifelseassignmentcs", "doifassignmentelsecs", "validassignment", "novalidassignment", "doiftext", "doifelsetext", "doiftextelse", "doifnottext", "quitcondition", "truecondition", "falsecondition", "tracingall", "tracingnone", "loggingall", "removetoks", "appendtoks", "prependtoks", "appendtotoks", "prependtotoks", "to", "endgraf", "endpar", "everyendpar", "reseteverypar", "finishpar", "empty", "null", "space", "quad", "enspace", "emspace", "charspace", "nbsp", "crlf", "obeyspaces", "obeylines", "obeyedspace", "obeyedline", "obeyedtab", "obeyedpage", "normalspace", "executeifdefined", "singleexpandafter", "doubleexpandafter", "tripleexpandafter", "dontleavehmode", "removelastspace", "removeunwantedspaces", "keepunwantedspaces", "removepunctuation", "ignoreparskip", "forcestrutdepth", "onlynonbreakablespace", "wait", "writestatus", "define", "defineexpandable", "redefine", "setmeasure", "setemeasure", "setgmeasure", "setxmeasure", "definemeasure", "freezemeasure", "measure", "measured", "directmeasure", "setquantity", "setequantity", "setgquantity", "setxquantity", "definequantity", "freezequantity", "quantity", "quantitied", "directquantity", "installcorenamespace", "getvalue", "getuvalue", "setvalue", "setevalue", "setgvalue", "setxvalue", "letvalue", "letgvalue", "resetvalue", "undefinevalue", "ignorevalue", "setuvalue", "setuevalue", "setugvalue", "setuxvalue", "globallet", "glet", "udef", "ugdef", "uedef", "uxdef", "checked", "unique", "getparameters", "geteparameters", "getgparameters", "getxparameters", "forgetparameters", "copyparameters", "getdummyparameters", "dummyparameter", "directdummyparameter", "setdummyparameter", "letdummyparameter", "setexpandeddummyparameter", "usedummystyleandcolor", "usedummystyleparameter", "usedummycolorparameter", "processcommalist", "processcommacommand", "quitcommalist", "quitprevcommalist", "processaction", "processallactions", "processfirstactioninset", "processallactionsinset", "unexpanded", "expanded", "startexpanded", "stopexpanded", "protected", "protect", "unprotect", "firstofoneargument", "firstoftwoarguments", "secondoftwoarguments", "firstofthreearguments", "secondofthreearguments", "thirdofthreearguments", "firstoffourarguments", "secondoffourarguments", "thirdoffourarguments", "fourthoffourarguments", "firstoffivearguments", "secondoffivearguments", "thirdoffivearguments", "fourthoffivearguments", "fifthoffivearguments", "firstofsixarguments", "secondofsixarguments", "thirdofsixarguments", "fourthofsixarguments", "fifthofsixarguments", "sixthofsixarguments", "firstofoneunexpanded", "firstoftwounexpanded", "secondoftwounexpanded", "firstofthreeunexpanded", "secondofthreeunexpanded", "thirdofthreeunexpanded", "gobbleoneargument", "gobbletwoarguments", "gobblethreearguments", "gobblefourarguments", "gobblefivearguments", "gobblesixarguments", "gobblesevenarguments", "gobbleeightarguments", "gobbleninearguments", "gobbletenarguments", "gobbleoneoptional", "gobbletwooptionals", "gobblethreeoptionals", "gobblefouroptionals", "gobblefiveoptionals", "dorecurse", "doloop", "exitloop", "dostepwiserecurse", "recurselevel", "recursedepth", "dofastloopcs", "fastloopindex", "fastloopfinal", "dowith", "newconstant", "setnewconstant", "setconstant", "setconstantvalue", "newconditional", "settrue", "setfalse", "settruevalue", "setfalsevalue", "newmacro", "setnewmacro", "newfraction", "newsignal", "dosingleempty", "dodoubleempty", "dotripleempty", "doquadrupleempty", "doquintupleempty", "dosixtupleempty", "doseventupleempty", "dosingleargument", "dodoubleargument", "dotripleargument", "doquadrupleargument", "doquintupleargument", "dosixtupleargument", "doseventupleargument", "dosinglegroupempty", "dodoublegroupempty", "dotriplegroupempty", "doquadruplegroupempty", "doquintuplegroupempty", "permitspacesbetweengroups", "dontpermitspacesbetweengroups", "nopdfcompression", "maximumpdfcompression", "normalpdfcompression", "onlypdfobjectcompression", "nopdfobjectcompression", "modulonumber", "dividenumber", "getfirstcharacter", "doifelsefirstchar", "doiffirstcharelse", "startnointerference", "stopnointerference", "twodigits", "threedigits", "leftorright", "offinterlineskip", "oninterlineskip", "nointerlineskip", "strut", "halfstrut", "quarterstrut", "depthstrut", "halflinestrut", "noheightstrut", "setstrut", "strutbox", "strutht", "strutdp", "strutwd", "struthtdp", "strutgap", "begstrut", "endstrut", "lineheight", "leftboundary", "rightboundary", "signalcharacter", "shiftbox", "vpackbox", "hpackbox", "vpackedbox", "hpackedbox", "ordordspacing", "ordopspacing", "ordbinspacing", "ordrelspacing", "ordopenspacing", "ordclosespacing", "ordpunctspacing", "ordinnerspacing", "opordspacing", "opopspacing", "opbinspacing", "oprelspacing", "opopenspacing", "opclosespacing", "oppunctspacing", "opinnerspacing", "binordspacing", "binopspacing", "binbinspacing", "binrelspacing", "binopenspacing", "binclosespacing", "binpunctspacing", "bininnerspacing", "relordspacing", "relopspacing", "relbinspacing", "relrelspacing", "relopenspacing", "relclosespacing", "relpunctspacing", "relinnerspacing", "openordspacing", "openopspacing", "openbinspacing", "openrelspacing", "openopenspacing", "openclosespacing", "openpunctspacing", "openinnerspacing", "closeordspacing", "closeopspacing", "closebinspacing", "closerelspacing", "closeopenspacing", "closeclosespacing", "closepunctspacing", "closeinnerspacing", "punctordspacing", "punctopspacing", "punctbinspacing", "punctrelspacing", "punctopenspacing", "punctclosespacing", "punctpunctspacing", "punctinnerspacing", "innerordspacing", "inneropspacing", "innerbinspacing", "innerrelspacing", "inneropenspacing", "innerclosespacing", "innerpunctspacing", "innerinnerspacing", "normalreqno", "startimath", "stopimath", "normalstartimath", "normalstopimath", "startdmath", "stopdmath", "normalstartdmath", "normalstopdmath", "normalsuperscript", "normalsubscript", "normalnosuperscript", "normalnosubscript", "superscript", "subscript", "nosuperscript", "nosubscript", "superprescript", "subprescript", "nosuperprescript", "nosubsprecript", "uncramped", "cramped", "mathstyletrigger", "triggermathstyle", "mathstylefont", "mathsmallstylefont", "mathstyleface", "mathsmallstyleface", "mathstylecommand", "mathpalette", "mathstylehbox", "mathstylevbox", "mathstylevcenter", "mathstylevcenteredhbox", "mathstylevcenteredvbox", "mathtext", "setmathsmalltextbox", "setmathtextbox", "pushmathstyle", "popmathstyle", "triggerdisplaystyle", "triggertextstyle", "triggerscriptstyle", "triggerscriptscriptstyle", "triggeruncrampedstyle", "triggercrampedstyle", "triggersmallstyle", "triggeruncrampedsmallstyle", "triggercrampedsmallstyle", "triggerbigstyle", "triggeruncrampedbigstyle", "triggercrampedbigstyle", "luaexpr", "expelsedoif", "expdoif", "expdoifnot", "expdoifelsecommon", "expdoifcommonelse", "expdoifelseinset", "expdoifinsetelse", "ctxdirectlua", "ctxlatelua", "ctxsprint", "ctxwrite", "ctxcommand", "ctxdirectcommand", "ctxlatecommand", "ctxreport", "ctxlua", "luacode", "lateluacode", "directluacode", "registerctxluafile", "ctxloadluafile", "luaversion", "luamajorversion", "luaminorversion", "ctxluacode", "luaconditional", "luaexpanded", "startluaparameterset", "stopluaparameterset", "luaparameterset", "definenamedlua", "obeylualines", "obeyluatokens", "startluacode", "stopluacode", "startlua", "stoplua", "startctxfunction", "stopctxfunction", "ctxfunction", "startctxfunctiondefinition", "stopctxfunctiondefinition", "installctxfunction", "installprotectedctxfunction", "installprotectedctxscanner", "installctxscanner", "resetctxscanner", "cldprocessfile", "cldloadfile", "cldloadviafile", "cldcontext", "cldcommand", "carryoverpar", "lastlinewidth", "assumelongusagecs", "Umathbotaccent", "righttolefthbox", "lefttorighthbox", "righttoleftvbox", "lefttorightvbox", "righttoleftvtop", "lefttorightvtop", "rtlhbox", "ltrhbox", "rtlvbox", "ltrvbox", "rtlvtop", "ltrvtop", "autodirhbox", "autodirvbox", "autodirvtop", "leftorrighthbox", "leftorrightvbox", "leftorrightvtop", "lefttoright", "righttoleft", "checkedlefttoright", "checkedrighttoleft", "synchronizelayoutdirection", "synchronizedisplaydirection", "synchronizeinlinedirection", "dirlre", "dirrle", "dirlro", "dirrlo", "lesshyphens", "morehyphens", "nohyphens", "dohyphens", "Ucheckedstartdisplaymath", "Ucheckedstopdisplaymath", "break", "nobreak", "allowbreak", "goodbreak", "nospace", "nospacing", "dospacing", "naturalhbox", "naturalvbox", "naturalvtop", "naturalhpack", "naturalvpack", "naturaltpack", "reversehbox", "reversevbox", "reversevtop", "reversehpack", "reversevpack", "reversetpack", "frule", "compoundhyphenpenalty", "start", "stop", "unsupportedcs" }, } \ No newline at end of file diff --git a/context/data/scite/context/scite-context-data-context.properties b/context/data/scite/context/scite-context-data-context.properties index ca68597f6..5bebca808 100644 --- a/context/data/scite/context/scite-context-data-context.properties +++ b/context/data/scite/context/scite-context-data-context.properties @@ -44,8 +44,7 @@ trueifcode falseifcode caseifcode definedifcode csnameifcode \ fontcharifcode fontslantperpoint fontinterwordspace fontinterwordstretch fontinterwordshrink \ fontexheight fontemwidth fontextraspace slantperpoint mathexheight \ mathemwidth interwordspace interwordstretch interwordshrink exheight \ -emwidth extraspace mathsupdisplay mathsupnormal mathsupcramped \ -mathsubnormal mathsubcombined mathaxisheight muquad startmode \ +emwidth extraspace mathaxisheight muquad startmode \ stopmode startnotmode stopnotmode startmodeset stopmodeset \ doifmode doifelsemode doifmodeelse doifnotmode startmodeset \ stopmodeset startallmodes stopallmodes startnotallmodes stopnotallmodes \ diff --git a/context/data/textadept/context/data/scite-context-data-context.lua b/context/data/textadept/context/data/scite-context-data-context.lua index bec15067d..3e243b290 100644 --- a/context/data/textadept/context/data/scite-context-data-context.lua +++ b/context/data/textadept/context/data/scite-context-data-context.lua @@ -1,4 +1,4 @@ return { - ["constants"]={ "zerocount", "minusone", "minustwo", "plusone", "plustwo", "plusthree", "plusfour", "plusfive", "plussix", "plusseven", "pluseight", "plusnine", "plusten", "plussixteen", "plusfifty", "plushundred", "plusonehundred", "plustwohundred", "plusfivehundred", "plusthousand", "plustenthousand", "plustwentythousand", "medcard", "maxcard", "maxcardminusone", "zeropoint", "onepoint", "halfapoint", "onebasepoint", "maxcount", "maxdimen", "scaledpoint", "thousandpoint", "points", "halfpoint", "zeroskip", "zeromuskip", "onemuskip", "pluscxxvii", "pluscxxviii", "pluscclv", "pluscclvi", "normalpagebox", "directionlefttoright", "directionrighttoleft", "endoflinetoken", "outputnewlinechar", "emptytoks", "empty", "undefined", "voidbox", "emptybox", "emptyvbox", "emptyhbox", "bigskipamount", "medskipamount", "smallskipamount", "fmtname", "fmtversion", "texengine", "texenginename", "texengineversion", "texenginefunctionality", "luatexengine", "pdftexengine", "xetexengine", "unknownengine", "contextformat", "contextversion", "contextkind", "contextlmtxmode", "contextmark", "mksuffix", "activecatcode", "bgroup", "egroup", "endline", "conditionaltrue", "conditionalfalse", "attributeunsetvalue", "uprotationangle", "rightrotationangle", "downrotationangle", "leftrotationangle", "inicatcodes", "ctxcatcodes", "texcatcodes", "notcatcodes", "txtcatcodes", "vrbcatcodes", "prtcatcodes", "nilcatcodes", "luacatcodes", "tpacatcodes", "tpbcatcodes", "xmlcatcodes", "ctdcatcodes", "escapecatcode", "begingroupcatcode", "endgroupcatcode", "mathshiftcatcode", "alignmentcatcode", "endoflinecatcode", "parametercatcode", "superscriptcatcode", "subscriptcatcode", "ignorecatcode", "spacecatcode", "lettercatcode", "othercatcode", "activecatcode", "commentcatcode", "invalidcatcode", "tabasciicode", "newlineasciicode", "formfeedasciicode", "endoflineasciicode", "endoffileasciicode", "commaasciicode", "spaceasciicode", "periodasciicode", "hashasciicode", "dollarasciicode", "commentasciicode", "ampersandasciicode", "colonasciicode", "backslashasciicode", "circumflexasciicode", "underscoreasciicode", "leftbraceasciicode", "barasciicode", "rightbraceasciicode", "tildeasciicode", "delasciicode", "leftparentasciicode", "rightparentasciicode", "lessthanasciicode", "morethanasciicode", "doublecommentsignal", "atsignasciicode", "exclamationmarkasciicode", "questionmarkasciicode", "doublequoteasciicode", "singlequoteasciicode", "forwardslashasciicode", "primeasciicode", "hyphenasciicode", "activemathcharcode", "activetabtoken", "activeformfeedtoken", "activeendoflinetoken", "batchmodecode", "nonstopmodecode", "scrollmodecode", "errorstopmodecode", "bottomlevelgroupcode", "simplegroupcode", "hboxgroupcode", "adjustedhboxgroupcode", "vboxgroupcode", "vtopgroupcode", "aligngroupcode", "noaligngroupcode", "outputgroupcode", "mathgroupcode", "discretionarygroupcode", "insertgroupcode", "vcentergroupcode", "mathabovegroupcode", "mathchoicegroupcode", "semisimplegroupcode", "mathshiftgroupcode", "mathleftgroupcode", "vadjustgroupcode", "charnodecode", "hlistnodecode", "vlistnodecode", "rulenodecode", "insertnodecode", "marknodecode", "adjustnodecode", "ligaturenodecode", "discretionarynodecode", "whatsitnodecode", "mathnodecode", "gluenodecode", "kernnodecode", "penaltynodecode", "unsetnodecode", "mathsnodecode", "charifcode", "catifcode", "numifcode", "dimifcode", "oddifcode", "vmodeifcode", "hmodeifcode", "mmodeifcode", "innerifcode", "voidifcode", "hboxifcode", "vboxifcode", "xifcode", "eofifcode", "trueifcode", "falseifcode", "caseifcode", "definedifcode", "csnameifcode", "fontcharifcode", "fontslantperpoint", "fontinterwordspace", "fontinterwordstretch", "fontinterwordshrink", "fontexheight", "fontemwidth", "fontextraspace", "slantperpoint", "mathexheight", "mathemwidth", "interwordspace", "interwordstretch", "interwordshrink", "exheight", "emwidth", "extraspace", "mathsupdisplay", "mathsupnormal", "mathsupcramped", "mathsubnormal", "mathsubcombined", "mathaxisheight", "muquad", "startmode", "stopmode", "startnotmode", "stopnotmode", "startmodeset", "stopmodeset", "doifmode", "doifelsemode", "doifmodeelse", "doifnotmode", "startmodeset", "stopmodeset", "startallmodes", "stopallmodes", "startnotallmodes", "stopnotallmodes", "doifallmodes", "doifelseallmodes", "doifallmodeselse", "doifnotallmodes", "startenvironment", "stopenvironment", "environment", "startcomponent", "stopcomponent", "component", "startproduct", "stopproduct", "product", "startproject", "stopproject", "project", "starttext", "stoptext", "startnotext", "stopnotext", "startdocument", "stopdocument", "documentvariable", "unexpandeddocumentvariable", "setupdocument", "presetdocument", "doifelsedocumentvariable", "doifdocumentvariableelse", "doifdocumentvariable", "doifnotdocumentvariable", "startmodule", "stopmodule", "usemodule", "usetexmodule", "useluamodule", "setupmodule", "currentmoduleparameter", "moduleparameter", "everystarttext", "everystoptext", "startTEXpage", "stopTEXpage", "enablemode", "disablemode", "preventmode", "definemode", "globalenablemode", "globaldisablemode", "globalpreventmode", "pushmode", "popmode", "typescriptone", "typescripttwo", "typescriptthree", "mathsizesuffix", "mathordcode", "mathopcode", "mathbincode", "mathrelcode", "mathopencode", "mathclosecode", "mathpunctcode", "mathalphacode", "mathinnercode", "mathnothingcode", "mathlimopcode", "mathnolopcode", "mathboxcode", "mathchoicecode", "mathaccentcode", "mathradicalcode", "constantnumber", "constantnumberargument", "constantdimen", "constantdimenargument", "constantemptyargument", "continueifinputfile", "luastringsep", "!!bs", "!!es", "lefttorightmark", "righttoleftmark", "lrm", "rlm", "bidilre", "bidirle", "bidipop", "bidilro", "bidirlo", "breakablethinspace", "nobreakspace", "nonbreakablespace", "narrownobreakspace", "zerowidthnobreakspace", "ideographicspace", "ideographichalffillspace", "twoperemspace", "threeperemspace", "fourperemspace", "fiveperemspace", "sixperemspace", "figurespace", "punctuationspace", "hairspace", "enquad", "emquad", "zerowidthspace", "zerowidthnonjoiner", "zerowidthjoiner", "zwnj", "zwj", "optionalspace", "asciispacechar", "softhyphen", "Ux", "eUx", "Umathaccents", "parfillleftskip", "parfillrightskip", "startlmtxmode", "stoplmtxmode", "startmkivmode", "stopmkivmode", "wildcardsymbol" }, + ["constants"]={ "zerocount", "minusone", "minustwo", "plusone", "plustwo", "plusthree", "plusfour", "plusfive", "plussix", "plusseven", "pluseight", "plusnine", "plusten", "plussixteen", "plusfifty", "plushundred", "plusonehundred", "plustwohundred", "plusfivehundred", "plusthousand", "plustenthousand", "plustwentythousand", "medcard", "maxcard", "maxcardminusone", "zeropoint", "onepoint", "halfapoint", "onebasepoint", "maxcount", "maxdimen", "scaledpoint", "thousandpoint", "points", "halfpoint", "zeroskip", "zeromuskip", "onemuskip", "pluscxxvii", "pluscxxviii", "pluscclv", "pluscclvi", "normalpagebox", "directionlefttoright", "directionrighttoleft", "endoflinetoken", "outputnewlinechar", "emptytoks", "empty", "undefined", "voidbox", "emptybox", "emptyvbox", "emptyhbox", "bigskipamount", "medskipamount", "smallskipamount", "fmtname", "fmtversion", "texengine", "texenginename", "texengineversion", "texenginefunctionality", "luatexengine", "pdftexengine", "xetexengine", "unknownengine", "contextformat", "contextversion", "contextkind", "contextlmtxmode", "contextmark", "mksuffix", "activecatcode", "bgroup", "egroup", "endline", "conditionaltrue", "conditionalfalse", "attributeunsetvalue", "uprotationangle", "rightrotationangle", "downrotationangle", "leftrotationangle", "inicatcodes", "ctxcatcodes", "texcatcodes", "notcatcodes", "txtcatcodes", "vrbcatcodes", "prtcatcodes", "nilcatcodes", "luacatcodes", "tpacatcodes", "tpbcatcodes", "xmlcatcodes", "ctdcatcodes", "escapecatcode", "begingroupcatcode", "endgroupcatcode", "mathshiftcatcode", "alignmentcatcode", "endoflinecatcode", "parametercatcode", "superscriptcatcode", "subscriptcatcode", "ignorecatcode", "spacecatcode", "lettercatcode", "othercatcode", "activecatcode", "commentcatcode", "invalidcatcode", "tabasciicode", "newlineasciicode", "formfeedasciicode", "endoflineasciicode", "endoffileasciicode", "commaasciicode", "spaceasciicode", "periodasciicode", "hashasciicode", "dollarasciicode", "commentasciicode", "ampersandasciicode", "colonasciicode", "backslashasciicode", "circumflexasciicode", "underscoreasciicode", "leftbraceasciicode", "barasciicode", "rightbraceasciicode", "tildeasciicode", "delasciicode", "leftparentasciicode", "rightparentasciicode", "lessthanasciicode", "morethanasciicode", "doublecommentsignal", "atsignasciicode", "exclamationmarkasciicode", "questionmarkasciicode", "doublequoteasciicode", "singlequoteasciicode", "forwardslashasciicode", "primeasciicode", "hyphenasciicode", "activemathcharcode", "activetabtoken", "activeformfeedtoken", "activeendoflinetoken", "batchmodecode", "nonstopmodecode", "scrollmodecode", "errorstopmodecode", "bottomlevelgroupcode", "simplegroupcode", "hboxgroupcode", "adjustedhboxgroupcode", "vboxgroupcode", "vtopgroupcode", "aligngroupcode", "noaligngroupcode", "outputgroupcode", "mathgroupcode", "discretionarygroupcode", "insertgroupcode", "vcentergroupcode", "mathabovegroupcode", "mathchoicegroupcode", "semisimplegroupcode", "mathshiftgroupcode", "mathleftgroupcode", "vadjustgroupcode", "charnodecode", "hlistnodecode", "vlistnodecode", "rulenodecode", "insertnodecode", "marknodecode", "adjustnodecode", "ligaturenodecode", "discretionarynodecode", "whatsitnodecode", "mathnodecode", "gluenodecode", "kernnodecode", "penaltynodecode", "unsetnodecode", "mathsnodecode", "charifcode", "catifcode", "numifcode", "dimifcode", "oddifcode", "vmodeifcode", "hmodeifcode", "mmodeifcode", "innerifcode", "voidifcode", "hboxifcode", "vboxifcode", "xifcode", "eofifcode", "trueifcode", "falseifcode", "caseifcode", "definedifcode", "csnameifcode", "fontcharifcode", "fontslantperpoint", "fontinterwordspace", "fontinterwordstretch", "fontinterwordshrink", "fontexheight", "fontemwidth", "fontextraspace", "slantperpoint", "mathexheight", "mathemwidth", "interwordspace", "interwordstretch", "interwordshrink", "exheight", "emwidth", "extraspace", "mathaxisheight", "muquad", "startmode", "stopmode", "startnotmode", "stopnotmode", "startmodeset", "stopmodeset", "doifmode", "doifelsemode", "doifmodeelse", "doifnotmode", "startmodeset", "stopmodeset", "startallmodes", "stopallmodes", "startnotallmodes", "stopnotallmodes", "doifallmodes", "doifelseallmodes", "doifallmodeselse", "doifnotallmodes", "startenvironment", "stopenvironment", "environment", "startcomponent", "stopcomponent", "component", "startproduct", "stopproduct", "product", "startproject", "stopproject", "project", "starttext", "stoptext", "startnotext", "stopnotext", "startdocument", "stopdocument", "documentvariable", "unexpandeddocumentvariable", "setupdocument", "presetdocument", "doifelsedocumentvariable", "doifdocumentvariableelse", "doifdocumentvariable", "doifnotdocumentvariable", "startmodule", "stopmodule", "usemodule", "usetexmodule", "useluamodule", "setupmodule", "currentmoduleparameter", "moduleparameter", "everystarttext", "everystoptext", "startTEXpage", "stopTEXpage", "enablemode", "disablemode", "preventmode", "definemode", "globalenablemode", "globaldisablemode", "globalpreventmode", "pushmode", "popmode", "typescriptone", "typescripttwo", "typescriptthree", "mathsizesuffix", "mathordcode", "mathopcode", "mathbincode", "mathrelcode", "mathopencode", "mathclosecode", "mathpunctcode", "mathalphacode", "mathinnercode", "mathnothingcode", "mathlimopcode", "mathnolopcode", "mathboxcode", "mathchoicecode", "mathaccentcode", "mathradicalcode", "constantnumber", "constantnumberargument", "constantdimen", "constantdimenargument", "constantemptyargument", "continueifinputfile", "luastringsep", "!!bs", "!!es", "lefttorightmark", "righttoleftmark", "lrm", "rlm", "bidilre", "bidirle", "bidipop", "bidilro", "bidirlo", "breakablethinspace", "nobreakspace", "nonbreakablespace", "narrownobreakspace", "zerowidthnobreakspace", "ideographicspace", "ideographichalffillspace", "twoperemspace", "threeperemspace", "fourperemspace", "fiveperemspace", "sixperemspace", "figurespace", "punctuationspace", "hairspace", "enquad", "emquad", "zerowidthspace", "zerowidthnonjoiner", "zerowidthjoiner", "zwnj", "zwj", "optionalspace", "asciispacechar", "softhyphen", "Ux", "eUx", "Umathaccents", "parfillleftskip", "parfillrightskip", "startlmtxmode", "stoplmtxmode", "startmkivmode", "stopmkivmode", "wildcardsymbol" }, ["helpers"]={ "startsetups", "stopsetups", "startxmlsetups", "stopxmlsetups", "startluasetups", "stopluasetups", "starttexsetups", "stoptexsetups", "startrawsetups", "stoprawsetups", "startlocalsetups", "stoplocalsetups", "starttexdefinition", "stoptexdefinition", "starttexcode", "stoptexcode", "startcontextcode", "stopcontextcode", "startcontextdefinitioncode", "stopcontextdefinitioncode", "texdefinition", "doifelsesetups", "doifsetupselse", "doifsetups", "doifnotsetups", "setup", "setups", "texsetup", "xmlsetup", "luasetup", "directsetup", "fastsetup", "copysetups", "resetsetups", "doifelsecommandhandler", "doifcommandhandlerelse", "doifnotcommandhandler", "doifcommandhandler", "newmode", "setmode", "resetmode", "newsystemmode", "setsystemmode", "resetsystemmode", "pushsystemmode", "popsystemmode", "globalsetmode", "globalresetmode", "globalsetsystemmode", "globalresetsystemmode", "booleanmodevalue", "newcount", "newdimen", "newskip", "newmuskip", "newbox", "newtoks", "newread", "newwrite", "newmarks", "newinsert", "newattribute", "newif", "newlanguage", "newfamily", "newfam", "newhelp", "then", "begcsname", "autorule", "strippedcsname", "checkedstrippedcsname", "firstargumentfalse", "firstargumenttrue", "secondargumentfalse", "secondargumenttrue", "thirdargumentfalse", "thirdargumenttrue", "fourthargumentfalse", "fourthargumenttrue", "fifthargumentfalse", "fifthargumenttrue", "sixthargumentfalse", "sixthargumenttrue", "seventhargumentfalse", "seventhargumenttrue", "vkern", "hkern", "doglobal", "dodoglobal", "redoglobal", "resetglobal", "donothing", "dontcomplain", "forgetall", "donetrue", "donefalse", "foundtrue", "foundfalse", "inlineordisplaymath", "indisplaymath", "forcedisplaymath", "startforceddisplaymath", "stopforceddisplaymath", "startpickupmath", "stoppickupmath", "reqno", "mathortext", "htdp", "unvoidbox", "hfilll", "vfilll", "mathbox", "mathlimop", "mathnolop", "mathnothing", "mathalpha", "currentcatcodetable", "defaultcatcodetable", "catcodetablename", "newcatcodetable", "startcatcodetable", "stopcatcodetable", "startextendcatcodetable", "stopextendcatcodetable", "pushcatcodetable", "popcatcodetable", "restorecatcodes", "setcatcodetable", "letcatcodecommand", "defcatcodecommand", "uedcatcodecommand", "hglue", "vglue", "hfillneg", "vfillneg", "hfilllneg", "vfilllneg", "ruledhss", "ruledhfil", "ruledhfill", "ruledhfilll", "ruledhfilneg", "ruledhfillneg", "normalhfillneg", "normalhfilllneg", "ruledvss", "ruledvfil", "ruledvfill", "ruledvfilll", "ruledvfilneg", "ruledvfillneg", "normalvfillneg", "normalvfilllneg", "ruledhbox", "ruledvbox", "ruledvtop", "ruledvcenter", "ruledmbox", "ruledhpack", "ruledvpack", "ruledtpack", "ruledhskip", "ruledvskip", "ruledkern", "ruledmskip", "ruledmkern", "ruledhglue", "ruledvglue", "normalhglue", "normalvglue", "ruledpenalty", "filledhboxb", "filledhboxr", "filledhboxg", "filledhboxc", "filledhboxm", "filledhboxy", "filledhboxk", "scratchcounter", "globalscratchcounter", "privatescratchcounter", "scratchdimen", "globalscratchdimen", "privatescratchdimen", "scratchskip", "globalscratchskip", "privatescratchskip", "scratchmuskip", "globalscratchmuskip", "privatescratchmuskip", "scratchtoks", "globalscratchtoks", "privatescratchtoks", "scratchbox", "globalscratchbox", "privatescratchbox", "globalscratchcounterone", "globalscratchcountertwo", "globalscratchcounterthree", "groupedcommand", "groupedcommandcs", "triggergroupedcommand", "triggergroupedcommandcs", "simplegroupedcommand", "pickupgroupedcommand", "normalbaselineskip", "normallineskip", "normallineskiplimit", "availablehsize", "localhsize", "setlocalhsize", "distributedhsize", "hsizefraction", "next", "nexttoken", "nextbox", "dowithnextbox", "dowithnextboxcs", "dowithnextboxcontent", "dowithnextboxcontentcs", "flushnextbox", "boxisempty", "givenwidth", "givenheight", "givendepth", "scangivendimensions", "scratchwidth", "scratchheight", "scratchdepth", "scratchoffset", "scratchdistance", "scratchtotal", "scratchhsize", "scratchvsize", "scratchxoffset", "scratchyoffset", "scratchhoffset", "scratchvoffset", "scratchxposition", "scratchyposition", "scratchtopoffset", "scratchbottomoffset", "scratchleftoffset", "scratchrightoffset", "scratchcounterone", "scratchcountertwo", "scratchcounterthree", "scratchcounterfour", "scratchcounterfive", "scratchcountersix", "scratchdimenone", "scratchdimentwo", "scratchdimenthree", "scratchdimenfour", "scratchdimenfive", "scratchdimensix", "scratchskipone", "scratchskiptwo", "scratchskipthree", "scratchskipfour", "scratchskipfive", "scratchskipsix", "scratchmuskipone", "scratchmuskiptwo", "scratchmuskipthree", "scratchmuskipfour", "scratchmuskipfive", "scratchmuskipsix", "scratchtoksone", "scratchtokstwo", "scratchtoksthree", "scratchtoksfour", "scratchtoksfive", "scratchtokssix", "scratchboxone", "scratchboxtwo", "scratchboxthree", "scratchboxfour", "scratchboxfive", "scratchboxsix", "scratchnx", "scratchny", "scratchmx", "scratchmy", "scratchunicode", "scratchmin", "scratchmax", "scratchleftskip", "scratchrightskip", "scratchtopskip", "scratchbottomskip", "doif", "doifnot", "doifelse", "firstinset", "doifinset", "doifnotinset", "doifelseinset", "doifinsetelse", "doifelsenextchar", "doifnextcharelse", "doifelsenextcharcs", "doifnextcharcselse", "doifelsenextoptional", "doifnextoptionalelse", "doifelsenextoptionalcs", "doifnextoptionalcselse", "doifelsefastoptionalcheck", "doiffastoptionalcheckelse", "doifelsefastoptionalcheckcs", "doiffastoptionalcheckcselse", "doifelsenextbgroup", "doifnextbgroupelse", "doifelsenextbgroupcs", "doifnextbgroupcselse", "doifelsenextparenthesis", "doifnextparenthesiselse", "doifelseundefined", "doifundefinedelse", "doifelsedefined", "doifdefinedelse", "doifundefined", "doifdefined", "doifelsevalue", "doifvalue", "doifnotvalue", "doifnothing", "doifsomething", "doifelsenothing", "doifnothingelse", "doifelsesomething", "doifsomethingelse", "doifvaluenothing", "doifvaluesomething", "doifelsevaluenothing", "doifvaluenothingelse", "doifelsedimension", "doifdimensionelse", "doifelsenumber", "doifnumberelse", "doifnumber", "doifnotnumber", "doifelsecommon", "doifcommonelse", "doifcommon", "doifnotcommon", "doifinstring", "doifnotinstring", "doifelseinstring", "doifinstringelse", "doifelseassignment", "doifassignmentelse", "docheckassignment", "doifelseassignmentcs", "doifassignmentelsecs", "validassignment", "novalidassignment", "doiftext", "doifelsetext", "doiftextelse", "doifnottext", "quitcondition", "truecondition", "falsecondition", "tracingall", "tracingnone", "loggingall", "removetoks", "appendtoks", "prependtoks", "appendtotoks", "prependtotoks", "to", "endgraf", "endpar", "everyendpar", "reseteverypar", "finishpar", "empty", "null", "space", "quad", "enspace", "emspace", "charspace", "nbsp", "crlf", "obeyspaces", "obeylines", "obeyedspace", "obeyedline", "obeyedtab", "obeyedpage", "normalspace", "executeifdefined", "singleexpandafter", "doubleexpandafter", "tripleexpandafter", "dontleavehmode", "removelastspace", "removeunwantedspaces", "keepunwantedspaces", "removepunctuation", "ignoreparskip", "forcestrutdepth", "onlynonbreakablespace", "wait", "writestatus", "define", "defineexpandable", "redefine", "setmeasure", "setemeasure", "setgmeasure", "setxmeasure", "definemeasure", "freezemeasure", "measure", "measured", "directmeasure", "setquantity", "setequantity", "setgquantity", "setxquantity", "definequantity", "freezequantity", "quantity", "quantitied", "directquantity", "installcorenamespace", "getvalue", "getuvalue", "setvalue", "setevalue", "setgvalue", "setxvalue", "letvalue", "letgvalue", "resetvalue", "undefinevalue", "ignorevalue", "setuvalue", "setuevalue", "setugvalue", "setuxvalue", "globallet", "glet", "udef", "ugdef", "uedef", "uxdef", "checked", "unique", "getparameters", "geteparameters", "getgparameters", "getxparameters", "forgetparameters", "copyparameters", "getdummyparameters", "dummyparameter", "directdummyparameter", "setdummyparameter", "letdummyparameter", "setexpandeddummyparameter", "usedummystyleandcolor", "usedummystyleparameter", "usedummycolorparameter", "processcommalist", "processcommacommand", "quitcommalist", "quitprevcommalist", "processaction", "processallactions", "processfirstactioninset", "processallactionsinset", "unexpanded", "expanded", "startexpanded", "stopexpanded", "protected", "protect", "unprotect", "firstofoneargument", "firstoftwoarguments", "secondoftwoarguments", "firstofthreearguments", "secondofthreearguments", "thirdofthreearguments", "firstoffourarguments", "secondoffourarguments", "thirdoffourarguments", "fourthoffourarguments", "firstoffivearguments", "secondoffivearguments", "thirdoffivearguments", "fourthoffivearguments", "fifthoffivearguments", "firstofsixarguments", "secondofsixarguments", "thirdofsixarguments", "fourthofsixarguments", "fifthofsixarguments", "sixthofsixarguments", "firstofoneunexpanded", "firstoftwounexpanded", "secondoftwounexpanded", "firstofthreeunexpanded", "secondofthreeunexpanded", "thirdofthreeunexpanded", "gobbleoneargument", "gobbletwoarguments", "gobblethreearguments", "gobblefourarguments", "gobblefivearguments", "gobblesixarguments", "gobblesevenarguments", "gobbleeightarguments", "gobbleninearguments", "gobbletenarguments", "gobbleoneoptional", "gobbletwooptionals", "gobblethreeoptionals", "gobblefouroptionals", "gobblefiveoptionals", "dorecurse", "doloop", "exitloop", "dostepwiserecurse", "recurselevel", "recursedepth", "dofastloopcs", "fastloopindex", "fastloopfinal", "dowith", "newconstant", "setnewconstant", "setconstant", "setconstantvalue", "newconditional", "settrue", "setfalse", "settruevalue", "setfalsevalue", "newmacro", "setnewmacro", "newfraction", "newsignal", "dosingleempty", "dodoubleempty", "dotripleempty", "doquadrupleempty", "doquintupleempty", "dosixtupleempty", "doseventupleempty", "dosingleargument", "dodoubleargument", "dotripleargument", "doquadrupleargument", "doquintupleargument", "dosixtupleargument", "doseventupleargument", "dosinglegroupempty", "dodoublegroupempty", "dotriplegroupempty", "doquadruplegroupempty", "doquintuplegroupempty", "permitspacesbetweengroups", "dontpermitspacesbetweengroups", "nopdfcompression", "maximumpdfcompression", "normalpdfcompression", "onlypdfobjectcompression", "nopdfobjectcompression", "modulonumber", "dividenumber", "getfirstcharacter", "doifelsefirstchar", "doiffirstcharelse", "startnointerference", "stopnointerference", "twodigits", "threedigits", "leftorright", "offinterlineskip", "oninterlineskip", "nointerlineskip", "strut", "halfstrut", "quarterstrut", "depthstrut", "halflinestrut", "noheightstrut", "setstrut", "strutbox", "strutht", "strutdp", "strutwd", "struthtdp", "strutgap", "begstrut", "endstrut", "lineheight", "leftboundary", "rightboundary", "signalcharacter", "shiftbox", "vpackbox", "hpackbox", "vpackedbox", "hpackedbox", "ordordspacing", "ordopspacing", "ordbinspacing", "ordrelspacing", "ordopenspacing", "ordclosespacing", "ordpunctspacing", "ordinnerspacing", "opordspacing", "opopspacing", "opbinspacing", "oprelspacing", "opopenspacing", "opclosespacing", "oppunctspacing", "opinnerspacing", "binordspacing", "binopspacing", "binbinspacing", "binrelspacing", "binopenspacing", "binclosespacing", "binpunctspacing", "bininnerspacing", "relordspacing", "relopspacing", "relbinspacing", "relrelspacing", "relopenspacing", "relclosespacing", "relpunctspacing", "relinnerspacing", "openordspacing", "openopspacing", "openbinspacing", "openrelspacing", "openopenspacing", "openclosespacing", "openpunctspacing", "openinnerspacing", "closeordspacing", "closeopspacing", "closebinspacing", "closerelspacing", "closeopenspacing", "closeclosespacing", "closepunctspacing", "closeinnerspacing", "punctordspacing", "punctopspacing", "punctbinspacing", "punctrelspacing", "punctopenspacing", "punctclosespacing", "punctpunctspacing", "punctinnerspacing", "innerordspacing", "inneropspacing", "innerbinspacing", "innerrelspacing", "inneropenspacing", "innerclosespacing", "innerpunctspacing", "innerinnerspacing", "normalreqno", "startimath", "stopimath", "normalstartimath", "normalstopimath", "startdmath", "stopdmath", "normalstartdmath", "normalstopdmath", "normalsuperscript", "normalsubscript", "normalnosuperscript", "normalnosubscript", "superscript", "subscript", "nosuperscript", "nosubscript", "superprescript", "subprescript", "nosuperprescript", "nosubsprecript", "uncramped", "cramped", "mathstyletrigger", "triggermathstyle", "mathstylefont", "mathsmallstylefont", "mathstyleface", "mathsmallstyleface", "mathstylecommand", "mathpalette", "mathstylehbox", "mathstylevbox", "mathstylevcenter", "mathstylevcenteredhbox", "mathstylevcenteredvbox", "mathtext", "setmathsmalltextbox", "setmathtextbox", "pushmathstyle", "popmathstyle", "triggerdisplaystyle", "triggertextstyle", "triggerscriptstyle", "triggerscriptscriptstyle", "triggeruncrampedstyle", "triggercrampedstyle", "triggersmallstyle", "triggeruncrampedsmallstyle", "triggercrampedsmallstyle", "triggerbigstyle", "triggeruncrampedbigstyle", "triggercrampedbigstyle", "luaexpr", "expelsedoif", "expdoif", "expdoifnot", "expdoifelsecommon", "expdoifcommonelse", "expdoifelseinset", "expdoifinsetelse", "ctxdirectlua", "ctxlatelua", "ctxsprint", "ctxwrite", "ctxcommand", "ctxdirectcommand", "ctxlatecommand", "ctxreport", "ctxlua", "luacode", "lateluacode", "directluacode", "registerctxluafile", "ctxloadluafile", "luaversion", "luamajorversion", "luaminorversion", "ctxluacode", "luaconditional", "luaexpanded", "startluaparameterset", "stopluaparameterset", "luaparameterset", "definenamedlua", "obeylualines", "obeyluatokens", "startluacode", "stopluacode", "startlua", "stoplua", "startctxfunction", "stopctxfunction", "ctxfunction", "startctxfunctiondefinition", "stopctxfunctiondefinition", "installctxfunction", "installprotectedctxfunction", "installprotectedctxscanner", "installctxscanner", "resetctxscanner", "cldprocessfile", "cldloadfile", "cldloadviafile", "cldcontext", "cldcommand", "carryoverpar", "lastlinewidth", "assumelongusagecs", "Umathbotaccent", "righttolefthbox", "lefttorighthbox", "righttoleftvbox", "lefttorightvbox", "righttoleftvtop", "lefttorightvtop", "rtlhbox", "ltrhbox", "rtlvbox", "ltrvbox", "rtlvtop", "ltrvtop", "autodirhbox", "autodirvbox", "autodirvtop", "leftorrighthbox", "leftorrightvbox", "leftorrightvtop", "lefttoright", "righttoleft", "checkedlefttoright", "checkedrighttoleft", "synchronizelayoutdirection", "synchronizedisplaydirection", "synchronizeinlinedirection", "dirlre", "dirrle", "dirlro", "dirrlo", "lesshyphens", "morehyphens", "nohyphens", "dohyphens", "Ucheckedstartdisplaymath", "Ucheckedstopdisplaymath", "break", "nobreak", "allowbreak", "goodbreak", "nospace", "nospacing", "dospacing", "naturalhbox", "naturalvbox", "naturalvtop", "naturalhpack", "naturalvpack", "naturaltpack", "reversehbox", "reversevbox", "reversevtop", "reversehpack", "reversevpack", "reversetpack", "frule", "compoundhyphenpenalty", "start", "stop", "unsupportedcs" }, } \ No newline at end of file diff --git a/context/data/vscode/extensions/context/syntaxes/context-syntax-tex.json b/context/data/vscode/extensions/context/syntaxes/context-syntax-tex.json index 36a8532e7..4ed46b02b 100644 --- a/context/data/vscode/extensions/context/syntaxes/context-syntax-tex.json +++ b/context/data/vscode/extensions/context/syntaxes/context-syntax-tex.json @@ -68,7 +68,7 @@ "name" : "context.comment.comment.tex" }, "constant" : { - "match" : "\u005C\u005C(zwnj|zwj|zerowidthspace|zerowidthnonjoiner|zerowidthnobreakspace|zerowidthjoiner|zeroskip|zeropoint|zeromuskip|zerocount|xmlcatcodes|xifcode|xetexengine|wildcardsymbol|whatsitnodecode|vtopgroupcode|vrbcatcodes|voidifcode|voidbox|vmodeifcode|vlistnodecode|vcentergroupcode|vboxifcode|vboxgroupcode|vadjustgroupcode|usetexmodule|usemodule|useluamodule|uprotationangle|unsetnodecode|unknownengine|unexpandeddocumentvariable|underscoreasciicode|undefined|typescripttwo|typescriptthree|typescriptone|txtcatcodes|twoperemspace|trueifcode|tpbcatcodes|tpacatcodes|tildeasciicode|threeperemspace|thousandpoint|texengineversion|texenginename|texenginefunctionality|texengine|texcatcodes|tabasciicode|superscriptcatcode|subscriptcatcode|stoptext|stopproject|stopproduct|stopnotmode|stopnotext|stopnotallmodes|stopmodule|stopmodeset|stopmodeset|stopmode|stopmkivmode|stoplmtxmode|stopenvironment|stopdocument|stopcomponent|stopallmodes|stopTEXpage|starttext|startproject|startproduct|startnotmode|startnotext|startnotallmodes|startmodule|startmodeset|startmodeset|startmode|startmkivmode|startlmtxmode|startenvironment|startdocument|startcomponent|startallmodes|startTEXpage|spacecatcode|spaceasciicode|softhyphen|smallskipamount|slantperpoint|sixperemspace|singlequoteasciicode|simplegroupcode|setupmodule|setupdocument|semisimplegroupcode|scrollmodecode|scaledpoint|rulenodecode|rlm|righttoleftmark|rightrotationangle|rightparentasciicode|rightbraceasciicode|questionmarkasciicode|pushmode|punctuationspace|prtcatcodes|project|product|primeasciicode|preventmode|presetdocument|popmode|points|plustwohundred|plustwo|plustwentythousand|plusthree|plusthousand|plustenthousand|plusten|plussixteen|plussix|plusseven|plusonehundred|plusone|plusnine|plushundred|plusfour|plusfivehundred|plusfive|plusfifty|pluseight|pluscxxviii|pluscxxvii|pluscclvi|pluscclv|periodasciicode|penaltynodecode|pdftexengine|parfillrightskip|parfillleftskip|parametercatcode|outputnewlinechar|outputgroupcode|othercatcode|optionalspace|onepoint|onemuskip|onebasepoint|oddifcode|numifcode|notcatcodes|normalpagebox|nonstopmodecode|nonbreakablespace|nobreakspace|noaligngroupcode|nilcatcodes|newlineasciicode|narrownobreakspace|muquad|morethanasciicode|moduleparameter|mmodeifcode|mksuffix|minustwo|minusone|medskipamount|medcard|maxdimen|maxcount|maxcardminusone|maxcard|mathsupnormal|mathsupdisplay|mathsupcramped|mathsubnormal|mathsubcombined|mathsnodecode|mathsizesuffix|mathshiftgroupcode|mathshiftcatcode|mathrelcode|mathradicalcode|mathpunctcode|mathordcode|mathopencode|mathopcode|mathnothingcode|mathnolopcode|mathnodecode|mathlimopcode|mathleftgroupcode|mathinnercode|mathgroupcode|mathexheight|mathemwidth|mathclosecode|mathchoicegroupcode|mathchoicecode|mathboxcode|mathbincode|mathaxisheight|mathalphacode|mathaccentcode|mathabovegroupcode|marknodecode|luatexengine|luastringsep|luacatcodes|lrm|ligaturenodecode|lettercatcode|lessthanasciicode|lefttorightmark|leftrotationangle|leftparentasciicode|leftbraceasciicode|kernnodecode|invalidcatcode|interwordstretch|interwordspace|interwordshrink|insertnodecode|insertgroupcode|innerifcode|inicatcodes|ignorecatcode|ideographicspace|ideographichalffillspace|hyphenasciicode|hmodeifcode|hlistnodecode|hboxifcode|hboxgroupcode|hashasciicode|halfpoint|halfapoint|hairspace|gluenodecode|globalpreventmode|globalenablemode|globaldisablemode|fourperemspace|forwardslashasciicode|formfeedasciicode|fontslantperpoint|fontinterwordstretch|fontinterwordspace|fontinterwordshrink|fontextraspace|fontexheight|fontemwidth|fontcharifcode|fmtversion|fmtname|fiveperemspace|figurespace|falseifcode|extraspace|exheight|exclamationmarkasciicode|everystoptext|everystarttext|escapecatcode|errorstopmodecode|eofifcode|environment|enquad|endoflinetoken|endoflinecatcode|endoflineasciicode|endoffileasciicode|endline|endgroupcatcode|enablemode|emwidth|emquad|emptyvbox|emptytoks|emptyhbox|emptybox|empty|egroup|eUx|downrotationangle|doublequoteasciicode|doublecommentsignal|dollarasciicode|doifnotmode|doifnotdocumentvariable|doifnotallmodes|doifmodeelse|doifmode|doifelsemode|doifelsedocumentvariable|doifelseallmodes|doifdocumentvariableelse|doifdocumentvariable|doifallmodeselse|doifallmodes|documentvariable|discretionarynodecode|discretionarygroupcode|disablemode|directionrighttoleft|directionlefttoright|dimifcode|delasciicode|definemode|definedifcode|currentmoduleparameter|ctxcatcodes|ctdcatcodes|csnameifcode|continueifinputfile|contextversion|contextmark|contextlmtxmode|contextkind|contextformat|constantnumberargument|constantnumber|constantemptyargument|constantdimenargument|constantdimen|conditionaltrue|conditionalfalse|component|commentcatcode|commentasciicode|commaasciicode|colonasciicode|circumflexasciicode|charnodecode|charifcode|catifcode|caseifcode|breakablethinspace|bottomlevelgroupcode|bigskipamount|bidirlo|bidirle|bidipop|bidilro|bidilre|bgroup|begingroupcatcode|batchmodecode|barasciicode|backslashasciicode|attributeunsetvalue|atsignasciicode|asciispacechar|ampersandasciicode|alignmentcatcode|aligngroupcode|adjustnodecode|adjustedhboxgroupcode|activetabtoken|activemathcharcode|activeformfeedtoken|activeendoflinetoken|activecatcode|activecatcode|Ux|Umathaccents|!!es|!!bs)(?=[^a-zA-Z])", + "match" : "\u005C\u005C(zwnj|zwj|zerowidthspace|zerowidthnonjoiner|zerowidthnobreakspace|zerowidthjoiner|zeroskip|zeropoint|zeromuskip|zerocount|xmlcatcodes|xifcode|xetexengine|wildcardsymbol|whatsitnodecode|vtopgroupcode|vrbcatcodes|voidifcode|voidbox|vmodeifcode|vlistnodecode|vcentergroupcode|vboxifcode|vboxgroupcode|vadjustgroupcode|usetexmodule|usemodule|useluamodule|uprotationangle|unsetnodecode|unknownengine|unexpandeddocumentvariable|underscoreasciicode|undefined|typescripttwo|typescriptthree|typescriptone|txtcatcodes|twoperemspace|trueifcode|tpbcatcodes|tpacatcodes|tildeasciicode|threeperemspace|thousandpoint|texengineversion|texenginename|texenginefunctionality|texengine|texcatcodes|tabasciicode|superscriptcatcode|subscriptcatcode|stoptext|stopproject|stopproduct|stopnotmode|stopnotext|stopnotallmodes|stopmodule|stopmodeset|stopmodeset|stopmode|stopmkivmode|stoplmtxmode|stopenvironment|stopdocument|stopcomponent|stopallmodes|stopTEXpage|starttext|startproject|startproduct|startnotmode|startnotext|startnotallmodes|startmodule|startmodeset|startmodeset|startmode|startmkivmode|startlmtxmode|startenvironment|startdocument|startcomponent|startallmodes|startTEXpage|spacecatcode|spaceasciicode|softhyphen|smallskipamount|slantperpoint|sixperemspace|singlequoteasciicode|simplegroupcode|setupmodule|setupdocument|semisimplegroupcode|scrollmodecode|scaledpoint|rulenodecode|rlm|righttoleftmark|rightrotationangle|rightparentasciicode|rightbraceasciicode|questionmarkasciicode|pushmode|punctuationspace|prtcatcodes|project|product|primeasciicode|preventmode|presetdocument|popmode|points|plustwohundred|plustwo|plustwentythousand|plusthree|plusthousand|plustenthousand|plusten|plussixteen|plussix|plusseven|plusonehundred|plusone|plusnine|plushundred|plusfour|plusfivehundred|plusfive|plusfifty|pluseight|pluscxxviii|pluscxxvii|pluscclvi|pluscclv|periodasciicode|penaltynodecode|pdftexengine|parfillrightskip|parfillleftskip|parametercatcode|outputnewlinechar|outputgroupcode|othercatcode|optionalspace|onepoint|onemuskip|onebasepoint|oddifcode|numifcode|notcatcodes|normalpagebox|nonstopmodecode|nonbreakablespace|nobreakspace|noaligngroupcode|nilcatcodes|newlineasciicode|narrownobreakspace|muquad|morethanasciicode|moduleparameter|mmodeifcode|mksuffix|minustwo|minusone|medskipamount|medcard|maxdimen|maxcount|maxcardminusone|maxcard|mathsnodecode|mathsizesuffix|mathshiftgroupcode|mathshiftcatcode|mathrelcode|mathradicalcode|mathpunctcode|mathordcode|mathopencode|mathopcode|mathnothingcode|mathnolopcode|mathnodecode|mathlimopcode|mathleftgroupcode|mathinnercode|mathgroupcode|mathexheight|mathemwidth|mathclosecode|mathchoicegroupcode|mathchoicecode|mathboxcode|mathbincode|mathaxisheight|mathalphacode|mathaccentcode|mathabovegroupcode|marknodecode|luatexengine|luastringsep|luacatcodes|lrm|ligaturenodecode|lettercatcode|lessthanasciicode|lefttorightmark|leftrotationangle|leftparentasciicode|leftbraceasciicode|kernnodecode|invalidcatcode|interwordstretch|interwordspace|interwordshrink|insertnodecode|insertgroupcode|innerifcode|inicatcodes|ignorecatcode|ideographicspace|ideographichalffillspace|hyphenasciicode|hmodeifcode|hlistnodecode|hboxifcode|hboxgroupcode|hashasciicode|halfpoint|halfapoint|hairspace|gluenodecode|globalpreventmode|globalenablemode|globaldisablemode|fourperemspace|forwardslashasciicode|formfeedasciicode|fontslantperpoint|fontinterwordstretch|fontinterwordspace|fontinterwordshrink|fontextraspace|fontexheight|fontemwidth|fontcharifcode|fmtversion|fmtname|fiveperemspace|figurespace|falseifcode|extraspace|exheight|exclamationmarkasciicode|everystoptext|everystarttext|escapecatcode|errorstopmodecode|eofifcode|environment|enquad|endoflinetoken|endoflinecatcode|endoflineasciicode|endoffileasciicode|endline|endgroupcatcode|enablemode|emwidth|emquad|emptyvbox|emptytoks|emptyhbox|emptybox|empty|egroup|eUx|downrotationangle|doublequoteasciicode|doublecommentsignal|dollarasciicode|doifnotmode|doifnotdocumentvariable|doifnotallmodes|doifmodeelse|doifmode|doifelsemode|doifelsedocumentvariable|doifelseallmodes|doifdocumentvariableelse|doifdocumentvariable|doifallmodeselse|doifallmodes|documentvariable|discretionarynodecode|discretionarygroupcode|disablemode|directionrighttoleft|directionlefttoright|dimifcode|delasciicode|definemode|definedifcode|currentmoduleparameter|ctxcatcodes|ctdcatcodes|csnameifcode|continueifinputfile|contextversion|contextmark|contextlmtxmode|contextkind|contextformat|constantnumberargument|constantnumber|constantemptyargument|constantdimenargument|constantdimen|conditionaltrue|conditionalfalse|component|commentcatcode|commentasciicode|commaasciicode|colonasciicode|circumflexasciicode|charnodecode|charifcode|catifcode|caseifcode|breakablethinspace|bottomlevelgroupcode|bigskipamount|bidirlo|bidirle|bidipop|bidilro|bidilre|bgroup|begingroupcatcode|batchmodecode|barasciicode|backslashasciicode|attributeunsetvalue|atsignasciicode|asciispacechar|ampersandasciicode|alignmentcatcode|aligngroupcode|adjustnodecode|adjustedhboxgroupcode|activetabtoken|activemathcharcode|activeformfeedtoken|activeendoflinetoken|activecatcode|activecatcode|Ux|Umathaccents|!!es|!!bs)(?=[^a-zA-Z])", "name" : "context.constant.commands.constant.tex" }, "csname" : { diff --git a/doc/context/documents/general/manuals/evenmore.pdf b/doc/context/documents/general/manuals/evenmore.pdf index 6e5b1105e..0f7da622e 100644 Binary files a/doc/context/documents/general/manuals/evenmore.pdf and b/doc/context/documents/general/manuals/evenmore.pdf differ diff --git a/doc/context/documents/general/manuals/luametatex.pdf b/doc/context/documents/general/manuals/luametatex.pdf index 93dcc0868..f3a25d6b3 100644 Binary files a/doc/context/documents/general/manuals/luametatex.pdf and b/doc/context/documents/general/manuals/luametatex.pdf differ diff --git a/doc/context/sources/general/manuals/evenmore/evenmore-parsing.tex b/doc/context/sources/general/manuals/evenmore/evenmore-parsing.tex new file mode 100644 index 000000000..d0cc29db1 --- /dev/null +++ b/doc/context/sources/general/manuals/evenmore/evenmore-parsing.tex @@ -0,0 +1,425 @@ +% language=us + +\environment evenmore-style + +\startcomponent evenmore-parsing + +\startchapter[title=Parsing] + +The macro mechanism is \TEX\ is quite powerful and once you understand the +concept of mixing parameters and delimiters you can do a lot with it. I assume +that you know what we're talking about, otherwise quit reading. When grabbing +arguments, there are a few catches. + +\startitemize +\startitem + When they are used, delimiters are mandate: \TEX\ will go on reading an + argument till the (current) delimiter condition is met. This means that when + you forget one you end up with way more in the argument than expected or even + run out of input. +\stopitem +\startitem + Because specified arguments and delimiters are mandate, when you want to + parse input, you often need multi|-|step macros that first pick up the to be + parsed input, and then piecewise fetch snippets. Bogus delimiters have to be + appended to the original in order to catch a run away argument and checking + has to be done to get rid of them when all is ok. +\stopitem +\stopitemize + +The first item can be illustrated as follows: + +\starttyping[option=TEX] +\def\foo[#1]{...} +\stoptyping + +When \type {\foo} gets expanded \TEX\ first looks for a \type{[} and then starts +collecting tokens for parameter \type {#1}. It stops doing that when aa \type {]} +is seen. So, + +\starttyping[option=TEX] +\starttext + \foo[whatever +\stoptext +\stoptyping + +will for sure give an error. When collecting tokens, \TEX\ doesn't expand them so +the \type {\stoptext} is just turned into a token that gets appended. + +The second item is harder to explain (or grasp): + +\starttyping[option=TEX] +\def\foo[#1=#2]{(#1/#2)} +\stoptyping + +Here we expect a key and a value, so these will work: + +\starttyping[option=TEX] +\foo[key=value] +\foo[key=] +\stoptyping + +while these will fail: + +\starttyping[option=TEX] +\foo[key] +\foo[] +\stoptyping + +unless we have: + +\starttyping[option=TEX] +\foo[key]=] +\foo[]=] +\stoptyping + +But, when processing the result, we then need to analyze the found arguments and +correct for them being wrong. For instance, argument \type {#1} can become \type +{]} or here \type {key]}. When indeed a valid key|/|value combination is given we +need to get rid of the two \quote {fixup} tokens \type{=]}. Normally we will have +multiple key|/|value pairs separated by a comma, and in practice we only need to +catch the missing equal because we can ignore empty cases. There are plenty of +examples (rather old old code but also more modern variants) in the \CONTEXT\ +code base. + +I will now show some new magic that is available in \LUAMETATEX\ as experimental +code. It will be tested in \LMTX\ for a while and might evolve in the process. + +\startbuffer +\def\foo#1=#2,{(#1/#2)} + +\foo 1=2,\ignorearguments +\foo 1=2\ignorearguments +\foo 1\ignorearguments +\foo \ignorearguments +\stopbuffer + +\typebuffer[option=TEX] + +Here we pick up a key and value separated by an equal sign. We end the input with +a special signal command: \type {\ignorearguments}. This tells the parser to quit +scanning. So, we get this, without any warning with respect to a missing +delimiter of running away: + +\getbuffer + +The implementation is actually fairly simple and adds not much overhead. +Alternatives (and I pondered a few) are just too messy, would remind me too much +of those awful expression syntaxes, and definitely impact performance of macro +expansion, therefore: a no|-|go. + +Using this new feature, we can implement a key value parser that does a sequence. +The prototypes used to get here made only use of this one new feature and +therefore still had to do some testing of the results. But, after looking at the +code, I decided that a few more helpers could make better looking code. So this +is what I ended up with: + +\startbuffer +\def\grabparameter#1=#2,% + {\ifarguments\or\or + % (\whatever/#1/#2)\par% + \expandafter\def\csname\namespace#1\endcsname{#2}% + \expandafter\grabnextparameter + \fi} + +\def\grabnextparameter + {\expandafterspaces\grabparameter} + +\def\grabparameters[#1]#2[#3]% + {\def\namespace{#1}% + \expandafterspaces\grabparameter#3\ignorearguments\ignorearguments} +\stopbuffer + +\typebuffer[option=TEX] + +Now, this one actually does what the \CONTEXT\ \type {\getparameters} command +does: setting variables in a namespace. Being a parameter driven macro package +this kind of macros have been part of \CONTEXT\ since the beginning. There are +some variants and we also need to deal with the multilingual interface. Actually, +\MKIV\ (and therefore \LMTX) do things a bit different, but the same principles +apply. + +The \type {\ignorearguments} quits the scanning. Here we need two because we +actually quit twice. The \type {\expandafterspaces} can be implemented in +traditional \TEX\ macros but I though it is nice to have it this way; the fact +that I only now added it has more to do with cosmetics. One could use the already +somewhat older extension \type {\futureexpandis} (which expands the second or +third token depending seeing the first, in this variant ignoring spaces) or a +bunch of good old primitives to do the same. The new conditional \type +{\ifarguments} can be used to act upon the number of arguments given. It reflects +the most recently expanded macro. There is also a \type {\lastarguments} +primitive (that provides the number of arguments. + +So, what are the benefits? You might think that it is about performance, but in +practice there are not that many parameter settings going on. When I process the +\LUAMETATEX\ manual, only some 5000 times one or more parameters are set. And +even in a way more complex document that I asked my colleague to run I was a bit +disappointed that only some 30.000 cases were reported. I know of users who have +documents with hundreds of thousands of cases, but compared to the rest of +processing this is not where the performance bottleneck is. \footnote {Think of +thousands of pages of tables with cell settings applied.} This means that a +change in implementation like the above is not paying off in significantly better +runtime: all these low level mechanisms in \CONTEXT\ have been very well +optimized over the years. And faster machines made old bottlenecks go away +anyway. Take this use case: + +\starttyping[option=TEX] +\grabparameters + [foo] + [key0=value0, + key1=value1, + key2=value2, + key3=value3] +\stoptyping + +After this, parameters can be accessed with: + +\starttyping[option=TEX] +\def\getvalue#1#2{\csname#1#2\endcsname} +\stoptyping + +used as: + +\starttyping[option=TEX] +\getvalue{foo}{key2} +\stoptyping + +which takes care of characters normally not permitted in macro names, like the +digits in this example. Of course some namespace protection can be added, like +adding a colon between the namespace and the key, but let's take just this one. + +Some 10.000 expansions of the grabber take on my machine 0.045 seconds while the +original \type {\getparameters} takes 0.090 so although for this case we're twice +as fast, the 0.045 difference will not be noticed on a real run. After all, when +these parameters are set some action will take place. Also, we don't actually use +this macro for collecting settings with the \type {\setupsomething} commands, so +the additional overhead that is involved adds a baseline to performance that can +turn any gain into noise. But some users might notice some gain. Of course this +observation might change once we apply this trickery in more places than +parameter parsing, because I have to admit that there might be other places in +the support macros where we can benefit: less code, double performance, but these +are all support macros that made sense in \MKII\ and not that much in \MKIV\ or +\LMTX\ and are kept just for convenience and backward compatibility. Think of +some list processing macros. So, as a kind of nostalgic trip I decided to rewrite +some low level macros anyway, if only to see what is no longer used and|/|or to +make the code base somewhat (c)leaner. + +Elsewhere I introduce the \type {#0} argument indicator. That one will just +gobbles the argument and does not store a token list on the stack. It saves some +memory access and token recycling when arguments are not used. Another special +indicator is \type {#+}. That one will flag an argument to be passed as|-|is. The +\type {#-} variant will simply discard an argument and move on. The following +examples demonstrate this: + +\startbuffer +\def\foo [#1]{\detokenize{#1}} +\def\ofo [#0]{\detokenize{#1}} +\def\oof [#+]{\detokenize{#1}} +\def\fof[#1#-#2]{\detokenize{#1#2}} +\def\fff[#1#0#3]{\detokenize{#1#3}} + +\meaning\foo\ : <\foo[{123}]> \crlf +\meaning\ofo\ : <\ofo[{123}]> \crlf +\meaning\oof\ : <\oof[{123}]> \crlf +\meaning\fof\ : <\fof[123]> \crlf +\meaning\fff\ : <\fof[123]> \crlf +\stopbuffer + +\typebuffer[option=TEX] + +This gives: + +{\tttf \getbuffer} + +% \getcommalistsize[a,b,c] \commalistsize\par +% \getcommalistsize[{a,b,c}] \commalistsize\par + +When playing with new features like the one described here, it makes sense to use +them in existing macros so that they get well tested. Some of the low level +system files come in different versions: for \MKII, \MKIV\ and \LMTX. The \MKII\ +files often also have the older implementations, so they are also good for +looking at the history. The \LMTX\ files can be leaner and meaner than the \MKIV\ +files because they use the latest features. \footnote {Some 70 primitives present +in \LUATEX\ are not in \LUAMETATEX. On the other hand there are also about 70 new +primitives. Of those gone, most concerned the backend, fonts or no longer +relevant features from other engines. Of those new, some are really new +primitives (conditionals, expansion magic), some control previously hardwired +behaviour, some give access to properties of for instance boxes, and some are +just variants of existing ones but with options for control.} + +When I was rewriting some of these low level \MKIV\ macros using the newer features, +at some point I wondered why I still had to jump through some hoops. Why not just +add some more primitives to deal with that? After all, \LUATEX\ and \LUAMETATEX\ +already have more primitives that are helpful in parsing, so a few dozen more lines +don't hurt. As long as these primitives are generic and not that specific. In this +particular case we talk about two new conditionals (in addition to the already +present comparison primitives): + +\starttyping[option=TEX] +\ifhastok {} +\ifhastoks {} {} +\ifhasxtoks {} {} +\stoptyping + +You can probably guess what they do from their names. The last one is the +expandable variant of the second one. The first one is the fast one. When playing +with these I decided to redo the set checker. In \MKII\ that one is done in good +old \TEX, in \MKIV\ we use \LUA. So, how about going back to \TEX ? + +\starttyping[option=TEX] +\ifhasxtoks {cd} {abcdef} +\stoptyping + +This check is true. But that doesn't work well with a comma separated list, but +there is a way out: + +\starttyping[option=TEX] +\ifhasxtoks {,cd,} {,ab,cd,ef,} +\stoptyping + +However, when I applied that a user reported that it didn't handle optional +spaces before commas. So how do we deal with such optional characters tokens? + +\startbuffer +\def\setcontains#1#2{\ifhasxtoks{,#1,}{,#2,}} + +\ifcondition\setcontains{cd}{ab,cd,ef}YES \else NO \fi +\ifcondition\setcontains{cd}{ab, cd, ef}YES \else NO \fi +\stopbuffer + +\typebuffer[option=TEX] + +We get: + +\getbuffer + +The \type {\ifcondition} is an old one. When nested in a condition it will be +seen as an \type {\if...} by the fast skipping scanner, but when expanded it will +go on and a following macro has to expand to a proper condition. That said, we +can take care of the optional space by entering some new territory. Look at this: + +\startbuffer +\def\setcontains#1#2{\ifhasxtoks{,\expandtoken 9 "20 #1,}{,#2,}} + +\ifcondition\setcontains{cd}{ab,cd,ef}YES \else NO \fi +\ifcondition\setcontains{cd}{ab, cd, ef}YES \else NO \fi +\stopbuffer + +\typebuffer[option=TEX] + +We get: + +\getbuffer + +So how does that work? The \type {\expandtoken} injects a space token with +catcode~9 which means that it is in the to be ignored category. When a to be +ignored token is seen, and the to be checked token is a character (letter, other, +space or ignored) then the character code will be compared. When they match, we +move on, otherwise we just skip over the ignored token (here the space). + +In the \CONTEXT\ code base there are already files that are specific for \MKIV\ +and \LMTX. The most visible difference is that we use the \type {\orelse} +primitive to construct nicer test trees, and we also use some of the additional +\type {\future...} and \type {\expandafter...} features. The extensions discussed +here make for the most recent differences (we're talking end May 2020). + +After implementing this trick I decided to look at the macro definition mechanism +one more time and see if I could also use this there. Before I demonstrate +another next feature, I will again show the argument extensions, this time with +a fourth variant: + +\startbuffer[definitions] +\def\TestA#1#2#3{{(#1)(#2)(#3)}} +\def\TestB#1#0#3{(#1)(#2)(#3)} +\def\TestC#1#+#3{(#1)(#2)(#3)} +\def\TestD#1#-#2{(#1)(#2)} +\stopbuffer + +\typebuffer[definitions][option=TEX] \getbuffer[definitions] + +The last one specifies a to be thrashed argument: \type {#-}. It goes further +than the second one (\type {#0}) which still keeps a reference. This is why in +this last case the third argument gets number \type {2}. The meanings of these +four are: + +\startlines \tttf +\meaning\TestA +\meaning\TestB +\meaning\TestC +\meaning\TestD +\stoplines + +There are some subtle differences between these variants, as you can see from +the following examples: + +\startbuffer[usage] +\TestA1{\red 2}3 +\TestB1{\red 2}3 +\TestC1{\red 2}3 +\TestD1{\red 2}3 +\stopbuffer + +\typebuffer[usage][option=TEX] + +Here you also see the side effect of keeping the braces. The zero argument (\type +{#0}) is ignored, and the thrashed argument (\type {#-}) can't even be accessed. + +\startlines \tttf \getbuffer[usage] \stoplines + +In the next example we see two delimiters being used, a comma and a space, but +they have catcode~9 which flags them as ignored. This is a signal for the parser +that both the comma and the space can be skipped. The zero arguments are still on +the parameter stack, but the thrashed ones result in a smaller stack, not that +the later matters much on today's machines. + +\startbuffer +\normalexpanded { + \def\noexpand\foo + \expandtoken 9 "2C % comma + \expandtoken 9 "20 % space + #1=#2]% +}{(#1)(#2)} +\stopbuffer + +\typebuffer[option=TEX] \getbuffer + +This means that the next tree expansions won't bark: + +\startbuffer +\foo,key=value] +\foo, key=value] +\foo key=value] +\stopbuffer + +\typebuffer[option=TEX] + +or expanded: + +\startlines \tttf \getbuffer \stoplines + +Now, why didn't I add these primitives long ago already? After all, I already +added dozens of new primitives over the years. To quote Andrew Cuomo, what +follows now are opinions, not facts. + +Decades ago, when \TEX\ showed up, there was no Internet. I remember that I got +my first copy on floppy disks. Computers were slow and memory was limited. The +\TEX book was the main resource and writing macros was a kind of art. One could +not look up solutions, so trial and error was a valid way to go. Figuring out +what was efficient in terms of memory consumption and runtime was often needed +too. I remember meetings where one was not taken serious when not talking in the +right \quote {token}, \quote {node}, \quote {stomach} and \quote {mouth} speak. +Suggesting extensions could end up in being told that there was no need because +all could be done in macros or even arguments of the \quotation {who needs that}. +I must admit that nowadays I wonder to what extend that was related to extensions +taking away some of the craftmanship and showing off. In a way it is no surprise +that (even trivial to implement) extensions never surfaced. Of course then the +question is: will extensions that once were considered not of importance be used +today? We'll see. + +Let's end by saying that, as with other experiments, I might port some of the new +features in \LUAMETATEX\ to \LUATEX, but only after they have become stable and +have been tested in \LMTX\ for quite a while. + +\stopchapter + +\stopcomponent diff --git a/doc/context/sources/general/manuals/evenmore/evenmore-tokens.tex b/doc/context/sources/general/manuals/evenmore/evenmore-tokens.tex new file mode 100644 index 000000000..d653703a9 --- /dev/null +++ b/doc/context/sources/general/manuals/evenmore/evenmore-tokens.tex @@ -0,0 +1,460 @@ +% language=us + +% TODO: copy_node_list : return tail +% TODO: grabnested + +\environment evenmore-style + +\startcomponent evenmore-tokens + +\startchapter[title=Tokens] + +\usemodule[article-basic,abbreviations-logos] + +\starttext + +{\em This is mostly a wrapup of some developments, and definitely not a tutorial.} + +Talking deep down \TEX\ is talking about tokens and nodes. Roughly spoken, from +the perspective of the user, tokens are what goes in and stays in (as macro, +token list of whatever) and nodes is what get produced and eventually results in +output. A character in the input becomes one token (before expansion) and a +control sequence like \type {\foo} also is turned into a token. Tokens can be +linked into lists. This actually means that in the engine we can talk of tokens +in two ways: the single item with properties that trigger actions, or as compound +item with that item and a pointer to the next token (called link). In \LUA\ speak +token memory can be seen as: + +\starttyping +fixmem = { + { info, link }, + { info, link }, + { info, link }, + { info, link }, + .... +} +\stoptyping + +Both are 32 bit integers. The \type {info} is a combination of a command code (an +operator) and a so called chr code (operand) and these determine its behaviour. +For instance the command code can indicate an integer register and the chr code +then indicates the number of that register. So, like: + +\starttyping +fixmem = { + { { cmd, chr}, index_into_fixmem }, + { { cmd, chr}, index_into_fixmem }, + { { cmd, chr}, index_into_fixmem }, + { { cmd, chr}, index_into_fixmem }, + .... +} +\stoptyping + + +In the following line the characters that make three words are tokens (letters), +so are the space (spacer), the curly braces (begin- and endgroup token) and the +bold face switch (which becomes one token which resolves to a token list of +tokens that trigger actions (in this case switching to a bolder font). + +\starttyping +foo {\bf bar} foo +\stoptyping + +When \TEX\ reads a line of input tokens are expanded immediately but a sequence +can also become part fo a macro body or token list. Here we have $3_{\type{foo}} ++ 1 + 1_{\type+{+} + 1_{\type{\bf}} + 3_{\type{bar}} + 1_{\type+}+} + 1 + +3_{\type{foo}} = 14$ tokens. + +A control sequence normally starts with a backslash. Some are built in, these are +called primitives, and others are defined by the macro package or the user. There +is a lookup table that relates the tokenized control sequence to some action. For +instance: + +\starttyping +\def\foo{foo} +\stoptyping + +creates an entry that leads (directly or following a hash chain) to the three +letter token list. Every time the input sees \type {\foo} it gets resolved to +that list via a hash lookup. However, once internalized and part of a token list, +it is a direct reference. On the other hand, + +\starttyping +\the\count0 +\stoptyping + +triggers the \type {\the} action that relates to this control sequence, which +then reads a next token and operates on that. That next token itself expects a +number as follow up. In the end the value of \type {\count0} is found and that +one is also in the so called equivalent lookup table, in what \TEX\ calls +specific regions. + +\starttyping +equivalents = { + { level, type, value }, + { level, type, value }, + { level, type, value }, + ... +} +\stoptyping + +The value is in most cases similar to the info (cmd & chr) field in fixmem, but +one difference is that counters, dimensions etc directly store their value, which +is why we sometimes need the type separately, for instance in order to reclaim +memory for glue or node specifications. It sound complicated and it is, but as +long as you get a rough idea we can continue. Just keep in mind that tokens +sometimes get expanded on the fly, and sometimes just get stored. + +There are a lot of primitives and each has a unique info. The same is true for +characters (each category has its own command code, so regular letters can be +distinguished from other tokens, comment signs, math triggers etc). All important +basic bits are in table of equivalents: macros as well as registers although the +meaning of a macro and content of token lists lives in the fixmem table and +the content of boxes in so called node lists (nodes have their own memory). + +In traditional \TEX\ the lookup table for primitives, registers and macros is as +compact as can be: it is an array of so called 32 bit memory words. These can be +divided into halfs and quarters, so in the source you find terms like \type +{halfword} and \type {quarterword}. The lookup table is a hybrid: + +\starttyping +[level 8] [type 8] [value 16] | [equivalent 32] +[level 8] [type 8] [value 16] | [equivalent 32] +[level 8] [type 8] [value 16] | [equivalent 32] +... +\stoptyping + +The mentioned counters and such are directly encoded in an equivalent and the +rest is a combination of level, type and value. The level is used for the +grouping, and in for instance \PDFTEX\ there can therefore be at most 255 levels. +In \LUATEX\ we use a wider model. There we have 64 bit memory words which means +that we have way more levels and don't need to have this dual nature: + +\starttyping +[level 16] [type 16] [value 32] +[level 16] [type 16] [value 32] +[level 16] [type 16] [value 32] +... +\stoptyping + +We already showed a \LUA\ representation. The type in this table is what a +command code is in an \quote {info} field. In such a token the integer encodes +the command as well as a value (called chr). In the lookup table the type is the +command code. When \TEX\ is dealing with a control sequences it looks at the +type, otherwise it filters the command from the token integer. This means that a +token cannot store an integer (or dimension), but the lookup table actually can +do that. However, commands can limit the range, for instance characters are bound +by what \UNICODE\ permits. + +Internally, \LUATEX\ still uses these ranges of fast accessible registers, like +counters, dimensions and attributes. However, we saw that in \LUATEX\ they don't +overlap with the level and type. In \LUATEX, at least till version 1.13 we still +have the shadow array for levels but in \LUAMETATEX\ we just use those in the +equivalents lookup table. If you look in the \PASCAL\ source you will notice that +arrays run from \type {[somemin ... somemax]} which in the \CCODE\ source would +mean using offsets. Actually, the shadow array starts at zero so we waste the +part that doesn't need shadowing. It is good to remind ourselves that traditional +\TEX\ is 8 bit character based. + +The equivalents lookup table has all kind of special ranges (combined into +regions of similar nature, in \TEX\ speak), like those for lowercase mapping, +specific catcode mappings, etc.\ but we're still talking of $n \times 256$ +entries. In \LUATEX\ all these mappings are in dedicated sparse hash tables +because we need to support the full \UNICODE\ repertoire. This means that, while +on the one hand \LUATEX\ uses more memory for the lookup table the number of +slots can be less. But still there was the waste of the shadow level table: I +didn't calculate the exact saving of ditching that one, but I bet it came close +to what was available as total memory for programs and data on the first machines +that I used for running \TEX. But \unknown\ after more than a decade of \LUATEX\ +we now reclaimed that space in \LUAMETATEX. \footnote {Don't expect a gain in +performance, although using less memory might pay back on a virtual machine or +when \TEX\ has to share the \CPU\ cache.} + +Now, in case you're interested (and actually I just write it down because I don't +want to forget it myself) the lookup table in \LUAMETATEX\ is layout as follows + +\starttabulate +\NC the hash table \NC \NC \NR +\NC some frozen primitives \NC \NC \NR +\NC current and defined fonts \NC one slot + many pointers \NC \NR +\NC undefined control sequence \NC one slot \NC \NR +\NC internal and register glue \NC pointer to node \NC \NR +\NC internal and register muglue \NC pointer to node \NC \NR +\NC internal and register toks \NC pointer to token list \NC \NR +\NC internal and register boxes \NC pointer to node list \NC \NR +\NC internal and register counts \NC value in token \NC \NR +\NC internal and register attributes \NC value in token \NC \NR +\NC internal and register dimens \NC value in token \NC \NR +\NC some special data structures \NC pointer to node list \NC \NC \NR +\NC the (runtime) extended hash table \NC \NC \NR +\stoptabulate + +Normally a user doesn't need to know anything about these specific properties of +the engine and it might comfort you to know that for a long time I could stay +away from these details. One difference with the other engines is that we have +internal variables and registers split more explicitly. The special data +structures have their own slots and are not just put somewhere (semi random). The +initialization is bit more granular in that we properly set the types (cmd codes) +for registers which in turn is possible because for instance we're able to +distinguish glue types. This is all part of coming up with a bit more consistent +interface to tokens from the \LUA\ end. It also permits diagnostics. + +Anyway, we now are ready for some more details about tokens. You don't need to +understand all of it in order to define decent macros. But when you are using +\LUATEX\ and do want to mess around here is some insight. Assume we have defined +these macros: + +\startluacode + local alsoraw = false + function documentdata.StartShowTokens(rawtoo) + context.starttabulate { "|T|rT|lT|rT|rT|rT|" .. (rawtoo and "rT|" or "") } + context.BC() + context.BC() context("cmd") + context.BC() context("name") + context.BC() context("chr") + context.BC() context("cs") + if rawtoo then + context.BC() context("rawchr") + end + context.BC() context.NR() + context.SL() + alsoraw = rawtoo + end + function documentdata.StopShowTokens() + context.stoptabulate() + end + function documentdata.ShowToken(name) + local cmd, chr, cs = token.get_cmdchrcs(name) + local _, raw, _ = token.get_cmdchrcs(name,true) + context.NC() context("\\string\\"..name) + context.NC() context(cmd) + context.NC() context(tokens.commands[cmd]) + context.NC() context(chr) + context.NC() context(cs) + if alsoraw and chr ~= raw then + context.NC() context(raw) + end + context.NC() context.NR() + end +\stopluacode + +\startbuffer +\def\MacroA{a} \def\MacroB{b} +\def\macroa{a} \def\macrob{b} +\def\MACROa{a} \def\MACROb{b} +\stopbuffer + +\typebuffer \getbuffer + +How does that end up internally? + +\startluacode + documentdata.StartShowTokens(true) + documentdata.ShowToken("scratchcounterone") + documentdata.ShowToken("scratchcountertwo") + documentdata.ShowToken("scratchdimen") + documentdata.ShowToken("scratchtoks") + documentdata.ShowToken("scratchcounter") + documentdata.ShowToken("letterpercent") + documentdata.ShowToken("everypar") + documentdata.ShowToken("%") + documentdata.ShowToken("pagegoal") + documentdata.ShowToken("pagetotal") + documentdata.ShowToken("hangindent") + documentdata.ShowToken("hangafter") + documentdata.ShowToken("dimdim") + documentdata.ShowToken("relax") + documentdata.ShowToken("dimen") + documentdata.ShowToken("stoptext") + documentdata.ShowToken("MacroA") + documentdata.ShowToken("MacroB") + documentdata.ShowToken("MacroC") + documentdata.ShowToken("macroa") + documentdata.ShowToken("macrob") + documentdata.ShowToken("macroc") + documentdata.ShowToken("MACROa") + documentdata.ShowToken("MACROb") + documentdata.ShowToken("MACROc") + documentdata.StopShowTokens() +\stopluacode + +We show the raw chr value but in the \LUA\ interface these are normalized to for +instance proper register indices. This is because the raw numbers can for +instance be indices into memory or some \UNICODE\ reference with catcode specific +bits set. But, while these indices are real and stable, these offsets can +actually change when the implementation changes. For that reason, in \LUAMETATEX\ +we can better talk of command codes as main indicator and: + +\starttabulate +\NC subcommand \NC for tokens that have variants, like \type {\ifnum} \NC \NR +\NC register indices \NC for the 64K register banks, like \type {\count0} \NC \NR +\NC internal indices \NC for internal variables like \type {\parindent} \NC \NR +\NC characters \NC specific \UNICODE\ slots combined with catcode \NC \NR +\NC pointers \NC to token lists, macros, \LUA\ functions, nodes \NC \NR +\stoptabulate + +This so called \type {cs} number is a pointer into the table of equivalents. That +number results comes from the hash table. A macro name, when scanned the first +time, is still a sequence of bytes. This sequence is used to compute a hash +number, which is a pointer to a slot in the lower part of the hash (lookup) +table. That slot points to a string and a next hash entry in the higher end. A +lookup goes as follows: + +\startitemize[n,packed] + \startitem + compute the index into the hash table from the string + \stopitem + \startitem + goto the slot with that index and compare the \type {string} field + \stopitem + \startitem + when there is no match goto the slot indicated by the \type {next} field + \stopitem + \startitem + compare again and keep following \type {next} fields till there is no + follow up + \stopitem + \startitem + optionally create a new entry + \stopitem + \startitem + use the index of that entry as index in the table of equivalents + \stopitem +\stopitemize + +So, in \LUA\ speak, we have: + +\starttyping +hashtable = { + -- lower part, accessed via the calculated hash number + { stringpointer, nextindex }, + { stringpointer, nextindex }, + ... + -- higher part, accessed by following nextindex + { stringpointer, nextindex }, + { stringpointer, nextindex }, + ... +} +\stoptyping + +Eventually, after following a lookup chain in the hash tabl;e, we end up at +pointer to the equivalents lookup table that we already discussed. From then on +we're talking tokens. When you're lucky, the list is small and you have a quick +match. The maximum initial hash index is not that large, around 64K (double that +in \LUAMETATEX), so in practice there will often be some indirect +(multi|-|compare) match but increasing the lower end of the hash table might +result in less string comparisons later on, but also increases the time to +calculate the initial hash needed for accessing the lower part. Here you can sort +of see that: + +\startbuffer +\dostepwiserecurse{`a}{`z}{1}{ + \expandafter\def\csname whatever\Uchar#1\endcsname + {} +} +\dostepwiserecurse{`a}{`z}{1}{ + \expandafter\let\csname somemore\Uchar#1\expandafter\endcsname + \csname whatever\Uchar#1\endcsname +} +\stopbuffer + +\typebuffer \getbuffer + +\startluacode + documentdata.StartShowTokens(true) + for i=utf.byte("a"),utf.byte("z") do + documentdata.ShowToken("whatever"..utf.char(i)) + documentdata.ShowToken("somemore"..utf.char(i)) + end + documentdata.StopShowTokens() +\stopluacode + +The command code indicates a macro and the action related to it is an expandable +call. We have no sub command \footnote {We cheat a little here because chr +actually is an index into token memory but we don't show them as such.} so that +column shows zeros. The fifth column is the hash entry which can bring us back to +the verbose name as needed in reporting while the last column is the index to +into token memory (watch the duplicates for \type {\let} macros: a ref count is +kept in order to be able to manage such shared references). When you look a the +cs column you will notice that some numbers are close which (I think) in this +case indicates some closeness in the calculated hash name and followed chain. + +It will be clear that it is best to not make any assumptions with respect to the +numbers which is why, in \LUAMETATEX\ we sort of normalize them when accessing +properties. + +\starttabulate +\NC field \NC meaning \NC \NR +\FL +\NC command \NC operator \NC \NR +\NC cmdname \NC internal name of operator \NC \NR +\NC index \NC sanitized operand \NC \NR +\NC mode \NC original operand \NC \NR +\NC csname \NC associated name \NC \NR +\NC id \NC the index in token memory (a virtual address) \NC \NR +\NC tok \NC the integer representation \NC \NR +\ML +\NC active \NC true when an active character \NC \NR +\NC expandable \NC true when expandable command \NC \NR +\NC protected \NC true when a protected command \NC \NR +\NC frozen \NC true when a frozen command \NC \NR +\NC user \NC true when a user defined command \NC \NR +\LL +\stoptabulate + +When a control sequence is an alias to an existing primitive, for instance +made by \type {\let}, the operand (chr) picked up from its meaning. Take this: + +\startbuffer +\newif\ifmyconditionone +\newif\ifmyconditiontwo + + \meaning\ifmyconditionone \crlf + \meaning\ifmyconditiontwo \crlf + \meaning\myconditiononetrue \crlf + \meaning\myconditiontwofalse \crlf +\myconditiononetrue \meaning\ifmyconditionone \crlf +\myconditiontwofalse\meaning\ifmyconditiontwo \crlf +\stopbuffer + +\typebuffer \getbuffer + +Internally this is: + +\startluacode + documentdata.StartShowTokens(false) + documentdata.ShowToken("ifmyconditionone") + documentdata.ShowToken("ifmyconditiontwo") + documentdata.ShowToken("iftrue") + documentdata.ShowToken("iffalse") + documentdata.StopShowTokens() +\stopluacode + +The whole list of available commands is given below. Once they are stable the \LUAMETATEX\ manual +will document the accessors. In this chapter we use: + +\starttyping +kind, min, max, fixedvalue token.get_range("primitive") +cmd, chr, cs = token.get_cmdchrcs("primitive") +\stoptyping + +The kind of command is given in the first column, which can have the following values: + +\starttabulate[|l|l|p|] +\NC 0 \NC no \NC not accessible \NC \NR +\NC 1 \NC regular \NC possibly with subcommand \NC \NR +\NC 2 \NC character \NC the \UNICODE\ slot is encodes in the the token \NC \NR +\NC 3 \NC register \NC this is an indexed register (zero upto 64K) \NC \NR +\NC 4 \NC internal \NC this is an internal register (range given) \NC \NR +\NC 5 \NC reference \NC this is a reference to a node, \LUA\ function, etc. \NC \NR +\NC 6 \NC data \NC a general data entry (kind of private) \NC \NR +\NC 7 \NC token \NC a token reference (that can have a followup) \NC \NR +\stoptabulate + +\usemodule[system-tokens] + +\start \switchtobodyfont[7pt] \showsystemtokens \stop + +\stopchapter + +\stopcomponent diff --git a/doc/context/sources/general/manuals/evenmore/evenmore.tex b/doc/context/sources/general/manuals/evenmore/evenmore.tex index b662e5108..c2e4e232b 100644 --- a/doc/context/sources/general/manuals/evenmore/evenmore.tex +++ b/doc/context/sources/general/manuals/evenmore/evenmore.tex @@ -22,8 +22,9 @@ \component evenmore-whattex \component evenmore-numbers % \component evenmore-parameters - % \component evenmore-parsing - % \component evenmore-tokens + \startchapter[title=Parameters] {\em This will appear first in \TUGBOAT.} \stopchapter + \component evenmore-parsing + \component evenmore-tokens \stopbodymatter \stopdocument diff --git a/doc/context/sources/general/manuals/luametatex/luametatex-tex.tex b/doc/context/sources/general/manuals/luametatex/luametatex-tex.tex index 8aa7408d6..7dfc00313 100644 --- a/doc/context/sources/general/manuals/luametatex/luametatex-tex.tex +++ b/doc/context/sources/general/manuals/luametatex/luametatex-tex.tex @@ -653,6 +653,8 @@ tex.currentifbranch \libindex{scantoks} +\libindex{getmark} + \TEX's attributes (\lpr {attribute}), counters (\prm {count}), dimensions (\prm {dimen}), skips (\prm {skip}, \prm {muskip}) and token (\prm {toks}) registers can be accessed and written to using two times five virtual sub|-|tables of the @@ -788,6 +790,12 @@ tex.scantoks("global",0,3,"$\int\limits^1_2$") In the function-based interface, it is possible to define values globally by using the string \type {global} as the first function argument. +There is a dedicated getter for marks: \type {getmark} that takes two arguments. +The first argument is one of \type {top}, \type {bottom}, \type {first}, \type +{splitbottom} or \type {splitfirst}, and the second argument is a marks class +number. When no arguments are given the current maximum number of classes is +returned. + \stopsubsection \startsubsection[title={Character code registers: \type {[get|set]*code[s]}}] @@ -2087,6 +2095,11 @@ macro, in which case the result will also provide information about what arguments are expected and in the result this is separated from the meaning by a separator token. The \type {expand} flag determines if the list will be expanded. +The \type {scan_argument} function expands the given argument. When a braced +argument is scanned, expansion can be prohibited by passing \type {false} +(default is \type {true}). In case of a control sequence passing \type {false} +will result in a one|-|level expansion (the meaning of the macro). + The string scanner scans for something between curly braces and expands on the way, or when it sees a control sequence it will return its meaning. Otherwise it will scan characters with catcode \type {letter} or \type {other}. So, given the diff --git a/doc/context/sources/general/manuals/luametatex/luametatex.tex b/doc/context/sources/general/manuals/luametatex/luametatex.tex index 0fd7a31b3..acdffcde3 100644 --- a/doc/context/sources/general/manuals/luametatex/luametatex.tex +++ b/doc/context/sources/general/manuals/luametatex/luametatex.tex @@ -9,13 +9,6 @@ % mswin 2562k 2555k mswin 2481k 2471k % ------------------------ ------------------------ -% experiment (if this becomes default we need to check visualizers and disable it when needed): - -\startluacode -nodes.handlers.cleanuppage = nodes.nuts.flatten_discretionaries -nodes.tasks.prependaction("shipouts", "normalizers", "nodes.handlers.cleanuppage", nil, "nut", "enabled") -\stopluacode - % 20200509 : 258 pages % % my 2013 i7 laptop with windows : 11.8 sec mingw64 diff --git a/tex/context/base/mkii/cont-new.mkii b/tex/context/base/mkii/cont-new.mkii index 7a8184ee4..3f7db0e5d 100644 --- a/tex/context/base/mkii/cont-new.mkii +++ b/tex/context/base/mkii/cont-new.mkii @@ -11,7 +11,7 @@ %C therefore copyrighted by \PRAGMA. See mreadme.pdf for %C details. -\newcontextversion{2020.06.14 22:04} +\newcontextversion{2020.06.17 18:56} %D This file is loaded at runtime, thereby providing an %D excellent place for hacks, patches, extensions and new diff --git a/tex/context/base/mkii/context.mkii b/tex/context/base/mkii/context.mkii index 8fcff83d3..595650caf 100644 --- a/tex/context/base/mkii/context.mkii +++ b/tex/context/base/mkii/context.mkii @@ -20,7 +20,7 @@ %D your styles an modules. \edef\contextformat {\jobname} -\edef\contextversion{2020.06.14 22:04} +\edef\contextversion{2020.06.17 18:56} %D For those who want to use this: diff --git a/tex/context/base/mkiv/cont-new.mkiv b/tex/context/base/mkiv/cont-new.mkiv index 58a3ef3e4..397aed038 100644 --- a/tex/context/base/mkiv/cont-new.mkiv +++ b/tex/context/base/mkiv/cont-new.mkiv @@ -13,7 +13,7 @@ % \normalend % uncomment this to get the real base runtime -\newcontextversion{2020.06.14 22:04} +\newcontextversion{2020.06.17 18:56} %D This file is loaded at runtime, thereby providing an excellent place for hacks, %D patches, extensions and new features. There can be local overloads in cont-loc diff --git a/tex/context/base/mkiv/context.mkiv b/tex/context/base/mkiv/context.mkiv index fc883aa5e..dec0327ff 100644 --- a/tex/context/base/mkiv/context.mkiv +++ b/tex/context/base/mkiv/context.mkiv @@ -45,7 +45,7 @@ %D {YYYY.MM.DD HH:MM} format. \edef\contextformat {\jobname} -\edef\contextversion{2020.06.14 22:04} +\edef\contextversion{2020.06.17 18:56} \edef\contextkind {beta} %D Kind of special: diff --git a/tex/context/base/mkiv/context.mkxl b/tex/context/base/mkiv/context.mkxl index fa498190b..0ca2406ea 100644 --- a/tex/context/base/mkiv/context.mkxl +++ b/tex/context/base/mkiv/context.mkxl @@ -29,7 +29,7 @@ %D {YYYY.MM.DD HH:MM} format. \edef\contextformat {\jobname} -\edef\contextversion{2020.06.14 22:04} +\edef\contextversion{2020.06.17 18:56} \edef\contextkind {beta} %D Kind of special: diff --git a/tex/context/base/mkiv/driv-shp.lua b/tex/context/base/mkiv/driv-shp.lua index e7f19aea0..569a1f8dc 100644 --- a/tex/context/base/mkiv/driv-shp.lua +++ b/tex/context/base/mkiv/driv-shp.lua @@ -547,7 +547,7 @@ local hlist_out, vlist_out do pos_r = getdirection(this_box) local boxwidth, boxheight, - boxdepth = getwhd(this_box) + boxdepth = getwhd(this_box) local cur_h = 0 local cur_v = 0 @@ -675,10 +675,10 @@ local hlist_out, vlist_out do end end elseif id == hlist_code or id == vlist_code then - local boxdir = getdirection(current) or lefttoright_code local width, height, depth = getwhd(current) local list = getlist(current) if list then + local boxdir = getdirection(current) or lefttoright_code local shift, orientation = getshift(current) if not orientation then local basepoint_h = boxdir ~= pos_r and width or 0 @@ -896,7 +896,7 @@ local hlist_out, vlist_out do local boxwidth, boxheight, - boxdepth = getwhd(this_box) + boxdepth = getwhd(this_box) local cur_h = 0 local cur_v = - boxheight @@ -997,10 +997,10 @@ local hlist_out, vlist_out do end end elseif id == hlist_code or id == vlist_code then - local boxdir = getdirection(current) or lefttoright_code local width, height, depth = getwhd(current) local list = getlist(current) if list then + local boxdir = getdirection(current) or lefttoright_code local shift, orientation = getshift(current) if not orientation then -- local basepoint_h = shift diff --git a/tex/context/base/mkiv/file-ini.mkvi b/tex/context/base/mkiv/file-ini.mkvi index 225b6b40d..5341cc07b 100644 --- a/tex/context/base/mkiv/file-ini.mkvi +++ b/tex/context/base/mkiv/file-ini.mkvi @@ -10,9 +10,8 @@ %C therefore copyrighted by \PRAGMA. See mreadme.pdf for %C details. -%D \TEX\ operates on files, so one wouldn't wonder that there -%D is a separate module for file commands. In \CONTEXT\ files -%D are used for several purposes: +%D \TEX\ operates on files, so one wouldn't wonder that there is a separate module +%D for file commands. In \CONTEXT\ files are used for several purposes: %D %D \startitemize[packed] %D \item general textual input @@ -21,10 +20,9 @@ %D \item buffering defered textual input %D \stopitemize %D -%D When dealing with files we can load them as a whole, using -%D the \type{\input} primitive or load them on a line||by||line -%D basis, using \type{\read}. Writing is always done line by -%D line, using \type{\write}. +%D When dealing with files we can load them as a whole, using the \type {\input} +%D primitive or load them on a line||by||line basis, using \type {\read}. Writing is +%D always done line by line, using \type {\write}. \writestatus{loading}{ConTeXt File Macros / Helpers} @@ -35,9 +33,9 @@ %D \macros %D {scratchread, scratchwrite} %D -%D We define a scratch file for reading. Keep in mind that -%D the number of files is limited to~16, so use this one when -%D possible. We also define a scratch output file. +%D We define a scratch file for reading. Keep in mind that the number of files is +%D limited to~16, so use this one when possible. We also define a scratch output +%D file. In \MKIV\ and \LMTX\ we never use these file handles. \ifdefined\scratchread \else \newread \scratchread \fi \ifdefined\scratchwrite \else \newwrite\scratchwrite \fi @@ -60,12 +58,10 @@ %D \macros %D {pushendofline,popendofline} %D -%D When we are loading files in the middle of the typesetting -%D process, for instance when we load references, we have to be -%D sure that the reading process does not generate so called -%D 'spurious spaces'. This can be prevented by assigning the -%D line ending character the \CATCODE\ comment. This is -%D accomplished by +%D When we are loading files in the middle of the typesetting process, for instance +%D when we load references, we have to be sure that the reading process does not +%D generate so called 'spurious spaces'. This can be prevented by assigning the line +%D ending character the \CATCODE\ comment. This is accomplished by %D %D \starttyping %D \pushendofline @@ -114,11 +110,10 @@ %D \macros %D {input, normalinput} %D -%D Sometimes we run into troubles when \type {\input} wants to get -%D expanded, e.g. in a \type {\write} (which happens in the metafun -%D manual when we permit long MP lines). So, instead of fixing that, -%D we go for a redefinition of \type {\input}. Of course it's better -%D to use \type {\readfile} or \type {\processfile}. +%D Sometimes we run into troubles when \type {\input} wants to get expanded, e.g. in +%D a \type {\write} (which happens in the metafun manual when we permit long MP +%D lines). So, instead of fixing that, we go for a redefinition of \type {\input}. +%D Of course it's better to use \type {\readfile} or \type {\processfile}. \unexpanded\def\input{\normalinput} @@ -127,8 +122,8 @@ %D \macros %D {doifelsefile} %D -%D The next alternative only looks if a file is present. No -%D loading is done. This one obeys the standard \TEX\ lookup. +%D The next alternative only looks if a file is present. No loading is done. This +%D one obeys the standard \TEX\ lookup. %D %D \starttyping %D \doiffileelse {filename} {found} {not found} @@ -155,7 +150,7 @@ %D \doifparentfileelse{filename}{yes}{no} %D \stoptyping -\ifx\outputfilename\undefined \def\outputfilename{\jobname} \fi +\ifdefined\outputfilename \else \def\outputfilename{\jobname} \fi \unexpanded\def\doifelseparentfile{\clf_doifelseparentfile} @@ -200,10 +195,9 @@ %D \macros %D {doonlyonce, doinputonce, doendinputonce} %D -%D Especially macropackages need only be loaded once. -%D Repetitive loading not only costs time, relocating registers -%D often leads to abortion of the processing because \TEX's -%D capacity is limited. One can prevent multiple execution and +%D Especially macropackages need only be loaded once. Repetitive loading not only +%D costs time, relocating registers often leads to abortion of the processing +%D because \TEX's capacity is limited. One can prevent multiple execution and %D loading by using one of both: %D %D \starttyping @@ -212,8 +206,8 @@ %D \doendinputonce{filename} %D \stoptyping %D -%D This command obeys the standard method for locating files. We could -%D move this function to the \LUA\ end. +%D This command obeys the standard method for locating files. We could move this +%D function to the \LUA\ end. \installsystemnamespace {fileonce} diff --git a/tex/context/base/mkiv/lxml-ini.lua b/tex/context/base/mkiv/lxml-ini.lua index 348ecbbe4..f9ba96ece 100644 --- a/tex/context/base/mkiv/lxml-ini.lua +++ b/tex/context/base/mkiv/lxml-ini.lua @@ -21,120 +21,122 @@ local implement = interfaces.implement -- lxml.id -implement { name = "lxmlid", actions = lxml.getid, arguments = "string" } - -implement { name = "xmldoif", actions = lxml.doif, arguments = "2 strings" } -implement { name = "xmldoifnot", actions = lxml.doifnot, arguments = "2 strings" } -implement { name = "xmldoifelse", actions = lxml.doifelse, arguments = "2 strings" } -implement { name = "xmldoiftext", actions = lxml.doiftext, arguments = "2 strings" } -implement { name = "xmldoifnottext", actions = lxml.doifnottext, arguments = "2 strings" } -implement { name = "xmldoifelsetext", actions = lxml.doifelsetext, arguments = "2 strings" } - -implement { name = "xmldoifempty", actions = lxml.doifempty, arguments = "2 strings" } -implement { name = "xmldoifnotempty", actions = lxml.doifnotempty, arguments = "2 strings" } -implement { name = "xmldoifelseempty", actions = lxml.doifelseempty, arguments = "2 strings" } -implement { name = "xmldoifselfempty", actions = lxml.doifempty, arguments = "string" } -- second arg is not passed (used) -implement { name = "xmldoifnotselfempty", actions = lxml.doifnotempty, arguments = "string" } -- second arg is not passed (used) -implement { name = "xmldoifelseselfempty", actions = lxml.doifelseempty, arguments = "string" } -- second arg is not passed (used) - ---------- { name = "xmlcontent", actions = lxml.content, arguments = "string" } ---------- { name = "xmlflushstripped", actions = lxml.strip, arguments = { "string", true } } - -implement { name = "xmlall", actions = lxml.all, arguments = "2 strings" } -implement { name = "xmlatt", actions = lxml.att, arguments = "2 strings" } -implement { name = "xmlattdef", actions = lxml.att, arguments = "3 strings" } -implement { name = "xmlattribute", actions = lxml.attribute, arguments = "3 strings" } -implement { name = "xmlattributedef", actions = lxml.attribute, arguments = "4 strings" } -implement { name = "xmlbadinclusions", actions = lxml.badinclusions, arguments = "string" } -implement { name = "xmlchainatt", actions = lxml.chainattribute, arguments = { "string", "'/'", "string" } } -implement { name = "xmlchainattdef", actions = lxml.chainattribute, arguments = { "string", "'/'", "string", "string" } } -implement { name = "xmlchecknamespace", actions = xml.checknamespace, arguments = { "lxmlid", "string", "string" } } -implement { name = "xmlcommand", actions = lxml.command, arguments = "3 strings" } -implement { name = "xmlconcat", actions = lxml.concat, arguments = "3 strings" } -- \detokenize{#3} -implement { name = "xmlconcatrange", actions = lxml.concatrange, arguments = { "string", "string", "string", "string", "string" } } -- \detokenize{#5} -implement { name = "xmlcontext", actions = lxml.context, arguments = "2 strings" } -implement { name = "xmlcount", actions = lxml.count, arguments = "2 strings" } -implement { name = "xmldelete", actions = lxml.delete, arguments = "2 strings" } -implement { name = "xmldirect", actions = lxml.direct, arguments = "string" } -implement { name = "xmldirectives", actions = lxml.directives.setup, arguments = "string" } -implement { name = "xmldirectivesafter", actions = lxml.directives.after, arguments = "string" } -implement { name = "xmldirectivesbefore", actions = lxml.directives.before, arguments = "string" } -implement { name = "xmldisplayverbatim", actions = lxml.displayverbatim, arguments = "string" } -implement { name = "xmlelement", actions = lxml.element, arguments = "2 strings" } -- could be integer but now we can alias -implement { name = "xmlfilter", actions = lxml.filter, arguments = "2 strings" } -implement { name = "xmlfilterlist", actions = lxml.filterlist, arguments = "2 strings" } -implement { name = "xmlfirst", actions = lxml.first, arguments = "2 strings" } -implement { name = "xmlflush", actions = lxml.flush, arguments = "string" } -implement { name = "xmlflushcontext", actions = lxml.context, arguments = "string" } -implement { name = "xmlflushlinewise", actions = lxml.flushlinewise, arguments = "string" } -implement { name = "xmlflushpure", actions = lxml.pure, arguments = "string" } -implement { name = "xmlflushspacewise", actions = lxml.flushspacewise, arguments = "string" } -implement { name = "xmlflushtext", actions = lxml.text, arguments = "string" } -implement { name = "xmlfunction", actions = lxml.applyfunction, arguments = "2 strings" } -implement { name = "xmlinclude", actions = lxml.include, arguments = { "string", "string", "string", true } } -implement { name = "xmlincludeoptions", actions = lxml.include, arguments = "4 strings" } -implement { name = "xmlinclusion", actions = lxml.inclusion, arguments = "string" } -implement { name = "xmlinclusionbase", actions = lxml.inclusion, arguments = { "string", false, true } } -implement { name = "xmlinclusions", actions = lxml.inclusions, arguments = "string" } -implement { name = "xmlindex", actions = lxml.index, arguments = "3 strings" } -- can be integer but now we can alias -implement { name = "xmlinlineverbatim", actions = lxml.inlineverbatim, arguments = "string" } -implement { name = "xmllast", actions = lxml.last, arguments = "2 strings" } -implement { name = "xmllastatt", actions = lxml.lastatt } -implement { name = "xmllastmatch", actions = lxml.lastmatch } -implement { name = "xmllastpar", actions = lxml.lastpar } -implement { name = "xmlloadfile", actions = lxml.load, arguments = "3 strings" } -implement { name = "xmlloadbuffer", actions = lxml.loadbuffer, arguments = "3 strings" } -implement { name = "xmlloaddata", actions = lxml.loaddata, arguments = "3 strings" } -implement { name = "xmlloaddirectives", actions = lxml.directives.load, arguments = "string" } -implement { name = "xmlmain", actions = lxml.main, arguments = "string" } -implement { name = "xmlmatch", actions = lxml.match, arguments = "string" } -implement { name = "xmlname", actions = lxml.name, arguments = "string" } -implement { name = "xmlnamespace", actions = lxml.namespace, arguments = "string" } -implement { name = "xmlnonspace", actions = lxml.nonspace, arguments = "2 strings" } -implement { name = "xmlpar", actions = lxml.par, arguments = "2 strings" } -implement { name = "xmlparam", actions = lxml.param, arguments = "3 strings" } -implement { name = "xmlpath", actions = lxml.path, arguments = { "string", "'/'" } } -implement { name = "xmlpopmatch", actions = lxml.popmatch } -implement { name = "xmlpos", actions = lxml.pos, arguments = "string" } -implement { name = "xmlpure", actions = lxml.pure, arguments = "2 strings" } -implement { name = "xmlpushmatch", actions = lxml.pushmatch } -implement { name = "xmlraw", actions = lxml.raw, arguments = "2 strings" } -implement { name = "xmlrawtex", actions = lxml.rawtex, arguments = "2 strings" } -implement { name = "xmlrefatt", actions = lxml.refatt, arguments = "2 strings" } -implement { name = "xmlregisterns", actions = xml.registerns, arguments = "2 strings" } -implement { name = "xmlremapname", actions = xml.remapname, arguments = { "lxmlid", "string","string","string" } } -implement { name = "xmlremapnamespace", actions = xml.renamespace, arguments = { "lxmlid", "string", "string" } } -implement { name = "xmlsave", actions = lxml.save, arguments = "2 strings" } -implement { name = "xmlsetatt", actions = lxml.setatt, arguments = "3 strings" } -implement { name = "xmlsetattribute", actions = lxml.setattribute, arguments = "4 strings" } -implement { name = "xmlsetpar", actions = lxml.setpar, arguments = "3 strings" } -implement { name = "xmlsetparam", actions = lxml.setparam, arguments = "4 strings" } -implement { name = "xmlsetsetup", actions = lxml.setsetup, arguments = "3 strings" } -implement { name = "xmlsnippet", actions = lxml.snippet, arguments = "2 strings" } -implement { name = "xmlstrip", actions = lxml.strip, arguments = "2 strings" } -implement { name = "xmlstripanywhere", actions = lxml.strip, arguments = { "string", "string", true, true } } -implement { name = "xmlstripnolines", actions = lxml.strip, arguments = { "string", "string", true } } -implement { name = "xmlstripped", actions = lxml.stripped, arguments = "2 strings" } -implement { name = "xmlstrippednolines", actions = lxml.stripped, arguments = { "string", "string", true } } -implement { name = "xmltag", actions = lxml.tag, arguments = "string" } -implement { name = "xmltext", actions = lxml.text, arguments = "2 strings" } -implement { name = "xmltobuffer", actions = lxml.tobuffer, arguments = "3 strings" } -implement { name = "xmltobuffertextonly", actions = lxml.tobuffer, arguments = { "string", "string", "string", false } } -implement { name = "xmltobufferverbose", actions = lxml.tobuffer, arguments = { "string", "string", "string", true, true } } -implement { name = "xmltofile", actions = lxml.tofile, arguments = "3 strings" } -implement { name = "xmltoparameters", actions = lxml.toparameters, arguments = "string" } -implement { name = "xmlverbatim", actions = lxml.verbatim, arguments = "string" } - -implement { name = "xmlstartraw", actions = lxml.startraw } -implement { name = "xmlstopraw", actions = lxml.stopraw } - -implement { name = "xmlprependsetup", actions = lxml.installsetup, arguments = { 1, "string", "string" } } -- 2:* -implement { name = "xmlappendsetup", actions = lxml.installsetup, arguments = { 2, "string", "string" } } -- 2:* -implement { name = "xmlbeforesetup", actions = lxml.installsetup, arguments = { 3, "string", "string", "string" } } -- 2:* -implement { name = "xmlaftersetup", actions = lxml.installsetup, arguments = { 4, "string", "string", "string" } } -- 2:* -implement { name = "xmlremovesetup", actions = lxml.removesetup, arguments = "2 strings" } -- 1:* -implement { name = "xmlflushsetups", actions = lxml.flushsetups, arguments = "3 strings" } -- 2:* -implement { name = "xmlresetsetups", actions = lxml.resetsetups, arguments = "string" } +implement { name = "lxmlid", public = true, actions = lxml.getid, arguments = "string" } + +implement { name = "xmldoif", public = true, actions = lxml.doif, arguments = "2 strings" } +implement { name = "xmldoifnot", public = true, actions = lxml.doifnot, arguments = "2 strings" } +implement { name = "xmldoifelse", public = true, actions = lxml.doifelse, arguments = "2 strings" } +implement { name = "xmldoiftext", public = true, actions = lxml.doiftext, arguments = "2 strings" } +implement { name = "xmldoifnottext", public = true, actions = lxml.doifnottext, arguments = "2 strings" } +implement { name = "xmldoifelsetext", public = true, actions = lxml.doifelsetext, arguments = "2 strings" } + +implement { name = "xmldoifempty", public = true, actions = lxml.doifempty, arguments = "2 strings" } +implement { name = "xmldoifnotempty", public = true, actions = lxml.doifnotempty, arguments = "2 strings" } +implement { name = "xmldoifelseempty", public = true, actions = lxml.doifelseempty, arguments = "2 strings" } +implement { name = "xmldoifselfempty", public = true, actions = lxml.doifempty, arguments = "string" } -- second arg is not passed (used) +implement { name = "xmldoifnotselfempty", public = true, actions = lxml.doifnotempty, arguments = "string" } -- second arg is not passed (used) +implement { name = "xmldoifelseselfempty", public = true, actions = lxml.doifelseempty, arguments = "string" } -- second arg is not passed (used) + +--------- { name = "xmlcontent", actions = lxml.content, arguments = "string" } +--------- { name = "xmlflushstripped", actions = lxml.strip, arguments = { "string", true } } + +implement { name = "xmlall", public = true, actions = lxml.all, arguments = "2 strings" } +implement { name = "xmlatt", public = true, actions = lxml.att, arguments = "2 strings" } +implement { name = "xmlattdef", public = true, actions = lxml.att, arguments = "3 strings" } +implement { name = "xmlattribute", public = true, actions = lxml.attribute, arguments = "3 strings" } +implement { name = "xmlattributedef", public = true, actions = lxml.attribute, arguments = "4 strings" } +implement { name = "xmlbadinclusions", public = true, actions = lxml.badinclusions, arguments = "string" } +implement { name = "xmlchainatt", public = true, actions = lxml.chainattribute, arguments = { "string", "'/'", "string" } } +implement { name = "xmlchainattdef", public = true, actions = lxml.chainattribute, arguments = { "string", "'/'", "string", "string" } } +implement { name = "xmlchecknamespace", public = true, actions = xml.checknamespace, arguments = { "lxmlid", "string", "string" } } +implement { name = "xmlcommand", public = true, actions = lxml.command, arguments = "3 strings" } +implement { name = "xmlconcat", actions = lxml.concat, arguments = "3 strings" } -- \detokenize{#3} +implement { name = "xmlconcatrange", actions = lxml.concatrange, arguments = "5 strings" } -- \detokenize{#5} +--------- { name = "xmlconcat", actions = lxml.concat, arguments = { "string", "string", "verbatim" } } +--------- { name = "xmlconcatrange", actions = lxml.concatrange, arguments = { "string", "string", "string", "string", "verbatim" } } +implement { name = "xmlcontext", public = true, actions = lxml.context, arguments = "2 strings" } +implement { name = "xmlcount", public = true, actions = lxml.count, arguments = "2 strings" } +implement { name = "xmldelete", public = true, actions = lxml.delete, arguments = "2 strings" } +implement { name = "xmldirect", public = true, actions = lxml.direct, arguments = "string" } +implement { name = "xmldirectives", public = true, actions = lxml.directives.setup, arguments = "string" } +implement { name = "xmldirectivesafter", public = true, actions = lxml.directives.after, arguments = "string" } +implement { name = "xmldirectivesbefore", public = true, actions = lxml.directives.before, arguments = "string" } +implement { name = "xmldisplayverbatim", public = true, actions = lxml.displayverbatim, arguments = "string" } +implement { name = "xmlelement", public = true, actions = lxml.element, arguments = "2 strings" } -- could be integer but now we can alias +implement { name = "xmlfilter", public = true, actions = lxml.filter, arguments = "2 strings" } +implement { name = "xmlfilterlist", public = true, actions = lxml.filterlist, arguments = "2 strings" } +implement { name = "xmlfirst", public = true, actions = lxml.first, arguments = "2 strings" } +implement { name = "xmlflush", public = true, actions = lxml.flush, arguments = "string" } +implement { name = "xmlflushcontext", public = true, actions = lxml.context, arguments = "string" } +implement { name = "xmlflushlinewise", public = true, actions = lxml.flushlinewise, arguments = "string" } +implement { name = "xmlflushpure", public = true, actions = lxml.pure, arguments = "string" } +implement { name = "xmlflushspacewise", public = true, actions = lxml.flushspacewise, arguments = "string" } +implement { name = "xmlflushtext", public = true, actions = lxml.text, arguments = "string" } +implement { name = "xmlfunction", public = true, actions = lxml.applyfunction, arguments = "2 strings" } +implement { name = "xmlinclude", public = true, actions = lxml.include, arguments = { "string", "string", "string", true } } +implement { name = "xmlincludeoptions", public = true, actions = lxml.include, arguments = "4 strings" } +implement { name = "xmlinclusion", public = true, actions = lxml.inclusion, arguments = "string" } +implement { name = "xmlinclusionbase", public = true, actions = lxml.inclusion, arguments = { "string", false, true } } +implement { name = "xmlinclusions", public = true, actions = lxml.inclusions, arguments = "string" } +implement { name = "xmlindex", public = true, actions = lxml.index, arguments = "3 strings" } -- can be integer but now we can alias +implement { name = "xmlinlineverbatim", public = true, actions = lxml.inlineverbatim, arguments = "string" } +implement { name = "xmllast", public = true, actions = lxml.last, arguments = "2 strings" } +implement { name = "xmllastatt", public = true, actions = lxml.lastatt } +implement { name = "xmllastmatch", public = true, actions = lxml.lastmatch } +implement { name = "xmllastpar", public = true, actions = lxml.lastpar } +implement { name = "xmlloadfile", actions = lxml.load, arguments = "3 strings" } +implement { name = "xmlloadbuffer", actions = lxml.loadbuffer, arguments = "3 strings" } +implement { name = "xmlloaddata", actions = lxml.loaddata, arguments = "3 strings" } +implement { name = "xmlloaddirectives", public = true, actions = lxml.directives.load, arguments = "string" } +implement { name = "xmlmain", public = true, actions = lxml.main, arguments = "string" } +implement { name = "xmlmatch", public = true, actions = lxml.match, arguments = "string" } +implement { name = "xmlname", public = true, actions = lxml.name, arguments = "string" } +implement { name = "xmlnamespace", public = true, actions = lxml.namespace, arguments = "string" } +implement { name = "xmlnonspace", public = true, actions = lxml.nonspace, arguments = "2 strings" } +implement { name = "xmlpar", public = true, actions = lxml.par, arguments = "2 strings" } +implement { name = "xmlparam", public = true, actions = lxml.param, arguments = "3 strings" } +implement { name = "xmlpath", public = true, actions = lxml.path, arguments = { "string", "'/'" } } +implement { name = "xmlpopmatch", public = true, actions = lxml.popmatch } +implement { name = "xmlpos", public = true, actions = lxml.pos, arguments = "string" } +implement { name = "xmlpure", public = true, actions = lxml.pure, arguments = "2 strings" } +implement { name = "xmlpushmatch", public = true, actions = lxml.pushmatch } +implement { name = "xmlraw", public = true, actions = lxml.raw, arguments = "2 strings" } +implement { name = "xmlrawtex", actions = lxml.rawtex, arguments = "2 strings" } +implement { name = "xmlrefatt", public = true, actions = lxml.refatt, arguments = "2 strings" } +implement { name = "xmlregisterns", public = true, actions = xml.registerns, arguments = "2 strings" } +implement { name = "xmlremapname", public = true, actions = xml.remapname, arguments = { "lxmlid", "string","string","string" } } +implement { name = "xmlremapnamespace", public = true, actions = xml.renamespace, arguments = { "lxmlid", "string", "string" } } +implement { name = "xmlsave", public = true, actions = lxml.save, arguments = "2 strings" } +implement { name = "xmlsetatt", public = true, actions = lxml.setatt, arguments = "3 strings" } +implement { name = "xmlsetattribute", public = true, actions = lxml.setattribute, arguments = "4 strings" } +implement { name = "xmlsetpar", public = true, actions = lxml.setpar, arguments = "3 strings" } +implement { name = "xmlsetparam", public = true, actions = lxml.setparam, arguments = "4 strings" } +implement { name = "xmlsetsetup", public = true, actions = lxml.setsetup, arguments = "3 strings" } +implement { name = "xmlsnippet", public = true, actions = lxml.snippet, arguments = "2 strings" } +implement { name = "xmlstrip", public = true, actions = lxml.strip, arguments = "2 strings" } +implement { name = "xmlstripanywhere", public = true, actions = lxml.strip, arguments = { "string", "string", true, true } } +implement { name = "xmlstripnolines", public = true, actions = lxml.strip, arguments = { "string", "string", true } } +implement { name = "xmlstripped", public = true, actions = lxml.stripped, arguments = "2 strings" } +implement { name = "xmlstrippednolines", public = true, actions = lxml.stripped, arguments = { "string", "string", true } } +implement { name = "xmltag", public = true, actions = lxml.tag, arguments = "string" } +implement { name = "xmltext", public = true, actions = lxml.text, arguments = "2 strings" } +implement { name = "xmltobuffer", public = true, actions = lxml.tobuffer, arguments = "3 strings" } +implement { name = "xmltobuffertextonly", public = true, actions = lxml.tobuffer, arguments = { "string", "string", "string", false } } +implement { name = "xmltobufferverbose", public = true, actions = lxml.tobuffer, arguments = { "string", "string", "string", true, true } } +implement { name = "xmltofile", public = true, actions = lxml.tofile, arguments = "3 strings" } +implement { name = "xmltoparameters", public = true, actions = lxml.toparameters, arguments = "string" } +implement { name = "xmlverbatim", public = true, actions = lxml.verbatim, arguments = "string" } + +implement { name = "xmlstartraw", actions = lxml.startraw } +implement { name = "xmlstopraw", actions = lxml.stopraw } + +implement { name = "xmlprependsetup", actions = lxml.installsetup, arguments = { 1, "string", "string" } } -- 2:* +implement { name = "xmlappendsetup", actions = lxml.installsetup, arguments = { 2, "string", "string" } } -- 2:* +implement { name = "xmlbeforesetup", actions = lxml.installsetup, arguments = { 3, "string", "string", "string" } } -- 2:* +implement { name = "xmlaftersetup", actions = lxml.installsetup, arguments = { 4, "string", "string", "string" } } -- 2:* +implement { name = "xmlremovesetup", actions = lxml.removesetup, arguments = "2 strings" } -- 1:* +implement { name = "xmlflushsetups", actions = lxml.flushsetups, arguments = "3 strings" } -- 2:* +implement { name = "xmlresetsetups", actions = lxml.resetsetups, arguments = "string" } implement { name = "xmlgetindex", actions = lxml.getindex, arguments = "2 strings" } implement { name = "xmlwithindex", actions = lxml.withindex, arguments = "3 strings" } diff --git a/tex/context/base/mkiv/lxml-ini.mkiv b/tex/context/base/mkiv/lxml-ini.mkiv index 09358e11c..1c7006f57 100644 --- a/tex/context/base/mkiv/lxml-ini.mkiv +++ b/tex/context/base/mkiv/lxml-ini.mkiv @@ -34,7 +34,7 @@ \def\ctxlxml #1{\ctxlua{lxml.#1}} -% for now indirect +% for now indirect .. this will change when we have updated luatex (scan_argument) \def\xmlconcat #1#2#3{\clf_xmlconcat {#1}{#2}{\detokenize{#3}}} \def\xmlconcatrange #1#2#3#4#5{\clf_xmlconcatrange{#1}{#2}{#3}{#4}{\detokenize{#5}}} @@ -49,85 +49,86 @@ % aliased -\let\xmlall \clf_xmlall -\let\xmlatt \clf_xmlatt -\let\xmlattdef \clf_xmlattdef -\let\xmlattribute \clf_xmlattribute -\let\xmlattributedef \clf_xmlattributedef -\let\xmlbadinclusions \clf_xmlbadinclusions -\let\xmlchainatt \clf_xmlchainatt -\let\xmlchainattdef \clf_xmlchainattdef -\let\xmlchecknamespace \clf_xmlchecknamespace -\let\xmlcommand \clf_xmlcommand -\let\xmlcontext \clf_xmlcontext -\let\xmlcount \clf_xmlcount -\let\xmldelete \clf_xmldelete -\let\xmldirect \clf_xmldirect % in loops, not dt but root -\let\xmldirectives \clf_xmldirectives -\let\xmldirectivesafter \clf_xmldirectivesafter -\let\xmldirectivesbefore \clf_xmldirectivesbefore -\let\xmldisplayverbatim \clf_xmldisplayverbatim -\let\xmlelement \clf_xmlelement -\let\xmlfilter \clf_xmlfilter -\let\xmlfilterlist \clf_xmlfilterlist -\let\xmlfirst \clf_xmlfirst -\let\xmlflush \clf_xmlflush -\let\xmlflushcontext \clf_xmlflushcontext -\let\xmlflushlinewise \clf_xmlflushlinewise -\let\xmlflushpure \clf_xmlflushpure -\let\xmlflushspacewise \clf_xmlflushspacewise -\let\xmlflushtext \clf_xmlflushtext -\let\xmlfunction \clf_xmlfunction -\let\xmlinclude \clf_xmlinclude -\let\xmlincludeoptions \clf_xmlincludeoptions -\let\xmlinclusion \clf_xmlinclusion -\let\xmlinclusionbase \clf_xmlinclusionbase -\let\xmlinclusions \clf_xmlinclusions -\let\xmlindex \clf_xmlindex -\let\xmlinlineverbatim \clf_xmlinlineverbatim -\let\xmllast \clf_xmllast -\let\xmllastatt \clf_xmllastatt -\let\xmllastmatch \clf_xmllastmatch -\let\xmllastpar \clf_xmllastpar -\let\xmlloaddirectives \clf_xmlloaddirectives -\let\xmlmain \clf_xmlmain -\let\xmlmatch \clf_xmlmatch -\let\xmlname \clf_xmlname -\let\xmlnamespace \clf_xmlnamespace -\let\xmlnonspace \clf_xmlnonspace -\let\xmlpar \clf_xmlpar -\let\xmlparam \clf_xmlparam -\let\xmlpath \clf_xmlpath -\let\xmlpopmatch \clf_xmlpopmatch -\let\xmlpos \clf_xmlpos -\let\xmlposition \clf_xmlindex -\let\xmlpure \clf_xmlpure -\let\xmlpushmatch \clf_xmlpushmatch -\let\xmlraw \clf_xmlraw -\let\xmlrefatt \clf_xmlrefatt -\let\xmlregisterns \clf_xmlregisterns % document -\let\xmlremapname \clf_xmlremapname % element -\let\xmlremapnamespace \clf_xmlremapnamespace % document -\let\xmlsave \clf_xmlsave -\let\xmlsetatt \clf_xmlsetatt -\let\xmlsetattribute \clf_xmlsetattribute -\let\xmlsetpar \clf_xmlsetpar -\let\xmlsetparam \clf_xmlsetparam -\let\xmlsetsetup \clf_xmlsetsetup -\let\xmlsnippet \clf_xmlsnippet -\let\xmlstrip \clf_xmlstrip -\let\xmlstripanywhere \clf_xmlstripanywhere -\let\xmlstripnolines \clf_xmlstripnolines -\let\xmlstripped \clf_xmlstripped -\let\xmlstrippednolines \clf_xmlstrippednolines -\let\xmltag \clf_xmltag -\let\xmltext \clf_xmltext -\let\xmltobuffer \clf_xmltobuffer % id pattern name -\let\xmltobuffertextonly \clf_xmltobuffertextonly % id pattern name -\let\xmltobufferverbose \clf_xmltobufferverbose % id pattern name -\let\xmltofile \clf_xmltofile % id pattern filename -\let\xmltoparameters \clf_xmltoparameters -\let\xmlverbatim \clf_xmlverbatim +%let\xmlall \clf_xmlall +%let\xmlatt \clf_xmlatt +%let\xmlattdef \clf_xmlattdef +%let\xmlattribute \clf_xmlattribute +%let\xmlattributedef \clf_xmlattributedef +%let\xmlbadinclusions \clf_xmlbadinclusions +%let\xmlchainatt \clf_xmlchainatt +%let\xmlchainattdef \clf_xmlchainattdef +%let\xmlchecknamespace \clf_xmlchecknamespace +%let\xmlcommand \clf_xmlcommand +%let\xmlcontext \clf_xmlcontext +%let\xmlcount \clf_xmlcount +%let\xmldelete \clf_xmldelete +%let\xmldirect \clf_xmldirect % in loops, not dt but root +%let\xmldirectives \clf_xmldirectives +%let\xmldirectivesafter \clf_xmldirectivesafter +%let\xmldirectivesbefore \clf_xmldirectivesbefore +%let\xmldisplayverbatim \clf_xmldisplayverbatim +%let\xmlelement \clf_xmlelement +%let\xmlfilter \clf_xmlfilter +%let\xmlfilterlist \clf_xmlfilterlist +%let\xmlfirst \clf_xmlfirst +%let\xmlflush \clf_xmlflush +%let\xmlflushcontext \clf_xmlflushcontext +%let\xmlflushlinewise \clf_xmlflushlinewise +%let\xmlflushpure \clf_xmlflushpure +%let\xmlflushspacewise \clf_xmlflushspacewise +%let\xmlflushtext \clf_xmlflushtext +%let\xmlfunction \clf_xmlfunction +%let\xmlinclude \clf_xmlinclude +%let\xmlincludeoptions \clf_xmlincludeoptions +%let\xmlinclusion \clf_xmlinclusion +%let\xmlinclusionbase \clf_xmlinclusionbase +%let\xmlinclusions \clf_xmlinclusions +%let\xmlindex \clf_xmlindex +%let\xmlinlineverbatim \clf_xmlinlineverbatim +%let\xmllast \clf_xmllast +%let\xmllastatt \clf_xmllastatt +%let\xmllastmatch \clf_xmllastmatch +%let\xmllastpar \clf_xmllastpar +%let\xmlloaddirectives \clf_xmlloaddirectives +%let\xmlmain \clf_xmlmain +%let\xmlmatch \clf_xmlmatch +%let\xmlname \clf_xmlname +%let\xmlnamespace \clf_xmlnamespace +%let\xmlnonspace \clf_xmlnonspace +%let\xmlpar \clf_xmlpar +%let\xmlparam \clf_xmlparam +%let\xmlpath \clf_xmlpath +%let\xmlpopmatch \clf_xmlpopmatch +%let\xmlpos \clf_xmlpos +%let\xmlpure \clf_xmlpure +%let\xmlpushmatch \clf_xmlpushmatch +%let\xmlraw \clf_xmlraw +%let\xmlrefatt \clf_xmlrefatt +%let\xmlregisterns \clf_xmlregisterns % document +%let\xmlremapname \clf_xmlremapname % element +%let\xmlremapnamespace \clf_xmlremapnamespace % document +%let\xmlsave \clf_xmlsave +%let\xmlsetatt \clf_xmlsetatt +%let\xmlsetattribute \clf_xmlsetattribute +%let\xmlsetpar \clf_xmlsetpar +%let\xmlsetparam \clf_xmlsetparam +%let\xmlsetsetup \clf_xmlsetsetup +%let\xmlsnippet \clf_xmlsnippet +%let\xmlstrip \clf_xmlstrip +%let\xmlstripanywhere \clf_xmlstripanywhere +%let\xmlstripnolines \clf_xmlstripnolines +%let\xmlstripped \clf_xmlstripped +%let\xmlstrippednolines \clf_xmlstrippednolines +%let\xmltag \clf_xmltag +%let\xmltext \clf_xmltext +%let\xmltobuffer \clf_xmltobuffer % id pattern name +%let\xmltobuffertextonly \clf_xmltobuffertextonly % id pattern name +%let\xmltobufferverbose \clf_xmltobufferverbose % id pattern name +%let\xmltofile \clf_xmltofile % id pattern filename +%let\xmltoparameters \clf_xmltoparameters +%let\xmlverbatim \clf_xmlverbatim + +\let\xmlposition \xmlindex \unexpanded\def\xmlinfo#1{\hbox{\ttxx[\clf_xmlname{#1}]}} \unexpanded\def\xmlshow#1{\startpacked\ttx\xmlverbatim{#1}\stoppacked} @@ -135,7 +136,7 @@ % the next one is handy for mode runs because it enforces a consistent % #1 indexing (needed when using \xmltext{main:123}{...} like calls -\let\xmladdindex \clf_xmladdindex +%let\xmladdindex \clf_xmladdindex % we need to pass the last argument as function, so @@ -185,23 +186,23 @@ % these are expandable! todo: \xmldoifelseattribute -\let\xmldoif \clf_xmldoif -\let\xmldoifnot \clf_xmldoifnot -\let\xmldoifelse \clf_xmldoifelse -\let\xmldoiftext \clf_xmldoiftext -\let\xmldoifnottext \clf_xmldoifnottext -\let\xmldoifelsetext \clf_xmldoifelsetext - -\let\xmldoifatt \clf_xmldoifatt -\let\xmldoifnotatt \clf_xmldoifnotatt -\let\xmldoifelseatt \clf_xmldoifelseatt - -\let\xmldoifempty \clf_xmldoifempty -\let\xmldoifnotempty \clf_xmldoifnotempty -\let\xmldoifelseempty \clf_xmldoifelseempty -\let\xmldoifselfempty \clf_xmldoifselfempty -\let\xmldoifnotselfempty \clf_xmldoifnotselfempty -\let\xmldoifelseselfempty \clf_xmldoifelseselfempty +%let\xmldoif \clf_xmldoif +%let\xmldoifnot \clf_xmldoifnot +%let\xmldoifelse \clf_xmldoifelse +%let\xmldoiftext \clf_xmldoiftext +%let\xmldoifnottext \clf_xmldoifnottext +%let\xmldoifelsetext \clf_xmldoifelsetext + +%let\xmldoifatt \clf_xmldoifatt +%let\xmldoifnotatt \clf_xmldoifnotatt +%let\xmldoifelseatt \clf_xmldoifelseatt + +%let\xmldoifempty \clf_xmldoifempty +%let\xmldoifnotempty \clf_xmldoifnotempty +%let\xmldoifelseempty \clf_xmldoifelseempty +%let\xmldoifselfempty \clf_xmldoifselfempty +%let\xmldoifnotselfempty \clf_xmldoifnotselfempty +%let\xmldoifelseselfempty \clf_xmldoifelseselfempty \let\xmldoiftextelse \xmldoifelsetext \let\xmldoifemptyelse \xmldoifelseempty diff --git a/tex/context/base/mkiv/lxml-tex.lua b/tex/context/base/mkiv/lxml-tex.lua index 9ab8cafc6..079ab29da 100644 --- a/tex/context/base/mkiv/lxml-tex.lua +++ b/tex/context/base/mkiv/lxml-tex.lua @@ -472,6 +472,7 @@ lxml.addindex = addindex implement { name = "xmladdindex", arguments = "string", + public = true, actions = addindex, } @@ -2070,7 +2071,8 @@ do implement { name = "xmldoifatt", arguments = "3 strings", - actions = function(id,k,v) + public = true, + actions = function(id,k,v) local e = getid(id) ctx_doif(e and e.at[k] == v or false) end @@ -2079,7 +2081,8 @@ do implement { name = "xmldoifnotatt", arguments = "3 strings", - actions = function(id,k,v) + public = true, + actions = function(id,k,v) local e = getid(id) ctx_doifnot(e and e.at[k] == v or false) end @@ -2088,7 +2091,8 @@ do implement { name = "xmldoifelseatt", arguments = "3 strings", - actions = function(id,k,v) + public = true, + actions = function(id,k,v) local e = getid(id) ctx_doifelse(e and e.at[k] == v or false) end diff --git a/tex/context/base/mkiv/math-ali.mkiv b/tex/context/base/mkiv/math-ali.mkiv index 400326d26..7f210bb41 100644 --- a/tex/context/base/mkiv/math-ali.mkiv +++ b/tex/context/base/mkiv/math-ali.mkiv @@ -1012,12 +1012,12 @@ \let\mathmatrixleft \empty % experimental hook \let\mathmatrixright\empty % experimental hook -\setvalue{\??mathmatrixalignlocation\v!top }{\raise\dimexpr(\nextboxdp-\nextboxht)/2 +\mathaxisheight\textfont\zerocount\relax} +\setvalue{\??mathmatrixalignlocation\v!top }{\raise\dimexpr(\nextboxdp-\nextboxht)/2 +\mathaxisheight\mathstyle\relax} \setvalue{\??mathmatrixalignlocation\v!high }{\raise\dimexpr(\nextboxdp-\nextboxht)/2\relax} \setvalue{\??mathmatrixalignlocation\v!center}{\relax} \setvalue{\??mathmatrixalignlocation\v!lohi} {\relax} \setvalue{\??mathmatrixalignlocation\v!normal}{\relax} -\setvalue{\??mathmatrixalignlocation\v!bottom}{\lower\dimexpr(\nextboxdp-\nextboxht)/2 +\mathaxisheight\textfont\zerocount\relax} +\setvalue{\??mathmatrixalignlocation\v!bottom}{\lower\dimexpr(\nextboxdp-\nextboxht)/2 +\mathaxisheight\mathstyle\relax} \setvalue{\??mathmatrixalignlocation\v!low }{\lower\dimexpr(\nextboxdp-\nextboxht)/2\relax} \def\math_matrix_finish_nextbox diff --git a/tex/context/base/mkiv/mult-low.lua b/tex/context/base/mkiv/mult-low.lua index 58202fa1a..16eb3e68b 100644 --- a/tex/context/base/mkiv/mult-low.lua +++ b/tex/context/base/mkiv/mult-low.lua @@ -90,7 +90,7 @@ return { "fontexheight", "fontemwidth", "fontextraspace", "slantperpoint", "mathexheight", "mathemwidth", "interwordspace", "interwordstretch", "interwordshrink", "exheight", "emwidth", "extraspace", - "mathsupdisplay", "mathsupnormal", "mathsupcramped", "mathsubnormal", "mathsubcombined", "mathaxisheight", + "mathaxisheight", "muquad", -- -- maybe a different class diff --git a/tex/context/base/mkiv/pack-rul.mkxl b/tex/context/base/mkiv/pack-rul.mkxl index 6268aad3e..97cb82968 100644 --- a/tex/context/base/mkiv/pack-rul.mkxl +++ b/tex/context/base/mkiv/pack-rul.mkxl @@ -469,29 +469,6 @@ {\def\pack_framed_define_overlay_indeed##1{\setvalue{\??overlay##1}{\executedefinedoverlay{##1}{#2}}}% \processcommalist[#1]\pack_framed_define_overlay_indeed} -% \unexpanded\def\executedefinedoverlay#1#2% we can share the definitions -% {\bgroup % redundant grouping -% \setbox\scratchbox\hbox\bgroup -% \ifzeropt\d_framed_target_dp -% \the\everyoverlay#2% saves wrapping (and lua call) -% \else -% \lower\d_framed_target_dp -% \hbox{\the\everyoverlay#2}% -% \fi -% \egroup -% \setlayoutcomponentattribute{\v!overlay:#1}% -% \setbox\scratchbox\hpack \layoutcomponentboxattribute -% {\kern -.5\dimexpr\wd\scratchbox-\d_framed_target_wd\relax % was \d_overlay_width -% \raise-.5\dimexpr\ht\scratchbox-\d_framed_target_ht\relax % not \d_overlay_height ! -% \box\scratchbox}% -% \wd\scratchbox\d_framed_target_wd -% \ht\scratchbox\d_framed_target_ht -% \dp\scratchbox\d_framed_target_dp -% \box\scratchbox -% \egroup} - -% 20191231: moved from cont-exp: - \unexpanded\def\executedefinedoverlay#1#2% we can share the definitions {\bgroup % redundant grouping \setlayoutcomponentattribute{\v!overlay:#1}% @@ -507,13 +484,6 @@ %D \macros %D {overlayfakebox} -% \unexpanded\def\overlayfakebox -% {\hpack -% {\setbox\scratchbox\emptyhbox -% \wd\scratchbox\d_overlay_width -% \ht\scratchbox\d_overlay_height -% \box\scratchbox}} - \unexpanded\def\overlayfakebox {\hpack % redundant but needs testing {\novrule diff --git a/tex/context/base/mkiv/spac-flr.mkiv b/tex/context/base/mkiv/spac-flr.mkiv index 4c3c0c042..a64171247 100644 --- a/tex/context/base/mkiv/spac-flr.mkiv +++ b/tex/context/base/mkiv/spac-flr.mkiv @@ -168,6 +168,23 @@ [\c!alternative=\v!space, \c!distance=3\emwidth] +% bonus: + +\definefiller + [dotfill] + [\c!symbol=\textperiod, + \c!style=\v!normal, + \c!method=\v!middle, + \c!width=.5\emwidth, + \c!leftmargin=.2\emwidth, + \c!rightmargin=.2\emwidth] + +\let\mathdotfill\dotfill + +\unexpanded\def\textdotfill{\filler[dotfill]} + +\unexpanded\def\dotfill{\mathortext\mathdotfill\textdotfill} + % maybe box -> symbol \protect \endinput diff --git a/tex/context/base/mkiv/status-files.pdf b/tex/context/base/mkiv/status-files.pdf new file mode 100644 index 000000000..9ef6ddd19 Binary files /dev/null and b/tex/context/base/mkiv/status-files.pdf differ diff --git a/tex/context/base/mkiv/status-lua.pdf b/tex/context/base/mkiv/status-lua.pdf new file mode 100644 index 000000000..e967a7798 Binary files /dev/null and b/tex/context/base/mkiv/status-lua.pdf differ diff --git a/tex/context/base/mkiv/syst-aux.mkiv b/tex/context/base/mkiv/syst-aux.mkiv index d268f2fb6..20716786d 100644 --- a/tex/context/base/mkiv/syst-aux.mkiv +++ b/tex/context/base/mkiv/syst-aux.mkiv @@ -4492,7 +4492,9 @@ \unexpanded\def\resetrecurselevel{\let\recurselevel\!!zerocount} -\let\recurselevel\!!zerocount +\let\recurselevel \!!zerocount +\let\recurseaction\relax +\let\recursestring\empty % \appendtoks \resetrecurselevel \to \everydump diff --git a/tex/context/base/mkiv/syst-aux.mkxl b/tex/context/base/mkiv/syst-aux.mkxl index 8188577e6..956d43f89 100644 --- a/tex/context/base/mkiv/syst-aux.mkxl +++ b/tex/context/base/mkiv/syst-aux.mkxl @@ -2979,6 +2979,9 @@ \def\recursedepth{\the\outerrecurse} \def\recurselevel{0} +\let\recurseaction\relax +\let\recursestring\empty + \let\syst_helpers_stepwise_next\relax \unexpanded\def\syst_helpers_stepwise_recurse#1#2#3% from to step @@ -3088,6 +3091,7 @@ \let\endofloop\donothing % maybe \syst_helpers_loop_end + \unexpanded\def\doloop#1% {\global\advance\outerrecurse \plusone \globalpushmacro\recurselevel diff --git a/tex/context/base/mkiv/syst-fnt.mkiv b/tex/context/base/mkiv/syst-fnt.mkiv index cacc5f517..764e486d2 100644 --- a/tex/context/base/mkiv/syst-fnt.mkiv +++ b/tex/context/base/mkiv/syst-fnt.mkiv @@ -31,12 +31,7 @@ \def\emwidth {\fontdimen\plussix \font} \def\extraspace {\fontdimen\plusseven\font} -\def\mathsupdisplay {\fontdimen13 } % to be remapped -\def\mathsupnormal {\fontdimen14 } % to be remapped -\def\mathsupcramped {\fontdimen15 } % to be remapped -\def\mathsubnormal {\fontdimen16 } % to be remapped -\def\mathsubcombined {\fontdimen17 } % to be remapped -\def\mathaxisheight {\fontdimen22 } % to be remapped +\def\mathaxisheight {\Umathaxis} % takes style \def\currentspaceskip {\interwordspace\s!plus\interwordstretch\s!minus\interwordshrink\relax} diff --git a/tex/context/base/mkiv/toks-ini.lua b/tex/context/base/mkiv/toks-ini.lua index da5affa63..8fc60335e 100644 --- a/tex/context/base/mkiv/toks-ini.lua +++ b/tex/context/base/mkiv/toks-ini.lua @@ -192,7 +192,7 @@ tokens.scanners = { -- these expand string = scan_string, argument = scan_argument, tokenlist = scan_tokenlist, - verbatim = scan_verbatim, + verbatim = scan_verbatim, -- detokenize code = scan_code, tokencode = scan_token_code, word = scan_word, diff --git a/tex/context/base/mkiv/trac-vis.lua b/tex/context/base/mkiv/trac-vis.lua index 760ba8726..f89043547 100644 --- a/tex/context/base/mkiv/trac-vis.lua +++ b/tex/context/base/mkiv/trac-vis.lua @@ -874,6 +874,7 @@ local ruledglue do local userskip_code = gluecodes.userskip local spaceskip_code = gluecodes.spaceskip local xspaceskip_code = gluecodes.xspaceskip + local zerospaceskip_code = gluecodes.zerospaceskip or gluecodes.userskip local leftskip_code = gluecodes.leftskip local rightskip_code = gluecodes.rightskip local parfillskip_code = gluecodes.parfillskip @@ -914,6 +915,7 @@ local ruledglue do [rightskip_code] = "RS", [spaceskip_code] = "SP", [xspaceskip_code] = "XS", + [zerospaceskip_code] = "ZS", [parfillskip_code] = "PF", [indentskip_code] = "IN", [correctionskip_code] = "CS", @@ -929,7 +931,7 @@ local ruledglue do if info then -- print("glue hit") else - if subtype == spaceskip_code or subtype == xspaceskip_code then + if subtype == spaceskip_code or subtype == xspaceskip_code or subtype == zerospaceskip_code then info = sometext(amount,l_glue,c_space) elseif subtype == leftskip_code or subtype == rightskip_code then info = sometext(amount,l_glue,c_skip_a) @@ -958,7 +960,7 @@ local ruledglue do -- ruledspace = function(head,current,parent) -- local subtype = getsubtype(current) - -- if subtype == spaceskip_code or subtype == xspaceskip_code then + -- if subtype == spaceskip_code or subtype == xspaceskip_code or subtype == zerospaceskip_code then -- local width = effectiveglue(current,parent) -- local amount = formatters["%s:%0.3f"](tags[subtype] or "HS",width*pt_factor) -- local info = g_cache_h[amount] @@ -981,7 +983,7 @@ local ruledglue do ruledspace = function(head,current,parent) local subtype = getsubtype(current) - if subtype == spaceskip_code or subtype == xspaceskip_code then -- not yet all space + if subtype == spaceskip_code or subtype == xspaceskip_code or subtype == zerospaceskip_code then -- not yet all space local width = effectiveglue(current,parent) local info if subtype == spaceskip_code then diff --git a/tex/context/base/mkiv/type-ini.mklx b/tex/context/base/mkiv/type-ini.mklx index c710fbec5..1cb9bc2e5 100644 --- a/tex/context/base/mkiv/type-ini.mklx +++ b/tex/context/base/mkiv/type-ini.mklx @@ -90,6 +90,13 @@ \installmacrostack\typescriptmethod \installmacrostack\typescriptstate +%D When these are loaded it is possible to get spaces but the whole idea is to do +%D that loading in vertical mode. Adding \type {\pushendofline} and \type +%D {\popendofline} is an option but not watertight as it can still interfere, for +%D instance work comments and leading spaces. Also, in horizontal mode it is likely +%D that one is also grouped and loading bodyfonts grouped is a real bad idea. +%D Ignoring all spaces is also not a solution. So, our verdict is: no catch. + \unexpanded\def\starttypescriptcollection {\dosingleempty\font_typescripts_collection_start} diff --git a/tex/generic/context/luatex/luatex-fonts-merged.lua b/tex/generic/context/luatex/luatex-fonts-merged.lua index f2a2b7d9e..a1c027064 100644 --- a/tex/generic/context/luatex/luatex-fonts-merged.lua +++ b/tex/generic/context/luatex/luatex-fonts-merged.lua @@ -1,6 +1,6 @@ -- merged file : c:/data/develop/context/sources/luatex-fonts-merged.lua -- parent file : c:/data/develop/context/sources/luatex-fonts.lua --- merge date : 2020-06-14 22:04 +-- merge date : 2020-06-17 18:56 do -- begin closure to overcome local limits and interference -- cgit v1.2.3