Geal / nom / 483

pending completion

Build # 483

Build Type

Pull #184

travis-ci

Committed by

tstorch

Commit Message

<a href="https://github.com/Geal/nom/commit/<a class=hub.com/Geal/nom/commit/cea7679c5b5d9f5efc8604ff77e7aa4212a3f5db">cea7679c5<a href="https://github.com/Geal/nom/commit/cea7679c5b5d9f5efc8604ff77e7aa4212a3f5db">&quot;&gt;Revert &amp;quot;Test overhaul&quot;

This reverts commit </a><a class="double-link" href="https://github.com/Geal/nom/commit/<a class="double-link" href="https://github.com/Geal/nom/commit/d2461c659634a70995292439ef72b264906fe307">d2461c659</a>">d2461c659</a><a href="https://github.com/Geal/nom/commit/cea7679c5b5d9f5efc8604ff77e7aa4212a3f5db">.

Pull Request Pull Request #184: Updated tag and test macro and test overhaul

Run Details

13 of 13 new or added lines in 1 file covered. (100.0%)

2374 of 2840 relevant lines covered (83.59%)

3.24 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.65

/src/util.rs

use internal::{IResult,Err};

#[cfg(not(feature = "core"))]
use std::collections::HashMap;

#[cfg(feature = "core")]
use std::prelude::v1::*;
use std::vec::Vec;
use std::string::ToString;

/// useful functions to calculate the offset between slices and show a hexdump of a slice
#[cfg(not(feature = "core"))]
pub trait HexDisplay {
  /// offset between the first byte of self and the first byte of the argument
  fn offset(&self, second:&[u8]) -> usize;// OFFSET SHOULD GO TO ITS OWN TRAIT

  /// Converts the value of `self` to a hex dump, returning the owned
  /// string.
  fn to_hex(&self, chunk_size: usize) -> String;

  /// Converts the value of `self` to a hex dump beginning at `from` address, returning the owned
  /// string.
  fn to_hex_from(&self, chunk_size: usize, from: usize) -> String;
}

pub trait InputLength {
  #[inline]
  fn input_len(&self) -> usize;
}

impl<'a, T> InputLength for &'a[T] {
  #[inline]
  fn input_len(&self) -> usize {
    self.len()
  }
}

impl<'a> InputLength for &'a str {
  #[inline]
  fn input_len(&self) -> usize {
    self.len()
  }
}

impl<'a> InputLength for (&'a [u8], usize) {
  #[inline]
  fn input_len(&self) -> usize {
    //println!("bit input length for ({:?}, {}):", self.0, self.1);
    let res = self.0.len() * 8 - self.1;
    //println!("-> {}", res);
    res
  }
}

use std::iter::Enumerate;
use std::str::CharIndices;

pub trait AsChar {
    #[inline]
    fn as_char(self)     -> char;
    #[inline]
    fn is_alpha(self)    -> bool;
    #[inline]
    fn is_alphanum(self) -> bool;
    #[inline]
    fn is_0_to_9(self)   -> bool;
    #[inline]
    fn is_hex_digit(self) -> bool;
}

impl<'a> AsChar for &'a u8 {
    #[inline]
    fn as_char(self)     -> char { *self as char }
    #[inline]
    fn is_alpha(self)    -> bool {
      (*self >= 0x41 && *self <= 0x5A) || (*self >= 0x61 && *self <= 0x7A)
    }
    #[inline]
    fn is_alphanum(self) -> bool { self.is_alpha() || self.is_0_to_9() }
    #[inline]
    fn is_0_to_9(self)   -> bool {
      *self >= 0x30 && *self <= 0x39
    }
    #[inline]
    fn is_hex_digit(self) -> bool {
      (*self >= 0x30 && *self <= 0x39) ||
      (*self >= 0x41 && *self <= 0x46) ||
      (*self >= 0x61 && *self <= 0x66)
    }
}

impl AsChar for char {
    #[inline]
    fn as_char(self)     -> char { self }
    #[inline]
    fn is_alpha(self)    -> bool { self.is_alphabetic() }
    #[inline]
    fn is_alphanum(self) -> bool { self.is_alpha() || self.is_0_to_9() }
    #[inline]
    fn is_0_to_9(self)   -> bool { self.is_digit(10) }
    #[inline]
    fn is_hex_digit(self) -> bool { self.is_digit(16) }
}

pub trait IterIndices {
    type Item: AsChar;
    type Iter : Iterator<Item=(usize, Self::Item)>;
    fn iter_indices(self) -> Self::Iter;
}

impl<'a> IterIndices for &'a [u8] {
    type Item = &'a u8;
    type Iter = Enumerate<::std::slice::Iter<'a, u8>>;
    #[inline]
    fn iter_indices(self) -> Enumerate<::std::slice::Iter<'a, u8>> {
        self.iter().enumerate()
    }
}

impl<'a> IterIndices for &'a str {
    type Item = char;
    type Iter = CharIndices<'a>;
    #[inline]
    fn iter_indices(self) -> CharIndices<'a> {
        self.char_indices()
    }
}

static CHARS: &'static[u8] = b"0123456789abcdef";

#[cfg(not(feature = "core"))]
impl HexDisplay for [u8] {
  fn offset(&self, second:&[u8]) -> usize {
    let fst = self.as_ptr();
    let snd = second.as_ptr();

    snd as usize - fst as usize
  }

  #[allow(unused_variables)]
  fn to_hex(&self, chunk_size: usize) -> String {
    self.to_hex_from(chunk_size, 0)
  }

