parse.h File Reference

Expando Parsing. More...

#include "node_condition.h"

Include dependency graph for parse.h:

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

Go to the source code of this file.

Data Structures
struct	ExpandoParseError
	Buffer for parsing errors. More...

Functions
struct ExpandoNode *	node_parse (const char *str, const char *end, enum ExpandoConditionStart condition_start, const char **parsed_until, const struct ExpandoDefinition *defs, struct ExpandoParseError *err)
	Parse a format string into ExpandoNodes.

Detailed Description

Expando Parsing.

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

Function Documentation

node_parse()

struct ExpandoNode * node_parse	(	const char *	str,
		const char *	end,
		enum ExpandoConditionStart	condition_start,
		const char **	parsed_until,
		const struct ExpandoDefinition *	defs,
		struct ExpandoParseError *	err
	)

Parse a format string into ExpandoNodes.

Parameters

[in]	str	Start of string to parse
[in]	end	End of string to parse
[in]	condition_start	Flag for conditional expandos
[out]	parsed_until	First character after parsed string
[in]	defs	Expando definitions
[out]	err	Buffer for errors

Return values

ptr	Tree of ExpandoNodes representing the format string

Definition at line 124 of file parse.c.

{
  if (!str || (*str == '\0'))
    return NULL;
 
  while (*str && (end ? (str <= end) : true))
  {
    // %X -> expando
    // if there is condition like <X..., the `%` is implicit
    if ((*str == '%') ||
        ((condition_start == CON_START) && ((*str == '?') || (*str == '<'))))
    {
      str++;
 
      // %% -> "%"s
      if (*str == '%')
      {
        *parsed_until = str + 1;
        return node_text_new(str, str + 1);
      }
      // conditional
      else if ((*str == '?') || (*str == '<'))
      {
        bool old_style = (*str == '?');
        char end_terminator = old_style ? '?' : '>';
 
        const char *cond_end = skip_until_ch(str, '?');
        const char *next = NULL;
        struct ExpandoNode *node_cond = node_parse(str, cond_end, CON_START,
                                                   &next, defs, err);
        if (!node_cond)
          return NULL;
 
        if (*next != '?')
        {
          err->position = next;
          snprintf(err->message, sizeof(err->message),
                   // L10N: Expando is missing a terminator character
                   //       e.g. "%[..." is missing the final ']'
                   _("Conditional expando is missing '%c'"), '?');
          node_free(&node_cond);
          return NULL;
        }
 
        str = next + 1;
 
        const char *start_true = str;
        // nested if-else only allowed in the new style
        const char *end_true = skip_until_if_true_end(str, end_terminator);
        bool only_true = (*end_true == end_terminator);
        bool invalid = ((*end_true != '&') && !only_true);
 
        if (invalid)
        {
          err->position = end_true;
          snprintf(err->message, sizeof(err->message),
                   // L10N: Expando is missing a terminator character
                   //       e.g. "%[..." is missing the final ']'
                   _("Conditional expando is missing '&' or '%c'"), end_terminator);
          node_free(&node_cond);
          return NULL;
        }
 
        const char *if_true_parsed = NULL;
        struct ExpandoNode *node_true = node_container_new();
 
        while (start_true < end_true)
        {
          struct ExpandoNode *node = node_parse(start_true, end_true, CON_NO_CONDITION,
                                                &if_true_parsed, defs, err);
          if (!node)
          {
            node_free(&node_true);
            node_free(&node_cond);
            return NULL;
          }
 
          node_add_child(node_true, node);
 
          start_true = if_true_parsed;
        }
 
        if (only_true)
        {
          *parsed_until = end_true + 1;
          return node_condition_new(node_cond, node_true, NULL);
        }
        else
        {
          const char *start_false = end_true + 1;
          // nested if-else only allowed in the new style
          const char *end_false = skip_until_if_false_end(start_false, end_terminator);
 
          if (*end_false != end_terminator)
          {
            err->position = start_false;
            snprintf(err->message, sizeof(err->message),
                     // L10N: Expando is missing a terminator character
                     //       e.g. "%[..." is missing the final ']'
                     _("Conditional expando is missing '%c'"), end_terminator);
            node_free(&node_true);
            node_free(&node_cond);
            return NULL;
          }
 
          const char *if_false_parsed = NULL;
          struct ExpandoNode *node_false = node_container_new();
 
          while (start_false < end_false)
          {
            struct ExpandoNode *node = node_parse(start_false, end_false, CON_NO_CONDITION,
                                                  &if_false_parsed, defs, err);
            if (!node)
            {
              node_free(&node_true);
              node_free(&node_false);
              node_free(&node_cond);
              return NULL;
            }
 
            node_add_child(node_false, node);
 
            start_false = if_false_parsed;
          }
 
          *parsed_until = end_false + 1;
          return node_condition_new(node_cond, node_true, node_false);
        }
      }
      else // expando
      {
        ExpandoParserFlags flags = (condition_start == CON_START) ? EP_CONDITIONAL : EP_NO_FLAGS;
        struct ExpandoNode *node = NULL;
        if (flags & EP_CONDITIONAL)
        {
          node = node_condbool_parse(str, defs, flags, parsed_until, err);
        }
        else
        {
          node = node_expando_parse(str, defs, flags, parsed_until, err);
        }
 
        if (!node || err->position)
        {
          node_free(&node);
          return NULL;
        }
 
        return node;
      }
    }
    else // text
    {
      return node_text_parse(str, end, parsed_until);
    }
  }
 
  ASSERT(false && "Internal parsing error"); // LCOV_EXCL_LINE
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function: