5 combinator::{map, map_res}, |
5 combinator::{map, map_res}, |
6 multi::separated_list, |
6 multi::separated_list, |
7 sequence::{delimited, pair, preceded, separated_pair}, |
7 sequence::{delimited, pair, preceded, separated_pair}, |
8 IResult, |
8 IResult, |
9 }; |
9 }; |
10 use std::collections::HashMap; |
10 use std::{ |
|
11 collections::HashMap, |
|
12 fmt::{Display, Error, Formatter}, |
|
13 }; |
11 |
14 |
12 type HaskellResult<'a, T> = IResult<&'a [u8], T, ()>; |
15 type HaskellResult<'a, T> = IResult<&'a [u8], T, ()>; |
13 |
16 |
14 #[derive(Debug, PartialEq)] |
17 #[derive(Debug, PartialEq)] |
15 pub enum HaskellValue { |
18 pub enum HaskellValue { |
|
19 Number(u8), |
|
20 String(String), |
|
21 Tuple(Vec<HaskellValue>), |
16 List(Vec<HaskellValue>), |
22 List(Vec<HaskellValue>), |
17 Tuple(Vec<HaskellValue>), |
23 AnonStruct { |
18 String(String), |
24 name: String, |
19 Number(u8), |
25 fields: Vec<HaskellValue>, |
|
26 }, |
20 Struct { |
27 Struct { |
21 name: String, |
28 name: String, |
22 fields: HashMap<String, HaskellValue>, |
29 fields: HashMap<String, HaskellValue>, |
23 }, |
30 }, |
24 AnonStruct { |
31 } |
25 name: String, |
32 |
26 fields: Vec<HaskellValue>, |
33 fn write_sequence( |
27 }, |
34 f: &mut Formatter<'_>, |
|
35 brackets: &[u8; 2], |
|
36 mut items: std::slice::Iter<HaskellValue>, |
|
37 ) -> Result<(), Error> { |
|
38 write!(f, "{}", brackets[0] as char)?; |
|
39 while let Some(value) = items.next() { |
|
40 write!(f, "{}", value); |
|
41 if !items.as_slice().is_empty() { |
|
42 write!(f, ", ")?; |
|
43 } |
|
44 } |
|
45 if brackets[1] != b'\0' { |
|
46 write!(f, "{}", brackets[1] as char) |
|
47 } else { |
|
48 Ok(()) |
|
49 } |
|
50 } |
|
51 |
|
52 fn write_text(f: &mut Formatter<'_>, text: &str) -> Result<(), Error> { |
|
53 write!(f, "\"")?; |
|
54 for c in text.chars() { |
|
55 if c.is_ascii() && !(c as u8).is_ascii_control() { |
|
56 write!(f, "{}", c); |
|
57 } else { |
|
58 let mut bytes = [0u8; 4]; |
|
59 let size = c.encode_utf8(&mut bytes).len(); |
|
60 for byte in &bytes[0..size] { |
|
61 write!(f, "\\{:03}", byte); |
|
62 } |
|
63 } |
|
64 } |
|
65 write!(f, "\"") |
|
66 } |
|
67 |
|
68 impl Display for HaskellValue { |
|
69 fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> { |
|
70 match self { |
|
71 HaskellValue::Number(value) => write!(f, "{}", value), |
|
72 HaskellValue::String(value) => write_text(f, value), |
|
73 HaskellValue::Tuple(items) => write_sequence(f, b"()", items.iter()), |
|
74 HaskellValue::List(items) => write_sequence(f, b"[]", items.iter()), |
|
75 HaskellValue::AnonStruct { name, fields } => { |
|
76 write!(f, "{} ", name); |
|
77 write_sequence(f, b" \0", fields.iter()) |
|
78 } |
|
79 HaskellValue::Struct { name, fields } => { |
|
80 write!(f, "{} {{", name); |
|
81 let fields = fields.iter().collect::<Vec<_>>(); |
|
82 let mut items = fields.iter(); |
|
83 while let Some((field_name, value)) = items.next() { |
|
84 write!(f, "{} = {}", field_name, value); |
|
85 if !items.as_slice().is_empty() { |
|
86 write!(f, ", ")?; |
|
87 } |
|
88 } |
|
89 write!(f, "}}") |
|
90 } |
|
91 } |
|
92 } |
28 } |
93 } |
29 |
94 |
30 fn comma(input: &[u8]) -> HaskellResult<&[u8]> { |
95 fn comma(input: &[u8]) -> HaskellResult<&[u8]> { |
31 delimited(take_while(is_space), tag(","), take_while(is_space))(input) |
96 delimited(take_while(is_space), tag(","), take_while(is_space))(input) |
32 } |
97 } |
103 map(tag("ESC"), |_| &b"\x1B"[..]), |
168 map(tag("ESC"), |_| &b"\x1B"[..]), |
104 map(tag("FS"), |_| &b"\x1C"[..]), |
169 map(tag("FS"), |_| &b"\x1C"[..]), |
105 map(tag("GS"), |_| &b"\x1D"[..]), |
170 map(tag("GS"), |_| &b"\x1D"[..]), |
106 map(tag("RS"), |_| &b"\x1E"[..]), |
171 map(tag("RS"), |_| &b"\x1E"[..]), |
107 map(tag("US"), |_| &b"\x1F"[..]), |
172 map(tag("US"), |_| &b"\x1F"[..]), |
108 map(tag("SP"), |_| &b"\x20"[..]), |
|
109 map(tag("DEL"), |_| &b"\x7F"[..]), |
173 map(tag("DEL"), |_| &b"\x7F"[..]), |
110 )), |
174 )), |
111 ))(input) |
175 ))(input) |
112 } |
176 } |
113 |
177 |