Lines Matching full:input
23 impl<Input, O, P> Parser<Input> for NotFollowedBy<P>
25 Input: Stream,
26 P: Parser<Input, Output = O>,
31 parse_mode!(Input);
36 input: &mut Input, in parse_mode_impl() argument
38 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_mode_impl()
42 let checkpoint = input.checkpoint(); in parse_mode_impl()
43 let result = self.0.parse_mode(mode, input, state); in parse_mode_impl()
44 ctry!(input.reset(checkpoint).committed()); in parse_mode_impl()
46 CommitOk(_) | PeekOk(_) => PeekErr(Input::Error::empty(input.position()).into()), in parse_mode_impl()
52 fn add_error(&mut self, _errors: &mut Tracked<<Input as StreamOnce>::Error>) {} in add_error()
54 fn add_committed_expected_error(&mut self, _error: &mut Tracked<<Input as StreamOnce>::Error>) { in add_committed_expected_error()
57 forward_parser!(Input, parser_count, 0);
61 /// Never consumes any input.
76 pub fn not_followed_by<Input, P>(parser: P) -> NotFollowedBy<P> in not_followed_by() argument
78 Input: Stream, in not_followed_by()
79 P: Parser<Input>, in not_followed_by() argument
80 P::Output: Into<Info<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, &'static str>>, in not_followed_by()
91 impl<Input, O, P> Parser<Input> for Try<P>
93 Input: Stream,
94 P: Parser<Input, Output = O>,
100 fn parse_stream(&mut self, input: &mut Input) -> ParseResult<O, <Input as StreamOnce>::Error> { in parse_stream()
101 self.parse_lazy(input) in parse_stream()
104 parse_mode!(Input);
109 input: &mut Input, in parse_committed_mode() argument
111 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_committed_mode()
115 self.parse_mode(mode, input, state) in parse_committed_mode()
122 input: &mut Input, in parse_mode_impl() argument
124 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_mode_impl()
128 match self.0.parse_committed_mode(mode, input, state) { in parse_mode_impl()
131 if input.is_partial() && err.is_unexpected_end_of_input() { in parse_mode_impl()
140 forward_parser!(Input, add_error add_committed_expected_error parser_count, 0);
159 pub fn attempt<Input, P>(p: P) -> Try<P> in attempt() argument
161 Input: Stream, in attempt()
162 P: Parser<Input>, in attempt() argument
170 impl<Input, O, P> Parser<Input> for LookAhead<P>
172 Input: Stream,
173 P: Parser<Input, Output = O>,
179 fn parse_lazy(&mut self, input: &mut Input) -> ParseResult<O, <Input as StreamOnce>::Error> { in parse_lazy()
180 let before = input.checkpoint(); in parse_lazy()
181 let result = self.0.parse_lazy(input); in parse_lazy()
182 ctry!(input.reset(before).committed()); in parse_lazy()
187 forward_parser!(Input, add_error add_committed_expected_error parser_count, 0);
190 /// `look_ahead(p)` acts as `p` but doesn't consume input on success.
206 pub fn look_ahead<Input, P>(p: P) -> LookAhead<P> in look_ahead() argument
208 Input: Stream, in look_ahead()
209 P: Parser<Input>, in look_ahead() argument
216 impl<Input, A, B, P, F> Parser<Input> for Map<P, F>
218 Input: Stream,
219 P: Parser<Input, Output = A>,
225 parse_mode!(Input);
230 input: &mut Input, in parse_mode_impl() argument
232 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_mode_impl()
236 match self.0.parse_mode(mode, input, state) { in parse_mode_impl()
244 forward_parser!(Input, add_error add_committed_expected_error parser_count, 0);
250 pub fn map<Input, P, F, B>(p: P, f: F) -> Map<P, F> in map() argument
252 Input: Stream, in map()
253 P: Parser<Input>, in map() argument
261 impl<Input, A, B, P, F> Parser<Input> for MapInput<P, F>
263 Input: Stream,
264 P: Parser<Input, Output = A>,
265 F: FnMut(A, &mut Input) -> B,
270 parse_mode!(Input);
275 input: &mut Input, in parse_mode_impl() argument
277 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_mode_impl()
281 match self.0.parse_mode(mode, input, state) { in parse_mode_impl()
282 CommitOk(x) => CommitOk((self.1)(x, input)), in parse_mode_impl()
283 PeekOk(x) => PeekOk((self.1)(x, input)), in parse_mode_impl()
289 forward_parser!(Input, add_error add_committed_expected_error parser_count, 0);
295 pub fn map_input<Input, P, F, B>(p: P, f: F) -> MapInput<P, F> in map_input() argument
297 Input: Stream, in map_input()
298 P: Parser<Input>, in map_input() argument
299 F: FnMut(P::Output, &mut Input) -> B, in map_input()
306 impl<Input, A, B, P, F> Parser<Input> for FlatMap<P, F>
308 Input: Stream,
309 P: Parser<Input, Output = A>,
310 F: FnMut(A) -> Result<B, Input::Error>,
315 parse_mode!(Input);
320 input: &mut Input, in parse_mode_impl() argument
322 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_mode_impl()
326 match self.0.parse_mode(mode, input, state) { in parse_mode_impl()
340 forward_parser!(Input, add_error add_committed_expected_error parser_count, 0);
346 pub fn flat_map<Input, P, F, B>(p: P, f: F) -> FlatMap<P, F> in flat_map() argument
348 Input: Stream, in flat_map()
349 P: Parser<Input>, in flat_map() argument
350 F: FnMut(P::Output) -> Result<B, <Input as StreamOnce>::Error>, in flat_map()
357 impl<Input, P, F, O, E> Parser<Input> for AndThen<P, F>
359 Input: Stream,
360 P: Parser<Input>,
362 E: Into<<Input::Error as ParseError<Input::Token, Input::Range, Input::Position>>::StreamError>,
363 Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
368 parse_mode!(Input);
372 input: &mut Input, in parse_mode_impl() argument
374 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_mode_impl()
378 let position = input.position(); in parse_mode_impl()
379 let checkpoint = input.checkpoint(); in parse_mode_impl()
380 match self.0.parse_mode(mode, input, state) { in parse_mode_impl()
384 let err = <Input as StreamOnce>::Error::from_error(position, err.into()); in parse_mode_impl()
386 if input.is_partial() && input_at_eof(input) { in parse_mode_impl()
387 ctry!(input.reset(checkpoint).committed()); in parse_mode_impl()
397 if input.is_partial() && input_at_eof(input) { in parse_mode_impl()
398 ctry!(input.reset(checkpoint).committed()); in parse_mode_impl()
400 CommitErr(<Input as StreamOnce>::Error::from_error( in parse_mode_impl()
411 forward_parser!(Input, add_error add_committed_expected_error parser_count, 0);
417 pub fn and_then<Input, P, F, O, E>(p: P, f: F) -> AndThen<P, F> in and_then() argument
419 P: Parser<Input>, in and_then() argument
421 Input: Stream, in and_then()
422 E: Into<<Input::Error as ParseError<Input::Token, Input::Range, Input::Position>>::StreamError>, in and_then()
432 fn recognize_result<Input>( in recognize_result()
434 before: <Input as ResetStream>::Checkpoint, in recognize_result()
435 input: &mut Input, in recognize_result() argument
436 result: ParseResult<P::Output, <Input as StreamOnce>::Error>, in recognize_result()
437 ) -> ParseResult<F, <Input as StreamOnce>::Error> in recognize_result() argument
439 P: Parser<Input>, in recognize_result()
440 Input: Stream, in recognize_result()
441 F: Default + Extend<Input::Token>, in recognize_result()
445 let last_position = input.position(); in recognize_result()
446 ctry!(input.reset(before).committed()); in recognize_result()
448 while input.position() != last_position { in recognize_result()
449 match input.uncons() { in recognize_result()
453 <Input as StreamOnce>::Error::from_error(input.position(), err) in recognize_result()
462 let last_position = input.position(); in recognize_result()
463 ctry!(input.reset(before).committed()); in recognize_result()
465 while input.position() != last_position { in recognize_result()
466 match input.uncons() { in recognize_result()
469 return CommitErr(<Input as StreamOnce>::Error::from_error( in recognize_result()
470 input.position(), in recognize_result()
479 let last_position = input.position(); in recognize_result()
480 ctry!(input.reset(before).committed()); in recognize_result()
482 while input.position() != last_position { in recognize_result()
483 match input.uncons() { in recognize_result()
486 return CommitErr(<Input as StreamOnce>::Error::from_error( in recognize_result()
487 input.position(), in recognize_result()
500 impl<Input, P, F> Parser<Input> for Recognize<F, P>
502 Input: Stream,
503 P: Parser<Input>,
504 F: Default + Extend<<Input as StreamOnce>::Token>,
509 parse_mode!(Input);
513 input: &mut Input, in parse_mode_impl() argument
515 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_mode_impl()
521 let before = input.checkpoint(); in parse_mode_impl()
522 let result = self.0.parse_mode(mode, input, child_state); in parse_mode_impl()
523 Self::recognize_result(elements, before, input, result) in parse_mode_impl()
527 fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>) { in add_error()
533 /// `F: Extend<Input::Token>` instead of `P::Output`.
543 pub fn recognize<F, Input, P>(parser: P) -> Recognize<F, P> in recognize() argument
545 Input: Stream, in recognize()
546 P: Parser<Input>, in recognize() argument
547 F: Default + Extend<<Input as StreamOnce>::Token>, in recognize()
557 impl<Input, L, R> Parser<Input> for Either<L, R>
559 Input: Stream,
560 L: Parser<Input>,
561 R: Parser<Input, Output = L::Output>,
569 input: &mut Input, in parse_lazy() argument
570 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> { in parse_lazy()
572 Either::Left(ref mut x) => x.parse_lazy(input), in parse_lazy()
573 Either::Right(ref mut x) => x.parse_lazy(input), in parse_lazy()
577 parse_mode!(Input);
582 input: &mut Input, in parse_mode_impl() argument
584 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_mode_impl()
598 input, in parse_mode_impl()
614 input, in parse_mode_impl()
625 fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>) { in add_error()
635 impl<Input, P> Parser<Input> for NoPartial<P>
637 Input: Stream,
638 P: Parser<Input>,
640 type Output = <P as Parser<Input>>::Output;
646 input: &mut Input, in parse_lazy() argument
647 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> { in parse_lazy()
648 self.0.parse_lazy(input) in parse_lazy()
651 parse_mode!(Input);
656 input: &mut Input, in parse_mode_impl() argument
658 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_mode_impl()
662 self.0.parse_lazy(input) in parse_mode_impl()
665 forward_parser!(Input, add_error add_committed_expected_error parser_count, 0);
668 pub fn no_partial<Input, P>(p: P) -> NoPartial<P> in no_partial() argument
670 Input: Stream, in no_partial()
671 P: Parser<Input>, in no_partial() argument
678 impl<Input, P> Parser<Input> for Ignore<P>
680 Input: Stream,
681 P: Parser<Input>,
689 input: &mut Input, in parse_lazy() argument
690 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> { in parse_lazy()
691 self.0.parse_lazy(input).map(|_| ()) in parse_lazy()
694 parse_mode!(Input);
699 input: &mut Input, in parse_mode_impl() argument
701 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_mode_impl()
705 self.0.parse_mode(mode, input, state).map(|_| ()) in parse_mode_impl()
708 forward_parser!(Input, add_error add_committed_expected_error parser_count, 0);
712 pub fn ignore<Input, P>(p: P) -> Ignore<P> in ignore() argument
714 Input: Stream, in ignore()
715 P: Parser<Input>, in ignore() argument
730 impl<Input, P> Parser<Input> for AnyPartialStateParser<P>
732 Input: Stream,
733 P: Parser<Input>,
742 input: &mut Input, in parse_lazy() argument
743 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> { in parse_lazy()
744 self.0.parse_lazy(input) in parse_lazy()
747 parse_mode!(Input);
752 input: &mut Input, in parse_mode() argument
754 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_mode()
768 self.0.parse_mode(mode, input, child_state) in parse_mode()
781 forward_parser!(Input, add_error add_committed_expected_error parser_count, 0);
798 /// fn example[Input]()(Input) -> (char, char)
799 /// where [ Input: Stream<Token = char> ]
814 pub fn any_partial_state<Input, P>(p: P) -> AnyPartialStateParser<P> in any_partial_state() argument
816 Input: Stream, in any_partial_state()
817 P: Parser<Input>, in any_partial_state() argument
833 impl<Input, P> Parser<Input> for AnySendPartialStateParser<P>
835 Input: Stream,
836 P: Parser<Input>,
845 input: &mut Input, in parse_lazy() argument
846 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> { in parse_lazy()
847 self.0.parse_lazy(input) in parse_lazy()
850 parse_mode!(Input);
855 input: &mut Input, in parse_mode() argument
857 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_mode()
871 self.0.parse_mode(mode, input, child_state) in parse_mode()
884 forward_parser!(Input, add_error add_committed_expected_error parser_count, 0);
901 /// fn example[Input]()(Input) -> (char, char)
902 /// where [ Input: Stream<Token = char> ]
917 pub fn any_send_partial_state<Input, P>(p: P) -> AnySendPartialStateParser<P> in any_send_partial_state() argument
919 Input: Stream, in any_send_partial_state()
920 P: Parser<Input>, in any_send_partial_state() argument
936 impl<Input, P> Parser<Input> for AnySendSyncPartialStateParser<P>
938 Input: Stream,
939 P: Parser<Input>,
948 input: &mut Input, in parse_lazy() argument
949 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> { in parse_lazy()
950 self.0.parse_lazy(input) in parse_lazy()
953 parse_mode!(Input);
958 input: &mut Input, in parse_mode() argument
960 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_mode()
974 self.0.parse_mode(mode, input, child_state) in parse_mode()
987 forward_parser!(Input, add_error add_committed_expected_error parser_count, 0);
1002 /// fn example<Input>() -> impl Parser<Input, Output = (char, char), PartialState = AnySendSyncPart…
1004 /// Input: Stream<Token = char>,
1005 /// Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
1019 pub fn any_send_sync_partial_state<Input, P>(p: P) -> AnySendSyncPartialStateParser<P> in any_send_sync_partial_state() argument
1021 Input: Stream, in any_send_sync_partial_state()
1022 P: Parser<Input>, in any_send_sync_partial_state() argument
1030 impl<Input, O, P, R> Parser<Input> for Lazy<P>
1032 Input: Stream,
1034 R: Parser<Input, Output = O>,
1039 fn parse_stream(&mut self, input: &mut Input) -> ParseResult<O, <Input as StreamOnce>::Error> { in parse_stream()
1040 (self.0)().parse_stream(input) in parse_stream()
1043 fn parse_lazy(&mut self, input: &mut Input) -> ParseResult<O, <Input as StreamOnce>::Error> { in parse_lazy()
1044 (self.0)().parse_lazy(input) in parse_lazy()
1047 parse_mode!(Input);
1052 input: &mut Input, in parse_committed_mode() argument
1054 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_committed_mode()
1058 (self.0)().parse_mode(mode, input, state) in parse_committed_mode()
1064 input: &mut Input, in parse_mode_impl() argument
1066 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_mode_impl()
1070 (self.0)().parse_mode_impl(mode, input, state) in parse_mode_impl()
1073 fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>) { in add_error()
1077 fn add_committed_expected_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>) { in add_committed_expected_error()
1090 pub fn lazy<Input, P, R>(p: P) -> Lazy<P> in lazy() argument
1092 Input: Stream, in lazy()
1094 R: Parser<Input>, in lazy() argument
1103 fn parser<Input>(&mut self, input: &mut Input) -> &mut R in parser()
1105 P: FnMut(&mut Input) -> R, in parser()
1110 self.1 = Some((self.0)(input)); in parser()
1115 impl<Input, O, P, R> Parser<Input> for Factory<P, R>
1117 Input: Stream,
1118 P: FnMut(&mut Input) -> R,
1119 R: Parser<Input, Output = O>,
1124 parse_mode!(Input);
1129 input: &mut Input, in parse_mode_impl() argument
1131 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_mode_impl()
1140 self.parser(input).parse_mode_impl(mode, input, state) in parse_mode_impl()
1143 fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>) { in add_error()
1149 fn add_committed_expected_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>) { in add_committed_expected_error()
1157 /// takes `Input` as an argument and allows different parsers to be returned on each call to
1172 pub fn factory<Input, P, R>(p: P) -> Factory<P, R> in factory() argument
1174 Input: Stream, in factory()
1175 P: FnMut(&mut Input) -> R, in factory()
1176 R: Parser<Input>, in factory() argument
1274 pub fn from_str[Input, O, P](parser: P)(Input) -> O
1276 P: Parser<Input>,
1284 .ok_or_else(|| StreamErrorFor::<Input>::expected_static_message("UTF-8"))
1285 .and_then(|s| s.parse().map_err(StreamErrorFor::<Input>::message_format))
1291 pub struct Opaque<F, Input, O, S>(F, PhantomData<fn(&mut Input, &mut S) -> O>);
1292 impl<Input, F, O, S> Parser<Input> for Opaque<F, Input, O, S>
1294 Input: Stream,
1296 F: FnMut(&mut dyn FnMut(&mut dyn Parser<Input, Output = O, PartialState = S>)),
1301 fn parse_stream(&mut self, input: &mut Input) -> ParseResult<O, <Input as StreamOnce>::Error> { in parse_stream()
1303 (self.0)(&mut |parser| x = Some(parser.parse_stream(input))); in parse_stream()
1307 fn parse_lazy(&mut self, input: &mut Input) -> ParseResult<O, <Input as StreamOnce>::Error> { in parse_lazy()
1309 (self.0)(&mut |parser| x = Some(parser.parse_lazy(input))); in parse_lazy()
1313 parse_mode!(Input);
1318 input: &mut Input, in parse_mode_impl() argument
1320 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_mode_impl()
1327 parser.parse_first(input, state) in parse_mode_impl()
1329 parser.parse_partial(input, state) in parse_mode_impl()
1335 fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>) { in add_error()
1339 fn add_committed_expected_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>) { in add_committed_expected_error()
1346 pub type FnOpaque<Input, O, S = ()> =
1347 Opaque<fn(&mut dyn FnMut(&mut dyn Parser<Input, Output = O, PartialState = S>)), Input, O, S>;
1374 /// fn expr<Input>() -> FnOpaque<Input, Expr>
1376 /// Input: Stream<Token = char>,
1377 /// Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
1401 pub fn opaque<Input, F, O, S>(f: F) -> Opaque<F, Input, O, S> in opaque() argument
1403 Input: Stream, in opaque()
1405 F: FnMut(&mut dyn FnMut(&mut dyn Parser<Input, Output = O, PartialState = S>)), in opaque() argument
1435 impl<Input, InputInner, P, C> Parser<Input> for InputConverter<InputInner, P, C>
1437 Input: Stream,
1440 for<'c> C: Converter<'c, Input, InputInner = InputInner>,
1445 parse_mode!(Input);
1450 input: &mut Input, in parse_mode_impl() argument
1452 ) -> ParseResult<Self::Output, Input::Error> in parse_mode_impl()
1456 let mut input_inner = match self.converter.convert(input) { in parse_mode_impl()
1462 .map_err(|err| self.converter.convert_error(input, err)) in parse_mode_impl()
1466 pub trait Converter<'a, Input>
1468 Input: Stream,
1471 fn convert(&mut self, input: &'a mut Input) -> Result<Self::InputInner, Input::Error>; in convert()
1474 input: &'a mut Input, in convert_error() argument
1476 ) -> Input::Error; in convert_error()
1479 impl<'a, Input, InputInner> Converter<'a, Input>
1481 fn(&'a mut Input) -> Result<InputInner, Input::Error>,
1482 fn(&'a mut Input, InputInner::Error) -> Input::Error,
1485 Input: Stream,
1489 fn convert(&mut self, input: &'a mut Input) -> Result<InputInner, Input::Error> { in convert()
1490 (self.0)(input) in convert()
1492 fn convert_error(&mut self, input: &'a mut Input, error: InputInner::Error) -> Input::Error { in convert_error() argument
1493 (self.1)(input, error) in convert_error()
1497 pub fn input_converter<Input, InputInner, P, C>( in input_converter() argument
1502 Input: Stream, in input_converter()
1505 for<'c> C: Converter<'c, Input, InputInner = InputInner>, in input_converter()
1516 impl<Input, P, Q> Parser<Input> for Spanned<P>
1518 P: Parser<Input>,
1519 Input: Stream<Position = Span<Q>>,
1520 Input::Error: ParseError<Input::Token, Input::Range, Span<Q>>,
1526 parse_mode!(Input);
1531 input: &mut Input, in parse_mode_impl() argument
1533 ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> in parse_mode_impl()
1537 let start = input.position().start; in parse_mode_impl()
1538 self.0.parse_mode(mode, input, state).map_err(|mut err| { in parse_mode_impl()
1543 let end = input.position().end; in parse_mode_impl()
1550 forward_parser!(Input, add_error, add_committed_expected_error, 0);
1556 pub fn spanned<Input, P>(p: P) -> Spanned<P> in spanned() argument
1558 P: Parser<Input>, in spanned()
1559 Input: Stream, in spanned()