Skip to content

Commit 0b8e7bc

Browse files
MingunMingun
committed
Generalize reading methods of PI and element
They are identical except different type of parser used.
1 parent 23dc390 commit 0b8e7bc

File tree

6 files changed

+80
-118
lines changed

6 files changed

+80
-118
lines changed

‎src/reader/async_tokio.rs‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,9 @@ use crate::errors::{Error, Result, SyntaxError};
88
use crate::events::Event;
99
use crate::name::{QName, ResolveResult};
1010
use crate::reader::buffered_reader::impl_buffered_source;
11-
use crate::reader::{is_whitespace, BangType, ElementParser, NsReader, ParseState, Reader, Span};
11+
use crate::reader::{
12+
is_whitespace, BangType, ElementParser, NsReader, ParseState, Parser, PiParser, Reader, Span,
13+
};
1214

1315
/// A struct for read XML asynchronously from an [`AsyncBufRead`].
1416
///

‎src/reader/buffered_reader.rs‎

Lines changed: 5 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -5,10 +5,10 @@ use std::fs::File;
55
use std::io::{self, BufRead, BufReader};
66
use std::path::Path;
77

8-
use crate::errors::{Error, Result, SyntaxError};
8+
use crate::errors::{Error, Result};
99
use crate::events::Event;
1010
use crate::name::QName;
11-
use crate::reader::{is_whitespace, BangType, ElementParser, Reader, Span, XmlSource};
11+
use crate::reader::{is_whitespace, BangType, Parser, Reader, Span, XmlSource};
1212

