if not modules then modules = { } end modules ['node-ini'] = {
    version   = 1.001,
    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"
}

--[[ldx--
<p>Most of the code that had accumulated here is now separated in modules.</p>
--ldx]]--

local next, type, tostring = next, type, tostring
local gsub = string.gsub
local concat, remove = table.concat, table.remove
local sortedhash, sortedkeys, swapped = table.sortedhash, table.sortedkeys, table.swapped

--[[ldx--
<p>Access to nodes is what gives <l n='luatex'/> its power. Here we implement a
few helper functions. These functions are rather optimized.</p>
--ldx]]--

nodes               = nodes or { }
local nodes         = nodes
nodes.handlers      = nodes.handlers or { }

local mark          = utilities.storage.mark
local allocate      = utilities.storage.allocate
local formatcolumns = utilities.formatters.formatcolumns

local getsubtypes   = node.subtypes
local getvalues     = node.values

tex.magicconstants = { -- we use tex.constants for something else
    running  = -1073741824, -- null_flag
    maxdimen =  1073741823, -- max_dimen
    trueinch =     4736286,
}

local listcodes     = mark(getsubtypes("list"))
local rulecodes     = mark(getsubtypes("rule"))
local dircodes      = mark(getsubtypes("dir"))
local glyphcodes    = mark(getsubtypes("glyph"))
local disccodes     = mark(getsubtypes("disc"))
local gluecodes     = mark(getsubtypes("glue"))
local boundarycodes = mark(getsubtypes("boundary"))
local penaltycodes  = mark(getsubtypes("penalty"))
local kerncodes     = mark(getsubtypes("kern"))
local mathcodes     = mark(getsubtypes("math"))
local noadcodes     = mark(getsubtypes("noad"))
local radicalcodes  = mark(getsubtypes("radical"))
local accentcodes   = mark(getsubtypes("accent"))
local fencecodes    = mark(getsubtypes("fence"))
----- fractioncodes = mark(getsubtypes("fraction"))
local parcodes      = mark(getsubtypes("par"))

local fillvalues    = mark(getvalues("fill"))
local dirvalues     = mark(getvalues("dir"))

local function simplified(t)
    local r = { }
    for k, v in next, t do
        r[k] = gsub(v,"_","")
    end
    return r
end

local nodecodes = simplified(node.types())

local whatcodes = allocate {
    literal     = 0x1, [0x1] = "literal",
    latelua     = 0x2, [0x2] = "latelua",
    userdefined = 0x3, [0x3] = "userdefined",
    savepos     = 0x4, [0x4] = "savepos",
    save        = 0x5, [0x5] = "save",
    restore     = 0x6, [0x6] = "restore",
    setmatrix   = 0x7, [0x7] = "setmatrix",
    open        = 0x8, [0x8] = "open",
    close       = 0x9, [0x9] = "close",
    write       = 0xA, [0xA] = "write",
}

local usercodes = allocate {
    [ 97] = "attribute", -- a
    [100] = "number",    -- d
    [102] = "float",     -- f
    [108] = "lua",       -- l
    [110] = "node",      -- n
    [115] = "string",    -- s
    [116] = "token"      -- t
}

local noadoptions = allocate {
    set      =        0x08,
    unused_1 = 0x00 + 0x08,
    unused_2 = 0x01 + 0x08,
    axis     = 0x02 + 0x08,
    no_axis  = 0x04 + 0x08,
    exact    = 0x10 + 0x08,
    left     = 0x11 + 0x08,
    middle   = 0x12 + 0x08,
    right    = 0x14 + 0x08,
}

local literalvalues = allocate {
    [0] = "origin",
    [1] = "page",
    [2] = "always",
    [3] = "raw",
    [4] = "text",
    [5] = "font",
    [6] = "special",
}

gluecodes     = allocate(swapped(gluecodes,gluecodes))
dircodes      = allocate(swapped(dircodes,dircodes))
boundarycodes = allocate(swapped(boundarycodes,boundarycodes))
noadcodes     = allocate(swapped(noadcodes,noadcodes))
radicalcodes  = allocate(swapped(radicalcodes,radicalcodes))
nodecodes     = allocate(swapped(nodecodes,nodecodes))
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))
mathcodes     = allocate(swapped(mathcodes,mathcodes))
disccodes     = allocate(swapped(disccodes,disccodes))
accentcodes   = allocate(swapped(accentcodes,accentcodes))
fencecodes    = allocate(swapped(fencecodes,fencecodes))
parcodes      = allocate(swapped(parcodes,parcodes))
rulecodes     = allocate(swapped(rulecodes,rulecodes))
usercodes     = allocate(swapped(usercodes,usercodes))
noadoptions   = allocate(swapped(noadoptions,noadoptions))

dirvalues     = allocate(swapped(dirvalues,dirvalues))
literalvalues = allocate(swapped(literalvalues,literalvalues))
fillvalues    = allocate(swapped(fillvalues,fillvalues))

