luajitos

ramfs.lua (5218B)

---

 local ramdisk_packed =[[os/
 apps/
 os/test.lua	osprint("test123! test123! test123!")\nosprint("\_-'-_/")\n]]
 
 
 function string.trimr(str, char)
     char = char or " "
 
     local len, epos = string.len(str), 1
     
     for i=1,len do
         if str:sub(len - epos, len - epos) == char then
             epos = epos + 1
         end
     end
 
     return str:sub(1, len - epos)
 end
 
 function string.triml(str, char)
     char = char or " "
 
     local len, spos = string.len(str), 1
     
     for i=1,len do
         if str:sub(spos, spos) == char then
             spos = spos + 1
         end
     end 
     return str:sub(spos, len)
 end
 
 function string.trim(str, char)
     return string.triml(string.trimr(str, char), char)
 end
 
 function ramdisk_followPath(fs, path, curnode)
     path = string.trim(path:triml("/"), "/")
 
     curnode = curnode or fs
 
     -- Empty path means we're at the target
     if string.len(path) == 0 then
         return curnode, ""
     end
 
     if path:match("^..") then
         if curnode.parent == nil then
             return curnode, path
         else
             curnode = curnode.parent
         end
     end
 
     local name = path:match("([^/]+)")
     local remaining = path:match("/(.*)$") or ""
 
     print("DEBUG: path='"..path.."' name='"..name.."' remaining='"..remaining.."'")
 
     if curnode.dirs[name] then
         if string.len(remaining) > 0 then
             return ramdisk_followPath(fs, remaining, curnode.dirs[name])
         else
             return curnode.dirs[name], ""
         end
     end
 
     if curnode.files then
         if curnode.files[name] then
             if string.len(remaining) > 0 then
                 return ramdisk_followPath(fs, remaining, curnode.files[name])
             else
                 return curnode.files[name]
             end
         end
     end
 
     return curnode, name
 end
 
 
 local FSInstance = {
     new = function(filesystem, manifest)
         if filesystem == nil or manifest == nil or manifest.allowedDirs == nil then
            return nil
         end
         local allowedDirs = manifest.allowedDirs
         local instance = {
             root = filesystem;
             allowedDirs = allowedDirs;
             pathHashes = {};
         }
         return setmetatable(instance, FSInstance)
     end
 }
 FSInstance.__index = FSInstance
 
 function FSInstance.read(path)
     local node, path = ramdisk_followPath(self.root, path)
     if node and node.type == "file" then
         return node.content
     end
 end
 
 
 function ramdisk_addDir(filesystem, path)
     local node, name = ramdisk_followPath(filesystem, path)
 
     local dir = {
         name = name;
         type = "directory";
         dirs = {};
         files = {};
         parent = node;
     }
 
     node.dirs[name] = dir
 end
 
 function ramdisk_addFile(filesystem, path, content)
     local node, name = ramdisk_followPath(filesystem, path)
     local file = {
         name = name;
         type = "file";
         content = content;
         parent = node;
     }
 
     node.files[name] = file
 end
 
 function ramdisk_print(node, path)
     if node == nil then return nil end
 
     local path = path or ""
     local fullpath = path..(node.name or "")
 
     if node.type == "directory" then
         fullpath = fullpath.."/"
     end
 
     print(fullpath)
 
     if node.type == "directory" then
         -- Sort keys to ensure consistent ordering
         local dirKeys = {}
         for k in pairs(node.dirs) do
             table.insert(dirKeys, k)
         end
         table.sort(dirKeys)
 
         -- Print directories depth-first
         for _, k in ipairs(dirKeys) do
             ramdisk_print(node.dirs[k], fullpath)
         end
 
         -- Then print files
         local fileKeys = {}
         for k in pairs(node.files) do
             table.insert(fileKeys, k)
         end
         table.sort(fileKeys)
 
         for _, k in ipairs(fileKeys) do
             ramdisk_print(node.files[k], fullpath)
         end
     end
 end
 
 --ramdisk_addDir(filesystem, "/os/")
 
 --ramdisk_addDir(filesystem, "/apps/")
 
 
 
 
 
 function ramdisk_unpack(packed, allowedDirs)
     local fs = {
         type = "directory";
         dirs = {};
         files = {};
         allowedDirs = allowedDirs;
         parent = nil;
     }
 
     while packed and string.len(packed) > 0 do
         local line = packed:match("([^\n]*)\n?")
         packed = packed:sub(string.len(line) + 2, string.len(packed))
 
         if string.len(line) <= 1 then
             break
         end
 
         local path, content = line:match("([^\t]+)\t(.*)")
 
         if path == nil and line:match("^.+/$") then
             path = line
             print("dir: "..path)
             ramdisk_addDir(fs, path)
         elseif path ~= nil then
             print("file: "..path)
             print("content: "..(content or ""))
             ramdisk_addFile(fs, path, content)
         end
 
     end
 
     return fs
 end
 
 local unpacked_fs = ramdisk_unpack(ramdisk_packed)
 
 print("~~~~~~~~~~~~~~~~~~")
 print("Manual filesystem:")
 ramdisk_print(filesystem)
 print("~~~~~~~~~~~~~~~~~~")
 print("Unpacked filesystem:")
 ramdisk_print(unpacked_fs)
 print("~~~~~~~~~~~~~~~~~~")
 local fs = FSInstance.new(unpacked_fs, { allowedDirs = "all" })
 print("test.lua:", fs:read("/os/test.lua"))
 print("~~~~~~~~~~~~~~~~~~")