cluConcatBytes 0.1.5

Merges literals into a static array.
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146


use syntax::source_map::Span;
use syntax::tokenstream::TokenTree;
use syntax::ext::base::{ExtCtxt, MacResult, DummyResult, MacEager};
use syntax::ext::build::AstBuilder;
use rustc_plugin::Registry;
use syntax::ast::ExprKind;
use syntax::ast::LitKind;
use syntax::ast::Mutability;
use syntax::ast::LitIntType;
use syntax::ast::UintTy;
use syntax::parse::token::TokenKind;

use syntax::ast::IntTy;


#[doc(hidden)]
#[plugin_registrar]
pub fn plugin_registrar(reg: &mut Registry) {
	reg.register_macro("concat_bytes", cstr);
}

#[doc(hidden)]
pub fn cstr(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree]) -> Box<dyn MacResult + 'static> {
	let mut parser = cx.new_parser_from_tts(args);
	
	
	let mut the_slice = true;
	
	let mut args_len = args.len();
	let mut array_expr = Vec::with_capacity(args_len / 2);
	if args_len > 0 {
		if parser.eat(&TokenKind::At) {
			the_slice = false;
			args_len -= 1;
		}
		
		match parser.parse_expr() {
			Ok(a) => array_expr.push(a),
			Err(_e) => {
				cx.span_err(parser.prev_span, "incorrect data, was expected: &[u8], str, u8, i8");
				return DummyResult::any(sp);
			}
		}
		let mut count_elements = 1;
		while parser.eat(&TokenKind::Comma) {
			args_len -= 1;
			//del comma
			
			match parser.parse_expr() {
				Ok(a) => {
					count_elements += 1;
					array_expr.push(a);
				},
				Err(_e) => {
					cx.span_err(parser.prev_span, "incorrect data, was expected: &[u8], str, u8, i8");
					return DummyResult::any(sp);
				},
			}
		}
		if count_elements != args_len {
			cx.span_err(parser.prev_span, "It was expected ',' or closing of a macro.");
			return DummyResult::any(sp);
		}
	}

	let mut r_array = Vec::with_capacity(args_len * 5);
	'looper: for unk in array_expr.into_iter() {
		match unk.node {
			ExprKind::Lit(ref l) => {
				match l.node {
					LitKind::Str(ref array, _) => {
						let s_array = array.as_str();
						let array = s_array.as_bytes();
						
						for a in array.into_iter() {
							r_array.push(
								cx.expr_lit(sp, LitKind::Int(*a as u128, LitIntType::Unsigned(UintTy::U8)))
							);
						}
					},
					LitKind::ByteStr(ref array) => {
						let array = array.as_slice();
						for a in array.into_iter() {
							r_array.push(
								cx.expr_lit(sp, LitKind::Int(*a as u128, LitIntType::Unsigned(UintTy::U8)))
							);
						}
					},
					
					/*LitKind::Int(0, LitIntType::Unsuffixed) => {
						if unk_index+1 == args_len {
							break 'looper;
						}else {
							cx.span_err(l.span, "trailing byte detected");
							return DummyResult::any(sp);
						}
					},*/
					//Del int.
					
					LitKind::Int(ref a, LitIntType::Unsigned(UintTy::U8)) 
					| LitKind::Int(ref a, LitIntType::Signed(IntTy::I8))
					=> {
						r_array.push(
							cx.expr_lit(sp, LitKind::Int(*a as u128, LitIntType::Unsigned(UintTy::U8)))
						);
					},
					
					LitKind::Byte(ref a) => {
						r_array.push(
							cx.expr_lit(sp, LitKind::Int(*a as u128, LitIntType::Unsigned(UintTy::U8)))
						);
					},
					_ => {
						cx.span_err(l.span, "incorrect data, was expected: &[u8], str, u8, i8");
						return DummyResult::any(sp);
					}
				}
			},
			_ => {
				cx.span_err(unk.span, "incorrect data, was expected: &[u8], str, u8, i8");
				return DummyResult::any(sp);
			}
		}
	}

	//END ARRAY
	
	let mut result = cx.expr(sp, ExprKind::Array(r_array));
	//Array -> [u8]
	
	if the_slice {
		result = cx.expr(
			sp, 
			ExprKind::AddrOf(Mutability::Immutable,
				result //[u8]
			) 
		);// & [u8]
	}
	
	MacEager::expr({
		result
	})// & [u8]
}