Data Structures
struct	interactive_grep_state_t

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

#define	GREP_INPUT_BUFFER_SIZE 256
	Input buffer size.

Functions
asciichat_error_t	interactive_grep_init (void)

void	interactive_grep_destroy (void)

void	interactive_grep_enter_mode (void)

void	interactive_grep_exit_mode (bool accept)

bool	interactive_grep_is_entering_atomic (void)

void	interactive_grep_signal_cancel (void)

bool	interactive_grep_check_signal_cancel (void)

bool	interactive_grep_is_entering (void)

bool	interactive_grep_is_active (void)

bool	interactive_grep_should_handle (int key)

asciichat_error_t	interactive_grep_handle_key (keyboard_key_t key)

asciichat_error_t	interactive_grep_gather_and_filter_logs (session_log_entry_t *out_entries, size_t out_count)

void	interactive_grep_render_input_line (int width)

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

bool	interactive_grep_needs_rerender (void)

bool	interactive_grep_get_global_highlight (void)

void *	interactive_grep_get_pattern_singleton (void)

void *	interactive_grep_get_mutex (void)

int	interactive_grep_get_input_len (void)

const char *	interactive_grep_get_input_buffer (void)

bool	interactive_grep_get_case_insensitive (void)

Macro Definition Documentation

◆ GREP_INPUT_BUFFER_SIZE

#define GREP_INPUT_BUFFER_SIZE 256

Input buffer size.

Definition at line 31 of file interactive_grep.c.

◆ MAX_GREP_PATTERNS

#define MAX_GREP_PATTERNS 32

Maximum number of patterns to support.

Definition at line 30 of file interactive_grep.c.

Function Documentation

◆ interactive_grep_check_signal_cancel()

bool interactive_grep_check_signal_cancel ( void )

Definition at line 381 of file interactive_grep.c.

                                                {
  return atomic_exchange(&g_grep_state.signal_cancelled, false);
}

References interactive_grep_state_t::signal_cancelled.

◆ interactive_grep_destroy()

void interactive_grep_destroy ( void )

Definition at line 193 of file interactive_grep.c.

                                    {
  mutex_lock(&g_grep_state.mutex);
 
  if (!g_grep_state.initialized) {
    mutex_unlock(&g_grep_state.mutex);
    return;
  }
 
  // Free active patterns
  for (int i = 0; i < g_grep_state.active_pattern_count; i++) {
    if (g_grep_state.active_patterns[i]) {
      // Note: pcre2_singleton handles its own reference counting
      g_grep_state.active_patterns[i] = NULL;
    }
  }
 
  g_grep_state.initialized = false;
 
  mutex_unlock(&g_grep_state.mutex);
}

References interactive_grep_state_t::active_pattern_count, interactive_grep_state_t::active_patterns, interactive_grep_state_t::initialized, and interactive_grep_state_t::mutex.

◆ interactive_grep_enter_mode()

void interactive_grep_enter_mode ( void )

Definition at line 218 of file interactive_grep.c.

                                       {
  mutex_lock(&g_grep_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_grep_state.input_buffer, 0, sizeof(g_grep_state.input_buffer));
  g_grep_state.len = 0;
  g_grep_state.cursor = 0;
 
  // Pre-populate with CLI --grep pattern if available (only once at startup)
  if (!g_grep_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_grep_state.input_buffer) - 1) {
        memcpy(g_grep_state.input_buffer, pattern_to_use, pattern_len + 1);
        g_grep_state.len = pattern_len;
        g_grep_state.cursor = pattern_len;
        g_grep_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_grep_state.input_buffer);
        if (parsed.valid) {
          // Store parsed flags
          g_grep_state.case_insensitive = parsed.case_insensitive;
          g_grep_state.fixed_string = parsed.is_fixed_string;
          g_grep_state.global_highlight = parsed.global_flag;
          g_grep_state.invert_match = parsed.invert;
          g_grep_state.context_before = parsed.context_before;
          g_grep_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_grep_state.active_patterns[0] = singleton;
                g_grep_state.active_pattern_count = 1;
              } else {
                g_grep_state.fixed_string = true;
              }
            } else {
              g_grep_state.fixed_string = true;
            }
          }
        }
      }
    }
  }
 
  // Enter input mode
  g_grep_state.mode = GREP_MODE_ENTERING;
  atomic_store(&g_grep_state.mode_atomic, GREP_MODE_ENTERING);
  atomic_store(&g_grep_state.needs_rerender, true);
 
  mutex_unlock(&g_grep_state.mutex);
}

Referenced by interactive_grep_handle_key(), server_status_display(), and server_status_display_interactive().

◆ interactive_grep_exit_mode()

void interactive_grep_exit_mode ( bool accept )

Definition at line 288 of file interactive_grep.c.

                                             {
  mutex_lock(&g_grep_state.mutex);
 
  if (g_grep_state.mode != GREP_MODE_ENTERING) {
    mutex_unlock(&g_grep_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_grep_state.active_pattern_count; i++) {
      g_grep_state.active_patterns[i] = NULL;
    }
    g_grep_state.active_pattern_count = 0;
 
    // Reset the CLI pattern auto-populated flag so user can re-enter grep mode with the pattern again
    g_grep_state.cli_pattern_auto_populated = false;
 
    g_grep_state.mode = GREP_MODE_INACTIVE;
    atomic_store(&g_grep_state.mode_atomic, GREP_MODE_INACTIVE);
    atomic_store(&g_grep_state.needs_rerender, true);
    mutex_unlock(&g_grep_state.mutex);
    return;
  }
 
  // Accept - parse and compile pattern
  grep_parse_result_t parsed = grep_parse_pattern(g_grep_state.input_buffer);
 
  if (!parsed.valid) {
    log_error("Invalid pattern format");
    mutex_unlock(&g_grep_state.mutex);
    return; // Stay in input mode
  }
 
  // Clear old regex patterns
  for (int i = 0; i < g_grep_state.active_pattern_count; i++) {
    g_grep_state.active_patterns[i] = NULL;
  }
  g_grep_state.active_pattern_count = 0;
 
  // Store parsed flags first
  g_grep_state.case_insensitive = parsed.case_insensitive;
  g_grep_state.fixed_string = parsed.is_fixed_string;
  g_grep_state.global_highlight = parsed.global_flag;
  g_grep_state.invert_match = parsed.invert;
  g_grep_state.context_before = parsed.context_before;
  g_grep_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_grep_state.active_patterns[0] = singleton;
        g_grep_state.active_pattern_count = 1;
      } else {
        // Compilation failed - fall back to fixed string matching
        g_grep_state.fixed_string = true; // Override to use fixed string instead
      }
    } else {
      // Malloc failed - fall back to fixed string
      g_grep_state.fixed_string = true;
    }
  }
  // For fixed strings, pattern stays in input_buffer and fixed_string=true
 
  g_grep_state.mode = GREP_MODE_ACTIVE;
  atomic_store(&g_grep_state.mode_atomic, GREP_MODE_ACTIVE);
  atomic_store(&g_grep_state.needs_rerender, true);
 
  mutex_unlock(&g_grep_state.mutex);
}

Referenced by interactive_grep_handle_key(), and server_status_display_interactive().

◆ interactive_grep_gather_and_filter_logs()

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

