initial/final commitHEADmaster

1 files changed, 4986 insertions, 0 deletions

diff --git a/vmime-master/src/vmime/net/imap/IMAPParser.hpp b/vmime-master/src/vmime/net/imap/IMAPParser.hpp
new file mode 100644
index 0000000..281fcb6
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPParser.hpp
@@ -0,0 +1,4986 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_NET_IMAP_IMAPPARSER_HPP_INCLUDED
+#define VMIME_NET_IMAP_IMAPPARSER_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/base.hpp"
+#include "vmime/dateTime.hpp"
+#include "vmime/charset.hpp"
+#include "vmime/exception.hpp"
+
+#include "vmime/utility/stringUtils.hpp"
+#include "vmime/utility/progressListener.hpp"
+
+#include "vmime/utility/encoder/b64Encoder.hpp"
+#include "vmime/utility/encoder/qpEncoder.hpp"
+
+#include "vmime/utility/inputStreamStringAdapter.hpp"
+#include "vmime/utility/outputStreamStringAdapter.hpp"
+
+#include "vmime/platform.hpp"
+
+#include "vmime/net/timeoutHandler.hpp"
+#include "vmime/net/socket.hpp"
+#include "vmime/net/tracer.hpp"
+
+#include "vmime/net/imap/IMAPTag.hpp"
+
+#include <vector>
+#include <stdexcept>
+#include <memory>
+
+
+//#define DEBUG_RESPONSE 1
+
+
+#if DEBUG_RESPONSE
+#   include <iostream>
+#endif
+
+
+/** Make the parsing of a component fail.
+  */
+#define VIMAP_PARSER_FAIL() \
+	{  \
+		parser.m_errorResponseLine = makeResponseLine(getComponentName(), line, pos);  \
+		return false;  \
+	}
+
+/** Make the parsing of a component fail if a condition is not matched.
+  * If the specified expression does not resolve to "true", the parsing
+  * will fail.
+  *
+  * @param cond condition expression
+  */
+#define VIMAP_PARSER_FAIL_UNLESS(cond) \
+	if (!(cond))  \
+	{  \
+		VIMAP_PARSER_FAIL();  \
+	}
+
+/** Check for a token and advance.
+  * If the token is not matched, parsing will fail.
+  *
+  * @param type token class
+  */
+#define VIMAP_PARSER_CHECK(type) \
+	VIMAP_PARSER_FAIL_UNLESS(parser.check <type>(line, &pos))
+
+/** Check for an optional token and advance.
+  * If the token is not matched, parsing will continue anyway.
+  *
+  * @param type token class
+  */
+#define VIMAP_PARSER_TRY_CHECK(type) \
+	(parser.check <type>(line, &pos))
+
+/** Get a token and advance.
+  * If the token is not matched, parsing will fail.
+  *
+  * @param type token class
+  * @param variable variable which will receive pointer to the retrieved token
+  */
+#define VIMAP_PARSER_GET(type, variable) \
+	{ \
+		variable.reset(parser.get <type>(line, &pos));  \
+		VIMAP_PARSER_FAIL_UNLESS(variable.get());  \
+	}
+
+/** Get an optional token and advance.
+  * If the token is not matched, parsing will continue anyway.
+  */
+#define VIMAP_PARSER_TRY_GET(type, variable) \
+	(variable.reset(parser.get <type>(line, &pos)), variable.get())
+
+/** Get an optional token and advance. If found, token will be pushed back
+  * to a vector. If the token is not matched, stopInstr will be executed.
+  *
+  * @param type token class
+  * @param variable variable of type std::vector<> to which the retrieved
+  * token will be pushed
+  * @param stopInstr instruction to execute if token is not found
+  */
+#define VIMAP_PARSER_TRY_GET_PUSHBACK_OR_ELSE(type, variable, stopInstr) \
+	{  \
+		std::unique_ptr <type> v;  \
+		try  \
+		{  \
+			v.reset(parser.get <type>(line, &pos));  \
+			if (!v)  \
+			{  \
+				stopInstr;  \
+			}  \
+			variable.push_back(std::move(v));  \
+		}  \
+		catch (...)  \
+		{  \
+			throw;  \
+		}  \
+	}
+
+/** Get a token and advance. Token will be pushed back to a vector.
+  * If the token is not matched, parsing will fail.
+  *
+  * @param type token class
+  * @param variable variable of type std::vector<> to which the retrieved
+  * token will be pushed
+  */
+#define VIMAP_PARSER_GET_PUSHBACK(type, variable) \
+	VIMAP_PARSER_TRY_GET_PUSHBACK_OR_ELSE(type, variable, VIMAP_PARSER_FAIL())
+
+
+/** Check for a token which takes an argument and advance.
+  * If the token is not matched, parsing will fail.
+  *
+  * @param type token class
+  */
+#define VIMAP_PARSER_CHECK_WITHARG(type, arg) \
+	VIMAP_PARSER_FAIL_UNLESS(parser.checkWithArg <type>(line, &pos, arg))
+
+/** Check for an optional token which takes an argument and advance.
+  * If the token is not matched, parsing will continue anyway.
+  *
+  * @param type token class
+  */
+#define VIMAP_PARSER_TRY_CHECK_WITHARG(type, arg) \
+	(parser.checkWithArg <type>(line, &pos, arg))
+
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+#if DEBUG_RESPONSE
+	static int IMAPParserDebugResponse_level = 0;
+	static std::vector <string> IMAPParserDebugResponse_stack;
+
+	class IMAPParserDebugResponse {
+
+	public:
+
+		IMAPParserDebugResponse(
+			const string& name,
+			string& line,
+			const size_t currentPos,
+			const bool &result
+		)
+			: m_name(name),
+			  m_line(line),
+			  m_pos(currentPos),
+			  m_result(result) {
+
+			++IMAPParserDebugResponse_level;
+			IMAPParserDebugResponse_stack.push_back(name);
+
+			for (int i = 0 ; i < IMAPParserDebugResponse_level ; ++i) {
+				std::cout << "  ";
+			}
+
+			std::cout << "ENTER(" << m_name << "), pos=" << m_pos;
+			std::cout << std::endl;
+
+			for (std::vector <string>::iterator it = IMAPParserDebugResponse_stack.begin() ;
+			     it != IMAPParserDebugResponse_stack.end() ; ++it) {
+
+				std::cout << "> " << *it << " ";
+			}
+
+			std::cout << std::endl;
+			std::cout << string(m_line.begin() + (m_pos < 30 ? 0U : m_pos - 30),
+				m_line.begin() + std::min(m_line.length(), m_pos + 30)) << std::endl;
+
+			for (size_t i = (m_pos < 30 ? m_pos : (m_pos - (m_pos - 30))) ; i != 0 ; --i) {
+				std::cout << " ";
+			}
+
+			std::cout << "^" << std::endl;
+		}
+
+		~IMAPParserDebugResponse() {
+
+			for (int i = 0 ; i < IMAPParserDebugResponse_level ; ++i) {
+				std::cout << "  ";
+			}
+
+			std::cout << "LEAVE(" << m_name << "), result=";
+			std::cout << (m_result ? "TRUE" : "FALSE") << ", pos=" << m_pos;
+			std::cout << std::endl;
+
+			--IMAPParserDebugResponse_level;
+			IMAPParserDebugResponse_stack.pop_back();
+		}
+
+	private:
+
+		const string m_name;
+		string m_line;
+		size_t m_pos;
+		const bool& m_result;
+	};
+
+
+	#define DEBUG_ENTER_COMPONENT(x, result) \
+		IMAPParserDebugResponse dbg(x, line, *currentPos, result)
+
+	#define DEBUG_FOUND(x, y) \
+		std::cout << "FOUND: " << x << ": " << y << std::endl;
+#else
+	#define DEBUG_ENTER_COMPONENT(x, result)
+	#define DEBUG_FOUND(x, y)
+#endif
+
+
+class VMIME_EXPORT IMAPParser : public object {
+
+public:
+
+	IMAPParser()
+		: m_progress(NULL),
+		  m_strict(false),
+		  m_literalHandler(NULL) {
+
+	}
+
+	~IMAPParser() {
+
+		for (auto it = m_pendingResponses.begin() ; it != m_pendingResponses.end() ; ++it) {
+			delete it->second;
+		}
+	}
+
+
+	/** Set the socket currently used by this parser to receive data
+	  * from server.
+	  *
+	  * @param sok socket
+	  */
+	void setSocket(const shared_ptr <socket>& sok) {
+
+		m_socket = sok;
+	}
+
+	/** Set the timeout handler currently used by this parser.
+	  *
+	  * @param toh timeout handler
+	  */
+	void setTimeoutHandler(const shared_ptr <timeoutHandler>& toh) {
+
+		m_timeoutHandler = toh;
+	}
+
+	/** Set the tracer currently used by this parser.
+	  *
+	  * @param tr tracer
+	  */
+	void setTracer(const shared_ptr <tracer>& tr) {
+
+		m_tracer = tr;
+	}
+
+	/** Set whether we operate in strict mode (this may not work
+	  * with some servers which are not fully standard-compliant).
+	  *
+	  * @param strict true to operate in strict mode, or false
+	  * to operate in default, relaxed mode
+	  */
+	void setStrict(const bool strict) {
+
+		m_strict = strict;
+	}
+
+	/** Return true if the parser operates in strict mode, or
+	  * false otherwise.
+	  *
+	  * @return true if we are in strict mode, false otherwise
+	  */
+	bool isStrict() const {
+
+		return m_strict;
+	}
+
+
+
+	//
+	// literalHandler : literal content handler
+	//
+
+	class component;
+
+	class literalHandler {
+
+	public:
+
+		virtual ~literalHandler() { }
+
+
+		// Abstract target class
+		class target {
+
+		protected:
+
+			target(utility::progressListener* progress) : m_progress(progress) {}
+			target(const target&) {}
+
+		public:
+
+			virtual ~target() { }
+
+
+			utility::progressListener* progressListener() { return (m_progress); }
+
+			virtual void putData(const string& chunk) = 0;
+
+			virtual size_t getBytesWritten() const = 0;
+
+		private:
+
+			utility::progressListener* m_progress;
+		};
+
+
+		// Target: put in a string
+		class targetString : public target {
+
+		public:
+
+			targetString(utility::progressListener* progress, vmime::string& str)
+				: target(progress), m_string(str), m_bytesWritten(0) { }
+
+			const vmime::string& string() const { return (m_string); }
+			vmime::string& string() { return (m_string); }
+
+
+			void putData(const vmime::string& chunk) {
+
+				m_string += chunk;
+				m_bytesWritten += chunk.length();
+			}
+
+			size_t getBytesWritten() const {
+
+				return m_bytesWritten;
+			}
+
+		private:
+
+			vmime::string& m_string;
+			size_t m_bytesWritten;
+		};
+
+
+		// Target: redirect to an output stream
+		class targetStream : public target {
+
+		public:
+
+			targetStream(
+				utility::progressListener* progress,
+				utility::outputStream& stream
+			)
+				: target(progress),
+				  m_stream(stream),
+				  m_bytesWritten(0) {
+
+			}
+
+			const utility::outputStream& stream() const { return (m_stream); }
+			utility::outputStream& stream() { return (m_stream); }
+
+
+			void putData(const string& chunk) {
+
+				m_stream.write(chunk.data(), chunk.length());
+				m_bytesWritten += chunk.length();
+			}
+
+			size_t getBytesWritten() const {
+
+				return m_bytesWritten;
+			}
+
+		private:
+
+			utility::outputStream& m_stream;
+			size_t m_bytesWritten;
+		};
+
+
+		// Called when the parser needs to know what to do with a literal
+		//    . comp: the component in which we are at this moment
+		//    . data: data specific to the component (may not be used)
+		//
+		// Returns :
+		//    . == NULL to put the literal into the response
+		//    . != NULL to redirect the literal to the specified target
+
+		virtual shared_ptr <target> targetFor(const component& comp, const int data) = 0;
+	};
+
+
+	//
+	// Base class for a terminal or a non-terminal
+	//
+
+	class component {
+
+	public:
+
+		component() { }
+		virtual ~component() { }
+
+		virtual const string getComponentName() const = 0;
+
+		bool parse(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			bool res = false;
+			DEBUG_ENTER_COMPONENT(getComponentName(), res);
+			res = parseImpl(parser, line, currentPos);
+			return res;
+		}
+
+		virtual bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) = 0;
+
+
+		const string makeResponseLine(
+			const string& comp,
+			const string& line,
+			const size_t pos
+		) {
+
+#if DEBUG_RESPONSE
+			if (pos > line.length()) {
+				std::cout << "WARNING: component::makeResponseLine(): pos > line.length()" << std::endl;
+			}
+#endif
+
+			string result(line.substr(0, pos));
+			result += "[^]";   // indicates current parser position
+			result += line.substr(pos, line.length());
+			if (!comp.empty()) result += " [" + comp + "]";
+
+			return (result);
+		}
+	};
+
+
+#define COMPONENT_ALIAS(parent, name) \
+	class name : public parent { \
+		virtual const string getComponentName() const { return #name; }  \
+	public: \
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) { \
+			return parent::parseImpl(parser, line, currentPos); \
+		} \
+	}
+
+#define DECLARE_COMPONENT(name) \
+	class name : public component {  \
+		virtual const string getComponentName() const { return #name; }  \
+	public:
+
+
+	//
+	// Parse one character
+	//
+
+	template <char C>
+	class one_char : public component {
+
+	public:
+
+		const string getComponentName() const {
+
+			return string("one_char <") + C + ">";
+		}
+
+		bool parseImpl(IMAPParser& /* parser */, string& line, size_t* currentPos) {
+
+			const size_t pos = *currentPos;
+
+			if (pos < line.length() && line[pos] == C) {
+				*currentPos = pos + 1;
+				return true;
+			} else {
+				return false;
+			}
+		}
+	};
+
+
+	//
+	// SPACE  ::= <ASCII SP, space, 0x20>
+	//
+
+	DECLARE_COMPONENT(SPACE)
+
+		bool parseImpl(IMAPParser& /* parser */, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			while (pos < line.length() && (line[pos] == ' ' || line[pos] == '\t')) {
+				++pos;
+			}
+
+			if (pos > *currentPos) {
+				*currentPos = pos;
+				return true;
+			} else {
+				return false;
+			}
+		}
+	};
+
+
+	//
+	// CR    ::= <ASCII CR, carriage return, 0x0D>
+	// LF    ::= <ASCII LF, line feed, 0x0A>
+	// CRLF  ::= CR LF
+	//
+
+	DECLARE_COMPONENT(CRLF)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_TRY_CHECK(SPACE);
+
+			if (pos + 1 < line.length() &&
+			    line[pos] == 0x0d && line[pos + 1] == 0x0a) {
+
+				*currentPos = pos + 2;
+				return true;
+
+			} else {
+
+				return false;
+			}
+		}
+	};
+
+
+	//
+	// SPACE           ::= <ASCII SP, space, 0x20>
+	// CTL             ::= <any ASCII control character and DEL, 0x00 - 0x1f, 0x7f>
+	// CHAR            ::= <any 7-bit US-ASCII character except NUL, 0x01 - 0x7f>
+	// ATOM_CHAR       ::= <any CHAR except atom_specials>
+	// atom_specials   ::= "(" / ")" / "{" / SPACE / CTL / list_wildcards / quoted_specials
+	// list_wildcards  ::= "%" / "*"
+	// quoted_specials ::= <"> / "\"
+	//
+	// tag             ::= 1*<any ATOM_CHAR except "+">    (named "xtag")
+	//
+
+	DECLARE_COMPONENT(xtag)
+
+		bool parseImpl(IMAPParser& /* parser */, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			bool end = false;
+
+			tagString.reserve(10);
+
+			while (!end && pos < line.length()) {
+
+				const unsigned char c = line[pos];
+
+				switch (c) {
+
+					case '+':
+					case '(':
+					case ')':
+					case '{':
+					case 0x20:  // SPACE
+					case '%':   // list_wildcards
+					case '*':   // list_wildcards
+					case '"':   // quoted_specials
+					case '\\':  // quoted_specials
+
+						end = true;
+						break;
+
+					default:
+
+						if (c <= 0x1f || c >= 0x7f) {
+							end = true;
+						} else {
+							tagString += c;
+							++pos;
+						}
+
+						break;
+				}
+			}
+
+			*currentPos = pos;
+			return true;
+		}
+
+		string tagString;
+	};
+
+
+	//
+	// digit     ::= "0" / digit_nz
+	// digit_nz  ::= "1" / "2" / "3" / "4" / "5" / "6" / "7" / "8" / "9"
+	//
+	// number    ::= 1*digit
+	//               ;; Unsigned 32-bit integer
+	//               ;; (0 <= n < 4,294,967,296)
+	//
+
+	DECLARE_COMPONENT(number)
+
+		number(const bool nonZero = false)
+			: value(0),
+			  m_nonZero(nonZero) {
+
+		}
+
+		bool parseImpl(IMAPParser& /* parser */, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			bool valid = true;
+			unsigned int val = 0;
+
+			while (valid && pos < line.length()) {
+
+				const char c = line[pos];
+
+				if (c >= '0' && c <= '9') {
+					val = (val * 10) + (c - '0');
+					++pos;
+				} else {
+					valid = false;
+				}
+			}
+
+			// Check for non-null length (and for non-zero number)
+			if (!(m_nonZero && val == 0) && pos != *currentPos) {
+				value = val;
+				*currentPos = pos;
+				return true;
+			} else {
+				return false;
+			}
+		}
+
+
+		unsigned long value;
+
+	private:
+
+		const bool m_nonZero;
+	};
+
+
+	// nz_number  ::= digit_nz *digit
+	//                ;; Non-zero unsigned 32-bit integer
+	//                ;; (0 < n < 4,294,967,296)
+	//
+
+	class nz_number : public number {
+
+	public:
+
+		nz_number()
+			: number(true) {
+
+		}
+	};
+
+
+	//
+	// uniqueid    ::= nz_number
+	//                 ;; Strictly ascending
+	//
+
+	class uniqueid : public nz_number {
+
+	public:
+
+		uniqueid()
+			: nz_number() {
+
+		}
+	};
+
+
+	// uid-range       = (uniqueid ":" uniqueid)
+	//                   ; two uniqueid values and all values
+	//                   ; between these two regards of order.
+	//                   ; Example: 2:4 and 4:2 are equivalent.
+
+	DECLARE_COMPONENT(uid_range)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(uniqueid, uniqueid1);
+			VIMAP_PARSER_CHECK(one_char <':'>);
+			VIMAP_PARSER_GET(uniqueid, uniqueid2);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <uniqueid> uniqueid1;
+		std::unique_ptr <uniqueid> uniqueid2;
+	};
+
+
+	//
+	// uid-set         = (uniqueid / uid-range) *("," uid-set)
+	//
+
+	DECLARE_COMPONENT(uid_set)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			// We have either a 'uid_range' or a 'uniqueid'
+			if (!VIMAP_PARSER_TRY_GET(IMAPParser::uid_range, uid_range)) {
+				VIMAP_PARSER_GET(IMAPParser::uniqueid, uniqueid);
+			}
+
+			// And maybe another 'uid-set' following
+			if (VIMAP_PARSER_TRY_CHECK(one_char <','>)) {
+				VIMAP_PARSER_GET(IMAPParser::uid_set, next_uid_set);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::uniqueid> uniqueid;
+		std::unique_ptr <IMAPParser::uid_range> uid_range;
+
+		std::unique_ptr <IMAPParser::uid_set> next_uid_set;
+	};
+
+
+	//
+	// text       ::= 1*TEXT_CHAR
+	//
+	// CHAR       ::= <any 7-bit US-ASCII character except NUL, 0x01 - 0x7f>
+	// TEXT_CHAR  ::= <any CHAR except CR and LF>
+	//
+
+	DECLARE_COMPONENT(text)
+
+		text(bool allow8bits = false, const char except = 0)
+			: m_allow8bits(allow8bits),
+			  m_except(except) {
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+			size_t len = 0;
+
+			if (m_allow8bits || !parser.isStrict()) {
+
+				const unsigned char except = m_except;
+
+				for (bool end = false ; !end && pos < line.length() ; ) {
+
+					const unsigned char c = line[pos];
+
+					if (c == 0x00 || c == 0x0d || c == 0x0a || c == except) {
+						end = true;
+					} else {
+						++pos;
+						++len;
+					}
+				}
+
+			} else {
+
+				const unsigned char except = m_except;
+
+				for (bool end = false ; !end && pos < line.length() ; ) {
+
+					const unsigned char c = line[pos];
+
+					if (c < 0x01 || c > 0x7f || c == 0x0d || c == 0x0a || c == except) {
+						end = true;
+					} else {
+						++pos;
+						++len;
+					}
+				}
+			}
+
+			if (len == 0) {
+				VIMAP_PARSER_FAIL();
+			}
+
+			value.resize(len);
+			std::copy(line.begin() + *currentPos, line.begin() + pos, value.begin());
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		string value;
+
+	private:
+
+		const bool m_allow8bits;
+		const char m_except;
+	};
+
+
+	class text8 : public text {
+
+	public:
+
+		text8() : text(true) {
+
+		}
+	};
+
+
+	template <char C>
+	class text_except : public text {
+
+	public:
+
+		text_except() : text(false, C) {
+
+		}
+	};
+
+
+	template <char C>
+	class text8_except : public text {
+
+	public:
+
+		text8_except() : text(true, C) {
+
+		}
+	};
+
+
+	//
+	// QUOTED_CHAR     ::= <any TEXT_CHAR except quoted_specials> / "\" quoted_specials
+	// quoted_specials ::= <"> / "\"
+	// TEXT_CHAR       ::= <any CHAR except CR and LF>
+	// CHAR            ::= <any 7-bit US-ASCII character except NUL, 0x01 - 0x7f>
+	//
+
+	DECLARE_COMPONENT(QUOTED_CHAR)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			const unsigned char c = static_cast <unsigned char>(pos < line.length() ? line[pos] : 0);
+
+			if (c >= 0x01 && c <= 0x7f &&   // 0x01 - 0x7f
+			    c != '"' && c != '\\' &&    // quoted_specials
+			    c != '\r' && c != '\n') {   // CR and LF
+
+				value = c;
+				*currentPos = pos + 1;
+
+			} else if (c == '\\' && pos + 1 < line.length() &&
+			           (line[pos + 1] == '"' || line[pos + 1] == '\\')) {
+
+				value = line[pos + 1];
+				*currentPos = pos + 2;
+
+			} else {
+
+				VIMAP_PARSER_FAIL();
+			}
+
+			return true;
+		}
+
+
+		char value;
+	};
+
+
+	//
+	// quoted          ::= <"> *QUOTED_CHAR <">
+	// QUOTED_CHAR     ::= <any TEXT_CHAR except quoted_specials> / "\" quoted_specials
+	// quoted_specials ::= <"> / "\"
+	// TEXT_CHAR       ::= <any CHAR except CR and LF>
+	// CHAR            ::= <any 7-bit US-ASCII character except NUL, 0x01 - 0x7f>
+	//
+
+	DECLARE_COMPONENT(quoted_text)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+			size_t len = 0;
+			bool valid = false;
+
+			value.reserve(line.length() - pos);
+
+			for (bool end = false, quoted = false ; !end && pos < line.length() ; ) {
+
+				const unsigned char c = line[pos];
+
+				if (quoted) {
+
+					if (c == '"' || c == '\\') {
+						value += c;
+					} else {
+						value += '\\';
+						value += c;
+					}
+
+					quoted = false;
+
+					++pos;
+					++len;
+
+				} else {
+
+					if (c == '\\') {
+
+						quoted = true;
+
+						++pos;
+						++len;
+
+					} else if (c == '"') {
+
+						valid = true;
+						end = true;
+
+					} else if (c >= 0x01 && c <= 0x7f &&  // CHAR
+					           c != 0x0a && c != 0x0d) {  // CR and LF
+
+						value += c;
+
+						++pos;
+						++len;
+
+					} else {
+
+						valid = false;
+						end = true;
+					}
+				}
+			}
+
+			if (!valid) {
+				VIMAP_PARSER_FAIL();
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		string value;
+	};
+
+
+	//
+	// nil  ::= "NIL"
+	//
+
+	DECLARE_COMPONENT(NIL)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK_WITHARG(special_atom, "nil");
+
+			*currentPos = pos;
+
+			return true;
+		}
+	};
+
+
+	//
+	// string          ::= quoted / literal    ----> named 'xstring'
+	//
+	// nil             ::= "NIL"
+	// quoted          ::= <"> *QUOTED_CHAR <">
+	// QUOTED_CHAR     ::= <any TEXT_CHAR except quoted_specials> / "\" quoted_specials
+	// quoted_specials ::= <"> / "\"
+	// TEXT_CHAR       ::= <any CHAR except CR and LF>
+	// CHAR            ::= <any 7-bit US-ASCII character except NUL, 0x01 - 0x7f>
+	// literal         ::= "{" number "}" CRLF *CHAR8
+	//                     ;; Number represents the number of CHAR8 octets
+	// CHAR8           ::= <any 8-bit octet except NUL, 0x01 - 0xff>
+	//
+
+	DECLARE_COMPONENT(xstring)
+
+		xstring(
+			const bool canBeNIL = false,
+			component* comp = NULL,
+			const int data = 0
+		)
+			: isNIL(true),
+			  m_canBeNIL(canBeNIL),
+			  m_component(comp),
+			  m_data(data) {
+
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (m_canBeNIL &&
+			    VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "nil")) {
+
+				// NIL
+				isNIL = true;
+
+			} else {
+
+				pos = *currentPos;
+
+				isNIL = false;
+
+				// quoted ::= <"> *QUOTED_CHAR <">
+				if (VIMAP_PARSER_TRY_CHECK(one_char <'"'>)) {
+
+					shared_ptr <quoted_text> text;
+					VIMAP_PARSER_GET(quoted_text, text);
+					VIMAP_PARSER_CHECK(one_char <'"'>);
+
+					if (parser.m_literalHandler != NULL) {
+
+						shared_ptr <literalHandler::target> target =
+							parser.m_literalHandler->targetFor(*m_component, m_data);
+
+						if (target != NULL) {
+
+							value = "[literal-handler]";
+
+							const size_t length = text->value.length();
+							utility::progressListener* progress = target->progressListener();
+
+							if (progress) {
+								progress->start(length);
+							}
+
+							target->putData(text->value);
+
+							if (progress) {
+								progress->progress(length, length);
+								progress->stop(length);
+							}
+
+						} else {
+
+							value = text->value;
+						}
+
+					} else {
+
+						value = text->value;
+					}
+
+					DEBUG_FOUND("string[quoted]", "<length=" << value.length() << ", value='" << value << "'>");
+
+				// literal ::= "{" number "}" CRLF *CHAR8
+				} else {
+
+					VIMAP_PARSER_CHECK(one_char <'{'>);
+
+					shared_ptr <number> num;
+					VIMAP_PARSER_GET(number, num);
+
+					const size_t length = num->value;
+
+					VIMAP_PARSER_CHECK(one_char <'}'> );
+
+					VIMAP_PARSER_CHECK(CRLF);
+
+
+					if (parser.m_literalHandler != NULL) {
+
+						shared_ptr <literalHandler::target> target =
+							parser.m_literalHandler->targetFor(*m_component, m_data);
+
+						if (target != NULL) {
+
+							value = "[literal-handler]";
+
+							parser.m_progress = target->progressListener();
+							parser.readLiteral(*target, length);
+							parser.m_progress = NULL;
+
+						} else {
+
+							literalHandler::targetString target(NULL, value);
+							parser.readLiteral(target, length);
+						}
+
+					} else {
+
+						literalHandler::targetString target(NULL, value);
+						parser.readLiteral(target, length);
+					}
+
+					line += parser.readLine();
+
+					DEBUG_FOUND("string[literal]", "<length=" << length << ", value='" << value << "'>");
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		bool isNIL;
+		string value;
+
+	private:
+
+		bool m_canBeNIL;
+
+		component* m_component;
+		const int m_data;
+	};
+
+
+	//
+	// nstring         ::= string / nil
+	//
+
+	class nstring : public xstring {
+
+	public:
+
+		const string getComponentName() const {
+
+			return "nstring";
+		}
+
+		nstring(component* comp = NULL, const int data = 0)
+			: xstring(true, comp, data) {
+
+		}
+	};
+
+
+	//
+	// astring ::= atom / string
+	//
+
+	DECLARE_COMPONENT(astring)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			std::unique_ptr <xstring> str;
+			VIMAP_PARSER_TRY_GET(xstring, str);
+
+			if (str) {
+				value = str->value;
+			} else {
+				std::unique_ptr <atom> at;
+				VIMAP_PARSER_GET(atom, at);
+				value = at->value;
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		string value;
+	};
+
+
+	//
+	// atom            ::= 1*ATOM_CHAR
+	//
+	// ATOM_CHAR       ::= <any CHAR except atom_specials>
+	// atom_specials   ::= "(" / ")" / "{" / SPACE / CTL / list_wildcards / quoted_specials
+	// CHAR            ::= <any 7-bit US-ASCII character except NUL, 0x01 - 0x7f>
+	// CTL             ::= <any ASCII control character and DEL, 0x00 - 0x1f, 0x7f>
+	// list_wildcards  ::= "%" / "*"
+	// quoted_specials ::= <"> / "\"
+	// SPACE           ::= <ASCII SP, space, 0x20>
+	//
+
+	DECLARE_COMPONENT(atom)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+			size_t len = 0;
+
+			for (bool end = false ; !end && pos < line.length() ; ) {
+
+				const unsigned char c = line[pos];
+
+				switch (c) {
+
+					case '(':
+					case ')':
+					case '{':
+					case 0x20:  // SPACE
+					case '%':   // list_wildcards
+					case '*':   // list_wildcards
+					case '"':   // quoted_specials
+					case '\\':  // quoted_specials
+
+					case '[':
+					case ']':   // for "special_atom"
+
+						end = true;
+						break;
+
+					default:
+
+						if (c <= 0x1f || c >= 0x7f) {
+							end = true;
+						} else {
+							++pos;
+							++len;
+						}
+					}
+			}
+
+			if (len != 0) {
+
+				value.resize(len);
+				std::copy(line.begin() + *currentPos, line.begin() + pos, value.begin());
+
+				*currentPos = pos;
+
+			} else {
+
+				VIMAP_PARSER_FAIL();
+			}
+
+			return true;
+		}
+
+
+		string value;
+	};
+
+
+	//
+	// special atom (eg. "CAPABILITY", "FLAGS", "STATUS"...)
+	//
+	//  " Except as noted otherwise, all alphabetic characters are case-
+	//    insensitive. The use of upper or lower case characters to define
+	//    token strings is for editorial clarity only. Implementations MUST
+	//    accept these strings in a case-insensitive fashion. "
+	//
+
+	class special_atom : public atom {
+
+	public:
+
+		const std::string getComponentName() const {
+
+			return string("special_atom <") + m_string + ">";
+		}
+
+		special_atom(const char* str)
+			: m_string(str) {  // 'string' must be in lower-case
+
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (!atom::parseImpl(parser, line, &pos)) {
+				return false;
+			}
+
+			const char* cmp = value.c_str();
+			const char* with = m_string;
+
+			bool ok = true;
+
+			while (ok && *cmp && *with) {
+
+				ok = (std::tolower(*cmp, std::locale()) == *with);
+
+				++cmp;
+				++with;
+			}
+
+			if (!ok || *cmp || *with) {
+				VIMAP_PARSER_FAIL();
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+	private:
+
+		const char* m_string;
+	};
+
+
+	//
+	// text_mime2 ::= "=?" <charset> "?" <encoding> "?" <encoded-text> "?="
+	//                ;; Syntax defined in [MIME-HDRS]
+	//
+
+	DECLARE_COMPONENT(text_mime2)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			std::unique_ptr <atom> theCharset, theEncoding;
+			std::unique_ptr <text> theText;
+
+			VIMAP_PARSER_CHECK(one_char <'='> );
+			VIMAP_PARSER_CHECK(one_char <'?'> );
+
+			VIMAP_PARSER_GET(atom, theCharset);
+
+			VIMAP_PARSER_CHECK(one_char <'?'> );
+
+			VIMAP_PARSER_GET(atom, theEncoding);
+
+			VIMAP_PARSER_CHECK(one_char <'?'> );
+
+			VIMAP_PARSER_GET(text8_except <'?'> , theText);
+
+			VIMAP_PARSER_CHECK(one_char <'?'> );
+			VIMAP_PARSER_CHECK(one_char <'='> );
+
+			charset = theCharset->value;
+
+			// Decode text
+			scoped_ptr <utility::encoder::encoder> theEncoder;
+
+			if (theEncoding->value[0] == 'q' || theEncoding->value[0] == 'Q') {
+
+				// Quoted-printable
+				theEncoder.reset(new utility::encoder::qpEncoder());
+				theEncoder->getProperties()["rfc2047"] = true;
+
+			} else if (theEncoding->value[0] == 'b' || theEncoding->value[0] == 'B') {
+
+				// Base64
+				theEncoder.reset(new utility::encoder::b64Encoder());
+			}
+
+			if (theEncoder.get()) {
+
+				utility::inputStreamStringAdapter in(theText->value);
+				utility::outputStreamStringAdapter out(value);
+
+				theEncoder->decode(in, out);
+
+			// No decoder available
+			} else {
+
+				value = theText->value;
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		vmime::charset charset;
+		string value;
+	};
+
+
+	// seq-number      = nz-number / "*"
+	//                    ; message sequence number (COPY, FETCH, STORE
+	//                    ; commands) or unique identifier (UID COPY,
+	//                    ; UID FETCH, UID STORE commands).
+
+	DECLARE_COMPONENT(seq_number)
+
+		seq_number()
+			: star(false) {
+
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <'*'> )) {
+
+				star = true;
+				number.reset();
+
+			} else {
+
+				star = false;
+				VIMAP_PARSER_GET(IMAPParser::number, number);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::number> number;
+		bool star;
+	};
+
+
+	// seq-range       = seq-number ":" seq-number
+	//                    ; two seq-number values and all values between
+	//                    ; these two regardless of order.
+	//                    ; Example: 2:4 and 4:2 are equivalent and indicate
+	//                    ; values 2, 3, and 4.
+
+	DECLARE_COMPONENT(seq_range)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(seq_number, first);
+
+			VIMAP_PARSER_CHECK(one_char <'*'> );
+
+			VIMAP_PARSER_GET(seq_number, last);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::seq_number> first;
+		std::unique_ptr <IMAPParser::seq_number> last;
+	};
+
+
+	// sequence-set    = (seq-number / seq-range) *("," sequence-set)
+	//                    ; set of seq-number values, regardless of order.
+	//                    ; Servers MAY coalesce overlaps and/or execute the
+	//                    ; sequence in any order.
+	//                    ; Example: a message sequence number set of
+	//                    ; 2,4:7,9,12:* for a mailbox with 15 messages is
+	//                    ; equivalent to 2,4,5,6,7,9,12,13,14,15
+
+	DECLARE_COMPONENT(sequence_set)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (!VIMAP_PARSER_TRY_GET(IMAPParser::seq_range, range)) {
+				VIMAP_PARSER_GET(IMAPParser::seq_number, number);
+			}
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <','> )) {
+				VIMAP_PARSER_GET(sequence_set, nextSet);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::seq_number> number;
+		std::unique_ptr <IMAPParser::seq_range> range;
+		std::unique_ptr <IMAPParser::sequence_set> nextSet;
+	};
+
+
+	// mod-sequence-value  = 1*DIGIT
+	//                        ;; Positive unsigned 64-bit integer
+	//                        ;; (mod-sequence)
+	//                        ;; (1 <= n < 18,446,744,073,709,551,615)
+
+	DECLARE_COMPONENT(mod_sequence_value)
+
+		mod_sequence_value()
+			: value(0) {
+
+		}
+
+		bool parseImpl(IMAPParser& /* parser */, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			bool valid = true;
+			vmime_uint64 val = 0;
+
+			while (valid && pos < line.length()) {
+
+				const char c = line[pos];
+
+				if (c >= '0' && c <= '9') {
+					val = (val * 10) + (c - '0');
+					++pos;
+				} else {
+					valid = false;
+				}
+			}
+
+			value = val;
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		vmime_uint64 value;
+	};
+
+
+	//
+	// flag            ::= "\Answered" / "\Flagged" / "\Deleted" /
+	//                     "\Seen" / "\Draft" / flag_keyword / flag_extension
+	//
+	// flag_extension  ::= "\" atom
+	//                     ;; Future expansion.  Client implementations
+	//                     ;; MUST accept flag_extension flags.  Server
+	//                     ;; implementations MUST NOT generate
+	//                     ;; flag_extension flags except as defined by
+	//                     ;; future standard or standards-track
+	//                     ;; revisions of this specification.
+	//
+	// flag_keyword    ::= atom
+	//
+
+	DECLARE_COMPONENT(flag)
+
+		flag()
+			: type(UNKNOWN) {
+
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <'\\'> )) {
+
+				if (VIMAP_PARSER_TRY_CHECK(one_char <'*'> )) {
+
+					type = STAR;
+
+				} else {
+
+					shared_ptr <atom> at;
+					VIMAP_PARSER_GET(atom, at);
+
+					const string tname = utility::stringUtils::toLower(at->value);
+
+					if (tname == "answered") {
+						type = ANSWERED;
+					} else if (tname == "flagged") {
+						type = FLAGGED;
+					} else if (tname == "deleted") {
+						type = DELETED;
+					} else if (tname == "seen") {
+						type = SEEN;
+					} else if (tname == "draft") {
+						type = DRAFT;
+					} else {
+						type = UNKNOWN;
+						name = tname;
+					}
+				}
+
+			} else {
+
+				if (!parser.isStrict() && VIMAP_PARSER_TRY_CHECK(one_char <'*'> )) {
+					type = STAR;  // map "*" to "\*"
+				} else {
+					type = KEYWORD_OR_EXTENSION;
+					VIMAP_PARSER_GET(atom, flag_keyword);
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+			UNKNOWN,
+			ANSWERED,
+			FLAGGED,
+			DELETED,
+			SEEN,
+			DRAFT,
+			KEYWORD_OR_EXTENSION,
+			STAR       // * = custom flags allowed
+		};
+
+
+		Type type;
+		string name;
+
+		std::unique_ptr <IMAPParser::atom> flag_keyword;
+	};
+
+
+	//
+	// flag_list ::= "(" #flag ")"
+	//
+
+	DECLARE_COMPONENT(flag_list)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'('> );
+
+			while (!VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+				VIMAP_PARSER_GET_PUSHBACK(flag, flags);
+				VIMAP_PARSER_TRY_CHECK(SPACE);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <flag>> flags;
+	};
+
+
+	//
+	// mailbox ::= "INBOX" / astring
+	//             ;; INBOX is case-insensitive.  All case variants of
+	//             ;; INBOX (e.g. "iNbOx") MUST be interpreted as INBOX
+	//             ;; not as an astring.  Refer to section 5.1 for
+	//             ;; further semantic details of mailbox names.
+	//
+
+	DECLARE_COMPONENT(mailbox)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "inbox")) {
+
+				type = INBOX;
+				name = "INBOX";
+
+			} else {
+
+				type = OTHER;
+
+				std::unique_ptr <astring> astr;
+				VIMAP_PARSER_GET(astring, astr);
+				name = astr->value;
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+			INBOX,
+			OTHER
+		};
+
+
+		Type type;
+		string name;
+	};
+
+
+	//
+	// mailbox_flag := "\Marked" / "\Noinferiors" /
+	//                 "\Noselect" / "\Unmarked" / flag_extension
+	//
+
+	DECLARE_COMPONENT(mailbox_flag)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <'\\'> )) {
+
+				std::unique_ptr <atom> at;
+				VIMAP_PARSER_GET(atom, at);
+
+				const string tname = utility::stringUtils::toLower(at->value);
+
+				type = UNKNOWN;  // default
+
+				switch (tname[0]) {
+
+					case 'a':
+
+						if (tname == "all") {
+							type = SPECIALUSE_ALL;
+						} else if (tname == "archive") {
+							type = SPECIALUSE_ARCHIVE;
+						}
+
+						break;
+
+					case 'd':
+
+						if (tname == "drafts") {
+							type = SPECIALUSE_DRAFTS;
+						}
+
+						break;
+
+					case 'f':
+
+						if (tname == "flagged") {
+							type = SPECIALUSE_FLAGGED;
+						}
+
+						break;
+
+					case 'h':
+
+						if (tname == "haschildren") {
+							type = HASCHILDREN;
+						} else if (tname == "hasnochildren") {
+							type = HASNOCHILDREN;
+						}
+
+						break;
+
+					case 'i':
+
+						if (tname == "important") {
+							type = SPECIALUSE_IMPORTANT;
+						}
+
+						break;
+
+					case 'j':
+
+						if (tname == "junk") {
+							type = SPECIALUSE_JUNK;
+						}
+
+						break;
+
+					case 'm':
+
+						if (tname == "marked") {
+							type = MARKED;
+						}
+
+						break;
+
+					case 'n':
+
+						if (tname == "noinferiors") {
+							type = NOINFERIORS;
+						} else if (tname == "noselect") {
+							type = NOSELECT;
+						}
+
+						break;
+
+					case 's':
+
+						if (tname == "sent") {
+							type = SPECIALUSE_SENT;
+						}
+
+						break;
+
+					case 't':
+
+						if (tname == "trash") {
+							type = SPECIALUSE_TRASH;
+						}
+
+						break;
+
+					case 'u':
+
+						if (tname == "unmarked") {
+							type = UNMARKED;
+						}
+
+						break;
+				}
+
+				if (type == UNKNOWN) {
+					name = "\\" + tname;
+				}
+
+			} else {
+
+				std::unique_ptr <atom> at;
+				VIMAP_PARSER_GET(atom, at);
+				const string tname = utility::stringUtils::toLower(at->value);
+
+				type = UNKNOWN;
+				name = tname;
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+			// RFC-3348 - Child Mailbox Extension
+			HASCHILDREN,
+			HASNOCHILDREN,
+
+			// RFC-6154 - Special-Use Mailboxes
+			SPECIALUSE_ALL,
+			SPECIALUSE_ARCHIVE,
+			SPECIALUSE_DRAFTS,
+			SPECIALUSE_FLAGGED,
+			SPECIALUSE_JUNK,
+			SPECIALUSE_SENT,
+			SPECIALUSE_TRASH,
+			SPECIALUSE_IMPORTANT,    // draft
+
+			// Standard mailbox flags
+			UNKNOWN,
+			MARKED,
+			NOINFERIORS,
+			NOSELECT,
+			UNMARKED
+		};
+
+
+		Type type;
+		string name;
+	};
+
+
+	//
+	// mailbox_flag_list ::= "(" #(mailbox_flag) ")"
+	//
+
+	DECLARE_COMPONENT(mailbox_flag_list)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'('> );
+
+			while (!VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+				VIMAP_PARSER_GET_PUSHBACK(mailbox_flag, flags);
+				VIMAP_PARSER_TRY_CHECK(SPACE);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <mailbox_flag>> flags;
+	};
+
+
+	//
+	// mailbox_list ::= mailbox_flag_list SPACE
+	//                  (<"> QUOTED_CHAR <"> / nil) SPACE mailbox
+	//
+
+	DECLARE_COMPONENT(mailbox_list)
+
+		mailbox_list()
+			: quoted_char('\0') {
+
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::mailbox_flag_list, mailbox_flag_list);
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			if (!VIMAP_PARSER_TRY_CHECK(NIL)) {
+
+				VIMAP_PARSER_CHECK(one_char <'"'> );
+
+				std::unique_ptr <QUOTED_CHAR> qc;
+				VIMAP_PARSER_GET(QUOTED_CHAR, qc);
+				quoted_char = qc->value;
+
+				VIMAP_PARSER_CHECK(one_char <'"'> );
+			}
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::mailbox, mailbox);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::mailbox_flag_list> mailbox_flag_list;
+		std::unique_ptr <IMAPParser::mailbox> mailbox;
+
+		char quoted_char;
+	};
+
+
+	//
+	// auth_type ::= atom
+	//               ;; Defined by [IMAP-AUTH]
+	//
+
+	DECLARE_COMPONENT(auth_type)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			std::unique_ptr <atom> at;
+			VIMAP_PARSER_GET(atom, at);
+
+			name = utility::stringUtils::toLower(at->value);
+
+			if (name == "kerberos_v4") {
+				type = KERBEROS_V4;
+			} else if (name == "gssapi") {
+				type = GSSAPI;
+			} else if (name == "skey") {
+				type = SKEY;
+			} else {
+				type = UNKNOWN;
+			}
+
+			return true;
+		}
+
+
+		enum Type {
+			UNKNOWN,
+
+			// RFC 1731 - IMAP4 Authentication Mechanisms
+			KERBEROS_V4,
+			GSSAPI,
+			SKEY
+		};
+
+
+		Type type;
+		string name;
+	};
+
+
+	//
+	// status-att-val  = ("MESSAGES" SP number) /
+	//                   ("RECENT" SP number) /
+	//                   ("UIDNEXT" SP nz-number) /
+	//                   ("UIDVALIDITY" SP nz-number) /
+	//                   ("UNSEEN" SP number)
+	//
+	// IMAP Extension for Conditional STORE (RFC-4551):
+	//
+	//   status-att-val      =/ "HIGHESTMODSEQ" SP mod-sequence-valzer
+	//                          ;; extends non-terminal defined in [IMAPABNF].
+	//                          ;; Value 0 denotes that the mailbox doesn't
+	//                          ;; support persistent mod-sequences
+	//
+
+	DECLARE_COMPONENT(status_att_val)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			// "HIGHESTMODSEQ" SP mod-sequence-valzer
+			if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "highestmodseq")) {
+
+				type = HIGHESTMODSEQ;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::mod_sequence_value, value);
+
+			} else {
+
+				if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "messages")) {
+					type = MESSAGES;
+				} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "recent")) {
+					type = RECENT;
+				} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "uidnext")) {
+					type = UIDNEXT;
+				} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "uidvalidity")) {
+					type = UIDVALIDITY;
+				} else {
+					VIMAP_PARSER_CHECK_WITHARG(special_atom, "unseen");
+					type = UNSEEN;
+				}
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::number, value);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+			// Extensions
+			HIGHESTMODSEQ,
+
+			// Standard IMAP
+			MESSAGES,
+			RECENT,
+			UIDNEXT,
+			UIDVALIDITY,
+			UNSEEN
+		};
+
+
+		Type type;
+		std::unique_ptr <IMAPParser::component> value;
+
+
+		const IMAPParser::number* value_as_number() const {
+			return dynamic_cast <IMAPParser::number *>(value.get());
+		}
+
+		const IMAPParser::mod_sequence_value* value_as_mod_sequence_value() const {
+			return dynamic_cast <IMAPParser::mod_sequence_value *>(value.get());
+		}
+	};
+
+
+	// status-att-list = status-att-val *(SP status-att-val)
+
+	DECLARE_COMPONENT(status_att_list)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET_PUSHBACK(IMAPParser::status_att_val, values);
+
+			while (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+				VIMAP_PARSER_GET_PUSHBACK(IMAPParser::status_att_val, values);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <status_att_val>> values;
+	};
+
+
+	//
+	// capability ::= "AUTH=" auth_type / atom
+	//                ;; New capabilities MUST begin with "X" or be
+	//                ;; registered with IANA as standard or standards-track
+	//
+
+	DECLARE_COMPONENT(capability)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::atom, atom);
+
+			string value = atom->value;
+			const char* str = value.c_str();
+
+			if ((str[0] == 'a' || str[0] == 'A') &&
+			    (str[1] == 'u' || str[1] == 'U') &&
+			    (str[2] == 't' || str[2] == 'T') &&
+			    (str[3] == 'h' || str[3] == 'H') &&
+			    (str[4] == '=')) {
+
+				size_t pos = 5;
+				auth_type.reset(parser.get <IMAPParser::auth_type>(value, &pos));
+
+				atom.reset();
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::auth_type> auth_type;
+		std::unique_ptr <IMAPParser::atom> atom;
+	};
+
+
+	//
+	// capability_data ::= "CAPABILITY" SPACE [1#capability SPACE] "IMAP4rev1"
+	//                     [SPACE 1#capability]
+	//                     ;; IMAP4rev1 servers which offer RFC 1730
+	//                     ;; compatibility MUST list "IMAP4" as the first
+	//                     ;; capability.
+	//
+
+	DECLARE_COMPONENT(capability_data)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK_WITHARG(special_atom, "capability");
+
+			while (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+
+				std::unique_ptr <capability> cap;
+
+				if (parser.isStrict() || capabilities.empty()) {
+					VIMAP_PARSER_GET(capability, cap);
+				} else {
+					VIMAP_PARSER_TRY_GET(capability, cap);  // allow SPACE at end of line (Apple iCloud IMAP server)
+				}
+
+				if (!cap) {
+					break;
+				}
+
+				capabilities.push_back(std::move(cap));
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <capability>> capabilities;
+	};
+
+
+	//
+	// date_day_fixed  ::= (SPACE digit) / 2digit
+	//                    ;; Fixed-format version of date_day
+	//
+	// date_month      ::= "Jan" / "Feb" / "Mar" / "Apr" / "May" / "Jun" /
+	//                    "Jul" / "Aug" / "Sep" / "Oct" / "Nov" / "Dec"
+	//
+	// date_year       ::= 4digit
+	//
+	// time            ::= 2digit ":" 2digit ":" 2digit
+	//                     ;; Hours minutes seconds
+	//
+	// zone            ::= ("+" / "-") 4digit
+	//                     ;; Signed four-digit value of hhmm representing
+	//                     ;; hours and minutes west of Greenwich (that is,
+	//                     ;; (the amount that the given time differs from
+	//                     ;; Universal Time).  Subtracting the timezone
+	//                     ;; from the given time will give the UT form.
+	//                     ;; The Universal Time zone is "+0000".
+	//
+	// date_time       ::= <"> date_day_fixed "-" date_month "-" date_year
+	//                     SPACE time SPACE zone <">
+	//
+
+	DECLARE_COMPONENT(date_time)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			// <"> date_day_fixed "-" date_month "-" date_year
+			VIMAP_PARSER_CHECK(one_char <'"'> );
+			VIMAP_PARSER_TRY_CHECK(SPACE);
+
+			shared_ptr <number> nd;
+			VIMAP_PARSER_GET(number, nd);
+
+			VIMAP_PARSER_CHECK(one_char <'-'> );
+
+			shared_ptr <atom> amo;
+			VIMAP_PARSER_GET(atom, amo);
+
+			VIMAP_PARSER_CHECK(one_char <'-'> );
+
+			shared_ptr <number> ny;
+			VIMAP_PARSER_GET(number, ny);
+
+			VIMAP_PARSER_TRY_CHECK(SPACE);
+
+			// 2digit ":" 2digit ":" 2digit
+			shared_ptr <number> nh;
+			VIMAP_PARSER_GET(number, nh);
+
+			VIMAP_PARSER_CHECK(one_char <':'> );
+
+			shared_ptr <number> nmi;
+			VIMAP_PARSER_GET(number, nmi);
+
+			VIMAP_PARSER_CHECK(one_char <':'> );
+
+			shared_ptr <number> ns;
+			VIMAP_PARSER_GET(number, ns);
+
+			VIMAP_PARSER_TRY_CHECK(SPACE);
+
+			// ("+" / "-") 4digit
+			int sign = 1;
+
+			if (!(VIMAP_PARSER_TRY_CHECK(one_char <'+'> ))) {
+				VIMAP_PARSER_CHECK(one_char <'-'> );
+			}
+
+			shared_ptr <number> nz;
+			VIMAP_PARSER_GET(number, nz);
+
+			VIMAP_PARSER_CHECK(one_char <'"'> );
+
+
+			m_datetime.setHour(static_cast <int>(std::min(std::max(nh->value, 0ul), 23ul)));
+			m_datetime.setMinute(static_cast <int>(std::min(std::max(nmi->value, 0ul), 59ul)));
+			m_datetime.setSecond(static_cast <int>(std::min(std::max(ns->value, 0ul), 59ul)));
+
+			const int zone = static_cast <int>(nz->value);
+			const int zh = zone / 100;   // hour offset
+			const int zm = zone % 100;   // minute offset
+
+			m_datetime.setZone(((zh * 60) + zm) * sign);
+
+			m_datetime.setDay(static_cast <int>(std::min(std::max(nd->value, 1ul), 31ul)));
+			m_datetime.setYear(static_cast <int>(ny->value));
+
+			const string month(utility::stringUtils::toLower(amo->value));
+			int mon = vmime::datetime::JANUARY;
+
+			if (month.length() >= 3) {
+
+				switch (month[0]) {
+
+					case 'j': {
+
+						switch (month[1]) {
+
+							case 'a': mon = vmime::datetime::JANUARY; break;
+							case 'u': {
+
+								switch (month[2]) {
+
+									case 'n': mon = vmime::datetime::JUNE; break;
+									default:  mon = vmime::datetime::JULY; break;
+								}
+
+								break;
+							}
+
+						}
+
+						break;
+					}
+					case 'f': mon = vmime::datetime::FEBRUARY; break;
+					case 'm': {
+
+						switch (month[2]) {
+							case 'r': mon = vmime::datetime::MARCH; break;
+							default:  mon = vmime::datetime::MAY; break;
+						}
+
+						break;
+					}
+					case 'a':
+					{
+						switch (month[1]) {
+							case 'p': mon = vmime::datetime::APRIL; break;
+							default:  mon = vmime::datetime::AUGUST; break;
+						}
+
+						break;
+					}
+					case 's': mon = vmime::datetime::SEPTEMBER; break;
+					case 'o': mon = vmime::datetime::OCTOBER; break;
+					case 'n': mon = vmime::datetime::NOVEMBER; break;
+					case 'd': mon = vmime::datetime::DECEMBER; break;
+				}
+			}
+
+			m_datetime.setMonth(mon);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+	private:
+
+		vmime::datetime m_datetime;
+	};
+
+
+	//
+	// header_fld_name ::= astring
+	//
+
+	COMPONENT_ALIAS(astring, header_fld_name);
+
+
+	//
+	// header_list     ::= "(" 1#header_fld_name ")"
+	//
+
+	DECLARE_COMPONENT(header_list)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'('> );
+
+			while (!VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+				VIMAP_PARSER_GET_PUSHBACK(header_fld_name, fld_names);
+				VIMAP_PARSER_TRY_CHECK(SPACE);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <header_fld_name>> fld_names;
+	};
+
+
+	//
+	// body_extension  ::= nstring / number / "(" 1#body_extension ")"
+	//                     ;; Future expansion.  Client implementations
+	//                     ;; MUST accept body_extension fields.  Server
+	//                     ;; implementations MUST NOT generate
+	//                     ;; body_extension fields except as defined by
+	//                     ;; future standard or standards-track
+	//                     ;; revisions of this specification.
+	//
+
+	DECLARE_COMPONENT(body_extension)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <'('> )) {
+
+				VIMAP_PARSER_GET_PUSHBACK(body_extension, body_extensions);
+
+				while (!VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+					VIMAP_PARSER_GET_PUSHBACK(body_extension, body_extensions);
+					VIMAP_PARSER_TRY_CHECK(SPACE);
+				}
+
+			} else {
+
+				if (!VIMAP_PARSER_TRY_GET(IMAPParser::nstring, nstring)) {
+					VIMAP_PARSER_GET(IMAPParser::number, number);
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::nstring> nstring;
+		std::unique_ptr <IMAPParser::number> number;
+
+		std::vector <std::unique_ptr <body_extension>> body_extensions;
+	};
+
+
+	//
+	// section_text    ::= "HEADER" / "HEADER.FIELDS" [".NOT"]
+	//                     SPACE header_list / "TEXT" / "MIME"
+	//
+
+	DECLARE_COMPONENT(section_text)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			// "HEADER.FIELDS" [".NOT"] SPACE header_list
+			const bool b1 = VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "header.fields.not");
+			const bool b2 = (b1 ? false : VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "header.fields"));
+
+			if (b1 || b2) {
+
+				type = b1 ? HEADER_FIELDS_NOT : HEADER_FIELDS;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::header_list, header_list);
+
+			// "HEADER"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "header")) {
+
+				type = HEADER;
+
+			// "MIME"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "mime")) {
+
+				type = MIME;
+
+			// "TEXT"
+			} else {
+
+				type = TEXT;
+
+				VIMAP_PARSER_CHECK_WITHARG(special_atom, "text");
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+			HEADER,
+			HEADER_FIELDS,
+			HEADER_FIELDS_NOT,
+			MIME,
+			TEXT
+		};
+
+
+		Type type;
+		std::unique_ptr <IMAPParser::header_list> header_list;
+	};
+
+
+	//
+	// section         ::= "[" [section_text / (nz_number *["." nz_number]
+	//                     ["." (section_text / "MIME")])] "]"
+	//
+
+	DECLARE_COMPONENT(section)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'['> );
+
+			if (!VIMAP_PARSER_TRY_CHECK(one_char <']'> )) {
+
+				if (!VIMAP_PARSER_TRY_GET(section_text, section_text1)) {
+
+					std::unique_ptr <nz_number> num;
+					VIMAP_PARSER_GET(nz_number, num);
+					nz_numbers.push_back(static_cast <unsigned int>(num->value));
+
+					while (VIMAP_PARSER_TRY_CHECK(one_char <'.'> )) {
+
+						if (VIMAP_PARSER_TRY_GET(nz_number, num)) {
+							nz_numbers.push_back(static_cast <unsigned int>(num->value));
+						} else {
+							VIMAP_PARSER_GET(section_text, section_text2);
+							break;
+						}
+					}
+				}
+
+				VIMAP_PARSER_CHECK(one_char <']'> );
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <section_text> section_text1;
+		std::unique_ptr <section_text> section_text2;
+		std::vector <unsigned int> nz_numbers;
+	};
+
+
+	//
+	// addr_adl        ::= nstring
+	//                     ;; Holds route from [RFC-822] route-addr if
+	//                     ;; non-NIL
+	//
+	// addr_host       ::= nstring
+	//                     ;; NIL indicates [RFC-822] group syntax.
+	//                     ;; Otherwise, holds [RFC-822] domain name
+	//
+	// addr_mailbox    ::= nstring
+	//                     ;; NIL indicates end of [RFC-822] group; if
+	//                     ;; non-NIL and addr_host is NIL, holds
+	//                     ;; [RFC-822] group name.
+	//                     ;; Otherwise, holds [RFC-822] local-part
+	//
+	// addr_name       ::= nstring
+	//                     ;; Holds phrase from [RFC-822] mailbox if
+	//                     ;; non-NIL
+	//
+	// address         ::= "(" addr_name SPACE addr_adl SPACE addr_mailbox
+	//                     SPACE addr_host ")"
+	//
+
+	DECLARE_COMPONENT(address)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'('> );
+			VIMAP_PARSER_GET(nstring, addr_name);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(nstring, addr_adl);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(nstring, addr_mailbox);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(nstring, addr_host);
+			VIMAP_PARSER_CHECK(one_char <')'> );
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <nstring> addr_name;
+		std::unique_ptr <nstring> addr_adl;
+		std::unique_ptr <nstring> addr_mailbox;
+		std::unique_ptr <nstring> addr_host;
+	};
+
+
+	//
+	// address_list ::= "(" 1*address ")" / nil
+	//
+
+	DECLARE_COMPONENT(address_list)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (!VIMAP_PARSER_TRY_CHECK(NIL)) {
+
+				VIMAP_PARSER_CHECK(one_char <'('> );
+
+				while (!VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+					VIMAP_PARSER_GET_PUSHBACK(address, addresses);
+					VIMAP_PARSER_TRY_CHECK(SPACE);
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <address>> addresses;
+	};
+
+
+	//
+	// env_bcc         ::= "(" 1*address ")" / nil
+	//
+
+	COMPONENT_ALIAS(address_list, env_bcc);
+
+
+	//
+	// env_cc          ::= "(" 1*address ")" / nil
+	//
+
+	COMPONENT_ALIAS(address_list, env_cc);
+
+
+	//
+	// env_date        ::= nstring
+	//
+
+	COMPONENT_ALIAS(nstring, env_date);
+
+
+	//
+	// env_from        ::= "(" 1*address ")" / nil
+	//
+
+	COMPONENT_ALIAS(address_list, env_from);
+
+
+	//
+	// env_in_reply_to ::= nstring
+	//
+
+	COMPONENT_ALIAS(nstring, env_in_reply_to);
+
+
+	//
+	// env_message_id  ::= nstring
+	//
+
+	COMPONENT_ALIAS(nstring, env_message_id);
+
+
+	//
+	// env_reply_to    ::= "(" 1*address ")" / nil
+	//
+
+	COMPONENT_ALIAS(address_list, env_reply_to);
+
+
+	//
+	// env_sender      ::= "(" 1*address ")" / nil
+	//
+
+	COMPONENT_ALIAS(address_list, env_sender);
+
+
+	//
+	// env_subject     ::= nstring
+	//
+
+	COMPONENT_ALIAS(nstring, env_subject);
+
+
+	//
+	// env_to          ::= "(" 1*address ")" / nil
+	//
+
+	COMPONENT_ALIAS(address_list, env_to);
+
+
+	//
+	// envelope ::= "(" env_date SPACE env_subject SPACE env_from
+	//              SPACE env_sender SPACE env_reply_to SPACE env_to
+	//              SPACE env_cc SPACE env_bcc SPACE env_in_reply_to
+	//              SPACE env_message_id ")"
+	//
+
+	DECLARE_COMPONENT(envelope)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'('> );
+
+			VIMAP_PARSER_GET(IMAPParser::env_date, env_date);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_subject, env_subject);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_from, env_from);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_sender, env_sender);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_reply_to, env_reply_to);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_to, env_to);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_cc, env_cc);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_bcc, env_bcc);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_in_reply_to, env_in_reply_to);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_message_id, env_message_id);
+
+			VIMAP_PARSER_CHECK(one_char <')'> );
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::env_date> env_date;
+		std::unique_ptr <IMAPParser::env_subject> env_subject;
+		std::unique_ptr <IMAPParser::env_from> env_from;
+		std::unique_ptr <IMAPParser::env_sender> env_sender;
+		std::unique_ptr <IMAPParser::env_reply_to> env_reply_to;
+		std::unique_ptr <IMAPParser::env_to> env_to;
+		std::unique_ptr <IMAPParser::env_cc> env_cc;
+		std::unique_ptr <IMAPParser::env_bcc> env_bcc;
+		std::unique_ptr <IMAPParser::env_in_reply_to> env_in_reply_to;
+		std::unique_ptr <IMAPParser::env_message_id> env_message_id;
+	};
+
+
+	//
+	// body_fld_desc   ::= nstring
+	//
+
+	COMPONENT_ALIAS(nstring, body_fld_desc);
+
+
+	//
+	// body_fld_id     ::= nstring
+	//
+
+	COMPONENT_ALIAS(nstring, body_fld_id);
+
+
+	//
+	// body_fld_md5    ::= nstring
+	//
+
+	COMPONENT_ALIAS(nstring, body_fld_md5);
+
+
+	//
+	// body_fld_octets ::= number
+	//
+
+	COMPONENT_ALIAS(number, body_fld_octets);
+
+
+	//
+	// body_fld_lines  ::= number
+	//
+
+	COMPONENT_ALIAS(number, body_fld_lines);
+
+
+	//
+	// body_fld_enc    ::= (<"> ("7BIT" / "8BIT" / "BINARY" / "BASE64"/
+	//                     "QUOTED-PRINTABLE") <">) / string
+	//
+
+	class body_fld_enc : public nstring {
+
+	public:
+
+		const string getComponentName() const {
+
+			return "body_fld_enc";
+		}
+
+		body_fld_enc() {
+
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (!xstring::parseImpl(parser, line, &pos)) {
+				return false;
+			}
+
+			// " When an IMAP4 client sends a FETCH (bodystructure) request
+			//   to a server that is running the Exchange Server 2007 IMAP4
+			//   service, a corrupted response is sent as a reply "
+			//   (see http://support.microsoft.com/kb/975918/en-us)
+			//
+			// Fail in strict mode
+			if (isNIL && parser.isStrict()) {
+				VIMAP_PARSER_FAIL();
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+	};
+
+
+	//
+	// body_fld_param_item ::= string SPACE string
+	//
+
+	DECLARE_COMPONENT(body_fld_param_item)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (!parser.isStrict()) {
+
+				// Some servers send an <atom> instead of a <string> here:
+				// eg. ... (CHARSET "X-UNKNOWN") ...
+				if (!VIMAP_PARSER_TRY_GET(xstring, string1)) {
+
+					std::unique_ptr <atom> at;
+					VIMAP_PARSER_GET(atom, at);
+
+					string1.reset(new xstring());
+					string1->value = at->value;
+				}
+
+			} else {
+
+				VIMAP_PARSER_GET(xstring, string1);
+			}
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			if (!parser.isStrict()) {
+
+				// In non-strict mode, allow NIL in value
+				std::unique_ptr <nstring> nstr;
+				VIMAP_PARSER_GET(nstring, nstr);
+
+				string2.reset(new xstring());
+				string2->value = nstr->value;
+
+			} else {
+
+				VIMAP_PARSER_GET(xstring, string2);
+			}
+
+			DEBUG_FOUND("body_fld_param_item", "<" << string1->value << ", " << string2->value << ">");
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <xstring> string1;
+		std::unique_ptr <xstring> string2;
+	};
+
+
+	//
+	// body_fld_param  ::= "(" 1#(body_fld_param_item) ")" / nil
+	//
+
+	DECLARE_COMPONENT(body_fld_param)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <'('> )) {
+
+				bool isNIL = false;
+
+				if (!parser.isStrict()) {
+
+					// In non-strict mode, allow "()" instead of "NIL"
+					if (VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+						isNIL = true;
+					}
+				}
+
+				if (!isNIL) {
+
+					VIMAP_PARSER_GET_PUSHBACK(body_fld_param_item, items);
+
+					while (!VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+						VIMAP_PARSER_CHECK(SPACE);
+						VIMAP_PARSER_GET_PUSHBACK(body_fld_param_item, items);
+					}
+				}
+
+			} else {
+
+				VIMAP_PARSER_CHECK(NIL);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <body_fld_param_item>> items;
+	};
+
+
+	//
+	// body_fld_dsp    ::= "(" string SPACE body_fld_param ")" / nil
+	//
+
+	DECLARE_COMPONENT(body_fld_dsp)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <'('> )) {
+
+				VIMAP_PARSER_GET(xstring, m_string);
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(class body_fld_param, m_body_fld_param);
+				VIMAP_PARSER_CHECK(one_char <')'> );
+
+			} else {
+
+				VIMAP_PARSER_CHECK(NIL);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+	private:
+
+		std::unique_ptr <class xstring> m_string;
+		std::unique_ptr <class body_fld_param> m_body_fld_param;
+
+	public:
+
+		const class xstring* str() const { return m_string.get(); }
+		const class body_fld_param* body_fld_param() const { return m_body_fld_param.get(); }
+	};
+
+
+	//
+	// body_fld_lang   ::= nstring / "(" 1#string ")"
+	//
+
+	DECLARE_COMPONENT(body_fld_lang)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <'('> )) {
+
+				VIMAP_PARSER_GET_PUSHBACK(xstring, strings);
+
+				while (!VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+					VIMAP_PARSER_CHECK(SPACE);
+					VIMAP_PARSER_GET_PUSHBACK(xstring, strings);
+				}
+
+			} else {
+
+				VIMAP_PARSER_GET_PUSHBACK(nstring, strings);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <xstring>> strings;
+	};
+
+
+	//
+	// body_fields     ::= body_fld_param SPACE body_fld_id SPACE
+	//                     body_fld_desc SPACE body_fld_enc SPACE
+	//                     body_fld_octets
+	//
+
+	DECLARE_COMPONENT(body_fields)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::body_fld_param, body_fld_param);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fld_id, body_fld_id);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fld_desc, body_fld_desc);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fld_enc, body_fld_enc);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fld_octets, body_fld_octets);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::body_fld_param> body_fld_param;
+		std::unique_ptr <IMAPParser::body_fld_id> body_fld_id;
+		std::unique_ptr <IMAPParser::body_fld_desc> body_fld_desc;
+		std::unique_ptr <IMAPParser::body_fld_enc> body_fld_enc;
+		std::unique_ptr <IMAPParser::body_fld_octets> body_fld_octets;
+	};
+
+
+	//
+	// media_subtype   ::= string
+	//                     ;; Defined in [MIME-IMT]
+	//
+
+	COMPONENT_ALIAS(xstring, media_subtype);
+
+
+	//
+	// media_text      ::= <"> "TEXT" <"> SPACE media_subtype
+	//                     ;; Defined in [MIME-IMT]
+	//
+
+	DECLARE_COMPONENT(media_text)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'"'> );
+			VIMAP_PARSER_CHECK_WITHARG(special_atom, "text");
+			VIMAP_PARSER_CHECK(one_char <'"'> );
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::media_subtype, media_subtype);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::media_subtype> media_subtype;
+	};
+
+
+	//
+	// media_message   ::= <"> "MESSAGE" <"> SPACE <"> "RFC822" <">
+	//                     ;; Defined in [MIME-IMT]
+	//
+
+	DECLARE_COMPONENT(media_message)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'"'> );
+			VIMAP_PARSER_CHECK_WITHARG(special_atom, "message");
+			VIMAP_PARSER_CHECK(one_char <'"'> );
+			VIMAP_PARSER_CHECK(SPACE);
+
+			//VIMAP_PARSER_CHECK(one_char <'"'> );
+			//VIMAP_PARSER_CHECK_WITHARG(special_atom, "rfc822");
+			//VIMAP_PARSER_CHECK(one_char <'"'> );
+
+			VIMAP_PARSER_GET(IMAPParser::media_subtype, media_subtype);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::media_subtype> media_subtype;
+	};
+
+
+	//
+	// media_basic     ::= (<"> ("APPLICATION" / "AUDIO" / "IMAGE" /
+	//                     "MESSAGE" / "VIDEO") <">) / string)
+	//                     SPACE media_subtype
+	//                     ;; Defined in [MIME-IMT]
+
+	DECLARE_COMPONENT(media_basic)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(xstring, media_type);
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::media_subtype, media_subtype);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::xstring> media_type;
+		std::unique_ptr <IMAPParser::media_subtype> media_subtype;
+	};
+
+
+	//
+	// body_ext_1part  ::= body_fld_md5 [SPACE body_fld_dsp
+	//                     [SPACE body_fld_lang
+	//                     [SPACE 1#body_extension]]]
+	//                     ;; MUST NOT be returned on non-extensible
+	//                     ;; "BODY" fetch
+	//
+
+	DECLARE_COMPONENT(body_ext_1part)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos)
+		{
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::body_fld_md5, body_fld_md5);
+
+			// [SPACE body_fld_dsp
+			if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+
+				VIMAP_PARSER_GET(IMAPParser::body_fld_dsp, body_fld_dsp);
+
+				// [SPACE body_fld_lang
+				if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+
+					VIMAP_PARSER_GET(IMAPParser::body_fld_lang, body_fld_lang);
+
+					// [SPACE 1#body_extension]
+					if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+
+						VIMAP_PARSER_GET_PUSHBACK(body_extension, body_extensions);
+
+						while (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+							VIMAP_PARSER_GET_PUSHBACK(body_extension, body_extensions);
+						}
+					}
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::body_fld_md5> body_fld_md5;
+		std::unique_ptr <IMAPParser::body_fld_dsp> body_fld_dsp;
+		std::unique_ptr <IMAPParser::body_fld_lang> body_fld_lang;
+
+		std::vector <std::unique_ptr <body_extension>> body_extensions;
+	};
+
+
+	//
+	// body_ext_mpart  ::= body_fld_param
+	//                     [SPACE body_fld_dsp [SPACE body_fld_lang
+	//                     [SPACE 1#body_extension]]]
+	//                     ;; MUST NOT be returned on non-extensible
+	//                     ;; "BODY" fetch
+
+	DECLARE_COMPONENT(body_ext_mpart)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::body_fld_param, body_fld_param);
+
+			// [SPACE body_fld_dsp [SPACE body_fld_lang [SPACE 1#body_extension]]]
+			if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+
+				VIMAP_PARSER_GET(IMAPParser::body_fld_dsp, body_fld_dsp);
+
+				if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+
+					VIMAP_PARSER_GET(IMAPParser::body_fld_lang, body_fld_lang);
+
+					// [SPACE 1#body_extension]
+					if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+
+						VIMAP_PARSER_GET_PUSHBACK(body_extension, body_extensions);
+
+						while (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+							VIMAP_PARSER_GET_PUSHBACK(body_extension, body_extensions);
+						}
+					}
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::body_fld_param> body_fld_param;
+		std::unique_ptr <IMAPParser::body_fld_dsp> body_fld_dsp;
+		std::unique_ptr <IMAPParser::body_fld_lang> body_fld_lang;
+
+		std::vector <std::unique_ptr <body_extension>> body_extensions;
+	};
+
+
+	//
+	// body_type_basic ::= media_basic SPACE body_fields
+	//                     ;; MESSAGE subtype MUST NOT be "RFC822"
+	//
+
+	DECLARE_COMPONENT(body_type_basic)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::media_basic, media_basic);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fields, body_fields);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::media_basic> media_basic;
+		std::unique_ptr <IMAPParser::body_fields> body_fields;
+	};
+
+
+	//
+	// body_type_msg   ::= media_message SPACE body_fields SPACE envelope
+	//                     SPACE body SPACE body_fld_lines
+	//
+
+	class xbody;
+	typedef xbody body;
+
+	DECLARE_COMPONENT(body_type_msg)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::media_message, media_message);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fields, body_fields);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			// BUGFIX: made SPACE optional. This is not standard, but some servers
+			// seem to return responses like that...
+			VIMAP_PARSER_GET(IMAPParser::envelope, envelope);
+			VIMAP_PARSER_TRY_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::xbody, body);
+			VIMAP_PARSER_TRY_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fld_lines, body_fld_lines);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::media_message> media_message;
+		std::unique_ptr <IMAPParser::body_fields> body_fields;
+		std::unique_ptr <IMAPParser::envelope> envelope;
+		std::unique_ptr <IMAPParser::xbody> body;
+		std::unique_ptr <IMAPParser::body_fld_lines> body_fld_lines;
+	};
+
+
+	//
+	// body_type_text  ::= media_text SPACE body_fields SPACE body_fld_lines
+	//
+
+	DECLARE_COMPONENT(body_type_text)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::media_text, media_text);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fields, body_fields);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fld_lines, body_fld_lines);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::media_text> media_text;
+		std::unique_ptr <IMAPParser::body_fields> body_fields;
+		std::unique_ptr <IMAPParser::body_fld_lines> body_fld_lines;
+	};
+
+
+	//
+	// body_type_1part ::= (body_type_basic / body_type_msg / body_type_text)
+	//                     [SPACE body_ext_1part]
+	//
+
+	DECLARE_COMPONENT(body_type_1part)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (!VIMAP_PARSER_TRY_GET(IMAPParser::body_type_text, body_type_text)) {
+				if (!VIMAP_PARSER_TRY_GET(IMAPParser::body_type_msg, body_type_msg)) {
+					VIMAP_PARSER_GET(IMAPParser::body_type_basic, body_type_basic);
+				}
+			}
+
+			if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+				if (!VIMAP_PARSER_TRY_GET(IMAPParser::body_ext_1part, body_ext_1part)) {
+					--pos;
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::body_type_basic> body_type_basic;
+		std::unique_ptr <IMAPParser::body_type_msg> body_type_msg;
+		std::unique_ptr <IMAPParser::body_type_text> body_type_text;
+
+		std::unique_ptr <IMAPParser::body_ext_1part> body_ext_1part;
+	};
+
+
+	//
+	// body_type_mpart ::= 1*body SPACE media_subtype
+	//                     [SPACE body_ext_mpart]
+	//
+
+	DECLARE_COMPONENT(body_type_mpart)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET_PUSHBACK(xbody, list);
+
+			while (true) {
+				VIMAP_PARSER_TRY_GET_PUSHBACK_OR_ELSE(xbody, list, break);
+			}
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::media_subtype, media_subtype);
+
+			if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+				VIMAP_PARSER_GET(IMAPParser::body_ext_mpart, body_ext_mpart);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::media_subtype> media_subtype;
+		std::unique_ptr <IMAPParser::body_ext_mpart> body_ext_mpart;
+
+		std::vector <std::unique_ptr <xbody>> list;
+	};
+
+
+	//
+	// xbody ::= "(" body_type_1part / body_type_mpart ")"
+	//
+
+	DECLARE_COMPONENT(xbody)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'('> );
+
+			if (!VIMAP_PARSER_TRY_GET(IMAPParser::body_type_mpart, body_type_mpart)) {
+				VIMAP_PARSER_GET(IMAPParser::body_type_1part, body_type_1part);
+			}
+
+			VIMAP_PARSER_CHECK(one_char <')'> );
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::body_type_1part> body_type_1part;
+		std::unique_ptr <IMAPParser::body_type_mpart> body_type_mpart;
+	};
+
+
+	// msg_att_item ::= "ENVELOPE" SPACE envelope /
+	//                  "FLAGS" SPACE "(" #(flag / "\Recent") ")" /
+	//                  "INTERNALDATE" SPACE date_time /
+	//                  "RFC822" [".HEADER" / ".TEXT"] SPACE nstring /
+	//                  "RFC822.SIZE" SPACE number /
+	//                  "BODY" ["STRUCTURE"] SPACE body /
+	//                  "BODY" section ["<" number ">"] SPACE nstring /
+	//                  "UID" SPACE uniqueid
+	//
+	// IMAP Extension for Conditional STORE (RFC-4551):
+	//
+	//   msg_att_item      /= "MODSEQ" SP "(" mod_sequence_value ")"
+
+	DECLARE_COMPONENT(msg_att_item)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			// "ENVELOPE" SPACE envelope
+			if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "envelope")) {
+
+				type = ENVELOPE;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::envelope, envelope);
+
+			// "FLAGS" SPACE "(" #(flag / "\Recent") ")"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "flags")) {
+
+				type = FLAGS;
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				VIMAP_PARSER_GET(IMAPParser::flag_list, flag_list);
+
+			// "INTERNALDATE" SPACE date_time
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "internaldate")) {
+
+				type = INTERNALDATE;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::date_time, date_time);
+
+			// "RFC822" ".HEADER" SPACE nstring
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "rfc822.header")) {
+
+				type = RFC822_HEADER;
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				VIMAP_PARSER_GET(IMAPParser::nstring, nstring);
+
+			// "RFC822" ".TEXT" SPACE nstring
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "rfc822.text")) {
+
+				type = RFC822_TEXT;
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				nstring.reset(parser.getWithArgs <IMAPParser::nstring>(line, &pos, this, RFC822_TEXT));
+
+				VIMAP_PARSER_FAIL_UNLESS(nstring);
+
+			// "RFC822.SIZE" SPACE number
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "rfc822.size")) {
+
+				type = RFC822_SIZE;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::number, number);
+
+			// "RFC822" SPACE nstring
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "rfc822")) {
+
+				type = RFC822;
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				VIMAP_PARSER_GET(IMAPParser::nstring, nstring);
+
+			// "BODY" "STRUCTURE" SPACE body
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "bodystructure")) {
+
+				type = BODY_STRUCTURE;
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				VIMAP_PARSER_GET(IMAPParser::body, body);
+
+			// "BODY" section ["<" number ">"] SPACE nstring
+			// "BODY" SPACE body
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "body")) {
+
+				VIMAP_PARSER_TRY_GET(IMAPParser::section, section);
+
+				// "BODY" section ["<" number ">"] SPACE nstring
+				if (section != NULL) {
+
+					type = BODY_SECTION;
+
+					if (VIMAP_PARSER_TRY_CHECK(one_char <'<'> )) {
+						VIMAP_PARSER_GET(IMAPParser::number, number);
+						VIMAP_PARSER_CHECK(one_char <'>'> );
+					}
+
+					VIMAP_PARSER_CHECK(SPACE);
+
+					nstring.reset(parser.getWithArgs <IMAPParser::nstring>(line, &pos, this, BODY_SECTION));
+
+					VIMAP_PARSER_FAIL_UNLESS(nstring);
+
+				// "BODY" SPACE body
+				} else {
+
+					type = BODY;
+
+					VIMAP_PARSER_CHECK(SPACE);
+
+					VIMAP_PARSER_GET(IMAPParser::body, body);
+				}
+
+			// "MODSEQ" SP "(" mod_sequence_value ")"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "modseq")) {
+
+				type = MODSEQ;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_CHECK(one_char <'('> );
+
+				VIMAP_PARSER_GET(IMAPParser::mod_sequence_value, mod_sequence_value);
+
+				VIMAP_PARSER_CHECK(one_char <')'> );
+
+			// "UID" SPACE uniqueid
+			} else {
+
+				type = UID;
+
+				VIMAP_PARSER_CHECK_WITHARG(special_atom, "uid");
+				VIMAP_PARSER_CHECK(SPACE);
+
+				VIMAP_PARSER_GET(IMAPParser::uniqueid, uniqueid);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+			ENVELOPE,
+			FLAGS,
+			INTERNALDATE,
+			RFC822,
+			RFC822_SIZE,
+			RFC822_HEADER,
+			RFC822_TEXT,
+			BODY,
+			BODY_SECTION,
+			BODY_STRUCTURE,
+			UID,
+			MODSEQ
+		};
+
+
+		Type type;
+
+		std::unique_ptr <IMAPParser::date_time> date_time;
+		std::unique_ptr <IMAPParser::number> number;
+		std::unique_ptr <IMAPParser::envelope> envelope;
+		std::unique_ptr <IMAPParser::uniqueid> uniqueid;
+		std::unique_ptr <IMAPParser::nstring> nstring;
+		std::unique_ptr <IMAPParser::xbody> body;
+		std::unique_ptr <IMAPParser::flag_list> flag_list;
+		std::unique_ptr <IMAPParser::section> section;
+		std::unique_ptr <IMAPParser::mod_sequence_value> mod_sequence_value;
+	};
+
+
+	//
+	// msg_att ::= "(" 1#(msg_att_item) ")"
+	//
+
+	DECLARE_COMPONENT(msg_att)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'('> );
+
+			items.push_back(std::move(std::unique_ptr <msg_att_item>(parser.get <msg_att_item>(line, &pos))));
+
+			while (!VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET_PUSHBACK(msg_att_item, items);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <msg_att_item>> items;
+	};
+
+
+	//
+	// message_data ::= nz_number SPACE ("EXPUNGE" /
+	//                  ("FETCH" SPACE msg_att))
+	//
+
+	DECLARE_COMPONENT(message_data)
+
+		message_data()
+			: number(0) {
+
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			scoped_ptr <nz_number> num;
+			VIMAP_PARSER_GET(nz_number, num);
+			number = static_cast <unsigned int>(num->value);
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "expunge")) {
+
+				type = EXPUNGE;
+
+			} else {
+
+				type = FETCH;
+
+				VIMAP_PARSER_CHECK_WITHARG(special_atom, "fetch");
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::msg_att, msg_att);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+			EXPUNGE,
+			FETCH
+		};
+
+
+		Type type;
+		unsigned int number;
+		std::unique_ptr <IMAPParser::msg_att> msg_att;
+	};
+
+
+	//
+	// resp_text_code ::= "ALERT" / "PARSE" /
+	//                    capability-data /
+	//                    "PERMANENTFLAGS" SPACE "(" #(flag / "\*") ")" /
+	//                    "READ-ONLY" / "READ-WRITE" / "TRYCREATE" /
+	//                    "UIDVALIDITY" SPACE nz_number /
+	//                    "UNSEEN" SPACE nz_number /
+	//                    "UIDNEXT" SPACE nz-number /
+	//                    atom [SPACE 1*<any TEXT_CHAR except "]">]
+	//
+	// IMAP Extension for Conditional STORE (RFC-4551):
+	//
+	//   resp-text-code      =/ "HIGHESTMODSEQ" SP mod-sequence-value /
+	//                          "NOMODSEQ" /
+	//                          "MODIFIED" SP set
+	//
+	// IMAP UIDPLUS Extension (RFC-4315):
+	//
+	//   resp-text-code      =/ "APPENDUID" SP nz-number SP append-uid /
+	//                          "COPYUID" SP nz-number SP uid-set SP uid-set /
+	//                          "UIDNOTSTICKY"
+
+	DECLARE_COMPONENT(resp_text_code)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			// "ALERT"
+			if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "alert")) {
+
+				type = ALERT;
+
+			// "PARSE"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "parse")) {
+
+				type = PARSE;
+
+			// capability_data
+			} else if (VIMAP_PARSER_TRY_GET(IMAPParser::capability_data, capability_data)) {
+
+				type = CAPABILITY;
+
+			// "PERMANENTFLAGS" SPACE flag_list
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "permanentflags")) {
+
+				type = PERMANENTFLAGS;
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				VIMAP_PARSER_GET(IMAPParser::flag_list, flag_list);
+
+			// "READ-ONLY"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "read-only")) {
+
+				type = READ_ONLY;
+
+			// "READ-WRITE"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "read-write")) {
+
+				type = READ_WRITE;
+
+			// "TRYCREATE"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "trycreate")) {
+
+				type = TRYCREATE;
+
+			// "UIDVALIDITY" SPACE nz_number
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "uidvalidity")) {
+
+				type = UIDVALIDITY;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::nz_number, nz_number);
+
+			// "UIDNEXT" SPACE nz_number
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "uidnext")) {
+
+				type = UIDNEXT;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::nz_number, nz_number);
+
+			// "UNSEEN" SPACE nz_number
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "unseen")) {
+
+				type = UNSEEN;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::nz_number, nz_number);
+
+			// "HIGHESTMODSEQ" SP mod-sequence-value
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "highestmodseq")) {
+
+				type = HIGHESTMODSEQ;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::mod_sequence_value, mod_sequence_value);
+
+			// "NOMODSEQ"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "nomodseq")) {
+
+				type = NOMODSEQ;
+
+			// "MODIFIED" SP sequence-set
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "modified")) {
+
+				type = MODIFIED;
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				VIMAP_PARSER_GET(IMAPParser::sequence_set, sequence_set);
+
+			// "APPENDUID" SP nz-number SP append-uid
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "appenduid")) {
+
+				type = APPENDUID;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::nz_number, nz_number);
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::uid_set, uid_set);
+
+			// "COPYUID" SP nz-number SP uid-set SP uid-set
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "copyuid")) {
+
+				type = COPYUID;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::nz_number, nz_number);
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::uid_set, uid_set);
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::uid_set, uid_set2);
+
+			// "UIDNOTSTICKY"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "uidnotsticky")) {
+
+				type = UIDNOTSTICKY;
+
+			// atom [SPACE 1*<any TEXT_CHAR except "]">]
+			} else {
+
+				type = OTHER;
+
+				VIMAP_PARSER_GET(IMAPParser::atom, atom);
+
+				if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+					VIMAP_PARSER_GET(text_except <']'> , text);
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+			// Extensions
+			HIGHESTMODSEQ,
+			NOMODSEQ,
+			MODIFIED,
+			APPENDUID,
+			COPYUID,
+			UIDNOTSTICKY,
+
+			// Standard IMAP
+			ALERT,
+			PARSE,
+			CAPABILITY,
+			PERMANENTFLAGS,
+			READ_ONLY,
+			READ_WRITE,
+			TRYCREATE,
+			UIDVALIDITY,
+			UIDNEXT,
+			UNSEEN,
+			OTHER
+		};
+
+
+		Type type;
+
+		std::unique_ptr <IMAPParser::nz_number> nz_number;
+		std::unique_ptr <IMAPParser::atom> atom;
+		std::unique_ptr <IMAPParser::flag_list> flag_list;
+		std::unique_ptr <IMAPParser::text> text;
+		std::unique_ptr <IMAPParser::mod_sequence_value> mod_sequence_value;
+		std::unique_ptr <IMAPParser::sequence_set> sequence_set;
+		std::unique_ptr <IMAPParser::capability_data> capability_data;
+		std::unique_ptr <IMAPParser::uid_set> uid_set;
+		std::unique_ptr <IMAPParser::uid_set> uid_set2;
+	};
+
+
+	//
+	// resp_text ::= ["[" resp_text_code "]" SPACE] (text_mime2 / text)
+	//               ;; text SHOULD NOT begin with "[" or "="
+
+	DECLARE_COMPONENT(resp_text)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <'['> )) {
+
+				VIMAP_PARSER_GET(IMAPParser::resp_text_code, resp_text_code);
+
+				VIMAP_PARSER_CHECK(one_char <']'> );
+				VIMAP_PARSER_TRY_CHECK(SPACE);
+			}
+
+			std::unique_ptr <text_mime2> text1;
+			VIMAP_PARSER_TRY_GET(text_mime2, text1);
+
+			if (text1.get()) {
+
+				text = text1->value;
+
+			} else {
+
+				std::unique_ptr <IMAPParser::text> text2;
+				VIMAP_PARSER_TRY_GET(IMAPParser::text, text2);
+
+				if (text2.get()) {
+					text = text2->value;
+				} else {
+					// Empty response text
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::resp_text_code> resp_text_code;
+		string text;
+	};
+
+
+	//
+	// continue_req   ::= "+" SPACE (resp_text / base64)
+	//
+
+	DECLARE_COMPONENT(continue_req)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'+'> );
+
+			if (!parser.isStrict()) {
+
+				// Some servers do not send SPACE when response text is empty
+				if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+					VIMAP_PARSER_GET(IMAPParser::resp_text, resp_text);
+				} else {
+					resp_text.reset(new IMAPParser::resp_text());  // empty
+				}
+
+			} else {
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				VIMAP_PARSER_GET(IMAPParser::resp_text, resp_text);
+			}
+
+			VIMAP_PARSER_CHECK(CRLF);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::resp_text> resp_text;
+	};
+
+
+	//
+	// resp_cond_state ::= ("OK" / "NO" / "BAD") SPACE resp_text
+	//                     ;; Status condition
+	//
+
+	DECLARE_COMPONENT(resp_cond_state)
+
+		resp_cond_state()
+			: status(BAD) {
+
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "ok")) {
+				status = OK;
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "no")) {
+				status = NO;
+			} else {
+				VIMAP_PARSER_CHECK_WITHARG(special_atom, "bad");
+				status = BAD;
+			}
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::resp_text, resp_text);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Status {
+			OK,
+			NO,
+			BAD
+		};
+
+
+		std::unique_ptr <IMAPParser::resp_text> resp_text;
+		Status status;
+	};
+
+
+	//
+	// resp_cond_bye ::= "BYE" SPACE resp_text
+	//
+
+	DECLARE_COMPONENT(resp_cond_bye)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK_WITHARG(special_atom, "bye");
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::resp_text, resp_text);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::resp_text> resp_text;
+	};
+
+
+	//
+	// resp_cond_auth  ::= ("OK" / "PREAUTH") SPACE resp_text
+	//                     ;; Authentication condition
+	//
+
+	DECLARE_COMPONENT(resp_cond_auth)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "ok")) {
+				condition = OK;
+			} else {
+				VIMAP_PARSER_CHECK_WITHARG(special_atom, "preauth");
+				condition = PREAUTH;
+			}
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::resp_text, resp_text);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Condition {
+			OK,
+			PREAUTH
+		};
+
+
+		Condition condition;
+		std::unique_ptr <IMAPParser::resp_text> resp_text;
+	};
+
+
+	//
+	// mailbox_data ::= "FLAGS" SPACE mailbox_flag_list /
+	//                  "LIST" SPACE mailbox_list /
+	//                  "LSUB" SPACE mailbox_list /
+	//                  "MAILBOX" SPACE text /
+	//                  "SEARCH" [SPACE 1#nz_number] /
+	//                  "STATUS" SPACE mailbox SPACE
+	//                    "(" [status-att-list] ")" /
+	//                  number SPACE "EXISTS" /
+	//                  number SPACE "RECENT"
+	//
+
+	DECLARE_COMPONENT(mailbox_data)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_GET(IMAPParser::number, number)) {
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "exists")) {
+					type = EXISTS;
+				} else {
+					VIMAP_PARSER_CHECK_WITHARG(special_atom, "recent");
+					type = RECENT;
+				}
+
+			} else {
+
+				// "FLAGS" SPACE mailbox_flag_list
+				if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "flags")) {
+
+					VIMAP_PARSER_CHECK(SPACE);
+
+					VIMAP_PARSER_GET(IMAPParser::mailbox_flag_list, mailbox_flag_list);
+
+					type = FLAGS;
+
+				// "LIST" SPACE mailbox_list
+				} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "list")) {
+
+					VIMAP_PARSER_CHECK(SPACE);
+
+					VIMAP_PARSER_GET(IMAPParser::mailbox_list, mailbox_list);
+
+					type = LIST;
+
+				// "LSUB" SPACE mailbox_list
+				} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "lsub")) {
+
+					VIMAP_PARSER_CHECK(SPACE);
+
+					VIMAP_PARSER_GET(IMAPParser::mailbox_list, mailbox_list);
+
+					type = LSUB;
+
+				// "MAILBOX" SPACE text
+				} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "mailbox")) {
+
+					VIMAP_PARSER_CHECK(SPACE);
+
+					VIMAP_PARSER_GET(IMAPParser::text, text);
+
+					type = MAILBOX;
+
+				// "SEARCH" [SPACE 1#nz_number]
+				} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "search")) {
+
+					if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+
+						VIMAP_PARSER_GET_PUSHBACK(nz_number, search_nz_number_list);
+
+						while (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+							VIMAP_PARSER_GET_PUSHBACK(nz_number, search_nz_number_list);
+						}
+					}
+
+					type = SEARCH;
+
+				// "STATUS" SPACE mailbox SPACE
+				// "(" [status_att_list] ")"
+				} else {
+
+					VIMAP_PARSER_CHECK_WITHARG(special_atom, "status");
+					VIMAP_PARSER_CHECK(SPACE);
+
+					VIMAP_PARSER_GET(IMAPParser::mailbox, mailbox);
+
+					VIMAP_PARSER_CHECK(SPACE);
+
+					VIMAP_PARSER_CHECK(one_char <'('> );
+					VIMAP_PARSER_TRY_GET(IMAPParser::status_att_list, status_att_list);
+					VIMAP_PARSER_CHECK(one_char <')'> );
+
+					type = STATUS;
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+
+			FLAGS,
+			LIST,
+			LSUB,
+			MAILBOX,
+			SEARCH,
+			STATUS,
+			EXISTS,
+			RECENT
+		};
+
+
+		Type type;
+
+		std::unique_ptr <IMAPParser::number> number;
+		std::unique_ptr <IMAPParser::mailbox_flag_list> mailbox_flag_list;
+		std::unique_ptr <IMAPParser::mailbox_list> mailbox_list;
+		std::unique_ptr <IMAPParser::mailbox> mailbox;
+		std::unique_ptr <IMAPParser::text> text;
+		std::vector <std::unique_ptr <nz_number>> search_nz_number_list;
+		std::unique_ptr <IMAPParser::status_att_list> status_att_list;
+	};
+
+
+	//
+	// response_data  ::= "*" SPACE (resp_cond_state / resp_cond_bye /
+	//                    mailbox_data / message_data / capability_data) CRLF
+	//
+
+	DECLARE_COMPONENT(response_data)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'*'> );
+			VIMAP_PARSER_CHECK(SPACE);
+
+			if (!VIMAP_PARSER_TRY_GET(IMAPParser::resp_cond_state, resp_cond_state)) {
+				if (!VIMAP_PARSER_TRY_GET(IMAPParser::resp_cond_bye, resp_cond_bye)) {
+					if (!VIMAP_PARSER_TRY_GET(IMAPParser::mailbox_data, mailbox_data)) {
+						if (!VIMAP_PARSER_TRY_GET(IMAPParser::message_data, message_data)) {
+							VIMAP_PARSER_GET(IMAPParser::capability_data, capability_data);
+						}
+					}
+				}
+			}
+
+			if (!parser.isStrict()) {
+
+				// Allow SPACEs at end of line
+				while (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+					;
+				}
+			}
+
+			VIMAP_PARSER_CHECK(CRLF);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::resp_cond_state> resp_cond_state;
+		std::unique_ptr <IMAPParser::resp_cond_bye> resp_cond_bye;
+		std::unique_ptr <IMAPParser::mailbox_data> mailbox_data;
+		std::unique_ptr <IMAPParser::message_data> message_data;
+		std::unique_ptr <IMAPParser::capability_data> capability_data;
+	};
+
+
+	DECLARE_COMPONENT(continue_req_or_response_data)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (!VIMAP_PARSER_TRY_GET(IMAPParser::continue_req, continue_req)) {
+				VIMAP_PARSER_GET(IMAPParser::response_data, response_data);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::continue_req> continue_req;
+		std::unique_ptr <IMAPParser::response_data> response_data;
+	};
+
+
+	//
+	// response_fatal ::= "*" SPACE resp_cond_bye CRLF
+	//                    ;; Server closes connection immediately
+	//
+
+	DECLARE_COMPONENT(response_fatal)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'*'> );
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::resp_cond_bye, resp_cond_bye);
+
+			if (!parser.isStrict()) {
+
+				// Allow SPACEs at end of line
+				while (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+					;
+				}
+			}
+
+			VIMAP_PARSER_CHECK(CRLF);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::resp_cond_bye> resp_cond_bye;
+	};
+
+
+	//
+	// response_tagged ::= tag SPACE resp_cond_state CRLF
+	//
+
+	DECLARE_COMPONENT(response_tagged)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::xtag, tag);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::resp_cond_state, resp_cond_state);
+
+			if (!parser.isStrict()) {
+
+				// Allow SPACEs at end of line
+				while (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+					;
+				}
+			}
+
+			VIMAP_PARSER_CHECK(CRLF);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::xtag> tag;
+		std::unique_ptr <IMAPParser::resp_cond_state> resp_cond_state;
+	};
+
+
+	//
+	// response_done ::= response_tagged / response_fatal
+	//
+
+	DECLARE_COMPONENT(response_done)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (!VIMAP_PARSER_TRY_GET(IMAPParser::response_tagged, response_tagged)) {
+				VIMAP_PARSER_GET(IMAPParser::response_fatal, response_fatal);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::response_tagged> response_tagged;
+		std::unique_ptr <IMAPParser::response_fatal> response_fatal;
+	};
+
+
+	//
+	// response ::= *(continue_req / response_data) response_done
+	//
+
+	DECLARE_COMPONENT(response)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+			string curLine = line;
+			bool partial = false;  // partial response
+
+			IMAPParser::continue_req_or_response_data* resp = NULL;
+
+			while ((resp = parser.get <IMAPParser::continue_req_or_response_data>(curLine, &pos))) {
+
+				continue_req_or_response_data.push_back(
+					std::move(
+						std::unique_ptr <IMAPParser::continue_req_or_response_data>(resp)
+					)
+				);
+
+				// Partial response (continue_req)
+				if (resp->continue_req) {
+					partial = true;
+					break;
+				}
+
+				// We have read a CRLF, read another line
+				curLine = parser.readLine();
+				pos = 0;
+			}
+
+			if (!partial) {
+				response_done.reset(parser.get <IMAPParser::response_done>(curLine, &pos));
+				VIMAP_PARSER_FAIL_UNLESS(response_done);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		bool isBad() const {
+
+			if (!response_done) {  // incomplete (partial) response
+				return true;
+			}
+
+			if (response_done->response_fatal) {
+				return true;
+			}
+
+			if (response_done->response_tagged->resp_cond_state->status == IMAPParser::resp_cond_state::BAD) {
+
+				return true;
+			}
+
+			return false;
+		}
+
+		void setErrorLog(const string& errorLog) {
+
+			m_errorLog = errorLog;
+		}
+
+		const string& getErrorLog() const {
+
+			return m_errorLog;
+		}
+
+
+		std::vector <std::unique_ptr <IMAPParser::continue_req_or_response_data>> continue_req_or_response_data;
+		std::unique_ptr <IMAPParser::response_done> response_done;
+
+	private:
+
+		string m_errorLog;
+	};
+
+
+	//
+	// greeting ::= "*" SPACE (resp_cond_auth / resp_cond_bye) CRLF
+	//
+
+	DECLARE_COMPONENT(greeting)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'*'> );
+			VIMAP_PARSER_CHECK(SPACE);
+
+			if (!VIMAP_PARSER_TRY_GET(IMAPParser::resp_cond_auth, resp_cond_auth)) {
+				VIMAP_PARSER_GET(IMAPParser::resp_cond_bye, resp_cond_bye);
+			}
+
+			VIMAP_PARSER_CHECK(CRLF);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+		void setErrorLog(const string& errorLog) {
+
+			m_errorLog = errorLog;
+		}
+
+		const string& getErrorLog() const {
+
+			return m_errorLog;
+		}
+
+
+		std::unique_ptr <IMAPParser::resp_cond_auth> resp_cond_auth;
+		std::unique_ptr <IMAPParser::resp_cond_bye> resp_cond_bye;
+
+	private:
+
+		string m_errorLog;
+	};
+
+
+
+	//
+	// The main functions used to parse a response
+	//
+
+	response* readResponse(const IMAPTag& tag, literalHandler* lh = NULL) {
+
+		while (true) {
+
+			auto it = m_pendingResponses.find(std::string(tag));
+
+			if (it != m_pendingResponses.end()) {
+				auto* resp = it->second;
+				m_pendingResponses.erase(it);
+				return resp;
+			}
+
+			size_t pos = 0;
+			string line = readLine();
+
+			m_literalHandler = lh;
+			response* resp = get <response>(line, &pos);
+			m_literalHandler = NULL;
+
+			if (!resp) {
+				throw exceptions::invalid_response("", m_errorResponseLine);
+			}
+
+			resp->setErrorLog(lastLine());
+
+			// If there is a continue_req, return the response immediately
+			for (auto &respData : resp->continue_req_or_response_data) {
+				if (respData->continue_req) {
+					return resp;
+				}
+			}
+
+			// Else, return response if the tag is the one we expect
+			if (resp->response_done && resp->response_done->response_tagged &&
+			    resp->response_done->response_tagged->tag) {
+
+				if (tag == resp->response_done->response_tagged->tag->tagString) {
+					return resp;
+				} else {
+					// Not our response tag, cache it for later
+					m_pendingResponses[resp->response_done->response_tagged->tag->tagString] = resp;
+				}
+			} else {
+				// Untagged response
+				return resp;
+			}
+		}
+	}
+
+
+	greeting* readGreeting() {
+
+		size_t pos = 0;
+		string line = readLine();
+
+		greeting* greet = get <greeting>(line, &pos);
+
+		if (!greet) {
+			throw exceptions::invalid_response("", m_errorResponseLine);
+		}
+
+		greet->setErrorLog(lastLine());
+
+		return greet;
+	}
+
+
+	/** Parse a token and advance.
+	  * If the token has been parsed successfully, a raw pointer to it
+	  * will be returned. The caller is responsible to free the memory.
+	  *
+	  * @param TYPE token type (class)
+	  * @param line line which is currently being parsed
+	  * @param currentPos current position in the line (will be updated
+	  * when the function returns)
+	  * @return a raw pointer to the parsed token, or NULL otherwise
+	  */
+	template <class TYPE>
+	TYPE* get(string& line, size_t* currentPos) {
+
+		component* resp = new TYPE;
+		return internalGet <TYPE>(resp, line, currentPos);
+	}
+
+	/** Parse a token which takes 2 arguments and advance.
+	  * If the token has been parsed successfully, a raw pointer to it
+	  * will be returned. The caller is responsible to free the memory.
+	  *
+	  * @param TYPE token type (class)
+	  * @param ARG1_TYPE type of argument #1 (class)
+	  * @param ARG2_TYPE type of argument #2 (class)
+	  * @param line line which is currently being parsed
+	  * @param currentPos current position in the line (will be updated
+	  * when the function returns)
+	  * @param arg1 value of argument 1 to be passed to the token
+	  * @param arg2 value of argument 2 to be passed to the token
+	  * @return a raw pointer to the parsed token, or NULL otherwise
+	  */
+	template <class TYPE, class ARG1_TYPE, class ARG2_TYPE>
+	TYPE* getWithArgs(string& line, size_t* currentPos, ARG1_TYPE arg1, ARG2_TYPE arg2) {
+
+		component* resp = new TYPE(arg1, arg2);
+		return internalGet <TYPE>(resp, line, currentPos);
+	}
+
+private:
+
+	template <class TYPE>
+	TYPE* internalGet(component* resp, string& line, size_t* currentPos) {
+
+		const size_t oldPos = *currentPos;
+
+		if (!resp->parse(*this, line, currentPos)) {
+
+			*currentPos = oldPos;
+
+			delete resp;
+
+			return NULL;
+		}
+
+		return static_cast <TYPE*>(resp);
+	}
+
+	const string lastLine() const {
+
+		// Remove blanks and new lines at the end of the line.
+		string line(m_lastLine);
+
+		string::const_iterator it = line.end();
+		int count = 0;
+
+		while (it != line.begin()) {
+
+			const unsigned char c = *(it - 1);
+
+			if (!(c == ' ' || c == '\t' || c == '\n' || c == '\r')) {
+				break;
+			}
+
+			++count;
+			--it;
+		}
+
+		line.resize(line.length() - count);
+
+		return (line);
+	}
+
+public:
+
+	/** Check for a token and advance.
+	  *
+	  * @param TYPE token type (class)
+	  * @param line line which is currently being parsed
+	  * @param currentPos current position in the line (will be updated
+	  * when the function returns)
+	  * @return true if the token has been parsed, or false otherwise
+	  */
+	template <class TYPE>
+	bool check(string& line, size_t* currentPos) {
+
+		const size_t oldPos = *currentPos;
+
+		TYPE term;
+
+		if (!term.parse(*this, line, currentPos)) {
+			*currentPos = oldPos;
+			return false;
+		} else {
+			return true;
+		}
+	}
+
+	/** Check for a token which takes an argument and advance.
+	  *
+	  * @param TYPE token type (class)
+	  * @param ARG_TYPE argument type (class)
+	  * @param line line which is currently being parsed
+	  * @param currentPos current position in the line (will be updated
+	  * when the function returns)
+	  * @param arg argument to be passed to the token
+	  * @return true if the token has been parsed, or false otherwise
+	  */
+	template <class TYPE, class ARG_TYPE>
+	bool checkWithArg(string& line, size_t* currentPos, const ARG_TYPE arg) {
+
+		const size_t oldPos = *currentPos;
+
+		TYPE term(arg);
+
+		if (!term.parse(*this, line, currentPos)) {
+			*currentPos = oldPos;
+			return false;
+		} else {
+			return true;
+		}
+	}
+
+
+private:
+
+	weak_ptr <socket> m_socket;
+	shared_ptr <tracer> m_tracer;
+
+	utility::progressListener* m_progress;
+
+	bool m_strict;
+
+	literalHandler* m_literalHandler;
+
+	weak_ptr <timeoutHandler> m_timeoutHandler;
+
+
+	string m_buffer;
+
+	string m_lastLine;
+	string m_errorResponseLine;
+
+	std::map <std::string, response*> m_pendingResponses;
+
+public:
+
+	/** Read a line from the input buffer. The function blocks until a
+	  * complete line is read from the buffer. Position in input buffer
+	  * will be updated.
+	  *
+	  * @return next line
+	  */
+	const string readLine() {
+
+		size_t pos;
+
+		while ((pos = m_buffer.find('\n')) == string::npos) {
+			read();
+		}
+
+		string line;
+		line.resize(pos + 1);
+		std::copy(m_buffer.begin(), m_buffer.begin() + pos + 1, line.begin());
+
+		m_buffer.erase(m_buffer.begin(), m_buffer.begin() + pos + 1);
+
+		m_lastLine = line;
+
+#if DEBUG_RESPONSE
+		std::cout << std::endl << "Read line:" << std::endl << line << std::endl;
+#endif
+
+		if (m_tracer) {
+			string::size_type len = line.length();
+			while (len != 0 && (line[len - 1] == '\r' || line[len - 1] == '\n')) --len;
+			m_tracer->traceReceive(line.substr(0, len));
+		}
+
+		return (line);
+	}
+
+	/** Fill in the input buffer with data available from the socket stream.
+	  * The function blocks until some data is available.
+	  */
+	void read() {
+
+		string receiveBuffer;
+
+		shared_ptr <timeoutHandler> toh = m_timeoutHandler.lock();
+		shared_ptr <socket> sok = m_socket.lock();
+
+		if (toh) {
+			toh->resetTimeOut();
+		}
+
+		while (receiveBuffer.empty()) {
+
+			// Check whether the time-out delay is elapsed
+			if (toh && toh->isTimeOut()) {
+				if (!toh->handleTimeOut()) {
+					throw exceptions::operation_timed_out();
+				}
+			}
+
+			// We have received data: reset the time-out counter
+			sok->receive(receiveBuffer);
+
+			if (receiveBuffer.empty()) {   // buffer is empty
+
+				if (sok->getStatus() & socket::STATUS_WANT_WRITE) {
+					sok->waitForWrite();
+				} else {
+					sok->waitForRead();
+				}
+
+				continue;
+			}
+
+			// We have received data ...
+			if (toh) {
+				toh->resetTimeOut();
+			}
+		}
+
+		m_buffer += receiveBuffer;
+	}
+
+
+	void readLiteral(literalHandler::target& buffer, size_t count) {
+
+		size_t len = 0;
+		string receiveBuffer;
+
+		shared_ptr <timeoutHandler> toh = m_timeoutHandler.lock();
+		shared_ptr <socket> sok = m_socket.lock();
+
+		if (m_progress) {
+			m_progress->start(count);
+		}
+
+		if (toh) {
+			toh->resetTimeOut();
+		}
+
+		if (!m_buffer.empty()) {
+
+			if (m_buffer.length() > count) {
+
+				buffer.putData(string(m_buffer.begin(), m_buffer.begin() + count));
+				m_buffer.erase(m_buffer.begin(), m_buffer.begin() + count);
+				len = count;
+
+			} else {
+
+				len += m_buffer.length();
+				buffer.putData(m_buffer);
+				m_buffer.clear();
+			}
+		}
+
+		while (len < count) {
+
+			// Check whether the time-out delay is elapsed
+			if (toh && toh->isTimeOut()) {
+
+				if (!toh->handleTimeOut()) {
+					throw exceptions::operation_timed_out();
+				}
+
+				toh->resetTimeOut();
+			}
+
+			// Receive data from the socket
+			sok->receive(receiveBuffer);
+
+			if (receiveBuffer.empty()) {  // buffer is empty
+
+				if (sok->getStatus() & socket::STATUS_WANT_WRITE) {
+					sok->waitForWrite();
+				} else {
+					sok->waitForRead();
+				}
+
+				continue;
+			}
+
+			// We have received data: reset the time-out counter
+			if (toh) {
+				toh->resetTimeOut();
+			}
+
+			if (len + receiveBuffer.length() > count) {
+
+				const size_t remaining = count - len;
+
+				// Get the needed amount of data
+				buffer.putData(string(receiveBuffer.begin(), receiveBuffer.begin() + remaining));
+
+				// Put the remaining data into the internal response buffer
+				receiveBuffer.erase(receiveBuffer.begin(), receiveBuffer.begin() + remaining);
+				m_buffer += receiveBuffer;
+
+				len = count;
+
+			} else {
+
+				buffer.putData(receiveBuffer);
+				len += receiveBuffer.length();
+			}
+
+			// Notify progress
+			if (m_progress) {
+				m_progress->progress(len, count);
+			}
+		}
+
+		if (m_tracer) {
+			m_tracer->traceReceiveBytes(count);
+		}
+
+		if (m_progress) {
+			m_progress->stop(count);
+		}
+	}
+};
+
+
+} // imap
+} // net
+} // vmime
+
+
+#undef VIMAP_PARSER_FAIL
+#undef VIMAP_PARSER_FAIL_UNLESS
+#undef VIMAP_PARSER_CHECK
+#undef VIMAP_PARSER_TRY_CHECK
+#undef VIMAP_PARSER_GET
+#undef VIMAP_PARSER_GET
+#undef VIMAP_PARSER_TRY_GET
+#undef VIMAP_PARSER_TRY_GET
+#undef VIMAP_PARSER_GET_PUSHBACK
+#undef VIMAP_PARSER_CHECK_WITHARG
+#undef VIMAP_PARSER_TRY_CHECK_WITHARG
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+#endif // VMIME_NET_IMAP_IMAPPARSER_HPP_INCLUDED