[go: up one dir, main page]

syntex 0.4.1

High-level bindings to the zeromq library
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

extern crate syntex_syntax;

use std::fs::File;
use std::io;
use std::path::Path;

use syntex_syntax::ast::MacroDef;
use syntex_syntax::config;
use syntex_syntax::ext::base::{
    IdentMacroExpander,
    ItemDecorator,
    ItemModifier,
    MultiItemModifier,
    NamedSyntaxExtension,
    SyntaxExtension,
    TTMacroExpander,
};
use syntex_syntax::ext::expand;
use syntex_syntax::parse::{self, token};
use syntex_syntax::print::{pp, pprust};

pub struct Registry {
    macros: Vec<MacroDef>,
    syntax_exts: Vec<NamedSyntaxExtension>,
}

impl Registry {
    pub fn new() -> Registry {
        Registry {
            macros: Vec::new(),
            syntax_exts: Vec::new(),
        }
    }

    pub fn with_standard_macros() -> Registry {
        let registry = Registry::new();
        registry
    }

    pub fn register_macro<F>(&mut self, name: &str, extension: F)
        where F: TTMacroExpander + 'static
    {
        let name = token::intern(name);
        let syntax_extension = SyntaxExtension::NormalTT(
            Box::new(extension),
            None,
            false
        );
        self.syntax_exts.push((name, syntax_extension));
    }

    pub fn register_ident<F>(&mut self, name: &str, extension: F)
        where F: IdentMacroExpander + 'static
    {
        let name = token::intern(name);
        let syntax_extension = SyntaxExtension::IdentTT(
            Box::new(extension),
            None,
            false
        );
        self.syntax_exts.push((name, syntax_extension));
    }

    pub fn register_decorator<F>(&mut self, name: &str, extension: F)
        where F: ItemDecorator + 'static
    {
        let name = token::intern(name);
        let syntax_extension = SyntaxExtension::Decorator(Box::new(extension));
        self.syntax_exts.push((name, syntax_extension));
    }

    pub fn register_item_modifier<F>(&mut self, name: &str, extension: F)
        where F: ItemModifier + 'static
    {
        let name = token::intern(name);
        let syntax_extension = SyntaxExtension::Modifier(Box::new(extension));
        self.syntax_exts.push((name, syntax_extension));
    }

    pub fn register_multi_item_modifier<F>(&mut self, name: &str, extension: F)
        where F: MultiItemModifier + 'static
    {
        let name = token::intern(name);
        let syntax_extension = SyntaxExtension::MultiModifier(Box::new(extension));
        self.syntax_exts.push((name, syntax_extension));
    }

    pub fn expand(self, crate_name: &str, src: &Path, dst: &Path) -> io::Result<()> {
        let sess = parse::new_parse_sess();
        let cfg = vec![];

        let krate = parse::parse_crate_from_file(
            src,
            cfg,
            &sess);

        let krate = config::strip_unconfigured_items(
            &sess.span_diagnostic,
            krate);

        let cfg = expand::ExpansionConfig::default(crate_name.to_string());

        let krate = expand::expand_crate(
            &sess,
            cfg,
            self.macros,
            self.syntax_exts,
            krate);

        let dst = try!(File::create(dst));

        let mut printer = pprust::rust_printer(Box::new(dst));
        try!(printer.print_mod(&krate.module, &krate.attrs[..]));
        try!(printer.print_remaining_comments());
        pp::eof(&mut printer.s)
    }
}