/Users/theraven/Documents/Work/Teaching/Compilers ACS Module/Coursework/Resources/Pegmatite/ast.hh

/*-
 * Copyright (c) 2012, Achilleas Margaritis
 * Copyright (c) 2014-2016, David T. Chisnall
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * * Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef PEGMATITE_AST_HPP
#define PEGMATITE_AST_HPP


#include <cassert>
#include <list>
#include <unordered_map>
#include <sstream>
#include <memory>
#include <cxxabi.h>
#include "parser.hh"


namespace pegmatite {

std::string demangle(std::string);

#ifdef DEBUG_AST_CONSTRUCTION
template <class T> void debug_log(const char *msg, size_t depth, T *obj)
{
    std::string demangled = demangle(typeid(*obj).name());
    fprintf(stderr, "[%ld] %s %s (%p) off the AST stack\n",
            depth, msg, demangled.c_str(), static_cast<const void*>(obj));
}
#else
template <class T> void debug_log(const char *, size_t /* depth */, T *) {}
#endif // DEBUG_AST_CONSTRUCTION

class ASTNode;
template <class T, bool Optional> class ASTPtr;
template <class T> class ASTList;
template <class T> class BindAST;


typedef std::pair<const InputRange, std::unique_ptr<ASTNode>> ASTStackEntry;
typedef std::vector<ASTStackEntry> ASTStack;

#ifdef USE_RTTI
#define PEGMATITE_RTTI(thisclass, superclass)
#else

#define PEGMATITE_RTTI(thisclass, superclass)            \
    friend ASTNode;                                      \
protected:                                               \
    static char *classKind()                             \
    {                                                    \
        static char thisclass ## id;                     \
        return &thisclass ## id;                         \
    }                                                    \
public:                                                  \
    virtual bool isa(char *x) override                   \
    {                                                    \
        return (x == classKind()) ||                     \
                (superclass::isa(x));                    \
    }
#endif


class ASTNode
{
public:
    ASTNode() : parent_node(0) {}
    ASTNode(const ASTNode&) = delete;

    virtual ~ASTNode();

    ASTNode *parent() const { return parent_node; }

    virtual void construct(const InputRange &r, ASTStack &st) = 0;

private:
    ASTNode *parent_node;

    template <class T, bool Optional> friend class ASTPtr;
    template <class T> friend class ASTList;
    template <class T> friend class BindAST;

#ifndef USE_RTTI
protected:
    virtual char *kind() { return classKind(); }
    static char *classKind()
    {
        static char ASTNodeid;
        return &ASTNodeid;
    }
public:
    virtual bool isa(char *x)
    {
        return x == classKind();
    }
    template <class T> bool isa()
    {
        return isa(T::classKind());
    }
    template <class T> T* get_as()
    {
        auto *t = this;
        return t ? (isa<T>() ? static_cast<T*>(this) : nullptr) : nullptr;
    }
#else
public:
    template <class T> T* get_as()
    {
        return dynamic_cast<T*>(this);
    }
#endif
};


class ASTMember;


class ASTContainer : public ASTNode
{
public:
    ASTContainer();

    virtual void construct(const InputRange &r, ASTStack &st);

private:
    typedef std::vector<ASTMember *> ASTMember_vector;
    ASTMember_vector members;

    friend class ASTMember;
    PEGMATITE_RTTI(ASTContainer, ASTNode)
};


class ASTMember
{
public:
    ASTMember();

    ASTContainer *container() const { return container_node; }

    virtual void construct(const InputRange &r, ASTStack &st) = 0;
    virtual ~ASTMember();
protected:
    ASTContainer *container_node;
};

template<typename T>
T& constructValue(const pegmatite::InputRange &r, T& value)
{
    std::stringstream stream;
    for_each(r.begin(), r.end(), [&](char c) {stream << c;});
    stream >> value;
    return value;
}

template <class T, bool Optional = false> class ASTPtr : public ASTMember
{
public:
    ASTPtr() : ptr(nullptr) {}

    T *get() const
    {
        return ptr.get();
    }

    const std::unique_ptr<T> &operator *() const
    {
        return ptr;
    }

    const std::unique_ptr<T> &operator ->() const
    {
        assert(ptr);
        return ptr;
    }

    explicit operator bool() const noexcept
    {
        return static_cast<bool>(ptr);
    }

    virtual void construct(const InputRange &r, ASTStack &st)
    {
        if (st.empty() && Optional)
        {
            return;
        }
        assert(!st.empty() && "Stack must not be empty");
        ASTStackEntry &e = st.back();
        const InputRange &childRange = e.first;
        // If the entry isn't within the range of this, then it's just
        // something of the same type that happens to be adjacent to this
        // entry.
        if ((childRange.begin() < r.begin()) ||
            (childRange.end() > r.end()))
        {
            assert(Optional && "Required object not found");
            return;
        }
        //get the node
        ASTNode *node = e.second.get();

        //get the object
        T *obj = node->get_as<T>();

        assert((obj || Optional) && "Required objects must exist!");
        //if the object is optional, simply return
        if (Optional && !obj)
        {
            return;
        }
        debug_log("Popped", st.size()-1, obj);
        //set the new object
        ptr.reset(obj);
        //pop the node from the stack
        st.back().second.release();
        st.pop_back();
        ptr->parent_node = container_node;
    }

private:
    std::unique_ptr<T> ptr;
};


