Go to:
Gentoo Home
Documentation
Forums
Lists
Bugs
Planet
Store
Wiki
Get Gentoo!
Gentoo's Bugzilla – Attachment 651586 Details for
Bug 730406
sys-kernel/genkernel-4.0.9-r1: Failed to create binpkg of boost-1.73.0: *** stack smashing detected ***: terminated
Home
|
New
–
[Ex]
|
Browse
|
Search
|
Privacy Policy
|
[?]
|
Reports
|
Requests
|
Help
|
New Account
|
Log In
[x]
|
Forgot Password
Login:
[x]
Reproducer
instantiate_cpp_grammar.ii (text/plain), 84.61 KB, created by
Stig Nielsen
on 2020-07-30 08:08:06 UTC
(
hide
)
Description:
Reproducer
Filename:
MIME Type:
Creator:
Stig Nielsen
Created:
2020-07-30 08:08:06 UTC
Size:
84.61 KB
patch
obsolete
> > typedef long unsigned int size_t; > typedef long int ptrdiff_t; > > > > > extern "C" > typedef signed int __int32_t; > typedef signed long int __int64_t; > typedef __int32_t __int_least32_t; > typedef __int64_t __int_least64_t; > typedef long int __intmax_t; > typedef struct > > __fsid_t; > typedef long int __time_t; > > extern "C" { > typedef __int32_t int32_t; > struct timeval ;; > typedef long int __fd_mask; > typedef struct { > } > fd_set; > typedef struct __pthread_internal_list {} > __pthread_list_t; > typedef struct __pthread_internal_slist > __pthread_slist_t; > typedef union > pthread_mutex_t; > typedef union > pthread_cond_t; > typedef union > pthread_rwlock_t; > typedef union > > pthread_barrierattr_t; > } > struct drand48_data ;; > > typedef __int_least64_t int_least64_t; > typedef __intmax_t intmax_t; > namespace boost { > using ::int32_t; > using ::intmax_t; > } > > template<typename> class allocator; > > typedef struct > __mbstate_t; > typedef __mbstate_t mbstate_t; > > extern "C++" { > > class exception {}; > > } > > template<typename _Tp, _Tp __v> struct integral_constant {}; > typedef integral_constant<bool, true> true_type; > typedef integral_constant<bool, false> false_type; > template<bool __v> using __bool_constant = integral_constant<bool, __v>; > template <typename _Type> struct __type_identity ;; > template<typename...> struct __or_; > template<typename...> struct __and_; > template<typename _Pp> struct __not_ : public __bool_constant<!bool(_Pp::value)> {}; > template<typename> struct is_function; > template<typename> struct is_void; > template <typename _Tp, size_t = sizeof(_Tp)> constexpr true_type __is_complete_or_unbounded() ; > template<typename _Tp> struct __success_type ; > struct __failure_type ; > template<typename> struct remove_cv; > template<typename _Tp> using __remove_cv_t = typename remove_cv<_Tp>::type; > template<typename> struct __is_integral_helper : public false_type { > }; > template<typename _Tp> struct is_integral : public __is_integral_helper<__remove_cv_t<_Tp>>::type { > }; > template<typename> struct __is_floating_point_helper : public false_type {}; > template<typename _Tp> struct is_floating_point : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type { > }; > template<typename> struct is_array : public false_type {}; > template<typename> struct __is_pointer_helper : public false_type {}; > template<typename _Tp> struct is_pointer : public __is_pointer_helper<__remove_cv_t<_Tp>>::type {}; > template<typename> struct is_lvalue_reference : public false_type {}; > template<typename> struct is_rvalue_reference : public false_type { > }; > template<typename _Tp> struct is_enum : public integral_constant<bool, __is_enum(_Tp)> { > }; > template<typename> struct __is_null_pointer_helper : public false_type {}; > template<typename _Tp> struct is_null_pointer : public __is_null_pointer_helper<__remove_cv_t<_Tp>>::type { > }; > template<typename _Tp> struct __is_nullptr_t : public is_null_pointer<_Tp> { > } > __attribute__ (()); > template<typename _Tp> struct is_reference : public __or_<is_lvalue_reference<_Tp>, is_rvalue_reference<_Tp>>::type { > }; > template<typename _Tp> struct is_arithmetic : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type {}; > template<typename> struct is_member_pointer; > template<typename _Tp> struct is_scalar : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>, is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type {}; > template<typename...> using __void_t = void; > template<typename _Tp, typename = void> struct __is_referenceable : public false_type {}; > template<typename _Tp> struct is_trivially_copyable : public integral_constant<bool, __is_trivially_copyable(_Tp)> {}; > template<typename _Tp> struct is_standard_layout : public integral_constant<bool, __is_standard_layout(_Tp)> {}; > template<typename _Tp> struct is_literal_type : public integral_constant<bool, __is_literal_type(_Tp)> {}; > template<typename _Tp, typename _Up = _Tp&&> _Up __declval; > template<typename _Tp> auto declval() noexcept -> decltype(__declval<>()); > template<typename, unsigned = 0> struct extent; > template<typename> struct remove_all_extents; > template<typename _Tp> struct __is_array_unknown_bounds : public __and_<is_array<_Tp>, __not_<extent<_Tp>>> {}; > struct __do_is_destructible_impl ; > struct __do_is_nt_destructible_impl {}; > template<typename _Tp> struct __is_nt_destructible_impl : public __do_is_nt_destructible_impl {}; > template<typename _Tp, bool = __or_<is_void<_Tp>, __is_array_unknown_bounds<_Tp>, is_function<_Tp>>::value, bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value> struct __is_nt_destructible_safe; > template<typename _Tp> struct __is_nt_destructible_safe<_Tp, false, false> : public __is_nt_destructible_impl<typename remove_all_extents<_Tp>::type>::type {}; > template<typename _Tp, typename... _Args> struct __is_constructible_impl : public __bool_constant<__is_constructible(_Tp, _Args...)> {}; > template<typename _Tp, typename... _Args> struct is_constructible : public __is_constructible_impl<_Tp, _Args...> { > static_assert(__is_complete_or_unbounded(__type_identity<_Tp>{} > ), "template argument must be a complete class or an unbounded array"); > }; > template<typename _Tp> struct is_default_constructible : public __is_constructible_impl<_Tp>::type {}; > template<typename _Tp, bool = __is_referenceable<_Tp>::value> struct __is_move_constructible_impl; > template<typename _Tp> struct __is_move_constructible_impl<_Tp, false> : public false_type {}; > template<typename _Tp> struct is_move_constructible : public __is_move_constructible_impl<_Tp> {}; > template<bool, typename _Tp, typename... _Args> struct __is_nt_constructible_impl : public false_type { > }; > template<typename _Tp, typename... _Args> using __is_nothrow_constructible_impl = __is_nt_constructible_impl<__is_constructible(_Tp, _Args...), _Tp, _Args...>; > template<typename _Tp, typename... _Args> struct is_nothrow_constructible : public __is_nothrow_constructible_impl<_Tp, _Args...>::type { > static_assert(__is_complete_or_unbounded(__type_identity<_Tp>{} > ), "template argument must be a complete class or an unbounded array"); > }; > template<typename _Tp, bool = __is_referenceable<_Tp>::value> struct __is_nothrow_copy_constructible_impl; > template<typename _Tp> struct is_nothrow_copy_constructible : public __is_nothrow_copy_constructible_impl<_Tp>::type {}; > template<typename _Tp, bool = __is_referenceable<_Tp>::value> struct __is_nothrow_move_constructible_impl; > template<typename _Tp> struct is_nothrow_move_constructible : public __is_nothrow_move_constructible_impl<_Tp>::type {}; > template<typename _Tp, bool = __is_referenceable<_Tp>::value> struct __is_move_assignable_impl; > template<typename _Tp> struct is_move_assignable : public __is_move_assignable_impl<_Tp>::type { > static_assert(__is_complete_or_unbounded(__type_identity<_Tp>{} > ), "template argument must be a complete class or an unbounded array"); > }; > template<typename _Tp, typename _Up> struct __is_nt_assignable_impl : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>)> {}; > template<typename _Tp, bool = __is_referenceable<_Tp>::value> struct __is_nt_move_assignable_impl; > template<typename _Tp> struct is_nothrow_move_assignable : public __is_nt_move_assignable_impl<_Tp> { > static_assert(__is_complete_or_unbounded(__type_identity<_Tp>{} > ), "template argument must be a complete class or an unbounded array"); > }; > template<typename _Tp, typename _Up> struct is_trivially_assignable : public __bool_constant<__is_trivially_assignable(_Tp, _Up)> { > static_assert(__is_complete_or_unbounded(__type_identity<_Tp>{} > ), "template argument must be a complete class or an unbounded array"); > }; > template<typename _Tp, typename _Up> struct is_same : public integral_constant<bool, __is_same_as(_Tp, _Up)> {}; > template<typename _Tp> struct remove_volatile ; > template<typename _Tp> struct remove_volatile<_Tp volatile> ;; > template<typename _Tp> struct remove_cv ;; > template<typename _Tp> struct add_volatile ;; > template<typename _Tp> struct remove_reference ; > template<typename _Tp, bool _IsInt = is_integral<_Tp>::value, bool _IsEnum = is_enum<_Tp>::value> class __make_unsigned_selector; > class __make_unsigned_selector_base ; > template<typename _Up, bool _IsArray = is_array<_Up>::value, bool _IsFunction = is_function<_Up>::value> struct __decay_selector; > template<typename _Tp> class decay ;; > template<typename _Tp> using __decay_t = typename decay<_Tp>::type; > template<typename _Tp> class reference_wrapper; > template<typename _Tp> struct __strip_reference_wrapper ;; > template<typename _Tp> struct __strip_reference_wrapper ; > template<bool, typename _Tp = void> struct enable_if ; > template<typename _Tp> struct enable_if<true, _Tp> ; > template<bool _Cond, typename _Tp = void> using __enable_if_t = typename enable_if<_Cond, _Tp>::type; > template<typename... _Cond> using _Require = __enable_if_t<__and_<_Cond...>::value>; > template<bool _Cond, typename _Iftrue, typename _Iffalse> struct conditional > ; > template<typename _Tp> using __remove_cvref_t = typename remove_cv<typename remove_reference<_Tp>::type>::type; > template<typename... _Tp> struct common_type; > struct __do_common_type_impl ; > template<typename _Tp1, typename _Tp2, typename _Dp1 = __decay_t<_Tp1>, typename _Dp2 = __decay_t<_Tp2>> struct __common_type_impl ;; > template<typename, typename, typename = void> struct __common_type_fold; > template<typename _Tp, bool = is_enum<_Tp>::value> struct __underlying_type_impl ;; > template<typename _MemPtr, typename _Arg> struct __result_of_memobj; > template<typename _Res, typename _Class, typename _Arg> struct __result_of_memobj<_Res _Class::*, _Arg> ; > template<typename _MemPtr, typename _Arg, typename... _Args> struct __result_of_memfun; > template<typename _Res, typename _Class, typename _Arg, typename... _Args> struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> ;; > template<typename _Tp, typename _Up = __remove_cvref_t<_Tp>> struct __inv_unwrap ; > template<bool, bool, typename _Functor, typename... _ArgTypes> struct __result_of_impl ; > template<typename _Default, typename _AlwaysVoid, template<typename...> class _Op, typename... _Args> struct __detector ; > template<typename _Default, template<typename...> class _Op, typename... _Args> using __detected_or = __detector<_Default, void, _Op, _Args...>; > template<typename _Default, template<typename...> class _Op, typename... _Args> using __detected_or_t = typename __detected_or<_Default, _Op, _Args...>::type; > > > namespace boost { > struct use_default ; > } > namespace mpl_ { > > > } > namespace boost { > namespace mpl { > using namespace mpl_; > namespace aux {} > } > } > namespace mpl_ { > template< bool C_ > struct bool_; > typedef bool_<true> true_; > typedef bool_<false> false_; > } > namespace mpl_ { > template< bool C_ > struct bool_ { > }; > struct na ; > } > namespace boost {} > namespace boost { > namespace mpl { > template< bool C , typename T1 , typename T2 > struct if_c { > typedef T1 type; > }; > template< typename T1 , typename T2 > struct if_c<false,T1,T2> { > typedef T2 type; > }; > template< typename T1 = na , typename T2 = na , typename T3 = na > struct if_ { > private: typedef if_c< static_cast<bool>(T1::value) , T2 , T3 > almost_type_; > public: typedef typename almost_type_::type type; > }; > namespace aux {} > } > namespace mpl { > template< typename C = na , typename F1 = na , typename F2 = na > struct eval_if {}; > namespace aux {} > } > } > namespace boost { > namespace mpl { > template< typename T = na > struct identity ; > template< typename T = na > struct make_identity ; > namespace aux {} > } > } > namespace mpl_ { > template< int N > struct arg; > } > namespace boost { > namespace mpl { > namespace aux { > template< typename T > struct nested_type_wknd : T::type {}; > } > }; > template< typename P > struct assert_arg_pred ; > template< typename P > struct assert_arg_pred_not ; > } > namespace mpl_ { > typedef arg<1> _1; > } > namespace boost { > namespace mpl {} > template <class T, T val> struct integral_constant { > static const bool value = val; > }; > typedef integral_constant<bool, false> false_type; > template <class T> struct is_void : public false_type { > }; > template <class T> struct is_lvalue_reference : public false_type{ > }; > template <class T> struct is_rvalue_reference : public false_type { > }; > template <class T> struct is_reference : public integral_constant< bool, ::boost::is_lvalue_reference<T>::value || ::boost::is_rvalue_reference<T>::value> { > }; > namespace type_traits_detail { > template <typename T, bool b> struct add_rvalue_reference_helper ; > template <typename T> struct add_rvalue_reference_helper<T, true> { > typedef T&& type; > }; > template <typename T> struct add_rvalue_reference_imp {}; > } > template <class T> struct add_rvalue_reference { > typedef typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type type; > }; > } > namespace boost { > template <typename T> typename add_rvalue_reference<T>::type declval() noexcept ; > namespace detail{ > template <class T> struct remove_rvalue_ref { > typedef T type; > }; > template <class T> struct remove_rvalue_ref<T&&> ; > } > template <class T> struct remove_reference{ > typedef typename boost::detail::remove_rvalue_ref<T>::type type; > }; > template <class T> struct remove_reference; > template <class T> struct is_function : public false_type { > }; > } > namespace boost { > namespace detail{} > template <class T> struct is_complete : public integral_constant<bool, ::boost::is_function<typename boost::remove_reference<T>::type>::value || 0> {}; > template <class T> struct is_integral : public false_type {}; > template <class T> struct is_floating_point : public false_type{}; > template <class T> struct is_arithmetic : public integral_constant<bool, is_integral<T>::value || is_floating_point<T>::value> {}; > } > namespace boost { > namespace detail { > template <typename T> struct add_reference_impl { > typedef T& type; > }; > template <typename T> struct add_reference_impl<T&&> ; > } > template <class T> struct add_reference { > typedef typename boost::detail::add_reference_impl<T>::type type; > }; > template <class T> struct add_lvalue_reference ; > namespace detail { > template <class A, class B, class C> struct or_helper > ; > template <typename From, typename To> struct is_convertible_impl ;; > template <typename From, typename To> struct is_convertible_impl_dispatch_base ;; > template <typename From, typename To> struct is_convertible_impl_dispatch : public is_convertible_impl_dispatch_base<From, To>::type { > }; > } > template <class From, class To> struct is_convertible : public integral_constant<bool, ::boost::detail::is_convertible_impl_dispatch<From, To>::value> {}; > } > > struct input_iterator_tag { > }; > struct output_iterator_tag ; > struct forward_iterator_tag : public input_iterator_tag {}; > struct bidirectional_iterator_tag : public forward_iterator_tag {}; > struct random_access_iterator_tag : public bidirectional_iterator_tag { > }; > template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t, typename _Pointer = _Tp*, typename _Reference = _Tp&> struct iterator ;; > template<typename _Iterator, typename = __void_t<>> struct __iterator_traits ; > template<typename _Iterator> struct iterator_traits : public __iterator_traits<_Iterator> { > }; > template<typename _Tp> struct iterator_traits ; > > extern "C++" {} > > template<typename _Tp> struct __get_first_arg ;; > template<typename _Tp, typename _Up> struct __replace_first_arg ; > template<typename _Ptr> struct pointer_traits ; > template<typename _Iterator> class reverse_iterator : public iterator<typename iterator_traits<_Iterator>::iterator_category, typename iterator_traits<_Iterator>::value_type, typename iterator_traits<_Iterator>::difference_type, typename iterator_traits<_Iterator>::pointer, typename iterator_traits<_Iterator>::reference> { > }; > > namespace __gnu_cxx __attribute__ (()) { > template<typename _Iterator, typename _Container> class __normal_iterator ; > } > > template<typename _InternT, typename _ExternT, typename _StateT> class codecvt; > > > > extern "C" > typedef pthread_mutex_t __gthread_mutex_t; > typedef pthread_mutex_t __gthread_recursive_mutex_t; > > template<typename _U1, typename _U2> class __pair_base { > }; > template<typename _T1, typename _T2> struct pair : private __pair_base<_T1, _T2> { > typedef _T1 first_type; > }; > > namespace __gnu_cxx __attribute__ (()) { > template<typename _CharT> struct char_traits ; > } > > template<class _CharT> struct char_traits : public __gnu_cxx::char_traits<_CharT> {}; > template<> struct char_traits<char> ; > > namespace __gnu_cxx __attribute__ (()) { > template<typename _Tp> class new_allocator { > private: }; > } > > template<typename _Tp> using __allocator_base = __gnu_cxx::new_allocator<_Tp>; > template<> class allocator<void> { > template<typename _Tp1> struct rebind ; > }; > template<typename _Tp> class allocator : public __allocator_base<_Tp> { > public: typedef _Tp value_type; > typedef size_t size_type; > }; > struct __allocator_traits_base { > template<typename _Tp, typename _Up, typename = void> struct __rebind : __replace_first_arg<_Tp, _Up> { > }; > protected: template<typename _Tp> using __pointer = typename _Tp::pointer; > }; > template<typename _Alloc, typename _Up> using __alloc_rebind = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type; > template<typename _Alloc> struct allocator_traits : __allocator_traits_base {}; > template<typename _Tp> struct allocator_traits<allocator<_Tp>> { > using allocator_type = allocator<_Tp>; > using value_type = _Tp; > using pointer = _Tp*; > using const_pointer = const _Tp*; > using const_void_pointer = const void*; > using size_type = size_t; > template<typename _Up> using rebind_alloc = allocator<_Up>; > }; > template<typename _Alloc, typename = void> struct __is_allocator : false_type {}; > template<typename _Alloc> struct __is_allocator<_Alloc, __void_t<typename _Alloc::value_type, decltype(0)>> : true_type { > }; > > namespace __gnu_cxx __attribute__ (()) { > template<typename _Alloc, typename = typename _Alloc::value_type> struct __alloc_traits : allocator_traits<_Alloc> { > typedef allocator_traits<_Alloc> _Base_type; > typedef typename _Base_type::value_type value_type; > typedef value_type& reference; > template<typename _Tp> struct rebind { > typedef typename _Base_type::template rebind_alloc<_Tp> other; > }; > }; > } > > template<typename _Result, typename _Arg> struct __hash_base ;; > class logic_error : public exception {}; > class out_of_range : public logic_error { > public: }; > > namespace boost { > > struct no_traversal_tag { > }; > struct incrementable_traversal_tag : no_traversal_tag { > }; > struct single_pass_traversal_tag : incrementable_traversal_tag {}; > struct forward_traversal_tag : single_pass_traversal_tag { > }; > struct bidirectional_traversal_tag : forward_traversal_tag { > }; > struct random_access_traversal_tag : bidirectional_traversal_tag {}; > namespace Trans_NS_iterators_detail { > template <class Cat> struct old_category_to_traversal : mpl::eval_if< is_convertible<Cat,random_access_iterator_tag> , mpl::identity<random_access_traversal_tag> , mpl::eval_if< is_convertible<Cat,bidirectional_iterator_tag> , mpl::identity<> , mpl::eval_if< is_convertible<Cat,forward_iterator_tag> , mpl::identity<forward_traversal_tag> , mpl::eval_if< is_convertible<Cat,input_iterator_tag> , mpl::identity<> , mpl::eval_if<> > > > > {}; > } > template <class Cat> struct iterator_category_to_traversal : mpl::eval_if<> {}; > template <class Iterator = mpl::_1> struct iterator_traversal : iterator_category_to_traversal< typename iterator_traits<Iterator>::iterator_category > {}; > > } > namespace boost { > namespace mpl { > namespace aux { > template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct or_impl : true_ {}; > } > template< typename T1 = na , typename T2 = na , typename T3 = false_, typename T4 = false_, typename T5 = false_ > struct or_ : aux::or_impl< ::boost::mpl::aux::nested_type_wknd<T1>::value , T2, T3, T4, T5 > {}; > template<> struct or_< na , na > ; > } > > template <typename A, typename B> struct Trans_NS_iterators_is_interoperable : mpl::or_< is_convertible< A, B > , is_convertible< B, A > > {}; > > > } > namespace boost { > > template <class Iterator> struct iterator_value ; > template <class Iterator> struct iterator_reference > ; > template <class Iterator> struct iterator_difference ; > > namespace mpl {} > } > namespace boost { > template <class T, class U> struct is_same : public false_type {}; > template <class T> struct is_pointer : public false_type{ > }; > namespace detail { > template <typename T> struct is_class_impl { > static const bool value = __is_class(T); > }; > } > template <class T> struct is_class : public integral_constant<bool, ::boost::detail::is_class_impl<T>::value> {}; > } > namespace boost {} > namespace boost { > template <class T> struct remove_cv{ > typedef T type; > }; > } > namespace boost { > template <class T> struct add_const ;; > template <typename T> struct add_pointer ; > template <class T> struct is_enum : public integral_constant<bool, __is_enum(T)> { > }; > namespace mpl {} > > > namespace Trans_NS_iterators_detail {} > namespace Trans_NS_iterators_detail { > template <class T, class DefaultNullaryFn> struct ia_dflt_help : mpl::eval_if<> { > }; > template < class Derived , class Base , class Value , class Traversal , class Reference , class Difference > struct iterator_adaptor_base ;; > ; > } > template < class Derived , class Base , class Value = use_default , class Traversal = use_default , class Reference = use_default , class Difference = use_default > class iterator_adaptor : public boost::Trans_NS_iterators_detail::iterator_adaptor_base< Derived, Base, Value, Traversal, Reference, Difference >::type {}; > > } > namespace boost {} > > typedef enum memory_order {} > memory_order; > typedef bool __atomic_flag_data_type; > extern "C" { > struct __atomic_flag_base ; > }; > template<typename _ITp> struct __atomic_base ;; > template<typename _Tp, typename _Alloc> struct _Vector_base { > typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_Tp>::other _Tp_alloc_type; > typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer pointer; > struct _Vector_impl_data ; > }; > template<typename _Tp, typename _Alloc = allocator<_Tp> > class vector : protected _Vector_base<_Tp, _Alloc> {}; > enum float_round_style { > round_to_nearest = 1, round_toward_neg_infinity }; > enum float_denorm_style { > denorm_indeterminate = -1, denorm_absent , }; > struct __numeric_limits_base {}; > template<typename _Tp> struct numeric_limits : public __numeric_limits_base {}; > > namespace boost { > > namespace util { > > template <typename T> struct get_unsigned { > typedef T result; > }; > template struct get_unsigned<int> ; > template struct get_unsigned<long int> ;; > > > template <typename E, class A = allocator<E> > class SimpleStringStorage ; > template <typename E, class A = allocator<E> > class AllocatorStringStorage : public A { > public: typedef E value_type; > typedef E* iterator; > typedef const E* const_iterator; > typedef A allocator_type; > }; > template < typename Storage, typename Align = typename Storage::value_type* > class CowString { > typedef typename Storage::value_type E; > typedef typename get_unsigned<E>::result RefCountType; > public: typedef E value_type; > typedef typename Storage::iterator iterator; > typedef typename Storage::const_iterator const_iterator; > typedef typename Storage::allocator_type allocator_type; > typedef typename allocator_traits<allocator_type>::size_type size_type; > typedef typename Storage::value_type& reference; > private: union {}; > }; > template <typename E, class T = char_traits<E>, class A = allocator<E>, class Storage = AllocatorStringStorage<E, A> > class flex_string : private Storage {}; > } > > } > > > struct _List_node_base ; > ; > template<typename _Tp> struct _List_iterator ;; > > template<typename _Tp, typename _Alloc> class Trans_NS___cxx11__List_base {}; > template<typename _Tp, typename _Alloc = allocator<_Tp> > class Trans_NS___cxx11_list : protected Trans_NS___cxx11__List_base<_Tp, _Alloc> { > }; > > > namespace boost { > > > struct nil_t { > }; > > > > > namespace util { > template <typename StringT> struct file_position ;; > typedef file_position<boost::util::flex_string< char, char_traits<char>, allocator<char>, boost::util::CowString< boost::util::AllocatorStringStorage<char> > > > file_position_type; > } > > > enum token_category { > IdentifierTokenType , ParameterTokenType = 0x08840000, ExtParameterTokenType , KeywordTokenType = 0x10040000, OperatorTokenType = 0x18040000, LiteralTokenType = 0x20040000, IntegerLiteralTokenType = 0x20840000, FloatingLiteralTokenType = 0x21040000, StringLiteralTokenType , CharacterLiteralTokenType = 0x22040000, BoolLiteralTokenType = 0x22840000, PPTokenType = 0x28040000, PPConditionalTokenType = 0x28440000, UnknownTokenType = 0x50000000, EOLTokenType , EOFTokenType = 0x60000000, WhiteSpaceTokenType , InternalTokenType = 0x70040000, TokenTypeMask = 0x7F800000, AltTokenType , TriGraphTokenType , AltExtTokenType = 0x00280000, PPTokenFlag = 0x00040000, ExtTokenTypeMask , ExtTokenOnlyMask , TokenValueMask = 0x0007FFFF, }; > enum token_id { > T_FIRST_TOKEN = 256, T_AND_ALT = ((T_FIRST_TOKEN) | (OperatorTokenType|AltExtTokenType)), T_ASSIGN = 0, T_ANDASSIGN , T_ANDASSIGN_ALT , T_OR = ((260) | (OperatorTokenType)), T_OR_ALT = 0, T_OR_TRIGRAPH = (0 | 0), T_ORASSIGN = 0, T_ORASSIGN_ALT = 0, T_XOR_TRIGRAPH = 0, T_XORASSIGN , T_XORASSIGN_ALT , T_XORASSIGN_TRIGRAPH = 0, T_COMMA , T_COLON , T_DIVIDE , T_DOT , T_DOTSTAR , T_ELLIPSIS , T_GREATER = ((272) | (OperatorTokenType)), T_GREATEREQUAL , T_LEFTBRACE , T_LEFTBRACE_ALT = ((274) | 0), T_LESS = ((275) | 0), T_LESSEQUAL , T_LEFTPAREN = ((277) | (OperatorTokenType)), T_LEFTBRACKET = ((278) | (OperatorTokenType)), T_MINUS = ((279) | 0), T_MINUSASSIGN = (0 | 0), T_PERCENT , T_NOT , T_NOT_ALT , T_NOTEQUAL_ALT , T_OROR = 0, T_ARROW = ((290) | (OperatorTokenType)), T_QUESTION_MARK , T_RIGHTBRACE_ALT = (0 | 0), T_RIGHTBRACE_TRIGRAPH = (0 | 0), T_RIGHTPAREN , T_RIGHTBRACKET_TRIGRAPH , T_COLON_COLON = 0, T_SEMICOLON = ((297) | (OperatorTokenType)), T_SHIFTLEFT = 0, T_SHIFTLEFTASSIGN = (0 | 0), T_COMPL_TRIGRAPH = 0, T_STARASSIGN , T_ASM , T_BOOL , T_BREAK , T_CONST = 0, T_DEFAULT = ((318) | (KeywordTokenType)), T_EXPLICIT = ((325) | 0), T_EXPORT = (0 | (KeywordTokenType)), T_EXTERN , T_FLOAT = 0, T_IF , T_INLINE , T_INT , T_OPERATOR , T_PRIVATE , T_PROTECTED = (0 | 0), T_RETURN , T_SHORT , T_SIGNED = 0, T_SIZEOF = 0, T_STATIC = 0, T_STRUCT = (0 | 0), T_TRY , T_TYPEDEF = ((357) | (KeywordTokenType)), T_TYPEID , T_TYPENAME = (0 | (KeywordTokenType)), T_UNSIGNED = ((361) | (KeywordTokenType)), T_USING = 0, T_VOID = (0 | (KeywordTokenType)), T_VOLATILE , T_PP_DEFINE = ((368) | (PPTokenType)), T_PP_ERROR , T_PP_PRAGMA = 0, T_PP_UNDEF = (0 | 0), T_PP_WARNING = 0, T_IDENTIFIER , T_OCTALINT , T_DECIMALINT = 0, T_INTLIT = ((384) | (IntegerLiteralTokenType)), T_FLOATLIT , T_FIXEDPOINTLIT , T_CPPCOMMENT , T_CHARLIT , T_STRINGLIT = (0 | (StringLiteralTokenType)), T_CONTLINE , T_SPACE = 0, T_NEWLINE , T_GENERATEDNEWLINE , T_POUND_POUND , T_POUND_POUND_TRIGRAPH = 0, T_POUND , T_POUND_ALT = (0 | 0), T_ANY = 0, T_PP_INCLUDE_NEXT = 0, T_PP_QHEADER_NEXT , T_EOF = (0 | (EOFTokenType)), T_MSEXT_INT8 = (0 | (KeywordTokenType)), T_MSEXT_INT16 , T_MSEXT_INT32 = 0, T_MSEXT_INT64 = (0 | (KeywordTokenType)), T_MSEXT_BASED = 0, T_MSEXT_CDECL , T_MSEXT_FASTCALL , T_MSEXT_STDCALL , T_MSEXT_FINALLY = 0, T_MSEXT_LEAVE = 0, T_MSEXT_INLINE = 0, T_MSEXT_PP_REGION = (0 | 0), T_ALIGNAS , T_CHAR16_T , T_CHAR32_T = 0, T_NOEXCEPT , T_NULLPTR = 0, T_THREADLOCAL , T_RAWSTRINGLIT = ((432) | (StringLiteralTokenType)), T_LAST_TOKEN_ID, T_LAST_TOKEN = (0 & ~TokenTypeMask), T_UNKNOWN_UNIVERSALCHAR = (('\\') | (UnknownTokenType)), T_NONREPLACABLE_IDENTIFIER = ((T_LAST_TOKEN+1) | (IdentifierTokenType)), T_PLACEHOLDER , T_PLACEMARKER , T_PARAMETERBASE , T_EXTPARAMETERBASE = 0 }; > > } > > class __mutex_base { > protected: typedef __gthread_mutex_t __native_type; > }; > class mutex : private __mutex_base {}; > > namespace boost{ > namespace details{ > > typedef mutex default_mutex; > > } > struct default_user_allocator_new_delete; > template <typename T, typename UserAllocator = default_user_allocator_new_delete, typename Mutex = details::default_mutex, unsigned NextSize = 32, unsigned MaxSize = 0> class fast_pool_allocator; > namespace detail {}; > namespace details {} > namespace detail{ > union max_align ;; > } > template <size_t Align> struct type_with_alignment ; > template <bool b, class T, class U> struct conditional ; > namespace detail { > > template < size_t size_ , size_t alignment_ > struct aligned_storage_imp ;; > > } > namespace detail {} > > namespace cpplexer { > namespace impl {} > template <typename PositionT = boost::util::file_position_type> class lex_token; > template <typename PositionT> class lex_token { > public: typedef boost::util::flex_string< char, char_traits<char>, allocator<char>, boost::util::CowString< boost::util::AllocatorStringStorage<char> > > string_type; > typedef PositionT position_type; > }; > } > > } > namespace boost { > template<typename T, typename R=void> struct enable_if_has_type ; > > > struct default_checking_policy {}; > > > > namespace iterator_policies { > struct ref_counted { > struct unique {}; > struct shared ; > }; > } > > } > namespace boost { > namespace detail { > template <typename T> struct empty_helper_t1 : public T { > int i[256]; > private: }; > struct empty_helper_t2 { > int i[256]; > }; > template <typename T, bool is_a_class = false> struct empty_helper ;; > template <typename T> struct empty_helper<T, true> { > static const bool value = (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2)) ; > }; > template <typename T> struct is_empty_impl { > typedef typename remove_cv<T>::type cvt; > static const bool value = ( ::boost::detail::empty_helper<cvt,::boost::is_class<T>::value>::value || false) ; > }; > } > template <class T> struct is_empty : integral_constant<bool, ::boost::detail::is_empty_impl<T>::value> { > }; > } > namespace boost { > > namespace iterator_policies { > struct split_functor_input { > template <typename Functor , bool FunctorIsEmpty = is_empty<typename Functor::first_type>::value> class unique; > template <typename Functor> class unique<Functor, true> { > protected: typedef typename Functor::first_type functor_type; > typedef typename functor_type::result_type result_type; > public: typedef result_type value_type; > }; > }; > } > > > namespace iterator_policies { > struct no_check { > struct unique : public default_checking_policy {}; > struct shared ; > }; > struct split_std_deque { > enum {}; > template <typename Value> class unique {}; > }; > } > > > namespace iterator_policies { > template <typename T , typename Ownership, typename Checking, typename Input, typename Storage , bool OwnershipIsEmpty = boost::is_empty<Ownership>::value , bool CheckingIsEmpty = boost::is_empty<Checking>::value , bool InputIsEmpty = boost::is_empty<Input>::value> struct multi_pass_unique; > template <typename T, typename Ownership, typename Checking , typename Input, typename Storage> struct multi_pass_unique<T, Ownership, Checking, Input, Storage , true, true, true> : Storage {}; > template<typename T, typename Ownership, typename Checking, typename Input , typename Storage> struct multi_pass_shared : Ownership, Checking, Input, Storage { > }; > template<typename Ownership, typename Checking, typename Input , typename Storage> struct default_policy { > typedef Checking checking_policy; > typedef Input input_policy; > typedef Storage storage_policy; > template <typename T> struct unique : multi_pass_unique<T , typename Ownership::unique, typename Checking::unique , typename Input:: template unique<T> , typename Storage:: template unique< typename Input:: template unique<T>::value_type> > { > typedef typename Ownership::unique ownership_policy; > typedef typename Input:: template unique<T> input_policy; > }; > template <typename T> struct shared : multi_pass_shared<T , typename Ownership::shared, typename Checking::shared , typename Input:: template shared<T> , typename Storage:: template shared< typename Input:: template unique<T>::value_type> > {}; > }; > } > > template < typename MemberType, int UniqueID = 0 > class base_from_member { > }; > > template<typename T, typename Policies> class multi_pass : private boost::base_from_member< typename Policies:: template shared<T>*> , public Policies:: template unique<T> { > private: typedef typename Policies:: template unique<T> policies_base_type; > typedef typename policies_base_type::input_policy iterator_type; > public: typedef forward_iterator_tag iterator_category; > private: }; > namespace traits { > } > > > namespace cpplexer { > template <typename TokenT> struct lex_input_interface ; > } > namespace cpplexer { > namespace impl { > template <typename TokenT> class lex_iterator_functor_shim { > public: typedef TokenT result_type; > typedef lex_iterator_functor_shim unique; > typedef lex_input_interface<TokenT>* shared; > }; > } > template <typename FunctorData> struct make_multi_pass { > typedef pair<typename FunctorData::unique, typename FunctorData::shared> functor_data_type; > typedef typename FunctorData::result_type result_type; > typedef boost::iterator_policies::split_functor_input input_policy; > typedef boost::iterator_policies::ref_counted ownership_policy; > typedef boost::iterator_policies::no_check check_policy; > typedef boost::iterator_policies::split_std_deque storage_policy; > typedef boost::iterator_policies::default_policy< ownership_policy, check_policy, input_policy, storage_policy> policy_type; > typedef boost::multi_pass<functor_data_type, policy_type> type; > }; > template <typename TokenT> class lex_iterator : public make_multi_pass<impl::lex_iterator_functor_shim<TokenT> >::type { > typedef impl::lex_iterator_functor_shim<TokenT> input_policy_type; > typedef typename make_multi_pass<input_policy_type>::type base_type; > typedef typename input_policy_type::shared shared_functor_type; > public: typedef TokenT token_type; > }; > } > > namespace detail{ > template <typename T, bool isp, bool b1, bool b2> struct ct_imp { > typedef const T& param_type; > }; > } > template <typename T> struct call_traits { > typedef T& reference; > typedef const T& const_reference; > typedef typename boost::detail::ct_imp< T, ::boost::is_pointer<T>::value, ::boost::is_arithmetic<T>::value, ::boost::is_enum<T>::value >::param_type param_type; > }; > template< class T > struct decay ; > template <class T> using decay_t = typename decay<T>::type; > namespace detail { > template <typename B, typename D> struct is_base_and_derived_impl { > typedef typename remove_cv<B>::type ncvB; > typedef typename remove_cv<D>::type ncvD; > static const bool value = ((__is_base_of(B,D) && !is_same<B,D>::value) && ! ::boost::is_same<ncvB,ncvD>::value); > }; > } > template <class Base, class Derived> struct is_base_and_derived : public integral_constant<bool, (::boost::detail::is_base_and_derived_impl<Base, Derived>::value)> { > }; > namespace detail{ > template <class B, class D> struct is_base_of_imp ; > } > template<class T> class optional ; > > > > template <typename T> struct no_base { > }; > template <typename T> struct safe_bool_impl ;; > > template <typename DerivedT, typename BaseT = no_base<DerivedT> > struct safe_bool : BaseT {}; > > > > > template <typename T = nil_t> class match : public safe_bool<match<T> > {}; > template <> class match<> : public safe_bool<match<nil_t> > { > public: typedef nil_t attr_t; > typedef nil_t return_t; > ; > }; > class parser_id { > public: > private: union { > void const* p; > }; > }; > struct parser_tag_base {}; > struct parser_address_tag : parser_tag_base { > }; > class dynamic_parser_tag : public parser_tag_base { > private: parser_id tag; > }; > > > > > struct iteration_policy; > struct action_policy; > struct match_policy; > template < typename IterationPolicyT = iteration_policy, typename MatchPolicyT = match_policy, typename ActionPolicyT = action_policy> struct scanner_policies; > template < typename IteratorT = char const*, typename PoliciesT = scanner_policies<> > class scanner; > > > struct iteration_policy {}; > struct match_policy {}; > template <typename MatchPolicyT, typename T> struct match_result { > typedef typename MatchPolicyT::template result<T>::type type; > }; > struct action_policy { > }; > template < typename IterationPolicyT, typename MatchPolicyT, typename ActionPolicyT> struct scanner_policies : public IterationPolicyT, public MatchPolicyT, public ActionPolicyT { > typedef IterationPolicyT iteration_policy_t; > typedef MatchPolicyT match_policy_t; > typedef ActionPolicyT action_policy_t; > }; > struct scanner_base {}; > template < typename IteratorT, typename PoliciesT> class scanner : public PoliciesT, public scanner_base { > public: typedef IteratorT iterator_t; > typedef PoliciesT policies_t; > typedef typename boost:: call_traits<IteratorT>::param_type iter_param_t; > scanner( IteratorT& first_, iter_param_t last_, PoliciesT const& policies = PoliciesT()) ; > private: }; > > > > > template <typename ParserT, typename ActionT> class action; > struct plain_parser_category { > }; > struct binary_parser_category : plain_parser_category {}; > struct unary_parser_category : plain_parser_category {}; > struct action_parser_category : unary_parser_category {}; > template <typename ParserT, typename ScannerT> struct parser_result { > typedef typename boost::remove_reference<ParserT>::type parser_type; > typedef typename parser_type::template result<ScannerT>::type type; > }; > template <typename DerivedT> struct parser { > typedef DerivedT embed_t; > typedef plain_parser_category parser_category_t; > template <typename ScannerT> struct result ; > DerivedT const& derived() const ; > template <typename ActionT> action<DerivedT, ActionT> operator[](ActionT const& actor) const ; > }; > > > template <typename DerivedT> struct char_parser : public parser<DerivedT> {}; > template <typename CharT = char> struct chlit : public char_parser<chlit<CharT> > { > }; > template <typename CharT> chlit<> ch_p(CharT ch) ; > template <typename IteratorT = char const*> class chseq : public parser<chseq<IteratorT> > {}; > template <typename IteratorT = char const*> class strlit : public parser<strlit<IteratorT> > { > }; > struct anychar_parser : public char_parser<anychar_parser> { > }; > anychar_parser const anychar_p = anychar_parser(); > > > template <class T> struct is_final : public integral_constant<bool, __is_final(T)> {}; > namespace details { > template<class T, bool E = boost::is_final<T>::value> struct compressed_pair_empty : ::boost::false_type { > }; > template <class T1, class T2, bool IsSame, bool FirstEmpty, bool SecondEmpty> struct compressed_pair_switch; > template <class T1, class T2> struct compressed_pair_switch<T1, T2, false, false, false> { > static const int value = 0; > }; > template <class T1, class T2> struct compressed_pair_switch<T1, T2, false, true, false> ;; > template <class T1, class T2, int Version> class compressed_pair_imp; > template <class T1, class T2> class compressed_pair_imp<T1, T2, 0> { > public: typedef T1 first_type; > private: first_type first_; > }; > template <class T1, class T2> class compressed_pair_imp<T1, T2, 5> ; > } > template <class T1, class T2> class compressed_pair : private ::boost::details::compressed_pair_imp<T1, T2, ::boost::details::compressed_pair_switch< T1, T2, ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value, ::boost::details::compressed_pair_empty<T1>::value, ::boost::details::compressed_pair_empty<T2>::value>::value> { > }; > > > template <typename S, typename BaseT> class unary : public BaseT { > public: typedef BaseT base_t; > typedef typename S::embed_t subject_embed_t; > private: subject_embed_t subj; > }; > template <typename A, typename B, typename BaseT> class binary : public BaseT { > typedef typename A::embed_t left_embed_t; > typedef typename B::embed_t right_embed_t; > private: boost::compressed_pair<left_embed_t, right_embed_t> subj; > }; > > > struct default_parser_context_base { > template <typename DerivedT> struct aux { > }; > }; > struct parser_context_base { > }; > template<typename ContextT> struct parser_context_linker; > template<typename AttrT = nil_t> struct parser_context : parser_context_base { > typedef AttrT attr_t; > typedef default_parser_context_base base_t; > typedef parser_context_linker<parser_context > context_linker_t; > }; > template <typename ContextT, typename DerivedT> struct context_aux : public ContextT::base_t::template aux<DerivedT> {}; > template<typename ScannerT> struct parser_scanner_linker : public ScannerT { > parser_scanner_linker(ScannerT const scan_) ; > }; > template<typename ContextT> struct parser_context_linker : public ContextT { > template <typename ParserT> parser_context_linker(ParserT const& p) ; > template <typename ResultT, typename ParserT, typename ScannerT> ResultT& post_parse(ResultT& hit, ParserT const& p, ScannerT const& scan) ; > }; > > > } > namespace boost {} > namespace boost { > template<class T> class scoped_ptr {}; > > > > template <typename BaseT, typename DefaultT , typename T0, typename T1, typename T2> struct get_param { > typedef typename mpl::if_< is_base_and_derived<BaseT, T0> , T0 , typename mpl::if_< is_base_and_derived<BaseT, T1> , T1 , typename mpl::if_< is_base_and_derived<BaseT, T2> , T2 , DefaultT >::type >::type >::type type; > }; > template <typename T0, typename T1, typename T2> struct get_context { > typedef typename get_param< parser_context_base, parser_context<>, T0, T1, T2>::type type; > }; > template <typename T0, typename T1, typename T2> struct get_tag { > typedef typename get_param< parser_tag_base, parser_address_tag, T0, T1, T2>::type type; > }; > template <typename T0, typename T1, typename T2> struct get_scanner { > typedef typename get_param< scanner_base, scanner<>, T0, T1, T2>::type type; > }; > class rule_base_access ; > template < typename DerivedT , typename EmbedT , typename T0 , typename T1 , typename T2 > class rule_base : public parser<DerivedT> , public get_context<T0, T1, T2>::type::base_t , public context_aux< typename get_context<T0, T1, T2>::type, DerivedT> , public get_tag<T0, T1, T2>::type { > public: typedef typename get_scanner<T0, T1, T2>::type scanner_t; > typedef typename get_context<T0, T1, T2>::type context_t; > typedef typename get_tag<T0, T1, T2>::type tag_t; > typedef typename context_t::context_linker_t linked_context_t; > typedef typename linked_context_t::attr_t attr_t; > template <typename ScannerT> struct result ; > template <typename ScannerT> typename parser_result<DerivedT, ScannerT>::type parse(void) const ; > }; > template <typename ScannerT, typename AttrT> struct abstract_parser ;; > template <typename ParserT, typename ScannerT, typename AttrT> struct concrete_parser : abstract_parser<ScannerT, AttrT> {}; > > > > > > template < typename T0 = nil_t , typename T1 = nil_t , typename T2 = nil_t > class rule : public rule_base< rule<T0, T1, T2> , rule<> const& , T0, T1, T2> { > public: typedef rule self_t; > typedef rule_base< self_t , self_t const& , T0, T1, T2> base_t; > typedef typename base_t::scanner_t scanner_t; > typedef typename base_t::attr_t attr_t; > typedef abstract_parser<scanner_t, attr_t> abstract_parser_t; > rule() ; > template <typename ParserT> rule& operator=(ParserT const& p) ; > scoped_ptr<abstract_parser_t> ptr; > }; > > > namespace detail { > template< class D > struct sp_convert_reference ; > } > } > namespace boost { > namespace movelib {} > namespace detail { > template< class T > struct sp_element { > typedef T type; > }; > template< class T > struct sp_member_access { > typedef T * type; > }; > } > template<class T> class shared_ptr { > public: typedef typename boost::detail::sp_element< T >::type element_type; > ; > typename boost::detail::sp_member_access< T >::type operator-> () const noexcept ; > }; > namespace detail {} > ; > } > namespace boost { > namespace date_time {} > namespace date_time { > enum time_resolutions {}; > } > > namespace operators_detail { > template <typename T> class empty_base { > }; > } > template <class T, class U, class B = operators_detail::empty_base<T> > struct less_than_comparable2 : B { > }; > template <class T, class B = operators_detail::empty_base<T> > struct equality_comparable1 : B {}; > template <class T, class U, class B = operators_detail::empty_base<T> > struct multipliable2 : B { > }; > template <class T, class U, class B = operators_detail::empty_base<T> > struct dividable2 : B { > }; > namespace operators_detail { > struct true_t ;; > struct false_t ; > } > template<class T> struct is_chained_base { > typedef operators_detail::false_t value; > }; > template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct less_than_comparable; > template<class T, class U, class B> struct less_than_comparable<T, U, B, operators_detail::false_t> : less_than_comparable2<T, U, B> { > }; > template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equality_comparable; > template<class T, class U> struct equality_comparable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : equality_comparable1<T, U> { > }; > template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct multipliable; > template<class T, class U, class B> struct multipliable<T, U, B, operators_detail::false_t> : multipliable2<T, U, B> { > }; > > > } > namespace boost {} > namespace boost {} > namespace boost { > > > namespace date_time {} > } > namespace boost { > > class millisec_posix_time_system_config ;; > > namespace date_time { > template<class config> struct counted_time_rep > ; > template<class time_rep> class counted_time_system ; > } > } > namespace boost { > > typedef date_time::counted_time_rep<millisec_posix_time_system_config> int64_time_rep; > typedef date_time::counted_time_system<int64_time_rep> posix_time_system; > > namespace date_time { > template <class T, class time_system> class base_time : private boost::less_than_comparable<T , boost::equality_comparable<T > > { > }; > } > > } > namespace mpl_ { > template< typename T, T N > struct integral_c ; > > > template< typename Tag1, typename Tag2 > struct gcd_impl; > template< typename T > struct gcd_tag ;; > template< typename N1 = na , typename N2 = na > struct gcd : gcd_impl< typename gcd_tag<N1>::type , typename gcd_tag<N2>::type >::template apply<>::type { > }; > > > template< typename Tag1, typename Tag2 > struct lcm_impl; > template< typename T > struct lcm_tag ; > template< typename N1 = na , typename N2 = na > struct lcm : lcm_impl< typename lcm_tag<N1>::type , typename lcm_tag<N2>::type >::template apply<N1, N2>::type {}; > template< typename T , T n1 , T n2 > struct lcm_c : lcm<integral_c<T,n1>,integral_c<T,n2> > { > }; > > } > namespace boost { > template<class T> class integer_traits : public numeric_limits<T> { > }; > namespace detail { > template<class T, T min_val, T max_val> class integer_traits_base ; > }; > template <boost::intmax_t N, boost::intmax_t D = 1> class ratio; > typedef ratio<1L, 1000000000L> nano; > namespace ratio_detail { > template <class R1, class R2> struct ratio_subtract ; > }; > } > namespace boost { > namespace type_traits_detail { > template<template<class...> class F, class... T> struct mp_valid_impl ;; > template<template<class...> class F, class... T> using mp_valid = typename mp_valid_impl<F, T...>::type; > struct mp_empty ; > template<template<class...> class F, class... T> struct mp_defer_impl ;; > template<template<class...> class F, class... T> using mp_defer = typename boost::conditional<mp_valid<F, T...>::value, mp_defer_impl<F, T...>, mp_empty>::type; > } > } > namespace boost { > template<class... T> struct common_type ;; > template<class... T> using common_type_t = typename common_type<T...>::type; > namespace type_traits_detail { > template<class T1, class T2, class... T> using common_type_fold = common_type_t<common_type_t<T1, T2>, T...>; > } > template<class T1, class T2, class... T> struct common_type<T1, T2, T...>: type_traits_detail::mp_defer<type_traits_detail::common_type_fold, T1, T2, T...> { > }; > namespace type_traits_detail { > template<class T1, class T2> using builtin_common_type = typename boost::decay<decltype( boost::declval<bool>? boost::declval<T1>(): 0 )>::type; > template<class T1, class T2> struct common_type_impl: mp_defer<builtin_common_type, T1, T2> {}; > template <class Rep, class Period> class __attribute__(()) duration ; > namespace detail { > } > } > namespace chrono { > } > } > namespace boost {} > namespace boost { > namespace detail { > } > class mutex { > }; > > } > namespace boost { > > > > > > > > > struct once_flag ; > ; > > > > template <typename IdT = size_t> struct object_with_id_base_supply ;; > template <typename TagT, typename IdT = size_t> struct object_with_id_base { > }; > template<class TagT, typename IdT = size_t> struct object_with_id : private object_with_id_base<TagT, IdT> { > typedef object_with_id<TagT, IdT> self_t; > typedef IdT object_id; > object_id get_object_id() const ; > }; > > > > namespace move_upmu { > struct nat{ > }; > template <class T> struct natify; > template <bool B, class T = nat> struct enable_if_c { > typedef T type; > }; > template< class T > struct remove_const ; > template< class T > struct remove_volatile ;; > template<class T> struct remove_extent { > typedef T type; > }; > template<class T> struct add_lvalue_reference { > typedef T& type; > }; > template<class T> struct add_const_lvalue_reference ; > template<class T> struct is_array { > static const bool value = false; > }; > template <class T> struct has_pointer_type { > struct two { > char c[2]; > }; > template <class U> static two test(...); > static const bool value = sizeof(0) == 1; > }; > template <class T, class D, bool = has_pointer_type<D>::value> struct pointer_type_imp { > typedef T* type; > }; > template <class T, class D> struct pointer_type { > typedef typename pointer_type_imp <typename remove_extent<T>::type, typename remove_reference<D>::type>::type type; > }; > template <class T, class U> class is_convertible { > typedef typename add_lvalue_reference<T>::type t_reference; > typedef char true_t; > static true_t dispatch(U); > static t_reference trigger(); > public: static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t); > }; > } > namespace move_upd { > namespace bmupmu = ::boost::move_upmu; > } > namespace movelib { > namespace bmupd = boost::move_upd; > namespace bmupmu = ::boost::move_upmu; > template <class T> struct default_delete ; > } > namespace move_upd { > template <class P1, class P2> struct is_same_cvelement_and_convertible ;; > template<bool IsArray, class FromPointer, class ThisPointer> struct is_unique_ptr_convertible : is_same_cvelement_and_convertible<FromPointer, ThisPointer> {}; > template<class FromPointer, class ThisPointer> struct is_unique_ptr_convertible<false, FromPointer, ThisPointer> : bmupmu::is_convertible<FromPointer, ThisPointer> { > }; > template<class T, class FromPointer, class ThisPointer, class Type = bmupmu::nat> struct enable_up_ptr : bmupmu::enable_if_c< is_unique_ptr_convertible < bmupmu::is_array<T>::value, FromPointer, ThisPointer>::value, Type> { > }; > } > namespace movelib { > template <class T, class D = default_delete<T> > class unique_ptr { > private: typedef bmupmu::pointer_type<T, D > pointer_type_obtainer; > public: typedef typename pointer_type_obtainer::type pointer; > template<class Pointer> __attribute__ (()) explicit unique_ptr(Pointer p , typename bmupd::enable_up_ptr<T , Pointer , pointer>::type* =0 ) ; > }; > } > } > namespace boost { > template<class T> class weak_ptr { > public: typedef typename boost::detail::sp_element< T >::type element_type; > shared_ptr<T> lock() const noexcept ; > > }; > } > namespace boost { > namespace noncopyable_ { > struct base_token { > }; > class noncopyable: base_token { > protected: }; > } > typedef noncopyable_::noncopyable noncopyable; > > > template <class T, class Tag> struct static_ : boost::noncopyable { > private: struct destructor ;; > struct default_ctor { > }; > public: typedef T value_type; > typedef typename boost::call_traits<T>::reference reference; > typedef typename boost::call_traits<T>::const_reference const_reference; > static_(Tag = Tag()) ; > operator reference() ; > }; > > > template <typename T> class thread_specific_ptr { > public: typedef T element_type; > T* get() const ; > typename add_reference<T>::type operator*() const ; > void reset() ; > }; > } > namespace boost { > > > template <typename DerivedT, typename ContextT> struct grammar; > template <typename GrammarT, typename ScannerT> struct grammar_definition { > typedef typename GrammarT::template definition<ScannerT> type; > }; > > struct grammar_tag ;; > template <typename GrammarT> struct grammar_helper_base { > > }; > template <typename GrammarT> struct grammar_helper_list { > typedef grammar_helper_base<GrammarT> helper_t; > void push_back() ; > > boost::mutex m; > }; > struct grammartract_helper_list { > template<typename GrammarT> static grammar_helper_list<GrammarT>& do_() ; > }; > template <typename GrammarT, typename DerivedT, typename ScannerT> struct grammar_helper : private grammar_helper_base<GrammarT> { > typedef GrammarT grammar_t; > typedef ScannerT scanner_t; > typedef DerivedT derived_t; > typedef typename grammar_definition<DerivedT, ScannerT>::type definition_t; > typedef grammar_helper<grammar_t, derived_t, scanner_t> helper_t; > typedef boost::shared_ptr<helper_t> helper_ptr_t; > typedef boost::weak_ptr<helper_t> helper_weak_ptr_t; > grammar_helper* this_() { > } > grammar_helper(helper_weak_ptr_t& p) : definitions_cnt(0) , self() { > } > definition_t& define(grammar_t const* target_grammar) { > typename grammar_t::object_id id = 0; > boost::movelib::unique_ptr<definition_t> result(new definition_t(target_grammar->derived())); > } > int undefine() { > typename grammar_t::object_id id = 0; > } > private: vector<definition_t*> definitions; > unsigned long definitions_cnt; > helper_ptr_t self; > }; > class get_definition_static_data_tag {}; > template<typename DerivedT, typename ContextT, typename ScannerT> inline typename DerivedT::template definition<ScannerT> & get_definition(grammar<DerivedT, ContextT> const* self) { > typedef grammar<DerivedT, ContextT> self_t; > typedef grammar_helper<self_t, DerivedT, ScannerT> helper_t; > typedef typename helper_t::helper_weak_ptr_t ptr_t; > boost::thread_specific_ptr<ptr_t> & tld_helper = static_<boost::thread_specific_ptr<ptr_t>, get_definition_static_data_tag>(); > if (!tld_helper.get()) 0; > ptr_t &helper = *tld_helper; > return helper.lock()->define(self); > } > template <int N> struct call_helper ;; > template <> struct call_helper<0> ;; > template<int N, typename DerivedT, typename ContextT, typename ScannerT> inline typename parser_result<grammar<DerivedT, ContextT>, ScannerT>::type grammar_parser_parse( grammar<DerivedT, ContextT> const* self, ScannerT const &scan) { > typedef typename parser_result<grammar<DerivedT, ContextT>, ScannerT>::type result_t; > typedef typename DerivedT::template definition<ScannerT> definition_t; > result_t result; > definition_t &def = get_definition<DerivedT, ContextT, ScannerT>(self); > 0; > return result; > } > template<typename GrammarT> inline void grammar_destruct(void) { > GrammarT * self = 0;} > template <typename DerivedT, int N, typename ContextT> class entry_grammar : public parser<entry_grammar<DerivedT, N, ContextT> > { > public: typedef entry_grammar self_t; > typedef self_t embed_t; > typedef typename ContextT::context_linker_t context_t; > typedef typename context_t::attr_t attr_t; > template <typename ScannerT> struct result ; > private: DerivedT const &target_grammar; > }; > > template <typename DerivedT, typename ContextT = parser_context<> > struct grammar : public parser<DerivedT> , public ContextT::base_t , public context_aux<ContextT, DerivedT> , public object_with_id<grammar_tag> { > typedef grammar<DerivedT, ContextT> self_t; > typedef DerivedT const& embed_t; > typedef typename ContextT::context_linker_t context_t; > typedef typename context_t::attr_t attr_t; > template <typename ScannerT> struct result { > typedef typename match_result<ScannerT, attr_t>::type type; > }; > template <typename ScannerT> typename parser_result<self_t, ScannerT>::type parse_main(ScannerT const& scan) const { > return grammar_parser_parse<0>(this, scan); > } > template <typename ScannerT> typename parser_result<self_t, ScannerT>::type parse(ScannerT const& scan) const { > typedef typename parser_result<self_t, ScannerT>::type result_t; > typedef parser_scanner_linker<ScannerT> scanner_t; > scanner_t scan_wrap(scan); > context_t context_wrap(*this); > result_t hit = parse_main(scan); > return context_wrap.post_parse(hit, *this, scan_wrap); > } > mutable grammar_helper_list<self_t> helpers; > }; > > > > } > namespace boost { > > > > template<typename T> struct default_as_parser { > typedef T type; > }; > struct char_as_parser ;; > struct wchar_as_parser ; > > template<typename T> struct as_parser : default_as_parser<T> {}; > > > } > namespace boost { > > > template <typename A, typename B> struct sequence : public binary<A, B, parser<sequence<A, B> > > { > }; > template <typename A, typename B> sequence<A, B> operator>>(parser<A> const& a, parser<B> const& b); > > > } > namespace boost { > > > > > } > namespace boost { > > > template <typename A, typename B> struct alternative : public binary<A, B, parser<alternative<A, B> > > { > ; > }; > template <typename A, typename B> alternative<A, B> operator|(parser<A> const& a, parser<B> const& b); > > > struct difference_parser_gen; > template <typename A, typename B> struct difference : public binary<A, B, parser<difference<A, B> > > {}; > template <typename A, typename B> difference<A, B> operator-(parser<A> const& a, parser<B> const& b); > > > } > namespace boost { > > > struct exclusive_or_parser_gen; > struct kleene_star_parser_gen; > template <typename S> struct kleene_star : public unary<S, parser<kleene_star<S> > > { > typedef kleene_star<S> self_t; > typedef unary<S, parser<self_t> > base_t; > kleene_star(S const& a) : base_t() { > } > }; > struct kleene_star_parser_gen ; > template <typename S> kleene_star<S> operator*(parser<S> const& a); > > > template <typename S> struct positive : public unary<S, parser<positive<S> > > { > typedef positive<S> self_t; > typedef unary<S, parser<self_t> > base_t; > positive(void) : base_t() { > const S & a; > } > }; > template <typename S> inline positive<S> operator+(parser<S> const& a); > > > > > template <typename S> struct Trans_NS_classic_optional : public unary<S, parser<Trans_NS_classic_optional<S> > > { > typedef Trans_NS_classic_optional<S> self_t; > typedef unary<S, parser<self_t> > base_t; > }; > template <typename S> Trans_NS_classic_optional<S> operator!(parser<S> const& a); > > > template <typename T> struct is_parser { > static const bool value = (::boost::is_base_and_derived<parser<T>, T>::value) ; > }; > > > > > template <typename CondT, bool positive_ = true> struct condition_parser : parser<condition_parser<CondT, positive_> > { > }; > struct empty_match_parser_gen; > template<typename SubjectT> struct empty_match_parser : unary<SubjectT, parser<empty_match_parser<SubjectT> > > { > template <typename ScannerT> struct result ;; > ; > }; > > template <typename SubjectT> struct epsilon_selector { > typedef typename as_parser<SubjectT>::type subject_t; > typedef typename mpl::if_< is_parser<subject_t> ,empty_match_parser<subject_t> ,condition_parser<subject_t> >::type type; > }; > > struct epsilon_parser : public parser<epsilon_parser> { > template <typename SubjectT> typename epsilon_selector<SubjectT>::type operator()() const ; > }; > epsilon_parser const eps_p = epsilon_parser(); > > > template <typename ValueT = nil_t> class node_val_data_factory; > template < typename IteratorT, typename NodeFactoryT = node_val_data_factory<>, typename T = nil_t > class tree_match; > template < typename IteratorT = char const *, typename NodeFactoryT = node_val_data_factory<nil_t>, typename T = nil_t > struct tree_parse_info; > > > } > namespace boost { > > > template <typename T> struct tree_node { > typedef allocator<tree_node<T> > allocator_type; > typedef vector<tree_node<T>, allocator_type> children_t; > children_t children; > }; > template <typename IteratorT = char const*, typename ValueT = nil_t> struct node_val_data ;; > template <typename ValueT> class node_val_data_factory { > public: template <typename IteratorT> class factory { > public: typedef IteratorT iterator_t; > typedef node_val_data<> node_t; > }; > }; > template <typename IteratorT, typename NodeFactoryT, typename T> class tree_match : public match<> {}; > template < typename MatchPolicyT, typename IteratorT, typename NodeFactoryT, typename TreePolicyT, typename T > struct common_tree_match_policy : public match_policy { > ; > template <typename U> struct result { > typedef tree_match<IteratorT, NodeFactoryT, U> type; > }; > typedef tree_match<IteratorT, NodeFactoryT, T> match_t; > }; > struct no_tree_gen_node_parser_gen; > template <typename T> struct no_tree_gen_node_parser : public unary<T, parser<no_tree_gen_node_parser<T> > > { > typedef unary_parser_category parser_category_t; > }; > struct no_tree_gen_node_parser_gen { > template <typename T> struct result ; > template <typename T> no_tree_gen_node_parser<T> operator[](parser<T> const& s) const ; > }; > const no_tree_gen_node_parser_gen no_node_d = no_tree_gen_node_parser_gen(); > template < typename IteratorT, typename NodeFactoryT, typename T > struct tree_parse_info {}; > template < typename MatchPolicyT, typename NodeFactoryT, typename T = nil_t > struct pt_tree_policy; > template < typename IteratorT, typename NodeFactoryT = node_val_data_factory<>, typename T = nil_t > struct pt_match_policy; > > > template < typename IteratorT, typename NodeFactoryT, typename T > struct pt_match_policy : public common_tree_match_policy< pt_match_policy<IteratorT, NodeFactoryT, T>, IteratorT, NodeFactoryT, pt_tree_policy< pt_match_policy<IteratorT, NodeFactoryT, T>, NodeFactoryT, T >, T > { > typedef common_tree_match_policy< pt_match_policy, IteratorT, NodeFactoryT, pt_tree_policy< pt_match_policy, NodeFactoryT, T >, T > common_tree_match_policy_; > pt_match_policy() ; > }; > struct non_nested ; > struct non_lexeme { > }; > template < typename OpenT, typename ExprT, typename CloseT, typename CategoryT, typename NestedT, typename LexemeT > struct confix_parser : public parser< confix_parser<OpenT, ExprT, CloseT, CategoryT, NestedT, LexemeT> > { > typename as_parser<CloseT>::type::embed_t close; > }; > template<typename NestedT, typename LexemeT> struct confix_parser_gen { > template<typename StartT, typename ExprT, typename EndT> struct paren_op_result_type { > typedef confix_parser< typename as_parser<StartT>::type, typename as_parser<ExprT>::type, typename as_parser<EndT>::type, typename as_parser<ExprT>::type::parser_category_t, NestedT, LexemeT > type; > }; > template<typename StartT, typename ExprT, typename EndT> typename paren_op_result_type<StartT, ExprT, EndT>::type operator()(StartT const &start_, ExprT const &expr_, EndT const &end_) const ; > template<typename StartT, typename ExprT, typename EndT> struct direct_result_type ; > }; > const confix_parser_gen<non_nested, non_lexeme> confix_p = confix_parser_gen<non_nested, non_lexeme>(); > > > > > struct no_list_endtoken; > template < typename ItemT, typename DelimT, typename EndT = no_list_endtoken, typename CategoryT = plain_parser_category > struct list_parser; > > > > > template < typename ItemT, typename DelimT, typename EndT, typename CategoryT > struct list_parser : public parser<list_parser<ItemT, DelimT, EndT, CategoryT> > { > ; > typename as_parser<DelimT>::type::embed_t delim; > }; > template <typename CharT = char> struct list_parser_gen : public list_parser<kleene_star<anychar_parser>, chlit<CharT> > { > typedef list_parser_gen self_t; > list_parser_gen() ; > template<typename ItemT, typename DelimT> list_parser< typename as_parser<ItemT>::type, typename as_parser<DelimT>::type, no_list_endtoken, typename as_parser<ItemT>::type::parser_category_t > operator()(ItemT const &item_, DelimT const &delim_) const ; > }; > const list_parser_gen<> list_p = list_parser_gen<>(); > ; > ; > template <typename T, typename UserAllocator, typename Mutex, unsigned NextSize, unsigned MaxSize > class fast_pool_allocator ; > > > template <typename LexIteratorT, typename TokenContainerT> struct __attribute__((__visibility__("default"))) cpp_grammar_gen { > typedef LexIteratorT iterator_type; > typedef typename LexIteratorT::token_type token_type; > typedef TokenContainerT token_container_type; > typedef typename token_type::position_type position_type; > typedef boost::node_val_data_factory< > node_factory_type; > static boost::tree_parse_info<iterator_type, node_factory_type> parse_cpp_grammar (iterator_type const &first, iterator_type const &last, position_type const &act_pos, bool &found_eof, token_type &found_directive, token_container_type &found_eoltokens); > }; > template <typename CharT = char> struct pattern_and : public boost::char_parser<pattern_and<CharT> > { > unsigned long pattern_mask; > }; > template <typename CharT> pattern_and<CharT> pattern_p(CharT pattern, unsigned long pattern_mask = 0UL) ; > > > > struct store_found_eof ; > template <typename TokenT> struct store_found_directive { > store_found_directive(void) ; > }; > template <typename ContainerT> struct store_found_eoltokens ;; > struct flush_underlying_parser : public boost::parser<flush_underlying_parser> { > }; > > template <typename TokenT, typename ContainerT> struct cpp_grammar : public boost::grammar<cpp_grammar<TokenT, ContainerT> > { > typedef store_found_directive<TokenT> store_found_directive_type; > template <typename ScannerT> struct definition { > typedef typename ScannerT::iteration_policy_t iteration_policy_t; > typedef boost::match_policy match_policy_t; > typedef typename ScannerT::action_policy_t action_policy_t; > typedef boost::scanner_policies<> policies_t; > typedef boost::scanner<typename ScannerT::iterator_t, policies_t> non_tree_scanner_t; > typedef boost::rule< non_tree_scanner_t, boost::dynamic_parser_tag> no_tree_rule_type; > typedef boost::rule<> rule_type; > rule_type pp_statement, macro_include_file; > rule_type plain_define, macro_definition, macro_parameters; > rule_type ppqualifiedname; > no_tree_rule_type ppsp; > pattern_and<> __trans_tmp_1; >definition(cpp_grammar const &self) { > using namespace boost; > using namespace boost::util; > boost::chlit<char> __trans_tmp_1 = ch_p(T_PP_DEFINE); > boost::alternative<boost::chlit<char>, boost::chlit<char> > __trans_tmp_2 = ch_p(T_IDENTIFIER) | __trans_tmp_1; > plain_define = no_node_d [ __trans_tmp_1 >> +ppsp ] >> ( __trans_tmp_2 | pattern_p(OperatorTokenType|AltExtTokenType, ExtTokenTypeMask|PPTokenFlag) | pattern_p(BoolLiteralTokenType, TokenTypeMask|PPTokenFlag) ) >> ( ( no_node_d[eps_p] >> macro_parameters >> !macro_definition ) | !( no_node_d[+ppsp] >> macro_definition ) ) ; > macro_parameters = confix_p( no_node_d[ch_p(T_LEFTPAREN) >> *ppsp], !list_p( ( ch_p(T_IDENTIFIER) | pattern_p(KeywordTokenType, TokenTypeMask|PPTokenFlag) | pattern_p(OperatorTokenType|AltExtTokenType, ExtTokenTypeMask|PPTokenFlag) | pattern_p(BoolLiteralTokenType, TokenTypeMask|PPTokenFlag) | ch_p(T_ELLIPSIS) ), no_node_d[*ppsp >> ch_p(T_COMMA) >> *ppsp] ), no_node_d[*ppsp >> ch_p(T_RIGHTPAREN)] ) ; > macro_definition = no_node_d[*ppsp] >> *( anychar_p - (ch_p(T_NEWLINE) | ch_p(T_CPPCOMMENT) | ch_p(T_EOF)) ) ; > } > rule_type const& start() const ; > }; > bool &found_eof; > TokenT &found_directive; > ContainerT &found_eoltokens; > cpp_grammar(bool &found_eof_, TokenT &found_directive_, ContainerT &found_eoltokens_) : found_eof(found_eof_), found_directive(found_directive_), found_eoltokens(found_eoltokens_) { > ; > } > }; > template <typename NodeFactoryT, typename IteratorT, typename ParserT> inline boost::tree_parse_info<IteratorT, NodeFactoryT> parsetree_parse(IteratorT const& first_, IteratorT const& last, boost::parser<ParserT> const& p) { > using namespace boost; > typedef pt_match_policy<IteratorT, NodeFactoryT> pt_match_policy_type; > typedef scanner_policies<iteration_policy, pt_match_policy_type> scanner_policies_type; > typedef scanner<IteratorT, scanner_policies_type> scanner_type; > scanner_policies_type policies; > IteratorT first = first_; > scanner_type scan(first, last, policies); > tree_match<IteratorT, NodeFactoryT> hit = p.derived().parse(scan); > } > template <typename LexIteratorT, typename TokenContainerT> boost::tree_parse_info< LexIteratorT, typename cpp_grammar_gen<LexIteratorT, TokenContainerT>::node_factory_type > cpp_grammar_gen<LexIteratorT, TokenContainerT>::parse_cpp_grammar ( LexIteratorT const &first, LexIteratorT const &last, position_type const &act_pos, bool &found_eof, token_type &found_directive, token_container_type &found_eoltokens) { > using namespace boost; > using namespace boost; > cpp_grammar<token_type, TokenContainerT> g(found_eof, found_directive, found_eoltokens); > tree_parse_info<LexIteratorT, node_factory_type> hit = parsetree_parse<node_factory_type>(first, last, g); > return hit; > } > > > } > typedef boost::cpplexer::lex_token<> token_type; > typedef boost::cpplexer::lex_iterator<token_type> lexer_type; > typedef Trans_NS___cxx11_list<token_type, boost::fast_pool_allocator<token_type> > token_sequence_type; > template struct __attribute__((__visibility__("default"))) boost::cpp_grammar_gen<lexer_type, token_sequence_type>;
You cannot view the attachment while viewing its details because your browser does not support IFRAMEs.
View the attachment on a separate page
.
View Attachment As Raw
Actions:
View
Attachments on
bug 730406
:
647330
|
650084
|
650112
|
650230
|
650246
|
650402
|
650644
|
650886
|
650896
|
651584
|
651586
|
651680
|
652808
|
652810
|
652812
|
653616
|
653939
|
656910
|
656980