Showing preview only (3,253K chars total). Download the full file or copy to clipboard to get everything.
Repository: rust-bakery/nom
Branch: main
Commit: 51c3c4e44fa7
Files: 102
Total size: 3.1 MB
Directory structure:
gitextract_rf49ku9m/
├── .github/
│ ├── CODEOWNERS
│ ├── ISSUE_TEMPLATE.md
│ ├── PULL_REQUEST_TEMPLATE.md
│ └── workflows/
│ ├── ci.yml
│ ├── cifuzz.yml
│ └── codspeed.yml
├── .gitignore
├── CHANGELOG.md
├── CONTRIBUTING.md
├── Cargo.toml
├── LICENSE
├── README.md
├── assets/
│ ├── links.txt
│ └── testfile.txt
├── benchmarks/
│ ├── Cargo.toml
│ ├── README.md
│ ├── benches/
│ │ ├── arithmetic.rs
│ │ ├── http.rs
│ │ ├── http_streaming.rs
│ │ ├── ini.rs
│ │ ├── ini_str.rs
│ │ ├── json.rs
│ │ ├── json_streaming.rs
│ │ └── number.rs
│ ├── canada.json
│ └── src/
│ └── lib.rs
├── doc/
│ ├── archive/
│ │ ├── FAQ.md
│ │ ├── how_nom_macros_work.md
│ │ ├── upgrading_to_nom_1.md
│ │ ├── upgrading_to_nom_2.md
│ │ └── upgrading_to_nom_4.md
│ ├── choosing_a_combinator.md
│ ├── custom_input_types.md
│ ├── error_management.md
│ ├── home.md
│ ├── making_a_new_parser_from_scratch.md
│ ├── nom_recipes.md
│ └── upgrading_to_nom_5.md
├── examples/
│ ├── custom_error.rs
│ ├── iterator.rs
│ ├── json.rs
│ ├── json2.rs
│ ├── json_iterator.rs
│ ├── s_expression.rs
│ └── string.rs
├── fuzz/
│ ├── .gitignore
│ ├── Cargo.toml
│ └── fuzz_targets/
│ └── fuzz_arithmetic.rs
├── nom-language/
│ ├── Cargo.toml
│ └── src/
│ ├── error.rs
│ ├── lib.rs
│ └── precedence/
│ ├── mod.rs
│ └── tests.rs
├── proptest-regressions/
│ ├── character/
│ │ ├── complete.txt
│ │ └── streaming.txt
│ └── number/
│ ├── complete.txt
│ └── streaming.txt
├── rustfmt.toml
├── src/
│ ├── bits/
│ │ ├── complete.rs
│ │ ├── mod.rs
│ │ └── streaming.rs
│ ├── branch/
│ │ ├── mod.rs
│ │ └── tests.rs
│ ├── bytes/
│ │ ├── complete.rs
│ │ ├── mod.rs
│ │ ├── streaming.rs
│ │ └── tests.rs
│ ├── character/
│ │ ├── complete.rs
│ │ ├── mod.rs
│ │ ├── streaming.rs
│ │ └── tests.rs
│ ├── combinator/
│ │ ├── mod.rs
│ │ └── tests.rs
│ ├── error.rs
│ ├── internal.rs
│ ├── lib.rs
│ ├── macros.rs
│ ├── multi/
│ │ ├── mod.rs
│ │ └── tests.rs
│ ├── number/
│ │ ├── complete.rs
│ │ ├── mod.rs
│ │ └── streaming.rs
│ ├── sequence/
│ │ ├── mod.rs
│ │ └── tests.rs
│ ├── str.rs
│ └── traits.rs
└── tests/
├── arithmetic.rs
├── arithmetic_ast.rs
├── css.rs
├── custom_errors.rs
├── escaped.rs
├── expression_ast.rs
├── float.rs
├── fnmut.rs
├── ini.rs
├── ini_str.rs
├── issues.rs
├── json.rs
├── mp4.rs
├── multiline.rs
├── overflow.rs
└── reborrow_fold.rs
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/CODEOWNERS
================================================
* @Geal
================================================
FILE: .github/ISSUE_TEMPLATE.md
================================================
Hello, and thank you for submitting an issue to nom!
First, please note that, for family reasons, I have limited time to work on
nom, so following the advice here will make sure I will quickly understand
your problem and answer as soon as possible.
Second, if I don't get to work on your issue quickly, that does not mean I
don't consider it important or useful. Major version releases happen once
a year, and a lot of fixes are done for the occasion, once I have had time
to think of the right solution. So I will get back to you :)
## Prerequisites
Here are a few things you should provide to help me understand the issue:
- Rust version : `rustc -V`
- nom version :
- nom compilation features used:
## Test case
Please provide a short, complete (with crate import, etc) test case for
the issue, showing clearly the expected and obtained results.
Example test case:
```
#[macro_use]
extern crate nom;
named!(multi<&[u8], Vec<&[u8]> >, many1!( tag!( "abcd" ) ) );
let a = b"abcdabcd";
fn main() {
let res = vec![&b"abcd"[..], &b"abcd"[..]];
assert_eq!(multi(&a[..]),Ok((&b""[..], res))); // returns Err::Incomplete(Unknown))
}
```
================================================
FILE: .github/PULL_REQUEST_TEMPLATE.md
================================================
<!--
Hello, and thank you for submitting a pull request to nom!
First, please note that, for family reasons, I have limited time to work on
nom, so following the advice here will make sure I will quickly understand
your work and be able to merge it early.
Second, if I don't get to work on your PR quickly, that does not mean I won't
include it later. Major version releases happen once a year, and a lot of
interesting work is merged for the occasion. So I will get back to you :)
## Prerequisites
Please provide the following information with this pull request:
- related issue number (I need some context to understand a PR with a lot of
code, except for documentation typos)
- a test case reproducing the issue. You can write it in [issues.rs](https://github.com/rust-bakery/nom/blob/main/tests/issues.rs)
- if adding a new combinator, please add code documentation and some unit tests
in the same file. Also, please update the [combinator list](https://github.com/rust-bakery/nom/blob/main/doc/choosing_a_combinator.md)
## Code style
This project follows a [code style](https://github.com/rust-bakery/nom/blob/main/rustfmt.toml)
checked by [rustfmt](https://github.com/rust-lang/rustfmt).
Please avoid cosmetic fixes unrelated to the pull request. Keeping the changes
as small as possible increase your chances of getting this merged quickly.
## Rebasing
To make sure the changes will work properly once merged into the main branch
(which might have changed while you were working on your PR), please
[rebase your PR on main](https://git-scm.com/book/en/v2/Git-Branching-Rebasing).
## Squashing the commits
If the pull request include a lot of small commits used for testing, debugging,
or correcting previous work, it might be useful to
[squash the commits](https://git-scm.com/book/en/v2/Git-Tools-Rewriting-History)
to make the code easier to merge.
-->
================================================
FILE: .github/workflows/ci.yml
================================================
name: CI
on: [push, pull_request]
env:
RUST_MINVERSION: 1.65.0
CARGO_INCREMENTAL: 0
CARGO_NET_RETRY: 10
jobs:
test:
name: Test
runs-on: ubuntu-latest
strategy:
matrix:
rust:
- stable
- beta
- nightly
- 1.65.0
features:
- ''
include:
- rust: stable
features: ''
- rust: stable
features: '--features "std"'
- rust: stable
features: '--no-default-features'
- rust: stable
features: '--no-default-features --features "alloc"'
- rust: nightly
features: ''
- rust: nightly
features: '--no-default-features'
- rust: nightly
features: '--no-default-features --features "alloc"'
steps:
- name: Checkout sources
uses: actions/checkout@v2
- name: Install rust (${{ matrix.rust }})
uses: actions-rs/toolchain@v1
with:
toolchain: ${{ matrix.rust }}
profile: minimal
override: true
- name: Cache
uses: Swatinem/rust-cache@v1
- name: Build
uses: actions-rs/cargo@v1
with:
command: build
args: --verbose ${{ matrix.features }}
- name: Test
uses: actions-rs/cargo@v1
with:
command: test
args: --verbose ${{ matrix.features }}
minrust:
name: Test minimal rust version
runs-on: ubuntu-latest
steps:
- name: Checkout sources
uses: actions/checkout@v2
- name: Install rust (${{ env.RUST_MINVERSION }})
uses: actions-rs/toolchain@v1
with:
toolchain: ${{ env.RUST_MINVERSION }}
profile: minimal
override: true
- name: Cache
uses: Swatinem/rust-cache@v1
- name: Build
uses: actions-rs/cargo@v1
with:
command: build
args: --verbose --no-default-features --features "alloc,std"
bench:
name: Bench
runs-on: ubuntu-latest
steps:
- name: Checkout sources
uses: actions/checkout@v2
- name: Install rust
uses: actions-rs/toolchain@v1
with:
toolchain: nightly
profile: minimal
override: true
- name: Cache
uses: Swatinem/rust-cache@v1
- name: Compile bench
uses: actions-rs/cargo@v1
with:
command: bench
args: --verbose --no-run --features ""
- name: Run bench
uses: actions-rs/cargo@v1
with:
command: bench
args: --verbose --features ""
doc:
name: Build documentation
runs-on: ubuntu-latest
steps:
- name: Checkout sources
uses: actions/checkout@v2
- name: Install rust
uses: actions-rs/toolchain@v1
with:
toolchain: nightly
profile: minimal
override: true
- name: Build
env:
RUSTDOCFLAGS: -D warnings
run: cargo doc --no-deps --document-private-items --workspace --verbose --features "std docsrs"
fmt:
name: Check formatting
runs-on: ubuntu-latest
steps:
- name: Checkout sources
uses: actions/checkout@v2
- name: Install rust
uses: actions-rs/toolchain@v1
with:
toolchain: stable
components: rustfmt
profile: minimal
override: true
- name: cargo fmt -- --check
continue-on-error: true
uses: actions-rs/cargo@v1
with:
command: fmt
args: -- --check
coverage:
name: Coverage
runs-on: ubuntu-latest
steps:
- name: Checkout sources
uses: actions/checkout@v2
- name: Install rust
uses: actions-rs/toolchain@v1
with:
toolchain: stable
profile: minimal
override: true
- name: Cache
uses: Swatinem/rust-cache@v1
- name: Install cargo-tarpaulin
uses: actions-rs/cargo@v1
with:
command: install
args: cargo-tarpaulin
- name: Run cargo tarpaulin
uses: actions-rs/cargo@v1
with:
command: tarpaulin
args: --output-dir coverage --out xml --workspace --exclude benchmarks
- name: Upload coverage reports to Codecov
uses: codecov/codecov-action@v4.0.1
with:
token: ${{ secrets.CODECOV_TOKEN }}
slug: rust-bakery/nom
================================================
FILE: .github/workflows/cifuzz.yml
================================================
name: CIFuzz
on: [pull_request]
jobs:
Fuzzing:
runs-on: ubuntu-latest
steps:
- name: Build Fuzzers
id: build
uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
with:
oss-fuzz-project-name: 'nom'
dry-run: false
language: rust
- name: Run Fuzzers
uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
with:
oss-fuzz-project-name: 'nom'
fuzz-seconds: 300
dry-run: false
language: rust
- name: Upload Crash
uses: actions/upload-artifact@v3
if: failure() && steps.build.outcome == 'success'
with:
name: artifacts
path: ./out/artifacts
================================================
FILE: .github/workflows/codspeed.yml
================================================
name: codspeed-benchmarks
on:
push:
branches:
- "main"
pull_request:
# `workflow_dispatch` allows CodSpeed to trigger backtest
# performance analysis in order to generate initial data.
workflow_dispatch:
jobs:
benchmarks:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Setup rust toolchain, cache and cargo-codspeed binary
uses: moonrepo/setup-rust@v0
with:
channel: stable
cache-target: release
bins: cargo-codspeed
- name: Build the benchmark target(s)
run: cargo codspeed build -p benchmarks
- name: Run the benchmarks
uses: CodSpeedHQ/action@v3
with:
run: cargo codspeed run -p benchmarks
token: ${{ secrets.CODSPEED_TOKEN }}
================================================
FILE: .gitignore
================================================
target/*
Cargo.lock
FullRecognition.jpg
map.rs
oldsrc/
realworld/
src/generator.rs
.DS_Store
private-docs/
.idea/
================================================
FILE: CHANGELOG.md
================================================
# Change Log
## 8.0.0 2025-01-25
This version represents a significant refactoring of nom to reduce the amount of code generated by parsers, and reduce the API surface. As such, it comes with some breaking changes, mostly around the move from closure based combinators to trait based ones. In practice, it means that instead of writing `combinator(arg)(input)`, we now write `combinator(arg).parse(input)`.
This release also marks the introduction of the [nom-language](https://crates.io/crates/nom-language) crate, which will hold tools more focused on language parsing than the rest of nom, like the `VerboseError` type and the newly added precedence parsing combinators.
### Thanks
- @cky
- @5c077m4n
- @epage
- @Fumon
- @jtracey
- @OliveIsAWord
- @Xiretza
- @flier
- @cenodis
- @Shadow53
- @@jmmaa
- @terror
- @zanedp
- @atouchet
- @CMDJojo
- @ackxolotl
- @xmakro
- @tfpk
- @WhyNotHugo
- @brollb
- @smheidrich
- @glittershark
- @GuillaumeGomez
- @LeoDog896
- @fmiras
- @ttsugriy
- @McDostone
- @superboum
- @rruppy
- @thssuck
- @Chasing1020
- @thatmarkenglishguy
- @ambiso
- @boxdot
- @krtab
- @code10129
- @manunio
- @stuarth
- @mindeng
- @JonathanPlasse
- @nabilwadih
- @phoenixr-codes
- @gdennie
- @art049
- @kstrohbeck
### Added
- `Parser::map_res`
- `Parser::map_opt`
- `many` and `fold` combinators using ranges
- `many` can collect into other types than `Vec`
- `Error` and `VerboseError` can be converted to owned versions
### Removed
- `nom::bits::*` is no longer re-exported at the crate root. This export caused frequent confusion, since e.g. `nom::complete::tag` referred to `nom::bits::complete::tag` instead of the much more commonly used `nom::bytes::complete::tag`. To migrate, change any imports of `nom::{complete::*, streaming::*, bits, bytes}` to `nom::bits::[...]`.
- `parse` combinator
- `InputIter`, `InputTakeAtPosition`, `InputLength`, `InputTake` and `Slice` are now merged in the `Input` trait
### Changed
- `Parser::map` and `Parser::flat_map` now take a `FnMut` as argument
## 7.1.2 - 2023-01-01
### Thanks
- @joubs
- @Fyko
- @LoganDark
- @darnuria
- @jkugelman
- @barower
- @puzzlewolf
- @epage
- @cky
- @wolthom
- @w1ll-i-code
### Changed
- documentation fixes
- tests fixes
- limit the initial capacity of the result vector of `many_m_n` to 64kiB
- bits parser now accept `Parser` implementors instead of only functions
### Added
- implement `Tuple` parsing for the unit type as a special case
- implement `ErrorConvert` on the unit type to make it usable as error type for bits parsers
- bool parser for bits input
## 7.1.1 - 2022-03-14
### Thanks
- @ThomasdenH
- @@SphinxKnight
- @irevoire
- @doehyunbaek
- @pxeger
- @punkeel
- @max-sixty
- @Xiretza
- @5c077m4n
- @erihsu
- @TheNeikos
- @LoganDark
- @nickelc
- @chotchki
- @ctrlcctrlv
### Changed
- documentation fixes
- more examples
## 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.
### Thanks
- @djc
- @homersimpsons
- @lo48576
- @myrrlyn
- @RalXYZ
- @nickelc
- @cenodis
### Added
- `take_until1` combinator
- more `to_owned` implementations
- `fail`: a parser that always fail, useful as default condition in other combinators
- text to number parsers: in the `character::streaming` and `character::complete` modules, there are parsers named `i8, u16, u32, u64, u128` and `u8 ,u16, u32, u64, u128` that recognize decimal digits and directly convert to a number in the target size (checking for max int size)
### Removed
- now that function combinators are the main way to write parsers, the old macro combinators are confusing newcomers. THey have been removed
- the `BitSlice` input type from bitvec has been moved into the [nom-bitvec](https://crates.io/crates/nom-bitvec) crate. nom does not depend on bitvec now
- regex parsers have been moved into the [nom-regex](https://crates.io/crates/nom-regex) crate. nom does not depend on regex now
- `ErrorKind::PArseTo` was not needed anymore
### Changed
- relax trait bounds
- some performance fixes
- `split_at_position*` functions should now be guaranteed panic free
- the `lexical-core` crate used for float parsing has now been replaced with `minimal-lexical`: the new crate is faster to compile, faster to parse, and has no dependencies
### Fixed
- infinite loop in `escaped` combinator
- `many_m_n` now fails if min > max
## 6.2.1 - 2021-06-23
### Thanks
This release was done thanks to the hard work of (by order of appearance in the commit list):
- @homersimpsons
### Fixed
- fix documentation building
## 6.2.0 - 2021-02-15
### Thanks
This release was done thanks to the hard work of (by order of appearance in the commit list):
- @DavidKorczynski
- @homersimpsons
- @kornelski
- @lf-
- @lewisbelcher
- @ronan-d
- @weirane
- @heymind
- @marcianx
- @Nukesor
### Added
- nom is now regularly fuzzed through the OSSFuzz project
### Changed
- lots of documentation fixes
- relax trait bounds
- workarounds for dependency issues with bitvec and memchr
## 6.1.2 - 2021-02-15
### Changed
- Fix cargo feature usage in previous release
## 6.1.1 - 2021-02-15
### Thanks
This release was done thanks to the hard work of (by order of appearance in the commit list):
- @nickelc
### Changed
- Fix dependenciy incompatibilities: Restrict the bitvec->funty dependency to <=1.1
## 6.1.0 - 2021-01-23
### Thanks
This release was done thanks to the hard work of (by order of appearance in the commit list):
- @sachaarbonel
- @vallentin
- @Lucretiel
- @meiomorphism
- @jufajardini
- @neithernut
- @drwilco
### Changed
- readme and documentation fixes
- rewrite of fold_many_m_n
- relax trait bounds on some parsers
- implement `std::error::Error` on `VerboseError`
## 6.0.1 - 2020-11-24
### Thanks
This release was done thanks to the hard work of (by order of appearance in the commit list):
- @Leonqn
- @nickelc
- @toshokan
- @juchiast
- @shssoichiro
- @jlkiri
- @chifflier
- @fkloiber
- @Kaoet
- @Matthew Plant
### Added
- `ErrorConvert` implementation for `VerboseError`
### Changed
- CI fixes
- `fold_many*` now accept `FnMut` for the accumulation function
- relaxed input bounds on `length_count`
# Fixed
- documentation fixes
- the `#[deprecated]` attribute was removed from traits because it does not compile anymore on nightly
- bits and bytes combinators from the bits modules are now converted to use `FnMut`
## 6.0.0 - 2020-10-31
### Thanks
This release was done thanks to the hard work of (by order of appearance in the commit list):
- @chifflier
- @shepmaster
- @amerelo
- @razican
- @Palladinium
- @0ndorio
- Sebastian Zivota
- @keruspe
- @devonhollowood
- @parasyte
- @nnt0
- @AntoineCezar
- @GuillaumeGomez
- @eijebong
- @stadelmanma
- @sphynx
- @snawaz
- @fosskers
- @JamesHarrison
- @calebsander
- @jthornber
- @ahmedcharles
- @rljacobson
- @benkay86
- @georgeclaghorn
- @TianyiShi2001
- @shnewto
- @alfriadox
- @resistor
- @myrrlyn
- @chipsenkbeil
- @ruza-net
- @fanf2
- @jameysharp
- @FallenWarrior2k
- @jmg-duarte
- @ericseppanen
- @hbina
- Andreas Molzer
- @nickelc
- @bgourlie
## Notable changes
This release is a more polished version of nom 5, that came with a focus on
function parsers, by relaxing the requirements: combinators will return a
`impl FnMut` instead of `impl Fn`, allowing closures that change their context,
and parsers can be any type now, as long as they implement the new `Parser` trait.
That parser trait also comes with a few helper methods.
Error management was often a pain point, so a lot of work went into making it easier.
Now it integrates with `std:error::Error`, the `IResult::finish()` method allows you
to convert to a more usable type, the `into` combinator can convert the error type
if there's a `From` implementation, and there are more specific error traits like
`ContextError` for the `context` combinator, and `FromExternalError` for `map_res`.
While the `VerboseError` type and its `convert_error` function saw some changes,
not many features ill be added to it, instead you are encouraged to build the error
type that corresponds to your needs if you are building a language parser.
This version also integrates with the excellent [bitvec](https://crates.io/crates/bitvec)
crate for better bit level parsing. This part of nom was not great and a bit of a hack,
so this will give better options for those parsers.
At last, documentation! There are now more code examples, functions and macros that require
specific cargo features are now clearly indicated, and there's a new `recipes` module
containing example patterns.
### Breaking changes
- the minimal Rust version is now 1.44 (1.37 if building without the `alloc` or `std` features)
- streaming parsers return the number of additional bytes they need, not the total. This was supposed to be the case everywhere, but some parsers were forgotten
- removed the `regexp_macros` cargo feature
- the `context` combinator is not linked to `ParseError` anymore, instead it come with its own `ContextError` trait
- `Needed::Size` now contains a `NonZeroUsize`, so we can reduce the structure's size by 8 bytes. When upgrading, `Needed::Size(number)` can be replaced with `Needed::new(number)`
- there is now a more general `Parser` trait, so parsers can be something else than a function. This trait also comes with combinator methods like `map`, `flat_map`, `or`. Since it is implemented on `Fn*` traits, it should not affect existing code too much
- combinators that returned a `impl Fn` now return a `impl FnMut` to allow parser closures that capture some mutable value from the context
- `separated_list` is now `separated_list0`
- removed the deprecated `methods` module
- 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 conflicts with `std::dbg!`
- `separated_list` now allows empty elements
### Added
- function version of regex parsers
- `fill`: attempts to fill the output slice passed as argument
- `success`: returns a value without consuming the input
- `satisfy`: checks a predicate over the next character
- `eof` function combinator
- `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`
- non macro versions of `u16`, `i32`, etc, with configurable endianness
- `is_newline` function
- `std::error::Error` implementation for nom's error types
- recipes section of the documentation, outlining common patterns in nom
- custom errors example
- bitstream parsing with the `BitSlice` type from the bitvec crate
- native endianness parsers
- github actions for CI
### Changed
- allows lexical-core 0.7
- number parsers are now generic over the input type
- stabilized the `alloc` feature
- `convert_error` accepts a type that derefs to `&str`
- the JSON example now follows the spec better
### Fixed
- use `fold_many0c` in the `fold_many0` macro
## 5.1.1 - 2020-02-24
### Thanks
- @Alexhuszagh for float fixes
- @AlexanderEkdahl, @JoshOrndorff, @akitsu-sanae for docs fixes
- @ignatenkobrain: dependency update
- @derekdreery: `map` implementation for errors
- @Lucretiel for docs fixes and compilation fixes
- adytzu2007: warning fixes
- @lo48576: error management fixes
### Fixed
- C symbols compilation errors due to old lexical-core version
### Added
- `Err` now has a `map` function
### Changed
- Make `error::context()` available without `alloc` feature
## 5.1.0 - 2020-01-07
### Thanks
- @Hywan, @nickmooney, @jplatte, @ngortheone, @ejmg, @SirWindfield, @demurgos, @spazm, @nyarly, @guedou, @adamnemecek, for docs fixes
- @Alxandr for error management bugfixes
- @Lucretiel for example fixes and optimizations
- @adytzu2007 for optimizations
- @audunhalland for utf8 fixes
### Fixed
- panic in `convert_error`
- `compile_error` macro usage
### Added
- `std::error::Error`, `std::fmt::Display`, `Eq`, `ToOwned` implementations for errors
- inline attribute for `ToUsize`
### Changed
- `convert_error` optimization
- `alt` optimization
## 5.0.1 - 2019-08-22
### Thanks
- @waywardmonkeys, @phaazon, @dalance for docs fixes
- @kali for `many0_m_n` fixes
- @ia0 for macros fixes
### Fixed
- `many0_m_n` now supports the n=1 case
- relaxed trait requirements in `cut`
- `peek!` macro reimplementation
- type inference in `value!`
## 5.0.0 - 2019-06-24
This version comes with a complete rewrite of nom internals to use functions as a base
for parsers, instead of macros. Macros have been updated to use functions under
the hood, so that most existing parsers will work directly or require minimal changes.
The `CompleteByteSlice` and `CompleteStr` input types were removed. To get different
behaviour related to streaming or complete input, there are different versions of some
parsers in different submodules, like `nom::character::streaming::alpha0` and
`nom::character::complete::alpha0`.
The `verbose-errors` feature is gone, now the error type is decided through a generic
bound. To get equivalent behaviour to `verbose-errors`, check out `nom::error::VerboseError`
### Thanks
- @lowenheim helped in refactoring and error management
- @Keruspe helped in refactoring and fixing tests
- @pingiun, @Songbird0, @jeremystucki, @BeatButton, @NamsooCho, @Waelwindows, @rbtcollins, @MarkMcCaskey for a lot of help in rewriting the documentation and adding code examples
- @GuillaumeGomez for documentation rewriting and checking
- @iosmanthus for bug fixes
- @lo48576 for error management fixes
- @vaffeine for macros visibility fixes
- @webholik and @Havvy for `escaped` and `escaped_transform` fixes
- @proman21 for help on porting bits parsers
### Added
- the `VerboseError` type accumulates position info and error codes, and can generate a trace with span information
- the `lexical-core` crate is now used by default (through the `lexical` compilation feature) to parse floats from text
- documentation and code examples for all functions and macros
### Changed
- nom now uses functions instead of macros to generate parsers
- macros now use the functions under the hood
- the minimal Rust version is now 1.31
- the verify combinator's condition function now takes its argument by reference
- `cond` will now return the error of the parser instead of None
- `alpha*`, `digit*`, `hex_digit*`, `alphanumeric*` now recognize only ASCII characters
### Removed
- deprecated string parsers (with the `_s` suffix), the normal version can be used instead
- `verbose-errors` is not needed anymore, now the error type can be decided when writing the parsers, and parsers provided by nom are generic over the error type
- `AtEof`, `CompleteByteSlice` and `CompleteStr` are gone, instead some parsers are specialized to work on streaming or complete input, and provided in different modules
- character parsers that were aliases to their `*1` version: eol, alpha, digit, hex_digit, oct_digit, alphanumeric, space, multispace
- `count_fixed` macro
- `whitespace::sp` can be replaced by `character::complete::multispace0`
- method combinators are now in the nom-methods crate
- `take_until_either`, `take_until_either1`, `take_until_either_and_consume` and `take_until_either_and_consume1`: they can be replaced with `is_not` (possibly combined with something else)
- `take_until_and_consume`, `take_until_and_consume1`: they can be replaced with `take_until` combined with `take`
- `sized_buffer` and `length_bytes!`: they can be replaced with the `length_data` function
- `non_empty`, `begin` and `rest_s` function
- `cond_reduce!`, `cond_with_error!`, `closure!`, `apply`, `map_res_err!`, `expr_opt!`, `expr_res!`
- `alt_complete`, `separated_list_complete`, `separated_nonempty_list_complete`
## 4.2.3 - 2019-03-23
### Fixed
- add missing `build.rs` file to the package
- fix code comparison links in changelog
## 4.2.2 - 2019-03-04
### Fixed
- regression in do_parse macro import for edition 2018
## 4.2.1 - 2019-02-27
### Fixed
- macro expansion error in `do_parse` due to `compile_error` macro usage
## 4.2.0 - 2019-01-29
### Thanks
- @JoshMcguigan for unit test fixes
- @oza for documentation fixes
- @wackywendell for better error conversion
- @Zebradil for documentation fixes
- @tsraom for new combinators
- @hcpl for minimum Rust version tests
- @KellerFuchs for removing some unsafe uses in float parsing
### Changed
- macro import in edition 2018 code should work without importing internal macros now
- the regex parsers do not require the calling code to have imported the regex crate anymore
- error conversions are more ergonomic
- method combinators are now deprecated. They might be moved to a separate crate
- nom now specifies Rust 1.24.1 as minimum version. This was already the case before, now it is made explicit
### Added
- `many0_count` and `many1_count` to count applications of a parser instead of
accumulating its results in a `Vec`
### Fixed
- overflow in the byte wrapper for bit level parsers
- `f64` parsing does not use `transmute` anymore
## 4.1.1 - 2018-10-14
### Fixed
- compilation issue in verbose-errors mode for `add_return_error`
## 4.1.0 - 2018-10-06
### Thanks
- @xfix for fixing warnings, simplifying examples and performance fixes
- @dvberkel for documentation fixes
- @chifflier for fixing warnings
- @myrrlyn for dead code elimination
- @petrochenkov for removing redundant test macros
- @tbelaire for documentation fixes
- @khernyo for fixing warnings
- @linkmauve for documentation fixes
- @ProgVal for documentation fixes, warning fixes and error management
- @Nemo157 for compilation fixes
- @RReverser for documentation fixes
- @xpayn for fixing warnings
- Blas Rodriguez Irizar for documentation fixes
- @badboy for documentation fixes
- @kyrias for compilation fixes
- @kurnevsky for the `rest_len` parser
- @hjr3 for new documentation examples
- @fengalin for error management
- @ithinuel for the pcap example project
- @phaazon for documentation fixes
- @juchiast for documentation fixes
- @jrakow for the `u128` and `i128` parsers
- @smarnach for documentation fixes
- @derekdreery for `pub(crate)` support
- @YaLTeR for `map_res_err!`
### Added
- `rest_len` parser, returns the length of the remaining input
- `parse_to` has its own error code now
- `u128` and `i128` parsers in big and little endian modes
- support for `pub(crate)` syntax
- `map_res_err!` combinator that appends the error of its argument function in verbose errors mode
### Fixed
- lots of unused imports warnings were removed
- the `bytes` combinator was not compiling in some cases
- the big and little endian combinators now work without external imports
- CI is now faster and uses less cache
- in `add_return_error`, the provided error code is now evaluated only once
### Changed
- `fold_many1` will now transmit a `Failure` instead of transforming it to an `Error`
- `float` and `double` now work on all of nom's input types (`&[u8]`, `&str`, `CompleteByteSlice`, `CompleteStr` and any type that implements the required traits). `float_s` and `double_s` got the same modification, but are now deprecated
- `CompleteByteSlice` and `CompleteStr` get a small optimization by inlining some functions
## 4.0.0 - 2018-05-14
### Thanks
- @jsgf for the new `AtEof` trait
- @tmccombs for fixes on `escaped*` combinators
- @s3bk for fixes around non Copy input types and documentation help
- @kamarkiewicz for fixes to no_std and CI
- @bheisler for documentation and examples
- @target-san for simplifying the `InputIter` trait for `&[u8]`
- @willmurphyscode for documentation and examples
- @Chaitanya1416 for typo fixes
- @fflorent for `input_len()` usage fixes
- @dbrgn for typo fixes
- @iBelieve for no_std fixes
- @kpp for warning fixes and clippy fixes
- @keruspe for fixes on FindToken
- @dtrebbien for fixes on take_until_and_consume1
- @Henning-K for typo fixes
- @vthriller for documentation fixes
- @federicomenaquintero and @veprbl for their help fixing the float parsers
- @vmchale for new named_args versions
- @hywan for documentation fixes
- @fbenkstein for typo fixes
- @CAD97 for catching missing trait implementations
- @goldenlentils for &str optimizations
- @passy for typo fixes
- @ayrat555 for typo fixes
- @GuillaumeGomez for documentation fixes
- @jrakow for documentation fixes and fixes for `switch!`
- @phlosioneer for documentation fixes
- @creativcoder for typo fixes
- @derekdreery for typo fixes
- @lucasem for implementing `Deref` on `CompleteStr` and `CompleteByteSlice`
- @lowenheim for `parse_to!` fixes
- @myrrlyn for trait fixes around `CompleteStr` and `CompleteByteSlice`
- @NotBad4U for fixing code coverage analysis
- @murarth for code formatting
- @glandium for fixing build in no_std
- @csharad for regex compatibility with `CompleteStr`
- @FauxFaux for implementing `AsRef<str>` on `CompleteStr`
- @jaje for implementing `std::Error` on `nom:Err`
- @fengalin for warning fixes
- @@khernyo for doc formatting
Special thanks to @corkami for the logo :)
### Breaking changes
- the `IResult` type now becomes a `Result` from the standard library
- `Incomplete` now returns the additional data size needed, not the total data size needed
- verbose-errors is now a superset of basic errors
- all the errors now include the related input slice
- the arguments from `error_position` and other such macros were swapped to be more consistent with the rest of nom
- automatic error conversion: to fix error type inference issues, a custom error type must now implement `std::convert::From<u32>`
- the `not!` combinator returns unit `()`
- FindToken's calling convention was swapped
- the `take_*` combinators are now more coherent and stricter, see commit 484f6724ea3ccb for more information
- `many0` and other related parsers will now return `Incomplete` if the reach the end of input without an error of the child parser. They will also return `Incomplete` on an empty input
- the `sep!` combinator for whitespace only consumes whitespace in the prefix, while the `ws!` combinator takes care of consuming the remaining whitespace
### Added
- the `AtEof` trait for input type: indicate if we can get more input data later (related to streaming parsers and `Incomplete` handling)
- the `escaped*` parsers now support the `&str`input type
- the `Failure` error variant represents an unrecoverable error, for which `alt` and other combinators will not try other branches. This error means we got in the right part of the code (like, a prefix was checked correctly), but there was an error in the following parts
- the `CompleteByteSlice` and `CompleteStr` input types consider there will be no more refill of the input. They fixed the `Incomplete` related issues when we have all of the data
- the `exact!()` combinator will fail if we did not consume the whole input
- the `take_while_m_n!` combinator will match a specified number of characters
- `ErrorKind::TakeUntilAndConsume1`
- the `recognize_float` parser will match a float number's characters, but will not transform to a `f32` or `f64`
- `alpha` and other basic parsers are now much stricter about partial inputs. We also introduce the `*0` and `*1` versions of those parsers
- `named_args` can now specify the input type as well
- `HexDisplay` is now implemented for `&str`
- `alloc` feature
- the `InputTakeAtposition` trait allows specialized implementations of parsers like `take_while!`
### Removed
- the producers and consumers were removed
- the `error_code` and `error_node` macros are not used anymore
### Fixed
- `anychar!` now works correctly with multibyte characters
- `take_until_and_consume1!` no longer results in "no method named \`find_substring\`" and "no method named \`slice\`" compilation errors
- `take_until_and_consume1!` returns the correct Incomplete(Needed) amount
- `no_std` compiles properly, and nom can work with `alloc` too
- `parse_to!` now consumes its input
### Changed
- `alt` and other combinators will now clone the input if necessary. If the input is already `Copy` there is no performance impact
- the `rest` parser now works on various input types
- `InputIter::Item` for `&[u8]` is now a `u8` directly, not a reference
- we now use the `compile_error` macro to return a compile time error if there was a syntax issue
- the permutation combinator now supports optional child parsers
- the float numbers parsers have been refactored to use one common implementation that is nearly 2 times faster than the previous one
- the float number parsers now accept more variants
## 3.2.1 - 2017-10-27
### Thanks
- @ordian for `alt_complete` fixes
- @friedm for documentation fixes
- @kali for improving error management
### Fixed
- there were cases where `alt_complete` could return `Incomplete`
### Added
- an `into_error_kind` method can be used to transform any error to a common value. This helps when the library is included multiple times as dependency with different feature sets
## 3.2.0 - 2017-07-24
### Thanks
- @jedireza for documentation fixes
- @gmorenz for the `bytes` combinator
- @meh for character combinator fixes for UTF-8
- @jethrogb for avoiding move issues in `separated_list`
### Changed
- new layout for the main page of documentation
- `anychar` can now work on any input type
- `length_bytes` is now an alias for `length_data`
### Fixed
- `one_of`, `none_of` and `char` will now index correctly UTF-8 characters
- the `compiler_error` macro is now correctly exported
### Added
- the `bytes` combinator transforms a bit stream back to a byte slice for child parsers
## 3.1.0 - 2017-06-16
### Thanks
- @sdroege: implementing be_i24 and le_i24
- @Hywan: integrating faster substring search using memchr
- @nizox: fixing type issues in bit stream parsing
- @grissiom: documentation fixes
- @doomrobo: implementing separated_list_complete and separated_nonempty_list_complete
- @CWood1: fixing memchr integration in no_std
- @lu_zero: integrating the compiler_error crate
- @dtolnay: helping debug a type inference issue in map
### Changed
- memchr is used for substring search if possible
- if building on nightly, some common syntax errors will display a specific error message. If building no stable, display the documentation to activate those messages
- `count` no longer preallocates its vector
### Fixed
- better type inference in alt_complete
- `alt` should now work with whitespace parsing
- `map` should not make type inference errors anymore
### Added
- be_i24 and le_i24, parsing big endian and little endian signed 24 bit integers
- `separated_list_complete` and `separated_nonempty_list_complete` will treat incomplete from sub parsers as error
## 3.0.0 - 2017-05-12
### Thanks
- Chris Pick for some `Incomplete` related refactors
- @dbrgn for documentation fixes
- @valarauca for adding `be_u24`
- @ithinuel for usability fixes
- @evuez for README readability fixes and improvements to `IResult`
- @s3bk for allowing non-`Copy` types as input
- @keruspe for documentation fixes
- @0xd34d10cc for trait fixes on `InputIter`
- @sdleffler for lifetime shenanigans on `named_args`
- @chengsun for type inference fixes in `alt`
- @iBelieve for adding str to no_std
- @Hywan for simplifying code in input traits
- @azerupi for extensive documentation of `alt` and `alt_complete`
### Breaking Changes
- `escaped`, `separated_list` and `separated_nonempty_list` can now return `Incomplete` when necessary
- `InputIter` does not require `AsChar` on its `Item` type anymore
- the `core` feature that was putting nom in `no_std` mode has been removed. There is now a `std` feature, activated by default. If it is not activated, nom is in `no_std`
- in `verbose-errors` mode, the error list is now stored in a `Vec` instead of a box based linked list
- `chain!` has finally been removed
### Changed
- `Endianness` now implements `Debug`, `PartialEq`, `Eq`, `Clone` and `Copy`
- custom input types can now be cloned if they're not `Copy`
- the infamous 'Cannot infer type for E' error should happen less often now
- `str` is now available in `no_std` mode
### Fixed
- `FileProducer` will be marked as `Eof` on full buffer
- `named_args!` now has lifetimes that cannot conflict with the lifetimes from other arguments
### Added
- `be_u24`: big endian 24 bit unsigned integer parsing
- `IResult` now has a `unwrap_or` method
## 2.2.1 - 2017-04-03
### Thanks
- @Victor-Savu for formatting fixes in the README
- @chifflier for detecting and fixing integer overflows
- @utkarshkukreti for some performance improvements in benchmarks
### Changed
- when calculating how much data is needed in `IResult::Incomplete`, the addition could overflow (it is stored as a usize). This would apparently not result in any security vulnerability on release code
## 2.2.0 - 2017-03-20
### Thanks
- @seppo0010 for fixing `named_args`
- @keruspe for implementing or() on `IResult`, adding the option of default cases in `switch!`, adding support for `cargo-travis`
- @timlyo for documentation fixes
- @JayKickliter for extending `hex_u32`
- @1011X for fixing regex integration
- @Kerollmops for actually marking `chain!` as deprecated
- @joliss for documentation fixes
- @utkarshkukreti for tests refactoring and performance improvement
- @tmccombs for documentation fixes
### Added
- `IResult` gets an `or()` method
- `take_until1`, `take_until_and_consume1`, `take_till1!` and `take_till1_s!` require at least 1 character
### Changed
- `hex_u32` accepts uppercase digits as well
- the character based combinators leverage the input traits
- the whitespace parsers now work on &str and other types
- `take_while1` returns `Incomplete` on empty input
- `switch!` can now take a default case
### Fixed
- `named_args!` now imports `IResult` directly
- the upgrade to regex 0.2 broke the regex combinators, they work now
## 2.1.0 - 2017-01-27
### Thanks
- @nickbabcock for documentation fixes
- @derekdreery for documentation fixes
- @DirkyJerky for documentation fixes
- @saschagrunert for documentation fixes
- @lucab for documentation fixes
- @hyone for documentation fixes
- @tstorch for factoring `Slice`
- @shepmaster for adding crate categories
- @antoyo for adding `named_args!`
### Added
- `verify!` uses a first parser, then applies a function to check that its result satisfies some conditions
- `named_args!` creates a parser function that can accept other arguments along with the input
- `parse_to!` will use the `parse` method from `FromStr` to parse a value. It will automatically translate the input to a string if necessary
- `float`, `float_s`, `double`, `double_s` can recognize floating point numbers in text
### Changed
- `escaped!` will now return `Incomplete` if needed
- `permutation!` supports up to 20 child parsers
## 2.0.1 - 2016-12-10
Bugfix release
*Warning*: there is a small breaking change, `add_error!` is renamed to `add_return_error!`. This was planned for the 2.0 release but was forgotten. This is a small change in a feature that not many people use, for a release that is not yet widely in use, so there will be no 3.0 release for that change.
### Thanks
- @nickbabcock for catching and fixing the `add_error!` mixup
- @lucab for documentation fixes
- @jtdowney for noticing that `tag_no_case!` was not working at all for byte slices
### Fixed
- `add_error!` has been renamed to `add_return_error!`
- the `not!` combinator now accepts functions
- `tag_no_case!` is now working as accepted (before, it accepted everything)
## 2.0 - 2016-11-25
The 2.0 release is one of the biggest yet. It was a good opportunity to clean up some badly named combinators and fix invalid behaviours.
Since this version introduces a few breaking changes, an [upgrade documentation](https://github.com/rust-bakery/nom/blob/main/doc/archive/upgrading_to_nom_2.md) is available, detailing the steps to fix the most common migration issues. After testing on a set of 30 crates, most of them will build directly, a large part will just need to activate the "verbose-errors" compilation feature. The remaining fixes are documented.
This version also adds a lot of interesting features, like the permutation combinator or whitespace separated formats support.
### Thanks
- @lu-zero for license help
- @adamgreig for type inference fixes
- @keruspe for documentation and example fixes, for the `IResult => Result` conversion work, making `AsChar`'s method more consistent, and adding `many_till!`
- @jdeeny for implementing `Offset` on `&str`
- @vickenty for documentation fixes and his refactoring of `length_value!` and `length_bytes!`
- @overdrivenpotato for refactoring some combinators
- @taralx for documentation fixes
- @keeperofdakeys for fixing eol behaviour, writing documentation and adding `named_attr!`
- @jturner314 for writing documentation
- @bozaro for fixing compilation errors
- @uniphil for adding a `crates.io` badge
- @badboy for documentation fixes
- @jugglerchris for fixing `take_s!`
- @AndyShiue for implementing `Error` and `Display` on `ErrorKind` and detecting incorrect UTF-8 string indexing
### Added
- the "simple" error management system does not accumulates errors when backtracking. This is a big perf gain, and is activated by default in nom 2.0
- nom can now work on any type that implement the traits defined in `src/traits.rs`: `InputLength`, `InputIter`, `InputTake`, `Compare`, `FindToken`, `FindSubstring`, `Slice`
- the documentation from Github's wiki has been moved to the `doc/` directory. They are markdown files that you can build with [cargo-external-doc](https://crates.io/crates/cargo-external-doc)
- whitespace separated format support: with the `ws!` combinator, you can automatically introduce whitespace parsers between all parsers and combinators
- the `permutation!` combinator applies its child parsers in any order, as long as they all succeed once, and return a tuple of the results
- `do_parse!` is a simpler alternative to `chain!`, which is now deprecated
- you can now transform an `IResult` in a `std::result::Result`
- `length_data!` parses a length, and returns a subslice of that length
- `tag_no_case!` provides case independent comparison. It works nicely, without any allocation, for ASCII strings, but for UTF-8 strings, it defaults to an unsatisfying (and incorrect) comparison by lowercasing both strings
- `named_attr!` creates functions like `named!` but can add attributes like documentation
- `many_till!` applies repeatedly its first child parser until the second succeeds
### Changed
- the "verbose" error management that was available in previous versions is now activated by the "verbose-errors" compilation feature
- code reorganization: most of the parsers were moved in separate files to make the source easier to navigate
- most of the combinators are now independent from the input type
- the `eof` function was replaced with the `eof!` macro
- `error!` and `add_error!` were replaced with `return_error!` and `add_return_error!` to fix the name conflict with the log crate
- the `offset()` method is now in the `Offset` trait
- `length_value!` has been renamed to `length_count!`. The new `length_value!` selects a slice and applies the second parser once on that slice
- `AsChar::is_0_to_9` is now `AsChar::is_dec_digit`
- the combinators with configurable endianness now take an enum instead of a boolean as parameter
### Fixed
- the `count!`, `count_fixed!` and `length_*!` combinator calculate incomplete data needs correctly
- `eol`, `line_ending` and `not_line_ending` now have a consistent behaviour that works correctly with incomplete data
- `take_s!` didn't correctly handle the case when the slice is exactly the right length
## 1.2.4 - 2016-07-20
### Thanks
- @Phlosioneer for documentation fixes
- @sourrust for fixing offsets in `take_bits!`
- @ChrisMacNaughton for the XFS crate
- @pwoolcoc for `rest_s`
- @fitzgen for more `IResult` methods
- @gtors for the negative lookahead feature
- @frk1 and @jeandudey for little endian float parsing
- @jethrogb for fixing input usage in `many1`
- @acatton for beating me at nom golf :D
### Added
- the `rest_s` method on `IResult` returns the remaining `&str` input
- `unwrap_err` and `unwrap_inc` methods on `IResult`
- `not!` will peek at the input and return `Done` if the underlying parser returned `Error` or `Incomplete`, without consuming the input
- `le_f32` and `le_f64` parse little endian floating point numbers (IEEE 754)
-
### Fixed
- documentation fixes
- `take_bits!` is now more precise
- `many1` inccorectly used the `len` function instead of `input_len`
- the INI parser is simpler
- `recognize!` had an early `return` that is removed now
## 1.2.3 - 2016-05-10
### Thanks
- @lu-zero for the contribution guidelines
- @GuillaumeGomez for fixes on `length_bytes` and some documentation
- @Hywan for documentation and test fixes
- @Xirdus for correct trait import issues
- @mspiegel for the new AST example
- @cholcombe973 for adding the `cond_with_error!` combinator
- @tstorch for refactoring `many0!`
- @panicbit for the folding combinators
- @evestera for `separated_list!` fixes
- @DanielKeep for correcting some enum imports
### Added
- Regular expression combinators starting with `re_bytes_` work on byte slices
- example parsing arithmetic expressions to an AST
- `cond_with_error!` works like `cond!` but will return `None` if the condition is false, and `Some(value)` if the underlying parser succeeded
- `fold_many0!`, `fold_many1!` and `fold_many_m_n!` will take a parser, an initial value and a combining function, and fold over the successful applications of the parser
### Fixed
- `length_bytes!` converts the result of its child parser to usize
- `take_till!` now imports `InputLength` instead of assuming it's in scope
- `separated_list!` and `separated_nonempty_list!` will not consume the separator if there's no following successfully parsed value
- no more warnings on build
### Changed
- simpler implementation of `many0!`
## 1.2.2 - 2016-03-09
### Thanks
- @conradev for fixing `take_until_s!`
- @GuillaumeGomez for some documentation fixes
- @frewsxcv for some documentation fixes
- @tstorch for some test refactorings
### Added
- `nom::Err` now implements `std::error::Error`
### Fixed
- `hex_u32` does not parses more than 8 chars now
- `take_while!` and `take_while1!` will not perturb the behaviour of `recognize!` anymore
## 1.2.1 - 2016-02-23
### Thanks
- @sourrust for adding methods to `IResult`
- @tstorch for the test refactoring, and for adding methods to `IResult` and `Needed`
- @joelself for fixing the method system
### Added
- mapping methods over `IResult` and `Needed`
### Changed
- `apply_rf` is renamed to `apply_m`. This will not warrant a major version, since it is part missing from the methods feture added in the 1.2.0 release
- the `regexp_macros` feature that used `regex!` to precompile regular expressions has been replaced by the normal regex engine combined with `lazy_static`
### Fixed
- when a parser or combinator was returning an empty buffer as remaining part, it was generating one from a static empty string. This was messing with buffer offset calculation. Now, that empty slice is taken like this: `&input[input.len()..]`.
- The `regexp_macros` and `no_std` feature build again and are now tested with Travis CI
## 1.2.0 - 2016-02-08
### Thanks
- @zentner-kyle for type inference fixes
- @joelself for his work on `&str` parsing and method parsers
- @GuillaumeGomez for implementing methods on `IResult`
- @dirk for the `alt_complete!` combinator
- @tstorch for a lot of refactoring work and unit tests additions
- @jansegre for the hex digit parsers
- @belgum for some documentation fixes
- @lwandrebeck for some documentation fixes and code fixes in `hex_digit`
### Added
- `take_until_and_consume_s!` for consumption of string data until a tag
- more function patterns in `named!`. The error type can now be specified
- `alt_complete!` works like the `alt!` combinator, but tries the next branch if the current one returned `Incomplete`, instead of returning directly
- more unit tests for a lot of combinators
- hexadecimal digit parsers
- the `tuple!` combinator takes a list of parsers as argument, and applies them serially on the input. If all of them are successful, it willr eturn a tuple accumulating all the values. This combinator will (hopefully) replace most uses of `chain!`
- parsers can now be implemented as a method for a struct thanks to the `method!`, `call_m!` and `apply_rf!` combinators
### Fixed
- there were type inference issues in a few combinators. They will now be easier to compile
- `peek!` compilation with bare functions
- `&str` parsers were splitting data at the byte level, not at the char level, which can result in inconsistencies in parsing UTF-8 characters. They now use character indexes
- some method implementations were missing on `IResult<I,O,E>` (with specified error type instead of implicit)
## 1.1.0 - 2016-01-01
This release adds a lot of features related to `&str` parsing. The previous versions
were focused on `&[u8]` and bit streams parsing, but there's a need for more text
parsing with nom. The parsing functions like `alpha`, `digit` and others will now
accept either a `&[u8]` or a `&str`, so there is no breaking change on that part.
There are also a few performance improvements and documentation fixes.
### Thanks
- @Binero for pushing the work on `&str` parsing
- @meh for fixing `Option` and `Vec` imports
- @hoodie for a documentation fix
- @joelself for some documentation fixes
- @vberger for his traits magic making nom functions more generic
### Added
- string related parsers: `tag_s!`, `take_s!`, `is_a_s!`, `is_not_s!`, `take_while_s!`, `take_while1_s!`, `take_till_s!`
- `value!` is a combinator that always returns the same value. If a child parser is passed as second argument, that value is returned when the child parser succeeds
### Changed
- `tag!` will now compare even on partial input. If it expects "abcd" but receives "ef", it will now return an `Error` instead of `Incomplete`
- `many0!` and others will preallocate a larger vector to avoid some copies and reallocations
- `alpha`, `digit`, `alphanumeric`, `space` and `multispace` now accept as input a `&[u8]` or a `&str`. Additionally, they return an error if they receive an empty input
- `take_while!`, `take_while1!`, `take_while_s!`, `take_while1_s!` wilreturn an error on empty input
### Fixed
- if the child parser of `many0!` or `many1!` returns `Incomplete`, it will return `Incomplete` too, possibly updating the needed size
- `Option,` `Some`, `None` and `Vec` are now used with full path imports
## 1.0.1 - 2015-11-22
This releases makes the 1.0 version compatible with Rust 1.2 and 1.3
### Thanks
- @steveklabnik for fixing lifetime issues in Producers and Consumers
## 1.0.0 - 2015-11-16
Stable release for nom. A lot of new features, a few breaking changes
### Thanks
- @ahenry for macro fixes
- @bluss for fixing documentation
- @sourrust for cleaning code and debugging the new streaming utilities
- @meh for inline optimizations
- @ccmtaylor for fixing function imports
- @soro for improvements to the streaming utilities
- @breard-r for catching my typos
- @nelsonjchen for catching my typos too
- @divarvel for hex string parsers
- @mrordinaire for the `length_bytes!` combinator
### Breaking changes
- `IResult::Error` can now use custom error types, and is generic over the input type
- Producers and consumers have been replaced. The new implementation uses less memory and integrates more with parsers
- `nom::ErrorCode` is now `nom::ErrorKind`
- `filter!` has been renamed to `take_while!`
- `chain!` will count how much data is consumed and use that number to calculate how much data is needed if a parser returned `Incomplete`
- `alt!` returns `Incomplete` if a child parser returned `Incomplete`, instead of skipping to the next parser
- `IResult` does not require a lifetime tag anymore, yay!
### Added
- `complete!` will return an error if the child parser returned `Incomplete`
- `add_error!` will wrap an error, but allow backtracking
- `hex_u32` parser
### Fixed
- the behaviour around `Incomplete` is better for most parsers now
## 0.5.0 - 2015-10-16
This release fixes a few issues and stabilizes the code.
### Thanks
- @nox for documentation fixes
- @daboross for linting fixes
- @ahenry for fixing `tap!` and extending `dbg!` and `dbg_dmp!`
- @bluss for tracking down and fixing issues with unsafe code
- @meh for inlining parser functions
- @ccmtaylor for fixing import of `str::from_utf8`
### Fixed
- `tap!`, `dbg!` and `dbg_dmp!` now accept function parameters
### Changed
- the type used in `count_fixed!` must be `Copy`
- `chain!` calculates how much data is needed if one of the parsers returns `Incomplete
- optional parsers in `chain!` can return `Incomplete`
## 0.4.0 - 2015-09-08
Considering the number of changes since the last release, this version can contain breaking changes, so the version number becomes 0.4.0. A lot of new features and performance improvements!
### Thanks
- @frewsxcv for documentation fixes
- @ngrewe for his work on producers and consumers
- @meh for fixes on `chain!` and for the `rest` parser
- @daboross for refactoring `many0!` and `many1!`
- @aleksander for the `switch!` combinator idea
- @TechnoMancer for his help with bit level parsing
- @sxeraverx for pointing out a bug in `is_a!`
### Fixed
- `count_fixed!` must take an explicit type as argument to generate the fixed-size array
- optional parsing behaviour in `chain!`
- `count!` can take 0 elements
- `is_a!` and `is_not!` can now consume the whole input
### Added
- it is now possible to seek to the end of a `MemProducer`
- `opt!` returns `Done(input, None)` if `the child parser returned `Incomplete`
- `rest` will return the remaining input
- consumers can now seek to and from the end of input
- `switch!` applies a first parser then matches on its result to choose the next parser
- bit-level parsers
- character-level parsers
- regular expression parsers
- implementation of `take_till!`, `take_while!` and `take_while1!`
### Changed
- `alt!` can return `Incomplete`
- the error analysis functions will now take references to functions instead of moving them
- performance improvements on producers
- performance improvement for `filter!`
- performance improvement for `count!`: a `Vec` of the right size is directly allocated
## 0.3.11 - 2015-08-04
### Thanks
- @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
## 0.3.10 - 2015-08-03
### Added
- `bits!` for bit level parsing. It indicates that all child parsers will take a `(&[u8], usize)`as input, with the second parameter indicating the bit offset in the first byte. This allows viewing a byte slice as a bit stream. Most combinators can be used directly under `bits!`
- `take_bits!` takes an integer type and a number of bits, consumes that number of bits and updates the offset, possibly by crossing byte boundaries
- bit level parsers are all written in `src/bits.rs`
### Changed
- Parsers that specifically handle bytes have been moved to src/bytes.rs`. This applies to `tag!`, `is_not!`, `is_a!`, `filter!`, `take!`, `take_str!`, `take_until_and_consume!`, `take_until!`, `take_until_either_and_consume!`, `take_until_either!`
## 0.3.9 - 2015-07-20
### Thanks
- @badboy for fixing `filter!`
- @idmit for some documentation fixes
### Added
- `opt_res!` applies a parser and transform its result in a Result. This parser never fails
- `cond_reduce!` takes an expression as parameter, applies the parser if the expression is true, and returns an error if the expression is false
- `tap!` pass the result of a parser to a block to manipulate it, but do not affect the parser's result
- `AccReader` is a Read+BufRead that supports data accumulation and partial consumption. The `consume` method must be called afterwardsto indicate how much was consumed
- Arithmetic expression evaluation and parsing example
- `u16!`, `u32!`, `u64!`, `i16!`, `i32!`, `i64!` take an expression as parameter, if the expression is true, apply the big endian integer parser, if false, the little endian version
- type information for combinators. This will make the documentation a bit easier to navigate
### Fixed
- `map_opt!` and `map_res!` had issues with argument order due to bad macros
- `delimited!` did not compile for certain combinations of arguments
- `filter!` did not return a byte slice but a fixed array
## 0.3.8 - 2015-07-03
### Added
- code coverage is now calculated automatically on Travis CI
- `Stepper`: wrap a `Producer`, and call the method `step` with a parser. This method will buffer data if there is not enough, apply the parser if there is, and keep the rest of the input in memory for the next call
- `ReadProducer`: takes something implementing `Read`, and makes a `Producer` out of it
### Fixed
- the combinators `separated_pair!` and `delimited!` did not work because an implementation macro was not exported
- if a `MemProducer` reached its end, it should always return `Eof`
- `map!` had issues with argument matching
## 0.3.7 - 2015-06-24
### Added
- `expr_res!` and `expr_opt!` evaluate an expression returning a Result or Opt and convert it to IResult
- `AsBytes` is implemented for fixed size arrays. This allows `tag!([41u8, 42u8])`
### Fixed
- `count_fixed!` argument parsing works again
## 0.3.6 - 2015-06-15
### 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 the alternative `named!(pub fun_name<OutputType>, ...)`
### Fixed
- `filter!` now returns the whole input if the filter function never returned false
- `take!` casts its argument as usize, so it can accepts any integer type now
## 0.3.5 - 2015-06-10
### Thanks
- @cmr for some documentation fixes
### Added
- `count_fixed!` returns a fixed array
### Fixed
- `count!` is back to the previous behaviour, returning a `Vec` for sizes known at runtime
### Changed
- functions and traits exported from `nom::util` are now directly in `nom::`
## 0.3.4 - 2015-06-09
### Thanks
- @andrew-d for fixes on `cond!`
- @keruspe for features in `chain!`
### Added
- `chain!` can now have mutable fields
### Fixed
- `cond!` had an infinite macro recursion
### Changed
- `chain!` generates less code now. No apprent compilation time improvement
## 0.3.3 - 2015-06-09
### Thanks
- @andrew-d for the little endian signed integer parsers
- @keruspe for fixes on `count!`
### Added
- `le_i8`, `le_i16`, `le_i32`, `le_i64`: little endian signed integer parsers
### Changed
- the `alt!` parser compiles much faster, even with more than 8 branches
- `count!` can now return a fixed size array instead of a growable vector
## 0.3.2 - 2015-05-31
### Thanks
- @keruspe for the `take_str` parser and the function application combinator
### Added
- `take_str!`: takes the specified number of bytes and return a UTF-8 string
- `apply!`: do partial application on the parameters of a function
### Changed
- `Needed::Size` now contains a `usize` instead of a `u32`
## 0.3.1 - 2015-05-21
### Thanks
- @divarvel for the big endian signed integer parsers
### Added
- `be_i8`, `be_i16`, `be_i32`, `be_i64`: big endian signed integer parsers
- the `core` feature can be passed to cargo to build with `no_std`
- colored hexdump can be generated from error chains
## 0.3.0 - 2015-05-07
### Thanks
- @filipegoncalves for some documentation and the new eof parser
- @CrimsonVoid for putting fully qualified types in the macros
- @lu_zero for some documentation fixes
### Added
- new error types that can contain an error code, an input slice, and a list of following errors
- `error!` will cut backtracking and return directly from the parser, with a specified error code
- `eof` parser, successful if there is no more input
- specific error codes for the parsers provided by nom
### Changed
- fully qualified types in macros. A lot of imports are not needed anymore
### Removed
- `FlatMap`, `FlatpMapOpt` and `Functor` traits (replaced by `map!`, `map_opt!` and `map_res!`)
## 0.2.2 - 2015-04-12
### Thanks
- @filipegoncalves and @thehydroimpulse for debugging an infinite loop in many0 and many1
- @thehydroimpulse for suggesting public named parsers
- @skade for removing the dependency on the collections gate
### Added
- `named!` can now declare public functions like this: `named!(pub tst, tag!("abcd"));`
- `pair!(X,Y)` returns a tuple `(x, y)`
- `separated_pair!(X, sep, Y)` returns a tuple `(x, y)`
- `preceded!(opening, X)` returns `x`
- `terminated!(X, closing)` returns `x`
- `delimited(opening, X, closing)` returns `x`
- `separated_list(sep, X)` returns a `Vec<X>`
- `separated_nonempty_list(sep, X)` returns a `Vec<X>` of at list one element
### Changed
- `many0!` and `many1!` forbid parsers that do not consume input
- `is_a!`, `is_not!`, `alpha`, `digit`, `space`, `multispace` will now return an error if they do not consume at least one byte
## 0.2.1 - 2015-04-04
### Thanks
- @mtsr for catching the remaining debug println!
- @jag426 who killed a lot of warnings
- @skade for removing the dependency on the core feature gate
### Added
- little endian unsigned int parsers le_u8, le_u16, le_u32, le_u64
- `count!` to apply a parser a specified number of times
- `cond!` applies a parser if the condition is met
- more parser development tools in `util::*`
### Fixed
- in one case, `opt!` would not compile
### Removed
- most of the feature gates are now removed. The only one still needed is `collections`
## 0.2.0 - 2015-03-24
*works with `rustc 1.0.0-dev (81e2396c7 2015-03-19) (built 2015-03-19)`*
### Thanks
- Ryman for the AsBytes implementation
- jag426 and jaredly for documentation fixes
- eternaleye on #rust IRC for his help on the new macro syntax
### Changed
- the AsBytes trait improves readability, no more b"...", but "..." instead
- Incomplete will now hold either Needed;;Unknown, or Needed::Size(u32). Matching on Incomplete without caring for the value is done with `Incomplete(_)`, but if more granularity is mandatory, `Needed` can be matched too
- `alt!` can pass the result of the parser to a closure
- the `take_*` macros changed behaviour, the default case is now not to consume the separator. The macros have been renamed as follows: `take_until!` -> `take_until_and_consume!`, `take_until_and_leave!` -> `take_until!`, `take_until_either_and_leave!` -> `take_until_either!`, `take_until_either!` -> `take_until_either_and_consume!`
### Added
- `peek!` macro: matches the future input but does not consume it
- `length_value!` macro: the first argument is a parser returning a `n` that can cast to usize, then applies the second parser `n` times. The macro has a variant with a third argument indicating the expected input size for the second parser
- benchmarks are available at https://github.com/rust-bakery/parser_benchmarks
- more documentation
- **Unnamed parser syntax**: warning, this is a breaking change. With this new syntax, the macro combinators do not generate functions anymore, they create blocks. That way, they can be nested, for better readability. The `named!` macro is provided to create functions from parsers. Please be aware that nesting parsers comes with a small cost of compilation time, negligible in most cases, but can quickly get to the minutes scale if not careful. If this happens, separate your parsers in multiple subfunctions.
- `named!`, `closure!` and `call!` macros used to support the unnamed syntax
- `map!`, `map_opt!` and `map_res!` to combine a parser with a normal function, transforming the input directly, or returning an `Option` or `Result`
### Fixed
- `is_a!` is now working properly
### Removed
- the `o!` macro does less than `chain!`, so it has been removed
- the `fold0!` and `fold1!` macros were too complex and awkward to use, the `many*` combinators will be useful for most uses for now
## 0.1.6 - 2015-02-24
### Changed
- consumers must have an end method that will be called after parsing
### Added
- big endian unsigned int and float parsers: be_u8, be_u16, be_u32, be_u64, be_f32, be_f64
- producers can seek
- function and macros documentation
- README documentation
### Fixed
- lifetime declarations
- tag! can return Incomplete
## 0.1.5 - 2015-02-17
### Changed
- traits were renamed: FlatMapper -> FlatMap, Mapper -> FlatMapOpt, Mapper2 -> Functor
### Fixed
- woeks with rustc f1bb6c2f4
## 0.1.4 - 2015-02-17
### Changed
- the chaining macro can take optional arguments with '?'
## 0.1.3 - 2015-02-16
### Changed
- the chaining macro now takes the closure at the end of the argument list
## 0.1.2 - 2015-02-16
### Added
- flat_map implementation for <&[u8], &[u8]>
- chaining macro
- partial MP4 parser example
## 0.1.1 - 2015-02-06
### Fixed
- closure syntax change
## Compare code
* [unreleased](https://github.com/rust-bakery/nom/compare/8.0.0...HEAD)
* [8.0.0](https://github.com/rust-bakery/nom/compare/7.1.3...8.0.0)
* [7.1.3](https://github.com/rust-bakery/nom/compare/7.1.2...7.1.3)
* [7.1.2](https://github.com/rust-bakery/nom/compare/7.1.1...7.1.2)
* [7.1.1](https://github.com/rust-bakery/nom/compare/7.1.0...7.1.1)
* [7.1.0](https://github.com/rust-bakery/nom/compare/7.0.0...7.1.0)
* [7.0.0](https://github.com/rust-bakery/nom/compare/6.2.1...7.0.0)
* [6.2.1](https://github.com/rust-bakery/nom/compare/6.2.0...6.2.1)
* [6.2.0](https://github.com/rust-bakery/nom/compare/6.1.2...6.2.0)
* [6.1.2](https://github.com/rust-bakery/nom/compare/6.1.1...6.1.2)
* [6.1.1](https://github.com/rust-bakery/nom/compare/6.1.0...6.1.1)
* [6.1.0](https://github.com/rust-bakery/nom/compare/6.0.1...6.1.0)
* [6.0.1](https://github.com/rust-bakery/nom/compare/6.0.0...6.0.1)
* [6.0.0](https://github.com/rust-bakery/nom/compare/5.1.1...6.0.0)
* [5.1.1](https://github.com/rust-bakery/nom/compare/5.1.0...5.1.1)
* [5.1.0](https://github.com/rust-bakery/nom/compare/5.0.1...5.1.0)
* [5.0.1](https://github.com/rust-bakery/nom/compare/5.0.0...5.0.1)
* [5.0.0](https://github.com/rust-bakery/nom/compare/4.2.3...5.0.0)
* [4.2.3](https://github.com/rust-bakery/nom/compare/4.2.2...4.2.3)
* [4.2.2](https://github.com/rust-bakery/nom/compare/4.2.1...4.2.2)
* [4.2.1](https://github.com/rust-bakery/nom/compare/4.2.0...4.2.1)
* [4.2.0](https://github.com/rust-bakery/nom/compare/4.1.1...4.2.0)
* [4.1.1](https://github.com/rust-bakery/nom/compare/4.1.0...4.1.1)
* [4.1.0](https://github.com/rust-bakery/nom/compare/4.0.0...4.1.0)
* [4.0.0](https://github.com/rust-bakery/nom/compare/3.2.1...4.0.0)
* [3.2.1](https://github.com/rust-bakery/nom/compare/3.2.0...3.2.1)
* [3.2.0](https://github.com/rust-bakery/nom/compare/3.1.0...3.2.0)
* [3.1.0](https://github.com/rust-bakery/nom/compare/3.0.0...3.1.0)
* [3.0.0](https://github.com/rust-bakery/nom/compare/2.2.1...3.0.0)
* [2.2.1](https://github.com/rust-bakery/nom/compare/2.2.0...2.2.1)
* [2.2.0](https://github.com/rust-bakery/nom/compare/2.1.0...2.2.0)
* [2.1.0](https://github.com/rust-bakery/nom/compare/2.0.1...2.1.0)
* [2.0.1](https://github.com/rust-bakery/nom/compare/2.0.0...2.0.1)
* [2.0.0](https://github.com/rust-bakery/nom/compare/1.2.4...2.0.0)
* [1.2.4](https://github.com/rust-bakery/nom/compare/1.2.3...1.2.4)
* [1.2.3](https://github.com/rust-bakery/nom/compare/1.2.2...1.2.3)
* [1.2.2](https://github.com/rust-bakery/nom/compare/1.2.1...1.2.2)
* [1.2.1](https://github.com/rust-bakery/nom/compare/1.2.0...1.2.1)
* [1.2.0](https://github.com/rust-bakery/nom/compare/1.1.0...1.2.0)
* [1.1.0](https://github.com/rust-bakery/nom/compare/1.0.1...1.1.0)
* [1.0.1](https://github.com/rust-bakery/nom/compare/1.0.0...1.0.1)
* [1.0.0](https://github.com/rust-bakery/nom/compare/0.5.0...1.0.0)
* [0.5.0](https://github.com/rust-bakery/nom/compare/0.4.0...0.5.0)
* [0.4.0](https://github.com/rust-bakery/nom/compare/0.3.11...0.4.0)
* [0.3.11](https://github.com/rust-bakery/nom/compare/0.3.10...0.3.11)
* [0.3.10](https://github.com/rust-bakery/nom/compare/0.3.9...0.3.10)
* [0.3.9](https://github.com/rust-bakery/nom/compare/0.3.8...0.3.9)
* [0.3.8](https://github.com/rust-bakery/nom/compare/0.3.7...0.3.8)
* [0.3.7](https://github.com/rust-bakery/nom/compare/0.3.6...0.3.7)
* [0.3.6](https://github.com/rust-bakery/nom/compare/0.3.5...0.3.6)
* [0.3.5](https://github.com/rust-bakery/nom/compare/0.3.4...0.3.5)
* [0.3.4](https://github.com/rust-bakery/nom/compare/0.3.3...0.3.4)
* [0.3.3](https://github.com/rust-bakery/nom/compare/0.3.2...0.3.3)
* [0.3.2](https://github.com/rust-bakery/nom/compare/0.3.1...0.3.2)
* [0.3.1](https://github.com/rust-bakery/nom/compare/0.3.0...0.3.1)
* [0.3.0](https://github.com/rust-bakery/nom/compare/0.2.2...0.3.0)
* [0.2.2](https://github.com/rust-bakery/nom/compare/0.2.1...0.2.2)
* [0.2.1](https://github.com/rust-bakery/nom/compare/0.2.0...0.2.1)
* [0.2.0](https://github.com/rust-bakery/nom/compare/0.1.6...0.2.0)
* [0.1.6](https://github.com/rust-bakery/nom/compare/0.1.5...0.1.6)
* [0.1.5](https://github.com/rust-bakery/nom/compare/0.1.4...0.1.5)
* [0.1.4](https://github.com/rust-bakery/nom/compare/0.1.3...0.1.4)
* [0.1.3](https://github.com/rust-bakery/nom/compare/0.1.2...0.1.3)
* [0.1.2](https://github.com/rust-bakery/nom/compare/0.1.1...0.1.2)
* [0.1.1](https://github.com/rust-bakery/nom/compare/0.1.0...0.1.1)
================================================
FILE: CONTRIBUTING.md
================================================
# Contributing to nom
Thanks a lot for contributing to this project!
The following is a set of guidelines for contributing to [nom][1].
**Since the project is young**: consider those best practices prone to change. Please suggest improvements!
[1]: https://github.com/rust-bakery/nom
## Basics
### License
The project uses the [MIT][l1] license. By contributing to this project you agree to license
your changes under this license.
[l1]: https://opensource.org/license/mit/
## What to do
### Issues
There is plenty of [features missing][i1] and possibly bugs might be already there. Feel free to add new [issues][i2]
and to wrangle over those already [open][i3] and help fixing them.
[i1]: https://github.com/rust-bakery/nom/issues?q=is%3Aopen+is%3Aissue+label%3Aenhancement
[i2]: https://github.com/rust-bakery/nom/issues
[i3]: https://github.com/rust-bakery/nom/issues?q=is%3Aopen+is%3Aissue
### Code
Implementing new codecs, container formats or protocols is always welcome!
### Tests
It is strongly suggested to provide test along changes so the coverage stays around the **85%**, helping to
get to full coverage is pretty welcome.
### Benchmark
Help in making sure the code does not have performance regression, by improving the benchmark suite or just by
running it weekly, is welcome as well.
### Documentation
To preview changes to the documentation: use `cargo doc` with [`cargo
external-doc`](https://github.com/Geal/cargo-external-doc)
## Style
### Issue style
Try to write at least 3 short paragraphs describing what were you trying to achieve, what is not working and
the step by step actions that lead to the unwanted outcome.
If possible provide:
- a code snippet or a link to a [gist][is1] showcasing the problem, if is a library usage issue.
- a backtrace, if it is a crash.
- a sample file, if it is a decoding or encoding issue.
[is1]: https://gist.github.com/
### Coding style
The normal rust coding style is checked by [rustfmt][cs1].
Readable code is the first step on having good and safe libraries.
To avoid slight differences appearing in nightly versions, please
use the following command to run rustfmt: `cargo +stable fmt`
[cs1]: https://github.com/rust-lang/rustfmt
================================================
FILE: Cargo.toml
================================================
[package]
name = "nom"
version = "8.0.0"
authors = ["contact@geoffroycouprie.com"]
description = "A byte-oriented, zero-copy, parser combinators library"
license = "MIT"
repository = "https://github.com/rust-bakery/nom"
readme = "README.md"
documentation = "https://docs.rs/nom"
keywords = ["parser", "parser-combinators", "parsing", "streaming", "bit"]
categories = ["parsing"]
edition = "2021"
autoexamples = false
# also update in README.md (badge and "Rust version requirements" section)
rust-version = "1.65.0"
include = [
"CHANGELOG.md",
"LICENSE",
"README.md",
".gitignore",
"Cargo.toml",
"src/*.rs",
"src/*/*.rs",
"tests/*.rs",
"doc/nom_recipes.md",
]
[features]
alloc = []
std = ["alloc", "memchr/std"]
default = ["std"]
docsrs = []
[dependencies.memchr]
version = "2.3"
default-features = false
[dev-dependencies]
doc-comment = "0.3"
proptest = "=1.0.0"
nom-language = { path = "./nom-language" }
[package.metadata.docs.rs]
features = ["alloc", "std", "docsrs"]
all-features = true
rustdoc-args = ["--generate-link-to-definition"]
[profile.bench]
debug = true
lto = true
codegen-units = 1
[[test]]
name = "arithmetic"
[[test]]
name = "arithmetic_ast"
required-features = ["alloc"]
[[test]]
name = "css"
[[test]]
name = "custom_errors"
[[test]]
name = "expression_ast"
required-features = ["alloc"]
[[test]]
name = "float"
[[test]]
name = "ini"
required-features = ["alloc"]
[[test]]
name = "ini_str"
required-features = ["alloc"]
[[test]]
name = "issues"
required-features = ["alloc"]
[[test]]
name = "json"
[[test]]
name = "mp4"
required-features = ["alloc"]
[[test]]
name = "multiline"
required-features = ["alloc"]
[[test]]
name = "overflow"
[[test]]
name = "reborrow_fold"
[[test]]
name = "fnmut"
required-features = ["alloc"]
[[example]]
name = "custom_error"
required-features = ["alloc"]
path = "examples/custom_error.rs"
[[example]]
name = "json"
required-features = ["alloc"]
path = "examples/json.rs"
[[example]]
name = "json2"
required-features = ["alloc"]
path = "examples/json2.rs"
[[example]]
name = "json_iterator"
required-features = ["alloc"]
path = "examples/json_iterator.rs"
[[example]]
name = "iterator"
path = "examples/iterator.rs"
[[example]]
name = "s_expression"
path = "examples/s_expression.rs"
required-features = ["alloc"]
[[example]]
name = "string"
required-features = ["alloc"]
path = "examples/string.rs"
[badges]
travis-ci = { repository = "Geal/nom" }
coveralls = { repository = "Geal/nom", branch = "main", service = "github" }
maintenance = { status = "actively-developed" }
[workspace]
members = [".", "benchmarks/", "nom-language"]
================================================
FILE: LICENSE
================================================
Copyright (c) 2014-2019 Geoffroy Couprie
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
================================================
FILE: README.md
================================================
# nom, eating data byte by byte
[](LICENSE)
[](https://gitter.im/Geal/nom?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[](https://github.com/rust-bakery/nom/actions/workflows/ci.yml)
[](https://coveralls.io/github/rust-bakery/nom?branch=main)
[](https://crates.io/crates/nom)
[](#rust-version-requirements-msrv)
nom is a parser combinators library written in Rust. Its goal is to provide tools
to build safe parsers without compromising the speed or memory consumption. To
that end, it uses extensively Rust's *strong typing* and *memory safety* to produce
fast and correct parsers, and provides functions, macros and traits to abstract most of the
error prone plumbing.
*nom will happily take a byte out of your files :)*
<!-- toc -->
- [Example](#example)
- [Documentation](#documentation)
- [Why use nom?](#why-use-nom)
- [Binary format parsers](#binary-format-parsers)
- [Text format parsers](#text-format-parsers)
- [Programming language parsers](#programming-language-parsers)
- [Streaming formats](#streaming-formats)
- [Parser combinators](#parser-combinators)
- [Technical features](#technical-features)
- [Rust version requirements](#rust-version-requirements-msrv)
- [Installation](#installation)
- [Related projects](#related-projects)
- [Parsers written with nom](#parsers-written-with-nom)
- [Contributors](#contributors)
<!-- tocstop -->
## Example
[Hexadecimal color](https://developer.mozilla.org/en-US/docs/Web/CSS/color) parser:
```rust
use nom::{
bytes::complete::{tag, take_while_m_n},
combinator::map_res,
sequence::Tuple,
IResult,
Parser,
};
#[derive(Debug, PartialEq)]
pub struct Color {
pub red: u8,
pub green: u8,
pub blue: u8,
}
fn from_hex(input: &str) -> Result<u8, std::num::ParseIntError> {
u8::from_str_radix(input, 16)
}
fn is_hex_digit(c: char) -> bool {
c.is_digit(16)
}
fn hex_primary(input: &str) -> IResult<&str, u8> {
map_res(
take_while_m_n(2, 2, is_hex_digit),
from_hex
).parse(input)
}
fn hex_color(input: &str) -> IResult<&str, Color> {
let (input, _) = tag("#")(input)?;
let (input, (red, green, blue)) = (hex_primary, hex_primary, hex_primary).parse(input)?;
Ok((input, Color { red, green, blue }))
}
fn main() {
println!("{:?}", hex_color("#2F14DF"))
}
#[test]
fn parse_color() {
assert_eq!(
hex_color("#2F14DF"),
Ok((
"",
Color {
red: 47,
green: 20,
blue: 223,
}
))
);
}
```
## Documentation
- [Reference documentation](https://docs.rs/nom)
- [The Nominomicon: A Guide To Using Nom](https://tfpk.github.io/nominomicon/)
- [Various design documents and tutorials](https://github.com/rust-bakery/nom/tree/main/doc)
- [List of combinators and their behaviour](https://github.com/rust-bakery/nom/blob/main/doc/choosing_a_combinator.md)
If you need any help developing your parsers, please ping `geal` on IRC (Libera, Geeknode, OFTC), go to `#nom-parsers` on Libera IRC, or on the [Gitter chat room](https://gitter.im/Geal/nom).
## Why use nom
If you want to write:
### Binary format parsers
nom was designed to properly parse binary formats from the beginning. Compared
to the usual handwritten C parsers, nom parsers are just as fast, free from
buffer overflow vulnerabilities, and handle common patterns for you:
- [TLV](https://en.wikipedia.org/wiki/Type-length-value)
- Bit level parsing
- Hexadecimal viewer in the debugging macros for easy data analysis
- Streaming parsers for network formats and huge files
Example projects:
- [FLV parser](https://github.com/rust-av/flavors)
- [Matroska parser](https://github.com/rust-av/matroska)
- [tar parser](https://github.com/Keruspe/tar-parser.rs)
### Text format parsers
While nom was made for binary format at first, it soon grew to work just as
well with text formats. From line based formats like CSV, to more complex, nested
formats such as JSON, nom can manage it, and provides you with useful tools:
- Fast case insensitive comparison
- Recognizers for escaped strings
- Regular expressions can be embedded in nom parsers to represent complex character patterns succinctly
- Special care has been given to managing non ASCII characters properly
Example projects:
- [HTTP proxy](https://github.com/sozu-proxy/sozu/blob/main/lib/src/protocol/h2/parser.rs)
- [TOML parser](https://github.com/joelself/tomllib)
### Programming language parsers
While programming language parsers are usually written manually for more
flexibility and performance, nom can be (and has been successfully) used
as a prototyping parser for a language.
nom will get you started quickly with powerful custom error types, that you
can leverage with [nom_locate](https://github.com/fflorent/nom_locate) to
pinpoint the exact line and column of the error. No need for separate
tokenizing, lexing and parsing phases: nom can automatically handle whitespace
parsing, and construct an AST in place.
Example projects:
- [PHP VM](https://github.com/tagua-vm/parser)
- [xshade shading language](https://github.com/xshade-lang/xshade)
### Streaming formats
While a lot of formats (and the code handling them) assume that they can fit
the complete data in memory, there are formats for which we only get a part
of the data at once, like network formats, or huge files.
nom has been designed for a correct behaviour with partial data: If there is
not enough data to decide, nom will tell you it needs more instead of silently
returning a wrong result. Whether your data comes entirely or in chunks, the
result should be the same.
It allows you to build powerful, deterministic state machines for your protocols.
Example projects:
- [HTTP proxy](https://github.com/sozu-proxy/sozu/blob/main/lib/src/protocol/h2/parser.rs)
- [Using nom with generators](https://github.com/rust-bakery/generator_nom)
## Parser combinators
Parser combinators are an approach to parsers that is very different from
software like [lex](https://en.wikipedia.org/wiki/Lex_(software)) and
[yacc](https://en.wikipedia.org/wiki/Yacc). Instead of writing the grammar
in a separate file and generating the corresponding code, you use very
small functions with very specific purpose, like "take 5 bytes", or
"recognize the word 'HTTP'", and assemble them in meaningful patterns
like "recognize 'HTTP', then a space, then a version".
The resulting code is small, and looks like the grammar you would have
written with other parser approaches.
This has a few advantages:
- The parsers are small and easy to write
- The parsers components are easy to reuse (if they're general enough, please add them to nom!)
- The parsers components are easy to test separately (unit tests and property-based tests)
- The parser combination code looks close to the grammar you would have written
- You can build partial parsers, specific to the data you need at the moment, and ignore the rest
## Technical features
nom parsers are for:
- [x] **byte-oriented**: The basic type is `&[u8]` and parsers will work as much as possible on byte array slices (but are not limited to them)
- [x] **bit-oriented**: nom can address a byte slice as a bit stream
- [x] **string-oriented**: The same kind of combinators can apply on UTF-8 strings as well
- [x] **zero-copy**: If a parser returns a subset of its input data, it will return a slice of that input, without copying
- [x] **streaming**: nom can work on partial data and detect when it needs more data to produce a correct result
- [x] **descriptive errors**: The parsers can aggregate a list of error codes with pointers to the incriminated input slice. Those error lists can be pattern matched to provide useful messages.
- [x] **custom error types**: You can provide a specific type to improve errors returned by parsers
- [x] **safe parsing**: nom leverages Rust's safe memory handling and powerful types, and parsers are routinely fuzzed and tested with real world data. So far, the only flaws found by fuzzing were in code written outside of nom
- [x] **speed**: Benchmarks have shown that nom parsers often outperform many parser combinators library like Parsec and attoparsec, some regular expression engines and even handwritten C parsers
Some benchmarks are available on [GitHub](https://github.com/rust-bakery/parser_benchmarks).
## Rust version requirements (MSRV)
The 8.0 series of nom supports **Rustc version 1.65 or greater**.
The current policy is that this will only be updated in the next major nom release.
## Installation
nom is available on [crates.io](https://crates.io/crates/nom) and can be included in your Cargo enabled project like this:
```toml
[dependencies]
nom = "8"
```
There are a few compilation features:
* `alloc`: (activated by default) if disabled, nom can work in `no_std` builds without memory allocators. If enabled, combinators that allocate (like `many0`) will be available
* `std`: (activated by default, activates `alloc` too) if disabled, nom can work in `no_std` builds
You can configure those features like this:
```toml
[dependencies.nom]
version = "8"
default-features = false
features = ["alloc"]
```
# Related projects
- [Get line and column info in nom's input type](https://github.com/fflorent/nom_locate)
- [Using nom as lexer and parser](https://github.com/Rydgel/monkey-rust)
# Parsers written with nom
Here is a (non exhaustive) list of known projects using nom:
- Text file formats: [Ceph Crush](https://github.com/cholcombe973/crushtool),
[Cronenberg](https://github.com/ayrat555/cronenberg),
[Email](https://github.com/deuxfleurs-org/eml-codec),
[XFS Runtime Stats](https://github.com/ChrisMacNaughton/xfs-rs),
[CSV](https://github.com/GuillaumeGomez/csv-parser),
[FASTA](https://github.com/TianyiShi2001/nom-fasta),
[FASTQ](https://github.com/elij/fastq.rs),
[INI](https://github.com/rust-bakery/nom/blob/main/tests/ini.rs),
[ISO 8601 dates](https://github.com/badboy/iso8601),
[libconfig-like configuration file format](https://github.com/filipegoncalves/rust-config),
[Web archive](https://github.com/sbeckeriv/warc_nom_parser),
[PDB](https://github.com/TianyiShi2001/nom-pdb),
[proto files](https://github.com/tafia/protobuf-parser),
[Fountain screenplay markup](https://github.com/adamchalmers/fountain-rs),
[vimwiki](https://github.com/chipsenkbeil/vimwiki-rs/tree/master/vimwiki), [vimwiki_macros](https://github.com/chipsenkbeil/vimwiki-rs/tree/master/vimwiki_macros),
[Kconfig language](https://github.com/Mcdostone/nom-kconfig), [Askama templates](https://crates.io/crates/askama_parser/), [LP files](https://github.com/dandxy89/lp_parser_rs)
- Programming languages:
[PHP](https://github.com/tagua-vm/parser),
[Basic Calculator](https://github.com/balajisivaraman/basic_calculator_rs),
[GLSL](https://sr.ht/~hadronized/glsl)
[Lua](https://github.com/rozbb/nom-lua53),
[Python](https://github.com/ProgVal/rust-python-parser),
[SQL](https://github.com/ms705/nom-sql),
[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-engine/tree/dev/csml_interpreter),
[Wasm](https://github.com/fabrizio-m/wasm-nom),
[Pseudocode](https://github.com/Gungy2/pseudocod),
[Filter for MeiliSearch](https://github.com/meilisearch/meilisearch),
[PotterScript](https://github.com/fmiras/potterscript),
[R](https://github.com/kpagacz/tergo)
- Interface definition formats: [Thrift](https://github.com/thehydroimpulse/thrust)
- Audio, video and image formats:
[GIF](https://github.com/Geal/gif.rs),
[MagicaVoxel .vox](https://github.com/dust-engine/dot_vox),
[MIDI](https://github.com/derekdreery/nom-midi-rs),
[SWF](https://github.com/open-flash/swf-parser),
[WAVE](https://github.com/Noise-Labs/wave),
[Matroska (MKV)](https://github.com/rust-av/matroska),
[Exif/Metadata parser for JPEG/HEIF/HEIC/MOV/MP4](https://github.com/mindeng/nom-exif)
- Document formats:
[TAR](https://github.com/Keruspe/tar-parser.rs),
[GZ](https://github.com/nharward/nom-gzip),
[GDSII](https://github.com/erihsu/gds2-io)
- Cryptographic formats:
[X.509](https://github.com/rusticata/x509-parser)
- Network protocol formats:
[Bencode](https://github.com/jbaum98/bencode.rs),
[D-Bus](https://github.com/toshokan/misato),
[DHCP](https://github.com/rusticata/dhcp-parser),
[HTTP](https://github.com/sozu-proxy/sozu/tree/main/lib/src/protocol/http),
[URI](https://github.com/santifa/rrp/blob/master/src/uri.rs),
[IMAP](https://github.com/djc/tokio-imap) ([alt](https://github.com/duesee/imap-codec)),
[IRC](https://github.com/Detegr/RBot-parser),
[Pcap-NG](https://github.com/richo/pcapng-rs),
[Pcap](https://github.com/ithinuel/pcap-rs),
[Pcap + PcapNG](https://github.com/rusticata/pcap-parser),
[IKEv2](https://github.com/rusticata/ipsec-parser),
[NTP](https://github.com/rusticata/ntp-parser),
[SNMP](https://github.com/rusticata/snmp-parser),
[Kerberos v5](https://github.com/rusticata/kerberos-parser),
[DER](https://github.com/rusticata/der-parser),
[TLS](https://github.com/rusticata/tls-parser),
[V5, V7, V9, IPFIX / Netflow v10](https://github.com/mikemiles-dev/netflow_parser),
[GTP](https://github.com/fuerstenau/gorrosion-gtp),
[SIP](https://github.com/kurotych/sipcore/tree/master/crates/sipmsg),
[SMTP](https://github.com/Ekleog/kannader),
[Prometheus](https://github.com/vectordotdev/vector/blob/master/lib/prometheus-parser/src/line.rs),
[DNS](https://github.com/adiSuper94/dns-rs)
- Language specifications:
[BNF](https://github.com/shnewto/bnf)
- Misc formats:
[Game Boy ROM](https://github.com/MarkMcCaskey/gameboy-rom-parser),
[ANT FIT](https://github.com/stadelmanma/fitparse-rs),
[Version Numbers](https://github.com/fosskers/rs-versions),
[Telcordia/Bellcore SR-4731 SOR OTDR files](https://github.com/JamesHarrison/otdrs),
[MySQL binary log](https://github.com/PrivateRookie/boxercrab),
[URI](https://github.com/Skasselbard/nom-uri),
[Furigana](https://github.com/sachaarbonel/furigana.rs),
[Wordle Result](https://github.com/Fyko/wordle-stats/tree/main/parser),
[NBT](https://github.com/phoenixr-codes/mcnbt)
Want to create a new parser using `nom`? A list of not yet implemented formats is available [here](https://github.com/rust-bakery/nom/issues/14).
Want to add your parser here? Create a pull request for it!
# Contributors
nom is the fruit of the work of many contributors over the years, many thanks for your help!
<a href="https://github.com/rust-bakery/nom/graphs/contributors">
<img src="https://contributors-img.web.app/image?repo=rust-bakery/nom" />
</a>
================================================
FILE: assets/links.txt
================================================
https://github.com/ekmett/machines
https://www.fpcomplete.com/user/snoyberg/library-documentation/conduit-overview
https://hackage.haskell.org/package/pipes
http://en.wikipedia.org/wiki/Iteratee#cite_note-play-enumeratee-3
http://okmij.org/ftp/Streams.html#design
http://okmij.org/ftp/Haskell/Iteratee/Iteratee.hs
http://okmij.org/ftp/Haskell/Iteratee/describe.pdf
http://okmij.org/ftp/Haskell/Iteratee/IterDemo.hs
http://okmij.org/ftp/Haskell/Iteratee/IterDemo1.hs
http://mandubian.com/2012/08/27/understanding-play2-iteratees-for-normal-humans/
https://github.com/playframework/playframework/tree/master/framework/src/iteratees/src/main/scala/play/api/libs/Iteratee
https://github.com/playframework/playframework/blob/master/framework/src/iteratees/src/main/scala/play/api/libs/iteratee/Iteratee.scala
https://github.com/playframework/playframework/blob/master/framework/src/iteratees/src/main/scala/play/api/libs/iteratee/Enumerator.scala
http://stackoverflow.com/questions/10177666/cant-understand-iteratee-enumerator-enumeratee-in-play-2-0
http://stackoverflow.com/questions/10346592/how-to-write-an-enumeratee-to-chunk-an-enumerator-along-different-boundaries
http://okmij.org/ftp/Haskell/Iteratee/Iteratee.hs
http://www.mew.org/~kazu/proj/enumerator/
http://www.reddit.com/r/rust/comments/2aur8x/using_macros_to_parse_file_formats/
https://github.com/LeoTestard/rustlex
https://github.com/rust-lang/rust/blob/master/src/test/run-pass/monad.rs
www.reddit.com/r/programming/comments/z7lwn/rust_typeclasses_talk/
https://github.com/rust-lang/rfcs/pull/53
http://apocalisp.wordpress.com/2011/10/26/tail-call-elimination-in-scala-monads/
http://www.cis.upenn.edu/~bcpierce/sf/current/toc.html
http://www.reddit.com/r/rust/comments/1a57pw/haskeller_playing_with_rust_a_question_about/
================================================
FILE: assets/testfile.txt
================================================
abcdabcdabcdabcdabcd
efgh
coin coin
hello
blah
================================================
FILE: benchmarks/Cargo.toml
================================================
[package]
name = "benchmarks"
version = "0.1.0"
edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
criterion = "0.5.0"
jemallocator = "0.5.4"
nom = { path = "../" }
[lib]
bench = false
[[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 = "http_streaming"
path = "benches/http_streaming.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
[[bench]]
name = "json_streaming"
path = "benches/json_streaming.rs"
harness = false
[dev-dependencies]
codspeed-criterion-compat = "2.4.1"
nom-language = { path = "../nom-language" }
================================================
FILE: benchmarks/README.md
================================================
# Benchmarks for nom parsers
================================================
FILE: benchmarks/benches/arithmetic.rs
================================================
#[global_allocator]
static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
use codspeed_criterion_compat::{criterion_group, criterion_main, Criterion};
use nom::{
branch::alt,
character::complete::{char, digit1, one_of, space0},
combinator::map_res,
multi::fold,
sequence::{delimited, pair},
IResult, Parser,
};
// Parser definition
// We transform an integer string into a i64, ignoring surrounding whitespaces
// We look for a digit suite, and try to convert it.
// If there are no digits, we look for a parenthesized expression.
fn factor(input: &[u8]) -> IResult<&[u8], i64> {
delimited(
space0,
alt((
map_res(digit1, |digits| {
unsafe { std::str::from_utf8_unchecked(digits) }.parse()
}),
delimited(char('('), expr, char(')')),
)),
space0,
)
.parse(input)
}
// We read an initial factor and for each time we find
// a * or / operator followed by another factor, we do
// the math by folding everything
fn term(input: &[u8]) -> IResult<&[u8], i64> {
let (input, init) = factor(input)?;
fold(
0..,
pair(one_of("*/"), factor),
move || init,
|acc, (op, val)| {
if op == '*' {
acc * val
} else {
acc / val
}
},
)
.parse_complete(input)
}
fn expr(input: &[u8]) -> IResult<&[u8], i64> {
let (input, init) = term(input)?;
fold(
0..,
pair(one_of("+-"), term),
move || init,
|acc, (op, val)| {
if op == '+' {
acc + val
} else {
acc - val
}
},
)
.parse_complete(input)
}
#[allow(clippy::eq_op, clippy::erasing_op)]
fn arithmetic(c: &mut Criterion) {
let data = b" 2*2 / ( 5 - 1) + 3 / 4 * (2 - 7 + 567 *12 /2) + 3*(1+2*( 45 /2));";
assert_eq!(
expr(data),
Ok((
&b";"[..],
2 * 2 / (5 - 1) + 3 / 4 * (2 - 7 + 567 * 12 / 2) + 3 * (1 + 2 * (45 / 2)),
))
);
c.bench_function("arithmetic", |b| {
b.iter(|| expr(data).unwrap());
});
}
criterion_group!(benches, arithmetic);
criterion_main!(benches);
================================================
FILE: benchmarks/benches/http.rs
================================================
#![cfg_attr(rustfmt, rustfmt_skip)]
#[global_allocator]
static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
use codspeed_criterion_compat::*;
use nom::{IResult, bytes::{tag, take_while1}, character:: char, multi::many, OutputMode, Parser, PResult, error::Error, Mode, sequence::{preceded, delimited, separated_pair, terminated, pair}, OutputM, Emit, Complete};
#[cfg_attr(rustfmt, rustfmt_skip)]
#[derive(Debug)]
struct Request<'a> {
method: &'a [u8],
uri: &'a [u8],
version: &'a [u8],
}
#[derive(Debug)]
struct Header<'a> {
name: &'a [u8],
value: Vec<&'a [u8]>,
}
#[cfg_attr(rustfmt, rustfmt_skip)]
#[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
fn is_token(c: u8) -> bool {
match c {
128..=255 => false,
0..=31 => false,
b'(' => false,
b')' => false,
b'<' => false,
b'>' => false,
b'@' => false,
b',' => false,
b';' => false,
b':' => false,
b'\\' => false,
b'"' => false,
b'/' => false,
b'[' => false,
b']' => false,
b'?' => false,
b'=' => false,
b'{' => false,
b'}' => false,
b' ' => false,
_ => true,
}
}
fn not_line_ending(c: u8) -> bool {
c != b'\r' && c != b'\n'
}
fn is_space(c: u8) -> bool {
c == b' '
}
fn is_not_space(c: u8) -> bool {
c != b' '
}
fn is_horizontal_space(c: u8) -> bool {
c == b' ' || c == b'\t'
}
fn is_version(c: u8) -> bool {
c >= b'0' && c <= b'9' || c == b'.'
}
fn line_ending<'a>()-> impl Parser<&'a[u8], Output=&'a[u8], Error=Error<&'a[u8]>> {
tag("\n").or(tag("\r\n"))
}
fn request_line<'a>()-> impl Parser<&'a[u8], Output=Request<'a>, Error=Error<&'a[u8]>> {
(take_while1(is_token), preceded(take_while1(is_space), take_while1(is_not_space)), delimited(take_while1(is_space), http_version(), line_ending()))
.map(|(method, uri, version)| Request {method, uri, version})
}
fn http_version<'a>() -> impl Parser<&'a[u8], Output=&'a[u8], Error=Error<&'a[u8]>> {
preceded(tag("HTTP/"), take_while1(is_version))
}
fn message_header_value<'a>() -> impl Parser<&'a[u8], Output=&'a[u8], Error=Error<&'a[u8]>> {
delimited(take_while1(is_horizontal_space), take_while1(not_line_ending), line_ending())
}
fn message_header<'a>() -> impl Parser<&'a[u8], Output=Header<'a>, Error=Error<&'a[u8]> >{
separated_pair(take_while1(is_token), char(':'), many(1.., message_header_value()))
.map(|(name, value)|Header{ name, value })
}
fn request<'a>() -> impl Parser<&'a[u8], Output=(Request<'a>, Vec<Header<'a>>), Error=Error<&'a[u8]> > {
pair(request_line(), terminated(many(1.., message_header()), line_ending()))
}
fn parse(data: &[u8]) -> Option<Vec<(Request<'_>, Vec<Header<'_>>)>> {
let mut buf = &data[..];
let mut v = Vec::new();
loop {
match request().process::<OutputM<Emit, Emit, Complete>>(buf) {
Ok((b, r)) => {
buf = b;
v.push(r);
if b.is_empty() {
//println!("{}", i);
break;
}
}
Err(e) => {
println!("error: {:?}", e);
return None;
},
}
}
Some(v)
}
/*
#[bench]
fn small_test(b: &mut Bencher) {
let data = include_bytes!("../../http-requests.txt");
b.iter(||{
parse(data)
});
}
#[bench]
fn bigger_test(b: &mut Bencher) {
let data = include_bytes!("../../bigger.txt");
b.iter(||{
parse(data)
});
}
*/
fn one_test(c: &mut Criterion) {
let data = &b"GET / HTTP/1.1
Host: www.reddit.com
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:15.0) Gecko/20100101 Firefox/15.0.1
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: keep-alive
"[..];
let mut http_group = c.benchmark_group("http");
http_group.throughput(Throughput::Bytes(data.len() as u64));
http_group.bench_with_input(
BenchmarkId::new("parse", data.len()),
data,
|b, data| {
b.iter(|| parse(data).unwrap());
});
http_group.finish();
}
/*
fn main() {
let mut contents: Vec<u8> = Vec::new();
{
use std::io::Read;
let mut file = File::open(env::args().nth(1).expect("File to read")).expect("Failed to open file");
let _ = file.read_to_end(&mut contents).unwrap();
}
let buf = &contents[..];
loop {
parse(buf);
}
}
*/
criterion_group!(http, one_test);
criterion_main!(http);
================================================
FILE: benchmarks/benches/http_streaming.rs
================================================
#![cfg_attr(rustfmt, rustfmt_skip)]
#[global_allocator]
static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
use codspeed_criterion_compat::*;
use nom::{IResult, bytes::streaming::{tag, take_while1}, character::streaming::{line_ending, char}, multi::many, Parser};
#[cfg_attr(rustfmt, rustfmt_skip)]
#[derive(Debug)]
struct Request<'a> {
method: &'a [u8],
uri: &'a [u8],
version: &'a [u8],
}
#[derive(Debug)]
struct Header<'a> {
name: &'a [u8],
value: Vec<&'a [u8]>,
}
#[cfg_attr(rustfmt, rustfmt_skip)]
#[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
fn is_token(c: u8) -> bool {
match c {
128..=255 => false,
0..=31 => false,
b'(' => false,
b')' => false,
b'<' => false,
b'>' => false,
b'@' => false,
b',' => false,
b';' => false,
b':' => false,
b'\\' => false,
b'"' => false,
b'/' => false,
b'[' => false,
b']' => false,
b'?' => false,
b'=' => false,
b'{' => false,
b'}' => false,
b' ' => false,
_ => true,
}
}
fn not_line_ending(c: u8) -> bool {
c != b'\r' && c != b'\n'
}
fn is_space(c: u8) -> bool {
c == b' '
}
fn is_not_space(c: u8) -> bool {
c != b' '
}
fn is_horizontal_space(c: u8) -> bool {
c == b' ' || c == b'\t'
}
fn is_version(c: u8) -> bool {
c >= b'0' && c <= b'9' || c == b'.'
}
fn request_line(input: &[u8]) -> IResult<&[u8], Request<'_>> {
let (input, method) = take_while1(is_token)(input)?;
let (input, _) = take_while1(is_space)(input)?;
let (input, uri) = take_while1(is_not_space)(input)?;
let (input, _) = take_while1(is_space)(input)?;
let (input, version) = http_version(input)?;
let (input, _) = line_ending(input)?;
Ok((input, Request {method, uri, version}))
}
fn http_version(input: &[u8]) -> IResult<&[u8], &[u8]> {
let (input, _) = tag("HTTP/")(input)?;
let (input, version) = take_while1(is_version)(input)?;
Ok((input, version))
}
fn message_header_value(input: &[u8]) -> IResult<&[u8], &[u8]> {
let (input, _) = take_while1(is_horizontal_space)(input)?;
let (input, data) = take_while1(not_line_ending)(input)?;
let (input, _) = line_ending(input)?;
Ok((input, data))
}
fn message_header(input: &[u8]) -> IResult<&[u8], Header<'_>> {
let (input, name) = take_while1(is_token)(input)?;
let (input, _) = char(':')(input)?;
let (input, value) = many(1.., message_header_value).parse(input)?;
Ok((input, Header{ name, value }))
}
fn request(input: &[u8]) -> IResult<&[u8], (Request<'_>, Vec<Header<'_>>)> {
let (input, req) = request_line(input)?;
let (input, h) = many(1.., message_header).parse(input)?;
let (input, _) = line_ending(input)?;
Ok((input, (req, h)))
}
fn parse(data: &[u8]) -> Option<Vec<(Request<'_>, Vec<Header<'_>>)>> {
let mut buf = &data[..];
let mut v = Vec::new();
loop {
match request(buf) {
Ok((b, r)) => {
buf = b;
v.push(r);
if b.is_empty() {
//println!("{}", i);
break;
}
}
Err(e) => {
println!("error: {:?}", e);
return None;
},
}
}
Some(v)
}
/*
#[bench]
fn small_test(b: &mut Bencher) {
let data = include_bytes!("../../http-requests.txt");
b.iter(||{
parse(data)
});
}
#[bench]
fn bigger_test(b: &mut Bencher) {
let data = include_bytes!("../../bigger.txt");
b.iter(||{
parse(data)
});
}
*/
fn one_test(c: &mut Criterion) {
let data = &b"GET / HTTP/1.1
Host: www.reddit.com
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:15.0) Gecko/20100101 Firefox/15.0.1
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: keep-alive
"[..];
let mut http_group = c.benchmark_group("http");
http_group.throughput(Throughput::Bytes(data.len() as u64));
http_group.bench_with_input(
BenchmarkId::new("parse_streaming", data.len()),
data,
|b, data| {
b.iter(|| parse(data).unwrap());
});
http_group.finish();
}
/*
fn main() {
let mut contents: Vec<u8> = Vec::new();
{
use std::io::Read;
let mut file = File::open(env::args().nth(1).expect("File to read")).expect("Failed to open file");
let _ = file.read_to_end(&mut contents).unwrap();
}
let buf = &contents[..];
loop {
parse(buf);
}
}
*/
criterion_group!(http_streaming, one_test);
criterion_main!(http_streaming);
================================================
FILE: benchmarks/benches/ini.rs
================================================
#[global_allocator]
static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
use codspeed_criterion_compat::*;
use nom::{
bytes::complete::take_while,
character::complete::{
alphanumeric1 as alphanumeric, char, multispace1 as multispace, space1 as space,
},
combinator::{map_res, opt},
multi::many,
sequence::{delimited, pair, separated_pair, terminated, tuple},
IResult, Parser,
};
use std::collections::HashMap;
use std::str;
fn category(i: &[u8]) -> IResult<&[u8], &str> {
map_res(
delimited(char('['), take_while(|c| c != b']'), char(']')),
str::from_utf8,
)
.parse_complete(i)
}
fn key_value(i: &[u8]) -> IResult<&[u8], (&str, &str)> {
let (i, key) = map_res(alphanumeric, str::from_utf8).parse_complete(i)?;
let (i, _) = tuple((opt(space), char('='), opt(space))).parse_complete(i)?;
let (i, val) =
map_res(take_while(|c| c != b'\n' && c != b';'), str::from_utf8).parse_complete(i)?;
let (i, _) = opt(pair(char(';'), take_while(|c| c != b'\n'))).parse_complete(i)?;
Ok((i, (key, val)))
}
fn categories(i: &[u8]) -> IResult<&[u8], HashMap<&str, HashMap<&str, &str>>> {
many(
0..,
separated_pair(
category,
opt(multispace),
many(0.., terminated(key_value, opt(multispace))),
),
)
.parse_complete(i)
}
fn bench_ini(c: &mut Criterion) {
let str = "[owner]
name=John Doe
organization=Acme Widgets Inc.
[database]
server=192.0.2.62
port=143
file=payroll.dat
\0";
let mut group = c.benchmark_group("ini");
group.throughput(Throughput::Bytes(str.len() as u64));
group.bench_function(BenchmarkId::new("parse", str.len()), |b| {
b.iter(|| categories(str.as_bytes()).unwrap())
});
}
fn bench_ini_keys_and_values(c: &mut Criterion) {
let str = "server=192.0.2.62
port=143
file=payroll.dat
\0";
fn acc(i: &[u8]) -> IResult<&[u8], Vec<(&str, &str)>> {
many(0.., key_value).parse_complete(i)
}
let mut group = c.benchmark_group("ini keys and values");
group.throughput(Throughput::Bytes(str.len() as u64));
group.bench_function(BenchmarkId::new("parse", str.len()), |b| {
b.iter(|| acc(str.as_bytes()).unwrap())
});
}
fn bench_ini_key_value(c: &mut Criterion) {
let str = "server=192.0.2.62\n";
let mut group = c.benchmark_group("ini key value");
group.throughput(Throughput::Bytes(str.len() as u64));
group.bench_function(BenchmarkId::new("parse", str.len()), |b| {
b.iter(|| key_value(str.as_bytes()).unwrap())
});
}
criterion_group!(
benches,
bench_ini,
bench_ini_keys_and_values,
bench_ini_key_value
);
criterion_main!(benches);
================================================
FILE: benchmarks/benches/ini_str.rs
================================================
#[global_allocator]
static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
use codspeed_criterion_compat::*;
use nom::{
bytes::complete::{is_a, tag, take_till, take_while},
character::complete::{alphanumeric1 as alphanumeric, char, not_line_ending, space0 as space},
combinator::opt,
multi::many,
sequence::{delimited, pair, terminated, tuple},
IResult, Parser,
};
use std::collections::HashMap;
fn is_line_ending_or_comment(chr: char) -> bool {
chr == ';' || chr == '\n'
}
fn space_or_line_ending(i: &str) -> IResult<&str, &str> {
is_a(" \r\n")(i)
}
fn category(i: &str) -> IResult<&str, &str> {
terminated(
delimited(char('['), take_while(|c| c != ']'), char(']')),
opt(is_a(" \r\n")),
)
.parse(i)
}
fn key_value(i: &str) -> IResult<&str, (&str, &str)> {
let (i, key) = alphanumeric(i)?;
let (i, _) = tuple((opt(space), tag("="), opt(space)))(i)?;
let (i, val) = take_till(is_line_ending_or_comment)(i)?;
let (i, _) = opt(space).parse_complete(i)?;
let (i, _) = opt(pair(tag(";"), not_line_ending)).parse_complete(i)?;
let (i, _) = opt(space_or_line_ending).parse_complete(i)?;
Ok((i, (key, val)))
}
fn keys_and_values(input: &str) -> IResult<&str, HashMap<&str, &str>> {
many(0.., key_value).parse_complete(input)
}
fn category_and_keys(i: &str) -> IResult<&str, (&str, HashMap<&str, &str>)> {
pair(category, keys_and_values).parse_complete(i)
}
fn categories(input: &str) -> IResult<&str, HashMap<&str, HashMap<&str, &str>>> {
many(0.., category_and_keys).parse_complete(input)
}
fn bench_ini_str(c: &mut Criterion) {
let s = "[owner]
name=John Doe
organization=Acme Widgets Inc.
[database]
server=192.0.2.62
port=143
file=payroll.dat
";
let mut group = c.benchmark_group("ini str");
group.throughput(Throughput::Bytes(s.len() as u64));
group.bench_function(BenchmarkId::new("parse", s.len()), |b| {
b.iter(|| categories(s).unwrap())
});
}
criterion_group!(benches, bench_ini_str);
criterion_main!(benches);
================================================
FILE: benchmarks/benches/json.rs
================================================
#[global_allocator]
static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
use codspeed_criterion_compat::*;
use nom::{
branch::alt,
bytes::{tag, take},
character::{anychar, char, multispace0, none_of},
combinator::{map, map_opt, map_res, value, verify},
error::{Error, ErrorKind, FromExternalError, ParseError},
multi::{fold, separated_list0},
number::double,
number::recognize_float,
sequence::{delimited, preceded, separated_pair},
Check, Complete, Emit, IResult, Mode, OutputM, Parser,
};
use nom_language::error::VerboseError;
use std::{collections::HashMap, marker::PhantomData, num::ParseIntError};
#[derive(Debug, PartialEq, Clone)]
pub enum JsonValue {
Null,
Bool(bool),
Str(String),
Num(f64),
Array(Vec<JsonValue>),
Object(HashMap<String, JsonValue>),
}
fn boolean<'a, E: ParseError<&'a str>>() -> impl Parser<&'a str, Output = bool, Error = E> {
alt((value(false, tag("false")), value(true, tag("true"))))
}
fn u16_hex<'a, E: ParseError<&'a str> + FromExternalError<&'a str, ParseIntError>>(
) -> impl Parser<&'a str, Output = u16, Error = E> {
map_res(take(4usize), |s| u16::from_str_radix(s, 16))
}
fn unicode_escape<'a, E: ParseError<&'a str> + FromExternalError<&'a str, ParseIntError>>(
) -> impl Parser<&'a str, Output = char, Error = E> {
map_opt(
alt((
// Not a surrogate
map(
verify(u16_hex(), |cp| !(0xD800..0xE000).contains(cp)),
|cp| cp as u32,
),
// See https://en.wikipedia.org/wiki/UTF-16#Code_points_from_U+010000_to_U+10FFFF for details
map(
verify(
separated_pair(u16_hex(), tag("\\u"), u16_hex()),
|(high, low)| (0xD800..0xDC00).contains(high) && (0xDC00..0xE000).contains(low),
),
|(high, low)| {
let high_ten = (high as u32) - 0xD800;
let low_ten = (low as u32) - 0xDC00;
(high_ten << 10) + low_ten + 0x10000
},
),
)),
// Could probably be replaced with .unwrap() or _unchecked due to the verify checks
std::char::from_u32,
)
}
fn character<
'a,
E: ParseError<&'a str> + FromExternalError<&'a str, ParseIntError> + FromExternalError<&'a str, ()>,
>() -> impl Parser<&'a str, Output = char, Error = E> {
Character { e: PhantomData }
/*let (input, c) = none_of("\"")(input)?;
if c == '\\' {
alt((
map_res(anychar, |c| {
Ok(match c {
'"' | '\\' | '/' => c,
'b' => '\x08',
'f' => '\x0C',
'n' => '\n',
'r' => '\r',
't' => '\t',
_ => return Err(()),
})
}),
preceded(char('u'), unicode_escape()),
))
.parse(input)
} else {
Ok((input, c))
}*/
}
struct Character<E> {
e: PhantomData<E>,
}
impl<'a, E> Parser<&'a str> for Character<E>
where
E: ParseError<&'a str>
+ FromExternalError<&'a str, ParseIntError>
+ FromExternalError<&'a str, ()>,
{
type Output = char;
type Error = E;
fn process<OM: nom::OutputMode>(
&mut self,
input: &'a str,
) -> nom::PResult<OM, &'a str, Self::Output, Self::Error> {
let (input, c): (&str, char) =
none_of("\"").process::<OutputM<Emit, OM::Error, OM::Incomplete>>(input)?;
if c == '\\' {
alt((
map_res(anychar, |c| {
Ok(match c {
'"' | '\\' | '/' => c,
'b' => '\x08',
'f' => '\x0C',
'n' => '\n',
'r' => '\r',
't' => '\t',
_ => return Err(()),
})
}),
preceded(char('u'), unicode_escape()),
))
.process::<OM>(input)
} else {
Ok((input, OM::Output::bind(|| c)))
}
}
}
fn string<
'a,
E: ParseError<&'a str> + FromExternalError<&'a str, ParseIntError> + FromExternalError<&'a str, ()>,
>() -> impl Parser<&'a str, Output = String, Error = E> {
delimited(
char('"'),
fold(0.., character(), String::new, |mut string, c| {
string.push(c);
string
}),
char('"'),
)
}
fn ws<
'a,
O,
E: ParseError<&'a str> + FromExternalError<&'a str, ParseIntError> + FromExternalError<&'a str, ()>,
F: Parser<&'a str, Output = O, Error = E>,
>(
f: F,
) -> impl Parser<&'a str, Output = O, Error = E> {
delimited(multispace0(), f, multispace0())
}
fn array<
'a,
E: ParseError<&'a str> + FromExternalError<&'a str, ParseIntError> + FromExternalError<&'a str, ()>,
>() -> impl Parser<&'a str, Output = Vec<JsonValue>, Error = E> {
delimited(
char('['),
ws(separated_list0(ws(char(',')), json_value())),
char(']'),
)
}
fn object<
'a,
E: ParseError<&'a str> + FromExternalError<&'a str, ParseIntError> + FromExternalError<&'a str, ()>,
>() -> impl Parser<&'a str, Output = HashMap<String, JsonValue>, Error = E> {
map(
delimited(
char('{'),
ws(separated_list0(
ws(char(',')),
separated_pair(string(), ws(char(':')), json_value()),
)),
char('}'),
),
|key_values| key_values.into_iter().collect(),
)
}
/*
fn json_value<'a, E: ParseError<&'a str> + FromExternalError<&'a str, ParseIntError> + FromExternalError<&'a str, ()>,
>() -> Box<dyn Parser<&'a str, Output = JsonValue, Error = E>> {
use JsonValue::*;
Box::new(alt((
value(Null, tag("null")),
map(boolean(), Bool),
map(string(), Str),
map(double, Num),
map(array(), Array),
map(object(), Object),
)))
}
*/
fn json_value<
'a,
E: ParseError<&'a str> + FromExternalError<&'a str, ParseIntError> + FromExternalError<&'a str, ()>,
>() -> JsonParser<E> {
JsonParser { e: PhantomData }
}
struct JsonParser<E> {
e: PhantomData<E>,
}
// the main Parser implementation is done explicitely on a real type,
// because haaving json_value return `impl Parser` would result in
// "recursive opaque type" errors
impl<'a, E> Parser<&'a str> for JsonParser<E>
where
E: ParseError<&'a str>
+ FromExternalError<&'a str, ParseIntError>
+ FromExternalError<&'a str, ()>,
{
type Output = JsonValue;
type Error = E;
fn process<OM: nom::OutputMode>(
&mut self,
input: &'a str,
) -> nom::PResult<OM, &'a str, Self::Output, Self::Error> {
use JsonValue::*;
alt((
value(Null, tag("null")),
map(boolean(), Bool),
map(string(), Str),
map(double(), Num),
map(array(), Array),
map(object(), Object),
))
.process::<OM>(input)
}
}
fn json<
'a,
E: ParseError<&'a str> + FromExternalError<&'a str, ParseIntError> + FromExternalError<&'a str, ()>,
>() -> impl Parser<&'a str, Output = JsonValue, Error = E> {
ws(json_value())
}
fn json_bench(c: &mut Criterion) {
let data = " { \"a\"\t: 42,
\"b\": [ \"x\", \"y\", 12 ,\"\\u2014\", \"\\uD83D\\uDE10\"] ,
\"c\": { \"hello\" : \"world\"
}
} ";
// test once to make sure it parses correctly
json::<Error<&str>>()
.process::<OutputM<Emit, Emit, Complete>>(data)
.unwrap();
// println!("data:\n{:?}", json(data));
c.bench_function("json", |b| {
b.iter(|| {
json::<Error<&str>>()
.process::<OutputM<Emit, Emit, Complete>>(data)
.unwrap()
});
});
}
fn json_bench_error_check(c: &mut Criterion) {
let data = " { \"a\"\t: 42,
\"b\": [ \"x\", \"y\", 12 ,\"\\u2014\", \"\\uD83D\\uDE10\"] ,
\"c\": { \"hello\" : \"world\"
}
} ";
// test once to make sure it parses correctly
json::<Error<&str>>()
.process::<OutputM<Emit, Check, Complete>>(data)
.unwrap();
// println!("data:\n{:?}", json(data));
c.bench_function("json", |b| {
b.iter(|| {
json::<Error<&str>>()
.process::<OutputM<Emit, Check, Complete>>(data)
.unwrap()
});
});
}
static CANADA: &str = include_str!("../canada.json");
fn canada_json(c: &mut Criterion) {
// test once to make sure it parses correctly
json::<Error<&str>>()
.process::<OutputM<Emit, Emit, Complete>>(CANADA)
.unwrap();
// println!("data:\n{:?}", json(data));
c.bench_function("json canada", |b| {
b.iter(|| {
json::<Error<&str>>()
.process::<OutputM<Emit, Emit, Complete>>(CANADA)
.unwrap()
});
});
}
fn verbose_json(c: &mut Criterion) {
let data = " { \"a\"\t: 42,
\"b\": [ \"x\", \"y\", 12 ,\"\\u2014\", \"\\uD83D\\uDE10\"] ,
\"c\": { \"hello\" : \"world\"
}
} ";
// test once to make sure it parses correctly
json::<VerboseError<&str>>()
.process::<OutputM<Emit, Emit, Complete>>(data)
.unwrap();
// println!("data:\n{:?}", json(data));
c.bench_function("json verbose", |b| {
b.iter(|| {
json::<VerboseError<&str>>()
.process::<OutputM<Emit, Emit, Complete>>(data)
.unwrap()
});
});
}
fn verbose_canada_json(c: &mut Criterion) {
// test once to make sure it parses correctly
json::<VerboseError<&str>>()
.process::<OutputM<Emit, Emit, Complete>>(CANADA)
.unwrap();
// println!("data:\n{:?}", json(data));
c.bench_function("json canada verbose", |b| {
b.iter(|| {
json::<VerboseError<&str>>()
.process::<OutputM<Emit, Emit, Complete>>(CANADA)
.unwrap()
});
});
}
fn recognize_float_bytes(c: &mut Criterion) {
println!(
"recognize_float_bytes result: {:?}",
recognize_float::<_, (_, ErrorKind)>()
.process::<OutputM<Emit, Emit, Complete>>(&b"-1.234E-12"[..])
);
c.bench_function("recognize float bytes", |b| {
b.iter(|| {
recognize_float::<_, (_, ErrorKind)>()
.process::<OutputM<Emit, Emit, Complete>>(&b"-1.234E-12"[..])
});
});
}
fn recognize_float_str(c: &mut Criterion) {
println!(
"recognize_float_str result: {:?}",
recognize_float::<_, (_, ErrorKind)>().process::<OutputM<Emit, Emit, Complete>>("-1.234E-12")
);
c.bench_function("recognize float str", |b| {
b.iter(|| {
recognize_float::<_, (_, ErrorKind)>().process::<OutputM<Emit, Emit, Complete>>("-1.234E-12")
});
});
}
fn float_bytes(c: &mut Criterion) {
println!(
"float_bytes result: {:?}",
double::<_, (_, ErrorKind)>().process::<OutputM<Emit, Emit, Complete>>(&b"-1.234E-12"[..])
);
c.bench_function("float bytes", |b| {
b.iter(|| {
double::<_, (_, ErrorKind)>().process::<OutputM<Emit, Emit, Complete>>(&b"-1.234E-12"[..])
});
});
}
fn float_str(c: &mut Criterion) {
println!(
"float_str result: {:?}",
double::<_, (_, ErrorKind)>().process::<OutputM<Emit, Emit, Complete>>("-1.234E-12")
);
c.bench_function("float str", |b| {
b.iter(|| double::<_, (_, ErrorKind)>().process::<OutputM<Emit, Emit, Complete>>("-1.234E-12"));
});
}
use nom::Err;
use nom::ParseTo;
fn std_float(input: &[u8]) -> IResult<&[u8], f64, (&[u8], ErrorKind)> {
match recognize_float().process::<OutputM<Emit, Emit, Complete>>(input) {
Err(e) => Err(e),
Ok((i, s)) => match s.parse_to() {
Some(n) => Ok((i, n)),
None => Err(Err::Error((i, ErrorKind::Float))),
},
}
}
fn std_float_bytes(c: &mut Criterion) {
println!(
"std_float_bytes result: {:?}",
std_float(&b"-1.234E-12"[..])
);
c.bench_function("std_float bytes", |b| {
b.iter(|| std_float(&b"-1.234E-12"[..]));
});
}
criterion_group!(
benches,
json_bench,
json_bench_error_check,
verbose_json,
canada_json,
verbose_canada_json,
recognize_float_bytes,
recognize_float_str,
float_bytes,
std_float_bytes,
float_str
);
criterion_main!(benches);
================================================
FILE: benchmarks/benches/json_streaming.rs
================================================
#[global_allocator]
static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
use codspeed_criterion_compat::*;
use nom::{
branch::alt,
bytes::streaming::{tag, take},
character::streaming::{anychar, char, multispace0, none_of},
combinator::{map, map_opt, map_res, value, verify},
error::{ErrorKind, ParseError},
multi::{fold, separated_list0},
number::streaming::{double, recognize_float},
sequence::{delimited, preceded, separated_pair},
IResult, Parser,
};
use std::collections::HashMap;
#[derive(Debug, PartialEq, Clone)]
pub enum JsonValue {
Null,
Bool(bool),
Str(String),
Num(f64),
Array(Vec<JsonValue>),
Object(HashMap<String, JsonValue>),
}
fn boolean(input: &str) -> IResult<&str, bool> {
alt((value(false, tag("false")), value(true, tag("true")))).parse(input)
}
fn u16_hex(input: &str) -> IResult<&str, u16> {
map_res(take(4usize), |s| u16::from_str_radix(s, 16)).parse(input)
}
fn unicode_escape(input: &str) -> IResult<&str, char> {
map_opt(
alt((
// Not a surrogate
map(verify(u16_hex, |cp| !(0xD800..0xE000).contains(cp)), |cp| {
cp as u32
}),
// See https://en.wikipedia.org/wiki/UTF-16#Code_points_from_U+010000_to_U+10FFFF for details
map(
verify(
separated_pair(u16_hex, tag("\\u"), u16_hex),
|(high, low)| (0xD800..0xDC00).contains(high) && (0xDC00..0xE000).contains(low),
),
|(high, low)| {
let high_ten = (high as u32) - 0xD800;
let low_ten = (low as u32) - 0xDC00;
(high_ten << 10) + low_ten + 0x10000
},
),
)),
// Could probably be replaced with .unwrap() or _unchecked due to the verify checks
std::char::from_u32,
)
.parse(input)
}
fn character(input: &str) -> IResult<&str, char> {
let (input, c) = none_of("\"")(input)?;
if c == '\\' {
alt((
map_res(anychar, |c| {
Ok(match c {
'"' | '\\' | '/' => c,
'b' => '\x08',
'f' => '\x0C',
'n' => '\n',
'r' => '\r',
't' => '\t',
_ => return Err(()),
})
}),
preceded(char('u'), unicode_escape),
))
.parse(input)
} else {
Ok((input, c))
}
}
fn string(input: &str) -> IResult<&str, String> {
delimited(
char('"'),
fold(0.., character, String::new, |mut string, c| {
string.push(c);
string
}),
char('"'),
)
.parse(input)
}
fn ws<'a, O, E: ParseError<&'a str>, F: Parser<&'a str, Output = O, Error = E>>(
f: F,
) -> impl Parser<&'a str, Output = O, Error = E> {
delimited(multispace0, f, multispace0)
}
fn array(input: &str) -> IResult<&str, Vec<JsonValue>> {
delimited(
char('['),
ws(separated_list0(ws(char(',')), json_value)),
char(']'),
)
.parse(input)
}
fn object(input: &str) -> IResult<&str, HashMap<String, JsonValue>> {
map(
delimited(
char('{'),
ws(separated_list0(
ws(char(',')),
separated_pair(string, ws(char(':')), json_value),
)),
char('}'),
),
|key_values| key_values.into_iter().collect(),
)
.parse(input)
}
fn json_value(input: &str) -> IResult<&str, JsonValue> {
use JsonValue::*;
alt((
value(Null, tag("null")),
map(boolean, Bool),
map(string, Str),
map(double, Num),
map(array, Array),
map(object, Object),
))
.parse(input)
}
fn json(input: &str) -> IResult<&str, JsonValue> {
ws(json_value).parse(input)
}
fn json_bench(c: &mut Criterion) {
let data = " { \"a\"\t: 42,
\"b\": [ \"x\", \"y\", 12 ,\"\\u2014\", \"\\uD83D\\uDE10\"] ,
\"c\": { \"hello\" : \"world\"
}
} ;";
// println!("data:\n{:?}", json(data));
c.bench_function("json streaming", |b| {
b.iter(|| json(data).unwrap());
});
}
fn recognize_float_bytes(c: &mut Criterion) {
println!(
"recognize_float_bytes result: {:?}",
recognize_float::<_, (_, ErrorKind)>(&b"-1.234E-12;"[..])
);
c.bench_function("recognize float bytes streaming", |b| {
b.iter(|| recognize_float::<_, (_, ErrorKind)>(&b"-1.234E-12;"[..]));
});
}
fn recognize_float_str(c: &mut Criterion) {
println!(
"recognize_float_str result: {:?}",
recognize_float::<_, (_, ErrorKind)>("-1.234E-12;")
);
c.bench_function("recognize float str streaming", |b| {
b.iter(|| recognize_float::<_, (_, ErrorKind)>("-1.234E-12;"));
});
}
fn float_bytes(c: &mut Criterion) {
println!(
"float_bytes result: {:?}",
double::<_, (_, ErrorKind)>(&b"-1.234E-12;"[..])
);
c.bench_function("float bytes streaming", |b| {
b.iter(|| double::<_, (_, ErrorKind)>(&b"-1.234E-12"[..]));
});
}
fn float_str(c: &mut Criterion) {
println!(
"float_str result: {:?}",
double::<_, (_, ErrorKind)>("-1.234E-12;")
);
c.bench_function("float str streaming", |b| {
b.iter(|| double::<_, (_, ErrorKind)>("-1.234E-12;"));
});
}
use nom::Err;
use nom::ParseTo;
fn std_float(input: &[u8]) -> IResult<&[u8], f64, (&[u8], ErrorKind)> {
match recognize_float(input) {
Err(e) => Err(e),
Ok((i, s)) => match s.parse_to() {
Some(n) => Ok((i, n)),
None => Err(Err::Error((i, ErrorKind::Float))),
},
}
}
fn std_float_bytes(c: &mut Criterion) {
println!(
"std_float_bytes result: {:?}",
std_float(&b"-1.234E-12;"[..])
);
c.bench_function("std_float bytes streaming", |b| {
b.iter(|| std_float(&b"-1.234E-12;"[..]));
});
}
criterion_group!(
benches,
json_bench,
recognize_float_bytes,
recognize_float_str,
float_bytes,
std_float_bytes,
float_str
);
criterion_main!(benches);
================================================
FILE: benchmarks/benches/number.rs
================================================
#[global_allocator]
static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
use codspeed_criterion_compat::*;
use nom::number::complete;
fn parser(i: &[u8]) -> nom::IResult<&[u8], u64> {
complete::be_u64(i)
}
fn number(c: &mut Criterion) {
let data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
parser(&data[..]).expect("should parse correctly");
c.bench_function("number", move |b| {
b.iter(|| parser(&data[..]).unwrap());
});
}
criterion_group!(benches, number);
criterion_main!(benches);
================================================
FILE: benchmarks/canada.json
================================================
{ "type": "FeatureCollection",
"features": [
{
"type": "Feature",
"properties": { "name": "Canada" },
"geometry": {"type":"Polygon","coordinates":[[[-65.613616999999977,43.420273000000009],[-65.619720000000029,43.418052999999986],[-65.625,43.421379000000059],[-65.636123999999882,43.449714999999969],[-65.633056999999951,43.474709000000132],[-65.611389000000031,43.513054000000068],[-65.605835000000013,43.516105999999979],[-65.598343,43.515830999999935],[-65.566101000000003,43.508331000000055],[-65.561935000000005,43.504439999999988],[-65.55999799999995,43.499718000000087],[-65.573333999999988,43.476379000000065],[-65.593612999999948,43.444153000000028],[-65.613616999999977,43.420273000000009]],[[-59.816947999999911,43.928328999999962],[-59.841667000000029,43.918602000000021],[-59.866393999999957,43.909987999999998],[-59.879722999999956,43.906654000000003],[-59.895835999999974,43.904160000000047],[-59.919448999999929,43.901099999999985],[-59.953330999999991,43.898604999999975],[-60.013617999999951,43.903320000000008],[-60.028609999999958,43.905548000000124],[-60.078338999999914,43.917496000000028],[-60.103888999999981,43.926659000000029],[-60.121666000000005,43.934990000000084],[-60.129997000000003,43.941933000000063],[-60.124167999999997,43.945267000000058],[-60.095000999999968,43.939430000000129],[-60.017776000000026,43.925827000000083],[-59.975554999999986,43.921936000000017],[-59.966942000000017,43.921936000000017],[-59.915000999999961,43.925552000000096],[-59.861945999999989,43.934433000000013],[-59.841385000000002,43.938880999999981],[-59.80972300000002,43.950828999999999],[-59.793334999999956,43.959435000000099],[-59.777221999999938,43.968048000000067],[-59.755279999999971,43.979431000000091],[-59.724716000000001,43.991104000000121],[-59.727775999999949,43.986382000000049],[-59.736389000000031,43.979156000000103],[-59.753615999999965,43.964995999999985],[-59.762504999999919,43.957771000000093],[-59.782501000000025,43.944434999999999],[-59.793059999999969,43.93832400000008],[-59.816947999999911,43.928328999999962]],[[-66.282775999999956,44.289719000000105],[-66.314437999999996,44.250548999999978],[-66.322234999999978,44.252777000000094],[-66.324448000000018,44.25750000000005],[-66.323897999999986,44.263329000000113],[-66.310271999999998,44.289993000000038],[-66.303054999999915,44.300545000000056],[-66.294723999999917,44.310271999999998],[-66.228333000000021,44.385826000000009],[-66.21945199999999,44.394713999999965],[-66.214447000000007,44.397774000000027],[-66.206389999999942,44.395271000000037],[-66.204726999999934,44.384995000000004],[-66.205275999999969,44.379433000000063],[-66.208053999999947,44.372765000000072],[-66.214721999999938,44.36360900000011],[-66.249725000000012,44.327217000000132],[-66.282775999999956,44.289719000000105]],[[-66.886123999999995,44.614440999999999],[-66.900283999999999,44.61332699999997],[-66.904174999999952,44.618049999999982],[-66.904449,44.622489999999971],[-66.884734999999978,44.68332700000002],[-66.858611999999937,44.743050000000039],[-66.837783999999942,44.770827999999995],[-66.833327999999938,44.774994000000049],[-66.803329000000019,44.798881999999992],[-66.798049999999932,44.802490000000091],[-66.786666999999852,44.808044000000109],[-66.779723999999931,44.809158000000082],[-66.772507000000019,44.809158000000082],[-66.767226999999934,44.805549999999982],[-66.764724999999999,44.801102000000014],[-66.757781999999963,44.792496000000085],[-66.734726000000023,44.729156000000103],[-66.736938000000009,44.717209000000139],[-66.740279999999927,44.70777099999998],[-66.761123999999995,44.676102000000128],[-66.765015000000005,44.671378999999945],[-66.875274999999931,44.619438000000059],[-66.886123999999995,44.614440999999999]],[[-61.199996999999996,45.558327000000077],[-61.204720000000009,45.555267000000072],[-61.212775999999963,45.556656000000032],[-61.219993999999986,45.559990000000028],[-61.224167000000023,45.564156000000139],[-61.222220999999934,45.569443000000035],[-61.21416499999998,45.568886000000134],[-61.208610999999962,45.56721500000009],[-61.202498999999989,45.563324000000023],[-61.199996999999996,45.558327000000077]],[[-60.993889000000024,45.45777099999998],[-61.00028199999997,45.455826000000002],[-61.007781999999963,45.457214000000079],[-61.019446999999957,45.463882000000069],[-61.101943999999946,45.523048000000017],[-61.105835000000013,45.526939000000084],[-61.108337000000006,45.540833000000021],[-61.104445999999939,45.546387000000038],[-61.098609999999951,45.549164000000076],[-61.023612999999955,45.574997000000053],[-61.017220000000009,45.575272000000041],[-60.936942999999985,45.576659999999947],[-60.908051,45.576103000000046],[-60.900275999999906,45.575554000000125],[-60.879996999999946,45.560547000000099],[-60.878608999999869,45.555824000000143],[-60.883888000000013,45.550544999999943],[-60.889167999999984,45.548332000000016],[-60.910277999999948,45.546104000000071],[-60.936110999999983,45.539161999999976],[-60.947495000000004,45.533607000000075],[-60.952498999999932,45.529990999999995],[-60.962501999999915,45.519989000000066],[-60.96305799999999,45.514998999999989],[-60.961669999999913,45.510277000000087],[-60.958611000000019,45.505829000000119],[-60.950553999999954,45.497771999999998],[-60.993889000000024,45.45777099999998]],[[-63.246391000000017,46.435547000000042],[-63.25389100000001,46.435265000000129],[-63.26167299999986,46.436378000000047],[-63.269446999999957,46.439713000000097],[-63.285004000000015,46.450829000000056],[-63.27055399999989,46.450271999999984],[-63.245834000000002,46.442764000000125],[-63.240836999999999,46.438599000000124],[-63.246391000000017,46.435547000000042]],[[-71.111114999999984,46.850548000000003],[-71.118606999999997,46.850273000000016],[-71.127486999999917,46.851662000000033],[-71.130279999999914,46.856102000000021],[-71.128326000000015,46.862213000000111],[-71.121383999999978,46.874161000000129],[-71.098891999999978,46.898048000000017],[-71.078339000000028,46.913605000000075],[-70.936935000000005,46.992493000000024],[-70.896666999999866,47.013329000000056],[-70.87222300000002,47.024162000000047],[-70.860001000000011,47.02777100000003],[-70.845276000000013,47.029160000000047],[-70.836394999999982,47.02777100000003],[-70.818893000000003,47.02276599999999],[-70.81361400000003,47.019440000000145],[-70.809158000000025,47.01527400000009],[-70.807495000000017,47.00999500000006],[-70.809432999999956,47.004439999999988],[-70.814437999999996,46.998329000000126],[-70.877212999999983,46.931107000000111],[-70.887512000000015,46.923607000000004],[-70.904174999999952,46.913605000000075],[-71.009170999999924,46.871101000000067],[-71.033324999999934,46.862494999999967],[-71.040832999999964,46.860549999999989],[-71.082229999999925,46.853325000000098],[-71.111114999999984,46.850548000000003]],[[-60.445273999999984,46.861664000000133],[-60.436942999999985,46.861107000000061],[-60.352782999999988,46.861664000000133],[-60.345832999999857,46.862494999999967],[-60.334441999999967,46.868881000000101],[-60.326110999999969,46.868323999999973],[-60.320838999999978,46.864441000000056],[-60.309440999999936,46.851105000000132],[-60.302223000000026,46.837493999999936],[-60.301392000000021,46.831940000000145],[-60.304442999999935,46.815269000000114],[-60.322776999999917,46.736382000000049],[-60.327224999999885,46.724991000000045],[-60.478881999999942,46.389992000000063],[-60.535277999999948,46.321663000000058],[-60.589438999999857,46.25499700000006],[-60.609169000000009,46.201934999999935],[-60.590331999999933,46.207821000000081],[-60.587001999999984,46.209488000000135],[-60.57150299999995,46.228653000000122],[-60.553329000000019,46.248878000000047],[-60.551391999999964,46.25499700000006],[-60.543335000000013,46.266663000000051],[-60.528053,46.278602999999919],[-60.479720999999984,46.311104000000057],[-60.46805599999999,46.316665999999998],[-60.44388600000002,46.326942000000088],[-60.430557000000022,46.33138299999996],[-60.424171000000001,46.331665000000044],[-60.416388999999867,46.328049000000021],[-60.412216000000001,46.31888600000002],[-60.417777999999942,46.285827999999981],[-60.419997999999964,46.279991000000052],[-60.42472099999992,46.27526899999998],[-60.438048999999921,46.270828000000051],[-60.454719999999952,46.262215000000083],[-60.470550999999944,46.251105999999993],[-60.53583100000003,46.192436000000043],[-60.59027900000001,46.138603000000103],[-60.600280999999939,46.130271999999991],[-60.61611199999993,46.120827000000133],[-60.645836000000031,46.106102000000021],[-60.687774999999874,46.088326000000052],[-60.701110999999912,46.08526599999999],[-60.788895000000025,46.066666000000055],[-60.86333499999995,46.052490000000034],[-60.986114999999927,45.982491000000095],[-61.023887999999943,45.969437000000028],[-61.080283999999949,45.951660000000004],[-61.087776000000019,45.95138500000013],[-61.095832999999971,45.952217000000076],[-61.105003000000011,45.954712000000086],[-61.113059999999905,45.955268999999987],[-61.117774999999938,45.950828999999999],[-61.126944999999978,45.928329000000133],[-61.125556999999958,45.923607000000061],[-61.118332000000009,45.923049999999932],[-61.056999000000019,45.931216999999947],[-61.052834000000018,45.931881000000033],[-61.017497999999989,45.940712000000076],[-61.014835000000005,45.943382000000042],[-60.989165999999955,45.95638300000013],[-60.987777999999935,45.962494000000049],[-60.984168999999952,45.967490999999939],[-60.957221999999945,45.984992999999974],[-60.940551999999911,45.994438000000059],[-60.892776000000026,46.01527400000009],[-60.853057999999976,46.03138000000007],[-60.770835999999917,46.057495000000074],[-60.757506999999919,46.060546999999985],[-60.743056999999965,46.061661000000015],[-60.735557999999912,46.058044000000052],[-60.734169000000009,46.05332199999998],[-60.734169000000009,46.047493000000145],[-60.807502999999997,45.931107000000111],[-60.870276999999987,45.910820000000058],[-60.898055999999997,45.906654000000117],[-60.956947000000014,45.903046000000018],[-61.042888999999946,45.891327000000103],[-61.047053999999946,45.890659000000085],[-61.050555999999972,45.888991999999973],[-61.053390999999976,45.886162000000127],[-61.096663999999976,45.860275000000001],[-61.097777999999948,45.854713000000061],[-61.094718999999998,45.850273000000016],[-61.087776000000019,45.847487999999998],[-61.079726999999991,45.84693900000002],[-61.073059000000001,45.84804500000007],[-61.060829000000012,45.852776000000006],[-61.049445999999989,45.858330000000024],[-61.026107999999965,45.86971299999999],[-60.989997999999957,45.881934999999999],[-60.96805599999999,45.883331000000055],[-60.960281000000009,45.880272000000048],[-60.919448999999986,45.857498000000078],[-60.915833000000021,45.852776000000006],[-60.917777999999942,45.847487999999998],[-60.935271999999941,45.825271999999984],[-60.940551999999911,45.821663000000001],[-60.947495000000004,45.820549000000028],[-61.019446999999957,45.809989999999971],[-61.067504999999983,45.791663999999969],[-61.079169999999976,45.786110000000008],[-61.118057000000022,45.763611000000026],[-61.12777699999998,45.755271999999991],[-61.147223999999994,45.704993999999999],[-61.149170000000026,45.699715000000026],[-61.142501999999922,45.696381000000031],[-61.077498999999932,45.688880999999981],[-61.070838999999978,45.689987000000031],[-61.041945999999996,45.704162999999994],[-61.012778999999966,45.718880000000013],[-60.996391000000017,45.727767999999969],[-60.972771000000023,45.738045],[-60.954719999999952,45.745543999999938],[-60.935829000000012,45.751389000000074],[-60.92222599999991,45.75360900000004],[-60.914443999999946,45.75360900000004],[-60.890556000000004,45.751663000000008],[-60.881942999999922,45.750000000000057],[-60.864165999999898,45.744438000000116],[-60.844161999999983,45.735268000000076],[-60.816665999999998,45.722488000000112],[-60.809998000000007,45.719154000000117],[-60.800835000000006,45.71166199999999],[-60.729438999999957,45.778603000000032],[-60.719718999999998,45.788329999999974],[-60.516944999999964,45.920830000000137],[-60.491942999999878,45.929436000000067],[-60.466942000000017,45.938041999999996],[-60.409163999999976,45.979987999999935],[-60.404166999999973,45.984436000000073],[-60.395835999999974,45.99610100000001],[-60.40166499999998,45.994713000000104],[-60.555000000000007,45.946938000000102],[-60.611671000000001,45.924995000000138],[-60.629722999999899,45.917496000000142],[-60.639998999999989,45.91027100000008],[-60.644721999999945,45.905548000000124],[-60.655272999999966,45.898330999999985],[-60.661110000000008,45.895270999999923],[-60.673331999999903,45.890549000000021],[-60.686110999999926,45.886940000000038],[-60.69388600000002,45.886107999999922],[-60.708892999999875,45.887215000000026],[-60.723327999999981,45.893326000000116],[-60.788337999999953,45.929436000000067],[-60.789725999999973,45.934433000000126],[-60.788895000000025,45.939986999999974],[-60.785278000000005,45.946381000000031],[-60.78055599999999,45.950828999999999],[-60.691382999999973,46.001937999999939],[-60.679168999999945,46.006660000000011],[-60.601395000000025,46.039719000000105],[-60.541114999999991,46.065544000000102],[-60.523612999999955,46.075554000000011],[-60.490836999999942,46.094437000000084],[-60.30999799999995,46.206939999999975],[-60.30499999999995,46.210548000000074],[-60.299994999999967,46.214996000000042],[-60.295279999999934,46.226936000000137],[-60.295279999999934,46.232208000000071],[-60.304169000000002,46.233878999999945],[-60.365554999999972,46.224990999999989],[-60.372771999999998,46.223320000000115],[-60.396111000000019,46.213051000000064],[-60.401938999999913,46.21027399999997],[-60.418335000000013,46.199996999999996],[-60.428054999999915,46.192490000000078],[-60.442497000000003,46.17943600000001],[-60.463332999999921,46.163879000000122],[-60.479163999999912,46.152771000000143],[-60.528053,46.121658000000139],[-60.605835000000013,46.074715000000083],[-60.629997000000003,46.065269000000114],[-60.644164999999987,46.063049000000092],[-60.65193899999997,46.063880999999981],[-60.656104999999968,46.067772000000048],[-60.656386999999938,46.073051000000021],[-60.652495999999985,46.079436999999984],[-60.638335999999867,46.093048000000124],[-60.456107999999972,46.241379000000052],[-60.404998999999975,46.279991000000052],[-60.399726999999984,46.283882000000119],[-60.388892999999996,46.291106999999954],[-60.359725999999966,46.304993000000138],[-60.347778000000005,46.310546999999985],[-60.285278000000005,46.321381000000031],[-60.205558999999994,46.240273000000002],[-60.138054000000011,46.246658000000025],[-60.131942999999922,46.248604000000114],[-60.124167999999997,46.248604000000114],[-60.099997999999971,46.246384000000091],[-60.091666999999916,46.244713000000047],[-59.950553999999897,46.201385000000073],[-59.873054999999965,46.17582699999997],[-59.808608999999876,46.111938000000066],[-59.80972300000002,46.106384000000048],[-59.819449999999961,46.097214000000008],[-59.834166999999979,46.084717000000012],[-59.853888999999924,46.00249500000001],[-59.840553,45.938324000000023],[-59.958610999999962,45.901657000000057],[-60.130279999999971,45.867767000000129],[-60.136115999999959,45.864997999999957],[-60.155272999999966,45.846656999999993],[-60.159438999999963,45.841102999999976],[-60.160552999999936,45.835548000000074],[-60.174445999999989,45.76388500000013],[-60.229163999999969,45.705551000000128],[-60.233886999999925,45.701102999999932],[-60.245834000000002,45.69499200000007],[-60.379723000000013,45.644997000000046],[-60.392226999999991,45.641105999999979],[-60.411666999999966,45.636940000000095],[-60.49888599999997,45.620269999999948],[-60.513061999999934,45.618880999999988],[-60.55750299999994,45.618049999999982],[-60.765556000000004,45.594994000000099],[-60.960830999999928,45.599433999999917],[-61.101669000000015,45.564437999999996],[-61.14833799999991,45.555267000000072],[-61.168334999999956,45.551384000000098],[-61.196917999999982,45.583740000000091],[-61.218696999999963,45.580788000000098],[-61.237521999999956,45.581528000000048],[-61.273055999999997,45.561935000000005],[-61.336945000000014,45.573326000000009],[-61.37557599999991,45.622131000000138],[-61.430556999999965,45.665543000000071],[-61.454719999999952,45.705551000000128],[-61.457503999999972,45.71527100000003],[-61.478049999999996,45.803879000000109],[-61.494720000000029,45.846381999999949],[-61.527495999999985,45.98943300000002],[-61.455558999999994,46.137497000000053],[-61.447776999999974,46.149436999999978],[-61.438888999999961,46.159430999999984],[-61.412772999999959,46.178329000000076],[-61.390839000000028,46.191376000000105],[-61.37388599999997,46.200829000000113],[-61.343329999999924,46.212493999999992],[-61.305557000000022,46.224990999999989],[-61.293892000000028,46.230819999999994],[-61.283332999999971,46.238884000000041],[-61.09722099999999,46.44609800000012],[-61.089438999999913,46.458046000000138],[-61.035278000000005,46.555549999999982],[-61.033057999999926,46.561661000000072],[-61.031113000000005,46.572769000000051],[-61.032501000000025,46.577492000000063],[-60.996947999999918,46.634720000000073],[-60.892226999999991,46.77388000000002],[-60.873610999999869,46.793052999999929],[-60.86361699999992,46.801384000000041],[-60.84027900000001,46.813605999999993],[-60.833884999999896,46.815543999999932],[-60.805557000000022,46.820273999999984],[-60.793892000000028,46.825271999999984],[-60.724716000000001,46.874992000000134],[-60.714721999999995,46.88249200000007],[-60.704444999999907,46.891380000000026],[-60.695273999999927,46.901657],[-60.686660999999958,46.912491000000045],[-60.678336999999942,46.930824000000143],[-60.670554999999979,46.953606000000036],[-60.664444000000003,46.966103000000032],[-60.65694400000001,46.978600000000029],[-60.640282000000013,47],[-60.609169000000009,47.024437000000091],[-60.597777999999892,47.031105000000025],[-60.591942000000017,47.033333000000027],[-60.583327999999938,47.031661999999926],[-60.460830999999871,46.999161000000015],[-60.427498000000014,46.965827999999988],[-60.493889000000024,46.902214000000072],[-60.498055000000022,46.896660000000111],[-60.452224999999942,46.864441000000056],[-60.445273999999984,46.861664000000133]],[[-64.039718999999991,46.743324000000086],[-64.031677000000002,46.742767000000015],[-64.016402999999912,46.743607000000054],[-64.009170999999981,46.744156000000032],[-64.005004999999983,46.749718000000144],[-63.999999999999943,46.75360900000004],[-63.991668999999945,46.753052000000139],[-63.979163999999912,46.746383999999978],[-63.974715999999944,46.742493000000081],[-63.832503999999972,46.617210000000057],[-63.831673000000023,46.611938000000123],[-63.865004999999883,46.537498000000085],[-63.868888999999967,46.531937000000084],[-63.840836000000024,46.464438999999913],[-63.828339000000028,46.458046000000138],[-63.780281000000002,46.44499200000007],[-63.742226000000016,46.439430000000129],[-63.733054999999979,46.438881000000038],[-63.709442000000024,46.43749200000002],[-63.703888000000006,46.440544000000102],[-63.698050999999964,46.456383000000073],[-63.698607999999979,46.461662000000047],[-63.700279000000023,46.466385000000002],[-63.722771000000023,46.48054500000012],[-63.738051999999982,46.491378999999995],[-63.739998000000014,46.496101000000067],[-63.723327999999924,46.543610000000058],[-63.716110000000015,46.553879000000109],[-63.709723999999994,46.556099000000131],[-63.676391999999964,46.564156000000082],[-63.662216000000001,46.566382999999973],[-63.647223999999881,46.56721500000009],[-63.618889000000024,46.561104],[-63.497779999999977,46.527771000000143],[-63.315001999999936,46.488602000000071],[-63.271979999999928,46.426926000000094],[-63.240661999999986,46.420456000000001],[-63.216392999999982,46.412209000000132],[-62.942771999999877,46.426941000000113],[-62.862777999999935,46.434715000000097],[-62.698607999999979,46.452492000000007],[-62.692497000000003,46.456100000000106],[-62.686385999999914,46.457497000000046],[-62.665833000000021,46.461104999999975],[-62.595001000000025,46.470825000000048],[-62.477218999999991,46.477768000000026],[-62.455558999999994,46.478600000000142],[-62.182502999999997,46.485824999999977],[-62.166388999999981,46.486107000000061],[-62.133330999999941,46.482764999999915],[-62.058051999999975,46.472762999999986],[-62.014724999999942,46.46527100000003],[-61.979720999999984,46.45915999999994],[-61.970551,46.456940000000145],[-61.965003999999965,46.453323000000012],[-61.968886999999995,46.447768999999994],[-61.973609999999951,46.443047000000092],[-62.013061999999991,46.421104000000128],[-62.101112000000001,46.379715000000033],[-62.173331999999959,46.349433999999974],[-62.215552999999943,46.343605000000139],[-62.279723999999931,46.338043000000027],[-62.309166000000005,46.349998000000085],[-62.326392999999996,46.354996000000085],[-62.342773000000022,46.356102000000135],[-62.357779999999934,46.35582700000009],[-62.355834999999956,46.35083000000003],[-62.348052999999993,46.332214000000022],[-62.334723999999994,46.311935000000062],[-62.361945999999932,46.276657000000057],[-62.419448999999986,46.219986000000119],[-62.424720999999977,46.215546000000074],[-62.453888000000006,46.21443899999997],[-62.507506999999919,46.214157000000114],[-62.603888999999924,46.182495000000131],[-62.603888999999924,46.177215999999987],[-62.54222900000002,46.122490000000028],[-62.507506999999919,46.118881000000044],[-62.5,46.119156000000089],[-62.478333000000021,46.120827000000133],[-62.477218999999991,46.126380999999924],[-62.478881999999999,46.131935000000112],[-62.481667000000016,46.13638300000008],[-62.489998000000014,46.138328999999999],[-62.497222999999963,46.138046000000031],[-62.506110999999976,46.139717000000076],[-62.513892999999996,46.142220000000066],[-62.509726999999998,46.148605000000032],[-62.504448000000025,46.150825999999995],[-62.489166000000012,46.151382000000126],[-62.473052999999993,46.150269000000094],[-62.468886999999995,46.146102999999982],[-62.449164999999937,46.100548000000003],[-62.447494999999947,46.095543000000134],[-62.446945000000028,46.090546000000018],[-62.454720000000009,46.018883000000073],[-62.459166999999979,46.006386000000077],[-62.473609999999951,45.994713000000104],[-62.496947999999975,45.983879000000002],[-62.510001999999929,45.979156000000046],[-62.541671999999949,45.970543000000077],[-62.548614999999927,45.969437000000028],[-62.591667000000029,45.964996000000099],[-62.613891999999964,45.962769000000037],[-62.650276000000019,45.960274000000027],[-62.761115999999959,45.954162999999937],[-62.837776000000019,45.967490999999939],[-62.856667000000016,45.977486000000056],[-62.882773999999984,45.995544000000109],[-62.930283000000031,46.037215999999944],[-62.970832999999971,46.07416500000005],[-62.922500999999954,46.092491000000052],[-62.917220999999984,46.096382000000119],[-62.875274999999931,46.134995000000004],[-62.871940999999936,46.143607999999972],[-62.885276999999974,46.155823000000055],[-62.890839000000028,46.159430999999984],[-63.025276000000019,46.189156000000082],[-63.103614999999991,46.201934999999935],[-63.112777999999992,46.204163000000108],[-63.119445999999868,46.207214000000135],[-63.12222300000002,46.211662000000103],[-63.120276999999987,46.217766000000097],[-63.115836999999942,46.222487999999998],[-63.038895000000025,46.280273000000079],[-63.02416999999997,46.290275999999949],[-63.017776000000026,46.292496000000142],[-63.010284000000013,46.292770000000075],[-63.002228000000002,46.289992999999981],[-62.99610899999999,46.292220999999984],[-62.979438999999957,46.301658999999972],[-62.969161999999983,46.309432999999956],[-62.964721999999881,46.314156000000139],[-62.962775999999963,46.319992000000013],[-62.969443999999953,46.31888600000002],[-63.035277999999892,46.301658999999972],[-63.041388999999981,46.299721000000034],[-63.052779999999927,46.293884000000048],[-63.058608999999933,46.290833000000021],[-63.090836000000024,46.26915699999995],[-63.165001000000018,46.210548000000074],[-63.143332999999984,46.201660000000118],[-63.139167999999984,46.197769000000051],[-63.138610999999912,46.192490000000078],[-63.140556000000004,46.186378000000104],[-63.22444200000001,46.139717000000076],[-63.23860899999994,46.138046000000031],[-63.253615999999965,46.137497000000053],[-63.26167299999986,46.138046000000031],[-63.289169000000015,46.14388299999996],[-63.409163999999919,46.176940999999999],[-63.519722000000002,46.206099999999935],[-63.591942000000017,46.211937000000091],[-63.642775999999913,46.224990999999989],[-63.649726999999928,46.228043000000071],[-63.699722000000008,46.259437999999989],[-63.700553999999954,46.269989000000066],[-63.702224999999999,46.27526899999998],[-63.70666499999993,46.278602999999919],[-63.741942999999935,46.304436000000067],[-63.754447999999968,46.310822000000144],[-63.811110999999926,46.32749200000012],[-63.772223999999937,46.360825000000091],[-63.736945999999932,46.353882000000112],[-63.729163999999969,46.352776000000063],[-63.714721999999995,46.354164000000026],[-63.739166000000012,46.391106000000036],[-63.745002999999997,46.394714000000135],[-63.754447999999968,46.396385000000009],[-63.761672999999917,46.396659999999997],[-63.841109999999958,46.39888000000002],[-63.963615000000004,46.401100000000042],[-63.981941000000006,46.39388300000013],[-63.989165999999898,46.393608000000086],[-64.121933000000013,46.404709000000025],[-64.129989999999964,46.407211000000132],[-64.133057000000008,46.4116590000001],[-64.135009999999909,46.416382000000056],[-64.133057000000008,46.43332700000002],[-64.115828999999962,46.523048000000017],[-64.11332699999997,46.53472099999999],[-64.110000999999954,46.541107000000125],[-64.105559999999969,46.54583000000008],[-64.100280999999882,46.549720999999977],[-64.094161999999926,46.551659000000086],[-64.105559999999969,46.618050000000096],[-64.273894999999982,46.62332200000003],[-64.387511999999958,46.62082700000002],[-64.391952999999944,46.624709999999936],[-64.413895000000025,46.665825000000098],[-64.415558000000033,46.670546999999999],[-64.416655999999932,46.68110699999994],[-64.414718999999991,46.697769000000108],[-64.410277999999948,46.711105000000089],[-64.400283999999942,46.727486000000113],[-64.382492000000013,46.746658000000082],[-64.346953999999982,46.773605000000032],[-64.323897999999929,46.786384999999996],[-64.296386999999982,46.801659000000029],[-64.286117999999931,46.80943300000007],[-64.27305599999994,46.823607999999979],[-64.249724999999955,46.868050000000039],[-64.247771999999941,46.874161000000129],[-64.247222999999906,46.879714999999976],[-64.243880999999988,46.886108000000092],[-64.236389000000031,46.897491000000116],[-64.226943999999946,46.906097000000045],[-64.182770000000005,46.945541000000105],[-64.168610000000001,46.956657000000064],[-64.020844000000011,47.038605000000132],[-63.99500299999994,46.984161000000086],[-63.969993999999986,46.901657],[-63.967498999999862,46.891662999999994],[-64.041381999999999,46.82249500000006],[-64.066100999999946,46.804436000000123],[-64.076401000000033,46.798881999999992],[-64.091674999999952,46.778603000000032],[-64.077498999999932,46.756386000000134],[-64.074448000000018,46.752220000000023],[-64.067504999999926,46.749161000000072],[-64.039718999999991,46.743324000000086]],[[-55.876105999999993,47.260551000000021],[-55.968329999999867,47.257773999999927],[-55.946388000000013,47.273323000000062],[-55.934440999999936,47.279434000000094],[-55.895003999999972,47.290833000000021],[-55.888053999999954,47.292496000000142],[-55.881110999999976,47.293326999999977],[-55.872771999999998,47.292221000000097],[-55.865836999999885,47.287773000000129],[-55.855003000000011,47.269714000000022],[-55.876105999999993,47.260551000000021]],[[-61.380554000000018,47.620270000000119],[-61.493057000000022,47.552490000000091],[-61.498610999999926,47.550270000000069],[-61.535560999999973,47.54583000000008],[-61.54222900000002,47.545547000000113],[-61.547782999999868,47.549164000000076],[-61.549445999999989,47.553879000000109],[-61.545279999999991,47.55943300000007],[-61.520279000000016,47.569160000000011],[-61.513892999999939,47.572495000000117],[-61.477492999999924,47.60054800000006],[-61.473610000000008,47.6055530000001],[-61.471382000000006,47.611382000000106],[-61.470551,47.616936000000123],[-61.479163999999969,47.618599000000017],[-61.534447,47.618881000000101],[-61.541945999999996,47.617210000000057],[-61.559440999999993,47.609161000000029],[-61.653610000000015,47.549995000000081],[-61.855559999999969,47.417213000000061],[-61.849723999999981,47.413605000000132],[-61.841667000000029,47.410820000000115],[-61.833611000000019,47.409987999999998],[-61.789169000000015,47.425827000000083],[-61.777221999999995,47.431664000000069],[-61.766662999999937,47.439156000000025],[-61.714447000000007,47.489989999999977],[-61.691382999999973,47.515548999999965],[-61.701392999999939,47.491936000000067],[-61.740836999999942,47.44499200000007],[-61.843329999999924,47.388603000000046],[-61.90589099999994,47.354935000000012],[-61.925277999999992,47.343605000000139],[-61.93332700000002,47.333327999999938],[-61.962776000000019,47.281662000000097],[-61.965003999999965,47.275551000000007],[-61.964721999999995,47.270271000000093],[-61.961945000000014,47.266106000000093],[-61.957503999999972,47.261940000000038],[-61.938605999999993,47.257217000000026],[-61.827782000000013,47.234161000000029],[-61.819450000000018,47.233330000000024],[-61.807776999999987,47.239159000000029],[-61.799445999999989,47.250274999999931],[-61.794723999999917,47.254714999999976],[-61.783057999999869,47.260551000000021],[-61.782775999999956,47.255272000000048],[-61.789725999999916,47.242493000000024],[-61.793892000000028,47.236938000000123],[-61.799445999999989,47.232764999999972],[-61.810279999999977,47.226654000000053],[-61.816948000000025,47.224709000000075],[-61.84444400000001,47.219436999999971],[-61.859443999999883,47.218047999999953],[-61.955276000000026,47.211662000000047],[-61.979995999999971,47.213608000000136],[-61.996390999999903,47.214996000000042],[-62.004722999999956,47.217766000000097],[-62.010001999999872,47.22137500000008],[-62.013061999999991,47.225821999999994],[-62.014724999999942,47.23054500000012],[-62.015006999999912,47.235825000000034],[-62.013061999999991,47.241661000000079],[-61.948607999999979,47.379432999999949],[-61.941665999999941,47.392219999999952],[-61.937499999999943,47.39777400000014],[-61.928054999999972,47.407211000000075],[-61.922225999999966,47.409987999999998],[-61.908889999999928,47.413879000000065],[-61.736114999999984,47.507216999999969],[-61.705832999999984,47.532494000000099],[-61.684440999999936,47.547492999999974],[-61.662216000000001,47.561661000000072],[-61.616942999999992,47.588042999999914],[-61.571114000000023,47.613608999999997],[-61.553611999999987,47.623046999999985],[-61.53583500000002,47.631659999999954],[-61.529167000000029,47.633606000000043],[-61.521110999999962,47.634437999999989],[-61.425277999999992,47.642769000000044],[-61.407775999999956,47.641105999999922],[-61.388892999999996,47.637771999999984],[-61.381942999999922,47.634437999999989],[-61.377776999999924,47.631103999999993],[-61.376105999999993,47.626380999999981],[-61.380554000000018,47.620270000000119]],[[-54.261391000000003,47.39027400000009],[-54.268889999999999,47.389717000000019],[-54.293059999999969,47.391663000000051],[-54.341385000000002,47.398048000000074],[-54.358054999999979,47.403046000000074],[-54.364448999999979,47.406654000000003],[-54.365554999999915,47.411659000000043],[-54.359726000000023,47.416664000000083],[-54.326392999999996,47.436653000000035],[-54.295279999999991,47.44999700000011],[-54.278053,47.460823000000062],[-54.267220000000009,47.469437000000084],[-54.262222000000008,47.474709000000018],[-54.257781999999963,47.480820000000108],[-54.230552999999986,47.523605000000032],[-54.229996000000028,47.550270000000069],[-54.204719999999952,47.593605000000082],[-54.13527699999986,47.668053000000043],[-54.128882999999973,47.670546999999999],[-54.122771999999998,47.66693900000007],[-54.121940999999993,47.661934000000031],[-54.122222999999963,47.656937000000084],[-54.124999999999943,47.640831000000105],[-54.160827999999981,47.534996000000035],[-54.238892000000021,47.40387700000008],[-54.243331999999953,47.399437000000091],[-54.255004999999983,47.392769000000101],[-54.261391000000003,47.39027400000009]],[[-54.077498999999989,47.479431000000091],[-54.08306099999993,47.474991000000102],[-54.093055999999933,47.483046999999999],[-54.096663999999976,47.487213000000054],[-54.101112000000001,47.496384000000035],[-54.101944000000003,47.501389000000074],[-54.099723999999924,47.558883999999978],[-54.09833500000002,47.589714000000015],[-54.097220999999934,47.605270000000132],[-54.09332999999998,47.631659999999954],[-54.083610999999962,47.679717999999923],[-54.078612999999962,47.684990000000028],[-54.071388000000013,47.685546999999929],[-54.067504999999983,47.681107000000111],[-54.060555000000022,47.651099999999985],[-54.078056000000004,47.563881000000038],[-54.05972300000002,47.532211000000132],[-54.058891000000017,47.527214000000072],[-54.077498999999989,47.479431000000091]],[[-55.901938999999857,47.602493000000038],[-55.923057999999912,47.599434000000088],[-55.947220000000016,47.601936000000137],[-56.013335999999981,47.611664000000019],[-56.097778000000005,47.627487000000031],[-56.105559999999855,47.630821000000026],[-56.109169000000009,47.63499500000006],[-56.113616999999977,47.644714000000022],[-56.112220999999977,47.649719000000118],[-56.106666999999959,47.654709000000139],[-56.100280999999939,47.657211000000018],[-56.005835999999988,47.680274999999995],[-55.941108999999983,47.689156000000139],[-55.933883999999978,47.688324000000023],[-55.92861199999993,47.684432999999956],[-55.927498000000014,47.676658999999972],[-55.934440999999936,47.658882000000119],[-55.934440999999936,47.653877000000023],[-55.932502999999997,47.643883000000017],[-55.930000000000007,47.639435000000049],[-55.926392000000021,47.635268999999994],[-55.914161999999976,47.628326000000015],[-55.889442000000031,47.618881000000101],[-55.876388999999961,47.611664000000019],[-55.882499999999936,47.607773000000122],[-55.901938999999857,47.602493000000038]],[[-64.482773000000009,47.917770000000019],[-64.50167799999997,47.856384000000048],[-64.503615999999909,47.850273000000016],[-64.514724999999999,47.832497000000046],[-64.523055999999997,47.822220000000016],[-64.541106999999954,47.80332199999998],[-64.604995999999971,47.748329000000126],[-64.610549999999989,47.745270000000005],[-64.635833999999988,47.735825000000091],[-64.647507000000019,47.733879000000002],[-64.690551999999968,47.753052000000139],[-64.693328999999949,47.758049000000028],[-64.702788999999939,47.823607999999979],[-64.697768999999994,47.836104999999918],[-64.685546999999985,47.852219000000048],[-64.667496000000028,47.866936000000067],[-64.662215999999944,47.870827000000133],[-64.624160999999958,47.884719999999959],[-64.617767000000015,47.886658000000125],[-64.609160999999972,47.886939999999981],[-64.584166999999923,47.884995000000004],[-64.508057000000008,47.903877000000023],[-64.482773000000009,47.917770000000019]],[[-64.567504999999926,47.899436999999978],[-64.574448000000018,47.89804799999996],[-64.583617999999888,47.899436999999978],[-64.589447000000007,47.902771000000143],[-64.593886999999995,47.90665400000006],[-64.594451999999933,47.911933999999974],[-64.593612999999891,47.918052999999986],[-64.531677000000002,48.016105999999979],[-64.52694699999995,48.02165999999994],[-64.522780999999952,48.025551000000007],[-64.516952999999944,48.028602999999976],[-64.509734999999921,48.029991000000052],[-64.50111400000003,48.027488999999946],[-64.495543999999938,48.023880000000133],[-64.490828999999906,48.019989000000066],[-64.48582499999992,48.013054000000011],[-64.482773000000009,48.008606000000043],[-64.469726999999978,47.969711000000132],[-64.469161999999869,47.96443899999997],[-64.470550999999944,47.953323000000069],[-64.47444200000001,47.947769000000051],[-64.496383999999978,47.933875999999998],[-64.513901000000033,47.924712999999997],[-64.567504999999926,47.899436999999978]],[[-53.712775999999963,48.14888000000002],[-53.689720000000023,48.147217000000126],[-53.682502999999997,48.147774000000027],[-53.667503000000011,48.150542999999971],[-53.647781000000009,48.155265999999926],[-53.615554999999915,48.167496000000028],[-53.583327999999995,48.18082400000003],[-53.571113999999909,48.186104000000114],[-53.564162999999951,48.190543999999932],[-53.553054999999972,48.199158000000011],[-53.539444000000003,48.202217000000132],[-53.53167000000002,48.202774000000034],[-53.516395999999986,48.201935000000105],[-53.509726999999941,48.198326000000066],[-53.509170999999867,48.193321000000026],[-53.510833999999988,48.150826000000109],[-53.512504999999919,48.145271000000037],[-53.530829999999924,48.097771000000023],[-53.536391999999978,48.093323000000055],[-53.549445999999989,48.088600000000099],[-53.56361400000003,48.084991000000116],[-53.598884999999996,48.079437000000098],[-53.634170999999924,48.075272000000098],[-53.823333999999932,48.092765999999983],[-53.83943899999997,48.094437000000084],[-53.856110000000001,48.098044999999956],[-53.871940999999936,48.104713000000118],[-53.876663000000008,48.108604000000014],[-53.93250299999994,48.172767999999962],[-53.935829000000012,48.182495000000131],[-53.932776999999987,48.198326000000066],[-53.929168999999945,48.209434999999985],[-53.922225999999966,48.212493999999936],[-53.906386999999938,48.21027400000014],[-53.898887999999943,48.206657000000007],[-53.860000999999954,48.174438000000123],[-53.855559999999969,48.169991000000095],[-53.712775999999963,48.14888000000002]],[[-123.47444200000001,48.709160000000054],[-123.48277300000001,48.708328000000108],[-123.48999000000003,48.709435000000042],[-123.51306199999993,48.716385000000116],[-123.52471899999989,48.722488000000055],[-123.54943800000001,48.746658000000082],[-123.551941,48.752220000000023],[-123.59277299999991,48.898331000000098],[-123.595551,48.909714000000122],[-123.59612299999998,48.928329000000076],[-123.59665699999994,48.946938000000046],[-123.59361299999995,48.947211999999979],[-123.58056599999992,48.935547000000042],[-123.57721699999996,48.929161000000136],[-123.53611799999999,48.914993000000095],[-123.53028899999998,48.911933999999974],[-123.45749699999993,48.863052000000039],[-123.43388400000003,48.844437000000084],[-123.37027,48.768326000000002],[-123.36888099999993,48.762771999999984],[-123.37165800000002,48.75750000000005],[-123.37638900000002,48.753608999999983],[-123.43195300000002,48.721099999999979],[-123.47444200000001,48.709160000000054]],[[-58.342223999999987,49.066101000000117],[-58.349166999999966,49.064437999999996],[-58.356109999999944,49.065826000000129],[-58.351943999999889,49.071938000000102],[-58.341385000000002,49.07638500000013],[-58.333611000000019,49.077773999999977],[-58.330558999999994,49.073326000000009],[-58.335830999999928,49.068885999999964],[-58.342223999999987,49.066101000000117]],[[-123.32277699999997,48.861107000000004],[-123.3705369999999,48.856384000000048],[-123.37888299999997,48.85694100000012],[-123.38474299999996,48.859993000000031],[-123.54055799999998,48.944992000000127],[-123.66251399999999,49.03527100000008],[-123.70388800000001,49.095268000000033],[-123.70527599999997,49.100273000000072],[-123.70249899999999,49.105552999999986],[-123.695831,49.108047000000113],[-123.68639400000001,49.106659000000036],[-123.68055700000002,49.103607000000068],[-123.674713,49.093048000000067],[-123.65943900000002,49.073608000000036],[-123.60444599999994,49.014717000000132],[-123.58640300000002,49.000549000000092],[-123.52166699999998,48.96027400000014],[-123.49916099999996,48.947211999999979],[-123.487503,48.94110100000006],[-123.45973200000003,48.930549999999982],[-123.43639399999995,48.924438000000009],[-123.42027299999995,48.920547000000113],[-123.38194299999992,48.910819999999944],[-123.32833900000003,48.895827999999938],[-123.32250999999991,48.892768999999987],[-123.31777999999997,48.88888500000013],[-123.31276700000001,48.872765000000072],[-123.3125,48.868050000000039],[-123.31639100000001,48.863327000000027],[-123.32277699999997,48.861107000000004]],[[-125.816101,49.125824000000136],[-125.82028200000002,49.124709999999993],[-125.86028299999998,49.134438000000046],[-125.906387,49.160820000000115],[-125.91027800000001,49.165543000000071],[-125.92582699999991,49.190826000000015],[-125.93360899999993,49.211104999999918],[-125.93306000000001,49.218048000000124],[-125.93055700000002,49.219986000000063],[-125.92610200000001,49.223320000000058],[-125.87888299999992,49.235824999999977],[-125.86749299999997,49.233330000000137],[-125.82917800000001,49.226379000000009],[-125.81806899999987,49.220543000000134],[-125.79915599999998,49.208328000000051],[-125.78888699999993,49.172768000000133],[-125.79583699999995,49.151932000000102],[-125.79833999999994,49.146385000000009],[-125.81249999999994,49.129158000000132],[-125.816101,49.125824000000136]],[[-126.13194299999992,49.393325999999945],[-126.126938,49.390274000000034],[-126.12470999999999,49.390274000000034],[-126.12053699999996,49.388602999999989],[-126.11054999999999,49.382210000000043],[-126.10665899999992,49.378601000000003],[-126.09612300000003,49.368599000000074],[-126.08640300000002,49.358604000000128],[-126.07277699999997,49.34304800000001],[-126.0497279999999,49.265548999999965],[-126.0511019999999,49.260550999999964],[-126.05583200000001,49.256104000000107],[-126.06471299999987,49.250832000000003],[-126.07112100000001,49.248329000000012],[-126.07972699999999,49.246658000000139],[-126.08917199999991,49.246101000000067],[-126.09638999999999,49.24721500000004],[-126.18666100000002,49.263328999999999],[-126.19167299999992,49.265548999999965],[-126.22332799999992,49.279716000000121],[-126.22944599999994,49.282493999999929],[-126.23916600000001,49.289718999999991],[-126.23473399999995,49.374161000000015],[-126.22917200000001,49.378601000000003],[-126.22138999999999,49.380547000000092],[-126.14138800000001,49.39415699999995],[-126.13194299999992,49.393325999999945]],[[-123.37943999999999,49.326941999999974],[-123.39222699999999,49.326103000000046],[-123.41027799999995,49.334159999999997],[-123.42194399999994,49.339714000000015],[-123.42666600000001,49.344154000000003],[-123.42804699999999,49.348877000000016],[-123.42027299999995,49.381660000000011],[-123.41332999999997,49.386107999999979],[-123.3600009999999,49.411658999999986],[-123.35472099999998,49.413322000000107],[-123.327789,49.416664000000083],[-123.31696299999999,49.417496000000142],[-123.31220999999999,49.414992999999981],[-123.30943300000001,49.41137700000013],[-123.31027199999994,49.40526600000004],[-123.31194299999993,49.401932000000045],[-123.327789,49.363052000000096],[-123.33112299999999,49.354996000000028],[-123.34472699999998,49.341934000000037],[-123.36833199999995,49.330275999999969],[-123.37943999999999,49.326941999999974]],[[-54.705276000000026,49.400543000000084],[-54.712776000000019,49.398330999999985],[-54.730277999999998,49.403046000000018],[-54.735557999999969,49.407211000000018],[-54.759726999999941,49.432495000000017],[-54.759170999999981,49.437766999999951],[-54.754723000000013,49.443878000000041],[-54.749442999999928,49.449158000000125],[-54.73833499999995,49.457771000000093],[-54.680556999999908,49.49193600000001],[-54.673057999999912,49.492493000000081],[-54.665001000000018,49.489159000000086],[-54.644164999999987,49.473320000000001],[-54.640281999999956,49.46915400000006],[-54.640838999999971,49.463881999999955],[-54.654716000000008,49.460823000000005],[-54.684440999999993,49.420546999999999],[-54.699164999999994,49.40387700000008],[-54.705276000000026,49.400543000000084]],[[-124.179169,49.441101000000117],[-124.18554699999999,49.439986999999974],[-124.31360599999999,49.456099999999992],[-124.32668299999995,49.460823000000005],[-124.36000099999995,49.474433999999974],[-124.36609599999997,49.477486000000056],[-124.37082699999996,49.481102000000135],[-124.37165799999997,49.483047000000113],[-124.38054699999998,49.506943000000035],[-124.38110399999994,49.511940000000095],[-124.37832599999996,49.515830999999991],[-124.37165799999997,49.518326000000002],[-124.361107,49.519157000000064],[-124.35500299999995,49.517494000000113],[-124.34889199999998,49.514442000000031],[-124.30471799999992,49.512214999999969],[-124.24471999999997,49.501389000000017],[-124.23750299999995,49.498329000000126],[-124.22138999999993,49.491379000000109],[-124.1875,49.474433999999974],[-124.18167099999999,49.471375000000023],[-124.17388900000003,49.45638299999996],[-124.17194399999994,49.446655000000135],[-124.17223399999989,49.444153000000085],[-124.179169,49.441101000000117]],[[-123.33277899999996,49.441101000000117],[-123.36028299999987,49.433051999999918],[-123.37499999999994,49.433327000000133],[-123.442207,49.438599000000067],[-123.448036,49.441658000000018],[-123.45944199999997,49.467209000000082],[-123.45973200000003,49.470543000000077],[-123.45305599999995,49.495544000000109],[-123.44526699999994,49.51527400000009],[-123.43666100000002,49.522217000000069],[-123.38082899999995,49.536110000000122],[-123.37000299999994,49.536110000000122],[-123.360817,49.534995999999978],[-123.3550029999999,49.531936999999971],[-123.33833300000003,49.50610400000005],[-123.33167999999995,49.500832000000116],[-123.32805599999995,49.496383999999978],[-123.32389799999993,49.488602000000014],[-123.319458,49.474708999999962],[-123.31777999999997,49.464157],[-123.319458,49.451934999999992],[-123.32224300000001,49.448043999999925],[-123.32695000000001,49.444153000000085],[-123.33277899999996,49.441101000000117]],[[-55.695548999999971,49.506943000000035],[-55.725829999999974,49.505554000000018],[-55.732497999999964,49.509163000000001],[-55.735001000000011,49.513610999999969],[-55.736114999999984,49.518599999999935],[-55.735832000000016,49.52388000000002],[-55.730277999999942,49.545547000000056],[-55.722771000000023,49.557770000000119],[-55.716110000000015,49.560271999999998],[-55.684998000000007,49.561104000000114],[-55.676948999999979,49.561104000000114],[-55.658332999999971,49.559158000000025],[-55.653052999999886,49.555267000000129],[-55.652221999999938,49.550270000000069],[-55.653885000000002,49.544716000000051],[-55.661384999999939,49.529716000000064],[-55.664444000000003,49.52388000000002],[-55.68111399999998,49.510826000000122],[-55.687499999999943,49.508049000000028],[-55.695548999999971,49.506943000000035]],[[-124.68943799999994,49.480270000000019],[-124.69611399999997,49.477767999999969],[-124.70221700000002,49.478042999999957],[-124.74137899999994,49.488045000000113],[-124.75361599999991,49.491379000000109],[-124.82362399999994,49.539435999999966],[-124.83666999999997,49.554993000000024],[-124.84111000000001,49.562767000000008],[-124.84249899999992,49.578605999999979],[-124.84194899999989,49.58415999999994],[-124.83416699999992,49.607773000000066],[-124.83168000000001,49.610549999999989],[-124.82749899999993,49.608887000000038],[-124.81054699999993,49.589714000000129],[-124.80888400000003,49.586655000000007],[-124.80583200000001,49.585823000000062],[-124.77887699999997,49.568886000000077],[-124.68804899999986,49.483604000000014],[-124.68943799999994,49.480270000000019]],[[-55.693053999999961,49.56749700000006],[-55.709166999999979,49.566383000000087],[-55.716659999999933,49.567214999999976],[-55.720832999999971,49.571381000000088],[-55.723052999999993,49.576102999999989],[-55.722771000000023,49.581383000000073],[-55.705832999999927,49.613883999999985],[-55.684998000000007,49.624992000000134],[-55.673888999999974,49.630547000000035],[-55.659720999999934,49.635551000000021],[-55.653052999999886,49.63638300000008],[-55.572776999999974,49.603881999999999],[-55.567504999999926,49.599998000000141],[-55.573058999999944,49.595543000000134],[-55.586387999999943,49.59137700000008],[-55.608054999999979,49.586104999999975],[-55.671669000000009,49.571381000000088],[-55.693053999999961,49.56749700000006]],[[-54.576667999999984,49.558601000000124],[-54.77305599999994,49.493880999999988],[-54.809440999999993,49.488045000000113],[-54.83916499999998,49.48443600000013],[-54.855835000000013,49.48443600000013],[-54.863060000000019,49.485268000000019],[-54.871940999999936,49.487495000000081],[-54.873055000000022,49.492218000000094],[-54.893616000000009,49.580551000000128],[-54.894447000000014,49.58526599999999],[-54.891945000000021,49.590546000000074],[-54.885276999999974,49.593048000000124],[-54.805556999999965,49.595825000000048],[-54.792228999999963,49.572768999999994],[-54.793335000000013,49.566939999999988],[-54.791671999999892,49.56249200000002],[-54.78833800000001,49.557770000000119],[-54.784172000000012,49.554161000000136],[-54.768607999999972,49.546661000000029],[-54.760001999999986,49.545547000000056],[-54.743889000000024,49.544998000000135],[-54.729720999999984,49.548050000000046],[-54.708611000000019,49.554436000000123],[-54.614722999999969,49.606102000000021],[-54.574722000000008,49.635269000000108],[-54.561942999999928,49.653603000000089],[-54.548889000000031,49.659988000000055],[-54.536117999999931,49.664153999999996],[-54.529723999999987,49.633881000000031],[-54.531669999999963,49.62221500000004],[-54.538054999999986,49.587494000000106],[-54.543334999999956,49.582497000000046],[-54.570557000000008,49.562209999999936],[-54.576667999999984,49.558601000000124]],[[-54.004448000000025,49.647491000000116],[-54.257781999999963,49.566666000000055],[-54.265839000000028,49.566939999999988],[-54.274719000000005,49.569160000000011],[-54.289444000000003,49.576102999999989],[-54.293335000000013,49.580551000000128],[-54.298888999999917,49.609993000000088],[-54.297782999999981,49.651100000000099],[-54.288054999999929,49.71138000000002],[-54.282775999999956,49.716660000000104],[-54.269996999999989,49.722487999999998],[-54.141945000000021,49.75],[-54.102225999999973,49.750274999999988],[-54.093886999999938,49.748878000000047],[-54.085830999999985,49.745544000000052],[-54.081115999999952,49.736381999999935],[-54.040000999999961,49.689987000000087],[-54.003058999999951,49.659988000000055],[-54.004448000000025,49.647491000000116]],[[-124.129707,49.650825999999995],[-124.139183,49.650543000000027],[-124.15361000000001,49.655548000000067],[-124.18694299999993,49.668883999999991],[-124.196663,49.676940999999999],[-124.20195000000001,49.701934999999992],[-124.19943199999989,49.706099999999992],[-124.14750699999996,49.746658000000025],[-124.14277600000003,49.75],[-124.13722199999995,49.752219999999966],[-124.09166699999997,49.767769000000101],[-124.03611799999999,49.777214000000129],[-124.029449,49.778328000000101],[-124.021118,49.77777100000003],[-124.01611299999996,49.775551000000007],[-124.01862299999999,49.77165999999994],[-124.02555799999993,49.767769000000101],[-124.04611199999999,49.756386000000077],[-124.06054699999999,49.744995000000131],[-124.07472200000001,49.733330000000024],[-124.09084300000001,49.715546000000131],[-124.10109699999992,49.700272000000041],[-124.10555999999991,49.689430000000016],[-124.10722399999992,49.677215999999987],[-124.11081699999994,49.664992999999924],[-124.11361699999998,49.659713999999951],[-124.12304699999993,49.651931999999988],[-124.129707,49.650825999999995]],[[-56.80361199999993,49.763329000000056],[-56.827498999999989,49.761107999999979],[-56.83555599999994,49.762771999999984],[-56.83805099999995,49.767494000000056],[-56.832779000000016,49.771934999999985],[-56.826667999999984,49.77526899999998],[-56.792503000000011,49.785552999999993],[-56.782218999999998,49.78694200000001],[-56.78194400000001,49.780822999999941],[-56.790840000000003,49.768326000000002],[-56.796669000000009,49.764999000000046],[-56.80361199999993,49.763329000000056]],[[-124.44611399999991,49.723320000000115],[-124.43749999999994,49.723045000000127],[-124.42887899999994,49.723877000000016],[-124.41000400000001,49.723045000000127],[-124.38137799999998,49.713326000000109],[-124.35138699999999,49.698044000000095],[-124.33277900000002,49.683327000000077],[-124.13474300000001,49.525269000000037],[-124.13221699999991,49.520271000000037],[-124.12416100000002,49.499161000000072],[-124.122772,49.493607000000054],[-124.12748699999997,49.489715999999987],[-124.13417099999992,49.487495000000081],[-124.14167799999996,49.485825000000091],[-124.14916999999997,49.486107000000004],[-124.15527299999985,49.488602000000014],[-124.281387,49.546661000000029],[-124.40583800000002,49.605826999999977],[-124.43804899999998,49.628875999999991],[-124.44220699999994,49.638046000000031],[-124.47666900000002,49.67193600000013],[-124.5396649999999,49.692768000000001],[-124.55249799999996,49.697105000000022],[-124.56167599999998,49.699935999999923],[-124.61416600000001,49.713607999999965],[-124.62721299999993,49.71915400000006],[-124.65416699999997,49.736107000000118],[-124.66082799999992,49.742767000000129],[-124.65666199999993,49.796943999999939],[-124.65110800000002,49.799995000000138],[-124.61945300000002,49.797218000000044],[-124.604446,49.789436000000137],[-124.59944199999995,49.78443900000002],[-124.59028599999999,49.77165999999994],[-124.56234000000001,49.753326000000015],[-124.55933399999998,49.751495000000034],[-124.49472000000003,49.733330000000024],[-124.44611399999991,49.723320000000115]],[[-126.67610199999996,49.583603000000039],[-126.68138099999993,49.583054000000118],[-126.68888899999996,49.583878000000084],[-126.69722000000002,49.585548000000074],[-126.78971899999999,49.612213000000111],[-126.80803699999996,49.61971299999999],[-126.81416299999995,49.622765000000072],[-126.90556300000003,49.685547000000099],[-126.96528599999999,49.726935999999966],[-126.96945199999999,49.731102000000078],[-126.97416699999991,49.740273000000002],[-126.97556299999997,49.75],[-126.94055200000003,49.831383000000017],[-126.890556,49.84777100000008],[-126.79915599999993,49.876099000000011],[-126.77749599999993,49.87971500000009],[-126.76872299999997,49.878616000000079],[-126.74944299999999,49.85694100000012],[-126.73416099999997,49.848045000000013],[-126.67804699999994,49.825272000000098],[-126.64472999999992,49.774162000000047],[-126.636124,49.759437999999989],[-126.63445300000001,49.753883000000087],[-126.61332699999997,49.648330999999985],[-126.61609599999997,49.624435000000062],[-126.62053699999996,49.606102000000021],[-126.62416099999996,49.601386999999988],[-126.63305700000001,49.596100000000035],[-126.66861,49.585548000000074],[-126.67610199999996,49.583603000000039]],[[-62.089721999999881,49.386383000000137],[-62.081389999999999,49.385551000000078],[-62.051665999999955,49.390274000000034],[-62.043616999999927,49.390549000000078],[-62.025276000000019,49.38749700000011],[-61.892226999999934,49.351387000000045],[-61.875557000000015,49.344994000000042],[-61.825835999999924,49.312209999999993],[-61.821114000000023,49.308883999999978],[-61.663329999999917,49.149162000000047],[-61.661666999999966,49.144439999999975],[-61.670837000000006,49.134163000000001],[-61.702224999999942,49.111107000000004],[-61.735557999999969,49.096099999999979],[-61.796111999999937,49.078048999999965],[-62.019996999999989,49.069443000000035],[-62.029167000000029,49.069443000000035],[-62.195549000000028,49.074997000000053],[-62.368057000000022,49.0991590000001],[-62.726105000000018,49.154709000000025],[-62.782218999999884,49.165824999999984],[-62.946662999999944,49.198874999999987],[-63.089995999999985,49.228043000000014],[-63.097778000000005,49.23054500000012],[-63.209442000000024,49.270827999999995],[-63.23082699999992,49.280273000000022],[-63.242774999999938,49.287498000000085],[-63.253059000000007,49.294997999999964],[-63.269996999999989,49.311104],[-63.275832999999977,49.314712999999983],[-63.283332999999914,49.317771999999934],[-63.387221999999952,49.34388000000007],[-63.416945999999882,49.350829999999974],[-63.501296999999965,49.370384000000115],[-63.537223999999867,49.379714999999976],[-63.573058999999944,49.396660000000111],[-63.61611199999993,49.446938000000102],[-63.621940999999879,49.455551000000071],[-63.620833999999945,49.461105000000089],[-63.616660999999908,49.46665999999999],[-63.61333499999995,49.473044999999956],[-63.612502999999947,49.478873999999962],[-63.61611199999993,49.488327000000027],[-63.619720000000029,49.492767000000015],[-63.662772999999959,49.533051],[-63.67888599999992,49.544716000000051],[-63.714446999999893,49.566383000000087],[-63.84194199999996,49.639160000000004],[-63.881942999999978,49.65915700000005],[-63.918334999999956,49.674438000000009],[-64.01556399999987,49.702492000000063],[-64.306945999999925,49.777489000000003],[-64.382216999999969,49.789436000000137],[-64.389998999999932,49.789719000000105],[-64.418335000000013,49.801658999999972],[-64.511123999999995,49.858604000000014],[-64.513901000000033,49.863609000000054],[-64.510283999999956,49.868599000000131],[-64.50111400000003,49.878043999999989],[-64.496108999999876,49.883049000000085],[-64.490828999999906,49.886939999999925],[-64.472778000000005,49.895828000000108],[-64.458618000000001,49.900826000000109],[-64.445540999999992,49.904434000000037],[-64.226943999999946,49.948326000000066],[-64.203613000000018,49.950271999999984],[-64.142775999999969,49.948044000000039],[-64.133057000000008,49.947212000000093],[-64.12388599999997,49.945267000000115],[-64.029175000000009,49.924438000000123],[-63.958892999999932,49.898048000000131],[-63.615836999999942,49.849158999999986],[-63.545006000000001,49.843323000000112],[-63.49222599999996,49.840828000000045],[-63.475272999999959,49.840546000000018],[-63.346946999999943,49.820274000000097],[-63.309722999999963,49.813880999999981],[-63.136115999999959,49.780822999999941],[-63.074447999999961,49.764160000000061],[-62.99610899999999,49.736656000000096],[-62.786667000000023,49.676384000000098],[-62.71055599999994,49.660820000000001],[-62.545554999999979,49.599998000000141],[-62.443610999999919,49.5472180000001],[-62.340553,49.486938000000009],[-62.212218999999948,49.41443600000008],[-62.205832999999984,49.41137700000013],[-62.188889000000017,49.405823000000112],[-62.169166999999959,49.401099999999985],[-62.099167000000023,49.387771999999984],[-62.089721999999881,49.386383000000137]],[[-124.92415599999998,50.05860100000001],[-124.96861299999995,50.035827999999981],[-125.00055699999996,50.056656000000032],[-125.06304899999998,50.103324999999984],[-125.06696299999999,50.107498000000135],[-125.066101,50.113884000000041],[-125.0625,50.118324000000086],[-125.03971899999999,50.130546999999922],[-124.991669,50.168327000000033],[-124.98222399999992,50.176102000000128],[-124.98055999999991,50.18221299999999],[-124.98332199999999,50.225548000000003],[-124.93138099999993,50.171104000000128],[-124.92859599999997,50.166100000000142],[-124.91528299999999,50.141380000000083],[-124.89778100000001,50.077492000000063],[-124.92415599999998,50.05860100000001]],[[-63.859443999999996,50.197768999999937],[-63.873610999999983,50.194434999999999],[-63.890282000000013,50.194709999999986],[-63.899993999999936,50.196098000000063],[-63.908607000000018,50.198601000000053],[-63.916107000000011,50.201660000000004],[-63.920837000000006,50.205551000000071],[-63.930557000000022,50.218597000000045],[-63.931389000000024,50.223877000000073],[-63.930557000000022,50.229431000000091],[-63.926948999999922,50.236107000000004],[-63.922774999999888,50.241661000000022],[-63.916663999999969,50.244713000000104],[-63.909995999999921,50.246658000000139],[-63.90193899999997,50.24721500000004],[-63.889724999999999,50.242218000000094],[-63.865554999999915,50.228325000000041],[-63.859443999999996,50.224709000000018],[-63.854720999999927,50.220824999999991],[-63.852782999999988,50.216103000000089],[-63.853614999999991,50.210548000000017],[-63.855835000000013,50.204437000000098],[-63.859443999999996,50.197768999999937]],[[-125.16777000000002,49.980819999999937],[-125.16999800000002,49.980819999999937],[-125.17111199999994,49.981659000000093],[-125.18582199999997,50.004165999999998],[-125.20722999999998,50.044998000000021],[-125.21417199999996,50.069992000000013],[-125.28167699999989,50.11332700000014],[-125.31777999999986,50.136107999999979],[-125.32362399999994,50.143326000000002],[-125.33999599999993,50.203049000000021],[-125.34916699999997,50.242493000000138],[-125.34973100000002,50.25777400000004],[-125.348343,50.261665000000107],[-125.34554299999996,50.263901000000033],[-125.33999599999993,50.26888300000013],[-125.31082200000003,50.281380000000127],[-125.26334400000002,50.293883999999991],[-125.25472999999988,50.293610000000058],[-125.24638399999998,50.290549999999996],[-125.24333199999995,50.288329999999974],[-125.16722099999987,50.213608000000079],[-125.16111799999999,50.200272000000098],[-125.16000400000001,50.190544000000102],[-125.18666100000002,50.141663000000051],[-125.1536099999999,50.006103999999937],[-125.15416699999997,50.000832000000003],[-125.16416900000002,49.985268000000133],[-125.16777000000002,49.980819999999937]],[[-124.8125,50.111381999999992],[-124.82112100000001,50.111107000000118],[-124.82749899999993,50.111937999999952],[-124.83361799999989,50.114441000000113],[-124.86110699999989,50.136383000000023],[-124.93916299999995,50.207771000000093],[-124.96305799999999,50.236382000000049],[-124.96610999999996,50.246941000000106],[-124.96556099999992,50.251663000000008],[-124.92304999999993,50.296386999999982],[-124.91832699999986,50.29972099999992],[-124.91082799999998,50.299995000000081],[-124.90249599999999,50.29833200000013],[-124.89862099999999,50.293883999999991],[-124.87581599999993,50.28472099999999],[-124.82167099999992,50.239716000000044],[-124.75666799999999,50.178328999999962],[-124.75250199999999,50.167770000000132],[-124.752228,50.161376999999959],[-124.75499699999995,50.156097000000102],[-124.80695300000002,50.113884000000041],[-124.8125,50.111381999999992]],[[-124.73082699999992,50.302215999999987],[-124.72693599999997,50.299164000000019],[-124.72471599999994,50.299164000000019],[-124.69554099999999,50.289436000000023],[-124.68331899999993,50.283333000000084],[-124.67250100000001,50.276100000000042],[-124.66860999999994,50.272491000000059],[-124.66111799999993,50.263054000000125],[-124.65943900000002,50.258330999999941],[-124.65750099999997,50.247772000000111],[-124.65611299999989,50.231377000000009],[-124.65834000000001,50.212212000000022],[-124.66000399999996,50.207496999999989],[-124.66251399999999,50.203323000000125],[-124.695831,50.157494000000042],[-124.70195000000001,50.158600000000092],[-124.70805399999995,50.161376999999959],[-124.79222099999993,50.22526600000009],[-124.79499800000002,50.228874000000019],[-124.78083800000002,50.269440000000031],[-124.77778599999999,50.27748900000006],[-124.74500299999994,50.299437999999952],[-124.74054699999994,50.30193300000002],[-124.73082699999992,50.302215999999987]],[[-125.54387700000001,50.393883000000017],[-125.63583399999999,50.379714999999976],[-125.69360399999999,50.383330999999998],[-125.70333899999991,50.384163000000115],[-125.75527999999997,50.391662999999994],[-125.762787,50.394157000000121],[-125.76363400000002,50.397491000000116],[-125.75527999999997,50.405548000000067],[-125.74416399999996,50.40776800000009],[-125.59528399999999,50.433052000000089],[-125.58640300000002,50.434158000000139],[-125.52390300000002,50.434433000000126],[-125.51889,50.431381000000044],[-125.51806599999998,50.428604000000121],[-125.51777600000003,50.409431000000041],[-125.520554,50.403320000000122],[-125.52500899999995,50.400825999999995],[-125.53639199999998,50.395827999999995],[-125.54387700000001,50.393883000000017]],[[-125.16555800000003,50.374435000000062],[-125.06139400000001,50.240547000000049],[-125.05194099999989,50.226653999999996],[-125.05027799999993,50.221657000000107],[-125.048607,50.207771000000093],[-125.04915599999993,50.193320999999969],[-125.05166599999995,50.190826000000129],[-125.11638599999998,50.136658000000011],[-125.12917299999998,50.126098999999954],[-125.13390400000003,50.122764999999958],[-125.14028899999994,50.121658000000025],[-125.14472999999987,50.12193300000007],[-125.15083299999998,50.12499200000002],[-125.15416699999997,50.133331000000055],[-125.13971699999996,50.159431000000097],[-125.15611299999995,50.239158999999972],[-125.21083099999993,50.313048999999921],[-125.21362299999993,50.316666000000055],[-125.22000099999991,50.318329000000006],[-125.26363400000002,50.323607999999979],[-125.27194199999997,50.323883000000023],[-125.31555199999997,50.318054000000018],[-125.32112099999989,50.316939999999988],[-125.32695000000001,50.313881000000038],[-125.33306900000002,50.304435999999953],[-125.33473200000003,50.29972099999992],[-125.33944699999989,50.29583000000008],[-125.35610999999994,50.290276000000063],[-125.37222300000002,50.289436000000023],[-125.38527699999997,50.289993000000095],[-125.390289,50.29222100000004],[-125.39306599999998,50.29583000000008],[-125.39917000000003,50.311104000000114],[-125.400284,50.320831000000055],[-125.39943699999998,50.331108000000086],[-125.39806399999998,50.333878000000084],[-125.391953,50.340546000000074],[-125.291946,50.433876000000055],[-125.28443899999996,50.435822000000144],[-125.27500900000001,50.433327000000133],[-125.27306399999992,50.431107000000111],[-125.23665599999993,50.415825000000098],[-125.21640000000002,50.404709000000139],[-125.16555800000003,50.374435000000062]],[[-125.42610200000001,50.3555530000001],[-125.45777899999996,50.349434000000088],[-125.46749899999998,50.350273000000016],[-125.52610800000002,50.378875999999991],[-125.52806099999998,50.381660000000124],[-125.51862299999993,50.390274000000034],[-125.47749299999998,50.424164000000133],[-125.47165699999999,50.427489999999977],[-125.465012,50.429993000000138],[-125.37998999999996,50.460823000000005],[-125.37165799999997,50.457771000000037],[-125.37082699999996,50.455826000000059],[-125.36665299999993,50.454162999999937],[-125.34306300000003,50.441658000000018],[-125.33194700000001,50.435547000000099],[-125.33000199999998,50.430824000000143],[-125.33056599999986,50.425270000000125],[-125.33693700000003,50.416664000000026],[-125.38583399999999,50.36971299999999],[-125.39835399999998,50.364159000000029],[-125.42610200000001,50.3555530000001]],[[-125.80721999999997,50.413605000000075],[-125.90695199999993,50.409714000000008],[-125.92194399999988,50.41027100000008],[-125.92804699999999,50.411658999999986],[-125.93110699999988,50.413879000000009],[-125.95111099999997,50.433876000000055],[-125.93943799999988,50.443047000000035],[-125.90583799999996,50.45638300000013],[-125.81416299999995,50.46804800000001],[-125.80777,50.467765999999983],[-125.80359599999997,50.465546000000131],[-125.79055799999998,50.456940000000031],[-125.74109599999997,50.431664000000012],[-125.73805199999998,50.428047000000049],[-125.73805199999998,50.426658999999972],[-125.74276700000001,50.424164000000133],[-125.75834700000001,50.419990999999982],[-125.79110700000001,50.414992999999981],[-125.80721999999997,50.413605000000075]],[[-126.22582999999997,50.555267000000129],[-126.30888399999998,50.528327999999988],[-126.33640299999996,50.521659999999997],[-126.35056299999997,50.52027099999998],[-126.486107,50.515549000000078],[-126.58805799999999,50.521378000000084],[-126.60417199999995,50.52526899999998],[-126.62389400000001,50.533881999999949],[-126.60417199999995,50.539719000000105],[-126.57444800000002,50.546387000000095],[-126.55695300000002,50.548607000000118],[-126.54194599999994,50.549438000000123],[-126.52667200000002,50.548882000000106],[-126.48860200000001,50.553321999999923],[-126.38110399999999,50.574715000000026],[-126.28611799999999,50.598327999999981],[-126.28278399999999,50.597488000000112],[-126.22609699999998,50.564156000000025],[-126.22305299999999,50.560546999999985],[-126.224716,50.556655999999919],[-126.22582999999997,50.555267000000129]],[[-126.46639999999996,50.575829000000056],[-126.47501399999993,50.575554000000011],[-126.47917199999995,50.576385000000016],[-126.53555299999999,50.590546000000018],[-126.54915599999998,50.596382000000062],[-126.55222300000003,50.598602000000085],[-126.554169,50.602776000000119],[-126.55248999999998,50.607498000000021],[-126.55027799999999,50.608604000000071],[-126.54360999999994,50.611382000000049],[-126.52916699999997,50.614998000000128],[-126.45361299999996,50.626937999999996],[-126.40499899999992,50.626099000000067],[-126.385559,50.625549000000035
gitextract_rf49ku9m/
├── .github/
│ ├── CODEOWNERS
│ ├── ISSUE_TEMPLATE.md
│ ├── PULL_REQUEST_TEMPLATE.md
│ └── workflows/
│ ├── ci.yml
│ ├── cifuzz.yml
│ └── codspeed.yml
├── .gitignore
├── CHANGELOG.md
├── CONTRIBUTING.md
├── Cargo.toml
├── LICENSE
├── README.md
├── assets/
│ ├── links.txt
│ └── testfile.txt
├── benchmarks/
│ ├── Cargo.toml
│ ├── README.md
│ ├── benches/
│ │ ├── arithmetic.rs
│ │ ├── http.rs
│ │ ├── http_streaming.rs
│ │ ├── ini.rs
│ │ ├── ini_str.rs
│ │ ├── json.rs
│ │ ├── json_streaming.rs
│ │ └── number.rs
│ ├── canada.json
│ └── src/
│ └── lib.rs
├── doc/
│ ├── archive/
│ │ ├── FAQ.md
│ │ ├── how_nom_macros_work.md
│ │ ├── upgrading_to_nom_1.md
│ │ ├── upgrading_to_nom_2.md
│ │ └── upgrading_to_nom_4.md
│ ├── choosing_a_combinator.md
│ ├── custom_input_types.md
│ ├── error_management.md
│ ├── home.md
│ ├── making_a_new_parser_from_scratch.md
│ ├── nom_recipes.md
│ └── upgrading_to_nom_5.md
├── examples/
│ ├── custom_error.rs
│ ├── iterator.rs
│ ├── json.rs
│ ├── json2.rs
│ ├── json_iterator.rs
│ ├── s_expression.rs
│ └── string.rs
├── fuzz/
│ ├── .gitignore
│ ├── Cargo.toml
│ └── fuzz_targets/
│ └── fuzz_arithmetic.rs
├── nom-language/
│ ├── Cargo.toml
│ └── src/
│ ├── error.rs
│ ├── lib.rs
│ └── precedence/
│ ├── mod.rs
│ └── tests.rs
├── proptest-regressions/
│ ├── character/
│ │ ├── complete.txt
│ │ └── streaming.txt
│ └── number/
│ ├── complete.txt
│ └── streaming.txt
├── rustfmt.toml
├── src/
│ ├── bits/
│ │ ├── complete.rs
│ │ ├── mod.rs
│ │ └── streaming.rs
│ ├── branch/
│ │ ├── mod.rs
│ │ └── tests.rs
│ ├── bytes/
│ │ ├── complete.rs
│ │ ├── mod.rs
│ │ ├── streaming.rs
│ │ └── tests.rs
│ ├── character/
│ │ ├── complete.rs
│ │ ├── mod.rs
│ │ ├── streaming.rs
│ │ └── tests.rs
│ ├── combinator/
│ │ ├── mod.rs
│ │ └── tests.rs
│ ├── error.rs
│ ├── internal.rs
│ ├── lib.rs
│ ├── macros.rs
│ ├── multi/
│ │ ├── mod.rs
│ │ └── tests.rs
│ ├── number/
│ │ ├── complete.rs
│ │ ├── mod.rs
│ │ └── streaming.rs
│ ├── sequence/
│ │ ├── mod.rs
│ │ └── tests.rs
│ ├── str.rs
│ └── traits.rs
└── tests/
├── arithmetic.rs
├── arithmetic_ast.rs
├── css.rs
├── custom_errors.rs
├── escaped.rs
├── expression_ast.rs
├── float.rs
├── fnmut.rs
├── ini.rs
├── ini_str.rs
├── issues.rs
├── json.rs
├── mp4.rs
├── multiline.rs
├── overflow.rs
└── reborrow_fold.rs
SYMBOL INDEX (1535 symbols across 62 files)
FILE: benchmarks/benches/arithmetic.rs
function factor (line 19) | fn factor(input: &[u8]) -> IResult<&[u8], i64> {
function term (line 36) | fn term(input: &[u8]) -> IResult<&[u8], i64> {
function expr (line 53) | fn expr(input: &[u8]) -> IResult<&[u8], i64> {
function arithmetic (line 71) | fn arithmetic(c: &mut Criterion) {
FILE: benchmarks/benches/http.rs
type Request (line 11) | struct Request<'a> {
type Header (line 18) | struct Header<'a> {
function is_token (line 25) | fn is_token(c: u8) -> bool {
function not_line_ending (line 51) | fn not_line_ending(c: u8) -> bool {
function is_space (line 55) | fn is_space(c: u8) -> bool {
function is_not_space (line 59) | fn is_not_space(c: u8) -> bool {
function is_horizontal_space (line 62) | fn is_horizontal_space(c: u8) -> bool {
function is_version (line 66) | fn is_version(c: u8) -> bool {
function line_ending (line 70) | fn line_ending<'a>()-> impl Parser<&'a[u8], Output=&'a[u8], Error=Error<...
function request_line (line 74) | fn request_line<'a>()-> impl Parser<&'a[u8], Output=Request<'a>, Error=E...
function http_version (line 79) | fn http_version<'a>() -> impl Parser<&'a[u8], Output=&'a[u8], Error=Erro...
function message_header_value (line 84) | fn message_header_value<'a>() -> impl Parser<&'a[u8], Output=&'a[u8], Er...
function message_header (line 89) | fn message_header<'a>() -> impl Parser<&'a[u8], Output=Header<'a>, Erro...
function request (line 94) | fn request<'a>() -> impl Parser<&'a[u8], Output=(Request<'a>, Vec<Header...
function parse (line 99) | fn parse(data: &[u8]) -> Option<Vec<(Request<'_>, Vec<Header<'_>>)>> {
function one_test (line 142) | fn one_test(c: &mut Criterion) {
FILE: benchmarks/benches/http_streaming.rs
type Request (line 11) | struct Request<'a> {
type Header (line 18) | struct Header<'a> {
function is_token (line 25) | fn is_token(c: u8) -> bool {
function not_line_ending (line 51) | fn not_line_ending(c: u8) -> bool {
function is_space (line 55) | fn is_space(c: u8) -> bool {
function is_not_space (line 59) | fn is_not_space(c: u8) -> bool {
function is_horizontal_space (line 62) | fn is_horizontal_space(c: u8) -> bool {
function is_version (line 66) | fn is_version(c: u8) -> bool {
function request_line (line 70) | fn request_line(input: &[u8]) -> IResult<&[u8], Request<'_>> {
function http_version (line 81) | fn http_version(input: &[u8]) -> IResult<&[u8], &[u8]> {
function message_header_value (line 88) | fn message_header_value(input: &[u8]) -> IResult<&[u8], &[u8]> {
function message_header (line 96) | fn message_header(input: &[u8]) -> IResult<&[u8], Header<'_>> {
function request (line 104) | fn request(input: &[u8]) -> IResult<&[u8], (Request<'_>, Vec<Header<'_>>...
function parse (line 113) | fn parse(data: &[u8]) -> Option<Vec<(Request<'_>, Vec<Header<'_>>)>> {
function one_test (line 156) | fn one_test(c: &mut Criterion) {
FILE: benchmarks/benches/ini.rs
function category (line 19) | fn category(i: &[u8]) -> IResult<&[u8], &str> {
function key_value (line 27) | fn key_value(i: &[u8]) -> IResult<&[u8], (&str, &str)> {
function categories (line 36) | fn categories(i: &[u8]) -> IResult<&[u8], HashMap<&str, HashMap<&str, &s...
function bench_ini (line 48) | fn bench_ini(c: &mut Criterion) {
function bench_ini_keys_and_values (line 66) | fn bench_ini_keys_and_values(c: &mut Criterion) {
function bench_ini_key_value (line 83) | fn bench_ini_key_value(c: &mut Criterion) {
FILE: benchmarks/benches/ini_str.rs
function is_line_ending_or_comment (line 17) | fn is_line_ending_or_comment(chr: char) -> bool {
function space_or_line_ending (line 21) | fn space_or_line_ending(i: &str) -> IResult<&str, &str> {
function category (line 25) | fn category(i: &str) -> IResult<&str, &str> {
function key_value (line 33) | fn key_value(i: &str) -> IResult<&str, (&str, &str)> {
function keys_and_values (line 43) | fn keys_and_values(input: &str) -> IResult<&str, HashMap<&str, &str>> {
function category_and_keys (line 47) | fn category_and_keys(i: &str) -> IResult<&str, (&str, HashMap<&str, &str...
function categories (line 51) | fn categories(input: &str) -> IResult<&str, HashMap<&str, HashMap<&str, ...
function bench_ini_str (line 55) | fn bench_ini_str(c: &mut Criterion) {
FILE: benchmarks/benches/json.rs
type JsonValue (line 22) | pub enum JsonValue {
function boolean (line 31) | fn boolean<'a, E: ParseError<&'a str>>() -> impl Parser<&'a str, Output ...
function u16_hex (line 35) | fn u16_hex<'a, E: ParseError<&'a str> + FromExternalError<&'a str, Parse...
function unicode_escape (line 40) | fn unicode_escape<'a, E: ParseError<&'a str> + FromExternalError<&'a str...
function character (line 67) | fn character<
type Character (line 94) | struct Character<E> {
type Output (line 104) | type Output = char;
type Error (line 106) | type Error = E;
function process (line 108) | fn process<OM: nom::OutputMode>(
function string (line 136) | fn string<
function ws (line 150) | fn ws<
function array (line 161) | fn array<
function object (line 172) | fn object<
function json_value (line 205) | fn json_value<
type JsonParser (line 212) | struct JsonParser<E> {
type Output (line 225) | type Output = JsonValue;
type Error (line 226) | type Error = E;
function process (line 228) | fn process<OM: nom::OutputMode>(
function json (line 246) | fn json<
function json_bench (line 253) | fn json_bench(c: &mut Criterion) {
function json_bench_error_check (line 275) | fn json_bench_error_check(c: &mut Criterion) {
function canada_json (line 298) | fn canada_json(c: &mut Criterion) {
function verbose_json (line 314) | fn verbose_json(c: &mut Criterion) {
function verbose_canada_json (line 336) | fn verbose_canada_json(c: &mut Criterion) {
function recognize_float_bytes (line 352) | fn recognize_float_bytes(c: &mut Criterion) {
function recognize_float_str (line 366) | fn recognize_float_str(c: &mut Criterion) {
function float_bytes (line 378) | fn float_bytes(c: &mut Criterion) {
function float_str (line 390) | fn float_str(c: &mut Criterion) {
function std_float (line 402) | fn std_float(input: &[u8]) -> IResult<&[u8], f64, (&[u8], ErrorKind)> {
function std_float_bytes (line 412) | fn std_float_bytes(c: &mut Criterion) {
FILE: benchmarks/benches/json_streaming.rs
type JsonValue (line 20) | pub enum JsonValue {
function boolean (line 29) | fn boolean(input: &str) -> IResult<&str, bool> {
function u16_hex (line 33) | fn u16_hex(input: &str) -> IResult<&str, u16> {
function unicode_escape (line 37) | fn unicode_escape(input: &str) -> IResult<&str, char> {
function character (line 63) | fn character(input: &str) -> IResult<&str, char> {
function string (line 86) | fn string(input: &str) -> IResult<&str, String> {
function ws (line 98) | fn ws<'a, O, E: ParseError<&'a str>, F: Parser<&'a str, Output = O, Erro...
function array (line 104) | fn array(input: &str) -> IResult<&str, Vec<JsonValue>> {
function object (line 113) | fn object(input: &str) -> IResult<&str, HashMap<String, JsonValue>> {
function json_value (line 128) | fn json_value(input: &str) -> IResult<&str, JsonValue> {
function json (line 142) | fn json(input: &str) -> IResult<&str, JsonValue> {
function json_bench (line 146) | fn json_bench(c: &mut Criterion) {
function recognize_float_bytes (line 159) | fn recognize_float_bytes(c: &mut Criterion) {
function recognize_float_str (line 169) | fn recognize_float_str(c: &mut Criterion) {
function float_bytes (line 179) | fn float_bytes(c: &mut Criterion) {
function float_str (line 189) | fn float_str(c: &mut Criterion) {
function std_float (line 201) | fn std_float(input: &[u8]) -> IResult<&[u8], f64, (&[u8], ErrorKind)> {
function std_float_bytes (line 211) | fn std_float_bytes(c: &mut Criterion) {
FILE: benchmarks/benches/number.rs
function parser (line 7) | fn parser(i: &[u8]) -> nom::IResult<&[u8], u64> {
function number (line 11) | fn number(c: &mut Criterion) {
FILE: benchmarks/src/lib.rs
function it_works (line 4) | fn it_works() {
FILE: examples/custom_error.rs
type CustomError (line 9) | pub enum CustomError<I> {
function from_error_kind (line 15) | fn from_error_kind(input: I, kind: ErrorKind) -> Self {
function append (line 19) | fn append(_: I, _: ErrorKind, other: Self) -> Self {
function parse (line 24) | pub fn parse(_input: &str) -> IResult<&str, &str, CustomError<&str>> {
function main (line 28) | fn main() {}
function it_works (line 37) | fn it_works() {
FILE: examples/iterator.rs
function main (line 10) | fn main() {
FILE: examples/json.rs
type JsonValue (line 19) | pub enum JsonValue {
function sp (line 31) | fn sp<'a, E: ParseError<&'a str>>(i: &'a str) -> IResult<&'a str, &'a st...
function parse_str (line 54) | fn parse_str<'a, E: ParseError<&'a str>>(i: &'a str) -> IResult<&'a str,...
function boolean (line 66) | fn boolean<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a st...
function null (line 80) | fn null<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, ...
function string (line 95) | fn string<'a, E: ParseError<&'a str> + ContextError<&'a str>>(
function array (line 109) | fn array<'a, E: ParseError<&'a str> + ContextError<&'a str>>(
function key_value (line 125) | fn key_value<'a, E: ParseError<&'a str> + ContextError<&'a str>>(
function hash (line 136) | fn hash<'a, E: ParseError<&'a str> + ContextError<&'a str>>(
function json_value (line 161) | fn json_value<'a, E: ParseError<&'a str> + ContextError<&'a str>>(
function root (line 179) | fn root<'a, E: ParseError<&'a str> + ContextError<&'a str>>(
function main (line 194) | fn main() {
FILE: examples/json2.rs
type JsonValue (line 19) | pub enum JsonValue {
function boolean (line 28) | fn boolean<'a>() -> impl Parser<&'a str, Output = bool, Error = Error<&'...
function u16_hex (line 32) | fn u16_hex<'a>() -> impl Parser<&'a str, Output = u16, Error = Error<&'a...
function unicode_escape (line 36) | fn unicode_escape<'a>() -> impl Parser<&'a str, Output = char, Error = E...
function character (line 62) | fn character<'a>() -> impl Parser<&'a str, Output = char, Error = Error<...
type Character (line 86) | struct Character;
type Output (line 89) | type Output = char;
type Error (line 91) | type Error = Error<&'a str>;
method process (line 93) | fn process<OM: nom::OutputMode>(
function string (line 121) | fn string<'a>() -> impl Parser<&'a str, Output = String, Error = Error<&...
function ws (line 132) | fn ws<'a, O, E: ParseError<&'a str>, F: Parser<&'a str, Output = O, Erro...
function array (line 138) | fn array<'a>() -> impl Parser<&'a str, Output = Vec<JsonValue>, Error = ...
function object (line 146) | fn object<'a>() -> impl Parser<&'a str, Output = HashMap<String, JsonVal...
function json_value (line 161) | fn json_value() -> JsonParser {
type JsonParser (line 165) | struct JsonParser;
type Output (line 171) | type Output = JsonValue;
type Error (line 172) | type Error = Error<&'a str>;
method process (line 174) | fn process<OM: nom::OutputMode>(
function json (line 193) | fn json<'a>() -> impl Parser<&'a str, Output = JsonValue, Error = Error<...
function main (line 197) | fn main() {
FILE: examples/json_iterator.rs
type JsonValue (line 20) | pub struct JsonValue<'a, 'b> {
function new (line 26) | pub fn new(input: &'a str, offset: &'b Cell<usize>) -> JsonValue<'a, 'b> {
function offset (line 30) | pub fn offset(&self, input: &'a str) {
function data (line 35) | pub fn data(&self) -> &'a str {
function string (line 39) | pub fn string(&self) -> Option<&'a str> {
function boolean (line 51) | pub fn boolean(&self) -> Option<bool> {
function number (line 63) | pub fn number(&self) -> Option<f64> {
function array (line 75) | pub fn array(&self) -> Option<impl Iterator<Item = JsonValue<'a, 'b>>> {
function object (line 132) | pub fn object(&self) -> Option<impl Iterator<Item = (&'a str, JsonValue<...
function sp (line 206) | fn sp<'a, E: ParseError<&'a str>>(i: &'a str) -> IResult<&'a str, &'a st...
function parse_str (line 212) | fn parse_str<'a, E: ParseError<&'a str>>(i: &'a str) -> IResult<&'a str,...
function string (line 216) | fn string(i: &str) -> IResult<&str, &str> {
function boolean (line 224) | fn boolean(input: &str) -> IResult<&str, bool> {
function array (line 228) | fn array(i: &str) -> IResult<&str, ()> {
function key_value (line 242) | fn key_value(i: &str) -> IResult<&str, (&str, ())> {
function hash (line 246) | fn hash(i: &str) -> IResult<&str, ()> {
function value (line 260) | fn value(i: &str) -> IResult<&str, ()> {
function main (line 280) | fn main() {
FILE: examples/s_expression.rs
type BuiltIn (line 24) | pub enum BuiltIn {
type Atom (line 37) | pub enum Atom {
type Expr (line 55) | pub enum Expr {
function parse_builtin_op (line 69) | fn parse_builtin_op(i: &str) -> IResult<&str, BuiltIn, VerboseError<&str...
function parse_builtin (line 88) | fn parse_builtin(i: &str) -> IResult<&str, BuiltIn, VerboseError<&str>> {
function parse_bool (line 101) | fn parse_bool(i: &str) -> IResult<&str, Atom, VerboseError<&str>> {
function parse_keyword (line 115) | fn parse_keyword(i: &str) -> IResult<&str, Atom, VerboseError<&str>> {
function parse_num (line 125) | fn parse_num(i: &str) -> IResult<&str, Atom, VerboseError<&str>> {
function parse_atom (line 139) | fn parse_atom(i: &str) -> IResult<&str, Atom, VerboseError<&str>> {
function parse_constant (line 150) | fn parse_constant(i: &str) -> IResult<&str, Expr, VerboseError<&str>> {
function s_exp (line 161) | fn s_exp<'a, O1, F>(inner: F) -> impl Parser<&'a str, Output = O1, Error...
function parse_application (line 182) | fn parse_application(i: &str) -> IResult<&str, Expr, VerboseError<&str>> {
function parse_if (line 196) | fn parse_if(i: &str) -> IResult<&str, Expr, VerboseError<&str>> {
function parse_quote (line 228) | fn parse_quote(i: &str) -> IResult<&str, Expr, VerboseError<&str>> {
function parse_expr (line 244) | fn parse_expr(i: &str) -> IResult<&str, Expr, VerboseError<&str>> {
function get_num_from_expr (line 261) | fn get_num_from_expr(e: Expr) -> Option<i32> {
function get_bool_from_expr (line 269) | fn get_bool_from_expr(e: Expr) -> Option<bool> {
function eval_expression (line 280) | fn eval_expression(e: Expr) -> Option<Expr> {
function eval_from_str (line 373) | fn eval_from_str(src: &str) -> Result<Expr, String> {
function main (line 379) | fn main() {
FILE: examples/string.rs
function parse_unicode (line 30) | fn parse_unicode<'a, E>(input: &'a str) -> IResult<&'a str, char, E>
function parse_escaped_char (line 61) | fn parse_escaped_char<'a, E>(input: &'a str) -> IResult<&'a str, char, E>
function parse_escaped_whitespace (line 90) | fn parse_escaped_whitespace<'a, E: ParseError<&'a str>>(
function parse_literal (line 97) | fn parse_literal<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<...
type StringFragment (line 113) | enum StringFragment<'a> {
function parse_fragment (line 121) | fn parse_fragment<'a, E>(input: &'a str) -> IResult<&'a str, StringFragm...
function parse_string (line 137) | fn parse_string<'a, E>(input: &'a str) -> IResult<&'a str, String, E>
function main (line 168) | fn main() {
FILE: fuzz/fuzz_targets/fuzz_arithmetic.rs
function reset (line 25) | fn reset() {
function incr (line 31) | fn incr(i: &str) -> IResult<&str, ()> {
function decr (line 47) | fn decr() {
function parens (line 53) | fn parens(i: &str) -> IResult<&str, i64> {
function factor (line 61) | fn factor(i: &str) -> IResult<&str, i64> {
function term (line 68) | fn term(i: &str) -> IResult<&str, i64> {
function expr (line 99) | fn expr(i: &str) -> IResult<&str, i64> {
FILE: nom-language/src/error.rs
type VerboseError (line 12) | pub struct VerboseError<I> {
type VerboseErrorKind (line 20) | pub enum VerboseErrorKind {
function from_error_kind (line 30) | fn from_error_kind(input: I, kind: ErrorKind) -> Self {
function append (line 36) | fn append(input: I, kind: ErrorKind, mut other: Self) -> Self {
function from_char (line 41) | fn from_char(input: I, c: char) -> Self {
function add_context (line 49) | fn add_context(input: I, ctx: &'static str, mut other: Self) -> Self {
function from_external_error (line 57) | fn from_external_error(input: I, kind: ErrorKind, _e: E) -> Self {
function fmt (line 63) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
function from (line 80) | fn from(value: VerboseError<&[u8]>) -> Self {
function from (line 92) | fn from(value: VerboseError<&str>) -> Self {
function convert (line 104) | fn convert(self) -> VerboseError<I> {
function convert (line 112) | fn convert(self) -> VerboseError<(I, usize)> {
function convert_error (line 123) | pub fn convert_error<I: core::ops::Deref<Target = str>>(input: I, e: Ver...
function convert_error_panic (line 232) | fn convert_error_panic() {
function issue_1027_convert_error_panic_nonempty (line 242) | fn issue_1027_convert_error_panic_nonempty() {
FILE: nom-language/src/precedence/mod.rs
type Unary (line 10) | pub struct Unary<V, Q: Ord + Copy> {
type Binary (line 16) | pub struct Binary<V, Q: Ord + Copy> {
type Operation (line 23) | pub enum Operation<P1, P2, P3, O> {
type Assoc (line 34) | pub enum Assoc {
type Operator (line 42) | enum Operator<P1, P2, P3, Q: Ord + Copy> {
function precedence (line 52) | fn precedence(&self) -> Q {
function is_postfix (line 60) | fn is_postfix(&self) -> bool {
function unary_op (line 74) | pub fn unary_op<I, O, E, P, Q>(
function binary_op (line 95) | pub fn binary_op<I, O, E, P, Q>(
function precedence (line 203) | pub fn precedence<I, O, E, E2, F, G, H1, H3, H2, P1, P2, P3, Q>(
function left_assoc (line 426) | pub fn left_assoc<I, E, O, OP, G, F, B>(
type LeftAssoc (line 446) | pub struct LeftAssoc<F, G, B> {
type Output (line 460) | type Output = O;
type Error (line 461) | type Error = E;
function process (line 463) | fn process<OM: OutputMode>(
FILE: nom-language/src/precedence/tests.rs
function parser (line 15) | fn parser(i: &str) -> IResult<&str, i64> {
function precedence_test (line 44) | fn precedence_test() {
FILE: src/bits/complete.rs
function take (line 33) | pub fn take<I, O, C, E: ParseError<(I, usize)>>(
function tag (line 83) | pub fn tag<I, O, C, E: ParseError<(I, usize)>>(
function bool (line 121) | pub fn bool<I, E: ParseError<(I, usize)>>(input: (I, usize)) -> IResult<...
function test_take_0 (line 134) | fn test_take_0() {
function test_take_eof (line 146) | fn test_take_eof() {
function test_take_span_over_multiple_bytes (line 161) | fn test_take_span_over_multiple_bytes() {
function test_bool_0 (line 173) | fn test_bool_0() {
function test_bool_eof (line 182) | fn test_bool_eof() {
FILE: src/bits/mod.rs
function bits (line 39) | pub fn bits<I, O, E1, E2, P>(mut parser: P) -> impl FnMut(I) -> IResult<...
function bytes (line 84) | pub fn bytes<I, O, E1, E2, P>(mut parser: P) -> impl FnMut((I, usize)) -...
function test_complete_byte_consumption_bits (line 120) | fn test_complete_byte_consumption_bits() {
function test_partial_byte_consumption_bits (line 143) | fn test_partial_byte_consumption_bits() {
function test_incomplete_bits (line 163) | fn test_incomplete_bits() {
FILE: src/bits/streaming.rs
function take (line 10) | pub fn take<I, O, C, E: ParseError<(I, usize)>>(
function tag (line 59) | pub fn tag<I, O, C, E: ParseError<(I, usize)>>(
function bool (line 97) | pub fn bool<I, E: ParseError<(I, usize)>>(input: (I, usize)) -> IResult<...
function test_take_0 (line 110) | fn test_take_0() {
function test_tag_ok (line 122) | fn test_tag_ok() {
function test_tag_err (line 135) | fn test_tag_err() {
function test_bool_0 (line 154) | fn test_bool_0() {
function test_bool_eof (line 163) | fn test_bool_eof() {
FILE: src/branch/mod.rs
function alt (line 41) | pub fn alt<List>(l: List) -> Choice<List> {
function permutation (line 90) | pub fn permutation<I: Clone, E: ParseError<I>, List>(list: List) -> Perm...
type Choice (line 113) | pub struct Choice<T> {
type Output (line 164) | type Output = Output;
type Error (line 165) | type Error = Error;
function process (line 168) | fn process<OM: crate::OutputMode>(
type Output (line 184) | type Output = Output;
type Error (line 185) | type Error = Error;
function process (line 188) | fn process<OM: crate::OutputMode>(
type Output (line 222) | type Output = Output;
type Error (line 223) | type Error = Error;
function process (line 226) | fn process<OM: crate::OutputMode>(
type Permutation (line 274) | pub struct Permutation<T, Error> {
FILE: src/branch/tests.rs
type ErrorStr (line 17) | pub struct ErrorStr(String);
method from (line 21) | fn from(i: u32) -> Self {
method from (line 28) | fn from(i: &'a str) -> Self {
method from_error_kind (line 35) | fn from_error_kind(input: I, kind: ErrorKind) -> Self {
method append (line 39) | fn append(input: I, kind: ErrorKind, other: Self) -> Self {
function alt_test (line 49) | fn alt_test() {
function alt_incomplete (line 99) | fn alt_incomplete() {
function alt_array (line 119) | fn alt_array() {
function alt_dynamic_array (line 135) | fn alt_dynamic_array() {
function permutation_test (line 151) | fn permutation_test() {
FILE: src/bytes/complete.rs
function tag (line 32) | pub fn tag<T, I, Error: ParseError<I>>(tag: T) -> impl Fn(I) -> IResult<...
function tag_no_case (line 68) | pub fn tag_no_case<T, I, Error: ParseError<I>>(tag: T) -> impl Fn(I) -> ...
function is_not (line 104) | pub fn is_not<T, I, Error: ParseError<I>>(arr: T) -> impl FnMut(I) -> IR...
function is_a (line 135) | pub fn is_a<T, I, Error: ParseError<I>>(arr: T) -> impl FnMut(I) -> IRes...
function take_while (line 164) | pub fn take_while<F, I, Error: ParseError<I>>(cond: F) -> impl FnMut(I) ...
function take_while1 (line 194) | pub fn take_while1<F, I, Error: ParseError<I>>(cond: F) -> impl FnMut(I)...
function take_while_m_n (line 227) | pub fn take_while_m_n<F, I, Error: ParseError<I>>(
function take_till (line 260) | pub fn take_till<F, I, Error: ParseError<I>>(cond: F) -> impl FnMut(I) -...
function take_till1 (line 292) | pub fn take_till1<F, I, Error: ParseError<I>>(cond: F) -> impl FnMut(I) ...
function take (line 331) | pub fn take<C, I, Error: ParseError<I>>(count: C) -> impl FnMut(I) -> IR...
function take_until (line 359) | pub fn take_until<T, I, Error: ParseError<I>>(tag: T) -> impl FnMut(I) -...
function take_until1 (line 388) | pub fn take_until1<T, I, Error: ParseError<I>>(tag: T) -> impl FnMut(I) ...
function escaped (line 418) | pub fn escaped<'a, I, Error, F, G>(
function escaped_transform (line 468) | pub fn escaped_transform<I, Error, F, G, O1, O2, ExtendItem, Output>(
function complete_take_while_m_n_utf8_all_matching (line 496) | fn complete_take_while_m_n_utf8_all_matching() {
function complete_take_while_m_n_utf8_all_matching_substring (line 503) | fn complete_take_while_m_n_utf8_all_matching_substring() {
function escaped_string (line 510) | fn escaped_string(input: &str) -> IResult<&str, &str> {
function escaped_hang (line 517) | fn escaped_hang() {
function unquote (line 523) | fn unquote(input: &str) -> IResult<&str, &str> {
function escaped_hang_1118 (line 538) | fn escaped_hang_1118() {
function complete_take_while_m_n_multibyte (line 544) | fn complete_take_while_m_n_multibyte() {
FILE: src/bytes/mod.rs
function tag (line 45) | pub fn tag<T, I, Error: ParseError<I>>(tag: T) -> impl Parser<I, Output ...
type Tag (line 57) | pub struct Tag<T, E> {
type Output (line 67) | type Output = I;
type Error (line 69) | type Error = Error;
function process (line 71) | fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Sel...
function tag_no_case (line 114) | pub fn tag_no_case<T, I, Error: ParseError<I>>(tag: T) -> impl Parser<I,...
type TagNoCase (line 126) | pub struct TagNoCase<T, E> {
type Output (line 136) | type Output = I;
type Error (line 138) | type Error = Error;
function process (line 140) | fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Sel...
type SplitPosition (line 165) | pub struct SplitPosition<F, E> {
type Output (line 175) | type Output = I;
type Error (line 177) | type Error = Error;
function process (line 180) | fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Sel...
type SplitPosition1 (line 186) | pub struct SplitPosition1<F, E> {
type Output (line 197) | type Output = I;
type Error (line 199) | type Error = Error;
function process (line 202) | fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Sel...
function is_not (line 228) | pub fn is_not<T, I, Error: ParseError<I>>(arr: T) -> impl Parser<I, Outp...
function is_a (line 261) | pub fn is_a<T, I, Error: ParseError<I>>(arr: T) -> impl Parser<I, Output...
function take_while (line 292) | pub fn take_while<F, I, Error: ParseError<I>>(cond: F) -> impl Parser<I,...
function take_while1 (line 327) | pub fn take_while1<F, I, Error: ParseError<I>>(cond: F) -> impl Parser<I...
function take_while_m_n (line 364) | pub fn take_while_m_n<F, I, Error: ParseError<I>>(
type TakeWhileMN (line 382) | pub struct TakeWhileMN<F, E> {
type Output (line 394) | type Output = I;
type Error (line 395) | type Error = Error;
function process (line 397) | fn process<OM: OutputMode>(
function take_till (line 465) | pub fn take_till<F, I, Error: ParseError<I>>(cond: F) -> impl Parser<I, ...
function take_till1 (line 499) | pub fn take_till1<F, I, Error: ParseError<I>>(cond: F) -> impl Parser<I,...
function take (line 534) | pub fn take<C, I, Error: ParseError<I>>(count: C) -> impl Parser<I, Outp...
type Take (line 546) | pub struct Take<E> {
type Output (line 555) | type Output = I;
type Error (line 556) | type Error = Error;
function process (line 558) | fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Sel...
function take_until (line 596) | pub fn take_until<T, I, Error: ParseError<I>>(tag: T) -> impl Parser<I, ...
type TakeUntil (line 608) | pub struct TakeUntil<T, E> {
type Output (line 618) | type Output = I;
type Error (line 619) | type Error = Error;
function process (line 621) | fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Sel...
function take_until1 (line 660) | pub fn take_until1<T, I, Error: ParseError<I>>(tag: T) -> impl Parser<I,...
type TakeUntil1 (line 672) | pub struct TakeUntil1<T, E> {
type Output (line 682) | type Output = I;
type Error (line 683) | type Error = Error;
function process (line 685) | fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Sel...
function escaped (line 726) | pub fn escaped<I, Error, F, G>(
type Escaped (line 747) | pub struct Escaped<F, G, E> {
type Output (line 762) | type Output = I;
type Error (line 763) | type Error = Error;
function process (line 765) | fn process<OM: OutputMode>(
function escaped_transform (line 901) | pub fn escaped_transform<I, Error, F, G, ExtendItem, Output>(
type EscapedTransform (line 927) | pub struct EscapedTransform<F, G, E, ExtendItem, Output> {
type Output (line 948) | type Output = Output;
type Error (line 949) | type Error = Error;
function process (line 951) | fn process<OM: OutputMode>(
FILE: src/bytes/streaming.rs
function tag (line 31) | pub fn tag<T, I, Error: ParseError<I>>(tag: T) -> impl Fn(I) -> IResult<...
function tag_no_case (line 65) | pub fn tag_no_case<T, I, Error: ParseError<I>>(tag: T) -> impl Fn(I) -> ...
function is_not (line 101) | pub fn is_not<T, I, Error: ParseError<I>>(arr: T) -> impl FnMut(I) -> IR...
function is_a (line 134) | pub fn is_a<T, I, Error: ParseError<I>>(arr: T) -> impl FnMut(I) -> IRes...
function take_while (line 166) | pub fn take_while<F, I, Error: ParseError<I>>(cond: F) -> impl FnMut(I) ...
function take_while1 (line 200) | pub fn take_while1<F, I, Error: ParseError<I>>(cond: F) -> impl FnMut(I)...
function take_while_m_n (line 235) | pub fn take_while_m_n<F, I, Error: ParseError<I>>(
function take_till (line 273) | pub fn take_till<F, I, Error: ParseError<I>>(cond: F) -> impl FnMut(I) -...
function take_till1 (line 306) | pub fn take_till1<F, I, Error: ParseError<I>>(cond: F) -> impl FnMut(I) ...
function take (line 339) | pub fn take<C, I, Error: ParseError<I>>(count: C) -> impl FnMut(I) -> IR...
function take_until (line 370) | pub fn take_until<T, I, Error: ParseError<I>>(tag: T) -> impl FnMut(I) -...
function take_until1 (line 402) | pub fn take_until1<T, I, Error: ParseError<I>>(tag: T) -> impl FnMut(I) ...
function escaped (line 432) | pub fn escaped<I, Error, F, G>(
function escaped_transform (line 481) | pub fn escaped_transform<I, Error, F, G, O1, O2, ExtendItem, Output>(
FILE: src/bytes/tests.rs
function is_a (line 19) | fn is_a() {
function is_not (line 43) | fn is_not() {
function escaping (line 72) | fn escaping() {
function escaping_str (line 107) | fn escaping_str() {
function to_s (line 143) | fn to_s(i: Vec<u8>) -> String {
function escape_transform (line 149) | fn escape_transform() {
function escape_transform_str (line 224) | fn escape_transform_str() {
function take_until_incomplete (line 282) | fn take_until_incomplete() {
function take_until_incomplete_s (line 293) | fn take_until_incomplete_s() {
function recognize (line 302) | fn recognize() {
function take_while (line 365) | fn take_while() {
function take_while1 (line 383) | fn take_while1() {
function take_while_m_n (line 404) | fn take_while_m_n() {
function take_till (line 429) | fn take_till() {
function take_till1 (line 447) | fn take_till1() {
function take_while_utf8 (line 468) | fn take_while_utf8() {
function take_till_utf8 (line 490) | fn take_till_utf8() {
function take_utf8 (line 512) | fn take_utf8() {
function take_while_m_n_utf8 (line 536) | fn take_while_m_n_utf8() {
function take_while_m_n_utf8_full_match (line 547) | fn take_while_m_n_utf8_full_match() {
function recognize_take_while (line 558) | fn recognize_take_while() {
function length_bytes (line 574) | fn length_bytes() {
function case_insensitive (line 597) | fn case_insensitive() {
function tag_fixed_size_array (line 634) | fn tag_fixed_size_array() {
FILE: src/character/complete.rs
function char (line 33) | pub fn char<I, Error: ParseError<I>>(c: char) -> impl FnMut(I) -> IResul...
function satisfy (line 57) | pub fn satisfy<F, I, Error: ParseError<I>>(predicate: F) -> impl FnMut(I...
function one_of (line 79) | pub fn one_of<I, T, Error: ParseError<I>>(list: T) -> impl FnMut(I) -> I...
function none_of (line 101) | pub fn none_of<I, T, Error: ParseError<I>>(list: T) -> impl FnMut(I) -> ...
function crlf (line 127) | pub fn crlf<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function not_line_ending (line 161) | pub fn not_line_ending<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function line_ending (line 209) | pub fn line_ending<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function newline (line 240) | pub fn newline<I, Error: ParseError<I>>(input: I) -> IResult<I, char, Er...
function tab (line 264) | pub fn tab<I, Error: ParseError<I>>(input: I) -> IResult<I, char, Error>
function anychar (line 287) | pub fn anychar<T, E: ParseError<T>>(input: T) -> IResult<T, char, E>
function alpha0 (line 316) | pub fn alpha0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function alpha1 (line 341) | pub fn alpha1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function digit0 (line 367) | pub fn digit0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function digit1 (line 410) | pub fn digit1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function hex_digit0 (line 434) | pub fn hex_digit0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function hex_digit1 (line 458) | pub fn hex_digit1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function oct_digit0 (line 483) | pub fn oct_digit0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function oct_digit1 (line 508) | pub fn oct_digit1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function bin_digit0 (line 533) | pub fn bin_digit0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function bin_digit1 (line 558) | pub fn bin_digit1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function alphanumeric0 (line 583) | pub fn alphanumeric0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function alphanumeric1 (line 608) | pub fn alphanumeric1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function space0 (line 633) | pub fn space0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function space1 (line 661) | pub fn space1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function multispace0 (line 692) | pub fn multispace0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function multispace1 (line 720) | pub fn multispace1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function sign (line 734) | pub(crate) fn sign<T, E: ParseError<T>>(input: T) -> IResult<T, bool, E>
function character (line 885) | fn character() {
function character_s (line 937) | fn character_s() {
function offset (line 974) | fn offset() {
function is_not_line_ending_bytes (line 1033) | fn is_not_line_ending_bytes() {
function is_not_line_ending_str (line 1057) | fn is_not_line_ending_str() {
function hex_digit_test (line 1083) | fn hex_digit_test() {
function oct_digit_test (line 1114) | fn oct_digit_test() {
function bin_digit_test (line 1137) | fn bin_digit_test() {
function full_line_windows (line 1160) | fn full_line_windows() {
function full_line_unix (line 1171) | fn full_line_unix() {
function check_windows_lineending (line 1182) | fn check_windows_lineending() {
function check_unix_lineending (line 1189) | fn check_unix_lineending() {
function cr_lf (line 1196) | fn cr_lf() {
function end_of_line (line 1219) | fn end_of_line() {
function digit_to_i16 (line 1243) | fn digit_to_i16(input: &str) -> IResult<&str, i16> {
function digit_to_u32 (line 1277) | fn digit_to_u32(i: &str) -> IResult<&str, u32> {
FILE: src/character/mod.rs
function is_alphabetic (line 22) | pub fn is_alphabetic(chr: u8) -> bool {
function is_digit (line 29) | pub fn is_digit(chr: u8) -> bool {
function is_hex_digit (line 36) | pub fn is_hex_digit(chr: u8) -> bool {
function is_oct_digit (line 43) | pub fn is_oct_digit(chr: u8) -> bool {
function is_bin_digit (line 59) | pub fn is_bin_digit(chr: u8) -> bool {
function is_alphanumeric (line 66) | pub fn is_alphanumeric(chr: u8) -> bool {
function is_space (line 73) | pub fn is_space(chr: u8) -> bool {
function is_newline (line 80) | pub fn is_newline(chr: u8) -> bool {
function char (line 98) | pub fn char<I, Error: ParseError<I>>(c: char) -> impl Parser<I, Output =...
type Char (line 107) | pub struct Char<E> {
type Output (line 117) | type Output = char;
type Error (line 118) | type Error = Error;
function process (line 120) | fn process<OM: crate::OutputMode>(
function satisfy (line 155) | pub fn satisfy<F, I, Error: ParseError<I>>(
type Satisfy (line 170) | pub struct Satisfy<F, MakeError> {
type Output (line 182) | type Output = char;
type Error (line 183) | type Error = Error;
function process (line 186) | fn process<OM: crate::OutputMode>(
function one_of (line 219) | pub fn one_of<I, T, Error: ParseError<I>>(list: T) -> impl Parser<I, Out...
function none_of (line 242) | pub fn none_of<I, T, Error: ParseError<I>>(list: T) -> impl Parser<I, Ou...
function anychar (line 268) | pub fn anychar<T, E: ParseError<T>>(input: T) -> IResult<T, char, E>
type AnyChar (line 281) | pub struct AnyChar<E> {
type Output (line 290) | type Output = char;
type Error (line 291) | type Error = Error;
function process (line 293) | fn process<OM: crate::OutputMode>(
function digit1 (line 325) | pub fn digit1<T, E: ParseError<T>>() -> impl Parser<T, Output = T, Error...
type Digit1 (line 334) | pub struct Digit1<E> {
type Output (line 342) | type Output = I;
type Error (line 344) | type Error = E;
function process (line 347) | fn process<OM: crate::OutputMode>(
function multispace0 (line 368) | pub fn multispace0<T, E: ParseError<T>>() -> impl Parser<T, Output = T, ...
type MultiSpace0 (line 381) | pub struct MultiSpace0<E> {
type Output (line 390) | type Output = I;
type Error (line 391) | type Error = Error;
function process (line 393) | fn process<OM: crate::OutputMode>(
FILE: src/character/streaming.rs
function char (line 32) | pub fn char<I, Error: ParseError<I>>(c: char) -> impl FnMut(I) -> IResul...
function satisfy (line 56) | pub fn satisfy<F, I, Error: ParseError<I>>(cond: F) -> impl FnMut(I) -> ...
function one_of (line 78) | pub fn one_of<I, T, Error: ParseError<I>>(list: T) -> impl FnMut(I) -> I...
function none_of (line 100) | pub fn none_of<I, T, Error: ParseError<I>>(list: T) -> impl FnMut(I) -> ...
function crlf (line 122) | pub fn crlf<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function not_line_ending (line 152) | pub fn not_line_ending<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function line_ending (line 197) | pub fn line_ending<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function newline (line 228) | pub fn newline<I, Error: ParseError<I>>(input: I) -> IResult<I, char, Er...
function tab (line 248) | pub fn tab<I, Error: ParseError<I>>(input: I) -> IResult<I, char, Error>
function anychar (line 266) | pub fn anychar<T, E: ParseError<T>>(input: T) -> IResult<T, char, E>
function alpha0 (line 291) | pub fn alpha0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function alpha1 (line 312) | pub fn alpha1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function digit0 (line 333) | pub fn digit0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function digit1 (line 354) | pub fn digit1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function hex_digit0 (line 375) | pub fn hex_digit0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function hex_digit1 (line 396) | pub fn hex_digit1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function oct_digit0 (line 417) | pub fn oct_digit0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function oct_digit1 (line 438) | pub fn oct_digit1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function bin_digit0 (line 459) | pub fn bin_digit0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function bin_digit1 (line 480) | pub fn bin_digit1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function alphanumeric0 (line 501) | pub fn alphanumeric0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function alphanumeric1 (line 522) | pub fn alphanumeric1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function space0 (line 543) | pub fn space0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function space1 (line 566) | pub fn space1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function multispace0 (line 593) | pub fn multispace0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function multispace1 (line 617) | pub fn multispace1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function sign (line 631) | pub(crate) fn sign<T, E: ParseError<T>>(input: T) -> IResult<T, bool, E>
function anychar_str (line 784) | fn anychar_str() {
function character (line 790) | fn character() {
function character_s (line 869) | fn character_s() {
function offset (line 932) | fn offset() {
function is_not_line_ending_bytes (line 991) | fn is_not_line_ending_bytes() {
function is_not_line_ending_str (line 1018) | fn is_not_line_ending_str() {
function hex_digit_test (line 1047) | fn hex_digit_test() {
function oct_digit_test (line 1078) | fn oct_digit_test() {
function bin_digit_test (line 1101) | fn bin_digit_test() {
function full_line_windows (line 1124) | fn full_line_windows() {
function full_line_unix (line 1134) | fn full_line_unix() {
function check_windows_lineending (line 1144) | fn check_windows_lineending() {
function check_unix_lineending (line 1151) | fn check_unix_lineending() {
function cr_lf (line 1158) | fn cr_lf() {
function end_of_line (line 1175) | fn end_of_line() {
function digit_to_i16 (line 1196) | fn digit_to_i16(input: &str) -> IResult<&str, i16> {
function digit_to_u32 (line 1230) | fn digit_to_u32(i: &str) -> IResult<&str, u32> {
FILE: src/character/tests.rs
function one_of_test (line 6) | fn one_of_test() {
function none_of_test (line 26) | fn none_of_test() {
function char_byteslice (line 39) | fn char_byteslice() {
function char_str (line 52) | fn char_str() {
FILE: src/combinator/mod.rs
function rest (line 33) | pub fn rest<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
function rest_len (line 49) | pub fn rest_len<T, E: ParseError<T>>(input: T) -> IResult<T, usize, E>
function map (line 74) | pub fn map<I, O, E: ParseError<I>, F, G>(parser: F, f: G) -> impl Parser...
function map_res (line 102) | pub fn map_res<I: Clone, O, E: ParseError<I> + FromExternalError<I, E2>,...
function map_opt (line 133) | pub fn map_opt<I: Clone, O, E: ParseError<I>, F, G>(
function map_parser (line 160) | pub fn map_parser<I, O, E: ParseError<I>, F, G>(
function flat_map (line 186) | pub fn flat_map<I, O, E: ParseError<I>, F, G, H>(
function opt (line 216) | pub fn opt<I: Clone, E: ParseError<I>, F>(
type Opt (line 226) | pub struct Opt<F> {
type Output (line 234) | type Output = Option<<F as Parser<I>>::Output>;
type Error (line 236) | type Error = <F as Parser<I>>::Error;
function process (line 239) | fn process<OM: OutputMode>(&mut self, input: I) -> PResult<OM, I, Self::...
function cond (line 271) | pub fn cond<I, E: ParseError<I>, F>(
type Cond (line 284) | pub struct Cond<F> {
type Output (line 292) | type Output = Option<<F as Parser<I>>::Output>;
type Error (line 293) | type Error = <F as Parser<I>>::Error;
function process (line 295) | fn process<OM: OutputMode>(&mut self, input: I) -> PResult<OM, I, Self::...
function peek (line 319) | pub fn peek<I: Clone, F>(
type Peek (line 329) | pub struct Peek<F> {
type Output (line 338) | type Output = <F as Parser<I>>::Output;
type Error (line 339) | type Error = <F as Parser<I>>::Error;
function process (line 341) | fn process<OM: OutputMode>(&mut self, input: I) -> PResult<OM, I, Self::...
function eof (line 366) | pub fn eof<I: Input + Clone, E: ParseError<I>>(input: I) -> IResult<I, I...
function complete (line 389) | pub fn complete<I: Clone, O, E: ParseError<I>, F>(
type MakeComplete (line 399) | pub struct MakeComplete<F> {
type Output (line 408) | type Output = <F as Parser<I>>::Output;
type Error (line 409) | type Error = <F as Parser<I>>::Error;
function process (line 411) | fn process<OM: OutputMode>(&mut self, input: I) -> PResult<OM, I, Self::...
function all_consuming (line 442) | pub fn all_consuming<I, E: ParseError<I>, F>(
type AllConsuming (line 453) | pub struct AllConsuming<F> {
type Output (line 462) | type Output = <F as Parser<I>>::Output;
type Error (line 463) | type Error = <F as Parser<I>>::Error;
function process (line 465) | fn process<OM: OutputMode>(&mut self, input: I) -> PResult<OM, I, Self::...
function verify (line 495) | pub fn verify<I: Clone, O2, E: ParseError<I>, F, G>(
type Verify (line 513) | pub struct Verify<F, G, O2: ?Sized> {
type Output (line 526) | type Output = <F as Parser<I>>::Output;
type Error (line 528) | type Error = <F as Parser<I>>::Error;
function process (line 530) | fn process<OM: OutputMode>(&mut self, input: I) -> PResult<OM, I, Self::...
function value (line 560) | pub fn value<I, O1: Clone, E: ParseError<I>, F>(
function not (line 584) | pub fn not<I: Clone, E: ParseError<I>, F>(parser: F) -> impl Parser<I, O...
type Not (line 592) | pub struct Not<F> {
type Output (line 601) | type Output = ();
type Error (line 602) | type Error = <F as Parser<I>>::Error;
function process (line 604) | fn process<OM: OutputMode>(&mut self, input: I) -> PResult<OM, I, Self::...
function recognize (line 631) | pub fn recognize<I: Clone + Offset + Input, E: ParseError<I>, F>(
type Recognize (line 641) | pub struct Recognize<F> {
type Output (line 650) | type Output = I;
type Error (line 651) | type Error = <F as Parser<I>>::Error;
function process (line 654) | fn process<OM: OutputMode>(&mut self, input: I) -> PResult<OM, I, Self::...
function consumed (line 706) | pub fn consumed<I, F, E>(
type Consumed (line 718) | pub struct Consumed<F> {
type Output (line 727) | type Output = (I, <F as Parser<I>>::Output);
type Error (line 728) | type Error = <F as Parser<I>>::Error;
function process (line 731) | fn process<OM: OutputMode>(&mut self, input: I) -> PResult<OM, I, Self::...
function cut (line 801) | pub fn cut<I, E: ParseError<I>, F>(
type Cut (line 811) | pub struct Cut<F> {
type Output (line 819) | type Output = <F as Parser<I>>::Output;
type Error (line 821) | type Error = <F as Parser<I>>::Error;
function process (line 824) | fn process<OM: OutputMode>(&mut self, input: I) -> PResult<OM, I, Self::...
function into (line 859) | pub fn into<I, O1, O2, E1, E2, F>(parser: F) -> impl Parser<I, Output = ...
function iterator (line 890) | pub fn iterator<Input, Error, F>(input: Input, f: F) -> ParserIterator<I...
type ParserIterator (line 903) | pub struct ParserIterator<I, E, F> {
function finish (line 911) | pub fn finish(mut self) -> IResult<I, (), E> {
type Item (line 925) | type Item = Output;
function next (line 927) | fn next(&mut self) -> Option<Self::Item> {
type State (line 956) | enum State<E> {
function success (line 984) | pub fn success<I, O: Clone, E: ParseError<I>>(val: O) -> impl Parser<I, ...
type Success (line 992) | pub struct Success<O: Clone, E> {
type Output (line 1002) | type Output = O;
type Error (line 1003) | type Error = E;
function process (line 1005) | fn process<OM: OutputMode>(&mut self, input: I) -> PResult<OM, I, Self::...
function fail (line 1019) | pub fn fail<I, O, E: ParseError<I>>() -> impl Parser<I, Output = O, Erro...
type Fail (line 1027) | pub struct Fail<O, E> {
type Output (line 1036) | type Output = O;
type Error (line 1037) | type Error = E;
function process (line 1039) | fn process<OM: OutputMode>(&mut self, input: I) -> PResult<OM, I, Self::...
FILE: src/combinator/tests.rs
function eof_on_slices (line 28) | fn eof_on_slices() {
function eof_on_strs (line 43) | fn eof_on_strs() {
function rest_on_slices (line 73) | fn rest_on_slices() {
function rest_on_strs (line 80) | fn rest_on_strs() {
function rest_len_on_slices (line 87) | fn rest_len_on_slices() {
type CustomError (line 109) | struct CustomError;
method from (line 94) | fn from(_: u32) -> Self {
method from_error_kind (line 100) | fn from_error_kind(_: I, _: ErrorKind) -> Self {
method append (line 104) | fn append(_: I, _: ErrorKind, _: CustomError) -> Self {
function custom_error (line 111) | fn custom_error(input: &[u8]) -> IResult<&[u8], &[u8], CustomError> {
function test_flat_map (line 117) | fn test_flat_map() {
function test_map_opt (line 126) | fn test_map_opt() {
function test_map_parser (line 139) | fn test_map_parser() {
function test_all_consuming (line 148) | fn test_all_consuming() {
function test_verify_ref (line 162) | fn test_verify_ref() {
function test_verify_alloc (line 180) | fn test_verify_alloc() {
function test_into (line 198) | fn test_into() {
function opt_test (line 212) | fn opt_test() {
function peek_test (line 226) | fn peek_test() {
function not_test (line 240) | fn not_test() {
function verify_test (line 254) | fn verify_test() {
function fail_test (line 272) | fn fail_test() {
FILE: src/error.rs
type ParseError (line 22) | pub trait ParseError<I>: Sized {
method from_error_kind (line 24) | fn from_error_kind(input: I, kind: ErrorKind) -> Self;
method append (line 29) | fn append(input: I, kind: ErrorKind, other: Self) -> Self;
method from_char (line 32) | fn from_char(input: I, _: char) -> Self {
method or (line 38) | fn or(self, other: Self) -> Self {
type ContextError (line 45) | pub trait ContextError<I>: Sized {
method add_context (line 49) | fn add_context(_input: I, _ctx: &'static str, other: Self) -> Self {
type FromExternalError (line 56) | pub trait FromExternalError<I, E> {
method from_external_error (line 59) | fn from_external_error(input: I, kind: ErrorKind, e: E) -> Self;
type Error (line 64) | pub struct Error<I> {
function new (line 73) | pub fn new(input: I, code: ErrorKind) -> Error<I> {
function from_error_kind (line 79) | fn from_error_kind(input: I, kind: ErrorKind) -> Self {
function append (line 83) | fn append(_: I, _: ErrorKind, other: Self) -> Self {
function from_external_error (line 92) | fn from_external_error(input: I, kind: ErrorKind, _e: E) -> Self {
function fmt (line 99) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
function cloned (line 107) | pub fn cloned(self) -> Error<I::Owned> {
function cloned (line 118) | pub fn cloned(self) -> Error<I::Owned> {
function copied (line 128) | pub fn copied(self) -> Error<I> {
function copied (line 138) | pub fn copied(self) -> Error<I> {
function from (line 152) | fn from(value: Error<&[u8]>) -> Self {
function from (line 163) | fn from(value: Error<&str>) -> Self {
function from_error_kind (line 174) | fn from_error_kind(input: I, kind: ErrorKind) -> Self {
function append (line 178) | fn append(_: I, _: ErrorKind, other: Self) -> Self {
function from_external_error (line 186) | fn from_external_error(input: I, kind: ErrorKind, _e: E) -> Self {
function from_error_kind (line 192) | fn from_error_kind(_: I, _: ErrorKind) -> Self {}
function append (line 194) | fn append(_: I, _: ErrorKind, _: Self) -> Self {}
function from_external_error (line 200) | fn from_external_error(_input: I, _kind: ErrorKind, _e: E) -> Self {}
function make_error (line 204) | pub fn make_error<I, E: ParseError<I>>(input: I, kind: ErrorKind) -> E {
function append_error (line 211) | pub fn append_error<I, E: ParseError<I>>(input: I, kind: ErrorKind, othe...
function context (line 218) | pub fn context<F>(context: &'static str, parser: F) -> Context<F> {
type Context (line 223) | pub struct Context<F> {
type Output (line 234) | type Output = <F as Parser<I>>::Output;
type Error (line 235) | type Error = <F as Parser<I>>::Error;
function process (line 237) | fn process<OM: OutputMode>(&mut self, input: I) -> PResult<OM, I, Self::...
type ErrorKind (line 256) | pub enum ErrorKind {
method description (line 385) | pub fn description(&self) -> &str {
function error_to_u32 (line 319) | pub fn error_to_u32(e: &ErrorKind) -> u32 {
function dbg_dmp (line 492) | pub fn dbg_dmp<'a, F, O, E: std::fmt::Debug>(
function context_test (line 514) | fn context_test() {
function clone_error (line 571) | fn clone_error() {
function copy_error (line 582) | fn copy_error() {
FILE: src/internal.rs
type IResult (line 19) | pub type IResult<I, O, E = error::Error<I>> = Result<(I, O), Err<E>>;
type Finish (line 22) | pub trait Finish<I, O, E> {
method finish (line 33) | fn finish(self) -> Result<(I, O), E>;
function finish (line 37) | fn finish(self) -> Result<(I, O), E> {
type Needed (line 50) | pub enum Needed {
method new (line 59) | pub fn new(s: usize) -> Self {
method is_known (line 67) | pub fn is_known(&self) -> bool {
method map (line 73) | pub fn map<F: Fn(NonZeroUsize) -> usize>(self, f: F) -> Needed {
type Err (line 101) | pub enum Err<Failure, Error = Failure> {
function is_incomplete (line 114) | pub fn is_incomplete(&self) -> bool {
function map (line 119) | pub fn map<E2, F>(self, f: F) -> Err<E2>
function convert (line 131) | pub fn convert<F>(e: Err<F>) -> Self
function map_input (line 141) | pub fn map_input<U, F>(self, f: F) -> Err<(U, ErrorKind)>
function map_input (line 155) | pub fn map_input<U, F>(self, f: F) -> Err<error::Error<U>>
function to_owned (line 179) | pub fn to_owned(self) -> Err<(Vec<u8>, ErrorKind)> {
function to_owned (line 188) | pub fn to_owned(self) -> Err<(String, ErrorKind)> {
function to_owned (line 197) | pub fn to_owned(self) -> Err<error::Error<Vec<u8>>> {
function to_owned (line 206) | pub fn to_owned(self) -> Err<error::Error<String>> {
function fmt (line 217) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
type Mode (line 248) | pub trait Mode {
method bind (line 253) | fn bind<T, F: FnOnce() -> T>(f: F) -> Self::Output<T>;
method map (line 256) | fn map<T, U, F: FnOnce(T) -> U>(x: Self::Output<T>, f: F) -> Self::Out...
method combine (line 259) | fn combine<T, U, V, F: FnOnce(T, U) -> V>(
type Output (line 269) | type Output<T> = T;
method bind (line 272) | fn bind<T, F: FnOnce() -> T>(f: F) -> Self::Output<T> {
method map (line 277) | fn map<T, U, F: FnOnce(T) -> U>(x: Self::Output<T>, f: F) -> Self::Out...
method combine (line 282) | fn combine<T, U, V, F: FnOnce(T, U) -> V>(
type Output (line 299) | type Output<T> = ();
method bind (line 302) | fn bind<T, F: FnOnce() -> T>(_: F) -> Self::Output<T> {}
method map (line 305) | fn map<T, U, F: FnOnce(T) -> U>(_: Self::Output<T>, _: F) -> Self::Out...
method combine (line 308) | fn combine<T, U, V, F: FnOnce(T, U) -> V>(
type Emit (line 267) | pub struct Emit;
type Check (line 297) | pub struct Check;
type PResult (line 323) | pub type PResult<OM, I, O, E> = Result<
type OutputMode (line 332) | pub trait OutputMode {
type Output (line 398) | type Output = M;
type Error (line 399) | type Error = EM;
type Incomplete (line 400) | type Incomplete = S;
type IsStreaming (line 352) | pub trait IsStreaming {
method incomplete (line 356) | fn incomplete<E, F: FnOnce() -> E>(needed: Needed, err_f: F) -> Err<E>;
method is_streaming (line 358) | fn is_streaming() -> bool;
method incomplete (line 365) | fn incomplete<E, F: FnOnce() -> E>(needed: Needed, _err_f: F) -> Err<E> {
method is_streaming (line 370) | fn is_streaming() -> bool {
method incomplete (line 379) | fn incomplete<E, F: FnOnce() -> E>(_needed: Needed, err_f: F) -> Err<E> {
method is_streaming (line 384) | fn is_streaming() -> bool {
type Streaming (line 362) | pub struct Streaming;
type Complete (line 376) | pub struct Complete;
type OutputM (line 391) | pub struct OutputM<M: Mode, EM: Mode, S: IsStreaming> {
type Parser (line 403) | pub trait Parser<Input> {
method parse (line 412) | fn parse(&mut self, input: Input) -> IResult<Input, Self::Output, Self...
method parse_complete (line 419) | fn parse_complete(&mut self, input: Input) -> IResult<Input, Self::Out...
method process (line 425) | fn process<OM: OutputMode>(
method map (line 431) | fn map<G, O2>(self, g: G) -> Map<Self, G>
method map_res (line 440) | fn map_res<G, O2, E2>(self, g: G) -> MapRes<Self, G>
method map_opt (line 450) | fn map_opt<G, O2>(self, g: G) -> MapOpt<Self, G>
method flat_map (line 459) | fn flat_map<G, H>(self, g: G) -> FlatMap<Self, G>
method and_then (line 469) | fn and_then<G>(self, g: G) -> AndThen<Self, G>
method and (line 478) | fn and<G, O2>(self, g: G) -> And<Self, G>
method or (line 487) | fn or<G>(self, g: G) -> Or<Self, G>
method into (line 497) | fn into<O2: From<Self::Output>, E2: From<Self::Error>>(self) -> Into<S...
type Output (line 513) | type Output = O;
type Error (line 514) | type Error = E;
method process (line 516) | fn process<OM: OutputMode>(&mut self, i: I) -> PResult<OM, I, Self::Outp...
type Map (line 580) | pub struct Map<F, G> {
type Output (line 588) | type Output = O2;
type Error (line 589) | type Error = E;
method source (line 235) | fn source(&self) -> Option<&(dyn Error + 'static)> {
function process (line 592) | fn process<OM: OutputMode>(&mut self, i: I) -> PResult<OM, I, Self::Outp...
type MapRes (line 601) | pub struct MapRes<F, G> {
type Output (line 613) | type Output = O2;
type Error (line 614) | type Error = <F as Parser<I>>::Error;
method source (line 235) | fn source(&self) -> Option<&(dyn Error + 'static)> {
function process (line 616) | fn process<OM: OutputMode>(&mut self, i: I) -> PResult<OM, I, Self::Outp...
type MapOpt (line 631) | pub struct MapOpt<F, G> {
type Output (line 642) | type Output = O2;
type Error (line 643) | type Error = <F as Parser<I>>::Error;
method source (line 235) | fn source(&self) -> Option<&(dyn Error + 'static)> {
function process (line 645) | fn process<OM: OutputMode>(&mut self, i: I) -> PResult<OM, I, Self::Outp...
type FlatMap (line 660) | pub struct FlatMap<F, G> {
type Output (line 673) | type Output = <H as Parser<I>>::Output;
type Error (line 674) | type Error = E;
method source (line 235) | fn source(&self) -> Option<&(dyn Error + 'static)> {
function process (line 676) | fn process<OM: OutputMode>(&mut self, i: I) -> PResult<OM, I, Self::Outp...
type AndThen (line 686) | pub struct AndThen<F, G> {
type Output (line 694) | type Output = <G as Parser<<F as Parser<I>>::Output>>::Output;
type Error (line 695) | type Error = <F as Parser<I>>::Error;
method source (line 235) | fn source(&self) -> Option<&(dyn Error + 'static)> {
function process (line 697) | fn process<OM: OutputMode>(&mut self, i: I) -> PResult<OM, I, Self::Outp...
type And (line 708) | pub struct And<F, G> {
type Output (line 716) | type Output = (<F as Parser<I>>::Output, <G as Parser<I>>::Output);
type Error (line 717) | type Error = E;
method source (line 235) | fn source(&self) -> Option<&(dyn Error + 'static)> {
function process (line 720) | fn process<OM: OutputMode>(&mut self, i: I) -> PResult<OM, I, Self::Outp...
type Or (line 729) | pub struct Or<F, G> {
type Output (line 742) | type Output = <F as Parser<I>>::Output;
type Error (line 743) | type Error = <F as Parser<I>>::Error;
method source (line 235) | fn source(&self) -> Option<&(dyn Error + 'static)> {
function process (line 745) | fn process<OM: OutputMode>(&mut self, i: I) -> PResult<OM, I, Self::Outp...
type Into (line 757) | pub struct Into<F, O2, E2> {
type Output (line 770) | type Output = O2;
type Error (line 771) | type Error = E2;
method source (line 235) | fn source(&self) -> Option<&(dyn Error + 'static)> {
function process (line 773) | fn process<OM: OutputMode>(&mut self, i: I) -> PResult<OM, I, Self::Outp...
type Either (line 784) | pub(crate) enum Either<F, G> {
type Output (line 795) | type Output = <F as Parser<I>>::Output;
type Error (line 796) | type Error = <F as Parser<I>>::Error;
method source (line 235) | fn source(&self) -> Option<&(dyn Error + 'static)> {
function process (line 799) | fn process<OM: OutputMode>(&mut self, i: I) -> PResult<OM, I, Self::Outp...
function size_test (line 826) | fn size_test() {
function err_map_test (line 837) | fn err_map_test() {
function native_tuple_test (line 843) | fn native_tuple_test() {
FILE: src/multi/mod.rs
constant MAX_INITIAL_CAPACITY_BYTES (line 34) | const MAX_INITIAL_CAPACITY_BYTES: usize = 65536;
function many0 (line 63) | pub fn many0<I, F>(
type Many0 (line 75) | pub struct Many0<F> {
type Output (line 85) | type Output = crate::lib::std::vec::Vec<<F as Parser<I>>::Output>;
type Error (line 86) | type Error = <F as Parser<I>>::Error;
function process (line 88) | fn process<OM: OutputMode>(
function many1 (line 150) | pub fn many1<I, F>(
type Many1 (line 162) | pub struct Many1<F> {
type Output (line 172) | type Output = Vec<<F as Parser<I>>::Output>;
type Error (line 173) | type Error = <F as Parser<I>>::Error;
function process (line 175) | fn process<OM: OutputMode>(
function many_till (line 251) | pub fn many_till<I, E, F, G>(
type ManyTill (line 270) | pub struct ManyTill<F, G, E> {
type Output (line 284) | type Output = (Vec<<F as Parser<I>>::Output>, <G as Parser<I>>::Output);
type Error (line 285) | type Error = E;
function process (line 287) | fn process<OM: OutputMode>(
function separated_list0 (line 358) | pub fn separated_list0<I, E, F, G>(
type SeparatedList0 (line 376) | pub struct SeparatedList0<F, G> {
type Output (line 388) | type Output = Vec<<F as Parser<I>>::Output>;
type Error (line 389) | type Error = <F as Parser<I>>::Error;
function process (line 391) | fn process<OM: OutputMode>(
function separated_list1 (line 479) | pub fn separated_list1<I, E, F, G>(
type SeparatedList1 (line 494) | pub struct SeparatedList1<F, G> {
type Output (line 506) | type Output = Vec<<F as Parser<I>>::Output>;
type Error (line 507) | type Error = <F as Parser<I>>::Error;
function process (line 509) | fn process<OM: OutputMode>(
function many_m_n (line 595) | pub fn many_m_n<I, E, F>(
type ManyMN (line 610) | pub struct ManyMN<F> {
type Output (line 622) | type Output = Vec<<F as Parser<I>>::Output>;
type Error (line 623) | type Error = <F as Parser<I>>::Error;
function process (line 625) | fn process<OM: OutputMode>(
function many0_count (line 702) | pub fn many0_count<I, E, F>(parser: F) -> impl Parser<I, Output = usize,...
type Many0Count (line 712) | pub struct Many0Count<F> {
type Output (line 721) | type Output = usize;
type Error (line 722) | type Error = <F as Parser<I>>::Error;
function process (line 724) | fn process<OM: OutputMode>(
function many1_count (line 783) | pub fn many1_count<I, E, F>(parser: F) -> impl Parser<I, Output = usize,...
type Many1Count (line 793) | pub struct Many1Count<F> {
type Output (line 802) | type Output = usize;
type Error (line 803) | type Error = <F as Parser<I>>::Error;
function process (line 805) | fn process<OM: OutputMode>(
function count (line 874) | pub fn count<I, F>(
type Count (line 887) | pub struct Count<F> {
type Output (line 898) | type Output = Vec<<F as Parser<I>>::Output>;
type Error (line 899) | type Error = <F as Parser<I>>::Error;
function process (line 901) | fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Sel...
function fill (line 958) | pub fn fill<'a, I, E, F>(
type Fill (line 971) | pub struct Fill<'a, F, O> {
type Output (line 981) | type Output = ();
type Error (line 982) | type Error = <F as Parser<I>>::Error;
function process (line 984) | fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Sel...
function fold_many0 (line 1044) | pub fn fold_many0<I, E, F, G, H, R>(
type FoldMany0 (line 1065) | pub struct FoldMany0<F, G, Init, R> {
type Output (line 1079) | type Output = R;
type Error (line 1080) | type Error = <F as Parser<I>>::Error;
function process (line 1082) | fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Sel...
function fold_many1 (line 1148) | pub fn fold_many1<I, E, F, G, H, R>(
type FoldMany1 (line 1169) | pub struct FoldMany1<F, G, Init, R> {
type Output (line 1183) | type Output = R;
type Error (line 1184) | type Error = <F as Parser<I>>::Error;
function process (line 1186) | fn process<OM: OutputMode>(&mut self, i: I) -> crate::PResult<OM, I, Sel...
function fold_many_m_n (line 1268) | pub fn fold_many_m_n<I, E, F, G, H, R>(
type FoldManyMN (line 1293) | pub struct FoldManyMN<F, G, Init, R> {
type Output (line 1309) | type Output = R;
type Error (line 1310) | type Error = <F as Parser<I>>::Error;
function process (line 1312) | fn process<OM: OutputMode>(
function length_data (line 1373) | pub fn length_data<I, E, F>(f: F) -> impl Parser<I, Output = I, Error = E>
function length_value (line 1405) | pub fn length_value<I, E, F, G>(
type LengthValue (line 1429) | pub struct LengthValue<F, G, E> {
type Output (line 1443) | type Output = <G as Parser<I>>::Output;
type Error (line 1444) | type Error = E;
function process (line 1446) | fn process<OM: OutputMode>(
function length_count (line 1497) | pub fn length_count<I, E, F, G>(
type LengthCount (line 1517) | pub struct LengthCount<F, G, E> {
type Output (line 1532) | type Output = Vec<<G as Parser<I>>::Output>;
type Error (line 1533) | type Error = E;
function process (line 1535) | fn process<OM: OutputMode>(
function many (line 1665) | pub fn many<I, E, Collection, F, G>(
type Many (line 1684) | pub struct Many<F, R, Collection> {
type Output (line 1697) | type Output = Collection;
type Error (line 1698) | type Error = <F as Parser<I>>::Error;
function process (line 1700) | fn process<OM: OutputMode>(
function fold (line 1787) | pub fn fold<I, E, F, G, H, J, R>(
type Fold (line 1810) | pub struct Fold<F, G, H, Range> {
type Output (line 1825) | type Output = Res;
type Error (line 1826) | type Error = <F as Parser<I>>::Error;
function process (line 1828) | fn process<OM: OutputMode>(
FILE: src/multi/tests.rs
function separated_list0_test (line 23) | fn separated_list0_test() {
function separated_list1_test (line 78) | fn separated_list1_test() {
function many0_test (line 120) | fn many0_test() {
function many1_test (line 148) | fn many1_test() {
function many_till_test (line 171) | fn many_till_test() {
function infinite_many (line 197) | fn infinite_many() {
function many_m_n_test (line 221) | fn many_m_n_test() {
function count_test (line 247) | fn count_test() {
function count_zero (line 281) | fn count_zero() {
type NilError (line 319) | pub struct NilError;
method from (line 322) | fn from(_: (I, ErrorKind)) -> Self {
method from_error_kind (line 328) | fn from_error_kind(_: I, _: ErrorKind) -> NilError {
method append (line 331) | fn append(_: I, _: ErrorKind, _: NilError) -> NilError {
function number (line 336) | fn number(i: &[u8]) -> IResult<&[u8], u32> {
function length_count_test (line 344) | fn length_count_test() {
function length_data_test (line 366) | fn length_data_test() {
function length_value_test (line 384) | fn length_value_test() {
function fold_many0_test (line 423) | fn fold_many0_test() {
function fold_many1_test (line 455) | fn fold_many1_test() {
function fold_many_m_n_test (line 482) | fn fold_many_m_n_test() {
function many0_count_test (line 511) | fn many0_count_test() {
function many1_count_test (line 529) | fn many1_count_test() {
function many_test (line 552) | fn many_test() {
function fold_test (line 702) | fn fold_test() {
FILE: src/number/complete.rs
function be_u8 (line 30) | pub fn be_u8<I, E: ParseError<I>>(input: I) -> IResult<I, u8, E>
function be_u16 (line 53) | pub fn be_u16<I, E: ParseError<I>>(input: I) -> IResult<I, u16, E>
function be_u24 (line 76) | pub fn be_u24<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
function be_u32 (line 99) | pub fn be_u32<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
function be_u64 (line 122) | pub fn be_u64<I, E: ParseError<I>>(input: I) -> IResult<I, u64, E>
function be_u128 (line 145) | pub fn be_u128<I, E: ParseError<I>>(input: I) -> IResult<I, u128, E>
function be_uint (line 153) | fn be_uint<I, Uint, E: ParseError<I>>(input: I, bound: usize) -> IResult...
function be_i8 (line 177) | pub fn be_i8<I, E: ParseError<I>>(input: I) -> IResult<I, i8, E>
function be_i16 (line 200) | pub fn be_i16<I, E: ParseError<I>>(input: I) -> IResult<I, i16, E>
function be_i24 (line 223) | pub fn be_i24<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E>
function be_i32 (line 255) | pub fn be_i32<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E>
function be_i64 (line 278) | pub fn be_i64<I, E: ParseError<I>>(input: I) -> IResult<I, i64, E>
function be_i128 (line 301) | pub fn be_i128<I, E: ParseError<I>>(input: I) -> IResult<I, i128, E>
function le_u8 (line 324) | pub fn le_u8<I, E: ParseError<I>>(input: I) -> IResult<I, u8, E>
function le_u16 (line 347) | pub fn le_u16<I, E: ParseError<I>>(input: I) -> IResult<I, u16, E>
function le_u24 (line 370) | pub fn le_u24<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
function le_u32 (line 393) | pub fn le_u32<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
function le_u64 (line 416) | pub fn le_u64<I, E: ParseError<I>>(input: I) -> IResult<I, u64, E>
function le_u128 (line 439) | pub fn le_u128<I, E: ParseError<I>>(input: I) -> IResult<I, u128, E>
function le_uint (line 447) | fn le_uint<I, Uint, E: ParseError<I>>(input: I, bound: usize) -> IResult...
function le_i8 (line 471) | pub fn le_i8<I, E: ParseError<I>>(input: I) -> IResult<I, i8, E>
function le_i16 (line 494) | pub fn le_i16<I, E: ParseError<I>>(input: I) -> IResult<I, i16, E>
function le_i24 (line 517) | pub fn le_i24<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E>
function le_i32 (line 549) | pub fn le_i32<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E>
function le_i64 (line 572) | pub fn le_i64<I, E: ParseError<I>>(input: I) -> IResult<I, i64, E>
function le_i128 (line 595) | pub fn le_i128<I, E: ParseError<I>>(input: I) -> IResult<I, i128, E>
function u8 (line 619) | pub fn u8<I, E: ParseError<I>>(input: I) -> IResult<I, u8, E>
function u16 (line 652) | pub fn u16<I, E: ParseError<I>>(
function u24 (line 686) | pub fn u24<I, E: ParseError<I>>(
function u32 (line 720) | pub fn u32<I, E: ParseError<I>>(
function u64 (line 754) | pub fn u64<I, E: ParseError<I>>(
function u128 (line 788) | pub fn u128<I, E: ParseError<I>>(
function i8 (line 814) | pub fn i8<I, E: ParseError<I>>(i: I) -> IResult<I, i8, E>
function i16 (line 846) | pub fn i16<I, E: ParseError<I>>(
function i24 (line 880) | pub fn i24<I, E: ParseError<I>>(
function i32 (line 914) | pub fn i32<I, E: ParseError<I>>(
function i64 (line 948) | pub fn i64<I, E: ParseError<I>>(
function i128 (line 982) | pub fn i128<I, E: ParseError<I>>(
function be_f32 (line 1007) | pub fn be_f32<I, E: ParseError<I>>(input: I) -> IResult<I, f32, E>
function be_f64 (line 1033) | pub fn be_f64<I, E: ParseError<I>>(input: I) -> IResult<I, f64, E>
function le_f32 (line 1059) | pub fn le_f32<I, E: ParseError<I>>(input: I) -> IResult<I, f32, E>
function le_f64 (line 1085) | pub fn le_f64<I, E: ParseError<I>>(input: I) -> IResult<I, f64, E>
function f32 (line 1120) | pub fn f32<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn...
function f64 (line 1159) | pub fn f64<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn...
function hex_u32 (line 1190) | pub fn hex_u32<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
function recognize_float (line 1245) | pub fn recognize_float<T, E:ParseError<T>>(input: T) -> IResult<T, T, E>
function recognize_float_or_exceptions (line 1267) | pub fn recognize_float_or_exceptions<T, E: ParseError<T>>(input: T) -> I...
function recognize_float_parts (line 1304) | pub fn recognize_float_parts<T, E: ParseError<T>>(input: T) -> IResult<T...
function float (line 1408) | pub fn float<T, E: ParseError<T>>(input: T) -> IResult<T, f32, E>
function double (line 1458) | pub fn double<T, E: ParseError<T>>(input: T) -> IResult<T, f64, E>
function i8_tests (line 1506) | fn i8_tests() {
function be_i8_tests (line 1514) | fn be_i8_tests() {
function be_i16_tests (line 1522) | fn be_i16_tests() {
function be_u24_tests (line 1530) | fn be_u24_tests() {
function be_i24_tests (line 1540) | fn be_i24_tests() {
function be_i32_tests (line 1550) | fn be_i32_tests() {
function be_i64_tests (line 1564) | fn be_i64_tests() {
function be_i128_tests (line 1584) | fn be_i128_tests() {
function le_i8_tests (line 1630) | fn le_i8_tests() {
function le_i16_tests (line 1638) | fn le_i16_tests() {
function le_u24_tests (line 1646) | fn le_u24_tests() {
function le_i24_tests (line 1656) | fn le_i24_tests() {
function le_i32_tests (line 1666) | fn le_i32_tests() {
function le_i64_tests (line 1680) | fn le_i64_tests() {
function le_i128_tests (line 1700) | fn le_i128_tests() {
function be_f32_tests (line 1746) | fn be_f32_tests() {
function be_f64_tests (line 1755) | fn be_f64_tests() {
function le_f32_tests (line 1767) | fn le_f32_tests() {
function le_f64_tests (line 1776) | fn le_f64_tests() {
function hex_u32_tests (line 1788) | fn hex_u32_tests() {
function float_test (line 1809) | fn float_test() {
function configurable_endianness (line 1862) | fn configurable_endianness() {
function parse_f64 (line 1945) | fn parse_f64(i: &str) -> IResult<&str, f64, ()> {
FILE: src/number/mod.rs
type Endianness (line 23) | pub enum Endianness {
function be_uint (line 37) | fn be_uint<I, Uint, E: ParseError<I>>(bound: usize) -> impl Parser<I, Ou...
type BeUint (line 50) | struct BeUint<Uint, E> {
type Output (line 61) | type Output = Uint;
type Error (line 62) | type Error = E;
function process (line 65) | fn process<OM: crate::OutputMode>(
function be_u8 (line 114) | pub fn be_u8<I, E: ParseError<I>>() -> impl Parser<I, Output = u8, Error...
function be_u16 (line 135) | pub fn be_u16<I, E: ParseError<I>>() -> impl Parser<I, Output = u16, Err...
function be_u24 (line 156) | pub fn be_u24<I, E: ParseError<I>>() -> impl Parser<I, Output = u32, Err...
function be_u32 (line 177) | pub fn be_u32<I, E: ParseError<I>>() -> impl Parser<I, Output = u32, Err...
function be_u64 (line 198) | pub fn be_u64<I, E: ParseError<I>>() -> impl Parser<I, Output = u64, Err...
function be_u128 (line 219) | pub fn be_u128<I, E: ParseError<I>>() -> impl Parser<I, Output = u128, E...
function be_i8 (line 239) | pub fn be_i8<I, E: ParseError<I>>() -> impl Parser<I, Output = i8, Error...
function be_i16 (line 258) | pub fn be_i16<I, E: ParseError<I>>() -> impl Parser<I, Output = i16, Err...
function be_i24 (line 277) | pub fn be_i24<I, E: ParseError<I>>() -> impl Parser<I, Output = i32, Err...
function be_i32 (line 303) | pub fn be_i32<I, E: ParseError<I>>() -> impl Parser<I, Output = i32, Err...
function be_i64 (line 322) | pub fn be_i64<I, E: ParseError<I>>() -> impl Parser<I, Output = i64, Err...
function be_i128 (line 341) | pub fn be_i128<I, E: ParseError<I>>() -> impl Parser<I, Output = i128, E...
function le_uint (line 353) | fn le_uint<I, Uint, E: ParseError<I>>(bound: usize) -> impl Parser<I, Ou...
type LeUint (line 366) | struct LeUint<Uint, E> {
type Output (line 377) | type Output = Uint;
type Error (line 378) | type Error = E;
function process (line 381) | fn process<OM: crate::OutputMode>(
function le_u8 (line 420) | pub fn le_u8<I, E: ParseError<I>>() -> impl Parser<I, Output = u8, Error...
function le_u16 (line 442) | pub fn le_u16<I, E: ParseError<I>>() -> impl Parser<I, Output = u16, Err...
function le_u24 (line 463) | pub fn le_u24<I, E: ParseError<I>>() -> impl Parser<I, Output = u32, Err...
function le_u32 (line 484) | pub fn le_u32<I, E: ParseError<I>>() -> impl Parser<I, Output = u32, Err...
function le_u64 (line 505) | pub fn le_u64<I, E: ParseError<I>>() -> impl Parser<I, Output = u64, Err...
function le_u128 (line 526) | pub fn le_u128<I, E: ParseError<I>>() -> impl Parser<I, Output = u128, E...
function le_i8 (line 545) | pub fn le_i8<I, E: ParseError<I>>() -> impl Parser<I, Output = i8, Error...
function le_i16 (line 566) | pub fn le_i16<I, E: ParseError<I>>() -> impl Parser<I, Output = i16, Err...
function le_i24 (line 587) | pub fn le_i24<I, E: ParseError<I>>() -> impl Parser<I, Output = i32, Err...
function le_i32 (line 615) | pub fn le_i32<I, E: ParseError<I>>() -> impl Parser<I, Output = i32, Err...
function le_i64 (line 636) | pub fn le_i64<I, E: ParseError<I>>() -> impl Parser<I, Output = i64, Err...
function le_i128 (line 657) | pub fn le_i128<I, E: ParseError<I>>() -> impl Parser<I, Output = i128, E...
function u8 (line 680) | pub fn u8<I, E: ParseError<I>>() -> impl Parser<I, Output = u8, Error = E>
function u16 (line 712) | pub fn u16<I, E: ParseError<I>>(
function u24 (line 752) | pub fn u24<I, E: ParseError<I>>(
function u32 (line 792) | pub fn u32<I, E: ParseError<I>>(
function u64 (line 832) | pub fn u64<I, E: ParseError<I>>(
function u128 (line 872) | pub fn u128<I, E: ParseError<I>>(
function i8 (line 905) | pub fn i8<I, E: ParseError<I>>() -> impl Parser<I, Output = i8, Error = E>
function i16 (line 937) | pub fn i16<I, E: ParseError<I>>(
function i24 (line 978) | pub fn i24<I, E: ParseError<I>>(
function i32 (line 1019) | pub fn i32<I, E: ParseError<I>>(
function i64 (line 1060) | pub fn i64<I, E: ParseError<I>>(
function i128 (line 1101) | pub fn i128<I, E: ParseError<I>>(
function be_f32 (line 1132) | pub fn be_f32<I, E: ParseError<I>>() -> impl Parser<I, Output = f32, Err...
function be_f64 (line 1154) | pub fn be_f64<I, E: ParseError<I>>() -> impl Parser<I, Output = f64, Err...
function le_f32 (line 1176) | pub fn le_f32<I, E: ParseError<I>>() -> impl Parser<I, Output = f32, Err...
function le_f64 (line 1198) | pub fn le_f64<I, E: ParseError<I>>() -> impl Parser<I, Output = f64, Err...
function f32 (line 1230) | pub fn f32<I, E: ParseError<I>>(
function f64 (line 1271) | pub fn f64<I, E: ParseError<I>>(
function recognize_float (line 1305) | pub fn recognize_float<T, E:ParseError<T>>() -> impl Parser<T, Output=T,...
function recognize_float_or_exceptions (line 1326) | pub fn recognize_float_or_exceptions<T, E: ParseError<T>>() -> impl Pars...
function float (line 1350) | pub fn float<T, E: ParseError<T>>() -> impl Parser<T, Output = f32, Erro...
function double (line 1365) | pub fn double<T, E: ParseError<T>>() -> impl Parser<T, Output = f64, Err...
type Float (line 1380) | struct Float<O, E> {
type Output (line 1393) | type Output = O;
type Error (line 1394) | type Error = E;
function process (line 1396) | fn process<OM: crate::OutputMode>(
function float_test (line 1427) | fn float_test() {
FILE: src/number/streaming.rs
function be_u8 (line 28) | pub fn be_u8<I, E: ParseError<I>>(input: I) -> IResult<I, u8, E>
function be_u16 (line 51) | pub fn be_u16<I, E: ParseError<I>>(input: I) -> IResult<I, u16, E>
function be_u24 (line 74) | pub fn be_u24<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
function be_u32 (line 97) | pub fn be_u32<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
function be_u64 (line 120) | pub fn be_u64<I, E: ParseError<I>>(input: I) -> IResult<I, u64, E>
function be_u128 (line 142) | pub fn be_u128<I, E: ParseError<I>>(input: I) -> IResult<I, u128, E>
function be_uint (line 150) | fn be_uint<I, Uint, E: ParseError<I>>(input: I, bound: usize) -> IResult...
function be_i8 (line 171) | pub fn be_i8<I, E: ParseError<I>>(input: I) -> IResult<I, i8, E>
function be_i16 (line 191) | pub fn be_i16<I, E: ParseError<I>>(input: I) -> IResult<I, i16, E>
function be_i24 (line 211) | pub fn be_i24<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E>
function be_i32 (line 240) | pub fn be_i32<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E>
function be_i64 (line 261) | pub fn be_i64<I, E: ParseError<I>>(input: I) -> IResult<I, i64, E>
function be_i128 (line 281) | pub fn be_i128<I, E: ParseError<I>>(input: I) -> IResult<I, i128, E>
function le_u8 (line 301) | pub fn le_u8<I, E: ParseError<I>>(input: I) -> IResult<I, u8, E>
function le_u16 (line 324) | pub fn le_u16<I, E: ParseError<I>>(input: I) -> IResult<I, u16, E>
function le_u24 (line 347) | pub fn le_u24<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
function le_u32 (line 370) | pub fn le_u32<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
function le_u64 (line 393) | pub fn le_u64<I, E: ParseError<I>>(input: I) -> IResult<I, u64, E>
function le_u128 (line 416) | pub fn le_u128<I, E: ParseError<I>>(input: I) -> IResult<I, u128, E>
function le_uint (line 424) | fn le_uint<I, Uint, E: ParseError<I>>(input: I, bound: usize) -> IResult...
function le_i8 (line 445) | pub fn le_i8<I, E: ParseError<I>>(input: I) -> IResult<I, i8, E>
function le_i16 (line 468) | pub fn le_i16<I, E: ParseError<I>>(input: I) -> IResult<I, i16, E>
function le_i24 (line 491) | pub fn le_i24<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E>
function le_i32 (line 523) | pub fn le_i32<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E>
function le_i64 (line 546) | pub fn le_i64<I, E: ParseError<I>>(input: I) -> IResult<I, i64, E>
function le_i128 (line 569) | pub fn le_i128<I, E: ParseError<I>>(input: I) -> IResult<I, i128, E>
function u8 (line 593) | pub fn u8<I, E: ParseError<I>>(input: I) -> IResult<I, u8, E>
function u16 (line 626) | pub fn u16<I, E: ParseError<I>>(
function u24 (line 660) | pub fn u24<I, E: ParseError<I>>(
function u32 (line 694) | pub fn u32<I, E: ParseError<I>>(
function u64 (line 728) | pub fn u64<I, E: ParseError<I>>(
function u128 (line 762) | pub fn u128<I, E: ParseError<I>>(
function i8 (line 788) | pub fn i8<I, E: ParseError<I>>(i: I) -> IResult<I, i8, E>
function i16 (line 820) | pub fn i16<I, E: ParseError<I>>(
function i24 (line 854) | pub fn i24<I, E: ParseError<I>>(
function i32 (line 888) | pub fn i32<I, E: ParseError<I>>(
function i64 (line 922) | pub fn i64<I, E: ParseError<I>>(
function i128 (line 956) | pub fn i128<I, E: ParseError<I>>(
function be_f32 (line 980) | pub fn be_f32<I, E: ParseError<I>>(input: I) -> IResult<I, f32, E>
function be_f64 (line 1005) | pub fn be_f64<I, E: ParseError<I>>(input: I) -> IResult<I, f64, E>
function le_f32 (line 1030) | pub fn le_f32<I, E: ParseError<I>>(input: I) -> IResult<I, f32, E>
function le_f64 (line 1055) | pub fn le_f64<I, E: ParseError<I>>(input: I) -> IResult<I, f64, E>
function f32 (line 1090) | pub fn f32<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn...
function f64 (line 1129) | pub fn f64<I, E: ParseError<I>>(endian: crate::number::Endianness) -> fn...
function hex_u32 (line 1159) | pub fn hex_u32<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
function recognize_float (line 1212) | pub fn recognize_float<T, E:ParseError<T>>(input: T) -> IResult<T, T, E>
function recognize_float_or_exceptions (line 1234) | pub fn recognize_float_or_exceptions<T, E: ParseError<T>>(input: T) -> I...
function recognize_float_parts (line 1271) | pub fn recognize_float_parts<T, E: ParseError<T>>(input: T) -> IResult<T...
function float (line 1377) | pub fn float<T, E: ParseError<T>>(input: T) -> IResult<T, f32, E>
function double (line 1427) | pub fn double<T, E: ParseError<T>>(input: T) -> IResult<T, f64, E>
function i8_tests (line 1474) | fn i8_tests() {
function i16_tests (line 1483) | fn i16_tests() {
function u24_tests (line 1493) | fn u24_tests() {
function i24_tests (line 1509) | fn i24_tests() {
function i32_tests (line 1525) | fn i32_tests() {
function i64_tests (line 1549) | fn i64_tests() {
function i128_tests (line 1595) | fn i128_tests() {
function le_i8_tests (line 1704) | fn le_i8_tests() {
function le_i16_tests (line 1712) | fn le_i16_tests() {
function le_u16_test (line 1720) | fn le_u16_test() {
function le_u24_tests (line 1727) | fn le_u24_tests() {
function le_i24_tests (line 1737) | fn le_i24_tests() {
function le_i32_tests (line 1747) | fn le_i32_tests() {
function le_u32_test (line 1761) | fn le_u32_test() {
function le_i64_tests (line 1774) | fn le_i64_tests() {
function le_i128_tests (line 1794) | fn le_i128_tests() {
function be_f32_tests (line 1840) | fn be_f32_tests() {
function be_f64_tests (line 1849) | fn be_f64_tests() {
function le_f32_tests (line 1861) | fn le_f32_tests() {
function le_f64_tests (line 1870) | fn le_f64_tests() {
function hex_u32_tests (line 1882) | fn hex_u32_tests() {
function float_test (line 1903) | fn float_test() {
function configurable_endianness (line 1957) | fn configurable_endianness() {
function parse_f64 (line 2040) | fn parse_f64(i: &str) -> IResult<&str, f64, ()> {
FILE: src/sequence/mod.rs
function pair (line 30) | pub fn pair<I, O1, O2, E: ParseError<I>, F, G>(
function preceded (line 61) | pub fn preceded<I, O, E: ParseError<I>, F, G>(
type Preceded (line 76) | pub struct Preceded<F, G> {
type Output (line 84) | type Output = <G as Parser<I>>::Output;
type Error (line 85) | type Error = E;
function process (line 88) | fn process<OM: OutputMode>(&mut self, i: I) -> PResult<OM, I, Self::Outp...
function terminated (line 118) | pub fn terminated<I, O, E: ParseError<I>, F, G>(
type Terminated (line 133) | pub struct Terminated<F, G> {
type Output (line 141) | type Output = <F as Parser<I>>::Output;
type Error (line 142) | type Error = E;
function process (line 145) | fn process<OM: OutputMode>(&mut self, i: I) -> PResult<OM, I, Self::Outp...
function separated_pair (line 177) | pub fn separated_pair<I, O1, O2, E: ParseError<I>, F, G, H>(
function delimited (line 212) | pub fn delimited<I, O, E: ParseError<I>, F, G, H>(
type Tuple (line 230) | pub trait Tuple<I, O, E> {
method parse_tuple (line 232) | fn parse_tuple(&mut self, input: I) -> IResult<I, O, E>;
function parse_tuple (line 239) | fn parse_tuple(&mut self, input: Input) -> IResult<Input, (Output,), Err...
function parse_tuple (line 299) | fn parse_tuple(&mut self, input: I) -> IResult<I, (), E> {
function tuple (line 317) | pub fn tuple<I, O, E: ParseError<I>, List: Tuple<I, O, E>>(
FILE: src/sequence/tests.rs
function single_element_tuples (line 8) | fn single_element_tuples() {
function complete (line 63) | fn complete() {
function pair_test (line 79) | fn pair_test() {
function separated_pair_test (line 111) | fn separated_pair_test() {
function preceded_test (line 143) | fn preceded_test() {
function terminated_test (line 175) | fn terminated_test() {
function delimited_test (line 207) | fn delimited_test() {
function tuple_test (line 250) | fn tuple_test() {
function unit_type (line 270) | fn unit_type() {
FILE: src/str.rs
function tagtr_succeed (line 12) | fn tagtr_succeed() {
function tagtr_incomplete (line 39) | fn tagtr_incomplete() {
function tagtr_error (line 59) | fn tagtr_error() {
function take_s_succeed (line 76) | fn take_s_succeed() {
function take_until_succeed (line 105) | fn take_until_succeed() {
function take_s_incomplete (line 137) | fn take_s_incomplete() {
function is_alphabetic (line 155) | fn is_alphabetic(c: char) -> bool {
function take_while (line 160) | fn take_while() {
function take_while1 (line 178) | fn take_while1() {
function take_till_s_succeed (line 199) | fn take_till_s_succeed() {
function take_while_succeed_none (line 232) | fn take_while_succeed_none() {
function is_not_succeed (line 267) | fn is_not_succeed() {
function take_while_succeed_some (line 298) | fn take_while_succeed_some() {
function is_not_fail (line 333) | fn is_not_fail() {
function take_while1_succeed (line 349) | fn take_while1_succeed() {
function take_until_incomplete (line 384) | fn take_until_incomplete() {
function is_a_succeed (line 402) | fn is_a_succeed() {
function take_while1_fail (line 433) | fn take_while1_fail() {
function is_a_fail (line 454) | fn is_a_fail() {
function take_until_error (line 470) | fn take_until_error() {
function recognize_is_a (line 489) | fn recognize_is_a() {
function utf8_indexing (line 508) | fn utf8_indexing() {
function case_insensitive (line 518) | fn case_insensitive() {
FILE: src/traits.rs
type Input (line 24) | pub trait Input: Clone + Sized {
method input_len (line 40) | fn input_len(&self) -> usize;
method take (line 43) | fn take(&self, index: usize) -> Self;
method take_from (line 45) | fn take_from(&self, index: usize) -> Self;
method take_split (line 47) | fn take_split(&self, index: usize) -> (Self, Self);
method position (line 50) | fn position<P>(&self, predicate: P) -> Option<usize>
method iter_elements (line 55) | fn iter_elements(&self) -> Self::Iter;
method iter_indices (line 57) | fn iter_indices(&self) -> Self::IterIndices;
method slice_index (line 60) | fn slice_index(&self, count: usize) -> Result<usize, Needed>;
method split_at_position (line 66) | fn split_at_position<P, E: ParseError<Self>>(&self, predicate: P) -> I...
method split_at_position1 (line 82) | fn split_at_position1<P, E: ParseError<Self>>(
method split_at_position_complete (line 101) | fn split_at_position_complete<P, E: ParseError<Self>>(
method split_at_position1_complete (line 120) | fn split_at_position1_complete<P, E: ParseError<Self>>(
method split_at_position_mode (line 141) | fn split_at_position_mode<OM: crate::OutputMode, P, E: ParseError<Self>>(
method split_at_position_mode1 (line 162) | fn split_at_position_mode1<OM: crate::OutputMode, P, E: ParseError<Sel...
type Item (line 194) | type Item = u8;
type Iter (line 195) | type Iter = Copied<Iter<'a, u8>>;
type IterIndices (line 196) | type IterIndices = Enumerate<Self::Iter>;
method input_len (line 198) | fn input_len(&self) -> usize {
method take (line 203) | fn take(&self, index: usize) -> Self {
method take_from (line 207) | fn take_from(&self, index: usize) -> Self {
method take_split (line 211) | fn take_split(&self, index: usize) -> (Self, Self) {
method position (line 217) | fn position<P>(&self, predicate: P) -> Option<usize>
method iter_elements (line 225) | fn iter_elements(&self) -> Self::Iter {
method iter_indices (line 230) | fn iter_indices(&self) -> Self::IterIndices {
method slice_index (line 235) | fn slice_index(&self, count: usize) -> Result<usize, Needed> {
method split_at_position (line 244) | fn split_at_position<P, E: ParseError<Self>>(&self, predicate: P) -> I...
method split_at_position1 (line 255) | fn split_at_position1<P, E: ParseError<Self>>(
method split_at_position_complete (line 270) | fn split_at_position_complete<P, E: ParseError<Self>>(
method split_at_position1_complete (line 284) | fn split_at_position1_complete<P, E: ParseError<Self>>(
method split_at_position_mode (line 307) | fn split_at_position_mode<OM: crate::OutputMode, P, E: ParseError<Self>>(
method split_at_position_mode1 (line 331) | fn split_at_position_mode1<OM: crate::OutputMode, P, E: ParseError<Sel...
type Item (line 359) | type Item = char;
type Iter (line 360) | type Iter = Chars<'a>;
type IterIndices (line 361) | type IterIndices = CharIndices<'a>;
method input_len (line 363) | fn input_len(&self) -> usize {
method take (line 368) | fn take(&self, index: usize) -> Self {
method take_from (line 373) | fn take_from(&self, index: usize) -> Self {
method take_split (line 379) | fn take_split(&self, index: usize) -> (Self, Self) {
method position (line 384) | fn position<P>(&self, predicate: P) -> Option<usize>
method iter_elements (line 392) | fn iter_elements(&self) -> Self::Iter {
method iter_indices (line 397) | fn iter_indices(&self) -> Self::IterIndices {
method slice_index (line 402) | fn slice_index(&self, count: usize) -> Result<usize, Needed> {
method split_at_position (line 417) | fn split_at_position<P, E: ParseError<Self>>(&self, predicate: P) -> I...
method split_at_position1 (line 432) | fn split_at_position1<P, E: ParseError<Self>>(
method split_at_position_complete (line 452) | fn split_at_position_complete<P, E: ParseError<Self>>(
method split_at_position1_complete (line 470) | fn split_at_position1_complete<P, E: ParseError<Self>>(
method split_at_position_mode (line 499) | fn split_at_position_mode<OM: crate::OutputMode, P, E: ParseError<Self>>(
method split_at_position_mode1 (line 532) | fn split_at_position_mode1<OM: crate::OutputMode, P, E: ParseError<Sel...
type Offset (line 569) | pub trait Offset {
method offset (line 573) | fn offset(&self, second: &Self) -> usize;
method offset (line 577) | fn offset(&self, second: &Self) -> usize {
method offset (line 586) | fn offset(&self, second: &Self) -> usize {
method offset (line 595) | fn offset(&self, second: &Self) -> usize {
method offset (line 604) | fn offset(&self, second: &Self) -> usize {
type AsBytes (line 613) | pub trait AsBytes {
method as_bytes (line 615) | fn as_bytes(&self) -> &[u8];
method as_bytes (line 620) | fn as_bytes(&self) -> &[u8] {
method as_bytes (line 627) | fn as_bytes(&self) -> &[u8] {
method as_bytes (line 634) | fn as_bytes(&self) -> &[u8] {
method as_bytes (line 641) | fn as_bytes(&self) -> &[u8] {
method as_bytes (line 648) | fn as_bytes(&self) -> &[u8] {
method as_bytes (line 655) | fn as_bytes(&self) -> &[u8] {
type AsChar (line 662) | pub trait AsChar: Copy {
method as_char (line 664) | fn as_char(self) -> char;
method is_alpha (line 670) | fn is_alpha(self) -> bool;
method is_alphanum (line 674) | fn is_alphanum(self) -> bool;
method is_dec_digit (line 676) | fn is_dec_digit(self) -> bool;
method is_hex_digit (line 678) | fn is_hex_digit(self) -> bool;
method is_oct_digit (line 680) | fn is_oct_digit(self) -> bool;
method is_bin_digit (line 682) | fn is_bin_digit(self) -> bool;
method len (line 684) | fn len(self) -> usize;
method is_space (line 686) | fn is_space(self) -> bool;
method is_newline (line 688) | fn is_newline(self) -> bool;
method as_char (line 693) | fn as_char(self) -> char {
method is_alpha (line 697) | fn is_alpha(self) -> bool {
method is_alphanum (line 701) | fn is_alphanum(self) -> bool {
method is_dec_digit (line 705) | fn is_dec_digit(self) -> bool {
method is_hex_digit (line 709) | fn is_hex_digit(self) -> bool {
method is_oct_digit (line 713) | fn is_oct_digit(self) -> bool {
method is_bin_digit (line 717) | fn is_bin_digit(self) -> bool {
method len (line 721) | fn len(self) -> usize {
method is_space (line 725) | fn is_space(self) -> bool {
method is_newline (line 728) | fn is_newline(self) -> bool {
method as_char (line 734) | fn as_char(self) -> char {
method is_alpha (line 738) | fn is_alpha(self) -> bool {
method is_alphanum (line 742) | fn is_alphanum(self) -> bool {
method is_dec_digit (line 746) | fn is_dec_digit(self) -> bool {
method is_hex_digit (line 750) | fn is_hex_digit(self) -> bool {
method is_oct_digit (line 754) | fn is_oct_digit(self) -> bool {
method is_bin_digit (line 758) | fn is_bin_digit(self) -> bool {
method len (line 762) | fn len(self) -> usize {
method is_space (line 766) | fn is_space(self) -> bool {
method is_newline (line 769) | fn is_newline(self) -> bool {
method as_char (line 776) | fn as_char(self) -> char {
method is_alpha (line 780) | fn is_alpha(self) -> bool {
method is_alphanum (line 784) | fn is_alphanum(self) -> bool {
method is_dec_digit (line 788) | fn is_dec_digit(self) -> bool {
method is_hex_digit (line 792) | fn is_hex_digit(self) -> bool {
method is_oct_digit (line 796) | fn is_oct_digit(self) -> bool {
method is_bin_digit (line 800) | fn is_bin_digit(self) -> bool {
method len (line 804) | fn len(self) -> usize {
method is_space (line 808) | fn is_space(self) -> bool {
method is_newline (line 811) | fn is_newline(self) -> bool {
method as_char (line 818) | fn as_char(self) -> char {
method is_alpha (line 822) | fn is_alpha(self) -> bool {
method is_alphanum (line 826) | fn is_alphanum(self) -> bool {
method is_dec_digit (line 830) | fn is_dec_digit(self) -> bool {
method is_hex_digit (line 834) | fn is_hex_digit(self) -> bool {
method is_oct_digit (line 838) | fn is_oct_digit(self) -> bool {
method is_bin_digit (line 842) | fn is_bin_digit(self) -> bool {
method len (line 846) | fn len(self) -> usize {
method is_space (line 850) | fn is_space(self) -> bool {
method is_newline (line 853) | fn is_newline(self) -> bool {
type CompareResult (line 861) | pub enum CompareResult {
type Compare (line 871) | pub trait Compare<T> {
method compare (line 873) | fn compare(&self, t: T) -> CompareResult;
method compare_no_case (line 881) | fn compare_no_case(&self, t: T) -> CompareResult;
function lowercase_byte (line 884) | fn lowercase_byte(c: u8) -> u8 {
function compare (line 893) | fn compare(&self, t: &'b [u8]) -> CompareResult {
function compare_no_case (line 909) | fn compare_no_case(&self, t: &'b [u8]) -> CompareResult {
function compare (line 926) | fn compare(&self, t: &'b str) -> CompareResult {
function compare_no_case (line 930) | fn compare_no_case(&self, t: &'b str) -> CompareResult {
function compare (line 937) | fn compare(&self, t: &'b str) -> CompareResult {
function compare_no_case (line 943) | fn compare_no_case(&self, t: &'b str) -> CompareResult {
function compare (line 964) | fn compare(&self, t: &'b [u8]) -> CompareResult {
function compare_no_case (line 968) | fn compare_no_case(&self, t: &'b [u8]) -> CompareResult {
type FindToken (line 974) | pub trait FindToken<T> {
method find_token (line 976) | fn find_token(&self, token: T) -> bool;
function find_token (line 980) | fn find_token(&self, token: u8) -> bool {
function find_token (line 986) | fn find_token(&self, token: u8) -> bool {
function find_token (line 992) | fn find_token(&self, token: &u8) -> bool {
function find_token (line 998) | fn find_token(&self, token: &u8) -> bool {
function find_token (line 1004) | fn find_token(&self, token: char) -> bool {
function find_token (line 1010) | fn find_token(&self, token: char) -> bool {
function find_token (line 1016) | fn find_token(&self, token: char) -> bool {
function find_token (line 1022) | fn find_token(&self, token: &char) -> bool {
type FindSubstring (line 1028) | pub trait FindSubstring<T> {
method find_substring (line 1030) | fn find_substring(&self, substr: T) -> Option<usize>;
function find_substring (line 1034) | fn find_substring(&self, substr: &'b [u8]) -> Option<usize> {
function find_substring (line 1068) | fn find_substring(&self, substr: &'b str) -> Option<usize> {
function find_substring (line 1075) | fn find_substring(&self, substr: &'b str) -> Option<usize> {
type ParseTo (line 1081) | pub trait ParseTo<R> {
method parse_to (line 1084) | fn parse_to(&self) -> Option<R>;
function parse_to (line 1088) | fn parse_to(&self) -> Option<R> {
function parse_to (line 1094) | fn parse_to(&self) -> Option<R> {
function compare (line 1101) | fn compare(&self, t: [u8; N]) -> CompareResult {
function compare_no_case (line 1106) | fn compare_no_case(&self, t: [u8; N]) -> CompareResult {
function compare (line 1113) | fn compare(&self, t: &'b [u8; N]) -> CompareResult {
function compare_no_case (line 1118) | fn compare_no_case(&self, t: &'b [u8; N]) -> CompareResult {
function find_token (line 1124) | fn find_token(&self, token: u8) -> bool {
function find_token (line 1130) | fn find_token(&self, token: &u8) -> bool {
type ExtendInto (line 1137) | pub trait ExtendInto {
method new_builder (line 1147) | fn new_builder(&self) -> Self::Extender;
method extend_into (line 1149) | fn extend_into(&self, acc: &mut Self::Extender);
type Item (line 1154) | type Item = u8;
type Extender (line 1155) | type Extender = Vec<u8>;
method new_builder (line 1158) | fn new_builder(&self) -> Vec<u8> {
method extend_into (line 1162) | fn extend_into(&self, acc: &mut Vec<u8>) {
type Item (line 1169) | type Item = u8;
type Extender (line 1170) | type Extender = Vec<u8>;
method new_builder (line 1173) | fn new_builder(&self) -> Vec<u8> {
method extend_into (line 1177) | fn extend_into(&self, acc: &mut Vec<u8>) {
type Item (line 1184) | type Item = char;
type Extender (line 1185) | type Extender = String;
method new_builder (line 1188) | fn new_builder(&self) -> String {
method extend_into (line 1192) | fn extend_into(&self, acc: &mut String) {
type Item (line 1199) | type Item = char;
type Extender (line 1200) | type Extender = String;
method new_builder (line 1203) | fn new_builder(&self) -> String {
method extend_into (line 1207) | fn extend_into(&self, acc: &mut String) {
type Item (line 1214) | type Item = char;
type Extender (line 1215) | type Extender = String;
method new_builder (line 1218) | fn new_builder(&self) -> String {
method extend_into (line 1222) | fn extend_into(&self, acc: &mut String) {
type ToUsize (line 1233) | pub trait ToUsize {
method to_usize (line 1235) | fn to_usize(&self) -> usize;
method to_usize (line 1240) | fn to_usize(&self) -> usize {
method to_usize (line 1247) | fn to_usize(&self) -> usize {
method to_usize (line 1254) | fn to_usize(&self) -> usize {
method to_usize (line 1262) | fn to_usize(&self) -> usize {
method to_usize (line 1270) | fn to_usize(&self) -> usize {
type ErrorConvert (line 1276) | pub trait ErrorConvert<E> {
method convert (line 1278) | fn convert(self) -> E;
function convert (line 1282) | fn convert(self) -> (I, ErrorKind) {
function convert (line 1288) | fn convert(self) -> ((I, usize), ErrorKind) {
function convert (line 1295) | fn convert(self) -> error::Error<I> {
function convert (line 1304) | fn convert(self) -> error::Error<(I, usize)> {
function convert (line 1313) | fn convert(self) {}
type HexDisplay (line 1319) | pub trait HexDisplay {
method to_hex (line 1322) | fn to_hex(&self, chunk_size: usize) -> String;
method to_hex_from (line 1326) | fn to_hex_from(&self, chunk_size: usize, from: usize) -> String;
method to_hex (line 1335) | fn to_hex(&self, chunk_size: usize) -> String {
method to_hex_from (line 1340) | fn to_hex_from(&self, chunk_size: usize, from: usize) -> String {
method to_hex (line 1383) | fn to_hex(&self, chunk_size: usize) -> String {
method to_hex_from (line 1388) | fn to_hex_from(&self, chunk_size: usize, from: usize) -> String {
type SaturatingIterator (line 1394) | pub struct SaturatingIterator {
type Item (line 1399) | type Item = usize;
method next (line 1401) | fn next(&mut self) -> Option<Self::Item> {
type NomRange (line 1409) | pub trait NomRange<Idx> {
method contains (line 1416) | fn contains(&self, item: &Idx) -> bool;
method bounds (line 1419) | fn bounds(&self) -> (Bound<Idx>, Bound<Idx>);
method is_inverted (line 1422) | fn is_inverted(&self) -> bool;
method saturating_iter (line 1428) | fn saturating_iter(&self) -> Self::Saturating;
method bounded_iter (line 1434) | fn bounded_iter(&self) -> Self::Bounded;
type Saturating (line 1438) | type Saturating = Range<usize>;
type Bounded (line 1439) | type Bounded = Range<usize>;
function bounds (line 1441) | fn bounds(&self) -> (Bound<usize>, Bound<usize>) {
function contains (line 1445) | fn contains(&self, item: &usize) -> bool {
function is_inverted (line 1449) | fn is_inverted(&self) -> bool {
function saturating_iter (line 1453) | fn saturating_iter(&self) -> Self::Saturating {
function bounded_iter (line 1461) | fn bounded_iter(&self) -> Self::Bounded {
type Saturating (line 1471) | type Saturating = Range<usize>;
type Bounded (line 1472) | type Bounded = Range<usize>;
function bounds (line 1474) | fn bounds(&self) -> (Bound<usize>, Bound<usize>) {
function contains (line 1478) | fn contains(&self, item: &usize) -> bool {
function is_inverted (line 1482) | fn is_inverted(&self) -> bool {
function saturating_iter (line 1486) | fn saturating_iter(&self) -> Self::Saturating {
function bounded_iter (line 1490) | fn bounded_iter(&self) -> Self::Bounded {
type Saturating (line 1496) | type Saturating = SaturatingIterator;
type Bounded (line 1497) | type Bounded = Range<usize>;
function bounds (line 1499) | fn bounds(&self) -> (Bound<usize>, Bound<usize>) {
function contains (line 1503) | fn contains(&self, item: &usize) -> bool {
function is_inverted (line 1507) | fn is_inverted(&self) -> bool {
function saturating_iter (line 1511) | fn saturating_iter(&self) -> Self::Saturating {
function bounded_iter (line 1515) | fn bounded_iter(&self) -> Self::Bounded {
type Saturating (line 1521) | type Saturating = Range<usize>;
type Bounded (line 1522) | type Bounded = Range<usize>;
function bounds (line 1524) | fn bounds(&self) -> (Bound<usize>, Bound<usize>) {
function contains (line 1528) | fn contains(&self, item: &usize) -> bool {
function is_inverted (line 1532) | fn is_inverted(&self) -> bool {
function saturating_iter (line 1536) | fn saturating_iter(&self) -> Self::Saturating {
function bounded_iter (line 1544) | fn bounded_iter(&self) -> Self::Bounded {
type Saturating (line 1554) | type Saturating = Range<usize>;
type Bounded (line 1555) | type Bounded = Range<usize>;
function bounds (line 1557) | fn bounds(&self) -> (Bound<usize>, Bound<usize>) {
function contains (line 1561) | fn contains(&self, item: &usize) -> bool {
function is_inverted (line 1565) | fn is_inverted(&self) -> bool {
function saturating_iter (line 1569) | fn saturating_iter(&self) -> Self::Saturating {
function bounded_iter (line 1573) | fn bounded_iter(&self) -> Self::Bounded {
type Saturating (line 1579) | type Saturating = SaturatingIterator;
type Bounded (line 1580) | type Bounded = Range<usize>;
method bounds (line 1582) | fn bounds(&self) -> (Bound<usize>, Bound<usize>) {
method contains (line 1586) | fn contains(&self, item: &usize) -> bool {
method is_inverted (line 1590) | fn is_inverted(&self) -> bool {
method saturating_iter (line 1594) | fn saturating_iter(&self) -> Self::Saturating {
method bounded_iter (line 1598) | fn bounded_iter(&self) -> Self::Bounded {
type Saturating (line 1604) | type Saturating = Range<usize>;
type Bounded (line 1605) | type Bounded = Range<usize>;
function bounds (line 1607) | fn bounds(&self) -> (Bound<usize>, Bound<usize>) {
function contains (line 1611) | fn contains(&self, item: &usize) -> bool {
function is_inverted (line 1615) | fn is_inverted(&self) -> bool {
function saturating_iter (line 1619) | fn saturating_iter(&self) -> Self::Saturating {
function bounded_iter (line 1623) | fn bounded_iter(&self) -> Self::Bounded {
function test_offset_u8 (line 1633) | fn test_offset_u8() {
function test_offset_str (line 1645) | fn test_offset_str() {
function test_slice_index (line 1656) | fn test_slice_index() {
function test_slice_index_utf8 (line 1663) | fn test_slice_index_utf8() {
FILE: tests/arithmetic.rs
function parens (line 17) | fn parens(i: &str) -> IResult<&str, i64> {
function factor (line 25) | fn factor(i: &str) -> IResult<&str, i64> {
function term (line 36) | fn term(i: &str) -> IResult<&str, i64> {
function expr (line 54) | fn expr(i: &str) -> IResult<&str, i64> {
function factor_test (line 73) | fn factor_test() {
function term_test (line 81) | fn term_test() {
function expr_test (line 88) | fn expr_test() {
function parens_test (line 95) | fn parens_test() {
FILE: tests/arithmetic_ast.rs
type Expr (line 17) | pub enum Expr {
type Oper (line 27) | pub enum Oper {
method fmt (line 35) | fn fmt(&self, format: &mut Formatter<'_>) -> fmt::Result {
method fmt (line 49) | fn fmt(&self, format: &mut Formatter<'_>) -> fmt::Result {
function parens (line 62) | fn parens(i: &str) -> IResult<&str, Expr> {
function factor (line 71) | fn factor(i: &str) -> IResult<&str, Expr> {
function fold_exprs (line 82) | fn fold_exprs(initial: Expr, remainder: Vec<(Oper, Expr)>) -> Expr {
function term (line 94) | fn term(i: &str) -> IResult<&str, Expr> {
function expr (line 114) | fn expr(i: &str) -> IResult<&str, Expr> {
function factor_test (line 135) | fn factor_test() {
function term_test (line 143) | fn term_test() {
function expr_test (line 151) | fn expr_test() {
function parens_test (line 167) | fn parens_test() {
FILE: tests/css.rs
type Color (line 6) | pub struct Color {
function from_hex (line 12) | fn from_hex(input: &str) -> Result<u8, std::num::ParseIntError> {
function is_hex_digit (line 16) | fn is_hex_digit(c: char) -> bool {
function hex_primary (line 20) | fn hex_primary(input: &str) -> IResult<&str, u8> {
function hex_color (line 24) | fn hex_color(input: &str) -> IResult<&str, Color> {
function parse_color (line 32) | fn parse_color() {
FILE: tests/custom_errors.rs
type CustomError (line 13) | pub struct CustomError(String);
method from (line 16) | fn from(error: (&'a str, ErrorKind)) -> Self {
method from_error_kind (line 22) | fn from_error_kind(_: &'a str, kind: ErrorKind) -> Self {
method append (line 26) | fn append(_: &'a str, kind: ErrorKind, other: CustomError) -> Self {
function test1 (line 31) | fn test1(input: &str) -> IResult<&str, &str, CustomError> {
function test2 (line 36) | fn test2(input: &str) -> IResult<&str, &str, CustomError> {
function test3 (line 41) | fn test3(input: &str) -> IResult<&str, &str, CustomError> {
function test4 (line 46) | fn test4(input: &str) -> IResult<&str, Vec<&str>, CustomError> {
FILE: tests/escaped.rs
function esc (line 6) | fn esc(s: &str) -> IResult<&str, &str, (&str, ErrorKind)> {
function esc_trans (line 11) | fn esc_trans(s: &str) -> IResult<&str, String, (&str, ErrorKind)> {
function test_escaped (line 17) | fn test_escaped() {
function test_escaped_transform (line 23) | fn test_escaped_transform() {
FILE: tests/expression_ast.rs
type Expr (line 14) | pub enum Expr {
type PrefixOp (line 31) | enum PrefixOp {
type PostfixOp (line 37) | enum PostfixOp {
type BinaryOp (line 44) | enum BinaryOp {
function function_call (line 54) | fn function_call(i: &str) -> IResult<&str, PostfixOp> {
function ternary_operator (line 77) | fn ternary_operator(i: &str) -> IResult<&str, BinaryOp> {
function expression (line 85) | fn expression(i: &str) -> IResult<&str, Expr> {
function expression_test (line 151) | fn expression_test() {
FILE: tests/float.rs
function unsigned_float (line 15) | fn unsigned_float(i: &[u8]) -> IResult<&[u8], f32> {
function float (line 24) | fn float(i: &[u8]) -> IResult<&[u8], f32> {
function unsigned_float_test (line 38) | fn unsigned_float_test() {
function float_test (line 47) | fn float_test() {
function test_f32_big_endian (line 54) | fn test_f32_big_endian() {
function test_f32_little_endian (line 64) | fn test_f32_little_endian() {
function test_f64_big_endian (line 74) | fn test_f64_big_endian() {
function test_f64_little_endian (line 92) | fn test_f64_little_endian() {
FILE: tests/fnmut.rs
function parse (line 8) | fn parse() {
function accumulate (line 25) | fn accumulate() {
FILE: tests/ini.rs
function category (line 15) | fn category(i: &[u8]) -> IResult<&[u8], &str> {
function key_value (line 23) | fn key_value(i: &[u8]) -> IResult<&[u8], (&str, &str)> {
function keys_and_values (line 31) | fn keys_and_values(i: &[u8]) -> IResult<&[u8], HashMap<&str, &str>> {
function category_and_keys (line 35) | fn category_and_keys(i: &[u8]) -> IResult<&[u8], (&str, HashMap<&str, &s...
function categories (line 41) | fn categories(i: &[u8]) -> IResult<&[u8], HashMap<&str, HashMap<&str, &s...
function parse_category_test (line 60) | fn parse_category_test() {
function parse_key_value_test (line 80) | fn parse_key_value_test() {
function parse_key_value_with_space_test (line 97) | fn parse_key_value_with_space_test() {
function parse_key_value_with_comment_test (line 114) | fn parse_key_value_with_comment_test() {
function parse_multiple_keys_and_values_test (line 131) | fn parse_multiple_keys_and_values_test() {
function parse_category_then_multiple_keys_and_values_test (line 154) | fn parse_category_then_multiple_keys_and_values_test() {
function parse_multiple_categories_test (line 179) | fn parse_multiple_categories_test() {
FILE: tests/ini_str.rs
function is_line_ending_or_comment (line 12) | fn is_line_ending_or_comment(chr: char) -> bool {
function not_line_ending (line 16) | fn not_line_ending(i: &str) -> IResult<&str, &str> {
function space_or_line_ending (line 20) | fn space_or_line_ending(i: &str) -> IResult<&str, &str> {
function category (line 24) | fn category(i: &str) -> IResult<&str, &str> {
function key_value (line 32) | fn key_value(i: &str) -> IResult<&str, (&str, &str)> {
function keys_and_values_aggregator (line 43) | fn keys_and_values_aggregator(i: &str) -> IResult<&str, Vec<(&str, &str)...
function keys_and_values (line 47) | fn keys_and_values(input: &str) -> IResult<&str, HashMap<&str, &str>> {
function category_and_keys (line 54) | fn category_and_keys(i: &str) -> IResult<&str, (&str, HashMap<&str, &str...
function categories_aggregator (line 59) | fn categories_aggregator(i: &str) -> IResult<&str, Vec<(&str, HashMap<&s...
function categories (line 63) | fn categories(input: &str) -> IResult<&str, HashMap<&str, HashMap<&str, ...
function parse_category_test (line 71) | fn parse_category_test() {
function parse_key_value_test (line 91) | fn parse_key_value_test() {
function parse_key_value_with_space_test (line 108) | fn parse_key_value_with_space_test() {
function parse_key_value_with_comment_test (line 125) | fn parse_key_value_with_comment_test() {
function parse_multiple_keys_and_values_test (line 142) | fn parse_multiple_keys_and_values_test() {
function parse_category_then_multiple_keys_and_values_test (line 165) | fn parse_category_then_multiple_keys_and_values_test() {
function parse_multiple_categories_test (line 190) | fn parse_multiple_categories_test() {
FILE: tests/issues.rs
type Range (line 8) | struct Range {
function take_char (line 13) | pub fn take_char(input: &[u8]) -> IResult<&[u8], char> {
function parse_ints (line 32) | fn parse_ints(input: &[u8]) -> IResult<&[u8], Vec<i32>> {
function spaces_or_int (line 36) | fn spaces_or_int(input: &[u8]) -> IResult<&[u8], i32> {
function issue_142 (line 55) | fn issue_142() {
function usize_length_bytes_issue (line 67) | fn usize_length_bytes_issue() {
function take_till_issue (line 74) | fn take_till_issue() {
function issue_655 (line 86) | fn issue_655() {
function issue_717 (line 104) | fn issue_717(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
type Input (line 117) | pub type Input<'a> = &'a [u8];
type Data (line 120) | struct Data {
function list (line 126) | fn list<'a>(
function data (line 133) | fn data(input: Input<'_>) -> IResult<Input<'_>, Data> {
function issue_848_overflow_incomplete_bits_to_bytes (line 142) | fn issue_848_overflow_incomplete_bits_to_bytes() {
function issue_942 (line 162) | fn issue_942() {
function issue_many_m_n_with_zeros (line 174) | fn issue_many_m_n_with_zeros() {
function issue_1231_bits_expect_fn_closure (line 182) | fn issue_1231_bits_expect_fn_closure() {
function issue_1282_findtoken_char (line 192) | fn issue_1282_findtoken_char() {
function issue_x_looser_fill_bounds (line 200) | fn issue_x_looser_fill_bounds() {
function issue_1459_clamp_capacity (line 227) | fn issue_1459_clamp_capacity() {
function issue_1617_count_parser_returning_zero_size (line 242) | fn issue_1617_count_parser_returning_zero_size() {
function issue_1586_parser_iterator_impl (line 255) | fn issue_1586_parser_iterator_impl() {
function issue_1808_complete_string_parser_returns_wrong_slice (line 274) | fn issue_1808_complete_string_parser_returns_wrong_slice() {
FILE: tests/json.rs
type JsonValue (line 18) | pub enum JsonValue {
function boolean (line 27) | fn boolean(input: &str) -> IResult<&str, bool> {
function u16_hex (line 31) | fn u16_hex(input: &str) -> IResult<&str, u16> {
function unicode_escape (line 35) | fn unicode_escape(input: &str) -> IResult<&str, char> {
function character (line 61) | fn character(input: &str) -> IResult<&str, char> {
function string (line 84) | fn string(input: &str) -> IResult<&str, String> {
function ws (line 96) | fn ws<'a, O, E: ParseError<&'a str>, F: Parser<&'a str, Output = O, Erro...
function array (line 102) | fn array(input: &str) -> IResult<&str, Vec<JsonValue>> {
function object (line 111) | fn object(input: &str) -> IResult<&str, HashMap<String, JsonValue>> {
function json_value (line 126) | fn json_value(input: &str) -> IResult<&str, JsonValue> {
function json (line 140) | fn json(input: &str) -> IResult<&str, JsonValue> {
function json_string (line 145) | fn json_string() {
function json_object (line 164) | fn json_object() {
function json_array (line 182) | fn json_array() {
function json_whitespace (line 193) | fn json_whitespace() {
FILE: tests/mp4.rs
function mp4_box (line 15) | fn mp4_box(input: &[u8]) -> IResult<&[u8], &[u8]> {
type FileType (line 31) | struct FileType<'a> {
type Mvhd32 (line 40) | pub struct Mvhd32 {
type Mvhd64 (line 70) | pub struct Mvhd64 {
function mvhd32 (line 98) | fn mvhd32(i: &[u8]) -> IResult<&[u8], MvhdBox> {
function mvhd64 (line 150) | fn mvhd64(i: &[u8]) -> IResult<&[u8], MvhdBox> {
type MvhdBox (line 202) | pub enum MvhdBox {
type MoovBox (line 208) | pub enum MoovBox {
type MP4BoxType (line 221) | enum MP4BoxType {
type MP4BoxHeader (line 241) | struct MP4BoxHeader {
function brand_name (line 246) | fn brand_name(input: &[u8]) -> IResult<&[u8], &str> {
function filetype_parser (line 250) | fn filetype_parser(input: &[u8]) -> IResult<&[u8], FileType<'_>> {
function mvhd_box (line 263) | fn mvhd_box(input: &[u8]) -> IResult<&[u8], MvhdBox> {
function unknown_box_type (line 277) | fn unknown_box_type(input: &[u8]) -> IResult<&[u8], MP4BoxType> {
function box_type (line 281) | fn box_type(input: &[u8]) -> IResult<&[u8], MP4BoxType> {
function moov_type (line 297) | fn moov_type(input: &[u8]) -> IResult<&[u8], MP4BoxType> {
function box_header (line 312) | fn box_header(input: &[u8]) -> IResult<&[u8], MP4BoxHeader> {
function moov_header (line 318) | fn moov_header(input: &[u8]) -> IResult<&[u8], MP4BoxHeader> {
FILE: tests/multiline.rs
function end_of_line (line 8) | pub fn end_of_line(input: &str) -> IResult<&str, &str> {
function read_line (line 16) | pub fn read_line(input: &str) -> IResult<&str, &str> {
function read_lines (line 20) | pub fn read_lines(input: &str) -> IResult<&str, Vec<&str>> {
function read_lines_test (line 26) | fn read_lines_test() {
FILE: tests/overflow.rs
function parser02 (line 14) | fn parser02(i: &[u8]) -> IResult<&[u8], (&[u8], &[u8])> {
function overflow_incomplete_tuple (line 19) | fn overflow_incomplete_tuple() {
function overflow_incomplete_length_bytes (line 28) | fn overflow_incomplete_length_bytes() {
function overflow_incomplete_many0 (line 42) | fn overflow_incomplete_many0() {
function overflow_incomplete_many1 (line 56) | fn overflow_incomplete_many1() {
function overflow_incomplete_many_till (line 70) | fn overflow_incomplete_many_till() {
function overflow_incomplete_many_m_n (line 87) | fn overflow_incomplete_many_m_n() {
function overflow_incomplete_count (line 101) | fn overflow_incomplete_count() {
function overflow_incomplete_length_count (line 116) | fn overflow_incomplete_length_count() {
function overflow_incomplete_length_data (line 132) | fn overflow_incomplete_length_data() {
FILE: tests/reborrow_fold.rs
function atom (line 13) | fn atom(_tomb: &mut ()) -> impl for<'a> FnMut(&'a [u8]) -> IResult<&'a [...
function list (line 24) | fn list<'a>(i: &'a [u8], tomb: &mut ()) -> IResult<&'a [u8], String> {
Condensed preview — 102 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (3,289K chars).
[
{
"path": ".github/CODEOWNERS",
"chars": 8,
"preview": "* @Geal\n"
},
{
"path": ".github/ISSUE_TEMPLATE.md",
"chars": 1149,
"preview": "Hello, and thank you for submitting an issue to nom!\n\n\nFirst, please note that, for family reasons, I have limited time "
},
{
"path": ".github/PULL_REQUEST_TEMPLATE.md",
"chars": 1873,
"preview": "<!--\nHello, and thank you for submitting a pull request to nom!\n\nFirst, please note that, for family reasons, I have lim"
},
{
"path": ".github/workflows/ci.yml",
"chars": 4521,
"preview": "name: CI\n\non: [push, pull_request]\n\nenv:\n RUST_MINVERSION: 1.65.0\n CARGO_INCREMENTAL: 0\n CARGO_NET_RETRY: 10\n\njobs:\n "
},
{
"path": ".github/workflows/cifuzz.yml",
"chars": 693,
"preview": "name: CIFuzz\non: [pull_request]\njobs:\n Fuzzing:\n runs-on: ubuntu-latest\n steps:\n - name: Build Fuzzers\n i"
},
{
"path": ".github/workflows/codspeed.yml",
"chars": 798,
"preview": "name: codspeed-benchmarks\n\non:\n push:\n branches:\n - \"main\"\n pull_request:\n # `workflow_dispatch` allows CodSp"
},
{
"path": ".gitignore",
"chars": 114,
"preview": "target/*\nCargo.lock\nFullRecognition.jpg\nmap.rs\noldsrc/\nrealworld/\nsrc/generator.rs\n.DS_Store\nprivate-docs/\n.idea/\n"
},
{
"path": "CHANGELOG.md",
"chars": 62646,
"preview": "# Change Log\n\n## 8.0.0 2025-01-25\n\nThis version represents a significant refactoring of nom to reduce the amount of code"
},
{
"path": "CONTRIBUTING.md",
"chars": 2227,
"preview": "# Contributing to nom\n\nThanks a lot for contributing to this project!\n\nThe following is a set of guidelines for contribu"
},
{
"path": "Cargo.toml",
"chars": 2632,
"preview": "[package]\n\nname = \"nom\"\nversion = \"8.0.0\"\nauthors = [\"contact@geoffroycouprie.com\"]\ndescription = \"A byte-oriented, zero"
},
{
"path": "LICENSE",
"chars": 1065,
"preview": "Copyright (c) 2014-2019 Geoffroy Couprie\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy o"
},
{
"path": "README.md",
"chars": 15141,
"preview": "# nom, eating data byte by byte\n\n[](LICENSE)\n[![Join the ch"
},
{
"path": "assets/links.txt",
"chars": 1788,
"preview": "https://github.com/ekmett/machines\nhttps://www.fpcomplete.com/user/snoyberg/library-documentation/conduit-overview\nhttps"
},
{
"path": "assets/testfile.txt",
"chars": 47,
"preview": "abcdabcdabcdabcdabcd\nefgh\ncoin coin\nhello\nblah\n"
},
{
"path": "benchmarks/Cargo.toml",
"chars": 955,
"preview": "[package]\nname = \"benchmarks\"\nversion = \"0.1.0\"\nedition = \"2018\"\n\n# See more keys and their definitions at https://doc.r"
},
{
"path": "benchmarks/README.md",
"chars": 29,
"preview": "# Benchmarks for nom parsers\n"
},
{
"path": "benchmarks/benches/arithmetic.rs",
"chars": 2026,
"preview": "#[global_allocator]\nstatic ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;\n\nuse codspeed_criterion_compat::{crit"
},
{
"path": "benchmarks/benches/http.rs",
"chars": 4448,
"preview": "#![cfg_attr(rustfmt, rustfmt_skip)]\n\n#[global_allocator]\nstatic ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;\n"
},
{
"path": "benchmarks/benches/http_streaming.rs",
"chars": 4529,
"preview": "#![cfg_attr(rustfmt, rustfmt_skip)]\n\n#[global_allocator]\nstatic ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;\n"
},
{
"path": "benchmarks/benches/ini.rs",
"chars": 2584,
"preview": "#[global_allocator]\nstatic ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;\n\nuse codspeed_criterion_compat::*;\n\nu"
},
{
"path": "benchmarks/benches/ini_str.rs",
"chars": 1998,
"preview": "#[global_allocator]\nstatic ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;\n\nuse codspeed_criterion_compat::*;\n\nu"
},
{
"path": "benchmarks/benches/json.rs",
"chars": 11345,
"preview": "#[global_allocator]\nstatic ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;\n\nuse codspeed_criterion_compat::*;\nus"
},
{
"path": "benchmarks/benches/json_streaming.rs",
"chars": 5582,
"preview": "#[global_allocator]\nstatic ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;\n\nuse codspeed_criterion_compat::*;\nus"
},
{
"path": "benchmarks/benches/number.rs",
"chars": 514,
"preview": "#[global_allocator]\nstatic ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;\n\nuse codspeed_criterion_compat::*;\nus"
},
{
"path": "benchmarks/canada.json",
"chars": 2251051,
"preview": "{ \"type\": \"FeatureCollection\",\n \"features\": [\n{\n \"type\": \"Feature\",\n\"properties\": { \"name\": \"Canada\" },\n\"geometry\": "
},
{
"path": "benchmarks/src/lib.rs",
"chars": 110,
"preview": "#[cfg(test)]\nmod tests {\n #[test]\n fn it_works() {\n let result = 2 + 2;\n assert_eq!(result, 4);\n }\n}\n"
},
{
"path": "doc/archive/FAQ.md",
"chars": 4943,
"preview": "# FAQ\n\n### Using nightly to get better error messages\n\n**warning**: this only applies to nom 3. nom 4 uses the\n[compile_"
},
{
"path": "doc/archive/how_nom_macros_work.md",
"chars": 5066,
"preview": "# How nom macros work\n\n**NOTE: macros were removed in nom 7. You should now use the function based combinators**\n\nnom us"
},
{
"path": "doc/archive/upgrading_to_nom_1.md",
"chars": 3041,
"preview": "# Upgrading to nom 1.0\n\nThe 1.0 release of nom is one of the biggest since the beginning of the project. Its goal was to"
},
{
"path": "doc/archive/upgrading_to_nom_2.md",
"chars": 8100,
"preview": "# Upgrading to nom 2.0\n\nThe 2.0 release of nom adds a lot of new features, but it was also time for a big cleanup of bad"
},
{
"path": "doc/archive/upgrading_to_nom_4.md",
"chars": 7798,
"preview": "# Upgrading to nom 4.0\n\nThe nom 4.0 is a nearly complete rewrite of nom's internal structures, along with a cleanup of a"
},
{
"path": "doc/choosing_a_combinator.md",
"chars": 21644,
"preview": "# List of parsers and combinators\n\n**Note**: this list is meant to provide a nicer way to find a nom parser than reading"
},
{
"path": "doc/custom_input_types.md",
"chars": 2422,
"preview": "# Custom input types\n\nWhile historically, nom has worked mainly on `&[u8]` and `&str`, it can actually\nuse any type as i"
},
{
"path": "doc/error_management.md",
"chars": 14670,
"preview": "# Error management\n\nnom's errors are designed with multiple needs in mind:\n- indicate which parser failed and where in t"
},
{
"path": "doc/home.md",
"chars": 665,
"preview": "# Nom is an awesome parser combinators library in Rust\n\nTo get started using nom, you can include it in your Rust projec"
},
{
"path": "doc/making_a_new_parser_from_scratch.md",
"chars": 7426,
"preview": "# Making a new parser from scratch\n\nWriting a parser is a very fun, interactive process, but sometimes a daunting\ntask. "
},
{
"path": "doc/nom_recipes.md",
"chars": 9396,
"preview": "# Common recipes to build nom parsers\n\nThese are short recipes for accomplishing common tasks with nom.\n\n* [Whitespace]("
},
{
"path": "doc/upgrading_to_nom_5.md",
"chars": 6998,
"preview": "# Upgrading to nom 5.0\n\n## Changes in error types\n\n**If you have a lot of unit tests, this is probably the biggest issue"
},
{
"path": "examples/custom_error.rs",
"chars": 832,
"preview": "extern crate nom;\n\nuse nom::error::ErrorKind;\nuse nom::error::ParseError;\nuse nom::Err::Error;\nuse nom::IResult;\n\n#[deri"
},
{
"path": "examples/iterator.rs",
"chars": 2343,
"preview": "use std::collections::HashMap;\nuse std::iter::Iterator;\n\nuse nom::bytes::complete::tag;\nuse nom::character::complete::al"
},
{
"path": "examples/json.rs",
"chars": 10116,
"preview": "#![cfg(feature = \"alloc\")]\n\nuse nom::{\n branch::alt,\n bytes::complete::{escaped, tag, take_while},\n character::comple"
},
{
"path": "examples/json2.rs",
"chars": 5090,
"preview": "//#[global_allocator]\n//static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;\n\nuse nom::{\n branch::alt,\n byte"
},
{
"path": "examples/json_iterator.rs",
"chars": 7639,
"preview": "#![cfg(feature = \"alloc\")]\n\nuse nom::{\n branch::alt,\n bytes::complete::{escaped, tag, take_while},\n character::comple"
},
{
"path": "examples/s_expression.rs",
"chars": 12811,
"preview": "//! In this example we build an [S-expression](https://en.wikipedia.org/wiki/S-expression)\n//! parser and tiny [lisp](ht"
},
{
"path": "examples/string.rs",
"chars": 7501,
"preview": "//! This example shows an example of how to parse an escaped string. The\n//! rules for the string are similar to JSON an"
},
{
"path": "fuzz/.gitignore",
"chars": 24,
"preview": "artifacts\ncorpus\ntarget\n"
},
{
"path": "fuzz/Cargo.toml",
"chars": 395,
"preview": "\n[package]\nname = \"nom-fuzz\"\nversion = \"0.0.0\"\nauthors = [\"David Korczynski <david@adalogics.com>\"]\npublish = false\nedit"
},
{
"path": "fuzz/fuzz_targets/fuzz_arithmetic.rs",
"chars": 2529,
"preview": "#![no_main]\nuse libfuzzer_sys::fuzz_target;\nuse std::str;\n\nextern crate nom;\n\nuse nom::{\n branch::alt,\n bytes::complet"
},
{
"path": "nom-language/Cargo.toml",
"chars": 311,
"preview": "[package]\nname = \"nom-language\"\nversion = \"0.1.0\"\nauthors = [\"contact@geoffroycouprie.com\"]\ndescription = \"Language pars"
},
{
"path": "nom-language/src/error.rs",
"chars": 7499,
"preview": "use std::fmt;\n\nuse nom::{\n error::{ContextError, ErrorKind, FromExternalError, ParseError},\n ErrorConvert,\n};\n\n/// Thi"
},
{
"path": "nom-language/src/lib.rs",
"chars": 321,
"preview": "//! # Langage parsing combinators for the nom parser combinators library\n//!\n//! nom is a parser combinator library with"
},
{
"path": "nom-language/src/precedence/mod.rs",
"chars": 16528,
"preview": "//! Combinators to parse expressions with operator precedence.\n\n#[cfg(test)]\nmod tests;\n\nuse nom::error::{ErrorKind, Fro"
},
{
"path": "nom-language/src/precedence/tests.rs",
"chars": 1786,
"preview": "use crate::precedence::{binary_op, unary_op, Assoc, Operation};\nuse nom::{\n branch::alt,\n bytes::complete::tag,\n char"
},
{
"path": "proptest-regressions/character/complete.txt",
"chars": 651,
"preview": "# Seeds for failure cases proptest has generated in the past. It is\n# automatically read and these particular cases re-r"
},
{
"path": "proptest-regressions/character/streaming.txt",
"chars": 652,
"preview": "# Seeds for failure cases proptest has generated in the past. It is\n# automatically read and these particular cases re-r"
},
{
"path": "proptest-regressions/number/complete.txt",
"chars": 920,
"preview": "# Seeds for failure cases proptest has generated in the past. It is\n# automatically read and these particular cases re-r"
},
{
"path": "proptest-regressions/number/streaming.txt",
"chars": 476,
"preview": "# Seeds for failure cases proptest has generated in the past. It is\n# automatically read and these particular cases re-r"
},
{
"path": "rustfmt.toml",
"chars": 31,
"preview": "tab_spaces = 2\nmax_width = 100\n"
},
{
"path": "src/bits/complete.rs",
"chars": 5372,
"preview": "//! Bit level parsers\n//!\n\nuse crate::error::{ErrorKind, ParseError};\nuse crate::internal::{Err, IResult};\nuse crate::li"
},
{
"path": "src/bits/mod.rs",
"chars": 5924,
"preview": "//! Bit level parsers\n//!\n\npub mod complete;\npub mod streaming;\n\nuse crate::error::{ErrorKind, ParseError};\nuse crate::i"
},
{
"path": "src/bits/streaming.rs",
"chars": 4434,
"preview": "//! Bit level parsers\n//!\n\nuse crate::error::{ErrorKind, ParseError};\nuse crate::internal::{Err, IResult, Needed};\nuse c"
},
{
"path": "src/branch/mod.rs",
"chars": 10846,
"preview": "//! Choice combinators\n\n#[cfg(test)]\nmod tests;\n\nuse core::marker::PhantomData;\n\nuse crate::error::ErrorKind;\nuse crate:"
},
{
"path": "src/branch/tests.rs",
"chars": 4636,
"preview": "use crate::branch::{alt, permutation};\nuse crate::bytes::streaming::tag;\nuse crate::error::ErrorKind;\nuse crate::interna"
},
{
"path": "src/bytes/complete.rs",
"chars": 19390,
"preview": "//! Parsers recognizing bytes streams, complete input version\n\nuse core::marker::PhantomData;\n\nuse crate::error::ParseEr"
},
{
"path": "src/bytes/mod.rs",
"chars": 31706,
"preview": "//! Parsers recognizing bytes streams\n\npub mod complete;\npub mod streaming;\n#[cfg(test)]\nmod tests;\n\nuse core::marker::P"
},
{
"path": "src/bytes/streaming.rs",
"chars": 17502,
"preview": "//! Parsers recognizing bytes streams, streaming version\n\nuse core::marker::PhantomData;\n\nuse crate::error::ParseError;\n"
},
{
"path": "src/bytes/tests.rs",
"chars": 17100,
"preview": "use crate::character::streaming::{\n alpha1 as alpha, alphanumeric1 as alphanumeric, bin_digit1 as bin_digit, digit1 as "
},
{
"path": "src/character/complete.rs",
"chars": 42727,
"preview": "//! Character specific parsers and combinators, complete input version.\n//!\n//! Functions recognizing specific character"
},
{
"path": "src/character/mod.rs",
"chars": 11130,
"preview": "//! Character specific parsers and combinators\n//!\n//! Functions recognizing specific characters\n\nuse core::marker::Phan"
},
{
"path": "src/character/streaming.rs",
"chars": 43032,
"preview": "//! Character specific parsers and combinators, streaming version\n//!\n//! Functions recognizing specific characters\n\nuse"
},
{
"path": "src/character/tests.rs",
"chars": 1267,
"preview": "use super::streaming::*;\nuse crate::error::ErrorKind;\nuse crate::internal::{Err, IResult};\n\n#[test]\nfn one_of_test() {\n "
},
{
"path": "src/combinator/mod.rs",
"chars": 28179,
"preview": "//! General purpose combinators\n\n#![allow(unused_imports)]\n\nuse core::marker::PhantomData;\n\n#[cfg(feature = \"alloc\")]\nus"
},
{
"path": "src/combinator/tests.rs",
"chars": 6681,
"preview": "use super::*;\nuse crate::bytes::complete::take;\nuse crate::bytes::streaming::tag;\nuse crate::error::ErrorKind;\nuse crate"
},
{
"path": "src/error.rs",
"chars": 23356,
"preview": "//! Error management\n//!\n//! Parsers are generic over their error type, requiring that it implements\n//! the `error::Par"
},
{
"path": "src/internal.rs",
"chars": 25819,
"preview": "//! Basic types to build the parsers\n\nuse self::Needed::*;\nuse crate::error::{self, ErrorKind, FromExternalError, ParseE"
},
{
"path": "src/lib.rs",
"chars": 15533,
"preview": "//! # nom, eating data byte by byte\n//!\n//! nom is a parser combinator library with a focus on safe parsing,\n//! streami"
},
{
"path": "src/macros.rs",
"chars": 1453,
"preview": "macro_rules! succ (\n (0, $submac:ident ! ($($rest:tt)*)) => ($submac!(1, $($rest)*));\n (1, $submac:ident ! ($($rest:tt"
},
{
"path": "src/multi/mod.rs",
"chars": 53630,
"preview": "//! Combinators applying their child parser multiple times\n\n#[cfg(test)]\nmod tests;\n\nuse core::marker::PhantomData;\n\nuse"
},
{
"path": "src/multi/tests.rs",
"chars": 24706,
"preview": "use super::{length_data, length_value, many0_count, many1_count};\nuse crate::{\n bytes::streaming::tag,\n character::str"
},
{
"path": "src/number/complete.rs",
"chars": 57485,
"preview": "//! Parsers recognizing numbers, complete input version\n\nuse crate::branch::alt;\nuse crate::bytes::complete::tag;\nuse cr"
},
{
"path": "src/number/mod.rs",
"chars": 44892,
"preview": "//! Parsers recognizing numbers\n\nuse core::{\n marker::PhantomData,\n ops::{Add, Shl},\n};\n\nuse crate::{\n branch::alt,\n "
},
{
"path": "src/number/streaming.rs",
"chars": 62592,
"preview": "//! Parsers recognizing numbers, streaming version\n\nuse crate::branch::alt;\nuse crate::bytes::streaming::tag;\nuse crate:"
},
{
"path": "src/sequence/mod.rs",
"chars": 9918,
"preview": "//! Combinators applying parsers in sequence\n\n#[cfg(test)]\nmod tests;\n\nuse crate::error::ParseError;\nuse crate::internal"
},
{
"path": "src/sequence/tests.rs",
"chars": 7815,
"preview": "use super::*;\nuse crate::bytes::streaming::{tag, take};\nuse crate::error::{Error, ErrorKind};\nuse crate::internal::{Err,"
},
{
"path": "src/str.rs",
"chars": 13054,
"preview": "#[cfg(test)]\nmod test {\n #[cfg(feature = \"alloc\")]\n use crate::{branch::alt, bytes::complete::tag_no_case, combinator:"
},
{
"path": "src/traits.rs",
"chars": 40729,
"preview": "//! Traits input types have to implement to work with nom combinators\nuse core::iter::Enumerate;\nuse core::str::CharIndi"
},
{
"path": "tests/arithmetic.rs",
"chars": 2333,
"preview": "use nom::{\n branch::alt,\n bytes::complete::tag,\n character::complete::char,\n character::complete::{digit1 as digit, "
},
{
"path": "tests/arithmetic_ast.rs",
"chars": 4175,
"preview": "use std::fmt;\nuse std::fmt::{Debug, Display, Formatter};\n\nuse std::str::FromStr;\n\nuse nom::Parser;\nuse nom::{\n branch::"
},
{
"path": "tests/css.rs",
"chars": 899,
"preview": "use nom::bytes::complete::{tag, take_while_m_n};\nuse nom::combinator::map_res;\nuse nom::{IResult, Parser};\n\n#[derive(Deb"
},
{
"path": "tests/custom_errors.rs",
"chars": 1357,
"preview": "#![allow(dead_code)]\n\nuse nom::bytes::streaming::tag;\nuse nom::character::streaming::digit1 as digit;\nuse nom::combinato"
},
{
"path": "tests/escaped.rs",
"chars": 732,
"preview": "use nom::bytes::complete::escaped;\nuse nom::character::complete::digit1;\nuse nom::character::complete::one_of;\nuse nom::"
},
{
"path": "tests/expression_ast.rs",
"chars": 5626,
"preview": "use nom::{\n branch::alt,\n bytes::complete::tag,\n character::complete::{alphanumeric1 as alphanumeric, digit1 as digit"
},
{
"path": "tests/float.rs",
"chars": 2993,
"preview": "use nom::branch::alt;\nuse nom::bytes::complete::tag;\nuse nom::character::streaming::digit1 as digit;\nuse nom::combinator"
},
{
"path": "tests/fnmut.rs",
"chars": 686,
"preview": "use nom::{\n bytes::complete::tag,\n multi::{many, many0_count},\n Parser,\n};\n\n#[test]\nfn parse() {\n let mut counter = "
},
{
"path": "tests/ini.rs",
"chars": 5412,
"preview": "use nom::{\n bytes::complete::take_while,\n character::complete::{\n alphanumeric1 as alphanumeric, char, multispace0 "
},
{
"path": "tests/ini_str.rs",
"chars": 5452,
"preview": "use nom::{\n bytes::complete::{is_a, tag, take_till, take_while},\n character::complete::{alphanumeric1 as alphanumeric,"
},
{
"path": "tests/issues.rs",
"chars": 7491,
"preview": "//#![feature(trace_macros)]\n#![allow(dead_code)]\n#![allow(clippy::redundant_closure)]\n\nuse nom::{error::ErrorKind, Err, "
},
{
"path": "tests/json.rs",
"chars": 5749,
"preview": "#![cfg(feature = \"alloc\")]\n\nuse nom::{\n branch::alt,\n bytes::complete::{tag, take},\n character::complete::{anychar, c"
},
{
"path": "tests/mp4.rs",
"chars": 7722,
"preview": "#![allow(dead_code)]\n\nuse nom::{\n branch::alt,\n bytes::streaming::{tag, take},\n combinator::{map, map_res},\n error::"
},
{
"path": "tests/multiline.rs",
"chars": 707,
"preview": "use nom::{\n character::complete::{alphanumeric1 as alphanumeric, line_ending as eol},\n multi::many,\n sequence::termin"
},
{
"path": "tests/overflow.rs",
"chars": 3811,
"preview": "#![allow(clippy::unreadable_literal)]\n#![cfg(target_pointer_width = \"64\")]\n\nuse nom::bytes::streaming::take;\n#[cfg(featu"
},
{
"path": "tests/reborrow_fold.rs",
"chars": 792,
"preview": "#![allow(dead_code)]\n// #![allow(unused_variables)]\n\nuse std::str;\n\nuse nom::bytes::complete::is_not;\nuse nom::character"
}
]
About this extraction
This page contains the full source code of the rust-bakery/nom GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 102 files (3.1 MB), approximately 813.8k tokens, and a symbol index with 1535 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.