Skip to content

Commit b980725

Browse files
999eagleMingun
999eagle
authored and
Mingun
committed
Update implementation macros to support async code
1 parent f062bbe commit b980725

File tree

3 files changed

+53
-39
lines changed

3 files changed

+53
-39
lines changed

‎src/reader/buffered_reader.rs

Lines changed: 23 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -13,9 +13,9 @@ use crate::name::QName;
1313
use crate::reader::{is_whitespace, BangType, ReadElementState, Reader, XmlSource};
1414

1515
macro_rules! impl_buffered_source {
16-
() => {
16+
($($lf:lifetime, $reader:tt, $async:ident, $await:ident)?) => {
1717
#[inline]
18-
fn read_bytes_until(
18+
$($async)? fn read_bytes_until $(<$lf>)? (
1919
&mut self,
2020
byte: u8,
2121
buf: &'b mut Vec<u8>,
@@ -29,7 +29,7 @@ macro_rules! impl_buffered_source {
2929
let start = buf.len();
3030
while !done {
3131
let used = {
32-
let available = match self.fill_buf() {
32+
let available = match self $(.$reader)? .fill_buf() $(.$await)? {
3333
Ok(n) if n.is_empty() => break,
3434
Ok(n) => n,
3535
Err(ref e) if e.kind() == io::ErrorKind::Interrupted => continue,
@@ -51,7 +51,7 @@ macro_rules! impl_buffered_source {
5151
}
5252
}
5353
};
54-
self.consume(used);
54+
self $(.$reader)? .consume(used);
5555
read += used;
5656
}
5757
*position += read;
@@ -63,7 +63,7 @@ macro_rules! impl_buffered_source {
6363
}
6464
}
6565

66-
fn read_bang_element(
66+
$($async)? fn read_bang_element $(<$lf>)? (
6767
&mut self,
6868
buf: &'b mut Vec<u8>,
6969
position: &mut usize,
@@ -73,20 +73,20 @@ macro_rules! impl_buffered_source {
7373
let start = buf.len();
7474
let mut read = 1;
7575
buf.push(b'!');
76-
self.consume(1);
76+
self $(.$reader)? .consume(1);
7777

78-
let bang_type = BangType::new(self.peek_one()?)?;
78+
let bang_type = BangType::new(self.peek_one() $(.$await)? ?)?;
7979

8080
loop {
81-
match self.fill_buf() {
81+
match self $(.$reader)? .fill_buf() $(.$await)? {
8282
// Note: Do not update position, so the error points to
8383
// somewhere sane rather than at the EOF
8484
Ok(n) if n.is_empty() => return Err(bang_type.to_err()),
8585
Ok(available) => {
8686
if let Some((consumed, used)) = bang_type.parse(available, read) {
8787
buf.extend_from_slice(consumed);
8888

89-
self.consume(used);
89+
self $(.$reader)? .consume(used);
9090
read += used;
9191

9292
*position += read;
@@ -95,7 +95,7 @@ macro_rules! impl_buffered_source {
9595
buf.extend_from_slice(available);
9696

9797
let used = available.len();
98-
self.consume(used);
98+
self $(.$reader)? .consume(used);
9999
read += used;
100100
}
101101
}
@@ -115,7 +115,7 @@ macro_rules! impl_buffered_source {
115115
}
116116

117117
#[inline]
118-
fn read_element(
118+
$($async)? fn read_element $(<$lf>)? (
119119
&mut self,
120120
buf: &'b mut Vec<u8>,
121121
position: &mut usize,
@@ -125,13 +125,13 @@ macro_rules! impl_buffered_source {
125125

126126
let start = buf.len();
127127
loop {
128-
match self.fill_buf() {
128+
match self $(.$reader)? .fill_buf() $(.$await)? {
129129
Ok(n) if n.is_empty() => break,
130130
Ok(available) => {
131131
if let Some((consumed, used)) = state.change(available) {
132132
buf.extend_from_slice(consumed);
133133

134-
self.consume(used);
134+
self $(.$reader)? .consume(used);
135135
read += used;
136136

137137
*position += read;
@@ -140,7 +140,7 @@ macro_rules! impl_buffered_source {
140140
buf.extend_from_slice(available);
141141

142142
let used = available.len();
143-
self.consume(used);
143+
self $(.$reader)? .consume(used);
144144
read += used;
145145
}
146146
}
@@ -161,13 +161,13 @@ macro_rules! impl_buffered_source {
161161

162162
/// Consume and discard all the whitespace until the next non-whitespace
163163
/// character or EOF.
164-
fn skip_whitespace(&mut self, position: &mut usize) -> Result<()> {
164+
$($async)? fn skip_whitespace(&mut self, position: &mut usize) -> Result<()> {
165165
loop {
166-
break match self.fill_buf() {
166+
break match self $(.$reader)? .fill_buf() $(.$await)? {
167167
Ok(n) => {
168168
let count = n.iter().position(|b| !is_whitespace(*b)).unwrap_or(n.len());
169169
if count > 0 {
170-
self.consume(count);
170+
self $(.$reader)? .consume(count);
171171
*position += count;
172172
continue;
173173
} else {
@@ -182,14 +182,14 @@ macro_rules! impl_buffered_source {
182182

183183
/// Consume and discard one character if it matches the given byte. Return
184184
/// true if it matched.
185-
fn skip_one(&mut self, byte: u8, position: &mut usize) -> Result<bool> {
185+
$($async)? fn skip_one(&mut self, byte: u8, position: &mut usize) -> Result<bool> {
186186
// search byte must be within the ascii range
187187
debug_assert!(byte.is_ascii());
188188

189-
match self.peek_one()? {
189+
match self.peek_one() $(.$await)? ? {
190190
Some(b) if b == byte => {
191191
*position += 1;
192-
self.consume(1);
192+
self $(.$reader)? .consume(1);
193193
Ok(true)
194194
}
195195
_ => Ok(false),
@@ -198,9 +198,9 @@ macro_rules! impl_buffered_source {
198198

199199
/// Return one character without consuming it, so that future `read_*` calls
200200
/// will still include it. On EOF, return None.
201-
fn peek_one(&mut self) -> Result<Option<u8>> {
201+
$($async)? fn peek_one(&mut self) -> Result<Option<u8>> {
202202
loop {
203-
break match self.fill_buf() {
203+
break match self $(.$reader)? .fill_buf() $(.$await)? {
204204
Ok(n) if n.is_empty() => Ok(None),
205205
Ok(n) => Ok(Some(n[0])),
206206
Err(ref e) if e.kind() == io::ErrorKind::Interrupted => continue,
@@ -353,7 +353,7 @@ impl<R: BufRead> Reader<R> {
353353
/// [`check_end_names`]: Self::check_end_names
354354
/// [the specification]: https://www.w3.org/TR/xml11/#dt-etag
355355
pub fn read_to_end_into(&mut self, end: QName, buf: &mut Vec<u8>) -> Result<()> {
356-
read_to_end!(self, end, buf, {
356+
read_to_end!(self, end, buf, read_event_impl, {
357357
buf.clear();
358358
})
359359
}

‎src/reader/mod.rs

Lines changed: 29 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -129,12 +129,15 @@ macro_rules! configure_methods {
129129

130130
macro_rules! read_event_impl {
131131
(
132-
$self:ident, $buf:ident
132+
$self:ident, $buf:ident,
133+
$read_until_open:ident,
134+
$read_until_close:ident
135+
$(, $await:ident)?
133136
) => {{
134137
let event = match $self.parser.state {
135-
ParseState::Init => $self.read_until_open($buf, true),
136-
ParseState::ClosedTag => $self.read_until_open($buf, false),
137-
ParseState::OpenedTag => $self.read_until_close($buf),
138+
ParseState::Init => $self.$read_until_open($buf, true) $(.$await)?,
139+
ParseState::ClosedTag => $self.$read_until_open($buf, false) $(.$await)?,
140+
ParseState::OpenedTag => $self.$read_until_close($buf) $(.$await)?,
138141
ParseState::Empty => $self.parser.close_expanded_empty(),
139142
ParseState::Exit => return Ok(Event::Eof),
140143
};
@@ -148,22 +151,25 @@ macro_rules! read_event_impl {
148151

149152
macro_rules! read_until_open {
150153
(
151-
$self:ident, $buf:ident, $first:ident
154+
$self:ident, $buf:ident, $first:ident,
155+
$read_event:ident
156+
$(, $await:ident)?
152157
) => {{
153158
$self.parser.state = ParseState::OpenedTag;
154159

155160
if $self.parser.trim_text_start {
156-
$self.reader.skip_whitespace(&mut $self.parser.offset)?;
161+
$self.reader.skip_whitespace(&mut $self.parser.offset) $(.$await)? ?;
157162
}
158163

159164
// If we already at the `<` symbol, do not try to return an empty Text event
160-
if $self.reader.skip_one(b'<', &mut $self.parser.offset)? {
161-
return $self.read_event_impl($buf);
165+
if $self.reader.skip_one(b'<', &mut $self.parser.offset) $(.$await)? ? {
166+
return $self.$read_event($buf) $(.$await)?;
162167
}
163168

164169
match $self
165170
.reader
166171
.read_bytes_until(b'<', $buf, &mut $self.parser.offset)
172+
$(.$await)?
167173
{
168174
Ok(Some(bytes)) => $self.parser.read_text(bytes, $first),
169175
Ok(None) => Ok(Event::Eof),
@@ -175,41 +181,47 @@ macro_rules! read_until_open {
175181
macro_rules! read_until_close {
176182
(
177183
$self:ident, $buf:ident
184+
$(, $await:ident)?
178185
) => {{
179186
$self.parser.state = ParseState::ClosedTag;
180187

181-
match $self.reader.peek_one() {
188+
match $self.reader.peek_one() $(.$await)? {
182189
// `<!` - comment, CDATA or DOCTYPE declaration
183190
Ok(Some(b'!')) => match $self
184191
.reader
185192
.read_bang_element($buf, &mut $self.parser.offset)
193+
$(.$await)?
186194
{
187195
Ok(None) => Ok(Event::Eof),
188196
Ok(Some((bang_type, bytes))) => $self.parser.read_bang(bang_type, bytes),
189197
Err(e) => Err(e),
190198
},
191199
// `</` - closing tag
192200
Ok(Some(b'/')) => match $self
193-
// Comment for prevent formatting
194201
.reader
195202
.read_bytes_until(b'>', $buf, &mut $self.parser.offset)
203+
$(.$await)?
196204
{
197205
Ok(None) => Ok(Event::Eof),
198206
Ok(Some(bytes)) => $self.parser.read_end(bytes),
199207
Err(e) => Err(e),
200208
},
201209
// `<?` - processing instruction
202210
Ok(Some(b'?')) => match $self
203-
// Comment for prevent formatting
204211
.reader
205212
.read_bytes_until(b'>', $buf, &mut $self.parser.offset)
213+
$(.$await)?
206214
{
207215
Ok(None) => Ok(Event::Eof),
208216
Ok(Some(bytes)) => $self.parser.read_question_mark(bytes),
209217
Err(e) => Err(e),
210218
},
211219
// `<...` - opening or self-closed tag
212-
Ok(Some(_)) => match $self.reader.read_element($buf, &mut $self.parser.offset) {
220+
Ok(Some(_)) => match $self
221+
.reader
222+
.read_element($buf, &mut $self.parser.offset)
223+
$(.$await)?
224+
{
213225
Ok(None) => Ok(Event::Eof),
214226
Ok(Some(bytes)) => $self.parser.read_start(bytes),
215227
Err(e) => Err(e),
@@ -224,13 +236,15 @@ macro_rules! read_until_close {
224236
macro_rules! read_to_end {
225237
(
226238
$self:expr, $end:expr, $buf:expr,
239+
$read_event:ident,
227240
// Code block that performs clearing of internal buffer after read of each event
228241
$clear:block
242+
$(, $await:ident)?
229243
) => {{
230244
let mut depth = 0;
231245
loop {
232246
$clear
233-
match $self.read_event_impl($buf) {
247+
match $self.$read_event($buf) $(.$await)? {
234248
Err(e) => return Err(e),
235249

236250
Ok(Event::Start(e)) if e.name() == $end => depth += 1,
@@ -528,7 +542,7 @@ impl<R> Reader<R> {
528542
where
529543
R: XmlSource<'i, B>,
530544
{
531-
read_event_impl!(self, buf)
545+
read_event_impl!(self, buf, read_until_open, read_until_close)
532546
}
533547

534548
/// Read until '<' is found and moves reader to an `OpenedTag` state.
@@ -538,7 +552,7 @@ impl<R> Reader<R> {
538552
where
539553
R: XmlSource<'i, B>,
540554
{
541-
read_until_open!(self, buf, first)
555+
read_until_open!(self, buf, first, read_event_impl)
542556
}
543557

544558
/// Private function to read until `>` is found. This function expects that

‎src/reader/slice_reader.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -138,7 +138,7 @@ impl<'a> Reader<&'a [u8]> {
138138
/// [`check_end_names`]: Self::check_end_names
139139
/// [the specification]: https://www.w3.org/TR/xml11/#dt-etag
140140
pub fn read_to_end(&mut self, end: QName) -> Result<()> {
141-
read_to_end!(self, end, (), {})
141+
read_to_end!(self, end, (), read_event_impl, {})
142142
}
143143
}
144144

0 commit comments

Comments
 (0)