add startup files and the source builtin

- login shells (-l or argv[0] starting with -) read /etc/gosh/profile
  and ~/.gosh_profile, interactive shells /etc/gosh/goshrc and ~/.goshrc;
  --noprofile and --norc skip them
- source file / . file runs a file in the current shell, nesting is
  limited to stop files that source themselves
- errors in startup files and scripts are reported with file and line
- ~ and the startup files use $HOME (like sh), the user database is
  only the fallback

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

README.md

@@ -12,6 +12,7 @@ Built-in commands:
   quit [code]   - Quit shell with status code (default: $?)
   set VAR=val   - Set environment variable
   export VAR=val - Export environment variable
+  source file   - Run the commands of file in this shell (also: . file)
   help          - Show this help
 
 Features:
@@ -23,6 +24,9 @@ Features:
     override with $GOSH_HISTFILE); lines starting with a space are not saved
   - Tab completion for commands and file paths
   - Tilde expansion (~, ~/path) at the start of unquoted words
+  - Wildcards: * ? [abc] [a-z] [!abc] match file names (not hidden files
+    unless the pattern starts with a dot); quoted wildcards and values of
+    variables are not expanded, a pattern without match is kept as is
   - Colored prompt (user@host green, red for root; directory blue),
     configurable with $GOSH_COLORS, e.g. GOSH_COLORS='user=1;33:path=36'
     (keys user, root, path; values are ANSI SGR codes, empty = no color);
@@ -35,14 +39,17 @@ Features:
     2>> file, 2>&1, >&2, &> file (stdout and stderr), &>> file
   - Non-interactive use: gosh -c 'command', gosh script, command | gosh;
     the exit status is the one of the last command
+  - Startup files: login shells (-l or argv[0] starting with -) read
+    /etc/gosh/profile and ~/.gosh_profile, interactive shells read
+    /etc/gosh/goshrc and ~/.goshrc (skip with --noprofile, --norc)
 
 ```
 
 ### Aufruf
 
 ```
-gosh [-l] [-i] [script]
+gosh [-l] [-i] [--norc] [--noprofile] [script]
-gosh [-l] -c command
+gosh [-l] [--noprofile] -c command
 gosh -version
 ```
 
@@ -53,12 +60,50 @@ gosh -version
 | `gosh skript.gosh`     | führt das Skript Zeile für Zeile aus                             |
 | `befehle \| gosh`      | liest die Befehle von stdin                                      |
 | `-i`                   | erzwingt den interaktiven Modus, auch ohne Terminal              |
-| `-l`, `--login`        | Login-Shell (wird akzeptiert, eine Startdatei gibt es noch nicht) |
+| `-l`, `--login`        | Login-Shell, liest die Profil-Dateien (siehe unten)              |
+| `--norc`               | `goshrc`-Dateien nicht lesen                                     |
+| `--noprofile`          | `profile`-Dateien nicht lesen                                    |
 
 Ohne Terminal bricht gosh bei einem fehlgeschlagenen Befehl nicht ab und beendet sich mit dem Exit-Status des letzten Befehls: `127`, wenn ein Befehl nicht gefunden wurde, `126`, wenn er nicht ausführbar ist, `128+n`, wenn er durch Signal `n` beendet wurde. Leere Zeilen und Zeilen, die mit `#` beginnen, werden übersprungen, Skripte können also mit `#!/usr/bin/gosh` beginnen.
 
 Damit funktionieren auch `ssh host befehl`, `scp` und `rsync`, wenn gosh als Login-Shell gesetzt ist. Befehle lassen sich mit `;`, `&&` und `||` verketten und mit Pipes verbinden, z. B. `ssh host 'cd /srv && git log | head'`.
 
+### Startdateien
+
+Beim Start liest gosh Startdateien und führt sie wie ein Skript in der laufenden Shell aus (Variablen, die dort gesetzt werden, bleiben also erhalten):
+
+| Shell                         | Dateien (in dieser Reihenfolge)              | abschalten mit  |
+|-------------------------------|----------------------------------------------|-----------------|
+| Login-Shell                   | `/etc/gosh/profile`, `~/.gosh_profile`       | `--noprofile`   |
+| interaktive Shell             | `/etc/gosh/goshrc`, `~/.goshrc`              | `--norc`        |
+
+- Eine Login-Shell ist gosh mit `-l` oder wenn `argv[0]` mit `-` beginnt (so starten `login`, `sshd` und `su -` die Shell). Eine interaktive Login-Shell liest erst die Profil-, dann die `goshrc`-Dateien.
+- `gosh -c '…'` und Skripte lesen keine Startdateien, außer als Login-Shell (`gosh -l -c '…'`).
+- Fehlende Dateien werden übersprungen. Fehler werden mit Datei und Zeile gemeldet (`gosh: ~/.goshrc:4: foo: command not found`), die übrigen Zeilen laufen trotzdem.
+- Bash-Dateien wie `/etc/profile` oder `~/.bashrc` liest gosh bewusst nicht, weil es deren Syntax (`if`, Funktionen, …) nicht versteht.
+- Mit `source datei` (oder `. datei`) lässt sich eine Datei auch später einlesen, z. B. nach einer Änderung: `source ~/.goshrc`.
+
+Beispiel für `~/.goshrc`:
+
+```bash
+# Eigene Programme zuerst
+export PATH=$HOME/bin:$HOME/go/bin:$PATH
+export EDITOR=vim
+
+# Prompt-Farben (Anführungszeichen wegen des ;)
+export GOSH_COLORS='user=1;38;5;208:path=38;5;205'
+
+# Weitere Einstellungen nur, wenn die Datei existiert
+test -f ~/.goshrc.local && source ~/.goshrc.local
+```
+
+Beispiel für `~/.gosh_profile` (wird nur von Login-Shells gelesen, z. B. beim Anmelden an der Konsole oder per `ssh host` ohne Befehl):
+
+```bash
+export LANG=de_DE.UTF-8
+export PATH=$HOME/bin:$PATH
+```
+
 ### Befehlslisten und Exit-Status
 
 Mehrere Befehle in einer Zeile werden wie in `sh` verknüpft:
@@ -83,6 +128,32 @@ Status 127
 
 Schlägt ein Programm fehl, gibt gosh selbst keine Meldung mehr aus (das Programm meldet den Fehler selbst), nur bei Fehlern von gosh, z. B. wenn ein Befehl nicht gefunden wird.
 
+### Wildcards
+
+Wörter mit `*`, `?` oder `[...]` werden durch die passenden Dateinamen ersetzt, sortiert:
+
+| Muster    | passt auf                                           |
+|-----------|-----------------------------------------------------|
+| `*`       | beliebig viele Zeichen (auch keine)                 |
+| `?`       | genau ein Zeichen                                   |
+| `[abc]`   | eines der Zeichen `a`, `b`, `c`                     |
+| `[a-z]`   | ein Zeichen aus dem Bereich                         |
+| `[!abc]`  | ein Zeichen außer `a`, `b`, `c` (auch `[^abc]`)     |
+
+```
+$ ls *.go
+main.go  main_test.go
+$ cat logs/2026-*/error.log
+$ ls -d */            # nur Verzeichnisse
+```
+
+- Muster gelten pro Pfadteil, `*` passt nie auf `/`: `*/*.go` findet `.go`-Dateien eine Ebene tiefer.
+- Versteckte Dateien (mit `.` am Anfang) werden nur gefunden, wenn das Muster selbst mit `.` beginnt: `*` findet `.bashrc` nicht, `.*rc` schon.
+- Passt keine Datei, bleibt das Wort unverändert stehen (wie in `sh`), `ls *.xyz` meldet dann also `ls` den Fehler.
+- In Anführungszeichen oder mit `\` davor sind die Zeichen normale Zeichen: `echo "*"`, `echo '*.go'`, `echo \*`.
+- Werte von Variablen werden nicht als Muster behandelt (anders als in `sh`): Nach `set P=*.go` gibt `echo $P` wörtlich `*.go` aus. So kann ein Variablenwert nie unbemerkt auf viele Dateien passen. `echo $DIR/*.go` funktioniert dagegen, weil das `*` direkt in der Zeile steht.
+- Bei einer Umleitung muss das Muster genau eine Datei treffen (`> *.log`), sonst meldet gosh `ambiguous redirect`.
+
 ### Pipes und Umleitungen
 
 ```

main.go

@@ -12,6 +12,7 @@ import (
 	"os/user"
 	"path/filepath"
 	"runtime/debug"
+	"sort"
 	"strconv"
 	"strings"
 	"syscall"
@@ -73,12 +74,15 @@ func versionInfo() string {
 // previousDir tracks the previous working directory for 'cd -' support
 var previousDir string
 
-// getHomeDir returns the user's home directory
+// getHomeDir returns the user's home directory: $HOME like in sh, or the
+// home directory from the user database if $HOME is not set
 func getHomeDir() string {
+	if home := os.Getenv("HOME"); home != "" {
+		return home
+	}
 	usr, err := user.Current()
 	if err != nil {
-		// Fallback to HOME environment variable
+		return ""
-		return os.Getenv("HOME")
 	}
 	return usr.HomeDir
 }
@@ -115,6 +119,8 @@ func expandTilde(path string) string {
 type token struct {
 	op      string // "" for a word, otherwise |, <, >, >>, >&, <&, &> or &>>
 	word    string // the word, if op == ""
+	pattern string // the word as glob pattern (quoted characters escaped)
+	glob    bool   // the word contains unquoted * ? or [ and is expanded
 	fd      int    // the redirected file descriptor (for redirections)
 	dup     int    // the target file descriptor of >& and <&
 }
@@ -136,6 +142,8 @@ func tokenize(input string) ([]token, error) {
 	var (
 		tokens   []token
 		b        strings.Builder
+		pat      strings.Builder // the word as glob pattern, quoted parts escaped
+		glob     bool            // the word contains unquoted * ? or [
 		inWord   bool            // a word has been started (even if it is still empty)
 		quote    byte
 		escaped  bool
@@ -144,12 +152,19 @@ func tokenize(input string) ([]token, error) {
 
 	endWord := func() {
 		if inWord {
-			tokens = append(tokens, token{word: b.String()})
+			tokens = append(tokens, token{word: b.String(), pattern: pat.String(), glob: glob})
 		}
 		b.Reset()
+		pat.Reset()
+		glob = false
 		inWord = false
 		rawStart = -1
 	}
+	// literal adds quoted, escaped or expanded text: it is never a pattern
+	literal := func(s string) {
+		b.WriteString(s)
+		pat.WriteString(escapeGlob(s))
+	}
 	startRaw := func(i int) {
 		if rawStart < 0 {
 			rawStart = i
@@ -161,16 +176,16 @@ func tokenize(input string) ([]token, error) {
 		switch {
 		case escaped:
 			if quote == '"' && !strings.ContainsRune("$\"\\`", rune(ch)) {
-				b.WriteByte('\\')
+				literal("\\")
 			}
-			b.WriteByte(ch)
+			literal(string(ch))
 			inWord = true
 			escaped = false
 		case quote == '\'':
 			if ch == '\'' {
 				quote = 0
 			} else {
-				b.WriteByte(ch)
+				literal(string(ch))
 			}
 		case ch == '\\':
 			startRaw(i)
@@ -181,7 +196,9 @@ func tokenize(input string) ([]token, error) {
 			if err != nil {
 				return nil, err
 			}
-			b.WriteString(value)
+			// Expanded values are never patterns (and never split), so that
+			// e.g. a * in a variable does not match files
+			literal(value)
 			// A literal "$" counts as content, an expansion that is empty does
 			// not (unless quoted), like in sh
 			if n == 1 || value != "" {
@@ -192,7 +209,7 @@ func tokenize(input string) ([]token, error) {
 			if ch == '"' {
 				quote = 0
 			} else {
-				b.WriteByte(ch)
+				literal(string(ch))
 			}
 		case ch == '"' || ch == '\'':
 			startRaw(i)
@@ -225,6 +242,8 @@ func tokenize(input string) ([]token, error) {
 			if inWord && rawStart >= 0 && isDigits(input[rawStart:i]) {
 				fd, _ = strconv.Atoi(input[rawStart:i])
 				b.Reset()
+				pat.Reset()
+				glob = false
 				inWord = false
 				rawStart = -1
 			} else {
@@ -256,11 +275,21 @@ func tokenize(input string) ([]token, error) {
 			if home == "" {
 				home = "~"
 			}
-			b.WriteString(home)
+			literal(home)
 			inWord = true
 		default:
 			startRaw(i)
 			b.WriteByte(ch)
+			switch {
+			case ch == '*' || ch == '?' || ch == '[':
+				glob = true
+				pat.WriteByte(ch)
+			case ch == '!' && strings.HasSuffix(pat.String(), "[") && !strings.HasSuffix(pat.String(), "\\["):
+				// POSIX [!...] is [^...] in Go
+				pat.WriteByte('^')
+			default:
+				pat.WriteByte(ch)
+			}
 			inWord = true
 		}
 	}
@@ -275,6 +304,123 @@ func tokenize(input string) ([]token, error) {
 	return tokens, nil
 }
 
+// escapeGlob escapes the characters that are special in a glob pattern.
+func escapeGlob(s string) string {
+	var b strings.Builder
+	for i := 0; i < len(s); i++ {
+		if strings.IndexByte("*?[]\\", s[i]) >= 0 {
+			b.WriteByte('\\')
+		}
+		b.WriteByte(s[i])
+	}
+	return b.String()
+}
+
+// hasGlobMeta reports whether pattern contains an unescaped * ? or [.
+func hasGlobMeta(pattern string) bool {
+	for i := 0; i < len(pattern); i++ {
+		switch pattern[i] {
+		case '\\':
+			i++
+		case '*', '?', '[':
+			return true
+		}
+	}
+	return false
+}
+
+// unescapeGlob removes the escapes from a pattern without wildcards.
+func unescapeGlob(pattern string) string {
+	var b strings.Builder
+	for i := 0; i < len(pattern); i++ {
+		if pattern[i] == '\\' && i+1 < len(pattern) {
+			i++
+		}
+		b.WriteByte(pattern[i])
+	}
+	return b.String()
+}
+
+// expandGlob returns the paths matching pattern, sorted. Like sh, * and ?
+// do not match a leading dot (hidden files), unless the pattern component
+// starts with a dot, and a trailing / only matches directories. An invalid
+// pattern matches nothing.
+func expandGlob(pattern string) []string {
+	paths := []string{""}
+	if strings.HasPrefix(pattern, "/") {
+		paths = []string{"/"}
+	}
+	components := strings.Split(strings.Trim(pattern, "/"), "/")
+	join := func(dir, name string) string {
+		if dir == "" || strings.HasSuffix(dir, "/") {
+			return dir + name
+		}
+		return dir + "/" + name
+	}
+
+	for _, comp := range components {
+		if comp == "" {
+			continue // a//b
+		}
+		var next []string
+		for _, dir := range paths {
+			if !hasGlobMeta(comp) {
+				p := join(dir, unescapeGlob(comp))
+				if _, err := os.Lstat(p); err == nil {
+					next = append(next, p)
+				}
+				continue
+			}
+			readDir := dir
+			if readDir == "" {
+				readDir = "."
+			}
+			entries, err := os.ReadDir(readDir)
+			if err != nil {
+				continue
+			}
+			for _, e := range entries {
+				name := e.Name()
+				if strings.HasPrefix(name, ".") && !strings.HasPrefix(comp, ".") && !strings.HasPrefix(comp, "\\.") {
+					continue
+				}
+				ok, err := filepath.Match(comp, name)
+				if err != nil {
+					return nil
+				}
+				if ok {
+					next = append(next, join(dir, name))
+				}
+			}
+		}
+		paths = next
+	}
+
+	if strings.HasSuffix(pattern, "/") {
+		var dirs []string
+		for _, p := range paths {
+			if info, err := os.Stat(p); err == nil && info.IsDir() {
+				dirs = append(dirs, p+"/")
+			}
+		}
+		paths = dirs
+	}
+	sort.Strings(paths)
+	return paths
+}
+
+// expandWord returns the words a token expands to: the matching paths for
+// a pattern, or the word itself if it is no pattern or nothing matches (like
+// in sh).
+func expandWord(t token) []string {
+	if t.glob {
+		if matches := expandGlob(t.pattern); len(matches) > 0 {
+			return matches
+		}
+	}
+	return []string{t.word}
+}
+
 // isDigits reports whether s is a non-empty string of ASCII digits.
 func isDigits(s string) bool {
 	if s == "" {
@@ -556,7 +702,7 @@ type shellCompleter struct {
 
 func newShellCompleter() *shellCompleter {
 	return &shellCompleter{
-		commands: []string{"cd", "pwd", "echo", "exit", "quit", "set", "export", "help"},
+		commands: []string{"cd", "pwd", "echo", "exit", "quit", "set", "export", "source", "help"},
 	}
 }
 
@@ -668,7 +814,7 @@ func currentWord(s string) (word string, start int, quote byte) {
 func escapeWord(s string) string {
 	var b strings.Builder
 	for _, r := range s {
-		if strings.ContainsRune(" \t\\'\";|&<>", r) {
+		if strings.ContainsRune(" \t\\'\";|&<>*?[$", r) {
 			b.WriteByte('\\')
 		}
 		b.WriteRune(r)
@@ -723,33 +869,48 @@ func completeFilePath(line, prefix string) []string {
 	return matches
 }
 
-const usage = `usage: gosh [-l] [-i] [script]
+const usage = `usage: gosh [-l] [-i] [--norc] [--noprofile] [script]
-       gosh [-l] -c command
+       gosh [-l] [--noprofile] -c command
        gosh -version`
 
+// sysConfDir holds the system-wide startup files.
+var sysConfDir = "/etc/gosh"
+
 func main() {
-	os.Exit(run(os.Args[1:]))
+	args := os.Args[1:]
+	// login(1), sshd and "su -" start a login shell with a leading - in
+	// argv[0], e.g. "-gosh"
+	if strings.HasPrefix(os.Args[0], "-") {
+		args = append([]string{"-l"}, args...)
+	}
+	os.Exit(run(args))
 }
 
 // run parses the command line and runs gosh in the matching mode. It returns
 // the exit status of the shell.
 func run(args []string) int {
-	// -l/--login is accepted for compatibility (e.g. "su -l", login(1)), but
+	var login, forceInteractive, noRC, noProfile bool
-	// gosh does not read a startup file yet. -i forces interactive mode even
-	// if stdin is not a terminal.
-	forceInteractive := false
 flags:
 	for len(args) > 0 {
 		switch args[0] {
 		case "-l", "--login":
+			login = true
 		case "-i":
+			// Interactive mode even if stdin is not a terminal
 			forceInteractive = true
+		case "--norc":
+			noRC = true
+		case "--noprofile":
+			noProfile = true
 		default:
 			break flags
 		}
 		args = args[1:]
 	}
 
+	// Determine what to run, before the startup files are read
+	var script func() int
+	interactiveMode := false
 	if len(args) > 0 {
 		switch arg := args[0]; {
 		case arg == "-version" || arg == "--version" || arg == "-V":
@@ -766,13 +927,13 @@ flags:
 				fmt.Fprintln(os.Stderr, usage)
 				return 2
 			}
-			return runScript(strings.NewReader(args[1]))
+			script = func() int { return runScript(strings.NewReader(args[1]), "") }
 		case strings.HasPrefix(arg, "-") && arg != "-":
 			fmt.Fprintf(os.Stderr, "gosh: %s: invalid option\n", arg)
 			fmt.Fprintln(os.Stderr, usage)
 			return 2
 		case arg == "-":
-			return runScript(os.Stdin)
+			script = func() int { return runScript(os.Stdin, "") }
 		default:
 			f, err := os.Open(arg)
 			if err != nil {
@@ -780,30 +941,107 @@ flags:
 				return 127
 			}
 			defer f.Close()
-			return runScript(bufio.NewReader(f))
+			script = func() int { return runScript(bufio.NewReader(f), arg) }
 		}
+	} else if forceInteractive || readline.IsTerminal(int(os.Stdin.Fd())) {
+		interactiveMode = true
+	} else {
+		// Without a terminal (e.g. "echo ls | gosh") read the commands from
+		// stdin
+		script = func() int { return runScript(os.Stdin, "") }
 	}
 
-	// Without a terminal (e.g. "echo ls | gosh") read the commands from stdin.
+	for _, file := range startupFiles(login && !noProfile, interactiveMode && !noRC) {
-	if !forceInteractive && !readline.IsTerminal(int(os.Stdin.Fd())) {
+		sourceStartupFile(file)
-		return runScript(os.Stdin)
 	}
 
+	if !interactiveMode {
+		return script()
+	}
 	interactive()
 	return 0
 }
 
+// startupFiles returns the startup files to read, in order: for login
+// shells /etc/gosh/profile and ~/.gosh_profile, for interactive shells
+// /etc/gosh/goshrc and ~/.goshrc. Non-interactive shells (gosh -c, scripts)
+// read no files unless they are login shells.
+func startupFiles(login, interactive bool) []string {
+	home := getHomeDir()
+	var files []string
+	if login {
+		files = append(files, filepath.Join(sysConfDir, "profile"))
+		if home != "" {
+			files = append(files, filepath.Join(home, ".gosh_profile"))
+		}
+	}
+	if interactive {
+		files = append(files, filepath.Join(sysConfDir, "goshrc"))
+		if home != "" {
+			files = append(files, filepath.Join(home, ".goshrc"))
+		}
+	}
+	return files
+}
+
+// sourceStartupFile runs a startup file in the current shell. A missing file
+// is skipped silently, other errors are reported.
+func sourceStartupFile(path string) {
+	f, err := os.Open(path)
+	if errors.Is(err, fs.ErrNotExist) {
+		return
+	}
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "gosh:", err)
+		return
+	}
+	defer f.Close()
+	runScript(bufio.NewReader(f), path)
+}
+
+// sourceDepth counts nested source commands, to stop a file that sources
+// itself.
+var sourceDepth int
+
+// sourceFile runs the commands of a file in the current shell (the source and
+// . builtins) and returns an error carrying the status of the last command.
+func sourceFile(cmd, path string) error {
+	if sourceDepth >= 100 {
+		return fmt.Errorf("%s: %s: maximum nesting depth exceeded", cmd, sanitize(path))
+	}
+	f, err := os.Open(path)
+	if err != nil {
+		var pathErr *fs.PathError
+		if errors.As(err, &pathErr) {
+			err = pathErr.Err
+		}
+		return fmt.Errorf("%s: %s: %v", cmd, sanitize(path), err)
+	}
+	defer f.Close()
+
+	sourceDepth++
+	defer func() { sourceDepth-- }()
+	if status := runScript(bufio.NewReader(f), path); status != 0 {
+		return statusError(status)
+	}
+	return nil
+}
+
 // runScript executes the commands from r line by line. Like sh, it does not
 // stop at a failing command and returns the exit status of the last one.
 // Empty lines and lines starting with # (e.g. a #!/usr/bin/gosh line) are
-// skipped.
+// skipped. If name is set, errors are reported with file name and line.
-func runScript(r io.Reader) int {
+func runScript(r io.Reader, name string) int {
 	status := 0
-	for {
+	for lineNo := 1; ; lineNo++ {
 		line, err := readLine(r)
 		if trimmed := strings.TrimSpace(line); trimmed != "" && !strings.HasPrefix(trimmed, "#") {
-			printError(execInput(line))
+			cmdErr := execInput(line)
 			status = lastStatus
+			if name != "" && cmdErr != nil {
+				cmdErr = fmt.Errorf("%s:%d: %w", sanitize(name), lineNo, cmdErr)
+			}
+			printError(cmdErr)
 		}
 		if err != nil {
 			if err != io.EOF {
@@ -1131,7 +1369,7 @@ func parsePipeline(tokens []token) ([]stage, error) {
 		t := tokens[i]
 		switch t.op {
 		case "":
-			cur.args = append(cur.args, t.word)
+			cur.args = append(cur.args, expandWord(t)...)
 		case "|":
 			if isEmpty(cur) {
 				return nil, syntaxError("|")
@@ -1148,7 +1386,11 @@ func parsePipeline(tokens []token) ([]stage, error) {
 				return nil, syntaxError(next.op)
 			}
 			i++
-			cur.redirects = append(cur.redirects, redirect{op: t.op, fd: t.fd, file: tokens[i].word})
+			files := expandWord(tokens[i])
+			if len(files) > 1 {
+				return nil, fmt.Errorf("%s: ambiguous redirect", sanitize(tokens[i].word))
+			}
+			cur.redirects = append(cur.redirects, redirect{op: t.op, fd: t.fd, file: files[0]})
 		}
 	}
 
@@ -1329,6 +1571,8 @@ var builtins = map[string]struct{ changesState bool }{
 	"set":    {changesState: true},
 	"export": {changesState: true},
 	"help":   {},
+	"source": {changesState: true},
+	".":      {changesState: true},
 }
 
 // runBuiltin executes a built-in command, writing its output to stdout.
@@ -1408,6 +1652,12 @@ func runBuiltin(args []string, stdout io.Writer) error {
 		}
 		os.Setenv(parts[0], parts[1])
 		return nil
+	case "source", ".":
+		// source file - run the commands of file in the current shell
+		if len(args) < 2 {
+			return fmt.Errorf("usage: %s file", args[0])
+		}
+		return sourceFile(args[0], args[1])
 	case "help":
 		fmt.Fprintln(stdout, "gosh - Go Shell\nVersion: " + versionInfo() + `
 
@@ -1419,6 +1669,7 @@ Built-in commands:
   quit [code]   - Quit shell with status code (default: $?)
   set VAR=val   - Set environment variable
   export VAR=val - Export environment variable
+  source file   - Run the commands of file in this shell (also: . file)
   help          - Show this help
 
 Features:
@@ -1430,6 +1681,9 @@ Features:
     override with $GOSH_HISTFILE); lines starting with a space are not saved
   - Tab completion for commands and file paths
   - Tilde expansion (~, ~/path) at the start of unquoted words
+  - Wildcards: * ? [abc] [a-z] [!abc] match file names (not hidden files
+    unless the pattern starts with a dot); quoted wildcards and values of
+    variables are not expanded, a pattern without match is kept as is
   - Colored prompt (user@host green, red for root; directory blue),
     configurable with $GOSH_COLORS, e.g. GOSH_COLORS='user=1;33:path=36'
     (keys user, root, path; values are ANSI SGR codes, empty = no color);
@@ -1441,7 +1695,10 @@ Features:
   - Pipes (a | b) and redirections: < file, > file, >> file, 2> file,
     2>> file, 2>&1, >&2, &> file (stdout and stderr), &>> file
   - Non-interactive use: gosh -c 'command', gosh script, command | gosh;
-    the exit status is the one of the last command`)
+    the exit status is the one of the last command
+  - Startup files: login shells (-l or argv[0] starting with -) read
+    /etc/gosh/profile and ~/.gosh_profile, interactive shells read
+    /etc/gosh/goshrc and ~/.goshrc (skip with --noprofile, --norc)`)
 		return nil
 	}
 	return fmt.Errorf("%s: not a builtin", args[0])

main_test.go

@@ -889,6 +889,9 @@ func TestMain(m *testing.M) {
 		panic(err)
 	}
 	os.Setenv("GOSH_HISTFILE", filepath.Join(dir, "history"))
+	// Never read the system's startup files; tests that read the user's
+	// files set $HOME themselves
+	sysConfDir = filepath.Join(dir, "etc")
 	code := m.Run()
 	os.RemoveAll(dir)
 	os.Exit(code)
@@ -1183,7 +1186,7 @@ func TestShell_History(t *testing.T) {
 	histFile := filepath.Join(t.TempDir(), "gosh", "history")
 	workDir := t.TempDir()
 
-	cmd := exec.Command(bin, "-i")
+	cmd := exec.Command(bin, "-i", "--norc")
 	cmd.Dir = workDir
 	cmd.Env = append(os.Environ(), "GOSH_HISTFILE="+histFile)
 	cmd.Stdin = strings.NewReader("echo first\n set SECRET=hunter2\nexit\n")
@@ -1215,7 +1218,7 @@ func TestShell_History(t *testing.T) {
 func TestShell_SIGINTKillsOnlyChild(t *testing.T) {
 	bin := buildShell(t)
 
-	cmd := exec.Command(bin, "-i")
+	cmd := exec.Command(bin, "-i", "--norc")
 	// Own process group, so that we can signal it like the terminal does
 	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
 	stdin, err := cmd.StdinPipe()
@@ -1313,7 +1316,7 @@ func TestRunScript(t *testing.T) {
 		"touch first\n" +
 		"false\n" +
 		"touch second" // no trailing newline
-	if got := runScript(strings.NewReader(script)); got != 0 {
+	if got := runScript(strings.NewReader(script), ""); got != 0 {
 		t.Errorf("runScript() = %d, want 0", got)
 	}
 	for _, name := range []string{"first", "second"} {
@@ -1323,7 +1326,7 @@ func TestRunScript(t *testing.T) {
 	}
 
 	// The status of the last command is returned
-	if got := runScript(strings.NewReader("true\nsh -c 'exit 3'\n")); got != 3 {
+	if got := runScript(strings.NewReader("true\nsh -c 'exit 3'\n"), ""); got != 3 {
 		t.Errorf("runScript() = %d, want 3", got)
 	}
 }
@@ -1335,7 +1338,7 @@ func TestRun_Options(t *testing.T) {
 	}{
 		{[]string{"-c", "true"}, 0},
 		{[]string{"-c", "false"}, 1},
-		{[]string{"-l", "-c", "sh -c 'exit 5'"}, 5},
+		{[]string{"-l", "--noprofile", "-c", "sh -c 'exit 5'"}, 5},
 		{[]string{"-c"}, 2},
 		{[]string{"-x"}, 2},
 		{[]string{"/gosh/no/such/script"}, 127},
@@ -1514,6 +1517,10 @@ func TestTokenize_Operators(t *testing.T) {
 			t.Errorf("tokenize(%q) returned error: %v", tc.input, err)
 			continue
 		}
+		// Patterns are tested in TestTokenize_Patterns
+		for i := range got {
+			got[i].pattern, got[i].glob = "", false
+		}
 		if !reflect.DeepEqual(got, tc.want) {
 			t.Errorf("tokenize(%q) = %+v, want %+v", tc.input, got, tc.want)
 		}
@@ -1620,3 +1627,231 @@ func TestExecInput_RedirectionErrors(t *testing.T) {
 		t.Error("file f must not be created for a bad file descriptor")
 	}
 }
+
+func TestTokenize_Patterns(t *testing.T) {
+	t.Setenv("GOSH_GLOB", "*.go")
+	tests := []struct {
+		input   string
+		pattern string
+		glob    bool
+	}{
+		{"*.go", "*.go", true},
+		{"a?c", "a?c", true},
+		{"[ab].go", "[ab].go", true},
+		{"[!a].go", "[^a].go", true},
+		{"plain", "plain", false},
+		// Quoted, escaped and expanded characters are literal
+		{`"*.go"`, `\*.go`, false},
+		{`'*'.go`, `\*.go`, false},
+		{`\*.go`, `\*.go`, false},
+		{`"x"*`, `x*`, true},
+		{"$GOSH_GLOB", `\*.go`, false},
+		{`'['!a].go`, `\[!a].go`, false},
+	}
+	for _, tc := range tests {
+		tokens, err := tokenize(tc.input)
+		if err != nil || len(tokens) != 1 {
+			t.Errorf("tokenize(%q) = %+v, %v", tc.input, tokens, err)
+			continue
+		}
+		if tokens[0].pattern != tc.pattern || tokens[0].glob != tc.glob {
+			t.Errorf("tokenize(%q): pattern %q, glob %v; want %q, %v",
+				tc.input, tokens[0].pattern, tokens[0].glob, tc.pattern, tc.glob)
+		}
+	}
+}
+
+func TestExpandGlob(t *testing.T) {
+	origDir, _ := os.Getwd()
+	defer os.Chdir(origDir)
+	dir := t.TempDir()
+	os.Chdir(dir)
+	for _, d := range []string{"sub/deep", "other"} {
+		os.MkdirAll(d, 0755)
+	}
+	for _, f := range []string{"a.go", "b.go", "c.txt", ".hidden.go", "with space.go", "[x].go", "sub/s1.go", "sub/deep/d.go", "other/o.go"} {
+		os.WriteFile(f, nil, 0644)
+	}
+
+	tests := []struct {
+		pattern string
+		want    []string
+	}{
+		{"*.go", []string{"[x].go", "a.go", "b.go", "with space.go"}},
+		{".*.go", []string{".hidden.go"}},
+		{"?.go", []string{"a.go", "b.go"}},
+		{"[ab].go", []string{"a.go", "b.go"}},
+		{"[^a].go", []string{"b.go"}},
+		{"*/*.go", []string{"other/o.go", "sub/s1.go"}},
+		{"*/", []string{"other/", "sub/"}},
+		{"sub/*/*.go", []string{"sub/deep/d.go"}},
+		{"./c*", []string{"./c.txt"}},
+		{dir + "/c*", []string{dir + "/c.txt"}},
+		{`\[x\].go`, []string{"[x].go"}},
+		{"*.xyz", nil},
+		{"[", nil},
+	}
+	for _, tc := range tests {
+		if got := expandGlob(tc.pattern); !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("expandGlob(%q) = %q, want %q", tc.pattern, got, tc.want)
+		}
+	}
+}
+
+func TestExecInput_Wildcards(t *testing.T) {
+	origDir, _ := os.Getwd()
+	defer os.Chdir(origDir)
+	dir := t.TempDir()
+	os.Chdir(dir)
+	for _, f := range []string{"a.go", "b.go", "c.txt"} {
+		os.WriteFile(f, []byte(f+"\n"), 0644)
+	}
+
+	tests := []struct {
+		input string
+		want  string
+	}{
+		{"echo *.go > out", "a.go b.go\n"},
+		{"cat *.go > out", "a.go\nb.go\n"},
+		// No match: the word is passed on unchanged, like in sh
+		{"echo *.xyz > out", "*.xyz\n"},
+		{`echo "*.go" '?.go' \*.go > out`, "*.go ?.go *.go\n"},
+		// A redirection to a pattern with a single match uses that file
+		{"echo hi > *.txt; cat c.txt > out", "hi\n"},
+	}
+	for _, tc := range tests {
+		if err := execInput(tc.input); err != nil {
+			t.Errorf("execInput(%q) returned error: %v", tc.input, err)
+		}
+		if got, _ := os.ReadFile("out"); string(got) != tc.want {
+			t.Errorf("%q: got %q, want %q", tc.input, got, tc.want)
+		}
+	}
+
+	err := execInput("echo hi > *.go")
+	if err == nil || err.Error() != "*.go: ambiguous redirect" {
+		t.Errorf("expected ambiguous redirect error, got %v", err)
+	}
+}
+
+func TestStartupFiles(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	sys := sysConfDir
+
+	tests := []struct {
+		login, interactive bool
+		want               []string
+	}{
+		{false, false, nil},
+		{true, false, []string{sys + "/profile", home + "/.gosh_profile"}},
+		{false, true, []string{sys + "/goshrc", home + "/.goshrc"}},
+		{true, true, []string{sys + "/profile", home + "/.gosh_profile", sys + "/goshrc", home + "/.goshrc"}},
+	}
+	for _, tc := range tests {
+		if got := startupFiles(tc.login, tc.interactive); !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("startupFiles(%v, %v) = %q, want %q", tc.login, tc.interactive, got, tc.want)
+		}
+	}
+}
+
+func TestRun_LoginReadsProfile(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	os.Unsetenv("GOSH_TEST_PROFILE")
+	defer os.Unsetenv("GOSH_TEST_PROFILE")
+	os.WriteFile(filepath.Join(home, ".gosh_profile"), []byte("export GOSH_TEST_PROFILE=yes\n"), 0644)
+	// .goshrc is only read by interactive shells
+	os.WriteFile(filepath.Join(home, ".goshrc"), []byte("exit 99\n"), 0644)
+
+	check := `sh -c 'test "$GOSH_TEST_PROFILE" = yes'`
+	if got := run([]string{"-c", check}); got != 1 {
+		t.Errorf("non-login shell: status %d, want 1 (profile must not be read)", got)
+	}
+	if got := run([]string{"-l", "--noprofile", "-c", check}); got != 1 {
+		t.Errorf("--noprofile: status %d, want 1 (profile must not be read)", got)
+	}
+	if got := run([]string{"-l", "-c", check}); got != 0 {
+		t.Errorf("login shell: status %d, want 0 (profile must be read)", got)
+	}
+}
+
+func TestShell_InteractiveReadsRC(t *testing.T) {
+	bin := buildShell(t)
+	home := t.TempDir()
+	os.WriteFile(filepath.Join(home, ".goshrc"), []byte("export GOSH_TEST_RC=from-rc\n"), 0644)
+	os.WriteFile(filepath.Join(home, ".gosh_profile"), []byte("export GOSH_TEST_PROFILE=from-profile\n"), 0644)
+
+	tests := []struct {
+		args []string
+		want string
+	}{
+		{[]string{"-i"}, "from-rc -\n"},
+		{[]string{"-i", "--norc"}, "- -\n"},
+		{[]string{"-i", "-l"}, "from-rc from-profile\n"},
+		{[]string{"-i", "-l", "--norc", "--noprofile"}, "- -\n"},
+	}
+	for _, tc := range tests {
+		cmd := exec.Command(bin, tc.args...)
+		cmd.Env = append(os.Environ(), "HOME="+home)
+		cmd.Stdin = strings.NewReader("echo ${GOSH_TEST_RC:--} ${GOSH_TEST_PROFILE:--}\nexit\n")
+		out, err := cmd.Output()
+		if err != nil {
+			t.Fatalf("%v: %v", tc.args, err)
+		}
+		if !strings.HasSuffix(string(out), tc.want) {
+			t.Errorf("%v: output %q, want suffix %q", tc.args, out, tc.want)
+		}
+	}
+}
+
+func TestExecInput_Source(t *testing.T) {
+	dir := t.TempDir()
+	os.Unsetenv("GOSH_TEST_SOURCE")
+	defer os.Unsetenv("GOSH_TEST_SOURCE")
+
+	file := filepath.Join(dir, "vars")
+	os.WriteFile(file, []byte("# comment\nexport GOSH_TEST_SOURCE=hello\nsh -c 'exit 4'\n"), 0644)
+
+	for _, cmd := range []string{"source", "."} {
+		os.Unsetenv("GOSH_TEST_SOURCE")
+		execInput(cmd + " " + file)
+		if os.Getenv("GOSH_TEST_SOURCE") != "hello" {
+			t.Errorf("%s: variable was not set in the current shell", cmd)
+		}
+		if lastStatus != 4 {
+			t.Errorf("%s: $? = %d, want 4 (status of the last command)", cmd, lastStatus)
+		}
+	}
+
+	err := execInput("source " + filepath.Join(dir, "missing"))
+	if err == nil || !strings.Contains(err.Error(), "source: "+dir+"/missing: no such file or directory") {
+		t.Errorf("unexpected error for missing file: %v", err)
+	}
+	if lastStatus != 1 {
+		t.Errorf("$? = %d for missing file, want 1", lastStatus)
+	}
+
+	// A file that sources itself is stopped
+	loop := filepath.Join(dir, "loop")
+	os.WriteFile(loop, []byte("source "+loop+"\n"), 0644)
+	if err := execInput("source " + loop); err == nil {
+		t.Error("expected an error for a file that sources itself")
+	}
+}
+
+func TestGetHomeDir_UsesHOME(t *testing.T) {
+	t.Setenv("HOME", "/gosh/test/home")
+	if got := getHomeDir(); got != "/gosh/test/home" {
+		t.Errorf("getHomeDir() = %q, want $HOME", got)
+	}
+	if words, _ := splitWords("echo ~/x"); words[1] != "/gosh/test/home/x" {
+		t.Errorf("~/x = %q, want it based on $HOME", words[1])
+	}
+
+	// Without $HOME the user database is used
+	t.Setenv("HOME", "")
+	if got := getHomeDir(); got == "" {
+		t.Error("getHomeDir() is empty without $HOME")
+	}
+}