grep.h File Reference

Go to the source code of this file.

Data Structures
struct	grep_parse_result_t
	Parsed pattern result from /pattern/flags syntax. More...

Functions
grep_parse_result_t	grep_parse_pattern (const char *input)
	Parse pattern in /pattern/flags format or plain regex format.
asciichat_error_t	grep_init (const char *pattern)
	Initialize log filtering with PCRE2 regex pattern.
bool	grep_should_output (const char *log_line, size_t *match_start, size_t *match_len)
	Check if log line should be output (matches filter)
const char *	grep_highlight (const char *log_line, size_t match_start, size_t match_len)
	Highlight matched portion with background color.
const char *	grep_highlight_colored (const char *colored_text, const char *plain_text, size_t match_start, size_t match_len)
	Highlight matches in colored text while preserving original colors.
char *	grep_highlight_colored_copy (const char *colored_text, const char *plain_text, size_t match_start, size_t match_len)
	Highlight matches in colored text, returning a new allocated copy.
void	grep_destroy (void)
	Clean up filter resources.
asciichat_error_t	grep_save_patterns (void)
	Save current filter patterns for later restoration.
asciichat_error_t	grep_restore_patterns (void)
	Restore previously saved filter patterns.
void	grep_clear_patterns (void)
	Clear all filter patterns.
int	grep_get_pattern_count (void)
	Get number of active filter patterns.
const char *	grep_get_last_pattern (void)
	Get the last (most recent) filter pattern string.

Function Documentation

grep_clear_patterns()

void grep_clear_patterns

(

void

)

Clear all filter patterns.

Temporarily disables filtering by setting pattern count to 0. Patterns remain allocated and can be restored later. Used by interactive grep when user types first character.

Definition at line 1315 of file grep.c.

                               {
  // Don't free patterns, just set count to 0
  // This allows quick restore without reallocation
  g_filter_state.pattern_count = 0;
  g_filter_state.enabled = false;
}

grep_destroy()

void grep_destroy

(

void

)

Clean up filter resources.

Frees compiled regex. Thread-local match_data is cleaned up via pthread_key destructor.

Definition at line 1177 of file grep.c.

                        {
  // Free all patterns
  for (int i = 0; i < g_filter_state.pattern_count; i++) {
    grep_pattern_t *pat = &g_filter_state.patterns[i];
    // Free the copied original string (need temp variable due to const qualifier)
    char *original_to_free = (char *)pat->original;
    SAFE_FREE(original_to_free);
    SAFE_FREE(pat->parsed_pattern);
    // Singletons are auto-cleaned by asciichat_pcre2_cleanup_all()
    pat->singleton = NULL;
  }
  SAFE_FREE(g_filter_state.patterns);
  g_filter_state.patterns = NULL; // Make idempotent
 
  // Free context buffer
  if (g_filter_state.line_buffer) {
    for (int i = 0; i < g_filter_state.buffer_size; i++) {
      SAFE_FREE(g_filter_state.line_buffer[i]);
    }
    SAFE_FREE(g_filter_state.line_buffer);
    g_filter_state.line_buffer = NULL; // Make idempotent
  }
 
  g_filter_state.pattern_count = 0;
  g_filter_state.pattern_capacity = 0;
  g_filter_state.buffer_size = 0;
  g_filter_state.buffer_pos = 0;
  g_filter_state.lines_after_match = 0;
  g_filter_state.max_context_after = 0;
  g_filter_state.enabled = false;
 
  // Note: Thread-local match_data is cleaned up via pthread_key destructor
}

References grep_pattern_t::original, grep_pattern_t::parsed_pattern, SAFE_FREE, and grep_pattern_t::singleton.

Referenced by log_destroy().

grep_get_last_pattern()

const char * grep_get_last_pattern

(

void

)

Get the last (most recent) filter pattern string.

Returns the original pattern string (with /pattern/flags syntax if provided) of the last –grep argument. Used by interactive grep to populate its input buffer when starting with CLI –grep patterns.

Returns

Pattern string of last CLI –grep, or NULL if no patterns

Definition at line 1326 of file grep.c.

                                        {
  if (g_filter_state.pattern_count == 0) {
    return NULL;
  }
 
  // Return the original pattern string of the last pattern
  return g_filter_state.patterns[g_filter_state.pattern_count - 1].original;
}

Referenced by log_search_enter_mode(), log_search_init(), ui_status_display(), and ui_status_display_interactive().

grep_get_pattern_count()

int grep_get_pattern_count

(

void

)

Get number of active filter patterns.

Returns

Number of currently active patterns

Definition at line 1322 of file grep.c.

                                 {
  return g_filter_state.pattern_count;
}

grep_highlight()

const char * grep_highlight	(	const char *	log_line,
		size_t	match_start,
		size_t	match_len
	)

Highlight matched portion with background color.

Inserts ANSI escape codes for yellow background (255, 200, 0) with black foreground (0, 0, 0) around the matched text.

Parameters

log_line	Original log line
match_start	Start offset of match
match_len	Length of match

Returns

Highlighted string (pointer to static thread-local buffer)

Definition at line 1074 of file grep.c.

                                                                                       {
  static __thread char highlight_buffer[16384];
 
  if (!log_line || match_len == 0) {
    return log_line; // No highlighting needed
  }
 
  size_t line_len = strlen(log_line);
  if (match_start + match_len > line_len) {
    return log_line; // Invalid range
  }
 
  char *dst = highlight_buffer;
  const char *src = log_line;
  size_t pos = 0;
 
  // If any pattern has global flag, highlight ALL matches
  grep_pattern_t *global_pat = NULL;
  for (int i = 0; i < g_filter_state.pattern_count; i++) {
    if (g_filter_state.patterns[i].global_flag && !g_filter_state.patterns[i].is_fixed_string) {
      global_pat = &g_filter_state.patterns[i];
      break;
    }
  }
 
  if (global_pat && global_pat->singleton) {
    pcre2_code *code = asciichat_pcre2_singleton_get_code(global_pat->singleton);
    pcre2_match_data *match_data = get_thread_match_data();
 
    if (!code || !match_data) {
      return log_line; // Fall back to no highlighting
    }
 
    // Find all matches in the line
    size_t offset = 0;
    while (offset < line_len) {
      int rc = pcre2_jit_match(code, (PCRE2_SPTR)log_line, line_len, offset, 0, match_data, NULL);
      if (rc < 0) {
        break; // No more matches
      }
 
      PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(match_data);
      size_t match_pos = (size_t)ovector[0];
      size_t match_end = (size_t)ovector[1];
      size_t len = match_end - match_pos;
 
      // Copy text before match
      if (match_pos > pos) {
        memcpy(dst, src + pos, match_pos - pos);
        dst += (match_pos - pos);
      }
 
      // Highlight the match (background only, preserve foreground color)
      uint8_t r, g, b;
      get_highlight_color(&r, &g, &b);
      dst = append_truecolor_bg(dst, r, g, b);
      memcpy(dst, src + match_pos, len);
      dst += len;
 
      pos = match_end;
      offset = match_end;
 
      // Prevent infinite loop on zero-length matches
      if (len == 0) {
        offset++;
      }
    }
 
    // Copy remaining text after last match
    if (pos < line_len) {
      memcpy(dst, src + pos, line_len - pos);
      dst += (line_len - pos);
    }
 
  } else {
    // Single match highlighting (original behavior)
    // Copy text before match
    if (match_start > 0) {
      memcpy(dst, log_line, match_start);
      dst += match_start;
    }
 
    // Add background color for match (preserve foreground color)
    uint8_t r, g, b;
    get_highlight_color(&r, &g, &b);
    dst = append_truecolor_bg(dst, r, g, b);
 
    // Copy matched text
    memcpy(dst, log_line + match_start, match_len);
    dst += match_len;
 
    // Copy text after match
    size_t remaining = line_len - (match_start + match_len);
    if (remaining > 0) {
      memcpy(dst, log_line + match_start + match_len, remaining);
      dst += remaining;
    }
  }
 
  *dst = '\0';
  return highlight_buffer;
}

References append_truecolor_bg(), asciichat_pcre2_singleton_get_code(), and grep_pattern_t::singleton.

grep_highlight_colored()

const char * grep_highlight_colored	(	const char *	colored_text,
		const char *	plain_text,
		size_t	match_start,
		size_t	match_len
	)

Highlight matches in colored text while preserving original colors.

Parameters

colored_text	Original text with ANSI color codes
plain_text	Stripped plain text (for match positions)
match_start	Match start position in plain text
match_len	Match length in plain text

Returns

Highlighted text with yellow background added to matches (pointer to static thread-local buffer)

Definition at line 755 of file grep.c.

                                                     {
  static __thread char highlight_buffer[16384];
 
  if (!colored_text || !plain_text || match_len == 0) {
    return colored_text;
  }
 
  // When interactive grep is active, check if it has global flag
  bool is_log_search = log_search_is_active();
  bool should_use_global_pattern = false;
  grep_pattern_t *global_pat = NULL;
 
  if (!is_log_search) {
    // If any pattern has global flag, highlight ALL matches for that pattern
    // Find first pattern with global flag
    for (int i = 0; i < g_filter_state.pattern_count; i++) {
      if (g_filter_state.patterns[i].global_flag && !g_filter_state.patterns[i].is_fixed_string) {
        global_pat = &g_filter_state.patterns[i];
        should_use_global_pattern = true;
        break;
      }
    }
  } else if (log_search_get_global_highlight()) {
    // Interactive grep is active and has /g flag - do global matching on the provided pattern
    // We'll do all-match highlighting using the match position to extract the pattern
    // and re-match for all occurrences
    should_use_global_pattern = true;
    // global_pat stays NULL, but we set the flag to enable global matching below
  }
 
  if (should_use_global_pattern) {
    pcre2_code *code = NULL;
    pcre2_match_data *match_data = NULL;
    char fixed_string_pattern[256] = {0};
    bool is_fixed_string_pattern = false;
    bool case_insensitive_fixed = false;
 
    // Get code from CLI pattern or interactive grep pattern
    if (global_pat && global_pat->singleton) {
      code = asciichat_pcre2_singleton_get_code(global_pat->singleton);
      match_data = get_thread_match_data();
    } else if (is_log_search) {
      // Interactive grep global highlighting - get pattern from grep state
      void *grep_singleton_void = log_search_get_pattern_singleton();
      if (grep_singleton_void) {
        pcre2_singleton_t *grep_singleton = (pcre2_singleton_t *)grep_singleton_void;
        code = asciichat_pcre2_singleton_get_code(grep_singleton);
        // Create match data for this pattern
        if (code) {
          match_data = pcre2_match_data_create_from_pattern(code, NULL);
        }
      } else {
        // No regex pattern - check if it's a fixed string pattern in interactive grep
        int pattern_len = log_search_get_input_len();
        const char *pattern = log_search_get_input_buffer();
        if (pattern_len > 0 && pattern && pattern_len < (int)sizeof(fixed_string_pattern)) {
          SAFE_STRNCPY(fixed_string_pattern, pattern, sizeof(fixed_string_pattern) - 1);
          is_fixed_string_pattern = true;
          case_insensitive_fixed = log_search_get_case_insensitive();
        }
      }
    }
 
    if (!code && !is_fixed_string_pattern) {
      if (match_data && is_log_search) {
        pcre2_match_data_free(match_data); // Free if we created it
      }
      return colored_text; // Fall back to no highlighting
    }
 
    size_t plain_len = strlen(plain_text);
    size_t colored_len = strlen(colored_text);
    char *dst = highlight_buffer;
    size_t plain_offset = 0;
    size_t colored_pos = 0;
 
    // Handle fixed string global matching
    if (is_fixed_string_pattern) {
      while (plain_offset < plain_len) {
        // Find next occurrence of fixed string
        const char *found = NULL;
        if (case_insensitive_fixed) {
          found = utf8_strcasestr(plain_text + plain_offset, fixed_string_pattern);
        } else {
          found = strstr(plain_text + plain_offset, fixed_string_pattern);
        }
 
        if (!found) {
          break; // No more matches
        }
 
        size_t plain_match_start = (size_t)(found - plain_text);
        size_t plain_match_end = plain_match_start + strlen(fixed_string_pattern);
 
        // Map to colored text positions (same as single-match path)
        size_t colored_match_start = map_plain_to_colored_pos(colored_text, plain_match_start);
        size_t colored_match_end = map_plain_to_colored_pos(colored_text, plain_match_end);
 
        // Copy text before match
        if (colored_match_start > colored_pos) {
          memcpy(dst, colored_text + colored_pos, colored_match_start - colored_pos);
          dst += (colored_match_start - colored_pos);
        }
 
        // Add highlight background
        uint8_t r, g, b;
        get_highlight_color(&r, &g, &b);
        dst = append_truecolor_bg(dst, r, g, b);
 
        // Copy matched text with background
        size_t match_byte_len = colored_match_end - colored_match_start;
        memcpy(dst, colored_text + colored_match_start, match_byte_len);
        dst += match_byte_len;
 
        // Reset background
        memcpy(dst, "\x1b[49m", 5);
        dst += 5;
 
        colored_pos = colored_match_end;
        plain_offset = plain_match_end;
      }
 
      // Copy remaining text
      if (colored_pos < colored_len) {
        memcpy(dst, colored_text + colored_pos, colored_len - colored_pos);
        dst += (colored_len - colored_pos);
      }
 
      // Reset both background and foreground at end
      *dst = '\0';
      return highlight_buffer;
    }
 
    // Find all matches in plain text and highlight in colored text (regex matching)
    while (plain_offset < plain_len) {
      int rc = pcre2_jit_match(code, (PCRE2_SPTR)plain_text, plain_len, plain_offset, 0, match_data, NULL);
      if (rc < 0) {
        break; // No more matches
      }
 
      PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(match_data);
      size_t plain_match_start = (size_t)ovector[0];
      size_t plain_match_end = (size_t)ovector[1];
 
      // Map to colored text positions
      size_t colored_match_start = map_plain_to_colored_pos(colored_text, plain_match_start);
      size_t colored_match_end = map_plain_to_colored_pos(colored_text, plain_match_end);
 
      // Copy text before match
      if (colored_match_start > colored_pos) {
        memcpy(dst, colored_text + colored_pos, colored_match_start - colored_pos);
        dst += (colored_match_start - colored_pos);
      }
 
      // Add highlight background
      uint8_t r, g, b;
      get_highlight_color(&r, &g, &b);
      dst = append_truecolor_bg(dst, r, g, b);
 
      // Copy matched text, re-applying background after any [0m or [00m reset codes
      size_t match_byte_len = colored_match_end - colored_match_start;
      const char *match_src = colored_text + colored_match_start;
      char *dst_end = highlight_buffer + sizeof(highlight_buffer) - 1; // Absolute buffer end
      size_t i = 0;
      while (i < match_byte_len) {
        // Check for [0m or [00m reset codes
        if (i + 4 <= match_byte_len && match_src[i] == '\x1b' && match_src[i + 1] == '[' && match_src[i + 2] == '0' &&
            match_src[i + 3] == 'm') {
          // Found [0m - copy it and re-apply background (if room)
          if (dst + 4 >= dst_end)
            break;                 // Not enough space for the reset code itself
          *dst++ = match_src[i++]; // ESC
          *dst++ = match_src[i++]; // '['
          *dst++ = match_src[i++]; // '0'
          *dst++ = match_src[i++]; // 'm'
          // Re-apply highlight background after reset (only if room)
          if (dst + 20 < dst_end) {
            uint8_t r2, g2, b2;
            get_highlight_color(&r2, &g2, &b2);
            dst = append_truecolor_bg(dst, r2, g2, b2);
          }
        } else if (i + 5 <= match_byte_len && match_src[i] == '\x1b' && match_src[i + 1] == '[' &&
                   match_src[i + 2] == '0' && match_src[i + 3] == '0' && match_src[i + 4] == 'm') {
          // Found [00m - copy it and re-apply background (if room)
          if (dst + 5 >= dst_end)
            break;                 // Not enough space for the reset code itself
          *dst++ = match_src[i++]; // ESC
          *dst++ = match_src[i++]; // '['
          *dst++ = match_src[i++]; // '0'
          *dst++ = match_src[i++]; // '0'
          *dst++ = match_src[i++]; // 'm'
          // Re-apply highlight background after reset (only if room)
          if (dst + 20 < dst_end) {
            uint8_t r2, g2, b2;
            get_highlight_color(&r2, &g2, &b2);
            dst = append_truecolor_bg(dst, r2, g2, b2);
          }
        } else {
          // Regular character - just copy
          if (dst + 1 >= dst_end)
            break;
          *dst++ = match_src[i++];
        }
      }
 
      // Reset background only
      memcpy(dst, "\x1b[49m", 5);
      dst += 5;
 
      colored_pos = colored_match_end;
      plain_offset = plain_match_end;
 
      // Prevent infinite loop on zero-length matches
      if (plain_match_end == plain_match_start) {
        plain_offset++;
      }
    }
 
    // Copy remaining text
    if (colored_pos < colored_len) {
      memcpy(dst, colored_text + colored_pos, colored_len - colored_pos);
      dst += (colored_len - colored_pos);
    }
 
    // Reset both background and foreground at end to prevent color bleeding
    *dst = '\0';
 
    // Clean up match data if we created it for interactive grep
    if (is_log_search && match_data && !global_pat) {
      pcre2_match_data_free(match_data);
    }
 
    return highlight_buffer;
  }
 
  // Single match highlighting (same logic as global path)
  // map_plain_to_colored_pos(N) returns byte position after counting N characters
  size_t colored_start = map_plain_to_colored_pos(colored_text, match_start);
  size_t colored_end = map_plain_to_colored_pos(colored_text, match_start + match_len);
 
  size_t colored_len = strlen(colored_text);
  char *dst = highlight_buffer;
 
  // Copy everything before the match
  if (colored_start > 0) {
    memcpy(dst, colored_text, colored_start);
    dst += colored_start;
  }
 
  // Add highlight background
  uint8_t r, g, b;
  get_highlight_color(&r, &g, &b);
  dst = append_truecolor_bg(dst, r, g, b);
 
  // Copy matched text, re-applying background after any [0m or [00m reset codes
  size_t match_byte_len = colored_end - colored_start;
  const char *match_src = colored_text + colored_start;
  char *dst_end = highlight_buffer + sizeof(highlight_buffer) - 1; // Absolute buffer end
  size_t i = 0;
 
  while (i < match_byte_len) {
    // Check for [0m or [00m reset codes
    if (i + 4 <= match_byte_len && match_src[i] == '\x1b' && match_src[i + 1] == '[' && match_src[i + 2] == '0' &&
        match_src[i + 3] == 'm') {
      // Found [0m - copy it and re-apply background (if room)
      if (dst + 4 >= dst_end)
        break;                 // Not enough space for even the reset code
      *dst++ = match_src[i++]; // ESC
      *dst++ = match_src[i++]; // '['
      *dst++ = match_src[i++]; // '0'
      *dst++ = match_src[i++]; // 'm'
      // Re-apply highlight background after reset (only if room)
      if (dst + 20 < dst_end) {
        uint8_t r2, g2, b2;
        get_highlight_color(&r2, &g2, &b2);
        dst = append_truecolor_bg(dst, r2, g2, b2);
      }
    } else if (i + 5 <= match_byte_len && match_src[i] == '\x1b' && match_src[i + 1] == '[' &&
               match_src[i + 2] == '0' && match_src[i + 3] == '0' && match_src[i + 4] == 'm') {
      // Found [00m - copy it and re-apply background (if room)
      if (dst + 5 >= dst_end)
        break;                 // Not enough space for even the reset code
      *dst++ = match_src[i++]; // ESC
      *dst++ = match_src[i++]; // '['
      *dst++ = match_src[i++]; // '0'
      *dst++ = match_src[i++]; // '0'
      *dst++ = match_src[i++]; // 'm'
      // Re-apply highlight background after reset (only if room)
      if (dst + 20 < dst_end) {
        uint8_t r3, g3, b3;
        get_highlight_color(&r3, &g3, &b3);
        dst = append_truecolor_bg(dst, r3, g3, b3);
      }
    } else {
      // Regular character - just copy
      if (dst + 1 >= dst_end) {
        break;
      }
      *dst++ = match_src[i++];
    }
  }
 
  // Reset only the background color to preserve foreground colors from headers
  // Using \x1b[49m (reset background only) instead of \x1b[0m (reset all)
  memcpy(dst, "\x1b[49m", 5);
  dst += 5;
 
  // Copy remaining text
  size_t remaining = colored_len - colored_end;
  if (remaining > 0) {
    memcpy(dst, colored_text + colored_end, remaining);
    dst += remaining;
  }
 
  *dst = '\0';
  return highlight_buffer;
}

References append_truecolor_bg(), asciichat_pcre2_singleton_get_code(), log_search_get_case_insensitive(), log_search_get_global_highlight(), log_search_get_input_buffer(), log_search_get_input_len(), log_search_get_pattern_singleton(), log_search_is_active(), SAFE_STRNCPY, grep_pattern_t::singleton, and utf8_strcasestr().

Referenced by grep_highlight_colored_copy(), and terminal_screen_render().

grep_highlight_colored_copy()

char * grep_highlight_colored_copy	(	const char *	colored_text,
		const char *	plain_text,
		size_t	match_start,
		size_t	match_len
	)

Highlight matches in colored text, returning a new allocated copy.

Like grep_highlight_colored() but returns a newly allocated string instead of a static buffer. Caller must free the returned string with SAFE_FREE().

Parameters

colored_text	Original text with ANSI color codes
plain_text	Stripped plain text (for match positions)
match_start	Match start position in plain text
match_len	Match length in plain text

Returns

Newly allocated highlighted text (caller must free), or NULL on error

Definition at line 741 of file grep.c.

                                                    {
  const char *result = grep_highlight_colored(colored_text, plain_text, match_start, match_len);
  if (result) {
    size_t result_len = strlen(result) + 1;
    char *copy = SAFE_MALLOC(result_len, char *);
    if (copy) {
      memcpy(copy, result, result_len);
      return copy;
    }
  }
  return NULL;
}

References grep_highlight_colored(), and SAFE_MALLOC.

grep_init()

asciichat_error_t grep_init

(

const char *

pattern

)

Initialize log filtering with PCRE2 regex pattern.

Compiles the pattern eagerly at startup. If compilation fails, logs a warning and disables filtering.

Parameters

pattern

PCRE2 regex pattern (NULL or empty = no filtering)

Returns

ASCIICHAT_OK on success, ERROR_INVALID_PARAM on bad regex

