parser.h

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// parser.h


#ifndef _PARSER_H
#  define _PARSER_H

#  include "misc.h"
#  include "stringtool.h"
#  include <vector>


///
class Token
{
public:
	///
	enum Type {
		Type_string,				///
		Type_number,				///
		Type_regexp,				///
		Type_openParen,				///
		Type_closeParen,				///
		Type_comma,					///
	};

private:
	u_char m_type;				///
	bool m_isValueQuoted;				///
	int m_numericValue;				///
	tstringi m_stringValue;			///
	long m_data;					///

public:
	///
	Token(const Token &i_token);
	///
	Token(int i_value, const tstringi &i_display);
	///
	Token(const tstringi &i_value, bool i_isValueQuoted,
		  bool i_isRegexp = false);
	///
	Token(Type i_type);

	/// is the value quoted ?
	bool isQuoted() const {
		return m_isValueQuoted;
	}

	/// value type
	Type getType() const {
		return static_cast<Type>(m_type);
	}
	///
	bool isString() const {
		return m_type == Type_string;
	}
	///
	bool isNumber() const {
		return m_type == Type_number;
	}
	///
	bool isRegexp() const {
		return m_type == Type_regexp;
	}
	///
	bool isOpenParen() const {
		return m_type == Type_openParen;
	}
	///
	bool isCloseParen() const {
		return m_type == Type_closeParen;
	}
	///
	bool isComma() const {
		return m_type == Type_comma;
	}

	/// get numeric value
	int getNumber() const;

	/// get string value
	tstringi getString() const;

	/// get regexp value
	tstringi getRegexp() const;

	/// get data
	long getData() const {
		return m_data;
	}
	///
	void setData(long i_data) {
		m_data = i_data;
	}

	/// case insensitive equal
	bool operator==(const tstringi &i_str) const {
		return *this == i_str.c_str();
	}
	///
	bool operator==(const _TCHAR *i_str) const;
	///
	bool operator!=(const tstringi &i_str) const {
		return *this != i_str.c_str();
	}
	///
	bool operator!=(const _TCHAR *i_str) const {
		return !(*this == i_str);
	}

	/** paren equal
	    @param i_c '<code>(</code>' or '<code>)</code>' */
	bool operator==(const _TCHAR i_c) const;
	/** paren equal
	    @param i_c '<code>(</code>' or '<code>)</code>' */
	bool operator!=(const _TCHAR i_c) const {
		return !(*this == i_c);
	}

	/// add string
	void add(const tstringi &i_str);

	/// stream output
	friend tostream &operator<<(tostream &i_ost, const Token &i_token);
};


///
class Parser
{
public:
	///
	typedef std::vector<Token> Tokens;

private:
	///
	typedef std::vector<tstringi> Prefixes;

private:
	size_t m_lineNumber;				/// current line number
	const Prefixes *m_prefixes;			/** string that may be prefix
                                                    of a token */

	size_t m_internalLineNumber;			/// next line number
	const _TCHAR *m_ptr;				/// read pointer
	const _TCHAR *m_end;				/// end pointer

private:
	/// get a line
	bool getLine(tstringi *o_line);

public:
	///
	Parser(const _TCHAR *i_str, size_t i_length);

	/** get a parsed line.  if no more lines exist, returns false */
	bool getLine(Tokens *o_tokens);

	/// get current line number
	size_t getLineNumber() const {
		return m_lineNumber;
	}

	/** set string that may be prefix of a token.  prefix_ is not
	    copied, so it must be preserved after setPrefix() */
	void setPrefixes(const Prefixes *m_prefixes);
};


#endif // !_PARSER_H