Definition at line 530 of file interactive_grep.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");
  }
 
  size_t buffer_count = session_log_buffer_get_recent(buffer_entries, SESSION_LOG_BUFFER_SIZE);
 
  // Check if filtering is active (either regex patterns or fixed string)
  mutex_lock(&g_grep_state.mutex);
  bool has_regex_patterns = (g_grep_state.active_pattern_count > 0);
  bool has_fixed_string = (g_grep_state.fixed_string && g_grep_state.len > 0);
  bool filtering_active = has_regex_patterns || has_fixed_string;
 
  if (!filtering_active) {
    // No filtering active - return all entries
    mutex_unlock(&g_grep_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_grep_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_grep_state.active_pattern_count; p++) {
    if (g_grep_state.active_patterns[p]) {
      pcre2_code *code = asciichat_pcre2_singleton_get_code(g_grep_state.active_patterns[p]);
      if (code) {
        match_data = pcre2_match_data_create_from_pattern(code, NULL);
        break;
      }
    }
  }
 
  if (!match_data && g_grep_state.active_pattern_count > 0) {
    // Couldn't create match data - fall back to returning all entries
    mutex_unlock(&g_grep_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_grep_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_grep_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_grep_state.active_pattern_count; p++) {
        pcre2_singleton_t *singleton = g_grep_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_grep_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_grep_state.mutex);
 
  SAFE_FREE(buffer_entries);
  *out_entries = filtered;
  *out_count = filtered_count;
  return ASCIICHAT_OK;
}

References interactive_grep_state_t::active_pattern_count, interactive_grep_state_t::active_patterns, asciichat_pcre2_singleton_get_code(), interactive_grep_state_t::case_insensitive, interactive_grep_state_t::fixed_string, grep_parse_pattern(), interactive_grep_state_t::input_buffer, interactive_grep_state_t::invert_match, interactive_grep_state_t::len, interactive_grep_state_t::mutex, session_log_buffer_get_recent(), and utf8_strcasestr().

Referenced by terminal_screen_render().

◆ interactive_grep_get_case_insensitive()

bool interactive_grep_get_case_insensitive ( void )

Definition at line 933 of file interactive_grep.c.

                                                 {
  return g_grep_state.case_insensitive;
}

References interactive_grep_state_t::case_insensitive.

Referenced by grep_highlight_colored().

◆ interactive_grep_get_global_highlight()

bool interactive_grep_get_global_highlight ( void )

Definition at line 881 of file interactive_grep.c.

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

References interactive_grep_state_t::global_highlight, interactive_grep_state_t::mode_atomic, and interactive_grep_state_t::mutex.

Referenced by grep_highlight_colored().

◆ interactive_grep_get_input_buffer()

const char * interactive_grep_get_input_buffer ( void )

Definition at line 929 of file interactive_grep.c.

                                                    {
  return g_grep_state.input_buffer;
}

References interactive_grep_state_t::input_buffer.

Referenced by grep_highlight_colored(), and terminal_screen_render().

◆ interactive_grep_get_input_len()

int interactive_grep_get_input_len ( void )

Definition at line 925 of file interactive_grep.c.

                                         {
  return (int)g_grep_state.len;
}

References interactive_grep_state_t::len.

Referenced by grep_highlight_colored(), and terminal_screen_render().

◆ interactive_grep_get_match_info()

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

Definition at line 714 of file interactive_grep.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(&g_grep_state.mode_atomic);
  if (mode == GREP_MODE_INACTIVE) {
    return false;
  }
 
  // Make a safe copy of state under mutex, then release before doing expensive work
  mutex_lock(&g_grep_state.mutex);
 
  bool has_fixed_string = g_grep_state.fixed_string && g_grep_state.len > 0;
  bool case_insensitive = g_grep_state.case_insensitive;
  char pattern_copy[GREP_INPUT_BUFFER_SIZE];
  size_t pattern_len = g_grep_state.len;
  int pattern_count = g_grep_state.active_pattern_count;
  pcre2_singleton_t *patterns_copy[MAX_GREP_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_grep_state.input_buffer);
    const char *src = parsed.valid ? parsed.pattern : g_grep_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_GREP_PATTERNS; i++) {
    patterns_copy[i] = g_grep_state.active_patterns[i];
  }
 
  mutex_unlock(&g_grep_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;
}

References interactive_grep_state_t::active_pattern_count, interactive_grep_state_t::active_patterns, asciichat_pcre2_singleton_get_code(), interactive_grep_state_t::case_insensitive, interactive_grep_state_t::fixed_string, GREP_INPUT_BUFFER_SIZE, grep_parse_pattern(), interactive_grep_state_t::input_buffer, interactive_grep_state_t::len, MAX_GREP_PATTERNS, interactive_grep_state_t::mode_atomic, interactive_grep_state_t::mutex, pattern_count, utf8_decode(), and utf8_strcasestr().

Referenced by terminal_screen_render().

◆ interactive_grep_get_mutex()

void * interactive_grep_get_mutex ( void )

Definition at line 921 of file interactive_grep.c.

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

References interactive_grep_state_t::mutex.

Referenced by terminal_screen_render().

◆ interactive_grep_get_pattern_singleton()

void * interactive_grep_get_pattern_singleton ( void )

Definition at line 896 of file interactive_grep.c.

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

References interactive_grep_state_t::active_pattern_count, interactive_grep_state_t::active_patterns, interactive_grep_state_t::fixed_string, interactive_grep_state_t::mode_atomic, and interactive_grep_state_t::mutex.

Referenced by grep_highlight_colored().

◆ interactive_grep_handle_key()

asciichat_error_t interactive_grep_handle_key ( keyboard_key_t key )

Definition at line 414 of file interactive_grep.c.

                                                                  {
  mutex_lock(&g_grep_state.mutex);
 
  // If not in input mode, check if user pressed '/'
  if (g_grep_state.mode != GREP_MODE_ENTERING) {
    mutex_unlock(&g_grep_state.mutex);
 
    // Check for '/' key (key already passed as parameter, don't read again!)
    if (key == '/') {
      interactive_grep_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 interactive_grep_gather_and_filter_logs().
  keyboard_line_edit_opts_t opts = {
      .buffer = g_grep_state.input_buffer,
      .max_len = sizeof(g_grep_state.input_buffer),
      .len = &g_grep_state.len,
      .cursor = &g_grep_state.cursor,
      .echo = false,                       // We handle rendering ourselves
      .mask_char = 0,                      // No masking
      .prefix = NULL,                      // Don't render prefix - interactive_grep_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_grep_state.mutex);
    interactive_grep_exit_mode(true); // Parse and accept pattern
    break;
  case LINE_EDIT_CANCELLED:
    // Unlock before exit_mode since it acquires the mutex
    mutex_unlock(&g_grep_state.mutex);
    interactive_grep_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_grep_state.len == 0) {
      g_grep_state.active_pattern_count = 0;
      mutex_unlock(&g_grep_state.mutex);
      atomic_store(&g_grep_state.needs_rerender, true);
      break;
    }
 
    // Parse and compile pattern for live filtering
    grep_parse_result_t parsed = grep_parse_pattern(g_grep_state.input_buffer);
 
    if (!parsed.valid) {
      // Invalid pattern - keep previous patterns active (don't clear)
      mutex_unlock(&g_grep_state.mutex);
      atomic_store(&g_grep_state.needs_rerender, true);
      break;
    }
 
    // Valid pattern - update filtering state
    if (parsed.is_fixed_string) {
      // Fixed string matching - no regex compilation needed
      g_grep_state.active_pattern_count = 0;
      g_grep_state.case_insensitive = parsed.case_insensitive;
      g_grep_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_grep_state.active_patterns[0] = singleton;
          g_grep_state.active_pattern_count = 1;
          g_grep_state.case_insensitive = parsed.case_insensitive;
          g_grep_state.fixed_string = false;
        } else {
          // Compilation failed - fall back to fixed string matching
          g_grep_state.active_pattern_count = 0;
          g_grep_state.fixed_string = true;
          g_grep_state.case_insensitive = parsed.case_insensitive;
        }
      } else {
        g_grep_state.active_pattern_count = 0;
        g_grep_state.fixed_string = true;
        g_grep_state.case_insensitive = parsed.case_insensitive;
      }
    }
 
    // Store parsed flags
    g_grep_state.global_highlight = parsed.global_flag;
    g_grep_state.invert_match = parsed.invert;
    g_grep_state.context_before = parsed.context_before;
    g_grep_state.context_after = parsed.context_after;
 
    mutex_unlock(&g_grep_state.mutex);
    atomic_store(&g_grep_state.needs_rerender, true);
    break;
  case LINE_EDIT_NO_INPUT:
    // No input available
    mutex_unlock(&g_grep_state.mutex);
    break;
  }
 
  return ASCIICHAT_OK;
}

Referenced by server_status_display_interactive(), and session_render_loop().

◆ interactive_grep_init()

asciichat_error_t interactive_grep_init ( void )

Definition at line 126 of file interactive_grep.c.

                                              {
  // Initialize mutex first (before any locking!)
  static bool mutex_inited = false;
  if (!mutex_inited) {
    mutex_init(&g_grep_state.mutex);
    mutex_inited = true;
  }
 
  mutex_lock(&g_grep_state.mutex);
 
  if (g_grep_state.initialized) {
    mutex_unlock(&g_grep_state.mutex);
    return ASCIICHAT_OK;
  }
 
  // Initialize state (careful not to destroy the mutex!)
  // Save the mutex before clearing state
  mutex_t saved_mutex = g_grep_state.mutex;
  memset(&g_grep_state, 0, sizeof(g_grep_state));
  // Restore the mutex
  g_grep_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_grep_state.mode = GREP_MODE_INACTIVE;
    atomic_store(&g_grep_state.mode_atomic, GREP_MODE_INACTIVE);
    g_grep_state.initialized = true;
    mutex_unlock(&g_grep_state.mutex);
    return ASCIICHAT_OK;
  }
 
  // Load CLI pattern into input buffer
  SAFE_STRNCPY(g_grep_state.input_buffer, cli_pattern, GREP_INPUT_BUFFER_SIZE - 1);
  g_grep_state.len = strlen(cli_pattern);
  g_grep_state.cursor = g_grep_state.len;
  g_grep_state.mode = GREP_MODE_ACTIVE;
  atomic_store(&g_grep_state.mode_atomic, GREP_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_grep_state.active_patterns[0] = singleton;
      g_grep_state.active_pattern_count = 1;
    }
    g_grep_state.case_insensitive = parsed.case_insensitive;
    g_grep_state.fixed_string = parsed.is_fixed_string;
    g_grep_state.global_highlight = parsed.global_flag;
    g_grep_state.invert_match = parsed.invert;
    g_grep_state.context_before = parsed.context_before;
    g_grep_state.context_after = parsed.context_after;
  }
 
  atomic_store(&g_grep_state.needs_rerender, true);
  g_grep_state.initialized = true;
 
  mutex_unlock(&g_grep_state.mutex);
  return ASCIICHAT_OK;
}

