/*============================================================================= | |
Boost.Wave: A Standard compliant C++ preprocessor library | |
http://www.boost.org/ | |
Copyright (c) 2001-2011 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(CPP_EXCEPTIONS_HPP_5190E447_A781_4521_A275_5134FF9917D7_INCLUDED) | |
#define CPP_EXCEPTIONS_HPP_5190E447_A781_4521_A275_5134FF9917D7_INCLUDED | |
#include <exception> | |
#include <string> | |
#include <limits> | |
#include <boost/assert.hpp> | |
#include <boost/config.hpp> | |
#include <boost/throw_exception.hpp> | |
#include <boost/wave/wave_config.hpp> | |
#include <boost/wave/cpp_throw.hpp> | |
// this must occur after all of the includes and before any code appears | |
#ifdef BOOST_HAS_ABI_HEADERS | |
#include BOOST_ABI_PREFIX | |
#endif | |
/////////////////////////////////////////////////////////////////////////////// | |
namespace boost { | |
namespace wave { | |
/////////////////////////////////////////////////////////////////////////////// | |
// exception severity | |
namespace util { | |
enum severity { | |
severity_remark = 0, | |
severity_warning, | |
severity_error, | |
severity_fatal, | |
severity_commandline_error, | |
last_severity_code = severity_commandline_error | |
}; | |
inline char const * | |
get_severity(int level) | |
{ | |
static char const *severity_text[] = | |
{ | |
"remark", // severity_remark | |
"warning", // severity_warning | |
"error", // severity_error | |
"fatal error", // severity_fatal | |
"command line error" // severity_commandline_error | |
}; | |
BOOST_ASSERT(severity_remark <= level && | |
level <= last_severity_code); | |
return severity_text[level]; | |
} | |
} | |
/////////////////////////////////////////////////////////////////////////////// | |
// cpp_exception, the base class for all specific C preprocessor exceptions | |
class BOOST_SYMBOL_VISIBLE cpp_exception | |
: public std::exception | |
{ | |
public: | |
cpp_exception(int line_, int 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; | |
} | |
~cpp_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 char const* get_related_name() const throw() = 0; | |
virtual bool is_recoverable() const throw() = 0; | |
int line_no() const throw() { return line; } | |
int column_no() const throw() { return column; } | |
char const *file_name() const throw() { return filename; } | |
protected: | |
char filename[512]; | |
int line; | |
int column; | |
}; | |
/////////////////////////////////////////////////////////////////////////////// | |
// preprocessor error | |
class BOOST_SYMBOL_VISIBLE preprocess_exception : | |
public cpp_exception | |
{ | |
public: | |
enum error_code { | |
no_error = 0, | |
unexpected_error, | |
macro_redefinition, | |
macro_insertion_error, | |
bad_include_file, | |
bad_include_statement, | |
ill_formed_directive, | |
error_directive, | |
warning_directive, | |
ill_formed_expression, | |
missing_matching_if, | |
missing_matching_endif, | |
ill_formed_operator, | |
bad_define_statement, | |
bad_define_statement_va_args, | |
too_few_macroarguments, | |
too_many_macroarguments, | |
empty_macroarguments, | |
improperly_terminated_macro, | |
bad_line_statement, | |
bad_line_number, | |
bad_line_filename, | |
bad_undefine_statement, | |
bad_macro_definition, | |
illegal_redefinition, | |
duplicate_parameter_name, | |
invalid_concat, | |
last_line_not_terminated, | |
ill_formed_pragma_option, | |
include_nesting_too_deep, | |
misplaced_operator, | |
alreadydefined_name, | |
undefined_macroname, | |
invalid_macroname, | |
unexpected_qualified_name, | |
division_by_zero, | |
integer_overflow, | |
illegal_operator_redefinition, | |
ill_formed_integer_literal, | |
ill_formed_character_literal, | |
unbalanced_if_endif, | |
character_literal_out_of_range, | |
could_not_open_output_file, | |
incompatible_config, | |
ill_formed_pragma_message, | |
pragma_message_directive, | |
last_error_number = pragma_message_directive | |
}; | |
preprocess_exception(char const *what_, error_code code, int line_, | |
int column_, char const *filename_) throw() | |
: cpp_exception(line_, column_, filename_), | |
code(code) | |
{ | |
unsigned int off = 0; | |
while (off < sizeof(buffer) && *what_) | |
buffer[off++] = *what_++; | |
buffer[off] = 0; | |
} | |
~preprocess_exception() throw() {} | |
virtual char const *what() const throw() | |
{ | |
return "boost::wave::preprocess_exception"; | |
} | |
virtual char const *description() const throw() | |
{ | |
return buffer; | |
} | |
virtual int get_severity() const throw() | |
{ | |
return severity_level(code); | |
} | |
virtual int get_errorcode() const throw() | |
{ | |
return code; | |
} | |
virtual char const* get_related_name() const throw() | |
{ | |
return "<unknown>"; | |
} | |
virtual bool is_recoverable() const throw() | |
{ | |
switch (get_errorcode()) { | |
// these are the exceptions thrown during processing not supposed to | |
// produce any tokens on the context::iterator level | |
case preprocess_exception::no_error: // just a placeholder | |
case preprocess_exception::macro_redefinition: | |
case preprocess_exception::macro_insertion_error: | |
case preprocess_exception::bad_macro_definition: | |
case preprocess_exception::illegal_redefinition: | |
case preprocess_exception::duplicate_parameter_name: | |
case preprocess_exception::invalid_macroname: | |
case preprocess_exception::bad_include_file: | |
case preprocess_exception::bad_include_statement: | |
case preprocess_exception::ill_formed_directive: | |
case preprocess_exception::error_directive: | |
case preprocess_exception::warning_directive: | |
case preprocess_exception::ill_formed_expression: | |
case preprocess_exception::missing_matching_if: | |
case preprocess_exception::missing_matching_endif: | |
case preprocess_exception::unbalanced_if_endif: | |
case preprocess_exception::bad_define_statement: | |
case preprocess_exception::bad_define_statement_va_args: | |
case preprocess_exception::bad_line_statement: | |
case preprocess_exception::bad_line_number: | |
case preprocess_exception::bad_line_filename: | |
case preprocess_exception::bad_undefine_statement: | |
case preprocess_exception::division_by_zero: | |
case preprocess_exception::integer_overflow: | |
case preprocess_exception::ill_formed_integer_literal: | |
case preprocess_exception::ill_formed_character_literal: | |
case preprocess_exception::character_literal_out_of_range: | |
case preprocess_exception::last_line_not_terminated: | |
case preprocess_exception::include_nesting_too_deep: | |
case preprocess_exception::illegal_operator_redefinition: | |
case preprocess_exception::incompatible_config: | |
case preprocess_exception::ill_formed_pragma_option: | |
case preprocess_exception::ill_formed_pragma_message: | |
case preprocess_exception::pragma_message_directive: | |
return true; | |
case preprocess_exception::unexpected_error: | |
case preprocess_exception::ill_formed_operator: | |
case preprocess_exception::too_few_macroarguments: | |
case preprocess_exception::too_many_macroarguments: | |
case preprocess_exception::empty_macroarguments: | |
case preprocess_exception::improperly_terminated_macro: | |
case preprocess_exception::invalid_concat: | |
case preprocess_exception::could_not_open_output_file: | |
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[] = { | |
"no error", // no_error | |
"unexpected error (should not happen)", // unexpected_error | |
"illegal macro redefinition", // macro_redefinition | |
"macro definition failed (out of memory?)", // macro_insertion_error | |
"could not find include file", // bad_include_file | |
"ill formed #include directive", // bad_include_statement | |
"ill formed preprocessor directive", // ill_formed_directive | |
"encountered #error directive or #pragma wave stop()", // error_directive | |
"encountered #warning directive", // warning_directive | |
"ill formed preprocessor expression", // ill_formed_expression | |
"the #if for this directive is missing", // missing_matching_if | |
"detected at least one missing #endif directive", // missing_matching_endif | |
"ill formed preprocessing operator", // ill_formed_operator | |
"ill formed #define directive", // bad_define_statement | |
"__VA_ARGS__ can only appear in the " | |
"expansion of a C99 variadic macro", // bad_define_statement_va_args | |
"too few macro arguments", // too_few_macroarguments | |
"too many macro arguments", // too_many_macroarguments | |
"empty macro arguments are not supported in pure C++ mode, " | |
"use variadics mode to allow these", // empty_macroarguments | |
"improperly terminated macro invocation " | |
"or replacement-list terminates in partial " | |
"macro expansion (not supported yet)", // improperly_terminated_macro | |
"ill formed #line directive", // bad_line_statement | |
"line number argument of #line directive " | |
"should consist out of decimal digits " | |
"only and must be in range of [1..INT_MAX]", // bad_line_number | |
"filename argument of #line directive should " | |
"be a narrow string literal", // bad_line_filename | |
"#undef may not be used on this predefined name", // bad_undefine_statement | |
"invalid macro definition", // bad_macro_definition | |
"this predefined name may not be redefined", // illegal_redefinition | |
"duplicate macro parameter name", // duplicate_parameter_name | |
"pasting the following two tokens does not " | |
"give a valid preprocessing token", // invalid_concat | |
"last line of file ends without a newline", // last_line_not_terminated | |
"unknown or illformed pragma option", // ill_formed_pragma_option | |
"include files nested too deep", // include_nesting_too_deep | |
"misplaced operator defined()", // misplaced_operator | |
"the name is already used in this scope as " | |
"a macro or scope name", // alreadydefined_name | |
"undefined macro or scope name may not be imported", // undefined_macroname | |
"ill formed macro name", // invalid_macroname | |
"qualified names are supported in C++0x mode only", // unexpected_qualified_name | |
"division by zero in preprocessor expression", // division_by_zero | |
"integer overflow in preprocessor expression", // integer_overflow | |
"this cannot be used as a macro name as it is " | |
"an operator in C++", // illegal_operator_redefinition | |
"ill formed integer literal or integer constant too large", // ill_formed_integer_literal | |
"ill formed character literal", // ill_formed_character_literal | |
"unbalanced #if/#endif in include file", // unbalanced_if_endif | |
"expression contains out of range character literal", // character_literal_out_of_range | |
"could not open output file", // could_not_open_output_file | |
"incompatible state information", // incompatible_config | |
"illformed pragma message", // ill_formed_pragma_message | |
"encountered #pragma message directive" // pragma_message_directive | |
}; | |
BOOST_ASSERT(no_error <= code && code <= last_error_number); | |
return preprocess_exception_errors[code]; | |
} | |
static util::severity severity_level(int code) | |
{ | |
static util::severity preprocess_exception_severity[] = { | |
util::severity_remark, // no_error | |
util::severity_fatal, // unexpected_error | |
util::severity_warning, // macro_redefinition | |
util::severity_fatal, // macro_insertion_error | |
util::severity_error, // bad_include_file | |
util::severity_error, // bad_include_statement | |
util::severity_error, // ill_formed_directive | |
util::severity_fatal, // error_directive | |
util::severity_warning, // warning_directive | |
util::severity_error, // ill_formed_expression | |
util::severity_error, // missing_matching_if | |
util::severity_error, // missing_matching_endif | |
util::severity_error, // ill_formed_operator | |
util::severity_error, // bad_define_statement | |
util::severity_error, // bad_define_statement_va_args | |
util::severity_warning, // too_few_macroarguments | |
util::severity_warning, // too_many_macroarguments | |
util::severity_warning, // empty_macroarguments | |
util::severity_error, // improperly_terminated_macro | |
util::severity_warning, // bad_line_statement | |
util::severity_warning, // bad_line_number | |
util::severity_warning, // bad_line_filename | |
util::severity_warning, // bad_undefine_statement | |
util::severity_commandline_error, // bad_macro_definition | |
util::severity_warning, // illegal_redefinition | |
util::severity_error, // duplicate_parameter_name | |
util::severity_error, // invalid_concat | |
util::severity_warning, // last_line_not_terminated | |
util::severity_warning, // ill_formed_pragma_option | |
util::severity_fatal, // include_nesting_too_deep | |
util::severity_error, // misplaced_operator | |
util::severity_error, // alreadydefined_name | |
util::severity_error, // undefined_macroname | |
util::severity_error, // invalid_macroname | |
util::severity_error, // unexpected_qualified_name | |
util::severity_fatal, // division_by_zero | |
util::severity_error, // integer_overflow | |
util::severity_error, // illegal_operator_redefinition | |
util::severity_error, // ill_formed_integer_literal | |
util::severity_error, // ill_formed_character_literal | |
util::severity_warning, // unbalanced_if_endif | |
util::severity_warning, // character_literal_out_of_range | |
util::severity_error, // could_not_open_output_file | |
util::severity_remark, // incompatible_config | |
util::severity_warning, // ill_formed_pragma_message | |
util::severity_remark, // pragma_message_directive | |
}; | |
BOOST_ASSERT(no_error <= code && code <= last_error_number); | |
return preprocess_exception_severity[code]; | |
} | |
static char const *severity_text(int code) | |
{ | |
return util::get_severity(severity_level(code)); | |
} | |
private: | |
char buffer[512]; | |
error_code code; | |
}; | |
/////////////////////////////////////////////////////////////////////////////// | |
// Error during macro handling, this exception contains the related macro name | |
class BOOST_SYMBOL_VISIBLE macro_handling_exception : | |
public preprocess_exception | |
{ | |
public: | |
macro_handling_exception(char const *what_, error_code code, int line_, | |
int column_, char const *filename_, char const *macroname) throw() | |
: preprocess_exception(what_, code, line_, column_, filename_) | |
{ | |
unsigned int off = 0; | |
while (off < sizeof(name) && *macroname) | |
name[off++] = *macroname++; | |
name[off] = 0; | |
} | |
~macro_handling_exception() throw() {} | |
virtual char const *what() const throw() | |
{ | |
return "boost::wave::macro_handling_exception"; | |
} | |
char const* get_related_name() const throw() | |
{ | |
return name; | |
} | |
private: | |
char name[512]; | |
}; | |
/////////////////////////////////////////////////////////////////////////////// | |
// | |
// 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(cpp_exception const& e) | |
{ | |
return e.is_recoverable(); | |
} | |
/////////////////////////////////////////////////////////////////////////////// | |
} // 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(CPP_EXCEPTIONS_HPP_5190E447_A781_4521_A275_5134FF9917D7_INCLUDED) |