improvement on parsing accuracy for case patterns

src/expand.rs

@@ -500,6 +500,7 @@ pub fn expand_var(chars: &mut Peekable<Chars<'_>>) -> ShResult<String> {
   let mut idx_brace_depth: i32 = 0;
   let mut idx_raw = String::new();
   let mut idx = None;
+  let mut in_operator = false;
   while let Some(&ch) = chars.peek() {
     match ch {
       markers::SUBSH if var_name.is_empty() => {
@@ -555,7 +556,7 @@ pub fn expand_var(chars: &mut Peekable<Chars<'_>>) -> ShResult<String> {
         };
         return Ok(val);
       }
-      '[' if brace_depth > 0 && bracket_depth == 0 && inner_brace_depth == 0 => {
+      '[' if brace_depth > 0 && bracket_depth == 0 && inner_brace_depth == 0 && !in_operator => {
         chars.next(); // consume the bracket
         bracket_depth += 1;
       }
@@ -590,6 +591,9 @@ pub fn expand_var(chars: &mut Peekable<Chars<'_>>) -> ShResult<String> {
         if ch == '}' {
           inner_brace_depth -= 1;
         }
+        if !in_operator && matches!(ch, '#' | '%' | ':' | '/' | '-' | '+' | '=' | '?' | '!') {
+          in_operator = true;
+        }
         var_name.push(ch);
       }
       ch if var_name.is_empty() && PARAMETERS.contains(&ch) => {
@@ -1026,7 +1030,7 @@ pub fn unescape_str(raw: &str) -> String {
                 result.push(next_ch);
               }
             }
-            '$' => {
+            '$' if chars.peek() != Some(&'\'') => {
               result.push(markers::VAR_SUB);
               if chars.peek() == Some(&'(') {
                 chars.next();
@@ -1058,6 +1062,76 @@ pub fn unescape_str(raw: &str) -> String {
                 }
               }
             }
+						'$' => {
+							log::debug!("Found ANSI-C quoting");
+							chars.next();
+							while let Some(q_ch) = chars.next() {
+								match q_ch {
+									'\'' => {
+										break;
+									}
+									'\\' => {
+										if let Some(esc) = chars.next() {
+											match esc {
+												'n' => result.push('\n'),
+												't' => result.push('\t'),
+												'r' => result.push('\r'),
+												'\'' => result.push('\''),
+												'\\' => result.push('\\'),
+												'a' => result.push('\x07'),
+												'b' => result.push('\x08'),
+												'e' | 'E' => result.push('\x1b'),
+												'v' => result.push('\x0b'),
+												'x' => {
+													let mut hex = String::new();
+													if let Some(h1) = chars.next() {
+														hex.push(h1);
+													} else {
+														result.push_str("\\x");
+														continue;
+													}
+													if let Some(h2) = chars.next() {
+														hex.push(h2);
+													} else {
+														result.push_str(&format!("\\x{hex}"));
+														continue;
+													}
+													if let Ok(byte) = u8::from_str_radix(&hex, 16) {
+														result.push(byte as char);
+													} else {
+														result.push_str(&format!("\\x{hex}"));
+														continue;
+													}
+												}
+												'o' => {
+													let mut oct = String::new();
+													for _ in 0..3 {
+														if let Some(o) = chars.peek() {
+															if o.is_digit(8) {
+																oct.push(*o);
+																chars.next();
+															} else {
+																break;
+															}
+														} else {
+															break;
+														}
+													}
+													if let Ok(byte) = u8::from_str_radix(&oct, 8) {
+														result.push(byte as char);
+													} else {
+														result.push_str(&format!("\\o{oct}"));
+														continue;
+													}
+												}
+												_ => result.push(esc),
+											}
+										}
+									}
+									_ => result.push(q_ch),
+								}
+							}
+						}
             '"' => {
               result.push(markers::DUB_QUOTE);
               break;
@@ -1145,6 +1219,7 @@ pub fn unescape_str(raw: &str) -> String {
         }
       }
       '$' if chars.peek() == Some(&'\'') => {
+				log::debug!("Found ANSI-C quoting");
         chars.next();
         result.push(markers::SNG_QUOTE);
         while let Some(q_ch) = chars.next() {
@@ -1318,6 +1393,8 @@ impl FromStr for ParamExp {
 			)	)
     };
 
+		log::debug!("Parsing parameter expansion: '{:?}'", s);
+
     // Handle indirect var expansion: ${!var}
     if let Some(var) = s.strip_prefix('!') {
       if var.ends_with('*') || var.ends_with('@') {
@@ -1333,6 +1410,7 @@ impl FromStr for ParamExp {
       return Ok(RemShortestPrefix(rest.to_string()));
     }
     if let Some(rest) = s.strip_prefix("%%") {
+			log::debug!("Matched longest suffix pattern: '{}'", rest);
       return Ok(RemLongestSuffix(rest.to_string()));
     } else if let Some(rest) = s.strip_prefix('%') {
       return Ok(RemShortestSuffix(rest.to_string()));
@@ -1512,7 +1590,9 @@ pub fn perform_param_expansion(raw: &str) -> ShResult<String> {
       }
       ParamExp::RemShortestPrefix(prefix) => {
         let value = vars.get_var(&var_name);
-        let pattern = Pattern::new(&prefix).unwrap();
+        let unescaped = unescape_str(&prefix);
+        let expanded = expand_raw(&mut unescaped.chars().peekable()).unwrap_or(prefix);
+        let pattern = Pattern::new(&expanded).unwrap();
         for i in 0..=value.len() {
           let sliced = &value[..i];
           if pattern.matches(sliced) {
@@ -1523,7 +1603,9 @@ pub fn perform_param_expansion(raw: &str) -> ShResult<String> {
       }
       ParamExp::RemLongestPrefix(prefix) => {
         let value = vars.get_var(&var_name);
-        let pattern = Pattern::new(&prefix).unwrap();
+        let unescaped = unescape_str(&prefix);
+        let expanded = expand_raw(&mut unescaped.chars().peekable()).unwrap_or(prefix);
+        let pattern = Pattern::new(&expanded).unwrap();
         for i in (0..=value.len()).rev() {
           let sliced = &value[..i];
           if pattern.matches(sliced) {
@@ -1534,7 +1616,9 @@ pub fn perform_param_expansion(raw: &str) -> ShResult<String> {
       }
       ParamExp::RemShortestSuffix(suffix) => {
         let value = vars.get_var(&var_name);
-        let pattern = Pattern::new(&suffix).unwrap();
+        let unescaped = unescape_str(&suffix);
+        let expanded = expand_raw(&mut unescaped.chars().peekable()).unwrap_or(suffix);
+        let pattern = Pattern::new(&expanded).unwrap();
         for i in (0..=value.len()).rev() {
           let sliced = &value[i..];
           if pattern.matches(sliced) {
@@ -1545,7 +1629,9 @@ pub fn perform_param_expansion(raw: &str) -> ShResult<String> {
       }
       ParamExp::RemLongestSuffix(suffix) => {
         let value = vars.get_var(&var_name);
-        let pattern = Pattern::new(&suffix).unwrap();
+        let unescaped = unescape_str(&suffix);
+        let expanded_suffix = expand_raw(&mut unescaped.chars().peekable()).unwrap_or(suffix.clone());
+        let pattern = Pattern::new(&expanded_suffix).unwrap();
         for i in 0..=value.len() {
           let sliced = &value[i..];
           if pattern.matches(sliced) {
@@ -1556,12 +1642,16 @@ pub fn perform_param_expansion(raw: &str) -> ShResult<String> {
       }
       ParamExp::ReplaceFirstMatch(search, replace) => {
         let value = vars.get_var(&var_name);
-        let regex = glob_to_regex(&search, false); // unanchored pattern
+        let search = unescape_str(&search);
+        let replace = unescape_str(&replace);
+        let expanded_search = expand_raw(&mut search.chars().peekable()).unwrap_or(search);
+        let expanded_replace = expand_raw(&mut replace.chars().peekable()).unwrap_or(replace);
+        let regex = glob_to_regex(&expanded_search, false); // unanchored pattern
 
         if let Some(mat) = regex.find(&value) {
           let before = &value[..mat.start()];
           let after = &value[mat.end()..];
-          let result = format!("{}{}{}", before, replace, after);
+          let result = format!("{}{}{}", before, expanded_replace, after);
           Ok(result)
         } else {
           Ok(value)
@@ -1569,13 +1659,17 @@ pub fn perform_param_expansion(raw: &str) -> ShResult<String> {
       }
       ParamExp::ReplaceAllMatches(search, replace) => {
         let value = vars.get_var(&var_name);
-        let regex = glob_to_regex(&search, false);
+        let search = unescape_str(&search);
+        let replace = unescape_str(&replace);
+        let expanded_search = expand_raw(&mut search.chars().peekable()).unwrap_or(search);
+        let expanded_replace = expand_raw(&mut replace.chars().peekable()).unwrap_or(replace);
+        let regex = glob_to_regex(&expanded_search, false);
         let mut result = String::new();
         let mut last_match_end = 0;
 
         for mat in regex.find_iter(&value) {
           result.push_str(&value[last_match_end..mat.start()]);
-          result.push_str(&replace);
+          result.push_str(&expanded_replace);
           last_match_end = mat.end();
         }
 
@@ -1585,22 +1679,30 @@ pub fn perform_param_expansion(raw: &str) -> ShResult<String> {
       }
       ParamExp::ReplacePrefix(search, replace) => {
         let value = vars.get_var(&var_name);
-        let pattern = Pattern::new(&search).unwrap();
+        let search = unescape_str(&search);
+        let replace = unescape_str(&replace);
+        let expanded_search = expand_raw(&mut search.chars().peekable()).unwrap_or(search);
+        let expanded_replace = expand_raw(&mut replace.chars().peekable()).unwrap_or(replace);
+        let pattern = Pattern::new(&expanded_search).unwrap();
         for i in (0..=value.len()).rev() {
           let sliced = &value[..i];
           if pattern.matches(sliced) {
-            return Ok(format!("{}{}", replace, &value[i..]));
+            return Ok(format!("{}{}", expanded_replace, &value[i..]));
           }
         }
         Ok(value)
       }
       ParamExp::ReplaceSuffix(search, replace) => {
         let value = vars.get_var(&var_name);
-        let pattern = Pattern::new(&search).unwrap();
+        let search = unescape_str(&search);
+        let replace = unescape_str(&replace);
+        let expanded_search = expand_raw(&mut search.chars().peekable()).unwrap_or(search);
+        let expanded_replace = expand_raw(&mut replace.chars().peekable()).unwrap_or(replace);
+        let pattern = Pattern::new(&expanded_search).unwrap();
         for i in (0..=value.len()).rev() {
           let sliced = &value[i..];
           if pattern.matches(sliced) {
-            return Ok(format!("{}{}", &value[..i], replace));
+            return Ok(format!("{}{}", &value[..i], expanded_replace));
           }
         }
         Ok(value)

src/main.rs

@@ -215,13 +215,12 @@ fn shed_interactive(args: ShedArgs) -> ShResult<()> {
       // Restore cursor to saved row before clearing, since the terminal
       // may have moved it during resize/rewrap
       readline.writer.update_t_cols();
-      readline.prompt_mut().refresh()?;
       readline.mark_dirty();
     }
 
     if JOB_DONE.swap(false, Ordering::SeqCst) {
       // update the prompt so any job count escape sequences update dynamically
-      readline.prompt_mut().refresh()?;
+      readline.prompt_mut().refresh();
     }
 
     readline.print_line(false)?;
@@ -388,6 +387,7 @@ fn shed_interactive(args: ShedArgs) -> ShResult<()> {
 
         // Reset for next command with fresh prompt
         readline.reset(true)?;
+
         let real_end = start.elapsed();
         log::info!("Total round trip time: {:.2?}", real_end);
       }

src/parse/execute.rs

@@ -424,18 +424,13 @@ impl Dispatcher {
       'outer: for block in case_blocks {
         let CaseNode { pattern, body } = block;
         let block_pattern_raw = pattern.span.as_str().strip_suffix(')').unwrap_or(pattern.span.as_str()).trim();
-        log::debug!("[case] raw block pattern: {:?}", block_pattern_raw);
         // Split at '|' to allow for multiple patterns like `foo|bar)`
         let block_patterns = block_pattern_raw.split('|');
 
         for pattern in block_patterns {
-					log::debug!("[case] testing pattern {:?} against input {:?}", pattern, pattern_raw);
 					let pattern_exp = Expander::from_raw(pattern)?.expand()?.join(" ");
-					log::debug!("[case] expanded pattern: {:?}", pattern_exp);
           let pattern_regex = glob_to_regex(&pattern_exp, false);
-          log::debug!("[case] testing input {:?} against pattern {:?} (regex: {:?})", pattern_raw, pattern_exp, pattern_regex);
           if pattern_regex.is_match(&pattern_raw) {
-            log::debug!("[case] matched pattern {:?}", pattern_exp);
             for node in &body {
               s.dispatch_node(node.clone())?;
             }

src/parse/lex.rs

@@ -1087,11 +1087,26 @@ pub fn case_pat_lookahead(mut chars: Peekable<Chars>) -> Option<usize> {
   while let Some(ch) = chars.next() {
     pos += ch.len_utf8();
     match ch {
-      _ if is_hard_sep(ch) => return None,
+      _ if qt_state.outside() && is_hard_sep(ch) => return None,
       '\\' => {
         if let Some(esc) = chars.next() {
           pos += esc.len_utf8();
         }
+      }
+      '$' if qt_state.outside() && chars.peek() == Some(&'\'') => {
+        // $'...' ANSI-C quoting — skip through to closing quote
+        chars.next(); // consume opening '
+        pos += 1;
+        while let Some(c) = chars.next() {
+          pos += c.len_utf8();
+          if c == '\\' {
+            if let Some(esc) = chars.next() {
+              pos += esc.len_utf8();
+            }
+          } else if c == '\'' {
+            break;
+          }
+        }
       }
 			'\'' => {
 				qt_state.toggle_single();

src/readline/highlight.rs

@@ -26,6 +26,7 @@ pub struct Highlighter {
   style_stack: Vec<StyleSet>,
   last_was_reset: bool,
   in_selection: bool,
+	only_hl_visual: bool
 }
 
 impl Highlighter {
@@ -38,8 +39,12 @@ impl Highlighter {
       style_stack: Vec::new(),
       last_was_reset: true, // start as true so we don't emit a leading reset
       in_selection: false,
+			only_hl_visual: false
     }
   }
+	pub fn only_visual(&mut self, only_visual: bool) {
+		self.only_hl_visual = only_visual;
+	}
 
   /// Loads raw input text and annotates it with syntax markers
   ///
@@ -61,6 +66,26 @@ impl Highlighter {
     out
   }
 
+	pub fn expand_control_chars(&mut self) {
+		let mut expanded = String::new();
+		let mut chars = self.input.chars().peekable();
+
+		while let Some(ch) = chars.next() {
+			match ch {
+				'\n' | '\t' | '\r' => expanded.push(ch),
+				c if c as u32 <= 0x1F => {
+					let display = (c as u8 + b'@') as char;
+					expanded.push_str("\x1b[7m^");
+					expanded.push(display);
+					expanded.push_str("\x1b[0m");
+				}
+				_ => expanded.push(ch),
+			}
+		}
+
+		self.input = expanded;
+	}
+
   /// Processes the annotated input and generates ANSI-styled output
   ///
   /// Walks through the input character by character, interpreting markers and
@@ -79,6 +104,9 @@ impl Highlighter {
           self.reapply_style();
           self.in_selection = false;
         }
+				_ if self.only_hl_visual => {
+					self.output.push(ch);
+				}
         markers::STRING_DQ_END
         | markers::STRING_SQ_END
         | markers::VAR_SUB_END

src/readline/linebuf.rs

@@ -2885,6 +2885,8 @@ impl LineBuf {
       Verb::Insert(string) => {
         self.push_str(&string);
         let graphemes = string.graphemes(true).count();
+				log::debug!("Inserted string: {string:?}, graphemes: {graphemes}");
+				log::debug!("buffer after insert: {:?}", self.buffer);
         self.cursor.add(graphemes);
       }
       Verb::Indent => {

src/readline/mod.rs

@@ -140,6 +140,7 @@ pub struct Prompt {
   ps1_raw: String,
   psr_expanded: Option<String>,
   psr_raw: Option<String>,
+  dirty: bool,
 }
 
 impl Prompt {
@@ -170,32 +171,54 @@ impl Prompt {
       ps1_raw,
       psr_expanded,
       psr_raw,
+      dirty: false,
     }
   }
 
-  pub fn get_ps1(&self) -> &str {
+  pub fn get_ps1(&mut self) -> &str {
+    if self.dirty {
+      self.refresh_now();
+    }
     &self.ps1_expanded
   }
   pub fn set_ps1(&mut self, ps1_raw: String) -> ShResult<()> {
-    self.ps1_expanded = expand_prompt(&ps1_raw)?;
     self.ps1_raw = ps1_raw;
+    self.dirty = true;
     Ok(())
   }
   pub fn set_psr(&mut self, psr_raw: String) -> ShResult<()> {
-    self.psr_expanded = Some(expand_prompt(&psr_raw)?);
     self.psr_raw = Some(psr_raw);
+    self.dirty = true;
     Ok(())
   }
-  pub fn get_psr(&self) -> Option<&str> {
+  pub fn get_psr(&mut self) -> Option<&str> {
+    if self.dirty {
+      self.refresh_now();
+    }
     self.psr_expanded.as_deref()
   }
 
-  pub fn refresh(&mut self) -> ShResult<()> {
-    self.ps1_expanded = expand_prompt(&self.ps1_raw)?;
-    if let Some(psr_raw) = &self.psr_raw {
-      self.psr_expanded = Some(expand_prompt(psr_raw)?);
+  /// Mark the prompt as needing re-expansion on next access.
+  pub fn invalidate(&mut self) {
+    self.dirty = true;
   }
-    Ok(())
+
+  fn refresh_now(&mut self) {
+    let saved_status = state::get_status();
+    if let Ok(expanded) = expand_prompt(&self.ps1_raw) {
+      self.ps1_expanded = expanded;
+    }
+    if let Some(psr_raw) = &self.psr_raw {
+      if let Ok(expanded) = expand_prompt(psr_raw) {
+        self.psr_expanded = Some(expanded);
+      }
+    }
+    state::set_status(saved_status);
+    self.dirty = false;
+  }
+
+  pub fn refresh(&mut self) {
+    self.invalidate();
   }
 }
 
@@ -207,6 +230,7 @@ impl Default for Prompt {
       ps1_raw: Self::DEFAULT_PS1.to_string(),
       psr_expanded: None,
       psr_raw: None,
+      dirty: false,
     }
   }
 }
@@ -253,7 +277,7 @@ impl ShedVi {
       needs_redraw: true,
     };
 		write_vars(|v| v.set_var("SHED_VI_MODE", VarKind::Str(new.mode.report_mode().to_string()), VarFlags::NONE))?;
-		new.prompt.refresh()?;
+		new.prompt.refresh();
     new.writer.flush_write("\n")?; // ensure we start on a new line, in case the previous command didn't end with a newline
     new.print_line(false)?;
     Ok(new)
@@ -296,7 +320,7 @@ impl ShedVi {
   pub fn reset(&mut self, full_redraw: bool) -> ShResult<()> {
     // Clear old display before resetting state — old_layout must survive
     // so print_line can call clear_rows with the full multi-line layout
-    self.prompt = Prompt::new();
+    self.prompt.refresh();
     self.editor = Default::default();
 		self.swap_mode(&mut (Box::new(ViInsert::new()) as Box<dyn ViMode>));
     self.needs_redraw = true;
@@ -598,14 +622,6 @@ impl ShedVi {
     Ok(None)
   }
 
-	pub fn update_layout(&mut self) {
-		let text = self.line_text();
-		let new = self.get_layout(&text);
-		if let Some(old) = self.old_layout.as_mut() {
-			*old = new;
-		}
-	}
-
   pub fn get_layout(&mut self, line: &str) -> Layout {
     let to_cursor = self.editor.slice_to_cursor().unwrap_or_default();
     let (cols, _) = get_win_size(*TTY_FILENO);
@@ -654,8 +670,7 @@ impl ShedVi {
             || (self.mode.pending_seq().unwrap(/* always Some on normal mode */).is_empty()
               && matches!(event, KeyEvent(KeyCode::Char('l'), ModKeys::NONE)))
         }
-				ModeReport::Ex => false,
-        _ => unimplemented!(),
+				ModeReport::Ex | ModeReport::Verbatim | ModeReport::Unknown => false,
       }
     } else {
       false
@@ -677,21 +692,19 @@ impl ShedVi {
   pub fn line_text(&mut self) -> String {
     let line = self.editor.to_string();
     let hint = self.editor.get_hint_text();
-    if crate::state::read_shopts(|s| s.prompt.highlight) {
-      self
-        .highlighter
-        .load_input(&line, self.editor.cursor_byte_pos());
+		let do_hl = state::read_shopts(|s| s.prompt.highlight);
+		self.highlighter.only_visual(!do_hl);
+		self.highlighter.load_input(&line, self.editor.cursor_byte_pos());
+		self.highlighter.expand_control_chars();
 		self.highlighter.highlight();
 		let highlighted = self.highlighter.take();
 		format!("{highlighted}{hint}")
-    } else {
-      format!("{line}{hint}")
-    }
   }
 
   pub fn print_line(&mut self, final_draw: bool) -> ShResult<()> {
     let line = self.line_text();
     let mut new_layout = self.get_layout(&line);
+
     let pending_seq = self.mode.pending_seq();
     let mut prompt_string_right = self.prompt.psr_expanded.clone();
 
@@ -710,7 +723,7 @@ impl ShedVi {
       .get_ps1()
       .lines()
       .next()
-      .map(|l| Layout::calc_pos(self.writer.t_cols, l, Pos { col: 0, row: 0 }, 0))
+      .map(|l| Layout::calc_pos(self.writer.t_cols, l, Pos { col: 0, row: 0 }, 0, false))
       .map(|p| p.col)
       .unwrap_or_default() as usize;
     let one_line = new_layout.end.row == 0;
@@ -769,7 +782,7 @@ impl ShedVi {
       // Record where the PSR ends so clear_rows can account for wrapping
       // if the terminal shrinks.
       let psr_start = Pos { row: new_layout.end.row, col: to_col };
-      new_layout.psr_end = Some(Layout::calc_pos(self.writer.t_cols, &psr, psr_start, 0));
+      new_layout.psr_end = Some(Layout::calc_pos(self.writer.t_cols, &psr, psr_start, 0, false));
     }
 
 		if let ModeReport::Ex = self.mode.report_mode() {
@@ -781,6 +794,7 @@ impl ShedVi {
     write!(buf, "{}", &self.mode.cursor_style()).unwrap();
 
 		self.writer.flush_write(&buf)?;
+
     // Tell the completer the width of the prompt line above its \n so it can
     // account for wrapping when clearing after a resize.
     let preceding_width = if new_layout.psr_end.is_some() {
@@ -808,7 +822,7 @@ impl ShedVi {
 		std::mem::swap(&mut self.mode, mode);
 		self.editor.set_cursor_clamp(self.mode.clamp_cursor());
 		write_vars(|v| v.set_var("SHED_VI_MODE", VarKind::Str(self.mode.report_mode().to_string()), VarFlags::NONE)).ok();
-		self.prompt.refresh().ok();
+		self.prompt.refresh();
 
 		let post_mode_change = read_logic(|l| l.get_autocmds(AutoCmdKind::PostModeChange));
 		post_mode_change.exec();
@@ -820,7 +834,7 @@ impl ShedVi {
     if cmd.is_mode_transition() {
       let count = cmd.verb_count();
 
-      let mut mode: Box<dyn ViMode> = if let ModeReport::Ex = self.mode.report_mode() && cmd.flags.contains(CmdFlags::EXIT_CUR_MODE) {
+      let mut mode: Box<dyn ViMode> = if matches!(self.mode.report_mode(), ModeReport::Ex | ModeReport::Verbatim)  && cmd.flags.contains(CmdFlags::EXIT_CUR_MODE) {
 				if let Some(saved) = self.saved_mode.take() {
 					saved
 				} else {
@@ -874,7 +888,7 @@ impl ShedVi {
 			if matches!(self.mode.report_mode(), ModeReport::Ex | ModeReport::Verbatim) {
 				self.saved_mode = Some(mode);
 				write_vars(|v| v.set_var("SHED_VI_MODE", VarKind::Str(self.mode.report_mode().to_string()), VarFlags::NONE))?;
-				self.prompt.refresh()?;
+				self.prompt.refresh();
 				return Ok(());
 			}
 
@@ -899,7 +913,7 @@ impl ShedVi {
       }
 
 			write_vars(|v| v.set_var("SHED_VI_MODE", VarKind::Str(self.mode.report_mode().to_string()), VarFlags::NONE))?;
-			self.prompt.refresh()?;
+			self.prompt.refresh();
 
 
       return Ok(());
@@ -1055,7 +1069,6 @@ pub fn annotate_input(input: &str) -> String {
     .filter(|tk| !matches!(tk.class, TkRule::SOI | TkRule::EOI | TkRule::Null))
     .collect();
 
-	log::debug!("Annotating input with tokens: {tokens:#?}");
 
   for tk in tokens.into_iter().rev() {
     let insertions = annotate_token(tk);

src/readline/term.rs

@@ -736,9 +736,9 @@ impl Layout {
     }
   }
   pub fn from_parts(term_width: u16, prompt: &str, to_cursor: &str, to_end: &str) -> Self {
-    let prompt_end = Self::calc_pos(term_width, prompt, Pos { col: 0, row: 0 }, 0);
-    let cursor = Self::calc_pos(term_width, to_cursor, prompt_end, prompt_end.col);
-    let end = Self::calc_pos(term_width, to_end, prompt_end, prompt_end.col);
+    let prompt_end = Self::calc_pos(term_width, prompt, Pos { col: 0, row: 0 }, 0, false);
+    let cursor = Self::calc_pos(term_width, to_cursor, prompt_end, prompt_end.col, true);
+    let end = Self::calc_pos(term_width, to_end, prompt_end, prompt_end.col, false);
     Layout {
       prompt_end,
       cursor,
@@ -748,7 +748,15 @@ impl Layout {
     }
   }
 
-  pub fn calc_pos(term_width: u16, s: &str, orig: Pos, left_margin: u16) -> Pos {
+	fn is_ctl_char(gr: &str) -> bool {
+		gr.len() > 0 &&
+		gr.as_bytes()[0] <= 0x1F &&
+		gr != "\n" &&
+		gr != "\t" &&
+		gr != "\r"
+	}
+
+  pub fn calc_pos(term_width: u16, s: &str, orig: Pos, left_margin: u16, raw_calc: bool) -> Pos {
     const TAB_STOP: u16 = 8;
     let mut pos = orig;
     let mut esc_seq = 0;
@@ -759,6 +767,8 @@ impl Layout {
       }
       let c_width = if c == "\t" {
         TAB_STOP - (pos.col % TAB_STOP)
+			} else if raw_calc && Self::is_ctl_char(c) {
+				2
       } else {
         width(c, &mut esc_seq)
       };
@@ -1002,7 +1012,7 @@ impl LineWriter for TermWriter {
     self.buffer.push_str(prompt);
     let multiline = line.contains('\n');
     if multiline {
-      let prompt_end = Layout::calc_pos(self.t_cols, prompt, Pos { col: 0, row: 0 }, 0);
+      let prompt_end = Layout::calc_pos(self.t_cols, prompt, Pos { col: 0, row: 0 }, 0, false);
       let display_line = enumerate_lines(line, prompt_end.col as usize);
       self.buffer.push_str(&display_line);
     } else {

src/readline/vimode/verbatim.rs

@@ -24,6 +24,7 @@ impl ViMode for ViVerbatim {
   fn handle_key(&mut self, key: E) -> Option<ViCmd> {
     match key {
 			E(K::Verbatim(seq),_mods) => {
+				log::debug!("Received verbatim key sequence: {:?}", seq);
 				let cmd = ViCmd { register: RegisterName::default(),
 					verb: Some(VerbCmd(1,Verb::Insert(seq.to_string()))),
 					motion: None,
@@ -61,6 +62,6 @@ impl ViMode for ViVerbatim {
     Some(To::End)
   }
   fn report_mode(&self) -> ModeReport {
-    ModeReport::Insert
+    ModeReport::Verbatim
   }
 }