121 lines
3.0 KiB
Go
121 lines
3.0 KiB
Go
package modules
|
|
|
|
import (
|
|
"embed"
|
|
"fmt"
|
|
"maps"
|
|
|
|
"Moonshark/modules/crypto"
|
|
"Moonshark/modules/fs"
|
|
"Moonshark/modules/json"
|
|
"Moonshark/modules/math"
|
|
lua_string "Moonshark/modules/string"
|
|
|
|
luajit "git.sharkk.net/Sky/LuaJIT-to-Go"
|
|
)
|
|
|
|
// Global registry instance
|
|
var Global *Registry
|
|
|
|
//go:embed crypto/*.lua fs/*.lua json/*.lua math/*.lua string/*.lua
|
|
var embeddedModules embed.FS
|
|
|
|
// Registry manages all Lua modules and Go functions
|
|
type Registry struct {
|
|
modules map[string]string
|
|
goFuncs map[string]luajit.GoFunction
|
|
}
|
|
|
|
// New creates a new registry with all modules loaded
|
|
func New() *Registry {
|
|
r := &Registry{
|
|
modules: make(map[string]string),
|
|
goFuncs: make(map[string]luajit.GoFunction),
|
|
}
|
|
|
|
// Load all Go functions
|
|
maps.Copy(r.goFuncs, json.GetFunctionList())
|
|
maps.Copy(r.goFuncs, lua_string.GetFunctionList())
|
|
maps.Copy(r.goFuncs, math.GetFunctionList())
|
|
maps.Copy(r.goFuncs, fs.GetFunctionList())
|
|
maps.Copy(r.goFuncs, crypto.GetFunctionList())
|
|
|
|
r.loadEmbeddedModules()
|
|
return r
|
|
}
|
|
|
|
// loadEmbeddedModules discovers and loads all .lua files
|
|
func (r *Registry) loadEmbeddedModules() {
|
|
// Discover all directories from embed
|
|
dirs, _ := embeddedModules.ReadDir(".")
|
|
|
|
for _, dir := range dirs {
|
|
if !dir.IsDir() {
|
|
continue
|
|
}
|
|
|
|
// Assume one module file per directory: dirname/dirname.lua
|
|
modulePath := fmt.Sprintf("%s/%s.lua", dir.Name(), dir.Name())
|
|
if source, err := embeddedModules.ReadFile(modulePath); err == nil {
|
|
r.modules[dir.Name()] = string(source)
|
|
}
|
|
}
|
|
}
|
|
|
|
// InstallInState sets up the complete module system in a Lua state
|
|
func (r *Registry) InstallInState(state *luajit.State) error {
|
|
// Create moonshark global table with Go functions
|
|
state.NewTable()
|
|
for name, fn := range r.goFuncs {
|
|
if err := state.PushGoFunction(fn); err != nil {
|
|
return fmt.Errorf("failed to register Go function '%s': %w", name, err)
|
|
}
|
|
state.SetField(-2, name)
|
|
}
|
|
state.SetGlobal("moonshark")
|
|
|
|
// Backup original require and install custom one
|
|
state.GetGlobal("require")
|
|
state.SetGlobal("_require_original")
|
|
|
|
return state.RegisterGoFunction("require", func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("require: %v", err)
|
|
}
|
|
|
|
moduleName, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("require: module name must be a string")
|
|
}
|
|
|
|
// Check built-in modules first
|
|
if source, exists := r.modules[moduleName]; exists {
|
|
if err := s.LoadString(source); err != nil {
|
|
return s.PushError("require: failed to load module '%s': %v", moduleName, err)
|
|
}
|
|
if err := s.Call(0, 1); err != nil {
|
|
return s.PushError("require: failed to execute module '%s': %v", moduleName, err)
|
|
}
|
|
return 1
|
|
}
|
|
|
|
// Fall back to original require
|
|
s.GetGlobal("_require_original")
|
|
if s.IsFunction(-1) {
|
|
s.PushString(moduleName)
|
|
if err := s.Call(1, 1); err != nil {
|
|
return s.PushError("require: %v", err)
|
|
}
|
|
return 1
|
|
}
|
|
|
|
return s.PushError("require: module '%s' not found", moduleName)
|
|
})
|
|
}
|
|
|
|
// Initialize sets up the global registry
|
|
func Initialize() error {
|
|
Global = New()
|
|
return nil
|
|
}
|