node_condition.h File Reference

Expando Node for a Condition. More...

#include "node_text.h"

Include dependency graph for node_condition.h:

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

Go to the source code of this file.

Enumerations
enum	ENCondition { ENC_CONDITION , ENC_TRUE , ENC_FALSE }
	Names for the Condition's children. More...

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

Enumeration Type Documentation

ENCondition

enum ENCondition

Names for the Condition's children.

A Condition has three children:

• Expando that acts as the Condition
• Tree of Expandos for the true case
• Tree of Expandos for the false case

Enumerator
ENC_CONDITION	Index of Condition Node.
ENC_TRUE	Index of True Node.
ENC_FALSE	Index of False Node.

Definition at line 40 of file node_condition.h.

{
  ENC_CONDITION,      
  ENC_TRUE,           
  ENC_FALSE,          
};

Function Documentation

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 141 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
  // Try long name first if it looks like %<{NAME}?...>
  if (str[0] == '{')
  {
    node_cond = parse_long_name(str + 1, defs, EP_CONDITIONAL, NULL, parsed_until, err);
    if (node_cond)
    {
      if ((*parsed_until)[0] != '}')
      {
        err->position = *parsed_until;
        snprintf(err->message, sizeof(err->message), _("Expando is missing closing '}'"));
        goto fail;
      }
      (*parsed_until)++; // Skip the '}'
    }
    else if (err->position)
    {
      goto fail;
    }
    else
    {
      // Report an error if the content looks like a long name
      const char *name_start = str + 1;
      const char *end = name_start + strspn(name_start, "abcdefghijklmnopqrstuvwxyz0123456789-");
      if (end != name_start)
      {
        err->position = name_start;
        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 - name_start), name_start);
        goto fail;
      }
      // Doesn't look like a long name, fall through to parse_short_name
    }
  }
 
  if (!node_cond)
  {
    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: