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 (const char *start, const char *end, 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 *error)
	Parse a format string.
struct ExpandoNode *	node_expando_parse (const char *str, const char **parsed_until, const struct ExpandoDefinition *defs, ExpandoParserFlags flags, struct ExpandoParseError *error)
	Parse an Expando format string.
struct ExpandoNode *	node_expando_parse_enclosure (const char *str, const char **parsed_until, int did, int uid, char terminator, struct ExpandoParseError *error)
	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	(	const char *	start,
		const char *	end,
		struct ExpandoFormat *	fmt,
		int	did,
		int	uid
	)

Create a new Expando ExpandoNode.

Parameters

start	Start of Expando string
end	End of Expando string
fmt	Formatting data
did	Domain ID
uid	Unique ID

Return values

ptr	New Expando ExpandoNode

Definition at line 80 of file node_expando.c.

{
  struct ExpandoNode *node = node_new();
 
  node->type = ENT_EXPANDO;
  node->start = start;
  node->end = end;
 
  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 106 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 121 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 *	error
	)

Parse a format string.

Parameters

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

Return values

ptr	New ExpandoFormat object

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

Definition at line 140 of file node_expando.c.

{
  if (start == end)
    return NULL;
 
  struct ExpandoFormat *fmt = mutt_mem_calloc(1, sizeof(struct ExpandoFormat));
 
  fmt->leader = ' ';
  fmt->start = start;
  fmt->end = end;
  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))
    {
      error->position = start;
      snprintf(error->message, sizeof(error->message), _("Invalid number: %s"), start);
      FREE(&fmt);
      return NULL;
    }
 
    fmt->min_cols = number;
    start = end_ptr;
  };
 
  if (*start == '.')
  {
    start++;
 
    if (!isdigit(*start))
    {
      error->position = start;
      // L10N: Expando format expected a number
      snprintf(error->message, sizeof(error->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))
    {
      error->position = start;
      snprintf(error->message, sizeof(error->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 char **	parsed_until,
		const struct ExpandoDefinition *	defs,
		ExpandoParserFlags	flags,
		struct ExpandoParseError *	error
	)

Parse an Expando format string.

Parameters

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

Return values

ptr	New ExpandoNode

Definition at line 237 of file node_expando.c.

{
  const struct ExpandoDefinition *definition = 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, error);
  if (error->position)
  {
    FREE(&fmt);
    return NULL;
  }
 
  while (definition && definition->short_name)
  {
    if (mutt_str_equal(definition->short_name, expando))
    {
      if (definition->parse && !(flags & EP_NO_CUSTOM_PARSE))
      {
        FREE(&fmt);
        return definition->parse(str, parsed_until, definition->did,
                                 definition->uid, flags, error);
      }
      else
      {
        *parsed_until = expando_end;
        return node_expando_new(format_end, expando_end, fmt, definition->did,
                                definition->uid);
      }
    }
 
    definition++;
  }
 
  error->position = format_end;
  // L10N: e.g. "Unknown expando: %Q"
  snprintf(error->message, sizeof(error->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,
		const char **	parsed_until,
		int	did,
		int	uid,
		char	terminator,
		struct ExpandoParseError *	error
	)

Parse an enclosed Expando.

Parameters

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

Return values

ptr	New ExpandoNode

Definition at line 296 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)
  {
    error->position = expando_end;
    snprintf(error->message, sizeof(error->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, error);
  if (error->position)
  {
    FREE(&fmt);
    return NULL;
  }
 
  *parsed_until = expando_end + 1;
  return node_expando_new(format_end, expando_end, fmt, did, uid);
}

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 333 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: