cg2 0.1.0

Rust code generator.
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

use alloc::string::String;

use crate::repeat_char;

use crate::{Keyword, Punct};

#[derive(Debug, Default)]
pub struct Generator {
  code: String,
}

impl Generator {
  #[must_use]
  pub fn new() -> Self {
    Self {
      code: String::new(),
    }
  }

  #[must_use]
  pub fn code(&self) -> &String {
    &self.code
  }

  #[must_use]
  pub fn into_code(self) -> String {
    self.code
  }

  pub fn out(&mut self, s: &str) -> &mut Self {
    self.code.push_str(s);
    self
  }

  pub fn outc(&mut self, c: char) -> &mut Self {
    self.code.push(c);
    self
  }
}

impl Generator {
  pub fn space(&mut self) -> &mut Self {
    self.outc(' ')
  }

  pub fn line(&mut self) -> &mut Self {
    self.outc('\n')
  }

  pub fn lines(&mut self, n: usize) -> &mut Self {
    self.out(&repeat_char('\n', n))
  }

  pub fn punct(&mut self, p: Punct) -> &mut Self {
    self.outc(p as u8 as _)
  }

  pub fn keyword(&mut self, kw: Keyword) -> &mut Self {
    self.out(kw.as_str())
  }

  pub fn ident(&mut self, i: &str) -> &mut Self {
    self.out(i)
  }
}

impl Generator {
  impl_punct!(semi, Semi);
  impl_punct!(dot, Dot);
  impl_punct!(comma, Comma);
  impl_punct!(colon, Colon);
  impl_punct!(hash, Hash);
  impl_punct!(star, Star);
  impl_punct!(l_paren, LParen);
  impl_punct!(r_paren, RParen);
  impl_punct!(l_brace, LBrace);
  impl_punct!(r_brace, RBrace);
  impl_punct!(l_curly, LCurly);
  impl_punct!(r_curly, RCurly);
  impl_punct!(quote, Quote);
  impl_punct!(single_quote, SingleQuote);
}

impl Generator {
  impl_keyword!(public, Pub);
  impl_keyword!(not_safe, Unsafe);
  impl_keyword!(func, Fn);
  impl_keyword!(mutable, Mut);
  impl_keyword!(implement, Impl);
  impl_keyword!(variable, Let);
  impl_keyword!(constant, Const);
}

impl Generator {
  impl_alias!(deref, star);
}

macro_rules! impl_punct {
  ($fn:ident, $var:ident) => {
    pub fn $fn(&mut self) -> &mut Self {
      self.punct(Punct::$var)
    }
  };
}

macro_rules! impl_keyword {
  ($fn:ident, $var:ident) => {
    pub fn $fn(&mut self) -> &mut Self {
      self.keyword(Keyword::$var)
    }
  };
}

macro_rules! impl_alias {
  ($fn:ident, $alias:ident) => {
    pub fn $fn(&mut self) -> &mut Self {
      self.$alias()
    }
  };
}

use {impl_alias, impl_keyword, impl_punct};