Definition at line 498 of file grep.c.

                                                 {
  // Reject NULL or empty patterns
  if (!pattern) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Pattern cannot be NULL");
  }
  if (strlen(pattern) == 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Pattern cannot be empty");
  }
 
  // Parse pattern
  parse_result_t parsed = grep_parse_pattern(pattern);
  if (!parsed.valid) {
    log_error("Invalid --grep pattern format: \"%s\"", pattern);
    log_error("Use /pattern/flags format (e.g., \"/query/ig\") or plain regex (e.g., \"query\")");
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid --grep pattern format");
  }
 
  // Allocate or expand pattern array
  if (g_filter_state.pattern_count >= g_filter_state.pattern_capacity) {
    int new_capacity = (g_filter_state.pattern_capacity == 0) ? 4 : g_filter_state.pattern_capacity * 2;
    grep_pattern_t *new_patterns =
        SAFE_REALLOC(g_filter_state.patterns, new_capacity * sizeof(grep_pattern_t), grep_pattern_t *);
    if (!new_patterns) {
      return SET_ERRNO(ERROR_MEMORY, "Failed to allocate pattern array");
    }
    g_filter_state.patterns = new_patterns;
    g_filter_state.pattern_capacity = new_capacity;
  }
 
  // Add new pattern
  grep_pattern_t *new_pat = &g_filter_state.patterns[g_filter_state.pattern_count];
  memset(new_pat, 0, sizeof(*new_pat));
 
  // Make a copy of the original pattern string (argv pointers may be deallocated)
  char *original_copy = SAFE_MALLOC(strlen(pattern) + 1, char *);
  if (!original_copy) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate original pattern string");
  }
  memcpy(original_copy, pattern, strlen(pattern) + 1);
  new_pat->original = original_copy;
 
  new_pat->parsed_pattern = SAFE_MALLOC(strlen(parsed.pattern) + 1, char *);
  if (!new_pat->parsed_pattern) {
    SAFE_FREE(original_copy);
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate pattern string");
  }
  memcpy(new_pat->parsed_pattern, parsed.pattern, strlen(parsed.pattern) + 1);
 
  new_pat->is_fixed_string = parsed.is_fixed_string;
  new_pat->case_insensitive = parsed.case_insensitive;
  new_pat->invert = parsed.invert;
  new_pat->global_flag = parsed.global_flag;
  new_pat->context_before = parsed.context_before;
  new_pat->context_after = parsed.context_after;
 
  // Compile regex (skip for fixed strings)
  if (!parsed.is_fixed_string) {
    new_pat->singleton = asciichat_pcre2_singleton_compile(parsed.pattern, parsed.pcre2_options);
    if (!new_pat->singleton) {
      SAFE_FREE(new_pat->parsed_pattern);
      return SET_ERRNO(ERROR_INVALID_PARAM, "Failed to compile regex pattern");
    }
 
    // Validate compilation
    pcre2_code *code = asciichat_pcre2_singleton_get_code(new_pat->singleton);
    if (!code) {
      SAFE_FREE(new_pat->parsed_pattern);
      return SET_ERRNO(ERROR_INVALID_PARAM, "Regex compilation failed");
    }
  }
 
  g_filter_state.pattern_count++;
 
  // Update context buffer size if needed
  if (parsed.context_before > g_filter_state.buffer_size) {
    // Reallocate line buffer
    char **new_buffer = SAFE_REALLOC(g_filter_state.line_buffer, parsed.context_before * sizeof(char *), char **);
    if (!new_buffer) {
      return SET_ERRNO(ERROR_MEMORY, "Failed to allocate context line buffer");
    }
    // Initialize new slots
    for (int i = g_filter_state.buffer_size; i < parsed.context_before; i++) {
      new_buffer[i] = NULL;
    }
    g_filter_state.line_buffer = new_buffer;
    g_filter_state.buffer_size = parsed.context_before;
  }
 
  // Update max context_after
  if (parsed.context_after > g_filter_state.max_context_after) {
    g_filter_state.max_context_after = parsed.context_after;
  }
 
  g_filter_state.enabled = true;
  log_info("Added --grep pattern #%d: %s", g_filter_state.pattern_count, pattern);
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, asciichat_pcre2_singleton_compile(), asciichat_pcre2_singleton_get_code(), grep_parse_result_t::case_insensitive, grep_pattern_t::case_insensitive, grep_parse_result_t::context_after, grep_pattern_t::context_after, grep_parse_result_t::context_before, grep_pattern_t::context_before, ERROR_INVALID_PARAM, ERROR_MEMORY, grep_parse_result_t::global_flag, grep_pattern_t::global_flag, grep_parse_pattern(), grep_parse_result_t::invert, grep_pattern_t::invert, grep_parse_result_t::is_fixed_string, grep_pattern_t::is_fixed_string, log_error, log_info, grep_pattern_t::original, grep_pattern_t::parsed_pattern, grep_parse_result_t::pattern, grep_parse_result_t::pcre2_options, SAFE_FREE, SAFE_MALLOC, SAFE_REALLOC, SET_ERRNO, grep_pattern_t::singleton, and grep_parse_result_t::valid.

Referenced by main().

grep_parse_pattern()

grep_parse_result_t grep_parse_pattern

(

const char *

input

)

Parse pattern in /pattern/flags format or plain regex format.

Supports two formats:

• Format 1: /pattern/flags (e.g., "/error/igC2")
• Format 2: plain pattern (e.g., "error")

Flags: i(case-insensitive), m(multiline), s(dotall), x(extended), g(global highlight), I(invert), F(fixed string), A<n>(after context), B<n>(before context), C<n>(both context)

Parameters

input

Input pattern string

Returns

Parsed result with pattern, flags, and validity

Parse pattern in /pattern/flags format or plain regex format.

Parameters

input

Input pattern string (either /pattern/flags, pattern/flags, or plain pattern)

Returns

Parse result with all extracted settings

Format 1 (with flags, explicit): /pattern/flags

• Pattern enclosed in forward slashes with optional flags
• Use F flag for fixed string (literal) matching

Format 2 (with flags, implicit): pattern/flags

• Interactive grep format (no leading slash, since / starts the grep command)
• Treats last slash as delimiter

Format 3 (plain regex): pattern

