Skip to content

Instantly share code, notes, and snippets.

@eschnett

eschnett/tree-2dac1a.cpp

Created July 26, 2014 13:46
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save eschnett/9324a9e249b8cd52dbea to your computer and use it in GitHub Desktop.
Save eschnett/9324a9e249b8cd52dbea to your computer and use it in GitHub Desktop.
Download ZIP
preprocessed source
Raw
tree-2dac1a.cpp
This file has been truncated, but you can view the full file.
# 1 "<built-in>" 1
# 1 "tree.i" 1
# 1 "tree.cc"
# 1 "<built-in>" 1
# 1 "<built-in>" 3
# 194 "<built-in>" 3
# 1 "<command line>" 1
# 1 "<built-in>" 2
# 1 "tree.cc" 2
# 1 "./rpc.hh" 1
# 1 "./first.hh" 1
# 5 "./rpc.hh" 2
# 1 "./cxx_invoke.hh" 1
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 1
# 59 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 3
# 68 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/c++config.h" 1 3
# 186 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/c++config.h" 3
namespace std {
typedef long unsigned int size_t;
typedef long int ptrdiff_t;
typedef decltype(nullptr) nullptr_t;
}
# 430 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/c++config.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/os_defines.h" 1 3
# 431 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/c++config.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/cpu_defines.h" 1 3
# 434 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/c++config.h" 2 3
# 69 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_relops.h" 1 3
# 67 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_relops.h" 3
namespace std __attribute__((__visibility__("default"))) {
namespace rel_ops {
# 85 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_relops.h" 3
template <class _Tp> inline bool operator!=(const _Tp &__x, const _Tp &__y) {
return !(__x == __y);
}
# 98 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_relops.h" 3
template <class _Tp> inline bool operator>(const _Tp &__x, const _Tp &__y) {
return __y < __x;
}
# 111 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_relops.h" 3
template <class _Tp> inline bool operator<=(const _Tp &__x, const _Tp &__y) {
return !(__y < __x);
}
# 124 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_relops.h" 3
template <class _Tp> inline bool operator>=(const _Tp &__x, const _Tp &__y) {
return !(__x < __y);
}
}
}
# 70 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_pair.h" 1 3
# 59 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_pair.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/concept_check.h" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/concept_check.h" 3
# 35 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _Tp> inline _Tp *__addressof(_Tp & __r) noexcept {
return reinterpret_cast<_Tp *>(
&const_cast<char &>(reinterpret_cast<const volatile char &>(__r)));
}
}
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
namespace std __attribute__((__visibility__("default"))) {
# 56 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp, _Tp __v> struct integral_constant {
static constexpr _Tp value = __v;
typedef _Tp value_type;
typedef integral_constant<_Tp, __v> type;
constexpr operator value_type() const { return value; }
};
template <typename _Tp, _Tp __v>
constexpr _Tp integral_constant<_Tp, __v>::value;
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
template <bool, typename, typename> struct conditional;
template <typename...> struct __or_;
template <> struct __or_<> : public false_type {};
template <typename _B1> struct __or_<_B1> : public _B1 {};
template <typename _B1, typename _B2>
struct __or_<_B1, _B2> : public conditional<_B1::value, _B1, _B2>::type {};
template <typename _B1, typename _B2, typename _B3, typename... _Bn>
struct __or_<_B1, _B2, _B3,
_Bn...> : public conditional<_B1::value, _B1,
__or_<_B2, _B3, _Bn...> >::type {};
template <typename...> struct __and_;
template <> struct __and_<> : public true_type {};
template <typename _B1> struct __and_<_B1> : public _B1 {};
template <typename _B1, typename _B2>
struct __and_<_B1, _B2> : public conditional<_B1::value, _B2, _B1>::type {};
template <typename _B1, typename _B2, typename _B3, typename... _Bn>
struct __and_<_B1, _B2, _B3,
_Bn...> : public conditional<_B1::value,
__and_<_B2, _B3, _Bn...>,
_B1>::type {};
template <typename _Pp>
struct __not_ : public integral_constant<bool, !_Pp::value> {};
template <typename _Tp> struct __success_type {
typedef _Tp type;
};
struct __failure_type {};
template <typename> struct remove_cv;
template <typename> struct __is_void_helper : public false_type {};
template <> struct __is_void_helper<void> : public true_type {};
template <typename _Tp>
struct is_void
: public __is_void_helper<typename remove_cv<_Tp>::type>::type {};
template <typename> struct __is_integral_helper : public false_type {};
template <> struct __is_integral_helper<bool> : public true_type {};
template <> struct __is_integral_helper<char> : public true_type {};
template <> struct __is_integral_helper<signed char> : public true_type {};
template <> struct __is_integral_helper<unsigned char> : public true_type {};
template <> struct __is_integral_helper<wchar_t> : public true_type {};
template <> struct __is_integral_helper<char16_t> : public true_type {};
template <> struct __is_integral_helper<char32_t> : public true_type {};
template <> struct __is_integral_helper<short> : public true_type {};
template <> struct __is_integral_helper<unsigned short> : public true_type {};
template <> struct __is_integral_helper<int> : public true_type {};
template <> struct __is_integral_helper<unsigned int> : public true_type {};
template <> struct __is_integral_helper<long> : public true_type {};
template <> struct __is_integral_helper<unsigned long> : public true_type {};
template <> struct __is_integral_helper<long long> : public true_type {};
template <>
struct __is_integral_helper<unsigned long long> : public true_type {};
# 241 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp>
struct is_integral
: public __is_integral_helper<typename remove_cv<_Tp>::type>::type {};
template <typename> struct __is_floating_point_helper : public false_type {};
template <> struct __is_floating_point_helper<float> : public true_type {};
template <> struct __is_floating_point_helper<double> : public true_type {};
template <>
struct __is_floating_point_helper<long double> : public true_type {};
# 269 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp>
struct is_floating_point
: public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type {
};
template <typename> struct is_array : public false_type {};
template <typename _Tp, std::size_t _Size>
struct is_array<_Tp[_Size]> : public true_type {};
template <typename _Tp> struct is_array<_Tp[]> : public true_type {};
template <typename> struct __is_pointer_helper : public false_type {};
template <typename _Tp>
struct __is_pointer_helper<_Tp *> : public true_type {};
template <typename _Tp>
struct is_pointer
: public __is_pointer_helper<typename remove_cv<_Tp>::type>::type {};
template <typename> struct is_lvalue_reference : public false_type {};
template <typename _Tp>
struct is_lvalue_reference<_Tp &> : public true_type {};
template <typename> struct is_rvalue_reference : public false_type {};
template <typename _Tp>
struct is_rvalue_reference<_Tp &&> : public true_type {};
template <typename> struct is_function;
template <typename>
struct __is_member_object_pointer_helper : public false_type {};
template <typename _Tp, typename _Cp>
struct __is_member_object_pointer_helper<
_Tp _Cp::*> : public integral_constant<bool, !is_function<_Tp>::value> {};
template <typename _Tp>
struct is_member_object_pointer : public __is_member_object_pointer_helper<
typename remove_cv<_Tp>::type>::type {};
template <typename>
struct __is_member_function_pointer_helper : public false_type {};
template <typename _Tp, typename _Cp>
struct __is_member_function_pointer_helper<
_Tp _Cp::*> : public integral_constant<bool, is_function<_Tp>::value> {};
template <typename _Tp>
struct is_member_function_pointer
: public __is_member_function_pointer_helper<
typename remove_cv<_Tp>::type>::type {};
template <typename _Tp>
struct is_enum : public integral_constant<bool, __is_enum(_Tp)> {};
template <typename _Tp>
struct is_union : public integral_constant<bool, __is_union(_Tp)> {};
template <typename _Tp>
struct is_class : public integral_constant<bool, __is_class(_Tp)> {};
template <typename> struct is_function : public false_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...)> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) &> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) && > : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......)> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) &> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) && > : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const &> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const && > : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const &> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const && > : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) volatile> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) volatile &> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) volatile && > : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) volatile> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) volatile &> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) volatile && > : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const volatile> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const volatile &> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const volatile && > : public true_type {
};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const volatile> : public true_type {
};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const
volatile &> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<
_Res(_ArgTypes......) const volatile && > : public true_type {};
template <typename> struct __is_null_pointer_helper : public false_type {};
template <>
struct __is_null_pointer_helper<std::nullptr_t> : public true_type {};
template <typename _Tp>
struct is_null_pointer
: public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type {};
template <typename _Tp>
struct __is_nullptr_t : public is_null_pointer<_Tp> {};
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 _Tp>
struct is_fundamental : public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
is_null_pointer<_Tp> >::type {};
template <typename _Tp>
struct is_object : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
is_void<_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 _Tp>
struct is_compound
: public integral_constant<bool, !is_fundamental<_Tp>::value> {};
template <typename _Tp>
struct __is_member_pointer_helper : public false_type {};
template <typename _Tp, typename _Cp>
struct __is_member_pointer_helper<_Tp _Cp::*> : public true_type {};
template <typename _Tp>
struct is_member_pointer
: public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type {
};
template <typename _Tp>
struct __is_referenceable
: public __or_<is_object<_Tp>, is_reference<_Tp> >::type {};
template <typename _Res, typename... _Args>
struct __is_referenceable<_Res(_Args...)> : public true_type {};
template <typename _Res, typename... _Args>
struct __is_referenceable<_Res(_Args......)> : public true_type {};
template <typename> struct is_const : public false_type {};
template <typename _Tp> struct is_const<_Tp const> : public true_type {};
template <typename> struct is_volatile : public false_type {};
template <typename _Tp>
struct is_volatile<_Tp volatile> : public true_type {};
template <typename _Tp>
struct is_trivial : public integral_constant<bool, __is_trivial(_Tp)> {};
template <typename _Tp>
struct is_standard_layout
: public integral_constant<bool, __is_standard_layout(_Tp)> {};
template <typename _Tp>
struct is_pod : public integral_constant<bool, __is_pod(_Tp)> {};
template <typename _Tp>
struct is_literal_type
: public integral_constant<bool, __is_literal_type(_Tp)> {};
template <typename _Tp>
struct is_empty : public integral_constant<bool, __is_empty(_Tp)> {};
template <typename _Tp>
struct is_polymorphic
: public integral_constant<bool, __is_polymorphic(_Tp)> {};
template <typename _Tp>
struct is_abstract : public integral_constant<bool, __is_abstract(_Tp)> {};
template <typename _Tp, bool = is_arithmetic<_Tp>::value>
struct __is_signed_helper : public false_type {};
template <typename _Tp>
struct __is_signed_helper<_Tp, true> : public integral_constant < bool,
_Tp(-1)<_Tp(0)> {};
template <typename _Tp>
struct is_signed : public __is_signed_helper<_Tp>::type {};
template <typename _Tp>
struct is_unsigned
: public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp> > >::type {};
template <typename> struct add_rvalue_reference;
template <typename _Tp>
typename add_rvalue_reference<_Tp>::type declval() noexcept;
template <typename, unsigned = 0> struct extent;
template <typename> struct remove_all_extents;
template <typename _Tp>
struct __is_array_known_bounds
: public integral_constant<bool, (extent<_Tp>::value > 0)> {};
template <typename _Tp>
struct __is_array_unknown_bounds
: public __and_<is_array<_Tp>, __not_<extent<_Tp> > >::type {};
struct __do_is_destructible_impl {
template <typename _Tp, typename = decltype(declval<_Tp &>().~_Tp())>
static true_type __test(int);
template <typename> static false_type __test(...);
};
template <typename _Tp>
struct __is_destructible_impl : public __do_is_destructible_impl {
typedef decltype(__test<_Tp>(0)) type;
};
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_destructible_safe;
template <typename _Tp>
struct __is_destructible_safe<
_Tp, false,
false> : public __is_destructible_impl<typename remove_all_extents<_Tp>::
type>::type {};
template <typename _Tp>
struct __is_destructible_safe<_Tp, true, false> : public false_type {};
template <typename _Tp>
struct __is_destructible_safe<_Tp, false, true> : public true_type {};
template <typename _Tp>
struct is_destructible : public __is_destructible_safe<_Tp>::type {};
struct __do_is_nt_destructible_impl {
template <typename _Tp>
static integral_constant<bool, noexcept(declval<_Tp &>().~_Tp())>
__test(int);
template <typename> static false_type __test(...);
};
template <typename _Tp>
struct __is_nt_destructible_impl : public __do_is_nt_destructible_impl {
typedef decltype(__test<_Tp>(0)) type;
};
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>
struct __is_nt_destructible_safe<_Tp, true, false> : public false_type {};
template <typename _Tp>
struct __is_nt_destructible_safe<_Tp, false, true> : public true_type {};
template <typename _Tp>
struct is_nothrow_destructible : public __is_nt_destructible_safe<_Tp>::type {
};
struct __do_is_default_constructible_impl {
template <typename _Tp, typename = decltype(_Tp())>
static true_type __test(int);
template <typename> static false_type __test(...);
};
template <typename _Tp>
struct __is_default_constructible_impl
: public __do_is_default_constructible_impl {
typedef decltype(__test<_Tp>(0)) type;
};
template <typename _Tp>
struct __is_default_constructible_atom
: public __and_<__not_<is_void<_Tp> >,
__is_default_constructible_impl<_Tp> >::type {};
template <typename _Tp, bool = is_array<_Tp>::value>
struct __is_default_constructible_safe;
template <typename _Tp>
struct __is_default_constructible_safe<
_Tp, true> : public __and_<__is_array_known_bounds<_Tp>,
__is_default_constructible_atom<
typename remove_all_extents<_Tp>::type> >::
type {};
template <typename _Tp>
struct __is_default_constructible_safe<
_Tp, false> : public __is_default_constructible_atom<_Tp>::type {};
template <typename _Tp>
struct is_default_constructible
: public __is_default_constructible_safe<_Tp>::type {};
# 838 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
struct __do_is_static_castable_impl {
template <typename _From, typename _To,
typename = decltype(static_cast<_To>(declval<_From>()))>
static true_type __test(int);
template <typename, typename> static false_type __test(...);
};
template <typename _From, typename _To>
struct __is_static_castable_impl : public __do_is_static_castable_impl {
typedef decltype(__test<_From, _To>(0)) type;
};
template <typename _From, typename _To>
struct __is_static_castable_safe
: public __is_static_castable_impl<_From, _To>::type {};
template <typename _From, typename _To>
struct __is_static_castable
: public integral_constant<
bool, (__is_static_castable_safe<_From, _To>::value)> {};
struct __do_is_direct_constructible_impl {
template <typename _Tp, typename _Arg,
typename = decltype(::new _Tp(declval<_Arg>()))>
static true_type __test(int);
template <typename, typename> static false_type __test(...);
};
template <typename _Tp, typename _Arg>
struct __is_direct_constructible_impl
: public __do_is_direct_constructible_impl {
typedef decltype(__test<_Tp, _Arg>(0)) type;
};
template <typename _Tp, typename _Arg>
struct __is_direct_constructible_new_safe
: public __and_<is_destructible<_Tp>,
__is_direct_constructible_impl<_Tp, _Arg> >::type {};
template <typename, typename> struct is_same;
template <typename, typename> struct is_base_of;
template <typename> struct remove_reference;
template <typename _From, typename _To,
bool = __not_<__or_<is_void<_From>, is_function<_From> > >::value>
struct __is_base_to_derived_ref;
template <typename _From, typename _To>
struct __is_base_to_derived_ref<_From, _To, true> {
typedef typename remove_cv<typename remove_reference<_From>::type>::type
__src_t;
typedef typename remove_cv<typename remove_reference<_To>::type>::type
__dst_t;
typedef __and_<__not_<is_same<__src_t, __dst_t> >,
is_base_of<__src_t, __dst_t> > type;
static constexpr bool value = type::value;
};
template <typename _From, typename _To>
struct __is_base_to_derived_ref<_From, _To, false> : public false_type {};
template <typename _From, typename _To,
bool = __and_<is_lvalue_reference<_From>,
is_rvalue_reference<_To> >::value>
struct __is_lvalue_to_rvalue_ref;
template <typename _From, typename _To>
struct __is_lvalue_to_rvalue_ref<_From, _To, true> {
typedef typename remove_cv<typename remove_reference<_From>::type>::type
__src_t;
typedef typename remove_cv<typename remove_reference<_To>::type>::type
__dst_t;
typedef __and_<
__not_<is_function<__src_t> >,
__or_<is_same<__src_t, __dst_t>, is_base_of<__dst_t, __src_t> > > type;
static constexpr bool value = type::value;
};
template <typename _From, typename _To>
struct __is_lvalue_to_rvalue_ref<_From, _To, false> : public false_type {};
template <typename _Tp, typename _Arg>
struct __is_direct_constructible_ref_cast
: public __and_<
__is_static_castable<_Arg, _Tp>,
__not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>,
__is_lvalue_to_rvalue_ref<_Arg, _Tp> > > >::type {};
template <typename _Tp, typename _Arg>
struct __is_direct_constructible_new
: public conditional<
is_reference<_Tp>::value,
__is_direct_constructible_ref_cast<_Tp, _Arg>,
__is_direct_constructible_new_safe<_Tp, _Arg> >::type {};
template <typename _Tp, typename _Arg>
struct __is_direct_constructible
: public __is_direct_constructible_new<_Tp, _Arg>::type {};
struct __do_is_nary_constructible_impl {
template <typename _Tp, typename... _Args,
typename = decltype(_Tp(declval<_Args>()...))>
static true_type __test(int);
template <typename, typename...> static false_type __test(...);
};
template <typename _Tp, typename... _Args>
struct __is_nary_constructible_impl : public __do_is_nary_constructible_impl {
typedef decltype(__test<_Tp, _Args...>(0)) type;
};
template <typename _Tp, typename... _Args>
struct __is_nary_constructible
: public __is_nary_constructible_impl<_Tp, _Args...>::type {
static_assert(sizeof...(_Args) > 1, "Only useful for > 1 arguments");
};
template <typename _Tp, typename... _Args>
struct __is_constructible_impl
: public __is_nary_constructible<_Tp, _Args...> {};
template <typename _Tp, typename _Arg>
struct __is_constructible_impl<_Tp, _Arg> : public __is_direct_constructible<
_Tp, _Arg> {};
template <typename _Tp>
struct __is_constructible_impl<_Tp> : public is_default_constructible<_Tp> {};
template <typename _Tp, typename... _Args>
struct is_constructible
: public __is_constructible_impl<_Tp, _Args...>::type {};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_copy_constructible_impl;
template <typename _Tp>
struct __is_copy_constructible_impl<_Tp, false> : public false_type {};
template <typename _Tp>
struct __is_copy_constructible_impl<_Tp, true> : public is_constructible<
_Tp, const _Tp &> {};
template <typename _Tp>
struct is_copy_constructible : public __is_copy_constructible_impl<_Tp> {};
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_impl<_Tp, true> : public is_constructible<
_Tp, _Tp &&> {};
template <typename _Tp>
struct is_move_constructible : public __is_move_constructible_impl<_Tp> {};
template <typename _Tp>
struct __is_nt_default_constructible_atom
: public integral_constant<bool, noexcept(_Tp())> {};
template <typename _Tp, bool = is_array<_Tp>::value>
struct __is_nt_default_constructible_impl;
template <typename _Tp>
struct __is_nt_default_constructible_impl<
_Tp, true> : public __and_<__is_array_known_bounds<_Tp>,
__is_nt_default_constructible_atom<
typename remove_all_extents<_Tp>::type> >::
type {};
template <typename _Tp>
struct __is_nt_default_constructible_impl<
_Tp, false> : public __is_nt_default_constructible_atom<_Tp> {};
template <typename _Tp>
struct is_nothrow_default_constructible
: public __and_<is_default_constructible<_Tp>,
__is_nt_default_constructible_impl<_Tp> >::type {};
template <typename _Tp, typename... _Args>
struct __is_nt_constructible_impl
: public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))> {};
template <typename _Tp, typename _Arg>
struct __is_nt_constructible_impl<_Tp, _Arg> : public integral_constant<
bool,
noexcept(static_cast<_Tp>(
declval<_Arg>()))> {};
template <typename _Tp>
struct __is_nt_constructible_impl<
_Tp> : public is_nothrow_default_constructible<_Tp> {};
template <typename _Tp, typename... _Args>
struct is_nothrow_constructible
: public __and_<is_constructible<_Tp, _Args...>,
__is_nt_constructible_impl<_Tp, _Args...> >::type {};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nothrow_copy_constructible_impl;
template <typename _Tp>
struct __is_nothrow_copy_constructible_impl<_Tp, false> : public false_type {
};
template <typename _Tp>
struct __is_nothrow_copy_constructible_impl<
_Tp, true> : public is_nothrow_constructible<_Tp, const _Tp &> {};
template <typename _Tp>
struct is_nothrow_copy_constructible
: public __is_nothrow_copy_constructible_impl<_Tp> {};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nothrow_move_constructible_impl;
template <typename _Tp>
struct __is_nothrow_move_constructible_impl<_Tp, false> : public false_type {
};
template <typename _Tp>
struct __is_nothrow_move_constructible_impl<
_Tp, true> : public is_nothrow_constructible<_Tp, _Tp &&> {};
template <typename _Tp>
struct is_nothrow_move_constructible
: public __is_nothrow_move_constructible_impl<_Tp> {};
template <typename _Tp, typename _Up> class __is_assignable_helper {
template <typename _Tp1, typename _Up1,
typename = decltype(declval<_Tp1>() = declval<_Up1>())>
static true_type __test(int);
template <typename, typename> static false_type __test(...);
public:
typedef decltype(__test<_Tp, _Up>(0)) type;
};
template <typename _Tp, typename _Up>
struct is_assignable : public __is_assignable_helper<_Tp, _Up>::type {};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_copy_assignable_impl;
template <typename _Tp>
struct __is_copy_assignable_impl<_Tp, false> : public false_type {};
template <typename _Tp>
struct __is_copy_assignable_impl<_Tp, true> : public is_assignable<
_Tp &, const _Tp &> {};
template <typename _Tp>
struct is_copy_assignable : public __is_copy_assignable_impl<_Tp> {};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_move_assignable_impl;
template <typename _Tp>
struct __is_move_assignable_impl<_Tp, false> : public false_type {};
template <typename _Tp>
struct __is_move_assignable_impl<_Tp, true> : public is_assignable<_Tp &,
_Tp &&> {};
template <typename _Tp>
struct is_move_assignable : public __is_move_assignable_impl<_Tp> {};
template <typename _Tp, typename _Up>
struct __is_nt_assignable_impl
: public integral_constant<bool,
noexcept(declval<_Tp>() = declval<_Up>())> {};
template <typename _Tp, typename _Up>
struct is_nothrow_assignable
: public __and_<is_assignable<_Tp, _Up>,
__is_nt_assignable_impl<_Tp, _Up> >::type {};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nt_copy_assignable_impl;
template <typename _Tp>
struct __is_nt_copy_assignable_impl<_Tp, false> : public false_type {};
template <typename _Tp>
struct __is_nt_copy_assignable_impl<_Tp, true> : public is_nothrow_assignable<
_Tp &, const _Tp &> {};
template <typename _Tp>
struct is_nothrow_copy_assignable : public __is_nt_copy_assignable_impl<_Tp> {
};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nt_move_assignable_impl;
template <typename _Tp>
struct __is_nt_move_assignable_impl<_Tp, false> : public false_type {};
template <typename _Tp>
struct __is_nt_move_assignable_impl<_Tp, true> : public is_nothrow_assignable<
_Tp &, _Tp &&> {};
template <typename _Tp>
struct is_nothrow_move_assignable : public __is_nt_move_assignable_impl<_Tp> {
};
# 1274 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp>
struct is_trivially_destructible
: public __and_<
is_destructible<_Tp>,
integral_constant<bool, __has_trivial_destructor(_Tp)> >::type {};
template <typename _Tp>
struct has_trivial_default_constructor
: public integral_constant<bool, __has_trivial_constructor(_Tp)> {};
template <typename _Tp>
struct has_trivial_copy_constructor
: public integral_constant<bool, __has_trivial_copy(_Tp)> {};
template <typename _Tp>
struct has_trivial_copy_assign
: public integral_constant<bool, __has_trivial_assign(_Tp)> {};
template <typename _Tp>
struct has_virtual_destructor
: public integral_constant<bool, __has_virtual_destructor(_Tp)> {};
template <typename _Tp>
struct alignment_of
: public integral_constant<std::size_t, __alignof__(_Tp)> {};
template <typename> struct rank : public integral_constant<std::size_t, 0> {};
template <typename _Tp, std::size_t _Size>
struct rank<_Tp[_Size]> : public integral_constant<std::size_t,
1 + rank<_Tp>::value> {};
template <typename _Tp>
struct rank<_Tp[]> : public integral_constant<std::size_t,
1 + rank<_Tp>::value> {};
template <typename, unsigned _Uint>
struct extent : public integral_constant<std::size_t, 0> {};
template <typename _Tp, unsigned _Uint, std::size_t _Size>
struct extent<_Tp[_Size], _Uint> : public integral_constant < std::size_t,
_Uint == 0 ? _Size : extent<_Tp, _Uint - 1>::value > {};
template <typename _Tp, unsigned _Uint>
struct extent<_Tp[], _Uint> : public integral_constant < std::size_t,
_Uint == 0 ? 0 : extent<_Tp, _Uint - 1>::value > {};
template <typename, typename> struct is_same : public false_type {};
template <typename _Tp> struct is_same<_Tp, _Tp> : public true_type {};
template <typename _Base, typename _Derived>
struct is_base_of
: public integral_constant<bool, __is_base_of(_Base, _Derived)> {};
template <typename _From, typename _To,
bool =
__or_<is_void<_From>, is_function<_To>, is_array<_To> >::value>
struct __is_convertible_helper {
typedef typename is_void<_To>::type type;
};
template <typename _From, typename _To>
class __is_convertible_helper<_From, _To, false> {
template <typename _To1> static void __test_aux(_To1);
template <typename _From1, typename _To1,
typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
static true_type __test(int);
template <typename, typename> static false_type __test(...);
public:
typedef decltype(__test<_From, _To>(0)) type;
};
template <typename _From, typename _To>
struct is_convertible : public __is_convertible_helper<_From, _To>::type {};
template <typename _Tp> struct remove_const {
typedef _Tp type;
};
template <typename _Tp> struct remove_const<_Tp const> {
typedef _Tp type;
};
template <typename _Tp> struct remove_volatile {
typedef _Tp type;
};
template <typename _Tp> struct remove_volatile<_Tp volatile> {
typedef _Tp type;
};
template <typename _Tp> struct remove_cv {
typedef typename remove_const<typename remove_volatile<_Tp>::type>::type
type;
};
template <typename _Tp> struct add_const {
typedef _Tp const type;
};
template <typename _Tp> struct add_volatile {
typedef _Tp volatile type;
};
template <typename _Tp> struct add_cv {
typedef typename add_const<typename add_volatile<_Tp>::type>::type type;
};
# 1470 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp> struct remove_reference {
typedef _Tp type;
};
template <typename _Tp> struct remove_reference<_Tp &> {
typedef _Tp type;
};
template <typename _Tp> struct remove_reference<_Tp &&> {
typedef _Tp type;
};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_lvalue_reference_helper {
typedef _Tp type;
};
template <typename _Tp> struct __add_lvalue_reference_helper<_Tp, true> {
typedef _Tp &type;
};
template <typename _Tp>
struct add_lvalue_reference : public __add_lvalue_reference_helper<_Tp> {};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_rvalue_reference_helper {
typedef _Tp type;
};
template <typename _Tp> struct __add_rvalue_reference_helper<_Tp, true> {
typedef _Tp &&type;
};
template <typename _Tp>
struct add_rvalue_reference : public __add_rvalue_reference_helper<_Tp> {};
# 1527 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Unqualified, bool _IsConst, bool _IsVol>
struct __cv_selector;
template <typename _Unqualified>
struct __cv_selector<_Unqualified, false, false> {
typedef _Unqualified __type;
};
template <typename _Unqualified>
struct __cv_selector<_Unqualified, false, true> {
typedef volatile _Unqualified __type;
};
template <typename _Unqualified>
struct __cv_selector<_Unqualified, true, false> {
typedef const _Unqualified __type;
};
template <typename _Unqualified>
struct __cv_selector<_Unqualified, true, true> {
typedef const volatile _Unqualified __type;
};
template <typename _Qualified, typename _Unqualified,
bool _IsConst = is_const<_Qualified>::value,
bool _IsVol = is_volatile<_Qualified>::value>
class __match_cv_qualifiers {
typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
public:
typedef typename __match::__type __type;
};
template <typename _Tp> struct __make_unsigned {
typedef _Tp __type;
};
template <> struct __make_unsigned<char> {
typedef unsigned char __type;
};
template <> struct __make_unsigned<signed char> {
typedef unsigned char __type;
};
template <> struct __make_unsigned<short> {
typedef unsigned short __type;
};
template <> struct __make_unsigned<int> {
typedef unsigned int __type;
};
template <> struct __make_unsigned<long> {
typedef unsigned long __type;
};
template <> struct __make_unsigned<long long> {
typedef unsigned long long __type;
};
# 1593 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp, bool _IsInt = is_integral<_Tp>::value,
bool _IsEnum = is_enum<_Tp>::value>
class __make_unsigned_selector;
template <typename _Tp> class __make_unsigned_selector<_Tp, true, false> {
typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt;
typedef typename __unsignedt::__type __unsigned_type;
typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
public:
typedef typename __cv_unsigned::__type __type;
};
template <typename _Tp> class __make_unsigned_selector<_Tp, false, true> {
typedef unsigned char __smallest;
static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short);
static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int);
typedef conditional<__b2, unsigned int, unsigned long> __cond2;
typedef typename __cond2::type __cond2_type;
typedef conditional<__b1, unsigned short, __cond2_type> __cond1;
typedef typename __cond1::type __cond1_type;
public:
typedef typename conditional<__b0, __smallest, __cond1_type>::type __type;
};
template <typename _Tp> struct make_unsigned {
typedef typename __make_unsigned_selector<_Tp>::__type type;
};
template <> struct make_unsigned<bool>;
template <typename _Tp> struct __make_signed {
typedef _Tp __type;
};
template <> struct __make_signed<char> {
typedef signed char __type;
};
template <> struct __make_signed<unsigned char> {
typedef signed char __type;
};
template <> struct __make_signed<unsigned short> {
typedef signed short __type;
};
template <> struct __make_signed<unsigned int> {
typedef signed int __type;
};
template <> struct __make_signed<unsigned long> {
typedef signed long __type;
};
template <> struct __make_signed<unsigned long long> {
typedef signed long long __type;
};
# 1675 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp, bool _IsInt = is_integral<_Tp>::value,
bool _IsEnum = is_enum<_Tp>::value>
class __make_signed_selector;
template <typename _Tp> class __make_signed_selector<_Tp, true, false> {
typedef __make_signed<typename remove_cv<_Tp>::type> __signedt;
typedef typename __signedt::__type __signed_type;
typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed;
public:
typedef typename __cv_signed::__type __type;
};
template <typename _Tp> class __make_signed_selector<_Tp, false, true> {
typedef signed char __smallest;
static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
static const bool __b1 = sizeof(_Tp) <= sizeof(signed short);
static const bool __b2 = sizeof(_Tp) <= sizeof(signed int);
typedef conditional<__b2, signed int, signed long> __cond2;
typedef typename __cond2::type __cond2_type;
typedef conditional<__b1, signed short, __cond2_type> __cond1;
typedef typename __cond1::type __cond1_type;
public:
typedef typename conditional<__b0, __smallest, __cond1_type>::type __type;
};
template <typename _Tp> struct make_signed {
typedef typename __make_signed_selector<_Tp>::__type type;
};
template <> struct make_signed<bool>;
# 1733 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp> struct remove_extent {
typedef _Tp type;
};
template <typename _Tp, std::size_t _Size> struct remove_extent<_Tp[_Size]> {
typedef _Tp type;
};
template <typename _Tp> struct remove_extent<_Tp[]> {
typedef _Tp type;
};
template <typename _Tp> struct remove_all_extents {
typedef _Tp type;
};
template <typename _Tp, std::size_t _Size>
struct remove_all_extents<_Tp[_Size]> {
typedef typename remove_all_extents<_Tp>::type type;
};
template <typename _Tp> struct remove_all_extents<_Tp[]> {
typedef typename remove_all_extents<_Tp>::type type;
};
# 1770 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp, typename> struct __remove_pointer_helper {
typedef _Tp type;
};
template <typename _Tp, typename _Up>
struct __remove_pointer_helper<_Tp, _Up *> {
typedef _Up type;
};
template <typename _Tp>
struct remove_pointer
: public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type> {};
template <typename _Tp,
bool = __or_<__is_referenceable<_Tp>, is_void<_Tp> >::value>
struct __add_pointer_helper {
typedef _Tp type;
};
template <typename _Tp> struct __add_pointer_helper<_Tp, true> {
typedef typename remove_reference<_Tp>::type *type;
};
template <typename _Tp>
struct add_pointer : public __add_pointer_helper<_Tp> {};
# 1809 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <std::size_t _Len> struct __aligned_storage_msa {
union __type {
unsigned char __data[_Len];
struct __attribute__((__aligned__)) {
} __align;
};
};
# 1829 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <std::size_t _Len, std::size_t _Align = __alignof__(
typename __aligned_storage_msa<_Len>::__type)>
struct aligned_storage {
union type {
unsigned char __data[_Len];
struct __attribute__((__aligned__((_Align)))) {
} __align;
};
};
template <typename _Up, bool _IsArray = is_array<_Up>::value,
bool _IsFunction = is_function<_Up>::value>
struct __decay_selector;
template <typename _Up> struct __decay_selector<_Up, false, false> {
typedef typename remove_cv<_Up>::type __type;
};
template <typename _Up> struct __decay_selector<_Up, true, false> {
typedef typename remove_extent<_Up>::type *__type;
};
template <typename _Up> struct __decay_selector<_Up, false, true> {
typedef typename add_pointer<_Up>::type __type;
};
template <typename _Tp> class decay {
typedef typename remove_reference<_Tp>::type __remove_type;
public:
typedef typename __decay_selector<__remove_type>::__type type;
};
template <typename _Tp> class reference_wrapper;
template <typename _Tp> struct __strip_reference_wrapper {
typedef _Tp __type;
};
template <typename _Tp>
struct __strip_reference_wrapper<reference_wrapper<_Tp> > {
typedef _Tp &__type;
};
template <typename _Tp> struct __decay_and_strip {
typedef typename __strip_reference_wrapper<
typename decay<_Tp>::type>::__type __type;
};
template <bool, typename _Tp = void> struct enable_if {};
template <typename _Tp> struct enable_if<true, _Tp> {
typedef _Tp type;
};
template <typename... _Cond>
using _Require = typename enable_if<__and_<_Cond...>::value>::type;
template <bool _Cond, typename _Iftrue, typename _Iffalse>
struct conditional {
typedef _Iftrue type;
};
template <typename _Iftrue, typename _Iffalse>
struct conditional<false, _Iftrue, _Iffalse> {
typedef _Iffalse type;
};
template <typename... _Tp> struct common_type;
struct __do_common_type_impl {
template <typename _Tp, typename _Up>
static __success_type<typename decay<
decltype(true ? std::declval<_Tp>() : std::declval<_Up>())>::type>
_S_test(int);
template <typename, typename> static __failure_type _S_test(...);
};
template <typename _Tp, typename _Up>
struct __common_type_impl : private __do_common_type_impl {
typedef decltype(_S_test<_Tp, _Up>(0)) type;
};
struct __do_member_type_wrapper {
template <typename _Tp>
static __success_type<typename _Tp::type> _S_test(int);
template <typename> static __failure_type _S_test(...);
};
template <typename _Tp>
struct __member_type_wrapper : private __do_member_type_wrapper {
typedef decltype(_S_test<_Tp>(0)) type;
};
template <typename _CTp, typename... _Args>
struct __expanded_common_type_wrapper {
typedef common_type<typename _CTp::type, _Args...> type;
};
template <typename... _Args>
struct __expanded_common_type_wrapper<__failure_type, _Args...> {
typedef __failure_type type;
};
template <typename _Tp> struct common_type<_Tp> {
typedef typename decay<_Tp>::type type;
};
template <typename _Tp, typename _Up>
struct common_type<_Tp, _Up> : public __common_type_impl<_Tp, _Up>::type {};
template <typename _Tp, typename _Up, typename... _Vp>
struct common_type<_Tp, _Up, _Vp...> : public __expanded_common_type_wrapper<
typename __member_type_wrapper<
common_type<_Tp, _Up> >::type,
_Vp...>::type {};
template <typename _Tp> struct underlying_type {
typedef __underlying_type(_Tp) type;
};
template <typename _Tp> struct __declval_protector {
static const bool __stop = false;
static typename add_rvalue_reference<_Tp>::type __delegate();
};
template <typename _Tp>
inline typename add_rvalue_reference<_Tp>::type declval() noexcept {
static_assert(__declval_protector<_Tp>::__stop,
"declval() must not be used!");
return __declval_protector<_Tp>::__delegate();
}
template <typename _Signature> class result_of;
struct __result_of_memfun_ref_impl {
template <typename _Fp, typename _Tp1, typename... _Args>
static __success_type<decltype(
(std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...))>
_S_test(int);
template <typename...> static __failure_type _S_test(...);
};
template <typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun_ref : private __result_of_memfun_ref_impl {
typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
};
struct __result_of_memfun_deref_impl {
template <typename _Fp, typename _Tp1, typename... _Args>
static __success_type<
decltype(((*std::declval<_Tp1>()).*
std::declval<_Fp>())(std::declval<_Args>()...))>
_S_test(int);
template <typename...> static __failure_type _S_test(...);
};
template <typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun_deref : private __result_of_memfun_deref_impl {
typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
};
struct __result_of_memobj_ref_impl {
template <typename _Fp, typename _Tp1>
static __success_type<decltype(std::declval<_Tp1>().*std::declval<_Fp>())>
_S_test(int);
template <typename, typename> static __failure_type _S_test(...);
};
template <typename _MemPtr, typename _Arg>
struct __result_of_memobj_ref : private __result_of_memobj_ref_impl {
typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
};
struct __result_of_memobj_deref_impl {
template <typename _Fp, typename _Tp1>
static __success_type<
decltype((*std::declval<_Tp1>()).*std::declval<_Fp>())>
_S_test(int);
template <typename, typename> static __failure_type _S_test(...);
};
template <typename _MemPtr, typename _Arg>
struct __result_of_memobj_deref : private __result_of_memobj_deref_impl {
typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
};
template <typename _MemPtr, typename _Arg> struct __result_of_memobj;
template <typename _Res, typename _Class, typename _Arg>
struct __result_of_memobj<_Res _Class::*, _Arg> {
typedef typename remove_cv<typename remove_reference<_Arg>::type>::type
_Argval;
typedef _Res _Class::*_MemPtr;
typedef typename conditional<
__or_<is_same<_Argval, _Class>, is_base_of<_Class, _Argval> >::value,
__result_of_memobj_ref<_MemPtr, _Arg>,
__result_of_memobj_deref<_MemPtr, _Arg> >::type::type type;
};
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...> {
typedef typename remove_cv<typename remove_reference<_Arg>::type>::type
_Argval;
typedef _Res _Class::*_MemPtr;
typedef typename conditional<
__or_<is_same<_Argval, _Class>, is_base_of<_Class, _Argval> >::value,
__result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
__result_of_memfun_deref<_MemPtr, _Arg, _Args...> >::type::type type;
};
template <bool, bool, typename _Functor, typename... _ArgTypes>
struct __result_of_impl {
typedef __failure_type type;
};
template <typename _MemPtr, typename _Arg>
struct __result_of_impl<
true, false, _MemPtr,
_Arg> : public __result_of_memobj<typename decay<_MemPtr>::type, _Arg> {};
template <typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_impl<
false, true, _MemPtr, _Arg,
_Args...> : public __result_of_memfun<typename decay<_MemPtr>::type, _Arg,
_Args...> {};
struct __result_of_other_impl {
template <typename _Fn, typename... _Args>
static __success_type<
decltype(std::declval<_Fn>()(std::declval<_Args>()...))>
_S_test(int);
template <typename...> static __failure_type _S_test(...);
};
template <typename _Functor, typename... _ArgTypes>
struct __result_of_impl<false, false, _Functor,
_ArgTypes...> : private __result_of_other_impl {
typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
};
template <typename _Functor, typename... _ArgTypes>
struct result_of<_Functor(_ArgTypes...)> : public __result_of_impl<
is_member_object_pointer<
typename remove_reference<
_Functor>::type>::
value,
is_member_function_pointer<
typename remove_reference<
_Functor>::type>::
value,
_Functor,
_ArgTypes...>::type {};
# 2232 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
}
# 58 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 74 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 3
template <typename _Tp>
constexpr _Tp &&forward(typename std::remove_reference<_Tp>::type &
__t) noexcept {
return static_cast<_Tp &&>(__t);
}
template <typename _Tp>
constexpr _Tp &&forward(typename std::remove_reference<_Tp>::type &&
__t) noexcept {
static_assert(!std::is_lvalue_reference<_Tp>::value,
"template argument"
" substituting _Tp is an lvalue reference type");
return static_cast<_Tp &&>(__t);
}
template <typename _Tp>
constexpr typename std::remove_reference<_Tp>::type &&move(_Tp &&
__t) noexcept {
return static_cast<typename std::remove_reference<_Tp>::type &&>(__t);
}
template <typename _Tp>
struct __move_if_noexcept_cond
: public __and_<__not_<is_nothrow_move_constructible<_Tp> >,
is_copy_constructible<_Tp> >::type {};
# 118 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 3
template <typename _Tp>
constexpr typename conditional<__move_if_noexcept_cond<_Tp>::value,
const _Tp &, _Tp &&>::type
move_if_noexcept(_Tp & __x) noexcept {
return std::move(__x);
}
# 133 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 3
template <typename _Tp> inline _Tp *addressof(_Tp & __r) noexcept {
return std::__addressof(__r);
}
}
# 149 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 3
namespace std __attribute__((__visibility__("default"))) {
# 164 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 3
template <typename _Tp>
inline void swap(_Tp & __a, _Tp & __b) noexcept(
__and_<is_nothrow_move_constructible<_Tp>,
is_nothrow_move_assignable<_Tp> >::value) {
_Tp __tmp = std::move(__a);
__a = std::move(__b);
__b = std::move(__tmp);
}
template <typename _Tp, size_t _Nm>
inline void swap(_Tp(&__a)[_Nm],
_Tp(&__b)[_Nm]) noexcept(noexcept(swap(*__a, *__b))) {
for (size_t __n = 0; __n < _Nm; ++__n)
swap(__a[__n], __b[__n]);
}
}
# 60 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_pair.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 76 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_pair.h" 3
struct piecewise_construct_t {};
constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
template <typename...> class tuple;
template <std::size_t...> struct _Index_tuple;
# 95 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_pair.h" 3
template <class _T1, class _T2> struct pair {
typedef _T1 first_type;
typedef _T2 second_type;
_T1 first;
_T2 second;
constexpr pair() : first(), second() {}
constexpr pair(const _T1 &__a, const _T2 &__b) : first(__a), second(__b) {}
template <class _U1, class _U2,
class = typename enable_if<
__and_<is_convertible<const _U1 &, _T1>,
is_convertible<const _U2 &, _T2> >::value>::type>
constexpr pair(const pair<_U1, _U2> &__p)
: first(__p.first), second(__p.second) {}
constexpr pair(const pair &) = default;
constexpr pair(pair &&) = default;
template <class _U1,
class = typename enable_if<is_convertible<_U1, _T1>::value>::type>
constexpr pair(_U1 &&__x, const _T2 &__y)
: first(std::forward<_U1>(__x)), second(__y) {}
template <class _U2,
class = typename enable_if<is_convertible<_U2, _T2>::value>::type>
constexpr pair(const _T1 &__x, _U2 &&__y)
: first(__x), second(std::forward<_U2>(__y)) {}
template <
class _U1, class _U2,
class = typename enable_if<__and_<
is_convertible<_U1, _T1>, is_convertible<_U2, _T2> >::value>::type>
constexpr pair(_U1 &&__x, _U2 &&__y)
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) {}
template <
class _U1, class _U2,
class = typename enable_if<__and_<
is_convertible<_U1, _T1>, is_convertible<_U2, _T2> >::value>::type>
constexpr pair(pair<_U1, _U2> &&__p)
: first(std::forward<_U1>(__p.first)),
second(std::forward<_U2>(__p.second)) {}
template <typename... _Args1, typename... _Args2>
pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
pair &operator=(const pair &__p) {
first = __p.first;
second = __p.second;
return *this;
}
pair &operator=(pair &&__p) noexcept(
__and_<is_nothrow_move_assignable<_T1>,
is_nothrow_move_assignable<_T2> >::value) {
first = std::forward<first_type>(__p.first);
second = std::forward<second_type>(__p.second);
return *this;
}
template <class _U1, class _U2> pair &operator=(const pair<_U1, _U2> &__p) {
first = __p.first;
second = __p.second;
return *this;
}
template <class _U1, class _U2> pair &operator=(pair<_U1, _U2> &&__p) {
first = std::forward<_U1>(__p.first);
second = std::forward<_U2>(__p.second);
return *this;
}
void swap(pair &__p) noexcept(noexcept(swap(first, __p.first)) &&
noexcept(swap(second, __p.second))) {
using std::swap;
swap(first, __p.first);
swap(second, __p.second);
}
private:
template <typename... _Args1, std::size_t... _Indexes1, typename... _Args2,
std::size_t... _Indexes2>
pair(tuple<_Args1...> &, tuple<_Args2...> &, _Index_tuple<_Indexes1...>,
_Index_tuple<_Indexes2...>);
};
template <class _T1, class _T2>
inline constexpr bool operator==(const pair<_T1, _T2> & __x,
const pair<_T1, _T2> & __y) {
return __x.first == __y.first && __x.second == __y.second;
}
template <class _T1, class _T2>
inline constexpr bool operator<(const pair<_T1, _T2> & __x,
const pair<_T1, _T2> & __y) {
return __x.first < __y.first ||
(!(__y.first < __x.first) && __x.second < __y.second);
}
template <class _T1, class _T2>
inline constexpr bool operator!=(const pair<_T1, _T2> & __x,
const pair<_T1, _T2> & __y) {
return !(__x == __y);
}
template <class _T1, class _T2>
inline constexpr bool operator>(const pair<_T1, _T2> & __x,
const pair<_T1, _T2> & __y) {
return __y < __x;
}
template <class _T1, class _T2>
inline constexpr bool operator<=(const pair<_T1, _T2> & __x,
const pair<_T1, _T2> & __y) {
return !(__y < __x);
}
template <class _T1, class _T2>
inline constexpr bool operator>=(const pair<_T1, _T2> & __x,
const pair<_T1, _T2> & __y) {
return !(__x < __y);
}
template <class _T1, class _T2>
inline void swap(pair<_T1, _T2> & __x,
pair<_T1, _T2> & __y) noexcept(noexcept(__x.swap(__y))) {
__x.swap(__y);
}
# 273 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_pair.h" 3
template <class _T1, class _T2>
constexpr pair<typename __decay_and_strip<_T1>::__type,
typename __decay_and_strip<_T2>::__type> make_pair(_T1 && __x,
_T2 &&
__y) {
typedef typename __decay_and_strip<_T1>::__type __ds_type1;
typedef typename __decay_and_strip<_T2>::__type __ds_type2;
typedef pair<__ds_type1, __ds_type2> __pair_type;
return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
}
# 293 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_pair.h" 3
}
# 71 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/initializer_list" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/initializer_list" 3
#pragma GCC visibility push(default)
namespace std {
template <class _E> class initializer_list {
public:
typedef _E value_type;
typedef const _E &reference;
typedef const _E &const_reference;
typedef size_t size_type;
typedef const _E *iterator;
typedef const _E *const_iterator;
private:
iterator _M_array;
size_type _M_len;
constexpr initializer_list(const_iterator __a, size_type __l)
: _M_array(__a), _M_len(__l) {}
public:
constexpr initializer_list() noexcept : _M_array(0), _M_len(0) {}
constexpr size_type size() const noexcept { return _M_len; }
constexpr const_iterator begin() const noexcept { return _M_array; }
constexpr const_iterator end() const noexcept { return begin() + size(); }
};
template <class _Tp>
constexpr const _Tp *begin(initializer_list<_Tp> __ils) noexcept {
return __ils.begin();
}
template <class _Tp>
constexpr const _Tp *end(initializer_list<_Tp> __ils) noexcept {
return __ils.end();
}
}
#pragma GCC visibility pop
# 75 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 2 3
namespace std __attribute__((__visibility__("default"))) {
template <class _Tp> class tuple_size;
template <std::size_t _Int, class _Tp> class tuple_element;
template <class _Tp1, class _Tp2>
struct tuple_size<std::pair<_Tp1, _Tp2> > : public integral_constant<
std::size_t, 2> {};
template <class _Tp1, class _Tp2>
struct tuple_element<0, std::pair<_Tp1, _Tp2> > {
typedef _Tp1 type;
};
template <class _Tp1, class _Tp2>
struct tuple_element<1, std::pair<_Tp1, _Tp2> > {
typedef _Tp2 type;
};
template <std::size_t _Int> struct __pair_get;
template <> struct __pair_get<0> {
template <typename _Tp1, typename _Tp2>
static constexpr _Tp1 &__get(std::pair<_Tp1, _Tp2> &__pair) noexcept {
return __pair.first;
}
template <typename _Tp1, typename _Tp2>
static constexpr _Tp1 &&
__move_get(std::pair<_Tp1, _Tp2> &&__pair) noexcept {
return std::forward<_Tp1>(__pair.first);
}
template <typename _Tp1, typename _Tp2>
static constexpr const _Tp1 &
__const_get(const std::pair<_Tp1, _Tp2> &__pair) noexcept {
return __pair.first;
}
};
template <> struct __pair_get<1> {
template <typename _Tp1, typename _Tp2>
static constexpr _Tp2 &__get(std::pair<_Tp1, _Tp2> &__pair) noexcept {
return __pair.second;
}
template <typename _Tp1, typename _Tp2>
static constexpr _Tp2 &&
__move_get(std::pair<_Tp1, _Tp2> &&__pair) noexcept {
return std::forward<_Tp2>(__pair.second);
}
template <typename _Tp1, typename _Tp2>
static constexpr const _Tp2 &
__const_get(const std::pair<_Tp1, _Tp2> &__pair) noexcept {
return __pair.second;
}
};
template <std::size_t _Int, class _Tp1, class _Tp2>
constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type &get(
std::pair<_Tp1, _Tp2> & __in) noexcept {
return __pair_get<_Int>::__get(__in);
}
template <std::size_t _Int, class _Tp1, class _Tp2>
constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type &&get(
std::pair<_Tp1, _Tp2> && __in) noexcept {
return __pair_get<_Int>::__move_get(std::move(__in));
}
template <std::size_t _Int, class _Tp1, class _Tp2>
constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type &
get(const std::pair<_Tp1, _Tp2> & __in) noexcept {
return __pair_get<_Int>::__const_get(__in);
}
# 199 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 3
template <size_t... _Indexes> struct _Index_tuple {
typedef _Index_tuple<_Indexes..., sizeof...(_Indexes)> __next;
};
template <size_t _Num> struct _Build_index_tuple {
typedef typename _Build_index_tuple<_Num - 1>::__type::__next __type;
};
template <> struct _Build_index_tuple<0> {
typedef _Index_tuple<> __type;
};
# 259 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 3
}
# 5 "./cxx_invoke.hh" 2
namespace cxx {
struct __any {
__any(...);
};
struct __nat {
__nat() = delete;
__nat(const __nat &) = delete;
__nat &operator=(const __nat &) = delete;
~__nat() = delete;
};
template <class _MP, bool _IsMemberFuctionPtr, bool _IsMemberObjectPtr>
struct member_pointer_traits_imp {};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...), true, false> {
typedef _Class class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const, true,
false> {
typedef _Class const class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile, true,
false> {
typedef _Class volatile class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile,
true, false> {
typedef _Class const volatile class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) &, true, false> {
typedef _Class &class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const &, true,
false> {
typedef _Class const &class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile &, true,
false> {
typedef _Class volatile &class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile &,
true, false> {
typedef _Class const volatile &class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) &&, true, false> {
typedef _Class &&class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const &&, true,
false> {
typedef _Class const &&class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile &&, true,
false> {
typedef _Class volatile &&class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile &&,
true, false> {
typedef _Class const volatile &&class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class>
struct member_pointer_traits_imp<_Rp _Class::*, false, true> {
typedef _Class class_type;
typedef _Rp return_type;
};
template <class _MP>
struct member_pointer_traits : public member_pointer_traits_imp<
typename std::remove_cv<_MP>::type,
std::is_member_function_pointer<_MP>::value,
std::is_member_object_pointer<_MP>::value> {
};
template <class... _Tp> struct check_complete;
template <> struct check_complete<> {};
template <class _Hp, class _T0, class... _Tp>
struct check_complete<_Hp, _T0, _Tp...> : private check_complete<_Hp>,
private check_complete<_T0, _Tp...> {
};
template <class _Hp>
struct check_complete<_Hp, _Hp> : private check_complete<_Hp> {};
template <class _Tp> struct check_complete<_Tp> {
static_assert(sizeof(_Tp) > 0, "Type must be complete.");
};
template <class _Tp>
struct check_complete<_Tp &> : private check_complete<_Tp> {};
template <class _Tp>
struct check_complete<_Tp &&> : private check_complete<_Tp> {};
template <class _Rp, class... _Param>
struct check_complete<_Rp (*)(_Param...)> : private check_complete<_Rp> {};
template <class... _Param> struct check_complete<void (*)(_Param...)> {};
template <class _Rp, class... _Param>
struct check_complete<_Rp(_Param...)> : private check_complete<_Rp> {};
template <class... _Param> struct check_complete<void(_Param...)> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<_Rp (_Class::*)(_Param...)> : private check_complete<
_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<
_Rp (_Class::*)(_Param...) const> : private check_complete<_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<
_Rp (_Class::*)(_Param...) volatile> : private check_complete<_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<_Rp (_Class::*)(_Param...) const
volatile> : private check_complete<_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<_Rp (_Class::*)(_Param...) &> : private check_complete<
_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<_Rp (_Class::*)(_Param...) const
&> : private check_complete<_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<
_Rp (_Class::*)(_Param...) volatile &> : private check_complete<_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<_Rp (_Class::*)(_Param...) const
volatile &> : private check_complete<_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<_Rp (_Class::*)(_Param...) && > : private check_complete<
_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<_Rp (_Class::*)(_Param...) const
&&> : private check_complete<_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<
_Rp (_Class::*)(_Param...) volatile &&> : private check_complete<_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<_Rp (_Class::*)(_Param...) const
volatile &&> : private check_complete<_Class> {};
template <class _Rp, class _Class>
struct check_complete<_Rp _Class::*> : private check_complete<_Class> {};
template <class... _Args> auto invoke(__any, _Args &&... __args) -> __nat;
template <
class _Fp, class _A0, class... _Args,
class = typename std::enable_if<
std::is_member_function_pointer<
typename std::remove_reference<_Fp>::type>::value &&
std::is_base_of<
typename member_pointer_traits<
typename std::remove_reference<_Fp>::type>::class_type,
typename std::remove_reference<_A0>::type>::value>::type>
auto invoke(_Fp &&__f, _A0 &&__a0, _Args &&... __args)
-> decltype((std::forward<_A0>(__a0).*__f)(std::forward<_Args>(__args)...));
template <class _Fp, class _A0, class... _Args,
class = typename std::enable_if<
std::is_member_function_pointer<
typename std::remove_reference<_Fp>::type>::value &&
!std::is_base_of<
typename member_pointer_traits<
typename std::remove_reference<_Fp>::type>::class_type,
typename std::remove_reference<_A0>::type>::value>::type>
auto invoke(_Fp &&__f, _A0 &&__a0, _Args &&... __args)
-> decltype(((*std::forward<_A0>(__a0)).*
__f)(std::forward<_Args>(__args)...));
template <
class _Fp, class _A0,
class = typename std::enable_if<
std::is_member_object_pointer<
typename std::remove_reference<_Fp>::type>::value &&
std::is_base_of<
typename member_pointer_traits<
typename std::remove_reference<_Fp>::type>::class_type,
typename std::remove_reference<_A0>::type>::value>::type>
auto invoke(_Fp &&__f, _A0 &&__a0) -> decltype(std::forward<_A0>(__a0).*__f);
template <class _Fp, class _A0,
class = typename std::enable_if<
std::is_member_object_pointer<
typename std::remove_reference<_Fp>::type>::value &&
!std::is_base_of<
typename member_pointer_traits<
typename std::remove_reference<_Fp>::type>::class_type,
typename std::remove_reference<_A0>::type>::value>::type>
auto invoke(_Fp &&__f, _A0 &&__a0) -> decltype((*std::forward<_A0>(__a0)).*__f);
template <class _Fp, class... _Args>
auto invoke(_Fp &&__f, _Args &&... __args)
-> decltype(std::forward<_Fp>(__f)(std::forward<_Args>(__args)...));
template <class _Fp, class... _Args>
struct invokable_imp : private check_complete<_Fp> {
typedef decltype(invoke(std::declval<_Fp>(), std::declval<_Args>()...)) type;
static const bool value = !std::is_same<type, __nat>::value;
};
template <class _Fp, class... _Args>
struct invokable
: public std::integral_constant<bool, invokable_imp<_Fp, _Args...>::value> {
};
template <bool _Invokable, class _Fp, class... _Args> struct invoke_of_imp {};
template <class _Fp, class... _Args> struct invoke_of_imp<true, _Fp, _Args...> {
typedef typename invokable_imp<_Fp, _Args...>::type type;
};
template <class _Fp, class... _Args>
struct invoke_of
: public invoke_of_imp<invokable<_Fp, _Args...>::value, _Fp, _Args...> {};
template <class _Fp, class _A0, class... _Args, class>
inline auto invoke(_Fp &&__f, _A0 &&__a0, _Args &&... __args)
-> decltype((std::forward<_A0>(__a0).*
__f)(std::forward<_Args>(__args)...)) {
return (std::forward<_A0>(__a0).*__f)(std::forward<_Args>(__args)...);
}
template <class _Fp, class _A0, class... _Args, class>
inline auto invoke(_Fp &&__f, _A0 &&__a0, _Args &&... __args)
-> decltype(((*std::forward<_A0>(__a0)).*
__f)(std::forward<_Args>(__args)...)) {
return ((*std::forward<_A0>(__a0)).*__f)(std::forward<_Args>(__args)...);
}
template <class _Fp, class _A0, class>
inline auto invoke(_Fp &&__f, _A0 &&__a0)
-> decltype(std::forward<_A0>(__a0).*__f) {
return std::forward<_A0>(__a0).*__f;
}
template <class _Fp, class _A0, class>
inline auto invoke(_Fp &&__f, _A0 &&__a0)
-> decltype((*std::forward<_A0>(__a0)).*__f) {
return (*std::forward<_A0>(__a0)).*__f;
}
template <class _Fp, class... _Args>
inline auto invoke(_Fp &&__f, _Args &&... __args)
-> decltype(std::forward<_Fp>(__f)(std::forward<_Args>(__args)...)) {
return std::forward<_Fp>(__f)(std::forward<_Args>(__args)...);
}
}
# 7 "./rpc.hh" 2
# 1 "./cxx_tuple.hh" 1
# 1 "./cxx_invoke.hh" 1
# 5 "./cxx_tuple.hh" 2
# 1 "./cxx_utils.hh" 1
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cassert" 1
# 42 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cassert" 3
# 1 "/usr/include/assert.h" 1 3 4
# 42 "/usr/include/assert.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 484 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/sys/_symbol_aliasing.h" 1 3 4
# 485 "/usr/include/sys/cdefs.h" 2 3 4
# 550 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/sys/_posix_availability.h" 1 3 4
# 551 "/usr/include/sys/cdefs.h" 2 3 4
# 43 "/usr/include/assert.h" 2 3 4
# 1 "/usr/include/stdlib.h" 1 3 4
# 61 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/Availability.h" 1 3 4
# 148 "/usr/include/Availability.h" 3 4
# 1 "/usr/include/AvailabilityInternal.h" 1 3 4
# 149 "/usr/include/Availability.h" 2 3 4
# 62 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/_types.h" 1 3 4
# 27 "/usr/include/_types.h" 3 4
# 1 "/usr/include/sys/_types.h" 1 3 4
# 33 "/usr/include/sys/_types.h" 3 4
# 1 "/usr/include/machine/_types.h" 1 3 4
# 32 "/usr/include/machine/_types.h" 3 4
# 1 "/usr/include/i386/_types.h" 1 3 4
# 37 "/usr/include/i386/_types.h" 3 4
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef short __int16_t;
typedef unsigned short __uint16_t;
typedef int __int32_t;
typedef unsigned int __uint32_t;
typedef long long __int64_t;
typedef unsigned long long __uint64_t;
typedef long __darwin_intptr_t;
typedef unsigned int __darwin_natural_t;
# 70 "/usr/include/i386/_types.h" 3 4
typedef int __darwin_ct_rune_t;
typedef union {
char __mbstate8[128];
long long _mbstateL;
} __mbstate_t;
typedef __mbstate_t __darwin_mbstate_t;
typedef long int __darwin_ptrdiff_t;
typedef long unsigned int __darwin_size_t;
typedef __builtin_va_list __darwin_va_list;
typedef int __darwin_wchar_t;
typedef __darwin_wchar_t __darwin_rune_t;
typedef int __darwin_wint_t;
typedef unsigned long __darwin_clock_t;
typedef __uint32_t __darwin_socklen_t;
typedef long __darwin_ssize_t;
typedef long __darwin_time_t;
# 33 "/usr/include/machine/_types.h" 2 3 4
# 34 "/usr/include/sys/_types.h" 2 3 4
# 58 "/usr/include/sys/_types.h" 3 4
struct __darwin_pthread_handler_rec {
void (*__routine)(void *);
void *__arg;
struct __darwin_pthread_handler_rec *__next;
};
struct _opaque_pthread_attr_t {
long __sig;
char __opaque[56];
};
struct _opaque_pthread_cond_t {
long __sig;
char __opaque[40];
};
struct _opaque_pthread_condattr_t {
long __sig;
char __opaque[8];
};
struct _opaque_pthread_mutex_t {
long __sig;
char __opaque[56];
};
struct _opaque_pthread_mutexattr_t {
long __sig;
char __opaque[8];
};
struct _opaque_pthread_once_t {
long __sig;
char __opaque[8];
};
struct _opaque_pthread_rwlock_t {
long __sig;
char __opaque[192];
};
struct _opaque_pthread_rwlockattr_t {
long __sig;
char __opaque[16];
};
struct _opaque_pthread_t {
long __sig;
struct __darwin_pthread_handler_rec *__cleanup_stack;
char __opaque[1168];
};
# 94 "/usr/include/sys/_types.h" 3 4
typedef __int64_t __darwin_blkcnt_t;
typedef __int32_t __darwin_blksize_t;
typedef __int32_t __darwin_dev_t;
typedef unsigned int __darwin_fsblkcnt_t;
typedef unsigned int __darwin_fsfilcnt_t;
typedef __uint32_t __darwin_gid_t;
typedef __uint32_t __darwin_id_t;
typedef __uint64_t __darwin_ino64_t;
typedef __darwin_ino64_t __darwin_ino_t;
typedef __darwin_natural_t __darwin_mach_port_name_t;
typedef __darwin_mach_port_name_t __darwin_mach_port_t;
typedef __uint16_t __darwin_mode_t;
typedef __int64_t __darwin_off_t;
typedef __int32_t __darwin_pid_t;
typedef struct _opaque_pthread_attr_t __darwin_pthread_attr_t;
typedef struct _opaque_pthread_cond_t __darwin_pthread_cond_t;
typedef struct _opaque_pthread_condattr_t __darwin_pthread_condattr_t;
typedef unsigned long __darwin_pthread_key_t;
typedef struct _opaque_pthread_mutex_t __darwin_pthread_mutex_t;
typedef struct _opaque_pthread_mutexattr_t __darwin_pthread_mutexattr_t;
typedef struct _opaque_pthread_once_t __darwin_pthread_once_t;
typedef struct _opaque_pthread_rwlock_t __darwin_pthread_rwlock_t;
typedef struct _opaque_pthread_rwlockattr_t __darwin_pthread_rwlockattr_t;
typedef struct _opaque_pthread_t *__darwin_pthread_t;
typedef __uint32_t __darwin_sigset_t;
typedef __int32_t __darwin_suseconds_t;
typedef __uint32_t __darwin_uid_t;
typedef __uint32_t __darwin_useconds_t;
typedef unsigned char __darwin_uuid_t[16];
typedef char __darwin_uuid_string_t[37];
# 28 "/usr/include/_types.h" 2 3 4
# 39 "/usr/include/_types.h" 3 4
typedef int __darwin_nl_item;
typedef int __darwin_wctrans_t;
typedef __uint32_t __darwin_wctype_t;
# 64 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/sys/wait.h" 1 3 4
# 79 "/usr/include/sys/wait.h" 3 4
typedef enum {
P_ALL,
P_PID,
P_PGID
} idtype_t;
# 1 "/usr/include/sys/_types/_pid_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_pid_t.h" 3 4
typedef __darwin_pid_t pid_t;
# 90 "/usr/include/sys/wait.h" 2 3 4
# 1 "/usr/include/sys/_types/_id_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_id_t.h" 3 4
typedef __darwin_id_t id_t;
# 91 "/usr/include/sys/wait.h" 2 3 4
# 109 "/usr/include/sys/wait.h" 3 4
# 1 "/usr/include/sys/signal.h" 1 3 4
# 73 "/usr/include/sys/signal.h" 3 4
# 1 "/usr/include/sys/appleapiopts.h" 1 3 4
# 74 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/machine/signal.h" 1 3 4
# 32 "/usr/include/machine/signal.h" 3 4
# 1 "/usr/include/i386/signal.h" 1 3 4
# 39 "/usr/include/i386/signal.h" 3 4
typedef int sig_atomic_t;
# 33 "/usr/include/machine/signal.h" 2 3 4
# 82 "/usr/include/sys/signal.h" 2 3 4
# 145 "/usr/include/sys/signal.h" 3 4
# 1 "/usr/include/machine/_mcontext.h" 1 3 4
# 29 "/usr/include/machine/_mcontext.h" 3 4
# 1 "/usr/include/i386/_mcontext.h" 1 3 4
# 33 "/usr/include/i386/_mcontext.h" 3 4
# 1 "/usr/include/mach/i386/_structs.h" 1 3 4
# 43 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_i386_thread_state {
unsigned int __eax;
unsigned int __ebx;
unsigned int __ecx;
unsigned int __edx;
unsigned int __edi;
unsigned int __esi;
unsigned int __ebp;
unsigned int __esp;
unsigned int __ss;
unsigned int __eflags;
unsigned int __eip;
unsigned int __cs;
unsigned int __ds;
unsigned int __es;
unsigned int __fs;
unsigned int __gs;
};
# 89 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_fp_control {
unsigned short __invalid : 1, __denorm : 1, __zdiv : 1, __ovrfl : 1,
__undfl : 1, __precis : 1, : 2, __pc : 2, __rc : 2, : 1, : 3;
};
typedef struct __darwin_fp_control __darwin_fp_control_t;
# 147 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_fp_status {
unsigned short __invalid : 1, __denorm : 1, __zdiv : 1, __ovrfl : 1,
__undfl : 1, __precis : 1, __stkflt : 1, __errsumm : 1, __c0 : 1,
__c1 : 1, __c2 : 1, __tos : 3, __c3 : 1, __busy : 1;
};
typedef struct __darwin_fp_status __darwin_fp_status_t;
# 191 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_mmst_reg {
char __mmst_reg[10];
char __mmst_rsrv[6];
};
# 210 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_xmm_reg {
char __xmm_reg[16];
};
# 232 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_i386_float_state {
int __fpu_reserved[2];
struct __darwin_fp_control __fpu_fcw;
struct __darwin_fp_status __fpu_fsw;
__uint8_t __fpu_ftw;
__uint8_t __fpu_rsrv1;
__uint16_t __fpu_fop;
__uint32_t __fpu_ip;
__uint16_t __fpu_cs;
__uint16_t __fpu_rsrv2;
__uint32_t __fpu_dp;
__uint16_t __fpu_ds;
__uint16_t __fpu_rsrv3;
__uint32_t __fpu_mxcsr;
__uint32_t __fpu_mxcsrmask;
struct __darwin_mmst_reg __fpu_stmm0;
struct __darwin_mmst_reg __fpu_stmm1;
struct __darwin_mmst_reg __fpu_stmm2;
struct __darwin_mmst_reg __fpu_stmm3;
struct __darwin_mmst_reg __fpu_stmm4;
struct __darwin_mmst_reg __fpu_stmm5;
struct __darwin_mmst_reg __fpu_stmm6;
struct __darwin_mmst_reg __fpu_stmm7;
struct __darwin_xmm_reg __fpu_xmm0;
struct __darwin_xmm_reg __fpu_xmm1;
struct __darwin_xmm_reg __fpu_xmm2;
struct __darwin_xmm_reg __fpu_xmm3;
struct __darwin_xmm_reg __fpu_xmm4;
struct __darwin_xmm_reg __fpu_xmm5;
struct __darwin_xmm_reg __fpu_xmm6;
struct __darwin_xmm_reg __fpu_xmm7;
char __fpu_rsrv4[14 * 16];
int __fpu_reserved1;
};
struct __darwin_i386_avx_state {
int __fpu_reserved[2];
struct __darwin_fp_control __fpu_fcw;
struct __darwin_fp_status __fpu_fsw;
__uint8_t __fpu_ftw;
__uint8_t __fpu_rsrv1;
__uint16_t __fpu_fop;
__uint32_t __fpu_ip;
__uint16_t __fpu_cs;
__uint16_t __fpu_rsrv2;
__uint32_t __fpu_dp;
__uint16_t __fpu_ds;
__uint16_t __fpu_rsrv3;
__uint32_t __fpu_mxcsr;
__uint32_t __fpu_mxcsrmask;
struct __darwin_mmst_reg __fpu_stmm0;
struct __darwin_mmst_reg __fpu_stmm1;
struct __darwin_mmst_reg __fpu_stmm2;
struct __darwin_mmst_reg __fpu_stmm3;
struct __darwin_mmst_reg __fpu_stmm4;
struct __darwin_mmst_reg __fpu_stmm5;
struct __darwin_mmst_reg __fpu_stmm6;
struct __darwin_mmst_reg __fpu_stmm7;
struct __darwin_xmm_reg __fpu_xmm0;
struct __darwin_xmm_reg __fpu_xmm1;
struct __darwin_xmm_reg __fpu_xmm2;
struct __darwin_xmm_reg __fpu_xmm3;
struct __darwin_xmm_reg __fpu_xmm4;
struct __darwin_xmm_reg __fpu_xmm5;
struct __darwin_xmm_reg __fpu_xmm6;
struct __darwin_xmm_reg __fpu_xmm7;
char __fpu_rsrv4[14 * 16];
int __fpu_reserved1;
char __avx_reserved1[64];
struct __darwin_xmm_reg __fpu_ymmh0;
struct __darwin_xmm_reg __fpu_ymmh1;
struct __darwin_xmm_reg __fpu_ymmh2;
struct __darwin_xmm_reg __fpu_ymmh3;
struct __darwin_xmm_reg __fpu_ymmh4;
struct __darwin_xmm_reg __fpu_ymmh5;
struct __darwin_xmm_reg __fpu_ymmh6;
struct __darwin_xmm_reg __fpu_ymmh7;
};
# 402 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_i386_exception_state {
__uint16_t __trapno;
__uint16_t __cpu;
__uint32_t __err;
__uint32_t __faultvaddr;
};
# 422 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_debug_state32 {
unsigned int __dr0;
unsigned int __dr1;
unsigned int __dr2;
unsigned int __dr3;
unsigned int __dr4;
unsigned int __dr5;
unsigned int __dr6;
unsigned int __dr7;
};
# 454 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_thread_state64 {
__uint64_t __rax;
__uint64_t __rbx;
__uint64_t __rcx;
__uint64_t __rdx;
__uint64_t __rdi;
__uint64_t __rsi;
__uint64_t __rbp;
__uint64_t __rsp;
__uint64_t __r8;
__uint64_t __r9;
__uint64_t __r10;
__uint64_t __r11;
__uint64_t __r12;
__uint64_t __r13;
__uint64_t __r14;
__uint64_t __r15;
__uint64_t __rip;
__uint64_t __rflags;
__uint64_t __cs;
__uint64_t __fs;
__uint64_t __gs;
};
# 509 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_float_state64 {
int __fpu_reserved[2];
struct __darwin_fp_control __fpu_fcw;
struct __darwin_fp_status __fpu_fsw;
__uint8_t __fpu_ftw;
__uint8_t __fpu_rsrv1;
__uint16_t __fpu_fop;
__uint32_t __fpu_ip;
__uint16_t __fpu_cs;
__uint16_t __fpu_rsrv2;
__uint32_t __fpu_dp;
__uint16_t __fpu_ds;
__uint16_t __fpu_rsrv3;
__uint32_t __fpu_mxcsr;
__uint32_t __fpu_mxcsrmask;
struct __darwin_mmst_reg __fpu_stmm0;
struct __darwin_mmst_reg __fpu_stmm1;
struct __darwin_mmst_reg __fpu_stmm2;
struct __darwin_mmst_reg __fpu_stmm3;
struct __darwin_mmst_reg __fpu_stmm4;
struct __darwin_mmst_reg __fpu_stmm5;
struct __darwin_mmst_reg __fpu_stmm6;
struct __darwin_mmst_reg __fpu_stmm7;
struct __darwin_xmm_reg __fpu_xmm0;
struct __darwin_xmm_reg __fpu_xmm1;
struct __darwin_xmm_reg __fpu_xmm2;
struct __darwin_xmm_reg __fpu_xmm3;
struct __darwin_xmm_reg __fpu_xmm4;
struct __darwin_xmm_reg __fpu_xmm5;
struct __darwin_xmm_reg __fpu_xmm6;
struct __darwin_xmm_reg __fpu_xmm7;
struct __darwin_xmm_reg __fpu_xmm8;
struct __darwin_xmm_reg __fpu_xmm9;
struct __darwin_xmm_reg __fpu_xmm10;
struct __darwin_xmm_reg __fpu_xmm11;
struct __darwin_xmm_reg __fpu_xmm12;
struct __darwin_xmm_reg __fpu_xmm13;
struct __darwin_xmm_reg __fpu_xmm14;
struct __darwin_xmm_reg __fpu_xmm15;
char __fpu_rsrv4[6 * 16];
int __fpu_reserved1;
};
struct __darwin_x86_avx_state64 {
int __fpu_reserved[2];
struct __darwin_fp_control __fpu_fcw;
struct __darwin_fp_status __fpu_fsw;
__uint8_t __fpu_ftw;
__uint8_t __fpu_rsrv1;
__uint16_t __fpu_fop;
__uint32_t __fpu_ip;
__uint16_t __fpu_cs;
__uint16_t __fpu_rsrv2;
__uint32_t __fpu_dp;
__uint16_t __fpu_ds;
__uint16_t __fpu_rsrv3;
__uint32_t __fpu_mxcsr;
__uint32_t __fpu_mxcsrmask;
struct __darwin_mmst_reg __fpu_stmm0;
struct __darwin_mmst_reg __fpu_stmm1;
struct __darwin_mmst_reg __fpu_stmm2;
struct __darwin_mmst_reg __fpu_stmm3;
struct __darwin_mmst_reg __fpu_stmm4;
struct __darwin_mmst_reg __fpu_stmm5;
struct __darwin_mmst_reg __fpu_stmm6;
struct __darwin_mmst_reg __fpu_stmm7;
struct __darwin_xmm_reg __fpu_xmm0;
struct __darwin_xmm_reg __fpu_xmm1;
struct __darwin_xmm_reg __fpu_xmm2;
struct __darwin_xmm_reg __fpu_xmm3;
struct __darwin_xmm_reg __fpu_xmm4;
struct __darwin_xmm_reg __fpu_xmm5;
struct __darwin_xmm_reg __fpu_xmm6;
struct __darwin_xmm_reg __fpu_xmm7;
struct __darwin_xmm_reg __fpu_xmm8;
struct __darwin_xmm_reg __fpu_xmm9;
struct __darwin_xmm_reg __fpu_xmm10;
struct __darwin_xmm_reg __fpu_xmm11;
struct __darwin_xmm_reg __fpu_xmm12;
struct __darwin_xmm_reg __fpu_xmm13;
struct __darwin_xmm_reg __fpu_xmm14;
struct __darwin_xmm_reg __fpu_xmm15;
char __fpu_rsrv4[6 * 16];
int __fpu_reserved1;
char __avx_reserved1[64];
struct __darwin_xmm_reg __fpu_ymmh0;
struct __darwin_xmm_reg __fpu_ymmh1;
struct __darwin_xmm_reg __fpu_ymmh2;
struct __darwin_xmm_reg __fpu_ymmh3;
struct __darwin_xmm_reg __fpu_ymmh4;
struct __darwin_xmm_reg __fpu_ymmh5;
struct __darwin_xmm_reg __fpu_ymmh6;
struct __darwin_xmm_reg __fpu_ymmh7;
struct __darwin_xmm_reg __fpu_ymmh8;
struct __darwin_xmm_reg __fpu_ymmh9;
struct __darwin_xmm_reg __fpu_ymmh10;
struct __darwin_xmm_reg __fpu_ymmh11;
struct __darwin_xmm_reg __fpu_ymmh12;
struct __darwin_xmm_reg __fpu_ymmh13;
struct __darwin_xmm_reg __fpu_ymmh14;
struct __darwin_xmm_reg __fpu_ymmh15;
};
# 751 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_exception_state64 {
__uint16_t __trapno;
__uint16_t __cpu;
__uint32_t __err;
__uint64_t __faultvaddr;
};
# 771 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_debug_state64 {
__uint64_t __dr0;
__uint64_t __dr1;
__uint64_t __dr2;
__uint64_t __dr3;
__uint64_t __dr4;
__uint64_t __dr5;
__uint64_t __dr6;
__uint64_t __dr7;
};
# 34 "/usr/include/i386/_mcontext.h" 2 3 4
struct __darwin_mcontext32 {
struct __darwin_i386_exception_state __es;
struct __darwin_i386_thread_state __ss;
struct __darwin_i386_float_state __fs;
};
struct __darwin_mcontext_avx32 {
struct __darwin_i386_exception_state __es;
struct __darwin_i386_thread_state __ss;
struct __darwin_i386_avx_state __fs;
};
# 76 "/usr/include/i386/_mcontext.h" 3 4
struct __darwin_mcontext64 {
struct __darwin_x86_exception_state64 __es;
struct __darwin_x86_thread_state64 __ss;
struct __darwin_x86_float_state64 __fs;
};
struct __darwin_mcontext_avx64 {
struct __darwin_x86_exception_state64 __es;
struct __darwin_x86_thread_state64 __ss;
struct __darwin_x86_avx_state64 __fs;
};
# 115 "/usr/include/i386/_mcontext.h" 3 4
typedef struct __darwin_mcontext64 *mcontext_t;
# 30 "/usr/include/machine/_mcontext.h" 2 3 4
# 146 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/sys/_types/_sigaltstack.h" 1 3 4
# 36 "/usr/include/sys/_types/_sigaltstack.h" 3 4
struct __darwin_sigaltstack {
void *ss_sp;
__darwin_size_t ss_size;
int ss_flags;
};
typedef struct __darwin_sigaltstack stack_t;
# 147 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/sys/_types/_ucontext.h" 1 3 4
# 34 "/usr/include/sys/_types/_ucontext.h" 3 4
struct __darwin_ucontext {
int uc_onstack;
__darwin_sigset_t uc_sigmask;
struct __darwin_sigaltstack uc_stack;
struct __darwin_ucontext *uc_link;
__darwin_size_t uc_mcsize;
struct __darwin_mcontext64 *uc_mcontext;
};
typedef struct __darwin_ucontext ucontext_t;
# 148 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/sys/_types/_pthread_attr_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_pthread_attr_t.h" 3 4
typedef __darwin_pthread_attr_t pthread_attr_t;
# 151 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/sys/_types/_sigset_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_sigset_t.h" 3 4
typedef __darwin_sigset_t sigset_t;
# 152 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/sys/_types/_size_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_size_t.h" 3 4
typedef __darwin_size_t size_t;
# 153 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/sys/_types/_uid_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_uid_t.h" 3 4
typedef __darwin_uid_t uid_t;
# 154 "/usr/include/sys/signal.h" 2 3 4
union sigval {
int sival_int;
void *sival_ptr;
};
struct sigevent {
int sigev_notify;
int sigev_signo;
union sigval sigev_value;
void (*sigev_notify_function)(union sigval);
pthread_attr_t *sigev_notify_attributes;
};
typedef struct __siginfo {
int si_signo;
int si_errno;
int si_code;
pid_t si_pid;
uid_t si_uid;
int si_status;
void *si_addr;
union sigval si_value;
long si_band;
unsigned long __pad[7];
} siginfo_t;
# 266 "/usr/include/sys/signal.h" 3 4
union __sigaction_u {
void (*__sa_handler)(int);
void (*__sa_sigaction)(int, struct __siginfo *, void *);
};
struct __sigaction {
union __sigaction_u __sigaction_u;
void (*sa_tramp)(void *, int, int, siginfo_t *, void *);
sigset_t sa_mask;
int sa_flags;
};
struct sigaction {
union __sigaction_u __sigaction_u;
sigset_t sa_mask;
int sa_flags;
};
# 328 "/usr/include/sys/signal.h" 3 4
typedef void (*sig_t)(int);
# 345 "/usr/include/sys/signal.h" 3 4
struct sigvec {
void (*sv_handler)(int);
int sv_mask;
int sv_flags;
};
# 364 "/usr/include/sys/signal.h" 3 4
struct sigstack {
char *ss_sp;
int ss_onstack;
};
# 386 "/usr/include/sys/signal.h" 3 4
extern "C" { void (*signal(int, void (*)(int)))(int); }
# 110 "/usr/include/sys/wait.h" 2 3 4
# 1 "/usr/include/sys/resource.h" 1 3 4
# 72 "/usr/include/sys/resource.h" 3 4
# 1 "/Users/eschnett/SIMFACTORY/llvm-3.4.2/install/bin/../lib/clang/3.4.2/include/stdint.h" 1 3 4
# 64 "/Users/eschnett/SIMFACTORY/llvm-3.4.2/install/bin/../lib/clang/3.4.2/include/stdint.h" 3 4
# 1 "/usr/include/stdint.h" 1 3 4
# 18 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/sys/_types/_int8_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_int8_t.h" 3 4
typedef signed char int8_t;
# 19 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/sys/_types/_int16_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_int16_t.h" 3 4
typedef short int16_t;
# 20 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/sys/_types/_int32_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_int32_t.h" 3 4
typedef int int32_t;
# 21 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/sys/_types/_int64_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_int64_t.h" 3 4
typedef long long int64_t;
# 22 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/_types/_uint8_t.h" 1 3 4
# 31 "/usr/include/_types/_uint8_t.h" 3 4
typedef unsigned char uint8_t;
# 24 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/_types/_uint16_t.h" 1 3 4
# 31 "/usr/include/_types/_uint16_t.h" 3 4
typedef unsigned short uint16_t;
# 25 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/_types/_uint32_t.h" 1 3 4
# 31 "/usr/include/_types/_uint32_t.h" 3 4
typedef unsigned int uint32_t;
# 26 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/_types/_uint64_t.h" 1 3 4
# 31 "/usr/include/_types/_uint64_t.h" 3 4
typedef unsigned long long uint64_t;
# 27 "/usr/include/stdint.h" 2 3 4
typedef int8_t int_least8_t;
typedef int16_t int_least16_t;
typedef int32_t int_least32_t;
typedef int64_t int_least64_t;
typedef uint8_t uint_least8_t;
typedef uint16_t uint_least16_t;
typedef uint32_t uint_least32_t;
typedef uint64_t uint_least64_t;
typedef int8_t int_fast8_t;
typedef int16_t int_fast16_t;
typedef int32_t int_fast32_t;
typedef int64_t int_fast64_t;
typedef uint8_t uint_fast8_t;
typedef uint16_t uint_fast16_t;
typedef uint32_t uint_fast32_t;
typedef uint64_t uint_fast64_t;
# 1 "/usr/include/sys/_types/_intptr_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_intptr_t.h" 3 4
typedef __darwin_intptr_t intptr_t;
# 54 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/sys/_types/_uintptr_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_uintptr_t.h" 3 4
typedef unsigned long uintptr_t;
# 55 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/_types/_intmax_t.h" 1 3 4
# 32 "/usr/include/_types/_intmax_t.h" 3 4
typedef long int intmax_t;
# 59 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/_types/_uintmax_t.h" 1 3 4
# 32 "/usr/include/_types/_uintmax_t.h" 3 4
typedef long unsigned int uintmax_t;
# 60 "/usr/include/stdint.h" 2 3 4
# 65 "/Users/eschnett/SIMFACTORY/llvm-3.4.2/install/bin/../lib/clang/3.4.2/include/stdint.h" 2 3 4
# 73 "/usr/include/sys/resource.h" 2 3 4
# 1 "/usr/include/sys/_types/_timeval.h" 1 3 4
# 30 "/usr/include/sys/_types/_timeval.h" 3 4
struct timeval {
__darwin_time_t tv_sec;
__darwin_suseconds_t tv_usec;
};
# 81 "/usr/include/sys/resource.h" 2 3 4
typedef __uint64_t rlim_t;
# 151 "/usr/include/sys/resource.h" 3 4
struct rusage {
struct timeval ru_utime;
struct timeval ru_stime;
# 162 "/usr/include/sys/resource.h" 3 4
long ru_maxrss;
long ru_ixrss;
long ru_idrss;
long ru_isrss;
long ru_minflt;
long ru_majflt;
long ru_nswap;
long ru_inblock;
long ru_oublock;
long ru_msgsnd;
long ru_msgrcv;
long ru_nsignals;
long ru_nvcsw;
long ru_nivcsw;
};
# 190 "/usr/include/sys/resource.h" 3 4
typedef void *rusage_info_t;
struct rusage_info_v0 {
uint8_t ri_uuid[16];
uint64_t ri_user_time;
uint64_t ri_system_time;
uint64_t ri_pkg_idle_wkups;
uint64_t ri_interrupt_wkups;
uint64_t ri_pageins;
uint64_t ri_wired_size;
uint64_t ri_resident_size;
uint64_t ri_phys_footprint;
uint64_t ri_proc_start_abstime;
uint64_t ri_proc_exit_abstime;
};
struct rusage_info_v1 {
uint8_t ri_uuid[16];
uint64_t ri_user_time;
uint64_t ri_system_time;
uint64_t ri_pkg_idle_wkups;
uint64_t ri_interrupt_wkups;
uint64_t ri_pageins;
uint64_t ri_wired_size;
uint64_t ri_resident_size;
uint64_t ri_phys_footprint;
uint64_t ri_proc_start_abstime;
uint64_t ri_proc_exit_abstime;
uint64_t ri_child_user_time;
uint64_t ri_child_system_time;
uint64_t ri_child_pkg_idle_wkups;
uint64_t ri_child_interrupt_wkups;
uint64_t ri_child_pageins;
uint64_t ri_child_elapsed_abstime;
};
struct rusage_info_v2 {
uint8_t ri_uuid[16];
uint64_t ri_user_time;
uint64_t ri_system_time;
uint64_t ri_pkg_idle_wkups;
uint64_t ri_interrupt_wkups;
uint64_t ri_pageins;
uint64_t ri_wired_size;
uint64_t ri_resident_size;
uint64_t ri_phys_footprint;
uint64_t ri_proc_start_abstime;
uint64_t ri_proc_exit_abstime;
uint64_t ri_child_user_time;
uint64_t ri_child_system_time;
uint64_t ri_child_pkg_idle_wkups;
uint64_t ri_child_interrupt_wkups;
uint64_t ri_child_pageins;
uint64_t ri_child_elapsed_abstime;
uint64_t ri_diskio_bytesread;
uint64_t ri_diskio_byteswritten;
};
# 290 "/usr/include/sys/resource.h" 3 4
struct rlimit {
rlim_t rlim_cur;
rlim_t rlim_max;
};
# 317 "/usr/include/sys/resource.h" 3 4
struct proc_rlimit_control_wakeupmon {
uint32_t wm_flags;
int32_t wm_rate;
};
# 346 "/usr/include/sys/resource.h" 3 4
extern "C" {
int getpriority(int, id_t);
int getiopolicy_np(int, int)
__attribute__((availability(macosx, introduced = 10.5)));
int getrlimit(int, struct rlimit *) __asm("_"
"getrlimit");
int getrusage(int, struct rusage *);
int setpriority(int, id_t, int);
int setiopolicy_np(int, int, int)
__attribute__((availability(macosx, introduced = 10.5)));
int setrlimit(int, const struct rlimit *) __asm("_"
"setrlimit");
}
# 111 "/usr/include/sys/wait.h" 2 3 4
# 186 "/usr/include/sys/wait.h" 3 4
# 1 "/usr/include/machine/endian.h" 1 3 4
# 35 "/usr/include/machine/endian.h" 3 4
# 1 "/usr/include/i386/endian.h" 1 3 4
# 99 "/usr/include/i386/endian.h" 3 4
# 1 "/usr/include/sys/_endian.h" 1 3 4
# 124 "/usr/include/sys/_endian.h" 3 4
# 1 "/usr/include/libkern/_OSByteOrder.h" 1 3 4
# 66 "/usr/include/libkern/_OSByteOrder.h" 3 4
# 1 "/usr/include/libkern/i386/_OSByteOrder.h" 1 3 4
# 44 "/usr/include/libkern/i386/_OSByteOrder.h" 3 4
static inline __uint16_t _OSSwapInt16(__uint16_t _data) {
return ((__uint16_t)((_data << 8) | (_data >> 8)));
}
static inline __uint32_t _OSSwapInt32(__uint32_t _data) {
return __builtin_bswap32(_data);
}
static inline __uint64_t _OSSwapInt64(__uint64_t _data) {
return __builtin_bswap64(_data);
}
# 67 "/usr/include/libkern/_OSByteOrder.h" 2 3 4
# 125 "/usr/include/sys/_endian.h" 2 3 4
# 100 "/usr/include/i386/endian.h" 2 3 4
# 36 "/usr/include/machine/endian.h" 2 3 4
# 187 "/usr/include/sys/wait.h" 2 3 4
union wait {
int w_status;
struct {
unsigned int w_Termsig : 7, w_Coredump : 1, w_Retcode : 8, w_Filler : 16;
} w_T;
struct {
unsigned int w_Stopval : 8, w_Stopsig : 8, w_Filler : 16;
} w_S;
};
# 247 "/usr/include/sys/wait.h" 3 4
extern "C" {
pid_t wait(int *) __asm("_"
"wait");
pid_t waitpid(pid_t, int *, int) __asm("_"
"waitpid");
int waitid(idtype_t, id_t, siginfo_t *, int) __asm("_"
"waitid");
pid_t wait3(int *, int, struct rusage *);
pid_t wait4(pid_t, int *, int, struct rusage *);
}
# 66 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/alloca.h" 1 3 4
# 31 "/usr/include/alloca.h" 3 4
extern "C" { void *alloca(size_t); }
# 68 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/sys/_types/_ct_rune_t.h" 1 3 4
# 31 "/usr/include/sys/_types/_ct_rune_t.h" 3 4
typedef __darwin_ct_rune_t ct_rune_t;
# 77 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/sys/_types/_rune_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_rune_t.h" 3 4
typedef __darwin_rune_t rune_t;
# 78 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/sys/_types/_wchar_t.h" 1 3 4
# 81 "/usr/include/stdlib.h" 2 3 4
typedef struct {
int quot;
int rem;
} div_t;
typedef struct {
long quot;
long rem;
} ldiv_t;
typedef struct {
long long quot;
long long rem;
} lldiv_t;
# 1 "/usr/include/sys/_types/_null.h" 1 3 4
# 100 "/usr/include/stdlib.h" 2 3 4
# 117 "/usr/include/stdlib.h" 3 4
extern int __mb_cur_max;
# 127 "/usr/include/stdlib.h" 3 4
extern "C" {
void abort(void) __attribute__((noreturn));
int abs(int) __attribute__((const));
int atexit(void (*)(void));
double atof(const char *);
int atoi(const char *);
long atol(const char *);
long long atoll(const char *);
void *bsearch(const void *, const void *, size_t, size_t,
int (*)(const void *, const void *));
void *calloc(size_t, size_t);
div_t div(int, int) __attribute__((const));
void exit(int) __attribute__((noreturn));
void free(void *);
char *getenv(const char *);
long labs(long) __attribute__((const));
ldiv_t ldiv(long, long) __attribute__((const));
long long llabs(long long);
lldiv_t lldiv(long long, long long);
void *malloc(size_t);
int mblen(const char *, size_t);
size_t mbstowcs(wchar_t *, const char *, size_t);
int mbtowc(wchar_t *, const char *, size_t);
int posix_memalign(void **, size_t, size_t)
__attribute__((availability(macosx, introduced = 10.6)));
void qsort(void *, size_t, size_t, int (*)(const void *, const void *));
int rand(void);
void *realloc(void *, size_t);
void srand(unsigned);
double strtod(const char *, char **) __asm("_"
"strtod");
float strtof(const char *, char **) __asm("_"
"strtof");
long strtol(const char *, char **, int);
long double strtold(const char *, char **);
long long strtoll(const char *, char **, int);
unsigned long strtoul(const char *, char **, int);
unsigned long long strtoull(const char *, char **, int);
int system(const char *) __asm("_"
"system");
size_t wcstombs(char *, const wchar_t *, size_t);
int wctomb(char *, wchar_t);
void _Exit(int) __attribute__((noreturn));
long a64l(const char *);
double drand48(void);
char *ecvt(double, int, int *, int *);
double erand48(unsigned short[3]);
char *fcvt(double, int, int *, int *);
char *gcvt(double, int, char *);
int getsubopt(char **, char *const *, char **);
int grantpt(int);
char *initstate(unsigned, char *, size_t);
long jrand48(unsigned short[3]);
char *l64a(long);
void lcong48(unsigned short[7]);
long lrand48(void);
char *mktemp(char *);
int mkstemp(char *);
long mrand48(void);
long nrand48(unsigned short[3]);
int posix_openpt(int);
char *ptsname(int);
int putenv(char *) __asm("_"
"putenv");
long random(void);
int rand_r(unsigned *);
char *realpath(const char *, char *) __asm("_"
"realpath"
"$DARWIN_EXTSN");
unsigned short *seed48(unsigned short[3]);
int setenv(const char *, const char *, int) __asm("_"
"setenv");
void setkey(const char *) __asm("_"
"setkey");
char *setstate(const char *);
void srand48(long);
void srandom(unsigned);
int unlockpt(int);
int unsetenv(const char *) __asm("_"
"unsetenv");
# 1 "/usr/include/machine/types.h" 1 3 4
# 35 "/usr/include/machine/types.h" 3 4
# 1 "/usr/include/i386/types.h" 1 3 4
# 81 "/usr/include/i386/types.h" 3 4
typedef unsigned char u_int8_t;
typedef unsigned short u_int16_t;
typedef unsigned int u_int32_t;
typedef unsigned long long u_int64_t;
typedef int64_t register_t;
# 97 "/usr/include/i386/types.h" 3 4
typedef u_int64_t user_addr_t;
typedef u_int64_t user_size_t;
typedef int64_t user_ssize_t;
typedef int64_t user_long_t;
typedef u_int64_t user_ulong_t;
typedef int64_t user_time_t;
typedef int64_t user_off_t;
typedef u_int64_t syscall_arg_t;
# 1 "/usr/include/sys/_types/___offsetof.h" 1 3 4
# 114 "/usr/include/i386/types.h" 2 3 4
# 36 "/usr/include/machine/types.h" 2 3 4
# 239 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/sys/_types/_dev_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_dev_t.h" 3 4
typedef __darwin_dev_t dev_t;
# 241 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/sys/_types/_mode_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_mode_t.h" 3 4
typedef __darwin_mode_t mode_t;
# 242 "/usr/include/stdlib.h" 2 3 4
u_int32_t arc4random(void);
void arc4random_addrandom(unsigned char *, int);
void arc4random_buf(void *, size_t)
__attribute__((availability(macosx, introduced = 10.7)));
void arc4random_stir(void);
u_int32_t arc4random_uniform(u_int32_t)
__attribute__((availability(macosx, introduced = 10.7)));
int atexit_b(void (^)(void))
__attribute__((availability(macosx, introduced = 10.6)));
void *bsearch_b(const void *, const void *, size_t, size_t,
int (^)(const void *, const void *))
__attribute__((availability(macosx, introduced = 10.6)));
char *cgetcap(char *, const char *, int);
int cgetclose(void);
int cgetent(char **, char **, const char *);
int cgetfirst(char **, char **);
int cgetmatch(const char *, const char *);
int cgetnext(char **, char **);
int cgetnum(char *, const char *, long *);
int cgetset(const char *);
int cgetstr(char *, const char *, char **);
int cgetustr(char *, const char *, char **);
int daemon(int, int) __asm("_"
"daemon"
"$1050")
__attribute__((availability(macosx, introduced = 10.0, deprecated = 10.5)));
char *devname(dev_t, mode_t);
char *devname_r(dev_t, mode_t, char *buf, int len);
char *getbsize(int *, long *);
int getloadavg(double[], int);
const char *getprogname(void);
int heapsort(void *, size_t, size_t, int (*)(const void *, const void *));
int heapsort_b(void *, size_t, size_t, int (^)(const void *, const void *))
__attribute__((availability(macosx, introduced = 10.6)));
int mergesort(void *, size_t, size_t, int (*)(const void *, const void *));
int mergesort_b(void *, size_t, size_t, int (^)(const void *, const void *))
__attribute__((availability(macosx, introduced = 10.6)));
void psort(void *, size_t, size_t, int (*)(const void *, const void *))
__attribute__((availability(macosx, introduced = 10.6)));
void psort_b(void *, size_t, size_t, int (^)(const void *, const void *))
__attribute__((availability(macosx, introduced = 10.6)));
void psort_r(void *, size_t, size_t, void *,
int (*)(void *, const void *, const void *))
__attribute__((availability(macosx, introduced = 10.6)));
void qsort_b(void *, size_t, size_t, int (^)(const void *, const void *))
__attribute__((availability(macosx, introduced = 10.6)));
void qsort_r(void *, size_t, size_t, void *,
int (*)(void *, const void *, const void *));
int radixsort(const unsigned char **, int, const unsigned char *, unsigned);
void setprogname(const char *);
int sradixsort(const unsigned char **, int, const unsigned char *, unsigned);
void sranddev(void);
void srandomdev(void);
void *reallocf(void *, size_t);
long long strtoq(const char *, char **, int);
unsigned long long strtouq(const char *, char **, int);
extern char *suboptarg;
void *valloc(size_t);
}
# 45 "/usr/include/assert.h" 2 3 4
# 75 "/usr/include/assert.h" 3 4
extern "C" {
void __assert_rtn(const char *, const char *, int, const char *)
__attribute__((noreturn));
}
# 44 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cassert" 2 3
# 5 "./cxx_utils.hh" 2
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/iostream" 1
# 37 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/iostream" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 1 3
# 37 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ios" 1 3
# 37 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ios" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/iosfwd" 1 3
# 37 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/iosfwd" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stringfwd.h" 1 3
# 38 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stringfwd.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/memoryfwd.h" 1 3
# 47 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/memoryfwd.h" 3
namespace std __attribute__((__visibility__("default"))) {
# 63 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/memoryfwd.h" 3
template <typename> class allocator;
template <> class allocator<void>;
template <typename, typename> struct uses_allocator;
}
# 41 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stringfwd.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 52 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stringfwd.h" 3
template <class _CharT> struct char_traits;
template <typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_string;
template <> struct char_traits<char>;
typedef basic_string<char> string;
template <> struct char_traits<wchar_t>;
typedef basic_string<wchar_t> wstring;
template <> struct char_traits<char16_t>;
template <> struct char_traits<char32_t>;
typedef basic_string<char16_t> u16string;
typedef basic_string<char32_t> u32string;
}
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/iosfwd" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/postypes.h" 1 3
# 39 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/postypes.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cwchar" 1 3
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cwchar" 3
# 1 "/usr/include/wchar.h" 1 3 4
# 76 "/usr/include/wchar.h" 3 4
# 1 "/usr/include/sys/_types/_mbstate_t.h" 1 3 4
# 31 "/usr/include/sys/_types/_mbstate_t.h" 3 4
typedef __darwin_mbstate_t mbstate_t;
# 77 "/usr/include/wchar.h" 2 3 4
# 1 "/usr/include/sys/_types/_wchar_t.h" 1 3 4
# 80 "/usr/include/wchar.h" 2 3 4
# 89 "/usr/include/wchar.h" 3 4
# 1 "/Users/eschnett/SIMFACTORY/llvm-3.4.2/install/bin/../lib/clang/3.4.2/include/stdarg.h" 1 3 4
# 30 "/Users/eschnett/SIMFACTORY/llvm-3.4.2/install/bin/../lib/clang/3.4.2/include/stdarg.h" 3 4
typedef __builtin_va_list va_list;
# 48 "/Users/eschnett/SIMFACTORY/llvm-3.4.2/install/bin/../lib/clang/3.4.2/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 90 "/usr/include/wchar.h" 2 3 4
# 1 "/usr/include/stdio.h" 1 3 4
# 71 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/sys/_types/_va_list.h" 1 3 4
# 31 "/usr/include/sys/_types/_va_list.h" 3 4
typedef __darwin_va_list va_list;
# 72 "/usr/include/stdio.h" 2 3 4
typedef __darwin_off_t fpos_t;
# 86 "/usr/include/stdio.h" 3 4
struct __sbuf {
unsigned char *_base;
int _size;
};
struct __sFILEX;
# 120 "/usr/include/stdio.h" 3 4
typedef struct __sFILE {
unsigned char *_p;
int _r;
int _w;
short _flags;
short _file;
struct __sbuf _bf;
int _lbfsize;
void *_cookie;
int (*_close)(void *);
int (*_read)(void *, char *, int);
fpos_t (*_seek)(void *, fpos_t, int);
int (*_write)(void *, const char *, int);
struct __sbuf _ub;
struct __sFILEX *_extra;
int _ur;
unsigned char _ubuf[3];
unsigned char _nbuf[1];
struct __sbuf _lb;
int _blksize;
fpos_t _offset;
} FILE;
extern "C" {
extern FILE *__stdinp;
extern FILE *__stdoutp;
extern FILE *__stderrp;
}
# 228 "/usr/include/stdio.h" 3 4
extern "C" {
void clearerr(FILE *);
int fclose(FILE *);
int feof(FILE *);
int ferror(FILE *);
int fflush(FILE *);
int fgetc(FILE *);
int fgetpos(FILE *, fpos_t *);
char *fgets(char *, int, FILE *);
FILE *fopen(const char *, const char *) __asm("_"
"fopen");
int fprintf(FILE *, const char *, ...)
__attribute__((__format__(__printf__, 2, 3)));
int fputc(int, FILE *);
int fputs(const char *, FILE *) __asm("_"
"fputs");
size_t fread(void *, size_t, size_t, FILE *);
FILE *freopen(const char *, const char *, FILE *) __asm("_"
"freopen");
int fscanf(FILE *, const char *, ...)
__attribute__((__format__(__scanf__, 2, 3)));
int fseek(FILE *, long, int);
int fsetpos(FILE *, const fpos_t *);
long ftell(FILE *);
size_t fwrite(const void *, size_t, size_t, FILE *) __asm("_"
"fwrite");
int getc(FILE *);
int getchar(void);
char *gets(char *);
void perror(const char *);
int printf(const char *, ...) __attribute__((__format__(__printf__, 1, 2)));
int putc(int, FILE *);
int putchar(int);
int puts(const char *);
int remove(const char *);
int rename(const char *, const char *);
void rewind(FILE *);
int scanf(const char *, ...) __attribute__((__format__(__scanf__, 1, 2)));
void setbuf(FILE *, char *);
int setvbuf(FILE *, char *, int, size_t);
int sprintf(char *, const char *, ...)
__attribute__((__format__(__printf__, 2, 3)));
int sscanf(const char *, const char *, ...)
__attribute__((__format__(__scanf__, 2, 3)));
FILE *tmpfile(void);
__attribute__((deprecated("This function is provided for compatibility reasons "
"only. Due to security concerns inherent in the "
"design of tmpnam(3), it is highly recommended that "
"you use mkstemp(3) instead."))) char *tmpnam(char *);
int ungetc(int, FILE *);
int vfprintf(FILE *, const char *, va_list)
__attribute__((__format__(__printf__, 2, 0)));
int vprintf(const char *, va_list)
__attribute__((__format__(__printf__, 1, 0)));
int vsprintf(char *, const char *, va_list)
__attribute__((__format__(__printf__, 2, 0)));
}
# 290 "/usr/include/stdio.h" 3 4
extern "C" {
char *ctermid(char *);
FILE *fdopen(int, const char *) __asm("_"
"fdopen");
int fileno(FILE *);
}
# 312 "/usr/include/stdio.h" 3 4
extern "C" {
int pclose(FILE *);
FILE *popen(const char *, const char *) __asm("_"
"popen");
}
# 334 "/usr/include/stdio.h" 3 4
extern "C" {
int __srget(FILE *);
int __svfscanf(FILE *, const char *, va_list)
__attribute__((__format__(__scanf__, 2, 0)));
int __swbuf(int, FILE *);
}
inline __attribute__((__always_inline__)) int __sputc(int _c, FILE *_p) {
if (--_p->_w >= 0 || (_p->_w >= _p->_lbfsize && (char)_c != '\n'))
return (*_p->_p++ = _c);
else
return (__swbuf(_c, _p));
}
# 371 "/usr/include/stdio.h" 3 4
extern "C" {
void flockfile(FILE *);
int ftrylockfile(FILE *);
void funlockfile(FILE *);
int getc_unlocked(FILE *);
int getchar_unlocked(void);
int putc_unlocked(int, FILE *);
int putchar_unlocked(int);
int getw(FILE *);
int putw(int, FILE *);
__attribute__((deprecated("This function is provided for compatibility reasons "
"only. Due to security concerns inherent in the "
"design of tempnam(3), it is highly recommended that "
"you use mkstemp(3) instead."))) char *tempnam(
const char *, const char *) __asm("_"
"tempnam");
}
# 409 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/sys/_types/_off_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_off_t.h" 3 4
typedef __darwin_off_t off_t;
# 410 "/usr/include/stdio.h" 2 3 4
extern "C" {
int fseeko(FILE *, off_t, int);
off_t ftello(FILE *);
}
extern "C" {
int snprintf(char *, size_t, const char *, ...)
__attribute__((__format__(__printf__, 3, 4)));
int vfscanf(FILE *, const char *, va_list)
__attribute__((__format__(__scanf__, 2, 0)));
int vscanf(const char *, va_list) __attribute__((__format__(__scanf__, 1, 0)));
int vsnprintf(char *, size_t, const char *, va_list)
__attribute__((__format__(__printf__, 3, 0)));
int vsscanf(const char *, const char *, va_list)
__attribute__((__format__(__scanf__, 2, 0)));
}
# 434 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/sys/_types/_ssize_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_ssize_t.h" 3 4
typedef __darwin_ssize_t ssize_t;
# 435 "/usr/include/stdio.h" 2 3 4
extern "C" {
int dprintf(int, const char *, ...)
__attribute__((__format__(__printf__, 2, 3)))
__attribute__((availability(macosx, introduced = 10.7)));
int vdprintf(int, const char *, va_list)
__attribute__((__format__(__printf__, 2, 0)))
__attribute__((availability(macosx, introduced = 10.7)));
ssize_t getdelim(char **, size_t *, int, FILE *)
__attribute__((availability(macosx, introduced = 10.7)));
ssize_t getline(char **, size_t *, FILE *)
__attribute__((availability(macosx, introduced = 10.7)));
}
extern "C" {
extern const int sys_nerr;
extern const char *const sys_errlist[];
int asprintf(char **, const char *, ...)
__attribute__((__format__(__printf__, 2, 3)));
char *ctermid_r(char *);
char *fgetln(FILE *, size_t *);
const char *fmtcheck(const char *, const char *);
int fpurge(FILE *);
void setbuffer(FILE *, char *, int);
int setlinebuf(FILE *);
int vasprintf(char **, const char *, va_list)
__attribute__((__format__(__printf__, 2, 0)));
FILE *zopen(const char *, const char *, int);
FILE *funopen(const void *, int (*)(void *, char *, int),
int (*)(void *, const char *, int),
fpos_t (*)(void *, fpos_t, int), int (*)(void *));
}
# 91 "/usr/include/wchar.h" 2 3 4
# 1 "/usr/include/time.h" 1 3 4
# 69 "/usr/include/time.h" 3 4
# 1 "/usr/include/_structs.h" 1 3 4
# 24 "/usr/include/_structs.h" 3 4
# 1 "/usr/include/sys/_structs.h" 1 3 4
# 73 "/usr/include/sys/_structs.h" 3 4
# 1 "/usr/include/sys/_types/_timespec.h" 1 3 4
# 30 "/usr/include/sys/_types/_timespec.h" 3 4
struct timespec {
__darwin_time_t tv_sec;
long tv_nsec;
};
# 74 "/usr/include/sys/_structs.h" 2 3 4
# 25 "/usr/include/_structs.h" 2 3 4
# 70 "/usr/include/time.h" 2 3 4
# 1 "/usr/include/sys/_types/_clock_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_clock_t.h" 3 4
typedef __darwin_clock_t clock_t;
# 72 "/usr/include/time.h" 2 3 4
# 1 "/usr/include/sys/_types/_time_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_time_t.h" 3 4
typedef __darwin_time_t time_t;
# 74 "/usr/include/time.h" 2 3 4
struct tm {
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
long tm_gmtoff;
char *tm_zone;
};
# 98 "/usr/include/time.h" 3 4
extern char *tzname[];
extern int getdate_err;
extern long timezone __asm("_"
"timezone");
extern int daylight;
extern "C" {
char *asctime(const struct tm *);
clock_t clock(void) __asm("_"
"clock");
char *ctime(const time_t *);
double difftime(time_t, time_t);
struct tm *getdate(const char *);
struct tm *gmtime(const time_t *);
struct tm *localtime(const time_t *);
time_t mktime(struct tm *) __asm("_"
"mktime");
size_t strftime(char *, size_t, const char *,
const struct tm *) __asm("_"
"strftime");
char *strptime(const char *, const char *, struct tm *) __asm("_"
"strptime");
time_t time(time_t *);
void tzset(void);
char *asctime_r(const struct tm *, char *);
char *ctime_r(const time_t *, char *);
struct tm *gmtime_r(const time_t *, struct tm *);
struct tm *localtime_r(const time_t *, struct tm *);
time_t posix2time(time_t);
void tzsetwall(void);
time_t time2posix(time_t);
time_t timelocal(struct tm *const);
time_t timegm(struct tm *const);
int nanosleep(const struct timespec *, struct timespec *) __asm("_"
"nanosleep");
}
# 92 "/usr/include/wchar.h" 2 3 4
# 1 "/usr/include/_wctype.h" 1 3 4
# 45 "/usr/include/_wctype.h" 3 4
# 1 "/usr/include/sys/_types/_wint_t.h" 1 3 4
# 31 "/usr/include/sys/_types/_wint_t.h" 3 4
typedef __darwin_wint_t wint_t;
# 46 "/usr/include/_wctype.h" 2 3 4
# 1 "/usr/include/_types/_wctype_t.h" 1 3 4
# 31 "/usr/include/_types/_wctype_t.h" 3 4
typedef __darwin_wctype_t wctype_t;
# 48 "/usr/include/_wctype.h" 2 3 4
# 57 "/usr/include/_wctype.h" 3 4
# 1 "/usr/include/ctype.h" 1 3 4
# 70 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/runetype.h" 1 3 4
# 49 "/usr/include/runetype.h" 3 4
# 1 "/usr/include/sys/_types/_wchar_t.h" 1 3 4
# 50 "/usr/include/runetype.h" 2 3 4
# 60 "/usr/include/runetype.h" 3 4
typedef struct {
__darwin_rune_t __min;
__darwin_rune_t __max;
__darwin_rune_t __map;
__uint32_t *__types;
} _RuneEntry;
typedef struct {
int __nranges;
_RuneEntry *__ranges;
} _RuneRange;
typedef struct {
char __name[14];
__uint32_t __mask;
} _RuneCharClass;
typedef struct {
char __magic[8];
char __encoding[32];
__darwin_rune_t (*__sgetrune)(const char *, __darwin_size_t, char const **);
int (*__sputrune)(__darwin_rune_t, char *, __darwin_size_t, char **);
__darwin_rune_t __invalid_rune;
__uint32_t __runetype[(1 << 8)];
__darwin_rune_t __maplower[(1 << 8)];
__darwin_rune_t __mapupper[(1 << 8)];
_RuneRange __runetype_ext;
_RuneRange __maplower_ext;
_RuneRange __mapupper_ext;
void *__variable;
int __variable_len;
int __ncharclasses;
_RuneCharClass *__charclasses;
} _RuneLocale;
extern "C" {
extern _RuneLocale _DefaultRuneLocale;
extern _RuneLocale *_CurrentRuneLocale;
}
# 71 "/usr/include/ctype.h" 2 3 4
# 128 "/usr/include/ctype.h" 3 4
extern "C" {
unsigned long ___runetype(__darwin_ct_rune_t);
__darwin_ct_rune_t ___tolower(__darwin_ct_rune_t);
__darwin_ct_rune_t ___toupper(__darwin_ct_rune_t);
}
inline int isascii(int _c) { return ((_c & ~0x7F) == 0); }
# 147 "/usr/include/ctype.h" 3 4
extern "C" { int __maskrune(__darwin_ct_rune_t, unsigned long); }
inline int __istype(__darwin_ct_rune_t _c, unsigned long _f) {
return (isascii(_c) ? !!(_DefaultRuneLocale.__runetype[_c] & _f)
: !!__maskrune(_c, _f));
}
inline __darwin_ct_rune_t __isctype(__darwin_ct_rune_t _c, unsigned long _f) {
return (_c < 0 || _c >= (1 << 8))
? 0
: !!(_DefaultRuneLocale.__runetype[_c] & _f);
}
# 187 "/usr/include/ctype.h" 3 4
extern "C" {
__darwin_ct_rune_t __toupper(__darwin_ct_rune_t);
__darwin_ct_rune_t __tolower(__darwin_ct_rune_t);
}
inline int __wcwidth(__darwin_ct_rune_t _c) {
unsigned int _x;
if (_c == 0)
return (0);
_x = (unsigned int)__maskrune(_c, 0xe0000000L | 0x00040000L);
if ((_x & 0xe0000000L) != 0)
return ((_x & 0xe0000000L) >> 30);
return ((_x & 0x00040000L) != 0 ? 1 : -1);
}
inline int isalnum(int _c) { return (__istype(_c, 0x00000100L | 0x00000400L)); }
inline int isalpha(int _c) { return (__istype(_c, 0x00000100L)); }
inline int isblank(int _c) { return (__istype(_c, 0x00020000L)); }
inline int iscntrl(int _c) { return (__istype(_c, 0x00000200L)); }
inline int isdigit(int _c) { return (__isctype(_c, 0x00000400L)); }
inline int isgraph(int _c) { return (__istype(_c, 0x00000800L)); }
inline int islower(int _c) { return (__istype(_c, 0x00001000L)); }
inline int isprint(int _c) { return (__istype(_c, 0x00040000L)); }
inline int ispunct(int _c) { return (__istype(_c, 0x00002000L)); }
inline int isspace(int _c) { return (__istype(_c, 0x00004000L)); }
inline int isupper(int _c) { return (__istype(_c, 0x00008000L)); }
inline int isxdigit(int _c) { return (__isctype(_c, 0x00010000L)); }
inline int toascii(int _c) { return (_c & 0x7F); }
inline int tolower(int _c) { return (__tolower(_c)); }
inline int toupper(int _c) { return (__toupper(_c)); }
inline int digittoint(int _c) { return (__maskrune(_c, 0x0F)); }
inline int ishexnumber(int _c) { return (__istype(_c, 0x00010000L)); }
inline int isideogram(int _c) { return (__istype(_c, 0x00080000L)); }
inline int isnumber(int _c) { return (__istype(_c, 0x00000400L)); }
inline int isphonogram(int _c) { return (__istype(_c, 0x00200000L)); }
inline int isrune(int _c) { return (__istype(_c, 0xFFFFFFF0L)); }
inline int isspecial(int _c) { return (__istype(_c, 0x00100000L)); }
# 58 "/usr/include/_wctype.h" 2 3 4
inline int iswalnum(wint_t _wc) {
return (__istype(_wc, 0x00000100L | 0x00000400L));
}
inline int iswalpha(wint_t _wc) { return (__istype(_wc, 0x00000100L)); }
inline int iswcntrl(wint_t _wc) { return (__istype(_wc, 0x00000200L)); }
inline int iswctype(wint_t _wc, wctype_t _charclass) {
return (__istype(_wc, _charclass));
}
inline int iswdigit(wint_t _wc) { return (__isctype(_wc, 0x00000400L)); }
inline int iswgraph(wint_t _wc) { return (__istype(_wc, 0x00000800L)); }
inline int iswlower(wint_t _wc) { return (__istype(_wc, 0x00001000L)); }
inline int iswprint(wint_t _wc) { return (__istype(_wc, 0x00040000L)); }
inline int iswpunct(wint_t _wc) { return (__istype(_wc, 0x00002000L)); }
inline int iswspace(wint_t _wc) { return (__istype(_wc, 0x00004000L)); }
inline int iswupper(wint_t _wc) { return (__istype(_wc, 0x00008000L)); }
inline int iswxdigit(wint_t _wc) { return (__isctype(_wc, 0x00010000L)); }
inline wint_t towlower(wint_t _wc) { return (__tolower(_wc)); }
inline wint_t towupper(wint_t _wc) { return (__toupper(_wc)); }
# 170 "/usr/include/_wctype.h" 3 4
extern "C" { wctype_t wctype(const char *); }
# 93 "/usr/include/wchar.h" 2 3 4
extern "C" {
wint_t btowc(int);
wint_t fgetwc(FILE *);
wchar_t *fgetws(wchar_t *, int, FILE *);
wint_t fputwc(wchar_t, FILE *);
int fputws(const wchar_t *, FILE *);
int fwide(FILE *, int);
int fwprintf(FILE *, const wchar_t *, ...);
int fwscanf(FILE *, const wchar_t *, ...);
wint_t getwc(FILE *);
wint_t getwchar(void);
size_t mbrlen(const char *, size_t, mbstate_t *);
size_t mbrtowc(wchar_t *, const char *, size_t, mbstate_t *);
int mbsinit(const mbstate_t *);
size_t mbsrtowcs(wchar_t *, const char **, size_t, mbstate_t *);
wint_t putwc(wchar_t, FILE *);
wint_t putwchar(wchar_t);
int swprintf(wchar_t *, size_t, const wchar_t *, ...);
int swscanf(const wchar_t *, const wchar_t *, ...);
wint_t ungetwc(wint_t, FILE *);
int vfwprintf(FILE *, const wchar_t *, __darwin_va_list);
int vswprintf(wchar_t *, size_t, const wchar_t *, __darwin_va_list);
int vwprintf(const wchar_t *, __darwin_va_list);
size_t wcrtomb(char *, wchar_t, mbstate_t *);
wchar_t *wcscat(wchar_t *, const wchar_t *);
wchar_t *wcschr(const wchar_t *, wchar_t);
int wcscmp(const wchar_t *, const wchar_t *);
int wcscoll(const wchar_t *, const wchar_t *);
wchar_t *wcscpy(wchar_t *, const wchar_t *);
size_t wcscspn(const wchar_t *, const wchar_t *);
size_t wcsftime(wchar_t *, size_t, const wchar_t *,
const struct tm *) __asm("_"
"wcsftime");
size_t wcslen(const wchar_t *);
wchar_t *wcsncat(wchar_t *, const wchar_t *, size_t);
int wcsncmp(const wchar_t *, const wchar_t *, size_t);
wchar_t *wcsncpy(wchar_t *, const wchar_t *, size_t);
wchar_t *wcspbrk(const wchar_t *, const wchar_t *);
wchar_t *wcsrchr(const wchar_t *, wchar_t);
size_t wcsrtombs(char *, const wchar_t **, size_t, mbstate_t *);
size_t wcsspn(const wchar_t *, const wchar_t *);
wchar_t *wcsstr(const wchar_t *, const wchar_t *);
size_t wcsxfrm(wchar_t *, const wchar_t *, size_t);
int wctob(wint_t);
double wcstod(const wchar_t *, wchar_t **);
wchar_t *wcstok(wchar_t *, const wchar_t *, wchar_t **);
long wcstol(const wchar_t *, wchar_t **, int);
unsigned long wcstoul(const wchar_t *, wchar_t **, int);
wchar_t *wmemchr(const wchar_t *, wchar_t, size_t);
int wmemcmp(const wchar_t *, const wchar_t *, size_t);
wchar_t *wmemcpy(wchar_t *, const wchar_t *, size_t);
wchar_t *wmemmove(wchar_t *, const wchar_t *, size_t);
wchar_t *wmemset(wchar_t *, wchar_t, size_t);
int wprintf(const wchar_t *, ...);
int wscanf(const wchar_t *, ...);
int wcswidth(const wchar_t *, size_t);
int wcwidth(wchar_t);
}
# 169 "/usr/include/wchar.h" 3 4
extern "C" {
int vfwscanf(FILE *, const wchar_t *, __darwin_va_list);
int vswscanf(const wchar_t *, const wchar_t *, __darwin_va_list);
int vwscanf(const wchar_t *, __darwin_va_list);
float wcstof(const wchar_t *, wchar_t **);
long double wcstold(const wchar_t *, wchar_t **);
long long wcstoll(const wchar_t *, wchar_t **, int);
unsigned long long wcstoull(const wchar_t *, wchar_t **, int);
}
# 194 "/usr/include/wchar.h" 3 4
extern "C" {
size_t mbsnrtowcs(wchar_t *, const char **, size_t, size_t, mbstate_t *);
wchar_t *wcpcpy(wchar_t *, const wchar_t *)
__attribute__((availability(macosx, introduced = 10.7)));
wchar_t *wcpncpy(wchar_t *, const wchar_t *, size_t)
__attribute__((availability(macosx, introduced = 10.7)));
wchar_t *wcsdup(const wchar_t *)
__attribute__((availability(macosx, introduced = 10.7)));
int wcscasecmp(const wchar_t *, const wchar_t *)
__attribute__((availability(macosx, introduced = 10.7)));
int wcsncasecmp(const wchar_t *, const wchar_t *, size_t n)
__attribute__((availability(macosx, introduced = 10.7)));
size_t wcsnlen(const wchar_t *, size_t)
__attribute__((availability(macosx, introduced = 10.7)));
size_t wcsnrtombs(char *, const wchar_t **, size_t, size_t, mbstate_t *);
}
extern "C" {
wchar_t *fgetwln(FILE *, size_t *)
__attribute__((availability(macosx, introduced = 10.7)));
size_t wcslcat(wchar_t *, const wchar_t *, size_t);
size_t wcslcpy(wchar_t *, const wchar_t *, size_t);
}
# 45 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cwchar" 2 3
# 62 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cwchar" 3
namespace std {
using ::mbstate_t;
}
# 135 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cwchar" 3
namespace std __attribute__((__visibility__("default"))) {
using ::wint_t;
using ::btowc;
using ::fgetwc;
using ::fgetws;
using ::fputwc;
using ::fputws;
using ::fwide;
using ::fwprintf;
using ::fwscanf;
using ::getwc;
using ::getwchar;
using ::mbrlen;
using ::mbrtowc;
using ::mbsinit;
using ::mbsrtowcs;
using ::putwc;
using ::putwchar;
using ::swprintf;
using ::swscanf;
using ::ungetwc;
using ::vfwprintf;
using ::vfwscanf;
using ::vswprintf;
using ::vswscanf;
using ::vwprintf;
using ::vwscanf;
using ::wcrtomb;
using ::wcscat;
using ::wcscmp;
using ::wcscoll;
using ::wcscpy;
using ::wcscspn;
using ::wcsftime;
using ::wcslen;
using ::wcsncat;
using ::wcsncmp;
using ::wcsncpy;
using ::wcsrtombs;
using ::wcsspn;
using ::wcstod;
using ::wcstof;
using ::wcstok;
using ::wcstol;
using ::wcstoul;
using ::wcsxfrm;
using ::wctob;
using ::wmemcmp;
using ::wmemcpy;
using ::wmemmove;
using ::wmemset;
using ::wprintf;
using ::wscanf;
using ::wcschr;
using ::wcspbrk;
using ::wcsrchr;
using ::wcsstr;
using ::wmemchr;
inline wchar_t *wcschr(wchar_t * __p, wchar_t __c) {
return wcschr(const_cast<const wchar_t *>(__p), __c);
}
inline wchar_t *wcspbrk(wchar_t * __s1, const wchar_t * __s2) {
return wcspbrk(const_cast<const wchar_t *>(__s1), __s2);
}
inline wchar_t *wcsrchr(wchar_t * __p, wchar_t __c) {
return wcsrchr(const_cast<const wchar_t *>(__p), __c);
}
inline wchar_t *wcsstr(wchar_t * __s1, const wchar_t * __s2) {
return wcsstr(const_cast<const wchar_t *>(__s1), __s2);
}
inline wchar_t *wmemchr(wchar_t * __p, wchar_t __c, size_t __n) {
return wmemchr(const_cast<const wchar_t *>(__p), __c, __n);
}
}
namespace __gnu_cxx {
using ::wcstold;
# 257 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cwchar" 3
using ::wcstoll;
using ::wcstoull;
}
namespace std {
using ::__gnu_cxx::wcstold;
using ::__gnu_cxx::wcstoll;
using ::__gnu_cxx::wcstoull;
}
# 277 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cwchar" 3
namespace std {
using std::wcstof;
using std::vfwscanf;
using std::vswscanf;
using std::vwscanf;
using std::wcstold;
using std::wcstoll;
using std::wcstoull;
}
# 41 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/postypes.h" 2 3
# 68 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/postypes.h" 3
namespace std __attribute__((__visibility__("default"))) {
# 90 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/postypes.h" 3
typedef long long streamoff;
typedef ptrdiff_t streamsize;
# 111 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/postypes.h" 3
template <typename _StateT> class fpos {
private:
streamoff _M_off;
_StateT _M_state;
public:
fpos() : _M_off(0), _M_state() {}
# 133 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/postypes.h" 3
fpos(streamoff __off) : _M_off(__off), _M_state() {}
operator streamoff() const { return _M_off; }
void state(_StateT __st) { _M_state = __st; }
_StateT state() const { return _M_state; }
fpos &operator+=(streamoff __off) {
_M_off += __off;
return *this;
}
fpos &operator-=(streamoff __off) {
_M_off -= __off;
return *this;
}
fpos operator+(streamoff __off) const {
fpos __pos(*this);
__pos += __off;
return __pos;
}
fpos operator-(streamoff __off) const {
fpos __pos(*this);
__pos -= __off;
return __pos;
}
streamoff operator-(const fpos &__other) const {
return _M_off - __other._M_off;
}
};
template <typename _StateT>
inline bool operator==(const fpos<_StateT> & __lhs,
const fpos<_StateT> & __rhs) {
return streamoff(__lhs) == streamoff(__rhs);
}
template <typename _StateT>
inline bool operator!=(const fpos<_StateT> & __lhs,
const fpos<_StateT> & __rhs) {
return streamoff(__lhs) != streamoff(__rhs);
}
typedef fpos<mbstate_t> streampos;
typedef fpos<mbstate_t> wstreampos;
typedef fpos<mbstate_t> u16streampos;
typedef fpos<mbstate_t> u32streampos;
}
# 41 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/iosfwd" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 74 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/iosfwd" 3
class ios_base;
template <typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ios;
template <typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_streambuf;
template <typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_istream;
template <typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ostream;
template <typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_iostream;
template <typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_stringbuf;
template <typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_istringstream;
template <typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_ostringstream;
template <typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_stringstream;
template <typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_filebuf;
template <typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ifstream;
template <typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ofstream;
template <typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_fstream;
template <typename _CharT, typename _Traits = char_traits<_CharT> >
class istreambuf_iterator;
template <typename _CharT, typename _Traits = char_traits<_CharT> >
class ostreambuf_iterator;
typedef basic_ios<char> ios;
typedef basic_streambuf<char> streambuf;
typedef basic_istream<char> istream;
typedef basic_ostream<char> ostream;
typedef basic_iostream<char> iostream;
typedef basic_stringbuf<char> stringbuf;
typedef basic_istringstream<char> istringstream;
typedef basic_ostringstream<char> ostringstream;
typedef basic_stringstream<char> stringstream;
typedef basic_filebuf<char> filebuf;
typedef basic_ifstream<char> ifstream;
typedef basic_ofstream<char> ofstream;
typedef basic_fstream<char> fstream;
typedef basic_ios<wchar_t> wios;
typedef basic_streambuf<wchar_t> wstreambuf;
typedef basic_istream<wchar_t> wistream;
typedef basic_ostream<wchar_t> wostream;
typedef basic_iostream<wchar_t> wiostream;
typedef basic_stringbuf<wchar_t> wstringbuf;
typedef basic_istringstream<wchar_t> wistringstream;
typedef basic_ostringstream<wchar_t> wostringstream;
typedef basic_stringstream<wchar_t> wstringstream;
typedef basic_filebuf<wchar_t> wfilebuf;
typedef basic_ifstream<wchar_t> wifstream;
typedef basic_ofstream<wchar_t> wofstream;
typedef basic_fstream<wchar_t> wfstream;
}
# 39 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ios" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/exception" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/exception" 3
#pragma GCC visibility push(default)
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/atomic_lockfree_defines.h" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/atomic_lockfree_defines.h" 3
# 39 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/exception" 2 3
extern "C++" {
namespace std {
# 60 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/exception" 3
class exception {
public:
exception() noexcept {}
virtual ~exception() noexcept;
virtual const char *what() const noexcept;
};
class bad_exception : public exception {
public:
bad_exception() noexcept {}
virtual ~bad_exception() noexcept;
virtual const char *what() const noexcept;
};
typedef void (*terminate_handler)();
typedef void (*unexpected_handler)();
terminate_handler set_terminate(terminate_handler) noexcept;
terminate_handler get_terminate() noexcept;
void terminate() noexcept __attribute__((__noreturn__));
unexpected_handler set_unexpected(unexpected_handler) noexcept;
unexpected_handler get_unexpected() noexcept;
void unexpected() __attribute__((__noreturn__));
# 127 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/exception" 3
bool uncaught_exception() noexcept __attribute__((__pure__));
}
namespace __gnu_cxx {
# 152 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/exception" 3
void __verbose_terminate_handler();
}
}
#pragma GCC visibility pop
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/exception_ptr.h" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/exception_ptr.h" 3
#pragma GCC visibility push(default)
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/exception_defines.h" 1 3
# 38 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/exception_ptr.h" 2 3
extern "C++" {
namespace std {
class type_info;
namespace __exception_ptr {
class exception_ptr;
}
using __exception_ptr::exception_ptr;
exception_ptr current_exception() noexcept;
void rethrow_exception(exception_ptr) __attribute__((__noreturn__));
namespace __exception_ptr {
class exception_ptr {
void *_M_exception_object;
explicit exception_ptr(void *__e) noexcept;
void _M_addref() noexcept;
void _M_release() noexcept;
void *_M_get() const noexcept __attribute__((__pure__));
friend exception_ptr std::current_exception() noexcept;
friend void std::rethrow_exception(exception_ptr);
public:
exception_ptr() noexcept;
exception_ptr(const exception_ptr &) noexcept;
exception_ptr(nullptr_t) noexcept : _M_exception_object(0) {}
exception_ptr(exception_ptr &&__o) noexcept
: _M_exception_object(__o._M_exception_object) {
__o._M_exception_object = 0;
}
# 111 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/exception_ptr.h" 3
exception_ptr &operator=(const exception_ptr &) noexcept;
exception_ptr &operator=(exception_ptr &&__o) noexcept {
exception_ptr(static_cast<exception_ptr &&>(__o)).swap(*this);
return *this;
}
~exception_ptr() noexcept;
void swap(exception_ptr &) noexcept;
# 138 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/exception_ptr.h" 3
explicit operator bool() const { return _M_exception_object; }
friend bool operator==(const exception_ptr &, const exception_ptr &) noexcept
__attribute__((__pure__));
const class std::type_info *__cxa_exception_type() const noexcept
__attribute__((__pure__));
};
bool operator==(const exception_ptr &, const exception_ptr &) noexcept
__attribute__((__pure__));
bool operator!=(const exception_ptr &, const exception_ptr &) noexcept
__attribute__((__pure__));
inline void swap(exception_ptr &__lhs, exception_ptr &__rhs) {
__lhs.swap(__rhs);
}
}
template <typename _Ex> exception_ptr make_exception_ptr(_Ex __ex) noexcept {
try {
throw __ex;
}
catch (...) {
return current_exception();
}
}
template <typename _Ex>
exception_ptr copy_exception(_Ex __ex) noexcept __attribute__((__deprecated__));
template <typename _Ex> exception_ptr copy_exception(_Ex __ex) noexcept {
return std::make_exception_ptr<_Ex>(__ex);
}
}
}
#pragma GCC visibility pop
# 163 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/exception" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/nested_exception.h" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/nested_exception.h" 3
#pragma GCC visibility push(default)
# 45 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/nested_exception.h" 3
extern "C++" {
namespace std {
class nested_exception {
exception_ptr _M_ptr;
public:
nested_exception() noexcept : _M_ptr(current_exception()) {}
nested_exception(const nested_exception &) = default;
nested_exception &operator=(const nested_exception &) = default;
virtual ~nested_exception() noexcept;
void rethrow_nested() const __attribute__((__noreturn__)) {
rethrow_exception(_M_ptr);
}
exception_ptr nested_ptr() const { return _M_ptr; }
};
template <typename _Except>
struct _Nested_exception : public _Except, public nested_exception {
explicit _Nested_exception(_Except &&__ex)
: _Except(static_cast<_Except &&>(__ex)) {}
};
template <typename _Ex> struct __get_nested_helper {
static const nested_exception *_S_get(const _Ex &__ex) {
return dynamic_cast<const nested_exception *>(&__ex);
}
};
template <typename _Ex> struct __get_nested_helper<_Ex *> {
static const nested_exception *_S_get(const _Ex *__ex) {
return dynamic_cast<const nested_exception *>(__ex);
}
};
template <typename _Ex>
inline const nested_exception *__get_nested_exception(const _Ex &__ex) {
return __get_nested_helper<_Ex>::_S_get(__ex);
}
template <typename _Ex>
void __throw_with_nested(_Ex &&, const nested_exception * = 0)
__attribute__((__noreturn__));
template <typename _Ex>
void __throw_with_nested(_Ex &&, ...) __attribute__((__noreturn__));
template <typename _Ex>
inline void __throw_with_nested(_Ex &&__ex, const nested_exception *) {
throw __ex;
}
template <typename _Ex> inline void __throw_with_nested(_Ex &&__ex, ...) {
throw _Nested_exception<_Ex>(static_cast<_Ex &&>(__ex));
}
template <typename _Ex>
void throw_with_nested(_Ex __ex) __attribute__((__noreturn__));
template <typename _Ex> inline void throw_with_nested(_Ex __ex) {
if (__get_nested_exception(__ex))
throw __ex;
__throw_with_nested(static_cast<_Ex &&>(__ex), &__ex);
}
template <typename _Ex> inline void rethrow_if_nested(const _Ex &__ex) {
if (const nested_exception *__nested = __get_nested_exception(__ex))
__nested->rethrow_nested();
}
inline void rethrow_if_nested(const nested_exception &__ex) {
__ex.rethrow_nested();
}
}
}
#pragma GCC visibility pop
# 164 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/exception" 2 3
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ios" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/char_traits.h" 1 3
# 38 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/char_traits.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 1 3
# 60 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/functexcept.h" 1 3
# 42 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/functexcept.h" 3
namespace std __attribute__((__visibility__("default"))) {
void __throw_bad_exception(void)__attribute__((__noreturn__));
void __throw_bad_alloc(void)__attribute__((__noreturn__));
void __throw_bad_cast(void)__attribute__((__noreturn__));
void __throw_bad_typeid(void)__attribute__((__noreturn__));
void __throw_logic_error(const char *)__attribute__((__noreturn__));
void __throw_domain_error(const char *)__attribute__((__noreturn__));
void __throw_invalid_argument(const char *)__attribute__((__noreturn__));
void __throw_length_error(const char *)__attribute__((__noreturn__));
void __throw_out_of_range(const char *)__attribute__((__noreturn__));
void __throw_out_of_range_fmt(const char *, ...) __attribute__((__noreturn__))
__attribute__((__format__(__printf__, 1, 2)));
void __throw_runtime_error(const char *)__attribute__((__noreturn__));
void __throw_range_error(const char *)__attribute__((__noreturn__));
void __throw_overflow_error(const char *)__attribute__((__noreturn__));
void __throw_underflow_error(const char *)__attribute__((__noreturn__));
void __throw_ios_failure(const char *)__attribute__((__noreturn__));
void __throw_system_error(int)__attribute__((__noreturn__));
void __throw_future_error(int)__attribute__((__noreturn__));
void __throw_bad_function_call() __attribute__((__noreturn__));
}
# 61 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/cpp_type_traits.h" 1 3
# 36 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/cpp_type_traits.h" 3
# 68 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/cpp_type_traits.h" 3
namespace __gnu_cxx __attribute__((__visibility__("default"))) {
template <typename _Iterator, typename _Container> class __normal_iterator;
}
namespace std __attribute__((__visibility__("default"))) {
struct __true_type {};
struct __false_type {};
template <bool> struct __truth_type {
typedef __false_type __type;
};
template <> struct __truth_type<true> {
typedef __true_type __type;
};
template <class _Sp, class _Tp> struct __traitor {
enum {
__value = bool(_Sp::__value) || bool(_Tp::__value)
};
typedef typename __truth_type<__value>::__type __type;
};
template <typename, typename> struct __are_same {
enum {
__value = 0
};
typedef __false_type __type;
};
template <typename _Tp> struct __are_same<_Tp, _Tp> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <typename _Tp> struct __is_void {
enum {
__value = 0
};
typedef __false_type __type;
};
template <> struct __is_void<void> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <typename _Tp> struct __is_integer {
enum {
__value = 0
};
typedef __false_type __type;
};
template <> struct __is_integer<bool> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_integer<char> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_integer<signed char> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_integer<unsigned char> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_integer<wchar_t> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_integer<char16_t> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_integer<char32_t> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_integer<short> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_integer<unsigned short> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_integer<int> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_integer<unsigned int> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_integer<long> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_integer<unsigned long> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_integer<long long> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_integer<unsigned long long> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <typename _Tp> struct __is_floating {
enum {
__value = 0
};
typedef __false_type __type;
};
template <> struct __is_floating<float> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_floating<double> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_floating<long double> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <typename _Tp> struct __is_pointer {
enum {
__value = 0
};
typedef __false_type __type;
};
template <typename _Tp> struct __is_pointer<_Tp *> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <typename _Tp> struct __is_normal_iterator {
enum {
__value = 0
};
typedef __false_type __type;
};
template <typename _Iterator, typename _Container>
struct __is_normal_iterator<
__gnu_cxx::__normal_iterator<_Iterator, _Container> > {
enum {
__value = 1
};
typedef __true_type __type;
};
template <typename _Tp>
struct __is_arithmetic
: public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >{};
template <typename _Tp>
struct __is_scalar
: public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >{};
template <typename _Tp> struct __is_char {
enum {
__value = 0
};
typedef __false_type __type;
};
template <> struct __is_char<char> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_char<wchar_t> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <typename _Tp> struct __is_byte {
enum {
__value = 0
};
typedef __false_type __type;
};
template <> struct __is_byte<char> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_byte<signed char> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <> struct __is_byte<unsigned char> {
enum {
__value = 1
};
typedef __true_type __type;
};
template <typename _Tp> struct __is_move_iterator {
enum {
__value = 0
};
typedef __false_type __type;
};
template <typename _Iterator> class move_iterator;
template <typename _Iterator>
struct __is_move_iterator<move_iterator<_Iterator> > {
enum {
__value = 1
};
typedef __true_type __type;
};
}
# 62 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/type_traits.h" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/type_traits.h" 3
namespace __gnu_cxx __attribute__((__visibility__("default"))) {
template <bool, typename> struct __enable_if {};
template <typename _Tp> struct __enable_if<true, _Tp> {
typedef _Tp __type;
};
template <bool _Cond, typename _Iftrue, typename _Iffalse>
struct __conditional_type {
typedef _Iftrue __type;
};
template <typename _Iftrue, typename _Iffalse>
struct __conditional_type<false, _Iftrue, _Iffalse> {
typedef _Iffalse __type;
};
template <typename _Tp> struct __add_unsigned {
private:
typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
public:
typedef typename __if_type::__type __type;
};
template <> struct __add_unsigned<char> {
typedef unsigned char __type;
};
template <> struct __add_unsigned<signed char> {
typedef unsigned char __type;
};
template <> struct __add_unsigned<short> {
typedef unsigned short __type;
};
template <> struct __add_unsigned<int> {
typedef unsigned int __type;
};
template <> struct __add_unsigned<long> {
typedef unsigned long __type;
};
template <> struct __add_unsigned<long long> {
typedef unsigned long long __type;
};
template <> struct __add_unsigned<bool>;
template <> struct __add_unsigned<wchar_t>;
template <typename _Tp> struct __remove_unsigned {
private:
typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
public:
typedef typename __if_type::__type __type;
};
template <> struct __remove_unsigned<char> {
typedef signed char __type;
};
template <> struct __remove_unsigned<unsigned char> {
typedef signed char __type;
};
template <> struct __remove_unsigned<unsigned short> {
typedef short __type;
};
template <> struct __remove_unsigned<unsigned int> {
typedef int __type;
};
template <> struct __remove_unsigned<unsigned long> {
typedef long __type;
};
template <> struct __remove_unsigned<unsigned long long> {
typedef long long __type;
};
template <> struct __remove_unsigned<bool>;
template <> struct __remove_unsigned<wchar_t>;
template <typename _Type> inline bool __is_null_pointer(_Type * __ptr) {
return __ptr == 0;
}
template <typename _Type> inline bool __is_null_pointer(_Type) {
return false;
}
inline bool __is_null_pointer(std::nullptr_t) { return true; }
template <typename _Tp, bool = std::__is_integer<_Tp>::__value>
struct __promote {
typedef double __type;
};
template <typename _Tp> struct __promote<_Tp, false> {};
template <> struct __promote<long double> {
typedef long double __type;
};
template <> struct __promote<double> {
typedef double __type;
};
template <> struct __promote<float> {
typedef float __type;
};
template <typename _Tp, typename _Up,
typename _Tp2 = typename __promote<_Tp>::__type,
typename _Up2 = typename __promote<_Up>::__type>
struct __promote_2 {
typedef __typeof__(_Tp2() + _Up2()) __type;
};
template <typename _Tp, typename _Up, typename _Vp,
typename _Tp2 = typename __promote<_Tp>::__type,
typename _Up2 = typename __promote<_Up>::__type,
typename _Vp2 = typename __promote<_Vp>::__type>
struct __promote_3 {
typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type;
};
template <typename _Tp, typename _Up, typename _Vp, typename _Wp,
typename _Tp2 = typename __promote<_Tp>::__type,
typename _Up2 = typename __promote<_Up>::__type,
typename _Vp2 = typename __promote<_Vp>::__type,
typename _Wp2 = typename __promote<_Wp>::__type>
struct __promote_4 {
typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type;
};
}
# 63 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/numeric_traits.h" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/numeric_traits.h" 3
namespace __gnu_cxx __attribute__((__visibility__("default"))) {
# 54 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/numeric_traits.h" 3
template <typename _Value> struct __numeric_traits_integer {
static const _Value __min =
(((_Value)(-1) < 0)
? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0))
: (_Value)0);
static const _Value __max =
(((_Value)(-1) < 0)
? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) -
1)) -
1)
<< 1) +
1)
: ~(_Value)0);
static const bool __is_signed = ((_Value)(-1) < 0);
static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
};
template <typename _Value>
const _Value __numeric_traits_integer<_Value>::__min;
template <typename _Value>
const _Value __numeric_traits_integer<_Value>::__max;
template <typename _Value>
const bool __numeric_traits_integer<_Value>::__is_signed;
template <typename _Value>
const int __numeric_traits_integer<_Value>::__digits;
# 99 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/numeric_traits.h" 3
template <typename _Value> struct __numeric_traits_floating {
static const int __max_digits10 =
(2 + (std::__are_same<_Value, float>::__value
? 24
: std::__are_same<_Value, double>::__value ? 53 : 64) *
643L / 2136);
static const bool __is_signed = true;
static const int __digits10 =
(std::__are_same<_Value, float>::__value
? 6
: std::__are_same<_Value, double>::__value ? 15 : 18);
static const int __max_exponent10 =
(std::__are_same<_Value, float>::__value
? 38
: std::__are_same<_Value, double>::__value ? 308 : 4932);
};
template <typename _Value>
const int __numeric_traits_floating<_Value>::__max_digits10;
template <typename _Value>
const bool __numeric_traits_floating<_Value>::__is_signed;
template <typename _Value>
const int __numeric_traits_floating<_Value>::__digits10;
template <typename _Value>
const int __numeric_traits_floating<_Value>::__max_exponent10;
template <typename _Value>
struct __numeric_traits : public __conditional_type<
std::__is_integer<_Value>::__value,
__numeric_traits_integer<_Value>,
__numeric_traits_floating<_Value> >::__type {};
}
# 64 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator_base_types.h" 1 3
# 63 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator_base_types.h" 3
namespace std __attribute__((__visibility__("default"))) {
# 89 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator_base_types.h" 3
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 {};
# 116 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator_base_types.h" 3
template <typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
typename _Pointer = _Tp *, typename _Reference = _Tp &>
struct iterator {
typedef _Category iterator_category;
typedef _Tp value_type;
typedef _Distance difference_type;
typedef _Pointer pointer;
typedef _Reference reference;
};
# 142 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator_base_types.h" 3
template <typename _Tp> class __has_iterator_category_helper {
template <typename _Up> struct _Wrap_type {};
template <typename _Up>
static true_type __test(_Wrap_type<typename _Up::iterator_category> *);
template <typename _Up> static false_type __test(...);
public:
typedef decltype(__test<_Tp>(0)) type;
};
template <typename _Tp>
struct __has_iterator_category : public __has_iterator_category_helper<
typename remove_cv<_Tp>::type>::type {};
template <typename _Iterator,
bool = __has_iterator_category<_Iterator>::value>
struct __iterator_traits {};
template <typename _Iterator> struct __iterator_traits<_Iterator, true> {
typedef typename _Iterator::iterator_category iterator_category;
typedef typename _Iterator::value_type value_type;
typedef typename _Iterator::difference_type difference_type;
typedef typename _Iterator::pointer pointer;
typedef typename _Iterator::reference reference;
};
template <typename _Iterator>
struct iterator_traits : public __iterator_traits<_Iterator> {};
# 174 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator_base_types.h" 3
template <typename _Tp> struct iterator_traits<_Tp *> {
typedef random_access_iterator_tag iterator_category;
typedef _Tp value_type;
typedef ptrdiff_t difference_type;
typedef _Tp *pointer;
typedef _Tp &reference;
};
template <typename _Tp> struct iterator_traits<const _Tp *> {
typedef random_access_iterator_tag iterator_category;
typedef _Tp value_type;
typedef ptrdiff_t difference_type;
typedef const _Tp *pointer;
typedef const _Tp &reference;
};
template <typename _Iter>
inline typename iterator_traits<_Iter>::iterator_category __iterator_category(
const _Iter &) {
return typename iterator_traits<_Iter>::iterator_category();
}
template <typename _Iterator, bool _HasBase> struct _Iter_base {
typedef _Iterator iterator_type;
static iterator_type _S_base(_Iterator __it) { return __it; }
};
template <typename _Iterator> struct _Iter_base<_Iterator, true> {
typedef typename _Iterator::iterator_type iterator_type;
static iterator_type _S_base(_Iterator __it) { return __it.base(); }
};
template <typename _InIter>
using _RequireInputIter = typename enable_if<
is_convertible<typename iterator_traits<_InIter>::iterator_category,
input_iterator_tag>::value>::type;
}
# 66 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator_base_funcs.h" 1 3
# 63 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator_base_funcs.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/debug/debug.h" 1 3
# 46 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/debug/debug.h" 3
namespace std {
namespace __debug {}
}
namespace __gnu_debug {
using namespace std::__debug;
}
# 66 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator_base_funcs.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type __distance(
_InputIterator __first, _InputIterator __last, input_iterator_tag) {
typename iterator_traits<_InputIterator>::difference_type __n = 0;
while (__first != __last) {
++__first;
++__n;
}
return __n;
}
template <typename _RandomAccessIterator>
inline typename iterator_traits<_RandomAccessIterator>::difference_type
__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag) {
return __last - __first;
}
# 112 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator_base_funcs.h" 3
template <typename _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type distance(
_InputIterator __first, _InputIterator __last) {
return std::__distance(__first, __last, std::__iterator_category(__first));
}
template <typename _InputIterator, typename _Distance>
inline void __advance(_InputIterator & __i, _Distance __n,
input_iterator_tag) {
;
while (__n--)
++__i;
}
template <typename _BidirectionalIterator, typename _Distance>
inline void __advance(_BidirectionalIterator & __i, _Distance __n,
bidirectional_iterator_tag) {
if (__n > 0)
while (__n--)
++__i;
else
while (__n++)
--__i;
}
template <typename _RandomAccessIterator, typename _Distance>
inline void __advance(_RandomAccessIterator & __i, _Distance __n,
random_access_iterator_tag) {
__i += __n;
}
# 171 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator_base_funcs.h" 3
template <typename _InputIterator, typename _Distance>
inline void advance(_InputIterator & __i, _Distance __n) {
typename iterator_traits<_InputIterator>::difference_type __d = __n;
std::__advance(__i, __d, std::__iterator_category(__i));
}
template <typename _ForwardIterator>
inline _ForwardIterator next(
_ForwardIterator __x,
typename iterator_traits<_ForwardIterator>::difference_type __n = 1) {
std::advance(__x, __n);
return __x;
}
template <typename _BidirectionalIterator>
inline _BidirectionalIterator prev(
_BidirectionalIterator __x,
typename iterator_traits<_BidirectionalIterator>::difference_type __n =
1) {
std::advance(__x, -__n);
return __x;
}
}
# 67 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 1 3
# 66 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ptr_traits.h" 1 3
# 37 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ptr_traits.h" 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _Tp> class __has_element_type_helper {
template <typename _Up> struct _Wrap_type {};
template <typename _Up>
static true_type __test(_Wrap_type<typename _Up::element_type> *);
template <typename _Up> static false_type __test(...);
public:
typedef decltype(__test<_Tp>(0)) type;
};
template <typename _Tp>
struct __has_element_type
: public __has_element_type_helper<typename remove_cv<_Tp>::type>::type {
};
template <typename _Tp> class __has_difference_type_helper {
template <typename _Up> struct _Wrap_type {};
template <typename _Up>
static true_type __test(_Wrap_type<typename _Up::difference_type> *);
template <typename _Up> static false_type __test(...);
public:
typedef decltype(__test<_Tp>(0)) type;
};
template <typename _Tp>
struct __has_difference_type : public __has_difference_type_helper<
typename remove_cv<_Tp>::type>::type {};
template <typename _Tp, bool = __has_element_type<_Tp>::value>
struct __ptrtr_elt_type;
template <typename _Tp> struct __ptrtr_elt_type<_Tp, true> {
typedef typename _Tp::element_type __type;
};
template <template <typename, typename...> class _SomePtr, typename _Tp,
typename... _Args>
struct __ptrtr_elt_type<_SomePtr<_Tp, _Args...>, false> {
typedef _Tp __type;
};
template <typename _Tp, bool = __has_difference_type<_Tp>::value>
struct __ptrtr_diff_type {
typedef typename _Tp::difference_type __type;
};
template <typename _Tp> struct __ptrtr_diff_type<_Tp, false> {
typedef ptrdiff_t __type;
};
template <typename _Ptr, typename _Up> class __ptrtr_rebind_helper {
template <typename _Ptr2, typename _Up2>
static constexpr true_type _S_chk(typename _Ptr2::template rebind<_Up2> *);
template <typename, typename> static constexpr false_type _S_chk(...);
public:
using __type = decltype(_S_chk<_Ptr, _Up>(nullptr));
};
template <typename _Tp, typename _Up,
bool = __ptrtr_rebind_helper<_Tp, _Up>::__type::value>
struct __ptrtr_rebind;
template <typename _Tp, typename _Up> struct __ptrtr_rebind<_Tp, _Up, true> {
typedef typename _Tp::template rebind<_Up> __type;
};
template <template <typename, typename...> class _SomePtr, typename _Up,
typename _Tp, typename... _Args>
struct __ptrtr_rebind<_SomePtr<_Tp, _Args...>, _Up, false> {
typedef _SomePtr<_Up, _Args...> __type;
};
template <typename _Tp, typename = typename remove_cv<_Tp>::type>
struct __ptrtr_not_void {
typedef _Tp __type;
};
template <typename _Tp> struct __ptrtr_not_void<_Tp, void> {
struct __type {};
};
template <typename _Ptr> class __ptrtr_pointer_to {
typedef typename __ptrtr_elt_type<_Ptr>::__type __orig_type;
typedef typename __ptrtr_not_void<__orig_type>::__type __element_type;
public:
static _Ptr pointer_to(__element_type &__e) {
return _Ptr::pointer_to(__e);
}
};
template <typename _Ptr> struct pointer_traits : __ptrtr_pointer_to<_Ptr> {
typedef _Ptr pointer;
typedef typename __ptrtr_elt_type<_Ptr>::__type element_type;
typedef typename __ptrtr_diff_type<_Ptr>::__type difference_type;
template <typename _Up>
using rebind = typename __ptrtr_rebind<_Ptr, _Up>::__type;
};
template <typename _Tp> struct pointer_traits<_Tp *> {
typedef _Tp *pointer;
typedef _Tp element_type;
typedef ptrdiff_t difference_type;
template <typename _Up> using rebind = _Up *;
static pointer
pointer_to(typename __ptrtr_not_void<element_type>::__type &__r) noexcept {
return std::addressof(__r);
}
};
}
# 67 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 96 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 3
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> {
protected:
_Iterator current;
typedef iterator_traits<_Iterator> __traits_type;
public:
typedef _Iterator iterator_type;
typedef typename __traits_type::difference_type difference_type;
typedef typename __traits_type::pointer pointer;
typedef typename __traits_type::reference reference;
reverse_iterator() : current() {}
explicit reverse_iterator(iterator_type __x) : current(__x) {}
reverse_iterator(const reverse_iterator &__x) : current(__x.current) {}
template <typename _Iter>
reverse_iterator(const reverse_iterator<_Iter> &__x)
: current(__x.base()) {}
iterator_type base() const { return current; }
# 160 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 3
reference operator*() const {
_Iterator __tmp = current;
return *--__tmp;
}
pointer operator->() const { return &(operator*()); }
reverse_iterator &operator++() {
--current;
return *this;
}
reverse_iterator operator++(int) {
reverse_iterator __tmp = *this;
--current;
return __tmp;
}
reverse_iterator &operator--() {
++current;
return *this;
}
reverse_iterator operator--(int) {
reverse_iterator __tmp = *this;
++current;
return __tmp;
}
reverse_iterator operator+(difference_type __n) const {
return reverse_iterator(current - __n);
}
reverse_iterator &operator+=(difference_type __n) {
current -= __n;
return *this;
}
reverse_iterator operator-(difference_type __n) const {
return reverse_iterator(current + __n);
}
reverse_iterator &operator-=(difference_type __n) {
current += __n;
return *this;
}
reference operator[](difference_type __n) const { return *(*this + __n); }
};
# 290 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 3
template <typename _Iterator>
inline bool operator==(const reverse_iterator<_Iterator> & __x,
const reverse_iterator<_Iterator> & __y) {
return __x.base() == __y.base();
}
template <typename _Iterator>
inline bool operator<(const reverse_iterator<_Iterator> & __x,
const reverse_iterator<_Iterator> & __y) {
return __y.base() < __x.base();
}
template <typename _Iterator>
inline bool operator!=(const reverse_iterator<_Iterator> & __x,
const reverse_iterator<_Iterator> & __y) {
return !(__x == __y);
}
template <typename _Iterator>
inline bool operator>(const reverse_iterator<_Iterator> & __x,
const reverse_iterator<_Iterator> & __y) {
return __y < __x;
}
template <typename _Iterator>
inline bool operator<=(const reverse_iterator<_Iterator> & __x,
const reverse_iterator<_Iterator> & __y) {
return !(__y < __x);
}
template <typename _Iterator>
inline bool operator>=(const reverse_iterator<_Iterator> & __x,
const reverse_iterator<_Iterator> & __y) {
return !(__x < __y);
}
template <typename _Iterator>
inline typename reverse_iterator<_Iterator>::difference_type operator-(
const reverse_iterator<_Iterator> & __x,
const reverse_iterator<_Iterator> & __y) {
return __y.base() - __x.base();
}
template <typename _Iterator>
inline reverse_iterator<_Iterator> operator+(
typename reverse_iterator<_Iterator>::difference_type __n,
const reverse_iterator<_Iterator> & __x) {
return reverse_iterator<_Iterator>(__x.base() - __n);
}
template <typename _IteratorL, typename _IteratorR>
inline bool operator==(const reverse_iterator<_IteratorL> & __x,
const reverse_iterator<_IteratorR> & __y) {
return __x.base() == __y.base();
}
template <typename _IteratorL, typename _IteratorR>
inline bool operator<(const reverse_iterator<_IteratorL> & __x,
const reverse_iterator<_IteratorR> & __y) {
return __y.base() < __x.base();
}
template <typename _IteratorL, typename _IteratorR>
inline bool operator!=(const reverse_iterator<_IteratorL> & __x,
const reverse_iterator<_IteratorR> & __y) {
return !(__x == __y);
}
template <typename _IteratorL, typename _IteratorR>
inline bool operator>(const reverse_iterator<_IteratorL> & __x,
const reverse_iterator<_IteratorR> & __y) {
return __y < __x;
}
template <typename _IteratorL, typename _IteratorR>
inline bool operator<=(const reverse_iterator<_IteratorL> & __x,
const reverse_iterator<_IteratorR> & __y) {
return !(__y < __x);
}
template <typename _IteratorL, typename _IteratorR>
inline bool operator>=(const reverse_iterator<_IteratorL> & __x,
const reverse_iterator<_IteratorR> & __y) {
return !(__x < __y);
}
template <typename _IteratorL, typename _IteratorR>
inline auto operator-(const reverse_iterator<_IteratorL> & __x,
const reverse_iterator<_IteratorR> & __y)
->decltype(__y.base() - __x.base()) {
return __y.base() - __x.base();
}
# 402 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 3
template <typename _Container>
class back_insert_iterator
: public iterator<output_iterator_tag, void, void, void, void> {
protected:
_Container *container;
public:
typedef _Container container_type;
explicit back_insert_iterator(_Container &__x) : container(&__x) {}
# 436 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 3
back_insert_iterator &
operator=(const typename _Container::value_type &__value) {
container->push_back(__value);
return *this;
}
back_insert_iterator &operator=(typename _Container::value_type &&__value) {
container->push_back(std::move(__value));
return *this;
}
back_insert_iterator &operator*() { return *this; }
back_insert_iterator &operator++() { return *this; }
back_insert_iterator operator++(int) { return *this; }
};
# 478 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 3
template <typename _Container>
inline back_insert_iterator<_Container> back_inserter(_Container & __x) {
return back_insert_iterator<_Container>(__x);
}
# 493 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 3
template <typename _Container>
class front_insert_iterator
: public iterator<output_iterator_tag, void, void, void, void> {
protected:
_Container *container;
public:
typedef _Container container_type;
explicit front_insert_iterator(_Container &__x) : container(&__x) {}
# 526 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 3
front_insert_iterator &
operator=(const typename _Container::value_type &__value) {
container->push_front(__value);
return *this;
}
front_insert_iterator &
operator=(typename _Container::value_type &&__value) {
container->push_front(std::move(__value));
return *this;
}
front_insert_iterator &operator*() { return *this; }
front_insert_iterator &operator++() { return *this; }
front_insert_iterator operator++(int) { return *this; }
};
# 568 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 3
template <typename _Container>
inline front_insert_iterator<_Container> front_inserter(_Container & __x) {
return front_insert_iterator<_Container>(__x);
}
# 587 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 3
template <typename _Container>
class insert_iterator
: public iterator<output_iterator_tag, void, void, void, void> {
protected:
_Container *container;
typename _Container::iterator iter;
public:
typedef _Container container_type;
insert_iterator(_Container &__x, typename _Container::iterator __i)
: container(&__x), iter(__i) {}
# 638 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 3
insert_iterator &operator=(const typename _Container::value_type &__value) {
iter = container->insert(iter, __value);
++iter;
return *this;
}
insert_iterator &operator=(typename _Container::value_type &&__value) {
iter = container->insert(iter, std::move(__value));
++iter;
return *this;
}
insert_iterator &operator*() { return *this; }
insert_iterator &operator++() { return *this; }
insert_iterator &operator++(int) { return *this; }
};
# 682 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 3
template <typename _Container, typename _Iterator>
inline insert_iterator<_Container> inserter(_Container & __x, _Iterator __i) {
return insert_iterator<_Container>(__x, typename _Container::iterator(__i));
}
}
namespace __gnu_cxx __attribute__((__visibility__("default"))) {
# 706 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 3
using std::iterator_traits;
using std::iterator;
template <typename _Iterator, typename _Container> class __normal_iterator {
protected:
_Iterator _M_current;
typedef iterator_traits<_Iterator> __traits_type;
public:
typedef _Iterator iterator_type;
typedef typename __traits_type::iterator_category iterator_category;
typedef typename __traits_type::value_type value_type;
typedef typename __traits_type::difference_type difference_type;
typedef typename __traits_type::reference reference;
typedef typename __traits_type::pointer pointer;
constexpr __normal_iterator() noexcept : _M_current(_Iterator()) {}
explicit __normal_iterator(const _Iterator &__i) noexcept
: _M_current(__i) {}
template <typename _Iter>
__normal_iterator(const __normal_iterator<
_Iter,
typename __enable_if<
(std::__are_same<_Iter, typename _Container::pointer>::__value),
_Container>::__type> &__i) noexcept : _M_current(__i.base()) {}
__normal_iterator<typename _Container::pointer, _Container>
_M_const_cast() const noexcept {
using _PTraits = std::pointer_traits<typename _Container::pointer>;
return __normal_iterator<typename _Container::pointer, _Container>(
_PTraits::pointer_to(
const_cast<typename _PTraits::element_type &>(*_M_current)));
}
reference operator*() const noexcept { return *_M_current; }
pointer operator->() const noexcept { return _M_current; }
__normal_iterator &operator++() noexcept {
++_M_current;
return *this;
}
__normal_iterator operator++(int) noexcept {
return __normal_iterator(_M_current++);
}
__normal_iterator &operator--() noexcept {
--_M_current;
return *this;
}
__normal_iterator operator--(int) noexcept {
return __normal_iterator(_M_current--);
}
reference operator[](difference_type __n) const noexcept {
return _M_current[__n];
}
__normal_iterator &operator+=(difference_type __n) noexcept {
_M_current += __n;
return *this;
}
__normal_iterator operator+(difference_type __n) const noexcept {
return __normal_iterator(_M_current + __n);
}
__normal_iterator &operator-=(difference_type __n) noexcept {
_M_current -= __n;
return *this;
}
__normal_iterator operator-(difference_type __n) const noexcept {
return __normal_iterator(_M_current - __n);
}
const _Iterator &base() const noexcept { return _M_current; }
};
# 821 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 3
template <typename _IteratorL, typename _IteratorR, typename _Container>
inline bool operator==(
const __normal_iterator<_IteratorL, _Container> & __lhs,
const __normal_iterator<_IteratorR, _Container> & __rhs) noexcept {
return __lhs.base() == __rhs.base();
}
template <typename _Iterator, typename _Container>
inline bool operator==(const __normal_iterator<_Iterator, _Container> & __lhs,
const __normal_iterator<_Iterator, _Container> &
__rhs) noexcept {
return __lhs.base() == __rhs.base();
}
template <typename _IteratorL, typename _IteratorR, typename _Container>
inline bool operator!=(
const __normal_iterator<_IteratorL, _Container> & __lhs,
const __normal_iterator<_IteratorR, _Container> & __rhs) noexcept {
return __lhs.base() != __rhs.base();
}
template <typename _Iterator, typename _Container>
inline bool operator!=(const __normal_iterator<_Iterator, _Container> & __lhs,
const __normal_iterator<_Iterator, _Container> &
__rhs) noexcept {
return __lhs.base() != __rhs.base();
}
template <typename _IteratorL, typename _IteratorR, typename _Container>
inline bool operator<(const __normal_iterator<_IteratorL, _Container> & __lhs,
const __normal_iterator<_IteratorR, _Container> &
__rhs) noexcept {
return __lhs.base() < __rhs.base();
}
template <typename _Iterator, typename _Container>
inline bool operator<(const __normal_iterator<_Iterator, _Container> & __lhs,
const __normal_iterator<_Iterator, _Container> &
__rhs) noexcept {
return __lhs.base() < __rhs.base();
}
template <typename _IteratorL, typename _IteratorR, typename _Container>
inline bool operator>(const __normal_iterator<_IteratorL, _Container> & __lhs,
const __normal_iterator<_IteratorR, _Container> &
__rhs) noexcept {
return __lhs.base() > __rhs.base();
}
template <typename _Iterator, typename _Container>
inline bool operator>(const __normal_iterator<_Iterator, _Container> & __lhs,
const __normal_iterator<_Iterator, _Container> &
__rhs) noexcept {
return __lhs.base() > __rhs.base();
}
template <typename _IteratorL, typename _IteratorR, typename _Container>
inline bool operator<=(
const __normal_iterator<_IteratorL, _Container> & __lhs,
const __normal_iterator<_IteratorR, _Container> & __rhs) noexcept {
return __lhs.base() <= __rhs.base();
}
template <typename _Iterator, typename _Container>
inline bool operator<=(const __normal_iterator<_Iterator, _Container> & __lhs,
const __normal_iterator<_Iterator, _Container> &
__rhs) noexcept {
return __lhs.base() <= __rhs.base();
}
template <typename _IteratorL, typename _IteratorR, typename _Container>
inline bool operator>=(
const __normal_iterator<_IteratorL, _Container> & __lhs,
const __normal_iterator<_IteratorR, _Container> & __rhs) noexcept {
return __lhs.base() >= __rhs.base();
}
template <typename _Iterator, typename _Container>
inline bool operator>=(const __normal_iterator<_Iterator, _Container> & __lhs,
const __normal_iterator<_Iterator, _Container> &
__rhs) noexcept {
return __lhs.base() >= __rhs.base();
}
template <typename _IteratorL, typename _IteratorR, typename _Container>
inline auto operator-(const __normal_iterator<_IteratorL, _Container> & __lhs,
const __normal_iterator<_IteratorR, _Container> &
__rhs) noexcept->decltype(__lhs.base() -
__rhs.base()) {
return __lhs.base() - __rhs.base();
}
template <typename _Iterator, typename _Container>
inline typename __normal_iterator<_Iterator, _Container>::difference_type
operator-(const __normal_iterator<_Iterator, _Container> & __lhs,
const __normal_iterator<_Iterator, _Container> & __rhs) noexcept {
return __lhs.base() - __rhs.base();
}
template <typename _Iterator, typename _Container>
inline __normal_iterator<_Iterator, _Container> operator+(
typename __normal_iterator<_Iterator, _Container>::difference_type __n,
const __normal_iterator<_Iterator, _Container> & __i) noexcept {
return __normal_iterator<_Iterator, _Container>(__i.base() + __n);
}
}
namespace std __attribute__((__visibility__("default"))) {
# 961 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_iterator.h" 3
template <typename _Iterator> class move_iterator {
protected:
_Iterator _M_current;
typedef iterator_traits<_Iterator> __traits_type;
public:
typedef _Iterator iterator_type;
typedef typename __traits_type::iterator_category iterator_category;
typedef typename __traits_type::value_type value_type;
typedef typename __traits_type::difference_type difference_type;
typedef _Iterator pointer;
typedef value_type &&reference;
move_iterator() : _M_current() {}
explicit move_iterator(iterator_type __i) : _M_current(__i) {}
template <typename _Iter>
move_iterator(const move_iterator<_Iter> &__i)
: _M_current(__i.base()) {}
iterator_type base() const { return _M_current; }
reference operator*() const { return std::move(*_M_current); }
pointer operator->() const { return _M_current; }
move_iterator &operator++() {
++_M_current;
return *this;
}
move_iterator operator++(int) {
move_iterator __tmp = *this;
++_M_current;
return __tmp;
}
move_iterator &operator--() {
--_M_current;
return *this;
}
move_iterator operator--(int) {
move_iterator __tmp = *this;
--_M_current;
return __tmp;
}
move_iterator operator+(difference_type __n) const {
return move_iterator(_M_current + __n);
}
move_iterator &operator+=(difference_type __n) {
_M_current += __n;
return *this;
}
move_iterator operator-(difference_type __n) const {
return move_iterator(_M_current - __n);
}
move_iterator &operator-=(difference_type __n) {
_M_current -= __n;
return *this;
}
reference operator[](difference_type __n) const {
return std::move(_M_current[__n]);
}
};
template <typename _IteratorL, typename _IteratorR>
inline bool operator==(const move_iterator<_IteratorL> & __x,
const move_iterator<_IteratorR> & __y) {
return __x.base() == __y.base();
}
template <typename _Iterator>
inline bool operator==(const move_iterator<_Iterator> & __x,
const move_iterator<_Iterator> & __y) {
return __x.base() == __y.base();
}
template <typename _IteratorL, typename _IteratorR>
inline bool operator!=(const move_iterator<_IteratorL> & __x,
const move_iterator<_IteratorR> & __y) {
return !(__x == __y);
}
template <typename _Iterator>
inline bool operator!=(const move_iterator<_Iterator> & __x,
const move_iterator<_Iterator> & __y) {
return !(__x == __y);
}
template <typename _IteratorL, typename _IteratorR>
inline bool operator<(const move_iterator<_IteratorL> & __x,
const move_iterator<_IteratorR> & __y) {
return __x.base() < __y.base();
}
template <typename _Iterator>
inline bool operator<(const move_iterator<_Iterator> & __x,
const move_iterator<_Iterator> & __y) {
return __x.base() < __y.base();
}
template <typename _IteratorL, typename _IteratorR>
inline bool operator<=(const move_iterator<_IteratorL> & __x,
const move_iterator<_IteratorR> & __y) {
return !(__y < __x);
}
template <typename _Iterator>
inline bool operator<=(const move_iterator<_Iterator> & __x,
const move_iterator<_Iterator> & __y) {
return !(__y < __x);
}
template <typename _IteratorL, typename _IteratorR>
inline bool operator>(const move_iterator<_IteratorL> & __x,
const move_iterator<_IteratorR> & __y) {
return __y < __x;
}
template <typename _Iterator>
inline bool operator>(const move_iterator<_Iterator> & __x,
const move_iterator<_Iterator> & __y) {
return __y < __x;
}
template <typename _IteratorL, typename _IteratorR>
inline bool operator>=(const move_iterator<_IteratorL> & __x,
const move_iterator<_IteratorR> & __y) {
return !(__x < __y);
}
template <typename _Iterator>
inline bool operator>=(const move_iterator<_Iterator> & __x,
const move_iterator<_Iterator> & __y) {
return !(__x < __y);
}
template <typename _IteratorL, typename _IteratorR>
inline auto operator-(const move_iterator<_IteratorL> & __x,
const move_iterator<_IteratorR> & __y)
->decltype(__x.base() - __y.base()) {
return __x.base() - __y.base();
}
template <typename _Iterator>
inline auto operator-(const move_iterator<_Iterator> & __x,
const move_iterator<_Iterator> & __y)
->decltype(__x.base() - __y.base()) {
return __x.base() - __y.base();
}
template <typename _Iterator>
inline move_iterator<_Iterator> operator+(
typename move_iterator<_Iterator>::difference_type __n,
const move_iterator<_Iterator> & __x) {
return __x + __n;
}
template <typename _Iterator>
inline move_iterator<_Iterator> make_move_iterator(_Iterator __i) {
return move_iterator<_Iterator>(__i);
}
template <typename _Iterator,
typename _ReturnType = typename conditional<
__move_if_noexcept_cond<
typename iterator_traits<_Iterator>::value_type>::value,
_Iterator, move_iterator<_Iterator> >::type>
inline _ReturnType __make_move_if_noexcept_iterator(_Iterator __i) {
return _ReturnType(__i);
}
}
# 68 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/predefined_ops.h" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/predefined_ops.h" 3
namespace __gnu_cxx {
namespace __ops {
struct _Iter_less_iter {
template <typename _Iterator1, typename _Iterator2>
bool operator()(_Iterator1 __it1, _Iterator2 __it2) const {
return *__it1 < *__it2;
}
};
inline _Iter_less_iter __iter_less_iter() { return _Iter_less_iter(); }
struct _Iter_less_val {
template <typename _Iterator, typename _Value>
bool operator()(_Iterator __it, _Value &__val) const {
return *__it < __val;
}
};
inline _Iter_less_val __iter_less_val() { return _Iter_less_val(); }
inline _Iter_less_val __iter_comp_val(_Iter_less_iter) {
return _Iter_less_val();
}
struct _Val_less_iter {
template <typename _Value, typename _Iterator>
bool operator()(_Value &__val, _Iterator __it) const {
return __val < *__it;
}
};
inline _Val_less_iter __val_less_iter() { return _Val_less_iter(); }
inline _Val_less_iter __val_comp_iter(_Iter_less_iter) {
return _Val_less_iter();
}
struct _Iter_equal_to_iter {
template <typename _Iterator1, typename _Iterator2>
bool operator()(_Iterator1 __it1, _Iterator2 __it2) const {
return *__it1 == *__it2;
}
};
inline _Iter_equal_to_iter __iter_equal_to_iter() {
return _Iter_equal_to_iter();
}
struct _Iter_equal_to_val {
template <typename _Iterator, typename _Value>
bool operator()(_Iterator __it, _Value &__val) const {
return *__it == __val;
}
};
inline _Iter_equal_to_val __iter_equal_to_val() { return _Iter_equal_to_val(); }
inline _Iter_equal_to_val __iter_comp_val(_Iter_equal_to_iter) {
return _Iter_equal_to_val();
}
template <typename _Compare> struct _Iter_comp_iter {
_Compare _M_comp;
_Iter_comp_iter(_Compare __comp) : _M_comp(__comp) {}
template <typename _Iterator1, typename _Iterator2>
bool operator()(_Iterator1 __it1, _Iterator2 __it2) {
return bool(_M_comp(*__it1, *__it2));
}
};
template <typename _Compare>
inline _Iter_comp_iter<_Compare> __iter_comp_iter(_Compare __comp) {
return _Iter_comp_iter<_Compare>(__comp);
}
template <typename _Compare> struct _Iter_comp_val {
_Compare _M_comp;
_Iter_comp_val(_Compare __comp) : _M_comp(__comp) {}
template <typename _Iterator, typename _Value>
bool operator()(_Iterator __it, _Value &__val) {
return bool(_M_comp(*__it, __val));
}
};
template <typename _Compare>
inline _Iter_comp_val<_Compare> __iter_comp_val(_Compare __comp) {
return _Iter_comp_val<_Compare>(__comp);
}
template <typename _Compare>
inline _Iter_comp_val<_Compare>
__iter_comp_val(_Iter_comp_iter<_Compare> __comp) {
return _Iter_comp_val<_Compare>(__comp._M_comp);
}
template <typename _Compare> struct _Val_comp_iter {
_Compare _M_comp;
_Val_comp_iter(_Compare __comp) : _M_comp(__comp) {}
template <typename _Value, typename _Iterator>
bool operator()(_Value &__val, _Iterator __it) {
return bool(_M_comp(__val, *__it));
}
};
template <typename _Compare>
inline _Val_comp_iter<_Compare> __val_comp_iter(_Compare __comp) {
return _Val_comp_iter<_Compare>(__comp);
}
template <typename _Compare>
inline _Val_comp_iter<_Compare>
__val_comp_iter(_Iter_comp_iter<_Compare> __comp) {
return _Val_comp_iter<_Compare>(__comp._M_comp);
}
template <typename _Value> struct _Iter_equals_val {
_Value &_M_value;
_Iter_equals_val(_Value &__value) : _M_value(__value) {}
template <typename _Iterator> bool operator()(_Iterator __it) {
return *__it == _M_value;
}
};
template <typename _Value>
inline _Iter_equals_val<_Value> __iter_equals_val(_Value &__val) {
return _Iter_equals_val<_Value>(__val);
}
template <typename _Iterator1> struct _Iter_equals_iter {
typename std::iterator_traits<_Iterator1>::reference _M_ref;
_Iter_equals_iter(_Iterator1 __it1) : _M_ref(*__it1) {}
template <typename _Iterator2> bool operator()(_Iterator2 __it2) {
return *__it2 == _M_ref;
}
};
template <typename _Iterator>
inline _Iter_equals_iter<_Iterator> __iter_comp_iter(_Iter_equal_to_iter,
_Iterator __it) {
return _Iter_equals_iter<_Iterator>(__it);
}
template <typename _Predicate> struct _Iter_pred {
_Predicate _M_pred;
_Iter_pred(_Predicate __pred) : _M_pred(__pred) {}
template <typename _Iterator> bool operator()(_Iterator __it) {
return bool(_M_pred(*__it));
}
};
template <typename _Predicate>
inline _Iter_pred<_Predicate> __pred_iter(_Predicate __pred) {
return _Iter_pred<_Predicate>(__pred);
}
template <typename _Compare, typename _Value> struct _Iter_comp_to_val {
_Compare _M_comp;
_Value &_M_value;
_Iter_comp_to_val(_Compare __comp, _Value &__value)
: _M_comp(__comp), _M_value(__value) {}
template <typename _Iterator> bool operator()(_Iterator __it) {
return bool(_M_comp(*__it, _M_value));
}
};
template <typename _Compare, typename _Value>
_Iter_comp_to_val<_Compare, _Value> __iter_comp_val(_Compare __comp,
_Value &__val) {
return _Iter_comp_to_val<_Compare, _Value>(__comp, __val);
}
template <typename _Compare, typename _Iterator1> struct _Iter_comp_to_iter {
_Compare _M_comp;
typename std::iterator_traits<_Iterator1>::reference _M_ref;
_Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
: _M_comp(__comp), _M_ref(*__it1) {}
template <typename _Iterator2> bool operator()(_Iterator2 __it2) {
return bool(_M_comp(*__it2, _M_ref));
}
};
template <typename _Compare, typename _Iterator>
inline _Iter_comp_to_iter<_Compare, _Iterator>
__iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) {
return _Iter_comp_to_iter<_Compare, _Iterator>(__comp._M_comp, __it);
}
template <typename _Predicate> struct _Iter_negate {
_Predicate _M_pred;
_Iter_negate(_Predicate __pred) : _M_pred(__pred) {}
template <typename _Iterator> bool operator()(_Iterator __it) {
return !bool(_M_pred(*__it));
}
};
template <typename _Predicate>
inline _Iter_negate<_Predicate> __negate(_Iter_pred<_Predicate> __pred) {
return _Iter_negate<_Predicate>(__pred._M_pred);
}
}
}
# 72 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 118 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _ForwardIterator1, typename _ForwardIterator2>
inline void iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) {
# 148 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
swap(*__a, *__b);
}
# 164 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator2 swap_ranges(_ForwardIterator1 __first1,
_ForwardIterator1 __last1,
_ForwardIterator2 __first2) {
;
for (; __first1 != __last1; ++__first1, ++__first2)
std::iter_swap(__first1, __first2);
return __first2;
}
# 192 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _Tp>
inline const _Tp &min(const _Tp & __a, const _Tp & __b) {
if (__b < __a)
return __b;
return __a;
}
# 215 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _Tp>
inline const _Tp &max(const _Tp & __a, const _Tp & __b) {
if (__a < __b)
return __b;
return __a;
}
# 238 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _Tp, typename _Compare>
inline const _Tp &min(const _Tp & __a, const _Tp & __b, _Compare __comp) {
if (__comp(__b, __a))
return __b;
return __a;
}
# 259 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _Tp, typename _Compare>
inline const _Tp &max(const _Tp & __a, const _Tp & __b, _Compare __comp) {
if (__comp(__a, __b))
return __b;
return __a;
}
template <typename _Iterator>
struct _Niter_base
: _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value> {};
template <typename _Iterator>
inline typename _Niter_base<_Iterator>::iterator_type __niter_base(
_Iterator __it) {
return std::_Niter_base<_Iterator>::_S_base(__it);
}
template <typename _Iterator>
struct _Miter_base
: _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value> {};
template <typename _Iterator>
inline typename _Miter_base<_Iterator>::iterator_type __miter_base(
_Iterator __it) {
return std::_Miter_base<_Iterator>::_S_base(__it);
}
template <bool, bool, typename> struct __copy_move {
template <typename _II, typename _OI>
static _OI __copy_m(_II __first, _II __last, _OI __result) {
for (; __first != __last; ++__result, ++__first)
*__result = *__first;
return __result;
}
};
template <typename _Category> struct __copy_move<true, false, _Category> {
template <typename _II, typename _OI>
static _OI __copy_m(_II __first, _II __last, _OI __result) {
for (; __first != __last; ++__result, ++__first)
*__result = std::move(*__first);
return __result;
}
};
template <> struct __copy_move<false, false, random_access_iterator_tag> {
template <typename _II, typename _OI>
static _OI __copy_m(_II __first, _II __last, _OI __result) {
typedef typename iterator_traits<_II>::difference_type _Distance;
for (_Distance __n = __last - __first; __n > 0; --__n) {
*__result = *__first;
++__first;
++__result;
}
return __result;
}
};
template <> struct __copy_move<true, false, random_access_iterator_tag> {
template <typename _II, typename _OI>
static _OI __copy_m(_II __first, _II __last, _OI __result) {
typedef typename iterator_traits<_II>::difference_type _Distance;
for (_Distance __n = __last - __first; __n > 0; --__n) {
*__result = std::move(*__first);
++__first;
++__result;
}
return __result;
}
};
template <bool _IsMove>
struct __copy_move<_IsMove, true, random_access_iterator_tag> {
template <typename _Tp>
static _Tp *__copy_m(const _Tp *__first, const _Tp *__last, _Tp *__result) {
static_assert(is_copy_assignable<_Tp>::value, "type is not assignable");
const ptrdiff_t _Num = __last - __first;
if (_Num)
__builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
return __result + _Num;
}
};
template <bool _IsMove, typename _II, typename _OI>
inline _OI __copy_move_a(_II __first, _II __last, _OI __result) {
typedef typename iterator_traits<_II>::value_type _ValueTypeI;
typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
typedef typename iterator_traits<_II>::iterator_category _Category;
const bool __simple =
(__is_trivial(_ValueTypeI) && __is_pointer<_II>::__value &&
__is_pointer<_OI>::__value &&
__are_same<_ValueTypeI, _ValueTypeO>::__value);
return std::__copy_move<_IsMove, __simple, _Category>::__copy_m(
__first, __last, __result);
}
template <typename _CharT> struct char_traits;
template <typename _CharT, typename _Traits> class istreambuf_iterator;
template <typename _CharT, typename _Traits> class ostreambuf_iterator;
template <bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<
__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
__copy_move_a2(_CharT *, _CharT *,
ostreambuf_iterator<_CharT, char_traits<_CharT> >);
template <bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<
__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
__copy_move_a2(const _CharT *, const _CharT *,
ostreambuf_iterator<_CharT, char_traits<_CharT> >);
template <bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, _CharT *>::__type
__copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT *);
template <bool _IsMove, typename _II, typename _OI>
inline _OI __copy_move_a2(_II __first, _II __last, _OI __result) {
return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result)));
}
# 454 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _II, typename _OI>
inline _OI copy(_II __first, _II __last, _OI __result) {
;
return (std::__copy_move_a2<__is_move_iterator<_II>::__value>(
std::__miter_base(__first), std::__miter_base(__last), __result));
}
# 487 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _II, typename _OI>
inline _OI move(_II __first, _II __last, _OI __result) {
;
return std::__copy_move_a2<true>(std::__miter_base(__first),
std::__miter_base(__last), __result);
}
template <bool, bool, typename> struct __copy_move_backward {
template <typename _BI1, typename _BI2>
static _BI2 __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) {
while (__first != __last)
*--__result = *--__last;
return __result;
}
};
template <typename _Category>
struct __copy_move_backward<true, false, _Category> {
template <typename _BI1, typename _BI2>
static _BI2 __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) {
while (__first != __last)
*--__result = std::move(*--__last);
return __result;
}
};
template <>
struct __copy_move_backward<false, false, random_access_iterator_tag> {
template <typename _BI1, typename _BI2>
static _BI2 __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) {
typename iterator_traits<_BI1>::difference_type __n;
for (__n = __last - __first; __n > 0; --__n)
*--__result = *--__last;
return __result;
}
};
template <>
struct __copy_move_backward<true, false, random_access_iterator_tag> {
template <typename _BI1, typename _BI2>
static _BI2 __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) {
typename iterator_traits<_BI1>::difference_type __n;
for (__n = __last - __first; __n > 0; --__n)
*--__result = std::move(*--__last);
return __result;
}
};
template <bool _IsMove>
struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> {
template <typename _Tp>
static _Tp *__copy_move_b(const _Tp *__first, const _Tp *__last,
_Tp *__result) {
static_assert(is_copy_assignable<_Tp>::value, "type is not assignable");
const ptrdiff_t _Num = __last - __first;
if (_Num)
__builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
return __result - _Num;
}
};
template <bool _IsMove, typename _BI1, typename _BI2>
inline _BI2 __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result) {
typedef typename iterator_traits<_BI1>::value_type _ValueType1;
typedef typename iterator_traits<_BI2>::value_type _ValueType2;
typedef typename iterator_traits<_BI1>::iterator_category _Category;
const bool __simple =
(__is_trivial(_ValueType1) && __is_pointer<_BI1>::__value &&
__is_pointer<_BI2>::__value &&
__are_same<_ValueType1, _ValueType2>::__value);
return std::__copy_move_backward<
_IsMove, __simple, _Category>::__copy_move_b(__first, __last, __result);
}
template <bool _IsMove, typename _BI1, typename _BI2>
inline _BI2 __copy_move_backward_a2(_BI1 __first, _BI1 __last,
_BI2 __result) {
return _BI2(std::__copy_move_backward_a<_IsMove>(
std::__niter_base(__first), std::__niter_base(__last),
std::__niter_base(__result)));
}
# 628 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _BI1, typename _BI2>
inline _BI2 copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) {
;
return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>(
std::__miter_base(__first), std::__miter_base(__last), __result));
}
# 664 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _BI1, typename _BI2>
inline _BI2 move_backward(_BI1 __first, _BI1 __last, _BI2 __result) {
;
return std::__copy_move_backward_a2<true>(
std::__miter_base(__first), std::__miter_base(__last), __result);
}
template <typename _ForwardIterator, typename _Tp>
inline typename __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value,
void>::__type
__fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp & __value) {
for (; __first != __last; ++__first)
*__first = __value;
}
template <typename _ForwardIterator, typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value,
void>::__type
__fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp & __value) {
const _Tp __tmp = __value;
for (; __first != __last; ++__first)
*__first = __tmp;
}
template <typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
__fill_a(_Tp * __first, _Tp * __last, const _Tp & __c) {
const _Tp __tmp = __c;
__builtin_memset(__first, static_cast<unsigned char>(__tmp),
__last - __first);
}
# 730 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _ForwardIterator, typename _Tp>
inline void fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp & __value) {
;
std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
__value);
}
template <typename _OutputIterator, typename _Size, typename _Tp>
inline typename __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value,
_OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp & __value) {
for (__decltype(__n + 0) __niter = __n; __niter > 0; --__niter, ++__first)
*__first = __value;
return __first;
}
template <typename _OutputIterator, typename _Size, typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value,
_OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp & __value) {
const _Tp __tmp = __value;
for (__decltype(__n + 0) __niter = __n; __niter > 0; --__niter, ++__first)
*__first = __tmp;
return __first;
}
template <typename _Size, typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp *>::__type
__fill_n_a(_Tp * __first, _Size __n, const _Tp & __c) {
std::__fill_a(__first, __first + __n, __c);
return __first + __n;
}
# 790 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _OI, typename _Size, typename _Tp>
inline _OI fill_n(_OI __first, _Size __n, const _Tp & __value) {
return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
}
template <bool _BoolType> struct __equal {
template <typename _II1, typename _II2>
static bool equal(_II1 __first1, _II1 __last1, _II2 __first2) {
for (; __first1 != __last1; ++__first1, ++__first2)
if (!(*__first1 == *__first2))
return false;
return true;
}
};
template <> struct __equal<true> {
template <typename _Tp>
static bool equal(const _Tp *__first1, const _Tp *__last1,
const _Tp *__first2) {
return !__builtin_memcmp(__first1, __first2,
sizeof(_Tp) * (__last1 - __first1));
}
};
template <typename _II1, typename _II2>
inline bool __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) {
typedef typename iterator_traits<_II1>::value_type _ValueType1;
typedef typename iterator_traits<_II2>::value_type _ValueType2;
const bool __simple =
((__is_integer<_ValueType1>::__value ||
__is_pointer<_ValueType1>::__value) &&
__is_pointer<_II1>::__value && __is_pointer<_II2>::__value &&
__are_same<_ValueType1, _ValueType2>::__value);
return std::__equal<__simple>::equal(__first1, __last1, __first2);
}
template <typename, typename> struct __lc_rai {
template <typename _II1, typename _II2>
static _II1 __newlast1(_II1, _II1 __last1, _II2, _II2) {
return __last1;
}
template <typename _II> static bool __cnd2(_II __first, _II __last) {
return __first != __last;
}
};
template <>
struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag> {
template <typename _RAI1, typename _RAI2>
static _RAI1 __newlast1(_RAI1 __first1, _RAI1 __last1, _RAI2 __first2,
_RAI2 __last2) {
const typename iterator_traits<_RAI1>::difference_type __diff1 =
__last1 - __first1;
const typename iterator_traits<_RAI2>::difference_type __diff2 =
__last2 - __first2;
return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
}
template <typename _RAI> static bool __cnd2(_RAI, _RAI) { return true; }
};
template <typename _II1, typename _II2, typename _Compare>
bool __lexicographical_compare_impl(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2,
_Compare __comp) {
typedef typename iterator_traits<_II1>::iterator_category _Category1;
typedef typename iterator_traits<_II2>::iterator_category _Category2;
typedef std::__lc_rai<_Category1, _Category2> __rai_type;
__last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
++__first1, ++__first2) {
if (__comp(__first1, __first2))
return true;
if (__comp(__first2, __first1))
return false;
}
return __first1 == __last1 && __first2 != __last2;
}
template <bool _BoolType> struct __lexicographical_compare {
template <typename _II1, typename _II2>
static bool __lc(_II1, _II1, _II2, _II2);
};
template <bool _BoolType>
template <typename _II1, typename _II2>
bool __lexicographical_compare<_BoolType>::__lc(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2) {
return std::__lexicographical_compare_impl(
__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_less_iter());
}
template <> struct __lexicographical_compare<true> {
template <typename _Tp, typename _Up>
static bool __lc(const _Tp *__first1, const _Tp *__last1,
const _Up *__first2, const _Up *__last2) {
const size_t __len1 = __last1 - __first1;
const size_t __len2 = __last2 - __first2;
const int __result =
__builtin_memcmp(__first1, __first2, std::min(__len1, __len2));
return __result != 0 ? __result < 0 : __len1 < __len2;
}
};
template <typename _II1, typename _II2>
inline bool __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2) {
typedef typename iterator_traits<_II1>::value_type _ValueType1;
typedef typename iterator_traits<_II2>::value_type _ValueType2;
const bool __simple =
(__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value &&
!__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed &&
!__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed &&
__is_pointer<_II1>::__value && __is_pointer<_II2>::__value);
return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
__first2, __last2);
}
template <typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator __lower_bound(_ForwardIterator __first,
_ForwardIterator __last, const _Tp & __val,
_Compare __comp) {
typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;
_DistanceType __len = std::distance(__first, __last);
while (__len > 0) {
_DistanceType __half = __len >> 1;
_ForwardIterator __middle = __first;
std::advance(__middle, __half);
if (__comp(__middle, __val)) {
__first = __middle;
++__first;
__len = __len - __half - 1;
} else
__len = __half;
}
return __first;
}
# 988 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _ForwardIterator, typename _Tp>
inline _ForwardIterator lower_bound(
_ForwardIterator __first, _ForwardIterator __last, const _Tp & __val) {
;
return std::__lower_bound(__first, __last, __val,
__gnu_cxx::__ops::__iter_less_val());
}
inline constexpr int __lg(int __n) {
return sizeof(int) * 8 - 1 - __builtin_clz(__n);
}
inline constexpr unsigned __lg(unsigned __n) {
return sizeof(int) * 8 - 1 - __builtin_clz(__n);
}
inline constexpr long __lg(long __n) {
return sizeof(long) * 8 - 1 - __builtin_clzl(__n);
}
inline constexpr unsigned long __lg(unsigned long __n) {
return sizeof(long) * 8 - 1 - __builtin_clzl(__n);
}
inline constexpr long long __lg(long long __n) {
return sizeof(long long) * 8 - 1 - __builtin_clzll(__n);
}
inline constexpr unsigned long long __lg(unsigned long long __n) {
return sizeof(long long) * 8 - 1 - __builtin_clzll(__n);
}
# 1045 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _II1, typename _II2>
inline bool equal(_II1 __first1, _II1 __last1, _II2 __first2) {
;
return std::__equal_aux(std::__niter_base(__first1),
std::__niter_base(__last1),
std::__niter_base(__first2));
}
# 1077 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _IIter1, typename _IIter2, typename _BinaryPredicate>
inline bool equal(_IIter1 __first1, _IIter1 __last1, _IIter2 __first2,
_BinaryPredicate __binary_pred) {
;
for (; __first1 != __last1; ++__first1, ++__first2)
if (!bool(__binary_pred(*__first1, *__first2)))
return false;
return true;
}
# 1202 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _II1, typename _II2>
inline bool lexicographical_compare(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2) {
# 1216 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
;
;
return std::__lexicographical_compare_aux(
std::__niter_base(__first1), std::__niter_base(__last1),
std::__niter_base(__first2), std::__niter_base(__last2));
}
# 1238 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _II1, typename _II2, typename _Compare>
inline bool lexicographical_compare(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2,
_Compare __comp) {
;
;
return std::__lexicographical_compare_impl(
__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
template <typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
pair<_InputIterator1, _InputIterator2> __mismatch(
_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _BinaryPredicate __binary_pred) {
while (__first1 != __last1 && __binary_pred(__first1, __first2)) {
++__first1;
++__first2;
}
return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
}
# 1281 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _InputIterator1, typename _InputIterator2>
inline pair<_InputIterator1, _InputIterator2> mismatch(
_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2) {
;
return std::__mismatch(__first1, __last1, __first2,
__gnu_cxx::__ops::__iter_equal_to_iter());
}
# 1314 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
template <typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
inline pair<_InputIterator1, _InputIterator2> mismatch(
_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _BinaryPredicate __binary_pred) {
;
return std::__mismatch(__first1, __last1, __first2,
__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
}
# 1415 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_algobase.h" 3
}
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/char_traits.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cwchar" 1 3
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cwchar" 3
# 42 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/char_traits.h" 2 3
namespace __gnu_cxx __attribute__((__visibility__("default"))) {
# 57 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/char_traits.h" 3
template <typename _CharT> struct _Char_types {
typedef unsigned long int_type;
typedef std::streampos pos_type;
typedef std::streamoff off_type;
typedef std::mbstate_t state_type;
};
# 82 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/char_traits.h" 3
template <typename _CharT> struct char_traits {
typedef _CharT char_type;
typedef typename _Char_types<_CharT>::int_type int_type;
typedef typename _Char_types<_CharT>::pos_type pos_type;
typedef typename _Char_types<_CharT>::off_type off_type;
typedef typename _Char_types<_CharT>::state_type state_type;
static void assign(char_type &__c1, const char_type &__c2) { __c1 = __c2; }
static constexpr bool eq(const char_type &__c1, const char_type &__c2) {
return __c1 == __c2;
}
static constexpr bool lt(const char_type &__c1, const char_type &__c2) {
return __c1 < __c2;
}
static int compare(const char_type *__s1, const char_type *__s2,
std::size_t __n);
static std::size_t length(const char_type *__s);
static const char_type *find(const char_type *__s, std::size_t __n,
const char_type &__a);
static char_type *move(char_type *__s1, const char_type *__s2,
std::size_t __n);
static char_type *copy(char_type *__s1, const char_type *__s2,
std::size_t __n);
static char_type *assign(char_type *__s, std::size_t __n, char_type __a);
static constexpr char_type to_char_type(const int_type &__c) {
return static_cast<char_type>(__c);
}
static constexpr int_type to_int_type(const char_type &__c) {
return static_cast<int_type>(__c);
}
static constexpr bool eq_int_type(const int_type &__c1,
const int_type &__c2) {
return __c1 == __c2;
}
static constexpr int_type eof() { return static_cast<int_type>(-1); }
static constexpr int_type not_eof(const int_type &__c) {
return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type());
}
};
template <typename _CharT>
int char_traits<_CharT>::compare(const char_type * __s1,
const char_type * __s2, std::size_t __n) {
for (std::size_t __i = 0; __i < __n; ++__i)
if (lt(__s1[__i], __s2[__i]))
return -1;
else if (lt(__s2[__i], __s1[__i]))
return 1;
return 0;
}
template <typename _CharT>
std::size_t char_traits<_CharT>::length(const char_type * __p) {
std::size_t __i = 0;
while (!eq(__p[__i], char_type()))
++__i;
return __i;
}
template <typename _CharT>
const typename char_traits<_CharT>::char_type *char_traits<_CharT>::find(
const char_type * __s, std::size_t __n, const char_type & __a) {
for (std::size_t __i = 0; __i < __n; ++__i)
if (eq(__s[__i], __a))
return __s + __i;
return 0;
}
template <typename _CharT>
typename char_traits<_CharT>::char_type *char_traits<_CharT>::move(
char_type * __s1, const char_type * __s2, std::size_t __n) {
return static_cast<_CharT *>(
__builtin_memmove(__s1, __s2, __n * sizeof(char_type)));
}
template <typename _CharT>
typename char_traits<_CharT>::char_type *char_traits<_CharT>::copy(
char_type * __s1, const char_type * __s2, std::size_t __n) {
std::copy(__s2, __s2 + __n, __s1);
return __s1;
}
template <typename _CharT>
typename char_traits<_CharT>::char_type *char_traits<_CharT>::assign(
char_type * __s, std::size_t __n, char_type __a) {
std::fill_n(__s, __n, __a);
return __s;
}
}
namespace std __attribute__((__visibility__("default"))) {
# 226 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/char_traits.h" 3
template <class _CharT>
struct char_traits : public __gnu_cxx::char_traits<_CharT> {};
template <> struct char_traits<char> {
typedef char char_type;
typedef int int_type;
typedef streampos pos_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
static void assign(char_type &__c1, const char_type &__c2) noexcept {
__c1 = __c2;
}
static constexpr bool eq(const char_type &__c1,
const char_type &__c2) noexcept {
return __c1 == __c2;
}
static constexpr bool lt(const char_type &__c1,
const char_type &__c2) noexcept {
return (static_cast<unsigned char>(__c1) <
static_cast<unsigned char>(__c2));
}
static int compare(const char_type *__s1, const char_type *__s2,
size_t __n) {
return __builtin_memcmp(__s1, __s2, __n);
}
static size_t length(const char_type *__s) { return __builtin_strlen(__s); }
static const char_type *find(const char_type *__s, size_t __n,
const char_type &__a) {
return static_cast<const char_type *>(__builtin_memchr(__s, __a, __n));
}
static char_type *move(char_type *__s1, const char_type *__s2, size_t __n) {
return static_cast<char_type *>(__builtin_memmove(__s1, __s2, __n));
}
static char_type *copy(char_type *__s1, const char_type *__s2, size_t __n) {
return static_cast<char_type *>(__builtin_memcpy(__s1, __s2, __n));
}
static char_type *assign(char_type *__s, size_t __n, char_type __a) {
return static_cast<char_type *>(__builtin_memset(__s, __a, __n));
}
static constexpr char_type to_char_type(const int_type &__c) noexcept {
return static_cast<char_type>(__c);
}
static constexpr int_type to_int_type(const char_type &__c) noexcept {
return static_cast<int_type>(static_cast<unsigned char>(__c));
}
static constexpr bool eq_int_type(const int_type &__c1,
const int_type &__c2) noexcept {
return __c1 == __c2;
}
static constexpr int_type eof() noexcept {
return static_cast<int_type>(-1);
}
static constexpr int_type not_eof(const int_type &__c) noexcept {
return (__c == eof()) ? 0 : __c;
}
};
template <> struct char_traits<wchar_t> {
typedef wchar_t char_type;
typedef wint_t int_type;
typedef streamoff off_type;
typedef wstreampos pos_type;
typedef mbstate_t state_type;
static void assign(char_type &__c1, const char_type &__c2) noexcept {
__c1 = __c2;
}
static constexpr bool eq(const char_type &__c1,
const char_type &__c2) noexcept {
return __c1 == __c2;
}
static constexpr bool lt(const char_type &__c1,
const char_type &__c2) noexcept {
return __c1 < __c2;
}
static int compare(const char_type *__s1, const char_type *__s2,
size_t __n) {
return wmemcmp(__s1, __s2, __n);
}
static size_t length(const char_type *__s) { return wcslen(__s); }
static const char_type *find(const char_type *__s, size_t __n,
const char_type &__a) {
return wmemchr(__s, __a, __n);
}
static char_type *move(char_type *__s1, const char_type *__s2, size_t __n) {
return wmemmove(__s1, __s2, __n);
}
static char_type *copy(char_type *__s1, const char_type *__s2, size_t __n) {
return wmemcpy(__s1, __s2, __n);
}
static char_type *assign(char_type *__s, size_t __n, char_type __a) {
return wmemset(__s, __a, __n);
}
static constexpr char_type to_char_type(const int_type &__c) noexcept {
return char_type(__c);
}
static constexpr int_type to_int_type(const char_type &__c) noexcept {
return int_type(__c);
}
static constexpr bool eq_int_type(const int_type &__c1,
const int_type &__c2) noexcept {
return __c1 == __c2;
}
static constexpr int_type eof() noexcept {
return static_cast<int_type>(((__darwin_wint_t) - 1));
}
static constexpr int_type not_eof(const int_type &__c) noexcept {
return eq_int_type(__c, eof()) ? 0 : __c;
}
};
}
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cstdint" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cstdint" 3
# 46 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cstdint" 3
namespace std {
using ::int8_t;
using ::int16_t;
using ::int32_t;
using ::int64_t;
using ::int_fast8_t;
using ::int_fast16_t;
using ::int_fast32_t;
using ::int_fast64_t;
using ::int_least8_t;
using ::int_least16_t;
using ::int_least32_t;
using ::int_least64_t;
using ::intmax_t;
using ::intptr_t;
using ::uint8_t;
using ::uint16_t;
using ::uint32_t;
using ::uint64_t;
using ::uint_fast8_t;
using ::uint_fast16_t;
using ::uint_fast32_t;
using ::uint_fast64_t;
using ::uint_least8_t;
using ::uint_least16_t;
using ::uint_least32_t;
using ::uint_least64_t;
using ::uintmax_t;
using ::uintptr_t;
}
# 381 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/char_traits.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
template <> struct char_traits<char16_t> {
typedef char16_t char_type;
typedef uint_least16_t int_type;
typedef streamoff off_type;
typedef u16streampos pos_type;
typedef mbstate_t state_type;
static void assign(char_type &__c1, const char_type &__c2) noexcept {
__c1 = __c2;
}
static constexpr bool eq(const char_type &__c1,
const char_type &__c2) noexcept {
return __c1 == __c2;
}
static constexpr bool lt(const char_type &__c1,
const char_type &__c2) noexcept {
return __c1 < __c2;
}
static int compare(const char_type *__s1, const char_type *__s2,
size_t __n) {
for (size_t __i = 0; __i < __n; ++__i)
if (lt(__s1[__i], __s2[__i]))
return -1;
else if (lt(__s2[__i], __s1[__i]))
return 1;
return 0;
}
static size_t length(const char_type *__s) {
size_t __i = 0;
while (!eq(__s[__i], char_type()))
++__i;
return __i;
}
static const char_type *find(const char_type *__s, size_t __n,
const char_type &__a) {
for (size_t __i = 0; __i < __n; ++__i)
if (eq(__s[__i], __a))
return __s + __i;
return 0;
}
static char_type *move(char_type *__s1, const char_type *__s2, size_t __n) {
return (static_cast<char_type *>(
__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
}
static char_type *copy(char_type *__s1, const char_type *__s2, size_t __n) {
return (static_cast<char_type *>(
__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
}
static char_type *assign(char_type *__s, size_t __n, char_type __a) {
for (size_t __i = 0; __i < __n; ++__i)
assign(__s[__i], __a);
return __s;
}
static constexpr char_type to_char_type(const int_type &__c) noexcept {
return char_type(__c);
}
static constexpr int_type to_int_type(const char_type &__c) noexcept {
return int_type(__c);
}
static constexpr bool eq_int_type(const int_type &__c1,
const int_type &__c2) noexcept {
return __c1 == __c2;
}
static constexpr int_type eof() noexcept {
return static_cast<int_type>(-1);
}
static constexpr int_type not_eof(const int_type &__c) noexcept {
return eq_int_type(__c, eof()) ? 0 : __c;
}
};
template <> struct char_traits<char32_t> {
typedef char32_t char_type;
typedef uint_least32_t int_type;
typedef streamoff off_type;
typedef u32streampos pos_type;
typedef mbstate_t state_type;
static void assign(char_type &__c1, const char_type &__c2) noexcept {
__c1 = __c2;
}
static constexpr bool eq(const char_type &__c1,
const char_type &__c2) noexcept {
return __c1 == __c2;
}
static constexpr bool lt(const char_type &__c1,
const char_type &__c2) noexcept {
return __c1 < __c2;
}
static int compare(const char_type *__s1, const char_type *__s2,
size_t __n) {
for (size_t __i = 0; __i < __n; ++__i)
if (lt(__s1[__i], __s2[__i]))
return -1;
else if (lt(__s2[__i], __s1[__i]))
return 1;
return 0;
}
static size_t length(const char_type *__s) {
size_t __i = 0;
while (!eq(__s[__i], char_type()))
++__i;
return __i;
}
static const char_type *find(const char_type *__s, size_t __n,
const char_type &__a) {
for (size_t __i = 0; __i < __n; ++__i)
if (eq(__s[__i], __a))
return __s + __i;
return 0;
}
static char_type *move(char_type *__s1, const char_type *__s2, size_t __n) {
return (static_cast<char_type *>(
__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
}
static char_type *copy(char_type *__s1, const char_type *__s2, size_t __n) {
return (static_cast<char_type *>(
__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
}
static char_type *assign(char_type *__s, size_t __n, char_type __a) {
for (size_t __i = 0; __i < __n; ++__i)
assign(__s[__i], __a);
return __s;
}
static constexpr char_type to_char_type(const int_type &__c) noexcept {
return char_type(__c);
}
static constexpr int_type to_int_type(const char_type &__c) noexcept {
return int_type(__c);
}
static constexpr bool eq_int_type(const int_type &__c1,
const int_type &__c2) noexcept {
return __c1 == __c2;
}
static constexpr int_type eof() noexcept {
return static_cast<int_type>(-1);
}
static constexpr int_type not_eof(const int_type &__c) noexcept {
return eq_int_type(__c, eof()) ? 0 : __c;
}
};
}
# 41 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ios" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/localefwd.h" 1 3
# 38 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/localefwd.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/c++locale.h" 1 3
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/c++locale.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/clocale" 1 3
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/clocale" 3
# 1 "/usr/include/locale.h" 1 3 4
# 40 "/usr/include/locale.h" 3 4
# 1 "/usr/include/_locale.h" 1 3 4
# 43 "/usr/include/_locale.h" 3 4
struct lconv {
char *decimal_point;
char *thousands_sep;
char *grouping;
char *int_curr_symbol;
char *currency_symbol;
char *mon_decimal_point;
char *mon_thousands_sep;
char *mon_grouping;
char *positive_sign;
char *negative_sign;
char int_frac_digits;
char frac_digits;
char p_cs_precedes;
char p_sep_by_space;
char n_cs_precedes;
char n_sep_by_space;
char p_sign_posn;
char n_sign_posn;
char int_p_cs_precedes;
char int_n_cs_precedes;
char int_p_sep_by_space;
char int_n_sep_by_space;
char int_p_sign_posn;
char int_n_sign_posn;
};
extern "C" { struct lconv *localeconv(void); }
# 41 "/usr/include/locale.h" 2 3 4
# 52 "/usr/include/locale.h" 3 4
extern "C" { char *setlocale(int, const char *); }
# 43 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/clocale" 2 3
namespace std {
using ::lconv;
using ::setlocale;
using ::localeconv;
}
# 42 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/c++locale.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
typedef int *__c_locale;
inline int __convert_from_v(const __c_locale &, char * __out,
const int __size __attribute__((__unused__)),
const char * __fmt, ...) {
char *__old = std::setlocale(4, 0);
char *__sav = 0;
if (__builtin_strcmp(__old, "C")) {
const size_t __len = __builtin_strlen(__old) + 1;
__sav = new char[__len];
__builtin_memcpy(__sav, __old, __len);
std::setlocale(4, "C");
}
__builtin_va_list __args;
__builtin_va_start(__args, __fmt);
const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
__builtin_va_end(__args);
if (__sav) {
std::setlocale(4, __sav);
delete[] __sav;
}
return __ret;
}
}
# 41 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/localefwd.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cctype" 1 3
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cctype" 3
# 62 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cctype" 3
namespace std {
using ::isalnum;
using ::isalpha;
using ::iscntrl;
using ::isdigit;
using ::isgraph;
using ::islower;
using ::isprint;
using ::ispunct;
using ::isspace;
using ::isupper;
using ::isxdigit;
using ::tolower;
using ::toupper;
}
namespace std {
using ::isblank;
}
# 43 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/localefwd.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 55 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/localefwd.h" 3
class locale;
template <typename _Facet> bool has_facet(const locale &)throw();
template <typename _Facet> const _Facet &use_facet(const locale &);
template <typename _CharT> bool isspace(_CharT, const locale &);
template <typename _CharT> bool isprint(_CharT, const locale &);
template <typename _CharT> bool iscntrl(_CharT, const locale &);
template <typename _CharT> bool isupper(_CharT, const locale &);
template <typename _CharT> bool islower(_CharT, const locale &);
template <typename _CharT> bool isalpha(_CharT, const locale &);
template <typename _CharT> bool isdigit(_CharT, const locale &);
template <typename _CharT> bool ispunct(_CharT, const locale &);
template <typename _CharT> bool isxdigit(_CharT, const locale &);
template <typename _CharT> bool isalnum(_CharT, const locale &);
template <typename _CharT> bool isgraph(_CharT, const locale &);
template <typename _CharT> _CharT toupper(_CharT, const locale &);
template <typename _CharT> _CharT tolower(_CharT, const locale &);
class ctype_base;
template <typename _CharT> class ctype;
template <> class ctype<char>;
template <> class ctype<wchar_t>;
template <typename _CharT> class ctype_byname;
class codecvt_base;
template <typename _InternT, typename _ExternT, typename _StateT>
class codecvt;
template <> class codecvt<char, char, mbstate_t>;
template <> class codecvt<wchar_t, char, mbstate_t>;
template <typename _InternT, typename _ExternT, typename _StateT>
class codecvt_byname;
template <typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class num_get;
template <typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class num_put;
template <typename _CharT> class numpunct;
template <typename _CharT> class numpunct_byname;
template <typename _CharT> class collate;
template <typename _CharT> class collate_byname;
class time_base;
template <typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class time_get;
template <typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class time_get_byname;
template <typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class time_put;
template <typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class time_put_byname;
class money_base;
template <typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class money_get;
template <typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class money_put;
template <typename _CharT, bool _Intl = false> class moneypunct;
template <typename _CharT, bool _Intl = false> class moneypunct_byname;
class messages_base;
template <typename _CharT> class messages;
template <typename _CharT> class messages_byname;
}
# 42 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ios" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 1 3
# 38 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/atomicity.h" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/atomicity.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/gthr.h" 1 3
# 30 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/gthr.h" 3
#pragma GCC visibility push(default)
# 148 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/gthr.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/gthr-default.h" 1 3
# 35 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/gthr-default.h" 3
# 1 "/usr/include/pthread.h" 1 3 4
# 57 "/usr/include/pthread.h" 3 4
# 1 "/usr/include/pthread_impl.h" 1 3 4
# 58 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/sched.h" 1 3 4
# 30 "/usr/include/sched.h" 3 4
extern "C" {
struct sched_param {
int sched_priority;
char __opaque[4];
};
extern int sched_yield(void);
extern int sched_get_priority_min(int);
extern int sched_get_priority_max(int);
}
# 60 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/sys/_types/_pthread_cond_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_pthread_cond_t.h" 3 4
typedef __darwin_pthread_cond_t pthread_cond_t;
# 63 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/sys/_types/_pthread_condattr_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_pthread_condattr_t.h" 3 4
typedef __darwin_pthread_condattr_t pthread_condattr_t;
# 64 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/sys/_types/_pthread_key_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_pthread_key_t.h" 3 4
typedef __darwin_pthread_key_t pthread_key_t;
# 65 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/sys/_types/_pthread_mutex_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_pthread_mutex_t.h" 3 4
typedef __darwin_pthread_mutex_t pthread_mutex_t;
# 66 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/sys/_types/_pthread_mutexattr_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_pthread_mutexattr_t.h" 3 4
typedef __darwin_pthread_mutexattr_t pthread_mutexattr_t;
# 67 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/sys/_types/_pthread_once_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_pthread_once_t.h" 3 4
typedef __darwin_pthread_once_t pthread_once_t;
# 68 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/sys/_types/_pthread_rwlock_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_pthread_rwlock_t.h" 3 4
typedef __darwin_pthread_rwlock_t pthread_rwlock_t;
# 69 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/sys/_types/_pthread_rwlockattr_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_pthread_rwlockattr_t.h" 3 4
typedef __darwin_pthread_rwlockattr_t pthread_rwlockattr_t;
# 70 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/sys/_types/_pthread_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_pthread_t.h" 3 4
typedef __darwin_pthread_t pthread_t;
# 71 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/sys/_types/_mach_port_t.h" 1 3 4
# 49 "/usr/include/sys/_types/_mach_port_t.h" 3 4
typedef __darwin_mach_port_t mach_port_t;
# 75 "/usr/include/pthread.h" 2 3 4
# 102 "/usr/include/pthread.h" 3 4
extern "C" {
# 206 "/usr/include/pthread.h" 3 4
__attribute__((availability(macosx, introduced = 10.4))) int pthread_atfork(
void (*)(void), void (*)(void), void (*)(void));
__attribute__((availability(
macosx, introduced = 10.4))) int pthread_attr_destroy(pthread_attr_t *);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_attr_getdetachstate(const pthread_attr_t *,
int *);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_attr_getguardsize(const pthread_attr_t *,
size_t *);
__attribute__((availability(
macosx, introduced =
10.4))) int pthread_attr_getinheritsched(const pthread_attr_t *,
int *);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_attr_getschedparam(const pthread_attr_t *,
struct sched_param *);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_attr_getschedpolicy(const pthread_attr_t *,
int *);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_attr_getscope(const pthread_attr_t *,
int *);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_attr_getstack(const pthread_attr_t *,
void **, size_t *);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_attr_getstackaddr(const pthread_attr_t *,
void **);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_attr_getstacksize(const pthread_attr_t *,
size_t *);
__attribute__((availability(macosx, introduced = 10.4))) int pthread_attr_init(
pthread_attr_t *);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_attr_setdetachstate(pthread_attr_t *, int);
__attribute__((availability(
macosx, introduced = 10.4))) int pthread_attr_setguardsize(pthread_attr_t *,
size_t);
__attribute__((availability(
macosx, introduced =
10.4))) int pthread_attr_setinheritsched(pthread_attr_t *, int);
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_attr_setschedparam(pthread_attr_t *,
const struct sched_param *);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_attr_setschedpolicy(pthread_attr_t *, int);
__attribute__((availability(
macosx, introduced = 10.4))) int pthread_attr_setscope(pthread_attr_t *,
int);
__attribute__((availability(
macosx, introduced = 10.4))) int pthread_attr_setstack(pthread_attr_t *,
void *, size_t);
__attribute__((availability(
macosx, introduced = 10.4))) int pthread_attr_setstackaddr(pthread_attr_t *,
void *);
__attribute__((availability(
macosx, introduced = 10.4))) int pthread_attr_setstacksize(pthread_attr_t *,
size_t);
__attribute__((availability(macosx, introduced = 10.4))) int pthread_cancel(
pthread_t) __asm("_"
"pthread_cancel");
__attribute__((availability(
macosx, introduced = 10.4))) int pthread_cond_broadcast(pthread_cond_t *);
__attribute__((availability(
macosx, introduced = 10.4))) int pthread_cond_destroy(pthread_cond_t *);
__attribute__((availability(macosx, introduced = 10.4))) int pthread_cond_init(
pthread_cond_t *, const pthread_condattr_t *) __asm("_"
"pthread_cond_init");
__attribute__((availability(
macosx, introduced = 10.4))) int pthread_cond_signal(pthread_cond_t *);
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_cond_timedwait(pthread_cond_t *, pthread_mutex_t *,
const struct timespec *) __asm("_"
"pthr"
"ead_"
"cond"
"_tim"
"edwa"
"it");
__attribute__((availability(macosx, introduced = 10.4))) int pthread_cond_wait(
pthread_cond_t *, pthread_mutex_t *) __asm("_"
"pthread_cond_wait");
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_condattr_destroy(pthread_condattr_t *);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_condattr_init(pthread_condattr_t *);
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_condattr_getpshared(const pthread_condattr_t *,
int *);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_condattr_setpshared(pthread_condattr_t *,
int);
__attribute__((availability(macosx, introduced = 10.4))) int pthread_create(
pthread_t *, const pthread_attr_t *, void *(*)(void *), void *);
__attribute__((availability(macosx,
introduced = 10.4))) int pthread_detach(pthread_t);
__attribute__((availability(macosx,
introduced = 10.4))) int pthread_equal(pthread_t,
pthread_t);
__attribute__((availability(macosx,
introduced = 10.4))) void pthread_exit(void *)
__attribute__((noreturn));
__attribute__((
availability(macosx, introduced = 10.4))) int pthread_getconcurrency(void);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_getschedparam(pthread_t, int *,
struct sched_param *);
__attribute__((availability(
macosx, introduced = 10.4))) void *pthread_getspecific(pthread_key_t);
__attribute__((availability(macosx, introduced = 10.4))) int pthread_join(
pthread_t, void **) __asm("_"
"pthread_join");
__attribute__((availability(macosx, introduced = 10.4))) int pthread_key_create(
pthread_key_t *, void (*)(void *));
__attribute__((availability(macosx, introduced = 10.4))) int pthread_key_delete(
pthread_key_t);
__attribute__((availability(
macosx, introduced = 10.4))) int pthread_mutex_destroy(pthread_mutex_t *);
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_mutex_getprioceiling(const pthread_mutex_t *,
int *);
__attribute__((availability(macosx, introduced = 10.4))) int pthread_mutex_init(
pthread_mutex_t *, const pthread_mutexattr_t *);
__attribute__((availability(macosx, introduced = 10.4))) int pthread_mutex_lock(
pthread_mutex_t *);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_mutex_setprioceiling(pthread_mutex_t *,
int, int *);
__attribute__((availability(
macosx, introduced = 10.4))) int pthread_mutex_trylock(pthread_mutex_t *);
__attribute__((availability(
macosx, introduced = 10.4))) int pthread_mutex_unlock(pthread_mutex_t *);
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_mutexattr_destroy(pthread_mutexattr_t *) __asm("_"
"pth"
"rea"
"d_"
"mut"
"exa"
"ttr"
"_de"
"str"
"o"
"y");
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *,
int *);
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *,
int *);
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_mutexattr_getpshared(const pthread_mutexattr_t *,
int *);
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_mutexattr_gettype(const pthread_mutexattr_t *,
int *);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_mutexattr_init(pthread_mutexattr_t *);
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *,
int);
__attribute__((availability(
macosx, introduced =
10.4))) int pthread_mutexattr_setprotocol(pthread_mutexattr_t *,
int);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_mutexattr_setpshared(pthread_mutexattr_t *,
int);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_mutexattr_settype(pthread_mutexattr_t *,
int);
__attribute__((availability(macosx, introduced = 10.4))) int pthread_once(
pthread_once_t *, void (*)(void));
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_rwlock_destroy(pthread_rwlock_t *) __asm("_"
"pthread_"
"rwlock_"
"destroy");
__attribute__((availability(macosx, introduced = 10.4))) int pthread_rwlock_init(
pthread_rwlock_t *,
const pthread_rwlockattr_t *) __asm("_"
"pthread_rwlock_init");
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_rwlock_rdlock(pthread_rwlock_t *) __asm("_"
"pthread_"
"rwlock_"
"rdlock");
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_rwlock_tryrdlock(pthread_rwlock_t *) __asm("_"
"pthread"
"_rwlock"
"_tryrdl"
"ock");
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_rwlock_trywrlock(pthread_rwlock_t *) __asm("_"
"pthread"
"_rwlock"
"_trywrl"
"ock");
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_rwlock_wrlock(pthread_rwlock_t *) __asm("_"
"pthread_"
"rwlock_"
"wrlock");
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_rwlock_unlock(pthread_rwlock_t *) __asm("_"
"pthread_"
"rwlock_"
"unlock");
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_rwlockattr_destroy(pthread_rwlockattr_t *);
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *,
int *);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_rwlockattr_init(pthread_rwlockattr_t *);
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *, int);
__attribute__((availability(macosx,
introduced = 10.4))) pthread_t pthread_self(void);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_setcancelstate(int, int *) __asm("_"
"pthread_"
"setcance"
"lstate");
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_setcanceltype(int,
int *) __asm("_"
"pthread_setcanceltype");
__attribute__((availability(macosx, introduced =
10.4))) int pthread_setconcurrency(int);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_setschedparam(pthread_t, int,
const struct sched_param *);
__attribute__((availability(macosx,
introduced =
10.4))) int pthread_setspecific(pthread_key_t,
const void *);
__attribute__((availability(
macosx,
introduced =
10.4))) void pthread_testcancel(void) __asm("_"
"pthread_testcancel");
__attribute__((
availability(macosx, introduced = 10.4))) int pthread_is_threaded_np(void);
__attribute__((availability(macosx,
introduced =
10.6))) int pthread_threadid_np(pthread_t,
__uint64_t *);
__attribute__((availability(macosx, introduced = 10.6))) int pthread_getname_np(
pthread_t, char *, size_t);
__attribute__((availability(macosx, introduced = 10.6))) int pthread_setname_np(
const char *);
__attribute__((availability(macosx,
introduced = 10.4))) int pthread_main_np(void);
__attribute__((availability(macosx, introduced = 10.4)))
mach_port_t pthread_mach_thread_np(pthread_t);
__attribute__((availability(macosx, introduced = 10.4)))
size_t pthread_get_stacksize_np(pthread_t);
__attribute__((availability(
macosx, introduced = 10.4))) void *pthread_get_stackaddr_np(pthread_t);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_cond_signal_thread_np(pthread_cond_t *,
pthread_t);
__attribute__((availability(
macosx,
introduced =
10.4))) int pthread_cond_timedwait_relative_np(pthread_cond_t *,
pthread_mutex_t *,
const struct timespec *);
__attribute__((availability(
macosx,
introduced = 10.4))) int pthread_create_suspended_np(pthread_t *,
const pthread_attr_t *,
void *(*)(void *),
void *);
__attribute__((availability(macosx,
introduced = 10.4))) int pthread_kill(pthread_t,
int);
__attribute__((availability(macosx, introduced = 10.5)))
pthread_t pthread_from_mach_thread_np(mach_port_t);
__attribute__((availability(macosx, introduced = 10.4))) int pthread_sigmask(
int, const sigset_t *, sigset_t *) __asm("_"
"pthread_sigmask");
__attribute__((availability(macosx,
introduced = 10.4))) void pthread_yield_np(void);
}
# 36 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/gthr-default.h" 2 3
# 47 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/gthr-default.h" 3
typedef pthread_t __gthread_t;
typedef pthread_key_t __gthread_key_t;
typedef pthread_once_t __gthread_once_t;
typedef pthread_mutex_t __gthread_mutex_t;
typedef pthread_mutex_t __gthread_recursive_mutex_t;
typedef pthread_cond_t __gthread_cond_t;
typedef struct timespec __gthread_time_t;
# 298 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/gthr-default.h" 3
static inline int __gthread_active_p(void) { return 1; }
# 658 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/gthr-default.h" 3
static inline int __gthread_create(__gthread_t *__threadid,
void *(*__func)(void *), void *__args) {
return pthread_create(__threadid, __null, __func, __args);
}
static inline int __gthread_join(__gthread_t __threadid, void **__value_ptr) {
return pthread_join(__threadid, __value_ptr);
}
static inline int __gthread_detach(__gthread_t __threadid) {
return pthread_detach(__threadid);
}
static inline int __gthread_equal(__gthread_t __t1, __gthread_t __t2) {
return pthread_equal(__t1, __t2);
}
static inline __gthread_t __gthread_self(void) { return pthread_self(); }
static inline int __gthread_yield(void) { return sched_yield(); }
static inline int __gthread_once(__gthread_once_t *__once,
void (*__func)(void)) {
if (__gthread_active_p())
return pthread_once(__once, __func);
else
return -1;
}
static inline int __gthread_key_create(__gthread_key_t *__key,
void (*__dtor)(void *)) {
return pthread_key_create(__key, __dtor);
}
static inline int __gthread_key_delete(__gthread_key_t __key) {
return pthread_key_delete(__key);
}
static inline void *__gthread_getspecific(__gthread_key_t __key) {
return pthread_getspecific(__key);
}
static inline int __gthread_setspecific(__gthread_key_t __key,
const void *__ptr) {
return pthread_setspecific(__key, __ptr);
}
static inline void __gthread_mutex_init_function(__gthread_mutex_t *__mutex) {
if (__gthread_active_p())
pthread_mutex_init(__mutex, __null);
}
static inline int __gthread_mutex_destroy(__gthread_mutex_t *__mutex) {
if (__gthread_active_p())
return pthread_mutex_destroy(__mutex);
else
return 0;
}
static inline int __gthread_mutex_lock(__gthread_mutex_t *__mutex) {
if (__gthread_active_p())
return pthread_mutex_lock(__mutex);
else
return 0;
}
static inline int __gthread_mutex_trylock(__gthread_mutex_t *__mutex) {
if (__gthread_active_p())
return pthread_mutex_trylock(__mutex);
else
return 0;
}
# 774 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/gthr-default.h" 3
static inline int __gthread_mutex_unlock(__gthread_mutex_t *__mutex) {
if (__gthread_active_p())
return pthread_mutex_unlock(__mutex);
else
return 0;
}
static inline int
__gthread_recursive_mutex_init_function(__gthread_recursive_mutex_t *__mutex) {
if (__gthread_active_p()) {
pthread_mutexattr_t __attr;
int __r;
__r = pthread_mutexattr_init(&__attr);
if (!__r)
__r = pthread_mutexattr_settype(&__attr, 2);
if (!__r)
__r = pthread_mutex_init(__mutex, &__attr);
if (!__r)
__r = pthread_mutexattr_destroy(&__attr);
return __r;
}
return 0;
}
static inline int
__gthread_recursive_mutex_lock(__gthread_recursive_mutex_t *__mutex) {
return __gthread_mutex_lock(__mutex);
}
static inline int
__gthread_recursive_mutex_trylock(__gthread_recursive_mutex_t *__mutex) {
return __gthread_mutex_trylock(__mutex);
}
# 828 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/gthr-default.h" 3
static inline int
__gthread_recursive_mutex_unlock(__gthread_recursive_mutex_t *__mutex) {
return __gthread_mutex_unlock(__mutex);
}
static inline int
__gthread_recursive_mutex_destroy(__gthread_recursive_mutex_t *__mutex) {
return __gthread_mutex_destroy(__mutex);
}
# 849 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/gthr-default.h" 3
static inline int __gthread_cond_broadcast(__gthread_cond_t *__cond) {
return pthread_cond_broadcast(__cond);
}
static inline int __gthread_cond_signal(__gthread_cond_t *__cond) {
return pthread_cond_signal(__cond);
}
static inline int __gthread_cond_wait(__gthread_cond_t *__cond,
__gthread_mutex_t *__mutex) {
return pthread_cond_wait(__cond, __mutex);
}
static inline int
__gthread_cond_timedwait(__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout) {
return pthread_cond_timedwait(__cond, __mutex, __abs_timeout);
}
static inline int
__gthread_cond_wait_recursive(__gthread_cond_t *__cond,
__gthread_recursive_mutex_t *__mutex) {
return __gthread_cond_wait(__cond, __mutex);
}
static inline int __gthread_cond_destroy(__gthread_cond_t *__cond) {
return pthread_cond_destroy(__cond);
}
# 149 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/gthr.h" 2 3
#pragma GCC visibility pop
# 36 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/atomicity.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/atomic_word.h" 1 3
# 32 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/atomic_word.h" 3
typedef int _Atomic_word;
# 37 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/atomicity.h" 2 3
namespace __gnu_cxx __attribute__((__visibility__("default"))) {
static inline _Atomic_word __exchange_and_add(volatile _Atomic_word * __mem,
int __val) {
return __atomic_fetch_add(__mem, __val, 4);
}
static inline void __atomic_add(volatile _Atomic_word * __mem, int __val) {
__atomic_fetch_add(__mem, __val, 4);
}
# 64 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/atomicity.h" 3
static inline _Atomic_word __exchange_and_add_single(_Atomic_word * __mem,
int __val) {
_Atomic_word __result = *__mem;
*__mem += __val;
return __result;
}
static inline void __atomic_add_single(_Atomic_word * __mem, int __val) {
*__mem += __val;
}
static inline _Atomic_word __attribute__((__unused__))
__exchange_and_add_dispatch(_Atomic_word * __mem, int __val) {
if (__gthread_active_p())
return __exchange_and_add(__mem, __val);
else
return __exchange_and_add_single(__mem, __val);
}
static inline void __attribute__((__unused__))
__atomic_add_dispatch(_Atomic_word * __mem, int __val) {
if (__gthread_active_p())
__atomic_add(__mem, __val);
else
__atomic_add_single(__mem, __val);
}
}
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 1 3
# 38 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/string" 1 3
# 37 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/string" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/allocator.h" 1 3
# 46 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/allocator.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/c++allocator.h" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/c++allocator.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/new_allocator.h" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/new_allocator.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/new" 1 3
# 38 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/new" 3
#pragma GCC visibility push(default)
extern "C++" {
namespace std {
class bad_alloc : public exception {
public:
bad_alloc() throw() {}
virtual ~bad_alloc() throw();
virtual const char *what() const throw();
};
class bad_array_new_length : public bad_alloc {
public:
bad_array_new_length() throw() {};
virtual ~bad_array_new_length() throw();
virtual const char *what() const throw();
};
# 99 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/new" 3
struct nothrow_t {};
extern const nothrow_t nothrow;
typedef void (*new_handler)();
new_handler set_new_handler(new_handler) throw();
new_handler get_new_handler() noexcept;
}
# 128 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/new" 3
void *operator new(std::size_t) __attribute__((__externally_visible__));
void *operator new[](std::size_t) __attribute__((__externally_visible__));
void operator delete(void *) noexcept __attribute__((__externally_visible__));
void operator delete[](void *) noexcept __attribute__((__externally_visible__));
void *operator new(std::size_t, const std::nothrow_t &) noexcept
__attribute__((__externally_visible__));
void *operator new[](std::size_t, const std::nothrow_t &) noexcept
__attribute__((__externally_visible__));
void operator delete(void *, const std::nothrow_t &) noexcept
__attribute__((__externally_visible__));
void operator delete[](void *, const std::nothrow_t &) noexcept
__attribute__((__externally_visible__));
inline void *operator new(std::size_t, void *__p) noexcept { return __p; }
inline void *operator new[](std::size_t, void *__p) noexcept { return __p; }
inline void operator delete(void *, void *) noexcept {}
inline void operator delete[](void *, void *) noexcept {}
}
#pragma GCC visibility pop
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/new_allocator.h" 2 3
namespace __gnu_cxx __attribute__((__visibility__("default"))) {
using std::size_t;
using std::ptrdiff_t;
# 57 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/new_allocator.h" 3
template <typename _Tp> class new_allocator {
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Tp *pointer;
typedef const _Tp *const_pointer;
typedef _Tp &reference;
typedef const _Tp &const_reference;
typedef _Tp value_type;
template <typename _Tp1> struct rebind {
typedef new_allocator<_Tp1> other;
};
typedef std::true_type propagate_on_container_move_assignment;
new_allocator() noexcept {}
new_allocator(const new_allocator &) noexcept {}
template <typename _Tp1>
new_allocator(const new_allocator<_Tp1> &) noexcept {}
~new_allocator() noexcept {}
pointer address(reference __x) const noexcept {
return std::__addressof(__x);
}
const_pointer address(const_reference __x) const noexcept {
return std::__addressof(__x);
}
pointer allocate(size_type __n, const void * = 0) {
if (__n > this->max_size())
std::__throw_bad_alloc();
return static_cast<_Tp *>(::operator new(__n * sizeof(_Tp)));
}
void deallocate(pointer __p, size_type) { ::operator delete(__p); }
size_type max_size() const noexcept { return size_t(-1) / sizeof(_Tp); }
template <typename _Up, typename... _Args>
void construct(_Up *__p, _Args &&... __args) {
::new ((void *)__p) _Up(std::forward<_Args>(__args)...);
}
template <typename _Up> void destroy(_Up *__p) { __p->~_Up(); }
# 135 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/new_allocator.h" 3
};
template <typename _Tp>
inline bool operator==(const new_allocator<_Tp> &,
const new_allocator<_Tp> &) {
return true;
}
template <typename _Tp>
inline bool operator!=(const new_allocator<_Tp> &,
const new_allocator<_Tp> &) {
return false;
}
}
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/c++allocator.h" 2 3
namespace std {
# 47 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/c++allocator.h" 3
template <typename _Tp> using __allocator_base = __gnu_cxx::new_allocator<_Tp>;
}
# 47 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/allocator.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 62 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/allocator.h" 3
template <> class allocator<void> {
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef void *pointer;
typedef const void *const_pointer;
typedef void value_type;
template <typename _Tp1> struct rebind {
typedef allocator<_Tp1> other;
};
typedef true_type propagate_on_container_move_assignment;
};
# 91 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/allocator.h" 3
template <typename _Tp> class allocator : public __allocator_base<_Tp> {
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Tp *pointer;
typedef const _Tp *const_pointer;
typedef _Tp &reference;
typedef const _Tp &const_reference;
typedef _Tp value_type;
template <typename _Tp1> struct rebind {
typedef allocator<_Tp1> other;
};
typedef true_type propagate_on_container_move_assignment;
allocator() throw() {}
allocator(const allocator &__a) throw() : __allocator_base<_Tp>(__a) {}
template <typename _Tp1> allocator(const allocator<_Tp1> &) throw() {}
~allocator() throw() {}
};
template <typename _T1, typename _T2>
inline bool operator==(const allocator<_T1> &, const allocator<_T2> &) {
return true;
}
template <typename _Tp>
inline bool operator==(const allocator<_Tp> &, const allocator<_Tp> &) {
return true;
}
template <typename _T1, typename _T2>
inline bool operator!=(const allocator<_T1> &, const allocator<_T2> &) {
return false;
}
template <typename _Tp>
inline bool operator!=(const allocator<_Tp> &, const allocator<_Tp> &) {
return false;
}
extern template class allocator<char>;
extern template class allocator<wchar_t>;
template <typename _Alloc, bool = __is_empty(_Alloc)> struct __alloc_swap {
static void _S_do_it(_Alloc &, _Alloc &) noexcept {}
};
template <typename _Alloc> struct __alloc_swap<_Alloc, false> {
static void _S_do_it(_Alloc &__one, _Alloc &__two) noexcept {
if (__one != __two)
swap(__one, __two);
}
};
template <typename _Alloc, bool = __is_empty(_Alloc)> struct __alloc_neq {
static bool _S_do_it(const _Alloc &, const _Alloc &) { return false; }
};
template <typename _Alloc> struct __alloc_neq<_Alloc, false> {
static bool _S_do_it(const _Alloc &__one, const _Alloc &__two) {
return __one != __two;
}
};
template <typename _Tp,
bool = __or_<is_copy_constructible<typename _Tp::value_type>,
is_nothrow_move_constructible<
typename _Tp::value_type> >::value>
struct __shrink_to_fit_aux {
static bool _S_do_it(_Tp &) noexcept { return false; }
};
template <typename _Tp> struct __shrink_to_fit_aux<_Tp, true> {
static bool _S_do_it(_Tp &__c) noexcept {
try {
_Tp(__make_move_if_noexcept_iterator(__c.begin()),
__make_move_if_noexcept_iterator(__c.end()),
__c.get_allocator()).swap(__c);
return true;
}
catch (...) {
return false;
}
}
};
}
# 42 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/string" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ostream_insert.h" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ostream_insert.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/cxxabi_forced.h" 1 3
# 35 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/cxxabi_forced.h" 3
#pragma GCC visibility push(default)
namespace __cxxabiv1 {
class __forced_unwind {
virtual ~__forced_unwind() throw();
virtual void __pure_dummy() = 0;
};
}
#pragma GCC visibility pop
# 37 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ostream_insert.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _CharT, typename _Traits>
inline void __ostream_write(basic_ostream<_CharT, _Traits> & __out,
const _CharT * __s, streamsize __n) {
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;
const streamsize __put = __out.rdbuf()->sputn(__s, __n);
if (__put != __n)
__out.setstate(__ios_base::badbit);
}
template <typename _CharT, typename _Traits>
inline void __ostream_fill(basic_ostream<_CharT, _Traits> & __out,
streamsize __n) {
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;
const _CharT __c = __out.fill();
for (; __n > 0; --__n) {
const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
if (_Traits::eq_int_type(__put, _Traits::eof())) {
__out.setstate(__ios_base::badbit);
break;
}
}
}
template <typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &__ostream_insert(
basic_ostream<_CharT, _Traits> & __out, const _CharT * __s,
streamsize __n) {
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;
typename __ostream_type::sentry __cerb(__out);
if (__cerb) {
try {
const streamsize __w = __out.width();
if (__w > __n) {
const bool __left =
((__out.flags() & __ios_base::adjustfield) == __ios_base::left);
if (!__left)
__ostream_fill(__out, __w - __n);
if (__out.good())
__ostream_write(__out, __s, __n);
if (__left && __out.good())
__ostream_fill(__out, __w - __n);
} else
__ostream_write(__out, __s, __n);
__out.width(0);
}
catch (__cxxabiv1::__forced_unwind &) {
__out._M_setstate(__ios_base::badbit);
throw;
}
catch (...) {
__out._M_setstate(__ios_base::badbit);
}
}
return __out;
}
extern template ostream &__ostream_insert(ostream &, const char *,
streamsize);
extern template wostream &__ostream_insert(wostream &, const wchar_t *,
streamsize);
}
# 45 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/string" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_function.h" 1 3
# 63 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_function.h" 3
namespace std __attribute__((__visibility__("default"))) {
# 104 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_function.h" 3
template <typename _Arg, typename _Result> struct unary_function {
typedef _Arg argument_type;
typedef _Result result_type;
};
template <typename _Arg1, typename _Arg2, typename _Result>
struct binary_function {
typedef _Arg1 first_argument_type;
typedef _Arg2 second_argument_type;
typedef _Result result_type;
};
# 166 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_function.h" 3
template <typename _Tp> struct plus : public binary_function<_Tp, _Tp, _Tp> {
_Tp operator()(const _Tp &__x, const _Tp &__y) const { return __x + __y; }
};
template <typename _Tp> struct minus : public binary_function<_Tp, _Tp, _Tp> {
_Tp operator()(const _Tp &__x, const _Tp &__y) const { return __x - __y; }
};
template <typename _Tp>
struct multiplies : public binary_function<_Tp, _Tp, _Tp> {
_Tp operator()(const _Tp &__x, const _Tp &__y) const { return __x * __y; }
};
template <typename _Tp>
struct divides : public binary_function<_Tp, _Tp, _Tp> {
_Tp operator()(const _Tp &__x, const _Tp &__y) const { return __x / __y; }
};
template <typename _Tp>
struct modulus : public binary_function<_Tp, _Tp, _Tp> {
_Tp operator()(const _Tp &__x, const _Tp &__y) const { return __x % __y; }
};
template <typename _Tp> struct negate : public unary_function<_Tp, _Tp> {
_Tp operator()(const _Tp &__x) const { return -__x; }
};
# 335 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_function.h" 3
template <typename _Tp>
struct equal_to : public binary_function<_Tp, _Tp, bool> {
bool operator()(const _Tp &__x, const _Tp &__y) const { return __x == __y; }
};
template <typename _Tp>
struct not_equal_to : public binary_function<_Tp, _Tp, bool> {
bool operator()(const _Tp &__x, const _Tp &__y) const { return __x != __y; }
};
template <typename _Tp>
struct greater : public binary_function<_Tp, _Tp, bool> {
bool operator()(const _Tp &__x, const _Tp &__y) const { return __x > __y; }
};
template <typename _Tp> struct less : public binary_function<_Tp, _Tp, bool> {
bool operator()(const _Tp &__x, const _Tp &__y) const { return __x < __y; }
};
template <typename _Tp>
struct greater_equal : public binary_function<_Tp, _Tp, bool> {
bool operator()(const _Tp &__x, const _Tp &__y) const { return __x >= __y; }
};
template <typename _Tp>
struct less_equal : public binary_function<_Tp, _Tp, bool> {
bool operator()(const _Tp &__x, const _Tp &__y) const { return __x <= __y; }
};
# 496 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_function.h" 3
template <typename _Tp>
struct logical_and : public binary_function<_Tp, _Tp, bool> {
bool operator()(const _Tp &__x, const _Tp &__y) const { return __x && __y; }
};
template <typename _Tp>
struct logical_or : public binary_function<_Tp, _Tp, bool> {
bool operator()(const _Tp &__x, const _Tp &__y) const { return __x || __y; }
};
template <typename _Tp>
struct logical_not : public unary_function<_Tp, bool> {
bool operator()(const _Tp &__x) const { return !__x; }
};
# 583 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_function.h" 3
template <typename _Tp>
struct bit_and : public binary_function<_Tp, _Tp, _Tp> {
_Tp operator()(const _Tp &__x, const _Tp &__y) const { return __x & __y; }
};
template <typename _Tp>
struct bit_or : public binary_function<_Tp, _Tp, _Tp> {
_Tp operator()(const _Tp &__x, const _Tp &__y) const { return __x | __y; }
};
template <typename _Tp>
struct bit_xor : public binary_function<_Tp, _Tp, _Tp> {
_Tp operator()(const _Tp &__x, const _Tp &__y) const { return __x ^ __y; }
};
template <typename _Tp> struct bit_not : public unary_function<_Tp, _Tp> {
_Tp operator()(const _Tp &__x) const { return ~__x; }
};
# 699 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_function.h" 3
template <typename _Predicate>
class unary_negate
: public unary_function<typename _Predicate::argument_type, bool> {
protected:
_Predicate _M_pred;
public:
explicit unary_negate(const _Predicate &__x) : _M_pred(__x) {}
bool operator()(const typename _Predicate::argument_type &__x) const {
return !_M_pred(__x);
}
};
template <typename _Predicate>
inline unary_negate<_Predicate> not1(const _Predicate & __pred) {
return unary_negate<_Predicate>(__pred);
}
template <typename _Predicate>
class binary_negate
: public binary_function<typename _Predicate::first_argument_type,
typename _Predicate::second_argument_type,
bool> {
protected:
_Predicate _M_pred;
public:
explicit binary_negate(const _Predicate &__x) : _M_pred(__x) {}
bool
operator()(const typename _Predicate::first_argument_type &__x,
const typename _Predicate::second_argument_type &__y) const {
return !_M_pred(__x, __y);
}
};
template <typename _Predicate>
inline binary_negate<_Predicate> not2(const _Predicate & __pred) {
return binary_negate<_Predicate>(__pred);
}
# 770 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_function.h" 3
template <typename _Arg, typename _Result>
class pointer_to_unary_function : public unary_function<_Arg, _Result> {
protected:
_Result (*_M_ptr)(_Arg);
public:
pointer_to_unary_function() {}
explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) {}
_Result operator()(_Arg __x) const { return _M_ptr(__x); }
};
template <typename _Arg, typename _Result>
inline pointer_to_unary_function<_Arg, _Result> ptr_fun(
_Result (*__x)(_Arg)) {
return pointer_to_unary_function<_Arg, _Result>(__x);
}
template <typename _Arg1, typename _Arg2, typename _Result>
class pointer_to_binary_function
: public binary_function<_Arg1, _Arg2, _Result> {
protected:
_Result (*_M_ptr)(_Arg1, _Arg2);
public:
pointer_to_binary_function() {}
explicit pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
: _M_ptr(__x) {}
_Result operator()(_Arg1 __x, _Arg2 __y) const { return _M_ptr(__x, __y); }
};
template <typename _Arg1, typename _Arg2, typename _Result>
inline pointer_to_binary_function<_Arg1, _Arg2, _Result> ptr_fun(
_Result (*__x)(_Arg1, _Arg2)) {
return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x);
}
template <typename _Tp> struct _Identity : public unary_function<_Tp, _Tp> {
_Tp &operator()(_Tp &__x) const { return __x; }
const _Tp &operator()(const _Tp &__x) const { return __x; }
};
template <typename _Pair>
struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> {
typename _Pair::first_type &operator()(_Pair &__x) const {
return __x.first;
}
const typename _Pair::first_type &operator()(const _Pair &__x) const {
return __x.first;
}
template <typename _Pair2>
typename _Pair2::first_type &operator()(_Pair2 &__x) const {
return __x.first;
}
template <typename _Pair2>
const typename _Pair2::first_type &operator()(const _Pair2 &__x) const {
return __x.first;
}
};
template <typename _Pair>
struct _Select2nd
: public unary_function<_Pair, typename _Pair::second_type> {
typename _Pair::second_type &operator()(_Pair &__x) const {
return __x.second;
}
const typename _Pair::second_type &operator()(const _Pair &__x) const {
return __x.second;
}
};
# 890 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_function.h" 3
template <typename _Ret, typename _Tp>
class mem_fun_t : public unary_function<_Tp *, _Ret> {
public:
explicit mem_fun_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
_Ret operator()(_Tp *__p) const { return (__p->*_M_f)(); }
private:
_Ret (_Tp::*_M_f)();
};
template <typename _Ret, typename _Tp>
class const_mem_fun_t : public unary_function<const _Tp *, _Ret> {
public:
explicit const_mem_fun_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
_Ret operator()(const _Tp *__p) const { return (__p->*_M_f)(); }
private:
_Ret (_Tp::*_M_f)() const;
};
template <typename _Ret, typename _Tp>
class mem_fun_ref_t : public unary_function<_Tp, _Ret> {
public:
explicit mem_fun_ref_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
_Ret operator()(_Tp &__r) const { return (__r.*_M_f)(); }
private:
_Ret (_Tp::*_M_f)();
};
template <typename _Ret, typename _Tp>
class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> {
public:
explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
_Ret operator()(const _Tp &__r) const { return (__r.*_M_f)(); }
private:
_Ret (_Tp::*_M_f)() const;
};
template <typename _Ret, typename _Tp, typename _Arg>
class mem_fun1_t : public binary_function<_Tp *, _Arg, _Ret> {
public:
explicit mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
_Ret operator()(_Tp *__p, _Arg __x) const { return (__p->*_M_f)(__x); }
private:
_Ret (_Tp::*_M_f)(_Arg);
};
template <typename _Ret, typename _Tp, typename _Arg>
class const_mem_fun1_t : public binary_function<const _Tp *, _Arg, _Ret> {
public:
explicit const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
_Ret operator()(const _Tp *__p, _Arg __x) const {
return (__p->*_M_f)(__x);
}
private:
_Ret (_Tp::*_M_f)(_Arg) const;
};
template <typename _Ret, typename _Tp, typename _Arg>
class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> {
public:
explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
_Ret operator()(_Tp &__r, _Arg __x) const { return (__r.*_M_f)(__x); }
private:
_Ret (_Tp::*_M_f)(_Arg);
};
template <typename _Ret, typename _Tp, typename _Arg>
class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> {
public:
explicit const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
_Ret operator()(const _Tp &__r, _Arg __x) const { return (__r.*_M_f)(__x); }
private:
_Ret (_Tp::*_M_f)(_Arg) const;
};
template <typename _Ret, typename _Tp>
inline mem_fun_t<_Ret, _Tp> mem_fun(_Ret (_Tp::*__f)()) {
return mem_fun_t<_Ret, _Tp>(__f);
}
template <typename _Ret, typename _Tp>
inline const_mem_fun_t<_Ret, _Tp> mem_fun(_Ret (_Tp::*__f)() const) {
return const_mem_fun_t<_Ret, _Tp>(__f);
}
template <typename _Ret, typename _Tp>
inline mem_fun_ref_t<_Ret, _Tp> mem_fun_ref(_Ret (_Tp::*__f)()) {
return mem_fun_ref_t<_Ret, _Tp>(__f);
}
template <typename _Ret, typename _Tp>
inline const_mem_fun_ref_t<_Ret, _Tp> mem_fun_ref(_Ret (_Tp::*__f)() const) {
return const_mem_fun_ref_t<_Ret, _Tp>(__f);
}
template <typename _Ret, typename _Tp, typename _Arg>
inline mem_fun1_t<_Ret, _Tp, _Arg> mem_fun(_Ret (_Tp::*__f)(_Arg)) {
return mem_fun1_t<_Ret, _Tp, _Arg>(__f);
}
template <typename _Ret, typename _Tp, typename _Arg>
inline const_mem_fun1_t<_Ret, _Tp, _Arg> mem_fun(
_Ret (_Tp::*__f)(_Arg) const) {
return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f);
}
template <typename _Ret, typename _Tp, typename _Arg>
inline mem_fun1_ref_t<_Ret, _Tp, _Arg> mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) {
return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f);
}
template <typename _Ret, typename _Tp, typename _Arg>
inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> mem_fun_ref(
_Ret (_Tp::*__f)(_Arg) const) {
return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f);
}
}
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/backward/binders.h" 1 3
# 59 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/backward/binders.h" 3
namespace std __attribute__((__visibility__("default"))) {
# 103 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/backward/binders.h" 3
template <typename _Operation>
class binder1st
: public unary_function<typename _Operation::second_argument_type,
typename _Operation::result_type> {
protected:
_Operation op;
typename _Operation::first_argument_type value;
public:
binder1st(const _Operation &__x,
const typename _Operation::first_argument_type &__y)
: op(__x), value(__y) {}
typename _Operation::result_type
operator()(const typename _Operation::second_argument_type &__x) const {
return op(value, __x);
}
typename _Operation::result_type
operator()(typename _Operation::second_argument_type &__x) const {
return op(value, __x);
}
} __attribute__((__deprecated__));
template <typename _Operation, typename _Tp>
inline binder1st<_Operation> bind1st(const _Operation & __fn,
const _Tp & __x) {
typedef typename _Operation::first_argument_type _Arg1_type;
return binder1st<_Operation>(__fn, _Arg1_type(__x));
}
template <typename _Operation>
class binder2nd
: public unary_function<typename _Operation::first_argument_type,
typename _Operation::result_type> {
protected:
_Operation op;
typename _Operation::second_argument_type value;
public:
binder2nd(const _Operation &__x,
const typename _Operation::second_argument_type &__y)
: op(__x), value(__y) {}
typename _Operation::result_type
operator()(const typename _Operation::first_argument_type &__x) const {
return op(__x, value);
}
typename _Operation::result_type
operator()(typename _Operation::first_argument_type &__x) const {
return op(__x, value);
}
} __attribute__((__deprecated__));
template <typename _Operation, typename _Tp>
inline binder2nd<_Operation> bind2nd(const _Operation & __fn,
const _Tp & __x) {
typedef typename _Operation::second_argument_type _Arg2_type;
return binder2nd<_Operation>(__fn, _Arg2_type(__x));
}
}
# 1081 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_function.h" 2 3
# 49 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/string" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/range_access.h" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/range_access.h" 3
namespace std __attribute__((__visibility__("default"))) {
template <class _Container>
inline auto begin(_Container & __cont)->decltype(__cont.begin()) {
return __cont.begin();
}
template <class _Container>
inline auto begin(const _Container & __cont)->decltype(__cont.begin()) {
return __cont.begin();
}
template <class _Container>
inline auto end(_Container & __cont)->decltype(__cont.end()) {
return __cont.end();
}
template <class _Container>
inline auto end(const _Container & __cont)->decltype(__cont.end()) {
return __cont.end();
}
template <class _Tp, size_t _Nm> inline _Tp *begin(_Tp(&__arr)[_Nm]) {
return __arr;
}
template <class _Tp, size_t _Nm> inline _Tp *end(_Tp(&__arr)[_Nm]) {
return __arr + _Nm;
}
}
# 52 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/string" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 1 3
# 38 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
namespace std __attribute__((__visibility__("default"))) {
# 111 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <typename _CharT, typename _Traits, typename _Alloc>
class basic_string {
typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
public:
typedef _Traits traits_type;
typedef typename _Traits::char_type value_type;
typedef _Alloc allocator_type;
typedef typename _CharT_alloc_type::size_type size_type;
typedef typename _CharT_alloc_type::difference_type difference_type;
typedef typename _CharT_alloc_type::reference reference;
typedef typename _CharT_alloc_type::const_reference const_reference;
typedef typename _CharT_alloc_type::pointer pointer;
typedef typename _CharT_alloc_type::const_pointer const_pointer;
typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
private:
# 148 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
struct _Rep_base {
size_type _M_length;
size_type _M_capacity;
_Atomic_word _M_refcount;
};
struct _Rep : _Rep_base {
typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
# 173 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
static const size_type _S_max_size;
static const _CharT _S_terminal;
static size_type _S_empty_rep_storage[];
static _Rep &_S_empty_rep() noexcept {
void *__p = reinterpret_cast<void *>(&_S_empty_rep_storage);
return *reinterpret_cast<_Rep *>(__p);
}
bool _M_is_leaked() const noexcept { return this->_M_refcount < 0; }
bool _M_is_shared() const noexcept { return this->_M_refcount > 0; }
void _M_set_leaked() noexcept { this->_M_refcount = -1; }
void _M_set_sharable() noexcept { this->_M_refcount = 0; }
void _M_set_length_and_sharable(size_type __n) noexcept {
if (__builtin_expect(this != &_S_empty_rep(), false)) {
this->_M_set_sharable();
this->_M_length = __n;
traits_type::assign(this->_M_refdata()[__n], _S_terminal);
}
}
_CharT *_M_refdata() throw() {
return reinterpret_cast<_CharT *>(this + 1);
}
_CharT *_M_grab(const _Alloc &__alloc1, const _Alloc &__alloc2) {
return (!_M_is_leaked() && __alloc1 == __alloc2) ? _M_refcopy()
: _M_clone(__alloc1);
}
static _Rep *_S_create(size_type, size_type, const _Alloc &);
void _M_dispose(const _Alloc &__a) noexcept {
if (__builtin_expect(this != &_S_empty_rep(), false)) {
;
if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, -1) <=
0) {
;
_M_destroy(__a);
}
}
}
void _M_destroy(const _Alloc &) throw();
_CharT *_M_refcopy() throw() {
if (__builtin_expect(this != &_S_empty_rep(), false))
__gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1);
return _M_refdata();
}
_CharT *_M_clone(const _Alloc &, size_type __res = 0);
};
struct _Alloc_hider : _Alloc {
_Alloc_hider(_CharT *__dat, const _Alloc &__a) noexcept : _Alloc(__a),
_M_p(__dat) {}
_CharT *_M_p;
};
public:
static const size_type npos = static_cast<size_type>(-1);
private:
mutable _Alloc_hider _M_dataplus;
_CharT *_M_data() const noexcept { return _M_dataplus._M_p; }
_CharT *_M_data(_CharT *__p) noexcept { return (_M_dataplus._M_p = __p); }
_Rep *_M_rep() const noexcept {
return &((reinterpret_cast<_Rep *>(_M_data()))[-1]);
}
iterator _M_ibegin() const noexcept { return iterator(_M_data()); }
iterator _M_iend() const noexcept {
return iterator(_M_data() + this->size());
}
void _M_leak() {
if (!_M_rep()->_M_is_leaked())
_M_leak_hard();
}
size_type _M_check(size_type __pos, const char *__s) const {
if (__pos > this->size())
__throw_out_of_range_fmt(("%s: __pos (which is %zu) > "
"this->size() (which is %zu)"),
__s, __pos, this->size());
return __pos;
}
void _M_check_length(size_type __n1, size_type __n2,
const char *__s) const {
if (this->max_size() - (this->size() - __n1) < __n2)
__throw_length_error((__s));
}
size_type _M_limit(size_type __pos, size_type __off) const noexcept {
const bool __testoff = __off < this->size() - __pos;
return __testoff ? __off : this->size() - __pos;
}
bool _M_disjunct(const _CharT *__s) const noexcept {
return (less<const _CharT *>()(__s, _M_data()) ||
less<const _CharT *>()(_M_data() + this->size(), __s));
}
static void _M_copy(_CharT *__d, const _CharT *__s,
size_type __n) noexcept {
if (__n == 1)
traits_type::assign(*__d, *__s);
else
traits_type::copy(__d, __s, __n);
}
static void _M_move(_CharT *__d, const _CharT *__s,
size_type __n) noexcept {
if (__n == 1)
traits_type::assign(*__d, *__s);
else
traits_type::move(__d, __s, __n);
}
static void _M_assign(_CharT *__d, size_type __n, _CharT __c) noexcept {
if (__n == 1)
traits_type::assign(*__d, __c);
else
traits_type::assign(__d, __n, __c);
}
template <class _Iterator>
static void _S_copy_chars(_CharT *__p, _Iterator __k1,
_Iterator __k2) noexcept {
for (; __k1 != __k2; ++__k1, ++__p)
traits_type::assign(*__p, *__k1);
}
static void _S_copy_chars(_CharT *__p, iterator __k1,
iterator __k2) noexcept {
_S_copy_chars(__p, __k1.base(), __k2.base());
}
static void _S_copy_chars(_CharT *__p, const_iterator __k1,
const_iterator __k2) noexcept {
_S_copy_chars(__p, __k1.base(), __k2.base());
}
static void _S_copy_chars(_CharT *__p, _CharT *__k1,
_CharT *__k2) noexcept {
_M_copy(__p, __k1, __k2 - __k1);
}
static void _S_copy_chars(_CharT *__p, const _CharT *__k1,
const _CharT *__k2) noexcept {
_M_copy(__p, __k1, __k2 - __k1);
}
static int _S_compare(size_type __n1, size_type __n2) noexcept {
const difference_type __d = difference_type(__n1 - __n2);
if (__d > __gnu_cxx::__numeric_traits<int>::__max)
return __gnu_cxx::__numeric_traits<int>::__max;
else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
return __gnu_cxx::__numeric_traits<int>::__min;
else
return int(__d);
}
void _M_mutate(size_type __pos, size_type __len1, size_type __len2);
void _M_leak_hard();
static _Rep &_S_empty_rep() noexcept { return _Rep::_S_empty_rep(); }
public:
basic_string() : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) {}
explicit basic_string(const _Alloc &__a);
basic_string(const basic_string &__str);
basic_string(const basic_string &__str, size_type __pos,
size_type __n = npos);
basic_string(const basic_string &__str, size_type __pos, size_type __n,
const _Alloc &__a);
# 488 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string(const _CharT *__s, size_type __n,
const _Alloc &__a = _Alloc());
basic_string(const _CharT *__s, const _Alloc &__a = _Alloc());
basic_string(size_type __n, _CharT __c, const _Alloc &__a = _Alloc());
# 512 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string(basic_string &&__str)
noexcept : _M_dataplus(__str._M_dataplus) {
__str._M_data(_S_empty_rep()._M_refdata());
}
basic_string(initializer_list<_CharT> __l, const _Alloc &__a = _Alloc());
# 539 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <class _InputIterator>
basic_string(_InputIterator __beg, _InputIterator __end,
const _Alloc &__a = _Alloc());
~basic_string() noexcept { _M_rep()->_M_dispose(this->get_allocator()); }
basic_string &operator=(const basic_string &__str) {
return this->assign(__str);
}
basic_string &operator=(const _CharT *__s) { return this->assign(__s); }
# 572 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &operator=(_CharT __c) {
this->assign(1, __c);
return *this;
}
# 588 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &operator=(basic_string &&__str) {
this->swap(__str);
return *this;
}
basic_string &operator=(initializer_list<_CharT> __l) {
this->assign(__l.begin(), __l.size());
return *this;
}
iterator begin() {
_M_leak();
return iterator(_M_data());
}
const_iterator begin() const noexcept { return const_iterator(_M_data()); }
iterator end() {
_M_leak();
return iterator(_M_data() + this->size());
}
const_iterator end() const noexcept {
return const_iterator(_M_data() + this->size());
}
reverse_iterator rbegin() { return reverse_iterator(this->end()); }
const_reverse_iterator rbegin() const noexcept {
return const_reverse_iterator(this->end());
}
reverse_iterator rend() { return reverse_iterator(this->begin()); }
const_reverse_iterator rend() const noexcept {
return const_reverse_iterator(this->begin());
}
const_iterator cbegin() const noexcept {
return const_iterator(this->_M_data());
}
const_iterator cend() const noexcept {
return const_iterator(this->_M_data() + this->size());
}
const_reverse_iterator crbegin() const noexcept {
return const_reverse_iterator(this->end());
}
const_reverse_iterator crend() const noexcept {
return const_reverse_iterator(this->begin());
}
public:
size_type size() const noexcept { return _M_rep()->_M_length; }
size_type length() const noexcept { return _M_rep()->_M_length; }
size_type max_size() const noexcept { return _Rep::_S_max_size; }
# 748 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
void resize(size_type __n, _CharT __c);
# 761 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
void resize(size_type __n) { this->resize(__n, _CharT()); }
void shrink_to_fit() noexcept {
if (capacity() > size()) {
try {
reserve(0);
}
catch (...) {
}
}
}
size_type capacity() const noexcept { return _M_rep()->_M_capacity; }
# 805 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
void reserve(size_type __res_arg = 0);
void clear() { _M_mutate(0, this->size(), 0); }
bool empty() const noexcept { return this->size() == 0; }
# 835 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
const_reference operator[](size_type __pos) const noexcept {
;
return _M_data()[__pos];
}
# 852 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
reference operator[](size_type __pos) {
;
;
_M_leak();
return _M_data()[__pos];
}
# 874 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
const_reference at(size_type __n) const {
if (__n >= this->size())
__throw_out_of_range_fmt(("basic_string::at: __n "
"(which is %zu) >= this->size() "
"(which is %zu)"),
__n, this->size());
return _M_data()[__n];
}
# 896 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
reference at(size_type __n) {
if (__n >= size())
__throw_out_of_range_fmt(("basic_string::at: __n "
"(which is %zu) >= this->size() "
"(which is %zu)"),
__n, this->size());
_M_leak();
return _M_data()[__n];
}
reference front() { return operator[](0); }
const_reference front() const noexcept { return operator[](0); }
reference back() { return operator[](this->size() - 1); }
const_reference back() const noexcept {
return operator[](this->size() - 1);
}
# 948 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &operator+=(const basic_string &__str) {
return this->append(__str);
}
basic_string &operator+=(const _CharT *__s) { return this->append(__s); }
basic_string &operator+=(_CharT __c) {
this->push_back(__c);
return *this;
}
basic_string &operator+=(initializer_list<_CharT> __l) {
return this->append(__l.begin(), __l.size());
}
basic_string &append(const basic_string &__str);
# 1005 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &append(const basic_string &__str, size_type __pos,
size_type __n);
basic_string &append(const _CharT *__s, size_type __n);
basic_string &append(const _CharT *__s) {
;
return this->append(__s, traits_type::length(__s));
}
# 1037 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &append(size_type __n, _CharT __c);
basic_string &append(initializer_list<_CharT> __l) {
return this->append(__l.begin(), __l.size());
}
# 1059 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <class _InputIterator>
basic_string &append(_InputIterator __first, _InputIterator __last) {
return this->replace(_M_iend(), _M_iend(), __first, __last);
}
void push_back(_CharT __c) {
const size_type __len = 1 + this->size();
if (__len > this->capacity() || _M_rep()->_M_is_shared())
this->reserve(__len);
traits_type::assign(_M_data()[this->size()], __c);
_M_rep()->_M_set_length_and_sharable(__len);
}
basic_string &assign(const basic_string &__str);
# 1096 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &assign(basic_string &&__str) {
this->swap(__str);
return *this;
}
# 1117 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &assign(const basic_string &__str, size_type __pos,
size_type __n) {
return this->assign(__str._M_data() +
__str._M_check(__pos, "basic_string::assign"),
__str._M_limit(__pos, __n));
}
# 1133 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &assign(const _CharT *__s, size_type __n);
# 1145 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &assign(const _CharT *__s) {
;
return this->assign(__s, traits_type::length(__s));
}
# 1161 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &assign(size_type __n, _CharT __c) {
return _M_replace_aux(size_type(0), this->size(), __n, __c);
}
# 1173 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <class _InputIterator>
basic_string &assign(_InputIterator __first, _InputIterator __last) {
return this->replace(_M_ibegin(), _M_iend(), __first, __last);
}
basic_string &assign(initializer_list<_CharT> __l) {
return this->assign(__l.begin(), __l.size());
}
# 1202 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
void insert(iterator __p, size_type __n, _CharT __c) {
this->replace(__p, __p, __n, __c);
}
# 1218 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <class _InputIterator>
void insert(iterator __p, _InputIterator __beg, _InputIterator __end) {
this->replace(__p, __p, __beg, __end);
}
# 1230 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
void insert(iterator __p, initializer_list<_CharT> __l) {
;
this->insert(__p - _M_ibegin(), __l.begin(), __l.size());
}
# 1250 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &insert(size_type __pos1, const basic_string &__str) {
return this->insert(__pos1, __str, size_type(0), __str.size());
}
# 1272 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &insert(size_type __pos1, const basic_string &__str,
size_type __pos2, size_type __n) {
return this->insert(__pos1,
__str._M_data() +
__str._M_check(__pos2, "basic_string::insert"),
__str._M_limit(__pos2, __n));
}
# 1295 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &insert(size_type __pos, const _CharT *__s, size_type __n);
# 1313 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &insert(size_type __pos, const _CharT *__s) {
;
return this->insert(__pos, __s, traits_type::length(__s));
}
# 1336 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &insert(size_type __pos, size_type __n, _CharT __c) {
return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
size_type(0), __n, __c);
}
# 1354 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
iterator insert(iterator __p, _CharT __c) {
;
const size_type __pos = __p - _M_ibegin();
_M_replace_aux(__pos, size_type(0), size_type(1), __c);
_M_rep()->_M_set_leaked();
return iterator(_M_data() + __pos);
}
# 1379 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &erase(size_type __pos = 0, size_type __n = npos) {
_M_mutate(_M_check(__pos, "basic_string::erase"), _M_limit(__pos, __n),
size_type(0));
return *this;
}
# 1395 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
iterator erase(iterator __position) {
;
const size_type __pos = __position - _M_ibegin();
_M_mutate(__pos, size_type(1), size_type(0));
_M_rep()->_M_set_leaked();
return iterator(_M_data() + __pos);
}
# 1415 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
iterator erase(iterator __first, iterator __last);
void pop_back() { erase(size() - 1, 1); }
# 1446 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &replace(size_type __pos, size_type __n,
const basic_string &__str) {
return this->replace(__pos, __n, __str._M_data(), __str.size());
}
# 1468 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &replace(size_type __pos1, size_type __n1,
const basic_string &__str, size_type __pos2,
size_type __n2) {
return this->replace(__pos1, __n1,
__str._M_data() +
__str._M_check(__pos2, "basic_string::replace"),
__str._M_limit(__pos2, __n2));
}
# 1493 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &replace(size_type __pos, size_type __n1, const _CharT *__s,
size_type __n2);
# 1513 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &replace(size_type __pos, size_type __n1, const _CharT *__s) {
;
return this->replace(__pos, __n1, __s, traits_type::length(__s));
}
# 1537 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &replace(size_type __pos, size_type __n1, size_type __n2,
_CharT __c) {
return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
_M_limit(__pos, __n1), __n2, __c);
}
# 1555 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &replace(iterator __i1, iterator __i2,
const basic_string &__str) {
return this->replace(__i1, __i2, __str._M_data(), __str.size());
}
# 1574 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &replace(iterator __i1, iterator __i2, const _CharT *__s,
size_type __n) {
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
}
# 1595 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &replace(iterator __i1, iterator __i2, const _CharT *__s) {
;
return this->replace(__i1, __i2, __s, traits_type::length(__s));
}
# 1616 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &replace(iterator __i1, iterator __i2, size_type __n,
_CharT __c) {
;
return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
}
# 1639 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <class _InputIterator>
basic_string &replace(iterator __i1, iterator __i2, _InputIterator __k1,
_InputIterator __k2) {
;
;
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
}
basic_string &replace(iterator __i1, iterator __i2, _CharT *__k1,
_CharT *__k2) {
;
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __k1, __k2 - __k1);
}
basic_string &replace(iterator __i1, iterator __i2, const _CharT *__k1,
const _CharT *__k2) {
;
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __k1, __k2 - __k1);
}
basic_string &replace(iterator __i1, iterator __i2, iterator __k1,
iterator __k2) {
;
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __k1.base(),
__k2 - __k1);
}
basic_string &replace(iterator __i1, iterator __i2, const_iterator __k1,
const_iterator __k2) {
;
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __k1.base(),
__k2 - __k1);
}
# 1710 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string &replace(iterator __i1, iterator __i2,
initializer_list<_CharT> __l) {
return this->replace(__i1, __i2, __l.begin(), __l.end());
}
private:
template <class _Integer>
basic_string &_M_replace_dispatch(iterator __i1, iterator __i2,
_Integer __n, _Integer __val,
__true_type) {
return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val);
}
template <class _InputIterator>
basic_string &_M_replace_dispatch(iterator __i1, iterator __i2,
_InputIterator __k1, _InputIterator __k2,
__false_type);
basic_string &_M_replace_aux(size_type __pos1, size_type __n1,
size_type __n2, _CharT __c);
basic_string &_M_replace_safe(size_type __pos1, size_type __n1,
const _CharT *__s, size_type __n2);
template <class _InIterator>
static _CharT *_S_construct_aux(_InIterator __beg, _InIterator __end,
const _Alloc &__a, __false_type) {
typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
return _S_construct(__beg, __end, __a, _Tag());
}
template <class _Integer>
static _CharT *_S_construct_aux(_Integer __beg, _Integer __end,
const _Alloc &__a, __true_type) {
return _S_construct_aux_2(static_cast<size_type>(__beg), __end, __a);
}
static _CharT *_S_construct_aux_2(size_type __req, _CharT __c,
const _Alloc &__a) {
return _S_construct(__req, __c, __a);
}
template <class _InIterator>
static _CharT *_S_construct(_InIterator __beg, _InIterator __end,
const _Alloc &__a) {
typedef typename std::__is_integer<_InIterator>::__type _Integral;
return _S_construct_aux(__beg, __end, __a, _Integral());
}
template <class _InIterator>
static _CharT *_S_construct(_InIterator __beg, _InIterator __end,
const _Alloc &__a, input_iterator_tag);
template <class _FwdIterator>
static _CharT *_S_construct(_FwdIterator __beg, _FwdIterator __end,
const _Alloc &__a, forward_iterator_tag);
static _CharT *_S_construct(size_type __req, _CharT __c, const _Alloc &__a);
public:
# 1797 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type copy(_CharT *__s, size_type __n, size_type __pos = 0) const;
# 1808 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
void swap(basic_string &__s);
# 1818 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
const _CharT *c_str() const noexcept { return _M_data(); }
const _CharT *data() const noexcept { return _M_data(); }
allocator_type get_allocator() const noexcept { return _M_dataplus; }
# 1851 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find(const _CharT *__s, size_type __pos, size_type __n) const;
# 1864 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find(const basic_string &__str, size_type __pos = 0) const
noexcept {
return this->find(__str.data(), __pos, __str.size());
}
# 1879 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find(const _CharT *__s, size_type __pos = 0) const {
;
return this->find(__s, __pos, traits_type::length(__s));
}
# 1896 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find(_CharT __c, size_type __pos = 0) const noexcept;
# 1909 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type rfind(const basic_string &__str, size_type __pos = npos) const
noexcept {
return this->rfind(__str.data(), __pos, __str.size());
}
# 1926 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type rfind(const _CharT *__s, size_type __pos, size_type __n) const;
# 1939 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type rfind(const _CharT *__s, size_type __pos = npos) const {
;
return this->rfind(__s, __pos, traits_type::length(__s));
}
# 1956 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type rfind(_CharT __c, size_type __pos = npos) const noexcept;
# 1970 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find_first_of(const basic_string &__str,
size_type __pos = 0) const noexcept {
return this->find_first_of(__str.data(), __pos, __str.size());
}
# 1987 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find_first_of(const _CharT *__s, size_type __pos,
size_type __n) const;
# 2000 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find_first_of(const _CharT *__s, size_type __pos = 0) const {
;
return this->find_first_of(__s, __pos, traits_type::length(__s));
}
# 2019 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find_first_of(_CharT __c, size_type __pos = 0) const noexcept {
return this->find(__c, __pos);
}
# 2034 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find_last_of(const basic_string &__str,
size_type __pos = npos) const noexcept {
return this->find_last_of(__str.data(), __pos, __str.size());
}
# 2051 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find_last_of(const _CharT *__s, size_type __pos,
size_type __n) const;
# 2064 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find_last_of(const _CharT *__s, size_type __pos = npos) const {
;
return this->find_last_of(__s, __pos, traits_type::length(__s));
}
# 2083 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find_last_of(_CharT __c, size_type __pos = npos) const noexcept {
return this->rfind(__c, __pos);
}
# 2097 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find_first_not_of(const basic_string &__str,
size_type __pos = 0) const noexcept {
return this->find_first_not_of(__str.data(), __pos, __str.size());
}
# 2114 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find_first_not_of(const _CharT *__s, size_type __pos,
size_type __n) const;
# 2128 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find_first_not_of(const _CharT *__s, size_type __pos = 0) const {
;
return this->find_first_not_of(__s, __pos, traits_type::length(__s));
}
# 2145 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept;
# 2160 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find_last_not_of(const basic_string &__str,
size_type __pos = npos) const noexcept {
return this->find_last_not_of(__str.data(), __pos, __str.size());
}
# 2177 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find_last_not_of(const _CharT *__s, size_type __pos,
size_type __n) const;
# 2191 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find_last_not_of(const _CharT *__s,
size_type __pos = npos) const {
;
return this->find_last_not_of(__s, __pos, traits_type::length(__s));
}
# 2208 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
size_type find_last_not_of(_CharT __c, size_type __pos = npos) const
noexcept;
# 2224 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
basic_string substr(size_type __pos = 0, size_type __n = npos) const {
return basic_string(*this, _M_check(__pos, "basic_string::substr"), __n);
}
# 2243 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
int compare(const basic_string &__str) const {
const size_type __size = this->size();
const size_type __osize = __str.size();
const size_type __len = std::min(__size, __osize);
int __r = traits_type::compare(_M_data(), __str.data(), __len);
if (!__r)
__r = _S_compare(__size, __osize);
return __r;
}
# 2275 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
int compare(size_type __pos, size_type __n,
const basic_string &__str) const;
# 2301 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
int compare(size_type __pos1, size_type __n1, const basic_string &__str,
size_type __pos2, size_type __n2) const;
# 2319 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
int compare(const _CharT *__s) const;
# 2343 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
int compare(size_type __pos, size_type __n1, const _CharT *__s) const;
# 2370 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
int compare(size_type __pos, size_type __n1, const _CharT *__s,
size_type __n2) const;
};
# 2382 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc> operator+(
const basic_string<_CharT, _Traits, _Alloc> & __lhs,
const basic_string<_CharT, _Traits, _Alloc> & __rhs) {
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
__str.append(__rhs);
return __str;
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc> operator+(
const _CharT * __lhs,
const basic_string<_CharT, _Traits, _Alloc> & __rhs);
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc> operator+(
_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc> & __rhs);
template <typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc> operator+(
const basic_string<_CharT, _Traits, _Alloc> & __lhs,
const _CharT * __rhs) {
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
__str.append(__rhs);
return __str;
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc> operator+(
const basic_string<_CharT, _Traits, _Alloc> & __lhs, _CharT __rhs) {
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
__string_type __str(__lhs);
__str.append(__size_type(1), __rhs);
return __str;
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc> operator+(
basic_string<_CharT, _Traits, _Alloc> && __lhs,
const basic_string<_CharT, _Traits, _Alloc> & __rhs) {
return std::move(__lhs.append(__rhs));
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc> operator+(
const basic_string<_CharT, _Traits, _Alloc> & __lhs,
basic_string<_CharT, _Traits, _Alloc> && __rhs) {
return std::move(__rhs.insert(0, __lhs));
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc> operator+(
basic_string<_CharT, _Traits, _Alloc> && __lhs,
basic_string<_CharT, _Traits, _Alloc> && __rhs) {
const auto __size = __lhs.size() + __rhs.size();
const bool __cond =
(__size > __lhs.capacity() && __size <= __rhs.capacity());
return __cond ? std::move(__rhs.insert(0, __lhs))
: std::move(__lhs.append(__rhs));
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc> operator+(
const _CharT * __lhs, basic_string<_CharT, _Traits, _Alloc> && __rhs) {
return std::move(__rhs.insert(0, __lhs));
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc> operator+(
_CharT __lhs, basic_string<_CharT, _Traits, _Alloc> && __rhs) {
return std::move(__rhs.insert(0, 1, __lhs));
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc> operator+(
basic_string<_CharT, _Traits, _Alloc> && __lhs, const _CharT * __rhs) {
return std::move(__lhs.append(__rhs));
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc> operator+(
basic_string<_CharT, _Traits, _Alloc> && __lhs, _CharT __rhs) {
return std::move(__lhs.append(1, __rhs));
}
# 2503 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator==(const basic_string<_CharT, _Traits, _Alloc> & __lhs,
const basic_string<_CharT, _Traits, _Alloc> & __rhs) {
return __lhs.compare(__rhs) == 0;
}
template <typename _CharT>
inline typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
bool>::__type
operator==(const basic_string<_CharT> & __lhs,
const basic_string<_CharT> & __rhs) {
return (__lhs.size() == __rhs.size() &&
!std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
__lhs.size()));
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator==(const _CharT * __lhs,
const basic_string<_CharT, _Traits, _Alloc> & __rhs) {
return __rhs.compare(__lhs) == 0;
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator==(const basic_string<_CharT, _Traits, _Alloc> & __lhs,
const _CharT * __rhs) {
return __lhs.compare(__rhs) == 0;
}
# 2549 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator!=(const basic_string<_CharT, _Traits, _Alloc> & __lhs,
const basic_string<_CharT, _Traits, _Alloc> & __rhs) {
return !(__lhs == __rhs);
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator!=(const _CharT * __lhs,
const basic_string<_CharT, _Traits, _Alloc> & __rhs) {
return !(__lhs == __rhs);
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator!=(const basic_string<_CharT, _Traits, _Alloc> & __lhs,
const _CharT * __rhs) {
return !(__lhs == __rhs);
}
# 2586 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator<(const basic_string<_CharT, _Traits, _Alloc> & __lhs,
const basic_string<_CharT, _Traits, _Alloc> & __rhs) {
return __lhs.compare(__rhs) < 0;
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator<(const basic_string<_CharT, _Traits, _Alloc> & __lhs,
const _CharT * __rhs) {
return __lhs.compare(__rhs) < 0;
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator<(const _CharT * __lhs,
const basic_string<_CharT, _Traits, _Alloc> & __rhs) {
return __rhs.compare(__lhs) > 0;
}
# 2623 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator>(const basic_string<_CharT, _Traits, _Alloc> & __lhs,
const basic_string<_CharT, _Traits, _Alloc> & __rhs) {
return __lhs.compare(__rhs) > 0;
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator>(const basic_string<_CharT, _Traits, _Alloc> & __lhs,
const _CharT * __rhs) {
return __lhs.compare(__rhs) > 0;
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator>(const _CharT * __lhs,
const basic_string<_CharT, _Traits, _Alloc> & __rhs) {
return __rhs.compare(__lhs) < 0;
}
# 2660 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator<=(const basic_string<_CharT, _Traits, _Alloc> & __lhs,
const basic_string<_CharT, _Traits, _Alloc> & __rhs) {
return __lhs.compare(__rhs) <= 0;
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator<=(const basic_string<_CharT, _Traits, _Alloc> & __lhs,
const _CharT * __rhs) {
return __lhs.compare(__rhs) <= 0;
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator<=(const _CharT * __lhs,
const basic_string<_CharT, _Traits, _Alloc> & __rhs) {
return __rhs.compare(__lhs) >= 0;
}
# 2697 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator>=(const basic_string<_CharT, _Traits, _Alloc> & __lhs,
const basic_string<_CharT, _Traits, _Alloc> & __rhs) {
return __lhs.compare(__rhs) >= 0;
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator>=(const basic_string<_CharT, _Traits, _Alloc> & __lhs,
const _CharT * __rhs) {
return __lhs.compare(__rhs) >= 0;
}
template <typename _CharT, typename _Traits, typename _Alloc>
inline bool operator>=(const _CharT * __lhs,
const basic_string<_CharT, _Traits, _Alloc> & __rhs) {
return __rhs.compare(__lhs) <= 0;
}
# 2734 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <typename _CharT, typename _Traits, typename _Alloc>
inline void swap(basic_string<_CharT, _Traits, _Alloc> & __lhs,
basic_string<_CharT, _Traits, _Alloc> & __rhs) {
__lhs.swap(__rhs);
}
# 2752 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits> &operator>>(
basic_istream<_CharT, _Traits> & __is,
basic_string<_CharT, _Traits, _Alloc> & __str);
template <>
basic_istream<char> &operator>>(basic_istream<char> & __is,
basic_string<char> & __str);
# 2770 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <typename _CharT, typename _Traits, typename _Alloc>
inline basic_ostream<_CharT, _Traits> &operator<<(
basic_ostream<_CharT, _Traits> & __os,
const basic_string<_CharT, _Traits, _Alloc> & __str) {
return __ostream_insert(__os, __str.data(), __str.size());
}
# 2793 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits> &getline(
basic_istream<_CharT, _Traits> & __is,
basic_string<_CharT, _Traits, _Alloc> & __str, _CharT __delim);
# 2810 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
template <typename _CharT, typename _Traits, typename _Alloc>
inline basic_istream<_CharT, _Traits> &getline(
basic_istream<_CharT, _Traits> & __is,
basic_string<_CharT, _Traits, _Alloc> & __str) {
return getline(__is, __str, __is.widen('\n'));
}
template <>
basic_istream<char> &getline(basic_istream<char> & __in,
basic_string<char> & __str, char __delim);
template <>
basic_istream<wchar_t> &getline(basic_istream<wchar_t> & __in,
basic_string<wchar_t> & __str,
wchar_t __delim);
}
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/string_conversions.h" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/string_conversions.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cstdlib" 1 3
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cstdlib" 3
# 114 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cstdlib" 3
namespace std __attribute__((__visibility__("default"))) {
using ::div_t;
using ::ldiv_t;
using ::abort;
using ::abs;
using ::atexit;
using ::atof;
using ::atoi;
using ::atol;
using ::bsearch;
using ::calloc;
using ::div;
using ::exit;
using ::free;
using ::getenv;
using ::labs;
using ::ldiv;
using ::malloc;
using ::mblen;
using ::mbstowcs;
using ::mbtowc;
using ::qsort;
using ::rand;
using ::realloc;
using ::srand;
using ::strtod;
using ::strtol;
using ::strtoul;
using ::system;
using ::wcstombs;
using ::wctomb;
inline long abs(long __i) { return __builtin_labs(__i); }
inline ldiv_t div(long __i, long __j) { return ldiv(__i, __j); }
inline long long abs(long long __x) { return __builtin_llabs(__x); }
# 183 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cstdlib" 3
}
# 196 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cstdlib" 3
namespace __gnu_cxx __attribute__((__visibility__("default"))) {
using ::lldiv_t;
using ::_Exit;
using ::llabs;
inline lldiv_t div(long long __n, long long __d) {
lldiv_t __q;
__q.quot = __n / __d;
__q.rem = __n % __d;
return __q;
}
using ::lldiv;
# 228 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cstdlib" 3
using ::atoll;
using ::strtoll;
using ::strtoull;
using ::strtof;
using ::strtold;
}
namespace std {
using ::__gnu_cxx::lldiv_t;
using ::__gnu_cxx::_Exit;
using ::__gnu_cxx::llabs;
using ::__gnu_cxx::div;
using ::__gnu_cxx::lldiv;
using ::__gnu_cxx::atoll;
using ::__gnu_cxx::strtof;
using ::__gnu_cxx::strtoll;
using ::__gnu_cxx::strtoull;
using ::__gnu_cxx::strtold;
}
# 42 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/string_conversions.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cwchar" 1 3
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cwchar" 3
# 43 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/string_conversions.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cstdio" 1 3
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cstdio" 3
# 96 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cstdio" 3
namespace std {
using ::FILE;
using ::fpos_t;
using ::clearerr;
using ::fclose;
using ::feof;
using ::ferror;
using ::fflush;
using ::fgetc;
using ::fgetpos;
using ::fgets;
using ::fopen;
using ::fprintf;
using ::fputc;
using ::fputs;
using ::fread;
using ::freopen;
using ::fscanf;
using ::fseek;
using ::fsetpos;
using ::ftell;
using ::fwrite;
using ::getc;
using ::getchar;
using ::gets;
using ::perror;
using ::printf;
using ::putc;
using ::putchar;
using ::puts;
using ::remove;
using ::rename;
using ::rewind;
using ::scanf;
using ::setbuf;
using ::setvbuf;
using ::sprintf;
using ::sscanf;
using ::tmpfile;
using ::tmpnam;
using ::ungetc;
using ::vfprintf;
using ::vprintf;
using ::vsprintf;
}
# 157 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cstdio" 3
namespace __gnu_cxx {
# 175 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cstdio" 3
using ::snprintf;
using ::vfscanf;
using ::vscanf;
using ::vsnprintf;
using ::vsscanf;
}
namespace std {
using ::__gnu_cxx::snprintf;
using ::__gnu_cxx::vfscanf;
using ::__gnu_cxx::vscanf;
using ::__gnu_cxx::vsnprintf;
using ::__gnu_cxx::vsscanf;
}
# 44 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/string_conversions.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cerrno" 1 3
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cerrno" 3
# 1 "/usr/include/errno.h" 1 3 4
# 23 "/usr/include/errno.h" 3 4
# 1 "/usr/include/sys/errno.h" 1 3 4
# 79 "/usr/include/sys/errno.h" 3 4
extern "C" { extern int *__error(void); }
# 24 "/usr/include/errno.h" 2 3 4
# 42 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cerrno" 2 3
# 45 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/string_conversions.h" 2 3
namespace __gnu_cxx __attribute__((__visibility__("default"))) {
template <typename _TRet, typename _Ret = _TRet, typename _CharT,
typename... _Base>
_Ret __stoa(_TRet (*__convf)(const _CharT *, _CharT **, _Base...),
const char * __name, const _CharT * __str, std::size_t * __idx,
_Base... __base) {
_Ret __ret;
_CharT *__endptr;
(*__error()) = 0;
const _TRet __tmp = __convf(__str, &__endptr, __base...);
if (__endptr == __str)
std::__throw_invalid_argument(__name);
else if ((*__error()) == 34 || (std::__are_same<_Ret, int>::__value &&
(__tmp < __numeric_traits<int>::__min ||
__tmp > __numeric_traits<int>::__max)))
std::__throw_out_of_range(__name);
else
__ret = __tmp;
if (__idx)
*__idx = __endptr - __str;
return __ret;
}
template <typename _String, typename _CharT = typename _String::value_type>
_String __to_xstring(
int (*__convf)(_CharT *, std::size_t, const _CharT *, __builtin_va_list),
std::size_t __n, const _CharT * __fmt, ...) {
_CharT *__s = static_cast<_CharT *>(__builtin_alloca(sizeof(_CharT) * __n));
__builtin_va_list __args;
__builtin_va_start(__args, __fmt);
const int __len = __convf(__s, __n, __fmt, __args);
__builtin_va_end(__args);
return _String(__s, __s + __len);
}
}
# 2835 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
inline int stoi(const string & __str, size_t *__idx = 0, int __base = 10) {
return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
__idx, __base);
}
inline long stol(const string & __str, size_t *__idx = 0, int __base = 10) {
return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(), __idx,
__base);
}
inline unsigned long stoul(const string & __str, size_t *__idx = 0,
int __base = 10) {
return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(), __idx,
__base);
}
inline long long stoll(const string & __str, size_t *__idx = 0,
int __base = 10) {
return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(), __idx,
__base);
}
inline unsigned long long stoull(const string & __str, size_t *__idx = 0,
int __base = 10) {
return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(), __idx,
__base);
}
inline float stof(const string & __str, size_t *__idx = 0) {
return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx);
}
inline double stod(const string & __str, size_t *__idx = 0) {
return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx);
}
inline long double stold(const string & __str, size_t *__idx = 0) {
return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx);
}
inline string to_string(int __val) {
return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(int),
"%d", __val);
}
inline string to_string(unsigned __val) {
return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
4 * sizeof(unsigned), "%u", __val);
}
inline string to_string(long __val) {
return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(long),
"%ld", __val);
}
inline string to_string(unsigned long __val) {
return __gnu_cxx::__to_xstring<string>(
&std::vsnprintf, 4 * sizeof(unsigned long), "%lu", __val);
}
inline string to_string(long long __val) {
return __gnu_cxx::__to_xstring<string>(
&std::vsnprintf, 4 * sizeof(long long), "%lld", __val);
}
inline string to_string(unsigned long long __val) {
return __gnu_cxx::__to_xstring<string>(
&std::vsnprintf, 4 * sizeof(unsigned long long), "%llu", __val);
}
inline string to_string(float __val) {
const int __n = __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n, "%f", __val);
}
inline string to_string(double __val) {
const int __n = __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n, "%f", __val);
}
inline string to_string(long double __val) {
const int __n =
__gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n, "%Lf", __val);
}
inline int stoi(const wstring & __str, size_t *__idx = 0, int __base = 10) {
return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
__idx, __base);
}
inline long stol(const wstring & __str, size_t *__idx = 0, int __base = 10) {
return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(), __idx,
__base);
}
inline unsigned long stoul(const wstring & __str, size_t *__idx = 0,
int __base = 10) {
return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(), __idx,
__base);
}
inline long long stoll(const wstring & __str, size_t *__idx = 0,
int __base = 10) {
return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(), __idx,
__base);
}
inline unsigned long long stoull(const wstring & __str, size_t *__idx = 0,
int __base = 10) {
return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(), __idx,
__base);
}
inline float stof(const wstring & __str, size_t *__idx = 0) {
return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx);
}
inline double stod(const wstring & __str, size_t *__idx = 0) {
return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx);
}
inline long double stold(const wstring & __str, size_t *__idx = 0) {
return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx);
}
inline wstring to_wstring(int __val) {
return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int),
L"%d", __val);
}
inline wstring to_wstring(unsigned __val) {
return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
4 * sizeof(unsigned), L"%u", __val);
}
inline wstring to_wstring(long __val) {
return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long),
L"%ld", __val);
}
inline wstring to_wstring(unsigned long __val) {
return __gnu_cxx::__to_xstring<wstring>(
&std::vswprintf, 4 * sizeof(unsigned long), L"%lu", __val);
}
inline wstring to_wstring(long long __val) {
return __gnu_cxx::__to_xstring<wstring>(
&std::vswprintf, 4 * sizeof(long long), L"%lld", __val);
}
inline wstring to_wstring(unsigned long long __val) {
return __gnu_cxx::__to_xstring<wstring>(
&std::vswprintf, 4 * sizeof(unsigned long long), L"%llu", __val);
}
inline wstring to_wstring(float __val) {
const int __n = __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n, L"%f", __val);
}
inline wstring to_wstring(double __val) {
const int __n = __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n, L"%f", __val);
}
inline wstring to_wstring(long double __val) {
const int __n =
__gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n, L"%Lf",
__val);
}
}
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/functional_hash.h" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/functional_hash.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/hash_bytes.h" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/hash_bytes.h" 3
namespace std {
size_t _Hash_bytes(const void *__ptr, size_t __len, size_t __seed);
size_t _Fnv_hash_bytes(const void *__ptr, size_t __len, size_t __seed);
}
# 36 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/functional_hash.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 49 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/functional_hash.h" 3
template <typename _Result, typename _Arg> struct __hash_base {
typedef _Result result_type;
typedef _Arg argument_type;
};
template <typename _Tp> struct hash;
template <typename _Tp>
struct hash<_Tp *> : public __hash_base<size_t, _Tp *> {
size_t operator()(_Tp *__p) const noexcept {
return reinterpret_cast<size_t>(__p);
}
};
# 80 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/functional_hash.h" 3
template <> struct hash<bool> : public __hash_base<size_t, bool> {
size_t operator()(bool __val) const noexcept {
return static_cast<size_t>(__val);
}
};
template <> struct hash<char> : public __hash_base<size_t, char> {
size_t operator()(char __val) const noexcept {
return static_cast<size_t>(__val);
}
};
template <>
struct hash<signed char> : public __hash_base<size_t, signed char> {
size_t operator()(signed char __val) const noexcept {
return static_cast<size_t>(__val);
}
};
template <>
struct hash<unsigned char> : public __hash_base<size_t, unsigned char> {
size_t operator()(unsigned char __val) const noexcept {
return static_cast<size_t>(__val);
}
};
template <> struct hash<wchar_t> : public __hash_base<size_t, wchar_t> {
size_t operator()(wchar_t __val) const noexcept {
return static_cast<size_t>(__val);
}
};
template <> struct hash<char16_t> : public __hash_base<size_t, char16_t> {
size_t operator()(char16_t __val) const noexcept {
return static_cast<size_t>(__val);
}
};
template <> struct hash<char32_t> : public __hash_base<size_t, char32_t> {
size_t operator()(char32_t __val) const noexcept {
return static_cast<size_t>(__val);
}
};
template <> struct hash<short> : public __hash_base<size_t, short> {
size_t operator()(short __val) const noexcept {
return static_cast<size_t>(__val);
}
};
template <> struct hash<int> : public __hash_base<size_t, int> {
size_t operator()(int __val) const noexcept {
return static_cast<size_t>(__val);
}
};
template <> struct hash<long> : public __hash_base<size_t, long> {
size_t operator()(long __val) const noexcept {
return static_cast<size_t>(__val);
}
};
template <> struct hash<long long> : public __hash_base<size_t, long long> {
size_t operator()(long long __val) const noexcept {
return static_cast<size_t>(__val);
}
};
template <>
struct hash<unsigned short> : public __hash_base<size_t, unsigned short> {
size_t operator()(unsigned short __val) const noexcept {
return static_cast<size_t>(__val);
}
};
template <>
struct hash<unsigned int> : public __hash_base<size_t, unsigned int> {
size_t operator()(unsigned int __val) const noexcept {
return static_cast<size_t>(__val);
}
};
template <>
struct hash<unsigned long> : public __hash_base<size_t, unsigned long> {
size_t operator()(unsigned long __val) const noexcept {
return static_cast<size_t>(__val);
}
};
template <>
struct hash<unsigned long long> : public __hash_base<size_t,
unsigned long long> {
size_t operator()(unsigned long long __val) const noexcept {
return static_cast<size_t>(__val);
}
};
struct _Hash_impl {
static size_t hash(const void *__ptr, size_t __clength,
size_t __seed = static_cast<size_t>(0xc70f6907UL)) {
return _Hash_bytes(__ptr, __clength, __seed);
}
template <typename _Tp> static size_t hash(const _Tp &__val) {
return hash(&__val, sizeof(__val));
}
template <typename _Tp>
static size_t __hash_combine(const _Tp &__val, size_t __hash) {
return hash(&__val, sizeof(__val), __hash);
}
};
struct _Fnv_hash_impl {
static size_t hash(const void *__ptr, size_t __clength,
size_t __seed = static_cast<size_t>(2166136261UL)) {
return _Fnv_hash_bytes(__ptr, __clength, __seed);
}
template <typename _Tp> static size_t hash(const _Tp &__val) {
return hash(&__val, sizeof(__val));
}
template <typename _Tp>
static size_t __hash_combine(const _Tp &__val, size_t __hash) {
return hash(&__val, sizeof(__val), __hash);
}
};
template <> struct hash<float> : public __hash_base<size_t, float> {
size_t operator()(float __val) const noexcept {
return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0;
}
};
template <> struct hash<double> : public __hash_base<size_t, double> {
size_t operator()(double __val) const noexcept {
return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0;
}
};
template <>
struct hash<long double> : public __hash_base<size_t, long double> {
__attribute__((__pure__)) size_t operator()(long double __val) const
noexcept;
};
template <typename _Hash> struct __is_fast_hash : public std::true_type {};
template <>
struct __is_fast_hash<hash<long double> > : public std::false_type {};
}
# 3053 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
template <> struct hash<string> : public __hash_base<size_t, string> {
size_t operator()(const string &__s) const noexcept {
return std::_Hash_impl::hash(__s.data(), __s.length());
}
};
template <> struct __is_fast_hash<hash<string> > : std::false_type {};
template <> struct hash<wstring> : public __hash_base<size_t, wstring> {
size_t operator()(const wstring &__s) const noexcept {
return std::_Hash_impl::hash(__s.data(), __s.length() * sizeof(wchar_t));
}
};
template <> struct __is_fast_hash<hash<wstring> > : std::false_type {};
template <> struct hash<u16string> : public __hash_base<size_t, u16string> {
size_t operator()(const u16string &__s) const noexcept {
return std::_Hash_impl::hash(__s.data(), __s.length() * sizeof(char16_t));
}
};
template <> struct __is_fast_hash<hash<u16string> > : std::false_type {};
template <> struct hash<u32string> : public __hash_base<size_t, u32string> {
size_t operator()(const u32string &__s) const noexcept {
return std::_Hash_impl::hash(__s.data(), __s.length() * sizeof(char32_t));
}
};
template <> struct __is_fast_hash<hash<u32string> > : std::false_type {};
# 3158 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.h" 3
}
# 53 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/string" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.tcc" 1 3
# 41 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.tcc" 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _CharT, typename _Traits, typename _Alloc>
const typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_max_size =
(((npos - sizeof(_Rep_base)) / sizeof(_CharT)) - 1) / 4;
template <typename _CharT, typename _Traits, typename _Alloc>
const _CharT basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_terminal =
_CharT();
template <typename _CharT, typename _Traits, typename _Alloc>
const typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::npos;
template <typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage
[(sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
sizeof(size_type)];
template <typename _CharT, typename _Traits, typename _Alloc>
template <typename _InIterator>
_CharT *basic_string<_CharT, _Traits, _Alloc>::_S_construct(
_InIterator __beg, _InIterator __end, const _Alloc & __a,
input_iterator_tag) {
if (__beg == __end && __a == _Alloc())
return _S_empty_rep()._M_refdata();
_CharT __buf[128];
size_type __len = 0;
while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT)) {
__buf[__len++] = *__beg;
++__beg;
}
_Rep *__r = _Rep::_S_create(__len, size_type(0), __a);
_M_copy(__r->_M_refdata(), __buf, __len);
try {
while (__beg != __end) {
if (__len == __r->_M_capacity) {
_Rep *__another = _Rep::_S_create(__len + 1, __len, __a);
_M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
__r->_M_destroy(__a);
__r = __another;
}
__r->_M_refdata()[__len++] = *__beg;
++__beg;
}
}
catch (...) {
__r->_M_destroy(__a);
throw;
}
__r->_M_set_length_and_sharable(__len);
return __r->_M_refdata();
}
template <typename _CharT, typename _Traits, typename _Alloc>
template <typename _InIterator>
_CharT *basic_string<_CharT, _Traits, _Alloc>::_S_construct(
_InIterator __beg, _InIterator __end, const _Alloc & __a,
forward_iterator_tag) {
if (__beg == __end && __a == _Alloc())
return _S_empty_rep()._M_refdata();
if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
__throw_logic_error(("basic_string::_S_construct null not valid"));
const size_type __dnew =
static_cast<size_type>(std::distance(__beg, __end));
_Rep *__r = _Rep::_S_create(__dnew, size_type(0), __a);
try {
_S_copy_chars(__r->_M_refdata(), __beg, __end);
}
catch (...) {
__r->_M_destroy(__a);
throw;
}
__r->_M_set_length_and_sharable(__dnew);
return __r->_M_refdata();
}
template <typename _CharT, typename _Traits, typename _Alloc>
_CharT *basic_string<_CharT, _Traits, _Alloc>::_S_construct(
size_type __n, _CharT __c, const _Alloc & __a) {
if (__n == 0 && __a == _Alloc())
return _S_empty_rep()._M_refdata();
_Rep *__r = _Rep::_S_create(__n, size_type(0), __a);
if (__n)
_M_assign(__r->_M_refdata(), __n, __c);
__r->_M_set_length_and_sharable(__n);
return __r->_M_refdata();
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::basic_string(const basic_string &
__str)
: _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
__str.get_allocator()),
__str.get_allocator()) {}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::basic_string(const _Alloc & __a)
: _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a) {}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::basic_string(
const basic_string & __str, size_type __pos, size_type __n)
: _M_dataplus(_S_construct(
__str._M_data() +
__str._M_check(__pos, "basic_string::basic_string"),
__str._M_data() + __str._M_limit(__pos, __n) + __pos,
_Alloc()),
_Alloc()) {}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::basic_string(
const basic_string & __str, size_type __pos, size_type __n,
const _Alloc & __a)
: _M_dataplus(_S_construct(
__str._M_data() +
__str._M_check(__pos, "basic_string::basic_string"),
__str._M_data() + __str._M_limit(__pos, __n) + __pos,
__a),
__a) {}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::basic_string(
const _CharT * __s, size_type __n, const _Alloc & __a)
: _M_dataplus(_S_construct(__s, __s + __n, __a), __a) {}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::basic_string(const _CharT * __s,
const _Alloc & __a)
: _M_dataplus(
_S_construct(__s, __s ? __s + traits_type::length(__s) : __s + npos,
__a),
__a) {}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::basic_string(size_type __n, _CharT __c,
const _Alloc & __a)
: _M_dataplus(_S_construct(__n, __c, __a), __a) {}
template <typename _CharT, typename _Traits, typename _Alloc>
template <typename _InputIterator>
basic_string<_CharT, _Traits, _Alloc>::basic_string(
_InputIterator __beg, _InputIterator __end, const _Alloc & __a)
: _M_dataplus(_S_construct(__beg, __end, __a), __a) {}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::basic_string(
initializer_list<_CharT> __l, const _Alloc & __a)
: _M_dataplus(_S_construct(__l.begin(), __l.end(), __a), __a) {}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc> &
basic_string<_CharT, _Traits, _Alloc>::assign(const basic_string & __str) {
if (_M_rep() != __str._M_rep()) {
const allocator_type __a = this->get_allocator();
_CharT *__tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
_M_rep()->_M_dispose(__a);
_M_data(__tmp);
}
return *this;
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc> &basic_string<
_CharT, _Traits, _Alloc>::assign(const _CharT * __s, size_type __n) {
;
_M_check_length(this->size(), __n, "basic_string::assign");
if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
return _M_replace_safe(size_type(0), this->size(), __s, __n);
else {
const size_type __pos = __s - _M_data();
if (__pos >= __n)
_M_copy(_M_data(), __s, __n);
else if (__pos)
_M_move(_M_data(), __s, __n);
_M_rep()->_M_set_length_and_sharable(__n);
return *this;
}
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc> &
basic_string<_CharT, _Traits, _Alloc>::append(size_type __n, _CharT __c) {
if (__n) {
_M_check_length(size_type(0), __n, "basic_string::append");
const size_type __len = __n + this->size();
if (__len > this->capacity() || _M_rep()->_M_is_shared())
this->reserve(__len);
_M_assign(_M_data() + this->size(), __n, __c);
_M_rep()->_M_set_length_and_sharable(__len);
}
return *this;
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc> &basic_string<
_CharT, _Traits, _Alloc>::append(const _CharT * __s, size_type __n) {
;
if (__n) {
_M_check_length(size_type(0), __n, "basic_string::append");
const size_type __len = __n + this->size();
if (__len > this->capacity() || _M_rep()->_M_is_shared()) {
if (_M_disjunct(__s))
this->reserve(__len);
else {
const size_type __off = __s - _M_data();
this->reserve(__len);
__s = _M_data() + __off;
}
}
_M_copy(_M_data() + this->size(), __s, __n);
_M_rep()->_M_set_length_and_sharable(__len);
}
return *this;
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc> &
basic_string<_CharT, _Traits, _Alloc>::append(const basic_string & __str) {
const size_type __size = __str.size();
if (__size) {
const size_type __len = __size + this->size();
if (__len > this->capacity() || _M_rep()->_M_is_shared())
this->reserve(__len);
_M_copy(_M_data() + this->size(), __str._M_data(), __size);
_M_rep()->_M_set_length_and_sharable(__len);
}
return *this;
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc> &
basic_string<_CharT, _Traits, _Alloc>::append(
const basic_string & __str, size_type __pos, size_type __n) {
__str._M_check(__pos, "basic_string::append");
__n = __str._M_limit(__pos, __n);
if (__n) {
const size_type __len = __n + this->size();
if (__len > this->capacity() || _M_rep()->_M_is_shared())
this->reserve(__len);
_M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
_M_rep()->_M_set_length_and_sharable(__len);
}
return *this;
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc> &
basic_string<_CharT, _Traits, _Alloc>::insert(
size_type __pos, const _CharT * __s, size_type __n) {
;
_M_check(__pos, "basic_string::insert");
_M_check_length(size_type(0), __n, "basic_string::insert");
if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
return _M_replace_safe(__pos, size_type(0), __s, __n);
else {
const size_type __off = __s - _M_data();
_M_mutate(__pos, 0, __n);
__s = _M_data() + __off;
_CharT *__p = _M_data() + __pos;
if (__s + __n <= __p)
_M_copy(__p, __s, __n);
else if (__s >= __p)
_M_copy(__p, __s + __n, __n);
else {
const size_type __nleft = __p - __s;
_M_copy(__p, __s, __nleft);
_M_copy(__p + __nleft, __p + __n, __n - __nleft);
}
return *this;
}
}
template <typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::iterator basic_string<
_CharT, _Traits, _Alloc>::erase(iterator __first, iterator __last) {
;
const size_type __size = __last - __first;
if (__size) {
const size_type __pos = __first - _M_ibegin();
_M_mutate(__pos, __size, size_type(0));
_M_rep()->_M_set_leaked();
return iterator(_M_data() + __pos);
} else
return __first;
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc> &
basic_string<_CharT, _Traits, _Alloc>::replace(
size_type __pos, size_type __n1, const _CharT * __s, size_type __n2) {
;
_M_check(__pos, "basic_string::replace");
__n1 = _M_limit(__pos, __n1);
_M_check_length(__n1, __n2, "basic_string::replace");
bool __left;
if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
return _M_replace_safe(__pos, __n1, __s, __n2);
else if ((__left = __s + __n2 <= _M_data() + __pos) ||
_M_data() + __pos + __n1 <= __s) {
size_type __off = __s - _M_data();
__left ? __off : (__off += __n2 - __n1);
_M_mutate(__pos, __n1, __n2);
_M_copy(_M_data() + __pos, _M_data() + __off, __n2);
return *this;
} else {
const basic_string __tmp(__s, __n2);
return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
}
}
template <typename _CharT, typename _Traits, typename _Alloc>
void basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_destroy(const _Alloc &
__a) throw() {
const size_type __size =
sizeof(_Rep_base) + (this->_M_capacity + 1) * sizeof(_CharT);
_Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char *>(this), __size);
}
template <typename _CharT, typename _Traits, typename _Alloc>
void basic_string<_CharT, _Traits, _Alloc>::_M_leak_hard() {
if (_M_rep() == &_S_empty_rep())
return;
if (_M_rep()->_M_is_shared())
_M_mutate(0, 0, 0);
_M_rep()->_M_set_leaked();
}
template <typename _CharT, typename _Traits, typename _Alloc>
void basic_string<_CharT, _Traits, _Alloc>::_M_mutate(
size_type __pos, size_type __len1, size_type __len2) {
const size_type __old_size = this->size();
const size_type __new_size = __old_size + __len2 - __len1;
const size_type __how_much = __old_size - __pos - __len1;
if (__new_size > this->capacity() || _M_rep()->_M_is_shared()) {
const allocator_type __a = get_allocator();
_Rep *__r = _Rep::_S_create(__new_size, this->capacity(), __a);
if (__pos)
_M_copy(__r->_M_refdata(), _M_data(), __pos);
if (__how_much)
_M_copy(__r->_M_refdata() + __pos + __len2, _M_data() + __pos + __len1,
__how_much);
_M_rep()->_M_dispose(__a);
_M_data(__r->_M_refdata());
} else if (__how_much && __len1 != __len2) {
_M_move(_M_data() + __pos + __len2, _M_data() + __pos + __len1,
__how_much);
}
_M_rep()->_M_set_length_and_sharable(__new_size);
}
template <typename _CharT, typename _Traits, typename _Alloc>
void basic_string<_CharT, _Traits, _Alloc>::reserve(size_type __res) {
if (__res != this->capacity() || _M_rep()->_M_is_shared()) {
if (__res < this->size())
__res = this->size();
const allocator_type __a = get_allocator();
_CharT *__tmp = _M_rep()->_M_clone(__a, __res - this->size());
_M_rep()->_M_dispose(__a);
_M_data(__tmp);
}
}
template <typename _CharT, typename _Traits, typename _Alloc>
void basic_string<_CharT, _Traits, _Alloc>::swap(basic_string & __s) {
if (_M_rep()->_M_is_leaked())
_M_rep()->_M_set_sharable();
if (__s._M_rep()->_M_is_leaked())
__s._M_rep()->_M_set_sharable();
if (this->get_allocator() == __s.get_allocator()) {
_CharT *__tmp = _M_data();
_M_data(__s._M_data());
__s._M_data(__tmp);
} else {
const basic_string __tmp1(_M_ibegin(), _M_iend(), __s.get_allocator());
const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
this->get_allocator());
*this = __tmp2;
__s = __tmp1;
}
}
template <typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::_Rep *
basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_create(
size_type __capacity, size_type __old_capacity, const _Alloc & __alloc) {
if (__capacity > _S_max_size)
__throw_length_error(("basic_string::_S_create"));
# 577 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_string.tcc" 3
const size_type __pagesize = 4096;
const size_type __malloc_header_size = 4 * sizeof(void *);
if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
__capacity = 2 * __old_capacity;
size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
const size_type __adj_size = __size + __malloc_header_size;
if (__adj_size > __pagesize && __capacity > __old_capacity) {
const size_type __extra = __pagesize - __adj_size % __pagesize;
__capacity += __extra / sizeof(_CharT);
if (__capacity > _S_max_size)
__capacity = _S_max_size;
__size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
}
void *__place = _Raw_bytes_alloc(__alloc).allocate(__size);
_Rep *__p = new (__place) _Rep;
__p->_M_capacity = __capacity;
__p->_M_set_sharable();
return __p;
}
template <typename _CharT, typename _Traits, typename _Alloc>
_CharT *basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_clone(
const _Alloc & __alloc, size_type __res) {
const size_type __requested_cap = this->_M_length + __res;
_Rep *__r = _Rep::_S_create(__requested_cap, this->_M_capacity, __alloc);
if (this->_M_length)
_M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);
__r->_M_set_length_and_sharable(this->_M_length);
return __r->_M_refdata();
}
template <typename _CharT, typename _Traits, typename _Alloc>
void basic_string<_CharT, _Traits, _Alloc>::resize(size_type __n,
_CharT __c) {
const size_type __size = this->size();
_M_check_length(__size, __n, "basic_string::resize");
if (__size < __n)
this->append(__n - __size, __c);
else if (__n < __size)
this->erase(__n);
}
template <typename _CharT, typename _Traits, typename _Alloc>
template <typename _InputIterator>
basic_string<_CharT, _Traits, _Alloc> &
basic_string<_CharT, _Traits, _Alloc>::_M_replace_dispatch(
iterator __i1, iterator __i2, _InputIterator __k1, _InputIterator __k2,
__false_type) {
const basic_string __s(__k1, __k2);
const size_type __n1 = __i2 - __i1;
_M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch");
return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(), __s.size());
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc> &
basic_string<_CharT, _Traits, _Alloc>::_M_replace_aux(
size_type __pos1, size_type __n1, size_type __n2, _CharT __c) {
_M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
_M_mutate(__pos1, __n1, __n2);
if (__n2)
_M_assign(_M_data() + __pos1, __n2, __c);
return *this;
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc> &
basic_string<_CharT, _Traits, _Alloc>::_M_replace_safe(
size_type __pos1, size_type __n1, const _CharT * __s, size_type __n2) {
_M_mutate(__pos1, __n1, __n2);
if (__n2)
_M_copy(_M_data() + __pos1, __s, __n2);
return *this;
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc> operator+(
const _CharT * __lhs,
const basic_string<_CharT, _Traits, _Alloc> & __rhs) {
;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
const __size_type __len = _Traits::length(__lhs);
__string_type __str;
__str.reserve(__len + __rhs.size());
__str.append(__lhs, __len);
__str.append(__rhs);
return __str;
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc> operator+(
_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc> & __rhs) {
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
__string_type __str;
const __size_type __len = __rhs.size();
__str.reserve(__len + 1);
__str.append(__size_type(1), __lhs);
__str.append(__rhs);
return __str;
}
template <typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::copy(_CharT * __s, size_type __n,
size_type __pos) const {
_M_check(__pos, "basic_string::copy");
__n = _M_limit(__pos, __n);
;
if (__n)
_M_copy(__s, _M_data() + __pos, __n);
return __n;
}
template <typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::find(
const _CharT * __s, size_type __pos, size_type __n) const {
;
const size_type __size = this->size();
const _CharT *__data = _M_data();
if (__n == 0)
return __pos <= __size ? __pos : npos;
if (__n <= __size) {
for (; __pos <= __size - __n; ++__pos)
if (traits_type::eq(__data[__pos], __s[0]) &&
traits_type::compare(__data + __pos + 1, __s + 1, __n - 1) == 0)
return __pos;
}
return npos;
}
template <typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::find(_CharT __c, size_type __pos) const
noexcept {
size_type __ret = npos;
const size_type __size = this->size();
if (__pos < __size) {
const _CharT *__data = _M_data();
const size_type __n = __size - __pos;
const _CharT *__p = traits_type::find(__data + __pos, __n, __c);
if (__p)
__ret = __p - __data;
}
return __ret;
}
template <typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::rfind(
const _CharT * __s, size_type __pos, size_type __n) const {
;
const size_type __size = this->size();
if (__n <= __size) {
__pos = std::min(size_type(__size - __n), __pos);
const _CharT *__data = _M_data();
do {
if (traits_type::compare(__data + __pos, __s, __n) == 0)
return __pos;
} while (__pos-- > 0);
}
return npos;
}
template <typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::rfind(_CharT __c,
size_type __pos) const noexcept {
size_type __size = this->size();
if (__size) {
if (--__size > __pos)
__size = __pos;
for (++__size; __size-- > 0;)
if (traits_type::eq(_M_data()[__size], __c))
return __size;
}
return npos;
}
template <typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::find_first_of(
const _CharT * __s, size_type __pos, size_type __n) const {
;
for (; __n && __pos < this->size(); ++__pos) {
const _CharT *__p = traits_type::find(__s, __n, _M_data()[__pos]);
if (__p)
return __pos;
}
return npos;
}
template <typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::find_last_of(
const _CharT * __s, size_type __pos, size_type __n) const {
;
size_type __size = this->size();
if (__size && __n) {
if (--__size > __pos)
__size = __pos;
do {
if (traits_type::find(__s, __n, _M_data()[__size]))
return __size;
} while (__size-- != 0);
}
return npos;
}
template <typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::find_first_not_of(
const _CharT * __s, size_type __pos, size_type __n) const {
;
for (; __pos < this->size(); ++__pos)
if (!traits_type::find(__s, __n, _M_data()[__pos]))
return __pos;
return npos;
}
template <typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::find_first_not_of(
_CharT __c, size_type __pos) const noexcept {
for (; __pos < this->size(); ++__pos)
if (!traits_type::eq(_M_data()[__pos], __c))
return __pos;
return npos;
}
template <typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::find_last_not_of(
const _CharT * __s, size_type __pos, size_type __n) const {
;
size_type __size = this->size();
if (__size) {
if (--__size > __pos)
__size = __pos;
do {
if (!traits_type::find(__s, __n, _M_data()[__size]))
return __size;
} while (__size--);
}
return npos;
}
template <typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::find_last_not_of(
_CharT __c, size_type __pos) const noexcept {
size_type __size = this->size();
if (__size) {
if (--__size > __pos)
__size = __pos;
do {
if (!traits_type::eq(_M_data()[__size], __c))
return __size;
} while (__size--);
}
return npos;
}
template <typename _CharT, typename _Traits, typename _Alloc>
int basic_string<_CharT, _Traits, _Alloc>::compare(
size_type __pos, size_type __n, const basic_string & __str) const {
_M_check(__pos, "basic_string::compare");
__n = _M_limit(__pos, __n);
const size_type __osize = __str.size();
const size_type __len = std::min(__n, __osize);
int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
if (!__r)
__r = _S_compare(__n, __osize);
return __r;
}
template <typename _CharT, typename _Traits, typename _Alloc>
int basic_string<_CharT, _Traits, _Alloc>::compare(
size_type __pos1, size_type __n1, const basic_string & __str,
size_type __pos2, size_type __n2) const {
_M_check(__pos1, "basic_string::compare");
__str._M_check(__pos2, "basic_string::compare");
__n1 = _M_limit(__pos1, __n1);
__n2 = __str._M_limit(__pos2, __n2);
const size_type __len = std::min(__n1, __n2);
int __r =
traits_type::compare(_M_data() + __pos1, __str.data() + __pos2, __len);
if (!__r)
__r = _S_compare(__n1, __n2);
return __r;
}
template <typename _CharT, typename _Traits, typename _Alloc>
int basic_string<_CharT, _Traits, _Alloc>::compare(const _CharT * __s) const {
;
const size_type __size = this->size();
const size_type __osize = traits_type::length(__s);
const size_type __len = std::min(__size, __osize);
int __r = traits_type::compare(_M_data(), __s, __len);
if (!__r)
__r = _S_compare(__size, __osize);
return __r;
}
template <typename _CharT, typename _Traits, typename _Alloc>
int basic_string<_CharT, _Traits, _Alloc>::compare(
size_type __pos, size_type __n1, const _CharT * __s) const {
;
_M_check(__pos, "basic_string::compare");
__n1 = _M_limit(__pos, __n1);
const size_type __osize = traits_type::length(__s);
const size_type __len = std::min(__n1, __osize);
int __r = traits_type::compare(_M_data() + __pos, __s, __len);
if (!__r)
__r = _S_compare(__n1, __osize);
return __r;
}
template <typename _CharT, typename _Traits, typename _Alloc>
int basic_string<_CharT, _Traits, _Alloc>::compare(
size_type __pos, size_type __n1, const _CharT * __s,
size_type __n2) const {
;
_M_check(__pos, "basic_string::compare");
__n1 = _M_limit(__pos, __n1);
const size_type __len = std::min(__n1, __n2);
int __r = traits_type::compare(_M_data() + __pos, __s, __len);
if (!__r)
__r = _S_compare(__n1, __n2);
return __r;
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits> &operator>>(
basic_istream<_CharT, _Traits> & __in,
basic_string<_CharT, _Traits, _Alloc> & __str) {
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __istream_type::ios_base __ios_base;
typedef typename __istream_type::int_type __int_type;
typedef typename __string_type::size_type __size_type;
typedef ctype<_CharT> __ctype_type;
typedef typename __ctype_type::ctype_base __ctype_base;
__size_type __extracted = 0;
typename __ios_base::iostate __err = __ios_base::goodbit;
typename __istream_type::sentry __cerb(__in, false);
if (__cerb) {
try {
__str.erase();
_CharT __buf[128];
__size_type __len = 0;
const streamsize __w = __in.width();
const __size_type __n =
__w > 0 ? static_cast<__size_type>(__w) : __str.max_size();
const __ctype_type &__ct = use_facet<__ctype_type>(__in.getloc());
const __int_type __eof = _Traits::eof();
__int_type __c = __in.rdbuf()->sgetc();
while (__extracted < __n && !_Traits::eq_int_type(__c, __eof) &&
!__ct.is(__ctype_base::space, _Traits::to_char_type(__c))) {
if (__len == sizeof(__buf) / sizeof(_CharT)) {
__str.append(__buf, sizeof(__buf) / sizeof(_CharT));
__len = 0;
}
__buf[__len++] = _Traits::to_char_type(__c);
++__extracted;
__c = __in.rdbuf()->snextc();
}
__str.append(__buf, __len);
if (_Traits::eq_int_type(__c, __eof))
__err |= __ios_base::eofbit;
__in.width(0);
}
catch (__cxxabiv1::__forced_unwind &) {
__in._M_setstate(__ios_base::badbit);
throw;
}
catch (...) {
__in._M_setstate(__ios_base::badbit);
}
}
if (!__extracted)
__err |= __ios_base::failbit;
if (__err)
__in.setstate(__err);
return __in;
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits> &getline(
basic_istream<_CharT, _Traits> & __in,
basic_string<_CharT, _Traits, _Alloc> & __str, _CharT __delim) {
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __istream_type::ios_base __ios_base;
typedef typename __istream_type::int_type __int_type;
typedef typename __string_type::size_type __size_type;
__size_type __extracted = 0;
const __size_type __n = __str.max_size();
typename __ios_base::iostate __err = __ios_base::goodbit;
typename __istream_type::sentry __cerb(__in, true);
if (__cerb) {
try {
__str.erase();
const __int_type __idelim = _Traits::to_int_type(__delim);
const __int_type __eof = _Traits::eof();
__int_type __c = __in.rdbuf()->sgetc();
while (__extracted < __n && !_Traits::eq_int_type(__c, __eof) &&
!_Traits::eq_int_type(__c, __idelim)) {
__str += _Traits::to_char_type(__c);
++__extracted;
__c = __in.rdbuf()->snextc();
}
if (_Traits::eq_int_type(__c, __eof))
__err |= __ios_base::eofbit;
else if (_Traits::eq_int_type(__c, __idelim)) {
++__extracted;
__in.rdbuf()->sbumpc();
} else
__err |= __ios_base::failbit;
}
catch (__cxxabiv1::__forced_unwind &) {
__in._M_setstate(__ios_base::badbit);
throw;
}
catch (...) {
__in._M_setstate(__ios_base::badbit);
}
}
if (!__extracted)
__err |= __ios_base::failbit;
if (__err)
__in.setstate(__err);
return __in;
}
extern template class basic_string<char>;
extern template basic_istream<char> &operator>>(basic_istream<char> &,
string &);
extern template basic_ostream<char> &operator<<(basic_ostream<char> &,
const string &);
extern template basic_istream<char> &getline(basic_istream<char> &, string &,
char);
extern template basic_istream<char> &getline(basic_istream<char> &, string &);
extern template class basic_string<wchar_t>;
extern template basic_istream<wchar_t> &operator>>(basic_istream<wchar_t> &,
wstring &);
extern template basic_ostream<wchar_t> &operator<<(basic_ostream<wchar_t> &,
const wstring &);
extern template basic_istream<wchar_t> &getline(basic_istream<wchar_t> &,
wstring &, wchar_t);
extern template basic_istream<wchar_t> &getline(basic_istream<wchar_t> &,
wstring &);
}
# 54 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/string" 2 3
# 41 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 62 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
class locale {
public:
typedef int category;
class facet;
class id;
class _Impl;
friend class facet;
friend class _Impl;
template <typename _Facet> friend bool has_facet(const locale &) throw();
template <typename _Facet> friend const _Facet &use_facet(const locale &);
template <typename _Cache> friend struct __use_cache;
# 98 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
static const category none = 0;
static const category ctype = 1L << 0;
static const category numeric = 1L << 1;
static const category collate = 1L << 2;
static const category time = 1L << 3;
static const category monetary = 1L << 4;
static const category messages = 1L << 5;
static const category all =
(ctype | numeric | collate | time | monetary | messages);
# 117 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
locale() throw();
# 126 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
locale(const locale &__other) throw();
# 136 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
explicit locale(const char *__s);
# 151 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
locale(const locale &__base, const char *__s, category __cat);
# 164 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
locale(const locale &__base, const locale &__add, category __cat);
# 177 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
template <typename _Facet> locale(const locale &__other, _Facet *__f);
~locale() throw();
# 191 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
const locale &operator=(const locale &__other) throw();
# 206 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
template <typename _Facet> locale combine(const locale &__other) const;
string name() const;
# 225 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
bool operator==(const locale &__other) const throw();
bool operator!=(const locale &__other) const throw() {
return !(this->operator==(__other));
}
# 253 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
template <typename _Char, typename _Traits, typename _Alloc>
bool operator()(const basic_string<_Char, _Traits, _Alloc> &__s1,
const basic_string<_Char, _Traits, _Alloc> &__s2) const;
# 269 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
static locale global(const locale &__loc);
static const locale &classic();
private:
_Impl *_M_impl;
static _Impl *_S_classic;
static _Impl *_S_global;
static const char *const *const _S_categories;
# 304 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
enum {
_S_categories_size = 6 + 0
};
static __gthread_once_t _S_once;
explicit locale(_Impl *) throw();
static void _S_initialize();
static void _S_initialize_once() throw();
static category _S_normalize_category(category);
void _M_coalesce(const locale &__base, const locale &__add, category __cat);
};
# 338 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
class locale::facet {
private:
friend class locale;
friend class locale::_Impl;
mutable _Atomic_word _M_refcount;
static __c_locale _S_c_locale;
static const char _S_c_name[2];
static __gthread_once_t _S_once;
static void _S_initialize_once();
protected:
# 369 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
explicit facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0) {}
virtual ~facet();
static void _S_create_c_locale(__c_locale &__cloc, const char *__s,
__c_locale __old = 0);
static __c_locale _S_clone_c_locale(__c_locale &__cloc) throw();
static void _S_destroy_c_locale(__c_locale &__cloc);
static __c_locale _S_lc_ctype_c_locale(__c_locale __cloc, const char *__s);
static __c_locale _S_get_c_locale();
__attribute__((__const__)) static const char *_S_get_c_name() throw();
private:
void _M_add_reference() const throw() {
__gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1);
}
void _M_remove_reference() const throw() {
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1) {
;
try {
delete this;
}
catch (...) {
}
}
}
facet(const facet &);
facet &operator=(const facet &);
};
# 436 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
class locale::id {
private:
friend class locale;
friend class locale::_Impl;
template <typename _Facet> friend const _Facet &use_facet(const locale &);
template <typename _Facet> friend bool has_facet(const locale &) throw();
mutable size_t _M_index;
static _Atomic_word _S_refcount;
void operator=(const id &);
id(const id &);
public:
id() {}
size_t _M_id() const throw();
};
class locale::_Impl {
public:
friend class locale;
friend class locale::facet;
template <typename _Facet> friend bool has_facet(const locale &) throw();
template <typename _Facet> friend const _Facet &use_facet(const locale &);
template <typename _Cache> friend struct __use_cache;
private:
_Atomic_word _M_refcount;
const facet **_M_facets;
size_t _M_facets_size;
const facet **_M_caches;
char **_M_names;
static const locale::id *const _S_id_ctype[];
static const locale::id *const _S_id_numeric[];
static const locale::id *const _S_id_collate[];
static const locale::id *const _S_id_time[];
static const locale::id *const _S_id_monetary[];
static const locale::id *const _S_id_messages[];
static const locale::id *const *const _S_facet_categories[];
void _M_add_reference() throw() {
__gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1);
}
void _M_remove_reference() throw() {
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1) {
;
try {
delete this;
}
catch (...) {
}
}
}
_Impl(const _Impl &, size_t);
_Impl(const char *, size_t);
_Impl(size_t) throw();
~_Impl() throw();
_Impl(const _Impl &);
void operator=(const _Impl &);
bool _M_check_same_name() {
bool __ret = true;
if (_M_names[1])
for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
__ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
return __ret;
}
void _M_replace_categories(const _Impl *, category);
void _M_replace_category(const _Impl *, const locale::id *const *);
void _M_replace_facet(const _Impl *, const locale::id *);
void _M_install_facet(const locale::id *, const facet *);
template <typename _Facet> void _M_init_facet(_Facet *__facet) {
_M_install_facet(&_Facet::id, __facet);
}
void _M_install_cache(const facet *, size_t);
};
# 583 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
template <typename _CharT> class collate : public locale::facet {
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
protected:
__c_locale _M_c_locale_collate;
public:
static locale::id id;
# 610 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
explicit collate(size_t __refs = 0)
: facet(__refs), _M_c_locale_collate(_S_get_c_locale()) {}
# 624 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
explicit collate(__c_locale __cloc, size_t __refs = 0)
: facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc)) {}
# 641 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
int compare(const _CharT *__lo1, const _CharT *__hi1, const _CharT *__lo2,
const _CharT *__hi2) const {
return this->do_compare(__lo1, __hi1, __lo2, __hi2);
}
# 660 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
string_type transform(const _CharT *__lo, const _CharT *__hi) const {
return this->do_transform(__lo, __hi);
}
# 674 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
long hash(const _CharT *__lo, const _CharT *__hi) const {
return this->do_hash(__lo, __hi);
}
int _M_compare(const _CharT *, const _CharT *) const throw();
size_t _M_transform(_CharT *, const _CharT *, size_t) const throw();
protected:
virtual ~collate() { _S_destroy_c_locale(_M_c_locale_collate); }
# 703 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
virtual int do_compare(const _CharT *__lo1, const _CharT *__hi1,
const _CharT *__lo2, const _CharT *__hi2) const;
# 717 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
virtual string_type do_transform(const _CharT *__lo,
const _CharT *__hi) const;
# 730 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 3
virtual long do_hash(const _CharT *__lo, const _CharT *__hi) const;
};
template <typename _CharT> locale::id collate<_CharT>::id;
template <>
int collate<char>::_M_compare(const char *, const char *)const throw();
template <>
size_t collate<char>::_M_transform(char *, const char *, size_t) const
throw();
template <>
int collate<wchar_t>::_M_compare(const wchar_t *, const wchar_t *)const
throw();
template <>
size_t collate<wchar_t>::_M_transform(wchar_t *, const wchar_t *,
size_t) const throw();
template <typename _CharT> class collate_byname : public collate<_CharT> {
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
explicit collate_byname(const char *__s, size_t __refs = 0)
: collate<_CharT>(__refs) {
if (__builtin_strcmp(__s, "C") != 0 &&
__builtin_strcmp(__s, "POSIX") != 0) {
this->_S_destroy_c_locale(this->_M_c_locale_collate);
this->_S_create_c_locale(this->_M_c_locale_collate, __s);
}
}
protected:
virtual ~collate_byname() {}
};
}
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.tcc" 1 3
# 38 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.tcc" 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _Facet>
locale::locale(const locale & __other, _Facet * __f) {
_M_impl = new _Impl(*__other._M_impl, 1);
try {
_M_impl->_M_install_facet(&_Facet::id, __f);
}
catch (...) {
_M_impl->_M_remove_reference();
throw;
}
delete[] _M_impl->_M_names[0];
_M_impl->_M_names[0] = 0;
}
template <typename _Facet>
locale locale::combine(const locale & __other) const {
_Impl *__tmp = new _Impl(*_M_impl, 1);
try {
__tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
}
catch (...) {
__tmp->_M_remove_reference();
throw;
}
return locale(__tmp);
}
template <typename _CharT, typename _Traits, typename _Alloc>
bool locale::operator()(const basic_string<_CharT, _Traits, _Alloc> & __s1,
const basic_string<_CharT, _Traits, _Alloc> &
__s2) const {
typedef std::collate<_CharT> __collate_type;
const __collate_type &__collate = use_facet<__collate_type>(*this);
return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
__s2.data(), __s2.data() + __s2.length()) < 0);
}
# 102 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.tcc" 3
template <typename _Facet> bool has_facet(const locale & __loc) throw() {
const size_t __i = _Facet::id._M_id();
const locale::facet **__facets = __loc._M_impl->_M_facets;
return (__i < __loc._M_impl->_M_facets_size &&
dynamic_cast<const _Facet *>(__facets[__i]));
}
# 130 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.tcc" 3
template <typename _Facet> const _Facet &use_facet(const locale & __loc) {
const size_t __i = _Facet::id._M_id();
const locale::facet **__facets = __loc._M_impl->_M_facets;
if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
__throw_bad_cast();
return dynamic_cast<const _Facet &>(*__facets[__i]);
}
template <typename _CharT>
int collate<_CharT>::_M_compare(const _CharT *, const _CharT *)const throw() {
return 0;
}
template <typename _CharT>
size_t collate<_CharT>::_M_transform(_CharT *, const _CharT *, size_t) const
throw() {
return 0;
}
template <typename _CharT>
int collate<_CharT>::do_compare(const _CharT * __lo1, const _CharT * __hi1,
const _CharT * __lo2,
const _CharT * __hi2) const {
const string_type __one(__lo1, __hi1);
const string_type __two(__lo2, __hi2);
const _CharT *__p = __one.c_str();
const _CharT *__pend = __one.data() + __one.length();
const _CharT *__q = __two.c_str();
const _CharT *__qend = __two.data() + __two.length();
for (;;) {
const int __res = _M_compare(__p, __q);
if (__res)
return __res;
__p += char_traits<_CharT>::length(__p);
__q += char_traits<_CharT>::length(__q);
if (__p == __pend && __q == __qend)
return 0;
else if (__p == __pend)
return -1;
else if (__q == __qend)
return 1;
__p++;
__q++;
}
}
template <typename _CharT>
typename collate<_CharT>::string_type collate<_CharT>::do_transform(
const _CharT * __lo, const _CharT * __hi) const {
string_type __ret;
const string_type __str(__lo, __hi);
const _CharT *__p = __str.c_str();
const _CharT *__pend = __str.data() + __str.length();
size_t __len = (__hi - __lo) * 2;
_CharT *__c = new _CharT[__len];
try {
for (;;) {
size_t __res = _M_transform(__c, __p, __len);
if (__res >= __len) {
__len = __res + 1;
delete[] __c, __c = 0;
__c = new _CharT[__len];
__res = _M_transform(__c, __p, __len);
}
__ret.append(__c, __res);
__p += char_traits<_CharT>::length(__p);
if (__p == __pend)
break;
__p++;
__ret.push_back(_CharT());
}
}
catch (...) {
delete[] __c;
throw;
}
delete[] __c;
return __ret;
}
template <typename _CharT>
long collate<_CharT>::do_hash(const _CharT * __lo,
const _CharT * __hi) const {
unsigned long __val = 0;
for (; __lo < __hi; ++__lo)
__val = *__lo +
((__val << 7) |
(__val >>
(__gnu_cxx::__numeric_traits<unsigned long>::__digits - 7)));
return static_cast<long>(__val);
}
extern template class collate<char>;
extern template class collate_byname<char>;
extern template const collate<char> &use_facet<collate<char> >(
const locale &);
extern template bool has_facet<collate<char> >(const locale &);
extern template class collate<wchar_t>;
extern template class collate_byname<wchar_t>;
extern template const collate<wchar_t> &use_facet<collate<wchar_t> >(
const locale &);
extern template bool has_facet<collate<wchar_t> >(const locale &);
}
# 788 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_classes.h" 2 3
# 42 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
enum _Ios_Fmtflags {
_S_boolalpha = 1L << 0,
_S_dec = 1L << 1,
_S_fixed = 1L << 2,
_S_hex = 1L << 3,
_S_internal = 1L << 4,
_S_left = 1L << 5,
_S_oct = 1L << 6,
_S_right = 1L << 7,
_S_scientific = 1L << 8,
_S_showbase = 1L << 9,
_S_showpoint = 1L << 10,
_S_showpos = 1L << 11,
_S_skipws = 1L << 12,
_S_unitbuf = 1L << 13,
_S_uppercase = 1L << 14,
_S_adjustfield = _S_left | _S_right | _S_internal,
_S_basefield = _S_dec | _S_oct | _S_hex,
_S_floatfield = _S_scientific | _S_fixed,
_S_ios_fmtflags_end = 1L << 16
};
inline constexpr _Ios_Fmtflags operator&(_Ios_Fmtflags __a,
_Ios_Fmtflags __b) {
return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b));
}
inline constexpr _Ios_Fmtflags operator|(_Ios_Fmtflags __a,
_Ios_Fmtflags __b) {
return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b));
}
inline constexpr _Ios_Fmtflags operator^(_Ios_Fmtflags __a,
_Ios_Fmtflags __b) {
return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b));
}
inline constexpr _Ios_Fmtflags operator~(_Ios_Fmtflags __a) {
return _Ios_Fmtflags(~static_cast<int>(__a));
}
inline const _Ios_Fmtflags &operator|=(_Ios_Fmtflags & __a,
_Ios_Fmtflags __b) {
return __a = __a | __b;
}
inline const _Ios_Fmtflags &operator&=(_Ios_Fmtflags & __a,
_Ios_Fmtflags __b) {
return __a = __a & __b;
}
inline const _Ios_Fmtflags &operator^=(_Ios_Fmtflags & __a,
_Ios_Fmtflags __b) {
return __a = __a ^ __b;
}
enum _Ios_Openmode {
_S_app = 1L << 0,
_S_ate = 1L << 1,
_S_bin = 1L << 2,
_S_in = 1L << 3,
_S_out = 1L << 4,
_S_trunc = 1L << 5,
_S_ios_openmode_end = 1L << 16
};
inline constexpr _Ios_Openmode operator&(_Ios_Openmode __a,
_Ios_Openmode __b) {
return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b));
}
inline constexpr _Ios_Openmode operator|(_Ios_Openmode __a,
_Ios_Openmode __b) {
return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b));
}
inline constexpr _Ios_Openmode operator^(_Ios_Openmode __a,
_Ios_Openmode __b) {
return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b));
}
inline constexpr _Ios_Openmode operator~(_Ios_Openmode __a) {
return _Ios_Openmode(~static_cast<int>(__a));
}
inline const _Ios_Openmode &operator|=(_Ios_Openmode & __a,
_Ios_Openmode __b) {
return __a = __a | __b;
}
inline const _Ios_Openmode &operator&=(_Ios_Openmode & __a,
_Ios_Openmode __b) {
return __a = __a & __b;
}
inline const _Ios_Openmode &operator^=(_Ios_Openmode & __a,
_Ios_Openmode __b) {
return __a = __a ^ __b;
}
enum _Ios_Iostate {
_S_goodbit = 0,
_S_badbit = 1L << 0,
_S_eofbit = 1L << 1,
_S_failbit = 1L << 2,
_S_ios_iostate_end = 1L << 16
};
inline constexpr _Ios_Iostate operator&(_Ios_Iostate __a, _Ios_Iostate __b) {
return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b));
}
inline constexpr _Ios_Iostate operator|(_Ios_Iostate __a, _Ios_Iostate __b) {
return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b));
}
inline constexpr _Ios_Iostate operator^(_Ios_Iostate __a, _Ios_Iostate __b) {
return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b));
}
inline constexpr _Ios_Iostate operator~(_Ios_Iostate __a) {
return _Ios_Iostate(~static_cast<int>(__a));
}
inline const _Ios_Iostate &operator|=(_Ios_Iostate & __a, _Ios_Iostate __b) {
return __a = __a | __b;
}
inline const _Ios_Iostate &operator&=(_Ios_Iostate & __a, _Ios_Iostate __b) {
return __a = __a & __b;
}
inline const _Ios_Iostate &operator^=(_Ios_Iostate & __a, _Ios_Iostate __b) {
return __a = __a ^ __b;
}
enum _Ios_Seekdir {
_S_beg = 0,
_S_cur = 1,
_S_end = 2,
_S_ios_seekdir_end = 1L << 16
};
# 199 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
class ios_base {
public:
class failure : public exception {
public:
explicit failure(const string &__str) throw();
virtual ~failure() throw();
virtual const char *what() const throw();
private:
string _M_msg;
};
# 255 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
typedef _Ios_Fmtflags fmtflags;
static const fmtflags boolalpha = _S_boolalpha;
static const fmtflags dec = _S_dec;
static const fmtflags fixed = _S_fixed;
static const fmtflags hex = _S_hex;
static const fmtflags internal = _S_internal;
static const fmtflags left = _S_left;
static const fmtflags oct = _S_oct;
static const fmtflags right = _S_right;
static const fmtflags scientific = _S_scientific;
static const fmtflags showbase = _S_showbase;
static const fmtflags showpoint = _S_showpoint;
static const fmtflags showpos = _S_showpos;
static const fmtflags skipws = _S_skipws;
static const fmtflags unitbuf = _S_unitbuf;
static const fmtflags uppercase = _S_uppercase;
static const fmtflags adjustfield = _S_adjustfield;
static const fmtflags basefield = _S_basefield;
static const fmtflags floatfield = _S_floatfield;
# 330 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
typedef _Ios_Iostate iostate;
static const iostate badbit = _S_badbit;
static const iostate eofbit = _S_eofbit;
static const iostate failbit = _S_failbit;
static const iostate goodbit = _S_goodbit;
# 361 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
typedef _Ios_Openmode openmode;
static const openmode app = _S_app;
static const openmode ate = _S_ate;
static const openmode binary = _S_bin;
static const openmode in = _S_in;
static const openmode out = _S_out;
static const openmode trunc = _S_trunc;
# 393 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
typedef _Ios_Seekdir seekdir;
static const seekdir beg = _S_beg;
static const seekdir cur = _S_cur;
static const seekdir end = _S_end;
typedef int io_state;
typedef int open_mode;
typedef int seek_dir;
typedef std::streampos streampos;
typedef std::streamoff streamoff;
# 419 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
enum event {
erase_event,
imbue_event,
copyfmt_event
};
# 436 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
typedef void (*event_callback)(event __e, ios_base &__b, int __i);
# 448 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
void register_callback(event_callback __fn, int __index);
protected:
streamsize _M_precision;
streamsize _M_width;
fmtflags _M_flags;
iostate _M_exception;
iostate _M_streambuf_state;
struct _Callback_list {
_Callback_list *_M_next;
ios_base::event_callback _M_fn;
int _M_index;
_Atomic_word _M_refcount;
_Callback_list(ios_base::event_callback __fn, int __index,
_Callback_list *__cb)
: _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) {}
void _M_add_reference() {
__gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1);
}
int _M_remove_reference() {
;
int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
if (__res == 0) {
;
}
return __res;
}
};
_Callback_list *_M_callbacks;
void _M_call_callbacks(event __ev) throw();
void _M_dispose_callbacks(void) throw();
struct _Words {
void *_M_pword;
long _M_iword;
_Words() : _M_pword(0), _M_iword(0) {}
};
_Words _M_word_zero;
enum {
_S_local_word_size = 8
};
_Words _M_local_word[_S_local_word_size];
int _M_word_size;
_Words *_M_word;
_Words &_M_grow_words(int __index, bool __iword);
locale _M_ios_locale;
void _M_init() throw();
public:
class Init {
friend class ios_base;
public:
Init();
~Init();
private:
static _Atomic_word _S_refcount;
static bool _S_synced_with_stdio;
};
fmtflags flags() const { return _M_flags; }
# 561 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
fmtflags flags(fmtflags __fmtfl) {
fmtflags __old = _M_flags;
_M_flags = __fmtfl;
return __old;
}
# 577 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
fmtflags setf(fmtflags __fmtfl) {
fmtflags __old = _M_flags;
_M_flags |= __fmtfl;
return __old;
}
# 594 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
fmtflags setf(fmtflags __fmtfl, fmtflags __mask) {
fmtflags __old = _M_flags;
_M_flags &= ~__mask;
_M_flags |= (__fmtfl & __mask);
return __old;
}
void unsetf(fmtflags __mask) { _M_flags &= ~__mask; }
# 620 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
streamsize precision() const { return _M_precision; }
streamsize precision(streamsize __prec) {
streamsize __old = _M_precision;
_M_precision = __prec;
return __old;
}
streamsize width() const { return _M_width; }
streamsize width(streamsize __wide) {
streamsize __old = _M_width;
_M_width = __wide;
return __old;
}
# 671 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
static bool sync_with_stdio(bool __sync = true);
# 683 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
locale imbue(const locale &__loc) throw();
# 694 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
locale getloc() const { return _M_ios_locale; }
# 705 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
const locale &_M_getloc() const { return _M_ios_locale; }
# 724 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
static int xalloc() throw();
# 740 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
long &iword(int __ix) {
_Words &__word =
(__ix < _M_word_size) ? _M_word[__ix] : _M_grow_words(__ix, true);
return __word._M_iword;
}
# 761 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
void *&pword(int __ix) {
_Words &__word =
(__ix < _M_word_size) ? _M_word[__ix] : _M_grow_words(__ix, false);
return __word._M_pword;
}
# 778 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ios_base.h" 3
virtual ~ios_base();
protected:
ios_base() throw();
private:
ios_base(const ios_base &);
ios_base &operator=(const ios_base &);
};
inline ios_base &boolalpha(ios_base & __base) {
__base.setf(ios_base::boolalpha);
return __base;
}
inline ios_base &noboolalpha(ios_base & __base) {
__base.unsetf(ios_base::boolalpha);
return __base;
}
inline ios_base &showbase(ios_base & __base) {
__base.setf(ios_base::showbase);
return __base;
}
inline ios_base &noshowbase(ios_base & __base) {
__base.unsetf(ios_base::showbase);
return __base;
}
inline ios_base &showpoint(ios_base & __base) {
__base.setf(ios_base::showpoint);
return __base;
}
inline ios_base &noshowpoint(ios_base & __base) {
__base.unsetf(ios_base::showpoint);
return __base;
}
inline ios_base &showpos(ios_base & __base) {
__base.setf(ios_base::showpos);
return __base;
}
inline ios_base &noshowpos(ios_base & __base) {
__base.unsetf(ios_base::showpos);
return __base;
}
inline ios_base &skipws(ios_base & __base) {
__base.setf(ios_base::skipws);
return __base;
}
inline ios_base &noskipws(ios_base & __base) {
__base.unsetf(ios_base::skipws);
return __base;
}
inline ios_base &uppercase(ios_base & __base) {
__base.setf(ios_base::uppercase);
return __base;
}
inline ios_base &nouppercase(ios_base & __base) {
__base.unsetf(ios_base::uppercase);
return __base;
}
inline ios_base &unitbuf(ios_base & __base) {
__base.setf(ios_base::unitbuf);
return __base;
}
inline ios_base &nounitbuf(ios_base & __base) {
__base.unsetf(ios_base::unitbuf);
return __base;
}
inline ios_base &internal(ios_base & __base) {
__base.setf(ios_base::internal, ios_base::adjustfield);
return __base;
}
inline ios_base &left(ios_base & __base) {
__base.setf(ios_base::left, ios_base::adjustfield);
return __base;
}
inline ios_base &right(ios_base & __base) {
__base.setf(ios_base::right, ios_base::adjustfield);
return __base;
}
inline ios_base &dec(ios_base & __base) {
__base.setf(ios_base::dec, ios_base::basefield);
return __base;
}
inline ios_base &hex(ios_base & __base) {
__base.setf(ios_base::hex, ios_base::basefield);
return __base;
}
inline ios_base &oct(ios_base & __base) {
__base.setf(ios_base::oct, ios_base::basefield);
return __base;
}
inline ios_base &fixed(ios_base & __base) {
__base.setf(ios_base::fixed, ios_base::floatfield);
return __base;
}
inline ios_base &scientific(ios_base & __base) {
__base.setf(ios_base::scientific, ios_base::floatfield);
return __base;
}
}
# 43 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ios" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 1 3
# 37 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _CharT, typename _Traits>
streamsize __copy_streambufs_eof(basic_streambuf<_CharT, _Traits> *,
basic_streambuf<_CharT, _Traits> *, bool &);
# 119 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
template <typename _CharT, typename _Traits> class basic_streambuf {
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_streambuf<char_type, traits_type> __streambuf_type;
friend class basic_ios<char_type, traits_type>;
friend class basic_istream<char_type, traits_type>;
friend class basic_ostream<char_type, traits_type>;
friend class istreambuf_iterator<char_type, traits_type>;
friend class ostreambuf_iterator<char_type, traits_type>;
friend streamsize __copy_streambufs_eof<>(basic_streambuf *,
basic_streambuf *, bool &);
template <bool _IsMove, typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
_CharT2 *>::__type
__copy_move_a2(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
_CharT2 *);
template <typename _CharT2>
friend typename __gnu_cxx::__enable_if<
__is_char<_CharT2>::__value, istreambuf_iterator<_CharT2> >::__type
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
const _CharT2 &);
template <typename _CharT2, typename _Traits2>
friend basic_istream<_CharT2, _Traits2> &
operator>>(basic_istream<_CharT2, _Traits2> &, _CharT2 *);
template <typename _CharT2, typename _Traits2, typename _Alloc>
friend basic_istream<_CharT2, _Traits2> &
operator>>(basic_istream<_CharT2, _Traits2> &,
basic_string<_CharT2, _Traits2, _Alloc> &);
template <typename _CharT2, typename _Traits2, typename _Alloc>
friend basic_istream<_CharT2, _Traits2> &
getline(basic_istream<_CharT2, _Traits2> &,
basic_string<_CharT2, _Traits2, _Alloc> &, _CharT2);
protected:
char_type *_M_in_beg;
char_type *_M_in_cur;
char_type *_M_in_end;
char_type *_M_out_beg;
char_type *_M_out_cur;
char_type *_M_out_end;
locale _M_buf_locale;
public:
virtual ~basic_streambuf() {}
# 208 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
locale pubimbue(const locale &__loc) {
locale __tmp(this->getloc());
this->imbue(__loc);
_M_buf_locale = __loc;
return __tmp;
}
# 225 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
locale getloc() const { return _M_buf_locale; }
# 238 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
basic_streambuf *pubsetbuf(char_type *__s, streamsize __n) {
return this->setbuf(__s, __n);
}
# 250 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
pos_type pubseekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode __mode =
ios_base::in | ios_base::out) {
return this->seekoff(__off, __way, __mode);
}
# 262 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
pos_type pubseekpos(pos_type __sp, ios_base::openmode __mode =
ios_base::in | ios_base::out) {
return this->seekpos(__sp, __mode);
}
int pubsync() { return this->sync(); }
# 283 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
streamsize in_avail() {
const streamsize __ret = this->egptr() - this->gptr();
return __ret ? __ret : this->showmanyc();
}
# 297 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
int_type snextc() {
int_type __ret = traits_type::eof();
if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(), __ret),
true))
__ret = this->sgetc();
return __ret;
}
# 315 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
int_type sbumpc() {
int_type __ret;
if (__builtin_expect(this->gptr() < this->egptr(), true)) {
__ret = traits_type::to_int_type(*this->gptr());
this->gbump(1);
} else
__ret = this->uflow();
return __ret;
}
# 337 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
int_type sgetc() {
int_type __ret;
if (__builtin_expect(this->gptr() < this->egptr(), true))
__ret = traits_type::to_int_type(*this->gptr());
else
__ret = this->underflow();
return __ret;
}
# 356 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
streamsize sgetn(char_type *__s, streamsize __n) {
return this->xsgetn(__s, __n);
}
# 371 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
int_type sputbackc(char_type __c) {
int_type __ret;
const bool __testpos = this->eback() < this->gptr();
if (__builtin_expect(
!__testpos || !traits_type::eq(__c, this->gptr()[-1]), false))
__ret = this->pbackfail(traits_type::to_int_type(__c));
else {
this->gbump(-1);
__ret = traits_type::to_int_type(*this->gptr());
}
return __ret;
}
# 396 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
int_type sungetc() {
int_type __ret;
if (__builtin_expect(this->eback() < this->gptr(), true)) {
this->gbump(-1);
__ret = traits_type::to_int_type(*this->gptr());
} else
__ret = this->pbackfail();
return __ret;
}
# 423 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
int_type sputc(char_type __c) {
int_type __ret;
if (__builtin_expect(this->pptr() < this->epptr(), true)) {
*this->pptr() = __c;
this->pbump(1);
__ret = traits_type::to_int_type(__c);
} else
__ret = this->overflow(traits_type::to_int_type(__c));
return __ret;
}
# 449 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
streamsize sputn(const char_type *__s, streamsize __n) {
return this->xsputn(__s, __n);
}
protected:
# 463 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
basic_streambuf()
: _M_in_beg(0), _M_in_cur(0), _M_in_end(0), _M_out_beg(0),
_M_out_cur(0), _M_out_end(0), _M_buf_locale(locale()) {}
# 481 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
char_type *eback() const { return _M_in_beg; }
char_type *gptr() const { return _M_in_cur; }
char_type *egptr() const { return _M_in_end; }
# 497 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
void gbump(int __n) { _M_in_cur += __n; }
# 508 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
void setg(char_type *__gbeg, char_type *__gnext, char_type *__gend) {
_M_in_beg = __gbeg;
_M_in_cur = __gnext;
_M_in_end = __gend;
}
# 528 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
char_type *pbase() const { return _M_out_beg; }
char_type *pptr() const { return _M_out_cur; }
char_type *epptr() const { return _M_out_end; }
# 544 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
void pbump(int __n) { _M_out_cur += __n; }
# 554 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
void setp(char_type *__pbeg, char_type *__pend) {
_M_out_beg = _M_out_cur = __pbeg;
_M_out_end = __pend;
}
# 575 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
virtual void imbue(const locale &__loc) {}
# 590 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
virtual basic_streambuf<char_type, _Traits> *setbuf(char_type *,
streamsize) {
return this;
}
# 601 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
virtual pos_type seekoff(off_type, ios_base::seekdir,
ios_base::openmode = ios_base::in |
ios_base::out) {
return pos_type(off_type(-1));
}
# 613 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
virtual pos_type seekpos(pos_type, ios_base::openmode = ios_base::in |
ios_base::out) {
return pos_type(off_type(-1));
}
# 626 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
virtual int sync() { return 0; }
# 648 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
virtual streamsize showmanyc() { return 0; }
# 664 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
virtual streamsize xsgetn(char_type *__s, streamsize __n);
# 686 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
virtual int_type underflow() { return traits_type::eof(); }
# 699 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
virtual int_type uflow() {
int_type __ret = traits_type::eof();
const bool __testeof = traits_type::eq_int_type(this->underflow(), __ret);
if (!__testeof) {
__ret = traits_type::to_int_type(*this->gptr());
this->gbump(1);
}
return __ret;
}
# 723 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
virtual int_type pbackfail(int_type __c = traits_type::eof()) {
return traits_type::eof();
}
# 741 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
virtual streamsize xsputn(const char_type *__s, streamsize __n);
# 767 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
virtual int_type overflow(int_type __c = traits_type::eof()) {
return traits_type::eof();
}
public:
# 782 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 3
void stossc() {
if (this->gptr() < this->egptr())
this->gbump(1);
else
this->uflow();
}
void __safe_gbump(streamsize __n) { _M_in_cur += __n; }
void __safe_pbump(streamsize __n) { _M_out_cur += __n; }
private:
basic_streambuf(const basic_streambuf &__sb)
: _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur),
_M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg),
_M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur),
_M_buf_locale(__sb._M_buf_locale) {}
basic_streambuf &operator=(const basic_streambuf &) {
return *this;
};
};
template <>
streamsize __copy_streambufs_eof(basic_streambuf<char> * __sbin,
basic_streambuf<char> * __sbout,
bool & __ineof);
template <>
streamsize __copy_streambufs_eof(basic_streambuf<wchar_t> * __sbin,
basic_streambuf<wchar_t> * __sbout,
bool & __ineof);
}
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/streambuf.tcc" 1 3
# 38 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/streambuf.tcc" 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _CharT, typename _Traits>
streamsize basic_streambuf<_CharT, _Traits>::xsgetn(char_type * __s,
streamsize __n) {
streamsize __ret = 0;
while (__ret < __n) {
const streamsize __buf_len = this->egptr() - this->gptr();
if (__buf_len) {
const streamsize __remaining = __n - __ret;
const streamsize __len = std::min(__buf_len, __remaining);
traits_type::copy(__s, this->gptr(), __len);
__ret += __len;
__s += __len;
this->__safe_gbump(__len);
}
if (__ret < __n) {
const int_type __c = this->uflow();
if (!traits_type::eq_int_type(__c, traits_type::eof())) {
traits_type::assign(*__s++, traits_type::to_char_type(__c));
++__ret;
} else
break;
}
}
return __ret;
}
template <typename _CharT, typename _Traits>
streamsize basic_streambuf<_CharT, _Traits>::xsputn(const char_type * __s,
streamsize __n) {
streamsize __ret = 0;
while (__ret < __n) {
const streamsize __buf_len = this->epptr() - this->pptr();
if (__buf_len) {
const streamsize __remaining = __n - __ret;
const streamsize __len = std::min(__buf_len, __remaining);
traits_type::copy(this->pptr(), __s, __len);
__ret += __len;
__s += __len;
this->__safe_pbump(__len);
}
if (__ret < __n) {
int_type __c = this->overflow(traits_type::to_int_type(*__s));
if (!traits_type::eq_int_type(__c, traits_type::eof())) {
++__ret;
++__s;
} else
break;
}
}
return __ret;
}
template <typename _CharT, typename _Traits>
streamsize __copy_streambufs_eof(basic_streambuf<_CharT, _Traits> * __sbin,
basic_streambuf<_CharT, _Traits> * __sbout,
bool & __ineof) {
streamsize __ret = 0;
__ineof = true;
typename _Traits::int_type __c = __sbin->sgetc();
while (!_Traits::eq_int_type(__c, _Traits::eof())) {
__c = __sbout->sputc(_Traits::to_char_type(__c));
if (_Traits::eq_int_type(__c, _Traits::eof())) {
__ineof = false;
break;
}
++__ret;
__c = __sbin->snextc();
}
return __ret;
}
template <typename _CharT, typename _Traits>
inline streamsize __copy_streambufs(basic_streambuf<_CharT, _Traits> * __sbin,
basic_streambuf<_CharT, _Traits> *
__sbout) {
bool __ineof;
return __copy_streambufs_eof(__sbin, __sbout, __ineof);
}
extern template class basic_streambuf<char>;
extern template streamsize __copy_streambufs(basic_streambuf<char> *,
basic_streambuf<char> *);
extern template streamsize __copy_streambufs_eof(
basic_streambuf<char> *, basic_streambuf<char> *, bool &);
extern template class basic_streambuf<wchar_t>;
extern template streamsize __copy_streambufs(basic_streambuf<wchar_t> *,
basic_streambuf<wchar_t> *);
extern template streamsize __copy_streambufs_eof(
basic_streambuf<wchar_t> *, basic_streambuf<wchar_t> *, bool &);
}
# 829 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/streambuf" 2 3
# 44 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ios" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 1 3
# 38 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cwctype" 1 3
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cwctype" 3
# 50 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cwctype" 3
# 1 "/usr/include/wctype.h" 1 3 4
# 36 "/usr/include/wctype.h" 3 4
# 1 "/usr/include/_types/_wctrans_t.h" 1 3 4
# 31 "/usr/include/_types/_wctrans_t.h" 3 4
typedef __darwin_wctrans_t wctrans_t;
# 37 "/usr/include/wctype.h" 2 3 4
# 49 "/usr/include/wctype.h" 3 4
inline int iswblank(wint_t _wc) { return (__istype(_wc, 0x00020000L)); }
inline int iswascii(wint_t _wc) { return ((_wc & ~0x7F) == 0); }
inline int iswhexnumber(wint_t _wc) { return (__istype(_wc, 0x00010000L)); }
inline int iswideogram(wint_t _wc) { return (__istype(_wc, 0x00080000L)); }
inline int iswnumber(wint_t _wc) { return (__istype(_wc, 0x00000400L)); }
inline int iswphonogram(wint_t _wc) { return (__istype(_wc, 0x00200000L)); }
inline int iswrune(wint_t _wc) { return (__istype(_wc, 0xFFFFFFF0L)); }
inline int iswspecial(wint_t _wc) { return (__istype(_wc, 0x00100000L)); }
# 117 "/usr/include/wctype.h" 3 4
extern "C" {
wint_t nextwctype(wint_t, wctype_t);
wint_t towctrans(wint_t, wctrans_t);
wctrans_t wctrans(const char *);
}
# 51 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cwctype" 2 3
# 80 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cwctype" 3
namespace std {
using ::wctrans_t;
using ::wctype_t;
using ::wint_t;
using ::iswalnum;
using ::iswalpha;
using ::iswblank;
using ::iswcntrl;
using ::iswctype;
using ::iswdigit;
using ::iswgraph;
using ::iswlower;
using ::iswprint;
using ::iswpunct;
using ::iswspace;
using ::iswupper;
using ::iswxdigit;
using ::towctrans;
using ::towlower;
using ::towupper;
using ::wctrans;
using ::wctype;
}
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cctype" 1 3
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cctype" 3
# 41 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/ctype_base.h" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/ctype_base.h" 3
namespace std __attribute__((__visibility__("default"))) {
struct ctype_base {
typedef const int *__to_type;
typedef unsigned long mask;
static const mask upper = 0x00008000L;
static const mask lower = 0x00001000L;
static const mask alpha = 0x00000100L;
static const mask digit = 0x00000400L;
static const mask xdigit = 0x00010000L;
static const mask space = 0x00004000L;
static const mask print = 0x00040000L;
static const mask graph = 0x00000100L | 0x00000400L | 0x00002000L;
static const mask cntrl = 0x00000200L;
static const mask punct = 0x00002000L;
static const mask alnum = 0x00000100L | 0x00000400L;
# 71 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/ctype_base.h" 3
};
}
# 42 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/streambuf_iterator.h" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/streambuf_iterator.h" 3
namespace std __attribute__((__visibility__("default"))) {
# 49 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/streambuf_iterator.h" 3
template <typename _CharT, typename _Traits>
class istreambuf_iterator
: public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
_CharT *, _CharT> {
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename _Traits::int_type int_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_istream<_CharT, _Traits> istream_type;
template <typename _CharT2>
friend typename __gnu_cxx::__enable_if<
__is_char<_CharT2>::__value, ostreambuf_iterator<_CharT2> >::__type
copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
ostreambuf_iterator<_CharT2>);
template <bool _IsMove, typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
_CharT2 *>::__type
__copy_move_a2(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
_CharT2 *);
template <typename _CharT2>
friend typename __gnu_cxx::__enable_if<
__is_char<_CharT2>::__value, istreambuf_iterator<_CharT2> >::__type
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
const _CharT2 &);
private:
mutable streambuf_type *_M_sbuf;
mutable int_type _M_c;
public:
constexpr istreambuf_iterator() noexcept : _M_sbuf(0),
_M_c(traits_type::eof()) {}
istreambuf_iterator(const istreambuf_iterator &) noexcept = default;
~istreambuf_iterator() = default;
istreambuf_iterator(istream_type &__s) noexcept : _M_sbuf(__s.rdbuf()),
_M_c(traits_type::eof()) {
}
istreambuf_iterator(streambuf_type *__s) noexcept
: _M_sbuf(__s),
_M_c(traits_type::eof()) {}
char_type operator*() const { return traits_type::to_char_type(_M_get()); }
istreambuf_iterator &operator++() {
;
if (_M_sbuf) {
_M_sbuf->sbumpc();
_M_c = traits_type::eof();
}
return *this;
}
istreambuf_iterator operator++(int) {
;
istreambuf_iterator __old = *this;
if (_M_sbuf) {
__old._M_c = _M_sbuf->sbumpc();
_M_c = traits_type::eof();
}
return __old;
}
bool equal(const istreambuf_iterator &__b) const {
return _M_at_eof() == __b._M_at_eof();
}
private:
int_type _M_get() const {
const int_type __eof = traits_type::eof();
int_type __ret = __eof;
if (_M_sbuf) {
if (!traits_type::eq_int_type(_M_c, __eof))
__ret = _M_c;
else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()), __eof))
_M_c = __ret;
else
_M_sbuf = 0;
}
return __ret;
}
bool _M_at_eof() const {
const int_type __eof = traits_type::eof();
return traits_type::eq_int_type(_M_get(), __eof);
}
};
template <typename _CharT, typename _Traits>
inline bool operator==(const istreambuf_iterator<_CharT, _Traits> & __a,
const istreambuf_iterator<_CharT, _Traits> & __b) {
return __a.equal(__b);
}
template <typename _CharT, typename _Traits>
inline bool operator!=(const istreambuf_iterator<_CharT, _Traits> & __a,
const istreambuf_iterator<_CharT, _Traits> & __b) {
return !__a.equal(__b);
}
template <typename _CharT, typename _Traits>
class ostreambuf_iterator
: public iterator<output_iterator_tag, void, void, void, void> {
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_ostream<_CharT, _Traits> ostream_type;
template <typename _CharT2>
friend typename __gnu_cxx::__enable_if<
__is_char<_CharT2>::__value, ostreambuf_iterator<_CharT2> >::__type
copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
ostreambuf_iterator<_CharT2>);
private:
streambuf_type *_M_sbuf;
bool _M_failed;
public:
ostreambuf_iterator(ostream_type &__s) noexcept : _M_sbuf(__s.rdbuf()),
_M_failed(!_M_sbuf) {}
ostreambuf_iterator(streambuf_type *__s) noexcept : _M_sbuf(__s),
_M_failed(!_M_sbuf) {}
ostreambuf_iterator &operator=(_CharT __c) {
if (!_M_failed &&
_Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
_M_failed = true;
return *this;
}
ostreambuf_iterator &operator*() { return *this; }
ostreambuf_iterator &operator++(int) { return *this; }
ostreambuf_iterator &operator++() { return *this; }
bool failed() const noexcept { return _M_failed; }
ostreambuf_iterator &_M_put(const _CharT *__ws, streamsize __len) {
if (__builtin_expect(!_M_failed, true) &&
__builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len, false))
_M_failed = true;
return *this;
}
};
template <typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
copy(istreambuf_iterator<_CharT> __first, istreambuf_iterator<_CharT> __last,
ostreambuf_iterator<_CharT> __result) {
if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed) {
bool __ineof;
__copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
if (!__ineof)
__result._M_failed = true;
}
return __result;
}
template <bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
__copy_move_a2(_CharT * __first, _CharT * __last,
ostreambuf_iterator<_CharT> __result) {
const streamsize __num = __last - __first;
if (__num > 0)
__result._M_put(__first, __num);
return __result;
}
template <bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
__copy_move_a2(const _CharT * __first, const _CharT * __last,
ostreambuf_iterator<_CharT> __result) {
const streamsize __num = __last - __first;
if (__num > 0)
__result._M_put(__first, __num);
return __result;
}
template <bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, _CharT *>::__type
__copy_move_a2(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last, _CharT * __result) {
typedef istreambuf_iterator<_CharT> __is_iterator_type;
typedef typename __is_iterator_type::traits_type traits_type;
typedef typename __is_iterator_type::streambuf_type streambuf_type;
typedef typename traits_type::int_type int_type;
if (__first._M_sbuf && !__last._M_sbuf) {
streambuf_type *__sb = __first._M_sbuf;
int_type __c = __sb->sgetc();
while (!traits_type::eq_int_type(__c, traits_type::eof())) {
const streamsize __n = __sb->egptr() - __sb->gptr();
if (__n > 1) {
traits_type::copy(__result, __sb->gptr(), __n);
__sb->__safe_gbump(__n);
__result += __n;
__c = __sb->underflow();
} else {
*__result++ = traits_type::to_char_type(__c);
__c = __sb->snextc();
}
}
}
return __result;
}
template <typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
istreambuf_iterator<_CharT> >::__type
find(istreambuf_iterator<_CharT> __first, istreambuf_iterator<_CharT> __last,
const _CharT & __val) {
typedef istreambuf_iterator<_CharT> __is_iterator_type;
typedef typename __is_iterator_type::traits_type traits_type;
typedef typename __is_iterator_type::streambuf_type streambuf_type;
typedef typename traits_type::int_type int_type;
if (__first._M_sbuf && !__last._M_sbuf) {
const int_type __ival = traits_type::to_int_type(__val);
streambuf_type *__sb = __first._M_sbuf;
int_type __c = __sb->sgetc();
while (!traits_type::eq_int_type(__c, traits_type::eof()) &&
!traits_type::eq_int_type(__c, __ival)) {
streamsize __n = __sb->egptr() - __sb->gptr();
if (__n > 1) {
const _CharT *__p = traits_type::find(__sb->gptr(), __n, __val);
if (__p)
__n = __p - __sb->gptr();
__sb->__safe_gbump(__n);
__c = __sb->sgetc();
} else
__c = __sb->snextc();
}
if (!traits_type::eq_int_type(__c, traits_type::eof()))
__first._M_c = __c;
else
__first._M_sbuf = 0;
}
return __first;
}
}
# 49 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 64 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
template <typename _Tp>
void __convert_to_v(const char *, _Tp &, ios_base::iostate &,
const __c_locale &)throw();
template <>
void __convert_to_v(const char *, float &, ios_base::iostate &,
const __c_locale &)throw();
template <>
void __convert_to_v(const char *, double &, ios_base::iostate &,
const __c_locale &)throw();
template <>
void __convert_to_v(const char *, long double &, ios_base::iostate &,
const __c_locale &)throw();
template <typename _CharT, typename _Traits> struct __pad {
static void _S_pad(ios_base &__io, _CharT __fill, _CharT *__news,
const _CharT *__olds, streamsize __newlen,
streamsize __oldlen);
};
template <typename _CharT>
_CharT *__add_grouping(_CharT * __s, _CharT __sep, const char * __gbeg,
size_t __gsize, const _CharT * __first,
const _CharT * __last);
template <typename _CharT>
inline ostreambuf_iterator<_CharT> __write(ostreambuf_iterator<_CharT> __s,
const _CharT * __ws, int __len) {
__s._M_put(__ws, __len);
return __s;
}
template <typename _CharT, typename _OutIter>
inline _OutIter __write(_OutIter __s, const _CharT * __ws, int __len) {
for (int __j = 0; __j < __len; __j++, ++__s)
*__s = __ws[__j];
return __s;
}
# 142 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
template <typename _CharT>
class __ctype_abstract_base : public locale::facet, public ctype_base {
public:
typedef _CharT char_type;
# 161 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
bool is(mask __m, char_type __c) const { return this->do_is(__m, __c); }
# 178 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
const char_type *is(const char_type *__lo, const char_type *__hi,
mask *__vec) const {
return this->do_is(__lo, __hi, __vec);
}
# 194 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
const char_type *scan_is(mask __m, const char_type *__lo,
const char_type *__hi) const {
return this->do_scan_is(__m, __lo, __hi);
}
# 210 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
const char_type *scan_not(mask __m, const char_type *__lo,
const char_type *__hi) const {
return this->do_scan_not(__m, __lo, __hi);
}
# 224 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
char_type toupper(char_type __c) const { return this->do_toupper(__c); }
# 239 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
const char_type *toupper(char_type *__lo, const char_type *__hi) const {
return this->do_toupper(__lo, __hi);
}
# 253 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
char_type tolower(char_type __c) const { return this->do_tolower(__c); }
# 268 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
const char_type *tolower(char_type *__lo, const char_type *__hi) const {
return this->do_tolower(__lo, __hi);
}
# 285 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
char_type widen(char __c) const { return this->do_widen(__c); }
# 304 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
const char *widen(const char *__lo, const char *__hi,
char_type *__to) const {
return this->do_widen(__lo, __hi, __to);
}
# 323 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
char narrow(char_type __c, char __dfault) const {
return this->do_narrow(__c, __dfault);
}
# 345 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
const char_type *narrow(const char_type *__lo, const char_type *__hi,
char __dfault, char *__to) const {
return this->do_narrow(__lo, __hi, __dfault, __to);
}
protected:
explicit __ctype_abstract_base(size_t __refs = 0) : facet(__refs) {}
virtual ~__ctype_abstract_base() {}
# 370 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual bool do_is(mask __m, char_type __c) const = 0;
# 389 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char_type *do_is(const char_type *__lo, const char_type *__hi,
mask *__vec) const = 0;
# 408 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char_type *do_scan_is(mask __m, const char_type *__lo,
const char_type *__hi) const = 0;
# 427 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char_type *do_scan_not(mask __m, const char_type *__lo,
const char_type *__hi) const = 0;
# 445 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual char_type do_toupper(char_type __c) const = 0;
# 462 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char_type *do_toupper(char_type *__lo,
const char_type *__hi) const = 0;
# 478 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual char_type do_tolower(char_type __c) const = 0;
# 495 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char_type *do_tolower(char_type *__lo,
const char_type *__hi) const = 0;
# 514 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual char_type do_widen(char __c) const = 0;
# 535 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char *do_widen(const char *__lo, const char *__hi,
char_type *__to) const = 0;
# 556 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual char do_narrow(char_type __c, char __dfault) const = 0;
# 581 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char_type *do_narrow(const char_type *__lo,
const char_type *__hi, char __dfault,
char *__to) const = 0;
};
# 604 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
template <typename _CharT>
class ctype : public __ctype_abstract_base<_CharT> {
public:
typedef _CharT char_type;
typedef typename __ctype_abstract_base<_CharT>::mask mask;
static locale::id id;
explicit ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) {}
protected:
virtual ~ctype();
virtual bool do_is(mask __m, char_type __c) const;
virtual const char_type *do_is(const char_type *__lo, const char_type *__hi,
mask *__vec) const;
virtual const char_type *do_scan_is(mask __m, const char_type *__lo,
const char_type *__hi) const;
virtual const char_type *do_scan_not(mask __m, const char_type *__lo,
const char_type *__hi) const;
virtual char_type do_toupper(char_type __c) const;
virtual const char_type *do_toupper(char_type *__lo,
const char_type *__hi) const;
virtual char_type do_tolower(char_type __c) const;
virtual const char_type *do_tolower(char_type *__lo,
const char_type *__hi) const;
virtual char_type do_widen(char __c) const;
virtual const char *do_widen(const char *__lo, const char *__hi,
char_type *__dest) const;
virtual char do_narrow(char_type, char __dfault) const;
virtual const char_type *do_narrow(const char_type *__lo,
const char_type *__hi, char __dfault,
char *__to) const;
};
template <typename _CharT> locale::id ctype<_CharT>::id;
# 673 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
template <> class ctype<char> : public locale::facet, public ctype_base {
public:
typedef char char_type;
protected:
__c_locale _M_c_locale_ctype;
bool _M_del;
__to_type _M_toupper;
__to_type _M_tolower;
const mask *_M_table;
mutable char _M_widen_ok;
mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
mutable char _M_narrow_ok;
public:
static locale::id id;
static const size_t table_size = 1 + static_cast<unsigned char>(-1);
# 710 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
explicit ctype(const mask *__table = 0, bool __del = false,
size_t __refs = 0);
# 723 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
explicit ctype(__c_locale __cloc, const mask *__table = 0,
bool __del = false, size_t __refs = 0);
# 736 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
inline bool is(mask __m, char __c) const;
# 751 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
inline const char *is(const char *__lo, const char *__hi,
mask *__vec) const;
# 765 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
inline const char *scan_is(mask __m, const char *__lo,
const char *__hi) const;
# 779 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
inline const char *scan_not(mask __m, const char *__lo,
const char *__hi) const;
# 794 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
char_type toupper(char_type __c) const { return this->do_toupper(__c); }
# 811 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
const char_type *toupper(char_type *__lo, const char_type *__hi) const {
return this->do_toupper(__lo, __hi);
}
# 827 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
char_type tolower(char_type __c) const { return this->do_tolower(__c); }
# 844 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
const char_type *tolower(char_type *__lo, const char_type *__hi) const {
return this->do_tolower(__lo, __hi);
}
# 864 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
char_type widen(char __c) const {
if (_M_widen_ok)
return _M_widen[static_cast<unsigned char>(__c)];
this->_M_widen_init();
return this->do_widen(__c);
}
# 891 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
const char *widen(const char *__lo, const char *__hi,
char_type *__to) const {
if (_M_widen_ok == 1) {
__builtin_memcpy(__to, __lo, __hi - __lo);
return __hi;
}
if (!_M_widen_ok)
_M_widen_init();
return this->do_widen(__lo, __hi, __to);
}
# 922 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
char narrow(char_type __c, char __dfault) const {
if (_M_narrow[static_cast<unsigned char>(__c)])
return _M_narrow[static_cast<unsigned char>(__c)];
const char __t = do_narrow(__c, __dfault);
if (__t != __dfault)
_M_narrow[static_cast<unsigned char>(__c)] = __t;
return __t;
}
# 955 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
const char_type *narrow(const char_type *__lo, const char_type *__hi,
char __dfault, char *__to) const {
if (__builtin_expect(_M_narrow_ok == 1, true)) {
__builtin_memcpy(__to, __lo, __hi - __lo);
return __hi;
}
if (!_M_narrow_ok)
_M_narrow_init();
return this->do_narrow(__lo, __hi, __dfault, __to);
}
const mask *table() const throw() { return _M_table; }
static const mask *classic_table() throw();
protected:
virtual ~ctype();
# 1004 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual char_type do_toupper(char_type __c) const;
# 1021 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char_type *do_toupper(char_type *__lo,
const char_type *__hi) const;
# 1037 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual char_type do_tolower(char_type __c) const;
# 1054 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char_type *do_tolower(char_type *__lo,
const char_type *__hi) const;
# 1074 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual char_type do_widen(char __c) const { return __c; }
# 1097 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char *do_widen(const char *__lo, const char *__hi,
char_type *__to) const {
__builtin_memcpy(__to, __lo, __hi - __lo);
return __hi;
}
# 1123 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual char do_narrow(char_type __c, char __dfault) const { return __c; }
# 1149 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char_type *do_narrow(const char_type *__lo,
const char_type *__hi, char __dfault,
char *__to) const {
__builtin_memcpy(__to, __lo, __hi - __lo);
return __hi;
}
private:
void _M_narrow_init() const;
void _M_widen_init() const;
};
# 1174 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
template <> class ctype<wchar_t> : public __ctype_abstract_base<wchar_t> {
public:
typedef wchar_t char_type;
typedef wctype_t __wmask_type;
protected:
__c_locale _M_c_locale_ctype;
bool _M_narrow_ok;
char _M_narrow[128];
wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
mask _M_bit[16];
__wmask_type _M_wmask[16];
public:
static locale::id id;
# 1207 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
explicit ctype(size_t __refs = 0);
# 1218 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
explicit ctype(__c_locale __cloc, size_t __refs = 0);
protected:
__wmask_type _M_convert_to_wmask(const mask __m) const throw();
virtual ~ctype();
# 1242 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual bool do_is(mask __m, char_type __c) const;
# 1261 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char_type *do_is(const char_type *__lo, const char_type *__hi,
mask *__vec) const;
# 1279 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char_type *do_scan_is(mask __m, const char_type *__lo,
const char_type *__hi) const;
# 1297 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char_type *do_scan_not(mask __m, const char_type *__lo,
const char_type *__hi) const;
# 1314 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual char_type do_toupper(char_type __c) const;
# 1331 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char_type *do_toupper(char_type *__lo,
const char_type *__hi) const;
# 1347 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual char_type do_tolower(char_type __c) const;
# 1364 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char_type *do_tolower(char_type *__lo,
const char_type *__hi) const;
# 1384 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual char_type do_widen(char __c) const;
# 1406 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char *do_widen(const char *__lo, const char *__hi,
char_type *__to) const;
# 1429 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual char do_narrow(char_type __c, char __dfault) const;
# 1455 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual const char_type *do_narrow(const char_type *__lo,
const char_type *__hi, char __dfault,
char *__to) const;
void _M_initialize_ctype() throw();
};
template <typename _CharT> class ctype_byname : public ctype<_CharT> {
public:
typedef typename ctype<_CharT>::mask mask;
explicit ctype_byname(const char *__s, size_t __refs = 0);
protected:
virtual ~ctype_byname() {};
};
template <> class ctype_byname<char> : public ctype<char> {
public:
explicit ctype_byname(const char *__s, size_t __refs = 0);
protected:
virtual ~ctype_byname();
};
template <> class ctype_byname<wchar_t> : public ctype<wchar_t> {
public:
explicit ctype_byname(const char *__s, size_t __refs = 0);
protected:
virtual ~ctype_byname();
};
}
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/ctype_inline.h" 1 3
# 37 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/ctype_inline.h" 3
namespace std __attribute__((__visibility__("default"))) {
bool ctype<char>::is(mask __m, char __c) const {
if (_M_table)
return _M_table[static_cast<unsigned char>(__c)] & __m;
else
return __istype(__c, __m);
}
const char *ctype<char>::is(const char * __low, const char * __high,
mask * __vec) const {
if (_M_table)
while (__low < __high)
*__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
else
for (; __low < __high; ++__vec, ++__low) {
*__vec =
__maskrune(*__low, upper | lower | alpha | digit | xdigit | space |
print | graph | cntrl | punct | alnum);
# 80 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/ctype_inline.h" 3
}
return __high;
}
const char *ctype<char>::scan_is(mask __m, const char * __low,
const char * __high) const {
if (_M_table)
while (__low < __high &&
!(_M_table[static_cast<unsigned char>(*__low)] & __m))
++__low;
else
while (__low < __high && !this->is(__m, *__low))
++__low;
return __low;
}
const char *ctype<char>::scan_not(mask __m, const char * __low,
const char * __high) const {
if (_M_table)
while (__low < __high &&
(_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
++__low;
else
while (__low < __high && this->is(__m, *__low) != 0)
++__low;
return __low;
}
inline bool ctype<wchar_t>::do_is(mask __m, wchar_t __c) const {
return __istype(__c, __m);
}
inline const wchar_t *ctype<wchar_t>::do_is(
const wchar_t * __lo, const wchar_t * __hi, mask * __vec) const {
for (; __lo < __hi; ++__vec, ++__lo)
*__vec =
__maskrune(*__lo, upper | lower | alpha | digit | xdigit | space |
print | graph | cntrl | punct | alnum);
return __hi;
}
inline const wchar_t *ctype<wchar_t>::do_scan_is(
mask __m, const wchar_t * __lo, const wchar_t * __hi) const {
while (__lo < __hi && !__istype(*__lo, __m))
++__lo;
return __lo;
}
inline const wchar_t *ctype<wchar_t>::do_scan_not(
mask __m, const char_type * __lo, const char_type * __hi) const {
while (__lo < __hi && __istype(*__lo, __m))
++__lo;
return __lo;
}
}
# 1512 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
class __num_base {
public:
enum {
_S_ominus,
_S_oplus,
_S_ox,
_S_oX,
_S_odigits,
_S_odigits_end = _S_odigits + 16,
_S_oudigits = _S_odigits_end,
_S_oudigits_end = _S_oudigits + 16,
_S_oe = _S_odigits + 14,
_S_oE = _S_oudigits + 14,
_S_oend = _S_oudigits_end
};
static const char *_S_atoms_out;
static const char *_S_atoms_in;
enum {
_S_iminus,
_S_iplus,
_S_ix,
_S_iX,
_S_izero,
_S_ie = _S_izero + 14,
_S_iE = _S_izero + 20,
_S_iend = 26
};
static void _S_format_float(const ios_base &__io, char *__fptr,
char __mod) throw();
};
template <typename _CharT> struct __numpunct_cache : public locale::facet {
const char *_M_grouping;
size_t _M_grouping_size;
bool _M_use_grouping;
const _CharT *_M_truename;
size_t _M_truename_size;
const _CharT *_M_falsename;
size_t _M_falsename_size;
_CharT _M_decimal_point;
_CharT _M_thousands_sep;
_CharT _M_atoms_out[__num_base::_S_oend];
_CharT _M_atoms_in[__num_base::_S_iend];
bool _M_allocated;
__numpunct_cache(size_t __refs = 0)
: facet(__refs), _M_grouping(0), _M_grouping_size(0),
_M_use_grouping(false), _M_truename(0), _M_truename_size(0),
_M_falsename(0), _M_falsename_size(0), _M_decimal_point(_CharT()),
_M_thousands_sep(_CharT()), _M_allocated(false) {}
~__numpunct_cache();
void _M_cache(const locale &__loc);
private:
__numpunct_cache &operator=(const __numpunct_cache &);
explicit __numpunct_cache(const __numpunct_cache &);
};
template <typename _CharT> __numpunct_cache<_CharT>::~__numpunct_cache() {
if (_M_allocated) {
delete[] _M_grouping;
delete[] _M_truename;
delete[] _M_falsename;
}
}
# 1640 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
template <typename _CharT> class numpunct : public locale::facet {
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
typedef __numpunct_cache<_CharT> __cache_type;
protected:
__cache_type *_M_data;
public:
static locale::id id;
explicit numpunct(size_t __refs = 0) : facet(__refs), _M_data(0) {
_M_initialize_numpunct();
}
# 1678 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
explicit numpunct(__cache_type *__cache, size_t __refs = 0)
: facet(__refs), _M_data(__cache) {
_M_initialize_numpunct();
}
# 1692 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
explicit numpunct(__c_locale __cloc, size_t __refs = 0)
: facet(__refs), _M_data(0) {
_M_initialize_numpunct(__cloc);
}
# 1706 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
char_type decimal_point() const { return this->do_decimal_point(); }
# 1719 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
char_type thousands_sep() const { return this->do_thousands_sep(); }
# 1750 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
string grouping() const { return this->do_grouping(); }
# 1763 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
string_type truename() const { return this->do_truename(); }
# 1776 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
string_type falsename() const { return this->do_falsename(); }
protected:
virtual ~numpunct();
# 1793 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual char_type do_decimal_point() const {
return _M_data->_M_decimal_point;
}
# 1805 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual char_type do_thousands_sep() const {
return _M_data->_M_thousands_sep;
}
# 1818 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual string do_grouping() const { return _M_data->_M_grouping; }
# 1831 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual string_type do_truename() const { return _M_data->_M_truename; }
# 1844 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual string_type do_falsename() const { return _M_data->_M_falsename; }
void _M_initialize_numpunct(__c_locale __cloc = 0);
};
template <typename _CharT> locale::id numpunct<_CharT>::id;
template <> numpunct<char>::~numpunct();
template <> void numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
template <> numpunct<wchar_t>::~numpunct();
template <> void numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
template <typename _CharT> class numpunct_byname : public numpunct<_CharT> {
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
explicit numpunct_byname(const char *__s, size_t __refs = 0)
: numpunct<_CharT>(__refs) {
if (__builtin_strcmp(__s, "C") != 0 &&
__builtin_strcmp(__s, "POSIX") != 0) {
__c_locale __tmp;
this->_S_create_c_locale(__tmp, __s);
this->_M_initialize_numpunct(__tmp);
this->_S_destroy_c_locale(__tmp);
}
}
protected:
virtual ~numpunct_byname() {}
};
# 1914 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
template <typename _CharT, typename _InIter>
class num_get : public locale::facet {
public:
typedef _CharT char_type;
typedef _InIter iter_type;
static locale::id id;
# 1935 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
explicit num_get(size_t __refs = 0) : facet(__refs) {}
# 1961 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
iter_type get(iter_type __in, iter_type __end, ios_base &__io,
ios_base::iostate &__err, bool &__v) const {
return this->do_get(__in, __end, __io, __err, __v);
}
# 1998 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
iter_type get(iter_type __in, iter_type __end, ios_base &__io,
ios_base::iostate &__err, long &__v) const {
return this->do_get(__in, __end, __io, __err, __v);
}
iter_type get(iter_type __in, iter_type __end, ios_base &__io,
ios_base::iostate &__err, unsigned short &__v) const {
return this->do_get(__in, __end, __io, __err, __v);
}
iter_type get(iter_type __in, iter_type __end, ios_base &__io,
ios_base::iostate &__err, unsigned int &__v) const {
return this->do_get(__in, __end, __io, __err, __v);
}
iter_type get(iter_type __in, iter_type __end, ios_base &__io,
ios_base::iostate &__err, unsigned long &__v) const {
return this->do_get(__in, __end, __io, __err, __v);
}
iter_type get(iter_type __in, iter_type __end, ios_base &__io,
ios_base::iostate &__err, long long &__v) const {
return this->do_get(__in, __end, __io, __err, __v);
}
iter_type get(iter_type __in, iter_type __end, ios_base &__io,
ios_base::iostate &__err, unsigned long long &__v) const {
return this->do_get(__in, __end, __io, __err, __v);
}
# 2058 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
iter_type get(iter_type __in, iter_type __end, ios_base &__io,
ios_base::iostate &__err, float &__v) const {
return this->do_get(__in, __end, __io, __err, __v);
}
iter_type get(iter_type __in, iter_type __end, ios_base &__io,
ios_base::iostate &__err, double &__v) const {
return this->do_get(__in, __end, __io, __err, __v);
}
iter_type get(iter_type __in, iter_type __end, ios_base &__io,
ios_base::iostate &__err, long double &__v) const {
return this->do_get(__in, __end, __io, __err, __v);
}
# 2101 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
iter_type get(iter_type __in, iter_type __end, ios_base &__io,
ios_base::iostate &__err, void *&__v) const {
return this->do_get(__in, __end, __io, __err, __v);
}
protected:
virtual ~num_get() {}
iter_type _M_extract_float(iter_type, iter_type, ios_base &,
ios_base::iostate &, string &) const;
template <typename _ValueT>
iter_type _M_extract_int(iter_type, iter_type, ios_base &,
ios_base::iostate &, _ValueT &) const;
template <typename _CharT2>
typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
_M_find(const _CharT2 *, size_t __len, _CharT2 __c) const {
int __ret = -1;
if (__len <= 10) {
if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
__ret = __c - _CharT2('0');
} else {
if (__c >= _CharT2('0') && __c <= _CharT2('9'))
__ret = __c - _CharT2('0');
else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
__ret = 10 + (__c - _CharT2('a'));
else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
__ret = 10 + (__c - _CharT2('A'));
}
return __ret;
}
template <typename _CharT2>
typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value, int>::__type
_M_find(const _CharT2 *__zero, size_t __len, _CharT2 __c) const {
int __ret = -1;
const char_type *__q = char_traits<_CharT2>::find(__zero, __len, __c);
if (__q) {
__ret = __q - __zero;
if (__ret > 15)
__ret -= 6;
}
return __ret;
}
# 2172 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual iter_type do_get(iter_type, iter_type, ios_base &,
ios_base::iostate &, bool &) const;
virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base &__io,
ios_base::iostate &__err, long &__v) const {
return _M_extract_int(__beg, __end, __io, __err, __v);
}
virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base &__io,
ios_base::iostate &__err,
unsigned short &__v) const {
return _M_extract_int(__beg, __end, __io, __err, __v);
}
virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base &__io,
ios_base::iostate &__err,
unsigned int &__v) const {
return _M_extract_int(__beg, __end, __io, __err, __v);
}
virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base &__io,
ios_base::iostate &__err,
unsigned long &__v) const {
return _M_extract_int(__beg, __end, __io, __err, __v);
}
virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base &__io,
ios_base::iostate &__err, long long &__v) const {
return _M_extract_int(__beg, __end, __io, __err, __v);
}
virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base &__io,
ios_base::iostate &__err,
unsigned long long &__v) const {
return _M_extract_int(__beg, __end, __io, __err, __v);
}
virtual iter_type do_get(iter_type, iter_type, ios_base &,
ios_base::iostate &, float &) const;
virtual iter_type do_get(iter_type, iter_type, ios_base &,
ios_base::iostate &, double &) const;
virtual iter_type do_get(iter_type, iter_type, ios_base &,
ios_base::iostate &, long double &) const;
virtual iter_type do_get(iter_type, iter_type, ios_base &,
ios_base::iostate &, void *&) const;
# 2235 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
};
template <typename _CharT, typename _InIter>
locale::id num_get<_CharT, _InIter>::id;
# 2253 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
template <typename _CharT, typename _OutIter>
class num_put : public locale::facet {
public:
typedef _CharT char_type;
typedef _OutIter iter_type;
static locale::id id;
# 2274 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
explicit num_put(size_t __refs = 0) : facet(__refs) {}
# 2292 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
iter_type put(iter_type __s, ios_base &__io, char_type __fill,
bool __v) const {
return this->do_put(__s, __io, __fill, __v);
}
# 2334 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
iter_type put(iter_type __s, ios_base &__io, char_type __fill,
long __v) const {
return this->do_put(__s, __io, __fill, __v);
}
iter_type put(iter_type __s, ios_base &__io, char_type __fill,
unsigned long __v) const {
return this->do_put(__s, __io, __fill, __v);
}
iter_type put(iter_type __s, ios_base &__io, char_type __fill,
long long __v) const {
return this->do_put(__s, __io, __fill, __v);
}
iter_type put(iter_type __s, ios_base &__io, char_type __fill,
unsigned long long __v) const {
return this->do_put(__s, __io, __fill, __v);
}
# 2397 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
iter_type put(iter_type __s, ios_base &__io, char_type __fill,
double __v) const {
return this->do_put(__s, __io, __fill, __v);
}
iter_type put(iter_type __s, ios_base &__io, char_type __fill,
long double __v) const {
return this->do_put(__s, __io, __fill, __v);
}
# 2422 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
iter_type put(iter_type __s, ios_base &__io, char_type __fill,
const void *__v) const {
return this->do_put(__s, __io, __fill, __v);
}
protected:
template <typename _ValueT>
iter_type _M_insert_float(iter_type, ios_base &__io, char_type __fill,
char __mod, _ValueT __v) const;
void _M_group_float(const char *__grouping, size_t __grouping_size,
char_type __sep, const char_type *__p, char_type *__new,
char_type *__cs, int &__len) const;
template <typename _ValueT>
iter_type _M_insert_int(iter_type, ios_base &__io, char_type __fill,
_ValueT __v) const;
void _M_group_int(const char *__grouping, size_t __grouping_size,
char_type __sep, ios_base &__io, char_type *__new,
char_type *__cs, int &__len) const;
void _M_pad(char_type __fill, streamsize __w, ios_base &__io,
char_type *__new, const char_type *__cs, int &__len) const;
virtual ~num_put() {};
# 2470 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
virtual iter_type do_put(iter_type __s, ios_base &__io, char_type __fill,
bool __v) const;
virtual iter_type do_put(iter_type __s, ios_base &__io, char_type __fill,
long __v) const {
return _M_insert_int(__s, __io, __fill, __v);
}
virtual iter_type do_put(iter_type __s, ios_base &__io, char_type __fill,
unsigned long __v) const {
return _M_insert_int(__s, __io, __fill, __v);
}
virtual iter_type do_put(iter_type __s, ios_base &__io, char_type __fill,
long long __v) const {
return _M_insert_int(__s, __io, __fill, __v);
}
virtual iter_type do_put(iter_type __s, ios_base &__io, char_type __fill,
unsigned long long __v) const {
return _M_insert_int(__s, __io, __fill, __v);
}
virtual iter_type do_put(iter_type, ios_base &, char_type, double) const;
virtual iter_type do_put(iter_type, ios_base &, char_type,
long double) const;
virtual iter_type do_put(iter_type, ios_base &, char_type,
const void *) const;
};
template <typename _CharT, typename _OutIter>
locale::id num_put<_CharT, _OutIter>::id;
# 2528 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 3
template <typename _CharT>
inline bool isspace(_CharT __c, const locale & __loc) {
return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c);
}
template <typename _CharT>
inline bool isprint(_CharT __c, const locale & __loc) {
return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c);
}
template <typename _CharT>
inline bool iscntrl(_CharT __c, const locale & __loc) {
return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c);
}
template <typename _CharT>
inline bool isupper(_CharT __c, const locale & __loc) {
return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c);
}
template <typename _CharT>
inline bool islower(_CharT __c, const locale & __loc) {
return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c);
}
template <typename _CharT>
inline bool isalpha(_CharT __c, const locale & __loc) {
return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c);
}
template <typename _CharT>
inline bool isdigit(_CharT __c, const locale & __loc) {
return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c);
}
template <typename _CharT>
inline bool ispunct(_CharT __c, const locale & __loc) {
return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c);
}
template <typename _CharT>
inline bool isxdigit(_CharT __c, const locale & __loc) {
return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c);
}
template <typename _CharT>
inline bool isalnum(_CharT __c, const locale & __loc) {
return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c);
}
template <typename _CharT>
inline bool isgraph(_CharT __c, const locale & __loc) {
return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c);
}
template <typename _CharT>
inline _CharT toupper(_CharT __c, const locale & __loc) {
return use_facet<ctype<_CharT> >(__loc).toupper(__c);
}
template <typename _CharT>
inline _CharT tolower(_CharT __c, const locale & __loc) {
return use_facet<ctype<_CharT> >(__loc).tolower(__c);
}
}
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.tcc" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.tcc" 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _Facet> struct __use_cache {
const _Facet *operator()(const locale &__loc) const;
};
template <typename _CharT> struct __use_cache<__numpunct_cache<_CharT> > {
const __numpunct_cache<_CharT> *operator()(const locale &__loc) const {
const size_t __i = numpunct<_CharT>::id._M_id();
const locale::facet **__caches = __loc._M_impl->_M_caches;
if (!__caches[__i]) {
__numpunct_cache<_CharT> *__tmp = 0;
try {
__tmp = new __numpunct_cache<_CharT>;
__tmp->_M_cache(__loc);
}
catch (...) {
delete __tmp;
throw;
}
__loc._M_impl->_M_install_cache(__tmp, __i);
}
return static_cast<const __numpunct_cache<_CharT> *>(__caches[__i]);
}
};
template <typename _CharT>
void __numpunct_cache<_CharT>::_M_cache(const locale & __loc) {
_M_allocated = true;
const numpunct<_CharT> &__np = use_facet<numpunct<_CharT> >(__loc);
char *__grouping = 0;
_CharT *__truename = 0;
_CharT *__falsename = 0;
try {
_M_grouping_size = __np.grouping().size();
__grouping = new char[_M_grouping_size];
__np.grouping().copy(__grouping, _M_grouping_size);
_M_grouping = __grouping;
_M_use_grouping =
(_M_grouping_size && static_cast<signed char>(_M_grouping[0]) > 0 &&
(_M_grouping[0] != __gnu_cxx::__numeric_traits<char>::__max));
_M_truename_size = __np.truename().size();
__truename = new _CharT[_M_truename_size];
__np.truename().copy(__truename, _M_truename_size);
_M_truename = __truename;
_M_falsename_size = __np.falsename().size();
__falsename = new _CharT[_M_falsename_size];
__np.falsename().copy(__falsename, _M_falsename_size);
_M_falsename = __falsename;
_M_decimal_point = __np.decimal_point();
_M_thousands_sep = __np.thousands_sep();
const ctype<_CharT> &__ct = use_facet<ctype<_CharT> >(__loc);
__ct.widen(__num_base::_S_atoms_out,
__num_base::_S_atoms_out + __num_base::_S_oend, _M_atoms_out);
__ct.widen(__num_base::_S_atoms_in,
__num_base::_S_atoms_in + __num_base::_S_iend, _M_atoms_in);
}
catch (...) {
delete[] __grouping;
delete[] __truename;
delete[] __falsename;
throw;
}
}
# 136 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.tcc" 3
__attribute__((__pure__)) bool __verify_grouping(
const char * __grouping, size_t __grouping_size,
const string & __grouping_tmp) throw();
template <typename _CharT, typename _InIter>
_InIter num_get<_CharT, _InIter>::_M_extract_float(
_InIter __beg, _InIter __end, ios_base & __io, ios_base::iostate & __err,
string & __xtrc) const {
typedef char_traits<_CharT> __traits_type;
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale &__loc = __io._M_getloc();
const __cache_type *__lc = __uc(__loc);
const _CharT *__lit = __lc->_M_atoms_in;
char_type __c = char_type();
bool __testeof = __beg == __end;
if (!__testeof) {
__c = *__beg;
const bool __plus = __c == __lit[__num_base::_S_iplus];
if ((__plus || __c == __lit[__num_base::_S_iminus]) &&
!(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) &&
!(__c == __lc->_M_decimal_point)) {
__xtrc += __plus ? '+' : '-';
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
}
bool __found_mantissa = false;
int __sep_pos = 0;
while (!__testeof) {
if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) ||
__c == __lc->_M_decimal_point)
break;
else if (__c == __lit[__num_base::_S_izero]) {
if (!__found_mantissa) {
__xtrc += '0';
__found_mantissa = true;
}
++__sep_pos;
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
} else
break;
}
bool __found_dec = false;
bool __found_sci = false;
string __found_grouping;
if (__lc->_M_use_grouping)
__found_grouping.reserve(32);
const char_type *__lit_zero = __lit + __num_base::_S_izero;
if (!__lc->_M_allocated)
while (!__testeof) {
const int __digit = _M_find(__lit_zero, 10, __c);
if (__digit != -1) {
__xtrc += '0' + __digit;
__found_mantissa = true;
} else if (__c == __lc->_M_decimal_point && !__found_dec &&
!__found_sci) {
__xtrc += '.';
__found_dec = true;
} else if ((__c == __lit[__num_base::_S_ie] ||
__c == __lit[__num_base::_S_iE]) &&
!__found_sci && __found_mantissa) {
__xtrc += 'e';
__found_sci = true;
if (++__beg != __end) {
__c = *__beg;
const bool __plus = __c == __lit[__num_base::_S_iplus];
if (__plus || __c == __lit[__num_base::_S_iminus])
__xtrc += __plus ? '+' : '-';
else
continue;
} else {
__testeof = true;
break;
}
} else
break;
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
else
while (!__testeof) {
if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) {
if (!__found_dec && !__found_sci) {
if (__sep_pos) {
__found_grouping += static_cast<char>(__sep_pos);
__sep_pos = 0;
} else {
__xtrc.clear();
break;
}
} else
break;
} else if (__c == __lc->_M_decimal_point) {
if (!__found_dec && !__found_sci) {
if (__found_grouping.size())
__found_grouping += static_cast<char>(__sep_pos);
__xtrc += '.';
__found_dec = true;
} else
break;
} else {
const char_type *__q = __traits_type::find(__lit_zero, 10, __c);
if (__q) {
__xtrc += '0' + (__q - __lit_zero);
__found_mantissa = true;
++__sep_pos;
} else if ((__c == __lit[__num_base::_S_ie] ||
__c == __lit[__num_base::_S_iE]) &&
!__found_sci && __found_mantissa) {
if (__found_grouping.size() && !__found_dec)
__found_grouping += static_cast<char>(__sep_pos);
__xtrc += 'e';
__found_sci = true;
if (++__beg != __end) {
__c = *__beg;
const bool __plus = __c == __lit[__num_base::_S_iplus];
if ((__plus || __c == __lit[__num_base::_S_iminus]) &&
!(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) &&
!(__c == __lc->_M_decimal_point))
__xtrc += __plus ? '+' : '-';
else
continue;
} else {
__testeof = true;
break;
}
} else
break;
}
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
if (__found_grouping.size()) {
if (!__found_dec && !__found_sci)
__found_grouping += static_cast<char>(__sep_pos);
if (!std::__verify_grouping(__lc->_M_grouping, __lc->_M_grouping_size,
__found_grouping))
__err = ios_base::failbit;
}
return __beg;
}
template <typename _CharT, typename _InIter>
template <typename _ValueT>
_InIter num_get<_CharT, _InIter>::_M_extract_int(
_InIter __beg, _InIter __end, ios_base & __io, ios_base::iostate & __err,
_ValueT & __v) const {
typedef char_traits<_CharT> __traits_type;
using __gnu_cxx::__add_unsigned;
typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale &__loc = __io._M_getloc();
const __cache_type *__lc = __uc(__loc);
const _CharT *__lit = __lc->_M_atoms_in;
char_type __c = char_type();
const ios_base::fmtflags __basefield = __io.flags() & ios_base::basefield;
const bool __oct = __basefield == ios_base::oct;
int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
bool __testeof = __beg == __end;
bool __negative = false;
if (!__testeof) {
__c = *__beg;
__negative = __c == __lit[__num_base::_S_iminus];
if ((__negative || __c == __lit[__num_base::_S_iplus]) &&
!(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) &&
!(__c == __lc->_M_decimal_point)) {
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
}
bool __found_zero = false;
int __sep_pos = 0;
while (!__testeof) {
if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) ||
__c == __lc->_M_decimal_point)
break;
else if (__c == __lit[__num_base::_S_izero] &&
(!__found_zero || __base == 10)) {
__found_zero = true;
++__sep_pos;
if (__basefield == 0)
__base = 8;
if (__base == 8)
__sep_pos = 0;
} else if (__found_zero && (__c == __lit[__num_base::_S_ix] ||
__c == __lit[__num_base::_S_iX])) {
if (__basefield == 0)
__base = 16;
if (__base == 16) {
__found_zero = false;
__sep_pos = 0;
} else
break;
} else
break;
if (++__beg != __end) {
__c = *__beg;
if (!__found_zero)
break;
} else
__testeof = true;
}
const size_t __len =
(__base == 16 ? __num_base::_S_iend - __num_base::_S_izero : __base);
string __found_grouping;
if (__lc->_M_use_grouping)
__found_grouping.reserve(32);
bool __testfail = false;
bool __testoverflow = false;
const __unsigned_type __max =
(__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
? -__gnu_cxx::__numeric_traits<_ValueT>::__min
: __gnu_cxx::__numeric_traits<_ValueT>::__max;
const __unsigned_type __smax = __max / __base;
__unsigned_type __result = 0;
int __digit = 0;
const char_type *__lit_zero = __lit + __num_base::_S_izero;
if (!__lc->_M_allocated)
while (!__testeof) {
__digit = _M_find(__lit_zero, __len, __c);
if (__digit == -1)
break;
if (__result > __smax)
__testoverflow = true;
else {
__result *= __base;
__testoverflow |= __result > __max - __digit;
__result += __digit;
++__sep_pos;
}
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
else
while (!__testeof) {
if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) {
if (__sep_pos) {
__found_grouping += static_cast<char>(__sep_pos);
__sep_pos = 0;
} else {
__testfail = true;
break;
}
} else if (__c == __lc->_M_decimal_point)
break;
else {
const char_type *__q = __traits_type::find(__lit_zero, __len, __c);
if (!__q)
break;
__digit = __q - __lit_zero;
if (__digit > 15)
__digit -= 6;
if (__result > __smax)
__testoverflow = true;
else {
__result *= __base;
__testoverflow |= __result > __max - __digit;
__result += __digit;
++__sep_pos;
}
}
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
if (__found_grouping.size()) {
__found_grouping += static_cast<char>(__sep_pos);
if (!std::__verify_grouping(__lc->_M_grouping, __lc->_M_grouping_size,
__found_grouping))
__err = ios_base::failbit;
}
if ((!__sep_pos && !__found_zero && !__found_grouping.size()) ||
__testfail) {
__v = 0;
__err = ios_base::failbit;
} else if (__testoverflow) {
if (__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
__v = __gnu_cxx::__numeric_traits<_ValueT>::__min;
else
__v = __gnu_cxx::__numeric_traits<_ValueT>::__max;
__err = ios_base::failbit;
} else
__v = __negative ? -__result : __result;
if (__testeof)
__err |= ios_base::eofbit;
return __beg;
}
template <typename _CharT, typename _InIter>
_InIter num_get<_CharT, _InIter>::do_get(
iter_type __beg, iter_type __end, ios_base & __io,
ios_base::iostate & __err, bool & __v) const {
if (!(__io.flags() & ios_base::boolalpha)) {
long __l = -1;
__beg = _M_extract_int(__beg, __end, __io, __err, __l);
if (__l == 0 || __l == 1)
__v = bool(__l);
else {
__v = true;
__err = ios_base::failbit;
if (__beg == __end)
__err |= ios_base::eofbit;
}
} else {
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale &__loc = __io._M_getloc();
const __cache_type *__lc = __uc(__loc);
bool __testf = true;
bool __testt = true;
bool __donef = __lc->_M_falsename_size == 0;
bool __donet = __lc->_M_truename_size == 0;
bool __testeof = false;
size_t __n = 0;
while (!__donef || !__donet) {
if (__beg == __end) {
__testeof = true;
break;
}
const char_type __c = *__beg;
if (!__donef)
__testf = __c == __lc->_M_falsename[__n];
if (!__testf && __donet)
break;
if (!__donet)
__testt = __c == __lc->_M_truename[__n];
if (!__testt && __donef)
break;
if (!__testt && !__testf)
break;
++__n;
++__beg;
__donef = !__testf || __n >= __lc->_M_falsename_size;
__donet = !__testt || __n >= __lc->_M_truename_size;
}
if (__testf && __n == __lc->_M_falsename_size && __n) {
__v = false;
if (__testt && __n == __lc->_M_truename_size)
__err = ios_base::failbit;
else
__err = __testeof ? ios_base::eofbit : ios_base::goodbit;
} else if (__testt && __n == __lc->_M_truename_size && __n) {
__v = true;
__err = __testeof ? ios_base::eofbit : ios_base::goodbit;
} else {
__v = false;
__err = ios_base::failbit;
if (__testeof)
__err |= ios_base::eofbit;
}
}
return __beg;
}
template <typename _CharT, typename _InIter>
_InIter num_get<_CharT, _InIter>::do_get(
iter_type __beg, iter_type __end, ios_base & __io,
ios_base::iostate & __err, float & __v) const {
string __xtrc;
__xtrc.reserve(32);
__beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
template <typename _CharT, typename _InIter>
_InIter num_get<_CharT, _InIter>::do_get(
iter_type __beg, iter_type __end, ios_base & __io,
ios_base::iostate & __err, double & __v) const {
string __xtrc;
__xtrc.reserve(32);
__beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
# 730 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.tcc" 3
template <typename _CharT, typename _InIter>
_InIter num_get<_CharT, _InIter>::do_get(
iter_type __beg, iter_type __end, ios_base & __io,
ios_base::iostate & __err, long double & __v) const {
string __xtrc;
__xtrc.reserve(32);
__beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
template <typename _CharT, typename _InIter>
_InIter num_get<_CharT, _InIter>::do_get(
iter_type __beg, iter_type __end, ios_base & __io,
ios_base::iostate & __err, void * &__v) const {
typedef ios_base::fmtflags fmtflags;
const fmtflags __fmt = __io.flags();
__io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
typedef __gnu_cxx::__conditional_type<
(sizeof(void *) <= sizeof(unsigned long)), unsigned long,
unsigned long long>::__type _UIntPtrType;
_UIntPtrType __ul;
__beg = _M_extract_int(__beg, __end, __io, __err, __ul);
__io.flags(__fmt);
__v = reinterpret_cast<void *>(__ul);
return __beg;
}
template <typename _CharT, typename _OutIter>
void num_put<_CharT, _OutIter>::_M_pad(
_CharT __fill, streamsize __w, ios_base & __io, _CharT * __new,
const _CharT * __cs, int & __len) const {
__pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new, __cs, __w,
__len);
__len = static_cast<int>(__w);
}
template <typename _CharT, typename _ValueT>
int __int_to_char(_CharT * __bufend, _ValueT __v, const _CharT * __lit,
ios_base::fmtflags __flags, bool __dec) {
_CharT *__buf = __bufend;
if (__builtin_expect(__dec, true)) {
do {
*--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
__v /= 10;
} while (__v != 0);
} else if ((__flags & ios_base::basefield) == ios_base::oct) {
do {
*--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
__v >>= 3;
} while (__v != 0);
} else {
const bool __uppercase = __flags & ios_base::uppercase;
const int __case_offset =
__uppercase ? __num_base::_S_oudigits : __num_base::_S_odigits;
do {
*--__buf = __lit[(__v & 0xf) + __case_offset];
__v >>= 4;
} while (__v != 0);
}
return __bufend - __buf;
}
template <typename _CharT, typename _OutIter>
void num_put<_CharT, _OutIter>::_M_group_int(
const char * __grouping, size_t __grouping_size, _CharT __sep, ios_base &,
_CharT * __new, _CharT * __cs, int & __len) const {
_CharT *__p = std::__add_grouping(__new, __sep, __grouping, __grouping_size,
__cs, __cs + __len);
__len = __p - __new;
}
template <typename _CharT, typename _OutIter>
template <typename _ValueT>
_OutIter num_put<_CharT, _OutIter>::_M_insert_int(
_OutIter __s, ios_base & __io, _CharT __fill, _ValueT __v) const {
using __gnu_cxx::__add_unsigned;
typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale &__loc = __io._M_getloc();
const __cache_type *__lc = __uc(__loc);
const _CharT *__lit = __lc->_M_atoms_out;
const ios_base::fmtflags __flags = __io.flags();
const int __ilen = 5 * sizeof(_ValueT);
_CharT *__cs =
static_cast<_CharT *>(__builtin_alloca(sizeof(_CharT) * __ilen));
const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
const bool __dec =
(__basefield != ios_base::oct && __basefield != ios_base::hex);
const __unsigned_type __u =
((__v > 0 || !__dec) ? __unsigned_type(__v) : -__unsigned_type(__v));
int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
__cs += __ilen - __len;
if (__lc->_M_use_grouping) {
_CharT *__cs2 = static_cast<_CharT *>(
__builtin_alloca(sizeof(_CharT) * (__len + 1) * 2));
_M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
__lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
__cs = __cs2 + 2;
}
if (__builtin_expect(__dec, true)) {
if (__v >= 0) {
if (bool(__flags & ios_base::showpos) &&
__gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
*--__cs = __lit[__num_base::_S_oplus], ++__len;
} else
*--__cs = __lit[__num_base::_S_ominus], ++__len;
} else if (bool(__flags & ios_base::showbase) && __v) {
if (__basefield == ios_base::oct)
*--__cs = __lit[__num_base::_S_odigits], ++__len;
else {
const bool __uppercase = __flags & ios_base::uppercase;
*--__cs = __lit[__num_base::_S_ox + __uppercase];
*--__cs = __lit[__num_base::_S_odigits];
__len += 2;
}
}
const streamsize __w = __io.width();
if (__w > static_cast<streamsize>(__len)) {
_CharT *__cs3 =
static_cast<_CharT *>(__builtin_alloca(sizeof(_CharT) * __w));
_M_pad(__fill, __w, __io, __cs3, __cs, __len);
__cs = __cs3;
}
__io.width(0);
return std::__write(__s, __cs, __len);
}
template <typename _CharT, typename _OutIter>
void num_put<_CharT, _OutIter>::_M_group_float(
const char * __grouping, size_t __grouping_size, _CharT __sep,
const _CharT * __p, _CharT * __new, _CharT * __cs, int & __len) const {
const int __declen = __p ? __p - __cs : __len;
_CharT *__p2 = std::__add_grouping(__new, __sep, __grouping,
__grouping_size, __cs, __cs + __declen);
int __newlen = __p2 - __new;
if (__p) {
char_traits<_CharT>::copy(__p2, __p, __len - __declen);
__newlen += __len - __declen;
}
__len = __newlen;
}
# 966 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.tcc" 3
template <typename _CharT, typename _OutIter>
template <typename _ValueT>
_OutIter num_put<_CharT, _OutIter>::_M_insert_float(
_OutIter __s, ios_base & __io, _CharT __fill, char __mod,
_ValueT __v) const {
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale &__loc = __io._M_getloc();
const __cache_type *__lc = __uc(__loc);
const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
const int __max_digits = __gnu_cxx::__numeric_traits<_ValueT>::__digits10;
int __len;
char __fbuf[16];
__num_base::_S_format_float(__io, __fbuf, __mod);
int __cs_size = __max_digits * 3;
char *__cs = static_cast<char *>(__builtin_alloca(__cs_size));
__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, __fbuf,
__prec, __v);
if (__len >= __cs_size) {
__cs_size = __len + 1;
__cs = static_cast<char *>(__builtin_alloca(__cs_size));
__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, __fbuf,
__prec, __v);
}
# 1027 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.tcc" 3
const ctype<_CharT> &__ctype = use_facet<ctype<_CharT> >(__loc);
_CharT *__ws =
static_cast<_CharT *>(__builtin_alloca(sizeof(_CharT) * __len));
__ctype.widen(__cs, __cs + __len, __ws);
_CharT *__wp = 0;
const char *__p = char_traits<char>::find(__cs, __len, '.');
if (__p) {
__wp = __ws + (__p - __cs);
*__wp = __lc->_M_decimal_point;
}
if (__lc->_M_use_grouping &&
(__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9' &&
__cs[1] >= '0' && __cs[2] >= '0'))) {
_CharT *__ws2 =
static_cast<_CharT *>(__builtin_alloca(sizeof(_CharT) * __len * 2));
streamsize __off = 0;
if (__cs[0] == '-' || __cs[0] == '+') {
__off = 1;
__ws2[0] = __ws[0];
__len -= 1;
}
_M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
__lc->_M_thousands_sep, __wp, __ws2 + __off, __ws + __off,
__len);
__len += __off;
__ws = __ws2;
}
const streamsize __w = __io.width();
if (__w > static_cast<streamsize>(__len)) {
_CharT *__ws3 =
static_cast<_CharT *>(__builtin_alloca(sizeof(_CharT) * __w));
_M_pad(__fill, __w, __io, __ws3, __ws, __len);
__ws = __ws3;
}
__io.width(0);
return std::__write(__s, __ws, __len);
}
template <typename _CharT, typename _OutIter>
_OutIter num_put<_CharT, _OutIter>::do_put(iter_type __s, ios_base & __io,
char_type __fill, bool __v) const {
const ios_base::fmtflags __flags = __io.flags();
if ((__flags & ios_base::boolalpha) == 0) {
const long __l = __v;
__s = _M_insert_int(__s, __io, __fill, __l);
} else {
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale &__loc = __io._M_getloc();
const __cache_type *__lc = __uc(__loc);
const _CharT *__name = __v ? __lc->_M_truename : __lc->_M_falsename;
int __len = __v ? __lc->_M_truename_size : __lc->_M_falsename_size;
const streamsize __w = __io.width();
if (__w > static_cast<streamsize>(__len)) {
const streamsize __plen = __w - __len;
_CharT *__ps =
static_cast<_CharT *>(__builtin_alloca(sizeof(_CharT) * __plen));
char_traits<_CharT>::assign(__ps, __plen, __fill);
__io.width(0);
if ((__flags & ios_base::adjustfield) == ios_base::left) {
__s = std::__write(__s, __name, __len);
__s = std::__write(__s, __ps, __plen);
} else {
__s = std::__write(__s, __ps, __plen);
__s = std::__write(__s, __name, __len);
}
return __s;
}
__io.width(0);
__s = std::__write(__s, __name, __len);
}
return __s;
}
template <typename _CharT, typename _OutIter>
_OutIter num_put<_CharT, _OutIter>::do_put(
iter_type __s, ios_base & __io, char_type __fill, double __v) const {
return _M_insert_float(__s, __io, __fill, char(), __v);
}
# 1152 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.tcc" 3
template <typename _CharT, typename _OutIter>
_OutIter num_put<_CharT, _OutIter>::do_put(
iter_type __s, ios_base & __io, char_type __fill, long double __v) const {
return _M_insert_float(__s, __io, __fill, 'L', __v);
}
template <typename _CharT, typename _OutIter>
_OutIter num_put<_CharT, _OutIter>::do_put(iter_type __s, ios_base & __io,
char_type __fill,
const void * __v) const {
const ios_base::fmtflags __flags = __io.flags();
const ios_base::fmtflags __fmt =
~(ios_base::basefield | ios_base::uppercase);
__io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
typedef __gnu_cxx::__conditional_type<
(sizeof(const void *) <= sizeof(unsigned long)), unsigned long,
unsigned long long>::__type _UIntPtrType;
__s = _M_insert_int(__s, __io, __fill, reinterpret_cast<_UIntPtrType>(__v));
__io.flags(__flags);
return __s;
}
# 1189 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.tcc" 3
template <typename _CharT, typename _Traits>
void __pad<_CharT, _Traits>::_S_pad(
ios_base & __io, _CharT __fill, _CharT * __news, const _CharT * __olds,
streamsize __newlen, streamsize __oldlen) {
const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
if (__adjust == ios_base::left) {
_Traits::copy(__news, __olds, __oldlen);
_Traits::assign(__news + __oldlen, __plen, __fill);
return;
}
size_t __mod = 0;
if (__adjust == ios_base::internal) {
const locale &__loc = __io._M_getloc();
const ctype<_CharT> &__ctype = use_facet<ctype<_CharT> >(__loc);
if (__ctype.widen('-') == __olds[0] || __ctype.widen('+') == __olds[0]) {
__news[0] = __olds[0];
__mod = 1;
++__news;
} else if (__ctype.widen('0') == __olds[0] && __oldlen > 1 &&
(__ctype.widen('x') == __olds[1] ||
__ctype.widen('X') == __olds[1])) {
__news[0] = __olds[0];
__news[1] = __olds[1];
__mod = 2;
__news += 2;
}
}
_Traits::assign(__news, __plen, __fill);
_Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
}
template <typename _CharT>
_CharT *__add_grouping(_CharT * __s, _CharT __sep, const char * __gbeg,
size_t __gsize, const _CharT * __first,
const _CharT * __last) {
size_t __idx = 0;
size_t __ctr = 0;
while (__last - __first > __gbeg[__idx] &&
static_cast<signed char>(__gbeg[__idx]) > 0 &&
__gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max) {
__last -= __gbeg[__idx];
__idx < __gsize - 1 ? ++__idx : ++__ctr;
}
while (__first != __last)
*__s++ = *__first++;
while (__ctr--) {
*__s++ = __sep;
for (char __i = __gbeg[__idx]; __i > 0; --__i)
*__s++ = *__first++;
}
while (__idx--) {
*__s++ = __sep;
for (char __i = __gbeg[__idx]; __i > 0; --__i)
*__s++ = *__first++;
}
return __s;
}
extern template class numpunct<char>;
extern template class numpunct_byname<char>;
extern template class num_get<char>;
extern template class num_put<char>;
extern template class ctype_byname<char>;
extern template const ctype<char> &use_facet<ctype<char> >(const locale &);
extern template const numpunct<char> &use_facet<numpunct<char> >(
const locale &);
extern template const num_put<char> &use_facet<num_put<char> >(
const locale &);
extern template const num_get<char> &use_facet<num_get<char> >(
const locale &);
extern template bool has_facet<ctype<char> >(const locale &);
extern template bool has_facet<numpunct<char> >(const locale &);
extern template bool has_facet<num_put<char> >(const locale &);
extern template bool has_facet<num_get<char> >(const locale &);
extern template class numpunct<wchar_t>;
extern template class numpunct_byname<wchar_t>;
extern template class num_get<wchar_t>;
extern template class num_put<wchar_t>;
extern template class ctype_byname<wchar_t>;
extern template const ctype<wchar_t> &use_facet<ctype<wchar_t> >(
const locale &);
extern template const numpunct<wchar_t> &use_facet<numpunct<wchar_t> >(
const locale &);
extern template const num_put<wchar_t> &use_facet<num_put<wchar_t> >(
const locale &);
extern template const num_get<wchar_t> &use_facet<num_get<wchar_t> >(
const locale &);
extern template bool has_facet<ctype<wchar_t> >(const locale &);
extern template bool has_facet<numpunct<wchar_t> >(const locale &);
extern template bool has_facet<num_put<wchar_t> >(const locale &);
extern template bool has_facet<num_get<wchar_t> >(const locale &);
}
# 2609 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/locale_facets.h" 2 3
# 38 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _Facet>
inline const _Facet &__check_facet(const _Facet * __f) {
if (!__f)
__throw_bad_cast();
return *__f;
}
# 65 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 3
template <typename _CharT, typename _Traits>
class basic_ios : public ios_base {
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef ctype<_CharT> __ctype_type;
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
__num_put_type;
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
__num_get_type;
protected:
basic_ostream<_CharT, _Traits> *_M_tie;
mutable char_type _M_fill;
mutable bool _M_fill_init;
basic_streambuf<_CharT, _Traits> *_M_streambuf;
const __ctype_type *_M_ctype;
const __num_put_type *_M_num_put;
const __num_get_type *_M_num_get;
public:
operator void *() const {
return this->fail() ? 0 : const_cast<basic_ios *>(this);
}
bool operator!() const { return this->fail(); }
# 130 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 3
iostate rdstate() const { return _M_streambuf_state; }
# 141 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 3
void clear(iostate __state = goodbit);
void setstate(iostate __state) { this->clear(this->rdstate() | __state); }
void _M_setstate(iostate __state) {
_M_streambuf_state |= __state;
if (this->exceptions() & __state)
throw;
}
bool good() const { return this->rdstate() == 0; }
bool eof() const { return (this->rdstate() & eofbit) != 0; }
# 194 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 3
bool fail() const { return (this->rdstate() & (badbit | failbit)) != 0; }
bool bad() const { return (this->rdstate() & badbit) != 0; }
# 215 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 3
iostate exceptions() const { return _M_exception; }
# 250 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 3
void exceptions(iostate __except) {
_M_exception = __except;
this->clear(_M_streambuf_state);
}
explicit basic_ios(basic_streambuf<_CharT, _Traits> *__sb)
: ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false),
_M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0) {
this->init(__sb);
}
virtual ~basic_ios() {}
# 288 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 3
basic_ostream<_CharT, _Traits> *tie() const { return _M_tie; }
# 300 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 3
basic_ostream<_CharT, _Traits> *
tie(basic_ostream<_CharT, _Traits> *__tiestr) {
basic_ostream<_CharT, _Traits> *__old = _M_tie;
_M_tie = __tiestr;
return __old;
}
basic_streambuf<_CharT, _Traits> *rdbuf() const { return _M_streambuf; }
# 340 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 3
basic_streambuf<_CharT, _Traits> *
rdbuf(basic_streambuf<_CharT, _Traits> *__sb);
# 354 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 3
basic_ios &copyfmt(const basic_ios &__rhs);
char_type fill() const {
if (!_M_fill_init) {
_M_fill = this->widen(' ');
_M_fill_init = true;
}
return _M_fill;
}
# 383 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 3
char_type fill(char_type __ch) {
char_type __old = this->fill();
_M_fill = __ch;
return __old;
}
# 403 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 3
locale imbue(const locale &__loc);
# 423 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 3
char narrow(char_type __c, char __dfault) const {
return __check_facet(_M_ctype).narrow(__c, __dfault);
}
# 442 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 3
char_type widen(char __c) const {
return __check_facet(_M_ctype).widen(__c);
}
protected:
basic_ios()
: ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
_M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0) {}
void init(basic_streambuf<_CharT, _Traits> *__sb);
void _M_cache_locale(const locale &__loc);
};
}
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.tcc" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.tcc" 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _CharT, typename _Traits>
void basic_ios<_CharT, _Traits>::clear(iostate __state) {
if (this->rdbuf())
_M_streambuf_state = __state;
else
_M_streambuf_state = __state | badbit;
if (this->exceptions() & this->rdstate())
__throw_ios_failure(("basic_ios::clear"));
}
template <typename _CharT, typename _Traits>
basic_streambuf<_CharT, _Traits> *basic_ios<_CharT, _Traits>::rdbuf(
basic_streambuf<_CharT, _Traits> * __sb) {
basic_streambuf<_CharT, _Traits> *__old = _M_streambuf;
_M_streambuf = __sb;
this->clear();
return __old;
}
template <typename _CharT, typename _Traits>
basic_ios<_CharT, _Traits> &basic_ios<_CharT, _Traits>::copyfmt(
const basic_ios & __rhs) {
if (this != &__rhs) {
_Words *__words = (__rhs._M_word_size <= _S_local_word_size)
? _M_local_word
: new _Words[__rhs._M_word_size];
_Callback_list *__cb = __rhs._M_callbacks;
if (__cb)
__cb->_M_add_reference();
_M_call_callbacks(erase_event);
if (_M_word != _M_local_word) {
delete[] _M_word;
_M_word = 0;
}
_M_dispose_callbacks();
_M_callbacks = __cb;
for (int __i = 0; __i < __rhs._M_word_size; ++__i)
__words[__i] = __rhs._M_word[__i];
_M_word = __words;
_M_word_size = __rhs._M_word_size;
this->flags(__rhs.flags());
this->width(__rhs.width());
this->precision(__rhs.precision());
this->tie(__rhs.tie());
this->fill(__rhs.fill());
_M_ios_locale = __rhs.getloc();
_M_cache_locale(_M_ios_locale);
_M_call_callbacks(copyfmt_event);
this->exceptions(__rhs.exceptions());
}
return *this;
}
template <typename _CharT, typename _Traits>
locale basic_ios<_CharT, _Traits>::imbue(const locale & __loc) {
locale __old(this->getloc());
ios_base::imbue(__loc);
_M_cache_locale(__loc);
if (this->rdbuf() != 0)
this->rdbuf()->pubimbue(__loc);
return __old;
}
template <typename _CharT, typename _Traits>
void basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits> *
__sb) {
ios_base::_M_init();
_M_cache_locale(_M_ios_locale);
# 146 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.tcc" 3
_M_fill = _CharT();
_M_fill_init = false;
_M_tie = 0;
_M_exception = goodbit;
_M_streambuf = __sb;
_M_streambuf_state = __sb ? goodbit : badbit;
}
template <typename _CharT, typename _Traits>
void basic_ios<_CharT, _Traits>::_M_cache_locale(const locale & __loc) {
if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
_M_ctype = &use_facet<__ctype_type>(__loc);
else
_M_ctype = 0;
if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
_M_num_put = &use_facet<__num_put_type>(__loc);
else
_M_num_put = 0;
if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
_M_num_get = &use_facet<__num_get_type>(__loc);
else
_M_num_get = 0;
}
extern template class basic_ios<char>;
extern template class basic_ios<wchar_t>;
}
# 476 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/basic_ios.h" 2 3
# 45 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ios" 2 3
# 39 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 57 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
template <typename _CharT, typename _Traits>
class basic_ostream : virtual public basic_ios<_CharT, _Traits> {
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_ios<_CharT, _Traits> __ios_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
__num_put_type;
typedef ctype<_CharT> __ctype_type;
# 83 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
explicit basic_ostream(__streambuf_type *__sb) { this->init(__sb); }
virtual ~basic_ostream() {}
class sentry;
friend class sentry;
# 107 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
__ostream_type &operator<<(__ostream_type &(*__pf)(__ostream_type &)) {
return __pf(*this);
}
__ostream_type &operator<<(__ios_type &(*__pf)(__ios_type &)) {
__pf(*this);
return *this;
}
__ostream_type &operator<<(ios_base &(*__pf)(ios_base &)) {
__pf(*this);
return *this;
}
# 165 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
__ostream_type &operator<<(long __n) { return _M_insert(__n); }
__ostream_type &operator<<(unsigned long __n) { return _M_insert(__n); }
__ostream_type &operator<<(bool __n) { return _M_insert(__n); }
__ostream_type &operator<<(short __n);
__ostream_type &operator<<(unsigned short __n) {
return _M_insert(static_cast<unsigned long>(__n));
}
__ostream_type &operator<<(int __n);
__ostream_type &operator<<(unsigned int __n) {
return _M_insert(static_cast<unsigned long>(__n));
}
__ostream_type &operator<<(long long __n) { return _M_insert(__n); }
__ostream_type &operator<<(unsigned long long __n) {
return _M_insert(__n);
}
# 219 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
__ostream_type &operator<<(double __f) { return _M_insert(__f); }
__ostream_type &operator<<(float __f) {
return _M_insert(static_cast<double>(__f));
}
__ostream_type &operator<<(long double __f) { return _M_insert(__f); }
# 244 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
__ostream_type &operator<<(const void *__p) { return _M_insert(__p); }
# 269 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
__ostream_type &operator<<(__streambuf_type *__sb);
# 302 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
__ostream_type &put(char_type __c);
void _M_write(const char_type *__s, streamsize __n) {
const streamsize __put = this->rdbuf()->sputn(__s, __n);
if (__put != __n)
this->setstate(ios_base::badbit);
}
# 334 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
__ostream_type &write(const char_type *__s, streamsize __n);
# 347 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
__ostream_type &flush();
# 357 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
pos_type tellp();
# 368 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
__ostream_type &seekp(pos_type);
# 380 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
__ostream_type &seekp(off_type, ios_base::seekdir);
protected:
basic_ostream() { this->init(0); }
template <typename _ValueT> __ostream_type &_M_insert(_ValueT __v);
};
# 399 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
template <typename _CharT, typename _Traits>
class basic_ostream<_CharT, _Traits>::sentry {
bool _M_ok;
basic_ostream<_CharT, _Traits> &_M_os;
public:
# 418 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
explicit sentry(basic_ostream<_CharT, _Traits> &__os);
# 428 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
~sentry() {
if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception()) {
if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
_M_os.setstate(ios_base::badbit);
}
}
# 447 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
explicit operator bool() const { return _M_ok; }
};
# 469 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
template <typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits> &operator<<(
basic_ostream<_CharT, _Traits> & __out, _CharT __c) {
return __ostream_insert(__out, &__c, 1);
}
template <typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits> &operator<<(
basic_ostream<_CharT, _Traits> & __out, char __c) {
return (__out << __out.widen(__c));
}
template <class _Traits>
inline basic_ostream<char, _Traits> &operator<<(
basic_ostream<char, _Traits> & __out, char __c) {
return __ostream_insert(__out, &__c, 1);
}
template <class _Traits>
inline basic_ostream<char, _Traits> &operator<<(
basic_ostream<char, _Traits> & __out, signed char __c) {
return (__out << static_cast<char>(__c));
}
template <class _Traits>
inline basic_ostream<char, _Traits> &operator<<(
basic_ostream<char, _Traits> & __out, unsigned char __c) {
return (__out << static_cast<char>(__c));
}
# 511 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
template <typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits> &operator<<(
basic_ostream<_CharT, _Traits> & __out, const _CharT * __s) {
if (!__s)
__out.setstate(ios_base::badbit);
else
__ostream_insert(__out, __s,
static_cast<streamsize>(_Traits::length(__s)));
return __out;
}
template <typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &operator<<(
basic_ostream<_CharT, _Traits> & __out, const char * __s);
template <class _Traits>
inline basic_ostream<char, _Traits> &operator<<(
basic_ostream<char, _Traits> & __out, const char * __s) {
if (!__s)
__out.setstate(ios_base::badbit);
else
__ostream_insert(__out, __s,
static_cast<streamsize>(_Traits::length(__s)));
return __out;
}
template <class _Traits>
inline basic_ostream<char, _Traits> &operator<<(
basic_ostream<char, _Traits> & __out, const signed char * __s) {
return (__out << reinterpret_cast<const char *>(__s));
}
template <class _Traits>
inline basic_ostream<char, _Traits> &operator<<(
basic_ostream<char, _Traits> & __out, const unsigned char * __s) {
return (__out << reinterpret_cast<const char *>(__s));
}
# 562 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
template <typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits> &endl(basic_ostream<_CharT, _Traits> &
__os) {
return flush(__os.put(__os.widen('\n')));
}
# 574 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
template <typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits> &ends(basic_ostream<_CharT, _Traits> &
__os) {
return __os.put(_CharT());
}
template <typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits> &flush(basic_ostream<_CharT, _Traits> &
__os) {
return __os.flush();
}
# 600 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 3
template <typename _CharT, typename _Traits, typename _Tp>
inline basic_ostream<_CharT, _Traits> &operator<<(
basic_ostream<_CharT, _Traits> && __os, const _Tp & __x) {
return (__os << __x);
}
}
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ostream.tcc" 1 3
# 38 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/ostream.tcc" 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>::sentry::sentry(
basic_ostream<_CharT, _Traits> & __os)
: _M_ok(false), _M_os(__os) {
if (__os.tie() && __os.good())
__os.tie()->flush();
if (__os.good())
_M_ok = true;
else
__os.setstate(ios_base::failbit);
}
template <typename _CharT, typename _Traits>
template <typename _ValueT>
basic_ostream<_CharT, _Traits> &basic_ostream<_CharT, _Traits>::_M_insert(
_ValueT __v) {
sentry __cerb(*this);
if (__cerb) {
ios_base::iostate __err = ios_base::goodbit;
try {
const __num_put_type &__np = __check_facet(this->_M_num_put);
if (__np.put(*this, *this, this->fill(), __v).failed())
__err |= ios_base::badbit;
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
}
return *this;
}
template <typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &basic_ostream<_CharT, _Traits>::operator<<(
short __n) {
const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
if (__fmt == ios_base::oct || __fmt == ios_base::hex)
return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
else
return _M_insert(static_cast<long>(__n));
}
template <typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &basic_ostream<_CharT, _Traits>::operator<<(
int __n) {
const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
if (__fmt == ios_base::oct || __fmt == ios_base::hex)
return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
else
return _M_insert(static_cast<long>(__n));
}
template <typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &basic_ostream<_CharT, _Traits>::operator<<(
__streambuf_type * __sbin) {
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this);
if (__cerb && __sbin) {
try {
if (!__copy_streambufs(__sbin, this->rdbuf()))
__err |= ios_base::failbit;
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::failbit);
}
} else if (!__sbin)
__err |= ios_base::badbit;
if (__err)
this->setstate(__err);
return *this;
}
template <typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &basic_ostream<_CharT, _Traits>::put(
char_type __c) {
sentry __cerb(*this);
if (__cerb) {
ios_base::iostate __err = ios_base::goodbit;
try {
const int_type __put = this->rdbuf()->sputc(__c);
if (traits_type::eq_int_type(__put, traits_type::eof()))
__err |= ios_base::badbit;
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
}
return *this;
}
template <typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &basic_ostream<_CharT, _Traits>::write(
const _CharT * __s, streamsize __n) {
sentry __cerb(*this);
if (__cerb) {
try {
_M_write(__s, __n);
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
}
return *this;
}
template <typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &basic_ostream<_CharT, _Traits>::flush() {
ios_base::iostate __err = ios_base::goodbit;
try {
if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
__err |= ios_base::badbit;
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
return *this;
}
template <typename _CharT, typename _Traits>
typename basic_ostream<_CharT, _Traits>::pos_type
basic_ostream<_CharT, _Traits>::tellp() {
pos_type __ret = pos_type(-1);
try {
if (!this->fail())
__ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
return __ret;
}
template <typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &basic_ostream<_CharT, _Traits>::seekp(
pos_type __pos) {
ios_base::iostate __err = ios_base::goodbit;
try {
if (!this->fail()) {
const pos_type __p = this->rdbuf()->pubseekpos(__pos, ios_base::out);
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
return *this;
}
template <typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &basic_ostream<_CharT, _Traits>::seekp(
off_type __off, ios_base::seekdir __dir) {
ios_base::iostate __err = ios_base::goodbit;
try {
if (!this->fail()) {
const pos_type __p =
this->rdbuf()->pubseekoff(__off, __dir, ios_base::out);
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
return *this;
}
template <typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &operator<<(
basic_ostream<_CharT, _Traits> & __out, const char * __s) {
if (!__s)
__out.setstate(ios_base::badbit);
else {
const size_t __clen = char_traits<char>::length(__s);
try {
struct __ptr_guard {
_CharT *__p;
__ptr_guard(_CharT *__ip) : __p(__ip) {}
~__ptr_guard() { delete[] __p; }
_CharT *__get() { return __p; }
} __pg(new _CharT[__clen]);
_CharT *__ws = __pg.__get();
for (size_t __i = 0; __i < __clen; ++__i)
__ws[__i] = __out.widen(__s[__i]);
__ostream_insert(__out, __ws, __clen);
}
catch (__cxxabiv1::__forced_unwind &) {
__out._M_setstate(ios_base::badbit);
throw;
}
catch (...) {
__out._M_setstate(ios_base::badbit);
}
}
return __out;
}
extern template class basic_ostream<char>;
extern template ostream &endl(ostream &);
extern template ostream &ends(ostream &);
extern template ostream &flush(ostream &);
extern template ostream &operator<<(ostream &, char);
extern template ostream &operator<<(ostream &, unsigned char);
extern template ostream &operator<<(ostream &, signed char);
extern template ostream &operator<<(ostream &, const char *);
extern template ostream &operator<<(ostream &, const unsigned char *);
extern template ostream &operator<<(ostream &, const signed char *);
extern template ostream &ostream::_M_insert(long);
extern template ostream &ostream::_M_insert(unsigned long);
extern template ostream &ostream::_M_insert(bool);
extern template ostream &ostream::_M_insert(long long);
extern template ostream &ostream::_M_insert(unsigned long long);
extern template ostream &ostream::_M_insert(double);
extern template ostream &ostream::_M_insert(long double);
extern template ostream &ostream::_M_insert(const void *);
extern template class basic_ostream<wchar_t>;
extern template wostream &endl(wostream &);
extern template wostream &ends(wostream &);
extern template wostream &flush(wostream &);
extern template wostream &operator<<(wostream &, wchar_t);
extern template wostream &operator<<(wostream &, char);
extern template wostream &operator<<(wostream &, const wchar_t *);
extern template wostream &operator<<(wostream &, const char *);
extern template wostream &wostream::_M_insert(long);
extern template wostream &wostream::_M_insert(unsigned long);
extern template wostream &wostream::_M_insert(bool);
extern template wostream &wostream::_M_insert(long long);
extern template wostream &wostream::_M_insert(unsigned long long);
extern template wostream &wostream::_M_insert(double);
extern template wostream &wostream::_M_insert(long double);
extern template wostream &wostream::_M_insert(const void *);
}
# 610 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ostream" 2 3
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/iostream" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 1 3
# 37 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
namespace std __attribute__((__visibility__("default"))) {
# 57 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
template <typename _CharT, typename _Traits>
class basic_istream : virtual public basic_ios<_CharT, _Traits> {
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_ios<_CharT, _Traits> __ios_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
__num_get_type;
typedef ctype<_CharT> __ctype_type;
protected:
streamsize _M_gcount;
public:
explicit basic_istream(__streambuf_type *__sb) : _M_gcount(streamsize(0)) {
this->init(__sb);
}
virtual ~basic_istream() { _M_gcount = streamsize(0); }
class sentry;
friend class sentry;
# 119 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &operator>>(__istream_type &(*__pf)(__istream_type &)) {
return __pf(*this);
}
__istream_type &operator>>(__ios_type &(*__pf)(__ios_type &)) {
__pf(*this);
return *this;
}
__istream_type &operator>>(ios_base &(*__pf)(ios_base &)) {
__pf(*this);
return *this;
}
# 167 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &operator>>(bool &__n) { return _M_extract(__n); }
__istream_type &operator>>(short &__n);
__istream_type &operator>>(unsigned short &__n) { return _M_extract(__n); }
__istream_type &operator>>(int &__n);
__istream_type &operator>>(unsigned int &__n) { return _M_extract(__n); }
__istream_type &operator>>(long &__n) { return _M_extract(__n); }
__istream_type &operator>>(unsigned long &__n) { return _M_extract(__n); }
__istream_type &operator>>(long long &__n) { return _M_extract(__n); }
__istream_type &operator>>(unsigned long long &__n) {
return _M_extract(__n);
}
# 213 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &operator>>(float &__f) { return _M_extract(__f); }
__istream_type &operator>>(double &__f) { return _M_extract(__f); }
__istream_type &operator>>(long double &__f) { return _M_extract(__f); }
# 234 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &operator>>(void *&__p) { return _M_extract(__p); }
# 258 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &operator>>(__streambuf_type *__sb);
# 268 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
streamsize gcount() const { return _M_gcount; }
# 301 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
int_type get();
# 315 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &get(char_type &__c);
# 342 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &get(char_type *__s, streamsize __n, char_type __delim);
# 353 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &get(char_type *__s, streamsize __n) {
return this->get(__s, __n, this->widen('\n'));
}
# 376 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &get(__streambuf_type &__sb, char_type __delim);
# 386 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &get(__streambuf_type &__sb) {
return this->get(__sb, this->widen('\n'));
}
# 415 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &getline(char_type *__s, streamsize __n, char_type __delim);
# 426 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &getline(char_type *__s, streamsize __n) {
return this->getline(__s, __n, this->widen('\n'));
}
# 450 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &ignore(streamsize __n, int_type __delim);
__istream_type &ignore(streamsize __n);
__istream_type &ignore();
# 467 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
int_type peek();
# 485 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &read(char_type *__s, streamsize __n);
# 504 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
streamsize readsome(char_type *__s, streamsize __n);
# 521 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &putback(char_type __c);
# 537 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &unget();
# 555 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
int sync();
# 570 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
pos_type tellg();
# 585 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &seekg(pos_type);
# 601 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
__istream_type &seekg(off_type, ios_base::seekdir);
protected:
basic_istream() : _M_gcount(streamsize(0)) { this->init(0); }
template <typename _ValueT> __istream_type &_M_extract(_ValueT &__v);
};
template <>
basic_istream<char> &basic_istream<char>::getline(
char_type * __s, streamsize __n, char_type __delim);
template <> basic_istream<char> &basic_istream<char>::ignore(streamsize __n);
template <>
basic_istream<char> &basic_istream<char>::ignore(streamsize __n,
int_type __delim);
template <>
basic_istream<wchar_t> &basic_istream<wchar_t>::getline(
char_type * __s, streamsize __n, char_type __delim);
template <>
basic_istream<wchar_t> &basic_istream<wchar_t>::ignore(streamsize __n);
template <>
basic_istream<wchar_t> &basic_istream<wchar_t>::ignore(streamsize __n,
int_type __delim);
# 656 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
template <typename _CharT, typename _Traits>
class basic_istream<_CharT, _Traits>::sentry {
bool _M_ok;
public:
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef typename __istream_type::__ctype_type __ctype_type;
typedef typename _Traits::int_type __int_type;
# 692 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
explicit sentry(basic_istream<_CharT, _Traits> &__is,
bool __noskipws = false);
# 703 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
explicit operator bool() const { return _M_ok; }
};
# 721 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &operator>>(
basic_istream<_CharT, _Traits> & __in, _CharT & __c);
template <class _Traits>
inline basic_istream<char, _Traits> &operator>>(
basic_istream<char, _Traits> & __in, unsigned char & __c) {
return (__in >> reinterpret_cast<char &>(__c));
}
template <class _Traits>
inline basic_istream<char, _Traits> &operator>>(
basic_istream<char, _Traits> & __in, signed char & __c) {
return (__in >> reinterpret_cast<char &>(__c));
}
# 763 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &operator>>(
basic_istream<_CharT, _Traits> & __in, _CharT * __s);
template <>
basic_istream<char> &operator>>(basic_istream<char> & __in, char * __s);
template <class _Traits>
inline basic_istream<char, _Traits> &operator>>(
basic_istream<char, _Traits> & __in, unsigned char * __s) {
return (__in >> reinterpret_cast<char *>(__s));
}
template <class _Traits>
inline basic_istream<char, _Traits> &operator>>(
basic_istream<char, _Traits> & __in, signed char * __s) {
return (__in >> reinterpret_cast<char *>(__s));
}
# 794 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
template <typename _CharT, typename _Traits>
class basic_iostream : public basic_istream<_CharT, _Traits>,
public basic_ostream<_CharT, _Traits> {
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
explicit basic_iostream(basic_streambuf<_CharT, _Traits> *__sb)
: __istream_type(__sb), __ostream_type(__sb) {}
virtual ~basic_iostream() {}
protected:
basic_iostream() : __istream_type(), __ostream_type() {}
};
# 854 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &ws(basic_istream<_CharT, _Traits> & __is);
# 870 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 3
template <typename _CharT, typename _Traits, typename _Tp>
inline basic_istream<_CharT, _Traits> &operator>>(
basic_istream<_CharT, _Traits> && __is, _Tp & __x) {
return (__is >> __x);
}
}
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/istream.tcc" 1 3
# 38 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/istream.tcc" 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>::sentry::sentry(
basic_istream<_CharT, _Traits> & __in, bool __noskip)
: _M_ok(false) {
ios_base::iostate __err = ios_base::goodbit;
if (__in.good()) {
if (__in.tie())
__in.tie()->flush();
if (!__noskip && bool(__in.flags() & ios_base::skipws)) {
const __int_type __eof = traits_type::eof();
__streambuf_type *__sb = __in.rdbuf();
__int_type __c = __sb->sgetc();
const __ctype_type &__ct = __check_facet(__in._M_ctype);
while (!traits_type::eq_int_type(__c, __eof) &&
__ct.is(ctype_base::space, traits_type::to_char_type(__c)))
__c = __sb->snextc();
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
}
}
if (__in.good() && __err == ios_base::goodbit)
_M_ok = true;
else {
__err |= ios_base::failbit;
__in.setstate(__err);
}
}
template <typename _CharT, typename _Traits>
template <typename _ValueT>
basic_istream<_CharT, _Traits> &basic_istream<_CharT, _Traits>::_M_extract(
_ValueT & __v) {
sentry __cerb(*this, false);
if (__cerb) {
ios_base::iostate __err = ios_base::goodbit;
try {
const __num_get_type &__ng = __check_facet(this->_M_num_get);
__ng.get(*this, 0, *this, __err, __v);
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
}
return *this;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &basic_istream<_CharT, _Traits>::operator>>(
short & __n) {
sentry __cerb(*this, false);
if (__cerb) {
ios_base::iostate __err = ios_base::goodbit;
try {
long __l;
const __num_get_type &__ng = __check_facet(this->_M_num_get);
__ng.get(*this, 0, *this, __err, __l);
if (__l < __gnu_cxx::__numeric_traits<short>::__min) {
__err |= ios_base::failbit;
__n = __gnu_cxx::__numeric_traits<short>::__min;
} else if (__l > __gnu_cxx::__numeric_traits<short>::__max) {
__err |= ios_base::failbit;
__n = __gnu_cxx::__numeric_traits<short>::__max;
} else
__n = short(__l);
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
}
return *this;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &basic_istream<_CharT, _Traits>::operator>>(
int & __n) {
sentry __cerb(*this, false);
if (__cerb) {
ios_base::iostate __err = ios_base::goodbit;
try {
long __l;
const __num_get_type &__ng = __check_facet(this->_M_num_get);
__ng.get(*this, 0, *this, __err, __l);
if (__l < __gnu_cxx::__numeric_traits<int>::__min) {
__err |= ios_base::failbit;
__n = __gnu_cxx::__numeric_traits<int>::__min;
} else if (__l > __gnu_cxx::__numeric_traits<int>::__max) {
__err |= ios_base::failbit;
__n = __gnu_cxx::__numeric_traits<int>::__max;
} else
__n = int(__l);
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
}
return *this;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &basic_istream<_CharT, _Traits>::operator>>(
__streambuf_type * __sbout) {
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, false);
if (__cerb && __sbout) {
try {
bool __ineof;
if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
__err |= ios_base::failbit;
if (__ineof)
__err |= ios_base::eofbit;
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::failbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::failbit);
}
} else if (!__sbout)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
template <typename _CharT, typename _Traits>
typename basic_istream<_CharT, _Traits>::int_type
basic_istream<_CharT, _Traits>::get(void) {
const int_type __eof = traits_type::eof();
int_type __c = __eof;
_M_gcount = 0;
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, true);
if (__cerb) {
try {
__c = this->rdbuf()->sbumpc();
if (!traits_type::eq_int_type(__c, __eof))
_M_gcount = 1;
else
__err |= ios_base::eofbit;
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
}
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return __c;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &basic_istream<_CharT, _Traits>::get(
char_type & __c) {
_M_gcount = 0;
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, true);
if (__cerb) {
try {
const int_type __cb = this->rdbuf()->sbumpc();
if (!traits_type::eq_int_type(__cb, traits_type::eof())) {
_M_gcount = 1;
__c = traits_type::to_char_type(__cb);
} else
__err |= ios_base::eofbit;
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
}
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &basic_istream<_CharT, _Traits>::get(
char_type * __s, streamsize __n, char_type __delim) {
_M_gcount = 0;
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, true);
if (__cerb) {
try {
const int_type __idelim = traits_type::to_int_type(__delim);
const int_type __eof = traits_type::eof();
__streambuf_type *__sb = this->rdbuf();
int_type __c = __sb->sgetc();
while (_M_gcount + 1 < __n && !traits_type::eq_int_type(__c, __eof) &&
!traits_type::eq_int_type(__c, __idelim)) {
*__s++ = traits_type::to_char_type(__c);
++_M_gcount;
__c = __sb->snextc();
}
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
}
if (__n > 0)
*__s = char_type();
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &basic_istream<_CharT, _Traits>::get(
__streambuf_type & __sb, char_type __delim) {
_M_gcount = 0;
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, true);
if (__cerb) {
try {
const int_type __idelim = traits_type::to_int_type(__delim);
const int_type __eof = traits_type::eof();
__streambuf_type *__this_sb = this->rdbuf();
int_type __c = __this_sb->sgetc();
char_type __c2 = traits_type::to_char_type(__c);
while (!traits_type::eq_int_type(__c, __eof) &&
!traits_type::eq_int_type(__c, __idelim) &&
!traits_type::eq_int_type(__sb.sputc(__c2), __eof)) {
++_M_gcount;
__c = __this_sb->snextc();
__c2 = traits_type::to_char_type(__c);
}
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
}
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &basic_istream<_CharT, _Traits>::getline(
char_type * __s, streamsize __n, char_type __delim) {
_M_gcount = 0;
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, true);
if (__cerb) {
try {
const int_type __idelim = traits_type::to_int_type(__delim);
const int_type __eof = traits_type::eof();
__streambuf_type *__sb = this->rdbuf();
int_type __c = __sb->sgetc();
while (_M_gcount + 1 < __n && !traits_type::eq_int_type(__c, __eof) &&
!traits_type::eq_int_type(__c, __idelim)) {
*__s++ = traits_type::to_char_type(__c);
__c = __sb->snextc();
++_M_gcount;
}
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
else {
if (traits_type::eq_int_type(__c, __idelim)) {
__sb->sbumpc();
++_M_gcount;
} else
__err |= ios_base::failbit;
}
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
}
if (__n > 0)
*__s = char_type();
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &basic_istream<_CharT, _Traits>::ignore(void) {
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb) {
ios_base::iostate __err = ios_base::goodbit;
try {
const int_type __eof = traits_type::eof();
__streambuf_type *__sb = this->rdbuf();
if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
__err |= ios_base::eofbit;
else
_M_gcount = 1;
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
}
return *this;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &basic_istream<_CharT, _Traits>::ignore(
streamsize __n) {
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb && __n > 0) {
ios_base::iostate __err = ios_base::goodbit;
try {
const int_type __eof = traits_type::eof();
__streambuf_type *__sb = this->rdbuf();
int_type __c = __sb->sgetc();
# 513 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/istream.tcc" 3
bool __large_ignore = false;
while (true) {
while (_M_gcount < __n && !traits_type::eq_int_type(__c, __eof)) {
++_M_gcount;
__c = __sb->snextc();
}
if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max &&
!traits_type::eq_int_type(__c, __eof)) {
_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__min;
__large_ignore = true;
} else
break;
}
if (__large_ignore)
_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
}
return *this;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &basic_istream<_CharT, _Traits>::ignore(
streamsize __n, int_type __delim) {
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb && __n > 0) {
ios_base::iostate __err = ios_base::goodbit;
try {
const int_type __eof = traits_type::eof();
__streambuf_type *__sb = this->rdbuf();
int_type __c = __sb->sgetc();
bool __large_ignore = false;
while (true) {
while (_M_gcount < __n && !traits_type::eq_int_type(__c, __eof) &&
!traits_type::eq_int_type(__c, __delim)) {
++_M_gcount;
__c = __sb->snextc();
}
if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max &&
!traits_type::eq_int_type(__c, __eof) &&
!traits_type::eq_int_type(__c, __delim)) {
_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__min;
__large_ignore = true;
} else
break;
}
if (__large_ignore)
_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
else if (traits_type::eq_int_type(__c, __delim)) {
if (_M_gcount < __gnu_cxx::__numeric_traits<streamsize>::__max)
++_M_gcount;
__sb->sbumpc();
}
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
}
return *this;
}
template <typename _CharT, typename _Traits>
typename basic_istream<_CharT, _Traits>::int_type
basic_istream<_CharT, _Traits>::peek(void) {
int_type __c = traits_type::eof();
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb) {
ios_base::iostate __err = ios_base::goodbit;
try {
__c = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(__c, traits_type::eof()))
__err |= ios_base::eofbit;
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
}
return __c;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &basic_istream<_CharT, _Traits>::read(
char_type * __s, streamsize __n) {
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb) {
ios_base::iostate __err = ios_base::goodbit;
try {
_M_gcount = this->rdbuf()->sgetn(__s, __n);
if (_M_gcount != __n)
__err |= (ios_base::eofbit | ios_base::failbit);
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
}
return *this;
}
template <typename _CharT, typename _Traits>
streamsize basic_istream<_CharT, _Traits>::readsome(char_type * __s,
streamsize __n) {
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb) {
ios_base::iostate __err = ios_base::goodbit;
try {
const streamsize __num = this->rdbuf()->in_avail();
if (__num > 0)
_M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
else if (__num == -1)
__err |= ios_base::eofbit;
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
}
return _M_gcount;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &basic_istream<_CharT, _Traits>::putback(
char_type __c) {
_M_gcount = 0;
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb) {
ios_base::iostate __err = ios_base::goodbit;
try {
const int_type __eof = traits_type::eof();
__streambuf_type *__sb = this->rdbuf();
if (!__sb || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
__err |= ios_base::badbit;
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
}
return *this;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &basic_istream<_CharT, _Traits>::unget(void) {
_M_gcount = 0;
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb) {
ios_base::iostate __err = ios_base::goodbit;
try {
const int_type __eof = traits_type::eof();
__streambuf_type *__sb = this->rdbuf();
if (!__sb || traits_type::eq_int_type(__sb->sungetc(), __eof))
__err |= ios_base::badbit;
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
}
return *this;
}
template <typename _CharT, typename _Traits>
int basic_istream<_CharT, _Traits>::sync(void) {
int __ret = -1;
sentry __cerb(*this, true);
if (__cerb) {
ios_base::iostate __err = ios_base::goodbit;
try {
__streambuf_type *__sb = this->rdbuf();
if (__sb) {
if (__sb->pubsync() == -1)
__err |= ios_base::badbit;
else
__ret = 0;
}
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
}
return __ret;
}
template <typename _CharT, typename _Traits>
typename basic_istream<_CharT, _Traits>::pos_type
basic_istream<_CharT, _Traits>::tellg(void) {
pos_type __ret = pos_type(-1);
sentry __cerb(*this, true);
if (__cerb) {
try {
if (!this->fail())
__ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
}
return __ret;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &basic_istream<_CharT, _Traits>::seekg(
pos_type __pos) {
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb) {
ios_base::iostate __err = ios_base::goodbit;
try {
if (!this->fail()) {
const pos_type __p = this->rdbuf()->pubseekpos(__pos, ios_base::in);
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
}
return *this;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &basic_istream<_CharT, _Traits>::seekg(
off_type __off, ios_base::seekdir __dir) {
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb) {
ios_base::iostate __err = ios_base::goodbit;
try {
if (!this->fail()) {
const pos_type __p =
this->rdbuf()->pubseekoff(__off, __dir, ios_base::in);
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
catch (__cxxabiv1::__forced_unwind &) {
this->_M_setstate(ios_base::badbit);
throw;
}
catch (...) {
this->_M_setstate(ios_base::badbit);
}
if (__err)
this->setstate(__err);
}
return *this;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &operator>>(
basic_istream<_CharT, _Traits> & __in, _CharT & __c) {
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef typename __istream_type::int_type __int_type;
typename __istream_type::sentry __cerb(__in, false);
if (__cerb) {
ios_base::iostate __err = ios_base::goodbit;
try {
const __int_type __cb = __in.rdbuf()->sbumpc();
if (!_Traits::eq_int_type(__cb, _Traits::eof()))
__c = _Traits::to_char_type(__cb);
else
__err |= (ios_base::eofbit | ios_base::failbit);
}
catch (__cxxabiv1::__forced_unwind &) {
__in._M_setstate(ios_base::badbit);
throw;
}
catch (...) {
__in._M_setstate(ios_base::badbit);
}
if (__err)
__in.setstate(__err);
}
return __in;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &operator>>(
basic_istream<_CharT, _Traits> & __in, _CharT * __s) {
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef typename _Traits::int_type int_type;
typedef _CharT char_type;
typedef ctype<_CharT> __ctype_type;
streamsize __extracted = 0;
ios_base::iostate __err = ios_base::goodbit;
typename __istream_type::sentry __cerb(__in, false);
if (__cerb) {
try {
streamsize __num = __in.width();
if (__num <= 0)
__num = __gnu_cxx::__numeric_traits<streamsize>::__max;
const __ctype_type &__ct = use_facet<__ctype_type>(__in.getloc());
const int_type __eof = _Traits::eof();
__streambuf_type *__sb = __in.rdbuf();
int_type __c = __sb->sgetc();
while (__extracted < __num - 1 && !_Traits::eq_int_type(__c, __eof) &&
!__ct.is(ctype_base::space, _Traits::to_char_type(__c))) {
*__s++ = _Traits::to_char_type(__c);
++__extracted;
__c = __sb->snextc();
}
if (_Traits::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
*__s = char_type();
__in.width(0);
}
catch (__cxxabiv1::__forced_unwind &) {
__in._M_setstate(ios_base::badbit);
throw;
}
catch (...) {
__in._M_setstate(ios_base::badbit);
}
}
if (!__extracted)
__err |= ios_base::failbit;
if (__err)
__in.setstate(__err);
return __in;
}
template <typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits> &ws(basic_istream<_CharT, _Traits> & __in) {
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef typename __istream_type::int_type __int_type;
typedef ctype<_CharT> __ctype_type;
const __ctype_type &__ct = use_facet<__ctype_type>(__in.getloc());
const __int_type __eof = _Traits::eof();
__streambuf_type *__sb = __in.rdbuf();
__int_type __c = __sb->sgetc();
while (!_Traits::eq_int_type(__c, __eof) &&
__ct.is(ctype_base::space, _Traits::to_char_type(__c)))
__c = __sb->snextc();
if (_Traits::eq_int_type(__c, __eof))
__in.setstate(ios_base::eofbit);
return __in;
}
extern template class basic_istream<char>;
extern template istream &ws(istream &);
extern template istream &operator>>(istream &, char &);
extern template istream &operator>>(istream &, char *);
extern template istream &operator>>(istream &, unsigned char &);
extern template istream &operator>>(istream &, signed char &);
extern template istream &operator>>(istream &, unsigned char *);
extern template istream &operator>>(istream &, signed char *);
extern template istream &istream::_M_extract(unsigned short &);
extern template istream &istream::_M_extract(unsigned int &);
extern template istream &istream::_M_extract(long &);
extern template istream &istream::_M_extract(unsigned long &);
extern template istream &istream::_M_extract(bool &);
extern template istream &istream::_M_extract(long long &);
extern template istream &istream::_M_extract(unsigned long long &);
extern template istream &istream::_M_extract(float &);
extern template istream &istream::_M_extract(double &);
extern template istream &istream::_M_extract(long double &);
extern template istream &istream::_M_extract(void *&);
extern template class basic_iostream<char>;
extern template class basic_istream<wchar_t>;
extern template wistream &ws(wistream &);
extern template wistream &operator>>(wistream &, wchar_t &);
extern template wistream &operator>>(wistream &, wchar_t *);
extern template wistream &wistream::_M_extract(unsigned short &);
extern template wistream &wistream::_M_extract(unsigned int &);
extern template wistream &wistream::_M_extract(long &);
extern template wistream &wistream::_M_extract(unsigned long &);
extern template wistream &wistream::_M_extract(bool &);
extern template wistream &wistream::_M_extract(long long &);
extern template wistream &wistream::_M_extract(unsigned long long &);
extern template wistream &wistream::_M_extract(float &);
extern template wistream &wistream::_M_extract(double &);
extern template wistream &wistream::_M_extract(long double &);
extern template wistream &wistream::_M_extract(void *&);
extern template class basic_iostream<wchar_t>;
}
# 880 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/istream" 2 3
# 41 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/iostream" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 60 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/iostream" 3
extern istream cin;
extern ostream cout;
extern ostream cerr;
extern ostream clog;
extern wistream wcin;
extern wostream wcout;
extern wostream wcerr;
extern wostream wclog;
static ios_base::Init __ioinit;
}
# 6 "./cxx_utils.hh" 2
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/memory" 1
# 47 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/memory" 3
# 64 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/memory" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_construct.h" 1 3
# 61 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_construct.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/alloc_traits.h" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/alloc_traits.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 1 3
# 39 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _Alloc, typename _Tp> class __alloctr_rebind_helper {
template <typename _Alloc2, typename _Tp2>
static constexpr true_type
_S_chk(typename _Alloc2::template rebind<_Tp2>::other *);
template <typename, typename> static constexpr false_type _S_chk(...);
public:
using __type = decltype(_S_chk<_Alloc, _Tp>(nullptr));
};
template <typename _Alloc, typename _Tp,
bool = __alloctr_rebind_helper<_Alloc, _Tp>::__type::value>
struct __alloctr_rebind;
template <typename _Alloc, typename _Tp>
struct __alloctr_rebind<_Alloc, _Tp, true> {
typedef typename _Alloc::template rebind<_Tp>::other __type;
};
template <template <typename, typename...> class _Alloc, typename _Tp,
typename _Up, typename... _Args>
struct __alloctr_rebind<_Alloc<_Up, _Args...>, _Tp, false> {
typedef _Alloc<_Tp, _Args...> __type;
};
template <typename _Alloc> struct allocator_traits {
typedef _Alloc allocator_type;
typedef typename _Alloc::value_type value_type;
# 95 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 3
private:
template <typename _Tp>
static typename _Tp::pointer _S_pointer_helper(_Tp *);
static value_type *_S_pointer_helper(...);
typedef decltype(_S_pointer_helper((_Alloc *)0)) __pointer;
public:
typedef __pointer pointer;
private:
template <typename _Tp>
static typename _Tp::const_pointer _S_const_pointer_helper(_Tp *);
static typename pointer_traits<pointer>::template rebind<const value_type>
_S_const_pointer_helper(...);
typedef decltype(_S_const_pointer_helper((_Alloc *)0)) __const_pointer;
public:
# 113 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 3
typedef __const_pointer const_pointer;
private:
template <typename _Tp>
static typename _Tp::void_pointer _S_void_pointer_helper(_Tp *);
static typename pointer_traits<pointer>::template rebind<void>
_S_void_pointer_helper(...);
typedef decltype(_S_void_pointer_helper((_Alloc *)0)) __void_pointer;
public:
# 124 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 3
typedef __void_pointer void_pointer;
private:
template <typename _Tp>
static typename _Tp::const_void_pointer _S_const_void_pointer_helper(_Tp *);
static typename pointer_traits<pointer>::template rebind<const void>
_S_const_void_pointer_helper(...);
typedef decltype(_S_const_void_pointer_helper((_Alloc *)0))
__const_void_pointer;
public:
# 135 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 3
typedef __const_void_pointer const_void_pointer;
private:
template <typename _Tp>
static typename _Tp::difference_type _S_difference_type_helper(_Tp *);
static typename pointer_traits<pointer>::difference_type
_S_difference_type_helper(...);
typedef decltype(_S_difference_type_helper((_Alloc *)0)) __difference_type;
public:
# 146 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 3
typedef __difference_type difference_type;
private:
template <typename _Tp>
static typename _Tp::size_type _S_size_type_helper(_Tp *);
static typename make_unsigned<difference_type>::type
_S_size_type_helper(...);
typedef decltype(_S_size_type_helper((_Alloc *)0)) __size_type;
public:
# 157 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 3
typedef __size_type size_type;
private:
template <typename _Tp>
static typename _Tp::propagate_on_container_copy_assignment
_S_propagate_on_container_copy_assignment_helper(_Tp *);
static false_type _S_propagate_on_container_copy_assignment_helper(...);
typedef decltype(_S_propagate_on_container_copy_assignment_helper(
(_Alloc *)0)) __propagate_on_container_copy_assignment;
public:
# 168 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 3
typedef __propagate_on_container_copy_assignment
propagate_on_container_copy_assignment;
private:
template <typename _Tp>
static typename _Tp::propagate_on_container_move_assignment
_S_propagate_on_container_move_assignment_helper(_Tp *);
static false_type _S_propagate_on_container_move_assignment_helper(...);
typedef decltype(_S_propagate_on_container_move_assignment_helper(
(_Alloc *)0)) __propagate_on_container_move_assignment;
public:
# 180 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 3
typedef __propagate_on_container_move_assignment
propagate_on_container_move_assignment;
private:
template <typename _Tp>
static typename _Tp::propagate_on_container_swap
_S_propagate_on_container_swap_helper(_Tp *);
static false_type _S_propagate_on_container_swap_helper(...);
typedef decltype(_S_propagate_on_container_swap_helper((_Alloc *)0))
__propagate_on_container_swap;
public:
# 192 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 3
typedef __propagate_on_container_swap propagate_on_container_swap;
template <typename _Tp>
using rebind_alloc = typename __alloctr_rebind<_Alloc, _Tp>::__type;
template <typename _Tp>
using rebind_traits = allocator_traits<rebind_alloc<_Tp> >;
private:
template <typename _Alloc2> struct __allocate_helper {
template <
typename _Alloc3,
typename = decltype(std::declval<_Alloc3 *>()->allocate(
std::declval<size_type>(), std::declval<const_void_pointer>()))>
static true_type __test(int);
template <typename> static false_type __test(...);
using type = decltype(__test<_Alloc>(0));
};
template <typename _Alloc2>
using __has_allocate = typename __allocate_helper<_Alloc2>::type;
template <typename _Alloc2, typename = _Require<__has_allocate<_Alloc2> > >
static pointer _S_allocate(_Alloc2 &__a, size_type __n,
const_void_pointer __hint) {
return __a.allocate(__n, __hint);
}
template <typename _Alloc2, typename _UnusedHint,
typename = _Require<__not_<__has_allocate<_Alloc2> > > >
static pointer _S_allocate(_Alloc2 &__a, size_type __n, _UnusedHint) {
return __a.allocate(__n);
}
template <typename _Tp, typename... _Args> struct __construct_helper {
template <typename _Alloc2,
typename = decltype(std::declval<_Alloc2 *>()->construct(
std::declval<_Tp *>(), std::declval<_Args>()...))>
static true_type __test(int);
template <typename> static false_type __test(...);
using type = decltype(__test<_Alloc>(0));
};
template <typename _Tp, typename... _Args>
using __has_construct = typename __construct_helper<_Tp, _Args...>::type;
template <typename _Tp, typename... _Args>
static _Require<__has_construct<_Tp, _Args...> >
_S_construct(_Alloc &__a, _Tp *__p, _Args &&... __args) {
__a.construct(__p, std::forward<_Args>(__args)...);
}
template <typename _Tp, typename... _Args>
static _Require<__and_<__not_<__has_construct<_Tp, _Args...> >,
is_constructible<_Tp, _Args...> > >
_S_construct(_Alloc &, _Tp *__p, _Args &&... __args) {
::new ((void *)__p) _Tp(std::forward<_Args>(__args)...);
}
template <typename _Tp> struct __destroy_helper {
template <typename _Alloc2,
typename = decltype(
std::declval<_Alloc2 *>()->destroy(std::declval<_Tp *>()))>
static true_type __test(int);
template <typename> static false_type __test(...);
using type = decltype(__test<_Alloc>(0));
};
template <typename _Tp>
using __has_destroy = typename __destroy_helper<_Tp>::type;
template <typename _Tp>
static _Require<__has_destroy<_Tp> > _S_destroy(_Alloc &__a, _Tp *__p) {
__a.destroy(__p);
}
template <typename _Tp>
static _Require<__not_<__has_destroy<_Tp> > > _S_destroy(_Alloc &,
_Tp *__p) {
__p->~_Tp();
}
template <typename _Alloc2> struct __maxsize_helper {
template <typename _Alloc3,
typename = decltype(std::declval<_Alloc3 *>()->max_size())>
static true_type __test(int);
template <typename> static false_type __test(...);
using type = decltype(__test<_Alloc2>(0));
};
template <typename _Alloc2>
using __has_max_size = typename __maxsize_helper<_Alloc2>::type;
template <typename _Alloc2, typename = _Require<__has_max_size<_Alloc2> > >
static size_type _S_max_size(_Alloc2 &__a, int) {
return __a.max_size();
}
template <typename _Alloc2,
typename = _Require<__not_<__has_max_size<_Alloc2> > > >
static size_type _S_max_size(_Alloc2 &, ...) {
return __gnu_cxx::__numeric_traits<size_type>::__max;
}
template <typename _Alloc2> struct __select_helper {
template <typename _Alloc3,
typename = decltype(std::declval<
_Alloc3 *>()->select_on_container_copy_construction())>
static true_type __test(int);
template <typename> static false_type __test(...);
using type = decltype(__test<_Alloc2>(0));
};
template <typename _Alloc2>
using __has_soccc = typename __select_helper<_Alloc2>::type;
template <typename _Alloc2, typename = _Require<__has_soccc<_Alloc2> > >
static _Alloc2 _S_select(_Alloc2 &__a, int) {
return __a.select_on_container_copy_construction();
}
template <typename _Alloc2,
typename = _Require<__not_<__has_soccc<_Alloc2> > > >
static _Alloc2 _S_select(_Alloc2 &__a, ...) {
return __a;
}
public:
# 355 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 3
static pointer allocate(_Alloc &__a, size_type __n) {
return __a.allocate(__n);
}
# 370 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 3
static pointer allocate(_Alloc &__a, size_type __n,
const_void_pointer __hint) {
return _S_allocate(__a, __n, __hint);
}
# 382 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 3
static void deallocate(_Alloc &__a, pointer __p, size_type __n) {
__a.deallocate(__p, __n);
}
# 396 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 3
template <typename _Tp, typename... _Args>
static auto construct(_Alloc &__a, _Tp *__p, _Args &&... __args)
-> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...)) {
_S_construct(__a, __p, std::forward<_Args>(__args)...);
}
# 409 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 3
template <class _Tp> static void destroy(_Alloc &__a, _Tp *__p) {
_S_destroy(__a, __p);
}
# 421 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 3
static size_type max_size(const _Alloc &__a) noexcept {
return _S_max_size(__a, 0);
}
# 432 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/alloc_traits.h" 3
static _Alloc select_on_container_copy_construction(const _Alloc &__rhs) {
return _S_select(__rhs, 0);
}
};
template <typename _Alloc>
inline void __do_alloc_on_copy(_Alloc & __one, const _Alloc & __two,
true_type) {
__one = __two;
}
template <typename _Alloc>
inline void __do_alloc_on_copy(_Alloc &, const _Alloc &, false_type) {}
template <typename _Alloc>
inline void __alloc_on_copy(_Alloc & __one, const _Alloc & __two) {
typedef allocator_traits<_Alloc> __traits;
typedef typename __traits::propagate_on_container_copy_assignment __pocca;
__do_alloc_on_copy(__one, __two, __pocca());
}
template <typename _Alloc> inline _Alloc __alloc_on_copy(const _Alloc & __a) {
typedef allocator_traits<_Alloc> __traits;
return __traits::select_on_container_copy_construction(__a);
}
template <typename _Alloc>
inline void __do_alloc_on_move(_Alloc & __one, _Alloc & __two, true_type) {
__one = std::move(__two);
}
template <typename _Alloc>
inline void __do_alloc_on_move(_Alloc &, _Alloc &, false_type) {}
template <typename _Alloc>
inline void __alloc_on_move(_Alloc & __one, _Alloc & __two) {
typedef allocator_traits<_Alloc> __traits;
typedef typename __traits::propagate_on_container_move_assignment __pocma;
__do_alloc_on_move(__one, __two, __pocma());
}
template <typename _Alloc>
inline void __do_alloc_on_swap(_Alloc & __one, _Alloc & __two, true_type) {
using std::swap;
swap(__one, __two);
}
template <typename _Alloc>
inline void __do_alloc_on_swap(_Alloc &, _Alloc &, false_type) {}
template <typename _Alloc>
inline void __alloc_on_swap(_Alloc & __one, _Alloc & __two) {
typedef allocator_traits<_Alloc> __traits;
typedef typename __traits::propagate_on_container_swap __pocs;
__do_alloc_on_swap(__one, __two, __pocs());
}
template <typename _Alloc> class __is_copy_insertable_impl {
typedef allocator_traits<_Alloc> _Traits;
template <typename _Up, typename = decltype(_Traits::construct(
std::declval<_Alloc &>(), std::declval<_Up *>(),
std::declval<const _Up &>()))>
static true_type _M_select(int);
template <typename _Up> static false_type _M_select(...);
public:
typedef decltype(_M_select<typename _Alloc::value_type>(0)) type;
};
template <typename _Alloc>
struct __is_copy_insertable : __is_copy_insertable_impl<_Alloc>::type {};
template <typename _Tp>
struct __is_copy_insertable<allocator<_Tp> > : is_copy_constructible<_Tp> {};
}
# 37 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/alloc_traits.h" 2 3
namespace __gnu_cxx __attribute__((__visibility__("default"))) {
template <typename _Alloc>
struct __allocator_always_compares_equal : std::false_type {};
template <typename _Tp>
struct __allocator_always_compares_equal<
std::allocator<_Tp> > : std::true_type {};
template <typename, typename> struct array_allocator;
template <typename _Tp, typename _Array>
struct __allocator_always_compares_equal<
array_allocator<_Tp, _Array> > : std::true_type {};
template <typename> struct bitmap_allocator;
template <typename _Tp>
struct __allocator_always_compares_equal<
bitmap_allocator<_Tp> > : std::true_type {};
template <typename> struct malloc_allocator;
template <typename _Tp>
struct __allocator_always_compares_equal<
malloc_allocator<_Tp> > : std::true_type {};
template <typename> struct mt_allocator;
template <typename _Tp>
struct __allocator_always_compares_equal<
mt_allocator<_Tp> > : std::true_type {};
template <typename> struct new_allocator;
template <typename _Tp>
struct __allocator_always_compares_equal<
new_allocator<_Tp> > : std::true_type {};
template <typename> struct pool_allocator;
template <typename _Tp>
struct __allocator_always_compares_equal<
pool_allocator<_Tp> > : std::true_type {};
template <typename _Alloc>
struct __alloc_traits : std::allocator_traits<_Alloc> {
typedef _Alloc allocator_type;
typedef std::allocator_traits<_Alloc> _Base_type;
typedef typename _Base_type::value_type value_type;
typedef typename _Base_type::pointer pointer;
typedef typename _Base_type::const_pointer const_pointer;
typedef typename _Base_type::size_type size_type;
typedef typename _Base_type::difference_type difference_type;
typedef value_type &reference;
typedef const value_type &const_reference;
using _Base_type::allocate;
using _Base_type::deallocate;
using _Base_type::construct;
using _Base_type::destroy;
using _Base_type::max_size;
private:
template <typename _Ptr>
using __is_custom_pointer = std::__and_<
std::is_same<pointer, _Ptr>, std::__not_<std::is_pointer<_Ptr> > >;
public:
template <typename _Ptr, typename... _Args>
static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
construct(_Alloc &__a, _Ptr __p, _Args &&... __args) {
_Base_type::construct(__a, std::addressof(*__p),
std::forward<_Args>(__args)...);
}
template <typename _Ptr>
static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
destroy(_Alloc &__a, _Ptr __p) {
_Base_type::destroy(__a, std::addressof(*__p));
}
static _Alloc _S_select_on_copy(const _Alloc &__a) {
return _Base_type::select_on_container_copy_construction(__a);
}
static void _S_on_swap(_Alloc &__a, _Alloc &__b) {
std::__alloc_on_swap(__a, __b);
}
static constexpr bool _S_propagate_on_copy_assign() {
return _Base_type::propagate_on_container_copy_assignment::value;
}
static constexpr bool _S_propagate_on_move_assign() {
return _Base_type::propagate_on_container_move_assignment::value;
}
static constexpr bool _S_propagate_on_swap() {
return _Base_type::propagate_on_container_swap::value;
}
static constexpr bool _S_always_equal() {
return __allocator_always_compares_equal<_Alloc>::value;
}
static constexpr bool _S_nothrow_move() {
return _S_propagate_on_move_assign() || _S_always_equal();
}
static constexpr bool _S_nothrow_swap() {
using std::swap;
return !_S_propagate_on_swap() ||
noexcept(swap(std::declval<_Alloc &>(), std::declval<_Alloc &>()));
}
template <typename _Tp> struct rebind {
typedef typename _Base_type::template rebind_alloc<_Tp> other;
};
# 210 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/alloc_traits.h" 3
};
}
# 62 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_construct.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _T1, typename... _Args>
inline void _Construct(_T1 * __p, _Args && ... __args) {
::new (static_cast<void *>(__p)) _T1(std::forward<_Args>(__args)...);
}
# 90 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_construct.h" 3
template <typename _Tp> inline void _Destroy(_Tp * __pointer) {
__pointer->~_Tp();
}
template <bool> struct _Destroy_aux {
template <typename _ForwardIterator>
static void __destroy(_ForwardIterator __first, _ForwardIterator __last) {
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
}
};
template <> struct _Destroy_aux<true> {
template <typename _ForwardIterator>
static void __destroy(_ForwardIterator, _ForwardIterator) {}
};
template <typename _ForwardIterator>
inline void _Destroy(_ForwardIterator __first, _ForwardIterator __last) {
typedef typename iterator_traits<_ForwardIterator>::value_type _Value_type;
std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::__destroy(__first,
__last);
}
template <typename _ForwardIterator, typename _Allocator>
void _Destroy(_ForwardIterator __first, _ForwardIterator __last,
_Allocator & __alloc) {
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
for (; __first != __last; ++__first)
__traits::destroy(__alloc, std::__addressof(*__first));
}
template <typename _ForwardIterator, typename _Tp>
inline void _Destroy(_ForwardIterator __first, _ForwardIterator __last,
allocator<_Tp> &) {
_Destroy(__first, __last);
}
}
# 65 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/memory" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_uninitialized.h" 1 3
# 59 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_uninitialized.h" 3
namespace std __attribute__((__visibility__("default"))) {
template <bool _TrivialValueTypes> struct __uninitialized_copy {
template <typename _InputIterator, typename _ForwardIterator>
static _ForwardIterator __uninit_copy(_InputIterator __first,
_InputIterator __last,
_ForwardIterator __result) {
_ForwardIterator __cur = __result;
try {
for (; __first != __last; ++__first, ++__cur)
std::_Construct(std::__addressof(*__cur), *__first);
return __cur;
}
catch (...) {
std::_Destroy(__result, __cur);
throw;
}
}
};
template <> struct __uninitialized_copy<true> {
template <typename _InputIterator, typename _ForwardIterator>
static _ForwardIterator __uninit_copy(_InputIterator __first,
_InputIterator __last,
_ForwardIterator __result) {
return std::copy(__first, __last, __result);
}
};
# 105 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_uninitialized.h" 3
template <typename _InputIterator, typename _ForwardIterator>
inline _ForwardIterator uninitialized_copy(_InputIterator __first,
_InputIterator __last,
_ForwardIterator __result) {
typedef typename iterator_traits<_InputIterator>::value_type _ValueType1;
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2;
typedef typename iterator_traits<_InputIterator>::reference _RefType;
const bool __assignable = is_assignable<_ValueType1, _RefType>::value;
return std::__uninitialized_copy < __is_trivial(_ValueType1) &&
__is_trivial(_ValueType2) &&
__assignable > ::__uninit_copy(__first, __last, __result);
}
template <bool _TrivialValueType> struct __uninitialized_fill {
template <typename _ForwardIterator, typename _Tp>
static void __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp &__x) {
_ForwardIterator __cur = __first;
try {
for (; __cur != __last; ++__cur)
std::_Construct(std::__addressof(*__cur), __x);
}
catch (...) {
std::_Destroy(__first, __cur);
throw;
}
}
};
template <> struct __uninitialized_fill<true> {
template <typename _ForwardIterator, typename _Tp>
static void __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp &__x) {
std::fill(__first, __last, __x);
}
};
# 170 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_uninitialized.h" 3
template <typename _ForwardIterator, typename _Tp>
inline void uninitialized_fill(_ForwardIterator __first,
_ForwardIterator __last, const _Tp & __x) {
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
const bool __assignable = is_copy_assignable<_ValueType>::value;
std::__uninitialized_fill < __is_trivial(_ValueType) &&
__assignable > ::__uninit_fill(__first, __last, __x);
}
template <bool _TrivialValueType> struct __uninitialized_fill_n {
template <typename _ForwardIterator, typename _Size, typename _Tp>
static void __uninit_fill_n(_ForwardIterator __first, _Size __n,
const _Tp &__x) {
_ForwardIterator __cur = __first;
try {
for (; __n > 0; --__n, ++__cur)
std::_Construct(std::__addressof(*__cur), __x);
}
catch (...) {
std::_Destroy(__first, __cur);
throw;
}
}
};
template <> struct __uninitialized_fill_n<true> {
template <typename _ForwardIterator, typename _Size, typename _Tp>
static void __uninit_fill_n(_ForwardIterator __first, _Size __n,
const _Tp &__x) {
std::fill_n(__first, __n, __x);
}
};
# 230 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_uninitialized.h" 3
template <typename _ForwardIterator, typename _Size, typename _Tp>
inline void uninitialized_fill_n(_ForwardIterator __first, _Size __n,
const _Tp & __x) {
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
const bool __assignable = is_copy_assignable<_ValueType>::value;
std::__uninitialized_fill_n < __is_trivial(_ValueType) &&
__assignable > ::__uninit_fill_n(__first, __n, __x);
}
template <typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
_ForwardIterator __uninitialized_copy_a(
_InputIterator __first, _InputIterator __last, _ForwardIterator __result,
_Allocator & __alloc) {
_ForwardIterator __cur = __result;
try {
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
for (; __first != __last; ++__first, ++__cur)
__traits::construct(__alloc, std::__addressof(*__cur), *__first);
return __cur;
}
catch (...) {
std::_Destroy(__result, __cur, __alloc);
throw;
}
}
template <typename _InputIterator, typename _ForwardIterator, typename _Tp>
inline _ForwardIterator __uninitialized_copy_a(
_InputIterator __first, _InputIterator __last, _ForwardIterator __result,
allocator<_Tp> &) {
return std::uninitialized_copy(__first, __last, __result);
}
template <typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
inline _ForwardIterator __uninitialized_move_a(
_InputIterator __first, _InputIterator __last, _ForwardIterator __result,
_Allocator & __alloc) {
return std::__uninitialized_copy_a(std::make_move_iterator(__first),
std::make_move_iterator(__last),
__result, __alloc);
}
template <typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
inline _ForwardIterator __uninitialized_move_if_noexcept_a(
_InputIterator __first, _InputIterator __last, _ForwardIterator __result,
_Allocator & __alloc) {
return std::__uninitialized_copy_a(
std::__make_move_if_noexcept_iterator(__first),
std::__make_move_if_noexcept_iterator(__last), __result, __alloc);
}
template <typename _ForwardIterator, typename _Tp, typename _Allocator>
void __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp & __x, _Allocator & __alloc) {
_ForwardIterator __cur = __first;
try {
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
for (; __cur != __last; ++__cur)
__traits::construct(__alloc, std::__addressof(*__cur), __x);
}
catch (...) {
std::_Destroy(__first, __cur, __alloc);
throw;
}
}
template <typename _ForwardIterator, typename _Tp, typename _Tp2>
inline void __uninitialized_fill_a(_ForwardIterator __first,
_ForwardIterator __last, const _Tp & __x,
allocator<_Tp2> &) {
std::uninitialized_fill(__first, __last, __x);
}
template <typename _ForwardIterator, typename _Size, typename _Tp,
typename _Allocator>
void __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
const _Tp & __x, _Allocator & __alloc) {
_ForwardIterator __cur = __first;
try {
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
for (; __n > 0; --__n, ++__cur)
__traits::construct(__alloc, std::__addressof(*__cur), __x);
}
catch (...) {
std::_Destroy(__first, __cur, __alloc);
throw;
}
}
template <typename _ForwardIterator, typename _Size, typename _Tp,
typename _Tp2>
inline void __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
const _Tp & __x, allocator<_Tp2> &) {
std::uninitialized_fill_n(__first, __n, __x);
}
# 366 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_uninitialized.h" 3
template <typename _InputIterator1, typename _InputIterator2,
typename _ForwardIterator, typename _Allocator>
inline _ForwardIterator __uninitialized_copy_move(
_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_ForwardIterator __result, _Allocator & __alloc) {
_ForwardIterator __mid =
std::__uninitialized_copy_a(__first1, __last1, __result, __alloc);
try {
return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
}
catch (...) {
std::_Destroy(__result, __mid, __alloc);
throw;
}
}
template <typename _InputIterator1, typename _InputIterator2,
typename _ForwardIterator, typename _Allocator>
inline _ForwardIterator __uninitialized_move_copy(
_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_ForwardIterator __result, _Allocator & __alloc) {
_ForwardIterator __mid =
std::__uninitialized_move_a(__first1, __last1, __result, __alloc);
try {
return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
}
catch (...) {
std::_Destroy(__result, __mid, __alloc);
throw;
}
}
template <typename _ForwardIterator, typename _Tp, typename _InputIterator,
typename _Allocator>
inline _ForwardIterator __uninitialized_fill_move(
_ForwardIterator __result, _ForwardIterator __mid, const _Tp & __x,
_InputIterator __first, _InputIterator __last, _Allocator & __alloc) {
std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
try {
return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
}
catch (...) {
std::_Destroy(__result, __mid, __alloc);
throw;
}
}
template <typename _InputIterator, typename _ForwardIterator, typename _Tp,
typename _Allocator>
inline void __uninitialized_move_fill(
_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2, _ForwardIterator __last2, const _Tp & __x,
_Allocator & __alloc) {
_ForwardIterator __mid2 =
std::__uninitialized_move_a(__first1, __last1, __first2, __alloc);
try {
std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
}
catch (...) {
std::_Destroy(__first2, __mid2, __alloc);
throw;
}
}
template <bool _TrivialValueType> struct __uninitialized_default_1 {
template <typename _ForwardIterator>
static void __uninit_default(_ForwardIterator __first,
_ForwardIterator __last) {
_ForwardIterator __cur = __first;
try {
for (; __cur != __last; ++__cur)
std::_Construct(std::__addressof(*__cur));
}
catch (...) {
std::_Destroy(__first, __cur);
throw;
}
}
};
template <> struct __uninitialized_default_1<true> {
template <typename _ForwardIterator>
static void __uninit_default(_ForwardIterator __first,
_ForwardIterator __last) {
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
std::fill(__first, __last, _ValueType());
}
};
template <bool _TrivialValueType> struct __uninitialized_default_n_1 {
template <typename _ForwardIterator, typename _Size>
static void __uninit_default_n(_ForwardIterator __first, _Size __n) {
_ForwardIterator __cur = __first;
try {
for (; __n > 0; --__n, ++__cur)
std::_Construct(std::__addressof(*__cur));
}
catch (...) {
std::_Destroy(__first, __cur);
throw;
}
}
};
template <> struct __uninitialized_default_n_1<true> {
template <typename _ForwardIterator, typename _Size>
static void __uninit_default_n(_ForwardIterator __first, _Size __n) {
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
std::fill_n(__first, __n, _ValueType());
}
};
template <typename _ForwardIterator>
inline void __uninitialized_default(_ForwardIterator __first,
_ForwardIterator __last) {
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
const bool __assignable = is_copy_assignable<_ValueType>::value;
std::__uninitialized_default_1 < __is_trivial(_ValueType) &&
__assignable > ::__uninit_default(__first, __last);
}
template <typename _ForwardIterator, typename _Size>
inline void __uninitialized_default_n(_ForwardIterator __first, _Size __n) {
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
const bool __assignable = is_copy_assignable<_ValueType>::value;
std::__uninitialized_default_n_1 < __is_trivial(_ValueType) &&
__assignable > ::__uninit_default_n(__first, __n);
}
template <typename _ForwardIterator, typename _Allocator>
void __uninitialized_default_a(
_ForwardIterator __first, _ForwardIterator __last, _Allocator & __alloc) {
_ForwardIterator __cur = __first;
try {
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
for (; __cur != __last; ++__cur)
__traits::construct(__alloc, std::__addressof(*__cur));
}
catch (...) {
std::_Destroy(__first, __cur, __alloc);
throw;
}
}
template <typename _ForwardIterator, typename _Tp>
inline void __uninitialized_default_a(
_ForwardIterator __first, _ForwardIterator __last, allocator<_Tp> &) {
std::__uninitialized_default(__first, __last);
}
template <typename _ForwardIterator, typename _Size, typename _Allocator>
void __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
_Allocator & __alloc) {
_ForwardIterator __cur = __first;
try {
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
for (; __n > 0; --__n, ++__cur)
__traits::construct(__alloc, std::__addressof(*__cur));
}
catch (...) {
std::_Destroy(__first, __cur, __alloc);
throw;
}
}
template <typename _ForwardIterator, typename _Size, typename _Tp>
inline void __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
allocator<_Tp> &) {
std::__uninitialized_default_n(__first, __n);
}
template <typename _InputIterator, typename _Size, typename _ForwardIterator>
_ForwardIterator __uninitialized_copy_n(_InputIterator __first, _Size __n,
_ForwardIterator __result,
input_iterator_tag) {
_ForwardIterator __cur = __result;
try {
for (; __n > 0; --__n, ++__first, ++__cur)
std::_Construct(std::__addressof(*__cur), *__first);
return __cur;
}
catch (...) {
std::_Destroy(__result, __cur);
throw;
}
}
template <typename _RandomAccessIterator, typename _Size,
typename _ForwardIterator>
inline _ForwardIterator __uninitialized_copy_n(
_RandomAccessIterator __first, _Size __n, _ForwardIterator __result,
random_access_iterator_tag) {
return std::uninitialized_copy(__first, __first + __n, __result);
}
# 671 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_uninitialized.h" 3
template <typename _InputIterator, typename _Size, typename _ForwardIterator>
inline _ForwardIterator uninitialized_copy_n(
_InputIterator __first, _Size __n, _ForwardIterator __result) {
return std::__uninitialized_copy_n(__first, __n, __result,
std::__iterator_category(__first));
}
}
# 66 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/memory" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_tempbuf.h" 1 3
# 62 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_tempbuf.h" 3
namespace std __attribute__((__visibility__("default"))) {
# 83 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_tempbuf.h" 3
template <typename _Tp>
pair<_Tp *, ptrdiff_t> get_temporary_buffer(ptrdiff_t __len) noexcept {
const ptrdiff_t __max =
__gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
if (__len > __max)
__len = __max;
while (__len > 0) {
_Tp *__tmp =
static_cast<_Tp *>(::operator new(__len * sizeof(_Tp), std::nothrow));
if (__tmp != 0)
return std::pair<_Tp *, ptrdiff_t>(__tmp, __len);
__len /= 2;
}
return std::pair<_Tp *, ptrdiff_t>(static_cast<_Tp *>(0), 0);
}
# 110 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_tempbuf.h" 3
template <typename _Tp> inline void return_temporary_buffer(_Tp * __p) {
::operator delete(__p, std::nothrow);
}
template <typename _ForwardIterator, typename _Tp> class _Temporary_buffer {
public:
typedef _Tp value_type;
typedef value_type *pointer;
typedef pointer iterator;
typedef ptrdiff_t size_type;
protected:
size_type _M_original_len;
size_type _M_len;
pointer _M_buffer;
public:
size_type size() const { return _M_len; }
size_type requested_size() const { return _M_original_len; }
iterator begin() { return _M_buffer; }
iterator end() { return _M_buffer + _M_len; }
_Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);
~_Temporary_buffer() {
std::_Destroy(_M_buffer, _M_buffer + _M_len);
std::return_temporary_buffer(_M_buffer);
}
private:
_Temporary_buffer(const _Temporary_buffer &);
void operator=(const _Temporary_buffer &);
};
template <bool> struct __uninitialized_construct_buf_dispatch {
template <typename _Pointer, typename _ForwardIterator>
static void __ucr(_Pointer __first, _Pointer __last,
_ForwardIterator __seed) {
if (__first == __last)
return;
_Pointer __cur = __first;
try {
std::_Construct(std::__addressof(*__first), std::move(*__seed));
_Pointer __prev = __cur;
++__cur;
for (; __cur != __last; ++__cur, ++__prev)
std::_Construct(std::__addressof(*__cur), std::move(*__prev));
*__seed = std::move(*__prev);
}
catch (...) {
std::_Destroy(__first, __cur);
throw;
}
}
};
template <> struct __uninitialized_construct_buf_dispatch<true> {
template <typename _Pointer, typename _ForwardIterator>
static void __ucr(_Pointer, _Pointer, _ForwardIterator) {}
};
# 229 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_tempbuf.h" 3
template <typename _Pointer, typename _ForwardIterator>
inline void __uninitialized_construct_buf(_Pointer __first, _Pointer __last,
_ForwardIterator __seed) {
typedef typename std::iterator_traits<_Pointer>::value_type _ValueType;
std::__uninitialized_construct_buf_dispatch<
__has_trivial_constructor(_ValueType)>::__ucr(__first, __last, __seed);
}
template <typename _ForwardIterator, typename _Tp>
_Temporary_buffer<_ForwardIterator, _Tp>::_Temporary_buffer(
_ForwardIterator __first, _ForwardIterator __last)
: _M_original_len(std::distance(__first, __last)), _M_len(0),
_M_buffer(0) {
try {
std::pair<pointer, size_type> __p(
std::get_temporary_buffer<value_type>(_M_original_len));
_M_buffer = __p.first;
_M_len = __p.second;
if (_M_buffer)
std::__uninitialized_construct_buf(_M_buffer, _M_buffer + _M_len,
__first);
}
catch (...) {
std::return_temporary_buffer(_M_buffer);
_M_buffer = 0;
_M_len = 0;
throw;
}
}
}
# 67 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/memory" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_raw_storage_iter.h" 1 3
# 59 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_raw_storage_iter.h" 3
namespace std __attribute__((__visibility__("default"))) {
template <class _OutputIterator, class _Tp>
class raw_storage_iterator
: public iterator<output_iterator_tag, void, void, void, void> {
protected:
_OutputIterator _M_iter;
public:
explicit raw_storage_iterator(_OutputIterator __x) : _M_iter(__x) {}
raw_storage_iterator &operator*() { return *this; }
raw_storage_iterator &operator=(const _Tp &__element) {
std::_Construct(std::__addressof(*_M_iter), __element);
return *this;
}
raw_storage_iterator<_OutputIterator, _Tp> &operator++() {
++_M_iter;
return *this;
}
raw_storage_iterator<_OutputIterator, _Tp> operator++(int) {
raw_storage_iterator<_OutputIterator, _Tp> __tmp = *this;
++_M_iter;
return __tmp;
}
};
}
# 68 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/memory" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/typeinfo" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/typeinfo" 3
#pragma GCC visibility push(default)
extern "C++" {
namespace __cxxabiv1 {
class __class_type_info;
}
# 80 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/typeinfo" 3
namespace std {
class type_info {
public:
virtual ~type_info();
const char *name() const noexcept {
return __name[0] == '*' ? __name + 1 : __name;
}
# 115 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/typeinfo" 3
bool before(const type_info &__arg) const noexcept {
return (__name[0] == '*' && __arg.__name[0] == '*')
? __name < __arg.__name
: __builtin_strcmp(__name, __arg.__name) < 0;
}
bool operator==(const type_info &__arg) const noexcept {
return ((__name == __arg.__name) ||
(__name[0] != '*' && __builtin_strcmp(__name, __arg.__name) == 0));
}
# 136 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/typeinfo" 3
bool operator!=(const type_info &__arg) const noexcept {
return !operator==(__arg);
}
size_t hash_code() const noexcept {
return _Hash_bytes(name(), __builtin_strlen(name()),
static_cast<size_t>(0xc70f6907UL));
}
virtual bool __is_pointer_p() const;
virtual bool __is_function_p() const;
virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
unsigned __outer) const;
virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
void **__obj_ptr) const;
protected:
const char *__name;
explicit type_info(const char *__n) : __name(__n) {}
private:
type_info &operator=(const type_info &);
type_info(const type_info &);
};
class bad_cast : public exception {
public:
bad_cast() noexcept {}
virtual ~bad_cast() noexcept;
virtual const char *what() const noexcept;
};
class bad_typeid : public exception {
public:
bad_typeid() noexcept {}
virtual ~bad_typeid() noexcept;
virtual const char *what() const noexcept;
};
}
}
#pragma GCC visibility pop
# 72 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/memory" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/concurrence.h" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/concurrence.h" 3
namespace __gnu_cxx __attribute__((__visibility__("default"))) {
enum _Lock_policy {
_S_single,
_S_mutex,
_S_atomic
};
static const _Lock_policy __default_lock_policy = _S_atomic;
# 67 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/concurrence.h" 3
class __concurrence_lock_error : public std::exception {
public:
virtual char const *what() const throw() {
return "__gnu_cxx::__concurrence_lock_error";
}
};
class __concurrence_unlock_error : public std::exception {
public:
virtual char const *what() const throw() {
return "__gnu_cxx::__concurrence_unlock_error";
}
};
class __concurrence_broadcast_error : public std::exception {
public:
virtual char const *what() const throw() {
return "__gnu_cxx::__concurrence_broadcast_error";
}
};
class __concurrence_wait_error : public std::exception {
public:
virtual char const *what() const throw() {
return "__gnu_cxx::__concurrence_wait_error";
}
};
inline void __throw_concurrence_lock_error() {
(throw(__concurrence_lock_error()));
}
inline void __throw_concurrence_unlock_error() {
(throw(__concurrence_unlock_error()));
}
inline void __throw_concurrence_broadcast_error() {
(throw(__concurrence_broadcast_error()));
}
inline void __throw_concurrence_wait_error() {
(throw(__concurrence_wait_error()));
}
class __mutex {
private:
__gthread_mutex_t _M_mutex = { 0x32AAABA7, { 0 } };
__mutex(const __mutex &);
__mutex &operator=(const __mutex &);
public:
__mutex() {}
# 147 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/concurrence.h" 3
void lock() {
if (__gthread_active_p()) {
if (__gthread_mutex_lock(&_M_mutex) != 0)
__throw_concurrence_lock_error();
}
}
void unlock() {
if (__gthread_active_p()) {
if (__gthread_mutex_unlock(&_M_mutex) != 0)
__throw_concurrence_unlock_error();
}
}
__gthread_mutex_t *gthread_mutex(void) { return &_M_mutex; }
};
class __recursive_mutex {
private:
__gthread_recursive_mutex_t _M_mutex;
__recursive_mutex(const __recursive_mutex &);
__recursive_mutex &operator=(const __recursive_mutex &);
public:
__recursive_mutex() {
if (__gthread_active_p())
__gthread_recursive_mutex_init_function(&_M_mutex);
}
~__recursive_mutex() {
if (__gthread_active_p())
__gthread_recursive_mutex_destroy(&_M_mutex);
}
void lock() {
if (__gthread_active_p()) {
if (__gthread_recursive_mutex_lock(&_M_mutex) != 0)
__throw_concurrence_lock_error();
}
}
void unlock() {
if (__gthread_active_p()) {
if (__gthread_recursive_mutex_unlock(&_M_mutex) != 0)
__throw_concurrence_unlock_error();
}
}
__gthread_recursive_mutex_t *gthread_recursive_mutex(void) {
return &_M_mutex;
}
};
class __scoped_lock {
public:
typedef __mutex __mutex_type;
private:
__mutex_type &_M_device;
__scoped_lock(const __scoped_lock &);
__scoped_lock &operator=(const __scoped_lock &);
public:
explicit __scoped_lock(__mutex_type &__name) : _M_device(__name) {
_M_device.lock();
}
~__scoped_lock() throw() { _M_device.unlock(); }
};
class __cond {
private:
__gthread_cond_t _M_cond = { 0x3CB0B1BB, { 0 } };
__cond(const __cond &);
__cond &operator=(const __cond &);
public:
__cond() {}
# 280 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/concurrence.h" 3
void broadcast() {
if (__gthread_active_p()) {
if (__gthread_cond_broadcast(&_M_cond) != 0)
__throw_concurrence_broadcast_error();
}
}
void wait(__mutex *mutex) {
{
if (__gthread_cond_wait(&_M_cond, mutex->gthread_mutex()) != 0)
__throw_concurrence_wait_error();
}
}
void wait_recursive(__recursive_mutex *mutex) {
{
if (__gthread_cond_wait_recursive(
&_M_cond, mutex->gthread_recursive_mutex()) != 0)
__throw_concurrence_wait_error();
}
}
};
}
# 75 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/memory" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/uses_allocator.h" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/uses_allocator.h" 3
namespace std __attribute__((__visibility__("default"))) {
struct allocator_arg_t {};
constexpr allocator_arg_t allocator_arg = allocator_arg_t();
template <typename _Tp> class __has_allocator_type_helper {
template <typename _Up> struct _Wrap_type {};
template <typename _Up>
static true_type __test(_Wrap_type<typename _Up::allocator_type> *);
template <typename _Up> static false_type __test(...);
public:
typedef decltype(__test<_Tp>(0)) type;
};
template <typename _Tp>
struct __has_allocator_type : public __has_allocator_type_helper<
typename remove_cv<_Tp>::type>::type {};
template <typename _Tp, typename _Alloc,
bool = __has_allocator_type<_Tp>::value>
struct __uses_allocator_helper : public false_type {};
template <typename _Tp, typename _Alloc>
struct __uses_allocator_helper<
_Tp, _Alloc,
true> : public integral_constant<bool,
is_convertible<
_Alloc,
typename _Tp::allocator_type>::
value> {};
template <typename _Tp, typename _Alloc>
struct uses_allocator
: public integral_constant<bool,
__uses_allocator_helper<_Tp, _Alloc>::value> {
};
template <typename _Tp, typename _Alloc, typename... _Args>
struct __uses_allocator_arg : is_constructible<_Tp, _Alloc, _Args...> {
static_assert(uses_allocator<_Tp, _Alloc>::value, "uses allocator");
};
struct __uses_alloc_base {};
struct __uses_alloc0 : __uses_alloc_base {
struct _Anything {
_Anything(...) {}
} _M_a;
};
template <typename _Alloc> struct __uses_alloc1 : __uses_alloc_base {
const _Alloc *_M_a;
};
template <typename _Alloc> struct __uses_alloc2 : __uses_alloc_base {
const _Alloc *_M_a;
};
template <bool, typename _Alloc, typename... _Args> struct __uses_alloc;
template <typename _Tp, typename _Alloc, typename... _Args>
struct __uses_alloc<
true, _Tp, _Alloc,
_Args...> : conditional<is_constructible<_Tp, allocator_arg_t, _Alloc,
_Args...>::value,
__uses_alloc1<_Alloc>,
__uses_alloc2<_Alloc> >::type {};
template <typename _Tp, typename _Alloc, typename... _Args>
struct __uses_alloc<false, _Tp, _Alloc, _Args...> : __uses_alloc0 {};
template <typename _Tp, typename _Alloc, typename... _Args>
struct __uses_alloc_impl : __uses_alloc<uses_allocator<_Tp, _Alloc>::value,
_Tp, _Alloc, _Args...> {};
template <typename _Tp, typename _Alloc, typename... _Args>
__uses_alloc_impl<_Tp, _Alloc, _Args...> __use_alloc(const _Alloc & __a) {
__uses_alloc_impl<_Tp, _Alloc, _Args...> __ret;
__ret._M_a = &__a;
return __ret;
}
}
# 78 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/memory" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 1 3
# 47 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/tuple" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/tuple" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/array" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/array" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/stdexcept" 1 3
# 37 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/stdexcept" 3
namespace std __attribute__((__visibility__("default"))) {
# 55 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/stdexcept" 3
class logic_error : public exception {
string _M_msg;
public:
explicit logic_error(const string &__arg);
virtual ~logic_error() noexcept;
virtual const char *what() const noexcept;
};
class domain_error : public logic_error {
public:
explicit domain_error(const string &__arg);
virtual ~domain_error() noexcept;
};
class invalid_argument : public logic_error {
public:
explicit invalid_argument(const string &__arg);
virtual ~invalid_argument() noexcept;
};
class length_error : public logic_error {
public:
explicit length_error(const string &__arg);
virtual ~length_error() noexcept;
};
class out_of_range : public logic_error {
public:
explicit out_of_range(const string &__arg);
virtual ~out_of_range() noexcept;
};
class runtime_error : public exception {
string _M_msg;
public:
explicit runtime_error(const string &__arg);
virtual ~runtime_error() noexcept;
virtual const char *what() const noexcept;
};
class range_error : public runtime_error {
public:
explicit range_error(const string &__arg);
virtual ~range_error() noexcept;
};
class overflow_error : public runtime_error {
public:
explicit overflow_error(const string &__arg);
virtual ~overflow_error() noexcept;
};
class underflow_error : public runtime_error {
public:
explicit underflow_error(const string &__arg);
virtual ~underflow_error() noexcept;
};
}
# 39 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/array" 2 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _Tp, std::size_t _Nm> struct __array_traits {
typedef _Tp _Type[_Nm];
static constexpr _Tp &_S_ref(const _Type &__t, std::size_t __n) noexcept {
return const_cast<_Tp &>(__t[__n]);
}
};
template <typename _Tp> struct __array_traits<_Tp, 0> {
struct _Type {};
static constexpr _Tp &_S_ref(const _Type &, std::size_t) noexcept {
return *static_cast<_Tp *>(nullptr);
}
};
# 80 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/array" 3
template <typename _Tp, std::size_t _Nm> struct array {
typedef _Tp value_type;
typedef value_type *pointer;
typedef const value_type *const_pointer;
typedef value_type &reference;
typedef const value_type &const_reference;
typedef value_type *iterator;
typedef const value_type *const_iterator;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::__array_traits<_Tp, _Nm> _AT_Type;
typename _AT_Type::_Type _M_elems;
void fill(const value_type &__u) { std::fill_n(begin(), size(), __u); }
void swap(array &__other) noexcept(noexcept(swap(std::declval<_Tp &>(),
std::declval<_Tp &>()))) {
std::swap_ranges(begin(), end(), __other.begin());
}
iterator begin() noexcept { return iterator(data()); }
const_iterator begin() const noexcept { return const_iterator(data()); }
iterator end() noexcept { return iterator(data() + _Nm); }
const_iterator end() const noexcept { return const_iterator(data() + _Nm); }
reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const noexcept {
return const_reverse_iterator(end());
}
reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
const_reverse_iterator rend() const noexcept {
return const_reverse_iterator(begin());
}
const_iterator cbegin() const noexcept { return const_iterator(data()); }
const_iterator cend() const noexcept {
return const_iterator(data() + _Nm);
}
const_reverse_iterator crbegin() const noexcept {
return const_reverse_iterator(end());
}
const_reverse_iterator crend() const noexcept {
return const_reverse_iterator(begin());
}
constexpr size_type size() const noexcept { return _Nm; }
constexpr size_type max_size() const noexcept { return _Nm; }
constexpr bool empty() const noexcept { return size() == 0; }
reference operator[](size_type __n) noexcept {
return _AT_Type::_S_ref(_M_elems, __n);
}
constexpr const_reference operator[](size_type __n) const noexcept {
return _AT_Type::_S_ref(_M_elems, __n);
}
reference at(size_type __n) {
if (__n >= _Nm)
std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) "
">= _Nm (which is %zu)"),
__n, _Nm);
return _AT_Type::_S_ref(_M_elems, __n);
}
constexpr const_reference at(size_type __n) const {
return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n)
: (std::__throw_out_of_range_fmt(
("array::at: __n (which is %zu) "
">= _Nm (which is %zu)"),
__n, _Nm),
_AT_Type::_S_ref(_M_elems, 0));
}
reference front() noexcept { return *begin(); }
constexpr const_reference front() const noexcept {
return _AT_Type::_S_ref(_M_elems, 0);
}
reference back() noexcept { return _Nm ? *(end() - 1) : *end(); }
constexpr const_reference back() const noexcept {
return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
: _AT_Type::_S_ref(_M_elems, 0);
}
pointer data() noexcept {
return std::__addressof(_AT_Type::_S_ref(_M_elems, 0));
}
const_pointer data() const noexcept {
return std::__addressof(_AT_Type::_S_ref(_M_elems, 0));
}
};
template <typename _Tp, std::size_t _Nm>
inline bool operator==(const array<_Tp, _Nm> & __one,
const array<_Tp, _Nm> & __two) {
return std::equal(__one.begin(), __one.end(), __two.begin());
}
template <typename _Tp, std::size_t _Nm>
inline bool operator!=(const array<_Tp, _Nm> & __one,
const array<_Tp, _Nm> & __two) {
return !(__one == __two);
}
template <typename _Tp, std::size_t _Nm>
inline bool operator<(const array<_Tp, _Nm> & __a,
const array<_Tp, _Nm> & __b) {
return std::lexicographical_compare(__a.begin(), __a.end(), __b.begin(),
__b.end());
}
template <typename _Tp, std::size_t _Nm>
inline bool operator>(const array<_Tp, _Nm> & __one,
const array<_Tp, _Nm> & __two) {
return __two < __one;
}
template <typename _Tp, std::size_t _Nm>
inline bool operator<=(const array<_Tp, _Nm> & __one,
const array<_Tp, _Nm> & __two) {
return !(__one > __two);
}
template <typename _Tp, std::size_t _Nm>
inline bool operator>=(const array<_Tp, _Nm> & __one,
const array<_Tp, _Nm> & __two) {
return !(__one < __two);
}
template <typename _Tp, std::size_t _Nm>
inline void swap(array<_Tp, _Nm> & __one, array<_Tp, _Nm> & __two) noexcept(
noexcept(__one.swap(__two))) {
__one.swap(__two);
}
template <std::size_t _Int, typename _Tp, std::size_t _Nm>
constexpr _Tp &get(array<_Tp, _Nm> & __arr) noexcept {
static_assert(_Int < _Nm, "index is out of bounds");
return std::__array_traits<_Tp, _Nm>::_S_ref(__arr._M_elems, _Int);
}
template <std::size_t _Int, typename _Tp, std::size_t _Nm>
constexpr _Tp &&get(array<_Tp, _Nm> && __arr) noexcept {
static_assert(_Int < _Nm, "index is out of bounds");
return std::move(get<_Int>(__arr));
}
template <std::size_t _Int, typename _Tp, std::size_t _Nm>
constexpr const _Tp &get(const array<_Tp, _Nm> & __arr) noexcept {
static_assert(_Int < _Nm, "index is out of bounds");
return std::__array_traits<_Tp, _Nm>::_S_ref(__arr._M_elems, _Int);
}
}
namespace std __attribute__((__visibility__("default"))) {
template <typename _Tp> class tuple_size;
template <typename _Tp, std::size_t _Nm>
struct tuple_size<std::array<_Tp, _Nm> > : public integral_constant<
std::size_t, _Nm> {};
template <std::size_t _Int, typename _Tp> class tuple_element;
template <std::size_t _Int, typename _Tp, std::size_t _Nm>
struct tuple_element<_Int, std::array<_Tp, _Nm> > {
static_assert(_Int < _Nm, "index is out of bounds");
typedef _Tp type;
};
}
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/tuple" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 52 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/tuple" 3
template <typename _Tp> struct __add_c_ref {
typedef const _Tp &type;
};
template <typename _Tp> struct __add_c_ref<_Tp &> {
typedef _Tp &type;
};
template <typename _Tp> struct __add_ref {
typedef _Tp &type;
};
template <typename _Tp> struct __add_ref<_Tp &> {
typedef _Tp &type;
};
template <typename _Tp> struct __add_r_ref {
typedef _Tp &&type;
};
template <typename _Tp> struct __add_r_ref<_Tp &> {
typedef _Tp &type;
};
template <std::size_t _Idx, typename _Head, bool _IsEmptyNotFinal>
struct _Head_base;
template <std::size_t _Idx, typename _Head>
struct _Head_base<_Idx, _Head, true> : public _Head {
constexpr _Head_base() : _Head() {}
constexpr _Head_base(const _Head &__h) : _Head(__h) {}
template <typename _UHead,
typename = typename enable_if<
!is_convertible<_UHead, __uses_alloc_base>::value>::type>
constexpr _Head_base(_UHead &&__h)
: _Head(std::forward<_UHead>(__h)) {}
_Head_base(__uses_alloc0) : _Head() {}
template <typename _Alloc>
_Head_base(__uses_alloc1<_Alloc> __a)
: _Head(allocator_arg, *__a._M_a) {}
template <typename _Alloc>
_Head_base(__uses_alloc2<_Alloc> __a)
: _Head(*__a._M_a) {}
template <typename _UHead>
_Head_base(__uses_alloc0, _UHead &&__uhead)
: _Head(std::forward<_UHead>(__uhead)) {}
template <typename _Alloc, typename _UHead>
_Head_base(__uses_alloc1<_Alloc> __a, _UHead &&__uhead)
: _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) {}
template <typename _Alloc, typename _UHead>
_Head_base(__uses_alloc2<_Alloc> __a, _UHead &&__uhead)
: _Head(std::forward<_UHead>(__uhead), *__a._M_a) {}
static constexpr _Head &_M_head(_Head_base &__b) noexcept { return __b; }
static constexpr const _Head &_M_head(const _Head_base &__b) noexcept {
return __b;
}
};
template <std::size_t _Idx, typename _Head>
struct _Head_base<_Idx, _Head, false> {
constexpr _Head_base() : _M_head_impl() {}
constexpr _Head_base(const _Head &__h) : _M_head_impl(__h) {}
template <typename _UHead,
typename = typename enable_if<
!is_convertible<_UHead, __uses_alloc_base>::value>::type>
constexpr _Head_base(_UHead &&__h)
: _M_head_impl(std::forward<_UHead>(__h)) {}
_Head_base(__uses_alloc0) : _M_head_impl() {}
template <typename _Alloc>
_Head_base(__uses_alloc1<_Alloc> __a)
: _M_head_impl(allocator_arg, *__a._M_a) {}
template <typename _Alloc>
_Head_base(__uses_alloc2<_Alloc> __a)
: _M_head_impl(*__a._M_a) {}
template <typename _UHead>
_Head_base(__uses_alloc0, _UHead &&__uhead)
: _M_head_impl(std::forward<_UHead>(__uhead)) {}
template <typename _Alloc, typename _UHead>
_Head_base(__uses_alloc1<_Alloc> __a, _UHead &&__uhead)
: _M_head_impl(allocator_arg, *__a._M_a,
std::forward<_UHead>(__uhead)) {}
template <typename _Alloc, typename _UHead>
_Head_base(__uses_alloc2<_Alloc> __a, _UHead &&__uhead)
: _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) {}
static constexpr _Head &_M_head(_Head_base &__b) noexcept {
return __b._M_head_impl;
}
static constexpr const _Head &_M_head(const _Head_base &__b) noexcept {
return __b._M_head_impl;
}
_Head _M_head_impl;
};
# 183 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/tuple" 3
template <std::size_t _Idx, typename... _Elements> struct _Tuple_impl;
template <std::size_t _Idx> struct _Tuple_impl<_Idx> {
template <std::size_t, typename...> friend class _Tuple_impl;
_Tuple_impl() = default;
template <typename _Alloc> _Tuple_impl(allocator_arg_t, const _Alloc &) {}
template <typename _Alloc>
_Tuple_impl(allocator_arg_t, const _Alloc &, const _Tuple_impl &) {}
template <typename _Alloc>
_Tuple_impl(allocator_arg_t, const _Alloc &, _Tuple_impl &&) {}
protected:
void _M_swap(_Tuple_impl &) noexcept {}
};
template <typename _Tp> struct __is_empty_non_tuple : is_empty<_Tp> {};
template <typename _El0, typename... _El>
struct __is_empty_non_tuple<tuple<_El0, _El...> > : false_type {};
template <typename _Tp>
using __empty_not_final = typename conditional<
__is_final(_Tp), false_type, __is_empty_non_tuple<_Tp> >::type;
template <std::size_t _Idx, typename _Head, typename... _Tail>
struct _Tuple_impl<_Idx, _Head,
_Tail...> : public _Tuple_impl<_Idx + 1, _Tail...>,
private _Head_base<
_Idx, _Head,
__empty_not_final<_Head>::value> {
template <std::size_t, typename...> friend class _Tuple_impl;
typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
static constexpr _Head &_M_head(_Tuple_impl &__t) noexcept {
return _Base::_M_head(__t);
}
static constexpr const _Head &_M_head(const _Tuple_impl &__t) noexcept {
return _Base::_M_head(__t);
}
static constexpr _Inherited &_M_tail(_Tuple_impl &__t) noexcept {
return __t;
}
static constexpr const _Inherited &
_M_tail(const _Tuple_impl &__t) noexcept {
return __t;
}
constexpr _Tuple_impl() : _Inherited(), _Base() {}
explicit constexpr _Tuple_impl(const _Head &__head, const _Tail &... __tail)
: _Inherited(__tail...), _Base(__head) {}
template <typename _UHead, typename... _UTail,
typename = typename enable_if<sizeof...(_Tail) ==
sizeof...(_UTail)>::type>
explicit constexpr _Tuple_impl(_UHead &&__head, _UTail &&... __tail)
: _Inherited(std::forward<_UTail>(__tail)...),
_Base(std::forward<_UHead>(__head)) {}
constexpr _Tuple_impl(const _Tuple_impl &) = default;
constexpr _Tuple_impl(_Tuple_impl &&__in) noexcept(
__and_<is_nothrow_move_constructible<_Head>,
is_nothrow_move_constructible<_Inherited> >::value)
: _Inherited(std::move(_M_tail(__in))),
_Base(std::forward<_Head>(_M_head(__in))) {}
template <typename... _UElements>
constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...> &__in)
: _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
_Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) {}
template <typename _UHead, typename... _UTails>
constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...> &&__in)
: _Inherited(
std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
_Base(std::forward<_UHead>(
_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) {}
template <typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc &__a)
: _Inherited(__tag, __a), _Base(__use_alloc<_Head>(__a)) {}
template <typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc &__a, const _Head &__head,
const _Tail &... __tail)
: _Inherited(__tag, __a, __tail...),
_Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) {}
template <typename _Alloc, typename _UHead, typename... _UTail,
typename = typename enable_if<sizeof...(_Tail) ==
sizeof...(_UTail)>::type>
_Tuple_impl(allocator_arg_t __tag, const _Alloc &__a, _UHead &&__head,
_UTail &&... __tail)
: _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
_Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
std::forward<_UHead>(__head)) {}
template <typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc &__a,
const _Tuple_impl &__in)
: _Inherited(__tag, __a, _M_tail(__in)),
_Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) {}
template <typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc &__a, _Tuple_impl &&__in)
: _Inherited(__tag, __a, std::move(_M_tail(__in))),
_Base(__use_alloc<_Head, _Alloc, _Head>(__a),
std::forward<_Head>(_M_head(__in))) {}
template <typename _Alloc, typename... _UElements>
_Tuple_impl(allocator_arg_t __tag, const _Alloc &__a,
const _Tuple_impl<_Idx, _UElements...> &__in)
: _Inherited(__tag, __a,
_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
_Base(__use_alloc<_Head, _Alloc, _Head>(__a),
_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) {}
template <typename _Alloc, typename _UHead, typename... _UTails>
_Tuple_impl(allocator_arg_t __tag, const _Alloc &__a,
_Tuple_impl<_Idx, _UHead, _UTails...> &&__in)
: _Inherited(
__tag, __a,
std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
_Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
std::forward<_UHead>(
_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) {}
_Tuple_impl &operator=(const _Tuple_impl &__in) {
_M_head(*this) = _M_head(__in);
_M_tail(*this) = _M_tail(__in);
return *this;
}
_Tuple_impl &operator=(_Tuple_impl &&__in) noexcept(
__and_<is_nothrow_move_assignable<_Head>,
is_nothrow_move_assignable<_Inherited> >::value) {
_M_head(*this) = std::forward<_Head>(_M_head(__in));
_M_tail(*this) = std::move(_M_tail(__in));
return *this;
}
template <typename... _UElements>
_Tuple_impl &operator=(const _Tuple_impl<_Idx, _UElements...> &__in) {
_M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
_M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in);
return *this;
}
template <typename _UHead, typename... _UTails>
_Tuple_impl &operator=(_Tuple_impl<_Idx, _UHead, _UTails...> &&__in) {
_M_head(*this) = std::forward<_UHead>(
_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
_M_tail(*this) =
std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
return *this;
}
protected:
void _M_swap(_Tuple_impl &__in) noexcept(
noexcept(swap(std::declval<_Head &>(), std::declval<_Head &>())) &&
noexcept(_M_tail(__in)._M_swap(_M_tail(__in)))) {
using std::swap;
swap(_M_head(*this), _M_head(__in));
_Inherited::_M_swap(_M_tail(__in));
}
};
template <typename... _Elements>
class tuple : public _Tuple_impl<0, _Elements...> {
typedef _Tuple_impl<0, _Elements...> _Inherited;
public:
constexpr tuple() : _Inherited() {}
explicit constexpr tuple(const _Elements &... __elements)
: _Inherited(__elements...) {}
template <typename... _UElements,
typename = typename enable_if<__and_<
is_convertible<_UElements, _Elements>...>::value>::type>
explicit constexpr tuple(_UElements &&... __elements)
: _Inherited(std::forward<_UElements>(__elements)...) {}
constexpr tuple(const tuple &) = default;
constexpr tuple(tuple &&) = default;
template <typename... _UElements,
typename = typename enable_if<__and_<is_convertible<
const _UElements &, _Elements>...>::value>::type>
constexpr tuple(const tuple<_UElements...> &__in)
: _Inherited(static_cast<const _Tuple_impl<0, _UElements...> &>(__in)) {
}
template <typename... _UElements,
typename = typename enable_if<__and_<
is_convertible<_UElements, _Elements>...>::value>::type>
constexpr tuple(tuple<_UElements...> &&__in)
: _Inherited(static_cast<_Tuple_impl<0, _UElements...> &&>(__in)) {}
template <typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc &__a)
: _Inherited(__tag, __a) {}
template <typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc &__a,
const _Elements &... __elements)
: _Inherited(__tag, __a, __elements...) {}
template <typename _Alloc, typename... _UElements,
typename = typename enable_if<sizeof...(_UElements) ==
sizeof...(_Elements)>::type>
tuple(allocator_arg_t __tag, const _Alloc &__a, _UElements &&... __elements)
: _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) {}
template <typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc &__a, const tuple &__in)
: _Inherited(__tag, __a, static_cast<const _Inherited &>(__in)) {}
template <typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc &__a, tuple &&__in)
: _Inherited(__tag, __a, static_cast<_Inherited &&>(__in)) {}
template <typename _Alloc, typename... _UElements,
typename = typename enable_if<sizeof...(_UElements) ==
sizeof...(_Elements)>::type>
tuple(allocator_arg_t __tag, const _Alloc &__a,
const tuple<_UElements...> &__in)
: _Inherited(__tag, __a,
static_cast<const _Tuple_impl<0, _UElements...> &>(__in)) {
}
template <typename _Alloc, typename... _UElements,
typename = typename enable_if<sizeof...(_UElements) ==
sizeof...(_Elements)>::type>
tuple(allocator_arg_t __tag, const _Alloc &__a, tuple<_UElements...> &&__in)
: _Inherited(__tag, __a,
static_cast<_Tuple_impl<0, _UElements...> &&>(__in)) {}
tuple &operator=(const tuple &__in) {
static_cast<_Inherited &>(*this) = __in;
return *this;
}
tuple &operator=(tuple &&__in) noexcept(
is_nothrow_move_assignable<_Inherited>::value) {
static_cast<_Inherited &>(*this) = std::move(__in);
return *this;
}
template <typename... _UElements,
typename = typename enable_if<sizeof...(_UElements) ==
sizeof...(_Elements)>::type>
tuple &operator=(const tuple<_UElements...> &__in) {
static_cast<_Inherited &>(*this) = __in;
return *this;
}
template <typename... _UElements,
typename = typename enable_if<sizeof...(_UElements) ==
sizeof...(_Elements)>::type>
tuple &operator=(tuple<_UElements...> &&__in) {
static_cast<_Inherited &>(*this) = std::move(__in);
return *this;
}
void swap(tuple &__in) noexcept(noexcept(__in._M_swap(__in))) {
_Inherited::_M_swap(__in);
}
};
template <> class tuple<> {
public:
void swap(tuple &) noexcept {}
};
template <typename _T1, typename _T2>
class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> {
typedef _Tuple_impl<0, _T1, _T2> _Inherited;
public:
constexpr tuple() : _Inherited() {}
explicit constexpr tuple(const _T1 &__a1, const _T2 &__a2)
: _Inherited(__a1, __a2) {}
template <
typename _U1, typename _U2,
typename = typename enable_if<__and_<
is_convertible<_U1, _T1>, is_convertible<_U2, _T2> >::value>::type>
explicit constexpr tuple(_U1 &&__a1, _U2 &&__a2)
: _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) {}
constexpr tuple(const tuple &) = default;
constexpr tuple(tuple &&) = default;
template <typename _U1, typename _U2,
typename = typename enable_if<
__and_<is_convertible<const _U1 &, _T1>,
is_convertible<const _U2 &, _T2> >::value>::type>
constexpr tuple(const tuple<_U1, _U2> &__in)
: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2> &>(__in)) {}
template <
typename _U1, typename _U2,
typename = typename enable_if<__and_<
is_convertible<_U1, _T1>, is_convertible<_U2, _T2> >::value>::type>
constexpr tuple(tuple<_U1, _U2> &&__in)
: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2> &&>(__in)) {}
template <typename _U1, typename _U2,
typename = typename enable_if<
__and_<is_convertible<const _U1 &, _T1>,
is_convertible<const _U2 &, _T2> >::value>::type>
constexpr tuple(const pair<_U1, _U2> &__in)
: _Inherited(__in.first, __in.second) {}
template <
typename _U1, typename _U2,
typename = typename enable_if<__and_<
is_convertible<_U1, _T1>, is_convertible<_U2, _T2> >::value>::type>
constexpr tuple(pair<_U1, _U2> &&__in)
: _Inherited(std::forward<_U1>(__in.first),
std::forward<_U2>(__in.second)) {}
template <typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc &__a)
: _Inherited(__tag, __a) {}
template <typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc &__a, const _T1 &__a1,
const _T2 &__a2)
: _Inherited(__tag, __a, __a1, __a2) {}
template <typename _Alloc, typename _U1, typename _U2>
tuple(allocator_arg_t __tag, const _Alloc &__a, _U1 &&__a1, _U2 &&__a2)
: _Inherited(__tag, __a, std::forward<_U1>(__a1),
std::forward<_U2>(__a2)) {}
template <typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc &__a, const tuple &__in)
: _Inherited(__tag, __a, static_cast<const _Inherited &>(__in)) {}
template <typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc &__a, tuple &&__in)
: _Inherited(__tag, __a, static_cast<_Inherited &&>(__in)) {}
template <typename _Alloc, typename _U1, typename _U2>
tuple(allocator_arg_t __tag, const _Alloc &__a, const tuple<_U1, _U2> &__in)
: _Inherited(__tag, __a,
static_cast<const _Tuple_impl<0, _U1, _U2> &>(__in)) {}
template <typename _Alloc, typename _U1, typename _U2>
tuple(allocator_arg_t __tag, const _Alloc &__a, tuple<_U1, _U2> &&__in)
: _Inherited(__tag, __a,
static_cast<_Tuple_impl<0, _U1, _U2> &&>(__in)) {}
template <typename _Alloc, typename _U1, typename _U2>
tuple(allocator_arg_t __tag, const _Alloc &__a, const pair<_U1, _U2> &__in)
: _Inherited(__tag, __a, __in.first, __in.second) {}
template <typename _Alloc, typename _U1, typename _U2>
tuple(allocator_arg_t __tag, const _Alloc &__a, pair<_U1, _U2> &&__in)
: _Inherited(__tag, __a, std::forward<_U1>(__in.first),
std::forward<_U2>(__in.second)) {}
tuple &operator=(const tuple &__in) {
static_cast<_Inherited &>(*this) = __in;
return *this;
}
tuple &operator=(tuple &&__in) noexcept(
is_nothrow_move_assignable<_Inherited>::value) {
static_cast<_Inherited &>(*this) = std::move(__in);
return *this;
}
template <typename _U1, typename _U2>
tuple &operator=(const tuple<_U1, _U2> &__in) {
static_cast<_Inherited &>(*this) = __in;
return *this;
}
template <typename _U1, typename _U2>
tuple &operator=(tuple<_U1, _U2> &&__in) {
static_cast<_Inherited &>(*this) = std::move(__in);
return *this;
}
template <typename _U1, typename _U2>
tuple &operator=(const pair<_U1, _U2> &__in) {
this->_M_head(*this) = __in.first;
this->_M_tail(*this)._M_head(*this) = __in.second;
return *this;
}
template <typename _U1, typename _U2>
tuple &operator=(pair<_U1, _U2> &&__in) {
this->_M_head(*this) = std::forward<_U1>(__in.first);
this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
return *this;
}
void swap(tuple &__in) noexcept(noexcept(__in._M_swap(__in))) {
_Inherited::_M_swap(__in);
}
};
template <std::size_t __i, typename _Tp> struct tuple_element;
template <std::size_t __i, typename _Head, typename... _Tail>
struct tuple_element<__i, tuple<_Head, _Tail...> > : tuple_element<
__i - 1,
tuple<_Tail...> > {};
template <typename _Head, typename... _Tail>
struct tuple_element<0, tuple<_Head, _Tail...> > {
typedef _Head type;
};
template <std::size_t __i, typename _Tp>
struct tuple_element<__i, const _Tp> {
typedef typename add_const<typename tuple_element<__i, _Tp>::type>::type
type;
};
template <std::size_t __i, typename _Tp>
struct tuple_element<__i, volatile _Tp> {
typedef typename add_volatile<typename tuple_element<__i, _Tp>::type>::type
type;
};
template <std::size_t __i, typename _Tp>
struct tuple_element<__i, const volatile _Tp> {
typedef typename add_cv<typename tuple_element<__i, _Tp>::type>::type type;
};
template <typename _Tp> struct tuple_size;
template <typename _Tp>
struct tuple_size<const _Tp> : public integral_constant<
typename remove_cv<decltype(
tuple_size<_Tp>::value)>::type,
tuple_size<_Tp>::value> {};
template <typename _Tp>
struct tuple_size<volatile _Tp> : public integral_constant<
typename remove_cv<decltype(
tuple_size<_Tp>::value)>::type,
tuple_size<_Tp>::value> {};
template <typename _Tp>
struct tuple_size<const volatile _Tp> : public integral_constant<
typename remove_cv<
decltype(tuple_size<
_Tp>::value)>::type,
tuple_size<_Tp>::value> {};
template <typename... _Elements>
struct tuple_size<tuple<_Elements...> > : public integral_constant<
std::size_t,
sizeof...(_Elements)> {};
template <std::size_t __i, typename _Head, typename... _Tail>
constexpr typename __add_ref<_Head>::type __get_helper(
_Tuple_impl<__i, _Head, _Tail...> & __t) noexcept {
return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t);
}
template <std::size_t __i, typename _Head, typename... _Tail>
constexpr typename __add_c_ref<_Head>::type __get_helper(
const _Tuple_impl<__i, _Head, _Tail...> & __t) noexcept {
return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t);
}
template <std::size_t __i, typename... _Elements>
constexpr typename __add_ref<
typename tuple_element<__i, tuple<_Elements...> >::type>::type
get(tuple<_Elements...> & __t) noexcept {
return __get_helper<__i>(__t);
}
template <std::size_t __i, typename... _Elements>
constexpr typename __add_c_ref<
typename tuple_element<__i, tuple<_Elements...> >::type>::type
get(const tuple<_Elements...> & __t) noexcept {
return __get_helper<__i>(__t);
}
template <std::size_t __i, typename... _Elements>
constexpr typename __add_r_ref<
typename tuple_element<__i, tuple<_Elements...> >::type>::type
get(tuple<_Elements...> && __t) noexcept {
return std::forward<
typename tuple_element<__i, tuple<_Elements...> >::type &&>(
get<__i>(__t));
}
# 803 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/tuple" 3
template <std::size_t __check_equal_size, std::size_t __i, std::size_t __j,
typename _Tp, typename _Up>
struct __tuple_compare;
template <std::size_t __i, std::size_t __j, typename _Tp, typename _Up>
struct __tuple_compare<0, __i, __j, _Tp, _Up> {
static constexpr bool __eq(const _Tp &__t, const _Up &__u) {
return (get<__i>(__t) == get<__i>(__u) &&
__tuple_compare<0, __i + 1, __j, _Tp, _Up>::__eq(__t, __u));
}
static constexpr bool __less(const _Tp &__t, const _Up &__u) {
return ((get<__i>(__t) < get<__i>(__u)) ||
!(get<__i>(__u) < get<__i>(__t)) &&
__tuple_compare<0, __i + 1, __j, _Tp, _Up>::__less(__t, __u));
}
};
template <std::size_t __i, typename _Tp, typename _Up>
struct __tuple_compare<0, __i, __i, _Tp, _Up> {
static constexpr bool __eq(const _Tp &, const _Up &) { return true; }
static constexpr bool __less(const _Tp &, const _Up &) { return false; }
};
template <typename... _TElements, typename... _UElements>
constexpr bool operator==(const tuple<_TElements...> & __t,
const tuple<_UElements...> & __u) {
typedef tuple<_TElements...> _Tp;
typedef tuple<_UElements...> _Up;
return bool(
__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value, 0,
tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u));
}
template <typename... _TElements, typename... _UElements>
constexpr bool operator<(const tuple<_TElements...> & __t,
const tuple<_UElements...> & __u) {
typedef tuple<_TElements...> _Tp;
typedef tuple<_UElements...> _Up;
return bool(
__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value, 0,
tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u));
}
template <typename... _TElements, typename... _UElements>
constexpr bool operator!=(const tuple<_TElements...> & __t,
const tuple<_UElements...> & __u) {
return !(__t == __u);
}
template <typename... _TElements, typename... _UElements>
constexpr bool operator>(const tuple<_TElements...> & __t,
const tuple<_UElements...> & __u) {
return __u < __t;
}
template <typename... _TElements, typename... _UElements>
constexpr bool operator<=(const tuple<_TElements...> & __t,
const tuple<_UElements...> & __u) {
return !(__u < __t);
}
template <typename... _TElements, typename... _UElements>
constexpr bool operator>=(const tuple<_TElements...> & __t,
const tuple<_UElements...> & __u) {
return !(__t < __u);
}
template <typename... _Elements>
constexpr tuple<typename __decay_and_strip<_Elements>::__type...> make_tuple(
_Elements && ... __args) {
typedef tuple<typename __decay_and_strip<_Elements>::__type...>
__result_type;
return __result_type(std::forward<_Elements>(__args)...);
}
template <typename... _Elements>
tuple<_Elements &&...> forward_as_tuple(_Elements && ... __args) noexcept {
return tuple < _Elements && ... > (std::forward<_Elements>(__args)...);
}
template <typename> struct __is_tuple_like_impl : false_type {};
template <typename... _Tps>
struct __is_tuple_like_impl<tuple<_Tps...> > : true_type {};
template <typename _T1, typename _T2>
struct __is_tuple_like_impl<pair<_T1, _T2> > : true_type {};
template <typename _Tp, std::size_t _Nm>
struct __is_tuple_like_impl<array<_Tp, _Nm> > : true_type {};
template <typename _Tp>
struct __is_tuple_like
: public __is_tuple_like_impl<typename std::remove_cv<
typename std::remove_reference<_Tp>::type>::type>::type {};
template <std::size_t, typename, typename, std::size_t>
struct __make_tuple_impl;
template <std::size_t _Idx, typename _Tuple, typename... _Tp, std::size_t _Nm>
struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm> {
typedef typename __make_tuple_impl<
_Idx + 1,
tuple<_Tp..., typename std::tuple_element<_Idx, _Tuple>::type>, _Tuple,
_Nm>::__type __type;
};
template <std::size_t _Nm, typename _Tuple, typename... _Tp>
struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm> {
typedef tuple<_Tp...> __type;
};
template <typename _Tuple>
struct __do_make_tuple
: public __make_tuple_impl<0, tuple<>, _Tuple,
std::tuple_size<_Tuple>::value> {};
template <typename _Tuple>
struct __make_tuple
: public __do_make_tuple<typename std::remove_cv<
typename std::remove_reference<_Tuple>::type>::type> {};
template <typename...> struct __combine_tuples;
template <> struct __combine_tuples<> {
typedef tuple<> __type;
};
template <typename... _Ts> struct __combine_tuples<tuple<_Ts...> > {
typedef tuple<_Ts...> __type;
};
template <typename... _T1s, typename... _T2s, typename... _Rem>
struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...> {
typedef typename __combine_tuples<tuple<_T1s..., _T2s...>, _Rem...>::__type
__type;
};
template <typename... _Tpls> struct __tuple_cat_result {
typedef typename __combine_tuples<
typename __make_tuple<_Tpls>::__type...>::__type __type;
};
template <typename...> struct __make_1st_indices;
template <> struct __make_1st_indices<> {
typedef std::_Index_tuple<> __type;
};
template <typename _Tp, typename... _Tpls>
struct __make_1st_indices<_Tp, _Tpls...> {
typedef typename std::_Build_index_tuple<std::tuple_size<
typename std::remove_reference<_Tp>::type>::value>::__type __type;
};
template <typename _Ret, typename _Indices, typename... _Tpls>
struct __tuple_concater;
template <typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...> {
template <typename... _Us>
static constexpr _Ret _S_do(_Tp &&__tp, _Tpls &&... __tps, _Us &&... __us) {
typedef typename __make_1st_indices<_Tpls...>::__type __idx;
typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
return __next::_S_do(std::forward<_Tpls>(__tps)...,
std::forward<_Us>(__us)...,
std::get<_Is>(std::forward<_Tp>(__tp))...);
}
};
template <typename _Ret> struct __tuple_concater<_Ret, std::_Index_tuple<> > {
template <typename... _Us> static constexpr _Ret _S_do(_Us &&... __us) {
return _Ret(std::forward<_Us>(__us)...);
}
};
template <typename... _Tpls, typename = typename enable_if<__and_<
__is_tuple_like<_Tpls>...>::value>::type>
constexpr auto tuple_cat(_Tpls && ... __tpls)
->typename __tuple_cat_result<_Tpls...>::__type {
typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
typedef typename __make_1st_indices<_Tpls...>::__type __idx;
typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
}
template <typename... _Elements>
inline tuple<_Elements &...> tie(_Elements & ... __args) noexcept {
return tuple<_Elements &...>(__args...);
}
template <typename... _Elements>
inline void swap(tuple<_Elements...> & __x,
tuple<_Elements...> &
__y) noexcept(noexcept(__x.swap(__y))) {
__x.swap(__y);
}
struct _Swallow_assign {
template <class _Tp> const _Swallow_assign &operator=(const _Tp &) const {
return *this;
}
};
const _Swallow_assign ignore{};
template <typename... _Types, typename _Alloc>
struct uses_allocator<tuple<_Types...>, _Alloc> : true_type {};
template <class _T1, class _T2>
template <typename... _Args1, typename... _Args2>
inline pair<_T1, _T2>::pair(piecewise_construct_t, tuple<_Args1...> __first,
tuple<_Args2...> __second)
: pair(__first, __second,
typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
typename _Build_index_tuple<sizeof...(_Args2)>::__type()) {}
template <class _T1, class _T2>
template <typename... _Args1, std::size_t... _Indexes1, typename... _Args2,
std::size_t... _Indexes2>
inline pair<_T1, _T2>::pair(
tuple<_Args1...> & __tuple1, tuple<_Args2...> & __tuple2,
_Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
: first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...) {}
}
# 56 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 2 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _MemberPointer> class _Mem_fn;
template <typename _Tp, typename _Class>
_Mem_fn<_Tp _Class::*> mem_fn(_Tp _Class::*)noexcept;
template <typename _Tp> class __has_result_type_helper {
template <typename _Up> struct _Wrap_type {};
template <typename _Up>
static true_type __test(_Wrap_type<typename _Up::result_type> *);
template <typename _Up> static false_type __test(...);
public:
typedef decltype(__test<_Tp>(0)) type;
};
template <typename _Tp>
struct __has_result_type
: public __has_result_type_helper<typename remove_cv<_Tp>::type>::type {};
template <bool _Has_result_type, typename _Functor>
struct _Maybe_get_result_type {};
template <typename _Functor> struct _Maybe_get_result_type<true, _Functor> {
typedef typename _Functor::result_type result_type;
};
template <typename _Functor>
struct _Weak_result_type_impl
: _Maybe_get_result_type<__has_result_type<_Functor>::value, _Functor> {};
template <typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...)> {
typedef _Res result_type;
};
template <typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......)> {
typedef _Res result_type;
};
template <typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) const> {
typedef _Res result_type;
};
template <typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) const> {
typedef _Res result_type;
};
template <typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile> {
typedef _Res result_type;
};
template <typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile> {
typedef _Res result_type;
};
template <typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile> {
typedef _Res result_type;
};
template <typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile> {
typedef _Res result_type;
};
template <typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)> {
typedef _Res result_type;
};
template <typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)> {
typedef _Res result_type;
};
template <typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (*)(_ArgTypes...)> {
typedef _Res result_type;
};
template <typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (*)(_ArgTypes......)> {
typedef _Res result_type;
};
template <typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)> {
typedef _Res result_type;
};
template <typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)> {
typedef _Res result_type;
};
template <typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const> {
typedef _Res result_type;
};
template <typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const> {
typedef _Res result_type;
};
template <typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile> {
typedef _Res result_type;
};
template <typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile> {
typedef _Res result_type;
};
template <typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const volatile> {
typedef _Res result_type;
};
template <typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const
volatile> {
typedef _Res result_type;
};
template <typename _Functor>
struct _Weak_result_type
: _Weak_result_type_impl<typename remove_cv<_Functor>::type> {};
template <typename _Functor, typename... _Args>
inline typename enable_if<
(!is_member_pointer<_Functor>::value && !is_function<_Functor>::value &&
!is_function<typename remove_pointer<_Functor>::type>::value),
typename result_of<_Functor &(_Args && ...)>::type>::type
__invoke(_Functor & __f, _Args && ... __args) {
return __f(std::forward<_Args>(__args)...);
}
template <typename _Functor, typename... _Args>
inline typename enable_if<
(is_member_pointer<_Functor>::value && !is_function<_Functor>::value &&
!is_function<typename remove_pointer<_Functor>::type>::value),
typename result_of<_Functor(_Args && ...)>::type>::type
__invoke(_Functor & __f, _Args && ... __args) {
return std::mem_fn(__f)(std::forward<_Args>(__args)...);
}
template <typename _Functor, typename... _Args>
inline typename enable_if<
(is_pointer<_Functor>::value &&
is_function<typename remove_pointer<_Functor>::type>::value),
typename result_of<_Functor(_Args && ...)>::type>::type
__invoke(_Functor __f, _Args && ... __args) {
return __f(std::forward<_Args>(__args)...);
}
template <bool _Unary, bool _Binary, typename _Tp>
struct _Reference_wrapper_base_impl;
template <typename _Tp>
struct _Reference_wrapper_base_impl<false, false,
_Tp> : _Weak_result_type<_Tp> {};
template <typename _Tp>
struct _Reference_wrapper_base_impl<true, false,
_Tp> : _Weak_result_type<_Tp> {
typedef typename _Tp::argument_type argument_type;
};
template <typename _Tp>
struct _Reference_wrapper_base_impl<false, true,
_Tp> : _Weak_result_type<_Tp> {
typedef typename _Tp::first_argument_type first_argument_type;
typedef typename _Tp::second_argument_type second_argument_type;
};
template <typename _Tp>
struct _Reference_wrapper_base_impl<true, true,
_Tp> : _Weak_result_type<_Tp> {
typedef typename _Tp::argument_type argument_type;
typedef typename _Tp::first_argument_type first_argument_type;
typedef typename _Tp::second_argument_type second_argument_type;
};
template <typename _Tp> class __has_argument_type_helper {
template <typename _Up> struct _Wrap_type {};
template <typename _Up>
static true_type __test(_Wrap_type<typename _Up::argument_type> *);
template <typename _Up> static false_type __test(...);
public:
typedef decltype(__test<_Tp>(0)) type;
};
template <typename _Tp>
struct __has_argument_type
: public __has_argument_type_helper<typename remove_cv<_Tp>::type>::type {
};
template <typename _Tp> class __has_first_argument_type_helper {
template <typename _Up> struct _Wrap_type {};
template <typename _Up>
static true_type __test(_Wrap_type<typename _Up::first_argument_type> *);
template <typename _Up> static false_type __test(...);
public:
typedef decltype(__test<_Tp>(0)) type;
};
template <typename _Tp>
struct __has_first_argument_type
: public __has_first_argument_type_helper<
typename remove_cv<_Tp>::type>::type {};
template <typename _Tp> class __has_second_argument_type_helper {
template <typename _Up> struct _Wrap_type {};
template <typename _Up>
static true_type __test(_Wrap_type<typename _Up::second_argument_type> *);
template <typename _Up> static false_type __test(...);
public:
typedef decltype(__test<_Tp>(0)) type;
};
template <typename _Tp>
struct __has_second_argument_type
: public __has_second_argument_type_helper<
typename remove_cv<_Tp>::type>::type {};
template <typename _Tp>
struct _Reference_wrapper_base
: _Reference_wrapper_base_impl<__has_argument_type<_Tp>::value,
__has_first_argument_type<_Tp>::value &&
__has_second_argument_type<_Tp>::value,
_Tp> {};
template <typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1)> : unary_function<_T1, _Res> {};
template <typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) const> : unary_function<_T1, _Res> {
};
template <typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) volatile> : unary_function<_T1,
_Res> {};
template <typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) const
volatile> : unary_function<_T1, _Res> {};
template <typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2)> : binary_function<_T1, _T2,
_Res> {};
template <typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) const> : binary_function<
_T1, _T2, _Res> {};
template <typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<
_Res(_T1, _T2) volatile> : binary_function<_T1, _T2, _Res> {};
template <typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) const
volatile> : binary_function<_T1, _T2, _Res> {};
template <typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (*)(_T1)> : unary_function<_T1, _Res> {};
template <typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (*)(_T1, _T2)> : binary_function<_T1, _T2,
_Res> {};
template <typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)()> : unary_function<_T1 *,
_Res> {};
template <typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2)> : binary_function<
_T1 *, _T2, _Res> {};
template <typename _Res, typename _T1>
struct _Reference_wrapper_base<
_Res (_T1::*)() const> : unary_function<const _T1 *, _Res> {};
template <typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<
_Res (_T1::*)(_T2) const> : binary_function<const _T1 *, _T2, _Res> {};
template <typename _Res, typename _T1>
struct _Reference_wrapper_base<
_Res (_T1::*)() volatile> : unary_function<volatile _T1 *, _Res> {};
template <typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (
_T1::*)(_T2) volatile> : binary_function<volatile _T1 *, _T2, _Res> {};
template <typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (
_T1::*)() const volatile> : unary_function<const volatile _T1 *, _Res> {};
template <typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<
_Res (_T1::*)(_T2) const
volatile> : binary_function<const volatile _T1 *, _T2, _Res> {};
template <typename _Tp>
class reference_wrapper
: public _Reference_wrapper_base<typename remove_cv<_Tp>::type> {
_Tp *_M_data;
public:
typedef _Tp type;
reference_wrapper(_Tp &__indata) noexcept
: _M_data(std::__addressof(__indata)) {}
reference_wrapper(_Tp &&) = delete;
reference_wrapper(const reference_wrapper<_Tp> &__inref) noexcept
: _M_data(__inref._M_data) {}
reference_wrapper &
operator=(const reference_wrapper<_Tp> &__inref) noexcept {
_M_data = __inref._M_data;
return *this;
}
operator _Tp &() const noexcept { return this->get(); }
_Tp &get() const noexcept { return *_M_data; }
template <typename... _Args>
typename result_of<_Tp &(_Args &&...)>::type
operator()(_Args &&... __args) const {
return __invoke(get(), std::forward<_Args>(__args)...);
}
};
template <typename _Tp>
inline reference_wrapper<_Tp> ref(_Tp & __t) noexcept {
return reference_wrapper<_Tp>(__t);
}
template <typename _Tp>
inline reference_wrapper<const _Tp> cref(const _Tp & __t) noexcept {
return reference_wrapper<const _Tp>(__t);
}
template <typename _Tp> void ref(const _Tp && ) = delete;
template <typename _Tp> void cref(const _Tp && ) = delete;
template <typename _Tp>
inline reference_wrapper<_Tp> ref(reference_wrapper<_Tp> __t) noexcept {
return ref(__t.get());
}
template <typename _Tp>
inline reference_wrapper<const _Tp> cref(
reference_wrapper<_Tp> __t) noexcept {
return cref(__t.get());
}
template <typename... _Types>
struct _Pack : integral_constant<size_t, sizeof...(_Types)> {};
template <typename _From, typename _To, bool = _From::value == _To::value>
struct _AllConvertible : false_type {};
template <typename... _From, typename... _To>
struct _AllConvertible<_Pack<_From...>, _Pack<_To...>,
true> : __and_<is_convertible<_From, _To>...> {};
template <typename _Tp1, typename _Tp2>
using _NotSame = __not_<is_same<typename std::decay<_Tp1>::type,
typename std::decay<_Tp2>::type> >;
template <typename _Res, typename... _ArgTypes>
struct _Maybe_unary_or_binary_function {};
template <typename _Res, typename _T1>
struct _Maybe_unary_or_binary_function<_Res, _T1> : std::unary_function<
_T1, _Res> {};
template <typename _Res, typename _T1, typename _T2>
struct _Maybe_unary_or_binary_function<
_Res, _T1, _T2> : std::binary_function<_T1, _T2, _Res> {};
template <typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (
_Class::
*)(_ArgTypes...)> : public _Maybe_unary_or_binary_function<_Res,
_Class *,
_ArgTypes...> {
typedef _Res (_Class::*_Functor)(_ArgTypes...);
template <typename _Tp, typename... _Args>
_Res _M_call(_Tp &&__object, const volatile _Class *,
_Args &&... __args) const {
return (std::forward<_Tp>(__object).*
__pmf)(std::forward<_Args>(__args)...);
}
template <typename _Tp, typename... _Args>
_Res _M_call(_Tp &&__ptr, const volatile void *, _Args &&... __args) const {
return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...);
}
template <typename... _Args>
using _RequireValidArgs =
_Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...> > >;
template <typename _Tp, typename... _Args>
using _RequireValidArgs2 =
_Require<_NotSame<_Class, _Tp>, _NotSame<_Class *, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...> > >;
template <typename _Tp, typename... _Args>
using _RequireValidArgs3 =
_Require<is_base_of<_Class, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...> > >;
public:
typedef _Res result_type;
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) {}
template <typename... _Args, typename _Req = _RequireValidArgs<_Args...> >
_Res operator()(_Class &__object, _Args &&... __args) const {
return (__object.*__pmf)(std::forward<_Args>(__args)...);
}
template <typename... _Args, typename _Req = _RequireValidArgs<_Args...> >
_Res operator()(_Class &&__object, _Args &&... __args) const {
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template <typename... _Args, typename _Req = _RequireValidArgs<_Args...> >
_Res operator()(_Class *__object, _Args &&... __args) const {
return (__object->*__pmf)(std::forward<_Args>(__args)...);
}
template <typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs2<_Tp, _Args...> >
_Res operator()(_Tp &&__object, _Args &&... __args) const {
return _M_call(std::forward<_Tp>(__object), &__object,
std::forward<_Args>(__args)...);
}
template <typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs3<_Tp, _Args...> >
_Res operator()(reference_wrapper<_Tp> __ref, _Args &&... __args) const {
return operator()(__ref.get(), std::forward<_Args>(__args)...);
}
private:
_Functor __pmf;
};
template <typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (_Class::*)(_ArgTypes...)
const> : public _Maybe_unary_or_binary_function<_Res,
const _Class *,
_ArgTypes...> {
typedef _Res (_Class::*_Functor)(_ArgTypes...) const;
template <typename _Tp, typename... _Args>
_Res _M_call(_Tp &&__object, const volatile _Class *,
_Args &&... __args) const {
return (std::forward<_Tp>(__object).*
__pmf)(std::forward<_Args>(__args)...);
}
template <typename _Tp, typename... _Args>
_Res _M_call(_Tp &&__ptr, const volatile void *, _Args &&... __args) const {
return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...);
}
template <typename... _Args>
using _RequireValidArgs =
_Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...> > >;
template <typename _Tp, typename... _Args>
using _RequireValidArgs2 =
_Require<_NotSame<_Class, _Tp>, _NotSame<const _Class *, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...> > >;
template <typename _Tp, typename... _Args>
using _RequireValidArgs3 =
_Require<is_base_of<_Class, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...> > >;
public:
typedef _Res result_type;
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) {}
template <typename... _Args, typename _Req = _RequireValidArgs<_Args...> >
_Res operator()(const _Class &__object, _Args &&... __args) const {
return (__object.*__pmf)(std::forward<_Args>(__args)...);
}
template <typename... _Args, typename _Req = _RequireValidArgs<_Args...> >
_Res operator()(const _Class &&__object, _Args &&... __args) const {
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template <typename... _Args, typename _Req = _RequireValidArgs<_Args...> >
_Res operator()(const _Class *__object, _Args &&... __args) const {
return (__object->*__pmf)(std::forward<_Args>(__args)...);
}
template <typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs2<_Tp, _Args...> >
_Res operator()(_Tp &&__object, _Args &&... __args) const {
return _M_call(std::forward<_Tp>(__object), &__object,
std::forward<_Args>(__args)...);
}
template <typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs3<_Tp, _Args...> >
_Res operator()(reference_wrapper<_Tp> __ref, _Args &&... __args) const {
return operator()(__ref.get(), std::forward<_Args>(__args)...);
}
private:
_Functor __pmf;
};
template <typename _Res, typename _Class, typename... _ArgTypes>
class
_Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile> : public _Maybe_unary_or_binary_function<
_Res,
volatile _Class *,
_ArgTypes...> {
typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile;
template <typename _Tp, typename... _Args>
_Res _M_call(_Tp &&__object, const volatile _Class *,
_Args &&... __args) const {
return (std::forward<_Tp>(__object).*
__pmf)(std::forward<_Args>(__args)...);
}
template <typename _Tp, typename... _Args>
_Res _M_call(_Tp &&__ptr, const volatile void *, _Args &&... __args) const {
return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...);
}
template <typename... _Args>
using _RequireValidArgs =
_Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...> > >;
template <typename _Tp, typename... _Args>
using _RequireValidArgs2 =
_Require<_NotSame<_Class, _Tp>, _NotSame<volatile _Class *, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...> > >;
template <typename _Tp, typename... _Args>
using _RequireValidArgs3 =
_Require<is_base_of<_Class, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...> > >;
public:
typedef _Res result_type;
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) {}
template <typename... _Args, typename _Req = _RequireValidArgs<_Args...> >
_Res operator()(volatile _Class &__object, _Args &&... __args) const {
return (__object.*__pmf)(std::forward<_Args>(__args)...);
}
template <typename... _Args, typename _Req = _RequireValidArgs<_Args...> >
_Res operator()(volatile _Class &&__object, _Args &&... __args) const {
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template <typename... _Args, typename _Req = _RequireValidArgs<_Args...> >
_Res operator()(volatile _Class *__object, _Args &&... __args) const {
return (__object->*__pmf)(std::forward<_Args>(__args)...);
}
template <typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs2<_Tp, _Args...> >
_Res operator()(_Tp &&__object, _Args &&... __args) const {
return _M_call(std::forward<_Tp>(__object), &__object,
std::forward<_Args>(__args)...);
}
template <typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs3<_Tp, _Args...> >
_Res operator()(reference_wrapper<_Tp> __ref, _Args &&... __args) const {
return operator()(__ref.get(), std::forward<_Args>(__args)...);
}
private:
_Functor __pmf;
};
template <typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<
_Res (_Class::*)(_ArgTypes...) const
volatile> : public _Maybe_unary_or_binary_function<_Res,
const volatile _Class *,
_ArgTypes...> {
typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile;
template <typename _Tp, typename... _Args>
_Res _M_call(_Tp &&__object, const volatile _Class *,
_Args &&... __args) const {
return (std::forward<_Tp>(__object).*
__pmf)(std::forward<_Args>(__args)...);
}
template <typename _Tp, typename... _Args>
_Res _M_call(_Tp &&__ptr, const volatile void *, _Args &&... __args) const {
return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...);
}
template <typename... _Args>
using _RequireValidArgs =
_Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...> > >;
template <typename _Tp, typename... _Args>
using _RequireValidArgs2 =
_Require<_NotSame<_Class, _Tp>, _NotSame<const volatile _Class *, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...> > >;
template <typename _Tp, typename... _Args>
using _RequireValidArgs3 =
_Require<is_base_of<_Class, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...> > >;
public:
typedef _Res result_type;
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) {}
template <typename... _Args, typename _Req = _RequireValidArgs<_Args...> >
_Res operator()(const volatile _Class &__object, _Args &&... __args) const {
return (__object.*__pmf)(std::forward<_Args>(__args)...);
}
template <typename... _Args, typename _Req = _RequireValidArgs<_Args...> >
_Res operator()(const volatile _Class &&__object,
_Args &&... __args) const {
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template <typename... _Args, typename _Req = _RequireValidArgs<_Args...> >
_Res operator()(const volatile _Class *__object, _Args &&... __args) const {
return (__object->*__pmf)(std::forward<_Args>(__args)...);
}
template <typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs2<_Tp, _Args...> >
_Res operator()(_Tp &&__object, _Args &&... __args) const {
return _M_call(std::forward<_Tp>(__object), &__object,
std::forward<_Args>(__args)...);
}
template <typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs3<_Tp, _Args...> >
_Res operator()(reference_wrapper<_Tp> __ref, _Args &&... __args) const {
return operator()(__ref.get(), std::forward<_Args>(__args)...);
}
private:
_Functor __pmf;
};
template <typename _Tp, bool> struct _Mem_fn_const_or_non {
typedef const _Tp &type;
};
template <typename _Tp> struct _Mem_fn_const_or_non<_Tp, false> {
typedef _Tp &type;
};
template <typename _Res, typename _Class> class _Mem_fn<_Res _Class::*> {
using __pm_type = _Res _Class::*;
template <typename _Tp>
auto _M_call(_Tp &&__object, const _Class *) const
noexcept -> decltype(std::forward<_Tp>(__object).*
std::declval<__pm_type &>()) {
return std::forward<_Tp>(__object).*__pm;
}
template <typename _Tp, typename _Up>
auto _M_call(_Tp &&__object, _Up *const *) const
noexcept -> decltype((*std::forward<_Tp>(__object)).*
std::declval<__pm_type &>()) {
return (*std::forward<_Tp>(__object)).*__pm;
}
template <typename _Tp>
auto _M_call(_Tp &&__ptr, const volatile void *) const
noexcept(noexcept((*__ptr).*std::declval<__pm_type &>()))
-> decltype((*__ptr).*std::declval<__pm_type &>()) {
return (*__ptr).*__pm;
}
public:
explicit _Mem_fn(_Res _Class::*__pm) noexcept : __pm(__pm) {}
_Res &operator()(_Class &__object) const noexcept { return __object.*__pm; }
const _Res &operator()(const _Class &__object) const noexcept {
return __object.*__pm;
}
_Res &&operator()(_Class &&__object) const noexcept {
return std::forward<_Class>(__object).*__pm;
}
const _Res &&operator()(const _Class &&__object) const noexcept {
return std::forward<const _Class>(__object).*__pm;
}
_Res &operator()(_Class *__object) const noexcept {
return __object->*__pm;
}
const _Res &operator()(const _Class *__object) const noexcept {
return __object->*__pm;
}
template <typename _Tp, typename _Req = _Require<_NotSame<_Class *, _Tp> > >
auto operator()(_Tp &&__unknown) const
noexcept(noexcept(std::declval<_Mem_fn *>() -> _M_call(
std::forward<_Tp>(__unknown), &__unknown)))
-> decltype(this -> _M_call(std::forward<_Tp>(__unknown),
&__unknown)) {
return _M_call(std::forward<_Tp>(__unknown), &__unknown);
}
template <typename _Tp, typename _Req = _Require<is_base_of<_Class, _Tp> > >
auto operator()(reference_wrapper<_Tp> __ref) const
noexcept(noexcept(std::declval<_Mem_fn &>()(__ref.get())))
-> decltype((*this)(__ref.get())) {
return (*this)(__ref.get());
}
private:
_Res _Class::*__pm;
};
# 927 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
template <typename _Tp, typename _Class>
inline _Mem_fn<_Tp _Class::*> mem_fn(_Tp _Class::*__pm) noexcept {
return _Mem_fn<_Tp _Class::*>(__pm);
}
template <typename _Tp> struct is_bind_expression : public false_type {};
template <typename _Tp>
struct is_placeholder : public integral_constant<int, 0> {};
template <int _Num> struct _Placeholder {};
namespace placeholders {
extern const _Placeholder<1> _1;
extern const _Placeholder<2> _2;
extern const _Placeholder<3> _3;
extern const _Placeholder<4> _4;
extern const _Placeholder<5> _5;
extern const _Placeholder<6> _6;
extern const _Placeholder<7> _7;
extern const _Placeholder<8> _8;
extern const _Placeholder<9> _9;
extern const _Placeholder<10> _10;
extern const _Placeholder<11> _11;
extern const _Placeholder<12> _12;
extern const _Placeholder<13> _13;
extern const _Placeholder<14> _14;
extern const _Placeholder<15> _15;
extern const _Placeholder<16> _16;
extern const _Placeholder<17> _17;
extern const _Placeholder<18> _18;
extern const _Placeholder<19> _19;
extern const _Placeholder<20> _20;
extern const _Placeholder<21> _21;
extern const _Placeholder<22> _22;
extern const _Placeholder<23> _23;
extern const _Placeholder<24> _24;
extern const _Placeholder<25> _25;
extern const _Placeholder<26> _26;
extern const _Placeholder<27> _27;
extern const _Placeholder<28> _28;
extern const _Placeholder<29> _29;
}
# 1011 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
template <int _Num>
struct is_placeholder<_Placeholder<_Num> > : public integral_constant<int,
_Num> {
};
template <int _Num>
struct is_placeholder<const _Placeholder<_Num> > : public integral_constant<
int, _Num> {};
struct _No_tuple_element;
template <std::size_t __i, typename _Tuple, bool _IsSafe>
struct _Safe_tuple_element_impl : tuple_element<__i, _Tuple> {};
template <std::size_t __i, typename _Tuple>
struct _Safe_tuple_element_impl<__i, _Tuple, false> {
typedef _No_tuple_element type;
};
template <std::size_t __i, typename _Tuple>
struct _Safe_tuple_element
: _Safe_tuple_element_impl<__i, _Tuple,
(__i < tuple_size<_Tuple>::value)> {};
# 1068 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
template <typename _Arg, bool _IsBindExp = is_bind_expression<_Arg>::value,
bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
class _Mu;
template <typename _Tp> class _Mu<reference_wrapper<_Tp>, false, false> {
public:
typedef _Tp &result_type;
template <typename _CVRef, typename _Tuple>
result_type operator()(_CVRef &__arg, _Tuple &) const volatile {
return __arg.get();
}
};
template <typename _Arg> class _Mu<_Arg, true, false> {
public:
template <typename _CVArg, typename... _Args>
auto operator()(_CVArg &__arg, tuple<_Args...> &__tuple) const
volatile -> decltype(__arg(declval<_Args>()...)) {
typedef typename _Build_index_tuple<sizeof...(_Args)>::__type _Indexes;
return this->__call(__arg, __tuple, _Indexes());
}
private:
template <typename _CVArg, typename... _Args, std::size_t... _Indexes>
auto __call(_CVArg &__arg, tuple<_Args...> &__tuple,
const _Index_tuple<_Indexes...> &) const
volatile -> decltype(__arg(declval<_Args>()...)) {
return __arg(std::forward<_Args>(get<_Indexes>(__tuple))...);
}
};
template <typename _Arg> class _Mu<_Arg, false, true> {
public:
template <typename _Signature> class result;
template <typename _CVMu, typename _CVArg, typename _Tuple>
class result<_CVMu(_CVArg, _Tuple)> {
typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value - 1),
_Tuple>::type __base_type;
public:
typedef typename add_rvalue_reference<__base_type>::type type;
};
template <typename _Tuple>
typename result<_Mu(_Arg, _Tuple)>::type operator()(const volatile _Arg &,
_Tuple &__tuple) const
volatile {
return std::forward<typename result<_Mu(_Arg, _Tuple)>::type>(
::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
}
};
template <typename _Arg> class _Mu<_Arg, false, false> {
public:
template <typename _Signature> struct result;
template <typename _CVMu, typename _CVArg, typename _Tuple>
struct result<_CVMu(_CVArg, _Tuple)> {
typedef typename add_lvalue_reference<_CVArg>::type type;
};
template <typename _CVArg, typename _Tuple>
_CVArg &&operator()(_CVArg &&__arg, _Tuple &) const volatile {
return std::forward<_CVArg>(__arg);
}
};
template <typename _Tp> struct _Maybe_wrap_member_pointer {
typedef _Tp type;
static const _Tp &__do_wrap(const _Tp &__x) { return __x; }
static _Tp &&__do_wrap(_Tp &&__x) { return static_cast<_Tp &&>(__x); }
};
template <typename _Tp, typename _Class>
struct _Maybe_wrap_member_pointer<_Tp _Class::*> {
typedef _Mem_fn<_Tp _Class::*> type;
static type __do_wrap(_Tp _Class::*__pm) { return type(__pm); }
};
template <> struct _Maybe_wrap_member_pointer<void> {
typedef void type;
};
template <std::size_t _Ind, typename... _Tp>
inline auto __volget(volatile tuple<_Tp...> & __tuple)
->typename tuple_element<_Ind, tuple<_Tp...> >::type volatile &
{
return std::get<_Ind>(const_cast<tuple<_Tp...> &>(__tuple));
}
template <std::size_t _Ind, typename... _Tp>
inline auto __volget(const volatile tuple<_Tp...> & __tuple)
->typename tuple_element<_Ind, tuple<_Tp...> >::type const volatile &
{
return std::get<_Ind>(const_cast<const tuple<_Tp...> &>(__tuple));
}
template <typename _Signature> struct _Bind;
template <typename _Functor, typename... _Bound_args>
class _Bind<_Functor(_Bound_args...)> : public _Weak_result_type<_Functor> {
typedef _Bind __self_type;
typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
_Bound_indexes;
_Functor _M_f;
tuple<_Bound_args...> _M_bound_args;
template <typename _Result, typename... _Args, std::size_t... _Indexes>
_Result __call(tuple<_Args...> &&__args, _Index_tuple<_Indexes...>) {
return _M_f(_Mu<_Bound_args>()(get<_Indexes>(_M_bound_args), __args)...);
}
template <typename _Result, typename... _Args, std::size_t... _Indexes>
_Result __call_c(tuple<_Args...> &&__args,
_Index_tuple<_Indexes...>) const {
return _M_f(_Mu<_Bound_args>()(get<_Indexes>(_M_bound_args), __args)...);
}
template <typename _Result, typename... _Args, std::size_t... _Indexes>
_Result __call_v(tuple<_Args...> &&__args,
_Index_tuple<_Indexes...>) volatile {
return _M_f(
_Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...);
}
template <typename _Result, typename... _Args, std::size_t... _Indexes>
_Result __call_c_v(tuple<_Args...> &&__args,
_Index_tuple<_Indexes...>) const volatile {
return _M_f(
_Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...);
}
public:
template <typename... _Args>
explicit _Bind(const _Functor &__f, _Args &&... __args)
: _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) {}
template <typename... _Args>
explicit _Bind(_Functor &&__f, _Args &&... __args)
: _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) {}
_Bind(const _Bind &) = default;
_Bind(_Bind &&__b)
: _M_f(std::move(__b._M_f)),
_M_bound_args(std::move(__b._M_bound_args)) {}
template <typename... _Args,
typename _Result = decltype(std::declval<_Functor>()(
_Mu<_Bound_args>()(std::declval<_Bound_args &>(),
std::declval<tuple<_Args...> &>())...))>
_Result operator()(_Args &&... __args) {
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template <typename... _Args,
typename _Result = decltype(std::declval<typename enable_if<
(sizeof...(_Args) >= 0), typename add_const<_Functor>::type>::
type>()(
_Mu<_Bound_args>()(std::declval<const _Bound_args &>(),
std::declval<tuple<_Args...> &>())...))>
_Result operator()(_Args &&... __args) const {
return this->__call_c<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template <
typename... _Args,
typename _Result = decltype(std::declval<typename enable_if<
(sizeof...(_Args) >= 0), typename add_volatile<_Functor>::type>::
type>()(
_Mu<_Bound_args>()(std::declval<volatile _Bound_args &>(),
std::declval<tuple<_Args...> &>())...))>
_Result operator()(_Args &&... __args) volatile {
return this->__call_v<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template <typename... _Args,
typename _Result = decltype(std::declval<typename enable_if<
(sizeof...(_Args) >= 0), typename add_cv<_Functor>::type>::
type>()(_Mu<
_Bound_args>()(std::declval<const volatile _Bound_args &>(),
std::declval<tuple<_Args...> &>())...))>
_Result operator()(_Args &&... __args) const volatile {
return this->__call_c_v<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
};
template <typename _Result, typename _Signature> struct _Bind_result;
template <typename _Result, typename _Functor, typename... _Bound_args>
class _Bind_result<_Result, _Functor(_Bound_args...)> {
typedef _Bind_result __self_type;
typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
_Bound_indexes;
_Functor _M_f;
tuple<_Bound_args...> _M_bound_args;
template <typename _Res>
struct __enable_if_void : enable_if<is_void<_Res>::value, int> {};
template <typename _Res>
struct __disable_if_void : enable_if<!is_void<_Res>::value, int> {};
template <typename _Res, typename... _Args, std::size_t... _Indexes>
_Result __call(tuple<_Args...> &&__args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) {
return _M_f(_Mu<_Bound_args>()(get<_Indexes>(_M_bound_args), __args)...);
}
template <typename _Res, typename... _Args, std::size_t... _Indexes>
void __call(tuple<_Args...> &&__args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) {
_M_f(_Mu<_Bound_args>()(get<_Indexes>(_M_bound_args), __args)...);
}
template <typename _Res, typename... _Args, std::size_t... _Indexes>
_Result __call(tuple<_Args...> &&__args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) const {
return _M_f(_Mu<_Bound_args>()(get<_Indexes>(_M_bound_args), __args)...);
}
template <typename _Res, typename... _Args, std::size_t... _Indexes>
void __call(tuple<_Args...> &&__args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) const {
_M_f(_Mu<_Bound_args>()(get<_Indexes>(_M_bound_args), __args)...);
}
template <typename _Res, typename... _Args, std::size_t... _Indexes>
_Result __call(tuple<_Args...> &&__args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) volatile {
return _M_f(
_Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...);
}
template <typename _Res, typename... _Args, std::size_t... _Indexes>
void __call(tuple<_Args...> &&__args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) volatile {
_M_f(_Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...);
}
template <typename _Res, typename... _Args, std::size_t... _Indexes>
_Result __call(tuple<_Args...> &&__args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) const volatile {
return _M_f(
_Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...);
}
template <typename _Res, typename... _Args, std::size_t... _Indexes>
void __call(tuple<_Args...> &&__args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) const volatile {
_M_f(_Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...);
}
public:
typedef _Result result_type;
template <typename... _Args>
explicit _Bind_result(const _Functor &__f, _Args &&... __args)
: _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) {}
template <typename... _Args>
explicit _Bind_result(_Functor &&__f, _Args &&... __args)
: _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) {}
_Bind_result(const _Bind_result &) = default;
_Bind_result(_Bind_result &&__b)
: _M_f(std::move(__b._M_f)),
_M_bound_args(std::move(__b._M_bound_args)) {}
template <typename... _Args> result_type operator()(_Args &&... __args) {
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template <typename... _Args>
result_type operator()(_Args &&... __args) const {
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template <typename... _Args>
result_type operator()(_Args &&... __args) volatile {
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template <typename... _Args>
result_type operator()(_Args &&... __args) const volatile {
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
};
template <typename _Signature>
struct is_bind_expression<_Bind<_Signature> > : public true_type {};
template <typename _Signature>
struct is_bind_expression<const _Bind<_Signature> > : public true_type {};
template <typename _Signature>
struct is_bind_expression<volatile _Bind<_Signature> > : public true_type {};
template <typename _Signature>
struct is_bind_expression<
const volatile _Bind<_Signature> > : public true_type {};
template <typename _Result, typename _Signature>
struct is_bind_expression<
_Bind_result<_Result, _Signature> > : public true_type {};
template <typename _Result, typename _Signature>
struct is_bind_expression<
const _Bind_result<_Result, _Signature> > : public true_type {};
template <typename _Result, typename _Signature>
struct is_bind_expression<
volatile _Bind_result<_Result, _Signature> > : public true_type {};
template <typename _Result, typename _Signature>
struct is_bind_expression<
const volatile _Bind_result<_Result, _Signature> > : public true_type {};
template <typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2> >;
template <bool _SocketLike, typename _Func, typename... _BoundArgs>
struct _Bind_helper {
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
__maybe_type;
typedef typename __maybe_type::type __func_type;
typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
};
template <typename _Func, typename... _BoundArgs>
struct _Bind_helper<true, _Func, _BoundArgs...> {};
template <typename _Func, typename... _BoundArgs>
inline typename _Bind_helper<__is_socketlike<_Func>::value, _Func,
_BoundArgs...>::type bind(_Func && __f,
_BoundArgs &&
... __args) {
typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
typedef typename __helper_type::__maybe_type __maybe_type;
typedef typename __helper_type::type __result_type;
return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
std::forward<_BoundArgs>(__args)...);
}
template <typename _Result, typename _Func, typename... _BoundArgs>
struct _Bindres_helper {
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
__maybe_type;
typedef typename __maybe_type::type __functor_type;
typedef _Bind_result<
_Result, __functor_type(typename decay<_BoundArgs>::type...)> type;
};
template <typename _Result, typename _Func, typename... _BoundArgs>
inline typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type bind(
_Func && __f, _BoundArgs && ... __args) {
typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
typedef typename __helper_type::__maybe_type __maybe_type;
typedef typename __helper_type::type __result_type;
return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
std::forward<_BoundArgs>(__args)...);
}
template <typename _Signature> struct _Bind_simple;
template <typename _Callable, typename... _Args>
struct _Bind_simple<_Callable(_Args...)> {
typedef typename result_of<_Callable(_Args...)>::type result_type;
template <typename... _Args2,
typename = typename enable_if<sizeof...(_Args) ==
sizeof...(_Args2)>::type>
explicit _Bind_simple(const _Callable &__callable, _Args2 &&... __args)
: _M_bound(__callable, std::forward<_Args2>(__args)...) {}
template <typename... _Args2,
typename = typename enable_if<sizeof...(_Args) ==
sizeof...(_Args2)>::type>
explicit _Bind_simple(_Callable &&__callable, _Args2 &&... __args)
: _M_bound(std::move(__callable), std::forward<_Args2>(__args)...) {}
_Bind_simple(const _Bind_simple &) = default;
_Bind_simple(_Bind_simple &&) = default;
result_type operator()() {
typedef typename _Build_index_tuple<sizeof...(_Args)>::__type _Indices;
return _M_invoke(_Indices());
}
private:
template <std::size_t... _Indices>
typename result_of<_Callable(_Args...)>::type
_M_invoke(_Index_tuple<_Indices...>) {
return std::forward<_Callable>(std::get<0>(_M_bound))(
std::forward<_Args>(std::get<_Indices + 1>(_M_bound))...);
}
std::tuple<_Callable, _Args...> _M_bound;
};
template <typename _Func, typename... _BoundArgs> struct _Bind_simple_helper {
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
__maybe_type;
typedef typename __maybe_type::type __func_type;
typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)>
__type;
};
template <typename _Callable, typename... _Args>
typename _Bind_simple_helper<_Callable, _Args...>::__type __bind_simple(
_Callable && __callable, _Args && ... __args) {
typedef _Bind_simple_helper<_Callable, _Args...> __helper_type;
typedef typename __helper_type::__maybe_type __maybe_type;
typedef typename __helper_type::__type __result_type;
return __result_type(
__maybe_type::__do_wrap(std::forward<_Callable>(__callable)),
std::forward<_Args>(__args)...);
}
class bad_function_call : public std::exception {
public:
virtual ~bad_function_call() noexcept;
const char *what() const noexcept;
};
template <typename _Tp>
struct __is_location_invariant
: integral_constant<
bool, (is_pointer<_Tp>::value || is_member_pointer<_Tp>::value)> {};
class _Undefined_class;
union _Nocopy_types {
void *_M_object;
const void *_M_const_object;
void (*_M_function_pointer)();
void (_Undefined_class::*_M_member_pointer)();
};
union _Any_data {
void *_M_access() { return &_M_pod_data[0]; }
const void *_M_access() const { return &_M_pod_data[0]; }
template <typename _Tp> _Tp &_M_access() {
return *static_cast<_Tp *>(_M_access());
}
template <typename _Tp> const _Tp &_M_access() const {
return *static_cast<const _Tp *>(_M_access());
}
_Nocopy_types _M_unused;
char _M_pod_data[sizeof(_Nocopy_types)];
};
enum _Manager_operation {
__get_type_info,
__get_functor_ptr,
__clone_functor,
__destroy_functor
};
template <typename _Tp> struct _Simple_type_wrapper {
_Simple_type_wrapper(_Tp __value) : __value(__value) {}
_Tp __value;
};
template <typename _Tp>
struct __is_location_invariant<
_Simple_type_wrapper<_Tp> > : __is_location_invariant<_Tp> {};
template <typename _Functor>
inline _Functor &__callable_functor(_Functor & __f) {
return __f;
}
template <typename _Member, typename _Class>
inline _Mem_fn<_Member _Class::*> __callable_functor(_Member _Class::* &
__p) {
return std::mem_fn(__p);
}
template <typename _Member, typename _Class>
inline _Mem_fn<_Member _Class::*> __callable_functor(_Member _Class::*const &
__p) {
return std::mem_fn(__p);
}
template <typename _Member, typename _Class>
inline _Mem_fn<_Member _Class::*> __callable_functor(
_Member _Class::*volatile & __p) {
return std::mem_fn(__p);
}
template <typename _Member, typename _Class>
inline _Mem_fn<_Member _Class::*> __callable_functor(
_Member _Class::*const volatile & __p) {
return std::mem_fn(__p);
}
template <typename _Signature> class function;
class _Function_base {
public:
static const std::size_t _M_max_size = sizeof(_Nocopy_types);
static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
template <typename _Functor> class _Base_manager {
protected:
static const bool __stored_locally =
(__is_location_invariant<_Functor>::value &&
sizeof(_Functor) <= _M_max_size &&
__alignof__(_Functor) <= _M_max_align &&
(_M_max_align % __alignof__(_Functor) == 0));
typedef integral_constant<bool, __stored_locally> _Local_storage;
static _Functor *_M_get_pointer(const _Any_data &__source) {
const _Functor *__ptr =
__stored_locally ? std::__addressof(__source._M_access<_Functor>())
: __source._M_access<_Functor *>();
return const_cast<_Functor *>(__ptr);
}
static void _M_clone(_Any_data &__dest, const _Any_data &__source,
true_type) {
new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
}
static void _M_clone(_Any_data &__dest, const _Any_data &__source,
false_type) {
__dest._M_access<_Functor *>() =
new _Functor(*__source._M_access<_Functor *>());
}
static void _M_destroy(_Any_data &__victim, true_type) {
__victim._M_access<_Functor>().~_Functor();
}
static void _M_destroy(_Any_data &__victim, false_type) {
delete __victim._M_access<_Functor *>();
}
public:
static bool _M_manager(_Any_data &__dest, const _Any_data &__source,
_Manager_operation __op) {
switch (__op) {
case __get_type_info:
__dest._M_access<const type_info *>() = &typeid(_Functor);
break;
case __get_functor_ptr:
__dest._M_access<_Functor *>() = _M_get_pointer(__source);
break;
case __clone_functor:
_M_clone(__dest, __source, _Local_storage());
break;
case __destroy_functor:
_M_destroy(__dest, _Local_storage());
break;
}
return false;
}
static void _M_init_functor(_Any_data &__functor, _Functor &&__f) {
_M_init_functor(__functor, std::move(__f), _Local_storage());
}
template <typename _Signature>
static bool _M_not_empty_function(const function<_Signature> &__f) {
return static_cast<bool>(__f);
}
template <typename _Tp>
static bool _M_not_empty_function(_Tp *const &__fp) {
return __fp;
}
template <typename _Class, typename _Tp>
static bool _M_not_empty_function(_Tp _Class::*const &__mp) {
return __mp;
}
template <typename _Tp> static bool _M_not_empty_function(const _Tp &) {
return true;
}
private:
static void _M_init_functor(_Any_data &__functor, _Functor &&__f,
true_type) {
new (__functor._M_access()) _Functor(std::move(__f));
}
static void _M_init_functor(_Any_data &__functor, _Functor &&__f,
false_type) {
__functor._M_access<_Functor *>() = new _Functor(std::move(__f));
}
};
template <typename _Functor>
class _Ref_manager : public _Base_manager<_Functor *> {
typedef _Function_base::_Base_manager<_Functor *> _Base;
public:
static bool _M_manager(_Any_data &__dest, const _Any_data &__source,
_Manager_operation __op) {
switch (__op) {
case __get_type_info:
__dest._M_access<const type_info *>() = &typeid(_Functor);
break;
case __get_functor_ptr:
__dest._M_access<_Functor *>() = *_Base::_M_get_pointer(__source);
return is_const<_Functor>::value;
break;
default:
_Base::_M_manager(__dest, __source, __op);
}
return false;
}
static void _M_init_functor(_Any_data &__functor,
reference_wrapper<_Functor> __f) {
_Base::_M_init_functor(__functor, std::__addressof(__f.get()));
}
};
_Function_base() : _M_manager(0) {}
~_Function_base() {
if (_M_manager)
_M_manager(_M_functor, _M_functor, __destroy_functor);
}
bool _M_empty() const { return !_M_manager; }
typedef bool (*_Manager_type)(_Any_data &, const _Any_data &,
_Manager_operation);
_Any_data _M_functor;
_Manager_type _M_manager;
};
template <typename _Signature, typename _Functor> class _Function_handler;
template <typename _Res, typename _Functor, typename... _ArgTypes>
class _Function_handler<
_Res(_ArgTypes...),
_Functor> : public _Function_base::_Base_manager<_Functor> {
typedef _Function_base::_Base_manager<_Functor> _Base;
public:
static _Res _M_invoke(const _Any_data &__functor, _ArgTypes... __args) {
return (*_Base::_M_get_pointer(__functor))(
std::forward<_ArgTypes>(__args)...);
}
};
template <typename _Functor, typename... _ArgTypes>
class _Function_handler<
void(_ArgTypes...),
_Functor> : public _Function_base::_Base_manager<_Functor> {
typedef _Function_base::_Base_manager<_Functor> _Base;
public:
static void _M_invoke(const _Any_data &__functor, _ArgTypes... __args) {
(*_Base::_M_get_pointer(__functor))(std::forward<_ArgTypes>(__args)...);
}
};
template <typename _Res, typename _Functor, typename... _ArgTypes>
class _Function_handler<
_Res(_ArgTypes...),
reference_wrapper<
_Functor> > : public _Function_base::_Ref_manager<_Functor> {
typedef _Function_base::_Ref_manager<_Functor> _Base;
public:
static _Res _M_invoke(const _Any_data &__functor, _ArgTypes... __args) {
return __callable_functor (**_Base::_M_get_pointer(__functor))(
std::forward<_ArgTypes>(__args)...);
}
};
template <typename _Functor, typename... _ArgTypes>
class _Function_handler<
void(_ArgTypes...),
reference_wrapper<
_Functor> > : public _Function_base::_Ref_manager<_Functor> {
typedef _Function_base::_Ref_manager<_Functor> _Base;
public:
static void _M_invoke(const _Any_data &__functor, _ArgTypes... __args) {
__callable_functor (**_Base::_M_get_pointer(__functor))(
std::forward<_ArgTypes>(__args)...);
}
};
template <typename _Class, typename _Member, typename _Res,
typename... _ArgTypes>
class _Function_handler<
_Res(_ArgTypes...),
_Member _Class::*> : public _Function_handler<void(_ArgTypes...),
_Member _Class::*> {
typedef _Function_handler<void(_ArgTypes...), _Member _Class::*> _Base;
public:
static _Res _M_invoke(const _Any_data &__functor, _ArgTypes... __args) {
return std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
std::forward<_ArgTypes>(__args)...);
}
};
template <typename _Class, typename _Member, typename... _ArgTypes>
class _Function_handler<
void(_ArgTypes...),
_Member _Class::*> : public _Function_base::
_Base_manager<
_Simple_type_wrapper<_Member _Class::*> > {
typedef _Member _Class::*_Functor;
typedef _Simple_type_wrapper<_Functor> _Wrapper;
typedef _Function_base::_Base_manager<_Wrapper> _Base;
public:
static bool _M_manager(_Any_data &__dest, const _Any_data &__source,
_Manager_operation __op) {
switch (__op) {
case __get_type_info:
__dest._M_access<const type_info *>() = &typeid(_Functor);
break;
case __get_functor_ptr:
__dest._M_access<_Functor *>() =
&_Base::_M_get_pointer(__source)->__value;
break;
default:
_Base::_M_manager(__dest, __source, __op);
}
return false;
}
static void _M_invoke(const _Any_data &__functor, _ArgTypes... __args) {
std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
std::forward<_ArgTypes>(__args)...);
}
};
template <typename _From, typename _To>
using __check_func_return_type =
__or_<is_void<_To>, is_convertible<_From, _To> >;
template <typename _Res, typename... _ArgTypes>
class function<_Res(_ArgTypes...)> : public _Maybe_unary_or_binary_function<
_Res, _ArgTypes...>,
private _Function_base {
typedef _Res _Signature_type(_ArgTypes...);
template <typename _Functor>
using _Invoke = decltype(__callable_functor(std::declval<_Functor &>())(
std::declval<_ArgTypes>()...));
template <typename _Functor>
using _Callable = __check_func_return_type<_Invoke<_Functor>, _Res>;
template <typename _Cond, typename _Tp>
using _Requires = typename enable_if<_Cond::value, _Tp>::type;
public:
typedef _Res result_type;
function() noexcept : _Function_base() {}
function(nullptr_t) noexcept : _Function_base() {}
# 2185 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
function(const function &__x);
# 2194 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
function(function &&__x) : _Function_base() { __x.swap(*this); }
# 2217 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
template <typename _Functor,
typename = _Requires<_Callable<_Functor>, void> >
function(_Functor);
# 2233 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
function &operator=(const function &__x) {
function(__x).swap(*this);
return *this;
}
# 2251 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
function &operator=(function &&__x) {
function(std::move(__x)).swap(*this);
return *this;
}
# 2265 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
function &operator=(nullptr_t) {
if (_M_manager) {
_M_manager(_M_functor, _M_functor, __destroy_functor);
_M_manager = 0;
_M_invoker = 0;
}
return *this;
}
# 2293 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
template <typename _Functor>
_Requires<_Callable<_Functor>, function &> operator=(_Functor &&__f) {
function(std::forward<_Functor>(__f)).swap(*this);
return *this;
}
template <typename _Functor>
function &operator=(reference_wrapper<_Functor> __f) noexcept {
function(__f).swap(*this);
return *this;
}
# 2319 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
void swap(function &__x) {
std::swap(_M_functor, __x._M_functor);
std::swap(_M_manager, __x._M_manager);
std::swap(_M_invoker, __x._M_invoker);
}
# 2347 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
explicit operator bool() const noexcept { return !_M_empty(); }
# 2360 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
_Res operator()(_ArgTypes... __args) const;
# 2373 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
const type_info &target_type() const noexcept;
# 2384 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
template <typename _Functor> _Functor *target() noexcept;
template <typename _Functor> const _Functor *target() const noexcept;
private:
typedef _Res (*_Invoker_type)(const _Any_data &, _ArgTypes...);
_Invoker_type _M_invoker;
};
template <typename _Res, typename... _ArgTypes>
function<_Res(_ArgTypes...)>::function(const function & __x)
: _Function_base() {
if (static_cast<bool>(__x)) {
_M_invoker = __x._M_invoker;
_M_manager = __x._M_manager;
__x._M_manager(_M_functor, __x._M_functor, __clone_functor);
}
}
template <typename _Res, typename... _ArgTypes>
template <typename _Functor, typename>
function<_Res(_ArgTypes...)>::function(_Functor __f)
: _Function_base() {
typedef _Function_handler<_Signature_type, _Functor> _My_handler;
if (_My_handler::_M_not_empty_function(__f)) {
_My_handler::_M_init_functor(_M_functor, std::move(__f));
_M_invoker = &_My_handler::_M_invoke;
_M_manager = &_My_handler::_M_manager;
}
}
template <typename _Res, typename... _ArgTypes>
_Res function<_Res(_ArgTypes...)>::operator()(_ArgTypes... __args) const {
if (_M_empty())
__throw_bad_function_call();
return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
}
template <typename _Res, typename... _ArgTypes>
const type_info &function<_Res(_ArgTypes...)>::target_type() const noexcept {
if (_M_manager) {
_Any_data __typeinfo_result;
_M_manager(__typeinfo_result, _M_functor, __get_type_info);
return *__typeinfo_result._M_access<const type_info *>();
} else
return typeid(void);
}
template <typename _Res, typename... _ArgTypes>
template <typename _Functor>
_Functor *function<_Res(_ArgTypes...)>::target() noexcept {
if (typeid(_Functor) == target_type() && _M_manager) {
_Any_data __ptr;
if (_M_manager(__ptr, _M_functor, __get_functor_ptr) &&
!is_const<_Functor>::value)
return 0;
else
return __ptr._M_access<_Functor *>();
} else
return 0;
}
template <typename _Res, typename... _ArgTypes>
template <typename _Functor>
const _Functor *function<_Res(_ArgTypes...)>::target() const noexcept {
if (typeid(_Functor) == target_type() && _M_manager) {
_Any_data __ptr;
_M_manager(__ptr, _M_functor, __get_functor_ptr);
return __ptr._M_access<const _Functor *>();
} else
return 0;
}
# 2496 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
template <typename _Res, typename... _Args>
inline bool operator==(const function<_Res(_Args...)> & __f,
nullptr_t) noexcept {
return !static_cast<bool>(__f);
}
template <typename _Res, typename... _Args>
inline bool operator==(nullptr_t,
const function<_Res(_Args...)> & __f) noexcept {
return !static_cast<bool>(__f);
}
# 2514 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
template <typename _Res, typename... _Args>
inline bool operator!=(const function<_Res(_Args...)> & __f,
nullptr_t) noexcept {
return static_cast<bool>(__f);
}
template <typename _Res, typename... _Args>
inline bool operator!=(nullptr_t,
const function<_Res(_Args...)> & __f) noexcept {
return static_cast<bool>(__f);
}
# 2532 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/functional" 3
template <typename _Res, typename... _Args>
inline void swap(function<_Res(_Args...)> & __x,
function<_Res(_Args...)> & __y) {
__x.swap(__y);
}
}
# 80 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/memory" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/unique_ptr.h" 1 3
# 39 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/unique_ptr.h" 3
namespace std __attribute__((__visibility__("default"))) {
# 49 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/unique_ptr.h" 3
template <typename> class auto_ptr;
template <typename _Tp> struct default_delete {
constexpr default_delete() noexcept = default;
template <typename _Up, typename = typename enable_if<
is_convertible<_Up *, _Tp *>::value>::type>
default_delete(const default_delete<_Up> &) noexcept {}
void operator()(_Tp *__ptr) const {
static_assert(!is_void<_Tp>::value,
"can't delete pointer to incomplete type");
static_assert(sizeof(_Tp) > 0, "can't delete pointer to incomplete type");
delete __ptr;
}
};
template <typename _Tp> struct default_delete<_Tp[]> {
private:
template <typename _Up> using __remove_cv = typename remove_cv<_Up>::type;
template <typename _Up>
using __is_derived_Tp =
__and_<is_base_of<_Tp, _Up>,
__not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up> > > >;
public:
constexpr default_delete() noexcept = default;
# 109 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/unique_ptr.h" 3
template <typename _Up,
typename = typename enable_if<!__is_derived_Tp<_Up>::value>::type>
default_delete(const default_delete<_Up[]> &) noexcept {}
void operator()(_Tp *__ptr) const {
static_assert(sizeof(_Tp) > 0, "can't delete pointer to incomplete type");
delete[] __ptr;
}
template <typename _Up>
typename enable_if<__is_derived_Tp<_Up>::value>::type
operator()(_Up *) const = delete;
};
template <typename _Tp, typename _Dp = default_delete<_Tp> >
class unique_ptr {
class _Pointer {
template <typename _Up>
static typename _Up::pointer __test(typename _Up::pointer *);
template <typename _Up> static _Tp *__test(...);
typedef typename remove_reference<_Dp>::type _Del;
public:
typedef decltype(__test<_Del>(0)) type;
};
typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
__tuple_type _M_t;
public:
typedef typename _Pointer::type pointer;
typedef _Tp element_type;
typedef _Dp deleter_type;
constexpr unique_ptr() noexcept : _M_t() {
static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter");
}
explicit unique_ptr(pointer __p) noexcept : _M_t(__p, deleter_type()) {
static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter");
}
# 181 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/unique_ptr.h" 3
unique_ptr(
pointer __p,
typename conditional<is_reference<deleter_type>::value, deleter_type,
const deleter_type &>::type __d) noexcept
: _M_t(__p, __d) {}
# 193 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/unique_ptr.h" 3
unique_ptr(pointer __p,
typename remove_reference<deleter_type>::type &&__d) noexcept
: _M_t(std::move(__p), std::move(__d)) {
static_assert(!std::is_reference<deleter_type>::value,
"rvalue deleter bound to reference");
}
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() {}
unique_ptr(unique_ptr &&__u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) {}
template <
typename _Up, typename _Ep,
typename = _Require<
is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
__not_<is_array<_Up> >,
typename conditional<is_reference<_Dp>::value, is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp> >::type> >
unique_ptr(unique_ptr<_Up, _Ep> &&__u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) {}
template <typename _Up,
typename = _Require<is_convertible<_Up *, _Tp *>,
is_same<_Dp, default_delete<_Tp> > > >
unique_ptr(auto_ptr<_Up> &&__u) noexcept;
~unique_ptr() noexcept {
auto &__ptr = std::get<0>(_M_t);
if (__ptr != nullptr)
get_deleter()(__ptr);
__ptr = pointer();
}
# 248 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/unique_ptr.h" 3
unique_ptr &operator=(unique_ptr &&__u) noexcept {
reset(__u.release());
get_deleter() = std::forward<deleter_type>(__u.get_deleter());
return *this;
}
# 263 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/unique_ptr.h" 3
template <typename _Up, typename _Ep>
typename enable_if<
__and_<is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
__not_<is_array<_Up> > >::value,
unique_ptr &>::type
operator=(unique_ptr<_Up, _Ep> &&__u) noexcept {
reset(__u.release());
get_deleter() = std::forward<_Ep>(__u.get_deleter());
return *this;
}
unique_ptr &operator=(nullptr_t) noexcept {
reset();
return *this;
}
typename add_lvalue_reference<element_type>::type operator*() const {
;
return *get();
}
pointer operator->() const noexcept {
;
return get();
}
pointer get() const noexcept { return std::get<0>(_M_t); }
deleter_type &get_deleter() noexcept { return std::get<1>(_M_t); }
const deleter_type &get_deleter() const noexcept {
return std::get<1>(_M_t);
}
explicit operator bool() const noexcept {
return get() == pointer() ? false : true;
}
pointer release() noexcept {
pointer __p = get();
std::get<0>(_M_t) = pointer();
return __p;
}
void reset(pointer __p = pointer()) noexcept {
using std::swap;
swap(std::get<0>(_M_t), __p);
if (__p != pointer())
get_deleter()(__p);
}
void swap(unique_ptr &__u) noexcept {
using std::swap;
swap(_M_t, __u._M_t);
}
unique_ptr(const unique_ptr &) = delete;
unique_ptr &operator=(const unique_ptr &) = delete;
};
template <typename _Tp, typename _Dp> class unique_ptr<_Tp[], _Dp> {
class _Pointer {
template <typename _Up>
static typename _Up::pointer __test(typename _Up::pointer *);
template <typename _Up> static _Tp *__test(...);
typedef typename remove_reference<_Dp>::type _Del;
public:
typedef decltype(__test<_Del>(0)) type;
};
typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
__tuple_type _M_t;
template <typename _Up> using __remove_cv = typename remove_cv<_Up>::type;
template <typename _Up>
using __is_derived_Tp =
__and_<is_base_of<_Tp, _Up>,
__not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up> > > >;
template <typename _Up, typename _Ep,
typename _Tp_pointer = typename _Pointer::type,
typename _Up_pointer = typename unique_ptr<_Up, _Ep>::pointer>
using __safe_conversion = __and_<
is_convertible<_Up_pointer, _Tp_pointer>, is_array<_Up>,
__or_<__not_<is_pointer<_Up_pointer> >,
__not_<is_pointer<_Tp_pointer> >,
__not_<__is_derived_Tp<typename remove_extent<_Up>::type> > > >;
public:
typedef typename _Pointer::type pointer;
typedef _Tp element_type;
typedef _Dp deleter_type;
constexpr unique_ptr() noexcept : _M_t() {
static_assert(!std::is_pointer<deleter_type>::value,
"constructed with null function pointer deleter");
}
explicit unique_ptr(pointer __p) noexcept : _M_t(__p, deleter_type()) {
static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter");
}
template <typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up *, pointer>,
__is_derived_Tp<_Up> > >
explicit unique_ptr(_Up *__p) = delete;
# 444 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/unique_ptr.h" 3
unique_ptr(
pointer __p,
typename conditional<is_reference<deleter_type>::value, deleter_type,
const deleter_type &>::type __d) noexcept
: _M_t(__p, __d) {}
# 456 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/unique_ptr.h" 3
unique_ptr(pointer __p,
typename remove_reference<deleter_type>::type &&__d) noexcept
: _M_t(std::move(__p), std::move(__d)) {
static_assert(!is_reference<deleter_type>::value,
"rvalue deleter bound to reference");
}
unique_ptr(unique_ptr &&__u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) {}
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() {}
template <
typename _Up, typename _Ep,
typename = _Require<
__safe_conversion<_Up, _Ep>,
typename conditional<is_reference<_Dp>::value, is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp> >::type> >
unique_ptr(unique_ptr<_Up, _Ep> &&__u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) {}
~unique_ptr() {
auto &__ptr = std::get<0>(_M_t);
if (__ptr != nullptr)
get_deleter()(__ptr);
__ptr = pointer();
}
# 496 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/unique_ptr.h" 3
unique_ptr &operator=(unique_ptr &&__u) noexcept {
reset(__u.release());
get_deleter() = std::forward<deleter_type>(__u.get_deleter());
return *this;
}
# 511 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/unique_ptr.h" 3
template <typename _Up, typename _Ep>
typename enable_if<__safe_conversion<_Up, _Ep>::value, unique_ptr &>::type
operator=(unique_ptr<_Up, _Ep> &&__u) noexcept {
reset(__u.release());
get_deleter() = std::forward<_Ep>(__u.get_deleter());
return *this;
}
unique_ptr &operator=(nullptr_t) noexcept {
reset();
return *this;
}
typename std::add_lvalue_reference<element_type>::type
operator[](size_t __i) const {
;
return get()[__i];
}
pointer get() const noexcept { return std::get<0>(_M_t); }
deleter_type &get_deleter() noexcept { return std::get<1>(_M_t); }
const deleter_type &get_deleter() const noexcept {
return std::get<1>(_M_t);
}
explicit operator bool() const noexcept {
return get() == pointer() ? false : true;
}
pointer release() noexcept {
pointer __p = get();
std::get<0>(_M_t) = pointer();
return __p;
}
void reset(pointer __p = pointer()) noexcept {
using std::swap;
swap(std::get<0>(_M_t), __p);
if (__p != nullptr)
get_deleter()(__p);
}
template <typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up *, pointer>,
__is_derived_Tp<_Up> > >
void reset(_Up *) = delete;
void swap(unique_ptr &__u) noexcept {
using std::swap;
swap(_M_t, __u._M_t);
}
unique_ptr(const unique_ptr &) = delete;
unique_ptr &operator=(const unique_ptr &) = delete;
template <typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up *, pointer>,
__is_derived_Tp<_Up> > >
unique_ptr(_Up *,
typename conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type &>::type) =
delete;
template <typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up *, pointer>,
__is_derived_Tp<_Up> > >
unique_ptr(_Up *, typename remove_reference<deleter_type>::type &&) =
delete;
};
template <typename _Tp, typename _Dp>
inline void swap(unique_ptr<_Tp, _Dp> & __x,
unique_ptr<_Tp, _Dp> & __y) noexcept {
__x.swap(__y);
}
template <typename _Tp, typename _Dp, typename _Up, typename _Ep>
inline bool operator==(const unique_ptr<_Tp, _Dp> & __x,
const unique_ptr<_Up, _Ep> & __y) {
return __x.get() == __y.get();
}
template <typename _Tp, typename _Dp>
inline bool operator==(const unique_ptr<_Tp, _Dp> & __x, nullptr_t) noexcept {
return !__x;
}
template <typename _Tp, typename _Dp>
inline bool operator==(nullptr_t, const unique_ptr<_Tp, _Dp> & __x) noexcept {
return !__x;
}
template <typename _Tp, typename _Dp, typename _Up, typename _Ep>
inline bool operator!=(const unique_ptr<_Tp, _Dp> & __x,
const unique_ptr<_Up, _Ep> & __y) {
return __x.get() != __y.get();
}
template <typename _Tp, typename _Dp>
inline bool operator!=(const unique_ptr<_Tp, _Dp> & __x, nullptr_t) noexcept {
return (bool)__x;
}
template <typename _Tp, typename _Dp>
inline bool operator!=(nullptr_t, const unique_ptr<_Tp, _Dp> & __x) noexcept {
return (bool)__x;
}
template <typename _Tp, typename _Dp, typename _Up, typename _Ep>
inline bool operator<(const unique_ptr<_Tp, _Dp> & __x,
const unique_ptr<_Up, _Ep> & __y) {
typedef typename std::common_type<
typename unique_ptr<_Tp, _Dp>::pointer,
typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
return std::less<_CT>()(__x.get(), __y.get());
}
template <typename _Tp, typename _Dp>
inline bool operator<(const unique_ptr<_Tp, _Dp> & __x, nullptr_t) {
return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
nullptr);
}
template <typename _Tp, typename _Dp>
inline bool operator<(nullptr_t, const unique_ptr<_Tp, _Dp> & __x) {
return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
__x.get());
}
template <typename _Tp, typename _Dp, typename _Up, typename _Ep>
inline bool operator<=(const unique_ptr<_Tp, _Dp> & __x,
const unique_ptr<_Up, _Ep> & __y) {
return !(__y < __x);
}
template <typename _Tp, typename _Dp>
inline bool operator<=(const unique_ptr<_Tp, _Dp> & __x, nullptr_t) {
return !(nullptr < __x);
}
template <typename _Tp, typename _Dp>
inline bool operator<=(nullptr_t, const unique_ptr<_Tp, _Dp> & __x) {
return !(__x < nullptr);
}
template <typename _Tp, typename _Dp, typename _Up, typename _Ep>
inline bool operator>(const unique_ptr<_Tp, _Dp> & __x,
const unique_ptr<_Up, _Ep> & __y) {
return (__y < __x);
}
template <typename _Tp, typename _Dp>
inline bool operator>(const unique_ptr<_Tp, _Dp> & __x, nullptr_t) {
return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
__x.get());
}
template <typename _Tp, typename _Dp>
inline bool operator>(nullptr_t, const unique_ptr<_Tp, _Dp> & __x) {
return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
nullptr);
}
template <typename _Tp, typename _Dp, typename _Up, typename _Ep>
inline bool operator>=(const unique_ptr<_Tp, _Dp> & __x,
const unique_ptr<_Up, _Ep> & __y) {
return !(__x < __y);
}
template <typename _Tp, typename _Dp>
inline bool operator>=(const unique_ptr<_Tp, _Dp> & __x, nullptr_t) {
return !(__x < nullptr);
}
template <typename _Tp, typename _Dp>
inline bool operator>=(nullptr_t, const unique_ptr<_Tp, _Dp> & __x) {
return !(nullptr < __x);
}
template <typename _Tp, typename _Dp>
struct hash<unique_ptr<_Tp, _Dp> > : public __hash_base<
size_t, unique_ptr<_Tp, _Dp> > {
size_t operator()(const unique_ptr<_Tp, _Dp> &__u) const noexcept {
typedef unique_ptr<_Tp, _Dp> _UP;
return std::hash<typename _UP::pointer>()(__u.get());
}
};
# 779 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/unique_ptr.h" 3
}
# 82 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/memory" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr.h" 1 3
# 52 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr_base.h" 1 3
# 52 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr_base.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/aligned_buffer.h" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ext/aligned_buffer.h" 3
namespace __gnu_cxx {
template <typename _Tp>
struct __aligned_buffer
: std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value> {
typename std::aligned_storage<sizeof(_Tp),
std::alignment_of<_Tp>::value>::type _M_storage;
void *_M_addr() noexcept { return static_cast<void *>(&_M_storage); }
const void *_M_addr() const noexcept {
return static_cast<const void *>(&_M_storage);
}
_Tp *_M_ptr() noexcept { return static_cast<_Tp *>(_M_addr()); }
const _Tp *_M_ptr() const noexcept {
return static_cast<const _Tp *>(_M_addr());
}
};
}
# 53 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr_base.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
template <typename> class auto_ptr;
class bad_weak_ptr : public std::exception {
public:
virtual char const *what() const noexcept;
virtual ~bad_weak_ptr() noexcept;
};
inline void __throw_bad_weak_ptr() { (throw(bad_weak_ptr())); }
using __gnu_cxx::_Lock_policy;
using __gnu_cxx::__default_lock_policy;
using __gnu_cxx::_S_single;
using __gnu_cxx::_S_mutex;
using __gnu_cxx::_S_atomic;
template <_Lock_policy _Lp> class _Mutex_base {
protected:
enum {
_S_need_barriers = 0
};
};
template <> class _Mutex_base<_S_mutex> : public __gnu_cxx::__mutex {
protected:
enum {
_S_need_barriers = 1
};
};
template <_Lock_policy _Lp = __default_lock_policy>
class _Sp_counted_base : public _Mutex_base<_Lp> {
public:
_Sp_counted_base() noexcept : _M_use_count(1), _M_weak_count(1) {}
virtual ~_Sp_counted_base() noexcept {}
virtual void _M_dispose() noexcept = 0;
virtual void _M_destroy() noexcept { delete this; }
virtual void *_M_get_deleter(const std::type_info &) noexcept = 0;
void _M_add_ref_copy() {
__gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1);
}
void _M_add_ref_lock();
bool _M_add_ref_lock_nothrow();
void _M_release() noexcept {
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) {
;
_M_dispose();
if (_Mutex_base<_Lp>::_S_need_barriers) {
__asm volatile("" :: : "memory");
__asm volatile("" :: : "memory");
};
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1) {
;
_M_destroy();
}
}
}
void _M_weak_add_ref() noexcept {
__gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1);
}
void _M_weak_release() noexcept {
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1) {
;
if (_Mutex_base<_Lp>::_S_need_barriers) {
__asm volatile("" :: : "memory");
__asm volatile("" :: : "memory");
}
_M_destroy();
}
}
long _M_get_use_count() const noexcept {
return __atomic_load_n(&_M_use_count, 0);
}
private:
_Sp_counted_base(_Sp_counted_base const &) = delete;
_Sp_counted_base &operator=(_Sp_counted_base const &) = delete;
_Atomic_word _M_use_count;
_Atomic_word _M_weak_count;
};
template <> inline void _Sp_counted_base<_S_single>::_M_add_ref_lock() {
if (_M_use_count == 0)
__throw_bad_weak_ptr();
++_M_use_count;
}
template <> inline void _Sp_counted_base<_S_mutex>::_M_add_ref_lock() {
__gnu_cxx::__scoped_lock sentry(*this);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0) {
_M_use_count = 0;
__throw_bad_weak_ptr();
}
}
template <> inline void _Sp_counted_base<_S_atomic>::_M_add_ref_lock() {
_Atomic_word __count = _M_get_use_count();
do {
if (__count == 0)
__throw_bad_weak_ptr();
} while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
true, 4, 0));
}
template <>
inline bool _Sp_counted_base<_S_single>::_M_add_ref_lock_nothrow() {
if (_M_use_count == 0)
return false;
++_M_use_count;
return true;
}
template <>
inline bool _Sp_counted_base<_S_mutex>::_M_add_ref_lock_nothrow() {
__gnu_cxx::__scoped_lock sentry(*this);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0) {
_M_use_count = 0;
return false;
}
return true;
}
template <>
inline bool _Sp_counted_base<_S_atomic>::_M_add_ref_lock_nothrow() {
_Atomic_word __count = _M_get_use_count();
do {
if (__count == 0)
return false;
} while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
true, 4, 0));
return true;
}
template <> inline void _Sp_counted_base<_S_single>::_M_add_ref_copy() {
++_M_use_count;
}
template <> inline void _Sp_counted_base<_S_single>::_M_release() noexcept {
if (--_M_use_count == 0) {
_M_dispose();
if (--_M_weak_count == 0)
_M_destroy();
}
}
template <>
inline void _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept {
++_M_weak_count;
}
template <>
inline void _Sp_counted_base<_S_single>::_M_weak_release() noexcept {
if (--_M_weak_count == 0)
_M_destroy();
}
template <>
inline long _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept {
return _M_use_count;
}
template <typename _Tp, _Lock_policy _Lp = __default_lock_policy>
class __shared_ptr;
template <typename _Tp, _Lock_policy _Lp = __default_lock_policy>
class __weak_ptr;
template <typename _Tp, _Lock_policy _Lp = __default_lock_policy>
class __enable_shared_from_this;
template <typename _Tp> class shared_ptr;
template <typename _Tp> class weak_ptr;
template <typename _Tp> struct owner_less;
template <typename _Tp> class enable_shared_from_this;
template <_Lock_policy _Lp = __default_lock_policy> class __weak_count;
template <_Lock_policy _Lp = __default_lock_policy> class __shared_count;
template <typename _Ptr, _Lock_policy _Lp>
class _Sp_counted_ptr final : public _Sp_counted_base<_Lp> {
public:
explicit _Sp_counted_ptr(_Ptr __p) noexcept : _M_ptr(__p) {}
virtual void _M_dispose() noexcept { delete _M_ptr; }
virtual void _M_destroy() noexcept { delete this; }
virtual void *_M_get_deleter(const std::type_info &) noexcept {
return nullptr;
}
_Sp_counted_ptr(const _Sp_counted_ptr &) = delete;
_Sp_counted_ptr &operator=(const _Sp_counted_ptr &) = delete;
private:
_Ptr _M_ptr;
};
template <>
inline void _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept {}
template <>
inline void _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept {}
template <>
inline void _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept {}
template <int _Nm, typename _Tp,
bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
struct _Sp_ebo_helper;
template <int _Nm, typename _Tp>
struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp {
explicit _Sp_ebo_helper(const _Tp &__tp) : _Tp(__tp) {}
static _Tp &_S_get(_Sp_ebo_helper &__eboh) {
return static_cast<_Tp &>(__eboh);
}
};
template <int _Nm, typename _Tp> struct _Sp_ebo_helper<_Nm, _Tp, false> {
explicit _Sp_ebo_helper(const _Tp &__tp) : _M_tp(__tp) {}
static _Tp &_S_get(_Sp_ebo_helper &__eboh) { return __eboh._M_tp; }
private:
_Tp _M_tp;
};
template <typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
class _Sp_counted_deleter final : public _Sp_counted_base<_Lp> {
class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc> {
typedef _Sp_ebo_helper<0, _Deleter> _Del_base;
typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base;
public:
_Impl(_Ptr __p, _Deleter __d, const _Alloc &__a) noexcept
: _M_ptr(__p),
_Del_base(__d),
_Alloc_base(__a) {}
_Deleter &_M_del() noexcept { return _Del_base::_S_get(*this); }
_Alloc &_M_alloc() noexcept { return _Alloc_base::_S_get(*this); }
_Ptr _M_ptr;
};
public:
_Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept
: _M_impl(__p, __d, _Alloc()) {}
_Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc &__a) noexcept
: _M_impl(__p, __d, __a) {}
~_Sp_counted_deleter() noexcept {}
virtual void _M_dispose() noexcept { _M_impl._M_del()(_M_impl._M_ptr); }
virtual void _M_destroy() noexcept {
typedef typename allocator_traits<_Alloc>::template rebind_traits<
_Sp_counted_deleter> _Alloc_traits;
typename _Alloc_traits::allocator_type __a(_M_impl._M_alloc());
_Alloc_traits::destroy(__a, this);
_Alloc_traits::deallocate(__a, this, 1);
}
virtual void *_M_get_deleter(const std::type_info &__ti) noexcept {
return __ti == typeid(_Deleter) ? &_M_impl._M_del() : nullptr;
}
private:
_Impl _M_impl;
};
struct _Sp_make_shared_tag {};
template <typename _Tp, typename _Alloc, _Lock_policy _Lp>
class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp> {
class _Impl : _Sp_ebo_helper<0, _Alloc> {
typedef _Sp_ebo_helper<0, _Alloc> _A_base;
public:
explicit _Impl(_Alloc __a) noexcept : _A_base(__a) {}
_Alloc &_M_alloc() noexcept { return _A_base::_S_get(*this); }
__gnu_cxx::__aligned_buffer<_Tp> _M_storage;
};
public:
template <typename... _Args>
_Sp_counted_ptr_inplace(_Alloc __a, _Args &&... __args)
: _M_impl(__a) {
allocator_traits<_Alloc>::construct(__a, _M_ptr(),
std::forward<_Args>(__args)...);
}
~_Sp_counted_ptr_inplace() noexcept {}
virtual void _M_dispose() noexcept {
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
}
virtual void _M_destroy() noexcept {
typedef typename allocator_traits<_Alloc>::template rebind_traits<
_Sp_counted_ptr_inplace> _Alloc_traits;
typename _Alloc_traits::allocator_type __a(_M_impl._M_alloc());
_Alloc_traits::destroy(__a, this);
_Alloc_traits::deallocate(__a, this, 1);
}
virtual void *_M_get_deleter(const std::type_info &__ti) noexcept {
if (__ti == typeid(_Sp_make_shared_tag))
return const_cast<typename remove_cv<_Tp>::type *>(_M_ptr());
return nullptr;
}
private:
_Tp *_M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }
_Impl _M_impl;
};
template <_Lock_policy _Lp> class __shared_count {
public:
constexpr __shared_count() noexcept : _M_pi(0) {}
template <typename _Ptr> explicit __shared_count(_Ptr __p) : _M_pi(0) {
try {
_M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
}
catch (...) {
delete __p;
throw;
}
}
template <typename _Ptr, typename _Deleter>
__shared_count(_Ptr __p, _Deleter __d)
: __shared_count(__p, std::move(__d), allocator<void>()) {}
template <typename _Ptr, typename _Deleter, typename _Alloc>
__shared_count(_Ptr __p, _Deleter __d, _Alloc __a)
: _M_pi(0) {
typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
typedef typename allocator_traits<_Alloc>::template rebind_traits<
_Sp_cd_type> _Alloc_traits;
typename _Alloc_traits::allocator_type __a2(__a);
_Sp_cd_type *__mem = 0;
try {
__mem = _Alloc_traits::allocate(__a2, 1);
_Alloc_traits::construct(__a2, __mem, __p, std::move(__d),
std::move(__a));
_M_pi = __mem;
}
catch (...) {
__d(__p);
if (__mem)
_Alloc_traits::deallocate(__a2, __mem, 1);
throw;
}
}
template <typename _Tp, typename _Alloc, typename... _Args>
__shared_count(_Sp_make_shared_tag, _Tp *, const _Alloc &__a,
_Args &&... __args)
: _M_pi(0) {
typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
typedef typename allocator_traits<_Alloc>::template rebind_traits<
_Sp_cp_type> _Alloc_traits;
typename _Alloc_traits::allocator_type __a2(__a);
_Sp_cp_type *__mem = _Alloc_traits::allocate(__a2, 1);
try {
_Alloc_traits::construct(__a2, __mem, std::move(__a),
std::forward<_Args>(__args)...);
_M_pi = __mem;
}
catch (...) {
_Alloc_traits::deallocate(__a2, __mem, 1);
throw;
}
}
template <typename _Tp> explicit __shared_count(std::auto_ptr<_Tp> &&__r);
template <typename _Tp, typename _Del>
explicit __shared_count(std::unique_ptr<_Tp, _Del> &&__r)
: _M_pi(0) {
using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
using _Del2 = typename conditional<
is_reference<_Del>::value,
reference_wrapper<typename remove_reference<_Del>::type>, _Del>::type;
using _Sp_cd_type =
_Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
using _Alloc = allocator<_Sp_cd_type>;
using _Alloc_traits = allocator_traits<_Alloc>;
_Alloc __a;
_Sp_cd_type *__mem = _Alloc_traits::allocate(__a, 1);
_Alloc_traits::construct(__a, __mem, __r.release(), __r.get_deleter());
_M_pi = __mem;
}
explicit __shared_count(const __weak_count<_Lp> &__r);
explicit __shared_count(const __weak_count<_Lp> &__r, std::nothrow_t);
~__shared_count() noexcept {
if (_M_pi != nullptr)
_M_pi->_M_release();
}
__shared_count(const __shared_count &__r) noexcept : _M_pi(__r._M_pi) {
if (_M_pi != 0)
_M_pi->_M_add_ref_copy();
}
__shared_count &operator=(const __shared_count &__r) noexcept {
_Sp_counted_base<_Lp> *__tmp = __r._M_pi;
if (__tmp != _M_pi) {
if (__tmp != 0)
__tmp->_M_add_ref_copy();
if (_M_pi != 0)
_M_pi->_M_release();
_M_pi = __tmp;
}
return *this;
}
void _M_swap(__shared_count &__r) noexcept {
_Sp_counted_base<_Lp> *__tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
}
long _M_get_use_count() const noexcept {
return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0;
}
bool _M_unique() const noexcept { return this->_M_get_use_count() == 1; }
void *_M_get_deleter(const std::type_info &__ti) const noexcept {
return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr;
}
bool _M_less(const __shared_count &__rhs) const noexcept {
return std::less<_Sp_counted_base<_Lp> *>()(this->_M_pi, __rhs._M_pi);
}
bool _M_less(const __weak_count<_Lp> &__rhs) const noexcept {
return std::less<_Sp_counted_base<_Lp> *>()(this->_M_pi, __rhs._M_pi);
}
friend inline bool operator==(const __shared_count &__a,
const __shared_count &__b) noexcept {
return __a._M_pi == __b._M_pi;
}
private:
friend class __weak_count<_Lp>;
_Sp_counted_base<_Lp> *_M_pi;
};
template <_Lock_policy _Lp> class __weak_count {
public:
constexpr __weak_count() noexcept : _M_pi(0) {}
__weak_count(const __shared_count<_Lp> &__r) noexcept : _M_pi(__r._M_pi) {
if (_M_pi != 0)
_M_pi->_M_weak_add_ref();
}
__weak_count(const __weak_count<_Lp> &__r) noexcept : _M_pi(__r._M_pi) {
if (_M_pi != 0)
_M_pi->_M_weak_add_ref();
}
~__weak_count() noexcept {
if (_M_pi != 0)
_M_pi->_M_weak_release();
}
__weak_count<_Lp> &operator=(const __shared_count<_Lp> &__r) noexcept {
_Sp_counted_base<_Lp> *__tmp = __r._M_pi;
if (__tmp != 0)
__tmp->_M_weak_add_ref();
if (_M_pi != 0)
_M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
}
__weak_count<_Lp> &operator=(const __weak_count<_Lp> &__r) noexcept {
_Sp_counted_base<_Lp> *__tmp = __r._M_pi;
if (__tmp != 0)
__tmp->_M_weak_add_ref();
if (_M_pi != 0)
_M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
}
void _M_swap(__weak_count<_Lp> &__r) noexcept {
_Sp_counted_base<_Lp> *__tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
}
long _M_get_use_count() const noexcept {
return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0;
}
bool _M_less(const __weak_count &__rhs) const noexcept {
return std::less<_Sp_counted_base<_Lp> *>()(this->_M_pi, __rhs._M_pi);
}
bool _M_less(const __shared_count<_Lp> &__rhs) const noexcept {
return std::less<_Sp_counted_base<_Lp> *>()(this->_M_pi, __rhs._M_pi);
}
friend inline bool operator==(const __weak_count &__a,
const __weak_count &__b) noexcept {
return __a._M_pi == __b._M_pi;
}
private:
friend class __shared_count<_Lp>;
_Sp_counted_base<_Lp> *_M_pi;
};
template <_Lock_policy _Lp>
inline __shared_count<_Lp>::__shared_count(const __weak_count<_Lp> & __r)
: _M_pi(__r._M_pi) {
if (_M_pi != nullptr)
_M_pi->_M_add_ref_lock();
else
__throw_bad_weak_ptr();
}
template <_Lock_policy _Lp>
inline __shared_count<_Lp>::__shared_count(const __weak_count<_Lp> & __r,
std::nothrow_t)
: _M_pi(__r._M_pi) {
if (_M_pi != nullptr)
if (!_M_pi->_M_add_ref_lock_nothrow())
_M_pi = nullptr;
}
template <_Lock_policy _Lp, typename _Tp1, typename _Tp2>
void __enable_shared_from_this_helper(
const __shared_count<_Lp> &, const __enable_shared_from_this<_Tp1, _Lp> *,
const _Tp2 *)noexcept;
template <typename _Tp1, typename _Tp2>
void __enable_shared_from_this_helper(const __shared_count<> &,
const enable_shared_from_this<_Tp1> *,
const _Tp2 *)noexcept;
template <_Lock_policy _Lp>
inline void __enable_shared_from_this_helper(const __shared_count<_Lp> &,
...) noexcept {}
template <typename _Tp, _Lock_policy _Lp> class __shared_ptr {
public:
typedef _Tp element_type;
constexpr __shared_ptr() noexcept : _M_ptr(0), _M_refcount() {}
template <typename _Tp1>
explicit __shared_ptr(_Tp1 *__p)
: _M_ptr(__p), _M_refcount(__p) {
static_assert(!is_void<_Tp>::value, "incomplete type");
static_assert(sizeof(_Tp1) > 0, "incomplete type");
__enable_shared_from_this_helper(_M_refcount, __p, __p);
}
template <typename _Tp1, typename _Deleter>
__shared_ptr(_Tp1 *__p, _Deleter __d)
: _M_ptr(__p), _M_refcount(__p, __d) {
__enable_shared_from_this_helper(_M_refcount, __p, __p);
}
template <typename _Tp1, typename _Deleter, typename _Alloc>
__shared_ptr(_Tp1 *__p, _Deleter __d, _Alloc __a)
: _M_ptr(__p), _M_refcount(__p, __d, std::move(__a)) {
__enable_shared_from_this_helper(_M_refcount, __p, __p);
}
template <typename _Deleter>
__shared_ptr(nullptr_t __p, _Deleter __d)
: _M_ptr(0), _M_refcount(__p, __d) {}
template <typename _Deleter, typename _Alloc>
__shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: _M_ptr(0), _M_refcount(__p, __d, std::move(__a)) {}
template <typename _Tp1>
__shared_ptr(const __shared_ptr<_Tp1, _Lp> &__r, _Tp *__p) noexcept
: _M_ptr(__p),
_M_refcount(__r._M_refcount) {}
__shared_ptr(const __shared_ptr &) noexcept = default;
__shared_ptr &operator=(const __shared_ptr &) noexcept = default;
~__shared_ptr() = default;
template <typename _Tp1,
typename = typename std::enable_if<
std::is_convertible<_Tp1 *, _Tp *>::value>::type>
__shared_ptr(const __shared_ptr<_Tp1, _Lp> &__r) noexcept
: _M_ptr(__r._M_ptr),
_M_refcount(__r._M_refcount) {}
__shared_ptr(__shared_ptr &&__r) noexcept : _M_ptr(__r._M_ptr),
_M_refcount() {
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
}
template <typename _Tp1,
typename = typename std::enable_if<
std::is_convertible<_Tp1 *, _Tp *>::value>::type>
__shared_ptr(__shared_ptr<_Tp1, _Lp> &&__r) noexcept : _M_ptr(__r._M_ptr),
_M_refcount() {
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
}
template <typename _Tp1>
explicit __shared_ptr(const __weak_ptr<_Tp1, _Lp> &__r)
: _M_refcount(__r._M_refcount) {
_M_ptr = __r._M_ptr;
}
template <typename _Tp1, typename _Del>
__shared_ptr(std::unique_ptr<_Tp1, _Del> &&__r)
: _M_ptr(__r.get()), _M_refcount() {
auto __raw = _S_raw_ptr(__r.get());
_M_refcount = __shared_count<_Lp>(std::move(__r));
__enable_shared_from_this_helper(_M_refcount, __raw, __raw);
}
template <typename _Tp1> __shared_ptr(std::auto_ptr<_Tp1> &&__r);
constexpr __shared_ptr(nullptr_t) noexcept : _M_ptr(0), _M_refcount() {}
template <typename _Tp1>
__shared_ptr &operator=(const __shared_ptr<_Tp1, _Lp> &__r) noexcept {
_M_ptr = __r._M_ptr;
_M_refcount = __r._M_refcount;
return *this;
}
template <typename _Tp1>
__shared_ptr &operator=(std::auto_ptr<_Tp1> &&__r) {
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
__shared_ptr &operator=(__shared_ptr &&__r) noexcept {
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
template <class _Tp1>
__shared_ptr &operator=(__shared_ptr<_Tp1, _Lp> &&__r) noexcept {
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
template <typename _Tp1, typename _Del>
__shared_ptr &operator=(std::unique_ptr<_Tp1, _Del> &&__r) {
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
void reset() noexcept { __shared_ptr().swap(*this); }
template <typename _Tp1> void reset(_Tp1 *__p) {
;
__shared_ptr(__p).swap(*this);
}
template <typename _Tp1, typename _Deleter>
void reset(_Tp1 *__p, _Deleter __d) {
__shared_ptr(__p, __d).swap(*this);
}
template <typename _Tp1, typename _Deleter, typename _Alloc>
void reset(_Tp1 *__p, _Deleter __d, _Alloc __a) {
__shared_ptr(__p, __d, std::move(__a)).swap(*this);
}
typename std::add_lvalue_reference<_Tp>::type operator*() const noexcept {
;
return *_M_ptr;
}
_Tp *operator->() const noexcept {
;
return _M_ptr;
}
_Tp *get() const noexcept { return _M_ptr; }
explicit operator bool() const { return _M_ptr == 0 ? false : true; }
bool unique() const noexcept { return _M_refcount._M_unique(); }
long use_count() const noexcept { return _M_refcount._M_get_use_count(); }
void swap(__shared_ptr<_Tp, _Lp> &__other) noexcept {
std::swap(_M_ptr, __other._M_ptr);
_M_refcount._M_swap(__other._M_refcount);
}
template <typename _Tp1>
bool owner_before(__shared_ptr<_Tp1, _Lp> const &__rhs) const {
return _M_refcount._M_less(__rhs._M_refcount);
}
template <typename _Tp1>
bool owner_before(__weak_ptr<_Tp1, _Lp> const &__rhs) const {
return _M_refcount._M_less(__rhs._M_refcount);
}
protected:
template <typename _Alloc, typename... _Args>
__shared_ptr(_Sp_make_shared_tag __tag, const _Alloc &__a,
_Args &&... __args)
: _M_ptr(),
_M_refcount(__tag, (_Tp *)0, __a, std::forward<_Args>(__args)...) {
void *__p = _M_refcount._M_get_deleter(typeid(__tag));
_M_ptr = static_cast<_Tp *>(__p);
__enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
}
# 1138 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr_base.h" 3
template <typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
typename... _Args>
friend __shared_ptr<_Tp1, _Lp1> __allocate_shared(const _Alloc &__a,
_Args &&... __args);
__shared_ptr(const __weak_ptr<_Tp, _Lp> &__r, std::nothrow_t)
: _M_refcount(__r._M_refcount, std::nothrow) {
_M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
}
friend class __weak_ptr<_Tp, _Lp>;
private:
void *_M_get_deleter(const std::type_info &__ti) const noexcept {
return _M_refcount._M_get_deleter(__ti);
}
template <typename _Tp1> static _Tp1 *_S_raw_ptr(_Tp1 *__ptr) {
return __ptr;
}
template <typename _Tp1>
static auto _S_raw_ptr(_Tp1 __ptr) -> decltype(std::__addressof(*__ptr)) {
return std::__addressof(*__ptr);
}
template <typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
template <typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
template <typename _Del, typename _Tp1, _Lock_policy _Lp1>
friend _Del *get_deleter(const __shared_ptr<_Tp1, _Lp1> &) noexcept;
_Tp *_M_ptr;
__shared_count<_Lp> _M_refcount;
};
template <typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool operator==(const __shared_ptr<_Tp1, _Lp> & __a,
const __shared_ptr<_Tp2, _Lp> & __b) noexcept {
return __a.get() == __b.get();
}
template <typename _Tp, _Lock_policy _Lp>
inline bool operator==(const __shared_ptr<_Tp, _Lp> & __a,
nullptr_t) noexcept {
return !__a;
}
template <typename _Tp, _Lock_policy _Lp>
inline bool operator==(nullptr_t,
const __shared_ptr<_Tp, _Lp> & __a) noexcept {
return !__a;
}
template <typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool operator!=(const __shared_ptr<_Tp1, _Lp> & __a,
const __shared_ptr<_Tp2, _Lp> & __b) noexcept {
return __a.get() != __b.get();
}
template <typename _Tp, _Lock_policy _Lp>
inline bool operator!=(const __shared_ptr<_Tp, _Lp> & __a,
nullptr_t) noexcept {
return (bool)__a;
}
template <typename _Tp, _Lock_policy _Lp>
inline bool operator!=(nullptr_t,
const __shared_ptr<_Tp, _Lp> & __a) noexcept {
return (bool)__a;
}
template <typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool operator<(const __shared_ptr<_Tp1, _Lp> & __a,
const __shared_ptr<_Tp2, _Lp> & __b) noexcept {
typedef typename std::common_type<_Tp1 *, _Tp2 *>::type _CT;
return std::less<_CT>()(__a.get(), __b.get());
}
template <typename _Tp, _Lock_policy _Lp>
inline bool operator<(const __shared_ptr<_Tp, _Lp> & __a,
nullptr_t) noexcept {
return std::less<_Tp *>()(__a.get(), nullptr);
}
template <typename _Tp, _Lock_policy _Lp>
inline bool operator<(nullptr_t,
const __shared_ptr<_Tp, _Lp> & __a) noexcept {
return std::less<_Tp *>()(nullptr, __a.get());
}
template <typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool operator<=(const __shared_ptr<_Tp1, _Lp> & __a,
const __shared_ptr<_Tp2, _Lp> & __b) noexcept {
return !(__b < __a);
}
template <typename _Tp, _Lock_policy _Lp>
inline bool operator<=(const __shared_ptr<_Tp, _Lp> & __a,
nullptr_t) noexcept {
return !(nullptr < __a);
}
template <typename _Tp, _Lock_policy _Lp>
inline bool operator<=(nullptr_t,
const __shared_ptr<_Tp, _Lp> & __a) noexcept {
return !(__a < nullptr);
}
template <typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool operator>(const __shared_ptr<_Tp1, _Lp> & __a,
const __shared_ptr<_Tp2, _Lp> & __b) noexcept {
return (__b < __a);
}
template <typename _Tp, _Lock_policy _Lp>
inline bool operator>(const __shared_ptr<_Tp, _Lp> & __a,
nullptr_t) noexcept {
return std::less<_Tp *>()(nullptr, __a.get());
}
template <typename _Tp, _Lock_policy _Lp>
inline bool operator>(nullptr_t,
const __shared_ptr<_Tp, _Lp> & __a) noexcept {
return std::less<_Tp *>()(__a.get(), nullptr);
}
template <typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool operator>=(const __shared_ptr<_Tp1, _Lp> & __a,
const __shared_ptr<_Tp2, _Lp> & __b) noexcept {
return !(__a < __b);
}
template <typename _Tp, _Lock_policy _Lp>
inline bool operator>=(const __shared_ptr<_Tp, _Lp> & __a,
nullptr_t) noexcept {
return !(__a < nullptr);
}
template <typename _Tp, _Lock_policy _Lp>
inline bool operator>=(nullptr_t,
const __shared_ptr<_Tp, _Lp> & __a) noexcept {
return !(nullptr < __a);
}
template <typename _Sp>
struct _Sp_less : public binary_function<_Sp, _Sp, bool> {
bool operator()(const _Sp &__lhs, const _Sp &__rhs) const noexcept {
typedef typename _Sp::element_type element_type;
return std::less<element_type *>()(__lhs.get(), __rhs.get());
}
};
template <typename _Tp, _Lock_policy _Lp>
struct less<__shared_ptr<_Tp, _Lp> > : public _Sp_less<
__shared_ptr<_Tp, _Lp> > {};
template <typename _Tp, _Lock_policy _Lp>
inline void swap(__shared_ptr<_Tp, _Lp> & __a,
__shared_ptr<_Tp, _Lp> & __b) noexcept {
__a.swap(__b);
}
# 1308 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr_base.h" 3
template <typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp> static_pointer_cast(
const __shared_ptr<_Tp1, _Lp> & __r) noexcept {
return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp *>(__r.get()));
}
template <typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp> const_pointer_cast(
const __shared_ptr<_Tp1, _Lp> & __r) noexcept {
return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp *>(__r.get()));
}
template <typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp> dynamic_pointer_cast(
const __shared_ptr<_Tp1, _Lp> & __r) noexcept {
if (_Tp *__p = dynamic_cast<_Tp *>(__r.get()))
return __shared_ptr<_Tp, _Lp>(__r, __p);
return __shared_ptr<_Tp, _Lp>();
}
template <typename _Tp, _Lock_policy _Lp> class __weak_ptr {
public:
typedef _Tp element_type;
constexpr __weak_ptr() noexcept : _M_ptr(0), _M_refcount() {}
__weak_ptr(const __weak_ptr &) noexcept = default;
__weak_ptr &operator=(const __weak_ptr &) noexcept = default;
~__weak_ptr() = default;
# 1366 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr_base.h" 3
template <typename _Tp1,
typename = typename std::enable_if<
std::is_convertible<_Tp1 *, _Tp *>::value>::type>
__weak_ptr(const __weak_ptr<_Tp1, _Lp> &__r) noexcept
: _M_refcount(__r._M_refcount) {
_M_ptr = __r.lock().get();
}
template <typename _Tp1,
typename = typename std::enable_if<
std::is_convertible<_Tp1 *, _Tp *>::value>::type>
__weak_ptr(const __shared_ptr<_Tp1, _Lp> &__r) noexcept
: _M_ptr(__r._M_ptr),
_M_refcount(__r._M_refcount) {}
template <typename _Tp1>
__weak_ptr &operator=(const __weak_ptr<_Tp1, _Lp> &__r) noexcept {
_M_ptr = __r.lock().get();
_M_refcount = __r._M_refcount;
return *this;
}
template <typename _Tp1>
__weak_ptr &operator=(const __shared_ptr<_Tp1, _Lp> &__r) noexcept {
_M_ptr = __r._M_ptr;
_M_refcount = __r._M_refcount;
return *this;
}
__shared_ptr<_Tp, _Lp> lock() const noexcept {
return __shared_ptr<element_type, _Lp>(*this, std::nothrow);
}
long use_count() const noexcept { return _M_refcount._M_get_use_count(); }
bool expired() const noexcept {
return _M_refcount._M_get_use_count() == 0;
}
template <typename _Tp1>
bool owner_before(const __shared_ptr<_Tp1, _Lp> &__rhs) const {
return _M_refcount._M_less(__rhs._M_refcount);
}
template <typename _Tp1>
bool owner_before(const __weak_ptr<_Tp1, _Lp> &__rhs) const {
return _M_refcount._M_less(__rhs._M_refcount);
}
void reset() noexcept { __weak_ptr().swap(*this); }
void swap(__weak_ptr &__s) noexcept {
std::swap(_M_ptr, __s._M_ptr);
_M_refcount._M_swap(__s._M_refcount);
}
private:
void _M_assign(_Tp *__ptr, const __shared_count<_Lp> &__refcount) noexcept {
_M_ptr = __ptr;
_M_refcount = __refcount;
}
template <typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
template <typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
friend class __enable_shared_from_this<_Tp, _Lp>;
friend class enable_shared_from_this<_Tp>;
_Tp *_M_ptr;
__weak_count<_Lp> _M_refcount;
};
template <typename _Tp, _Lock_policy _Lp>
inline void swap(__weak_ptr<_Tp, _Lp> & __a,
__weak_ptr<_Tp, _Lp> & __b) noexcept {
__a.swap(__b);
}
template <typename _Tp, typename _Tp1>
struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool> {
bool operator()(const _Tp &__lhs, const _Tp &__rhs) const {
return __lhs.owner_before(__rhs);
}
bool operator()(const _Tp &__lhs, const _Tp1 &__rhs) const {
return __lhs.owner_before(__rhs);
}
bool operator()(const _Tp1 &__lhs, const _Tp &__rhs) const {
return __lhs.owner_before(__rhs);
}
};
template <typename _Tp, _Lock_policy _Lp>
struct owner_less<__shared_ptr<_Tp, _Lp> > : public _Sp_owner_less<
__shared_ptr<_Tp, _Lp>,
__weak_ptr<_Tp, _Lp> > {};
template <typename _Tp, _Lock_policy _Lp>
struct owner_less<__weak_ptr<_Tp, _Lp> > : public _Sp_owner_less<
__weak_ptr<_Tp, _Lp>,
__shared_ptr<_Tp, _Lp> > {};
template <typename _Tp, _Lock_policy _Lp> class __enable_shared_from_this {
protected:
constexpr __enable_shared_from_this() noexcept {}
__enable_shared_from_this(const __enable_shared_from_this &) noexcept {}
__enable_shared_from_this &
operator=(const __enable_shared_from_this &) noexcept {
return *this;
}
~__enable_shared_from_this() {}
public:
__shared_ptr<_Tp, _Lp> shared_from_this() {
return __shared_ptr<_Tp, _Lp>(this->_M_weak_this);
}
__shared_ptr<const _Tp, _Lp> shared_from_this() const {
return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this);
}
private:
template <typename _Tp1>
void _M_weak_assign(_Tp1 *__p, const __shared_count<_Lp> &__n) const
noexcept {
_M_weak_this._M_assign(__p, __n);
}
template <typename _Tp1>
friend void
__enable_shared_from_this_helper(const __shared_count<_Lp> &__pn,
const __enable_shared_from_this *__pe,
const _Tp1 *__px) noexcept {
if (__pe != 0)
__pe->_M_weak_assign(const_cast<_Tp1 *>(__px), __pn);
}
mutable __weak_ptr<_Tp, _Lp> _M_weak_this;
};
template <typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args>
inline __shared_ptr<_Tp, _Lp> __allocate_shared(const _Alloc & __a,
_Args && ... __args) {
return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(), __a,
std::forward<_Args>(__args)...);
}
template <typename _Tp, _Lock_policy _Lp, typename... _Args>
inline __shared_ptr<_Tp, _Lp> __make_shared(_Args && ... __args) {
typedef typename std::remove_const<_Tp>::type _Tp_nc;
return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
std::forward<_Args>(__args)...);
}
template <typename _Tp, _Lock_policy _Lp>
struct hash<__shared_ptr<_Tp, _Lp> > : public __hash_base<
size_t, __shared_ptr<_Tp, _Lp> > {
size_t operator()(const __shared_ptr<_Tp, _Lp> &__s) const noexcept {
return std::hash<_Tp *>()(__s.get());
}
};
}
# 53 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 64 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr.h" 3
template <typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
inline std::basic_ostream<_Ch, _Tr> &operator<<(
std::basic_ostream<_Ch, _Tr> & __os, const __shared_ptr<_Tp, _Lp> & __p) {
__os << __p.get();
return __os;
}
template <typename _Del, typename _Tp, _Lock_policy _Lp>
inline _Del *get_deleter(const __shared_ptr<_Tp, _Lp> & __p) noexcept {
return static_cast<_Del *>(__p._M_get_deleter(typeid(_Del)));
}
# 92 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr.h" 3
template <typename _Tp> class shared_ptr : public __shared_ptr<_Tp> {
public:
constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() {}
shared_ptr(const shared_ptr &) noexcept = default;
template <typename _Tp1>
explicit shared_ptr(_Tp1 *__p)
: __shared_ptr<_Tp>(__p) {}
# 128 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr.h" 3
template <typename _Tp1, typename _Deleter>
shared_ptr(_Tp1 *__p, _Deleter __d)
: __shared_ptr<_Tp>(__p, __d) {}
# 145 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr.h" 3
template <typename _Deleter>
shared_ptr(nullptr_t __p, _Deleter __d)
: __shared_ptr<_Tp>(__p, __d) {}
# 164 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr.h" 3
template <typename _Tp1, typename _Deleter, typename _Alloc>
shared_ptr(_Tp1 *__p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, __d, std::move(__a)) {}
# 183 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr.h" 3
template <typename _Deleter, typename _Alloc>
shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, __d, std::move(__a)) {}
# 205 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr.h" 3
template <typename _Tp1>
shared_ptr(const shared_ptr<_Tp1> &__r, _Tp *__p) noexcept
: __shared_ptr<_Tp>(__r, __p) {}
# 216 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr.h" 3
template <typename _Tp1,
typename = typename std::enable_if<
std::is_convertible<_Tp1 *, _Tp *>::value>::type>
shared_ptr(const shared_ptr<_Tp1> &__r) noexcept : __shared_ptr<_Tp>(__r) {}
shared_ptr(shared_ptr &&__r) noexcept : __shared_ptr<_Tp>(std::move(__r)) {}
template <typename _Tp1,
typename = typename std::enable_if<
std::is_convertible<_Tp1 *, _Tp *>::value>::type>
shared_ptr(shared_ptr<_Tp1> &&__r) noexcept
: __shared_ptr<_Tp>(std::move(__r)) {}
# 247 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr.h" 3
template <typename _Tp1>
explicit shared_ptr(const weak_ptr<_Tp1> &__r)
: __shared_ptr<_Tp>(__r) {}
template <typename _Tp1> shared_ptr(std::auto_ptr<_Tp1> &&__r);
template <typename _Tp1, typename _Del>
shared_ptr(std::unique_ptr<_Tp1, _Del> &&__r)
: __shared_ptr<_Tp>(std::move(__r)) {}
constexpr shared_ptr(nullptr_t __p) noexcept : __shared_ptr<_Tp>(__p) {}
shared_ptr &operator=(const shared_ptr &) noexcept = default;
template <typename _Tp1>
shared_ptr &operator=(const shared_ptr<_Tp1> &__r) noexcept {
this->__shared_ptr<_Tp>::operator=(__r);
return *this;
}
template <typename _Tp1> shared_ptr &operator=(std::auto_ptr<_Tp1> &&__r) {
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
shared_ptr &operator=(shared_ptr &&__r) noexcept {
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
template <class _Tp1>
shared_ptr &operator=(shared_ptr<_Tp1> &&__r) noexcept {
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
template <typename _Tp1, typename _Del>
shared_ptr &operator=(std::unique_ptr<_Tp1, _Del> &&__r) {
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
private:
template <typename _Alloc, typename... _Args>
shared_ptr(_Sp_make_shared_tag __tag, const _Alloc &__a, _Args &&... __args)
: __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...) {}
template <typename _Tp1, typename _Alloc, typename... _Args>
friend shared_ptr<_Tp1> allocate_shared(const _Alloc &__a,
_Args &&... __args);
shared_ptr(const weak_ptr<_Tp> &__r, std::nothrow_t)
: __shared_ptr<_Tp>(__r, std::nothrow) {}
friend class weak_ptr<_Tp>;
};
template <typename _Tp1, typename _Tp2>
inline bool operator==(const shared_ptr<_Tp1> & __a,
const shared_ptr<_Tp2> & __b) noexcept {
return __a.get() == __b.get();
}
template <typename _Tp>
inline bool operator==(const shared_ptr<_Tp> & __a, nullptr_t) noexcept {
return !__a;
}
template <typename _Tp>
inline bool operator==(nullptr_t, const shared_ptr<_Tp> & __a) noexcept {
return !__a;
}
template <typename _Tp1, typename _Tp2>
inline bool operator!=(const shared_ptr<_Tp1> & __a,
const shared_ptr<_Tp2> & __b) noexcept {
return __a.get() != __b.get();
}
template <typename _Tp>
inline bool operator!=(const shared_ptr<_Tp> & __a, nullptr_t) noexcept {
return (bool)__a;
}
template <typename _Tp>
inline bool operator!=(nullptr_t, const shared_ptr<_Tp> & __a) noexcept {
return (bool)__a;
}
template <typename _Tp1, typename _Tp2>
inline bool operator<(const shared_ptr<_Tp1> & __a,
const shared_ptr<_Tp2> & __b) noexcept {
typedef typename std::common_type<_Tp1 *, _Tp2 *>::type _CT;
return std::less<_CT>()(__a.get(), __b.get());
}
template <typename _Tp>
inline bool operator<(const shared_ptr<_Tp> & __a, nullptr_t) noexcept {
return std::less<_Tp *>()(__a.get(), nullptr);
}
template <typename _Tp>
inline bool operator<(nullptr_t, const shared_ptr<_Tp> & __a) noexcept {
return std::less<_Tp *>()(nullptr, __a.get());
}
template <typename _Tp1, typename _Tp2>
inline bool operator<=(const shared_ptr<_Tp1> & __a,
const shared_ptr<_Tp2> & __b) noexcept {
return !(__b < __a);
}
template <typename _Tp>
inline bool operator<=(const shared_ptr<_Tp> & __a, nullptr_t) noexcept {
return !(nullptr < __a);
}
template <typename _Tp>
inline bool operator<=(nullptr_t, const shared_ptr<_Tp> & __a) noexcept {
return !(__a < nullptr);
}
template <typename _Tp1, typename _Tp2>
inline bool operator>(const shared_ptr<_Tp1> & __a,
const shared_ptr<_Tp2> & __b) noexcept {
return (__b < __a);
}
template <typename _Tp>
inline bool operator>(const shared_ptr<_Tp> & __a, nullptr_t) noexcept {
return std::less<_Tp *>()(nullptr, __a.get());
}
template <typename _Tp>
inline bool operator>(nullptr_t, const shared_ptr<_Tp> & __a) noexcept {
return std::less<_Tp *>()(__a.get(), nullptr);
}
template <typename _Tp1, typename _Tp2>
inline bool operator>=(const shared_ptr<_Tp1> & __a,
const shared_ptr<_Tp2> & __b) noexcept {
return !(__a < __b);
}
template <typename _Tp>
inline bool operator>=(const shared_ptr<_Tp> & __a, nullptr_t) noexcept {
return !(__a < nullptr);
}
template <typename _Tp>
inline bool operator>=(nullptr_t, const shared_ptr<_Tp> & __a) noexcept {
return !(nullptr < __a);
}
template <typename _Tp>
struct less<shared_ptr<_Tp> > : public _Sp_less<shared_ptr<_Tp> > {};
template <typename _Tp>
inline void swap(shared_ptr<_Tp> & __a, shared_ptr<_Tp> & __b) noexcept {
__a.swap(__b);
}
template <typename _Tp, typename _Tp1>
inline shared_ptr<_Tp> static_pointer_cast(const shared_ptr<_Tp1> &
__r) noexcept {
return shared_ptr<_Tp>(__r, static_cast<_Tp *>(__r.get()));
}
template <typename _Tp, typename _Tp1>
inline shared_ptr<_Tp> const_pointer_cast(const shared_ptr<_Tp1> &
__r) noexcept {
return shared_ptr<_Tp>(__r, const_cast<_Tp *>(__r.get()));
}
template <typename _Tp, typename _Tp1>
inline shared_ptr<_Tp> dynamic_pointer_cast(const shared_ptr<_Tp1> &
__r) noexcept {
if (_Tp *__p = dynamic_cast<_Tp *>(__r.get()))
return shared_ptr<_Tp>(__r, __p);
return shared_ptr<_Tp>();
}
template <typename _Tp> class weak_ptr : public __weak_ptr<_Tp> {
public:
constexpr weak_ptr() noexcept : __weak_ptr<_Tp>() {}
template <typename _Tp1,
typename = typename std::enable_if<
std::is_convertible<_Tp1 *, _Tp *>::value>::type>
weak_ptr(const weak_ptr<_Tp1> &__r) noexcept : __weak_ptr<_Tp>(__r) {}
template <typename _Tp1,
typename = typename std::enable_if<
std::is_convertible<_Tp1 *, _Tp *>::value>::type>
weak_ptr(const shared_ptr<_Tp1> &__r) noexcept : __weak_ptr<_Tp>(__r) {}
template <typename _Tp1>
weak_ptr &operator=(const weak_ptr<_Tp1> &__r) noexcept {
this->__weak_ptr<_Tp>::operator=(__r);
return *this;
}
template <typename _Tp1>
weak_ptr &operator=(const shared_ptr<_Tp1> &__r) noexcept {
this->__weak_ptr<_Tp>::operator=(__r);
return *this;
}
shared_ptr<_Tp> lock() const noexcept {
return shared_ptr<_Tp>(*this, std::nothrow);
}
};
template <typename _Tp>
inline void swap(weak_ptr<_Tp> & __a, weak_ptr<_Tp> & __b) noexcept {
__a.swap(__b);
}
template <typename _Tp> struct owner_less;
template <typename _Tp>
struct owner_less<shared_ptr<_Tp> > : public _Sp_owner_less<shared_ptr<_Tp>,
weak_ptr<_Tp> > {
};
template <typename _Tp>
struct owner_less<weak_ptr<_Tp> > : public _Sp_owner_less<weak_ptr<_Tp>,
shared_ptr<_Tp> > {
};
template <typename _Tp> class enable_shared_from_this {
protected:
constexpr enable_shared_from_this() noexcept {}
enable_shared_from_this(const enable_shared_from_this &) noexcept {}
enable_shared_from_this &
operator=(const enable_shared_from_this &) noexcept {
return *this;
}
~enable_shared_from_this() {}
public:
shared_ptr<_Tp> shared_from_this() {
return shared_ptr<_Tp>(this->_M_weak_this);
}
shared_ptr<const _Tp> shared_from_this() const {
return shared_ptr<const _Tp>(this->_M_weak_this);
}
private:
template <typename _Tp1>
void _M_weak_assign(_Tp1 *__p, const __shared_count<> &__n) const noexcept {
_M_weak_this._M_assign(__p, __n);
}
template <typename _Tp1>
friend void
__enable_shared_from_this_helper(const __shared_count<> &__pn,
const enable_shared_from_this *__pe,
const _Tp1 *__px) noexcept {
if (__pe != 0)
__pe->_M_weak_assign(const_cast<_Tp1 *>(__px), __pn);
}
mutable weak_ptr<_Tp> _M_weak_this;
};
# 583 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr.h" 3
template <typename _Tp, typename _Alloc, typename... _Args>
inline shared_ptr<_Tp> allocate_shared(const _Alloc & __a,
_Args && ... __args) {
return shared_ptr<_Tp>(_Sp_make_shared_tag(), __a,
std::forward<_Args>(__args)...);
}
# 598 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/shared_ptr.h" 3
template <typename _Tp, typename... _Args>
inline shared_ptr<_Tp> make_shared(_Args && ... __args) {
typedef typename std::remove_const<_Tp>::type _Tp_nc;
return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
std::forward<_Args>(__args)...);
}
template <typename _Tp>
struct hash<shared_ptr<_Tp> > : public __hash_base<size_t, shared_ptr<_Tp> > {
size_t operator()(const shared_ptr<_Tp> &__s) const noexcept {
return std::hash<_Tp *>()(__s.get());
}
};
}
# 83 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/memory" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/backward/auto_ptr.h" 1 3
# 36 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/backward/auto_ptr.h" 3
namespace std __attribute__((__visibility__("default"))) {
# 47 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/backward/auto_ptr.h" 3
template <typename _Tp1> struct auto_ptr_ref {
_Tp1 *_M_ptr;
explicit auto_ptr_ref(_Tp1 *__p) : _M_ptr(__p) {}
} __attribute__((__deprecated__));
# 86 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/backward/auto_ptr.h" 3
template <typename _Tp> class auto_ptr {
private:
_Tp *_M_ptr;
public:
typedef _Tp element_type;
explicit auto_ptr(element_type *__p = 0) throw() : _M_ptr(__p) {}
# 112 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/backward/auto_ptr.h" 3
auto_ptr(auto_ptr &__a) throw() : _M_ptr(__a.release()) {}
# 124 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/backward/auto_ptr.h" 3
template <typename _Tp1>
auto_ptr(auto_ptr<_Tp1> &__a) throw()
: _M_ptr(__a.release()) {}
# 135 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/backward/auto_ptr.h" 3
auto_ptr &operator=(auto_ptr &__a) throw() {
reset(__a.release());
return *this;
}
# 152 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/backward/auto_ptr.h" 3
template <typename _Tp1> auto_ptr &operator=(auto_ptr<_Tp1> &__a) throw() {
reset(__a.release());
return *this;
}
# 170 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/backward/auto_ptr.h" 3
~auto_ptr() { delete _M_ptr; }
# 180 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/backward/auto_ptr.h" 3
element_type &operator*() const throw() {
;
return *_M_ptr;
}
element_type *operator->() const throw() {
;
return _M_ptr;
}
# 210 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/backward/auto_ptr.h" 3
element_type *get() const throw() { return _M_ptr; }
# 224 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/backward/auto_ptr.h" 3
element_type *release() throw() {
element_type *__tmp = _M_ptr;
_M_ptr = 0;
return __tmp;
}
# 239 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/backward/auto_ptr.h" 3
void reset(element_type *__p = 0) throw() {
if (__p != _M_ptr) {
delete _M_ptr;
_M_ptr = __p;
}
}
# 260 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/backward/auto_ptr.h" 3
auto_ptr(auto_ptr_ref<element_type> __ref) throw() : _M_ptr(__ref._M_ptr) {}
auto_ptr &operator=(auto_ptr_ref<element_type> __ref) throw() {
if (__ref._M_ptr != this->get()) {
delete _M_ptr;
_M_ptr = __ref._M_ptr;
}
return *this;
}
template <typename _Tp1> operator auto_ptr_ref<_Tp1>() throw() {
return auto_ptr_ref<_Tp1>(this->release());
}
template <typename _Tp1> operator auto_ptr<_Tp1>() throw() {
return auto_ptr<_Tp1>(this->release());
}
} __attribute__((__deprecated__));
template <> class auto_ptr<void> {
public:
typedef void element_type;
} __attribute__((__deprecated__));
template <_Lock_policy _Lp>
template <typename _Tp>
inline __shared_count<_Lp>::__shared_count(std::auto_ptr<_Tp> && __r)
: _M_pi(new _Sp_counted_ptr<_Tp *, _Lp>(__r.get())) {
__r.release();
}
template <typename _Tp, _Lock_policy _Lp>
template <typename _Tp1>
inline __shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1> && __r)
: _M_ptr(__r.get()), _M_refcount() {
static_assert(sizeof(_Tp1) > 0, "incomplete type");
_Tp1 *__tmp = __r.get();
_M_refcount = __shared_count<_Lp>(std::move(__r));
__enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
}
template <typename _Tp>
template <typename _Tp1>
inline shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1> && __r)
: __shared_ptr<_Tp>(std::move(__r)) {}
template <typename _Tp, typename _Dp>
template <typename _Up, typename>
inline unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up> && __u) noexcept
: _M_t(__u.release(), deleter_type()) {}
}
# 85 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/memory" 2 3
# 7 "./cxx_utils.hh" 2
# 17 "./cxx_utils.hh"
namespace cxx {
template <typename T> struct special_decay {
using type = typename std::decay<T>::type;
};
template <typename T> struct special_decay<std::reference_wrapper<T> > {
using type = T &;
};
template <typename T> inline typename std::decay<T>::type decay_copy(T &&t) {
return std::forward<T>(t);
}
template <typename T> struct const_ref {
typedef const typename std::decay<T>::type &type;
};
inline void rpc_assert(bool cond) {
if (cond)
return;
std::cout << "ASSERTION FAILURE\n" << std::flush;
std::cerr << "ASSERTION FAILURE\n" << std::flush;
(__builtin_expect(!(0), 0) ? __assert_rtn(__func__, "./cxx_utils.hh", 43, "0")
: (void)0);
}
template <typename T>
auto make_ptr(T &&value)
-> decltype(new typename std::decay<T>::type(std::forward<T>(value))) {
return new typename std::decay<T>::type(std::forward<T>(value));
}
template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args &&... args) {
return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}
template <typename T> T identity(T &&x) { return std::forward<T>(x); }
template <typename T> struct identity_type {
typedef T type;
T value;
operator bool() const { return true; }
const T &operator*() const { return value; }
T &operator*() { return value; }
const T *operator->() const { return &value; }
T *operator->() { return &value; }
};
template <bool...> struct all;
template <> struct all<> : std::true_type {};
template <bool... xs> struct all<true, xs...> : all<xs...> {};
template <bool... xs> struct all<false, xs...> : std::false_type {};
template <bool... xs>
struct any : std::integral_constant<bool, !all<!xs...>::value> {};
template <bool... xs>
struct none : std::integral_constant<bool, all<!xs...>::value> {};
template <bool...> struct ffs;
template <> struct ffs<> : std::integral_constant<size_t, 0> {};
template <bool... xs>
struct ffs<true, xs...> : std::integral_constant<size_t, 0> {};
template <bool... xs>
struct ffs<false, xs...> : std::integral_constant<size_t,
ffs<xs...>::value + 1> {};
}
# 6 "./cxx_tuple.hh" 2
namespace cxx {
# 21 "./cxx_tuple.hh"
namespace detail {
template <size_t...> struct seq {};
template <size_t N, size_t... S>
struct make_seq : make_seq<N - 1, N - 1, S...> {};
template <size_t... S> struct make_seq<0, S...> {
typedef seq<S...> type;
};
}
template <typename F, typename... As, size_t... S>
auto tuple_apply_impl(const F &f, const std::tuple<As...> &t, detail::seq<S...>)
-> typename cxx::invoke_of<F, As...>::type {
return cxx::invoke(f, std::get<S>(t)...);
}
template <typename F, typename... As>
auto tuple_apply(const F &f, const std::tuple<As...> &t)
-> typename cxx::invoke_of<F, As...>::type {
typename detail::make_seq<sizeof...(As)>::type s;
return tuple_apply_impl(f, t, s);
}
# 107 "./cxx_tuple.hh"
template <template <typename> class F, typename... As, size_t... S>
auto tuple_map_impl(const std::tuple<As...> &t, detail::seq<S...>)
-> std::tuple<cxx::invoke_of<F<As>(As)>...> {
return make_tuple(F<As>()(std::get<S>(t))...);
}
template <template <typename> class F, typename... As>
auto tuple_map(const std::tuple<As...> &t)
-> std::tuple<cxx::invoke_of<F<As>(As)>...> {
return tuple_map_impl<F>(t, detail::make_seq<sizeof...(As)>::type());
}
template <size_t N> struct input_tuple_impl {
template <typename... As>
static void input(std::istream &is, std::tuple<As...> &t) {
input_tuple_impl<N - 1>::input(is, t);
is >> std::get<N - 1>(t);
}
};
template <> struct input_tuple_impl<0> {
template <typename... As>
static void input(std::istream &is, std::tuple<As...> &t) {}
};
template <size_t N> struct output_tuple_impl {
template <typename... As>
static void output(std::ostream &os, const std::tuple<As...> &t) {
output_tuple_impl<N - 1>::output(os, t);
if (N > 1)
os << ",";
os << std::get<N - 1>(t);
}
};
template <> struct output_tuple_impl<0> {
template <typename... As>
static void output(std::ostream &os, const std::tuple<As...> &t) {}
};
}
namespace std {
template <typename... As>
std::istream &operator>>(std::istream &is, std::tuple<As...> &t) {
cxx::input_tuple_impl<sizeof...(As)>::input(is, t);
return is;
}
template <typename... As>
std::ostream &operator<<(std::ostream &os, const std::tuple<As...> &t) {
os << "(";
cxx::output_tuple_impl<sizeof...(As)>::output(os, t);
os << ")";
return os;
}
}
# 8 "./rpc.hh" 2
# 1 "./cxx_utils.hh" 1
# 9 "./rpc.hh" 2
# 1 "./rpc_future.hh" 1
# 1 "./rpc_future_fwd.hh" 1
# 1 "./rpc_thread.hh" 1
# 11 "./rpc_thread.hh"
# 1 "./stl_thread.hh" 1
# 1 "./cxx_invoke.hh" 1
# 5 "./stl_thread.hh" 2
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/future" 1
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/future" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/mutex" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/mutex" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/chrono" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/chrono" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ratio" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ratio" 3
# 43 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ratio" 3
namespace std __attribute__((__visibility__("default"))) {
# 55 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ratio" 3
template <intmax_t _Pn>
struct __static_sign : integral_constant < intmax_t,
(_Pn < 0) ? -1 : 1 > {};
template <intmax_t _Pn>
struct __static_abs
: integral_constant<intmax_t, _Pn *__static_sign<_Pn>::value> {};
template <intmax_t _Pn, intmax_t _Qn>
struct __static_gcd : __static_gcd<_Qn, (_Pn % _Qn)> {};
template <intmax_t _Pn>
struct __static_gcd<_Pn, 0> : integral_constant<intmax_t,
__static_abs<_Pn>::value> {};
template <intmax_t _Qn>
struct __static_gcd<0, _Qn> : integral_constant<intmax_t,
__static_abs<_Qn>::value> {};
template <intmax_t _Pn, intmax_t _Qn> struct __safe_multiply {
private:
static const uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);
static const uintmax_t __a0 = __static_abs<_Pn>::value % __c;
static const uintmax_t __a1 = __static_abs<_Pn>::value / __c;
static const uintmax_t __b0 = __static_abs<_Qn>::value % __c;
static const uintmax_t __b1 = __static_abs<_Qn>::value / __c;
static_assert(__a1 == 0 || __b1 == 0, "overflow in multiplication");
static_assert(__a0 * __b1 + __b0 * __a1 < (__c >> 1),
"overflow in multiplication");
static_assert(__b0 * __a0 <= 9223372036854775807L,
"overflow in multiplication");
static_assert((__a0 * __b1 + __b0 * __a1) * __c <=
9223372036854775807L - __b0 * __a0,
"overflow in multiplication");
public:
static const intmax_t value = _Pn * _Qn;
};
template <uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
struct __big_less
: integral_constant<
bool, (__hi1 < __hi2 || (__hi1 == __hi2 && __lo1 < __lo2))> {};
template <uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
struct __big_add {
static constexpr uintmax_t __lo = __lo1 + __lo2;
static constexpr uintmax_t __hi = (__hi1 + __hi2 + (__lo1 + __lo2 < __lo1));
};
template <uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
struct __big_sub {
static_assert(!__big_less<__hi1, __lo1, __hi2, __lo2>::value,
"Internal library error");
static constexpr uintmax_t __lo = __lo1 - __lo2;
static constexpr uintmax_t __hi = (__hi1 - __hi2 - (__lo1 < __lo2));
};
template <uintmax_t __x, uintmax_t __y> struct __big_mul {
private:
static constexpr uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);
static constexpr uintmax_t __x0 = __x % __c;
static constexpr uintmax_t __x1 = __x / __c;
static constexpr uintmax_t __y0 = __y % __c;
static constexpr uintmax_t __y1 = __y / __c;
static constexpr uintmax_t __x0y0 = __x0 * __y0;
static constexpr uintmax_t __x0y1 = __x0 * __y1;
static constexpr uintmax_t __x1y0 = __x1 * __y0;
static constexpr uintmax_t __x1y1 = __x1 * __y1;
static constexpr uintmax_t __mix = __x0y1 + __x1y0;
static constexpr uintmax_t __mix_lo = __mix * __c;
static constexpr uintmax_t __mix_hi =
__mix / __c + ((__mix < __x0y1) ? __c : 0);
typedef __big_add<__mix_hi, __mix_lo, __x1y1, __x0y0> _Res;
public:
static constexpr uintmax_t __hi = _Res::__hi;
static constexpr uintmax_t __lo = _Res::__lo;
};
template <uintmax_t __n1, uintmax_t __n0, uintmax_t __d>
struct __big_div_impl {
private:
static_assert(__d >= (uintmax_t(1) << (sizeof(intmax_t) * 8 - 1)),
"Internal library error");
static_assert(__n1 < __d, "Internal library error");
static constexpr uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);
static constexpr uintmax_t __d1 = __d / __c;
static constexpr uintmax_t __d0 = __d % __c;
static constexpr uintmax_t __q1x = __n1 / __d1;
static constexpr uintmax_t __r1x = __n1 % __d1;
static constexpr uintmax_t __m = __q1x * __d0;
static constexpr uintmax_t __r1y = __r1x * __c + __n0 / __c;
static constexpr uintmax_t __r1z = __r1y + __d;
static constexpr uintmax_t __r1 =
((__r1y < __m) ? ((__r1z >= __d) && (__r1z < __m)) ? (__r1z + __d)
: __r1z
: __r1y) -
__m;
static constexpr uintmax_t __q1 =
__q1x - ((__r1y < __m) ? ((__r1z >= __d) && (__r1z < __m)) ? 2 : 1 : 0);
static constexpr uintmax_t __q0x = __r1 / __d1;
static constexpr uintmax_t __r0x = __r1 % __d1;
static constexpr uintmax_t __n = __q0x * __d0;
static constexpr uintmax_t __r0y = __r0x * __c + __n0 % __c;
static constexpr uintmax_t __r0z = __r0y + __d;
static constexpr uintmax_t __r0 =
((__r0y < __n) ? ((__r0z >= __d) && (__r0z < __n)) ? (__r0z + __d)
: __r0z
: __r0y) -
__n;
static constexpr uintmax_t __q0 =
__q0x - ((__r0y < __n) ? ((__r0z >= __d) && (__r0z < __n)) ? 2 : 1 : 0);
public:
static constexpr uintmax_t __quot = __q1 * __c + __q0;
static constexpr uintmax_t __rem = __r0;
private:
typedef __big_mul<__quot, __d> _Prod;
typedef __big_add<_Prod::__hi, _Prod::__lo, 0, __rem> _Sum;
static_assert(_Sum::__hi == __n1 && _Sum::__lo == __n0,
"Internal library error");
};
template <uintmax_t __n1, uintmax_t __n0, uintmax_t __d> struct __big_div {
private:
static_assert(__d != 0, "Internal library error");
static_assert(sizeof(uintmax_t) == sizeof(unsigned long long),
"This library calls __builtin_clzll on uintmax_t, which "
"is unsafe on your platform. Please complain to "
"http://gcc.gnu.org/bugzilla/");
static constexpr int __shift = __builtin_clzll(__d);
static constexpr int __coshift_ = sizeof(uintmax_t) * 8 - __shift;
static constexpr int __coshift = (__shift != 0) ? __coshift_ : 0;
static constexpr uintmax_t __c1 = uintmax_t(1) << __shift;
static constexpr uintmax_t __c2 = uintmax_t(1) << __coshift;
static constexpr uintmax_t __new_d = __d * __c1;
static constexpr uintmax_t __new_n0 = __n0 * __c1;
static constexpr uintmax_t __n1_shifted = (__n1 % __d) * __c1;
static constexpr uintmax_t __n0_top = (__shift != 0) ? (__n0 / __c2) : 0;
static constexpr uintmax_t __new_n1 = __n1_shifted + __n0_top;
typedef __big_div_impl<__new_n1, __new_n0, __new_d> _Res;
public:
static constexpr uintmax_t __quot_hi = __n1 / __d;
static constexpr uintmax_t __quot_lo = _Res::__quot;
static constexpr uintmax_t __rem = _Res::__rem / __c1;
private:
typedef __big_mul<__quot_lo, __d> _P0;
typedef __big_mul<__quot_hi, __d> _P1;
typedef __big_add<_P0::__hi, _P0::__lo, _P1::__lo, __rem> _Sum;
static_assert(_P1::__hi == 0, "Internal library error");
static_assert(_Sum::__hi >= _P0::__hi, "Internal library error");
static_assert(_Sum::__hi == __n1 && _Sum::__lo == __n0,
"Internal library error");
static_assert(__rem < __d, "Internal library error");
};
# 262 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ratio" 3
template <intmax_t _Num, intmax_t _Den = 1> struct ratio {
static_assert(_Den != 0, "denominator cannot be zero");
static_assert(_Num >= -9223372036854775807L &&
_Den >= -9223372036854775807L,
"out of range");
static constexpr intmax_t num =
_Num * __static_sign<_Den>::value / __static_gcd<_Num, _Den>::value;
static constexpr intmax_t den =
__static_abs<_Den>::value / __static_gcd<_Num, _Den>::value;
typedef ratio<num, den> type;
};
template <intmax_t _Num, intmax_t _Den>
constexpr intmax_t ratio<_Num, _Den>::num;
template <intmax_t _Num, intmax_t _Den>
constexpr intmax_t ratio<_Num, _Den>::den;
template <typename _R1, typename _R2> struct __ratio_multiply {
private:
static const intmax_t __gcd1 = __static_gcd<_R1::num, _R2::den>::value;
static const intmax_t __gcd2 = __static_gcd<_R2::num, _R1::den>::value;
public:
typedef ratio<
__safe_multiply<(_R1::num / __gcd1), (_R2::num / __gcd2)>::value,
__safe_multiply<(_R1::den / __gcd2), (_R2::den / __gcd1)>::value> type;
static constexpr intmax_t num = type::num;
static constexpr intmax_t den = type::den;
};
template <typename _R1, typename _R2>
constexpr intmax_t __ratio_multiply<_R1, _R2>::num;
template <typename _R1, typename _R2>
constexpr intmax_t __ratio_multiply<_R1, _R2>::den;
template <typename _R1, typename _R2>
using ratio_multiply = typename __ratio_multiply<_R1, _R2>::type;
template <typename _R1, typename _R2> struct __ratio_divide {
static_assert(_R2::num != 0, "division by 0");
typedef typename __ratio_multiply<_R1, ratio<_R2::den, _R2::num> >::type
type;
static constexpr intmax_t num = type::num;
static constexpr intmax_t den = type::den;
};
template <typename _R1, typename _R2>
constexpr intmax_t __ratio_divide<_R1, _R2>::num;
template <typename _R1, typename _R2>
constexpr intmax_t __ratio_divide<_R1, _R2>::den;
template <typename _R1, typename _R2>
using ratio_divide = typename __ratio_divide<_R1, _R2>::type;
template <typename _R1, typename _R2>
struct ratio_equal
: integral_constant<bool, _R1::num == _R2::num &&_R1::den == _R2::den> {};
template <typename _R1, typename _R2>
struct ratio_not_equal
: integral_constant<bool, !ratio_equal<_R1, _R2>::value> {};
template <typename _R1, typename _R2,
typename _Left = __big_mul<_R1::num, _R2::den>,
typename _Right = __big_mul<_R2::num, _R1::den> >
struct __ratio_less_impl_1
: integral_constant<bool,
__big_less<_Left::__hi, _Left::__lo, _Right::__hi,
_Right::__lo>::value> {};
template <typename _R1, typename _R2,
bool = (_R1::num == 0 || _R2::num == 0 ||
(__static_sign<_R1::num>::value !=
__static_sign<_R2::num>::value)),
bool = (__static_sign<_R1::num>::value == -1 &&
__static_sign<_R2::num>::value == -1)>
struct __ratio_less_impl : __ratio_less_impl_1<_R1, _R2>::type {};
template <typename _R1, typename _R2>
struct __ratio_less_impl<_R1, _R2, true, false> : integral_constant <
bool,
_R1::num<_R2::num> {};
template <typename _R1, typename _R2>
struct __ratio_less_impl<
_R1, _R2, false,
true> : __ratio_less_impl_1<ratio<-_R2::num, _R2::den>,
ratio<-_R1::num, _R1::den> >::type {};
template <typename _R1, typename _R2>
struct ratio_less : __ratio_less_impl<_R1, _R2>::type {};
template <typename _R1, typename _R2>
struct ratio_less_equal
: integral_constant<bool, !ratio_less<_R2, _R1>::value> {};
template <typename _R1, typename _R2>
struct ratio_greater : integral_constant<bool, ratio_less<_R2, _R1>::value> {
};
template <typename _R1, typename _R2>
struct ratio_greater_equal
: integral_constant<bool, !ratio_less<_R1, _R2>::value> {};
template <
typename _R1, typename _R2, bool = (_R1::num >= 0),
bool = (_R2::num >= 0),
bool = ratio_less<ratio<__static_abs<_R1::num>::value, _R1::den>,
ratio<__static_abs<_R2::num>::value, _R2::den> >::value>
struct __ratio_add_impl {
private:
typedef typename __ratio_add_impl<ratio<-_R1::num, _R1::den>,
ratio<-_R2::num, _R2::den> >::type __t;
public:
typedef ratio<-__t::num, __t::den> type;
};
template <typename _R1, typename _R2, bool __b>
struct __ratio_add_impl<_R1, _R2, true, true, __b> {
private:
static constexpr uintmax_t __g = __static_gcd<_R1::den, _R2::den>::value;
static constexpr uintmax_t __d2 = _R2::den / __g;
typedef __big_mul<_R1::den, __d2> __d;
typedef __big_mul<_R1::num, _R2::den / __g> __x;
typedef __big_mul<_R2::num, _R1::den / __g> __y;
typedef __big_add<__x::__hi, __x::__lo, __y::__hi, __y::__lo> __n;
static_assert(__n::__hi >= __x::__hi, "Internal library error");
typedef __big_div<__n::__hi, __n::__lo, __g> __ng;
static constexpr uintmax_t __g2 = __static_gcd<__ng::__rem, __g>::value;
typedef __big_div<__n::__hi, __n::__lo, __g2> __n_final;
static_assert(__n_final::__rem == 0, "Internal library error");
static_assert(__n_final::__quot_hi == 0 &&
__n_final::__quot_lo <= 9223372036854775807L,
"overflow in addition");
typedef __big_mul<_R1::den / __g2, __d2> __d_final;
static_assert(__d_final::__hi == 0 &&
__d_final::__lo <= 9223372036854775807L,
"overflow in addition");
public:
typedef ratio<__n_final::__quot_lo, __d_final::__lo> type;
};
template <typename _R1, typename _R2>
struct __ratio_add_impl<_R1, _R2, false, true,
true> : __ratio_add_impl<_R2, _R1> {};
template <typename _R1, typename _R2>
struct __ratio_add_impl<_R1, _R2, true, false, false> {
private:
static constexpr uintmax_t __g = __static_gcd<_R1::den, _R2::den>::value;
static constexpr uintmax_t __d2 = _R2::den / __g;
typedef __big_mul<_R1::den, __d2> __d;
typedef __big_mul<_R1::num, _R2::den / __g> __x;
typedef __big_mul<-_R2::num, _R1::den / __g> __y;
typedef __big_sub<__x::__hi, __x::__lo, __y::__hi, __y::__lo> __n;
typedef __big_div<__n::__hi, __n::__lo, __g> __ng;
static constexpr uintmax_t __g2 = __static_gcd<__ng::__rem, __g>::value;
typedef __big_div<__n::__hi, __n::__lo, __g2> __n_final;
static_assert(__n_final::__rem == 0, "Internal library error");
static_assert(__n_final::__quot_hi == 0 &&
__n_final::__quot_lo <= 9223372036854775807L,
"overflow in addition");
typedef __big_mul<_R1::den / __g2, __d2> __d_final;
static_assert(__d_final::__hi == 0 &&
__d_final::__lo <= 9223372036854775807L,
"overflow in addition");
public:
typedef ratio<__n_final::__quot_lo, __d_final::__lo> type;
};
template <typename _R1, typename _R2> struct __ratio_add {
typedef typename __ratio_add_impl<_R1, _R2>::type type;
static constexpr intmax_t num = type::num;
static constexpr intmax_t den = type::den;
};
template <typename _R1, typename _R2>
constexpr intmax_t __ratio_add<_R1, _R2>::num;
template <typename _R1, typename _R2>
constexpr intmax_t __ratio_add<_R1, _R2>::den;
template <typename _R1, typename _R2>
using ratio_add = typename __ratio_add<_R1, _R2>::type;
template <typename _R1, typename _R2> struct __ratio_subtract {
typedef typename __ratio_add<_R1, ratio<-_R2::num, _R2::den> >::type type;
static constexpr intmax_t num = type::num;
static constexpr intmax_t den = type::den;
};
template <typename _R1, typename _R2>
constexpr intmax_t __ratio_subtract<_R1, _R2>::num;
template <typename _R1, typename _R2>
constexpr intmax_t __ratio_subtract<_R1, _R2>::den;
template <typename _R1, typename _R2>
using ratio_subtract = typename __ratio_subtract<_R1, _R2>::type;
typedef ratio<1, 1000000000000000000> atto;
typedef ratio<1, 1000000000000000> femto;
typedef ratio<1, 1000000000000> pico;
typedef ratio<1, 1000000000> nano;
typedef ratio<1, 1000000> micro;
typedef ratio<1, 1000> milli;
typedef ratio<1, 100> centi;
typedef ratio<1, 10> deci;
typedef ratio<10, 1> deca;
typedef ratio<100, 1> hecto;
typedef ratio<1000, 1> kilo;
typedef ratio<1000000, 1> mega;
typedef ratio<1000000000, 1> giga;
typedef ratio<1000000000000, 1> tera;
typedef ratio<1000000000000000, 1> peta;
typedef ratio<1000000000000000000, 1> exa;
}
# 39 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/chrono" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/limits" 1 3
# 41 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/limits" 3
# 147 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/limits" 3
namespace std __attribute__((__visibility__("default"))) {
enum float_round_style {
round_indeterminate = -1,
round_toward_zero = 0,
round_to_nearest = 1,
round_toward_infinity = 2,
round_toward_neg_infinity = 3
};
enum float_denorm_style {
denorm_indeterminate = -1,
denorm_absent = 0,
denorm_present = 1
};
# 191 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/limits" 3
struct __numeric_limits_base {
static constexpr bool is_specialized = false;
static constexpr int digits = 0;
static constexpr int digits10 = 0;
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 0;
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = false;
# 277 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/limits" 3
static constexpr bool is_modulo = false;
static constexpr bool traps = false;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
# 303 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/limits" 3
template <typename _Tp> struct numeric_limits : public __numeric_limits_base {
static constexpr _Tp min() noexcept { return _Tp(); }
static constexpr _Tp max() noexcept { return _Tp(); }
static constexpr _Tp lowest() noexcept { return _Tp(); }
static constexpr _Tp epsilon() noexcept { return _Tp(); }
static constexpr _Tp round_error() noexcept { return _Tp(); }
static constexpr _Tp infinity() noexcept { return _Tp(); }
static constexpr _Tp quiet_NaN() noexcept { return _Tp(); }
static constexpr _Tp signaling_NaN() noexcept { return _Tp(); }
static constexpr _Tp denorm_min() noexcept { return _Tp(); }
};
template <typename _Tp>
struct numeric_limits<const _Tp> : public numeric_limits<_Tp> {};
template <typename _Tp>
struct numeric_limits<volatile _Tp> : public numeric_limits<_Tp> {};
template <typename _Tp>
struct numeric_limits<const volatile _Tp> : public numeric_limits<_Tp> {};
template <> struct numeric_limits<bool> {
static constexpr bool is_specialized = true;
static constexpr bool min() noexcept { return false; }
static constexpr bool max() noexcept { return true; }
static constexpr bool lowest() noexcept { return min(); }
static constexpr int digits = 1;
static constexpr int digits10 = 0;
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr bool epsilon() noexcept { return false; }
static constexpr bool round_error() noexcept { return false; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr bool infinity() noexcept { return false; }
static constexpr bool quiet_NaN() noexcept { return false; }
static constexpr bool signaling_NaN() noexcept { return false; }
static constexpr bool denorm_min() noexcept { return false; }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template <> struct numeric_limits<char> {
static constexpr bool is_specialized = true;
static constexpr char min() noexcept {
return (((char)(-1) < 0)
? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 -
((char)(-1) < 0)) -
1)) -
1)
<< 1) +
1)
: ~(char)0) -
1
: (char)0);
}
static constexpr char max() noexcept {
return (
((char)(-1) < 0)
? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1)
<< 1) +
1)
: ~(char)0);
}
static constexpr char lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
static constexpr int digits10 =
((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((char)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr char epsilon() noexcept { return 0; }
static constexpr char round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr char infinity() noexcept { return char(); }
static constexpr char quiet_NaN() noexcept { return char(); }
static constexpr char signaling_NaN() noexcept { return char(); }
static constexpr char denorm_min() noexcept { return static_cast<char>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template <> struct numeric_limits<signed char> {
static constexpr bool is_specialized = true;
static constexpr signed char min() noexcept { return -127 - 1; }
static constexpr signed char max() noexcept { return 127; }
static constexpr signed char lowest() noexcept { return min(); }
static constexpr int digits =
(sizeof(signed char) * 8 - ((signed char)(-1) < 0));
static constexpr int digits10 =
((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr signed char epsilon() noexcept { return 0; }
static constexpr signed char round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr signed char infinity() noexcept {
return static_cast<signed char>(0);
}
static constexpr signed char quiet_NaN() noexcept {
return static_cast<signed char>(0);
}
static constexpr signed char signaling_NaN() noexcept {
return static_cast<signed char>(0);
}
static constexpr signed char denorm_min() noexcept {
return static_cast<signed char>(0);
}
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template <> struct numeric_limits<unsigned char> {
static constexpr bool is_specialized = true;
static constexpr unsigned char min() noexcept { return 0; }
static constexpr unsigned char max() noexcept { return 127 * 2U + 1; }
static constexpr unsigned char lowest() noexcept { return min(); }
static constexpr int digits =
(sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
static constexpr int digits10 =
((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned char epsilon() noexcept { return 0; }
static constexpr unsigned char round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned char infinity() noexcept {
return static_cast<unsigned char>(0);
}
static constexpr unsigned char quiet_NaN() noexcept {
return static_cast<unsigned char>(0);
}
static constexpr unsigned char signaling_NaN() noexcept {
return static_cast<unsigned char>(0);
}
static constexpr unsigned char denorm_min() noexcept {
return static_cast<unsigned char>(0);
}
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template <> struct numeric_limits<wchar_t> {
static constexpr bool is_specialized = true;
static constexpr wchar_t min() noexcept {
return (((wchar_t)(-1) < 0)
? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1
<< ((sizeof(wchar_t) * 8 -
((wchar_t)(-1) < 0)) -
1)) -
1)
<< 1) +
1)
: ~(wchar_t)0) -
1
: (wchar_t)0);
}
static constexpr wchar_t max() noexcept {
return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 -
((wchar_t)(-1) < 0)) -
1)) -
1)
<< 1) +
1)
: ~(wchar_t)0);
}
static constexpr wchar_t lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
static constexpr int digits10 =
((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((wchar_t)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr wchar_t epsilon() noexcept { return 0; }
static constexpr wchar_t round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr wchar_t infinity() noexcept { return wchar_t(); }
static constexpr wchar_t quiet_NaN() noexcept { return wchar_t(); }
static constexpr wchar_t signaling_NaN() noexcept { return wchar_t(); }
static constexpr wchar_t denorm_min() noexcept { return wchar_t(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template <> struct numeric_limits<char16_t> {
static constexpr bool is_specialized = true;
static constexpr char16_t min() noexcept {
return (((char16_t)(-1) < 0)
? -(((char16_t)(-1) < 0) ? (((((char16_t)1
<< ((sizeof(char16_t) * 8 -
((char16_t)(-1) < 0)) -
1)) -
1)
<< 1) +
1)
: ~(char16_t)0) -
1
: (char16_t)0);
}
static constexpr char16_t max() noexcept {
return (((char16_t)(-1) < 0) ? (((((char16_t)1
<< ((sizeof(char16_t) * 8 -
((char16_t)(-1) < 0)) -
1)) -
1)
<< 1) +
1)
: ~(char16_t)0);
}
static constexpr char16_t lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0));
static constexpr int digits10 =
((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((char16_t)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr char16_t epsilon() noexcept { return 0; }
static constexpr char16_t round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr char16_t infinity() noexcept { return char16_t(); }
static constexpr char16_t quiet_NaN() noexcept { return char16_t(); }
static constexpr char16_t signaling_NaN() noexcept { return char16_t(); }
static constexpr char16_t denorm_min() noexcept { return char16_t(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template <> struct numeric_limits<char32_t> {
static constexpr bool is_specialized = true;
static constexpr char32_t min() noexcept {
return (((char32_t)(-1) < 0)
? -(((char32_t)(-1) < 0) ? (((((char32_t)1
<< ((sizeof(char32_t) * 8 -
((char32_t)(-1) < 0)) -
1)) -
1)
<< 1) +
1)
: ~(char32_t)0) -
1
: (char32_t)0);
}
static constexpr char32_t max() noexcept {
return (((char32_t)(-1) < 0) ? (((((char32_t)1
<< ((sizeof(char32_t) * 8 -
((char32_t)(-1) < 0)) -
1)) -
1)
<< 1) +
1)
: ~(char32_t)0);
}
static constexpr char32_t lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0));
static constexpr int digits10 =
((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((char32_t)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr char32_t epsilon() noexcept { return 0; }
static constexpr char32_t round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr char32_t infinity() noexcept { return char32_t(); }
static constexpr char32_t quiet_NaN() noexcept { return char32_t(); }
static constexpr char32_t signaling_NaN() noexcept { return char32_t(); }
static constexpr char32_t denorm_min() noexcept { return char32_t(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template <> struct numeric_limits<short> {
static constexpr bool is_specialized = true;
static constexpr short min() noexcept { return -32767 - 1; }
static constexpr short max() noexcept { return 32767; }
static constexpr short lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
static constexpr int digits10 =
((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr short epsilon() noexcept { return 0; }
static constexpr short round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr short infinity() noexcept { return short(); }
static constexpr short quiet_NaN() noexcept { return short(); }
static constexpr short signaling_NaN() noexcept { return short(); }
static constexpr short denorm_min() noexcept { return short(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template <> struct numeric_limits<unsigned short> {
static constexpr bool is_specialized = true;
static constexpr unsigned short min() noexcept { return 0; }
static constexpr unsigned short max() noexcept { return 32767 * 2U + 1; }
static constexpr unsigned short lowest() noexcept { return min(); }
static constexpr int digits =
(sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
static constexpr int digits10 =
((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L /
2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned short epsilon() noexcept { return 0; }
static constexpr unsigned short round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned short infinity() noexcept {
return static_cast<unsigned short>(0);
}
static constexpr unsigned short quiet_NaN() noexcept {
return static_cast<unsigned short>(0);
}
static constexpr unsigned short signaling_NaN() noexcept {
return static_cast<unsigned short>(0);
}
static constexpr unsigned short denorm_min() noexcept {
return static_cast<unsigned short>(0);
}
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template <> struct numeric_limits<int> {
static constexpr bool is_specialized = true;
static constexpr int min() noexcept { return -2147483647 - 1; }
static constexpr int max() noexcept { return 2147483647; }
static constexpr int lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
static constexpr int digits10 =
((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr int epsilon() noexcept { return 0; }
static constexpr int round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr int infinity() noexcept { return static_cast<int>(0); }
static constexpr int quiet_NaN() noexcept { return static_cast<int>(0); }
static constexpr int signaling_NaN() noexcept {
return static_cast<int>(0);
}
static constexpr int denorm_min() noexcept { return static_cast<int>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template <> struct numeric_limits<unsigned int> {
static constexpr bool is_specialized = true;
static constexpr unsigned int min() noexcept { return 0; }
static constexpr unsigned int max() noexcept { return 2147483647 * 2U + 1; }
static constexpr unsigned int lowest() noexcept { return min(); }
static constexpr int digits =
(sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
static constexpr int digits10 =
((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned int epsilon() noexcept { return 0; }
static constexpr unsigned int round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned int infinity() noexcept {
return static_cast<unsigned int>(0);
}
static constexpr unsigned int quiet_NaN() noexcept {
return static_cast<unsigned int>(0);
}
static constexpr unsigned int signaling_NaN() noexcept {
return static_cast<unsigned int>(0);
}
static constexpr unsigned int denorm_min() noexcept {
return static_cast<unsigned int>(0);
}
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template <> struct numeric_limits<long> {
static constexpr bool is_specialized = true;
static constexpr long min() noexcept { return -9223372036854775807L - 1; }
static constexpr long max() noexcept { return 9223372036854775807L; }
static constexpr long lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
static constexpr int digits10 =
((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr long epsilon() noexcept { return 0; }
static constexpr long round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr long infinity() noexcept { return static_cast<long>(0); }
static constexpr long quiet_NaN() noexcept { return static_cast<long>(0); }
static constexpr long signaling_NaN() noexcept {
return static_cast<long>(0);
}
static constexpr long denorm_min() noexcept { return static_cast<long>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template <> struct numeric_limits<unsigned long> {
static constexpr bool is_specialized = true;
static constexpr unsigned long min() noexcept { return 0; }
static constexpr unsigned long max() noexcept {
return 9223372036854775807L * 2UL + 1;
}
static constexpr unsigned long lowest() noexcept { return min(); }
static constexpr int digits =
(sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
static constexpr int digits10 =
((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned long epsilon() noexcept { return 0; }
static constexpr unsigned long round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned long infinity() noexcept {
return static_cast<unsigned long>(0);
}
static constexpr unsigned long quiet_NaN() noexcept {
return static_cast<unsigned long>(0);
}
static constexpr unsigned long signaling_NaN() noexcept {
return static_cast<unsigned long>(0);
}
static constexpr unsigned long denorm_min() noexcept {
return static_cast<unsigned long>(0);
}
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template <> struct numeric_limits<long long> {
static constexpr bool is_specialized = true;
static constexpr long long min() noexcept {
return -9223372036854775807LL - 1;
}
static constexpr long long max() noexcept { return 9223372036854775807LL; }
static constexpr long long lowest() noexcept { return min(); }
static constexpr int digits =
(sizeof(long long) * 8 - ((long long)(-1) < 0));
static constexpr int digits10 =
((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr long long epsilon() noexcept { return 0; }
static constexpr long long round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr long long infinity() noexcept {
return static_cast<long long>(0);
}
static constexpr long long quiet_NaN() noexcept {
return static_cast<long long>(0);
}
static constexpr long long signaling_NaN() noexcept {
return static_cast<long long>(0);
}
static constexpr long long denorm_min() noexcept {
return static_cast<long long>(0);
}
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template <> struct numeric_limits<unsigned long long> {
static constexpr bool is_specialized = true;
static constexpr unsigned long long min() noexcept { return 0; }
static constexpr unsigned long long max() noexcept {
return 9223372036854775807LL * 2ULL + 1;
}
static constexpr unsigned long long lowest() noexcept { return min(); }
static constexpr int digits =
(sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
static constexpr int digits10 =
((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) *
643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned long long epsilon() noexcept { return 0; }
static constexpr unsigned long long round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned long long infinity() noexcept {
return static_cast<unsigned long long>(0);
}
static constexpr unsigned long long quiet_NaN() noexcept {
return static_cast<unsigned long long>(0);
}
static constexpr unsigned long long signaling_NaN() noexcept {
return static_cast<unsigned long long>(0);
}
static constexpr unsigned long long denorm_min() noexcept {
return static_cast<unsigned long long>(0);
}
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
# 1552 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/limits" 3
template <> struct numeric_limits<float> {
static constexpr bool is_specialized = true;
static constexpr float min() noexcept { return 1.17549435e-38F; }
static constexpr float max() noexcept { return 3.40282347e+38F; }
static constexpr float lowest() noexcept { return -3.40282347e+38F; }
static constexpr int digits = 24;
static constexpr int digits10 = 6;
static constexpr int max_digits10 = (2 + (24) * 643L / 2136);
static constexpr bool is_signed = true;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 2;
static constexpr float epsilon() noexcept { return 1.19209290e-7F; }
static constexpr float round_error() noexcept { return 0.5F; }
static constexpr int min_exponent = (-125);
static constexpr int min_exponent10 = (-37);
static constexpr int max_exponent = 128;
static constexpr int max_exponent10 = 38;
static constexpr bool has_infinity = 1;
static constexpr bool has_quiet_NaN = 1;
static constexpr bool has_signaling_NaN = has_quiet_NaN;
static constexpr float_denorm_style has_denorm =
bool(1) ? denorm_present : denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr float infinity() noexcept { return __builtin_huge_valf(); }
static constexpr float quiet_NaN() noexcept { return __builtin_nanf(""); }
static constexpr float signaling_NaN() noexcept {
return __builtin_nansf("");
}
static constexpr float denorm_min() noexcept { return 1.40129846e-45F; }
static constexpr bool is_iec559 =
has_infinity && has_quiet_NaN && has_denorm == denorm_present;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = false;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_to_nearest;
};
template <> struct numeric_limits<double> {
static constexpr bool is_specialized = true;
static constexpr double min() noexcept { return 2.2250738585072014e-308; }
static constexpr double max() noexcept { return 1.7976931348623157e+308; }
static constexpr double lowest() noexcept {
return -1.7976931348623157e+308;
}
static constexpr int digits = 53;
static constexpr int digits10 = 15;
static constexpr int max_digits10 = (2 + (53) * 643L / 2136);
static constexpr bool is_signed = true;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 2;
static constexpr double epsilon() noexcept {
return 2.2204460492503131e-16;
}
static constexpr double round_error() noexcept { return 0.5; }
static constexpr int min_exponent = (-1021);
static constexpr int min_exponent10 = (-307);
static constexpr int max_exponent = 1024;
static constexpr int max_exponent10 = 308;
static constexpr bool has_infinity = 1;
static constexpr bool has_quiet_NaN = 1;
static constexpr bool has_signaling_NaN = has_quiet_NaN;
static constexpr float_denorm_style has_denorm =
bool(1) ? denorm_present : denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr double infinity() noexcept { return __builtin_huge_val(); }
static constexpr double quiet_NaN() noexcept { return __builtin_nan(""); }
static constexpr double signaling_NaN() noexcept {
return __builtin_nans("");
}
static constexpr double denorm_min() noexcept {
return 4.9406564584124654e-324;
}
static constexpr bool is_iec559 =
has_infinity && has_quiet_NaN && has_denorm == denorm_present;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = false;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_to_nearest;
};
template <> struct numeric_limits<long double> {
static constexpr bool is_specialized = true;
static constexpr long double min() noexcept {
return 3.36210314311209350626e-4932L;
}
static constexpr long double max() noexcept {
return 1.18973149535723176502e+4932L;
}
static constexpr long double lowest() noexcept {
return -1.18973149535723176502e+4932L;
}
static constexpr int digits = 64;
static constexpr int digits10 = 18;
static constexpr int max_digits10 = (2 + (64) * 643L / 2136);
static constexpr bool is_signed = true;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 2;
static constexpr long double epsilon() noexcept {
return 1.08420217248550443401e-19L;
}
static constexpr long double round_error() noexcept { return 0.5L; }
static constexpr int min_exponent = (-16381);
static constexpr int min_exponent10 = (-4931);
static constexpr int max_exponent = 16384;
static constexpr int max_exponent10 = 4932;
static constexpr bool has_infinity = 1;
static constexpr bool has_quiet_NaN = 1;
static constexpr bool has_signaling_NaN = has_quiet_NaN;
static constexpr float_denorm_style has_denorm =
bool(1) ? denorm_present : denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr long double infinity() noexcept {
return __builtin_huge_vall();
}
static constexpr long double quiet_NaN() noexcept {
return __builtin_nanl("");
}
static constexpr long double signaling_NaN() noexcept {
return __builtin_nansl("");
}
static constexpr long double denorm_min() noexcept {
return 3.64519953188247460253e-4951L;
}
static constexpr bool is_iec559 =
has_infinity && has_quiet_NaN && has_denorm == denorm_present;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = false;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_to_nearest;
};
}
# 41 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/chrono" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ctime" 1 3
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ctime" 3
# 58 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/ctime" 3
namespace std {
using ::clock_t;
using ::time_t;
using ::tm;
using ::clock;
using ::difftime;
using ::mktime;
using ::time;
using ::asctime;
using ::ctime;
using ::gmtime;
using ::localtime;
using ::strftime;
}
# 42 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/chrono" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/parse_numbers.h" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/parse_numbers.h" 3
# 43 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/chrono" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 59 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/chrono" 3
namespace chrono {
template <typename _Rep, typename _Period = ratio<1> > struct duration;
template <typename _Clock, typename _Dur = typename _Clock::duration>
struct time_point;
}
template <typename _CT, typename _Period1, typename _Period2>
struct __duration_common_type_wrapper {
private:
typedef __static_gcd<_Period1::num, _Period2::num> __gcd_num;
typedef __static_gcd<_Period1::den, _Period2::den> __gcd_den;
typedef typename _CT::type __cr;
typedef ratio<__gcd_num::value,
(_Period1::den / __gcd_den::value) * _Period2::den> __r;
public:
typedef __success_type<chrono::duration<__cr, __r> > type;
};
template <typename _Period1, typename _Period2>
struct __duration_common_type_wrapper<__failure_type, _Period1, _Period2> {
typedef __failure_type type;
};
template <typename _Rep1, typename _Period1, typename _Rep2,
typename _Period2>
struct common_type<
chrono::duration<_Rep1, _Period1>,
chrono::duration<
_Rep2,
_Period2> > : public __duration_common_type_wrapper<typename __member_type_wrapper<common_type<_Rep1,
_Rep2> >::
type,
_Period1,
_Period2>::
type {};
template <typename _CT, typename _Clock>
struct __timepoint_common_type_wrapper {
typedef __success_type<chrono::time_point<_Clock, typename _CT::type> >
type;
};
template <typename _Clock>
struct __timepoint_common_type_wrapper<__failure_type, _Clock> {
typedef __failure_type type;
};
template <typename _Clock, typename _Duration1, typename _Duration2>
struct common_type<
chrono::time_point<_Clock, _Duration1>,
chrono::time_point<
_Clock,
_Duration2> > : public __timepoint_common_type_wrapper<typename __member_type_wrapper<common_type<_Duration1,
_Duration2> >::
type,
_Clock>::
type {};
namespace chrono {
template <typename _ToDur, typename _CF, typename _CR, bool _NumIsOne = false,
bool _DenIsOne = false>
struct __duration_cast_impl {
template <typename _Rep, typename _Period>
static constexpr _ToDur __cast(const duration<_Rep, _Period> &__d) {
typedef typename _ToDur::rep __to_rep;
return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count()) *
static_cast<_CR>(_CF::num) /
static_cast<_CR>(_CF::den)));
}
};
template <typename _ToDur, typename _CF, typename _CR>
struct __duration_cast_impl<_ToDur, _CF, _CR, true, true> {
template <typename _Rep, typename _Period>
static constexpr _ToDur __cast(const duration<_Rep, _Period> &__d) {
typedef typename _ToDur::rep __to_rep;
return _ToDur(static_cast<__to_rep>(__d.count()));
}
};
template <typename _ToDur, typename _CF, typename _CR>
struct __duration_cast_impl<_ToDur, _CF, _CR, true, false> {
template <typename _Rep, typename _Period>
static constexpr _ToDur __cast(const duration<_Rep, _Period> &__d) {
typedef typename _ToDur::rep __to_rep;
return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count()) /
static_cast<_CR>(_CF::den)));
}
};
template <typename _ToDur, typename _CF, typename _CR>
struct __duration_cast_impl<_ToDur, _CF, _CR, false, true> {
template <typename _Rep, typename _Period>
static constexpr _ToDur __cast(const duration<_Rep, _Period> &__d) {
typedef typename _ToDur::rep __to_rep;
return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count()) *
static_cast<_CR>(_CF::num)));
}
};
template <typename _Tp> struct __is_duration : std::false_type {};
template <typename _Rep, typename _Period>
struct __is_duration<duration<_Rep, _Period> > : std::true_type {};
template <typename _ToDur, typename _Rep, typename _Period>
constexpr typename enable_if<__is_duration<_ToDur>::value, _ToDur>::type
duration_cast(const duration<_Rep, _Period> &__d) {
typedef typename _ToDur::period __to_period;
typedef typename _ToDur::rep __to_rep;
typedef ratio_divide<_Period, __to_period> __cf;
typedef typename common_type<__to_rep, _Rep, intmax_t>::type __cr;
typedef __duration_cast_impl<_ToDur, __cf, __cr, __cf::num == 1,
__cf::den == 1> __dc;
return __dc::__cast(__d);
}
template <typename _Rep>
struct treat_as_floating_point : is_floating_point<_Rep> {};
template <typename _Rep> struct duration_values {
static constexpr _Rep zero() { return _Rep(0); }
static constexpr _Rep max() { return numeric_limits<_Rep>::max(); }
static constexpr _Rep min() { return numeric_limits<_Rep>::lowest(); }
};
template <typename _Tp> struct __is_ratio : std::false_type {};
template <intmax_t _Num, intmax_t _Den>
struct __is_ratio<ratio<_Num, _Den> > : std::true_type {};
template <typename _Rep, typename _Period> struct duration {
typedef _Rep rep;
typedef _Period period;
static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
static_assert(__is_ratio<_Period>::value,
"period must be a specialization of ratio");
static_assert(_Period::num > 0, "period must be positive");
constexpr duration() = default;
duration(const duration &) = default;
template <typename _Rep2,
typename =
typename enable_if<is_convertible<_Rep2, rep>::value &&(
treat_as_floating_point<rep>::value ||
!treat_as_floating_point<_Rep2>::value)>::type>
constexpr explicit duration(const _Rep2 &__rep)
: __r(static_cast<rep>(__rep)) {}
template <typename _Rep2, typename _Period2,
typename = typename enable_if<
treat_as_floating_point<rep>::value ||
(ratio_divide<_Period2, period>::den == 1 &&
!treat_as_floating_point<_Rep2>::value)>::type>
constexpr duration(const duration<_Rep2, _Period2> &__d)
: __r(duration_cast<duration>(__d).count()) {}
~duration() = default;
duration &operator=(const duration &) = default;
constexpr rep count() const { return __r; }
constexpr duration operator+() const { return *this; }
constexpr duration operator-() const { return duration(-__r); }
duration &operator++() {
++__r;
return *this;
}
duration operator++(int) { return duration(__r++); }
duration &operator--() {
--__r;
return *this;
}
duration operator--(int) { return duration(__r--); }
duration &operator+=(const duration &__d) {
__r += __d.count();
return *this;
}
duration &operator-=(const duration &__d) {
__r -= __d.count();
return *this;
}
duration &operator*=(const rep &__rhs) {
__r *= __rhs;
return *this;
}
duration &operator/=(const rep &__rhs) {
__r /= __rhs;
return *this;
}
template <typename _Rep2 = rep>
typename enable_if<!treat_as_floating_point<_Rep2>::value, duration &>::type
operator%=(const rep &__rhs) {
__r %= __rhs;
return *this;
}
template <typename _Rep2 = rep>
typename enable_if<!treat_as_floating_point<_Rep2>::value, duration &>::type
operator%=(const duration &__d) {
__r %= __d.count();
return *this;
}
static constexpr duration zero() {
return duration(duration_values<rep>::zero());
}
static constexpr duration min() {
return duration(duration_values<rep>::min());
}
static constexpr duration max() {
return duration(duration_values<rep>::max());
}
private:
rep __r;
};
template <typename _Rep1, typename _Period1, typename _Rep2,
typename _Period2>
constexpr typename common_type<duration<_Rep1, _Period1>,
duration<_Rep2, _Period2> >::type
operator+(const duration<_Rep1, _Period1> &__lhs,
const duration<_Rep2, _Period2> &__rhs) {
typedef duration<_Rep1, _Period1> __dur1;
typedef duration<_Rep2, _Period2> __dur2;
typedef typename common_type<__dur1, __dur2>::type __cd;
return __cd(__cd(__lhs).count() + __cd(__rhs).count());
}
template <typename _Rep1, typename _Period1, typename _Rep2,
typename _Period2>
constexpr typename common_type<duration<_Rep1, _Period1>,
duration<_Rep2, _Period2> >::type
operator-(const duration<_Rep1, _Period1> &__lhs,
const duration<_Rep2, _Period2> &__rhs) {
typedef duration<_Rep1, _Period1> __dur1;
typedef duration<_Rep2, _Period2> __dur2;
typedef typename common_type<__dur1, __dur2>::type __cd;
return __cd(__cd(__lhs).count() - __cd(__rhs).count());
}
template <typename _Rep1, typename _Rep2,
bool = is_convertible<
_Rep2, typename common_type<_Rep1, _Rep2>::type>::value>
struct __common_rep_type {};
template <typename _Rep1, typename _Rep2>
struct __common_rep_type<_Rep1, _Rep2, true> {
typedef typename common_type<_Rep1, _Rep2>::type type;
};
template <typename _Rep1, typename _Period, typename _Rep2>
constexpr duration<typename __common_rep_type<_Rep1, _Rep2>::type, _Period>
operator*(const duration<_Rep1, _Period> &__d, const _Rep2 &__s) {
typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> __cd;
return __cd(__cd(__d).count() * __s);
}
template <typename _Rep1, typename _Rep2, typename _Period>
constexpr duration<typename __common_rep_type<_Rep2, _Rep1>::type, _Period>
operator*(const _Rep1 &__s, const duration<_Rep2, _Period> &__d) {
return __d * __s;
}
template <typename _Rep1, typename _Period, typename _Rep2>
constexpr duration<typename __common_rep_type<
_Rep1, typename enable_if<!__is_duration<_Rep2>::value,
_Rep2>::type>::type,
_Period>
operator/(const duration<_Rep1, _Period> &__d, const _Rep2 &__s) {
typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> __cd;
return __cd(__cd(__d).count() / __s);
}
template <typename _Rep1, typename _Period1, typename _Rep2,
typename _Period2>
constexpr typename common_type<_Rep1, _Rep2>::type
operator/(const duration<_Rep1, _Period1> &__lhs,
const duration<_Rep2, _Period2> &__rhs) {
typedef duration<_Rep1, _Period1> __dur1;
typedef duration<_Rep2, _Period2> __dur2;
typedef typename common_type<__dur1, __dur2>::type __cd;
return __cd(__lhs).count() / __cd(__rhs).count();
}
template <typename _Rep1, typename _Period, typename _Rep2>
constexpr duration<typename __common_rep_type<
_Rep1, typename enable_if<!__is_duration<_Rep2>::value,
_Rep2>::type>::type,
_Period>
operator%(const duration<_Rep1, _Period> &__d, const _Rep2 &__s) {
typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> __cd;
return __cd(__cd(__d).count() % __s);
}
template <typename _Rep1, typename _Period1, typename _Rep2,
typename _Period2>
constexpr typename common_type<duration<_Rep1, _Period1>,
duration<_Rep2, _Period2> >::type
operator%(const duration<_Rep1, _Period1> &__lhs,
const duration<_Rep2, _Period2> &__rhs) {
typedef duration<_Rep1, _Period1> __dur1;
typedef duration<_Rep2, _Period2> __dur2;
typedef typename common_type<__dur1, __dur2>::type __cd;
return __cd(__cd(__lhs).count() % __cd(__rhs).count());
}
template <typename _Rep1, typename _Period1, typename _Rep2,
typename _Period2>
constexpr bool operator==(const duration<_Rep1, _Period1> &__lhs,
const duration<_Rep2, _Period2> &__rhs) {
typedef duration<_Rep1, _Period1> __dur1;
typedef duration<_Rep2, _Period2> __dur2;
typedef typename common_type<__dur1, __dur2>::type __ct;
return __ct(__lhs).count() == __ct(__rhs).count();
}
template <typename _Rep1, typename _Period1, typename _Rep2,
typename _Period2>
constexpr bool operator<(const duration<_Rep1, _Period1> &__lhs,
const duration<_Rep2, _Period2> &__rhs) {
typedef duration<_Rep1, _Period1> __dur1;
typedef duration<_Rep2, _Period2> __dur2;
typedef typename common_type<__dur1, __dur2>::type __ct;
return __ct(__lhs).count() < __ct(__rhs).count();
}
template <typename _Rep1, typename _Period1, typename _Rep2,
typename _Period2>
constexpr bool operator!=(const duration<_Rep1, _Period1> &__lhs,
const duration<_Rep2, _Period2> &__rhs) {
return !(__lhs == __rhs);
}
template <typename _Rep1, typename _Period1, typename _Rep2,
typename _Period2>
constexpr bool operator<=(const duration<_Rep1, _Period1> &__lhs,
const duration<_Rep2, _Period2> &__rhs) {
return !(__rhs < __lhs);
}
template <typename _Rep1, typename _Period1, typename _Rep2,
typename _Period2>
constexpr bool operator>(const duration<_Rep1, _Period1> &__lhs,
const duration<_Rep2, _Period2> &__rhs) {
return __rhs < __lhs;
}
template <typename _Rep1, typename _Period1, typename _Rep2,
typename _Period2>
constexpr bool operator>=(const duration<_Rep1, _Period1> &__lhs,
const duration<_Rep2, _Period2> &__rhs) {
return !(__lhs < __rhs);
}
typedef duration<int64_t, nano> nanoseconds;
typedef duration<int64_t, micro> microseconds;
typedef duration<int64_t, milli> milliseconds;
typedef duration<int64_t> seconds;
typedef duration<int64_t, ratio<60> > minutes;
typedef duration<int64_t, ratio<3600> > hours;
template <typename _Clock, typename _Dur> struct time_point {
typedef _Clock clock;
typedef _Dur duration;
typedef typename duration::rep rep;
typedef typename duration::period period;
constexpr time_point() : __d(duration::zero()) {}
constexpr explicit time_point(const duration &__dur) : __d(__dur) {}
template <typename _Dur2>
constexpr time_point(const time_point<clock, _Dur2> &__t)
: __d(__t.time_since_epoch()) {}
constexpr duration time_since_epoch() const { return __d; }
time_point &operator+=(const duration &__dur) {
__d += __dur;
return *this;
}
time_point &operator-=(const duration &__dur) {
__d -= __dur;
return *this;
}
static constexpr time_point min() { return time_point(duration::min()); }
static constexpr time_point max() { return time_point(duration::max()); }
private:
duration __d;
};
template <typename _ToDur, typename _Clock, typename _Dur>
constexpr typename enable_if<__is_duration<_ToDur>::value,
time_point<_Clock, _ToDur> >::type
time_point_cast(const time_point<_Clock, _Dur> &__t) {
typedef time_point<_Clock, _ToDur> __time_point;
return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
}
template <typename _Clock, typename _Dur1, typename _Rep2, typename _Period2>
constexpr time_point<
_Clock, typename common_type<_Dur1, duration<_Rep2, _Period2> >::type>
operator+(const time_point<_Clock, _Dur1> &__lhs,
const duration<_Rep2, _Period2> &__rhs) {
typedef duration<_Rep2, _Period2> __dur2;
typedef typename common_type<_Dur1, __dur2>::type __ct;
typedef time_point<_Clock, __ct> __time_point;
return __time_point(__lhs.time_since_epoch() + __rhs);
}
template <typename _Rep1, typename _Period1, typename _Clock, typename _Dur2>
constexpr time_point<
_Clock, typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
operator+(const duration<_Rep1, _Period1> &__lhs,
const time_point<_Clock, _Dur2> &__rhs) {
typedef duration<_Rep1, _Period1> __dur1;
typedef typename common_type<__dur1, _Dur2>::type __ct;
typedef time_point<_Clock, __ct> __time_point;
return __time_point(__rhs.time_since_epoch() + __lhs);
}
template <typename _Clock, typename _Dur1, typename _Rep2, typename _Period2>
constexpr time_point<
_Clock, typename common_type<_Dur1, duration<_Rep2, _Period2> >::type>
operator-(const time_point<_Clock, _Dur1> &__lhs,
const duration<_Rep2, _Period2> &__rhs) {
typedef duration<_Rep2, _Period2> __dur2;
typedef typename common_type<_Dur1, __dur2>::type __ct;
typedef time_point<_Clock, __ct> __time_point;
return __time_point(__lhs.time_since_epoch() - __rhs);
}
template <typename _Clock, typename _Dur1, typename _Dur2>
constexpr typename common_type<_Dur1, _Dur2>::type
operator-(const time_point<_Clock, _Dur1> &__lhs,
const time_point<_Clock, _Dur2> &__rhs) {
return __lhs.time_since_epoch() - __rhs.time_since_epoch();
}
template <typename _Clock, typename _Dur1, typename _Dur2>
constexpr bool operator==(const time_point<_Clock, _Dur1> &__lhs,
const time_point<_Clock, _Dur2> &__rhs) {
return __lhs.time_since_epoch() == __rhs.time_since_epoch();
}
template <typename _Clock, typename _Dur1, typename _Dur2>
constexpr bool operator!=(const time_point<_Clock, _Dur1> &__lhs,
const time_point<_Clock, _Dur2> &__rhs) {
return !(__lhs == __rhs);
}
template <typename _Clock, typename _Dur1, typename _Dur2>
constexpr bool operator<(const time_point<_Clock, _Dur1> &__lhs,
const time_point<_Clock, _Dur2> &__rhs) {
return __lhs.time_since_epoch() < __rhs.time_since_epoch();
}
template <typename _Clock, typename _Dur1, typename _Dur2>
constexpr bool operator<=(const time_point<_Clock, _Dur1> &__lhs,
const time_point<_Clock, _Dur2> &__rhs) {
return !(__rhs < __lhs);
}
template <typename _Clock, typename _Dur1, typename _Dur2>
constexpr bool operator>(const time_point<_Clock, _Dur1> &__lhs,
const time_point<_Clock, _Dur2> &__rhs) {
return __rhs < __lhs;
}
template <typename _Clock, typename _Dur1, typename _Dur2>
constexpr bool operator>=(const time_point<_Clock, _Dur1> &__lhs,
const time_point<_Clock, _Dur2> &__rhs) {
return !(__lhs < __rhs);
}
# 709 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/chrono" 3
inline namespace _V2 {
struct system_clock {
typedef chrono::nanoseconds duration;
typedef duration::rep rep;
typedef duration::period period;
typedef chrono::time_point<system_clock, duration> time_point;
static_assert(system_clock::duration::min() <
system_clock::duration::zero(),
"a clock's minimum duration cannot be less than its epoch");
static constexpr bool is_steady = false;
static time_point now() noexcept;
static std::time_t to_time_t(const time_point &__t) noexcept {
return std::time_t(
duration_cast<chrono::seconds>(__t.time_since_epoch()).count());
}
static time_point from_time_t(std::time_t __t) noexcept {
typedef chrono::time_point<system_clock, seconds> __from;
return time_point_cast<system_clock::duration>(
__from(chrono::seconds(__t)));
}
};
struct steady_clock {
typedef chrono::nanoseconds duration;
typedef duration::rep rep;
typedef duration::period period;
typedef chrono::time_point<steady_clock, duration> time_point;
static constexpr bool is_steady = true;
static time_point now() noexcept;
};
# 776 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/chrono" 3
using high_resolution_clock = system_clock;
}
}
# 908 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/chrono" 3
}
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/mutex" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/system_error" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/system_error" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/error_constants.h" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/error_constants.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cerrno" 1 3
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cerrno" 3
# 1 "/usr/include/errno.h" 1 3 4
# 42 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cerrno" 2 3
# 35 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/error_constants.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
enum class errc {
address_family_not_supported = 47,
address_in_use = 48,
address_not_available = 49,
already_connected = 56,
argument_list_too_long = 7,
argument_out_of_domain = 33,
bad_address = 14,
bad_file_descriptor = 9,
bad_message = 94,
broken_pipe = 32,
connection_aborted = 53,
connection_already_in_progress = 37,
connection_refused = 61,
connection_reset = 54,
cross_device_link = 18,
destination_address_required = 39,
device_or_resource_busy = 16,
directory_not_empty = 66,
executable_format_error = 8,
file_exists = 17,
file_too_large = 27,
filename_too_long = 63,
function_not_supported = 78,
host_unreachable = 65,
identifier_removed = 90,
illegal_byte_sequence = 92,
inappropriate_io_control_operation = 25,
interrupted = 4,
invalid_argument = 22,
invalid_seek = 29,
io_error = 5,
is_a_directory = 21,
message_size = 40,
network_down = 50,
network_reset = 52,
network_unreachable = 51,
no_buffer_space = 55,
no_child_process = 10,
no_link = 97,
no_lock_available = 77,
no_message_available = 96,
no_message = 91,
no_protocol_option = 42,
no_space_on_device = 28,
no_stream_resources = 98,
no_such_device_or_address = 6,
no_such_device = 19,
no_such_file_or_directory = 2,
no_such_process = 3,
not_a_directory = 20,
not_a_socket = 38,
not_a_stream = 99,
not_connected = 57,
not_enough_memory = 12,
not_supported = 45,
operation_canceled = 89,
operation_in_progress = 36,
operation_not_permitted = 1,
operation_not_supported = 102,
operation_would_block = 35,
owner_dead = 105,
permission_denied = 13,
protocol_error = 100,
protocol_not_supported = 43,
read_only_file_system = 30,
resource_deadlock_would_occur = 11,
resource_unavailable_try_again = 35,
result_out_of_range = 34,
state_not_recoverable = 104,
stream_timeout = 101,
text_file_busy = 26,
timed_out = 60,
too_many_files_open_in_system = 23,
too_many_files_open = 24,
too_many_links = 31,
too_many_symbolic_link_levels = 62,
value_too_large = 84,
wrong_protocol_type = 41
};
}
# 40 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/system_error" 2 3
namespace std __attribute__((__visibility__("default"))) {
class error_code;
class error_condition;
class error_category;
class system_error;
template <typename _Tp> struct is_error_code_enum : public false_type {};
template <typename _Tp> struct is_error_condition_enum : public false_type {};
template <> struct is_error_condition_enum<errc> : public true_type {};
class error_category {
public:
constexpr error_category() noexcept = default;
virtual ~error_category();
error_category(const error_category &) = delete;
error_category &operator=(const error_category &) = delete;
virtual const char *name() const noexcept = 0;
virtual string message(int) const = 0;
virtual error_condition default_error_condition(int __i) const noexcept;
virtual bool equivalent(int __i, const error_condition &__cond) const
noexcept;
virtual bool equivalent(const error_code &__code, int __i) const noexcept;
bool operator<(const error_category &__other) const noexcept {
return less<const error_category *>()(this, &__other);
}
bool operator==(const error_category &__other) const noexcept {
return this == &__other;
}
bool operator!=(const error_category &__other) const noexcept {
return this != &__other;
}
};
__attribute__((__const__)) const error_category & system_category() noexcept;
__attribute__((__const__)) const error_category & generic_category() noexcept;
error_code make_error_code(errc) noexcept;
template <typename _Tp> struct hash;
struct error_code {
error_code() noexcept : _M_value(0), _M_cat(&system_category()) {}
error_code(int __v, const error_category &__cat) noexcept : _M_value(__v),
_M_cat(&__cat) {
}
template <typename _ErrorCodeEnum,
typename = typename enable_if<
is_error_code_enum<_ErrorCodeEnum>::value>::type>
error_code(_ErrorCodeEnum __e) noexcept {
*this = make_error_code(__e);
}
void assign(int __v, const error_category &__cat) noexcept {
_M_value = __v;
_M_cat = &__cat;
}
void clear() noexcept { assign(0, system_category()); }
template <typename _ErrorCodeEnum>
typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value,
error_code &>::type
operator=(_ErrorCodeEnum __e) noexcept {
return *this = make_error_code(__e);
}
int value() const noexcept { return _M_value; }
const error_category &category() const noexcept { return *_M_cat; }
error_condition default_error_condition() const noexcept;
string message() const { return category().message(value()); }
explicit operator bool() const noexcept {
return _M_value != 0 ? true : false;
}
private:
friend class hash<error_code>;
int _M_value;
const error_category *_M_cat;
};
inline error_code make_error_code(errc __e) noexcept {
return error_code(static_cast<int>(__e), generic_category());
}
inline bool operator<(const error_code & __lhs,
const error_code & __rhs) noexcept {
return (__lhs.category() < __rhs.category() ||
(__lhs.category() == __rhs.category() &&
__lhs.value() < __rhs.value()));
}
template <typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &operator<<(
basic_ostream<_CharT, _Traits> & __os, const error_code & __e) {
return (__os << __e.category().name() << ':' << __e.value());
}
error_condition make_error_condition(errc) noexcept;
struct error_condition {
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment