Interactive search filtering implementation. More...

Data Structures
struct	log_search_state_t

Macros
#define	MAX_LOG_SEARCH_PATTERNS 32
	Maximum number of patterns to support.

#define	LOG_SEARCH_INPUT_BUFFER_SIZE 256
	Input buffer size.

Functions
asciichat_error_t	log_search_init (void)
	Initialize interactive grep subsystem.

void	log_search_destroy (void)
	Clean up interactive grep subsystem.

void	log_search_enter_mode (void)
	Enter search mode (user pressed '/')

void	log_search_exit_mode (bool accept)
	Exit search mode.

bool	log_search_is_entering_atomic (void)
	Check if grep is in entering mode (async-signal-safe)

void	log_search_signal_cancel (void)
	Cancel grep mode from a signal handler (async-signal-safe)

bool	log_search_check_signal_cancel (void)
	Check and clear the signal-cancel flag.

bool	log_search_is_entering (void)
	Check if currently in input mode (typing pattern)

bool	log_search_is_active (void)
	Check if filtering is active.

bool	log_search_should_handle (int key)
	Check if a key should be handled by grep module.

asciichat_error_t	log_search_handle_key (keyboard_key_t key)
	Process keyboard input for grep.

asciichat_error_t	log_search_gather_and_filter_logs (session_log_entry_t *out_entries, size_t out_count)
	Gather and filter logs for display.

void	log_search_render_input_line (int width)
	Render grep input line at bottom of screen.

bool	log_search_get_match_info (const char message, size_t out_match_start, size_t *out_match_len)
	Get match info for highlighting a log message.

bool	log_search_needs_rerender (void)
	Check if screen needs immediate re-render.

bool	log_search_get_global_highlight (void)
	Check if global highlighting (/g flag) is enabled in current pattern.

void *	log_search_get_pattern_singleton (void)
	Get the compiled regex pattern for interactive grep (internal use)

void *	log_search_get_mutex (void)
	Get the mutex protecting grep state.

int	log_search_get_input_len (void)
	Get current input buffer length (must hold mutex)

int	log_search_get_cursor_position (void)
	Get current cursor position in input buffer (must hold mutex)

const char *	log_search_get_input_buffer (void)
	Get current input buffer content (must hold mutex)

bool	log_search_get_case_insensitive (void)
	Check if case-insensitive flag is set (must hold mutex)

Detailed Description

Interactive search filtering implementation.

Implements vim-style / search functionality for terminal screens. Supports full /pattern/flags syntax with real-time filtering.

Definition in file search.c.

Macro Definition Documentation

◆ LOG_SEARCH_INPUT_BUFFER_SIZE

#define LOG_SEARCH_INPUT_BUFFER_SIZE 256

Input buffer size.

Definition at line 33 of file search.c.

◆ MAX_LOG_SEARCH_PATTERNS

#define MAX_LOG_SEARCH_PATTERNS 32

Maximum number of patterns to support.

Definition at line 32 of file search.c.

Function Documentation

◆ log_search_check_signal_cancel()

bool log_search_check_signal_cancel ( void )

Check and clear the signal-cancel flag.

Returns: true if grep was cancelled by a signal since last check

Called by the status screen loop to detect signal-initiated cancellation.

Definition at line 380 of file search.c.

                                          {
  bool expected = true;
  return atomic_cas_bool(&g_search_state.signal_cancelled, &expected, false);
}

References atomic_cas_bool(), and log_search_state_t::signal_cancelled.

◆ log_search_destroy()

void log_search_destroy ( void )

Clean up interactive grep subsystem.

Frees all allocated resources. Safe to call multiple times.

Definition at line 192 of file search.c.

                              {
  if (!lifecycle_shutdown(&g_log_search_lifecycle)) {
    return; // Already shut down or never initialized
  }
 
  mutex_lock(&g_search_state.mutex);
 
  // Free active patterns
  for (int i = 0; i < g_search_state.active_pattern_count; i++) {
    if (g_search_state.active_patterns[i]) {
      // Note: pcre2_singleton handles its own reference counting
      g_search_state.active_patterns[i] = NULL;
    }
  }
 
  mutex_unlock(&g_search_state.mutex);
}

References log_search_state_t::active_pattern_count, log_search_state_t::active_patterns, lifecycle_shutdown(), log_search_state_t::mutex, mutex_lock, and mutex_unlock.

◆ log_search_enter_mode()

void log_search_enter_mode ( void )

Enter search mode (user pressed '/')

Saves current CLI –grep patterns, activates input mode, and prepares for interactive pattern entry.

