add aliases

- alias name=value defines aliases, alias lists or shows them in a form
  that can be read back, unalias removes them (unalias -a: all)
- the first word of every command (at the start and after ;, &, &&, ||
  and |) is replaced, the value is expanded again except for aliases
  that are already being expanded (alias ls='ls --color' works)
- a value ending with a blank makes the next word a command name too
- quoted or escaped words (\ll, 'll') skip the alias
- aliases are only expanded in interactive shells and their startup
  files, like in bash
- tab completion includes aliases

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

README.md

@@ -12,6 +12,13 @@ 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)
+  jobs          - List background and stopped jobs
+  fg [%n]       - Continue job n (default: current job) in the foreground
+  bg [%n]       - Continue stopped job n in the background
+  wait [%n]     - Wait for job n or all background jobs
+  alias [name[=value] ...] - Define or show aliases (alias ll='ls -l')
+  unalias name  - Remove an alias (unalias -a: all aliases)
   help          - Show this help
 
 Features:
@@ -36,16 +43,23 @@ Features:
     a || b (b only if a failed); $? is the exit status of the last command
   - Pipes (a | b) and redirections: < file, > file, >> file, 2> file,
     2>> file, 2>&1, >&2, &> file (stdout and stderr), &>> file
+  - Job control: command & runs in the background, Ctrl+Z stops the
+    foreground job; jobs, fg, bg and wait manage the jobs
+  - Aliases replace the first word of a command in interactive shells
+    (define them in ~/.goshrc); \name or 'name' skips the alias
   - 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
 ```
 
@@ -56,12 +70,54 @@ 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
+
+# Aliase
+alias ll='ls -l'
+alias ..='cd ..'
+
+# 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:
@@ -137,7 +193,70 @@ $ grep -c error < build.log
 - Operatoren in Anführungszeichen oder mit `\` davor sind normale Zeichen: `echo "a|b" 'c>d' e\>f`.
 - Der Exit-Status einer Pipeline ist der des letzten Befehls. Beendet sich ein Befehl am Ende (z. B. `head`), bekommt der schreibende Befehl davor `SIGPIPE`, `yes | head -1` endet also sofort.
 - Die Built-ins `pwd` und `help` lassen sich umleiten und in Pipes verwenden (`help | less`). `cd`, `set`, `export`, `exit` und `quit` verändern die Shell selbst und sind in einer Pipeline nicht erlaubt.
-- Ein einzelnes `&` (Hintergrundprozesse) gibt es noch nicht, es wird als normales Zeichen übergeben.
+
+### Aliase
+
+Ein Alias ist ein Kurzname für einen Befehl, am besten in `~/.goshrc` definiert:
+
+```bash
+alias ll='ls -l'
+alias la='ls -la'
+alias ..='cd ..'
+alias gs='git status'
+alias ls='ls --color=auto'      # ein Alias darf den eigenen Namen enthalten
+alias please='sudo '            # endet mit Leerzeichen: das nächste Wort wird auch ersetzt
+```
+
+| Befehl                  | Bedeutung                                         |
+|-------------------------|---------------------------------------------------|
+| `alias name='wert'`     | definiert einen Alias (mehrere in einem Aufruf möglich) |
+| `alias`                 | listet alle Aliase (in einer Form, die sich wieder einlesen lässt) |
+| `alias name`            | zeigt einen Alias                                 |
+| `unalias name`          | entfernt einen Alias, `unalias -a` alle           |
+
+- Ersetzt wird nur das erste Wort eines Befehls, also am Zeilenanfang und nach `;`, `&&`, `||`, `|` und `&`: `ll | less` funktioniert, `echo ll` gibt `ll` aus.
+- Der Wert darf selbst mehrere Befehle enthalten (`alias up='cd .. && ls'`) und wird wiederum auf Aliase geprüft. Ein Alias, der gerade ersetzt wird, wird darin nicht noch einmal ersetzt, deshalb funktioniert `alias ls='ls --color=auto'`.
+- Endet der Wert mit einem Leerzeichen, wird auch das nächste Wort als Alias geprüft: Mit den Aliasen oben wird `please ll` zu `sudo ls --color=auto -l`.
+- Mit `\ll` oder `'ll'` umgeht man den Alias und ruft das Programm direkt auf.
+- Aliase gelten nur in interaktiven Shells (wie in bash), also auch in `~/.goshrc`, aber nicht in Skripten und bei `gosh -c`. Ein Alias wirkt erst ab der nächsten Zeile, nicht in der Zeile, in der er definiert wird.
+- Erlaubt sind Namen aus Buchstaben, Ziffern und `_ - . + : , @ % ^`.
+- Aliase werden auch mit Tab vervollständigt.
+
+### Job-Control
+
+In einer interaktiven Shell läuft jede Befehlszeile (bzw. jede Pipeline) als eigener *Job* in einer eigenen Prozessgruppe:
+
+```
+$ sleep 100 &                 # im Hintergrund starten
+[1] 12345
+$ vim notizen.txt             # Ctrl+Z hält vim an
+^Z
+[2]+  Stopped                 vim notizen.txt
+$ jobs
+[1]-  Running                 sleep 100 &
+[2]+  Stopped                 vim notizen.txt
+$ fg                          # vim wieder im Vordergrund
+$ bg %2                       # oder: angehaltenen Job im Hintergrund weiterlaufen lassen
+```
+
+| Befehl / Taste | Bedeutung                                                                 |
+|----------------|---------------------------------------------------------------------------|
+| `befehl &`     | startet den Befehl im Hintergrund, gosh wartet nicht auf ihn (`$?` ist 0) |
+| Ctrl+Z         | hält den Vordergrund-Job an (`$?` wird 128+SIGTSTP, unter Linux 148)      |
+| Ctrl+C         | bricht nur den Vordergrund-Job ab, nicht die Shell                        |
+| `jobs`         | listet laufende und angehaltene Jobs                                      |
+| `fg [%n]`      | holt Job `n` in den Vordergrund (und setzt ihn fort, falls angehalten)    |
+| `bg [%n]`      | setzt einen angehaltenen Job im Hintergrund fort                          |
+| `wait [%n]`    | wartet auf Job `n` bzw. auf alle Hintergrund-Jobs                         |
+
+- Ohne Angabe gilt der *aktuelle* Job (in `jobs` mit `+` markiert, der zuletzt angehaltene oder in den Hintergrund geschickte), `%-` ist der vorherige (`-`). `%n` und `n` meinen Job Nummer `n`.
+- Beendete Hintergrund-Jobs meldet gosh vor dem nächsten Prompt (`[1]+  Done   sleep 100`, bei Fehlern `Exit N`).
+- Liest ein Hintergrund-Job vom Terminal, wird er angehalten (wie in bash), mit `fg` bekommt er die Eingabe.
+- Die Terminal-Einstellungen werden gesichert und wiederhergestellt: Nach dem Anhalten von `vim` oder `less` funktioniert der Prompt normal, nach `fg` bekommt das Programm seine Einstellungen zurück.
+- `exit` (oder Ctrl+D) mit angehaltenen Jobs warnt einmal (`there are stopped jobs`), ein zweites `exit` direkt danach beendet gosh.
+- `cd`, `set`, `export`, `exit`, `source`, `fg`, `bg` und `wait` lassen sich nicht mit `&` im Hintergrund starten.
+- In Skripten und mit `gosh -c` gibt es keine Job-Control (kein Ctrl+Z, kein `fg`/`bg`), `&` und `wait` funktionieren aber. Hintergrund-Jobs lesen dort von `/dev/null`.
+- Einen Job beenden lässt sich mit `kill` über die Prozess-ID (z. B. `kill 12345`); `kill %1` versteht gosh noch nicht.
 
 ### Farben
 

alias.go

@@ -0,0 +1,191 @@
+package main
+
+// Aliases: like in bash, an alias replaces the first word of a command and
+// is only expanded in interactive shells (including the startup files), not
+// in scripts or with gosh -c.
+
+import (
+	"fmt"
+	"io"
+	"sort"
+	"strings"
+	"sync"
+)
+
+var (
+	aliasMu sync.Mutex
+	aliases = map[string]string{}
+)
+
+// isAliasName reports whether s can be an alias name: letters, digits and a
+// few punctuation characters, but nothing that is special to the shell.
+func isAliasName(s string) bool {
+	if s == "" {
+		return false
+	}
+	for _, r := range s {
+		switch {
+		case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z', r >= '0' && r <= '9':
+		case strings.ContainsRune("_-.+:,@%^", r):
+		default:
+			return false
+		}
+	}
+	return true
+}
+
+// lookupAlias returns the value of an alias.
+func lookupAlias(name string) (string, bool) {
+	aliasMu.Lock()
+	defer aliasMu.Unlock()
+	value, ok := aliases[name]
+	return value, ok
+}
+
+// aliasNames returns the names of all aliases, sorted.
+func aliasNames() []string {
+	aliasMu.Lock()
+	defer aliasMu.Unlock()
+	names := make([]string, 0, len(aliases))
+	for name := range aliases {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	return names
+}
+
+// expandAliases replaces aliases at the start of every command in line (at
+// the start and after ;, &, &&, || and |). The value of an alias is expanded
+// again, except for aliases that are already being expanded, so that e.g.
+// alias ls='ls --color' works. If the value ends with a blank, the next word
+// is checked for an alias too. Quoted or escaped words (\ls, 'ls') are never
+// replaced.
+func expandAliases(line string) string {
+	return expandAliasesIn(line, map[string]bool{})
+}
+
+func expandAliasesIn(line string, active map[string]bool) string {
+	var (
+		out        strings.Builder
+		quote      byte
+		escaped    bool
+		commandPos = true // the next word is the name of a command
+	)
+
+	for i := 0; i < len(line); i++ {
+		ch := line[i]
+		if quote == 0 && !escaped && commandPos {
+			if ch == ' ' || ch == '\t' {
+				out.WriteByte(ch)
+				continue
+			}
+			commandPos = false
+			end := i
+			for end < len(line) && strings.IndexByte(" \t\n;&|<>", line[end]) < 0 {
+				end++
+			}
+			name := line[i:end]
+			if value, ok := lookupAlias(name); ok && isAliasName(name) && !active[name] {
+				active[name] = true
+				out.WriteString(expandAliasesIn(value, active))
+				delete(active, name)
+				// A trailing blank makes the next word a command name too
+				commandPos = strings.HasSuffix(value, " ") || strings.HasSuffix(value, "\t")
+				i = end - 1
+				continue
+			}
+		}
+
+		out.WriteByte(ch)
+		switch {
+		case escaped:
+			escaped = false
+		case quote == '\'':
+			if ch == '\'' {
+				quote = 0
+			}
+		case ch == '\\':
+			escaped = true
+		case quote == '"':
+			if ch == '"' {
+				quote = 0
+			}
+		case ch == '"' || ch == '\'':
+			quote = ch
+		case ch == '#' && (i == 0 || strings.IndexByte(" \t", line[i-1]) >= 0):
+			// Comment until the end of the line
+			out.WriteString(line[i+1:])
+			return out.String()
+		case ch == ';' || ch == '|':
+			commandPos = true
+		case ch == '&':
+			// & and && separate commands, &>, >& and <& do not
+			if !(i+1 < len(line) && line[i+1] == '>') && !(i > 0 && strings.IndexByte("<>", line[i-1]) >= 0) {
+				commandPos = true
+			}
+		}
+	}
+	return out.String()
+}
+
+// quoteAlias quotes a value for the output of alias, so that it can be read
+// back: 'value' with ' written as '\”.
+func quoteAlias(value string) string {
+	return "'" + strings.ReplaceAll(value, "'", `'\''`) + "'"
+}
+
+// builtinAlias defines aliases (alias name=value ...), prints them (alias
+// name ...) or lists all of them (alias).
+func builtinAlias(args []string, stdout io.Writer) error {
+	if len(args) == 1 {
+		for _, name := range aliasNames() {
+			value, _ := lookupAlias(name)
+			fmt.Fprintf(stdout, "alias %s=%s\n", name, sanitize(quoteAlias(value)))
+		}
+		return nil
+	}
+
+	var err error
+	for _, arg := range args[1:] {
+		name, value, define := strings.Cut(arg, "=")
+		if !isAliasName(name) {
+			err = fmt.Errorf("alias: `%s': invalid alias name", sanitize(name))
+			continue
+		}
+		if define {
+			aliasMu.Lock()
+			aliases[name] = value
+			aliasMu.Unlock()
+			continue
+		}
+		if value, ok := lookupAlias(name); ok {
+			fmt.Fprintf(stdout, "alias %s=%s\n", name, sanitize(quoteAlias(value)))
+		} else {
+			err = fmt.Errorf("alias: %s: not found", sanitize(name))
+		}
+	}
+	return err
+}
+
+// builtinUnalias removes aliases (unalias name ...) or all of them
+// (unalias -a).
+func builtinUnalias(args []string) error {
+	if len(args) < 2 {
+		return fmt.Errorf("usage: unalias [-a] name ...")
+	}
+	aliasMu.Lock()
+	defer aliasMu.Unlock()
+	if args[1] == "-a" {
+		aliases = map[string]string{}
+		return nil
+	}
+	var err error
+	for _, name := range args[1:] {
+		if _, ok := aliases[name]; !ok {
+			err = fmt.Errorf("unalias: %s: not found", sanitize(name))
+			continue
+		}
+		delete(aliases, name)
+	}
+	return err
+}

alias_test.go

@@ -0,0 +1,164 @@
+package main
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// withAliases sets the aliases for a test and restores them afterwards.
+func withAliases(t *testing.T, defs map[string]string) {
+	t.Helper()
+	aliasMu.Lock()
+	saved := aliases
+	aliases = map[string]string{}
+	for name, value := range defs {
+		aliases[name] = value
+	}
+	aliasMu.Unlock()
+	t.Cleanup(func() {
+		aliasMu.Lock()
+		aliases = saved
+		aliasMu.Unlock()
+	})
+}
+
+func TestExpandAliases(t *testing.T) {
+	withAliases(t, map[string]string{
+		"ll":    "ls -l",
+		"ls":    "ls --color",
+		"..":    "cd ..",
+		"e":     "echo ",
+		"w":     "world",
+		"a":     "b",
+		"b":     "a",
+		"multi": "cd /tmp && ls",
+	})
+
+	tests := []struct {
+		input, want string
+	}{
+		{"ll", "ls --color -l"},
+		{"  ll -a", "  ls --color -l -a"},
+		{"ls", "ls --color"},
+		{"..", "cd .."},
+		// Only the command name is replaced
+		{"echo ll", "echo ll"},
+		{"ll ll", "ls --color -l ll"},
+		// ... also after ;, &&, ||, | and &
+		{"ll; ll && ll || ll | ll & ll", "ls --color -l; ls --color -l && ls --color -l || ls --color -l | ls --color -l & ls --color -l"},
+		// but not after redirections with &
+		{"ll 2>&1 ll", "ls --color -l 2>&1 ll"},
+		{"ll &> ll", "ls --color -l &> ll"},
+		// Quoted or escaped words are not replaced
+		{`\ll`, `\ll`},
+		{`'ll'`, `'ll'`},
+		{`"ll"`, `"ll"`},
+		{`echo "a; ll"`, `echo "a; ll"`},
+		{`echo 'a | ll'`, `echo 'a | ll'`},
+		// A trailing blank makes the next word a command name too
+		{"e w", "echo  world"},
+		{"e e w", "echo  echo  world"},
+		// Recursion stops at aliases that are already being expanded
+		{"a", "a"},
+		{"b", "b"},
+		// The value can contain several commands
+		{"multi", "cd /tmp && ls --color"},
+		// Comments are left alone
+		{"echo x # ll", "echo x # ll"},
+	}
+	for _, tc := range tests {
+		if got := expandAliases(tc.input); got != tc.want {
+			t.Errorf("expandAliases(%q) = %q, want %q", tc.input, got, tc.want)
+		}
+	}
+}
+
+func TestBuiltinAlias(t *testing.T) {
+	withAliases(t, nil)
+
+	run := func(args ...string) (string, error) {
+		var out bytes.Buffer
+		err := builtinAlias(append([]string{"alias"}, args...), &out)
+		return out.String(), err
+	}
+
+	if _, err := run("ll=ls -l", "q=echo it's", "..=cd .."); err != nil {
+		t.Fatal(err)
+	}
+	out, _ := run()
+	want := "alias ..='cd ..'\nalias ll='ls -l'\nalias q='echo it'\\''s'\n"
+	if out != want {
+		t.Errorf("alias = %q, want %q", out, want)
+	}
+	if out, _ := run("ll"); out != "alias ll='ls -l'\n" {
+		t.Errorf("alias ll = %q", out)
+	}
+	if _, err := run("nope"); err == nil || err.Error() != "alias: nope: not found" {
+		t.Errorf("alias nope: %v", err)
+	}
+	for _, name := range []string{"a/b", "a=b", "$x", "a b", ""} {
+		if isAliasName(name) {
+			t.Errorf("isAliasName(%q) = true", name)
+		}
+	}
+	if _, err := run("a/b=x"); err == nil || !strings.Contains(err.Error(), "invalid alias name") {
+		t.Errorf("alias a/b=x: %v", err)
+	}
+
+	if err := builtinUnalias([]string{"unalias", "ll", "nope"}); err == nil || err.Error() != "unalias: nope: not found" {
+		t.Errorf("unalias nope: %v", err)
+	}
+	if _, ok := lookupAlias("ll"); ok {
+		t.Error("ll still defined after unalias")
+	}
+	builtinUnalias([]string{"unalias", "-a"})
+	if names := aliasNames(); len(names) != 0 {
+		t.Errorf("aliases after unalias -a: %q", names)
+	}
+}
+
+func TestExecInput_Aliases(t *testing.T) {
+	withAliases(t, nil)
+	origDir, _ := os.Getwd()
+	defer os.Chdir(origDir)
+	dir := t.TempDir()
+	os.Chdir(dir)
+	defer func(saved bool) { interactiveShell = saved }(interactiveShell)
+
+	// Aliases are expanded in interactive shells only
+	interactiveShell = true
+	execInput(`alias say='echo hello' to=out`)
+	execInput("say world > out")
+	if got, _ := os.ReadFile("out"); string(got) != "hello world\n" {
+		t.Errorf("alias in interactive shell: out = %q", got)
+	}
+
+	interactiveShell = false
+	os.Remove("out")
+	if err := execInput("say world > out"); err == nil {
+		t.Error("alias was expanded in a non-interactive shell")
+	}
+
+	// alias works in pipelines (listing), unalias does not
+	interactiveShell = true
+	execInput("alias | grep say > out")
+	if got, _ := os.ReadFile(filepath.Join(dir, "out")); string(got) != "alias say='echo hello'\n" {
+		t.Errorf("alias | grep = %q", got)
+	}
+	if err := execInput("echo | unalias say"); err == nil {
+		t.Error("unalias in a pipeline must fail")
+	}
+}
+
+func TestShellCompleter_Aliases(t *testing.T) {
+	withAliases(t, map[string]string{"gst": "git status"})
+	t.Setenv("PATH", t.TempDir())
+	got, length := completeLine("gs")
+	if !reflect.DeepEqual(got, []string{"t "}) || length != 2 {
+		t.Errorf("completion of gs = %q, %d", got, length)
+	}
+}

go.mod

@@ -7,4 +7,4 @@ require (
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510
 )
 
-require golang.org/x/sys v0.48.0 // indirect
+require golang.org/x/sys v0.48.0

jobs.go

@@ -0,0 +1,525 @@
+package main
+
+// Job control: in an interactive shell every pipeline runs in its own process
+// group, which gets the terminal while it runs in the foreground. Ctrl+Z stops
+// the foreground job, "&" starts a job in the background, and the builtins
+// jobs, fg, bg and wait manage the jobs. Without a terminal (scripts, gosh -c)
+// there is no job control, but "&" and wait still work.
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"os/signal"
+	"strconv"
+	"strings"
+	"syscall"
+
+	"github.com/chzyer/readline"
+	"golang.org/x/sys/unix"
+)
+
+// proc is a stage of a job: a process, or a builtin or a stage that failed to
+// start (both without process).
+type proc struct {
+	cmd      *exec.Cmd  // nil if the stage is no process
+	done     chan error // the result of a stage without process
+	finished bool
+	stopped  bool
+	err      error
+}
+
+// job is a pipeline that was started by the shell.
+type job struct {
+	id    int    // number in the job table, 0 if not in the table
+	pgid  int    // process group, 0 without job control or processes
+	text  string // the command line
+	procs []*proc
+	tty   *readline.State // terminal modes of the job when it was stopped
+}
+
+var (
+	jobControl       bool            // job control is enabled
+	interactiveShell bool            // the shell reads commands from a user
+	ttyFd            int             // the terminal of the shell
+	shellPgid        int             // the process group of the shell
+	origPgid         int             // the foreground process group at start
+	shellTTY         *readline.State // terminal modes of the shell
+	jobTable         []*job          // background and stopped jobs
+	exitWarned       bool            // "there are stopped jobs" was shown
+)
+
+// initJobControl enables job control if stdin is a terminal: the shell moves
+// into its own process group and takes the terminal.
+func initJobControl() {
+	fd := int(os.Stdin.Fd())
+	if !readline.IsTerminal(fd) {
+		return
+	}
+	pgrp, err := unix.IoctlGetInt(fd, unix.TIOCGPGRP)
+	if err != nil {
+		return
+	}
+	pid := os.Getpid()
+	if syscall.Getpgrp() != pid {
+		if err := syscall.Setpgid(0, 0); err != nil {
+			return
+		}
+	}
+	origPgid, ttyFd, shellPgid = pgrp, fd, pid
+	if err := setForeground(pid); err != nil {
+		return
+	}
+	// Ctrl+Z must not stop the shell itself. (signal.Ignore would be
+	// inherited by the child processes.)
+	signal.Notify(make(chan os.Signal, 1), syscall.SIGTSTP)
+	jobControl = true
+}
+
+// releaseTerminal gives the terminal back to the process group that had it
+// when the shell started.
+func releaseTerminal() {
+	if jobControl && origPgid > 0 && origPgid != shellPgid {
+		setForeground(origPgid)
+	}
+}
+
+// setForeground makes pgid the foreground process group of the terminal.
+func setForeground(pgid int) error {
+	// The shell gets SIGTTOU if it does this while it is in the background
+	// (when it takes the terminal back from a job), unless the signal is
+	// ignored. It is only ignored for this call, since ignored signals are
+	// inherited by child processes.
+	signal.Ignore(syscall.SIGTTOU)
+	defer signal.Reset(syscall.SIGTTOU)
+	return unix.IoctlSetPointerInt(ttyFd, unix.TIOCSPGRP, pgid)
+}
+
+// ttyIndex returns the index of the file in fds that is the terminal of the
+// shell, or -1.
+func ttyIndex(fds [3]*os.File) int {
+	tty, err := os.Stdin.Stat()
+	if err != nil {
+		return -1
+	}
+	for i, f := range fds {
+		if info, err := f.Stat(); err == nil && os.SameFile(info, tty) {
+			return i
+		}
+	}
+	return -1
+}
+
+// finishedProc returns a proc without process that already has its result.
+func finishedProc(err error) *proc {
+	p := &proc{done: make(chan error, 1)}
+	p.done <- err
+	return p
+}
+
+// running reports whether a process of the job is running.
+func (j *job) running() bool {
+	for _, p := range j.procs {
+		if p.cmd != nil && !p.finished && !p.stopped {
+			return true
+		}
+	}
+	return false
+}
+
+// stopped reports whether the job is stopped: no process is running, but
+// one is stopped.
+func (j *job) stopped() bool {
+	if j.running() {
+		return false
+	}
+	for _, p := range j.procs {
+		if p.stopped {
+			return true
+		}
+	}
+	return false
+}
+
+// finished reports whether all stages of the job have finished.
+func (j *job) finished() bool {
+	for _, p := range j.procs {
+		if !p.finished {
+			return false
+		}
+	}
+	return true
+}
+
+// update records a status change of process pid.
+func (j *job) update(pid int, ws syscall.WaitStatus) {
+	for _, p := range j.procs {
+		if p.cmd == nil || p.cmd.Process.Pid != pid {
+			continue
+		}
+		switch {
+		case ws.Stopped():
+			p.stopped = true
+		case ws.Continued():
+			p.stopped = false
+		default:
+			p.finished, p.stopped = true, false
+			p.err = waitStatusError(ws)
+			p.cmd.Process.Release()
+		}
+	}
+}
+
+// waitStatusError converts the status of a finished process into an error:
+// nil for exit code 0, otherwise a statusError with the exit code, or 128+n
+// if the process was killed by signal n.
+func waitStatusError(ws syscall.WaitStatus) error {
+	switch {
+	case ws.Signaled():
+		return statusError(128 + int(ws.Signal()))
+	case ws.ExitStatus() != 0:
+		return statusError(ws.ExitStatus())
+	}
+	return nil
+}
+
+// wait waits until no process of the job is running any more (all finished
+// or, with job control, stopped). With nohang it only collects the status
+// changes that are already available and does not block.
+func (j *job) wait(nohang bool) {
+	flags := 0
+	if jobControl && j.pgid != 0 {
+		flags |= syscall.WUNTRACED | syscall.WCONTINUED
+	}
+	if nohang {
+		flags |= syscall.WNOHANG
+	}
+
+	for {
+		// With job control all processes of the job are in its process
+		// group, otherwise they are waited for one by one.
+		target := 0
+		if jobControl && j.pgid != 0 {
+			if !j.running() && !(nohang && j.stopped()) {
+				break
+			}
+			target = -j.pgid
+		} else {
+			if nohang {
+				// Check every process once
+				for _, p := range j.procs {
+					if p.cmd == nil || p.finished {
+						continue
+					}
+					var ws syscall.WaitStatus
+					if pid, err := syscall.Wait4(p.cmd.Process.Pid, &ws, flags, nil); err == nil && pid > 0 {
+						j.update(pid, ws)
+					}
+				}
+				break
+			}
+			for _, p := range j.procs {
+				if p.cmd != nil && !p.finished {
+					target = p.cmd.Process.Pid
+					break
+				}
+			}
+			if target == 0 {
+				break
+			}
+		}
+
+		var ws syscall.WaitStatus
+		pid, err := syscall.Wait4(target, &ws, flags, nil)
+		if errors.Is(err, syscall.EINTR) {
+			continue
+		}
+		if err != nil {
+			// Should not happen; do not wait forever
+			for _, p := range j.procs {
+				if p.cmd != nil && !p.finished {
+					p.finished, p.stopped = true, false
+				}
+			}
+			break
+		}
+		if pid == 0 {
+			break // nohang and nothing changed
+		}
+		j.update(pid, ws)
+	}
+
+	// Stages without process (builtins in pipelines)
+	for _, p := range j.procs {
+		if p.cmd != nil || p.finished {
+			continue
+		}
+		if nohang || j.stopped() {
+			select {
+			case p.err = <-p.done:
+				p.finished = true
+			default:
+			}
+		} else {
+			p.err = <-p.done
+			p.finished = true
+		}
+	}
+}
+
+// result returns the error of the last stage of a finished job (so $? is its
+// exit status, like in sh) and prints the errors of the other stages.
+func (j *job) result() error {
+	for _, p := range j.procs[:len(j.procs)-1] {
+		printError(p.err)
+	}
+	return j.procs[len(j.procs)-1].err
+}
+
+// waitForeground waits for a job in the foreground. If it is stopped, it is
+// added to the job table.
+func waitForeground(j *job) error {
+	j.wait(false)
+	if jobControl && j.pgid != 0 {
+		setForeground(shellPgid)
+		if j.stopped() {
+			j.tty, _ = readline.GetState(ttyFd)
+		}
+		if shellTTY != nil {
+			readline.Restore(ttyFd, shellTTY)
+		}
+	}
+
+	if j.stopped() {
+		addJob(j)
+		fmt.Fprintln(os.Stderr)
+		fmt.Fprintln(os.Stderr, j.describe("Stopped"))
+		return statusError(128 + int(syscall.SIGTSTP))
+	}
+	removeJob(j)
+	j.wait(false) // wait for the builtins, if any
+	return j.result()
+}
+
+// addJob adds j to the job table (if it is not there yet) and makes it the
+// current job.
+func addJob(j *job) {
+	removeJob(j)
+	if j.id == 0 {
+		for _, other := range jobTable {
+			j.id = max(j.id, other.id)
+		}
+		j.id++
+	}
+	jobTable = append(jobTable, j)
+}
+
+// removeJob removes j from the job table.
+func removeJob(j *job) {
+	for i, other := range jobTable {
+		if other == j {
+			jobTable = append(jobTable[:i], jobTable[i+1:]...)
+			return
+		}
+	}
+}
+
+// describe formats a job for jobs and the notifications, like bash:
+// "[1]+  Stopped                 sleep 30". The current job (the last one in
+// the table, i.e. the one stopped or put into the background most recently) is
+// marked with +, the previous one with -.
+func (j *job) describe(state string) string {
+	mark := ' '
+	if n := len(jobTable); n > 0 && jobTable[n-1] == j {
+		mark = '+'
+	} else if n > 1 && jobTable[n-2] == j {
+		mark = '-'
+	}
+	text := j.text
+	if state == "Running" {
+		text += " &"
+	}
+	return fmt.Sprintf("[%d]%c  %-24s%s", j.id, mark, state, sanitize(text))
+}
+
+// state returns the state of a job for jobs and the notifications.
+func (j *job) state() string {
+	switch {
+	case j.stopped():
+		return "Stopped"
+	case !j.finished():
+		return "Running"
+	}
+	if status := exitStatus(j.procs[len(j.procs)-1].err); status != 0 {
+		return "Exit " + strconv.Itoa(status)
+	}
+	return "Done"
+}
+
+// hasStoppedJobs reports whether a job in the table is stopped.
+func hasStoppedJobs() bool {
+	for _, j := range jobTable {
+		if j.stopped() {
+			return true
+		}
+	}
+	return false
+}
+
+// reapJobs collects the status changes of the background jobs, reports
+// finished and newly stopped jobs (if notify is set) and removes finished
+// jobs from the table.
+func reapJobs(notify bool) {
+	for _, j := range append([]*job(nil), jobTable...) {
+		wasStopped := j.stopped()
+		j.wait(true)
+		switch {
+		case j.finished():
+			if notify {
+				for _, p := range j.procs {
+					printError(p.err)
+				}
+				fmt.Fprintln(os.Stderr, j.describe(j.state()))
+			}
+			removeJob(j)
+		case j.stopped() && !wasStopped:
+			addJob(j) // the current job now
+			if notify {
+				fmt.Fprintln(os.Stderr, j.describe("Stopped"))
+			}
+		}
+	}
+}
+
+// findJob returns the job for a job spec: %N or N for job N, %+, %% or nothing
+// for the current job, %- for the previous one.
+func findJob(cmd string, args []string) (*job, error) {
+	spec := "%+"
+	if len(args) > 1 {
+		spec = args[1]
+	}
+	n := len(jobTable)
+	switch spec {
+	case "%+", "%%", "%":
+		if n > 0 {
+			return jobTable[n-1], nil
+		}
+		return nil, fmt.Errorf("%s: current: no such job", cmd)
+	case "%-":
+		if n > 1 {
+			return jobTable[n-2], nil
+		}
+		return nil, fmt.Errorf("%s: previous: no such job", cmd)
+	}
+	id, err := strconv.Atoi(strings.TrimPrefix(spec, "%"))
+	if err == nil {
+		for _, j := range jobTable {
+			if j.id == id {
+				return j, nil
+			}
+		}
+	}
+	return nil, fmt.Errorf("%s: %s: no such job", cmd, sanitize(spec))
+}
+
+// continueJob sends SIGCONT to a stopped job.
+func continueJob(j *job) {
+	for _, p := range j.procs {
+		p.stopped = false
+	}
+	if j.pgid != 0 {
+		syscall.Kill(-j.pgid, syscall.SIGCONT)
+	}
+}
+
+// builtinJobs lists the jobs.
+func builtinJobs(stdout io.Writer) error {
+	for _, j := range jobTable {
+		j.wait(true)
+	}
+	for _, j := range append([]*job(nil), jobTable...) {
+		fmt.Fprintln(stdout, j.describe(j.state()))
+		if j.finished() {
+			removeJob(j)
+		}
+	}
+	return nil
+}
+
+// builtinFg continues a job in the foreground and waits for it.
+func builtinFg(args []string, stdout io.Writer) error {
+	if !jobControl {
+		return errors.New("fg: no job control")
+	}
+	j, err := findJob("fg", args)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintln(stdout, sanitize(j.text))
+
+	if j.pgid != 0 {
+		shellTTY, _ = readline.GetState(ttyFd)
+		if j.stopped() && j.tty != nil {
+			readline.Restore(ttyFd, j.tty)
+		}
+		setForeground(j.pgid)
+	}
+	continueJob(j)
+	return waitForeground(j)
+}
+
+// builtinBg continues a stopped job in the background.
+func builtinBg(args []string, stdout io.Writer) error {
+	if !jobControl {
+		return errors.New("bg: no job control")
+	}
+	j, err := findJob("bg", args)
+	if err != nil {
+		return err
+	}
+	if !j.stopped() {
+		return fmt.Errorf("bg: job %d already in background", j.id)
+	}
+	continueJob(j)
+	addJob(j) // the current job now
+	fmt.Fprintln(stdout, j.describe("Running"))
+	return nil
+}
+
+// builtinWait waits for a job, or for all background jobs. Stopped jobs are
+// not waited for.
+func builtinWait(args []string) error {
+	jobs := append([]*job(nil), jobTable...)
+	if len(args) > 1 {
+		j, err := findJob("wait", args)
+		if err != nil {
+			return err
+		}
+		jobs = []*job{j}
+	}
+
+	var err error
+	for _, j := range jobs {
+		j.wait(false)
+		err = nil
+		if j.finished() {
+			removeJob(j)
+			err = j.result()
+		}
+	}
+	return err
+}
+
+// exitShell exits the shell, unless there are stopped jobs and the user was
+// not warned yet (like bash).
+func exitShell(code int) error {
+	if interactiveShell && hasStoppedJobs() && !exitWarned {
+		exitWarned = true
+		return errors.New("there are stopped jobs")
+	}
+	releaseTerminal()
+	os.Exit(code)
+	return nil
+}

