NeoMutt  2021-02-05-89-gabe350
Teaching an old dog new tricks
DOXYGEN
private.h File Reference
#include "config.h"
#include <stdbool.h>
#include "mutt/lib.h"
#include "lib.h"
+ Include dependency graph for private.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  PatternFlags
 Mapping between user character and internal constant. More...
 
struct  RangeRegex
 Regular expression representing a range. More...
 

Macros

#define RANGE_NUM_RX   "([[:digit:]]+|0x[[:xdigit:]]+)[MmKk]?"
 
#define RANGE_REL_SLOT_RX   "[[:blank:]]*([.^$]|-?" RANGE_NUM_RX ")?[[:blank:]]*"
 
#define RANGE_REL_RX   "^" RANGE_REL_SLOT_RX "," RANGE_REL_SLOT_RX
 
#define RANGE_ABS_SLOT_RX   "[[:blank:]]*([.^$]|" RANGE_NUM_RX ")?[[:blank:]]*"
 
#define RANGE_ABS_RX   "^" RANGE_ABS_SLOT_RX "-" RANGE_ABS_SLOT_RX
 
#define RANGE_LT_RX   "^()[[:blank:]]*(<[[:blank:]]*" RANGE_NUM_RX ")[[:blank:]]*"
 
#define RANGE_GT_RX   "^()[[:blank:]]*(>[[:blank:]]*" RANGE_NUM_RX ")[[:blank:]]*"
 
#define RANGE_BARE_RX   "^[[:blank:]]*([.^$]|" RANGE_NUM_RX ")[[:blank:]]*"
 
#define RANGE_RX_GROUPS   5
 
#define RANGE_DOT   '.'
 
#define RANGE_CIRCUM   '^'
 
#define RANGE_DOLLAR   '$'
 
#define RANGE_LT   '<'
 
#define RANGE_GT   '>'
 
#define EMSG(e)   (((e)->msgno) + 1)
 
#define MUTT_MAXRANGE   -1
 

Enumerations

enum  PatternEat {
  EAT_NONE, EAT_REGEX, EAT_DATE, EAT_RANGE,
  EAT_MESSAGE_RANGE, EAT_QUERY
}
 Function to process pattern arguments. More...
 
enum  RangeType {
  RANGE_K_REL, RANGE_K_ABS, RANGE_K_LT, RANGE_K_GT,
  RANGE_K_BARE, RANGE_K_INVALID
}
 Type of range. More...
 
enum  RangeSide { RANGE_S_LEFT, RANGE_S_RIGHT }
 Which side of the range. More...
 

Functions

const struct PatternFlagslookup_op (int op)
 Lookup the Pattern Flags for an op. More...
 
const struct PatternFlagslookup_tag (char tag)
 Lookup a pattern modifier. More...
 
bool eval_date_minmax (struct Pattern *pat, const char *s, struct Buffer *err)
 Evaluate a date-range pattern against 'now'. More...
 

Variables

struct RangeRegex range_regexes []
 Set of Regexes for various range types. More...
 
const struct PatternFlags Flags []
 Lookup table for all patterns. More...
 
char * C_ExternalSearchCommand
 Config: External search command. More...
 
char * C_PatternFormat
 Config: printf-like format string for the pattern completion menu. More...
 

Detailed Description

Shared constants/structs that are private to libpattern

Authors
  • Richard Russon

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 private.h.

Macro Definition Documentation

◆ RANGE_NUM_RX

#define RANGE_NUM_RX   "([[:digit:]]+|0x[[:xdigit:]]+)[MmKk]?"

Definition at line 89 of file private.h.

◆ RANGE_REL_SLOT_RX

#define RANGE_REL_SLOT_RX   "[[:blank:]]*([.^$]|-?" RANGE_NUM_RX ")?[[:blank:]]*"

Definition at line 90 of file private.h.

◆ RANGE_REL_RX

#define RANGE_REL_RX   "^" RANGE_REL_SLOT_RX "," RANGE_REL_SLOT_RX

Definition at line 91 of file private.h.

◆ RANGE_ABS_SLOT_RX

#define RANGE_ABS_SLOT_RX   "[[:blank:]]*([.^$]|" RANGE_NUM_RX ")?[[:blank:]]*"

Definition at line 94 of file private.h.

◆ RANGE_ABS_RX

#define RANGE_ABS_RX   "^" RANGE_ABS_SLOT_RX "-" RANGE_ABS_SLOT_RX

Definition at line 95 of file private.h.

◆ RANGE_LT_RX

#define RANGE_LT_RX   "^()[[:blank:]]*(<[[:blank:]]*" RANGE_NUM_RX ")[[:blank:]]*"

Definition at line 98 of file private.h.

◆ RANGE_GT_RX

#define RANGE_GT_RX   "^()[[:blank:]]*(>[[:blank:]]*" RANGE_NUM_RX ")[[:blank:]]*"

Definition at line 99 of file private.h.

◆ RANGE_BARE_RX

#define RANGE_BARE_RX   "^[[:blank:]]*([.^$]|" RANGE_NUM_RX ")[[:blank:]]*"

Definition at line 102 of file private.h.

◆ RANGE_RX_GROUPS

#define RANGE_RX_GROUPS   5

Definition at line 103 of file private.h.

◆ RANGE_DOT

#define RANGE_DOT   '.'

Definition at line 105 of file private.h.

◆ RANGE_CIRCUM

#define RANGE_CIRCUM   '^'

Definition at line 106 of file private.h.

◆ RANGE_DOLLAR

#define RANGE_DOLLAR   '$'

Definition at line 107 of file private.h.

◆ RANGE_LT

#define RANGE_LT   '<'

Definition at line 108 of file private.h.

◆ RANGE_GT

#define RANGE_GT   '>'

Definition at line 109 of file private.h.

◆ EMSG

#define EMSG (   e)    (((e)->msgno) + 1)

Definition at line 120 of file private.h.

◆ MUTT_MAXRANGE

#define MUTT_MAXRANGE   -1

Definition at line 122 of file private.h.

Enumeration Type Documentation

◆ PatternEat

enum PatternEat

Function to process pattern arguments.

Values for PatternFlags.eat_arg

Enumerator
EAT_NONE 

No arguments required.

EAT_REGEX 

Process a regex.

EAT_DATE 

Process a date (range)

EAT_RANGE 

Process a number (range)

EAT_MESSAGE_RANGE 

Process a message number (range)

EAT_QUERY 

Process a query string.

Definition at line 39 of file private.h.

40 {
41  EAT_NONE,
42  EAT_REGEX,
43  EAT_DATE,
44  EAT_RANGE,
46  EAT_QUERY,
47 };

◆ RangeType

enum RangeType

Type of range.

Enumerator
RANGE_K_REL 

Relative range.

RANGE_K_ABS 

Absolute range.

RANGE_K_LT 

Less-than range.

RANGE_K_GT 

Greater-than range.

RANGE_K_BARE 

Single symbol.

RANGE_K_INVALID 

Range is invalid.

Definition at line 77 of file private.h.

78 {
79  RANGE_K_REL,
80  RANGE_K_ABS,
81  RANGE_K_LT,
82  RANGE_K_GT,
83  RANGE_K_BARE,
84  /* add new ones HERE */
86 };

◆ RangeSide

enum RangeSide

Which side of the range.

Enumerator
RANGE_S_LEFT 

Left side of range.

RANGE_S_RIGHT 

Right side of range.

Definition at line 114 of file private.h.

115 {
116  RANGE_S_LEFT,
117  RANGE_S_RIGHT,
118 };

Function Documentation

◆ lookup_op()

const struct PatternFlags* lookup_op ( int  op)

Lookup the Pattern Flags for an op.

Parameters
opOperation, e.g. MUTT_PAT_SENDER
Return values
ptrPatternFlags

Definition at line 210 of file flags.c.

211 {
212  for (int i = 0; Flags[i].tag; i++)
213  if (Flags[i].op == op)
214  return (&Flags[i]);
215  return NULL;
216 }
+ Here is the caller graph for this function:

