1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
use lalrpop_util::ParseError;
use crate::{
Error,
packet::Tag,
};
pub(crate) mod lexer;
lalrpop_util::lalrpop_mod!(
#[allow(clippy::all)]
#[allow(unused_parens)]
grammar,
"/cert/parser/low_level/grammar.rs"
);
pub(crate) mod grammar_util;
pub(crate) use self::lexer::Token;
pub(crate) use self::lexer::Lexer;
pub(crate) use self::grammar::CertParser;
// Converts a ParseError<usize, Token, Error> to a
// ParseError<usize, Tag, Error>.
//
// Justification: a Token is a tuple containing a Tag and a Packet.
// This function essentially drops the Packet. Dropping the packet was
// necessary, because packets were not Sync, but Error, which we want
// to convert ParseErrors to, was. Since we don't need the packet in
// general anyways, changing the Token to a Tag is a simple and
// sufficient fix. Unfortunately, this conversion is a bit ugly and
// will break if lalrpop ever extends ParseError.
//
// This justification is no longer up-to-date because Packet is now
// also Sync. However, we didn't catch this when we made Packet Sync,
// and now the justification is simply that CertParserError::Parser(_)
// expects a Tag, not a Packet. It is not public, so we could change
// it.
pub(crate) fn parse_error_downcast(e: ParseError<usize, Token, Error>)
-> ParseError<usize, Tag, Error>
{
match e {
ParseError::UnrecognizedToken {
token: (start, t, end),
expected,
} => ParseError::UnrecognizedToken {
token: (start, t.into(), end),
expected,
},
ParseError::ExtraToken {
token: (start, t, end),
} => ParseError::ExtraToken {
token: (start, t.into(), end),
},
ParseError::InvalidToken { location }
=> ParseError::InvalidToken { location },
ParseError::User { error }
=> ParseError::User { error },
ParseError::UnrecognizedEof { location, expected }
=> ParseError::UnrecognizedEof { location, expected },
}
}
pub(crate) fn parse_error_to_openpgp_error(e: ParseError<usize, Tag, Error>)
-> Error
{
match e {
ParseError::User { error } => error,
e => Error::MalformedCert(format!("{}", e)),
}
}
/// Errors that CertValidator::check may return.
#[derive(Debug, Clone)]
pub enum CertParserError {
/// A parser error.
Parser(ParseError<usize, Tag, Error>),
/// An OpenPGP error.
OpenPGP(Error),
}
assert_send_and_sync!(CertParserError);
impl From<CertParserError> for anyhow::Error {
fn from(err: CertParserError) -> Self {
match err {
CertParserError::Parser(p) => p.into(),
CertParserError::OpenPGP(p) => p.into(),
}
}
}
|
