Add support for GNU ~step address ranges

Author: dspinellis

README.md

@@ -85,6 +85,8 @@ cargo test
 * The `--follow-symlinks` flag for in-place editing.
 * 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.
 
 ### Supported BSD and GNU extensions
 * The second address in a range can be specified as a relative address with +N.

src/sed/command.rs

@@ -93,6 +93,8 @@ pub enum Address {
     Line(usize),       // Specific line
     RelLine(usize),    // Relative line
     Last,              // Last line
+    StepMatch(usize),  // Lines matching specified step from first
+    StepEnd(usize),    // Range ending at specified step from first
 }
 
 #[derive(Debug)]

src/sed/compiler.rs

@@ -339,27 +339,66 @@ fn compile_address_range(
         cmd.addr1 = Some(addr1);
         if is_line0 && context.posix {
             // 0 starting address is a GNU extension.
-            return compilation_error(lines, line, "address 0 invalid in POSIX mode");
+            return compilation_error(lines, line, "address 0 is invalid in POSIX mode");
         }
         n_addr += 1;
     }
 
     line.eat_spaces();
-    if n_addr == 1 && !line.eol() && line.current() == ',' {
+    if n_addr == 1 && !line.eol() && matches!(line.current(), ',' | '~') {
+        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() == '~' {
+            // E.g. /foo/,~10: Start at foo, include all lines until multiple of 10 is reached.
+            line.advance();
+            line.eat_spaces();
+            true
+        } else {
+            false
+        };
+
+        if (is_step_match || is_step_end) && context.posix {
+            // ~ steps are a GNU extension.
+            return compilation_error(lines, line, "~step is invalid in POSIX mode");
+        }
+
+        // Look for second address.
         if !line.eol()
             && let Ok(addr2) = compile_address(lines, line, context)
         {
-            let addr2_is_re = matches!(addr2, Address::Re(_));
-            cmd.addr2 = Some(addr2);
-            if is_line0 && !addr2_is_re {
+            // 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 on numeric addresses",
+                        );
+                    }
+                }
+            } else {
+                0 // dummy, not used
+            };
+
+            if is_line0 && !matches!(addr2, Address::Re(_)) && !is_step_match {
                 return compilation_error(
                     lines,
                     line,
-                    "address 0 can only be used with a regular expression second address",
+                    "address 0 can only be used with a regular expression or ~step",
                 );
             }
+
+            // 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;
         }
     }
@@ -390,6 +429,8 @@ fn read_file_path(lines: &ScriptLineProvider, line: &mut ScriptCharProvider) ->
 }
 
 /// Compile and return a single range address specification.
