opus/sys/kernel.lua

local sandboxEnv = { }
for k,v in pairs(_ENV) do
  sandboxEnv[k] = v
end

_G.requireInjector()

local Util = require('util')

_G.kernel = {
  UID = 0,
  hooks = { },
  routines = { },
  terminal = _G.term.current(),
}

local kernel = _G.kernel
local os     = _G.os
local term   = _G.term

local focusedRoutineEvents = Util.transpose {
  'char', 'key', 'key_up',
  'mouse_click', 'mouse_drag', 'mouse_scroll', 'mouse_up',
  'paste', 'terminate',
}

-- any function that runs in a kernel hook does not run in
-- a separate coroutine or have a window. an error in a hook
-- function will crash the system.
function kernel.hook(event, fn)
  if type(event) == 'table' then
    for _,v in pairs(event) do
      kernel.hook(v, fn)
    end
  else
    if not kernel.hooks[event] then
      kernel.hooks[event] = { }
    end
    table.insert(kernel.hooks[event], fn)
  end
end

-- you can only unhook from within the function that hooked
function kernel.unhook(event, fn)
  local eventHooks = kernel.hooks[event]
  if eventHooks then
    Util.removeByValue(eventHooks, fn)
    if #eventHooks == 0 then
      kernel.hooks[event] = nil
    end
  end
end

local Routine = { }

function Routine:resume(event, ...)
  if not self.co or coroutine.status(self.co) == 'dead' then
    return
  end

  if not self.filter or self.filter == event or event == "terminate" then
    term.redirect(self.terminal)

    local previous = kernel.running
    kernel.running = self -- stupid shell set title
    local ok, result = coroutine.resume(self.co, event, ...)
    kernel.running = previous

    self.terminal = term.current()
    if ok then
      self.filter = result
    else
      _G.printError(result)
    end
    if coroutine.status(self.co) == 'dead' then
      Util.removeByValue(kernel.routines, self)
      if #kernel.routines > 0 then
        os.queueEvent('kernel_focus', kernel.routines[1].uid)
      end
    end
    return ok, result
  end
end

function kernel.getFocused()
  return kernel.routines[1]
end

function kernel.getCurrent()
  return kernel.running
end

function kernel.newRoutine(args)
  kernel.UID = kernel.UID + 1

  args = args or { }

  local routine = setmetatable(args, { __index = Routine })
  routine.uid = kernel.UID

  return routine
end

function kernel.run(routine)
  routine.timestamp = os.clock()
  routine.terminal = routine.terminal or kernel.terminal
  routine.window = routine.window or kernel.window
  routine.env = Util.shallowCopy(routine.env or sandboxEnv)

  routine.co = routine.co or coroutine.create(function()
    local result, err

    if routine.fn then
      result, err = Util.runFunction(routine.env, routine.fn, table.unpack(routine.args or { } ))
    elseif routine.path then
      result, err = Util.run(routine.env, routine.path, table.unpack(routine.args or { } ))
    else
      err = 'kernel: invalid routine'
    end

    if not result and err and err ~= 'Terminated' then
      _G.printError(tostring(err))
    end
  end)

  table.insert(kernel.routines, routine)

  local previousTerm = term.current()
  local s, m = routine:resume()
  term.redirect(previousTerm)

  return s, m
end

function kernel.raise(uid)
  local routine = Util.find(kernel.routines, 'uid', uid)

  if routine then
    local previous = kernel.routines[1]
    if routine ~= previous then
      Util.removeByValue(kernel.routines, routine)
      table.insert(kernel.routines, 1, routine)
    end
    os.queueEvent('kernel_focus', routine.uid, previous and previous.uid)
    return true
  end
  return false
end

function kernel.lower(uid)
  local routine = Util.find(kernel.routines, 'uid', uid)

  if routine and #kernel.routines > 1 then
    Util.removeByValue(kernel.routines, routine)
    table.insert(kernel.routines, routine)
    return true
  end
  return false
end

function kernel.find(uid)
  return Util.find(kernel.routines, 'uid', uid)
end

function kernel.halt()
  os.queueEvent('kernel_halt')
end

function kernel.event(event, eventData)
  local stopPropagation

  local eventHooks = kernel.hooks[event]
  if eventHooks then
    for i = #eventHooks, 1, -1 do
      local s, m = pcall(function()
        stopPropagation = eventHooks[i](event, eventData)
      end)
      if not s then
        error(m)
      end
      if stopPropagation then
        break
      end
    end
  end

  if not stopPropagation then
    if focusedRoutineEvents[event] then
      local active = kernel.routines[1]
      if active then
        active:resume(event, table.unpack(eventData))
      end
    else
      -- Passthrough to all processes
      for _,routine in pairs(Util.shallowCopy(kernel.routines)) do
        routine:resume(event, table.unpack(eventData))
      end
    end
  end
end

function kernel.start()
  repeat
    local eventData = { os.pullEventRaw() }
    local event = table.remove(eventData, 1)
    kernel.event(event, eventData)
  until event == 'kernel_halt' or not kernel.routines[1]
end