From a68d7f9415f5d58b44a10aa32a51434080abb346 Mon Sep 17 00:00:00 2001 From: Kornel Date: Tue, 30 Aug 2022 04:51:35 +0100 Subject: [PATCH] Edition 2018 (#121) * Edition 2018 * Fix unused const on aarch64 * Fix Edition 2018 for SIMD --- Cargo.toml | 2 +- benches/parse.rs | 10 +- src/iter.rs | 2 +- src/lib.rs | 216 +++++++++++++++++++++---------------------- src/simd/avx2.rs | 6 +- src/simd/fallback.rs | 6 +- src/simd/mod.rs | 23 +++-- src/simd/sse42.rs | 6 +- tests/uri.rs | 3 +- 9 files changed, 138 insertions(+), 136 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 736e66c..0db1be2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,7 +10,7 @@ documentation = "https://docs.rs/httparse" readme = "README.md" keywords = ["http", "parser", "no_std"] categories = ["network-programming", "no-std", "parser-implementations", "web-programming"] - +edition = "2018" build = "build.rs" [features] diff --git a/benches/parse.rs b/benches/parse.rs index 7b1cbd5..cc6d470 100644 --- a/benches/parse.rs +++ b/benches/parse.rs @@ -1,16 +1,14 @@ -extern crate criterion; -extern crate httparse; use std::time::Duration; use criterion::{black_box, criterion_group, criterion_main, Criterion, Throughput}; -const REQ_SHORT: &'static [u8] = b"\ +const REQ_SHORT: &[u8] = b"\ GET / HTTP/1.0\r\n\ Host: example.com\r\n\ Cookie: session=60; user_id=1\r\n\r\n"; -const REQ: &'static [u8] = b"\ +const REQ: &[u8] = b"\ GET /wp-content/uploads/2010/03/hello-kitty-darth-vader-pink.jpg HTTP/1.1\r\n\ Host: www.kittyhell.com\r\n\ User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.6; ja-JP-mac; rv:1.9.2.3) Gecko/20100401 Firefox/3.6.3 Pathtraq/0.9\r\n\ @@ -44,13 +42,13 @@ fn req_short(c: &mut Criterion) { })); } -const RESP_SHORT: &'static [u8] = b"\ +const RESP_SHORT: &[u8] = b"\ HTTP/1.0 200 OK\r\n\ Date: Wed, 21 Oct 2015 07:28:00 GMT\r\n\ Set-Cookie: session=60; user_id=1\r\n\r\n"; // These particular headers don't all make semantic sense for a response, but they're syntactically valid. -const RESP: &'static [u8] = b"\ +const RESP: &[u8] = b"\ HTTP/1.1 200 OK\r\n\ Date: Wed, 21 Oct 2015 07:28:00 GMT\r\n\ Host: www.kittyhell.com\r\n\ diff --git a/src/iter.rs b/src/iter.rs index dcd4df8..c004f41 100644 --- a/src/iter.rs +++ b/src/iter.rs @@ -28,7 +28,7 @@ impl<'a> Bytes<'a> { #[inline] pub fn peek_ahead(&self, n: usize) -> Option { - self.slice.get(self.pos + n).cloned() + self.slice.get(self.pos + n).copied() } #[inline] diff --git a/src/lib.rs b/src/lib.rs index dce6fd4..7153de5 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -20,13 +20,11 @@ //! If compiling for a specific target, remembering to include //! `-C target_cpu=native` allows the detection to become compile time checks, //! making it *even* faster. -#[cfg(feature = "std")] -extern crate std as core; use core::{fmt, result, str}; use core::mem::{self, MaybeUninit}; -use iter::Bytes; +use crate::iter::Bytes; mod iter; #[macro_use] mod macros; @@ -167,7 +165,7 @@ impl Error { } impl fmt::Display for Error { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str(self.description_str()) } } @@ -185,7 +183,7 @@ impl std::error::Error for Error { pub struct InvalidChunkSize; impl fmt::Display for InvalidChunkSize { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str("invalid chunk size") } } @@ -446,7 +444,7 @@ impl ParserConfig { /// } /// ``` #[derive(Debug, Eq, PartialEq)] -pub struct Request<'headers, 'buf: 'headers> { +pub struct Request<'headers, 'buf> { /// The request method, such as `GET`. pub method: Option<&'buf str>, /// The request path, such as `/about-us`. @@ -535,13 +533,13 @@ impl<'h, 'b> Request<'h, 'b> { /* SAFETY: see `parse_headers_iter_uninit` guarantees */ unsafe { - let headers: *mut [Header] = headers; - let headers = headers as *mut [MaybeUninit
]; + let headers: *mut [Header<'_>] = headers; + let headers = headers as *mut [MaybeUninit>]; match self.parse_with_config_and_uninit_headers(buf, config, &mut *headers) { Ok(Status::Complete(idx)) => Ok(Status::Complete(idx)), other => { // put the original headers back - self.headers = &mut *(headers as *mut [Header]); + self.headers = &mut *(headers as *mut [Header<'_>]); other }, } @@ -557,7 +555,7 @@ impl<'h, 'b> Request<'h, 'b> { } #[inline] -fn skip_empty_lines(bytes: &mut Bytes) -> Result<()> { +fn skip_empty_lines(bytes: &mut Bytes<'_>) -> Result<()> { loop { let b = bytes.peek(); match b { @@ -580,7 +578,7 @@ fn skip_empty_lines(bytes: &mut Bytes) -> Result<()> { } #[inline] -fn skip_spaces(bytes: &mut Bytes) -> Result<()> { +fn skip_spaces(bytes: &mut Bytes<'_>) -> Result<()> { loop { let b = bytes.peek(); match b { @@ -601,7 +599,7 @@ fn skip_spaces(bytes: &mut Bytes) -> Result<()> { /// /// See `Request` docs for explanation of optional values. #[derive(Debug, Eq, PartialEq)] -pub struct Response<'headers, 'buf: 'headers> { +pub struct Response<'headers, 'buf> { /// The response minor version, such as `1` for `HTTP/1.1`. pub version: Option, /// The response code, such as `200`. @@ -635,13 +633,13 @@ impl<'h, 'b> Response<'h, 'b> { let headers = mem::replace(&mut self.headers, &mut []); unsafe { - let headers: *mut [Header] = headers; - let headers = headers as *mut [MaybeUninit
]; + let headers: *mut [Header<'_>] = headers; + let headers = headers as *mut [MaybeUninit>]; match self.parse_with_config_and_uninit_headers(buf, config, &mut *headers) { Ok(Status::Complete(idx)) => Ok(Status::Complete(idx)), other => { // put the original headers back - self.headers = &mut *(headers as *mut [Header]); + self.headers = &mut *(headers as *mut [Header<'_>]); other }, } @@ -745,7 +743,7 @@ impl<'a> fmt::Debug for Header<'a> { pub const EMPTY_HEADER: Header<'static> = Header { name: "", value: b"" }; #[inline] -fn parse_version(bytes: &mut Bytes) -> Result { +fn parse_version(bytes: &mut Bytes<'_>) -> Result { if let Some(eight) = bytes.peek_n::<[u8; 8]>(8) { unsafe { bytes.advance(8); } return match &eight { @@ -864,7 +862,7 @@ fn parse_uri<'a>(bytes: &mut Bytes<'a>) -> Result<&'a str> { #[inline] -fn parse_code(bytes: &mut Bytes) -> Result { +fn parse_code(bytes: &mut Bytes<'_>) -> Result { let hundreds = expect!(bytes.next() == b'0'..=b'9' => Err(Error::Status)); let tens = expect!(bytes.next() == b'0'..=b'9' => Err(Error::Status)); let ones = expect!(bytes.next() == b'0'..=b'9' => Err(Error::Status)); @@ -1437,7 +1435,7 @@ mod tests { req! { test_request_partial_parses_headers_as_much_as_it_can, b"GET / HTTP/1.1\r\nHost: yolo\r\n", - Ok(::Status::Partial), + Ok(crate::Status::Partial), |req| { assert_eq!(req.method.unwrap(), "GET"); assert_eq!(req.path.unwrap(), "/"); @@ -1490,7 +1488,7 @@ mod tests { req! { test_request_with_invalid_token_delimiter, b"GET\n/ HTTP/1.1\r\nHost: foo.bar\r\n\r\n", - Err(::Error::Token), + Err(crate::Error::Token), |_r| {} } @@ -1498,28 +1496,28 @@ mod tests { req! { test_request_with_invalid_but_short_version, b"GET / HTTP/1!", - Err(::Error::Version), + Err(crate::Error::Version), |_r| {} } req! { test_request_with_empty_method, b" / HTTP/1.1\r\n\r\n", - Err(::Error::Token), + Err(crate::Error::Token), |_r| {} } req! { test_request_with_empty_path, b"GET HTTP/1.1\r\n\r\n", - Err(::Error::Token), + Err(crate::Error::Token), |_r| {} } req! { test_request_with_empty_method_and_path, b" HTTP/1.1\r\n\r\n", - Err(::Error::Token), + Err(crate::Error::Token), |_r| {} } @@ -1602,7 +1600,7 @@ mod tests { } } - static RESPONSE_REASON_WITH_OBS_TEXT_BYTE: &'static [u8] = b"HTTP/1.1 200 X\xFFZ\r\n\r\n"; + static RESPONSE_REASON_WITH_OBS_TEXT_BYTE: &[u8] = b"HTTP/1.1 200 X\xFFZ\r\n\r\n"; res! { test_response_reason_with_obsolete_text_byte, RESPONSE_REASON_WITH_OBS_TEXT_BYTE, @@ -1617,7 +1615,7 @@ mod tests { res! { test_response_reason_with_nul_byte, b"HTTP/1.1 200 \x00\r\n\r\n", - Err(::Error::Status), + Err(crate::Error::Status), |_res| {} } @@ -1638,7 +1636,7 @@ mod tests { res! { test_response_partial_parses_headers_as_much_as_it_can, b"HTTP/1.1 200 OK\r\nServer: yolo\r\n", - Ok(::Status::Partial), + Ok(crate::Status::Partial), |res| { assert_eq!(res.version.unwrap(), 1); assert_eq!(res.code.unwrap(), 200); @@ -1668,7 +1666,7 @@ mod tests { } } - static RESPONSE_WITH_WHITESPACE_BETWEEN_HEADER_NAME_AND_COLON: &'static [u8] = + static RESPONSE_WITH_WHITESPACE_BETWEEN_HEADER_NAME_AND_COLON: &[u8] = b"HTTP/1.1 200 OK\r\nAccess-Control-Allow-Credentials : true\r\nBread: baguette\r\n\r\n"; #[test] @@ -1677,14 +1675,14 @@ mod tests { let mut response = Response::new(&mut headers[..]); let result = response.parse(RESPONSE_WITH_WHITESPACE_BETWEEN_HEADER_NAME_AND_COLON); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); } #[test] fn test_allow_response_with_whitespace_between_header_name_and_colon() { let mut headers = [EMPTY_HEADER; 2]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .allow_spaces_after_header_name_in_responses(true) .parse_response(&mut response, RESPONSE_WITH_WHITESPACE_BETWEEN_HEADER_NAME_AND_COLON); @@ -1703,7 +1701,7 @@ mod tests { fn test_ignore_header_line_with_whitespaces_after_header_name() { let mut headers = [EMPTY_HEADER; 2]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .ignore_invalid_headers_in_responses(true) .parse_response(&mut response, RESPONSE_WITH_WHITESPACE_BETWEEN_HEADER_NAME_AND_COLON); @@ -1716,7 +1714,7 @@ mod tests { assert_eq!(response.headers[0].value, &b"baguette"[..]); } - static REQUEST_WITH_WHITESPACE_BETWEEN_HEADER_NAME_AND_COLON: &'static [u8] = + static REQUEST_WITH_WHITESPACE_BETWEEN_HEADER_NAME_AND_COLON: &[u8] = b"GET / HTTP/1.1\r\nHost : localhost\r\n\r\n"; #[test] @@ -1725,10 +1723,10 @@ mod tests { let mut request = Request::new(&mut headers[..]); let result = request.parse(REQUEST_WITH_WHITESPACE_BETWEEN_HEADER_NAME_AND_COLON); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); } - static RESPONSE_WITH_OBSOLETE_LINE_FOLDING_AT_START: &'static [u8] = + static RESPONSE_WITH_OBSOLETE_LINE_FOLDING_AT_START: &[u8] = b"HTTP/1.1 200 OK\r\nLine-Folded-Header: \r\n \r\n hello there\r\n\r\n"; #[test] @@ -1737,14 +1735,14 @@ mod tests { let mut response = Response::new(&mut headers[..]); let result = response.parse(RESPONSE_WITH_OBSOLETE_LINE_FOLDING_AT_START); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); } #[test] fn test_allow_response_with_obsolete_line_folding_at_start() { let mut headers = [EMPTY_HEADER; 1]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .allow_obsolete_multiline_headers_in_responses(true) .parse_response(&mut response, RESPONSE_WITH_OBSOLETE_LINE_FOLDING_AT_START); @@ -1757,7 +1755,7 @@ mod tests { assert_eq!(response.headers[0].value, &b"hello there"[..]); } - static RESPONSE_WITH_OBSOLETE_LINE_FOLDING_AT_END: &'static [u8] = + static RESPONSE_WITH_OBSOLETE_LINE_FOLDING_AT_END: &[u8] = b"HTTP/1.1 200 OK\r\nLine-Folded-Header: hello there\r\n \r\n \r\n\r\n"; #[test] @@ -1766,14 +1764,14 @@ mod tests { let mut response = Response::new(&mut headers[..]); let result = response.parse(RESPONSE_WITH_OBSOLETE_LINE_FOLDING_AT_END); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); } #[test] fn test_allow_response_with_obsolete_line_folding_at_end() { let mut headers = [EMPTY_HEADER; 1]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .allow_obsolete_multiline_headers_in_responses(true) .parse_response(&mut response, RESPONSE_WITH_OBSOLETE_LINE_FOLDING_AT_END); @@ -1786,7 +1784,7 @@ mod tests { assert_eq!(response.headers[0].value, &b"hello there"[..]); } - static RESPONSE_WITH_OBSOLETE_LINE_FOLDING_IN_MIDDLE: &'static [u8] = + static RESPONSE_WITH_OBSOLETE_LINE_FOLDING_IN_MIDDLE: &[u8] = b"HTTP/1.1 200 OK\r\nLine-Folded-Header: hello \r\n \r\n there\r\n\r\n"; #[test] @@ -1795,14 +1793,14 @@ mod tests { let mut response = Response::new(&mut headers[..]); let result = response.parse(RESPONSE_WITH_OBSOLETE_LINE_FOLDING_IN_MIDDLE); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); } #[test] fn test_allow_response_with_obsolete_line_folding_in_middle() { let mut headers = [EMPTY_HEADER; 1]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .allow_obsolete_multiline_headers_in_responses(true) .parse_response(&mut response, RESPONSE_WITH_OBSOLETE_LINE_FOLDING_IN_MIDDLE); @@ -1815,7 +1813,7 @@ mod tests { assert_eq!(response.headers[0].value, &b"hello \r\n \r\n there"[..]); } - static RESPONSE_WITH_OBSOLETE_LINE_FOLDING_IN_EMPTY_HEADER: &'static [u8] = + static RESPONSE_WITH_OBSOLETE_LINE_FOLDING_IN_EMPTY_HEADER: &[u8] = b"HTTP/1.1 200 OK\r\nLine-Folded-Header: \r\n \r\n \r\n\r\n"; #[test] @@ -1824,14 +1822,14 @@ mod tests { let mut response = Response::new(&mut headers[..]); let result = response.parse(RESPONSE_WITH_OBSOLETE_LINE_FOLDING_IN_EMPTY_HEADER); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); } #[test] fn test_allow_response_with_obsolete_line_folding_in_empty_header() { let mut headers = [EMPTY_HEADER; 1]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .allow_obsolete_multiline_headers_in_responses(true) .parse_response(&mut response, RESPONSE_WITH_OBSOLETE_LINE_FOLDING_IN_EMPTY_HEADER); @@ -1853,16 +1851,16 @@ mod tests { assert_eq!(parse_chunk_size(b"3735ab1 ; baz \r\n"), Ok(Status::Complete((16, 57891505)))); assert_eq!(parse_chunk_size(b"77a65\r"), Ok(Status::Partial)); assert_eq!(parse_chunk_size(b"ab"), Ok(Status::Partial)); - assert_eq!(parse_chunk_size(b"567f8a\rfoo"), Err(::InvalidChunkSize)); - assert_eq!(parse_chunk_size(b"567f8a\rfoo"), Err(::InvalidChunkSize)); - assert_eq!(parse_chunk_size(b"567xf8a\r\n"), Err(::InvalidChunkSize)); - assert_eq!(parse_chunk_size(b"ffffffffffffffff\r\n"), Ok(Status::Complete((18, ::core::u64::MAX)))); - assert_eq!(parse_chunk_size(b"1ffffffffffffffff\r\n"), Err(::InvalidChunkSize)); - assert_eq!(parse_chunk_size(b"Affffffffffffffff\r\n"), Err(::InvalidChunkSize)); - assert_eq!(parse_chunk_size(b"fffffffffffffffff\r\n"), Err(::InvalidChunkSize)); + assert_eq!(parse_chunk_size(b"567f8a\rfoo"), Err(crate::InvalidChunkSize)); + assert_eq!(parse_chunk_size(b"567f8a\rfoo"), Err(crate::InvalidChunkSize)); + assert_eq!(parse_chunk_size(b"567xf8a\r\n"), Err(crate::InvalidChunkSize)); + assert_eq!(parse_chunk_size(b"ffffffffffffffff\r\n"), Ok(Status::Complete((18, std::u64::MAX)))); + assert_eq!(parse_chunk_size(b"1ffffffffffffffff\r\n"), Err(crate::InvalidChunkSize)); + assert_eq!(parse_chunk_size(b"Affffffffffffffff\r\n"), Err(crate::InvalidChunkSize)); + assert_eq!(parse_chunk_size(b"fffffffffffffffff\r\n"), Err(crate::InvalidChunkSize)); } - static RESPONSE_WITH_MULTIPLE_SPACE_DELIMITERS: &'static [u8] = + static RESPONSE_WITH_MULTIPLE_SPACE_DELIMITERS: &[u8] = b"HTTP/1.1 200 OK\r\n\r\n"; #[test] @@ -1871,14 +1869,14 @@ mod tests { let mut response = Response::new(&mut headers[..]); let result = response.parse(RESPONSE_WITH_MULTIPLE_SPACE_DELIMITERS); - assert_eq!(result, Err(::Error::Status)); + assert_eq!(result, Err(crate::Error::Status)); } #[test] fn test_allow_response_with_multiple_space_delimiters() { let mut headers = [EMPTY_HEADER; NUM_OF_HEADERS]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .allow_multiple_spaces_in_response_status_delimiters(true) .parse_response(&mut response, RESPONSE_WITH_MULTIPLE_SPACE_DELIMITERS); @@ -1891,7 +1889,7 @@ mod tests { /// This is technically allowed by the spec, but we only support multiple spaces as an option, /// not stray `\r`s. - static RESPONSE_WITH_WEIRD_WHITESPACE_DELIMITERS: &'static [u8] = + static RESPONSE_WITH_WEIRD_WHITESPACE_DELIMITERS: &[u8] = b"HTTP/1.1 200\rOK\r\n\r\n"; #[test] @@ -1900,20 +1898,20 @@ mod tests { let mut response = Response::new(&mut headers[..]); let result = response.parse(RESPONSE_WITH_WEIRD_WHITESPACE_DELIMITERS); - assert_eq!(result, Err(::Error::Status)); + assert_eq!(result, Err(crate::Error::Status)); } #[test] fn test_still_forbid_response_with_weird_whitespace_delimiters() { let mut headers = [EMPTY_HEADER; NUM_OF_HEADERS]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .allow_multiple_spaces_in_response_status_delimiters(true) .parse_response(&mut response, RESPONSE_WITH_WEIRD_WHITESPACE_DELIMITERS); - assert_eq!(result, Err(::Error::Status)); + assert_eq!(result, Err(crate::Error::Status)); } - static REQUEST_WITH_MULTIPLE_SPACE_DELIMITERS: &'static [u8] = + static REQUEST_WITH_MULTIPLE_SPACE_DELIMITERS: &[u8] = b"GET / HTTP/1.1\r\n\r\n"; #[test] @@ -1922,14 +1920,14 @@ mod tests { let mut request = Request::new(&mut headers[..]); let result = request.parse(REQUEST_WITH_MULTIPLE_SPACE_DELIMITERS); - assert_eq!(result, Err(::Error::Token)); + assert_eq!(result, Err(crate::Error::Token)); } #[test] fn test_allow_request_with_multiple_space_delimiters() { let mut headers = [EMPTY_HEADER; NUM_OF_HEADERS]; let mut request = Request::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .allow_multiple_spaces_in_request_line_delimiters(true) .parse_request(&mut request, REQUEST_WITH_MULTIPLE_SPACE_DELIMITERS); @@ -1942,7 +1940,7 @@ mod tests { /// This is technically allowed by the spec, but we only support multiple spaces as an option, /// not stray `\r`s. - static REQUEST_WITH_WEIRD_WHITESPACE_DELIMITERS: &'static [u8] = + static REQUEST_WITH_WEIRD_WHITESPACE_DELIMITERS: &[u8] = b"GET\r/\rHTTP/1.1\r\n\r\n"; #[test] @@ -1951,41 +1949,41 @@ mod tests { let mut request = Request::new(&mut headers[..]); let result = request.parse(REQUEST_WITH_WEIRD_WHITESPACE_DELIMITERS); - assert_eq!(result, Err(::Error::Token)); + assert_eq!(result, Err(crate::Error::Token)); } #[test] fn test_still_forbid_request_with_weird_whitespace_delimiters() { let mut headers = [EMPTY_HEADER; NUM_OF_HEADERS]; let mut request = Request::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .allow_multiple_spaces_in_request_line_delimiters(true) .parse_request(&mut request, REQUEST_WITH_WEIRD_WHITESPACE_DELIMITERS); - assert_eq!(result, Err(::Error::Token)); + assert_eq!(result, Err(crate::Error::Token)); } - static REQUEST_WITH_MULTIPLE_SPACES_AND_BAD_PATH: &'static [u8] = b"GET /foo>ohno HTTP/1.1\r\n\r\n"; + static REQUEST_WITH_MULTIPLE_SPACES_AND_BAD_PATH: &[u8] = b"GET /foo>ohno HTTP/1.1\r\n\r\n"; #[test] fn test_request_with_multiple_spaces_and_bad_path() { let mut headers = [EMPTY_HEADER; NUM_OF_HEADERS]; let mut request = Request::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .allow_multiple_spaces_in_request_line_delimiters(true) .parse_request(&mut request, REQUEST_WITH_MULTIPLE_SPACES_AND_BAD_PATH); - assert_eq!(result, Err(::Error::Token)); + assert_eq!(result, Err(crate::Error::Token)); } - static RESPONSE_WITH_SPACES_IN_CODE: &'static [u8] = b"HTTP/1.1 99 200 OK\r\n\r\n"; + static RESPONSE_WITH_SPACES_IN_CODE: &[u8] = b"HTTP/1.1 99 200 OK\r\n\r\n"; #[test] fn test_response_with_spaces_in_code() { let mut headers = [EMPTY_HEADER; NUM_OF_HEADERS]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .allow_multiple_spaces_in_response_status_delimiters(true) .parse_response(&mut response, RESPONSE_WITH_SPACES_IN_CODE); - assert_eq!(result, Err(::Error::Status)); + assert_eq!(result, Err(crate::Error::Status)); } #[test] @@ -1996,12 +1994,12 @@ mod tests { let mut headers = [EMPTY_HEADER; 2]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .allow_spaces_after_header_name_in_responses(true) .parse_response(&mut response, RESPONSE); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .ignore_invalid_headers_in_responses(true) .parse_response(&mut response, RESPONSE); assert_eq!(result, Ok(Status::Complete(45))); @@ -2022,16 +2020,16 @@ mod tests { let mut headers = [EMPTY_HEADER; 2]; let mut request = Request::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .allow_spaces_after_header_name_in_responses(true) .parse_request(&mut request, REQUEST); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .ignore_invalid_headers_in_responses(true) .parse_request(&mut request, REQUEST); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); } #[test] @@ -2042,12 +2040,12 @@ mod tests { let mut headers = [EMPTY_HEADER; 2]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .allow_spaces_after_header_name_in_responses(true) .parse_response(&mut response, RESPONSE); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .ignore_invalid_headers_in_responses(true) .parse_response(&mut response, RESPONSE); @@ -2068,11 +2066,11 @@ mod tests { let mut headers = [EMPTY_HEADER; 2]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .parse_response(&mut response, RESPONSE); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .ignore_invalid_headers_in_responses(true) .parse_response(&mut response, RESPONSE); assert_eq!(result, Ok(Status::Complete(70))); @@ -2093,13 +2091,13 @@ mod tests { let mut headers = [EMPTY_HEADER; 2]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .allow_obsolete_multiline_headers_in_responses(true) .allow_spaces_after_header_name_in_responses(true) .parse_response(&mut response, RESPONSE); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .ignore_invalid_headers_in_responses(true) .parse_response(&mut response, RESPONSE); assert_eq!(result, Ok(Status::Complete(81))); @@ -2120,14 +2118,14 @@ mod tests { let mut headers = [EMPTY_HEADER; 2]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .parse_response(&mut response, RESPONSE); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .ignore_invalid_headers_in_responses(true) .parse_response(&mut response, RESPONSE); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); } #[test] @@ -2138,14 +2136,14 @@ mod tests { let mut headers = [EMPTY_HEADER; 2]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .parse_response(&mut response, RESPONSE); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .ignore_invalid_headers_in_responses(true) .parse_response(&mut response, RESPONSE); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); } #[test] @@ -2156,16 +2154,16 @@ mod tests { let mut headers = [EMPTY_HEADER; 2]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .allow_spaces_after_header_name_in_responses(true) .parse_response(&mut response, RESPONSE); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .allow_spaces_after_header_name_in_responses(true) .ignore_invalid_headers_in_responses(true) .parse_response(&mut response, RESPONSE); - assert_eq!(result, Err(::Error::HeaderName)); + assert_eq!(result, Err(crate::Error::HeaderName)); } #[test] @@ -2176,14 +2174,14 @@ mod tests { let mut headers = [EMPTY_HEADER; 2]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .parse_response(&mut response, RESPONSE); - assert_eq!(result, Err(::Error::HeaderValue)); + assert_eq!(result, Err(crate::Error::HeaderValue)); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .ignore_invalid_headers_in_responses(true) .parse_response(&mut response, RESPONSE); - assert_eq!(result, Err(::Error::HeaderValue)); + assert_eq!(result, Err(crate::Error::HeaderValue)); } #[test] @@ -2194,11 +2192,11 @@ mod tests { let mut headers = [EMPTY_HEADER; 2]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .parse_response(&mut response, RESPONSE); - assert_eq!(result, Err(::Error::HeaderValue)); + assert_eq!(result, Err(crate::Error::HeaderValue)); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .ignore_invalid_headers_in_responses(true) .parse_response(&mut response, RESPONSE); assert_eq!(result, Ok(Status::Complete(78))); @@ -2219,11 +2217,11 @@ mod tests { let mut headers = [EMPTY_HEADER; 2]; let mut response = Response::new(&mut headers[..]); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .parse_response(&mut response, RESPONSE); - assert_eq!(result, Err(::Error::HeaderValue)); + assert_eq!(result, Err(crate::Error::HeaderValue)); - let result = ::ParserConfig::default() + let result = crate::ParserConfig::default() .ignore_invalid_headers_in_responses(true) .parse_response(&mut response, RESPONSE); assert_eq!(result, Ok(Status::Complete(88))); diff --git a/src/simd/avx2.rs b/src/simd/avx2.rs index ddf3ec8..6bea358 100644 --- a/src/simd/avx2.rs +++ b/src/simd/avx2.rs @@ -1,4 +1,4 @@ -use ::iter::Bytes; +use crate::iter::Bytes; pub enum Scan { /// Returned when an implementation finds a noteworthy token. @@ -129,7 +129,7 @@ fn avx2_code_matches_uri_chars_table() { unsafe { assert!(byte_is_allowed(b'_', parse_uri_batch_32)); - for (b, allowed) in ::URI_MAP.iter().cloned().enumerate() { + for (b, allowed) in crate::URI_MAP.iter().cloned().enumerate() { assert_eq!( byte_is_allowed(b as u8, parse_uri_batch_32), allowed, "byte_is_allowed({:?}) should be {:?}", b, allowed, @@ -148,7 +148,7 @@ fn avx2_code_matches_header_value_chars_table() { unsafe { assert!(byte_is_allowed(b'_', match_header_value_batch_32)); - for (b, allowed) in ::HEADER_VALUE_MAP.iter().cloned().enumerate() { + for (b, allowed) in crate::HEADER_VALUE_MAP.iter().cloned().enumerate() { assert_eq!( byte_is_allowed(b as u8, match_header_value_batch_32), allowed, "byte_is_allowed({:?}) should be {:?}", b, allowed, diff --git a/src/simd/fallback.rs b/src/simd/fallback.rs index 4a79cb9..871cd01 100644 --- a/src/simd/fallback.rs +++ b/src/simd/fallback.rs @@ -1,8 +1,8 @@ -use ::iter::Bytes; +use crate::iter::Bytes; // Fallbacks that do nothing... #[inline(always)] -pub fn match_uri_vectored(_: &mut Bytes) {} +pub fn match_uri_vectored(_: &mut Bytes<'_>) {} #[inline(always)] -pub fn match_header_value_vectored(_: &mut Bytes) {} +pub fn match_header_value_vectored(_: &mut Bytes<'_>) {} diff --git a/src/simd/mod.rs b/src/simd/mod.rs index 02d46e1..b1cd85c 100644 --- a/src/simd/mod.rs +++ b/src/simd/mod.rs @@ -68,8 +68,15 @@ pub const AVX_2: usize = 2; ), ))] pub const AVX_2_AND_SSE_42: usize = 3; -#[cfg(httparse_simd)] -const NONE: usize = ::core::usize::MAX; + +#[cfg(all( + httparse_simd, + any( + target_arch = "x86", + target_arch = "x86_64", + ), +))] +const NONE: usize = std::usize::MAX; #[cfg(all( httparse_simd, not(any( @@ -116,7 +123,7 @@ mod runtime { feat } - pub fn match_uri_vectored(bytes: &mut ::Bytes) { + pub fn match_uri_vectored(bytes: &mut crate::iter::Bytes) { unsafe { match detect() { super::SSE_42 => super::sse42::parse_uri_batch_16(bytes), @@ -134,7 +141,7 @@ mod runtime { // else do nothing } - pub fn match_header_value_vectored(bytes: &mut ::Bytes) { + pub fn match_header_value_vectored(bytes: &mut crate::iter::Bytes) { unsafe { match detect() { super::SSE_42 => super::sse42::match_header_value_batch_16(bytes), @@ -176,7 +183,7 @@ pub use self::runtime::*; ), ))] mod sse42_compile_time { - pub fn match_uri_vectored(bytes: &mut ::Bytes) { + pub fn match_uri_vectored(bytes: &mut crate::iter::Bytes) { if detect() == super::SSE_42 { unsafe { super::sse42::parse_uri_batch_16(bytes); @@ -186,7 +193,7 @@ mod sse42_compile_time { // else do nothing } - pub fn match_header_value_vectored(bytes: &mut ::Bytes) { + pub fn match_header_value_vectored(bytes: &mut crate::iter::Bytes) { if detect() == super::SSE_42 { unsafe { super::sse42::match_header_value_batch_16(bytes); @@ -225,7 +232,7 @@ pub use self::sse42_compile_time::*; ), ))] mod avx2_compile_time { - pub fn match_uri_vectored(bytes: &mut ::Bytes) { + pub fn match_uri_vectored(bytes: &mut crate::iter::Bytes) { // do both, since avx2 only works when bytes.len() >= 32 if detect() == super::AVX_2_AND_SSE_42 { unsafe { @@ -242,7 +249,7 @@ mod avx2_compile_time { // else do nothing } - pub fn match_header_value_vectored(bytes: &mut ::Bytes) { + pub fn match_header_value_vectored(bytes: &mut crate::iter::Bytes) { // do both, since avx2 only works when bytes.len() >= 32 if detect() == super::AVX_2_AND_SSE_42 { let scanned = unsafe { diff --git a/src/simd/sse42.rs b/src/simd/sse42.rs index 284dc1b..8caf8f7 100644 --- a/src/simd/sse42.rs +++ b/src/simd/sse42.rs @@ -1,4 +1,4 @@ -use ::iter::Bytes; +use crate::iter::Bytes; pub unsafe fn parse_uri_batch_16(bytes: &mut Bytes) { while bytes.as_ref().len() >= 16 { @@ -109,7 +109,7 @@ fn sse_code_matches_uri_chars_table() { unsafe { assert!(byte_is_allowed(b'_', parse_uri_batch_16)); - for (b, allowed) in ::URI_MAP.iter().cloned().enumerate() { + for (b, allowed) in crate::URI_MAP.iter().cloned().enumerate() { assert_eq!( byte_is_allowed(b as u8, parse_uri_batch_16), allowed, "byte_is_allowed({:?}) should be {:?}", b, allowed, @@ -128,7 +128,7 @@ fn sse_code_matches_header_value_chars_table() { unsafe { assert!(byte_is_allowed(b'_', match_header_value_batch_16)); - for (b, allowed) in ::HEADER_VALUE_MAP.iter().cloned().enumerate() { + for (b, allowed) in crate::HEADER_VALUE_MAP.iter().cloned().enumerate() { assert_eq!( byte_is_allowed(b as u8, match_header_value_batch_16), allowed, "byte_is_allowed({:?}) should be {:?}", b, allowed, diff --git a/tests/uri.rs b/tests/uri.rs index a483c67..e0ceab4 100644 --- a/tests/uri.rs +++ b/tests/uri.rs @@ -1,4 +1,3 @@ -extern crate httparse; use httparse::{Error, Request, Status, EMPTY_HEADER}; @@ -17,7 +16,7 @@ macro_rules! req { assert_eq!(status, $len); closure(req); - fn closure($arg: Request) { + fn closure($arg: Request<'_, '_>) { $body } }