package main import ( "regexp" "strconv" "strings" "sync" "hilbish/util" rt "github.com/arnodel/golua/runtime" ) var aliases *aliasModule type aliasModule struct { aliases map[string]string mu *sync.RWMutex } // initialize aliases map func newAliases() *aliasModule { return &aliasModule{ aliases: make(map[string]string), mu: &sync.RWMutex{}, } } func (a *aliasModule) Add(alias, cmd string) { a.mu.Lock() defer a.mu.Unlock() a.aliases[alias] = cmd } func (a *aliasModule) All() map[string]string { return a.aliases } func (a *aliasModule) Delete(alias string) { a.mu.Lock() defer a.mu.Unlock() delete(a.aliases, alias) } func (a *aliasModule) Resolve(cmdstr string) string { a.mu.RLock() defer a.mu.RUnlock() arg, _ := regexp.Compile(`[\\]?%\d+`) args, _ := splitInput(cmdstr) if len(args) == 0 { // this shouldnt reach but...???? return cmdstr } for a.aliases[args[0]] != "" { alias := a.aliases[args[0]] alias = arg.ReplaceAllStringFunc(alias, func(a string) string { idx, _ := strconv.Atoi(a[1:]) if strings.HasPrefix(a, "\\") || idx == 0 { return strings.TrimPrefix(a, "\\") } if idx + 1 > len(args) { return a } val := args[idx] args = cut(args, idx) cmdstr = strings.Join(args, " ") return val }) cmdstr = alias + strings.TrimPrefix(cmdstr, args[0]) cmdArgs, _ := splitInput(cmdstr) args = cmdArgs if a.aliases[args[0]] == alias { break } if a.aliases[args[0]] != "" { continue } } return cmdstr } // lua section // #interface aliases // command aliasing // The alias interface deals with all command aliases in Hilbish. func (a *aliasModule) Loader(rtm *rt.Runtime) *rt.Table { // create a lua module with our functions hshaliasesLua := map[string]util.LuaExport{ /* "add": util.LuaExport{hlalias, 2, false}, "list": util.LuaExport{a.luaList, 0, false}, "del": util.LuaExport{a.luaDelete, 1, false}, "resolve": util.LuaExport{a.luaResolve, 1, false}, */ } mod := rt.NewTable() util.SetExports(rtm, mod, hshaliasesLua) return mod } // #interface aliases // add(alias, cmd) // This is an alias (ha) for the [hilbish.alias](../#alias) function. // --- @param alias string // --- @param cmd string func _hlalias() {} // #interface aliases // list() -> table[string, string] // Get a table of all aliases, with string keys as the alias and the value as the command. // #returns table[string, string] /* #example hilbish.aliases.add('hi', 'echo hi') local aliases = hilbish.aliases.list() -- -> {hi = 'echo hi'} #example */ func (a *aliasModule) luaList(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) { aliasesList := rt.NewTable() for k, v := range a.All() { aliasesList.Set(rt.StringValue(k), rt.StringValue(v)) } return c.PushingNext1(t.Runtime, rt.TableValue(aliasesList)), nil } // #interface aliases // delete(name) // Removes an alias. // #param name string func (a *aliasModule) luaDelete(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) { if err := c.Check1Arg(); err != nil { return nil, err } alias, err := c.StringArg(0) if err != nil { return nil, err } a.Delete(alias) return c.Next(), nil } // #interface aliases // resolve(alias) -> string? // Resolves an alias to its original command. Will thrown an error if the alias doesn't exist. // #param alias string // #returns string func (a *aliasModule) luaResolve(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) { if err := c.Check1Arg(); err != nil { return nil, err } alias, err := c.StringArg(0) if err != nil { return nil, err } resolved := a.Resolve(alias) return c.PushingNext1(t.Runtime, rt.StringValue(resolved)), nil }