1 //! Bit level parsers and combinators 2 //! 3 //! Bit parsing is handled by tweaking the input in most macros. 4 //! In byte level parsing, the input is generally a `&[u8]` passed from combinator 5 //! to combinator as the slices are manipulated. 6 //! 7 //! Bit parsers take a `(&[u8], usize)` as input. The first part of the tuple is a byte slice, 8 //! the second part is a bit offset in the first byte of the slice. 9 //! 10 //! By passing a pair like this, we can leverage most of the existing combinators, and avoid 11 //! transforming the whole slice to a vector of booleans. This should make it easy 12 //! to see a byte slice as a bit stream, and parse code points of arbitrary bit length. 13 //! 14 15 /// Transforms its byte slice input into a bit stream for the underlying parser. This allows the 16 /// given bit stream parser to work on a byte slice input. 17 /// 18 /// Signature: 19 /// `bits!( parser ) => ( &[u8], (&[u8], usize) -> IResult<(&[u8], usize), T> ) -> IResult<&[u8], T>` 20 /// 21 /// ``` 22 /// # #[macro_use] extern crate nom; 23 /// # fn main() { 24 /// named!( take_4_bits<u8>, bits!( take_bits!( u8, 4 ) ) ); 25 /// 26 /// let input = vec![0xAB, 0xCD, 0xEF, 0x12]; 27 /// let sl = &input[..]; 28 /// 29 /// assert_eq!(take_4_bits( sl ), Ok( (&sl[1..], 0xA) )); 30 /// # } 31 #[macro_export] 32 macro_rules! bits ( 33 ($i:expr, $submac:ident!( $($args:tt)* )) => ( 34 bits_impl!($i, $submac!($($args)*)); 35 ); 36 ($i:expr, $f:expr) => ( 37 bits_impl!($i, call!($f)); 38 ); 39 ); 40 41 #[cfg(feature = "verbose-errors")] 42 /// Internal parser, do not use directly 43 #[doc(hidden)] 44 #[macro_export] 45 macro_rules! bits_impl ( 46 ($i:expr, $submac:ident!( $($args:tt)* )) => ( 47 { 48 use $crate::lib::std::result::Result::*; 49 use $crate::{Context,Err,Needed}; 50 51 let input = ($i, 0usize); 52 match $submac!(input, $($args)*) { 53 Err(Err::Error(e)) => { 54 let err = match e { 55 Context::Code((i,b), kind) => Context::Code(&i[b/8..], kind), 56 Context::List(mut v) => { 57 Context::List(v.drain(..).map(|((i,b), kind)| (&i[b/8..], kind)).collect()) 58 } 59 }; 60 Err(Err::Error(err)) 61 }, 62 Err(Err::Failure(e)) => { 63 let err = match e { 64 Context::Code((i,b), kind) => Context::Code(&i[b/8..], kind), 65 Context::List(mut v) => { 66 Context::List(v.drain(..).map(|((i,b), kind)| (&i[b/8..], kind)).collect()) 67 } 68 }; 69 Err(Err::Failure(err)) 70 }, 71 Err(Err::Incomplete(Needed::Unknown)) => Err(Err::Incomplete(Needed::Unknown)), 72 Err(Err::Incomplete(Needed::Size(i))) => { 73 //println!("bits parser returned Needed::Size({})", i); 74 Err(Err::Incomplete(Needed::Size(i / 8 + 1))) 75 }, 76 Ok(((i, bit_index), o)) => { 77 let byte_index = bit_index / 8 + if bit_index % 8 == 0 { 0 } else { 1 } ; 78 //println!("bit index=={} => byte index=={}", bit_index, byte_index); 79 Ok((&i[byte_index..], o)) 80 } 81 } 82 } 83 ); 84 ); 85 86 #[cfg(not(feature = "verbose-errors"))] 87 /// Internal parser, do not use directly 88 #[doc(hidden)] 89 #[macro_export] 90 macro_rules! bits_impl ( 91 ($i:expr, $submac:ident!( $($args:tt)* )) => ( 92 { 93 use $crate::lib::std::result::Result::*; 94 use $crate::{Err,Needed,Context}; 95 96 let input = ($i, 0usize); 97 match $submac!(input, $($args)*) { 98 Err(Err::Error(e)) => { 99 let Context::Code(_,err) = e; 100 Err(Err::Error(error_position!($i, err))) 101 }, 102 Err(Err::Failure(e)) => { 103 let Context::Code(_,err) = e; 104 Err(Err::Failure(error_position!($i, err))) 105 }, 106 Err(Err::Incomplete(Needed::Unknown)) => Err(Err::Incomplete(Needed::Unknown)), 107 Err(Err::Incomplete(Needed::Size(i))) => { 108 //println!("bits parser returned Needed::Size({})", i); 109 $crate::need_more($i, $crate::Needed::Size(i / 8 + 1)) 110 }, 111 Ok(((i, bit_index), o)) => { 112 let byte_index = bit_index / 8 + if bit_index % 8 == 0 { 0 } else { 1 } ; 113 //println!("bit index=={} => byte index=={}", bit_index, byte_index); 114 Ok((&i[byte_index..], o)) 115 } 116 } 117 } 118 ); 119 ); 120 121 /// Counterpart to bits, bytes! transforms its bit stream input into a byte slice for the underlying 122 /// parser, allowing byte-slice parsers to work on bit streams. 123 /// 124 /// Signature: 125 /// `bytes!( parser ) => ( (&[u8], usize), &[u8] -> IResult<&[u8], T> ) -> IResult<(&[u8], usize), T>`, 126 /// 127 /// A partial byte remaining in the input will be ignored and the given parser will start parsing 128 /// at the next full byte. 129 /// 130 /// ``` 131 /// # #[macro_use] extern crate nom; 132 /// # use nom::rest; 133 /// # fn main() { 134 /// named!( parse<(u8, u8, &[u8])>, bits!( tuple!( 135 /// take_bits!(u8, 4), 136 /// take_bits!(u8, 8), 137 /// bytes!(rest) 138 /// ))); 139 /// 140 /// let input = &[0xde, 0xad, 0xbe, 0xaf]; 141 /// 142 /// assert_eq!(parse( input ), Ok(( &[][..], (0xd, 0xea, &[0xbe, 0xaf][..]) ))); 143 /// # } 144 #[macro_export] 145 macro_rules! bytes ( 146 ($i:expr, $submac:ident!( $($args:tt)* )) => ( 147 bytes_impl!($i, $submac!($($args)*)); 148 ); 149 ($i:expr, $f:expr) => ( 150 bytes_impl!($i, call!($f)); 151 ); 152 ); 153 154 #[cfg(feature = "verbose-errors")] 155 /// Internal parser, do not use directly 156 #[doc(hidden)] 157 #[macro_export] 158 macro_rules! bytes_impl ( 159 ($macro_i:expr, $submac:ident!( $($args:tt)* )) => ( 160 { 161 use $crate::lib::std::result::Result::*; 162 use $crate::{Err,Needed,Context}; 163 164 let inp; 165 if $macro_i.1 % 8 != 0 { 166 inp = & $macro_i.0[1 + $macro_i.1 / 8 ..]; 167 } 168 else { 169 inp = & $macro_i.0[$macro_i.1 / 8 ..]; 170 } 171 172 let sub = $submac!(inp, $($args)*); 173 let res = match sub { 174 Err(Err::Incomplete(Needed::Size(i))) => { 175 Err(Err::Incomplete(Needed::Size(i * 8))) 176 }, 177 Err(Err::Incomplete(Needed::Unknown)) => Err(Err::Incomplete(Needed::Unknown)), 178 Ok((i, o)) => { 179 Ok(((i, 0), o)) 180 }, 181 Err(Err::Error(e)) => { 182 let err = match e { 183 Context::Code(i, c) => Context::Code((i,0), c), 184 Context::List(mut v) => { 185 let (i, c) = v.remove(0); 186 Context::Code((i,0), c) 187 } 188 }; 189 Err(Err::Error(err)) 190 }, 191 Err(Err::Failure(e)) => { 192 let err = match e { 193 Context::Code(i, c) => Context::Code((i,0), c), 194 Context::List(mut v) => { 195 let (i, c) = v.remove(0); 196 Context::Code((i,0), c) 197 } 198 }; 199 Err(Err::Error(err)) 200 }, 201 Err(Err::Incomplete(Needed::Unknown)) => Err(Err::Incomplete(Needed::Unknown)), 202 Err(Err::Incomplete(Needed::Size(i))) => { 203 Err(Err::Incomplete(Needed::Size(i * 8))) 204 }, 205 Ok((i, o)) => { 206 Ok(((i, 0), o)) 207 } 208 }; 209 res 210 } 211 ); 212 ); 213 214 #[cfg(not(feature = "verbose-errors"))] 215 /// Internal parser, do not use directly 216 #[doc(hidden)] 217 #[macro_export] 218 macro_rules! bytes_impl ( 219 ($macro_i:expr, $submac:ident!( $($args:tt)* )) => ( 220 { 221 use $crate::lib::std::result::Result::*; 222 use $crate::{Err,Needed,Context}; 223 224 let inp; 225 if $macro_i.1 % 8 != 0 { 226 inp = & $macro_i.0[1 + $macro_i.1 / 8 ..]; 227 } 228 else { 229 inp = & $macro_i.0[$macro_i.1 / 8 ..]; 230 } 231 232 let sub = $submac!(inp, $($args)*); 233 let res = match sub { 234 Err(Err::Incomplete(Needed::Size(i))) => { 235 Err(Err::Incomplete(Needed::Size(i * 8))) 236 }, 237 Err(Err::Incomplete(Needed::Unknown)) => Err(Err::Incomplete(Needed::Unknown)), 238 Ok((i, o)) => { 239 Ok(((i, 0), o)) 240 }, 241 Err(Err::Error(e)) => { 242 let Context::Code(i, c) = e; 243 Err(Err::Error(Context::Code((i,0), c))) 244 }, 245 Err(Err::Failure(e)) => { 246 let Context::Code(i, c) = e; 247 Err(Err::Failure(Context::Code((i,0), c))) 248 }, 249 }; 250 res 251 } 252 ); 253 ); 254 255 /// Consumes the specified number of bits and returns them as the specified type. 256 /// 257 /// Signature: 258 /// `take_bits!(type, count) => ( (&[T], usize), U, usize) -> IResult<(&[T], usize), U>` 259 /// 260 /// ``` 261 /// # #[macro_use] extern crate nom; 262 /// # fn main() { 263 /// named!( take_pair<(u8, u8)>, bits!( pair!( take_bits!(u8, 4), take_bits!(u8, 4) ) ) ); 264 /// 265 /// let input = vec![0xAB, 0xCD, 0xEF]; 266 /// let sl = &input[..]; 267 /// 268 /// assert_eq!(take_pair( sl ), Ok((&sl[1..], (0xA, 0xB))) ); 269 /// assert_eq!(take_pair( &sl[1..] ), Ok((&sl[2..], (0xC, 0xD))) ); 270 /// # } 271 /// ``` 272 #[macro_export] 273 macro_rules! take_bits ( 274 ($i:expr, $t:ty, $count:expr) => ( 275 { 276 use $crate::lib::std::result::Result::*; 277 use $crate::{Needed,IResult}; 278 279 use $crate::lib::std::ops::Div; 280 use $crate::lib::std::convert::Into; 281 //println!("taking {} bits from {:?}", $count, $i); 282 let (input, bit_offset) = $i; 283 let res : IResult<(&[u8],usize), $t> = if $count == 0 { 284 Ok(( (input, bit_offset), (0 as u8).into())) 285 } else { 286 let cnt = ($count as usize + bit_offset).div(8); 287 if input.len() * 8 < $count as usize + bit_offset { 288 //println!("returning incomplete: {}", $count as usize + bit_offset); 289 $crate::need_more($i, Needed::Size($count as usize)) 290 } else { 291 let mut acc:$t = (0 as u8).into(); 292 let mut offset: usize = bit_offset; 293 let mut remaining: usize = $count; 294 let mut end_offset: usize = 0; 295 296 for byte in input.iter().take(cnt + 1) { 297 if remaining == 0 { 298 break; 299 } 300 let val: $t = if offset == 0 { 301 (*byte as u8).into() 302 } else { 303 (((*byte as u8) << offset) as u8 >> offset).into() 304 }; 305 306 if remaining < 8 - offset { 307 acc += val >> (8 - offset - remaining); 308 end_offset = remaining + offset; 309 break; 310 } else { 311 acc += val << (remaining - (8 - offset)); 312 remaining -= 8 - offset; 313 offset = 0; 314 } 315 } 316 Ok(( (&input[cnt..], end_offset) , acc)) 317 } 318 }; 319 res 320 } 321 ); 322 ); 323 324 /// Matches the given bit pattern. 325 /// 326 /// Signature: 327 /// `tag_bits!(type, count, pattern) => ( (&[T], usize), U, usize, U) -> IResult<(&[T], usize), U>` 328 /// 329 /// The caller must specify the number of bits to consume. The matched value is included in the 330 /// result on success. 331 /// 332 /// ``` 333 /// # #[macro_use] extern crate nom; 334 /// # fn main() { 335 /// named!( take_a<u8>, bits!( tag_bits!(u8, 4, 0xA) ) ); 336 /// 337 /// let input = vec![0xAB, 0xCD, 0xEF]; 338 /// let sl = &input[..]; 339 /// 340 /// assert_eq!(take_a( sl ), Ok((&sl[1..], 0xA)) ); 341 /// # } 342 /// ``` 343 #[macro_export] 344 macro_rules! tag_bits ( 345 ($i:expr, $t:ty, $count:expr, $p: pat) => ( 346 { 347 use $crate::lib::std::result::Result::*; 348 use $crate::{Err,IResult}; 349 350 match take_bits!($i, $t, $count) { 351 Err(Err::Incomplete(i)) => Err(Err::Incomplete(i)), 352 Ok((i, o)) => { 353 if let $p = o { 354 let res: IResult<(&[u8],usize),$t> = Ok((i, o)); 355 res 356 } else { 357 let e: $crate::ErrorKind<u32> = $crate::ErrorKind::TagBits; 358 Err(Err::Error(error_position!($i, e))) 359 } 360 }, 361 _ => { 362 let e: $crate::ErrorKind<u32> = $crate::ErrorKind::TagBits; 363 Err(Err::Error(error_position!($i, e))) 364 } 365 } 366 } 367 ) 368 ); 369 370 #[cfg(test)] 371 mod tests { 372 use lib::std::ops::{AddAssign, Shl, Shr}; 373 use internal::{Err, Needed}; 374 use util::ErrorKind; 375 376 #[test] take_bits()377 fn take_bits() { 378 let input = [0b10_10_10_10, 0b11_11_00_00, 0b00_11_00_11]; 379 let sl = &input[..]; 380 381 assert_eq!(take_bits!((sl, 0), u8, 0), Ok(((sl, 0), 0))); 382 assert_eq!(take_bits!((sl, 0), u8, 8), Ok(((&sl[1..], 0), 170))); 383 assert_eq!(take_bits!((sl, 0), u8, 3), Ok(((&sl[0..], 3), 5))); 384 assert_eq!(take_bits!((sl, 0), u8, 6), Ok(((&sl[0..], 6), 42))); 385 assert_eq!(take_bits!((sl, 1), u8, 1), Ok(((&sl[0..], 2), 0))); 386 assert_eq!(take_bits!((sl, 1), u8, 2), Ok(((&sl[0..], 3), 1))); 387 assert_eq!(take_bits!((sl, 1), u8, 3), Ok(((&sl[0..], 4), 2))); 388 assert_eq!(take_bits!((sl, 6), u8, 3), Ok(((&sl[1..], 1), 5))); 389 assert_eq!(take_bits!((sl, 0), u16, 10), Ok(((&sl[1..], 2), 683))); 390 assert_eq!(take_bits!((sl, 0), u16, 8), Ok(((&sl[1..], 0), 170))); 391 assert_eq!(take_bits!((sl, 6), u16, 10), Ok(((&sl[2..], 0), 752))); 392 assert_eq!(take_bits!((sl, 6), u16, 11), Ok(((&sl[2..], 1), 1504))); 393 assert_eq!(take_bits!((sl, 0), u32, 20), Ok(((&sl[2..], 4), 700_163))); 394 assert_eq!(take_bits!((sl, 4), u32, 20), Ok(((&sl[3..], 0), 716_851))); 395 assert_eq!( 396 take_bits!((sl, 4), u32, 22), 397 Err(Err::Incomplete(Needed::Size(22))) 398 ); 399 } 400 401 #[test] tag_bits()402 fn tag_bits() { 403 let input = [0b10_10_10_10, 0b11_11_00_00, 0b00_11_00_11]; 404 let sl = &input[..]; 405 406 assert_eq!(tag_bits!((sl, 0), u8, 3, 0b101), Ok(((&sl[0..], 3), 5))); 407 assert_eq!(tag_bits!((sl, 0), u8, 4, 0b1010), Ok(((&sl[0..], 4), 10))); 408 } 409 410 named!(ch<(&[u8],usize),(u8,u8)>, 411 do_parse!( 412 tag_bits!(u8, 3, 0b101) >> 413 x: take_bits!(u8, 4) >> 414 y: take_bits!(u8, 5) >> 415 (x,y) 416 ) 417 ); 418 419 #[test] chain_bits()420 fn chain_bits() { 421 let input = [0b10_10_10_10, 0b11_11_00_00, 0b00_11_00_11]; 422 let sl = &input[..]; 423 assert_eq!(ch((&input[..], 0)), Ok(((&sl[1..], 4), (5, 15)))); 424 assert_eq!(ch((&input[..], 4)), Ok(((&sl[2..], 0), (7, 16)))); 425 assert_eq!(ch((&input[..1], 0)), Err(Err::Incomplete(Needed::Size(5)))); 426 } 427 428 named!(ch_bytes<(u8, u8)>, bits!(ch)); 429 #[test] bits_to_bytes()430 fn bits_to_bytes() { 431 let input = [0b10_10_10_10, 0b11_11_00_00, 0b00_11_00_11]; 432 assert_eq!(ch_bytes(&input[..]), Ok((&input[2..], (5, 15)))); 433 assert_eq!(ch_bytes(&input[..1]), Err(Err::Incomplete(Needed::Size(1)))); 434 assert_eq!( 435 ch_bytes(&input[1..]), 436 Err(Err::Error(error_position!(&input[1..], ErrorKind::TagBits))) 437 ); 438 } 439 440 #[derive(PartialEq, Debug)] 441 struct FakeUint(u32); 442 443 impl AddAssign for FakeUint { add_assign(&mut self, other: FakeUint)444 fn add_assign(&mut self, other: FakeUint) { 445 *self = FakeUint(self.0 + other.0); 446 } 447 } 448 449 impl Shr<usize> for FakeUint { 450 type Output = FakeUint; 451 shr(self, shift: usize) -> FakeUint452 fn shr(self, shift: usize) -> FakeUint { 453 FakeUint(self.0 >> shift) 454 } 455 } 456 457 impl Shl<usize> for FakeUint { 458 type Output = FakeUint; 459 shl(self, shift: usize) -> FakeUint460 fn shl(self, shift: usize) -> FakeUint { 461 FakeUint(self.0 << shift) 462 } 463 } 464 465 impl From<u8> for FakeUint { from(i: u8) -> FakeUint466 fn from(i: u8) -> FakeUint { 467 FakeUint(u32::from(i)) 468 } 469 } 470 471 #[test] non_privitive_type()472 fn non_privitive_type() { 473 let input = [0b10_10_10_10, 0b11_11_00_00, 0b00_11_00_11]; 474 let sl = &input[..]; 475 476 assert_eq!( 477 take_bits!((sl, 0), FakeUint, 20), 478 Ok(((&sl[2..], 4), FakeUint(700_163))) 479 ); 480 assert_eq!( 481 take_bits!((sl, 4), FakeUint, 20), 482 Ok(((&sl[3..], 0), FakeUint(716_851))) 483 ); 484 assert_eq!( 485 take_bits!((sl, 4), FakeUint, 22), 486 Err(Err::Incomplete(Needed::Size(22))) 487 ); 488 } 489 } 490