+// Due to their irregular syntax ~ addresses are returned as Line() and adjusted
+// in compile_address_range().
 fn compile_address(
     lines: &ScriptLineProvider,
     line: &mut ScriptCharProvider,
@@ -1625,6 +1666,28 @@ mod tests {
         assert!(matches!(cmd.borrow().addr2, Some(Address::RelLine(3))));
     }
 
+    #[test]
+    fn test_compile_step_match_address() {
+        let (lines, mut chars) = make_providers("0~2");
+        let mut cmd = Rc::new(RefCell::new(Command::default()));
+        let n_addr = compile_address_range(&lines, &mut chars, &mut cmd, &ctx()).unwrap();
+
+        assert_eq!(n_addr, 2);
+        assert!(matches!(cmd.borrow().addr1, Some(Address::Line(0))));
+        assert!(matches!(cmd.borrow().addr2, Some(Address::StepMatch(2))));
+    }
+
+    #[test]
+    fn test_compile_step_end_address() {
+        let (lines, mut chars) = make_providers("1,~10");
+        let mut cmd = Rc::new(RefCell::new(Command::default()));
+        let n_addr = compile_address_range(&lines, &mut chars, &mut cmd, &ctx()).unwrap();
+
+        assert_eq!(n_addr, 2);
+        assert!(matches!(cmd.borrow().addr1, Some(Address::Line(1))));
+        assert!(matches!(cmd.borrow().addr2, Some(Address::StepEnd(10))));
+    }
+
     #[test]
     fn test_compile_last_address() {
         let (lines, mut chars) = make_providers("$");

src/sed/processor.rs

@@ -86,11 +86,11 @@ fn applies(
             // Range is already latched active.
             match addr2 {
                 Address::RelLine(n) => {
-                    if linenum - start <= *n {
-                        Ok(true)
-                    } else {
+                    if linenum - start > *n {
                         command.start_line = None;
                         Ok(false)
+                    } else {
+                        Ok(true)
                     }
                 }
                 Address::Line(n) => {
@@ -102,14 +102,20 @@ fn applies(
                         Ok(true)
                     }
                 }
+                Address::StepMatch(step) => Ok((linenum - start).is_multiple_of(*step)),
+                Address::StepEnd(step) => {
+                    // Inclusive end on multiple of step
+                    if linenum.is_multiple_of(*step) {
+                        command.start_line = None;
+                    }
+                    Ok(true)
+                }
                 _ => {
                     if match_address(addr2, reader, pattern, context, &command.location)? {
                         command.start_line = None;
                         context.last_address = true;
-                        Ok(true)
-                    } else {
-                        Ok(true)
                     }
+                    Ok(true)
                 }
             }
         } else if let Some(addr1) = &command.addr1 {

tests/by-util/test_sed.rs

@@ -269,6 +269,10 @@ check_output!(
 );
 check_output!(addr_empty_re_reuse, ["-n", "/_2/,//p", LINES1, LINES2]);
 check_output!(addr_simple_negation, ["-e", r"4,12!s/^/^/", LINES1]);
+check_output!(addr_range_even, ["-n", "0~2p", LINES1]);
+check_output!(addr_range_odd, ["-n", "1~2p", LINES1]);
+check_output!(addr_range_step_zero, ["-n", "10~0p", LINES1]);
+check_output!(addr_range_end_multiple, ["-n", "/l1_2/,~10p", LINES1]);
 
 ////////////////////////////////////////////////////////////
 // Substitution: s
@@ -1068,7 +1072,7 @@ fn test_addr0_non_posix() {
         .args(&["--posix", "0,/foo/p"])
         .fails()
         .code_is(1)
-        .stderr_is("sed: <script argument 1>:1:2: error: address 0 invalid in POSIX mode\n");
+        .stderr_is("sed: <script argument 1>:1:2: error: address 0 is invalid in POSIX mode\n");
 }
 
 #[test]
@@ -1086,7 +1090,25 @@ fn test_addr0_second_re_only() {
         .args(&["0,4p"])
         .fails()
         .code_is(1)
-        .stderr_is("sed: <script argument 1>:1:4: error: address 0 can only be used with a regular expression second address\n");
+        .stderr_is("sed: <script argument 1>:1:4: error: address 0 can only be used with a regular expression or ~step\n");
+}
+
+#[test]
+fn test_step_match_non_posix() {
+    new_ucmd!()
+        .args(&["--posix", "3~2p"])
+        .fails()
+        .code_is(1)
+        .stderr_is("sed: <script argument 1>:1:3: error: ~step is invalid in POSIX mode\n");
+}
+
+#[test]
+fn test_step_end_non_posix() {
+    new_ucmd!()
+        .args(&["--posix", "3,~2p"])
+        .fails()
+        .code_is(1)
+        .stderr_is("sed: <script argument 1>:1:4: error: ~step is invalid in POSIX mode\n");
 }
 
 // The following test diverse ways in which regexes are matched.

tests/fixtures/sed/output/addr_range_end_multiple

@@ -0,0 +1,9 @@
+l1_2
+l1_3
+l1_4
+l1_5
+l1_6
+l1_7
+l1_8
+l1_9
+l1_10

tests/fixtures/sed/output/addr_range_even

@@ -0,0 +1,7 @@
+l1_2
+l1_4
+l1_6
+l1_8
+l1_10
+l1_12
+l1_14

tests/fixtures/sed/output/addr_range_odd

@@ -0,0 +1,7 @@
+l1_1
+l1_3
+l1_5
+l1_7
+l1_9
+l1_11
+l1_13

tests/fixtures/sed/output/addr_range_step_zero

@@ -0,0 +1 @@
+l1_10