parseal 0.2.4

An easy way to create your own parsers
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

#![allow(unused)]

use std::fs;

use expression::Statement;
use parseal::{
    Parsable,
    parsing::{self, Parse, charstream::CharStream, tokens, Group, List, Identifier, StringValue},
};
use typedata::{NamedField, Enum, Struct};

mod typedata;
mod expression;

#[derive(Debug, Clone, Parsable)]
pub enum UsePart {
    Group(Group<tokens::Brace, List<Box<UsePart>>>),
    Path(Identifier, Option<(tokens::DoubleColon, Box<UsePart>)>),
}

#[derive(Parsable, Clone, Debug)]
pub enum AttrValue {
    Ident(Identifier),
    String(StringValue),
}

#[derive(Parsable, Clone, Debug)]
pub struct Attribute {
    start: tokens::Hash,
    outer: Option<tokens::Bang>,
    value: Group<tokens::Bracket, (Identifier, Group<tokens::Paren, List<AttrValue>>)>
}

#[derive(Parsable, Clone, Debug)]
pub enum Visibility {
    Public(#[value("pub")] Identifier),
    Private,
}

#[derive(Parsable, Clone, Debug)]
pub struct Function {
    attrs: Option<Vec<Attribute>>,
    vis: Visibility,
    #[value("fn")]
    keyword: Identifier,
    name: Identifier,
    parameters: Group<tokens::Paren, List<NamedField>>,
    code: Group<tokens::Brace, Option<Vec<Statement>>>,
}

#[derive(Parsable, Clone, Debug)]
pub enum Definition {
    Use(#[value("use")] Identifier, UsePart, tokens::Semicolon),
    Mod(#[value("mod")] Identifier, Identifier, tokens::Semicolon),
    Enum(Enum),
    Struct(Struct),
    Function(Function),
}

#[derive(Parsable, Clone, Debug)]
pub struct Rust {
    attrs: Option<Vec<Attribute>>,
    definitions: Vec<Definition>
}

pub fn main() {
    let file = fs::read_to_string("examples/rust/main.rs")
        .expect("could not find file.");
    let mut buffer = CharStream::new(file).build();
    let value = Rust::parse(&mut buffer);
    println!("value: {:#?}", value);
}