579 lines
13 KiB
Go
579 lines
13 KiB
Go
package functions
|
|
|
|
import (
|
|
"io"
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
luajit "git.sharkk.net/Sky/LuaJIT-to-Go"
|
|
)
|
|
|
|
func GetFSFunctions() map[string]luajit.GoFunction {
|
|
return map[string]luajit.GoFunction{
|
|
"file_exists": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("file_exists: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("file_exists: argument must be a string")
|
|
}
|
|
_, err = os.Stat(path)
|
|
s.PushBoolean(err == nil)
|
|
return 1
|
|
},
|
|
|
|
"file_size": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("file_size: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("file_size: argument must be a string")
|
|
}
|
|
info, err := os.Stat(path)
|
|
if err != nil {
|
|
s.PushNumber(-1)
|
|
return 1
|
|
}
|
|
s.PushNumber(float64(info.Size()))
|
|
return 1
|
|
},
|
|
|
|
"file_is_dir": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("file_is_dir: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("file_is_dir: argument must be a string")
|
|
}
|
|
info, err := os.Stat(path)
|
|
if err != nil {
|
|
s.PushBoolean(false)
|
|
return 1
|
|
}
|
|
s.PushBoolean(info.IsDir())
|
|
return 1
|
|
},
|
|
|
|
"file_read": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("file_read: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("file_read: argument must be a string")
|
|
}
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
s.PushNil()
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
s.PushString(string(data))
|
|
return 1
|
|
},
|
|
|
|
"file_write": func(s *luajit.State) int {
|
|
if err := s.CheckExactArgs(2); err != nil {
|
|
return s.PushError("file_write: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("file_write: first argument must be a string")
|
|
}
|
|
content, err := s.SafeToString(2)
|
|
if err != nil {
|
|
return s.PushError("file_write: second argument must be a string")
|
|
}
|
|
err = os.WriteFile(path, []byte(content), 0644)
|
|
if err != nil {
|
|
s.PushBoolean(false)
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
s.PushBoolean(true)
|
|
return 1
|
|
},
|
|
|
|
"file_append": func(s *luajit.State) int {
|
|
if err := s.CheckExactArgs(2); err != nil {
|
|
return s.PushError("file_append: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("file_append: first argument must be a string")
|
|
}
|
|
content, err := s.SafeToString(2)
|
|
if err != nil {
|
|
return s.PushError("file_append: second argument must be a string")
|
|
}
|
|
file, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
|
|
if err != nil {
|
|
s.PushBoolean(false)
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
defer file.Close()
|
|
_, err = file.WriteString(content)
|
|
if err != nil {
|
|
s.PushBoolean(false)
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
s.PushBoolean(true)
|
|
return 1
|
|
},
|
|
|
|
"file_copy": func(s *luajit.State) int {
|
|
if err := s.CheckExactArgs(2); err != nil {
|
|
return s.PushError("file_copy: %v", err)
|
|
}
|
|
src, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("file_copy: first argument must be a string")
|
|
}
|
|
dst, err := s.SafeToString(2)
|
|
if err != nil {
|
|
return s.PushError("file_copy: second argument must be a string")
|
|
}
|
|
|
|
srcFile, err := os.Open(src)
|
|
if err != nil {
|
|
s.PushBoolean(false)
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
defer srcFile.Close()
|
|
|
|
dstFile, err := os.Create(dst)
|
|
if err != nil {
|
|
s.PushBoolean(false)
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
defer dstFile.Close()
|
|
|
|
_, err = io.Copy(dstFile, srcFile)
|
|
if err != nil {
|
|
s.PushBoolean(false)
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
s.PushBoolean(true)
|
|
return 1
|
|
},
|
|
|
|
"file_move": func(s *luajit.State) int {
|
|
if err := s.CheckExactArgs(2); err != nil {
|
|
return s.PushError("file_move: %v", err)
|
|
}
|
|
src, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("file_move: first argument must be a string")
|
|
}
|
|
dst, err := s.SafeToString(2)
|
|
if err != nil {
|
|
return s.PushError("file_move: second argument must be a string")
|
|
}
|
|
err = os.Rename(src, dst)
|
|
if err != nil {
|
|
s.PushBoolean(false)
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
s.PushBoolean(true)
|
|
return 1
|
|
},
|
|
|
|
"file_delete": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("file_delete: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("file_delete: argument must be a string")
|
|
}
|
|
err = os.Remove(path)
|
|
if err != nil {
|
|
s.PushBoolean(false)
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
s.PushBoolean(true)
|
|
return 1
|
|
},
|
|
|
|
"file_mtime": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("file_mtime: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("file_mtime: argument must be a string")
|
|
}
|
|
info, err := os.Stat(path)
|
|
if err != nil {
|
|
s.PushNumber(-1)
|
|
return 1
|
|
}
|
|
s.PushNumber(float64(info.ModTime().Unix()))
|
|
return 1
|
|
},
|
|
|
|
"dir_create": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("dir_create: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("dir_create: argument must be a string")
|
|
}
|
|
err = os.MkdirAll(path, 0755)
|
|
if err != nil {
|
|
s.PushBoolean(false)
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
s.PushBoolean(true)
|
|
return 1
|
|
},
|
|
|
|
"dir_remove": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("dir_remove: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("dir_remove: argument must be a string")
|
|
}
|
|
err = os.RemoveAll(path)
|
|
if err != nil {
|
|
s.PushBoolean(false)
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
s.PushBoolean(true)
|
|
return 1
|
|
},
|
|
|
|
"dir_list": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("dir_list: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("dir_list: argument must be a string")
|
|
}
|
|
entries, err := os.ReadDir(path)
|
|
if err != nil {
|
|
s.PushNil()
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
|
|
s.CreateTable(len(entries), 0)
|
|
for i, entry := range entries {
|
|
s.PushNumber(float64(i + 1))
|
|
s.CreateTable(0, 4)
|
|
|
|
s.PushString("name")
|
|
s.PushString(entry.Name())
|
|
s.SetTable(-3)
|
|
|
|
s.PushString("is_dir")
|
|
s.PushBoolean(entry.IsDir())
|
|
s.SetTable(-3)
|
|
|
|
if info, err := entry.Info(); err == nil {
|
|
s.PushString("size")
|
|
s.PushNumber(float64(info.Size()))
|
|
s.SetTable(-3)
|
|
|
|
s.PushString("mtime")
|
|
s.PushNumber(float64(info.ModTime().Unix()))
|
|
s.SetTable(-3)
|
|
}
|
|
|
|
s.SetTable(-3)
|
|
}
|
|
return 1
|
|
},
|
|
|
|
"path_join": func(s *luajit.State) int {
|
|
var parts []string
|
|
for i := 1; i <= s.GetTop(); i++ {
|
|
part, err := s.SafeToString(i)
|
|
if err != nil {
|
|
return s.PushError("path_join: argument %d must be a string", i)
|
|
}
|
|
parts = append(parts, part)
|
|
}
|
|
s.PushString(filepath.Join(parts...))
|
|
return 1
|
|
},
|
|
|
|
"path_dir": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("path_dir: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("path_dir: argument must be a string")
|
|
}
|
|
s.PushString(filepath.Dir(path))
|
|
return 1
|
|
},
|
|
|
|
"path_basename": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("path_basename: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("path_basename: argument must be a string")
|
|
}
|
|
s.PushString(filepath.Base(path))
|
|
return 1
|
|
},
|
|
|
|
"path_ext": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("path_ext: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("path_ext: argument must be a string")
|
|
}
|
|
s.PushString(filepath.Ext(path))
|
|
return 1
|
|
},
|
|
|
|
"path_abs": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("path_abs: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("path_abs: argument must be a string")
|
|
}
|
|
abs, err := filepath.Abs(path)
|
|
if err != nil {
|
|
s.PushNil()
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
s.PushString(abs)
|
|
return 1
|
|
},
|
|
|
|
"path_clean": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("path_clean: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("path_clean: argument must be a string")
|
|
}
|
|
s.PushString(filepath.Clean(path))
|
|
return 1
|
|
},
|
|
|
|
"path_split": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("path_split: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("path_split: argument must be a string")
|
|
}
|
|
dir, file := filepath.Split(path)
|
|
s.PushString(dir)
|
|
s.PushString(file)
|
|
return 2
|
|
},
|
|
|
|
"temp_file": func(s *luajit.State) int {
|
|
var prefix string
|
|
if s.GetTop() >= 1 {
|
|
if p, err := s.SafeToString(1); err == nil {
|
|
prefix = p
|
|
}
|
|
}
|
|
|
|
file, err := os.CreateTemp("", prefix)
|
|
if err != nil {
|
|
s.PushNil()
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
defer file.Close()
|
|
|
|
s.PushString(file.Name())
|
|
return 1
|
|
},
|
|
|
|
"temp_dir": func(s *luajit.State) int {
|
|
var prefix string
|
|
if s.GetTop() >= 1 {
|
|
if p, err := s.SafeToString(1); err == nil {
|
|
prefix = p
|
|
}
|
|
}
|
|
|
|
dir, err := os.MkdirTemp("", prefix)
|
|
if err != nil {
|
|
s.PushNil()
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
|
|
s.PushString(dir)
|
|
return 1
|
|
},
|
|
|
|
"glob": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("glob: %v", err)
|
|
}
|
|
pattern, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("glob: argument must be a string")
|
|
}
|
|
|
|
matches, err := filepath.Glob(pattern)
|
|
if err != nil {
|
|
s.PushNil()
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
|
|
if err := s.PushValue(matches); err != nil {
|
|
return s.PushError("glob: failed to push result: %v", err)
|
|
}
|
|
return 1
|
|
},
|
|
|
|
"walk": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("walk: %v", err)
|
|
}
|
|
root, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("walk: argument must be a string")
|
|
}
|
|
|
|
var files []string
|
|
err = filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
|
|
if err != nil {
|
|
return nil // Skip errors
|
|
}
|
|
files = append(files, path)
|
|
return nil
|
|
})
|
|
|
|
if err != nil {
|
|
s.PushNil()
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
|
|
if err := s.PushValue(files); err != nil {
|
|
return s.PushError("walk: failed to push result: %v", err)
|
|
}
|
|
return 1
|
|
},
|
|
|
|
"getcwd": func(s *luajit.State) int {
|
|
cwd, err := os.Getwd()
|
|
if err != nil {
|
|
s.PushNil()
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
s.PushString(cwd)
|
|
return 1
|
|
},
|
|
|
|
"chdir": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("chdir: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("chdir: argument must be a string")
|
|
}
|
|
err = os.Chdir(path)
|
|
if err != nil {
|
|
s.PushBoolean(false)
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
s.PushBoolean(true)
|
|
return 1
|
|
},
|
|
|
|
"file_lines": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("file_lines: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("file_lines: argument must be a string")
|
|
}
|
|
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
s.PushNil()
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
|
|
lines := strings.Split(string(data), "\n")
|
|
// Remove empty last line if file ends with newline
|
|
if len(lines) > 0 && lines[len(lines)-1] == "" {
|
|
lines = lines[:len(lines)-1]
|
|
}
|
|
|
|
if err := s.PushValue(lines); err != nil {
|
|
return s.PushError("file_lines: failed to push result: %v", err)
|
|
}
|
|
return 1
|
|
},
|
|
|
|
"touch": func(s *luajit.State) int {
|
|
if err := s.CheckMinArgs(1); err != nil {
|
|
return s.PushError("touch: %v", err)
|
|
}
|
|
path, err := s.SafeToString(1)
|
|
if err != nil {
|
|
return s.PushError("touch: argument must be a string")
|
|
}
|
|
|
|
now := time.Now()
|
|
err = os.Chtimes(path, now, now)
|
|
if os.IsNotExist(err) {
|
|
// Create file if it doesn't exist
|
|
file, err := os.Create(path)
|
|
if err != nil {
|
|
s.PushBoolean(false)
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
file.Close()
|
|
} else if err != nil {
|
|
s.PushBoolean(false)
|
|
s.PushString(err.Error())
|
|
return 2
|
|
}
|
|
|
|
s.PushBoolean(true)
|
|
return 1
|
|
},
|
|
}
|
|
}
|