From 9d24b7378294c625954d4ac1dce520525beecdf8 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sat, 22 Mar 2025 14:26:04 +0200
Subject: [PATCH 01/16] Remove GNU --binary option

There are specialized commands that can handle this (tr, dos2unit).
Adding such support to every command runs against the Unix philosphy.
Furthermore, Rust, for good reasons, does not support opening files
in binary or text mode, so such support (which is complex and platform
dependent) would have to be emulated.
---
 src/uu/sed/src/sed.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/uu/sed/src/sed.rs b/src/uu/sed/src/sed.rs
index 48fa4590..23e76371 100644
--- a/src/uu/sed/src/sed.rs
+++ b/src/uu/sed/src/sed.rs
@@ -118,7 +118,6 @@ pub fn uu_app() -> Command {
                 .short('a')
                 .help("Create or truncate all output files before processing.")
                 .action(clap::ArgAction::SetTrue),
-            arg!(-b --binary "Treat files as binary: do not process CR+LFs."),
             arg!(--debug "Annotate program execution."),
             Arg::new("regexp-extended")
                 .short('E')

From d540eef0805b312640355094a7f3109fd8dfff59 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sat, 22 Mar 2025 15:22:41 +0200
Subject: [PATCH 02/16] Create processing context out of CLI options

---
 LICENSE                   |   2 +-
 src/uu/sed/src/command.rs |  28 ++++++++-
 src/uu/sed/src/sed.rs     | 129 +++++++++++++++++++++++++++++++++++++-
 3 files changed, 154 insertions(+), 5 deletions(-)

diff --git a/LICENSE b/LICENSE
index 6bd7307b..c66459ce 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 uutils
+Copyright (c) 2025 Diomidis Spinellis
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/uu/sed/src/command.rs b/src/uu/sed/src/command.rs
index c395c8fb..4e85fa50 100644
--- a/src/uu/sed/src/command.rs
+++ b/src/uu/sed/src/command.rs
@@ -1,7 +1,10 @@
 // Definitions for the compiled code data structures
 //
-// This file is part of the uutils sed package.
+// 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.
 
@@ -13,6 +16,29 @@ use std::collections::HashMap;
 use std::fs::File;
 use std::path::PathBuf; // For file descriptors and equivalent
 
+// Compilation and processing context
+#[derive(Debug)]
+pub struct Context {
+    // Input file/string and position
+    pub input: String,
+    pub line: usize,
+
+    // Command-line flags with corresponding names
+    pub all_output_files: bool,
+    pub debug: bool,
+    pub regexp_extended: bool,
+    pub follow_symlinks: bool,
+    pub in_place: bool,
+    pub in_place_suffix: Option<String>,
+    pub length: usize,
+    pub quiet: bool,
+    pub posix: bool,
+    pub separate: bool,
+    pub sandbox: bool,
+    pub unbuffered: bool,
+    pub null_data: bool,
+}
+
 // The specification of a script: through a string or a file
 #[derive(Debug, PartialEq)]
 pub enum ScriptValue {
diff --git a/src/uu/sed/src/sed.rs b/src/uu/sed/src/sed.rs
index 23e76371..d6f81d32 100644
--- a/src/uu/sed/src/sed.rs
+++ b/src/uu/sed/src/sed.rs
@@ -1,5 +1,10 @@
-// This file is part of the uutils sed package.
+// Program entry point and CLI processing
+//
+// 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.
 
@@ -7,7 +12,7 @@ pub mod command;
 pub mod compiler;
 pub mod processor;
 
-use crate::command::ScriptValue;
+use crate::command::{Context, ScriptValue};
 use crate::compiler::compile;
 use crate::processor::process;
 use clap::{arg, Arg, ArgMatches, Command};
@@ -96,6 +101,8 @@ fn get_scripts_files(matches: &ArgMatches) -> UResult<(Vec<ScriptValue>, Vec<Pat
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().try_get_matches_from(args)?;
     let (scripts, files) = get_scripts_files(&matches)?;
+    let _context = build_context(&matches);
+
     let executable = compile(scripts)?;
     process(executable, files)?;
     Ok(())
@@ -123,7 +130,8 @@ pub fn uu_app() -> Command {
                 .short('E')
                 .long("regexp-extended")
                 .short_alias('r')
-                .help("Use extended regular expressions."),
+                .help("Use extended regular expressions.")
+                .action(clap::ArgAction::SetTrue),
             arg!(-e --expression <SCRIPT> "Add script to executed commands.")
                 .action(clap::ArgAction::Append),
             // Access with .get_many::<PathBuf>("file")
@@ -160,6 +168,38 @@ pub fn uu_app() -> Command {
         ])
 }
 
+// Parse CLI flag arguments and return a Context struct based on them
+fn build_context(matches: &ArgMatches) -> Context {
+    Context {
+        input: String::new(),
+        line: 1,
+
+        // Flags
+        all_output_files: matches.get_flag("all-output-files"),
+        debug: matches.get_flag("debug"),
+        regexp_extended: matches.get_flag("regexp-extended"),
+        follow_symlinks: matches.get_flag("follow-symlinks"),
+        in_place: matches.contains_id("in-place"),
+        in_place_suffix: matches.get_one::<String>("in-place").and_then(|s| {
+            if s.is_empty() {
+                None
+            } else {
+                Some(s.clone())
+            }
+        }),
+        length: matches
+            .get_one::<u32>("length")
+            .map(|v| *v as usize)
+            .unwrap_or(70),
+        quiet: matches.get_flag("quiet"),
+        posix: matches.get_flag("posix"),
+        separate: matches.get_flag("separate"),
+        sandbox: matches.get_flag("sandbox"),
+        unbuffered: matches.get_flag("unbuffered"),
+        null_data: matches.get_flag("null-data"),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*; // Allows access to private functions/items in this module
@@ -257,4 +297,87 @@ mod tests {
         );
         assert_eq!(files, vec![PathBuf::from("-")]); // Stdin should be used
     }
+
+    fn test_matches(args: &[&str]) -> ArgMatches {
+        uu_app().get_matches_from(["sed"].into_iter().chain(args.iter().copied()))
+    }
+
+    #[test]
+    fn test_defaults() {
+        let matches = test_matches(&[]);
+        let ctx = build_context(&matches);
+
+        assert_eq!(ctx.input.len(), 0);
+        assert_eq!(ctx.line, 1);
+        assert!(!ctx.all_output_files);
+        assert!(!ctx.debug);
+        assert!(!ctx.regexp_extended);
+        assert!(!ctx.follow_symlinks);
+        assert!(!ctx.in_place);
+        assert_eq!(ctx.in_place_suffix, None);
+        assert_eq!(ctx.length, 70);
+        assert!(!ctx.quiet);
+        assert!(!ctx.posix);
+        assert!(!ctx.separate);
+        assert!(!ctx.sandbox);
+        assert!(!ctx.unbuffered);
+        assert!(!ctx.null_data);
+    }
+
+    #[test]
+    fn test_all_flags() {
+        let matches = test_matches(&[
+            "--all-output-files",
+            "--debug",
+            "-E",
+            "--follow-symlinks",
+            "-i",
+            "-l",
+            "80",
+            "-n",
+            "--posix",
+            "-s",
+            "--sandbox",
+            "-u",
+            "-z",
+        ]);
+
+        let ctx = build_context(&matches);
+
+        assert_eq!(ctx.input.len(), 0);
+        assert!(ctx.all_output_files);
+        assert!(ctx.debug);
+        assert!(ctx.regexp_extended);
+        assert!(ctx.follow_symlinks);
+        assert!(ctx.in_place);
+        assert!(ctx.in_place_suffix.is_none());
+        assert_eq!(ctx.length, 80);
+        assert!(ctx.quiet);
+        assert!(ctx.posix);
+        assert!(ctx.separate);
+        assert!(ctx.sandbox);
+        assert!(ctx.unbuffered);
+        assert!(ctx.null_data);
+    }
+
+    #[test]
+    fn test_in_place_with_suffix() {
+        let matches = test_matches(&["-i", ".bak"]);
+        let ctx = build_context(&matches);
+
+        assert!(ctx.in_place);
+        assert_eq!(ctx.in_place_suffix, Some(".bak".to_string()));
+    }
+
+    #[test]
+    fn test_length_default_and_custom() {
+        let matches_default = test_matches(&[]);
+        let matches_custom = test_matches(&["-l", "120"]);
+
+        let ctx_default = build_context(&matches_default);
+        let ctx_custom = build_context(&matches_custom);
+
+        assert_eq!(ctx_default.length, 70);
+        assert_eq!(ctx_custom.length, 120);
+    }
 }

From f591509c32e264a48784f41d9118f1b7ad32e0c6 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sat, 22 Mar 2025 15:30:35 +0200
Subject: [PATCH 03/16] Pass context to processing functions

---
 src/uu/sed/src/compiler.rs  |  9 ++++++---
 src/uu/sed/src/processor.rs | 12 ++++++++++--
 src/uu/sed/src/sed.rs       | 14 ++++++--------
 3 files changed, 22 insertions(+), 13 deletions(-)

diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index 590da110..88765df1 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.rs
@@ -1,14 +1,17 @@
 // Compile the scripts into the internal representation of commands
 //
-// This file is part of the uutils sed package.
+// 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::command::{Command, ScriptValue};
+use crate::command::{Command, Context, ScriptValue};
 use uucore::error::UResult;
 
-pub fn compile(_scripts: Vec<ScriptValue>) -> UResult<Option<Command>> {
+pub fn compile(_scripts: Vec<ScriptValue>, _context: &mut Context) -> UResult<Option<Command>> {
     // TODO
     Ok(None)
 }
diff --git a/src/uu/sed/src/processor.rs b/src/uu/sed/src/processor.rs
index e481c1de..402c5eef 100644
--- a/src/uu/sed/src/processor.rs
+++ b/src/uu/sed/src/processor.rs
@@ -1,15 +1,23 @@
 // Process the files with the compiled scripts
 //
-// This file is part of the uutils sed package.
+// 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::command::Command;
+use crate::command::Context;
 use std::path::PathBuf;
 use uucore::error::UResult;
 
-pub fn process(_code: Option<Command>, _files: Vec<PathBuf>) -> UResult<()> {
+pub fn process(
+    _code: Option<Command>,
+    _files: Vec<PathBuf>,
+    _context: &mut Context,
+) -> UResult<()> {
     // TODO
     Ok(())
 }
diff --git a/src/uu/sed/src/sed.rs b/src/uu/sed/src/sed.rs
index d6f81d32..2e89bdc7 100644
--- a/src/uu/sed/src/sed.rs
+++ b/src/uu/sed/src/sed.rs
@@ -23,11 +23,9 @@ use uucore::format_usage;
 const ABOUT: &str = "Stream editor for filtering and transforming text";
 const USAGE: &str = "sed [OPTION]... [script] [file]...";
 
-/*
- * Iterate through script and file arguments specified in matches and
- * return vectors of all scripts and input files in the specified order.
- * If no script is specified fail with "missing script" error.
- */
+// Iterate through script and file arguments specified in matches and
+// return vectors of all scripts and input files in the specified order.
+// If no script is specified fail with "missing script" error.
 fn get_scripts_files(matches: &ArgMatches) -> UResult<(Vec<ScriptValue>, Vec<PathBuf>)> {
     let mut indexed_scripts: Vec<(usize, ScriptValue)> = Vec::new();
     let mut files: Vec<PathBuf> = Vec::new();
@@ -101,10 +99,10 @@ fn get_scripts_files(matches: &ArgMatches) -> UResult<(Vec<ScriptValue>, Vec<Pat
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().try_get_matches_from(args)?;
     let (scripts, files) = get_scripts_files(&matches)?;
-    let _context = build_context(&matches);
+    let mut context = build_context(&matches);
 
-    let executable = compile(scripts)?;
-    process(executable, files)?;
+    let executable = compile(scripts, &mut context)?;
+    process(executable, files, &mut context)?;
     Ok(())
 }
 

From c45a13d5dfd4be29527abcf2d307ecfb5cd16012 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sat, 22 Mar 2025 15:31:55 +0200
Subject: [PATCH 04/16] Move helper function near the others

---
 src/uu/sed/src/sed.rs | 142 +++++++++++++++++++++---------------------
 1 file changed, 71 insertions(+), 71 deletions(-)

diff --git a/src/uu/sed/src/sed.rs b/src/uu/sed/src/sed.rs
index 2e89bdc7..963b7ed3 100644
--- a/src/uu/sed/src/sed.rs
+++ b/src/uu/sed/src/sed.rs
@@ -23,6 +23,77 @@ use uucore::format_usage;
 const ABOUT: &str = "Stream editor for filtering and transforming text";
 const USAGE: &str = "sed [OPTION]... [script] [file]...";
 
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().try_get_matches_from(args)?;
+    let (scripts, files) = get_scripts_files(&matches)?;
+    let mut context = build_context(&matches);
+
+    let executable = compile(scripts, &mut context)?;
+    process(executable, files, &mut context)?;
+    Ok(())
+}
+
+#[allow(clippy::cognitive_complexity)]
+pub fn uu_app() -> Command {
+    Command::new(uucore::util_name())
+        .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
+        .args([
+            arg!([script] "Script to execute if not otherwise provided."),
+            Arg::new("file")
+                .help("Input files")
+                .value_parser(clap::value_parser!(PathBuf))
+                .num_args(0..),
+            Arg::new("all-output-files")
+                .long("all-output-files")
+                .short('a')
+                .help("Create or truncate all output files before processing.")
+                .action(clap::ArgAction::SetTrue),
+            arg!(--debug "Annotate program execution."),
+            Arg::new("regexp-extended")
+                .short('E')
+                .long("regexp-extended")
+                .short_alias('r')
+                .help("Use extended regular expressions.")
+                .action(clap::ArgAction::SetTrue),
+            arg!(-e --expression <SCRIPT> "Add script to executed commands.")
+                .action(clap::ArgAction::Append),
+            // Access with .get_many::<PathBuf>("file")
+            Arg::new("script-file")
+                .short('f')
+                .long("script-file")
+                .help("Specify script file.")
+                .value_parser(clap::value_parser!(PathBuf))
+                .action(clap::ArgAction::Append),
+            Arg::new("follow-symlinks")
+                .long("follow-symlinks")
+                .help("Follow symlinks when processing in place.")
+                .action(clap::ArgAction::SetTrue),
+            // Access with .get_one::<String>("in-place")
+            Arg::new("in-place")
+                .short('i')
+                .long("in-place")
+                .help("Edit files in place, making a backup if SUFFIX is supplied.")
+                .num_args(0..=1)
+                .default_missing_value(""),
+            // Access with .get_one::<u32>("line-length")
+            arg!(-l --length <NUM> "Specify the 'l' command line-wrap length.")
+                .value_parser(clap::value_parser!(u32)),
+            arg!(-n --quiet "Suppress automatic printing of pattern space.").aliases(["silent"]),
+            arg!(--posix "Disable all POSIX extensions."),
+            arg!(-s --separate "Consider files as separate rather than as a long stream."),
+            arg!(--sandbox "Operate in a sandbox by disabling e/r/w commands."),
+            arg!(-u --unbuffered "Load minimal input data and flush output buffers regularly."),
+            Arg::new("null-data")
+                .short('z')
+                .long("null-data")
+                .help("Separate lines by NUL characters.")
+                .action(clap::ArgAction::SetTrue),
+        ])
+}
+
 // Iterate through script and file arguments specified in matches and
 // return vectors of all scripts and input files in the specified order.
 // If no script is specified fail with "missing script" error.
@@ -95,77 +166,6 @@ fn get_scripts_files(matches: &ArgMatches) -> UResult<(Vec<ScriptValue>, Vec<Pat
     Ok((scripts, files))
 }
 
-#[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let matches = uu_app().try_get_matches_from(args)?;
-    let (scripts, files) = get_scripts_files(&matches)?;
-    let mut context = build_context(&matches);
-
-    let executable = compile(scripts, &mut context)?;
-    process(executable, files, &mut context)?;
-    Ok(())
-}
-
-#[allow(clippy::cognitive_complexity)]
-pub fn uu_app() -> Command {
-    Command::new(uucore::util_name())
-        .about(ABOUT)
-        .override_usage(format_usage(USAGE))
-        .infer_long_args(true)
-        .args([
-            arg!([script] "Script to execute if not otherwise provided."),
-            Arg::new("file")
-                .help("Input files")
-                .value_parser(clap::value_parser!(PathBuf))
-                .num_args(0..),
-            Arg::new("all-output-files")
-                .long("all-output-files")
-                .short('a')
-                .help("Create or truncate all output files before processing.")
-                .action(clap::ArgAction::SetTrue),
-            arg!(--debug "Annotate program execution."),
-            Arg::new("regexp-extended")
-                .short('E')
-                .long("regexp-extended")
-                .short_alias('r')
-                .help("Use extended regular expressions.")
-                .action(clap::ArgAction::SetTrue),
-            arg!(-e --expression <SCRIPT> "Add script to executed commands.")
-                .action(clap::ArgAction::Append),
-            // Access with .get_many::<PathBuf>("file")
-            Arg::new("script-file")
-                .short('f')
-                .long("script-file")
-                .help("Specify script file.")
-                .value_parser(clap::value_parser!(PathBuf))
-                .action(clap::ArgAction::Append),
-            Arg::new("follow-symlinks")
-                .long("follow-symlinks")
-                .help("Follow symlinks when processing in place.")
-                .action(clap::ArgAction::SetTrue),
-            // Access with .get_one::<String>("in-place")
-            Arg::new("in-place")
-                .short('i')
-                .long("in-place")
-                .help("Edit files in place, making a backup if SUFFIX is supplied.")
-                .num_args(0..=1)
-                .default_missing_value(""),
-            // Access with .get_one::<u32>("line-length")
-            arg!(-l --length <NUM> "Specify the 'l' command line-wrap length.")
-                .value_parser(clap::value_parser!(u32)),
-            arg!(-n --quiet "Suppress automatic printing of pattern space.").aliases(["silent"]),
-            arg!(--posix "Disable all POSIX extensions."),
-            arg!(-s --separate "Consider files as separate rather than as a long stream."),
-            arg!(--sandbox "Operate in a sandbox by disabling e/r/w commands."),
-            arg!(-u --unbuffered "Load minimal input data and flush output buffers regularly."),
-            Arg::new("null-data")
-                .short('z')
-                .long("null-data")
-                .help("Separate lines by NUL characters.")
-                .action(clap::ArgAction::SetTrue),
-        ])
-}
-
 // Parse CLI flag arguments and return a Context struct based on them
 fn build_context(matches: &ArgMatches) -> Context {
     Context {

From 4abea3aee8323e4d835cc0c4a28f59adb473529b Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sat, 22 Mar 2025 16:51:51 +0200
Subject: [PATCH 05/16] Add script line provider

---
 Cargo.lock                             |   1 +
 src/uu/sed/Cargo.toml                  |   1 +
 src/uu/sed/src/script_line_provider.rs | 179 +++++++++++++++++++++++++
 src/uu/sed/src/sed.rs                  |   1 +
 4 files changed, 182 insertions(+)
 create mode 100644 src/uu/sed/src/script_line_provider.rs

diff --git a/Cargo.lock b/Cargo.lock
index 1baa9000..06788393 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -753,6 +753,7 @@ version = "0.0.1"
 dependencies = [
  "clap",
  "regex",
+ "tempfile",
  "uucore",
 ]
 
diff --git a/src/uu/sed/Cargo.toml b/src/uu/sed/Cargo.toml
index 36c6cdca..56900a03 100644
--- a/src/uu/sed/Cargo.toml
+++ b/src/uu/sed/Cargo.toml
@@ -16,6 +16,7 @@ categories = ["command-line-utilities"]
 uucore = { workspace = true }
 clap = { workspace = true }
 regex = { workspace = true }
+tempfile = { workspace = true }
 
 [lib]
 path = "src/sed.rs"
diff --git a/src/uu/sed/src/script_line_provider.rs b/src/uu/sed/src/script_line_provider.rs
new file mode 100644
index 00000000..aae3f9cb
--- /dev/null
+++ b/src/uu/sed/src/script_line_provider.rs
@@ -0,0 +1,179 @@
+// Provide the script contents line by line
+//
+// 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 std::fs::File;
+use std::io::{self, BufRead, BufReader};
+use std::path::PathBuf;
+
+#[derive(Debug, Clone)]
+pub enum ScriptValue {
+    StringVal(String),
+    PathVal(PathBuf),
+}
+
+pub struct ScriptLineProvider {
+    sources: Vec<ScriptValue>,
+    state: State,
+}
+
+enum State {
+    NotStarted,
+    Active {
+        index: usize,
+        reader: Box<dyn BufRead>,
+    },
+    Done,
+}
+
+impl ScriptLineProvider {
+    pub fn new(sources: Vec<ScriptValue>) -> Self {
+        Self {
+            sources,
+            state: State::NotStarted,
+        }
+    }
+
+    pub fn next_line(&mut self) -> io::Result<Option<String>> {
+        let mut line = String::new();
+
+        loop {
+            let advance = match &mut self.state {
+                State::NotStarted => {
+                    Some(0)
+                }
+                State::Active { index, reader } => {
+                    line.clear();
+                    let bytes = reader.read_line(&mut line)?;
+                    if bytes == 0 {
+                        Some(*index + 1) // finished reading this source
+                    } else {
+                        return Ok(Some(line));
+                    }
+                }
+                State::Done => {
+                    return Ok(None);
+                }
+            };
+
+            if let Some(next_index) = advance {
+                self.advance_source(next_index)?;
+            }
+        }
+    }
+
+    fn advance_source(&mut self, next_index: usize) -> io::Result<()> {
+        if next_index >= self.sources.len() {
+            self.state = State::Done;
+            return Ok(());
+        }
+
+        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)),
+                };
+            }
+            ScriptValue::PathVal(p) => {
+                if p.to_string_lossy() == "-" {
+                    self.state = State::Active {
+                        index: next_index,
+                        reader: Box::new(BufReader::new(io::stdin())),
+                    };
+                } else {
+                    let file = File::open(p)?;
+                    self.state = State::Active {
+                        index: next_index,
+                        reader: Box::new(BufReader::new(file)),
+                    };
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::NamedTempFile;
+    use std::io::Write;
+
+    #[test]
+    fn test_string_source() {
+        let input = vec![
+            ScriptValue::StringVal("line one\nline two\n".to_string()),
+            ScriptValue::StringVal("line three".to_string()),
+        ];
+        let mut provider = ScriptLineProvider::new(input);
+
+        let mut lines = Vec::new();
+        while let Some(line) = provider.next_line().unwrap() {
+            lines.push(line.trim_end().to_string());
+        }
+
+        assert_eq!(
+            lines,
+            vec!["line one", "line two", "line three"]
+        );
+    }
+
+    #[test]
+    fn test_file_source() {
+        let mut temp_file = NamedTempFile::new().unwrap();
+        writeln!(temp_file, "file line 1").unwrap();
+        writeln!(temp_file, "file line 2").unwrap();
+
+        let input = vec![
+            ScriptValue::PathVal(temp_file.path().to_path_buf()),
+        ];
+        let mut provider = ScriptLineProvider::new(input);
+
+        let mut lines = Vec::new();
+        while let Some(line) = provider.next_line().unwrap() {
+            lines.push(line.trim_end().to_string());
+        }
+
+        assert_eq!(lines, vec!["file line 1", "file line 2"]);
+    }
+
+    #[test]
+    fn test_mixed_source() {
+        let mut temp_file = NamedTempFile::new().unwrap();
+        writeln!(temp_file, "file line 1").unwrap();
+        writeln!(temp_file, "file line 2").unwrap();
+        let temp_file2 = NamedTempFile::new().unwrap();
+
+        let input = vec![
+            ScriptValue::PathVal(temp_file.path().to_path_buf()),
+            ScriptValue::StringVal("script line 1".to_string()),
+            ScriptValue::PathVal(temp_file.path().to_path_buf()),
+            ScriptValue::StringVal("".to_string()),
+            ScriptValue::PathVal(temp_file2.path().to_path_buf()),
+            ScriptValue::StringVal("other script line 1".to_string()),
+        ];
+        let mut provider = ScriptLineProvider::new(input);
+
+        let mut lines = Vec::new();
+        while let Some(line) = provider.next_line().unwrap() {
+            lines.push(line.trim_end().to_string());
+        }
+
+        assert_eq!(lines, vec![
+            "file line 1",
+            "file line 2",
+            "script line 1",
+            "file line 1",
+            "file line 2",
+            "other script line 1",
+        ]);
+    }
+}
diff --git a/src/uu/sed/src/sed.rs b/src/uu/sed/src/sed.rs
index 963b7ed3..c714ed38 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 processor;
+pub mod script_line_provider;
 
 use crate::command::{Context, ScriptValue};
 use crate::compiler::compile;

From b757ce26d98d3a492e22ae45d5984d6db50421b4 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sat, 22 Mar 2025 17:33:19 +0200
Subject: [PATCH 06/16] Move input position to the line provider

---
 src/uu/sed/src/command.rs              |   4 -
 src/uu/sed/src/script_line_provider.rs | 106 ++++++++++++++++++++-----
 src/uu/sed/src/sed.rs                  |   7 --
 3 files changed, 86 insertions(+), 31 deletions(-)

diff --git a/src/uu/sed/src/command.rs b/src/uu/sed/src/command.rs
index 4e85fa50..e176bb8e 100644
--- a/src/uu/sed/src/command.rs
+++ b/src/uu/sed/src/command.rs
@@ -19,10 +19,6 @@ use std::path::PathBuf; // For file descriptors and equivalent
 // Compilation and processing context
 #[derive(Debug)]
 pub struct Context {
-    // Input file/string and position
-    pub input: String,
-    pub line: usize,
-
     // Command-line flags with corresponding names
     pub all_output_files: bool,
     pub debug: bool,
diff --git a/src/uu/sed/src/script_line_provider.rs b/src/uu/sed/src/script_line_provider.rs
index aae3f9cb..b21b61c0 100644
--- a/src/uu/sed/src/script_line_provider.rs
+++ b/src/uu/sed/src/script_line_provider.rs
@@ -28,6 +28,8 @@ enum State {
     Active {
         index: usize,
         reader: Box<dyn BufRead>,
+        input_name: String,
+        line_number: usize,
     },
     Done,
 }
@@ -40,20 +42,38 @@ impl ScriptLineProvider {
         }
     }
 
+    pub fn get_line_number(&self) -> usize {
+        match &self.state {
+            State::Active { line_number, .. } => *line_number,
+            _ => 0,
+        }
+    }
+
+    pub fn get_input_name(&self) -> &str {
+        match &self.state {
+            State::Active { input_name, .. } => input_name.as_str(),
+            _ => "",
+        }
+    }
+
     pub fn next_line(&mut self) -> io::Result<Option<String>> {
         let mut line = String::new();
 
         loop {
             let advance = match &mut self.state {
-                State::NotStarted => {
-                    Some(0)
-                }
-                State::Active { index, reader } => {
+                State::NotStarted => Some(0),
+                State::Active {
+                    index,
+                    reader,
+                    line_number,
+                    ..
+                } => {
                     line.clear();
                     let bytes = reader.read_line(&mut line)?;
                     if bytes == 0 {
                         Some(*index + 1) // finished reading this source
                     } else {
+                        *line_number += 1;
                         return Ok(Some(line));
                     }
                 }
@@ -74,12 +94,23 @@ 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),
+                    line_number: 0,
                 };
             }
             ScriptValue::PathVal(p) => {
@@ -87,12 +118,16 @@ impl ScriptLineProvider {
                     self.state = State::Active {
                         index: next_index,
                         reader: Box::new(BufReader::new(io::stdin())),
+                        input_name: "<stdin>".to_string(),
+                        line_number: 0,
                     };
                 } else {
                     let file = File::open(p)?;
                     self.state = State::Active {
                         index: next_index,
                         reader: Box::new(BufReader::new(file)),
+                        input_name: p.to_string_lossy().to_string(),
+                        line_number: 0,
                     };
                 }
             }
@@ -104,8 +139,8 @@ impl ScriptLineProvider {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use tempfile::NamedTempFile;
     use std::io::Write;
+    use tempfile::NamedTempFile;
 
     #[test]
     fn test_string_source() {
@@ -120,10 +155,7 @@ mod tests {
             lines.push(line.trim_end().to_string());
         }
 
-        assert_eq!(
-            lines,
-            vec!["line one", "line two", "line three"]
-        );
+        assert_eq!(lines, vec!["line one", "line two", "line three"]);
     }
 
     #[test]
@@ -132,9 +164,7 @@ mod tests {
         writeln!(temp_file, "file line 1").unwrap();
         writeln!(temp_file, "file line 2").unwrap();
 
-        let input = vec![
-            ScriptValue::PathVal(temp_file.path().to_path_buf()),
-        ];
+        let input = vec![ScriptValue::PathVal(temp_file.path().to_path_buf())];
         let mut provider = ScriptLineProvider::new(input);
 
         let mut lines = Vec::new();
@@ -167,13 +197,49 @@ mod tests {
             lines.push(line.trim_end().to_string());
         }
 
-        assert_eq!(lines, vec![
-            "file line 1",
-            "file line 2",
-            "script line 1",
-            "file line 1",
-            "file line 2",
-            "other script line 1",
-        ]);
+        assert_eq!(
+            lines,
+            vec![
+                "file line 1",
+                "file line 2",
+                "script line 1",
+                "file line 1",
+                "file line 2",
+                "other script line 1",
+            ]
+        );
+    }
+
+    #[test]
+    fn test_getters() {
+        let input = vec![
+            ScriptValue::StringVal("l1\nl2\n".to_string()),
+            ScriptValue::StringVal("l3".to_string()),
+        ];
+        let mut provider = ScriptLineProvider::new(input);
+
+        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");
+        } else {
+            panic!("Expected a line");
+        }
+
+        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");
+        } else {
+            panic!("Expected a line");
+        }
+
+        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");
+        } else {
+            panic!("Expected a line");
+        }
     }
 }
diff --git a/src/uu/sed/src/sed.rs b/src/uu/sed/src/sed.rs
index c714ed38..a7640a2e 100644
--- a/src/uu/sed/src/sed.rs
+++ b/src/uu/sed/src/sed.rs
@@ -170,10 +170,6 @@ fn get_scripts_files(matches: &ArgMatches) -> UResult<(Vec<ScriptValue>, Vec<Pat
 // Parse CLI flag arguments and return a Context struct based on them
 fn build_context(matches: &ArgMatches) -> Context {
     Context {
-        input: String::new(),
-        line: 1,
-
-        // Flags
         all_output_files: matches.get_flag("all-output-files"),
         debug: matches.get_flag("debug"),
         regexp_extended: matches.get_flag("regexp-extended"),
@@ -306,8 +302,6 @@ mod tests {
         let matches = test_matches(&[]);
         let ctx = build_context(&matches);
 
-        assert_eq!(ctx.input.len(), 0);
-        assert_eq!(ctx.line, 1);
         assert!(!ctx.all_output_files);
         assert!(!ctx.debug);
         assert!(!ctx.regexp_extended);
@@ -343,7 +337,6 @@ mod tests {
 
         let ctx = build_context(&matches);
 
-        assert_eq!(ctx.input.len(), 0);
         assert!(ctx.all_output_files);
         assert!(ctx.debug);
         assert!(ctx.regexp_extended);

From 5916292600bab1f9e743a491f1f7c5707cf8a1f4 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sat, 22 Mar 2025 17:50:52 +0200
Subject: [PATCH 07/16] Integrate into script compiler ScriptLineProvider

---
 src/uu/sed/src/compiler.rs             | 5 ++++-
 src/uu/sed/src/script_line_provider.rs | 8 +-------
 2 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index 88765df1..3ce6be71 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.rs
@@ -9,9 +9,12 @@
 // file that was distributed with this source code.
 
 use crate::command::{Command, Context, ScriptValue};
+use crate::script_line_provider::ScriptLineProvider;
 use uucore::error::UResult;
 
-pub fn compile(_scripts: Vec<ScriptValue>, _context: &mut Context) -> UResult<Option<Command>> {
+pub fn compile(scripts: Vec<ScriptValue>, _context: &mut Context) -> UResult<Option<Command>> {
+    let mut _line_provider = ScriptLineProvider::new(scripts);
+
     // TODO
     Ok(None)
 }
diff --git a/src/uu/sed/src/script_line_provider.rs b/src/uu/sed/src/script_line_provider.rs
index b21b61c0..1730fa6f 100644
--- a/src/uu/sed/src/script_line_provider.rs
+++ b/src/uu/sed/src/script_line_provider.rs
@@ -8,15 +8,9 @@
 // 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::fs::File;
 use std::io::{self, BufRead, BufReader};
-use std::path::PathBuf;
-
-#[derive(Debug, Clone)]
-pub enum ScriptValue {
-    StringVal(String),
-    PathVal(PathBuf),
-}
 
 pub struct ScriptLineProvider {
     sources: Vec<ScriptValue>,

From 43b0a1b9c306ba14b028f6d7d899be281999b4c1 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sat, 22 Mar 2025 18:50:55 +0200
Subject: [PATCH 08/16] Add command definitions

---
 src/uu/sed/src/command.rs  |  19 ----
 src/uu/sed/src/compiler.rs | 177 +++++++++++++++++++++++++++++++++++++
 2 files changed, 177 insertions(+), 19 deletions(-)

diff --git a/src/uu/sed/src/command.rs b/src/uu/sed/src/command.rs
index e176bb8e..e29a553e 100644
--- a/src/uu/sed/src/command.rs
+++ b/src/uu/sed/src/command.rs
@@ -116,25 +116,6 @@ enum CommandData {
     WriteFileDescriptor(File),        // File descriptor for 'w'
 }
 
-/*
- * Types of command arguments recognized by the parser
- */
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum CommandArgs {
-    Empty,      // d D g G h H l n N p P q x = \0
-    Text,       // a c i
-    NonSelect,  // !
-    Group,      // {
-    EndGroup,   // }
-    Comment,    // #
-    Branch,     // b t
-    Label,      // :
-    ReadFile,   // r
-    WriteFile,  // w
-    Substitute, // s
-    Translate,  // y
-}
-
 /*
  * Structure containing things to append before a line is read
  */
diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index 3ce6be71..eb6c74c8 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.rs
@@ -10,11 +10,188 @@
 
 use crate::command::{Command, Context, ScriptValue};
 use crate::script_line_provider::ScriptLineProvider;
+use std::collections::HashMap;
 use uucore::error::UResult;
 
+// Types of command arguments recognized by the parser
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum CommandArgs {
+    Empty,      // d D g G h H l n N p P q x = \0
+    Text,       // a c i
+    NonSelect,  // !
+    Group,      // {
+    EndGroup,   // }
+    Comment,    // #
+    Branch,     // b t
+    Label,      // :
+    ReadFile,   // r
+    WriteFile,  // w
+    Substitute, // s
+    Translate,  // y
+}
+
+// Command specification
+#[derive(Debug, Clone, Copy)]
+struct SFormat {
+    code: char,         // Command letter used by sed
+    n_addr: usize,      // Number of supported addresses
+    args: CommandArgs,  // Type of command arguments
+}
+
+// Build the command specification map (char -> SFormat)
+fn build_command_map() -> HashMap<char, SFormat> {
+    let formats = [
+        SFormat { code: '{', n_addr: 2, args: CommandArgs::Group },
+        SFormat { code: '}', n_addr: 0, args: CommandArgs::EndGroup },
+        SFormat { code: 'a', n_addr: 1, args: CommandArgs::Text },
+        SFormat { code: 'b', n_addr: 2, args: CommandArgs::Branch },
+        SFormat { code: 'c', n_addr: 2, args: CommandArgs::Text },
+        SFormat { code: 'd', n_addr: 2, args: CommandArgs::Empty },
+        SFormat { code: 'D', n_addr: 2, args: CommandArgs::Empty },
+        SFormat { code: 'g', n_addr: 2, args: CommandArgs::Empty },
+        SFormat { code: 'G', n_addr: 2, args: CommandArgs::Empty },
+        SFormat { code: 'h', n_addr: 2, args: CommandArgs::Empty },
+        SFormat { code: 'H', n_addr: 2, args: CommandArgs::Empty },
+        SFormat { code: 'i', n_addr: 1, args: CommandArgs::Text },
+        SFormat { code: 'l', n_addr: 2, args: CommandArgs::Empty },
+        SFormat { code: 'n', n_addr: 2, args: CommandArgs::Empty },
+        SFormat { code: 'N', n_addr: 2, args: CommandArgs::Empty },
+        SFormat { code: 'p', n_addr: 2, args: CommandArgs::Empty },
+        SFormat { code: 'P', n_addr: 2, args: CommandArgs::Empty },
+        SFormat { code: 'q', n_addr: 1, args: CommandArgs::Empty },
+        SFormat { code: 'r', n_addr: 1, args: CommandArgs::ReadFile },
+        SFormat { code: 's', n_addr: 2, args: CommandArgs::Substitute },
+        SFormat { code: 't', n_addr: 2, args: CommandArgs::Branch },
+        SFormat { code: 'w', n_addr: 2, args: CommandArgs::WriteFile },
+        SFormat { code: 'x', n_addr: 2, args: CommandArgs::Empty },
+        SFormat { code: 'y', n_addr: 2, args: CommandArgs::Translate },
+        SFormat { code: '!', n_addr: 2, args: CommandArgs::NonSelect },
+        SFormat { code: ':', n_addr: 0, args: CommandArgs::Label },
+        SFormat { code: '#', n_addr: 0, args: CommandArgs::Comment },
+        SFormat { code: '=', n_addr: 1, args: CommandArgs::Empty },
+        SFormat { code: '\0', n_addr: 0, args: CommandArgs::Comment },
+    ];
+
+    formats.into_iter().map(|f| (f.code, f)).collect()
+}
+
+// Look up a command format by its command code.
+fn lookup_command(cmd: char, map: &HashMap<char, SFormat>) -> Option<&SFormat> {
+    map.get(&cmd)
+}
+
 pub fn compile(scripts: Vec<ScriptValue>, _context: &mut Context) -> UResult<Option<Command>> {
+    let _cmd_map = build_command_map();
     let mut _line_provider = ScriptLineProvider::new(scripts);
 
     // TODO
     Ok(None)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_lookup_empty_command() {
+        let cmd_map = build_command_map();
+        let cmd = lookup_command('d', &cmd_map).unwrap();
+        assert_eq!(cmd.n_addr, 2);
+        assert_eq!(cmd.args, CommandArgs::Empty);
+    }
+
+    #[test]
+    fn test_lookup_text_command() {
+        let cmd_map = build_command_map();
+        let cmd = lookup_command('a', &cmd_map).unwrap();
+        assert_eq!(cmd.n_addr, 1);
+        assert_eq!(cmd.args, CommandArgs::Text);
+    }
+
+    #[test]
+    fn test_lookup_nonselect_command() {
+        let cmd_map = build_command_map();
+        let cmd = lookup_command('!', &cmd_map).unwrap();
+        assert_eq!(cmd.n_addr, 2);
+        assert_eq!(cmd.args, CommandArgs::NonSelect);
+    }
+
+    #[test]
+    fn test_lookup_group_command() {
+        let cmd_map = build_command_map();
+        let cmd = lookup_command('{', &cmd_map).unwrap();
+        assert_eq!(cmd.n_addr, 2);
+        assert_eq!(cmd.args, CommandArgs::Group);
+    }
+
+    #[test]
+    fn test_lookup_endgroup_command() {
+        let cmd_map = build_command_map();
+        let cmd = lookup_command('}', &cmd_map).unwrap();
+        assert_eq!(cmd.n_addr, 0);
+        assert_eq!(cmd.args, CommandArgs::EndGroup);
+    }
+
+    #[test]
+    fn test_lookup_comment_command() {
+        let cmd_map = build_command_map();
+        let cmd = lookup_command('#', &cmd_map).unwrap();
+        assert_eq!(cmd.n_addr, 0);
+        assert_eq!(cmd.args, CommandArgs::Comment);
+    }
+
+    #[test]
+    fn test_lookup_branch_command() {
+        let cmd_map = build_command_map();
+        let cmd = lookup_command('b', &cmd_map).unwrap();
+        assert_eq!(cmd.n_addr, 2);
+        assert_eq!(cmd.args, CommandArgs::Branch);
+    }
+
+    #[test]
+    fn test_lookup_label_command() {
+        let cmd_map = build_command_map();
+        let cmd = lookup_command(':', &cmd_map).unwrap();
+        assert_eq!(cmd.n_addr, 0);
+        assert_eq!(cmd.args, CommandArgs::Label);
+    }
+
+    #[test]
+    fn test_lookup_readfile_command() {
+        let cmd_map = build_command_map();
+        let cmd = lookup_command('r', &cmd_map).unwrap();
+        assert_eq!(cmd.n_addr, 1);
+        assert_eq!(cmd.args, CommandArgs::ReadFile);
+    }
+
+    #[test]
+    fn test_lookup_writefile_command() {
+        let cmd_map = build_command_map();
+        let cmd = lookup_command('w', &cmd_map).unwrap();
+        assert_eq!(cmd.n_addr, 2);
+        assert_eq!(cmd.args, CommandArgs::WriteFile);
+    }
+
+    #[test]
+    fn test_lookup_substitute_command() {
+        let cmd_map = build_command_map();
+        let cmd = lookup_command('s', &cmd_map).unwrap();
+        assert_eq!(cmd.n_addr, 2);
+        assert_eq!(cmd.args, CommandArgs::Substitute);
+    }
+
+    #[test]
+    fn test_lookup_translate_command() {
+        let cmd_map = build_command_map();
+        let cmd = lookup_command('y', &cmd_map).unwrap();
+        assert_eq!(cmd.n_addr, 2);
+        assert_eq!(cmd.args, CommandArgs::Translate);
+    }
+
+    #[test]
+    fn test_lookup_invalid_command() {
+        let cmd_map = build_command_map();
+        let result = lookup_command('Z', &cmd_map);
+        assert!(result.is_none());
+    }
+}

From 14e963c9c7336652f32cbe9c76929dd1f58c4a52 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sun, 23 Mar 2025 15:24:45 +0200
Subject: [PATCH 09/16] Add hyperlinks to GNU and FreeBSD documentation

---
 README.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index a62bf28f..32dd9fb7 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,9 @@
 
 # sed
 
-Rust reimplementation of the [sed utility](https://pubs.opengroup.org/onlinepubs/9799919799/utilities/sed.html).
+Rust reimplementation of the [sed utility](https://pubs.opengroup.org/onlinepubs/9799919799/utilities/sed.html)
+with some [GNU sed](https://www.gnu.org/software/sed/manual/sed.html)
+and [FreeBSD sed](https://man.freebsd.org/cgi/man.cgi?sed(1)) extensions.
 
 ## Installation
 

From 880a2774efd9875fa61bb21b3c0c59091cdeb593 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sun, 23 Mar 2025 16:12:35 +0200
Subject: [PATCH 10/16] Initialize command map statically

---
 Cargo.lock                 |  1 +
 Cargo.toml                 |  1 +
 src/uu/sed/Cargo.toml      |  1 +
 src/uu/sed/src/compiler.rs | 48 +++++++++++++++-----------------------
 4 files changed, 22 insertions(+), 29 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 06788393..5536ed07 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -752,6 +752,7 @@ name = "uu_sed"
 version = "0.0.1"
 dependencies = [
  "clap",
+ "once_cell",
  "regex",
  "tempfile",
  "uucore",
diff --git a/Cargo.toml b/Cargo.toml
index c7b37fc8..7bb15914 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -37,6 +37,7 @@ clap_mangen = "0.2"
 regex = "1.10.4"
 sysinfo = "0.33"
 libc = "0.2.153"
+once_cell = "1.21"
 phf = "0.11.2"
 phf_codegen = "0.11.2"
 textwrap = { version = "0.16.1", features = ["terminal_size"] }
diff --git a/src/uu/sed/Cargo.toml b/src/uu/sed/Cargo.toml
index 56900a03..4a095456 100644
--- a/src/uu/sed/Cargo.toml
+++ b/src/uu/sed/Cargo.toml
@@ -15,6 +15,7 @@ categories = ["command-line-utilities"]
 [dependencies]
 uucore = { workspace = true }
 clap = { workspace = true }
+once_cell = { workspace = true }
 regex = { workspace = true }
 tempfile = { workspace = true }
 
diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index eb6c74c8..2373fd80 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.rs
@@ -10,9 +10,13 @@
 
 use crate::command::{Command, Context, ScriptValue};
 use crate::script_line_provider::ScriptLineProvider;
+use once_cell::sync::Lazy;
 use std::collections::HashMap;
 use uucore::error::UResult;
 
+// A global, immutable map of command properties, initialized on first access
+static CMD_MAP: Lazy<HashMap<char, SFormat>> = Lazy::new(build_command_map);
+
 // Types of command arguments recognized by the parser
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum CommandArgs {
@@ -76,12 +80,11 @@ fn build_command_map() -> HashMap<char, SFormat> {
 }
 
 // Look up a command format by its command code.
-fn lookup_command(cmd: char, map: &HashMap<char, SFormat>) -> Option<&SFormat> {
-    map.get(&cmd)
+fn lookup_command(cmd: char) -> Option<&'static SFormat> {
+    CMD_MAP.get(&cmd)
 }
 
 pub fn compile(scripts: Vec<ScriptValue>, _context: &mut Context) -> UResult<Option<Command>> {
-    let _cmd_map = build_command_map();
     let mut _line_provider = ScriptLineProvider::new(scripts);
 
     // TODO
@@ -94,104 +97,91 @@ mod tests {
 
     #[test]
     fn test_lookup_empty_command() {
-        let cmd_map = build_command_map();
-        let cmd = lookup_command('d', &cmd_map).unwrap();
+        let cmd = lookup_command('d').unwrap();
         assert_eq!(cmd.n_addr, 2);
         assert_eq!(cmd.args, CommandArgs::Empty);
     }
 
     #[test]
     fn test_lookup_text_command() {
-        let cmd_map = build_command_map();
-        let cmd = lookup_command('a', &cmd_map).unwrap();
+        let cmd = lookup_command('a').unwrap();
         assert_eq!(cmd.n_addr, 1);
         assert_eq!(cmd.args, CommandArgs::Text);
     }
 
     #[test]
     fn test_lookup_nonselect_command() {
-        let cmd_map = build_command_map();
-        let cmd = lookup_command('!', &cmd_map).unwrap();
+        let cmd = lookup_command('!').unwrap();
         assert_eq!(cmd.n_addr, 2);
         assert_eq!(cmd.args, CommandArgs::NonSelect);
     }
 
     #[test]
     fn test_lookup_group_command() {
-        let cmd_map = build_command_map();
-        let cmd = lookup_command('{', &cmd_map).unwrap();
+        let cmd = lookup_command('{').unwrap();
         assert_eq!(cmd.n_addr, 2);
         assert_eq!(cmd.args, CommandArgs::Group);
     }
 
     #[test]
     fn test_lookup_endgroup_command() {
-        let cmd_map = build_command_map();
-        let cmd = lookup_command('}', &cmd_map).unwrap();
+        let cmd = lookup_command('}').unwrap();
         assert_eq!(cmd.n_addr, 0);
         assert_eq!(cmd.args, CommandArgs::EndGroup);
     }
 
     #[test]
     fn test_lookup_comment_command() {
-        let cmd_map = build_command_map();
-        let cmd = lookup_command('#', &cmd_map).unwrap();
+        let cmd = lookup_command('#').unwrap();
         assert_eq!(cmd.n_addr, 0);
         assert_eq!(cmd.args, CommandArgs::Comment);
     }
 
     #[test]
     fn test_lookup_branch_command() {
-        let cmd_map = build_command_map();
-        let cmd = lookup_command('b', &cmd_map).unwrap();
+        let cmd = lookup_command('b').unwrap();
         assert_eq!(cmd.n_addr, 2);
         assert_eq!(cmd.args, CommandArgs::Branch);
     }
 
     #[test]
     fn test_lookup_label_command() {
-        let cmd_map = build_command_map();
-        let cmd = lookup_command(':', &cmd_map).unwrap();
+        let cmd = lookup_command(':').unwrap();
         assert_eq!(cmd.n_addr, 0);
         assert_eq!(cmd.args, CommandArgs::Label);
     }
 
     #[test]
     fn test_lookup_readfile_command() {
-        let cmd_map = build_command_map();
-        let cmd = lookup_command('r', &cmd_map).unwrap();
+        let cmd = lookup_command('r').unwrap();
         assert_eq!(cmd.n_addr, 1);
         assert_eq!(cmd.args, CommandArgs::ReadFile);
     }
 
     #[test]
     fn test_lookup_writefile_command() {
-        let cmd_map = build_command_map();
-        let cmd = lookup_command('w', &cmd_map).unwrap();
+        let cmd = lookup_command('w').unwrap();
         assert_eq!(cmd.n_addr, 2);
         assert_eq!(cmd.args, CommandArgs::WriteFile);
     }
 
     #[test]
     fn test_lookup_substitute_command() {
-        let cmd_map = build_command_map();
-        let cmd = lookup_command('s', &cmd_map).unwrap();
+        let cmd = lookup_command('s').unwrap();
         assert_eq!(cmd.n_addr, 2);
         assert_eq!(cmd.args, CommandArgs::Substitute);
     }
 
     #[test]
     fn test_lookup_translate_command() {
-        let cmd_map = build_command_map();
-        let cmd = lookup_command('y', &cmd_map).unwrap();
+        let cmd = lookup_command('y').unwrap();
         assert_eq!(cmd.n_addr, 2);
         assert_eq!(cmd.args, CommandArgs::Translate);
     }
 
     #[test]
     fn test_lookup_invalid_command() {
-        let cmd_map = build_command_map();
-        let result = lookup_command('Z', &cmd_map);
+        let result = lookup_command('Z');
         assert!(result.is_none());
     }
 }

From db8d2041b94cbf6761ce8880595d11f6672999a4 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sun, 23 Mar 2025 20:38:31 +0200
Subject: [PATCH 11/16] Use non-empty file with portable path

---
 tests/by-util/test_sed.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/tests/by-util/test_sed.rs b/tests/by-util/test_sed.rs
index 8c66b373..1bbe5188 100644
--- a/tests/by-util/test_sed.rs
+++ b/tests/by-util/test_sed.rs
@@ -4,6 +4,8 @@
 // file that was distributed with this source code.
 
 use crate::common::util::TestScenario;
+use std::io::Write;
+use tempfile::NamedTempFile;
 
 // Test application's invocation
 #[test]
@@ -41,5 +43,9 @@ fn test_e_script_ok() {
 
 #[test]
 fn test_f_script_ok() {
-    new_ucmd!().arg("-f").arg("/dev/null").succeeds();
+    let mut temp = NamedTempFile::new().expect("Failed to create temp file");
+    writeln!(temp, "l").expect("Failed to write to temp file");
+    let path = temp.path();
+
+    new_ucmd!().arg("-f").arg(path).succeeds();
 }

From 150627e5cd8fa0fbc5972bbfb15e75ebadba5155 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Sun, 23 Mar 2025 20:54:57 +0200
Subject: [PATCH 12/16] Implement script compilation framework

---
 src/uu/sed/src/command.rs              |  85 ++---
 src/uu/sed/src/compiler.rs             | 507 ++++++++++++++++++++++---
 src/uu/sed/src/processor.rs            |   2 +-
 src/uu/sed/src/script_line_provider.rs |  15 +
 src/uu/sed/src/sed.rs                  |   3 +-
 tests/by-util/test_sed.rs              |   7 +-
 6 files changed, 529 insertions(+), 90 deletions(-)

diff --git a/src/uu/sed/src/command.rs b/src/uu/sed/src/command.rs
index e29a553e..b0b6ba81 100644
--- a/src/uu/sed/src/command.rs
+++ b/src/uu/sed/src/command.rs
@@ -46,7 +46,7 @@ pub enum ScriptValue {
  * Types of address specifications
  */
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum AddressType {
+pub enum AddressType {
     Re,      // Line that matches regex
     Line,    // Specific line
     RelLine, // Relative line
@@ -57,14 +57,14 @@ enum AddressType {
  * Format of an address
  */
 #[derive(Debug)]
-struct Address {
-    atype: AddressType,  // Address type
-    value: AddressValue, // Line number or regex
+pub struct Address {
+    pub atype: AddressType,  // Address type
+    pub value: AddressValue, // Line number or regex
 }
 
 #[derive(Debug)]
-enum AddressValue {
-    LineNumber(u64),
+pub enum AddressValue {
+    LineNumber(usize),
     Regex(Regex),
 }
 
@@ -72,25 +72,23 @@ enum AddressValue {
  * Substitution command
  */
 #[derive(Debug)]
-struct Substitution {
-    occurrence: usize,             // Which occurrence to substitute
-    print_flag: bool,              // True if 'p' flag
-    ignore_case: bool,             // True if 'I' flag
-    write_file: Option<PathBuf>,   // Path to file if 'w' flag is used
-    file_descriptor: Option<File>, // Cached file descriptor
-    regex: Regex,                  // Regular expression
-    max_backref: u32,              // Largest backreference
-    line_number: u64,              // Line number
-    replacement: String,           // Replacement text
+pub struct Substitution {
+    pub occurrence: usize,             // Which occurrence to substitute
+    pub print_flag: bool,              // True if 'p' flag
+    pub ignore_case: bool,             // True if 'I' flag
+    pub write_file: Option<PathBuf>,   // Path to file if 'w' flag is used
+    pub file_descriptor: Option<File>, // Cached file descriptor
+    pub regex: Regex,                  // Regular expression
+    pub max_backref: u32,              // Largest backreference
+    pub line_number: usize,            // Line number
+    pub replacement: String,           // Replacement text
 }
 
-/*
- * Translate command.
- */
+// Transliteration command (y)
 #[derive(Debug)]
-struct TranslateCommand {
-    byte_table: [u8; 256],          // Byte translation table
-    multi_map: HashMap<char, char>, // Direct mapping from one char to another
+pub struct Transliteration {
+    pub byte_table: [u8; 256],          // Byte translation table
+    pub multi_map: HashMap<char, char>, // Direct mapping from one char to another
 }
 
 /*
@@ -98,35 +96,36 @@ struct TranslateCommand {
  */
 #[derive(Debug)]
 pub struct Command {
-    next: Option<Box<Command>>, // Pointer to next command
-    addr1: Option<Address>,     // Start address
-    addr2: Option<Address>,     // End address
-    start_line: Option<u64>,    // Start line number (or None)
-    text: Option<String>,       // Text for ':', 'a', 'c', 'i', 'r', 'w'
-    data: CommandData,          // Union equivalent
-    code: char,                 // Command code
-    non_select: bool,           // True if '!'
+    pub code: char,                 // Command code
+    pub addr1: Option<Address>,     // Start address
+    pub addr2: Option<Address>,     // End address
+    pub non_select: bool,           // True if '!'
+    pub start_line: Option<usize>,  // Start line number (or None)
+    pub text: Option<String>,       // Text for ':', 'a', 'c', 'i', 'r', 'w'
+    pub data: CommandData,          // Command-specific data
+    pub next: Option<Box<Command>>, // Pointer to next command
 }
 
 #[derive(Debug)]
-enum CommandData {
-    SubCommands(Vec<Command>),        // Commands for 'b', 't', '{'
-    Substitution(Box<Substitution>),  // Substitute command
-    Translate(Box<TranslateCommand>), // Replace command array
-    WriteFileDescriptor(File),        // File descriptor for 'w'
+pub enum CommandData {
+    None,
+    SubCommands(Vec<Command>),             // Commands for 'b', 't', '{'
+    Substitution(Box<Substitution>),       // Substitute command 's'
+    Transliteration(Box<Transliteration>), // Transliteration command 'y'
+    WriteFileDescriptor(File),             // File descriptor for 'w'
 }
 
 /*
  * Structure containing things to append before a line is read
  */
 #[derive(Debug)]
-struct AppendBuffer {
+pub struct AppendBuffer {
     append_type: AppendType,
     content: String,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum AppendType {
+pub enum AppendType {
     String,
     File,
 }
@@ -135,7 +134,7 @@ enum AppendType {
  * Special flag for space modifications
  */
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum SpaceFlag {
+pub enum SpaceFlag {
     Append,  // Append to contents
     Replace, // Replace contents
 }
@@ -144,9 +143,9 @@ enum SpaceFlag {
  * Structure for a processing space (process, hold, otherwise).
  */
 #[derive(Debug)]
-struct Space {
-    current: String,      // Current space content
-    deleted: bool,        // Whether content was deleted
-    append_newline: bool, // Whether originally terminated by \n
-    backup: String,       // Backing memory
+pub struct Space {
+    pub current: String,      // Current space content
+    pub deleted: bool,        // Whether content was deleted
+    pub append_newline: bool, // Whether originally terminated by \n
+    pub backup: String,       // Backing memory
 }
diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index 2373fd80..4ab6f16a 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.rs
@@ -8,14 +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, Context, ScriptValue};
+use crate::command::{Command, CommandData, Context, ScriptValue};
 use crate::script_line_provider::ScriptLineProvider;
 use once_cell::sync::Lazy;
 use std::collections::HashMap;
-use uucore::error::UResult;
+use uucore::error::{UResult, USimpleError};
 
 // A global, immutable map of command properties, initialized on first access
-static CMD_MAP: Lazy<HashMap<char, SFormat>> = Lazy::new(build_command_map);
+static CMD_MAP: Lazy<HashMap<char, CommandSpec>> = Lazy::new(build_command_map);
 
 // Types of command arguments recognized by the parser
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -36,65 +36,363 @@ enum CommandArgs {
 
 // Command specification
 #[derive(Debug, Clone, Copy)]
-struct SFormat {
-    code: char,         // Command letter used by sed
-    n_addr: usize,      // Number of supported addresses
-    args: CommandArgs,  // Type of command arguments
+struct CommandSpec {
+    code: char,        // Command letter used by sed
+    n_addr: usize,     // Number of supported addresses
+    args: CommandArgs, // Type of command arguments
 }
 
-// Build the command specification map (char -> SFormat)
-fn build_command_map() -> HashMap<char, SFormat> {
+// Build the command specification map (char -> CommandSpec)
+fn build_command_map() -> HashMap<char, CommandSpec> {
     let formats = [
-        SFormat { code: '{', n_addr: 2, args: CommandArgs::Group },
-        SFormat { code: '}', n_addr: 0, args: CommandArgs::EndGroup },
-        SFormat { code: 'a', n_addr: 1, args: CommandArgs::Text },
-        SFormat { code: 'b', n_addr: 2, args: CommandArgs::Branch },
-        SFormat { code: 'c', n_addr: 2, args: CommandArgs::Text },
-        SFormat { code: 'd', n_addr: 2, args: CommandArgs::Empty },
-        SFormat { code: 'D', n_addr: 2, args: CommandArgs::Empty },
-        SFormat { code: 'g', n_addr: 2, args: CommandArgs::Empty },
-        SFormat { code: 'G', n_addr: 2, args: CommandArgs::Empty },
-        SFormat { code: 'h', n_addr: 2, args: CommandArgs::Empty },
-        SFormat { code: 'H', n_addr: 2, args: CommandArgs::Empty },
-        SFormat { code: 'i', n_addr: 1, args: CommandArgs::Text },
-        SFormat { code: 'l', n_addr: 2, args: CommandArgs::Empty },
-        SFormat { code: 'n', n_addr: 2, args: CommandArgs::Empty },
-        SFormat { code: 'N', n_addr: 2, args: CommandArgs::Empty },
-        SFormat { code: 'p', n_addr: 2, args: CommandArgs::Empty },
-        SFormat { code: 'P', n_addr: 2, args: CommandArgs::Empty },
-        SFormat { code: 'q', n_addr: 1, args: CommandArgs::Empty },
-        SFormat { code: 'r', n_addr: 1, args: CommandArgs::ReadFile },
-        SFormat { code: 's', n_addr: 2, args: CommandArgs::Substitute },
-        SFormat { code: 't', n_addr: 2, args: CommandArgs::Branch },
-        SFormat { code: 'w', n_addr: 2, args: CommandArgs::WriteFile },
-        SFormat { code: 'x', n_addr: 2, args: CommandArgs::Empty },
-        SFormat { code: 'y', n_addr: 2, args: CommandArgs::Translate },
-        SFormat { code: '!', n_addr: 2, args: CommandArgs::NonSelect },
-        SFormat { code: ':', n_addr: 0, args: CommandArgs::Label },
-        SFormat { code: '#', n_addr: 0, args: CommandArgs::Comment },
-        SFormat { code: '=', n_addr: 1, args: CommandArgs::Empty },
-        SFormat { code: '\0', n_addr: 0, args: CommandArgs::Comment },
+        CommandSpec {
+            code: '{',
+            n_addr: 2,
+            args: CommandArgs::Group,
+        },
+        CommandSpec {
+            code: '}',
+            n_addr: 0,
+            args: CommandArgs::EndGroup,
+        },
+        CommandSpec {
+            code: 'a',
+            n_addr: 1,
+            args: CommandArgs::Text,
+        },
+        CommandSpec {
+            code: 'b',
+            n_addr: 2,
+            args: CommandArgs::Branch,
+        },
+        CommandSpec {
+            code: 'c',
+            n_addr: 2,
+            args: CommandArgs::Text,
+        },
+        CommandSpec {
+            code: 'd',
+            n_addr: 2,
+            args: CommandArgs::Empty,
+        },
+        CommandSpec {
+            code: 'D',
+            n_addr: 2,
+            args: CommandArgs::Empty,
+        },
+        CommandSpec {
+            code: 'g',
+            n_addr: 2,
+            args: CommandArgs::Empty,
+        },
+        CommandSpec {
+            code: 'G',
+            n_addr: 2,
+            args: CommandArgs::Empty,
+        },
+        CommandSpec {
+            code: 'h',
+            n_addr: 2,
+            args: CommandArgs::Empty,
+        },
+        CommandSpec {
+            code: 'H',
+            n_addr: 2,
+            args: CommandArgs::Empty,
+        },
+        CommandSpec {
+            code: 'i',
+            n_addr: 1,
+            args: CommandArgs::Text,
+        },
+        CommandSpec {
+            code: 'l',
+            n_addr: 2,
+            args: CommandArgs::Empty,
+        },
+        CommandSpec {
+            code: 'n',
+            n_addr: 2,
+            args: CommandArgs::Empty,
+        },
+        CommandSpec {
+            code: 'N',
+            n_addr: 2,
+            args: CommandArgs::Empty,
+        },
+        CommandSpec {
+            code: 'p',
+            n_addr: 2,
+            args: CommandArgs::Empty,
+        },
+        CommandSpec {
+            code: 'P',
+            n_addr: 2,
+            args: CommandArgs::Empty,
+        },
+        CommandSpec {
+            code: 'q',
+            n_addr: 1,
+            args: CommandArgs::Empty,
+        },
+        CommandSpec {
+            code: 'r',
+            n_addr: 1,
+            args: CommandArgs::ReadFile,
+        },
+        CommandSpec {
+            code: 's',
+            n_addr: 2,
+            args: CommandArgs::Substitute,
+        },
+        CommandSpec {
+            code: 't',
+            n_addr: 2,
+            args: CommandArgs::Branch,
+        },
+        CommandSpec {
+            code: 'w',
+            n_addr: 2,
+            args: CommandArgs::WriteFile,
+        },
+        CommandSpec {
+            code: 'x',
+            n_addr: 2,
+            args: CommandArgs::Empty,
+        },
+        CommandSpec {
+            code: 'y',
+            n_addr: 2,
+            args: CommandArgs::Translate,
+        },
+        CommandSpec {
+            code: '!',
+            n_addr: 2,
+            args: CommandArgs::NonSelect,
+        },
+        CommandSpec {
+            code: ':',
+            n_addr: 0,
+            args: CommandArgs::Label,
+        },
+        CommandSpec {
+            code: '#',
+            n_addr: 0,
+            args: CommandArgs::Comment,
+        },
+        CommandSpec {
+            code: '=',
+            n_addr: 1,
+            args: CommandArgs::Empty,
+        },
     ];
 
     formats.into_iter().map(|f| (f.code, f)).collect()
 }
 
-// Look up a command format by its command code.
-fn lookup_command(cmd: char) -> Option<&'static SFormat> {
-    CMD_MAP.get(&cmd)
+// How to continue after processing a command
+#[derive(Debug)]
+enum ContinueAction {
+    NextLine,
+    NextChar,
+}
+
+pub fn compile(scripts: Vec<ScriptValue>, context: &mut Context) -> UResult<Option<Box<Command>>> {
+    let mut line_provider = ScriptLineProvider::new(scripts);
+
+    let result = compile_thread(&mut line_provider, context)?;
+    // TODO: fix-up labels, check used labels, setup append & match structures
+    Ok(result)
 }
 
-pub fn compile(scripts: Vec<ScriptValue>, _context: &mut Context) -> UResult<Option<Command>> {
-    let mut _line_provider = ScriptLineProvider::new(scripts);
+// Compile provided scripts into a thread of commands
+fn compile_thread(
+    lines: &mut ScriptLineProvider,
+    _context: &mut Context,
+) -> UResult<Option<Box<Command>>> {
+    // Initialize the head of the list as None
+    let mut head: Option<Box<Command>> = None;
+
+    // A mutable reference to the place we’ll insert next
+    let mut next_p = &mut head;
+
+    'next_line: loop {
+        match lines.next_line().unwrap() {
+            None => {
+                // TODO: Error if stack isn't empty
+                return Ok(head);
+            }
+            Some(line_string) => {
+                // Line as a vector we can index through pos
+                let line: Vec<char> = line_string.chars().collect();
+                let mut pos: usize = 0;
+
+                // TODO: set context.quiet for StringVal starting with #n
+                'next_char: loop {
+                    eat_spaces(&line, &mut pos);
+                    if pos == line.len() || line[pos] == '#' {
+                        continue 'next_line;
+                    } else if line[pos] == ';' {
+                        pos += 1;
+                        continue 'next_char;
+                    }
+                    let mut cmd = Box::new(Command {
+                        next: None,
+                        addr1: None,
+                        addr2: None,
+                        start_line: Some(0),
+                        text: None,
+                        data: CommandData::None,
+                        code: '_',
+                        non_select: false,
+                    });
+
+                    let n_addr = compile_addresses(&line, &mut pos, &mut cmd);
+                    let mut cmd_spec = get_cmd_spec(lines, &line, pos, n_addr)?;
+
+                    if cmd_spec.args == CommandArgs::NonSelect {
+                        pos += 1;
+                        eat_spaces(&line, &mut pos);
+                        cmd.non_select = true;
+                        cmd_spec = get_cmd_spec(lines, &line, pos, n_addr)?;
+                    }
+                    let action = compile_command(lines, &line, &mut pos, &mut cmd, cmd_spec)?;
 
+                    // Move cmd into next_p, transferring its ownership
+                    *next_p = Some(cmd);
+                    next_p = &mut next_p.as_mut().unwrap().next;
+
+                    match action {
+                        ContinueAction::NextLine => continue 'next_line,
+                        ContinueAction::NextChar => continue 'next_char,
+                    }
+                }
+            }
+        }
+    }
+}
+
+// Compile the specified command
+fn compile_command(
+    lines: &mut ScriptLineProvider,
+    line: &[char],
+    pos: &mut usize,
+    cmd: &mut Command,
+    cmd_spec: &'static CommandSpec,
+) -> UResult<ContinueAction> {
+    cmd.code = line[*pos];
     // TODO
-    Ok(None)
+    match cmd_spec.args {
+        CommandArgs::Empty => {
+            // d D g G h H l n N p P q x = \0
+            *pos += 1;
+            eat_spaces(line, pos);
+            if *pos < line.len() && line[*pos] == ';' {
+                *pos += 1;
+                // TODO: update link
+                return Ok(ContinueAction::NextChar);
+            }
+            if *pos < line.len() {
+                return compile_error(
+                    lines,
+                    *pos,
+                    format!("extra characters at the end of the {} command", cmd.code),
+                );
+            }
+        }
+        CommandArgs::Text => { // a c i
+        }
+        CommandArgs::NonSelect => { // !
+        }
+        CommandArgs::Group => { // {
+        }
+        CommandArgs::EndGroup => { // }
+        }
+        CommandArgs::Comment => { // #
+        }
+        CommandArgs::Branch => { // b t
+        }
+        CommandArgs::Label => { // :
+        }
+        CommandArgs::ReadFile => { // r
+        }
+        CommandArgs::WriteFile => { // w
+        }
+        CommandArgs::Substitute => { // s
+        }
+        CommandArgs::Translate => { // y
+        }
+    }
+    Ok(ContinueAction::NextLine)
+}
+
+// Compile a command's addresses into cmd.
+// Return the number of addresses encountered.
+fn compile_addresses(_line: &[char], _pos: &mut usize, _cmd: &mut Command) -> usize {
+    // TODO: let n_addr = 0; ...
+    0
+}
+
+// Fail with msg as a compile error at the current location
+fn compile_error<T>(lines: &ScriptLineProvider, pos: usize, msg: impl ToString) -> UResult<T> {
+    Err(USimpleError::new(
+        1,
+        format!(
+            "{}:{}:{}: error: {}",
+            lines.get_input_name(),
+            lines.get_line_number(),
+            pos,
+            msg.to_string()
+        ),
+    ))
+}
+
+// Return the specification for the command letter line[pos]
+// checking for diverse errors.
+fn get_cmd_spec(
+    lines: &ScriptLineProvider,
+    line: &[char],
+    pos: usize,
+    n_addr: usize,
+) -> UResult<&'static CommandSpec> {
+    if pos == line.len() {
+        return compile_error(lines, pos, "command expected");
+    }
+    let opt_cmd_spec = lookup_command(line[pos]);
+    if opt_cmd_spec.is_none() {
+        return compile_error(lines, pos, format!("invalid command code {}", line[pos]));
+    }
+    let cmd_spec = opt_cmd_spec.unwrap();
+    if n_addr > cmd_spec.n_addr {
+        return compile_error(
+            lines,
+            pos,
+            format!(
+                "command {} expects up to {} address(es), found {}",
+                line[pos], cmd_spec.n_addr, n_addr
+            ),
+        );
+    }
+    Ok(cmd_spec)
+}
+
+// Advance pos over any white space occuring in chars
+fn eat_spaces(chars: &[char], pos: &mut usize) {
+    while *pos < chars.len() && chars[*pos].is_whitespace() {
+        *pos += 1;
+    }
+}
+
+// Look up a command format by its command code.
+fn lookup_command(cmd: char) -> Option<&'static CommandSpec> {
+    CMD_MAP.get(&cmd)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    // lookup_command
     #[test]
     fn test_lookup_empty_command() {
         let cmd = lookup_command('d').unwrap();
@@ -184,4 +482,125 @@ mod tests {
         let result = lookup_command('Z');
         assert!(result.is_none());
     }
+
+    // eat_spaces
+    #[test]
+    fn test_eat_spaces() {
+        let input = "   \t\n  hello";
+        let chars: Vec<char> = input.chars().collect();
+        let mut pos = 0;
+
+        eat_spaces(&chars, &mut pos);
+
+        // Should skip all whitespace and land at 'h'
+        assert_eq!(chars[pos], 'h');
+        assert_eq!(pos, 7); // 3 spaces + 1 tab + 1 newline + 2 spaces
+    }
+
+    #[test]
+    fn test_eat_spaces_only_whitespace() {
+        let input = " \t\n  ";
+        let chars: Vec<char> = input.chars().collect();
+        let mut pos = 0;
+
+        eat_spaces(&chars, &mut pos);
+
+        // Should move pos to the end
+        assert_eq!(pos, chars.len());
+    }
+
+    #[test]
+    fn test_eat_spaces_no_whitespace() {
+        let input = "hello";
+        let chars: Vec<char> = input.chars().collect();
+        let mut pos = 0;
+
+        eat_spaces(&chars, &mut pos);
+
+        // Should not change pos
+        assert_eq!(pos, 0);
+    }
+
+    // compile_error
+    #[test]
+    fn test_compile_error_message_format() {
+        let lines = ScriptLineProvider::with_active_state("test.sed", 42);
+        let pos = 7;
+        let msg = "unexpected token";
+
+        let result: UResult<()> = compile_error(&lines, pos, msg);
+
+        assert!(result.is_err());
+
+        let err = result.unwrap_err();
+        let msg = err.to_string();
+
+        assert!(msg.contains("test.sed:42:7: error: unexpected token"));
+    }
+
+    #[test]
+    fn test_compile_error_with_format_message() {
+        let lines = ScriptLineProvider::with_active_state("input.txt", 3);
+        let pos = 1;
+
+        let result: UResult<()> = compile_error(&lines, pos, format!("invalid command '{}'", 'x'));
+
+        assert!(result.is_err());
+
+        let err = result.unwrap_err();
+        let msg = err.to_string();
+
+        assert_eq!(msg, "input.txt:3:1: error: invalid command 'x'");
+    }
+
+    // get_cmd_spec
+    fn line_from_str(s: &str) -> Vec<char> {
+        s.chars().collect()
+    }
+
+    #[test]
+    fn test_missing_command_character() {
+        let lines = ScriptLineProvider::with_active_state("test.sed", 1);
+        let line = line_from_str("");
+        let result = get_cmd_spec(&lines, &line, 0, 0);
+
+        assert!(result.is_err());
+        let msg = result.unwrap_err().to_string();
+        assert!(msg.contains("test.sed:1:0: error: command expected"));
+    }
+
+    #[test]
+    fn test_invalid_command_character() {
+        let lines = ScriptLineProvider::with_active_state("script.sed", 2);
+        let line = line_from_str("@");
+        let result = get_cmd_spec(&lines, &line, 0, 0);
+
+        assert!(result.is_err());
+        let msg = result.unwrap_err().to_string();
+        assert!(msg.contains("script.sed:2:0: error: invalid command code @"));
+    }
+
+    #[test]
+    fn test_too_many_addresses() {
+        let lines = ScriptLineProvider::with_active_state("input.sed", 3);
+        let line = line_from_str("q"); // q takes one address
+        let result = get_cmd_spec(&lines, &line, 0, 2);
+
+        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")
+        );
+    }
+
+    #[test]
+    fn test_valid_command_spec() {
+        let lines = ScriptLineProvider::with_active_state("input.sed", 4);
+        let line = line_from_str("a"); // valid command
+        let result = get_cmd_spec(&lines, &line, 0, 1);
+
+        assert!(result.is_ok());
+        let spec = result.unwrap();
+        assert_eq!(spec.code, 'a');
+    }
 }
diff --git a/src/uu/sed/src/processor.rs b/src/uu/sed/src/processor.rs
index 402c5eef..239915f1 100644
--- a/src/uu/sed/src/processor.rs
+++ b/src/uu/sed/src/processor.rs
@@ -14,7 +14,7 @@ use std::path::PathBuf;
 use uucore::error::UResult;
 
 pub fn process(
-    _code: Option<Command>,
+    _code: Option<Box<Command>>,
     _files: Vec<PathBuf>,
     _context: &mut Context,
 ) -> UResult<()> {
diff --git a/src/uu/sed/src/script_line_provider.rs b/src/uu/sed/src/script_line_provider.rs
index 1730fa6f..f41a457b 100644
--- a/src/uu/sed/src/script_line_provider.rs
+++ b/src/uu/sed/src/script_line_provider.rs
@@ -237,3 +237,18 @@ mod tests {
         }
     }
 }
+
+#[cfg(test)]
+impl ScriptLineProvider {
+    pub fn with_active_state(input_name: &str, line_number: usize) -> Self {
+        Self {
+            sources: vec![],
+            state: State::Active {
+                input_name: input_name.to_string(),
+                line_number,
+                index: 0,
+                reader: Box::new(BufReader::new(io::stdin())),
+            },
+        }
+    }
+}
diff --git a/src/uu/sed/src/sed.rs b/src/uu/sed/src/sed.rs
index a7640a2e..97103c2d 100644
--- a/src/uu/sed/src/sed.rs
+++ b/src/uu/sed/src/sed.rs
@@ -199,7 +199,7 @@ fn build_context(matches: &ArgMatches) -> Context {
 mod tests {
     use super::*; // Allows access to private functions/items in this module
 
-    // Test the get_scripts_files function
+    // get_scripts_files
 
     // Helper function for supplying arguments
     fn get_test_matches(args: &[&str]) -> ArgMatches {
@@ -293,6 +293,7 @@ mod tests {
         assert_eq!(files, vec![PathBuf::from("-")]); // Stdin should be used
     }
 
+    // build_context
     fn test_matches(args: &[&str]) -> ArgMatches {
         uu_app().get_matches_from(["sed"].into_iter().chain(args.iter().copied()))
     }
diff --git a/tests/by-util/test_sed.rs b/tests/by-util/test_sed.rs
index 1bbe5188..3e88c5b5 100644
--- a/tests/by-util/test_sed.rs
+++ b/tests/by-util/test_sed.rs
@@ -1,5 +1,10 @@
-// This file is part of the uutils sed package.
+// Integration tests
+//
+// 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.
 

From ae95f4eab115de3dd7d8fef8917767afb46ad8d4 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Mon, 24 Mar 2025 09:11:22 +0200
Subject: [PATCH 13/16] Improve naming of CLI options

---
 src/uu/sed/src/command.rs   |  5 +++--
 src/uu/sed/src/compiler.rs  | 13 ++++++++-----
 src/uu/sed/src/processor.rs |  4 ++--
 src/uu/sed/src/sed.rs       | 14 +++++++-------
 4 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/src/uu/sed/src/command.rs b/src/uu/sed/src/command.rs
index b0b6ba81..a70f681f 100644
--- a/src/uu/sed/src/command.rs
+++ b/src/uu/sed/src/command.rs
@@ -16,9 +16,10 @@ use std::collections::HashMap;
 use std::fs::File;
 use std::path::PathBuf; // For file descriptors and equivalent
 
-// Compilation and processing context
+// Compilation and processing options provided mostly through the
+// command-line interface
 #[derive(Debug)]
-pub struct Context {
+pub struct CliOptions {
     // Command-line flags with corresponding names
     pub all_output_files: bool,
     pub debug: bool,
diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index 4ab6f16a..bf7a9e72 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.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::command::{Command, CommandData, Context, ScriptValue};
+use crate::command::{CliOptions, Command, CommandData, ScriptValue};
 use crate::script_line_provider::ScriptLineProvider;
 use once_cell::sync::Lazy;
 use std::collections::HashMap;
@@ -197,10 +197,13 @@ enum ContinueAction {
     NextChar,
 }
 
-pub fn compile(scripts: Vec<ScriptValue>, context: &mut Context) -> UResult<Option<Box<Command>>> {
+pub fn compile(
+    scripts: Vec<ScriptValue>,
+    cli_options: &mut CliOptions,
+) -> UResult<Option<Box<Command>>> {
     let mut line_provider = ScriptLineProvider::new(scripts);
 
-    let result = compile_thread(&mut line_provider, context)?;
+    let result = compile_thread(&mut line_provider, cli_options)?;
     // TODO: fix-up labels, check used labels, setup append & match structures
     Ok(result)
 }
@@ -208,7 +211,7 @@ pub fn compile(scripts: Vec<ScriptValue>, context: &mut Context) -> UResult<Opti
 // Compile provided scripts into a thread of commands
 fn compile_thread(
     lines: &mut ScriptLineProvider,
-    _context: &mut Context,
+    _cli_options: &mut CliOptions,
 ) -> UResult<Option<Box<Command>>> {
     // Initialize the head of the list as None
     let mut head: Option<Box<Command>> = None;
@@ -227,7 +230,7 @@ fn compile_thread(
                 let line: Vec<char> = line_string.chars().collect();
                 let mut pos: usize = 0;
 
-                // TODO: set context.quiet for StringVal starting with #n
+                // TODO: set cli_options.quiet for StringVal starting with #n
                 'next_char: loop {
                     eat_spaces(&line, &mut pos);
                     if pos == line.len() || line[pos] == '#' {
diff --git a/src/uu/sed/src/processor.rs b/src/uu/sed/src/processor.rs
index 239915f1..4d5b3c15 100644
--- a/src/uu/sed/src/processor.rs
+++ b/src/uu/sed/src/processor.rs
@@ -8,15 +8,15 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use crate::command::CliOptions;
 use crate::command::Command;
-use crate::command::Context;
 use std::path::PathBuf;
 use uucore::error::UResult;
 
 pub fn process(
     _code: Option<Box<Command>>,
     _files: Vec<PathBuf>,
-    _context: &mut Context,
+    _cli_options: &mut CliOptions,
 ) -> UResult<()> {
     // TODO
     Ok(())
diff --git a/src/uu/sed/src/sed.rs b/src/uu/sed/src/sed.rs
index 97103c2d..ad8c853e 100644
--- a/src/uu/sed/src/sed.rs
+++ b/src/uu/sed/src/sed.rs
@@ -13,7 +13,7 @@ pub mod compiler;
 pub mod processor;
 pub mod script_line_provider;
 
-use crate::command::{Context, ScriptValue};
+use crate::command::{CliOptions, ScriptValue};
 use crate::compiler::compile;
 use crate::processor::process;
 use clap::{arg, Arg, ArgMatches, Command};
@@ -28,10 +28,10 @@ const USAGE: &str = "sed [OPTION]... [script] [file]...";
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().try_get_matches_from(args)?;
     let (scripts, files) = get_scripts_files(&matches)?;
-    let mut context = build_context(&matches);
+    let mut cli_options = build_context(&matches);
 
-    let executable = compile(scripts, &mut context)?;
-    process(executable, files, &mut context)?;
+    let executable = compile(scripts, &mut cli_options)?;
+    process(executable, files, &mut cli_options)?;
     Ok(())
 }
 
@@ -167,9 +167,9 @@ fn get_scripts_files(matches: &ArgMatches) -> UResult<(Vec<ScriptValue>, Vec<Pat
     Ok((scripts, files))
 }
 
-// Parse CLI flag arguments and return a Context struct based on them
-fn build_context(matches: &ArgMatches) -> Context {
-    Context {
+// Parse CLI flag arguments and return a CliOptions struct based on them
+fn build_context(matches: &ArgMatches) -> CliOptions {
+    CliOptions {
         all_output_files: matches.get_flag("all-output-files"),
         debug: matches.get_flag("debug"),
         regexp_extended: matches.get_flag("regexp-extended"),

From ae7a23505f675f32acc94588ba6ba5aab559af9e Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Mon, 24 Mar 2025 10:40:35 +0200
Subject: [PATCH 14/16] Refactor iterating over a line into a struct

---
 src/uu/sed/src/compiler.rs             | 182 +++++++++++--------------
 src/uu/sed/src/script_char_provider.rs | 101 ++++++++++++++
 src/uu/sed/src/sed.rs                  |   1 +
 3 files changed, 178 insertions(+), 106 deletions(-)
 create mode 100644 src/uu/sed/src/script_char_provider.rs

diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index bf7a9e72..94c68a29 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.rs
@@ -9,6 +9,7 @@
 // file that was distributed with this source code.
 
 use crate::command::{CliOptions, Command, CommandData, ScriptValue};
+use crate::script_char_provider::ScriptCharProvider;
 use crate::script_line_provider::ScriptLineProvider;
 use once_cell::sync::Lazy;
 use std::collections::HashMap;
@@ -213,9 +214,7 @@ fn compile_thread(
     lines: &mut ScriptLineProvider,
     _cli_options: &mut CliOptions,
 ) -> UResult<Option<Box<Command>>> {
-    // Initialize the head of the list as None
     let mut head: Option<Box<Command>> = None;
-
     // A mutable reference to the place we’ll insert next
     let mut next_p = &mut head;
 
@@ -226,19 +225,18 @@ fn compile_thread(
                 return Ok(head);
             }
             Some(line_string) => {
-                // Line as a vector we can index through pos
-                let line: Vec<char> = line_string.chars().collect();
-                let mut pos: usize = 0;
+                let mut line = ScriptCharProvider::new(&line_string);
 
                 // TODO: set cli_options.quiet for StringVal starting with #n
                 'next_char: loop {
-                    eat_spaces(&line, &mut pos);
-                    if pos == line.len() || line[pos] == '#' {
+                    line.eat_spaces();
+                    if line.eol() || line.current() == '#' {
                         continue 'next_line;
-                    } else if line[pos] == ';' {
-                        pos += 1;
+                    } else if line.current() == ';' {
+                        line.advance();
                         continue 'next_char;
                     }
+
                     let mut cmd = Box::new(Command {
                         next: None,
                         addr1: None,
@@ -250,18 +248,19 @@ fn compile_thread(
                         non_select: false,
                     });
 
-                    let n_addr = compile_addresses(&line, &mut pos, &mut cmd);
-                    let mut cmd_spec = get_cmd_spec(lines, &line, pos, n_addr)?;
+                    let n_addr = compile_addresses(&mut line, &mut cmd);
+                    let mut cmd_spec = get_cmd_spec(lines, &line, n_addr)?;
 
                     if cmd_spec.args == CommandArgs::NonSelect {
-                        pos += 1;
-                        eat_spaces(&line, &mut pos);
+                        line.advance();
+                        line.eat_spaces();
                         cmd.non_select = true;
-                        cmd_spec = get_cmd_spec(lines, &line, pos, n_addr)?;
+                        cmd_spec = get_cmd_spec(lines, &line, n_addr)?;
                     }
-                    let action = compile_command(lines, &line, &mut pos, &mut cmd, cmd_spec)?;
 
                     // Move cmd into next_p, transferring its ownership
+                    let action = compile_command(lines, &mut line, &mut cmd, cmd_spec)?;
+
                     *next_p = Some(cmd);
                     next_p = &mut next_p.as_mut().unwrap().next;
 
@@ -275,34 +274,41 @@ fn compile_thread(
     }
 }
 
+// Compile a command's addresses into cmd.
+// Return the number of addresses encountered.
+fn compile_addresses(_line: &mut ScriptCharProvider, _cmd: &mut Command) -> usize {
+    // TODO: implement address parsing
+    0
+}
+
 // Compile the specified command
 fn compile_command(
     lines: &mut ScriptLineProvider,
-    line: &[char],
-    pos: &mut usize,
+    line: &mut ScriptCharProvider,
     cmd: &mut Command,
     cmd_spec: &'static CommandSpec,
 ) -> UResult<ContinueAction> {
-    cmd.code = line[*pos];
-    // TODO
+    cmd.code = line.current();
+
     match cmd_spec.args {
         CommandArgs::Empty => {
-            // d D g G h H l n N p P q x = \0
-            *pos += 1;
-            eat_spaces(line, pos);
-            if *pos < line.len() && line[*pos] == ';' {
-                *pos += 1;
+            // d D g G h H l n N p P q x =
+            line.advance();
+            line.eat_spaces();
+            if !line.eol() && line.current() == ';' {
+                line.advance();
                 // TODO: update link
                 return Ok(ContinueAction::NextChar);
             }
-            if *pos < line.len() {
+            if !line.eol() {
                 return compile_error(
                     lines,
-                    *pos,
+                    line,
                     format!("extra characters at the end of the {} command", cmd.code),
                 );
             }
         }
+        // TODO
         CommandArgs::Text => { // a c i
         }
         CommandArgs::NonSelect => { // !
@@ -326,64 +332,59 @@ fn compile_command(
         CommandArgs::Translate => { // y
         }
     }
-    Ok(ContinueAction::NextLine)
-}
 
-// Compile a command's addresses into cmd.
-// Return the number of addresses encountered.
-fn compile_addresses(_line: &[char], _pos: &mut usize, _cmd: &mut Command) -> usize {
-    // TODO: let n_addr = 0; ...
-    0
+    Ok(ContinueAction::NextLine)
 }
 
 // Fail with msg as a compile error at the current location
-fn compile_error<T>(lines: &ScriptLineProvider, pos: usize, msg: impl ToString) -> UResult<T> {
+fn compile_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(),
-            pos,
+            line.get_pos(),
             msg.to_string()
         ),
     ))
 }
 
-// Return the specification for the command letter line[pos]
+// Return the specification for the command letter at the current line position
 // checking for diverse errors.
 fn get_cmd_spec(
     lines: &ScriptLineProvider,
-    line: &[char],
-    pos: usize,
+    line: &ScriptCharProvider,
     n_addr: usize,
 ) -> UResult<&'static CommandSpec> {
-    if pos == line.len() {
-        return compile_error(lines, pos, "command expected");
+    if line.eol() {
+        return compile_error(lines, line, "command expected");
     }
-    let opt_cmd_spec = lookup_command(line[pos]);
+
+    let ch = line.current();
+    let opt_cmd_spec = lookup_command(ch);
+
     if opt_cmd_spec.is_none() {
-        return compile_error(lines, pos, format!("invalid command code {}", line[pos]));
+        return compile_error(lines, line, format!("invalid command code {}", ch));
     }
+
     let cmd_spec = opt_cmd_spec.unwrap();
     if n_addr > cmd_spec.n_addr {
         return compile_error(
             lines,
-            pos,
+            line,
             format!(
                 "command {} expects up to {} address(es), found {}",
-                line[pos], cmd_spec.n_addr, n_addr
+                ch, cmd_spec.n_addr, n_addr
             ),
         );
     }
-    Ok(cmd_spec)
-}
 
-// Advance pos over any white space occuring in chars
-fn eat_spaces(chars: &[char], pos: &mut usize) {
-    while *pos < chars.len() && chars[*pos].is_whitespace() {
-        *pos += 1;
-    }
+    Ok(cmd_spec)
 }
 
 // Look up a command format by its command code.
@@ -486,86 +487,55 @@ mod tests {
         assert!(result.is_none());
     }
 
-    // eat_spaces
-    #[test]
-    fn test_eat_spaces() {
-        let input = "   \t\n  hello";
-        let chars: Vec<char> = input.chars().collect();
-        let mut pos = 0;
-
-        eat_spaces(&chars, &mut pos);
-
-        // Should skip all whitespace and land at 'h'
-        assert_eq!(chars[pos], 'h');
-        assert_eq!(pos, 7); // 3 spaces + 1 tab + 1 newline + 2 spaces
-    }
-
-    #[test]
-    fn test_eat_spaces_only_whitespace() {
-        let input = " \t\n  ";
-        let chars: Vec<char> = input.chars().collect();
-        let mut pos = 0;
-
-        eat_spaces(&chars, &mut pos);
-
-        // Should move pos to the end
-        assert_eq!(pos, chars.len());
-    }
-
-    #[test]
-    fn test_eat_spaces_no_whitespace() {
-        let input = "hello";
-        let chars: Vec<char> = input.chars().collect();
-        let mut pos = 0;
-
-        eat_spaces(&chars, &mut pos);
-
-        // Should not change pos
-        assert_eq!(pos, 0);
+    // Utility to create a ScriptCharProvider from a &str
+    fn char_provider_from(s: &str) -> ScriptCharProvider {
+        ScriptCharProvider::new(s)
     }
 
     // compile_error
     #[test]
     fn test_compile_error_message_format() {
         let lines = ScriptLineProvider::with_active_state("test.sed", 42);
-        let pos = 7;
-        let msg = "unexpected token";
+        let mut line = char_provider_from("whatever");
+        line.advance(); // move to position 1
+        line.advance(); // move to position 2
+        line.advance(); // move to position 3
+        line.advance(); // now at position 4
 
-        let result: UResult<()> = compile_error(&lines, pos, msg);
+        let msg = "unexpected token";
+        let result: UResult<()> = compile_error(&lines, &line, msg);
 
         assert!(result.is_err());
 
         let err = result.unwrap_err();
         let msg = err.to_string();
 
-        assert!(msg.contains("test.sed:42:7: error: unexpected token"));
+        assert!(msg.contains("test.sed:42:4: error: unexpected token"));
     }
 
     #[test]
     fn test_compile_error_with_format_message() {
         let lines = ScriptLineProvider::with_active_state("input.txt", 3);
-        let pos = 1;
+        let mut line = char_provider_from("x");
+        // We're at position 0
 
-        let result: UResult<()> = compile_error(&lines, pos, format!("invalid command '{}'", 'x'));
+        let result: UResult<()> =
+            compile_error(&lines, &line, format!("invalid command '{}'", 'x'));
 
         assert!(result.is_err());
 
         let err = result.unwrap_err();
         let msg = err.to_string();
 
-        assert_eq!(msg, "input.txt:3:1: error: invalid command 'x'");
+        assert_eq!(msg, "input.txt:3:0: error: invalid command 'x'");
     }
 
     // get_cmd_spec
-    fn line_from_str(s: &str) -> Vec<char> {
-        s.chars().collect()
-    }
-
     #[test]
     fn test_missing_command_character() {
         let lines = ScriptLineProvider::with_active_state("test.sed", 1);
-        let line = line_from_str("");
-        let result = get_cmd_spec(&lines, &line, 0, 0);
+        let line = char_provider_from("");
+        let result = get_cmd_spec(&lines, &line, 0);
 
         assert!(result.is_err());
         let msg = result.unwrap_err().to_string();
@@ -575,8 +545,8 @@ mod tests {
     #[test]
     fn test_invalid_command_character() {
         let lines = ScriptLineProvider::with_active_state("script.sed", 2);
-        let line = line_from_str("@");
-        let result = get_cmd_spec(&lines, &line, 0, 0);
+        let line = char_provider_from("@");
+        let result = get_cmd_spec(&lines, &line, 0);
 
         assert!(result.is_err());
         let msg = result.unwrap_err().to_string();
@@ -586,8 +556,8 @@ mod tests {
     #[test]
     fn test_too_many_addresses() {
         let lines = ScriptLineProvider::with_active_state("input.sed", 3);
-        let line = line_from_str("q"); // q takes one address
-        let result = get_cmd_spec(&lines, &line, 0, 2);
+        let line = char_provider_from("q"); // q takes one address
+        let result = get_cmd_spec(&lines, &line, 2);
 
         assert!(result.is_err());
         let msg = result.unwrap_err().to_string();
@@ -599,8 +569,8 @@ mod tests {
     #[test]
     fn test_valid_command_spec() {
         let lines = ScriptLineProvider::with_active_state("input.sed", 4);
-        let line = line_from_str("a"); // valid command
-        let result = get_cmd_spec(&lines, &line, 0, 1);
+        let line = char_provider_from("a"); // valid command
+        let result = get_cmd_spec(&lines, &line, 1);
 
         assert!(result.is_ok());
         let spec = result.unwrap();
diff --git a/src/uu/sed/src/script_char_provider.rs b/src/uu/sed/src/script_char_provider.rs
new file mode 100644
index 00000000..6f404693
--- /dev/null
+++ b/src/uu/sed/src/script_char_provider.rs
@@ -0,0 +1,101 @@
+// Provide the script contents character by character
+//
+// 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.
+
+pub struct ScriptCharProvider {
+    line: Vec<char>,
+    pos: usize,
+}
+
+impl ScriptCharProvider {
+    pub fn new(line_string: &str) -> Self {
+        Self {
+            line: line_string.chars().collect(),
+            pos: 0,
+        }
+    }
+
+    /// Advances to the next character, if not at end of line.
+    pub fn advance(&mut self) {
+        if self.pos < self.line.len() {
+            self.pos += 1;
+        }
+    }
+
+    /// Returns the current character. Panics if out of bounds.
+    pub fn current(&self) -> char {
+        self.line[self.pos]
+    }
+
+    /// Returns true if at the end of the line.
+    pub fn eol(&self) -> bool {
+        self.pos >= self.line.len()
+    }
+
+    /// Advances the position past any whitespace characters.
+    pub fn eat_spaces(&mut self) {
+        while self.pos < self.line.len() && self.line[self.pos].is_whitespace() {
+            self.pos += 1;
+        }
+    }
+
+    /// Return current position
+    pub fn get_pos(&self) -> usize {
+        self.pos
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_basic_navigation() {
+        let mut provider = ScriptCharProvider::new("abc");
+        assert_eq!(provider.get_pos(), 0);
+        assert_eq!(provider.current(), 'a');
+        provider.advance();
+        assert_eq!(provider.get_pos(), 1);
+        assert_eq!(provider.current(), 'b');
+        provider.advance();
+        assert_eq!(provider.get_pos(), 2);
+        assert_eq!(provider.current(), 'c');
+        provider.advance();
+        assert_eq!(provider.get_pos(), 3);
+        assert!(provider.eol());
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_current_panics_out_of_bounds() {
+        let mut provider = ScriptCharProvider::new("x");
+        provider.advance(); // now at end
+        provider.current(); // should panic
+    }
+
+    #[test]
+    fn test_eat_spaces() {
+        let mut provider = ScriptCharProvider::new("   xyz");
+        provider.eat_spaces();
+        assert_eq!(provider.current(), 'x');
+    }
+
+    #[test]
+    fn test_eol_on_empty() {
+        let provider = ScriptCharProvider::new("");
+        assert!(provider.eol());
+    }
+
+    #[test]
+    fn test_eat_spaces_mixed() {
+        let mut provider = ScriptCharProvider::new("  \t\nabc");
+        provider.eat_spaces();
+        assert_eq!(provider.current(), 'a');
+    }
+}
diff --git a/src/uu/sed/src/sed.rs b/src/uu/sed/src/sed.rs
index ad8c853e..2a3dae8b 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 processor;
+pub mod script_char_provider;
 pub mod script_line_provider;
 
 use crate::command::{CliOptions, ScriptValue};

From 03958ae1b58876acb874d41b49b3c249cb825600 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Fri, 4 Apr 2025 11:02:45 +0300
Subject: [PATCH 15/16] Fix mutability warning

---
 src/uu/sed/src/compiler.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index 94c68a29..5d016299 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.rs
@@ -516,7 +516,7 @@ mod tests {
     #[test]
     fn test_compile_error_with_format_message() {
         let lines = ScriptLineProvider::with_active_state("input.txt", 3);
-        let mut line = char_provider_from("x");
+        let line = char_provider_from("x");
         // We're at position 0
 
         let result: UResult<()> =

From 640e54836a79405eccdd0874283d46a0aa9930b2 Mon Sep 17 00:00:00 2001
From: Diomidis Spinellis <dds@aueb.gr>
Date: Fri, 4 Apr 2025 11:02:58 +0300
Subject: [PATCH 16/16] Add required comments

---
 src/uu/sed/src/script_line_provider.rs | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

diff --git a/src/uu/sed/src/script_line_provider.rs b/src/uu/sed/src/script_line_provider.rs
index f41a457b..24841d5d 100644
--- a/src/uu/sed/src/script_line_provider.rs
+++ b/src/uu/sed/src/script_line_provider.rs
@@ -1,4 +1,4 @@
-// Provide the script contents line by line
+//! Provide the script contents line by line
 //
 // SPDX-License-Identifier: MIT
 // Copyright (c) 2025 Diomidis Spinellis
@@ -12,23 +12,27 @@ use crate::command::ScriptValue;
 use std::fs::File;
 use std::io::{self, BufRead, BufReader};
 
+/// The provider of script lines across all specified scripts
+/// Scripts can be specified to sed as files or as strings.
 pub struct ScriptLineProvider {
     sources: Vec<ScriptValue>,
     state: State,
 }
 
+// Encapsulation of the script line provider's state
 enum State {
-    NotStarted,
+    NotStarted, // Processing has not yet started
     Active {
         index: usize,
-        reader: Box<dyn BufRead>,
-        input_name: String,
-        line_number: usize,
+        reader: Box<dyn BufRead>, // Object on which read_line is called
+        input_name: String,       // Input description (path or script string)
+        line_number: usize,       // Current line number
     },
-    Done,
+    Done, // All scripts have been processed
 }
 
 impl ScriptLineProvider {
+    /// Construct the script provider from the specified script sources
     pub fn new(sources: Vec<ScriptValue>) -> Self {
         Self {
             sources,
@@ -36,6 +40,7 @@ impl ScriptLineProvider {
         }
     }
 
+    /// Return the currently processed script line number.
     pub fn get_line_number(&self) -> usize {
         match &self.state {
             State::Active { line_number, .. } => *line_number,
@@ -43,6 +48,7 @@ impl ScriptLineProvider {
         }
     }
 
+    /// Return the currently processed script descriptive name.
     pub fn get_input_name(&self) -> &str {
         match &self.state {
             State::Active { input_name, .. } => input_name.as_str(),
@@ -50,6 +56,7 @@ impl ScriptLineProvider {
         }
     }
 
+    /// Return the next script line to process across all scripts.
     pub fn next_line(&mut self) -> io::Result<Option<String>> {
         let mut line = String::new();
 
@@ -82,6 +89,7 @@ impl ScriptLineProvider {
         }
     }
 
+    // Move to the next available script source.
     fn advance_source(&mut self, next_index: usize) -> io::Result<()> {
         if next_index >= self.sources.len() {
             self.state = State::Done;
@@ -130,6 +138,7 @@ impl ScriptLineProvider {
         Ok(())
     }
 }
+
 #[cfg(test)]
 mod tests {
     use super::*;