sv_parser_parser/expressions/
numbers.rs

1use crate::*;
2
3// -----------------------------------------------------------------------------
4
5#[tracable_parser]
6#[packrat_parser]
7pub(crate) fn number(s: Span) -> IResult<Span, Number> {
8    alt((
9        map(real_number, |x| Number::RealNumber(Box::new(x))),
10        map(integral_number, |x| Number::IntegralNumber(Box::new(x))),
11    ))(s)
12}
13
14#[tracable_parser]
15#[packrat_parser]
16pub(crate) fn integral_number(s: Span) -> IResult<Span, IntegralNumber> {
17    alt((
18        map(octal_number, |x| IntegralNumber::OctalNumber(Box::new(x))),
19        map(binary_number, |x| IntegralNumber::BinaryNumber(Box::new(x))),
20        map(hex_number, |x| IntegralNumber::HexNumber(Box::new(x))),
21        map(decimal_number, |x| {
22            IntegralNumber::DecimalNumber(Box::new(x))
23        }),
24    ))(s)
25}
26
27#[tracable_parser]
28#[packrat_parser]
29pub(crate) fn decimal_number(s: Span) -> IResult<Span, DecimalNumber> {
30    alt((
31        decimal_number_base_unsigned,
32        decimal_number_base_x_number,
33        decimal_number_base_z_number,
34        map(unsigned_number, |x| {
35            DecimalNumber::UnsignedNumber(Box::new(x))
36        }),
37    ))(s)
38}
39
40#[tracable_parser]
41#[packrat_parser]
42pub(crate) fn decimal_number_base_unsigned(s: Span) -> IResult<Span, DecimalNumber> {
43    let (s, a) = opt(size)(s)?;
44    let (s, b) = decimal_base(s)?;
45    let (s, c) = unsigned_number(s)?;
46    Ok((
47        s,
48        DecimalNumber::BaseUnsigned(Box::new(DecimalNumberBaseUnsigned { nodes: (a, b, c) })),
49    ))
50}
51
52#[tracable_parser]
53#[packrat_parser]
54pub(crate) fn decimal_number_base_x_number(s: Span) -> IResult<Span, DecimalNumber> {
55    let (s, a) = opt(size)(s)?;
56    let (s, b) = decimal_base(s)?;
57    let (s, c) = x_number(s)?;
58    Ok((
59        s,
60        DecimalNumber::BaseXNumber(Box::new(DecimalNumberBaseXNumber { nodes: (a, b, c) })),
61    ))
62}
63
64#[tracable_parser]
65#[packrat_parser]
66pub(crate) fn decimal_number_base_z_number(s: Span) -> IResult<Span, DecimalNumber> {
67    let (s, a) = opt(size)(s)?;
68    let (s, b) = decimal_base(s)?;
69    let (s, c) = z_number(s)?;
70    Ok((
71        s,
72        DecimalNumber::BaseZNumber(Box::new(DecimalNumberBaseZNumber { nodes: (a, b, c) })),
73    ))
74}
75
76#[tracable_parser]
77#[packrat_parser]
78pub(crate) fn binary_number(s: Span) -> IResult<Span, BinaryNumber> {
79    let (s, a) = opt(size)(s)?;
80    let (s, b) = binary_base(s)?;
81    let (s, c) = binary_value(s)?;
82    Ok((s, BinaryNumber { nodes: (a, b, c) }))
83}
84
85#[tracable_parser]
86#[packrat_parser]
87pub(crate) fn octal_number(s: Span) -> IResult<Span, OctalNumber> {
88    let (s, a) = opt(size)(s)?;
89    let (s, b) = octal_base(s)?;
90    let (s, c) = octal_value(s)?;
91    Ok((s, OctalNumber { nodes: (a, b, c) }))
92}
93
94#[tracable_parser]
95#[packrat_parser]
96pub(crate) fn hex_number(s: Span) -> IResult<Span, HexNumber> {
97    let (s, a) = opt(size)(s)?;
98    let (s, b) = hex_base(s)?;
99    let (s, c) = hex_value(s)?;
100    Ok((s, HexNumber { nodes: (a, b, c) }))
101}
102
103#[tracable_parser]
104#[packrat_parser]
105pub(crate) fn sign(s: Span) -> IResult<Span, Sign> {
106    alt((
107        map(
108            map(tag("+"), |x: Span| Symbol {
109                nodes: (into_locate(x), vec![]),
110            }),
111            |x| Sign::Plus(Box::new(x)),
112        ),
113        map(
114            map(tag("-"), |x: Span| Symbol {
115                nodes: (into_locate(x), vec![]),
116            }),
117            |x| Sign::Minus(Box::new(x)),
118        ),
119    ))(s)
120}
121
122#[tracable_parser]
123#[packrat_parser]
124pub(crate) fn size(s: Span) -> IResult<Span, Size> {
125    let (s, a) = non_zero_unsigned_number(s)?;
126    Ok((s, Size { nodes: (a,) }))
127}
128
129#[tracable_parser]
130#[packrat_parser]
131pub(crate) fn non_zero_unsigned_number(s: Span) -> IResult<Span, NonZeroUnsignedNumber> {
132    let (s, a) = ws(non_zero_unsigned_number_impl)(s)?;
133    Ok((s, NonZeroUnsignedNumber { nodes: a }))
134}
135
136#[tracable_parser]
137pub(crate) fn non_zero_unsigned_number_impl(s: Span) -> IResult<Span, Locate> {
138    let (s, a) = is_a("123456789")(s)?;
139    let (s, a) = fold_many0(
140        alt((tag("_"), digit1)),
141        || a,
142        |acc, item| concat(acc, item).unwrap(),
143    )(s)?;
144    Ok((s, into_locate(a)))
145}
146
147#[tracable_parser]
148#[packrat_parser]
149pub(crate) fn real_number(s: Span) -> IResult<Span, RealNumber> {
150    alt((
151        real_number_floating,
152        map(fixed_point_number, |x| {
153            RealNumber::FixedPointNumber(Box::new(x))
154        }),
155    ))(s)
156}
157
158#[tracable_parser]
159#[packrat_parser]
160pub(crate) fn real_number_floating(s: Span) -> IResult<Span, RealNumber> {
161    let (s, a) = unsigned_number_without_ws(s)?;
162    let (s, b) = opt(pair(
163        map(tag("."), |x: Span| Symbol {
164            nodes: (into_locate(x), vec![]),
165        }),
166        unsigned_number_without_ws,
167    ))(s)?;
168    let (s, c) = exp(s)?;
169    let (s, d) = opt(sign)(s)?;
170    let (s, e) = unsigned_number(s)?;
171    Ok((
172        s,
173        RealNumber::Floating(Box::new(RealNumberFloating {
174            nodes: (a, b, c, d, e),
175        })),
176    ))
177}
178
179#[tracable_parser]
180#[packrat_parser]
181pub(crate) fn fixed_point_number(s: Span) -> IResult<Span, FixedPointNumber> {
182    let (s, a) = unsigned_number_without_ws(s)?;
183    let (s, b) = map(tag("."), |x: Span| Symbol {
184        nodes: (into_locate(x), vec![]),
185    })(s)?;
186    let (s, c) = unsigned_number(s)?;
187    Ok((s, FixedPointNumber { nodes: (a, b, c) }))
188}
189
190#[tracable_parser]
191#[packrat_parser]
192pub(crate) fn fixed_point_number_exact(s: Span) -> IResult<Span, FixedPointNumber> {
193    let (s, a) = unsigned_number_without_ws(s)?;
194    let (s, b) = map(tag("."), |x: Span| Symbol {
195        nodes: (into_locate(x), vec![]),
196    })(s)?;
197    let (s, c) = unsigned_number_exact(s)?;
198    Ok((s, FixedPointNumber { nodes: (a, b, c) }))
199}
200
201#[tracable_parser]
202#[packrat_parser]
203pub(crate) fn exp(s: Span) -> IResult<Span, Exp> {
204    let (s, a) = alt((
205        map(tag("e"), |x: Span| Symbol {
206            nodes: (into_locate(x), vec![]),
207        }),
208        map(tag("E"), |x: Span| Symbol {
209            nodes: (into_locate(x), vec![]),
210        }),
211    ))(s)?;
212    Ok((s, Exp { nodes: (a,) }))
213}
214
215#[tracable_parser]
216#[packrat_parser]
217pub(crate) fn unsigned_number_without_ws(s: Span) -> IResult<Span, UnsignedNumber> {
218    let (s, a) = unsigned_number_impl(s)?;
219    Ok((s, UnsignedNumber { nodes: (a, vec![]) }))
220}
221
222#[tracable_parser]
223#[packrat_parser]
224pub(crate) fn unsigned_number(s: Span) -> IResult<Span, UnsignedNumber> {
225    let (s, a) = ws(unsigned_number_impl)(s)?;
226    Ok((s, UnsignedNumber { nodes: a }))
227}
228
229#[tracable_parser]
230#[packrat_parser]
231pub(crate) fn unsigned_number_exact(s: Span) -> IResult<Span, UnsignedNumber> {
232    let (s, a) = no_ws(unsigned_number_impl)(s)?;
233    Ok((s, UnsignedNumber { nodes: a }))
234}
235
236#[tracable_parser]
237pub(crate) fn unsigned_number_impl(s: Span) -> IResult<Span, Locate> {
238    let (s, a) = digit1(s)?;
239    let (s, a) = fold_many0(
240        alt((tag("_"), digit1)),
241        || a,
242        |acc, item| concat(acc, item).unwrap(),
243    )(s)?;
244    Ok((s, into_locate(a)))
245}
246
247#[tracable_parser]
248#[packrat_parser]
249pub(crate) fn binary_value(s: Span) -> IResult<Span, BinaryValue> {
250    let (s, a) = ws(binary_value_impl)(s)?;
251    Ok((s, BinaryValue { nodes: a }))
252}
253
254#[tracable_parser]
255pub(crate) fn binary_value_impl(s: Span) -> IResult<Span, Locate> {
256    let (s, a) = is_a("01xXzZ?")(s)?;
257    let (s, a) = fold_many0(
258        alt((tag("_"), is_a("01xXzZ?"))),
259        || a,
260        |acc, item| concat(acc, item).unwrap(),
261    )(s)?;
262    Ok((s, into_locate(a)))
263}
264
265#[tracable_parser]
266#[packrat_parser]
267pub(crate) fn octal_value(s: Span) -> IResult<Span, OctalValue> {
268    let (s, a) = ws(octal_value_impl)(s)?;
269    Ok((s, OctalValue { nodes: a }))
270}
271
272#[tracable_parser]
273pub(crate) fn octal_value_impl(s: Span) -> IResult<Span, Locate> {
274    let (s, a) = is_a("01234567xXzZ?")(s)?;
275    let (s, a) = fold_many0(
276        alt((tag("_"), is_a("01234567xXzZ?"))),
277        || a,
278        |acc, item| concat(acc, item).unwrap(),
279    )(s)?;
280    Ok((s, into_locate(a)))
281}
282
283#[tracable_parser]
284#[packrat_parser]
285pub(crate) fn hex_value(s: Span) -> IResult<Span, HexValue> {
286    let (s, a) = ws(hex_value_impl)(s)?;
287    Ok((s, HexValue { nodes: a }))
288}
289
290#[tracable_parser]
291pub(crate) fn hex_value_impl(s: Span) -> IResult<Span, Locate> {
292    let (s, a) = is_a("0123456789abcdefABCDEFxXzZ?")(s)?;
293    let (s, a) = fold_many0(
294        alt((tag("_"), is_a("0123456789abcdefABCDEFxXzZ?"))),
295        || a,
296        |acc, item| concat(acc, item).unwrap(),
297    )(s)?;
298    Ok((s, into_locate(a)))
299}
300
301#[tracable_parser]
302#[packrat_parser]
303pub(crate) fn decimal_base(s: Span) -> IResult<Span, DecimalBase> {
304    let (s, a) = ws(decimal_base_impl)(s)?;
305    Ok((s, DecimalBase { nodes: a }))
306}
307
308#[tracable_parser]
309pub(crate) fn decimal_base_impl(s: Span) -> IResult<Span, Locate> {
310    let (s, a) = alt((tag_no_case("'d"), tag_no_case("'sd")))(s)?;
311    Ok((s, into_locate(a)))
312}
313
314#[tracable_parser]
315#[packrat_parser]
316pub(crate) fn binary_base(s: Span) -> IResult<Span, BinaryBase> {
317    let (s, a) = ws(binary_base_impl)(s)?;
318    Ok((s, BinaryBase { nodes: a }))
319}
320
321#[tracable_parser]
322pub(crate) fn binary_base_impl(s: Span) -> IResult<Span, Locate> {
323    let (s, a) = alt((tag_no_case("'b"), tag_no_case("'sb")))(s)?;
324    Ok((s, into_locate(a)))
325}
326
327#[tracable_parser]
328#[packrat_parser]
329pub(crate) fn octal_base(s: Span) -> IResult<Span, OctalBase> {
330    let (s, a) = ws(octal_base_impl)(s)?;
331    Ok((s, OctalBase { nodes: a }))
332}
333
334#[tracable_parser]
335pub(crate) fn octal_base_impl(s: Span) -> IResult<Span, Locate> {
336    let (s, a) = alt((tag_no_case("'o"), tag_no_case("'so")))(s)?;
337    Ok((s, into_locate(a)))
338}
339
340#[tracable_parser]
341#[packrat_parser]
342pub(crate) fn hex_base(s: Span) -> IResult<Span, HexBase> {
343    let (s, a) = ws(hex_base_impl)(s)?;
344    Ok((s, HexBase { nodes: a }))
345}
346
347#[tracable_parser]
348pub(crate) fn hex_base_impl(s: Span) -> IResult<Span, Locate> {
349    let (s, a) = alt((tag_no_case("'h"), tag_no_case("'sh")))(s)?;
350    Ok((s, into_locate(a)))
351}
352
353#[tracable_parser]
354#[packrat_parser]
355pub(crate) fn x_number(s: Span) -> IResult<Span, XNumber> {
356    let (s, a) = ws(x_number_impl)(s)?;
357    Ok((s, XNumber { nodes: a }))
358}
359
360#[tracable_parser]
361pub(crate) fn x_number_impl(s: Span) -> IResult<Span, Locate> {
362    let (s, a) = tag_no_case("x")(s)?;
363    let (s, a) = fold_many0(
364        alt((tag("_"), is_a("_"))),
365        || a,
366        |acc, item| concat(acc, item).unwrap(),
367    )(s)?;
368    Ok((s, into_locate(a)))
369}
370
371#[tracable_parser]
372#[packrat_parser]
373pub(crate) fn z_number(s: Span) -> IResult<Span, ZNumber> {
374    let (s, a) = ws(z_number_impl)(s)?;
375    Ok((s, ZNumber { nodes: a }))
376}
377
378#[tracable_parser]
379pub(crate) fn z_number_impl(s: Span) -> IResult<Span, Locate> {
380    let (s, a) = alt((tag_no_case("z"), tag("?")))(s)?;
381    let (s, a) = fold_many0(
382        alt((tag("_"), is_a("_"))),
383        || a,
384        |acc, item| concat(acc, item).unwrap(),
385    )(s)?;
386    Ok((s, into_locate(a)))
387}
388
389#[tracable_parser]
390#[packrat_parser]
391pub(crate) fn unbased_unsized_literal(s: Span) -> IResult<Span, UnbasedUnsizedLiteral> {
392    let (s, a) = alt((
393        symbol("'0"),
394        symbol("'1"),
395        symbol("'z"),
396        symbol("'x"),
397        symbol("'Z"),
398        symbol("'X"),
399    ))(s)?;
400    Ok((s, UnbasedUnsizedLiteral { nodes: (a,) }))
401}
sv_parser_parser/expressions/numbers.rs

sv_parser_parser/expressions/
numbers.rs
