Handling similar syntaxes

[qawbecrdtey]

I am making a simple parser with grammar where n, {e + e}, and {e - e} are expressions. I wrote a code like:

namespace Example {
    namespace {
///...
        struct integer : digits {};
        struct expression;
        struct add : tao::pegtl::must<
                  open_curly,
                  expression,
                  plus,
                  expression,
                  close_curly
                > {};
        struct subtract : tao::pegtl::must<
                  open_curly,
                  expression,
                  minus,
                  expression,
                  close_curly
                > {};
        struct expression : tao::pegtl::must<empty, tao::pegtl::sor<
                  integer,
                  add,
                  subtract
                >, empty> {};
    }

    struct grammar : tao::pegtl::until<eof, expression> {};

/// actions...
}

The program works well with input like {{1 + 2} + {3 + 4}}, but it will return an error parse error matching Example::(anonymous namespace)::plus whenever I put a - in the string. I think the error appears in struct expression since subtract appears after add in sor, but I can't find a way to fix this problem. Would anyone give me advice with this? Also, it would be nice if anyone could give me a way to actually calculate the expression.

[nshcat]

I think it will work if you remove the must rule in both add and subtract. It causes a failure of add to be converted into a global failure, but you want a local failure in order to use back tracking in your sor

[qawbecrdtey]

Thanks @nshcat ! I must have misunderstood the rule reference "Allows local failure of R... even within must<> etc."

[ColinH]

@qawbecrdtey The part of the rule reference that you quoted is indeed easy to misunderstand, we removed the offending occurrences of that sentence.