From 6389bf38961d84fd3e1c8fbdc78040e1b1be3ba9 Mon Sep 17 00:00:00 2001 From: Fridrich Štrba Date: Fri, 17 May 2013 16:04:07 +0200 Subject: Silence a bit libcdr build Change-Id: I9bae7d0ea71072168ba53d7376e816bcd05722fa --- boost/UnpackedTarball_boost.mk | 1 + boost/boost.libcdr.warnings.patch.1 | 694 ++++++++++++++++++++++++++++++++++++ 2 files changed, 695 insertions(+) create mode 100644 boost/boost.libcdr.warnings.patch.1 diff --git a/boost/UnpackedTarball_boost.mk b/boost/UnpackedTarball_boost.mk index 687a1638701d..658fcb0fe51a 100644 --- a/boost/UnpackedTarball_boost.mk +++ b/boost/UnpackedTarball_boost.mk @@ -40,6 +40,7 @@ boost_patches += boost.wundef.patch.1 boost_patches += boost.windows.patch boost_patches += boost.vc2012.patch +boost_patches += boost.libcdr.warnings.patch.1 # Help static analysis tools (see SAL_UNUSED_PARAMETER in sal/types.h): ifeq (GCC,$(COM)) diff --git a/boost/boost.libcdr.warnings.patch.1 b/boost/boost.libcdr.warnings.patch.1 new file mode 100644 index 000000000000..2df0e3b6f9d9 --- /dev/null +++ b/boost/boost.libcdr.warnings.patch.1 @@ -0,0 +1,694 @@ +--- boost/boost/archive/basic_archive.hpp 2010-08-11 20:15:46.000000000 +0200 ++++ boost/boost/archive/basic_archive.hpp 2013-05-17 15:39:58.624333369 +0200 +@@ -54,7 +54,7 @@ + return *this; + } + // used for text output +- operator const base_type () const { ++ operator base_type () const { + return t; + } + // used for text input +@@ -90,7 +90,7 @@ + return *this; + } + // used for text output +- operator const base_type () const { ++ operator base_type () const { + return t; + } + // used for text intput +@@ -127,7 +127,7 @@ + } + + // used for text output +- operator const int () const { ++ operator int () const { + return t; + } + // used for text input +@@ -161,7 +161,7 @@ + return *this; + } + // used for text output +- operator const uint_least32_t () const { ++ operator uint_least32_t () const { + return t; + } + // used for text input +@@ -254,7 +254,7 @@ + #define BOOST_ARCHIVE_STRONG_TYPEDEF(T, D) \ + class D : public T { \ + public: \ +- explicit D(const T t) : T(t){} \ ++ explicit D(const T t_) : T(t_){} \ + }; \ + /**/ + +--- boost/boost/multi_index/detail/index_matcher.hpp 2008-07-03 18:51:53.000000000 +0200 ++++ boost/boost/multi_index/detail/index_matcher.hpp 2013-05-17 15:30:12.539099597 +0200 +@@ -132,17 +132,17 @@ + entries(),entries()+size_, + entry(node),entry::less_by_node()); /* localize entry */ + ent->ordered=false; +- std::size_t n=ent->pos; /* get its position */ ++ std::size_t n_=ent->pos; /* get its position */ + + entry dummy(0); +- dummy.pile_top=n; ++ dummy.pile_top=n_; + + entry* pile_ent= /* find the first available pile */ + std::lower_bound( /* to stack the entry */ + entries(),entries()+num_piles, + dummy,entry::less_by_pile_top()); + +- pile_ent->pile_top=n; /* stack the entry */ ++ pile_ent->pile_top=n_; /* stack the entry */ + pile_ent->pile_top_entry=ent; + + /* if not the first pile, link entry to top of the preceding pile */ +@@ -164,7 +164,7 @@ + */ + + entry* ent=entries()[num_piles-1].pile_top_entry; +- for(std::size_t n=num_piles;n--;){ ++ for(std::size_t n_=num_piles;n_--;){ + ent->ordered=true; + ent=ent->previous; + } +--- boost/boost/multi_index/ordered_index.hpp 2010-07-25 12:44:55.000000000 +0200 ++++ boost/boost/multi_index/ordered_index.hpp 2013-05-17 15:33:42.785182819 +0200 +@@ -436,9 +436,9 @@ + + template + iterator find( +- const CompatibleKey& x,const CompatibleCompare& comp)const ++ const CompatibleKey& x,const CompatibleCompare& comp_)const + { +- return make_iterator(ordered_index_find(root(),header(),key,x,comp)); ++ return make_iterator(ordered_index_find(root(),header(),key,x,comp_)); + } + + template +@@ -448,9 +448,9 @@ + } + + template +- size_type count(const CompatibleKey& x,const CompatibleCompare& comp)const ++ size_type count(const CompatibleKey& x,const CompatibleCompare& comp_)const + { +- std::pair p=equal_range(x,comp); ++ std::pair p=equal_range(x,comp_); + size_type n=std::distance(p.first,p.second); + return n; + } +@@ -464,10 +464,10 @@ + + template + iterator lower_bound( +- const CompatibleKey& x,const CompatibleCompare& comp)const ++ const CompatibleKey& x,const CompatibleCompare& comp_)const + { + return make_iterator( +- ordered_index_lower_bound(root(),header(),key,x,comp)); ++ ordered_index_lower_bound(root(),header(),key,x,comp_)); + } + + template +@@ -479,10 +479,10 @@ + + template + iterator upper_bound( +- const CompatibleKey& x,const CompatibleCompare& comp)const ++ const CompatibleKey& x,const CompatibleCompare& comp_)const + { + return make_iterator( +- ordered_index_upper_bound(root(),header(),key,x,comp)); ++ ordered_index_upper_bound(root(),header(),key,x,comp_)); + } + + template +@@ -497,10 +497,10 @@ + + template + std::pair equal_range( +- const CompatibleKey& x,const CompatibleCompare& comp)const ++ const CompatibleKey& x,const CompatibleCompare& comp_)const + { + std::pair p= +- ordered_index_equal_range(root(),header(),key,x,comp); ++ ordered_index_equal_range(root(),header(),key,x,comp_); + return std::pair( + make_iterator(p.first),make_iterator(p.second)); + } +--- boost/boost/multi_index/sequenced_index.hpp 2008-07-03 18:51:53.000000000 +0200 ++++ boost/boost/multi_index/sequenced_index.hpp 2013-05-17 15:44:15.265289335 +0200 +@@ -346,7 +346,7 @@ + } + + template +- bool modify(iterator position,Modifier mod,Rollback back) ++ bool modify(iterator position,Modifier mod,Rollback back_) + { + BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position); + BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position); +@@ -363,7 +363,7 @@ + #endif + + return this->final_modify_( +- mod,back,static_cast(position.get_node())); ++ mod,back_,static_cast(position.get_node())); + } + + void swap(sequenced_index& x) +--- boost/boost/multi_index_container.hpp 2010-07-24 11:20:29.000000000 +0200 ++++ boost/boost/multi_index_container.hpp 2013-05-17 15:45:56.723899853 +0200 +@@ -360,7 +360,7 @@ + IteratorType it + BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) + { +- typedef typename nth_index::type index; ++ typedef typename nth_index::type index_; + + #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */ + BOOST_STATIC_ASSERT( +@@ -371,7 +371,7 @@ + BOOST_MULTI_INDEX_CHECK_IS_OWNER( + it,static_cast(*this)); + +- return index::make_iterator(static_cast(it.get_node())); ++ return index_::make_iterator(static_cast(it.get_node())); + } + + template +@@ -379,7 +379,7 @@ + IteratorType it + BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))const + { +- typedef typename nth_index::type index; ++ typedef typename nth_index::type index_; + + #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */ + BOOST_STATIC_ASSERT(( +@@ -390,7 +390,7 @@ + BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); + BOOST_MULTI_INDEX_CHECK_IS_OWNER( + it,static_cast(*this)); +- return index::make_iterator(static_cast(it.get_node())); ++ return index_::make_iterator(static_cast(it.get_node())); + } + #endif + +@@ -414,7 +414,7 @@ + IteratorType it + BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag)) + { +- typedef typename index::type index; ++ typedef typename index::type index_; + + #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */ + BOOST_STATIC_ASSERT( +@@ -424,7 +424,7 @@ + BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); + BOOST_MULTI_INDEX_CHECK_IS_OWNER( + it,static_cast(*this)); +- return index::make_iterator(static_cast(it.get_node())); ++ return index_::make_iterator(static_cast(it.get_node())); + } + + template +@@ -432,7 +432,7 @@ + IteratorType it + BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))const + { +- typedef typename index::type index; ++ typedef typename index::type index_; + + #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */ + BOOST_STATIC_ASSERT(( +@@ -443,7 +443,7 @@ + BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); + BOOST_MULTI_INDEX_CHECK_IS_OWNER( + it,static_cast(*this)); +- return index::make_iterator(static_cast(it.get_node())); ++ return index_::make_iterator(static_cast(it.get_node())); + } + #endif + +--- boost/boost/property_tree/detail/exception_implementation.hpp 2009-09-01 23:27:45.000000000 +0200 ++++ boost/boost/property_tree/detail/exception_implementation.hpp 2013-05-17 15:28:28.599529530 +0200 +@@ -30,8 +30,8 @@ + /////////////////////////////////////////////////////////////////////////// + // ptree_error + +- inline ptree_error::ptree_error(const std::string &what): +- std::runtime_error(what) ++ inline ptree_error::ptree_error(const std::string &what_): ++ std::runtime_error(what_) + { + } + +@@ -43,8 +43,8 @@ + // ptree_bad_data + + template inline +- ptree_bad_data::ptree_bad_data(const std::string &what, const D &data): +- ptree_error(what), m_data(data) ++ ptree_bad_data::ptree_bad_data(const std::string &what_, const D &data_): ++ ptree_error(what_), m_data(data_) + { + } + +@@ -62,8 +62,8 @@ + // ptree_bad_path + + template inline +- ptree_bad_path::ptree_bad_path(const std::string &what, const P &path): +- ptree_error(detail::prepare_bad_path_what(what, path)), m_path(path) ++ ptree_bad_path::ptree_bad_path(const std::string &what_, const P &path_): ++ ptree_error(detail::prepare_bad_path_what(what_, path_)), m_path(path_) + { + + } +--- boost/boost/property_tree/detail/file_parser_error.hpp 2009-09-01 23:27:45.000000000 +0200 ++++ boost/boost/property_tree/detail/file_parser_error.hpp 2013-05-17 15:36:01.615914822 +0200 +@@ -26,11 +26,11 @@ + // Construction & destruction + + // Construct error +- file_parser_error(const std::string &message, +- const std::string &filename, +- unsigned long line) : +- ptree_error(format_what(message, filename, line)), +- m_message(message), m_filename(filename), m_line(line) ++ file_parser_error(const std::string &message_, ++ const std::string &filename_, ++ unsigned long line_) : ++ ptree_error(format_what(message_, filename_, line_)), ++ m_message(message_), m_filename(filename_), m_line(line_) + { + } + +@@ -69,20 +69,20 @@ + unsigned long m_line; + + // Format error message to be returned by std::runtime_error::what() +- std::string format_what(const std::string &message, +- const std::string &filename, +- unsigned long line) ++ std::string format_what(const std::string &message_, ++ const std::string &filename_, ++ unsigned long line_) + { + std::stringstream stream; +- if (line > 0) +- stream << (filename.empty() ? "" +- : filename.c_str()) +- << '(' << line << "): " +- << message; ++ if (line_ > 0) ++ stream << (filename_.empty() ? "" ++ : filename_.c_str()) ++ << '(' << line_ << "): " ++ << message_; + else +- stream << (filename.empty() ? "" +- : filename.c_str()) +- << ": " << message; ++ stream << (filename_.empty() ? "" ++ : filename_.c_str()) ++ << ": " << message_; + return stream.str(); + } + +--- boost/boost/property_tree/detail/json_parser_error.hpp 2007-05-13 00:02:53.000000000 +0200 ++++ boost/boost/property_tree/detail/json_parser_error.hpp 2013-05-17 15:36:44.605902442 +0200 +@@ -20,10 +20,10 @@ + class json_parser_error: public file_parser_error + { + public: +- json_parser_error(const std::string &message, +- const std::string &filename, +- unsigned long line): +- file_parser_error(message, filename, line) ++ json_parser_error(const std::string &message_, ++ const std::string &filename_, ++ unsigned long line_): ++ file_parser_error(message_, filename_, line_) + { + } + }; +--- boost/boost/property_tree/detail/json_parser_read.hpp 2013-05-17 15:57:23.740638395 +0200 ++++ boost/boost/property_tree/detail/json_parser_read.hpp 2013-05-17 15:31:05.666857356 +0200 +@@ -45,7 +45,7 @@ + struct a_object_s + { + context &c; +- a_object_s(context &c): c(c) { } ++ a_object_s(context &c_): c(c_) { } + void operator()(Ch) const + { + if (c.stack.empty()) +@@ -63,7 +63,7 @@ + struct a_object_e + { + context &c; +- a_object_e(context &c): c(c) { } ++ a_object_e(context &c_): c(c_) { } + void operator()(Ch) const + { + BOOST_ASSERT(c.stack.size() >= 1); +@@ -74,7 +74,7 @@ + struct a_name + { + context &c; +- a_name(context &c): c(c) { } ++ a_name(context &c_): c(c_) { } + void operator()(It, It) const + { + c.name.swap(c.string); +@@ -85,7 +85,7 @@ + struct a_string_val + { + context &c; +- a_string_val(context &c): c(c) { } ++ a_string_val(context &c_): c(c_) { } + void operator()(It, It) const + { + BOOST_ASSERT(c.stack.size() >= 1); +@@ -98,7 +98,7 @@ + struct a_literal_val + { + context &c; +- a_literal_val(context &c): c(c) { } ++ a_literal_val(context &c_): c(c_) { } + void operator()(It b, It e) const + { + BOOST_ASSERT(c.stack.size() >= 1); +@@ -111,8 +111,8 @@ + struct a_char + { + context &c; +- a_char(context &c): c(c) { } +- void operator()(It b, It e) const ++ a_char(context &c_): c(c_) { } ++ void operator()(It b, It /* e */) const + { + c.string += *b; + } +@@ -121,7 +121,7 @@ + struct a_escape + { + context &c; +- a_escape(context &c): c(c) { } ++ a_escape(context &c_): c(c_) { } + void operator()(Ch ch) const + { + switch (ch) +@@ -142,7 +142,7 @@ + struct a_unicode + { + context &c; +- a_unicode(context &c): c(c) { } ++ a_unicode(context &c_): c(c_) { } + void operator()(unsigned long u) const + { + u = (std::min)(u, static_cast((std::numeric_limits::max)())); +--- boost/boost/property_tree/detail/ptree_implementation.hpp 2010-07-03 22:59:45.000000000 +0200 ++++ boost/boost/property_tree/detail/ptree_implementation.hpp 2013-05-17 15:55:56.449713452 +0200 +@@ -183,8 +183,8 @@ + } + + template inline +- basic_ptree::basic_ptree(const data_type &data) +- : m_data(data), m_children(new typename subs::base_container) ++ basic_ptree::basic_ptree(const data_type &data_) ++ : m_data(data_), m_children(new typename subs::base_container) + { + } + +@@ -539,48 +539,48 @@ + + template + basic_ptree & +- basic_ptree::get_child(const path_type &path) ++ basic_ptree::get_child(const path_type &path_) + { +- path_type p(path); ++ path_type p(path_); + self_type *n = walk_path(p); + if (!n) { +- BOOST_PROPERTY_TREE_THROW(ptree_bad_path("No such node", path)); ++ BOOST_PROPERTY_TREE_THROW(ptree_bad_path("No such node", path_)); + } + return *n; + } + + template inline + const basic_ptree & +- basic_ptree::get_child(const path_type &path) const ++ basic_ptree::get_child(const path_type &path_) const + { +- return const_cast(this)->get_child(path); ++ return const_cast(this)->get_child(path_); + } + + template inline + basic_ptree & +- basic_ptree::get_child(const path_type &path, ++ basic_ptree::get_child(const path_type &path_, + self_type &default_value) + { +- path_type p(path); ++ path_type p(path_); + self_type *n = walk_path(p); + return n ? *n : default_value; + } + + template inline + const basic_ptree & +- basic_ptree::get_child(const path_type &path, ++ basic_ptree::get_child(const path_type &path_, + const self_type &default_value) const + { +- return const_cast(this)->get_child(path, ++ return const_cast(this)->get_child(path_, + const_cast(default_value)); + } + + + template + optional &> +- basic_ptree::get_child_optional(const path_type &path) ++ basic_ptree::get_child_optional(const path_type &path_) + { +- path_type p(path); ++ path_type p(path_); + self_type *n = walk_path(p); + if (!n) { + return optional(); +@@ -590,9 +590,9 @@ + + template + optional &> +- basic_ptree::get_child_optional(const path_type &path) const ++ basic_ptree::get_child_optional(const path_type &path_) const + { +- path_type p(path); ++ path_type p(path_); + self_type *n = walk_path(p); + if (!n) { + return optional(); +@@ -602,10 +602,10 @@ + + template + basic_ptree & +- basic_ptree::put_child(const path_type &path, ++ basic_ptree::put_child(const path_type &path_, + const self_type &value) + { +- path_type p(path); ++ path_type p(path_); + self_type &parent = force_path(p); + // Got the parent. Now get the correct child. + key_type fragment = p.reduce(); +@@ -620,10 +620,10 @@ + + template + basic_ptree & +- basic_ptree::add_child(const path_type &path, ++ basic_ptree::add_child(const path_type &path_, + const self_type &value) + { +- path_type p(path); ++ path_type p(path_); + self_type &parent = force_path(p); + // Got the parent. + key_type fragment = p.reduce(); +@@ -709,26 +709,26 @@ + template + template inline + typename boost::enable_if, Type>::type +- basic_ptree::get(const path_type &path, ++ basic_ptree::get(const path_type &path_, + Translator tr) const + { +- return get_child(path).BOOST_NESTED_TEMPLATE get_value(tr); ++ return get_child(path_).BOOST_NESTED_TEMPLATE get_value(tr); + } + + template + template inline +- Type basic_ptree::get(const path_type &path) const ++ Type basic_ptree::get(const path_type &path_) const + { +- return get_child(path).BOOST_NESTED_TEMPLATE get_value(); ++ return get_child(path_).BOOST_NESTED_TEMPLATE get_value(); + } + + template + template inline +- Type basic_ptree::get(const path_type &path, ++ Type basic_ptree::get(const path_type &path_, + const Type &default_value, + Translator tr) const + { +- return get_optional(path, tr).get_value_or(default_value); ++ return get_optional(path_, tr).get_value_or(default_value); + } + + template +@@ -738,18 +738,18 @@ + std::basic_string + >::type + basic_ptree::get( +- const path_type &path, const Ch *default_value, Translator tr) const ++ const path_type &path_, const Ch *default_value, Translator tr) const + { +- return get, Translator>(path, default_value, tr); ++ return get, Translator>(path_, default_value, tr); + } + + template + template inline + typename boost::disable_if, Type>::type +- basic_ptree::get(const path_type &path, ++ basic_ptree::get(const path_type &path_, + const Type &default_value) const + { +- return get_optional(path).get_value_or(default_value); ++ return get_optional(path_).get_value_or(default_value); + } + + template +@@ -759,17 +759,17 @@ + std::basic_string + >::type + basic_ptree::get( +- const path_type &path, const Ch *default_value) const ++ const path_type &path_, const Ch *default_value) const + { +- return get< std::basic_string >(path, default_value); ++ return get< std::basic_string >(path_, default_value); + } + + template + template +- optional basic_ptree::get_optional(const path_type &path, ++ optional basic_ptree::get_optional(const path_type &path_, + Translator tr) const + { +- if (optional child = get_child_optional(path)) ++ if (optional child = get_child_optional(path_)) + return child.get().BOOST_NESTED_TEMPLATE get_value_optional(tr); + else + return optional(); +@@ -778,9 +778,9 @@ + template + template + optional basic_ptree::get_optional( +- const path_type &path) const ++ const path_type &path_) const + { +- if (optional child = get_child_optional(path)) ++ if (optional child = get_child_optional(path_)) + return child.get().BOOST_NESTED_TEMPLATE get_value_optional(); + else + return optional(); +@@ -809,13 +809,13 @@ + template + template + basic_ptree & basic_ptree::put( +- const path_type &path, const Type &value, Translator tr) ++ const path_type &path_, const Type &value, Translator tr) + { +- if(optional child = get_child_optional(path)) { ++ if(optional child = get_child_optional(path_)) { + child.get().put_value(value, tr); + return *child; + } else { +- self_type &child2 = put_child(path, self_type()); ++ self_type &child2 = put_child(path_, self_type()); + child2.put_value(value, tr); + return child2; + } +@@ -824,18 +824,18 @@ + template + template inline + basic_ptree & basic_ptree::put( +- const path_type &path, const Type &value) ++ const path_type &path_, const Type &value) + { +- return put(path, value, ++ return put(path_, value, + typename translator_between::type()); + } + + template + template inline + basic_ptree & basic_ptree::add( +- const path_type &path, const Type &value, Translator tr) ++ const path_type &path_, const Type &value, Translator tr) + { +- self_type &child = add_child(path, self_type()); ++ self_type &child = add_child(path_, self_type()); + child.put_value(value, tr); + return child; + } +@@ -843,9 +843,9 @@ + template + template inline + basic_ptree & basic_ptree::add( +- const path_type &path, const Type &value) ++ const path_type &path_, const Type &value) + { +- return add(path, value, ++ return add(path_, value, + typename translator_between::type()); + } + +--- boost/boost/serialization/collection_size_type.hpp 2010-07-09 18:50:03.000000000 +0200 ++++ boost/boost/serialization/collection_size_type.hpp 2013-05-17 15:40:32.789528782 +0200 +@@ -37,7 +37,7 @@ + return *this; + } + // used for text output +- operator const base_type () const { ++ operator base_type () const { + return t; + } + // used for text input +--- boost/boost/spirit/home/classic/error_handling/exceptions.hpp 2013-05-17 15:57:23.722638823 +0200 ++++ boost/boost/spirit/home/classic/error_handling/exceptions.hpp 2013-05-17 15:26:32.319247352 +0200 +@@ -126,8 +126,8 @@ + typedef unary > base_t; + typedef unary_parser_category parser_category_t; + +- assertive_parser(ParserT const& parser, ErrorDescrT descriptor_) +- : base_t(parser), descriptor(descriptor_) {} ++ assertive_parser(ParserT const& parser_, ErrorDescrT descriptor_) ++ : base_t(parser_), descriptor(descriptor_) {} + + template + struct result -- cgit