fastxdr 1.0.2

Generate Rust types from XDR specs with fast, zero-copy deserialisation
Documentation 
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

mod basic_type;
pub use basic_type::*;

mod structure;
pub use structure::*;

mod union;
pub use union::*;

mod enumeration;
pub use enumeration::*;

mod node;
use node::*;

mod array;
pub use array::*;

mod typedef;
pub use typedef::*;

pub mod indexes;
use indexes::*;

pub trait CompoundType {
    fn inner_types(&self) -> Vec<&ArrayType<BasicType>>;
    fn contains_opaque(&self) -> bool;
}

use crate::Result;
use pest::iterators::Pair;
use pest::Parser;
use pest_derive::Parser;
use std::convert::TryFrom;

#[derive(Parser)]
#[grammar = "xdr.pest"]
pub(crate) struct XDRParser;

#[derive(Debug)]
pub struct Ast {
    constant_index: ConstantIndex,
    generic_index: GenericIndex,
    type_index: TypeIndex,
}

/// The `Ast` type provides high-level access to elements of the AST read from
/// an XDR spec.
impl Ast {
    pub fn new(xdr: &str) -> Result<Self> {
        // Tokenise the input
        let mut root = XDRParser::parse(Rule::item, xdr)?;
        // Parse into an AST
        let ast = walk(root.next().ok_or("unable to tokenise input")?);

        // Build some helpful indexes to answer questions about types when
        // generating the Rust code.
        let constant_index = ConstantIndex::new(&ast);
        let generic_index = GenericIndex::new(&ast);
        let type_index = TypeIndex::new(&ast);

        Ok(Ast {
            constant_index,
            generic_index,
            type_index,
        })
    }

    pub fn constants(&self) -> &ConstantIndex {
        &self.constant_index
    }

    pub fn generics(&self) -> &GenericIndex {
        &self.generic_index
    }

    pub fn types(&self) -> &TypeIndex {
        &self.type_index
    }
}

// Recurse into the tokens from the PEG parser, constructing a syntax tree and
// initialising higher-level representations of the compound types from them.
//
// These higher-level types will then be extracted and added to the type index
// later.
fn walk(ast: Pair<'_, Rule>) -> Node<'_> {
    fn collect_values(ast: Pair<'_, Rule>) -> Vec<Node<'_>> {
        ast.into_inner().map(walk).collect()
    }

    match ast.as_rule() {
        Rule::item => Node::Root(collect_values(ast)),
        Rule::typedef => Node::Typedef(Typedef::new(collect_values(ast))),
        Rule::constant => Node::Constant(collect_values(ast)),
        Rule::ident | Rule::ident_const | Rule::ident_value => {
            if let Ok(t) = BasicType::try_from(ast.as_str()) {
                Node::Type(t)
            } else {
                Node::Ident(ast.as_str())
            }
        }
        Rule::enum_type => Node::Enum(Enum::new(collect_values(ast))),
        Rule::enum_variant => Node::EnumVariant(collect_values(ast)),
        Rule::array => Node::Array(collect_values(ast)),
        Rule::array_variable => Node::ArrayVariable(ast.into_inner().as_str()),
        Rule::array_fixed => Node::ArrayFixed(ast.into_inner().as_str()),
        Rule::struct_type => Node::Struct(Struct::new(collect_values(ast))),
        Rule::struct_data_field => Node::StructDataField(collect_values(ast)),
        Rule::union_data_field => Node::UnionDataField(collect_values(ast)),
        Rule::union => Node::Union(Union::new(collect_values(ast))),
        Rule::union_case => Node::UnionCase(collect_values(ast)),
        Rule::union_default => Node::UnionDefault(collect_values(ast)),
        Rule::union_void => Node::UnionVoid,
        Rule::option => Node::Option(collect_values(ast)),
        Rule::basic_type => {
            Node::Type(BasicType::try_from(ast.as_str()).expect("unrecognised type"))
        }
        Rule::EOI => Node::EOF,
        e => unimplemented!("unknown token type {:?}", e),
    }
}