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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180

/// Construct a `BitVec` out of a literal array in source code, analagous to
/// `vec!`.
///
/// `bitvec!` can be invoked in a number of ways. It takes the name of an
/// `Endian` implementation, the name of a `Bits`-implementing primitive, and
/// zero or more primitives (integer, floating-point, or bool) which are used to
/// build the bits. Each primitive literal corresponds to one bit, and is
/// considered to represent 1 if *any* bit in the representation is set.
///
/// `bitvec!` can be invoked with no specifiers, and `Endian` specifier, or an
/// `Endian` and a `Bits` specifier. It cannot be invoked with a `Bits`
/// specifier but no `Endian` specifier, due to overlap in how those tokens are
/// matched by the macro system.
///
/// Like `vec!`, `bitvec!` supports bit lists `[0, 1, ...]` and repetition
/// markers `[1; n]`.
///
/// # All Syntaxes
///
/// ```rust
/// # use bitvec::*;
/// bitvec![BigEndian, u8; 0, 1];
/// bitvec![LittleEndian, u8; 0, 1,];
/// bitvec![BigEndian; 0, 1];
/// bitvec![LittleEndian; 0, 1,];
/// bitvec![0, 1];
/// bitvec![0, 1,];
/// bitvec![BigEndian, u8; 1; 5];
/// bitvec![LittleEndian; 0; 5];
/// bitvec![1; 5];
/// ```
#[macro_export]
macro_rules! bitvec {
	//  bitvec![endian, type ; 0, 1, ...]
	( $end:ident , $prim:ty ; $( $elt:expr ),* ) => {
		__bitvec_impl![ $end, $prim ; $( $elt ),* ]
	};
	//  bitvec![endian, type ; 0, 1, ..., ]
	( $end:ident , $prim:ty ; $( $elt:expr , )* ) => {
		__bitvec_impl![ $end , $prim ; $( $elt ),* ]
	};
	//  bitvec![endian ; 0, 1, ...]
	( $end:ident ; $( $elt:expr ),* ) => {
		__bitvec_impl![ $end , u8 ; $( $elt ),* ]
	};
	//  bitvec![endian ; 0, 1, ..., ]
	( $end:ident ; $( $elt:expr , )* ) => {
		__bitvec_impl![ $end , u8 ; $( $elt ),* ]
	};
	//  bitvec![0, 1, ...]
	( $( $elt:expr ),* ) => {
		__bitvec_impl![ BigEndian , u8 ; $($elt),* ]
	};
	//  bitvec![0, 1, ..., ]
	( $( $elt:expr , )* ) => {
		__bitvec_impl![ BigEndian , u8 ; $($elt),* ]
	};

	//  bitvec![endian, type, bit; rep]
	( $end:ident , $prim:ty ; $elt:expr ; $rep:expr ) => {
		__bitvec_impl![ $end , $prim ; $elt; $rep ]
	};
	//  bitvec![endian, bit; rep]
	( $end:ident ; $elt:expr ; $rep:expr ) => {
		__bitvec_impl![ $end , u8 ;  $elt; $rep ]
	};
	//  bitvec![bit; rep]
	( $elt:expr ; $rep:expr ) => {
		__bitvec_impl![ BigEndian, u8 ; $elt; $rep ]
	};
}

/// Build an array of `bool` (one bit per byte) and then build a `BitVec` from that (one
/// bit per bit). I have yet to think of a way to make the source array be
/// binary-compatible with a `BitVec` representation, so the static source is 8x larger
/// than it needs to be.
///
/// I'm sure there is a way, but I don’t think I need to spend the effort yet.
#[macro_export]
#[doc(hidden)]
macro_rules! __bitvec_impl {
	( $end:ident , $prim:ty ; $( $elt:expr ),* ) => {{
		let init: &[bool] = &[
			$( $elt as u8 > 0 ),*
		];
		$crate :: BitVec ::< $crate :: $end , $prim >:: from(init)
	}};

	( $end:ident , $prim:ty ; $elt:expr; $rep:expr ) => {{
		::std::iter::repeat( $elt as u8 > 0 )
			.take( $rep )
			.collect ::< $crate :: BitVec < $crate :: $end , $prim > > ()
	}};
}

#[doc(hidden)]
macro_rules! __bitslice_shift {
	( $( $t:ty ),+ ) => { $(
#[doc(hidden)]
impl<E: $crate::Endian, T: $crate::Bits> ShlAssign< $t > for $crate::BitSlice<E, T> {
	fn shl_assign(&mut self, shamt: $t ) {
		ShlAssign::<usize>::shl_assign(self, shamt as usize);
	}
}

#[doc(hidden)]
impl<E: $crate::Endian, T: $crate::Bits> ShrAssign< $t > for $crate::BitSlice<E, T> {
	fn shr_assign(&mut self, shamt: $t ) {
		ShrAssign::<usize>::shr_assign(self, shamt as usize);
	}
}
	)+ };
}

#[doc(hidden)]
macro_rules! __bitvec_shift {
	( $( $t:ty ),+ ) => { $(
#[doc(hidden)]
impl<E: $crate::Endian, T: $crate::Bits> Shl< $t > for $crate::BitVec<E, T> {
	type Output = <Self as Shl<usize>>::Output;

	fn shl(self, shamt: $t ) -> Self::Output {
		Shl::<usize>::shl(self, shamt as usize)
	}
}

#[doc(hidden)]
impl<E: $crate::Endian, T: $crate::Bits> ShlAssign< $t > for $crate::BitVec<E, T> {
	fn shl_assign(&mut self, shamt: $t ) {
		ShlAssign::<usize>::shl_assign(self, shamt as usize)
	}
}

#[doc(hidden)]
impl<E: $crate::Endian, T: $crate::Bits> Shr< $t > for $crate::BitVec<E, T> {
	type Output = <Self as Shr<usize>>::Output;

	fn shr(self, shamt: $t ) -> Self::Output {
		Shr::<usize>::shr(self, shamt as usize)
	}
}

#[doc(hidden)]
impl<E: $crate::Endian, T: $crate::Bits> ShrAssign< $t > for $crate::BitVec<E, T> {
	fn shr_assign(&mut self, shamt: $t ) {
		ShrAssign::<usize>::shr_assign(self, shamt as usize)
	}
}
	)+ };
}

#[cfg(test)]
mod tests {
	#[test]
	fn compile_macros() {
		bitvec![0, 1];
		bitvec![BigEndian; 0, 1];
		bitvec![LittleEndian; 0, 1];
		bitvec![BigEndian, u8; 0, 1];
		bitvec![LittleEndian, u8; 0, 1];
		bitvec![BigEndian, u16; 0, 1];
		bitvec![LittleEndian, u16; 0, 1];
		bitvec![BigEndian, u32; 0, 1];
		bitvec![LittleEndian, u32; 0, 1];
		bitvec![BigEndian, u64; 0, 1];
		bitvec![LittleEndian, u64; 0, 1];

		bitvec![1; 70];
		bitvec![BigEndian; 0; 70];
		bitvec![LittleEndian; 1; 70];
		bitvec![BigEndian, u8; 0; 70];
		bitvec![LittleEndian, u8; 1; 70];
		bitvec![BigEndian, u16; 0; 70];
		bitvec![LittleEndian, u16; 1; 70];
		bitvec![BigEndian, u32; 0; 70];
		bitvec![LittleEndian, u32; 1; 70];
		bitvec![BigEndian, u64; 0; 70];
		bitvec![LittleEndian, u64; 1; 70];
	}
}