emilis
/
termion
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fixed unwraps on nones occuring on fast subsequent reads in async (+rustfmt)

This commit is contained in:
emilis 2023-01-24 12:51:31 +00:00
parent f2b8517c31
commit ce611b8283
1 changed files with 184 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
src/event.rs
View File

@ -107,7 +107,8 @@ pub enum Key {
/// Parse an Event from `item` and possibly subsequent bytes through `iter`.
pub fn parse_event<I>(item: u8, iter: &mut I) -> Result<Event, Error>
where I: Iterator<Item = Result<u8, Error>>
where
I: Iterator<Item = Result<u8, Error>>,
{
let error = Error::new(ErrorKind::Other, "Could not parse an event");
match item {
@ -138,12 +139,10 @@ pub fn parse_event<I>(item: u8, iter: &mut I) -> Result<Event, Error>
c @ b'\x01'..=b'\x1A' => Ok(Event::Key(Key::Ctrl((c as u8 - 0x1 + b'a') as char))),
c @ b'\x1C'..=b'\x1F' => Ok(Event::Key(Key::Ctrl((c as u8 - 0x1C + b'4') as char))),
b'\0' => Ok(Event::Key(Key::Null)),
c => {
Ok({
c => Ok({
let ch = parse_utf8_char(c, iter)?;
Event::Key(Key::Char(ch))
})
}
}),
}
}
@ -151,7 +150,8 @@ pub fn parse_event<I>(item: u8, iter: &mut I) -> Result<Event, Error>
///
/// Returns None if an unrecognized sequence is found.
fn parse_csi<I>(iter: &mut I) -> Option<Event>
where I: Iterator<Item = Result<u8, Error>>
where
I: Iterator<Item = Result<u8, Error>>,
{
Some(match iter.next() {
Some(Ok(b'[')) => match iter.next() {
@ -197,29 +197,26 @@ fn parse_csi<I>(iter: &mut I) -> Option<Event>
// xterm mouse encoding:
// ESC [ < Cb ; Cx ; Cy (;) (M or m)
let mut buf = Vec::new();
let mut c = iter.next().unwrap().unwrap();
let mut c = match iter.next() {
Some(next) => next.unwrap(),
None => return None,
};
while match c {
b'm' | b'M' => false,
_ => true,
} {
buf.push(c);
c = iter.next().unwrap().unwrap();
c = match iter.next() {
Some(next) => next.unwrap(),
None => return None,
};
}
let str_buf = String::from_utf8(buf).unwrap();
let nums = &mut str_buf.split(';');
let cb = nums.next()
.unwrap()
.parse::<u16>()
.unwrap();
let cx = nums.next()
.unwrap()
.parse::<u16>()
.unwrap();
let cy = nums.next()
.unwrap()
.parse::<u16>()
.unwrap();
let cb = nums.next().unwrap().parse::<u16>().unwrap();
let cx = nums.next().unwrap().parse::<u16>().unwrap();
let cy = nums.next().unwrap().parse::<u16>().unwrap();
let event = match cb {
0..=2 | 64..=65 => {
@ -248,12 +245,18 @@ fn parse_csi<I>(iter: &mut I) -> Option<Event>
// Numbered escape code.
let mut buf = Vec::new();
buf.push(c);
let mut c = iter.next().unwrap().unwrap();
let mut c = match iter.next() {
Some(next) => next.unwrap(),
None => return None,
};
// The final byte of a CSI sequence can be in the range 64-126, so
// let's keep reading anything else.
while c < 64 || c > 126 {
buf.push(c);
c = iter.next().unwrap().unwrap();
c = match iter.next() {
Some(next) => next.unwrap(),
None => return None,
};
}
match c {
@ -316,14 +319,17 @@ fn parse_csi<I>(iter: &mut I) -> Option<Event>
}
_ => return None,
})
}
/// Parse `c` as either a single byte ASCII char or a variable size UTF-8 char.
fn parse_utf8_char<I>(c: u8, iter: &mut I) -> Result<char, Error>
where I: Iterator<Item = Result<u8, Error>>
where
I: Iterator<Item = Result<u8, Error>>,
{
let error = Err(Error::new(ErrorKind::Other, "Input character is not valid UTF-8"));
let error = Err(Error::new(
ErrorKind::Other,
"Input character is not valid UTF-8",
));
if c.is_ascii() {
Ok(c as char)
} else {