diff --git a/src/ast.hpp b/src/ast.hpp
index e941a8b..26d93a6 100644
--- a/src/ast.hpp
+++ b/src/ast.hpp
@@ -17,7 +17,6 @@
 #include <map>
 #include <vector>
 
-#include "CTree.hpp"
 #include "utils.hpp"
 namespace x3 = boost::spirit::x3;
 namespace ascii = boost::spirit::x3::ascii;
@@ -35,21 +34,6 @@
 
 using keyValue_ = std::pair<std::string, std::string>;
 
-class InvalidKeyException : public std::invalid_argument {
-public:
-    using std::invalid_argument::invalid_argument;
-    ~InvalidKeyException() override;
-};
-
-struct ParserContext {
-    ParserContext(const CTree& tree);
-    const CTree& m_tree;
-    std::string m_curPath;
-    std::string m_errorMsg;
-    std::string m_tmpListName;
-    std::set<std::string> m_tmpListKeys;
-    bool m_errorHandled = false;
-};
 
 struct parser_context_tag;
 
@@ -62,7 +46,6 @@
     std::string m_name;
 };
 
-BOOST_FUSION_ADAPT_STRUCT(container_, m_name)
 
 struct list_ {
     std::vector<std::string> m_keys;
@@ -78,194 +61,21 @@
     std::map<std::string, std::string> m_keys;
 };
 
-BOOST_FUSION_ADAPT_STRUCT(listElement_, m_listName, m_keys)
 
 struct path_ {
     bool operator==(const path_& b) const;
     std::vector<boost::variant<container_, listElement_>> m_nodes;
 };
 
-BOOST_FUSION_ADAPT_STRUCT(path_, m_nodes)
 
 struct cd_ : x3::position_tagged {
     bool operator==(const cd_& b) const;
     path_ m_path;
 };
 
+
+
+BOOST_FUSION_ADAPT_STRUCT(container_, m_name)
+BOOST_FUSION_ADAPT_STRUCT(listElement_, m_listName, m_keys)
+BOOST_FUSION_ADAPT_STRUCT(path_, m_nodes)
 BOOST_FUSION_ADAPT_STRUCT(cd_, m_path)
-
-struct keyValue_class {
-    template <typename T, typename Iterator, typename Context>
-    void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
-    {
-        auto& parserContext = x3::get<parser_context_tag>(context);
-        const CTree& tree = parserContext.m_tree;
-
-        if (parserContext.m_tmpListKeys.find(ast.first) != parserContext.m_tmpListKeys.end()) {
-            _pass(context) = false;
-            parserContext.m_errorMsg = "Key \"" + ast.first + "\" was entered more than once.";
-        } else if (tree.listHasKey(parserContext.m_curPath, parserContext.m_tmpListName, ast.first)) {
-            parserContext.m_tmpListKeys.insert(ast.first);
-        } else {
-            _pass(context) = false;
-            parserContext.m_errorMsg = parserContext.m_tmpListName + " is not indexed by \"" + ast.first + "\".";
-        }
-    }
-};
-struct identifier_class;
-
-struct listPrefix_class {
-    template <typename T, typename Iterator, typename Context>
-    void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
-    {
-        auto& parserContext = x3::get<parser_context_tag>(context);
-        const CTree& tree = parserContext.m_tree;
-
-        if (tree.isList(parserContext.m_curPath, ast)) {
-            parserContext.m_tmpListName = ast;
-        } else {
-            _pass(context) = false;
-        }
-    }
-};
-
-struct listSuffix_class {
-    template <typename T, typename Iterator, typename Context>
-    void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
-    {
-        auto& parserContext = x3::get<parser_context_tag>(context);
-        const CTree& tree = parserContext.m_tree;
-
-        const auto& keysNeeded = tree.listKeys(parserContext.m_curPath, parserContext.m_tmpListName);
-        std::set<std::string> keysSupplied;
-        for (const auto& it : ast)
-            keysSupplied.insert(it.first);
-
-        if (keysNeeded != keysSupplied) {
-            parserContext.m_errorMsg = "Not enough keys for " + parserContext.m_tmpListName + ". " +
-                                       "These keys were not supplied:";
-            std::set<std::string> missingKeys;
-            std::set_difference(keysNeeded.begin(), keysNeeded.end(),
-                                keysSupplied.begin(), keysSupplied.end(),
-                                std::inserter(missingKeys, missingKeys.end()));
-
-            for (const auto& it : missingKeys)
-                parserContext.m_errorMsg += " " + it;
-            parserContext.m_errorMsg += ".";
-
-            _pass(context) = false;
-        }
-    }
-};
-struct listElement_class {
-    template <typename T, typename Iterator, typename Context>
-    void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
-    {
-        auto& parserContext = x3::get<parser_context_tag>(context);
-        parserContext.m_curPath = joinPaths(parserContext.m_curPath, ast.m_listName);
-    }
-
-    template <typename Iterator, typename Exception, typename Context>
-    x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const& ex, Context const& context)
-    {
-        auto& parserContext = x3::get<parser_context_tag>(context);
-        auto& error_handler = x3::get<x3::error_handler_tag>(context).get();
-        if (parserContext.m_errorHandled) // someone already handled our error
-            return x3::error_handler_result::fail;
-
-        parserContext.m_errorHandled = true;
-
-        std::string message = parserContext.m_errorMsg;
-        error_handler(ex.where(), message);
-        return x3::error_handler_result::fail;
-    }
-};
-
-struct container_class {
-    template <typename T, typename Iterator, typename Context>
-    void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
-    {
-        auto& parserContext = x3::get<parser_context_tag>(context);
-        const auto& tree = parserContext.m_tree;
-
-        if (tree.isContainer(parserContext.m_curPath, ast.m_name)) {
-            parserContext.m_curPath = joinPaths(parserContext.m_curPath, ast.m_name);
-        } else {
-            _pass(context) = false;
-        }
-    }
-};
-
-struct path_class {
-    template <typename T, typename Iterator, typename Context>
-    void on_success(Iterator const&, Iterator const&, T&, Context const&)
-    {
-    }
-};
-
-struct cd_class {
-    template <typename T, typename Iterator, typename Context>
-    void on_success(Iterator const&, Iterator const&, T&, Context const&)
-    {
-    }
-
-    template <typename Iterator, typename Exception, typename Context>
-    x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const& x, Context const& context)
-    {
-        auto& parserContext = x3::get<parser_context_tag>(context);
-        auto& error_handler = x3::get<x3::error_handler_tag>(context).get();
-        std::string message = "This isn't a list or a container or nothing.";
-        if (parserContext.m_errorHandled) // someone already handled our error
-            return x3::error_handler_result::fail;
-
-        parserContext.m_errorHandled = true;
-        error_handler(x.where(), message);
-        return x3::error_handler_result::fail;
-    }
-};
-
-
-x3::rule<keyValue_class, keyValue_> const keyValue = "keyValue";
-x3::rule<identifier_class, std::string> const identifier = "identifier";
-x3::rule<listPrefix_class, std::string> const listPrefix = "listPrefix";
-x3::rule<listSuffix_class, std::vector<keyValue_>> const listSuffix = "listSuffix";
-x3::rule<listElement_class, listElement_> const listElement = "listElement";
-x3::rule<container_class, container_> const container = "container";
-x3::rule<path_class, path_> const path = "path";
-x3::rule<cd_class, cd_> const cd = "cd";
-
-
-auto const keyValue_def =
-    lexeme[+alnum >> '=' >> +alnum];
-
-auto const identifier_def =
-    lexeme[
-        ((alpha | char_("_")) >> *(alnum | char_("_") | char_("-") | char_(".")))
-    ];
-
-auto const listPrefix_def =
-    identifier >> '[';
-
-auto const listSuffix_def =
-    +keyValue > ']';
-
-auto const listElement_def =
-   listPrefix > listSuffix;
-
-auto const container_def =
-    identifier;
-
-auto const path_def =
-    (container | listElement) % '/';
-
-auto const cd_def =
-    lit("cd") > path >> x3::eoi;
-
-BOOST_SPIRIT_DEFINE(keyValue)
-BOOST_SPIRIT_DEFINE(identifier)
-BOOST_SPIRIT_DEFINE(listPrefix)
-BOOST_SPIRIT_DEFINE(listSuffix)
-BOOST_SPIRIT_DEFINE(listElement)
-BOOST_SPIRIT_DEFINE(container)
-BOOST_SPIRIT_DEFINE(path)
-BOOST_SPIRIT_DEFINE(cd)