cessen/psychopath
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity
99dc371a75
psychopath/src/parse/basics.rs

308 lines
9.7 KiB
Rust
Raw Blame History

//! Some basic nom parsers
#![allow(dead_code)]
use std::str;
use nom::{IResult, Needed, digit, multispace};
use nom::IResult::*;
// Parsers for numbers surrounded by whitespace
named!(pub ws_u32<u32>, delimited!(opt!(multispace), u32_utf8, opt!(multispace)));
named!(pub ws_u64<u64>, delimited!(opt!(multispace), u64_utf8, opt!(multispace)));
named!(pub ws_usize<usize>, delimited!(opt!(multispace), usize_utf8, opt!(multispace)));
named!(pub ws_i32<i32>, delimited!(opt!(multispace), i32_utf8, opt!(multispace)));
named!(pub ws_i64<i64>, delimited!(opt!(multispace), i64_utf8, opt!(multispace)));
named!(pub ws_isize<isize>, delimited!(opt!(multispace), isize_utf8, opt!(multispace)));
named!(pub ws_f32<f32>, delimited!(opt!(multispace), f32_utf8, opt!(multispace)));
named!(pub ws_f64<f64>, delimited!(opt!(multispace), f64_utf8, opt!(multispace)));
// ========================================================
named!(pub u32_utf8<u32>, chain!(
bytes: digit,
|| { str::from_utf8(bytes).unwrap().parse::<u32>().unwrap() }
));
named!(pub i32_utf8<i32>, chain!(
sign: one_of!("-+")? ~
bytes: digit,
|| {
match sign {
Some(s) if s == '-' => -str::from_utf8(bytes).unwrap().parse::<i32>().unwrap(),
_ => str::from_utf8(bytes).unwrap().parse::<i32>().unwrap(),
}
}
));
named!(pub u64_utf8<u64>, chain!(
bytes: digit,
|| { str::from_utf8(bytes).unwrap().parse::<u64>().unwrap() }
));
named!(pub i64_utf8<i64>, chain!(
sign: one_of!("-+")? ~
bytes: digit,
|| {
match sign {
Some(s) if s == '-' => -str::from_utf8(bytes).unwrap().parse::<i64>().unwrap(),
_ => str::from_utf8(bytes).unwrap().parse::<i64>().unwrap(),
}
}
));
named!(pub usize_utf8<usize>, chain!(
bytes: digit,
|| { str::from_utf8(bytes).unwrap().parse::<usize>().unwrap() }
));
named!(pub isize_utf8<isize>, chain!(
sign: one_of!("-+")? ~
bytes: digit,
|| {
match sign {
Some(s) if s == '-' => -str::from_utf8(bytes).unwrap().parse::<isize>().unwrap(),
_ => str::from_utf8(bytes).unwrap().parse::<isize>().unwrap(),
}
}
));
named!(pub f32_utf8<f32>, chain!(
bytes: take_decimal_real,
|| {
str::from_utf8(bytes).unwrap().parse::<f32>().unwrap()
}
));
named!(pub f64_utf8<f64>, chain!(
bytes: take_decimal_real,
|| {
str::from_utf8(bytes).unwrap().parse::<f64>().unwrap()
}
));
fn take_decimal_integer(i: &[u8]) -> IResult<&[u8], &[u8]> {
named!(rr<&[u8], ()>, chain!(
one_of!("-+")? ~
digit,
||{()}
));
match rr(i) {
Done(remaining, _) => {
let m = i.len() - remaining.len();
if m == 0 {
Incomplete(Needed::Unknown)
} else {
Done(&i[m..], &i[0..m])
}
}
Error(e) => Error(e),
Incomplete(e) => Incomplete(e),
}
}
fn take_decimal_real(i: &[u8]) -> IResult<&[u8], &[u8]> {
named!(rr<&[u8], ()>, chain!(
one_of!("-+")? ~
digit ~
complete!(chain!(tag!(".") ~ digit, ||{()}))?,
||{()}
));
match rr(i) {
Done(remaining, _) => {
let m = i.len() - remaining.len();
if m == 0 {
Incomplete(Needed::Unknown)
} else {
Done(&i[m..], &i[0..m])
}
}
Error(e) => Error(e),
Incomplete(e) => Incomplete(e),
}
}
// ========================================================
#[cfg(test)]
mod test {
use nom::IResult;
use nom::IResult::*;
use super::take_decimal_real;
use super::*;
#[test]
fn ws_u32_1() {
assert_eq!(ws_u32(b"42"), Done(&b""[..], 42));
assert_eq!(ws_u32(b" 42"), Done(&b""[..], 42));
assert_eq!(ws_u32(b"42 "), Done(&b""[..], 42));
assert_eq!(ws_u32(b" 42"), Done(&b""[..], 42));
assert_eq!(ws_u32(b" 42 53"), Done(&b"53"[..], 42));
}
#[test]
fn ws_i32_1() {
assert_eq!(ws_i32(b"42"), Done(&b""[..], 42));
assert_eq!(ws_i32(b" 42"), Done(&b""[..], 42));
assert_eq!(ws_i32(b"42 "), Done(&b""[..], 42));
assert_eq!(ws_i32(b" 42"), Done(&b""[..], 42));
assert_eq!(ws_i32(b" 42 53"), Done(&b"53"[..], 42));
}
#[test]
fn ws_i32_2() {
assert_eq!(ws_i32(b"-42"), Done(&b""[..], -42));
assert_eq!(ws_i32(b" -42"), Done(&b""[..], -42));
assert_eq!(ws_i32(b"-42 "), Done(&b""[..], -42));
assert_eq!(ws_i32(b" -42 "), Done(&b""[..], -42));
assert_eq!(ws_i32(b" -42 53"), Done(&b"53"[..], -42));
}
#[test]
fn ws_u64_1() {
assert_eq!(ws_u64(b"42"), Done(&b""[..], 42));
assert_eq!(ws_u64(b" 42"), Done(&b""[..], 42));
assert_eq!(ws_u64(b"42 "), Done(&b""[..], 42));
assert_eq!(ws_u64(b" 42"), Done(&b""[..], 42));
assert_eq!(ws_u64(b" 42 53"), Done(&b"53"[..], 42));
}
#[test]
fn ws_i64_1() {
assert_eq!(ws_i64(b"42"), Done(&b""[..], 42));
assert_eq!(ws_i64(b" 42"), Done(&b""[..], 42));
assert_eq!(ws_i64(b"42 "), Done(&b""[..], 42));
assert_eq!(ws_i64(b" 42"), Done(&b""[..], 42));
assert_eq!(ws_i64(b" 42 53"), Done(&b"53"[..], 42));
}
#[test]
fn ws_i64_2() {
assert_eq!(ws_i64(b"-42"), Done(&b""[..], -42));
assert_eq!(ws_i64(b" -42"), Done(&b""[..], -42));
assert_eq!(ws_i64(b"-42 "), Done(&b""[..], -42));
assert_eq!(ws_i64(b" -42 "), Done(&b""[..], -42));
assert_eq!(ws_i64(b" -42 53"), Done(&b"53"[..], -42));
}
#[test]
fn ws_f32_1() {
assert_eq!(ws_f32(b"42"), Done(&b""[..], 42.0));
assert_eq!(ws_f32(b" 42"), Done(&b""[..], 42.0));
assert_eq!(ws_f32(b"42 "), Done(&b""[..], 42.0));
assert_eq!(ws_f32(b" 42"), Done(&b""[..], 42.0));
assert_eq!(ws_f32(b" 42 53"), Done(&b"53"[..], 42.0));
}
#[test]
fn ws_f32_2() {
assert_eq!(ws_f32(b"42.5"), Done(&b""[..], 42.5));
assert_eq!(ws_f32(b" 42.5"), Done(&b""[..], 42.5));
assert_eq!(ws_f32(b"42.5 "), Done(&b""[..], 42.5));
assert_eq!(ws_f32(b" 42.5"), Done(&b""[..], 42.5));
assert_eq!(ws_f32(b" 42.5 53"), Done(&b"53"[..], 42.5));
}
#[test]
fn ws_f32_3() {
assert_eq!(ws_f32(b"-42.5"), Done(&b""[..], -42.5));
assert_eq!(ws_f32(b" -42.5"), Done(&b""[..], -42.5));
assert_eq!(ws_f32(b"-42.5 "), Done(&b""[..], -42.5));
assert_eq!(ws_f32(b" -42.5"), Done(&b""[..], -42.5));
assert_eq!(ws_f32(b" -42.5 53"), Done(&b"53"[..], -42.5));
}
#[test]
fn ws_f64_1() {
assert_eq!(ws_f64(b"42"), Done(&b""[..], 42.0));
assert_eq!(ws_f64(b" 42"), Done(&b""[..], 42.0));
assert_eq!(ws_f64(b"42 "), Done(&b""[..], 42.0));
assert_eq!(ws_f64(b" 42"), Done(&b""[..], 42.0));
assert_eq!(ws_f64(b" 42 53"), Done(&b"53"[..], 42.0));
}
#[test]
fn ws_f64_2() {
assert_eq!(ws_f64(b"42.5"), Done(&b""[..], 42.5));
assert_eq!(ws_f64(b" 42.5"), Done(&b""[..], 42.5));
assert_eq!(ws_f64(b"42.5 "), Done(&b""[..], 42.5));
assert_eq!(ws_f64(b" 42.5"), Done(&b""[..], 42.5));
assert_eq!(ws_f64(b" 42.5 53"), Done(&b"53"[..], 42.5));
}
#[test]
fn ws_f64_3() {
assert_eq!(ws_f64(b"-42.5"), Done(&b""[..], -42.5));
assert_eq!(ws_f64(b" -42.5"), Done(&b""[..], -42.5));
assert_eq!(ws_f64(b"-42.5 "), Done(&b""[..], -42.5));
assert_eq!(ws_f64(b" -42.5"), Done(&b""[..], -42.5));
assert_eq!(ws_f64(b" -42.5 53"), Done(&b"53"[..], -42.5));
}
#[test]
fn take_decimal_real_1() {
assert_eq!(take_decimal_real(b"-42.3"), Done(&b""[..], &b"-42.3"[..]));
assert_eq!(take_decimal_real(b"42.3"), Done(&b""[..], &b"42.3"[..]));
assert_eq!(take_decimal_real(b"-42"), Done(&b""[..], &b"-42"[..]));
assert_eq!(take_decimal_real(b"+42.3"), Done(&b""[..], &b"+42.3"[..]));
}
#[test]
fn u32_utf8_1() {
assert_eq!(u32_utf8(b"42"), Done(&b""[..], 42));
assert_eq!(u32_utf8(b"-42").is_err(), true);
}
#[test]
fn i32_utf8_1() {
assert_eq!(i32_utf8(b"42"), Done(&b""[..], 42));
assert_eq!(i32_utf8(b"-42"), Done(&b""[..], -42));
assert_eq!(i32_utf8(b"+42"), Done(&b""[..], 42));
assert_eq!(i32_utf8(b"--42").is_err(), true);
assert_eq!(i32_utf8(b"+-42").is_err(), true);
}
#[test]
fn u64_utf8_1() {
assert_eq!(u64_utf8(b"42"), Done(&b""[..], 42));
assert_eq!(u64_utf8(b"-42").is_err(), true);
}
#[test]
fn i64_utf8_1() {
assert_eq!(i64_utf8(b"42"), Done(&b""[..], 42));
assert_eq!(i64_utf8(b"-42"), Done(&b""[..], -42));
assert_eq!(i64_utf8(b"+42"), Done(&b""[..], 42));
assert_eq!(i64_utf8(b"--42").is_err(), true);
assert_eq!(i64_utf8(b"+-42").is_err(), true);
}
#[test]
fn f32_utf8_1() {
assert_eq!(f32_utf8(b"-42.3"), Done(&b""[..], -42.3));
assert_eq!(f32_utf8(b"+42.3"), Done(&b""[..], 42.3));
assert_eq!(f32_utf8(b"42.3"), Done(&b""[..], 42.3));
assert_eq!(f32_utf8(b"42"), Done(&b""[..], 42.0));
}
#[test]
fn f64_utf8_1() {
assert_eq!(f64_utf8(b"-42.3"), Done(&b""[..], -42.3));
assert_eq!(f64_utf8(b"+42.3"), Done(&b""[..], 42.3));
assert_eq!(f64_utf8(b"42.3"), Done(&b""[..], 42.3));
assert_eq!(f64_utf8(b"42"), Done(&b""[..], 42.0));
}
}
Reference in New Issue View Git Blame Copy Permalink