nom-trace 0.2.1

A tracer for nom parsers
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
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

//#![feature(trace_macros)]
#[macro_use]
extern crate nom;
#[macro_use]
extern crate nom_trace;

use nom::{number::complete::recognize_float, character::complete::space0 as sp};

use std::str;
use std::collections::HashMap;

pub fn is_string_character(c: u8) -> bool {
  //FIXME: should validate unicode character
  c != b'"' && c != b'\\'
}

#[derive(Debug, PartialEq)]
pub enum JsonValue {
  Str(String),
  Boolean(bool),
  Num(f64),
  Array(Vec<JsonValue>),
  Object(HashMap<String, JsonValue>),
}

named!(float<f64>, flat_map!(recognize_float, parse_to!(f64)));

//FIXME: handle the cases like \u1234
named!(
  string<&str>,
  delimited!(
    char!('\"'),
    map_res!(
      escaped!(take_while1!(is_string_character), '\\', one_of!("\"bfnrt\\")),
      str::from_utf8
    ),
    char!('\"')
  )
);

named!(
  boolean<bool>,
  alt!(value!(false, tag!("false")) | value!(true, tag!("true")))
);

named!(
  array<Vec<JsonValue>>,
  preceded!(sp, delimited!(
    char!('['),
    separated_list!(char!(','), value),
    preceded!(sp, char!(']'))
  ))
);

named!(
  key_value<(&str, JsonValue)>,
  preceded!(sp, separated_pair!(string, char!(':'), value))
);

named!(
  hash<HashMap<String, JsonValue>>,
  preceded!(sp, map!(
    delimited!(
      char!('{'),
      separated_list!(char!(','), key_value),
      preceded!(sp, char!('}'))
    ),
    |tuple_vec| tuple_vec
      .into_iter()
      .map(|(k, v)| (String::from(k), v))
      .collect()
  ))
);

named!(
  value<JsonValue>,
  preceded!(sp, tr!(alt!(
    tr!(hash)    => { |h| JsonValue::Object(h)            } |
    tr!(array)   => { |v| JsonValue::Array(v)             } |
    tr!(string)  => { |s| JsonValue::Str(String::from(s)) } |
    tr!(float)   => { |f| JsonValue::Num(f)               } |
    tr!(boolean) => { |b| JsonValue::Boolean(b)           }
  )))
);

named!(
  root<JsonValue>,
  tr!(delimited!(
    call!(sp),
    tr!(alt!(
      map!(tr!(hash), JsonValue::Object) |
      map!(tr!(array), JsonValue::Array)
    )),
    not!(complete!(sp))
  ))
);

fn main() {
  let data = b"  { \"a\"\t: 42,
  \"b\": [ \"x\", \"y\", 12 ] ,
  \"c\": { \"hello\" : \"world\"
  }
  }  ";

  match root(data) {
    Ok(val) => println!("parsed value: {:#?}", val),
    Err(e) => {
      println!("parse error: {:?}", e);
      print_trace!();
    }
  }
  reset_trace!();
}