package lua import ( "fmt" "io" "os" "runtime" "strconv" "strings" ) /* basic functions {{{ */ func OpenBase(L *LState) int { global := L.Get(GlobalsIndex).(*LTable) L.SetGlobal("_G", global) L.SetGlobal("_VERSION", LString(PackageName+" "+PackageVersion)) basemod := L.RegisterModule("_G", baseFuncs) global.RawSetString("ipairs", L.NewClosure(baseIpairs, L.NewFunction(ipairsaux))) global.RawSetString("pairs", L.NewClosure(basePairs, L.NewFunction(pairsaux))) L.Push(basemod) return 1 } var baseFuncs = map[string]LGFunction{ "assert": baseAssert, "collectgarbage": baseCollectGarbage, "dofile": baseDoFile, "error": baseError, "getfenv": baseGetFEnv, "getmetatable": baseGetMetatable, "load": baseLoad, "loadfile": baseLoadFile, "loadstring": baseLoadString, "next": baseNext, "pcall": basePCall, "print": basePrint, "rawequal": baseRawEqual, "rawget": baseRawGet, "rawset": baseRawSet, "select": baseSelect, "_printregs": base_PrintRegs, "setfenv": baseSetFEnv, "setmetatable": baseSetMetatable, "tonumber": baseToNumber, "tostring": baseToString, "type": baseType, "unpack": baseUnpack, "xpcall": baseXPCall, // loadlib "module": loModule, "require": loRequire, } func baseAssert(L *LState) int { if !L.ToBool(1) { L.RaiseError(L.OptString(2, "assertion failed!")) return 0 } return L.GetTop() } func baseCollectGarbage(L *LState) int { runtime.GC() return 0 } func baseDoFile(L *LState) int { src := L.ToString(1) top := L.GetTop() fn, err := L.LoadFile(src) if err != nil { L.Push(LString(err.Error())) L.Panic(L) } L.Push(fn) L.Call(0, MultRet) return L.GetTop() - top } func baseError(L *LState) int { obj := L.CheckAny(1) level := L.OptInt(2, 1) L.Error(obj, level) return 0 } func baseGetFEnv(L *LState) int { var value LValue if L.GetTop() == 0 { value = LNumber(1) } else { value = L.Get(1) } if fn, ok := value.(*LFunction); ok { if !fn.IsG { L.Push(fn.Env) } else { L.Push(L.G.Global) } return 1 } if number, ok := value.(LNumber); ok { level := int(float64(number)) if level <= 0 { L.Push(L.Env) } else { cf := L.currentFrame for i := 0; i < level && cf != nil; i++ { cf = cf.Parent } if cf == nil || cf.Fn.IsG { L.Push(L.G.Global) } else { L.Push(cf.Fn.Env) } } return 1 } L.Push(L.G.Global) return 1 } func baseGetMetatable(L *LState) int { L.Push(L.GetMetatable(L.CheckAny(1))) return 1 } func ipairsaux(L *LState) int { tb := L.CheckTable(1) i := L.CheckInt(2) i++ v := tb.RawGetInt(i) if v == LNil { return 0 } else { L.Pop(1) L.Push(LNumber(i)) L.Push(LNumber(i)) L.Push(v) return 2 } } func baseIpairs(L *LState) int { tb := L.CheckTable(1) L.Push(L.Get(UpvalueIndex(1))) L.Push(tb) L.Push(LNumber(0)) return 3 } func loadaux(L *LState, reader io.Reader, chunkname string) int { if fn, err := L.Load(reader, chunkname); err != nil { L.Push(LNil) L.Push(LString(err.Error())) return 2 } else { L.Push(fn) return 1 } } func baseLoad(L *LState) int { fn := L.CheckFunction(1) chunkname := L.OptString(2, "?") top := L.GetTop() buf := []string{} for { L.SetTop(top) L.Push(fn) L.Call(0, 1) ret := L.reg.Pop() if ret == LNil { break } else if LVCanConvToString(ret) { str := ret.String() if len(str) > 0 { buf = append(buf, string(str)) } else { break } } else { L.Push(LNil) L.Push(LString("reader function must return a string")) return 2 } } return loadaux(L, strings.NewReader(strings.Join(buf, "")), chunkname) } func baseLoadFile(L *LState) int { var reader io.Reader var chunkname string var err error if L.GetTop() < 1 { reader = os.Stdin chunkname = "<stdin>" } else { chunkname = L.CheckString(1) reader, err = os.Open(chunkname) if err != nil { L.Push(LNil) L.Push(LString(fmt.Sprintf("can not open file: %v", chunkname))) return 2 } defer reader.(*os.File).Close() } return loadaux(L, reader, chunkname) } func baseLoadString(L *LState) int { return loadaux(L, strings.NewReader(L.CheckString(1)), L.OptString(2, "<string>")) } func baseNext(L *LState) int { tb := L.CheckTable(1) index := LNil if L.GetTop() >= 2 { index = L.Get(2) } key, value := tb.Next(index) if key == LNil { L.Push(LNil) return 1 } L.Push(key) L.Push(value) return 2 } func pairsaux(L *LState) int { tb := L.CheckTable(1) key, value := tb.Next(L.Get(2)) if key == LNil { return 0 } else { L.Pop(1) L.Push(key) L.Push(key) L.Push(value) return 2 } } func basePairs(L *LState) int { tb := L.CheckTable(1) L.Push(L.Get(UpvalueIndex(1))) L.Push(tb) L.Push(LNil) return 3 } func basePCall(L *LState) int { L.CheckFunction(1) nargs := L.GetTop() - 1 if err := L.PCall(nargs, MultRet, nil); err != nil { L.Push(LFalse) if aerr, ok := err.(*ApiError); ok { L.Push(aerr.Object) } else { L.Push(LString(err.Error())) } return 2 } else { L.Insert(LTrue, 1) return L.GetTop() } } func basePrint(L *LState) int { top := L.GetTop() for i := 1; i <= top; i++ { fmt.Print(L.ToStringMeta(L.Get(i)).String()) if i != top { fmt.Print("\t") } } fmt.Println("") return 0 } func base_PrintRegs(L *LState) int { L.printReg() return 0 } func baseRawEqual(L *LState) int { if L.CheckAny(1) == L.CheckAny(2) { L.Push(LTrue) } else { L.Push(LFalse) } return 1 } func baseRawGet(L *LState) int { L.Push(L.RawGet(L.CheckTable(1), L.CheckAny(2))) return 1 } func baseRawSet(L *LState) int { L.RawSet(L.CheckTable(1), L.CheckAny(2), L.CheckAny(3)) return 0 } func baseSelect(L *LState) int { L.CheckTypes(1, LTNumber, LTString) switch lv := L.Get(1).(type) { case LNumber: idx := int(lv) num := L.reg.Top() - L.indexToReg(int(lv)) - 1 if idx < 0 { num++ } return num case LString: if string(lv) != "#" { L.ArgError(1, "invalid string '"+string(lv)+"'") } L.Push(LNumber(L.GetTop() - 1)) return 1 } return 0 } func baseSetFEnv(L *LState) int { var value LValue if L.GetTop() == 0 { value = LNumber(1) } else { value = L.Get(1) } env := L.CheckTable(2) if fn, ok := value.(*LFunction); ok { if fn.IsG { L.RaiseError("cannot change the environment of given object") } else { fn.Env = env L.Push(fn) return 1 } } if number, ok := value.(LNumber); ok { level := int(float64(number)) if level <= 0 { L.Env = env return 0 } cf := L.currentFrame for i := 0; i < level && cf != nil; i++ { cf = cf.Parent } if cf == nil || cf.Fn.IsG { L.RaiseError("cannot change the environment of given object") } else { cf.Fn.Env = env L.Push(cf.Fn) return 1 } } L.RaiseError("cannot change the environment of given object") return 0 } func baseSetMetatable(L *LState) int { L.CheckTypes(2, LTNil, LTTable) obj := L.Get(1) if obj == LNil { L.RaiseError("cannot set metatable to a nil object.") } mt := L.Get(2) if m := L.metatable(obj, true); m != LNil { if tb, ok := m.(*LTable); ok && tb.RawGetString("__metatable") != LNil { L.RaiseError("cannot change a protected metatable") } } L.SetMetatable(obj, mt) L.SetTop(1) return 1 } func baseToNumber(L *LState) int { base := L.OptInt(2, 10) noBase := L.Get(2) == LNil switch lv := L.CheckAny(1).(type) { case LNumber: L.Push(lv) case LString: str := strings.Trim(string(lv), " \n\t") if strings.Index(str, ".") > -1 { if v, err := strconv.ParseFloat(str, LNumberBit); err != nil { L.Push(LNil) } else { L.Push(LNumber(v)) } } else { if noBase && strings.HasPrefix(strings.ToLower(str), "0x") { base, str = 16, str[2:] // Hex number } if v, err := strconv.ParseInt(str, base, LNumberBit); err != nil { L.Push(LNil) } else { L.Push(LNumber(v)) } } default: L.Push(LNil) } return 1 } func baseToString(L *LState) int { v1 := L.CheckAny(1) L.Push(L.ToStringMeta(v1)) return 1 } func baseType(L *LState) int { L.Push(LString(L.CheckAny(1).Type().String())) return 1 } func baseUnpack(L *LState) int { tb := L.CheckTable(1) start := L.OptInt(2, 1) end := L.OptInt(3, tb.Len()) for i := start; i <= end; i++ { L.Push(tb.RawGetInt(i)) } ret := end - start + 1 if ret < 0 { return 0 } return ret } func baseXPCall(L *LState) int { fn := L.CheckFunction(1) errfunc := L.CheckFunction(2) top := L.GetTop() L.Push(fn) if err := L.PCall(0, MultRet, errfunc); err != nil { L.Push(LFalse) if aerr, ok := err.(*ApiError); ok { L.Push(aerr.Object) } else { L.Push(LString(err.Error())) } return 2 } else { L.Insert(LTrue, top+1) return L.GetTop() - top } } /* }}} */ /* load lib {{{ */ func loModule(L *LState) int { name := L.CheckString(1) loaded := L.GetField(L.Get(RegistryIndex), "_LOADED") tb := L.GetField(loaded, name) if _, ok := tb.(*LTable); !ok { tb = L.FindTable(L.Get(GlobalsIndex).(*LTable), name, 1) if tb == LNil { L.RaiseError("name conflict for module: %v", name) } L.SetField(loaded, name, tb) } if L.GetField(tb, "_NAME") == LNil { L.SetField(tb, "_M", tb) L.SetField(tb, "_NAME", LString(name)) names := strings.Split(name, ".") pname := "" if len(names) > 1 { pname = strings.Join(names[:len(names)-1], ".") + "." } L.SetField(tb, "_PACKAGE", LString(pname)) } caller := L.currentFrame.Parent if caller == nil { L.RaiseError("no calling stack.") } else if caller.Fn.IsG { L.RaiseError("module() can not be called from GFunctions.") } L.SetFEnv(caller.Fn, tb) top := L.GetTop() for i := 2; i <= top; i++ { L.Push(L.Get(i)) L.Push(tb) L.Call(1, 0) } L.Push(tb) return 1 } var loopdetection = &LUserData{} func loRequire(L *LState) int { name := L.CheckString(1) loaded := L.GetField(L.Get(RegistryIndex), "_LOADED") lv := L.GetField(loaded, name) if LVAsBool(lv) { if lv == loopdetection { L.RaiseError("loop or previous error loading module: %s", name) } L.Push(lv) return 1 } loaders, ok := L.GetField(L.Get(RegistryIndex), "_LOADERS").(*LTable) if !ok { L.RaiseError("package.loaders must be a table") } messages := []string{} var modasfunc LValue for i := 1; ; i++ { loader := L.RawGetInt(loaders, i) if loader == LNil { L.RaiseError("module %s not found:\n\t%s, ", name, strings.Join(messages, "\n\t")) } L.Push(loader) L.Push(LString(name)) L.Call(1, 1) ret := L.reg.Pop() switch retv := ret.(type) { case *LFunction: modasfunc = retv goto loopbreak case LString: messages = append(messages, string(retv)) } } loopbreak: L.SetField(loaded, name, loopdetection) L.Push(modasfunc) L.Push(LString(name)) L.Call(1, 1) ret := L.reg.Pop() modv := L.GetField(loaded, name) if ret != LNil && modv == loopdetection { L.SetField(loaded, name, ret) L.Push(ret) } else if modv == loopdetection { L.SetField(loaded, name, LTrue) L.Push(LTrue) } else { L.Push(modv) } return 1 } /* }}} */ //