Snap for 8261343 from 33e245682495f988c4e003215a1fda28aa26cf6d to tm-release
Change-Id: I2ccc703643486e564960acdaaeae294e1751fbc6
diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index a624533..d603d8a 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,5 +1,5 @@
{
"git": {
- "sha1": "9678b061d3ed0a6b8e31ce569e024ec25f3dd354"
+ "sha1": "b6f79c4d375ae55e1fd1a35032ebb47a52ea3389"
}
-}
+}
\ No newline at end of file
diff --git a/Android.bp b/Android.bp
index 216642a..6fd9d6f 100644
--- a/Android.bp
+++ b/Android.bp
@@ -23,7 +23,7 @@
host_supported: true,
crate_name: "nom",
cargo_env_compat: true,
- cargo_pkg_version: "7.0.0",
+ cargo_pkg_version: "7.1.0",
srcs: ["src/lib.rs"],
edition: "2018",
features: [
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 49ef3f5..a1bff5c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,38 @@
### Changed
+## 7.1.0 - 2021-11-04
+
+### Thanks
+
+- @nickelc
+- @Stargateur
+- @NilsIrl
+- @clonejo
+- @Strytyp
+- @schubart
+- @jihchi
+- @nipunn1313
+- @Gungy2
+- @Drumato
+- @Alexhuszagh
+- @Aehmlo
+- @homersimpsons
+- @dne
+- @epage
+- @saiintbrisson
+- @pymongo
+
+### Changed
+
+- documentation fixes
+- Ci fixes
+- the move to minimal-lexical for float parsing introduced bugs that cannot be resolved right now, so this version moves back to using the standard lib' parser. *This is a performance regression**. If you have specific requirements around float parsing, you are strongly encouraged to use [recognize_float](https://docs.rs/nom/latest/nom/number/complete/fn.recognize_float.html) and another library to convert to a f32 or f64
+
+### Added
+
+- alt now works with 1 elment tuples
+
## 7.0.0 - 2021-08-21
This release fixes dependency compilation issues and strengthen the minimum supported Rust version (MSRV) policy. This is also the first release without the macros that were used since nom's beginning.
@@ -84,7 +116,7 @@
- lots of documentation fixes
- relax trait bounds
-- workarounds for depenency issues with bitvec and memchr
+- workarounds for dependency issues with bitvec and memchr
## 6.1.2 - 2021-02-15
@@ -245,7 +277,7 @@
- removed the deprecated `whitespace` module
- the default error type is now a struct (`nom::error::Error`) instead of a tuple
- the `FromExternalError` allows wrapping the error returned by the function in the `map_res` combinator
-- renamed the `dbg!` macro to avoid conficts with `std::dbg!`
+- renamed the `dbg!` macro to avoid conflicts with `std::dbg!`
- `separated_list` now allows empty elements
@@ -256,7 +288,7 @@
- `success`: returns a value without consuming the input
- `satisfy`: checks a predicate over the next character
- `eof` function combinator
-- `consumed`: returnes the produced value and the consumed input
+- `consumed`: returns the produced value and the consumed input
- `length_count` function combinator
- `into`: converts a parser's output and error values if `From` implementations are available
- `IResult::finish()`: converts a parser's result to `Result<(I, O), E>` by removing the distinction between `Error` and `Failure` and panicking on `Incomplete`
@@ -1124,7 +1156,7 @@
## 0.3.11 - 2015-08-04
### Thanks
-- @bluss for remarking that the crate included random junk lying non commited in my local repository
+- @bluss for remarking that the crate included random junk lying non committed in my local repository
### Fixed
- cleanup of my local repository will ship less files in the crates, resulting in a smaller download
@@ -1187,7 +1219,7 @@
### Added
- documentation for a few functions
- the consumer trait now requires the `failed(&self, error_code)` method in case of parsing error
-- `named!` now handles thge alternative `named!(pub fun_name<OutputType>, ...)`
+- `named!` now handles the alternative `named!(pub fun_name<OutputType>, ...)`
### Fixed
- `filter!` now returns the whole input if the filter function never returned false
diff --git a/Cargo.toml b/Cargo.toml
index 1a14020..6e38fa0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,7 +12,7 @@
[package]
edition = "2018"
name = "nom"
-version = "7.0.0"
+version = "7.1.0"
authors = ["contact@geoffroycouprie.com"]
include = ["CHANGELOG.md", "LICENSE", "README.md", ".gitignore", "Cargo.toml", "src/*.rs", "src/*/*.rs", "tests/*.rs", "doc/nom_recipes.md", "build.rs"]
autoexamples = false
@@ -31,15 +31,16 @@
codegen-units = 1
debug = true
-[lib]
-bench = false
-
[[example]]
name = "json"
path = "examples/json.rs"
required-features = ["alloc"]
[[example]]
+name = "iterator"
+path = "examples/iterator.rs"
+
+[[example]]
name = "s_expression"
path = "examples/s_expression.rs"
required-features = ["alloc"]
@@ -57,9 +58,6 @@
required-features = ["alloc"]
[[test]]
-name = "blockbuf-arithmetic"
-
-[[test]]
name = "css"
[[test]]
@@ -100,51 +98,16 @@
[[test]]
name = "fnmut"
required-features = ["alloc"]
-
-[[bench]]
-name = "arithmetic"
-path = "benches/arithmetic.rs"
-harness = false
-
-[[bench]]
-name = "number"
-path = "benches/number.rs"
-harness = false
-
-[[bench]]
-name = "http"
-path = "benches/http.rs"
-harness = false
-
-[[bench]]
-name = "ini"
-path = "benches/ini.rs"
-harness = false
-
-[[bench]]
-name = "ini_str"
-path = "benches/ini_str.rs"
-harness = false
-
-[[bench]]
-name = "json"
-path = "benches/json.rs"
-harness = false
[dependencies.memchr]
-version = "2.0"
+version = "2.3"
default-features = false
[dependencies.minimal-lexical]
-version = "0.1.2"
-[dev-dependencies.criterion]
-version = "0.3"
-
+version = "0.2.0"
+default-features = false
[dev-dependencies.doc-comment]
version = "0.3"
-[dev-dependencies.jemallocator]
-version = "^0.3"
-
[dev-dependencies.proptest]
version = "1.0.0"
[build-dependencies.version_check]
@@ -154,7 +117,7 @@
alloc = []
default = ["std"]
docsrs = []
-std = ["alloc", "memchr/use_std"]
+std = ["alloc", "memchr/std", "minimal-lexical/std"]
[badges.coveralls]
branch = "master"
repository = "Geal/nom"
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index b2e176a..4e5b011 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,7 +1,7 @@
[package]
name = "nom"
-version = "7.0.0"
+version = "7.1.0"
authors = [ "contact@geoffroycouprie.com" ]
description = "A byte-oriented, zero-copy, parser combinators library"
license = "MIT"
@@ -28,20 +28,19 @@
[features]
alloc = []
-std = ["alloc", "memchr/use_std"]
+std = ["alloc", "memchr/std", "minimal-lexical/std"]
default = ["std"]
docsrs = []
-[dependencies]
-minimal-lexical = "0.1.2"
+[dependencies.minimal-lexical]
+version = "0.2.0"
+default-features = false
[dependencies.memchr]
-version = "2.0"
+version = "2.3"
default-features = false
[dev-dependencies]
-criterion = "0.3"
-jemallocator = "^0.3"
doc-comment = "0.3"
proptest = "1.0.0"
@@ -57,9 +56,6 @@
lto = true
codegen-units = 1
-[lib]
-bench = false
-
[[test]]
name = "arithmetic"
@@ -68,9 +64,6 @@
required-features = ["alloc"]
[[test]]
-name = "blockbuf-arithmetic"
-
-[[test]]
name = "css"
[[test]]
@@ -112,43 +105,14 @@
name = "fnmut"
required-features = ["alloc"]
-[[bench]]
-name = "arithmetic"
-path = "benches/arithmetic.rs"
-harness = false
-
-[[bench]]
-name = "number"
-path = "benches/number.rs"
-harness = false
-
-[[bench]]
-name = "http"
-path = "benches/http.rs"
-harness = false
-
-[[bench]]
-name = "ini"
-path = "benches/ini.rs"
-harness = false
-
-[[bench]]
-name = "ini_str"
-path = "benches/ini_str.rs"
-harness = false
-
-[[bench]]
-name = "json"
-path = "benches/json.rs"
-harness = false
-
[[example]]
name = "json"
required-features = ["alloc"]
path = "examples/json.rs"
-#[[example]]
-#name = "iterator"
+[[example]]
+name = "iterator"
+path = "examples/iterator.rs"
[[example]]
name = "s_expression"
@@ -164,3 +128,6 @@
travis-ci = { repository = "Geal/nom" }
coveralls = { repository = "Geal/nom", branch = "master", service = "github" }
maintenance = { status = "actively-developed" }
+
+[workspace]
+members = [".", "benchmarks/"]
diff --git a/METADATA b/METADATA
index c61aba3..504894c 100644
--- a/METADATA
+++ b/METADATA
@@ -7,13 +7,13 @@
}
url {
type: ARCHIVE
- value: "https://static.crates.io/crates/nom/nom-7.0.0.crate"
+ value: "https://static.crates.io/crates/nom/nom-7.1.0.crate"
}
- version: "7.0.0"
+ version: "7.1.0"
license_type: NOTICE
last_upgrade_date {
- year: 2021
- month: 9
- day: 23
+ year: 2022
+ month: 3
+ day: 1
}
}
diff --git a/README.md b/README.md
index e1bf4a8..1a95f96 100644
--- a/README.md
+++ b/README.md
@@ -2,8 +2,8 @@
[](LICENSE)
[](https://gitter.im/Geal/nom?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-[](https://travis-ci.org/Geal/nom)
-[](https://coveralls.io/r/Geal/nom?branch=master)
+[](https://github.com/Geal/nom/actions/workflows/ci.yml)
+[](https://coveralls.io/github/Geal/nom?branch=master)
[](https://crates.io/crates/nom)
[](#rust-version-requirements)
@@ -248,7 +248,9 @@
[Elm](https://github.com/cout970/Elm-interpreter),
[SystemVerilog](https://github.com/dalance/sv-parser),
[Turtle](https://github.com/vandenoever/rome/tree/master/src/io/turtle),
-[CSML](https://github.com/CSML-by-Clevy/csml-interpreter)
+[CSML](https://github.com/CSML-by-Clevy/csml-interpreter),
+[Wasm](https://github.com/Strytyp/wasm-nom),
+[Pseudocode](https://github.com/Gungy2/pseudocode)
- Interface definition formats: [Thrift](https://github.com/thehydroimpulse/thrust)
- Audio, video and image formats:
[GIF](https://github.com/Geal/gif.rs),
diff --git a/src/bits/complete.rs b/src/bits/complete.rs
index e9ad81a..b46bc7a 100644
--- a/src/bits/complete.rs
+++ b/src/bits/complete.rs
@@ -50,7 +50,7 @@
ErrorKind::Eof,
)))
} else {
- let mut acc: O = (0 as u8).into();
+ let mut acc: O = 0_u8.into();
let mut offset: usize = bit_offset;
let mut remaining: usize = count;
let mut end_offset: usize = 0;
diff --git a/src/bits/streaming.rs b/src/bits/streaming.rs
index 700b903..e8adc1c 100644
--- a/src/bits/streaming.rs
+++ b/src/bits/streaming.rs
@@ -24,7 +24,7 @@
if input.input_len() * 8 < count + bit_offset {
Err(Err::Incomplete(Needed::new(count as usize)))
} else {
- let mut acc: O = (0 as u8).into();
+ let mut acc: O = 0_u8.into();
let mut offset: usize = bit_offset;
let mut remaining: usize = count;
let mut end_offset: usize = 0;
@@ -78,3 +78,52 @@
})
}
}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ #[test]
+ fn test_take_0() {
+ let input = [].as_ref();
+ let count = 0usize;
+ assert_eq!(count, 0usize);
+ let offset = 0usize;
+
+ let result: crate::IResult<(&[u8], usize), usize> = take(count)((input, offset));
+
+ assert_eq!(result, Ok(((input, offset), 0)));
+ }
+
+ #[test]
+ fn test_tag_ok() {
+ let input = [0b00011111].as_ref();
+ let offset = 0usize;
+ let bits_to_take = 4usize;
+ let value_to_tag = 0b0001;
+
+ let result: crate::IResult<(&[u8], usize), usize> =
+ tag(value_to_tag, bits_to_take)((input, offset));
+
+ assert_eq!(result, Ok(((input, bits_to_take), value_to_tag)));
+ }
+
+ #[test]
+ fn test_tag_err() {
+ let input = [0b00011111].as_ref();
+ let offset = 0usize;
+ let bits_to_take = 4usize;
+ let value_to_tag = 0b1111;
+
+ let result: crate::IResult<(&[u8], usize), usize> =
+ tag(value_to_tag, bits_to_take)((input, offset));
+
+ assert_eq!(
+ result,
+ Err(crate::Err::Error(crate::error::Error {
+ input: (input, offset),
+ code: ErrorKind::TagBits
+ }))
+ );
+ }
+}
diff --git a/src/branch/mod.rs b/src/branch/mod.rs
index 902d4e8..9df5a29 100644
--- a/src/branch/mod.rs
+++ b/src/branch/mod.rs
@@ -46,7 +46,7 @@
/// like this: `alt(parser_a, alt(parser_b, parser_c))`
///
/// ```rust
-/// # #[macro_use] extern crate nom;
+/// # use nom::error_position;
/// # use nom::{Err,error::ErrorKind, Needed, IResult};
/// use nom::character::complete::{alpha1, digit1};
/// use nom::branch::alt;
@@ -89,7 +89,6 @@
/// tuple of the parser results.
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err,error::{Error, ErrorKind}, Needed, IResult};
/// use nom::character::complete::{alpha1, digit1};
/// use nom::branch::permutation;
@@ -183,6 +182,15 @@
alt_trait!(A B C D E F G H I J K L M N O P Q R S T U);
+// Manually implement Alt for (A,), the 1-tuple type
+impl<Input, Output, Error: ParseError<Input>, A: Parser<Input, Output, Error>>
+ Alt<Input, Output, Error> for (A,)
+{
+ fn choice(&mut self, input: Input) -> IResult<Input, Output, Error> {
+ self.0.parse(input)
+ }
+}
+
macro_rules! permutation_trait(
(
$name1:ident $ty1:ident $item1:ident
diff --git a/src/bytes/complete.rs b/src/bytes/complete.rs
index 8a0c88b..9375b1f 100644
--- a/src/bytes/complete.rs
+++ b/src/bytes/complete.rs
@@ -18,7 +18,6 @@
/// It will return `Err(Err::Error((_, ErrorKind::Tag)))` if the input doesn't match the pattern
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::bytes::complete::tag;
///
@@ -59,7 +58,6 @@
/// It will return `Err(Err::Error((_, ErrorKind::Tag)))` if the input doesn't match the pattern.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::bytes::complete::tag_no_case;
///
@@ -104,7 +102,6 @@
/// It will return a `Err::Error(("", ErrorKind::IsNot))` if the pattern wasn't met.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::bytes::complete::is_not;
///
@@ -138,7 +135,6 @@
/// It will return a `Err(Err::Error((_, ErrorKind::IsA)))` if the pattern wasn't met.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::bytes::complete::is_a;
///
@@ -171,7 +167,6 @@
/// takes the input and returns a bool)*.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::ErrorKind, Needed, IResult};
/// use nom::bytes::complete::take_while;
/// use nom::character::is_alphabetic;
@@ -203,7 +198,6 @@
/// It will return an `Err(Err::Error((_, ErrorKind::TakeWhile1)))` if the pattern wasn't met.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::bytes::complete::take_while1;
/// use nom::character::is_alphabetic;
@@ -238,7 +232,6 @@
/// of range (m <= len <= n).
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::bytes::complete::take_while_m_n;
/// use nom::character::is_alphabetic;
@@ -322,7 +315,6 @@
/// takes the input and returns a bool)*.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::ErrorKind, Needed, IResult};
/// use nom::bytes::complete::take_till;
///
@@ -354,7 +346,6 @@
/// predicate matches the first input.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::bytes::complete::take_till1;
///
@@ -385,7 +376,6 @@
/// It will return `Err(Err::Error((_, ErrorKind::Eof)))` if the input is shorter than the argument.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::bytes::complete::take;
///
@@ -418,7 +408,6 @@
/// if the pattern wasn't met.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::bytes::complete::take_until;
///
@@ -454,7 +443,6 @@
/// if the pattern wasn't met.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::bytes::complete::take_until1;
///
@@ -493,7 +481,6 @@
/// * The third argument matches the escaped characters
/// # Example
/// ```
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::ErrorKind, Needed, IResult};
/// # use nom::character::complete::digit1;
/// use nom::bytes::complete::escaped;
@@ -597,7 +584,6 @@
/// As an example, the chain `abc\tdef` could be `abc def` (it also consumes the control character)
///
/// ```
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::ErrorKind, Needed, IResult};
/// # use std::str::from_utf8;
/// use nom::bytes::complete::{escaped_transform, tag};
diff --git a/src/bytes/streaming.rs b/src/bytes/streaming.rs
index 8deac13..e972760 100644
--- a/src/bytes/streaming.rs
+++ b/src/bytes/streaming.rs
@@ -16,7 +16,6 @@
/// the input that matches the argument.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::bytes::streaming::tag;
///
@@ -58,7 +57,6 @@
/// the input that matches the argument with no regard to case.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::bytes::streaming::tag_no_case;
///
@@ -104,7 +102,6 @@
/// It will return a `Err::Incomplete(Needed::new(1))` if the pattern wasn't met.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::ErrorKind, Needed, IResult};
/// use nom::bytes::streaming::is_not;
///
@@ -140,7 +137,6 @@
/// or if the pattern reaches the end of the input.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::ErrorKind, Needed, IResult};
/// use nom::bytes::streaming::is_a;
///
@@ -176,7 +172,6 @@
/// *Streaming version* will return a `Err::Incomplete(Needed::new(1))` if the pattern reaches the end of the input.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::ErrorKind, Needed, IResult};
/// use nom::bytes::streaming::take_while;
/// use nom::character::is_alphabetic;
@@ -212,7 +207,6 @@
///
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::bytes::streaming::take_while1;
/// use nom::character::is_alphabetic;
@@ -249,7 +243,6 @@
///
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::bytes::streaming::take_while_m_n;
/// use nom::character::is_alphabetic;
@@ -335,7 +328,6 @@
///
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::ErrorKind, Needed, IResult};
/// use nom::bytes::streaming::take_till;
///
@@ -368,7 +360,6 @@
/// end of input or if there was not match.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::bytes::streaming::take_till1;
///
@@ -406,7 +397,6 @@
///
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::ErrorKind, Needed, IResult};
/// use nom::bytes::streaming::take;
///
@@ -441,7 +431,6 @@
/// contain the pattern or if the input is smaller than the pattern.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::ErrorKind, Needed, IResult};
/// use nom::bytes::streaming::take_until;
///
@@ -481,7 +470,6 @@
/// contain the pattern or if the input is smaller than the pattern.
/// # Example
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::bytes::streaming::take_until1;
///
@@ -521,7 +509,6 @@
/// * The third argument matches the escaped characters
/// # Example
/// ```
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::ErrorKind, Needed, IResult};
/// # use nom::character::complete::digit1;
/// use nom::bytes::streaming::escaped;
@@ -614,7 +601,6 @@
/// As an example, the chain `abc\tdef` could be `abc def` (it also consumes the control character)
///
/// ```
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::ErrorKind, Needed, IResult};
/// # use std::str::from_utf8;
/// use nom::bytes::streaming::{escaped_transform, tag};
@@ -629,7 +615,7 @@
/// alt((
/// value("\\", tag("\\")),
/// value("\"", tag("\"")),
-/// value("n", tag("\n")),
+/// value("\n", tag("n")),
/// ))
/// )(input)
/// }
diff --git a/src/combinator/mod.rs b/src/combinator/mod.rs
index a2e59fb..7071cc7 100644
--- a/src/combinator/mod.rs
+++ b/src/combinator/mod.rs
@@ -56,7 +56,6 @@
/// Maps a function on the result of a parser.
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// use nom::{Err,error::ErrorKind, IResult,Parser};
/// use nom::character::complete::digit1;
/// use nom::combinator::map;
@@ -85,7 +84,6 @@
/// Applies a function returning a `Result` over the result of a parser.
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err,error::ErrorKind, IResult};
/// use nom::character::complete::digit1;
/// use nom::combinator::map_res;
@@ -124,7 +122,6 @@
/// Applies a function returning an `Option` over the result of a parser.
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err,error::ErrorKind, IResult};
/// use nom::character::complete::digit1;
/// use nom::combinator::map_opt;
@@ -163,7 +160,6 @@
/// Applies a parser over the result of another one.
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err,error::ErrorKind, IResult};
/// use nom::character::complete::digit1;
/// use nom::bytes::complete::take;
@@ -195,7 +191,6 @@
/// Creates a new parser from the output of the first parser, then apply that parser over the rest of the input.
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err,error::ErrorKind, IResult};
/// use nom::bytes::complete::take;
/// use nom::number::complete::u8;
@@ -210,11 +205,11 @@
/// ```
pub fn flat_map<I, O1, O2, E: ParseError<I>, F, G, H>(
mut parser: F,
- applied_parser: G,
+ mut applied_parser: G,
) -> impl FnMut(I) -> IResult<I, O2, E>
where
F: Parser<I, O1, E>,
- G: Fn(O1) -> H,
+ G: FnMut(O1) -> H,
H: Parser<I, O2, E>,
{
move |input: I| {
@@ -226,7 +221,6 @@
/// Optional parser: Will return `None` if not successful.
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err,error::ErrorKind, IResult};
/// use nom::combinator::opt;
/// use nom::character::complete::alpha1;
@@ -257,7 +251,6 @@
/// Calls the parser if the condition is met.
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, IResult};
/// use nom::combinator::cond;
/// use nom::character::complete::alpha1;
@@ -295,7 +288,6 @@
/// Tries to apply its parser without consuming the input.
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err,error::ErrorKind, IResult};
/// use nom::combinator::peek;
/// use nom::character::complete::alpha1;
@@ -326,7 +318,6 @@
/// will succeed
///
/// ```
-/// # #[macro_use] extern crate nom;
/// # use std::str;
/// # use nom::{Err, error::ErrorKind, IResult};
/// # use nom::combinator::eof;
@@ -349,7 +340,6 @@
/// Transforms Incomplete into `Error`.
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err,error::ErrorKind, IResult};
/// use nom::bytes::streaming::take;
/// use nom::combinator::complete;
@@ -377,7 +367,6 @@
/// Succeeds if all the input has been consumed by its child parser.
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err,error::ErrorKind, IResult};
/// use nom::combinator::all_consuming;
/// use nom::character::complete::alpha1;
@@ -411,7 +400,6 @@
/// parser.
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err,error::ErrorKind, IResult};
/// use nom::combinator::verify;
/// use nom::character::complete::alpha1;
@@ -449,7 +437,6 @@
/// Returns the provided value if the child parser succeeds.
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err,error::ErrorKind, IResult};
/// use nom::combinator::value;
/// use nom::character::complete::alpha1;
@@ -474,7 +461,6 @@
/// Succeeds if the child parser returns an error.
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err,error::ErrorKind, IResult};
/// use nom::combinator::not;
/// use nom::character::complete::alpha1;
@@ -503,7 +489,6 @@
/// If the child parser was successful, return the consumed input as produced value.
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err,error::ErrorKind, IResult};
/// use nom::combinator::recognize;
/// use nom::character::complete::{char, alpha1};
@@ -544,7 +529,6 @@
/// Returned tuple is of the format `(consumed input, produced output)`.
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err,error::ErrorKind, IResult};
/// use nom::combinator::{consumed, value, recognize, map};
/// use nom::character::complete::{char, alpha1};
@@ -594,7 +578,6 @@
/// transforms an error to failure
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err,error::ErrorKind, IResult};
/// use nom::combinator::cut;
/// use nom::character::complete::alpha1;
@@ -622,7 +605,6 @@
/// as long as the `Into` implementations are available
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::IResult;
/// use nom::combinator::into;
/// use nom::character::complete::alpha1;
@@ -753,7 +735,6 @@
/// specify the default case.
///
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err,error::ErrorKind, IResult};
/// use nom::branch::alt;
/// use nom::combinator::{success, value};
diff --git a/src/internal.rs b/src/internal.rs
index 762f3d8..8a3c6a1 100644
--- a/src/internal.rs
+++ b/src/internal.rs
@@ -259,7 +259,7 @@
/// Creates a second parser from the output of the first one, then apply over the rest of the input
fn flat_map<G, H, O2>(self, g: G) -> FlatMap<Self, G, O>
where
- G: Fn(O) -> H,
+ G: FnMut(O) -> H,
H: Parser<I, O2, E>,
Self: core::marker::Sized,
{
diff --git a/src/lib.rs b/src/lib.rs
index 98cd585..1ce115a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -136,13 +136,13 @@
//! A parser in nom is a function which, for an input type `I`, an output type `O`
//! and an optional error type `E`, will have the following signature:
//!
-//! ```rust,ignore
+//! ```rust,compile_fail
//! fn parser(input: I) -> IResult<I, O, E>;
//! ```
//!
//! Or like this, if you don't want to specify a custom error type (it will be `(I, ErrorKind)` by default):
//!
-//! ```rust,ignore
+//! ```rust,compile_fail
//! fn parser(input: I) -> IResult<I, O>;
//! ```
//!
@@ -445,29 +445,21 @@
#[macro_use]
pub mod error;
-#[macro_use]
+pub mod combinator;
mod internal;
mod traits;
#[macro_use]
-pub mod combinator;
-#[macro_use]
pub mod branch;
-#[macro_use]
-pub mod sequence;
-#[macro_use]
pub mod multi;
+pub mod sequence;
-#[macro_use]
-pub mod bytes;
-#[macro_use]
pub mod bits;
+pub mod bytes;
-#[macro_use]
pub mod character;
mod str;
-#[macro_use]
pub mod number;
#[cfg(feature = "docsrs")]
diff --git a/src/multi/mod.rs b/src/multi/mod.rs
index 9f72888..a119134 100644
--- a/src/multi/mod.rs
+++ b/src/multi/mod.rs
@@ -260,7 +260,6 @@
/// * `sep` Parses the separator between list elements.
/// * `f` Parses the elements of the list.
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::multi::separated_list1;
/// use nom::bytes::complete::tag;
@@ -332,7 +331,6 @@
/// * `n` The maximum number of iterations.
/// * `f` The parser to apply.
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::ErrorKind, Needed, IResult};
/// use nom::multi::many_m_n;
/// use nom::bytes::complete::tag;
@@ -399,7 +397,6 @@
/// # Arguments
/// * `f` The parser to apply.
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::ErrorKind, Needed, IResult};
/// use nom::multi::many0_count;
/// use nom::bytes::complete::tag;
@@ -452,7 +449,6 @@
/// # Arguments
/// * `f` The parser to apply.
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::multi::many1_count;
/// use nom::bytes::complete::tag;
@@ -509,7 +505,6 @@
/// * `f` The parser to apply.
/// * `count` How often to apply the parser.
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::multi::count;
/// use nom::bytes::complete::tag;
@@ -562,7 +557,6 @@
/// * `f` The parser to apply.
/// * `buf` The slice to fill
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::multi::fill;
/// use nom::bytes::complete::tag;
@@ -616,7 +610,6 @@
/// * `g` The function that combines a result of `f` with
/// the current accumulator.
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::ErrorKind, Needed, IResult};
/// use nom::multi::fold_many0;
/// use nom::bytes::complete::tag;
@@ -687,7 +680,6 @@
/// * `g` The function that combines a result of `f` with
/// the current accumulator.
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::multi::fold_many1;
/// use nom::bytes::complete::tag;
@@ -768,7 +760,6 @@
/// * `g` The function that combines a result of `f` with
/// the current accumulator.
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::ErrorKind, Needed, IResult};
/// use nom::multi::fold_many_m_n;
/// use nom::bytes::complete::tag;
@@ -847,7 +838,6 @@
/// # Arguments
/// * `f` The parser to apply.
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::ErrorKind, Needed, IResult};
/// use nom::number::complete::be_u16;
/// use nom::multi::length_data;
@@ -892,7 +882,6 @@
/// * `f` The parser to apply.
/// * `g` The parser to apply on the subslice.
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::number::complete::be_u16;
/// use nom::multi::length_value;
@@ -941,7 +930,6 @@
/// * `f` The parser to apply to obtain the count.
/// * `g` The parser to apply repeatedly.
/// ```rust
-/// # #[macro_use] extern crate nom;
/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
/// use nom::number::complete::u8;
/// use nom::multi::length_count;
diff --git a/src/number/complete.rs b/src/number/complete.rs
index c5553a4..d23079e 100644
--- a/src/number/complete.rs
+++ b/src/number/complete.rs
@@ -1426,6 +1426,40 @@
)(input)
}
+// workaround until issues with minimal-lexical are fixed
+#[doc(hidden)]
+pub fn recognize_float_or_exceptions<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
+where
+ T: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>>,
+ T: Clone + Offset,
+ T: InputIter + InputTake + Compare<&'static str>,
+ <T as InputIter>::Item: AsChar,
+ T: InputTakeAtPosition,
+ <T as InputTakeAtPosition>::Item: AsChar,
+{
+ alt((
+ |i: T| {
+ recognize_float::<_, E>(i.clone()).map_err(|e| match e {
+ crate::Err::Error(_) => crate::Err::Error(E::from_error_kind(i, ErrorKind::Float)),
+ crate::Err::Failure(_) => crate::Err::Failure(E::from_error_kind(i, ErrorKind::Float)),
+ crate::Err::Incomplete(needed) => crate::Err::Incomplete(needed),
+ })
+ },
+ |i: T| {
+ crate::bytes::complete::tag_no_case::<_, _, E>("nan")(i.clone())
+ .map_err(|_| crate::Err::Error(E::from_error_kind(i, ErrorKind::Float)))
+ },
+ |i: T| {
+ crate::bytes::complete::tag_no_case::<_, _, E>("inf")(i.clone())
+ .map_err(|_| crate::Err::Error(E::from_error_kind(i, ErrorKind::Float)))
+ },
+ |i: T| {
+ crate::bytes::complete::tag_no_case::<_, _, E>("infinity")(i.clone())
+ .map_err(|_| crate::Err::Error(E::from_error_kind(i, ErrorKind::Float)))
+ },
+ ))(input)
+}
+
/// Recognizes a floating point number in text format and returns the integer, fraction and exponent parts of the input data
///
/// *Complete version*: Can parse until the end of input.
@@ -1444,7 +1478,7 @@
let (i, sign) = sign(input.clone())?;
//let (i, zeroes) = take_while(|c: <T as InputTakeAtPosition>::Item| c.as_char() == '0')(i)?;
- let (i, zeroes) = match i.as_bytes().iter().position(|c| *c != b'0' as u8) {
+ let (i, zeroes) = match i.as_bytes().iter().position(|c| *c != b'0') {
Some(index) => i.take_split(index),
None => i.take_split(i.input_len()),
};
@@ -1452,7 +1486,7 @@
let (i, mut integer) = match i
.as_bytes()
.iter()
- .position(|c| !(*c >= b'0' as u8 && *c <= b'9' as u8))
+ .position(|c| !(*c >= b'0' && *c <= b'9'))
{
Some(index) => i.take_split(index),
None => i.take_split(i.input_len()),
@@ -1472,8 +1506,8 @@
let mut zero_count = 0usize;
let mut position = None;
for (pos, c) in i.as_bytes().iter().enumerate() {
- if *c >= b'0' as u8 && *c <= b'9' as u8 {
- if *c == b'0' as u8 {
+ if *c >= b'0' && *c <= b'9' {
+ if *c == b'0' {
zero_count += 1;
} else {
zero_count = 0;
@@ -1517,6 +1551,8 @@
Ok((i, (sign, integer, fraction, exp)))
}
+use crate::traits::ParseTo;
+
/// Recognizes floating point number in text format and returns a f32.
///
/// *Complete version*: Can parse until the end of input.
@@ -1537,7 +1573,7 @@
pub fn float<T, E: ParseError<T>>(input: T) -> IResult<T, f32, E>
where
T: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>> + Slice<Range<usize>>,
- T: Clone + Offset,
+ T: Clone + Offset + ParseTo<f32> + Compare<&'static str>,
T: InputIter + InputLength + InputTake,
<T as InputIter>::Item: AsChar + Copy,
<T as InputIter>::IterElem: Clone,
@@ -1546,6 +1582,7 @@
T: AsBytes,
T: for<'a> Compare<&'a [u8]>,
{
+ /*
let (i, (sign, integer, fraction, exponent)) = recognize_float_parts(input)?;
let mut float: f32 = minimal_lexical::parse_float(
@@ -1558,18 +1595,27 @@
}
Ok((i, float))
+ */
+ let (i, s) = recognize_float_or_exceptions(input)?;
+ match s.parse_to() {
+ Some(f) => (Ok((i, f))),
+ None => Err(crate::Err::Error(E::from_error_kind(
+ i,
+ crate::error::ErrorKind::Float,
+ ))),
+ }
}
-/// Recognizes floating point number in text format and returns a f32.
+/// Recognizes floating point number in text format and returns a f64.
///
/// *Complete version*: Can parse until the end of input.
/// ```rust
/// # use nom::{Err, error::ErrorKind, Needed};
/// # use nom::Needed::Size;
-/// use nom::number::complete::float;
+/// use nom::number::complete::double;
///
/// let parser = |s| {
-/// float(s)
+/// double(s)
/// };
///
/// assert_eq!(parser("11e-1"), Ok(("", 1.1)));
@@ -1580,7 +1626,7 @@
pub fn double<T, E: ParseError<T>>(input: T) -> IResult<T, f64, E>
where
T: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>> + Slice<Range<usize>>,
- T: Clone + Offset,
+ T: Clone + Offset + ParseTo<f64> + Compare<&'static str>,
T: InputIter + InputLength + InputTake,
<T as InputIter>::Item: AsChar + Copy,
<T as InputIter>::IterElem: Clone,
@@ -1589,6 +1635,7 @@
T: AsBytes,
T: for<'a> Compare<&'a [u8]>,
{
+ /*
let (i, (sign, integer, fraction, exponent)) = recognize_float_parts(input)?;
let mut float: f64 = minimal_lexical::parse_float(
@@ -1601,6 +1648,15 @@
}
Ok((i, float))
+ */
+ let (i, s) = recognize_float_or_exceptions(input)?;
+ match s.parse_to() {
+ Some(f) => (Ok((i, f))),
+ None => Err(crate::Err::Error(E::from_error_kind(
+ i,
+ crate::error::ErrorKind::Float,
+ ))),
+ }
}
#[cfg(test)]
@@ -1608,7 +1664,6 @@
use super::*;
use crate::error::ErrorKind;
use crate::internal::Err;
- use crate::traits::ParseTo;
use proptest::prelude::*;
macro_rules! assert_parse(
@@ -1942,6 +1997,7 @@
"12.34",
"-1.234E-12",
"-1.234e-12",
+ "0.00000000000000000087",
];
for test in test_cases.drain(..) {
@@ -1965,6 +2021,14 @@
recognize_float(remaining_exponent),
Err(Err::Failure(("", ErrorKind::Digit)))
);
+
+ let (_i, nan) = float::<_, ()>("NaN").unwrap();
+ assert!(nan.is_nan());
+
+ let (_i, inf) = float::<_, ()>("inf").unwrap();
+ assert!(inf.is_infinite());
+ let (_i, inf) = float::<_, ()>("infinite").unwrap();
+ assert!(inf.is_infinite());
}
#[test]
@@ -2050,6 +2114,7 @@
);
}
+ #[cfg(feature = "std")]
fn parse_f64(i: &str) -> IResult<&str, f64, ()> {
match recognize_float(i) {
Err(e) => Err(e),
diff --git a/src/number/streaming.rs b/src/number/streaming.rs
index 3ca445f..7c53ccc 100644
--- a/src/number/streaming.rs
+++ b/src/number/streaming.rs
@@ -1395,6 +1395,40 @@
)(input)
}
+// workaround until issues with minimal-lexical are fixed
+#[doc(hidden)]
+pub fn recognize_float_or_exceptions<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
+where
+ T: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>>,
+ T: Clone + Offset,
+ T: InputIter + InputTake + InputLength + Compare<&'static str>,
+ <T as InputIter>::Item: AsChar,
+ T: InputTakeAtPosition,
+ <T as InputTakeAtPosition>::Item: AsChar,
+{
+ alt((
+ |i: T| {
+ recognize_float::<_, E>(i.clone()).map_err(|e| match e {
+ crate::Err::Error(_) => crate::Err::Error(E::from_error_kind(i, ErrorKind::Float)),
+ crate::Err::Failure(_) => crate::Err::Failure(E::from_error_kind(i, ErrorKind::Float)),
+ crate::Err::Incomplete(needed) => crate::Err::Incomplete(needed),
+ })
+ },
+ |i: T| {
+ crate::bytes::streaming::tag_no_case::<_, _, E>("nan")(i.clone())
+ .map_err(|_| crate::Err::Error(E::from_error_kind(i, ErrorKind::Float)))
+ },
+ |i: T| {
+ crate::bytes::streaming::tag_no_case::<_, _, E>("inf")(i.clone())
+ .map_err(|_| crate::Err::Error(E::from_error_kind(i, ErrorKind::Float)))
+ },
+ |i: T| {
+ crate::bytes::streaming::tag_no_case::<_, _, E>("infinity")(i.clone())
+ .map_err(|_| crate::Err::Error(E::from_error_kind(i, ErrorKind::Float)))
+ },
+ ))(input)
+}
+
/// Recognizes a floating point number in text format and returns the integer, fraction and exponent parts of the input data
///
/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there is not enough data.
@@ -1413,7 +1447,7 @@
let (i, sign) = sign(input.clone())?;
//let (i, zeroes) = take_while(|c: <T as InputTakeAtPosition>::Item| c.as_char() == '0')(i)?;
- let (i, zeroes) = match i.as_bytes().iter().position(|c| *c != b'0' as u8) {
+ let (i, zeroes) = match i.as_bytes().iter().position(|c| *c != b'0') {
Some(index) => i.take_split(index),
None => i.take_split(i.input_len()),
};
@@ -1422,7 +1456,7 @@
let (i, mut integer) = match i
.as_bytes()
.iter()
- .position(|c| !(*c >= b'0' as u8 && *c <= b'9' as u8))
+ .position(|c| !(*c >= b'0' && *c <= b'9'))
{
Some(index) => i.take_split(index),
None => i.take_split(i.input_len()),
@@ -1442,8 +1476,8 @@
let mut zero_count = 0usize;
let mut position = None;
for (pos, c) in i.as_bytes().iter().enumerate() {
- if *c >= b'0' as u8 && *c <= b'9' as u8 {
- if *c == b'0' as u8 {
+ if *c >= b'0' && *c <= b'9' {
+ if *c == b'0' {
zero_count += 1;
} else {
zero_count = 0;
@@ -1512,7 +1546,7 @@
where
T: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>>,
T: Clone + Offset,
- T: InputIter + InputLength + InputTake + crate::traits::ParseTo<i32>,
+ T: InputIter + InputLength + InputTake + crate::traits::ParseTo<f32> + Compare<&'static str>,
<T as InputIter>::Item: AsChar,
<T as InputIter>::IterElem: Clone,
T: InputTakeAtPosition,
@@ -1520,6 +1554,7 @@
T: AsBytes,
T: for<'a> Compare<&'a [u8]>,
{
+ /*
let (i, (sign, integer, fraction, exponent)) = recognize_float_parts(input)?;
let mut float: f32 = minimal_lexical::parse_float(
@@ -1532,19 +1567,28 @@
}
Ok((i, float))
+ */
+ let (i, s) = recognize_float_or_exceptions(input)?;
+ match s.parse_to() {
+ Some(f) => (Ok((i, f))),
+ None => Err(crate::Err::Error(E::from_error_kind(
+ i,
+ crate::error::ErrorKind::Float,
+ ))),
+ }
}
-/// Recognizes floating point number in text format and returns a f32.
+/// Recognizes floating point number in text format and returns a f64.
///
/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there is not enough data.
///
/// ```rust
/// # use nom::{Err, error::ErrorKind, Needed};
/// # use nom::Needed::Size;
-/// use nom::number::complete::float;
+/// use nom::number::complete::double;
///
/// let parser = |s| {
-/// float(s)
+/// double(s)
/// };
///
/// assert_eq!(parser("11e-1"), Ok(("", 1.1)));
@@ -1556,7 +1600,7 @@
where
T: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>>,
T: Clone + Offset,
- T: InputIter + InputLength + InputTake + crate::traits::ParseTo<i32>,
+ T: InputIter + InputLength + InputTake + crate::traits::ParseTo<f64> + Compare<&'static str>,
<T as InputIter>::Item: AsChar,
<T as InputIter>::IterElem: Clone,
T: InputTakeAtPosition,
@@ -1564,6 +1608,7 @@
T: AsBytes,
T: for<'a> Compare<&'a [u8]>,
{
+ /*
let (i, (sign, integer, fraction, exponent)) = recognize_float_parts(input)?;
let mut float: f64 = minimal_lexical::parse_float(
@@ -1576,6 +1621,15 @@
}
Ok((i, float))
+ */
+ let (i, s) = recognize_float_or_exceptions(input)?;
+ match s.parse_to() {
+ Some(f) => (Ok((i, f))),
+ None => Err(crate::Err::Error(E::from_error_kind(
+ i,
+ crate::error::ErrorKind::Float,
+ ))),
+ }
}
#[cfg(test)]
@@ -1583,7 +1637,6 @@
use super::*;
use crate::error::ErrorKind;
use crate::internal::{Err, Needed};
- use crate::traits::ParseTo;
use proptest::prelude::*;
macro_rules! assert_parse(
@@ -2023,6 +2076,7 @@
"12.34",
"-1.234E-12",
"-1.234e-12",
+ "0.00000000000000000087",
];
for test in test_cases.drain(..) {
@@ -2046,6 +2100,14 @@
recognize_float(remaining_exponent),
Err(Err::Incomplete(Needed::new(1)))
);
+
+ let (_i, nan) = float::<_, ()>("NaN").unwrap();
+ assert!(nan.is_nan());
+
+ let (_i, inf) = float::<_, ()>("inf").unwrap();
+ assert!(inf.is_infinite());
+ let (_i, inf) = float::<_, ()>("infinite").unwrap();
+ assert!(inf.is_infinite());
}
#[test]
@@ -2131,7 +2193,9 @@
);
}
+ #[cfg(feature = "std")]
fn parse_f64(i: &str) -> IResult<&str, f64, ()> {
+ use crate::traits::ParseTo;
match recognize_float(i) {
Err(e) => Err(e),
Ok((i, s)) => {
diff --git a/src/sequence/mod.rs b/src/sequence/mod.rs
index bf5dcfd..100c63f 100644
--- a/src/sequence/mod.rs
+++ b/src/sequence/mod.rs
@@ -12,6 +12,7 @@
/// # Arguments
/// * `first` The first parser to apply.
/// * `second` The second parser to apply.
+///
/// ```rust
/// # use nom::{Err, error::ErrorKind, Needed};
/// # use nom::Needed::Size;
@@ -45,6 +46,7 @@
/// # Arguments
/// * `first` The opening parser.
/// * `second` The second parser to get object.
+///
/// ```rust
/// # use nom::{Err, error::ErrorKind, Needed};
/// # use nom::Needed::Size;
@@ -78,6 +80,7 @@
/// # Arguments
/// * `first` The first parser to apply.
/// * `second` The second parser to match an object.
+///
/// ```rust
/// # use nom::{Err, error::ErrorKind, Needed};
/// # use nom::Needed::Size;
@@ -113,6 +116,7 @@
/// * `first` The first parser to apply.
/// * `sep` The separator parser to apply.
/// * `second` The second parser to apply.
+///
/// ```rust
/// # use nom::{Err, error::ErrorKind, Needed};
/// # use nom::Needed::Size;
@@ -151,6 +155,7 @@
/// * `first` The first parser to apply and discard.
/// * `second` The second parser to apply.
/// * `third` The third parser to apply and discard.
+///
/// ```rust
/// # use nom::{Err, error::ErrorKind, Needed};
/// # use nom::Needed::Size;
diff --git a/src/str.rs b/src/str.rs
index e8d38c6..1a8b8ba 100644
--- a/src/str.rs
+++ b/src/str.rs
@@ -88,7 +88,7 @@
);
assert!(
output == CONSUMED,
- "Parser `take_s` doens't return the string it consumed on success. Expected `{}`, got `{}`.",
+ "Parser `take_s` doesn't return the string it consumed on success. Expected `{}`, got `{}`.",
CONSUMED,
output
);
@@ -120,7 +120,7 @@
assert!(
output == CONSUMED,
"Parser `take_until`\
- doens't return the string it consumed on success. Expected `{}`, got `{}`.",
+ doesn't return the string it consumed on success. Expected `{}`, got `{}`.",
CONSUMED,
output
);
@@ -281,7 +281,7 @@
);
assert!(
output == CONSUMED,
- "Parser `is_not` doens't return the string it consumed on success. Expected `{}`, got `{}`.",
+ "Parser `is_not` doesn't return the string it consumed on success. Expected `{}`, got `{}`.",
CONSUMED,
output
);
@@ -432,7 +432,7 @@
);
assert!(
output == CONSUMED,
- "Parser `is_a` doens't return the string it consumed on success. Expected `{}`, got `{}`.",
+ "Parser `is_a` doesn't return the string it consumed on success. Expected `{}`, got `{}`.",
CONSUMED,
output
);
diff --git a/src/traits.rs b/src/traits.rs
index a073fd3..3c3053e 100644
--- a/src/traits.rs
+++ b/src/traits.rs
@@ -701,7 +701,7 @@
}
}
-/// Indicates wether a comparison was successful, an error, or
+/// Indicates whether a comparison was successful, an error, or
/// if more data was needed
#[derive(Debug, PartialEq)]
pub enum CompareResult {
diff --git a/tests/blockbuf-arithmetic.rs b/tests/blockbuf-arithmetic.rs
deleted file mode 100644
index 27a295f..0000000
--- a/tests/blockbuf-arithmetic.rs
+++ /dev/null
@@ -1,321 +0,0 @@
-/*
-#[macro_use]
-extern crate nom;
-extern crate bytes;
-
-use nom::{Compare,CompareResult,InputLength,InputIter,Slice,HexDisplay};
-
-use std::str;
-use std::str::FromStr;
-use bytes::{Buf,MutBuf};
-use bytes::buf::{BlockBuf,BlockBufCursor};
-use std::ops::{Range,RangeTo,RangeFrom,RangeFull};
-use std::iter::{Enumerate,Iterator};
-use std::fmt;
-use std::cmp::{min,PartialEq};
-
-#[derive(Clone,Copy)]
-#[repr(C)]
-pub struct BlockSlice<'a> {
- buf: &'a BlockBuf,
- start: usize,
- end: usize,
-}
-
-impl<'a> BlockSlice<'a> {
- fn cursor(&self) -> WrapCursor<'a> {
- let mut cur = self.buf.buf();
- cur.advance(self.start);
- WrapCursor {
- cursor: cur,
- length: self.end - self.start,
- }
- }
-}
-
-impl<'a> fmt::Debug for BlockSlice<'a> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "BlockSlice {{ start: {}, end: {}, data:\n{}\n}}", self.start, self.end, self.buf.bytes().unwrap_or(&b""[..]).to_hex(16))
- }
-}
-
-impl<'a> PartialEq for BlockSlice<'a> {
- fn eq(&self, other: &BlockSlice<'a>) -> bool {
- let bufs = (self.buf as *const BlockBuf) == (other.buf as *const BlockBuf);
- self.start == other.start && self.end == other.end && bufs
- }
-}
-
-impl<'a> Slice<Range<usize>> for BlockSlice<'a> {
- fn slice(&self, range:Range<usize>) -> Self {
- BlockSlice {
- buf: self.buf,
- start: self.start + range.start,
- //FIXME: check for valid end here
- end: self.start + range.end,
- }
- }
-}
-
-impl<'a> Slice<RangeTo<usize>> for BlockSlice<'a> {
- fn slice(&self, range:RangeTo<usize>) -> Self {
- self.slice(0..range.end)
- }
-}
-
-impl<'a> Slice<RangeFrom<usize>> for BlockSlice<'a> {
- fn slice(&self, range:RangeFrom<usize>) -> Self {
- self.slice(range.start..self.end - self.start)
- }
-}
-
-impl<'a> Slice<RangeFull> for BlockSlice<'a> {
- fn slice(&self, _:RangeFull) -> Self {
- BlockSlice {
- buf: self.buf,
- start: self.start,
- end: self.end,
- }
- }
-}
-
-
-impl<'a> InputIter for BlockSlice<'a> {
- type Item = u8;
- type RawItem = u8;
- type Iter = Enumerate<WrapCursor<'a>>;
- type IterElem = WrapCursor<'a>;
-
- fn iter_indices(&self) -> Self::Iter {
- self.cursor().enumerate()
- }
- fn iter_elements(&self) -> Self::IterElem {
- self.cursor()
- }
- fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::RawItem) -> bool {
- self.cursor().position(|b| predicate(b))
- }
- fn slice_index(&self, count:usize) -> Option<usize> {
- if self.end - self.start >= count {
- Some(count)
- } else {
- None
- }
- }
-}
-
-
-impl<'a> InputLength for BlockSlice<'a> {
- fn input_len(&self) -> usize {
- self.end - self.start
- }
-}
-
-impl<'a,'b> Compare<&'b[u8]> for BlockSlice<'a> {
- fn compare(&self, t: &'b[u8]) -> CompareResult {
- let len = self.end - self.start;
- let blen = t.len();
- let m = if len < blen { len } else { blen };
- let reduced = self.slice(..m);
- let b = &t[..m];
-
- for (a,b) in reduced.cursor().zip(b.iter()) {
- if a != *b {
- return CompareResult::Error;
- }
- }
- if m < blen {
- CompareResult::Incomplete
- } else {
- CompareResult::Ok
- }
- }
-
-
- #[inline(always)]
- fn compare_no_case(&self, t: &'b[u8]) -> CompareResult {
- let len = self.end - self.start;
- let blen = t.len();
- let m = if len < blen { len } else { blen };
- let reduced = self.slice(..m);
- let other = &t[..m];
-
- if !reduced.cursor().zip(other).all(|(a, b)| {
- match (a,*b) {
- (0...64, 0...64) | (91...96, 91...96) | (123...255, 123...255) => a == *b,
- (65...90, 65...90) | (97...122, 97...122) | (65...90, 97...122 ) |(97...122, 65...90) => {
- a & 0b01000000 == *b & 0b01000000
- }
- _ => false
- }
- }) {
- CompareResult::Error
- } else if m < blen {
- CompareResult::Incomplete
- } else {
- CompareResult::Ok
- }
- }
-}
-
-impl<'a,'b> Compare<&'b str> for BlockSlice<'a> {
- fn compare(&self, t: &'b str) -> CompareResult {
- self.compare(str::as_bytes(t))
- }
- fn compare_no_case(&self, t: &'b str) -> CompareResult {
- self.compare_no_case(str::as_bytes(t))
- }
-}
-
-//Wrapper to implement Iterator on BlockBufCursor
-pub struct WrapCursor<'a> {
- pub cursor: BlockBufCursor<'a>,
- pub length: usize,
-}
-
-impl<'a> Iterator for WrapCursor<'a> {
- type Item = u8;
- fn next(&mut self) -> Option<u8> {
- //println!("NEXT: length={}, remaining={}", self.length, self.cursor.remaining());
- if min(self.length, self.cursor.remaining()) > 0 {
- self.length -=1;
- Some(self.cursor.read_u8())
- } else {
- None
- }
- }
-}
-
-//Reimplement eat_separator instead of fixing iterators
-#[macro_export]
-macro_rules! block_eat_separator (
- ($i:expr, $arr:expr) => (
- {
- use nom::{InputLength,InputIter,Slice};
- if ($i).input_len() == 0 {
- Ok(($i, ($i).slice(0..0)))
- } else {
- match ($i).iter_indices().position(|(_, item)| {
- for (_,c) in ($arr).iter_indices() {
- if *c == item { return false; }
- }
- true
- }) {
- Some(index) => {
- Ok((($i).slice(index..), ($i).slice(..index)))
- },
- None => {
- Ok((($i).slice(($i).input_len()..), $i))
- }
- }
- }
- }
- )
-);
-
-#[macro_export]
-macro_rules! block_named (
- ($name:ident, $submac:ident!( $($args:tt)* )) => (
- fn $name<'a>( i: BlockSlice<'a> ) -> nom::IResult<BlockSlice<'a>, BlockSlice<'a>, u32> {
- $submac!(i, $($args)*)
- }
- );
- ($name:ident<$o:ty>, $submac:ident!( $($args:tt)* )) => (
- fn $name<'a>( i: BlockSlice<'a> ) -> nom::IResult<BlockSlice<'a>, $o, u32> {
- $submac!(i, $($args)*)
- }
- );
-);
-
-block_named!(sp, block_eat_separator!(&b" \t\r\n"[..]));
-
-macro_rules! block_ws (
- ($i:expr, $($args:tt)*) => (
- {
- sep!($i, sp, $($args)*)
- }
- )
-);
-
-block_named!(digit, is_a!("0123456789"));
-
-block_named!(parens<i64>, block_ws!(delimited!( tag!("("), expr, tag!(")") )) );
-
-
-block_named!(factor<i64>, alt!(
- map_res!(
- block_ws!(digit),
- to_i64
- )
- | parens
- )
-);
-
-block_named!(term <i64>, do_parse!(
- init: factor >>
- res: fold_many0!(
- pair!(alt!(tag!("*") | tag!("/")), factor),
- init,
- |acc, (op, val): (BlockSlice, i64)| {
- if (op.cursor().next().unwrap() as char) == '*' { acc * val } else { acc / val }
- }
- ) >>
- (res)
- )
-);
-
-block_named!(expr <i64>, do_parse!(
- init: term >>
- res: fold_many0!(
- pair!(alt!(tag!("+") | tag!("-")), term),
- init,
- |acc, (op, val): (BlockSlice, i64)| {
- if (op.cursor().next().unwrap() as char) == '+' { acc + val } else { acc - val }
- }
- ) >>
- (res)
- )
-);
-
-
-fn blockbuf_from(input: &[u8]) -> BlockBuf {
- let mut b = BlockBuf::new(2, 100);
- b.copy_from(input);
- b
-}
-
-
-fn sl<'a>(input: &'a BlockBuf) -> BlockSlice<'a> {
- BlockSlice {
- buf: input,
- start: 0,
- end: input.len(),
- }
-}
-
-fn to_i64<'a>(input: BlockSlice<'a>) -> Result<i64, ()> {
- let v: Vec<u8> = input.cursor().collect();
-
- match str::from_utf8(&v) {
- Err(_) => Err(()),
- Ok(s) => match FromStr::from_str(s) {
- Err(_) => Err(()),
- Ok(i) => Ok(i)
- }
- }
-}
-
-#[test]
-fn factor_test() {
- let a = blockbuf_from(&b"3"[..]);
- println!("calculated: {:?}", factor(sl(&a)));
-}
-
-#[test]
-fn parens_test() {
- let input1 = blockbuf_from(&b" 2* ( 3 + 4 ) "[..]);
- println!("calculated 1: {:?}", expr(sl(&input1)));
- let input2 = blockbuf_from(&b" 2*2 / ( 5 - 1) + 3"[..]);
- println!("calculated 2: {:?}", expr(sl(&input2)));
-}
-*/
diff --git a/tests/issues.rs b/tests/issues.rs
index 79c3493..6df183b 100644
--- a/tests/issues.rs
+++ b/tests/issues.rs
@@ -172,7 +172,7 @@
use nom::character::complete::char;
use nom::multi::many_m_n;
let mut parser = many_m_n::<_, _, (), _>(0, 0, char('a'));
- assert_eq!(parser("aaa"), Ok(("aaa", vec!())));
+ assert_eq!(parser("aaa"), Ok(("aaa", vec![])));
}
#[test]
