prime8dev

shell_lang.go (8226B)

---

 package tui
 
 import (
 	"path"
 	"strings"
 
 	"git.prime8.dev/moncheeta/prime8dev/internal/vfs"
 )
 
 // A small POSIX-ish command language for the about-page shell, the Go twin of
 // internal/web/scripts/modules/shell-lang.js: quoting, escapes, $VAR / ${VAR}
 // / $? expansion, ~, globs, pipes, redirects and ; && ||.
 
 var shellOps = []string{"2>&1", "2>>", "&&", "||", ">>", "2>", "|", ";", ">", "<", "&"}
 
 const varMark = "\x00"
 
 // shellWord is one argument. v is the literal value; pat is the same with
 // quoted glob characters backslash-escaped (path.Match syntax).
 type shellWord struct {
 	v, pat string
 	glob   bool
 	quoted bool
 }
 
 type shellToken struct {
 	op string
 	w  *shellWord
 }
 
 type shellRedir struct {
 	op     string
 	target shellWord
 }
 
 type shellSimple struct {
 	words  []shellWord
 	redirs []shellRedir
 }
 
 type shellListItem struct {
 	conn     string // operator joining this item to the previous one
 	pipeline []shellSimple
 }
 
 func isShellBreak(c byte) bool {
 	return c == ' ' || c == '\t' || c == ';' || c == '|' || c == '&' || c == '<' || c == '>'
 }
 
 func escGlob(s string) string {
 	var b strings.Builder
 	for _, r := range s {
 		if r == '\\' || r == '*' || r == '?' || r == '[' || r == ']' {
 			b.WriteByte('\\')
 		}
 		b.WriteRune(r)
 	}
 	return b.String()
 }
 
 func isVarStart(c byte) bool {
 	return c == '_' || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
 }
 
 func isVarChar(c byte) bool { return isVarStart(c) || (c >= '0' && c <= '9') }
 
 // readVar leaves a \0name\0 marker; variables expand per command so
 // `false; echo $?` sees the right status.
 func readVar(line string, i int) (string, int) {
 	if i+1 >= len(line) {
 		return "$", i + 1
 	}
 	nx := line[i+1]
 	switch {
 	case nx == '?' || nx == '$':
 		return varMark + string(nx) + varMark, i + 2
 	case nx == '{':
 		j := strings.IndexByte(line[i+2:], '}')
 		if j < 0 {
 			return "$", i + 1
 		}
 		return varMark + line[i+2:i+2+j] + varMark, i + 3 + j
 	case isVarStart(nx):
 		j := i + 1
 		for j < len(line) && isVarChar(line[j]) {
 			j++
 		}
 		return varMark + line[i+1:j] + varMark, j
 	}
 	return "$", i + 1
 }
 
 // shellTokenize splits a line into words and operators.
 func shellTokenize(line, home string) ([]shellToken, string) {
 	line = strings.ReplaceAll(line, varMark, "")
 	var toks []shellToken
 	n := len(line)
 	i := 0
 	for i < n {
 		c := line[i]
 		if c == ' ' || c == '\t' {
 			i++
 			continue
 		}
 		if c == '#' {
 			break
 		}
 		matched := ""
 		for _, op := range shellOps {
 			if strings.HasPrefix(line[i:], op) {
 				matched = op
 				break
 			}
 		}
 		if matched != "" {
 			toks = append(toks, shellToken{op: matched})
 			i += len(matched)
 			continue
 		}
 		var v, pat strings.Builder
 		glob, quoted := false, false
 		if c == '~' && (i+1 == n || line[i+1] == '/' || isShellBreak(line[i+1])) {
 			v.WriteString(home)
 			pat.WriteString(escGlob(home))
 			i++
 		}
 		for i < n {
 			ch := line[i]
 			if isShellBreak(ch) {
 				break
 			}
 			switch ch {
 			case '\\':
 				if i+1 < n {
 					v.WriteByte(line[i+1])
 					pat.WriteString(escGlob(line[i+1 : i+2]))
 				}
 				quoted = true
 				i += 2
 				continue
 			case '\'':
 				j := strings.IndexByte(line[i+1:], '\'')
 				if j < 0 {
 					return nil, "unexpected EOF while looking for matching `''"
 				}
 				s := line[i+1 : i+1+j]
 				v.WriteString(s)
 				pat.WriteString(escGlob(s))
 				quoted = true
 				i += j + 2
 				continue
 			case '"':
 				i++
 				var s strings.Builder
 				for i < n && line[i] != '"' {
 					if line[i] == '\\' && i+1 < n && strings.IndexByte("$\"\\`", line[i+1]) >= 0 {
 						s.WriteByte(line[i+1])
 						i += 2
 						continue
 					}
 					if line[i] == '$' {
 						r, j := readVar(line, i)
 						s.WriteString(r)
 						i = j
 						continue
 					}
 					s.WriteByte(line[i])
 					i++
 				}
 				if i >= n {
 					return nil, "unexpected EOF while looking for matching `\"'"
 				}
 				i++
 				v.WriteString(s.String())
 				pat.WriteString(escGlob(s.String()))
 				quoted = true
 				continue
 			case '$':
 				r, j := readVar(line, i)
 				v.WriteString(r)
 				pat.WriteString(escGlob(r))
 				i = j
 				continue
 			case '*', '?', '[':
 				glob = true
 			}
 			v.WriteByte(ch)
 			pat.WriteByte(ch)
 			i++
 		}
 		toks = append(toks, shellToken{w: &shellWord{v: v.String(), pat: pat.String(), glob: glob, quoted: quoted}})
 	}
 	return toks, ""
 }
 
 var shellRedirOps = map[string]bool{">": true, ">>": true, "<": true, "2>": true, "2>>": true}
 
 // shellParse groups tokens into ; && || separated pipelines.
 func shellParse(toks []shellToken) ([]shellListItem, string) {
 	var list []shellListItem
 	var pipeline []shellSimple
 	cmd := shellSimple{}
 	conn := ""
 	dangling := false
 	empty := func() bool { return len(cmd.words) == 0 && len(cmd.redirs) == 0 }
 	fail := func(tok string) string { return "syntax error near unexpected token `" + tok + "'" }
 
 	for k := 0; k < len(toks); k++ {
 		t := toks[k]
 		if t.w != nil {
 			cmd.words = append(cmd.words, *t.w)
 			dangling = false
 			continue
 		}
 		op := t.op
 		switch {
 		case shellRedirOps[op]:
 			if k+1 >= len(toks) {
 				return nil, fail("newline")
 			}
 			if toks[k+1].w == nil {
 				return nil, fail(toks[k+1].op)
 			}
 			cmd.redirs = append(cmd.redirs, shellRedir{op: op, target: *toks[k+1].w})
 			k++
 			dangling = false
 		case op == "2>&1":
 			cmd.redirs = append(cmd.redirs, shellRedir{op: op})
 		case op == "|":
 			if empty() {
 				return nil, fail("|")
 			}
 			pipeline = append(pipeline, cmd)
 			cmd = shellSimple{}
 			dangling = true
 		default: // ; & && ||
 			if empty() {
 				return nil, fail(op)
 			}
 			pipeline = append(pipeline, cmd)
 			list = append(list, shellListItem{conn: conn, pipeline: pipeline})
 			pipeline = nil
 			cmd = shellSimple{}
 			conn = op
 			if op == "&" {
 				conn = ";"
 			}
 			dangling = op == "&&" || op == "||"
 		}
 	}
 	if !empty() {
 		pipeline = append(pipeline, cmd)
 	}
 	if dangling {
 		return nil, "syntax error: unexpected end of file"
 	}
 	if len(pipeline) > 0 {
 		list = append(list, shellListItem{conn: conn, pipeline: pipeline})
 	}
 	return list, ""
 }
 
 // resolveVars substitutes the \0name\0 markers.
 func resolveVars(w shellWord, env func(string) string) shellWord {
 	if !strings.Contains(w.v, varMark) {
 		return w
 	}
 	sub := func(s string, esc bool) string {
 		parts := strings.Split(s, varMark)
 		var b strings.Builder
 		for i, p := range parts {
 			if i%2 == 0 {
 				b.WriteString(p)
 				continue
 			}
 			val := env(strings.ReplaceAll(p, "\\", ""))
 			if esc {
 				val = escGlob(val)
 			}
 			b.WriteString(val)
 		}
 		return b.String()
 	}
 	return shellWord{v: sub(w.v, false), pat: sub(w.pat, true), glob: w.glob, quoted: w.quoted}
 }
 
 func hasGlobMeta(seg string) bool {
 	for i := 0; i < len(seg); i++ {
 		switch seg[i] {
 		case '\\':
 			i++
 		case '*', '?', '[':
 			return true
 		}
 	}
 	return false
 }
 
 func unescapeGlob(seg string) string {
 	var b strings.Builder
 	for i := 0; i < len(seg); i++ {
 		if seg[i] == '\\' && i+1 < len(seg) {
 			i++
 		}
 		b.WriteByte(seg[i])
 	}
 	return b.String()
 }
 
 // expandGlob matches a word against the fs; no match keeps the word as is.
 func expandGlob(w shellWord, root *vfs.Node, home, cwd string) []string {
 	if !w.glob {
 		return []string{w.v}
 	}
 	absolute := strings.HasPrefix(w.pat, "/")
 	bases := []string{""}
 	if absolute {
 		bases = []string{"/"}
 	}
 	join := func(b, name string) string {
 		switch b {
 		case "":
 			return name
 		case "/":
 			return "/" + name
 		}
 		return b + "/" + name
 	}
 	for _, seg := range strings.Split(w.pat, "/") {
 		if seg == "" {
 			continue
 		}
 		var next []string
 		for _, b := range bases {
 			if !hasGlobMeta(seg) {
 				next = append(next, join(b, unescapeGlob(seg)))
 				continue
 			}
 			lookup := b
 			if lookup == "" {
 				lookup = "."
 			}
 			dir := root.Lookup(vfs.Resolve(home, cwd, lookup))
 			if dir == nil || !dir.Dir {
 				continue
 			}
 			for _, c := range dir.SortedChildren() {
 				if strings.HasPrefix(c.Name, ".") && !strings.HasPrefix(seg, ".") {
 					continue
 				}
 				if ok, err := path.Match(seg, c.Name); err == nil && ok {
 					next = append(next, join(b, c.Name))
 				}
 			}
 		}
 		bases = next
 	}
 	var found []string
 	for _, p := range bases {
 		if root.Lookup(vfs.Resolve(home, cwd, p)) != nil {
 			found = append(found, p)
 		}
 	}
 	if len(found) == 0 {
 		return []string{w.v}
 	}
 	return found
 }