Parse a pattern API

Prototype for a function to parse a pattern. More...

Functions
static bool	eat_regex (struct Pattern *pat, PatternCompFlags flags, struct Buffer *s, struct Buffer *err)
	Parse a regex - Implements eat_arg_t -.
static bool	eat_query (struct Pattern *pat, PatternCompFlags flags, struct Buffer *s, struct Buffer *err, struct Mailbox *m)
	Parse a query for an external search program - Implements eat_arg_t -.
static bool	eat_range (struct Pattern *pat, PatternCompFlags flags, struct Buffer *s, struct Buffer *err)
	Parse a number range - Implements eat_arg_t -.
static bool	eat_date (struct Pattern *pat, PatternCompFlags flags, struct Buffer *s, struct Buffer *err)
	Parse a date pattern - Implements eat_arg_t -.
bool	eat_message_range (struct Pattern *pat, PatternCompFlags flags, struct Buffer *s, struct Buffer *err, struct MailboxView *mv)
	Parse a range of message numbers - Implements eat_arg_t -.

Detailed Description

Prototype for a function to parse a pattern.

Parameters

pat	Pattern to store the results in
flags	Flags, e.g. MUTT_PC_PATTERN_DYNAMIC
s	String to parse
err	Buffer for error messages

Return values

true	The pattern was read successfully

Function Documentation

eat_regex()

static bool eat_regex ( struct Pattern *  pat, PatternCompFlags  flags, struct Buffer *  s, struct Buffer *  err  )

static

Parse a regex - Implements eat_arg_t -.

Definition at line 66 of file compile.c.

{
  struct Buffer *buf = buf_pool_get();
  bool rc = false;
  char *pexpr = s->dptr;
  if ((parse_extract_token(buf, s, TOKEN_PATTERN | TOKEN_COMMENT) != 0) || !buf->data)
  {
    buf_printf(err, _("Error in expression: %s"), pexpr);
    goto out;
  }
  if (buf_is_empty(buf))
  {
    buf_addstr(err, _("Empty expression"));
    goto out;
  }
 
  if (pat->string_match)
  {
    pat->p.str = mutt_str_dup(buf->data);
    pat->ign_case = mutt_mb_is_lower(buf->data);
  }
  else if (pat->group_match)
  {
    pat->p.group = mutt_pattern_group(buf->data);
  }
  else
  {
    pat->p.regex = MUTT_MEM_CALLOC(1, regex_t);
#ifdef USE_DEBUG_GRAPHVIZ
    pat->raw_pattern = mutt_str_dup(buf->data);
#endif
    uint16_t case_flags = mutt_mb_is_lower(buf->data) ? REG_ICASE : 0;
    int rc2 = REG_COMP(pat->p.regex, buf->data, REG_NEWLINE | REG_NOSUB | case_flags);
    if (rc2 != 0)
    {
      char errmsg[256] = { 0 };
      regerror(rc2, pat->p.regex, errmsg, sizeof(errmsg));
      buf_printf(err, "'%s': %s", buf->data, errmsg);
      FREE(&pat->p.regex);
      goto out;
    }
  }
 
  rc = true;
 
out:
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eat_query()

static bool eat_query ( struct Pattern *  pat, PatternCompFlags  flags, struct Buffer *  s, struct Buffer *  err, struct Mailbox *  m  )

static

Parse a query for an external search program - Implements eat_arg_t -.

Parameters

pat	Pattern to store the results in
flags	Flags, e.g. MUTT_PC_PATTERN_DYNAMIC
s	String to parse
err	Buffer for error messages
m	Mailbox

Return values

true	The pattern was read successfully

Definition at line 141 of file compile.c.

{
  struct Buffer *cmd_buf = buf_pool_get();
  struct Buffer *tok_buf = buf_pool_get();
  bool rc = false;
 
  FILE *fp = NULL;
 
  const char *const c_external_search_command = cs_subset_string(NeoMutt->sub, "external_search_command");
  if (!c_external_search_command)
  {
    buf_addstr(err, _("No search command defined"));
    goto out;
  }
 
  char *pexpr = s->dptr;
  if ((parse_extract_token(tok_buf, s, TOKEN_PATTERN | TOKEN_COMMENT) != 0) ||
      !tok_buf->data)
  {
    buf_printf(err, _("Error in expression: %s"), pexpr);
    goto out;
  }
  if (*tok_buf->data == '\0')
  {
    buf_addstr(err, _("Empty expression"));
    goto out;
  }
 
  buf_addstr(cmd_buf, c_external_search_command);
  buf_addch(cmd_buf, ' ');
 
  if (m)
  {
    char *escaped_folder = mutt_path_escape(mailbox_path(m));
    mutt_debug(LL_DEBUG2, "escaped folder path: %s\n", escaped_folder);
    buf_addch(cmd_buf, '\'');
    buf_addstr(cmd_buf, escaped_folder);
    buf_addch(cmd_buf, '\'');
  }
  else
  {
    buf_addch(cmd_buf, '/');
  }
  buf_addch(cmd_buf, ' ');
  buf_addstr(cmd_buf, tok_buf->data);
 
  mutt_message(_("Running search command: %s ..."), cmd_buf->data);
  pat->is_multi = true;
  mutt_list_clear(&pat->p.multi_cases);
  pid_t pid = filter_create(cmd_buf->data, NULL, &fp, NULL, NeoMutt->env);
  if (pid < 0)
  {
    buf_printf(err, "unable to fork command: %s\n", cmd_buf->data);
    goto out;
  }
 
  mutt_file_map_lines(add_query_msgid, &pat->p.multi_cases, fp, MUTT_RL_NO_FLAGS);
  mutt_file_fclose(&fp);
  filter_wait(pid);
 
  rc = true;
 
out:
  buf_pool_release(&cmd_buf);
  buf_pool_release(&tok_buf);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eat_range()

static bool eat_range ( struct Pattern *  pat, PatternCompFlags  flags, struct Buffer *  s, struct Buffer *  err  )

static

Parse a number range - Implements eat_arg_t -.

Definition at line 622 of file compile.c.

{
  char *tmp = NULL;
  bool do_exclusive = false;
  bool skip_quote = false;
 
  /* If simple_search is set to "~m %s", the range will have double quotes
   * around it...  */
  if (*s->dptr == '"')
  {
    s->dptr++;
    skip_quote = true;
  }
  if (*s->dptr == '<')
    do_exclusive = true;
  if ((*s->dptr != '-') && (*s->dptr != '<'))
  {
    /* range minimum */
    if (*s->dptr == '>')
    {
      pat->max = MUTT_MAXRANGE;
      pat->min = strtol(s->dptr + 1, &tmp, 0) + 1; /* exclusive range */
    }
    else
    {
      pat->min = strtol(s->dptr, &tmp, 0);
    }
    if (mutt_toupper(*tmp) == 'K') /* is there a prefix? */
    {
      pat->min *= 1024;
      tmp++;
    }
    else if (mutt_toupper(*tmp) == 'M')
    {
      pat->min *= 1048576;
      tmp++;
    }
    if (*s->dptr == '>')
    {
      s->dptr = tmp;
      return true;
    }
    if (*tmp != '-')
    {
      /* exact value */
      pat->max = pat->min;
      s->dptr = tmp;
      return true;
    }
    tmp++;
  }
  else
  {
    s->dptr++;
    tmp = s->dptr;
  }
 
  if (mutt_isdigit(*tmp))
  {
    /* range maximum */
    pat->max = strtol(tmp, &tmp, 0);
    if (mutt_toupper(*tmp) == 'K')
    {
      pat->max *= 1024;
      tmp++;
    }
    else if (mutt_toupper(*tmp) == 'M')
    {
      pat->max *= 1048576;
      tmp++;
    }
    if (do_exclusive)
      (pat->max)--;
  }
  else
  {
    pat->max = MUTT_MAXRANGE;
  }
 
  if (skip_quote && (*tmp == '"'))
    tmp++;
 
  SKIPWS(tmp);
  s->dptr = tmp;
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eat_date()

static bool eat_date ( struct Pattern *  pat, PatternCompFlags  flags, struct Buffer *  s, struct Buffer *  err  )

static

Parse a date pattern - Implements eat_arg_t -.

Definition at line 713 of file compile.c.

{
  struct Buffer *tmp = buf_pool_get();
  bool rc = false;
 
  char *pexpr = s->dptr;
  if (parse_extract_token(tmp, s, TOKEN_COMMENT | TOKEN_PATTERN) != 0)
  {
    buf_printf(err, _("Error in expression: %s"), pexpr);
    goto out;
  }
 
  if (buf_is_empty(tmp))
  {
    buf_addstr(err, _("Empty expression"));
    goto out;
  }
 
  if (flags & MUTT_PC_PATTERN_DYNAMIC)
  {
    pat->dynamic = true;
    pat->p.str = mutt_str_dup(tmp->data);
  }
 
  rc = eval_date_minmax(pat, tmp->data, err);
 
out:
  buf_pool_release(&tmp);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eat_message_range()

bool eat_message_range	(	struct Pattern *	pat,
		PatternCompFlags	flags,
		struct Buffer *	s,
		struct Buffer *	err,
		struct MailboxView *	mv
	)

Parse a range of message numbers - Implements eat_arg_t -.

Parameters

pat	Pattern to store the results in
flags	Flags, e.g. MUTT_PC_PATTERN_DYNAMIC
s	String to parse
err	Buffer for error messages
mv	Mailbox view

Return values

true	The pattern was read successfully

Definition at line 281 of file message.c.

{
  if (!mv || !mv->mailbox || !mv->menu)
  {
    // We need these for pretty much anything
    buf_strcpy(err, _("No mailbox is open"));
    return false;
  }
 
  bool skip_quote = false;
 
  /* If simple_search is set to "~m %s", the range will have double quotes
   * around it...  */
  if (*s->dptr == '"')
  {
    s->dptr++;
    skip_quote = true;
  }
 
  for (int i_kind = 0; i_kind != RANGE_K_INVALID; i_kind++)
  {
    switch (eat_range_by_regex(pat, s, i_kind, err, mv))
    {
      case RANGE_E_MVIEW:
        /* This means it matched syntactically but lacked context.
         * No point in continuing. */
        break;
      case RANGE_E_SYNTAX:
        /* Try another syntax, then */
        continue;
      case RANGE_E_OK:
        if (skip_quote && (*s->dptr == '"'))
          s->dptr++;
        SKIPWS(s->dptr);
        return true;
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function: