Set max addresses to 2 for a, i and = and make n_addr conditional, based on POSIX flag

- Update `get_cmd_spec()` and `get_verified_cmd_spec()` to accept a boolean POSIX param
- Add unit and high level tests
- Update README.md

Author: LoukasPap

README.md

@@ -86,6 +86,7 @@ cargo test
 * 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.

src/sed/compiler.rs

@@ -285,14 +285,14 @@ fn compile_sequence(
         let mut cmd = Rc::new(RefCell::new(Command::at_position(lines, line)));
         let n_addr = compile_address_range(lines, line, &mut cmd, context)?;
         line.eat_spaces();
-        let mut cmd_spec = get_verified_cmd_spec(lines, line, n_addr)?;
+        let mut cmd_spec = get_verified_cmd_spec(lines, line, n_addr, context.posix)?;
 
         // Compile the command according to its specification.
         let mut cmd_mut = cmd.borrow_mut();
         cmd_mut.code = line.current();
         match (cmd_spec.handler)(lines, line, &mut cmd_mut, context)? {
             CommandHandling::GetNext => {
-                cmd_spec = get_verified_cmd_spec(lines, line, n_addr)?;
+                cmd_spec = get_verified_cmd_spec(lines, line, n_addr, context.posix)?;
                 cmd_mut.code = line.current();
                 (cmd_spec.handler)(lines, line, &mut cmd_mut, context)?;
             }
@@ -1119,7 +1119,6 @@ fn compile_text_command(
     context: &mut ProcessingContext,
 ) -> UResult<CommandHandling> {
     line.advance(); // Skip the command character.
-
     line.eat_spaces(); // Skip any leading whitespace.
     if context.posix {
         compile_text_command_posix(lines, line, cmd, context)
@@ -1251,13 +1250,14 @@ fn get_verified_cmd_spec(
     lines: &ScriptLineProvider,
     line: &ScriptCharProvider,
     n_addr: usize,
+    posix: bool,
 ) -> UResult<CommandSpec> {
     if line.eol() {
         return compilation_error(lines, line, "command expected");
     }
 
     let ch = line.current();
-    let cmd_spec = get_cmd_spec(lines, line, ch)?;
+    let cmd_spec = get_cmd_spec(lines, line, ch, posix)?;
 
     if n_addr > cmd_spec.n_addr {
         return compilation_error(
@@ -1278,14 +1278,15 @@ fn get_cmd_spec(
     lines: &ScriptLineProvider,
     line: &ScriptCharProvider,
     cmd_code: char,
+    posix: bool,
 ) -> UResult<CommandSpec> {
     match cmd_code {
         '!' => Ok(CommandSpec {
             n_addr: 2,
             handler: compile_negation_command,
         }),
         '=' => Ok(CommandSpec {
-            n_addr: 1,
+            n_addr: if posix { 1 } else { 2 },
             handler: compile_empty_command,
         }),
         ':' => Ok(CommandSpec {
@@ -1301,7 +1302,7 @@ fn get_cmd_spec(
             handler: compile_end_group_command,
         }),
         'a' | 'i' => Ok(CommandSpec {
-            n_addr: 1,
+            n_addr: if posix { 1 } else { 2 },
             handler: compile_text_command,
         }),
         'b' | 't' => Ok(CommandSpec {
@@ -1320,13 +1321,17 @@ fn get_cmd_spec(
             n_addr: 2,
             handler: compile_number_command,
         }),
+        'q' => Ok(CommandSpec {
+            n_addr: if posix { 1 } else { 2 },
+            handler: compile_number_command,
+        }),
         // Q is a GNU extension
-        'q' | 'Q' => Ok(CommandSpec {
+        'Q' => Ok(CommandSpec {
             n_addr: 1,
             handler: compile_number_command,
         }),
         'r' => Ok(CommandSpec {
-            n_addr: 1,
+            n_addr: if posix { 1 } else { 2 },
             handler: compile_read_file_command,
         }),
         's' => Ok(CommandSpec {
@@ -1378,35 +1383,35 @@ mod tests {
     #[test]
     fn test_lookup_empty_command() {
         let (lines, line) = make_providers("123abc");
-        let cmd = get_cmd_spec(&lines, &line, 'd').unwrap();
+        let cmd = get_cmd_spec(&lines, &line, 'd', false).unwrap();
         assert_eq!(cmd.n_addr, 2);
     }
 
     #[test]
     fn test_lookup_text_command() {
         let (lines, line) = make_providers("123abc");
-        let cmd = get_cmd_spec(&lines, &line, 'a').unwrap();
-        assert_eq!(cmd.n_addr, 1);
+        let cmd = get_cmd_spec(&lines, &line, 'a', false).unwrap();
+        assert_eq!(cmd.n_addr, 2);
     }
 
     #[test]
     fn test_lookup_nonselect_command() {
         let (lines, line) = make_providers("123abc");
-        let cmd = get_cmd_spec(&lines, &line, '!').unwrap();
+        let cmd = get_cmd_spec(&lines, &line, '!', false).unwrap();
         assert_eq!(cmd.n_addr, 2);
     }
 
     #[test]
     fn test_lookup_endgroup_command() {
         let (lines, line) = make_providers("123abc");
-        let cmd = get_cmd_spec(&lines, &line, '}').unwrap();
+        let cmd = get_cmd_spec(&lines, &line, '}', false).unwrap();
         assert_eq!(cmd.n_addr, 0);
     }
 
     #[test]
     fn test_lookup_invalid_command() {
         let (lines, line) = make_providers("123abc");
-        let result = get_cmd_spec(&lines, &line, 'Z');
+        let result = get_cmd_spec(&lines, &line, 'Z', false);
         assert!(result.is_err());
     }
 
@@ -1458,7 +1463,7 @@ mod tests {
     fn test_missing_command_character() {
         let lines = ScriptLineProvider::with_active_state("test.sed", 1);
         let line = char_provider_from("");
-        let result = get_verified_cmd_spec(&lines, &line, 0);
+        let result = get_verified_cmd_spec(&lines, &line, 0, ctx().posix);
 
         assert!(result.is_err());
         let msg = result.unwrap_err().to_string();
@@ -1469,7 +1474,7 @@ mod tests {
     fn test_invalid_command_character() {
         let lines = ScriptLineProvider::with_active_state("script.sed", 2);
         let line = char_provider_from("@");
-        let result = get_verified_cmd_spec(&lines, &line, 0);
+        let result = get_verified_cmd_spec(&lines, &line, 0, ctx().posix);
 
         assert!(result.is_err());
         let msg = result.unwrap_err().to_string();
@@ -1480,7 +1485,7 @@ mod tests {
     fn test_too_many_addresses() {
         let lines = ScriptLineProvider::with_active_state("input.sed", 3);
         let line = char_provider_from("q"); // q takes one address
-        let result = get_verified_cmd_spec(&lines, &line, 2);
+        let result = get_verified_cmd_spec(&lines, &line, 2, true);
 
         assert!(result.is_err());
         let msg = result.unwrap_err().to_string();
@@ -1493,11 +1498,22 @@ mod tests {
     fn test_valid_command_spec() {
         let lines = ScriptLineProvider::with_active_state("input.sed", 4);
         let line = char_provider_from("a"); // valid command
-        let result = get_verified_cmd_spec(&lines, &line, 1);
-
+        let result = get_verified_cmd_spec(&lines, &line, 2, ctx().posix);
         assert!(result.is_ok());
         let spec = result.unwrap();
-        assert_eq!(spec.n_addr, 1);
+        assert_eq!(spec.n_addr, 2);
+    }
+
+    #[test]
+    fn test_invalid_address_range_posix() {
+        let lines = ScriptLineProvider::with_active_state("input.sed", 1);
+        let line = char_provider_from("i"); // valid command
+        let result = get_verified_cmd_spec(&lines, &line, 2, true);
+        assert!(result.is_err());
+        let msg = result.unwrap_err().to_string();
+        assert!(
+            msg.contains("input.sed:1:1: error: command i expects up to 1 address(es), found 2")
+        );
     }
 
     // parse_number

tests/by-util/test_sed.rs

@@ -594,6 +594,30 @@ tb"#,
 
 // Check both POSIX and GNU parsing routines.
 
+check_output!(
+    text_simple_insert,
+    [
+        "-e",
+        r#"
+2,4i\
+extra
+"#,
+        LINES1
+    ]
+);
+
+check_output!(
+    text_simple_append,
+    [
+        "-e",
+        r#"
+2,4a\
+extra
+"#,
+        LINES1
+    ]
+);
+
 check_output_posix!(
     text_insert_quit,
     [
@@ -785,6 +809,8 @@ fn write_two_files() -> std::io::Result<()> {
 // =, l commands
 check_output!(number_continuous, ["/l2_/=", LINES1, LINES2]);
 check_output!(number_separate, ["-s", "/l._8/=", LINES1, LINES2]);
+check_output!(number_range, ["-e", "10,12=", LINES1]);
+check_output!(number_range_out_of_bounds, ["-e", "47,60=", LINES1]);
 
 check_output!(list_ascii, ["-n", "l 60", "input/ascii"]);
 check_output!(list_empty, ["-n", "l 60", "input/empty"]);

tests/fixtures/sed/output/number_range

@@ -0,0 +1,17 @@
+l1_1
+l1_2
+l1_3
+l1_4
+l1_5
+l1_6
+l1_7
+l1_8
+l1_9
+10
+l1_10
+11
+l1_11
+12
+l1_12
+l1_13
+l1_14

tests/fixtures/sed/output/number_range_out_of_bounds

@@ -0,0 +1,14 @@
+l1_1
+l1_2
+l1_3
+l1_4
+l1_5
+l1_6
+l1_7
+l1_8
+l1_9
+l1_10
+l1_11
+l1_12
+l1_13
+l1_14

tests/fixtures/sed/output/text_simple_append

@@ -0,0 +1,17 @@
+l1_1
+l1_2
+extra
+l1_3
+extra
+l1_4
+extra
+l1_5
+l1_6
+l1_7
+l1_8
+l1_9
+l1_10
+l1_11
+l1_12
+l1_13
+l1_14

tests/fixtures/sed/output/text_simple_insert

@@ -0,0 +1,17 @@
+l1_1
+extra
+l1_2
+extra
+l1_3
+extra
+l1_4
+l1_5
+l1_6
+l1_7
+l1_8
+l1_9
+l1_10
+l1_11
+l1_12
+l1_13
+l1_14