dcbor_parse/
parse.rs

1use base64::Engine as _;
2use bc_ur::prelude::*;
3use known_values::KnownValue;
4use logos::{ Lexer, Logos, Span };
5use thiserror::Error;
6
7#[derive(Debug, Error, Clone, PartialEq)]
8#[rustfmt::skip]
9pub enum Error {
10    #[error("Empty input")]
11    EmptyInput,
12    #[error("Unexpected end of input")]
13    UnexpectedEndOfInput,
14    #[error("Extra data at end of input")]
15    ExtraData(Span),
16    #[error("Unexpected token {0:?}")]
17    UnexpectedToken(Box<Token>, Span),
18    #[error("Unrecognized token")]
19    UnrecognizedToken(Span),
20    #[error("Expected comma")]
21    ExpectedComma(Span),
22    #[error("Expected colon")]
23    ExpectedColon(Span),
24    #[error("Unmatched parentheses")]
25    UnmatchedParentheses(Span),
26    #[error("Unmatched braces")]
27    UnmatchedBraces(Span),
28    #[error("Expected map key")]
29    ExpectedMapKey(Span),
30    #[error("Invalid tag value '{0}'")]
31    InvalidTagValue(String, Span),
32    #[error("Unknown tag name '{0}'")]
33    UnknownTagName(String, Span),
34    #[error("Invalid hex string")]
35    InvalidHexString(Span),
36    #[error("Invalid base64 string")]
37    InvalidBase64String(Span),
38    #[error("Unknown UR type '{0}'")]
39    UnknownUrType(String, Span),
40    #[error("Invalid UR '{0}'")]
41    InvalidUr(String, Span),
42    #[error("Invalid known value '{0}'")]
43    InvalidKnownValue(String, Span),
44    #[error("Unknown known value name '{0}'")]
45    UnknownKnownValueName(String, Span),
46}
47
48impl Error {
49    pub fn is_default(&self) -> bool {
50        matches!(self, Error::UnrecognizedToken(_))
51    }
52
53    fn format_message(message: &dyn ToString, source: &str, range: &Span) -> String {
54        let message = message.to_string();
55        let start = range.start;
56        let end = range.end;
57        // Walk through the bytes up to `start` to find line number and line start offset
58        let mut line_number = 1;
59        let mut line_start = 0;
60        for (idx, ch) in source.char_indices() {
61            if idx >= start {
62                break;
63            }
64            if ch == '\n' {
65                line_number += 1;
66                line_start = idx + 1;
67            }
68        }
69        // Grab the exact line text (or empty if out of bounds)
70        let line = source
71            .lines()
72            .nth(line_number - 1)
73            .unwrap_or("");
74        // Column is byte-offset into that line
75        let column = start.saturating_sub(line_start);
76        // Underline at least one caret, even for zero-width spans
77        let underline_len = end.saturating_sub(start).max(1);
78        let caret = " ".repeat(column) + &"^".repeat(underline_len);
79        format!("line {line_number}: {message}\n{line}\n{caret}")
80    }
81
82    #[rustfmt::skip]
83    pub fn full_message(&self, source: &str) -> String {
84        match self {
85            Error::EmptyInput => Self::format_message(self, source, &Span::default()),
86            Error::UnexpectedEndOfInput => Self::format_message(self, source, &(source.len()..source.len())),
87            Error::ExtraData(range) => Self::format_message(self, source, range),
88            Error::UnexpectedToken(_, range) => Self::format_message(self, source, range),
89            Error::UnrecognizedToken(range) => Self::format_message(self, source, range),
90            Error::UnknownUrType(_, range) => Self::format_message(self, source, range),
91            Error::UnmatchedParentheses(range) => Self::format_message(self, source, range),
92            Error::ExpectedComma(range) => Self::format_message(self, source, range),
93            Error::ExpectedColon(range) => Self::format_message(self, source, range),
94            Error::ExpectedMapKey(range) => Self::format_message(self, source, range),
95            Error::UnmatchedBraces(range) => Self::format_message(self, source, range),
96            Error::UnknownTagName(_, range) => Self::format_message(self, source, range),
97            Error::InvalidHexString(range) => Self::format_message(self, source, range),
98            Error::InvalidBase64String(range) => Self::format_message(self, source, range),
99            Error::InvalidTagValue(_, range) => Self::format_message(self, source, range),
100            Error::InvalidUr(_, range) => Self::format_message(self, source, range),
101            Error::InvalidKnownValue(_, range) => Self::format_message(self, source, range),
102            Error::UnknownKnownValueName(_, range) => Self::format_message(self, source, range),
103        }
104    }
105}
106
107impl Default for Error {
108    fn default() -> Self {
109        Error::UnrecognizedToken(Span::default())
110    }
111}
112
113pub type Result<T> = std::result::Result<T, Error>;
114
115/// Parses a dCBOR item from a string input.
116///
117/// This function takes a string slice containing a dCBOR diagnostic notation
118/// encoded value and attempts to parse it into a `CBOR` object. If the input
119/// contains extra tokens after a valid item, an error is returned.
120///
121/// # Arguments
122///
123/// * `src` - A string slice containing the dCBOR-encoded data.
124///
125/// # Returns
126///
127/// * `Ok(CBOR)` if parsing is successful and the input contains exactly one
128///   valid dCBOR item, which itself might be an atomic value like a number or
129///   string, or a complex value like an array or map.
130/// * `Err(Error)` if parsing fails or if extra tokens are found after the item.
131///
132/// # Errors
133///
134/// Returns an error if the input is invalid, contains extra tokens, or if any
135/// token cannot be parsed as expected.
136///
137/// # Example
138///
139/// ```rust
140/// # use dcbor_parse::parse_dcbor_item;
141/// let cbor = parse_dcbor_item("[1, 2, 3]").unwrap();
142/// assert_eq!(cbor.diagnostic(), "[1, 2, 3]");
143/// ```
144pub fn parse_dcbor_item(src: &str) -> Result<CBOR> {
145    let mut lexer = Token::lexer(src);
146    let first_token = expect_token(&mut lexer);
147    match first_token {
148        Ok(token) => {
149            parse_item_token(&token, &mut lexer).and_then(|cbor| {
150                if lexer.next().is_some() { Err(Error::ExtraData(lexer.span())) } else { Ok(cbor) }
151            })
152        }
153        Err(e) => {
154            if e == Error::UnexpectedEndOfInput {
155                return Err(Error::EmptyInput);
156            }
157            return Err(e);
158        }
159    }
160}
161
162//
163// === Private Functions ===
164//
165
166fn parse_item(lexer: &mut Lexer<'_, Token>) -> Result<CBOR> {
167    let token = expect_token(lexer)?;
168    parse_item_token(&token, lexer)
169}
170
171fn expect_token(lexer: &mut Lexer<'_, Token>) -> Result<Token> {
172    let span = lexer.span();
173    match lexer.next() {
174        Some(token_or_err) => {
175            match token_or_err {
176                Ok(token) => { Ok(token) }
177                Err(e) => {
178                    if e.is_default() { Err(Error::UnrecognizedToken(span)) } else { Err(e) }
179                }
180            }
181        }
182        None => Err(Error::UnexpectedEndOfInput),
183    }
184}
185
186fn parse_item_token(token: &Token, lexer: &mut Lexer<'_, Token>) -> Result<CBOR> {
187    // Handle embedded lexing errors in token payloads
188    if let Token::ByteStringHex(Err(e)) = token {
189        return Err(e.clone());
190    }
191    if let Token::ByteStringBase64(Err(e)) = token {
192        return Err(e.clone());
193    }
194    if let Token::TagValue(Err(e)) = token {
195        return Err(e.clone());
196    }
197    if let Token::UR(Err(e)) = token {
198        return Err(e.clone());
199    }
200    if let Token::KnownValueNumber(Err(e)) = token {
201        return Err(e.clone());
202    }
203
204    match token {
205        Token::Bool(b) => Ok((*b).into()),
206        Token::Null => Ok(CBOR::null()),
207        Token::ByteStringHex(Ok(bytes)) => Ok(CBOR::to_byte_string(bytes)),
208        Token::ByteStringBase64(Ok(bytes)) => Ok(CBOR::to_byte_string(bytes)),
209        Token::Number(num) => Ok((*num).into()),
210        Token::NaN => Ok(f64::NAN.into()),
211        Token::Infinity => Ok(f64::INFINITY.into()),
212        Token::NegInfinity => Ok(f64::NEG_INFINITY.into()),
213        Token::String(s) => parse_string(s, lexer.span()),
214        Token::UR(Ok(ur)) => parse_ur(ur, lexer.span()),
215        Token::TagValue(Ok(tag_value)) => parse_number_tag(*tag_value, lexer),
216        Token::TagName(name) => parse_name_tag(&name, lexer),
217        Token::KnownValueNumber(Ok(value)) => Ok(KnownValue::new(*value).into()),
218        Token::KnownValueName(name) => {
219            if let Some(known_value) = known_value_for_name(&name) {
220                Ok(known_value.into())
221            } else {
222                let span = lexer.span().start + 1..lexer.span().end - 1;
223                Err(Error::UnknownKnownValueName(name.clone(), span))
224            }
225        }
226        Token::BracketOpen => parse_array(lexer),
227        Token::BraceOpen => parse_map(lexer),
228        _ => Err(Error::UnexpectedToken(Box::new(token.clone()), lexer.span())),
229    }
230}
231
232fn parse_string(s: &str, span: Span) -> Result<CBOR> {
233    if s.starts_with('"') && s.ends_with('"') {
234        let s = &s[1..s.len() - 1];
235        Ok(s.into())
236    } else {
237        Err(Error::UnrecognizedToken(span))
238    }
239}
240
241fn tag_for_name(name: &str) -> Option<Tag> {
242    with_tags!(|tags: &TagsStore| tags.tag_for_name(name))
243}
244
245fn known_value_for_name(name: &str) -> Option<KnownValue> {
246    let binding = known_values::KNOWN_VALUES.get();
247    let known_values = binding.as_ref().unwrap();
248    known_values.known_value_named(name).cloned()
249}
250
251fn parse_ur(ur: &UR, span: Span) -> Result<CBOR> {
252    let ur_type = ur.ur_type_str();
253    if let Some(tag) = tag_for_name(ur_type) {
254        Ok(CBOR::to_tagged_value(tag, ur.cbor()))
255    } else {
256        Err(
257            Error::UnknownUrType(
258                ur_type.to_string(),
259                span.start + 3..span.start + 3 + ur_type.len()
260            )
261        )
262    }
263}
264
265fn parse_number_tag(tag_value: TagValue, lexer: &mut Lexer<'_, Token>) -> Result<CBOR> {
266    let item = parse_item(lexer)?;
267    match expect_token(lexer) {
268        Ok(Token::ParenthesisClose) => Ok(CBOR::to_tagged_value(tag_value, item)),
269        Ok(_) => Err(Error::UnmatchedParentheses(lexer.span())),
270        Err(e) => {
271            if e == Error::UnexpectedEndOfInput {
272                return Err(Error::UnmatchedParentheses(lexer.span()));
273            }
274            return Err(e);
275        }
276    }
277}
278
279fn parse_name_tag(name: &str, lexer: &mut Lexer<'_, Token>) -> Result<CBOR> {
280    let span = lexer.span().start..lexer.span().end - 1;
281    let item = parse_item(lexer)?;
282    match expect_token(lexer)? {
283        Token::ParenthesisClose => {
284            if let Some(tag) = tag_for_name(name) {
285                Ok(CBOR::to_tagged_value(tag, item))
286            } else {
287                Err(Error::UnknownTagName(name.to_string(), span))
288            }
289        }
290        _ => { Err(Error::UnmatchedParentheses(lexer.span())) }
291    }
292}
293
294fn parse_array(lexer: &mut Lexer<'_, Token>) -> Result<CBOR> {
295    let mut items = Vec::new();
296    let mut awaits_comma = false;
297    let mut awaits_item = false;
298
299    loop {
300        match expect_token(lexer)? {
301            Token::Bool(b) if !awaits_comma => {
302                items.push(b.into());
303                awaits_item = false;
304            }
305            Token::Null if !awaits_comma => {
306                items.push(CBOR::null());
307                awaits_item = false;
308            }
309            Token::ByteStringHex(Ok(bytes)) if !awaits_comma => {
310                items.push(CBOR::to_byte_string(bytes));
311                awaits_item = false;
312            }
313            Token::ByteStringBase64(Ok(bytes)) if !awaits_comma => {
314                items.push(CBOR::to_byte_string(bytes));
315                awaits_item = false;
316            }
317            Token::Number(num) if !awaits_comma => {
318                items.push(num.into());
319                awaits_item = false;
320            }
321            Token::NaN if !awaits_comma => {
322                items.push(f64::NAN.into());
323                awaits_item = false;
324            }
325            Token::Infinity if !awaits_comma => {
326                items.push(f64::INFINITY.into());
327                awaits_item = false;
328            }
329            Token::NegInfinity if !awaits_comma => {
330                items.push(f64::NEG_INFINITY.into());
331                awaits_item = false;
332            }
333            Token::String(s) if !awaits_comma => {
334                items.push(parse_string(&s, lexer.span())?);
335                awaits_item = false;
336            }
337            Token::UR(Ok(ur)) if !awaits_comma => {
338                items.push(parse_ur(&ur, lexer.span())?);
339                awaits_item = false;
340            }
341            Token::TagValue(Ok(tag_value)) if !awaits_comma => {
342                items.push(parse_number_tag(tag_value, lexer)?);
343                awaits_item = false;
344            }
345            Token::TagName(name) if !awaits_comma => {
346                items.push(parse_name_tag(&name, lexer)?);
347                awaits_item = false;
348            }
349            Token::KnownValueNumber(Ok(value)) if !awaits_comma => {
350                items.push(KnownValue::new(value).into());
351                awaits_item = false;
352            }
353            Token::KnownValueName(name) if !awaits_comma => {
354                if let Some(known_value) = known_value_for_name(&name) {
355                    items.push(known_value.into());
356                } else {
357                    return Err(Error::UnknownKnownValueName(name, lexer.span()));
358                }
359                awaits_item = false;
360            }
361            Token::BracketOpen if !awaits_comma => {
362                items.push(parse_array(lexer)?);
363                awaits_item = false;
364            }
365            Token::BraceOpen if !awaits_comma => {
366                items.push(parse_map(lexer)?);
367                awaits_item = false;
368            }
369            Token::Comma if awaits_comma => {
370                awaits_item = true;
371            }
372            Token::BracketClose if !awaits_item => {
373                return Ok(items.into());
374            }
375            token => {
376                if awaits_comma {
377                    return Err(Error::ExpectedComma(lexer.span()));
378                }
379                return Err(Error::UnexpectedToken(Box::new(token), lexer.span()));
380            }
381        }
382        awaits_comma = !awaits_item;
383    }
384}
385
386fn parse_map(lexer: &mut Lexer<'_, Token>) -> Result<CBOR> {
387    let mut map = Map::new();
388    let mut awaits_comma = false;
389    let mut awaits_key = false;
390
391    loop {
392        let token = match expect_token(lexer) {
393            Ok(tok) => tok,
394            Err(e) if e == Error::UnexpectedEndOfInput => {
395                return Err(Error::UnmatchedBraces(lexer.span()));
396            }
397            Err(e) => {
398                return Err(e);
399            }
400        };
401        match token {
402            Token::BraceClose if !awaits_key => {
403                return Ok(map.into());
404            }
405            Token::Comma if awaits_comma => {
406                awaits_key = true;
407            }
408            _ => {
409                if awaits_comma {
410                    return Err(Error::ExpectedComma(lexer.span()));
411                }
412                let key = parse_item_token(&token, lexer)?;
413                if let Some(Token::Colon) = expect_token(lexer).ok() {
414                    let value = match parse_item(lexer) {
415                        Err(Error::UnexpectedToken(token, span)) if *token == Token::BraceClose => {
416                            return Err(Error::ExpectedMapKey(span));
417                        }
418                        other => other?,
419                    };
420                    map.insert(key, value);
421                    awaits_key = false;
422                } else {
423                    return Err(Error::ExpectedColon(lexer.span()));
424                }
425            }
426        }
427        awaits_comma = !awaits_key;
428    }
429}
430
431#[derive(Debug, Clone, Logos, PartialEq)]
432#[rustfmt::skip]
433#[logos(error = Error)]
434#[logos(skip r"(?:[ \t\r\n\f]|/[^/]*/|#[^\n]*)+")]
435pub enum Token {
436    #[token("false", |_| false)]
437    #[token("true", |_| true)]
438    Bool(bool),
439
440    #[token("{")]
441    BraceOpen,
442
443    #[token("}")]
444    BraceClose,
445
446    #[token("[")]
447    BracketOpen,
448
449    #[token("]")]
450    BracketClose,
451
452    #[token("(")]
453    ParenthesisOpen,
454
455    #[token(")")]
456    ParenthesisClose,
457
458    #[token(":")]
459    Colon,
460
461    #[token(",")]
462    Comma,
463
464    #[token("null")]
465    Null,
466
467    #[token("NaN")]
468    NaN,
469
470    #[token("Infinity")]
471    Infinity,
472
473    #[token("-Infinity")]
474    NegInfinity,
475
476    /// Binary string in hex format.
477    #[regex(r"h'[0-9a-fA-F]*'", |lex| {
478        let hex = lex.slice();
479        let raw_hex = hex[2..hex.len() - 1].as_bytes();
480        if raw_hex.len() % 2 != 0 {
481            return Err(Error::InvalidHexString(lex.span()));
482        }
483        hex::decode(raw_hex)
484            .map_err(|_|
485                Error::InvalidHexString(lex.span())
486            )
487    })]
488    ByteStringHex(Result<Vec<u8>>),
489
490    /// Binary string in base64 format.
491    #[regex(r"b64'([A-Za-z0-9+/=]{2,})'", |lex| {
492        let base64 = lex.slice();
493        let s = &base64[4..base64.len() - 1];
494        base64::engine::general_purpose::STANDARD
495        .decode(s)
496        .map_err(|_| Error::InvalidBase64String(lex.span()))
497    })]
498    ByteStringBase64(Result<Vec<u8>>),
499
500    /// JavaScript-style number.
501    #[regex(r"-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?", |lex|
502        lex.slice().parse::<f64>().unwrap()
503    )]
504    Number(f64),
505
506    /// JavaScript-style string.
507    #[regex(r#""([^"\\\x00-\x1F]|\\(["\\bnfrt/]|u[a-fA-F0-9]{4}))*""#, |lex|
508        lex.slice().to_owned()
509    )]
510    String(String),
511
512    /// Integer followed immediately by an opening parenthesis.
513    #[regex(r#"[1-9][0-9]*\("#, |lex|
514        let span = (lex.span().start)..(lex.span().end - 1);
515        let stripped = lex.slice().strip_suffix('(').unwrap();
516        stripped.parse::<TagValue>().map_err(|_|
517                Error::InvalidTagValue(stripped.to_string(), span)
518            )
519    )]
520    TagValue(Result<TagValue>),
521
522    /// Tag name followed immediately by an opening parenthesis.
523    #[regex(r#"[a-zA-Z_][a-zA-Z0-9_-]*\("#, |lex|
524        // safe to drop the trailing '('
525        lex.slice()[..lex.slice().len()-1].to_string()
526    )]
527    TagName(String),
528
529    /// Integer (same regex as TagValue) enclosed in single quotes.
530    #[regex(r#"'0'|'[1-9][0-9]*'"#, |lex|
531        let span = (lex.span().start + 1)..(lex.span().end - 1);
532        let slice = lex.slice();
533        let stripped = slice[1..slice.len() - 1].to_string();
534        stripped.parse::<TagValue>().map_err(|_|
535                Error::InvalidKnownValue(stripped, span)
536            )
537    )]
538    KnownValueNumber(Result<u64>),
539
540    /// Single-quoted empty string (i.e., `''`) (Unit) or Identifier (same regex
541    /// as for tag names) enclosed in single quotes.
542    #[regex(r#"''|'[a-zA-Z_][a-zA-Z0-9_-]*'"#, |lex|
543        lex.slice()[1..lex.slice().len()-1].to_string()
544    )]
545    KnownValueName(String),
546
547    #[regex(r#"ur:([a-zA-Z0-9][a-zA-Z0-9-]*)/([a-zA-Z]{8,})"#, |lex|
548        let s = lex.slice();
549        let ur = UR::from_ur_string(s);
550        ur.map_err(|e| {
551            Error::InvalidUr(e.to_string(), lex.span())
552        })
553    )]
554    UR(Result<UR>),
555}
dcbor_parse/parse.rs

dcbor_parse/
parse.rs
