node_conddate.c

Go to the documentation of this file.

 
#include "config.h"
#include <assert.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);
}
 
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 = mutt_date_now();
  struct tm tm = { 0 };
  gmtime_r(&t, &tm);
 
  switch (priv->period)
  {
    case 'y':
      tm.tm_year -= priv->count;
      break;
 
    case 'm':
      tm.tm_mon -= priv->count;
      break;
 
    case 'w':
      tm.tm_mday -= (7 * priv->count);
      break;
 
    case 'd':
      tm.tm_mday -= priv->count;
      break;
 
    case 'H':
      tm.tm_hour -= priv->count;
      break;
 
    case 'M':
      tm.tm_min -= priv->count;
      break;
  }
 
  const time_t t_cutoff = mktime(&tm);
 
  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, const char **parsed_until,
                                        int did, int uid, struct ExpandoParseError *error)
{
  int count = 1;
  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))
    {
      error->position = str;
      snprintf(error->message, sizeof(error->message), _("Invalid number: %s"), str);
      return NULL;
    }
 
    count = number;
    str = end_ptr;
  };
 
  // Allowed periods: year, month, week, day, hour, minute
  if (!strchr("ymwdHM", *str))
  {
    error->position = str;
    snprintf(error->message, sizeof(error->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);
}