beta 2013.01.17 18:16

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
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
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
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
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