node_expando.h File Reference

Expando Node for an Expando. More...

#include <stdbool.h>
#include "definition.h"
#include "render.h"

Include dependency graph for node_expando.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	NodeExpandoPrivate
	Private data for an Expando -. More...

Functions
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 *str, const char **parsed_until, struct ExpandoParseError *err)
	Parse a format string.
struct ExpandoNode *	parse_long_name (const char *str, const struct ExpandoDefinition *defs, ExpandoParserFlags flags, struct ExpandoFormat *fmt, const char **parsed_until, struct ExpandoParseError *err)
	Create an expando by its long name.
struct ExpandoNode *	parse_short_name (const char *str, const struct ExpandoDefinition *defs, ExpandoParserFlags flags, struct ExpandoFormat *fmt, const char **parsed_until, struct ExpandoParseError *err)
	Create an expando by its short name.
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_name (const char *str, const struct ExpandoDefinition *defs, ExpandoParserFlags flags, const char **parsed_until, struct ExpandoParseError *err)
	Parse an Expando format string.
int	node_expando_render (const struct ExpandoNode *node, const struct ExpandoRenderCallback *erc, struct Buffer *buf, int max_cols, void *data, MuttFormatFlags flags)
	Render an Expando Node - Implements ExpandoNode::render() -.
struct ExpandoNode *	node_expando_parse_enclosure (const char *str, int did, int uid, char terminator, struct ExpandoFormat *fmt, const char **parsed_until, struct ExpandoParseError *err)
	Parse an enclosed Expando.

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

Function Documentation

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 79 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 101 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 116 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 *	str,
		const char **	parsed_until,
		struct ExpandoParseError *	err )

Parse a format string.

Parameters

[in]	str	String to parse
[out]	parsed_until	First character after the parsed string
[out]	err	Buffer for errors

Return values

ptr	New ExpandoFormat object

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

Note

A trailing _ (underscore) means lowercase the string

Definition at line 137 of file node_expando.c.