◆ lookup_tag()

const struct PatternFlags* lookup_tag ( char  tag)

Lookup a pattern modifier.

Parameters
tagLetter, e.g. 'b' for pattern '~b'
Return values
ptrPattern data

Definition at line 197 of file flags.c.

198 {
199  for (int i = 0; Flags[i].tag; i++)
200  if (Flags[i].tag == tag)
201  return &Flags[i];
202  return NULL;
203 }
+ Here is the caller graph for this function:

◆ eval_date_minmax()

bool eval_date_minmax ( struct Pattern pat,
const char *  s,
struct Buffer err 
)

Evaluate a date-range pattern against 'now'.

Parameters
patPattern to modify
sPattern string to use
errBuffer for error messages
Return values
truePattern valid and updated
falsePattern invalid

Definition at line 498 of file compile.c.

499 {
500  /* the '0' time is Jan 1, 1970 UTC, so in order to prevent a negative time
501  * when doing timezone conversion, we use Jan 2, 1970 UTC as the base here */
502  struct tm min = { 0 };
503  min.tm_mday = 2;
504  min.tm_year = 70;
505 
506  /* Arbitrary year in the future. Don't set this too high or
507  * mutt_date_make_time() returns something larger than will fit in a time_t
508  * on some systems */
509  struct tm max = { 0 };
510  max.tm_year = 130;
511  max.tm_mon = 11;
512  max.tm_mday = 31;
513  max.tm_hour = 23;
514  max.tm_min = 59;
515  max.tm_sec = 59;
516 
517  if (strchr("<>=", s[0]))
518  {
519  /* offset from current time
520  * <3d less than three days ago
521  * >3d more than three days ago
522  * =3d exactly three days ago */
523  struct tm *tm = NULL;
524  bool exact = false;
525 
526  if (s[0] == '<')
527  {
529  tm = &min;
530  }
531  else
532  {
534  tm = &max;
535 
536  if (s[0] == '=')
537  exact = true;
538  }
539 
540  /* Reset the HMS unless we are relative matching using one of those
541  * offsets. */
542  char *offset_type = NULL;
543  strtol(s + 1, &offset_type, 0);
544  if (!(*offset_type && strchr("HMS", *offset_type)))
545  {
546  tm->tm_hour = 23;
547  tm->tm_min = 59;
548  tm->tm_sec = 59;
549  }
550 
551  /* force negative offset */
552  get_offset(tm, s + 1, -1);
553 
554  if (exact)
555  {
556  /* start at the beginning of the day in question */
557  memcpy(&min, &max, sizeof(max));
558  min.tm_hour = 0;
559  min.tm_sec = 0;
560  min.tm_min = 0;
561  }
562  }
563  else
564  {
565  const char *pc = s;
566 
567  bool have_min = false;
568  bool until_now = false;
569  if (isdigit((unsigned char) *pc))
570  {
571  /* minimum date specified */
572  pc = get_date(pc, &min, err);
573  if (!pc)
574  {
575  return false;
576  }
577  have_min = true;
578  SKIPWS(pc);
579  if (*pc == '-')
580  {
581  const char *pt = pc + 1;
582  SKIPWS(pt);
583  until_now = (*pt == '\0');
584  }
585  }
586 
587  if (!until_now)
588  { /* max date or relative range/window */
589 
590  struct tm base_min;
591 
592  if (!have_min)
593  { /* save base minimum and set current date, e.g. for "-3d+1d" */
594  memcpy(&base_min, &min, sizeof(base_min));
596  min.tm_hour = 0;
597  min.tm_sec = 0;
598  min.tm_min = 0;
599  }
600 
601  /* preset max date for relative offsets,
602  * if nothing follows we search for messages on a specific day */
603  max.tm_year = min.tm_year;
604  max.tm_mon = min.tm_mon;
605  max.tm_mday = min.tm_mday;
606 
607  if (!parse_date_range(pc, &min, &max, have_min, &base_min, err))
608  { /* bail out on any parsing error */
609  return false;
610  }
611  }
612  }
613 
614  /* Since we allow two dates to be specified we'll have to adjust that. */
615  adjust_date_range(&min, &max);
616 
617  pat->min = mutt_date_make_time(&min, true);
618  pat->max = mutt_date_make_time(&max, true);
619 
620  return true;
621 }
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ range_regexes

struct RangeRegex range_regexes[]

Set of Regexes for various range types.

This array, will also contain the compiled regexes.

Definition at line 64 of file pattern.c.

◆ Flags

const struct PatternFlags Flags[]

Lookup table for all patterns.

Definition at line 41 of file flags.c.

◆ C_ExternalSearchCommand

char* C_ExternalSearchCommand

Config: External search command.

Definition at line 36 of file config.c.

◆ C_PatternFormat

char* C_PatternFormat

Config: printf-like format string for the pattern completion menu.

Definition at line 37 of file config.c.

EAT_DATE
@ EAT_DATE
Process a date (range)
Definition: private.h:43
get_offset
static const char * get_offset(struct tm *tm, const char *s, int sign)
Calculate a symbolic offset.
Definition: compile.c:234
RANGE_K_INVALID
@ RANGE_K_INVALID
Range is invalid.
Definition: private.h:85
EAT_NONE
@ EAT_NONE
No arguments required.
Definition: private.h:41
PatternFlags::tag
int tag
Character used to represent this operation, e.g. 'A' for '~A'.
Definition: private.h:54
adjust_date_range
static void adjust_date_range(struct tm *min, struct tm *max)
Put a date range in the correct order.
Definition: compile.c:460
RANGE_K_REL
@ RANGE_K_REL
Relative range.
Definition: private.h:79
EAT_RANGE
@ EAT_RANGE
Process a number (range)
Definition: private.h:44
SKIPWS
#define SKIPWS(ch)
Definition: string2.h:46
mutt_date_make_time
time_t mutt_date_make_time(struct tm *t, bool local)
Convert struct tm to time_t
Definition: date.c:229
Pattern::min
int min
Minimum for range checks.
Definition: lib.h:84
get_date
static const char * get_date(const char *s, struct tm *t, struct Buffer *err)
Parse a (partial) date in dd/mm/yyyy format.
Definition: compile.c:288
RANGE_K_ABS
@ RANGE_K_ABS
Absolute range.
Definition: private.h:80
mutt_date_localtime
struct tm mutt_date_localtime(time_t t)
Converts calendar time to a broken-down time structure expressed in user timezone.
Definition: date.c:643
parse_date_range
static const char * parse_date_range(const char *pc, struct tm *min, struct tm *max, bool have_min, struct tm *base_min, struct Buffer *err)
Parse a date range.
Definition: compile.c:374
RANGE_K_BARE
@ RANGE_K_BARE
Single symbol.
Definition: private.h:83
EAT_REGEX
@ EAT_REGEX
Process a regex.
Definition: private.h:42
MUTT_DATE_NOW
#define MUTT_DATE_NOW
Constant representing the 'current time', see: mutt_date_gmtime(), mutt_date_localtime()
Definition: date.h:39
Flags
const struct PatternFlags Flags[]
Lookup table for all patterns.
Definition: flags.c:41
EAT_MESSAGE_RANGE
@ EAT_MESSAGE_RANGE
Process a message number (range)
Definition: private.h:45
EAT_QUERY
@ EAT_QUERY
Process a query string.
Definition: private.h:46
RANGE_K_LT
@ RANGE_K_LT
Less-than range.
Definition: private.h:81
Pattern::max
int max
Maximum for range checks.
Definition: lib.h:85
RANGE_K_GT
@ RANGE_K_GT
Greater-than range.
Definition: private.h:82
RANGE_S_RIGHT
@ RANGE_S_RIGHT
Right side of range.
Definition: private.h:117
RANGE_S_LEFT
@ RANGE_S_LEFT
Left side of range.
Definition: private.h:116