karellen-llvm-core 22.1.0rc1.post26__py3-none-manylinux_2_28_x86_64.whl

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/random.inc

@@ -0,0 +1,115 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [rand.req.urng], uniform random bit generator requirements
+  using std::uniform_random_bit_generator;
+
+  // [rand.eng.lcong], class template linear_congruential_engine
+  using std::linear_congruential_engine;
+
+  // [rand.eng.mers], class template mersenne_twister_engine
+  using std::mersenne_twister_engine;
+
+  // [rand.eng.sub], class template subtract_with_carry_engine
+  using std::subtract_with_carry_engine;
+
+  // [rand.adapt.disc], class template discard_block_engine
+  using std::discard_block_engine;
+
+  // [rand.adapt.ibits], class template independent_bits_engine
+  using std::independent_bits_engine;
+
+  // [rand.adapt.shuf], class template shuffle_order_engine
+  using std::shuffle_order_engine;
+
+  // [rand.predef], engines and engine adaptors with predefined parameters
+  using std::knuth_b;
+  using std::minstd_rand;
+  using std::minstd_rand0;
+  using std::mt19937;
+  using std::mt19937_64;
+  using std::ranlux24;
+  using std::ranlux24_base;
+  using std::ranlux48;
+  using std::ranlux48_base;
+
+  using std::default_random_engine;
+
+#if _LIBCPP_HAS_RANDOM_DEVICE
+  // [rand.device], class random_device
+  using std::random_device;
+#endif
+
+  // [rand.util.seedseq], class seed_seq
+  using std::seed_seq;
+
+  // [rand.util.canonical], function template generate_canonical
+  using std::generate_canonical;
+
+  // [rand.dist.uni.int], class template uniform_int_distribution
+  using std::uniform_int_distribution;
+
+  // [rand.dist.uni.real], class template uniform_real_distribution
+  using std::uniform_real_distribution;
+
+  // [rand.dist.bern.bernoulli], class bernoulli_distribution
+  using std::bernoulli_distribution;
+
+  // [rand.dist.bern.bin], class template binomial_distribution
+  using std::binomial_distribution;
+
+  // [rand.dist.bern.geo], class template geometric_distribution
+  using std::geometric_distribution;
+
+  // [rand.dist.bern.negbin], class template negative_binomial_distribution
+  using std::negative_binomial_distribution;
+
+  // [rand.dist.pois.poisson], class template poisson_distribution
+  using std::poisson_distribution;
+
+  // [rand.dist.pois.exp], class template exponential_distribution
+  using std::exponential_distribution;
+
+  // [rand.dist.pois.gamma], class template gamma_distribution
+  using std::gamma_distribution;
+
+  // [rand.dist.pois.weibull], class template weibull_distribution
+  using std::weibull_distribution;
+
+  // [rand.dist.pois.extreme], class template extreme_value_distribution
+  using std::extreme_value_distribution;
+
+  // [rand.dist.norm.normal], class template normal_distribution
+  using std::normal_distribution;
+
+  // [rand.dist.norm.lognormal], class template lognormal_distribution
+  using std::lognormal_distribution;
+
+  // [rand.dist.norm.chisq], class template chi_squared_distribution
+  using std::chi_squared_distribution;
+
+  // [rand.dist.norm.cauchy], class template cauchy_distribution
+  using std::cauchy_distribution;
+
+  // [rand.dist.norm.f], class template fisher_f_distribution
+  using std::fisher_f_distribution;
+
+  // [rand.dist.norm.t], class template student_t_distribution
+  using std::student_t_distribution;
+
+  // [rand.dist.samp.discrete], class template discrete_distribution
+  using std::discrete_distribution;
+
+  // [rand.dist.samp.pconst], class template piecewise_constant_distribution
+  using std::piecewise_constant_distribution;
+
+  // [rand.dist.samp.plinear], class template piecewise_linear_distribution
+  using std::piecewise_linear_distribution;
+} // namespace std

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/ranges.inc