{
  if (!str || !parsed_until || !err)
    return NULL;
 
  const char *start = str;
 
  struct ExpandoFormat *fmt = MUTT_MEM_CALLOC(1, struct ExpandoFormat);
 
  fmt->leader = ' ';
  fmt->justification = JUSTIFY_RIGHT;
  fmt->min_cols = 0;
  fmt->max_cols = -1;
 
  if (*str == '-')
  {
    fmt->justification = JUSTIFY_LEFT;
    str++;
  }
  else if (*str == '=')
  {
    fmt->justification = JUSTIFY_CENTER;
    str++;
  }
 
  if (*str == '0')
  {
    // Ignore '0' with left-justification
    if (fmt->justification != JUSTIFY_LEFT)
      fmt->leader = '0';
    str++;
  }
 
  // Parse the width (min_cols)
  if (mutt_isdigit(*str))
  {
    unsigned short number = 0;
    const char *end_ptr = mutt_str_atous(str, &number);
 
    if (!end_ptr || (number == USHRT_MAX))
    {
      err->position = str;
      snprintf(err->message, sizeof(err->message), _("Invalid number: %s"), str);
      FREE(&fmt);
      return NULL;
    }
 
    fmt->min_cols = number;
    str = end_ptr;
  }
 
  // Parse the precision (max_cols)
  if (*str == '.')
  {
    str++;
 
    unsigned short number = 1;
 
    if (mutt_isdigit(*str))
    {
      const char *end_ptr = mutt_str_atous(str, &number);
 
      if (!end_ptr || (number == USHRT_MAX))
      {
        err->position = str;
        snprintf(err->message, sizeof(err->message), _("Invalid number: %s"), str);
        FREE(&fmt);
        return NULL;
      }
 
      str = end_ptr;
    }
    else
    {
      number = 0;
    }
 
    fmt->leader = (number == 0) ? ' ' : '0';
    fmt->max_cols = number;
  }
 
  // A modifier of '_' before the letter means force lower case
  if (*str == '_')
  {
    fmt->lower = true;
    str++;
  }
 
  if (str == start) // Failed to parse anything
    FREE(&fmt);
 
  if (fmt && (fmt->min_cols == 0) && (fmt->max_cols == -1) && !fmt->lower)
    FREE(&fmt);
 
  *parsed_until = str;
  return fmt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_long_name()

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

Create an expando by its long name.

Parameters

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

Return values

ptr	New ExpandoNode

Definition at line 288 of file node_expando.c.

{
  if (!str || !defs)
    return NULL;
 
  const struct ExpandoDefinition *def = defs;
  for (; def && (def->short_name || def->long_name); def++)
  {
    if (!def->long_name)
      continue;
 
    size_t len = mutt_str_len(def->long_name);
 
    if (mutt_strn_equal(def->long_name, str, len))
    {
      *parsed_until = str + len;
      if (def->parse)
      {
        struct ExpandoNode *node = def->parse(str, fmt, def->did, def->uid,
                                              flags, parsed_until, err);
        if (node || (err->message[0] != '\0'))
          return node;
      }
      else
      {
        if (str[len] != '}') // Not an exact match
          continue;
 
        return node_expando_new(fmt, def->did, def->uid);
      }
    }
  }
 
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_short_name()

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

Create an expando by its short name.

Parameters

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

Return values

ptr	New ExpandoNode

Definition at line 246 of file node_expando.c.

{
  if (!str || !defs)
    return NULL;
 
  const struct ExpandoDefinition *def = defs;
  for (; def && (def->short_name || def->long_name); def++)
  {
    size_t len = mutt_str_len(def->short_name);
    if (len == 0)
      continue;
 
    if (mutt_strn_equal(def->short_name, str, len))
    {
      if (def->parse)
      {
        return def->parse(str, fmt, def->did, def->uid, flags, parsed_until, err);
      }
      else
      {
        *parsed_until = str + len;
        return node_expando_new(fmt, def->did, def->uid);
      }
    }
  }
 
  return NULL;
}

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 336 of file node_expando.c.

{
  ASSERT(str[0] == '%');
  str++;
 
  struct ExpandoFormat *fmt = parse_format(str, parsed_until, err);
  if (err->position)
  {
    FREE(&fmt);
    return NULL;
  }
 
  str = *parsed_until;
 
  struct ExpandoNode *node = parse_short_name(str, defs, flags, fmt, parsed_until, err);
  if (node)
    return node;
 
  if (!err->position)
  {
    err->position = *parsed_until;
    // L10N: e.g. "Unknown expando: %Q"
    snprintf(err->message, sizeof(err->message), _("Unknown expando: %%%.1s"), *parsed_until);
  }
 
  FREE(&fmt);
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

node_expando_parse_name()

struct ExpandoNode * node_expando_parse_name	(	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 376 of file node_expando.c.

{
  ASSERT(str[0] == '%');
  str++;
 
  struct ExpandoFormat *fmt = parse_format(str, parsed_until, err);
  if (err->position)
    goto fail;
 
  str = *parsed_until;
 
  if (str[0] != '{')
    goto fail;
 
  str++;
 
  struct ExpandoNode *node = parse_long_name(str, defs, flags, fmt, parsed_until, err);
  if (!node)
  {
    if (!err->position)
    {
      const char *end = str + strspn(str, "abcdefghijklmnopqrstuvwxyz0123456789-");
 
      // Only report an error if the content looks like a long name (i.e. starts
      // with at least one valid character).  If it doesn't, the '{' is probably
      // a short-name expando like %{%b %d} — let node_expando_parse() handle it.
      if (end != str)
      {
        err->position = str;
        if (*end != '}')
        {
          snprintf(err->message, sizeof(err->message), _("Expando is missing closing '}'"));
        }
        else
        {
          // L10N: e.g. "Unknown expando: %{bad}"
          snprintf(err->message, sizeof(err->message),
                   _("Unknown expando: %%{%.*s}"), (int) (end - str), str);
        }
      }
    }
    goto fail;
  }
 
  fmt = NULL; // owned by the node, now
 
  if ((*parsed_until)[0] == '}')
  {
    (*parsed_until)++;
    return node;
  }
 
  node_free(&node);
 
fail:
  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,
		struct ExpandoFormat *	fmt,
		const char **	parsed_until,
		struct ExpandoParseError *	err )

Parse an enclosed Expando.

Parameters

[in]	str	String to parse
[in]	did	Domain ID
[in]	uid	Unique ID
[in]	terminator	Terminating character
[in]	fmt	Formatting info
[out]	parsed_until	First character after the parsed string
[out]	err	Buffer for errors

Return values

ptr	New ExpandoNode

Definition at line 476 of file node_expando.c.

{
  str++; // skip opening char
 
  const char *expando_end = skip_until_ch(str, 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;
  }
 
  *parsed_until = expando_end + 1;
 
  struct ExpandoNode *node = node_expando_new(fmt, did, uid);
 
  struct Buffer *buf = buf_pool_get();
  for (; str < expando_end; str++)
  {
    if (str[0] == '\\')
      continue;
    buf_addch(buf, str[0]);
  }
 
  node->text = buf_strdup(buf);
  buf_pool_release(&buf);
 
  return node;
}

Here is the call graph for this function:

Here is the caller graph for this function: