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
 
//------------------------------------------------------------------------------------------------------------------------------
class Node: public Sawyer::Tree::Vertex<Node> {
public:
    virtual ~Node() {}
 
    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;
 
    Sawyer::Optional<std::string> serializerBaseName;
 
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;
 
    std::string qualifiedNamespace;
 
    std::string userSerializerFunction;
 
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();
 
    ClassPtr findClassByName(const std::string&);
};
 
} // namespace
} // namespace
#endif