shell_node.h

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "BashSpark/shell/shell_status.h"
 
namespace bs {
    class shell_session;
}
 
namespace bs {
    enum class shell_node_type {
        SNT_COMMAND_EXPRESSION,
        SNT_STR_SIMPLE,
        SNT_STR_DOUBLE,
        SNT_STR_BACK,
        SNT_WORD,
        SNT_UNICODE,
        SNT_ARG,
        SNT_VARIABLE,
        SNT_DOLLAR_SPECIAL,
        SNT_DOLLAR_VARIABLE,
        SNT_DOLLAR_VARIABLE_DHOP,
        SNT_DOLLAR_ARG,
        SNT_DOLLAR_ARG_DHOP,
        SNT_DOLLAR_COMMAND,
        SNT_BACKGROUND,
        SNT_AND,
        SNT_PIPE,
        SNT_OR,
        // Structure
        SNT_IF,
        SNT_TEST,
        SNT_FOR,
        SNT_WHILE,
        SNT_UNTIL,
        SNT_BREAK,
        SNT_CONTINUE,
        SNT_FUNCTION,
        // Executable
        SNT_NULL_COMMAND,
        SNT_COMMAND,
        SNT_COMMAND_BLOCK,
        SNT_COMMAND_BLOCK_SUBSHELL,
    };
 
    class shell_node_invalid_argument final : public std::invalid_argument {
    public:
        explicit shell_node_invalid_argument(const std::string &sMessage)
            : std::invalid_argument(sMessage) {
        }
    };
 
    class shell_node {
    public:
        virtual ~shell_node() = default;
 
    protected:
        shell_node(
            const shell_node_type nType,
            const std::size_t nPos
        )
            : m_nType(nType),
              m_nPos(nPos) {
        }
 
    public:
        [[nodiscard]] shell_node_type get_type() const noexcept {
            return this->m_nType;
        }
 
        [[nodiscard]] std::size_t get_pos() const noexcept {
            return this->m_nPos;
        }
 
    protected:
        const shell_node_type m_nType; 
        const std::size_t m_nPos; 
    };
 
    class shell_node_evaluable : public virtual shell_node {
    public:
        shell_node_evaluable(
            const shell_node_type nType,
            const std::size_t nPos
        )
            : shell_node(nType, nPos) {
        }
 
    public:
        virtual shell_status evaluate(shell_session &oSession) const =0;
    };
 
    class shell_node_expandable : public virtual shell_node {
    public:
        shell_node_expandable(
            const shell_node_type nType,
            const std::size_t nPos
        )
            : shell_node(nType, nPos) {
        }
 
    public:
        virtual void expand(
            std::vector<std::string> &vTokens,
            shell_session &oSession,
            bool bSplit
        ) const =0;
    };
 
    class shell_node_command_expression final : public shell_node_expandable {
    public:
        explicit shell_node_command_expression(
            std::vector<std::unique_ptr<shell_node_expandable> > &&vChildren
        );
 
    public:
        void expand(
            std::vector<std::string> &vTokens,
            shell_session &oSession,
            bool bSplit
        ) const override;
 
    public:
        [[nodiscard]] const std::vector<std::unique_ptr<shell_node_expandable> > &get_children() const noexcept {
            return this->m_vChildren;
        }
 
    private:
        std::vector<std::unique_ptr<shell_node_expandable> > m_vChildren; 
    };
 
    class shell_node_str : public shell_node_expandable {
    protected:
        shell_node_str(
            shell_node_type nType,
            std::size_t nPos,
            std::vector<std::unique_ptr<shell_node_expandable> > &&vChildren
        );
 
    public:
        void expand(
            std::vector<std::string> &vTokens,
            shell_session &oSession,
            bool bSplit
        ) const override;
 
        [[nodiscard]] const std::vector<std::unique_ptr<shell_node_expandable> > &get_children() const noexcept {
            return this->m_vChildren;
        }
 
    private:
        std::vector<std::unique_ptr<shell_node_expandable> > m_vChildren; 
    };
 
    class shell_node_str_simple final : public shell_node_str {
    public:
        shell_node_str_simple(
            const std::size_t nPos,
            std::vector<std::unique_ptr<shell_node_expandable> > &&vChildren
        )
            : shell_node(shell_node_type::SNT_STR_SIMPLE, nPos),
              shell_node_str(shell_node_type::SNT_STR_SIMPLE, nPos, std::move(vChildren)) {
        }
    };
 
    class shell_node_str_double final : public shell_node_str {
    public:
        shell_node_str_double(
            const std::size_t nPos,
            std::vector<std::unique_ptr<shell_node_expandable> > &&vChildren
        )
            : shell_node(shell_node_type::SNT_STR_DOUBLE, nPos),
              shell_node_str(shell_node_type::SNT_STR_DOUBLE, nPos, std::move(vChildren)) {
        }
    };
 
    class shell_node_str_back final : public shell_node_expandable {
    public:
        shell_node_str_back(
            std::size_t nPos,
            std::unique_ptr<shell_node_evaluable> &&pCommand
        );
 
    public:
        void expand(
            std::vector<std::string> &vTokens,
            shell_session &oSession,
            bool bSplit
        ) const override;
 
        [[nodiscard]] const shell_node_evaluable *get_command() const noexcept {
            return this->m_pCommand.get();
        }
 
    private:
        std::unique_ptr<shell_node_evaluable> m_pCommand; 
    };
 
    class shell_node_word final : public shell_node_expandable {
    public:
        shell_node_word(
            const std::size_t nPos,
            std::string sText
        ) : shell_node(shell_node_type::SNT_WORD, nPos),
            shell_node_expandable(shell_node_type::SNT_WORD, nPos),
            m_sText(std::move(sText)) {
        }
 
    public:
        void expand(
            std::vector<std::string> &vTokens,
            shell_session &oSession,
            bool bSplit
        ) const override;
 
    public:
        [[nodiscard]] std::string get_text() const noexcept {
            return this->m_sText;
        }
 
    private:
        std::string m_sText; 
    };
 
    class shell_node_unicode final : public shell_node_expandable {
    public:
        shell_node_unicode(
            const std::size_t nPos,
            const char32_t cCharacter
        ) : shell_node(shell_node_type::SNT_UNICODE, nPos),
            shell_node_expandable(shell_node_type::SNT_UNICODE, nPos),
            m_cCharacter(cCharacter) {
        }
 
    public:
        void expand(
            std::vector<std::string> &vTokens,
            shell_session &oSession,
            bool bSplit
        ) const override;
 
    public:
        [[nodiscard]] char32_t get_character() const noexcept {
            return this->m_cCharacter;
        }
 
    private:
        char32_t m_cCharacter; 
    };
 
    class shell_node_session_extractor : public shell_node_expandable {
    public:
        shell_node_session_extractor(
            const shell_node_type nType,
            const std::size_t nPos
        )
            : shell_node(nType, nPos),
              shell_node_expandable(nType, nPos) {
        }
 
    public:
        void expand(
            std::vector<std::string> &vTokens,
            shell_session &oSession,
            bool bSplit
        ) const override;
 
    public:
        [[nodiscard]] virtual std::string get_value(const shell_session &oSession) const =0;
    };
 
    class shell_node_arg final : public shell_node_session_extractor {
    public:
        shell_node_arg(
            const std::size_t nPos,
            const std::uint64_t nArg
        ) : shell_node(shell_node_type::SNT_ARG, nPos),
            shell_node_session_extractor(shell_node_type::SNT_ARG, nPos),
            m_nArg(nArg) {
        }
 
    public:
        [[nodiscard]] std::string get_value(const shell_session &oSession) const override;
 
        [[nodiscard]] std::uint64_t get_arg() const noexcept {
            return this->m_nArg;
        }
 
    private:
        std::uint64_t m_nArg; 
    };
 
    class shell_node_variable final : public shell_node_session_extractor {
    public:
        shell_node_variable(
            const std::size_t nPos,
            std::string sVariable
        ) : shell_node(shell_node_type::SNT_VARIABLE, nPos),
            shell_node_session_extractor(shell_node_type::SNT_VARIABLE, nPos),
            m_sVariable(std::move(sVariable)) {
        }
 
    public:
        [[nodiscard]] std::string get_value(const shell_session &oSession) const override;
 
        [[nodiscard]] std::string get_variable() const noexcept {
            return this->m_sVariable;
        }
 
    private:
        std::string m_sVariable; 
    };
 
