Ast.h

#ifndef Rosebud_Ast_H
#define Rosebud_Ast_H

#include <Rosebud/BasicTypes.h>

#include <Sawyer/Cached.h>
#include <Sawyer/Tree.h>

#include <list>
#include <memory>
#include <string>
#include <vector>

namespace Rosebud {

namespace Ast {

// AST nodes specific to Rosebud

//------------------------------------------------------------------------------------------------------------------------------
// Base class of all AST nodes for Rosebud
class Node: public Sawyer::Tree::Vertex<Node> {
public:
    using Ptr = NodePtr;

    template<class T>
    std::shared_ptr<T> findAncestor() {
        return traverseReverse<T>([](const std::shared_ptr<T> &node, TraversalEvent) {
            return node;
        });
    }
};

//------------------------------------------------------------------------------------------------------------------------------
class TokenList: public Node {
public:
    using Ptr = TokenListPtr;

private:
    Sawyer::Cached<std::string> string_;                // cached string representation

public:
    std::vector<Token> tokens;

protected:
    TokenList();

public:
    static Ptr instance();

    bool empty() const;

    size_t size() const;

    void push_back(const Token &token);

    std::string string();
    std::string string(const FilePtr&);
    void string(const std::string&);
    std::vector<Token>::iterator begin() {
        return tokens.begin();
    }
    std::vector<Token>::iterator end() {
        return tokens.end();
    }
};

//------------------------------------------------------------------------------------------------------------------------------
class CppStack: public Node {
public:
    using Ptr = CppStackPtr;

    enum class Type {
        IF,                                             
        ELSE,                                           
        END,                                            
        OTHER                                           
    };

    struct Directive {
        Type type;                                      
        Token token;                                    
        std::string lexeme;                             
    };

    using Level = std::list<Directive>;

    using Stack = std::vector<Level>;

public:
    Stack stack;

protected:
    CppStack();

public:
    static Ptr instance();

    static Type type(const std::string &directive);

    static bool process(const FilePtr&, const Token &directive, Stack &runningStack);

    bool printError(const FilePtr &file) const;

    void emitOpen(std::ostream&);

    void emitClose(std::ostream&);
};

//------------------------------------------------------------------------------------------------------------------------------
class ArgumentList: public Node {
public:
    using Ptr = ArgumentListPtr;

public:
    EdgeVector<TokenList> elmts;

protected:
    ArgumentList();

public:
    static Ptr instance();
};

//------------------------------------------------------------------------------------------------------------------------------
class Attribute: public Node {
public:
    using Ptr = AttributePtr;

public:
    std::string fqName;

    std::vector<Token> nameTokens;

    Edge<ArgumentList> arguments;

protected:
    Attribute();
public:

    static Ptr instance();
    static Ptr instance(const std::string &fqName, const std::vector<Token> &nameTokens);
};

//------------------------------------------------------------------------------------------------------------------------------
class Definition: public Node {
public:
    using Ptr = DefinitionPtr;

public:
    Token startToken;

    std::string name;

    Token nameToken;

    std::string doc;

    Token docToken;

    Edge<CppStack> cppStack;

    std::string priorText;

    Token priorTextToken;

    EdgeVector<Attribute> attributes;

protected:
    Definition();

public:
    AttributePtr findAttribute(const std::string &fqName);
};

//------------------------------------------------------------------------------------------------------------------------------
class Property: public Definition {
public:
    using Ptr = PropertyPtr;

public:
    Edge<TokenList> cType;

    Edge<TokenList> cInit;

    Sawyer::Optional<std::string> dataMemberName;

    Sawyer::Optional<std::vector<std::string>> accessorNames;

    Sawyer::Optional<std::vector<std::string>> mutatorNames;

protected:
    Property();

public:
    static Ptr instance();
};

//------------------------------------------------------------------------------------------------------------------------------
class Class: public Definition {
public:
    using Ptr = ClassPtr;

    using Inheritance = std::vector<std::pair<std::string /*visibility*/, std::string/*name*/>>;

public:
    EdgeVector<Property> properties;

    Inheritance inheritance;

    std::string endText;

    Token endTextToken;

    std::string tag;

protected:
    Class();

public:
    static Ptr instance();
};

//------------------------------------------------------------------------------------------------------------------------------
class File: public Node {
public:
    using Ptr = FilePtr;

private:
    TokenStream stream_;

public:
    EdgeVector<Class> classes;

    std::string endText;

    Token endTextToken;

protected:
    File() = delete;

    File(const std::string &name);

public:
    static Ptr instance(const std::string &name);

    std::string name();

    TokenStream& tokenStream();

    const Token token(size_t lookAhead = 0);

    std::string lexeme(size_t position = 0);
    std::string lexeme(const Token&);
    bool matches(const Token&, const char*);
    bool matches(const Token&, const std::string&);
    bool matches(size_t lookAhead, const char*);
    bool matches(size_t lookAhead, const std::string&);
    bool matches(const char*);
    bool matches(const std::string&);
    bool matchesAny(size_t tokenPosition, const std::vector<std::string>&);

    bool startsWith(const Token&, const char*);

    Token consume();
    void consume(size_t n);
    std::string content(const std::vector<Token>&, Expand);

    std::string content(size_t begin, size_t end);

    std::string trimmedContent(size_t begin, size_t end, Token &outputToken);
    std::string trimmedContent(size_t begin, size_t end, const Token &exclude, Token &outputToken);
    void emitContext(std::ostream&, const Token &first, const Token &locus, const Token &last);
};

//------------------------------------------------------------------------------------------------------------------------------
class Project: public Node {
public:
    using Ptr = ProjectPtr;

public:
    EdgeVector<File> files;

protected:
    Project();

public:
    static Ptr instance();

    std::vector<ClassPtr> allClassesFileOrder();
};

} // namespace
} // namespace
#endif