node_expando.c File Reference

Expando Node for an Expando. More...

#include "config.h"
#include <ctype.h>
#include <limits.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "node_expando.h"
#include "color/lib.h"
#include "definition.h"
#include "format.h"
#include "helpers.h"
#include "mutt_thread.h"
#include "node.h"
#include "parse.h"
#include "render.h"

Include dependency graph for node_expando.c:

Go to the source code of this file.

Functions
struct NodeExpandoPrivate *	node_expando_private_new (void)
	Create new Expando private data.
void	node_expando_private_free (void **ptr)
	Free Expando private data - Implements ExpandoNode::ndata_free()
struct ExpandoNode *	node_expando_new (struct ExpandoFormat *fmt, int did, int uid)
	Create a new Expando ExpandoNode.
void	node_expando_set_color (const struct ExpandoNode *node, int cid)
	Set the colour for an Expando.
void	node_expando_set_has_tree (const struct ExpandoNode *node, bool has_tree)
	Set the has_tree flag for an Expando.
struct ExpandoFormat *	parse_format (const char *start, const char *end, struct ExpandoParseError *err)
	Parse a format string.
struct ExpandoNode *	node_expando_parse (const char *str, const struct ExpandoDefinition *defs, ExpandoParserFlags flags, const char **parsed_until, struct ExpandoParseError *err)
	Parse an Expando format string.
struct ExpandoNode *	node_expando_parse_enclosure (const char *str, int did, int uid, char terminator, const char **parsed_until, struct ExpandoParseError *err)
	Parse an enclosed Expando.
void	add_color (struct Buffer *buf, enum ColorId cid)
	Add a colour code to a buffer.
int	node_expando_render (const struct ExpandoNode *node, const struct ExpandoRenderData *rdata, struct Buffer *buf, int max_cols, void *data, MuttFormatFlags flags)
	Render an Expando Node - Implements ExpandoNode::render() -.

Detailed Description

Expando Node for an Expando.

Authors

• Tóth János
• Richard Russon

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 node_expando.c.

Function Documentation

node_expando_private_new()

struct NodeExpandoPrivate * node_expando_private_new

(

void

)

Create new Expando private data.

Return values

ptr	New Expando private data

Definition at line 49 of file node_expando.c.

{
  struct NodeExpandoPrivate *priv = mutt_mem_calloc(1, sizeof(struct NodeExpandoPrivate));
 
  // NOTE(g0mb4): Expando definition should contain this
  priv->color = -1;
 
  return priv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

node_expando_private_free()

void node_expando_private_free

(

void **

ptr

)

Free Expando private data - Implements ExpandoNode::ndata_free()

Parameters

ptr	Data to free

Definition at line 63 of file node_expando.c.

{
  if (!ptr || !*ptr)
    return;
 
  FREE(ptr);
}

Here is the caller graph for this function:

node_expando_new()

struct ExpandoNode * node_expando_new	(	struct ExpandoFormat *	fmt,
		int	did,
		int	uid
	)

Create a new Expando ExpandoNode.

Parameters

fmt	Formatting data
did	Domain ID
uid	Unique ID

Return values

ptr	New Expando ExpandoNode

Definition at line 78 of file node_expando.c.

{
  struct ExpandoNode *node = node_new();
 
  node->type = ENT_EXPANDO;
  node->did = did;
  node->uid = uid;
  node->render = node_expando_render;
 
  node->format = fmt;
 
  node->ndata = node_expando_private_new();
  node->ndata_free = node_expando_private_free;
 
  return node;
}

Here is the call graph for this function:

Here is the caller graph for this function:

node_expando_set_color()

void node_expando_set_color	(	const struct ExpandoNode *	node,
		int	cid
	)

Set the colour for an Expando.

Parameters

node	Node to alter
cid	Colour

Definition at line 100 of file node_expando.c.

{
  if (!node || (node->type != ENT_EXPANDO) || !node->ndata)
    return;
 
  struct NodeExpandoPrivate *priv = node->ndata;
 
  priv->color = cid;
}

Here is the caller graph for this function:

node_expando_set_has_tree()

void node_expando_set_has_tree	(	const struct ExpandoNode *	node,
		bool	has_tree
	)

Set the has_tree flag for an Expando.

Parameters

node	Node to alter
has_tree	Flag to set

Definition at line 115 of file node_expando.c.

{
  if (!node || (node->type != ENT_EXPANDO) || !node->ndata)
    return;
 
  struct NodeExpandoPrivate *priv = node->ndata;
 
  priv->has_tree = has_tree;
}

Here is the caller graph for this function:

parse_format()

struct ExpandoFormat * parse_format	(	const char *	start,
		const char *	end,
		struct ExpandoParseError *	err
	)

Parse a format string.

Parameters

start	Start of string
end	End of string
err	Buffer for errors

Return values

ptr	New ExpandoFormat object

Parse a printf()-style format, e.g. '-15.20x'

Definition at line 134 of file node_expando.c.

{
  if (start == end)
    return NULL;
 
  struct ExpandoFormat *fmt = mutt_mem_calloc(1, sizeof(struct ExpandoFormat));
 
  fmt->leader = ' ';
  fmt->justification = JUSTIFY_RIGHT;
  fmt->min_cols = 0;
  fmt->max_cols = INT_MAX;
 
  if (*start == '-')
  {
    fmt->justification = JUSTIFY_LEFT;
    start++;
  }
  else if (*start == '=')
  {
    fmt->justification = JUSTIFY_CENTER;
    start++;
  }
 
  if (*start == '0')
  {
    fmt->leader = '0';
    start++;
  }
 
  if (isdigit(*start))
  {
    unsigned short number = 0;
    const char *end_ptr = mutt_str_atous(start, &number);
 
    // NOTE(g0mb4): start is NOT null-terminated
    if (!end_ptr || (end_ptr > end) || (number == USHRT_MAX))
    {
      err->position = start;
      snprintf(err->message, sizeof(err->message), _("Invalid number: %s"), start);
      FREE(&fmt);
      return NULL;
    }
 
    fmt->min_cols = number;
    start = end_ptr;
  };
 
  if (*start == '.')
  {
    start++;
 
    if (!isdigit(*start))
    {
      err->position = start;
      // L10N: Expando format expected a number
      snprintf(err->message, sizeof(err->message), _("Number is expected"));
      FREE(&fmt);
      return NULL;
    }
 
    unsigned short number = 0;
    const char *end_ptr = mutt_str_atous(start, &number);
 
    // NOTE(g0mb4): start is NOT null-terminated
    if (!end_ptr || (end_ptr > end) || (number == USHRT_MAX))
    {
      err->position = start;
      snprintf(err->message, sizeof(err->message), _("Invalid number: %s"), start);
      FREE(&fmt);
      return NULL;
    }
 
    fmt->max_cols = number;
    start = end_ptr;
  }
 
  if (*start == '_')
  {
    fmt->lower = true;
    start++;
  }
 
  return fmt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

node_expando_parse()

struct ExpandoNode * node_expando_parse	(	const char *	str,
		const struct ExpandoDefinition *	defs,
		ExpandoParserFlags	flags,
		const char **	parsed_until,
		struct ExpandoParseError *	err
	)

Parse an Expando format string.

Parameters

[in]	str	String to parse
[in]	defs	Expando definitions
[in]	flags	Flag for conditional expandos
[out]	parsed_until	First character after parsed string
[out]	err	Buffer for errors

Return values

ptr	New ExpandoNode

Definition at line 229 of file node_expando.c.

{
  const struct ExpandoDefinition *def = defs;
 
  const char *format_end = skip_until_classic_expando(str);
  const char *expando_end = skip_classic_expando(format_end, defs);
  char expando[128] = { 0 };
  const int expando_len = expando_end - format_end;
  mutt_strn_copy(expando, format_end, expando_len, sizeof(expando));
 
  struct ExpandoFormat *fmt = parse_format(str, format_end, err);
  if (err->position)
  {
    FREE(&fmt);
    return NULL;
  }
 
  while (def && def->short_name)
  {
    if (mutt_str_equal(def->short_name, expando))
    {
      if (def->parse && !(flags & EP_NO_CUSTOM_PARSE))
      {
        FREE(&fmt);
        return def->parse(str, def->did, def->uid, flags, parsed_until, err);
      }
      else
      {
        *parsed_until = expando_end;
        return node_expando_new(fmt, def->did, def->uid);
      }
    }
 
    def++;
  }
 
  err->position = format_end;
  // L10N: e.g. "Unknown expando: %Q"
  snprintf(err->message, sizeof(err->message), _("Unknown expando: %%%.*s"),
           expando_len, format_end);
  FREE(&fmt);
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

node_expando_parse_enclosure()

struct ExpandoNode * node_expando_parse_enclosure	(	const char *	str,
		int	did,
		int	uid,
		char	terminator,
		const char **	parsed_until,
		struct ExpandoParseError *	err
	)

Parse an enclosed Expando.

Parameters

str	String to parse
did	Domain ID
uid	Unique ID
terminator	Terminating character
parsed_until	First character after the parsed string
err	Buffer for errors

Return values

ptr	New ExpandoNode

Definition at line 285 of file node_expando.c.

{
  const char *format_end = skip_until_classic_expando(str);
 
  format_end++; // skip opening char
 
  const char *expando_end = skip_until_ch(format_end, terminator);
 
  if (*expando_end != terminator)
  {
    err->position = expando_end;
    snprintf(err->message, sizeof(err->message),
             // L10N: Expando is missing a terminator character
             //       e.g. "%[..." is missing the final ']'
             _("Expando is missing terminator: '%c'"), terminator);
    return NULL;
  }
 
  // revert skipping for fmt
  struct ExpandoFormat *fmt = parse_format(str, format_end - 1, err);
  if (err->position)
  {
    FREE(&fmt);
    return NULL;
  }
 
  *parsed_until = expando_end + 1;
 
  struct ExpandoNode *node = node_expando_new(fmt, did, uid);
  node->text = mutt_strn_dup(format_end, expando_end - format_end);
  return node;
}

Here is the call graph for this function:

Here is the caller graph for this function:

add_color()

void add_color	(	struct Buffer *	buf,
		enum ColorId	cid
	)

Add a colour code to a buffer.

Parameters

buf	Buffer for colour code
cid	Colour

Definition at line 325 of file node_expando.c.

{
  ASSERT(cid < MT_COLOR_MAX);
 
  buf_addch(buf, MUTT_SPECIAL_INDEX);
  buf_addch(buf, cid);
}

Here is the call graph for this function:

Here is the caller graph for this function: