-- This file is generated, don't change it!

texconfig.buffersize        = { size =   10000000, step =    1000000 }
texconfig.expandsize        = { size =      10000 }
texconfig.filesize          = { size =       2000, step =        200 }
texconfig.fontsize          = { size =     100000, step =        250 }
texconfig.hashsize          = { size =     250000, step =     100000 }
texconfig.inputsize         = { size =     100000, step =      10000 }
texconfig.languagesize      = { size =        250, step =        250 }
texconfig.marksize          = { size =        250, step =         50 }
texconfig.insertsize        = { size =        250, step =         25 }
texconfig.nestsize          = { size =      10000, step =       1000 }
texconfig.nodesize          = { size =   50000000, step =     500000 }
texconfig.parametersize     = { size =     100000, step =      10000 }
texconfig.poolsize          = { size =   10000000, step =    1000000 }
texconfig.savesize          = { size =     500000, step =      10000 }
texconfig.stringsize        = { size =     500000, step =     100000 }
texconfig.tokensize         = { size =   10000000, step =     250000 }
texconfig.errorlinesize     = { size =        250 }
texconfig.halferrorlinesize = { size =        250 }


-- checking

storage = storage or { }
luatex  = luatex  or { }

-- as soon as possible

texconfig.functionsize   = 32768
texconfig.propertiessize = 10000

luatex.starttime = os.gettimeofday()

-- this will happen after the format is loaded

function texconfig.init()

    -- development

    local builtin, globals = { }, { }

    libraries = { -- we set it here as we want libraries also 'indexed'
        basiclua = {
            "string", "table", "coroutine", "debug", "file", "io", "lpeg", "math", "os", "package",
            "utf8",
        },
        basictex = {
            "callback", "font", "lua", "node", "status", "tex", "texconfig", "texio", "token",
            "font", "language",
        },
        extralua = {
            "library", "luac",
            "xzip", "xmath", "xcomplex", "xdecimal", "basexx", "posit", "sparse",
            "md5", "sha2", "aes", "fio", "sio",
            "lfs","socket",
        },
        extratex = {
            "pdfe", "mplib", "potrace",
            "pdfdecode", "pngdecode",
        },
        optional = {
            "cerf", "curl", "foreign", "ghostscript", "graphicsmagick", "hb", "imagemagick",
            "kpse", "lzma", "lzo", "lz4", "mujs", "mysql", "optional", "postgress", "sqlite",
            "zint", "zstd",
        },
        obsolete = {
        },
        functions = {
            "assert", "pcall", "xpcall", "error", "collectgarbage",
            "dofile", "load","loadfile", "require", "module",
            "getmetatable", "setmetatable",
            "ipairs", "pairs", "rawequal", "rawget", "rawset", "next",
            "tonumber", "tostring",
            "type", "unpack", "select", "print",
        },
        builtin = builtin, -- to be filled
        globals = globals, -- to be filled
    }

    for k, v in next, _G do
        globals[k] = tostring(v)
    end

    local function collect(t,fnc)
        local lib = { }
        for k, v in next, t do
            if fnc then
                lib[v] = _G[v]
            else
                local keys = { }
                local gv = _G[v]
                local tv = type(gv)
                if tv == "table" then
                    for k, v in next, gv do
                        keys[k] = tostring(v) -- true -- by tostring we cannot call overloads functions (security)
                    end
                end
                lib[v] = keys
                builtin[v] = keys
            end
        end
        return lib
    end

    libraries.basiclua  = collect(libraries.basiclua)
    libraries.basictex  = collect(libraries.basictex)
    libraries.extralua  = collect(libraries.extralua)
    libraries.extratex  = collect(libraries.extratex)
    libraries.functions = collect(libraries.functions,true)
    libraries.obsolete  = collect(libraries.obsolete)
    libraries.optional  = collect(libraries.optional)

    -- shortcut and helper

    local setbytecode  = lua.setbytecode
    local getbytecode  = lua.getbytecode
    local callbytecode = lua.callbytecode or function(i)
        local b = getbytecode(i)
        if type(b) == "function" then
            b()
            return true
        else
            return false
        end
    end

    local function init(start)
        local i = start
        local t = os.clock()
        while true do
         -- local b = callbytecode(i)
            local e, b = pcall(callbytecode,i)
            if not e then
                print(string.format("fatal error : unable to load bytecode register %i, maybe wipe the cache first\n",i))
                os.exit()
            end
            if b then
                setbytecode(i,nil) ;
                i = i + 1
            else
                break
            end
        end
        return i - start, os.clock() - t
    end

    -- the stored tables and modules

    storage.noftables , storage.toftables  = init(0)
    storage.nofmodules, storage.tofmodules = init(501)

    if modules then
        local loaded = package.loaded
        for module, _ in next, modules do
            loaded[module] = true
        end
    end

    texconfig.init = function() end

end

CONTEXTLMTXMODE = 1

-- we provide a qualified path

callback.register('find_format_file',function(name)
    texconfig.formatname = name
    return name
end)

-- done, from now on input and callbacks are internal
