|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r80762 - in branches/release: . boost boost/wave boost/wave/cpplexer boost/wave/cpplexer/re2clex libs libs/wave libs/wave/src/cpplexer/re2clex tools tools/wave
From: hartmut.kaiser_at_[hidden]
Date: 2012-09-29 16:15:32
Author: hkaiser
Date: 2012-09-29 16:15:30 EDT (Sat, 29 Sep 2012)
New Revision: 80762
URL: http://svn.boost.org/trac/boost/changeset/80762
Log:
Wave: merging from trunk
Properties modified:
branches/release/ (props changed)
branches/release/boost/ (props changed)
branches/release/boost/wave/ (props changed)
branches/release/libs/ (props changed)
branches/release/libs/wave/ (props changed)
branches/release/tools/ (props changed)
branches/release/tools/wave/ (props changed)
Text files modified:
branches/release/boost/wave/cpp_exceptions.hpp | 52 ++++++++++----------
branches/release/boost/wave/cpp_iteration_context.hpp | 4
branches/release/boost/wave/cpplexer/cpplexer_exceptions.hpp | 46 +++++++++---------
branches/release/boost/wave/cpplexer/re2clex/cpp_re2c_lexer.hpp | 96 ++++++++++++++++++++--------------------
branches/release/boost/wave/cpplexer/re2clex/scanner.hpp | 16 +++---
branches/release/boost/wave/cpplexer/validate_universal_char.hpp | 94 +++++++++++++++++++-------------------
branches/release/libs/wave/ChangeLog | 3 +
branches/release/libs/wave/src/cpplexer/re2clex/cpp_re.cpp | 54 +++++++++++-----------
branches/release/tools/wave/trace_macro_expansion.hpp | 4
9 files changed, 186 insertions(+), 183 deletions(-)
Modified: branches/release/boost/wave/cpp_exceptions.hpp
==============================================================================
--- branches/release/boost/wave/cpp_exceptions.hpp (original)
+++ branches/release/boost/wave/cpp_exceptions.hpp 2012-09-29 16:15:30 EDT (Sat, 29 Sep 2012)
@@ -42,11 +42,11 @@
severity_commandline_error,
last_severity_code = severity_commandline_error
};
-
+
inline char const *
- get_severity(int level)
+ get_severity(int level)
{
- static char const *severity_text[] =
+ static char const *severity_text[] =
{
"remark", // severity_remark
"warning", // severity_warning
@@ -54,20 +54,20 @@
"fatal error", // severity_fatal
"command line error" // severity_commandline_error
};
- BOOST_ASSERT(severity_remark <= level &&
+ BOOST_ASSERT(severity_remark <= level &&
level <= last_severity_code);
return severity_text[level];
}
}
///////////////////////////////////////////////////////////////////////////////
-// cpp_exception, the base class for all specific C preprocessor exceptions
+// 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_)
+ cpp_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_)
@@ -75,22 +75,22 @@
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; }
+
+ 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];
- int line;
- int column;
+ std::size_t line;
+ std::size_t column;
};
///////////////////////////////////////////////////////////////////////////////
@@ -149,9 +149,9 @@
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_),
+ preprocess_exception(char const *what_, error_code code, std::size_t line_,
+ std::size_t column_, char const *filename_) throw()
+ : cpp_exception(line_, column_, filename_),
code(code)
{
unsigned int off = 0;
@@ -160,7 +160,7 @@
buffer[off] = 0;
}
~preprocess_exception() throw() {}
-
+
virtual char const *what() const throw()
{
return "boost::wave::preprocess_exception";
@@ -184,7 +184,7 @@
virtual bool is_recoverable() const throw()
{
switch (get_errorcode()) {
- // these are the exceptions thrown during processing not supposed to
+ // 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:
@@ -221,7 +221,7 @@
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:
@@ -234,7 +234,7 @@
}
return false;
}
-
+
static char const *error_text(int code)
{
// error texts in this array must appear in the same order as the items in
@@ -370,8 +370,8 @@
public preprocess_exception
{
public:
- macro_handling_exception(char const *what_, error_code code, int line_,
- int column_, char const *filename_, char const *macroname) throw()
+ macro_handling_exception(char const *what_, error_code code, std::size_t line_,
+ std::size_t column_, char const *filename_, char const *macroname) throw()
: preprocess_exception(what_, code, line_, column_, filename_)
{
unsigned int off = 0;
@@ -380,7 +380,7 @@
name[off] = 0;
}
~macro_handling_exception() throw() {}
-
+
virtual char const *what() const throw()
{
return "boost::wave::macro_handling_exception";
@@ -396,10 +396,10 @@
///////////////////////////////////////////////////////////////////////////////
//
-// The is_recoverable() function allows to decide, whether it is possible
+// 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
+// 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.
//
///////////////////////////////////////////////////////////////////////////////
Modified: branches/release/boost/wave/cpp_iteration_context.hpp
==============================================================================
--- branches/release/boost/wave/cpp_iteration_context.hpp (original)
+++ branches/release/boost/wave/cpp_iteration_context.hpp 2012-09-29 16:15:30 EDT (Sat, 29 Sep 2012)
@@ -124,8 +124,8 @@
BOOST_WAVE_STRINGTYPE real_filename; // real name of the current file
BOOST_WAVE_STRINGTYPE real_relative_filename; // real relative name of the current file
BOOST_WAVE_STRINGTYPE filename; // actual processed file
- unsigned int line; // line counter of underlying stream
- unsigned int emitted_lines; // count of emitted newlines
+ std::size_t line; // line counter of underlying stream
+ std::size_t emitted_lines; // count of emitted newlines
std::size_t if_block_depth; // depth of #if block recursion
ContextT& ctx; // corresponding context<> object
file_type type; // the type of the handled file
Modified: branches/release/boost/wave/cpplexer/cpplexer_exceptions.hpp
==============================================================================
--- branches/release/boost/wave/cpplexer/cpplexer_exceptions.hpp (original)
+++ branches/release/boost/wave/cpplexer/cpplexer_exceptions.hpp 2012-09-29 16:15:30 EDT (Sat, 29 Sep 2012)
@@ -110,11 +110,11 @@
severity_error,
severity_fatal
};
-
+
inline char const *
- get_severity(severity level)
+ get_severity(severity level)
{
- static char const *severity_text[] =
+ static char const *severity_text[] =
{
"remark", // severity_remark
"warning", // severity_warning
@@ -127,13 +127,13 @@
}
///////////////////////////////////////////////////////////////////////////////
-// cpplexer_exception, the base class for all specific C++ lexer exceptions
+// cpplexer_exception, the base class for all specific C++ lexer exceptions
class BOOST_SYMBOL_VISIBLE cpplexer_exception
: public std::exception
{
public:
- cpplexer_exception(int line_, int column_, char const *filename_) throw()
- : line(line_), column(column_)
+ 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_)
@@ -141,21 +141,21 @@
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;
- int line_no() const throw() { return line; }
- int column_no() const throw() { return column; }
+ 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];
- int line;
- int column;
+ std::size_t line;
+ std::size_t column;
};
///////////////////////////////////////////////////////////////////////////////
@@ -174,9 +174,9 @@
generic_lexing_warning = 6
};
- lexing_exception(char const *what_, error_code code, int line_,
- int column_, char const *filename_) throw()
- : cpplexer_exception(line_, column_, filename_),
+ 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;
@@ -185,7 +185,7 @@
buffer[off] = 0;
}
~lexing_exception() throw() {}
-
+
virtual char const *what() const throw()
{
return "boost::wave::lexing_exception";
@@ -212,14 +212,14 @@
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
@@ -229,7 +229,7 @@
"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
+ "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
@@ -246,7 +246,7 @@
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_error, // generic_lexing_error
util::severity_warning // invalid_long_long_literal
};
return preprocess_exception_severity[code];
@@ -264,10 +264,10 @@
///////////////////////////////////////////////////////////////////////////////
//
-// The is_recoverable() function allows to decide, whether it is possible
+// 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
+// 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.
//
///////////////////////////////////////////////////////////////////////////////
@@ -280,7 +280,7 @@
///////////////////////////////////////////////////////////////////////////////
} // namespace cpplexer
} // namespace wave
-} // namespace boost
+} // namespace boost
// the suffix header occurs after all of the code
#ifdef BOOST_HAS_ABI_HEADERS
Modified: branches/release/boost/wave/cpplexer/re2clex/cpp_re2c_lexer.hpp
==============================================================================
--- branches/release/boost/wave/cpplexer/re2clex/cpp_re2c_lexer.hpp (original)
+++ branches/release/boost/wave/cpplexer/re2clex/cpp_re2c_lexer.hpp 2012-09-29 16:15:30 EDT (Sat, 29 Sep 2012)
@@ -54,21 +54,21 @@
namespace re2clex {
///////////////////////////////////////////////////////////////////////////////
-//
+//
// encapsulation of the re2c based cpp lexer
//
///////////////////////////////////////////////////////////////////////////////
-template <typename IteratorT,
+template <typename IteratorT,
typename PositionT = boost::wave::util::file_position_type,
typename TokenT = lex_token<PositionT> >
-class lexer
+class lexer
{
public:
typedef TokenT token_type;
typedef typename token_type::string_type string_type;
- lexer(IteratorT const &first, IteratorT const &last,
+ lexer(IteratorT const &first, IteratorT const &last,
PositionT const &pos, boost::wave::language_support language_);
~lexer();
@@ -82,9 +82,9 @@
scanner.file_name = filename.c_str();
}
#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0
- bool has_include_guards(std::string& guard_name) const
- {
- return guards.detected(guard_name);
+ bool has_include_guards(std::string& guard_name) const
+ {
+ return guards.detected(guard_name);
}
#endif
@@ -111,12 +111,12 @@
};
///////////////////////////////////////////////////////////////////////////////
-// initialize cpp lexer
+// initialize cpp lexer
template <typename IteratorT, typename PositionT, typename TokenT>
inline
-lexer<IteratorT, PositionT, TokenT>::lexer(IteratorT const &first,
- IteratorT const &last, PositionT const &pos,
- boost::wave::language_support language_)
+lexer<IteratorT, PositionT, TokenT>::lexer(IteratorT const &first,
+ IteratorT const &last, PositionT const &pos,
+ boost::wave::language_support language_)
: filename(pos.get_file()), at_eof(false), language(language_)
#if BOOST_WAVE_SUPPORT_THREADING != 0
, cache()
@@ -127,7 +127,7 @@
scanner.eol_offsets = aq_create();
if (first != last) {
scanner.first = scanner.act = (uchar *)&(*first);
- scanner.last = scanner.first + std::distance(first, last);
+ scanner.last = scanner.first + std::distance(first, last);
}
scanner.line = pos.get_line();
scanner.column = scanner.curr_column = pos.get_column();
@@ -162,7 +162,7 @@
template <typename IteratorT, typename PositionT, typename TokenT>
inline
-lexer<IteratorT, PositionT, TokenT>::~lexer()
+lexer<IteratorT, PositionT, TokenT>::~lexer()
{
using namespace std; // some systems have free in std
aq_terminate(scanner.eol_offsets);
@@ -175,31 +175,31 @@
inline TokenT&
lexer<IteratorT, PositionT, TokenT>::get(TokenT& result)
{
- if (at_eof)
+ if (at_eof)
return result = token_type(); // return T_EOI
- unsigned int actline = scanner.line;
+ std::size_t actline = scanner.line;
token_id id = token_id(scan(&scanner));
switch (static_cast<unsigned int>(id)) {
case T_IDENTIFIER:
// test identifier characters for validity (throws if invalid chars found)
- value = string_type((char const *)scanner.tok,
+ value = string_type((char const *)scanner.tok,
scanner.cur-scanner.tok);
if (!boost::wave::need_no_character_validation(language))
- impl::validate_identifier_name(value, actline, scanner.column, filename);
+ impl::validate_identifier_name(value, actline, scanner.column, filename);
break;
case T_STRINGLIT:
case T_CHARLIT:
case T_RAWSTRINGLIT:
// test literal characters for validity (throws if invalid chars found)
- value = string_type((char const *)scanner.tok,
+ value = string_type((char const *)scanner.tok,
scanner.cur-scanner.tok);
if (boost::wave::need_convert_trigraphs(language))
- value = impl::convert_trigraphs(value);
+ value = impl::convert_trigraphs(value);
if (!boost::wave::need_no_character_validation(language))
- impl::validate_literal(value, actline, scanner.column, filename);
+ impl::validate_literal(value, actline, scanner.column, filename);
break;
#if BOOST_WAVE_SUPPORT_INCLUDE_NEXT != 0
@@ -208,7 +208,7 @@
case T_PP_INCLUDE:
// convert to the corresponding ..._next token, if appropriate
{
- value = string_type((char const *)scanner.tok,
+ value = string_type((char const *)scanner.tok,
scanner.cur-scanner.tok);
// Skip '#' and whitespace and see whether we find an 'include_next' here.
@@ -220,11 +220,11 @@
#endif
case T_LONGINTLIT: // supported in C++11, C99 and long_long mode
- value = string_type((char const *)scanner.tok,
+ value = string_type((char const *)scanner.tok,
scanner.cur-scanner.tok);
if (!boost::wave::need_long_long(language)) {
// syntax error: not allowed in C++ mode
- BOOST_WAVE_LEXER_THROW(lexing_exception, invalid_long_long_literal,
+ BOOST_WAVE_LEXER_THROW(lexing_exception, invalid_long_long_literal,
value.c_str(), actline, scanner.column, filename.c_str());
}
break;
@@ -241,7 +241,7 @@
case T_SPACE2:
case T_ANY:
case T_PP_NUMBER:
- value = string_type((char const *)scanner.tok,
+ value = string_type((char const *)scanner.tok,
scanner.cur-scanner.tok);
break;
@@ -264,7 +264,7 @@
value = cache.get_token_value(BASEID_FROM_TOKEN(id));
}
else {
- value = string_type((char const *)scanner.tok,
+ value = string_type((char const *)scanner.tok,
scanner.cur-scanner.tok);
}
break;
@@ -272,10 +272,10 @@
case T_ANY_TRIGRAPH:
if (boost::wave::need_convert_trigraphs(language)) {
value = impl::convert_trigraph(
- string_type((char const *)scanner.tok));
+ string_type((char const *)scanner.tok));
}
else {
- value = string_type((char const *)scanner.tok,
+ value = string_type((char const *)scanner.tok,
scanner.cur-scanner.tok);
}
break;
@@ -284,7 +284,7 @@
if (CATEGORY_FROM_TOKEN(id) != EXTCATEGORY_FROM_TOKEN(id) ||
IS_CATEGORY(id, UnknownTokenType))
{
- value = string_type((char const *)scanner.tok,
+ value = string_type((char const *)scanner.tok,
scanner.cur-scanner.tok);
}
else {
@@ -306,8 +306,8 @@
}
template <typename IteratorT, typename PositionT, typename TokenT>
-inline int
-lexer<IteratorT, PositionT, TokenT>::report_error(Scanner const *s, int errcode,
+inline int
+lexer<IteratorT, PositionT, TokenT>::report_error(Scanner const *s, int errcode,
char const *msg, ...)
{
BOOST_ASSERT(0 != s);
@@ -321,28 +321,28 @@
vsprintf(buffer, msg, params);
va_end(params);
- BOOST_WAVE_LEXER_THROW_VAR(lexing_exception, errcode, buffer, s->line,
+ BOOST_WAVE_LEXER_THROW_VAR(lexing_exception, errcode, buffer, s->line,
s->column, s->file_name);
// BOOST_UNREACHABLE_RETURN(0);
return 0;
}
///////////////////////////////////////////////////////////////////////////////
-//
+//
// lex_functor
-//
+//
///////////////////////////////////////////////////////////////////////////////
-template <typename IteratorT,
+template <typename IteratorT,
typename PositionT = boost::wave::util::file_position_type,
typename TokenT = typename lexer<IteratorT, PositionT>::token_type>
-class lex_functor
+class lex_functor
: public lex_input_interface_generator<TokenT>
{
public:
typedef TokenT token_type;
- lex_functor(IteratorT const &first, IteratorT const &last,
+ lex_functor(IteratorT const &first, IteratorT const &last,
PositionT const &pos, boost::wave::language_support language)
: re2c_lexer(first, last, pos, language)
{}
@@ -352,7 +352,7 @@
token_type& get(token_type& result) { return re2c_lexer.get(result); }
void set_position(PositionT const &pos) { re2c_lexer.set_position(pos); }
#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0
- bool has_include_guards(std::string& guard_name) const
+ bool has_include_guards(std::string& guard_name) const
{ return re2c_lexer.has_include_guards(guard_name); }
#endif
@@ -364,16 +364,16 @@
///////////////////////////////////////////////////////////////////////////////
template <typename IteratorT, typename PositionT, typename TokenT>
token_cache<typename lexer<IteratorT, PositionT, TokenT>::string_type> const
- lexer<IteratorT, PositionT, TokenT>::cache =
+ lexer<IteratorT, PositionT, TokenT>::cache =
token_cache<typename lexer<IteratorT, PositionT, TokenT>::string_type>();
#endif
} // namespace re2clex
///////////////////////////////////////////////////////////////////////////////
-//
+//
// The new_lexer_gen<>::new_lexer function (declared in cpp_lex_interface.hpp)
-// should be defined inline, if the lex_functor shouldn't be instantiated
+// should be defined inline, if the lex_functor shouldn't be instantiated
// separately from the lex_iterator.
//
// Separate (explicit) instantiation helps to reduce compilation time.
@@ -384,21 +384,21 @@
#define BOOST_WAVE_RE2C_NEW_LEXER_INLINE
#else
#define BOOST_WAVE_RE2C_NEW_LEXER_INLINE inline
-#endif
+#endif
///////////////////////////////////////////////////////////////////////////////
//
// The 'new_lexer' function allows the opaque generation of a new lexer object.
-// It is coupled to the iterator type to allow to decouple the lexer/iterator
+// It is coupled to the iterator type to allow to decouple the lexer/iterator
// configurations at compile time.
//
-// This function is declared inside the cpp_lex_token.hpp file, which is
+// This function is declared inside the cpp_lex_token.hpp file, which is
// referenced by the source file calling the lexer and the source file, which
-// instantiates the lex_functor. But is is defined here, so it will be
-// instantiated only while compiling the source file, which instantiates the
+// instantiates the lex_functor. But is is defined here, so it will be
+// instantiated only while compiling the source file, which instantiates the
// lex_functor. While the cpp_re2c_token.hpp file may be included everywhere,
// this file (cpp_re2c_lexer.hpp) should be included only once. This allows
-// to decouple the lexer interface from the lexer implementation and reduces
+// to decouple the lexer interface from the lexer implementation and reduces
// compilation time.
//
///////////////////////////////////////////////////////////////////////////////
@@ -407,7 +407,7 @@
BOOST_WAVE_RE2C_NEW_LEXER_INLINE
lex_input_interface<TokenT> *
new_lexer_gen<IteratorT, PositionT, TokenT>::new_lexer(IteratorT const &first,
- IteratorT const &last, PositionT const &pos,
+ IteratorT const &last, PositionT const &pos,
boost::wave::language_support language)
{
using re2clex::lex_functor;
@@ -419,7 +419,7 @@
///////////////////////////////////////////////////////////////////////////////
} // namespace cpplexer
} // namespace wave
-} // namespace boost
+} // namespace boost
// the suffix header occurs after all of the code
#ifdef BOOST_HAS_ABI_HEADERS
Modified: branches/release/boost/wave/cpplexer/re2clex/scanner.hpp
==============================================================================
--- branches/release/boost/wave/cpplexer/re2clex/scanner.hpp (original)
+++ branches/release/boost/wave/cpplexer/re2clex/scanner.hpp 2012-09-29 16:15:30 EDT (Sat, 29 Sep 2012)
@@ -4,8 +4,8 @@
http://www.boost.org/
Copyright (c) 2001 Daniel C. Nuffer.
- Copyright (c) 2001-2012 Hartmut Kaiser.
- Distributed under the Boost Software License, Version 1.0. (See accompanying
+ 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)
=============================================================================*/
@@ -28,7 +28,7 @@
struct Scanner;
typedef unsigned char uchar;
-typedef int (* ReportErrorProc)(struct Scanner const *, int errorcode,
+typedef int (* ReportErrorProc)(struct Scanner const *, int errorcode,
char const *, ...);
typedef struct Scanner {
@@ -37,7 +37,7 @@
uchar* last; /* end (one past last char) of input buffer */
uchar* bot; /* beginning of the current buffer */
uchar* top; /* top of the current buffer */
- uchar* eof; /* when we read in the last buffer, will point 1 past the
+ uchar* eof; /* when we read in the last buffer, will point 1 past the
end of the file, otherwise 0 */
uchar* tok; /* points to the beginning of the current token */
uchar* ptr; /* used for YYMARKER - saves backtracking info */
@@ -45,10 +45,10 @@
uchar* lim; /* used for YYLIMIT - points to the end of the buffer */
/* (lim == top) except for the last buffer, it points to
the end of the input (lim == eof - 1) */
- unsigned int line; /* current line being lex'ed */
- unsigned int column; /* current token start column position */
- unsigned int curr_column; /* current column position */
- ReportErrorProc error_proc; /* must be != 0, this function is called to
+ std::size_t line; /* current line being lex'ed */
+ std::size_t column; /* current token start column position */
+ std::size_t curr_column; /* current column position */
+ ReportErrorProc error_proc; /* must be != 0, this function is called to
report an error */
char const *file_name; /* name of the lex'ed file */
aq_queue eol_offsets;
Modified: branches/release/boost/wave/cpplexer/validate_universal_char.hpp
==============================================================================
--- branches/release/boost/wave/cpplexer/validate_universal_char.hpp (original)
+++ branches/release/boost/wave/cpplexer/validate_universal_char.hpp 2012-09-29 16:15:30 EDT (Sat, 29 Sep 2012)
@@ -2,7 +2,7 @@
Boost.Wave: A Standard compliant C++ preprocessor library
Grammar for universal character validation (see C++ standard: Annex E)
-
+
http://www.boost.org/
Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost
@@ -37,12 +37,12 @@
};
///////////////////////////////////////////////////////////////////////////
-//
-// is_range is a helper function for the classification by brute force
+//
+// is_range is a helper function for the classification by brute force
// below
//
///////////////////////////////////////////////////////////////////////////
-inline bool
+inline bool
in_range(unsigned long ch, unsigned long l, unsigned long u)
{
return (l <= ch && ch <= u);
@@ -67,15 +67,15 @@
// Implementation note:
// This classification isn't implemented very effectively here. This
// function should be rewritten with some range run matching algorithm.
-//
+//
///////////////////////////////////////////////////////////////////////////////
-inline universal_char_type
+inline universal_char_type
classify_universal_char (unsigned long ch)
{
// test for invalid characters
if (ch <= 0x0020 || in_range(ch, 0x007f, 0x009f))
return universal_char_type_invalid;
-
+
// test for characters in the range of the base character set
if (in_range(ch, 0x0021, 0x005f) || in_range(ch, 0x0061, 0x007e))
return universal_char_type_base_charset;
@@ -88,7 +88,7 @@
{
return universal_char_type_valid; // Latin
}
-
+
if (0x0384 == ch || in_range(ch, 0x0388, 0x038a) ||
0x038c == ch || in_range(ch, 0x038e, 0x03a1) ||
in_range(ch, 0x03a3, 0x03ce) || in_range(ch, 0x03d0, 0x03d6) ||
@@ -96,7 +96,7 @@
in_range(ch, 0x03e2, 0x03f3) || in_range(ch, 0x1f00, 0x1f15) ||
in_range(ch, 0x1f18, 0x1f1d) || in_range(ch, 0x1f20, 0x1f45) ||
in_range(ch, 0x1f48, 0x1f4d) || in_range(ch, 0x1f50, 0x1f57) ||
- 0x1f59 == ch || 0x1f5b == ch || 0x1f5d == ch ||
+ 0x1f59 == ch || 0x1f5b == ch || 0x1f5d == ch ||
in_range(ch, 0x1f5f, 0x1f7d) || in_range(ch, 0x1f80, 0x1fb4) ||
in_range(ch, 0x1fb6, 0x1fbc) || in_range(ch, 0x1fc2, 0x1fc4) ||
in_range(ch, 0x1fc6, 0x1fcc) || in_range(ch, 0x1fd0, 0x1fd3) ||
@@ -105,7 +105,7 @@
{
return universal_char_type_valid; // Greek
}
-
+
if (in_range(ch, 0x0401, 0x040d) || in_range(ch, 0x040f, 0x044f) ||
in_range(ch, 0x0451, 0x045c) || in_range(ch, 0x045e, 0x0481) ||
in_range(ch, 0x0490, 0x04c4) || in_range(ch, 0x04c7, 0x04c8) ||
@@ -114,20 +114,20 @@
{
return universal_char_type_valid; // Cyrillic
}
-
+
if (in_range(ch, 0x0531, 0x0556) || in_range(ch, 0x0561, 0x0587))
return universal_char_type_valid; // Armenian
if (in_range(ch, 0x05d0, 0x05ea) || in_range(ch, 0x05f0, 0x05f4))
return universal_char_type_valid; // Hebrew
-
+
if (in_range(ch, 0x0621, 0x063a) || in_range(ch, 0x0640, 0x0652) ||
in_range(ch, 0x0670, 0x06b7) || in_range(ch, 0x06ba, 0x06be) ||
in_range(ch, 0x06c0, 0x06ce) || in_range(ch, 0x06e5, 0x06e7))
{
return universal_char_type_valid; // Arabic
}
-
+
if (in_range(ch, 0x0905, 0x0939) || in_range(ch, 0x0958, 0x0962))
return universal_char_type_valid; // Devanagari
@@ -139,7 +139,7 @@
{
return universal_char_type_valid; // Bengali
}
-
+
if (in_range(ch, 0x0a05, 0x0a0a) || in_range(ch, 0x0a0f, 0x0a10) ||
in_range(ch, 0x0a13, 0x0a28) || in_range(ch, 0x0a2a, 0x0a30) ||
in_range(ch, 0x0a32, 0x0a33) || in_range(ch, 0x0a35, 0x0a36) ||
@@ -209,49 +209,49 @@
// validate_identifier_name
//
// The validate_identifier_name function tests a given identifier name for
-// its validity with regard to eventually contained universal characters.
-// These should be in valid ranges (see the function
+// its validity with regard to eventually contained universal characters.
+// These should be in valid ranges (see the function
// classify_universal_char above).
//
-// If the identifier name contains invalid or not allowed universal
+// If the identifier name contains invalid or not allowed universal
// characters a corresponding lexing_exception is thrown.
//
///////////////////////////////////////////////////////////////////////////////
template <typename StringT>
-inline void
-validate_identifier_name (StringT const &name, int line, int column,
- StringT const &file_name)
+inline void
+validate_identifier_name (StringT const &name, std::size_t line,
+ std::size_t column, StringT const &file_name)
{
using namespace std; // some systems have strtoul in namespace std::
-
+
typename StringT::size_type pos = name.find_first_of('\\');
while (StringT::npos != pos) {
// the identifier name contains a backslash (must be universal char)
BOOST_ASSERT('u' == name[pos+1] || 'U' == name[pos+1]);
-
+
StringT uchar_val(name.substr(pos+2, ('u' == name[pos+1]) ? 4 : 8));
- universal_char_type type =
- classify_universal_char(strtoul(uchar_val.c_str(), 0, 16));
-
+ universal_char_type type =
+ classify_universal_char(strtoul(uchar_val.c_str(), 0, 16));
+
if (universal_char_type_valid != type) {
// an invalid char was found, so throw an exception
StringT error_uchar(name.substr(pos, ('u' == name[pos+1]) ? 6 : 10));
-
+
if (universal_char_type_invalid == type) {
- BOOST_WAVE_LEXER_THROW(lexing_exception, universal_char_invalid,
+ BOOST_WAVE_LEXER_THROW(lexing_exception, universal_char_invalid,
error_uchar, line, column, file_name.c_str());
}
else if (universal_char_type_base_charset == type) {
- BOOST_WAVE_LEXER_THROW(lexing_exception, universal_char_base_charset,
+ BOOST_WAVE_LEXER_THROW(lexing_exception, universal_char_base_charset,
error_uchar, line, column, file_name.c_str());
}
else {
- BOOST_WAVE_LEXER_THROW(lexing_exception, universal_char_not_allowed,
+ BOOST_WAVE_LEXER_THROW(lexing_exception, universal_char_not_allowed,
error_uchar, line, column, file_name.c_str());
}
}
-
+
// find next universal char (if appropriate)
pos = name.find_first_of('\\', pos+2);
}
@@ -261,55 +261,55 @@
//
// validate_literal
//
-// The validate_literal function tests a given string or character literal
-// for its validity with regard to eventually contained universal
-// characters. These should be in valid ranges (see the function
+// The validate_literal function tests a given string or character literal
+// for its validity with regard to eventually contained universal
+// characters. These should be in valid ranges (see the function
// classify_universal_char above).
//
-// If the string or character literal contains invalid or not allowed
+// If the string or character literal contains invalid or not allowed
// universal characters a corresponding lexing_exception is thrown.
//
///////////////////////////////////////////////////////////////////////////////
template <typename StringT>
-inline void
-validate_literal (StringT const &name, int line, int column,
+inline void
+validate_literal (StringT const &name, std::size_t line, std::size_t column,
StringT const &file_name)
{
using namespace std; // some systems have strtoul in namespace std::
-
+
typename StringT::size_type pos = name.find_first_of('\\');
while (StringT::npos != pos) {
// the literal contains a backslash (may be universal char)
if ('u' == name[pos+1] || 'U' == name[pos+1]) {
StringT uchar_val(name.substr(pos+2, ('u' == name[pos+1]) ? 4 : 8));
- universal_char_type type =
- classify_universal_char(strtoul(uchar_val.c_str(), 0, 16));
-
- if (universal_char_type_valid != type &&
- universal_char_type_not_allowed_for_identifiers != type)
+ universal_char_type type =
+ classify_universal_char(strtoul(uchar_val.c_str(), 0, 16));
+
+ if (universal_char_type_valid != type &&
+ universal_char_type_not_allowed_for_identifiers != type)
{
// an invalid char was found, so throw an exception
StringT error_uchar(name.substr(pos, ('u' == name[pos+1]) ? 6 : 10));
-
+
if (universal_char_type_invalid == type) {
- BOOST_WAVE_LEXER_THROW(lexing_exception, universal_char_invalid,
+ BOOST_WAVE_LEXER_THROW(lexing_exception, universal_char_invalid,
error_uchar, line, column, file_name.c_str());
}
else {
- BOOST_WAVE_LEXER_THROW(lexing_exception, universal_char_base_charset,
+ BOOST_WAVE_LEXER_THROW(lexing_exception, universal_char_base_charset,
error_uchar, line, column, file_name.c_str());
}
}
}
-
+
// find next universal char (if appropriate)
pos = name.find_first_of('\\', pos+2);
}
}
///////////////////////////////////////////////////////////////////////////////
-} // namespace impl
+} // namespace impl
} // namespace cpplexer
} // namespace wave
} // namespace boost
Modified: branches/release/libs/wave/ChangeLog
==============================================================================
--- branches/release/libs/wave/ChangeLog (original)
+++ branches/release/libs/wave/ChangeLog 2012-09-29 16:15:30 EDT (Sat, 29 Sep 2012)
@@ -34,6 +34,9 @@
sequence was skipped, now we skip only the macro itself, which still expands
the arguments for the macro invocation.
+Boost V1.52.0:
+ - Fixed a couple of compilation warnings
+
Boost V1.51.0
- Fixed #7050: Invalid memory write bug in lexing_exception
- Fixed #7159: Text-lines are processed as if they were preprocessing directives
Modified: branches/release/libs/wave/src/cpplexer/re2clex/cpp_re.cpp
==============================================================================
--- branches/release/libs/wave/src/cpplexer/re2clex/cpp_re.cpp (original)
+++ branches/release/libs/wave/src/cpplexer/re2clex/cpp_re.cpp 2012-09-29 16:15:30 EDT (Sat, 29 Sep 2012)
@@ -2,14 +2,14 @@
Boost.Wave: A Standard compliant C++ preprocessor library
Copyright (c) 2001 Daniel C. Nuffer
- Copyright (c) 2001-2012 Hartmut Kaiser.
- Distributed under the Boost Software License, Version 1.0. (See accompanying
+ 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)
- TODO:
- It also may be necessary to add $ to identifiers, for asm.
+ TODO:
+ It also may be necessary to add $ to identifiers, for asm.
handle errors better.
- have some easier way to parse strings instead of files (done)
+ have some easier way to parse strings instead of files (done)
=============================================================================*/
#define BOOST_WAVE_SOURCE 1
@@ -31,7 +31,7 @@
#include <unistd.h>
#else
#include <io.h>
-#endif
+#endif
#include <boost/assert.hpp>
#include <boost/detail/workaround.hpp>
@@ -103,7 +103,7 @@
if (0 != s->act) {
RE2C_ASSERT(s->first != 0 && s->last != 0);
RE2C_ASSERT(s->first <= s->act && s->act <= s->last);
- if (s->act < s->last)
+ if (s->act < s->last)
return *(s->act)++;
}
return -1;
@@ -136,7 +136,7 @@
{
aq_queue q;
std::size_t i;
-
+
if (!s->eol_offsets)
s->eol_offsets = aq_create();
@@ -218,10 +218,10 @@
{
using namespace std; // some systems have printf in std
if (0 != s->error_proc) {
- (*s->error_proc)(s, lexing_exception::unexpected_error,
+ (*s->error_proc)(s, lexing_exception::unexpected_error,
"Out of memory!");
}
- else
+ else
printf("Out of memory!\n");
/* get the scanner to stop */
@@ -245,12 +245,12 @@
cnt = BOOST_WAVE_BSIZE;
memmove(s->lim, s->act, cnt);
s->act += cnt;
- if (cnt != BOOST_WAVE_BSIZE)
+ if (cnt != BOOST_WAVE_BSIZE)
{
s->eof = &s->lim[cnt]; *(s->eof)++ = '\0';
}
}
-
+
/* backslash-newline erasing time */
/* first scan for backslash-newline and erase them */
@@ -265,7 +265,7 @@
memmove(p, p + offset, s->lim + cnt - p - offset);
cnt -= offset;
--p;
- aq_enqueue(s->eol_offsets, p - s->bot + 1);
+ aq_enqueue(s->eol_offsets, p - s->bot + 1);
}
else if (*(p+len) == '\r')
{
@@ -283,14 +283,14 @@
cnt -= offset;
--p;
}
- aq_enqueue(s->eol_offsets, p - s->bot + 1);
+ aq_enqueue(s->eol_offsets, p - s->bot + 1);
}
}
}
- /* FIXME: the following code should be fixed to recognize correctly the
+ /* FIXME: the following code should be fixed to recognize correctly the
trigraph backslash token */
-
+
/* check to see if what we just read ends in a backslash */
if (cnt >= 2)
{
@@ -304,7 +304,7 @@
if (next == '\n')
{
--cnt; /* chop the final \, we've already read the \n. */
- aq_enqueue(s->eol_offsets, cnt + (s->lim - s->bot));
+ aq_enqueue(s->eol_offsets, cnt + (s->lim - s->bot));
}
else if (next == '\r')
{
@@ -319,7 +319,7 @@
rewind_stream(s, -1);
--cnt;
}
- aq_enqueue(s->eol_offsets, cnt + (s->lim - s->bot));
+ aq_enqueue(s->eol_offsets, cnt + (s->lim - s->bot));
}
else if (next != -1) /* -1 means end of file */
{
@@ -341,13 +341,13 @@
rewind_stream(s, -1);
cnt -= 2;
}
- aq_enqueue(s->eol_offsets, cnt + (s->lim - s->bot));
+ aq_enqueue(s->eol_offsets, cnt + (s->lim - s->bot));
}
/* check \ \n EOB */
else if (last == '\n' && last2 == '\\')
{
cnt -= 2;
- aq_enqueue(s->eol_offsets, cnt + (s->lim - s->bot));
+ aq_enqueue(s->eol_offsets, cnt + (s->lim - s->bot));
}
}
@@ -362,21 +362,21 @@
}
///////////////////////////////////////////////////////////////////////////////
-// Special wrapper class holding the current cursor position
+// Special wrapper class holding the current cursor position
struct uchar_wrapper
{
- uchar_wrapper (uchar *base_cursor, unsigned int column = 1)
+ uchar_wrapper (uchar *base_cursor, std::size_t column = 1)
: base_cursor(base_cursor), column(column)
{}
- uchar_wrapper& operator++()
+ uchar_wrapper& operator++()
{
++base_cursor;
++column;
return *this;
}
- uchar_wrapper& operator--()
+ uchar_wrapper& operator--()
{
--base_cursor;
--column;
@@ -393,14 +393,14 @@
return base_cursor;
}
- friend std::ptrdiff_t
+ friend std::ptrdiff_t
operator- (uchar_wrapper const& lhs, uchar_wrapper const& rhs)
{
return lhs.base_cursor - rhs.base_cursor;
}
uchar *base_cursor;
- unsigned int column;
+ std::size_t column;
};
///////////////////////////////////////////////////////////////////////////////
@@ -428,7 +428,7 @@
} // namespace boost
#undef BOOST_WAVE_RET
-#undef BOOST_WAVE_BSIZE
+#undef BOOST_WAVE_BSIZE
#undef YYCTYPE
#undef YYCURSOR
#undef YYLIMIT
Modified: branches/release/tools/wave/trace_macro_expansion.hpp
==============================================================================
--- branches/release/tools/wave/trace_macro_expansion.hpp (original)
+++ branches/release/tools/wave/trace_macro_expansion.hpp 2012-09-29 16:15:30 EDT (Sat, 29 Sep 2012)
@@ -76,8 +76,8 @@
pragma_mismatched_push_pop,
};
- bad_pragma_exception(char const *what_, error_code code, int line_,
- int column_, char const *filename_) throw()
+ bad_pragma_exception(char const *what_, error_code code, std::size_t line_,
+ std::size_t column_, char const *filename_) throw()
: boost::wave::preprocess_exception(what_,
(boost::wave::preprocess_exception::error_code)code, line_,
column_, filename_)
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk