sed: underline the offending script character at a terminal

When stderr is a terminal (or UUTILS_DIAG=always), quote the offending
script line and underline the faulty character, in the layout uucore's
diagnostics use. Pipes and the test suite still get the single-line
message.

Both error constructors handle this, so no call site changes.
ScriptLocation now carries the line text, captured only when diagnostics
are on and shared between commands from the same line, so semantic
errors raised after compilation can still be drawn.

Anything that cannot be drawn (non-UTF-8 script, empty line, no line
recorded) leaves the message unchanged.

.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@v25
       continue-on-error: true
       with:
         workflow: GnuTests.yml

.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 chrono 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"]
 
@@ -45,11 +59,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,6 +82,7 @@ regex = { workspace = true }
 tempfile = { workspace = true }
 terminal_size = { workspace = true }
 textwrap = { workspace = true }
+unicode-width = { workspace = true }
 uucore = { workspace = true }
 rustix = { workspace = true }
 
@@ -83,7 +99,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 +133,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,84 @@
+# 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.
+
+## 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.lock

@@ -245,9 +245,9 @@ checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
 
 [[package]]
 name = "console"
-version = "0.16.4"
+version = "0.16.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fe5f465a4f6fee88fad41b85d990f84c835335e85b5d9e6e63e0d06d28cba7c"
+checksum = "e96a4956774c13c126a8b5af4daa79384f4d826534c95a02d76afb39e2ab64e3"
 dependencies = [
  "encode_unicode",
  "libc",
@@ -820,9 +820,9 @@ checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 
 [[package]]
 name = "rand"
-version = "0.10.2"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80"
+checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af"
 dependencies = [
  "chacha20",
  "getrandom 0.4.2",
@@ -897,7 +897,7 @@ checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 
 [[package]]
 name = "sed"
-version = "0.1.1"
+version = "0.3.0"
 dependencies = [
  "clap",
  "clap_complete",
@@ -985,9 +985,9 @@ checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
 
 [[package]]
 name = "similar"
-version = "3.1.2"
+version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85ee016af5d736b69fc89e19254540fa4b5f5492853fb5503920f084011c78b6"
+checksum = "4f66ca1f7aca2474dc10c942eb22feffc897735f54cd1db90138c2fddb490987"
 dependencies = [
  "bstr",
 ]
@@ -1034,7 +1034,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
  "fastrand",
- "getrandom 0.4.2",
+ "getrandom 0.3.4",
  "once_cell",
  "rustix",
  "windows-sys",
@@ -1152,9 +1152,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uucore"
-version = "0.10.0"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e97dd0fd8bb2ed12affba9f956c3b94b8ad3f9432746717475420e916ae0b8d4"
+checksum = "f24a5910ebbf2c0baf486a9125705f8e026a8f7741a3ea8cf5eca3c9257c9bdf"
 dependencies = [
  "bigdecimal",
  "clap",
@@ -1167,7 +1167,6 @@ dependencies = [
  "os_display",
  "procfs",
  "rustc-hash",
- "rustix",
  "thiserror",
  "unic-langid",
  "unicode-width",
@@ -1192,9 +1191,9 @@ dependencies = [
 
 [[package]]
 name = "uucore_procs"
-version = "0.10.0"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "907f1b828046ea42cdb4bd898f05b48ab873a41937bf75ebe12f09a5bf411f58"
+checksum = "50aa1f3bba55168888ae6f1f2714ce58897d8020d742d21f474f01e86468fedd"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1202,9 +1201,9 @@ dependencies = [
 
 [[package]]
 name = "uufuzz"
-version = "0.10.0"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72d4c5bac0f8ccabaa8e8ccbf2724446f8b007c06ad343fabfe1a1525a4ff4f2"
+checksum = "7147da7bd2de08e6647116e005b0992cc602e34c34972793844a45c4e8648dd9"
 dependencies = [
  "console",
  "rand",

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
@@ -66,6 +68,9 @@ pub struct ProcessingContext {
     pub parsed_block_nesting: usize,
     /// 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
@@ -367,6 +372,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'

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};
@@ -358,7 +359,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 +373,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 +503,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"),
     }
 }
 
@@ -1122,6 +1130,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,
@@ -1632,6 +1662,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 +1682,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 +3055,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/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;
@@ -114,6 +115,11 @@ pub fn uu_app() -> Command {
             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,16 +245,17 @@ 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,
@@ -262,6 +269,7 @@ fn build_context(matches: &ArgMatches) -> UResult<ProcessingContext> {
         },
         parsed_block_nesting: 0,
         label_to_command_map: HashMap::new(),
+        named_readers: HashMap::new(),
         range_commands: Vec::new(),
         substitution_made: false,
         append_elements: Vec::new(),
@@ -389,6 +397,7 @@ mod tests {
         assert!(!ctx.sandbox);
         assert!(!ctx.unbuffered);
         assert!(!ctx.null_data);
+        assert!(!ctx.uutil_extensions);
     }
 
     #[test]
@@ -406,6 +415,7 @@ mod tests {
             "-s",
             "--sandbox",
             "-u",
+            "-U",
             "-z",
         ]);
 
@@ -424,6 +434,7 @@ mod tests {
         assert!(ctx.sandbox);
         assert!(ctx.unbuffered);
         assert!(ctx.null_data);
+        assert!(ctx.uutil_extensions);
     }
 
     #[test]

src/sed/named_reader.rs

@@ -0,0 +1,101 @@
+// An abstraction for input files read one line at a time by the `R` command
+//
+// 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::cell::RefCell;
+use std::fs::File;
+use std::io::{BufRead, BufReader};
+use std::path::PathBuf;
+use std::rc::Rc;
+
+#[derive(Debug)]
+/// State of the file backing an `R` command, opened lazily on first use.
+enum State {
+    Unopened,
+    Open(BufReader<File>),
+    Exhausted,
+}
+
+#[derive(Debug)]
+/// Reader that yields successive lines of a file for the GNU `R` command.
+/// The file is opened on first use; a file that cannot be opened or read is
+/// treated as having no more lines, matching GNU sed (no error is raised).
+pub struct NamedReader {
+    path: PathBuf,
+    state: State,
+}
+
+impl NamedReader {
+    /// Create a reader for `path` without opening it yet.
+    pub fn new(path: PathBuf) -> Rc<RefCell<Self>> {
+        Rc::new(RefCell::new(NamedReader {
+            path,
+            state: State::Unopened,
+        }))
+    }
+
+    /// Return the next line of the file, including its trailing newline if
+    /// present, or `None` once the file is exhausted or could not be read.
+    pub fn next_line(&mut self) -> Option<Vec<u8>> {
+        if matches!(self.state, State::Unopened) {
+            self.state = match File::open(&self.path) {
+                Ok(file) => State::Open(BufReader::new(file)),
+                Err(_) => State::Exhausted,
+            };
+        }
+
+        let State::Open(reader) = &mut self.state else {
+            return None;
+        };
+
+        let mut line = Vec::new();
+        match reader.read_until(b'\n', &mut line) {
+            Ok(0) | Err(_) => {
+                self.state = State::Exhausted;
+                None
+            }
+            Ok(_) => Some(line),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write;
+    use tempfile::NamedTempFile;
+
+    #[test]
+    fn yields_successive_lines_then_none() {
+        let mut file = NamedTempFile::new().unwrap();
+        file.write_all(b"one\ntwo\n").unwrap();
+        let reader = NamedReader::new(file.path().to_path_buf());
+
+        assert_eq!(reader.borrow_mut().next_line(), Some(b"one\n".to_vec()));
+        assert_eq!(reader.borrow_mut().next_line(), Some(b"two\n".to_vec()));
+        assert_eq!(reader.borrow_mut().next_line(), None);
+        assert_eq!(reader.borrow_mut().next_line(), None);
+    }
+
+    #[test]
+    fn last_line_without_newline_is_preserved() {
+        let mut file = NamedTempFile::new().unwrap();
+        file.write_all(b"abc").unwrap();
+        let reader = NamedReader::new(file.path().to_path_buf());
+
+        assert_eq!(reader.borrow_mut().next_line(), Some(b"abc".to_vec()));
+        assert_eq!(reader.borrow_mut().next_line(), None);
+    }
+
+    #[test]
+    fn missing_file_yields_no_lines() {
+        let reader = NamedReader::new(PathBuf::from("/nonexistent/xyzzy-42-does-not-exist"));
+        assert_eq!(reader.borrow_mut().next_line(), None);
+    }
+}

src/sed/named_writer.rs

@@ -55,16 +55,22 @@ impl NamedWriter {
         Ok(writer)
     }
 
-    /// Write a line to the file with a newline, returning descriptive errors.
-    pub fn write_line(&mut self, line: &str) -> UResult<()> {
-        self.write_line_bytes(line.as_bytes())
+    /// Write String to the file, possibly with a newline, returning errors.
+    pub fn write_line(&mut self, line: &str, newline: bool) -> UResult<()> {
+        self.write_line_bytes(line.as_bytes(), newline)
     }
 
-    /// Write bytes to the file with a newline, returning descriptive errors.
-    pub fn write_line_bytes(&mut self, line: &[u8]) -> UResult<()> {
+    /// Write bytes to the file, possibly with a newline, returning errors.
+    pub fn write_line_bytes(&mut self, line: &[u8], newline: bool) -> UResult<()> {
         self.writer
             .write_all(line)
-            .and_then(|()| self.writer.write_all(b"\n"))
+            .and_then(|()| {
+                if newline {
+                    self.writer.write_all(b"\n")
+                } else {
+                    Ok(())
+                }
+            })
             .map_err(|e| {
                 runtime_error::<()>(
                     &self.location,
@@ -109,9 +115,27 @@ mod tests {
         let path = file.path().to_path_buf();
         let writer = NamedWriter::new(path.clone(), ScriptLocation::default()).unwrap();
 
-        writer.borrow_mut().write_line_bytes(b"a\xE9").unwrap();
+        writer
+            .borrow_mut()
+            .write_line_bytes(b"a\xE9", true)
+            .unwrap();
         writer.borrow_mut().flush().unwrap();
 
         assert_eq!(fs::read(path).unwrap(), b"a\xE9\n");
     }
+
+    #[test]
+    fn test_write_line_bytes_appends_no_newline() {
+        let file = NamedTempFile::new().unwrap();
+        let path = file.path().to_path_buf();
+        let writer = NamedWriter::new(path.clone(), ScriptLocation::default()).unwrap();
+
+        writer
+            .borrow_mut()
+            .write_line_bytes(b"a\xE9", false)
+            .unwrap();
+        writer.borrow_mut().flush().unwrap();
+
+        assert_eq!(fs::read(path).unwrap(), b"a\xE9");
+    }
 }