vasilito
cb424d7448
verify-patch-sanity.py validates every active recipe .patch has internally- consistent hunk line counts — catching the 'malformed patch at line N' failure at commit/CI/preflight time instead of hours into a cook. This cycle hit that class three times (qtwaylandscanner, sddm, xwayland), each only discovered when cookbook tried to apply the patch. Running it across the repo found 29 latent malformed patches (validated against GNU patch: e.g. relibc/P3-sysv-ipc reproduces 'malformed patch at line 22'). They were harmless only because they sit in vendored recipes (baked, not re- applied) — but would fail on any version-bump re-derivation. --fix recounts the hunk headers (body untouched) and repaired all 29. Wired into build-preflight.sh (Phase 1.0D) and redbear-ci.yml, with a unit test (test-patch-sanity.sh). Skips archived/legacy trees and unvalidatable formats (empty placeholders, bare-@@ git hunks).
505 lines
19 KiB
C++
505 lines
19 KiB
C++
// RUN: %clang_cc1 -fsyntax-only -fblocks -fcxx-exceptions -std=c++20 -verify -Wfunction-effects -Wno-vla-extension %s
|
|
// These are in a separate file because errors (e.g. incompatible attributes) currently prevent
|
|
// the FXAnalysis pass from running at all.
|
|
|
|
// This diagnostic is re-enabled and exercised in isolation later in this file.
|
|
#pragma clang diagnostic ignored "-Wperf-constraint-implies-noexcept"
|
|
|
|
// --- CONSTRAINTS ---
|
|
|
|
void nb1() [[clang::nonblocking]]
|
|
{
|
|
int *pInt = new int; // expected-warning {{function with 'nonblocking' attribute must not allocate or deallocate memory}}
|
|
delete pInt; // expected-warning {{function with 'nonblocking' attribute must not allocate or deallocate memory}}
|
|
}
|
|
|
|
void nb2() [[clang::nonblocking]]
|
|
{
|
|
static int global; // expected-warning {{function with 'nonblocking' attribute must not have static local variables}}
|
|
}
|
|
|
|
void nb3() [[clang::nonblocking]]
|
|
{
|
|
try {
|
|
throw 42; // expected-warning {{function with 'nonblocking' attribute must not throw or catch exceptions}}
|
|
}
|
|
catch (...) { // expected-warning {{function with 'nonblocking' attribute must not throw or catch exceptions}}
|
|
}
|
|
}
|
|
|
|
void nb4_inline() {}
|
|
void nb4_not_inline(); // expected-note {{declaration cannot be inferred 'nonblocking' because it has no definition in this translation unit}}
|
|
|
|
void nb4() [[clang::nonblocking]]
|
|
{
|
|
nb4_inline(); // OK
|
|
nb4_not_inline(); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function}}
|
|
}
|
|
|
|
|
|
struct HasVirtual {
|
|
virtual void unsafe(); // expected-note {{virtual method cannot be inferred 'nonblocking'}}
|
|
};
|
|
|
|
void nb5() [[clang::nonblocking]]
|
|
{
|
|
HasVirtual hv;
|
|
hv.unsafe(); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function}}
|
|
}
|
|
|
|
void nb6_unsafe(); // expected-note {{declaration cannot be inferred 'nonblocking' because it has no definition in this translation unit}}
|
|
void nb6_transitively_unsafe()
|
|
{
|
|
nb6_unsafe(); // expected-note {{function cannot be inferred 'nonblocking' because it calls non-'nonblocking' function}}
|
|
}
|
|
|
|
void nb6() [[clang::nonblocking]]
|
|
{
|
|
nb6_transitively_unsafe(); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function}}
|
|
}
|
|
|
|
thread_local int tl_var{ 42 };
|
|
|
|
bool tl_test() [[clang::nonblocking]]
|
|
{
|
|
return tl_var > 0; // expected-warning {{function with 'nonblocking' attribute must not use thread-local variables}}
|
|
}
|
|
|
|
void nb7()
|
|
{
|
|
// Make sure we verify blocks
|
|
auto blk = ^() [[clang::nonblocking]] {
|
|
throw 42; // expected-warning {{block with 'nonblocking' attribute must not throw or catch exceptions}}
|
|
};
|
|
}
|
|
|
|
void nb8()
|
|
{
|
|
// Make sure we verify lambdas
|
|
auto lambda = []() [[clang::nonblocking]] {
|
|
throw 42; // expected-warning {{lambda with 'nonblocking' attribute must not throw or catch exceptions}}
|
|
};
|
|
}
|
|
|
|
void nb8a() [[clang::nonblocking]]
|
|
{
|
|
// A blocking lambda shouldn't make the outer function unsafe.
|
|
auto unsafeLambda = []() {
|
|
throw 42;
|
|
};
|
|
}
|
|
|
|
void nb8b() [[clang::nonblocking]]
|
|
{
|
|
// An unsafe lambda capture makes the outer function unsafe.
|
|
auto unsafeCapture = [foo = new int]() { // expected-warning {{function with 'nonblocking' attribute must not allocate or deallocate memory}}
|
|
delete foo;
|
|
};
|
|
}
|
|
|
|
void nb8c()
|
|
{
|
|
// An unsafe lambda capture does not make the lambda unsafe.
|
|
auto unsafeCapture = [foo = new int]() [[clang::nonblocking]] {
|
|
};
|
|
}
|
|
|
|
// Make sure template expansions are found and verified.
|
|
template <typename T>
|
|
struct Adder {
|
|
static T add_explicit(T x, T y) [[clang::nonblocking]]
|
|
{
|
|
return x + y; // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function}}
|
|
}
|
|
static T add_implicit(T x, T y)
|
|
{
|
|
return x + y; // expected-note {{function cannot be inferred 'nonblocking' because it calls non-'nonblocking' function}}
|
|
}
|
|
};
|
|
|
|
struct Stringy {
|
|
friend Stringy operator+(const Stringy& x, const Stringy& y)
|
|
{
|
|
// Do something inferably unsafe
|
|
auto* z = new char[42]; // expected-note {{function cannot be inferred 'nonblocking' because it allocates or deallocates memory}}
|
|
return {};
|
|
}
|
|
};
|
|
|
|
struct Stringy2 {
|
|
friend Stringy2 operator+(const Stringy2& x, const Stringy2& y)
|
|
{
|
|
// Do something inferably unsafe
|
|
throw 42; // expected-note {{function cannot be inferred 'nonblocking' because it throws or catches exceptions}}
|
|
}
|
|
};
|
|
|
|
void nb9() [[clang::nonblocking]]
|
|
{
|
|
Adder<int>::add_explicit(1, 2);
|
|
Adder<int>::add_implicit(1, 2);
|
|
|
|
Adder<Stringy>::add_explicit({}, {}); // expected-note {{in template expansion here}}
|
|
Adder<Stringy2>::add_implicit({}, {}); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function}} \
|
|
expected-note {{in template expansion here}}
|
|
}
|
|
|
|
// Make sure we verify lambdas produced from template expansions.
|
|
struct HasTemplatedLambda {
|
|
void (*fptr)() [[clang::nonblocking]];
|
|
|
|
template <typename C>
|
|
HasTemplatedLambda(const C&)
|
|
: fptr{ []() [[clang::nonblocking]] {
|
|
auto* y = new int; // expected-warning {{lambda with 'nonblocking' attribute must not allocate or deallocate memory}}
|
|
} }
|
|
{}
|
|
};
|
|
|
|
void nb9a()
|
|
{
|
|
HasTemplatedLambda bad(42);
|
|
}
|
|
|
|
// Templated function and lambda.
|
|
template <typename T>
|
|
void TemplatedFunc(T x) [[clang::nonblocking]] {
|
|
auto* ptr = new T; // expected-warning {{function with 'nonblocking' attribute must not allocate or deallocate memory}}
|
|
}
|
|
|
|
void nb9b() [[clang::nonblocking]] {
|
|
TemplatedFunc(42); // expected-note {{in template expansion here}}
|
|
|
|
auto foo = [](auto x) [[clang::nonblocking]] {
|
|
auto* ptr = new int; // expected-warning {{lambda with 'nonblocking' attribute must not allocate or deallocate memory}}
|
|
return x;
|
|
};
|
|
|
|
// Note that foo() won't be validated unless instantiated.
|
|
foo(42);
|
|
}
|
|
|
|
void nb10(
|
|
void (*fp1)(), // expected-note {{function pointer cannot be inferred 'nonblocking'}}
|
|
void (*fp2)() [[clang::nonblocking]]
|
|
) [[clang::nonblocking]]
|
|
{
|
|
fp1(); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function}}
|
|
fp2();
|
|
|
|
// When there's a cast, there's a separate diagnostic.
|
|
static_cast<void (*)()>(fp1)(); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' expression}}
|
|
}
|
|
|
|
// Expression involving indirection
|
|
int nb10a() [[clang::nonblocking]];
|
|
int nb10b() [[clang::nonblocking]];
|
|
int blocking();
|
|
|
|
int nb10c(bool x) [[clang::nonblocking]]
|
|
{
|
|
int y = (x ? nb10a : blocking)(); // expected-warning {{attribute 'nonblocking' should not be added via type conversion}}
|
|
return (x ? nb10a : nb10b)(); // No diagnostic.
|
|
}
|
|
|
|
// Interactions with nonblocking(false)
|
|
void nb11_no_inference_1() [[clang::nonblocking(false)]] // expected-note {{function does not permit inference of 'nonblocking'}}
|
|
{
|
|
}
|
|
void nb11_no_inference_2() [[clang::nonblocking(false)]]; // expected-note {{function does not permit inference of 'nonblocking'}}
|
|
|
|
template <bool V>
|
|
struct ComputedNB {
|
|
void method() [[clang::nonblocking(V)]]; // expected-note {{function does not permit inference of 'nonblocking' because it is declared 'blocking'}}
|
|
};
|
|
|
|
void nb11() [[clang::nonblocking]]
|
|
{
|
|
nb11_no_inference_1(); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function}}
|
|
nb11_no_inference_2(); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function}}
|
|
|
|
ComputedNB<true> CNB_true;
|
|
CNB_true.method();
|
|
|
|
ComputedNB<false> CNB_false;
|
|
CNB_false.method(); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function}}
|
|
}
|
|
|
|
// Verify that when attached to a redeclaration, the attribute successfully attaches.
|
|
void nb12() {
|
|
static int x; // expected-warning {{function with 'nonblocking' attribute must not have static local variables}}
|
|
}
|
|
void nb12() [[clang::nonblocking]];
|
|
void nb13() [[clang::nonblocking]] { nb12(); }
|
|
|
|
// C++ member function pointers
|
|
struct PTMFTester {
|
|
typedef void (PTMFTester::*ConvertFunction)() [[clang::nonblocking]];
|
|
|
|
void convert() [[clang::nonblocking]];
|
|
|
|
ConvertFunction mConvertFunc;
|
|
};
|
|
|
|
void PTMFTester::convert() [[clang::nonblocking]]
|
|
{
|
|
(this->*mConvertFunc)();
|
|
}
|
|
|
|
// Allow implicit conversion from array to pointer.
|
|
void nb14(unsigned idx) [[clang::nonblocking]]
|
|
{
|
|
using FP = void (*)() [[clang::nonblocking]];
|
|
using FPArray = FP[2];
|
|
auto nb = +[]() [[clang::nonblocking]] {};
|
|
|
|
FPArray src{ nb, nullptr };
|
|
FP f = src[idx]; // This should not generate a warning.
|
|
|
|
FP twoDim[2][2] = {};
|
|
FP g = twoDim[1][1];
|
|
|
|
FP vla[idx];
|
|
FP h = vla[0];
|
|
}
|
|
|
|
// Block variables
|
|
void nb17(void (^blk)() [[clang::nonblocking]]) [[clang::nonblocking]] {
|
|
blk();
|
|
}
|
|
|
|
// References to blocks
|
|
void nb18(void (^block)() [[clang::nonblocking]]) [[clang::nonblocking]]
|
|
{
|
|
auto &ref = block;
|
|
ref();
|
|
}
|
|
|
|
// Builtin functions
|
|
void nb19() [[clang::nonblocking]] {
|
|
__builtin_assume(1);
|
|
void *ptr = __builtin_malloc(1); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function '__builtin_malloc'}}
|
|
__builtin_free(ptr); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function '__builtin_free'}}
|
|
|
|
void *p2 = __builtin_operator_new(1); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function '__builtin_operator_new'}}
|
|
__builtin_operator_delete(p2); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function '__builtin_operator_delete'}}
|
|
}
|
|
|
|
// Function try-block
|
|
void catches() try {} catch (...) {} // expected-note {{function cannot be inferred 'nonblocking' because it throws or catches exceptions}}
|
|
|
|
void nb20() [[clang::nonblocking]] {
|
|
catches(); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function 'catches'}}
|
|
}
|
|
|
|
struct S {
|
|
int x;
|
|
S(int x) try : x(x) {} catch (...) {} // expected-note {{constructor cannot be inferred 'nonblocking' because it throws or catches exceptions}}
|
|
S(double) : x((throw 3, 3)) {} // expected-note {{member initializer cannot be inferred 'nonblocking' because it throws or catches exceptions}} \
|
|
expected-note {{in constructor here}}
|
|
};
|
|
|
|
int badi(); // expected-note {{declaration cannot be inferred 'nonblocking' because it has no definition in this translation unit}} \
|
|
// expected-note {{declaration cannot be inferred 'nonblocking' because it has no definition in this translation unit}}
|
|
|
|
struct A { // expected-note {{in implicit constructor here}}
|
|
int x = (throw 3, 3); // expected-note {{member initializer cannot be inferred 'nonblocking' because it throws or catches exceptions}}
|
|
};
|
|
|
|
struct B {
|
|
int y = badi(); // expected-note {{member initializer cannot be inferred 'nonblocking' because it calls non-'nonblocking' function 'badi'}}
|
|
};
|
|
|
|
void f() [[clang::nonblocking]] {
|
|
S s1(3); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' constructor 'S::S'}}
|
|
S s2(3.0); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' constructor 'S::S'}}
|
|
A a; // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' constructor 'A::A'}}
|
|
B b; // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' constructor 'B::B'}}
|
|
}
|
|
|
|
struct T {
|
|
int x = badi(); // expected-warning {{member initializer of constructor with 'nonblocking' attribute must not call non-'nonblocking' function 'badi'}}
|
|
T() [[clang::nonblocking]] {} // expected-note {{in constructor here}}
|
|
T(int x) [[clang::nonblocking]] : x(x) {} // OK
|
|
};
|
|
|
|
// Default arguments
|
|
int badForDefaultArg(); // expected-note {{declaration cannot be inferred 'nonblocking' because it has no definition in this translation unit}} \
|
|
expected-note {{declaration cannot be inferred 'nonblocking' because it has no definition in this translation unit}} \
|
|
expected-note {{declaration cannot be inferred 'nonblocking' because it has no definition in this translation unit}}
|
|
|
|
void hasDefaultArg(int param = badForDefaultArg()) { // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function 'badForDefaultArg'}} \
|
|
expected-note {{function cannot be inferred 'nonblocking' because it calls non-'nonblocking' function 'badForDefaultArg'}}
|
|
}
|
|
|
|
void nb21() [[clang::nonblocking]] {
|
|
hasDefaultArg(); // expected-note {{in evaluating default argument here}} \
|
|
expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function 'hasDefaultArg'}}
|
|
}
|
|
|
|
void nb22(int param = badForDefaultArg()) [[clang::nonblocking]] { // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function 'badForDefaultArg'}}
|
|
}
|
|
|
|
// Verify traversal of implicit code paths - constructors and destructors.
|
|
struct Unsafe {
|
|
static void problem1(); // expected-note {{declaration cannot be inferred 'nonblocking' because it has no definition in this translation unit}}
|
|
static void problem2(); // expected-note {{declaration cannot be inferred 'nonblocking' because it has no definition in this translation unit}}
|
|
|
|
Unsafe() { problem1(); } // expected-note {{constructor cannot be inferred 'nonblocking' because it calls non-'nonblocking' function 'Unsafe::problem1'}}
|
|
~Unsafe() { problem2(); } // expected-note {{destructor cannot be inferred 'nonblocking' because it calls non-'nonblocking' function 'Unsafe::problem2'}}
|
|
|
|
Unsafe(int x); // expected-note {{declaration cannot be inferred 'nonblocking' because it has no definition in this translation unit}} expected-note {{declaration cannot be inferred 'nonblocking' because it has no definition in this translation unit}}
|
|
|
|
// Delegating initializer.
|
|
Unsafe(float y) [[clang::nonblocking]] : Unsafe(int(y)) {} // expected-warning {{constructor with 'nonblocking' attribute must not call non-'nonblocking' constructor 'Unsafe::Unsafe'}}
|
|
};
|
|
|
|
struct DerivedFromUnsafe : public Unsafe {
|
|
DerivedFromUnsafe() [[clang::nonblocking]] {} // expected-warning {{constructor with 'nonblocking' attribute must not call non-'nonblocking' constructor 'Unsafe::Unsafe'}}
|
|
DerivedFromUnsafe(int x) [[clang::nonblocking]] : Unsafe(x) {} // expected-warning {{constructor with 'nonblocking' attribute must not call non-'nonblocking' constructor 'Unsafe::Unsafe'}}
|
|
~DerivedFromUnsafe() [[clang::nonblocking]] {} // expected-warning {{destructor with 'nonblocking' attribute must not call non-'nonblocking' destructor 'Unsafe::~Unsafe'}}
|
|
};
|
|
|
|
// Don't try to follow a deleted destructor, as with std::optional<T>.
|
|
struct HasDtor {
|
|
~HasDtor() {}
|
|
};
|
|
|
|
template <typename T>
|
|
struct Optional {
|
|
union {
|
|
char __null_state_;
|
|
T __val_;
|
|
};
|
|
bool engaged = false;
|
|
|
|
~Optional() {
|
|
if (engaged)
|
|
__val_.~T();
|
|
}
|
|
};
|
|
|
|
void nb_opt() [[clang::nonblocking]] {
|
|
Optional<HasDtor> x;
|
|
}
|
|
|
|
// Virtual inheritance
|
|
struct VBase {
|
|
int *Ptr;
|
|
|
|
VBase() { Ptr = new int; } // expected-note {{constructor cannot be inferred 'nonblocking' because it allocates or deallocates memory}}
|
|
virtual ~VBase() { delete Ptr; } // expected-note {{virtual method cannot be inferred 'nonblocking'}}
|
|
};
|
|
|
|
struct VDerived : virtual VBase {
|
|
VDerived() [[clang::nonblocking]] {} // expected-warning {{constructor with 'nonblocking' attribute must not call non-'nonblocking' constructor 'VBase::VBase'}}
|
|
|
|
~VDerived() [[clang::nonblocking]] {} // expected-warning {{destructor with 'nonblocking' attribute must not call non-'nonblocking' destructor 'VBase::~VBase'}}
|
|
};
|
|
|
|
// Contexts where there is no function call, no diagnostic.
|
|
bool bad();
|
|
|
|
template <bool>
|
|
requires requires { bad(); }
|
|
void g() [[clang::nonblocking]] {}
|
|
|
|
void g() [[clang::nonblocking]] {
|
|
decltype(bad()) a; // doesn't generate a call so, OK
|
|
[[maybe_unused]] auto b = noexcept(bad());
|
|
[[maybe_unused]] auto c = sizeof(bad());
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wassume"
|
|
[[assume(bad())]]; // never evaluated, but maybe still semantically questionable?
|
|
#pragma clang diagnostic pop
|
|
}
|
|
|
|
// Make sure we are skipping concept requirements -- they can trigger an unexpected
|
|
// warning involving use of a function pointer (e.g. std::reverse_iterator::operator==
|
|
struct HasFoo { int foo() const { return 0; } };
|
|
|
|
template <class A, class B>
|
|
inline bool compare(const A& a, const B& b)
|
|
requires requires {
|
|
a.foo();
|
|
}
|
|
{
|
|
return a.foo() == b.foo();
|
|
}
|
|
|
|
void nb25() [[clang::nonblocking]] {
|
|
HasFoo a, b;
|
|
compare(a, b);
|
|
}
|
|
|
|
// If the callee is both noreturn and noexcept, it presumably terminates.
|
|
// Ignore it for the purposes of effect analysis.
|
|
[[noreturn]] void abort_wrapper() noexcept;
|
|
|
|
void nb26() [[clang::nonblocking]] {
|
|
abort_wrapper(); // no diagnostic
|
|
}
|
|
|
|
// --- Make sure we don't traverse requires and noexcept clauses. ---
|
|
|
|
// Apparently some requires clauses are able to be collapsed into a constant before the nonblocking
|
|
// analysis sees any function calls. This example (extracted from a real-world case where
|
|
// `operator&&` in <valarray>, preceding the inclusion of <expected>) is sufficiently complex
|
|
// to look like it contains function calls. There may be simpler examples.
|
|
|
|
namespace ExpectedTest {
|
|
|
|
template <class _Tp>
|
|
inline constexpr bool is_copy_constructible_v = __is_constructible(_Tp, _Tp&);
|
|
|
|
template <bool, class _Tp = void>
|
|
struct enable_if {};
|
|
template <class _Tp>
|
|
struct enable_if<true, _Tp> {
|
|
typedef _Tp type;
|
|
};
|
|
|
|
template <bool _Bp, class _Tp = void>
|
|
using enable_if_t = typename enable_if<_Bp, _Tp>::type;
|
|
|
|
// Doesn't seem to matter whether the enable_if is true or false.
|
|
template <class E1, class E2, enable_if_t<is_copy_constructible_v<E1>> = 0>
|
|
inline bool operator&&(const E1& x, const E2& y);
|
|
|
|
template <class _Tp, class _Err>
|
|
class expected {
|
|
public:
|
|
constexpr expected()
|
|
{}
|
|
|
|
// This is a deliberate corruption of the real implementation for simplicity.
|
|
constexpr expected(const expected&)
|
|
requires(is_copy_constructible_v<_Tp> && is_copy_constructible_v<_Err>)
|
|
= default;
|
|
};
|
|
|
|
void test() [[clang::nonblocking]]
|
|
{
|
|
expected<int, int> a;
|
|
auto b = a; // Copy constructor.
|
|
}
|
|
|
|
} // namespace ExpectedTest
|
|
|
|
// Make sure a function call in a noexcept() clause is ignored.
|
|
constexpr bool foo() [[clang::nonblocking(false)]] { return true; }
|
|
void nb27() noexcept(foo()) [[clang::nonblocking]] {}
|
|
|
|
// Make sure that simple type traits don't cause violations.
|
|
void nb28() [[clang::nonblocking]] {
|
|
bool x = __is_constructible(int, const int&);
|
|
}
|
|
|
|
// --- nonblocking implies noexcept ---
|
|
#pragma clang diagnostic warning "-Wperf-constraint-implies-noexcept"
|
|
|
|
void needs_noexcept() [[clang::nonblocking]] // expected-warning {{function with 'nonblocking' attribute should be declared noexcept}}
|
|
{
|
|
auto lambda = []() [[clang::nonblocking]] {}; // expected-warning {{lambda with 'nonblocking' attribute should be declared noexcept}}
|
|
}
|