--- /dev/null
+/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+/* { dg-require-effective-target c++11 } */
+/* { dg-options "-O3 -fnon-call-exceptions -ftracer -march=k8 -Wno-return-type" } */
+
+
+template <int __v> struct integral_constant {
+
+ static constexpr int value = __v;
+
+};
+
+template <bool __v> using __bool_constant = integral_constant<__v>;
+
+template <typename _Tp, typename _Up>
+
+struct is_same : integral_constant<true> {};
+
+template <bool, typename _Tp> using __enable_if_t = _Tp;
+
+void *operator new(unsigned long, void *__p) { return __p; }
+
+template <typename _Iterator, typename> class __normal_iterator {
+
+ _Iterator _M_current;
+
+
+
+public:
+
+ __normal_iterator(_Iterator) {}
+
+ void operator++() { ++_M_current; }
+
+ _Iterator base() { return _M_current; }
+
+};
+
+template <typename _IteratorL, typename _IteratorR, typename _Container>
+
+bool operator!=(__normal_iterator<_IteratorL, _Container> __lhs,
+
+ __normal_iterator<_IteratorR, _Container> __rhs) {
+
+ return __lhs.base() != __rhs.base();
+
+}
+
+template <typename _Tp> void construct_at(_Tp *__location) noexcept {
+
+ new (__location) _Tp;
+
+}
+
+template <typename _Tp> void _Construct(_Tp __p) { construct_at(__p); }
+
+struct _Any_data {
+
+ template <typename _Tp> _Tp _M_access();
+
+};
+
+enum _Manager_operation {};
+
+template <typename> class function;
+
+class _Function_base {
+
+public:
+
+ template <typename _Functor> class _Base_manager {
+
+public:
+
+ static bool _M_manager(_Any_data, _Any_data __source, _Manager_operation) {
+
+ _Functor(*__source._M_access<_Functor *>());
+
+ return true;
+
+ }
+
+ };
+
+ typedef bool (*_Manager_type)(_Any_data &, const _Any_data &,
+
+ _Manager_operation);
+
+ _Manager_type _M_manager;
+
+};
+
+template <typename, typename> class _Function_handler;
+
+template <typename _Res, typename _Functor, typename... _ArgTypes>
+
+class _Function_handler<_Res(_ArgTypes...), _Functor> : _Function_base {
+
+public:
+
+ static bool _M_manager(_Any_data &__dest, const _Any_data &__source,
+
+ _Manager_operation __op) {
+
+ _Base_manager<_Functor>::_M_manager(__dest, __source, __op);
+
+ }
+
+};
+
+template <typename _Res, typename... _ArgTypes>
+
+class function<_Res(_ArgTypes...)> : _Function_base {
+
+ template <typename, typename _Tp> using _Requires = _Tp;
+
+
+
+public:
+
+ template <typename _Functor,
+
+ typename = _Requires<__bool_constant<!bool()>, void>,
+
+ typename = _Requires<_Functor, void>>
+
+ function(_Functor);
+
+};
+
+template <typename _Res, typename... _ArgTypes>
+
+template <typename _Functor, typename, typename>
+
+function<_Res(_ArgTypes...)>::function(_Functor) {
+
+ _M_manager = _Function_handler<_Res(), _Functor>::_M_manager;
+
+}
+
+template <typename _Tp> class new_allocator {
+
+public:
+
+ _Tp *allocate(long) { return static_cast<_Tp *>(operator new(sizeof(_Tp))); }
+
+};
+
+namespace std {
+
+ template <typename> struct allocator_traits;
+
+ template <typename _Tp> struct allocator_traits<new_allocator<_Tp>> {
+
+ using allocator_type = new_allocator<_Tp>;
+
+ using pointer = _Tp *;
+
+ using const_pointer = _Tp *;
+
+ using size_type = long;
+
+ template <typename _Up> using rebind_alloc = new_allocator<_Up>;
+
+ static pointer allocate(allocator_type __a, size_type __n) {
+
+ return __a.allocate(__n);
+
+ }
+
+ static void deallocate(allocator_type, pointer, size_type);
+
+ };
+
+}
+
+template <typename _Alloc>
+
+struct __alloc_traits : std::allocator_traits<_Alloc> {
+
+ template <typename _Tp> struct rebind {
+
+ typedef typename std::allocator_traits<_Alloc>::template rebind_alloc<_Tp> other;
+
+ };
+
+};
+
+namespace std {
+
+ struct __uninitialized_copy {
+
+ template <typename _InputIterator, typename _ForwardIterator>
+
+ static _ForwardIterator __uninit_copy(_InputIterator __first,
+
+ _InputIterator __last,
+
+ _ForwardIterator __result) {
+
+ for (; __first != __last; ++__first, ++__result)
+
+ _Construct(__result);
+
+ return __result;
+
+ }
+
+ };
+
+ template <typename _InputIterator, typename _ForwardIterator>
+
+ _ForwardIterator uninitialized_copy(_InputIterator __first,
+
+ _InputIterator __last,
+
+ _ForwardIterator __result) {
+
+ return __uninitialized_copy::__uninit_copy(__first, __last, __result);
+
+ }
+
+ template <typename _InputIterator, typename _ForwardIterator, typename _Tp>
+
+ _ForwardIterator __uninitialized_copy_a(_InputIterator __first,
+
+ _InputIterator __last,
+
+ _ForwardIterator __result, _Tp) {
+
+ return uninitialized_copy(__first, __last, __result);
+
+ }
+
+ template <typename _Tp, typename _Alloc> struct _Vector_base {
+
+ typedef typename __alloc_traits<_Alloc>::template rebind<_Tp>::other _Tp_alloc_type;
+
+ typedef typename __alloc_traits<_Tp_alloc_type>::pointer pointer;
+
+ struct _Vector_impl_data {
+
+ pointer _M_start;
+
+ pointer _M_finish;
+
+ };
+
+ struct _Vector_impl : _Tp_alloc_type, _Vector_impl_data {};
+
+ _Tp_alloc_type _M_get_Tp_allocator();
+
+ _Vector_base(long, _Alloc) {
+
+ _M_impl._M_start = _M_allocate();
+
+ _M_impl._M_finish = _M_impl._M_start;
+
+ }
+
+ ~_Vector_base() { _M_deallocate(_M_impl._M_start); }
+
+ _Vector_impl _M_impl;
+
+ long _M_allocate___n;
+
+ pointer _M_allocate() {
+
+ typedef __alloc_traits<_Tp_alloc_type> _Tr;
+
+ return _M_allocate___n ? _Tr::allocate(_M_impl, _M_allocate___n)
+
+ : pointer();
+
+ }
+
+ long _M_deallocate___n;
+
+ void _M_deallocate(pointer __p) {
+
+ typedef __alloc_traits<_Tp_alloc_type> _Tr;
+
+ if (__p)
+
+ _Tr::deallocate(_M_impl, __p, _M_deallocate___n);
+
+ }
+
+ };
+
+ template <typename _Tp, typename _Alloc = new_allocator<_Tp>>
+
+ class vector : _Vector_base<_Tp, _Alloc> {
+
+ typedef _Vector_base<_Tp, _Alloc> _Base;
+
+ typedef __normal_iterator<
+
+ typename __alloc_traits<typename _Base::_Tp_alloc_type>::const_pointer,
+
+ int>
+
+ const_iterator;
+
+ using _Base::_M_get_Tp_allocator;
+
+
+
+public:
+
+ vector();
+
+ vector(vector &__x) : _Base(0, _M_get_Tp_allocator()) {
+
+ this->_M_impl._M_finish = __uninitialized_copy_a(__x.begin(), __x.end(),
+
+ this->_M_impl._M_start, 0);
+
+ }
+
+ const_iterator begin() noexcept { return this->_M_impl._M_start; }
+
+ const_iterator end() noexcept { return this->_M_impl._M_finish; }
+
+ };
+
+ template <typename _Tp> class __shared_ptr_access {
+
+public:
+
+ using element_type = _Tp;
+
+ element_type *operator->();
+
+ };
+
+ enum syntax_option_type : int;
+
+ template <typename> using _Matcher = function<bool()>;
+
+ struct _NFA {
+
+ void _M_insert_matcher(_Matcher<int>);
+
+ };
+
+ template <typename _TraitsT> class _Compiler {
+
+public:
+
+ typedef typename _TraitsT::char_type *_IterT;
+
+ _Compiler(_IterT, _IterT, const typename _TraitsT::locale_type &, syntax_option_type);
+
+ template <bool> void _M_insert_character_class_matcher();
+
+ syntax_option_type _M_flags;
+
+ __shared_ptr_access<_NFA> _M_nfa;
+
+ _TraitsT _M_traits;
+
+ };
+
+ template <typename, typename>
+
+ using __enable_if_contiguous_iter =
+
+ __enable_if_t<integral_constant<false>::value,
+
+ __shared_ptr_access<_NFA>>;
+
+ syntax_option_type __compile_nfa___flags;
+
+ struct Trans_NS___cxx11_regex_traits {
+
+ typedef char char_type;
+
+ typedef int locale_type;
+
+ struct _RegexMask {
+
+ short _M_base;
+
+ char _M_extended;
+
+ _RegexMask() : _M_extended() {}
+
+ } typedef char_class_type;
+
+ };
+
+ template <typename _FwdIter>
+
+ __enable_if_contiguous_iter<_FwdIter, char> __compile_nfa(_FwdIter) {
+
+ auto __cfirst = nullptr;
+
+ using _Cmplr = _Compiler<Trans_NS___cxx11_regex_traits>;
+
+ _Cmplr(__cfirst, __cfirst, 0, __compile_nfa___flags);
+
+ }
+
+ class _RegexTranslatorBase {
+
+public:
+
+ _RegexTranslatorBase(Trans_NS___cxx11_regex_traits);
+
+ };
+
+ class _RegexTranslator : _RegexTranslatorBase {
+
+ typedef _RegexTranslatorBase _Base;
+
+ using _Base::_Base;
+
+ };
+
+ template <typename _TraitsT, int> struct _BracketMatcher {
+
+ _BracketMatcher(bool, _TraitsT __traits) : _M_translator(__traits) {}
+
+ vector<typename _TraitsT::char_class_type> _M_neg_class_set;
+
+ _RegexTranslator _M_translator;
+
+ };
+
+ template <typename _TraitsT>
+
+ _Compiler<_TraitsT>::_Compiler(_IterT __b, _IterT __e,
+
+ const typename _TraitsT::locale_type &__loc,
+
+ syntax_option_type) {
+
+ _M_insert_character_class_matcher<false>();
+
+ _M_insert_character_class_matcher<true>();
+
+ }
+
+ template <typename _TraitsT>
+
+ template <bool __collate>
+
+ void _Compiler<_TraitsT>::_M_insert_character_class_matcher() {
+
+ _BracketMatcher<_TraitsT, __collate> __matcher(0, _M_traits);
+
+ _M_nfa->_M_insert_matcher(__matcher);
+
+ }
+
+ class Trans_NS___cxx11_basic_regex {
+
+public:
+
+ char Trans_NS___cxx11_basic_regex___last;
+
+ Trans_NS___cxx11_basic_regex()
+
+ : _M_automaton(__compile_nfa(Trans_NS___cxx11_basic_regex___last)) {} /* { dg-error } */
+
+ __shared_ptr_access<_NFA> _M_automaton;
+
+ } regex_sanity_check___f;
+
+}
projects / gcc.git / commitdiff