1313
macro_rules! impl_buffered_source {
1414
($($lf:lifetime, $reader:tt, $async:ident, $await:ident)?) => {
@@ -91,12 +91,12 @@ macro_rules! impl_buffered_source {
9191
Ok((&buf[start..], done))
9292
}
9393

94-
$($async)? fn read_pi $(<$lf>)? (
94+
$($async)? fn read_with<$($lf,)? P: Parser>(
9595
&mut self,
9696
buf: &'b mut Vec<u8>,
9797
position: &mut usize,
9898
) -> Result<&'b [u8]> {
99-
let mut parser = super::PiParser::default();
99+
let mut parser = P::default();
100100

101101
let mut read = 0;
102102
let start = buf.len();
@@ -131,7 +131,7 @@ macro_rules! impl_buffered_source {
131131
}
132132

133133
*position += read;
134-
Err(Error::Syntax(SyntaxError::UnclosedPIOrXmlDecl))
134+
Err(Error::Syntax(P::eof_error()))
135135
}
136136

137137
$($async)? fn read_bang_element $(<$lf>)? (
@@ -184,50 +184,6 @@ macro_rules! impl_buffered_source {
184184
Err(bang_type.to_err())
185185
}
186186

187-
#[inline]
188-
$($async)? fn read_element $(<$lf>)? (
189-
&mut self,
190-
buf: &'b mut Vec<u8>,
191-
position: &mut usize,
192-
) -> Result<&'b [u8]> {
193-
let mut parser = ElementParser::default();
194-
let mut read = 0;
195-
196-
let start = buf.len();
197-
loop {
198-
let available = match self $(.$reader)? .fill_buf() $(.$await)? {
199-
Ok(n) if n.is_empty() => break,
200-
Ok(n) => n,
201-
Err(ref e) if e.kind() == io::ErrorKind::Interrupted => continue,
202-
Err(e) => {
203-
*position += read;
204-
return Err(Error::Io(e.into()));
205-
}
206-
};
207-
208-
if let Some(used) = parser.feed(available) {
209-
buf.extend_from_slice(&available[..used]);
210-
211-
// +1 for `>` which we do not include
212-
self $(.$reader)? .consume(used + 1);
213-
read += used + 1;
214-
215-
// Position now just after the `>` symbol
216-
*position += read;
217-
return Ok(&buf[start..]);
218-
}
219-
220-
// The `>` symbol not yet found, continue reading
221-
buf.extend_from_slice(available);
222-
let used = available.len();
223-
self $(.$reader)? .consume(used);
224-
read += used;
225-
}
226-
227-
*position += read;
228-
Err(Error::Syntax(SyntaxError::UnclosedTag))
229-
}
230-
231187
$($async)? fn skip_whitespace(&mut self, position: &mut usize) -> Result<()> {
232188
loop {
233189
break match self $(.$reader)? .fill_buf() $(.$await)? {

‎src/reader/element.rs‎

Lines changed: 12 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
//! Contains a parser for an XML element.
22
3+
use crate::errors::SyntaxError;
4+
use crate::reader::Parser;
5+
36
/// A parser that search a `>` symbol in the slice outside of quoted regions.
47
///
58
/// The parser considers two quoted regions: a double-quoted (`"..."`) and
@@ -21,8 +24,9 @@
2124
/// # Example
2225
///
2326
/// ```
24-
/// # use quick_xml::reader::ElementParser;
2527
/// # use pretty_assertions::assert_eq;
28+
/// use quick_xml::reader::{ElementParser, Parser};
29+
///
2630
/// let mut parser = ElementParser::default();
2731
///
2832
/// // Parse `<my-element with = 'some > inside'>and the text follow...`
@@ -47,10 +51,10 @@ pub enum ElementParser {
4751
DoubleQ,
4852
}
4953

50-
impl ElementParser {
54+
impl Parser for ElementParser {
5155
/// Returns number of consumed bytes or `None` if `>` was not found in `bytes`.
5256
#[inline]
53-
pub fn feed(&mut self, bytes: &[u8]) -> Option<usize> {
57+
fn feed(&mut self, bytes: &[u8]) -> Option<usize> {
5458
for i in memchr::memchr3_iter(b'>', b'\'', b'"', bytes) {
5559
*self = match (*self, bytes[i]) {
5660
// only allowed to match `>` while we are in state `Outside`
@@ -67,6 +71,11 @@ impl ElementParser {
6771
}
6872
None
6973
}
74+
75+
#[inline]
76+
fn eof_error() -> SyntaxError {
77+
SyntaxError::UnclosedTag
78+
}
7079
}
7180

7281
impl Default for ElementParser {

‎src/reader/mod.rs‎

Lines changed: 42 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -361,7 +361,7 @@ macro_rules! read_until_close {
361361
},
362362
// `<?` - processing instruction
363363
Ok(Some(b'?')) => match $reader
364-
.read_pi($buf, &mut $self.state.offset)
364+
.read_with::<PiParser>($buf, &mut $self.state.offset)
365365
$(.$await)?
366366
{
367367
Ok(bytes) => $self.state.emit_question_mark(bytes),
@@ -374,7 +374,7 @@ macro_rules! read_until_close {
374374
},
375375
// `<...` - opening or self-closed tag
376376
Ok(Some(_)) => match $reader
377-
.read_element($buf, &mut $self.state.offset)
377+
.read_with::<ElementParser>($buf, &mut $self.state.offset)
378378
$(.$await)?
379379
{
380380
Ok(bytes) => $self.state.emit_start(bytes),
@@ -763,6 +763,26 @@ impl<R> Reader<R> {
763763

764764
////////////////////////////////////////////////////////////////////////////////////////////////////
765765

766+
/// Used to decouple reading of data from data source and parsing XML structure from it.
767+
/// This is a state preserved between getting chunks of bytes from the reader.
768+
///
769+
/// This trait is implemented for every parser that processes piece of XML grammar.
770+
pub trait Parser: Default {
771+
/// Process new data and try to determine end of the parsed thing.
772+
///
773+
/// Returns position of the end of thing in `bytes` in case of successful search
774+
/// and `None` otherwise.
775+
///
776+
/// # Parameters
777+
/// - `bytes`: a slice to find the end of a thing.
778+
/// Should contain text in ASCII-compatible encoding
779+
fn feed(&mut self, bytes: &[u8]) -> Option<usize>;
780+
781+
/// Returns parse error produced by this parser in case of reaching end of
782+
/// input without finding the end of a parsed thing.
783+
fn eof_error() -> SyntaxError;
784+
}
785+
766786
/// Represents an input for a reader that can return borrowed data.
767787
///
768788
/// There are two implementors of this trait: generic one that read data from
@@ -821,20 +841,23 @@ trait XmlSource<'r, B> {
821841

822842
/// Read input until processing instruction is finished.
823843
///
824-
/// This method expect that `<?` already was read.
844+
/// This method expect that start sequence of a parser already was read.
825845
///
826-
/// Returns a slice of data read up to end of processing instruction (`>`),
827-
/// which does not include into result (`?` at the end included).
846+
/// Returns a slice of data read up to the end of the thing being parsed.
847+
/// The end of thing and the returned content is determined by the used parser.
828848
///
829-
/// If input (`Self`) is exhausted and nothing was read, returns `None`.
849+
/// If input (`Self`) is exhausted and no bytes was read, or if the specified
850+
/// parser could not find the ending sequence of the thing, returns `SyntaxError`.
830851
///
831852
/// # Parameters
832853
/// - `buf`: Buffer that could be filled from an input (`Self`) and
833854
/// from which [events] could borrow their data
834855
/// - `position`: Will be increased by amount of bytes consumed
835856
///
857+
/// A `P` type parameter is used to preserve state between calls to the underlying
858+
/// reader which provides bytes fed into the parser.
836859
/// [events]: crate::events::Event
837-
fn read_pi(&mut self, buf: B, position: &mut usize) -> Result<&'r [u8]>;
860+
fn read_with<P: Parser>(&mut self, buf: B, position: &mut usize) -> Result<&'r [u8]>;
838861

839862
/// Read input until comment or CDATA is finished.
840863
///
@@ -853,30 +876,6 @@ trait XmlSource<'r, B> {
853876
/// [events]: crate::events::Event
854877
fn read_bang_element(&mut self, buf: B, position: &mut usize) -> Result<(BangType, &'r [u8])>;
855878

856-
/// Read input until XML element is closed by approaching a `>` symbol.
857-
/// Returns a buffer that contains a data between `<` and `>` or
858-
/// [`SyntaxError::UnclosedTag`] if end-of-input was reached before reading `>`.
859-
///
860-
/// Derived from `read_until`, but modified to handle XML attributes
861-
/// using a minimal state machine.
862-
///
863-
/// Attribute values are [defined] as follows:
864-
/// ```plain
865-
/// AttValue := '"' (([^<&"]) | Reference)* '"'
866-
/// | "'" (([^<&']) | Reference)* "'"
867-
/// ```
868-
/// (`Reference` is something like `&quot;`, but we don't care about
869-
/// escaped characters at this level)
870-
///
871-
/// # Parameters
872-
/// - `buf`: Buffer that could be filled from an input (`Self`) and
873-
/// from which [events] could borrow their data
874-
/// - `position`: Will be increased by amount of bytes consumed
875-
///
876-
/// [defined]: https://www.w3.org/TR/xml11/#NT-AttValue
877-
/// [events]: crate::events::Event
878-
fn read_element(&mut self, buf: B, position: &mut usize) -> Result<&'r [u8]>;
879-
880879
/// Consume and discard all the whitespace until the next non-whitespace
881880
/// character or EOF.
882881
///
@@ -1510,6 +1509,7 @@ mod test {
15101509
mod read_element {
15111510
use super::*;
15121511
use crate::errors::{Error, SyntaxError};
1512+
use crate::reader::ElementParser;
15131513
use crate::utils::Bytes;
15141514
use pretty_assertions::assert_eq;
15151515

@@ -1521,7 +1521,7 @@ mod test {
15211521
let mut input = b"".as_ref();
15221522
// ^= 1
15231523

1524-
match $source(&mut input).read_element(buf, &mut position) $(.$await)? {
1524+
match $source(&mut input).read_with::<ElementParser>(buf, &mut position) $(.$await)? {
15251525
Err(Error::Syntax(SyntaxError::UnclosedTag)) => {}
15261526
x => panic!(
15271527
"Expected `Err(Syntax(UnclosedTag))`, but got `{:?}`",
@@ -1543,7 +1543,7 @@ mod test {
15431543
// ^= 2
15441544

15451545
assert_eq!(
1546-
Bytes($source(&mut input).read_element(buf, &mut position) $(.$await)? .unwrap()),
1546+
Bytes($source(&mut input).read_with::<ElementParser>(buf, &mut position) $(.$await)? .unwrap()),
15471547
Bytes(b"")
15481548
);
15491549
assert_eq!(position, 2);
@@ -1557,7 +1557,7 @@ mod test {
15571557
// ^= 5
15581558

15591559
assert_eq!(
1560-
Bytes($source(&mut input).read_element(buf, &mut position) $(.$await)? .unwrap()),
1560+
Bytes($source(&mut input).read_with::<ElementParser>(buf, &mut position) $(.$await)? .unwrap()),
15611561
Bytes(b"tag")
15621562
);
15631563
assert_eq!(position, 5);
@@ -1571,7 +1571,7 @@ mod test {
15711571
// ^= 3
15721572

15731573
assert_eq!(
1574-
Bytes($source(&mut input).read_element(buf, &mut position) $(.$await)? .unwrap()),
1574+
Bytes($source(&mut input).read_with::<ElementParser>(buf, &mut position) $(.$await)? .unwrap()),
15751575
Bytes(b":")
15761576
);
15771577
assert_eq!(position, 3);
@@ -1585,7 +1585,7 @@ mod test {
15851585
// ^= 6
15861586

15871587
assert_eq!(
1588-
Bytes($source(&mut input).read_element(buf, &mut position) $(.$await)? .unwrap()),
1588+
Bytes($source(&mut input).read_with::<ElementParser>(buf, &mut position) $(.$await)? .unwrap()),
15891589
Bytes(b":tag")
15901590
);
15911591
assert_eq!(position, 6);
@@ -1599,7 +1599,7 @@ mod test {
15991599
// ^= 39
16001600

16011601
assert_eq!(
1602-
Bytes($source(&mut input).read_element(buf, &mut position) $(.$await)? .unwrap()),
1602+
Bytes($source(&mut input).read_with::<ElementParser>(buf, &mut position) $(.$await)? .unwrap()),
16031603
Bytes(br#"tag attr-1=">" attr2 = '>' 3attr"#)
16041604
);
16051605
assert_eq!(position, 39);
@@ -1618,7 +1618,7 @@ mod test {
16181618
// ^= 3
16191619

16201620
assert_eq!(
1621-
Bytes($source(&mut input).read_element(buf, &mut position) $(.$await)? .unwrap()),
1621+
Bytes($source(&mut input).read_with::<ElementParser>(buf, &mut position) $(.$await)? .unwrap()),
16221622
Bytes(b"/")
16231623
);
16241624
assert_eq!(position, 3);
@@ -1632,7 +1632,7 @@ mod test {
16321632
// ^= 6
16331633

16341634
assert_eq!(
1635-
Bytes($source(&mut input).read_element(buf, &mut position) $(.$await)? .unwrap()),
1635+
Bytes($source(&mut input).read_with::<ElementParser>(buf, &mut position) $(.$await)? .unwrap()),
16361636
Bytes(b"tag/")
16371637
);
16381638
assert_eq!(position, 6);
@@ -1646,7 +1646,7 @@ mod test {
16461646
// ^= 4
16471647

16481648
assert_eq!(
1649-
Bytes($source(&mut input).read_element(buf, &mut position) $(.$await)? .unwrap()),
1649+
Bytes($source(&mut input).read_with::<ElementParser>(buf, &mut position) $(.$await)? .unwrap()),
16501650
Bytes(b":/")
16511651
);
16521652
assert_eq!(position, 4);
@@ -1660,7 +1660,7 @@ mod test {
16601660
// ^= 7
16611661

16621662
assert_eq!(
1663-
Bytes($source(&mut input).read_element(buf, &mut position) $(.$await)? .unwrap()),
1663+
Bytes($source(&mut input).read_with::<ElementParser>(buf, &mut position) $(.$await)? .unwrap()),
16641664
Bytes(b":tag/")
16651665
);
16661666
assert_eq!(position, 7);
@@ -1674,7 +1674,7 @@ mod test {
16741674
// ^= 42
16751675

16761676
assert_eq!(
1677-
Bytes($source(&mut input).read_element(buf, &mut position) $(.$await)? .unwrap()),
1677+
Bytes($source(&mut input).read_with::<ElementParser>(buf, &mut position) $(.$await)? .unwrap()),
16781678
Bytes(br#"tag attr-1="/>" attr2 = '/>' 3attr/"#)
16791679
);
16801680
assert_eq!(position, 42);

0 commit comments

Comments
 (0)