  #[allow(unused_variables)]
  fn to_hex_from(&self, chunk_size: usize, from: usize) -> String {
    let mut v = Vec::with_capacity(self.len() * 3);
    let mut i = from;
    for chunk in self.chunks(chunk_size) {
      let s = format!("{:08x}", i);
      for &ch in s.as_bytes().iter() {
        v.push(ch);
      }
      v.push('\t' as u8);

      i = i + chunk_size;

      for &byte in chunk {
        v.push(CHARS[(byte >> 4) as usize]);
        v.push(CHARS[(byte & 0xf) as usize]);
        v.push(' ' as u8);
      }
      if chunk_size > chunk.len() {
        for j in 0..(chunk_size - chunk.len()) {
          v.push(' ' as u8);
          v.push(' ' as u8);
          v.push(' ' as u8);
        }
      }
      v.push('\t' as u8);

      for &byte in chunk {
        if (byte >=32 && byte <= 126) || byte >= 128 {
          v.push(byte);
        } else {
          v.push('.' as u8);
        }
      }
      v.push('\n' as u8);
    }

    String::from_utf8_lossy(&v[..]).into_owned()
  }
}

/// Prints a message if the parser fails
///
/// The message prints the `Error` or `Incomplete`
/// and the parser's calling code
///
/// ```
/// # #[macro_use] extern crate nom;
/// # fn main() {
///    named!(f, dbg!( tag!( "abcd" ) ) );
///
///    let a = &b"efgh"[..];
///
///    // Will print the following message:
///    // Error(Position(0, [101, 102, 103, 104])) at l.5 by ' tag ! ( "abcd" ) '
///    f(a);
/// # }
/// ```
#[macro_export]
macro_rules! dbg (
  ($i: expr, $submac:ident!( $($args:tt)* )) => (
    {
      let l = line!();
      match $submac!($i, $($args)*) {
        $crate::IResult::Error(a) => {
          println!("Error({:?}) at l.{} by ' {} '", a, l, stringify!($submac!($($args)*)));
          $crate::IResult::Error(a)
        },
        $crate::IResult::Incomplete(a) => {
          println!("Incomplete({:?}) at {} by ' {} '", a, l, stringify!($submac!($($args)*)));
          $crate::IResult::Incomplete(a)
        },
        a => a
      }
    }
  );

  ($i:expr, $f:ident) => (
      dbg!($i, call!($f));
  );
);

/// Prints a message and the input if the parser fails
///
/// The message prints the `Error` or `Incomplete`
/// and the parser's calling code.
///
/// It also displays the input in hexdump format
///
/// ```
/// # #[macro_use] extern crate nom;
/// # fn main() {
///    named!(f, dbg_dmp!( tag!( "abcd" ) ) );
///
///    let a = &b"efghijkl"[..];
///
///    // Will print the following message:
///    // Error(Position(0, [101, 102, 103, 104, 105, 106, 107, 108])) at l.5 by ' tag ! ( "abcd" ) '
///    // 00000000        65 66 67 68 69 6a 6b 6c         efghijkl
///    f(a);
/// # }
#[macro_export]
macro_rules! dbg_dmp (
  ($i: expr, $submac:ident!( $($args:tt)* )) => (
    {
      use $crate::HexDisplay;
      let l = line!();
      match $submac!($i, $($args)*) {
        $crate::IResult::Error(a) => {
          println!("Error({:?}) at l.{} by ' {} '\n{}", a, l, stringify!($submac!($($args)*)), $i.to_hex(8));
          $crate::IResult::Error(a)
        },
        $crate::IResult::Incomplete(a) => {
          println!("Incomplete({:?}) at {} by ' {} '\n{}", a, l, stringify!($submac!($($args)*)), $i.to_hex(8));
          $crate::IResult::Incomplete(a)
        },
        a => a
      }
    }
  );

  ($i:expr, $f:ident) => (
      dbg_dmp!($i, call!($f));
  );
);

pub fn error_to_list<P,E:Clone>(e:&Err<P,E>) -> Vec<ErrorKind<E>> {
  let mut v:Vec<ErrorKind<E>> = Vec::new();
  let mut err = e;
  loop {
    match *err {
      Err::Code(ref i) | Err::Position(ref i,_)                  => {
        v.push(i.clone());
        return v;
      },
      Err::Node(ref i, ref next) | Err::NodePosition(ref i, _, ref next) => {
        v.push(i.clone());
        err = &*next;
      }
    }
  }
}

pub fn compare_error_paths<P,E:Clone+PartialEq>(e1:&Err<P,E>, e2:&Err<P,E>) -> bool {
  error_to_list(e1) == error_to_list(e2)
}

use std::hash::Hash;

#[cfg(not(feature = "core"))]
pub fn add_error_pattern<'a,I,O,E: Clone+Hash+Eq>(h: &mut HashMap<Vec<ErrorKind<E>>, &'a str>, res: IResult<I,O,E>, message: &'a str) -> bool {
  if let IResult::Error(e) = res {
    h.insert(error_to_list(&e), message);
    true
  } else {
    false
  }
}

pub fn slice_to_offsets(input: &[u8], s: &[u8]) -> (usize, usize) {
  let start = input.as_ptr();
  let off1  = s.as_ptr() as usize - start as usize;
  let off2  = off1 + s.len();
  (off1, off2)
}

#[cfg(not(feature = "core"))]
pub fn prepare_errors<O,E: Clone>(input: &[u8], res: IResult<&[u8],O,E>) -> Option<Vec<(ErrorKind<E>, usize, usize)> > {
  if let IResult::Error(e) = res {
    let mut v:Vec<(ErrorKind<E>, usize, usize)> = Vec::new();
    let mut err = e.clone();
    loop {
      match err {
        Err::Position(i,s)            => {
          let (o1, o2) = slice_to_offsets(input, s);
          v.push((i, o1, o2));
          //println!("v is: {:?}", v);
          break;
        },
        Err::NodePosition(i, s, next) => {
          let (o1, o2) = slice_to_offsets(input, s);
          v.push((i, o1, o2));
          err = *next;
        },
        Err::Node(_, next)            => {
          err = *next;
        },
        Err::Code(_)                  => {
          break;
        }
      }
    }
    v.sort_by(|a, b| a.1.cmp(&b.1));
    Some(v)
  } else {
    None
  }
}

