b55300b729
* Start on lua scripting * Implement evalsha, script load, script exists, and script flush * Type conversions from lua to resp/json. Refactor to make luastate and luascripts persistent in the controller. * Change controller.command and all underlying commands to return resp.Value. Serialize only during the ouput. * First stab at tile38 call from lua * Change tile38 into tile38.call in Lua * Property return errors from scripts * Minor refactoring. No locking on script run * Cleanup/refactoring * Create a pool of 5 lua states, allow for more as needed. Refactor. * Use safe map for scripts. Add a limit for max number of lua states. Refactor. * Refactor * Refactor script commands into atomic, read-only, and non-atomic classes. Proper locking for all three classes. Add tests for scripts * More tests for scripts * Properly escape newlines in lua-produced errors * Better test for readonly failure * Correctly convert ok/err messages between lua and resp. Add pcall, sha1hex, error_reply, status_reply functions to tile38 namespace in lua. * Add pcall test. Change writeErr to work with string argument * Make sure eval/evalsha never attempt to write AOF * Add eval-set and eval-get to benchmarks * Fix eval benchmark tests, add more * Improve benchmarks * Optimizations and refactoring. * Add lua memtest * Typo * Add dependency * golint fixes * gofmt fixes * Add scripting commands to the core/commands.json * Use ARGV for args inside lua
113 lines
1.9 KiB
Go
113 lines
1.9 KiB
Go
package lua
|
|
|
|
func OpenCoroutine(L *LState) int {
|
|
// TODO: Tie module name to contents of linit.go?
|
|
mod := L.RegisterModule(CoroutineLibName, coFuncs)
|
|
L.Push(mod)
|
|
return 1
|
|
}
|
|
|
|
var coFuncs = map[string]LGFunction{
|
|
"create": coCreate,
|
|
"yield": coYield,
|
|
"resume": coResume,
|
|
"running": coRunning,
|
|
"status": coStatus,
|
|
"wrap": coWrap,
|
|
}
|
|
|
|
func coCreate(L *LState) int {
|
|
fn := L.CheckFunction(1)
|
|
newthread, _ := L.NewThread()
|
|
base := 0
|
|
newthread.stack.Push(callFrame{
|
|
Fn: fn,
|
|
Pc: 0,
|
|
Base: base,
|
|
LocalBase: base + 1,
|
|
ReturnBase: base,
|
|
NArgs: 0,
|
|
NRet: MultRet,
|
|
Parent: nil,
|
|
TailCall: 0,
|
|
})
|
|
L.Push(newthread)
|
|
return 1
|
|
}
|
|
|
|
func coYield(L *LState) int {
|
|
return -1
|
|
}
|
|
|
|
func coResume(L *LState) int {
|
|
th := L.CheckThread(1)
|
|
if L.G.CurrentThread == th {
|
|
msg := "can not resume a running thread"
|
|
if th.wrapped {
|
|
L.RaiseError(msg)
|
|
return 0
|
|
}
|
|
L.Push(LFalse)
|
|
L.Push(LString(msg))
|
|
return 2
|
|
}
|
|
if th.Dead {
|
|
msg := "can not resume a dead thread"
|
|
if th.wrapped {
|
|
L.RaiseError(msg)
|
|
return 0
|
|
}
|
|
L.Push(LFalse)
|
|
L.Push(LString(msg))
|
|
return 2
|
|
}
|
|
th.Parent = L
|
|
L.G.CurrentThread = th
|
|
if !th.isStarted() {
|
|
cf := th.stack.Last()
|
|
th.currentFrame = cf
|
|
th.SetTop(0)
|
|
nargs := L.GetTop() - 1
|
|
L.XMoveTo(th, nargs)
|
|
cf.NArgs = nargs
|
|
th.initCallFrame(cf)
|
|
th.Panic = panicWithoutTraceback
|
|
} else {
|
|
nargs := L.GetTop() - 1
|
|
L.XMoveTo(th, nargs)
|
|
}
|
|
top := L.GetTop()
|
|
threadRun(th)
|
|
return L.GetTop() - top
|
|
}
|
|
|
|
func coRunning(L *LState) int {
|
|
if L.G.MainThread == L {
|
|
L.Push(LNil)
|
|
return 1
|
|
}
|
|
L.Push(L.G.CurrentThread)
|
|
return 1
|
|
}
|
|
|
|
func coStatus(L *LState) int {
|
|
L.Push(LString(L.Status(L.CheckThread(1))))
|
|
return 1
|
|
}
|
|
|
|
func wrapaux(L *LState) int {
|
|
L.Insert(L.ToThread(UpvalueIndex(1)), 1)
|
|
return coResume(L)
|
|
}
|
|
|
|
func coWrap(L *LState) int {
|
|
coCreate(L)
|
|
L.CheckThread(L.GetTop()).wrapped = true
|
|
v := L.Get(L.GetTop())
|
|
L.Pop(1)
|
|
L.Push(L.NewClosure(wrapaux, v))
|
|
return 1
|
|
}
|
|
|
|
//
|