Definition at line 214 of file search.c.

                                 {
  // Ensure cursor is visible for user typing
  (void)terminal_cursor_show();
 
  mutex_lock(&g_search_state.mutex);
 
  // Save current patterns (CLI --grep patterns)
  asciichat_error_t result = grep_save_patterns();
  if (result != ASCIICHAT_OK) {
    log_warn("Failed to save filter patterns");
  }
 
  // Clear input buffer
  memset(g_search_state.input_buffer, 0, sizeof(g_search_state.input_buffer));
  g_search_state.len = 0;
  g_search_state.cursor = 0;
 
  // Pre-populate with CLI --grep pattern if available (only once at startup)
  if (!g_search_state.cli_pattern_auto_populated) {
    const char *cli_pattern = grep_get_last_pattern();
    if (cli_pattern && cli_pattern[0] != '\0') {
      // Skip leading slash if present (prompt already shows "/")
      const char *pattern_to_use = cli_pattern;
      if (cli_pattern[0] == '/') {
        pattern_to_use = cli_pattern + 1;
      }
 
      size_t pattern_len = strlen(pattern_to_use);
      if (pattern_len < sizeof(g_search_state.input_buffer) - 1) {
        memcpy(g_search_state.input_buffer, pattern_to_use, pattern_len + 1);
        g_search_state.len = pattern_len;
        g_search_state.cursor = pattern_len;
        g_search_state.cli_pattern_auto_populated = true;
 
        // Compile and apply the pattern immediately so it starts filtering
        grep_parse_result_t parsed = grep_parse_pattern(g_search_state.input_buffer);
        if (parsed.valid) {
          // Store parsed flags
          g_search_state.case_insensitive = parsed.case_insensitive;
          g_search_state.fixed_string = parsed.is_fixed_string;
          g_search_state.global_highlight = parsed.global_flag;
          g_search_state.invert_match = parsed.invert;
          g_search_state.context_before = parsed.context_before;
          g_search_state.context_after = parsed.context_after;
 
          // Compile pattern if not fixed string
          if (strlen(parsed.pattern) > 0 && !parsed.is_fixed_string) {
            pcre2_singleton_t *singleton = asciichat_pcre2_singleton_compile(parsed.pattern, parsed.pcre2_options);
            if (singleton) {
              pcre2_code *code = asciichat_pcre2_singleton_get_code(singleton);
              if (code) {
                g_search_state.active_patterns[0] = singleton;
                g_search_state.active_pattern_count = 1;
              } else {
                g_search_state.fixed_string = true;
              }
            } else {
              g_search_state.fixed_string = true;
            }
          }
        }
      }
    }
  }
 
  // Enter input mode
  g_search_state.mode = LOG_SEARCH_MODE_ENTERING;
  atomic_store_int(&g_search_state.mode_atomic, LOG_SEARCH_MODE_ENTERING);
  atomic_store_bool(&g_search_state.needs_rerender, true);
 
  mutex_unlock(&g_search_state.mutex);
}

Referenced by log_search_handle_key(), ui_status_display(), and ui_status_display_interactive().

◆ log_search_exit_mode()

void log_search_exit_mode ( bool accept )

Exit search mode.

Parameters

accept If true, compile and activate typed pattern; if false, restore previous patterns

If accepting: Parses pattern with /pattern/flags syntax, compiles with PCRE2, and activates filtering. If canceling: Restores CLI –grep patterns.

Definition at line 287 of file search.c.

                                       {
  mutex_lock(&g_search_state.mutex);
 
  if (g_search_state.mode != LOG_SEARCH_MODE_ENTERING) {
    mutex_unlock(&g_search_state.mutex);
    return;
  }
 
  if (!accept) {
    // Cancel - restore previous patterns and reset CLI pattern flag so user can re-populate
    asciichat_error_t result = grep_restore_patterns();
    if (result != ASCIICHAT_OK) {
      log_warn("Failed to restore filter patterns");
    }
 
    // Clear interactive grep patterns
    for (int i = 0; i < g_search_state.active_pattern_count; i++) {
      g_search_state.active_patterns[i] = NULL;
    }
    g_search_state.active_pattern_count = 0;
 
    // Reset the CLI pattern auto-populated flag so user can re-enter grep mode with the pattern again
    g_search_state.cli_pattern_auto_populated = false;
 
    g_search_state.mode = LOG_SEARCH_MODE_INACTIVE;
    atomic_store_int(&g_search_state.mode_atomic, LOG_SEARCH_MODE_INACTIVE);
    atomic_store_bool(&g_search_state.needs_rerender, true);
    mutex_unlock(&g_search_state.mutex);
    return;
  }
 
  // Accept - parse and compile pattern
  grep_parse_result_t parsed = grep_parse_pattern(g_search_state.input_buffer);
 
  if (!parsed.valid) {
    log_error("Invalid pattern format");
    mutex_unlock(&g_search_state.mutex);
    return; // Stay in input mode
  }
 
  // Clear old regex patterns
  for (int i = 0; i < g_search_state.active_pattern_count; i++) {
    g_search_state.active_patterns[i] = NULL;
  }
  g_search_state.active_pattern_count = 0;
 
  // Store parsed flags first
  g_search_state.case_insensitive = parsed.case_insensitive;
  g_search_state.fixed_string = parsed.is_fixed_string;
  g_search_state.global_highlight = parsed.global_flag;
  g_search_state.invert_match = parsed.invert;
  g_search_state.context_before = parsed.context_before;
  g_search_state.context_after = parsed.context_after;
 
  // Compile and store new pattern (if not fixed string)
  if (strlen(parsed.pattern) > 0 && !parsed.is_fixed_string) {
    pcre2_singleton_t *singleton = asciichat_pcre2_singleton_compile(parsed.pattern, parsed.pcre2_options);
    if (singleton) {
      // Verify the pattern actually compiles
      pcre2_code *code = asciichat_pcre2_singleton_get_code(singleton);
      if (code) {
        g_search_state.active_patterns[0] = singleton;
        g_search_state.active_pattern_count = 1;
      } else {
        // Compilation failed - fall back to fixed string matching
        g_search_state.fixed_string = true; // Override to use fixed string instead
      }
    } else {
      // Malloc failed - fall back to fixed string
      g_search_state.fixed_string = true;
    }
  }
  // For fixed strings, pattern stays in input_buffer and fixed_string=true
 
  g_search_state.mode = LOG_SEARCH_MODE_ACTIVE;
  atomic_store_int(&g_search_state.mode_atomic, LOG_SEARCH_MODE_ACTIVE);
  atomic_store_bool(&g_search_state.needs_rerender, true);
 
  mutex_unlock(&g_search_state.mutex);
}

Referenced by log_search_handle_key(), and ui_status_display_interactive().

◆ log_search_gather_and_filter_logs()

asciichat_error_t log_search_gather_and_filter_logs	(	session_log_entry_t **	out_entries,
		size_t *	out_count
	)

Gather and filter logs for display.

Parameters

out_entries	Output array of filtered log entries (caller must free with SAFE_FREE)
out_count	Output count of filtered entries

Returns: ASCIICHAT_OK on success, error code on failure

Hybrid approach:

If –log-file specified: tail last N KB, parse entries
Fetch entries from in-memory session_log_buffer (up to 100 entries)
Merge and deduplicate by timestamp
Filter combined set with active PCRE2 patterns
Return filtered entries (caller must free)

If no log file or read error: Falls back to in-memory buffer only.

Definition at line 530 of file search.c.

                                                                                                          {
  if (!out_entries || !out_count) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "out_entries and out_count must not be NULL");
  }
 
  // Get logs from in-memory buffer
  session_log_entry_t *buffer_entries =
      SAFE_MALLOC(SESSION_LOG_BUFFER_SIZE * sizeof(session_log_entry_t), session_log_entry_t *);
  if (!buffer_entries) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate log buffer");
  }
 
  session_log_buffer_t *log_buf = log_get_session_log_buffer();
  size_t buffer_count = session_log_buffer_get_recent(log_buf, buffer_entries, SESSION_LOG_BUFFER_SIZE);
 
  // Check if filtering is active (either regex patterns or fixed string)
  mutex_lock(&g_search_state.mutex);
  bool has_regex_patterns = (g_search_state.active_pattern_count > 0);
  bool has_fixed_string = (g_search_state.fixed_string && g_search_state.len > 0);
  bool filtering_active = has_regex_patterns || has_fixed_string;
 
  if (!filtering_active) {
    // No filtering active - return all entries
    mutex_unlock(&g_search_state.mutex);
    *out_entries = buffer_entries;
    *out_count = buffer_count;
    return ASCIICHAT_OK;
  }
 
  // Filter entries with PCRE2
  session_log_entry_t *filtered =
      SAFE_MALLOC(SESSION_LOG_BUFFER_SIZE * sizeof(session_log_entry_t), session_log_entry_t *);
  if (!filtered) {
    mutex_unlock(&g_search_state.mutex);
    SAFE_FREE(buffer_entries);
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate filtered buffer");
  }
 
  size_t filtered_count = 0;
 
  // Create match data for PCRE2 matching
  pcre2_match_data *match_data = NULL;
  for (int p = 0; p < g_search_state.active_pattern_count; p++) {
    if (g_search_state.active_patterns[p]) {
      pcre2_code *code = asciichat_pcre2_singleton_get_code(g_search_state.active_patterns[p]);
      if (code) {
        match_data = pcre2_match_data_create_from_pattern(code, NULL);
        break;
      }
    }
  }
 
  if (!match_data && g_search_state.active_pattern_count > 0) {
    // Couldn't create match data - fall back to returning all entries
    mutex_unlock(&g_search_state.mutex);
    SAFE_FREE(filtered);
    *out_entries = buffer_entries;
    *out_count = buffer_count;
    return ASCIICHAT_OK;
  }
 
  // Parse pattern once before loop (for fixed string mode)
  grep_parse_result_t parsed = {0};
  if (has_fixed_string) {
    parsed = grep_parse_pattern(g_search_state.input_buffer);
  }
 
  for (size_t i = 0; i < buffer_count; i++) {
    const char *original_message = buffer_entries[i].message;
    bool matches = false;
 
    // Strip ANSI codes to match against plain text (consistent with highlighting)
    char plain_message[SESSION_LOG_LINE_MAX] = {0};
    const char *strip_ansi_codes_fn(const char *src, char *dst, size_t dst_size);
    // Use inline stripping to avoid function call overhead
    {
      size_t pos = 0;
      const char *src = original_message;
      char *dst = plain_message;
      size_t dst_size = sizeof(plain_message);
 
      while (*src && pos < dst_size - 1) {
        if (*src == '\x1b' && src[1] != '\0' && src[1] == '[') {
          // CSI sequence - skip until final byte
          src += 2;
          while (*src && pos < dst_size - 1 && !(*src >= 0x40 && *src <= 0x7E)) {
            src++;
          }
          if (*src)
            src++; // Skip final byte
        } else {
          dst[pos++] = *src++;
        }
      }
      dst[pos] = '\0';
    }
 
    size_t message_len = strlen(plain_message);
 
    // Fixed string matching
    if (has_fixed_string) {
      const char *search_pattern = parsed.pattern;
 
      if (g_search_state.case_insensitive) {
        // Unicode-aware case-insensitive fixed string search
        matches = (utf8_strcasestr(plain_message, search_pattern) != NULL);
      } else {
        // Case-sensitive fixed string search
        matches = (strstr(plain_message, search_pattern) != NULL);
      }
    }
    // Regex pattern matching
    else if (has_regex_patterns) {
      // Check against all active patterns (OR logic)
      for (int p = 0; p < g_search_state.active_pattern_count; p++) {
        pcre2_singleton_t *singleton = g_search_state.active_patterns[p];
        if (!singleton) {
          continue;
        }
 
        pcre2_code *code = asciichat_pcre2_singleton_get_code(singleton);
        if (!code) {
          continue;
        }
 
        // Match against plain message (without ANSI codes)
        int rc = pcre2_jit_match(code, (PCRE2_SPTR)plain_message, message_len, 0, 0, match_data, NULL);
        if (rc >= 0) {
          matches = true;
          break;
        }
      }
    }
 
    // Apply invert logic
    if (g_search_state.invert_match) {
      matches = !matches;
    }
 
    if (matches) {
      filtered[filtered_count++] = buffer_entries[i];
    }
  }
 
  // Free match data
  if (match_data) {
    pcre2_match_data_free(match_data);
  }
 
  mutex_unlock(&g_search_state.mutex);
 
  SAFE_FREE(buffer_entries);
  *out_entries = filtered;
  *out_count = filtered_count;
  return ASCIICHAT_OK;
}

