* [PATCH] c++: Fix up decltype of non-dependent structured binding decl in template [PR92687]
@ 2024-02-29 11:50 Jakub Jelinek
2024-03-01 7:55 ` [PATCH] c++, v2: " Jakub Jelinek
0 siblings, 1 reply; 3+ messages in thread
From: Jakub Jelinek @ 2024-02-29 11:50 UTC (permalink / raw)
To: Jason Merrill; +Cc: gcc-patches
Hi!
finish_decltype_type uses DECL_HAS_VALUE_EXPR_P (expr) check for
DECL_DECOMPOSITION_P (expr) to determine if it is
array/struct/vector/complex etc. subobject proxy case vs. structured
binding using std::tuple_{size,element}.
For non-templates or when templates are already instantiated, that works
correctly, finalized DECL_DECOMPOSITION_P non-base vars indeed have
DECL_VALUE_EXPR in the former case and don't have it in the latter.
It works fine for dependent structured bindings as well, cp_finish_decomp in
that case creates DECLTYPE_TYPE tree and defers the handling until
instantiation.
As the testcase shows, this doesn't work for the non-dependent structured
binding case in templates, because DECL_HAS_VALUE_EXPR_P is set in that case
always; cp_finish_decomp ends with:
if (processing_template_decl)
{
for (unsigned int i = 0; i < count; i++)
if (!DECL_HAS_VALUE_EXPR_P (v[i]))
{
tree a = build_nt (ARRAY_REF, decl, size_int (i),
NULL_TREE, NULL_TREE);
SET_DECL_VALUE_EXPR (v[i], a);
DECL_HAS_VALUE_EXPR_P (v[i]) = 1;
}
}
and those artificial ARRAY_REFs are used in various places during
instantiation to find out what base the DECL_DECOMPOSITION_P VAR_DECLs
have and their positions.
The following patch fixes it by remembering from cp_finish_decomp in
the processing_template_decl case whether the structured binding uses
std::tuple_{size,element} or not in a flag, which then finish_decltype_type
can use.
Rather than wasting a lang_decl_base bit on it or growing the size of
lang_decl_decomp for it, I chose to abuse the ARRAY_REF operands;
the ARRAY_REF in that case is completely artificial, will never be emitted
(when the cp_finish_decomp is called on the instantiated version of it
with !processing_template_decl, DECL_VALUE_EXPR/DECL_HAS_VALUE_EXPR_P is
cleared), so I chose to use size_zero_node for the TREE_OPERAND (array_ref,
2) as a flag this structured binding is the tuple case (per ARRAY_REF
documentation the third operand is an optional copy of TYPE_MIN_VALUE of the
index type; and AFAIK everything in the C++ FE uses NULL there, it is mainly
there for Ada (and the 4th argument for arrays of non-constant length
elements), but all these ARRAY_REFs aren't even folded or something similar).
Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?
Another option would be to change
tree
lookup_decomp_type (tree v)
{
- return *decomp_type_table->get (v);
+ if (tree *slot = decomp_type_table->get (v))
+ return *slot;
+ return NULL_TREE;
}
and in finish_decl_decomp either just in the ptds.saved case or always
try to lookup_decomp_type, if it returns non-NULL, return what it returned,
otherwise return unlowered_expr_type (expr). I guess it would be cleaner,
I thought it would be more costly due to the hash table lookup, but now that
I think about it again, DECL_VALUE_EXPR is a hash table lookup as well.
So maybe then
+ if (ptds.saved)
+ {
+ gcc_checking_assert (DECL_HAS_VALUE_EXPR_P (expr));
+ /* DECL_HAS_VALUE_EXPR_P is always set if
+ processing_template_decl. If lookup_decomp_type
+ returns non-NULL, it is the tuple case. */
+ if (tree ret = lookup_decomp_type (expr))
+ return ret;
+ }
if (DECL_HAS_VALUE_EXPR_P (expr))
/* Expr is an array or struct subobject proxy, handle
bit-fields properly. */
return unlowered_expr_type (expr);
else
/* Expr is a reference variable for the tuple case. */
return lookup_decomp_type (expr);
2024-02-29 Jakub Jelinek <jakub@redhat.com>
PR c++/92687
* decl.cc (cp_finish_decomp): If processing_template_decl, remember
whether std::tuple_{size,element} will be used or not in third
operand of DECL_VALUE_EXPR ARRAY_REF.
* semantics.cc (finish_decltype_type): Use that if ptds.saved to see
if lookup_decomp_type should be used.
* g++.dg/cpp1z/decomp59.C: New test.
--- gcc/cp/decl.cc.jj 2024-02-28 08:41:18.486493565 +0100
+++ gcc/cp/decl.cc 2024-02-28 15:10:47.555186301 +0100
@@ -9384,6 +9384,7 @@ cp_finish_decomp (tree decl, cp_decomp *
tree eltype = NULL_TREE;
unsigned HOST_WIDE_INT eltscnt = 0;
+ bool tuple_p = false;
if (TREE_CODE (type) == ARRAY_TYPE)
{
tree nelts;
@@ -9535,6 +9536,7 @@ cp_finish_decomp (tree decl, cp_decomp *
of the individual variables. If those will be read, we'll mark
the underlying decl as read at that point. */
DECL_READ_P (decl) = save_read;
+ tuple_p = true;
}
else if (TREE_CODE (type) == UNION_TYPE)
{
@@ -9607,14 +9609,25 @@ cp_finish_decomp (tree decl, cp_decomp *
}
if (processing_template_decl)
{
+ /* For non-dependent structured bindings using std::tuple_size
+ and std::tuple_element, remember that in third operand of
+ the DECL_VALUE_EXPR ARRAY_REF for finish_decltype_type purposes. */
for (unsigned int i = 0; i < count; i++)
if (!DECL_HAS_VALUE_EXPR_P (v[i]))
{
tree a = build_nt (ARRAY_REF, decl, size_int (i),
- NULL_TREE, NULL_TREE);
+ tuple_p ? size_zero_node : NULL_TREE,
+ NULL_TREE);
SET_DECL_VALUE_EXPR (v[i], a);
DECL_HAS_VALUE_EXPR_P (v[i]) = 1;
}
+ else
+ {
+ tree vexpr = DECL_VALUE_EXPR (v[i]);
+ gcc_checking_assert (TREE_CODE (vexpr) == ARRAY_REF
+ && TREE_OPERAND (vexpr, 0) == decl);
+ TREE_OPERAND (vexpr, 2) = tuple_p ? size_zero_node : NULL_TREE;
+ }
}
}
--- gcc/cp/semantics.cc.jj 2024-02-10 09:38:25.871982914 +0100
+++ gcc/cp/semantics.cc 2024-02-28 15:08:01.026496157 +0100
@@ -11804,7 +11804,22 @@ finish_decltype_type (tree expr, bool id
access expression). */
if (DECL_DECOMPOSITION_P (expr))
{
- if (DECL_HAS_VALUE_EXPR_P (expr))
+ bool non_tuple_p = DECL_HAS_VALUE_EXPR_P (expr);
+ if (non_tuple_p && ptds.saved)
+ {
+ /* cp_finish_decl sets DECL_VALUE_EXPR on all
+ DECL_DECOMPOSITION_P decls, not just ones for
+ array, struct, vector, complex etc. subobject proxies.
+ The ARRAY_REFs for the tuple cases are marked with
+ non-NULL third argument. */
+ tree vexpr = DECL_VALUE_EXPR (expr);
+ if (TREE_CODE (vexpr) == ARRAY_REF
+ && DECL_P (TREE_OPERAND (vexpr, 0))
+ && DECL_DECOMPOSITION_P (TREE_OPERAND (vexpr, 0))
+ && TREE_OPERAND (vexpr, 2) == size_zero_node)
+ non_tuple_p = false;
+ }
+ if (non_tuple_p)
/* Expr is an array or struct subobject proxy, handle
bit-fields properly. */
return unlowered_expr_type (expr);
--- gcc/testsuite/g++.dg/cpp1z/decomp59.C.jj 2024-02-28 15:14:38.846978129 +0100
+++ gcc/testsuite/g++.dg/cpp1z/decomp59.C 2024-02-28 15:22:45.611226413 +0100
@@ -0,0 +1,63 @@
+// PR c++/92687
+// { dg-do compile { target c++11 } }
+// { dg-options "" }
+
+namespace std {
+ template<typename T> struct tuple_size;
+ template<int, typename> struct tuple_element;
+}
+
+struct A {
+ int i;
+ template <int I> int& get() { return i; }
+};
+
+template<> struct std::tuple_size<A> { static const int value = 2; };
+template<int I> struct std::tuple_element<I,A> { using type = int; };
+
+template<typename T>
+struct is_reference {
+ static const bool value = false;
+};
+
+template<typename T>
+struct is_reference<T&>
+{
+ static const bool value = true;
+};
+
+template<typename T>
+struct is_reference<T&&>
+{
+ static const bool value = true;
+};
+
+template<int N>
+void
+foo ()
+{
+ auto [x, y] = A {}; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ static_assert (!is_reference<decltype (x)>::value, "");
+}
+
+void
+bar ()
+{
+ auto [x, y] = A {}; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ static_assert (!is_reference<decltype (x)>::value, "");
+}
+
+template<typename T>
+void
+baz ()
+{
+ auto [x, y] = T {}; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ static_assert (!is_reference<decltype (x)>::value, "");
+}
+
+void
+qux ()
+{
+ foo<0> ();
+ baz<A> ();
+}
Jakub
^ permalink raw reply [flat|nested] 3+ messages in thread
* [PATCH] c++, v2: Fix up decltype of non-dependent structured binding decl in template [PR92687]
2024-02-29 11:50 [PATCH] c++: Fix up decltype of non-dependent structured binding decl in template [PR92687] Jakub Jelinek
@ 2024-03-01 7:55 ` Jakub Jelinek
2024-03-01 15:35 ` Jason Merrill
0 siblings, 1 reply; 3+ messages in thread
From: Jakub Jelinek @ 2024-03-01 7:55 UTC (permalink / raw)
To: Jason Merrill; +Cc: gcc-patches
On Thu, Feb 29, 2024 at 12:50:47PM +0100, Jakub Jelinek wrote:
> finish_decltype_type uses DECL_HAS_VALUE_EXPR_P (expr) check for
> DECL_DECOMPOSITION_P (expr) to determine if it is
> array/struct/vector/complex etc. subobject proxy case vs. structured
> binding using std::tuple_{size,element}.
> For non-templates or when templates are already instantiated, that works
> correctly, finalized DECL_DECOMPOSITION_P non-base vars indeed have
> DECL_VALUE_EXPR in the former case and don't have it in the latter.
> It works fine for dependent structured bindings as well, cp_finish_decomp in
> that case creates DECLTYPE_TYPE tree and defers the handling until
> instantiation.
> As the testcase shows, this doesn't work for the non-dependent structured
> binding case in templates, because DECL_HAS_VALUE_EXPR_P is set in that case
> always; cp_finish_decomp ends with:
> if (processing_template_decl)
> {
> for (unsigned int i = 0; i < count; i++)
> if (!DECL_HAS_VALUE_EXPR_P (v[i]))
> {
> tree a = build_nt (ARRAY_REF, decl, size_int (i),
> NULL_TREE, NULL_TREE);
> SET_DECL_VALUE_EXPR (v[i], a);
> DECL_HAS_VALUE_EXPR_P (v[i]) = 1;
> }
> }
> and those artificial ARRAY_REFs are used in various places during
> instantiation to find out what base the DECL_DECOMPOSITION_P VAR_DECLs
> have and their positions.
> Another option would be to change
> tree
> lookup_decomp_type (tree v)
> {
> - return *decomp_type_table->get (v);
> + if (tree *slot = decomp_type_table->get (v))
> + return *slot;
> + return NULL_TREE;
> }
>
> and in finish_decl_decomp either just in the ptds.saved case or always
> try to lookup_decomp_type, if it returns non-NULL, return what it returned,
> otherwise return unlowered_expr_type (expr). I guess it would be cleaner,
> I thought it would be more costly due to the hash table lookup, but now that
> I think about it again, DECL_VALUE_EXPR is a hash table lookup as well.
> So maybe then
> + if (ptds.saved)
> + {
> + gcc_checking_assert (DECL_HAS_VALUE_EXPR_P (expr));
> + /* DECL_HAS_VALUE_EXPR_P is always set if
> + processing_template_decl. If lookup_decomp_type
> + returns non-NULL, it is the tuple case. */
> + if (tree ret = lookup_decomp_type (expr))
> + return ret;
> + }
> if (DECL_HAS_VALUE_EXPR_P (expr))
> /* Expr is an array or struct subobject proxy, handle
> bit-fields properly. */
> return unlowered_expr_type (expr);
> else
> /* Expr is a reference variable for the tuple case. */
> return lookup_decomp_type (expr);
Here is a variant of the patch which does that.
Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?
Or the other version, or adding some flag to the DECL_DECOMPOSITION_P
decls?
2024-03-01 Jakub Jelinek <jakub@redhat.com>
PR c++/92687
* decl.cc (lookup_decomp_type): Return NULL_TREE if decomp_type_table
doesn't have entry for V.
* semantics.cc (finish_decltype_type): If ptds.saved, assert
DECL_HAS_VALUE_EXPR_P is true and decide on tuple vs. non-tuple based
on if lookup_decomp_type is NULL or not.
* g++.dg/cpp1z/decomp59.C: New test.
--- gcc/cp/decl.cc.jj 2024-02-28 23:20:01.004751204 +0100
+++ gcc/cp/decl.cc 2024-02-29 20:03:11.087218176 +0100
@@ -9262,7 +9262,9 @@ static GTY((cache)) decl_tree_cache_map
tree
lookup_decomp_type (tree v)
{
- return *decomp_type_table->get (v);
+ if (tree *slot = decomp_type_table->get (v))
+ return *slot;
+ return NULL_TREE;
}
/* Mangle a decomposition declaration if needed. Arguments like
--- gcc/cp/semantics.cc.jj 2024-02-28 22:57:08.101800588 +0100
+++ gcc/cp/semantics.cc 2024-02-29 20:04:51.936880622 +0100
@@ -11804,6 +11804,15 @@ finish_decltype_type (tree expr, bool id
access expression). */
if (DECL_DECOMPOSITION_P (expr))
{
+ if (ptds.saved)
+ {
+ gcc_checking_assert (DECL_HAS_VALUE_EXPR_P (expr));
+ /* DECL_HAS_VALUE_EXPR_P is always set if
+ processing_template_decl. If lookup_decomp_type
+ returns non-NULL, it is the tuple case. */
+ if (tree ret = lookup_decomp_type (expr))
+ return ret;
+ }
if (DECL_HAS_VALUE_EXPR_P (expr))
/* Expr is an array or struct subobject proxy, handle
bit-fields properly. */
--- gcc/testsuite/g++.dg/cpp1z/decomp59.C.jj 2024-02-29 20:02:17.467929327 +0100
+++ gcc/testsuite/g++.dg/cpp1z/decomp59.C 2024-02-29 20:02:17.467929327 +0100
@@ -0,0 +1,63 @@
+// PR c++/92687
+// { dg-do compile { target c++11 } }
+// { dg-options "" }
+
+namespace std {
+ template<typename T> struct tuple_size;
+ template<int, typename> struct tuple_element;
+}
+
+struct A {
+ int i;
+ template <int I> int& get() { return i; }
+};
+
+template<> struct std::tuple_size<A> { static const int value = 2; };
+template<int I> struct std::tuple_element<I,A> { using type = int; };
+
+template<typename T>
+struct is_reference {
+ static const bool value = false;
+};
+
+template<typename T>
+struct is_reference<T&>
+{
+ static const bool value = true;
+};
+
+template<typename T>
+struct is_reference<T&&>
+{
+ static const bool value = true;
+};
+
+template<int N>
+void
+foo ()
+{
+ auto [x, y] = A {}; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ static_assert (!is_reference<decltype (x)>::value, "");
+}
+
+void
+bar ()
+{
+ auto [x, y] = A {}; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ static_assert (!is_reference<decltype (x)>::value, "");
+}
+
+template<typename T>
+void
+baz ()
+{
+ auto [x, y] = T {}; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ static_assert (!is_reference<decltype (x)>::value, "");
+}
+
+void
+qux ()
+{
+ foo<0> ();
+ baz<A> ();
+}
Jakub
^ permalink raw reply [flat|nested] 3+ messages in thread
* Re: [PATCH] c++, v2: Fix up decltype of non-dependent structured binding decl in template [PR92687]
2024-03-01 7:55 ` [PATCH] c++, v2: " Jakub Jelinek
@ 2024-03-01 15:35 ` Jason Merrill
0 siblings, 0 replies; 3+ messages in thread
From: Jason Merrill @ 2024-03-01 15:35 UTC (permalink / raw)
To: Jakub Jelinek; +Cc: gcc-patches
On 3/1/24 02:55, Jakub Jelinek wrote:
> On Thu, Feb 29, 2024 at 12:50:47PM +0100, Jakub Jelinek wrote:
>> finish_decltype_type uses DECL_HAS_VALUE_EXPR_P (expr) check for
>> DECL_DECOMPOSITION_P (expr) to determine if it is
>> array/struct/vector/complex etc. subobject proxy case vs. structured
>> binding using std::tuple_{size,element}.
>> For non-templates or when templates are already instantiated, that works
>> correctly, finalized DECL_DECOMPOSITION_P non-base vars indeed have
>> DECL_VALUE_EXPR in the former case and don't have it in the latter.
>> It works fine for dependent structured bindings as well, cp_finish_decomp in
>> that case creates DECLTYPE_TYPE tree and defers the handling until
>> instantiation.
>> As the testcase shows, this doesn't work for the non-dependent structured
>> binding case in templates, because DECL_HAS_VALUE_EXPR_P is set in that case
>> always; cp_finish_decomp ends with:
>> if (processing_template_decl)
>> {
>> for (unsigned int i = 0; i < count; i++)
>> if (!DECL_HAS_VALUE_EXPR_P (v[i]))
>> {
>> tree a = build_nt (ARRAY_REF, decl, size_int (i),
>> NULL_TREE, NULL_TREE);
>> SET_DECL_VALUE_EXPR (v[i], a);
>> DECL_HAS_VALUE_EXPR_P (v[i]) = 1;
>> }
>> }
>> and those artificial ARRAY_REFs are used in various places during
>> instantiation to find out what base the DECL_DECOMPOSITION_P VAR_DECLs
>> have and their positions.
>
>> Another option would be to change
>> tree
>> lookup_decomp_type (tree v)
>> {
>> - return *decomp_type_table->get (v);
>> + if (tree *slot = decomp_type_table->get (v))
>> + return *slot;
>> + return NULL_TREE;
>> }
>>
>> and in finish_decl_decomp either just in the ptds.saved case or always
>> try to lookup_decomp_type, if it returns non-NULL, return what it returned,
>> otherwise return unlowered_expr_type (expr). I guess it would be cleaner,
>> I thought it would be more costly due to the hash table lookup, but now that
>> I think about it again, DECL_VALUE_EXPR is a hash table lookup as well.
>> So maybe then
>> + if (ptds.saved)
>> + {
>> + gcc_checking_assert (DECL_HAS_VALUE_EXPR_P (expr));
>> + /* DECL_HAS_VALUE_EXPR_P is always set if
>> + processing_template_decl. If lookup_decomp_type
>> + returns non-NULL, it is the tuple case. */
>> + if (tree ret = lookup_decomp_type (expr))
>> + return ret;
>> + }
>> if (DECL_HAS_VALUE_EXPR_P (expr))
>> /* Expr is an array or struct subobject proxy, handle
>> bit-fields properly. */
>> return unlowered_expr_type (expr);
>> else
>> /* Expr is a reference variable for the tuple case. */
>> return lookup_decomp_type (expr);
>
> Here is a variant of the patch which does that.
>
> Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?
OK.
> Or the other version, or adding some flag to the DECL_DECOMPOSITION_P
> decls?
>
> 2024-03-01 Jakub Jelinek <jakub@redhat.com>
>
> PR c++/92687
> * decl.cc (lookup_decomp_type): Return NULL_TREE if decomp_type_table
> doesn't have entry for V.
> * semantics.cc (finish_decltype_type): If ptds.saved, assert
> DECL_HAS_VALUE_EXPR_P is true and decide on tuple vs. non-tuple based
> on if lookup_decomp_type is NULL or not.
>
> * g++.dg/cpp1z/decomp59.C: New test.
>
> --- gcc/cp/decl.cc.jj 2024-02-28 23:20:01.004751204 +0100
> +++ gcc/cp/decl.cc 2024-02-29 20:03:11.087218176 +0100
> @@ -9262,7 +9262,9 @@ static GTY((cache)) decl_tree_cache_map
> tree
> lookup_decomp_type (tree v)
> {
> - return *decomp_type_table->get (v);
> + if (tree *slot = decomp_type_table->get (v))
> + return *slot;
> + return NULL_TREE;
> }
>
> /* Mangle a decomposition declaration if needed. Arguments like
> --- gcc/cp/semantics.cc.jj 2024-02-28 22:57:08.101800588 +0100
> +++ gcc/cp/semantics.cc 2024-02-29 20:04:51.936880622 +0100
> @@ -11804,6 +11804,15 @@ finish_decltype_type (tree expr, bool id
> access expression). */
> if (DECL_DECOMPOSITION_P (expr))
> {
> + if (ptds.saved)
> + {
> + gcc_checking_assert (DECL_HAS_VALUE_EXPR_P (expr));
> + /* DECL_HAS_VALUE_EXPR_P is always set if
> + processing_template_decl. If lookup_decomp_type
> + returns non-NULL, it is the tuple case. */
> + if (tree ret = lookup_decomp_type (expr))
> + return ret;
> + }
> if (DECL_HAS_VALUE_EXPR_P (expr))
> /* Expr is an array or struct subobject proxy, handle
> bit-fields properly. */
> --- gcc/testsuite/g++.dg/cpp1z/decomp59.C.jj 2024-02-29 20:02:17.467929327 +0100
> +++ gcc/testsuite/g++.dg/cpp1z/decomp59.C 2024-02-29 20:02:17.467929327 +0100
> @@ -0,0 +1,63 @@
> +// PR c++/92687
> +// { dg-do compile { target c++11 } }
> +// { dg-options "" }
> +
> +namespace std {
> + template<typename T> struct tuple_size;
> + template<int, typename> struct tuple_element;
> +}
> +
> +struct A {
> + int i;
> + template <int I> int& get() { return i; }
> +};
> +
> +template<> struct std::tuple_size<A> { static const int value = 2; };
> +template<int I> struct std::tuple_element<I,A> { using type = int; };
> +
> +template<typename T>
> +struct is_reference {
> + static const bool value = false;
> +};
> +
> +template<typename T>
> +struct is_reference<T&>
> +{
> + static const bool value = true;
> +};
> +
> +template<typename T>
> +struct is_reference<T&&>
> +{
> + static const bool value = true;
> +};
> +
> +template<int N>
> +void
> +foo ()
> +{
> + auto [x, y] = A {}; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
> + static_assert (!is_reference<decltype (x)>::value, "");
> +}
> +
> +void
> +bar ()
> +{
> + auto [x, y] = A {}; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
> + static_assert (!is_reference<decltype (x)>::value, "");
> +}
> +
> +template<typename T>
> +void
> +baz ()
> +{
> + auto [x, y] = T {}; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
> + static_assert (!is_reference<decltype (x)>::value, "");
> +}
> +
> +void
> +qux ()
> +{
> + foo<0> ();
> + baz<A> ();
> +}
>
>
> Jakub
>
^ permalink raw reply [flat|nested] 3+ messages in thread
end of thread, other threads:[~2024-03-01 15:36 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2024-02-29 11:50 [PATCH] c++: Fix up decltype of non-dependent structured binding decl in template [PR92687] Jakub Jelinek
2024-03-01 7:55 ` [PATCH] c++, v2: " Jakub Jelinek
2024-03-01 15:35 ` Jason Merrill
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).