From a795eb5d22abfb74a6dc81055df6d7ba7e599b9b Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sun, 15 Jun 2025 12:19:16 +0300
Subject: [PATCH 01/15] Improve error reporting of script arguments

Specify the argument number rather than its initial string, as the
latter can be ambiguous.
---
 src/uu/sed/src/script_line_provider.rs | 17 ++++-------------
 1 file changed, 4 insertions(+), 13 deletions(-)

diff --git a/src/uu/sed/src/script_line_provider.rs b/src/uu/sed/src/script_line_provider.rs
index d75eb9b9..24525f92 100644
--- a/src/uu/sed/src/script_line_provider.rs
+++ b/src/uu/sed/src/script_line_provider.rs
@@ -104,22 +104,13 @@ impl ScriptLineProvider {
             return Ok(());
         }
 
-        fn truncate_with_ellipsis(input: &str) -> String {
-            const MAX_LEN: usize = 20;
-            if input.chars().count() <= MAX_LEN {
-                input.to_string()
-            } else {
-                input.chars().take(MAX_LEN).collect::<String>() + "..."
-            }
-        }
-
         match &self.sources[next_index] {
             ScriptValue::StringVal(s) => {
                 let cursor = std::io::Cursor::new(s.clone());
                 self.state = State::Active {
                     index: next_index,
                     reader: Box::new(BufReader::new(cursor)),
-                    input_name: truncate_with_ellipsis(s),
+                    input_name: format!("<script argument {}>", next_index + 1),
                     line_number: 0,
                 };
             }
@@ -254,7 +245,7 @@ mod tests {
         if let Some(line) = provider.next_line().unwrap() {
             assert_eq!(line.trim(), "l1");
             assert_eq!(provider.get_line_number(), 1);
-            assert_eq!(provider.get_input_name(), "l1\nl2\n");
+            assert_eq!(provider.get_input_name(), "<script argument 1>");
         } else {
             panic!("Expected a line");
         }
@@ -262,7 +253,7 @@ mod tests {
         if let Some(line) = provider.next_line().unwrap() {
             assert_eq!(line.trim(), "l2");
             assert_eq!(provider.get_line_number(), 2);
-            assert_eq!(provider.get_input_name(), "l1\nl2\n");
+            assert_eq!(provider.get_input_name(), "<script argument 1>");
         } else {
             panic!("Expected a line");
         }
@@ -270,7 +261,7 @@ mod tests {
         if let Some(line) = provider.next_line().unwrap() {
             assert_eq!(line.trim(), "l3");
             assert_eq!(provider.get_line_number(), 1);
-            assert_eq!(provider.get_input_name(), "l3");
+            assert_eq!(provider.get_input_name(), "<script argument 2>");
         } else {
             panic!("Expected a line");
         }

From 5f6d9dd5705782d91ae8fbb721016cb93986f5cf Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sun, 15 Jun 2025 12:28:38 +0300
Subject: [PATCH 02/15] Report error columns in 1-based format

Following row numbering and most common convention.
---
 src/uu/sed/src/compiler.rs         | 10 +++++-----
 src/uu/sed/src/delimited_parser.rs |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index 9246a49d..2b5d1a10 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.rs
@@ -1368,7 +1368,7 @@ mod tests {
         let err = result.unwrap_err();
         let msg = err.to_string();
 
-        assert!(msg.contains("test.sed:42:4: error: unexpected token"));
+        assert!(msg.contains("test.sed:42:5: error: unexpected token"));
     }
 
     #[test]
@@ -1385,7 +1385,7 @@ mod tests {
         let err = result.unwrap_err();
         let msg = err.to_string();
 
-        assert_eq!(msg, "input.txt:3:0: error: invalid command 'x'");
+        assert_eq!(msg, "input.txt:3:1: error: invalid command 'x'");
     }
 
     // get_cmd_spec
@@ -1397,7 +1397,7 @@ mod tests {
 
         assert!(result.is_err());
         let msg = result.unwrap_err().to_string();
-        assert!(msg.contains("test.sed:1:0: error: command expected"));
+        assert!(msg.contains("test.sed:1:1: error: command expected"));
     }
 
     #[test]
@@ -1408,7 +1408,7 @@ mod tests {
 
         assert!(result.is_err());
         let msg = result.unwrap_err().to_string();
-        assert!(msg.contains("script.sed:2:0: error: invalid command code `@'"));
+        assert!(msg.contains("script.sed:2:1: error: invalid command code `@'"));
     }
 
     #[test]
@@ -1420,7 +1420,7 @@ mod tests {
         assert!(result.is_err());
         let msg = result.unwrap_err().to_string();
         assert!(
-            msg.contains("input.sed:3:0: error: command q expects up to 1 address(es), found 2")
+            msg.contains("input.sed:3:1: error: command q expects up to 1 address(es), found 2")
         );
     }
 
diff --git a/src/uu/sed/src/delimited_parser.rs b/src/uu/sed/src/delimited_parser.rs
index e96e4b04..447273dc 100644
--- a/src/uu/sed/src/delimited_parser.rs
+++ b/src/uu/sed/src/delimited_parser.rs
@@ -25,7 +25,7 @@ pub fn compilation_error<T>(
             "{}:{}:{}: error: {}",
             lines.get_input_name(),
             lines.get_line_number(),
-            line.get_pos(),
+            line.get_pos() + 1,
             msg.to_string()
         ),
     ))

From 25209fbe273b00c0a56b95f720f4522732bc992a Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sun, 15 Jun 2025 13:27:28 +0300
Subject: [PATCH 03/15] Incorporate script coordinates in commands

These can be used to improve runtime error reporting.

The implementation required moving ScriptValue to script_line_provider
to avoid the circular use chain.
---
 src/uu/sed/src/command.rs              | 29 ++++++++++++++++------
 src/uu/sed/src/compiler.rs             | 34 +++++++++++++++++++++++---
 src/uu/sed/src/script_line_provider.rs | 10 +++++++-
 src/uu/sed/src/sed.rs                  |  3 ++-
 4 files changed, 64 insertions(+), 12 deletions(-)

diff --git a/src/uu/sed/src/command.rs b/src/uu/sed/src/command.rs
index acaca06b..7b636a48 100644
--- a/src/uu/sed/src/command.rs
+++ b/src/uu/sed/src/command.rs
@@ -10,6 +10,8 @@
 
 use crate::fast_regex::{Captures, Match, Regex};
 use crate::named_writer::NamedWriter;
+use crate::script_char_provider::ScriptCharProvider;
+use crate::script_line_provider::ScriptLineProvider;
 
 use std::borrow::Cow;
 use std::cell::RefCell;
@@ -80,13 +82,6 @@ pub struct StringSpace {
     pub has_newline: bool, // True if \n-terminated
 }
 
-#[derive(Debug, PartialEq)]
-/// The specification of a script: through a string or a file
-pub enum ScriptValue {
-    StringVal(String),
-    PathVal(PathBuf),
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 /// Types of address specifications that precede commands
 pub enum AddressType {
@@ -285,6 +280,11 @@ pub struct Command {
     pub start_line: Option<usize>,          // Start line number (or None)
     pub data: CommandData,                  // Command-specific data
     pub next: Option<Rc<RefCell<Command>>>, // Pointer to next command
+
+    // Coordinates of command's definition
+    pub input_name: Rc<str>,  // Shared input name
+    pub line_number: usize,   // 1-based line number
+    pub column_number: usize, // 1-based column number
 }
 
 impl Default for Command {
@@ -297,6 +297,21 @@ impl Default for Command {
             start_line: None,
             data: CommandData::None,
             next: None,
+            input_name: Rc::from("<unknown>"),
+            line_number: 1,
+            column_number: 1,
+        }
+    }
+}
+
+impl Command {
+    /// Construct with position information from the given providers.
+    pub fn at_position(lines: &ScriptLineProvider, line: &ScriptCharProvider) -> Self {
+        Command {
+            line_number: lines.get_line_number(),
+            column_number: line.get_pos() + 1,
+            input_name: Rc::from(lines.get_input_name()),
+            ..Default::default()
         }
     }
 }
diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index 2b5d1a10..e6fa2756 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.rs
@@ -10,7 +10,7 @@
 
 use crate::command::{
     Address, AddressType, AddressValue, Command, CommandData, ProcessingContext, ReplacementPart,
-    ReplacementTemplate, ScriptValue, Substitution, Transliteration,
+    ReplacementTemplate, Substitution, Transliteration,
 };
 use crate::delimited_parser::{
     compilation_error, parse_char_escape, parse_regex, parse_transliteration,
@@ -18,7 +18,7 @@ use crate::delimited_parser::{
 use crate::fast_regex::Regex;
 use crate::named_writer::NamedWriter;
 use crate::script_char_provider::ScriptCharProvider;
-use crate::script_line_provider::ScriptLineProvider;
+use crate::script_line_provider::{ScriptLineProvider, ScriptValue};
 
 use std::borrow::Cow;
 use std::cell::RefCell;
@@ -394,7 +394,7 @@ fn compile_sequence(
             continue;
         }
 
-        let mut cmd = Rc::new(RefCell::new(Command::default()));
+        let mut cmd = Rc::new(RefCell::new(Command::at_position(lines, line)));
         let n_addr = compile_address_range(lines, line, &mut cmd, context)?;
         line.eat_spaces();
         let mut cmd_spec = get_cmd_spec(lines, line, n_addr)?;
@@ -1854,9 +1854,37 @@ mod tests {
         };
         assert_eq!(line, 1);
 
+        assert_eq!(cmd.line_number, 1);
+        assert_eq!(cmd.column_number, 1);
+        assert_eq!(cmd.input_name.as_ref(), "<script argument 1>");
+
         assert!(cmd.next.is_none());
     }
 
+    #[test]
+    fn test_compile_two_commands() {
+        let scripts = vec![ScriptValue::StringVal("l;q".to_string())];
+        let mut opts = ProcessingContext::default();
+
+        let result = compile(scripts, &mut opts).unwrap();
+        let binding = result.unwrap();
+        let cmd = binding.borrow();
+
+        assert_eq!(cmd.code, 'l');
+        assert_eq!(cmd.line_number, 1);
+        assert_eq!(cmd.column_number, 1);
+        assert_eq!(cmd.input_name.as_ref(), "<script argument 1>");
+
+        let binding2 = cmd.next.clone().unwrap();
+        let cmd2 = binding2.borrow();
+        assert_eq!(cmd2.code, 'q');
+        assert_eq!(cmd2.line_number, 1);
+        assert_eq!(cmd2.column_number, 3);
+        assert_eq!(cmd2.input_name.as_ref(), "<script argument 1>");
+
+        assert!(cmd2.next.is_none());
+    }
+
     // compile_replacement
     #[test]
     fn test_compile_replacement_literal() {
diff --git a/src/uu/sed/src/script_line_provider.rs b/src/uu/sed/src/script_line_provider.rs
index 24525f92..dff5fe9b 100644
--- a/src/uu/sed/src/script_line_provider.rs
+++ b/src/uu/sed/src/script_line_provider.rs
@@ -8,13 +8,21 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use crate::command::ScriptValue;
 use std::fmt;
 use std::fs::File;
 use std::io::{self, BufRead, BufReader};
+use std::path::PathBuf;
+
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult};
 
+#[derive(Debug, PartialEq)]
+/// The specification of a script: through a string or a file
+pub enum ScriptValue {
+    StringVal(String),
+    PathVal(PathBuf),
+}
+
 #[derive(Debug)]
 /// The provider of script lines across all specified scripts
 /// Scripts can be specified to sed as files or as strings.
diff --git a/src/uu/sed/src/sed.rs b/src/uu/sed/src/sed.rs
index fa34a512..cf18c8cb 100644
--- a/src/uu/sed/src/sed.rs
+++ b/src/uu/sed/src/sed.rs
@@ -19,9 +19,10 @@ pub mod processor;
 pub mod script_char_provider;
 pub mod script_line_provider;
 
-use crate::command::{ProcessingContext, ScriptValue, StringSpace};
+use crate::command::{ProcessingContext, StringSpace};
 use crate::compiler::compile;
 use crate::processor::process_all_files;
+use crate::script_line_provider::ScriptValue;
 use clap::{Arg, ArgMatches, Command, arg};
 use std::collections::HashMap;
 use std::path::PathBuf;

From ee4d3b39638599e777b655ffcac4d08f8602b407 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sun, 15 Jun 2025 18:53:11 +0300
Subject: [PATCH 04/15] Pass command to apply_captures

This is needed for improved error reporting.
---
 src/uu/sed/src/command.rs   | 22 +++++++++++++--------
 src/uu/sed/src/processor.rs | 38 ++++++++++++++++++-------------------
 2 files changed, 32 insertions(+), 28 deletions(-)

diff --git a/src/uu/sed/src/command.rs b/src/uu/sed/src/command.rs
index 7b636a48..6b63209c 100644
--- a/src/uu/sed/src/command.rs
+++ b/src/uu/sed/src/command.rs
@@ -147,9 +147,9 @@ impl ReplacementTemplate {
     /// Apply the template to the given RE captures.
     /// Example:
     /// let result = regex.replace_all(input, |caps: &Captures| {
-    ///    template.apply_captures(caps) });
+    ///    template.apply_captures(&command, caps) });
     /// Returns an error if a backreference in the template was not matched by the RE.
-    pub fn apply_captures(&self, caps: &Captures) -> UResult<String> {
+    pub fn apply_captures(&self, _command: &Command, caps: &Captures) -> UResult<String> {
         let mut result = String::new();
 
         // Invalid group numbers may end here through (unkown at compile time)
@@ -368,8 +368,9 @@ mod tests {
         let template = ReplacementTemplate::default();
         let input = &mut IOChunk::from_str("foo");
         let caps = caps_for("foo", input);
+        let cmd = Command::default();
 
-        let result = template.apply_captures(&caps).unwrap();
+        let result = template.apply_captures(&cmd, &caps).unwrap();
         assert_eq!(result, "");
     }
 
@@ -379,8 +380,9 @@ mod tests {
         let template = ReplacementTemplate::new(vec![ReplacementPart::Literal("hello".into())]);
         let input = &mut IOChunk::from_str("abc");
         let caps = caps_for("abc", input);
+        let cmd = Command::default();
 
-        let result = template.apply_captures(&caps).unwrap();
+        let result = template.apply_captures(&cmd, &caps).unwrap();
         assert_eq!(result, "hello");
     }
 
@@ -393,8 +395,9 @@ mod tests {
         ]);
         let input = &mut IOChunk::from_str("foo42");
         let caps = caps_for(r"foo\d+", input);
+        let cmd = Command::default();
 
-        let result = template.apply_captures(&caps).unwrap();
+        let result = template.apply_captures(&cmd, &caps).unwrap();
         assert_eq!(result, "got: foo42");
     }
 
@@ -407,8 +410,9 @@ mod tests {
         ]);
         let input = &mut IOChunk::from_str("foo42");
         let caps = caps_for(r"foo(\d+)", input);
+        let cmd = Command::default();
 
-        let result = template.apply_captures(&caps).unwrap();
+        let result = template.apply_captures(&cmd, &caps).unwrap();
         assert_eq!(result, "number: 42");
     }
 
@@ -423,8 +427,9 @@ mod tests {
         ]);
         let input = &mut IOChunk::from_str("x:123");
         let caps = caps_for(r"(\w+):(\d+)", input);
+        let cmd = Command::default();
 
-        let result = template.apply_captures(&caps).unwrap();
+        let result = template.apply_captures(&cmd, &caps).unwrap();
         assert_eq!(result, "key: x, value: 123");
     }
 
@@ -439,8 +444,9 @@ mod tests {
         ]);
         let input = &mut IOChunk::from_str("x:123");
         let caps = caps_for(r"(\w+):(\d+)", input);
