chore(deps): update rust crate divan to v5.0.3

When a range command is first evaluated on a line after its numeric first
address (inside a block, or after d, n, N, c or a branch skipped it), start
the range on the current line, as GNU sed does, unless a numeric second
address has also been passed. The range can start this way only once.

Fixes #541

.github/workflows/GnuTests.yml

@@ -49,6 +49,19 @@ jobs:
 
     # Omit installing part of https://github.com/actions/runner-images/tree/main/images/ubuntu
 
+    ### Locales
+    # Several testsuite scripts guard themselves with require_*_locale_ and
+    # silently skip when the locale is missing, which hides both regressions
+    # and improvements in the multibyte code paths.
+    - name: Generate the locales required by the testsuite
+      shell: bash
+      run: |
+        ## Generate the locales required by the testsuite
+        sudo localedef -i en_US -f UTF-8 en_US.UTF-8
+        sudo localedef -i ru_RU -f UTF-8 ru_RU.UTF-8
+        sudo localedef -i el_GR -f ISO-8859-7 el_GR.iso88597
+        locale -a
+
     ### Build
     - name: Build Rust sed binary
       shell: bash
@@ -134,7 +147,7 @@ jobs:
         persist-credentials: false
 
     - name: Retrieve reference artifacts
-      uses: dawidd6/action-download-artifact@v21
+      uses: dawidd6/action-download-artifact@v27
       continue-on-error: true
       with:
         workflow: GnuTests.yml

.github/workflows/ci.yml

@@ -97,12 +97,12 @@ jobs:
         RUSTC_WRAPPER: ""
         RUSTFLAGS: "-Cinstrument-coverage -Zcoverage-options=branch -Ccodegen-units=1 -Copt-level=0 -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
         RUSTDOCFLAGS: "-Cpanic=abort"
-        LLVM_PROFILE_FILE: "sed-%p-%m.profraw"
+        LLVM_PROFILE_FILE: "${{ github.workspace }}/sed-%p-%m.profraw"
     - name: "`grcov` ~ install"
       id: build_grcov
       shell: bash
       run: |
-        git clone https://github.com/mozilla/grcov.git ~/grcov/
+        git clone --depth=1 https://github.com/mozilla/grcov.git ~/grcov/
         cd ~/grcov
         cargo install --path .
         cd -

.github/workflows/documentation.yml

@@ -0,0 +1,41 @@
+name: Documentation
+
+on:
+  pull_request:
+    paths:
+      - 'docs/**'
+      - '.github/workflows/documentation.yml'
+  push:
+    branches:
+      - main
+    paths:
+      - 'docs/**'
+      - '.github/workflows/documentation.yml'
+
+permissions:
+  contents: read
+
+jobs:
+  build-doc:
+    name: Build the mdBook documentation
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v7
+        with:
+          persist-credentials: false
+
+      - name: Install mdbook
+        uses: taiki-e/install-action@v2
+        with:
+          tool: mdbook@0.5.0
+
+      - name: Build documentation
+        run: mdbook build docs
+
+      - name: Upload documentation
+        uses: actions/upload-artifact@v7
+        with:
+          name: documentation
+          path: docs/book

.github/workflows/release.yml

@@ -64,7 +64,7 @@ jobs:
         # we specify bash to get pipefail; it guards against the `curl` command
         # failing. otherwise `sh` won't catch that `curl` returned non-0
         shell: bash
-        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.30.3/cargo-dist-installer.sh | sh"
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.33.0/cargo-dist-installer.sh | sh"
       - name: Cache dist
         uses: actions/upload-artifact@v7
         with:

Cargo.toml

@@ -1,11 +1,12 @@
 # sed (uutils)
 # * see the repository LICENSE, README, and CONTRIBUTING files for more information
 
-# spell-checker:ignore (libs) mangen sed
+# spell-checker:ignore (libs) mangen sed binstall codspeed libc memchr memmap rlimit rustix textwrap uucore uutests xattr
+# spell-checker:ignore (misc) clippy codegen msvc startswith uninlined uutils
 
 [package]
 name = "sed"
-version = "0.2.0"
+version = "0.3.0"
 license = "MIT"
 description = "sed ~ implemented as universal (cross-platform) utils, written in Rust"
 default-run = "sed"
@@ -20,6 +21,19 @@ rust-version = "1.88"
 
 build = "build.rs"
 
+# cargo-binstall: fetch the archives published by `dist` in the GitHub releases
+# instead of building from source. The layout below has to stay in sync with
+# `dist-workspace.toml` (targets) and the archives it produces:
+#   sed-<target>.tar.xz (zip on Windows), containing a sed-<target>/ directory.
+# Note that the release tags carry no `v` prefix, hence `{ version }`.
+[package.metadata.binstall]
+pkg-url = "{ repo }/releases/download/{ version }/{ name }-{ target }.{ archive-suffix }"
+bin-dir = "{ name }-{ target }/{ bin }{ binary-ext }"
+pkg-fmt = "txz"
+
+[package.metadata.binstall.overrides.x86_64-pc-windows-msvc]
+pkg-fmt = "zip"
+
 [features]
 default = ["feat_common_core"]
 
@@ -28,9 +42,6 @@ sed = []
 
 [workspace.dependencies]
 assert_fs = "1.1.3"
-chrono = { version = "0.4.37", default-features = false, features = [
-  "clock",
-] }
 clap = { version = "4.4", features = ["wrap_help", "cargo"] }
 clap_complete = "4.5"
 clap_mangen = "0.3"
@@ -45,11 +56,12 @@ phf_codegen = "0.14.0"
 predicates = "3.1.3"
 rand = { version = "0.10.0" }
 regex = "1.10.4"
-sha2 = "0.11"
+sha2 = { version = "0.11.0", default-features = false, features = ["alloc"] }
 tempfile = "3.10.1"
 terminal_size = "0.4.2"
 textwrap = { version = "0.16.1", features = ["terminal_size"] }
-uucore = { version = "0.10.0", features = ["libc"] }
+unicode-width = "0.2.2"
+uucore = { version = "0.12.0", features = ["diagnostics", "libc"] }
 rustix = "1.1.4"
 xattr = "1.3.1"
 
@@ -67,12 +79,12 @@ regex = { workspace = true }
 tempfile = { workspace = true }
 terminal_size = { workspace = true }
 textwrap = { workspace = true }
+unicode-width = { workspace = true }
 uucore = { workspace = true }
 rustix = { workspace = true }
 
 [dev-dependencies]
 assert_fs = { workspace = true }
-chrono = { workspace = true }
 ctor = "1.0.0"
 divan = { workspace = true }
 hex = { workspace = true }
@@ -83,7 +95,7 @@ regex = { workspace = true }
 sha2 = { workspace = true }
 tempfile = { workspace = true }
 uucore = { workspace = true, features = ["entries", "process", "signals", "benchmark"] }
-uutests = "0.10.0"
+uutests = "0.12.0"
 
 [target.'cfg(unix)'.dev-dependencies]
 xattr = { workspace = true }
@@ -117,6 +129,10 @@ inherits = "release"
 opt-level = "z"
 strip = true
 
+# The profile that 'dist' will build with
+[profile.dist]
+inherits = "release"
+
 [lints.clippy]
 all = { level = "warn", priority = -1 }
 

README.md

@@ -15,22 +15,30 @@ and other extensions.
 ## Status
 
 At this state _sed_ implements all [POSIX features](https://pubs.opengroup.org/onlinepubs/9799919799/)
-and can run correctly the two complex scripts of its integration tests:
-[hanoi.sed](https://github.com/uutils/sed/blob/main/tests/fixtures/sed/script/hanoi.sed) (solves the Towers of Hanoi puzzle) and
+and can run correctly the three complex scripts of its integration tests:
+[hanoi.sed](https://github.com/uutils/sed/blob/main/tests/fixtures/sed/script/hanoi.sed) (solves the Towers of Hanoi puzzle),
+[mandelbrot.sed](https://github.com/uutils/sed/blob/main/tests/fixtures/sed/script/mandelbrot.sed), (draws the Mandelbrot set) and
 [math.sed](https://github.com/uutils/sed/blob/main/tests/fixtures/sed/script/math.sed)  (implements an arbitrary precision integer math calculator).
 
 The performance of this Rust implementation is now better than the GNU and FreeBSD implementations for most benchmarked cases.
 
 Further work aims to:
-* Adjust buffering on terminal output to match current implementations,
-* Implement more GNU extensions,
-* Improve performance where possible.
+* improve GNU _sed_ compatibility, especially on the regular expression front,
+* implement more GNU extensions, and
+* improve performance where possible.
 
 ## Installation and Use
 
 We provide a Linux x86_64 binary archive from the main branch at
 https://github.com/uutils/sed/releases/tag/latest-commit .
 
+If you have [cargo-binstall](https://github.com/cargo-bins/cargo-binstall),
+the released binaries can be installed directly with:
+
+```bash
+cargo binstall sed
+```
+
 For other platforms, ensure you have Rust installed on your system. You can install Rust through [rustup](https://rustup.rs/).
 
 Clone the repository and build the project using Cargo:
@@ -80,65 +88,8 @@ cargo test
 ```
 
 ## Extensions and incompatibilities
-### Supported GNU extensions
-* Command-line arguments can be specified in long (`--`) form.
-* Spaces can precede a regular expression modifier.
-* `I` can be used in as a synonym for the `i` (case insensitive) substitution
-  flag.
-* `M` and `m` substitution flags allow multi-line matching.
-* In addition to `\n`, other escape sequences (octal, hex, C) are supported
-  in the strings of the `y` command.
-  Under POSIX these yield undefined behavior.
-* The `a`, `c`, and `i` commands do not require an initial backslash,
-  allow text to appear on the same line, and support escape sequences
-  in the specified text.
-* The `a`, `i`, `=`, `l`, `q` and `r` commands support address range as an extension to POSIX.
-* The substitution command replacement group `\0` is a synonym for &.
-* A `Q` command (optionally followed by an exit code) quits immediately.
-* The `q` command can be optionally followed by an exit code.
-* The `l` command can be optionally followed by the output width.
-* The `--follow-symlinks` option for in-place editing.
-* The `--sandbox` option that limits potentially destructive commands.
-* Address 0 can be used to specify an address range that is already
-  active on line 1 and can finish with the specified regular expression.
-* Address steps can be specified in the form of start~step and start,~step
-  ranges.
-* Address 0 can be used in the `r` command to prepend a file.
-
-### Supported BSD and GNU extensions
-* The second address in a range can be specified as a relative address with +N.
-* In-place editing of file with the `-i` flag.
-
-### New extensions
-* Unicode characters can be specified in regular expression pattern, replacement
-  and transliteration sequences using `\uXXXX` or `\UXXXXXXXX` sequences.
-* The `l` command lists Unicode characters using the `\uXXXX` and `\UXXXXXXXX`
-  sequences.
-
-### Incompatibilities
-* Similarly to GNU _sed_, input is processed as raw bytes or as valid UTF-8
-  (this includes 7-bit ASCII) based on the locale as specified by the
-  `LC_ALL`, `LC_CTYPE`, and `LANG` environment variables,
-  with the default being byte processing.
-  However, in contrast with GNU _sed_, other locales (e.g. ISO-8859-1)
-  are not supported. If the input is in another code page or encoding
-  and requires locale-specific processing (e.g. ignore/map case,
-  character classes), consider converting it through UTF-8 to ensure
-  the correct handling of locale-specific regular expressions.
-  This _sed_ program can also handle arbitrary byte sequences
-  if no part of the input requires treating it as a Rust String.
-* Back-references aren't supported when input is processed as bytes
-  (`LC_ALL=C`).
-* The command will report an error and fail if duplicate labels are found
-  in the script.
-  This matches the BSD behavior. The GNU version accepts duplicate labels.
-* The last line (`$`) address is interpreted as the last non-empty line of
-  the last file.  If files specified in subsequent arguments until the last
-  one are empty, then the last line condition will never be triggered.
-  This behavior is consistent with the
-  [original implementation](https://github.com/dspinellis/unix-history-repo/blob/Research-V7/usr/src/cmd/sed/sed1.c#L665).
-* Labels are parsed for alphanumeric characters. The BSD version parses them
-  until the end of the line, preventing ; to be used as a separator.
+The GNU, BSD and new extensions _sed_ supports, and where it differs from GNU
+_sed_, are listed in [docs/src/extensions.md](docs/src/extensions.md).
 
 ## GNU test suite compatibility
 

dist-workspace.toml

@@ -4,7 +4,7 @@ members = ["cargo:."]
 # Config for 'dist'
 [dist]
 # The preferred dist version to use in CI (Cargo.toml SemVer syntax)
-cargo-dist-version = "0.30.3"
+cargo-dist-version = "0.33.0"
 # CI backends to support
 ci = "github"
 # The installers to generate for each app
@@ -13,5 +13,5 @@ installers = []
 targets = ["aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-unknown-linux-musl", "x86_64-pc-windows-msvc"]
 # Which actions to run on pull requests
 pr-run-mode = "plan"
-# Allow dirty workflows to ignore out-of-date contents
+# Skip checking whether the specified configuration files are up to date
 allow-dirty = ["ci"]

docs/.gitignore

@@ -0,0 +1 @@
+book

docs/book.toml

@@ -0,0 +1,7 @@
+[book]
+language = "en"
+src = "src"
+title = "uutils sed Documentation"
+
+[output.html]
+git-repository-url = "https://github.com/uutils/sed/tree/main/docs/src"

docs/src/SUMMARY.md

@@ -0,0 +1,5 @@
+# Summary
+
+[Introduction](index.md)
+
+* [Extensions and incompatibilities](extensions.md)

docs/src/extensions.md

@@ -0,0 +1,86 @@
+# Extensions and incompatibilities
+
+The main goal of the project is compatibility with GNU _sed_, but _sed_ also
+supports features that GNU _sed_ does not, and differs from it in a few places.
+Below is a list of these extensions and incompatibilities.
+
+## Supported GNU extensions
+* Command-line arguments can be specified in long (`--`) form.
+* Spaces can precede a regular expression modifier.
+* `I` can be used in as a synonym for the `i` (case insensitive) substitution
+  flag.
+* `M` and `m` substitution flags allow multi-line matching.
+* In addition to `\n`, other escape sequences (octal, hex, C) are supported
+  in the strings of the `y` command.
+  Under POSIX these yield undefined behavior.
+* The `a`, `c`, and `i` commands do not require an initial backslash,
+  allow text to appear on the same line, and support escape sequences
+  in the specified text.
+* The `a`, `i`, `=`, `l`, `q` and `r` commands support address range as an extension to POSIX.
+* The substitution command replacement group `\0` is a synonym for &.
+* An `F` command outputs the name of the file currently being processed.
+* A `Q` command (optionally followed by an exit code) quits immediately.
+* The `q` command can be optionally followed by an exit code.
+* A `W` command writes to a file the pattern's first line.
+* An `R` command reads one line at a time from a file.
+* The `l` command can be optionally followed by the output width.
+* The `--follow-symlinks` option for in-place editing.
+* The `--sandbox` option that limits potentially destructive commands.
+* Address 0 can be used to specify an address range that is already
+  active on line 1 and can finish with the specified regular expression.
+* Address steps can be specified in the form of start~step and start,~step
+  ranges.
+* Address 0 can be used in the `r` command to prepend a file.
+
+## Supported BSD and GNU extensions
+* The second address in a range can be specified as a relative address with +N.
+* In-place editing of file with the `-i` flag.
+  As in GNU _sed_, a backup suffix must be attached (`-i.bak`,
+  `--in-place=.bak`); BSD's `-i .bak` and `-i ''` are not supported.
+
+## New extensions
+* Unicode characters can be specified in regular expression pattern, replacement
+  and transliteration sequences using `\uXXXX` or `\UXXXXXXXX` sequences.
+* On a terminal, script errors also quote the script line and underline the
+  character at fault (`UUTILS_DIAG=always` or `never` overrides this):
+  ```
+  $ sed 's/a/b/q'
+  sed: <script argument 1>:1:7: error: invalid substitute flag: 'q'
+     ╭─[ <script argument 1>:1:7 ]
+     │
+   1 │ s/a/b/q
+     │       ─
+  ───╯
+  ```
+
+## Incompatible extensions
+The `-U` or `--uutil-extensions` option enables useful extensions or bug fixes
+that aren't compatible with GNU sed or POSIX.
+
+* The `l` command lists Unicode characters using the `\uXXXX` and `\UXXXXXXXX`
+  escapes rather than as octal UTF-8 byte sequences.
+
+## Incompatibilities
+* Similarly to GNU _sed_, input is processed as raw bytes or as valid UTF-8
+  (this includes 7-bit ASCII) based on the locale as specified by the
+  `LC_ALL`, `LC_CTYPE`, and `LANG` environment variables,
+  with the default being byte processing.
+  However, in contrast with GNU _sed_, other locales (e.g. ISO-8859-1)
+  are not supported. If the input is in another code page or encoding
+  and requires locale-specific processing (e.g. ignore/map case,
+  character classes), consider converting it through UTF-8 to ensure
+  the correct handling of locale-specific regular expressions.
+  This _sed_ program can also handle arbitrary byte sequences
+  if no part of the input requires treating it as a Rust String.
+* Back-references aren't supported when input is processed as bytes
+  (`LC_ALL=C`).
+* The command will report an error and fail if duplicate labels are found
+  in the script.
+  This matches the BSD behavior. The GNU version accepts duplicate labels.
+* The last line (`$`) address is interpreted as the last non-empty line of
+  the last file.  If files specified in subsequent arguments until the last
+  one are empty, then the last line condition will never be triggered.
+  This behavior is consistent with the
+  [original implementation](https://github.com/dspinellis/unix-history-repo/blob/Research-V7/usr/src/cmd/sed/sed1.c#L665).
+* Labels are parsed for alphanumeric characters. The BSD version parses them
+  until the end of the line, preventing ; to be used as a separator.

docs/src/index.md

@@ -0,0 +1,10 @@
+# uutils sed
+
+_sed_ is a 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),
+[FreeBSD sed](https://man.freebsd.org/cgi/man.cgi?sed(1)),
+and other extensions.
+
+It is part of the [uutils](https://uutils.github.io/) project. The source code
+is on [GitHub](https://github.com/uutils/sed).

fuzz/Cargo.toml

@@ -14,8 +14,8 @@ libc = "0.2.153"
 tempfile = "3.15.0"
 rand = { version = "0.10.0" }
 similar = "3.0.0"
-uucore = { version = "0.10.0", features = ["libc"] }
-uufuzz = "0.10.0"
+uucore = { version = "0.12.0", features = ["libc"] }
+uufuzz = "0.12.0"
 
 sed = { path = ".." }
 

src/sed/command.rs

@@ -10,6 +10,7 @@
 
 use crate::sed::error_handling::{ScriptLocation, runtime_error};
 use crate::sed::fast_regex::{Captures, Match, Regex};
+use crate::sed::named_reader::NamedReader;
 use crate::sed::named_writer::NamedWriter;
 use crate::sed::script_char_provider::ScriptCharProvider;
 use crate::sed::script_line_provider::ScriptLineProvider;
@@ -38,10 +39,11 @@ pub struct ProcessingContext {
     pub sandbox: bool,
     pub unbuffered: bool,
     pub null_data: bool,
+    pub uutil_extensions: bool,
 
     // Other context
-    /// Currently processed input file name (not script) in quoted form
-    pub input_name: String,
+    /// Currently processed input file name (not script)
+    pub input_name: PathBuf,
     /// Current input line number
     pub line_number: usize,
     /// True if this is the last address of a range
@@ -52,6 +54,8 @@ pub struct ProcessingContext {
     pub last_file: bool,
     /// Stop processing further input.
     pub stop_processing: bool,
+    /// Stop without writing a missing final newline (`Q`).
+    pub quit_silently: bool,
     /// Whether sed operates on bytes or UTF-8 characters
     pub character_mode: CharacterMode,
     /// Previously compiled RE, saved for reuse when specifying an empty RE
@@ -62,10 +66,13 @@ pub struct ProcessingContext {
     pub input_action: Option<InputAction>,
     /// Hold space
     pub hold: ByteSpace,
-    /// Nesting of { } at compile time
-    pub parsed_block_nesting: usize,
+    /// Location of each `{` still open at compile time, innermost last
+    pub open_blocks: Vec<ScriptLocation>,
     /// Command associated with each label
     pub label_to_command_map: HashMap<String, Rc<RefCell<Command>>>,
+    /// Shared `R` readers keyed by file path, so that all `R` commands naming
+    /// the same file advance a single cursor, matching GNU sed.
+    pub named_readers: HashMap<PathBuf, Rc<RefCell<NamedReader>>>,
     /// Commands with a (latchable and resetable) address range
     pub range_commands: Vec<Rc<RefCell<Command>>>,
     /// True if a substitution was made as specified in the t command
@@ -329,6 +336,7 @@ pub struct Command {
     pub addr2: Option<Address>,             // End address
     pub non_select: bool,                   // True if '!'
     pub start_line: Option<usize>,          // Start line number (or None if unlatched)
+    pub range_started: bool,                // True once the range has been entered
     pub data: CommandData,                  // Command-specific data
     pub next: Option<Rc<RefCell<Command>>>, // Pointer to next command
     pub location: ScriptLocation,           // Command's definition location
@@ -342,6 +350,7 @@ impl Default for Command {
             addr2: None,
             non_select: false,
             start_line: None,
+            range_started: false,
             data: CommandData::None,
             next: None,
             location: ScriptLocation::default(),
@@ -367,6 +376,7 @@ pub enum CommandData {
     BranchTarget(Option<Rc<RefCell<Command>>>), // Commands for 'b', 't', 'T', '{'
     Label(Option<String>),                      // Label name for 'b', 't', 'T', ':'
     Path(PathBuf),                              // File path for 'r'
+    NamedReader(Rc<RefCell<NamedReader>>),      // Successive file lines for 'R'
     NamedWriter(Rc<RefCell<NamedWriter>>),      // File output for 'w'
     Number(usize),                              // Number for 'l', 'q', 'Q' (GNU)
     Substitution(Box<Substitution>),            // Substitute command 's'
@@ -386,8 +396,17 @@ pub enum SpaceFlag {
 pub struct InputAction {
     /// Next command to execute (rather than commands from start)
     pub next_command: Option<Rc<RefCell<Command>>>,
-    /// Data to prepend to the read contents
-    pub prepend: Vec<u8>,
+    /// How the read line becomes the pattern space
+    pub next_line: NextLine,
+}
+
+#[derive(Debug, Clone)]
+/// How a line read by `n` or `N` becomes the pattern space
+pub enum NextLine {
+    /// Replace the pattern space with the line (`n`)
+    Replace,
+    /// Append the line, after a newline, to these contents (`N`)
+    Append(Vec<u8>),
 }
 
 #[cfg(test)]

src/sed/compiler.rs

@@ -18,6 +18,7 @@ use crate::sed::delimited_parser::{
 };
 use crate::sed::error_handling::{ScriptLocation, compilation_error, semantic_error};
 use crate::sed::fast_regex::Regex;
+use crate::sed::named_reader::NamedReader;
 use crate::sed::named_writer::NamedWriter;
 use crate::sed::script_char_provider::ScriptCharProvider;
 use crate::sed::script_line_provider::{ScriptLineProvider, ScriptValue};
@@ -28,7 +29,7 @@ use std::path::PathBuf;
 use std::rc::Rc;
 
 use terminal_size::{Width, terminal_size};
-use uucore::error::{UResult, USimpleError};
+use uucore::error::UResult;
 
 const DEFAULT_OUTPUT_WIDTH: usize = 60;
 
@@ -76,6 +77,11 @@ pub fn compile(
     #[cfg(any())]
     dbg!(&result);
 
+    // Like GNU sed, point at the innermost `{` left open.
+    if let Some(location) = context.open_blocks.last() {
+        return semantic_error(location, "unmatched `{'");
+    }
+
     // Link branch commands to the target label commands.
     populate_label_map(result.clone(), context)?;
     populate_range_commands(result.clone(), context);
@@ -84,9 +90,6 @@ pub fn compile(
     // Link the ends of command blocks to their following commands.
     // This converts the tree into a graph, so it must be the last
     // conversion that traverses the structure as a tree.
-    if context.parsed_block_nesting > 0 {
-        return Err(USimpleError::new(1, "unmatched `{'"));
-    }
     patch_block_endings(result.clone());
 
     Ok(result)
@@ -358,7 +361,7 @@ fn compile_address_range(
         let is_step_match = line.current() == '~'; // E.g. 0~2: Pick even-numbered lines
         line.advance();
         line.eat_spaces();
-        let is_step_end = if line.current() == '~' {
+        let is_step_end = if !line.eol() && line.current() == '~' {
             // E.g. /foo/,~10: Start at foo, include all lines until multiple of 10 is reached.
             line.advance();
             line.eat_spaces();
@@ -372,39 +375,46 @@ fn compile_address_range(
             return compilation_error(lines, line, "~step is invalid in POSIX mode");
         }
 
-        // Look for second address.
-        if !line.eol() {
-            let addr2 = compile_address(lines, line, context)?;
-            // Set step_n to the number specified in the (required numeric) address.
-            let step_n = if is_step_match || is_step_end {
-                match addr2 {
-                    Address::Line(n) => n,
-                    _ => {
-                        return compilation_error(
-                            lines,
-                            line,
-                            "~step can only be specified through numeric values",
-                        );
-                    }
-                }
-            } else {
-                0 // dummy, not used
-            };
-
-            if is_line0 && !matches!(addr2, Address::Re(_)) && !is_step_match {
-                return compilation_error(lines, line, ERR_ADDRESS_0_USAGE);
-            }
-
-            // If needed, transform Address::Line into Address::Step*.
-            cmd.addr2 = if is_step_match {
-                Some(Address::StepMatch(step_n))
-            } else if is_step_end {
-                Some(Address::StepEnd(step_n))
-            } else {
-                Some(addr2)
-            };
-            n_addr += 1;
+        // Look for second address; a missing ~step counts as 0.
+        let has_addr2 = !line.eol() && (is_address_char(line.current()) || line.current() == '+');
+        if !(has_addr2 || is_step_match || is_step_end) {
+            return compilation_error(lines, line, "unexpected `,'");
         }
+        let addr2 = if has_addr2 {
+            compile_address(lines, line, context)?
+        } else {
+            Address::Line(0)
+        };
+        // Set step_n to the number specified in the (required numeric) address.
+        let step_n = if is_step_match || is_step_end {
+            match addr2 {
+                Address::Line(n) => n,
+                _ => {
+                    return compilation_error(
+                        lines,
+                        line,
+                        "~step can only be specified through numeric values",
+                    );
+                }
+            }
+        } else {
+            0 // dummy, not used
+        };
+
+        // Address 0 needs a regex end or a positive ~step (0~0 selects no line).
+        if is_line0 && !matches!(addr2, Address::Re(_)) && !(is_step_match && step_n > 0) {
+            return compilation_error(lines, line, ERR_ADDRESS_0_USAGE);
+        }
+
+        // If needed, transform Address::Line into Address::Step*.
+        cmd.addr2 = if is_step_match {
+            Some(Address::StepMatch(step_n))
+        } else if is_step_end {
+            Some(Address::StepEnd(step_n))
+        } else {
+            Some(addr2)
+        };
+        n_addr += 1;
     }
 
     // Zero-address read command check
@@ -495,7 +505,7 @@ fn compile_address(
             let number = parse_number(lines, line, true)?.unwrap();
             Ok(Address::Line(number))
         }
-        _ => panic!("invalid context address"),
+        _ => compilation_error(lines, line, "expected context address"),
     }
 }
 
@@ -833,6 +843,10 @@ fn compile_subst_command(
 ) -> UResult<CommandHandling> {
     line.advance(); // move past 's'
 
+    if line.eol() {
+        return compilation_error(lines, line, "unterminated `s' command");
+    }
+
     let delimiter = line.current();
     if delimiter == '\0' || delimiter == '\\' {
         return compilation_error(
@@ -899,6 +913,10 @@ fn compile_trans_command(
 ) -> UResult<CommandHandling> {
     line.advance(); // move past 'y'
 
+    if line.eol() {
+        return compilation_error(lines, line, "unterminated `y' command");
+    }
+
     let delimiter = line.current();
     if delimiter == '\0' || delimiter == '\\' {
         return compilation_error(
@@ -1066,10 +1084,9 @@ fn compile_end_group_command(
     cmd: &mut Command,
     context: &mut ProcessingContext,
 ) -> UResult<CommandHandling> {
-    if context.parsed_block_nesting == 0 {
+    if context.open_blocks.pop().is_none() {
         return compilation_error(lines, line, "unexpected `}'");
     }
-    context.parsed_block_nesting -= 1;
     line.advance();
     line.eat_spaces();
     parse_command_ending(lines, line, cmd)?;
@@ -1122,6 +1139,28 @@ fn compile_read_file_command(
     Ok(CommandHandling::Continue)
 }
 
+// Handles R
+fn compile_read_line_command(
+    lines: &mut ScriptLineProvider,
+    line: &mut ScriptCharProvider,
+    cmd: &mut Command,
+    context: &mut ProcessingContext,
+) -> UResult<CommandHandling> {
+    if context.sandbox {
+        return compilation_error(lines, line, ERR_SANDBOX);
+    }
+    let path = read_file_path(lines, line)?;
+    // Reuse a reader keyed by path so all `R` commands on the same file share
+    // one cursor (see `ProcessingContext::named_readers`).
+    let reader = context
+        .named_readers
+        .entry(path.clone())
+        .or_insert_with(|| NamedReader::new(path))
+        .clone();
+    cmd.data = CommandData::NamedReader(reader);
+    Ok(CommandHandling::Continue)
+}
+
 // Handles w
 fn compile_write_file_command(
     lines: &mut ScriptLineProvider,
@@ -1146,7 +1185,7 @@ fn compile_block_command(
     context: &mut ProcessingContext,
 ) -> UResult<CommandHandling> {
     line.advance(); // move past '{'
-    context.parsed_block_nesting += 1;
+    context.open_blocks.push(cmd.location.clone());
     let block_body = compile_sequence(lines, line, context)?;
     cmd.data = CommandData::BranchTarget(block_body);
     Ok(CommandHandling::Continue)
@@ -1632,6 +1671,14 @@ fn get_cmd_spec(
             n_addr: 2,
             handler: compile_execute_command,
         }),
+        'F' if !posix => Ok(CommandSpec {
+            n_addr: 2,
+            handler: compile_empty_command,
+        }),
+        'R' if !posix => Ok(CommandSpec {
+            n_addr: 2,
+            handler: compile_read_line_command,
+        }),
         'r' => Ok(CommandSpec {
             n_addr: if posix { 1 } else { 2 },
             handler: compile_read_file_command,
@@ -1644,6 +1691,10 @@ fn get_cmd_spec(
             n_addr: 2,
             handler: compile_label_command,
         }),
+        'W' if !posix => Ok(CommandSpec {
+            n_addr: 2,
+            handler: compile_write_file_command,
+        }),
         'w' => Ok(CommandSpec {
             n_addr: 2,
             handler: compile_write_file_command,
@@ -3013,6 +3064,31 @@ mod tests {
         assert!(err.to_string().contains(ERR_SANDBOX));
     }
 
+    // compile_read_line_command (R)
+    #[test]
+    fn test_compile_read_line_command_rejected_under_sandbox() {
+        let (mut lines, mut chars) = make_providers("R input.txt");
+        let mut cmd = Command::default();
+        let mut context = ctx();
+        context.sandbox = true;
+
+        let err =
+            compile_read_line_command(&mut lines, &mut chars, &mut cmd, &mut context).unwrap_err();
+        assert!(err.to_string().contains(ERR_SANDBOX));
+    }
+
+    #[test]
+    fn test_compile_read_line_command_sets_named_reader() {
+        let (mut lines, mut chars) = make_providers("R input.txt");
+        let mut cmd = Command::default();
+        let mut context = ctx();
+
+        let handling =
+            compile_read_line_command(&mut lines, &mut chars, &mut cmd, &mut context).unwrap();
+        assert!(matches!(handling, CommandHandling::Continue));
+        assert!(matches!(cmd.data, CommandData::NamedReader(_)));
+    }
+
     // compile_write_file_command
     #[test]
     fn test_compile_write_file_command_rejected_under_sandbox() {

src/sed/error_handling.rs

@@ -12,8 +12,14 @@ use crate::sed::command::ProcessingContext;
 use crate::sed::script_char_provider::ScriptCharProvider;
 use crate::sed::script_line_provider::ScriptLineProvider;
 
+use std::env;
+use std::io::{IsTerminal, stderr};
 use std::rc::Rc;
+use std::sync::OnceLock;
 
+use unicode_width::UnicodeWidthChar;
+use uucore::diagnostics;
+use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError};
 
 #[derive(Clone, Debug)]
@@ -22,6 +28,9 @@ pub struct ScriptLocation {
     pub input_name: Rc<str>,  // Shared input name
     pub line_number: usize,   // 1-based line number
     pub column_number: usize, // 1-based column number
+    /// The script line, for errors raised after it was consumed.
+    /// `None` when diagnostics are off.
+    pub line_text: Option<Rc<str>>,
 }
 
 impl Default for ScriptLocation {
@@ -30,6 +39,7 @@ impl Default for ScriptLocation {
             input_name: Rc::from("<unknown>"),
             line_number: 1,
             column_number: 1,
+            line_text: None,
         }
     }
 }
@@ -41,10 +51,123 @@ impl ScriptLocation {
             line_number: lines.get_line_number(),
             column_number: line.get_pos() + 1,
             input_name: Rc::from(lines.get_input_name()),
+            line_text: if diagnostics_enabled() {
+                line.line_text()
+            } else {
+                None
+            },
         }
     }
 }
 
+/// Whether script errors get a snippet. Evaluated once: a location is
+/// recorded for every compiled command, and the terminal check is a syscall.
+fn diagnostics_enabled() -> bool {
+    static ENABLED: OnceLock<bool> = OnceLock::new();
+    *ENABLED.get_or_init(diagnostics::enabled)
+}
+
+/// Format `msg` as an error at the given script position, followed by the
+/// offending script line, underlined, when diagnostics are enabled.
+fn script_error(
+    input_name: &str,
+    line_number: usize,
+    column_number: usize,
+    line_text: Option<&str>,
+    msg: impl ToString,
+) -> String {
+    let message = format!(
+        "{input_name}:{line_number}:{column_number}: error: {}",
+        msg.to_string()
+    );
+    // Line 0: the script was exhausted, so there is no line to show.
+    if !diagnostics_enabled() || line_number == 0 {
+        return message;
+    }
+    // A script line that is not valid UTF-8 cannot be drawn.
+    let Some(text) = line_text.filter(|text| !text.is_empty()) else {
+        return message;
+    };
+
+    // `column_number` is a 1-based byte column; errors at end of line point
+    // one past the last character.
+    let Some(prefix) = text.get(..(column_number - 1).min(text.len())) else {
+        return message;
+    };
+    let drawn = render_snippet(
+        input_name,
+        line_number,
+        column_number,
+        text,
+        prefix,
+        use_color(),
+    );
+    format!("{message}\n{drawn}")
+}
+
+/// Whether the underline is colored. uucore's diagnostics make the same
+/// check but keep it private.
+fn use_color() -> bool {
+    env::var_os("NO_COLOR").is_none() && stderr().is_terminal()
+}
+
+/// Draw `text` as line `line_number` of `input_name`, underlining the
+/// character that follows `prefix`, in the layout uucore's diagnostics use:
+///
+/// ```text
+///    ╭─[ <script argument 1>:1:7 ]
+///    │
+///  1 │ s/a/b/q
+///    │       ─
+/// ───╯
+/// ```
+fn render_snippet(
+    input_name: &str,
+    line_number: usize,
+    column_number: usize,
+    text: &str,
+    prefix: &str,
+    color: bool,
+) -> String {
+    let number = line_number.to_string();
+    let margin = " ".repeat(number.len() + 2);
+    // Pad by display width so the underline lines up with the character
+    // above it; tabs are kept as they are, since their width depends on the
+    // terminal.
+    let indent: String = prefix
+        .chars()
+        .flat_map(|c| {
+            let (fill, width) = if c == '\t' {
+                ('\t', 1)
+            } else {
+                (' ', c.width().unwrap_or(0))
+            };
+            std::iter::repeat_n(fill, width)
+        })
+        .collect();
+    // As wide as the offending character; one column past the end of line.
+    let width = text[prefix.len()..]
+        .chars()
+        .next()
+        .and_then(UnicodeWidthChar::width)
+        .unwrap_or(1)
+        .max(1);
+    let underline = "─".repeat(width);
+    let underline = if color {
+        format!("\x1b[31m{underline}\x1b[0m")
+    } else {
+        underline
+    };
+    format!(
+        "{margin}╭─[ {input_name}:{line_number}:{column_number} ]\n\
+         {margin}│\n\
+         \x20{number} │ {text}\n\
+         {margin}│ {indent}{underline}\n\
+         {rule}╯",
+        rule = "─".repeat(margin.len()),
+    )
+}
+
 /// Fail with msg as a compile error at the provider location.
 /// The error's exit code is 1 (compilation phase).
 pub fn compilation_error<T>(
@@ -54,12 +177,12 @@ pub fn compilation_error<T>(
 ) -> UResult<T> {
     Err(USimpleError::new(
         1,
-        format!(
-            "{}:{}:{}: error: {}",
+        script_error(
             lines.get_input_name(),
             lines.get_line_number(),
             line.get_pos() + 1,
-            msg.to_string()
+            str::from_utf8(line.get_line()).ok(),
+            msg,
         ),
     ))
 }
@@ -69,12 +192,12 @@ pub fn compilation_error<T>(
 fn location_error<T>(location: &ScriptLocation, msg: impl ToString, exit_code: i32) -> UResult<T> {
     Err(USimpleError::new(
         exit_code,
-        format!(
-            "{}:{}:{}: error: {}",
-            location.input_name,
+        script_error(
+            &location.input_name,
             location.line_number,
             location.column_number,
-            msg.to_string()
+            location.line_text.as_deref(),
+            msg,
         ),
     ))
 }
@@ -108,9 +231,31 @@ pub fn input_runtime_error<T>(
             location.input_name,
             location.line_number,
             location.column_number,
-            context.input_name,
+            context.input_name.quote(),
             context.line_number,
             msg.to_string()
         ),
     ))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // The integration tests check the layout; they cannot get color, as
+    // their stderr is not a terminal.
+    #[test]
+    fn the_underline_is_red_when_colored() {
+        let drawn = render_snippet("f.sed", 1, 7, "s/a/b/q", "s/a/b/", true);
+        assert_eq!(
+            drawn,
+            concat!(
+                "   ╭─[ f.sed:1:7 ]\n",
+                "   │\n",
+                " 1 │ s/a/b/q\n",
+                "   │       \x1b[31m─\x1b[0m\n",
+                "───╯",
+            )
+        );
+    }
+}

src/sed/fast_io.rs

@@ -678,13 +678,20 @@ impl OutputBuffer {
         )))
     }
 
-    /// Copy the specified file to the output.
-    pub fn copy_file(&mut self, path: &PathBuf) -> io::Result<()> {
-        // Flush mmap writes, if any.
+    /// Schedule the specified text for output unchanged, after any
+    /// deferred newline.
+    pub fn write_raw(&mut self, bytes: &[u8]) -> io::Result<()> {
+        self.flush_pending_newline()?;
         #[cfg(unix)]
-        {
-            self.flush_mmap(WriteRange::Complete)?;
-        }
+        self.flush_mmap(WriteRange::Complete)?;
+        self.out.write_all(bytes)
+    }
+
+    /// Copy the specified file to the output, after any deferred newline.
+    pub fn copy_file(&mut self, path: &PathBuf) -> io::Result<()> {
+        // As in GNU sed, write the deferred newline even when the file is
+        // empty or cannot be read.
+        self.write_raw(b"")?;
 
         let Ok(file) = File::open(path) else {
             // Per POSIX, if the file can't be read treat it as empty.

src/sed/mod.rs

@@ -15,6 +15,7 @@ pub mod error_handling;
 pub mod fast_io;
 pub mod fast_regex;
 pub mod in_place;
+pub mod named_reader;
 pub mod named_writer;
 pub mod processor;
 pub mod script_char_provider;
@@ -27,6 +28,7 @@ use crate::sed::script_line_provider::ScriptValue;
 use clap::{Arg, ArgMatches, Command, arg};
 use std::collections::HashMap;
 use std::env;
+use std::ffi::OsString;
 use std::path::PathBuf;
 use uucore::error::{UResult, USimpleError, UUsageError};
 use uucore::format_usage;
@@ -37,7 +39,7 @@ const VERSION: &str = concat!(env!("CARGO_PKG_VERSION"), " (uutils)");
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let matches = uu_app().try_get_matches_from(args)?;
+    let matches = parse_args(args)?;
 
     // Don't use arg_required_else_help when declaring command
     // as it exits with code 2 and we use it to check
@@ -55,6 +57,120 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     Ok(())
 }
 
+fn parse_args(args: impl IntoIterator<Item = OsString>) -> clap::error::Result<ArgMatches> {
+    let mut cmd = uu_app();
+    cmd.build();
+    let args = gnu_in_place_args(&cmd, args);
+    cmd.try_get_matches_from(args)
+}
+
+/// Rewrite GNU's `-iSUFFIX`, which clap cannot parse, as `--in-place=SUFFIX`,
+/// splitting it from flags clustered before it: `-ni.bak` becomes
+/// `-n --in-place=.bak`. The values of other options are left as they are.
+fn gnu_in_place_args(cmd: &Command, args: impl IntoIterator<Item = OsString>) -> Vec<OsString> {
+    let mut args = args.into_iter();
+    // The program name.
+    let mut out: Vec<OsString> = args.next().into_iter().collect();
+    while let Some(arg) = args.next() {
+        // Pass non-UTF-8 arguments to clap unchanged.
+        let arg = match arg.into_string() {
+            Ok(arg) => arg,
+            Err(arg) => {
+                out.push(arg);
+                continue;
+            }
+        };
+        if arg == "--" {
+            out.push(arg.into());
+            break;
+        }
+        match option_kind(cmd, &arg) {
+            OptionKind::InPlace(pos) => {
+                if pos > 1 {
+                    out.push(arg[..pos].into());
+                }
+                out.push(format!("--in-place={}", &arg[pos + 1..]).into());
+            }
+            OptionKind::ValueFollows => {
+                out.push(arg.into());
+                // Keep the value as is, even if it looks like `-iSUFFIX`.
+                out.extend(args.next());
+            }
+            OptionKind::Other => out.push(arg.into()),
+        }
+    }
+    out.extend(args);
+    out
+}
+
+enum OptionKind {
+    /// A cluster like `-ni.bak`, with the position of its `i`.
+    InPlace(usize),
+    /// An option whose value is the next argument, like `-f FILE`.
+    ValueFollows,
+    Other,
+}
+
+fn option_kind(cmd: &Command, arg: &str) -> OptionKind {
+    if let Some(name) = arg.strip_prefix("--") {
+        return match long_option(cmd, name) {
+            Some(opt) if opt.get_action().takes_values() && !opt.is_require_equals_set() => {
+                OptionKind::ValueFollows
+            }
+            _ => OptionKind::Other,
+        };
+    }
+    let Some(cluster) = arg.strip_prefix('-') else {
+        return OptionKind::Other;
+    };
+    for (pos, c) in cluster.char_indices() {
+        // Leave unknown options for clap to report.
+        let Some(opt) = cmd.get_arguments().find(|a| {
+            a.get_short() == Some(c) || a.get_all_short_aliases().is_some_and(|s| s.contains(&c))
+        }) else {
+            return OptionKind::Other;
+        };
+        let attached = pos + c.len_utf8() < cluster.len();
+        if opt.get_id() == "in-place" {
+            return if attached {
+                OptionKind::InPlace(pos + 1)
+            } else {
+                OptionKind::Other
+            };
+        }
+        if opt.get_action().takes_values() {
+            // The rest of the cluster, or else the next argument, is the value.
+            return if attached {
+                OptionKind::Other
+            } else {
+                OptionKind::ValueFollows
+            };
+        }
+    }
+    OptionKind::Other
+}
+
+/// Find a long option by its name or, as `infer_long_args` allows, a unique
+/// prefix of it. `None` if `name` includes a value.
+fn long_option<'a>(cmd: &'a Command, name: &str) -> Option<&'a Arg> {
+    if name.contains('=') {
+        return None;
+    }
+    let names = |a: &'a Arg| {
+        a.get_long()
+            .into_iter()
+            .chain(a.get_all_aliases().into_iter().flatten())
+    };
+    if let Some(opt) = cmd.get_arguments().find(|a| names(a).any(|n| n == name)) {
+        return Some(opt);
+    }
+    let mut found = cmd
+        .get_arguments()
+        .filter(|a| names(a).any(|n| n.starts_with(name)));
+    let opt = found.next()?;
+    found.next().is_none().then_some(opt)
+}
+
 #[allow(clippy::cognitive_complexity)]
 pub fn uu_app() -> Command {
     #[cfg(windows)]
@@ -86,7 +202,9 @@ pub fn uu_app() -> Command {
                 .short_alias('r')
                 .help("Use extended regular expressions.")
                 .action(clap::ArgAction::SetTrue),
+            // As in GNU sed, a value may begin with `-`.
             arg!(-e --expression <SCRIPT> "Add script to executed commands.")
+                .allow_hyphen_values(true)
                 .action(clap::ArgAction::Append),
             // Access with .get_many::<PathBuf>("file")
             Arg::new("script-file")
@@ -94,26 +212,36 @@ pub fn uu_app() -> Command {
                 .long("script-file")
                 .help("Specify script file.")
                 .value_parser(clap::value_parser!(PathBuf))
+                .allow_hyphen_values(true)
                 .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")
+            // The SUFFIX must be attached, as in GNU sed.
             Arg::new("in-place")
                 .short('i')
                 .long("in-place")
                 .help("Edit files in place, making a backup if SUFFIX is supplied.")
+                .value_name("SUFFIX")
                 .num_args(0..=1)
+                .require_equals(true)
                 .default_missing_value(""),
             // Access with .get_one::<u32>("line-length")
             arg!(-l --length <NUM> "Specify the 'l' command line-wrap length.")
+                .allow_hyphen_values(true)
                 .value_parser(clap::value_parser!(u32)),
             arg!(-n --quiet "Suppress automatic printing of pattern space.").aliases(["silent"]),
             arg!(--posix "Disable non-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("uutil-extensions")
+                .short('U')
+                .long("uutil-extensions")
+                .help("Enable incompatible extensions.")
+                .action(clap::ArgAction::SetTrue),
             Arg::new("null-data")
                 .short('z')
                 .long("null-data")
@@ -239,29 +367,32 @@ fn build_context(matches: &ArgMatches) -> UResult<ProcessingContext> {
         length: matches.get_one::<u32>("length").map_or(70, |v| *v as usize),
         quiet: matches.get_flag("quiet"),
         posix: matches.get_flag("posix"),
-        separate: matches.get_flag("separate"),
+        separate: matches.get_flag("separate") || matches.contains_id("in-place"),
         sandbox: matches.get_flag("sandbox"),
         unbuffered: matches.get_flag("unbuffered"),
         null_data: matches.get_flag("null-data"),
+        uutil_extensions: matches.get_flag("uutil-extensions"),
 
         // Environment
         character_mode: character_mode_for_locale(&locale)?,
 
         // Other context
-        input_name: "<stdin>".to_string(),
+        input_name: PathBuf::from("-"),
         line_number: 0,
         last_address: false,
         last_line: false,
         last_file: false,
         stop_processing: false,
+        quit_silently: false,
         saved_regex: None,
         input_action: None,
         hold: ByteSpace {
             content: Vec::new(),
             has_newline: true,
         },
-        parsed_block_nesting: 0,
+        open_blocks: Vec::new(),
         label_to_command_map: HashMap::new(),
+        named_readers: HashMap::new(),
         range_commands: Vec::new(),
         substitution_made: false,
         append_elements: Vec::new(),
@@ -389,6 +520,7 @@ mod tests {
         assert!(!ctx.sandbox);
         assert!(!ctx.unbuffered);
         assert!(!ctx.null_data);
+        assert!(!ctx.uutil_extensions);
     }
 
     #[test]
@@ -406,6 +538,7 @@ mod tests {
             "-s",
             "--sandbox",
             "-u",
+            "-U",
             "-z",
         ]);
 
@@ -424,6 +557,7 @@ mod tests {
         assert!(ctx.sandbox);
         assert!(ctx.unbuffered);
         assert!(ctx.null_data);
+        assert!(ctx.uutil_extensions);
     }
 
     #[test]
@@ -434,13 +568,76 @@ mod tests {
         assert!(ctx.regex_extended);
     }
 
-    #[test]
-    fn test_in_place_with_suffix() {
-        let matches = test_matches(&["-i", ".bak"]);
-        let ctx = build_context(&matches).unwrap();
+    // In-place argument rewriting
+    fn in_place_args(args: &[&str]) -> Vec<String> {
+        let mut cmd = uu_app();
+        cmd.build();
+        gnu_in_place_args(&cmd, ["sed"].iter().chain(args).map(OsString::from))
+            .into_iter()
+            .skip(1)
+            .map(|arg| arg.into_string().unwrap())
+            .collect()
+    }
 
-        assert!(ctx.in_place);
-        assert_eq!(ctx.in_place_suffix, Some(".bak".to_string()));
+    #[test]
+    fn test_in_place_args_rewrite_attached_suffix() {
+        let cases: &[(&[&str], &[&str])] = &[
+            (&["-i.bak"], &["--in-place=.bak"]),
+            // Everything after the `i` is the suffix, as in GNU sed.
+            (&["-iE"], &["--in-place=E"]),
+            (&["-i=.bak"], &["--in-place==.bak"]),
+            // Flags clustered before `-i` are kept.
+            (&["-ni.bak"], &["-n", "--in-place=.bak"]),
+            (&["-Esi.bak"], &["-Es", "--in-place=.bak"]),
+            (&["-ri.bak"], &["-r", "--in-place=.bak"]),
+            (
+                &["-i.bak", "--", "-i.keep"],
+                &["--in-place=.bak", "--", "-i.keep"],
+            ),
+            // Only the next argument is another option's value.
+            (&["-e", "p", "-i.bak"], &["-e", "p", "--in-place=.bak"]),
+            (
+                &["--expression=p", "-i.bak"],
+                &["--expression=p", "--in-place=.bak"],
+            ),
+            (&["--quiet", "-i.bak"], &["--quiet", "--in-place=.bak"]),
+            (
+                &["--in-place", "-i.bak"],
+                &["--in-place", "--in-place=.bak"],
+            ),
+            // A `--` that is an option's value does not end the options.
+            (&["-e", "--", "-i.bak"], &["-e", "--", "--in-place=.bak"]),
+        ];
+        for (args, expected) in cases {
+            assert_eq!(in_place_args(args), *expected, "args: {args:?}");
+        }
+    }
+
+    #[test]
+    fn test_in_place_args_leave_other_arguments_alone() {
+        let cases: &[&[&str]] = &[
+            &["-i", "s/a/b/", "file"],
+            &["-Ei", "s/a/b/", "file"],
+            &["-En", "s/a/b/", "file"],
+            &["--in-place=.bak", "s/a/b/", "file"],
+            &["--in=.bak", "s/a/b/", "file"],
+            // Values attached to other options.
+            &["-fi.sed", "file"],
+            &["-nfi.sed", "file"],
+            &["-ei", "file"],
+            // Values that follow other options.
+            &["-f", "-ifoo.sed", "file"],
+            &["-nf", "-ifoo.sed", "file"],
+            &["-l", "-i5"],
+            &["--expression", "-i.bak"],
+            &["--expr", "-i.bak"],
+            // Unknown options are left for clap to report.
+            &["-xi.bak"],
+            &["--", "-i.bak"],
+        ];
+        for args in cases {
+            assert_eq!(in_place_args(args), *args, "args: {args:?}");
+        }
     }
 
     #[test]