Rename identifiers named `__output`

[arichardson]

Summary

In the CHERI clang compiler output and input are keywords and therefore
we can't compile libc++ with our compiler.

[EricWF]

LGTM minus inline comments.

test/support/nasty_macros.hpp

55

Shouldn't these not be defined when running the tests with a CHER compiler? Otherwise the macro will conflict with the keyword?

[arichardson]

test/support/nasty_macros.hpp

55

It isn't being used anywhere in libcxx so that should be fine. The tests are still working for me since it doesn't seem like we are compiling with -Werror=reserved-id-macro.

include/algorithm

#endif
     }
 }
 #endif
 
 template <class _PopulationIterator, class _SampleIterator, class _Distance,
           class _UniformRandomNumberGenerator>
 _LIBCPP_INLINE_VISIBILITY
 _SampleIterator __sample(_PopulationIterator __first,
-                         _PopulationIterator __last, _SampleIterator __output,
+                         _PopulationIterator __last, _SampleIterator __output_iter,
                          _Distance __n,
                          _UniformRandomNumberGenerator & __g,
                          input_iterator_tag) {
 
   _Distance __k = 0;
   for (; __first != __last && __k < __n; ++__first, (void)++__k)
-    __output[__k] = *__first;
+    __output_iter[__k] = *__first;
   _Distance __sz = __k;
   for (; __first != __last; ++__first, (void)++__k) {
     _Distance __r = _VSTD::uniform_int_distribution<_Distance>(0, __k)(__g);
     if (__r < __sz)
-      __output[__r] = *__first;
+      __output_iter[__r] = *__first;
   }
-  return __output + _VSTD::min(__n, __k);
+  return __output_iter + _VSTD::min(__n, __k);
 }
 
 template <class _PopulationIterator, class _SampleIterator, class _Distance,
           class _UniformRandomNumberGenerator>
 _LIBCPP_INLINE_VISIBILITY
 _SampleIterator __sample(_PopulationIterator __first,
-                         _PopulationIterator __last, _SampleIterator __output,
+                         _PopulationIterator __last, _SampleIterator __output_iter,
                          _Distance __n,
                          _UniformRandomNumberGenerator& __g,
                          forward_iterator_tag) {
   _Distance __unsampled_sz = _VSTD::distance(__first, __last);
   for (__n = _VSTD::min(__n, __unsampled_sz); __n != 0; ++__first) {
     _Distance __r =
         _VSTD::uniform_int_distribution<_Distance>(0, --__unsampled_sz)(__g);
     if (__r < __n) {
-      *__output++ = *__first;
+      *__output_iter++ = *__first;
       --__n;
     }
   }
-  return __output;
+  return __output_iter;
 }
 
 template <class _PopulationIterator, class _SampleIterator, class _Distance,
           class _UniformRandomNumberGenerator>
 _LIBCPP_INLINE_VISIBILITY
 _SampleIterator __sample(_PopulationIterator __first,
-                         _PopulationIterator __last, _SampleIterator __output,
+                         _PopulationIterator __last, _SampleIterator __output_iter,
                          _Distance __n, _UniformRandomNumberGenerator& __g) {
   typedef typename iterator_traits<_PopulationIterator>::iterator_category
         _PopCategory;
   typedef typename iterator_traits<_PopulationIterator>::difference_type
         _Difference;
   static_assert(__is_forward_iterator<_PopulationIterator>::value ||
                 __is_random_access_iterator<_SampleIterator>::value,
                 "SampleIterator must meet the requirements of RandomAccessIterator");
   typedef typename common_type<_Distance, _Difference>::type _CommonType;
   _LIBCPP_ASSERT(__n >= 0, "N must be a positive number.");
   return _VSTD::__sample(
-      __first, __last, __output, _CommonType(__n),
+      __first, __last, __output_iter, _CommonType(__n),
       __g, _PopCategory());
 }
 
 #if _LIBCPP_STD_VER > 14
 template <class _PopulationIterator, class _SampleIterator, class _Distance,
           class _UniformRandomNumberGenerator>
 inline _LIBCPP_INLINE_VISIBILITY
 _SampleIterator sample(_PopulationIterator __first,
-                       _PopulationIterator __last, _SampleIterator __output,
+                       _PopulationIterator __last, _SampleIterator __output_iter,
                        _Distance __n, _UniformRandomNumberGenerator&& __g) {
-    return _VSTD::__sample(__first, __last, __output, __n, __g);
+    return _VSTD::__sample(__first, __last, __output_iter, __n, __g);
 }
 #endif // _LIBCPP_STD_VER > 14
 
 template<class _RandomAccessIterator, class _UniformRandomNumberGenerator>
     void shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
 #ifndef _LIBCPP_CXX03_LANG
                  _UniformRandomNumberGenerator&& __g)
 #else

include/experimental/algorithm

 _ForwardIterator search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher &__s)
 { return __s(__f, __l).first; }
 
 
 template <class _PopulationIterator, class _SampleIterator, class _Distance,
           class _UniformRandomNumberGenerator>
 inline _LIBCPP_INLINE_VISIBILITY
 _SampleIterator sample(_PopulationIterator __first, _PopulationIterator __last,
-                       _SampleIterator __output, _Distance __n,
+                       _SampleIterator __output_iter, _Distance __n,
                        _UniformRandomNumberGenerator &&__g) {
-  return _VSTD::__sample(__first, __last, __output, __n, __g);
+  return _VSTD::__sample(__first, __last, __output_iter, __n, __g);
 }
 
 _LIBCPP_END_NAMESPACE_LFTS
 
 _LIBCPP_POP_MACROS
 
 #endif /* _LIBCPP_EXPERIMENTAL_ALGORITHM */

include/experimental/iterator

public:
     typedef basic_ostream<char_type,traits_type> ostream_type;
     typedef output_iterator_tag                  iterator_category;
     typedef void                                 value_type;
     typedef void                                 difference_type;
     typedef void                                 pointer;
     typedef void                                 reference;
 
     ostream_joiner(ostream_type& __os, _Delim&& __d)
-        : __output(_VSTD::addressof(__os)), __delim(_VSTD::move(__d)), __first(true) {}
+        : __output_iter(_VSTD::addressof(__os)), __delim(_VSTD::move(__d)), __first(true) {}
         
     ostream_joiner(ostream_type& __os, const _Delim& __d)
-        : __output(_VSTD::addressof(__os)), __delim(__d), __first(true) {}
+        : __output_iter(_VSTD::addressof(__os)), __delim(__d), __first(true) {}
     
 
     template<typename _Tp>
     ostream_joiner& operator=(const _Tp& __v)
     {
         if (!__first)
-            *__output << __delim;
+            *__output_iter << __delim;
         __first = false;
-        *__output << __v;
+        *__output_iter << __v;
         return *this;
     }
 
     ostream_joiner& operator*()     _NOEXCEPT { return *this; }
     ostream_joiner& operator++()    _NOEXCEPT { return *this; }
     ostream_joiner& operator++(int) _NOEXCEPT { return *this; }
 
 private:
-    ostream_type*   __output;
+    ostream_type*   __output_iter;
     _Delim          __delim;
     bool            __first;
 };
 
 
 template <class _CharT, class _Traits, class _Delim>
 ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits>
 make_ostream_joiner(basic_ostream<_CharT, _Traits>& __os, _Delim && __d)
 { return ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits>(__os, _VSTD::forward<_Delim>(__d)); }
 
 _LIBCPP_END_NAMESPACE_LFTS
 
 #endif /* _LIBCPP_STD_VER > 11 */
 
 #endif // _LIBCPP_EXPERIMENTAL_ITERATOR

include/regex

//    ~match_results() = default;
     _LIBCPP_INLINE_VISIBILITY
     const_iterator cbegin() const {return empty() ? __matches_.end() : __matches_.begin();}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator cend() const {return __matches_.end();}
 
     // format:
     template <class _OutputIter>
         _OutputIter
