fennel implemention: love2d lite editor w/ custom commands & imgui
This commit is contained in:
parent
0eb081d040
commit
4918867140
250
asm.fnl
Normal file
250
asm.fnl
Normal file
|
|
@ -0,0 +1,250 @@
|
|||
(local {: stream : kvstream : one} (require "stream"))
|
||||
|
||||
(local opcodes {})
|
||||
|
||||
; op mode arg
|
||||
; single-byte ops
|
||||
(let [ops
|
||||
{:php 0x08 :plp 0x28 :pha 0x48 :pla 0x68 :dey 0x88 :tay 0xa8 :iny 0xc8 :inx 0xe8
|
||||
:clc 0x18 :sec 0x38 :cli 0x58 :sei 0x78 :tya 0x98 :clv 0xb8 :cld 0xd8 :sed 0xf8
|
||||
:txa 0x8a :txs 0x9a :tax 0xaa :tsx 0xba :dex 0xca :nop 0xea :brk 0x00 :rti 0x40
|
||||
:rts 0x60}]
|
||||
(each [opcode byte (pairs ops)]
|
||||
(tset opcodes opcode (fn [mode] (if mode nil byte)))))
|
||||
|
||||
; branch ops
|
||||
(let [ops {:bpl 0x10 :bmi 0x30 :bvc 0x50 :bvs 0x70 :bcc 0x90 :bcs 0xb0 :bne 0xd0 :beq 0xf0}]
|
||||
(each [opcode byte (pairs ops)]
|
||||
(tset opcodes opcode (fn [mode] (if (= mode :rel) byte nil)))))
|
||||
(set opcodes.jsr (fn [mode] (if (= mode :abs) 0x20 nil)))
|
||||
|
||||
; aaabbbcc ops
|
||||
(fn aaabbbcc [aaa cc modemap]
|
||||
(local base (bit.bor cc (bit.lshift aaa 5)))
|
||||
(fn [mode]
|
||||
(local bbb (. modemap mode))
|
||||
(if bbb (bit.bor base (bit.lshift bbb 2)) nil)))
|
||||
|
||||
(fn indexed-modes [...]
|
||||
(let [modemap {}]
|
||||
(each [index mode (pairs [...])]
|
||||
(tset modemap mode (- index 1)))
|
||||
modemap))
|
||||
|
||||
(fn without-modes [modemap ...]
|
||||
(let [newmodemap (table.clone modemap)]
|
||||
(each [_ mode (pairs [...])]
|
||||
(tset newmodemap mode nil))
|
||||
newmodemap))
|
||||
|
||||
(fn only-modes [modemap ...]
|
||||
(let [newmodemap {}]
|
||||
(each [_ mode (pairs [...])]
|
||||
(tset newmodemap mode (. modemap mode)))
|
||||
newmodemap))
|
||||
|
||||
; cc=1 ops
|
||||
(let [cc1-modes (indexed-modes :zp-x* :zp :imm :abs :zp*-y :zp-x :abs-y :abs-x)
|
||||
ops {:ora 0 :and 1 :eor 2 :adc 3 :lda 5 :cmp 6 :sbc 7}]
|
||||
(each [opcode aaa (pairs ops)]
|
||||
(tset opcodes opcode (aaabbbcc aaa 1 cc1-modes))
|
||||
(tset opcodes :sta (aaabbbcc 4 1 (without-modes cc1-modes :imm)))))
|
||||
|
||||
; cc=2 ops
|
||||
(let [cc2-modes (indexed-modes nil :zp :a :abs nil :zp-x nil :abs-x)]
|
||||
(each [opcode aaa (pairs {:asl 0 :rol 1 :lsr 2 :ror 3})]
|
||||
(tset opcodes opcode (aaabbbcc aaa 2 cc2-modes))
|
||||
(each [opcode aaa (pairs {:dec 6 :inc 7})]
|
||||
(tset opcodes opcode (aaabbbcc aaa 2 (without-modes cc2-modes :a))))))
|
||||
(tset opcodes :stx (aaabbbcc 4 2 (indexed-modes nil :zp nil :abs nil nil :zp-y)))
|
||||
(tset opcodes :ldx (aaabbbcc 5 2 (indexed-modes :imm :zp nil :abs nil nil :zp-y nil :abs-y)))
|
||||
|
||||
; cc=0 ops
|
||||
(let [cc0-modes (indexed-modes :imm :zp nil :abs nil :zp-x nil :abs-x)]
|
||||
(tset opcodes :bit (aaabbbcc 1 0 (only-modes cc0-modes :zp :abs)))
|
||||
(tset opcodes :sty (aaabbbcc 4 0 (only-modes cc0-modes :zp :abs :zp-x)))
|
||||
(tset opcodes :ldy (aaabbbcc 5 0 cc0-modes))
|
||||
(each [opcode aaa (pairs {:cpy 6 :cpx 7})]
|
||||
(tset opcodes opcode (aaabbbcc aaa 0 (only-modes cc0-modes :imm :zp :abs)))))
|
||||
(tset opcodes :jmp (fn [mode] (match mode :abs 0x4c :abs* 0x6c _ nil)))
|
||||
|
||||
(fn size [mode]
|
||||
(if
|
||||
(or (= mode nil) (= mode :a)) 1
|
||||
(= (mode:sub 1 3) :abs) 3
|
||||
2))
|
||||
(fn opsize [op] (if (= op.opcode :block) 0 (size op.mode)))
|
||||
|
||||
(fn parse-mode-arg [op]
|
||||
(match op
|
||||
[_ :a] [:a nil]
|
||||
([_ imm] ? (= (type imm) "number")) [:imm imm]
|
||||
([op addr] ? (and (= (type addr) "string") (= (op:sub 1 1) "b"))) [:rel addr] ; branch
|
||||
([_ addr] ? (= (type addr) "string")) [:addr addr]
|
||||
[_ addr :x] [:addr-x addr]
|
||||
[_ addr :y] [:addr-y addr]
|
||||
[_ [addr] :y] [:zp*-y addr]
|
||||
[_ [addr :x]] [:zp-x* addr]
|
||||
[_ [addr]] [:abs* addr]
|
||||
[_] [nil nil]
|
||||
_ (error (.. "Unrecognized syntax" (fv op)))))
|
||||
|
||||
(fn parse-ops [block ops]
|
||||
(var index 1)
|
||||
(each [_ op (ipairs ops)]
|
||||
(if (= (type op) "string")
|
||||
(tset block.symbols op index)
|
||||
(let [opcode (. op 1)]
|
||||
(if
|
||||
(. opcodes opcode)
|
||||
(let [[mode arg] (parse-mode-arg op)]
|
||||
(table.insert block.code {: opcode : mode : arg}))
|
||||
|
||||
(= opcode :block)
|
||||
(let [ops (table.clone op)]
|
||||
(table.remove ops 1)
|
||||
(table.insert block.code (parse-ops {: opcode :code [] :symbols {}} ops)))
|
||||
|
||||
(error (.. "Unrecognized opcode " (fv opcode))))
|
||||
(set index (+ index 1)))))
|
||||
block)
|
||||
|
||||
(fn block [org ...] (parse-ops {:type :code : org :code [] :symbols {}} [...]))
|
||||
(fn db [org init] {:type :var : org : init :size 1})
|
||||
(fn dw [org init] {:type :var : org : init :size 2})
|
||||
(fn allot [org size] {:type :var : org : size})
|
||||
|
||||
(fn make-env [blocks]
|
||||
{: blocks
|
||||
:push (fn [self block]
|
||||
(make-env
|
||||
(-> (stream self.blocks)
|
||||
(: :concat (one block))
|
||||
(: :tolist))))
|
||||
:lookup
|
||||
(fn [self name]
|
||||
(-> (stream self.blocks)
|
||||
(: :reverse)
|
||||
(: :map
|
||||
(fn [block]
|
||||
(let [symbol (. block.symbols name)]
|
||||
(match (type symbol)
|
||||
"number" (. block.code symbol)
|
||||
"table" symbol
|
||||
_ nil))))
|
||||
(: :filter (fn [symbol] symbol))
|
||||
(: :first)))
|
||||
:lookup-block
|
||||
(fn [self name]
|
||||
(if
|
||||
(-> (stream self.blocks)
|
||||
(: :skip 1)
|
||||
(: :filter (fn [block] (. block.symbols name)))
|
||||
(: :next))
|
||||
(. self.blocks 2)
|
||||
(. (. self.blocks 1) name)))
|
||||
:is-zp? (fn [self name] (< (. (self:lookup-block name) :org) 0x100))})
|
||||
|
||||
(fn op-stream [env block]
|
||||
(-> (stream block.code)
|
||||
(: :map
|
||||
(fn [op]
|
||||
(if (= op.opcode :block)
|
||||
(: (one op env)
|
||||
:concat (op-stream (env:push op) op))
|
||||
(one op env))))
|
||||
(: :flatten)))
|
||||
|
||||
(fn int8-to-bytes [i]
|
||||
(string.char (bit.band i 0xff)))
|
||||
(fn int16-to-bytes [i]
|
||||
(string.char (bit.band i 0xff) (bit.band (bit.rshift i 8) 0xff)))
|
||||
|
||||
(fn program []
|
||||
{:symbols {}
|
||||
:start-symbol :main
|
||||
:add (fn [self name elem] (tset self.symbols name elem))
|
||||
:block (fn [self name org ...] (self:add name (block org ...)))
|
||||
:db (fn [self name org init] (self:add name (db org init)))
|
||||
:dw (fn [self name org init] (self:add name (dw org init)))
|
||||
:allot (fn [self name org size] (self:add name (allot org size)))
|
||||
:op-stream
|
||||
(fn [self block] (op-stream (make-env [self block]) block))
|
||||
:patch-addr-modes
|
||||
(fn [self]
|
||||
(each [name block (pairs self.symbols)]
|
||||
(each [op env (: (self:op-stream block) :iter)]
|
||||
(when (and op.mode (= (op.mode:sub 1 4) :addr))
|
||||
(let [zp-mode (.. :zp (op.mode:sub 5))
|
||||
abs-mode (.. :abs (op.mode:sub 5))
|
||||
is-zp (and ((. opcodes op.opcode) zp-mode) (env:is-zp? op.arg))]
|
||||
(set op.mode (if is-zp zp-mode abs-mode)))))))
|
||||
:allocate
|
||||
(fn [self org size org-addr]
|
||||
(var addr (. org-addr org))
|
||||
(when (= nil addr)
|
||||
(tset org-addr org org)
|
||||
(set addr org))
|
||||
(tset org-addr org (+ addr size))
|
||||
addr)
|
||||
:allocate-var-block
|
||||
(fn [self block org-addr]
|
||||
(set block.addr (self:allocate block.org block.size org-addr)))
|
||||
:allocate-code-block
|
||||
(fn [self block org-addr]
|
||||
(set block.addr (self:allocate block.org 0 org-addr))
|
||||
(each [op env (: (self:op-stream block) :iter)]
|
||||
(set op.addr (self:allocate block.org (opsize op) org-addr))))
|
||||
:allocate-addresses
|
||||
(fn [self]
|
||||
(let [org-addr {}]
|
||||
(each [name block (pairs self.symbols)]
|
||||
(match block.type
|
||||
:var (self:allocate-var-block block org-addr)
|
||||
:code (self:allocate-code-block block org-addr)))))
|
||||
:generate-var-block
|
||||
(fn [self block]
|
||||
(match block.size
|
||||
1 (int8-to-bytes (or block.init 0))
|
||||
2 (int16-to-bytes (or block.init 0))
|
||||
n (string.rep "\0" n)))
|
||||
:lookup-addr
|
||||
(fn [self sym env]
|
||||
(local op (env:lookup sym))
|
||||
(if op
|
||||
op.addr
|
||||
(tonumber sym)))
|
||||
:generate-op-arg
|
||||
(fn [self op env]
|
||||
(if
|
||||
(= op.mode :imm) (int8-to-bytes op.arg)
|
||||
(= op.mode :rel)
|
||||
(int8-to-bytes (- (self:lookup-addr op.arg env) (+ op.addr 2)))
|
||||
(= (size op.mode) 2) (int8-to-bytes (self:lookup-addr op.arg env))
|
||||
(= (size op.mode) 3) (int16-to-bytes (self:lookup-addr op.arg env))
|
||||
""))
|
||||
:generate-op
|
||||
(fn [self op env]
|
||||
(let [bytegen (. opcodes op.opcode)]
|
||||
(if bytegen
|
||||
(.. (int8-to-bytes (bytegen op.mode)) (self:generate-op-arg op env))
|
||||
"")))
|
||||
:generate-code-block
|
||||
(fn [self block]
|
||||
(var bytes "")
|
||||
(each [op env (: (self:op-stream block) :iter)]
|
||||
(set bytes (.. bytes (self:generate-op op env))))
|
||||
(set block.bytes bytes))
|
||||
:generate-bytes
|
||||
(fn [self]
|
||||
(each [name block (pairs self.symbols)]
|
||||
(match block.type
|
||||
:var (self:generate-var-block block)
|
||||
:code (self:generate-code-block block))))
|
||||
:assemble
|
||||
(fn [self]
|
||||
(self:patch-addr-modes)
|
||||
(self:allocate-addresses)
|
||||
(self:generate-bytes))})
|
||||
|
||||
program
|
||||
5
conf.lua
Normal file
5
conf.lua
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
function love.conf(t)
|
||||
t.window.width = 1280
|
||||
t.window.height = 1000
|
||||
t.window.resizable = true
|
||||
end
|
||||
714
dkjson.lua
Normal file
714
dkjson.lua
Normal file
|
|
@ -0,0 +1,714 @@
|
|||
-- Module options:
|
||||
local always_try_using_lpeg = true
|
||||
local register_global_module_table = false
|
||||
local global_module_name = 'json'
|
||||
|
||||
--[==[
|
||||
|
||||
David Kolf's JSON module for Lua 5.1/5.2
|
||||
|
||||
Version 2.5
|
||||
|
||||
|
||||
For the documentation see the corresponding readme.txt or visit
|
||||
<http://dkolf.de/src/dkjson-lua.fsl/>.
|
||||
|
||||
You can contact the author by sending an e-mail to 'david' at the
|
||||
domain 'dkolf.de'.
|
||||
|
||||
|
||||
Copyright (C) 2010-2013 David Heiko Kolf
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
"Software"), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be
|
||||
included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
|
||||
--]==]
|
||||
|
||||
-- global dependencies:
|
||||
local pairs, type, tostring, tonumber, getmetatable, setmetatable, rawset =
|
||||
pairs, type, tostring, tonumber, getmetatable, setmetatable, rawset
|
||||
local error, require, pcall, select = error, require, pcall, select
|
||||
local floor, huge = math.floor, math.huge
|
||||
local strrep, gsub, strsub, strbyte, strchar, strfind, strlen, strformat =
|
||||
string.rep, string.gsub, string.sub, string.byte, string.char,
|
||||
string.find, string.len, string.format
|
||||
local strmatch = string.match
|
||||
local concat = table.concat
|
||||
|
||||
local json = { version = "dkjson 2.5" }
|
||||
|
||||
if register_global_module_table then
|
||||
_G[global_module_name] = json
|
||||
end
|
||||
|
||||
local _ENV = nil -- blocking globals in Lua 5.2
|
||||
|
||||
pcall (function()
|
||||
-- Enable access to blocked metatables.
|
||||
-- Don't worry, this module doesn't change anything in them.
|
||||
local debmeta = require "debug".getmetatable
|
||||
if debmeta then getmetatable = debmeta end
|
||||
end)
|
||||
|
||||
json.null = setmetatable ({}, {
|
||||
__tojson = function () return "null" end
|
||||
})
|
||||
|
||||
local function isarray (tbl)
|
||||
local max, n, arraylen = 0, 0, 0
|
||||
for k,v in pairs (tbl) do
|
||||
if k == 'n' and type(v) == 'number' then
|
||||
arraylen = v
|
||||
if v > max then
|
||||
max = v
|
||||
end
|
||||
else
|
||||
if type(k) ~= 'number' or k < 1 or floor(k) ~= k then
|
||||
return false
|
||||
end
|
||||
if k > max then
|
||||
max = k
|
||||
end
|
||||
n = n + 1
|
||||
end
|
||||
end
|
||||
if max > 10 and max > arraylen and max > n * 2 then
|
||||
return false -- don't create an array with too many holes
|
||||
end
|
||||
return true, max
|
||||
end
|
||||
|
||||
local escapecodes = {
|
||||
["\""] = "\\\"", ["\\"] = "\\\\", ["\b"] = "\\b", ["\f"] = "\\f",
|
||||
["\n"] = "\\n", ["\r"] = "\\r", ["\t"] = "\\t"
|
||||
}
|
||||
|
||||
local function escapeutf8 (uchar)
|
||||
local value = escapecodes[uchar]
|
||||
if value then
|
||||
return value
|
||||
end
|
||||
local a, b, c, d = strbyte (uchar, 1, 4)
|
||||
a, b, c, d = a or 0, b or 0, c or 0, d or 0
|
||||
if a <= 0x7f then
|
||||
value = a
|
||||
elseif 0xc0 <= a and a <= 0xdf and b >= 0x80 then
|
||||
value = (a - 0xc0) * 0x40 + b - 0x80
|
||||
elseif 0xe0 <= a and a <= 0xef and b >= 0x80 and c >= 0x80 then
|
||||
value = ((a - 0xe0) * 0x40 + b - 0x80) * 0x40 + c - 0x80
|
||||
elseif 0xf0 <= a and a <= 0xf7 and b >= 0x80 and c >= 0x80 and d >= 0x80 then
|
||||
value = (((a - 0xf0) * 0x40 + b - 0x80) * 0x40 + c - 0x80) * 0x40 + d - 0x80
|
||||
else
|
||||
return ""
|
||||
end
|
||||
if value <= 0xffff then
|
||||
return strformat ("\\u%.4x", value)
|
||||
elseif value <= 0x10ffff then
|
||||
-- encode as UTF-16 surrogate pair
|
||||
value = value - 0x10000
|
||||
local highsur, lowsur = 0xD800 + floor (value/0x400), 0xDC00 + (value % 0x400)
|
||||
return strformat ("\\u%.4x\\u%.4x", highsur, lowsur)
|
||||
else
|
||||
return ""
|
||||
end
|
||||
end
|
||||
|
||||
local function fsub (str, pattern, repl)
|
||||
-- gsub always builds a new string in a buffer, even when no match
|
||||
-- exists. First using find should be more efficient when most strings
|
||||
-- don't contain the pattern.
|
||||
if strfind (str, pattern) then
|
||||
return gsub (str, pattern, repl)
|
||||
else
|
||||
return str
|
||||
end
|
||||
end
|
||||
|
||||
local function quotestring (value)
|
||||
-- based on the regexp "escapable" in https://github.com/douglascrockford/JSON-js
|
||||
value = fsub (value, "[%z\1-\31\"\\\127]", escapeutf8)
|
||||
if strfind (value, "[\194\216\220\225\226\239]") then
|
||||
value = fsub (value, "\194[\128-\159\173]", escapeutf8)
|
||||
value = fsub (value, "\216[\128-\132]", escapeutf8)
|
||||
value = fsub (value, "\220\143", escapeutf8)
|
||||
value = fsub (value, "\225\158[\180\181]", escapeutf8)
|
||||
value = fsub (value, "\226\128[\140-\143\168-\175]", escapeutf8)
|
||||
value = fsub (value, "\226\129[\160-\175]", escapeutf8)
|
||||
value = fsub (value, "\239\187\191", escapeutf8)
|
||||
value = fsub (value, "\239\191[\176-\191]", escapeutf8)
|
||||
end
|
||||
return "\"" .. value .. "\""
|
||||
end
|
||||
json.quotestring = quotestring
|
||||
|
||||
local function replace(str, o, n)
|
||||
local i, j = strfind (str, o, 1, true)
|
||||
if i then
|
||||
return strsub(str, 1, i-1) .. n .. strsub(str, j+1, -1)
|
||||
else
|
||||
return str
|
||||
end
|
||||
end
|
||||
|
||||
-- locale independent num2str and str2num functions
|
||||
local decpoint, numfilter
|
||||
|
||||
local function updatedecpoint ()
|
||||
decpoint = strmatch(tostring(0.5), "([^05+])")
|
||||
-- build a filter that can be used to remove group separators
|
||||
numfilter = "[^0-9%-%+eE" .. gsub(decpoint, "[%^%$%(%)%%%.%[%]%*%+%-%?]", "%%%0") .. "]+"
|
||||
end
|
||||
|
||||
updatedecpoint()
|
||||
|
||||
local function num2str (num)
|
||||
return replace(fsub(tostring(num), numfilter, ""), decpoint, ".")
|
||||
end
|
||||
|
||||
local function str2num (str)
|
||||
local num = tonumber(replace(str, ".", decpoint))
|
||||
if not num then
|
||||
updatedecpoint()
|
||||
num = tonumber(replace(str, ".", decpoint))
|
||||
end
|
||||
return num
|
||||
end
|
||||
|
||||
local function addnewline2 (level, buffer, buflen)
|
||||
buffer[buflen+1] = "\n"
|
||||
buffer[buflen+2] = strrep (" ", level)
|
||||
buflen = buflen + 2
|
||||
return buflen
|
||||
end
|
||||
|
||||
function json.addnewline (state)
|
||||
if state.indent then
|
||||
state.bufferlen = addnewline2 (state.level or 0,
|
||||
state.buffer, state.bufferlen or #(state.buffer))
|
||||
end
|
||||
end
|
||||
|
||||
local encode2 -- forward declaration
|
||||
|
||||
local function addpair (key, value, prev, indent, level, buffer, buflen, tables, globalorder, state)
|
||||
local kt = type (key)
|
||||
if kt ~= 'string' and kt ~= 'number' then
|
||||
return nil, "type '" .. kt .. "' is not supported as a key by JSON."
|
||||
end
|
||||
if prev then
|
||||
buflen = buflen + 1
|
||||
buffer[buflen] = ","
|
||||
end
|
||||
if indent then
|
||||
buflen = addnewline2 (level, buffer, buflen)
|
||||
end
|
||||
buffer[buflen+1] = quotestring (key)
|
||||
buffer[buflen+2] = ":"
|
||||
return encode2 (value, indent, level, buffer, buflen + 2, tables, globalorder, state)
|
||||
end
|
||||
|
||||
local function appendcustom(res, buffer, state)
|
||||
local buflen = state.bufferlen
|
||||
if type (res) == 'string' then
|
||||
buflen = buflen + 1
|
||||
buffer[buflen] = res
|
||||
end
|
||||
return buflen
|
||||
end
|
||||
|
||||
local function exception(reason, value, state, buffer, buflen, defaultmessage)
|
||||
defaultmessage = defaultmessage or reason
|
||||
local handler = state.exception
|
||||
if not handler then
|
||||
return nil, defaultmessage
|
||||
else
|
||||
state.bufferlen = buflen
|
||||
local ret, msg = handler (reason, value, state, defaultmessage)
|
||||
if not ret then return nil, msg or defaultmessage end
|
||||
return appendcustom(ret, buffer, state)
|
||||
end
|
||||
end
|
||||
|
||||
function json.encodeexception(reason, value, state, defaultmessage)
|
||||
return quotestring("<" .. defaultmessage .. ">")
|
||||
end
|
||||
|
||||
encode2 = function (value, indent, level, buffer, buflen, tables, globalorder, state)
|
||||
local valtype = type (value)
|
||||
local valmeta = getmetatable (value)
|
||||
valmeta = type (valmeta) == 'table' and valmeta -- only tables
|
||||
local valtojson = valmeta and valmeta.__tojson
|
||||
if valtojson then
|
||||
if tables[value] then
|
||||
return exception('reference cycle', value, state, buffer, buflen)
|
||||
end
|
||||
tables[value] = true
|
||||
state.bufferlen = buflen
|
||||
local ret, msg = valtojson (value, state)
|
||||
if not ret then return exception('custom encoder failed', value, state, buffer, buflen, msg) end
|
||||
tables[value] = nil
|
||||
buflen = appendcustom(ret, buffer, state)
|
||||
elseif value == nil then
|
||||
buflen = buflen + 1
|
||||
buffer[buflen] = "null"
|
||||
elseif valtype == 'number' then
|
||||
local s
|
||||
if value ~= value or value >= huge or -value >= huge then
|
||||
-- This is the behaviour of the original JSON implementation.
|
||||
s = "null"
|
||||
else
|
||||
s = num2str (value)
|
||||
end
|
||||
buflen = buflen + 1
|
||||
buffer[buflen] = s
|
||||
elseif valtype == 'boolean' then
|
||||
buflen = buflen + 1
|
||||
buffer[buflen] = value and "true" or "false"
|
||||
elseif valtype == 'string' then
|
||||
buflen = buflen + 1
|
||||
buffer[buflen] = quotestring (value)
|
||||
elseif valtype == 'table' then
|
||||
if tables[value] then
|
||||
return exception('reference cycle', value, state, buffer, buflen)
|
||||
end
|
||||
tables[value] = true
|
||||
level = level + 1
|
||||
local isa, n = isarray (value)
|
||||
if n == 0 and valmeta and valmeta.__jsontype == 'object' then
|
||||
isa = false
|
||||
end
|
||||
local msg
|
||||
if isa then -- JSON array
|
||||
buflen = buflen + 1
|
||||
buffer[buflen] = "["
|
||||
for i = 1, n do
|
||||
buflen, msg = encode2 (value[i], indent, level, buffer, buflen, tables, globalorder, state)
|
||||
if not buflen then return nil, msg end
|
||||
if i < n then
|
||||
buflen = buflen + 1
|
||||
buffer[buflen] = ","
|
||||
end
|
||||
end
|
||||
buflen = buflen + 1
|
||||
buffer[buflen] = "]"
|
||||
else -- JSON object
|
||||
local prev = false
|
||||
buflen = buflen + 1
|
||||
buffer[buflen] = "{"
|
||||
local order = valmeta and valmeta.__jsonorder or globalorder
|
||||
if order then
|
||||
local used = {}
|
||||
n = #order
|
||||
for i = 1, n do
|
||||
local k = order[i]
|
||||
local v = value[k]
|
||||
if v then
|
||||
used[k] = true
|
||||
buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder, state)
|
||||
prev = true -- add a seperator before the next element
|
||||
end
|
||||
end
|
||||
for k,v in pairs (value) do
|
||||
if not used[k] then
|
||||
buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder, state)
|
||||
if not buflen then return nil, msg end
|
||||
prev = true -- add a seperator before the next element
|
||||
end
|
||||
end
|
||||
else -- unordered
|
||||
for k,v in pairs (value) do
|
||||
buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder, state)
|
||||
if not buflen then return nil, msg end
|
||||
prev = true -- add a seperator before the next element
|
||||
end
|
||||
end
|
||||
if indent then
|
||||
buflen = addnewline2 (level - 1, buffer, buflen)
|
||||
end
|
||||
buflen = buflen + 1
|
||||
buffer[buflen] = "}"
|
||||
end
|
||||
tables[value] = nil
|
||||
else
|
||||
return exception ('unsupported type', value, state, buffer, buflen,
|
||||
"type '" .. valtype .. "' is not supported by JSON.")
|
||||
end
|
||||
return buflen
|
||||
end
|
||||
|
||||
function json.encode (value, state)
|
||||
state = state or {}
|
||||
local oldbuffer = state.buffer
|
||||
local buffer = oldbuffer or {}
|
||||
state.buffer = buffer
|
||||
updatedecpoint()
|
||||
local ret, msg = encode2 (value, state.indent, state.level or 0,
|
||||
buffer, state.bufferlen or 0, state.tables or {}, state.keyorder, state)
|
||||
if not ret then
|
||||
error (msg, 2)
|
||||
elseif oldbuffer == buffer then
|
||||
state.bufferlen = ret
|
||||
return true
|
||||
else
|
||||
state.bufferlen = nil
|
||||
state.buffer = nil
|
||||
return concat (buffer)
|
||||
end
|
||||
end
|
||||
|
||||
local function loc (str, where)
|
||||
local line, pos, linepos = 1, 1, 0
|
||||
while true do
|
||||
pos = strfind (str, "\n", pos, true)
|
||||
if pos and pos < where then
|
||||
line = line + 1
|
||||
linepos = pos
|
||||
pos = pos + 1
|
||||
else
|
||||
break
|
||||
end
|
||||
end
|
||||
return "line " .. line .. ", column " .. (where - linepos)
|
||||
end
|
||||
|
||||
local function unterminated (str, what, where)
|
||||
return nil, strlen (str) + 1, "unterminated " .. what .. " at " .. loc (str, where)
|
||||
end
|
||||
|
||||
local function scanwhite (str, pos)
|
||||
while true do
|
||||
pos = strfind (str, "%S", pos)
|
||||
if not pos then return nil end
|
||||
local sub2 = strsub (str, pos, pos + 1)
|
||||
if sub2 == "\239\187" and strsub (str, pos + 2, pos + 2) == "\191" then
|
||||
-- UTF-8 Byte Order Mark
|
||||
pos = pos + 3
|
||||
elseif sub2 == "//" then
|
||||
pos = strfind (str, "[\n\r]", pos + 2)
|
||||
if not pos then return nil end
|
||||
elseif sub2 == "/*" then
|
||||
pos = strfind (str, "*/", pos + 2)
|
||||
if not pos then return nil end
|
||||
pos = pos + 2
|
||||
else
|
||||
return pos
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local escapechars = {
|
||||
["\""] = "\"", ["\\"] = "\\", ["/"] = "/", ["b"] = "\b", ["f"] = "\f",
|
||||
["n"] = "\n", ["r"] = "\r", ["t"] = "\t"
|
||||
}
|
||||
|
||||
local function unichar (value)
|
||||
if value < 0 then
|
||||
return nil
|
||||
elseif value <= 0x007f then
|
||||
return strchar (value)
|
||||
elseif value <= 0x07ff then
|
||||
return strchar (0xc0 + floor(value/0x40),
|
||||
0x80 + (floor(value) % 0x40))
|
||||
elseif value <= 0xffff then
|
||||
return strchar (0xe0 + floor(value/0x1000),
|
||||
0x80 + (floor(value/0x40) % 0x40),
|
||||
0x80 + (floor(value) % 0x40))
|
||||
elseif value <= 0x10ffff then
|
||||
return strchar (0xf0 + floor(value/0x40000),
|
||||
0x80 + (floor(value/0x1000) % 0x40),
|
||||
0x80 + (floor(value/0x40) % 0x40),
|
||||
0x80 + (floor(value) % 0x40))
|
||||
else
|
||||
return nil
|
||||
end
|
||||
end
|
||||
|
||||
local function scanstring (str, pos)
|
||||
local lastpos = pos + 1
|
||||
local buffer, n = {}, 0
|
||||
while true do
|
||||
local nextpos = strfind (str, "[\"\\]", lastpos)
|
||||
if not nextpos then
|
||||
return unterminated (str, "string", pos)
|
||||
end
|
||||
if nextpos > lastpos then
|
||||
n = n + 1
|
||||
buffer[n] = strsub (str, lastpos, nextpos - 1)
|
||||
end
|
||||
if strsub (str, nextpos, nextpos) == "\"" then
|
||||
lastpos = nextpos + 1
|
||||
break
|
||||
else
|
||||
local escchar = strsub (str, nextpos + 1, nextpos + 1)
|
||||
local value
|
||||
if escchar == "u" then
|
||||
value = tonumber (strsub (str, nextpos + 2, nextpos + 5), 16)
|
||||
if value then
|
||||
local value2
|
||||
if 0xD800 <= value and value <= 0xDBff then
|
||||
-- we have the high surrogate of UTF-16. Check if there is a
|
||||
-- low surrogate escaped nearby to combine them.
|
||||
if strsub (str, nextpos + 6, nextpos + 7) == "\\u" then
|
||||
value2 = tonumber (strsub (str, nextpos + 8, nextpos + 11), 16)
|
||||
if value2 and 0xDC00 <= value2 and value2 <= 0xDFFF then
|
||||
value = (value - 0xD800) * 0x400 + (value2 - 0xDC00) + 0x10000
|
||||
else
|
||||
value2 = nil -- in case it was out of range for a low surrogate
|
||||
end
|
||||
end
|
||||
end
|
||||
value = value and unichar (value)
|
||||
if value then
|
||||
if value2 then
|
||||
lastpos = nextpos + 12
|
||||
else
|
||||
lastpos = nextpos + 6
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
if not value then
|
||||
value = escapechars[escchar] or escchar
|
||||
lastpos = nextpos + 2
|
||||
end
|
||||
n = n + 1
|
||||
buffer[n] = value
|
||||
end
|
||||
end
|
||||
if n == 1 then
|
||||
return buffer[1], lastpos
|
||||
elseif n > 1 then
|
||||
return concat (buffer), lastpos
|
||||
else
|
||||
return "", lastpos
|
||||
end
|
||||
end
|
||||
|
||||
local scanvalue -- forward declaration
|
||||
|
||||
local function scantable (what, closechar, str, startpos, nullval, objectmeta, arraymeta)
|
||||
local len = strlen (str)
|
||||
local tbl, n = {}, 0
|
||||
local pos = startpos + 1
|
||||
if what == 'object' then
|
||||
setmetatable (tbl, objectmeta)
|
||||
else
|
||||
setmetatable (tbl, arraymeta)
|
||||
end
|
||||
while true do
|
||||
pos = scanwhite (str, pos)
|
||||
if not pos then return unterminated (str, what, startpos) end
|
||||
local char = strsub (str, pos, pos)
|
||||
if char == closechar then
|
||||
return tbl, pos + 1
|
||||
end
|
||||
local val1, err
|
||||
val1, pos, err = scanvalue (str, pos, nullval, objectmeta, arraymeta)
|
||||
if err then return nil, pos, err end
|
||||
pos = scanwhite (str, pos)
|
||||
if not pos then return unterminated (str, what, startpos) end
|
||||
char = strsub (str, pos, pos)
|
||||
if char == ":" then
|
||||
if val1 == nil then
|
||||
return nil, pos, "cannot use nil as table index (at " .. loc (str, pos) .. ")"
|
||||
end
|
||||
pos = scanwhite (str, pos + 1)
|
||||
if not pos then return unterminated (str, what, startpos) end
|
||||
local val2
|
||||
val2, pos, err = scanvalue (str, pos, nullval, objectmeta, arraymeta)
|
||||
if err then return nil, pos, err end
|
||||
tbl[val1] = val2
|
||||
pos = scanwhite (str, pos)
|
||||
if not pos then return unterminated (str, what, startpos) end
|
||||
char = strsub (str, pos, pos)
|
||||
else
|
||||
n = n + 1
|
||||
tbl[n] = val1
|
||||
end
|
||||
if char == "," then
|
||||
pos = pos + 1
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
scanvalue = function (str, pos, nullval, objectmeta, arraymeta)
|
||||
pos = pos or 1
|
||||
pos = scanwhite (str, pos)
|
||||
if not pos then
|
||||
return nil, strlen (str) + 1, "no valid JSON value (reached the end)"
|
||||
end
|
||||
local char = strsub (str, pos, pos)
|
||||
if char == "{" then
|
||||
return scantable ('object', "}", str, pos, nullval, objectmeta, arraymeta)
|
||||
elseif char == "[" then
|
||||
return scantable ('array', "]", str, pos, nullval, objectmeta, arraymeta)
|
||||
elseif char == "\"" then
|
||||
return scanstring (str, pos)
|
||||
else
|
||||
local pstart, pend = strfind (str, "^%-?[%d%.]+[eE]?[%+%-]?%d*", pos)
|
||||
if pstart then
|
||||
local number = str2num (strsub (str, pstart, pend))
|
||||
if number then
|
||||
return number, pend + 1
|
||||
end
|
||||
end
|
||||
pstart, pend = strfind (str, "^%a%w*", pos)
|
||||
if pstart then
|
||||
local name = strsub (str, pstart, pend)
|
||||
if name == "true" then
|
||||
return true, pend + 1
|
||||
elseif name == "false" then
|
||||
return false, pend + 1
|
||||
elseif name == "null" then
|
||||
return nullval, pend + 1
|
||||
end
|
||||
end
|
||||
return nil, pos, "no valid JSON value at " .. loc (str, pos)
|
||||
end
|
||||
end
|
||||
|
||||
local function optionalmetatables(...)
|
||||
if select("#", ...) > 0 then
|
||||
return ...
|
||||
else
|
||||
return {__jsontype = 'object'}, {__jsontype = 'array'}
|
||||
end
|
||||
end
|
||||
|
||||
function json.decode (str, pos, nullval, ...)
|
||||
local objectmeta, arraymeta = optionalmetatables(...)
|
||||
return scanvalue (str, pos, nullval, objectmeta, arraymeta)
|
||||
end
|
||||
|
||||
function json.use_lpeg ()
|
||||
local g = require ("lpeg")
|
||||
|
||||
if g.version() == "0.11" then
|
||||
error "due to a bug in LPeg 0.11, it cannot be used for JSON matching"
|
||||
end
|
||||
|
||||
local pegmatch = g.match
|
||||
local P, S, R = g.P, g.S, g.R
|
||||
|
||||
local function ErrorCall (str, pos, msg, state)
|
||||
if not state.msg then
|
||||
state.msg = msg .. " at " .. loc (str, pos)
|
||||
state.pos = pos
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
local function Err (msg)
|
||||
return g.Cmt (g.Cc (msg) * g.Carg (2), ErrorCall)
|
||||
end
|
||||
|
||||
local SingleLineComment = P"//" * (1 - S"\n\r")^0
|
||||
local MultiLineComment = P"/*" * (1 - P"*/")^0 * P"*/"
|
||||
local Space = (S" \n\r\t" + P"\239\187\191" + SingleLineComment + MultiLineComment)^0
|
||||
|
||||
local PlainChar = 1 - S"\"\\\n\r"
|
||||
local EscapeSequence = (P"\\" * g.C (S"\"\\/bfnrt" + Err "unsupported escape sequence")) / escapechars
|
||||
local HexDigit = R("09", "af", "AF")
|
||||
local function UTF16Surrogate (match, pos, high, low)
|
||||
high, low = tonumber (high, 16), tonumber (low, 16)
|
||||
if 0xD800 <= high and high <= 0xDBff and 0xDC00 <= low and low <= 0xDFFF then
|
||||
return true, unichar ((high - 0xD800) * 0x400 + (low - 0xDC00) + 0x10000)
|
||||
else
|
||||
return false
|
||||
end
|
||||
end
|
||||
local function UTF16BMP (hex)
|
||||
return unichar (tonumber (hex, 16))
|
||||
end
|
||||
local U16Sequence = (P"\\u" * g.C (HexDigit * HexDigit * HexDigit * HexDigit))
|
||||
local UnicodeEscape = g.Cmt (U16Sequence * U16Sequence, UTF16Surrogate) + U16Sequence/UTF16BMP
|
||||
local Char = UnicodeEscape + EscapeSequence + PlainChar
|
||||
local String = P"\"" * g.Cs (Char ^ 0) * (P"\"" + Err "unterminated string")
|
||||
local Integer = P"-"^(-1) * (P"0" + (R"19" * R"09"^0))
|
||||
local Fractal = P"." * R"09"^0
|
||||
local Exponent = (S"eE") * (S"+-")^(-1) * R"09"^1
|
||||
local Number = (Integer * Fractal^(-1) * Exponent^(-1))/str2num
|
||||
local Constant = P"true" * g.Cc (true) + P"false" * g.Cc (false) + P"null" * g.Carg (1)
|
||||
local SimpleValue = Number + String + Constant
|
||||
local ArrayContent, ObjectContent
|
||||
|
||||
-- The functions parsearray and parseobject parse only a single value/pair
|
||||
-- at a time and store them directly to avoid hitting the LPeg limits.
|
||||
local function parsearray (str, pos, nullval, state)
|
||||
local obj, cont
|
||||
local npos
|
||||
local t, nt = {}, 0
|
||||
repeat
|
||||
obj, cont, npos = pegmatch (ArrayContent, str, pos, nullval, state)
|
||||
if not npos then break end
|
||||
pos = npos
|
||||
nt = nt + 1
|
||||
t[nt] = obj
|
||||
until cont == 'last'
|
||||
return pos, setmetatable (t, state.arraymeta)
|
||||
end
|
||||
|
||||
local function parseobject (str, pos, nullval, state)
|
||||
local obj, key, cont
|
||||
local npos
|
||||
local t = {}
|
||||
repeat
|
||||
key, obj, cont, npos = pegmatch (ObjectContent, str, pos, nullval, state)
|
||||
if not npos then break end
|
||||
pos = npos
|
||||
t[key] = obj
|
||||
until cont == 'last'
|
||||
return pos, setmetatable (t, state.objectmeta)
|
||||
end
|
||||
|
||||
local Array = P"[" * g.Cmt (g.Carg(1) * g.Carg(2), parsearray) * Space * (P"]" + Err "']' expected")
|
||||
local Object = P"{" * g.Cmt (g.Carg(1) * g.Carg(2), parseobject) * Space * (P"}" + Err "'}' expected")
|
||||
local Value = Space * (Array + Object + SimpleValue)
|
||||
local ExpectedValue = Value + Space * Err "value expected"
|
||||
ArrayContent = Value * Space * (P"," * g.Cc'cont' + g.Cc'last') * g.Cp()
|
||||
local Pair = g.Cg (Space * String * Space * (P":" + Err "colon expected") * ExpectedValue)
|
||||
ObjectContent = Pair * Space * (P"," * g.Cc'cont' + g.Cc'last') * g.Cp()
|
||||
local DecodeValue = ExpectedValue * g.Cp ()
|
||||
|
||||
function json.decode (str, pos, nullval, ...)
|
||||
local state = {}
|
||||
state.objectmeta, state.arraymeta = optionalmetatables(...)
|
||||
local obj, retpos = pegmatch (DecodeValue, str, pos, nullval, state)
|
||||
if state.msg then
|
||||
return nil, state.pos, state.msg
|
||||
else
|
||||
return obj, retpos
|
||||
end
|
||||
end
|
||||
|
||||
-- use this function only once:
|
||||
json.use_lpeg = function () return json end
|
||||
|
||||
json.using_lpeg = true
|
||||
|
||||
return json -- so you can get the module using json = require "dkjson".use_lpeg()
|
||||
end
|
||||
|
||||
if always_try_using_lpeg then
|
||||
pcall (json.use_lpeg)
|
||||
end
|
||||
|
||||
return json
|
||||
|
||||
3011
lib/fennel.lua
Normal file
3011
lib/fennel.lua
Normal file
File diff suppressed because it is too large
Load diff
225
lib/fennelview.lua
Normal file
225
lib/fennelview.lua
Normal file
|
|
@ -0,0 +1,225 @@
|
|||
local function view_quote(str)
|
||||
return ("\"" .. str:gsub("\"", "\\\"") .. "\"")
|
||||
end
|
||||
local short_control_char_escapes = {["\11"] = "\\v", ["\12"] = "\\f", ["\13"] = "\\r", ["\7"] = "\\a", ["\8"] = "\\b", ["\9"] = "\\t", ["\n"] = "\\n"}
|
||||
local long_control_char_escapes = nil
|
||||
do
|
||||
local long = {}
|
||||
for i = 0, 31 do
|
||||
local ch = string.char(i)
|
||||
if not short_control_char_escapes[ch] then
|
||||
short_control_char_escapes[ch] = ("\\" .. i)
|
||||
long[ch] = ("\\%03d"):format(i)
|
||||
end
|
||||
end
|
||||
long_control_char_escapes = long
|
||||
end
|
||||
local function escape(str)
|
||||
return str:gsub("\\", "\\\\"):gsub("(%c)%f[0-9]", long_control_char_escapes):gsub("%c", short_control_char_escapes)
|
||||
end
|
||||
local function sequence_key_3f(k, len)
|
||||
return ((type(k) == "number") and (1 <= k) and (k <= len) and (math.floor(k) == k))
|
||||
end
|
||||
local type_order = {["function"] = 5, boolean = 2, number = 1, string = 3, table = 4, thread = 7, userdata = 6}
|
||||
local function sort_keys(a, b)
|
||||
local ta = type(a)
|
||||
local tb = type(b)
|
||||
if ((ta == tb) and (ta ~= "boolean") and ((ta == "string") or (ta == "number"))) then
|
||||
return (a < b)
|
||||
else
|
||||
local dta = type_order[a]
|
||||
local dtb = type_order[b]
|
||||
if (dta and dtb) then
|
||||
return (dta < dtb)
|
||||
elseif dta then
|
||||
return true
|
||||
elseif dtb then
|
||||
return false
|
||||
elseif "else" then
|
||||
return (ta < tb)
|
||||
end
|
||||
end
|
||||
end
|
||||
local function get_sequence_length(t)
|
||||
local len = 1
|
||||
for i in ipairs(t) do
|
||||
len = i
|
||||
end
|
||||
return len
|
||||
end
|
||||
local function get_nonsequential_keys(t)
|
||||
local keys = {}
|
||||
local sequence_length = get_sequence_length(t)
|
||||
for k in pairs(t) do
|
||||
if not sequence_key_3f(k, sequence_length) then
|
||||
table.insert(keys, k)
|
||||
end
|
||||
end
|
||||
table.sort(keys, sort_keys)
|
||||
return keys, sequence_length
|
||||
end
|
||||
local function count_table_appearances(t, appearances)
|
||||
if (type(t) == "table") then
|
||||
if not appearances[t] then
|
||||
appearances[t] = 1
|
||||
for k, v in pairs(t) do
|
||||
count_table_appearances(k, appearances)
|
||||
count_table_appearances(v, appearances)
|
||||
end
|
||||
end
|
||||
else
|
||||
if (t and (t == t)) then
|
||||
appearances[t] = ((appearances[t] or 0) + 1)
|
||||
end
|
||||
end
|
||||
return appearances
|
||||
end
|
||||
local put_value = nil
|
||||
local function puts(self, ...)
|
||||
for _, v in ipairs({...}) do
|
||||
table.insert(self.buffer, v)
|
||||
end
|
||||
return nil
|
||||
end
|
||||
local function tabify(self)
|
||||
return puts(self, "\n", (self.indent):rep(self.level))
|
||||
end
|
||||
local function already_visited_3f(self, v)
|
||||
return (self.ids[v] ~= nil)
|
||||
end
|
||||
local function get_id(self, v)
|
||||
local id = self.ids[v]
|
||||
if not id then
|
||||
local tv = type(v)
|
||||
id = ((self["max-ids"][tv] or 0) + 1)
|
||||
self["max-ids"][tv] = id
|
||||
self.ids[v] = id
|
||||
end
|
||||
return tostring(id)
|
||||
end
|
||||
local function put_sequential_table(self, t, len)
|
||||
puts(self, "[")
|
||||
self.level = (self.level + 1)
|
||||
for i = 1, len do
|
||||
local _0_ = (1 + len)
|
||||
if ((1 < i) and (i < _0_)) then
|
||||
puts(self, " ")
|
||||
end
|
||||
put_value(self, t[i])
|
||||
end
|
||||
self.level = (self.level - 1)
|
||||
return puts(self, "]")
|
||||
end
|
||||
local function put_key(self, k)
|
||||
if ((type(k) == "string") and k:find("^[-%w?\\^_!$%&*+./@:|<=>]+$")) then
|
||||
return puts(self, ":", k)
|
||||
else
|
||||
return put_value(self, k)
|
||||
end
|
||||
end
|
||||
local function put_kv_table(self, t, ordered_keys)
|
||||
puts(self, "{")
|
||||
self.level = (self.level + 1)
|
||||
for i, k in ipairs(ordered_keys) do
|
||||
if (self["table-edges"] or (i ~= 1)) then
|
||||
tabify(self)
|
||||
end
|
||||
put_key(self, k)
|
||||
puts(self, " ")
|
||||
put_value(self, t[k])
|
||||
end
|
||||
for i, v in ipairs(t) do
|
||||
tabify(self)
|
||||
put_key(self, i)
|
||||
puts(self, " ")
|
||||
put_value(self, v)
|
||||
end
|
||||
self.level = (self.level - 1)
|
||||
if self["table-edges"] then
|
||||
tabify(self)
|
||||
end
|
||||
return puts(self, "}")
|
||||
end
|
||||
local function put_table(self, t)
|
||||
local metamethod = nil
|
||||
local function _1_()
|
||||
local _0_0 = t
|
||||
if _0_0 then
|
||||
local _2_0 = getmetatable(_0_0)
|
||||
if _2_0 then
|
||||
return _2_0.__fennelview
|
||||
else
|
||||
return _2_0
|
||||
end
|
||||
else
|
||||
return _0_0
|
||||
end
|
||||
end
|
||||
metamethod = (self["metamethod?"] and _1_())
|
||||
if (already_visited_3f(self, t) and self["detect-cycles?"]) then
|
||||
return puts(self, "#<table ", get_id(self, t), ">")
|
||||
elseif (self.level >= self.depth) then
|
||||
return puts(self, "{...}")
|
||||
elseif metamethod then
|
||||
return puts(self, metamethod(t, self.fennelview))
|
||||
elseif "else" then
|
||||
local non_seq_keys, len = get_nonsequential_keys(t)
|
||||
local id = get_id(self, t)
|
||||
if ((1 < (self.appearances[t] or 0)) and self["detect-cycles?"]) then
|
||||
return puts(self, "#<table", id, ">")
|
||||
elseif ((#non_seq_keys == 0) and (#t == 0)) then
|
||||
local function _2_()
|
||||
if self["empty-as-square"] then
|
||||
return "[]"
|
||||
else
|
||||
return "{}"
|
||||
end
|
||||
end
|
||||
return puts(self, _2_())
|
||||
elseif (#non_seq_keys == 0) then
|
||||
return put_sequential_table(self, t, len)
|
||||
elseif "else" then
|
||||
return put_kv_table(self, t, non_seq_keys)
|
||||
end
|
||||
end
|
||||
end
|
||||
local function _0_(self, v)
|
||||
local tv = type(v)
|
||||
if (tv == "string") then
|
||||
return puts(self, view_quote(escape(v)))
|
||||
elseif ((tv == "number") or (tv == "boolean") or (tv == "nil")) then
|
||||
return puts(self, tostring(v))
|
||||
elseif (tv == "table") then
|
||||
return put_table(self, v)
|
||||
elseif "else" then
|
||||
return puts(self, "#<", tostring(v), ">")
|
||||
end
|
||||
end
|
||||
put_value = _0_
|
||||
local function one_line(str)
|
||||
local ret = str:gsub("\n", " "):gsub("%[ ", "["):gsub(" %]", "]"):gsub("%{ ", "{"):gsub(" %}", "}"):gsub("%( ", "("):gsub(" %)", ")")
|
||||
return ret
|
||||
end
|
||||
local function fennelview(x, options)
|
||||
local options0 = (options or {})
|
||||
local inspector = nil
|
||||
local function _1_(_241)
|
||||
return fennelview(_241, options0)
|
||||
end
|
||||
local function _2_()
|
||||
if options0["one-line"] then
|
||||
return ""
|
||||
else
|
||||
return " "
|
||||
end
|
||||
end
|
||||
inspector = {["detect-cycles?"] = not (false == options0["detect-cycles?"]), ["empty-as-square"] = options0["empty-as-square"], ["max-ids"] = {}, ["metamethod?"] = not (false == options0["metamethod?"]), ["table-edges"] = (options0["table-edges"] ~= false), appearances = count_table_appearances(x, {}), buffer = {}, depth = (options0.depth or 128), fennelview = _1_, ids = {}, indent = (options0.indent or _2_()), level = 0}
|
||||
put_value(inspector, x)
|
||||
local str = table.concat(inspector.buffer)
|
||||
if options0["one-line"] then
|
||||
return one_line(str)
|
||||
else
|
||||
return str
|
||||
end
|
||||
end
|
||||
return fennelview
|
||||
46
lib/stdio.fnl
Normal file
46
lib/stdio.fnl
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
(require "love.event")
|
||||
(local view (require "lib.fennelview"))
|
||||
|
||||
;; This module exists in order to expose stdio over a channel so that it
|
||||
;; can be used in a non-blocking way from another thread.
|
||||
|
||||
(local (event channel) ...)
|
||||
|
||||
(when channel
|
||||
(let [prompt (fn [] (io.write "> ") (io.flush) (io.read "*l"))]
|
||||
((fn looper [input]
|
||||
(when input
|
||||
;; This is consumed by love.handlers[event]
|
||||
(love.event.push event input)
|
||||
(let [output (: channel :demand)]
|
||||
;; There is probably a more efficient way of determining an error
|
||||
(if (and (. output 2) (= "Error:" (. output 2)))
|
||||
(print (view output))
|
||||
(each [_ ret (ipairs output)]
|
||||
(print ret))))
|
||||
(io.flush)
|
||||
(looper (prompt)))) (prompt))))
|
||||
|
||||
{:start (fn start-repl []
|
||||
|
||||
(let [code (love.filesystem.read "lib/stdio.fnl")
|
||||
luac (if code
|
||||
(love.filesystem.newFileData
|
||||
(fennel.compileString code) "io")
|
||||
(love.filesystem.read "lib/stdio.lua"))
|
||||
thread (love.thread.newThread luac)
|
||||
io-channel (love.thread.newChannel)
|
||||
coro (coroutine.create fennel.repl)
|
||||
out (fn [val]
|
||||
(: io-channel :push val))
|
||||
options {:readChunk coroutine.yield
|
||||
:onValues out
|
||||
:onError (fn [kind ...] (out [kind "Error:" ...]))
|
||||
:pp view
|
||||
:moduleName "lib.fennel"}]
|
||||
;; this thread will send "eval" events for us to consume:
|
||||
(coroutine.resume coro options)
|
||||
(: thread :start "eval" io-channel)
|
||||
(set love.handlers.eval
|
||||
(fn [input]
|
||||
(coroutine.resume coro (.. input "\n"))))))}
|
||||
109
machine.fnl
Normal file
109
machine.fnl
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
(local command (require "core.command"))
|
||||
(local spawn (require "spawn"))
|
||||
(local socket (require "socket"))
|
||||
(local json (require "dkjson"))
|
||||
|
||||
(local gsplus-path "/home/jeremy/src/gsplus/result/bin/GSplus")
|
||||
|
||||
(local debug-port 8769)
|
||||
(local reg-write-format {
|
||||
:ip "k%06X "
|
||||
:a "a%04X "
|
||||
:x "x%04X "
|
||||
:y "y%04X "
|
||||
:s "s%04X "
|
||||
:d "d%04X "
|
||||
:b "b%02X "
|
||||
:psr "p%06X "
|
||||
})
|
||||
(local machine
|
||||
{:boot
|
||||
(fn [self]
|
||||
(when (not self.pid)
|
||||
(set self.pid (spawn [:nixGL gsplus-path :-debugport (tostring debug-port)]))))
|
||||
:die
|
||||
(fn [self]
|
||||
(when self.pid
|
||||
(spawn [:kill (tostring self.pid)])
|
||||
(set self.pid nil)
|
||||
(when self.socket
|
||||
(self.socket:close)
|
||||
(set self.socket nil))))
|
||||
:connect
|
||||
(fn [self]
|
||||
(when (not self.socket)
|
||||
(set self.socket (socket.connect :localhost debug-port))
|
||||
(if self.socket
|
||||
(self.socket:settimeout 1)
|
||||
(love.timer.sleep 0.25))))
|
||||
:disconnect
|
||||
(fn [self]
|
||||
(when self.socket
|
||||
(self.socket:close)
|
||||
(set self.socket nil)))
|
||||
:cmd (fn [self cmd] (self.socket:send (.. cmd "\n")))
|
||||
:response
|
||||
(fn [self]
|
||||
(var bytes "")
|
||||
(var done false)
|
||||
(while (not done)
|
||||
(local (line err) (self.socket:receive))
|
||||
(set done (or (= line "") (= line nil)))
|
||||
(when line (set bytes (.. bytes line))))
|
||||
(json.decode bytes))
|
||||
:cmd-response (fn [self cmd] (self:cmd cmd) (self:response))
|
||||
:hello (fn [self] (self:cmd-response "1"))
|
||||
:continue (fn [self] (self:cmd-response "3"))
|
||||
:step (fn [self] (self:cmd-response "2"))
|
||||
:getreg (fn [self] (self:cmd-response "4"))
|
||||
:set-bp (fn [self addr] (self:cmd-response (.. "8" (string.format "%06X" addr))))
|
||||
:delete-bp (fn [self addr] (self:cmd-response (.. "9" (string.format "%06X" addr))))
|
||||
:get-bp (fn [self] (self:cmd-response "A"))
|
||||
:write
|
||||
(fn [self addr bytes]
|
||||
(self:cmd-response (.. "7" (string.format "%06X" addr) (bytes:tohex))))
|
||||
:setreg
|
||||
(fn [self regvals]
|
||||
(var bytes "5")
|
||||
(each [reg val (pairs regvals)]
|
||||
(set bytes (.. bytes (string.format (. reg-write-format reg) val))))
|
||||
(self:cmd-response bytes))
|
||||
:stop-at
|
||||
(fn [self addr k]
|
||||
(local fulladdr (bit.bor addr (bit.lshift (or k 0) 16)))
|
||||
(self:set-bp fulladdr)
|
||||
(var retries 5)
|
||||
(while (> retries 0)
|
||||
(local reg (. (self:getreg) 1 :data))
|
||||
(pp reg.PC.fromhex)
|
||||
(local pc (reg.PC:fromhex))
|
||||
(pp)
|
||||
(local curr-k (reg.K:fromhex))
|
||||
(print (curr-k:tohex) (pc:tohex))
|
||||
(if (and (= pc addr) (= curr-k (or k 0)))
|
||||
(set retries 0)
|
||||
(do (love.timer.sleep 1) (set retries (- retries 1)))))
|
||||
(self:delete-bp fulladdr))
|
||||
})
|
||||
|
||||
(command.add #(not machine.pid) {
|
||||
"gsplus:launch-gsplus" #(machine:boot)
|
||||
"gsplus:boot" (fn []
|
||||
(machine:boot)
|
||||
(while (not machine.socket) (pp (machine:connect)))
|
||||
(machine:hello)
|
||||
)
|
||||
})
|
||||
(command.add (fn [] machine.socket) {
|
||||
"gsplus:disconnect" #(machine:disconnect)
|
||||
"gsplus:hello" #(machine:hello)
|
||||
"gsplus:dump-cpu-state" #(pp (machine:getreg))
|
||||
"gsplus:step" #(pp (machine:step))
|
||||
"gsplus:continue" #(pp (machine:continue))
|
||||
})
|
||||
(command.add #(not machine.socket) {
|
||||
"gsplus:connect" #(machine:connect)
|
||||
})
|
||||
|
||||
machine
|
||||
|
||||
21
main.lua
Normal file
21
main.lua
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
-- bootstrap the compiler
|
||||
fennel = require("lib.fennel")
|
||||
table.insert(package.loaders, fennel.make_searcher({correlate=true}))
|
||||
fv = require("lib.fennelview")
|
||||
pp = function(x) print(fv(x)) end
|
||||
|
||||
function reload(modname)
|
||||
package.loaded[modname] = nil
|
||||
return require(modname)
|
||||
end
|
||||
|
||||
_coroutine_resume = coroutine.resume
|
||||
function coroutine.resume(...)
|
||||
local state,result = _coroutine_resume(...)
|
||||
if not state then
|
||||
error( tostring(result), 2 ) -- Output error message
|
||||
end
|
||||
return state,result
|
||||
end
|
||||
|
||||
require("wrap")
|
||||
41
spawn.lua
Normal file
41
spawn.lua
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
-- adapted from https://gist.github.com/iMega/f47f5a2ae1f02d7d5769a008538fd925
|
||||
|
||||
local ffi = require 'ffi'
|
||||
local C = ffi.C
|
||||
|
||||
ffi.cdef([[
|
||||
typedef int32_t pid_t;
|
||||
pid_t fork(void);
|
||||
int open(const char *pathname, int flags, int mode);
|
||||
int close(int fd);
|
||||
int dup2(int oldfd, int newfd);
|
||||
int execvp(const char *file, char *const argv[]);
|
||||
]])
|
||||
|
||||
local bor = bit.bor
|
||||
|
||||
local ffi_cast = ffi.cast
|
||||
local k_char_p_arr_t = ffi.typeof('const char * [?]')
|
||||
local char_p_k_p_t = ffi.typeof('char * const *')
|
||||
|
||||
local function spawn(args)
|
||||
if not args or #args == 0 then error("couldn't tokenize cmd_line") end
|
||||
|
||||
local pid = C.fork()
|
||||
if pid < 0 then
|
||||
error("fork failed " .. ffi.errno())
|
||||
elseif pid == 0 then -- child process
|
||||
local argv = k_char_p_arr_t(#args + 1) -- automatically NULL terminated
|
||||
for i = 1, #args do
|
||||
argv[i-1] = args[i] -- args is 1-based Lua table, argv is 0-based C array
|
||||
end
|
||||
|
||||
local res = C.execvp(args[1], ffi_cast(char_p_k_p_t, argv))
|
||||
if res == -1 then error("execvp failed with " .. ffi.errno()) end
|
||||
-- HERE SHOULD BE UNREACHABLE!!
|
||||
else
|
||||
return pid
|
||||
end
|
||||
end
|
||||
|
||||
return spawn
|
||||
163
stream.fnl
Normal file
163
stream.fnl
Normal file
|
|
@ -0,0 +1,163 @@
|
|||
(var make-stream nil)
|
||||
(fn stream [table]
|
||||
(make-stream
|
||||
{:table (or table [])
|
||||
:i 0
|
||||
:n (length table)
|
||||
:step 1
|
||||
:next
|
||||
(fn [self]
|
||||
(when (~= self.i self.n)
|
||||
(set self.i (+ self.i self.step))
|
||||
true))
|
||||
:curr (fn [self] (. self.table self.i))
|
||||
:reverse
|
||||
(fn [self]
|
||||
(local prev-i self.i)
|
||||
(set self.i (+ self.n self.step))
|
||||
(set self.n (+ prev-i self.step))
|
||||
(set self.step (* self.step -1))
|
||||
self)}))
|
||||
|
||||
(fn kvstream [table]
|
||||
(make-stream
|
||||
{:table (or table {})
|
||||
:curr-key nil
|
||||
:curr-val :start
|
||||
:curr (fn [self] (values self.curr-key self.curr-val))
|
||||
:keys (fn [self] (self:map (fn [k v] k)))
|
||||
:values (fn [self] (self:map (fn [k v] v)))
|
||||
:next
|
||||
(fn [self]
|
||||
(when self.curr-val
|
||||
(set (self.curr-key self.curr-val) (next self.table self.curr-key)))
|
||||
(~= self.curr-key nil))}))
|
||||
|
||||
(fn one [...]
|
||||
(make-stream
|
||||
{:vals [...]
|
||||
:advanced false
|
||||
:curr (fn [self] (unpack self.vals))
|
||||
:next
|
||||
(fn [self]
|
||||
(if self.advanced
|
||||
false
|
||||
(do
|
||||
(set self.advanced true)
|
||||
true)))}))
|
||||
|
||||
(fn iter [self]
|
||||
(values
|
||||
(fn [self _]
|
||||
(when (self:next)
|
||||
(self:curr)))
|
||||
self
|
||||
nil))
|
||||
|
||||
(fn first [self]
|
||||
(if (self:next) (self:curr) nil))
|
||||
|
||||
(fn map [stream f]
|
||||
(make-stream
|
||||
{: stream : f
|
||||
:curr (fn [self] (self.f (self.stream:curr)))
|
||||
:next (fn [self] (self.stream:next))
|
||||
:reverse
|
||||
(fn [self]
|
||||
(set self.stream (self.stream:reverse))
|
||||
self)}))
|
||||
|
||||
(fn filter [stream f]
|
||||
(make-stream
|
||||
{: stream : f :curr-val nil
|
||||
:curr (fn [self] self.curr-val)
|
||||
:next
|
||||
(fn [self]
|
||||
(set self.curr-val nil)
|
||||
(var has-more (self.stream:next))
|
||||
(while has-more
|
||||
(let [curr (self.stream:curr)
|
||||
include? (self.f curr)]
|
||||
(when include?
|
||||
(set self.curr-val curr))
|
||||
(set has-more (if include? false (self.stream:next)))))
|
||||
self.curr-val)}))
|
||||
|
||||
(fn reduce [stream f init]
|
||||
(var val init)
|
||||
(each [v (stream:iter)]
|
||||
(set val (f val v)))
|
||||
val)
|
||||
|
||||
(fn flatten [stream]
|
||||
(make-stream
|
||||
{: stream
|
||||
:curr-stream nil
|
||||
:curr (fn [self] (self.curr-stream:curr))
|
||||
:next
|
||||
(fn [self]
|
||||
(var reached-next
|
||||
(if self.curr-stream (self.curr-stream:next) false))
|
||||
(while (not reached-next)
|
||||
(set self.curr-stream
|
||||
(if (self.stream:next) (self.stream:curr) nil))
|
||||
(set reached-next
|
||||
(if self.curr-stream (self.curr-stream:next) true)))
|
||||
(~= self.curr-stream nil))}))
|
||||
|
||||
(fn concat [s ...]
|
||||
(: (stream [s ...]) :flatten))
|
||||
|
||||
(fn skip [stream n]
|
||||
(make-stream
|
||||
{: stream
|
||||
: n
|
||||
:curr (fn [self] (self.stream:curr))
|
||||
:next
|
||||
(fn [self]
|
||||
(for [_ 1 self.n]
|
||||
(self.stream:next))
|
||||
(set self.n 0)
|
||||
(self.stream:next))}))
|
||||
|
||||
(fn take [stream n]
|
||||
(make-stream
|
||||
{: stream
|
||||
: next
|
||||
:curr (fn [self] (self.stream:curr))
|
||||
:next
|
||||
(fn [self]
|
||||
(if (> self.n 0)
|
||||
(do
|
||||
(set self.n (- self.n 1))
|
||||
(self.stream:next))
|
||||
false))}))
|
||||
|
||||
(fn tolist [stream]
|
||||
(let [l []]
|
||||
(each [v (stream:iter)]
|
||||
(table.insert l v))
|
||||
l))
|
||||
|
||||
(fn tomap [stream]
|
||||
(let [m {}]
|
||||
(each [k v (stream:iter)]
|
||||
(tset m k v))
|
||||
m))
|
||||
|
||||
(set make-stream
|
||||
(fn [stream]
|
||||
(set stream.iter iter)
|
||||
(set stream.map map)
|
||||
(set stream.filter filter)
|
||||
(set stream.first first)
|
||||
(set stream.reduce reduce)
|
||||
(set stream.flatten flatten)
|
||||
(set stream.concat concat)
|
||||
(set stream.skip skip)
|
||||
(set stream.take take)
|
||||
(set stream.tolist tolist)
|
||||
(set stream.tomap tomap)
|
||||
stream))
|
||||
|
||||
{: stream : kvstream : one}
|
||||
14
test.fnl
Normal file
14
test.fnl
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
(local program (require "asm"))
|
||||
(local {: stream : kvstream : one} (require "stream"))
|
||||
|
||||
(local prg (program))
|
||||
|
||||
(prg:block :print-chars-forever 0x0c00
|
||||
:start
|
||||
[:dex]
|
||||
[:txa]
|
||||
[:jsr :0xfded]
|
||||
[:jmp :start])
|
||||
(prg:assemble)
|
||||
(set prg.start-symbol :print-chars-forever)
|
||||
prg
|
||||
9
util.fnl
Normal file
9
util.fnl
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
(fn table.clone [tbl]
|
||||
(let [newtbl {}]
|
||||
(each [k v (pairs tbl)]
|
||||
(tset newtbl k v))
|
||||
newtbl))
|
||||
(fn string.fromhex [str]
|
||||
(str:gsub ".." (fn [cc] (string.char (tonumber cc 16)))))
|
||||
(fn string.tohex [str]
|
||||
(str:gsub "." (fn [c] (string.format "%02X" (string.byte c)))))
|
||||
47
wrap.fnl
Normal file
47
wrap.fnl
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
(require "lite")
|
||||
(require "util")
|
||||
(local imgui (require "imgui"))
|
||||
(local machine (require "machine"))
|
||||
|
||||
(fn love.load []
|
||||
; (repl.start)
|
||||
)
|
||||
|
||||
(fn love.update [dt]
|
||||
(imgui.NewFrame))
|
||||
|
||||
(fn love.draw []
|
||||
(when machine.socket
|
||||
(when (imgui.Button "Stop on keypress")
|
||||
(machine:stop-at 0xfd1b))
|
||||
(when (imgui.Button "Upload")
|
||||
(local prg (reload "test"))
|
||||
(each [_ block (pairs prg.symbols)]
|
||||
(pp (machine:write block.addr block.bytes)))
|
||||
(pp (machine:setreg {:ip (. prg.symbols prg.start-symbol :addr)}))
|
||||
(pp (machine:continue))))
|
||||
(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))
|
||||
Loading…
Reference in a new issue