Referenced by server_main().

◆ interactive_grep_is_active()

bool interactive_grep_is_active ( void )

Definition at line 390 of file interactive_grep.c.

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

References interactive_grep_state_t::mode_atomic.

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

◆ interactive_grep_is_entering()

bool interactive_grep_is_entering ( void )

Definition at line 385 of file interactive_grep.c.

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

References interactive_grep_state_t::mode_atomic.

Referenced by terminal_screen_render().

◆ interactive_grep_is_entering_atomic()

bool interactive_grep_is_entering_atomic ( void )

Definition at line 373 of file interactive_grep.c.

                                               {
  return atomic_load(&g_grep_state.mode_atomic) == GREP_MODE_ENTERING;
}

References interactive_grep_state_t::mode_atomic.

◆ interactive_grep_needs_rerender()

bool interactive_grep_needs_rerender ( void )

Definition at line 869 of file interactive_grep.c.

                                           {
  bool needs = atomic_load(&g_grep_state.needs_rerender);
  if (needs) {
    atomic_store(&g_grep_state.needs_rerender, false);
  }
  return needs;
}

References interactive_grep_state_t::needs_rerender.

Referenced by terminal_screen_render().

◆ interactive_grep_render_input_line()

void interactive_grep_render_input_line ( int width )

Definition at line 690 of file interactive_grep.c.

                                                   {
  (void)width; // Reserved for future use (line truncation)
 
  mutex_lock(&g_grep_state.mutex);
 
  if (g_grep_state.mode != GREP_MODE_ENTERING) {
    mutex_unlock(&g_grep_state.mutex);
    return;
  }
 
  // Just show slash and pattern (cursor already positioned by caller)
  char output_buf[256];
  int len = snprintf(output_buf, sizeof(output_buf), "/%.*s", (int)g_grep_state.len, g_grep_state.input_buffer);
  if (len > 0) {
    platform_write_all(STDOUT_FILENO, output_buf, len);
  }
 
  mutex_unlock(&g_grep_state.mutex);
}

References interactive_grep_state_t::input_buffer, interactive_grep_state_t::len, interactive_grep_state_t::mode, interactive_grep_state_t::mutex, and platform_write_all().

Referenced by terminal_screen_render().

◆ interactive_grep_should_handle()

bool interactive_grep_should_handle ( int key )

Definition at line 399 of file interactive_grep.c.

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

References interactive_grep_state_t::mode, and interactive_grep_state_t::mutex.

Referenced by server_status_display_interactive(), and session_render_loop().

◆ interactive_grep_signal_cancel()

void interactive_grep_signal_cancel ( void )

Definition at line 377 of file interactive_grep.c.

                                          {
  atomic_store(&g_grep_state.signal_cancelled, true);
}

References interactive_grep_state_t::signal_cancelled.

Data Structures

Macros

Functions

Macro Definition Documentation

◆ GREP_INPUT_BUFFER_SIZE

◆ MAX_GREP_PATTERNS

Function Documentation

◆ interactive_grep_check_signal_cancel()

◆ interactive_grep_destroy()

◆ interactive_grep_enter_mode()

◆ interactive_grep_exit_mode()

◆ interactive_grep_gather_and_filter_logs()

◆ interactive_grep_get_case_insensitive()

◆ interactive_grep_get_global_highlight()

◆ interactive_grep_get_input_buffer()

◆ interactive_grep_get_input_len()

◆ interactive_grep_get_match_info()

◆ interactive_grep_get_mutex()

◆ interactive_grep_get_pattern_singleton()

◆ interactive_grep_handle_key()

◆ interactive_grep_init()

◆ interactive_grep_is_active()

◆ interactive_grep_is_entering()

◆ interactive_grep_is_entering_atomic()

◆ interactive_grep_needs_rerender()

◆ interactive_grep_render_input_line()

◆ interactive_grep_should_handle()

◆ interactive_grep_signal_cancel()