Fix EXIT trap not firing when ERR_EXIT or ${var:?} triggers inside a function

When ERR_EXIT triggers inside a function, the errexit code path
called realexit() directly, bypassing endtrapscope() and skipping
any EXIT traps saved by starttrapscope() on function entry.

Similarly, when ${var:?message} triggers inside a function, the
paramsubst code path called _exit(1) or zexit() directly,
bypassing the function unwind and skipping EXIT traps at outer
scopes.

Reuse the same exit_pending unwind mechanism as the exit builtin,
so that endtrapscope() runs at each function level and all nested
EXIT traps are executed bottom-up, matching the behaviour of an
explicit exit call.

Extract set_exit_pending() to consolidate the repeated unwind
setup (trap_state, retflag, breaks, exit_pending, exit_level,
exit_val) used by the exit builtin, the ERR_EXIT handler, and
the new ${var:?} handler.

Extract restore_saved_trap() from endtrapscope() to reduce
duplication in the trap restoration logic.

Clear errflag in endtrapscope() when exit_pending, so that
EXIT traps can fire even when the exit was triggered by an error
(e.g. ${var:?}).  This mirrors what zexit() already does before
calling dotrap(SIGEXIT).

Author: tmoschou

README

@@ -56,6 +56,17 @@ The ERR_EXIT and ERR_RETURN options were refined to be more self-
 consistent and better aligned with the POSIX-2017 specification of
 `set -e`:
 
+  - The EXIT trap is now correctly executed when ERR_EXIT triggers
+    inside a function.  Previously, `starttrapscope()` hid the EXIT
+    trap on function entry, and the ERR_EXIT code path called
+    `realexit()` without restoring it. Example:
+
+      setopt ERR_EXIT
+      trap 'echo exiting' EXIT
+      f() { false }
+      f
+      # "exiting" is printed only since 5.10.
+
   - Function calls or anonymous functions prefixed with `!` now never
     trigger exit or return. Negated function calls or anonymous
     functions used to trigger exit or return if ERR_EXIT or ERR_RETURN

Src/builtin.c

@@ -5823,6 +5823,25 @@ mod_export volatile int exit_pending;
 /**/
 mod_export volatile int exit_level;
 
+/*
+ * Set up exit_pending unwind: instead of exiting immediately,
+ * force all active functions to return so that endtrapscope()
+ * runs at each level and all saved EXIT traps are executed.
+ */
+
+/**/
+mod_export void
+set_exit_pending(int val)
+{
+    if (trap_state)
+	trap_state = TRAP_STATE_FORCE_RETURN;
+    retflag = 1;
+    breaks = loops;
+    exit_pending = 1;
+    exit_level = locallevel;
+    exit_val = val;
+}
+
 /* we have printed a 'you have stopped (running) jobs.' message */
 
 /**/
@@ -5905,13 +5924,7 @@ bin_break(char *name, char **argv, UNUSED(Options ops), int func)
 	     * a bad job.
 	     */
 	    if (stopmsg || (zexit(0, ZEXIT_DEFERRED), !stopmsg)) {
-		if (trap_state) 
-		    trap_state = TRAP_STATE_FORCE_RETURN;
-		retflag = 1;
-		breaks = loops;
-		exit_pending = 1;
-		exit_level = locallevel;
-		exit_val = num;
+		set_exit_pending(num);
 	    }
 	} else
 	    zexit(num, ZEXIT_NORMAL);

Src/exec.c

@@ -1616,12 +1616,22 @@ execlist(Estate state, int dont_change_job, int exiting)
 		    !(noerrexit & NOERREXIT_EXIT);
 		if (errexit) {
 		    errflag = 0;
-		    if (sigtrapped[SIGEXIT])
-			dotrap(SIGEXIT);
-		    if (mypid != getpid())
-			_realexit();
-		    else
-			realexit();
+		    if (locallevel > forklevel) {
+			/*
+			 * Inside a function: use the same unwind
+			 * mechanism as the exit builtin so that
+			 * endtrapscope() runs at each level and
+			 * all saved EXIT traps are executed.
+			 */
+			set_exit_pending(lastval);
+		    } else {
+			if (sigtrapped[SIGEXIT])
+			    dotrap(SIGEXIT);
+			if (mypid != getpid())
+			    _realexit();
+			else
+			    realexit();
+		    }
 		}
 		if (errreturn) {
 		    retflag = 1;

Src/signals.c

@@ -875,6 +875,36 @@ starttrapscope(void)
  * endparamscope() so that the locallevel has been decremented.
  */
 
+/*
+ * Restore a single saved trap entry: call settrap() to reinstall it,
+ * update sigtrapped[], and for function-style traps re-add the node
+ * to shfunctab.  Used by endtrapscope().
+ */
+
+static void
+restore_saved_trap(struct savetrap *st)
+{
+    int sig = st->sig;
+
+    dontsavetrap++;
+    if (st->flags & ZSIG_FUNC)
+	settrap(sig, NULL, ZSIG_FUNC);
+    else
+	settrap(sig, (Eprog) st->list, 0);
+    if (sig == SIGEXIT)
+	exit_trap_posix = st->posix;
+    dontsavetrap--;
+    /*
+     * counting of nsigtrapped should presumably be handled
+     * in settrap...
+     */
+    DPUTS((sigtrapped[sig] ^ st->flags) & ZSIG_TRAPPED,
+	  "BUG: settrap didn't restore correct ZSIG_TRAPPED");
+    if ((sigtrapped[sig] = st->flags) & ZSIG_FUNC)
+	shfunctab->addnode(shfunctab, ((Shfunc)st->list)->node.nam,
+			   (Shfunc) st->list);
+}
+
 /**/
 void
 endtrapscope(void)
@@ -911,24 +941,7 @@ endtrapscope(void)
 	    remnode(savetraps, ln);
 
 	    if (st->flags && (st->list != NULL)) {
-		/* prevent settrap from saving this */
-		dontsavetrap++;
-		if (st->flags & ZSIG_FUNC)
-		    settrap(sig, NULL, ZSIG_FUNC);
-		else
-			settrap(sig, (Eprog) st->list, 0);
-		if (sig == SIGEXIT)
-		    exit_trap_posix = st->posix;
-		dontsavetrap--;
-		/*
-		 * counting of nsigtrapped should presumably be handled
-		 * in settrap...
-		 */
-		DPUTS((sigtrapped[sig] ^ st->flags) & ZSIG_TRAPPED,
-		      "BUG: settrap didn't restore correct ZSIG_TRAPPED");
-		if ((sigtrapped[sig] = st->flags) & ZSIG_FUNC)
-		    shfunctab->addnode(shfunctab, ((Shfunc)st->list)->node.nam,
-				       (Shfunc) st->list);
+		restore_saved_trap(st);
 	    } else if (sigtrapped[sig]) {
 		/*
 		 * Don't restore the old state if someone has set a
@@ -947,7 +960,12 @@ endtrapscope(void)
 	 * We already made sure this wasn't set as a POSIX exit trap.
 	 * We respect the user's intention when the trap in question
 	 * was set.
+	 *
+	 * If we are exiting, clear errflag so the trap can run.
+	 * Matches what zexit() does before calling dotrap().
 	 */
+	if (exit_pending)
+	    errflag = 0;
 	dotrapargs(SIGEXIT, &exittr, exitfn);
 	if (exittr & ZSIG_FUNC)
 	    shfunctab->freenode((HashNode)exitfn);
@@ -958,7 +976,6 @@ endtrapscope(void)
 	  "BUG: still saved traps outside all function scope");
 }
 
-
 /*
  * Decide whether a trap needs handling.
  * If so, see if the trap should be run now or queued.

Src/subst.c

@@ -3343,15 +3343,23 @@ paramsubst(LinkList l, LinkNode n, char **str, int qt, int pf_flags,
                      */
                     errflag |= ERRFLAG_HARD;
                     if (!interact) {
-                        if (mypid == getpid()) {
+                        if (locallevel > forklevel) {
                             /*
-                             * paranoia: don't check for jobs, but there
-                             * shouldn't be any if not interactive.
+                             * Inside a function: use the same unwind
+                             * mechanism as the exit builtin so that
+                             * endtrapscope() runs at each level and
+                             * all saved EXIT traps are executed.
+                             */
+                            set_exit_pending(1);
+                        } else {
+                            /*
+                             * Not inside a function: zexit() runs the
+                             * EXIT trap and handles both main process
+                             * and subshell (_exit) cases.
                              */
                             stopmsg = 1;
                             zexit(1, ZEXIT_NORMAL);
-                        } else
-                            _exit(1);
+                        }
                     }
                 }
 		return NULL;

Test/C03traps.ztst

@@ -1014,6 +1014,47 @@ F:Must be tested with a top-level script rather than source or function
 >one
 >one
 
+  (setopt err_exit; trap 'echo EXIT' EXIT; f() { false; }; f)
+1:EXIT trap called when ERR_EXIT triggers inside function
+>EXIT
+
+  (setopt err_exit
+  trap 'echo A' EXIT
+  f1() {
+    trap 'echo B' EXIT
+    f2() {
+      trap 'echo C' EXIT
+      false
+    }
+    f2
+  }
+  f1)
+1:nested EXIT traps all called when ERR_EXIT triggers inside function
+>C
+>B
+>A
+
+  (trap 'echo EXIT' EXIT; f() { echo "a${unsetvar:?oops}z"; }; f)
+1:EXIT trap called when ${var:?} triggers inside function
+*?*unsetvar: oops
+>EXIT
+
+  (trap 'echo A' EXIT
+  f1() {
+    trap 'echo B' EXIT
+    f2() {
+      trap 'echo C' EXIT
+      echo "a${unsetvar:?oops}z"
+    }
+    f2
+  }
+  f1)
+1:nested EXIT traps all called when ${var:?} triggers inside function
+*?*unsetvar: oops
+>C
+>B
+>A
+
   ( set -o ERR_RETURN; f() { false; echo NOT REACHED;  }; f || true; echo OK )
   ( set -o ERR_RETURN; f() { true && false; echo NOT REACHED;  }; f || true; echo OK )
   ( set -o ERR_RETURN; f() { true && { false }; echo NOT REACHED;  }; f || true; echo OK )