message.c File Reference

Pattern handling for messages. More...

#include "config.h"
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include "private.h"
#include "mutt/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "lib.h"
#include "menu/lib.h"
#include "module_data.h"

Include dependency graph for message.c:

Go to the source code of this file.

Macros
#define	KILO   1024
	1024 bytes (1 kibibyte)
#define	MEGA   1048576
	1048576 bytes (1 mebibyte)

Enumerations
enum	EatRangeError { RANGE_E_OK , RANGE_E_SYNTAX , RANGE_E_MVIEW }
	Error codes for eat_range_by_regex(). More...

Functions
static int	report_regerror (int regerr, regex_t *preg, struct Buffer *err)
	Create a regex error message.
static bool	is_menu_available (struct Buffer *s, regmatch_t pmatch[], int kind, struct Buffer *err, const struct Menu *menu)
	Do we need a MailboxView for this Pattern?
static int	scan_range_num (struct Buffer *s, regmatch_t pmatch[], int group, int kind, struct MailboxView *mv)
	Parse a number range.
static int	scan_range_slot (struct Buffer *s, regmatch_t pmatch[], int grp, int side, int kind, struct MailboxView *mv)
	Parse a range of message numbers.
static void	order_range (struct Pattern *pat)
	Put a range in order.
static int	eat_range_by_regex (struct Pattern *pat, struct Buffer *s, int kind, struct Buffer *err, struct MailboxView *mv)
	Parse a range given as a regex.
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

Pattern handling for messages.

Authors

• Richard Russon
• Thomas Klausner

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file message.c.

Macro Definition Documentation

KILO

#define KILO   1024

1024 bytes (1 kibibyte)

Definition at line 42 of file message.c.

MEGA

#define MEGA   1048576

1048576 bytes (1 mebibyte)

Definition at line 43 of file message.c.

Enumeration Type Documentation

EatRangeError

enum EatRangeError

Error codes for eat_range_by_regex().

Enumerator
RANGE_E_OK	Range is valid.
RANGE_E_SYNTAX	Range contains syntax error.
RANGE_E_MVIEW	Range requires MailboxView, but none available.

Definition at line 48 of file message.c.

{
  RANGE_E_OK,     
  RANGE_E_SYNTAX, 
  RANGE_E_MVIEW,  
};

Function Documentation

report_regerror()

int report_regerror ( int regerr, regex_t * preg, struct Buffer * err )

static

Create a regex error message.

Parameters

regerr	Regex error code
preg	Regex pattern buffer
err	Buffer for error messages

Return values

RANGE_E_SYNTAX

Always

Definition at line 62 of file message.c.

{
  size_t ds = err->dsize;
 
  if (regerror(regerr, preg, err->data, ds) > ds)
    mutt_debug(LL_DEBUG2, "warning: buffer too small for regerror\n");
  /* The return value is fixed, exists only to shorten code at callsite */
  return RANGE_E_SYNTAX;
}

Here is the caller graph for this function:

is_menu_available()

bool is_menu_available ( struct Buffer * s, regmatch_t pmatch[], int kind, struct Buffer * err, const struct Menu * menu )

static

Do we need a MailboxView for this Pattern?

Parameters

s	String to check
pmatch	Regex matches
kind	Range type, e.g. RANGE_K_REL
err	Buffer for error messages
menu	Current Menu

Return values

false	MailboxView is required, but not available
true	Otherwise

Definition at line 82 of file message.c.

{
  const char *context_req_chars[] = {
    [RANGE_K_REL] = ".0123456789",
    [RANGE_K_ABS] = ".",
    [RANGE_K_LT] = "",
    [RANGE_K_GT] = "",
    [RANGE_K_BARE] = ".",
  };
 
  /* First decide if we're going to need the menu at all.
   * Relative patterns need it if they contain a dot or a number.
   * Absolute patterns only need it if they contain a dot. */
  char *context_loc = strpbrk(s->dptr + pmatch[0].rm_so, context_req_chars[kind]);
  if (!context_loc || (context_loc >= &s->dptr[pmatch[0].rm_eo]))
    return true;
 
  /* We need a current message.  Do we actually have one? */
  if (menu)
    return true;
 
  /* Nope. */
  buf_strcpy(err, _("No current message"));
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

scan_range_num()

int scan_range_num ( struct Buffer * s, regmatch_t pmatch[], int group, int kind, struct MailboxView * mv )

static

Parse a number range.

Parameters

s	String to parse
pmatch	Array of regex matches
group	Index of regex match to use
kind	Range type, e.g. RANGE_K_REL
mv	Mailbox view

Return values

num	Parse number

Definition at line 118 of file message.c.

{
  int num = (int) strtol(&s->dptr[pmatch[group].rm_so], NULL, 0);
  unsigned char c = (unsigned char) (s->dptr[pmatch[group].rm_eo - 1]);
  if (mutt_toupper(c) == 'K')
    num *= KILO;
  else if (mutt_toupper(c) == 'M')
    num *= MEGA;
  switch (kind)
  {
    case RANGE_K_REL:
    {
      struct Mailbox *m = mv->mailbox;
      struct Menu *menu = mv->menu;
      struct Email *e = mutt_get_virt_email(m, menu_get_index(menu));
      if (!e)
        return num;
      return num + email_msgno(e);
    }
    case RANGE_K_LT:
      return num - 1;
    case RANGE_K_GT:
      return num + 1;
    default:
      return num;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

scan_range_slot()

int scan_range_slot ( struct Buffer * s, regmatch_t pmatch[], int grp, int side, int kind, struct MailboxView * mv )

static

Parse a range of message numbers.

Parameters

s	String to parse
pmatch	Regex matches
grp	Which regex match to use
side	Which side of the range is this? RANGE_S_LEFT or RANGE_S_RIGHT
kind	Range type, e.g. RANGE_K_REL
mv	Mailbox view

Return values

num	Index number for the message specified

Definition at line 157 of file message.c.

{
  struct Mailbox *m = mv->mailbox;
  struct Menu *menu = mv->menu;
 
  /* This means the left or right subpattern was empty, e.g. ",." */
  if ((pmatch[grp].rm_so == -1) || (pmatch[grp].rm_so == pmatch[grp].rm_eo))
  {
    if (side == RANGE_S_LEFT)
      return 1;
    if (side == RANGE_S_RIGHT)
      return m->msg_count;
  }
  /* We have something, so determine what */
  unsigned char c = (unsigned char) (s->dptr[pmatch[grp].rm_so]);
  switch (c)
  {
    case RANGE_CIRCUM:
      return 1;
    case RANGE_DOLLAR:
      return m->msg_count;
    case RANGE_DOT:
    {
      struct Email *e = mutt_get_virt_email(m, menu_get_index(menu));
      if (!e)
        return 1;
      return email_msgno(e);
    }
    case RANGE_LT:
    case RANGE_GT:
      return scan_range_num(s, pmatch, grp + 1, kind, mv);
    default:
      /* Only other possibility: a number */
      return scan_range_num(s, pmatch, grp, kind, mv);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

order_range()

void order_range ( struct Pattern * pat )

static

Put a range in order.

Parameters

pat	Pattern to check

Definition at line 199 of file message.c.

{
  if (pat->min <= pat->max)
    return;
  long num = pat->min;
  pat->min = pat->max;
  pat->max = num;
}

Here is the caller graph for this function:

eat_range_by_regex()

int eat_range_by_regex ( struct Pattern * pat, struct Buffer * s, int kind, struct Buffer * err, struct MailboxView * mv )

static

Parse a range given as a regex.

Parameters

pat	Pattern to store the range in
s	String to parse
kind	Range type, e.g. RANGE_K_REL
err	Buffer for error messages
mv	Mailbox view

Return values

num	EatRangeError code, e.g. RANGE_E_OK

Definition at line 217 of file message.c.

{
  struct PatternModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_PATTERN);
  int regerr;
  regmatch_t pmatch[RANGE_RX_GROUPS] = { 0 };
  struct RangeRegex *pspec = &mod_data->range_regexes[kind];
 
  /* First time through, compile the big regex */
  if (!pspec->ready)
  {
    regerr = regcomp(&pspec->cooked, pspec->raw, REG_EXTENDED);
    if (regerr != 0)
      return report_regerror(regerr, &pspec->cooked, err);
    pspec->ready = true;
  }
 
  /* Match the pattern buffer against the compiled regex.
   * No match means syntax error. */
  regerr = regexec(&pspec->cooked, s->dptr, RANGE_RX_GROUPS, pmatch, 0);
  if (regerr != 0)
    return report_regerror(regerr, &pspec->cooked, err);
 
  struct Mailbox *m = mv->mailbox;
  struct Menu *menu = mv->menu;
  if (!is_menu_available(s, pmatch, kind, err, menu))
    return RANGE_E_MVIEW;
 
  /* Snarf the contents of the two sides of the range. */
  pat->min = scan_range_slot(s, pmatch, pspec->lgrp, RANGE_S_LEFT, kind, mv);
  pat->max = scan_range_slot(s, pmatch, pspec->rgrp, RANGE_S_RIGHT, kind, mv);
  mutt_debug(LL_DEBUG1, "pat->min=%ld pat->max=%ld\n", pat->min, pat->max);
 
  /* Special case for a bare 0. */
  if ((kind == RANGE_K_BARE) && (pat->min == 0) && (pat->max == 0))
  {
    if (!m || !menu)
    {
      buf_strcpy(err, _("No current message"));
      return RANGE_E_MVIEW;
    }
    struct Email *e = mutt_get_virt_email(m, menu_get_index(menu));
    if (!e)
      return RANGE_E_MVIEW;
 
    pat->max = email_msgno(e);
    pat->min = pat->max;
  }
 
  /* Since we don't enforce order, we must swap bounds if they're backward */
  order_range(pat);
 
  /* Slide pointer past the entire match. */
  s->dptr += pmatch[0].rm_eo;
  return RANGE_E_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function: