[ceph.git] / ceph / src / boost / libs / wave / include / boost / wave / cpplexer / cpplexer_exceptions.hpp

/*=============================================================================
    Boost.Wave: A Standard compliant C++ preprocessor library

    http://www.boost.org/

    Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost
    Software License, Version 1.0. (See accompanying file
    LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/

#if !defined(CPPLEXER_EXCEPTIONS_HPP_1A09DE1A_6D1F_4091_AF7F_5F13AB0D31AB_INCLUDED)
#define CPPLEXER_EXCEPTIONS_HPP_1A09DE1A_6D1F_4091_AF7F_5F13AB0D31AB_INCLUDED

#include <exception>
#include <string>

#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/throw_exception.hpp>

#include <boost/wave/wave_config.hpp>

// this must occur after all of the includes and before any code appears
#ifdef BOOST_HAS_ABI_HEADERS
#include BOOST_ABI_PREFIX
#endif

///////////////////////////////////////////////////////////////////////////////
// helper macro for throwing exceptions
#if !defined(BOOST_WAVE_LEXER_THROW)
#ifdef BOOST_NO_STRINGSTREAM
#include <strstream>
#define BOOST_WAVE_LEXER_THROW(cls, code, msg, line, column, name)            \
    {                                                                         \
    using namespace boost::wave;                                              \
    std::strstream stream;                                                    \
        stream << cls::severity_text(cls::code) << ": "                       \
        << cls::error_text(cls::code);                                        \
    if ((msg)[0] != 0) stream << ": " << (msg);                               \
    stream << std::ends;                                                      \
    std::string throwmsg = stream.str(); stream.freeze(false);                \
    boost::throw_exception(cls(throwmsg.c_str(), cls::code, line, column,     \
        name));                                                               \
    }                                                                         \
    /**/
#else
#include <sstream>
#define BOOST_WAVE_LEXER_THROW(cls, code, msg, line, column, name)            \
    {                                                                         \
    using namespace boost::wave;                                              \
    std::stringstream stream;                                                 \
        stream << cls::severity_text(cls::code) << ": "                       \
        << cls::error_text(cls::code);                                        \
    if ((msg)[0] != 0) stream << ": " << (msg);                               \
    stream << std::ends;                                                      \
    boost::throw_exception(cls(stream.str().c_str(), cls::code, line, column, \
        name));                                                               \
    }                                                                         \
    /**/
#endif // BOOST_NO_STRINGSTREAM
#endif // BOOST_WAVE_LEXER_THROW

#if !defined(BOOST_WAVE_LEXER_THROW_VAR)
#ifdef BOOST_NO_STRINGSTREAM
#include <strstream>
#define BOOST_WAVE_LEXER_THROW_VAR(cls, codearg, msg, line, column, name)     \
    {                                                                         \
    using namespace boost::wave;                                              \
    cls::error_code code = static_cast<cls::error_code>(codearg);             \
    std::strstream stream;                                                    \
        stream << cls::severity_text(code) << ": "                            \
        << cls::error_text(code);                                             \
    if ((msg)[0] != 0) stream << ": " << (msg);                               \
    stream << std::ends;                                                      \
    std::string throwmsg = stream.str(); stream.freeze(false);                \
    boost::throw_exception(cls(throwmsg.c_str(), code, line, column,          \
        name));                                                               \
    }                                                                         \
    /**/
#else
#include <sstream>
#define BOOST_WAVE_LEXER_THROW_VAR(cls, codearg, msg, line, column, name)     \
    {                                                                         \
    using namespace boost::wave;                                              \
    cls::error_code code = static_cast<cls::error_code>(codearg);             \
    std::stringstream stream;                                                 \
        stream << cls::severity_text(code) << ": "                            \
        << cls::error_text(code);                                             \
    if ((msg)[0] != 0) stream << ": " << (msg);                               \
    stream << std::ends;                                                      \
    boost::throw_exception(cls(stream.str().c_str(), code, line, column,      \
        name));                                                               \
    }                                                                         \
    /**/
#endif // BOOST_NO_STRINGSTREAM
#endif // BOOST_WAVE_LEXER_THROW