• Plain regex pattern without slashes or flags
• Treated as regex with default options (no flags)

Flags (formats 1 & 2):

• i: case-insensitive
• m: multiline mode (regex only)
• s: dotall mode (regex only)
• x: extended mode (regex only)
• g: global (highlight all matches)
• I: invert match (show non-matching lines)
• F: fixed string (literal match, no regex)
• A<n>: show n lines after match (e.g., A3)
• B<n>: show n lines before match (e.g., B2)
• C<n>: show n lines before and after match (e.g., C5)

Examples:

• "/test/" - Simple regex with slashes
• "test" - Plain regex without slashes
• "/query/i" - Case-insensitive regex
• "/test/F" - Fixed string match for "test"
• "/api/v1/users/F" - Fixed string match for "api/v1/users"
• "/ERROR/IA3" - Invert match + 3 lines after
• "/FATAL/B2A5F" - Fixed string, 2 before, 5 after
• "error|warn" - Plain regex with alternation
• "search/i" - Interactive grep: case-insensitive "search"
• "api/v1/users/F" - Interactive grep: fixed string match

Definition at line 351 of file grep.c.

                                                          {
  parse_result_t result = {0};
  result.pcre2_options = PCRE2_UTF | PCRE2_UCP; // Default: UTF-8 mode
 
  if (!input || strlen(input) == 0) {
    return result; // Invalid: empty pattern
  }
 
  size_t len = strlen(input);
  const char *closing_slash = NULL;
  const char *pattern_start = input;
 
  // Check if pattern uses /pattern/flags format (explicit)
  if (input[0] == '/') {
    // Format 1: /pattern/flags
    if (len < 3) {
      return result; // Invalid: too short for /pattern/ format
    }
 
    // Find closing slash - don't treat backslash as an escape character
    // (backslashes are regex escapes, not delimiter escapes)
    closing_slash = strchr(input + 1, '/');
    if (!closing_slash) {
      return result; // Invalid: missing closing /
    }
 
    pattern_start = input + 1;
  } else {
    // Check for pattern/flags format (implicit, no leading slash)
    // Find the last forward slash to use as delimiter
    closing_slash = strrchr(input, '/');
 
    const char *implicit_flags = closing_slash ? closing_slash + 1 : NULL;
    bool implicit_flags_valid = closing_slash && closing_slash > input && *implicit_flags != '\0';
    if (implicit_flags_valid) {
      for (const char *flag = implicit_flags; *flag; flag++) {
        if (!strchr("imsxgIF", *flag) && *flag != 'A' && *flag != 'B' && *flag != 'C' &&
            !(*flag >= '0' && *flag <= '9')) {
          implicit_flags_valid = false;
          break;
        }
      }
    }
 
    if (implicit_flags_valid) {
      // There's at least one slash (not at the beginning)
      // Try to parse as pattern/flags format
      pattern_start = input;
    } else {
      // No slash or slash at beginning - treat as plain pattern
      closing_slash = NULL;
    }
  }
 
  if (closing_slash) {
    // Extract pattern between start and closing slash
    size_t pattern_len = (size_t)(closing_slash - pattern_start);
    if (pattern_len == 0) {
      return result; // Invalid: empty pattern
    }
    if (pattern_len >= sizeof(result.pattern)) {
      pattern_len = sizeof(result.pattern) - 1;
    }
    memcpy(result.pattern, pattern_start, pattern_len);
    result.pattern[pattern_len] = '\0';
 
    // Parse flags after closing slash
    // First pass: check for F flag
    const char *flags = closing_slash + 1;
    bool has_F_flag = (strchr(flags, 'F') != NULL);
 
    // Parse all flags
    for (const char *p = flags; *p; p++) {
      char c = *p;
 
      // Single-character flags
      if (c == 'i') {
        result.pcre2_options |= PCRE2_CASELESS;
        result.case_insensitive = true;
      } else if (c == 'm') {
        result.pcre2_options |= PCRE2_MULTILINE;
      } else if (c == 's') {
        result.pcre2_options |= PCRE2_DOTALL;
      } else if (c == 'x') {
        result.pcre2_options |= PCRE2_EXTENDED;
      } else if (c == 'g') {
        result.global_flag = true;
      } else if (c == 'I') {
        result.invert = true;
      } else if (c == 'F') {
        result.is_fixed_string = true;
      }
      // Multi-character flags with integers
      else if (c == 'A') {
        p++; // Move to digits
        int num = 0;
        while (*p >= '0' && *p <= '9') {
          num = num * 10 + (*p - '0');
          p++;
        }
        p--;                                        // Back up one (for loop will increment)
        result.context_after = (num > 0) ? num : 1; // Default to 1 if no number
      } else if (c == 'B') {
        p++;
        int num = 0;
        while (*p >= '0' && *p <= '9') {
          num = num * 10 + (*p - '0');
          p++;
        }
        p--;
        result.context_before = (num > 0) ? num : 1;
      } else if (c == 'C') {
        p++;
        int num = 0;
        while (*p >= '0' && *p <= '9') {
          num = num * 10 + (*p - '0');
          p++;
        }
        p--;
        int ctx = (num > 0) ? num : 1;
        result.context_before = ctx;
        result.context_after = ctx;
      } else {
        // Invalid flag character - only error if not using F flag
        if (!has_F_flag) {
          return result; // Invalid
        }
        // Otherwise ignore invalid flags (they're part of the fixed string context)
      }
    }
  } else {
    // Format 3: Plain pattern without slashes (treat as regex, no flags)
    size_t pattern_len = len;
    if (pattern_len >= sizeof(result.pattern)) {
      pattern_len = sizeof(result.pattern) - 1;
    }
    memcpy(result.pattern, input, pattern_len);
    result.pattern[pattern_len] = '\0';
 
    // No flags for plain format - just use default options
    // (PCRE2_UTF | PCRE2_UCP already set at the top)
  }
 
  result.valid = true;
  return result;
}

References grep_parse_result_t::case_insensitive, grep_parse_result_t::context_after, grep_parse_result_t::context_before, grep_parse_result_t::global_flag, grep_parse_result_t::invert, grep_parse_result_t::is_fixed_string, grep_parse_result_t::pattern, grep_parse_result_t::pcre2_options, and grep_parse_result_t::valid.

Referenced by grep_init(), log_search_enter_mode(), log_search_exit_mode(), log_search_gather_and_filter_logs(), log_search_get_match_info(), log_search_handle_key(), and log_search_init().

grep_restore_patterns()

asciichat_error_t grep_restore_patterns

(

void

)

Restore previously saved filter patterns.

Restores filter patterns saved by grep_save_patterns(). Used by interactive grep when user cancels (Escape) to restore CLI –grep patterns.

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 1265 of file grep.c.

                                              {
  // Clear current patterns (but don't free the array)
  for (int i = 0; i < g_filter_state.pattern_count; i++) {
    SAFE_FREE(g_filter_state.patterns[i].parsed_pattern);
    g_filter_state.patterns[i].singleton = NULL;
  }
 
  // Ensure we have capacity for saved patterns
  if (g_filter_state.saved_pattern_count > g_filter_state.pattern_capacity) {
    grep_pattern_t *new_patterns = SAFE_REALLOC(
        g_filter_state.patterns, g_filter_state.saved_pattern_count * sizeof(grep_pattern_t), grep_pattern_t *);
    if (!new_patterns) {
      return SET_ERRNO(ERROR_MEMORY, "Failed to allocate pattern array for restore");
    }
    g_filter_state.patterns = new_patterns;
    g_filter_state.pattern_capacity = g_filter_state.saved_pattern_count;
  }
 
  // Restore patterns
  if (g_filter_state.saved_patterns) {
    for (int i = 0; i < g_filter_state.saved_pattern_count; i++) {
      grep_pattern_t *src = &g_filter_state.saved_patterns[i];
      grep_pattern_t *dst = &g_filter_state.patterns[i];
 
      // Copy pattern structure
      *dst = *src;
 
      // Deep copy parsed_pattern string
      dst->parsed_pattern = SAFE_MALLOC(strlen(src->parsed_pattern) + 1, char *);
      if (!dst->parsed_pattern) {
        // Clean up partial restore
        for (int j = 0; j < i; j++) {
          SAFE_FREE(g_filter_state.patterns[j].parsed_pattern);
        }
        g_filter_state.pattern_count = 0;
        return SET_ERRNO(ERROR_MEMORY, "Failed to restore pattern string");
      }
      memcpy(dst->parsed_pattern, src->parsed_pattern, strlen(src->parsed_pattern) + 1);
 
      // Singleton pointers are shared (reference counted)
      dst->singleton = src->singleton;
    }
  }
 
  g_filter_state.pattern_count = g_filter_state.saved_pattern_count;
  g_filter_state.enabled = g_filter_state.saved_enabled;
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_MEMORY, grep_pattern_t::parsed_pattern, SAFE_FREE, SAFE_MALLOC, SAFE_REALLOC, SET_ERRNO, and grep_pattern_t::singleton.

Referenced by log_search_exit_mode().

grep_save_patterns()

asciichat_error_t grep_save_patterns

(

void

)

Save current filter patterns for later restoration.

Saves the current state of CLI –grep patterns so they can be restored later. Used by interactive grep to preserve initial filters when entering interactive mode.

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 1215 of file grep.c.

                                           {
  // Free previous saved patterns if any
  if (g_filter_state.saved_patterns) {
    for (int i = 0; i < g_filter_state.saved_pattern_count; i++) {
      SAFE_FREE(g_filter_state.saved_patterns[i].parsed_pattern);
    }
    SAFE_FREE(g_filter_state.saved_patterns);
  }
 
  // Allocate saved pattern array
  if (g_filter_state.pattern_count > 0) {
    g_filter_state.saved_patterns =
        SAFE_MALLOC(g_filter_state.pattern_count * sizeof(grep_pattern_t), grep_pattern_t *);
    if (!g_filter_state.saved_patterns) {
      return SET_ERRNO(ERROR_MEMORY, "Failed to allocate saved pattern array");
    }
 
    // Deep copy all patterns
    for (int i = 0; i < g_filter_state.pattern_count; i++) {
      grep_pattern_t *src = &g_filter_state.patterns[i];
      grep_pattern_t *dst = &g_filter_state.saved_patterns[i];
 
      // Copy pattern structure
      *dst = *src;
 
      // Deep copy parsed_pattern string
      dst->parsed_pattern = SAFE_MALLOC(strlen(src->parsed_pattern) + 1, char *);
      if (!dst->parsed_pattern) {
        // Clean up partial save
        for (int j = 0; j < i; j++) {
          SAFE_FREE(g_filter_state.saved_patterns[j].parsed_pattern);
        }
        SAFE_FREE(g_filter_state.saved_patterns);
        g_filter_state.saved_patterns = NULL;
        return SET_ERRNO(ERROR_MEMORY, "Failed to save pattern string");
      }
      memcpy(dst->parsed_pattern, src->parsed_pattern, strlen(src->parsed_pattern) + 1);
 
      // Singleton pointers are shared (reference counted)
      dst->singleton = src->singleton;
    }
  }
 
  g_filter_state.saved_pattern_count = g_filter_state.pattern_count;
  g_filter_state.saved_pattern_capacity = g_filter_state.pattern_count;
  g_filter_state.saved_enabled = g_filter_state.enabled;
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_MEMORY, grep_pattern_t::parsed_pattern, SAFE_FREE, SAFE_MALLOC, SET_ERRNO, and grep_pattern_t::singleton.

Referenced by log_search_enter_mode().

grep_should_output()

bool grep_should_output	(	const char *	log_line,
		size_t *	match_start,
		size_t *	match_len
	)

Check if log line should be output (matches filter)

Thread-safe: Uses thread-local match_data storage. Non-allocating: Reuses pre-allocated match_data.

Parameters

log_line	Formatted log line to check
match_start	Output: start offset of match
match_len	Output: length of match

Returns

true if line should be output, false to suppress

Definition at line 597 of file grep.c.

                                                                                      {
  // Reject NULL lines
  if (!log_line) {
    if (match_start)
      *match_start = 0;
    if (match_len)
      *match_len = 0;
    return false;
  }
 
  // If filtering disabled, output everything
  if (!g_filter_state.enabled) {
    return true;
  }
 
  // Check if we're in "context after" mode (outputting lines after a match)
  if (g_filter_state.lines_after_match > 0) {
    g_filter_state.lines_after_match--;
    *match_start = 0;
    *match_len = 0;
 
    // Store in buffer even during context-after mode
    if (g_filter_state.buffer_size > 0) {
      SAFE_FREE(g_filter_state.line_buffer[g_filter_state.buffer_pos]);
      size_t line_len = strlen(log_line) + 1;
      g_filter_state.line_buffer[g_filter_state.buffer_pos] = SAFE_MALLOC(line_len, char *);
      if (g_filter_state.line_buffer[g_filter_state.buffer_pos]) {
        memcpy(g_filter_state.line_buffer[g_filter_state.buffer_pos], log_line, line_len);
      }
      g_filter_state.buffer_pos = (g_filter_state.buffer_pos + 1) % g_filter_state.buffer_size;
    }
 
    return true; // Output context line
  }
 
  pcre2_match_data *match_data = get_thread_match_data();
  size_t line_len = strlen(log_line);
 
  // Try each pattern (OR logic)
  bool any_match = false;
  grep_pattern_t *matched_pattern = NULL;
 
  for (int i = 0; i < g_filter_state.pattern_count; i++) {
    grep_pattern_t *pat = &g_filter_state.patterns[i];
    bool this_match = false;
 
    if (pat->is_fixed_string) {
      // Fixed string matching (with optional case-insensitive support)
      const char *found;
      if (pat->case_insensitive) {
        // Unicode-aware case-insensitive search
        found = utf8_strcasestr(log_line, pat->parsed_pattern);
      } else {
        // Case-sensitive search
        found = strstr(log_line, pat->parsed_pattern);
      }
 
      if (found) {
        this_match = true;
        if (!matched_pattern) {
          *match_start = (size_t)(found - log_line);
          *match_len = strlen(pat->parsed_pattern);
          matched_pattern = pat;
        }
      }
    } else {
      // Regex matching
      if (!match_data || !pat->singleton) {
        continue;
      }
 
      pcre2_code *code = asciichat_pcre2_singleton_get_code(pat->singleton);
      if (!code) {
        continue;
      }
 
      int rc = pcre2_jit_match(code, (PCRE2_SPTR)log_line, line_len, 0, 0, match_data, NULL);
      if (rc >= 0) {
        this_match = true;
        if (!matched_pattern) {
          PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(match_data);
          *match_start = (size_t)ovector[0];
          *match_len = (size_t)(ovector[1] - ovector[0]);
          matched_pattern = pat;
        }
      }
    }
 
    // Apply invert flag
    if (pat->invert) {
      this_match = !this_match;
    }
 
    if (this_match) {
      any_match = true;
      // Update matched_pattern if this one has more context
      if (!matched_pattern || (pat->context_before + pat->context_after) >
                                  (matched_pattern->context_before + matched_pattern->context_after)) {
        matched_pattern = pat;
      }
    }
  }
 
  // If any pattern matched
  if (any_match && matched_pattern) {
    // Output context_before lines from circular buffer
    if (matched_pattern->context_before > 0 && g_filter_state.buffer_size > 0) {
      int num_lines = (matched_pattern->context_before < g_filter_state.buffer_size) ? matched_pattern->context_before
                                                                                     : g_filter_state.buffer_size;
 
      // Calculate starting position in circular buffer
      int start_pos = (g_filter_state.buffer_pos - num_lines + g_filter_state.buffer_size) % g_filter_state.buffer_size;
 
      // Output buffered lines
      for (int i = 0; i < num_lines; i++) {
        int pos = (start_pos + i) % g_filter_state.buffer_size;
        if (g_filter_state.line_buffer[pos]) {
          fprintf(stderr, "%s\n", g_filter_state.line_buffer[pos]);
        }
      }
    }
 
    // Set up context_after counter
    if (matched_pattern->context_after > 0) {
      g_filter_state.lines_after_match = matched_pattern->context_after;
    }
 
    return true; // Match found, output line
  }
 
  // No match - store in context buffer for potential future use
  if (g_filter_state.buffer_size > 0) {
    SAFE_FREE(g_filter_state.line_buffer[g_filter_state.buffer_pos]);
    size_t line_len_copy = strlen(log_line) + 1;
    g_filter_state.line_buffer[g_filter_state.buffer_pos] = SAFE_MALLOC(line_len_copy, char *);
    if (g_filter_state.line_buffer[g_filter_state.buffer_pos]) {
      memcpy(g_filter_state.line_buffer[g_filter_state.buffer_pos], log_line, line_len_copy);
    }
    g_filter_state.buffer_pos = (g_filter_state.buffer_pos + 1) % g_filter_state.buffer_size;
  }
 
  return false; // No match, suppress line
}

References asciichat_pcre2_singleton_get_code(), grep_pattern_t::case_insensitive, grep_pattern_t::context_after, grep_pattern_t::context_before, grep_pattern_t::invert, grep_pattern_t::is_fixed_string, grep_pattern_t::parsed_pattern, SAFE_FREE, SAFE_MALLOC, grep_pattern_t::singleton, and utf8_strcasestr().