jobs_linux_test.go

@@ -0,0 +1,182 @@
+package main
+
+import (
+	"bytes"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+	"testing"
+	"time"
+
+	"golang.org/x/sys/unix"
+)
+
+// openPty opens a new pseudo terminal and returns the master and slave side.
+func openPty(t *testing.T) (*os.File, *os.File) {
+	t.Helper()
+	master, err := os.OpenFile("/dev/ptmx", os.O_RDWR, 0)
+	if err != nil {
+		t.Skipf("no pty available: %v", err)
+	}
+	if err := unix.IoctlSetPointerInt(int(master.Fd()), unix.TIOCSPTLCK, 0); err != nil {
+		t.Fatal(err)
+	}
+	n, err := unix.IoctlGetInt(int(master.Fd()), unix.TIOCGPTN)
+	if err != nil {
+		t.Fatal(err)
+	}
+	slave, err := os.OpenFile("/dev/pts/"+strconv.Itoa(n), os.O_RDWR|syscall.O_NOCTTY, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return master, slave
+}
+
+// ptyShell is the shell running on a pseudo terminal.
+type ptyShell struct {
+	t      *testing.T
+	master *os.File
+	mu     sync.Mutex
+	out    bytes.Buffer
+	cmd    *exec.Cmd
+}
+
+func startPtyShell(t *testing.T) *ptyShell {
+	bin := buildShell(t)
+	master, slave := openPty(t)
+	cmd := exec.Command(bin, "--norc")
+	cmd.Stdin, cmd.Stdout, cmd.Stderr = slave, slave, slave
+	cmd.Env = append(os.Environ(), "NO_COLOR=1")
+	// New session with the pty as controlling terminal, like a terminal
+	// emulator does
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setsid: true, Setctty: true, Ctty: 0}
+	if err := cmd.Start(); err != nil {
+		t.Fatal(err)
+	}
+	slave.Close()
+
+	s := &ptyShell{t: t, master: master, cmd: cmd}
+	go func() {
+		buf := make([]byte, 4096)
+		for {
+			n, err := master.Read(buf)
+			s.mu.Lock()
+			s.out.Write(buf[:n])
+			s.mu.Unlock()
+			if err != nil {
+				return
+			}
+		}
+	}()
+	t.Cleanup(func() {
+		cmd.Process.Kill()
+		cmd.Wait()
+		master.Close()
+	})
+	s.expect("$ ")
+	return s
+}
+
+func (s *ptyShell) send(text string) {
+	s.master.WriteString(text)
+}
+
+// expect waits until want appears in the output after the position of the
+// last match and consumes the output up to it.
+func (s *ptyShell) expect(want string) {
+	s.t.Helper()
+	deadline := time.Now().Add(5 * time.Second)
+	for time.Now().Before(deadline) {
+		s.mu.Lock()
+		out := s.out.String()
+		if i := strings.Index(out, want); i >= 0 {
+			s.out.Next(i + len(want))
+			s.mu.Unlock()
+			return
+		}
+		s.mu.Unlock()
+		time.Sleep(20 * time.Millisecond)
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.t.Fatalf("timeout waiting for %q, output:\n%s", want, s.out.String())
+}
+
+func TestJobControl(t *testing.T) {
+	s := startPtyShell(t)
+
+	// Ctrl+Z stops the foreground job, the shell gets the terminal back
+	s.send("sleep 30\n")
+	time.Sleep(300 * time.Millisecond)
+	s.send("\x1a")
+	s.expect("[1]+  Stopped                 sleep 30")
+	s.send("jobs\n")
+	s.expect("[1]+  Stopped                 sleep 30")
+
+	// bg continues it in the background
+	s.send("bg\n")
+	s.expect("[1]+  Running                 sleep 30 &")
+
+	// fg brings it back, Ctrl+C reaches only the job
+	s.send("fg %1\n")
+	s.expect("sleep 30")
+	time.Sleep(300 * time.Millisecond)
+	s.send("\x03")
+	s.send("echo status=$?\n")
+	s.expect("status=130")
+
+	// A pipeline is stopped and continued as a whole
+	s.send("sleep 30 | cat\n")
+	time.Sleep(300 * time.Millisecond)
+	s.send("\x1a")
+	s.expect("Stopped                 sleep 30 | cat")
+	s.send("fg\n")
+	time.Sleep(300 * time.Millisecond)
+	s.send("\x03")
+	s.send("echo pipeline=$?\n")
+	s.expect("pipeline=130")
+
+	// A background job that reads from the terminal is stopped (SIGTTIN),
+	// in the foreground it gets the input
+	s.send("cat &\n")
+	s.expect("[1] ")
+	time.Sleep(300 * time.Millisecond)
+	s.send("echo next\n")
+	s.expect("[1]+  Stopped                 cat")
+	s.send("fg\n")
+	time.Sleep(300 * time.Millisecond)
+	s.send("hello cat\n")
+	s.expect("hello cat\r\nhello cat")
+	s.send("\x04")
+	s.send("echo cat=$?\n")
+	s.expect("cat=0")
+
+	// Finished background jobs are reported before the next prompt
+	s.send("sleep 0.2 &\n")
+	time.Sleep(500 * time.Millisecond)
+	s.send("echo tick\n")
+	s.expect("Done                    sleep 0.2")
+
+	// exit warns about stopped jobs once
+	s.send("sleep 30\n")
+	time.Sleep(300 * time.Millisecond)
+	s.send("\x1a")
+	s.expect("Stopped")
+	s.send("exit\n")
+	s.expect("there are stopped jobs")
+	s.send("exit 0\n")
+
+	done := make(chan error, 1)
+	go func() { done <- s.cmd.Wait() }()
+	select {
+	case err := <-done:
+		if err != nil {
+			t.Errorf("shell exited with %v", err)
+		}
+	case <-time.After(5 * time.Second):
+		t.Fatal("shell did not exit")
+	}
+}

main.go

@@ -74,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
 }
@@ -699,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", "jobs", "fg", "bg", "wait", "alias", "unalias", "help"},
 	}
 }
 
@@ -723,7 +726,8 @@ func (c *shellCompleter) Do(line []rune, pos int) ([][]rune, int) {
 		// Complete commands
 		var candidates [][]rune
 		seen := make(map[string]bool)
-		for _, cmd := range append(c.commands, pathExecutables(word)...) {
+		names := append(append(append([]string(nil), c.commands...), aliasNames()...), pathExecutables(word)...)
+		for _, cmd := range names {
 			if strings.HasPrefix(cmd, word) && !seen[cmd] {
 				seen[cmd] = true
 				candidates = append(candidates, []rune(escapeWord(cmd[len(word):])+" "))
@@ -866,33 +870,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":
@@ -909,13 +928,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 {
@@ -923,30 +942,109 @@ 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.
+	// Aliases are expanded in interactive shells, also in their startup files
-	if !forceInteractive && !readline.IsTerminal(int(os.Stdin.Fd())) {
+	interactiveShell = interactiveMode
-		return runScript(os.Stdin)
+	for _, file := range startupFiles(login && !noProfile, interactiveMode && !noRC) {
+		sourceStartupFile(file)
 	}
 
+	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 {
@@ -1014,6 +1112,10 @@ func exitStatus(err error) int {
 // interactive runs the interactive shell with line editing, history and
 // completion until the user exits.
 func interactive() {
+	interactiveShell = true
+	initJobControl()
+	defer releaseTerminal()
+
 	// Ctrl+C sends SIGINT to the whole foreground process group. Catch it so
 	// that it only stops the running command and not the shell. (signal.Ignore
 	// would be inherited by the child processes.)
@@ -1044,6 +1146,9 @@ func interactive() {
 
 	// Main loop
 	for {
+		// Report finished and stopped background jobs
+		reapJobs(true)
+
 		// Update prompt dynamically (in case directory changed)
 		l.SetPrompt(getPrompt())
 		
@@ -1056,6 +1161,11 @@ func interactive() {
 			// Handle EOF (Ctrl+D)
 			if err == io.EOF {
 				fmt.Println()
+				if hasStoppedJobs() && !exitWarned {
+					exitWarned = true
+					fmt.Fprintln(os.Stderr, "gosh: there are stopped jobs")
+					continue
+				}
 				break
 			}
 			fmt.Fprintln(os.Stderr, "Error reading input:", err)
@@ -1118,9 +1228,10 @@ func printError(err error) {
 type listItem struct {
 	op         string // "", ";", "&&" or "||"
 	command    string
+	background bool // the command ends with &
 }
 
-// splitList splits input at unquoted ;, && and ||. Quotes, escapes, ${...}
+// splitList splits input at unquoted ;, &, && and ||. Quotes, escapes, ${...}
 // and comments are handled like in splitWords, but nothing is expanded yet:
 // that happens per command when it runs, so "cd /tmp && echo $PWD" works.
 func splitList(input string) ([]listItem, error) {
@@ -1180,6 +1291,17 @@ scan:
 		case ch == '#' && isWordStart:
 			end = i
 			break scan
+		case ch == '&' && !(i+1 < len(input) && strings.IndexByte("&>", input[i+1]) >= 0) &&
+			!(i > 0 && strings.IndexByte("<>", input[i-1]) >= 0):
+			// A single & (not &&, &>, >& or <&) runs the command in the
+			// background
+			if err := add(i, "&"); err != nil {
+				return nil, err
+			}
+			items[len(items)-1].background = true
+			op = ";"
+			start = i + 1
+			wordStart = true
 		case ch == ';',
 			ch == '&' && i+1 < len(input) && input[i+1] == '&',
 			ch == '|' && i+1 < len(input) && input[i+1] == '|':
@@ -1208,6 +1330,9 @@ scan:
 // and ||. It returns the error of the last command that was run; errors of
 // earlier commands are printed. $? is updated after each command.
 func execInput(input string) error {
+	if interactiveShell {
+		input = expandAliases(input)
+	}
 	items, err := splitList(input)
 	if err != nil {
 		lastStatus = exitStatus(err)
@@ -1220,14 +1345,15 @@ func execInput(input string) error {
 			continue
 		}
 		printError(lastErr)
-		lastErr = execCommand(item.command)
+		lastErr = execCommand(item.command, item.background)
 		lastStatus = exitStatus(lastErr)
 	}
 	return lastErr
 }
 
-// execCommand executes a pipeline of simple commands with redirections.
+// execCommand executes a pipeline of simple commands with redirections, in
-func execCommand(input string) error {
+// the background if background is set.
+func execCommand(input string, background bool) error {
 	// Split the input into words and operators, expanding variables and ~ on
 	// the way.
 	tokens, err := tokenize(input)
@@ -1245,7 +1371,11 @@ func execCommand(input string) error {
 	if len(stages) == 0 {
 		return nil
 	}
-	return runPipeline(stages)
+	// "exit" with stopped jobs only warns, unless it is repeated right away
+	if name := stages[0].args; len(name) == 0 || (name[0] != "exit" && name[0] != "quit") {
+		exitWarned = false
+	}
+	return runPipeline(stages, strings.TrimSpace(input), background)
 }
 
 // redirect is a redirection of a simple command, e.g. 2>>file or 2>&1.
@@ -1308,49 +1438,71 @@ func parsePipeline(tokens []token) ([]stage, error) {
 	return append(stages, cur), nil
 }
 
-// runPipeline runs the stages of a pipeline concurrently, connecting the
+// runPipeline runs the stages of a pipeline concurrently as a job,
-// stdout of each stage to the stdin of the next one. It returns the error of
+// connecting the stdout of each stage to the stdin of the next one. In the
-// the last stage (so $? is its exit status, like in sh); errors of the other
+// foreground it waits for the job and returns the error of the last stage (so
-// stages are printed.
+// $? is its exit status, like in sh); errors of the other stages are printed.
-func runPipeline(stages []stage) error {
+// In the background it adds the job to the job table and returns nil.
-	waits := make([]func() error, len(stages))
+func runPipeline(stages []stage, text string, background bool) error {
+	j := &job{text: text}
+	if jobControl && !background {
+		shellTTY, _ = readline.GetState(ttyFd)
+	}
+
 	stdin := os.Stdin
+	if background && !jobControl {
+		// Without job control background jobs must not read from the
+		// terminal, like in sh
+		if devNull, err := os.Open(os.DevNull); err == nil {
+			stdin = devNull
+		}
+	}
+	var startErr error
 	for i, st := range stages {
 		stdout := os.Stdout
 		var next *os.File
 		if i < len(stages)-1 {
 			r, w, err := os.Pipe()
 			if err != nil {
-				// Let the stages that already run finish
 				if stdin != os.Stdin {
 					stdin.Close()
 				}
-				for _, wait := range waits[:i] {
+				startErr = err
-					printError(wait())
+				break
-				}
-				return err
 			}
 			stdout, next = w, r
 		}
-		waits[i] = startStage(st, stdin, stdout, len(stages) > 1)
+		j.procs = append(j.procs, startStage(st, stdin, stdout, j, len(stages) > 1, background))
 		stdin = next
 	}
-
+	if startErr != nil {
-	var err error
+		// Let the stages that already run finish
-	for i, wait := range waits {
+		if len(j.procs) > 0 {
-		err = wait()
+			waitForeground(j)
-		if i < len(waits)-1 {
-			printError(err)
 		}
-	}
+		return startErr
-	return err
 	}
 
-// startStage starts a stage of a pipeline with the given stdin and stdout and
+	if background {
-// returns a function that waits for it to finish. Pipe ends passed in are
+		addJob(j)
-// closed by startStage once the stage no longer needs them, so that the
+		if interactiveShell {
-// neighbors see EOF or get SIGPIPE.
+			pid := 0
-func startStage(st stage, stdin, stdout *os.File, inPipeline bool) func() error {
+			for _, p := range j.procs {
+				if p.cmd != nil {
+					pid = p.cmd.Process.Pid
+				}
+			}
+			fmt.Fprintf(os.Stderr, "[%d] %d\n", j.id, pid)
+		}
+		return nil
+	}
+	return waitForeground(j)
+}
+
+// startStage starts a stage of the pipeline of job j with the given stdin and
+// stdout. Pipe ends passed in are closed by startStage once the stage no
+// longer needs them, so that the neighbors see EOF or get SIGPIPE.
+func startStage(st stage, stdin, stdout *os.File, j *job, inPipeline, background bool) *proc {
 	var owned []*os.File
 	if stdin != os.Stdin {
 		owned = append(owned, stdin)
@@ -1363,9 +1515,6 @@ func startStage(st stage, stdin, stdout *os.File, inPipeline bool) func() error
 			f.Close()
 		}
 	}
-	result := func(err error) func() error {
-		return func() error { return err }
-	}
 
 	// Connect the command to the terminal unless redirected. Without Stdin
 	// the command would read from /dev/null, so interactive programs (su,
@@ -1377,13 +1526,17 @@ func startStage(st stage, stdin, stdout *os.File, inPipeline bool) func() error
 	if err != nil || len(st.args) == 0 {
 		// A command without arguments only creates or truncates the files
 		closeOwned()
-		return result(err)
+		return finishedProc(err)
 	}
 
 	if builtin, ok := builtins[st.args[0]]; ok {
-		if inPipeline && builtin.changesState {
+		switch {
+		case inPipeline && builtin.changesState:
 			closeOwned()
-			return result(fmt.Errorf("%s: cannot be used in a pipeline", st.args[0]))
+			return finishedProc(fmt.Errorf("%s: cannot be used in a pipeline", st.args[0]))
+		case background && builtin.changesState:
+			closeOwned()
+			return finishedProc(fmt.Errorf("%s: cannot be run in the background", st.args[0]))
 		}
 		run := func() error {
 			defer closeOwned()
@@ -1395,16 +1548,29 @@ func startStage(st stage, stdin, stdout *os.File, inPipeline bool) func() error
 			}
 			return err
 		}
-		if !inPipeline {
+		if !inPipeline && !background {
-			return result(run())
+			return finishedProc(run())
 		}
-		done := make(chan error, 1)
+		p := &proc{done: make(chan error, 1)}
-		go func() { done <- run() }()
+		go func() { p.done <- run() }()
-		return func() error { return <-done }
+		return p
 	}
 
 	cmd := exec.Command(st.args[0], st.args[1:]...)
 	cmd.Stdin, cmd.Stdout, cmd.Stderr = fds[0], fds[1], fds[2]
+	if jobControl {
+		// All processes of the job share a process group: the one of the
+		// first process. In the foreground, the first process makes its
+		// group the foreground group of the terminal before it starts the
+		// program, so that it can use the terminal right away.
+		attr := &syscall.SysProcAttr{Setpgid: true, Pgid: j.pgid}
+		if j.pgid == 0 && !background {
+			if ctty := ttyIndex(fds); ctty >= 0 {
+				attr.Foreground, attr.Ctty = true, ctty
+			}
+		}
+		cmd.SysProcAttr = attr
+	}
 	err = cmd.Start()
 	// The child has its own copies of the files now
 	closeOwned()
@@ -1412,9 +1578,16 @@ func startStage(st stage, stdin, stdout *os.File, inPipeline bool) func() error
 		err = fmt.Errorf("%s: %w", sanitize(st.args[0]), errCommandNotFound)
 	}
 	if err != nil {
-		return result(err)
+		return finishedProc(err)
 	}
-	return cmd.Wait
+	if jobControl && j.pgid == 0 {
+		j.pgid = cmd.Process.Pid
+		if !background {
+			// In case the process could not do it (no terminal in fds)
+			setForeground(j.pgid)
+		}
+	}
+	return &proc{cmd: cmd}
 }
 
 // applyRedirects applies the redirections in order to fds (stdin, stdout,
@@ -1476,6 +1649,14 @@ var builtins = map[string]struct{ changesState bool }{
 	"set":     {changesState: true},
 	"export":  {changesState: true},
 	"help":    {},
+	"source":  {changesState: true},
+	".":       {changesState: true},
+	"jobs":    {},
+	"fg":      {changesState: true},
+	"bg":      {changesState: true},
+	"wait":    {changesState: true},
+	"alias":   {},
+	"unalias": {changesState: true},
 }
 
 // runBuiltin executes a built-in command, writing its output to stdout.
@@ -1520,17 +1701,17 @@ func runBuiltin(args []string, stdout io.Writer) error {
 		if len(args) > 1 {
 			var exitCode int
 			fmt.Sscanf(args[1], "%d", &exitCode)
-			os.Exit(exitCode)
+			return exitShell(exitCode)
 		}
-		os.Exit(lastStatus)
+		return exitShell(lastStatus)
 	case "quit":
 		// quit with optional status code
 		if len(args) > 1 {
 			var exitCode int
 			fmt.Sscanf(args[1], "%d", &exitCode)
-			os.Exit(exitCode)
+			return exitShell(exitCode)
 		}
-		os.Exit(lastStatus)
+		return exitShell(lastStatus)
 	case "set":
 		// set VAR=value - set environment variable
 		if len(args) < 2 {
@@ -1555,6 +1736,24 @@ func runBuiltin(args []string, stdout io.Writer) error {
 		}
 		os.Setenv(parts[0], parts[1])
 		return nil
+	case "alias":
+		return builtinAlias(args, stdout)
+	case "unalias":
+		return builtinUnalias(args)
+	case "jobs":
+		return builtinJobs(stdout)
+	case "fg":
+		return builtinFg(args, stdout)
+	case "bg":
+		return builtinBg(args, stdout)
+	case "wait":
+		return builtinWait(args)
+	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() + `
 
@@ -1566,6 +1765,13 @@ 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)
+  jobs          - List background and stopped jobs
+  fg [%n]       - Continue job n (default: current job) in the foreground
+  bg [%n]       - Continue stopped job n in the background
+  wait [%n]     - Wait for job n or all background jobs
+  alias [name[=value] ...] - Define or show aliases (alias ll='ls -l')
+  unalias name  - Remove an alias (unalias -a: all aliases)
   help          - Show this help
 
 Features:
@@ -1590,8 +1796,15 @@ Features:
     a || b (b only if a failed); $? is the exit status of the last command
   - Pipes (a | b) and redirections: < file, > file, >> file, 2> file,
     2>> file, 2>&1, >&2, &> file (stdout and stderr), &>> file
+  - Job control: command & runs in the background, Ctrl+Z stops the
+    foreground job; jobs, fg, bg and wait manage the jobs
+  - Aliases replace the first word of a command in interactive shells
+    (define them in ~/.goshrc); \name or 'name' skips the alias
   - 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

@@ -226,7 +226,7 @@ func TestShell_EndToEnd(t *testing.T) {
 
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			cmd := exec.Command("go", "run", "main.go")
+			cmd := exec.Command("go", "run", ".")
 			cmd.Stdin = strings.NewReader(tc.input)
 			var stdout, stderr bytes.Buffer
 			cmd.Stdout = &stdout
@@ -259,7 +259,7 @@ func TestShell_EOF_ExitsGracefully(t *testing.T) {
 	// Simulate EOF by sending empty input
 	// Note: When using piped input, readline doesn't print prompts
 	// So we just verify the shell exits cleanly
-	cmd := exec.Command("go", "run", "main.go")
+	cmd := exec.Command("go", "run", ".")
 	cmd.Stdin = strings.NewReader("")
 	var stdout, stderr bytes.Buffer
 	cmd.Stdout = &stdout
@@ -278,7 +278,7 @@ func TestShell_EOF_ExitsGracefully(t *testing.T) {
 func TestShell_EOF_AfterCommand(t *testing.T) {
 	// Test that EOF after a command works
 	// Note: When using piped input, readline doesn't print prompts
-	cmd := exec.Command("go", "run", "main.go")
+	cmd := exec.Command("go", "run", ".")
 	cmd.Stdin = strings.NewReader("echo test\n")
 	var stdout, stderr bytes.Buffer
 	cmd.Stdout = &stdout
@@ -302,7 +302,7 @@ func TestShell_SIGINT_HandlerSetup(t *testing.T) {
 	// This test verifies that the shell doesn't panic when receiving signals
 	// We can't easily test SIGINT handling from a test, but we can verify
 	// the shell runs without crashing
-	cmd := exec.Command("go", "run", "main.go")
+	cmd := exec.Command("go", "run", ".")
 	cmd.Stdin = strings.NewReader("echo test\nquit\n")
 	var stdout, stderr bytes.Buffer
 	cmd.Stdout = &stdout
@@ -458,7 +458,7 @@ func TestShell_ExitWithStatusCode(t *testing.T) {
 	}
 	
 	// Build the binary once
-	build := exec.Command("go", "build", "-o", "gosh_test", "main.go")
+	build := exec.Command("go", "build", "-o", "gosh_test", ".")
 	if err := build.Run(); err != nil {
 		t.Fatalf("failed to build: %v", err)
 	}
@@ -494,7 +494,7 @@ func TestShell_ExitWithStatusCode(t *testing.T) {
 // =============================================================================
 
 func TestShell_EnvExpansion_Home(t *testing.T) {
-	cmd := exec.Command("go", "run", "main.go")
+	cmd := exec.Command("go", "run", ".")
 	cmd.Stdin = strings.NewReader("echo $HOME\nexit\n")
 	var stdout, stderr bytes.Buffer
 	cmd.Stdout = &stdout
@@ -513,7 +513,7 @@ func TestShell_EnvExpansion_Home(t *testing.T) {
 }
 
 func TestShell_EnvExpansion_Path(t *testing.T) {
-	cmd := exec.Command("go", "run", "main.go")
+	cmd := exec.Command("go", "run", ".")
 	cmd.Stdin = strings.NewReader("echo $PATH\nexit\n")
 	var stdout, stderr bytes.Buffer
 	cmd.Stdout = &stdout
@@ -532,7 +532,7 @@ func TestShell_EnvExpansion_Path(t *testing.T) {
 }
 
 func TestShell_EnvExpansion_Braces(t *testing.T) {
-	cmd := exec.Command("go", "run", "main.go")
+	cmd := exec.Command("go", "run", ".")
 	cmd.Stdin = strings.NewReader("echo ${HOME}\nexit\n")
 	var stdout, stderr bytes.Buffer
 	cmd.Stdout = &stdout
@@ -551,7 +551,7 @@ func TestShell_EnvExpansion_Braces(t *testing.T) {
 }
 
 func TestShell_EnvExpansion_CdWithVar(t *testing.T) {
-	cmd := exec.Command("go", "run", "main.go")
+	cmd := exec.Command("go", "run", ".")
 	cmd.Stdin = strings.NewReader("cd $HOME\npwd\nexit\n")
 	var stdout, stderr bytes.Buffer
 	cmd.Stdout = &stdout
@@ -570,7 +570,7 @@ func TestShell_EnvExpansion_CdWithVar(t *testing.T) {
 }
 
 func TestShell_TildeExpansion_Ls(t *testing.T) {
-	cmd := exec.Command("go", "run", "main.go")
+	cmd := exec.Command("go", "run", ".")
 	cmd.Stdin = strings.NewReader("ls ~\nexit\n")
 	var stdout, stderr bytes.Buffer
 	cmd.Stdout = &stdout
@@ -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},
@@ -1366,16 +1369,23 @@ func TestSplitList(t *testing.T) {
 		{"", nil},
 		{"   ", nil},
 		{"# only a comment", nil},
-		{"ls", []listItem{{"", "ls"}}},
+		{"ls", []listItem{{"", "ls", false}}},
-		{"a; b", []listItem{{"", "a"}, {";", " b"}}},
+		{"a; b", []listItem{{"", "a", false}, {";", " b", false}}},
-		{"a;", []listItem{{"", "a"}}},
+		{"a;", []listItem{{"", "a", false}}},
-		{"a && b || c", []listItem{{"", "a "}, {"&&", " b "}, {"||", " c"}}},
+		{"a && b || c", []listItem{{"", "a ", false}, {"&&", " b ", false}, {"||", " c", false}}},
-		{`echo "a;b" 'c&&d' e\;f`, []listItem{{"", `echo "a;b" 'c&&d' e\;f`}}},
+		{`echo "a;b" 'c&&d' e\;f`, []listItem{{"", `echo "a;b" 'c&&d' e\;f`, false}}},
-		{`echo "x\"; y"`, []listItem{{"", `echo "x\"; y"`}}},
+		{`echo "x\"; y"`, []listItem{{"", `echo "x\"; y"`, false}}},
-		{"echo ${X:-a;b}; c", []listItem{{"", "echo ${X:-a;b}"}, {";", " c"}}},
+		{"echo ${X:-a;b}; c", []listItem{{"", "echo ${X:-a;b}", false}, {";", " c", false}}},
-		{"echo a # b; c", []listItem{{"", "echo a "}}},
+		{"echo a # b; c", []listItem{{"", "echo a ", false}}},
-		{"echo a#b; c", []listItem{{"", "echo a#b"}, {";", " c"}}},
+		{"echo a#b; c", []listItem{{"", "echo a#b", false}, {";", " c", false}}},
-		{"echo a|b", []listItem{{"", "echo a|b"}}},
+		{"echo a|b", []listItem{{"", "echo a|b", false}}},
+		{"a & b", []listItem{{"", "a ", true}, {";", " b", false}}},
+		{"a &", []listItem{{"", "a ", true}}},
+		{"a&", []listItem{{"", "a", true}}},
+		{"a 2>&1 &", []listItem{{"", "a 2>&1 ", true}}},
+		{"a &> f &", []listItem{{"", "a &> f ", true}}},
+		{"a >&2 && b", []listItem{{"", "a >&2 ", false}, {"&&", " b", false}}},
+		{`echo "a & b" \&`, []listItem{{"", `echo "a & b" \&`, false}}},
 	}
 	for _, tc := range tests {
 		got, err := splitList(tc.input)
@@ -1384,13 +1394,13 @@ func TestSplitList(t *testing.T) {
 			continue
 		}
 		if !reflect.DeepEqual(got, tc.want) {
-			t.Errorf("splitList(%q) = %q, want %q", tc.input, got, tc.want)
+			t.Errorf("splitList(%q) = %+v, want %+v", tc.input, got, tc.want)
 		}
 	}
 }
 
 func TestSplitList_SyntaxErrors(t *testing.T) {
-	for _, input := range []string{"; a", "a ;; b", "&& a", "a &&", "a ||", "a && ; b", "a || && b"} {
+	for _, input := range []string{"; a", "a ;; b", "&& a", "a &&", "a ||", "a && ; b", "a || && b", "& a", "a & && b", "a & & b"} {
 		if _, err := splitList(input); err == nil || !strings.Contains(err.Error(), "syntax error") {
 			t.Errorf("splitList(%q) = %v, want syntax error", input, err)
 		}
@@ -1730,3 +1740,197 @@ func TestExecInput_Wildcards(t *testing.T) {
 		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")
+	}
+}
+
+func TestExecInput_Background(t *testing.T) {
+	origDir, _ := os.Getwd()
+	defer os.Chdir(origDir)
+	dir := t.TempDir()
+	os.Chdir(dir)
+
+	// The shell does not wait for a background job, wait does
+	start := time.Now()
+	if err := execInput("sh -c 'sleep 0.3; echo done > out' &"); err != nil {
+		t.Fatal(err)
+	}
+	if lastStatus != 0 {
+		t.Errorf("$? = %d after starting a background job, want 0", lastStatus)
+	}
+	if time.Since(start) > 200*time.Millisecond {
+		t.Error("the shell waited for the background job")
+	}
+	if _, err := os.Stat("out"); err == nil {
+		t.Error("background job finished too early")
+	}
+	if err := execInput("wait"); err != nil {
+		t.Fatal(err)
+	}
+	if got, _ := os.ReadFile("out"); string(got) != "done\n" {
+		t.Errorf("out = %q after wait", got)
+	}
+	if len(jobTable) != 0 {
+		t.Errorf("job table not empty after wait: %d jobs", len(jobTable))
+	}
+
+	// wait %n returns the status of the job
+	execInput("sh -c 'exit 3' &")
+	execInput("wait %1")
+	if lastStatus != 3 {
+		t.Errorf("$? = %d after wait %%1, want 3", lastStatus)
+	}
+
+	// Without job control, background jobs read from /dev/null
+	execInput("cat > stdin.txt &")
+	execInput("wait")
+	if got, err := os.ReadFile("stdin.txt"); err != nil || len(got) != 0 {
+		t.Errorf("background job read %q, %v from stdin", got, err)
+	}
+
+	// jobs lists running jobs, also into a redirection
+	execInput("sleep 0.3 &")
+	execInput("jobs > jobs.txt")
+	if got, _ := os.ReadFile("jobs.txt"); !strings.Contains(string(got), "Running                 sleep 0.3 &") {
+		t.Errorf("jobs output = %q", got)
+	}
+	execInput("wait")
+
+	// Builtins that change the shell cannot run in the background
+	if err := execInput("cd / &"); err != nil {
+		t.Fatal(err)
+	}
+	execInput("wait %1")
+	if wd, _ := os.Getwd(); wd != dir {
+		t.Errorf("cd in the background changed the directory to %s", wd)
+	}
+
+	// fg and bg need job control
+	for _, cmd := range []string{"fg", "bg"} {
+		if err := execInput(cmd); err == nil || err.Error() != cmd+": no job control" {
+			t.Errorf("%s without job control: %v", cmd, err)
+		}
+	}
+	if err := execInput("wait %9"); err == nil || err.Error() != "wait: %9: no such job" {
+		t.Errorf("wait %%9: %v", err)
+	}
+}