ceph/src/boost/boost/wave/cpp_exceptions.hpp

   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(BOOST_CPP_EXCEPTIONS_HPP_5190E447_A781_4521_A275_5134FF9917D7_INCLUDED)
  12 #define BOOST_CPP_EXCEPTIONS_HPP_5190E447_A781_4521_A275_5134FF9917D7_INCLUDED
  13
  14 #include <exception>
  15 #include <string>
  16 #include <limits>
  17
  18 #include <boost/assert.hpp>
  19 #include <boost/config.hpp>
  20 #include <boost/throw_exception.hpp>
  21 #include <boost/wave/wave_config.hpp>
  22 #include <boost/wave/cpp_throw.hpp>
  23
  24 // this must occur after all of the includes and before any code appears
  25 #ifdef BOOST_HAS_ABI_HEADERS
  26 #include BOOST_ABI_PREFIX
  27 #endif
  28
  29 ///////////////////////////////////////////////////////////////////////////////
  30 namespace boost {
  31 namespace wave {
  32
  33 ///////////////////////////////////////////////////////////////////////////////
  34 // exception severity
  35 namespace util {
  36
  37     enum severity {
  38         severity_remark = 0,
  39         severity_warning,
  40         severity_error,
  41         severity_fatal,
  42         severity_commandline_error,
  43         last_severity_code = severity_commandline_error
  44     };
  45
  46     inline char const *
  47     get_severity(int level)
  48     {
  49         static char const *severity_text[] =
  50         {
  51             "remark",               // severity_remark
  52             "warning",              // severity_warning
  53             "error",                // severity_error
  54             "fatal error",          // severity_fatal
  55             "command line error"    // severity_commandline_error
  56         };
  57         BOOST_ASSERT(severity_remark <= level &&
  58             level <= last_severity_code);
  59         return severity_text[level];
  60     }
  61 }
  62
  63 ///////////////////////////////////////////////////////////////////////////////
  64 //  cpp_exception, the base class for all specific C preprocessor exceptions
  65 class BOOST_SYMBOL_VISIBLE cpp_exception
  66 :   public std::exception
  67 {
  68 public:
  69     cpp_exception(std::size_t line_, std::size_t column_, char const *filename_) throw()
  70     :   line(line_), column(column_)
  71     {
  72         unsigned int off = 0;
  73         while (off < sizeof(filename)-1 && *filename_)
  74             filename[off++] = *filename_++;
  75         filename[off] = 0;
  76     }
  77     ~cpp_exception() throw() {}
  78
  79     char const *what() const throw() BOOST_OVERRIDE = 0;    // to be overloaded
  80     virtual char const *description() const throw() = 0;
  81     virtual int get_errorcode() const throw() = 0;
  82     virtual int get_severity() const throw() = 0;
  83     virtual char const* get_related_name() const throw() = 0;
  84     virtual bool is_recoverable() const throw() = 0;
  85
  86     std::size_t line_no() const throw() { return line; }
  87     std::size_t column_no() const throw() { return column; }
  88     char const *file_name() const throw() { return filename; }
  89
  90 protected:
  91     char filename[512];
  92     std::size_t line;
  93     std::size_t column;
  94 };
  95
  96 ///////////////////////////////////////////////////////////////////////////////
  97 // preprocessor error
  98 class BOOST_SYMBOL_VISIBLE preprocess_exception :
  99     public cpp_exception
 100 {
 101 public:
 102     enum error_code {
 103         no_error = 0,
 104         unexpected_error,
 105         macro_redefinition,
 106         macro_insertion_error,
 107         bad_include_file,
 108         bad_include_statement,
 109         bad_has_include_expression,
 110         ill_formed_directive,
 111         error_directive,
 112         warning_directive,
 113         ill_formed_expression,
 114         missing_matching_if,
 115         missing_matching_endif,
 116         ill_formed_operator,
 117         bad_define_statement,
 118         bad_define_statement_va_args,
 119         bad_define_statement_va_opt,
 120         bad_define_statement_va_opt_parens,
 121         bad_define_statement_va_opt_recurse,
 122         too_few_macroarguments,
 123         too_many_macroarguments,
 124         empty_macroarguments,
 125         improperly_terminated_macro,
 126         bad_line_statement,
 127         bad_line_number,
 128         bad_line_filename,
 129         bad_undefine_statement,
 130         bad_macro_definition,
 131         illegal_redefinition,
 132         duplicate_parameter_name,
 133         invalid_concat,
 134         last_line_not_terminated,
 135         ill_formed_pragma_option,
 136         include_nesting_too_deep,
 137         misplaced_operator,
 138         alreadydefined_name,
 139         undefined_macroname,
 140         invalid_macroname,
 141         unexpected_qualified_name,
 142         division_by_zero,
 143         integer_overflow,
 144         illegal_operator_redefinition,
 145         ill_formed_integer_literal,
 146         ill_formed_character_literal,
 147         unbalanced_if_endif,
 148         character_literal_out_of_range,
 149         could_not_open_output_file,
 150         incompatible_config,
 151         ill_formed_pragma_message,
 152         pragma_message_directive,
 153         last_error_number = pragma_message_directive
 154     };
 155
 156     preprocess_exception(char const *what_, error_code code, std::size_t line_,
 157         std::size_t column_, char const *filename_) throw()
 158     :   cpp_exception(line_, column_, filename_),
 159         code(code)
 160     {
 161         unsigned int off = 0;
 162         while (off < sizeof(buffer) - 1 && *what_)
 163             buffer[off++] = *what_++;
 164         buffer[off] = 0;
 165     }
 166     ~preprocess_exception() throw() {}
 167
 168     char const *what() const throw() BOOST_OVERRIDE
 169     {
 170         return "boost::wave::preprocess_exception";
 171     }
 172     char const *description() const throw() BOOST_OVERRIDE
 173     {
 174         return buffer;
 175     }
 176     int get_severity() const throw() BOOST_OVERRIDE
 177     {
 178         return severity_level(code);
 179     }
 180     int get_errorcode() const throw() BOOST_OVERRIDE
 181     {
 182         return code;
 183     }
 184     char const* get_related_name() const throw() BOOST_OVERRIDE
 185     {
 186         return "<unknown>";
 187     }
 188     bool is_recoverable() const throw() BOOST_OVERRIDE
 189     {
 190         switch (get_errorcode()) {
 191         // these are the exceptions thrown during processing not supposed to
 192         // produce any tokens on the context::iterator level
 193         case preprocess_exception::no_error:        // just a placeholder
 194         case preprocess_exception::macro_redefinition:
 195         case preprocess_exception::macro_insertion_error:
 196         case preprocess_exception::bad_macro_definition:
 197         case preprocess_exception::illegal_redefinition:
 198         case preprocess_exception::duplicate_parameter_name:
 199         case preprocess_exception::invalid_macroname:
 200         case preprocess_exception::bad_include_file:
 201         case preprocess_exception::bad_include_statement:
 202         case preprocess_exception::bad_has_include_expression:
 203         case preprocess_exception::ill_formed_directive:
 204         case preprocess_exception::error_directive:
 205         case preprocess_exception::warning_directive:
 206         case preprocess_exception::ill_formed_expression:
 207         case preprocess_exception::missing_matching_if:
 208         case preprocess_exception::missing_matching_endif:
 209         case preprocess_exception::unbalanced_if_endif:
 210         case preprocess_exception::bad_define_statement:
 211         case preprocess_exception::bad_define_statement_va_args:
 212         case preprocess_exception::bad_define_statement_va_opt:
 213         case preprocess_exception::bad_define_statement_va_opt_parens:
 214         case preprocess_exception::bad_define_statement_va_opt_recurse:
 215         case preprocess_exception::bad_line_statement:
 216         case preprocess_exception::bad_line_number:
 217         case preprocess_exception::bad_line_filename:
 218         case preprocess_exception::bad_undefine_statement:
 219         case preprocess_exception::division_by_zero:
 220         case preprocess_exception::integer_overflow:
 221         case preprocess_exception::ill_formed_integer_literal:
 222         case preprocess_exception::ill_formed_character_literal:
 223         case preprocess_exception::character_literal_out_of_range:
 224         case preprocess_exception::last_line_not_terminated:
 225         case preprocess_exception::include_nesting_too_deep:
 226         case preprocess_exception::illegal_operator_redefinition:
 227         case preprocess_exception::incompatible_config:
 228         case preprocess_exception::ill_formed_pragma_option:
 229         case preprocess_exception::ill_formed_pragma_message:
 230         case preprocess_exception::pragma_message_directive:
 231             return true;
 232
 233         case preprocess_exception::unexpected_error:
 234         case preprocess_exception::ill_formed_operator:
 235         case preprocess_exception::too_few_macroarguments:
 236         case preprocess_exception::too_many_macroarguments:
 237         case preprocess_exception::empty_macroarguments:
 238         case preprocess_exception::improperly_terminated_macro:
 239         case preprocess_exception::invalid_concat:
 240         case preprocess_exception::could_not_open_output_file:
 241             break;
 242         }
 243         return false;
 244     }
 245
 246     static char const *error_text(int code)
 247     {
 248         // error texts in this array must appear in the same order as the items in
 249         // the error enum above
 250         static char const *preprocess_exception_errors[] = {
 251             "no error",                                 // no_error
 252             "unexpected error (should not happen)",     // unexpected_error
 253             "illegal macro redefinition",               // macro_redefinition
 254             "macro definition failed (out of memory?)", // macro_insertion_error
 255             "could not find include file",              // bad_include_file
 256             "ill formed #include directive",            // bad_include_statement
 257             "ill formed __has_include expression",      // bad_has_include_expression
 258             "ill formed preprocessor directive",        // ill_formed_directive
 259             "encountered #error directive or #pragma wave stop()", // error_directive
 260             "encountered #warning directive",           // warning_directive
 261             "ill formed preprocessor expression",       // ill_formed_expression
 262             "the #if for this directive is missing",    // missing_matching_if
 263             "detected at least one missing #endif directive",   // missing_matching_endif
 264             "ill formed preprocessing operator",        // ill_formed_operator
 265             "ill formed #define directive",             // bad_define_statement
 266             "__VA_ARGS__ can only appear in the "
 267             "expansion of a C99 variadic macro",        // bad_define_statement_va_args
 268             "__VA_OPT__ can only appear in the "
 269             "expansion of a C++20 variadic macro",      // bad_define_statement_va_opt
 270             "__VA_OPT__ must be followed by a left "
 271             "paren in a C++20 variadic macro",          // bad_define_statement_va_opt_parens
 272             "__VA_OPT__() may not contain __VA_OPT__",  // bad_define_statement_va_opt_recurse
 273             "too few macro arguments",                  // too_few_macroarguments
 274             "too many macro arguments",                 // too_many_macroarguments
 275             "empty macro arguments are not supported in pure C++ mode, "
 276             "use variadics mode to allow these",        // empty_macroarguments
 277             "improperly terminated macro invocation "
 278             "or replacement-list terminates in partial "
 279             "macro expansion (not supported yet)",      // improperly_terminated_macro
 280             "ill formed #line directive",               // bad_line_statement
 281             "line number argument of #line directive "
 282             "should consist out of decimal digits "
 283             "only and must be in range of [1..INT_MAX]", // bad_line_number
 284             "filename argument of #line directive should "
 285             "be a narrow string literal",               // bad_line_filename
 286             "#undef may not be used on this predefined name",   // bad_undefine_statement
 287             "invalid macro definition",                 // bad_macro_definition
 288             "this predefined name may not be redefined",        // illegal_redefinition
 289             "duplicate macro parameter name",           // duplicate_parameter_name
 290             "pasting the following two tokens does not "
 291             "give a valid preprocessing token",         // invalid_concat
 292             "last line of file ends without a newline", // last_line_not_terminated
 293             "unknown or illformed pragma option",       // ill_formed_pragma_option
 294             "include files nested too deep",            // include_nesting_too_deep
 295             "misplaced operator defined()",             // misplaced_operator
 296             "the name is already used in this scope as "
 297             "a macro or scope name",                    // alreadydefined_name
 298             "undefined macro or scope name may not be imported", // undefined_macroname
 299             "ill formed macro name",                    // invalid_macroname
 300             "qualified names are supported in C++11 mode only",  // unexpected_qualified_name
 301             "division by zero in preprocessor expression",       // division_by_zero
 302             "integer overflow in preprocessor expression",       // integer_overflow
 303             "this cannot be used as a macro name as it is "
 304             "an operator in C++",                       // illegal_operator_redefinition
 305             "ill formed integer literal or integer constant too large",   // ill_formed_integer_literal
 306             "ill formed character literal",             // ill_formed_character_literal
 307             "unbalanced #if/#endif in include file",    // unbalanced_if_endif
 308             "expression contains out of range character literal", // character_literal_out_of_range
 309             "could not open output file",               // could_not_open_output_file
 310             "incompatible state information",           // incompatible_config
 311             "illformed pragma message",                 // ill_formed_pragma_message
 312             "encountered #pragma message directive"     // pragma_message_directive
 313         };
 314         BOOST_ASSERT(no_error <= code && code <= last_error_number);
 315         return preprocess_exception_errors[code];
 316     }
 317
 318     static util::severity severity_level(int code)
 319     {
 320         static util::severity preprocess_exception_severity[] = {
 321             util::severity_remark,             // no_error
 322             util::severity_fatal,              // unexpected_error
 323             util::severity_warning,            // macro_redefinition
 324             util::severity_fatal,              // macro_insertion_error
 325             util::severity_error,              // bad_include_file
 326             util::severity_error,              // bad_include_statement
 327             util::severity_error,              // bad_has_include_expression
 328             util::severity_error,              // ill_formed_directive
 329             util::severity_fatal,              // error_directive
 330             util::severity_warning,            // warning_directive
 331             util::severity_error,              // ill_formed_expression
 332             util::severity_error,              // missing_matching_if
 333             util::severity_error,              // missing_matching_endif
 334             util::severity_error,              // ill_formed_operator
 335             util::severity_error,              // bad_define_statement
 336             util::severity_error,              // bad_define_statement_va_args
 337             util::severity_error,              // bad_define_statement_va_opt
 338             util::severity_error,              // bad_define_statement_va_opt_parens
 339             util::severity_error,              // bad_define_statement_va_opt_recurse
 340             util::severity_warning,            // too_few_macroarguments
 341             util::severity_warning,            // too_many_macroarguments
 342             util::severity_warning,            // empty_macroarguments
 343             util::severity_error,              // improperly_terminated_macro
 344             util::severity_warning,            // bad_line_statement
 345             util::severity_warning,            // bad_line_number
 346             util::severity_warning,            // bad_line_filename
 347             util::severity_warning,            // bad_undefine_statement
 348             util::severity_commandline_error,  // bad_macro_definition
 349             util::severity_warning,            // illegal_redefinition
 350             util::severity_error,              // duplicate_parameter_name
 351             util::severity_error,              // invalid_concat
 352             util::severity_warning,            // last_line_not_terminated
 353             util::severity_warning,            // ill_formed_pragma_option
 354             util::severity_fatal,              // include_nesting_too_deep
 355             util::severity_error,              // misplaced_operator
 356             util::severity_error,              // alreadydefined_name
 357             util::severity_error,              // undefined_macroname
 358             util::severity_error,              // invalid_macroname
 359             util::severity_error,              // unexpected_qualified_name
 360             util::severity_fatal,              // division_by_zero
 361             util::severity_error,              // integer_overflow
 362             util::severity_error,              // illegal_operator_redefinition
 363             util::severity_error,              // ill_formed_integer_literal
 364             util::severity_error,              // ill_formed_character_literal
 365             util::severity_warning,            // unbalanced_if_endif
 366             util::severity_warning,            // character_literal_out_of_range
 367             util::severity_error,              // could_not_open_output_file
 368             util::severity_remark,             // incompatible_config
 369             util::severity_warning,            // ill_formed_pragma_message
 370             util::severity_remark,             // pragma_message_directive
 371         };
 372         BOOST_ASSERT(no_error <= code && code <= last_error_number);
 373         return preprocess_exception_severity[code];
 374     }
 375     static char const *severity_text(int code)
 376     {
 377         return util::get_severity(severity_level(code));
 378     }
 379
 380 private:
 381     char buffer[512];
 382     error_code code;
 383 };
 384
 385 ///////////////////////////////////////////////////////////////////////////////
 386 //  Error during macro handling, this exception contains the related macro name
 387 class BOOST_SYMBOL_VISIBLE macro_handling_exception :
 388     public preprocess_exception
 389 {
 390 public:
 391     macro_handling_exception(char const *what_, error_code code, std::size_t line_,
 392         std::size_t column_, char const *filename_, char const *macroname) throw()
 393     :   preprocess_exception(what_, code, line_, column_, filename_)
 394     {
 395         unsigned int off = 0;
 396         while (off < sizeof(name) && *macroname)
 397             name[off++] = *macroname++;
 398         name[off] = 0;
 399     }
 400     ~macro_handling_exception() throw() {}
 401
 402     char const *what() const throw() BOOST_OVERRIDE
 403     {
 404         return "boost::wave::macro_handling_exception";
 405     }
 406     char const* get_related_name() const throw() BOOST_OVERRIDE
 407     {
 408         return name;
 409     }
 410
 411 private:
 412     char name[512];
 413 };
 414
 415 ///////////////////////////////////////////////////////////////////////////////
 416 //
 417 //  The is_recoverable() function allows to decide, whether it is possible
 418 //  simply to continue after a given exception was thrown by Wave.
 419 //
 420 //  This is kind of a hack to allow to recover from certain errors as long as
 421 //  Wave doesn't provide better means of error recovery.
 422 //
 423 ///////////////////////////////////////////////////////////////////////////////
 424 inline bool
 425 is_recoverable(cpp_exception const& e)
 426 {
 427     return e.is_recoverable();
 428 }
 429
 430 ///////////////////////////////////////////////////////////////////////////////
 431 }   // namespace wave
 432 }   // namespace boost
 433
 434 // the suffix header occurs after all of the code
 435 #ifdef BOOST_HAS_ABI_HEADERS
 436 #include BOOST_ABI_SUFFIX
 437 #endif
 438
 439 #endif // !defined(BOOST_CPP_EXCEPTIONS_HPP_5190E447_A781_4521_A275_5134FF9917D7_INCLUDED)