@@ -0,0 +1,370 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  namespace ranges {
+    inline namespace __cpo {
+      // [range.access], range access
+      using std::ranges::__cpo::begin;
+      using std::ranges::__cpo::cbegin;
+      using std::ranges::__cpo::cend;
+      using std::ranges::__cpo::crbegin;
+      using std::ranges::__cpo::crend;
+      using std::ranges::__cpo::end;
+      using std::ranges::__cpo::rbegin;
+      using std::ranges::__cpo::rend;
+
+      using std::ranges::__cpo::cdata;
+      using std::ranges::__cpo::data;
+      using std::ranges::__cpo::empty;
+      using std::ranges::__cpo::size;
+      using std::ranges::__cpo::ssize;
+    } // namespace __cpo
+
+    // [range.range], ranges
+    using std::ranges::range;
+
+    using std::ranges::enable_borrowed_range;
+
+    using std::ranges::borrowed_range;
+
+    // using std::ranges::const_iterator_t;
+    // using std::ranges::const_sentinel_t;
+    using std::ranges::iterator_t;
+    // using std::ranges::range_const_reference_t;
+    using std::ranges::range_common_reference_t;
+    using std::ranges::range_difference_t;
+    using std::ranges::range_reference_t;
+    using std::ranges::range_rvalue_reference_t;
+    using std::ranges::range_size_t;
+    using std::ranges::range_value_t;
+    using std::ranges::sentinel_t;
+
+    // [range.sized], sized ranges
+    using std::ranges::disable_sized_range;
+    using std::ranges::sized_range;
+
+    // [range.view], views
+    using std::ranges::enable_view;
+    using std::ranges::view;
+    using std::ranges::view_base;
+
+    // [range.refinements], other range refinements
+    using std::ranges::bidirectional_range;
+    using std::ranges::common_range;
+    // using std::ranges::constant_range;
+    using std::ranges::contiguous_range;
+    using std::ranges::forward_range;
+    using std::ranges::input_range;
+    using std::ranges::output_range;
+    using std::ranges::random_access_range;
+    using std::ranges::viewable_range;
+
+    // [view.interface], class template view_­interface
+    using std::ranges::view_interface;
+
+    // [range.subrange], sub-ranges
+    using std::ranges::subrange;
+    using std::ranges::subrange_kind;
+
+    using std::ranges::get;
+  } // namespace ranges
+
+  using std::ranges::get;
+
+  namespace ranges {
+
+    // [range.dangling], dangling iterator handling
+    using std::ranges::dangling;
+
+#if _LIBCPP_STD_VER >= 23
+    // [range.elementsof], class template elements_­of
+    using std::ranges::elements_of;
+#endif
+
+    using std::ranges::borrowed_iterator_t;
+
+    using std::ranges::borrowed_subrange_t;
+
+#if _LIBCPP_STD_VER >= 23
+    // [range.utility.conv], range conversions
+    using std::ranges::to;
+#endif
+
+    // [range.empty], empty view
+    using std::ranges::empty_view;
+
+    namespace views {
+      using std::ranges::views::empty;
+    }
+
+    // [range.single], single view
+    using std::ranges::single_view;
+
+    namespace views {
+      using std::ranges::views::single;
+    } // namespace views
+
+    // [range.iota], iota view
+    using std::ranges::iota_view;
+
+    namespace views {
+      using std::ranges::views::iota;
+#if _LIBCPP_STD_VER >= 26
+      using std::ranges::views::indices;
+#endif
+    } // namespace views
+
+#if _LIBCPP_STD_VER >= 23
+    // [range.repeat], repeat view
+    using std::ranges::repeat_view;
+
+    namespace views {
+      using std::ranges::views::repeat;
+    } // namespace views
+#endif // _LIBCPP_STD_VER >= 23
+
+#if _LIBCPP_HAS_LOCALIZATION
+    // [range.istream], istream view
+    using std::ranges::basic_istream_view;
+    using std::ranges::istream_view;
+#  if _LIBCPP_HAS_WIDE_CHARACTERS
+    using std::ranges::wistream_view;
+#  endif
+
+    namespace views {
+      using std::ranges::views::istream;
+    }
+#endif // _LIBCPP_HAS_LOCALIZATION
+
+    // Note: This declaration not in the synopsis or explicitly in the wording.
+    // However it is needed for the range adaptors.
+    // [range.adaptor.object]/3
+    //   The template parameter D for range_adaptor_closure may be an
+    //   incomplete type. If an expression of type cv D is used as an operand
+    //   to the | operator, D shall be complete and model
+    //   derived_from<range_adaptor_closure<D>>. The behavior of an expression
+    //   involving an object of type cv D as an operand to the | operator is
+    //   undefined if overload resolution selects a program-defined operator|
+    //   function.
+    // This is used internally in C++20 mode.
+    using std::ranges::operator|;
+#if _LIBCPP_STD_VER >= 23
+    // [range.adaptor.object], range adaptor objects
+    using std::ranges::range_adaptor_closure;
+#endif
+
+    // [range.all], all view
+    namespace views {
+      using std::ranges::views::all;
+      using std::ranges::views::all_t;
+    } // namespace views
+
+    // [range.ref.view], ref view
+    using std::ranges::ref_view;
+
+    // [range.owning.view], owning view
+    using std::ranges::owning_view;
+
+#if _LIBCPP_STD_VER >= 23
+    // [range.as.rvalue], as rvalue view
+    using std::ranges::as_rvalue_view;
+
+    namespace views {
+      using std::ranges::views::as_rvalue;
+    } // namespace views
+#endif // _LIBCPP_STD_VER >= 23
+
+    // [range.filter], filter view
+    using std::ranges::filter_view;
+
+    namespace views {
+      using std::ranges::views::filter;
+    } // namespace views
+
+    // [range.transform], transform view
+    using std::ranges::transform_view;
+
+    namespace views {
+      using std::ranges::views::transform;
+    } // namespace views
+
+    // [range.take], take view
+    using std::ranges::take_view;
+
+    namespace views {
+      using std::ranges::views::take;
+    } // namespace views
+
+    // [range.take.while], take while view
+    using std::ranges::take_while_view;
+
+    namespace views {
+      using std::ranges::views::take_while;
+    } // namespace views
+
+    // [range.drop], drop view
+    using std::ranges::drop_view;
+
+    namespace views {
+      using std::ranges::views::drop;
+    } // namespace views
+
+    // [range.drop.while], drop while view
+    using std::ranges::drop_while_view;
+
+    namespace views {
+      using std::ranges::views::drop_while;
+    } // namespace views
+
+    using std::ranges::join_view;
+
+    namespace views {
+      using std::ranges::views::join;
+    } // namespace views
+
+#if _LIBCPP_STD_VER >= 23
+    // [range.join.with]
+    using std::ranges::join_with_view;
+
+    namespace views {
+      using std::ranges::views::join_with;
+    } // namespace views
+#endif // _LIBCPP_STD_VER >= 23
+
+    using std::ranges::lazy_split_view;
+
+    // [range.split], split view
+    using std::ranges::split_view;
+
+    namespace views {
+      using std::ranges::views::lazy_split;
+      using std::ranges::views::split;
+    } // namespace views
+
+    // [range.counted], counted view
+    namespace views {
+      using std::ranges::views::counted;
+    } // namespace views
+
+    // [range.common], common view
+    using std::ranges::common_view;
+
+    namespace views {
+      using std::ranges::views::common;
+    } // namespace views
+
+    // [range.reverse], reverse view
+    using std::ranges::reverse_view;
+
+    namespace views {
+      using std::ranges::views::reverse;
+    } // namespace views
+
+    // [range.as.const], as const view
+#if 0
+    using std::ranges::as_const_view;
+
+    namespace views {
+      using std::ranges::views::as_const;
+    } // namespace views
+#endif
+    // [range.elements], elements view
+    using std::ranges::elements_view;
+
+    using std::ranges::keys_view;
+    using std::ranges::values_view;
+
+    namespace views {
+      using std::ranges::views::elements;
+      using std::ranges::views::keys;
+      using std::ranges::views::values;
+    } // namespace views
+
+#if _LIBCPP_STD_VER >= 23
+    // [range.zip], zip view
+    using std::ranges::zip_view;
+
+    namespace views {
+      using std::ranges::views::zip;
+    } // namespace views
+
+    // [range.zip.transform], zip transform view
+    using std::ranges::zip_transform_view;
+
+    namespace views {
+      using std::ranges::views::zip_transform;
+    }
+    using std::ranges::adjacent_view;
+
+    namespace views {
+      using std::ranges::views::adjacent;
+      using std::ranges::views::pairwise;
+    } // namespace views
+
+    using std::ranges::adjacent_transform_view;
+
+    namespace views {
+      using std::ranges::views::adjacent_transform;
+      using std::ranges::views::pairwise_transform;
+    } // namespace views
+
+#endif // _LIBCPP_STD_VER >= 23
+
+#if 0
+    using std::ranges::chunk_view;
+
+    using std::ranges::chunk_view<V>;
+
+    namespace views {
+      using std::ranges::views::chunk;
+    }
+
+    using std::ranges::slide_view;
+
+    namespace views {
+      using std::ranges::views::slide;
+    }
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+    // [range.chunk.by], chunk by view
+    using std::ranges::chunk_by_view;
+
+    namespace views {
+      using std::ranges::views::chunk_by;
+    }
+#endif // _LIBCPP_STD_VER >= 23
+
+#if 0
+    // [range.stride], stride view
+    using std::ranges::stride_view;
+
+    namespace views {
+      using std::ranges::views::stride;
+    }
+
+    using std::ranges::cartesian_product_view;
+
+    namespace views {
+      using std::ranges::views::cartesian_product;
+    }
+#endif
+  } // namespace ranges
+
+  namespace views = ranges::views;
+
+  using std::tuple_element;
+  using std::tuple_size;
+
+#if _LIBCPP_STD_VER >= 23
+  using std::from_range;
+  using std::from_range_t;
+#endif // _LIBCPP_STD_VER >= 23
+} // namespace std

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/ratio.inc

