if not modules then modules = { } end modules ['luat-cod'] = {
    version   = 1.001,
    comment   = "companion to luat-cod.mkiv",
    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
    copyright = "PRAGMA ADE / ConTeXt Development Team",
    license   = "see context related readme files"
}

local type, loadfile, tonumber = type, loadfile, tonumber
local match, gsub, find, format, gmatch = string.match, string.gsub, string.find, string.format, string.gmatch

local texconfig, lua = texconfig, lua

-- maybe pick up from commandline:
--
-- texconfig.interaction: 0=batchmode 1=nonstopmode 2=scrollmode 3=errornonstopmode 4=normal

-- some basic housekeeping

texconfig.kpse_init       = false
texconfig.shell_escape    = 't'

texconfig.error_line      =     250
texconfig.expand_depth    =   10000
texconfig.half_error_line =     125
texconfig.max_in_open     =    1000
texconfig.max_print_line  =  100000
texconfig.max_strings     =  500000
texconfig.nest_size       =    1000
texconfig.param_size      =   25000
texconfig.save_size       =  100000
texconfig.stack_size      =   10000
texconfig.function_size   =   32768
texconfig.properties_size =   10000
texconfig.fix_mem_init    = 1000000

-- registering bytecode chunks

local bytedata    = lua.bytedata or { }
local bytedone    = lua.bytedone or { }

---.bytecode      = bytecode
lua.bytedata      = bytedata
lua.bytedone      = bytedone

local setbytecode = lua.setbytecode
----- getbytecode = lua.getbytecode

lua.firstbytecode = 501
lua.lastbytecode  = lua.lastbytecode or (lua.firstbytecode - 1) -- as we load ourselves again ... maybe return earlier

function lua.registeredcodes()
    return lua.lastbytecode - lua.firstbytecode + 1
end

-- no file.* and utilities.parsers.* functions yet

local strip = false if arg then for i=-1,#arg do if arg[i] == "--c:strip" then strip = true break end end end

function lua.registercode(filename,options)
    local barename = gsub(filename,"%.[%a%d]+$","")
    local basename = match(barename,"^.+[/\\](.-)$") or barename
    if not bytedone[basename] then
        local opts = { }
        if type(options) == "string" and options ~= "" then
            for s in gmatch(options,"([a-z]+)") do
                opts[s] = true
            end
        end
        if barename == filename then
            filename = filename .. ".lua"
        end
        local code = environment.luafilechunk(filename,false,opts.optimize)
        if code then
            bytedone[basename] = true
            if environment.initex and not opts.initexonly then
                local n = lua.lastbytecode + 1
                bytedata[n] = { name = barename, options = opts }
                if strip or opts.strip then
                    setbytecode(n,code,true)
                else
                    setbytecode(n,code)
                end
                lua.lastbytecode = n
            end
        elseif environment.initex then
            texio.write_nl(format("\nerror loading file: %s (aborting)",filename))
            os.exit()
        end
    end
end

-- A first start with environments. This will be overloaded later.

environment       = environment or { }
local environment = environment

-- no string.unquoted yet

local sourcefile = gsub(arg and arg[1] or "","^\"(.*)\"$","%1")
local sourcepath = find(sourcefile,"/",1,true) and gsub(sourcefile,"/[^/]+$","") or ""
local targetpath = "."

-- delayed (via metatable):
--
-- environment.jobname = tex.jobname
-- environment.version = tostring(tex.toks.contextversiontoks)

-- traditionally the revision has been a one character string and only
-- pdftex went beyond "9" but anyway we test for it

if LUATEXENGINE == nil then
    LUATEXENGINE = status.luatex_engine and string.lower(status.luatex_engine)
                or (find(status.banner,"LuajitTeX",1,true) and "luajittex" or "luatex")
end

if LUATEXVERSION == nil then
    LUATEXVERSION = status.luatex_version/100
                  + tonumber(status.luatex_revision)/10000
