lib3d6 0.0.4

Potentially my personal utility library, for now a test
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

use proc_macro::TokenStream;
use std::io::Write;


fn _format(input: TokenStream) -> TokenStream {
    let mut var_vector: Vec<String> = Vec::new();
    let mut print_string = String::new();

    let mut buffer = String::new();
    let mut is_var: bool = false;
    let mut first: bool = true;
    for token in input.to_string().chars() {
        if first {
            if token != 'f' {
                let mut output = "std::format!(".to_owned();
                output.push_str(&input.to_string());
                output.push_str(")");
                let stream: TokenStream = output.parse().unwrap();
                return stream
            } else {
                first = false;
                continue
            }
        }
        let token: String = token.to_string();
        if token.eq("{") {
            is_var = true;
            print_string += "{:?}";
        } else if token.eq("}") {
            is_var = false;
            var_vector.push(buffer);
            buffer = String::new();
        } else if is_var {
            buffer.push_str(&token);
        } else {
            print_string.push_str(&token);
        }
    }

    let mut output = "std::format!(".to_owned();
    output.push_str(&print_string);
    output.push_str(", ");
    output.push_str(&var_vector.join(","));
    output.push_str(")");
    let stream: TokenStream = output.parse().unwrap();
    return stream
}


#[proc_macro]
pub fn format(input: TokenStream) -> TokenStream {
    _format(input)
}


#[proc_macro]
pub fn print(input: TokenStream) -> TokenStream {
    let formated: String = _format(input).to_string();
    let mut buffer = "std::print!(\"{}\", ".to_owned();
    buffer.push_str(&formated);
    buffer.push_str(")");
    let stream: TokenStream = buffer.parse().unwrap();
    return stream
}


#[proc_macro]
pub fn println(input: TokenStream) -> TokenStream {
    let formated: String = _format(input).to_string();
    let mut buffer = "std::println!(\"{}\", ".to_owned();
    buffer.push_str(&formated);
    buffer.push_str(")");
    let stream: TokenStream = buffer.parse().unwrap();
    return stream
}


#[cfg(test)]
mod tests {
}