honeylisp/wrap.fnl

(require "lite")
(local util (require "util"))
(local lume (require "lume"))
(local imgui (require "imgui"))
(local serial (require "serial"))
(local gsplus (require "machine"))
(local core (require "core"))
(local command (require "core.command"))
(local keymap (require "core.keymap"))
(local translate (require "core.doc.translate"))

(var machine (if (and (pcall #(serial:connect)) (serial:connected?)) serial gsplus))

(command.add #(not= machine serial) {
  "serial:switch-machine" #(set machine serial)
})
(command.add #(not= machine gsplus) {
  "gsplus:switch-machine" #(set machine gsplus)
})
(command.add #(machine:connected?) {
  "honeylisp:upload" (fn []
    (local p (util.reload "neut"))
    (p:upload machine)
    (core.log (string.format "%x" (p:lookup-addr p.start-symbol))))
})
(command.add (fn [] true) {
  "honeylisp:rebuild" #(util.reload "neut")
})

(fn selected-symbol []
  (local ldoc core.active_view.doc)
  (var (aline acol bline bcol) (ldoc:get_selection))
  (when (and (= aline bline) (= acol bcol))
    (set (aline acol) (translate.start_of_word ldoc aline acol))
    (set (bline bcol) (translate.end_of_word ldoc bline bcol)))
  (ldoc:get_text aline acol bline bcol))

(command.add "core.docview" {
  "fennel:eval" (fn []
    (let [ldoc core.active_view.doc
          (aline acol bline bcol) (ldoc:get_selection)
          options {:env _G :compiler-env _G}
          inject #(ldoc:insert bline bcol (fv (fennel.eval $1 options) {}))]
      (if (and (= aline bline) (= acol bcol))
        (inject (ldoc:get_text aline 1 aline 10000000))
        (inject (ldoc:get_text aline acol bline bcol)))))
  "lume:hotswap" (fn []
    (local modname
      (-> core.active_view.doc.filename
        (: :gsub "%.%a+$" "")
        (: :gsub "/" ".")
        (: :gsub "^data%." "")
        (: :gsub "%.init$" "")))
    (core.log (.. "Hotswapping " modname))
    (local (mod err) (util.hotswap modname))
    (when (not= err nil) (print err) (error err)))
  "honeylisp:address" (fn []
    (local word (selected-symbol))
    (local p (require "neut"))
    (core.log (string.format "%s %x" word (or (p:lookup-addr word) -1)))
  )
})
(keymap.add {
  "alt+e" "fennel:eval"
  "alt+r" "lume:hotswap"
  "alt+a" "honeylisp:address"
})

(fn love.load [])

(fn love.update [dt]
  (imgui.NewFrame))

(fn love.draw []
  (imgui.Render))

(fn love.quit []
  (imgui.ShutDown))

(fn love.textinput [t]
  (imgui.TextInput t))

(fn love.keypressed [key]
  (imgui.KeyPressed key))

(fn love.keyreleased [key]
  (imgui.KeyReleased key))

(fn love.mousemoved [x y]
  (imgui.MouseMoved x y))

(fn love.mousepressed [x y button]
  (imgui.MousePressed button))

(fn love.mousereleased [x y button]
  (imgui.MouseReleased button))

(fn love.wheelmoved [x y]
  (imgui.WheelMoved y))

{}