+        let cmd = Command::default();
 
-        let result = template.apply_captures(&caps);
+        let result = template.apply_captures(&cmd, &caps);
         assert!(result.is_err());
 
         let msg = result.unwrap_err().to_string();
diff --git a/src/uu/sed/src/processor.rs b/src/uu/sed/src/processor.rs
index e1f01764..aa9be161 100644
--- a/src/uu/sed/src/processor.rs
+++ b/src/uu/sed/src/processor.rs
@@ -10,7 +10,7 @@
 
 use crate::command::{
     Address, AddressType, AddressValue, AppendElement, Command, CommandData, InputAction,
-    ProcessingContext, Substitution, Transliteration,
+    ProcessingContext, Transliteration,
 };
 use crate::fast_io::{IOChunk, LineReader, OutputBuffer};
 use crate::fast_regex::Regex;
@@ -25,6 +25,17 @@ use std::rc::Rc;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError, set_exit_code};
 
+/// Return the specified command variant or panic.
+// Example: let path = extract_variant!(command, Path);
+macro_rules! extract_variant {
+    ($cmd:expr, $variant:ident) => {
+        match &$cmd.data {
+            CommandData::$variant(inner) => inner,
+            _ => panic!(concat!("Expected ", stringify!($variant), " command data")),
+        }
+    };
+}
+
 /// Return true if the passed address matches the current I/O context.
 fn match_address(
     addr: &Address,
@@ -188,10 +199,12 @@ fn re_or_saved_re<'a>(
 /// Perform the specified RE replacement in the provided pattern space.
 fn substitute(
     pattern: &mut IOChunk,
-    sub: &mut Substitution,
+    command: &Command,
     context: &mut ProcessingContext,
     output: &mut OutputBuffer,
 ) -> UResult<()> {
+    let sub = extract_variant!(command, Substitution);
+
     let mut count = 0;
     let mut last_end = 0;
     let mut result = String::new();
@@ -224,7 +237,7 @@ fn substitute(
                 text = Some(pattern.as_str()?);
                 result.push_str(&text.unwrap()[last_end..m.start()]);
 
-                let replacement = sub.replacement.apply_captures(&caps)?;
+                let replacement = sub.replacement.apply_captures(command, &caps)?;
                 result.push_str(&replacement);
                 replaced = true;
                 last_end = m.end();
@@ -247,7 +260,7 @@ fn substitute(
                 result.push_str(&text.unwrap()[last_end..m.start()]);
 
                 if sub.occurrence == 0 || count == sub.occurrence {
-                    let replacement = sub.replacement.apply_captures(&caps)?;
+                    let replacement = sub.replacement.apply_captures(command, &caps)?;
                     result.push_str(&replacement);
                     replaced = true;
                 } else {
@@ -325,17 +338,6 @@ fn flush_appends(output: &mut OutputBuffer, context: &mut ProcessingContext) ->
     Ok(())
 }
 
-/// Return the specified command variant or panic.
-// Example: let path = extract_variant!(command, Path);
-macro_rules! extract_variant {
-    ($cmd:expr, $variant:ident) => {
-        match &$cmd.data {
-            CommandData::$variant(inner) => inner,
-            _ => panic!(concat!("Expected ", stringify!($variant), " command data")),
-        }
-    };
-}
-
 /// List the passed pattern space in unambiguous form.
 fn list(output: &mut OutputBuffer, line: &IOChunk, max_width: usize) -> UResult<()> {
     // Special case for an empty pattern space
@@ -572,11 +574,7 @@ fn process_file(
                         .push(AppendElement::Path(path.clone()));
                 }
                 's' => {
-                    let subst = match &mut command.data {
-                        CommandData::Substitution(subst) => subst,
-                        _ => panic!("Expected Substitution command data"),
-                    };
-                    substitute(&mut pattern, &mut *subst, context, output)?;
+                    substitute(&mut pattern, &command, context, output)?;
                 }
                 't' if !context.substitution_made => { /* Do nothing. */ }
                 't' => {

From af9de7ff89a573e6b49bad1830311e55a5a2cf8f Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sun, 15 Jun 2025 19:07:58 +0300
Subject: [PATCH 05/15] Move error handling to dedicated module

This will be used to also host the runtime error function.
---
 src/uu/sed/src/compiler.rs         |  5 ++---
 src/uu/sed/src/delimited_parser.rs | 22 +++------------------
 src/uu/sed/src/error_handling.rs   | 31 ++++++++++++++++++++++++++++++
 src/uu/sed/src/sed.rs              |  1 +
 4 files changed, 37 insertions(+), 22 deletions(-)
 create mode 100644 src/uu/sed/src/error_handling.rs

diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index e6fa2756..c5e82090 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.rs
@@ -12,9 +12,8 @@ use crate::command::{
     Address, AddressType, AddressValue, Command, CommandData, ProcessingContext, ReplacementPart,
     ReplacementTemplate, Substitution, Transliteration,
 };
-use crate::delimited_parser::{
-    compilation_error, parse_char_escape, parse_regex, parse_transliteration,
-};
+use crate::delimited_parser::{parse_char_escape, parse_regex, parse_transliteration};
+use crate::error_handling::compilation_error;
 use crate::fast_regex::Regex;
 use crate::named_writer::NamedWriter;
 use crate::script_char_provider::ScriptCharProvider;
diff --git a/src/uu/sed/src/delimited_parser.rs b/src/uu/sed/src/delimited_parser.rs
index 447273dc..59fc16a9 100644
--- a/src/uu/sed/src/delimited_parser.rs
+++ b/src/uu/sed/src/delimited_parser.rs
@@ -8,28 +8,12 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use crate::error_handling::compilation_error;
 use crate::script_char_provider::ScriptCharProvider;
 use crate::script_line_provider::ScriptLineProvider;
-use std::char;
-use uucore::error::{UResult, USimpleError};
 
-// Fail with msg as a compile error at the current location
-pub fn compilation_error<T>(
-    lines: &ScriptLineProvider,
-    line: &ScriptCharProvider,
-    msg: impl ToString,
-) -> UResult<T> {
-    Err(USimpleError::new(
-        1,
-        format!(
-            "{}:{}:{}: error: {}",
-            lines.get_input_name(),
-            lines.get_line_number(),
-            line.get_pos() + 1,
-            msg.to_string()
-        ),
-    ))
-}
+use std::char;
+use uucore::error::UResult;
 
 /// Return true if c is a valid octal digit
 fn is_ascii_octal_digit(c: char) -> bool {
diff --git a/src/uu/sed/src/error_handling.rs b/src/uu/sed/src/error_handling.rs
new file mode 100644
index 00000000..8a53ddc4
--- /dev/null
+++ b/src/uu/sed/src/error_handling.rs
@@ -0,0 +1,31 @@
+// Parse delimited character sequences
+//
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 Diomidis Spinellis
+//
+// This file is part of the uutils sed package.
+// It is licensed under the MIT License.
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use crate::script_char_provider::ScriptCharProvider;
+use crate::script_line_provider::ScriptLineProvider;
+use uucore::error::{UResult, USimpleError};
+
+/// Fail with msg as a compile error at the current location
+pub fn compilation_error<T>(
+    lines: &ScriptLineProvider,
+    line: &ScriptCharProvider,
+    msg: impl ToString,
+) -> UResult<T> {
+    Err(USimpleError::new(
+        1,
+        format!(
+            "{}:{}:{}: error: {}",
+            lines.get_input_name(),
+            lines.get_line_number(),
+            line.get_pos() + 1,
+            msg.to_string()
+        ),
+    ))
+}
diff --git a/src/uu/sed/src/sed.rs b/src/uu/sed/src/sed.rs
index cf18c8cb..9cd9d0e9 100644
--- a/src/uu/sed/src/sed.rs
+++ b/src/uu/sed/src/sed.rs
@@ -11,6 +11,7 @@
 pub mod command;
 pub mod compiler;
 pub mod delimited_parser;
+pub mod error_handling;
 pub mod fast_io;
 pub mod fast_regex;
 pub mod in_place;

From 0416a89e21fae669561918b57b53915312a29575 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sun, 15 Jun 2025 20:10:59 +0300
Subject: [PATCH 06/15] Improve error reporting for s captures, b, :

---
 src/uu/sed/src/command.rs        | 13 +++++++------
 src/uu/sed/src/compiler.rs       |  7 ++++---
 src/uu/sed/src/error_handling.rs | 33 +++++++++++++++++++++++++++++++-
 src/uu/sed/src/fast_io.rs        |  2 +-
 tests/by-util/test_sed.rs        | 29 ++++++++++++++++++++++++++++
 5 files changed, 73 insertions(+), 11 deletions(-)

diff --git a/src/uu/sed/src/command.rs b/src/uu/sed/src/command.rs
index 6b63209c..daa4bd37 100644
--- a/src/uu/sed/src/command.rs
+++ b/src/uu/sed/src/command.rs
@@ -8,6 +8,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use crate::error_handling::runtime_error;
 use crate::fast_regex::{Captures, Match, Regex};
 use crate::named_writer::NamedWriter;
 use crate::script_char_provider::ScriptCharProvider;
@@ -18,7 +19,7 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::path::PathBuf; // For file descriptors and equivalent
 use std::rc::Rc;
-use uucore::error::{UResult, USimpleError};
+use uucore::error::UResult;
 
 #[derive(Debug, Default, Clone)]
 /// Compilation and processing options provided mostly through the
@@ -149,19 +150,19 @@ impl ReplacementTemplate {
     /// let result = regex.replace_all(input, |caps: &Captures| {
     ///    template.apply_captures(&command, caps) });
     /// Returns an error if a backreference in the template was not matched by the RE.
-    pub fn apply_captures(&self, _command: &Command, caps: &Captures) -> UResult<String> {
+    pub fn apply_captures(&self, command: &Command, caps: &Captures) -> UResult<String> {
         let mut result = String::new();
 
         // Invalid group numbers may end here through (unkown at compile time)
         // reused REs.
         if self.max_group_number > caps.len() - 1 {
-            return Err(USimpleError::new(
-                2,
+            return runtime_error(
+                command,
                 format!(
-                    "invalid reference \\{} on `s' command's RHS",
+                    "invalid reference \\{} on command's RHS",
                     self.max_group_number
                 ),
-            ));
+            );
         }
 
         for part in &self.parts {
diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index c5e82090..2d1dc6ff 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.rs
@@ -13,7 +13,7 @@ use crate::command::{
     ReplacementTemplate, Substitution, Transliteration,
 };
 use crate::delimited_parser::{parse_char_escape, parse_regex, parse_transliteration};
-use crate::error_handling::compilation_error;
+use crate::error_handling::{compilation_error, semantic_error};
 use crate::fast_regex::Regex;
 use crate::named_writer::NamedWriter;
 use crate::script_char_provider::ScriptCharProvider;
@@ -309,7 +309,7 @@ fn populate_label_map(
         if let Some(label) = maybe_label {
             if cmd.code == ':' {
                 if context.label_to_command_map.contains_key(&label) {
-                    return Err(USimpleError::new(2, format!("duplicate label `{label}'")));
+                    return semantic_error(&cmd, format!("duplicate label `{label}'"));
                 }
                 context.label_to_command_map.insert(label, rc_cmd.clone());
             }
@@ -348,7 +348,8 @@ fn resolve_branch_targets(
                         .get(&label)
                         .cloned()
                         .ok_or_else(|| {
-                            USimpleError::new(2, format!("undefined label `{label}'"))
+                            semantic_error::<()>(&cmd, format!("undefined label `{label}'"))
+                                .unwrap_err()
                         })?;
                     CommandData::BranchTarget(Some(target))
                 }
diff --git a/src/uu/sed/src/error_handling.rs b/src/uu/sed/src/error_handling.rs
index 8a53ddc4..bad44d60 100644
--- a/src/uu/sed/src/error_handling.rs
+++ b/src/uu/sed/src/error_handling.rs
@@ -8,11 +8,14 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use crate::command::Command;
 use crate::script_char_provider::ScriptCharProvider;
 use crate::script_line_provider::ScriptLineProvider;
+
 use uucore::error::{UResult, USimpleError};
 
-/// Fail with msg as a compile error at the current location
+/// Fail with msg as a compile error at the provider location.
+/// The error's exit code is 1 (compilation phase).
 pub fn compilation_error<T>(
     lines: &ScriptLineProvider,
     line: &ScriptCharProvider,
@@ -29,3 +32,31 @@ pub fn compilation_error<T>(
         ),
     ))
 }
+
+/// Fail with msg as a compilation error at the command's location.
+/// The error's exit code is as specified.
+fn command_error<T>(command: &Command, msg: impl ToString, exit_code: i32) -> UResult<T> {
+    Err(USimpleError::new(
+        exit_code,
+        format!(
+            "{}:{}:{}: command `{}': error: {}",
+            command.input_name,
+            command.line_number,
+            command.column_number,
+            command.code,
+            msg.to_string()
+        ),
+    ))
+}
+
+/// Fail with msg as a compilation error at the command's location.
+/// The error's exit code is 1 (compilation phase).
+pub fn semantic_error<T>(command: &Command, msg: impl ToString) -> UResult<T> {
+    command_error(command, msg, 1)
+}
+
+/// Fail with msg as a runtime error at the command's location.
+/// The error's exit code is 2 (processing phase).
+pub fn runtime_error<T>(command: &Command, msg: impl ToString) -> UResult<T> {
+    command_error(command, msg, 2)
+}
diff --git a/src/uu/sed/src/fast_io.rs b/src/uu/sed/src/fast_io.rs
index c101163d..6b08d1d1 100644
--- a/src/uu/sed/src/fast_io.rs
+++ b/src/uu/sed/src/fast_io.rs
@@ -263,7 +263,7 @@ impl<'a> IOChunk<'a> {
                         self.utf8_verified.set(true);
                         Ok(())
                     }
-                    Err(e) => Err(USimpleError::new(1, e.to_string())),
+                    Err(e) => Err(USimpleError::new(2, e.to_string())),
                 }
             }
         }
diff --git a/tests/by-util/test_sed.rs b/tests/by-util/test_sed.rs
index e623b65c..7ebf6775 100644
--- a/tests/by-util/test_sed.rs
+++ b/tests/by-util/test_sed.rs
@@ -897,3 +897,32 @@ check_output!(pi, ["-f", "script/math.sed", "input/pi"]);
 
 // Solve the Towers of Hanoi puzzle
 check_output!(hanoi, ["-f", "script/hanoi.sed", "input/hanoi"]);
+
+////////////////////////////////////////////////////////////
+// Error handling
+#[test]
+fn test_invalid_backreference() {
+    new_ucmd!()
+        .args(&["-n", "-e", r"s/./X/;s//\1/", LINES1])
+        .fails()
+        .code_is(2)
+        .stderr_is("sed: <script argument 1>:1:8: command `s': error: invalid reference \\1 on command's RHS\n");
+}
+
+#[test]
+fn test_duplicate_label() {
+    new_ucmd!()
+        .args(&[":foo;:foo"])
+        .fails()
+        .code_is(1)
+        .stderr_is("sed: <script argument 1>:1:6: command `:': error: duplicate label `foo'\n");
+}
+
+#[test]
+fn test_undefined_label() {
+    new_ucmd!()
+        .args(&["b foo"])
+        .fails()
+        .code_is(1)
+        .stderr_is("sed: <script argument 1>:1:1: command `b': error: undefined label `foo'\n");
+}

From fd3172e6b65cb43bc1b3eb186dd9c45bece4f87f Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sun, 15 Jun 2025 22:58:34 +0300
Subject: [PATCH 07/15] Isolate error location into separate struct

In contrast to the whole mutable and large Command struct, this is immutable
and small, and can therefore can be easily copied around for reporting
runtime errors.
---
 src/uu/sed/src/command.rs        | 18 ++++-------
 src/uu/sed/src/compiler.rs       | 28 ++++++++++--------
 src/uu/sed/src/error_handling.rs | 51 +++++++++++++++++++++++++-------
 tests/by-util/test_sed.rs        |  6 ++--
 4 files changed, 64 insertions(+), 39 deletions(-)

diff --git a/src/uu/sed/src/command.rs b/src/uu/sed/src/command.rs
index daa4bd37..db701a49 100644
--- a/src/uu/sed/src/command.rs
+++ b/src/uu/sed/src/command.rs
@@ -8,7 +8,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use crate::error_handling::runtime_error;
+use crate::error_handling::{ScriptLocation, runtime_error};
 use crate::fast_regex::{Captures, Match, Regex};
 use crate::named_writer::NamedWriter;
 use crate::script_char_provider::ScriptCharProvider;
@@ -157,7 +157,7 @@ impl ReplacementTemplate {
         // reused REs.
         if self.max_group_number > caps.len() - 1 {
             return runtime_error(
-                command,
+                &command.location,
                 format!(
                     "invalid reference \\{} on command's RHS",
                     self.max_group_number
@@ -281,11 +281,7 @@ pub struct Command {
     pub start_line: Option<usize>,          // Start line number (or None)
     pub data: CommandData,                  // Command-specific data
     pub next: Option<Rc<RefCell<Command>>>, // Pointer to next command
-
-    // Coordinates of command's definition
-    pub input_name: Rc<str>,  // Shared input name
-    pub line_number: usize,   // 1-based line number
-    pub column_number: usize, // 1-based column number
+    pub location: ScriptLocation,           // Command's definition location
 }
 
 impl Default for Command {
@@ -298,9 +294,7 @@ impl Default for Command {
             start_line: None,
             data: CommandData::None,
             next: None,
-            input_name: Rc::from("<unknown>"),
-            line_number: 1,
-            column_number: 1,
+            location: ScriptLocation::default(),
         }
     }
 }
@@ -309,9 +303,7 @@ impl Command {
     /// Construct with position information from the given providers.
     pub fn at_position(lines: &ScriptLineProvider, line: &ScriptCharProvider) -> Self {
         Command {
-            line_number: lines.get_line_number(),
-            column_number: line.get_pos() + 1,
-            input_name: Rc::from(lines.get_input_name()),
+            location: ScriptLocation::at_position(lines, line),
             ..Default::default()
         }
     }
diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index 2d1dc6ff..bf83e955 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.rs
@@ -309,7 +309,8 @@ fn populate_label_map(
         if let Some(label) = maybe_label {
             if cmd.code == ':' {
                 if context.label_to_command_map.contains_key(&label) {
-                    return semantic_error(&cmd, format!("duplicate label `{label}'"));
+                    return semantic_error(&cmd.location, format!("duplicate label `{label}'"));
+>>>>>>> a429b31 (Isolate error location into separate struct)
                 }
                 context.label_to_command_map.insert(label, rc_cmd.clone());
             }
@@ -348,8 +349,11 @@ fn resolve_branch_targets(
                         .get(&label)
                         .cloned()
                         .ok_or_else(|| {
-                            semantic_error::<()>(&cmd, format!("undefined label `{label}'"))
-                                .unwrap_err()
+                            semantic_error::<()>(
+                                &cmd.location,
+                                format!("undefined label `{label}'"),
+                            )
+                            .unwrap_err()
                         })?;
                     CommandData::BranchTarget(Some(target))
                 }
@@ -1854,9 +1858,9 @@ mod tests {
         };
         assert_eq!(line, 1);
 
-        assert_eq!(cmd.line_number, 1);
-        assert_eq!(cmd.column_number, 1);
-        assert_eq!(cmd.input_name.as_ref(), "<script argument 1>");
+        assert_eq!(cmd.location.line_number, 1);
+        assert_eq!(cmd.location.column_number, 1);
+        assert_eq!(cmd.location.input_name.as_ref(), "<script argument 1>");
 
         assert!(cmd.next.is_none());
     }
@@ -1871,16 +1875,16 @@ mod tests {
         let cmd = binding.borrow();
 
         assert_eq!(cmd.code, 'l');
-        assert_eq!(cmd.line_number, 1);
-        assert_eq!(cmd.column_number, 1);
-        assert_eq!(cmd.input_name.as_ref(), "<script argument 1>");
+        assert_eq!(cmd.location.line_number, 1);
+        assert_eq!(cmd.location.column_number, 1);
+        assert_eq!(cmd.location.input_name.as_ref(), "<script argument 1>");
 
         let binding2 = cmd.next.clone().unwrap();
         let cmd2 = binding2.borrow();
         assert_eq!(cmd2.code, 'q');
-        assert_eq!(cmd2.line_number, 1);
-        assert_eq!(cmd2.column_number, 3);
-        assert_eq!(cmd2.input_name.as_ref(), "<script argument 1>");
+        assert_eq!(cmd2.location.line_number, 1);
+        assert_eq!(cmd2.location.column_number, 3);
+        assert_eq!(cmd2.location.input_name.as_ref(), "<script argument 1>");
 
         assert!(cmd2.next.is_none());
     }
diff --git a/src/uu/sed/src/error_handling.rs b/src/uu/sed/src/error_handling.rs
index bad44d60..cb33e531 100644
--- a/src/uu/sed/src/error_handling.rs
+++ b/src/uu/sed/src/error_handling.rs
@@ -8,12 +8,42 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use crate::command::Command;
 use crate::script_char_provider::ScriptCharProvider;
 use crate::script_line_provider::ScriptLineProvider;
 
+use std::rc::Rc;
+
 use uucore::error::{UResult, USimpleError};
 
+#[derive(Debug)]
+/// The location in a script where a command is defined
+pub struct ScriptLocation {
+    pub input_name: Rc<str>,  // Shared input name
+    pub line_number: usize,   // 1-based line number
+    pub column_number: usize, // 1-based column number
+}
+
+impl Default for ScriptLocation {
+    fn default() -> Self {
+        ScriptLocation {
+            input_name: Rc::from("<unknown>"),
+            line_number: 1,
+            column_number: 1,
+        }
+    }
+}
+
+impl ScriptLocation {
+    /// Construct with position information from the given providers.
+    pub fn at_position(lines: &ScriptLineProvider, line: &ScriptCharProvider) -> Self {
+        ScriptLocation {
+            line_number: lines.get_line_number(),
+            column_number: line.get_pos() + 1,
+            input_name: Rc::from(lines.get_input_name()),
+        }
+    }
+}
+
 /// Fail with msg as a compile error at the provider location.
 /// The error's exit code is 1 (compilation phase).
 pub fn compilation_error<T>(
@@ -35,15 +65,14 @@ pub fn compilation_error<T>(
 
 /// Fail with msg as a compilation error at the command's location.
 /// The error's exit code is as specified.
-fn command_error<T>(command: &Command, msg: impl ToString, exit_code: i32) -> UResult<T> {
+fn location_error<T>(location: &ScriptLocation, msg: impl ToString, exit_code: i32) -> UResult<T> {
     Err(USimpleError::new(
         exit_code,
         format!(
-            "{}:{}:{}: command `{}': error: {}",
-            command.input_name,
-            command.line_number,
-            command.column_number,
-            command.code,
+            "{}:{}:{}: error: {}",
+            location.input_name,
+            location.line_number,
+            location.column_number,
             msg.to_string()
         ),
     ))
@@ -51,12 +80,12 @@ fn command_error<T>(command: &Command, msg: impl ToString, exit_code: i32) -> UR
 
 /// Fail with msg as a compilation error at the command's location.
 /// The error's exit code is 1 (compilation phase).
-pub fn semantic_error<T>(command: &Command, msg: impl ToString) -> UResult<T> {
-    command_error(command, msg, 1)
+pub fn semantic_error<T>(location: &ScriptLocation, msg: impl ToString) -> UResult<T> {
+    location_error(location, msg, 1)
 }
 
 /// Fail with msg as a runtime error at the command's location.
 /// The error's exit code is 2 (processing phase).
-pub fn runtime_error<T>(command: &Command, msg: impl ToString) -> UResult<T> {
-    command_error(command, msg, 2)
+pub fn runtime_error<T>(location: &ScriptLocation, msg: impl ToString) -> UResult<T> {
+    location_error(location, msg, 2)
 }
diff --git a/tests/by-util/test_sed.rs b/tests/by-util/test_sed.rs
index 7ebf6775..edc778bf 100644
--- a/tests/by-util/test_sed.rs
+++ b/tests/by-util/test_sed.rs
@@ -906,7 +906,7 @@ fn test_invalid_backreference() {
         .args(&["-n", "-e", r"s/./X/;s//\1/", LINES1])
         .fails()
         .code_is(2)
-        .stderr_is("sed: <script argument 1>:1:8: command `s': error: invalid reference \\1 on command's RHS\n");
+        .stderr_is("sed: <script argument 1>:1:8: error: invalid reference \\1 on command's RHS\n");
 }
 
 #[test]
@@ -915,7 +915,7 @@ fn test_duplicate_label() {
         .args(&[":foo;:foo"])
         .fails()
         .code_is(1)
-        .stderr_is("sed: <script argument 1>:1:6: command `:': error: duplicate label `foo'\n");
+        .stderr_is("sed: <script argument 1>:1:6: error: duplicate label `foo'\n");
 }
 
 #[test]
@@ -924,5 +924,5 @@ fn test_undefined_label() {
         .args(&["b foo"])
         .fails()
         .code_is(1)
-        .stderr_is("sed: <script argument 1>:1:1: command `b': error: undefined label `foo'\n");
+        .stderr_is("sed: <script argument 1>:1:1: error: undefined label `foo'\n");
 }

From 60cba2bf553a3679205debf4e9e050901cb154c8 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Mon, 16 Jun 2025 00:02:29 +0300
Subject: [PATCH 08/15] Improve error reporting for RE errors

---
 src/uu/sed/src/command.rs        |   2 +-
 src/uu/sed/src/compiler.rs       |  48 ++++++++++----
 src/uu/sed/src/error_handling.rs |   2 +-
 src/uu/sed/src/fast_regex.rs     | 105 ++++++++++++++++++-------------
 tests/by-util/test_sed.rs        |   9 +++
 5 files changed, 109 insertions(+), 57 deletions(-)

diff --git a/src/uu/sed/src/command.rs b/src/uu/sed/src/command.rs
index db701a49..249c0d8c 100644
--- a/src/uu/sed/src/command.rs
+++ b/src/uu/sed/src/command.rs
@@ -348,7 +348,7 @@ mod tests {
 
     // Return the captures for the RE applied to the specified string
     fn caps_for<'a>(re: &str, chunk: &'a mut IOChunk) -> Captures<'a> {
-        Regex::new(re)
+        Regex::new(ScriptLocation::default(), re)
             .unwrap()
             .captures(chunk)
             .unwrap()
diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index bf83e955..245c58ec 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.rs
@@ -13,7 +13,7 @@ use crate::command::{
     ReplacementTemplate, Substitution, Transliteration,
 };
 use crate::delimited_parser::{parse_char_escape, parse_regex, parse_transliteration};
-use crate::error_handling::{compilation_error, semantic_error};
+use crate::error_handling::{ScriptLocation, compilation_error, semantic_error};
 use crate::fast_regex::Regex;
 use crate::named_writer::NamedWriter;
 use crate::script_char_provider::ScriptCharProvider;
@@ -509,6 +509,7 @@ fn compile_address(
     match line.current() {
         '\\' | '/' => {
             // Regular expression
+            let location = ScriptLocation::at_position(lines, line);
             if line.current() == '\\' {
                 // The next character is an arbitrary delimiter
                 line.advance();
@@ -525,7 +526,9 @@ fn compile_address(
 
             Ok(Address {
                 atype: AddressType::Re,
-                value: AddressValue::Regex(compile_regex(lines, line, &re, context, icase)?),
+                value: AddressValue::Regex(compile_regex(
+                    lines, line, &location, &re, context, icase,
+                )?),
             })
         }
         '$' => {
@@ -688,6 +691,7 @@ fn bre_to_ere(pattern: &str) -> String {
 fn compile_regex(
     lines: &ScriptLineProvider,
     line: &ScriptCharProvider,
+    location: &ScriptLocation,
     pattern: &str,
     context: &ProcessingContext,
     icase: bool,
@@ -711,7 +715,7 @@ fn compile_regex(
     };
 
     // Compile into engine.
-    let compiled = Regex::new(&pattern).map_err(|e| {
+    let compiled = Regex::new(location.clone(), &pattern).map_err(|e| {
         compilation_error::<Regex>(lines, line, format!("invalid regex '{pattern}': {e}"))
             .unwrap_err()
     })?;
@@ -848,6 +852,7 @@ fn compile_subst_command(
         );
     }
 
+    let location = ScriptLocation::at_position(lines, line);
     let pattern = parse_regex(lines, line)?;
 
     let mut subst = Box::new(Substitution {
@@ -867,7 +872,7 @@ fn compile_subst_command(
     }
 
     // Compile regex with now known ignore_case flag.
-    subst.regex = compile_regex(lines, line, &pattern, context, subst.ignore_case)?;
+    subst.regex = compile_regex(lines, line, &location, &pattern, context, subst.ignore_case)?;
 
     // Catch invalid group references at compile time, if possible.
     if let Some(regex) = &subst.regex {
@@ -1475,9 +1480,16 @@ mod tests {
     #[test]
     fn test_compile_re_basic() {
         let (lines, chars) = dummy_providers();
-        let regex = compile_regex(&lines, &chars, "abc", &ctx(), false)
-            .unwrap()
-            .expect("regex should be present");
+        let regex = compile_regex(
+            &lines,
+            &chars,
+            &ScriptLocation::default(),
+            "abc",
+            &ctx(),
+            false,
+        )
+        .unwrap()
+        .expect("regex should be present");
         assert!(regex.is_match(&mut IOChunk::from_str("abc")).unwrap());
         assert!(!regex.is_match(&mut IOChunk::from_str("ABC")).unwrap());
     }
@@ -1485,9 +1497,16 @@ mod tests {
     #[test]
     fn test_compile_re_case_insensitive() {
         let (lines, chars) = dummy_providers();
-        let regex = compile_regex(&lines, &chars, "abc", &ctx(), true)
-            .unwrap()
-            .expect("regex should be present");
+        let regex = compile_regex(
+            &lines,
+            &chars,
+            &ScriptLocation::default(),
+            "abc",
+            &ctx(),
+            true,
+        )
+        .unwrap()
+        .expect("regex should be present");
         assert!(regex.is_match(&mut IOChunk::from_str("abc")).unwrap());
         assert!(regex.is_match(&mut IOChunk::from_str("ABC")).unwrap());
         assert!(regex.is_match(&mut IOChunk::from_str("AbC")).unwrap());
@@ -1496,7 +1515,14 @@ mod tests {
     #[test]
     fn test_compile_re_invalid() {
         let (lines, chars) = dummy_providers();
-        let result = compile_regex(&lines, &chars, "a[d", &ctx(), false);
+        let result = compile_regex(
+            &lines,
+            &chars,
+            &ScriptLocation::default(),
+            "a[d",
+            &ctx(),
+            false,
+        );
         assert!(result.is_err()); // Should fail due to open bracketed expression
     }
 
diff --git a/src/uu/sed/src/error_handling.rs b/src/uu/sed/src/error_handling.rs
index cb33e531..56967173 100644
--- a/src/uu/sed/src/error_handling.rs
+++ b/src/uu/sed/src/error_handling.rs
@@ -15,7 +15,7 @@ use std::rc::Rc;
 
 use uucore::error::{UResult, USimpleError};
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 /// The location in a script where a command is defined
 pub struct ScriptLocation {
     pub input_name: Rc<str>,  // Shared input name
diff --git a/src/uu/sed/src/fast_regex.rs b/src/uu/sed/src/fast_regex.rs
index cc284853..bb9c0bcd 100644
--- a/src/uu/sed/src/fast_regex.rs
+++ b/src/uu/sed/src/fast_regex.rs
@@ -11,6 +11,8 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use crate::error_handling::{ScriptLocation, runtime_error};
+
 use fancy_regex::{
     CaptureMatches as FancyCaptureMatches, Captures as FancyCaptures, Regex as FancyRegex,
 };
@@ -234,69 +236,84 @@ pub fn remove_escapes(pattern: &str) -> String {
 
 #[derive(Clone, Debug)]
 /// A regular expression that can be implemented in diverse efficient ways
-pub enum Regex {
+pub enum RegexEngine {
     Literal(LiteralMatcher), // Fastest: literal bytes
     Byte(ByteRegex),         // Slower: byte-based RE
     Fancy(FancyRegex),       // Slowest: RE supporting UTF-8 and back-references
 }
 
+#[derive(Clone, Debug)]
+pub struct Regex {
+    loc: ScriptLocation,
+    engine: RegexEngine,
+}
+
 impl Regex {
     /// Construct the most efficient RE-like matching engine possible.
-    pub fn new(pattern: &str) -> Result<Self, Box<dyn Error>> {
-        if NEEDS_FANCY_RE.is_match(pattern) {
-            Ok(Self::Fancy(FancyRegex::new(pattern)?))
+    pub fn new(loc: ScriptLocation, pattern: &str) -> Result<Self, Box<dyn Error>> {
+        let engine = if NEEDS_FANCY_RE.is_match(pattern) {
+            RegexEngine::Fancy(FancyRegex::new(pattern)?)
         } else if NEEDS_RE.is_match(pattern) {
-            Ok(Self::Byte(ByteRegex::new(pattern)?))
+            RegexEngine::Byte(ByteRegex::new(pattern)?)
         } else {
-            Ok(Self::Literal(LiteralMatcher::new(&remove_escapes(pattern))))
-        }
+            RegexEngine::Literal(LiteralMatcher::new(&remove_escapes(pattern)))
+        };
+        Ok(Regex { loc, engine })
+    }
+
+    #[cfg(test)]
+    /// Construct with a default location
+    pub fn new_unlocated(pattern: &str) -> Result<Self, Box<dyn Error>> {
+        Regex::new(ScriptLocation::default(), pattern)
     }
 
     /// Check if the regex matches the content of the IOChunk.
     pub fn is_match(&self, chunk: &mut IOChunk) -> UResult<bool> {
-        match self {
-            Regex::Literal(m) => Ok(m.is_match(chunk.as_bytes())),
-            Regex::Byte(re) => Ok(re.is_match(chunk.as_bytes())),
-            Regex::Fancy(re) => {
+        match &self.engine {
+            RegexEngine::Literal(m) => Ok(m.is_match(chunk.as_bytes())),
+            RegexEngine::Byte(re) => Ok(re.is_match(chunk.as_bytes())),
+            RegexEngine::Fancy(re) => {
                 let text = chunk.as_str()?;
-                re.is_match(text)
-                    .map_err(|e| USimpleError::new(2, e.to_string()))
+                match re.is_match(text) {
+                    Ok(found) => Ok(found),
+                    Err(e) => runtime_error(&self.loc, e.to_string()),
+                }
             }
         }
     }
 
     /// Return an iterator over capture groups.
     pub fn captures_iter<'t>(&'t self, chunk: &'t IOChunk) -> UResult<CaptureMatches<'t>> {
-        match self {
-            Regex::Literal(m) => {
+        match &self.engine {
+            RegexEngine::Literal(m) => {
                 let haystack = chunk.as_bytes();
                 Ok(CaptureMatches::Literal(Box::new(m.iter(haystack).map(
                     |(start, end, text)| Ok(Captures::Literal(Match { start, end, text })),
                 ))))
             }
 
-            Regex::Byte(re) => Ok(CaptureMatches::Byte(re.captures_iter(chunk.as_bytes()))),
+            RegexEngine::Byte(re) => Ok(CaptureMatches::Byte(re.captures_iter(chunk.as_bytes()))),
 
-            Regex::Fancy(re) => {
+            RegexEngine::Fancy(re) => {
                 let text = chunk.as_str()?;
-                Ok(CaptureMatches::Fancy(re.captures_iter(text)))
+                Ok(CaptureMatches::Fancy(re.captures_iter(text), &self.loc))
             }
         }
     }
 
     /// Return the number of capture groups, including group 0.
     pub fn captures_len(&self) -> usize {
-        match self {
-            Regex::Literal(_) => 1, // Only group 0
-            Regex::Byte(re) => re.captures_len(),
-            Regex::Fancy(re) => re.captures_len(),
+        match &self.engine {
+            RegexEngine::Literal(_) => 1, // Only group 0
+            RegexEngine::Byte(re) => re.captures_len(),
+            RegexEngine::Fancy(re) => re.captures_len(),
         }
     }
 
     /// Return the elements of the first capture.
     pub fn captures<'t>(&self, chunk: &'t IOChunk) -> UResult<Option<Captures<'t>>> {
-        match self {
-            Regex::Literal(m) => {
+        match &self.engine {
+            RegexEngine::Literal(m) => {
                 let haystack = chunk.as_bytes();
                 match m.find(haystack) {
                     Some((start, end, text)) => {
@@ -306,17 +323,17 @@ impl Regex {
                 }
             }
 
-            Regex::Byte(re) => {
+            RegexEngine::Byte(re) => {
                 let bytes = chunk.as_bytes();
                 Ok(re.captures(bytes).map(Captures::Byte))
             }
 
-            Regex::Fancy(re) => {
+            RegexEngine::Fancy(re) => {
                 let text = chunk.as_str()?;
                 match re.captures(text) {
                     Ok(Some(caps)) => Ok(Some(Captures::Fancy(caps))),
                     Ok(None) => Ok(None),
-                    Err(e) => Err(USimpleError::new(2, e.to_string())),
+                    Err(e) => runtime_error(&self.loc, e.to_string()),
                 }
             }
         }
@@ -324,8 +341,8 @@ impl Regex {
 
     /// Return a non-capturing result for a single match.
     pub fn find<'t>(&self, chunk: &'t IOChunk) -> UResult<Option<Match<'t>>> {
-        match self {
-            Regex::Literal(m) => {
+        match &self.engine {
+            RegexEngine::Literal(m) => {
                 let haystack = chunk.as_bytes();
                 match m.find(haystack) {
                     Some((start, end, text)) => Ok(Some(Match { start, end, text })),
@@ -333,7 +350,7 @@ impl Regex {
                 }
             }
 
-            Regex::Byte(re) => {
+            RegexEngine::Byte(re) => {
                 let haystack = chunk.as_bytes();
                 if let Some(m) = re.find(haystack) {
                     // Attempt UTF-8 decode for the match region only
@@ -349,7 +366,7 @@ impl Regex {
                 }
             }
 
-            Regex::Fancy(re) => {
+            RegexEngine::Fancy(re) => {
                 let text = chunk.as_str()?;
                 match re.find(text) {
                     Ok(Some(m)) => Ok(Some(Match {
@@ -358,7 +375,7 @@ impl Regex {
                         text: m.as_str(),
                     })),
                     Ok(None) => Ok(None),
-                    Err(e) => Err(USimpleError::new(2, e.to_string())),
+                    Err(e) => runtime_error(&self.loc, e.to_string()),
                 }
             }
         }
@@ -369,7 +386,7 @@ impl Regex {
 pub enum CaptureMatches<'t> {
     Literal(Box<dyn Iterator<Item = UResult<Captures<'t>>> + 't>),
     Byte(ByteCaptureMatches<'t, 't>),
-    Fancy(FancyCaptureMatches<'t, 't>),
+    Fancy(FancyCaptureMatches<'t, 't>, &'t ScriptLocation),
 }
 
 impl<'t> Iterator for CaptureMatches<'t> {
@@ -379,12 +396,12 @@ impl<'t> Iterator for CaptureMatches<'t> {
         match self {
             CaptureMatches::Literal(iter) => iter.next(),
             CaptureMatches::Byte(iter) => iter.next().map(|caps| Ok(Captures::Byte(caps))),
-            CaptureMatches::Fancy(iter) => match iter.next() {
+            CaptureMatches::Fancy(iter, loc) => match iter.next() {
                 Some(Ok(caps)) => Some(Ok(Captures::Fancy(caps))),
-                Some(Err(e)) => Some(Err(USimpleError::new(
-                    2,
+                Some(Err(e)) => Some(runtime_error(
+                    loc,
                     format!("error retrieving RE captures: {e}"),
-                ))),
+                )),
                 None => None,
             },
         }
@@ -588,25 +605,25 @@ mod tests {
     // Regex::new
     #[test]
     fn assert_byte_selection() {
-        let re = Regex::new(r"x*").unwrap();
-        assert!(matches!(re, Regex::Byte(_)));
+        let re = Regex::new_unlocated(r"x*").unwrap();
+        assert!(matches!(re.engine, RegexEngine::Byte(_)));
     }
 
     #[test]
     fn assert_fancy() {
-        let re = Regex::new(r"\d").unwrap();
-        assert!(matches!(re, Regex::Fancy(_)));
+        let re = Regex::new_unlocated(r"\d").unwrap();
+        assert!(matches!(re.engine, RegexEngine::Fancy(_)));
     }
 
     #[test]
     fn assert_literal() {
-        let re = Regex::new(r"x\.").unwrap();
-        assert!(matches!(re, Regex::Literal(_)));
+        let re = Regex::new_unlocated(r"x\.").unwrap();
+        assert!(matches!(re.engine, RegexEngine::Literal(_)));
     }
 
     #[test]
     fn handles_invalid_regex_gracefully() {
-        let err = Regex::new("(").unwrap_err().to_string();
+        let err = Regex::new_unlocated("(").unwrap_err().to_string();
         assert!(
             err.contains("unclosed group") || err.contains("error parsing"),
             "Unexpected error: {}",
diff --git a/tests/by-util/test_sed.rs b/tests/by-util/test_sed.rs
index edc778bf..498674a2 100644
--- a/tests/by-util/test_sed.rs
+++ b/tests/by-util/test_sed.rs
@@ -926,3 +926,12 @@ fn test_undefined_label() {
         .code_is(1)
         .stderr_is("sed: <script argument 1>:1:1: error: undefined label `foo'\n");
 }
+
+#[test]
+fn test_fancy_regex_error() {
+    new_ucmd!()
+        .args(&["-E", r"/(\.+)+\1b$/p", "input/dots-4k.txt"])
+        .fails()
+        .code_is(2)
+        .stderr_is("sed: <script argument 1>:1:1: error: Error executing regex: Max limit for backtracking count exceeded\n");
+}

From a92be4e3ac9d30e9bc5cb0fc245840409785f842 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Mon, 16 Jun 2025 11:00:43 +0300
Subject: [PATCH 09/15] Improve write file error reporting

---
 src/uu/sed/src/compiler.rs     |  6 ++++--
 src/uu/sed/src/named_writer.rs | 34 +++++++++++++++++++++++++---------
 tests/by-util/test_sed.rs      |  9 +++++++++
 3 files changed, 38 insertions(+), 11 deletions(-)

diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index 245c58ec..3ba7e1f9 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.rs
@@ -999,8 +999,9 @@ pub fn compile_subst_flags(
             }
 
             'w' => {
+                let location = ScriptLocation::at_position(lines, line);
                 let path = read_file_path(lines, line)?;
-                subst.write_file = Some(NamedWriter::new(path)?);
+                subst.write_file = Some(NamedWriter::new(path, location)?);
                 return Ok(()); // 'w' is the last flag allowed
             }
 
@@ -1202,8 +1203,9 @@ fn compile_command(
         }
         CommandArgs::WriteFile => {
             // w
+            let location = ScriptLocation::at_position(lines, line);
             let path = read_file_path(lines, line)?;
-            cmd.data = CommandData::NamedWriter(NamedWriter::new(path)?);
+            cmd.data = CommandData::NamedWriter(NamedWriter::new(path, location)?);
         }
     }
 
diff --git a/src/uu/sed/src/named_writer.rs b/src/uu/sed/src/named_writer.rs
index 003c4a05..fcee964e 100644
--- a/src/uu/sed/src/named_writer.rs
+++ b/src/uu/sed/src/named_writer.rs
@@ -8,6 +8,8 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use crate::error_handling::{ScriptLocation, runtime_error};
+
 use std::cell::RefCell;
 use std::fs::{File, OpenOptions};
 use std::io::{BufWriter, Write};
@@ -15,7 +17,7 @@ use std::path::PathBuf;
 use std::rc::Rc;
 
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult};
+use uucore::error::UResult;
 
 thread_local! {
     /// Global list of all writers that should be flushed at shutdown
@@ -26,22 +28,27 @@ thread_local! {
 /// Writer that tracks its file name for better error messages
 pub struct NamedWriter {
     pub path: PathBuf,
-    pub writer: BufWriter<File>,
+    writer: BufWriter<File>,
+    location: ScriptLocation,
 }
 
 impl NamedWriter {
     /// Create a new writer, truncate the file, and register it for flushing.
-    pub fn new(path: PathBuf) -> UResult<Rc<RefCell<Self>>> {
+    pub fn new(path: PathBuf, location: ScriptLocation) -> UResult<Rc<RefCell<Self>>> {
         let file = OpenOptions::new()
             .create(true)
             .write(true)
             .truncate(true)
             .open(&path)
-            .map_err_context(|| format!("error opening output file {}", path.quote()))?;
+            .map_err(|e| {
+                runtime_error::<()>(&location, format!("creating file {}: {}", path.quote(), e))
+                    .unwrap_err()
+            })?;
 
         let writer = Rc::new(RefCell::new(NamedWriter {
             path,
             writer: BufWriter::new(file),
+            location,
         }));
 
         FLUSH_LIST.with(|list| list.borrow_mut().push(Rc::clone(&writer)));
@@ -50,15 +57,24 @@ impl NamedWriter {
 
     /// Write a line to the file with a newline, returning descriptive errors.
     pub fn write_line(&mut self, line: &str) -> UResult<()> {
-        writeln!(self.writer, "{line}")
-            .map_err_context(|| format!("error writing to file {}", self.path.quote()))
+        writeln!(self.writer, "{line}").map_err(|e| {
+            runtime_error::<()>(
+                &self.location,
+                format!("writing to file {}: {e}", self.path.quote()),
+            )
+            .unwrap_err()
+        })
     }
 
     /// Flush the writer, returning a descriptive error.
     pub fn flush(&mut self) -> UResult<()> {
-        self.writer
-            .flush()
-            .map_err_context(|| format!("error writing to file {}", self.path.quote()))
+        self.writer.flush().map_err(|e| {
+            runtime_error::<()>(
+                &self.location,
+                format!("writing to file {}: {}", self.path.quote(), e),
+            )
+            .unwrap_err()
+        })
     }
 }
 
diff --git a/tests/by-util/test_sed.rs b/tests/by-util/test_sed.rs
index 498674a2..ac6af8c9 100644
--- a/tests/by-util/test_sed.rs
+++ b/tests/by-util/test_sed.rs
@@ -935,3 +935,12 @@ fn test_fancy_regex_error() {
         .code_is(2)
         .stderr_is("sed: <script argument 1>:1:1: error: Error executing regex: Max limit for backtracking count exceeded\n");
 }
+
+#[test]
+fn test_write_file_failure() {
+    new_ucmd!()
+        .args(&["w /xyzzy/xyzy", LINES1])
+        .fails()
+        .code_is(2)
+        .stderr_is("sed: <script argument 1>:1:1: error: creating file '/xyzzy/xyzy': The system cannot find the path specified. (os error 3)\n");
+}

From f14f2e1daa157311e0f8a6ca7bccf2d2dd7692b1 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Mon, 16 Jun 2025 11:27:15 +0300
Subject: [PATCH 10/15] Improve empty RE error reporting

---
 src/uu/sed/src/processor.rs | 17 ++++++++++-------
 tests/by-util/test_sed.rs   | 18 ++++++++++++++++++
 2 files changed, 28 insertions(+), 7 deletions(-)

diff --git a/src/uu/sed/src/processor.rs b/src/uu/sed/src/processor.rs
index aa9be161..2523818b 100644
--- a/src/uu/sed/src/processor.rs
+++ b/src/uu/sed/src/processor.rs
@@ -12,6 +12,7 @@ use crate::command::{
     Address, AddressType, AddressValue, AppendElement, Command, CommandData, InputAction,
     ProcessingContext, Transliteration,
 };
+use crate::error_handling::{ScriptLocation, runtime_error};
 use crate::fast_io::{IOChunk, LineReader, OutputBuffer};
 use crate::fast_regex::Regex;
 use crate::in_place::InPlace;
@@ -23,7 +24,7 @@ use std::io::{self, IsTerminal};
 use std::path::PathBuf;
 use std::rc::Rc;
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult, USimpleError, set_exit_code};
+use uucore::error::{FromIo, UResult, set_exit_code};
 
 /// Return the specified command variant or panic.
 // Example: let path = extract_variant!(command, Path);
@@ -41,11 +42,12 @@ fn match_address(
     addr: &Address,
     pattern: &mut IOChunk,
     context: &mut ProcessingContext,
+    location: &ScriptLocation,
 ) -> UResult<bool> {
     match addr.atype {
         AddressType::Re => {
             if let AddressValue::Regex(ref re) = addr.value {
-                let regex = re_or_saved_re(re, context)?;
+                let regex = re_or_saved_re(re, context, location)?;
                 regex.is_match(pattern)
             } else {
                 Ok(false)
@@ -99,7 +101,7 @@ fn applies(
                     }
                 }
                 _ => {
-                    if match_address(addr2, pattern, context)? {
+                    if match_address(addr2, pattern, context, &command.location)? {
                         command.start_line = None;
                         context.last_address = true;
                         Ok(true)
@@ -120,7 +122,7 @@ fn applies(
                 }
             }
         } else if let Some(addr1) = &command.addr1 {
-            if match_address(addr1, pattern, context)? {
+            if match_address(addr1, pattern, context, &command.location)? {
                 match addr2.atype {
                     AddressType::Line => {
                         if let AddressValue::LineNumber(n) = addr2.value {
@@ -150,7 +152,7 @@ fn applies(
             Ok(false)
         }
     } else if let Some(addr1) = &command.addr1 {
-        Ok(match_address(addr1, pattern, context)?)
+        Ok(match_address(addr1, pattern, context, &command.location)?)
     } else {
         Ok(false)
     };
@@ -182,6 +184,7 @@ fn write_chunk(
 fn re_or_saved_re<'a>(
     regex: &Option<Regex>,
     context: &'a mut ProcessingContext,
+    location: &ScriptLocation,
 ) -> UResult<&'a Regex> {
     if let Some(re) = regex {
         // First time we see this regex: clone it *once* into the context.
@@ -192,7 +195,7 @@ fn re_or_saved_re<'a>(
         // We already have one: just borrow it.
         Ok(saved_re)
     } else {
-        Err(USimpleError::new(2, "no previous regular expression"))
+        runtime_error(location, "no previous regular expression")
     }
 }
 
@@ -212,7 +215,7 @@ fn substitute(
 
     let mut text: Option<&str> = None;
 
-    let regex = re_or_saved_re(&sub.regex, context)?;
+    let regex = re_or_saved_re(&sub.regex, context, &command.location)?;
 
     match (sub.occurrence, sub.replacement.max_group_number) {
         (1, 0) => {
diff --git a/tests/by-util/test_sed.rs b/tests/by-util/test_sed.rs
index ac6af8c9..cd530e29 100644
--- a/tests/by-util/test_sed.rs
+++ b/tests/by-util/test_sed.rs
@@ -944,3 +944,21 @@ fn test_write_file_failure() {
         .code_is(2)
         .stderr_is("sed: <script argument 1>:1:1: error: creating file '/xyzzy/xyzy': The system cannot find the path specified. (os error 3)\n");
 }
+
+#[test]
+fn test_missing_substitute_re() {
+    new_ucmd!()
+        .args(&["l;s//foo/", LINES1])
+        .fails()
+        .code_is(2)
+        .stderr_is("sed: <script argument 1>:1:3: error: no previous regular expression\n");
+}
+
+#[test]
+fn test_missing_address_re() {
+    new_ucmd!()
+        .args(&["l\np;//s/foo/bar/", LINES1])
+        .fails()
+        .code_is(2)
+        .stderr_is("sed: <script argument 1>:2:3: error: no previous regular expression\n");
+}

From 7d57a75285f30d3f55c4d6b8b0564d6ab8650c30 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Mon, 16 Jun 2025 11:44:12 +0300
Subject: [PATCH 11/15] Allow for different errno strings

---
 tests/by-util/test_sed.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/by-util/test_sed.rs b/tests/by-util/test_sed.rs
index cd530e29..9fe23e82 100644
--- a/tests/by-util/test_sed.rs
+++ b/tests/by-util/test_sed.rs
@@ -942,7 +942,7 @@ fn test_write_file_failure() {
         .args(&["w /xyzzy/xyzy", LINES1])
         .fails()
         .code_is(2)
-        .stderr_is("sed: <script argument 1>:1:1: error: creating file '/xyzzy/xyzy': The system cannot find the path specified. (os error 3)\n");
+        .stderr_contains("sed: <script argument 1>:1:1: error: creating file '/xyzzy/xyzy':");
 }
 
 #[test]

From 1eb155400ee8a6478657b3fa33348bad48c330a6 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Mon, 16 Jun 2025 12:52:34 +0300
Subject: [PATCH 12/15] Collapse Regex back into an enum

Only provide location to the Fancy RE engine, which is the only one
requiring it. This should improve the following 2-10% fall in benchmark
results that appeared with the improved error reporting.

This is the original fall in performance after adding error location
information..
           no-op-short previous is  1.05 times faster than error-loc
      access-log-no-op previous is  1.05 times faster than error-loc
   access-log-no-subst previous is  1.06 times faster than error-loc
      access-log-subst previous is  1.05 times faster than error-loc
     access-log-no-del previous is  1.07 times faster than error-loc
    access-log-all-del previous is  1.05 times faster than error-loc
   access-log-translit previous is  1.06 times faster than error-loc
access-log-complex-sub previous is  1.01 times faster than error-loc
             remove-cr previous is  1.07 times faster than error-loc
          genome-subst previous is  1.10 times faster than error-loc
            number-fix previous is  1.11 times faster than error-loc
           long-script previous is  1.03 times faster than error-loc
                 hanoi error-loc     is similarly fast as   previous
             factorial previous is  1.02 times faster than error-loc

The change of this commit improves performance in most cases as follows.
           no-op-short error-loc is  1.05 times faster than collaped-re
      access-log-no-op collaped-re is  1.04 times faster than error-loc
   access-log-no-subst collaped-re is  1.05 times faster than error-loc
      access-log-subst collaped-re is  1.04 times faster than error-loc
     access-log-no-del collaped-re is  1.05 times faster than error-loc
    access-log-all-del collaped-re is  1.05 times faster than error-loc
   access-log-translit error-loc     is similarly fast as   collaped-re
access-log-complex-sub collaped-re is  1.02 times faster than error-loc
             remove-cr collaped-re is  1.05 times faster than error-loc
          genome-subst collaped-re is  1.06 times faster than error-loc
            number-fix collaped-re is  1.05 times faster than error-loc
           long-script collaped-re is  1.01 times faster than error-loc
                 hanoi error-loc is  1.01 times faster than collaped-re
             factorial collaped-re is  1.03 times faster than error-loc

This results in a smaller pessimization over the original version before
the error location information was added.
           no-op-short previous is  1.10 times faster than collaped-re
      access-log-no-op previous is  1.02 times faster than collaped-re
   access-log-no-subst previous is  1.01 times faster than collaped-re
      access-log-subst collaped-re     is similarly fast as   previous
     access-log-no-del previous is  1.02 times faster than collaped-re
    access-log-all-del collaped-re     is similarly fast as   previous
   access-log-translit previous is  1.06 times faster than collaped-re
access-log-complex-sub collaped-re is  1.01 times faster than previous
             remove-cr previous is  1.02 times faster than collaped-re
          genome-subst previous is  1.04 times faster than collaped-re
            number-fix previous is  1.06 times faster than collaped-re
           long-script previous is  1.02 times faster than collaped-re
                 hanoi previous is  1.01 times faster than collaped-re
             factorial collaped-re     is similarly fast as   previous
---
 src/uu/sed/src/fast_regex.rs | 87 +++++++++++++++++-------------------
 1 file changed, 41 insertions(+), 46 deletions(-)

diff --git a/src/uu/sed/src/fast_regex.rs b/src/uu/sed/src/fast_regex.rs
index bb9c0bcd..a329bcae 100644
--- a/src/uu/sed/src/fast_regex.rs
+++ b/src/uu/sed/src/fast_regex.rs
@@ -236,29 +236,24 @@ pub fn remove_escapes(pattern: &str) -> String {
 
 #[derive(Clone, Debug)]
 /// A regular expression that can be implemented in diverse efficient ways
-pub enum RegexEngine {
-    Literal(LiteralMatcher), // Fastest: literal bytes
-    Byte(ByteRegex),         // Slower: byte-based RE
-    Fancy(FancyRegex),       // Slowest: RE supporting UTF-8 and back-references
-}
-
-#[derive(Clone, Debug)]
-pub struct Regex {
-    loc: ScriptLocation,
-    engine: RegexEngine,
+pub enum Regex {
+    Literal(LiteralMatcher),           // Fastest: literal bytes
+    Byte(ByteRegex),                   // Slower: byte-based RE
+    Fancy(FancyRegex, ScriptLocation), // Slowest: RE supporting UTF-8 and back-references
 }
 
 impl Regex {
     /// Construct the most efficient RE-like matching engine possible.
-    pub fn new(loc: ScriptLocation, pattern: &str) -> Result<Self, Box<dyn Error>> {
-        let engine = if NEEDS_FANCY_RE.is_match(pattern) {
-            RegexEngine::Fancy(FancyRegex::new(pattern)?)
+    pub fn new(location: ScriptLocation, pattern: &str) -> Result<Self, Box<dyn Error>> {
+        if NEEDS_FANCY_RE.is_match(pattern) {
+            Ok(Regex::Fancy(FancyRegex::new(pattern)?, location))
         } else if NEEDS_RE.is_match(pattern) {
-            RegexEngine::Byte(ByteRegex::new(pattern)?)
+            Ok(Regex::Byte(ByteRegex::new(pattern)?))
         } else {
-            RegexEngine::Literal(LiteralMatcher::new(&remove_escapes(pattern)))
-        };
-        Ok(Regex { loc, engine })
+            Ok(Regex::Literal(LiteralMatcher::new(&remove_escapes(
+                pattern,
+            ))))
+        }
     }
 
     #[cfg(test)]
@@ -269,14 +264,14 @@ impl Regex {
 
     /// Check if the regex matches the content of the IOChunk.
     pub fn is_match(&self, chunk: &mut IOChunk) -> UResult<bool> {
-        match &self.engine {
-            RegexEngine::Literal(m) => Ok(m.is_match(chunk.as_bytes())),
-            RegexEngine::Byte(re) => Ok(re.is_match(chunk.as_bytes())),
-            RegexEngine::Fancy(re) => {
+        match self {
+            Regex::Literal(m) => Ok(m.is_match(chunk.as_bytes())),
+            Regex::Byte(re) => Ok(re.is_match(chunk.as_bytes())),
+            Regex::Fancy(re, location) => {
                 let text = chunk.as_str()?;
                 match re.is_match(text) {
                     Ok(found) => Ok(found),
-                    Err(e) => runtime_error(&self.loc, e.to_string()),
+                    Err(e) => runtime_error(location, e.to_string()),
                 }
             }
         }
@@ -284,36 +279,36 @@ impl Regex {
 
     /// Return an iterator over capture groups.
     pub fn captures_iter<'t>(&'t self, chunk: &'t IOChunk) -> UResult<CaptureMatches<'t>> {
-        match &self.engine {
-            RegexEngine::Literal(m) => {
+        match self {
+            Regex::Literal(m) => {
                 let haystack = chunk.as_bytes();
                 Ok(CaptureMatches::Literal(Box::new(m.iter(haystack).map(
                     |(start, end, text)| Ok(Captures::Literal(Match { start, end, text })),
                 ))))
             }
 
-            RegexEngine::Byte(re) => Ok(CaptureMatches::Byte(re.captures_iter(chunk.as_bytes()))),
+            Regex::Byte(re) => Ok(CaptureMatches::Byte(re.captures_iter(chunk.as_bytes()))),
 
-            RegexEngine::Fancy(re) => {
+            Regex::Fancy(re, location) => {
                 let text = chunk.as_str()?;
-                Ok(CaptureMatches::Fancy(re.captures_iter(text), &self.loc))
+                Ok(CaptureMatches::Fancy(re.captures_iter(text), location))
             }
         }
     }
 
     /// Return the number of capture groups, including group 0.
     pub fn captures_len(&self) -> usize {
-        match &self.engine {
-            RegexEngine::Literal(_) => 1, // Only group 0
-            RegexEngine::Byte(re) => re.captures_len(),
-            RegexEngine::Fancy(re) => re.captures_len(),
+        match self {
+            Regex::Literal(_) => 1, // Only group 0
+            Regex::Byte(re) => re.captures_len(),
+            Regex::Fancy(re, _location) => re.captures_len(),
         }
     }
 
     /// Return the elements of the first capture.
     pub fn captures<'t>(&self, chunk: &'t IOChunk) -> UResult<Option<Captures<'t>>> {
-        match &self.engine {
-            RegexEngine::Literal(m) => {
+        match self {
+            Regex::Literal(m) => {
                 let haystack = chunk.as_bytes();
                 match m.find(haystack) {
                     Some((start, end, text)) => {
@@ -323,17 +318,17 @@ impl Regex {
                 }
             }
 
-            RegexEngine::Byte(re) => {
+            Regex::Byte(re) => {
                 let bytes = chunk.as_bytes();
                 Ok(re.captures(bytes).map(Captures::Byte))
             }
 
-            RegexEngine::Fancy(re) => {
+            Regex::Fancy(re, location) => {
                 let text = chunk.as_str()?;
                 match re.captures(text) {
                     Ok(Some(caps)) => Ok(Some(Captures::Fancy(caps))),
                     Ok(None) => Ok(None),
-                    Err(e) => runtime_error(&self.loc, e.to_string()),
+                    Err(e) => runtime_error(location, e.to_string()),
                 }
             }
         }
@@ -341,8 +336,8 @@ impl Regex {
 
     /// Return a non-capturing result for a single match.
     pub fn find<'t>(&self, chunk: &'t IOChunk) -> UResult<Option<Match<'t>>> {
-        match &self.engine {
-            RegexEngine::Literal(m) => {
+        match self {
+            Regex::Literal(m) => {
                 let haystack = chunk.as_bytes();
                 match m.find(haystack) {
                     Some((start, end, text)) => Ok(Some(Match { start, end, text })),
@@ -350,7 +345,7 @@ impl Regex {
                 }
             }
 
-            RegexEngine::Byte(re) => {
+            Regex::Byte(re) => {
                 let haystack = chunk.as_bytes();
                 if let Some(m) = re.find(haystack) {
                     // Attempt UTF-8 decode for the match region only
@@ -366,7 +361,7 @@ impl Regex {
                 }
             }
 
-            RegexEngine::Fancy(re) => {
+            Regex::Fancy(re, location) => {
                 let text = chunk.as_str()?;
                 match re.find(text) {
                     Ok(Some(m)) => Ok(Some(Match {
@@ -375,7 +370,7 @@ impl Regex {
                         text: m.as_str(),
                     })),
                     Ok(None) => Ok(None),
-                    Err(e) => runtime_error(&self.loc, e.to_string()),
+                    Err(e) => runtime_error(location, e.to_string()),
                 }
             }
         }
@@ -396,10 +391,10 @@ impl<'t> Iterator for CaptureMatches<'t> {
         match self {
             CaptureMatches::Literal(iter) => iter.next(),
             CaptureMatches::Byte(iter) => iter.next().map(|caps| Ok(Captures::Byte(caps))),
-            CaptureMatches::Fancy(iter, loc) => match iter.next() {
+            CaptureMatches::Fancy(iter, location) => match iter.next() {
                 Some(Ok(caps)) => Some(Ok(Captures::Fancy(caps))),
                 Some(Err(e)) => Some(runtime_error(
-                    loc,
+                    location,
                     format!("error retrieving RE captures: {e}"),
                 )),
                 None => None,
@@ -606,19 +601,19 @@ mod tests {
     #[test]
     fn assert_byte_selection() {
         let re = Regex::new_unlocated(r"x*").unwrap();
-        assert!(matches!(re.engine, RegexEngine::Byte(_)));
+        assert!(matches!(re, Regex::Byte(_)));
     }
 
     #[test]
     fn assert_fancy() {
         let re = Regex::new_unlocated(r"\d").unwrap();
-        assert!(matches!(re.engine, RegexEngine::Fancy(_)));
+        assert!(matches!(re, Regex::Fancy(_, _)));
     }
 
     #[test]
     fn assert_literal() {
         let re = Regex::new_unlocated(r"x\.").unwrap();
-        assert!(matches!(re.engine, RegexEngine::Literal(_)));
+        assert!(matches!(re, Regex::Literal(_)));
     }
 
     #[test]

From 46a0f78218be64f8d7b5a744234ca6afd507515d Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Tue, 17 Jun 2025 10:42:34 +0300
Subject: [PATCH 13/15] Move script location outside fast_regex

Instead, detect and handle runtime errors at the point where regex
methods are called.

This is always faster or the same as the preceding method.

           no-op-short current is  1.03 times faster than preceding
      access-log-no-op current     is similarly fast as   preceding
   access-log-no-subst current is  1.05 times faster than preceding
      access-log-subst current     is similarly fast as   preceding
     access-log-no-del current is  1.05 times faster than preceding
    access-log-all-del current is  1.04 times faster than preceding
   access-log-translit current     is similarly fast as   preceding
access-log-complex-sub current     is similarly fast as   preceding
             remove-cr current is  1.03 times faster than preceding
          genome-subst current     is similarly fast as   preceding
            number-fix current     is similarly fast as   preceding
           long-script current is  1.01 times faster than preceding
                 hanoi current is  1.02 times faster than preceding
             factorial current     is similarly fast as   preceding

Also, this rectified most performance pessimization introduced by adding
error locations in fast_regex.

           no-op-short previous  is  1.07 times faster than error-loc
      access-log-no-op previous     is similarly fast as    error-loc
   access-log-no-subst error-loc is  1.04 times faster than previous
      access-log-subst previous     is similarly fast as    error-loc
     access-log-no-del error-loc is  1.03 times faster than previous
    access-log-all-del error-loc is  1.04 times faster than previous
   access-log-translit previous  is  1.06 times faster than error-loc
access-log-complex-sub error-loc is  1.02 times faster than previous
             remove-cr previous     is similarly fast as    error-loc
          genome-subst previous  is  1.04 times faster than error-loc
            number-fix previous  is  1.06 times faster than error-loc
           long-script previous     is similarly fast as    error-loc
                 hanoi previous     is similarly fast as    error-loc
             factorial previous     is similarly fast as    error-loc

TODO: In fast_regex distinguish between UTF-8 conversion and regex
errors.  The former should be reported as I/O errors with input file
location info, which the latter should be reported as script errors
with script file location info.
---
 src/uu/sed/src/command.rs    |   2 +-
 src/uu/sed/src/compiler.rs   |  47 ++++------------
 src/uu/sed/src/fast_regex.rs |  66 ++++++++++-------------
 src/uu/sed/src/processor.rs  | 101 +++++++++++++++++++++--------------
 tests/by-util/test_sed.rs    |  31 ++++++++++-
 5 files changed, 128 insertions(+), 119 deletions(-)

diff --git a/src/uu/sed/src/command.rs b/src/uu/sed/src/command.rs
index 249c0d8c..db701a49 100644
--- a/src/uu/sed/src/command.rs
+++ b/src/uu/sed/src/command.rs
@@ -348,7 +348,7 @@ mod tests {
 
     // Return the captures for the RE applied to the specified string
     fn caps_for<'a>(re: &str, chunk: &'a mut IOChunk) -> Captures<'a> {
-        Regex::new(ScriptLocation::default(), re)
+        Regex::new(re)
             .unwrap()
             .captures(chunk)
             .unwrap()
diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index 3ba7e1f9..7fbc8eed 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.rs
@@ -310,7 +310,6 @@ fn populate_label_map(
             if cmd.code == ':' {
                 if context.label_to_command_map.contains_key(&label) {
                     return semantic_error(&cmd.location, format!("duplicate label `{label}'"));
->>>>>>> a429b31 (Isolate error location into separate struct)
                 }
                 context.label_to_command_map.insert(label, rc_cmd.clone());
             }
@@ -509,7 +508,6 @@ fn compile_address(
     match line.current() {
         '\\' | '/' => {
             // Regular expression
-            let location = ScriptLocation::at_position(lines, line);
             if line.current() == '\\' {
                 // The next character is an arbitrary delimiter
                 line.advance();
@@ -526,9 +524,7 @@ fn compile_address(
 
             Ok(Address {
                 atype: AddressType::Re,
-                value: AddressValue::Regex(compile_regex(
-                    lines, line, &location, &re, context, icase,
-                )?),
+                value: AddressValue::Regex(compile_regex(lines, line, &re, context, icase)?),
             })
         }
         '$' => {
@@ -691,7 +687,6 @@ fn bre_to_ere(pattern: &str) -> String {
 fn compile_regex(
     lines: &ScriptLineProvider,
     line: &ScriptCharProvider,
-    location: &ScriptLocation,
     pattern: &str,
     context: &ProcessingContext,
     icase: bool,
@@ -715,7 +710,7 @@ fn compile_regex(
     };
 
     // Compile into engine.
-    let compiled = Regex::new(location.clone(), &pattern).map_err(|e| {
+    let compiled = Regex::new(&pattern).map_err(|e| {
         compilation_error::<Regex>(lines, line, format!("invalid regex '{pattern}': {e}"))
             .unwrap_err()
     })?;
@@ -852,7 +847,6 @@ fn compile_subst_command(
         );
     }
 
-    let location = ScriptLocation::at_position(lines, line);
     let pattern = parse_regex(lines, line)?;
 
     let mut subst = Box::new(Substitution {
@@ -872,7 +866,7 @@ fn compile_subst_command(
     }
 
     // Compile regex with now known ignore_case flag.
-    subst.regex = compile_regex(lines, line, &location, &pattern, context, subst.ignore_case)?;
+    subst.regex = compile_regex(lines, line, &pattern, context, subst.ignore_case)?;
 
     // Catch invalid group references at compile time, if possible.
     if let Some(regex) = &subst.regex {
@@ -1482,16 +1476,9 @@ mod tests {
     #[test]
     fn test_compile_re_basic() {
         let (lines, chars) = dummy_providers();
-        let regex = compile_regex(
-            &lines,
-            &chars,
-            &ScriptLocation::default(),
-            "abc",
-            &ctx(),
-            false,
-        )
-        .unwrap()
-        .expect("regex should be present");
+        let regex = compile_regex(&lines, &chars, "abc", &ctx(), false)
+            .unwrap()
+            .expect("regex should be present");
         assert!(regex.is_match(&mut IOChunk::from_str("abc")).unwrap());
         assert!(!regex.is_match(&mut IOChunk::from_str("ABC")).unwrap());
     }
@@ -1499,16 +1486,9 @@ mod tests {
     #[test]
     fn test_compile_re_case_insensitive() {
         let (lines, chars) = dummy_providers();
-        let regex = compile_regex(
-            &lines,
-            &chars,
-            &ScriptLocation::default(),
-            "abc",
-            &ctx(),
-            true,
-        )
-        .unwrap()
-        .expect("regex should be present");
+        let regex = compile_regex(&lines, &chars, "abc", &ctx(), true)
+            .unwrap()
+            .expect("regex should be present");
         assert!(regex.is_match(&mut IOChunk::from_str("abc")).unwrap());
         assert!(regex.is_match(&mut IOChunk::from_str("ABC")).unwrap());
         assert!(regex.is_match(&mut IOChunk::from_str("AbC")).unwrap());
@@ -1517,14 +1497,7 @@ mod tests {
     #[test]
     fn test_compile_re_invalid() {
         let (lines, chars) = dummy_providers();
-        let result = compile_regex(
-            &lines,
-            &chars,
-            &ScriptLocation::default(),
-            "a[d",
-            &ctx(),
-            false,
-        );
+        let result = compile_regex(&lines, &chars, "a[d", &ctx(), false);
         assert!(result.is_err()); // Should fail due to open bracketed expression
     }
 
diff --git a/src/uu/sed/src/fast_regex.rs b/src/uu/sed/src/fast_regex.rs
index a329bcae..cc284853 100644
--- a/src/uu/sed/src/fast_regex.rs
+++ b/src/uu/sed/src/fast_regex.rs
@@ -11,8 +11,6 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use crate::error_handling::{ScriptLocation, runtime_error};
-
 use fancy_regex::{
     CaptureMatches as FancyCaptureMatches, Captures as FancyCaptures, Regex as FancyRegex,
 };
@@ -237,42 +235,32 @@ pub fn remove_escapes(pattern: &str) -> String {
 #[derive(Clone, Debug)]
 /// A regular expression that can be implemented in diverse efficient ways
 pub enum Regex {
-    Literal(LiteralMatcher),           // Fastest: literal bytes
-    Byte(ByteRegex),                   // Slower: byte-based RE
-    Fancy(FancyRegex, ScriptLocation), // Slowest: RE supporting UTF-8 and back-references
+    Literal(LiteralMatcher), // Fastest: literal bytes
+    Byte(ByteRegex),         // Slower: byte-based RE
+    Fancy(FancyRegex),       // Slowest: RE supporting UTF-8 and back-references
 }
 
 impl Regex {
     /// Construct the most efficient RE-like matching engine possible.
-    pub fn new(location: ScriptLocation, pattern: &str) -> Result<Self, Box<dyn Error>> {
+    pub fn new(pattern: &str) -> Result<Self, Box<dyn Error>> {
         if NEEDS_FANCY_RE.is_match(pattern) {
-            Ok(Regex::Fancy(FancyRegex::new(pattern)?, location))
+            Ok(Self::Fancy(FancyRegex::new(pattern)?))
         } else if NEEDS_RE.is_match(pattern) {
-            Ok(Regex::Byte(ByteRegex::new(pattern)?))
+            Ok(Self::Byte(ByteRegex::new(pattern)?))
         } else {
-            Ok(Regex::Literal(LiteralMatcher::new(&remove_escapes(
-                pattern,
-            ))))
+            Ok(Self::Literal(LiteralMatcher::new(&remove_escapes(pattern))))
         }
     }
 
-    #[cfg(test)]
-    /// Construct with a default location
-    pub fn new_unlocated(pattern: &str) -> Result<Self, Box<dyn Error>> {
-        Regex::new(ScriptLocation::default(), pattern)
-    }
-
     /// Check if the regex matches the content of the IOChunk.
     pub fn is_match(&self, chunk: &mut IOChunk) -> UResult<bool> {
         match self {
             Regex::Literal(m) => Ok(m.is_match(chunk.as_bytes())),
             Regex::Byte(re) => Ok(re.is_match(chunk.as_bytes())),
-            Regex::Fancy(re, location) => {
+            Regex::Fancy(re) => {
                 let text = chunk.as_str()?;
-                match re.is_match(text) {
-                    Ok(found) => Ok(found),
-                    Err(e) => runtime_error(location, e.to_string()),
-                }
+                re.is_match(text)
+                    .map_err(|e| USimpleError::new(2, e.to_string()))
             }
         }
     }
@@ -289,9 +277,9 @@ impl Regex {
 
             Regex::Byte(re) => Ok(CaptureMatches::Byte(re.captures_iter(chunk.as_bytes()))),
 
-            Regex::Fancy(re, location) => {
+            Regex::Fancy(re) => {
                 let text = chunk.as_str()?;
-                Ok(CaptureMatches::Fancy(re.captures_iter(text), location))
+                Ok(CaptureMatches::Fancy(re.captures_iter(text)))
             }
         }
     }
@@ -301,7 +289,7 @@ impl Regex {
         match self {
             Regex::Literal(_) => 1, // Only group 0
             Regex::Byte(re) => re.captures_len(),
-            Regex::Fancy(re, _location) => re.captures_len(),
+            Regex::Fancy(re) => re.captures_len(),
         }
     }
 
@@ -323,12 +311,12 @@ impl Regex {
                 Ok(re.captures(bytes).map(Captures::Byte))
             }
 
-            Regex::Fancy(re, location) => {
+            Regex::Fancy(re) => {
                 let text = chunk.as_str()?;
                 match re.captures(text) {
                     Ok(Some(caps)) => Ok(Some(Captures::Fancy(caps))),
                     Ok(None) => Ok(None),
-                    Err(e) => runtime_error(location, e.to_string()),
+                    Err(e) => Err(USimpleError::new(2, e.to_string())),
                 }
             }
         }
@@ -361,7 +349,7 @@ impl Regex {
                 }
             }
 
-            Regex::Fancy(re, location) => {
+            Regex::Fancy(re) => {
                 let text = chunk.as_str()?;
                 match re.find(text) {
                     Ok(Some(m)) => Ok(Some(Match {
@@ -370,7 +358,7 @@ impl Regex {
                         text: m.as_str(),
                     })),
                     Ok(None) => Ok(None),
-                    Err(e) => runtime_error(location, e.to_string()),
+                    Err(e) => Err(USimpleError::new(2, e.to_string())),
                 }
             }
         }
@@ -381,7 +369,7 @@ impl Regex {
 pub enum CaptureMatches<'t> {
     Literal(Box<dyn Iterator<Item = UResult<Captures<'t>>> + 't>),
     Byte(ByteCaptureMatches<'t, 't>),
-    Fancy(FancyCaptureMatches<'t, 't>, &'t ScriptLocation),
+    Fancy(FancyCaptureMatches<'t, 't>),
 }
 
 impl<'t> Iterator for CaptureMatches<'t> {
@@ -391,12 +379,12 @@ impl<'t> Iterator for CaptureMatches<'t> {
         match self {
             CaptureMatches::Literal(iter) => iter.next(),
             CaptureMatches::Byte(iter) => iter.next().map(|caps| Ok(Captures::Byte(caps))),
-            CaptureMatches::Fancy(iter, location) => match iter.next() {
+            CaptureMatches::Fancy(iter) => match iter.next() {
                 Some(Ok(caps)) => Some(Ok(Captures::Fancy(caps))),
-                Some(Err(e)) => Some(runtime_error(
-                    location,
+                Some(Err(e)) => Some(Err(USimpleError::new(
+                    2,
                     format!("error retrieving RE captures: {e}"),
-                )),
+                ))),
                 None => None,
             },
         }
@@ -600,25 +588,25 @@ mod tests {
     // Regex::new
     #[test]
     fn assert_byte_selection() {
-        let re = Regex::new_unlocated(r"x*").unwrap();
+        let re = Regex::new(r"x*").unwrap();
         assert!(matches!(re, Regex::Byte(_)));
     }
 
     #[test]
     fn assert_fancy() {
-        let re = Regex::new_unlocated(r"\d").unwrap();
-        assert!(matches!(re, Regex::Fancy(_, _)));
+        let re = Regex::new(r"\d").unwrap();
+        assert!(matches!(re, Regex::Fancy(_)));
     }
 
     #[test]
     fn assert_literal() {
-        let re = Regex::new_unlocated(r"x\.").unwrap();
+        let re = Regex::new(r"x\.").unwrap();
         assert!(matches!(re, Regex::Literal(_)));
     }
 
     #[test]
     fn handles_invalid_regex_gracefully() {
-        let err = Regex::new_unlocated("(").unwrap_err().to_string();
+        let err = Regex::new("(").unwrap_err().to_string();
         assert!(
             err.contains("unclosed group") || err.contains("error parsing"),
             "Unexpected error: {}",
diff --git a/src/uu/sed/src/processor.rs b/src/uu/sed/src/processor.rs
index 2523818b..98532311 100644
--- a/src/uu/sed/src/processor.rs
+++ b/src/uu/sed/src/processor.rs
@@ -48,7 +48,10 @@ fn match_address(
         AddressType::Re => {
             if let AddressValue::Regex(ref re) = addr.value {
                 let regex = re_or_saved_re(re, context, location)?;
-                regex.is_match(pattern)
+                match regex.is_match(pattern) {
+                    Ok(result) => Ok(result),
+                    Err(e) => runtime_error(location, e.to_string()),
+                }
             } else {
                 Ok(false)
             }
@@ -220,30 +223,40 @@ fn substitute(
     match (sub.occurrence, sub.replacement.max_group_number) {
         (1, 0) => {
             // Example: s/foo/bar/: find() is enough.
-            let m = regex.find(pattern)?;
-            if let Some(m) = m {
-                text = Some(pattern.as_str()?);
-                result.push_str(&text.unwrap()[last_end..m.start()]);
-
-                let replacement = sub.replacement.apply_match(&m);
-                result.push_str(&replacement);
-                replaced = true;
-                last_end = m.end();
+            match regex.find(pattern) {
+                Err(e) => {
+                    return runtime_error(&command.location, e.to_string());
+                }
+                Ok(Some(m)) => {
+                    text = Some(pattern.as_str()?);
+                    result.push_str(&text.unwrap()[last_end..m.start()]);
+
+                    let replacement = sub.replacement.apply_match(&m);
+                    result.push_str(&replacement);
+                    replaced = true;
+                    last_end = m.end();
+                }
+                Ok(None) => (), // No match
             }
         }
 
         (1, _) => {
             // Example: s/\(.\)\(.\)/\2\1/: captures() is enough.
-            let caps = regex.captures(pattern)?;
-            if let Some(caps) = caps {
-                let m = caps.get(0)?.unwrap();
-                text = Some(pattern.as_str()?);
-                result.push_str(&text.unwrap()[last_end..m.start()]);
-
-                let replacement = sub.replacement.apply_captures(command, &caps)?;
-                result.push_str(&replacement);
-                replaced = true;
-                last_end = m.end();
+            match regex.captures(pattern) {
+                Err(e) => {
+                    return runtime_error(&command.location, e.to_string());
+                }
+                Ok(Some(caps)) => {
+                    let m = caps.get(0)?.unwrap();
+                    text = Some(pattern.as_str()?);
+                    result.push_str(&text.unwrap()[last_end..m.start()]);
+
+                    let replacement = sub.replacement.apply_captures(command, &caps)?;
+                    result.push_str(&replacement);
+                    replaced = true;
+                    last_end = m.end();
+                }
+                Ok(None) => (), // No match
             }
         }
 
@@ -251,32 +264,38 @@ fn substitute(
             // Example: s/(.)(.)/\2\1/3: captures_iter() is needed.
             // Iterate over multiple captures of the RE in the pattern.
             for caps in regex.captures_iter(pattern)? {
-                count += 1;
-                let caps = caps?;
+                match caps {
+                    Err(e) => {
+                        return runtime_error(&command.location, e.to_string());
+                    }
+                    Ok(caps) => {
+                        count += 1;
 
-                let m = caps.get(0)?.unwrap();
+                        let m = caps.get(0)?.unwrap();
 
-                // Always write the unmatched text before this match.
-                if text.is_none() {
-                    text = Some(pattern.as_str()?);
-                }
-                result.push_str(&text.unwrap()[last_end..m.start()]);
+                        // Always write the unmatched text before this match.
+                        if text.is_none() {
+                            text = Some(pattern.as_str()?);
+                        }
+                        result.push_str(&text.unwrap()[last_end..m.start()]);
 
-                if sub.occurrence == 0 || count == sub.occurrence {
-                    let replacement = sub.replacement.apply_captures(command, &caps)?;
-                    result.push_str(&replacement);
-                    replaced = true;
-                } else {
-                    // Not the target match — leave the match unchanged.
-                    result.push_str(m.as_str());
-                }
+                        if sub.occurrence == 0 || count == sub.occurrence {
+                            let replacement = sub.replacement.apply_captures(command, &caps)?;
+                            result.push_str(&replacement);
+                            replaced = true;
+                        } else {
+                            // Not the target match — leave the match unchanged.
+                            result.push_str(m.as_str());
+                        }
 
-                last_end = m.end();
+                        last_end = m.end();
 
-                // Early exit if only a specific occurrence,
-                // (likely 1) needed replacing.
-                if count == sub.occurrence {
-                    break;
+                        // Early exit if only a specific occurrence,
+                        // (likely 1) needed replacing.
+                        if count == sub.occurrence {
+                            break;
+                        }
+                    }
                 }
             }
         }
diff --git a/tests/by-util/test_sed.rs b/tests/by-util/test_sed.rs
index 9fe23e82..d94d6d47 100644
--- a/tests/by-util/test_sed.rs
+++ b/tests/by-util/test_sed.rs
@@ -927,8 +927,10 @@ fn test_undefined_label() {
         .stderr_is("sed: <script argument 1>:1:1: error: undefined label `foo'\n");
 }
 
+// The following test diverse ways in which regexes are matched.
+// Search for 'regex\.' to find them in the code.
 #[test]
-fn test_fancy_regex_error() {
+fn test_fancy_regex_is_match_error() {
     new_ucmd!()
         .args(&["-E", r"/(\.+)+\1b$/p", "input/dots-4k.txt"])
         .fails()
@@ -936,6 +938,33 @@ fn test_fancy_regex_error() {
         .stderr_is("sed: <script argument 1>:1:1: error: Error executing regex: Max limit for backtracking count exceeded\n");
 }
 
+#[test]
+fn test_fancy_regex_find_error() {
+    new_ucmd!()
+        .args(&["-E", r"p;s/(\.+)+\1b$/X/", "input/dots-4k.txt"])
+        .fails()
+        .code_is(2)
+        .stderr_is("sed: <script argument 1>:1:3: error: Error executing regex: Max limit for backtracking count exceeded\n");
+}
+
+#[test]
+fn test_fancy_regex_captures_error() {
+    new_ucmd!()
+        .args(&["-E", r"p;s/(\.+)+\1b$/\1/", "input/dots-4k.txt"])
+        .fails()
+        .code_is(2)
+        .stderr_is("sed: <script argument 1>:1:3: error: Error executing regex: Max limit for backtracking count exceeded\n");
+}
+
+#[test]
+fn test_fancy_regex_captures_iter_error() {
+    new_ucmd!()
+        .args(&["-E", r"p;s/(\.+)+\1b$/\1/3", "input/dots-4k.txt"])
+        .fails()
+        .code_is(2)
+        .stderr_is("sed: <script argument 1>:1:3: error: error retrieving RE captures: Error executing regex: Max limit for backtracking count exceeded\n");
+}
+
 #[test]
 fn test_write_file_failure() {
     new_ucmd!()

From f734ba3078d3622e0c81731dbc6b93a17257a9bb Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Tue, 17 Jun 2025 19:10:20 +0300
Subject: [PATCH 14/15] Error with script and input file/line when needed

---
 src/uu/sed/src/command.rs        |  2 +
 src/uu/sed/src/error_handling.rs | 25 ++++++++++
 src/uu/sed/src/processor.rs      | 85 +++++++++++++++++---------------
 src/uu/sed/src/sed.rs            |  1 +
 tests/by-util/test_sed.rs        | 12 ++---
 5 files changed, 80 insertions(+), 45 deletions(-)

diff --git a/src/uu/sed/src/command.rs b/src/uu/sed/src/command.rs
index db701a49..24de7865 100644
--- a/src/uu/sed/src/command.rs
+++ b/src/uu/sed/src/command.rs
@@ -41,6 +41,8 @@ pub struct ProcessingContext {
     pub null_data: bool,
 
     // Other context
+    /// Currently processed input file name (not script) in quoted form
+    pub input_name: String,
     /// Current input line number
     pub line_number: usize,
     /// True if this is the last address of a range
diff --git a/src/uu/sed/src/error_handling.rs b/src/uu/sed/src/error_handling.rs
index 56967173..e8d83b01 100644
--- a/src/uu/sed/src/error_handling.rs
+++ b/src/uu/sed/src/error_handling.rs
@@ -8,6 +8,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use crate::command::ProcessingContext;
 use crate::script_char_provider::ScriptCharProvider;
 use crate::script_line_provider::ScriptLineProvider;
 
@@ -89,3 +90,27 @@ pub fn semantic_error<T>(location: &ScriptLocation, msg: impl ToString) -> UResu
 pub fn runtime_error<T>(location: &ScriptLocation, msg: impl ToString) -> UResult<T> {
     location_error(location, msg, 2)
 }
+
+/// Fail with msg as a runtime error at the command's and input's location.
+/// This is to be used in cases where the error depends on both, for example,
+/// a fancy regular expression applied on invalid UTF-8 input.
+/// (A fixed string match will not err in this case.)
+/// The error's exit code is 2 (processing phase).
+pub fn input_runtime_error<T>(
+    location: &ScriptLocation,
+    context: &ProcessingContext,
+    msg: impl ToString,
+) -> UResult<T> {
+    Err(USimpleError::new(
+        2,
+        format!(
+            "{}:{}:{}: {}:{} error: {}",
+            location.input_name,
+            location.line_number,
+            location.column_number,
+            context.input_name,
+            context.line_number,
+            msg.to_string()
+        ),
+    ))
+}
diff --git a/src/uu/sed/src/processor.rs b/src/uu/sed/src/processor.rs
index 98532311..d8d761b0 100644
--- a/src/uu/sed/src/processor.rs
+++ b/src/uu/sed/src/processor.rs
@@ -12,7 +12,7 @@ use crate::command::{
     Address, AddressType, AddressValue, AppendElement, Command, CommandData, InputAction,
     ProcessingContext, Transliteration,
 };
-use crate::error_handling::{ScriptLocation, runtime_error};
+use crate::error_handling::{ScriptLocation, input_runtime_error};
 use crate::fast_io::{IOChunk, LineReader, OutputBuffer};
 use crate::fast_regex::Regex;
 use crate::in_place::InPlace;
@@ -50,7 +50,7 @@ fn match_address(
                 let regex = re_or_saved_re(re, context, location)?;
                 match regex.is_match(pattern) {
                     Ok(result) => Ok(result),
-                    Err(e) => runtime_error(location, e.to_string()),
+                    Err(e) => input_runtime_error(location, context, e.to_string()),
                 }
             } else {
                 Ok(false)
@@ -198,7 +198,7 @@ fn re_or_saved_re<'a>(
         // We already have one: just borrow it.
         Ok(saved_re)
     } else {
-        runtime_error(location, "no previous regular expression")
+        input_runtime_error(location, context, "no previous regular expression")
     }
 }
 
@@ -220,13 +220,14 @@ fn substitute(
 
     let regex = re_or_saved_re(&sub.regex, context, &command.location)?;
 
-    match (sub.occurrence, sub.replacement.max_group_number) {
+    // The following let block allows a common input_runtime_error to be
+    // called once in all cases, and most importantly, to finish the regex
+    // mutable borrowing of context, so as to reuse context in the error call.
+    let subst_result = match (sub.occurrence, sub.replacement.max_group_number) {
         (1, 0) => {
             // Example: s/foo/bar/: find() is enough.
             match regex.find(pattern) {
-                Err(e) => {
-                    return runtime_error(&command.location, e.to_string());
-                }
+                Err(e) => Err(e),
                 Ok(Some(m)) => {
                     text = Some(pattern.as_str()?);
                     result.push_str(&text.unwrap()[last_end..m.start()]);
@@ -235,17 +236,16 @@ fn substitute(
                     result.push_str(&replacement);
                     replaced = true;
                     last_end = m.end();
+                    Ok(())
                 }
-                Ok(None) => (), // No match
+                Ok(None) => Ok(()), // No match
             }
         }
 
         (1, _) => {
             // Example: s/\(.\)\(.\)/\2\1/: captures() is enough.
             match regex.captures(pattern) {
-                Err(e) => {
-                    return runtime_error(&command.location, e.to_string());
-                }
+                Err(e) => Err(e),
                 Ok(Some(caps)) => {
                     let m = caps.get(0)?.unwrap();
                     text = Some(pattern.as_str()?);
@@ -255,50 +255,56 @@ fn substitute(
                     result.push_str(&replacement);
                     replaced = true;
                     last_end = m.end();
+                    Ok(())
                 }
-                Ok(None) => (), // No match
+                Ok(None) => Ok(()), // No match
             }
         }
 
         (_, _) => {
             // Example: s/(.)(.)/\2\1/3: captures_iter() is needed.
             // Iterate over multiple captures of the RE in the pattern.
-            for caps in regex.captures_iter(pattern)? {
-                match caps {
-                    Err(e) => {
-                        return runtime_error(&command.location, e.to_string());
-                    }
-                    Ok(caps) => {
-                        count += 1;
+            'captures: {
+                for caps_result in regex.captures_iter(pattern)? {
+                    let caps = match caps_result {
+                        Ok(caps) => caps,
+                        Err(e) => break 'captures Err(e),
+                    };
+                    count += 1;
 
-                        let m = caps.get(0)?.unwrap();
+                    let m = caps.get(0)?.unwrap();
 
-                        // Always write the unmatched text before this match.
-                        if text.is_none() {
-                            text = Some(pattern.as_str()?);
-                        }
-                        result.push_str(&text.unwrap()[last_end..m.start()]);
+                    // Always write the unmatched text before this match.
+                    if text.is_none() {
+                        text = Some(pattern.as_str()?);
+                    }
+                    result.push_str(&text.unwrap()[last_end..m.start()]);
 
-                        if sub.occurrence == 0 || count == sub.occurrence {
-                            let replacement = sub.replacement.apply_captures(command, &caps)?;
-                            result.push_str(&replacement);
-                            replaced = true;
-                        } else {
-                            // Not the target match — leave the match unchanged.
-                            result.push_str(m.as_str());
-                        }
+                    if sub.occurrence == 0 || count == sub.occurrence {
+                        let replacement = sub.replacement.apply_captures(command, &caps)?;
+                        result.push_str(&replacement);
+                        replaced = true;
+                    } else {
+                        // Not the target match — leave the match unchanged.
+                        result.push_str(m.as_str());
+                    }
 
-                        last_end = m.end();
+                    last_end = m.end();
 
-                        // Early exit if only a specific occurrence,
-                        // (likely 1) needed replacing.
-                        if count == sub.occurrence {
-                            break;
-                        }
+                    // Early exit if only a specific occurrence,
+                    // (likely 1) needed replacing.
+                    if count == sub.occurrence {
+                        break 'captures Ok(());
                     }
                 }
+                break 'captures Ok(());
             }
         }
+    };
+
+    // Handle errors.
+    if let Err(e) = subst_result {
+        return input_runtime_error(&command.location, context, e.to_string());
     }
 
     // Handle substitution success.
@@ -688,6 +694,7 @@ pub fn process_all_files(
         if context.separate {
             context.line_number = 0;
         }
+        context.input_name = path.quote().to_string();
         process_file(&commands, &mut reader, output, context)?;
 
         // Handle any N command remains.
diff --git a/src/uu/sed/src/sed.rs b/src/uu/sed/src/sed.rs
index 9cd9d0e9..c7147127 100644
--- a/src/uu/sed/src/sed.rs
+++ b/src/uu/sed/src/sed.rs
@@ -199,6 +199,7 @@ fn build_context(matches: &ArgMatches) -> ProcessingContext {
         null_data: matches.get_flag("null-data"),
 
         // Other context
+        input_name: "<stdin>".to_string(),
         line_number: 0,
         last_address: false,
         last_line: false,
diff --git a/tests/by-util/test_sed.rs b/tests/by-util/test_sed.rs
index d94d6d47..cfe26c51 100644
--- a/tests/by-util/test_sed.rs
+++ b/tests/by-util/test_sed.rs
@@ -935,7 +935,7 @@ fn test_fancy_regex_is_match_error() {
         .args(&["-E", r"/(\.+)+\1b$/p", "input/dots-4k.txt"])
         .fails()
         .code_is(2)
-        .stderr_is("sed: <script argument 1>:1:1: error: Error executing regex: Max limit for backtracking count exceeded\n");
+        .stderr_is("sed: <script argument 1>:1:1: 'input/dots-4k.txt':1 error: Error executing regex: Max limit for backtracking count exceeded\n");
 }
 
 #[test]
@@ -944,7 +944,7 @@ fn test_fancy_regex_find_error() {
         .args(&["-E", r"p;s/(\.+)+\1b$/X/", "input/dots-4k.txt"])
         .fails()
         .code_is(2)
-        .stderr_is("sed: <script argument 1>:1:3: error: Error executing regex: Max limit for backtracking count exceeded\n");
+        .stderr_is("sed: <script argument 1>:1:3: 'input/dots-4k.txt':1 error: Error executing regex: Max limit for backtracking count exceeded\n");
 }
 
 #[test]
@@ -953,7 +953,7 @@ fn test_fancy_regex_captures_error() {
         .args(&["-E", r"p;s/(\.+)+\1b$/\1/", "input/dots-4k.txt"])
         .fails()
         .code_is(2)
-        .stderr_is("sed: <script argument 1>:1:3: error: Error executing regex: Max limit for backtracking count exceeded\n");
+        .stderr_is("sed: <script argument 1>:1:3: 'input/dots-4k.txt':1 error: Error executing regex: Max limit for backtracking count exceeded\n");
 }
 
 #[test]
@@ -962,7 +962,7 @@ fn test_fancy_regex_captures_iter_error() {
         .args(&["-E", r"p;s/(\.+)+\1b$/\1/3", "input/dots-4k.txt"])
         .fails()
         .code_is(2)
-        .stderr_is("sed: <script argument 1>:1:3: error: error retrieving RE captures: Error executing regex: Max limit for backtracking count exceeded\n");
+        .stderr_is("sed: <script argument 1>:1:3: 'input/dots-4k.txt':1 error: error retrieving RE captures: Error executing regex: Max limit for backtracking count exceeded\n");
 }
 
 #[test]
@@ -980,7 +980,7 @@ fn test_missing_substitute_re() {
         .args(&["l;s//foo/", LINES1])
         .fails()
         .code_is(2)
-        .stderr_is("sed: <script argument 1>:1:3: error: no previous regular expression\n");
+        .stderr_is("sed: <script argument 1>:1:3: 'input/lines1':1 error: no previous regular expression\n");
 }
 
 #[test]
@@ -989,5 +989,5 @@ fn test_missing_address_re() {
         .args(&["l\np;//s/foo/bar/", LINES1])
         .fails()
         .code_is(2)
-        .stderr_is("sed: <script argument 1>:2:3: error: no previous regular expression\n");
+        .stderr_is("sed: <script argument 1>:2:3: 'input/lines1':1 error: no previous regular expression\n");
 }

From ab07fd5673956070a310f113876bd4feea85aa01 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Tue, 8 Jul 2025 14:19:45 +0300
Subject: [PATCH 15/15] Remove redundant struct member

---
 src/uu/sed/src/command.rs   | 17 +++++------
 src/uu/sed/src/compiler.rs  | 58 +++++++++++++++++++------------------
 src/uu/sed/src/processor.rs |  2 +-
 3 files changed, 39 insertions(+), 38 deletions(-)

diff --git a/src/uu/sed/src/command.rs b/src/uu/sed/src/command.rs
index 24de7865..35e8ad19 100644
--- a/src/uu/sed/src/command.rs
+++ b/src/uu/sed/src/command.rs
@@ -316,15 +316,14 @@ impl Command {
 /// After parsing, t, b Label elements are converted into BranchTarget ones.
 pub enum CommandData {
     None,
-    Block(Option<Rc<RefCell<Command>>>), // Commands for '{'
-    BranchTarget(Option<Rc<RefCell<Command>>>), // Commands for 'b', 't'
-    Label(Option<String>),               // Label name for 'b', 't', ':'
-    Path(PathBuf),                       // File path for 'r'
-    NamedWriter(Rc<RefCell<NamedWriter>>), // File output for 'w'
-    Number(usize),                       // Number for 'l', 'q', 'Q' (GNU)
-    Substitution(Box<Substitution>),     // Substitute command 's'
-    Text(Cow<'static, str>),             // Text for 'a', 'c', 'i'
-    Transliteration(Box<Transliteration>), // Transliteration command 'y'
+    BranchTarget(Option<Rc<RefCell<Command>>>), // Commands for 'b', 't', '{'
+    Label(Option<String>),                      // Label name for 'b', 't', ':'
+    Path(PathBuf),                              // File path for 'r'
+    NamedWriter(Rc<RefCell<NamedWriter>>),      // File output for 'w'
+    Number(usize),                              // Number for 'l', 'q', 'Q' (GNU)
+    Substitution(Box<Substitution>),            // Substitute command 's'
+    Text(Cow<'static, str>),                    // Text for 'a', 'c', 'i'
+    Transliteration(Box<Transliteration>),      // Transliteration command 'y'
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index 7fbc8eed..0574ecf1 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.rs
@@ -237,9 +237,9 @@ pub fn compile(
 }
 
 /// For every Command in the top-level `head` chain, look for
-/// `CommandData::Block(Some(sub_head))`.  Recursively patch
-/// the sub-chain, then splice its tail back to the original
-/// “next” pointer of the *parent* (falling back to its own
+/// `CommandData::BranchTarget(Some(sub_head))` '{' commands.
+/// Recursively patch the sub-chain, then splice its tail back to the
+/// original “next” pointer of the *parent* (falling back to its own
 /// parent_next if its own next was `None`).
 fn patch_block_endings(head: Option<Rc<RefCell<Command>>>) {
     fn patch_block_endings_to_parent(
@@ -257,22 +257,24 @@ fn patch_block_endings(head: Option<Rc<RefCell<Command>>>) {
             let splice_target = own_next.clone().or(parent_next.clone());
 
             // If it has a sub-block, recurse and then patch its tail
-            if let CommandData::Block(Some(ref sub_head)) = cmd.data {
-                // 1) recurse into the sub-chain, passing along splice_target
-                patch_block_endings_to_parent(Some(sub_head.clone()), splice_target.clone());
-
-                // 2) find the tail of that sub-chain
-                let mut tail = sub_head.clone();
-                loop {
-                    let next_in_sub = tail.borrow().next.clone();
-                    match next_in_sub {
-                        Some(n) => tail = n,
-                        None => break,
+            if let CommandData::BranchTarget(Some(ref sub_head)) = cmd.data {
+                if cmd.code == '{' {
+                    // 1) recurse into the sub-chain, passing splice_target
+                    patch_block_endings_to_parent(Some(sub_head.clone()), splice_target.clone());
+
+                    // 2) find the tail of that sub-chain
+                    let mut tail = sub_head.clone();
+                    loop {
+                        let next_in_sub = tail.borrow().next.clone();
+                        match next_in_sub {
+                            Some(n) => tail = n,
+                            None => break,
+                        }
                     }
-                }
 
-                // 3) splice the tail’s `.next` to splice_target
-                tail.borrow_mut().next = splice_target.clone();
+                    // 3) splice the tail’s `.next` to splice_target
+                    tail.borrow_mut().next = splice_target.clone();
+                }
             }
 
             // drop the borrow before moving on
@@ -298,7 +300,7 @@ fn populate_label_map(
 
         // Extract any label to insert after borrow ends
         let maybe_label = match &cmd.data {
-            CommandData::Block(Some(sub_head)) => {
+            CommandData::BranchTarget(Some(sub_head)) => {
                 populate_label_map(Some(sub_head.clone()), context)?;
                 None
             }
@@ -331,7 +333,7 @@ fn resolve_branch_targets(
         let mut cmd = rc_cmd.borrow_mut();
 
         // Recurse into blocks
-        if let CommandData::Block(Some(sub_head)) = &cmd.data {
+        if let CommandData::BranchTarget(Some(sub_head)) = &cmd.data {
             resolve_branch_targets(Some(sub_head.clone()), context)?;
         }
 
@@ -1158,7 +1160,7 @@ fn compile_command(
             line.advance(); // move past '{'
             context.parsed_block_nesting += 1;
             let block_body = compile_sequence(lines, line, context)?;
-            cmd.data = CommandData::Block(block_body);
+            cmd.data = CommandData::BranchTarget(block_body);
         }
         CommandArgs::EndGroup => { // }
             // Implemented at a higher level.
@@ -2248,7 +2250,7 @@ mod tests {
 
         let head = link_commands(vec![a.clone(), block.clone(), b.clone()]);
         let sub_head = link_commands(vec![x.clone(), y.clone()]);
-        block.borrow_mut().data = CommandData::Block(sub_head.clone());
+        block.borrow_mut().data = CommandData::BranchTarget(sub_head.clone());
 
         patch_block_endings(head.clone());
 
@@ -2261,7 +2263,7 @@ mod tests {
     #[test]
     fn test_empty_block_no_panic() {
         let a = command_with_code('a');
-        a.borrow_mut().data = CommandData::Block(None);
+        a.borrow_mut().data = CommandData::BranchTarget(None);
 
         patch_block_endings(Some(a.clone()));
 
@@ -2292,8 +2294,8 @@ mod tests {
         let head = link_commands(vec![a.clone(), outer_block.clone(), b.clone()]);
         let outer = link_commands(vec![m.clone(), inner_block.clone(), n.clone()]);
         let inner = link_commands(vec![x.clone(), y.clone()]);
-        outer_block.borrow_mut().data = CommandData::Block(outer.clone());
-        inner_block.borrow_mut().data = CommandData::Block(inner.clone());
+        outer_block.borrow_mut().data = CommandData::BranchTarget(outer.clone());
+        inner_block.borrow_mut().data = CommandData::BranchTarget(inner.clone());
 
         patch_block_endings(head.clone());
 
@@ -2320,8 +2322,8 @@ mod tests {
         let head = link_commands(vec![a.clone(), outer_block.clone(), b.clone()]);
         let outer = link_commands(vec![inner_block.clone()]);
         let inner = link_commands(vec![x.clone()]);
-        outer_block.borrow_mut().data = CommandData::Block(outer.clone());
-        inner_block.borrow_mut().data = CommandData::Block(inner.clone());
+        outer_block.borrow_mut().data = CommandData::BranchTarget(outer.clone());
+        inner_block.borrow_mut().data = CommandData::BranchTarget(inner.clone());
 
         patch_block_endings(head.clone());
 
@@ -2396,7 +2398,7 @@ mod tests {
     fn test_label_inside_block() {
         let nested = command_with_data(CommandData::Label(Some("inside".to_string())));
         nested.borrow_mut().code = ':';
-        let block = command_with_data(CommandData::Block(Some(nested.clone())));
+        let block = command_with_data(CommandData::BranchTarget(Some(nested.clone())));
         let mut context = ProcessingContext::default();
 
         populate_label_map(Some(block.clone()), &mut context).unwrap();
@@ -2538,7 +2540,7 @@ mod tests {
         let branch = command_with_data(CommandData::Label(Some("inner".to_string())));
         branch.borrow_mut().code = 't';
 
-        let block = command_with_data(CommandData::Block(Some(label.clone())));
+        let block = command_with_data(CommandData::BranchTarget(Some(label.clone())));
         let head = link_commands(vec![branch.clone(), block]);
 
         let mut context = ProcessingContext::default();
diff --git a/src/uu/sed/src/processor.rs b/src/uu/sed/src/processor.rs
index d8d761b0..d79f10ae 100644
--- a/src/uu/sed/src/processor.rs
+++ b/src/uu/sed/src/processor.rs
@@ -464,7 +464,7 @@ fn process_file(
             match command.code {
                 '{' => {
                     // Block begin; start processing the enclosed ones.
-                    let body = extract_variant!(command, Block);
+                    let body = extract_variant!(command, BranchTarget);
                     current = body.clone();
                     continue;
                 }