macroonz-compiler 0.2.0

Deterministic Rust code generation for procedural macros: plan, render, close, explain, and bind one sealed expansion from declared input.
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

//! The canonical byte form of a generated token tree.
//!
//! Existing occupied slots never move; new token distinctions append at the end.

use super::{GeneratedDelimiter, GeneratedLiteralForm, GeneratedSpacing, GeneratedToken};
use crate::identity::{encode_bytes, encode_length};

/// Encode one generated token into the canonical byte form.
pub(super) fn encode_generated(token: &GeneratedToken, into: &mut Vec<u8>) {
    match token {
        GeneratedToken::Word(word) => {
            into.push(1);
            encode_text(word, into);
        }
        GeneratedToken::Punct { mark, spacing } => {
            into.push(2);
            into.push(match spacing {
                GeneratedSpacing::Joint => 0,
                GeneratedSpacing::Alone => 1,
            });
            let mut buffer = [0u8; 4];
            encode_text(mark.encode_utf8(&mut buffer), into);
        }
        GeneratedToken::Text(text) => {
            into.push(3);
            encode_text(text, into);
        }
        GeneratedToken::Group { delimiter, tokens } => {
            into.push(4);
            into.push(match delimiter {
                GeneratedDelimiter::Parenthesis => 0,
                GeneratedDelimiter::Brace => 1,
                GeneratedDelimiter::Bracket => 2,
                GeneratedDelimiter::Bare => 3,
            });
            encode_length(tokens.len(), into);
            for inner in tokens.as_slice() {
                encode_generated(inner, into);
            }
        }
        GeneratedToken::ByteText(material) => {
            into.push(5);
            encode_bytes(material, into);
        }
        GeneratedToken::Number(value) => {
            into.push(6);
            into.extend_from_slice(&value.to_be_bytes());
        }
        GeneratedToken::RawIdentifier(name) => {
            into.push(7);
            encode_text(name, into);
        }
        GeneratedToken::Literal(literal) => {
            into.push(8);
            encode_literal(literal.form(), into);
        }
    }
}

/// Encode one admitted exact literal beneath the generated-literal slot.
fn encode_literal(literal: GeneratedLiteralForm<'_>, into: &mut Vec<u8>) {
    match literal {
        GeneratedLiteralForm::Number(spelling) => {
            into.push(0);
            encode_text(spelling, into);
        }
        GeneratedLiteralForm::Character(character) => {
            into.push(1);
            let mut buffer = [0u8; 4];
            encode_text(character.encode_utf8(&mut buffer), into);
        }
        GeneratedLiteralForm::Byte(byte) => {
            into.push(2);
            into.push(byte);
        }
        GeneratedLiteralForm::NulTerminatedText(material) => {
            into.push(3);
            encode_bytes(material, into);
        }
    }
}

fn encode_text(text: &str, into: &mut Vec<u8>) {
    encode_bytes(text.as_bytes(), into);
}