Crate nom [−] [src]
Nom, eating data byte by byte
The goal is to make a parser combinator library that is safe, supports streaming (push and pull), and as much as possible zero copy.
The code is available on Github
Example
#[macro_use] extern crate nom; use nom::{Consumer,ConsumerState,MemProducer,IResult}; use nom::IResult::*; // Parser definition named!( om_parser, tag!( "om" ) ); named!( nomnom_parser< &[u8], Vec<&[u8]> >, many1!( tag!( "nom" ) ) ); named!( end_parser, tag!( "kthxbye") ); // Streaming parsing and state machine #[derive(PartialEq,Eq,Debug)] enum State { Beginning, Middle, End, Done } struct TestConsumer { state: State, counter: usize } impl Consumer for TestConsumer { fn consume(&mut self, input: &[u8]) -> ConsumerState { match self.state { State::Beginning => { match om_parser(input) { Error(_) => ConsumerState::ConsumerError(0), Incomplete(_) => ConsumerState::Await(0, 2), Done(_,_) => { // "om" was recognized, get to the next state self.state = State::Middle; ConsumerState::Await(2, 3) } } }, State::Middle => { match nomnom_parser(input) { Error(a) => { // the "nom" parser failed, let's get to the next state self.state = State::End; ConsumerState::Await(0, 7) }, Incomplete(_) => ConsumerState::Await(0, 3), Done(i,noms_vec) => { // we got a few noms, let's count them and continue self.counter = self.counter + noms_vec.len(); ConsumerState::Await(input.len() - i.len(), 3) } } }, State::End => { match end_parser(input) { Error(_) => ConsumerState::ConsumerError(0), Incomplete(_) => ConsumerState::Await(0, 7), Done(_,_) => { // we recognized the suffix, everything was parsed correctly self.state = State::Done; ConsumerState::ConsumerDone } } }, State::Done => { // this should not be called ConsumerState::ConsumerError(42) } } } fn end(&mut self) { println!("we counted {} noms", self.counter); } } fn main() { let mut p = MemProducer::new(b"omnomnomnomkthxbye", 4); let mut c = TestConsumer{state: State::Beginning, counter: 0}; c.run(&mut p); assert_eq!(c.counter, 3); assert_eq!(c.state, State::Done); }
Reexports
pub use self::util::*; |
pub use self::internal::*; |
pub use self::macros::*; |
pub use self::producer::*; |
pub use self::consumer::*; |
pub use self::nom::*; |
Modules
consumer |
Data consumers |
internal |
Basic types to build the parsers |
macros |
Macro combinators |
nom |
Useful parser combinators |
producer |
Data producers |
util |
Macros
alt! |
try a list of parser, return the result of the first successful one |
alt_parser! |
Internal parser, do not use directly |
apply! | |
call! |
Used to wrap common expressions and function as macros |
chain! |
chains parsers and assemble the results through a closure |
chaining_parser! |
Internal parser, do not use directly |
closure! |
Wraps a parser in a closure |
cond! |
Conditional combinator |
count! |
Applies the child parser a specified number of times |
dbg! |
Prints a message if the parser fails |
dbg_dmp! |
Prints a message and the input if the parser fails |
delimited! |
delimited(opening, X, closing) returns X |
error! |
Prevents backtracking if the child parser fails |
fail! | |
filter! |
returns the longest list of bytes until the provided parser fails |
flat_map! |
flat_map! combines a parser R -> IResult |
is_a! |
returns the longest list of bytes that appear in the provided array |
is_not! |
returns the longest list of bytes that do not appear in the provided array |
length_value! |
returns |
many0! |
Applies the parser 0 or more times and returns the list of results in a Vec |
many1! |
Applies the parser 1 or more times and returns the list of results in a Vec |
map! |
maps a function on the result of a parser |
map_opt! |
maps a function returning an Option on the output of a parser |
map_res! |
maps a function returning a Result on the output of a parser |
named! |
Makes a function from a parser combination |
opt! |
make the underlying parser optional |
pair! |
pair(X,Y), returns (x,y) |
peek! |
returns a result without consuming the input |
preceded! |
preceded(opening, X) returns X |
pusher! |
Prepares a parser function for a push pipeline |
separated_list! |
separated_list(sep, X) returns Vec |
separated_nonempty_list! |
separated_nonempty_list(sep, X) returns Vec |
separated_pair! |
separated_pair(X,sep,Y) returns (x,y) |
tag! |
declares a byte array as a suite to recognize |
take! |
generates a parser consuming the specified number of bytes |
take_str! |
same as take! but returning a &str |
take_until! | |
take_until_and_consume! |
generates a parser consuming bytes until the specified byte sequence is found |
take_until_either! | |
take_until_either_and_consume! | |
terminated! |
terminated(X, closing) returns X |