luametalatex = luametalatex or {} local lmlt = luametalatex local initex = status.ini_version if initex then lua.prepared_code = {false} end bit32 = require'luametalatex-bit32' -- Why? And why so early? status.init_kpse = 1 -- Why? status.safer_option = 0 -- compat status.shell_escape = 0 -- compat -- This is currently a lie. -- require'module' -- ??? pdf = { variable = {}, } require'luametalatex-font-resolve' -- Replace font.define. Must be loaded before callbacks require'luametalatex-basecallbacks' require'luametalatex-oldnames' local callbacks = require'luametalatex-callbacks' local function swap_table(t) local s = {} for k, v in next, t do s[v] = k end return s end local primitives = {} do local token_primitives = token.getprimitives() local token_new = token.new for i=1,#token_primitives do local prim = token_primitives[i] primitives[prim[3]] = token_new(prim[2], prim[1]) end end lmlt.primitive_tokens = primitives do local command_id = swap_table(token.getcommandvalues()) function token.command_id(name) return command_id[name] end end lmlt.value = swap_table(token.getfunctionvalues()) lmlt.flag = swap_table(tex.getflagvalues()) local functions = lua.getfunctionstable() -- I am not sure why this is necessary, but otherwise LuaMetaTeX resets -- the functions table every time the getter is called function lua.get_functions_table() return functions end local set_lua = token.set_lua -- There are two approaches to manage luafunctions ids without triggering -- issues with ltluatex assigned numbers: Originally we assigned numbers -- starting with 1, then switched to luatexbase ASAP and synchronised both -- numbering schemes. But there is a useful quirk in ltluatex's luafunction -- allocator: It only uses numbers upto 65535, so we can just use bigger -- numbers. (This might have negative repercussins on performance because it -- probably doesn't store the function in the array part of the Lua table. -- Let's reconsider if this ever becomes a problem. -- local new_luafunction = luatexbase.new_luafunction local predefined_luafunctions = initex and 65536 -- 1<<16 -- We start with 1<<16 + 1 (1<<16=65536 is reserved for luametalatex-local) local new_luafunction function new_luafunction(name) if predefined_luafunctions then predefined_luafunctions = predefined_luafunctions + 1 return predefined_luafunctions else error[[Here only preexisting luafunctions should be set]] end end local undefined_cmd = token.command_id'undefined_cs' local lua_call_cmd = token.command_id'lua_call' local lua_value_cmd = token.command_id'lua_value' local lua_protected_call_cmd = token.command_id'lua_protected_call' local if_test_cmd = token.command_id'if_test' function lmlt.luacmd(name, func, ...) local idx local tok = token.create(name) local cmd = tok.command if cmd == lua_value_cmd then idx = tok.index elseif cmd == lua_call_cmd then idx = tok.index elseif cmd == lua_protected_call_cmd then idx = tok.index elseif cmd == if_test_cmd and tok.index > 53 then idx = tok.index - 53 elseif ... == 'force' then idx = new_luafunction(name) set_lua(name, idx, select(2, ...)) elseif cmd == undefined_cmd then idx = new_luafunction(name) set_lua(name, idx, ...) else error(tok.cmdname) end if functions[idx] then error[[Already defined]] end functions[idx] = func return idx end if initex then local build_bytecode = nil -- To be filled function callbacks.pre_dump() local user_callback = callbacks.pre_dump if user_callback then user_callback() end local prepared = lua.prepared_code prepared[1] = string.format("fixupluafunctions(%i)", predefined_luafunctions) --[[ for i=0,0 do -- maybeFIXME: In practise only one language is preloaded in LuaTeX anyway -- for i=0,tex.count[19] do -- Sometimes catches reserved language ids which are not used yet -- for i=0,lang.new():id()-1 do -- lang.new():id() is always 0 in luametatex?!? local l = language.new(i) local str = string.format("do \z local l = language.new(%i)\z l:hyphenationmin(%i)\z l:prehyphenchar(%i)\z l:posthyphenchar(%i)\z l:preexhyphenchar(%i)\z l:postexhyphenchar(%i)", i, l:hyphenationmin(), l:prehyphenchar(), l:posthyphenchar(), l:preexhyphenchar(), l:postexhyphenchar()) local patterns = l:patterns() local exceptions = l:hyphenation() if patterns and exceptions then str = string.format("%sl:patterns(%q)l:hyphenation(%q)end", str, patterns, exceptions) elseif patterns then str = string.format("%sl:patterns(%q)end", str, patterns) elseif exceptions then str = string.format("%sl:hyphenation(%q)end", str, exceptions) else str = str .. 'end' end prepared[#prepared+1] = str end ]] for i=2,#prepared do if type(prepared[i]) ~= 'string' then prepared[i] = assert(prepared[i]()) end end lua.bytecode[tex.count[262]+1] = build_bytecode(table.concat(prepared, '\n')) end callbacks.__freeze('pre_dump', true) return function(f) build_bytecode = f return require'luametalatex-firstcode' end else function fixupluafunctions(i) predefined_luafunctions = i fixupluafunctions = nil end return function(f) f() return require'luametalatex-firstcode' end end