mirror of
https://github.com/NeoFlock/neonucleus.git
synced 2025-09-24 17:13:31 +02:00
151 lines
4.1 KiB
Lua
151 lines
4.1 KiB
Lua
-- called from /init.lua
|
|
local raw_loadfile = ...
|
|
|
|
_G._OSVERSION = "OpenOS 1.8.8"
|
|
|
|
-- luacheck: globals component computer unicode _OSVERSION
|
|
local component = component
|
|
local computer = computer
|
|
local unicode = unicode
|
|
|
|
-- Runlevel information.
|
|
_G.runlevel = "S"
|
|
local shutdown = computer.shutdown
|
|
computer.runlevel = function() return _G.runlevel end
|
|
computer.shutdown = function(reboot)
|
|
_G.runlevel = reboot and 6 or 0
|
|
if os.sleep then
|
|
computer.pushSignal("shutdown")
|
|
os.sleep(0.1) -- Allow shutdown processing.
|
|
end
|
|
shutdown(reboot)
|
|
end
|
|
|
|
local w, h
|
|
local screen = component.list("screen", true)()
|
|
local gpu = screen and component.list("gpu", true)()
|
|
if gpu then
|
|
gpu = component.proxy(gpu)
|
|
if not gpu.getScreen() then
|
|
gpu.bind(screen)
|
|
end
|
|
_G.boot_screen = gpu.getScreen()
|
|
w, h = gpu.maxResolution()
|
|
gpu.setResolution(w, h)
|
|
gpu.setBackground(0x000000)
|
|
gpu.setForeground(0xFFFFFF)
|
|
gpu.fill(1, 1, w, h, " ")
|
|
end
|
|
|
|
-- Report boot progress if possible.
|
|
local y = 1
|
|
local uptime = computer.uptime
|
|
-- we actually want to ref the original pullSignal here because /lib/event intercepts it later
|
|
-- because of that, we must re-pushSignal when we use this, else things break badly
|
|
local pull = computer.pullSignal
|
|
local last_sleep = uptime()
|
|
local function status(msg)
|
|
if gpu then
|
|
gpu.set(1, y, msg)
|
|
if y == h then
|
|
gpu.copy(1, 2, w, h - 1, 0, -1)
|
|
gpu.fill(1, h, w, 1, " ")
|
|
else
|
|
y = y + 1
|
|
end
|
|
end
|
|
-- boot can be slow in some environments, protect from timeouts
|
|
if uptime() - last_sleep > 1 then
|
|
local signal = table.pack(pull(0))
|
|
-- there might not be any signal
|
|
if signal.n > 0 then
|
|
-- push the signal back in queue for the system to use it
|
|
computer.pushSignal(table.unpack(signal, 1, signal.n))
|
|
end
|
|
last_sleep = uptime()
|
|
end
|
|
end
|
|
|
|
status("Booting " .. _OSVERSION .. "...")
|
|
|
|
-- Custom low-level dofile implementation reading from our ROM.
|
|
local function dofile(file)
|
|
status("> " .. file)
|
|
local program, reason = raw_loadfile(file)
|
|
if program then
|
|
return program()
|
|
else
|
|
error(reason)
|
|
end
|
|
end
|
|
|
|
status("Initializing package management...")
|
|
|
|
-- Load file system related libraries we need to load other stuff moree
|
|
-- comfortably. This is basically wrapper stuff for the file streams
|
|
-- provided by the filesystem components.
|
|
local package = dofile("/lib/package.lua")
|
|
|
|
do
|
|
-- Unclutter global namespace now that we have the package module and a filesystem
|
|
_G.component = nil
|
|
_G.computer = nil
|
|
_G.process = nil
|
|
_G.unicode = nil
|
|
-- Inject the package modules into the global namespace, as in Lua.
|
|
_G.package = package
|
|
|
|
-- Initialize the package module with some of our own APIs.
|
|
package.loaded.component = component
|
|
package.loaded.computer = computer
|
|
package.loaded.unicode = unicode
|
|
package.loaded.buffer = dofile("/lib/buffer.lua")
|
|
package.loaded.filesystem = dofile("/lib/filesystem.lua")
|
|
|
|
-- Inject the io modules
|
|
_G.io = dofile("/lib/io.lua")
|
|
end
|
|
|
|
status("Initializing file system...")
|
|
|
|
-- Mount the ROM and temporary file systems to allow working on the file
|
|
-- system module from this point on.
|
|
require("filesystem").mount(computer.getBootAddress(), "/")
|
|
|
|
status("Running boot scripts...")
|
|
|
|
-- Run library startup scripts. These mostly initialize event handlers.
|
|
local function rom_invoke(method, ...)
|
|
return component.invoke(computer.getBootAddress(), method, ...)
|
|
end
|
|
|
|
local scripts = {}
|
|
for _, file in ipairs(rom_invoke("list", "boot")) do
|
|
local path = "boot/" .. file
|
|
if not rom_invoke("isDirectory", path) then
|
|
table.insert(scripts, path)
|
|
end
|
|
end
|
|
table.sort(scripts)
|
|
for i = 1, #scripts do
|
|
dofile(scripts[i])
|
|
end
|
|
|
|
status("Initializing components...")
|
|
|
|
for c, t in component.list() do
|
|
computer.pushSignal("component_added", c, t)
|
|
end
|
|
|
|
status("Initializing system...")
|
|
|
|
require("event").listen("component_added", debugprint)
|
|
require("event").listen("component_available", debugprint)
|
|
require("event").listen("term_available", debugprint)
|
|
|
|
computer.pushSignal("init") -- so libs know components are initialized.
|
|
require("event").pull(1, "init") -- Allow init processing.
|
|
|
|
require("tty").bind(component.gpu)
|
|
_G.runlevel = 1
|