parse.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "parse.h"
#include "definition.h"
#include "helpers.h"
#include "node.h"
#include "node_condbool.h"
#include "node_condition.h"
#include "node_container.h"
#include "node_expando.h"
#include "node_text.h"
 
static const char *skip_until_if_true_end(const char *start, char end_terminator)
{
  int ctr = 0;
  char prev = '\0';
  while (*start)
  {
    if ((ctr == 0) && (((*start == end_terminator) && (prev != '%')) || (*start == '&')))
    {
      break;
    }
 
    // handle nested if-else-s
    if ((prev == '%') && (*start == '<'))
    {
      ctr++;
    }
 
    if ((*start == '>') && (prev != '%'))
    {
      ctr--;
    }
 
    prev = *start;
    start++;
  }
 
  return start;
}
 
static const char *skip_until_if_false_end(const char *start, char end_terminator)
{
  int ctr = 0;
  char prev = '\0';
  while (*start)
  {
    if ((ctr == 0) && (*start == end_terminator) && (prev != '%'))
    {
      break;
    }
 
    // handle nested if-else-s
    if ((prev == '%') && (*start == '<'))
    {
      ctr++;
    }
 
    if ((*start == '>') && (prev != '%'))
    {
      ctr--;
    }
 
    prev = *start;
    start++;
  }
 
  return start;
}
 
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)
{
  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;
}