unityrs_core/version/
parse.rs1use std::iter::Peekable;
6
7use super::Packed;
8use super::packed::significant;
9use crate::error::Error;
10use crate::limits::{Charge, heap_cost};
11
12pub const LIMB_WORK: u64 = 8;
16
17const LIMBS: usize = 226;
20
21pub const MAX_LIMBS: usize = LIMBS;
26
27const CHUNK: u64 = 10_000_000_000_000_000_000;
29
30struct Wide {
34 limbs: [u64; LIMBS],
35 len: usize,
36}
37
38impl Wide {
39 fn zero() -> Self {
40 Self {
41 limbs: [0; LIMBS],
42 len: 0,
43 }
44 }
45
46 fn clear(&mut self) {
48 self.limbs.iter_mut().take(self.len).for_each(|l| *l = 0);
49 self.len = 0;
50 }
51
52 fn used(&self) -> &[u64] {
54 self.limbs.get(..self.len).unwrap_or_default()
55 }
56
57 fn mul_add(&mut self, mul: u64, add: u64, work: &mut Work<'_>) -> Result<(), Error> {
61 let n = (self.len + 1).min(LIMBS);
62 work.step(n)?;
63 let mut carry = u128::from(add);
64 for l in self.limbs.iter_mut().take(n) {
65 let cur = u128::from(*l) * u128::from(mul) + carry;
66 *l = u64::try_from(cur & u128::from(u64::MAX)).unwrap_or(0);
67 carry = cur >> 64;
68 }
69 self.len = significant(self.limbs.get(..n).unwrap_or_default());
70 Ok(())
71 }
72
73 fn or_shifted(&mut self, other: &Self, shift: u32, work: &mut Work<'_>) -> Result<(), Error> {
76 work.step(other.len)?;
77 let bits = shift % 64;
78 for (i, l) in other.used().iter().enumerate() {
79 if let Some(dst) = self.limbs.get_mut(i) {
80 *dst |= l << bits;
81 }
82 if bits > 0
83 && let Some(dst) = self.limbs.get_mut(i + 1)
84 {
85 *dst |= l >> (64 - bits);
86 }
87 }
88 let reach = (other.len + 1).max(self.len).min(LIMBS);
89 self.len = significant(self.limbs.get(..reach).unwrap_or_default());
90 Ok(())
91 }
92}
93
94pub(super) struct Work<'a> {
99 charge: Option<&'a mut Charge>,
100 scanned: u64,
101}
102
103impl<'a> Work<'a> {
104 pub(super) fn new(charge: Option<&'a mut Charge>) -> Self {
105 Self { charge, scanned: 0 }
106 }
107
108 fn scan(&mut self, bytes: usize) {
109 self.scanned = self
110 .scanned
111 .saturating_add(u64::try_from(bytes).unwrap_or(u64::MAX));
112 }
113
114 fn step(&mut self, limbs: usize) -> Result<(), Error> {
118 let pending = u64::try_from(limbs)
119 .unwrap_or(u64::MAX)
120 .saturating_mul(LIMB_WORK);
121 let done = std::mem::take(&mut self.scanned);
122 let Some(charge) = self.charge.as_deref().filter(|_| done > 0 || pending > 0) else {
123 return Ok(());
124 };
125 let meter = charge.meter();
126 meter.count_work(done.saturating_add(pending)).map_err(|e| {
127 meter.add_work(done);
128 Error::Limit(e)
129 })
130 }
131
132 fn finish(&mut self) -> Result<(), Error> {
134 self.step(0)
135 }
136
137 fn charge_heap(&mut self, limbs: usize) -> Result<(), Error> {
139 let Some(charge) = self.charge.as_deref_mut() else {
140 return Ok(());
141 };
142 let bytes = u64::try_from(limbs.saturating_mul(8)).unwrap_or(u64::MAX);
143 Ok(charge.grow(heap_cost(bytes))?)
144 }
145}
146
147#[derive(Clone, Copy)]
150enum Unit {
151 Char(char),
152 Byte,
153}
154
155impl Unit {
156 fn len(self) -> usize {
158 match self {
159 Self::Char(c) => c.len_utf8(),
160 Self::Byte => 1,
161 }
162 }
163}
164
165fn units(bytes: &[u8]) -> impl Iterator<Item = Unit> + '_ {
166 bytes.utf8_chunks().flat_map(|chunk| {
167 chunk
168 .valid()
169 .chars()
170 .map(Unit::Char)
171 .chain(chunk.invalid().iter().map(|_| Unit::Byte))
172 })
173}
174
175fn digit(u: Unit) -> Option<u8> {
176 match u {
177 Unit::Char(c) => crate::tables::nd_digit(c),
178 Unit::Byte => None,
179 }
180}
181
182fn next<I: Iterator<Item = Unit>>(it: &mut Peekable<I>, work: &mut Work<'_>) -> Option<Unit> {
184 let u = it.next()?;
185 work.scan(u.len());
186 Some(u)
187}
188
189fn digits<I: Iterator<Item = Unit>>(
193 it: &mut Peekable<I>,
194 value: &mut Wide,
195 work: &mut Work<'_>,
196) -> Result<Option<usize>, Error> {
197 value.clear();
198 let (mut count, mut chunk, mut chunk_len) = (0usize, 0u64, 0u32);
199 while let Some(d) = it.peek().copied().and_then(digit) {
200 next(it, work);
201 count += 1;
202 if count > super::PY_INT_MAX_STR_DIGITS {
203 return Ok(None);
204 }
205 chunk = chunk * 10 + u64::from(d);
206 chunk_len += 1;
207 if chunk_len == 19 {
208 value.mul_add(CHUNK, chunk, work)?;
209 (chunk, chunk_len) = (0, 0);
210 }
211 }
212 if chunk_len > 0 {
213 value.mul_add(10_u64.pow(chunk_len), chunk, work)?;
214 }
215 Ok(Some(count))
216}
217
218pub(super) fn parse_packed(raw: &[u8], mut work: Work<'_>) -> Result<Option<Packed>, Error> {
226 let got = pack(raw, &mut work);
227 let rest = work.finish();
228 let packed = got?;
229 rest?;
230 let Some(packed) = packed else {
231 return Ok(None);
232 };
233 if packed.len > 2 {
234 work.charge_heap(packed.len)?;
235 }
236 Ok(Some(Packed::from_limbs(packed.used())))
237}
238
239fn pack(raw: &[u8], work: &mut Work<'_>) -> Result<Option<Wide>, Error> {
240 let mut it = units(raw).peekable();
241 let mut packed = Wide::zero();
242 let mut group = Wide::zero();
243 for (i, shift) in [48u32, 32, 16].into_iter().enumerate() {
244 match digits(&mut it, &mut group, work)? {
245 None | Some(0) => return Ok(None),
246 Some(_) => {}
247 }
248 if i < 2 && !matches!(next(&mut it, work), Some(Unit::Char('.'))) {
249 return Ok(None);
250 }
251 packed.or_shifted(&group, shift, work)?;
252 }
253 let ty = match next(&mut it, work) {
257 None => 3u64,
258 Some(unit) => {
259 let ty = match unit {
260 Unit::Char('a' | 'A') => 0,
261 Unit::Char('b' | 'B') => 1,
262 Unit::Char('c' | 'C') => 2,
263 Unit::Char('f' | 'F') => 3,
264 Unit::Char('p' | 'P') => 4,
265 Unit::Char('x' | 'X') => 5,
266 _ => 255,
267 };
268 if digits(&mut it, &mut group, work)?.is_none() {
269 return Ok(None);
270 }
271 packed.or_shifted(&group, 0, work)?;
272 ty
273 }
274 };
275 group.clear();
276 group.mul_add(1, ty, work)?;
277 packed.or_shifted(&group, 8, work)?;
278 Ok(Some(packed))
279}