diff options
97 files changed, 1551 insertions, 1133 deletions
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 afb6565eb..43b517d38 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", "spaceasciicode", "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", "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" }, - ["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", "scratchwidth", "scratchheight", "scratchdepth", "scratchoffset", "scratchdistance", "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", "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", "doiftext", "doifelsetext", "doiftextelse", "doifnottext", "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", "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", "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", "uncramped", "cramped", "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" }, + ["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", "scratchwidth", "scratchheight", "scratchdepth", "scratchoffset", "scratchdistance", "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", "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", "doiftext", "doifelsetext", "doiftextelse", "doifnottext", "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", "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", "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", "uncramped", "cramped", "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 c70aadab2..b5a57ced6 100644 --- a/context/data/scite/context/scite-context-data-context.properties +++ b/context/data/scite/context/scite-context-data-context.properties @@ -237,5 +237,5 @@ break nobreak allowbreak goodbreak nospace \ nospacing dospacing naturalhbox naturalvbox naturalvtop \ naturalhpack naturalvpack naturaltpack reversehbox reversevbox \ reversevtop reversehpack reversevpack reversetpack frule \ -compoundhyphenpenalty start stop +compoundhyphenpenalty start stop unsupportedcs 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 afb6565eb..43b517d38 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", "spaceasciicode", "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", "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" }, - ["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", "scratchwidth", "scratchheight", "scratchdepth", "scratchoffset", "scratchdistance", "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", "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", "doiftext", "doifelsetext", "doiftextelse", "doifnottext", "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", "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", "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", "uncramped", "cramped", "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" }, + ["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", "scratchwidth", "scratchheight", "scratchdepth", "scratchoffset", "scratchdistance", "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", "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", "doiftext", "doifelsetext", "doiftextelse", "doifnottext", "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", "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", "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", "uncramped", "cramped", "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/doc/context/documents/general/qrcs/setup-cs.pdf b/doc/context/documents/general/qrcs/setup-cs.pdf Binary files differindex 906899401..c41cb49ef 100644 --- a/doc/context/documents/general/qrcs/setup-cs.pdf +++ b/doc/context/documents/general/qrcs/setup-cs.pdf diff --git a/doc/context/documents/general/qrcs/setup-de.pdf b/doc/context/documents/general/qrcs/setup-de.pdf Binary files differindex b18b06d95..d44254e68 100644 --- a/doc/context/documents/general/qrcs/setup-de.pdf +++ b/doc/context/documents/general/qrcs/setup-de.pdf diff --git a/doc/context/documents/general/qrcs/setup-en.pdf b/doc/context/documents/general/qrcs/setup-en.pdf Binary files differindex 1c790c10b..4b47392f8 100644 --- a/doc/context/documents/general/qrcs/setup-en.pdf +++ b/doc/context/documents/general/qrcs/setup-en.pdf diff --git a/doc/context/documents/general/qrcs/setup-fr.pdf b/doc/context/documents/general/qrcs/setup-fr.pdf Binary files differindex 2ab138572..251a62e8f 100644 --- a/doc/context/documents/general/qrcs/setup-fr.pdf +++ b/doc/context/documents/general/qrcs/setup-fr.pdf diff --git a/doc/context/documents/general/qrcs/setup-it.pdf b/doc/context/documents/general/qrcs/setup-it.pdf Binary files differindex fbe3ba085..fa1068b95 100644 --- a/doc/context/documents/general/qrcs/setup-it.pdf +++ b/doc/context/documents/general/qrcs/setup-it.pdf diff --git a/doc/context/documents/general/qrcs/setup-mapping-cs.pdf b/doc/context/documents/general/qrcs/setup-mapping-cs.pdf Binary files differindex d5e0f679f..224eda405 100644 --- a/doc/context/documents/general/qrcs/setup-mapping-cs.pdf +++ b/doc/context/documents/general/qrcs/setup-mapping-cs.pdf diff --git a/doc/context/documents/general/qrcs/setup-mapping-de.pdf b/doc/context/documents/general/qrcs/setup-mapping-de.pdf Binary files differindex 8e717a7cb..e6b32a837 100644 --- a/doc/context/documents/general/qrcs/setup-mapping-de.pdf +++ b/doc/context/documents/general/qrcs/setup-mapping-de.pdf diff --git a/doc/context/documents/general/qrcs/setup-mapping-en.pdf b/doc/context/documents/general/qrcs/setup-mapping-en.pdf Binary files differindex 7a04a2da9..2381c3fc8 100644 --- a/doc/context/documents/general/qrcs/setup-mapping-en.pdf +++ b/doc/context/documents/general/qrcs/setup-mapping-en.pdf diff --git a/doc/context/documents/general/qrcs/setup-mapping-fr.pdf b/doc/context/documents/general/qrcs/setup-mapping-fr.pdf Binary files differindex 4ebd7bbef..392d5cc7c 100644 --- a/doc/context/documents/general/qrcs/setup-mapping-fr.pdf +++ b/doc/context/documents/general/qrcs/setup-mapping-fr.pdf diff --git a/doc/context/documents/general/qrcs/setup-mapping-it.pdf b/doc/context/documents/general/qrcs/setup-mapping-it.pdf Binary files differindex edcf7ac25..f4d44dc8e 100644 --- a/doc/context/documents/general/qrcs/setup-mapping-it.pdf +++ b/doc/context/documents/general/qrcs/setup-mapping-it.pdf diff --git a/doc/context/documents/general/qrcs/setup-mapping-nl.pdf b/doc/context/documents/general/qrcs/setup-mapping-nl.pdf Binary files differindex 8ec8f8474..03b2eb89e 100644 --- a/doc/context/documents/general/qrcs/setup-mapping-nl.pdf +++ b/doc/context/documents/general/qrcs/setup-mapping-nl.pdf diff --git a/doc/context/documents/general/qrcs/setup-mapping-ro.pdf b/doc/context/documents/general/qrcs/setup-mapping-ro.pdf Binary files differindex f3fc39f34..a09dc6902 100644 --- a/doc/context/documents/general/qrcs/setup-mapping-ro.pdf +++ b/doc/context/documents/general/qrcs/setup-mapping-ro.pdf diff --git a/doc/context/documents/general/qrcs/setup-nl.pdf b/doc/context/documents/general/qrcs/setup-nl.pdf Binary files differindex 71317e34a..bab841262 100644 --- a/doc/context/documents/general/qrcs/setup-nl.pdf +++ b/doc/context/documents/general/qrcs/setup-nl.pdf diff --git a/doc/context/documents/general/qrcs/setup-ro.pdf b/doc/context/documents/general/qrcs/setup-ro.pdf Binary files differindex 6adfd643d..8074e904d 100644 --- a/doc/context/documents/general/qrcs/setup-ro.pdf +++ b/doc/context/documents/general/qrcs/setup-ro.pdf diff --git a/scripts/context/lua/mtx-context.lua b/scripts/context/lua/mtx-context.lua index 4466992fd..17867234d 100644 --- a/scripts/context/lua/mtx-context.lua +++ b/scripts/context/lua/mtx-context.lua @@ -876,11 +876,9 @@ function scripts.context.run(ctxdata,filename) -- report("run %s: %s",currentrun,command) print("") -- cleaner, else continuation on same line --- local returncode, errorstring = os.spawn(command) local returncode = os.execute(command) -- todo: remake format when no proper format is found if not returncode then --- report("fatal error: no return code, message: %s",errorstring or "?") report("fatal error: no return code") if resultname then result_save_error(oldbase,newbase) @@ -929,7 +927,7 @@ function scripts.context.run(ctxdata,filename) local command = luatex_command(l_flags,c_flags,mainfile,a_engine) -- report("arrange run: %s",command) - local returncode, errorstring = os.spawn(command) + local returncode, errorstring = os.execute(command) if not returncode then report("fatal error: no return code, message: %s",errorstring or "?") os.exit(1) @@ -1052,7 +1050,7 @@ function scripts.context.pipe() -- still used? report("entering scrollmode using '%s' with optionfile, end job with \\end",filename) end local command = luatex_command(l_flags,c_flags,filename) - os.spawn(command) + os.execute(command) if getargument("purge") then scripts.context.purge_job(filename) elseif getargument("purgeall") then diff --git a/scripts/context/lua/mtx-convert.lua b/scripts/context/lua/mtx-convert.lua index b3e20ea87..61ce15040 100644 --- a/scripts/context/lua/mtx-convert.lua +++ b/scripts/context/lua/mtx-convert.lua @@ -90,7 +90,7 @@ function converters.convertgraphic(kind,oldname,newname) local command = converters[kind](oldname,tmpname) report("command: %s",command) io.flush() - os.spawn(command) + os.execute(command) os.remove(newname) os.rename(tmpname,newname) if lfs.attributes(newname,"size") == 0 then diff --git a/scripts/context/lua/mtx-watch.lua b/scripts/context/lua/mtx-watch.lua index 8629058e5..7815dafdd 100644 --- a/scripts/context/lua/mtx-watch.lua +++ b/scripts/context/lua/mtx-watch.lua @@ -208,11 +208,11 @@ report("checking file %s/%s: %s",dirname,basename,ok and "okay" or "skipped") local oldpath = lfs.currentdir() lfs.chdir(newpath) scripts.watch.save_exa_modes(joblog,ctmname) - if pipe then result = os.resultof(command) else result = os.spawn(command) end + if pipe then result = os.resultof(command) else result = os.execute(command) end lfs.chdir(oldpath) else scripts.watch.save_exa_modes(joblog,ctmname) - if pipe then result = os.resultof(command) else result = os.spawn(command) end + if pipe then result = os.resultof(command) else result = os.execute(command) end end report("return value: %s", result) done = true diff --git a/scripts/context/lua/mtxrun.lua b/scripts/context/lua/mtxrun.lua index a79ffc029..a5f15a5f9 100644 --- a/scripts/context/lua/mtxrun.lua +++ b/scripts/context/lua/mtxrun.lua @@ -14040,7 +14040,7 @@ do -- create closure to overcome 200 locals limit package.loaded["util-lua"] = package.loaded["util-lua"] or true --- original size: 6664, stripped down to: 4589 +-- original size: 6778, stripped down to: 4699 if not modules then modules={} end modules ['util-lua']={ version=1.001, @@ -14067,9 +14067,9 @@ local strippedchunks={} luautilities.strippedchunks=strippedchunks luautilities.suffixes={ tma="tma", - tmc=jit and "tmb" or "tmc", + tmc=(CONTEXTLMTXMODE and CONTEXTLMTXMODE>0 and "tmd") or (jit and "tmb") or "tmc", lua="lua", - luc=jit and "lub" or "luc", + luc=(CONTEXTLMTXMODE and CONTEXTLMTXMODE>0 and "lud") or (jit and "lub") or "luc", lui="lui", luv="luv", luj="luj", @@ -25615,8 +25615,8 @@ end -- of closure -- used libraries : l-bit32.lua l-lua.lua l-macro.lua l-sandbox.lua l-package.lua l-lpeg.lua l-function.lua l-string.lua l-table.lua l-io.lua l-number.lua l-set.lua l-os.lua l-file.lua l-gzip.lua l-md5.lua l-sha.lua l-url.lua l-dir.lua l-boolean.lua l-unicode.lua l-math.lua util-str.lua util-tab.lua util-fil.lua util-sac.lua util-sto.lua util-prs.lua util-fmt.lua util-soc-imp-reset.lua util-soc-imp-socket.lua util-soc-imp-copas.lua util-soc-imp-ltn12.lua util-soc-imp-mime.lua util-soc-imp-url.lua util-soc-imp-headers.lua util-soc-imp-tp.lua util-soc-imp-http.lua util-soc-imp-ftp.lua util-soc-imp-smtp.lua trac-set.lua trac-log.lua trac-inf.lua trac-pro.lua util-lua.lua util-deb.lua util-tpl.lua util-sbx.lua util-mrg.lua util-env.lua luat-env.lua util-zip.lua lxml-tab.lua lxml-lpt.lua lxml-mis.lua lxml-aux.lua lxml-xml.lua trac-xml.lua data-ini.lua data-exp.lua data-env.lua data-tmp.lua data-met.lua data-res.lua data-pre.lua data-inp.lua data-out.lua data-fil.lua data-con.lua data-use.lua data-zip.lua data-tre.lua data-sch.lua data-lua.lua data-aux.lua data-tmf.lua data-lst.lua util-lib.lua luat-sta.lua luat-fmt.lua -- skipped libraries : - --- original bytes : 1020503 --- stripped bytes : 404014 +-- original bytes : 1020617 +-- stripped bytes : 404018 -- end library merge @@ -26163,7 +26163,7 @@ function runners.execute_program(fullname) report() report() io.flush() - local code = os.exec(command) -- (fullname,unpack(after)) does not work / maybe spawn + local code = os.execute(command) -- (fullname,unpack(after)) does not work / maybe spawn return code == 0 end end diff --git a/scripts/context/stubs/mswin/mtxrun.lua b/scripts/context/stubs/mswin/mtxrun.lua index a79ffc029..a5f15a5f9 100644 --- a/scripts/context/stubs/mswin/mtxrun.lua +++ b/scripts/context/stubs/mswin/mtxrun.lua @@ -14040,7 +14040,7 @@ do -- create closure to overcome 200 locals limit package.loaded["util-lua"] = package.loaded["util-lua"] or true --- original size: 6664, stripped down to: 4589 +-- original size: 6778, stripped down to: 4699 if not modules then modules={} end modules ['util-lua']={ version=1.001, @@ -14067,9 +14067,9 @@ local strippedchunks={} luautilities.strippedchunks=strippedchunks luautilities.suffixes={ tma="tma", - tmc=jit and "tmb" or "tmc", + tmc=(CONTEXTLMTXMODE and CONTEXTLMTXMODE>0 and "tmd") or (jit and "tmb") or "tmc", lua="lua", - luc=jit and "lub" or "luc", + luc=(CONTEXTLMTXMODE and CONTEXTLMTXMODE>0 and "lud") or (jit and "lub") or "luc", lui="lui", luv="luv", luj="luj", @@ -25615,8 +25615,8 @@ end -- of closure -- used libraries : l-bit32.lua l-lua.lua l-macro.lua l-sandbox.lua l-package.lua l-lpeg.lua l-function.lua l-string.lua l-table.lua l-io.lua l-number.lua l-set.lua l-os.lua l-file.lua l-gzip.lua l-md5.lua l-sha.lua l-url.lua l-dir.lua l-boolean.lua l-unicode.lua l-math.lua util-str.lua util-tab.lua util-fil.lua util-sac.lua util-sto.lua util-prs.lua util-fmt.lua util-soc-imp-reset.lua util-soc-imp-socket.lua util-soc-imp-copas.lua util-soc-imp-ltn12.lua util-soc-imp-mime.lua util-soc-imp-url.lua util-soc-imp-headers.lua util-soc-imp-tp.lua util-soc-imp-http.lua util-soc-imp-ftp.lua util-soc-imp-smtp.lua trac-set.lua trac-log.lua trac-inf.lua trac-pro.lua util-lua.lua util-deb.lua util-tpl.lua util-sbx.lua util-mrg.lua util-env.lua luat-env.lua util-zip.lua lxml-tab.lua lxml-lpt.lua lxml-mis.lua lxml-aux.lua lxml-xml.lua trac-xml.lua data-ini.lua data-exp.lua data-env.lua data-tmp.lua data-met.lua data-res.lua data-pre.lua data-inp.lua data-out.lua data-fil.lua data-con.lua data-use.lua data-zip.lua data-tre.lua data-sch.lua data-lua.lua data-aux.lua data-tmf.lua data-lst.lua util-lib.lua luat-sta.lua luat-fmt.lua -- skipped libraries : - --- original bytes : 1020503 --- stripped bytes : 404014 +-- original bytes : 1020617 +-- stripped bytes : 404018 -- end library merge @@ -26163,7 +26163,7 @@ function runners.execute_program(fullname) report() report() io.flush() - local code = os.exec(command) -- (fullname,unpack(after)) does not work / maybe spawn + local code = os.execute(command) -- (fullname,unpack(after)) does not work / maybe spawn return code == 0 end end diff --git a/scripts/context/stubs/unix/mtxrun b/scripts/context/stubs/unix/mtxrun index a79ffc029..a5f15a5f9 100644 --- a/scripts/context/stubs/unix/mtxrun +++ b/scripts/context/stubs/unix/mtxrun @@ -14040,7 +14040,7 @@ do -- create closure to overcome 200 locals limit package.loaded["util-lua"] = package.loaded["util-lua"] or true --- original size: 6664, stripped down to: 4589 +-- original size: 6778, stripped down to: 4699 if not modules then modules={} end modules ['util-lua']={ version=1.001, @@ -14067,9 +14067,9 @@ local strippedchunks={} luautilities.strippedchunks=strippedchunks luautilities.suffixes={ tma="tma", - tmc=jit and "tmb" or "tmc", + tmc=(CONTEXTLMTXMODE and CONTEXTLMTXMODE>0 and "tmd") or (jit and "tmb") or "tmc", lua="lua", - luc=jit and "lub" or "luc", + luc=(CONTEXTLMTXMODE and CONTEXTLMTXMODE>0 and "lud") or (jit and "lub") or "luc", lui="lui", luv="luv", luj="luj", @@ -25615,8 +25615,8 @@ end -- of closure -- used libraries : l-bit32.lua l-lua.lua l-macro.lua l-sandbox.lua l-package.lua l-lpeg.lua l-function.lua l-string.lua l-table.lua l-io.lua l-number.lua l-set.lua l-os.lua l-file.lua l-gzip.lua l-md5.lua l-sha.lua l-url.lua l-dir.lua l-boolean.lua l-unicode.lua l-math.lua util-str.lua util-tab.lua util-fil.lua util-sac.lua util-sto.lua util-prs.lua util-fmt.lua util-soc-imp-reset.lua util-soc-imp-socket.lua util-soc-imp-copas.lua util-soc-imp-ltn12.lua util-soc-imp-mime.lua util-soc-imp-url.lua util-soc-imp-headers.lua util-soc-imp-tp.lua util-soc-imp-http.lua util-soc-imp-ftp.lua util-soc-imp-smtp.lua trac-set.lua trac-log.lua trac-inf.lua trac-pro.lua util-lua.lua util-deb.lua util-tpl.lua util-sbx.lua util-mrg.lua util-env.lua luat-env.lua util-zip.lua lxml-tab.lua lxml-lpt.lua lxml-mis.lua lxml-aux.lua lxml-xml.lua trac-xml.lua data-ini.lua data-exp.lua data-env.lua data-tmp.lua data-met.lua data-res.lua data-pre.lua data-inp.lua data-out.lua data-fil.lua data-con.lua data-use.lua data-zip.lua data-tre.lua data-sch.lua data-lua.lua data-aux.lua data-tmf.lua data-lst.lua util-lib.lua luat-sta.lua luat-fmt.lua -- skipped libraries : - --- original bytes : 1020503 --- stripped bytes : 404014 +-- original bytes : 1020617 +-- stripped bytes : 404018 -- end library merge @@ -26163,7 +26163,7 @@ function runners.execute_program(fullname) report() report() io.flush() - local code = os.exec(command) -- (fullname,unpack(after)) does not work / maybe spawn + local code = os.execute(command) -- (fullname,unpack(after)) does not work / maybe spawn return code == 0 end end diff --git a/scripts/context/stubs/win64/mtxrun.lua b/scripts/context/stubs/win64/mtxrun.lua index a79ffc029..a5f15a5f9 100644 --- a/scripts/context/stubs/win64/mtxrun.lua +++ b/scripts/context/stubs/win64/mtxrun.lua @@ -14040,7 +14040,7 @@ do -- create closure to overcome 200 locals limit package.loaded["util-lua"] = package.loaded["util-lua"] or true --- original size: 6664, stripped down to: 4589 +-- original size: 6778, stripped down to: 4699 if not modules then modules={} end modules ['util-lua']={ version=1.001, @@ -14067,9 +14067,9 @@ local strippedchunks={} luautilities.strippedchunks=strippedchunks luautilities.suffixes={ tma="tma", - tmc=jit and "tmb" or "tmc", + tmc=(CONTEXTLMTXMODE and CONTEXTLMTXMODE>0 and "tmd") or (jit and "tmb") or "tmc", lua="lua", - luc=jit and "lub" or "luc", + luc=(CONTEXTLMTXMODE and CONTEXTLMTXMODE>0 and "lud") or (jit and "lub") or "luc", lui="lui", luv="luv", luj="luj", @@ -25615,8 +25615,8 @@ end -- of closure -- used libraries : l-bit32.lua l-lua.lua l-macro.lua l-sandbox.lua l-package.lua l-lpeg.lua l-function.lua l-string.lua l-table.lua l-io.lua l-number.lua l-set.lua l-os.lua l-file.lua l-gzip.lua l-md5.lua l-sha.lua l-url.lua l-dir.lua l-boolean.lua l-unicode.lua l-math.lua util-str.lua util-tab.lua util-fil.lua util-sac.lua util-sto.lua util-prs.lua util-fmt.lua util-soc-imp-reset.lua util-soc-imp-socket.lua util-soc-imp-copas.lua util-soc-imp-ltn12.lua util-soc-imp-mime.lua util-soc-imp-url.lua util-soc-imp-headers.lua util-soc-imp-tp.lua util-soc-imp-http.lua util-soc-imp-ftp.lua util-soc-imp-smtp.lua trac-set.lua trac-log.lua trac-inf.lua trac-pro.lua util-lua.lua util-deb.lua util-tpl.lua util-sbx.lua util-mrg.lua util-env.lua luat-env.lua util-zip.lua lxml-tab.lua lxml-lpt.lua lxml-mis.lua lxml-aux.lua lxml-xml.lua trac-xml.lua data-ini.lua data-exp.lua data-env.lua data-tmp.lua data-met.lua data-res.lua data-pre.lua data-inp.lua data-out.lua data-fil.lua data-con.lua data-use.lua data-zip.lua data-tre.lua data-sch.lua data-lua.lua data-aux.lua data-tmf.lua data-lst.lua util-lib.lua luat-sta.lua luat-fmt.lua -- skipped libraries : - --- original bytes : 1020503 --- stripped bytes : 404014 +-- original bytes : 1020617 +-- stripped bytes : 404018 -- end library merge @@ -26163,7 +26163,7 @@ function runners.execute_program(fullname) report() report() io.flush() - local code = os.exec(command) -- (fullname,unpack(after)) does not work / maybe spawn + local code = os.execute(command) -- (fullname,unpack(after)) does not work / maybe spawn return code == 0 end end diff --git a/tex/context/base/mkii/cont-new.mkii b/tex/context/base/mkii/cont-new.mkii index 0dda26e80..02708252c 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{2019.04.04 13:31} +\newcontextversion{2019.04.12 17:43} %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 91d282601..a5c5b8be5 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{2019.04.04 13:31} +\edef\contextversion{2019.04.12 17:43} %D For those who want to use this: diff --git a/tex/context/base/mkiv/anch-pgr.mkiv b/tex/context/base/mkiv/anch-pgr.mkiv index 7fa378cd1..f2195818a 100644 --- a/tex/context/base/mkiv/anch-pgr.mkiv +++ b/tex/context/base/mkiv/anch-pgr.mkiv @@ -70,7 +70,7 @@ {\anch_positions_trace_action_yes \the\everyinsertpositionaction \the\everypositionaction - \csname\??positionaction\currentpositionaction\endcsname + \begincsname\??positionaction\currentpositionaction\endcsname \anch_positions_cleanup_action}% \smashedbox\scratchbox % smashing is really needed else we get problems with too big overlays \endgroup} @@ -367,7 +367,7 @@ \obeyMPboxorigin % do we also set the size ? when needed this must be done in mp ... might change \def\anch_positions_meta_graphic_direct{\anch_positions_meta_graphic_nested{#3}}% takes two extra arguments \setbox\b_anch_positions_graphic\hbox % \hpack - {\ignorespaces\csname#1#2\endcsname\removelastspace}% + {\ignorespaces\begincsname#1#2\endcsname\removelastspace}% \smashbox\b_anch_positions_graphic \box\b_anch_positions_graphic \endgroup} @@ -377,7 +377,7 @@ \setupMPvariables[#2][#1,#3]% \edef\currentmpvariableclass{#2}% \anch_positions_meta_graphic_prepare - \csname\??positiongraphic#2\endcsname + \begincsname\??positiongraphic#2\endcsname \endgroup}% \def\startMPpositionmethod#1#2\stopMPpositionmethod diff --git a/tex/context/base/mkiv/attr-ini.mkiv b/tex/context/base/mkiv/attr-ini.mkiv index 3792b1c63..6a1ac86de 100644 --- a/tex/context/base/mkiv/attr-ini.mkiv +++ b/tex/context/base/mkiv/attr-ini.mkiv @@ -108,8 +108,13 @@ \let\dompattribute\gobbletwoarguments -\unexpanded\def\resetglobalattributes{\the\t_attr_list_global\attribute\zerocount\zerocount} -\unexpanded\def\resetlocalattributes {\the\t_attr_list_local \attribute\zerocount\zerocount} +\ifcase\contextlmtxmode + \unexpanded\def\resetglobalattributes{\attribute\zerocount\zerocount\the\t_attr_list_global\relax} + \unexpanded\def\resetlocalattributes {\attribute\zerocount\zerocount\the\t_attr_list_local \relax} +\else + \unexpanded\def\resetglobalattributes{\glyphdatafield \zerocount\the\t_attr_list_global\relax} + \unexpanded\def\resetlocalattributes {\glyphdatafield \zerocount\the\t_attr_list_local \relax} +\fi \let\resetallattributes\resetlocalattributes @@ -152,7 +157,7 @@ % for the luatex list: % % \attributedef\zeroattribute=0 -% \attributedef\someatriubute=999 +% \attributedef\someattribute=999 % % \directlua { % local createtoken = newtoken.create diff --git a/tex/context/base/mkiv/back-ini.lua b/tex/context/base/mkiv/back-ini.lua index b7af1529b..b7ecce00b 100644 --- a/tex/context/base/mkiv/back-ini.lua +++ b/tex/context/base/mkiv/back-ini.lua @@ -76,7 +76,7 @@ local lmtx_mode = nil local function lmtxmode() if lmtx_mode == nil then - lmtx_mode = ((tonumber(CONTEXTLMTXMODE) or 0) > 0) and drivers and drivers.lmtxversion + lmtx_mode = CONTEXTLMTXMODE > 0 and drivers and drivers.lmtxversion end return lmtx_mode end diff --git a/tex/context/base/mkiv/back-lpd.lua b/tex/context/base/mkiv/back-lpd.lua index 44ffbc43a..48053e72b 100644 --- a/tex/context/base/mkiv/back-lpd.lua +++ b/tex/context/base/mkiv/back-lpd.lua @@ -2346,7 +2346,8 @@ do local isfile = lfs.isfile local removefile = os.remove local renamefile = os.rename --- local addsuffix = file.addsuffix + -- local copyfile = file.copy + -- local addsuffix = file.addsuffix local pdfname = nil local tmpname = nil @@ -2408,6 +2409,7 @@ do end if isfile(pdfname) then ok = false + file.copy(tmpname,pdfname) else renamefile(tmpname,pdfname) if isfile(tmpname) then diff --git a/tex/context/base/mkiv/back-out.lua b/tex/context/base/mkiv/back-out.lua index a0e05afca..86a1669a0 100644 --- a/tex/context/base/mkiv/back-out.lua +++ b/tex/context/base/mkiv/back-out.lua @@ -7,35 +7,6 @@ if not modules then modules = { } end modules ['back-out'] = { } if CONTEXTLMTXMODE == 0 then - - return - -elseif CONTEXTLMTXMODE == 1 then - - local type = type - local getdata = nodes.nuts.getdata - local loadstring = loadstring - - function backends.latelua(current,pos_h,pos_v,cur_h,cur_v) - data = getdata(current) - local kind = type(data) - if kind == "function" then - data() - elseif kind == "table" then - data.action(data) - else - -- if kind ~= "string" then - -- data = tokentostring(data) - -- end - if #data ~= "" then - local code = loadstring(data) - if code then - code() - end - end - end - end - return end @@ -57,6 +28,7 @@ local tokentostring = token.to_string local logwriter = logs.writer local openfile = io.open +local flushio = io.flush local nuts = nodes.nuts local tonode = nuts.tonode @@ -93,15 +65,17 @@ local setmatrixnode = register(newnut(whatsit_code,whatsitcodes.setmatrix) local tomatrix = drivers.helpers.tomatrix +local immediately = false -- not watertight + local open_command, write_command, close_command backends = backends or { } -local function openout(immediate) +local function openout() local channel = scaninteger() scankeyword("=") -- hack local filename = scanstring() - if not immediate then + if not immediately then local n = copynode(opennode) nodeproperties[n] = { channel = channel, filename = filename } -- action = "open" return context(tonode(n)) @@ -113,6 +87,7 @@ local function openout(immediate) -- error end end + immediately = false end function backends.openout(n) @@ -127,9 +102,9 @@ function backends.openout(n) end end -local function write(immediate) +local function write() local channel = scaninteger() - if not immediate then + if not immediately then local t = scantokenlist() local n = copynode(writenode) nodeproperties[n] = { channel = channel, data = t } -- action = "write" @@ -143,6 +118,7 @@ local function write(immediate) logwriter(content,"\n") end end + immediately = false end function backends.writeout(n) @@ -158,9 +134,9 @@ function backends.writeout(n) end end -local function closeout(immediate) +local function closeout() local channel = scaninteger() - if not immediate then + if not immediately then local n = copynode(closenode) nodeproperties[n] = { channel = channel } -- action = "close" return context(tonode(n)) @@ -169,10 +145,12 @@ local function closeout(immediate) if handle then handle:close() channels[channel] = false + flushio() else -- error end end + immediately = false end function backends.closeout(n) @@ -183,6 +161,7 @@ function backends.closeout(n) if handle then handle:close() channels[channel] = false + flushio() else -- error end @@ -190,14 +169,7 @@ function backends.closeout(n) end local function immediate() - local command = scancode() - if command == write_command then - write(true) - elseif command == open_command then - openout(true) - elseif command == close_command then - closeout(true) - end + immediately = true end local noflatelua = 0 diff --git a/tex/context/base/mkiv/back-pdf.mkiv b/tex/context/base/mkiv/back-pdf.mkiv index 9e88ab193..776581413 100644 --- a/tex/context/base/mkiv/back-pdf.mkiv +++ b/tex/context/base/mkiv/back-pdf.mkiv @@ -16,7 +16,11 @@ \writestatus{loading}{ConTeXt Backend Macros / PDF} \registerctxluafile{lpdf-ini}{optimize} -\registerctxluafile{lpdf-nod}{} + +\ifcase\contextlmtxmode\relax + \registerctxluafile{lpdf-nod}{} +\fi + \registerctxluafile{lpdf-col}{} \registerctxluafile{lpdf-xmp}{} \registerctxluafile{lpdf-ano}{} @@ -72,9 +76,10 @@ %D \type {\pdfextension} and \type {\pdffeedback} primitives but it will probably %D have bad side effects. -%D For the moment we put these here as they are pdf related but they might move to -%D a better place. We overload the primitives with our own but use a bit of indirection -%D for the purpose of tracing. +%D For the moment we put these here as they are pdf related but they might move to a +%D better place. We overload the primitives with our own but use a bit of +%D indirection for the purpose of tracing. Some of these are needes for packages like +%D tikz. \unexpanded\def\saveboxresource {\clf_saveboxresource} \unexpanded\def\lastsavedboxresourceindex {\numexpr\clf_lastsavedboxresourceindex\relax} @@ -85,54 +90,53 @@ \unexpanded\def\lastsavedimageresourcepages{\numexpr\clf_lastsavedimageresourcepages\relax} \unexpanded\def\useimageresource {\clf_useimageresource} -\unexpanded\def\savepos {\clf_savepos} - \def\lastxpos {\clf_lastxpos} - \def\lastypos {\clf_lastypos} - -\unexpanded\def\pdfextension {\clf_pdfextension} - \def\pdffeedback {\clf_pdffeedback} - -%D These are no-ops and don't even intercept what comes next. Maybe some day -%D I'll write a parser that maps onto \CONTEXT. - -\unexpanded\def\unsupportedpdfprimitive#1% - {\writestatus{fatal error}{the primitive \string#1\space is not supported}% - \directlua{os.exit()}} - -\unexpanded\def\pdfcolorstack {\unsupportedpdfprimitive\pdfcolorstack} -\unexpanded\def\pdfcolorstackinit{\unsupportedpdfprimitive\pdfcolorstackinit} -% pdfannot -\unexpanded\def\pdfstartlink {\unsupportedpdfprimitive\pdfstartlink} -\unexpanded\def\pdfendlink {\unsupportedpdfprimitive\pdfendlink} -\unexpanded\def\pdfoutline {\unsupportedpdfprimitive\pdfoutline} -% pdfdest -\unexpanded\def\pdfthread {\unsupportedpdfprimitive\pdfthread} -\unexpanded\def\pdfstartthread {\unsupportedpdfprimitive\pdfstartthread} -\unexpanded\def\pdfendthread {\unsupportedpdfprimitive\pdfendthread} -\unexpanded\def\pdffontattr {\unsupportedpdfprimitive\pdffontattr} -\unexpanded\def\pdfglyphtounicode{\unsupportedpdfprimitive\pdfglyphtounicode} +%D Maybe these are used: -\unexpanded\def\pdfannot {\clf_pdfannot} -\unexpanded\def\pdfdest {\clf_pdfdest} +\unexpanded\def\savepos {\clf_savepos} + \def\lastxpos{\clf_lastxpos} + \def\lastypos{\clf_lastypos} -%D Here we do intercept (silently) what gets passed. One should use the \CONTEXT\ -%D interfaces instead. +%D We do some interception: -\let\pdfcatalog \relax \newtoks\pdfcatalog -\let\pdfinfo \relax \newtoks\pdfinfo -\let\pdfnames \relax \newtoks\pdfnames -\let\pdftrailer \relax \newtoks\pdftrailer -\let\pdfpageresources \relax \newtoks\pdfpageresources -\let\pdfpageattr \relax \newtoks\pdfpageattr -\let\pdfpagesattr \relax \newtoks\pdfpagesattr -\let\pdfxformattr \relax \newtoks\pdfxformattr -\let\pdfxformresources\relax \newtoks\pdfxformresources +\unexpanded\def\pdfextension{\clf_pdfextension} + \def\pdffeedback {\clf_pdffeedback} -%D We use the \LUA\ interface (which then permits more control over possible pdf/x -%D extensions). +%D These are no-ops and don't even intercept what comes next. We used to use +%D token registers for some so that they kept working but now we just abort the +%D run. -\let\pdfcompresslevel \relax \newcount\pdfcompresslevel -\let\pdfobjcompresslevel\relax \newcount\pdfobjcompresslevel +\unexpanded\def\pdfannot {\clf_pdfannot} +\unexpanded\def\pdfcolorstack {\unsupportedcs\pdfcolorstack} +\unexpanded\def\pdfcolorstackinit{\unsupportedcs\pdfcolorstackinit} +\unexpanded\def\pdfdest {\clf_pdfdest} +\unexpanded\def\pdfendlink {\unsupportedcs\pdfendlink} +\unexpanded\def\pdfendthread {\unsupportedcs\pdfendthread} +\unexpanded\def\pdffontattr {\unsupportedcs\pdffontattr} +\unexpanded\def\pdfglyphtounicode{\unsupportedcs\pdfglyphtounicode} +\unexpanded\def\pdfoutline {\unsupportedcs\pdfoutline} +\unexpanded\def\pdfstartlink {\unsupportedcs\pdfstartlink} +\unexpanded\def\pdfstartthread {\unsupportedcs\pdfstartthread} +\unexpanded\def\pdfthread {\unsupportedcs\pdfthread} + +\unexpanded\def\pdfcatalog {\unsupportedcs\pdfcatalog} +\unexpanded\def\pdfinfo {\unsupportedcs\pdfinfo} +\unexpanded\def\pdfnames {\unsupportedcs\pdfnames} +\unexpanded\def\pdftrailer {\unsupportedcs\pdftrailer} +\unexpanded\def\pdfpageresources {\unsupportedcs\pdfpageresources} +\unexpanded\def\pdfpageattr {\unsupportedcs\pdfpageattr} +\unexpanded\def\pdfpagesattr {\unsupportedcs\pdfpagesattr} +\unexpanded\def\pdfxformattr {\unsupportedcs\pdfxformattr} +\unexpanded\def\pdfxformresources{\unsupportedcs\pdfxformresources} + +%D There is no need for these: + +\unexpanded\def\pdfmapfile {\unsupportedcs\pdfmapfile} +\unexpanded\def\pdfmapline {\unsupportedcs\pdfmapline} + +%D These have been no-ops for a long time so now we just abort on their usage. + +\unexpanded\def\pdfcompresslevel {\unsupportedcs\pdfcompresslevel} +\unexpanded\def\pdfobjcompresslevel{\unsupportedcs\pdfobjcompresslevel} %D But we still provide: @@ -141,53 +145,48 @@ \unexpanded\def\maximumpdfcompression {\clf_setpdfcompression\plusnine \plusnine } \unexpanded\def\normalpdfcompression {\clf_setpdfcompression\plusthree\plusthree} -%D These might even become no-ops as we don't need them in \CONTEXT: - -\unexpanded\def\pdfmapfile#1{} % obsolete -\unexpanded\def\pdfmapline#1{} % obsolete - %D We don't support these directives, at least not this way. If they are needed %D by third party modules we can provide some interface. -%pdfcreationdate -\let\pdfdecimaldigits \relax \newcount\pdfdecimaldigits -\let\pdfdestmargin \relax \newdimen\pdfdestmargin +% pdfcreationdate +\def\pdfdecimaldigits {\unsupportedcs\pdfdecimaldigits} +\def\pdfdestmargin {\unsupportedcs\pdfdestmargin} % pdffontname % pdffontobjnum -\let\pdffontsize \relax \newcount\pdffontsize -\let\pdfgamma \relax \newcount\pdfgamma -\let\pdfgentounicode \relax \newcount\pdfgentounicode -\let\pdfhorigin \relax \newcount\pdfhorigin -\let\pdfignoreunknownimages \relax \newcount\pdfignoreunknownimages -\let\pdfimageaddfilename \relax \newcount\pdfimageaddfilename -\let\pdfimageapplygamma \relax \newcount\pdfimageapplygamma -\let\pdfimagegamma \relax \newcount\pdfimagegamma -\let\pdfimagehicolor \relax \newcount\pdfimagehicolor -\let\pdfimageresolution \relax \newcount\pdfimageresolution -\let\pdfincludechars \relax \newtoks \pdfincludechars -\let\pdfinclusioncopyfonts \relax \newcount\pdfinclusioncopyfonts -\let\pdfinclusionerrorlevel \relax \newcount\pdfinclusionerrorlevel -\let\pdfinfoomitdate \relax \newcount\pdfinfoomitdate +\def\pdffontsize {\unsupportedcs\pdffontsize} +\def\pdfgamma {\unsupportedcs\pdfgamma} +\def\pdfgentounicode {\unsupportedcs\pdfgentounicode} +\def\pdfhorigin {\unsupportedcs\pdfhorigin} +\def\pdfignoreunknownimages {\unsupportedcs\pdfignoreunknownimages} +\def\pdfimageaddfilename {\unsupportedcs\pdfimageaddfilename} +\def\pdfimageapplygamma {\unsupportedcs\pdfimageapplygamma} +\def\pdfimagegamma {\unsupportedcs\pdfimagegamma} +\def\pdfimagehicolor {\unsupportedcs\pdfimagehicolor} +\def\pdfimageresolution {\unsupportedcs\pdfimageresolution} +\def\pdfincludechars {\unsupportedcs\pdfincludechars} +\def\pdfinclusioncopyfonts {\unsupportedcs\pdfinclusioncopyfonts} +\def\pdfinclusionerrorlevel {\unsupportedcs\pdfinclusionerrorlevel} +\def\pdfinfoomitdate {\unsupportedcs\pdfinfoomitdate} % pdflastannot % pdflastlink -\let\pdflinkmargin \relax \newdimen\pdflinkmargin -\let\pdfmajorversion \relax \newcount\pdfmajorversion -\let\pdfminorversion \relax \newcount\pdfminorversion -\let\pdfpagebox \relax \newcount\pdfpagebox +\def\pdflinkmargin {\unsupportedcs\pdflinkmargin} +\def\pdfmajorversion {\unsupportedcs\pdfmajorversion} +\def\pdfminorversion {\unsupportedcs\pdfminorversion} +\def\pdfpagebox {\unsupportedcs\pdfpagebox} % pdfpageref -\let\pdfpkfixeddpi \relax \newcount\pdfpkfixeddpi -\let\pdfpkmode \relax \newtoks \pdfpkmode -\let\pdfpkresolution \relax \newcount\pdfpkresolution +\def\pdfpkfixeddpi {\unsupportedcs\pdfpkfixeddpi} +\def\pdfpkmode {\unsupportedcs\pdfpkmode} +\def\pdfpkresolution {\unsupportedcs\pdfpkresolution} % pdfretval -\let\pdfsuppressoptionalinfo \relax \newcount\pdfsuppressoptionalinfo -\let\pdfsuppressptexinfo \relax \newcount\pdfsuppressptexinfo +\def\pdfsuppressoptionalinfo {\unsupportedcs\pdfsuppressoptionalinfo} +\def\pdfsuppressptexinfo {\unsupportedcs\pdfsuppressptexinfo} % pdftexrevision % pdftexversion -\let\pdfthreadmargin \relax \newdimen\pdfthreadmargin -\let\pdftrailerid \relax \newtoks \pdftrailerid -\let\pdfuniqueresname \relax \newcount\pdfuniqueresname -\let\pdfvorigin \relax \newcount\pdfvorigin -\let\pdfxformmargin \relax \newdimen\pdfxformmargin +\def\pdfthreadmargin {\unsupportedcs\pdfthreadmargin} +\def\pdftrailerid {\unsupportedcs\pdftrailerid} +\def\pdfuniqueresname {\unsupportedcs\pdfuniqueresname} +\def\pdfvorigin {\unsupportedcs\pdfvorigin} +\def\pdfxformmargin {\unsupportedcs\pdfxformmargin} % \pdfxformname %D These are still accepted but are normally not needed. @@ -210,15 +209,15 @@ %D For the moment we keep these as they are but they will become \LUA\ calls %D eventually, after which we will nil the three \type {\pdf} interface primitives. -\normalprotected\def\pdfliteral {\clf_pdfliteral}% +\unexpanded\def\pdfliteral {\clf_pdfliteral}% -\normalprotected\def\pdfobj {\clf_pdfobj}% -\normalprotected\def\pdflastobj {\numexpr\clf_pdflastobj\relax}% +\unexpanded\def\pdfobj {\clf_pdfobj}% +\unexpanded\def\pdflastobj {\numexpr\clf_pdflastobj\relax}% -\normalprotected\def\pdfrefobj {\pdfextension refobj } -\normalprotected\def\pdfrestore {\clf_restore} -\normalprotected\def\pdfsave {\clf_save} -\normalprotected\def\pdfsetmatrix{\clf_setmatrix} +\unexpanded\def\pdfrefobj {\pdfextension refobj } +\unexpanded\def\pdfrestore {\clf_restore} +\unexpanded\def\pdfsave {\clf_save} +\unexpanded\def\pdfsetmatrix{\clf_setmatrix} %D This one can be consulted by users although the suffix is also a system mode. diff --git a/tex/context/base/mkiv/back-pdp.lua b/tex/context/base/mkiv/back-pdp.lua index 7363cfcae..d7033608c 100644 --- a/tex/context/base/mkiv/back-pdp.lua +++ b/tex/context/base/mkiv/back-pdp.lua @@ -349,7 +349,6 @@ implement { name = "pdfdest", actions = pdfdest } -- management - local function pdfsave() context(newsave()) end @@ -362,7 +361,6 @@ local function pdfsetmatrix() context(newsetmatrix(scanstring())) end - -- extras local function pdfpageref() diff --git a/tex/context/base/mkiv/buff-ini.mkiv b/tex/context/base/mkiv/buff-ini.mkiv index 145f0f392..4e12271dd 100644 --- a/tex/context/base/mkiv/buff-ini.mkiv +++ b/tex/context/base/mkiv/buff-ini.mkiv @@ -132,7 +132,7 @@ \unexpanded\def\buff_stop#1% {\endgroup % (3 & 4 & 5 & 6) - \csname#1\endcsname} + \begincsname#1\endcsname} % \installctxfunction\dopickupbuffer{commands.dopickupbuffer} diff --git a/tex/context/base/mkiv/cldf-bas.lua b/tex/context/base/mkiv/cldf-bas.lua index f55132a06..9e789a72f 100644 --- a/tex/context/base/mkiv/cldf-bas.lua +++ b/tex/context/base/mkiv/cldf-bas.lua @@ -193,34 +193,12 @@ context.registers = { newchar = function(name,u) context([[\chardef\%s=%s\relax]],name,u) end, } -do - - if CONTEXTLMTXMODE > 1 then - - function context.latelua(f) - -- table check moved elsewhere - local latelua = new_latelua(f) - setattrlist(latelua,true) -- will become an option - ctx_flushnode(latelua,true) - end - - else - - function context.latelua(f) - if type(f) == "table" then - local action = f.action - local specification = f.specification or f - f = function() action(specification) end - end - local latelua = new_latelua(f) - setattrlist(latelua,true) -- will become an option - ctx_flushnode(latelua,true) - end - - end - +function context.latelua(f) + -- table check moved elsewhere + local latelua = new_latelua(f) + setattrlist(latelua,true) -- will become an option + ctx_flushnode(latelua,true) end --- yes or no do diff --git a/tex/context/base/mkiv/colo-ini.mkiv b/tex/context/base/mkiv/colo-ini.mkiv index 7079322f7..8c2c0e792 100644 --- a/tex/context/base/mkiv/colo-ini.mkiv +++ b/tex/context/base/mkiv/colo-ini.mkiv @@ -485,7 +485,7 @@ \def\colo_palet_prepare#1% {\edef\colo_palet_name{#1}% \ifcsname\??paletlist\colo_palet_name\endcsname - \csname\??paletsize#1\endcsname\zerocount + \csname\??paletsize\colo_palet_name\endcsname\zerocount \else \colo_palet_allocate\colo_palet_name \fi @@ -804,21 +804,21 @@ \def\colo_helpers_fast_activate_yes#1% {\ifcsname\??colorsetter\currentcolorprefix#1\endcsname \lastnamedcs - \csname\??transparencysetter\currentcolorprefix#1\endcsname + \begincsname\??transparencysetter\currentcolorprefix#1\endcsname \else\ifcsname\??colorsetter#1\endcsname \lastnamedcs - \csname\??transparencysetter#1\endcsname + \begincsname\??transparencysetter#1\endcsname \fi\fi} \def\colo_helpers_fast_activate_nop#1% {\ifcsname\??colorsetter#1\endcsname \lastnamedcs - \csname\??transparencysetter#1\endcsname + \begincsname\??transparencysetter#1\endcsname \fi} \def\colo_helpers_activate_dummy - {\csname\??colorsetter \v_colo_dummy_name\endcsname - \csname\??transparencysetter\v_colo_dummy_name\endcsname} + {\begincsname\??colorsetter \v_colo_dummy_name\endcsname + \begincsname\??transparencysetter\v_colo_dummy_name\endcsname} \let\dofastcoloractivation\colo_helpers_fast_activate @@ -835,16 +835,16 @@ \def\colo_helpers_activate_yes {\ifcsname\??colorsetter\currentcolorprefix\currentcolorname\endcsname \lastnamedcs - \csname\??transparencysetter\currentcolorprefix\currentcolorname\endcsname + \begincsname\??transparencysetter\currentcolorprefix\currentcolorname\endcsname \else\ifcsname\??colorsetter\currentcolorname\endcsname \lastnamedcs - \csname\??transparencysetter\currentcolorname\endcsname + \begincsname\??transparencysetter\currentcolorname\endcsname \fi\fi} \def\colo_helpers_activate_nop {\ifcsname\??colorsetter\currentcolorname\endcsname \lastnamedcs - \csname\??transparencysetter\currentcolorname\endcsname + \begincsname\??transparencysetter\currentcolorname\endcsname \fi} \def\colo_helpers_activate_yes_only @@ -870,10 +870,10 @@ {\let\currentcolorname\currentcolorparameter % maybe only when success \ifcsname\??colorsetter\currentcolorprefix\currentcolorparameter\endcsname \lastnamedcs - \csname\??transparencysetter\currentcolorprefix\currentcolorparameter\endcsname + \begincsname\??transparencysetter\currentcolorprefix\currentcolorparameter\endcsname \else\ifcsname\??colorsetter\currentcolorparameter\endcsname \lastnamedcs - \csname\??transparencysetter\currentcolorparameter\endcsname + \begincsname\??transparencysetter\currentcolorparameter\endcsname \fi\fi} \let\dosetcolorattribute\dousecolorhashparameter % for a while diff --git a/tex/context/base/mkiv/cont-new.mkiv b/tex/context/base/mkiv/cont-new.mkiv index a94cb5d08..5565f1eaf 100644 --- a/tex/context/base/mkiv/cont-new.mkiv +++ b/tex/context/base/mkiv/cont-new.mkiv @@ -11,7 +11,7 @@ %C therefore copyrighted by \PRAGMA. See mreadme.pdf for %C details. -\newcontextversion{2019.04.04 13:31} +\newcontextversion{2019.04.12 17:43} %D This file is loaded at runtime, thereby providing an excellent place for %D hacks, patches, extensions and new features. diff --git a/tex/context/base/mkiv/context.mkiv b/tex/context/base/mkiv/context.mkiv index 98d964b24..a3e237f20 100644 --- a/tex/context/base/mkiv/context.mkiv +++ b/tex/context/base/mkiv/context.mkiv @@ -42,7 +42,7 @@ %D has to match \type {YYYY.MM.DD HH:MM} format. \edef\contextformat {\jobname} -\edef\contextversion{2019.04.04 13:31} +\edef\contextversion{2019.04.12 17:43} \edef\contextkind {beta} %D Kind of special: diff --git a/tex/context/base/mkiv/driv-ini.mkiv b/tex/context/base/mkiv/driv-ini.mkiv index 95b6c88a7..958afb6a9 100644 --- a/tex/context/base/mkiv/driv-ini.mkiv +++ b/tex/context/base/mkiv/driv-ini.mkiv @@ -17,9 +17,15 @@ \unprotect -\def\page_shipout_box#1% +\unexpanded\def\page_shipout_box#1% {\clf_shipoutpage#1\relax - \setbox#1\emptybox + \global\setbox#1\emptybox \global\deadcycles\zerocount} +\ifdefined\page_otr_shipout_yes \else + + \let\page_otr_shipout_yes\page_shipout_box + +\fi + \protect \endinput diff --git a/tex/context/base/mkiv/driv-shp.lua b/tex/context/base/mkiv/driv-shp.lua index 7938e3e5c..5fcfc7955 100644 --- a/tex/context/base/mkiv/driv-shp.lua +++ b/tex/context/base/mkiv/driv-shp.lua @@ -115,8 +115,6 @@ local instances = drivers.instances --------------------------------------------------------------------------------------- -local synctex = false - local lastfont = nil local fontcharacters = nil @@ -330,11 +328,10 @@ flush_character = function(current,font,char,factor,vfcommands,pos_h,pos_v,pos_r return 0, 0, 0 end - local width, height, depth + local width, height, depth, naturalwidth if current then --- width, height, depth = getwhd(current) --- factor = getexpansion(current) width, height, depth, factor = getwhd(current,true) + naturalwidth = width if factor ~= 0 then width = (1.0 + factor/1000000.0) * width end @@ -342,6 +339,7 @@ flush_character = function(current,font,char,factor,vfcommands,pos_h,pos_v,pos_r width = data.width or 0 height = data.height or 0 depth = data.depth or 0 + naturalwidth = width if not factor then factor = 0 end @@ -366,10 +364,10 @@ flush_character = function(current,font,char,factor,vfcommands,pos_h,pos_v,pos_r pos_v = pos_v + y end pushorientation(orientation,pos_h,pos_v) - flushcharacter(current,pos_h,pos_v,pos_r,font,char,data,factor,width,f,e) + flushcharacter(current,pos_h,pos_v,pos_r,font,char,data,factor,naturalwidth,f,e) poporientation(orientation,pos_h,pos_v) else - flushcharacter(current,pos_h,pos_v,pos_r,font,char,data,factor,width,f,e) + flushcharacter(current,pos_h,pos_v,pos_r,font,char,data,factor,naturalwidth,f,e) end end return width, height, depth @@ -551,10 +549,6 @@ local hlist_out, vlist_out do current = getlist(this_box) end - -- if synctex then - -- synctexhlist(this_box) - -- end - while current do local char, id = isglyph(current) if char then @@ -664,17 +658,9 @@ local hlist_out, vlist_out do cur_h = edge - 10 else cur_h = cur_h + gluewidth - -- if synctex then - -- synch_pos_with_cur(ref_h, ref_v, cur_h, cur_v) - -- synctexhorizontalruleorglue(p, this_box) - -- end end else cur_h = cur_h + gluewidth - -- if synctex then - -- synch_pos_with_cur(ref_h, ref_v, cur_h, cur_v) - -- synctexhorizontalruleorglue(p, this_box) - -- end end end elseif id == hlist_code or id == vlist_code then @@ -685,9 +671,11 @@ local hlist_out, vlist_out do if list then local shift, orientation = getshift(current) if not orientation then --- local width, height, depth, list, boxdir, shift, orientation = getall(current) --- if list then --- if not orientation then + -- + -- local width, height, depth, list, boxdir, shift, orientation = getall(current) + -- if list then + -- if not orientation then + -- local basepoint_h = boxdir ~= pos_r and width or 0 -- local basepoint_v = shift -- synch_pos_with_cur(ref_h,ref_v,cur_h + basepoint_h,shift) @@ -754,14 +742,6 @@ local hlist_out, vlist_out do end poporientation(orientation,pos_h,pos_v,pos_r) end - else - -- if synctex then - -- if id == vlist_code then - -- synctexvoidvlist(p,this_box) - -- else - -- synctexvoidhlist(p,this_box) - -- end - -- end end cur_h = cur_h + width elseif id == disc_code then @@ -773,11 +753,6 @@ local hlist_out, vlist_out do setfield(current,"replace") end elseif id == kern_code then - -- if synctex then - -- synctexkern(p, this_box) - -- end --- local kern = getkern(current) --- local factor = getexpansion(current) local kern, factor = getkern(current,true) if kern ~= 0 then if factor and factor ~= 0 then @@ -817,9 +792,6 @@ local hlist_out, vlist_out do cur_h = cur_h + width end elseif id == math_code then - -- if synctex then - -- synctexmath(p, this_box) - -- end local kern = getkern(current) if kern ~= 0 then cur_h = cur_h + kern @@ -904,9 +876,6 @@ local hlist_out, vlist_out do pos_v = ref_v - cur_v -- synced end - -- if synctex then - -- synctextsilh(this_box) - -- end pos_h = ref_h pos_v = ref_v pos_r = ref_r @@ -945,10 +914,6 @@ local hlist_out, vlist_out do current = getlist(this_box) end - -- if synctex then - -- synctexvlist(this_box) - -- end - -- while current do -- local id = getid(current) for current, id, subtype in nextnode, current do @@ -1111,15 +1076,6 @@ local hlist_out, vlist_out do end poporientation(orientation,pos_h,pos_v,pos_r) end - else - -- if synctex then - -- synch_pos_with_cur(ref_h, ref_v, cur_h, cur_v) - -- if id == vlist_code then - -- synctexvoidvlist(current, this_box) - -- else - -- synctexvoidhlist(current, this_box) - -- end - -- end end cur_v = cur_v + height + depth elseif id == kern_code then @@ -1180,9 +1136,6 @@ local hlist_out, vlist_out do pos_v = ref_v - cur_v -- synced end - -- if synctex then - -- synctextsilh(this_box) - -- end pos_h = ref_h pos_v = ref_v pos_r = ref_r @@ -1231,12 +1184,6 @@ function lpdf.convert(box,smode,objnum,specification) -- temp name shippingmode = smode - -- synctex = texget("synctex") - - -- if synctex then - -- synctexsheet(1000) - -- end - local width, height, depth = getwhd(box) local total = height + depth @@ -1336,10 +1283,6 @@ function lpdf.convert(box,smode,objnum,specification) -- temp name ::DONE:: - -- if synctex then - -- synctexteehs() - -- end - finalize(objnum,specification) shippingmode = "none" end diff --git a/tex/context/base/mkiv/font-ctx.lua b/tex/context/base/mkiv/font-ctx.lua index 6847a2b8d..0fd6c61af 100644 --- a/tex/context/base/mkiv/font-ctx.lua +++ b/tex/context/base/mkiv/font-ctx.lua @@ -87,8 +87,6 @@ local getprop = nuts.getprop local setprop = nuts.setprop local setsubtype = nuts.setsubtype -local texgetattribute = tex.getattribute -local texsetattribute = tex.setattribute local texgetdimen = tex.getdimen local texsetcount = tex.setcount local texget = tex.get @@ -2429,6 +2427,26 @@ to scale virtual characters.</p> do + -- can become luat-tex.lua + + local texsetglyphdata = tex.setglyphdata + local texgetglyphdata = tex.getglyphdata + + if not texsetglyphdata then + + local texsetattribute = tex.setattribute + local texgetattribute = tex.getattribute + + texsetglyphdata = function(n) return texsetattribute(0,n) end + texgetglyphdata = function() return texgetattribute(0) end + + tex.setglyphdata = texsetglyphdata + tex.getglyphdata = texgetglyphdata + + end + + -- till here + local setmacro = tokens.setters.macro function constructors.currentfonthasfeature(n) @@ -2452,6 +2470,63 @@ do local f_strip = formatters["%0.2fpt"] -- normally this value is changed only once local stripper = lpeg.patterns.stripzeros + local cache = { } + + local hows = { + ["+"] = "add", + ["-"] = "subtract", + ["="] = "replace", + } + + local function setfeature(how,parent,name,font) -- 0/1 test temporary for testing + if not how or how == 0 then + if trace_features and texgetglyphdata() ~= 0 then + report_cummulative("font %!font:name!, reset",fontdata[font or true]) + end + texsetglyphdata(0) + elseif how == true or how == 1 then + local hash = "feature > " .. parent + local done = cache[hash] + if trace_features and done then + report_cummulative("font %!font:name!, revive %a : %!font:features!",fontdata[font or true],parent,setups[numbers[done]]) + end + texsetglyphdata(done or 0) + else + local full = parent .. how .. name + local hash = "feature > " .. full + local done = cache[hash] + if not done then + local n = setups[full] + if n then + -- already defined + else + n = mergecontextfeatures(parent,name,how,full) + end + done = registercontextfeature(hash,full,how) + cache[hash] = done + if trace_features then + report_cummulative("font %!font:name!, %s %a : %!font:features!",fontdata[font or true],hows[how],full,setups[numbers[done]]) + end + end + texsetglyphdata(done) + end + end + + local function resetfeature() + if trace_features and texgetglyphdata() ~= 0 then + report_cummulative("font %!font:name!, reset",fontdata[true]) + end + texsetglyphdata(0) + end + + local function setfontfeature(tag) + texsetglyphdata(contextnumber(tag)) + end + + local function resetfontfeature() + texsetglyphdata(0) + end + implement { name = "nbfs", arguments = "dimen", @@ -2469,13 +2544,13 @@ do implement { name = "setfontfeature", arguments = "string", - actions = function(tag) texsetattribute(0,contextnumber(tag)) end + actions = setfontfeature, } implement { name = "resetfontfeature", arguments = { 0, 0 }, - actions = texsetattribute, + actions = resetfontfeature, } implement { @@ -2504,62 +2579,12 @@ do actions = function(name) ctx_doif(contextnumber(name) == 0) end, } - implement { name = "adaptfontfeature", arguments = "2 strings", actions = adaptcontext } - local cache = { } - - local hows = { - ["+"] = "add", - ["-"] = "subtract", - ["="] = "replace", - } - - local function setfeature(how,parent,name,font) -- 0/1 test temporary for testing - if not how or how == 0 then - if trace_features and texgetattribute(0) ~= 0 then - report_cummulative("font %!font:name!, reset",fontdata[font or true]) - end - texsetattribute(0,0) - elseif how == true or how == 1 then - local hash = "feature > " .. parent - local done = cache[hash] - if trace_features and done then - report_cummulative("font %!font:name!, revive %a : %!font:features!",fontdata[font or true],parent,setups[numbers[done]]) - end - texsetattribute(0,done or 0) - else - local full = parent .. how .. name - local hash = "feature > " .. full - local done = cache[hash] - if not done then - local n = setups[full] - if n then - -- already defined - else - n = mergecontextfeatures(parent,name,how,full) - end - done = registercontextfeature(hash,full,how) - cache[hash] = done - if trace_features then - report_cummulative("font %!font:name!, %s %a : %!font:features!",fontdata[font or true],hows[how],full,setups[numbers[done]]) - end - end - texsetattribute(0,done) - end - end - - local function resetfeature() - if trace_features and texgetattribute(0) ~= 0 then - report_cummulative("font %!font:name!, reset",fontdata[true]) - end - texsetattribute(0,0) - end - local function registerlanguagefeatures() local specifications = languages.data.specifications for i=1,#specifications do diff --git a/tex/context/base/mkiv/font-dsp.lua b/tex/context/base/mkiv/font-dsp.lua index f8bf6f2c8..3285c689c 100644 --- a/tex/context/base/mkiv/font-dsp.lua +++ b/tex/context/base/mkiv/font-dsp.lua @@ -1473,6 +1473,11 @@ end -- ValueFormat1 applies to the ValueRecord of the first glyph in each pair. ValueRecords for all first glyphs must use ValueFormat1. If ValueFormat1 is set to zero (0), the corresponding glyph has no ValueRecord and, therefore, should not be repositioned. -- ValueFormat2 applies to the ValueRecord of the second glyph in each pair. ValueRecords for all second glyphs must use ValueFormat2. If ValueFormat2 is set to null, then the second glyph of the pair is the “next” glyph for which a lookup should be performed. +-- local simple = { +-- [true] = { [true] = { true, true }, [false] = { true } }, +-- [false] = { [true] = { false, true }, [false] = { false } }, +-- } + function gposhandlers.pair(f,fontdata,lookupid,lookupoffset,offset,glyphs,nofglyphs) local tableoffset = lookupoffset + offset setposition(f,tableoffset) @@ -1520,6 +1525,7 @@ function gposhandlers.pair(f,fontdata,lookupid,lookupoffset,offset,glyphs,nofgly classdef1 = readclassdef(f,tableoffset+classdef1,coverage) classdef2 = readclassdef(f,tableoffset+classdef2,nofglyphs) local usedcoverage = { } +local shared = { } -- partial sparse for g1, c1 in next, classdef1 do if coverage[g1] then local l1 = classlist[c1] @@ -1531,7 +1537,18 @@ function gposhandlers.pair(f,fontdata,lookupid,lookupoffset,offset,glyphs,nofgly local first = offsets[1] local second = offsets[2] if first or second then - hash[paired] = { first, second or nil } +local s1 = shared[first] +if not s1 then + s1 = { } + shared[first] = s1 +end +local s2 = s1[second] +if not s2 then + s2 = { first, second or nil } + s1[second] = s2 +end +hash[paired] = s2 +-- hash[paired] = { first, second or nil } else -- upto the next lookup for this combination end diff --git a/tex/context/base/mkiv/font-fea.mkvi b/tex/context/base/mkiv/font-fea.mkvi index 4a5356090..9c4b60d9f 100644 --- a/tex/context/base/mkiv/font-fea.mkvi +++ b/tex/context/base/mkiv/font-fea.mkvi @@ -137,11 +137,28 @@ \def\font_basics_features_list[#name][#separator]% todo: arg voor type {\clf_featurelist{#name}{\detokenize{#separator}}} -\attribute\zerocount\zerocount % first in list, so fast match +\ifcase\contextlmtxmode -\prependtoks - \attribute\zerocount\attributeunsetvalue % new per 2017-08-30 -\to \t_attr_list_local + \attribute\zerocount\zerocount % first in list, so fast match + + \prependtoks + \attribute\zerocount\attributeunsetvalue % new per 2017-08-30 / why not zero + \to \t_attr_list_local + + \def\font_dynamic_value{\attribute\zerocount} + +\else + + \glyphdatafield\zerocount + \attribute\zerocount\attributeunsetvalue + + \prependtoks + \glyphdatafield\attributeunsetvalue % why not zero + \to \t_attr_list_local + + \let\font_dynamic_value\glyphdatafield + +\fi % beware: these are global features on top of existing font features diff --git a/tex/context/base/mkiv/font-ini.mkvi b/tex/context/base/mkiv/font-ini.mkvi index dd8a5f148..4ebbff88e 100644 --- a/tex/context/base/mkiv/font-ini.mkvi +++ b/tex/context/base/mkiv/font-ini.mkvi @@ -327,6 +327,16 @@ \fontemwidth \nullfont 786432\scaledpoint \fontextraspace \nullfont 85459\scaledpoint +\appendtoks + \fontslantperpoint \nullfont 0\scaledpoint + \fontinterwordspace \nullfont 256377\scaledpoint + \fontinterwordstretch\nullfont 128188\scaledpoint + \fontinterwordshrink \nullfont 85459\scaledpoint + \fontexheight \nullfont 338952\scaledpoint + \fontemwidth \nullfont 786432\scaledpoint + \fontextraspace \nullfont 85459\scaledpoint +\to \everyjob + %D Tracing \newtoks\t_font_tracers_definitions diff --git a/tex/context/base/mkiv/font-otr.lua b/tex/context/base/mkiv/font-otr.lua index e851c3157..4ac737697 100644 --- a/tex/context/base/mkiv/font-otr.lua +++ b/tex/context/base/mkiv/font-otr.lua @@ -2073,9 +2073,7 @@ end local function readtable(tag,f,fontdata,specification,...) local reader = readers[tag] if reader then - -- local t = os.clock() reader(f,fontdata,specification,...) - -- report("reading table %a took %0.4f seconds",tag,os.clock()-t) end end diff --git a/tex/context/base/mkiv/font-ots.lua b/tex/context/base/mkiv/font-ots.lua index b9f719a5f..09351b1f1 100644 --- a/tex/context/base/mkiv/font-ots.lua +++ b/tex/context/base/mkiv/font-ots.lua @@ -185,8 +185,6 @@ local setprev = nuts.setprev local getboth = nuts.getboth local setboth = nuts.setboth local getid = nuts.getid -local getattr = nuts.getattr -local setattr = nuts.setattr local getprop = nuts.getprop local setprop = nuts.setprop local getsubtype = nuts.getsubtype @@ -199,6 +197,9 @@ local setlink = nuts.setlink local getcomponents = nuts.getcomponents -- the original one, not yet node-aux local setcomponents = nuts.setcomponents -- the original one, not yet node-aux local getwidth = nuts.getwidth +local getattr = nuts.getattr + +local getglyphdata = nuts.getglyphdata local ischar = nuts.is_char local isglyph = nuts.isglyph @@ -3291,7 +3292,7 @@ end -- discretionaries (maybe we need to tag those some day). So, at least for now, we don't -- have the following test in the sub runs: -- --- -- local a = getattr(start,0) +-- -- local a = getglyhpdata(start) -- -- if a then -- -- a = (a == attr) and (not attribute or getprop(start,a_state) == attribute) -- -- else @@ -3301,7 +3302,7 @@ end -- -- but use this instead: -- --- -- local a = getattr(start,0) +-- -- local a = getglyphdata(start) -- -- if not a or (a == attr) then -- -- and even that one is probably not needed. However, we can handle interesting @@ -3327,7 +3328,7 @@ local function c_run_single(head,font,attr,lookupcache,step,dataset,sequence,rlm if char then local a -- happens often so no assignment is faster if attr then - a = getattr(start,0) + a = getglyphdata(start) end if not a or (a == attr) then local lookupmatch = lookupcache[char] @@ -3367,7 +3368,7 @@ local function t_run_single(start,stop,font,attr,lookupcache) if char then local a -- happens often so no assignment is faster if attr then - a = getattr(start,0) + a = getglyphdata(start) end local startnext = getnext(start) if not a or (a == attr) then @@ -3451,7 +3452,7 @@ end local function k_run_single(sub,injection,last,font,attr,lookupcache,step,dataset,sequence,rlmode,skiphash,handler) local a -- happens often so no assignment is faster if attr then - a = getattr(sub,0) + a = getglyphdata(sub) end if not a or (a == attr) then for n in nextnode, sub do -- only gpos @@ -3487,7 +3488,7 @@ local function c_run_multiple(head,font,attr,steps,nofsteps,dataset,sequence,rlm if char then local a -- happens often so no assignment is faster if attr then - a = getattr(start,0) + a = getglyphdata(start) end if not a or (a == attr) then for i=1,nofsteps do @@ -3535,7 +3536,7 @@ local function t_run_multiple(start,stop,font,attr,steps,nofsteps) if char then local a -- happens often so no assignment is faster if attr then - a = getattr(start,0) + a = getglyphdata(start) end local startnext = getnext(start) if not a or (a == attr) then @@ -3616,7 +3617,7 @@ end local function k_run_multiple(sub,injection,last,font,attr,steps,nofsteps,dataset,sequence,rlmode,skiphash,handler) local a -- happens often so no assignment is faster if attr then - a = getattr(sub,0) + a = getglyphdata(sub) end if not a or (a == attr) then for n in nextnode, sub do -- only gpos @@ -3709,7 +3710,7 @@ do -- reference: -- - -- local a = attr and getattr(start,0) + -- local a = attr and getglyphdata(start) -- if a then -- a = (a == attr) and (not attribute or getprop(start,a_state) == attribute) -- else @@ -3720,7 +3721,7 @@ do -- -- local a -- happens often so no assignment is faster -- if attr then - -- if getattr(start,0) == attr and (not attribute or getprop(start,a_state) == attribute) then + -- if getglyphdata(start) == attr and (not attribute or getprop(start,a_state) == attribute) then -- a = true -- end -- elseif not attribute or getprop(start,a_state) == attribute then @@ -3860,7 +3861,7 @@ do if m then local a -- happens often so no assignment is faster if attr then - a = getattr(start,0) + a = getglyphdata(start) end if not a or (a == attr) then for i=m[1],m[2] do @@ -3907,7 +3908,7 @@ do if lookupmatch then local a -- happens often so no assignment is faster if attr then - if getattr(start,0) == attr and (not attribute or getprop(start,a_state) == attribute) then + if getglyphdata(start) == attr and (not attribute or getprop(start,a_state) == attribute) then a = true end elseif not attribute or getprop(start,a_state) == attribute then @@ -3974,7 +3975,7 @@ do if m then local a -- happens often so no assignment is faster if attr then - if getattr(start,0) == attr and (not attribute or getprop(start,a_state) == attribute) then + if getglyphdata(start) == attr and (not attribute or getprop(start,a_state) == attribute) then a = true end elseif not attribute or getprop(start,a_state) == attribute then diff --git a/tex/context/base/mkiv/font-tfm.lua b/tex/context/base/mkiv/font-tfm.lua index 6e4f86980..5fdae5990 100644 --- a/tex/context/base/mkiv/font-tfm.lua +++ b/tex/context/base/mkiv/font-tfm.lua @@ -6,6 +6,8 @@ if not modules then modules = { } end modules ['font-tfm'] = { license = "see context related readme files" } +if not context then return end -- use luatex-fonts-tfm.lua instead + local next, type = next, type local match, format = string.match, string.format local concat, sortedhash = table.concat, table.sortedhash @@ -118,266 +120,201 @@ local depth = { } -- table.setmetatableindex("number") -- -- So "czechdqcheat=yes" is then a valid feature. And yes, it's a cheat. -local read_from_tfm, check_tfm do - - local tfmreaders = context and tfm.readers - local loadtfmvf = tfmreaders and tfmreaders.loadtfmvf - local loadtfm = font.read_tfm - local loadvf = font.read_vf +local loadtfmvf = tfm.readers.loadtfmvf - directives.register("fonts.tfm.builtin",function(v) - loadtfmvf = tfmreaders and tfmreaders.loadtfmvf - if v and loadtfm then - loadtfmvf = false - end - end) +local function read_from_tfm(specification) + local filename = specification.filename + local size = specification.size + depth[filename] = (depth[filename] or 0) + 1 + if trace_defining then + report_defining("loading tfm file %a at size %s",filename,size) + end + local tfmdata = loadtfmvf(filename,size) + if tfmdata then - read_from_tfm = function(specification) - local filename = specification.filename - local size = specification.size - depth[filename] = (depth[filename] or 0) + 1 - if trace_defining then - report_defining("loading tfm file %a at size %s",filename,size) - end - local tfmdata -- not cached, fast enough - if loadtfmvf then - tfmdata = loadtfmvf(filename,size) - else - tfmdata = loadtfm(filename,size) - end - if tfmdata then + local features = specification.features and specification.features.normal or { } + local features = constructors.checkedfeatures("tfm",features) + specification.features.normal = features - local features = specification.features and specification.features.normal or { } - local features = constructors.checkedfeatures("tfm",features) - specification.features.normal = features + -- If reencode returns a new table, we assume that we're doing something + -- special. An 'auto' reencode picks up its vector from the pfb file. - -- If reencode returns a new table, we assume that we're doing something - -- special. An 'auto' reencode picks up its vector from the pfb file. + local newtfmdata = (depth[filename] == 1) and tfm.reencode(tfmdata,specification) + if newtfmdata then + tfmdata = newtfmdata + end - local newtfmdata = (depth[filename] == 1) and tfm.reencode(tfmdata,specification) - if newtfmdata then - tfmdata = newtfmdata + local resources = tfmdata.resources or { } + local properties = tfmdata.properties or { } + local parameters = tfmdata.parameters or { } + local shared = tfmdata.shared or { } + -- + shared.features = features + shared.resources = resources + -- + properties.name = tfmdata.name -- todo: fallback + properties.fontname = tfmdata.fontname -- todo: fallback + properties.psname = tfmdata.psname -- todo: fallback + properties.fullname = tfmdata.fullname -- todo: fallback + properties.filename = specification.filename -- todo: fallback + properties.format = tfmdata.format or fonts.formats.tfm -- better than nothing + properties.usedbitmap = tfmdata.usedbitmap + -- + tfmdata.properties = properties + tfmdata.resources = resources + tfmdata.parameters = parameters + tfmdata.shared = shared + -- + shared.rawdata = { resources = resources } + shared.features = features + -- + -- The next branch is only entered when we have a proper encoded file i.e. + -- unicodes and such. It really nakes no sense to do feature juggling when + -- we have no names and unicodes. + -- + if newtfmdata then + -- + -- Some opentype processing assumes these to be present: + -- + if not resources.marks then + resources.marks = { } + end + if not resources.sequences then + resources.sequences = { } + end + if not resources.features then + resources.features = { + gsub = { }, + gpos = { }, + } + end + if not tfmdata.changed then + tfmdata.changed = { } + end + if not tfmdata.descriptions then + tfmdata.descriptions = tfmdata.characters end - - local resources = tfmdata.resources or { } - local properties = tfmdata.properties or { } - local parameters = tfmdata.parameters or { } - local shared = tfmdata.shared or { } -- - shared.features = features - shared.resources = resources + -- It might be handy to have this: -- - properties.name = tfmdata.name -- todo: fallback - properties.fontname = tfmdata.fontname -- todo: fallback - properties.psname = tfmdata.psname -- todo: fallback - properties.fullname = tfmdata.fullname -- todo: fallback - properties.filename = specification.filename -- todo: fallback - properties.format = tfmdata.format or fonts.formats.tfm -- better than nothing - properties.usedbitmap = tfmdata.usedbitmap + otf.readers.addunicodetable(tfmdata) -- - tfmdata.properties = properties - tfmdata.resources = resources - tfmdata.parameters = parameters - tfmdata.shared = shared + -- We make a pseudo opentype font, e.g. kerns and ligatures etc: -- - shared.rawdata = { resources = resources } - shared.features = features + tfmenhancers.apply(tfmdata,filename) -- - -- The next branch is only entered when we have a proper encoded file i.e. - -- unicodes and such. It really nakes no sense to do feature juggling when - -- we have no names and unicodes. + -- Now user stuff can kick in. -- - if newtfmdata then - -- - -- Some opentype processing assumes these to be present: - -- - if not resources.marks then - resources.marks = { } - end - if not resources.sequences then - resources.sequences = { } - end - if not resources.features then - resources.features = { - gsub = { }, - gpos = { }, - } - end - if not tfmdata.changed then - tfmdata.changed = { } - end - if not tfmdata.descriptions then - tfmdata.descriptions = tfmdata.characters - end - -- - -- It might be handy to have this: - -- - otf.readers.addunicodetable(tfmdata) - -- - -- We make a pseudo opentype font, e.g. kerns and ligatures etc: - -- - tfmenhancers.apply(tfmdata,filename) - -- - -- Now user stuff can kick in. - -- - constructors.applymanipulators("tfm",tfmdata,features,trace_features,report_tfm) - -- - -- As that can also mess with names and such, we are now ready for finalizing - -- the unicode information. This is a different order that for instance type one - -- (afm) files. First we try to deduce unicodes from already present information. - -- - otf.readers.unifymissing(tfmdata) - -- - -- Next we fill in the gaps, based on names from teh agl. Probably not much will - -- happen here. - -- - fonts.mappings.addtounicode(tfmdata,filename) - -- - -- The tounicode data is passed to the backend that constructs the vectors for us. - -- - tfmdata.tounicode = 1 - local tounicode = fonts.mappings.tounicode - for unicode, v in next, tfmdata.characters do - local u = v.unicode - if u then - v.tounicode = tounicode(u) - end - end - -- - -- However, when we use a bitmap font those vectors can't be constructed because - -- that information is not carried with those fonts (there is no name info, nor - -- proper index info, nor unicodes at that end). So, we provide it ourselves. - -- - if tfmdata.usedbitmap then - tfm.addtounicode(tfmdata) - end - end + constructors.applymanipulators("tfm",tfmdata,features,trace_features,report_tfm) -- - shared.processes = next(features) and tfm.setfeatures(tfmdata,features) or nil + -- As that can also mess with names and such, we are now ready for finalizing + -- the unicode information. This is a different order that for instance type one + -- (afm) files. First we try to deduce unicodes from already present information. -- - if size < 0 then - size = idiv(65536 * -size,100) - end - parameters.factor = 1 -- already scaled - parameters.units = 1000 -- just in case - parameters.size = size - parameters.slant = parameters.slant or parameters[1] or 0 - parameters.space = parameters.space or parameters[2] or 0 - parameters.space_stretch = parameters.space_stretch or parameters[3] or 0 - parameters.space_shrink = parameters.space_shrink or parameters[4] or 0 - parameters.x_height = parameters.x_height or parameters[5] or 0 - parameters.quad = parameters.quad or parameters[6] or 0 - parameters.extra_space = parameters.extra_space or parameters[7] or 0 + otf.readers.unifymissing(tfmdata) -- - constructors.enhanceparameters(parameters) -- official copies for us + -- Next we fill in the gaps, based on names from teh agl. Probably not much will + -- happen here. -- - properties.private = properties.private or tfmdata.private or privateoffset + fonts.mappings.addtounicode(tfmdata,filename) -- - if newtfmdata then - -- - -- We do nothing as we assume flat tfm files. It would become real messy - -- otherwise and I don't have something for testing on my system anyway. - -- - elseif loadtfmvf then - -- already loaded - local fonts = tfmdata.fonts - if fonts then - for i=1,#fonts do - local font = fonts[i] - local id = font.id - if not id then - local name = font.name - local size = font.size - if name and size then - local data, id = constructors.readanddefine(name,size) - if id then - font.id = id - font.name = nil - font.size = nil - end - end - end - end - end - elseif constructors.resolvevirtualtoo then - fonts.loggers.register(tfmdata,file.suffix(filename),specification) -- strange, why here - local vfname = findbinfile(specification.name, 'ovf') - if vfname and vfname ~= "" then - local vfdata = loadvf(vfname,size) - if vfdata then - local chars = tfmdata.characters - for k,v in next, vfdata.characters do - chars[k].commands = v.commands - end - properties.virtualized = true - tfmdata.fonts = vfdata.fonts - tfmdata.type = "virtual" -- else nested calls with cummulative scaling - local fontlist = vfdata.fonts - local name = file.nameonly(filename) - for i=1,#fontlist do - local n = fontlist[i].name - local s = fontlist[i].size - local d = depth[filename] - s = constructors.scaled(s,vfdata.designsize) - if d > tfm.maxnestingdepth then - report_defining("too deeply nested virtual font %a with size %a, max nesting depth %s",n,s,tfm.maxnestingdepth) - fontlist[i] = { id = 0 } - elseif (d > 1) and (s > tfm.maxnestingsize) then - report_defining("virtual font %a exceeds size %s",n,s) - fontlist[i] = { id = 0 } - else - local t, id = constructors.readanddefine(n,s) - fontlist[i] = { id = id } - end - end - end + -- The tounicode data is passed to the backend that constructs the vectors for us. + -- + tfmdata.tounicode = 1 + local tounicode = fonts.mappings.tounicode + for unicode, v in next, tfmdata.characters do + local u = v.unicode + if u then + v.tounicode = tounicode(u) end end -- - -- This is for old times sake (and context specific) so we comment it. It has - -- to do with encoding prefixes (a context naming that was later adopted by - -- the lm/gyre project) - -- - -- if not features.encoding then - -- local encoding, filename = match(properties.filename,"^(.-)%-(.*)$") - -- if filename and encoding and encodings.known and encodings.known[encoding] then - -- features.encoding = encoding - -- end - -- end - -- - -- Some afterthoughts: + -- However, when we use a bitmap font those vectors can't be constructed because + -- that information is not carried with those fonts (there is no name info, nor + -- proper index info, nor unicodes at that end). So, we provide it ourselves. -- - properties.haskerns = true - properties.hasligatures = true - properties.hasitalics = true - resources.unicodes = { } - resources.lookuptags = { } + if tfmdata.usedbitmap then + tfm.addtounicode(tfmdata) + end + end + -- + shared.processes = next(features) and tfm.setfeatures(tfmdata,features) or nil + -- + if size < 0 then + size = idiv(65536 * -size,100) + end + parameters.factor = 1 -- already scaled + parameters.units = 1000 -- just in case + parameters.size = size + parameters.slant = parameters.slant or parameters[1] or 0 + parameters.space = parameters.space or parameters[2] or 0 + parameters.space_stretch = parameters.space_stretch or parameters[3] or 0 + parameters.space_shrink = parameters.space_shrink or parameters[4] or 0 + parameters.x_height = parameters.x_height or parameters[5] or 0 + parameters.quad = parameters.quad or parameters[6] or 0 + parameters.extra_space = parameters.extra_space or parameters[7] or 0 + -- + constructors.enhanceparameters(parameters) -- official copies for us + -- + properties.private = properties.private or tfmdata.private or privateoffset + -- + if newtfmdata then -- - depth[filename] = depth[filename] - 1 + -- We do nothing as we assume flat tfm files. It would become real messy + -- otherwise and I don't have something for testing on my system anyway. -- - return tfmdata else - depth[filename] = depth[filename] - 1 + -- already loaded + local fonts = tfmdata.fonts + if fonts then + for i=1,#fonts do + local font = fonts[i] + local id = font.id + if not id then + local name = font.name + local size = font.size + if name and size then + local data, id = constructors.readanddefine(name,size) + if id then + font.id = id + font.name = nil + font.size = nil + end + end + end + end + end end + -- + properties.haskerns = true + properties.hasligatures = true + properties.hasitalics = true + resources.unicodes = { } + resources.lookuptags = { } + -- + depth[filename] = depth[filename] - 1 + -- + return tfmdata + else + depth[filename] = depth[filename] - 1 end +end - check_tfm = function(specification,fullname) -- we could split up like afm/otf - local foundname = findbinfile(fullname, 'tfm') or "" - if foundname == "" then - foundname = findbinfile(fullname, 'ofm') or "" -- not needed in context - end - if foundname == "" then - foundname = fonts.names.getfilename(fullname,"tfm") or "" - end - if foundname ~= "" then - specification.filename = foundname - specification.format = "ofm" - return read_from_tfm(specification) - elseif trace_defining then - report_defining("loading tfm with name %a fails",specification.name) - end +local function check_tfm(specification,fullname) -- we could split up like afm/otf + local foundname = findbinfile(fullname, 'tfm') or "" + if foundname == "" then + foundname = findbinfile(fullname, 'ofm') or "" -- not needed in context + end + if foundname == "" then + foundname = fonts.names.getfilename(fullname,"tfm") or "" + end + if foundname ~= "" then + specification.filename = foundname + specification.format = "ofm" + return read_from_tfm(specification) + elseif trace_defining then + report_defining("loading tfm with name %a fails",specification.name) end - end readers.check_tfm = check_tfm @@ -575,68 +512,6 @@ do end --- This code adds a ToUnicode vector for bitmap fonts. We don't bother about --- ranges because we have small fonts. it works ok with acrobat but fails with --- the other viewers (they get confused by the bitmaps I guess). - -do - - local template = [[ -/CIDInit /ProcSet findresource begin - 12 dict begin - begincmap - /CIDSystemInfo << /Registry (TeX) /Ordering (bitmap-%s) /Supplement 0 >> def - /CMapName /TeX-bitmap-%s def - /CMapType 2 def - 1 begincodespacerange - <00> <FF> - endcodespacerange - %s beginbfchar -%s - endbfchar - endcmap -CMapName currentdict /CMap defineresource pop end -end -end -]] - - local flushstreamobject = lpdf and lpdf.flushstreamobject -- context - local setfontattributes = lpdf and lpdf.setfontattributes -- context - - if not flushstreamobject then - flushstreamobject = function(data) - return pdf.obj { immediate = true, type = "stream", string = data } -- generic - end - end - - if not setfontattributes then - setfontattributes = function(id,data) - return pdf.setfontattributes(id,data) -- generic - end - end - - function tfm.addtounicode(tfmdata) - local id = tfmdata.usedbitmap - local map = { } - local char = { } -- no need for range, hardly used - for k, v in next, tfmdata.characters do - local index = v.oindex - local tounicode = v.tounicode - if index and tounicode then - map[index] = tounicode - end - end - for k, v in sortedhash(map) do - char[#char+1] = format("<%02X> <%s>",k,v) - end - char = concat(char,"\n") - local stream = format(template,id,id,#char,char) - local reference = flushstreamobject(stream,nil,true) - setfontattributes(id,format("/ToUnicode %i 0 R",reference)) - end - -end - -- Now we implement the regular features handlers. We need to convert the -- tfm specific structures to opentype structures. In basemode they are -- converted back so that is a bit of a waste but it's fast enough. diff --git a/tex/context/base/mkiv/grph-chk.lua b/tex/context/base/mkiv/grph-chk.lua index 6356755aa..fedd8d3ca 100644 --- a/tex/context/base/mkiv/grph-chk.lua +++ b/tex/context/base/mkiv/grph-chk.lua @@ -27,7 +27,7 @@ local placeholder = graphics.bitmaps.placeholder -- but opens up some possibilities (like merging fonts) that I will look into some -- day. -local function pdf_checker(data) +function checkers.pdf(data) local request = data.request local used = data.used if request and used and not request.scanimage then @@ -130,7 +130,7 @@ local function wrappedidentify(identify,filename) end end -local function jpg_checker(data) +function checkers.jpg(data) local request = data.request local used = data.used if request and used and not request.scanimage then @@ -166,7 +166,7 @@ local function jpg_checker(data) return checkers.generic(data) end -local function jp2_checker(data) -- idem as jpg +function checkers.jp2(data) -- idem as jpg local request = data.request local used = data.used if request and used and not request.scanimage then @@ -202,7 +202,7 @@ local function jp2_checker(data) -- idem as jpg return checkers.generic(data) end -local function png_checker(data) -- same as jpg (for now) +function checkers.png(data) -- same as jpg (for now) local request = data.request local used = data.used if request and used and not request.scanimage then @@ -247,30 +247,3 @@ local function png_checker(data) -- same as jpg (for now) end return checkers.generic(data) end - - -if CONTEXTLMTXMODE then - - checkers.pdf = pdf_checker - checkers.jpg = jpg_checker - checkers.jp2 = jp2_checker - checkers.png = png_checker - -else - - -- yes or no ... - - directives.register("graphics.pdf.uselua",function(v) - checkers.pdf = v and pdf_checker or nil - report("%s Lua based PDF inclusion",v and "enabling" or "disabling") - end) - - -- directives.register("graphics.uselua",function(v) - -- checkers.pdf = v and pdf_checker or nil - -- checkers.jpg = v and jpg_checker or nil - -- checkers.jp2 = v and jp2_checker or nil - -- checkers.png = v and png_checker or nil - -- -- report("%s Lua based PDF, PNG, JPG and JP2 inclusion",v and "enabling" or "disabling") - -- end) - -end diff --git a/tex/context/base/mkiv/lang-lab.mkiv b/tex/context/base/mkiv/lang-lab.mkiv index 9d73d96e5..f03d9af3a 100644 --- a/tex/context/base/mkiv/lang-lab.mkiv +++ b/tex/context/base/mkiv/lang-lab.mkiv @@ -350,7 +350,7 @@ \unexpanded\def\assigntranslation[#1]\to#2% bad, this \to {\getparameters[\??translation][#1]% - \edef#2{\csname\??translation\currentlanguage\endcsname}} + \edef#2{\begincsname\??translation\currentlanguage\endcsname}} %D \macros %D {commalistsentence} diff --git a/tex/context/base/mkiv/lpdf-emb.lua b/tex/context/base/mkiv/lpdf-emb.lua index 27fb2dc9a..0f5d14cf1 100644 --- a/tex/context/base/mkiv/lpdf-emb.lua +++ b/tex/context/base/mkiv/lpdf-emb.lua @@ -1146,13 +1146,6 @@ do local stdhw = cffinfo.stdhw local stdvw = cffinfo.stdvw -- --- bluescale = 0.039625 --- blueshift = 7 --- bluefuzz = 1 --- defaultwidth = 500 --- nominalwidth = 696 --- stdhw = { 28, 36, 42, 48, 60 } --- stdvw = { 40, 60, 66, 72, 76, 80, 88, 94 } if defaultwidth == 0 then defaultwidth = nil end if nomimalwidth == 0 then nominalwidth = nil end if bluevalues then bluevalues = todictarray(bluevalues) end @@ -1162,10 +1155,8 @@ do if bluescale then bluescale = todictnumber(bluescale) end if blueshift then blueshift = todictnumber(blueshift) end if bluefuzz then bluefuzz = todictnumber(bluefuzz) end --- if stdhw then stdhw = todictarray(stdhw) end --- if stdvw then stdvw = todictarray(stdvw) end -if stdhw then stdhw = todictdeltas(stdhw) end -if stdvw then stdvw = todictdeltas(stdvw) end + if stdhw then stdhw = todictdeltas(stdhw) end + if stdvw then stdvw = todictdeltas(stdvw) end -- local fontversion = todictstring(fontfile,fontheader.fontversion or "uknown version") local familyname = todictstring(fontfile,cffinfo.familyname or names.family or basefontname) diff --git a/tex/context/base/mkiv/lpdf-img.lua b/tex/context/base/mkiv/lpdf-img.lua index aa91f9f22..ff89ad322 100644 --- a/tex/context/base/mkiv/lpdf-img.lua +++ b/tex/context/base/mkiv/lpdf-img.lua @@ -169,10 +169,10 @@ do -- The amount of code is larger that I like and looks somewhat redundant but we sort of -- optimize a few combinations that happen often. - local pngapplyfilter = pnge and pnge.applyfilter - local pngsplitmask = pnge and pnge.splitmask - local pnginterlace = pnge and pnge.interlace - local pngexpand = pnge and pnge.expand + local pngapplyfilter = pngdecode.applyfilter + local pngsplitmask = pngdecode.splitmask + local pnginterlace = pngdecode.interlace + local pngexpand = pngdecode.expand local filtermask, decodemask, decodestrip, transpose, expand diff --git a/tex/context/base/mkiv/lpdf-nod.lua b/tex/context/base/mkiv/lpdf-nod.lua index 8bcf18c62..db99f0e5d 100644 --- a/tex/context/base/mkiv/lpdf-nod.lua +++ b/tex/context/base/mkiv/lpdf-nod.lua @@ -6,7 +6,7 @@ if not modules then modules = { } end modules ['lpdf-nod'] = { license = "see context related readme files" } -if CONTEXTLMTXMODE > 1 then +if CONTEXTLMTXMODE > 0 then return end diff --git a/tex/context/base/mkiv/luat-bwc.lua b/tex/context/base/mkiv/luat-bwc.lua index 993de7bf3..a86514fa8 100644 --- a/tex/context/base/mkiv/luat-bwc.lua +++ b/tex/context/base/mkiv/luat-bwc.lua @@ -8,25 +8,25 @@ if not modules then modules = { } end modules ['luat-bwc'] = { -- backward compatibility -if not tex.wd then - - local box = tex.box - - local wd = { } setmetatable(wd, { - __index = function(t,k) local bk = box[k] return bk and bk.width or 0 end, - __newindex = function(t,k,v) local bk = box[k] if bk then bk.width = v end end, - } ) - - local ht = { } setmetatable(ht, { - __index = function(t,k) local bk = box[k] return bk and bk.height or 0 end, - __newindex = function(t,k,v) local bk = box[k] if bk then bk.height = v end end, - } ) - - local dp = { } setmetatable(dp, { - __index = function(t,k) local bk = box[k] return bk and bk.depth or 0 end, - __newindex = function(t,k,v) local bk = box[k] if bk then bk.depth = v end end, - } ) - - -- tex.wd, tex.ht, tex.dp = wd, ht, dp - -end +-- if not tex.wd then +-- +-- local box = tex.box +-- +-- local wd = { } setmetatable(wd, { +-- __index = function(t,k) local bk = box[k] return bk and bk.width or 0 end, +-- __newindex = function(t,k,v) local bk = box[k] if bk then bk.width = v end end, +-- } ) +-- +-- local ht = { } setmetatable(ht, { +-- __index = function(t,k) local bk = box[k] return bk and bk.height or 0 end, +-- __newindex = function(t,k,v) local bk = box[k] if bk then bk.height = v end end, +-- } ) +-- +-- local dp = { } setmetatable(dp, { +-- __index = function(t,k) local bk = box[k] return bk and bk.depth or 0 end, +-- __newindex = function(t,k,v) local bk = box[k] if bk then bk.depth = v end end, +-- } ) +-- +-- tex.wd, tex.ht, tex.dp = wd, ht, dp +-- +-- end diff --git a/tex/context/base/mkiv/luat-cnf.lua b/tex/context/base/mkiv/luat-cnf.lua index 5e3f026e9..c8aa0423b 100644 --- a/tex/context/base/mkiv/luat-cnf.lua +++ b/tex/context/base/mkiv/luat-cnf.lua @@ -218,7 +218,9 @@ local function makestub() t[#t+1] = format("texconfig.%s=%s",v,tv) end end - io.savedata(name,format("%s\n\n%s",concat(t,"\n"),format(stub,firsttable,tostring(CONTEXTLMTXMODE) or 0))) + t[#t+1] = "" + t[#t+1] = format(stub,firsttable,tostring(CONTEXTLMTXMODE or 0)) + io.savedata(name,concat(t,"\n")) logs.newline() end diff --git a/tex/context/base/mkiv/luat-cod.lua b/tex/context/base/mkiv/luat-cod.lua index c667f3ecc..0658fca1e 100644 --- a/tex/context/base/mkiv/luat-cod.lua +++ b/tex/context/base/mkiv/luat-cod.lua @@ -136,7 +136,7 @@ if LUATEXENGINE == nil then or (find(status.banner,"LuajitTeX",1,true) and "luajittex" or "luatex") end -if LUATEXVERION == nil then +if LUATEXVERSION == nil then LUATEXVERSION = status.luatex_revision LUATEXVERSION = status.luatex_version/100 -- + tonumber(LUATEXVERSION)/1000 @@ -144,15 +144,7 @@ if LUATEXVERION == nil then end if CONTEXTLMTXMODE == nil then - if status.obj_ptr == nil then - CONTEXTLMTXMODE = 2 - else - CONTEXTLMTXMODE = 0 - for i=1,#arg do if arg[i] == "--c:lmtx" then - CONTEXTLMTXMODE, pdf, img = 1, nil, nil - break - end end - end + CONTEXTLMTXMODE = LUATEXENGINE == "luametatex" and 1 or 0 end if LUATEXFUNCTIONALITY == nil then diff --git a/tex/context/base/mkiv/luat-ini.lua b/tex/context/base/mkiv/luat-ini.lua index ffd402c77..3d6df530e 100644 --- a/tex/context/base/mkiv/luat-ini.lua +++ b/tex/context/base/mkiv/luat-ini.lua @@ -37,7 +37,7 @@ JITSUPPORTED = LUATEXENGINE == "luajittex" or jit INITEXMODE = status.ini_version -CONTEXTLMTXMODE = CONTEXTLMTXMODE or (status.obj_ptr == nil and 2 or 1) +CONTEXTLMTXMODE = CONTEXTLMTXMODE or (LUATEXENGINE == "luametatex" and 1) or 0 function os.setlocale() -- no need for a message diff --git a/tex/context/base/mkiv/luat-lib.mkiv b/tex/context/base/mkiv/luat-lib.mkiv index 666032369..381a60e42 100644 --- a/tex/context/base/mkiv/luat-lib.mkiv +++ b/tex/context/base/mkiv/luat-lib.mkiv @@ -95,7 +95,7 @@ \registerctxluafile{luat-env}{} \registerctxluafile{luat-exe}{} % simplified \registerctxluafile{luat-iop}{} % simplified -\registerctxluafile{luat-bwc}{} +%registerctxluafile{luat-bwc}{} \registerctxluafile{trac-lmx}{} % might become l-lmx or luat-lmx \registerctxluafile{luat-mac}{} %registerctxluafile{luat-prp}{} % for the moment of not much use diff --git a/tex/context/base/mkiv/luat-run.lua b/tex/context/base/mkiv/luat-run.lua index ed4d5f5e7..3ec0e131f 100644 --- a/tex/context/base/mkiv/luat-run.lua +++ b/tex/context/base/mkiv/luat-run.lua @@ -7,7 +7,7 @@ if not modules then modules = { } end modules ['luat-run'] = { } local next = next -local format, find = string.format, string.find +local find = string.find local insert, remove = table.insert, table.remove local osexit = os.exit @@ -225,7 +225,8 @@ end luatex.registerstopactions(luatex.cleanuptempfiles) --- filenames +-- Reporting filenames has been simplified since lmtx because we don't need the +-- traditional () {} <> etc methods (read: that directive option was never chosen). local report_open = logs.reporter("open source") local report_close = logs.reporter("close source") @@ -236,13 +237,15 @@ local register = callbacks.register local level = 0 local total = 0 local stack = { } -local all = false function luatex.currentfile() return stack[#stack] or tex.jobname end -local function report_start(name) +local function report_start(name,rest) + if rest then + name = rest -- luatex + end if find(name,"virtual://",1,true) then insert(stack,false) else @@ -265,39 +268,6 @@ local function report_stop() end end -if CONTEXTLMTXMODE < 2 then - - local types = { - "data", - "font map", - "image", - "font subset", - "full font", - } - - local do_report_start = report_start - local do_report_stop = report_stop - - report_start = function(left,name) - if not left then - -- skip - elseif left ~= 1 then - if all then - report_load("type %a, name %a",types[left],name or "?") - end - else - do_report_start(name) - end - end - - report_stop = function(right) - if level == 1 or not right or right == 1 then - do_report_stop() - end - end - -end - local function report_none() end @@ -305,17 +275,9 @@ register("start_file",report_start) register("stop_file", report_stop) directives.register("system.reportfiles", function(v) - if v == "noresources" then - all = false - register("start_file",report_start) - register("stop_file", report_stop) - elseif toboolean(v) or v == "all" then - all = true + if v then register("start_file",report_start) register("stop_file", report_stop) - elseif v == "traditional" then - register("start_file",nil) - register("stop_file", nil) else register("start_file",report_none) register("stop_file", report_none) diff --git a/tex/context/base/mkiv/math-ini.mkiv b/tex/context/base/mkiv/math-ini.mkiv index 3c27bbf07..b6dcf9ba9 100644 --- a/tex/context/base/mkiv/math-ini.mkiv +++ b/tex/context/base/mkiv/math-ini.mkiv @@ -1474,7 +1474,7 @@ \to \everymathematics \setupmathematics - [\s!collapsing=3] % mathlist wins over specials + [\s!collapsing=\v!none] % was 3 : mathlist wins over specials %D Math italics (experiment) diff --git a/tex/context/base/mkiv/mult-low.lua b/tex/context/base/mkiv/mult-low.lua index 75c048c92..6cc468514 100644 --- a/tex/context/base/mkiv/mult-low.lua +++ b/tex/context/base/mkiv/mult-low.lua @@ -458,5 +458,7 @@ return { "compoundhyphenpenalty", -- "start", "stop", + -- + "unsupportedcs", } } diff --git a/tex/context/base/mkiv/node-fnt.lua b/tex/context/base/mkiv/node-fnt.lua index 01d7e42e5..25254009f 100644 --- a/tex/context/base/mkiv/node-fnt.lua +++ b/tex/context/base/mkiv/node-fnt.lua @@ -43,7 +43,6 @@ local handlers = nodes.handlers local nuts = nodes.nuts -local getattr = nuts.getattr local getid = nuts.getid local getsubtype = nuts.getsubtype local getdisc = nuts.getdisc @@ -51,7 +50,9 @@ local getnext = nuts.getnext local getprev = nuts.getprev local getboth = nuts.getboth local getdata = nuts.getdata +local getglyphdata = nuts.getglyphdata ----- getdisc = nuts.getdisc + local setchar = nuts.setchar local setlink = nuts.setlink local setnext = nuts.setnext @@ -179,7 +180,7 @@ local function start_trace(head) local char, id = isglyph(n) if char then local font = id - local attr = getattr(n,0) or 0 + local attr = getglyphdata(n) or 0 report_fonts("font %03i, dynamic %03i, glyph %C",font,attr,char) elseif id == disc_code then report_fonts("[disc] %s",nodes.listtoutf(n,true,false,n)) @@ -316,8 +317,8 @@ do -- metafun manual (with some 2500 single char lists) the difference is just noise. for n, char, font in nextchar, head do - -- local attr = (none and prevattr) or getattr(n,0) or 0 -- zero attribute is reserved for fonts in context - local attr = getattr(n) or 0 -- zero attribute is reserved for fonts in context + -- local attr = (none and prevattr) or getglyphdata(n) or 0 -- zero attribute is reserved for fonts in context + local attr = getglyphdata(n) or 0 -- zero attribute is reserved for fonts in context if font ~= prevfont or attr ~= prevattr then prevfont = font prevattr = attr @@ -440,7 +441,7 @@ do firstnone = nil basefont = nil for n, char, font in nextchar, r do - local attr = getattr(n) or 0 -- zero attribute is reserved for fonts in context + local attr = getglyphdata(n) or 0 -- zero attribute is reserved for fonts in context if font ~= prevfont or attr ~= prevattr then prevfont = font prevattr = attr diff --git a/tex/context/base/mkiv/node-ini.lua b/tex/context/base/mkiv/node-ini.lua index f910c7e01..8579ce18b 100644 --- a/tex/context/base/mkiv/node-ini.lua +++ b/tex/context/base/mkiv/node-ini.lua @@ -364,7 +364,7 @@ dirvalues = allocate(swapped(dirvalues,dirvalues)) gluevalues = allocate(swapped(gluevalues,gluevalues)) literalvalues = allocate(swapped(literalvalues,literalvalues)) -if CONTEXTLMTXMODE > 1 then +if CONTEXTLMTXMODE > 0 then whatcodes.literal = 0x1 whatcodes[0x1] = "literal" whatcodes.latelua = 0x2 whatcodes[0x2] = "latelua" whatcodes.userdefined = 0x3 whatcodes[0x3] = "userdefined" diff --git a/tex/context/base/mkiv/node-nut.lua b/tex/context/base/mkiv/node-nut.lua index 50e87e988..124f64301 100644 --- a/tex/context/base/mkiv/node-nut.lua +++ b/tex/context/base/mkiv/node-nut.lua @@ -229,9 +229,13 @@ nuts.getid = direct.getid nuts.getprev = direct.getprev nuts.setprev = direct.setprev -nuts.getattr = direct.get_attribute -nuts.setattr = direct.set_attribute -nuts.takeattr = direct.unset_attribute -- ? +local get_attribute = direct.get_attribute +local set_attribute = direct.set_attribute +local unset_attribute = direct.unset_attribute + +nuts.getattr = get_attribute +nuts.setattr = set_attribute +nuts.takeattr = unset_attribute -- ? nuts.is_zero_glue = direct.is_zero_glue nuts.effective_glue = direct.effective_glue @@ -246,10 +250,13 @@ nuts.setdisc = direct.setdisc nuts.getdiscretionary = direct.getdisc nuts.setdiscretionary = direct.setdisc -nuts.getdata = direct.getdata -nuts.setdata = direct.setdata -nuts.getvalue = direct.getdata -nuts.setvalue = direct.setdata +local getdata = direct.getdata +local setdata = direct.setdata + +nuts.getdata = getdata +nuts.setdata = setdata +nuts.getvalue = getdata +nuts.setvalue = setdata nuts.getexpansion = direct.getexpansion nuts.setexpansion = direct.setexpansion @@ -264,9 +271,20 @@ nuts.getdepth = direct.getdepth nuts.setdepth = direct.setdepth nuts.getshift = direct.getshift nuts.setshift = direct.setshift + +-- lmtx compatibility + nuts.getorientation = direct.getorientation or function() end nuts.setorientation = direct.setorientation or function() end +nuts.getglyphdata = direct.getglyphdata or get_attribute +nuts.setglyphdata = direct.setglyphdata or set_attribute + +nuts.getruledata = direct.getglyphdata and getdata or function(n) return getfield(n,"transform") end +nuts.setruledata = direct.setglyphdata and setdata or function(n,d) return setfield(n,"transform",d) end + +-- so far + nuts.getnucleus = direct.getnucleus nuts.setnucleus = direct.setnucleus nuts.getsup = direct.getsup diff --git a/tex/context/base/mkiv/node-par.lua b/tex/context/base/mkiv/node-par.lua index 8564c8764..d89edf6f4 100644 --- a/tex/context/base/mkiv/node-par.lua +++ b/tex/context/base/mkiv/node-par.lua @@ -39,7 +39,7 @@ local function newgraf(mode,indented) local runner = actions.runner if runner then starttiming(builders) - indent = runner(mode,indented) + indented = runner(mode,indented) stoptiming(builders) end return indented diff --git a/tex/context/base/mkiv/node-res.lua b/tex/context/base/mkiv/node-res.lua index 5b4961683..4b8187fa3 100644 --- a/tex/context/base/mkiv/node-res.lua +++ b/tex/context/base/mkiv/node-res.lua @@ -96,6 +96,7 @@ local setsubtype = nuts.setsubtype local setleader = nuts.setleader local setdata = nuts.setdata +local setruledata = nuts.setruledata local setvalue = nuts.setvalue local copy_nut = nuts.copy @@ -172,7 +173,7 @@ local savepos = register_nut(new_nut(whatsit_code,whatsitcodes.savepos local user_node = new_nut(whatsit_code,whatsitcodes.userdefined) -if CONTEXTLMTXMODE < 2 then +if CONTEXTLMTXMODE == 0 then setfield(user_node,"type",usercodes.number) end @@ -394,7 +395,7 @@ function nutpool.outlinerule(width,height,depth,line) -- w/h/d == nil will let t setwhd(n,width,height,depth) end if line then - if CONTEXTLMTXMODE > 1 then setdata(n,line) else setfield(n,"transform",line) end + setruledata(n,line) end return n end @@ -414,11 +415,16 @@ function nutpool.savepos() return copy_nut(savepos) end -if CONTEXTLMTXMODE > 1 then +if CONTEXTLMTXMODE == 0 then function nutpool.latelua(code) local n = copy_nut(latelua) - nodeproperties[n] = { data = code } + if type(code) == "table" then + local action = code.action + local specification = code.specification or code + code = function() action(specification) end + end + setdata(n,code) return n end @@ -426,12 +432,7 @@ else function nutpool.latelua(code) local n = copy_nut(latelua) - if type(code) == "table" then - local action = code.action - local specification = code.specification or code - code = function() action(specification) end - end - setdata(n,code) + nodeproperties[n] = { data = code } return n end diff --git a/tex/context/base/mkiv/node-rul.lua b/tex/context/base/mkiv/node-rul.lua index 1df5bf32a..61d78668f 100644 --- a/tex/context/base/mkiv/node-rul.lua +++ b/tex/context/base/mkiv/node-rul.lua @@ -30,7 +30,6 @@ local nuts = nodes.nuts local tonode = nuts.tonode local tonut = nuts.tonut -local getfield = nuts.getfield local setnext = nuts.setnext local setprev = nuts.setprev local setlink = nuts.setlink @@ -50,7 +49,10 @@ local getwidth = nuts.getwidth local setwidth = nuts.setwidth local setoffsets = nuts.setoffsets local setfield = nuts.setfield -local getdata = nuts.getdata + +----- getfield = nuts.getfield +----- getdata = nuts.getdata +local getruledata = nuts.getruledata local isglyph = nuts.isglyph @@ -166,7 +168,7 @@ rules .ruleactions = ruleactions nutrules.ruleactions = ruleactions -- convenient local function mathaction(n,h,v,what) - local font = CONTEXTLMTXMODE > 1 and getdata(n) or getfield(n,"transform") + local font = getruledata(n) local actions = fontresources[font].mathruleactions if actions then local action = actions[what] diff --git a/tex/context/base/mkiv/node-syn.lua b/tex/context/base/mkiv/node-syn.lua index a00dc65ec..35fb8fc7c 100644 --- a/tex/context/base/mkiv/node-syn.lua +++ b/tex/context/base/mkiv/node-syn.lua @@ -89,7 +89,6 @@ if not modules then modules = { } end modules ['node-syn'] = { -- h2,5:4661756,12973165:22918783,655360,327680 -- h2,6:27884864,12973165:4746833,655360,327680 -- h2,6:4661756,13922231:18320732,655360,327680 --- ) -- ] -- !533 -- }1 @@ -106,7 +105,6 @@ if not modules then modules = { } end modules ['node-syn'] = { -- h3,4:8459505,11075033:19885281,655360,327680 -- h3,5:28571312,11075033:4060385,655360,327680 -- h3,5:4661756,12024099:15344870,655360,327680 --- ) -- ] -- !441 -- }2 @@ -692,7 +690,8 @@ end function synctex.stop() if enabled then - filehandle:write(s_vlist,s_hlist) +-- filehandle:write(s_vlist,s_hlist) + filehandle:write(s_hlist) writeanchor() filehandle:write("}",nofsheets,eol) nofobjects = nofobjects + 2 diff --git a/tex/context/base/mkiv/pack-rul.mkiv b/tex/context/base/mkiv/pack-rul.mkiv index 3d03942aa..599547032 100644 --- a/tex/context/base/mkiv/pack-rul.mkiv +++ b/tex/context/base/mkiv/pack-rul.mkiv @@ -1723,8 +1723,8 @@ {\setvalue{\??framedlocatorbefore#1}{#2}% \setvalue{\??framedlocatorafter #1}{#3}} -\def\pack_framed_locator_before#1{\csname\??framedlocatorbefore#1\endcsname} -\def\pack_framed_locator_after #1{\csname\??framedlocatorafter #1\endcsname} +\def\pack_framed_locator_before#1{\begincsname\??framedlocatorbefore#1\endcsname} +\def\pack_framed_locator_after #1{\begincsname\??framedlocatorafter #1\endcsname} \newdimen\d_framed_locator_ht \newdimen\d_framed_locator_dp diff --git a/tex/context/base/mkiv/page-imp.mkiv b/tex/context/base/mkiv/page-imp.mkiv index 838ad7421..2f4e9a2f9 100644 --- a/tex/context/base/mkiv/page-imp.mkiv +++ b/tex/context/base/mkiv/page-imp.mkiv @@ -136,7 +136,7 @@ {\begingroup \writestatus\m!system {\ifarrangingpages arranged \fi page - \ifarrangingpages\the\arrangeno\else\the\realpageno\fi\normalspace + \ifarrangingpages\the\arrangeno\else\the\realpageno\fi\normalspace not flushed}% % \setbox\scratchbox\hpack % {#1}% no finalize diff --git a/tex/context/base/mkiv/page-inj.mkvi b/tex/context/base/mkiv/page-inj.mkvi index 5f48ffd13..b1a2913cf 100644 --- a/tex/context/base/mkiv/page-inj.mkvi +++ b/tex/context/base/mkiv/page-inj.mkvi @@ -93,7 +93,7 @@ \def\page_injections_direct_indeed_yes#parameters% {\clf_savepageinjections - name {\currentpageinjection}% + name {\currentpageinjection}% state {\p_page_injections_state}% userdata {\normalunexpanded{#parameters}}% \relax diff --git a/tex/context/base/mkiv/page-lay.mkiv b/tex/context/base/mkiv/page-lay.mkiv index 02cc5aa17..f94517144 100644 --- a/tex/context/base/mkiv/page-lay.mkiv +++ b/tex/context/base/mkiv/page-lay.mkiv @@ -1340,6 +1340,7 @@ %D \showsetup{showsetups} %D %showsetup{showmargins} %D %showsetup{showgrid} +%D %showsetup{showusage} \fetchruntimecommand \showprint \f!page_run \fetchruntimecommand \showframe \f!page_run @@ -1347,6 +1348,7 @@ \fetchruntimecommand \showsetups \f!page_run \fetchruntimecommand \showmargins \f!page_run \fetchruntimecommand \showgrid \f!page_run +\fetchruntimecommand \showusage \f!page_run \glet\page_grids_add_to_box\gobbleoneargument \glet\page_grids_add_to_one\gobbleoneargument diff --git a/tex/context/base/mkiv/page-run.lua b/tex/context/base/mkiv/page-run.lua index c0a2022b2..88a7d6664 100644 --- a/tex/context/base/mkiv/page-run.lua +++ b/tex/context/base/mkiv/page-run.lua @@ -186,3 +186,38 @@ function commands.showlayout(options) end +local report = logs.reporter("usage") + +function commands.showusage() + report("") + report("status after shipping out page %s",tex.getcount("realpageno")) + report("") + report(" filename : %s", status.filename) + report(" inputid : %s", status.inputid) + report(" linenumber : %s", status.linenumber) + report(" input pointer : %s", status.input_ptr) + report("") + report(" string pointer : %s of %s", status.str_ptr, status.max_strings + status.init_str_ptr) + report(" pool size : %s", status.pool_size) + report("") + report(" node memory usage : %s of %s", status.node_mem_usage, status.var_mem_max) + report(" fixex memory end : %s of %s", status.fix_mem_end, status.fix_mem_max) + report("") + report(" cs count : %s of %s", status.cs_count, status.hash_size + status.hash_extra) + report("") + report(" stack size : %s of %s", status.max_in_stack, status.stack_size) + report(" nest size : %s of %s", status.max_nest_stack, status.nest_size) + report(" parameter size : %s of %s", status.max_param_stack, status.param_size) + report(" buffer size : %s of %s", status.max_buf_stack, status.buf_size) + report(" save size : %s of %s", status.max_save_stack, status.save_size) + report("") + report(" luabytecode bytes : %s in %s registers", status.luabytecode_bytes, status.luabytecodes) + report(" luastate bytes : %s", status.luastate_bytes) + report("") + report(" callbacks : %s", status.callbacks) + report(" indirect callbacks : %s", status.indirect_callbacks) + report(" saved callbacks : %s", status.saved_callbacks) + report(" direct callbacks : %s", status.direct_callbacks) + report(" function callbacks : %s", status.function_callbacks) + report("") +end diff --git a/tex/context/base/mkiv/page-run.mkiv b/tex/context/base/mkiv/page-run.mkiv index 85da8d9e5..eedcfa416 100644 --- a/tex/context/base/mkiv/page-run.mkiv +++ b/tex/context/base/mkiv/page-run.mkiv @@ -215,4 +215,10 @@ \global\setbox#1\vpack{\backgroundline[layout:mix]{\box#1}}% \endgroup} +%D Ths next command shows some statistics (we might add more in due time): + +\unexpanded\gdef\showusage + {\gtoksapp\everyaftershipout{\ctxcommand{showusage()}}% + \glet\showusage\relax} + \protect \endinput diff --git a/tex/context/base/mkiv/page-txt.mkvi b/tex/context/base/mkiv/page-txt.mkvi index 97668c143..2f0ac72de 100644 --- a/tex/context/base/mkiv/page-txt.mkvi +++ b/tex/context/base/mkiv/page-txt.mkvi @@ -445,11 +445,11 @@ %D The following macro has to be called after a page is flushed. \unexpanded\def\resetlayouttextlines % public - {\csname\??layouttextsreset\v!top \endcsname - \csname\??layouttextsreset\v!header\endcsname - \csname\??layouttextsreset\v!text \endcsname - \csname\??layouttextsreset\v!footer\endcsname - \csname\??layouttextsreset\v!bottom\endcsname + {\begincsname\??layouttextsreset\v!top \endcsname + \begincsname\??layouttextsreset\v!header\endcsname + \begincsname\??layouttextsreset\v!text \endcsname + \begincsname\??layouttextsreset\v!footer\endcsname + \begincsname\??layouttextsreset\v!bottom\endcsname \ifconditional\resyncaftertextline \calculateglobalvsizes \page_backgrounds_recalculate diff --git a/tex/context/base/mkiv/scrp-ini.lua b/tex/context/base/mkiv/scrp-ini.lua index e6aa5f072..d76b64133 100644 --- a/tex/context/base/mkiv/scrp-ini.lua +++ b/tex/context/base/mkiv/scrp-ini.lua @@ -57,8 +57,11 @@ local getnext = nuts.getnext local getchar = nuts.getchar local getfont = nuts.getfont local getid = nuts.getid +local getglyphdata = nuts.getglyphdata + local getattr = nuts.getattr local setattr = nuts.setattr + local isglyph = nuts.isglyph local insert_node_after = nuts.insert_after @@ -894,7 +897,7 @@ function autofontfeature.handler(head) -- else local script = otfscripts[char] if script then - local dynamic = getattr(n,0) or 0 + local dynamic = getglyphdata(n) or 0 if dynamic > 0 then local slot = cache_yes[font] local attr = slot[script] diff --git a/tex/context/base/mkiv/spac-hor.mkiv b/tex/context/base/mkiv/spac-hor.mkiv index 24c7c7893..c0c7d95d2 100644 --- a/tex/context/base/mkiv/spac-hor.mkiv +++ b/tex/context/base/mkiv/spac-hor.mkiv @@ -38,8 +38,14 @@ \unexpanded\def\setupindenting {\doifelsenextoptionalcs\spac_indentation_setup_options\spac_indentation_setup_size} +% \unexpanded\def\spac_indentation_setup_size +% {\assigndimension\v_spac_indentation_current\d_spac_indentation_par{1\emwidth}{1.5\emwidth}{2\emwidth}} + \unexpanded\def\spac_indentation_setup_size - {\assigndimension\v_spac_indentation_current\d_spac_indentation_par{1\emwidth}{1.5\emwidth}{2\emwidth}} + {\assigndimension\v_spac_indentation_current\d_spac_indentation_par{1\emwidth}{1.5\emwidth}{2\emwidth}% + \ifdim\parindent=\zeropoint\else + \parindent\d_spac_indentation_par\relax % new per 2019-04-12 : just in case it has been set beforehand + \fi} \let\synchronizeindenting\spac_indentation_setup_size diff --git a/tex/context/base/mkiv/status-files.pdf b/tex/context/base/mkiv/status-files.pdf Binary files differindex faae4787a..bf34fe167 100644 --- a/tex/context/base/mkiv/status-files.pdf +++ b/tex/context/base/mkiv/status-files.pdf diff --git a/tex/context/base/mkiv/status-lua.pdf b/tex/context/base/mkiv/status-lua.pdf Binary files differindex 622b5fbe7..bab191ca1 100644 --- a/tex/context/base/mkiv/status-lua.pdf +++ b/tex/context/base/mkiv/status-lua.pdf diff --git a/tex/context/base/mkiv/strc-pag.lua b/tex/context/base/mkiv/strc-pag.lua index ee1b245b9..a9933a21f 100644 --- a/tex/context/base/mkiv/strc-pag.lua +++ b/tex/context/base/mkiv/strc-pag.lua @@ -45,10 +45,21 @@ pages.collected = collected pages.tobesaved = tobesaved pages.nofpages = 0 +-- utilitydata.structures.counters.collected.realpage[1] + local function initializer() collected = pages.collected tobesaved = pages.tobesaved - pages.nofpages = #collected + -- tricky, with pageinjection we can have holes + -- pages.nofpages = #collected + -- pages.nofpages = table.count(collected) -- could be a helper + local n = 0 + for k in next, collected do + if k > n then + n = k + end + end + pages.nofpages = n end job.register('structures.pages.collected', tobesaved, initializer) diff --git a/tex/context/base/mkiv/syst-ini.mkiv b/tex/context/base/mkiv/syst-ini.mkiv index 7ce48c79f..7c77ec97e 100644 --- a/tex/context/base/mkiv/syst-ini.mkiv +++ b/tex/context/base/mkiv/syst-ini.mkiv @@ -1002,7 +1002,7 @@ \spanomit \advance\mscount\minusone \repeat} -%D Backend: +%D For the \LUATEX\ backend (overloaded anyway): \ifdefined\pdfvariable diff --git a/tex/context/base/mkiv/tabl-tbl.mkiv b/tex/context/base/mkiv/tabl-tbl.mkiv index f3c2e2e10..fb7e283cd 100644 --- a/tex/context/base/mkiv/tabl-tbl.mkiv +++ b/tex/context/base/mkiv/tabl-tbl.mkiv @@ -909,7 +909,7 @@ \let\tabl_tabulate_hook\tabl_tabulate_hook_nop -\def\tabl_tabulate_hook_yes{\csname\??tabulatehook\the\c_tabl_tabulate_column\endcsname} +\def\tabl_tabulate_hook_yes{\begincsname\??tabulatehook\the\c_tabl_tabulate_column\endcsname} \def\tabl_tabulate_pheight_reset {\global\c_tabl_tabulate_plines_min\plusone @@ -1090,12 +1090,12 @@ \def\tabl_tabulate_insert_head_content {\tabulatenoalign{\global\settrue\c_tabl_tabulate_someamble}% - \csname\??tabulatehead\currenttabulation\endcsname + \begincsname\??tabulatehead\currenttabulation\endcsname \tabulatenoalign{\global\setfalse\c_tabl_tabulate_someamble}}% \def\tabl_tabulate_insert_foot_content {\tabulatenoalign{\global\settrue\c_tabl_tabulate_someamble}% - \csname\??tabulatefoot\currenttabulation\endcsname + \begincsname\??tabulatefoot\currenttabulation\endcsname \tabulatenoalign{\global\setfalse\c_tabl_tabulate_someamble}}% \def\tabl_tabulate_check_full_content % - needed, else confusion with \c!header @@ -1364,7 +1364,7 @@ \fi % \settrue\c_tabl_tabulate_split - \csname\??tabulatesplit\tabulationparameter\c!split\endcsname + \begincsname\??tabulatesplit\tabulationparameter\c!split\endcsname % \let\m_tabl_tabulate_blank_default\p_blank % diff --git a/tex/context/base/mkiv/toks-ini.lua b/tex/context/base/mkiv/toks-ini.lua index 2c85a5754..2a288caf6 100644 --- a/tex/context/base/mkiv/toks-ini.lua +++ b/tex/context/base/mkiv/toks-ini.lua @@ -61,14 +61,6 @@ local new_token = token.new local is_defined = token.is_defined local is_token = token.is_token -if not is_defined then - - is_defined = function(name) - return get_cmdname(create_token(name)) ~= "undefined_cs" - end - -end - tokens.new = new_token tokens.create = create_token tokens.istoken = is_token @@ -104,14 +96,10 @@ local bits = { tokens.bits = bits -local space_bits = bits.space - -- words are space or \relax terminated and the trailing space is gobbled; a word --- can contain any non-space letter/other +-- can contain any non-space letter/other (see archive for implementation in lua) -local t = { } -- small optimization, a shared variable that is not reset - -if scan_word then +if not scan_number then scan_number = function(base) local s = scan_word() @@ -124,70 +112,8 @@ if scan_word then end end -else - - scan_word = function() - local n = 0 - while true do - local c = scan_code() - if c then - n = n + 1 - t[n] = utfchar(c) - elseif scan_code(space_bits) then - if n > 0 then - break - end - elseif n > 0 then - break - else - return - end - end - return concat(t,"",1,n) - end - - -- so we gobble the space (like scan_int) (number has to be space or non-char terminated - -- as we accept 0xabcd and such so there is no clear separator for a keyword - - scan_number = function(base) - local n = 0 - while true do - local c = scan_code() - if c then - n = n + 1 - t[n] = char(c) - elseif scan_code(space_bits) then - if n > 0 then - break - end - elseif n > 0 then - break - else - return - end - end - local s = concat(t,"",1,n) - if base then - return tonumber(s,base) - else - return tonumber(s) - end - end - end --- -- the next one cannot handle \iftrue true\else false\fi --- --- local function scan_boolean() --- if scan_keyword("true") then --- return true --- elseif scan_keyword("false") then --- return false --- else --- return nil --- end --- end - local function scan_boolean() local kw = scan_word() if kw == "true" then @@ -199,16 +125,6 @@ local function scan_boolean() end end -if not scan_csname then - - scan_csname = function() - local t = get_next() - local n = t.csname - return n ~= "" and n or nil - end - -end - local function scan_verbatim() return scan_argument(false) end diff --git a/tex/context/base/mkiv/trac-ctx.lua b/tex/context/base/mkiv/trac-ctx.lua index 33637fd66..6681be51c 100644 --- a/tex/context/base/mkiv/trac-ctx.lua +++ b/tex/context/base/mkiv/trac-ctx.lua @@ -70,3 +70,17 @@ implement { install(texdirectives,directives.register,tag,enable,disable) end, } + +-- this one might move + +interfaces.implement { + name = "unsupportedcs", + public = true, + actions = function() + logs.newline() + logs.report("fatal error","unsupported cs \\%s",tokens.scanners.csname()) + logs.newline() + luatex.abort() + end +} + diff --git a/tex/context/base/mkiv/trac-tex.mkiv b/tex/context/base/mkiv/trac-tex.mkiv index 4c2db68f3..d659f4bab 100644 --- a/tex/context/base/mkiv/trac-tex.mkiv +++ b/tex/context/base/mkiv/trac-tex.mkiv @@ -32,8 +32,8 @@ \unexpanded\def\enabletextracers [#1]{\processcommalist[#1]\syst_textracers_enable } \unexpanded\def\disabletextracers[#1]{\processcommalist[#1]\syst_textracers_disable} -\def\syst_textracers_enable #1{\csname enabletracer#1\endcsname} -\def\syst_textracers_disable#1{\csname disabletracer#1\endcsname} +\def\syst_textracers_enable #1{\begincsname enabletracer#1\endcsname} +\def\syst_textracers_disable#1{\begincsname disabletracer#1\endcsname} % The next one is for Taco, although we can use directives as well: diff --git a/tex/context/base/mkiv/typo-drp.lua b/tex/context/base/mkiv/typo-drp.lua index 9a59891e1..6ac59d00c 100644 --- a/tex/context/base/mkiv/typo-drp.lua +++ b/tex/context/base/mkiv/typo-drp.lua @@ -45,6 +45,7 @@ local setchar = nuts.setchar local setwhd = nuts.setwhd local setkern = nuts.setkern local setoffsets = nuts.setoffsets +local setglyphdata = nuts.setglyphdata local hpack_nodes = nuts.hpack @@ -257,7 +258,7 @@ actions[v_default] = function(head,setting) setfont(current,font) end if dynamic > 0 then - setattr(current,0,dynamic) + setglyphdata(current,dynamic) end -- apply font diff --git a/tex/context/base/mkiv/typo-drp.mkiv b/tex/context/base/mkiv/typo-drp.mkiv index 183925108..917b4255b 100644 --- a/tex/context/base/mkiv/typo-drp.mkiv +++ b/tex/context/base/mkiv/typo-drp.mkiv @@ -112,7 +112,7 @@ ca \attribute\colorattribute ta \attribute\transparencyattribute font \fontid\font - dynamic \attribute\zerocount % it's a bit over the top to support this here + dynamic \font_dynamic_value % it's a bit over the top to support this here \relax \stopluacode \kern\zeropoint % we need a node diff --git a/tex/context/base/mkiv/typo-fln.lua b/tex/context/base/mkiv/typo-fln.lua index 048980732..13a990e26 100644 --- a/tex/context/base/mkiv/typo-fln.lua +++ b/tex/context/base/mkiv/typo-fln.lua @@ -47,6 +47,7 @@ local getdisc = nuts.getdisc local setdisc = nuts.setdisc local setlink = nuts.setlink local setfont = nuts.setfont +local setglyphdata = nuts.setglyphdata local nodecodes = nodes.nodecodes local glyph_code = nodecodes.glyph @@ -135,10 +136,10 @@ actions[v_line] = function(head,setting) local temp = copy_node_list(head) local linebreaks = { } - local function set(head) + set = function(head) for g in nextglyph, head do if dynamic > 0 then - setattr(g,0,dynamic) + setglyphdata(g,dynamic) end setfont(g,font) end @@ -234,7 +235,7 @@ actions[v_line] = function(head,setting) local function update(start) if dynamic > 0 then - setattr(start,0,dynamic) + setglyphdata(start,dynamic) end setfont(start,font) if ca and ca > 0 then @@ -348,7 +349,7 @@ actions[v_word] = function(head,setting) setattr(start,a_transparency,ta) end if dynamic > 0 then - setattr(start,0,dynamic) + setglyphdata(start,dynamic) end setfont(start,font) elseif id == disc_code then diff --git a/tex/context/base/mkiv/typo-fln.mkiv b/tex/context/base/mkiv/typo-fln.mkiv index 533c197cd..bcf67af9b 100644 --- a/tex/context/base/mkiv/typo-fln.mkiv +++ b/tex/context/base/mkiv/typo-fln.mkiv @@ -86,7 +86,7 @@ ta \attribute\transparencyattribute n \numexpr\firstlineparameter\c!n\relax font \fontid\font - dynamic \attribute\zerocount + dynamic \font_dynamic_value \relax \kern\zeropoint % we need a node % \hskip\zeropoint\s!plus\emwidth\relax % can be an option diff --git a/tex/context/base/mkiv/typo-inj.mkiv b/tex/context/base/mkiv/typo-inj.mkiv index 3b77379b3..633d430e4 100644 --- a/tex/context/base/mkiv/typo-inj.mkiv +++ b/tex/context/base/mkiv/typo-inj.mkiv @@ -73,8 +73,8 @@ \setuxvalue{typo_injectors_check_#1}{\noexpand\clf_checkinjector{#1}}} \unexpanded\def\dotestinjector#1% only for testing outside unprotect - {\csname typo_injectors_check_#1\endcsname - \csname typo_injectors_mark_#1\endcsname} + {\begincsname typo_injectors_check_#1\endcsname + \begincsname typo_injectors_mark_#1\endcsname} \protect \endinput diff --git a/tex/context/base/mkiv/typo-krn.lua b/tex/context/base/mkiv/typo-krn.lua index c26004a49..c7edf4055 100644 --- a/tex/context/base/mkiv/typo-krn.lua +++ b/tex/context/base/mkiv/typo-krn.lua @@ -40,8 +40,9 @@ local getchar = nuts.getchar local getdisc = nuts.getdisc local getglue = nuts.getglue local getkern = nuts.getkern +local getglyphdata = nuts.getglyphdata + local isglyph = nuts.isglyph -local setchar = nuts.setchar local setfield = nuts.setfield local getattr = nuts.getattr @@ -51,12 +52,12 @@ local setlink = nuts.setlink local setdisc = nuts.setdisc local setglue = nuts.setglue local setkern = nuts.setkern +local setchar = nuts.setchar +local setglue = nuts.setglue -- todo local texsetattribute = tex.setattribute local unsetvalue = attributes.unsetvalue -local setglue = nuts.setglue -- todo - local new_kern = nodepool.kern local new_glue = nodepool.glue @@ -139,7 +140,7 @@ local gluefactor = 4 -- assumes quad = .5 enspace function kerns.keepligature(n) -- might become default local f = getfont(n) - local a = getattr(n,0) or 0 + local a = getglyphdata(n) or 0 if trace_ligatures then local c = getchar(n) local d = fontdescriptions[f][c].name diff --git a/tex/context/base/mkiv/util-lua.lua b/tex/context/base/mkiv/util-lua.lua index 1199301f4..f7e6e4f31 100644 --- a/tex/context/base/mkiv/util-lua.lua +++ b/tex/context/base/mkiv/util-lua.lua @@ -30,9 +30,9 @@ luautilities.strippedchunks = strippedchunks luautilities.suffixes = { tma = "tma", - tmc = jit and "tmb" or "tmc", + tmc = (CONTEXTLMTXMODE and CONTEXTLMTXMODE > 0 and "tmd") or (jit and "tmb") or "tmc", lua = "lua", - luc = jit and "lub" or "luc", + luc = (CONTEXTLMTXMODE and CONTEXTLMTXMODE > 0 and "lud") or (jit and "lub") or "luc", lui = "lui", luv = "luv", luj = "luj", diff --git a/tex/context/interface/mkiv/i-context.pdf b/tex/context/interface/mkiv/i-context.pdf Binary files differindex 1c790c10b..4b47392f8 100644 --- a/tex/context/interface/mkiv/i-context.pdf +++ b/tex/context/interface/mkiv/i-context.pdf diff --git a/tex/context/interface/mkiv/i-readme.pdf b/tex/context/interface/mkiv/i-readme.pdf Binary files differindex d713701b0..d21f00223 100644 --- a/tex/context/interface/mkiv/i-readme.pdf +++ b/tex/context/interface/mkiv/i-readme.pdf diff --git a/tex/generic/context/luatex/luatex-basics-nod.lua b/tex/generic/context/luatex/luatex-basics-nod.lua index 879da4bc7..9e035efa6 100644 --- a/tex/generic/context/luatex/luatex-basics-nod.lua +++ b/tex/generic/context/luatex/luatex-basics-nod.lua @@ -203,6 +203,9 @@ nuts.setsplit = direct.setsplit nuts.setsubtype = direct.setsubtype nuts.setwidth = direct.setwidth +nuts.getglyphdata = direct.getattr +nuts.setglyphdata = direct.setattr + nuts.is_char = direct.is_char nuts.is_glyph = direct.is_glyph nuts.ischar = direct.is_char diff --git a/tex/generic/context/luatex/luatex-fonts-merged.lua b/tex/generic/context/luatex/luatex-fonts-merged.lua index 6a8a418bd..462cd6a2e 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 : 04/04/19 13:31:02 +-- merge date : 04/12/19 17:43:58 do -- begin closure to overcome local limits and interference @@ -4873,6 +4873,8 @@ nuts.setprev=direct.setprev nuts.setsplit=direct.setsplit nuts.setsubtype=direct.setsubtype nuts.setwidth=direct.setwidth +nuts.getglyphdata=direct.getattr +nuts.setglyphdata=direct.setattr nuts.is_char=direct.is_char nuts.is_glyph=direct.is_glyph nuts.ischar=direct.is_char @@ -17931,6 +17933,7 @@ function gposhandlers.pair(f,fontdata,lookupid,lookupoffset,offset,glyphs,nofgly classdef1=readclassdef(f,tableoffset+classdef1,coverage) classdef2=readclassdef(f,tableoffset+classdef2,nofglyphs) local usedcoverage={} +local shared={} for g1,c1 in next,classdef1 do if coverage[g1] then local l1=classlist[c1] @@ -17942,7 +17945,17 @@ function gposhandlers.pair(f,fontdata,lookupid,lookupoffset,offset,glyphs,nofgly local first=offsets[1] local second=offsets[2] if first or second then - hash[paired]={ first,second or nil } +local s1=shared[first] +if not s1 then + s1={} + shared[first]=s1 +end +local s2=s1[second] +if not s2 then + s2={ first,second or nil } + s1[second]=s2 +end +hash[paired]=s2 else end end @@ -25572,8 +25585,6 @@ local setprev=nuts.setprev local getboth=nuts.getboth local setboth=nuts.setboth local getid=nuts.getid -local getattr=nuts.getattr -local setattr=nuts.setattr local getprop=nuts.getprop local setprop=nuts.setprop local getsubtype=nuts.getsubtype @@ -25586,6 +25597,8 @@ local setlink=nuts.setlink local getcomponents=nuts.getcomponents local setcomponents=nuts.setcomponents local getwidth=nuts.getwidth +local getattr=nuts.getattr +local getglyphdata=nuts.getglyphdata local ischar=nuts.is_char local isglyph=nuts.isglyph local usesfont=nuts.uses_font @@ -28189,7 +28202,7 @@ local function c_run_single(head,font,attr,lookupcache,step,dataset,sequence,rlm if char then local a if attr then - a=getattr(start,0) + a=getglyphdata(start) end if not a or (a==attr) then local lookupmatch=lookupcache[char] @@ -28223,7 +28236,7 @@ local function t_run_single(start,stop,font,attr,lookupcache) if char then local a if attr then - a=getattr(start,0) + a=getglyphdata(start) end local startnext=getnext(start) if not a or (a==attr) then @@ -28298,7 +28311,7 @@ end local function k_run_single(sub,injection,last,font,attr,lookupcache,step,dataset,sequence,rlmode,skiphash,handler) local a if attr then - a=getattr(sub,0) + a=getglyphdata(sub) end if not a or (a==attr) then for n in nextnode,sub do @@ -28332,7 +28345,7 @@ local function c_run_multiple(head,font,attr,steps,nofsteps,dataset,sequence,rlm if char then local a if attr then - a=getattr(start,0) + a=getglyphdata(start) end if not a or (a==attr) then for i=1,nofsteps do @@ -28373,7 +28386,7 @@ local function t_run_multiple(start,stop,font,attr,steps,nofsteps) if char then local a if attr then - a=getattr(start,0) + a=getglyphdata(start) end local startnext=getnext(start) if not a or (a==attr) then @@ -28451,7 +28464,7 @@ end local function k_run_multiple(sub,injection,last,font,attr,steps,nofsteps,dataset,sequence,rlmode,skiphash,handler) local a if attr then - a=getattr(sub,0) + a=getglyphdata(sub) end if not a or (a==attr) then for n in nextnode,sub do @@ -28602,7 +28615,7 @@ do if m then local a if attr then - a=getattr(start,0) + a=getglyphdata(start) end if not a or (a==attr) then for i=m[1],m[2] do @@ -28646,7 +28659,7 @@ do if lookupmatch then local a if attr then - if getattr(start,0)==attr and (not attribute or getprop(start,a_state)==attribute) then + if getglyphdata(start)==attr and (not attribute or getprop(start,a_state)==attribute) then a=true end elseif not attribute or getprop(start,a_state)==attribute then @@ -28702,7 +28715,7 @@ do if m then local a if attr then - if getattr(start,0)==attr and (not attribute or getprop(start,a_state)==attribute) then + if getglyphdata(start)==attr and (not attribute or getprop(start,a_state)==attribute) then a=true end elseif not attribute or getprop(start,a_state)==attribute then @@ -33517,7 +33530,7 @@ end -- closure do -- begin closure to overcome local limits and interference -if not modules then modules={} end modules ['font-tfm']={ +if not modules then modules={} end modules ['luatex-fonts-tfm']={ version=1.001, comment="companion to font-ini.mkiv", author="Hans Hagen, PRAGMA-ADE, Hasselt NL", @@ -33553,7 +33566,7 @@ local registertfmenhancer=tfmenhancers.register local charcommand=helpers.commands.char constructors.resolvevirtualtoo=false fonts.formats.tfm="type1" -fonts.formats.ofm="type1" +fonts.formats.ofm="type1" function tfm.setfeatures(tfmdata,features) local okay=constructors.initializefeatures("tfm",tfmdata,features,trace_features,report_tfm) if okay then @@ -33562,191 +33575,156 @@ function tfm.setfeatures(tfmdata,features) return {} end end -local depth={} -local read_from_tfm,check_tfm do - local tfmreaders=context and tfm.readers - local loadtfmvf=tfmreaders and tfmreaders.loadtfmvf - local loadtfm=font.read_tfm - local loadvf=font.read_vf - directives.register("fonts.tfm.builtin",function(v) - loadtfmvf=tfmreaders and tfmreaders.loadtfmvf - if v and loadtfm then - loadtfmvf=false - end - end) - read_from_tfm=function(specification) - local filename=specification.filename - local size=specification.size - depth[filename]=(depth[filename] or 0)+1 - if trace_defining then - report_defining("loading tfm file %a at size %s",filename,size) - end - local tfmdata - if loadtfmvf then - tfmdata=loadtfmvf(filename,size) - else - tfmdata=loadtfm(filename,size) +local depth={} +local loadtfm=font.read_tfm +local loadvf=font.read_vf +local function read_from_tfm(specification) + local filename=specification.filename + local size=specification.size + depth[filename]=(depth[filename] or 0)+1 + if trace_defining then + report_defining("loading tfm file %a at size %s",filename,size) + end + local tfmdata=loadtfm(filename,size) + if tfmdata then + local features=specification.features and specification.features.normal or {} + local features=constructors.checkedfeatures("tfm",features) + specification.features.normal=features + local newtfmdata=(depth[filename]==1) and tfm.reencode(tfmdata,specification) + if newtfmdata then + tfmdata=newtfmdata end - if tfmdata then - local features=specification.features and specification.features.normal or {} - local features=constructors.checkedfeatures("tfm",features) - specification.features.normal=features - local newtfmdata=(depth[filename]==1) and tfm.reencode(tfmdata,specification) - if newtfmdata then - tfmdata=newtfmdata - end - local resources=tfmdata.resources or {} - local properties=tfmdata.properties or {} - local parameters=tfmdata.parameters or {} - local shared=tfmdata.shared or {} - shared.features=features - shared.resources=resources - properties.name=tfmdata.name - properties.fontname=tfmdata.fontname - properties.psname=tfmdata.psname - properties.fullname=tfmdata.fullname - properties.filename=specification.filename - properties.format=tfmdata.format or fonts.formats.tfm - properties.usedbitmap=tfmdata.usedbitmap - tfmdata.properties=properties - tfmdata.resources=resources - tfmdata.parameters=parameters - tfmdata.shared=shared - shared.rawdata={ resources=resources } - shared.features=features - if newtfmdata then - if not resources.marks then - resources.marks={} - end - if not resources.sequences then - resources.sequences={} - end - if not resources.features then - resources.features={ - gsub={}, - gpos={}, - } - end - if not tfmdata.changed then - tfmdata.changed={} - end - if not tfmdata.descriptions then - tfmdata.descriptions=tfmdata.characters - end - otf.readers.addunicodetable(tfmdata) - tfmenhancers.apply(tfmdata,filename) - constructors.applymanipulators("tfm",tfmdata,features,trace_features,report_tfm) - otf.readers.unifymissing(tfmdata) - fonts.mappings.addtounicode(tfmdata,filename) - tfmdata.tounicode=1 - local tounicode=fonts.mappings.tounicode - for unicode,v in next,tfmdata.characters do - local u=v.unicode - if u then - v.tounicode=tounicode(u) - end - end - if tfmdata.usedbitmap then - tfm.addtounicode(tfmdata) - end - end - shared.processes=next(features) and tfm.setfeatures(tfmdata,features) or nil - if size<0 then - size=idiv(65536*-size,100) - end - parameters.factor=1 - parameters.units=1000 - parameters.size=size - parameters.slant=parameters.slant or parameters[1] or 0 - parameters.space=parameters.space or parameters[2] or 0 - parameters.space_stretch=parameters.space_stretch or parameters[3] or 0 - parameters.space_shrink=parameters.space_shrink or parameters[4] or 0 - parameters.x_height=parameters.x_height or parameters[5] or 0 - parameters.quad=parameters.quad or parameters[6] or 0 - parameters.extra_space=parameters.extra_space or parameters[7] or 0 - constructors.enhanceparameters(parameters) - properties.private=properties.private or tfmdata.private or privateoffset - if newtfmdata then - elseif loadtfmvf then - local fonts=tfmdata.fonts - if fonts then - for i=1,#fonts do - local font=fonts[i] - local id=font.id - if not id then - local name=font.name - local size=font.size - if name and size then - local data,id=constructors.readanddefine(name,size) - if id then - font.id=id - font.name=nil - font.size=nil - end - end - end - end - end - elseif constructors.resolvevirtualtoo then - fonts.loggers.register(tfmdata,file.suffix(filename),specification) - local vfname=findbinfile(specification.name,'ovf') - if vfname and vfname~="" then - local vfdata=loadvf(vfname,size) - if vfdata then - local chars=tfmdata.characters - for k,v in next,vfdata.characters do - chars[k].commands=v.commands - end - properties.virtualized=true - tfmdata.fonts=vfdata.fonts - tfmdata.type="virtual" - local fontlist=vfdata.fonts - local name=file.nameonly(filename) - for i=1,#fontlist do - local n=fontlist[i].name - local s=fontlist[i].size - local d=depth[filename] - s=constructors.scaled(s,vfdata.designsize) - if d>tfm.maxnestingdepth then - report_defining("too deeply nested virtual font %a with size %a, max nesting depth %s",n,s,tfm.maxnestingdepth) - fontlist[i]={ id=0 } - elseif (d>1) and (s>tfm.maxnestingsize) then - report_defining("virtual font %a exceeds size %s",n,s) - fontlist[i]={ id=0 } - else - local t,id=constructors.readanddefine(n,s) - fontlist[i]={ id=id } - end + local resources=tfmdata.resources or {} + local properties=tfmdata.properties or {} + local parameters=tfmdata.parameters or {} + local shared=tfmdata.shared or {} + shared.features=features + shared.resources=resources + properties.name=tfmdata.name + properties.fontname=tfmdata.fontname + properties.psname=tfmdata.psname + properties.fullname=tfmdata.fullname + properties.filename=specification.filename + properties.format=tfmdata.format or fonts.formats.tfm + properties.usedbitmap=tfmdata.usedbitmap + tfmdata.properties=properties + tfmdata.resources=resources + tfmdata.parameters=parameters + tfmdata.shared=shared + shared.rawdata={ resources=resources } + shared.features=features + if newtfmdata then + if not resources.marks then + resources.marks={} + end + if not resources.sequences then + resources.sequences={} + end + if not resources.features then + resources.features={ + gsub={}, + gpos={}, + } + end + if not tfmdata.changed then + tfmdata.changed={} + end + if not tfmdata.descriptions then + tfmdata.descriptions=tfmdata.characters + end + otf.readers.addunicodetable(tfmdata) + tfmenhancers.apply(tfmdata,filename) + constructors.applymanipulators("tfm",tfmdata,features,trace_features,report_tfm) + otf.readers.unifymissing(tfmdata) + fonts.mappings.addtounicode(tfmdata,filename) + tfmdata.tounicode=1 + local tounicode=fonts.mappings.tounicode + for unicode,v in next,tfmdata.characters do + local u=v.unicode + if u then + v.tounicode=tounicode(u) + end + end + if tfmdata.usedbitmap then + tfm.addtounicode(tfmdata) + end + end + shared.processes=next(features) and tfm.setfeatures(tfmdata,features) or nil + if size<0 then + size=idiv(65536*-size,100) + end + parameters.factor=1 + parameters.units=1000 + parameters.size=size + parameters.slant=parameters.slant or parameters[1] or 0 + parameters.space=parameters.space or parameters[2] or 0 + parameters.space_stretch=parameters.space_stretch or parameters[3] or 0 + parameters.space_shrink=parameters.space_shrink or parameters[4] or 0 + parameters.x_height=parameters.x_height or parameters[5] or 0 + parameters.quad=parameters.quad or parameters[6] or 0 + parameters.extra_space=parameters.extra_space or parameters[7] or 0 + constructors.enhanceparameters(parameters) + properties.private=properties.private or tfmdata.private or privateoffset + if newtfmdata then + elseif constructors.resolvevirtualtoo then + fonts.loggers.register(tfmdata,file.suffix(filename),specification) + local vfname=findbinfile(specification.name,'ovf') + if vfname and vfname~="" then + local vfdata=loadvf(vfname,size) + if vfdata then + local chars=tfmdata.characters + for k,v in next,vfdata.characters do + chars[k].commands=v.commands + end + properties.virtualized=true + tfmdata.fonts=vfdata.fonts + tfmdata.type="virtual" + local fontlist=vfdata.fonts + local name=file.nameonly(filename) + for i=1,#fontlist do + local n=fontlist[i].name + local s=fontlist[i].size + local d=depth[filename] + s=constructors.scaled(s,vfdata.designsize) + if d>tfm.maxnestingdepth then + report_defining("too deeply nested virtual font %a with size %a, max nesting depth %s",n,s,tfm.maxnestingdepth) + fontlist[i]={ id=0 } + elseif (d>1) and (s>tfm.maxnestingsize) then + report_defining("virtual font %a exceeds size %s",n,s) + fontlist[i]={ id=0 } + else + local t,id=constructors.readanddefine(n,s) + fontlist[i]={ id=id } end end end end - properties.haskerns=true - properties.hasligatures=true - properties.hasitalics=true - resources.unicodes={} - resources.lookuptags={} - depth[filename]=depth[filename]-1 - return tfmdata - else - depth[filename]=depth[filename]-1 end + properties.haskerns=true + properties.hasligatures=true + properties.hasitalics=true + resources.unicodes={} + resources.lookuptags={} + depth[filename]=depth[filename]-1 + return tfmdata + else + depth[filename]=depth[filename]-1 end - check_tfm=function(specification,fullname) - local foundname=findbinfile(fullname,'tfm') or "" - if foundname=="" then - foundname=findbinfile(fullname,'ofm') or "" - end - if foundname=="" then - foundname=fonts.names.getfilename(fullname,"tfm") or "" - end - if foundname~="" then - specification.filename=foundname - specification.format="ofm" - return read_from_tfm(specification) - elseif trace_defining then - report_defining("loading tfm with name %a fails",specification.name) - end +end +local function check_tfm(specification,fullname) + local foundname=findbinfile(fullname,'tfm') or "" + if foundname=="" then + foundname=findbinfile(fullname,'ofm') or "" + end + if foundname=="" then + foundname=fonts.names.getfilename(fullname,"tfm") or "" + end + if foundname~="" then + specification.filename=foundname + specification.format="ofm" + return read_from_tfm(specification) + elseif trace_defining then + report_defining("loading tfm with name %a fails",specification.name) end end readers.check_tfm=check_tfm diff --git a/tex/generic/context/luatex/luatex-fonts-tfm.lua b/tex/generic/context/luatex/luatex-fonts-tfm.lua new file mode 100644 index 000000000..0b6e09a8f --- /dev/null +++ b/tex/generic/context/luatex/luatex-fonts-tfm.lua @@ -0,0 +1,654 @@ +if not modules then modules = { } end modules ['luatex-fonts-tfm'] = { + version = 1.001, + comment = "companion to font-ini.mkiv", + author = "Hans Hagen, PRAGMA-ADE, Hasselt NL", + copyright = "PRAGMA ADE / ConTeXt Development Team", + license = "see context related readme files" +} + +-- This is the generic tfm/vf loader. There are no fundamental differences with +-- the one used in ConTeXt but we save some byte(codes) this way. + +local next, type = next, type +local match, format = string.match, string.format +local concat, sortedhash = table.concat, table.sortedhash +local idiv = number.idiv + +local trace_defining = false trackers.register("fonts.defining", function(v) trace_defining = v end) +local trace_features = false trackers.register("tfm.features", function(v) trace_features = v end) + +local report_defining = logs.reporter("fonts","defining") +local report_tfm = logs.reporter("fonts","tfm loading") + +local findbinfile = resolvers.findbinfile +local setmetatableindex = table.setmetatableindex + +local fonts = fonts +local handlers = fonts.handlers +local helpers = fonts.helpers +local readers = fonts.readers +local constructors = fonts.constructors +local encodings = fonts.encodings + +local tfm = constructors.handlers.tfm +tfm.version = 1.000 +tfm.maxnestingdepth = 5 +tfm.maxnestingsize = 65536*1024 + +local otf = fonts.handlers.otf +local otfenhancers = otf.enhancers + +local tfmfeatures = constructors.features.tfm +local registertfmfeature = tfmfeatures.register + +local tfmenhancers = constructors.enhancers.tfm +local registertfmenhancer = tfmenhancers.register + +local charcommand = helpers.commands.char + +constructors.resolvevirtualtoo = false -- wil be set in font-ctx.lua + +fonts.formats.tfm = "type1" -- we need to have at least a value here +fonts.formats.ofm = "type1" -- we need to have at least a value here + +function tfm.setfeatures(tfmdata,features) + local okay = constructors.initializefeatures("tfm",tfmdata,features,trace_features,report_tfm) + if okay then + return constructors.collectprocessors("tfm",tfmdata,features,trace_features,report_tfm) + else + return { } -- will become false + end +end + +local depth = { } -- table.setmetatableindex("number") + +local loadtfm = font.read_tfm +local loadvf = font.read_vf + +local function read_from_tfm(specification) + local filename = specification.filename + local size = specification.size + depth[filename] = (depth[filename] or 0) + 1 + if trace_defining then + report_defining("loading tfm file %a at size %s",filename,size) + end + local tfmdata = loadtfm(filename,size) + if tfmdata then + + local features = specification.features and specification.features.normal or { } + local features = constructors.checkedfeatures("tfm",features) + specification.features.normal = features + + -- If reencode returns a new table, we assume that we're doing something + -- special. An 'auto' reencode picks up its vector from the pfb file. + + local newtfmdata = (depth[filename] == 1) and tfm.reencode(tfmdata,specification) + if newtfmdata then + tfmdata = newtfmdata + end + + local resources = tfmdata.resources or { } + local properties = tfmdata.properties or { } + local parameters = tfmdata.parameters or { } + local shared = tfmdata.shared or { } + -- + shared.features = features + shared.resources = resources + -- + properties.name = tfmdata.name -- todo: fallback + properties.fontname = tfmdata.fontname -- todo: fallback + properties.psname = tfmdata.psname -- todo: fallback + properties.fullname = tfmdata.fullname -- todo: fallback + properties.filename = specification.filename -- todo: fallback + properties.format = tfmdata.format or fonts.formats.tfm -- better than nothing + properties.usedbitmap = tfmdata.usedbitmap + -- + tfmdata.properties = properties + tfmdata.resources = resources + tfmdata.parameters = parameters + tfmdata.shared = shared + -- + shared.rawdata = { resources = resources } + shared.features = features + -- + -- The next branch is only entered when we have a proper encoded file i.e. + -- unicodes and such. It really nakes no sense to do feature juggling when + -- we have no names and unicodes. + -- + if newtfmdata then + -- + -- Some opentype processing assumes these to be present: + -- + if not resources.marks then + resources.marks = { } + end + if not resources.sequences then + resources.sequences = { } + end + if not resources.features then + resources.features = { + gsub = { }, + gpos = { }, + } + end + if not tfmdata.changed then + tfmdata.changed = { } + end + if not tfmdata.descriptions then + tfmdata.descriptions = tfmdata.characters + end + -- + -- It might be handy to have this: + -- + otf.readers.addunicodetable(tfmdata) + -- + -- We make a pseudo opentype font, e.g. kerns and ligatures etc: + -- + tfmenhancers.apply(tfmdata,filename) + -- + -- Now user stuff can kick in. + -- + constructors.applymanipulators("tfm",tfmdata,features,trace_features,report_tfm) + -- + -- As that can also mess with names and such, we are now ready for finalizing + -- the unicode information. This is a different order that for instance type one + -- (afm) files. First we try to deduce unicodes from already present information. + -- + otf.readers.unifymissing(tfmdata) + -- + -- Next we fill in the gaps, based on names from teh agl. Probably not much will + -- happen here. + -- + fonts.mappings.addtounicode(tfmdata,filename) + -- + -- The tounicode data is passed to the backend that constructs the vectors for us. + -- + tfmdata.tounicode = 1 + local tounicode = fonts.mappings.tounicode + for unicode, v in next, tfmdata.characters do + local u = v.unicode + if u then + v.tounicode = tounicode(u) + end + end + -- + -- However, when we use a bitmap font those vectors can't be constructed because + -- that information is not carried with those fonts (there is no name info, nor + -- proper index info, nor unicodes at that end). So, we provide it ourselves. + -- + if tfmdata.usedbitmap then + tfm.addtounicode(tfmdata) + end + end + -- + shared.processes = next(features) and tfm.setfeatures(tfmdata,features) or nil + -- + if size < 0 then + size = idiv(65536 * -size,100) + end + parameters.factor = 1 -- already scaled + parameters.units = 1000 -- just in case + parameters.size = size + parameters.slant = parameters.slant or parameters[1] or 0 + parameters.space = parameters.space or parameters[2] or 0 + parameters.space_stretch = parameters.space_stretch or parameters[3] or 0 + parameters.space_shrink = parameters.space_shrink or parameters[4] or 0 + parameters.x_height = parameters.x_height or parameters[5] or 0 + parameters.quad = parameters.quad or parameters[6] or 0 + parameters.extra_space = parameters.extra_space or parameters[7] or 0 + -- + constructors.enhanceparameters(parameters) -- official copies for us + -- + properties.private = properties.private or tfmdata.private or privateoffset + -- + if newtfmdata then + -- + -- We do nothing as we assume flat tfm files. It would become real messy + -- otherwise and I don't have something for testing on my system anyway. + -- + elseif constructors.resolvevirtualtoo then + fonts.loggers.register(tfmdata,file.suffix(filename),specification) -- strange, why here + local vfname = findbinfile(specification.name, 'ovf') + if vfname and vfname ~= "" then + local vfdata = loadvf(vfname,size) + if vfdata then + local chars = tfmdata.characters + for k,v in next, vfdata.characters do + chars[k].commands = v.commands + end + properties.virtualized = true + tfmdata.fonts = vfdata.fonts + tfmdata.type = "virtual" -- else nested calls with cummulative scaling + local fontlist = vfdata.fonts + local name = file.nameonly(filename) + for i=1,#fontlist do + local n = fontlist[i].name + local s = fontlist[i].size + local d = depth[filename] + s = constructors.scaled(s,vfdata.designsize) + if d > tfm.maxnestingdepth then + report_defining("too deeply nested virtual font %a with size %a, max nesting depth %s",n,s,tfm.maxnestingdepth) + fontlist[i] = { id = 0 } + elseif (d > 1) and (s > tfm.maxnestingsize) then + report_defining("virtual font %a exceeds size %s",n,s) + fontlist[i] = { id = 0 } + else + local t, id = constructors.readanddefine(n,s) + fontlist[i] = { id = id } + end + end + end + end + end + -- + properties.haskerns = true + properties.hasligatures = true + properties.hasitalics = true + resources.unicodes = { } + resources.lookuptags = { } + -- + depth[filename] = depth[filename] - 1 + -- + return tfmdata + else + depth[filename] = depth[filename] - 1 + end +end + +local function check_tfm(specification,fullname) -- we could split up like afm/otf + local foundname = findbinfile(fullname, 'tfm') or "" + if foundname == "" then + foundname = findbinfile(fullname, 'ofm') or "" -- not needed in context + end + if foundname == "" then + foundname = fonts.names.getfilename(fullname,"tfm") or "" + end + if foundname ~= "" then + specification.filename = foundname + specification.format = "ofm" + return read_from_tfm(specification) + elseif trace_defining then + report_defining("loading tfm with name %a fails",specification.name) + end +end + +readers.check_tfm = check_tfm + +function readers.tfm(specification) + local fullname = specification.filename or "" + if fullname == "" then + local forced = specification.forced or "" + if forced ~= "" then + fullname = specification.name .. "." .. forced + else + fullname = specification.name + end + end + return check_tfm(specification,fullname) +end + +readers.ofm = readers.tfm + +-- The reencoding acts upon the 'reencode' feature which can have values 'auto' or +-- an enc file. You can also specify a 'pfbfile' feature (but it defaults to the +-- tfm filename) and a 'bitmap' feature. When no enc file is givven (auto) we will +-- get the vectors from the pfb file. + +do + + local outfiles = { } + + local tfmcache = table.setmetatableindex(function(t,tfmdata) + local id = font.define(tfmdata) + t[tfmdata] = id + return id + end) + + local encdone = table.setmetatableindex("table") + + function tfm.reencode(tfmdata,specification) + + local features = specification.features + + if not features then + return + end + + local features = features.normal + + if not features then + return + end + + local tfmfile = file.basename(tfmdata.name) + local encfile = features.reencode -- or features.enc + local pfbfile = features.pfbfile -- or features.pfb + local bitmap = features.bitmap -- or features.pk + + if not encfile then + return + end + + local pfbfile = outfiles[tfmfile] + + if pfbfile == nil then + if bitmap then + pfbfile = false + elseif type(pfbfile) ~= "string" then + pfbfile = tfmfile + end + if type(pfbfile) == "string" then + pfbfile = file.addsuffix(pfbfile,"pfb") + -- pdf.mapline(tfmfile .. "<" .. pfbfile) + report_tfm("using type1 shapes from %a for %a",pfbfile,tfmfile) + else + report_tfm("using bitmap shapes for %a",tfmfile) + pfbfile = false -- use bitmap + end + outfiles[tfmfile] = pfbfile + end + + local encoding = false + local vector = false + + if type(pfbfile) == "string" then + local pfb = constructors.handlers.pfb + if pfb and pfb.loadvector then + local v, e = pfb.loadvector(pfbfile) + if v then + vector = v + end + if e then + encoding = e + end + end + end + if type(encfile) == "string" and encfile ~= "auto" then + encoding = fonts.encodings.load(file.addsuffix(encfile,"enc")) + if encoding then + encoding = encoding.vector + end + end + if not encoding then + report_tfm("bad encoding for %a, quitting",tfmfile) + return + end + + local unicoding = fonts.encodings.agl and fonts.encodings.agl.unicodes + local virtualid = tfmcache[tfmdata] + local tfmdata = table.copy(tfmdata) -- good enough for small fonts + local characters = { } + local originals = tfmdata.characters + local indices = { } + local parentfont = { "font", 1 } + local private = tfmdata.privateoffset or constructors.privateoffset + local reported = encdone[tfmfile][encfile] + + -- create characters table + + local backmap = vector and table.swapped(vector) + local done = { } -- prevent duplicate + + for index, name in sortedhash(encoding) do -- predictable order + local unicode = unicoding[name] + local original = originals[index] + if original then + if unicode then + original.unicode = unicode + else + unicode = private + private = private + 1 + if not reported then + report_tfm("glyph %a in font %a with encoding %a gets unicode %U",name,tfmfile,encfile,unicode) + end + end + characters[unicode] = original + indices[index] = unicode + original.name = name -- so one can lookup weird names + if backmap then + original.index = backmap[name] + else -- probably bitmap + original.commands = { parentfont, charcommand[index] } -- or "slot" + original.oindex = index + end + done[name] = true + elseif not done[name] then + report_tfm("bad index %a in font %a with name %a",index,tfmfile,name) + end + end + + encdone[tfmfile][encfile] = true + + -- redo kerns and ligatures + + for k, v in next, characters do + local kerns = v.kerns + if kerns then + local t = { } + for k, v in next, kerns do + local i = indices[k] + if i then + t[i] = v + end + end + v.kerns = next(t) and t or nil + end + local ligatures = v.ligatures + if ligatures then + local t = { } + for k, v in next, ligatures do + local i = indices[k] + if i then + t[i] = v + v.char = indices[v.char] + end + end + v.ligatures = next(t) and t or nil + end + end + + -- wrap up + + tfmdata.fonts = { { id = virtualid } } + tfmdata.characters = characters + tfmdata.fullname = tfmdata.fullname or tfmdata.name + tfmdata.psname = file.nameonly(pfbfile or tfmdata.name) + tfmdata.filename = pfbfile + tfmdata.encodingbytes = 2 + -- tfmdata.format = bitmap and "type3" or "type1" + tfmdata.format = "type1" + tfmdata.tounicode = 1 + tfmdata.embedding = "subset" + tfmdata.usedbitmap = bitmap and virtualid + tfmdata.private = private + + return tfmdata + end + +end + +-- This code adds a ToUnicode vector for bitmap fonts. We don't bother about +-- ranges because we have small fonts. it works ok with acrobat but fails with +-- the other viewers (they get confused by the bitmaps I guess). + +do + + local template = [[ +/CIDInit /ProcSet findresource begin + 12 dict begin + begincmap + /CIDSystemInfo << /Registry (TeX) /Ordering (bitmap-%s) /Supplement 0 >> def + /CMapName /TeX-bitmap-%s def + /CMapType 2 def + 1 begincodespacerange + <00> <FF> + endcodespacerange + %s beginbfchar +%s + endbfchar + endcmap +CMapName currentdict /CMap defineresource pop end +end +end +]] + + local flushstreamobject = lpdf and lpdf.flushstreamobject -- context + local setfontattributes = lpdf and lpdf.setfontattributes -- context + + if not flushstreamobject then + flushstreamobject = function(data) + return pdf.obj { immediate = true, type = "stream", string = data } -- generic + end + end + + if not setfontattributes then + setfontattributes = function(id,data) + return pdf.setfontattributes(id,data) -- generic + end + end + + function tfm.addtounicode(tfmdata) + local id = tfmdata.usedbitmap + local map = { } + local char = { } -- no need for range, hardly used + for k, v in next, tfmdata.characters do + local index = v.oindex + local tounicode = v.tounicode + if index and tounicode then + map[index] = tounicode + end + end + for k, v in sortedhash(map) do + char[#char+1] = format("<%02X> <%s>",k,v) + end + char = concat(char,"\n") + local stream = format(template,id,id,#char,char) + local reference = flushstreamobject(stream,nil,true) + setfontattributes(id,format("/ToUnicode %i 0 R",reference)) + end + +end + +-- Now we implement the regular features handlers. We need to convert the +-- tfm specific structures to opentype structures. In basemode they are +-- converted back so that is a bit of a waste but it's fast enough. + +do + + local everywhere = { ["*"] = { ["*"] = true } } -- or: { ["*"] = { "*" } } + local noflags = { false, false, false, false } + + local function enhance_normalize_features(data) + local ligatures = setmetatableindex("table") + local kerns = setmetatableindex("table") + local characters = data.characters + for u, c in next, characters do + local l = c.ligatures + local k = c.kerns + if l then + ligatures[u] = l + for u, v in next, l do + l[u] = { ligature = v.char } + end + c.ligatures = nil + end + if k then + kerns[u] = k + for u, v in next, k do + k[u] = v -- { v, 0 } + end + c.kerns = nil + end + end + + for u, l in next, ligatures do + for k, v in next, l do + local vl = v.ligature + local dl = ligatures[vl] + if dl then + for kk, vv in next, dl do + v[kk] = vv -- table.copy(vv) + end + end + end + end + + local features = { + gpos = { }, + gsub = { }, + } + local sequences = { + -- only filled ones + } + if next(ligatures) then + features.gsub.liga = everywhere + data.properties.hasligatures = true + sequences[#sequences+1] = { + features = { + liga = everywhere, + }, + flags = noflags, + name = "s_s_0", + nofsteps = 1, + order = { "liga" }, + type = "gsub_ligature", + steps = { + { + coverage = ligatures, + }, + }, + } + end + if next(kerns) then + features.gpos.kern = everywhere + data.properties.haskerns = true + sequences[#sequences+1] = { + features = { + kern = everywhere, + }, + flags = noflags, + name = "p_s_0", + nofsteps = 1, + order = { "kern" }, + type = "gpos_pair", + steps = { + { + format = "kern", + coverage = kerns, + }, + }, + } + end + data.resources.features = features + data.resources.sequences = sequences + data.shared.resources = data.shared.resources or resources + end + + registertfmenhancer("normalize features", enhance_normalize_features) + registertfmenhancer("check extra features", otfenhancers.enhance) + +end + +-- As with type one (afm) loading, we just use the opentype ones: + +registertfmfeature { + name = "mode", + description = "mode", + initializers = { + base = otf.modeinitializer, + node = otf.modeinitializer, + } +} + +registertfmfeature { + name = "features", + description = "features", + default = true, + initializers = { + base = otf.basemodeinitializer, + node = otf.nodemodeinitializer, + }, + processors = { + node = otf.featuresprocessor, + } +} diff --git a/tex/generic/context/luatex/luatex-fonts.lua b/tex/generic/context/luatex/luatex-fonts.lua index 06fb682f3..85fe1ae97 100644 --- a/tex/generic/context/luatex/luatex-fonts.lua +++ b/tex/generic/context/luatex/luatex-fonts.lua @@ -283,7 +283,7 @@ if non_generic_context.luatex_fonts.skip_loading ~= true then -- And for traditional TeX fonts. - loadmodule('font-tfm.lua') + loadmodule('luatex-fonts-tfm.lua') -- Some common code. |