template <class T> class ASTList : public ASTMember
{
public:
    typedef std::list<std::unique_ptr<T>> container;

    ASTList() {}

    ASTList(const ASTList<T> &src)
    {
        _dup(src);
    }

    const container &objects() const
    {
        return child_objects;
    }

    size_t size() { return child_objects.size(); }
    bool empty() const { return child_objects.size() == 0; }
    typename container::iterator begin() { return child_objects.begin(); }
    typename container::iterator end() { return child_objects.end(); }
    typename container::reverse_iterator rbegin() { return child_objects.rbegin(); }
    typename container::reverse_iterator rend() { return child_objects.rend(); }

    typename container::const_iterator begin() const
    {
        return child_objects.begin();
    }
    typename container::const_iterator end() const
    {
        return child_objects.end();
    }
    typename container::const_reverse_iterator rbegin() const
    {
        return child_objects.rbegin();
    }
    typename container::const_reverse_iterator rend() const
    {
        return child_objects.rend();
    }

    virtual void construct(const InputRange &r, ASTStack &st)
    {
        for(;;)
        {
            // If the stack is empty, don't fetch anything from it
            if (st.empty()) break;
            // Get the top entry on the stack
            ASTStackEntry &e = st.back();
            const InputRange &childRange = e.first;
            // If the entry isn't within the range of this, then it's just
            // something of the same type that happens to be adjacent to this
            // entry.
            if ((childRange.begin() < r.begin()) ||
                (childRange.end() > r.end()))
            {
                break;
            }

            //get the node
            ASTNode *node = e.second.get();

            //get the object
            T *obj = node->get_as<T>();

            //if the object was not not of the appropriate type,
            //end the list parsing
            if (!obj) return;
            debug_log("Popped", st.size()-1, obj);

            //remove the node from the stack
            e.second.release();
            st.pop_back();

            //insert the object in the list, in reverse order
            child_objects.push_front(std::unique_ptr<T>(obj));

            //set the object's parent
            obj->parent_node = ASTMember::container();
        }
    }
    virtual ~ASTList() {}

private:
    //objects
    container child_objects;

    //duplicate the given list.
    void _dup(const ASTList<T> &src)
    {
        for (auto child : src.child_objects)
        {
            T *obj = new T(child.get());
            child_objects.push_back(obj);
            obj->parent_node = ASTMember::container();
        }
    }
};

std::unique_ptr<ASTNode> parse(Input &i, const Rule &g, const Rule &ws,
                               ErrorReporter &err, const ParserDelegate &d);

class ASTParserDelegate : ParserDelegate
{
    template <class T> friend class BindAST;
    private:
    std::unordered_map<const Rule*, parse_proc> handlers;
    protected:
    void set_parse_proc(const Rule &r, parse_proc p);
    static void bind_parse_proc(const Rule &r, parse_proc p);
    public:
    ASTParserDelegate();
    virtual parse_proc get_parse_proc(const Rule &) const;
    template <class T> bool parse(Input &i, const Rule &g, const Rule &ws,
                                  ErrorReporter err,
                                  std::unique_ptr<T> &ast) const
    {
        std::unique_ptr<ASTNode> node = pegmatite::parse(i, g, ws, err, *this);
        T *n = node->get_as<T>();
        if (n)
        {
            node.release();
            ast.reset(n);
            return true;
        }
        return false;
    }
};

template <class T> class BindAST
{
public:
    BindAST(const Rule &r)
    {
        ASTParserDelegate::bind_parse_proc(r, [](const InputRange &range,
                                                 void *d)
            {
                ASTStack *st = reinterpret_cast<ASTStack *>(d);
                T *obj = new T();
                debug_log("Constructing", st->size(), obj);
                obj->construct(range, *st);
                st->push_back(std::make_pair(range, std::unique_ptr<ASTNode>(obj)));
                debug_log("Constructed", st->size()-1, obj);
                return true;
            });
    }
};


} //namespace pegmatite


#endif //PEGMATITE_AST_HPP