Lines Matching refs:input
77 fn skip_whitespace(input: Cursor) -> Cursor {
78 let mut s = input;
125 fn block_comment(input: Cursor) -> PResult<&str> {
126 if !input.starts_with("/*") {
131 let bytes = input.as_bytes();
142 return Ok((input.advance(i + 2), &input.rest[..i + 2]));
157 fn word_break(input: Cursor) -> Result<Cursor, Reject> {
158 match input.chars().next() {
160 Some(_) | None => Ok(input),
168 pub(crate) fn token_stream(mut input: Cursor) -> Result<TokenStream, LexError> {
173 input = skip_whitespace(input);
175 if let Ok((rest, ())) = doc_comment(input, &mut trees) {
176 input = rest;
181 let lo = input.off;
183 let first = match input.bytes().next() {
199 b'(' if !input.starts_with(ERROR) => Some(Delimiter::Parenthesis),
204 input = input.advance(1);
218 None => return Err(lex_error(input)),
224 return Err(lex_error(input));
226 input = input.advance(1);
232 hi: input.off,
237 let (rest, mut tt) = match leaf_token(input) {
239 Err(Reject) => return Err(lex_error(input)),
248 input = rest;
266 fn leaf_token(input: Cursor) -> PResult<TokenTree> {
267 if let Ok((input, l)) = literal(input) {
269 Ok((input, TokenTree::Literal(crate::Literal::_new_fallback(l))))
270 } else if let Ok((input, p)) = punct(input) {
271 Ok((input, TokenTree::Punct(p)))
272 } else if let Ok((input, i)) = ident(input) {
273 Ok((input, TokenTree::Ident(i)))
274 } else if input.starts_with(ERROR) {
275 let rest = input.advance(ERROR.len());
283 fn ident(input: Cursor) -> PResult<crate::Ident> {
288 .any(|prefix| input.starts_with(prefix))
292 ident_any(input)
296 fn ident_any(input: Cursor) -> PResult<crate::Ident> {
297 let raw = input.starts_with("r#");
298 let rest = input.advance((raw as usize) << 1);
322 fn ident_not_raw(input: Cursor) -> PResult<&str> {
323 let mut chars = input.char_indices();
330 let mut end = input.len();
338 Ok((input.advance(end), &input.rest[..end]))
341 pub(crate) fn literal(input: Cursor) -> PResult<Literal> {
342 let rest = literal_nocapture(input)?;
343 let end = input.len() - rest.len();
344 Ok((rest, Literal::_new(input.rest[..end].to_string())))
347 fn literal_nocapture(input: Cursor) -> Result<Cursor, Reject> {
348 if let Ok(ok) = string(input) {
350 } else if let Ok(ok) = byte_string(input) {
352 } else if let Ok(ok) = c_string(input) {
354 } else if let Ok(ok) = byte(input) {
356 } else if let Ok(ok) = character(input) {
358 } else if let Ok(ok) = float(input) {
360 } else if let Ok(ok) = int(input) {
367 fn literal_suffix(input: Cursor) -> Cursor {
368 match ident_not_raw(input) {
369 Ok((input, _)) => input,
370 Err(Reject) => input,
374 fn string(input: Cursor) -> Result<Cursor, Reject> {
375 if let Ok(input) = input.parse("\"") {
376 cooked_string(input)
377 } else if let Ok(input) = input.parse("r") {
378 raw_string(input)
384 fn cooked_string(mut input: Cursor) -> Result<Cursor, Reject> {
385 let mut chars = input.char_indices();
390 let input = input.advance(i + 1);
391 return Ok(literal_suffix(input));
406 input = input.advance(newline + 1);
407 trailing_backslash(&mut input, ch as u8)?;
408 chars = input.char_indices();
418 fn raw_string(input: Cursor) -> Result<Cursor, Reject> {
419 let (input, delimiter) = delimiter_of_raw_string(input)?;
420 let mut bytes = input.bytes().enumerate();
423 b'"' if input.rest[i + 1..].starts_with(delimiter) => {
424 let rest = input.advance(i + 1 + delimiter.len());
437 fn byte_string(input: Cursor) -> Result<Cursor, Reject> {
438 if let Ok(input) = input.parse("b\"") {
439 cooked_byte_string(input)
440 } else if let Ok(input) = input.parse("br") {
441 raw_byte_string(input)
447 fn cooked_byte_string(mut input: Cursor) -> Result<Cursor, Reject> {
448 let mut bytes = input.bytes().enumerate();
452 let input = input.advance(offset + 1);
453 return Ok(literal_suffix(input));
465 input = input.advance(newline + 1);
466 trailing_backslash(&mut input, b)?;
467 bytes = input.bytes().enumerate();
478 fn delimiter_of_raw_string(input: Cursor) -> PResult<&str> {
479 for (i, byte) in input.bytes().enumerate() {
486 return Ok((input.advance(i + 1), &input.rest[..i]));
495 fn raw_byte_string(input: Cursor) -> Result<Cursor, Reject> {
496 let (input, delimiter) = delimiter_of_raw_string(input)?;
497 let mut bytes = input.bytes().enumerate();
500 b'"' if input.rest[i + 1..].starts_with(delimiter) => {
501 let rest = input.advance(i + 1 + delimiter.len());
518 fn c_string(input: Cursor) -> Result<Cursor, Reject> {
519 if let Ok(input) = input.parse("c\"") {
520 cooked_c_string(input)
521 } else if let Ok(input) = input.parse("cr") {
522 raw_c_string(input)
528 fn raw_c_string(input: Cursor) -> Result<Cursor, Reject> {
529 let (input, delimiter) = delimiter_of_raw_string(input)?;
530 let mut bytes = input.bytes().enumerate();
533 b'"' if input.rest[i + 1..].starts_with(delimiter) => {
534 let rest = input.advance(i + 1 + delimiter.len());
548 fn cooked_c_string(mut input: Cursor) -> Result<Cursor, Reject> {
549 let mut chars = input.char_indices();
554 let input = input.advance(i + 1);
555 return Ok(literal_suffix(input));
572 input = input.advance(newline + 1);
573 trailing_backslash(&mut input, ch as u8)?;
574 chars = input.char_indices();
585 fn byte(input: Cursor) -> Result<Cursor, Reject> {
586 let input = input.parse("b'")?;
587 let mut bytes = input.bytes().enumerate();
600 if !input.chars().as_str().is_char_boundary(offset) {
603 let input = input.advance(offset).parse("'")?;
604 Ok(literal_suffix(input))
607 fn character(input: Cursor) -> Result<Cursor, Reject> {
608 let input = input.parse("'")?;
609 let mut chars = input.char_indices();
623 let input = input.advance(idx).parse("'")?;
624 Ok(literal_suffix(input))
696 fn trailing_backslash(input: &mut Cursor, mut last: u8) -> Result<(), Reject> {
697 let mut whitespace = input.bytes().enumerate();
707 *input = input.advance(offset);
715 fn float(input: Cursor) -> Result<Cursor, Reject> {
716 let mut rest = float_digits(input)?;
725 fn float_digits(input: Cursor) -> Result<Cursor, Reject> {
726 let mut chars = input.chars().peekable();
771 Ok(input.advance(len - 1))
807 Ok(input.advance(len))
810 fn int(input: Cursor) -> Result<Cursor, Reject> {
811 let mut rest = digits(input)?;
820 fn digits(mut input: Cursor) -> Result<Cursor, Reject> {
821 let base = if input.starts_with("0x") {
822 input = input.advance(2);
824 } else if input.starts_with("0o") {
825 input = input.advance(2);
827 } else if input.starts_with("0b") {
828 input = input.advance(2);
836 for b in input.bytes() {
871 Ok(input.advance(len))
875 fn punct(input: Cursor) -> PResult<Punct> {
876 let (rest, ch) = punct_char(input)?;
892 fn punct_char(input: Cursor) -> PResult<char> {
893 if input.starts_with("//") || input.starts_with("/*") {
898 let mut chars = input.chars();
907 Ok((input.advance(first.len_utf8()), first))
913 fn doc_comment<'a>(input: Cursor<'a>, trees: &mut TokenStreamBuilder) -> PResult<'a, ()> {
915 let lo = input.off;
916 let (rest, (comment, inner)) = doc_comment_contents(input)?;
961 fn doc_comment_contents(input: Cursor) -> PResult<(&str, bool)> {
962 if input.starts_with("//!") {
963 let input = input.advance(3);
964 let (input, s) = take_until_newline_or_eof(input);
965 Ok((input, (s, true)))
966 } else if input.starts_with("/*!") {
967 let (input, s) = block_comment(input)?;
968 Ok((input, (&s[3..s.len() - 2], true)))
969 } else if input.starts_with("///") {
970 let input = input.advance(3);
971 if input.starts_with_char('/') {
974 let (input, s) = take_until_newline_or_eof(input);
975 Ok((input, (s, false)))
976 } else if input.starts_with("/**") && !input.rest[3..].starts_with('*') {
977 let (input, s) = block_comment(input)?;
978 Ok((input, (&s[3..s.len() - 2], false)))
984 fn take_until_newline_or_eof(input: Cursor) -> (Cursor, &str) {
985 let chars = input.char_indices();
989 return (input.advance(i), &input.rest[..i]);
990 } else if ch == '\r' && input.rest[i + 1..].starts_with('\n') {
991 return (input.advance(i + 1), &input.rest[..i]);
995 (input.advance(input.len()), input.rest)