-        format(_OutputIter __output, const char_type* __fmt_first,
+        format(_OutputIter __output_iter, const char_type* __fmt_first,
                const char_type* __fmt_last,
                regex_constants::match_flag_type __flags = regex_constants::format_default) const;
     template <class _OutputIter, class _ST, class _SA>
         _LIBCPP_INLINE_VISIBILITY
         _OutputIter
-        format(_OutputIter __output, const basic_string<char_type, _ST, _SA>& __fmt,
+        format(_OutputIter __output_iter, const basic_string<char_type, _ST, _SA>& __fmt,
                regex_constants::match_flag_type __flags = regex_constants::format_default) const
-            {return format(__output, __fmt.data(), __fmt.data() + __fmt.size(), __flags);}
+            {return format(__output_iter, __fmt.data(), __fmt.data() + __fmt.size(), __flags);}
     template <class _ST, class _SA>
         _LIBCPP_INLINE_VISIBILITY
         basic_string<char_type, _ST, _SA>
         format(const basic_string<char_type, _ST, _SA>& __fmt,
                regex_constants::match_flag_type __flags = regex_constants::format_default) const
         {
             basic_string<char_type, _ST, _SA> __r;
             format(back_inserter(__r), __fmt.data(), __fmt.data() + __fmt.size(),
match_results<_BidirectionalIterator, _Allocator>::__init(unsigned __s,
     if (!__no_update_pos)
         __position_start_ = __prefix_.first;
     __ready_ = true;
 }
 
 template <class _BidirectionalIterator, class _Allocator>
 template <class _OutputIter>
 _OutputIter
-match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __output,
+match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __output_iter,
         const char_type* __fmt_first, const char_type* __fmt_last,
         regex_constants::match_flag_type __flags) const
 {
     if (__flags & regex_constants::format_sed)
     {
         for (; __fmt_first != __fmt_last; ++__fmt_first)
         {
             if (*__fmt_first == '&')
-                __output = _VSTD::copy(__matches_[0].first, __matches_[0].second,
-                                   __output);
+                __output_iter = _VSTD::copy(__matches_[0].first, __matches_[0].second,
+                                   __output_iter);
             else if (*__fmt_first == '\\' && __fmt_first + 1 != __fmt_last)
             {
                 ++__fmt_first;
                 if ('0' <= *__fmt_first && *__fmt_first <= '9')
                 {
                     size_t __i = *__fmt_first - '0';
-                    __output = _VSTD::copy((*this)[__i].first,
-                                        (*this)[__i].second, __output);
+                    __output_iter = _VSTD::copy((*this)[__i].first,
+                                        (*this)[__i].second, __output_iter);
                 }
                 else
                 {
-                    *__output = *__fmt_first;
-                    ++__output;
+                    *__output_iter = *__fmt_first;
+                    ++__output_iter;
                 }
             }
             else
             {
-                *__output = *__fmt_first;
-                ++__output;
+                *__output_iter = *__fmt_first;
+                ++__output_iter;
             }
         }
     }
     else
     {
         for (; __fmt_first != __fmt_last; ++__fmt_first)
         {
             if (*__fmt_first == '$' && __fmt_first + 1 != __fmt_last)
             {
                 switch (__fmt_first[1])
                 {
                 case '$':
-                    *__output = *++__fmt_first;
-                    ++__output;
+                    *__output_iter = *++__fmt_first;
+                    ++__output_iter;
                     break;
                 case '&':
                     ++__fmt_first;
-                    __output = _VSTD::copy(__matches_[0].first, __matches_[0].second,
-                                       __output);
+                    __output_iter = _VSTD::copy(__matches_[0].first, __matches_[0].second,
+                                       __output_iter);
                     break;
                 case '`':
                     ++__fmt_first;
-                    __output = _VSTD::copy(__prefix_.first, __prefix_.second, __output);
+                    __output_iter = _VSTD::copy(__prefix_.first, __prefix_.second, __output_iter);
                     break;
                 case '\'':
                     ++__fmt_first;
-                    __output = _VSTD::copy(__suffix_.first, __suffix_.second, __output);
+                    __output_iter = _VSTD::copy(__suffix_.first, __suffix_.second, __output_iter);
                     break;
                 default:
                     if ('0' <= __fmt_first[1] && __fmt_first[1] <= '9')
                     {
                         ++__fmt_first;
                         size_t __idx = *__fmt_first - '0';
                         if (__fmt_first + 1 != __fmt_last &&
                             '0' <= __fmt_first[1] && __fmt_first[1] <= '9')
                         {
                             ++__fmt_first;
                             if (__idx >= std::numeric_limits<size_t>::max() / 10)
                                 __throw_regex_error<regex_constants::error_escape>();
                             __idx = 10 * __idx + *__fmt_first - '0';
                         }
-                        __output = _VSTD::copy((*this)[__idx].first,
-                                            (*this)[__idx].second, __output);
+                        __output_iter = _VSTD::copy((*this)[__idx].first,
+                                            (*this)[__idx].second, __output_iter);
                     }
                     else
                     {
-                        *__output = *__fmt_first;
-                        ++__output;
+                        *__output_iter = *__fmt_first;
+                        ++__output_iter;
                     }
                     break;
                 }
             }
             else
             {
-                *__output = *__fmt_first;
-                ++__output;
+                *__output_iter = *__fmt_first;
+                ++__output_iter;
             }
         }
     }
-    return __output;
+    return __output_iter;
 }
 
 template <class _BidirectionalIterator, class _Allocator>
 void
 match_results<_BidirectionalIterator, _Allocator>::swap(match_results& __m)
 {
     using _VSTD::swap;
     swap(__matches_, __m.__matches_);

 typedef regex_token_iterator<string::const_iterator>  sregex_token_iterator;
 typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
 
 // regex_replace
 
 template <class _OutputIterator, class _BidirectionalIterator,
           class _Traits, class _CharT>
 _OutputIterator
-regex_replace(_OutputIterator __output,
+regex_replace(_OutputIterator __output_iter,
               _BidirectionalIterator __first, _BidirectionalIterator __last,
               const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Iter;
     _Iter __i(__first, __last, __e, __flags);
     _Iter __eof;
     if (__i == __eof)
     {
         if (!(__flags & regex_constants::format_no_copy))
-            __output = _VSTD::copy(__first, __last, __output);
+            __output_iter = _VSTD::copy(__first, __last, __output_iter);
     }
     else
     {
         sub_match<_BidirectionalIterator> __lm;
         for (size_t __len = char_traits<_CharT>::length(__fmt); __i != __eof; ++__i)
         {
             if (!(__flags & regex_constants::format_no_copy))
-                __output = _VSTD::copy(__i->prefix().first, __i->prefix().second, __output);
-            __output = __i->format(__output, __fmt, __fmt + __len, __flags);
+                __output_iter = _VSTD::copy(__i->prefix().first, __i->prefix().second, __output_iter);
+            __output_iter = __i->format(__output_iter, __fmt, __fmt + __len, __flags);
             __lm = __i->suffix();
             if (__flags & regex_constants::format_first_only)
                 break;
         }
         if (!(__flags & regex_constants::format_no_copy))
-            __output = _VSTD::copy(__lm.first, __lm.second, __output);
+            __output_iter = _VSTD::copy(__lm.first, __lm.second, __output_iter);
     }
-    return __output;
+    return __output_iter;
 }
 
 template <class _OutputIterator, class _BidirectionalIterator,
           class _Traits, class _CharT, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
-regex_replace(_OutputIterator __output,
+regex_replace(_OutputIterator __output_iter,
               _BidirectionalIterator __first, _BidirectionalIterator __last,
               const basic_regex<_CharT, _Traits>& __e,
               const basic_string<_CharT, _ST, _SA>& __fmt,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
-    return _VSTD::regex_replace(__output, __first, __last, __e, __fmt.c_str(), __flags);
+    return _VSTD::regex_replace(__output_iter, __first, __last, __e, __fmt.c_str(), __flags);
 }
 
 template <class _Traits, class _CharT, class _ST, class _SA, class _FST,
           class _FSA>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _ST, _SA>
 regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
               const basic_regex<_CharT, _Traits>& __e,

test/support/nasty_macros.hpp

 
 // Test that libc++ doesn't use names reserved by WIN32 API Macros.
 // NOTE: Obviously we can only define these on non-windows platforms.
 #ifndef _WIN32
 #define __deallocate NASTY_MACRO
 #define __out NASTY_MACRO
 #endif
 
+#define __output NASTY_MACRO
+#define __input NASTY_MACRO
+
 #endif // SUPPORT_NASTY_MACROS_HPP