From nobody Sat Jun 22 17:54:05 2024 X-Original-To: dev-commits-ports-all@mlmmj.nyi.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mlmmj.nyi.freebsd.org (Postfix) with ESMTP id 4W620Y3czSz5NpHR; Sat, 22 Jun 2024 17:54:05 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from mxrelay.nyi.freebsd.org (mxrelay.nyi.freebsd.org [IPv6:2610:1c1:1:606c::19:3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256 client-signature RSA-PSS (4096 bits) client-digest SHA256) (Client CN "mxrelay.nyi.freebsd.org", Issuer "R3" (verified OK)) by mx1.freebsd.org (Postfix) with ESMTPS id 4W620Y3Dz3z44XJ; Sat, 22 Jun 2024 17:54:05 +0000 (UTC) (envelope-from git@FreeBSD.org) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1719078845; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=7j+ctwBnuHIdcwpocS8mcNtFZa8sQ1NDN/OfQ+qnEcA=; b=O0QZlof6wcuQAXu3G4vR1W66pwrzOWjWK7saxdOTYJpQcI8jpUQw5foh32eaAE6FOGdW9/ +GhHq1QUa0Fv4JHmaBhNE9hYD0sEjlFl/NmMqpj7k5f4/r/lb4kQJhbL1EAVhK9ivK9Uys gmXSMfz154q1oHZjYXCTqphURlzk9oqVgxj/UUdyZn0LUOxzA8KDMN0IaqHJ47tCiUY5VC b71r0EBpHV3r2BZrxRAxrdyspeimCT6uwGGxgjGW9SxDt2iz8YS6j7X2kP3Z/3vh/gKCtb zmrN4lXUE+ytTL624avFt65UOuGRFQX82H6PB8gwmYUyyhwHkIsF/2zbf1QWcQ== ARC-Seal: i=1; s=dkim; d=freebsd.org; t=1719078845; a=rsa-sha256; cv=none; b=UfDKxzdSxmmsi4WAUv9Zj8AiutPawsyaWNUfYOphAjHEUNU1er34JW2eKKHo4mM++occad SSHfKQZ5CRr99T5raI90fsxWk2rqpwn0iGnjz/2+5R23uD3g3W+8YdwPz8n/bjRFkHRLte 6GF/JkZyBR0q0ebs1NJRVQb5DarMlJGIgIbh8hjQ0RFrrAGELiqVfLorBYEg2vDU4o6mMG Ar/2yoxdmt7K1jglGKpLphxqmJaUCgclgO+BrVn+BRqrzNTZNWWSoC0uUETlZnbOFZGxNP DF28W4uIt7dMkAct6Oy3ZkAio3ZLJXRnk025IjENkUwry97gOaYkyEdAzAIqdg== ARC-Authentication-Results: i=1; mx1.freebsd.org; none ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1719078845; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=7j+ctwBnuHIdcwpocS8mcNtFZa8sQ1NDN/OfQ+qnEcA=; b=IkJk36Uns7QgdZdiqZUe6x4mj/1/a2uS0nwaZvuCtBmphYAxlhAQ8SJv0xqiKGBvez5LWe hcsAIyh/1TXidpqEJJl3vIBFgq9chykOXSZ9MdEuhkmYvbhXIfNyjr7XDmc54HRVtKKDqd /gnxwbSUUgkYP4+upSmG4Ci7UuIxHRZrQ13SvYhMzDqTg2AAfjuFo3DAAdJqo/dCcDFQ1O k2EJdan0rS2m0IIQk8OSRp2LFI2LocvnRXL6N8kmIf3kox9OteMILmALZhZWcCwX6/mjmZ kc5ze9NXRJ/9udNBWwkv40ZS+Srpuq1cGw5pD/vLtUgJ7GzOJGpy8Cp9g/VVcQ== Received: from gitrepo.freebsd.org (gitrepo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:5]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (Client did not present a certificate) by mxrelay.nyi.freebsd.org (Postfix) with ESMTPS id 4W620Y2qqLz11Ds; Sat, 22 Jun 2024 17:54:05 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from gitrepo.freebsd.org ([127.0.1.44]) by gitrepo.freebsd.org (8.17.1/8.17.1) with ESMTP id 45MHs5Gu032952; Sat, 22 Jun 2024 17:54:05 GMT (envelope-from git@gitrepo.freebsd.org) Received: (from git@localhost) by gitrepo.freebsd.org (8.17.1/8.17.1/Submit) id 45MHs59t032949; Sat, 22 Jun 2024 17:54:05 GMT (envelope-from git) Date: Sat, 22 Jun 2024 17:54:05 GMT Message-Id: <202406221754.45MHs59t032949@gitrepo.freebsd.org> To: ports-committers@FreeBSD.org, dev-commits-ports-all@FreeBSD.org, dev-commits-ports-branches@FreeBSD.org From: Nuno Teixeira Subject: git: 8a773bd047a3 - 2024Q2 - devel/root: Update to 6.30/06 List-Id: Commit messages for all branches of the ports repository List-Archive: https://lists.freebsd.org/archives/dev-commits-ports-all List-Help: List-Post: List-Subscribe: List-Unsubscribe: X-BeenThere: dev-commits-ports-all@freebsd.org Sender: owner-dev-commits-ports-all@FreeBSD.org MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Git-Committer: eduardo X-Git-Repository: ports X-Git-Refname: refs/heads/2024Q2 X-Git-Reftype: branch X-Git-Commit: 8a773bd047a39d17789480a87bf391c49b4c3e43 Auto-Submitted: auto-generated The branch 2024Q2 has been updated by eduardo: URL: https://cgit.FreeBSD.org/ports/commit/?id=8a773bd047a39d17789480a87bf391c49b4c3e43 commit 8a773bd047a39d17789480a87bf391c49b4c3e43 Author: Erik Jensen AuthorDate: 2024-05-18 10:26:06 +0000 Commit: Nuno Teixeira CommitDate: 2024-06-22 17:51:50 +0000 devel/root: Update to 6.30/06 ChangeLog: https://root.cern/doc/v630/release-notes.html#release-6.3006 PR: 278110 (cherry picked from commit a68970e0e109c1d1155851af8d2b2869522a1a68) --- devel/root/Makefile | 43 +- devel/root/distinfo | 6 +- ...ter-cling-include-cling-std__fbsd13.2.modulemap | 1097 ++++++++++ ...ter-cling-include-cling-std__fbsd13.3.modulemap | 2072 +++++++++++++++++++ ...ter-cling-include-cling-std__fbsd14.0.modulemap | 1729 ++++++++++++++++ ...ter-cling-include-cling-std__fbsd15.0.modulemap | 2087 ++++++++++++++++++++ .../files/patch-cmake_modules_SetUpFreeBSD.cmake | 12 + .../files/patch-core_clingutils_CMakeLists.txt | 23 + .../patch-core_clingutils_src_TClingUtils.cxx | 18 + devel/root/files/patch-interpreter_CMakeLists.txt | 4 +- ...interpreter_cling_lib_Interpreter_CIFactory.cpp | 14 + ...terpreter_cling_lib_Interpreter_Interpreter.cpp | 13 + ...m-project_clang_lib_Serialization_ASTWriter.cpp | 15 +- devel/root/pkg-plist | 12 +- 14 files changed, 7121 insertions(+), 24 deletions(-) diff --git a/devel/root/Makefile b/devel/root/Makefile index fb7f875369d5..e1782e634e92 100644 --- a/devel/root/Makefile +++ b/devel/root/Makefile @@ -1,6 +1,5 @@ PORTNAME= root -DISTVERSION= 6.30.02 -PORTREVISION= 1 +DISTVERSION= 6.30.06 CATEGORIES= devel science math parallel python MASTER_SITES= https://root.cern/download/ DISTFILES= ${PORTNAME}_v${DISTVERSION}.source${EXTRACT_SUFX} @@ -33,10 +32,26 @@ USES= cmake compiler:c++17-lang desktop-file-utils \ gnome iconv shebangfix ssl USE_GNOME= libxml2 -SHEBANG_FILES= config/rootssh etc/dictpch/makepch.py etc/proof/utils/circle.sh \ - etc/proof/utils/crypt etc/proof/utils/pps \ - etc/proof/utils/proofctl.sh etc/proof/utils/proofinstall.sh \ +SHEBANG_FILES= main/python/rootbrowse.py \ + main/python/rootcp.py \ + main/python/rootdrawtree.py \ + main/python/rooteventselector.py \ + main/python/rootls.py \ + main/python/rootmkdir.py \ + main/python/rootmv.py \ + main/python/rootprint.py \ + main/python/rootrm.py \ + main/python/rootslimtree.py \ + config/rootssh \ + etc/dictpch/makepch.py \ + etc/proof/utils/circle.sh \ + etc/proof/utils/crypt \ + etc/proof/utils/pps \ + etc/proof/utils/proofctl.sh \ + etc/proof/utils/proofinstall.sh \ etc/pdg_table_update.py +# add a port-specific shebang to be replaced +python_OLD_CMD+= "/usr/bin/env @python@" # Flags and environment variables for building CMAKE_ARGS= -DCMAKE_CXX_STANDARD=17 @@ -52,6 +67,7 @@ OPTIONS_SUB= yes # Option: MYSQL MYSQL_DESC= Enable MySQL bindings +MYSQL_LIB_DEPENDS= libunwind.so:devel/libunwind MYSQL_USES= mysql MYSQL_CMAKE_BOOL= mysql @@ -95,12 +111,27 @@ PLIST_SUB+= SHLIB_SHVER="${DISTVERSION:R}" \ SHLIB_VER="${DISTVERSION}" # Some .modulemap, .pcm and .idx files are not installed on aarch64, a few .pcm files are exclusive to aarch64 and files LIBRARY.pcm are renamed libLIBRARY_rdict.pcm on aarch64 -.if ${ARCH} == "aarch64" +.if ${OPSYS} == FreeBSD && ${ARCH} == "aarch64" PLIST_SUB+= NOT_INSTALLED_ON_AARCH64="@comment " ONLY_INSTALLED_ON_AARCH64="" AARCH64_PCM_PREFIX="lib" AARCH64_PCM_SUFFIX="_rdict" .else PLIST_SUB+= NOT_INSTALLED_ON_AARCH64="" ONLY_INSTALLED_ON_AARCH64="@comment " AARCH64_PCM_PREFIX="" AARCH64_PCM_SUFFIX="" .endif +# std_config.pcm exclusive to FreeBSD 14 +.if ${OPSYS} == FreeBSD && (1400000 <= ${OSVERSION} && ${OSVERSION} < 1500000) +PLIST_SUB+= ONLY_INSTALLED_ON_FBSD14="" +.else +PLIST_SUB+= ONLY_INSTALLED_ON_FBSD14="@comment " +.endif + +# Port patch removes implicit use of system's module.modulemap and applies +# explicit use of the same module.modulemap, with modifications, provided +# by the port +post-patch: + ${CP} \ + ${PATCHDIR}/interpreter-cling-include-cling-std__fbsd${OSREL}.modulemap \ + ${WRKSRC}/interpreter/cling/include/cling/std_fbsd.modulemap + # The following two files should not be staged. This happens even when PYROOT option is OFF. post-install: ${RM} ${STAGEDIR}${PREFIX}/lib/root/__pycache__/cmdLineUtils.cpython-39.pyc diff --git a/devel/root/distinfo b/devel/root/distinfo index e5b446340bd5..3e92c81d97ac 100644 --- a/devel/root/distinfo +++ b/devel/root/distinfo @@ -1,3 +1,3 @@ -TIMESTAMP = 1702064317 -SHA256 (root_v6.30.02.source.tar.gz) = 7965a456d1ad1ee0d5fe4769bf5a8fec291af684ed93db0f3080a9c362435183 -SIZE (root_v6.30.02.source.tar.gz) = 184758362 +TIMESTAMP = 1712945107 +SHA256 (root_v6.30.06.source.tar.gz) = 300db7ed1b678ed2fb9635ca675921a1945c7c2103da840033b493091f55700c +SIZE (root_v6.30.06.source.tar.gz) = 184791201 diff --git a/devel/root/files/interpreter-cling-include-cling-std__fbsd13.2.modulemap b/devel/root/files/interpreter-cling-include-cling-std__fbsd13.2.modulemap new file mode 100644 index 000000000000..e2b828a18fe1 --- /dev/null +++ b/devel/root/files/interpreter-cling-include-cling-std__fbsd13.2.modulemap @@ -0,0 +1,1097 @@ +// FreeBSD port maintainer note: +// Taken from +// https://github.com/freebsd/freebsd-src/blob/release/13.2.0/contrib/llvm-project/libcxx/include/module.modulemap +// on 2024-05-15. + +// define the module for __config outside of the top level 'std' module +// since __config may be included from C headers which may create an +// include cycle. +module std_config [system] [extern_c] { + textual header "__config" + textual header "__config_site" +} + +module std [system] { + export std_config + // FIXME: The standard does not require that each of these submodules + // re-exports its imported modules. We should provide an alternative form of + // export that issues a warning if a name from the submodule is used, and + // use that to provide a 'strict mode' for libc++. + + // Deprecated C-compatibility headers. These can all be included from within + // an 'extern "C"' context. + module depr [extern_c] { + // provided by C library. + module ctype_h { + header "ctype.h" + export * + } + module errno_h { + header "errno.h" + export * + } + module fenv_h { + header "fenv.h" + export * + } + // provided by compiler or C library. + module inttypes_h { + header "inttypes.h" + export stdint_h + export * + } + // provided by compiler. + // provided by compiler or C library. + module locale_h { + header "locale.h" + export * + } + module math_h { + header "math.h" + export * + } + module setjmp_h { + header "setjmp.h" + export * + } + // FIXME: is missing. + // provided by C library. + // provided by compiler. + // provided by compiler. + module stddef_h { + // 's __need_* macros require textual inclusion. + textual header "stddef.h" + } + module stdint_h { + header "stdint.h" + export * + // FIXME: This module only exists on OS X and for some reason the + // wildcard above doesn't export it. + export Darwin.C.stdint + } + module stdio_h { + // 's __need_* macros require textual inclusion. + textual header "stdio.h" + export * + export Darwin.C.stdio + } + module stdlib_h { + // 's __need_* macros require textual inclusion. + textual header "stdlib.h" + export * + } + module string_h { + header "string.h" + export * + } + // FIXME: is missing. + // provided by C library. + module wchar_h { + // 's __need_* macros require textual inclusion. + textual header "wchar.h" + export * + } + module wctype_h { + header "wctype.h" + export * + } + } + + // and are not C headers in any real sense, do not + // allow their use in extern "C" contexts. + module complex_h { + header "complex.h" + export ccomplex + export * + } + module tgmath_h { + header "tgmath.h" + export ccomplex + export cmath + export * + } + + // C compatibility headers. + module compat { + module cassert { + // 's use of NDEBUG requires textual inclusion. + textual header "cassert" + } + module ccomplex { + header "ccomplex" + export complex + export * + } + module cctype { + header "cctype" + export * + } + module cerrno { + header "cerrno" + export * + } + module cfenv { + header "cfenv" + export * + } + module cfloat { + header "cfloat" + export * + } + module cinttypes { + header "cinttypes" + export cstdint + export * + } + module ciso646 { + header "ciso646" + export * + } + module climits { + header "climits" + export * + } + module clocale { + header "clocale" + export * + } + module cmath { + header "cmath" + export * + } + module csetjmp { + header "csetjmp" + export * + } + module csignal { + header "csignal" + export * + } + // FIXME: is missing. + module cstdarg { + header "cstdarg" + export * + } + module cstdbool { + header "cstdbool" + export * + } + module cstddef { + header "cstddef" + export * + } + module cstdint { + header "cstdint" + export depr.stdint_h + export * + } + module cstdio { + header "cstdio" + export * + } + module cstdlib { + header "cstdlib" + export * + } + module cstring { + header "cstring" + export * + } + module ctgmath { + header "ctgmath" + export ccomplex + export cmath + export * + } + module ctime { + header "ctime" + export * + } + // FIXME: is missing. + module cwchar { + header "cwchar" + export depr.stdio_h + export * + } + module cwctype { + header "cwctype" + export * + } + } + + module algorithm { + header "algorithm" + export initializer_list + export * + + module __algorithm { + module adjacent_find { private header "__algorithm/adjacent_find.h" } + module all_of { private header "__algorithm/all_of.h" } + module any_of { private header "__algorithm/any_of.h" } + module binary_search { private header "__algorithm/binary_search.h" } + module clamp { private header "__algorithm/clamp.h" } + module comp { private header "__algorithm/comp.h" } + module comp_ref_type { private header "__algorithm/comp_ref_type.h" } + module copy { private header "__algorithm/copy.h" } + module copy_backward { private header "__algorithm/copy_backward.h" } + module copy_if { private header "__algorithm/copy_if.h" } + module copy_n { private header "__algorithm/copy_n.h" } + module count { private header "__algorithm/count.h" } + module count_if { private header "__algorithm/count_if.h" } + module equal { private header "__algorithm/equal.h" } + module equal_range { private header "__algorithm/equal_range.h" } + module fill { private header "__algorithm/fill.h" } + module fill_n { private header "__algorithm/fill_n.h" } + module find { private header "__algorithm/find.h" } + module find_end { private header "__algorithm/find_end.h" } + module find_first_of { private header "__algorithm/find_first_of.h" } + module find_if { private header "__algorithm/find_if.h" } + module find_if_not { private header "__algorithm/find_if_not.h" } + module for_each { private header "__algorithm/for_each.h" } + module for_each_n { private header "__algorithm/for_each_n.h" } + module generate { private header "__algorithm/generate.h" } + module generate_n { private header "__algorithm/generate_n.h" } + module half_positive { private header "__algorithm/half_positive.h" } + module in_in_out_result { private header "__algorithm/in_in_out_result.h" } + module in_in_result { private header "__algorithm/in_in_result.h" } + module in_out_result { private header "__algorithm/in_out_result.h" } + module includes { private header "__algorithm/includes.h" } + module inplace_merge { private header "__algorithm/inplace_merge.h" } + module is_heap { private header "__algorithm/is_heap.h" } + module is_heap_until { private header "__algorithm/is_heap_until.h" } + module is_partitioned { private header "__algorithm/is_partitioned.h" } + module is_permutation { private header "__algorithm/is_permutation.h" } + module is_sorted { private header "__algorithm/is_sorted.h" } + module is_sorted_until { private header "__algorithm/is_sorted_until.h" } + module iter_swap { private header "__algorithm/iter_swap.h" } + module lexicographical_compare { private header "__algorithm/lexicographical_compare.h" } + module lower_bound { private header "__algorithm/lower_bound.h" } + module make_heap { private header "__algorithm/make_heap.h" } + module max { private header "__algorithm/max.h" } + module max_element { private header "__algorithm/max_element.h" } + module merge { private header "__algorithm/merge.h" } + module min { private header "__algorithm/min.h" } + module min_element { private header "__algorithm/min_element.h" } + module minmax { private header "__algorithm/minmax.h" } + module minmax_element { private header "__algorithm/minmax_element.h" } + module mismatch { private header "__algorithm/mismatch.h" } + module move { private header "__algorithm/move.h" } + module move_backward { private header "__algorithm/move_backward.h" } + module next_permutation { private header "__algorithm/next_permutation.h" } + module none_of { private header "__algorithm/none_of.h" } + module nth_element { private header "__algorithm/nth_element.h" } + module partial_sort { private header "__algorithm/partial_sort.h" } + module partial_sort_copy { private header "__algorithm/partial_sort_copy.h" } + module partition { private header "__algorithm/partition.h" } + module partition_copy { private header "__algorithm/partition_copy.h" } + module partition_point { private header "__algorithm/partition_point.h" } + module pop_heap { private header "__algorithm/pop_heap.h" } + module prev_permutation { private header "__algorithm/prev_permutation.h" } + module push_heap { private header "__algorithm/push_heap.h" } + module remove { private header "__algorithm/remove.h" } + module remove_copy { private header "__algorithm/remove_copy.h" } + module remove_copy_if { private header "__algorithm/remove_copy_if.h" } + module remove_if { private header "__algorithm/remove_if.h" } + module replace { private header "__algorithm/replace.h" } + module replace_copy { private header "__algorithm/replace_copy.h" } + module replace_copy_if { private header "__algorithm/replace_copy_if.h" } + module replace_if { private header "__algorithm/replace_if.h" } + module reverse { private header "__algorithm/reverse.h" } + module reverse_copy { private header "__algorithm/reverse_copy.h" } + module rotate { private header "__algorithm/rotate.h" } + module rotate_copy { private header "__algorithm/rotate_copy.h" } + module sample { private header "__algorithm/sample.h" } + module search { private header "__algorithm/search.h" } + module search_n { private header "__algorithm/search_n.h" } + module set_difference { private header "__algorithm/set_difference.h" } + module set_intersection { private header "__algorithm/set_intersection.h" } + module set_symmetric_difference { private header "__algorithm/set_symmetric_difference.h" } + module set_union { private header "__algorithm/set_union.h" } + module shift_left { private header "__algorithm/shift_left.h" } + module shift_right { private header "__algorithm/shift_right.h" } + module shuffle { private header "__algorithm/shuffle.h" } + module sift_down { private header "__algorithm/sift_down.h" } + module sort { private header "__algorithm/sort.h" } + module sort_heap { private header "__algorithm/sort_heap.h" } + module stable_partition { private header "__algorithm/stable_partition.h" } + module stable_sort { private header "__algorithm/stable_sort.h" } + module swap_ranges { private header "__algorithm/swap_ranges.h" } + module transform { private header "__algorithm/transform.h" } + module unique { private header "__algorithm/unique.h" } + module unique_copy { private header "__algorithm/unique_copy.h" } + module unwrap_iter { private header "__algorithm/unwrap_iter.h" } + module upper_bound { private header "__algorithm/upper_bound.h" } + } + } + module any { + header "any" + export * + } + module array { + header "array" + export initializer_list + export * + } + module atomic { + header "atomic" + export * + } + module barrier { + requires cplusplus14 + header "barrier" + export * + } + module bit { + header "bit" + export * + + module __bit { + module bit_cast { private header "__bit/bit_cast.h" } + module byteswap { private header "__bit/byteswap.h" } + } + } + module bitset { + header "bitset" + export string + export iosfwd + export * + } + // No submodule for cassert. It fundamentally needs repeated, textual inclusion. + module charconv { + header "charconv" + export * + + module __charconv { + module chars_format { private header "__charconv/chars_format.h" } + module from_chars_result { private header "__charconv/from_chars_result.h" } + module to_chars_result { private header "__charconv/to_chars_result.h" } + } + + } + module chrono { + header "chrono" + export * + + module __chrono { + module calendar { private header "__chrono/calendar.h" } + module convert_to_timespec { private header "__chrono/convert_to_timespec.h" } + module duration { private header "__chrono/duration.h" } + module file_clock { private header "__chrono/file_clock.h" } + module high_resolution_clock { private header "__chrono/high_resolution_clock.h" } + module steady_clock { private header "__chrono/steady_clock.h" } + module system_clock { private header "__chrono/system_clock.h" } + module time_point { private header "__chrono/time_point.h" } + } + } + module codecvt { + header "codecvt" + export * + } + module compare { + header "compare" + export * + + module __compare { + module common_comparison_category { private header "__compare/common_comparison_category.h" } + module compare_partial_order_fallback { private header "__compare/compare_partial_order_fallback.h" } + module compare_strong_order_fallback { private header "__compare/compare_strong_order_fallback.h" } + module compare_three_way { private header "__compare/compare_three_way.h" } + module compare_three_way_result { private header "__compare/compare_three_way_result.h" } + module compare_weak_order_fallback { private header "__compare/compare_weak_order_fallback.h" } + module is_eq { private header "__compare/is_eq.h" } + module ordering { private header "__compare/ordering.h" } + module partial_order { private header "__compare/partial_order.h" } + module strong_order { private header "__compare/strong_order.h" } + module synth_three_way { private header "__compare/synth_three_way.h" } + module three_way_comparable { private header "__compare/three_way_comparable.h" } + module weak_order { private header "__compare/weak_order.h" } + } + } + module complex { + header "complex" + export * + } + module concepts { + header "concepts" + export * + + module __concepts { + module arithmetic { private header "__concepts/arithmetic.h" } + module assignable { private header "__concepts/assignable.h" } + module boolean_testable { private header "__concepts/boolean_testable.h" } + module class_or_enum { private header "__concepts/class_or_enum.h" } + module common_reference_with { private header "__concepts/common_reference_with.h" } + module common_with { private header "__concepts/common_with.h" } + module constructible { private header "__concepts/constructible.h" } + module convertible_to { private header "__concepts/convertible_to.h" } + module copyable { private header "__concepts/copyable.h" } + module derived_from { private header "__concepts/derived_from.h" } + module destructible { private header "__concepts/destructible.h" } + module different_from { private header "__concepts/different_from.h" } + module equality_comparable { private header "__concepts/equality_comparable.h" } + module invocable { private header "__concepts/invocable.h" } + module movable { private header "__concepts/movable.h" } + module predicate { private header "__concepts/predicate.h" } + module regular { private header "__concepts/regular.h" } + module relation { private header "__concepts/relation.h" } + module same_as { private header "__concepts/same_as.h" } + module semiregular { private header "__concepts/semiregular.h" } + module swappable { private header "__concepts/swappable.h" } + module totally_ordered { private header "__concepts/totally_ordered.h" } + } + } + module condition_variable { + header "condition_variable" + export * + } + module coroutine { + requires coroutines + header "coroutine" + export compare + export * + + module __coroutine { + module coroutine_handle { private header "__coroutine/coroutine_handle.h" } + module coroutine_traits { private header "__coroutine/coroutine_traits.h" } + module noop_coroutine_handle { private header "__coroutine/noop_coroutine_handle.h" } + module trivial_awaitables { private header "__coroutine/trivial_awaitables.h" } + } + } + module deque { + header "deque" + export initializer_list + export * + } + module exception { + header "exception" + export * + } + module execution { + header "execution" + export * + } + module filesystem { + header "filesystem" + export * + + module __filesystem { + module copy_options { private header "__filesystem/copy_options.h" } + module directory_entry { private header "__filesystem/directory_entry.h" } + module directory_iterator { private header "__filesystem/directory_iterator.h" } + module directory_options { private header "__filesystem/directory_options.h" } + module file_status { private header "__filesystem/file_status.h" } + module file_time_type { private header "__filesystem/file_time_type.h" } + module file_type { private header "__filesystem/file_type.h" } + module filesystem_error { private header "__filesystem/filesystem_error.h" } + module operations { private header "__filesystem/operations.h" } + module path { private header "__filesystem/path.h" } + module path_iterator { private header "__filesystem/path_iterator.h" } + module perm_options { private header "__filesystem/perm_options.h" } + module perms { private header "__filesystem/perms.h" } + module recursive_directory_iterator { private header "__filesystem/recursive_directory_iterator.h" } + module space_info { private header "__filesystem/space_info.h" } + module u8path { private header "__filesystem/u8path.h" } + } + } + module format { + header "format" + export * + + module __format { + module format_arg { private header "__format/format_arg.h" } + module format_args { private header "__format/format_args.h" } + module format_context { + private header "__format/format_context.h" + export optional + export locale + } + module format_error { private header "__format/format_error.h" } + module format_fwd { private header "__format/format_fwd.h" } + module format_parse_context { private header "__format/format_parse_context.h" } + module format_string { private header "__format/format_string.h" } + module format_to_n_result { private header "__format/format_to_n_result.h" } + module formatter { private header "__format/formatter.h" } + module formatter_bool { private header "__format/formatter_bool.h" } + module formatter_char { private header "__format/formatter_char.h" } + module formatter_floating_point { private header "__format/formatter_floating_point.h" } + module formatter_integer { private header "__format/formatter_integer.h" } + module formatter_integral { private header "__format/formatter_integral.h" } + module formatter_pointer { private header "__format/formatter_pointer.h" } + module formatter_string { private header "__format/formatter_string.h" } + module parser_std_format_spec { private header "__format/parser_std_format_spec.h" } + } + } + module forward_list { + header "forward_list" + export initializer_list + export * + } + module fstream { + header "fstream" + export * + } + module functional { + header "functional" + export * + + module __functional { + module binary_function { private header "__functional/binary_function.h" } + module binary_negate { private header "__functional/binary_negate.h" } + module bind { private header "__functional/bind.h" } + module bind_back { private header "__functional/bind_back.h" } + module bind_front { private header "__functional/bind_front.h" } + module binder1st { private header "__functional/binder1st.h" } + module binder2nd { private header "__functional/binder2nd.h" } + module compose { private header "__functional/compose.h" } + module default_searcher { private header "__functional/default_searcher.h" } + module function { private header "__functional/function.h" } + module hash { private header "__functional/hash.h" } + module identity { private header "__functional/identity.h" } + module invoke { private header "__functional/invoke.h" } + module is_transparent { private header "__functional/is_transparent.h" } + module mem_fn { private header "__functional/mem_fn.h" } + module mem_fun_ref { private header "__functional/mem_fun_ref.h" } + module not_fn { private header "__functional/not_fn.h" } + module operations { private header "__functional/operations.h" } + module perfect_forward { private header "__functional/perfect_forward.h" } + module pointer_to_binary_function { private header "__functional/pointer_to_binary_function.h" } + module pointer_to_unary_function { private header "__functional/pointer_to_unary_function.h" } + module ranges_operations { private header "__functional/ranges_operations.h" } + module reference_wrapper { private header "__functional/reference_wrapper.h" } + module unary_function { private header "__functional/unary_function.h" } + module unary_negate { private header "__functional/unary_negate.h" } + module unwrap_ref { private header "__functional/unwrap_ref.h" } + module weak_result_type { private header "__functional/weak_result_type.h" } + } + } + module future { + header "future" + export * + } + module initializer_list { + header "initializer_list" + export * + } + module iomanip { + header "iomanip" + export * + } + module ios { + header "ios" + export iosfwd + export * + } + module iosfwd { + header "iosfwd" + export * + } + module iostream { + header "iostream" + export ios + export streambuf + export istream + export ostream + export * + } + module istream { + header "istream" + // FIXME: should re-export ios, streambuf? + export * + } + module iterator { + header "iterator" + export * + + module __iterator { + module access { private header "__iterator/access.h" } + module advance { private header "__iterator/advance.h" } + module back_insert_iterator { private header "__iterator/back_insert_iterator.h" } + module common_iterator { private header "__iterator/common_iterator.h" } + module concepts { private header "__iterator/concepts.h" } + module counted_iterator { private header "__iterator/counted_iterator.h" } + module data { private header "__iterator/data.h" } + module default_sentinel { private header "__iterator/default_sentinel.h" } + module distance { private header "__iterator/distance.h" } + module empty { private header "__iterator/empty.h" } + module erase_if_container { private header "__iterator/erase_if_container.h" } + module front_insert_iterator { private header "__iterator/front_insert_iterator.h" } + module incrementable_traits { private header "__iterator/incrementable_traits.h" } + module indirectly_comparable { private header "__iterator/indirectly_comparable.h" } + module insert_iterator { private header "__iterator/insert_iterator.h" } + module istream_iterator { private header "__iterator/istream_iterator.h" } + module istreambuf_iterator { private header "__iterator/istreambuf_iterator.h" } + module iter_move { private header "__iterator/iter_move.h" } + module iter_swap { private header "__iterator/iter_swap.h" } + module iterator { private header "__iterator/iterator.h" } + module iterator_traits { private header "__iterator/iterator_traits.h" } + module move_iterator { private header "__iterator/move_iterator.h" } + module next { private header "__iterator/next.h" } + module ostream_iterator { private header "__iterator/ostream_iterator.h" } + module ostreambuf_iterator { private header "__iterator/ostreambuf_iterator.h" } + module prev { private header "__iterator/prev.h" } + module projected { private header "__iterator/projected.h" } + module readable_traits { private header "__iterator/readable_traits.h" } + module reverse_access { private header "__iterator/reverse_access.h" } + module reverse_iterator { private header "__iterator/reverse_iterator.h" } + module size { private header "__iterator/size.h" } + module unreachable_sentinel { private header "__iterator/unreachable_sentinel.h" } + module wrap_iter { private header "__iterator/wrap_iter.h" } + } + } + module latch { + requires cplusplus14 + header "latch" + export * + } + module limits { + header "limits" + export * + } + module list { + header "list" + export initializer_list + export * + } + module locale { + header "locale" + export * + } + module map { + header "map" + export initializer_list + export * + } + module memory { + header "memory" + export * + + module __memory { + module addressof { private header "__memory/addressof.h" } + module allocation_guard { private header "__memory/allocation_guard.h" } + module allocator { private header "__memory/allocator.h" } + module allocator_arg_t { private header "__memory/allocator_arg_t.h" } + module allocator_traits { private header "__memory/allocator_traits.h" } + module auto_ptr { private header "__memory/auto_ptr.h" } + module compressed_pair { private header "__memory/compressed_pair.h" } + module concepts { private header "__memory/concepts.h" } + module construct_at { private header "__memory/construct_at.h" } + module pointer_traits { private header "__memory/pointer_traits.h" } + module ranges_construct_at { private header "__memory/ranges_construct_at.h" } + module ranges_uninitialized_algorithms { private header "__memory/ranges_uninitialized_algorithms.h" } + module raw_storage_iterator { private header "__memory/raw_storage_iterator.h" } + module shared_ptr { private header "__memory/shared_ptr.h" } + module temporary_buffer { private header "__memory/temporary_buffer.h" } + module uninitialized_algorithms { private header "__memory/uninitialized_algorithms.h" } + module unique_ptr { private header "__memory/unique_ptr.h" } + module uses_allocator { private header "__memory/uses_allocator.h" } + module voidify { private header "__memory/voidify.h" } + } + } + module mutex { + header "mutex" + export * + } + module new { + header "new" + export * + } + module numbers { + header "numbers" + export * + } + module numeric { + header "numeric" + export * + + module __numeric { + module accumulate { private header "__numeric/accumulate.h" } + module adjacent_difference { private header "__numeric/adjacent_difference.h" } + module exclusive_scan { private header "__numeric/exclusive_scan.h" } + module gcd_lcm { private header "__numeric/gcd_lcm.h" } + module inclusive_scan { private header "__numeric/inclusive_scan.h" } + module inner_product { private header "__numeric/inner_product.h" } + module iota { private header "__numeric/iota.h" } + module midpoint { private header "__numeric/midpoint.h" } + module partial_sum { private header "__numeric/partial_sum.h" } + module reduce { private header "__numeric/reduce.h" } + module transform_exclusive_scan { private header "__numeric/transform_exclusive_scan.h" } + module transform_inclusive_scan { private header "__numeric/transform_inclusive_scan.h" } + module transform_reduce { private header "__numeric/transform_reduce.h" } + } + } + module optional { + header "optional" + export * + } + module ostream { + header "ostream" + // FIXME: should re-export ios, streambuf? + export * + } + module queue { + header "queue" + export initializer_list + export * + } + module random { + header "random" + export initializer_list + export * + + module __random { + module bernoulli_distribution { private header "__random/bernoulli_distribution.h" } + module binomial_distribution { private header "__random/binomial_distribution.h" } + module cauchy_distribution { private header "__random/cauchy_distribution.h" } + module chi_squared_distribution { private header "__random/chi_squared_distribution.h" } + module clamp_to_integral { private header "__random/clamp_to_integral.h" } + module default_random_engine { private header "__random/default_random_engine.h" } + module discard_block_engine { private header "__random/discard_block_engine.h" } + module discrete_distribution { private header "__random/discrete_distribution.h" } + module exponential_distribution { private header "__random/exponential_distribution.h" } + module extreme_value_distribution { private header "__random/extreme_value_distribution.h" } + module fisher_f_distribution { private header "__random/fisher_f_distribution.h" } + module gamma_distribution { private header "__random/gamma_distribution.h" } + module generate_canonical { private header "__random/generate_canonical.h" } + module geometric_distribution { private header "__random/geometric_distribution.h" } + module independent_bits_engine { private header "__random/independent_bits_engine.h" } + module is_seed_sequence { private header "__random/is_seed_sequence.h" } + module knuth_b { private header "__random/knuth_b.h" } + module linear_congruential_engine { private header "__random/linear_congruential_engine.h" } + module log2 { private header "__random/log2.h" } + module lognormal_distribution { private header "__random/lognormal_distribution.h" } + module mersenne_twister_engine { private header "__random/mersenne_twister_engine.h" } + module negative_binomial_distribution { private header "__random/negative_binomial_distribution.h" } + module normal_distribution { private header "__random/normal_distribution.h" } + module piecewise_constant_distribution { private header "__random/piecewise_constant_distribution.h" } + module piecewise_linear_distribution { private header "__random/piecewise_linear_distribution.h" } + module poisson_distribution { private header "__random/poisson_distribution.h" } + module random_device { private header "__random/random_device.h" } + module ranlux { private header "__random/ranlux.h" } + module seed_seq { private header "__random/seed_seq.h" } + module shuffle_order_engine { private header "__random/shuffle_order_engine.h" } + module student_t_distribution { private header "__random/student_t_distribution.h" } + module subtract_with_carry_engine { private header "__random/subtract_with_carry_engine.h" } + module uniform_int_distribution { private header "__random/uniform_int_distribution.h" } + module uniform_random_bit_generator { private header "__random/uniform_random_bit_generator.h" } + module uniform_real_distribution { private header "__random/uniform_real_distribution.h" } + module weibull_distribution { private header "__random/weibull_distribution.h" } + } + } + module ranges { + header "ranges" + export compare + export initializer_list + export iterator + export * + + module __ranges { + module access { private header "__ranges/access.h" } + module all { + private header "__ranges/all.h" + export functional.__functional.compose + export functional.__functional.perfect_forward + } + module common_view { private header "__ranges/common_view.h" } + module concepts { private header "__ranges/concepts.h" } + module copyable_box { private header "__ranges/copyable_box.h" } + module counted { + private header "__ranges/counted.h" + export span + } + module dangling { private header "__ranges/dangling.h" } + module data { private header "__ranges/data.h" } + module drop_view { private header "__ranges/drop_view.h" } + module empty { private header "__ranges/empty.h" } + module empty_view { private header "__ranges/empty_view.h" } + module enable_borrowed_range { private header "__ranges/enable_borrowed_range.h" } + module enable_view { private header "__ranges/enable_view.h" } + module iota_view { private header "__ranges/iota_view.h" } + module join_view { private header "__ranges/join_view.h" } + module non_propagating_cache { private header "__ranges/non_propagating_cache.h" } + module owning_view { private header "__ranges/owning_view.h" } + module range_adaptor { private header "__ranges/range_adaptor.h" } + module ref_view { private header "__ranges/ref_view.h" } + module reverse_view { private header "__ranges/reverse_view.h" } + module single_view { private header "__ranges/single_view.h" } + module size { private header "__ranges/size.h" } + module subrange { private header "__ranges/subrange.h" } + module take_view { private header "__ranges/take_view.h" } + module transform_view { + private header "__ranges/transform_view.h" + export functional.__functional.bind_back + export functional.__functional.perfect_forward + } + module view_interface { private header "__ranges/view_interface.h" } + module views { private header "__ranges/views.h" } + } + } + module ratio { + header "ratio" + export * + } + module regex { + header "regex" + export initializer_list + export * + } + module scoped_allocator { + header "scoped_allocator" + export * + } + module semaphore { + requires cplusplus14 + header "semaphore" + export * + } + module set { + header "set" + export initializer_list + export * + } + module shared_mutex { + header "shared_mutex" + export version + } + module span { + header "span" + export ranges.__ranges.enable_borrowed_range + export version + } *** 6368 LINES SKIPPED ***