node_condition.c File Reference

Expando Node for a Condition. More...

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "node_condition.h"
#include "definition.h"
#include "format.h"
#include "helpers.h"
#include "node.h"
#include "node_condbool.h"
#include "node_container.h"
#include "node_expando.h"
#include "node_text.h"
#include "parse.h"
#include "render.h"

Include dependency graph for node_condition.c:

Go to the source code of this file.

Functions
static int	node_condition_render (const struct ExpandoNode *node, const struct ExpandoRenderCallback *erc, struct Buffer *buf, int max_cols, void *data, MuttFormatFlags flags)
	Render a Conditional Node - Implements ExpandoNode::render() -.
struct ExpandoNode *	node_condition_new (struct ExpandoNode *node_cond, struct ExpandoNode *node_true, struct ExpandoNode *node_false, struct ExpandoFormat *fmt)
	Create a new Condition Expando Node.
struct ExpandoNode *	node_condition_parse (const char *str, NodeTextTermFlags term_chars, const struct ExpandoDefinition *defs, const char **parsed_until, struct ExpandoParseError *err)
	Parse a conditional Expando.

Detailed Description

Expando Node for a Condition.

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

Function Documentation

node_condition_new()

struct ExpandoNode * node_condition_new	(	struct ExpandoNode *	node_cond,
		struct ExpandoNode *	node_true,
		struct ExpandoNode *	node_false,
		struct ExpandoFormat *	fmt
	)

Create a new Condition Expando Node.

Parameters

node_cond	Expando Node that will be tested
node_true	Node tree for the 'true' case
node_false	Node tree for the 'false' case
fmt	Formatting info

Return values

ptr	New Condition Expando Node

Definition at line 110 of file node_condition.c.

{
  ASSERT(node_cond);
 
  struct ExpandoNode *node = node_new();
 
  node->type = ENT_CONDITION;
  node->render = node_condition_render;
 
  ARRAY_SET(&node->children, ENC_CONDITION, node_cond);
  ARRAY_SET(&node->children, ENC_TRUE, node_true);
  ARRAY_SET(&node->children, ENC_FALSE, node_false);
 
  node->format = fmt;
 
  return node;
}

Here is the call graph for this function:

Here is the caller graph for this function:

node_condition_parse()

struct ExpandoNode * node_condition_parse	(	const char *	str,
		NodeTextTermFlags	term_chars,
		const struct ExpandoDefinition *	defs,
		const char **	parsed_until,
		struct ExpandoParseError *	err
	)

Parse a conditional Expando.

Parameters

[in]	str	String to parse
[in]	term_chars	Terminator characters, e.g. NTE_GREATER
[in]	defs	Expando definitions
[out]	parsed_until	First character after parsed string
[out]	err	Buffer for errors

Return values

ptr	Expando Node

Definition at line 140 of file node_condition.c.

{
  if (!str || (str[0] != '%'))
    return NULL;
 
  str++; // Skip %
 
  struct ExpandoFormat *fmt = NULL;
  struct ExpandoNode *node_cond = NULL;
  struct ExpandoNode *node_true = NULL;
  struct ExpandoNode *node_false = NULL;
 
  //----------------------------------------------------------------------------
  // Parse the format (optional)
  fmt = parse_format(str, parsed_until, err);
  if (err->position)
    goto fail;
 
  str = *parsed_until;
 
  if ((str[0] != '<') && (str[0] != '?'))
    goto fail;
 
  const bool old_style = (str[0] == '?'); // %?X?...&...?
  str++;
 
  //----------------------------------------------------------------------------
  // Parse the condition
  node_cond = parse_short_name(str, defs, EP_CONDITIONAL, NULL, parsed_until, err);
  if (!node_cond)
    goto fail;
 
  if (node_cond->type == ENT_EXPANDO)
  {
    node_cond->type = ENT_CONDBOOL;
    node_cond->render = node_condbool_render;
  }
 
  str = *parsed_until; // Skip the expando
  if (str[0] != '?')
  {
    err->position = str;
    snprintf(err->message, sizeof(err->message),
             // L10N: Expando is missing a terminator character
             //       e.g. "%[..." is missing the final ']'
             _("Conditional expando is missing '%c'"), '?');
    goto fail;
  }
  str++; // Skip the '?'
 
  //----------------------------------------------------------------------------
  // Parse the 'true' clause (optional)
  const NodeTextTermFlags term_true = term_chars | NTE_AMPERSAND |
                                      (old_style ? NTE_QUESTION : NTE_GREATER);
 
  node_true = node_container_new();
  node_parse_many(node_true, str, term_true, defs, parsed_until, err);
  if (err->position)
    goto fail;
 
  str = *parsed_until;
 
  //----------------------------------------------------------------------------
  // Parse the 'false' clause (optional)
 
  node_false = NULL;
  if (str[0] == '&')
  {
    str++;
    const NodeTextTermFlags term_false = term_chars | (old_style ? NTE_QUESTION : NTE_GREATER);
 
    node_false = node_container_new();
    node_parse_many(node_false, str, term_false, defs, parsed_until, err);
    if (err->position)
      goto fail;
 
    str = *parsed_until;
  }
 
  //----------------------------------------------------------------------------
  // Check for the terminator character
  const char terminator = old_style ? '?' : '>';
 
  if (str[0] != terminator)
  {
    err->position = str;
    snprintf(err->message, sizeof(err->message),
             // L10N: Expando is missing a terminator character
             //       e.g. "%[..." is missing the final ']'
             _("Conditional expando is missing '%c'"), '?');
    goto fail;
  }
 
  *parsed_until = str + 1;
 
  return node_condition_new(node_cond, node_true, node_false, fmt);
 
fail:
  FREE(&fmt);
  node_free(&node_cond);
  node_free(&node_true);
  node_free(&node_false);
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function: