More fixes towards yuin#55, yuin#60.

New private type, luaLib, to contain name and load function, same
idea as Lua5.1's luaL_Reg: http://pgl.yoyo.org/luai/i/luaL_Reg

luaLibs is now private, is now a slice of luaLibs.

Each module register function now returns the module table.

luaLibs are now executed by pushing onto the stack, pushing
the module name, and calling with args 1 and returns 0.

Some comments removed by request.

Author: Cathal Garvey

baselib.go

@@ -11,15 +11,15 @@ import (
 
 /* basic functions {{{ */
 
-// OpenBase opens the base functions of Lua.
 func OpenBase(L *LState) int {
 	global := L.Get(GlobalsIndex).(*LTable)
 	L.SetGlobal("_G", global)
 	L.SetGlobal("_VERSION", LString(PackageName+" "+PackageVersion))
-	L.RegisterModule("_G", baseFuncs)
+	basemod := L.RegisterModule("_G", baseFuncs)
 	global.RawSetString("ipairs", L.NewClosure(baseIpairs, L.NewFunction(ipairsaux)))
 	global.RawSetString("pairs", L.NewClosure(basePairs, L.NewFunction(pairsaux)))
-	return 0
+	L.Push(basemod)
+	return 1
 }
 
 var baseFuncs = map[string]LGFunction{

channellib.go

@@ -17,16 +17,17 @@ func checkGoroutineSafe(L *LState, idx int) LValue {
 	return v
 }
 
-// OpenChannel opens the 'channel' library in Lua.
 func OpenChannel(L *LState) int {
+	var mod LValue
 	_, ok := L.G.builtinMts[int(LTChannel)]
 	if !ok {
-		L.RegisterModule("channel", channelFuncs)
+		mod = L.RegisterModule("channel", channelFuncs)
 		mt := L.SetFuncs(L.NewTable(), channelMethods)
 		mt.RawSetString("__index", mt)
 		L.G.builtinMts[int(LTChannel)] = mt
 	}
-	return 0
+	L.Push(mod)
+	return 1
 }
 
 var channelFuncs = map[string]LGFunction{

coroutinelib.go

@@ -1,10 +1,10 @@
 package lua
 
-// OpenCoroutine opens the 'coroutine' library in Lua.
 func OpenCoroutine(L *LState) int {
 	// TODO: Tie module name to contents of linit.go?
-	L.RegisterModule("coroutine", coFuncs)
-	return 0
+	mod := L.RegisterModule("coroutine", coFuncs)
+	L.Push(mod)
+	return 1
 }
 
 var coFuncs = map[string]LGFunction{

debuglib.go

@@ -4,10 +4,10 @@ import (
 	"fmt"
 )
 
-// OpenDebug opens the 'debug' library.
 func OpenDebug(L *LState) int {
-	L.RegisterModule("debug", debugFuncs)
-	return 0
+	dbgmod := L.RegisterModule("debug", debugFuncs)
+	L.Push(dbgmod)
+	return 1
 }
 
 var debugFuncs = map[string]LGFunction{

iolib.go

@@ -179,8 +179,6 @@ var stdFiles = []struct {
 	{"stderr", os.Stderr, true, false},
 }
 
-// OpenIo - New way to open IO, as per https://github.com/yuin/gopher-lua/issues/55
-// Satisfies LGFunction.
 func OpenIo(L *LState) int {
 	mod := L.RegisterModule("io", map[string]LGFunction{}).(*LTable)
 	mt := L.NewTypeMetatable(lFileClass)
@@ -200,7 +198,8 @@ func OpenIo(L *LState) int {
 	}
 	mod.RawSetString("lines", L.NewClosure(ioLines, uv, L.NewClosure(ioLinesIter, uv)))
 	// Modifications are being made in-place rather than returned?
-	return 0
+	L.Push(mod)
+	return 1
 }
 
 var fileMethods = map[string]LGFunction{

linit.go

@@ -1,8 +1,10 @@
 package lua
 
-import "fmt"
-
 const (
+	// BaseLibName is here for consistency; the base functions have no namespace/library.
+	BaseLibName = ""
+	// LoadLibName is here for consistency; the loading system has no namespace/library.
+	LoadLibName = "package"
 	// TabLibName is the name of the table Library.
 	TabLibName = "table"
 	// IoLibName is the name of the io Library.
@@ -19,40 +21,34 @@ const (
 	ChannelLibName = "channel"
 	// CoroutineLibName is the name of the coroutine Library.
 	CoroutineLibName = "coroutine"
-	// BaseLibName is here for consistency; the base functions have no namespace/library.
-	BaseLibName = "_baseLib"
-	// LoadLibName is here for consistency; the loading system has no namespace/library.
-	LoadLibName = "_loadLib"
 )
 
-// LuaLibs are the built-in Gopher-lua libraries as opened by LState.OpenLibs(),
-// including Base/Load.
-var LuaLibs = map[string]LGFunction{
-	TabLibName:       OpenTable,
-	IoLibName:        OpenIo,
-	OsLibName:        OpenOs,
-	StringLibName:    OpenString,
-	MathLibName:      OpenMath,
-	DebugLibName:     OpenDebug,
-	ChannelLibName:   OpenChannel,
-	CoroutineLibName: OpenCoroutine,
-	BaseLibName:      OpenBase,
-	LoadLibName:      OpenLoad,
+type luaLib struct {
+	libName string
+	libFunc LGFunction
+}
+
+var luaLibs = []luaLib{
+	luaLib{LoadLibName, OpenPackage},
+	luaLib{BaseLibName, OpenBase},
+	luaLib{TabLibName, OpenTable},
+	luaLib{IoLibName, OpenIo},
+	luaLib{OsLibName, OpenOs},
+	luaLib{StringLibName, OpenString},
+	luaLib{MathLibName, OpenMath},
+	luaLib{DebugLibName, OpenDebug},
+	luaLib{ChannelLibName, OpenChannel},
+	luaLib{CoroutineLibName, OpenCoroutine},
 }
 
 // OpenLibs loads the built-in libraries. It is equivalent to running OpenLoad,
 // then OpenBase, then iterating over the other OpenXXX functions in any order.
 func (ls *LState) OpenLibs() {
 	// NB: Map iteration order in Go is deliberately randomised, so must open Load/Base
 	// prior to iterating.
-	OpenLoad(ls)
-	OpenBase(ls)
-	for name, loader := range LuaLibs {
-		if name == BaseLibName || name == LoadLibName {
-			continue
-		}
-		ls.PreloadModule(name, loader)
-		// TODO: Are all built-ins normally "required"
-		ls.DoString(fmt.Sprintf(`%s = require "%s"`, name, name))
+	for _, lib := range luaLibs {
+		ls.Push(ls.NewFunction(lib.libFunc))
+		ls.Push(LString(lib.libName))
+		ls.Call(1, 0)
 	}
 }

loadlib.go

@@ -46,9 +46,7 @@ func loFindFile(L *LState, name, pname string) (string, string) {
 	return "", strings.Join(messages, "\n\t")
 }
 
-// OpenLoad opens the loading system of Lua; it is essential to load this before
-// other built-ins or third-party modules.
-func OpenLoad(L *LState) int {
+func OpenPackage(L *LState) int {
 	packagemod := L.RegisterModule("package", loFuncs)
 
 	L.SetField(packagemod, "preload", L.NewTable())
@@ -66,7 +64,9 @@ func OpenLoad(L *LState) int {
 
 	L.SetField(packagemod, "path", LString(loGetPath(LuaPath, LuaPathDefault)))
 	L.SetField(packagemod, "cpath", LString(""))
-	return 0
+
+	L.Push(packagemod)
+	return 1
 }
 
 var loFuncs = map[string]LGFunction{

mathlib.go

@@ -5,12 +5,12 @@ import (
 	"math/rand"
 )
 
-// OpenMath opens the 'math' library.
 func OpenMath(L *LState) int {
 	mod := L.RegisterModule("math", mathFuncs).(*LTable)
 	mod.RawSetString("pi", LNumber(math.Pi))
 	mod.RawSetString("huge", LNumber(math.MaxFloat64))
-	return 0
+	L.Push(mod)
+	return 1
 }
 
 var mathFuncs = map[string]LGFunction{

oslib.go

@@ -29,10 +29,10 @@ func getBoolField(L *LState, tb *LTable, key string, v bool) bool {
 	return v
 }
 
-// OpenOs opens the 'os' library in Lua.
 func OpenOs(L *LState) int {
-	L.RegisterModule("os", osFuncs)
-	return 0
+	osmod := L.RegisterModule("os", osFuncs)
+	L.Push(osmod)
+	return 1
 }
 
 var osFuncs = map[string]LGFunction{

stringlib.go

@@ -8,8 +8,8 @@ import (
 	"github.com/yuin/gopher-lua/pm"
 )
 
-// OpenString opens the 'string' library in Lua.
 func OpenString(L *LState) int {
+	var mod LValue
 	_, ok := L.G.builtinMts[int(LTString)]
 	if !ok {
 		mod := L.RegisterModule("string", strFuncs).(*LTable)
@@ -19,7 +19,8 @@ func OpenString(L *LState) int {
 		mod.RawSetString("__index", mod)
 		L.G.builtinMts[int(LTString)] = mod
 	}
-	return 0
+	L.Push(mod)
+	return 1
 }
 
 var strFuncs = map[string]LGFunction{

tablelib.go

@@ -4,10 +4,10 @@ import (
 	"sort"
 )
 
-// OpenTable opens the 'table' library.
 func OpenTable(L *LState) int {
-	L.RegisterModule("table", tableFuncs)
-	return 0
+	tabmod := L.RegisterModule("table", tableFuncs)
+	L.Push(tabmod)
+	return 1
 }
 
 var tableFuncs = map[string]LGFunction{