You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
421 lines
18 KiB
421 lines
18 KiB
/*============================================================================= |
|
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)
|
|
|