///////////////////////////////////////////////////////////////////////////////
namespace boost {
namespace wave {
namespace cpplexer {

///////////////////////////////////////////////////////////////////////////////
// exception severity
namespace util {

    enum severity {
        severity_remark = 0,
        severity_warning,
        severity_error,
        severity_fatal
    };

    inline char const *
    get_severity(severity level)
    {
        static char const *severity_text[] =
        {
            "remark",           // severity_remark
            "warning",          // severity_warning
            "error",            // severity_error
            "fatal error"       // severity_fatal
        };
        BOOST_ASSERT(severity_remark <= level && level <= severity_fatal);
        return severity_text[level];
    }
}

///////////////////////////////////////////////////////////////////////////////
//  cpplexer_exception, the base class for all specific C++ lexer exceptions
class BOOST_SYMBOL_VISIBLE cpplexer_exception
:   public std::exception
{
public:
    cpplexer_exception(std::size_t line_, std::size_t column_, char const *filename_) throw()
    :   line(line_), column(column_)
    {
        unsigned int off = 0;
        while (off < sizeof(filename)-1 && *filename_)
            filename[off++] = *filename_++;
        filename[off] = 0;
    }
    ~cpplexer_exception() throw() {}

    virtual char const *what() const throw() = 0;   // to be overloaded
    virtual char const *description() const throw() = 0;
    virtual int get_errorcode() const throw() = 0;
    virtual int get_severity() const throw() = 0;
    virtual bool is_recoverable() const throw() = 0;

    std::size_t line_no() const throw() { return line; }
    std::size_t column_no() const throw() { return column; }
    char const *file_name() const throw() { return filename; }

protected:
    char filename[512];
    std::size_t line;
    std::size_t column;
};

///////////////////////////////////////////////////////////////////////////////
// lexing_exception error
class BOOST_SYMBOL_VISIBLE lexing_exception :
    public cpplexer_exception
{
public:
    enum error_code {
        unexpected_error = 0,
        universal_char_invalid = 1,
        universal_char_base_charset = 2,
        universal_char_not_allowed = 3,
        invalid_long_long_literal = 4,
        generic_lexing_error = 5,
        generic_lexing_warning = 6
    };

    lexing_exception(char const *what_, error_code code, std::size_t line_,
        std::size_t column_, char const *filename_) throw()
    :   cpplexer_exception(line_, column_, filename_),
        level(severity_level(code)), code(code)
    {
        unsigned int off = 0;
        while (off < sizeof(buffer)-1 && *what_)
            buffer[off++] = *what_++;
        buffer[off] = 0;
    }
    ~lexing_exception() throw() {}

    virtual char const *what() const throw()
    {
        return "boost::wave::lexing_exception";
    }
    virtual char const *description() const throw()
    {
        return buffer;
    }
    virtual int get_severity() const throw()
    {
        return level;
    }
    virtual int get_errorcode() const throw()
    {
        return code;
    }
    virtual bool is_recoverable() const throw()
    {
        switch (get_errorcode()) {
        case lexing_exception::universal_char_invalid:
        case lexing_exception::universal_char_base_charset:
        case lexing_exception::universal_char_not_allowed:
        case lexing_exception::invalid_long_long_literal:
        case lexing_exception::generic_lexing_warning:
        case lexing_exception::generic_lexing_error:
            return true;    // for now allow all exceptions to be recoverable

        case lexing_exception::unexpected_error:
        default:
            break;
        }
        return false;
    }

    static char const *error_text(int code)
    {
    // error texts in this array must appear in the same order as the items in
    // the error enum above
        static char const *preprocess_exception_errors[] = {
            "unexpected error (should not happen)",     // unexpected_error
            "universal character name specifies an invalid character",  // universal_char_invalid
            "a universal character name cannot designate a character in the "
                "basic character set",                  // universal_char_base_charset
            "this universal character is not allowed in an identifier", // universal_char_not_allowed
            "long long suffixes are not allowed in pure C++ mode, "
            "enable long_long mode to allow these",     // invalid_long_long_literal
            "generic lexer error",                      // generic_lexing_error
            "generic lexer warning"                     // generic_lexing_warning
        };
        return preprocess_exception_errors[code];
    }

    static util::severity severity_level(int code)
    {
        static util::severity preprocess_exception_severity[] = {
            util::severity_fatal,               // unexpected_error
            util::severity_error,               // universal_char_invalid
            util::severity_error,               // universal_char_base_charset
            util::severity_error,               // universal_char_not_allowed
            util::severity_warning,             // invalid_long_long_literal
            util::severity_error,               // generic_lexing_error
            util::severity_warning              // invalid_long_long_literal
        };
        return preprocess_exception_severity[code];
    }
    static char const *severity_text(int code)
    {
        return util::get_severity(severity_level(code));
    }

private:
    char buffer[512];
    util::severity level;
    error_code code;
};

///////////////////////////////////////////////////////////////////////////////
//
//  The is_recoverable() function allows to decide, whether it is possible
//  simply to continue after a given exception was thrown by Wave.
//
//  This is kind of a hack to allow to recover from certain errors as long as
//  Wave doesn't provide better means of error recovery.
//
///////////////////////////////////////////////////////////////////////////////
inline bool
is_recoverable(lexing_exception const& e)
{
    return e.is_recoverable();
}

///////////////////////////////////////////////////////////////////////////////
}   // namespace cpplexer
}   // namespace wave
}   // namespace boost

// the suffix header occurs after all of the code
#ifdef BOOST_HAS_ABI_HEADERS
#include BOOST_ABI_SUFFIX
#endif

#endif // !defined(CPPLEXER_EXCEPTIONS_HPP_1A09DE1A_6D1F_4091_AF7F_5F13AB0D31AB_INCLUDED)
Commit	Line	Data
7c673cae FG	1	/*=============================================================================
	2	Boost.Wave: A Standard compliant C++ preprocessor library
	3
	4	http://www.boost.org/
	5
	6	Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost
	7	Software License, Version 1.0. (See accompanying file
	8	LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
	9	=============================================================================*/
	10
	11	#if !defined(CPPLEXER_EXCEPTIONS_HPP_1A09DE1A_6D1F_4091_AF7F_5F13AB0D31AB_INCLUDED)
	12	#define CPPLEXER_EXCEPTIONS_HPP_1A09DE1A_6D1F_4091_AF7F_5F13AB0D31AB_INCLUDED
	13
	14	#include <exception>
	15	#include <string>
	16
	17	#include <boost/assert.hpp>
	18	#include <boost/config.hpp>
	19	#include <boost/throw_exception.hpp>
	20
	21	#include <boost/wave/wave_config.hpp>
	22
	23	// this must occur after all of the includes and before any code appears
	24	#ifdef BOOST_HAS_ABI_HEADERS
	25	#include BOOST_ABI_PREFIX
	26	#endif
	27
	28	///////////////////////////////////////////////////////////////////////////////
	29	// helper macro for throwing exceptions
	30	#if !defined(BOOST_WAVE_LEXER_THROW)
	31	#ifdef BOOST_NO_STRINGSTREAM
	32	#include <strstream>
	33	#define BOOST_WAVE_LEXER_THROW(cls, code, msg, line, column, name) \
	34	{ \
	35	using namespace boost::wave; \
	36	std::strstream stream; \
	37	stream << cls::severity_text(cls::code) << ": " \
	38	<< cls::error_text(cls::code); \
	39	if ((msg)[0] != 0) stream << ": " << (msg); \
	40	stream << std::ends; \
	41	std::string throwmsg = stream.str(); stream.freeze(false); \
	42	boost::throw_exception(cls(throwmsg.c_str(), cls::code, line, column, \
	43	name)); \
	44	} \
	45	/**/
	46	#else
	47	#include <sstream>
	48	#define BOOST_WAVE_LEXER_THROW(cls, code, msg, line, column, name) \
	49	{ \
	50	using namespace boost::wave; \
	51	std::stringstream stream; \
	52	stream << cls::severity_text(cls::code) << ": " \
	53	<< cls::error_text(cls::code); \
	54	if ((msg)[0] != 0) stream << ": " << (msg); \
	55	stream << std::ends; \
	56	boost::throw_exception(cls(stream.str().c_str(), cls::code, line, column, \
	57	name)); \
	58	} \
	59	/**/
	60	#endif // BOOST_NO_STRINGSTREAM
	61	#endif // BOOST_WAVE_LEXER_THROW
	62
	63	#if !defined(BOOST_WAVE_LEXER_THROW_VAR)
	64	#ifdef BOOST_NO_STRINGSTREAM
65	#include <strstream>
66	#define BOOST_WAVE_LEXER_THROW_VAR(cls, codearg, msg, line, column, name) \
67	{ \
68	using namespace boost::wave; \
69	cls::error_code code = static_cast<cls::error_code>(codearg); \
70	std::strstream stream; \
71	stream << cls::severity_text(code) << ": " \
72	<< cls::error_text(code); \
73	if ((msg)[0] != 0) stream << ": " << (msg); \
74	stream << std::ends; \
75	std::string throwmsg = stream.str(); stream.freeze(false); \
76	boost::throw_exception(cls(throwmsg.c_str(), code, line, column, \
77	name)); \
78	} \
79	/**/
80	#else
81	#include <sstream>
82	#define BOOST_WAVE_LEXER_THROW_VAR(cls, codearg, msg, line, column, name) \
83	{ \
84	using namespace boost::wave; \
85	cls::error_code code = static_cast<cls::error_code>(codearg); \
86	std::stringstream stream; \
87	stream << cls::severity_text(code) << ": " \
88	<< cls::error_text(code); \
89	if ((msg)[0] != 0) stream << ": " << (msg); \
90	stream << std::ends; \
91	boost::throw_exception(cls(stream.str().c_str(), code, line, column, \
92	name)); \
93	} \
94	/**/
95	#endif // BOOST_NO_STRINGSTREAM
96	#endif // BOOST_WAVE_LEXER_THROW
97
98	///////////////////////////////////////////////////////////////////////////////
99	namespace boost {
100	namespace wave {
101	namespace cpplexer {
102
103	///////////////////////////////////////////////////////////////////////////////
104	// exception severity
105	namespace util {
106
107	enum severity {
108	severity_remark = 0,
109	severity_warning,
110	severity_error,
111	severity_fatal
112	};
113
114	inline char const *
115	get_severity(severity level)
116	{
117	static char const *severity_text[] =
118	{
119	"remark", // severity_remark
120	"warning", // severity_warning
121	"error", // severity_error
122	"fatal error" // severity_fatal
123	};
124	BOOST_ASSERT(severity_remark <= level && level <= severity_fatal);
125	return severity_text[level];
126	}
127	}
128
129	///////////////////////////////////////////////////////////////////////////////
130	// cpplexer_exception, the base class for all specific C++ lexer exceptions
131	class BOOST_SYMBOL_VISIBLE cpplexer_exception
132	: public std::exception
133	{
134	public:
135	cpplexer_exception(std::size_t line_, std::size_t column_, char const *filename_) throw()
136	: line(line_), column(column_)
137	{
138	unsigned int off = 0;
139	while (off < sizeof(filename)-1 && *filename_)
140	filename[off++] = *filename_++;
141	filename[off] = 0;
142	}
143	~cpplexer_exception() throw() {}
144
145	virtual char const *what() const throw() = 0; // to be overloaded
146	virtual char const *description() const throw() = 0;
147	virtual int get_errorcode() const throw() = 0;
148	virtual int get_severity() const throw() = 0;
149	virtual bool is_recoverable() const throw() = 0;
150
151	std::size_t line_no() const throw() { return line; }
152	std::size_t column_no() const throw() { return column; }
153	char const *file_name() const throw() { return filename; }
154
155	protected:
156	char filename[512];
157	std::size_t line;
158	std::size_t column;
159	};
160
161	///////////////////////////////////////////////////////////////////////////////
162	// lexing_exception error
163	class BOOST_SYMBOL_VISIBLE lexing_exception :
164	public cpplexer_exception
165	{
166	public:
167	enum error_code {
168	unexpected_error = 0,
169	universal_char_invalid = 1,
170	universal_char_base_charset = 2,
171	universal_char_not_allowed = 3,
172	invalid_long_long_literal = 4,
173	generic_lexing_error = 5,
174	generic_lexing_warning = 6
175	};
176
177	lexing_exception(char const *what_, error_code code, std::size_t line_,
178	std::size_t column_, char const *filename_) throw()
179	: cpplexer_exception(line_, column_, filename_),
180	level(severity_level(code)), code(code)
181	{
182	unsigned int off = 0;
183	while (off < sizeof(buffer)-1 && *what_)
184	buffer[off++] = *what_++;
185	buffer[off] = 0;
186	}
187	~lexing_exception() throw() {}
188
189	virtual char const *what() const throw()
190	{
191	return "boost::wave::lexing_exception";
192	}
193	virtual char const *description() const throw()
194	{
195	return buffer;
196	}
197	virtual int get_severity() const throw()
198	{
199	return level;
200	}
201	virtual int get_errorcode() const throw()
202	{
203	return code;
204	}
205	virtual bool is_recoverable() const throw()
206	{
207	switch (get_errorcode()) {
208	case lexing_exception::universal_char_invalid:
209	case lexing_exception::universal_char_base_charset:
210	case lexing_exception::universal_char_not_allowed:
211	case lexing_exception::invalid_long_long_literal:
212	case lexing_exception::generic_lexing_warning:
213	case lexing_exception::generic_lexing_error:
214	return true; // for now allow all exceptions to be recoverable
215
216	case lexing_exception::unexpected_error:
217	default:
218	break;
219	}
220	return false;
221	}
222
223	static char const *error_text(int code)
224	{
225	// error texts in this array must appear in the same order as the items in
226	// the error enum above
227	static char const *preprocess_exception_errors[] = {
228	"unexpected error (should not happen)", // unexpected_error
229	"universal character name specifies an invalid character", // universal_char_invalid
230	"a universal character name cannot designate a character in the "
231	"basic character set", // universal_char_base_charset
232	"this universal character is not allowed in an identifier", // universal_char_not_allowed
233	"long long suffixes are not allowed in pure C++ mode, "
234	"enable long_long mode to allow these", // invalid_long_long_literal
235	"generic lexer error", // generic_lexing_error
236	"generic lexer warning" // generic_lexing_warning
237	};
238	return preprocess_exception_errors[code];
239	}
240
241	static util::severity severity_level(int code)
242	{
243	static util::severity preprocess_exception_severity[] = {
244	util::severity_fatal, // unexpected_error
245	util::severity_error, // universal_char_invalid
246	util::severity_error, // universal_char_base_charset
247	util::severity_error, // universal_char_not_allowed
248	util::severity_warning, // invalid_long_long_literal
249	util::severity_error, // generic_lexing_error
250	util::severity_warning // invalid_long_long_literal
251	};
252	return preprocess_exception_severity[code];
253	}
254	static char const *severity_text(int code)
255	{
256	return util::get_severity(severity_level(code));
257	}
258
259	private:
260	char buffer[512];
261	util::severity level;
262	error_code code;
263	};
264
265	///////////////////////////////////////////////////////////////////////////////
266	//
267	// The is_recoverable() function allows to decide, whether it is possible
268	// simply to continue after a given exception was thrown by Wave.
269	//
270	// This is kind of a hack to allow to recover from certain errors as long as
271	// Wave doesn't provide better means of error recovery.
272	//
273	///////////////////////////////////////////////////////////////////////////////
274	inline bool
275	is_recoverable(lexing_exception const& e)
276	{
277	return e.is_recoverable();
278	}
279
280	///////////////////////////////////////////////////////////////////////////////
281	} // namespace cpplexer
282	} // namespace wave
283	} // namespace boost
284
285	// the suffix header occurs after all of the code
286	#ifdef BOOST_HAS_ABI_HEADERS
287	#include BOOST_ABI_SUFFIX
288	#endif
289
290	#endif // !defined(CPPLEXER_EXCEPTIONS_HPP_1A09DE1A_6D1F_4091_AF7F_5F13AB0D31AB_INCLUDED)