@@ -0,0 +1,58 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [ratio.ratio], class template ratio
+  using std::ratio;
+
+  // [ratio.arithmetic], ratio arithmetic
+  using std::ratio_add;
+  using std::ratio_divide;
+  using std::ratio_multiply;
+  using std::ratio_subtract;
+
+  // [ratio.comparison], ratio comparison
+  using std::ratio_equal;
+  using std::ratio_greater;
+  using std::ratio_greater_equal;
+  using std::ratio_less;
+  using std::ratio_less_equal;
+  using std::ratio_not_equal;
+
+  using std::ratio_equal_v;
+  using std::ratio_greater_equal_v;
+  using std::ratio_greater_v;
+  using std::ratio_less_equal_v;
+  using std::ratio_less_v;
+  using std::ratio_not_equal_v;
+
+  // [ratio.si], convenience SI typedefs
+  using std::atto;
+  using std::centi;
+  using std::deca;
+  using std::deci;
+  using std::exa;
+  using std::femto;
+  using std::giga;
+  using std::hecto;
+  using std::kilo;
+  using std::mega;
+  using std::micro;
+  using std::milli;
+  using std::nano;
+  using std::peta;
+  using std::pico;
+  using std::tera;
+
+  // These are not supported by libc++, due to the range of intmax_t
+  // using std::yocto;
+  // using std::yotta;
+  // using std::zepto;
+  // using std::zetta
+} // namespace std

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/rcu.inc

@@ -0,0 +1,22 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#if 0
+#  if _LIBCPP_STD_VER >= 23
+  // 2.2.3, class template rcu_obj_base using std::rcu_obj_base;
+  // 2.2.4, class rcu_domain
+  using std::rcu_domain;
+  using std::rcu_default_domain();
+  using std::rcu_barrier;
+  using std::rcu_retire;
+  using std::rcu_synchronize;
+#  endif // _LIBCPP_STD_VER >= 23
+#endif
+} // namespace std

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/regex.inc

@@ -0,0 +1,117 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#if _LIBCPP_HAS_LOCALIZATION
+  // [re.const], regex constants
+  namespace regex_constants {
+    using std::regex_constants::error_type;
+    using std::regex_constants::match_flag_type;
+    using std::regex_constants::syntax_option_type;
+
+    // regex_constants is a bitmask type.
+    // [bitmask.types] specified operators
+    using std::regex_constants::operator&;
+    using std::regex_constants::operator&=;
+    using std::regex_constants::operator^;
+    using std::regex_constants::operator^=;
+    using std::regex_constants::operator|;
+    using std::regex_constants::operator|=;
+    using std::regex_constants::operator~;
+
+  } // namespace regex_constants
+
+  // [re.badexp], class regex_error
+  using std::regex_error;
+
+  // [re.traits], class template regex_traits
+  using std::regex_traits;
+
+  // [re.regex], class template basic_regex
+  using std::basic_regex;
+
+  using std::regex;
+#  if _LIBCPP_HAS_WIDE_CHARACTERS
+  using std::wregex;
+#  endif
+
+  // [re.regex.swap], basic_regex swap
+  using std::swap;
+
+  // [re.submatch], class template sub_match
+  using std::sub_match;
+
+  using std::csub_match;
+  using std::ssub_match;
+#  if _LIBCPP_HAS_WIDE_CHARACTERS
+  using std::wcsub_match;
+  using std::wssub_match;
+#  endif
+
+  // [re.submatch.op], sub_match non-member operators
+  using std::operator==;
+  using std::operator<=>;
+
+  using std::operator<<;
+
+  // [re.results], class template match_results
+  using std::match_results;
+
+  using std::cmatch;
+  using std::smatch;
+#  if _LIBCPP_HAS_WIDE_CHARACTERS
+  using std::wcmatch;
+  using std::wsmatch;
+#  endif
+
+  // match_results comparisons
+
+  // [re.results.swap], match_results swap
+
+  // [re.alg.match], function template regex_match
+  using std::regex_match;
+
+  // [re.alg.search], function template regex_search
+  using std::regex_search;
+
+  // [re.alg.replace], function template regex_replace
+  using std::regex_replace;
+
+  // [re.regiter], class template regex_iterator
+  using std::regex_iterator;
+
+  using std::cregex_iterator;
+  using std::sregex_iterator;
+#  if _LIBCPP_HAS_WIDE_CHARACTERS
+  using std::wcregex_iterator;
+  using std::wsregex_iterator;
+#  endif
+
+  // [re.tokiter], class template regex_token_iterator
+  using std::regex_token_iterator;
+
+  using std::cregex_token_iterator;
+  using std::sregex_token_iterator;
+#  if _LIBCPP_HAS_WIDE_CHARACTERS
+  using std::wcregex_token_iterator;
+  using std::wsregex_token_iterator;
+#  endif
+
+  namespace pmr {
+    using std::pmr::match_results;
+
+    using std::pmr::cmatch;
+    using std::pmr::smatch;
+#  if _LIBCPP_HAS_WIDE_CHARACTERS
+    using std::pmr::wcmatch;
+    using std::pmr::wsmatch;
+#  endif
+  }    // namespace pmr
+#endif // _LIBCPP_HAS_LOCALIZATION
+} // namespace std

karellen_llvm_core-22.1.0rc1.post26.data/data/share/libc++/v1/std/scoped_allocator.inc

@@ -0,0 +1,17 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // class template scoped_allocator_adaptor
+  using std::scoped_allocator_adaptor;
+
+  // [scoped.adaptor.operators], scoped allocator operators
+  using std::operator==;
+
+} // namespace std