    class shell_node_dollar_variable final : public shell_node_session_extractor {
    public:
        shell_node_dollar_variable(
            const std::size_t nPos,
            std::string sVariable
        ) : shell_node(shell_node_type::SNT_DOLLAR_VARIABLE, nPos),
            shell_node_session_extractor(shell_node_type::SNT_DOLLAR_VARIABLE, nPos),
            m_sVariable(std::move(sVariable)) {
        }
 
    public:
        [[nodiscard]] std::string get_value(const shell_session &oSession) const override;
 
        [[nodiscard]] std::string get_variable() const noexcept {
            return this->m_sVariable;
        }
 
    private:
        std::string m_sVariable; 
    };
 
    class shell_node_dollar_arg final : public shell_node_session_extractor {
    public:
        shell_node_dollar_arg(
            const std::size_t nPos,
            const std::uint64_t nArg
        ) : shell_node(shell_node_type::SNT_DOLLAR_ARG, nPos),
            shell_node_session_extractor(shell_node_type::SNT_DOLLAR_ARG, nPos),
            m_nArg(nArg) {
        }
 
    public:
        [[nodiscard]] std::string get_value(const shell_session &oSession) const override;
 
        [[nodiscard]] std::uint64_t get_arg() const noexcept {
            return this->m_nArg;
        }
 
    private:
        std::uint64_t m_nArg; 
    };
 
    class shell_node_dollar_arg_dhop final : public shell_node_session_extractor {
    public:
        shell_node_dollar_arg_dhop(
            const std::size_t nPos,
            const std::uint64_t nArg
        ) : shell_node(shell_node_type::SNT_DOLLAR_ARG_DHOP, nPos),
            shell_node_session_extractor(shell_node_type::SNT_DOLLAR_ARG_DHOP, nPos),
            m_nArg(nArg) {
        }
 
    public:
        [[nodiscard]] std::string get_value(const shell_session &oSession) const override;
 
        [[nodiscard]] std::uint64_t get_arg() const noexcept {
            return this->m_nArg;
        }
 
    private:
        std::uint64_t m_nArg; 
    };
 
    class shell_node_dollar_variable_dhop final : public shell_node_session_extractor {
    public:
        shell_node_dollar_variable_dhop(
            const std::size_t nPos,
            std::string sVariable
        ) : shell_node(shell_node_type::SNT_DOLLAR_VARIABLE_DHOP, nPos),
            shell_node_session_extractor(shell_node_type::SNT_DOLLAR_VARIABLE_DHOP, nPos),
            m_sVariable(std::move(sVariable)) {
        }
 
    public:
        [[nodiscard]] std::string get_value(const shell_session &oSession) const override;
 
        [[nodiscard]] std::string get_variable() const noexcept {
            return this->m_sVariable;
        }
 
    private:
        std::string m_sVariable; 
    };
 
    class shell_node_dollar_command final : public shell_node_expandable {
    public:
        shell_node_dollar_command(
            std::size_t nPos,
            std::unique_ptr<shell_node_evaluable> &&pCommand
        );
 
    public:
        void expand(
            std::vector<std::string> &vTokens,
            shell_session &oSession,
            bool bSplit
        ) const override;
 
        [[nodiscard]] const shell_node_evaluable *get_command() const noexcept {
            return this->m_pCommand.get();
        }
 
    private:
        std::unique_ptr<shell_node_evaluable> m_pCommand; 
    };
 
    class shell_node_dollar_special final : public shell_node_session_extractor {
    public:
        shell_node_dollar_special(
            const std::size_t nPos,
            const char cItem
        )
            : shell_node(shell_node_type::SNT_DOLLAR_SPECIAL, nPos),
              shell_node_session_extractor(shell_node_type::SNT_DOLLAR_SPECIAL, nPos),
              m_cItem(cItem) {
        }
 
    public:
        [[nodiscard]] std::string get_value(const shell_session &oSession) const override;
 
        [[nodiscard]] char get_item() const noexcept {
            return this->m_cItem;
        }
 
    private:
        char m_cItem; 
    };
 
    class shell_node_null_command final : public shell_node_evaluable {
    public:
        explicit shell_node_null_command(
            const std::size_t nPos
        )
            : shell_node(shell_node_type::SNT_NULL_COMMAND, nPos),
              shell_node_evaluable(shell_node_type::SNT_NULL_COMMAND, nPos) {
        }
 
    public:
        shell_status evaluate(shell_session &oSession) const override;
    };
 
    class shell_node_command final : public shell_node_evaluable {
    public:
        explicit shell_node_command(
            std::unique_ptr<shell_node_command_expression> &&pCommand
        );
 
    public:
        shell_status evaluate(shell_session &oSession) const override;
 
        [[nodiscard]] const shell_node_command_expression *get_command() const noexcept {
            return this->m_pCommand.get();
        }
 
    private:
        std::unique_ptr<shell_node_command_expression> m_pCommand; 
    };
 
    class shell_node_command_block final : public shell_node_evaluable {
    public:
        shell_node_command_block(
            const std::size_t nPos,
            std::vector<std::unique_ptr<shell_node_evaluable> > &&vSubCommands
        )
            : shell_node(shell_node_type::SNT_COMMAND_BLOCK, nPos),
              shell_node_evaluable(shell_node_type::SNT_COMMAND_BLOCK, nPos),
              m_vSubCommands(std::move(vSubCommands)) {
        }
 
    public:
        shell_status evaluate(shell_session &oSession) const override;
 
        [[nodiscard]] const std::vector<std::unique_ptr<shell_node_evaluable> > &get_children() const noexcept {
            return this->m_vSubCommands;
        }
 
    private:
        std::vector<std::unique_ptr<shell_node_evaluable> > m_vSubCommands; 
    };
 
    class shell_node_command_block_subshell final : public shell_node_evaluable {
    public:
        shell_node_command_block_subshell(
            const std::size_t nPos,
            std::vector<std::unique_ptr<shell_node_evaluable> > &&vSubCommands
        )
            : shell_node(shell_node_type::SNT_COMMAND_BLOCK_SUBSHELL, nPos),
              shell_node_evaluable(shell_node_type::SNT_COMMAND_BLOCK_SUBSHELL, nPos),
              m_vSubCommands(std::move(vSubCommands)) {
        }
 
    public:
        shell_status evaluate(shell_session &oSession) const override;
 
        [[nodiscard]] const std::vector<std::unique_ptr<shell_node_evaluable> > &get_children() const noexcept {
            return this->m_vSubCommands;
        }
 
    private:
        std::vector<std::unique_ptr<shell_node_evaluable> > m_vSubCommands; 
    };
 
    class shell_node_background final : public shell_node_evaluable {
    public:
        shell_node_background(
            std::size_t nPos,
            std::unique_ptr<shell_node_evaluable> &&pCommand
        );
 
    public:
        shell_status evaluate(shell_session &oSession) const override;
 
    public:
        [[nodiscard]] const shell_node_evaluable *get_command() const noexcept {
            return this->m_pCommand.get();
        }
 
    private:
        std::unique_ptr<shell_node_evaluable> m_pCommand; 
    };
 
    class shell_node_operator : public shell_node_evaluable {
    public:
        constexpr static int PRIORITY_PIPE = 5;
        constexpr static int PRIORITY_AND = 4;
        constexpr static int PRIORITY_OR = 3;
 
    public:
        static std::unique_ptr<shell_node_evaluable> make(
            shell_node_type nType,
            std::size_t nPos,
            std::unique_ptr<shell_node_evaluable> &&pLeft,
            std::unique_ptr<shell_node_evaluable> &&pRight
        );
 
    protected:
        shell_node_operator(
            shell_node_type nType,
            std::size_t nPos,
            int nPriority,
            std::unique_ptr<shell_node_evaluable> &&pLeft,
            std::unique_ptr<shell_node_evaluable> &&pRight
        );
 
    protected:
        shell_node_operator(
            shell_node_type nType,
            std::size_t nPos,
            int nPriority
        );
 
    public:
        [[nodiscard]] int get_priority() const noexcept {
            return this->m_nPriority;
        }
 
        [[nodiscard]] const shell_node_evaluable *get_left() const noexcept {
            return this->m_pLeft.get();
        }
 
        [[nodiscard]] const shell_node_evaluable *get_right() const noexcept {
            return this->m_pRight.get();
        }
 
        std::unique_ptr<shell_node_evaluable> swap_left(std::unique_ptr<shell_node_evaluable> &&pLeft);
 
        std::unique_ptr<shell_node_evaluable> swap_right(std::unique_ptr<shell_node_evaluable> &&pRight);
 
    private:
        int m_nPriority;
        std::unique_ptr<shell_node_evaluable> m_pLeft;
        std::unique_ptr<shell_node_evaluable> m_pRight;
    };
 
    class shell_node_and final : public shell_node_operator {
        friend class shell_node_operator;
 
    public:
        shell_node_and(
            const std::size_t nPos,
            std::unique_ptr<shell_node_evaluable> &&pLeft,
            std::unique_ptr<shell_node_evaluable> &&pRight
        )
            : shell_node(shell_node_type::SNT_AND, nPos),
              shell_node_operator(
                  shell_node_type::SNT_AND, nPos, PRIORITY_AND,
                  std::move(pLeft), std::move(pRight)
              ) {
        }
 
    public:
        shell_status evaluate(shell_session &oSession) const override;
 
    private:
        explicit shell_node_and(
            const std::size_t nPos
        )
            : shell_node(shell_node_type::SNT_AND, nPos),
              shell_node_operator(shell_node_type::SNT_AND, nPos, PRIORITY_AND) {
        }
    };
 
    class shell_node_pipe final : public shell_node_operator {
        friend class shell_node_operator;
 
    public:
        shell_node_pipe(
            const std::size_t nPos,
            std::unique_ptr<shell_node_evaluable> &&pLeft,
            std::unique_ptr<shell_node_evaluable> &&pRight
        )
            : shell_node(shell_node_type::SNT_PIPE, nPos),
              shell_node_operator(
                  shell_node_type::SNT_PIPE, nPos, PRIORITY_PIPE,
                  std::move(pLeft), std::move(pRight)
              ) {
        }
 
    public:
        shell_status evaluate(shell_session &oSession) const override;
 
    private:
        explicit shell_node_pipe(
            const std::size_t nPos
        )
            : shell_node(shell_node_type::SNT_PIPE, nPos),
              shell_node_operator(shell_node_type::SNT_PIPE, nPos, PRIORITY_PIPE) {
        }
    };
 
    class shell_node_or final : public shell_node_operator {
        friend class shell_node_operator;
 
    public:
        shell_node_or(
            const std::size_t nPos,
            std::unique_ptr<shell_node_evaluable> &&pLeft,
            std::unique_ptr<shell_node_evaluable> &&pRight
        )
            : shell_node(shell_node_type::SNT_OR, nPos),
              shell_node_operator(
                  shell_node_type::SNT_OR, nPos, PRIORITY_OR,
                  std::move(pLeft), std::move(pRight)
              ) {
        }
 
    public:
        shell_status evaluate(shell_session &oSession) const override;
 
    private:
        explicit shell_node_or(
            const std::size_t nPos
        )
            : shell_node(shell_node_type::SNT_OR, nPos),
              shell_node_operator(shell_node_type::SNT_OR, nPos, PRIORITY_OR) {
        }
    };
 
    class shell_node_test final : public shell_node_evaluable {
    public:
        shell_node_test(
            std::size_t nPos,
            std::unique_ptr<shell_node_expandable> &&pTest
        );
 
    public:
        shell_status evaluate(shell_session &oSession) const override;
 
    public:
        [[nodiscard]] const shell_node_expandable *get_test() const noexcept {
            return this->m_pTest.get();
        }
 
    private:
        std::unique_ptr<shell_node_expandable> m_pTest;
    };
 
 
    class shell_node_if final : public shell_node_evaluable {
    public:
        shell_node_if(
            std::size_t nPos,
            std::unique_ptr<shell_node_evaluable> &&pCondition,
            std::unique_ptr<shell_node_evaluable> &&pCaseIf,
            std::unique_ptr<shell_node_evaluable> &&pCaseElse
        );
 
    public:
        shell_status evaluate(shell_session &oSession) const override;
 
    public:
        [[nodiscard]] const shell_node_evaluable *get_condition() const noexcept {
            return this->m_pCondition.get();
        }
 
        [[nodiscard]] const shell_node_evaluable *get_case_if() const noexcept {
            return this->m_pCaseIf.get();
        }
 
        [[nodiscard]] const shell_node_evaluable *get_case_else() const noexcept {
            return this->m_pCaseElse.get();
        }
 
    private:
        std::unique_ptr<shell_node_evaluable> m_pCondition;
        std::unique_ptr<shell_node_evaluable> m_pCaseIf;
        std::unique_ptr<shell_node_evaluable> m_pCaseElse;
    };
 
