Issues with recursion

[bruno-j-nicoletti]

I'm currently working on a grammar to parse expressions, which include function calls, and expressions are necessarily recursive. I differentiate beween function names and variable names, function names are identifiers while variable names are one or moreidentifiers seperated by '.' I've got a cut down grammar below which replicates my problem, which is that I'm getting a runtime assert when it is fed f(a), the assertion is....

Assertion failed: ((control_block->max_depth > 0) && ("dsl::recurse_branch<P> is disabled in this context")), function increment_depth, file production.hpp, line 154.

I've looked at the header, scratched my head and I've no idea what I'm doing wrong as I thought dsl::recurse_branch could handle indirect recursion. If I replace dsl::list(term, commaSeperator) in the FunctionTerm production with dsl::list(variable, commaSeperator) it all works fine, except that means I can't have expressions as function arguments.

Any help is appreciated. The grammar is...

struct Term;

constexpr auto term = dsl::recurse_branch<Term>;

/// An identifier production
struct IdentifierProduction : lexy::token_production
{
  static constexpr auto rule = [] {
    auto lead_char     = dsl::ascii::alpha;
    auto trailing_char = dsl::ascii::word;
    return dsl::identifier(lead_char, trailing_char);
  }();
};

constexpr auto identifier = dsl::p<IdentifierProduction>;

/// the variable seperator literal
constexpr auto variableSeperatorLiteral = dsl::lit_c<'.'>;

/// the variable seperator
constexpr auto variableSeperator = dsl::sep(variableSeperatorLiteral);

/// A variable
struct VariableProduction
{
  static constexpr auto rule = [] {
    return dsl::list(identifier, variableSeperator);
  }();
};

/// the variable rule
constexpr auto variable = dsl::p<VariableProduction>;

/// comma literal parens
constexpr auto commaLiteral = dsl::lit_c<','>;

/// the variable seperator
constexpr auto commaSeperator = dsl::sep(commaLiteral);

/// the function term
struct Function {
  static constexpr auto whitespace = dsl::ascii::space;
  static constexpr auto rule = [] {
    return identifier + LEXY_LIT("(") + dsl::list(term, commaSeperator) +  LEXY_LIT(")") ;
  }();
};

constexpr auto function = dsl::p<Function>;

struct Term
{
  static constexpr auto rule = [] {
    auto isFunction = dsl::peek(function);
    return isFunction >> function | variable ;
  }();
};

using production = Term;

[bruno-j-nicoletti]

Fixed it! Changing the condition in Term did it. Looks like calling recursive products in peek isn't a good thing.

struct Term
{
  static constexpr auto rule = [] {
    auto isFunction = dsl::peek(identifier + LEXY_LIT("("));
    return isFunction >> function | variable ;
  }();
};

[foonathan]

Yes, in generally you want to do as little as possible in dsl::peek.

[foonathan]

You want to use a lexy::expression_production for that, with a postfix operator:https://lexy.foonathan.net/playground/?id=bTWo1o9jW&mode=tree

[bruno-j-nicoletti]

Thanks. I've got it all working now and I'm using expression_production for parsing operators.