luajitos

pack_ramdisk.lua (5642B)

---

 #!/usr/bin/env luajit
 -- pack_ramdisk.lua - Generates packed.bin from iso_includes directory
 -- Usage: luajit pack_ramdisk.lua <source_dir> <output_file>
 
 local source_dir = arg[1] or "iso_includes"
 local output_file = arg[2] or "OS/packed.bin"
 
 -- Helper function to check if a file is binary
 local function isBinary(content)
     for i = 1, #content do
         local byte = content:byte(i)
         if byte < 32 and byte ~= 9 and byte ~= 10 and byte ~= 13 then
             return true
         end
         if byte > 127 then
             return true
         end
     end
     return false
 end
 
 -- Base64 encoding
 local function base64Encode(data)
     local b = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
     local result = {}
 
     for i = 1, #data, 3 do
         local b1 = data:byte(i)
         local b2 = data:byte(i + 1)
         local b3 = data:byte(i + 2)
 
         local c1 = b:sub(bit.rshift(b1, 2) + 1, bit.rshift(b1, 2) + 1)
 
         if b2 then
             local c2 = b:sub(bit.bor(bit.lshift(bit.band(b1, 0x03), 4), bit.rshift(b2, 4)) + 1, bit.bor(bit.lshift(bit.band(b1, 0x03), 4), bit.rshift(b2, 4)) + 1)
 
             if b3 then
                 local c3 = b:sub(bit.bor(bit.lshift(bit.band(b2, 0x0F), 2), bit.rshift(b3, 6)) + 1, bit.bor(bit.lshift(bit.band(b2, 0x0F), 2), bit.rshift(b3, 6)) + 1)
                 local c4 = b:sub(bit.band(b3, 0x3F) + 1, bit.band(b3, 0x3F) + 1)
                 table.insert(result, c1 .. c2 .. c3 .. c4)
             else
                 local c3 = b:sub(bit.lshift(bit.band(b2, 0x0F), 2) + 1, bit.lshift(bit.band(b2, 0x0F), 2) + 1)
                 table.insert(result, c1 .. c2 .. c3 .. '=')
             end
         else
             local c2 = b:sub(bit.lshift(bit.band(b1, 0x03), 4) + 1, bit.lshift(bit.band(b1, 0x03), 4) + 1)
             table.insert(result, c1 .. c2 .. '==')
         end
     end
 
     return table.concat(result)
 end
 
 -- Escape text content
 local function escapeText(text)
     local result = {}
     for i = 1, #text do
         local c = text:sub(i, i)
         if c == "\\" then
             table.insert(result, "\\\\")
         elseif c == "\n" then
             table.insert(result, "\\n")
         elseif c == "\t" then
             table.insert(result, "\\t")
         elseif c == "\r" then
             table.insert(result, "\\r")
         else
             table.insert(result, c)
         end
     end
     return table.concat(result)
 end
 
 -- Recursively scan directory
 local function scanDirectory(path, relative_path)
     local dirs = {}
     local files = {}
 
     -- Get directory listing
     local handle = io.popen("find " .. path .. " -mindepth 1 -maxdepth 1 2>/dev/null")
     if not handle then
         io.stderr:write("Error: Cannot read directory " .. path .. "\n")
         return dirs, files
     end
 
     for entry in handle:lines() do
         local name = entry:match("^.+/(.+)$")
         local entry_relative = relative_path == "" and name or relative_path .. "/" .. name
 
         -- Check if it's a directory
         local is_dir = os.execute("test -d " .. entry .. " 2>/dev/null") == 0
 
         if is_dir then
             -- Add directory
             table.insert(dirs, entry_relative)
             -- Recursively scan subdirectory
             local subdirs, subfiles = scanDirectory(entry, entry_relative)
             for _, d in ipairs(subdirs) do
                 table.insert(dirs, d)
             end
             for _, f in ipairs(subfiles) do
                 table.insert(files, f)
             end
         else
             -- Skip init.lua and packed.bin at any level
             if entry_relative ~= "os/packed.bin" and entry_relative ~= "packed.bin" then
                 -- Add file
                 local file_handle = io.open(entry, "rb")
                 if file_handle then
                     local content = file_handle:read("*a")
                     file_handle:close()
 
                     table.insert(files, {
                         path = entry_relative,
                         content = content
                     })
                 end
             end
         end
     end
 
     handle:close()
     return dirs, files
 end
 
 -- Main
 print("Packing ramdisk from: " .. source_dir)
 print("Output file: " .. output_file)
 
 local dirs, files = scanDirectory(source_dir, "")
 
 -- Sort directories and files
 table.sort(dirs)
 table.sort(files, function(a, b) return a.path < b.path end)
 
 print("Found " .. #dirs .. " directories and " .. #files .. " files")
 
 -- Build packed format
 local entries = {}
 
 -- Add directories
 for _, dir in ipairs(dirs) do
     table.insert(entries, dir .. "/")
     print("  DIR:  " .. dir .. "/")
 end
 
 -- Add files
 for _, file in ipairs(files) do
     local entry
     if isBinary(file.content) then
         entry = file.path .. "~~~~BIN:" .. base64Encode(file.content)
         print("  FILE: " .. file.path .. " (binary, " .. #file.content .. " bytes)")
     else
         local escaped = escapeText(file.content)
         entry = file.path .. "~~~~" .. escaped
         print("  FILE: " .. file.path .. " (text, original=" .. #file.content .. " escaped=" .. #escaped .. " entry=" .. #entry .. " bytes)")
     end
     table.insert(entries, entry)
 end
 
 -- Write output
 -- Use null bytes as delimiter (won't appear in text files)
 local ENTRY_SEP = "\x00\x00\x00\x00"
 local packed = table.concat(entries, ENTRY_SEP)
 print("\nDEBUG: Packed size: " .. #packed .. " bytes")
 
 local out = io.open(output_file, "wb")
 if not out then
     io.stderr:write("Error: Cannot write to " .. output_file .. "\n")
     os.exit(1)
 end
 
 out:write(packed)
 out:close()
 
 print("\nPacked ramdisk created: " .. output_file .. " (" .. #packed .. " bytes)")