|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r79796 - in trunk: boost/wave/util libs/wave
From: hartmut.kaiser_at_[hidden]
Date: 2012-07-29 09:40:40
Author: hkaiser
Date: 2012-07-29 09:40:39 EDT (Sun, 29 Jul 2012)
New Revision: 79796
URL: http://svn.boost.org/trac/boost/changeset/79796
Log:
Wave: Changed the effect of the -N command line option to simply not expand the macro by pretending it was not defined. Earlier the whole invocation sequence was skipped, now we skip only the macro itself, which still expands the arguments for the macro invocation.
Text files modified:
trunk/boost/wave/util/cpp_macromap.hpp | 628 ++++++++++++++++++++-------------------
trunk/libs/wave/ChangeLog | 4
2 files changed, 320 insertions(+), 312 deletions(-)
Modified: trunk/boost/wave/util/cpp_macromap.hpp
==============================================================================
--- trunk/boost/wave/util/cpp_macromap.hpp (original)
+++ trunk/boost/wave/util/cpp_macromap.hpp 2012-07-29 09:40:39 EDT (Sun, 29 Jul 2012)
@@ -2,7 +2,7 @@
Boost.Wave: A Standard compliant C++ preprocessor library
Macro expansion engine
-
+
http://www.boost.org/
Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost
@@ -58,9 +58,9 @@
///////////////////////////////////////////////////////////////////////////////
//
// macromap
-//
-// This class holds all currently defined macros and on demand expands
-// those macro definitions
+//
+// This class holds all currently defined macros and on demand expands
+// those macro definitions
//
///////////////////////////////////////////////////////////////////////////////
template <typename ContextT>
@@ -74,16 +74,16 @@
typedef typename ContextT::token_sequence_type definition_container_type;
typedef std::vector<token_type> parameter_container_type;
- typedef macro_definition<token_type, definition_container_type>
+ typedef macro_definition<token_type, definition_container_type>
macro_definition_type;
- typedef symbol_table<string_type, macro_definition_type>
+ typedef symbol_table<string_type, macro_definition_type>
defined_macros_type;
- typedef typename defined_macros_type::value_type::second_type
+ typedef typename defined_macros_type::value_type::second_type
macro_ref_type;
public:
- macromap(ContextT &ctx_)
- : current_macros(0), defined_macros(new defined_macros_type(1)),
+ macromap(ContextT &ctx_)
+ : current_macros(0), defined_macros(new defined_macros_type(1)),
main_pos("", 0), ctx(ctx_), macro_uid(1)
{
current_macros = defined_macros.get();
@@ -91,14 +91,14 @@
~macromap() {}
// Add a new macro to the given macro scope
- bool add_macro(token_type const &name, bool has_parameters,
- parameter_container_type ¶meters,
- definition_container_type &definition, bool is_predefined = false,
+ bool add_macro(token_type const &name, bool has_parameters,
+ parameter_container_type ¶meters,
+ definition_container_type &definition, bool is_predefined = false,
defined_macros_type *scope = 0);
// Tests, whether the given macro name is defined in the given macro scope
- bool is_defined(string_type const &name,
- typename defined_macros_type::iterator &it,
+ bool is_defined(string_type const &name,
+ typename defined_macros_type::iterator &it,
defined_macros_type *scope = 0) const;
// expects a token sequence as its parameters
@@ -109,31 +109,31 @@
bool is_defined(string_type const &str) const;
// Get the macro definition for the given macro scope
- bool get_macro(string_type const &name, bool &has_parameters,
- bool &is_predefined, position_type &pos,
- parameter_container_type ¶meters,
- definition_container_type &definition,
+ bool get_macro(string_type const &name, bool &has_parameters,
+ bool &is_predefined, position_type &pos,
+ parameter_container_type ¶meters,
+ definition_container_type &definition,
defined_macros_type *scope = 0) const;
// Remove a macro name from the given macro scope
- bool remove_macro(string_type const &name, position_type const& pos,
+ bool remove_macro(string_type const &name, position_type const& pos,
bool even_predefined = false);
template <typename IteratorT, typename ContainerT>
- token_type const &expand_tokensequence(IteratorT &first,
- IteratorT const &last, ContainerT &pending, ContainerT &expanded,
+ token_type const &expand_tokensequence(IteratorT &first,
+ IteratorT const &last, ContainerT &pending, ContainerT &expanded,
bool& seen_newline, bool expand_operator_defined);
// Expand all macros inside the given token sequence
template <typename IteratorT, typename ContainerT>
- void expand_whole_tokensequence(ContainerT &expanded,
- IteratorT &first, IteratorT const &last,
+ void expand_whole_tokensequence(ContainerT &expanded,
+ IteratorT &first, IteratorT const &last,
bool expand_operator_defined);
// Init the predefined macros (add them to the given scope)
- void init_predefined_macros(char const *fname = "<Unknown>",
+ void init_predefined_macros(char const *fname = "<Unknown>",
defined_macros_type *scope = 0, bool at_global_scope = true);
- void predefine_macro(defined_macros_type *scope, string_type const &name,
+ void predefine_macro(defined_macros_type *scope, string_type const &name,
token_type const &t);
// Init the internal macro symbol namespace
@@ -146,9 +146,9 @@
typedef typename defined_macros_type::name_iterator name_iterator;
typedef typename defined_macros_type::const_name_iterator const_name_iterator;
- name_iterator begin()
+ name_iterator begin()
{ return defined_macros_type::make_iterator(current_macros->begin()); }
- name_iterator end()
+ name_iterator end()
{ return defined_macros_type::make_iterator(current_macros->end()); }
const_name_iterator begin() const
{ return defined_macros_type::make_iterator(current_macros->begin()); }
@@ -158,43 +158,43 @@
protected:
// Helper functions for expanding all macros in token sequences
template <typename IteratorT, typename ContainerT>
- token_type const &expand_tokensequence_worker(ContainerT &pending,
- unput_queue_iterator<IteratorT, token_type, ContainerT> &first,
- unput_queue_iterator<IteratorT, token_type, ContainerT> const &last,
+ token_type const &expand_tokensequence_worker(ContainerT &pending,
+ unput_queue_iterator<IteratorT, token_type, ContainerT> &first,
+ unput_queue_iterator<IteratorT, token_type, ContainerT> const &last,
bool& seen_newline, bool expand_operator_defined);
// Collect all arguments supplied to a macro invocation
#if BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS != 0
template <typename IteratorT, typename ContainerT, typename SizeT>
typename std::vector<ContainerT>::size_type collect_arguments (
- token_type const curr_token, std::vector<ContainerT> &arguments,
+ token_type const curr_token, std::vector<ContainerT> &arguments,
IteratorT &next, IteratorT const &end, SizeT const ¶meter_count,
bool& seen_newline);
#else
template <typename IteratorT, typename ContainerT, typename SizeT>
typename std::vector<ContainerT>::size_type collect_arguments (
- token_type const curr_token, std::vector<ContainerT> &arguments,
- IteratorT &next, IteratorT &endparen, IteratorT const &end,
+ token_type const curr_token, std::vector<ContainerT> &arguments,
+ IteratorT &next, IteratorT &endparen, IteratorT const &end,
SizeT const ¶meter_count, bool& seen_newline);
#endif
// Expand a single macro name
template <typename IteratorT, typename ContainerT>
- bool expand_macro(ContainerT &pending, token_type const &name,
- typename defined_macros_type::iterator it,
- IteratorT &first, IteratorT const &last,
+ bool expand_macro(ContainerT &pending, token_type const &name,
+ typename defined_macros_type::iterator it,
+ IteratorT &first, IteratorT const &last,
bool& seen_newline, bool expand_operator_defined,
defined_macros_type *scope = 0, ContainerT *queue_symbol = 0);
// Expand a predefined macro (__LINE__, __FILE__ and __INCLUDE_LEVEL__)
template <typename ContainerT>
- bool expand_predefined_macro(token_type const &curr_token,
+ bool expand_predefined_macro(token_type const &curr_token,
ContainerT &expanded);
// Expand a single macro argument
template <typename ContainerT>
void expand_argument (typename std::vector<ContainerT>::size_type arg,
- std::vector<ContainerT> &arguments,
+ std::vector<ContainerT> &arguments,
std::vector<ContainerT> &expanded_args, bool expand_operator_defined,
std::vector<bool> &has_expanded_args);
@@ -202,13 +202,13 @@
template <typename ContainerT>
void expand_replacement_list(
macro_definition_type const ¯odefinition,
- std::vector<ContainerT> &arguments,
+ std::vector<ContainerT> &arguments,
bool expand_operator_defined, ContainerT &expanded);
// Rescans the replacement list for macro expansion
template <typename IteratorT, typename ContainerT>
- void rescan_replacement_list(token_type const &curr_token,
- macro_definition_type ¯odef, ContainerT &replacement_list,
+ void rescan_replacement_list(token_type const &curr_token,
+ macro_definition_type ¯odef, ContainerT &replacement_list,
ContainerT &expanded, bool expand_operator_defined,
IteratorT &nfirst, IteratorT const &nlast);
@@ -219,15 +219,15 @@
// Resolve operator _Pragma or the #pragma directive
template <typename IteratorT, typename ContainerT>
- bool resolve_operator_pragma(IteratorT &first,
+ bool resolve_operator_pragma(IteratorT &first,
IteratorT const &last, ContainerT &expanded, bool& seen_newline);
-// Handle the concatenation operator '##'
+// Handle the concatenation operator '##'
template <typename ContainerT>
bool concat_tokensequence(ContainerT &expanded);
template <typename ContainerT>
- bool is_valid_concat(string_type new_value,
+ bool is_valid_concat(string_type new_value,
position_type const &pos, ContainerT &rescanned);
#if BOOST_WAVE_SERIALIZATION != 0
@@ -248,7 +248,7 @@
{
using namespace boost::serialization;
if (version != (loaded_version & ~version_mask)) {
- BOOST_WAVE_THROW(preprocess_exception, incompatible_config,
+ BOOST_WAVE_THROW(preprocess_exception, incompatible_config,
"cpp_context state version", get_main_pos());
}
ar & make_nvp("defined_macros", defined_macros);
@@ -271,35 +271,35 @@
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
-//
+//
// add_macro(): adds a new macro to the macromap
//
///////////////////////////////////////////////////////////////////////////////
template <typename ContextT>
-inline bool
-macromap<ContextT>::add_macro(token_type const &name, bool has_parameters,
- parameter_container_type ¶meters, definition_container_type &definition,
+inline bool
+macromap<ContextT>::add_macro(token_type const &name, bool has_parameters,
+ parameter_container_type ¶meters, definition_container_type &definition,
bool is_predefined, defined_macros_type *scope)
{
if (!is_predefined && impl::is_special_macroname (name.get_value())) {
// exclude special macro names
- BOOST_WAVE_THROW_NAME_CTX(ctx, macro_handling_exception,
- illegal_redefinition, name.get_value().c_str(), main_pos,
+ BOOST_WAVE_THROW_NAME_CTX(ctx, macro_handling_exception,
+ illegal_redefinition, name.get_value().c_str(), main_pos,
name.get_value().c_str());
return false;
}
- if (boost::wave::need_variadics(ctx.get_language()) &&
- "__VA_ARGS__" == name.get_value())
+ if (boost::wave::need_variadics(ctx.get_language()) &&
+ "__VA_ARGS__" == name.get_value())
{
// can't use __VA_ARGS__ as a macro name
- BOOST_WAVE_THROW_NAME_CTX(ctx, macro_handling_exception,
- bad_define_statement_va_args, name.get_value().c_str(), main_pos,
+ BOOST_WAVE_THROW_NAME_CTX(ctx, macro_handling_exception,
+ bad_define_statement_va_args, name.get_value().c_str(), main_pos,
name.get_value().c_str());
return false;
}
if (AltExtTokenType == (token_id(name) & ExtTokenOnlyMask)) {
// exclude special operator names
- BOOST_WAVE_THROW_NAME_CTX(ctx, macro_handling_exception,
+ BOOST_WAVE_THROW_NAME_CTX(ctx, macro_handling_exception,
illegal_operator_redefinition, name.get_value().c_str(), main_pos,
name.get_value().c_str());
return false;
@@ -316,8 +316,8 @@
!impl::parameters_equal(macrodef->macroparameters, parameters) ||
!impl::definition_equals(macrodef->macrodefinition, definition))
{
- BOOST_WAVE_THROW_NAME_CTX(ctx, macro_handling_exception,
- macro_redefinition, name.get_value().c_str(), main_pos,
+ BOOST_WAVE_THROW_NAME_CTX(ctx, macro_handling_exception,
+ macro_redefinition, name.get_value().c_str(), main_pos,
name.get_value().c_str());
}
return false;
@@ -327,20 +327,20 @@
if (has_parameters) {
std::set<typename token_type::string_type> names;
- typedef typename parameter_container_type::iterator
+ typedef typename parameter_container_type::iterator
parameter_iterator_type;
- typedef typename std::set<typename token_type::string_type>::iterator
+ typedef typename std::set<typename token_type::string_type>::iterator
name_iterator_type;
parameter_iterator_type end = parameters.end();
- for (parameter_iterator_type itp = parameters.begin(); itp != end; ++itp)
+ for (parameter_iterator_type itp = parameters.begin(); itp != end; ++itp)
{
name_iterator_type pit = names.find((*itp).get_value());
if (pit != names.end()) {
// duplicate parameter name
- BOOST_WAVE_THROW_NAME_CTX(ctx, macro_handling_exception,
- duplicate_parameter_name, (*pit).c_str(), main_pos,
+ BOOST_WAVE_THROW_NAME_CTX(ctx, macro_handling_exception,
+ duplicate_parameter_name, (*pit).c_str(), main_pos,
name.get_value().c_str());
return false;
}
@@ -349,19 +349,19 @@
}
// insert a new macro node
- std::pair<typename defined_macros_type::iterator, bool> p =
+ std::pair<typename defined_macros_type::iterator, bool> p =
current_scope->insert(
typename defined_macros_type::value_type(
- name.get_value(),
- macro_ref_type(new macro_definition_type(name,
+ name.get_value(),
+ macro_ref_type(new macro_definition_type(name,
has_parameters, is_predefined, ++macro_uid)
)
)
);
if (!p.second) {
- BOOST_WAVE_THROW_NAME_CTX(ctx, macro_handling_exception,
- macro_insertion_error, name.get_value().c_str(), main_pos,
+ BOOST_WAVE_THROW_NAME_CTX(ctx, macro_handling_exception,
+ macro_insertion_error, name.get_value().c_str(), main_pos,
name.get_value().c_str());
return false;
}
@@ -372,26 +372,26 @@
// call the context supplied preprocessing hook
#if BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS != 0
- ctx.get_hooks().defined_macro(name, has_parameters,
- (*p.first).second->macroparameters,
+ ctx.get_hooks().defined_macro(name, has_parameters,
+ (*p.first).second->macroparameters,
(*p.first).second->macrodefinition, is_predefined);
#else
- ctx.get_hooks().defined_macro(ctx.derived(), name, has_parameters,
- (*p.first).second->macroparameters,
+ ctx.get_hooks().defined_macro(ctx.derived(), name, has_parameters,
+ (*p.first).second->macroparameters,
(*p.first).second->macrodefinition, is_predefined);
#endif
return true;
}
///////////////////////////////////////////////////////////////////////////////
-//
+//
// is_defined(): returns, whether a given macro is already defined
//
///////////////////////////////////////////////////////////////////////////////
template <typename ContextT>
-inline bool
+inline bool
macromap<ContextT>::is_defined(typename token_type::string_type const &name,
- typename defined_macros_type::iterator &it,
+ typename defined_macros_type::iterator &it,
defined_macros_type *scope) const
{
if (0 == scope) scope = current_macros;
@@ -403,27 +403,27 @@
if (name.size() < 8 || '_' != name[0] || '_' != name[1])
return false; // quick check failed
- return name == "__LINE__" || name == "__FILE__" ||
+ return name == "__LINE__" || name == "__FILE__" ||
name == "__INCLUDE_LEVEL__";
}
template <typename ContextT>
template <typename IteratorT>
-inline bool
-macromap<ContextT>::is_defined(IteratorT const &begin,
+inline bool
+macromap<ContextT>::is_defined(IteratorT const &begin,
IteratorT const &end) const
{
// in normal mode the name under inspection should consist of an identifier
// only
token_id id = token_id(*begin);
- if (T_IDENTIFIER != id &&
+ if (T_IDENTIFIER != id &&
!IS_CATEGORY(id, KeywordTokenType) &&
!IS_EXTCATEGORY(id, OperatorTokenType|AltExtTokenType) &&
- !IS_CATEGORY(id, BoolLiteralTokenType))
+ !IS_CATEGORY(id, BoolLiteralTokenType))
{
std::string msg(impl::get_full_name(begin, end));
- BOOST_WAVE_THROW_CTX(ctx, preprocess_exception, invalid_macroname,
+ BOOST_WAVE_THROW_CTX(ctx, preprocess_exception, invalid_macroname,
msg.c_str(), main_pos);
return false;
}
@@ -435,7 +435,7 @@
if (++it != end) {
// there should be only one token as the inspected name
std::string msg(impl::get_full_name(begin, end));
- BOOST_WAVE_THROW_CTX(ctx, preprocess_exception, invalid_macroname,
+ BOOST_WAVE_THROW_CTX(ctx, preprocess_exception, invalid_macroname,
msg.c_str(), main_pos);
return false;
}
@@ -445,24 +445,24 @@
///////////////////////////////////////////////////////////////////////////////
// same as above, only takes an arbitrary string type as its parameter
template <typename ContextT>
-inline bool
+inline bool
macromap<ContextT>::is_defined(string_type const &str) const
{
typename defined_macros_type::iterator cit;
- return is_defined(str, cit, 0);
+ return is_defined(str, cit, 0);
}
///////////////////////////////////////////////////////////////////////////////
-//
+//
// Get the macro definition for the given macro scope
//
///////////////////////////////////////////////////////////////////////////////
template <typename ContextT>
-inline bool
-macromap<ContextT>::get_macro(string_type const &name, bool &has_parameters,
- bool &is_predefined, position_type &pos,
- parameter_container_type ¶meters,
- definition_container_type &definition,
+inline bool
+macromap<ContextT>::get_macro(string_type const &name, bool &has_parameters,
+ bool &is_predefined, position_type &pos,
+ parameter_container_type ¶meters,
+ definition_container_type &definition,
defined_macros_type *scope) const
{
typename defined_macros_type::iterator it;
@@ -480,21 +480,21 @@
}
///////////////////////////////////////////////////////////////////////////////
-//
+//
// remove_macro(): remove a macro from the macromap
//
///////////////////////////////////////////////////////////////////////////////
template <typename ContextT>
-inline bool
-macromap<ContextT>::remove_macro(string_type const &name,
+inline bool
+macromap<ContextT>::remove_macro(string_type const &name,
position_type const& pos, bool even_predefined)
{
typename defined_macros_type::iterator it = current_macros->find(name);
-
+
if (it != current_macros->end()) {
if ((*it).second->is_predefined) {
if (!even_predefined || impl::is_special_macroname(name)) {
- BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
+ BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
bad_undefine_statement, name.c_str(), main_pos);
return false;
}
@@ -512,32 +512,32 @@
return true;
}
else if (impl::is_special_macroname(name)) {
- BOOST_WAVE_THROW_CTX(ctx, preprocess_exception, bad_undefine_statement,
+ BOOST_WAVE_THROW_CTX(ctx, preprocess_exception, bad_undefine_statement,
name.c_str(), pos);
}
return false; // macro was not defined
}
///////////////////////////////////////////////////////////////////////////////
-//
+//
// expand_tokensequence
//
-// This function is a helper function which wraps the given iterator
+// This function is a helper function which wraps the given iterator
// range into corresponding unput_iterator's and calls the main workhorse
// of the macro expansion engine (the function expand_tokensequence_worker)
//
-// This is the top level macro expansion function called from the
+// This is the top level macro expansion function called from the
// preprocessing iterator component only.
//
///////////////////////////////////////////////////////////////////////////////
template <typename ContextT>
template <typename IteratorT, typename ContainerT>
inline typename ContextT::token_type const &
-macromap<ContextT>::expand_tokensequence(IteratorT &first,
- IteratorT const &last, ContainerT &pending, ContainerT &expanded,
+macromap<ContextT>::expand_tokensequence(IteratorT &first,
+ IteratorT const &last, ContainerT &pending, ContainerT &expanded,
bool& seen_newline, bool expand_operator_defined)
{
- typedef impl::gen_unput_queue_iterator<IteratorT, token_type, ContainerT>
+ typedef impl::gen_unput_queue_iterator<IteratorT, token_type, ContainerT>
gen_type;
typedef typename gen_type::return_type iterator_type;
@@ -546,7 +546,7 @@
on_exit::assign<IteratorT, iterator_type> on_exit(first, first_it);
- return expand_tokensequence_worker(pending, first_it, last_it,
+ return expand_tokensequence_worker(pending, first_it, last_it,
seen_newline, expand_operator_defined);
}
@@ -555,8 +555,8 @@
// expand_tokensequence_worker
//
// This function is the main workhorse of the macro expansion engine. It
-// expands as much tokens as needed to identify the next preprocessed
-// token to return to the caller.
+// expands as much tokens as needed to identify the next preprocessed
+// token to return to the caller.
// It returns the next preprocessed token.
//
// The iterator 'first' is adjusted accordingly.
@@ -566,9 +566,9 @@
template <typename IteratorT, typename ContainerT>
inline typename ContextT::token_type const &
macromap<ContextT>::expand_tokensequence_worker(
- ContainerT &pending,
- unput_queue_iterator<IteratorT, token_type, ContainerT> &first,
- unput_queue_iterator<IteratorT, token_type, ContainerT> const &last,
+ ContainerT &pending,
+ unput_queue_iterator<IteratorT, token_type, ContainerT> &first,
+ unput_queue_iterator<IteratorT, token_type, ContainerT> const &last,
bool& seen_newline, bool expand_operator_defined)
{
// if there exist pending tokens (tokens, which are already preprocessed), then
@@ -579,7 +579,7 @@
return act_token = pending.front();
}
-// analyze the next element of the given sequence, if it is an
+// analyze the next element of the given sequence, if it is an
// T_IDENTIFIER token, try to replace this as a macro etc.
using namespace boost::wave;
typedef unput_queue_iterator<IteratorT, token_type, ContainerT> iterator_type;
@@ -599,23 +599,23 @@
if (T_IDENTIFIER == id || IS_CATEGORY(id, KeywordTokenType) ||
IS_EXTCATEGORY(id, OperatorTokenType|AltExtTokenType) ||
- IS_CATEGORY(id, BoolLiteralTokenType))
+ IS_CATEGORY(id, BoolLiteralTokenType))
{
// try to replace this identifier as a macro
if (expand_operator_defined && (*first).get_value() == "defined") {
// resolve operator defined()
return resolve_defined(first, last, pending);
}
- else if (boost::wave::need_variadics(ctx.get_language()) &&
- (*first).get_value() == "_Pragma")
+ else if (boost::wave::need_variadics(ctx.get_language()) &&
+ (*first).get_value() == "_Pragma")
{
// in C99 mode only: resolve the operator _Pragma
token_type curr_token = *first;
if (!resolve_operator_pragma(first, last, pending, seen_newline) ||
- pending.size() > 0)
+ pending.size() > 0)
{
- // unknown to us pragma or supplied replacement, return the
+ // unknown to us pragma or supplied replacement, return the
// next token
on_exit::pop_front<definition_container_type> pop_token(pending);
@@ -623,7 +623,7 @@
}
// the operator _Pragma() was eaten completely, continue
- return act_token = token_type(T_PLACEHOLDER, "_",
+ return act_token = token_type(T_PLACEHOLDER, "_",
curr_token.get_position());
}
@@ -631,10 +631,10 @@
typename defined_macros_type::iterator it;
if (is_defined(name_token.get_value(), it)) {
- // the current token contains an identifier, which is currently
+ // the current token contains an identifier, which is currently
// defined as a macro
- if (expand_macro(pending, name_token, it, first, last,
- seen_newline, expand_operator_defined))
+ if (expand_macro(pending, name_token, it, first, last,
+ seen_newline, expand_operator_defined))
{
// the tokens returned by expand_macro should be rescanned
// beginning at the last token of the returned replacement list
@@ -652,7 +652,7 @@
else if (!pending.empty()) {
// return the first token from the pending queue
on_exit::pop_front<definition_container_type> pop_queue (pending);
-
+
return act_token = pending.front();
}
else {
@@ -661,13 +661,13 @@
}
// return the next preprocessed token
- return expand_tokensequence_worker(pending, first, last,
+ return expand_tokensequence_worker(pending, first, last,
seen_newline, expand_operator_defined);
}
// else if (expand_operator_defined) {
-// // in preprocessing conditionals undefined identifiers and keywords
+// // in preprocessing conditionals undefined identifiers and keywords
// // are to be replaced with '0' (see. C++ standard 16.1.4, [cpp.cond])
-// return act_token =
+// return act_token =
// token_type(T_INTLIT, "0", (*first++).get_position());
// }
else {
@@ -678,11 +678,11 @@
}
else if (expand_operator_defined && IS_CATEGORY(*first, BoolLiteralTokenType)) {
// expanding a constant expression inside #if/#elif, special handling
- // of 'true' and 'false'
+ // of 'true' and 'false'
- // all remaining identifiers and keywords, except for true and false,
+ // all remaining identifiers and keywords, except for true and false,
// are replaced with the pp-number 0 (C++ standard 16.1.4, [cpp.cond])
- return act_token = token_type(T_INTLIT, T_TRUE != id ? "0" : "1",
+ return act_token = token_type(T_INTLIT, T_TRUE != id ? "0" : "1",
(*first++).get_position());
}
else {
@@ -695,7 +695,7 @@
}
///////////////////////////////////////////////////////////////////////////////
-//
+//
// collect_arguments(): collect the actual arguments of a macro invocation
//
// return the number of successfully detected non-empty arguments
@@ -704,15 +704,15 @@
#if BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS != 0
template <typename ContextT>
template <typename IteratorT, typename ContainerT, typename SizeT>
-inline typename std::vector<ContainerT>::size_type
-macromap<ContextT>::collect_arguments (token_type const curr_token,
- std::vector<ContainerT> &arguments, IteratorT &next,
+inline typename std::vector<ContainerT>::size_type
+macromap<ContextT>::collect_arguments (token_type const curr_token,
+ std::vector<ContainerT> &arguments, IteratorT &next,
IteratorT const &end, SizeT const ¶meter_count, bool& seen_newline)
#else
template <typename ContextT>
template <typename IteratorT, typename ContainerT, typename SizeT>
-inline typename std::vector<ContainerT>::size_type
-macromap<ContextT>::collect_arguments (token_type const curr_token,
+inline typename std::vector<ContainerT>::size_type
+macromap<ContextT>::collect_arguments (token_type const curr_token,
std::vector<ContainerT> &arguments, IteratorT &next, IteratorT &endparen,
IteratorT const &end, SizeT const ¶meter_count, bool& seen_newline)
#endif
@@ -731,13 +731,13 @@
while (++next != end && nested_parenthesis_level) {
token_id id = token_id(*next);
- if (0 == parameter_count &&
+ if (0 == parameter_count &&
!IS_CATEGORY((*next), WhiteSpaceTokenType) && id != T_NEWLINE &&
- id != T_RIGHTPAREN && id != T_LEFTPAREN)
+ id != T_RIGHTPAREN && id != T_LEFTPAREN)
{
// there shouldn't be any arguments
- BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
- too_many_macroarguments, curr_token.get_value().c_str(),
+ BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
+ too_many_macroarguments, curr_token.get_value().c_str(),
main_pos);
return 0;
}
@@ -760,13 +760,13 @@
endparen = next;
#endif
if (parameter_count > 0) {
- if (argument->empty() ||
- impl::is_whitespace_only(*argument))
+ if (argument->empty() ||
+ impl::is_whitespace_only(*argument))
{
#if BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS != 0
if (boost::wave::need_variadics(ctx.get_language())) {
// store a placemarker as the argument
- argument->push_back(token_type(T_PLACEMARKER, "\xA7",
+ argument->push_back(token_type(T_PLACEMARKER, "\xA7",
(*next).get_position()));
++count_arguments;
}
@@ -785,13 +785,13 @@
if (1 == nested_parenthesis_level) {
// next parameter
// trim_sequence(argument);
- if (argument->empty() ||
- impl::is_whitespace_only(*argument))
+ if (argument->empty() ||
+ impl::is_whitespace_only(*argument))
{
#if BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS != 0
if (boost::wave::need_variadics(ctx.get_language())) {
// store a placemarker as the argument
- argument->push_back(token_type(T_PLACEMARKER, "\xA7",
+ argument->push_back(token_type(T_PLACEMARKER, "\xA7",
(*next).get_position()));
++count_arguments;
}
@@ -816,7 +816,7 @@
case T_SPACE:
case T_SPACE2:
case T_CCOMMENT:
- if (!was_whitespace)
+ if (!was_whitespace)
argument->push_back(token_type(T_SPACE, " ", (*next).get_position()));
was_whitespace = true;
break; // skip whitespace
@@ -833,12 +833,12 @@
if (nested_parenthesis_level >= 1) {
// missing ')': improperly terminated macro invocation
- BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
+ BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
improperly_terminated_macro, "missing ')'", main_pos);
return 0;
}
-// if no argument was expected and we didn't find any, than remove the empty
+// if no argument was expected and we didn't find any, than remove the empty
// element
if (0 == parameter_count && 0 == count_arguments) {
BOOST_ASSERT(1 == arguments.size());
@@ -848,20 +848,20 @@
}
///////////////////////////////////////////////////////////////////////////////
-//
+//
// expand_whole_tokensequence
//
-// fully expands a given token sequence
+// fully expands a given token sequence
//
///////////////////////////////////////////////////////////////////////////////
template <typename ContextT>
template <typename IteratorT, typename ContainerT>
inline void
-macromap<ContextT>::expand_whole_tokensequence(ContainerT &expanded,
- IteratorT &first, IteratorT const &last,
+macromap<ContextT>::expand_whole_tokensequence(ContainerT &expanded,
+ IteratorT &first, IteratorT const &last,
bool expand_operator_defined)
{
- typedef impl::gen_unput_queue_iterator<IteratorT, token_type, ContainerT>
+ typedef impl::gen_unput_queue_iterator<IteratorT, token_type, ContainerT>
gen_type;
typedef typename gen_type::return_type iterator_type;
@@ -875,7 +875,7 @@
while (!pending_queue.empty() || first_it != last_it) {
expanded.push_back(
- expand_tokensequence_worker(pending_queue, first_it,
+ expand_tokensequence_worker(pending_queue, first_it,
last_it, seen_newline, expand_operator_defined)
);
}
@@ -885,23 +885,23 @@
}
///////////////////////////////////////////////////////////////////////////////
-//
+//
// expand_argument
//
-// fully expands the given argument of a macro call
+// fully expands the given argument of a macro call
//
///////////////////////////////////////////////////////////////////////////////
template <typename ContextT>
template <typename ContainerT>
-inline void
+inline void
macromap<ContextT>::expand_argument (
- typename std::vector<ContainerT>::size_type arg,
- std::vector<ContainerT> &arguments, std::vector<ContainerT> &expanded_args,
+ typename std::vector<ContainerT>::size_type arg,
+ std::vector<ContainerT> &arguments, std::vector<ContainerT> &expanded_args,
bool expand_operator_defined, std::vector<bool> &has_expanded_args)
{
if (!has_expanded_args[arg]) {
// expand the argument only once
- typedef typename std::vector<ContainerT>::value_type::iterator
+ typedef typename std::vector<ContainerT>::value_type::iterator
argument_iterator_type;
argument_iterator_type begin_it = arguments[arg].begin();
@@ -915,10 +915,10 @@
}
///////////////////////////////////////////////////////////////////////////////
-//
+//
// expand_replacement_list
//
-// fully expands the replacement list of a given macro with the
+// fully expands the replacement list of a given macro with the
// actual arguments/expanded arguments
// handles the '#' [cpp.stringize] and the '##' [cpp.concat] operator
//
@@ -928,11 +928,11 @@
inline void
macromap<ContextT>::expand_replacement_list(
macro_definition_type const ¯odef,
- std::vector<ContainerT> &arguments, bool expand_operator_defined,
+ std::vector<ContainerT> &arguments, bool expand_operator_defined,
ContainerT &expanded)
{
using namespace boost::wave;
- typedef typename macro_definition_type::const_definition_iterator_t
+ typedef typename macro_definition_type::const_definition_iterator_t
macro_definition_iter_t;
std::vector<ContainerT> expanded_args(arguments.size());
@@ -947,7 +947,7 @@
{
bool use_replaced_arg = true;
token_id base_id = BASE_TOKEN(token_id(*cit));
-
+
if (T_POUND_POUND == base_id) {
// concatenation operator
adjacent_concat = true;
@@ -958,7 +958,7 @@
adjacent_stringize = true;
}
else {
- if (adjacent_stringize || adjacent_concat ||
+ if (adjacent_stringize || adjacent_concat ||
T_POUND_POUND == impl::next_token<macro_definition_iter_t>
::peek(cit, cend))
{
@@ -978,8 +978,8 @@
BOOST_ASSERT(boost::wave::need_variadics(ctx.get_language()));
i = token_id(*cit) - T_EXTPARAMETERBASE;
is_ellipsis = true;
- }
- else
+ }
+ else
#endif
{
i = token_id(*cit) - T_PARAMETERBASE;
@@ -995,30 +995,30 @@
BOOST_ASSERT(boost::wave::need_variadics(ctx.get_language()));
// ensure all variadic arguments to be expanded
- for (typename vector<ContainerT>::size_type arg = i;
+ for (typename vector<ContainerT>::size_type arg = i;
arg < expanded_args.size(); ++arg)
{
- expand_argument(arg, arguments, expanded_args,
+ expand_argument(arg, arguments, expanded_args,
expand_operator_defined, has_expanded_args);
}
impl::replace_ellipsis(expanded_args, i, expanded, pos);
}
- else
+ else
#endif
{
// ensure argument i to be expanded
- expand_argument(i, arguments, expanded_args,
+ expand_argument(i, arguments, expanded_args,
expand_operator_defined, has_expanded_args);
// replace argument
ContainerT const &arg = expanded_args[i];
-
- std::copy(arg.begin(), arg.end(),
+
+ std::copy(arg.begin(), arg.end(),
std::inserter(expanded, expanded.end()));
}
}
- else if (adjacent_stringize &&
- !IS_CATEGORY(*cit, WhiteSpaceTokenType))
+ else if (adjacent_stringize &&
+ !IS_CATEGORY(*cit, WhiteSpaceTokenType))
{
// stringize the current argument
BOOST_ASSERT(!arguments[i].empty());
@@ -1030,14 +1030,14 @@
if (is_ellipsis && boost::wave::need_variadics(ctx.get_language())) {
impl::trim_sequence_left(arguments[i]);
impl::trim_sequence_right(arguments.back());
- expanded.push_back(token_type(T_STRINGLIT,
+ expanded.push_back(token_type(T_STRINGLIT,
impl::as_stringlit(arguments, i, pos), pos));
}
- else
-#endif
+ else
+#endif
{
impl::trim_sequence(arguments[i]);
- expanded.push_back(token_type(T_STRINGLIT,
+ expanded.push_back(token_type(T_STRINGLIT,
impl::as_stringlit(arguments[i], pos), pos));
}
adjacent_stringize = false;
@@ -1057,9 +1057,9 @@
#endif
{
ContainerT &arg = arguments[i];
-
+
impl::trim_sequence(arg);
- std::copy(arg.begin(), arg.end(),
+ std::copy(arg.begin(), arg.end(),
std::inserter(expanded, expanded.end()));
}
}
@@ -1086,15 +1086,15 @@
//
// rescan_replacement_list
//
-// As the name implies, this function is used to rescan the replacement list
+// As the name implies, this function is used to rescan the replacement list
// after the first macro substitution phase.
//
///////////////////////////////////////////////////////////////////////////////
template <typename ContextT>
template <typename IteratorT, typename ContainerT>
-inline void
-macromap<ContextT>::rescan_replacement_list(token_type const &curr_token,
- macro_definition_type ¯o_def, ContainerT &replacement_list,
+inline void
+macromap<ContextT>::rescan_replacement_list(token_type const &curr_token,
+ macro_definition_type ¯o_def, ContainerT &replacement_list,
ContainerT &expanded, bool expand_operator_defined,
IteratorT &nfirst, IteratorT const &nlast)
{
@@ -1126,8 +1126,8 @@
typename ContainerT::iterator begin_it = replacement_list.begin();
typename ContainerT::iterator end_it = replacement_list.end();
- expand_whole_tokensequence(expanded, begin_it, end_it,
- expand_operator_defined);
+ expand_whole_tokensequence(expanded, begin_it, end_it,
+ expand_operator_defined);
// trim replacement list, leave placeholder tokens untouched
impl::trim_replacement_list(expanded);
@@ -1141,7 +1141,7 @@
}
///////////////////////////////////////////////////////////////////////////////
-//
+//
// expand_macro(): expands a defined macro
//
// This functions tries to expand the macro, to which points the 'first'
@@ -1151,12 +1151,12 @@
///////////////////////////////////////////////////////////////////////////////
template <typename ContextT>
template <typename IteratorT, typename ContainerT>
-inline bool
-macromap<ContextT>::expand_macro(ContainerT &expanded,
- token_type const &curr_token, typename defined_macros_type::iterator it,
- IteratorT &first, IteratorT const &last,
- bool& seen_newline, bool expand_operator_defined,
- defined_macros_type *scope, ContainerT *queue_symbol)
+inline bool
+macromap<ContextT>::expand_macro(ContainerT &expanded,
+ token_type const &curr_token, typename defined_macros_type::iterator it,
+ IteratorT &first, IteratorT const &last,
+ bool& seen_newline, bool expand_operator_defined,
+ defined_macros_type *scope, ContainerT *queue_symbol)
{
using namespace boost::wave;
@@ -1166,7 +1166,7 @@
IS_CATEGORY(token_id(curr_token), KeywordTokenType) ||
IS_EXTCATEGORY(token_id(curr_token), OperatorTokenType|AltExtTokenType) ||
IS_CATEGORY(token_id(curr_token), BoolLiteralTokenType));
-
+
if (it == scope->end()) {
++first; // advance
@@ -1210,7 +1210,7 @@
ContainerT replacement_list;
if (T_LEFTPAREN == impl::next_token<IteratorT>::peek(first, last)) {
- // called as a function-like macro
+ // called as a function-like macro
impl::skip_to_token(ctx, first, last, T_LEFTPAREN, seen_newline);
#if BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS == 0
@@ -1224,44 +1224,44 @@
// collect the arguments
std::vector<ContainerT> arguments;
#if BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS != 0
- typename std::vector<ContainerT>::size_type count_args =
- collect_arguments (curr_token, arguments, first, last,
+ typename std::vector<ContainerT>::size_type count_args =
+ collect_arguments (curr_token, arguments, first, last,
macro_def.macroparameters.size(), seen_newline);
#else
- typename std::vector<ContainerT>::size_type count_args =
- collect_arguments (curr_token, arguments, first, seqend, last,
+ typename std::vector<ContainerT>::size_type count_args =
+ collect_arguments (curr_token, arguments, first, seqend, last,
macro_def.macroparameters.size(), seen_newline);
#endif
// verify the parameter count
if (count_args < macro_def.macroparameters.size() ||
- arguments.size() < macro_def.macroparameters.size())
+ arguments.size() < macro_def.macroparameters.size())
{
if (count_args != arguments.size()) {
// must been at least one empty argument in C++ mode
- BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
- empty_macroarguments, curr_token.get_value().c_str(),
+ BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
+ empty_macroarguments, curr_token.get_value().c_str(),
main_pos);
}
else {
// too few macro arguments
- BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
- too_few_macroarguments, curr_token.get_value().c_str(),
+ BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
+ too_few_macroarguments, curr_token.get_value().c_str(),
main_pos);
}
return false;
}
if (count_args > macro_def.macroparameters.size() ||
- arguments.size() > macro_def.macroparameters.size())
+ arguments.size() > macro_def.macroparameters.size())
{
#if BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS != 0
- if (!macro_def.has_ellipsis)
-#endif
+ if (!macro_def.has_ellipsis)
+#endif
{
// too many macro arguments
- BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
- too_many_macroarguments,
+ BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
+ too_many_macroarguments,
curr_token.get_value().c_str(), main_pos);
return false;
}
@@ -1270,18 +1270,22 @@
// inject tracing support
#if BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS != 0
ctx.get_hooks().expanding_function_like_macro(
- macro_def.macroname, macro_def.macroparameters,
+ macro_def.macroname, macro_def.macroparameters,
macro_def.macrodefinition, curr_token, arguments);
#else
- if (ctx.get_hooks().expanding_function_like_macro(ctx.derived(),
- macro_def.macroname, macro_def.macroparameters,
+ if (ctx.get_hooks().expanding_function_like_macro(ctx.derived(),
+ macro_def.macroname, macro_def.macroparameters,
macro_def.macrodefinition, curr_token, arguments,
seqstart, seqend))
{
- // do not expand this macro, just copy the whole sequence
+// // do not expand this macro, just copy the whole sequence
+// expanded.push_back(curr_token);
+// std::copy(seqstart, first,
+// std::inserter(expanded, expanded.end()));
+ // do not expand macro, just copy macro name and parenthesis
expanded.push_back(curr_token);
- std::copy(seqstart, first,
- std::inserter(expanded, expanded.end()));
+ expanded.push_back(*seqstart);
+ first = ++seqstart;
return false; // no further preprocessing required
}
#endif
@@ -1296,10 +1300,10 @@
ctx.get_hooks().expanding_object_like_macro(
macro_def.macroname, macro_def.macrodefinition, curr_token);
#else
- if (ctx.get_hooks().expanding_object_like_macro(ctx.derived(),
+ if (ctx.get_hooks().expanding_object_like_macro(ctx.derived(),
macro_def.macroname, macro_def.macrodefinition, curr_token))
{
- // do not expand this macro, just copy the whole sequence
+ // do not expand this macro, just copy the whole sequence
expanded.push_back(curr_token);
return false; // no further preprocessing required
}
@@ -1308,8 +1312,8 @@
bool found = false;
impl::find_concat_operator concat_tag(found);
- std::remove_copy_if(macro_def.macrodefinition.begin(),
- macro_def.macrodefinition.end(),
+ std::remove_copy_if(macro_def.macrodefinition.begin(),
+ macro_def.macrodefinition.end(),
std::inserter(replacement_list, replacement_list.end()),
concat_tag);
@@ -1338,10 +1342,10 @@
ctx.get_hooks().expanding_object_like_macro(
macro_def.macroname, macro_def.macrodefinition, curr_token);
#else
- if (ctx.get_hooks().expanding_object_like_macro(ctx.derived(),
+ if (ctx.get_hooks().expanding_object_like_macro(ctx.derived(),
macro_def.macroname, macro_def.macrodefinition, curr_token))
{
- // do not expand this macro, just copy the whole sequence
+ // do not expand this macro, just copy the whole sequence
expanded.push_back(curr_token);
++first; // skip macro name
return false; // no further preprocessing required
@@ -1351,15 +1355,15 @@
bool found = false;
impl::find_concat_operator concat_tag(found);
- std::remove_copy_if(macro_def.macrodefinition.begin(),
- macro_def.macrodefinition.end(),
+ std::remove_copy_if(macro_def.macrodefinition.begin(),
+ macro_def.macrodefinition.end(),
std::inserter(replacement_list, replacement_list.end()),
concat_tag);
// handle concatenation operators
if (found && !concat_tokensequence(replacement_list))
return false;
-
+
++first; // skip macro name
}
}
@@ -1373,13 +1377,13 @@
ctx.get_hooks().expanded_macro(ctx.derived(), replacement_list);
#endif
- rescan_replacement_list(curr_token, macro_def, replacement_list,
+ rescan_replacement_list(curr_token, macro_def, replacement_list,
expanded_list, expand_operator_defined, first, last);
#if BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS != 0
- ctx.get_hooks().rescanned_macro(expanded_list);
+ ctx.get_hooks().rescanned_macro(expanded_list);
#else
- ctx.get_hooks().rescanned_macro(ctx.derived(), expanded_list);
+ ctx.get_hooks().rescanned_macro(ctx.derived(), expanded_list);
#endif
expanded.splice(expanded.end(), expanded_list);
return true; // rescan is required
@@ -1387,25 +1391,25 @@
///////////////////////////////////////////////////////////////////////////////
//
-// If the token under inspection points to a certain predefined macro it will
+// If the token under inspection points to a certain predefined macro it will
// be expanded, otherwise false is returned.
// (only __FILE__, __LINE__ and __INCLUDE_LEVEL__ macros are expanded here)
//
///////////////////////////////////////////////////////////////////////////////
template <typename ContextT>
template <typename ContainerT>
-inline bool
-macromap<ContextT>::expand_predefined_macro(token_type const &curr_token,
+inline bool
+macromap<ContextT>::expand_predefined_macro(token_type const &curr_token,
ContainerT &expanded)
{
using namespace boost::wave;
-
+
string_type const &value = curr_token.get_value();
if (value.size() < 8 || '_' != value[0] || '_' != value[1])
return false; // quick check failed
-
- if (value == "__LINE__") {
+
+ if (value == "__LINE__") {
// expand the __LINE__ macro
char buffer[22]; // 21 bytes holds all NUL-terminated unsigned 64-bit numbers
@@ -1417,13 +1421,13 @@
else if (value == "__FILE__") {
// expand the __FILE__ macro
namespace fs = boost::filesystem;
-
+
std::string file("\"");
fs::path filename(wave::util::create_path(main_pos.get_file().c_str()));
-
+
using boost::wave::util::impl::escape_lit;
file += escape_lit(wave::util::native_file_string(filename)) + "\"";
- expanded.push_back(token_type(T_STRINGLIT, file.c_str(),
+ expanded.push_back(token_type(T_STRINGLIT, file.c_str(),
curr_token.get_position()));
return true;
}
@@ -1441,29 +1445,29 @@
///////////////////////////////////////////////////////////////////////////////
//
-// resolve_defined(): resolve the operator defined() and replace it with the
+// resolve_defined(): resolve the operator defined() and replace it with the
// correct T_INTLIT token
//
///////////////////////////////////////////////////////////////////////////////
template <typename ContextT>
template <typename IteratorT, typename ContainerT>
inline typename ContextT::token_type const &
-macromap<ContextT>::resolve_defined(IteratorT &first,
- IteratorT const &last, ContainerT &pending)
+macromap<ContextT>::resolve_defined(IteratorT &first,
+ IteratorT const &last, ContainerT &pending)
{
using namespace boost::wave;
using namespace boost::wave::grammars;
ContainerT result;
IteratorT start = first;
-boost::spirit::classic::parse_info<IteratorT> hit =
+boost::spirit::classic::parse_info<IteratorT> hit =
defined_grammar_gen<typename ContextT::lexer_type>::
parse_operator_defined(start, last, result);
-
+
if (!hit.hit) {
string_type msg ("defined(): ");
msg = msg + util::impl::as_string<string_type>(first, last);
- BOOST_WAVE_THROW_CTX(ctx, preprocess_exception, ill_formed_expression,
+ BOOST_WAVE_THROW_CTX(ctx, preprocess_exception, ill_formed_expression,
msg.c_str(), main_pos);
// insert a dummy token
@@ -1473,11 +1477,11 @@
impl::assign_iterator<IteratorT>::do_(first, hit.stop);
// insert a token, which reflects the outcome
- pending.push_back(token_type(T_INTLIT,
- is_defined(result.begin(), result.end()) ? "1" : "0",
+ pending.push_back(token_type(T_INTLIT,
+ is_defined(result.begin(), result.end()) ? "1" : "0",
main_pos));
}
-
+
on_exit::pop_front<definition_container_type> pop_front_token(pending);
return act_token = pending.front();
@@ -1488,52 +1492,52 @@
// resolve_operator_pragma(): resolve the operator _Pragma() and dispatch to
// the associated action
//
-// This function returns true, if the pragma was correctly interpreted.
+// This function returns true, if the pragma was correctly interpreted.
// The iterator 'first' is positioned behind the closing ')'.
-// This function returns false, if the _Pragma was not known, the
+// This function returns false, if the _Pragma was not known, the
// preprocessed token sequence is pushed back to the 'pending' sequence.
//
///////////////////////////////////////////////////////////////////////////////
template <typename ContextT>
template <typename IteratorT, typename ContainerT>
inline bool
-macromap<ContextT>::resolve_operator_pragma(IteratorT &first,
- IteratorT const &last, ContainerT &pending, bool& seen_newline)
+macromap<ContextT>::resolve_operator_pragma(IteratorT &first,
+ IteratorT const &last, ContainerT &pending, bool& seen_newline)
{
// isolate the parameter of the operator _Pragma
token_type pragma_token = *first;
-
+
if (!impl::skip_to_token(ctx, first, last, T_LEFTPAREN, seen_newline)) {
// illformed operator _Pragma
- BOOST_WAVE_THROW_CTX(ctx, preprocess_exception, ill_formed_expression,
+ BOOST_WAVE_THROW_CTX(ctx, preprocess_exception, ill_formed_expression,
"operator _Pragma()", pragma_token.get_position());
return false;
}
-
+
std::vector<ContainerT> arguments;
#if BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS != 0
- typename std::vector<ContainerT>::size_type count_args =
+ typename std::vector<ContainerT>::size_type count_args =
collect_arguments (pragma_token, arguments, first, last, 1, seen_newline);
#else
IteratorT endparen = first;
- typename std::vector<ContainerT>::size_type count_args =
- collect_arguments (pragma_token, arguments, first, endparen, last, 1,
+ typename std::vector<ContainerT>::size_type count_args =
+ collect_arguments (pragma_token, arguments, first, endparen, last, 1,
seen_newline);
#endif
// verify the parameter count
if (pragma_token.get_position().get_file().empty())
pragma_token.set_position(act_token.get_position());
-
+
if (count_args < 1 || arguments.size() < 1) {
// too few macro arguments
- BOOST_WAVE_THROW_CTX(ctx, preprocess_exception, too_few_macroarguments,
+ BOOST_WAVE_THROW_CTX(ctx, preprocess_exception, too_few_macroarguments,
pragma_token.get_value().c_str(), pragma_token.get_position());
return false;
}
if (count_args > 1 || arguments.size() > 1) {
// too many macro arguments
- BOOST_WAVE_THROW_CTX(ctx, preprocess_exception, too_many_macroarguments,
+ BOOST_WAVE_THROW_CTX(ctx, preprocess_exception, too_many_macroarguments,
pragma_token.get_value().c_str(), pragma_token.get_position());
return false;
}
@@ -1541,7 +1545,7 @@
// preprocess the pragma token body
typedef typename std::vector<ContainerT>::value_type::iterator
argument_iterator_type;
-
+
ContainerT expanded;
argument_iterator_type begin_it = arguments[0].begin();
argument_iterator_type end_it = arguments[0].end();
@@ -1549,7 +1553,7 @@
// un-escape the parameter of the operator _Pragma
typedef typename token_type::string_type string_type;
-
+
string_type pragma_cmd;
typename ContainerT::const_iterator end_exp = expanded.end();
for (typename ContainerT::const_iterator it_exp = expanded.begin();
@@ -1559,24 +1563,24 @@
break;
if (IS_CATEGORY(*it_exp, WhiteSpaceTokenType))
continue;
-
+
if (T_STRINGLIT != token_id(*it_exp)) {
// ill formed operator _Pragma
- BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
- ill_formed_pragma_option, "_Pragma",
+ BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
+ ill_formed_pragma_option, "_Pragma",
pragma_token.get_position());
return false;
}
if (pragma_cmd.size() > 0) {
- // there should be exactly one string literal (string literals are to
- // be concatenated at translation phase 6, but _Pragma operators are
+ // there should be exactly one string literal (string literals are to
+ // be concatenated at translation phase 6, but _Pragma operators are
// to be executed at translation phase 4)
- BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
- ill_formed_pragma_option, "_Pragma",
+ BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
+ ill_formed_pragma_option, "_Pragma",
pragma_token.get_position());
return false;
}
-
+
// remove the '\"' and concat all given string literal-values
string_type token_str = (*it_exp).get_value();
pragma_cmd += token_str.substr(1, token_str.size() - 2);
@@ -1585,23 +1589,23 @@
// tokenize the pragma body
typedef typename ContextT::lexer_type lexer_type;
-
+
ContainerT pragma;
std::string pragma_cmd_str(pragma_cmd_unesc.c_str());
- lexer_type it = lexer_type(pragma_cmd_str.begin(), pragma_cmd_str.end(),
+ lexer_type it = lexer_type(pragma_cmd_str.begin(), pragma_cmd_str.end(),
pragma_token.get_position(), ctx.get_language());
lexer_type end = lexer_type();
- for (/**/; it != end; ++it)
+ for (/**/; it != end; ++it)
pragma.push_back(*it);
-// analyze the preprocessed token sequence and eventually dispatch to the
+// analyze the preprocessed token sequence and eventually dispatch to the
// associated action
- if (interpret_pragma(ctx, pragma_token, pragma.begin(), pragma.end(),
+ if (interpret_pragma(ctx, pragma_token, pragma.begin(), pragma.end(),
pending))
{
return true; // successfully recognized a wave specific pragma
}
-
+
// unknown pragma token sequence, push it back and return to the caller
pending.push_front(token_type(T_SPACE, " ", pragma_token.get_position()));
pending.push_front(token_type(T_RIGHTPAREN, ")", pragma_token.get_position()));
@@ -1614,16 +1618,16 @@
///////////////////////////////////////////////////////////////////////////////
//
-// Test, whether the result of a concat operator is well formed or not.
+// Test, whether the result of a concat operator is well formed or not.
//
-// This is done by re-scanning (re-tokenizing) the resulting token sequence,
+// This is done by re-scanning (re-tokenizing) the resulting token sequence,
// which should give back exactly one token.
//
///////////////////////////////////////////////////////////////////////////////
template <typename ContextT>
template <typename ContainerT>
inline bool
-macromap<ContextT>::is_valid_concat(string_type new_value,
+macromap<ContextT>::is_valid_concat(string_type new_value,
position_type const &pos, ContainerT &rescanned)
{
// re-tokenize the newly generated string
@@ -1631,14 +1635,14 @@
std::string value_to_test(new_value.c_str());
- boost::wave::language_support lang =
+ boost::wave::language_support lang =
boost::wave::enable_prefer_pp_numbers(ctx.get_language());
lang = boost::wave::enable_single_line(lang);
- lexer_type it = lexer_type(value_to_test.begin(), value_to_test.end(), pos,
+ lexer_type it = lexer_type(value_to_test.begin(), value_to_test.end(), pos,
lang);
lexer_type end = lexer_type();
- for (/**/; it != end && T_EOF != token_id(*it); ++it)
+ for (/**/; it != end && T_EOF != token_id(*it); ++it)
{
// as of Wave V2.0.7 pasting of tokens is valid only if the resulting
// tokens are pp_tokens (as mandated by C++11)
@@ -1650,7 +1654,7 @@
#if BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS != 0
if (boost::wave::need_variadics(ctx.get_language()))
return true; // in variadics mode token pasting is well defined
-#endif
+#endif
// test if the newly generated token sequence contains more than 1 token
return 1 == rescanned.size();
@@ -1663,8 +1667,8 @@
//
///////////////////////////////////////////////////////////////////////////////
template <typename Context>
-inline void report_invalid_concatenation(Context& ctx,
- typename Context::token_type const& prev,
+inline void report_invalid_concatenation(Context& ctx,
+ typename Context::token_type const& prev,
typename Context::token_type const& next,
typename Context::position_type const& main_pos)
{
@@ -1680,7 +1684,7 @@
template <typename ContextT>
template <typename ContainerT>
-inline bool
+inline bool
macromap<ContextT>::concat_tokensequence(ContainerT &expanded)
{
using namespace boost::wave;
@@ -1688,7 +1692,7 @@
iterator_type end = expanded.end();
iterator_type prev = end;
- for (iterator_type it = expanded.begin(); it != end; /**/)
+ for (iterator_type it = expanded.begin(); it != end; /**/)
{
if (T_POUND_POUND == BASE_TOKEN(token_id(*it))) {
iterator_type next = it;
@@ -1696,7 +1700,7 @@
++next;
if (prev == end || next == end) {
// error, '##' should be in between two tokens
- BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
+ BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
ill_formed_operator, "concat ('##')", main_pos);
return false;
}
@@ -1707,12 +1711,12 @@
++next;
if (next == end) {
// error, '##' should be in between two tokens
- BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
+ BOOST_WAVE_THROW_CTX(ctx, preprocess_exception,
ill_formed_operator, "concat ('##')", main_pos);
return false;
}
}
-
+
#if BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS != 0
if (boost::wave::need_variadics(ctx.get_language())) {
if (T_PLACEMARKER == token_id(*next)) {
@@ -1728,14 +1732,14 @@
iterator_type first_to_delete = prev;
*prev = *next;
- expanded.erase(++first_to_delete, ++next);
+ expanded.erase(++first_to_delete, ++next);
it = next;
continue;
}
}
#endif // BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS != 0
- // test if the concat operator has to concatenate two unrelated
+ // test if the concat operator has to concatenate two unrelated
// tokens i.e. the result yields more then one token
string_type concat_result;
ContainerT rescanned;
@@ -1743,10 +1747,10 @@
concat_result = ((*prev).get_value() + (*next).get_value());
// analyze the validity of the concatenation result
- if (!is_valid_concat(concat_result, (*prev).get_position(),
+ if (!is_valid_concat(concat_result, (*prev).get_position(),
rescanned) &&
- !IS_CATEGORY(*prev, WhiteSpaceTokenType) &&
- !IS_CATEGORY(*next, WhiteSpaceTokenType))
+ !IS_CATEGORY(*prev, WhiteSpaceTokenType) &&
+ !IS_CATEGORY(*next, WhiteSpaceTokenType))
{
report_invalid_concatenation(ctx, *prev, *next, main_pos);
return false;
@@ -1755,12 +1759,12 @@
#if BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS != 0
if (boost::wave::need_variadics(ctx.get_language())) {
// remove the prev, '##' and the next tokens from the sequence
- expanded.erase(prev, ++next); // remove not needed tokens
+ expanded.erase(prev, ++next); // remove not needed tokens
// some stl implementations clear() the container if we erased all
- // the elements, which orphans all iterators. we re-initialize these
+ // the elements, which orphans all iterators. we re-initialize these
// here
- if (expanded.empty())
+ if (expanded.empty())
end = next = expanded.end();
// replace the old token (pointed to by *prev) with the re-tokenized
@@ -1775,7 +1779,7 @@
else
#endif // BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS != 0
{
- // we leave the token_id unchanged, but unmark the token as
+ // we leave the token_id unchanged, but unmark the token as
// disabled, if appropriate
(*prev).set_value(concat_result);
if (T_NONREPLACABLE_IDENTIFIER == token_id(*prev))
@@ -1784,7 +1788,7 @@
// remove the '##' and the next tokens from the sequence
iterator_type first_to_delete = prev;
- expanded.erase(++first_to_delete, ++next);
+ expanded.erase(++first_to_delete, ++next);
}
it = next;
continue;
@@ -1806,14 +1810,14 @@
///////////////////////////////////////////////////////////////////////////////
template <typename ContextT>
inline void
-macromap<ContextT>::predefine_macro(defined_macros_type *scope,
+macromap<ContextT>::predefine_macro(defined_macros_type *scope,
string_type const &name, token_type const &t)
{
definition_container_type macrodefinition;
std::vector<token_type> param;
macrodefinition.push_back(t);
- add_macro(token_type(T_IDENTIFIER, name, t.get_position()),
+ add_macro(token_type(T_IDENTIFIER, name, t.get_position()),
false, param, macrodefinition, true, scope);
}
@@ -1823,8 +1827,8 @@
//
///////////////////////////////////////////////////////////////////////////////
template <typename ContextT>
-inline void
-macromap<ContextT>::init_predefined_macros(char const *fname,
+inline void
+macromap<ContextT>::init_predefined_macros(char const *fname,
defined_macros_type *scope, bool at_global_scope)
{
// if no scope is given, use the current one
@@ -1842,25 +1846,25 @@
token_type(m.token_id, m.value, pos));
}
}
- else
-#endif
+ else
+#endif
{
#if BOOST_WAVE_SUPPORT_CPP0X != 0
if (boost::wave::need_cpp0x(ctx.get_language())) {
// define C++11 specifics
for (int i = 0; 0 != predef.static_data_cpp0x(i).name; ++i) {
predefined_macros::static_macros const& m = predef.static_data_cpp0x(i);
- predefine_macro(current_scope, m.name,
+ predefine_macro(current_scope, m.name,
token_type(m.token_id, m.value, pos));
}
}
- else
-#endif
+ else
+#endif
{
// define C++ specifics
for (int i = 0; 0 != predef.static_data_cpp(i).name; ++i) {
predefined_macros::static_macros const& m = predef.static_data_cpp(i);
- predefine_macro(current_scope, m.name,
+ predefine_macro(current_scope, m.name,
token_type(m.token_id, m.value, pos));
}
@@ -1870,18 +1874,18 @@
predefine_macro(current_scope, "__WAVE_HAS_VARIADICS__",
token_type(T_INTLIT, "1", pos));
}
-#endif
+#endif
}
}
-// predefine the __BASE_FILE__ macro which contains the main file name
- namespace fs = boost::filesystem;
+// predefine the __BASE_FILE__ macro which contains the main file name
+ namespace fs = boost::filesystem;
if (string_type(fname) != "<Unknown>") {
fs::path filename(create_path(fname));
using boost::wave::util::impl::escape_lit;
predefine_macro(current_scope, "__BASE_FILE__",
- token_type(T_STRINGLIT, string_type("\"") +
+ token_type(T_STRINGLIT, string_type("\"") +
escape_lit(native_file_string(filename)).c_str() + "\"", pos));
base_name = fname;
}
@@ -1890,7 +1894,7 @@
using boost::wave::util::impl::escape_lit;
predefine_macro(current_scope, "__BASE_FILE__",
- token_type(T_STRINGLIT, string_type("\"") +
+ token_type(T_STRINGLIT, string_type("\"") +
escape_lit(native_file_string(filename)).c_str() + "\"", pos));
}
@@ -1908,7 +1912,7 @@
//
///////////////////////////////////////////////////////////////////////////////
template <typename ContextT>
-inline void
+inline void
macromap<ContextT>::reset_macromap()
{
current_macros->clear();
Modified: trunk/libs/wave/ChangeLog
==============================================================================
--- trunk/libs/wave/ChangeLog (original)
+++ trunk/libs/wave/ChangeLog 2012-07-29 09:40:39 EDT (Sun, 29 Jul 2012)
@@ -29,6 +29,10 @@
which allows to pre-pend the content of a (license) file to every newly
created file. This option simplifies the implementation of partial
preprocessing as done on Phoenix, Fusion, etc.
+- Changed the effect of the -N command line option to simply not expand
+ the macro by pretending it was not defined. Earlier the whole invocation
+ sequence was skipped, now we skip only the macro itself, which still expands
+ the arguments for the macro invocation.
Boost V1.51.0
- Fixed #7050: Invalid memory write bug in lexing_exception
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