add job control

- in an interactive shell every pipeline runs in its own process group and gets the terminal while it runs in the foreground - Ctrl+Z stops the foreground job, command & starts a job in the background; finished and stopped jobs are reported before the prompt - new builtins jobs, fg, bg and wait (wait also works without job control, e.g. in scripts, where background jobs read from /dev/null) - terminal modes are saved and restored when a job stops or continues - exit and Ctrl+D warn once if there are stopped jobs - processes are waited for with wait4 (WUNTRACED) instead of exec.Cmd.Wait - pty based test for job control (Linux) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
add startup files and the source builtin
2026-10-03 23:22:21 +02:00 · 2026-10-03 23:08:23 +02:00 · 2026-10-03 20:44:58 +02:00 · 2026-10-03 20:39:38 +02:00
6 changed files with 2112 additions and 105 deletions
@@ -12,6 +12,11 @@ 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
  help          - Show this help
 Features:
@@ -23,6 +28,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);
@@ -31,16 +39,23 @@ Features:
    using an unset variable is an error, use ${VAR:-} for an empty default
  - Command lists: a ; b (run both), a && b (b only if a succeeded),
    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
  - 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
 ```
@@ -51,11 +66,49 @@ 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 (z. B. `ssh host 'cd /srv && git pull'`), Pipes und Umleitungen kennt gosh aber noch nicht.
+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
@@ -81,6 +134,94 @@ 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
 ```
 $ ls | sort -r | head -3
 $ make > build.log 2>&1
 $ grep -c error < build.log
 ```
 | Syntax          | Bedeutung                                                  |
 |-----------------|------------------------------------------------------------|
 | `a \| b`        | stdout von `a` wird stdin von `b`                          |
 | `< datei`       | stdin aus `datei` lesen                                    |
 | `> datei`       | stdout in `datei` schreiben (wird überschrieben)           |
 | `>> datei`      | stdout an `datei` anhängen                                 |
 | `2> datei`      | stderr in `datei` schreiben (`2>>` hängt an)               |
 | `2>&1`          | stderr dorthin, wohin stdout gerade geht                   |
 | `>&2`           | stdout dorthin, wohin stderr gerade geht                   |
 | `&> datei`      | stdout und stderr in `datei` (`&>>` hängt an)              |
 | `> datei`       | ohne Befehl: legt `datei` an bzw. leert sie                |
 - Umleitungen werden von links nach rechts ausgewertet: `befehl > log 2>&1` schreibt beides in `log`, `befehl 2>&1 > log` schickt stderr dorthin, wo stdout vorher hinging (z. B. in eine Pipe).
 - Unterstützt werden die Dateideskriptoren 0, 1 und 2. Vor `>` und `<` zählt nur eine Zahl ohne Anführungszeichen als Deskriptor (`2>f`, aber nicht `x2>f` oder `"2">f`).
 - 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.
 ### 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
 Der Prompt wird über die Umgebungsvariable `GOSH_COLORS` eingefärbt. Sie besteht aus durch `:` getrennten Einträgen `schlüssel=code`:
@@ -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
@@ -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
 }
@@ -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")
 	}
 }
@@ -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
@@ -859,6 +859,15 @@ func TestShellCompleter_Do(t *testing.T) {
 		{"ls " + tmpDir + "/ma", []string{"in.go"}, 2},
 		{"ls xyz", nil, 3},
 		{"ls ~", []string{"/"}, 1},
 		// Commands are completed after |, ;, && and ||, files after redirections
 		{"ls | gi", []string{"tty "}, 2},
 		{"ls|gi", []string{"tty "}, 2},
 		{"true; gi", []string{"tty "}, 2},
 		{"true && gi", []string{"tty "}, 2},
 		{"false || gi", []string{"tty "}, 2},
 		{"ls > ma", []string{"in.go"}, 2},
 		{"ls 2>ma", []string{"in.go"}, 2},
 		{"cat <ma", []string{"in.go"}, 2},
 	}
 	for _, tt := range tests {
 		got, length := completeLine(tt.line)
@@ -880,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)
@@ -1174,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")
@@ -1206,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()
@@ -1304,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"} {
@@ -1314,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)
 	}
 }
@@ -1326,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},
@@ -1357,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)
@@ -1375,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)
 		}
@@ -1471,3 +1490,447 @@ func TestExecInput_CommandNotFound(t *testing.T) {
 		t.Errorf("$? = %d, want 127", lastStatus)
 	}
 }
 func TestTokenize_Operators(t *testing.T) {
 	tests := []struct {
 		input string
 		want  []token
 	}{
 		{"a | b", []token{{word: "a"}, {op: "|"}, {word: "b"}}},
 		{"a|b", []token{{word: "a"}, {op: "|"}, {word: "b"}}},
 		{"a > f", []token{{word: "a"}, {op: ">", fd: 1}, {word: "f"}}},
 		{"a >>f", []token{{word: "a"}, {op: ">>", fd: 1}, {word: "f"}}},
 		{"a < f", []token{{word: "a"}, {op: "<", fd: 0}, {word: "f"}}},
 		{"a 2>f", []token{{word: "a"}, {op: ">", fd: 2}, {word: "f"}}},
 		{"a 2>>f", []token{{word: "a"}, {op: ">>", fd: 2}, {word: "f"}}},
 		{"a 2>&1", []token{{word: "a"}, {op: ">&", fd: 2, dup: 1}}},
 		{"a >&2", []token{{word: "a"}, {op: ">&", fd: 1, dup: 2}}},
 		{"a 0<&2", []token{{word: "a"}, {op: "<&", fd: 0, dup: 2}}},
 		{"a &>f", []token{{word: "a"}, {op: "&>", fd: 1}, {word: "f"}}},
 		{"a &>>f", []token{{word: "a"}, {op: "&>>", fd: 1}, {word: "f"}}},
 		// Only a word of unquoted digits is a file descriptor
 		{"a x2>f", []token{{word: "a"}, {word: "x2"}, {op: ">", fd: 1}, {word: "f"}}},
 		{`a "2">f`, []token{{word: "a"}, {word: "2"}, {op: ">", fd: 1}, {word: "f"}}},
 		{"a 2 >f", []token{{word: "a"}, {word: "2"}, {op: ">", fd: 1}, {word: "f"}}},
 		// Quoted and escaped operators are words
 		{`echo "a|b" 'c>d' e\<f`, []token{{word: "echo"}, {word: "a|b"}, {word: "c>d"}, {word: "e<f"}}},
 		// A lone & is a word
 		{"a & b", []token{{word: "a"}, {word: "&"}, {word: "b"}}},
 		{"cat ~|x", []token{{word: "cat"}, {word: getHomeDir()}, {op: "|"}, {word: "x"}}},
 	}
 	for _, tc := range tests {
 		got, err := tokenize(tc.input)
 		if err != nil {
 			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)
 		}
 	}
 }
 func TestExecInput_SyntaxErrors(t *testing.T) {
 	for _, input := range []string{"echo a |", "| echo a", "echo a | | b", "echo a >", "echo a > | b", "echo a >&", "echo a 2>&x", "; a"} {
 		err := execInput(input)
 		if err == nil || !strings.Contains(err.Error(), "syntax error") {
 			t.Errorf("execInput(%q) = %v, want syntax error", input, err)
 		}
 		if lastStatus != 2 {
 			t.Errorf("execInput(%q): $? = %d, want 2", input, lastStatus)
 		}
 	}
 }
 func TestExecInput_PipesAndRedirections(t *testing.T) {
 	origDir, _ := os.Getwd()
 	defer os.Chdir(origDir)
 	dir := t.TempDir()
 	os.Chdir(dir)
 	read := func(name string) string {
 		data, err := os.ReadFile(filepath.Join(dir, name))
 		if err != nil {
 			t.Errorf("reading %s: %v", name, err)
 		}
 		return string(data)
 	}
 	tests := []struct {
 		input  string
 		file   string
 		want   string
 		status int
 	}{
 		{`printf 'b\na\nc\n' | sort | head -n 2 > out`, "out", "a\nb\n", 0},
 		{"echo one > f1; echo two >> f1", "f1", "one\ntwo\n", 0},
 		{"echo one > f2; echo two > f2", "f2", "two\n", 0},
 		{"tr a-z A-Z < f1 > f3", "f3", "ONE\nTWO\n", 0},
 		{"sh -c 'echo out; echo err >&2' > f4 2>&1", "f4", "out\nerr\n", 0},
 		{"sh -c 'echo out; echo err >&2' &> f5", "f5", "out\nerr\n", 0},
 		{"sh -c 'echo err >&2' 2> f6", "f6", "err\n", 0},
 		// 2>&1 before >file sends stderr to the old stdout (the pipe)
 		{"sh -c 'echo out; echo err >&2' 2>&1 > /dev/null | cat > f7", "f7", "err\n", 0},
 		{"sh -c 'echo err >&2' 2>&1 | tr a-z A-Z > f8", "f8", "ERR\n", 0},
 		// Builtins write to redirections and pipes
 		{"pwd > f9", "f9", dir + "\n", 0},
 		{"pwd | cat > f10", "f10", dir + "\n", 0},
 		{"help | head -n 1 > f11", "f11", "gosh - Go Shell\n", 0},
 		// Errors of builtins go to the redirected stderr
 		{"cd /gosh/no/such/dir 2> f12", "f12", "gosh: chdir /gosh/no/such/dir: no such file or directory\n", 1},
 		// The status of a pipeline is the one of the last command
 		{"false | true > f13", "f13", "", 0},
 		{"true | false > f14", "f14", "", 1},
 		// A redirection without a command creates the file
 		{"> f15", "f15", "", 0},
 		// SIGPIPE ends the writer when the reader exits
 		{"yes | head -n 1 > f16", "f16", "y\n", 0},
 		// A command that is not found does not stop the pipeline
 		{"gosh-no-such-command | echo after > f17", "f17", "after\n", 0},
 		{"echo before | gosh-no-such-command 2> f18", "f18", "", 127},
 	}
 	for _, tc := range tests {
 		execInput(tc.input)
 		if lastStatus != tc.status {
 			t.Errorf("%q: $? = %d, want %d", tc.input, lastStatus, tc.status)
 		}
 		if got := read(tc.file); got != tc.want {
 			t.Errorf("%q: %s = %q, want %q", tc.input, tc.file, got, tc.want)
 		}
 	}
 }
 func TestExecInput_RedirectionErrors(t *testing.T) {
 	origDir, _ := os.Getwd()
 	defer os.Chdir(origDir)
 	os.Chdir(t.TempDir())
 	tests := []struct {
 		input   string
 		wantErr string
 	}{
 		{"cat < gosh-no-such-file", "gosh-no-such-file: no such file or directory"},
 		{"echo a > gosh-no-such-dir/f", "gosh-no-such-dir/f: no such file or directory"},
 		{"echo a 3> f", "3: bad file descriptor"},
 		{"echo a 2>&5", "5: bad file descriptor"},
 		{"echo a | cd /", "cd: cannot be used in a pipeline"},
 		{"echo a | exit 3", "exit: cannot be used in a pipeline"},
 	}
 	for _, tc := range tests {
 		err := execInput(tc.input)
 		if err == nil || err.Error() != tc.wantErr {
 			t.Errorf("execInput(%q) = %v, want %q", tc.input, err, tc.wantErr)
 		}
 		if lastStatus != 1 {
 			t.Errorf("execInput(%q): $? = %d, want 1", tc.input, lastStatus)
 		}
 	}
 	// The command is not run if a redirection fails
 	if _, err := os.Stat("f"); err == nil {
 		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")
 	}
 }
 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)
 	}
 }
Author	SHA1	Message	Date
Florian WaltherandClaude Opus 5.5	dae4087a94	add job control - in an interactive shell every pipeline runs in its own process group and gets the terminal while it runs in the foreground - Ctrl+Z stops the foreground job, command & starts a job in the background; finished and stopped jobs are reported before the prompt - new builtins jobs, fg, bg and wait (wait also works without job control, e.g. in scripts, where background jobs read from /dev/null) - terminal modes are saved and restored when a job stops or continues - exit and Ctrl+D warn once if there are stopped jobs - processes are waited for with wait4 (WUNTRACED) instead of exec.Cmd.Wait - pty based test for job control (Linux) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-03 23:22:21 +02:00
Florian WaltherandClaude Opus 5.5	4b44cc6e72	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>	2026-10-03 23:08:23 +02:00
Florian WaltherandClaude Opus 5.5	1182d8d146	add wildcards (, ?, [...]) - unquoted ? and [...] (including [!...]) are expanded to the matching file names, sorted, per path component - hidden files only match if the pattern starts with a dot, a trailing / only matches directories, a pattern without match is kept as is - quoted or escaped characters and values of variables are never expanded - redirections to a pattern must match exactly one file - completion escapes * ? [ and $ in file names Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-03 20:44:58 +02:00
Florian WaltherandClaude Opus 5.5	c46903e3d2	add pipes and redirections - tokenizer recognizes unquoted \|, <, >, >>, N>, N>>, N>&M, N<&M, &> and &>>; only a word of unquoted digits is a file descriptor - pipelines run concurrently, the status is the one of the last command, errors of earlier stages are printed - redirections are applied left to right (fds 0-2), a redirection without a command creates/truncates the file - pwd and help can be redirected and piped; cd, set, export, exit and quit are rejected in pipelines - syntax errors have exit status 2 - completion: commands after \|, ;, && and \|\|, files after redirections; operator characters are escaped in completed names Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-03 20:39:38 +02:00