#[cfg(not(feature = "core"))]
pub fn print_error<O,E:Clone>(input: &[u8], res: IResult<&[u8],O,E>) {
  if let Some(v) = prepare_errors(input, res) {
    let colors = generate_colors(&v);
    println!("parser codes: {}",   print_codes(colors, HashMap::new()));
    println!("{}",   print_offsets(input, 0, &v));

  } else {
    println!("not an error");
  }
}

#[cfg(not(feature = "core"))]
pub fn generate_colors<E>(v: &[(ErrorKind<E>, usize, usize)]) -> HashMap<u32, u8> {
  let mut h: HashMap<u32, u8> = HashMap::new();
  let mut color = 0;

  for &(ref c,_,_) in v.iter() {
    h.insert(error_to_u32(c), color + 31);
    color = color + 1 % 7;
  }

  h
}

pub fn code_from_offset<E>(v: &[(ErrorKind<E>, usize, usize)], offset: usize) -> Option<u32> {
  let mut acc: Option<(u32, usize, usize)> = None;
  for &(ref ek, s, e) in v.iter() {
    let c = error_to_u32(ek);
    if s <= offset && offset <=e {
      if let Some((_, start, end)) = acc {
        if start <= s && e <= end {
          acc = Some((c, s, e));
        }
      } else {
        acc = Some((c, s, e));
      }
    }
  }
  if let Some((code, _, _)) = acc {
    return Some(code);
  } else {
    return None;
  }
}

pub fn reset_color(v: &mut Vec<u8>) {
  v.push(0x1B);
  v.push('[' as u8);
  v.push(0);
  v.push('m' as u8);
}

pub fn write_color(v: &mut Vec<u8>, color: u8) {
  v.push(0x1B);
  v.push('[' as u8);
  v.push(1);
  v.push(';' as u8);
  let s = color.to_string();
  let bytes = s.as_bytes();
  v.extend(bytes.iter().cloned());
  v.push('m' as u8);
}

#[cfg(not(feature = "core"))]
pub fn print_codes(colors: HashMap<u32, u8>, names: HashMap<u32, &str>) -> String {
  let mut v = Vec::new();
  for (code, &color) in &colors {
    if let Some(&s) = names.get(&code) {
      let bytes = s.as_bytes();
      write_color(&mut v, color);
      v.extend(bytes.iter().cloned());
    } else {
      let s = code.to_string();
      let bytes = s.as_bytes();
      write_color(&mut v, color);
      v.extend(bytes.iter().cloned());
    }
    reset_color(&mut v);
    v.push(' ' as u8);
  }
  reset_color(&mut v);

  String::from_utf8_lossy(&v[..]).into_owned()
}

#[cfg(not(feature = "core"))]
pub fn print_offsets<E>(input: &[u8], from: usize, offsets: &[(ErrorKind<E>, usize, usize)]) -> String {
  let mut v = Vec::with_capacity(input.len() * 3);
  let mut i = from;
  let chunk_size = 8;
  let mut current_code:  Option<u32> = None;
  let mut current_code2: Option<u32> = None;

  let colors = generate_colors(&offsets);

  for chunk in input.chunks(chunk_size) {
    let s = format!("{:08x}", i);
    for &ch in s.as_bytes().iter() {
      v.push(ch);
    }
    v.push('\t' as u8);

    let mut k = i;
    let mut l = i;
    for &byte in chunk {
      if let Some(code) = code_from_offset(&offsets, k) {
        if let Some(current) = current_code {
          if current != code {
            reset_color(&mut v);
            current_code = Some(code);
            if let Some(&color) = colors.get(&code) {
              write_color(&mut v, color);
            }
          }
        } else {
          current_code = Some(code);
          if let Some(&color) = colors.get(&code) {
            write_color(&mut v, color);
          }
        }
      }
      v.push(CHARS[(byte >> 4) as usize]);
      v.push(CHARS[(byte & 0xf) as usize]);
      v.push(' ' as u8);
      k = k + 1;
    }

    reset_color(&mut v);

    if chunk_size > chunk.len() {
      for _ in 0..(chunk_size - chunk.len()) {
        v.push(' ' as u8);
        v.push(' ' as u8);
        v.push(' ' as u8);
      }
    }
    v.push('\t' as u8);

    for &byte in chunk {
      if let Some(code) = code_from_offset(&offsets, l) {
        if let Some(current) = current_code2 {
          if current != code {
            reset_color(&mut v);
            current_code2 = Some(code);
            if let Some(&color) = colors.get(&code) {
              write_color(&mut v, color);
            }
          }
        } else {
          current_code2 = Some(code);
          if let Some(&color) = colors.get(&code) {
            write_color(&mut v, color);
          }
        }
      }
      if (byte >=32 && byte <= 126) || byte >= 128 {
        v.push(byte);
      } else {
        v.push('.' as u8);
      }
      l = l + 1;
    }
    reset_color(&mut v);

    v.push('\n' as u8);
    i = i + chunk_size;
  }

  String::from_utf8_lossy(&v[..]).into_owned()
}

pub trait AsBytes {
  fn as_bytes(&self) -> &[u8];
}

impl<'a> AsBytes for &'a str {
  #[inline(always)]
  fn as_bytes(&self) -> &[u8] {
    str::as_bytes(self)
  }
}

impl AsBytes for str {
  #[inline(always)]
  fn as_bytes(&self) -> &[u8] {
    str::as_bytes(self)
  }
}

impl<'a> AsBytes for &'a [u8] {
  #[inline(always)]
  fn as_bytes(&self) -> &[u8] {
    *self
  }
}

impl AsBytes for [u8] {
  #[inline(always)]
  fn as_bytes(&self) -> &[u8] {
    self
  }
}

macro_rules! array_impls {
  ($($N:expr)+) => {
    $(
      impl<'a> AsBytes for &'a [u8; $N] {
        #[inline(always)]
        fn as_bytes(&self) -> &[u8] {
          *self
        }
      }

      impl AsBytes for [u8; $N] {
        #[inline(always)]
        fn as_bytes(&self) -> &[u8] {
          self
        }
      }
    )+
  };
}