    class shell_node_continue final : public shell_node_evaluable {
    public:
        class continue_signal final : public std::runtime_error {
        public:
            continue_signal() : std::runtime_error("") {
            }
        };
 
    public:
        shell_status evaluate(shell_session &oSession) const override;
 
    public:
        explicit shell_node_continue(const std::size_t nPos)
            : shell_node(shell_node_type::SNT_CONTINUE, nPos),
              shell_node_evaluable(shell_node_type::SNT_CONTINUE, nPos) {
        }
    };
 
    class shell_node_break final : public shell_node_evaluable {
    public:
        class break_signal final : public std::runtime_error {
        public:
            break_signal() : std::runtime_error("") {
            }
        };
 
    public:
        shell_status evaluate(shell_session &oSession) const override;
 
    public:
        explicit shell_node_break(const std::size_t nPos)
            : shell_node(shell_node_type::SNT_CONTINUE, nPos),
              shell_node_evaluable(shell_node_type::SNT_CONTINUE, nPos) {
        }
    };
 
    class shell_node_for final : public shell_node_evaluable {
    public:
        shell_node_for(
            std::size_t nPos,
            std::string sVariable,
            std::unique_ptr<shell_node_expandable> &&pSequence,
            std::unique_ptr<shell_node_evaluable> &&pIterative
        );
 
    public:
        shell_status evaluate(shell_session &oSession) const override;
 
    public:
        [[nodiscard]] const std::string &get_variable() const noexcept {
            return this->m_sVariable;
        }
 
        [[nodiscard]] const shell_node_expandable *get_sequence() const noexcept {
            return this->m_pSequence.get();
        }
 
        [[nodiscard]] const shell_node_evaluable *get_iterative() const noexcept {
            return this->m_pIterative.get();
        }
 
    private:
        std::string m_sVariable; 
        std::unique_ptr<shell_node_expandable> m_pSequence; 
        std::unique_ptr<shell_node_evaluable> m_pIterative; 
    };
 
 
    class shell_node_while final : public shell_node_evaluable {
    public:
        shell_node_while(
            std::size_t nPos,
            std::unique_ptr<shell_node_evaluable> &&pCondition,
            std::unique_ptr<shell_node_evaluable> &&pIterative
        );
 
    public:
        shell_status evaluate(shell_session &oSession) const override;
 
    public:
        [[nodiscard]] const shell_node_evaluable *get_condition() const noexcept {
            return this->m_pCondition.get();
        }
 
        [[nodiscard]] const shell_node_evaluable *get_iterative() const noexcept {
            return this->m_pIterative.get();
        }
 
    private:
        std::unique_ptr<shell_node_evaluable> m_pCondition;
        std::unique_ptr<shell_node_evaluable> m_pIterative;
    };
 
 
    class shell_node_until final : public shell_node_evaluable {
    public:
        shell_node_until(
            std::size_t nPos,
            std::unique_ptr<shell_node_evaluable> &&pCondition,
            std::unique_ptr<shell_node_evaluable> &&pIterative
        );
 
    public:
        shell_status evaluate(shell_session &oSession) const override;
 
    public:
        [[nodiscard]] const shell_node_evaluable *get_condition() const noexcept {
            return this->m_pCondition.get();
        }
 
        [[nodiscard]] const shell_node_evaluable *get_iterative() const noexcept {
            return this->m_pIterative.get();
        }
 
    private:
        std::unique_ptr<shell_node_evaluable> m_pCondition;
        std::unique_ptr<shell_node_evaluable> m_pIterative;
    };
 
    class shell_node_function final : public shell_node_evaluable {
    public:
        shell_node_function(
            std::size_t nPos,
            std::unique_ptr<shell_node_expandable> &&pName,
            std::unique_ptr<shell_node_evaluable> &&pBody
        );
 
    public:
        shell_status evaluate(shell_session &oSession) const override;
 
    public:
        [[nodiscard]] const shell_node_expandable *get_name() const noexcept {
            return this->m_pName.get();
        }
 
        [[nodiscard]] const shell_node_evaluable *get_body() const noexcept {
            return this->m_pBody.get();
        }
 
    private:
        std::unique_ptr<shell_node_expandable> m_pName;
        std::unique_ptr<shell_node_evaluable> m_pBody;
    };
} // namespace bs