Referenced by terminal_screen_render().

◆ log_search_get_case_insensitive()

bool log_search_get_case_insensitive ( void )

Check if case-insensitive flag is set (must hold mutex)

Returns: true if /i flag is set, false otherwise

Must be called while holding the mutex from log_search_get_mutex().

Definition at line 952 of file search.c.

                                           {
  return g_search_state.case_insensitive;
}

References log_search_state_t::case_insensitive.

Referenced by grep_highlight_colored().

◆ log_search_get_cursor_position()

int log_search_get_cursor_position ( void )

Get current cursor position in input buffer (must hold mutex)

Returns: Cursor position (0-based index within input buffer)

Must be called while holding the mutex from log_search_get_mutex().

Definition at line 944 of file search.c.

                                         {
  return (int)g_search_state.cursor;
}

References log_search_state_t::cursor.

Referenced by terminal_screen_render().

◆ log_search_get_global_highlight()

bool log_search_get_global_highlight ( void )

Check if global highlighting (/g flag) is enabled in current pattern.

Returns: true if interactive grep is active and /g flag is set, false otherwise

Used by filter highlighting code to determine if all matches should be highlighted or just the first match. Returns false when interactive grep is inactive.

Definition at line 896 of file search.c.

                                           {
  // Use atomic read to avoid mutex contention with keyboard handler
  int mode = atomic_load_int(&g_search_state.mode_atomic);
  if (mode == LOG_SEARCH_MODE_INACTIVE) {
    return false;
  }
 
  // Safe read under mutex (quick operation)
  mutex_lock(&g_search_state.mutex);
  bool result = g_search_state.global_highlight;
  mutex_unlock(&g_search_state.mutex);
 
  return result;
}

References atomic_load_int(), log_search_state_t::global_highlight, LOG_SEARCH_MODE_INACTIVE, log_search_state_t::mode_atomic, log_search_state_t::mutex, mutex_lock, and mutex_unlock.

Referenced by grep_highlight_colored().

◆ log_search_get_input_buffer()

const char * log_search_get_input_buffer ( void )

Get current input buffer content (must hold mutex)

Returns: Pointer to the input buffer (valid only while holding mutex)

Must be called while holding the mutex from log_search_get_mutex().

Definition at line 948 of file search.c.

                                              {
  return g_search_state.input_buffer;
}

References log_search_state_t::input_buffer.

Referenced by grep_highlight_colored(), and terminal_screen_render().

◆ log_search_get_input_len()

int log_search_get_input_len ( void )

Get current input buffer length (must hold mutex)

Returns: Length of the current grep input pattern

Must be called while holding the mutex from log_search_get_mutex().

Definition at line 940 of file search.c.

                                   {
  return (int)g_search_state.len;
}

References log_search_state_t::len.

Referenced by grep_highlight_colored(), and terminal_screen_render().

◆ log_search_get_match_info()

bool log_search_get_match_info	(	const char *	message,
		size_t *	out_match_start,
		size_t *	out_match_len
	)

Get match info for highlighting a log message.

Parameters

message	Log message to check
out_match_start	Output: start position of match in plain text
out_match_len	Output: length of match

Returns: true if message matches current filter pattern, false otherwise

Used by display code to apply highlighting to matching portions of logs. Returns match position for use with log_filter_highlight().

Definition at line 729 of file search.c.

                                                                                                    {
  if (!message || !out_match_start || !out_match_len) {
    return false;
  }
 
  *out_match_start = 0;
  *out_match_len = 0;
 
  // Use atomic read to avoid mutex contention with keyboard handler
  int mode = atomic_load_int(&g_search_state.mode_atomic);
  if (mode == LOG_SEARCH_MODE_INACTIVE) {
    return false;
  }
 
  // Make a safe copy of state under mutex, then release before doing expensive work
  mutex_lock(&g_search_state.mutex);
 
  bool has_fixed_string = g_search_state.fixed_string && g_search_state.len > 0;
  bool case_insensitive = g_search_state.case_insensitive;
  char pattern_copy[LOG_SEARCH_INPUT_BUFFER_SIZE];
  size_t pattern_len = g_search_state.len;
  int pattern_count = g_search_state.active_pattern_count;
  pcre2_singleton_t *patterns_copy[MAX_LOG_SEARCH_PATTERNS];
 
  if (has_fixed_string) {
    // Parse the input buffer to extract just the pattern part (without flags)
    grep_parse_result_t parsed = grep_parse_pattern(g_search_state.input_buffer);
    const char *src = parsed.valid ? parsed.pattern : g_search_state.input_buffer;
    SAFE_STRNCPY(pattern_copy, src, sizeof(pattern_copy) - 1);
    pattern_copy[sizeof(pattern_copy) - 1] = '\0';
    pattern_len = strlen(pattern_copy); // Update pattern_len for the actual parsed pattern
  }
 
  for (int i = 0; i < pattern_count && i < MAX_LOG_SEARCH_PATTERNS; i++) {
    patterns_copy[i] = g_search_state.active_patterns[i];
  }
 
  mutex_unlock(&g_search_state.mutex);
 
  // Now do matching without holding mutex
  size_t message_len = strlen(message);
  bool matches = false;
 
  // Fixed string matching
  if (has_fixed_string) {
    const char *found = NULL;
 
    if (case_insensitive) {
      found = utf8_strcasestr(message, pattern_copy);
    } else {
      found = strstr(message, pattern_copy);
    }
 
    if (found) {
      matches = true;
 
      // Convert byte position to character position (UTF-8 aware)
      size_t byte_pos = (size_t)(found - message);
      size_t char_pos = 0;
      for (size_t i = 0; i < byte_pos && message[i] != '\0';) {
        uint32_t codepoint;
        int utf8_len = utf8_decode((const uint8_t *)(message + i), &codepoint);
        if (utf8_len <= 0)
          utf8_len = 1;
        i += utf8_len;
        char_pos++;
      }
 
      // Count characters in the match (pattern_len is in bytes for the pattern)
      size_t match_char_len = 0;
      for (size_t i = 0; i < pattern_len && found[i] != '\0';) {
        uint32_t codepoint;
        int utf8_len = utf8_decode((const uint8_t *)(found + i), &codepoint);
        if (utf8_len <= 0)
          utf8_len = 1;
        i += utf8_len;
        match_char_len++;
      }
 
      *out_match_start = char_pos;
      *out_match_len = match_char_len;
    }
  }
  // Regex pattern matching
  else if (pattern_count > 0) {
    pcre2_match_data *match_data = NULL;
    for (int p = 0; p < pattern_count; p++) {
      if (patterns_copy[p]) {
        pcre2_code *code = asciichat_pcre2_singleton_get_code(patterns_copy[p]);
        if (code) {
          match_data = pcre2_match_data_create_from_pattern(code, NULL);
          break;
        }
      }
    }
 
    if (match_data) {
      for (int p = 0; p < pattern_count; p++) {
        pcre2_singleton_t *singleton = patterns_copy[p];
        if (!singleton) {
          continue;
        }
 
        pcre2_code *code = asciichat_pcre2_singleton_get_code(singleton);
        if (!code) {
          continue;
        }
 
        int rc = pcre2_jit_match(code, (PCRE2_SPTR)message, message_len, 0, 0, match_data, NULL);
        if (rc >= 0) {
          matches = true;
          PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(match_data);
 
          // Convert byte positions to character positions (UTF-8 aware)
          size_t byte_start = (size_t)ovector[0];
          size_t byte_end = (size_t)ovector[1];
 
          // Count characters up to byte_start
          size_t char_start = 0;
          for (size_t i = 0; i < byte_start && message[i] != '\0';) {
            uint32_t codepoint;
            int utf8_len = utf8_decode((const uint8_t *)(message + i), &codepoint);
            if (utf8_len <= 0)
              utf8_len = 1;
            i += utf8_len;
            char_start++;
          }
 
          // Count characters up to byte_end
          size_t char_end = char_start;
          for (size_t i = byte_start; i < byte_end && message[i] != '\0';) {
            uint32_t codepoint;
            int utf8_len = utf8_decode((const uint8_t *)(message + i), &codepoint);
            if (utf8_len <= 0)
              utf8_len = 1;
            i += utf8_len;
            char_end++;
          }
 
          *out_match_start = char_start;
          *out_match_len = char_end - char_start;
          break;
        }
      }
      pcre2_match_data_free(match_data);
    }
  }
 
  return matches;
}

Referenced by terminal_screen_render().

◆ log_search_get_mutex()

void * log_search_get_mutex ( void )

Get the mutex protecting grep state.

Returns: Pointer to the grep state mutex (internal use only)

Used by terminal rendering to perform atomic read of grep input for consistent rendering without flicker.

Definition at line 936 of file search.c.

                                 {
  return (void *)&g_search_state.mutex;
}

References log_search_state_t::mutex.

Referenced by terminal_screen_render().

◆ log_search_get_pattern_singleton()

void * log_search_get_pattern_singleton ( void )

Get the compiled regex pattern for interactive grep (internal use)

Returns: Opaque PCRE2 singleton for the current pattern, or NULL if inactive/no pattern

Internal function used by filter highlighting code to enable global match highlighting in interactive grep mode. Returns NULL when not in active mode or if pattern is fixed string type (no regex compilation).

Definition at line 911 of file search.c.

                                             {
  // Use atomic read to check if active
  int mode = atomic_load_int(&g_search_state.mode_atomic);
  if (mode == LOG_SEARCH_MODE_INACTIVE) {
    return NULL;
  }
 
  // Safe read under mutex
  mutex_lock(&g_search_state.mutex);
 
  // Return the compiled pattern if we have one (not fixed string)
  void *result = NULL;
  if (g_search_state.active_pattern_count > 0 && !g_search_state.fixed_string) {
    result = (void *)g_search_state.active_patterns[0];
  }
 
  mutex_unlock(&g_search_state.mutex);
 
  return result;
}

References log_search_state_t::active_pattern_count, log_search_state_t::active_patterns, atomic_load_int(), log_search_state_t::fixed_string, LOG_SEARCH_MODE_INACTIVE, log_search_state_t::mode_atomic, log_search_state_t::mutex, mutex_lock, and mutex_unlock.

Referenced by grep_highlight_colored().

◆ log_search_handle_key()

asciichat_error_t log_search_handle_key ( keyboard_key_t key )

Process keyboard input for grep.

Parameters

key	The keyboard key to process

Returns: ASCIICHAT_OK on success, error code on failure

Uses keyboard_read_line_interactive() to handle text editing. Supports backspace, delete, arrows, home, end, enter, escape, UTF-8.

Pattern validation happens live via validator callback. Enter compiles and activates pattern. Escape cancels and restores previous patterns.

Definition at line 414 of file search.c.

                                                            {
  mutex_lock(&g_search_state.mutex);
 
  // If not in input mode, check if user pressed '/'
  if (g_search_state.mode != LOG_SEARCH_MODE_ENTERING) {
    mutex_unlock(&g_search_state.mutex);
 
    // Check for '/' key (key already passed as parameter, don't read again!)
    if (key == '/') {
      log_search_enter_mode();
    }
    return ASCIICHAT_OK;
  }
 
  // In input mode - use keyboard_read_line_interactive()
  // CRITICAL: Keep mutex held during keyboard_read_line_interactive() to prevent races
  // with the rendering thread. The validator callback and buffer modifications must be
  // synchronized with readers in log_search_gather_and_filter_logs().
  keyboard_line_edit_opts_t opts = {
      .buffer = g_search_state.input_buffer,
      .max_len = sizeof(g_search_state.input_buffer),
      .len = &g_search_state.len,
      .cursor = &g_search_state.cursor,
      .echo = false,                       // We handle rendering ourselves
      .mask_char = 0,                      // No masking
      .prefix = NULL,                      // Don't render prefix - log_search_render_input_line() handles it
      .validator = validate_pcre2_pattern, // Live validation
      .key = key                           // Pass the pre-read key
  };
 
  keyboard_line_edit_result_t result = keyboard_read_line_interactive(&opts);
 
  switch (result) {
  case LINE_EDIT_ACCEPTED:
    // Unlock before exit_mode since it acquires the mutex
    mutex_unlock(&g_search_state.mutex);
    log_search_exit_mode(true); // Parse and accept pattern
    break;
  case LINE_EDIT_CANCELLED:
    // Unlock before exit_mode since it acquires the mutex
    mutex_unlock(&g_search_state.mutex);
    log_search_exit_mode(false); // Restore previous
    break;
  case LINE_EDIT_CONTINUE:
    // Still editing - compile pattern for live filtering
    // Mutex is still held here
 
    // If buffer is empty, clear patterns to show all logs (don't exit grep mode)
    if (g_search_state.len == 0) {
      g_search_state.active_pattern_count = 0;
      mutex_unlock(&g_search_state.mutex);
      atomic_store_bool(&g_search_state.needs_rerender, true);
      break;
    }
 
    // Parse and compile pattern for live filtering
    grep_parse_result_t parsed = grep_parse_pattern(g_search_state.input_buffer);
 
    if (!parsed.valid) {
      // Invalid pattern - keep previous patterns active (don't clear)
      mutex_unlock(&g_search_state.mutex);
      atomic_store_bool(&g_search_state.needs_rerender, true);
      break;
    }
 
    // Valid pattern - update filtering state
    if (parsed.is_fixed_string) {
      // Fixed string matching - no regex compilation needed
      g_search_state.active_pattern_count = 0;
      g_search_state.case_insensitive = parsed.case_insensitive;
      g_search_state.fixed_string = true;
    } else {
      // Regex pattern - compile with full pcre2_options
      pcre2_singleton_t *singleton = asciichat_pcre2_singleton_compile(parsed.pattern, parsed.pcre2_options);
      if (singleton) {
        pcre2_code *code = asciichat_pcre2_singleton_get_code(singleton);
        if (code) {
          g_search_state.active_patterns[0] = singleton;
          g_search_state.active_pattern_count = 1;
          g_search_state.case_insensitive = parsed.case_insensitive;
          g_search_state.fixed_string = false;
        } else {
          // Compilation failed - fall back to fixed string matching
          g_search_state.active_pattern_count = 0;
          g_search_state.fixed_string = true;
          g_search_state.case_insensitive = parsed.case_insensitive;
        }
      } else {
        g_search_state.active_pattern_count = 0;
        g_search_state.fixed_string = true;
        g_search_state.case_insensitive = parsed.case_insensitive;
      }
    }
 
    // Store parsed flags
    g_search_state.global_highlight = parsed.global_flag;
    g_search_state.invert_match = parsed.invert;
    g_search_state.context_before = parsed.context_before;
    g_search_state.context_after = parsed.context_after;
 
    mutex_unlock(&g_search_state.mutex);
    atomic_store_bool(&g_search_state.needs_rerender, true);
    break;
  case LINE_EDIT_NO_INPUT:
    // No input available
    mutex_unlock(&g_search_state.mutex);
    break;
  }
 
  return ASCIICHAT_OK;
}

Referenced by session_render_loop(), and ui_status_display_interactive().

◆ log_search_init()

asciichat_error_t log_search_init ( void )

Initialize interactive grep subsystem.

Returns: ASCIICHAT_OK on success, error code on failure

Must be called before using any other log_search functions. Initializes state, mutex, and loads CLI –grep patterns if any.

Definition at line 125 of file search.c.

                                        {
  // Use lifecycle API for unified initialization
  if (!lifecycle_init_once(&g_log_search_lifecycle)) {
    // Already initialized, acquire mutex lock and return
    mutex_lock(&g_search_state.mutex);
    return ASCIICHAT_OK;
  }
 
  // Winner of init_once - initialize mutex and state
  g_log_search_lifecycle.sync_type = LIFECYCLE_SYNC_MUTEX;
  g_log_search_lifecycle.sync.mutex = &g_search_state.mutex;
  lifecycle_init(&g_log_search_lifecycle, "log_search");
 
  mutex_lock(&g_search_state.mutex);
 
  // Initialize state (careful not to destroy the mutex!)
  // Save the mutex before clearing state
  mutex_t saved_mutex = g_search_state.mutex;
  memset(&g_search_state, 0, sizeof(g_search_state));
  // Restore the mutex
  g_search_state.mutex = saved_mutex;
 
  // Check if there are CLI --grep patterns to use
  const char *cli_pattern = grep_get_last_pattern();
 
  // Start in INACTIVE mode if no CLI pattern is provided.
  // Only use patterns from CLI --grep arguments, not default patterns.
  // This ensures logs are visible by default and only filtered if explicitly requested.
  if (!cli_pattern || cli_pattern[0] == '\0') {
    // No CLI pattern - start inactive
    g_search_state.mode = LOG_SEARCH_MODE_INACTIVE;
    atomic_store_int(&g_search_state.mode_atomic, LOG_SEARCH_MODE_INACTIVE);
    lifecycle_init_commit(&g_log_search_lifecycle);
    mutex_unlock(&g_search_state.mutex);
    return ASCIICHAT_OK;
  }
 
  // Load CLI pattern into input buffer
  SAFE_STRNCPY(g_search_state.input_buffer, cli_pattern, LOG_SEARCH_INPUT_BUFFER_SIZE - 1);
  g_search_state.len = strlen(cli_pattern);
  g_search_state.cursor = g_search_state.len;
  g_search_state.mode = LOG_SEARCH_MODE_ACTIVE;
  atomic_store_int(&g_search_state.mode_atomic, LOG_SEARCH_MODE_ACTIVE);
 
  // Compile the initial pattern
  grep_parse_result_t parsed = grep_parse_pattern(cli_pattern);
  if (parsed.valid) {
    pcre2_singleton_t *singleton = asciichat_pcre2_singleton_compile(parsed.pattern, parsed.pcre2_options);
    if (singleton) {
      g_search_state.active_patterns[0] = singleton;
      g_search_state.active_pattern_count = 1;
    }
    g_search_state.case_insensitive = parsed.case_insensitive;
    g_search_state.fixed_string = parsed.is_fixed_string;
    g_search_state.global_highlight = parsed.global_flag;
    g_search_state.invert_match = parsed.invert;
    g_search_state.context_before = parsed.context_before;
    g_search_state.context_after = parsed.context_after;
  }
 
  atomic_store_bool(&g_search_state.needs_rerender, true);
  lifecycle_init_commit(&g_log_search_lifecycle);
 
  mutex_unlock(&g_search_state.mutex);
  return ASCIICHAT_OK;
}

◆ log_search_is_active()

bool log_search_is_active ( void )

Check if filtering is active.

Returns: true if in GREP_MODE_ENTERING or GREP_MODE_ACTIVE, false if INACTIVE

Definition at line 390 of file search.c.

                                {
  // Use atomic read (async-signal-safe) to avoid mutex issues when called from signal handlers
  return atomic_load_int(&g_search_state.mode_atomic) != LOG_SEARCH_MODE_INACTIVE;
}

References atomic_load_int(), LOG_SEARCH_MODE_INACTIVE, and log_search_state_t::mode_atomic.

Referenced by grep_highlight_colored(), terminal_screen_render(), and ui_status_display_interactive().

◆ log_search_is_entering()

bool log_search_is_entering ( void )

Check if currently in input mode (typing pattern)

Returns: true if in GREP_MODE_ENTERING, false otherwise

Definition at line 385 of file search.c.

                                  {
  // Use atomic read (async-signal-safe) to avoid mutex issues when called from signal handlers
  return atomic_load_int(&g_search_state.mode_atomic) == LOG_SEARCH_MODE_ENTERING;
}

References atomic_load_int(), LOG_SEARCH_MODE_ENTERING, and log_search_state_t::mode_atomic.

Referenced by terminal_screen_render().

◆ log_search_is_entering_atomic()

bool log_search_is_entering_atomic ( void )

Check if grep is in entering mode (async-signal-safe)

Returns: true if in GREP_MODE_ENTERING

Uses atomic load only (no mutex). Safe to call from signal handlers.

Definition at line 372 of file search.c.

                                         {
  return atomic_load_int(&g_search_state.mode_atomic) == LOG_SEARCH_MODE_ENTERING;
}

References atomic_load_int(), LOG_SEARCH_MODE_ENTERING, and log_search_state_t::mode_atomic.

◆ log_search_needs_rerender()

bool log_search_needs_rerender ( void )

Check if screen needs immediate re-render.

Returns: true if pattern changed and re-render needed, false otherwise

Uses atomic flag for lock-free checking in render loops. Automatically clears flag after returning true.

Definition at line 884 of file search.c.

                                     {
  bool needs = atomic_load_bool(&g_search_state.needs_rerender);
  if (needs) {
    atomic_store_bool(&g_search_state.needs_rerender, false);
  }
  return needs;
}

References atomic_load_bool(), atomic_store_bool(), and log_search_state_t::needs_rerender.

Referenced by terminal_screen_render().

◆ log_search_render_input_line()

void log_search_render_input_line ( int width )

Render grep input line at bottom of screen.

Parameters

width Terminal width in columns

Renders: /<pattern>/flags█ with cursor position indicated. Cursor shown as block character or with background color.

If pattern is invalid (validator returns false), shows red background.

Definition at line 691 of file search.c.

                                             {
  (void)width; // Reserved for future use (line truncation)
 
  mutex_lock(&g_search_state.mutex);
 
  if (g_search_state.mode != LOG_SEARCH_MODE_ENTERING) {
    mutex_unlock(&g_search_state.mutex);
    return;
  }
 
  // Render the pattern and position terminal cursor at current edit position
  char output_buf[512];
 
  // Build output: "/" + pattern
  int pattern_len =
      snprintf(output_buf, sizeof(output_buf), "/%.*s", (int)g_search_state.len, g_search_state.input_buffer);
 
  if (pattern_len > 0 && pattern_len < (int)sizeof(output_buf)) {
    // Write the pattern to terminal
    platform_write_all(STDOUT_FILENO, output_buf, pattern_len);
 
    // After writing, cursor is at: column = 1 (for "/") + len + 1
    // We want it at: column = 1 (for "/") + cursor_position + 1
    // So we need to move back by: len - cursor_position columns
    int cursor_offset = (int)g_search_state.len - (int)g_search_state.cursor;
    if (cursor_offset > 0) {
      // Move left by the difference
      terminal_move_cursor_relative(-cursor_offset);
    }
  }
 
  mutex_unlock(&g_search_state.mutex);
}

References log_search_state_t::cursor, log_search_state_t::input_buffer, log_search_state_t::len, LOG_SEARCH_MODE_ENTERING, log_search_state_t::mode, log_search_state_t::mutex, mutex_lock, mutex_unlock, platform_write_all(), and terminal_move_cursor_relative().

Referenced by terminal_screen_render().

◆ log_search_should_handle()

bool log_search_should_handle ( int key )

Check if a key should be handled by grep module.

Parameters

key	Keyboard key code

Returns: true if grep should handle this key, false to pass through

Returns true for:

'/' when not in input mode (to enter mode)
All keys when in GREP_MODE_ENTERING (to edit pattern)

Definition at line 399 of file search.c.

                                       {
  mutex_lock(&g_search_state.mutex);
 
  // If in input mode, handle all keys
  if (g_search_state.mode == LOG_SEARCH_MODE_ENTERING) {
    mutex_unlock(&g_search_state.mutex);
    return true;
  }
 
  // If not in input mode, only handle '/' to enter mode
  bool should_handle = (key == '/');
  mutex_unlock(&g_search_state.mutex);
  return should_handle;
}

References LOG_SEARCH_MODE_ENTERING, log_search_state_t::mode, log_search_state_t::mutex, mutex_lock, and mutex_unlock.

Referenced by session_render_loop(), and ui_status_display_interactive().

◆ log_search_signal_cancel()

void log_search_signal_cancel ( void )

Cancel grep mode from a signal handler (async-signal-safe)

Sets an atomic flag that the status screen loop checks on its next iteration. Does not use mutexes or allocate memory.

Definition at line 376 of file search.c.

                                    {
  atomic_store_bool(&g_search_state.signal_cancelled, true);
}

References atomic_store_bool(), and log_search_state_t::signal_cancelled.

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ LOG_SEARCH_INPUT_BUFFER_SIZE

◆ MAX_LOG_SEARCH_PATTERNS

Function Documentation

◆ log_search_check_signal_cancel()

◆ log_search_destroy()

◆ log_search_enter_mode()

◆ log_search_exit_mode()

◆ log_search_gather_and_filter_logs()

◆ log_search_get_case_insensitive()

◆ log_search_get_cursor_position()

◆ log_search_get_global_highlight()

◆ log_search_get_input_buffer()

◆ log_search_get_input_len()

◆ log_search_get_match_info()

◆ log_search_get_mutex()

◆ log_search_get_pattern_singleton()

◆ log_search_handle_key()

◆ log_search_init()

◆ log_search_is_active()

◆ log_search_is_entering()

◆ log_search_is_entering_atomic()

◆ log_search_needs_rerender()

◆ log_search_render_input_line()

◆ log_search_should_handle()

◆ log_search_signal_cancel()