array_impls! {
     0  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
}

/// indicates which parser returned an error
#[derive(Debug,PartialEq,Eq,Hash,Clone)]
pub enum ErrorKind<E=u32> {
  Custom(E),
  Tag,
  MapRes,
  MapOpt,
  Alt,
  IsNot,
  IsA,
  SeparatedList,
  SeparatedNonEmptyList,
  Many1,
  Count,
  TakeUntilAndConsume,
  TakeUntil,
  TakeUntilEitherAndConsume,
  TakeUntilEither,
  LengthValue,
  TagClosure,
  Alpha,
  Digit,
  HexDigit,
  AlphaNumeric,
  Space,
  MultiSpace,
  LengthValueFn,
  Eof,
  ExprOpt,
  ExprRes,
  CondReduce,
  Switch,
  TagBits,
  OneOf,
  NoneOf,
  Char,
  CrLf,
  RegexpMatch,
  RegexpMatches,
  RegexpFind,
  RegexpCapture,
  RegexpCaptures,
  TakeWhile1,
  Complete,
  Fix,
  Escaped,
  EscapedTransform,
  TagStr,
  IsNotStr,
  IsAStr,
  TakeWhile1Str,
  NonEmpty,
  ManyMN,
  TakeUntilAndConsumeStr,
  TakeUntilStr,
}

pub fn error_to_u32<E>(e: &ErrorKind<E>) -> u32 {
  match *e {
    ErrorKind::Custom(_)                 => 0,
    ErrorKind::Tag                       => 1,
    ErrorKind::MapRes                    => 2,
    ErrorKind::MapOpt                    => 3,
    ErrorKind::Alt                       => 4,
    ErrorKind::IsNot                     => 5,
    ErrorKind::IsA                       => 6,
    ErrorKind::SeparatedList             => 7,
    ErrorKind::SeparatedNonEmptyList     => 8,
    ErrorKind::Many1                     => 9,
    ErrorKind::Count                     => 10,
    ErrorKind::TakeUntilAndConsume       => 11,
    ErrorKind::TakeUntil                 => 12,
    ErrorKind::TakeUntilEitherAndConsume => 13,
    ErrorKind::TakeUntilEither           => 14,
    ErrorKind::LengthValue               => 15,
    ErrorKind::TagClosure                => 16,
    ErrorKind::Alpha                     => 17,
    ErrorKind::Digit                     => 18,
    ErrorKind::AlphaNumeric              => 19,
    ErrorKind::Space                     => 20,
    ErrorKind::MultiSpace                => 21,
    ErrorKind::LengthValueFn             => 22,
    ErrorKind::Eof                       => 23,
    ErrorKind::ExprOpt                   => 24,
    ErrorKind::ExprRes                   => 25,
    ErrorKind::CondReduce                => 26,
    ErrorKind::Switch                    => 27,
    ErrorKind::TagBits                   => 28,
    ErrorKind::OneOf                     => 29,
    ErrorKind::NoneOf                    => 30,
    ErrorKind::Char                      => 40,
    ErrorKind::CrLf                      => 41,
    ErrorKind::RegexpMatch               => 42,
    ErrorKind::RegexpMatches             => 43,
    ErrorKind::RegexpFind                => 44,
    ErrorKind::RegexpCapture             => 45,
    ErrorKind::RegexpCaptures            => 46,
    ErrorKind::TakeWhile1                => 47,
    ErrorKind::Complete                  => 48,
    ErrorKind::Fix                       => 49,
    ErrorKind::Escaped                   => 50,
    ErrorKind::EscapedTransform          => 51,
    ErrorKind::TagStr                    => 52,
    ErrorKind::IsNotStr                  => 53,
    ErrorKind::IsAStr                    => 54,
    ErrorKind::TakeWhile1Str             => 55,
    ErrorKind::NonEmpty                  => 56,
    ErrorKind::ManyMN                    => 57,
    ErrorKind::TakeUntilAndConsumeStr    => 58,
    ErrorKind::HexDigit                  => 59,
    ErrorKind::TakeUntilStr              => 60,
  }
}

1	use internal::{IResult,Err};
2		4✔
3	#[cfg(not(feature = "core"))]
4	use std::collections::HashMap;
5
6	#[cfg(feature = "core")]
7	use std::prelude::v1::*;
8	use std::vec::Vec;
9	use std::string::ToString;
10
11	/// useful functions to calculate the offset between slices and show a hexdump of a slice
12	#[cfg(not(feature = "core"))]
13	pub trait HexDisplay {
14	/// offset between the first byte of self and the first byte of the argument
15	fn offset(&self, second:&[u8]) -> usize;// OFFSET SHOULD GO TO ITS OWN TRAIT
16
17	/// Converts the value of `self` to a hex dump, returning the owned
18	/// string.
19	fn to_hex(&self, chunk_size: usize) -> String;
20
21	/// Converts the value of `self` to a hex dump beginning at `from` address, returning the owned
22	/// string.
23	fn to_hex_from(&self, chunk_size: usize, from: usize) -> String;
24	}
25
26	pub trait InputLength {
27	#[inline]
28	fn input_len(&self) -> usize;
29	}
30
31	impl<'a, T> InputLength for &'a[T] {
32	#[inline]
33	fn input_len(&self) -> usize {	4✔
34	self.len()	4✔
35	}	4✔
36	}
37
38	impl<'a> InputLength for &'a str {
39	#[inline]
40	fn input_len(&self) -> usize {	4✔
41	self.len()	4✔
42	}	4✔
43	}
44
45	impl<'a> InputLength for (&'a [u8], usize) {
46	#[inline]
47	fn input_len(&self) -> usize {	4✔
48	//println!("bit input length for ({:?}, {}):", self.0, self.1);
49	let res = self.0.len() * 8 - self.1;	4✔
50	//println!("-> {}", res);
51	res	4✔
52	}	4✔
53	}
54
55	use std::iter::Enumerate;
56	use std::str::CharIndices;
57
58	pub trait AsChar {
59	#[inline]
60	fn as_char(self) -> char;
61	#[inline]
62	fn is_alpha(self) -> bool;
63	#[inline]
64	fn is_alphanum(self) -> bool;
65	#[inline]
66	fn is_0_to_9(self) -> bool;
67	#[inline]
68	fn is_hex_digit(self) -> bool;
69	}
70
71	impl<'a> AsChar for &'a u8 {
72	#[inline]
73	fn as_char(self) -> char { *self as char }	4✔
74	#[inline]
75	fn is_alpha(self) -> bool {	4✔
76	(self >= 0x41 && self <= 0x5A) \|\| (self >= 0x61 && self <= 0x7A)	4✔
77	}	4✔
78	#[inline]
79	fn is_alphanum(self) -> bool { self.is_alpha() \|\| self.is_0_to_9() }	4✔
80	#[inline]
81	fn is_0_to_9(self) -> bool {	4✔
82	self >= 0x30 && self <= 0x39	4✔
83	}	4✔
84	#[inline]
85	fn is_hex_digit(self) -> bool {	4✔
86	(self >= 0x30 && self <= 0x39) \|\|	4✔
87	(self >= 0x41 && self <= 0x46) \|\|	4✔
88	(self >= 0x61 && self <= 0x66)	4✔
89	}	4✔
90	}
91
92	impl AsChar for char {
93	#[inline]
94	fn as_char(self) -> char { self }	4✔
95	#[inline]
96	fn is_alpha(self) -> bool { self.is_alphabetic() }	4✔
97	#[inline]
98	fn is_alphanum(self) -> bool { self.is_alpha() \|\| self.is_0_to_9() }	4✔
99	#[inline]
100	fn is_0_to_9(self) -> bool { self.is_digit(10) }	4✔
101	#[inline]
102	fn is_hex_digit(self) -> bool { self.is_digit(16) }	4✔
103	}
104
105	pub trait IterIndices {
106	type Item: AsChar;
107	type Iter : Iterator<Item=(usize, Self::Item)>;
108	fn iter_indices(self) -> Self::Iter;
109	}
110
111	impl<'a> IterIndices for &'a [u8] {
112	type Item = &'a u8;
113	type Iter = Enumerate<::std::slice::Iter<'a, u8>>;
114	#[inline]
115	fn iter_indices(self) -> Enumerate<::std::slice::Iter<'a, u8>> {	4✔
116	self.iter().enumerate()	4✔
117	}	4✔
118	}
119
120	impl<'a> IterIndices for &'a str {
121	type Item = char;
122	type Iter = CharIndices<'a>;
123	#[inline]
124	fn iter_indices(self) -> CharIndices<'a> {	4✔
125	self.char_indices()	4✔
126	}	4✔
127	}
128
129	static CHARS: &'static[u8] = b"0123456789abcdef";
130
131	#[cfg(not(feature = "core"))]
132	impl HexDisplay for [u8] {
133	fn offset(&self, second:&[u8]) -> usize {	4✔
134	let fst = self.as_ptr();	4✔
135	let snd = second.as_ptr();	4✔
136
137	snd as usize - fst as usize	4✔
138	}	4✔
139
140	#[allow(unused_variables)]
141	fn to_hex(&self, chunk_size: usize) -> String {	4✔
142	self.to_hex_from(chunk_size, 0)	4✔
143	}	4✔
144
145	#[allow(unused_variables)]
146	fn to_hex_from(&self, chunk_size: usize, from: usize) -> String {	4✔
147	let mut v = Vec::with_capacity(self.len() * 3);	4✔
148	let mut i = from;	4✔
149	for chunk in self.chunks(chunk_size) {	4✔
150	let s = format!("{:08x}", i);	4✔
151	for &ch in s.as_bytes().iter() {	4✔
152	v.push(ch);	4✔
153	}
154	v.push('\t' as u8);	4✔
155
156	i = i + chunk_size;	4✔
157
158	for &byte in chunk {	4✔
159	v.push(CHARS[(byte >> 4) as usize]);	4✔
160	v.push(CHARS[(byte & 0xf) as usize]);	4✔
161	v.push(' ' as u8);	4✔
162	}
163	if chunk_size > chunk.len() {	4✔
164	for j in 0..(chunk_size - chunk.len()) {	4✔
165	v.push(' ' as u8);	4✔
166	v.push(' ' as u8);	4✔
167	v.push(' ' as u8);	4✔
168	}
169	}
170	v.push('\t' as u8);	4✔
171
172	for &byte in chunk {	4✔
173	if (byte >=32 && byte <= 126) \|\| byte >= 128 {	4✔
174	v.push(byte);	4✔
175	} else {
176	v.push('.' as u8);	×
177	}
178	}
179	v.push('\n' as u8);	4✔
180	}	4✔
181
182	String::from_utf8_lossy(&v[..]).into_owned()	4✔
183	}	4✔
184	}
185
186	/// Prints a message if the parser fails
187	///
188	/// The message prints the `Error` or `Incomplete`
189	/// and the parser's calling code
190	///
191	/// ```
192	/// # #[macro_use] extern crate nom;
193	/// # fn main() {
194	/// named!(f, dbg!( tag!( "abcd" ) ) );
195	///
196	/// let a = &b"efgh"[..];
197	///
198	/// // Will print the following message:
199	/// // Error(Position(0, [101, 102, 103, 104])) at l.5 by ' tag ! ( "abcd" ) '
200	/// f(a);
201	/// # }
202	/// ```
203	#[macro_export]
204	macro_rules! dbg (
205	($i: expr, $submac:ident!( $($args:tt)* )) => (
206	{
207	let l = line!();
208	match $submac!($i, $($args)*) {
209	$crate::IResult::Error(a) => {
210	println!("Error({:?}) at l.{} by ' {} '", a, l, stringify!($submac!($($args)*)));
211	$crate::IResult::Error(a)
212	},
213	$crate::IResult::Incomplete(a) => {
214	println!("Incomplete({:?}) at {} by ' {} '", a, l, stringify!($submac!($($args)*)));
215	$crate::IResult::Incomplete(a)
216	},
217	a => a
218	}
219	}
220	);
221
222	($i:expr, $f:ident) => (
223	dbg!($i, call!($f));
224	);
225	);
226
227	/// Prints a message and the input if the parser fails
228	///
229	/// The message prints the `Error` or `Incomplete`
230	/// and the parser's calling code.
231	///
232	/// It also displays the input in hexdump format
233	///
234	/// ```
235	/// # #[macro_use] extern crate nom;
236	/// # fn main() {
237	/// named!(f, dbg_dmp!( tag!( "abcd" ) ) );
238	///
239	/// let a = &b"efghijkl"[..];
240	///
241	/// // Will print the following message:
242	/// // Error(Position(0, [101, 102, 103, 104, 105, 106, 107, 108])) at l.5 by ' tag ! ( "abcd" ) '
243	/// // 00000000 65 66 67 68 69 6a 6b 6c efghijkl
244	/// f(a);
245	/// # }
246	#[macro_export]
247	macro_rules! dbg_dmp (
248	($i: expr, $submac:ident!( $($args:tt)* )) => (
249	{
250	use $crate::HexDisplay;
251	let l = line!();
252	match $submac!($i, $($args)*) {
253	$crate::IResult::Error(a) => {
254	println!("Error({:?}) at l.{} by ' {} '\n{}", a, l, stringify!($submac!($($args)*)), $i.to_hex(8));
255	$crate::IResult::Error(a)
256	},
257	$crate::IResult::Incomplete(a) => {
258	println!("Incomplete({:?}) at {} by ' {} '\n{}", a, l, stringify!($submac!($($args)*)), $i.to_hex(8));
259	$crate::IResult::Incomplete(a)
260	},
261	a => a
262	}
263	}
264	);
265
266	($i:expr, $f:ident) => (
267	dbg_dmp!($i, call!($f));
268	);
269	);
270
271	pub fn error_to_list<P,E:Clone>(e:&Err<P,E>) -> Vec<ErrorKind<E>> {	4✔
272	let mut v:Vec<ErrorKind<E>> = Vec::new();	4✔
273	let mut err = e;	4✔
274	loop {	4✔
275	match *err {	4✔
276	Err::Code(ref i) \| Err::Position(ref i,_) => {
277	v.push(i.clone());	4✔
278	return v;	4✔
279	},
280	Err::Node(ref i, ref next) \| Err::NodePosition(ref i, _, ref next) => {
281	v.push(i.clone());	4✔
282	err = &*next;	4✔
283	}
284	}
285	}
286	}	4✔
287
288	pub fn compare_error_paths<P,E:Clone+PartialEq>(e1:&Err<P,E>, e2:&Err<P,E>) -> bool {
289	error_to_list(e1) == error_to_list(e2)
290	}
291
292	use std::hash::Hash;
293
294	#[cfg(not(feature = "core"))]
295	pub fn add_error_pattern<'a,I,O,E: Clone+Hash+Eq>(h: &mut HashMap<Vec<ErrorKind<E>>, &'a str>, res: IResult<I,O,E>, message: &'a str) -> bool {	4✔
296	if let IResult::Error(e) = res {	4✔
297	h.insert(error_to_list(&e), message);	4✔
298	true	4✔
299	} else {	×
300	false
301	}
302	}	4✔
303
304	pub fn slice_to_offsets(input: &[u8], s: &[u8]) -> (usize, usize) {	4✔
305	let start = input.as_ptr();	4✔
306	let off1 = s.as_ptr() as usize - start as usize;	4✔
307	let off2 = off1 + s.len();	4✔
308	(off1, off2)	4✔
309	}	4✔
310
311	#[cfg(not(feature = "core"))]
312	pub fn prepare_errors<O,E: Clone>(input: &[u8], res: IResult<&[u8],O,E>) -> Option<Vec<(ErrorKind<E>, usize, usize)> > {	4✔
313	if let IResult::Error(e) = res {	4✔
314	let mut v:Vec<(ErrorKind<E>, usize, usize)> = Vec::new();	4✔
315	let mut err = e.clone();	4✔
316	loop {	4✔
317	match err {	4✔
318	Err::Position(i,s) => {	4✔
319	let (o1, o2) = slice_to_offsets(input, s);	4✔
320	v.push((i, o1, o2));	4✔
321	//println!("v is: {:?}", v);
322	break;	4✔
323	},
324	Err::NodePosition(i, s, next) => {	4✔
325	let (o1, o2) = slice_to_offsets(input, s);	4✔
326	v.push((i, o1, o2));	4✔
327	err = *next;	4✔
328	},
329	Err::Node(_, next) => {
330	err = *next;	×
331	},
332	Err::Code(_) => {
333	break;	×
334	}
335	}
336	}
337	v.sort_by(\|a, b\| a.1.cmp(&b.1));	4✔
338	Some(v)
339	} else {	4✔
340	None
341	}
342	}	4✔
343
344	#[cfg(not(feature = "core"))]
345	pub fn print_error<O,E:Clone>(input: &[u8], res: IResult<&[u8],O,E>) {	4✔
346	if let Some(v) = prepare_errors(input, res) {	4✔
347	let colors = generate_colors(&v);	4✔
348	println!("parser codes: {}", print_codes(colors, HashMap::new()));	4✔
349	println!("{}", print_offsets(input, 0, &v));	4✔
350
351	} else {	4✔
352	println!("not an error");
353	}
354	}	4✔
355
356	#[cfg(not(feature = "core"))]
357	pub fn generate_colors<E>(v: &[(ErrorKind<E>, usize, usize)]) -> HashMap<u32, u8> {	4✔
358	let mut h: HashMap<u32, u8> = HashMap::new();	4✔
359	let mut color = 0;	4✔
360
361	for &(ref c,_,_) in v.iter() {	4✔
362	h.insert(error_to_u32(c), color + 31);	4✔
363	color = color + 1 % 7;	4✔
364	}
365
366	h	4✔
367	}	4✔
368
369	pub fn code_from_offset<E>(v: &[(ErrorKind<E>, usize, usize)], offset: usize) -> Option<u32> {	4✔
370	let mut acc: Option<(u32, usize, usize)> = None;
371	for &(ref ek, s, e) in v.iter() {	4✔
372	let c = error_to_u32(ek);	4✔
373	if s <= offset && offset <=e {	4✔
374	if let Some((_, start, end)) = acc {	4✔
375	if start <= s && e <= end {	4✔
376	acc = Some((c, s, e));	4✔
377	}
378	} else {
379	acc = Some((c, s, e));	4✔
380	}
381	}
382	}
383	if let Some((code, _, _)) = acc {
384	return Some(code);	4✔
385	} else {
386	return None;	4✔
387	}
388	}	4✔
389
390	pub fn reset_color(v: &mut Vec<u8>) {	4✔
391	v.push(0x1B);	4✔
392	v.push('[' as u8);	4✔
393	v.push(0);	4✔
394	v.push('m' as u8);	4✔
395	}	4✔
396
397	pub fn write_color(v: &mut Vec<u8>, color: u8) {	4✔
398	v.push(0x1B);	4✔
399	v.push('[' as u8);	4✔
400	v.push(1);	4✔
401	v.push(';' as u8);	4✔
402	let s = color.to_string();	4✔
403	let bytes = s.as_bytes();	4✔
404	v.extend(bytes.iter().cloned());	4✔
405	v.push('m' as u8);	4✔
406	}	4✔
407
408	#[cfg(not(feature = "core"))]
409	pub fn print_codes(colors: HashMap<u32, u8>, names: HashMap<u32, &str>) -> String {	4✔
410	let mut v = Vec::new();	4✔
411	for (code, &color) in &colors {	4✔
412	if let Some(&s) = names.get(&code) {	4✔
413	let bytes = s.as_bytes();	×
414	write_color(&mut v, color);	×
415	v.extend(bytes.iter().cloned());	×
416	} else {
417	let s = code.to_string();	4✔
418	let bytes = s.as_bytes();	4✔
419	write_color(&mut v, color);	4✔
420	v.extend(bytes.iter().cloned());	4✔
421	}	4✔
422	reset_color(&mut v);	4✔
423	v.push(' ' as u8);	4✔
424	}
425	reset_color(&mut v);	4✔
426
427	String::from_utf8_lossy(&v[..]).into_owned()	4✔
428	}	4✔
429
430	#[cfg(not(feature = "core"))]
431	pub fn print_offsets<E>(input: &[u8], from: usize, offsets: &[(ErrorKind<E>, usize, usize)]) -> String {	4✔
432	let mut v = Vec::with_capacity(input.len() * 3);	4✔
433	let mut i = from;	4✔
434	let chunk_size = 8;	4✔
435	let mut current_code: Option<u32> = None;
436	let mut current_code2: Option<u32> = None;
437
438	let colors = generate_colors(&offsets);	4✔
439
440	for chunk in input.chunks(chunk_size) {	4✔
441	let s = format!("{:08x}", i);	4✔
442	for &ch in s.as_bytes().iter() {	4✔
443	v.push(ch);	4✔
444	}
445	v.push('\t' as u8);	4✔
446
447	let mut k = i;	4✔
448	let mut l = i;	4✔
449	for &byte in chunk {	4✔
450	if let Some(code) = code_from_offset(&offsets, k) {	4✔
451	if let Some(current) = current_code {
452	if current != code {	4✔
453	reset_color(&mut v);	4✔
454	current_code = Some(code);	4✔
455	if let Some(&color) = colors.get(&code) {	4✔
456	write_color(&mut v, color);	4✔
457	}
458	}
459	} else {
460	current_code = Some(code);	4✔
461	if let Some(&color) = colors.get(&code) {	4✔
462	write_color(&mut v, color);	4✔
463	}
464	}
465	}
466	v.push(CHARS[(byte >> 4) as usize]);	4✔
467	v.push(CHARS[(byte & 0xf) as usize]);	4✔
468	v.push(' ' as u8);	4✔
469	k = k + 1;	4✔
470	}
471
472	reset_color(&mut v);	4✔
473
474	if chunk_size > chunk.len() {	4✔
475	for _ in 0..(chunk_size - chunk.len()) {	4✔
476	v.push(' ' as u8);	4✔
477	v.push(' ' as u8);	4✔
478	v.push(' ' as u8);	4✔
479	}
480	}
481	v.push('\t' as u8);	4✔
482
483	for &byte in chunk {	4✔
484	if let Some(code) = code_from_offset(&offsets, l) {	4✔
485	if let Some(current) = current_code2 {
486	if current != code {	4✔
487	reset_color(&mut v);	4✔
488	current_code2 = Some(code);	4✔
489	if let Some(&color) = colors.get(&code) {	4✔
490	write_color(&mut v, color);	4✔
491	}
492	}
493	} else {
494	current_code2 = Some(code);	4✔
495	if let Some(&color) = colors.get(&code) {	4✔
496	write_color(&mut v, color);	4✔
497	}
498	}
499	}
500	if (byte >=32 && byte <= 126) \|\| byte >= 128 {	4✔
501	v.push(byte);	4✔
502	} else {
503	v.push('.' as u8);	×
504	}
505	l = l + 1;	4✔
506	}
507	reset_color(&mut v);	4✔
508
509	v.push('\n' as u8);	4✔
510	i = i + chunk_size;	4✔
511	}	4✔
512
513	String::from_utf8_lossy(&v[..]).into_owned()	4✔
514	}	4✔
515
516	pub trait AsBytes {
517	fn as_bytes(&self) -> &[u8];
518	}
519
520	impl<'a> AsBytes for &'a str {
521	#[inline(always)]
522	fn as_bytes(&self) -> &[u8] {	1 only 483.4 ✔
523	str::as_bytes(self)	4✔
524	}	1 only 483.4 ✔
525	}
526
527	impl AsBytes for str {
528	#[inline(always)]
529	fn as_bytes(&self) -> &[u8] {
530	str::as_bytes(self)
531	}
532	}
533
534	impl<'a> AsBytes for &'a [u8] {
535	#[inline(always)]
536	fn as_bytes(&self) -> &[u8] {	1 only 483.4 ✔
537	*self
538	}	1 only 483.4 ✔
539	}
540
541	impl AsBytes for [u8] {
542	#[inline(always)]
543	fn as_bytes(&self) -> &[u8] {
544	self
545	}
546	}
547
548	macro_rules! array_impls {
549	($($N:expr)+) => {
550	$(
551	impl<'a> AsBytes for &'a [u8; $N] {
552	#[inline(always)]
553	fn as_bytes(&self) -> &[u8] {
554	*self
555	}
556	}
557
558	impl AsBytes for [u8; $N] {
559	#[inline(always)]
560	fn as_bytes(&self) -> &[u8] {
561	self
562	}
563	}
564	)+
565	};
566	}
567
568
569	array_impls! {
570	0 1 2 3 4 5 6 7 8 9
571	10 11 12 13 14 15 16 17 18 19
572	20 21 22 23 24 25 26 27 28 29
573	30 31 32
574	}
575
576	/// indicates which parser returned an error
577	#[derive(Debug,PartialEq,Eq,Hash,Clone)]	4✔
578	pub enum ErrorKind<E=u32> {
579	Custom(E),	4✔
580	Tag,
581	MapRes,
582	MapOpt,
583	Alt,
584	IsNot,
585	IsA,
586	SeparatedList,
587	SeparatedNonEmptyList,
588	Many1,
589	Count,
590	TakeUntilAndConsume,
591	TakeUntil,
592	TakeUntilEitherAndConsume,
593	TakeUntilEither,
594	LengthValue,
595	TagClosure,
596	Alpha,
597	Digit,
598	HexDigit,
599	AlphaNumeric,
600	Space,
601	MultiSpace,
602	LengthValueFn,
603	Eof,
604	ExprOpt,
605	ExprRes,
606	CondReduce,
607	Switch,
608	TagBits,
609	OneOf,
610	NoneOf,
611	Char,
612	CrLf,
613	RegexpMatch,
614	RegexpMatches,
615	RegexpFind,
616	RegexpCapture,
617	RegexpCaptures,
618	TakeWhile1,
619	Complete,
620	Fix,
621	Escaped,
622	EscapedTransform,
623	TagStr,
624	IsNotStr,
625	IsAStr,
626	TakeWhile1Str,
627	NonEmpty,
628	ManyMN,
629	TakeUntilAndConsumeStr,
630	TakeUntilStr,
631	}
632
633	pub fn error_to_u32<E>(e: &ErrorKind<E>) -> u32 {	4✔
634	match *e {	4✔
635	ErrorKind::Custom(_) => 0,	4✔
636	ErrorKind::Tag => 1,	4✔
637	ErrorKind::MapRes => 2,	×
638	ErrorKind::MapOpt => 3,	×
639	ErrorKind::Alt => 4,	×
640	ErrorKind::IsNot => 5,	×
641	ErrorKind::IsA => 6,	×
642	ErrorKind::SeparatedList => 7,	×
643	ErrorKind::SeparatedNonEmptyList => 8,	×
644	ErrorKind::Many1 => 9,	×
645	ErrorKind::Count => 10,	×
646	ErrorKind::TakeUntilAndConsume => 11,	×
647	ErrorKind::TakeUntil => 12,	×
648	ErrorKind::TakeUntilEitherAndConsume => 13,	×
649	ErrorKind::TakeUntilEither => 14,	×
650	ErrorKind::LengthValue => 15,	×
651	ErrorKind::TagClosure => 16,	×
652	ErrorKind::Alpha => 17,	×
653	ErrorKind::Digit => 18,	×
654	ErrorKind::AlphaNumeric => 19,	×
655	ErrorKind::Space => 20,	×
656	ErrorKind::MultiSpace => 21,	×
657	ErrorKind::LengthValueFn => 22,	×
658	ErrorKind::Eof => 23,	×
659	ErrorKind::ExprOpt => 24,	×
660	ErrorKind::ExprRes => 25,	×
661	ErrorKind::CondReduce => 26,	×
662	ErrorKind::Switch => 27,	×
663	ErrorKind::TagBits => 28,	×
664	ErrorKind::OneOf => 29,	×
665	ErrorKind::NoneOf => 30,	×
666	ErrorKind::Char => 40,	×
667	ErrorKind::CrLf => 41,	×
668	ErrorKind::RegexpMatch => 42,	×
669	ErrorKind::RegexpMatches => 43,	×
670	ErrorKind::RegexpFind => 44,	×
671	ErrorKind::RegexpCapture => 45,	×
672	ErrorKind::RegexpCaptures => 46,	×
673	ErrorKind::TakeWhile1 => 47,	×
674	ErrorKind::Complete => 48,	×
675	ErrorKind::Fix => 49,	×
676	ErrorKind::Escaped => 50,	×
677	ErrorKind::EscapedTransform => 51,	×
678	ErrorKind::TagStr => 52,	×
679	ErrorKind::IsNotStr => 53,	×
680	ErrorKind::IsAStr => 54,	×
681	ErrorKind::TakeWhile1Str => 55,	×
682	ErrorKind::NonEmpty => 56,	×
683	ErrorKind::ManyMN => 57,	×
684	ErrorKind::TakeUntilAndConsumeStr => 58,	×
685	ErrorKind::HexDigit => 59,	×
686	ErrorKind::TakeUntilStr => 60,	×
687	}
688	}	4✔

Geal / nom / 483

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous