beta 2013.05.19 19:27

1 files changed, 159 insertions, 159 deletions

diff --git a/tex/context/base/lxml-sor.lua b/tex/context/base/lxml-sor.lua
index 951017bcd..a31d0ebb8 100644
--- a/tex/context/base/lxml-sor.lua
+++ b/tex/context/base/lxml-sor.lua
@@ -1,159 +1,159 @@
-if not modules then modules = { } end modules ['lxml-sor'] = {
-    version   = 1.001,
-    comment   = "companion to lxml-sor.mkiv",
-    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
-    copyright = "PRAGMA ADE / ConTeXt Development Team",
-    license   = "see context related readme files"
-}
-
-local format, concat, rep = string.format, table.concat, string.rep
-local lpegmatch = lpeg.match
-
-local xml, lxml = xml, lxml
-
-lxml.sorters = lxml.sorters or { }
-
-if not lxml.splitid then
-    local splitter = lpeg.C((1-lpeg.P(":"))^1) * lpeg.P("::") * lpeg.C(lpeg.P(1)^1)
-    function lxml.splitid(id)
-        local d, i = lpegmatch(splitter,id)
-        if d then
-            return d, i
-        else
-            return "", id
-        end
-    end
-end
-
-local lists = { }
-
-function lxml.sorters.reset(name)
-    lists[name] = {
-        sorted  = false,
-        entries = { },
-        reverse = { },
-        results = { },
-    }
-end
-
-function lxml.sorters.add(name,n,key)
-    local list = lists[name]
-    if list.sorted then
-        -- reverse is messed up, we could regenerate it and go on
-    else
-        local entries = list and list.entries
-        if entries then
-            local reverse = list.reverse
-            local e = reverse[n]
-            if e then
-                local keys = entries[e][2]
-                keys[#keys+1] = key
-            else
-                entries[#entries+1] = { n, { key } }
-                reverse[n] = #entries
-            end
-        end
-    end
-end
-
-function lxml.sorters.show(name)
-    local list = lists[name]
-    local entries = list and list.entries
-    local NC, NR, bold = context.NC, context.NR, context.bold -- somehow bold is not working
-    if entries then
-        local maxn = 1
-        for i=1,#entries do
-            if #entries[i][2] > maxn then maxn = #entries[i][2] end
-        end
-        context.starttabulate { "|Tr|Tr|" .. rep("Tlp|",maxn) }
-        NC() bold("n")
-        NC() bold("id")
-        if maxn > 1 then
-            for i=1,maxn do
-                NC() bold("entry " .. i)
-            end
-        else
-            NC() bold("entry")
-        end
-        NC() NR()
-        context.HL()
-        for i=1,#entries do
-            local entry = entries[i]
-            local document, node = lxml.splitid(entry[1])
-            NC() context(i)
-            NC() context(node)
-            local e = entry[2]
-            for i=1,#e do
-                NC() context.detokenize(e[i])
-            end
-            NC() NR()
-        end
-        context.stoptabulate()
-    end
-end
-
-lxml.sorters.compare = sorters.comparers.basic -- (a,b)
-
-function lxml.sorters.sort(name)
-    local list = lists[name]
-    local entries = list and list.entries
-    if entries then
-        -- filtering
-        local results = { }
-        list.results = results
-        for i=1,#entries do
-            local entry = entries[i]
-            results[i] = {
-                entry = entry[1],
-                key = concat(entry[2], " "),
-            }
-        end
-        -- preparation
-        local strip = sorters.strip
-        local splitter = sorters.splitters.utf
-        local firstofsplit = sorters.firstofsplit
-        for i=1, #results do
-            local r = results[i]
-            r.split = splitter(strip(r.key))
-        end
-        -- sorting
-        sorters.sort(results,lxml.sorters.compare)
-        -- finalizing
-        list.nofsorted = #results
-        local split = { }
-        for k=1,#results do -- rather generic so maybe we need a function
-            local v = results[k]
-            local entry, tag = firstofsplit(v)
-            local s = split[entry] -- keeps track of change
-            if not s then
-                s = { tag = tag, data = { } }
-                split[entry] = s
-            end
-            s.data[#s.data+1] = v
-        end
-        list.results = split
-        -- done
-        list.sorted = true
-    end
-end
-
-function lxml.sorters.flush(name,setup)
-    local list = lists[name]
-    local results = list and list.results
-    local xmlw = context.xmlw
-    if results and next(results) then
-        for key, result in next, results do
-            local tag, data = result.tag, result.data
-            for d=1,#data do
-                xmlw(setup,data[d].entry)
-            end
-        end
-    else
-        local entries = list and list.entries
-        if entries then
-            for i=1,#entries do
-                xmlw(setup,entries[i][1])
-            end
-        end
-    end
-end
+if not modules then modules = { } end modules ['lxml-sor'] = {

+    version   = 1.001,

+    comment   = "companion to lxml-sor.mkiv",

+    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",

+    copyright = "PRAGMA ADE / ConTeXt Development Team",

+    license   = "see context related readme files"

+}

+

+local format, concat, rep = string.format, table.concat, string.rep

+local lpegmatch = lpeg.match

+

+local xml, lxml = xml, lxml

+

+lxml.sorters = lxml.sorters or { }

+

+if not lxml.splitid then

+    local splitter = lpeg.C((1-lpeg.P(":"))^1) * lpeg.P("::") * lpeg.C(lpeg.P(1)^1)

+    function lxml.splitid(id)

+        local d, i = lpegmatch(splitter,id)

+        if d then

+            return d, i

+        else

+            return "", id

+        end

+    end

+end

+

+local lists = { }

+

+function lxml.sorters.reset(name)

+    lists[name] = {

+        sorted  = false,

+        entries = { },

+        reverse = { },

+        results = { },

+    }

+end

+

+function lxml.sorters.add(name,n,key)

+    local list = lists[name]

+    if list.sorted then

+        -- reverse is messed up, we could regenerate it and go on

+    else

+        local entries = list and list.entries

+        if entries then

+            local reverse = list.reverse

+            local e = reverse[n]

+            if e then

+                local keys = entries[e][2]

+                keys[#keys+1] = key

+            else

+                entries[#entries+1] = { n, { key } }

+                reverse[n] = #entries

+            end

+        end

+    end

+end

+

+function lxml.sorters.show(name)

+    local list = lists[name]

+    local entries = list and list.entries

+    local NC, NR, bold = context.NC, context.NR, context.bold -- somehow bold is not working

+    if entries then

+        local maxn = 1

+        for i=1,#entries do

+            if #entries[i][2] > maxn then maxn = #entries[i][2] end

+        end

+        context.starttabulate { "|Tr|Tr|" .. rep("Tlp|",maxn) }

+        NC() bold("n")

+        NC() bold("id")

+        if maxn > 1 then

+            for i=1,maxn do

+                NC() bold("entry " .. i)

+            end

+        else

+            NC() bold("entry")

+        end

+        NC() NR()

+        context.HL()

+        for i=1,#entries do

+            local entry = entries[i]

+            local document, node = lxml.splitid(entry[1])

+            NC() context(i)

+            NC() context(node)

+            local e = entry[2]

+            for i=1,#e do

+                NC() context.detokenize(e[i])

+            end

+            NC() NR()

+        end

+        context.stoptabulate()

+    end

+end

+

+lxml.sorters.compare = sorters.comparers.basic -- (a,b)

+

+function lxml.sorters.sort(name)

+    local list = lists[name]

+    local entries = list and list.entries

+    if entries then

+        -- filtering

+        local results = { }

+        list.results = results

+        for i=1,#entries do

+            local entry = entries[i]

+            results[i] = {

+                entry = entry[1],

+                key = concat(entry[2], " "),

+            }

+        end

+        -- preparation

+        local strip = sorters.strip

+        local splitter = sorters.splitters.utf

+        local firstofsplit = sorters.firstofsplit

+        for i=1, #results do

+            local r = results[i]

+            r.split = splitter(strip(r.key))

+        end

+        -- sorting

+        sorters.sort(results,lxml.sorters.compare)

+        -- finalizing

+        list.nofsorted = #results

+        local split = { }

+        for k=1,#results do -- rather generic so maybe we need a function

+            local v = results[k]

+            local entry, tag = firstofsplit(v)

+            local s = split[entry] -- keeps track of change

+            if not s then

+                s = { tag = tag, data = { } }

+                split[entry] = s

+            end

+            s.data[#s.data+1] = v

+        end

+        list.results = split

+        -- done

+        list.sorted = true

+    end

+end

+

+function lxml.sorters.flush(name,setup)

+    local list = lists[name]

+    local results = list and list.results

+    local xmlw = context.xmlw

+    if results and next(results) then

+        for key, result in next, results do

+            local tag, data = result.tag, result.data

+            for d=1,#data do

+                xmlw(setup,data[d].entry)

+            end

+        end

+    else

+        local entries = list and list.entries

+        if entries then

+            for i=1,#entries do

+                xmlw(setup,entries[i][1])

+            end

+        end

+    end

+end