nodes.gluecodes     = gluecodes
nodes.dircodes      = dircodes
nodes.boundarycodes = boundarycodes
nodes.noadcodes     = noadcodes
nodes.whatcodes     = whatcodes
nodes.listcodes     = listcodes
nodes.glyphcodes    = glyphcodes
nodes.kerncodes     = kerncodes
nodes.penaltycodes  = penaltycodes
nodes.mathcodes     = mathcodes
nodes.disccodes     = disccodes
nodes.accentcodes   = accentcodes
nodes.radicalcodes  = radicalcodes
nodes.fencecodes    = fencecodes
nodes.parcodes      = parcodes
nodes.rulecodes     = rulecodes
nodes.usercodes     = usercodes

nodes.noadoptions   = noadoptions
nodes.fillvalues    = fillvalues
nodes.fillcodes     = fillvalues -- for now
nodes.dirvalues     = dirvalues
nodes.literalvalues = literalvalues

nodes.nodecodes     = nodecodes

-- local subtypes = allocate {
--     [nodecodes.glue]      = gluecodes,
--     [nodecodes.dir]       = dircodes,
--     [nodecodes.boundary]  = boundarycodes,
--     [nodecodes.noad]      = noadcodes,
--     [nodecodes.whatsit]   = whatcodes,
--     [nodecodes.glyph]     = glyphcodes,
--     [nodecodes.kern]      = kerncodes,
--     [nodecodes.penalty]   = penaltycodes,
--     [nodecodes.math]      = mathcodes,
--     [nodecodes.disc]      = disccodes,
--     [nodecodes.accent]    = accentcodes,
--     [nodecodes.radical]   = radicalcodes,
--     [nodecodes.fence]     = fencecodes,
--     [nodecodes.par]       = parcodes,
--     [nodecodes.rule]      = rulecodes,

--     [nodecodes.vlist]     = listcodes,
--     [nodecodes.hlist]     = listcodes,

--  -- [nodecodes.list]      = listcodes,

--  -- [nodecodes.parameter] = parametercodes,
--  -- [nodecodes.user]      = usercodes,
-- }

-- for k in next, table.sortedkeys(subtypes) do
--     local v = nodecodes[k]
--     print(k,v)
--     if k and subtypes[k] then
--         subtypes[v] = subtypes[k]
--     end
-- end

local subtypes = allocate {
    glue      = gluecodes,
    dir       = dircodes,
    boundary  = boundarycodes,
    noad      = noadcodes,
    whatsit   = whatcodes,
    glyph     = glyphcodes,
    kern      = kerncodes,
    penalty   = penaltycodes,
    math      = mathcodes,
    disc      = disccodes,
    accent    = accentcodes,
    radical   = radicalcodes,
    fence     = fencecodes,
    par       = parcodes,
    rule      = rulecodes,

    vlist     = listcodes,
    hlist     = listcodes,

 -- list      = listcodes,

 -- parameter = parametercodes,
 -- user      = usercodes,
}

for k, v in table.sortedhash(subtypes) do
    local i = nodecodes[k]
    if i and not subtypes[i] then
        subtypes[i] = v
    end
end

nodes.subtypes = subtypes

-- a few more friendly aliases:

nodes.skipcodes            = gluecodes
nodes.directioncodes       = dircodes
nodes.whatsitcodes         = whatcodes
nodes.discretionarycodes   = disccodes

nodes.directionvalues      = dirvalues
nodes.literalvalues        = literalvalues

glyphcodes.glyph           = glyphcodes.character

gluecodes.parfillrightskip = gluecodes.parfillrightskip or gluecodes.parfillskip
gluecodes.parfillskip      = gluecodes.parfillskip      or gluecodes.parfillrightskip

listcodes.row              = listcodes.alignment
listcodes.column           = listcodes.alignment

kerncodes.kerning          = kerncodes.fontkern
kerncodes.italiccorrection = kerncodes.italiccorrection or 1 -- new

literalvalues.direct       = literalvalues.always

nodes.noadoptions = {
    set      =        0x08,
    unused_1 = 0x00 + 0x08,
    unused_2 = 0x01 + 0x08,
    axis     = 0x02 + 0x08,
    no_axis  = 0x04 + 0x08,
    exact    = 0x10 + 0x08,
    left     = 0x11 + 0x08,
    middle   = 0x12 + 0x08,
    right    = 0x14 + 0x08,
}

-- We use the real node code numbers.

local texsetintegervalue = tex.setintegervalue

for i=0,nodecodes.glyph do
    texsetintegervalue(nodecodes[i] .. "nodecode",i,"immutable")
end
for i=0,#gluecodes do
    texsetintegervalue(gluecodes[i] .. "subtypecode",i,"immutable")
end

-- tex.set("internalcodesmode",1) -- obsolete