Lug 0.5.0

// lug - Embedded DSL for PE grammar parser combinators in C++
// Copyright (c) 2017-2025 Jesse W. Towner
// See LICENSE.md file for license details

#include <lug/lug.hpp>
#include <lug/iostream.hpp>

#include <cstdlib>

namespace samples::calc {

using namespace lug::language;

int i;
double e, l, n, r, s;
double v[26];

extern rule Expr;

implicit_space_rule BLANK = lexeme[ *"[ \t]"_rx ];

rule EOL    = lexeme[ "[\n\r;]"_rx ];
rule ID     = lexeme[ "[a-zA-Z]"_rx  <[](syntax m) -> int { return static_cast<int>(lug::unicode::tolower(static_cast<char32_t>(m.str().at(0))) - U'a'); } ];
rule NUMBER = lexeme[ ( ~"[-+]"_rx > +"[0-9]"_rx > ~('.' > +"[0-9]"_rx) )
                                     <[](syntax m) -> double { return std::stod(std::string{m}); } ];
rule Value  = n%NUMBER               <[]{ return n; }
            | i%ID > !"="_sx         <[]{ return v[i]; }
            | '(' > e%Expr > ')'     <[]{ return e; };
rule Prod   = l%Value > *(
                  '*' > r%Value      <[]{ l *= r; }
                | '/' > r%Value      <[]{ l /= r; }
            )                        <[]{ return l; };
rule Sum    = l%Prod > *(
                  '+' > r%Prod       <[]{ l += r; }
                | '-' > r%Prod       <[]{ l -= r; }
            )                        <[]{ return l; };
rule Expr   = i%ID > '=' > s%Sum     <[]{ return v[i] = s; }
            | s%Sum                  <[]{ return s; };
rule Stmt   = ( (   "exit"_isx
                  | "quit"_isx )     <[]{ std::exit(EXIT_SUCCESS); }
                | e%Expr             <[]{ std::cout << e << "\n"; }
            ) > EOL
            | *( !EOL > any ) > EOL  <[]{ std::cout << "SYNTAX ERROR\n"; };

grammar Grammar = start(Stmt > eoi);

} // namespace samples::calc

int main()
try {
    while (lug::parse(samples::calc::Grammar, lug::source_options::interactive)) ;
    return 0;
} catch (std::exception const& e) {
    std::cerr << "ERROR: " << e.what() << "\n";
    return 1;
} catch (...) {
    std::cerr << "UNKNOWN ERROR\n";
    return 1;
}

rule Value  = n%NUMBER               <[]{ return n; }
            | i%ID > !"="_sx         <[]{ return v[i]; }
            | '(' > e%Expr > ')'     <[]{ return e; };

namespace grammar
{
    namespace dsl = lexy::dsl;

    constexpr auto escaped_newline = dsl::backslash >> dsl::newline;

    // An integer literal.
    // Supports hexadecimal and decimal literals.
    struct integer : lexy::token_production
    {
        static constexpr auto rule
            = LEXY_LIT("0x") >> dsl::integer<int, dsl::hex> | dsl::integer<int>;

        static constexpr auto value = lexy::forward<int>;
    };

    // A Unicode-aware identifier.
    struct name
    {
        static constexpr auto rule
            = dsl::identifier(dsl::unicode::xid_start_underscore, dsl::unicode::xid_continue);

        static constexpr auto value = lexy::as_string<std::string>;
    };

    // An expression that is nested inside another expression.
    struct nested_expr : lexy::transparent_production
    {
        // We change the whitespace rule to allow newlines:
        // as it's nested, the REPL can properly handle continuation lines.
        static constexpr auto whitespace = dsl::ascii::space | escaped_newline;
        // The rule itself just recurses back to expression, but with the adjusted whitespace now.
        static constexpr auto rule = dsl::recurse<struct expr>;

        static constexpr auto value = lexy::forward<ast::expr_ptr>;
    };

    // An arbitrary expression.
    // It uses lexy's built-in support for operator precedence parsing to automatically generate a
    // proper rule. This is done by inheriting from expression_production.
    struct expr : lexy::expression_production
    {
        struct expected_operand
        {
            static constexpr auto name = "expected operand";
        };

        // We need to specify the atomic part of an expression.
        static constexpr auto atom = [] {
            auto paren_expr = dsl::parenthesized(dsl::p<nested_expr>);
            // Functions can only have a single argument for simplicity.
            auto var_or_call = dsl::p<name> >> dsl::if_(paren_expr);
            auto literal     = dsl::p<integer>;

            return paren_expr | var_or_call | literal | dsl::error<expected_operand>;
        }();

        // Each of the nested classes defines one operation.
        // They inherit from a tag type that specify the kind of operation (prefix, infix, postfix),
        // and associativy (left, right, single (non-associative)),
        // and specify the operator rule and operand.

        // x**2
        struct math_power : dsl::infix_op_right
        {
            static constexpr auto op = dsl::op<ast::expr_binary_arithmetic::pow>(LEXY_LIT("**"));

            // math_power has highest binding power, so it's operand is the atom rule.
            using operand = dsl::atom;
        };
        // -x
        struct math_prefix : dsl::prefix_op
        {
            static constexpr auto op = dsl::op<ast::expr_unary_arithmetic::negate>(LEXY_LIT("-"));

            using operand = math_power;
        };
        // x * x, x / x
        struct math_product : dsl::infix_op_left
        {
            static constexpr auto op = [] {
                // Since we have both ** and * as possible operators, we need to ensure that * is
                // only matched when it is not followed by *. In the particular situation where **
                // has higher binding power, it doesn't actually matter here, but it's better to be
                // more resilient.
                auto star = dsl::not_followed_by(LEXY_LIT("*"), dsl::lit_c<'*'>);
                return dsl::op<ast::expr_binary_arithmetic::times>(star)
                       / dsl::op<ast::expr_binary_arithmetic::div>(LEXY_LIT("/"));
            }();
            using operand = math_prefix;
        };
        // x + x, x - x
        struct math_sum : dsl::infix_op_left
        {
            static constexpr auto op = dsl::op<ast::expr_binary_arithmetic::plus>(LEXY_LIT("+"))
                                       / dsl::op<ast::expr_binary_arithmetic::minus>(LEXY_LIT("-"));

            using operand = math_product;
        };

        // ~x
        struct bit_prefix : dsl::prefix_op
        {
            static constexpr auto op
                = dsl::op<ast::expr_unary_arithmetic::complement>(LEXY_LIT("~"));
            using operand = dsl::atom;
        };
        // x & x
        struct bit_and : dsl::infix_op_left
        {
            static constexpr auto op = dsl::op<ast::expr_binary_arithmetic::bit_and>(LEXY_LIT("&"));
            using operand            = bit_prefix;
        };
        // x | x, x ^ x
        struct bit_or : dsl::infix_op_left
        {
            static constexpr auto op
                = dsl::op<ast::expr_binary_arithmetic::bit_or>(LEXY_LIT("|"))
                  / dsl::op<ast::expr_binary_arithmetic::bit_xor>(LEXY_LIT("^"));
            using operand = bit_and;
        };

        // Comparisons are list operators, which allows implementation of chaining.
        // x == y < z
        struct comparison : dsl::infix_op_list
        {
            // Other comparison operators omitted for simplicity.
            static constexpr auto op = dsl::op<ast::expr_comparison::equal>(LEXY_LIT("=="))
                                       / dsl::op<ast::expr_comparison::less>(LEXY_LIT("<"));

            // The use of dsl::groups ensures that an expression can either contain math or bit
            // operators. Mixing requires parenthesis.
            using operand = dsl::groups<math_sum, bit_or>;
        };

        // x ? y : z
        struct conditional : dsl::infix_op_single
        {
            // We treat a conditional operator, which has three operands,
            // as a binary operator where the operator consists of ?, the inner operator, and :.
            // The <void> ensures that `dsl::op` does not produce a value.
            static constexpr auto op
                = dsl::op<void>(LEXY_LIT("?") >> dsl::p<nested_expr> + dsl::lit_c<':'>);
            using operand = comparison;
        };

        struct assignment : dsl::infix_op_single
        {
            static constexpr auto op
                // Similar to * above, we need to prevent `=` from matching `==`.
                = dsl::op<void>(dsl::not_followed_by(LEXY_LIT("="), dsl::lit_c<'='>));
            using operand = conditional;
        };

        // An expression also needs to specify the operation with the lowest binding power.
        // The operation of everything else is determined by following the `::operand` member.
        using operation = assignment;

        static constexpr auto value =
            // We need a sink as the comparison expression generates a list.
            lexy::fold_inplace<std::unique_ptr<ast::expr_comparison>>(
                [] { return std::make_unique<ast::expr_comparison>(); },
                [](auto& node, ast::expr_ptr opr) { node->operands.push_back(LEXY_MOV(opr)); },
                [](auto& node, ast::expr_comparison::op_t op) { node->ops.push_back(op); })
            // The result of the list feeds into a callback that handles all other cases.
            >> lexy::callback(
                // atoms
                lexy::forward<ast::expr_ptr>, lexy::new_<ast::expr_literal, ast::expr_ptr>,
                lexy::new_<ast::expr_name, ast::expr_ptr>,
                lexy::new_<ast::expr_call, ast::expr_ptr>,
                // unary/binary operators
                lexy::new_<ast::expr_unary_arithmetic, ast::expr_ptr>,
                lexy::new_<ast::expr_binary_arithmetic, ast::expr_ptr>,
                // conditional and assignment
                lexy::new_<ast::expr_if, ast::expr_ptr>,
                lexy::new_<ast::expr_assignment, ast::expr_ptr>);
    };
} // namespace grammar