node_conddate.c

Go to the documentation of this file.

 
#include "config.h"
#include <ctype.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "mutt/lib.h"
#include "node_conddate.h"
#include "helpers.h"
#include "node.h"
#include "parse.h"
#include "render.h"
 
struct NodeCondDatePrivate *node_conddate_private_new(int count, char period)
{
  struct NodeCondDatePrivate *priv = mutt_mem_calloc(1, sizeof(struct NodeCondDatePrivate));
 
  priv->count = count;
  priv->period = period;
 
  return priv;
}
 
void node_conddate_private_free(void **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  FREE(ptr);
}
 
time_t cutoff_number(char period, int count)
{
  time_t t = mutt_date_now();
  struct tm tm = { 0 };
  localtime_r(&t, &tm);
 
  switch (period)
  {
    case 'y':
      tm.tm_year -= count;
      break;
 
    case 'm':
      tm.tm_mon -= count;
      break;
 
    case 'w':
      tm.tm_mday -= (7 * count);
      break;
 
    case 'd':
      tm.tm_mday -= count;
      break;
 
    case 'H':
      tm.tm_hour -= count;
      break;
 
    case 'M':
      tm.tm_min -= count;
      break;
  }
 
  return mktime(&tm);
}
 
time_t cutoff_this(char period)
{
  time_t t = mutt_date_now();
  struct tm tm = { 0 };
  localtime_r(&t, &tm);
 
  switch (period)
  {
    case 'y':
      tm.tm_mon = 0; // January
      FALLTHROUGH;
 
    case 'm':
      tm.tm_mday = 1; // 1st of the month
      FALLTHROUGH;
 
    case 'd':
      tm.tm_hour = 0; // Beginning of day (Midnight)
      FALLTHROUGH;
 
    case 'H':
      tm.tm_min = 0; // Beginning of hour
      FALLTHROUGH;
 
    case 'M':
      tm.tm_sec = 0; // Beginning of minute
      break;
 
    case 'w':
      tm.tm_mday = 1;
      break;
  }
 
  return mktime(&tm);
}
 
int node_conddate_render(const struct ExpandoNode *node,
                         const struct ExpandoRenderData *rdata, struct Buffer *buf,
                         int max_cols, void *data, MuttFormatFlags flags)
{
  ASSERT(node->type == ENT_CONDDATE);
 
  const struct ExpandoRenderData *rd_match = find_get_number(rdata, node->did, node->uid);
  ASSERT(rd_match && "Unknown UID");
 
  const long t_test = rd_match->get_number(node, data, flags);
 
  const struct NodeCondDatePrivate *priv = node->ndata;
 
  time_t t_cutoff;
  if (priv->count == 0)
    t_cutoff = cutoff_this(priv->period);
  else
    t_cutoff = cutoff_number(priv->period, priv->count);
 
  return (t_test > t_cutoff); // bool-ify
}
 
struct ExpandoNode *node_conddate_new(int count, char period, int did, int uid)
{
  struct ExpandoNode *node = node_new();
  node->type = ENT_CONDDATE;
  node->did = did;
  node->uid = uid;
  node->render = node_conddate_render;
 
  node->ndata = node_conddate_private_new(count, period);
  node->ndata_free = node_conddate_private_free;
 
  return node;
}
 
struct ExpandoNode *node_conddate_parse(const char *str, int did, int uid,
                                        const char **parsed_until,
                                        struct ExpandoParseError *err)
{
  int count = 0;
  char period = '\0';
 
  if (isdigit(*str))
  {
    unsigned short number = 0;
    const char *end_ptr = mutt_str_atous(str, &number);
 
    // NOTE(g0mb4): str is NOT null-terminated
    if (!end_ptr || (number == USHRT_MAX))
    {
      err->position = str;
      snprintf(err->message, sizeof(err->message), _("Invalid number: %s"), str);
      return NULL;
    }
 
    count = number;
    str = end_ptr;
  };
 
  // Allowed periods: year, month, week, day, hour, minute
  if (!strchr("ymwdHM", *str))
  {
    err->position = str;
    snprintf(err->message, sizeof(err->message),
             // L10N: The 'ymwdHM' should not be translated
             _("Invalid time period: '%c', must be one of 'ymwdHM'"), *str);
    return NULL;
  }
 
  period = *str;
  *parsed_until = str + 1;
 
  return node_conddate_new(count, period, did, uid);
}