end

if CONTEXTLMTXMODE == nil then
    CONTEXTLMTXMODE = 0
end

if LUATEXFUNCTIONALITY == nil then
    LUATEXFUNCTIONALITY = status.development_id or 6346
end

if LUATEXFORMATID == nil then
    LUATEXFORMATID = status.format_id or 0
end

if JITSUPPORTED == nil then
    JITSUPPORTED = LUATEXENGINE == "luajittex" or jit -- "or jit" can go
end

if INITEXMODE == nil then
    INITEXMODE = status.ini_version
end

environment.luatexengine        = LUATEXENGINE
environment.luatexversion       = LUATEXVERSION
environment.luatexfunctionality = LUATEXFUNCTIONALITY
environment.jitsupported        = JITSUPPORTED
environment.initex              = INITEXMODE
environment.initexmode          = INITEXMODE

if INITEXMODE then

    local finalizers = { }

    function lua.registerinitexfinalizer(f,comment)
        comment = comment or "unknown"
        if type(f) == "function" then
            finalizers[#finalizers+1] = { action = f, comment = comment }
        else
            print(format("\nfatal error: invalid finalizer, action: %s\n",comment))
            os.exit()
        end
    end

    function lua.finalizeinitex(logger)
        for i=1,#finalizers do
            local finalizer = finalizers[i]
            finalizer.action()
            if logger then
                logger("finalize action: %s",finalizer.comment)
            end
        end
    end

else

    function lua.registerinitexfinalizer() end
    function lua.finalizeinitex         () end

end


if not environment.luafilechunk then

    function environment.luafilechunk(filename)
        local fullname = filename
        if sourcepath ~= "" then
            fullname = sourcepath .. "/" .. filename
        end
        local data = loadfile(fullname)
        texio.write("term and log","<",data and "+ " or "- ",fullname,">")
        if data then
-- package.loaded[gsub(filename,"%..-$"] =
            data()
        end
        return data
    end

end

if not environment.engineflags then -- raw flags

    local engineflags = { }

    for i=-10,#arg do
        local a = arg[i]
        if a then
            local flag, content = match(a,"^%-%-([^=]+)=?(.-)$")
            if flag then
                engineflags[flag] = content or ""
            end
        end
    end

    environment.engineflags = engineflags

end

-- We need a few premature callbacks in the format generator. We
-- also do this when the format is loaded as otherwise we get
-- a kpse error when disabled. This is an engine issue that will
-- be sorted out in due time.

if not lfs.isfile then

    local attributes = lfs.attributes

    function lfs.isdir(name)
        return attributes(name,"mode") == "directory"
    end

    function lfs.isfile(name)
        local a = attributes(name,"mode")
        return a == "file" or a == "link" or nil
    end

end

local isfile = lfs.isfile

local function source_file(name)
    local fullname = sourcepath .. "/" .. name
    if isfile(fullname) then
        return fullname
    end
    fullname = fullname .. ".tex"
    if isfile(fullname) then
        return fullname
    end
    if isfile(name) then
        return name
    end
    name = name .. ".tex"
    if isfile(name) then
        return name
    end
    return nil
end

local function target_file(name)
    return targetpath .. "/" .. name
end

local function find_read_file(id,name)
    return source_file(name)
end

local function find_write_file(id,name)
    return target_file(name)
end

local function find_log_file(name)
    return target_file(name)
end

local function open_read_file(name)
    local f = io.open(name,'rb')
    return {
        reader = function()
            return f:read("*line")
        end
    }
end

local function find_data_file(name)
    return source_file(name)
end

local open_data_file = open_read_file

callback.register('find_read_file' , find_read_file )
callback.register('open_read_file' , open_read_file )
callback.register('find_write_file', find_write_file)
callback.register('find_log_file',   find_log_file)

callback.register('find_data_file' , find_data_file )
callback.register('open_data_file' , open_data_file )
