Goose  Artifact [65218d809d]

Artifact 65218d809d6f6dc7c061e95c88f16d1cb1ffdd38e3cd5b79dd1d8d9b139557ec:

• File bs/eir/term.h — part of check-in [6b3eee40c4] at 2021-09-25 15:53:33 on branch trunk — eir: implemented OrPattern term (user: achavasse size: 3767)

#ifndef GOOSE_EIR_TERM_H
#define GOOSE_EIR_TERM_H

namespace goose::eir
{
    class Vector;
    using pvec = ptr< Vector >;

    enum class Delimiter
    {
        OpenParen,
        OpenBrace,
        OpenBracket,

        CloseParen,
        CloseBrace,
        CloseBracket
    };

    struct STerm;

    class Hole
    {
        public:
            Hole() = default;

            Hole( StringId name );

            template< typename K >
            Hole( StringId name, K&& kind ) :
                m_name( name ),
                m_kind( make_shared< STerm >( STerm{ forward< K >( kind ) } ) )
            {}

            const auto& name() const { return m_name; }
            const auto& kind() const;

            bool operator<( const Hole& rhs ) const;
            bool operator==( const Hole& rhs ) const;

        private:
            StringId m_name;
            ptr< STerm > m_kind = make_shared< STerm >();
    };

    class OrPattern
    {
        public:
            OrPattern() = default;

            template< typename L, typename R >
            OrPattern( L&& lhs, R&& rhs ) :
                m_lhs( make_shared< STerm >( STerm{ forward< L >( lhs ) } ) ),
                m_rhs( make_shared< STerm >( STerm{ forward< R >( rhs ) } ) )
            {}

            const auto& lhs() const;
            const auto& rhs() const;

            bool operator<( const OrPattern& rhs ) const;
            bool operator==( const OrPattern& rhs ) const;

        private:
            ptr< STerm > m_lhs = make_shared< STerm >();
            ptr< STerm > m_rhs = make_shared< STerm >();
    };

    using Term = variant
    <
        uint32_t,
        LocationId,
        string,
        StringId,
        Delimiter,
        Hole,
        AnyTerm,
        VecOfLength,
        OrPattern,
        pvec,

        // Representation for ct_int, the compile time only integers
        // with "unlimited" precision
        BigInt,

        // Compile time representation for normal, fixed size integers
        APSInt,

        ptr< void >,
        void*
    >;

    extern bool operator==( const Term& lhs, const Term& rhs );
    extern bool operator!=( const Term& lhs, const Term& rhs );

    struct STerm
    {
        Term content;
    };

    inline Hole::Hole( StringId name ) : Hole( name, Term( "anykind"_sid ) ) {}
    inline const auto& Hole::kind() const { return m_kind->content; }

    inline const auto& OrPattern::lhs() const { return m_lhs->content; }
    inline const auto& OrPattern::rhs() const { return m_rhs->content; }

    extern ostream& operator<<( ostream& out, const Term& t );

    // A term associated with a location id.
    // Used to represent tokens and tokens/values coming out of the resolver.
    using TermLoc = pair< eir::Term, LocationId >;

    static inline auto operator|( const Term& lhs, const Term& rhs )
    {
        return Term( OrPattern( lhs, rhs ) );
    }

    static inline auto operator|( Term&& lhs, const Term& rhs )
    {
        return Term( OrPattern( move( lhs ), rhs ) );
    }

    static inline auto operator|( const Term& lhs, Term&& rhs )
    {
        return Term( OrPattern( lhs, move( rhs ) ) );
    }

    static inline auto operator|( Term&& lhs, Term&& rhs )
    {
        return Term( OrPattern( move( lhs ), move( rhs ) ) );
    }
}

#define TERM( x )           eir::Term( x )
#define TSTR( x )           TERM( string( x ) )
#define TSID( x )           TERM( #x##_sid )
#define HOLE( ... )         TERM( ( eir::Hole{ __VA_ARGS__ } ) )
#define ANYTERM( x )        TERM( eir::AnyTerm( #x##_sid ) )
#define VECOFLENGTH( x )    TERM( eir::VecOfLength( #x##_sid ) )
#define VEC( ... )          TERM( eir::Vector::Make( __VA_ARGS__ ) )
#define REPEAT( x )         eir::Repetition( x )

#endif