summaryrefslogtreecommitdiffstats
path: root/meta-python/recipes-devtools/python/python3-pydantic-core/0001-Upgrade-radium-to-1.0.patch
diff options
context:
space:
mode:
authorKhem Raj <raj.khem@gmail.com>2025-04-19 00:17:45 -0700
committerKhem Raj <raj.khem@gmail.com>2025-04-19 14:36:08 -0700
commit055fc16cdade530fe821f856ded9faa2d95fd101 (patch)
tree9b13a1e9786319e494ffe53d0e6496e371297d56 /meta-python/recipes-devtools/python/python3-pydantic-core/0001-Upgrade-radium-to-1.0.patch
parent9cf14c34c09c1f930bec586e56ffc54ca57c3252 (diff)
downloadmeta-openembedded-055fc16cdade530fe821f856ded9faa2d95fd101.tar.gz
python3-pydantic-core: Upgrade to 2.34.1
Fix RISCV-32 builds while here Signed-off-by: Khem Raj <raj.khem@gmail.com>
Diffstat (limited to 'meta-python/recipes-devtools/python/python3-pydantic-core/0001-Upgrade-radium-to-1.0.patch')
-rw-r--r--meta-python/recipes-devtools/python/python3-pydantic-core/0001-Upgrade-radium-to-1.0.patch540
1 files changed, 540 insertions, 0 deletions
diff --git a/meta-python/recipes-devtools/python/python3-pydantic-core/0001-Upgrade-radium-to-1.0.patch b/meta-python/recipes-devtools/python/python3-pydantic-core/0001-Upgrade-radium-to-1.0.patch
new file mode 100644
index 0000000000..00dcd634f2
--- /dev/null
+++ b/meta-python/recipes-devtools/python/python3-pydantic-core/0001-Upgrade-radium-to-1.0.patch
@@ -0,0 +1,540 @@
1From 87753249fb9ac26acd1eb0135fefded871c24e6c Mon Sep 17 00:00:00 2001
2From: Khem Raj <raj.khem@gmail.com>
3Date: Fri, 18 Apr 2025 17:54:42 -0700
4Subject: [PATCH] Upgrade radium to 1.0
5
6Upstream-Status: Submitted [https://github.com/ferrilab/bitvec/pull/220]
7Signed-off-by: Khem Raj <raj.khem@gmail.com>
8---
9 Cargo.toml | 2 +-
10 src/macros/tests.rs | 256 ++++++++++++++++++++++----------------------
11 src/mem.rs | 28 ++---
12 src/serdes.rs | 58 +++++-----
13 src/store.rs | 61 +++++------
14 5 files changed, 207 insertions(+), 198 deletions(-)
15
16--- a/Cargo.toml
17+++ b/Cargo.toml
18@@ -55,7 +55,7 @@ version = "^2.0"
19 default-features = false
20
21 [dependencies.radium]
22-version = "0.7"
23+version = "1"
24
25 [dependencies.serde]
26 version = "1"
27--- a/src/macros/tests.rs
28+++ b/src/macros/tests.rs
29@@ -231,50 +231,52 @@ fn compile_bits() {
30 let _: &BitSlice<u64, Msb0> = bits![u64, crate::order::Msb0; 1; 100];
31 }
32
33- radium::if_atomic! {
34- if atomic(8) {
35- let _: &BitSlice<AtomicU8, LocalBits> = bits![AtomicU8, LocalBits; 0, 1];
36- let _: &BitSlice<AtomicU8, Lsb0> = bits![AtomicU8, Lsb0; 0, 1];
37- let _: &BitSlice<AtomicU8, Msb0> = bits![AtomicU8, Msb0; 0, 1];
38- let _: &BitSlice<RadiumU8, LocalBits> = bits![RadiumU8, LocalBits; 1; 100];
39- let _: &BitSlice<RadiumU8, Lsb0> = bits![RadiumU8, Lsb0; 1; 100];
40- let _: &BitSlice<RadiumU8, Msb0> = bits![RadiumU8, Msb0; 1; 100];
41- }
42- if atomic(16) {
43- let _: &BitSlice<AtomicU16, LocalBits> = bits![AtomicU16, LocalBits; 0, 1];
44- let _: &BitSlice<AtomicU16, Lsb0> = bits![AtomicU16, Lsb0; 0, 1];
45- let _: &BitSlice<AtomicU16, Msb0> = bits![AtomicU16, Msb0; 0, 1];
46- let _: &BitSlice<RadiumU16, LocalBits> = bits![RadiumU16, LocalBits; 1; 100];
47- let _: &BitSlice<RadiumU16, Lsb0> = bits![RadiumU16, Lsb0; 1; 100];
48- let _: &BitSlice<RadiumU16, Msb0> = bits![RadiumU16, Msb0; 1; 100];
49- }
50- if atomic(32) {
51- let _: &BitSlice<AtomicU32, LocalBits> = bits![AtomicU32, LocalBits; 0, 1];
52- let _: &BitSlice<AtomicU32, Lsb0> = bits![AtomicU32, Lsb0; 0, 1];
53- let _: &BitSlice<AtomicU32, Msb0> = bits![AtomicU32, Msb0; 0, 1];
54- let _: &BitSlice<RadiumU32, LocalBits> = bits![RadiumU32, LocalBits; 1; 100];
55- let _: &BitSlice<RadiumU32, Lsb0> = bits![RadiumU32, Lsb0; 1; 100];
56- let _: &BitSlice<RadiumU32, Msb0> = bits![RadiumU32, Msb0; 1; 100];
57- }
58- if atomic(size) {
59- let _: &BitSlice<AtomicUsize, LocalBits> = bits![AtomicUsize, LocalBits; 0, 1];
60- let _: &BitSlice<AtomicUsize, Lsb0> = bits![AtomicUsize, Lsb0; 0, 1];
61- let _: &BitSlice<AtomicUsize, Msb0> = bits![AtomicUsize, Msb0; 0, 1];
62- let _: &BitSlice<RadiumUsize, LocalBits> = bits![RadiumUsize, LocalBits; 1; 100];
63- let _: &BitSlice<RadiumUsize, Lsb0> = bits![RadiumUsize, Lsb0; 1; 100];
64- let _: &BitSlice<RadiumUsize, Msb0> = bits![RadiumUsize, Msb0; 1; 100];
65- }
66+ #[cfg(target_has_atomic = "8")]
67+ {
68+ let _: &BitSlice<AtomicU8, LocalBits> = bits![AtomicU8, LocalBits; 0, 1];
69+ let _: &BitSlice<AtomicU8, Lsb0> = bits![AtomicU8, Lsb0; 0, 1];
70+ let _: &BitSlice<AtomicU8, Msb0> = bits![AtomicU8, Msb0; 0, 1];
71+ let _: &BitSlice<RadiumU8, LocalBits> = bits![RadiumU8, LocalBits; 1; 100];
72+ let _: &BitSlice<RadiumU8, Lsb0> = bits![RadiumU8, Lsb0; 1; 100];
73+ let _: &BitSlice<RadiumU8, Msb0> = bits![RadiumU8, Msb0; 1; 100];
74+ }
75+ #[cfg(target_has_atomic = "16")]
76+ {
77+ let _: &BitSlice<AtomicU16, LocalBits> = bits![AtomicU16, LocalBits; 0, 1];
78+ let _: &BitSlice<AtomicU16, Lsb0> = bits![AtomicU16, Lsb0; 0, 1];
79+ let _: &BitSlice<AtomicU16, Msb0> = bits![AtomicU16, Msb0; 0, 1];
80+ let _: &BitSlice<RadiumU16, LocalBits> = bits![RadiumU16, LocalBits; 1; 100];
81+ let _: &BitSlice<RadiumU16, Lsb0> = bits![RadiumU16, Lsb0; 1; 100];
82+ let _: &BitSlice<RadiumU16, Msb0> = bits![RadiumU16, Msb0; 1; 100];
83+ }
84+ #[cfg(target_has_atomic = "32")]
85+ {
86+ let _: &BitSlice<AtomicU32, LocalBits> = bits![AtomicU32, LocalBits; 0, 1];
87+ let _: &BitSlice<AtomicU32, Lsb0> = bits![AtomicU32, Lsb0; 0, 1];
88+ let _: &BitSlice<AtomicU32, Msb0> = bits![AtomicU32, Msb0; 0, 1];
89+ let _: &BitSlice<RadiumU32, LocalBits> = bits![RadiumU32, LocalBits; 1; 100];
90+ let _: &BitSlice<RadiumU32, Lsb0> = bits![RadiumU32, Lsb0; 1; 100];
91+ let _: &BitSlice<RadiumU32, Msb0> = bits![RadiumU32, Msb0; 1; 100];
92+ }
93+ #[cfg(target_has_atomic = "ptr")]
94+ {
95+ let _: &BitSlice<AtomicUsize, LocalBits> = bits![AtomicUsize, LocalBits; 0, 1];
96+ let _: &BitSlice<AtomicUsize, Lsb0> = bits![AtomicUsize, Lsb0; 0, 1];
97+ let _: &BitSlice<AtomicUsize, Msb0> = bits![AtomicUsize, Msb0; 0, 1];
98+ let _: &BitSlice<RadiumUsize, LocalBits> = bits![RadiumUsize, LocalBits; 1; 100];
99+ let _: &BitSlice<RadiumUsize, Lsb0> = bits![RadiumUsize, Lsb0; 1; 100];
100+ let _: &BitSlice<RadiumUsize, Msb0> = bits![RadiumUsize, Msb0; 1; 100];
101 }
102+
103 #[cfg(target_pointer_width = "64")]
104- radium::if_atomic! {
105- if atomic(64) {
106- let _: &BitSlice<AtomicU64, LocalBits> = bits![AtomicU64, LocalBits; 0, 1];
107- let _: &BitSlice<AtomicU64, Lsb0> = bits![AtomicU64, Lsb0; 0, 1];
108- let _: &BitSlice<AtomicU64, Msb0> = bits![AtomicU64, Msb0; 0, 1];
109- let _: &BitSlice<RadiumU64, LocalBits> = bits![RadiumU64, LocalBits; 1; 100];
110- let _: &BitSlice<RadiumU64, Lsb0> = bits![RadiumU64, Lsb0; 1; 100];
111- let _: &BitSlice<RadiumU64, Msb0> = bits![RadiumU64, Msb0; 1; 100];
112- }
113+ #[cfg(target_has_atomic = "64")]
114+ {
115+ let _: &BitSlice<AtomicU64, LocalBits> = bits![AtomicU64, LocalBits; 0, 1];
116+ let _: &BitSlice<AtomicU64, Lsb0> = bits![AtomicU64, Lsb0; 0, 1];
117+ let _: &BitSlice<AtomicU64, Msb0> = bits![AtomicU64, Msb0; 0, 1];
118+ let _: &BitSlice<RadiumU64, LocalBits> = bits![RadiumU64, LocalBits; 1; 100];
119+ let _: &BitSlice<RadiumU64, Lsb0> = bits![RadiumU64, Lsb0; 1; 100];
120+ let _: &BitSlice<RadiumU64, Msb0> = bits![RadiumU64, Msb0; 1; 100];
121 }
122 }
123
124@@ -346,50 +348,51 @@ fn compile_bitvec() {
125 bitvec![Cell<u64>, crate::order::Msb0; 1; 100];
126 let _: BitVec<u64, Msb0> = bitvec![u64, crate::order::Msb0; 1; 100];
127 }
128- radium::if_atomic! {
129- if atomic(8) {
130- let _: BitVec<AtomicU8, LocalBits> =bitvec![AtomicU8, LocalBits; 0, 1];
131- let _: BitVec<AtomicU8, Lsb0> =bitvec![AtomicU8, Lsb0; 0, 1];
132- let _: BitVec<AtomicU8, Msb0> =bitvec![AtomicU8, Msb0; 0, 1];
133- let _: BitVec<RadiumU8, LocalBits> =bitvec![RadiumU8, LocalBits; 1; 100];
134- let _: BitVec<RadiumU8, Lsb0> =bitvec![RadiumU8, Lsb0; 1; 100];
135- let _: BitVec<RadiumU8, Msb0> =bitvec![RadiumU8, Msb0; 1; 100];
136- }
137- if atomic(16) {
138- let _: BitVec<AtomicU16, LocalBits> =bitvec![AtomicU16, LocalBits; 0, 1];
139- let _: BitVec<AtomicU16, Lsb0> =bitvec![AtomicU16, Lsb0; 0, 1];
140- let _: BitVec<AtomicU16, Msb0> =bitvec![AtomicU16, Msb0; 0, 1];
141- let _: BitVec<RadiumU16, LocalBits> =bitvec![RadiumU16, LocalBits; 1; 100];
142- let _: BitVec<RadiumU16, Lsb0> =bitvec![RadiumU16, Lsb0; 1; 100];
143- let _: BitVec<RadiumU16, Msb0> =bitvec![RadiumU16, Msb0; 1; 100];
144- }
145- if atomic(32) {
146- let _: BitVec<AtomicU32, LocalBits> =bitvec![AtomicU32, LocalBits; 0, 1];
147- let _: BitVec<AtomicU32, Lsb0> =bitvec![AtomicU32, Lsb0; 0, 1];
148- let _: BitVec<AtomicU32, Msb0> =bitvec![AtomicU32, Msb0; 0, 1];
149- let _: BitVec<RadiumU32, LocalBits> =bitvec![RadiumU32, LocalBits; 1; 100];
150- let _: BitVec<RadiumU32, Lsb0> =bitvec![RadiumU32, Lsb0; 1; 100];
151- let _: BitVec<RadiumU32, Msb0> =bitvec![RadiumU32, Msb0; 1; 100];
152- }
153- if atomic(size) {
154- let _: BitVec<AtomicUsize, LocalBits> =bitvec![AtomicUsize, LocalBits; 0, 1];
155- let _: BitVec<AtomicUsize, Lsb0> =bitvec![AtomicUsize, Lsb0; 0, 1];
156- let _: BitVec<AtomicUsize, Msb0> =bitvec![AtomicUsize, Msb0; 0, 1];
157- let _: BitVec<RadiumUsize, LocalBits> =bitvec![RadiumUsize, LocalBits; 1; 100];
158- let _: BitVec<RadiumUsize, Lsb0> =bitvec![RadiumUsize, Lsb0; 1; 100];
159- let _: BitVec<RadiumUsize, Msb0> =bitvec![RadiumUsize, Msb0; 1; 100];
160- }
161+ #[cfg(target_has_atomic = "8")]
162+ {
163+ let _: BitVec<AtomicU8, LocalBits> =bitvec![AtomicU8, LocalBits; 0, 1];
164+ let _: BitVec<AtomicU8, Lsb0> =bitvec![AtomicU8, Lsb0; 0, 1];
165+ let _: BitVec<AtomicU8, Msb0> =bitvec![AtomicU8, Msb0; 0, 1];
166+ let _: BitVec<RadiumU8, LocalBits> =bitvec![RadiumU8, LocalBits; 1; 100];
167+ let _: BitVec<RadiumU8, Lsb0> =bitvec![RadiumU8, Lsb0; 1; 100];
168+ let _: BitVec<RadiumU8, Msb0> =bitvec![RadiumU8, Msb0; 1; 100];
169+ }
170+ #[cfg(target_has_atomic = "16")]
171+ {
172+ let _: BitVec<AtomicU16, LocalBits> =bitvec![AtomicU16, LocalBits; 0, 1];
173+ let _: BitVec<AtomicU16, Lsb0> =bitvec![AtomicU16, Lsb0; 0, 1];
174+ let _: BitVec<AtomicU16, Msb0> =bitvec![AtomicU16, Msb0; 0, 1];
175+ let _: BitVec<RadiumU16, LocalBits> =bitvec![RadiumU16, LocalBits; 1; 100];
176+ let _: BitVec<RadiumU16, Lsb0> =bitvec![RadiumU16, Lsb0; 1; 100];
177+ let _: BitVec<RadiumU16, Msb0> =bitvec![RadiumU16, Msb0; 1; 100];
178+ }
179+ #[cfg(target_has_atomic = "32")]
180+ {
181+ let _: BitVec<AtomicU32, LocalBits> =bitvec![AtomicU32, LocalBits; 0, 1];
182+ let _: BitVec<AtomicU32, Lsb0> =bitvec![AtomicU32, Lsb0; 0, 1];
183+ let _: BitVec<AtomicU32, Msb0> =bitvec![AtomicU32, Msb0; 0, 1];
184+ let _: BitVec<RadiumU32, LocalBits> =bitvec![RadiumU32, LocalBits; 1; 100];
185+ let _: BitVec<RadiumU32, Lsb0> =bitvec![RadiumU32, Lsb0; 1; 100];
186+ let _: BitVec<RadiumU32, Msb0> =bitvec![RadiumU32, Msb0; 1; 100];
187+ }
188+ #[cfg(target_has_atomic = "ptr")]
189+ {
190+ let _: BitVec<AtomicUsize, LocalBits> =bitvec![AtomicUsize, LocalBits; 0, 1];
191+ let _: BitVec<AtomicUsize, Lsb0> =bitvec![AtomicUsize, Lsb0; 0, 1];
192+ let _: BitVec<AtomicUsize, Msb0> =bitvec![AtomicUsize, Msb0; 0, 1];
193+ let _: BitVec<RadiumUsize, LocalBits> =bitvec![RadiumUsize, LocalBits; 1; 100];
194+ let _: BitVec<RadiumUsize, Lsb0> =bitvec![RadiumUsize, Lsb0; 1; 100];
195+ let _: BitVec<RadiumUsize, Msb0> =bitvec![RadiumUsize, Msb0; 1; 100];
196 }
197 #[cfg(target_pointer_width = "64")]
198- radium::if_atomic! {
199- if atomic(64) {
200- let _: BitVec<AtomicU64, LocalBits> =bitvec![AtomicU64, LocalBits; 0, 1];
201- let _: BitVec<AtomicU64, Lsb0> =bitvec![AtomicU64, Lsb0; 0, 1];
202- let _: BitVec<AtomicU64, Msb0> =bitvec![AtomicU64, Msb0; 0, 1];
203- let _: BitVec<RadiumU64, LocalBits> =bitvec![RadiumU64, LocalBits; 1; 100];
204- let _: BitVec<RadiumU64, Lsb0> =bitvec![RadiumU64, Lsb0; 1; 100];
205- let _: BitVec<RadiumU64, Msb0> =bitvec![RadiumU64, Msb0; 1; 100];
206- }
207+ #[cfg(target_has_atomic = "64")]
208+ {
209+ let _: BitVec<AtomicU64, LocalBits> =bitvec![AtomicU64, LocalBits; 0, 1];
210+ let _: BitVec<AtomicU64, Lsb0> =bitvec![AtomicU64, Lsb0; 0, 1];
211+ let _: BitVec<AtomicU64, Msb0> =bitvec![AtomicU64, Msb0; 0, 1];
212+ let _: BitVec<RadiumU64, LocalBits> =bitvec![RadiumU64, LocalBits; 1; 100];
213+ let _: BitVec<RadiumU64, Lsb0> =bitvec![RadiumU64, Lsb0; 1; 100];
214+ let _: BitVec<RadiumU64, Msb0> =bitvec![RadiumU64, Msb0; 1; 100];
215 }
216 }
217
218@@ -461,50 +464,51 @@ fn compile_bitbox() {
219 bitbox![Cell<u64>, crate::order::Msb0; 1; 100];
220 let _: BitBox<u64, Msb0> = bitbox![u64, crate::order::Msb0; 1; 100];
221 }
222- radium::if_atomic! {
223- if atomic(8) {
224- let _: BitBox<AtomicU8, LocalBits> =bitbox![AtomicU8, LocalBits; 0, 1];
225- let _: BitBox<AtomicU8, Lsb0> =bitbox![AtomicU8, Lsb0; 0, 1];
226- let _: BitBox<AtomicU8, Msb0> =bitbox![AtomicU8, Msb0; 0, 1];
227- let _: BitBox<RadiumU8, LocalBits> =bitbox![RadiumU8, LocalBits; 1; 100];
228- let _: BitBox<RadiumU8, Lsb0> =bitbox![RadiumU8, Lsb0; 1; 100];
229- let _: BitBox<RadiumU8, Msb0> =bitbox![RadiumU8, Msb0; 1; 100];
230- }
231- if atomic(16) {
232- let _: BitBox<AtomicU16, LocalBits> =bitbox![AtomicU16, LocalBits; 0, 1];
233- let _: BitBox<AtomicU16, Lsb0> =bitbox![AtomicU16, Lsb0; 0, 1];
234- let _: BitBox<AtomicU16, Msb0> =bitbox![AtomicU16, Msb0; 0, 1];
235- let _: BitBox<RadiumU16, LocalBits> =bitbox![RadiumU16, LocalBits; 1; 100];
236- let _: BitBox<RadiumU16, Lsb0> =bitbox![RadiumU16, Lsb0; 1; 100];
237- let _: BitBox<RadiumU16, Msb0> =bitbox![RadiumU16, Msb0; 1; 100];
238- }
239- if atomic(32) {
240- let _: BitBox<AtomicU32, LocalBits> =bitbox![AtomicU32, LocalBits; 0, 1];
241- let _: BitBox<AtomicU32, Lsb0> =bitbox![AtomicU32, Lsb0; 0, 1];
242- let _: BitBox<AtomicU32, Msb0> =bitbox![AtomicU32, Msb0; 0, 1];
243- let _: BitBox<RadiumU32, LocalBits> =bitbox![RadiumU32, LocalBits; 1; 100];
244- let _: BitBox<RadiumU32, Lsb0> =bitbox![RadiumU32, Lsb0; 1; 100];
245- let _: BitBox<RadiumU32, Msb0> =bitbox![RadiumU32, Msb0; 1; 100];
246- }
247- if atomic(size) {
248- let _: BitBox<AtomicUsize, LocalBits> =bitbox![AtomicUsize, LocalBits; 0, 1];
249- let _: BitBox<AtomicUsize, Lsb0> =bitbox![AtomicUsize, Lsb0; 0, 1];
250- let _: BitBox<AtomicUsize, Msb0> =bitbox![AtomicUsize, Msb0; 0, 1];
251- let _: BitBox<RadiumUsize, LocalBits> =bitbox![RadiumUsize, LocalBits; 1; 100];
252- let _: BitBox<RadiumUsize, Lsb0> =bitbox![RadiumUsize, Lsb0; 1; 100];
253- let _: BitBox<RadiumUsize, Msb0> =bitbox![RadiumUsize, Msb0; 1; 100];
254- }
255+ #[cfg(target_has_atomic = "8")]
256+ {
257+ let _: BitBox<AtomicU8, LocalBits> =bitbox![AtomicU8, LocalBits; 0, 1];
258+ let _: BitBox<AtomicU8, Lsb0> =bitbox![AtomicU8, Lsb0; 0, 1];
259+ let _: BitBox<AtomicU8, Msb0> =bitbox![AtomicU8, Msb0; 0, 1];
260+ let _: BitBox<RadiumU8, LocalBits> =bitbox![RadiumU8, LocalBits; 1; 100];
261+ let _: BitBox<RadiumU8, Lsb0> =bitbox![RadiumU8, Lsb0; 1; 100];
262+ let _: BitBox<RadiumU8, Msb0> =bitbox![RadiumU8, Msb0; 1; 100];
263+ }
264+ #[cfg(target_has_atomic = "16")]
265+ {
266+ let _: BitBox<AtomicU16, LocalBits> =bitbox![AtomicU16, LocalBits; 0, 1];
267+ let _: BitBox<AtomicU16, Lsb0> =bitbox![AtomicU16, Lsb0; 0, 1];
268+ let _: BitBox<AtomicU16, Msb0> =bitbox![AtomicU16, Msb0; 0, 1];
269+ let _: BitBox<RadiumU16, LocalBits> =bitbox![RadiumU16, LocalBits; 1; 100];
270+ let _: BitBox<RadiumU16, Lsb0> =bitbox![RadiumU16, Lsb0; 1; 100];
271+ let _: BitBox<RadiumU16, Msb0> =bitbox![RadiumU16, Msb0; 1; 100];
272+ }
273+ #[cfg(target_has_atomic = "32")]
274+ {
275+ let _: BitBox<AtomicU32, LocalBits> =bitbox![AtomicU32, LocalBits; 0, 1];
276+ let _: BitBox<AtomicU32, Lsb0> =bitbox![AtomicU32, Lsb0; 0, 1];
277+ let _: BitBox<AtomicU32, Msb0> =bitbox![AtomicU32, Msb0; 0, 1];
278+ let _: BitBox<RadiumU32, LocalBits> =bitbox![RadiumU32, LocalBits; 1; 100];
279+ let _: BitBox<RadiumU32, Lsb0> =bitbox![RadiumU32, Lsb0; 1; 100];
280+ let _: BitBox<RadiumU32, Msb0> =bitbox![RadiumU32, Msb0; 1; 100];
281+ }
282+ #[cfg(target_has_atomic = "ptr")]
283+ {
284+ let _: BitBox<AtomicUsize, LocalBits> =bitbox![AtomicUsize, LocalBits; 0, 1];
285+ let _: BitBox<AtomicUsize, Lsb0> =bitbox![AtomicUsize, Lsb0; 0, 1];
286+ let _: BitBox<AtomicUsize, Msb0> =bitbox![AtomicUsize, Msb0; 0, 1];
287+ let _: BitBox<RadiumUsize, LocalBits> =bitbox![RadiumUsize, LocalBits; 1; 100];
288+ let _: BitBox<RadiumUsize, Lsb0> =bitbox![RadiumUsize, Lsb0; 1; 100];
289+ let _: BitBox<RadiumUsize, Msb0> =bitbox![RadiumUsize, Msb0; 1; 100];
290 }
291 #[cfg(target_pointer_width = "64")]
292- radium::if_atomic! {
293- if atomic(64) {
294- let _: BitBox<AtomicU64, LocalBits> =bitbox![AtomicU64, LocalBits; 0, 1];
295- let _: BitBox<AtomicU64, Lsb0> =bitbox![AtomicU64, Lsb0; 0, 1];
296- let _: BitBox<AtomicU64, Msb0> =bitbox![AtomicU64, Msb0; 0, 1];
297- let _: BitBox<RadiumU64, LocalBits> =bitbox![RadiumU64, LocalBits; 1; 100];
298- let _: BitBox<RadiumU64, Lsb0> =bitbox![RadiumU64, Lsb0; 1; 100];
299- let _: BitBox<RadiumU64, Msb0> =bitbox![RadiumU64, Msb0; 1; 100];
300- }
301+ #[cfg(target_has_atomic = "64")]
302+ {
303+ let _: BitBox<AtomicU64, LocalBits> =bitbox![AtomicU64, LocalBits; 0, 1];
304+ let _: BitBox<AtomicU64, Lsb0> =bitbox![AtomicU64, Lsb0; 0, 1];
305+ let _: BitBox<AtomicU64, Msb0> =bitbox![AtomicU64, Msb0; 0, 1];
306+ let _: BitBox<RadiumU64, LocalBits> =bitbox![RadiumU64, LocalBits; 1; 100];
307+ let _: BitBox<RadiumU64, Lsb0> =bitbox![RadiumU64, Lsb0; 1; 100];
308+ let _: BitBox<RadiumU64, Msb0> =bitbox![RadiumU64, Msb0; 1; 100];
309 }
310 }
311
312--- a/src/mem.rs
313+++ b/src/mem.rs
314@@ -101,30 +101,30 @@ macro_rules! element {
315 }
316 }
317
318- radium::if_atomic!( if atomic($size) {
319- use core::sync::atomic::$atom;
320- impl BitElement<$atom> {
321- /// Creates a new element wrapper from a raw integer.
322- pub const fn new(elem: $bare) -> Self {
323- Self {
324- elem: <$atom>::new(elem),
325- }
326+ #[cfg(target_has_atomic = $size)]
327+ use core::sync::atomic::$atom;
328+ #[cfg(target_has_atomic = $size)]
329+ impl BitElement<$atom> {
330+ /// Creates a new element wrapper from a raw integer.
331+ pub const fn new(elem: $bare) -> Self {
332+ Self {
333+ elem: <$atom>::new(elem),
334 }
335 }
336- });
337+ }
338 )+ };
339 }
340
341 element! {
342- 8, u8 => AtomicU8;
343- 16, u16 => AtomicU16;
344- 32, u32 => AtomicU32;
345+ "8", u8 => AtomicU8;
346+ "16", u16 => AtomicU16;
347+ "32", u32 => AtomicU32;
348 }
349
350 #[cfg(target_pointer_width = "64")]
351-element!(64, u64 => AtomicU64);
352+element!("64", u64 => AtomicU64);
353
354-element!(size, usize => AtomicUsize);
355+element!("ptr", usize => AtomicUsize);
356
357 #[cfg(test)]
358 mod tests {
359--- a/src/serdes.rs
360+++ b/src/serdes.rs
361@@ -112,36 +112,39 @@ mod tests {
362 Msb0 @ RadiumU8, RadiumU16, RadiumU32, RadiumUsize;
363 LocalBits @ RadiumU8, RadiumU16, RadiumU32, RadiumUsize;
364 }
365- radium::if_atomic! {
366- if atomic(8) {
367- check_impl! {
368- Lsb0 @ AtomicU8;
369- Msb0 @ AtomicU8;
370- LocalBits @ AtomicU8;
371- }
372+ #[cfg(target_has_atomic = "8")]
373+ {
374+ check_impl! {
375+ Lsb0 @ AtomicU8;
376+ Msb0 @ AtomicU8;
377+ LocalBits @ AtomicU8;
378 }
379- if atomic(16) {
380- check_impl! {
381- Lsb0 @ AtomicU16;
382- Msb0 @ AtomicU16;
383- LocalBits @ AtomicU16;
384- }
385+ }
386+ #[cfg(target_has_atomic = "16")]
387+ {
388+ check_impl! {
389+ Lsb0 @ AtomicU16;
390+ Msb0 @ AtomicU16;
391+ LocalBits @ AtomicU16;
392 }
393- if atomic(32) {
394- check_impl! {
395- Lsb0 @ AtomicU32;
396- Msb0 @ AtomicU32;
397- LocalBits @ AtomicU32;
398- }
399+ }
400+ #[cfg(target_has_atomic = "32")]
401+ {
402+ check_impl! {
403+ Lsb0 @ AtomicU32;
404+ Msb0 @ AtomicU32;
405+ LocalBits @ AtomicU32;
406 }
407- if atomic(ptr) {
408- check_impl! {
409- Lsb0 @ AtomicUsize;
410- Msb0 @ AtomicUsize;
411- LocalBits @ AtomicUsize;
412- }
413+ }
414+ #[cfg(target_has_atomic = "ptr")]
415+ {
416+ check_impl! {
417+ Lsb0 @ AtomicUsize;
418+ Msb0 @ AtomicUsize;
419+ LocalBits @ AtomicUsize;
420 }
421 }
422+
423 #[cfg(target_pointer_width = "64")]
424 check_impl! {
425 Lsb0 @ u64, RadiumU64;
426@@ -149,12 +152,13 @@ mod tests {
427 LocalBits @ u64, RadiumU64;
428 }
429 #[cfg(target_pointer_width = "64")]
430- radium::if_atomic!(if atomic(64) {
431+ #[cfg(target_has_atomic = "64")]
432+ {
433 check_impl! {
434 Lsb0 @ AtomicU64;
435 Msb0 @ AtomicU64;
436 LocalBits @ AtomicU64;
437 }
438- });
439+ }
440 }
441 }
442--- a/src/store.rs
443+++ b/src/store.rs
444@@ -199,49 +199,49 @@ store!(usize => BitSafeUsize);
445 /// Generates `BitStore` implementations for atomic types.
446 macro_rules! atomic {
447 ($($size:tt, $base:ty => $atom:ident);+ $(;)?) => { $(
448- radium::if_atomic!(if atomic($size) {
449- use core::sync::atomic::$atom;
450+ #[cfg(target_has_atomic = $size)]
451+ use core::sync::atomic::$atom;
452
453- impl BitStore for $atom {
454- type Mem = $base;
455- type Access = Self;
456- type Alias = Self;
457- type Unalias = Self;
458-
459- const ZERO: Self = <Self>::new(0);
460-
461- #[inline]
462- fn new(value: Self::Mem) -> Self { <Self>::new(value) }
463-
464- #[inline]
465- fn load_value(&self) -> Self::Mem {
466- self.load(core::sync::atomic::Ordering::Relaxed)
467- }
468-
469- #[inline]
470- fn store_value(&mut self, value: Self::Mem) {
471- *self = Self::new(value);
472- }
473-
474- const ALIGNED_TO_SIZE: [(); 1]
475- = [(); mem::aligned_to_size::<Self>() as usize];
476+ #[cfg(target_has_atomic = $size)]
477+ impl BitStore for $atom {
478+ type Mem = $base;
479+ type Access = Self;
480+ type Alias = Self;
481+ type Unalias = Self;
482+
483+ const ZERO: Self = <Self>::new(0);
484+
485+ #[inline]
486+ fn new(value: Self::Mem) -> Self { <Self>::new(value) }
487+
488+ #[inline]
489+ fn load_value(&self) -> Self::Mem {
490+ self.load(core::sync::atomic::Ordering::Relaxed)
491+ }
492
493- const ALIAS_WIDTH: [(); 1] = [()];
494+ #[inline]
495+ fn store_value(&mut self, value: Self::Mem) {
496+ *self = Self::new(value);
497 }
498- });
499+
500+ const ALIGNED_TO_SIZE: [(); 1]
501+ = [(); mem::aligned_to_size::<Self>() as usize];
502+
503+ const ALIAS_WIDTH: [(); 1] = [()];
504+ }
505 )+ };
506 }
507
508 atomic! {
509- 8, u8 => AtomicU8;
510- 16, u16 => AtomicU16;
511- 32, u32 => AtomicU32;
512+ "8", u8 => AtomicU8;
513+ "16", u16 => AtomicU16;
514+ "32", u32 => AtomicU32;
515 }
516
517 #[cfg(target_pointer_width = "64")]
518-atomic!(64, u64 => AtomicU64);
519+atomic!("64", u64 => AtomicU64);
520
521-atomic!(size, usize => AtomicUsize);
522+atomic!("ptr", usize => AtomicUsize);
523
524 #[cfg(test)]
525 mod tests {
526@@ -265,11 +265,12 @@ mod tests {
527 cell.store_value(39);
528 assert_eq!(cell.load_value(), 39);
529
530- radium::if_atomic!(if atomic(size) {
531+ #[cfg(target_has_atomic = "ptr")]
532+ {
533 let mut atom = AtomicUsize::new(0);
534 atom.store_value(57);
535 assert_eq!(atom.load_value(), 57);
536- });
537+ }
538 }
539
540 /// Unaliased `BitSlice`s are universally threadsafe, because they satisfy
generated by cgit v1.2.3-54-g00ecf (git 2.39.0) at 2025-11-01 09:53:53 +0000