summaryrefslogtreecommitdiff
path: root/tex
diff options
context:
space:
mode:
authorHans Hagen <pragma@wxs.nl>2013-01-17 18:16:00 +0100
committerHans Hagen <pragma@wxs.nl>2013-01-17 18:16:00 +0100
commit9c266934ab4fde7d71d13c607ac5e5e13bedf1ff (patch)
treec4bfef6ef5e6ea9c41c52b90846f175fa91ce9f3 /tex
parentde678e954438110850d93c5f35a0d6bf14129901 (diff)
downloadcontext-9c266934ab4fde7d71d13c607ac5e5e13bedf1ff.tar.gz
beta 2013.01.17 18:16
Diffstat (limited to 'tex')
-rw-r--r--tex/context/base/bibl-tra.mkiv16
-rw-r--r--tex/context/base/cont-new.mkii2
-rw-r--r--tex/context/base/cont-new.mkiv2
-rw-r--r--tex/context/base/context-version.pdfbin4126 -> 4125 bytes
-rw-r--r--tex/context/base/context-version.pngbin39975 -> 40102 bytes
-rw-r--r--tex/context/base/context.mkii2
-rw-r--r--tex/context/base/context.mkiv2
-rw-r--r--tex/context/base/font-odv.lua3074
-rw-r--r--tex/context/base/font-otn.lua84
-rw-r--r--tex/context/base/luat-env.lua11
-rw-r--r--tex/context/base/luat-lib.mkiv1
-rw-r--r--tex/context/base/math-tag.lua2
-rw-r--r--tex/context/base/mlib-ctx.lua14
-rw-r--r--tex/context/base/mlib-pps.lua4
-rw-r--r--tex/context/base/mlib-run.lua7
-rw-r--r--tex/context/base/node-fin.lua2
-rw-r--r--tex/context/base/node-fnt.lua4
-rw-r--r--tex/context/base/node-ini.lua2
-rw-r--r--tex/context/base/node-ini.mkiv1
-rw-r--r--tex/context/base/node-inj.lua2
-rw-r--r--tex/context/base/spac-chr.lua2
-rw-r--r--tex/context/base/spac-hor.mkiv4
-rw-r--r--tex/context/base/status-files.pdfbin24750 -> 24704 bytes
-rw-r--r--tex/context/base/status-lua.pdfbin208234 -> 208162 bytes
-rw-r--r--tex/context/base/trac-inf.lua19
-rw-r--r--tex/context/base/typo-dir.lua1
-rw-r--r--tex/context/base/util-lua.lua7
-rw-r--r--tex/generic/context/luatex/luatex-fonts-merged.lua235
28 files changed, 3222 insertions, 278 deletions
diff --git a/tex/context/base/bibl-tra.mkiv b/tex/context/base/bibl-tra.mkiv
index 914470fbe..3eb885eef 100644
--- a/tex/context/base/bibl-tra.mkiv
+++ b/tex/context/base/bibl-tra.mkiv
@@ -1475,14 +1475,24 @@
\bibresetrefsep
\processcommalist[#1]\dobibauthornumref}
+% \def\dobibauthornumref#1%
+% {\bibinsertrefsep
+% \doifbibreferencefoundelse{#1}
+% {\begingroup
+% \bibgetvara{#1}%
+% \bibalternative\c!inbetween
+% \setuppublications[\c!refcommand=num]%
+% \cite[#1]%
+% \endgroup}
+% {}}
+
\def\dobibauthornumref#1%
{\bibinsertrefsep
\doifbibreferencefoundelse{#1}
{\begingroup
- \bibgetvara{#1}%
+ \cite[\c!left=,\c!right=,\c!alternative=\v!author][#1]%
\bibalternative\c!inbetween
- \setuppublications[\c!refcommand=num]%
- \cite[#1]%
+ \cite[num][#1]%
\endgroup}
{}}
diff --git a/tex/context/base/cont-new.mkii b/tex/context/base/cont-new.mkii
index 3ce67992e..e1d8f6f91 100644
--- a/tex/context/base/cont-new.mkii
+++ b/tex/context/base/cont-new.mkii
@@ -11,7 +11,7 @@
%C therefore copyrighted by \PRAGMA. See mreadme.pdf for
%C details.
-\newcontextversion{2013.01.13 23:10}
+\newcontextversion{2013.01.17 18:16}
%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/cont-new.mkiv b/tex/context/base/cont-new.mkiv
index 18153995f..6339c3793 100644
--- a/tex/context/base/cont-new.mkiv
+++ b/tex/context/base/cont-new.mkiv
@@ -11,7 +11,7 @@
%C therefore copyrighted by \PRAGMA. See mreadme.pdf for
%C details.
-\newcontextversion{2013.01.13 23:10}
+\newcontextversion{2013.01.17 18:16}
%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/context-version.pdf b/tex/context/base/context-version.pdf
index 43f4790bd..66ce96cb4 100644
--- a/tex/context/base/context-version.pdf
+++ b/tex/context/base/context-version.pdf
Binary files differ
diff --git a/tex/context/base/context-version.png b/tex/context/base/context-version.png
index 3157fb849..4d1a73000 100644
--- a/tex/context/base/context-version.png
+++ b/tex/context/base/context-version.png
Binary files differ
diff --git a/tex/context/base/context.mkii b/tex/context/base/context.mkii
index 6abbe0653..e0c952341 100644
--- a/tex/context/base/context.mkii
+++ b/tex/context/base/context.mkii
@@ -20,7 +20,7 @@
%D your styles an modules.
\edef\contextformat {\jobname}
-\edef\contextversion{2013.01.13 23:10}
+\edef\contextversion{2013.01.17 18:16}
%D For those who want to use this:
diff --git a/tex/context/base/context.mkiv b/tex/context/base/context.mkiv
index ded53e1cf..ab199bceb 100644
--- a/tex/context/base/context.mkiv
+++ b/tex/context/base/context.mkiv
@@ -25,7 +25,7 @@
%D up and the dependencies are more consistent.
\edef\contextformat {\jobname}
-\edef\contextversion{2013.01.13 23:10}
+\edef\contextversion{2013.01.17 18:16}
%D For those who want to use this:
diff --git a/tex/context/base/font-odv.lua b/tex/context/base/font-odv.lua
new file mode 100644
index 000000000..eb8f7a9da
--- /dev/null
+++ b/tex/context/base/font-odv.lua
@@ -0,0 +1,3074 @@
+if not modules then modules = { } end modules ['font-odv'] = {
+ version = 1.001,
+ comment = "companion to font-ini.mkiv",
+ author = "Kai Eigner, TAT Zetwerk / Hans Hagen, PRAGMA ADE",
+ copyright = "TAT Zetwerk / PRAGMA ADE / ConTeXt Development Team",
+ license = "see context related readme files"
+}
+
+-- Kai: we're leaking nodes (happens when assigning start nodes behind start, also
+-- in the original code) so this needs to be sorted out. As I touched nearly all code,
+-- reshuffled, etc. etc. (imagine how much can get messed up in nearly a week work) it
+-- could be that I introduced bugs. There is more to gain (esp in the functions applied
+-- to a range) but I'll do that when everything works as expected.
+
+-- A few remarks:
+--
+-- This code is a partial rewrite of the code that deals with devanagari. The data and logic
+-- is by Kai Eigner and based based on Microsoft's OpenType specifications for specific
+-- scripts, but with a few improvements. More information can be found at:
+--
+-- deva: http://www.microsoft.com/typography/OpenType%20Dev/devanagari/introO.mspx
+-- dev2: http://www.microsoft.com/typography/OpenType%20Dev/devanagari/intro.mspx
+--
+-- Interesting is that Kai managed to write this on top of the existing otf handler. Only a
+-- few extensions were needed, like a few more analyzing states and dealing with changed
+-- head nodes in the core scanner as that only happens here. There's a lot going on here
+-- and it's only because I touched nearly all code that I got a bit of a picture of what
+-- happens. For in-depth knowledge one needs to consult Kai.
+--
+-- The rewrite mostly deals with efficiency, both in terms of speed and code. We also made
+-- sure that it suits generic use as well as use in ConTeXt. I removed some buglets but can
+-- as well have messed up the logic by doing this. For this we keep the original around
+-- as that serves as reference. I kept the comments but added a few more. Due to the lots
+-- of reshuffling glyphs quite some leaks occur(red) but once I'm satisfied with the rewrite
+-- I'll weed them. I also integrated initialization etc into the regular mechanisms.
+--
+-- In the meantime, we're down from 25.5-3.5=22 seconds to 17.7-3.5=14.2 seconds for a 100
+-- page sample with both variants so it's worth the effort. Due to the method chosen it will
+-- never be real fast. If I ever become a power user I'll have a go at some further speed
+-- up. I will rename some functions (and features) once we don't need to check the original
+-- code. We now use a special subset sequence for use inside the analyzer (after all we could
+-- can store this in the dataset and save redundant analysis).
+--
+-- I might go for an array approach with respect to attributes (and reshuffling). Easier.
+--
+-- Hans Hagen, PRAGMA-ADE, Hasselt NL
+
+-- Matras: according to Microsoft typography specifications "up to one of each type:
+-- pre-, above-, below- or post- base", but that does not seem to be right. It could
+-- become an option.
+--
+-- The next code looks weird anyway: the "and boolean" should move inside the if
+-- or we should check differently (case vs successive).
+--
+-- local function ms_matra(c)
+-- local prebase, abovebase, belowbase, postbase = true, true, true, true
+-- local n = c.next
+-- while n and n.id == glyph_code and n.subtype<256 and n.font == font do
+-- local char = n.char
+-- if not dependent_vowel[char] then
+-- break
+-- elseif pre_mark[char] and prebase then
+-- prebase = false
+-- elseif above_mark[char] and abovebase then
+-- abovebase = false
+-- elseif below_mark[char] and belowbase then
+-- belowbase = false
+-- elseif post_mark[char] and postbase then
+-- postbase = false
+-- else
+-- return c
+-- end
+-- c = c.next
+-- end
+-- return c
+-- end
+
+-- todo: first test for font then for subtype
+
+local insert, imerge = table.insert, table.imerge
+local next = next
+
+local trace_analyzing = false trackers.register("otf.analyzing", function(v) trace_analyzing = v end)
+local report_devanagari = logs.reporter("otf","devanagari")
+
+fonts = fonts or { }
+fonts.analyzers = fonts.analyzers or { }
+fonts.analyzers.methods = fonts.analyzers.methods or { node = { otf = { } } }
+
+local otf = fonts.handlers.otf
+
+local nodecodes = nodes.nodecodes
+local glyph_code = nodecodes.glyph
+
+local handlers = otf.handlers
+local methods = fonts.analyzers.methods
+
+local otffeatures = fonts.constructors.newfeatures("otf")
+local registerotffeature = otffeatures.register
+
+local processcharacters = nodes.handlers.characters
+
+local set_attribute = node.set_attribute
+local unset_attribute = node.unset_attribute
+local has_attribute = node.has_attribute
+local insert_node_after = node.insert_after
+local copy_node = node.copy
+local free_node = node.free
+local remove_node = node.remove
+local flush_list = node.flush_list
+
+local fontdata = fonts.hashes.identifiers
+
+local a_state = attributes.private('state')
+local a_syllabe = attributes.private('syllabe')
+
+local dotted_circle = 0x25CC
+
+-- In due time there will be entries here for scripts like Bengali, Gujarati,
+-- Gurmukhi, Kannada, Malayalam, Oriya, Tamil, Telugu. Feel free to provide the
+-- code points.
+
+local consonant = {
+ [0x0915] = true, [0x0916] = true, [0x0917] = true, [0x0918] = true,
+ [0x0919] = true, [0x091A] = true, [0x091B] = true, [0x091C] = true,
+ [0x091D] = true, [0x091E] = true, [0x091F] = true, [0x0920] = true,
+ [0x0921] = true, [0x0922] = true, [0x0923] = true, [0x0924] = true,
+ [0x0925] = true, [0x0926] = true, [0x0927] = true, [0x0928] = true,
+ [0x0929] = true, [0x092A] = true, [0x092B] = true, [0x092C] = true,
+ [0x092D] = true, [0x092E] = true, [0x092F] = true, [0x0930] = true,
+ [0x0931] = true, [0x0932] = true, [0x0933] = true, [0x0934] = true,
+ [0x0935] = true, [0x0936] = true, [0x0937] = true, [0x0938] = true,
+ [0x0939] = true, [0x0958] = true, [0x0959] = true, [0x095A] = true,
+ [0x095B] = true, [0x095C] = true, [0x095D] = true, [0x095E] = true,
+ [0x095F] = true, [0x0979] = true, [0x097A] = true,
+}
+
+local independent_vowel = {
+ [0x0904] = true, [0x0905] = true, [0x0906] = true, [0x0907] = true,
+ [0x0908] = true, [0x0909] = true, [0x090A] = true, [0x090B] = true,
+ [0x090C] = true, [0x090D] = true, [0x090E] = true, [0x090F] = true,
+ [0x0910] = true, [0x0911] = true, [0x0912] = true, [0x0913] = true,
+ [0x0914] = true, [0x0960] = true, [0x0961] = true, [0x0972] = true,
+ [0x0973] = true, [0x0974] = true, [0x0975] = true, [0x0976] = true,
+ [0x0977] = true,
+}
+
+local dependent_vowel = { -- matra
+ [0x093A] = true, [0x093B] = true, [0x093E] = true, [0x093F] = true,
+ [0x0940] = true, [0x0941] = true, [0x0942] = true, [0x0943] = true,
+ [0x0944] = true, [0x0945] = true, [0x0946] = true, [0x0947] = true,
+ [0x0948] = true, [0x0949] = true, [0x094A] = true, [0x094B] = true,
+ [0x094C] = true, [0x094E] = true, [0x094F] = true, [0x0955] = true,
+ [0x0956] = true, [0x0957] = true, [0x0962] = true, [0x0963] = true,
+}
+
+local vowel_modifier = {
+ [0x0900] = true, [0x0901] = true, [0x0902] = true, [0x0903] = true,
+ -- A8E0 - A8F1 are cantillation marks for the Samaveda and may not belong here.
+ [0xA8E0] = true, [0xA8E1] = true, [0xA8E2] = true, [0xA8E3] = true,
+ [0xA8E4] = true, [0xA8E5] = true, [0xA8E6] = true, [0xA8E7] = true,
+ [0xA8E8] = true, [0xA8E9] = true, [0xA8EA] = true, [0xA8EB] = true,
+ [0xA8EC] = true, [0xA8ED] = true, [0xA8EE] = true, [0xA8EF] = true,
+ [0xA8F0] = true, [0xA8F1] = true,
+}
+
+local stress_tone_mark = {
+ [0x0951] = true, [0x0952] = true, [0x0953] = true, [0x0954] = true,
+}
+
+local nukta = {
+ [0x093C] = true,
+}
+
+local halant = {
+ [0x094D] = true,
+}
+
+local ra = {
+ [0x0930] = true,
+}
+
+local anudatta = {
+ [0x0952] = true,
+}
+
+local nbsp = { -- might become a constant instead of table
+ [0x00A0] = true,
+}
+
+local zwnj = { -- might become a constant instead of table
+ [0x200C] = true,
+}
+
+local zwj = { -- might become a constant instead of table
+ [0x200D] = true,
+}
+
+local zw_char = {
+ [0x200C] = true,
+ [0x200D] = true,
+}
+
+local pre_mark = {
+ [0x093F] = true, [0x094E] = true,
+}
+
+local above_mark = {
+ [0x0900] = true, [0x0901] = true, [0x0902] = true, [0x093A] = true,
+ [0x0945] = true, [0x0946] = true, [0x0947] = true, [0x0948] = true,
+ [0x0951] = true, [0x0953] = true, [0x0954] = true, [0x0955] = true,
+ [0xA8E0] = true, [0xA8E1] = true, [0xA8E2] = true, [0xA8E3] = true,
+ [0xA8E4] = true, [0xA8E5] = true, [0xA8E6] = true, [0xA8E7] = true,
+ [0xA8E8] = true, [0xA8E9] = true, [0xA8EA] = true, [0xA8EB] = true,
+ [0xA8EC] = true, [0xA8ED] = true, [0xA8EE] = true, [0xA8EF] = true,
+ [0xA8F0] = true, [0xA8F1] = true,
+}
+
+local below_mark = {
+ [0x093C] = true, [0x0941] = true, [0x0942] = true, [0x0943] = true,
+ [0x0944] = true, [0x094D] = true, [0x0952] = true, [0x0956] = true,
+ [0x0957] = true, [0x0962] = true, [0x0963] = true,
+}
+
+local post_mark = {
+ [0x0903] = true, [0x093B] = true, [0x093E] = true, [0x0940] = true,
+ [0x0949] = true, [0x094A] = true, [0x094B] = true, [0x094C] = true,
+ [0x094F] = true,
+}
+
+local mark_four = { } -- As we access these frequently an extra hash is used.
+
+for k, v in next, pre_mark do mark_four[k] = pre_mark end
+for k, v in next, above_mark do mark_four[k] = above_mark end
+for k, v in next, below_mark do mark_four[k] = below_mark end
+for k, v in next, post_mark do mark_four[k] = post_mark end
+
+local mark_above_below_post = { }
+
+for k, v in next, above_mark do mark_above_below_post[k] = above_mark end
+for k, v in next, below_mark do mark_above_below_post[k] = below_mark end
+for k, v in next, post_mark do mark_above_below_post[k] = post_mark end
+
+-- Again, this table can be extended for other scripts than devanagari. Actually,
+-- for ConTeXt this kind of dat is kept elsewhere so eventually we might move
+-- tables to someplace else.
+
+local reorder_class = {
+ [0x0930] = "before postscript",
+ [0x093F] = "before half",
+ [0x0940] = "after subscript",
+ [0x0941] = "after subscript",
+ [0x0942] = "after subscript",
+ [0x0943] = "after subscript",
+ [0x0944] = "after subscript",
+ [0x0945] = "after subscript",
+ [0x0946] = "after subscript",
+ [0x0947] = "after subscript",
+ [0x0948] = "after subscript",
+ [0x0949] = "after subscript",
+ [0x094A] = "after subscript",
+ [0x094B] = "after subscript",
+ [0x094C] = "after subscript",
+ [0x0962] = "after subscript",
+ [0x0963] = "after subscript",
+ [0x093E] = "after subscript",
+}
+
+-- We use some pseudo features as we need to manipulate the nodelist based
+-- on information in the font as well as already applied features.
+
+local dflt_true = {
+ dflt = true
+}
+
+local dev2_defaults = {
+ dev2 = dflt_true,
+}
+
+local deva_defaults = {
+ dev2 = dflt_true,
+ deva = dflt_true,
+}
+
+local false_flags = { false, false, false, false }
+
+local both_joiners_true = { [0x200C] = true, [0x200D] = true }
+
+local sequence_reorder_matras = {
+ chain = 0,
+ features = { dv01 = dev2_defaults },
+ flags = false_flags,
+ name = "dv01_reorder_matras",
+ subtables = { "dv01_reorder_matras" },
+ type = "devanagari_reorder_matras",
+}
+
+local sequence_reorder_reph = {
+ chain = 0,
+ features = { dv02 = dev2_defaults },
+ flags = false_flags,
+ name = "dv02_reorder_reph",
+ subtables = { "dv02_reorder_reph" },
+ type = "devanagari_reorder_reph",
+}
+
+local sequence_reorder_pre_base_reordering_consonants = {
+ chain = 0,
+ features = { dv03 = dev2_defaults },
+ flags = false_flags,
+ name = "dv03_reorder_pre_base_reordering_consonants",
+ subtables = { "dv03_reorder_pre_base_reordering_consonants" },
+ type = "devanagari_reorder_pre_base_reordering_consonants",
+}
+
+local sequence_remove_joiners = {
+ chain = 0,
+ features = { dv04 = deva_defaults },
+ flags = false_flags,
+ name = "dv04_remove_joiners",
+ subtables = { "dv04_remove_joiners" },
+ type = "devanagari_remove_joiners",
+}
+
+-- Looping over feature twice as efficient as looping over basic forms (some
+-- 350 checks instead of 750 for one font). This is something to keep an eye on
+-- as it might depends on the font. Not that it's a bottleneck.
+
+local basic_shaping_forms = {
+ nukt = true,
+ akhn = true,
+ rphf = true,
+ pref = true,
+ rkrf = true,
+ blwf = true,
+ half = true,
+ pstf = true,
+ vatu = true,
+ cjct = true,
+}
+
+local function initializedevanagi(tfmdata)
+ local script, language = otf.scriptandlanguage(tfmdata,attr) -- take fast variant
+ if script == "deva" or script == "dev2" then
+ local resources = tfmdata.resources
+ local lookuphash = resources.lookuphash
+ if not lookuphash["dv01"] then
+ report_devanagari("adding devanagari features to font")
+ --
+ local features = resources.features
+ local gsubfeatures = features.gsub
+ local sequences = resources.sequences
+ local sharedfeatures = tfmdata.shared.features
+ --
+ local lastmatch = 0
+ for s=1,#sequences do -- classify chars
+ local features = sequences[s].features
+ if features then
+ for k, v in next, features do
+ if basic_shaping_forms[k] then
+ lastmatch = s
+ end
+ end
+ end
+ end
+ local insertindex = lastmatch + 1
+ --
+ lookuphash["dv04_remove_joiners"] = both_joiners_true
+ --
+ gsubfeatures["dv01"] = dev2_defaults -- reorder matras
+ gsubfeatures["dv02"] = dev2_defaults -- reorder reph
+ gsubfeatures["dv03"] = dev2_defaults -- reorder pre base reordering consonants
+ gsubfeatures["dv04"] = deva_defaults -- remove joiners
+ --
+ insert(sequences,insertindex,sequence_reorder_pre_base_reordering_consonants)
+ insert(sequences,insertindex,sequence_reorder_reph)
+ insert(sequences,insertindex,sequence_reorder_matras)
+ insert(sequences,insertindex,sequence_remove_joiners)
+ --
+ if script == "deva" then
+ sharedfeatures["dv04"] = true -- dv04_remove_joiners
+ end
+ --
+ if script == "dev2" then
+ sharedfeatures["dv01"] = true -- dv01_reorder_matras
+ sharedfeatures["dv02"] = true -- dv02_reorder_reph
+ sharedfeatures["dv03"] = true -- dv03_reorder_pre_base_reordering_consonants
+ sharedfeatures["dv04"] = true -- dv04_remove_joiners
+ end
+ --
+ end
+ end
+end
+
+registerotffeature {
+ name = "devanagari",
+ description = "inject additional features",
+ default = true,
+ initializers = {
+ node = initializedevanagi,
+ },
+}
+
+-- hm, this is applied to one character:
+
+local function deva_initialize(font,attr)
+
+ local tfmdata = fontdata[font]
+ local resources = tfmdata.resources
+ local lookuphash = resources.lookuphash
+
+ local datasets = otf.dataset(tfmdata,font,attr)
+ local devanagaridata = datasets.devanagari
+
+ if devanagaridata then -- maybe also check for e.g. reph
+
+ return lookuphash, devanagaridata.reph, devanagaridata.vattu, devanagaridata.blwfcache
+
+ else
+
+ devanagaridata = { }
+ datasets.devanagari = devanagaridata
+
+ local reph = false
+ local vattu = false
+ local blwfcache = { }
+
+ local sequences = resources.sequences
+
+ for s=1,#sequences do -- triggers creation of dataset
+ -- local sequence = sequences[s]
+ local dataset = datasets[s]
+ if dataset and dataset[1] then -- value
+ local kind = dataset[4]
+ if kind == "rphf" then
+ -- deva
+ reph = true
+ elseif kind == "blwf" then
+ -- deva
+ vattu = true
+ -- dev2
+ -- local subtables = sequence.subtables -- dataset[5].subtables
+ local subtables = dataset[5].subtables
+ for i=1,#subtables do
+ local lookupname = subtables[i]
+ local lookupcache = lookuphash[lookupname]
+ if lookupcache then
+ for k, v in next, lookupcache do
+ blwfcache[k] = blwfcache[k] or v
+ end
+ end
+ end
+ end
+ end
+ end
+
+ devanagaridata.reph = reph
+ devanagaridata.vattu = vattu
+ devanagaridata.blwfcache = blwfcache
+
+ return lookuphash, reph, vattu, blwfcache
+
+ end
+
+end
+
+local function deva_reorder(head,start,stop,font,attr)
+
+ local lookuphash, reph, vattu, blwfcache = deva_initialize(font,attr) -- could be inlines but ugly
+
+ local current = start
+ local n = start.next
+ local base = nil
+ local firstcons = nil
+ local lastcons = nil
+ local basefound = false
+
+ if ra[start.char] and halant[n.char] and reph then
+ -- if syllable starts with Ra + H and script has 'Reph' then exclude Reph
+ -- from candidates for base consonants
+ if n == stop then
+ return head, stop
+ end
+ if zwj[n.next.char] then
+ current = start
+ else
+ current = n.next
+ set_attribute(start,a_state,5) -- rphf
+ end
+ end
+
+ if nbsp[current.char] then
+ -- Stand Alone cluster
+ if current == stop then
+ stop = stop.prev
+ head = remove_node(head, current)
+ free_node(current)
+ return head, stop
+ else
+ base, firstcons, lastcons = current, current, current
+ current = current.next
+ if current ~= stop then
+ if nukta[current.char] then
+ current = current.next
+ end
+ if zwj[current.char] then
+ if current ~= stop then
+ local next = current.next
+ if next ~= stop and halant[next.char] then
+ current = next
+ next = current.next
+ local tmp = next.next
+ local changestop = next == stop
+ local tempcurrent = copy_node(next)
+ local nextcurrent = copy_node(current)
+ tempcurrent.next = nextcurrent
+ nextcurrent.prev = tempcurrent
+ set_attribute(tempcurrent,a_state,8) --blwf
+ tempcurrent = processcharacters(tempcurrent)
+ unset_attribute(tempcurrent,a_state)
+ if next.char == tempcurrent.char then
+ flush_list(tempcurrent)
+ local n = copy_node(current)
+ current.char = dotted_circle
+ head = insert_node_after(head, current, n)
+ else
+ current.char = tempcurrent.char -- (assumes that result of blwf consists of one node)
+ local freenode = current.next
+ current.next = tmp
+ tmp.prev = current
+ free_node(freenode)
+ flush_list(tempcurrent)
+ if changestop then
+ stop = current
+ end
+ end
+ end
+ end
+ end
+ end
+ end
+ end
+
+ while not basefound do
+ -- find base consonant
+ if consonant[current.char] then
+ set_attribute(current,a_state,6) -- half
+ if not firstcons then
+ firstcons = current
+ end
+ lastcons = current
+ if not base then
+ base = current
+ elseif blwfcache[current.char] then
+ -- consonant has below-base (or post-base) form
+ set_attribute(current,a_state,8) -- blwf
+ else
+ base = current
+ end
+ end
+ basefound = current == stop
+ current = current.next
+ end
+
+ if base ~= lastcons then
+ -- if base consonant is not last one then move halant from base consonant to last one
+ local np = base
+ local n = base.next
+ if nukta[n.char] then
+ np = n
+ n = n.next
+ end
+ if halant[n.char] then
+ if lastcons ~= stop then
+ local ln = lastcons.next
+ if nukta[ln.char] then
+ lastcons = ln
+ end
+ end
+ -- local np = n.prev
+ local nn = n.next
+ local ln = lastcons.next -- what if lastcons is nn ?
+ np.next = nn
+ nn.prev = np
+ lastcons.next = n
+ if ln then
+ ln.prev = n
+ end
+ n.next = ln
+ n.prev = lastcons
+ if lastcons == stop then
+ stop = n
+ end
+ end
+ end
+
+ n = start.next
+ if ra[start.char] and halant[n.char] and not (n ~= stop and zw_char[n.next.char]) then
+ -- if syllable starts with Ra + H then move this combination so that it follows either:
+ -- the post-base 'matra' (if any) or the base consonant
+ local matra = base
+ if base ~= stop then
+ local next = base.next
+ if dependent_vowel[next.char] then
+ matra = next
+ end
+ end
+ -- [sp][start][n][nn] [matra|base][?]
+ -- [matra|base][start] [n][?] [sp][nn]
+ local sp = start.prev
+ local nn = n.next
+ local mn = matra.next
+ if sp then
+ sp.next = nn
+ end
+ nn.prev = sp
+ matra.next = start
+ start.prev = matra
+ n.next = mn
+ if mn then
+ mn.prev = n
+ end
+ if head == start then
+ head = nn
+ end
+ start = nn
+ if matra == stop then
+ stop = n
+ end
+ end
+
+ local current = start
+ while current ~= stop do
+ local next = current.next
+ if next ~= stop and halant[next.char] and zwnj[next.next.char] then
+ unset_attribute(current,a_state)
+ end
+ current = next
+ end
+
+ if base ~= stop and has_attribute(base,a_state) then
+ local next = base.next
+ if halant[next.char] and not (next ~= stop and zwj[next.next.char]) then
+ unset_attribute(base,a_state)
+ end
+ end
+
+ -- ToDo: split two- or three-part matras into their parts. Then, move the left 'matra' part to the beginning of the syllable.
+ -- Not necessary for Devanagari. However it is necessay for other scripts, such as Tamil (e.g. TAMIL VOWEL SIGN O - 0BCA)
+
+ -- classify consonants and 'matra' parts as pre-base, above-base (Reph), below-base or post-base, and group elements of the syllable (consonants and 'matras') according to this classification
+
+ local current, allreordered, moved = start, false, { [base] = true }
+ local a, b, p, bn = base, base, base, base.next
+ if base ~= stop and nukta[bn.char] then
+ a, b, p = bn, bn, bn
+ end
+ while not allreordered do
+ -- current is always consonant
+ local c = current
+ local n = current.next
+ local l = nil -- used ?
+ if c ~= stop then
+ if nukta[n.char] then
+ c = n
+ n = n.next
+ end
+ if c ~= stop then
+ if halant[n.char] then
+ c = n
+ n = n.next
+ end
+ while c ~= stop and dependent_vowel[n.char] do
+ c = n
+ n = n.next
+ end
+ if c ~= stop then
+ if vowel_modifier[n.char] then
+ c = n
+ n = n.next
+ end
+ if c ~= stop and stress_tone_mark[n.char] then
+ c = n
+ n = n.next
+ end
+ end
+ end
+ end
+ local bp = firstcons.prev
+ local cn = current.next
+ local last = c.next
+ while cn ~= last do
+ -- move pre-base matras...
+ if pre_mark[cn.char] then
+ if bp then
+ bp.next = cn
+ end
+ local next = cn.next
+ local prev = cn.prev
+ if next then
+ next.prev = prev
+ end
+ prev.next = next
+ if cn == stop then
+ stop = prev
+ end
+ cn.prev = bp
+ cn.next = firstcons
+ firstcons.prev = cn
+ if firstcons == start then
+ if head == start then
+ head = cn
+ end
+ start = cn
+ end
+ break
+ end
+ cn = cn.next
+ end
+ allreordered = c == stop
+ current = c.next
+ end
+
+ if reph or vattu then
+ local current, cns = start, nil
+ while current ~= stop do
+ local c = current
+ local n = current.next
+ if ra[current.char] and halant[n.char] then
+ c = n
+ n = n.next
+ local b, bn = base, base
+ while bn ~= stop do
+ local next = bn.next
+ if dependent_vowel[next.char] then
+ b = next
+ end
+ bn = next
+ end
+ if has_attribute(current,a_state) == 5 then
+ -- position Reph (Ra + H) after post-base 'matra' (if any) since these
+ -- become marks on the 'matra', not on the base glyph
+ if b ~= current then
+ if current == start then
+ if head == start then
+ head = n
+ end
+ start = n
+ end
+ if b == stop then
+ stop = c
+ end
+ local prev = current.prev
+ if prev then
+ prev.next = n
+ end
+ if n then
+ n.prev = prev
+ end
+ local next = b.next
+ c.next = next
+ if next then
+ next.prev = c
+ end
+ c.next = next
+ b.next = current
+ current.prev = b
+ end
+ elseif cns and cns.next ~= current then
+ -- position below-base Ra (vattu) following the consonants on which it is placed (either the base consonant or one of the pre-base consonants)
+ local cp, cnsn = current.prev, cns.next
+ if cp then
+ cp.next = n
+ end
+ if n then
+ n.prev = cp
+ end
+ cns.next = current
+ current.prev = cns
+ c.next = cnsn
+ if cnsn then
+ cnsn.prev = c
+ end
+ if c == stop then
+ stop = cp
+ break
+ end
+ current = n.prev
+ end
+ else
+ local char = current.char
+ if consonant[char] or nbsp[char] then -- maybe combined hash
+ cns = current
+ local next = cns.next
+ if halant[next.char] then
+ cns = next
+ end
+ end
+ end
+ current = current.next
+ end
+ end
+
+ if nbsp[base.char] then
+ head = remove_node(head,base)
+ free_node(base)
+ end
+
+ return head, stop
+end
+
+-- If a pre-base matra character had been reordered before applying basic features,
+-- the glyph can be moved closer to the main consonant based on whether half-forms had been formed.
+-- Actual position for the matra is defined as “after last standalone halant glyph,
+-- after initial matra position and before the main consonant”.
+-- If ZWJ or ZWNJ follow this halant, position is moved after it.
+
+-- so we break out ... this is only done for the first 'word' (if we feed words we can as
+-- well test for non glyph.
+
+function handlers.devanagari_reorder_matras(start,kind,lookupname,replacement) -- no leak
+ local current = start -- we could cache attributes here
+ local startfont = start.font
+ local startattr = has_attribute(start,a_syllabe)
+ -- can be fast loop
+ while current and current.id == glyph_code and current.subtype<256 and current.font == font and has_attribute(current,a_syllabe) == startattr do
+ local next = current.next
+ if halant[current.char] and not has_attribute(current,a_state) then
+ if next and next.id == glyph_code and next.subtype<256 and next.font == font and has_attribute(next,a_syllabe) == startattr and zw_char[next.char] then
+ current = next
+ end
+ local startnext = start.next
+-- local startprev = start.prev
+-- startnext.prev = startprev
+-- if startprev then
+-- startprev.next = startnext
+-- end
+remove_node(start,start)
+ local next = current.next
+ if next then
+ next.prev = start
+ end
+ start.next = next
+ current.next = start
+ start.prev = current
+ start = startnext
+ break
+ end
+ current = next
+ end
+ return start, true
+end
+
+-- todo: way more caching of attributes and font
+
+-- Reph’s original position is always at the beginning of the syllable, (i.e. it is not reordered at the character reordering stage).
+-- However, it will be reordered according to the basic-forms shaping results.
+-- Possible positions for reph, depending on the script, are; after main, before post-base consonant forms,
+-- and after post-base consonant forms.
+
+-- 1 If reph should be positioned after post-base consonant forms, proceed to step 5.
+-- 2 If the reph repositioning class is not after post-base: target position is after the first explicit halant glyph between
+-- the first post-reph consonant and last main consonant. If ZWJ or ZWNJ are following this halant, position is moved after it.
+-- If such position is found, this is the target position. Otherwise, proceed to the next step.
+-- Note: in old-implementation fonts, where classifications were fixed in shaping engine,
+-- there was no case where reph position will be found on this step.
+-- 3 If reph should be repositioned after the main consonant: from the first consonant not ligated with main,
+-- or find the first consonant that is not a potential pre-base reordering Ra.
+-- 4 If reph should be positioned before post-base consonant, find first post-base classified consonant not ligated with main.
+-- If no consonant is found, the target position should be before the first matra, syllable modifier sign or vedic sign.
+-- 5 If no consonant is found in steps 3 or 4, move reph to a position immediately before the first post-base matra,
+-- syllable modifier sign or vedic sign that has a reordering class after the intended reph position.
+-- For example, if the reordering position for reph is post-main, it will skip above-base matras that also have a post-main position.
+-- 6 Otherwise, reorder reph to the end of the syllable.
+
+-- hm, this only looks at the start of a nodelist ... is this supposed to be line based?
+
+function handlers.devanagari_reorder_reph(start,kind,lookupname,replacement)
+ -- since in Devanagari reph has reordering position 'before postscript' dev2 only follows step 2, 4, and 6,
+ -- the other steps are still ToDo (required for scripts other than dev2)
+ local current = start.next
+ local startnext = nil
+ local startprev = nil
+ local startfont = start.font
+ local startattr = has_attribute(start,a_syllabe)
+ while current and current.id == glyph_code and current.subtype<256 and current.font == startfont and has_attribute(current,a_syllabe) == startattr do --step 2
+ if halant[current.char] and not has_attribute(current,a_state) then
+ local next = current.next
+ if next and next.id == glyph_code and next.subtype<256 and next.font == startfont and has_attribute(next,a_syllabe) == startattr and zw_char[next.char] then
+ current = next
+ end
+-- startnext = start.next
+-- startprev = start.prev
+-- startnext.prev = startprev
+-- if startprev then
+-- startprev.next = startnext
+-- end
+remove_node(start,start)
+ local next = current.next
+ if next then
+ next.prev = start
+ end
+ start.next = next
+ current.next = start
+ start.prev = current
+ start = startnext
+ startattr = has_attribute(start,a_syllabe)
+ break
+ end
+ current = current.next
+ end
+ if not startnext then
+ current = start.next
+ while current and current.id == glyph_code and current.subtype<256 and current.font == startfont and has_attribute(current,a_syllabe) == startattr do --step 4
+ if has_attribute(current,a_state) == 9 then --post-base
+ startnext = start.next
+-- startprev = start.prev
+-- startnext.prev = startprev
+-- if startprev then
+-- startprev.next = startnext
+-- end
+remove_node(start,start)
+ local prev = current.prev
+ start.prev = prev
+ prev.next = start
+ start.next = current
+ current.prev = start
+ start = startnext
+ startattr = has_attribute(start,a_syllabe)
+ break
+ end
+ current = current.next
+ end
+ end
+ -- ToDo: determine position for reph with reordering position other than 'before postscript'
+ -- (required for scripts other than dev2)
+ -- leaks
+ if not startnext then
+ current = start.next
+ local c = nil
+ while current and current.id == glyph_code and current.subtype<256 and current.font == startfont and has_attribute(current,a_syllabe) == startattr do --step 5
+ if not c then
+ local char = current.char
+ -- todo: combine in one
+ if mark_above_below_post[char] and reorder_class[char] ~= "after subscript" then
+ c = current
+ end
+ end
+ current = current.next
+ end
+ -- here we can loose the old start node: maybe best split cases
+ if c then
+ startnext = start.next
+ -- if c ~= startnext then -- needs testing
+-- startprev = start.prev
+-- startnext.prev = startprev
+-- if startprev then
+-- startprev.next = startnext
+-- end
+remove_node(start,start)
+ local prev = c.prev
+ start.prev = prev
+ prev.next = start
+ start.next = c
+ c.prev = start
+ -- end
+ start = startnext
+ startattr = has_attribute(start,a_syllabe)
+ end
+ end
+ -- leaks
+ if not startnext then
+ current = start
+ local next = current.next
+ while next and next.id == glyph_code and next.subtype<256 and next.font == startfont and has_attribute(next,a_syllabe) == startattr do --step 6
+ current = next
+ next = current.next
+ end
+ if start ~= current then
+ startnext = start.next
+-- startprev = start.prev
+-- startnext.prev = startprev
+-- if startprev then
+-- startprev.next = startnext
+-- end
+remove_node(start,start)
+ local next = current.next
+ if next then
+ next.prev = start
+ end
+ start.next = next
+ current.next = start
+ start.prev = current
+ start = startnext
+ end
+ end
+ --
+ return start, true
+end
+
+-- we can cache some checking (v)
+
+-- If a pre-base reordering consonant is found, reorder it according to the following rules:
+--
+-- 1 Only reorder a glyph produced by substitution during application of the feature.
+-- (Note that a font may shape a Ra consonant with the feature generally but block it in certain contexts.)
+-- 2 Try to find a target position the same way as for pre-base matra. If it is found, reorder pre-base consonant glyph.
+-- 3 If position is not found, reorder immediately before main consonant.
+
+-- UNTESTED: NOT CALLED IN EXAMPLE
+
+function handlers.devanagari_reorder_pre_base_reordering_consonants(start,kind,lookupname,replacement)
+ local current = start
+ local startnext = nil
+ local startprev = nil
+ local startfont = start.font
+ local startattr = has_attribute(start,a_syllabe)
+ -- can be fast for loop + caching state
+ while current and current.id == glyph_code and current.subtype<256 and current.font == startfont and has_attribute(current,a_syllabe) == startattr do
+ local next = current.next
+ if halant[current.char] and not has_attribute(current,a_state) then
+ if next and next.id == glyph_code and next.subtype<256 and next.font == font and has_attribute(next,a_syllabe) == startattr then
+ local char = next.char
+ if zw_char[char] then
+ current = next
+ end
+ end
+ startnext = start.next
+-- startprev = start.prev
+-- startnext.prev = startprev
+-- if startprev then
+-- startprev.next = startnext
+-- end
+removenode(start,start)
+ local next = current.next
+ if next then
+ next.prev = start
+ end
+ start.next = next
+ current.next = start
+ start.prev = current
+ start = startnext
+ break
+ end
+ current = next
+ end
+ if not startnext then
+ current = start.next
+ startattr = has_attribute(start,a_syllabe)
+ while current and current.id == glyph_code and current.subtype<256 and current.font == startfont and has_attribute(current,a_syllabe) == startattr do
+ if not consonant[current.char] and has_attribute(current,a_state) then --main
+ startnext = start.next
+-- startprev = start.prev
+-- startnext.prev = startprev
+-- if startprev then
+-- startprev.next = startnext
+-- end
+removenode(start,start)
+ local prev = current.prev
+ start.prev = prev
+ prev.next = start
+ start.next = current
+ current.prev = start
+ start = startnext
+ break
+ end
+ current = current.next
+ end
+ end
+ return start, true
+end
+
+function handlers.devanagari_remove_joiners(start,kind,lookupname,replacement)
+ local stop = start.next
+ local startfont = start.font
+ while stop and stop.id == glyph_code and stop.subtype<256 and stop.font == startfont do
+ local char = stop.char
+ if zw_char[char] then
+ stop = stop.next
+ else
+ break
+ end
+ end
+ if stop then
+ stop.prev.next = nil
+ stop.prev = start.prev
+ end
+ local prev = start.prev
+ if prev then
+ prev.next = stop
+ end
+ flush_list(start)
+ return stop, true
+end
+
+local valid = {
+ rphf = true,
+ pref = true,
+ half = true,
+ blwf = true,
+ pstf = true,
+}
+
+local function dev2_initialize(font,attr)
+
+ local tfmdata = fontdata[font]
+ local resources = tfmdata.resources
+ local lookuphash = resources.lookuphash
+
+ local datasets = otf.dataset(tfmdata,font,attr)
+ local devanagaridata = datasets.devanagari
+
+ if devanagaridata then -- maybe also check for e.g. seqsubset
+
+ return lookuphash, devanagaridata.seqsubset
+
+ else
+
+ devanagaridata = { }
+ datasets.devanagari = devanagaridata
+
+ local seqsubset = { }
+ devanagaridata.seqsubset = seqsubset
+
+ local sequences = resources.sequences
+
+ for s=1,#sequences do
+ -- local sequence = sequences[s]
+ local dataset = datasets[s]
+ if dataset and dataset[1] then -- featurevalue
+ local kind = dataset[4]
+ if kind and valid[kind] then
+ -- could become a function call
+ -- local subtables = sequence.subtables
+ local subtables = dataset[5].subtables
+ for i=1,#subtables do
+ local lookupname = subtables[i]
+ local lookupcache = lookuphash[lookupname]
+ if lookupcache then
+ local reph = false
+ local chain = dataset[3]
+ if chain ~= 0 then --rphf is result of of chain
+ --ToDo: rphf might be result of other handler/chainproc
+ else
+ reph = lookupcache[0x0930]
+ if reph then
+ reph = reph[0x094D]
+ if reph then
+ reph = reph["ligature"]
+ end
+ end
+ --ToDo: rphf actualy acts on consonant + halant. This consonant might not necesseraly be 0x0930 ... (but fot dev2 it is)
+ end
+ seqsubset[#seqsubset+1] = { kind, lookupcache, reph }
+ end
+ end
+ end
+ end
+ end
+
+ lookuphash["dv01_reorder_matras"] = pre_mark -- move to initializer ?
+
+ return lookuphash, seqsubset
+
+ end
+
+end
+
+-- this one will be merged into the caller: it saves a call, but we will then make function
+-- of the actions
+
+local function dev2_reorder(head,start,stop,font,attr) -- maybe do a pass over (determine stop in sweep)
+
+ local lookuphash, seqsubset = dev2_initialize(font,attr)
+
+ local reph, pre_base_reordering_consonants = false, { } -- was nil ... probably went unnoticed because never assigned
+ local halfpos, basepos, subpos, postpos = nil, nil, nil, nil
+ local locl = { }
+
+ for i=1,#seqsubset do
+
+ -- maybe quit if start == stop
+
+ local subset = seqsubset[i]
+ local kind = subset[1]
+ local lookupcache = subset[2]
+ if kind == "rphf" then
+ if subset[3] then
+ reph = true
+ end
+ local current = start
+ local last = stop.next
+ while current ~= last do
+ if current ~= stop then
+ local c = locl[current] or current.char
+ local found = lookupcache[c]
+ if found then
+ local next = current.next
+ local n = locl[next] or next.char
+ if found[n] then --above-base: rphf Consonant + Halant
+ local afternext = next ~= stop and next.next
+ if afternext and zw_char[afternext.char] then -- ZWJ and ZWNJ prevent creation of reph
+ current = next
+ current = current.next
+ elseif current == start then
+ set_attribute(current,a_state,5)
+ current = next
+ else
+ current = next
+ end
+ end
+ end
+ end
+ current = current.next
+ end
+ elseif kind == "pref" then
+ -- why not global? pretty ineffient this way
+ -- this will move to the initializer and we will store the hash in dataset
+ for k, v in lookupcache[0x094D], next do
+ pre_base_reordering_consonants[k] = v and v["ligature"] --ToDo: reph might also be result of chain
+ end
+ --
+ local current = start
+ local last = stop.next
+ while current ~= last do
+ if current ~= stop then
+ local c = locl[current] or current.char
+ local found = lookupcache[c]
+ if found then
+ local next = current.next
+ local n = locl[next] or next.char
+ if found[n] then
+ set_attribute(current,a_state,7)
+ set_attribute(next,a_state,7)
+ current = next
+ end
+ end
+ end
+ current = current.next
+ end
+ elseif kind == "half" then -- half forms: half / Consonant + Halant
+ local current = start
+ local last = stop.next
+ while current ~= last do
+ if current ~= stop then
+ local c = locl[current] or current.char
+ local found = lookupcache[c]
+ if found then
+ local next = current.next
+ local n = locl[next] or next.char
+ if found[n] then
+ if next ~= stop and zwnj[next.next.char] then --ZWNJ prevent creation of half
+ current = current.next
+ else
+ set_attribute(current,a_state,6)
+ if not halfpos then
+ halfpos = current
+ end
+ end
+ current = next
+ end
+ end
+ end
+ current = current.next
+ end
+ elseif kind == "blwf" then -- below-base: blwf / Halant + Consonant
+ local current = start
+ local last = stop.next
+ while current ~= last do
+ if current ~= stop then
+ local c = locl[current] or current.char
+ local found = lookupcache[c]
+ if found then
+ local next = current.next
+ local n = locl[next] or next.char
+ if found[n] then
+ set_attribute(current,a_state,8)
+ set_attribute(next,a_state,8)
+ current = next
+ subpos = current
+ end
+ end
+ end
+ current = current.next
+ end
+ elseif kind == "pstf" then -- post-base: pstf / Halant + Consonant
+ local current = start
+ local last = stop.next
+ while current ~= last do
+ if current ~= stop then
+ local c = locl[current] or current.char
+ local found = lookupcache[c]
+ if found then
+ local next = current.next
+ local n = locl[next] or next.char
+ if found[n] then
+ set_attribute(current,a_state,9)
+ set_attribute(next,a_state,9)
+ current = next
+ postpos = current
+ end
+ end
+ end
+ current = current.next
+ end
+ end
+ end
+
+ -- this one changes per word
+
+ lookuphash["dv02_reorder_reph"] = { [reph] = true }
+ lookuphash["dv03_reorder_pre_base_reordering_consonants"] = pre_base_reordering_consonants
+
+ local current, base, firstcons = start, nil, nil
+
+ if has_attribute(start,a_state) == 5 then
+ -- if syllable starts with Ra + H and script has 'Reph' then exclude Reph from candidates for base consonants
+ current = start.next.next
+ end
+
+ if current ~= stop.next and nbsp[current.char] then
+ -- Stand Alone cluster
+ if current == stop then
+ stop = stop.prev
+ head = remove_node(head,current)
+ free_node(current)
+ return head, stop
+ else
+ base = current
+ current = current.next
+ if current ~= stop then
+ local char = current.char
+ if nukta[char] then
+ current = current.next
+ char = current.char
+ end
+ if zwj[char] then
+ local next = current.next
+ if current ~= stop and next ~= stop and halant[next.char] then
+ current = next
+ next = current.next
+ local tmp = next.next
+ local changestop = next == stop
+ next.next = nil
+ set_attribute(current,a_state,7) --pref
+ current = processcharacters(current)
+ set_attribute(current,a_state,8) --blwf
+ current = processcharacters(current)
+ set_attribute(current,a_state,9) --pstf
+ current = processcharacters(current)
+ unset_attribute(current,a_state)
+ if halant[current.char] then
+ current.next.next = tmp
+ local nc = copy_node(current)
+ current.char = dotted_circle
+ head = insert_node_after(head,current,nc)
+ else
+ current.next = tmp -- assumes that result of pref, blwf, or pstf consists of one node
+ if changestop then
+ stop = current
+ end
+ end
+ end
+ end
+ end
+ end
+ else -- not Stand Alone cluster
+ local last = stop.next
+ while current ~= last do -- find base consonant
+ local next = current.next
+ if consonant[current.char] then
+ if not (current ~= stop and next ~= stop and halant[next.char] and zwj[next.next.char]) then
+ if not firstcons then
+ firstcons = current
+ end
+ -- check whether consonant has below-base or post-base form or is pre-base reordering Ra
+ local a = has_attribute(current,a_state)
+ if not (a == 7 or a == 8 or a == 9) then
+ base = current
+ end
+ end
+ end
+ current = next
+ end
+ if not base then
+ base = firstcons
+ end
+ end
+
+ if not base then
+ if has_attribute(start,a_state) == 5 then
+ unset_attribute(start,a_state)
+ end
+ return head, stop
+ else
+ if has_attribute(base,a_state) then
+ unset_attribute(base,a_state)
+ end
+ basepos = base
+ end
+ if not halfpos then
+ halfpos = base
+ end
+ if not subpos then
+ subpos = base
+ end
+ if not postpos then
+ postpos = subpos or base
+ end
+
+ -- Matra characters are classified and reordered by which consonant in a conjunct they have affinity for
+
+ local moved = { }
+ local current = start
+ local last = stop.next
+ while current ~= last do
+ local char, target, cn = locl[current] or current.char, nil, current.next
+ if not moved[current] and dependent_vowel[char] then
+ if pre_mark[char] then -- Before first half form in the syllable
+ moved[current] = true
+ local prev = current.prev
+ local next = current.next
+ if prev then
+ prev.next = next
+ end
+ if next then
+ next.prev = prev
+ end
+ if current == stop then
+ stop = current.prev
+ end
+ if halfpos == start then
+ if head == start then
+ head = current
+ end
+ start = current
+ end
+ local prev = halfpos.prev
+ if prev then
+ prev.next = current
+ end
+ current.prev = prev
+ halfpos.prev = current
+ current.next = halfpos
+ halfpos = current
+ elseif above_mark[char] then -- After main consonant
+ target = basepos
+ if subpos == basepos then
+ subpos = current
+ end
+ if postpos == basepos then
+ postpos = current
+ end
+ basepos = current
+ elseif below_mark[char] then -- After subjoined consonants
+ target = subpos
+ if postpos == subpos then
+ postpos = current
+ end
+ subpos = current
+ elseif post_mark[char] then -- After post-form consonant
+ target = postpos
+ postpos = current
+ end
+ if mark_above_below_post[char] then
+ local prev = current.prev
+ if prev ~= target then
+ local next = current.next
+ if prev then -- not needed, already tested with target
+ prev.next = next
+ end
+ if next then
+ next.prev = prev
+ end
+ if current == stop then
+ stop = prev
+ end
+ local next = target.next
+ if next then
+ next.prev = current
+ end
+ current.next = next
+ target.next = current
+ current.prev = target
+ end
+ end
+ end
+ current = cn
+ end
+
+ -- Reorder marks to canonical order: Adjacent nukta and halant or nukta and vedic sign are always repositioned if necessary, so that the nukta is first.
+
+ local current, c = start, nil
+ while current ~= stop do
+ local char = current.char
+ if halant[char] or stress_tone_mark[char] then
+ if not c then
+ c = current
+ end
+ else
+ c = nil
+ end
+ local next = current.next
+ if c and nukta[next.char] then
+ if head == c then
+ head = next
+ end
+ if stop == next then
+ stop = current
+ end
+ local prev = c.prev
+ if prev then
+ prev.next = next
+ end
+ next.prev = prev
+ local nextnext = next.next
+ current.next = nextnext
+ local nextnextnext = nextnext.next
+ if nextnextnext then
+ nextnextnext.prev = current
+ end
+ c.prev = nextnext
+ nextnext.next = c
+ end
+ if stop == current then break end
+ current = current.next
+ end
+
+ if nbsp[base.char] then
+ head = remove_node(head, base)
+ free_node(base)
+ end
+
+ return head, stop
+end
+
+-- cleaned up and optimized ... needs checking (local, check order, fixes, extra hash, etc)
+
+local separator = { }
+
+imerge(separator,consonant)
+imerge(separator,independent_vowel)
+imerge(separator,dependent_vowel)
+imerge(separator,vowel_modifier)
+imerge(separator,stress_tone_mark)
+imerge(separator,nukta)
+imerge(separator,halant)
+
+local function analyze_next_chars_one(c,font,variant) -- skip one dependent vowel
+ -- why two variants ... the comment suggests that it's the same ruleset
+ local n = c.next
+ if not n then
+ return c
+ end
+ if variant == 1 then
+ local v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if v and nukta[n.char] then
+ n = n.next
+ if n then
+ v = n.id == glyph_code and n.subtype<256 and n.font == font
+ end
+ end
+ if n and v then
+ local nn = n.next
+ if nn and nn.id == glyph_code and nn.subtype<256 and nn.font == font then
+ local nnn = nn.next
+ if nnn and nnn.id == glyph_code and nnn.subtype<256 and nnn.font == font then
+ local nnc = nn.char
+ local nnnc = nnn.char
+ if zwj[nnc] and consonant[nnnc] then
+ c = nnn
+ elseif zw_char[nnc] and halant[nnnc] then
+ local nnnn = nnn.next
+ if nnnn and nnnn.id == glyph_code and consonant[nnnn.char] and nnnn.subtype<256 and nnnn.font == font then
+ c = nnnn
+ end
+ end
+ end
+ end
+ end
+ elseif variant == 2 then
+ if n.id == glyph_code and nukta[n.char] and n.subtype<256 and n.font == font then
+ c = n
+ end
+ n = c.next
+ if n and n.id == glyph_code and n.subtype<256 and n.font == font then
+ local nn = n.next
+ if nn then
+ local nv = nn.id == glyph_code and nn.subtype<256 and nn.font == font
+ if nv and zw_char[n.char] then
+ n = nn
+ nn = nn.next
+ nv = nn.id == glyph_code and nn.subtype<256 and nn.font == font
+ end
+ if nn and nv and halant[n.char] and consonant[nn.char] then
+ c = nn
+ end
+ end
+ end
+ end
+ -- c = ms_matra(c)
+ local n = c.next
+ if not n then
+ return c
+ end
+ local v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ return c
+ end
+ local char = n.char
+ if dependent_vowel[char] then
+ c = c.next
+ n = c.next
+ if not n then
+ return c
+ end
+ v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ return c
+ end
+ char = n.char
+ end
+ if nukta[char] then
+ c = c.next
+ n = c.next
+ if not n then
+ return c
+ end
+ v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ return c
+ end
+ char = n.char
+ end
+ if halant[char] then
+ c = c.next
+ n = c.next
+ if not n then
+ return c
+ end
+ v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ return c
+ end
+ char = n.char
+ end
+ if vowel_modifier[char] then
+ c = c.next
+ n = c.next
+ if not n then
+ return c
+ end
+ v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ return c
+ end
+ char = n.char
+ end
+ if stress_tone_mark[char] then
+ c = c.next
+ n = c.next
+ if not n then
+ return c
+ end
+ v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ return c
+ end
+ char = n.char
+ end
+ if stress_tone_mark[char] then
+ return n
+ else
+ return c
+ end
+end
+
+local function analyze_next_chars_two(c,font)
+ local n = c.next
+ if not n then
+ return c
+ end
+ if n.id == glyph_code and nukta[n.char] and n.subtype<256 and n.font == font then
+ c = n
+ end
+ n = c
+ while true do
+ local nn = n.next
+ if nn and nn.id == glyph_code and nn.subtype<256 and nn.font == font then
+ local char = nn.char
+ if halant[char] then
+ n = nn
+ local nnn = nn.next
+ if nnn and nnn.id == glyph_code and zw_char[nnn.char] and nnn.subtype<256 and nnn.font == font then
+ n = nnn
+ end
+ elseif zw_char[char] then
+ -- n = nn -- not here (?)
+ local nnn = nn.next
+ if nnn and nnn.id == glyph_code and halant[nnn.char] and nnn.subtype<256 and nnn.font == font then
+ n = nnn
+ end
+ else
+ break
+ end
+ local nn = n.next
+ if nn and nn.id == glyph_code and consonant[nn.char] and nn.subtype<256 and nn.font == font then
+ n = nn
+ local nnn = nn.next
+ if nnn and nnn.id == glyph_code and nukta[nnn.char] and nnn.subtype<256 and nnn.font == font then
+ n = nnn
+ end
+ c = n
+ else
+ break
+ end
+ else
+ break
+ end
+ end
+ --
+ if not c then
+ -- This shouldn't happen I guess.
+ return
+ end
+ local n = c.next
+ if not n then
+ return c
+ end
+ local v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ return c
+ end
+ local char = n.char
+ if anudatta[char] then
+ c = n
+ n = c.next
+ if not n then
+ return c
+ end
+ v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ return c
+ end
+ char = n.char
+ end
+ if halant[char] then
+ c = c.next
+ n = c.next
+ if not n then
+ return c
+ end
+ v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ return c
+ end
+ char = n.char
+ if zw_char[char] then
+ c = c.next
+ n = c.next
+ if not n then
+ return c
+ end
+ v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ return c
+ end
+ char = n.char
+ end
+ else
+ -- c = ms_matra(c)
+ -- same as one
+ if dependent_vowel[char] then
+ c = c.next
+ n = c.next
+ if not n then
+ return c
+ end
+ v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ return c
+ end
+ char = n.char
+ end
+ if nukta[char] then
+ c = c.next
+ n = c.next
+ if not n then
+ return c
+ end
+ v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ return c
+ end
+ char = n.char
+ end
+ if halant[char] then
+ c = c.next
+ n = c.next
+ if not n then
+ return c
+ end
+ v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ return c
+ end
+ char = n.char
+ end
+ end
+ -- same as one
+ if vowel_modifier[char] then
+ c = c.next
+ n = c.next
+ if not n then
+ return c
+ end
+ v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ return c
+ end
+ char = n.char
+ end
+ if stress_tone_mark[char] then
+ c = c.next
+ n = c.next
+ if not n then
+ return c
+ end
+ v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ return c
+ end
+ char = n.char
+ end
+ if stress_tone_mark[char] then
+ return n
+ else
+ return c
+ end
+end
+
+local function inject_syntax_error(head,current,mark)
+ local signal = copy_node(current)
+ if mark == pre_mark then
+ signal.char = dotted_circle
+ else
+ current.char = dotted_circle
+ end
+ return insert_node_after(head,current,signal)
+end
+
+-- It looks like these two analyzers were written independently but they share
+-- a lot. Common code has been synced.
+
+function methods.deva(head,font,attr)
+ local current, start, done = head, true, false
+ while current do
+ if current.id == glyph_code and current.subtype<256 and current.font == font then
+ done = true
+ local syllablestart = current
+ local syllableend = nil
+ local c = current
+ local n = c.next
+ if n and ra[c.char] and n.id == glyph_code and halant[n.char] and n.subtype<256 and n.font == font then
+ local n = n.next
+ if n and n.id == glyph_code and n.subtype<256 and n.font == font then
+ c = n
+ end
+ end
+ local standalone = nbsp[c.char]
+ if standalone then
+ local prev = current.prev
+ if not prev then
+ -- begin of paragraph or box
+ elseif prev.id ~= glyph_code or prev.subtype>=256 or prev.font ~= font then
+ -- different font or language so quite certainly a different word
+ elseif not separator[prev.char] then
+ -- something that separates words
+ else
+ standalone = false
+ end
+ end
+ if standalone then
+ -- stand alone cluster (at the start of the word only): #[Ra+H]+NBSP+[N]+[<[<ZWJ|ZWNJ>]+H+C>]+[{M}+[N]+[H]]+[SM]+[(VD)]
+ local syllabeend, current = analyze_next_chars_one(c,font,2) -- watch out, here we set current to next
+ if syllablestart ~= syllableend then
+ head, current = deva_reorder(head,syllablestart,syllableend,font,attr)
+ current = current.next
+ end
+ else
+ -- we can delay the n.subtype and n.font and test for say halant[c] first
+ -- as an table access is faster than two function calls (subtype and font are
+ -- pseudo fields) but the code becomes messy (unless we make it a function)
+ local char = current.char
+ if consonant[char] then
+ -- syllable containing consonant
+ local prevc = true
+ while prevc do
+ prevc = false
+ local n = current.next
+ if not n then
+ break
+ end
+ local v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ break
+ end
+ local c = n.char
+ if nukta[c] then
+ n = n.next
+ if not n then
+ break
+ end
+ v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ break
+ end
+ c = n.char
+ end
+ if halant[c] then
+ n = n.next
+ if not n then
+ break
+ end
+ v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ break
+ end
+ c = n.char
+ if zw_char[c] then
+ n = n.next
+ if not n then
+ break
+ end
+ v = n.id == glyph_code and n.subtype<256 and n.font == font
+ if not v then
+ break
+ end
+ c = n.char
+ end
+ if consonant[c] then
+ prevc = true
+ current = n
+ end
+ end
+ end
+ local n = current.next
+ if n and n.id == glyph_code and nukta[n.char] and n.subtype<256 and n.font == font then
+ -- nukta (not specified in Microsft Devanagari OpenType specification)
+ current = n
+ n = current.next
+ end
+ syllableend = current
+ current = n
+ if current then
+ local v = current.id == glyph_code and current.subtype<256 and current.font == font
+ if v then
+ if halant[current.char] then
+ -- syllable containing consonant without vowels: {C + [Nukta] + H} + C + H
+ local n = current.next
+ if n and n.id == glyph_code and zw_char[n.char] and n.subtype<256 and n.font == font then
+ -- code collapsed, probably needs checking with intention
+ syllableend = n
+ current = n.next
+ else
+ syllableend = current
+ current = n
+ end
+ else
+ -- syllable containing consonant with vowels: {C + [Nukta] + H} + C + [M] + [VM] + [SM]
+ local c = current.char
+ if dependent_vowel[c] then
+ syllableend = current
+ current = current.next
+ v = current and current.id == glyph_code and current.subtype<256 and current.font == font
+ if v then
+ c = current.char
+ end
+ end
+ if v and vowel_modifier[c] then
+ syllableend = current
+ current = current.next
+ v = current and current.id == glyph_code and current.subtype<256 and current.font == font
+ if v then
+ c = current.char
+ end
+ end
+ if v and stress_tone_mark[c] then
+ syllableend = current
+ current = current.next
+ end
+ end
+ end
+ end
+ if syllablestart ~= syllableend then
+ head, current = deva_reorder(head,syllablestart,syllableend,font,attr)
+ current = current.next
+ end
+ elseif independent_vowel[char] then
+ -- syllable without consonants: VO + [VM] + [SM]
+ syllableend = current
+ current = current.next
+ if current then
+ local v = current.id == glyph_code and current.subtype<256 and current.font == font
+ if v then
+ local c = current.char
+ if vowel_modifier[c] then
+ syllableend = current
+ current = current.next
+ v = current and current.id == glyph_code and current.subtype<256 and current.font == font
+ if v then
+ c = current.char
+ end
+ end
+ if v and stress_tone_mark[c] then
+ syllableend = current
+ current = current.next
+ end
+ end
+ end
+ else
+ local mark = mark_four[char]
+ if mark then
+ head, current = inject_syntax_error(head,current,mark)
+ end
+ current = current.next
+ end
+ end
+ else
+ current = current.next
+ end
+ start = false
+ end
+
+ return head, done
+end
+
+-- there is a good change that when we run into one with subtype < 256 that the rest is also done
+-- so maybe we can omit this check (it's pretty hard to get glyphs in the stream out of the blue)
+
+-- handler(start,kind,lookupname,lookupmatch,sequence,lookuphash,1)
+
+function methods.dev2(head,font,attr)
+ local current = head
+ local start = true
+ local done = false
+ local syllabe = 0
+ while current do
+ local syllablestart, syllableend = nil, nil
+ if current.id == glyph_code and current.subtype<256 and current.font == font then
+ done = true
+ syllablestart = current
+ local c = current
+ local n = current.next
+ if n and ra[c.char] and n.id == glyph_code and halant[n.char] and n.subtype<256 and n.font == font then
+ local n = n.next
+ if n and n.id == glyph_code and n.subtype<256 and n.font == font then
+ c = n
+ end
+ end
+ local char = c.char
+ if independent_vowel[char] then
+ -- vowel-based syllable: [Ra+H]+V+[N]+[<[<ZWJ|ZWNJ>]+H+C|ZWJ+C>]+[{M}+[N]+[H]]+[SM]+[(VD)]
+ current = analyze_next_chars_one(c,font,1)
+ syllableend = current
+ else
+ local standalone = nbsp[char]
+ if standalone then
+ local p = current.prev
+ if not p then
+ -- begin of paragraph or box
+ elseif p.id ~= glyph_code or p.subtype>=256 or p.font ~= font then
+ -- different font or language so quite certainly a different word
+ elseif not separator[p.char] then
+ -- something that separates words
+ else
+ standalone = false
+ end
+ end
+ if standalone then
+ -- Stand Alone cluster (at the start of the word only): #[Ra+H]+NBSP+[N]+[<[<ZWJ|ZWNJ>]+H+C>]+[{M}+[N]+[H]]+[SM]+[(VD)]
+ current = analyze_next_chars_one(c,font,2)
+ syllableend = current
+ elseif consonant[current.char] then
+ -- WHY current INSTEAD OF c ?
+
+ -- Consonant syllable: {C+[N]+<H+[<ZWNJ|ZWJ>]|<ZWNJ|ZWJ>+H>} + C+[N]+[A] + [< H+[<ZWNJ|ZWJ>] | {M}+[N]+[H]>]+[SM]+[(VD)]
+ current = analyze_next_chars_two(current,font) -- not c !
+ syllableend = current
+ end
+ end
+ end
+ if syllableend then
+ syllabe = syllabe + 1
+ local c = syllablestart
+ local n = syllableend.next
+ while c ~= n do
+ set_attribute(c,a_syllabe,syllabe)
+ c = c.next
+ end
+ end
+ if syllableend and syllablestart ~= syllableend then
+ head, current = dev2_reorder(head,syllablestart,syllableend,font,attr)
+ end
+ if not syllableend and current.id == glyph_code and current.subtype<256 and current.font == font and not has_attribute(current,a_state) then
+ local mark = mark_four[current.char]
+ if mark then
+ head, current = inject_syntax_error(head,current,mark)
+ end
+ end
+ start = false
+ current = current.next
+ end
+
+ return head, done
+end
+
+-- Temporary checker:
+
+if false then -- when true we can see how much nodes bleed
+
+ local function check(what,action,head,kind,lookupname,replacement)
+ local n_before = nodes.count(head)
+ local s_before = nodes.listtoutf(head)
+ local head, done = action(head,kind,lookupname,replacement)
+ local n_after = nodes.count(head)
+ local s_after = nodes.listtoutf(head)
+ if n_before ~= n_after then
+ print("leak",what)
+ print(n_before,s_before)
+ print(n_after,s_after)
+ end
+ return head, done
+ end
+
+ local devanagari_reorder_matras = handlers.devanagari_reorder_matras
+ local devanagari_reorder_reph = handlers.devanagari_reorder_reph
+ local devanagari_reorder_pre_base_reordering_consonants = handlers.devanagari_reorder_pre_base_reordering_consonants
+ local devanagari_remove_joiners = handlers.devanagari_remove_joiners
+
+ function handlers.devanagari_reorder_matras(start,kind,lookupname,replacement)
+ if trace then
+ return check("matras",devanagari_reorder_matras,start,kind,lookupname,replacement)
+ else
+ return devanagari_reorder_matras(start,kind,lookupname,replacement)
+ end
+ end
+
+ function handlers.devanagari_reorder_reph(start,kind,lookupname,replacement)
+ if trace then
+ return check("reph",devanagari_reorder_reph,start,kind,lookupname,replacement)
+ else
+ return devanagari_reorder_reph(start,kind,lookupname,replacement)
+ end
+ end
+
+ function handlers.devanagari_reorder_pre_base_reordering_consonants(start,kind,lookupname,replacement)
+ if trace then
+ return check("consonants",devanagari_reorder_pre_base_reordering_consonants,start,kind,lookupname,replacement)
+ else
+ return devanagari_reorder_pre_base_reordering_consonants(start,kind,lookupname,replacement)
+ end
+ end
+
+ function handlers.devanagari_remove_joiners(start,kind,lookupname,replacement)
+ if trace then
+ return check("joiners",devanagari_remove_joiners,start,kind,lookupname,replacement)
+ else
+ return devanagari_remove_joiners(start,kind,lookupname,replacement)
+ end
+ end
+
+end
+
+-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+-- We keep the original around for a while so that we can check it --
+-- when the above code does it wrong (data tables are not included). --
+-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+-- local state = attributes.private('state')
+-- local sylnr = attributes.private('syllabe')
+--
+-- local function install_dev(tfmdata)
+-- local features = tfmdata.resources.features
+-- local sequences = tfmdata.resources.sequences
+--
+-- local insertpos = 1
+-- for s=1,#sequences do -- classify chars
+-- for k in pairs(basic_shaping_forms) do
+-- if sequences[s].features and ( sequences[s].features[k] or sequences[s].features.locl ) then insertpos = s + 1 end
+-- end
+-- end
+--
+-- features.gsub["dev2_reorder_matras"] = { ["dev2"] = { ["dflt"] = true } }
+-- features.gsub["dev2_reorder_reph"] = { ["dev2"] = { ["dflt"] = true } }
+-- features.gsub["dev2_reorder_pre_base_reordering_consonants"] = { ["dev2"] = { ["dflt"] = true } }
+-- features.gsub["remove_joiners"] = { ["deva"] = { ["dflt"] = true }, ["dev2"] = { ["dflt"] = true } }
+--
+-- local sequence_dev2_reorder_matras = {
+-- chain = 0,
+-- features = { dev2_reorder_matras = { dev2 = { dflt = true } } },
+-- flags = { false, false, false, false },
+-- name = "dev2_reorder_matras",
+-- subtables = { "dev2_reorder_matras" },
+-- type = "dev2_reorder_matras",
+-- }
+-- local sequence_dev2_reorder_reph = {
+-- chain = 0,
+-- features = { dev2_reorder_reph = { dev2 = { dflt = true } } },
+-- flags = { false, false, false, false },
+-- name = "dev2_reorder_reph",
+-- subtables = { "dev2_reorder_reph" },
+-- type = "dev2_reorder_reph",
+-- }
+-- local sequence_dev2_reorder_pre_base_reordering_consonants = {
+-- chain = 0,
+-- features = { dev2_reorder_pre_base_reordering_consonants = { dev2 = { dflt = true } } },
+-- flags = { false, false, false, false },
+-- name = "dev2_reorder_pre_base_reordering_consonants",
+-- subtables = { "dev2_reorder_pre_base_reordering_consonants" },
+-- type = "dev2_reorder_pre_base_reordering_consonants",
+-- }
+-- local sequence_remove_joiners = {
+-- chain = 0,
+-- features = { remove_joiners = { deva = { dflt = true }, dev2 = { dflt = true } } },
+-- flags = { false, false, false, false },
+-- name = "remove_joiners",
+-- subtables = { "remove_joiners" },
+-- type = "remove_joiners",
+-- }
+-- table.insert(sequences, insertpos, sequence_dev2_reorder_pre_base_reordering_consonants)
+-- table.insert(sequences, insertpos, sequence_dev2_reorder_reph)
+-- table.insert(sequences, insertpos, sequence_dev2_reorder_matras)
+-- table.insert(sequences, insertpos, sequence_remove_joiners)
+-- end
+--
+-- local function deva_reorder(head,start,stop,font,attr)
+-- local tfmdata = fontdata[font]
+-- local lookuphash = tfmdata.resources.lookuphash
+-- local sequences = tfmdata.resources.sequences
+--
+-- if not lookuphash["remove_joiners"] then install_dev(tfmdata) end --install Devanagari-features
+--
+-- local sharedfeatures = tfmdata.shared.features
+-- sharedfeatures["remove_joiners"] = true
+-- local datasets = otf.dataset(tfmdata,font,attr)
+--
+-- lookuphash["remove_joiners"] = { [0x200C] = true, [0x200D] = true }
+--
+-- local current, n, base, firstcons, lastcons, basefound = start, start.next, nil, nil, nil, false
+-- local reph, vattu = false, false
+-- for s=1,#sequences do
+-- local dataset = datasets[s]
+-- featurevalue = dataset and dataset[1]
+-- if featurevalue and dataset[4] == "rphf" then reph = true end
+-- if featurevalue and dataset[4] == "blwf" then vattu = true end
+-- end
+-- if ra[start.char] and halant[n.char] and reph then -- if syllable starts with Ra + H and script has 'Reph' then exclude Reph from candidates for base consonants
+-- if n == stop then return head, stop end
+-- if zwj[n.next.char] then
+-- current = start
+-- else
+-- current = n.next
+-- set_attribute(start,state,5) -- rphf
+-- end
+-- end
+--
+-- if nbsp[current.char] then --Stand Alone cluster
+-- if current == stop then
+-- stop = stop.prev
+-- head = node.remove(head, current)
+-- node.free(current)
+-- return head, stop
+-- else
+-- base, firstcons, lastcons = current, current, current
+-- current = current.next
+-- if current ~= stop then
+-- if nukta[current.char] then current = current.next end
+-- if zwj[current.char] then
+-- if current ~= stop and current.next ~= stop and halant[current.next.char] then
+-- current = current.next
+-- local tmp = current.next.next
+-- local changestop = current.next == stop
+-- local tempcurrent = node.copy(current.next)
+-- tempcurrent.next = node.copy(current)
+-- tempcurrent.next.prev = tempcurrent
+-- set_attribute(tempcurrent,state,8) --blwf
+-- tempcurrent = nodes.handlers.characters(tempcurrent)
+-- unset_attribute(tempcurrent,state)
+-- if current.next.char == tempcurrent.char then
+-- node.flush_list(tempcurrent)
+-- local n = node.copy(current)
+-- current.char = dotted_circle
+-- head = node.insert_after(head, current, n)
+-- else
+-- current.char = tempcurrent.char -- (assumes that result of blwf consists of one node)
+-- local freenode = current.next
+-- current.next = tmp
+-- tmp.prev = current
+-- node.free(freenode)
+-- node.flush_list(tempcurrent)
+-- if changestop then stop = current end
+-- end
+-- end
+-- end
+-- end
+-- end
+-- end
+--
+-- while not basefound do -- find base consonant
+-- if consonant[current.char] then
+-- set_attribute(current, state, 6) -- half
+-- if not firstcons then firstcons = current end
+-- lastcons = current
+-- if not base then
+-- base = current
+-- else --check whether consonant has below-base (or post-base) form
+-- local baseform = true
+-- for s=1,#sequences do
+-- local sequence = sequences[s]
+-- local dataset = datasets[s]
+-- featurevalue = dataset and dataset[1]
+-- if featurevalue and dataset[4] == "blwf" then
+-- local subtables = sequence.subtables
+-- for i=1,#subtables do
+-- local lookupname = subtables[i]
+-- local lookupcache = lookuphash[lookupname]
+-- if lookupcache then
+-- local lookupmatch = lookupcache[current.char]
+-- if lookupmatch then
+-- set_attribute(current, state, 8) -- blwf
+-- baseform = false
+-- end
+-- end
+-- end
+-- end
+-- end
+-- if baseform then base = current end
+-- end
+-- end
+-- basefound = current == stop
+-- current = current.next
+-- end
+-- if base ~= lastcons then -- if base consonant is not last one then move halant from base consonant to last one
+-- n = base.next
+-- if nukta[n.char] then n = n.next end
+-- if halant[n.char] then
+-- if lastcons ~= stop then
+-- local ln = lastcons.next
+-- if nukta[ln.char] then lastcons = ln end
+-- end
+-- local np, nn, ln = n.prev, n.next, lastcons.next
+-- np.next = n.next
+-- nn.prev = n.prev
+-- lastcons.next = n
+-- if ln then ln.prev = n end
+-- n.next = ln
+-- n.prev = lastcons
+-- if lastcons == stop then stop = n end
+-- end
+-- end
+--
+-- n = start.next
+-- if ra[start.char] and halant[n.char] and not ( n ~= stop and ( zwj[n.next.char] or zwnj[n.next.char] ) ) then -- if syllable starts with Ra + H then move this combination so that it follows either: the post-base 'matra' (if any) or the base consonant
+-- local matra = base
+-- if base ~= stop and dependent_vowel[base.next.char] then matra = base.next end
+-- local sp, nn, mn = start.prev, n.next, matra.next
+-- if sp then sp.next = nn end
+-- nn.prev = sp
+-- matra.next = start
+-- start.prev = matra
+-- n.next = mn
+-- if mn then mn.prev = n end
+-- if head == start then head = nn end
+-- start = nn
+-- if matra == stop then stop = n end
+-- end
+--
+-- local current = start
+-- while current ~= stop do
+-- if halant[current.next.char] and current.next ~= stop and zwnj[current.next.next.char] then unset_attribute(current, state) end
+-- current = current.next
+-- end
+--
+-- if has_attribute(base, state) and base ~= stop and halant[base.next.char] and not ( base.next ~= stop and zwj[base.next.next.char] ) then unset_attribute(base, state) end
+--
+-- local current, allreordered, moved = start, false, { [base] = true }
+-- local a, b, p, bn = base, base, base, base.next
+-- if base ~= stop and nukta[bn.char] then a, b, p = bn, bn, bn end
+-- while not allreordered do
+-- local c, n, l = current, current.next, nil --current is always consonant
+-- if c ~= stop and nukta[n.char] then c = n n = n.next end
+-- if c ~= stop and halant[n.char] then c = n n = n.next end
+-- while c ~= stop and dependent_vowel[n.char] do c = n n = n.next end
+-- if c ~= stop and vowel_modifier[n.char] then c = n n = n.next end
+-- if c ~= stop and stress_tone_mark[n.char] then c = n n = n.next end
+-- local bp, cn = firstcons.prev, current.next
+-- while cn ~= c.next do -- move pre-base matras...
+-- if pre_mark[cn.char] then
+-- if bp then bp.next = cn end
+-- cn.prev.next = cn.next
+-- if cn.next then cn.next.prev = cn.prev end
+-- if cn == stop then stop = cn.prev end
+-- cn.prev = bp
+-- cn.next = firstcons
+-- firstcons.prev = cn
+-- if firstcons == start then
+-- if head == start then head = cn end
+-- start = cn
+-- end
+-- break
+-- end
+-- cn = cn.next
+-- end
+-- allreordered = c == stop
+-- current = c.next
+-- end
+--
+-- if reph or vattu then
+-- local current, cns = start, nil
+-- while current ~= stop do
+-- local c, n = current, current.next
+-- if ra[current.char] and halant[n.char] then
+-- c, n = n, n.next
+-- local b, bn = base, base
+-- while bn ~= stop do
+-- if dependent_vowel[bn.next.char] then b = bn.next end
+-- bn = bn.next
+-- end
+-- if has_attribute(current,state,attribute) == 5 then -- position Reph (Ra + H) after post-base 'matra' (if any) since these become marks on the 'matra', not on the base glyph
+-- if b ~= current then
+-- if current == start then
+-- if head == start then head = n end
+-- start = n
+-- end
+-- if b == stop then stop = c end
+-- if current.prev then current.prev.next = n end
+-- if n then n.prev = current.prev end
+-- c.next = b.next
+-- if b.next then b.next.prev = c end
+-- b.next = current
+-- current.prev = b
+-- end
+-- elseif cns and cns.next ~= current then -- position below-base Ra (vattu) following the consonants on which it is placed (either the base consonant or one of the pre-base consonants)
+-- local cp, cnsn = current.prev, cns.next
+-- if cp then cp.next = n end
+-- if n then n.prev = cp end
+-- cns.next = current
+-- current.prev = cns
+-- c.next = cnsn
+-- if cnsn then cnsn.prev = c end
+-- if c == stop then stop = cp break end
+-- current = n.prev
+-- end
+-- elseif consonant[current.char] or nbsp[current.char] then
+-- cns = current
+-- if halant[cns.next.char] then cns = cns.next end
+-- end
+-- current = current.next
+-- end
+-- end
+--
+-- if nbsp[base.char] then
+-- head = node.remove(head, base)
+-- node.free(base)
+-- end
+--
+-- return head, stop
+-- end
+--
+-- function dev2_reorder_matras(start,kind,lookupname,replacement)
+-- local current = start
+-- while current and current.id == glyph and current.subtype<256 and current.font == start.font and has_attribute(current, sylnr) == has_attribute(start, sylnr) do
+-- if halant[current.char] and not has_attribute(current, state) then
+-- if current.next and current.next.id == glyph and current.next.subtype<256 and current.next.font == start.font and has_attribute(current.next, sylnr) == has_attribute(start, sylnr) and ( zwj[current.next.char] or zwnj[current.next.char] ) then current = current.next end
+-- local sn = start.next
+-- start.next.prev = start.prev
+-- if start.prev then start.prev.next = start.next end
+-- if current.next then current.next.prev = start end
+-- start.next = current.next
+-- current.next = start
+-- start.prev = current
+-- start = sn
+-- break
+-- end
+-- current = current.next
+-- end
+-- return start, true
+-- end
+--
+-- function dev2_reorder_reph(start,kind,lookupname,replacement)
+-- local current, sn = start.next, nil
+-- while current and current.id == glyph and current.subtype<256 and current.font == start.font and has_attribute(current, sylnr) == has_attribute(start, sylnr) do --step 2
+-- if halant[current.char] and not has_attribute(current, state) then
+-- if current.next and current.next.id == glyph and current.next.subtype<256 and current.next.font == start.font and has_attribute(current.next, sylnr) == has_attribute(start, sylnr) and ( zwj[current.next.char] or zwnj[current.next.char] ) then current = current.next end
+-- sn = start.next
+-- start.next.prev = start.prev
+-- if start.prev then start.prev.next = start.next end
+-- if current.next then current.next.prev = start end
+-- start.next = current.next
+-- current.next = start
+-- start.prev = current
+-- start = sn
+-- break
+-- end
+-- current = current.next
+-- end
+-- if not sn then
+-- current = start.next
+-- while current and current.id == glyph and current.subtype<256 and current.font == start.font and has_attribute(current, sylnr) == has_attribute(start, sylnr) do --step 4
+-- if has_attribute(current, state) == 9 then --post-base
+-- sn = start.next
+-- start.next.prev = start.prev
+-- if start.prev then start.prev.next = start.next end
+-- start.prev = current.prev
+-- current.prev.next = start
+-- start.next = current
+-- current.prev = start
+-- start = sn
+-- break
+-- end
+-- current = current.next
+-- end
+-- end
+-- if not sn then
+-- current = start.next
+-- local c = nil
+-- while current and current.id == glyph and current.subtype<256 and current.font == start.font and has_attribute(current, sylnr) == has_attribute(start, sylnr) do --step 5
+-- if not c and ( above_mark[current.char] or below_mark[current.char] or post_mark[current.char] ) and ReorderClass[current.char] ~= "after subscript" then c = current end
+-- current = current.next
+-- end
+-- if c then
+-- sn = start.next
+-- start.next.prev = start.prev
+-- if start.prev then start.prev.next = start.next end
+-- start.prev = c.prev
+-- c.prev.next = start
+-- start.next = c
+-- c.prev = start
+-- start = sn
+-- end
+-- end
+-- if not sn then
+-- current = start
+-- while current.next and current.next.id == glyph and current.next.subtype<256 and current.next.font == start.font and has_attribute(current.next, sylnr) == has_attribute(start, sylnr) do --step 6
+-- current = current.next
+-- end
+-- if start ~= current then
+-- sn = start.next
+-- start.next.prev = start.prev
+-- if start.prev then start.prev.next = start.next end
+-- if current.next then current.next.prev = start end
+-- start.next = current.next
+-- current.next = start
+-- start.prev = current
+-- start = sn
+-- end
+-- end
+-- return start, true
+-- end
+--
+-- function dev2_reorder_pre_base_reordering_consonants(start,kind,lookupname,replacement)
+-- local current, sn = start, nil
+-- while current and current.id == glyph and current.subtype<256 and current.font == start.font and has_attribute(current, sylnr) == has_attribute(start, sylnr) do
+-- if halant[current.char] and not has_attribute(current, state) then
+-- if current.next and current.next.id == glyph and current.next.subtype<256 and current.next.font == start.font and has_attribute(current.next, sylnr) == has_attribute(start, sylnr) and ( zwj[current.next.char] or zwnj[current.next.char] ) then current = current.next end
+-- sn = start.next
+-- start.next.prev = start.prev
+-- if start.prev then start.prev.next = start.next end
+-- if current.next then current.next.prev = start end
+-- start.next = current.next
+-- current.next = start
+-- start.prev = current
+-- start = sn
+-- break
+-- end
+-- current = current.next
+-- end
+-- if not sn then
+-- current = start.next
+-- while current and current.id == glyph and current.subtype<256 and current.font == start.font and has_attribute(current, sylnr) == has_attribute(start, sylnr) do
+-- if not consonant[current.char] and has_attribute(current, state) then --main
+-- sn = start.next
+-- start.next.prev = start.prev
+-- if start.prev then start.prev.next = start.next end
+-- start.prev = current.prev
+-- current.prev.next = start
+-- start.next = current
+-- current.prev = start
+-- start = sn
+-- break
+-- end
+-- current = current.next
+-- end
+-- end
+-- return start, true
+-- end
+--
+-- function remove_joiners(start,kind,lookupname,replacement)
+-- local stop = start.next
+-- while stop and stop.id == glyph and stop.subtype<256 and stop.font == start.font and (zwj[stop.char] or zwnj[stop.char]) do stop = stop.next end
+-- if stop then stop.prev.next = nil stop.prev = start.prev end
+-- if start.prev then start.prev.next = stop end
+-- node.flush_list(start)
+-- return stop, true
+-- end
+--
+-- local function dev2_reorder(head,start,stop,font,attr)
+-- local tfmdata = fontdata[font]
+-- local lookuphash = tfmdata.resources.lookuphash
+-- local sequences = tfmdata.resources.sequences
+--
+-- if not lookuphash["remove_joiners"] then install_dev(tfmdata) end --install Devanagari-features
+--
+-- local sharedfeatures = tfmdata.shared.features
+-- sharedfeatures["dev2_reorder_matras"] = true
+-- sharedfeatures["dev2_reorder_reph"] = true
+-- sharedfeatures["dev2_reorder_pre_base_reordering_consonants"] = true
+-- sharedfeatures["remove_joiners"] = true
+-- local datasets = otf.dataset(tfmdata,font,attr)
+--
+-- local reph, pre_base_reordering_consonants = false, nil
+-- local halfpos, basepos, subpos, postpos = nil, nil, nil, nil
+-- local locl = { }
+--
+-- for s=1,#sequences do -- classify chars
+-- local sequence = sequences[s]
+-- local dataset = datasets[s]
+-- featurevalue = dataset and dataset[1]
+-- if featurevalue and dataset[4] then
+-- local subtables = sequence.subtables
+-- for i=1,#subtables do
+-- local lookupname = subtables[i]
+-- local lookupcache = lookuphash[lookupname]
+-- if lookupcache then
+-- if dataset[4] == "rphf" then
+-- if dataset[3] ~= 0 then --rphf is result of of chain
+-- else
+-- reph = lookupcache[0x0930] and lookupcache[0x0930][0x094D] and lookupcache[0x0930][0x094D]["ligature"]
+-- end
+-- end
+-- if dataset[4] == "pref" and not pre_base_reordering_consonants then
+-- for k, v in pairs(lookupcache[0x094D]) do
+-- pre_base_reordering_consonants[k] = v and v["ligature"] --ToDo: reph might also be result of chain
+-- end
+-- end
+-- local current = start
+-- while current ~= stop.next do
+-- if dataset[4] == "locl" then locl[current] = lookupcache[current.char] end --ToDo: locl might also be result of chain
+-- if current ~= stop then
+-- local c, n = locl[current] or current.char, locl[current.next] or current.next.char
+-- if dataset[4] == "rphf" and lookupcache[c] and lookupcache[c][n] then --above-base: rphf Consonant + Halant
+-- if current.next ~= stop and ( zwj[current.next.next.char] or zwnj[current.next.next.char] ) then --ZWJ and ZWNJ prevent creation of reph
+-- current = current.next
+-- elseif current == start then
+-- set_attribute(current,state,5)
+-- end
+-- current = current.next
+-- end
+-- if dataset[4] == "half" and lookupcache[c] and lookupcache[c][n] then --half forms: half Consonant + Halant
+-- if current.next ~= stop and zwnj[current.next.next.char] then --ZWNJ prevent creation of half
+-- current = current.next
+-- else
+-- set_attribute(current,state,6)
+-- if not halfpos then halfpos = current end
+-- end
+-- current = current.next
+-- end
+-- if dataset[4] == "pref" and lookupcache[c] and lookupcache[c][n] then --pre-base: pref Halant + Consonant
+-- set_attribute(current,state,7)
+-- set_attribute(current.next,state,7)
+-- current = current.next
+-- end
+-- if dataset[4] == "blwf" and lookupcache[c] and lookupcache[c][n] then --below-base: blwf Halant + Consonant
+-- set_attribute(current,state,8)
+-- set_attribute(current.next,state,8)
+-- current = current.next
+-- subpos = current
+-- end
+-- if dataset[4] == "pstf" and lookupcache[c] and lookupcache[c][n] then --post-base: pstf Halant + Consonant
+-- set_attribute(current,state,9)
+-- set_attribute(current.next,state,9)
+-- current = current.next
+-- postpos = current
+-- end
+-- end
+-- current = current.next
+-- end
+-- end
+-- end
+-- end
+-- end
+--
+-- lookuphash["dev2_reorder_matras"] = pre_mark
+-- lookuphash["dev2_reorder_reph"] = { [reph] = true }
+-- lookuphash["dev2_reorder_pre_base_reordering_consonants"] = pre_base_reordering_consonants or { }
+-- lookuphash["remove_joiners"] = { [0x200C] = true, [0x200D] = true }
+--
+-- local current, base, firstcons = start, nil, nil
+-- if has_attribute(start,state) == 5 then current = start.next.next end -- if syllable starts with Ra + H and script has 'Reph' then exclude Reph from candidates for base consonants
+--
+-- if current ~= stop.next and nbsp[current.char] then --Stand Alone cluster
+-- if current == stop then
+-- stop = stop.prev
+-- head = node.remove(head, current)
+-- node.free(current)
+-- return head, stop
+-- else
+-- base = current
+-- current = current.next
+-- if current ~= stop then
+-- if nukta[current.char] then current = current.next end
+-- if zwj[current.char] then
+-- if current ~= stop and current.next ~= stop and halant[current.next.char] then
+-- current = current.next
+-- local tmp = current.next.next
+-- local changestop = current.next == stop
+-- current.next.next = nil
+-- set_attribute(current,state,7) --pref
+-- current = nodes.handlers.characters(current)
+-- set_attribute(current,state,8) --blwf
+-- current = nodes.handlers.characters(current)
+-- set_attribute(current,state,9) --pstf
+-- current = nodes.handlers.characters(current)
+-- unset_attribute(current,state)
+-- if halant[current.char] then
+-- current.next.next = tmp
+-- local nc = node.copy(current)
+-- current.char = dotted_circle
+-- head = node.insert_after(head, current, nc)
+-- else
+-- current.next = tmp -- (assumes that result of pref, blwf, or pstf consists of one node)
+-- if changestop then stop = current end
+-- end
+-- end
+-- end
+-- end
+-- end
+-- else --not Stand Alone cluster
+-- while current ~= stop.next do -- find base consonant
+-- if consonant[current.char] and not ( current ~= stop and halant[current.next.char] and current.next ~= stop and zwj[current.next.next.char] ) then
+-- if not firstcons then firstcons = current end
+-- if not ( has_attribute(current, state) == 7 or has_attribute(current, state) == 8 or has_attribute(current, state) == 9 ) then base = current end --check whether consonant has below-base or post-base form or is pre-base reordering Ra
+-- end
+-- current = current.next
+-- end
+-- if not base then
+-- base = firstcons
+-- end
+-- end
+--
+-- if not base then
+-- if has_attribute(start, state) == 5 then unset_attribute(start, state) end
+-- return head, stop
+-- else
+-- if has_attribute(base, state) then unset_attribute(base, state) end
+-- basepos = base
+-- end
+-- if not halfpos then halfpos = base end
+-- if not subpos then subpos = base end
+-- if not postpos then postpos = subpos or base end
+--
+-- --Matra characters are classified and reordered by which consonant in a conjunct they have affinity for
+-- local moved = { }
+-- current = start
+-- while current ~= stop.next do
+-- local char, target, cn = locl[current] or current.char, nil, current.next
+-- if not moved[current] and dependent_vowel[char] then
+-- if pre_mark[char] then -- Before first half form in the syllable
+-- moved[current] = true
+-- if current.prev then current.prev.next = current.next end
+-- if current.next then current.next.prev = current.prev end
+-- if current == stop then stop = current.prev end
+-- if halfpos == start then
+-- if head == start then head = current end
+-- start = current
+-- end
+-- if halfpos.prev then halfpos.prev.next = current end
+-- current.prev = halfpos.prev
+-- halfpos.prev = current
+-- current.next = halfpos
+-- halfpos = current
+-- elseif above_mark[char] then -- After main consonant
+-- target = basepos
+-- if subpos == basepos then subpos = current end
+-- if postpos == basepos then postpos = current end
+-- basepos = current
+-- elseif below_mark[char] then -- After subjoined consonants
+-- target = subpos
+-- if postpos == subpos then postpos = current end
+-- subpos = current
+-- elseif post_mark[char] then -- After post-form consonant
+-- target = postpos
+-- postpos = current
+-- end
+-- if ( above_mark[char] or below_mark[char] or post_mark[char] ) and current.prev ~= target then
+-- if current.prev then current.prev.next = current.next end
+-- if current.next then current.next.prev = current.prev end
+-- if current == stop then stop = current.prev end
+-- if target.next then target.next.prev = current end
+-- current.next = target.next
+-- target.next = current
+-- current.prev = target
+-- end
+-- end
+-- current = cn
+-- end
+--
+-- --Reorder marks to canonical order: Adjacent nukta and halant or nukta and vedic sign are always repositioned if necessary, so that the nukta is first.
+-- local current, c = start, nil
+-- while current ~= stop do
+-- if halant[current.char] or stress_tone_mark[current.char] then
+-- if not c then c = current end
+-- else
+-- c = nil
+-- end
+-- if c and nukta[current.next.char] then
+-- if head == c then head = current.next end
+-- if stop == current.next then stop = current end
+-- if c.prev then c.prev.next = current.next end
+-- current.next.prev = c.prev
+-- current.next = current.next.next
+-- if current.next.next then current.next.next.prev = current end
+-- c.prev = current.next
+-- current.next.next = c
+-- end
+-- if stop == current then break end
+-- current = current.next
+-- end
+--
+-- if nbsp[base.char] then
+-- head = node.remove(head, base)
+-- node.free(base)
+-- end
+--
+-- return head, stop
+-- end
+--
+-- function fonts.analyzers.methods.deva(head,font,attr)
+-- local orighead = head
+-- local current, start, done = head, true, false
+-- while current do
+-- if current.id == glyph and current.subtype<256 and current.font == font then
+-- done = true
+-- local syllablestart, syllableend = current, nil
+--
+-- local c = current --Checking Stand Alone cluster (this behavior is copied from dev2)
+-- if ra[c.char] and c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and halant[c.next.char] and c.next.next and c.next.next.id == glyph and c.next.next.subtype<256 and c.next.next.font == font then c = c.next.next end
+-- if nbsp[c.char] and ( not current.prev or current.prev.id ~= glyph or current.prev.subtype>=256 or current.prev.font ~= font or
+-- ( not consonant[current.prev.char] and not independent_vowel[current.prev.char] and not dependent_vowel[current.prev.char] and
+-- not vowel_modifier[current.prev.char] and not stress_tone_mark[current.prev.char] and not nukta[current.prev.char] and not halant[current.prev.char] )
+-- ) then --Stand Alone cluster (at the start of the word only): #[Ra+H]+NBSP+[N]+[<[<ZWJ|ZWNJ>]+H+C>]+[{M}+[N]+[H]]+[SM]+[(VD)]
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and nukta[c.next.char] then c = c.next end
+-- local n = c.next
+-- if n and n.id == glyph and n.subtype<256 and n.font == font then
+-- local ni = n.next
+-- if ( zwj[n.char] or zwnj[n.char] ) and ni and ni.id == glyph and ni.subtype<256 and ni.font == font then n = ni ni = ni.next end
+-- if halant[n.char] and ni and ni.id == glyph and ni.subtype<256 and ni.font == font and consonant[ni.char] then c = ni end
+-- end
+-- while c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and dependent_vowel[c.next.char] do c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and nukta[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and halant[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and vowel_modifier[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and stress_tone_mark[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and stress_tone_mark[c.next.char] then c = c.next end
+-- current = c.next
+-- syllableend = c
+-- if syllablestart ~= syllableend then
+-- head, current = deva_reorder(head, syllablestart,syllableend,font,attr)
+-- current = current.next
+-- end
+-- elseif consonant[current.char] then -- syllable containing consonant
+-- prevc = true
+-- while prevc do
+-- prevc = false
+-- local n = current.next
+-- if n and n.id == glyph and n.subtype<256 and n.font == font and nukta[n.char] then n = n.next end
+-- if n and n.id == glyph and n.subtype<256 and n.font == font and halant[n.char] then
+-- local n = n.next
+-- if n and n.id == glyph and n.subtype<256 and n.font == font and ( zwj[n.char] or zwnj[n.char] ) then n = n.next end
+-- if n and n.id == glyph and n.subtype<256 and n.font == font and consonant[n.char] then
+-- prevc = true
+-- current = n
+-- end
+-- end
+-- end
+-- if current.next and current.next.id == glyph and current.next.subtype<256 and current.next.font == font and nukta[current.next.char] then current = current.next end -- nukta (not specified in Microsft Devanagari OpenType specification)
+-- syllableend = current
+-- current = current.next
+-- if current and current.id == glyph and current.subtype<256 and current.font == font and halant[current.char] then -- syllable containing consonant without vowels: {C + [Nukta] + H} + C + H
+-- if current.next and current.next.id == glyph and current.next.subtype<256 and current.next.font == font and ( zwj[current.next.char] or zwnj[current.next.char] ) then current = current.next end
+-- syllableend = current
+-- current = current.next
+-- else -- syllable containing consonant with vowels: {C + [Nukta] + H} + C + [M] + [VM] + [SM]
+-- if current and current.id == glyph and current.subtype<256 and current.font == font and dependent_vowel[current.char] then
+-- syllableend = current
+-- current = current.next
+-- end
+-- if current and current.id == glyph and current.subtype<256 and current.font == font and vowel_modifier[current.char] then
+-- syllableend = current
+-- current = current.next
+-- end
+-- if current and current.id == glyph and current.subtype<256 and current.font == font and stress_tone_mark[current.char] then
+-- syllableend = current
+-- current = current.next
+-- end
+-- end
+-- if syllablestart ~= syllableend then
+-- head, current = deva_reorder(head,syllablestart,syllableend,font,attr)
+-- current = current.next
+-- end
+-- elseif current.id == glyph and current.subtype<256 and current.font == font and independent_vowel[current.char] then -- syllable without consonants: VO + [VM] + [SM]
+-- syllableend = current
+-- current = current.next
+-- if current and current.id == glyph and current.subtype<256 and current.font == font and vowel_modifier[current.char] then
+-- syllableend = current
+-- current = current.next
+-- end
+-- if current and current.id == glyph and current.subtype<256 and current.font == font and stress_tone_mark[current.char] then
+-- syllableend = current
+-- current = current.next
+-- end
+-- else -- Syntax error
+-- if pre_mark[current.char] or above_mark[current.char] or below_mark[current.char] or post_mark[current.char] then
+-- local n = node.copy(current)
+-- if pre_mark[current.char] then
+-- n.char = dotted_circle
+-- else
+-- current.char = dotted_circle
+-- end
+-- head, current = node.insert_after(head, current, n)
+-- end
+-- current = current.next
+-- end
+-- else
+-- current = current.next
+-- end
+-- start = false
+-- end
+--
+-- return head, done
+-- end
+--
+-- function fonts.analyzers.methods.dev2(head,font,attr)
+-- local current, start, done, syl_nr = head, true, false, 0
+-- while current do
+-- local syllablestart, syllableend = nil, nil
+-- if current.id == glyph and current.subtype<256 and current.font == font then
+-- syllablestart = current
+-- done = true
+-- local c, n = current, current.next
+-- if ra[current.char] and n and n.id == glyph and n.subtype<256 and n.font == font and halant[n.char] and n.next and n.next.id == glyph and n.next.subtype<256 and n.next.font == font then c = n.next end
+-- if independent_vowel[c.char] then --Vowel-based syllable: [Ra+H]+V+[N]+[<[<ZWJ|ZWNJ>]+H+C|ZWJ+C>]+[{M}+[N]+[H]]+[SM]+[(VD)]
+-- n = c.next
+-- local ni, nii = nil, nil
+-- if n and n.id == glyph and n.subtype<256 and n.font == font and nukta[n.char] then n = n.next end
+-- if n and n.id == glyph and n.subtype<256 and n.font == font then local ni = n.next end
+-- if ni and ni.id == glyph and ni.subtype<256 and ni.font == font and ni.next and ni.next.id == glyph and ni.next.subtype<256 and ni.next.font == font then
+-- nii = ni.next
+-- if zwj[ni.char] and consonant[nii.char] then
+-- c = nii
+-- elseif (zwj[ni.char] or zwnj[ni.char]) and halant[nii.char] and nii.next and nii.next.id == glyph and nii.next.subtype<256 and nii.next.font == font and consonant[nii.next.char] then
+-- c = nii.next
+-- end
+-- end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and dependent_vowel[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and nukta[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and halant[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and vowel_modifier[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and stress_tone_mark[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and stress_tone_mark[c.next.char] then c = c.next end
+-- current = c
+-- syllableend = c
+-- elseif nbsp[c.char] and ( not current.prev or current.prev.id ~= glyph or current.prev.subtype>=256 or current.prev.font ~= font or
+-- ( not consonant[current.prev.char] and not independent_vowel[current.prev.char] and not dependent_vowel[current.prev.char] and
+-- not vowel_modifier[current.prev.char] and not stress_tone_mark[current.prev.char] and not nukta[current.prev.char] and not halant[current.prev.char] )
+-- ) then --Stand Alone cluster (at the start of the word only): #[Ra+H]+NBSP+[N]+[<[<ZWJ|ZWNJ>]+H+C>]+[{M}+[N]+[H]]+[SM]+[(VD)]
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and nukta[c.next.char] then c = c.next end
+-- n = c.next
+-- if n and n.id == glyph and n.subtype<256 and n.font == font then
+-- local ni = n.next
+-- if ( zwj[n.char] or zwnj[n.char] ) and ni and ni.id == glyph and ni.subtype<256 and ni.font == font then n = ni ni = ni.next end
+-- if halant[n.char] and ni and ni.id == glyph and ni.subtype<256 and ni.font == font and consonant[ni.char] then c = ni end
+-- end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and dependent_vowel[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and nukta[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and halant[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and vowel_modifier[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and stress_tone_mark[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and stress_tone_mark[c.next.char] then c = c.next end
+-- current = c
+-- syllableend = c
+-- elseif consonant[current.char] then --Consonant syllable: {C+[N]+<H+[<ZWNJ|ZWJ>]|<ZWNJ|ZWJ>+H>} + C+[N]+[A] + [< H+[<ZWNJ|ZWJ>] | {M}+[N]+[H]>]+[SM]+[(VD)]
+-- c = current
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and nukta[c.next.char] then c = c.next end
+-- n = c
+-- while n.next and n.next.id == glyph and n.next.subtype<256 and n.next.font == font and ( halant[n.next.char] or zwnj[n.next.char] or zwj[n.next.char] ) do
+-- if halant[n.next.char] then
+-- n = n.next
+-- if n.next and n.next.id == glyph and n.next.subtype<256 and n.next.font == font and ( zwnj[n.next.char] or zwj[n.next.char] ) then n = n.next end
+-- else
+-- if n.next.next and n.next.next.id == glyph and n.next.next.subtype<256 and n.next.next.font == font and halant[n.next.next.char] then n = n.next.next end
+-- end
+-- if n.next and n.next.id == glyph and n.next.subtype<256 and n.next.font == font and consonant[n.next.char] then
+-- n = n.next
+-- if n.next and n.next.id == glyph and n.next.subtype<256 and n.next.font == font and nukta[n.next.char] then n = n.next end
+-- c = n
+-- else
+-- break
+-- end
+-- end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and anudatta[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and halant[c.next.char] then
+-- c = c.next
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and ( zwnj[c.next.char] or zwj[c.next.char] ) then c = c.next end
+-- else
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and dependent_vowel[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and nukta[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and halant[c.next.char] then c = c.next end
+-- end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and vowel_modifier[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and stress_tone_mark[c.next.char] then c = c.next end
+-- if c.next and c.next.id == glyph and c.next.subtype<256 and c.next.font == font and stress_tone_mark[c.next.char] then c = c.next end
+-- current = c
+-- syllableend = c
+-- end
+-- end
+--
+-- if syllableend then
+-- syl_nr = syl_nr + 1
+-- c = syllablestart
+-- while c ~= syllableend.next do
+-- set_attribute(c,sylnr,syl_nr)
+-- c = c.next
+-- end
+-- end
+-- if syllableend and syllablestart ~= syllableend then
+-- head, current = dev2_reorder(head,syllablestart,syllableend,font,attr)
+-- end
+--
+-- if not syllableend and not has_attribute(current, state) and current.id == glyph and current.subtype<256 and current.font == font then -- Syntax error
+-- if pre_mark[current.char] or above_mark[current.char] or below_mark[current.char] or post_mark[current.char] then
+-- local n = node.copy(current)
+-- if pre_mark[current.char] then
+-- n.char = dotted_circle
+-- else
+-- current.char = dotted_circle
+-- end
+-- head, current = node.insert_after(head, current, n)
+-- end
+-- end
+--
+-- start = false
+-- current = current.next
+-- end
+--
+-- return head, done
+-- end
+--
+-- function otf.handlers.dev2_reorder_matras(start,kind,lookupname,replacement)
+-- return dev2_reorder_matras(start,kind,lookupname,replacement)
+-- end
+--
+-- function otf.handlers.dev2_reorder_reph(start,kind,lookupname,replacement)
+-- return dev2_reorder_reph(start,kind,lookupname,replacement)
+-- end
+--
+-- function otf.handlers.dev2_reorder_pre_base_reordering_consonants(start,kind,lookupname,replacement)
+-- return dev2_reorder_pre_base_reordering_consonants(start,kind,lookupname,replacement)
+-- end
+--
+-- function otf.handlers.remove_joiners(start,kind,lookupname,replacement)
+-- return remove_joiners(start,kind,lookupname,replacement)
+-- end
diff --git a/tex/context/base/font-otn.lua b/tex/context/base/font-otn.lua
index 2c6016427..59d0cac9a 100644
--- a/tex/context/base/font-otn.lua
+++ b/tex/context/base/font-otn.lua
@@ -3,9 +3,11 @@ if not modules then modules = { } end modules ['font-otn'] = {
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"
+ license = "see context related readme files",
}
+-- preprocessors = { "nodes" }
+
-- this is still somewhat preliminary and it will get better in due time;
-- much functionality could only be implemented thanks to the husayni font
-- of Idris Samawi Hamid to who we dedicate this module.
@@ -404,80 +406,6 @@ local function getcomponentindex(start)
end
end
--- local function toligature(kind,lookupname,start,stop,char,markflag,discfound) -- brr head
--- if start == stop and start.char == char then
--- start.char = char
--- return start
--- elseif discfound then
--- local prev = start.prev
--- local next = stop.next
--- start.prev = nil
--- stop.next = nil
--- local base = copy_glyph(start)
--- base.char = char
--- base.subtype = ligature_code
--- base.components = start -- start can have components
--- if prev then
--- prev.next = base
--- end
--- if next then
--- next.prev = base
--- end
--- base.next = next
--- base.prev = prev
--- return base
--- else
--- -- start is the ligature
--- local deletemarks = markflag ~= "mark"
--- local prev = start.prev
--- local next = stop.next
--- local base = copy_glyph(start)
--- local current, start = insert_node_after(start,start,base)
--- -- [start->current][copyofstart->start]...[stop]
--- current.next = next
--- if next then
--- next.prev = current
--- end
--- start.prev = nil
--- stop.next = nil
--- current.char = char
--- current.subtype = ligature_code
--- current.components = start
--- local head = current
--- -- this is messy ... we should get rid of the components eventually
--- local baseindex = 0
--- local componentindex = 0
--- while start do
--- local char = start.char
--- if not marks[char] then
--- baseindex = baseindex + componentindex
--- componentindex = getcomponentindex(start)
--- elseif not deletemarks then -- quite fishy
--- set_attribute(start,ligacomp,baseindex + (has_attribute(start,ligacomp) or componentindex))
--- if trace_marks then
--- logwarning("%s: keep mark %s, gets index %s",pref(kind,lookupname),gref(char),has_attribute(start,ligacomp))
--- end
--- head, current = insert_node_after(head,current,copy_glyph(start)) -- unlikely that mark has components
--- end
--- start = start.next
--- end
--- start = current.next
--- while start and start.id == glyph_code do -- hm, is id test needed ?
--- local char = start.char
--- if marks[char] then
--- set_attribute(start,ligacomp,baseindex + (has_attribute(start,ligacomp) or componentindex))
--- if trace_marks then
--- logwarning("%s: keep mark %s, gets index %s",pref(kind,lookupname),gref(char),has_attribute(start,ligacomp))
--- end
--- else
--- break
--- end
--- start = start.next
--- end
--- return head
--- end
--- end
-
local function toligature(kind,lookupname,start,stop,char,markflag,discfound) -- brr head
if start == stop and start.char == char then
start.char = char
@@ -848,9 +776,6 @@ function handlers.gpos_mark2mark(start,kind,lookupname,markanchors,sequence)
local markchar = start.char
if marks[markchar] then
local base = start.prev -- [glyph] [basemark] [start=mark]
- -- while base and has_attribute(base,ligacomp) and has_attribute(base,ligacomp) ~= has_attribute(start,ligacomp) do
- -- base = base.prev -- KE: prevents mkmk for marks on different components of a ligature
- -- end
local slc = has_attribute(start,ligacomp)
if slc then -- a rather messy loop ... needs checking with husayni
while base do
@@ -1505,9 +1430,6 @@ function chainprocs.gpos_mark2mark(start,stop,kind,chainname,currentcontext,look
end
if markanchors then
local base = start.prev -- [glyph] [basemark] [start=mark]
- -- while (base and has_attribute(base,ligacomp) and has_attribute(base,ligacomp) ~= has_attribute(start,ligacomp)) do
- -- base = base.prev -- KE: prevents mkmk for marks on different components of a ligature
- -- end
local slc = has_attribute(start,ligacomp)
if slc then -- a rather messy loop ... needs checking with husayni
while base do
diff --git a/tex/context/base/luat-env.lua b/tex/context/base/luat-env.lua
index a00acdc63..e483169fd 100644
--- a/tex/context/base/luat-env.lua
+++ b/tex/context/base/luat-env.lua
@@ -21,11 +21,12 @@ local allocate, mark = utilities.storage.allocate, utilities.storage.mark
local format, sub, match, gsub, find = string.format, string.sub, string.match, string.gsub, string.find
local unquoted, quoted = string.unquoted, string.quoted
local concat, insert, remove = table.concat, table.insert, table.remove
-local loadedluacode = utilities.lua.loadedluacode
-local luasuffixes = utilities.lua.suffixes
-environment = environment or { }
-local environment = environment
+local luautilities = utilities.lua
+local luasuffixes = luautilities.suffixes
+
+environment = environment or { }
+local environment = environment
-- precautions
@@ -314,7 +315,7 @@ function environment.luafilechunk(filename,silent) -- used for loading lua bytec
filename = file.replacesuffix(filename, "lua")
local fullname = environment.luafile(filename)
if fullname and fullname ~= "" then
- local data = loadedluacode(fullname,strippable,filename)
+ local data = luautilities.loadedluacode(fullname,strippable,filename) -- can be overloaded
if trace_locating then
report_lua("loading file %s%s", fullname, not data and " failed" or "")
elseif not silent then
diff --git a/tex/context/base/luat-lib.mkiv b/tex/context/base/luat-lib.mkiv
index 283ed8998..521ecbf5e 100644
--- a/tex/context/base/luat-lib.mkiv
+++ b/tex/context/base/luat-lib.mkiv
@@ -71,6 +71,7 @@
\registerctxluafile{luat-bwc}{1.001}
\registerctxluafile{trac-lmx}{1.001} % might become l-lmx or luat-lmx
\registerctxluafile{luat-mac}{1.001}
+%registerctxluafile{luat-prp}{1.001} % for the moment of not much use
\registerctxluafile{lxml-tab}{1.001}
\registerctxluafile{lxml-lpt}{1.001}
diff --git a/tex/context/base/math-tag.lua b/tex/context/base/math-tag.lua
index 0ac5b0897..c504b610a 100644
--- a/tex/context/base/math-tag.lua
+++ b/tex/context/base/math-tag.lua
@@ -127,7 +127,7 @@ process = function(start) -- we cannot use the processor as we have no finalizer
-- check for code
local a = get_attribute(start,a_mathcategory)
if a then
- set_attribute(start,a_tagged,start_tagged("ms"),{ detail = a })
+ set_attribute(start,a_tagged,start_tagged("ms",{ detail = a }))
else
set_attribute(start,a_tagged,start_tagged("ms"))
end
diff --git a/tex/context/base/mlib-ctx.lua b/tex/context/base/mlib-ctx.lua
index 5a3becd7a..5d976d161 100644
--- a/tex/context/base/mlib-ctx.lua
+++ b/tex/context/base/mlib-ctx.lua
@@ -103,11 +103,15 @@ end
statistics.register("metapost processing time", function()
local n = metapost.n
if n and n > 0 then
- local e, t = metapost.makempy.nofconverted, statistics.elapsedtime
- local str = format("%s seconds, loading: %s seconds, execution: %s seconds, n: %s",
- t(metapost), t(mplib), t(metapost.exectime), n)
- if e > 0 then
- return format("%s, external: %s seconds (%s calls)", str, t(metapost.makempy), e)
+ local nofconverted = metapost.makempy.nofconverted
+ local elapsedtime = statistics.elapsedtime
+ local elapsed = statistics.elapsed
+ local str = format("%s seconds, loading: %s, execution: %s, n: %s, average: %s",
+ elapsedtime(metapost), elapsedtime(mplib), elapsedtime(metapost.exectime), n,
+ elapsedtime((elapsed(metapost) + elapsed(mplib) + elapsed(metapost.exectime)) / n))
+ if nofconverted > 0 then
+ return format("%s, external: %s (%s calls)",
+ str, elapsedtime(metapost.makempy), nofconverted)
else
return str
end
diff --git a/tex/context/base/mlib-pps.lua b/tex/context/base/mlib-pps.lua
index 43a548c65..8e69066d0 100644
--- a/tex/context/base/mlib-pps.lua
+++ b/tex/context/base/mlib-pps.lua
@@ -479,6 +479,8 @@ local function sxsy(wd,ht,dp) -- helper for text
return (wd ~= 0 and factor/wd) or 0, (hd ~= 0 and factor/hd) or 0
end
+local no_first_run = "mfun_first_run := false ;"
+local do_first_run = "mfun_first_run := true ;"
local no_trial_run = "mfun_trial_run := false ;"
local do_trial_run = "mfun_trial_run := true ;"
local do_begin_fig = "; beginfig(1) ; "
@@ -588,6 +590,7 @@ function metapost.graphic_base_pass(specification)
extensions,
inclusions,
wrappit and do_begin_fig or "",
+ do_first_run,
do_trial_run,
current_initializations,
do_safeguard,
@@ -611,6 +614,7 @@ function metapost.graphic_base_pass(specification)
metapost.process(mpx, {
preamble,
wrappit and do_begin_fig or "",
+ do_first_run,
no_trial_run,
current_initializations,
do_safeguard,
diff --git a/tex/context/base/mlib-run.lua b/tex/context/base/mlib-run.lua
index 6a23fe316..16ab55c3b 100644
--- a/tex/context/base/mlib-run.lua
+++ b/tex/context/base/mlib-run.lua
@@ -161,8 +161,11 @@ function metapost.reporterror(result)
if t and t ~= "" then
(metapost.texerrors and texerrormessage or report_metapost)("terminal: %s",t)
end
+ if e == "" or e == "no-error" then
+ e = nil
+ end
if e then
- (metapost.texerrors and texerrormessage or report_metapost)("error: %s",(e=="" and "?") or e)
+ (metapost.texerrors and texerrormessage or report_metapost)("error: %s",e)
end
if not t and not e and l then
metapost.lastlog = metapost.lastlog .. "\n" .. l
@@ -458,7 +461,7 @@ function metapost.process(mpx, data, trialrun, flusher, multipass, isextrapass,
end
if not metapost.reporterror(result) then
if metapost.showlog then
- local str = (result.term ~= "" and result.term) or "no terminal output"
+ local str = result.term ~= "" and result.term or "no terminal output"
if not emptystring(str) then
metapost.lastlog = metapost.lastlog .. "\n" .. str
report_metapost("log: %s",str)
diff --git a/tex/context/base/node-fin.lua b/tex/context/base/node-fin.lua
index 506fc724f..9bcfa0a7b 100644
--- a/tex/context/base/node-fin.lua
+++ b/tex/context/base/node-fin.lua
@@ -3,7 +3,7 @@ if not modules then modules = { } end modules ['node-fin'] = {
comment = "companion to node-fin.mkiv",
author = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright = "PRAGMA ADE / ConTeXt Development Team",
- license = "see context related readme files"
+ license = "see context related readme files",
}
-- this module is being reconstructed
diff --git a/tex/context/base/node-fnt.lua b/tex/context/base/node-fnt.lua
index 49e1029e7..a97c98d83 100644
--- a/tex/context/base/node-fnt.lua
+++ b/tex/context/base/node-fnt.lua
@@ -3,7 +3,7 @@ if not modules then modules = { } end modules ['node-fnt'] = {
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"
+ license = "see context related readme files",
}
if not context then os.exit() end -- generic function in node-dum
@@ -219,7 +219,7 @@ function handlers.characters(head)
return head, true
end
--- function handlers.xcharacters(head)
+-- function handlers.characters(head)
-- -- either next or not, but definitely no already processed list
-- starttiming(nodes)
-- local usedfonts, attrfonts, done = { }, { }, false
diff --git a/tex/context/base/node-ini.lua b/tex/context/base/node-ini.lua
index a294643b2..7f33a0149 100644
--- a/tex/context/base/node-ini.lua
+++ b/tex/context/base/node-ini.lua
@@ -174,7 +174,7 @@ whatcodes = allocate(swapped(whatcodes, whatcodes ))
listcodes = allocate(swapped(listcodes, listcodes ))
glyphcodes = allocate(swapped(glyphcodes, glyphcodes))
kerncodes = allocate(swapped(kerncodes, kerncodes ))
-penaltycodes = allocate(swapped(penaltycodes, penaltycodes ))
+penaltycodes = allocate(swapped(penaltycodes, penaltycodes))
mathcodes = allocate(swapped(mathcodes, mathcodes ))
fillcodes = allocate(swapped(fillcodes, fillcodes ))
diff --git a/tex/context/base/node-ini.mkiv b/tex/context/base/node-ini.mkiv
index 79e02ff46..4eeafe442 100644
--- a/tex/context/base/node-ini.mkiv
+++ b/tex/context/base/node-ini.mkiv
@@ -31,6 +31,7 @@
\registerctxluafile{node-ext}{1.001}
%registerctxluafile{node-inj}{1.001} % we might split it off
\registerctxluafile{node-acc}{1.001} % experimental
+%registerctxluafile{node-prp}{1.001} % makes no sense (yet)
\newcount\c_node_tracers_show_box % box number
diff --git a/tex/context/base/node-inj.lua b/tex/context/base/node-inj.lua
index 33eaa6eb1..b03ded9f2 100644
--- a/tex/context/base/node-inj.lua
+++ b/tex/context/base/node-inj.lua
@@ -3,7 +3,7 @@ if not modules then modules = { } end modules ['node-inj'] = {
comment = "companion to node-ini.mkiv",
author = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright = "PRAGMA ADE / ConTeXt Development Team",
- license = "see context related readme files"
+ license = "see context related readme files",
}
-- This is very experimental (this will change when we have luatex > .50 and
diff --git a/tex/context/base/spac-chr.lua b/tex/context/base/spac-chr.lua
index 00c3d6766..2db0b9a7b 100644
--- a/tex/context/base/spac-chr.lua
+++ b/tex/context/base/spac-chr.lua
@@ -78,7 +78,7 @@ local function inject_char_space(unicode,head,current,parent)
local glue = new_glue(char and char.width or fontparameters[font].space)
-- glue.attr = copy_node_list(current.attr)
glue.attr = current.attr
-current.attr = nil
+ current.attr = nil
set_attribute(glue,a_character,unicode)
head, current = insert_node_after(head,current,glue)
return head, current
diff --git a/tex/context/base/spac-hor.mkiv b/tex/context/base/spac-hor.mkiv
index d40bcf3ee..42661010b 100644
--- a/tex/context/base/spac-hor.mkiv
+++ b/tex/context/base/spac-hor.mkiv
@@ -215,7 +215,7 @@
\let\dorechecknextindentation\relax % public (in macros)
-\def\spac_indentation_check_next_indentation
+\unexpanded\def\spac_indentation_check_next_indentation
{\global\let\dorechecknextindentation\relax
\doifnextcharelse\par\donothing\spac_indentation_variant_no} % messy check as next is seldom \par
@@ -969,7 +969,7 @@
{\futurelet\nexttoken\spac_spaces_auto_insert_next}
\def\spac_spaces_auto_insert_next
- {\ctxcommand{autonextspace("\meaning\nexttoken")}} % todo, just consult nexttoken at the lua end
+ {\ctxcommand{autonextspace(\!!bs\meaning\nexttoken\!!es)}} % todo, just consult nexttoken at the lua end
%D Moved from bib module:
diff --git a/tex/context/base/status-files.pdf b/tex/context/base/status-files.pdf
index 05e831c58..49660f7d2 100644
--- a/tex/context/base/status-files.pdf
+++ b/tex/context/base/status-files.pdf
Binary files differ
diff --git a/tex/context/base/status-lua.pdf b/tex/context/base/status-lua.pdf
index e045bc941..90da15dfd 100644
--- a/tex/context/base/status-lua.pdf
+++ b/tex/context/base/status-lua.pdf
Binary files differ
diff --git a/tex/context/base/trac-inf.lua b/tex/context/base/trac-inf.lua
index 5575639eb..826271169 100644
--- a/tex/context/base/trac-inf.lua
+++ b/tex/context/base/trac-inf.lua
@@ -11,6 +11,7 @@ if not modules then modules = { } end modules ['trac-inf'] = {
-- get warnings about assignments. This is more efficient than using rawset
-- and rawget.
+local type, tonumber = type, tonumber
local format, lower = string.format, string.lower
local concat = table.concat
local clock = os.gettimeofday or os.clock -- should go in environment
@@ -72,19 +73,26 @@ local function stoptiming(instance, report)
return 0
end
+local function elapsed(instance)
+ if type(instance) == "table" then
+ local timer = timers[instance or "notimer"]
+ return timer and timer.loadtime or 0
+ else
+ return tonumber(instance) or 0
+ end
+end
+
local function elapsedtime(instance)
- local timer = timers[instance or "notimer"]
- return format("%0.3f",timer and timer.loadtime or 0)
+ return format("%0.3f",elapsed(instance))
end
local function elapsedindeed(instance)
- local timer = timers[instance or "notimer"]
- return (timer and timer.loadtime or 0) > statistics.threshold
+ return elapsed(instance) > statistics.threshold
end
local function elapsedseconds(instance,rest) -- returns nil if 0 seconds
if elapsedindeed(instance) then
- return format("%s seconds %s", elapsedtime(instance),rest or "")
+ return format("%0.3f seconds %s", elapsed(instance),rest or "")
end
end
@@ -92,6 +100,7 @@ statistics.hastiming = hastiming
statistics.resettiming = resettiming
statistics.starttiming = starttiming
statistics.stoptiming = stoptiming
+statistics.elapsed = elapsed
statistics.elapsedtime = elapsedtime
statistics.elapsedindeed = elapsedindeed
statistics.elapsedseconds = elapsedseconds
diff --git a/tex/context/base/typo-dir.lua b/tex/context/base/typo-dir.lua
index ee9407074..da324b7e2 100644
--- a/tex/context/base/typo-dir.lua
+++ b/tex/context/base/typo-dir.lua
@@ -180,7 +180,6 @@ function directions.process(namespace,attribute,start) -- todo: make faster
local lro, rlo, prevattr, inmath = false, false, 0, false
while current do
local id = current.id
---~ print(id,attribute,has_attribute(current,attribute))
if skipmath and id == math_code then
local subtype = current.subtype
if subtype == beginmath_code then
diff --git a/tex/context/base/util-lua.lua b/tex/context/base/util-lua.lua
index b496880b2..36daaff55 100644
--- a/tex/context/base/util-lua.lua
+++ b/tex/context/base/util-lua.lua
@@ -41,6 +41,8 @@ local function fatalerror(name)
utilities.report(format("fatal error in %q",name or "unknown"))
end
+-- environment.loadpreprocessedfile can be set to a preprocessor
+
if jit or status.luatex_version >= 74 then
local function register(name)
@@ -76,7 +78,7 @@ if jit or status.luatex_version >= 74 then
function luautilities.loadedluacode(fullname,forcestrip,name)
-- quite subtle ... doing this wrong incidentally can give more bytes
name = name or fullname
- local code = loadfile(fullname)
+ local code = environment.loadpreprocessedfile and environment.loadpreprocessedfile(fullname) or loadfile(fullname)
if code then
code()
end
@@ -229,8 +231,7 @@ else
function luautilities.loadedluacode(fullname,forcestrip,name)
-- quite subtle ... doing this wrong incidentally can give more bytes
- name = name or fullname
- local code = loadfile(fullname)
+ local code = environment.loadpreprocessedfile and environment.preprocessedloadfile(fullname) or loadfile(fullname)
if code then
code()
end
diff --git a/tex/generic/context/luatex/luatex-fonts-merged.lua b/tex/generic/context/luatex/luatex-fonts-merged.lua
index 60e2a7942..5739422b5 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 : luatex-fonts-merged.lua
-- parent file : luatex-fonts.lua
--- merge date : 01/13/13 23:10:29
+-- merge date : 01/17/13 18:16:10
do -- begin closure to overcome local limits and interference
@@ -8480,7 +8480,7 @@ if not modules then modules = { } end modules ['node-inj'] = {
comment = "companion to node-ini.mkiv",
author = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright = "PRAGMA ADE / ConTeXt Development Team",
- license = "see context related readme files"
+ license = "see context related readme files",
}
-- This is very experimental (this will change when we have luatex > .50 and
@@ -8508,9 +8508,6 @@ local nodepool = nodes.pool
local newkern = nodepool.kern
local traverse_id = node.traverse_id
-local unset_attribute = node.unset_attribute
-local has_attribute = node.has_attribute
-local set_attribute = node.set_attribute
local insert_node_before = node.insert_before
local insert_node_after = node.insert_after
@@ -8547,8 +8544,8 @@ function injections.setcursive(start,nxt,factor,rlmode,exit,entry,tfmstart,tfmne
local dx, dy = factor*(exit[1]-entry[1]), factor*(exit[2]-entry[2])
local ws, wn = tfmstart.width, tfmnext.width
local bound = #cursives + 1
- set_attribute(start,cursbase,bound)
- set_attribute(nxt,curscurs,bound)
+ start[cursbase] = bound
+ nxt[curscurs] = bound
cursives[bound] = { rlmode, dx, dy, ws, wn }
return dx, dy, bound
end
@@ -8557,14 +8554,14 @@ function injections.setpair(current,factor,rlmode,r2lflag,spec,tfmchr)
local x, y, w, h = factor*spec[1], factor*spec[2], factor*spec[3], factor*spec[4]
-- dy = y - h
if x ~= 0 or w ~= 0 or y ~= 0 or h ~= 0 then
- local bound = has_attribute(current,kernpair)
+ local bound = current[kernpair]
if bound then
local kb = kerns[bound]
-- inefficient but singles have less, but weird anyway, needs checking
kb[2], kb[3], kb[4], kb[5] = (kb[2] or 0) + x, (kb[3] or 0) + y, (kb[4] or 0)+ w, (kb[5] or 0) + h
else
bound = #kerns + 1
- set_attribute(current,kernpair,bound)
+ current[kernpair] = bound
kerns[bound] = { rlmode, x, y, w, h, r2lflag, tfmchr.width }
end
return x, y, w, h, bound
@@ -8576,7 +8573,7 @@ function injections.setkern(current,factor,rlmode,x,tfmchr)
local dx = factor*x
if dx ~= 0 then
local bound = #kerns + 1
- set_attribute(current,kernpair,bound)
+ current[kernpair] = bound
kerns[bound] = { rlmode, dx }
return dx, bound
else
@@ -8586,7 +8583,7 @@ end
function injections.setmark(start,base,factor,rlmode,ba,ma,index) -- ba=baseanchor, ma=markanchor
local dx, dy = factor*(ba[1]-ma[1]), factor*(ba[2]-ma[2]) -- the index argument is no longer used but when this
- local bound = has_attribute(base,markbase) -- fails again we should pass it
+ local bound = base[markbase] -- fails again we should pass it
local index = 1
if bound then
local mb = marks[bound]
@@ -8594,8 +8591,8 @@ local index = 1
-- if not index then index = #mb + 1 end
index = #mb + 1
mb[index] = { dx, dy, rlmode }
- set_attribute(start,markmark,bound)
- set_attribute(start,markdone,index)
+ start[markmark] = bound
+ start[markdone] = index
return dx, dy, bound
else
report_injections("possible problem, U+%05X is base mark without data (id: %s)",base.char,bound)
@@ -8604,9 +8601,9 @@ index = #mb + 1
-- index = index or 1
index = index or 1
bound = #marks + 1
- set_attribute(base,markbase,bound)
- set_attribute(start,markmark,bound)
- set_attribute(start,markdone,index)
+ base[markbase] = bound
+ start[markmark] = bound
+ start[markdone] = index
marks[bound] = { [index] = { dx, dy, rlmode } }
return dx, dy, bound
end
@@ -8619,12 +8616,12 @@ local function trace(head)
report_injections("begin run")
for n in traverse_id(glyph_code,head) do
if n.subtype < 256 then
- local kp = has_attribute(n,kernpair)
- local mb = has_attribute(n,markbase)
- local mm = has_attribute(n,markmark)
- local md = has_attribute(n,markdone)
- local cb = has_attribute(n,cursbase)
- local cc = has_attribute(n,curscurs)
+ local kp = n[kernpair]
+ local mb = n[markbase]
+ local mm = n[markmark]
+ local md = n[markdone]
+ local cb = n[cursbase]
+ local cc = n[curscurs]
report_injections("char U+%05X, font=%s",n.char,n.font)
if kp then
local k = kerns[kp]
@@ -8690,7 +8687,7 @@ function injections.handler(head,where,keep)
if tm then
mk[n] = tm[n.char]
end
- local k = has_attribute(n,kernpair)
+ local k = n[kernpair]
if k then
local kk = kerns[k]
if kk then
@@ -8739,9 +8736,9 @@ function injections.handler(head,where,keep)
for i=1,nofvalid do -- valid == glyphs
local n = valid[i]
if not mk[n] then
- local n_cursbase = has_attribute(n,cursbase)
+ local n_cursbase = n[cursbase]
if p_cursbase then
- local n_curscurs = has_attribute(n,curscurs)
+ local n_curscurs = n[curscurs]
if p_cursbase == n_curscurs then
local c = cursives[n_curscurs]
if c then
@@ -8802,14 +8799,14 @@ function injections.handler(head,where,keep)
if has_marks then
for i=1,nofvalid do
local p = valid[i]
- local p_markbase = has_attribute(p,markbase)
+ local p_markbase = p[markbase]
if p_markbase then
local mrks = marks[p_markbase]
local nofmarks = #mrks
for n in traverse_id(glyph_code,p.next) do
- local n_markmark = has_attribute(n,markmark)
+ local n_markmark = n[markmark]
if p_markbase == n_markmark then
- local index = has_attribute(n,markdone) or 1
+ local index = n[markdone] or 1
local d = mrks[index]
if d then
local rlmode = d[3]
@@ -8912,7 +8909,7 @@ function injections.handler(head,where,keep)
end
for n in traverse_id(glyph_code,head) do
if n.subtype < 256 then
- local k = has_attribute(n,kernpair)
+ local k = n[kernpair]
if k then
local kk = kerns[k]
if kk then
@@ -8996,8 +8993,6 @@ analyzers.useunicodemarks = false
local nodecodes = nodes.nodecodes
local glyph_code = nodecodes.glyph
-local set_attribute = node.set_attribute
-local has_attribute = node.has_attribute
local traverse_id = node.traverse_id
local traverse_node_list = node.traverse
@@ -9043,40 +9038,40 @@ function analyzers.setstate(head,font)
if d then
if d.class == "mark" or (useunicodemarks and categories[char] == "mn") then
done = true
- set_attribute(current,state,5) -- mark
+ current[state] = 5 -- mark
elseif n == 0 then
first, last, n = current, current, 1
- set_attribute(current,state,1) -- init
+ current[state] = 1 -- init
else
last, n = current, n+1
- set_attribute(current,state,2) -- medi
+ current[state] = 2 -- medi
end
else -- finish
if first and first == last then
- set_attribute(last,state,4) -- isol
+ last[state] = 4 -- isol
elseif last then
- set_attribute(last,state,3) -- fina
+ last[state] = 3 -- fina
end
first, last, n = nil, nil, 0
end
elseif id == disc_code then
-- always in the middle
- set_attribute(current,state,2) -- midi
+ current[state] = 2 -- midi
last = current
else -- finish
if first and first == last then
- set_attribute(last,state,4) -- isol
+ last[state] = 4 -- isol
elseif last then
- set_attribute(last,state,3) -- fina
+ last[state] = 3 -- fina
end
first, last, n = nil, nil, 0
end
current = current.next
end
if first and first == last then
- set_attribute(last,state,4) -- isol
+ last[state] = 4 -- isol
elseif last then
- set_attribute(last,state,3) -- fina
+ last[state] = 3 -- fina
end
return head, done
end
@@ -9238,19 +9233,19 @@ local function finish(first,last)
if first == last then
local fc = first.char
if isol_fina_medi_init[fc] or isol_fina[fc] then
- set_attribute(first,state,4) -- isol
+ first[state] = 4 -- isol
else
warning(first,"isol")
- set_attribute(first,state,0) -- error
+ first[state] = 0 -- error
end
else
local lc = last.char
if isol_fina_medi_init[lc] or isol_fina[lc] then -- why isol here ?
-- if laststate == 1 or laststate == 2 or laststate == 4 then
- set_attribute(last,state,3) -- fina
+ last[state] = 3 -- fina
else
warning(last,"fina")
- set_attribute(last,state,0) -- error
+ last[state] = 0 -- error
end
end
first, last = nil, nil
@@ -9258,10 +9253,10 @@ local function finish(first,last)
-- first and last are either both set so we never com here
local fc = first.char
if isol_fina_medi_init[fc] or isol_fina[fc] then
- set_attribute(first,state,4) -- isol
+ first[state] = 4 -- isol
else
warning(first,"isol")
- set_attribute(first,state,0) -- error
+ first[state] = 0 -- error
end
first = nil
end
@@ -9274,37 +9269,37 @@ function methods.arab(head,font,attr) -- maybe make a special version with no tr
local marks = tfmdata.resources.marks
local first, last, current, done = nil, nil, head, false
while current do
- if current.id == glyph_code and current.font == font and current.subtype<256 and not has_attribute(current,state) then
+ if current.id == glyph_code and current.font == font and current.subtype<256 and not current[state] then
done = true
local char = current.char
if marks[char] or (useunicodemarks and categories[char] == "mn") then
- set_attribute(current,state,5) -- mark
+ current[state] = 5 -- mark
elseif isol[char] then -- can be zwj or zwnj too
first, last = finish(first,last)
- set_attribute(current,state,4) -- isol
+ current[state] = 4 -- isol
first, last = nil, nil
elseif not first then
if isol_fina_medi_init[char] then
- set_attribute(current,state,1) -- init
+ current[state] = 1 -- init
first, last = first or current, current
elseif isol_fina[char] then
- set_attribute(current,state,4) -- isol
+ current[state] = 4 -- isol
first, last = nil, nil
else -- no arab
first, last = finish(first,last)
end
elseif isol_fina_medi_init[char] then
first, last = first or current, current
- set_attribute(current,state,2) -- medi
+ current[state] = 2 -- medi
elseif isol_fina[char] then
- if not has_attribute(last,state,1) then
+ if not last[state] == 1 then
-- tricky, we need to check what last may be !
- set_attribute(last,state,2) -- medi
+ last[state] = 2 -- medi
end
- set_attribute(current,state,3) -- fina
+ current[state] = 3 -- fina
first, last = nil, nil
elseif char >= 0x0600 and char <= 0x06FF then
- set_attribute(current,state,6) -- rest
+ current[state] = 6 -- rest
first, last = finish(first,last)
else --no
first, last = finish(first,last)
@@ -9333,9 +9328,11 @@ if not modules then modules = { } end modules ['font-otn'] = {
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"
+ license = "see context related readme files",
}
+-- preprocessors = { "nodes" }
+
-- this is still somewhat preliminary and it will get better in due time;
-- much functionality could only be implemented thanks to the husayni font
-- of Idris Samawi Hamid to who we dedicate this module.
@@ -9501,8 +9498,6 @@ local insert_node_after = node.insert_after
local delete_node = nodes.delete
local copy_node = node.copy
local find_node_tail = node.tail or node.slide
-local set_attribute = node.set_attribute
-local has_attribute = node.has_attribute
local flush_node_list = node.flush_list
local setmetatableindex = table.setmetatableindex
@@ -9734,80 +9729,6 @@ local function getcomponentindex(start)
end
end
--- local function toligature(kind,lookupname,start,stop,char,markflag,discfound) -- brr head
--- if start == stop and start.char == char then
--- start.char = char
--- return start
--- elseif discfound then
--- local prev = start.prev
--- local next = stop.next
--- start.prev = nil
--- stop.next = nil
--- local base = copy_glyph(start)
--- base.char = char
--- base.subtype = ligature_code
--- base.components = start -- start can have components
--- if prev then
--- prev.next = base
--- end
--- if next then
--- next.prev = base
--- end
--- base.next = next
--- base.prev = prev
--- return base
--- else
--- -- start is the ligature
--- local deletemarks = markflag ~= "mark"
--- local prev = start.prev
--- local next = stop.next
--- local base = copy_glyph(start)
--- local current, start = insert_node_after(start,start,base)
--- -- [start->current][copyofstart->start]...[stop]
--- current.next = next
--- if next then
--- next.prev = current
--- end
--- start.prev = nil
--- stop.next = nil
--- current.char = char
--- current.subtype = ligature_code
--- current.components = start
--- local head = current
--- -- this is messy ... we should get rid of the components eventually
--- local baseindex = 0
--- local componentindex = 0
--- while start do
--- local char = start.char
--- if not marks[char] then
--- baseindex = baseindex + componentindex
--- componentindex = getcomponentindex(start)
--- elseif not deletemarks then -- quite fishy
--- set_attribute(start,ligacomp,baseindex + (has_attribute(start,ligacomp) or componentindex))
--- if trace_marks then
--- logwarning("%s: keep mark %s, gets index %s",pref(kind,lookupname),gref(char),has_attribute(start,ligacomp))
--- end
--- head, current = insert_node_after(head,current,copy_glyph(start)) -- unlikely that mark has components
--- end
--- start = start.next
--- end
--- start = current.next
--- while start and start.id == glyph_code do -- hm, is id test needed ?
--- local char = start.char
--- if marks[char] then
--- set_attribute(start,ligacomp,baseindex + (has_attribute(start,ligacomp) or componentindex))
--- if trace_marks then
--- logwarning("%s: keep mark %s, gets index %s",pref(kind,lookupname),gref(char),has_attribute(start,ligacomp))
--- end
--- else
--- break
--- end
--- start = start.next
--- end
--- return head
--- end
--- end
-
local function toligature(kind,lookupname,start,stop,char,markflag,discfound) -- brr head
if start == stop and start.char == char then
start.char = char
@@ -9842,9 +9763,9 @@ local function toligature(kind,lookupname,start,stop,char,markflag,discfound) --
baseindex = baseindex + componentindex
componentindex = getcomponentindex(start)
elseif not deletemarks then -- quite fishy
- set_attribute(start,ligacomp,baseindex + (has_attribute(start,ligacomp) or componentindex))
+ start[ligacomp] = baseindex + (start[ligacomp] or componentindex)
if trace_marks then
- logwarning("%s: keep mark %s, gets index %s",pref(kind,lookupname),gref(char),has_attribute(start,ligacomp))
+ logwarning("%s: keep mark %s, gets index %s",pref(kind,lookupname),gref(char),start[ligacomp])
end
head, current = insert_node_after(head,current,copy_node(start)) -- unlikely that mark has components
end
@@ -9854,9 +9775,9 @@ local function toligature(kind,lookupname,start,stop,char,markflag,discfound) --
while start and start.id == glyph_code do -- hm, is id test needed ?
local char = start.char
if marks[char] then
- set_attribute(start,ligacomp,baseindex + (has_attribute(start,ligacomp) or componentindex))
+ start[ligacomp] = baseindex + (start[ligacomp] or componentindex)
if trace_marks then
- logwarning("%s: keep mark %s, gets index %s",pref(kind,lookupname),gref(char),has_attribute(start,ligacomp))
+ logwarning("%s: keep mark %s, gets index %s",pref(kind,lookupname),gref(char),start[ligacomp])
end
else
break
@@ -10132,7 +10053,7 @@ function handlers.gpos_mark2ligature(start,kind,lookupname,markanchors,sequence)
end
end
end
- local index = has_attribute(start,ligacomp)
+ local index = start[ligacomp]
local baseanchors = descriptions[basechar]
if baseanchors then
baseanchors = baseanchors.anchors
@@ -10178,13 +10099,10 @@ function handlers.gpos_mark2mark(start,kind,lookupname,markanchors,sequence)
local markchar = start.char
if marks[markchar] then
local base = start.prev -- [glyph] [basemark] [start=mark]
- -- while base and has_attribute(base,ligacomp) and has_attribute(base,ligacomp) ~= has_attribute(start,ligacomp) do
- -- base = base.prev -- KE: prevents mkmk for marks on different components of a ligature
- -- end
- local slc = has_attribute(start,ligacomp)
+ local slc = start[ligacomp]
if slc then -- a rather messy loop ... needs checking with husayni
while base do
- local blc = has_attribute(base,ligacomp)
+ local blc = base[ligacomp]
if blc and blc ~= slc then
base = base.prev
else
@@ -10233,7 +10151,7 @@ function handlers.gpos_mark2mark(start,kind,lookupname,markanchors,sequence)
end
function handlers.gpos_cursive(start,kind,lookupname,exitanchors,sequence) -- to be checked
- local alreadydone = cursonce and has_attribute(start,cursbase)
+ local alreadydone = cursonce and start[cursbase]
if not alreadydone then
local done = false
local startchar = start.char
@@ -10782,7 +10700,7 @@ function chainprocs.gpos_mark2ligature(start,stop,kind,chainname,currentcontext,
end
end
-- todo: like marks a ligatures hash
- local index = has_attribute(start,ligacomp)
+ local index = start[ligacomp]
local baseanchors = descriptions[basechar].anchors
if baseanchors then
local baseanchors = baseanchors['baselig']
@@ -10824,7 +10742,7 @@ end
function chainprocs.gpos_mark2mark(start,stop,kind,chainname,currentcontext,lookuphash,currentlookup,chainlookupname)
local markchar = start.char
if marks[markchar] then
---~ local alreadydone = markonce and has_attribute(start,markmark)
+--~ local alreadydone = markonce and start[markmark]
--~ if not alreadydone then
-- local markanchors = descriptions[markchar].anchors markanchors = markanchors and markanchors.mark
local subtables = currentlookup.subtables
@@ -10835,13 +10753,10 @@ function chainprocs.gpos_mark2mark(start,stop,kind,chainname,currentcontext,look
end
if markanchors then
local base = start.prev -- [glyph] [basemark] [start=mark]
- -- while (base and has_attribute(base,ligacomp) and has_attribute(base,ligacomp) ~= has_attribute(start,ligacomp)) do
- -- base = base.prev -- KE: prevents mkmk for marks on different components of a ligature
- -- end
- local slc = has_attribute(start,ligacomp)
+ local slc = start[ligacomp]
if slc then -- a rather messy loop ... needs checking with husayni
while base do
- local blc = has_attribute(base,ligacomp)
+ local blc = base[ligacomp]
if blc and blc ~= slc then
base = base.prev
else
@@ -10892,7 +10807,7 @@ end
-- ! ! ! untested ! ! !
function chainprocs.gpos_cursive(start,stop,kind,chainname,currentcontext,lookuphash,currentlookup,chainlookupname)
- local alreadydone = cursonce and has_attribute(start,cursbase)
+ local alreadydone = cursonce and start[cursbase]
if not alreadydone then
local startchar = start.char
local subtables = currentlookup.subtables
@@ -11557,7 +11472,7 @@ local function featuresprocessor(head,font,attr)
local id = start.id
if id == glyph_code then
if start.font == font and start.subtype<256 then
- local a = has_attribute(start,0)
+ local a = start[0]
if a then
a = a == attr
else
@@ -11609,11 +11524,11 @@ local function featuresprocessor(head,font,attr)
local id = start.id
if id == glyph_code then
if start.font == font and start.subtype<256 then
- local a = has_attribute(start,0)
+ local a = start[0]
if a then
- a = (a == attr) and (not attribute or has_attribute(start,state,attribute))
+ a = (a == attr) and (not attribute or start[state] == attribute)
else
- a = not attribute or has_attribute(start,state,attribute)
+ a = not attribute or start[state] == attribute
end
if a then
local lookupmatch = lookupcache[start.char]
@@ -11682,11 +11597,11 @@ local function featuresprocessor(head,font,attr)
local id = start.id
if id == glyph_code then
if start.font == font and start.subtype<256 then
- local a = has_attribute(start,0)
+ local a = start[0]
if a then
- a = (a == attr) and (not attribute or has_attribute(start,state,attribute))
+ a = (a == attr) and (not attribute or start[state] == attribute)
else
- a = not attribute or has_attribute(start,state,attribute)
+ a = not attribute or start[state] == attribute
end
if a then
for i=1,ns do