The event emitter of the reader compiles.

The event emitter of the reader now compiles.  I am leaving the project
as is for now, though I may return later.

Author: DemiMarie

src/read.rs

@@ -1,15 +1,30 @@
 use std::io;
 use std::io::prelude::*;
 use std::char;
-use super::{alloc, value};
+use std::iter::Peekable;
+use super::interp;
 
+#[derive(Debug)]
 pub enum ReadError {
+    /// EOF in list
     EOFInList,
+
+    /// EOF in vector
     EOFInVector,
+
+    /// Missing `)`
     MissingCloseParen,
+
+    /// Input/output error
     IoError(io::Error),
+
+    /// EOF in string
     EOFInString,
+
+    /// EOF in symbol
     EOFInSymbol,
+
+    /// EOF after `#\\`
     EOFAfterSharpBackslash,
 
     /// Bad sharpsign read macro
@@ -30,6 +45,9 @@ pub enum ReadError {
     /// Stream not valid UTF-8.  The argument is
     /// the partial sequence accumulated.
     InvalidUtf8(u32),
+
+    /// `|` in symbol unescaped
+    PipeInSymbol,
 }
 
 /// An event that can be emitted by the reader or tree-walker, and which
@@ -93,6 +111,9 @@ pub enum Event {
     /// Unsyntax splicing #,@
     UnsyntaxSplicing,
 
+    /// Dot `.`
+    Dot,
+
     /// End of file
     EOF,
 }
@@ -103,7 +124,8 @@ enum StringOrSymbol {
     Symbol,
 }
 
-fn char_from_stream_and_byte<R: BufRead>(file: &mut Bytes<R>, unicode_char: u8)
+fn char_from_stream_and_byte<R: BufRead>(file: &mut Peekable<Bytes<R>>,
+                                         unicode_char: u8)
                                          -> Result<char, ReadError> {
     if unicode_char <= 0x7F {
         return Ok(unicode_char as char);
@@ -115,9 +137,8 @@ fn char_from_stream_and_byte<R: BufRead>(file: &mut Bytes<R>, unicode_char: u8)
             let len = len - 1;
             let mut value: u32 = (unicode_char >> (len + 2)).into();
             value <<= len * 6;
-            for (count, current_byte_value) in file.take(len.into()).enumerate()  {
-                let current: u32 = try!(current_byte_value.map_err(
-                    ReadError::IoError)).into();
+            for (count, current_byte_value) in file.take(len.into()).enumerate() {
+                let current: u32 = try!(current_byte_value.map_err(ReadError::IoError)).into();
                 value &= current << (len - count as u8)
             }
             char::from_u32(value).ok_or(ReadError::InvalidUtf8(value))
@@ -134,7 +155,7 @@ macro_rules! next {
 type ReadResult = Result<char, ReadError>;
 
 use std::io::Bytes;
-fn handle_unicode_escape<R: BufRead>(file: &mut Bytes<R>) -> ReadResult {
+fn handle_unicode_escape<R: BufRead>(file: &mut Peekable<Bytes<R>>) -> ReadResult {
     loop {
         let eof = ReadError::BadEscape;
         let mut escaped_char = 0;
@@ -157,10 +178,10 @@ fn handle_unicode_escape<R: BufRead>(file: &mut Bytes<R>) -> ReadResult {
     }
 }
 
-fn process_escape<R: BufRead>(file: &mut Bytes<R>) -> ReadResult {
+fn process_escape<R: BufRead>(file: &mut Peekable<Bytes<R>>) -> ReadResult {
     let bad = ReadError::BadEscape;
     loop {
-        return Ok(match next!(file, bad) {
+        return Ok(match next!(file, ReadError::BadEscape) {
             b'n' => '\n',
             b't' => '\t',
             b'e' => '\x1b',
@@ -186,8 +207,9 @@ fn process_escape<R: BufRead>(file: &mut Bytes<R>) -> ReadResult {
 
 
 
-pub fn read_escaped<R: BufRead>(file: &mut Bytes<R>, delimiter: StringOrSymbol)
-                             -> Result<String, ReadError> {
+fn read_escaped<R: BufRead>(file: &mut Peekable<Bytes<R>>,
+                            delimiter: StringOrSymbol)
+                            -> Result<String, ReadError> {
     use std::char;
     let premature_eof = || {
         match delimiter {
@@ -196,7 +218,7 @@ pub fn read_escaped<R: BufRead>(file: &mut Bytes<R>, delimiter: StringOrSymbol)
         }
     };
 
-    let buf = String::new();
+    let mut buf = String::new();
     loop {
         buf.push(match next!(file, premature_eof()) {
             b'\\' => try!(process_escape(file)),
@@ -208,100 +230,164 @@ pub fn read_escaped<R: BufRead>(file: &mut Bytes<R>, delimiter: StringOrSymbol)
     }
     Ok(buf)
 }
-// if delimiter == UndelimitedSymbol && c.is_whitespace() {
-// break
-// } else {
-// c
-// }
-// }
-// let bad = ReadError::BadEscape;
-// loop {
-// return Ok(match next!(file, bad) {
-// b'n' => '\n',
-// b't' => '\t',
-// b'e' => '\x1b',
-// b'b' => '\x08',
-// b'v' => '\x0b',
-// b'\r' => match next!(file, bad) {
-// Some(b'\n') => continue,
-// _ => return Err(bad),
-// },
-// b'\n' => continue,
-// b'x' | b'u' => try!(handle_unicode_escape(file)),
-// literal@b'|'|b'"'|b'\\'|b'#'|b'`'|b','|b'\'' => literal.into(),
-// _ => return Err(bad),
-// })
-// }
-//
+
 pub struct Reader<'a, 'b, T: 'a + BufRead> {
     stream: &'a mut T,
     state: &'b mut interp::State,
 }
 
-//    let chars = file.chars().peekable();
-// let mut depth = 1;
-// let ref mut heap = state.heap;
-// let run_macros_self_evaluating = |mut value| while let Some(x) = vec.pop()
-// {
-// match x {
-// State::InList(ref x)|State::InVec(ref x) => {
-// x += 1
-// }
-// State::ReadEval => unimplemented!(),
-//
-// State::Quote | State::Unquote | State::Quasiquote |
-// State::Syntax | State::Unsyntax | State::Quasisyntax => {
-// state.push_nil();
-// state.list(2)
-// }
-// }
-// };
-//
-
-
-
-pub fn read<R: BufRead>(file: &mut Bytes<R>) -> Result<Event, ReadError> {
-    let handle_splicing = |file: &mut Bytes<R>, nosplice, splice| match file.peek() {
-        Some(Ok('@')) => { file.next(); Ok(splice) }
-        Some(Ok(_)) | None => Ok(nosplice),
-        Some(x) => x,
-    };
+pub struct EventSource<'a, R: 'a + BufRead> {
+    file: &'a mut Peekable<Bytes<R>>,
+    last_chr: Option<u8>,
+}
 
-    loop {
-        let next: Option<Result<u8, io::Error>> = file.next();
-        if let Some(c) = next {
-            return Ok(match try!(c.map_err(ReadError::IoError)) {
+impl<'a, R: BufRead> EventSource<'a, R> {
+    pub fn new(reader: &'a mut Peekable<Bytes<R>>) -> Self {
+        EventSource {
+            file: reader,
+            last_chr: Default::default(),
+        }
+    }
+}
+impl<'a, R: BufRead> Iterator for EventSource<'a, R> {
+    type Item = Result<Event, ReadError>;
+
+    fn next(&mut self) -> Option<<Self as Iterator>::Item> {
+        let handle_splicing = |file: &mut Peekable<Bytes<R>>, nosplice: Event, splice: Event| {
+            let res1 = {
+                let q = file.peek();
+                match q {
+                    Some(&Ok(b'@')) => (Ok(splice), true),
+                    Some(&Ok(_)) | None => (Ok(nosplice), false),
+                    Some(&Err(ref _a)) => (Err(()), true),
+                }
+            };
+            match res1 {
+                (Ok(good), take_char) => {
+                    if take_char {
+                        file.next();
+                    }
+                    Ok(good)
+                }
+                (Err(()), false) => unreachable!(),
+                (Err(()), true) => Err(file.next().unwrap().unwrap_err()),
+            }
+        };
+
+        macro_rules! my_try {
+            ($exp: expr) => {
+                match $exp {
+                    Ok(x) => x,
+                    Err(x) => return Some(Err(x)),
+                }
+            }
+        }
+
+        macro_rules! iter_next {
+            ($exp: expr, $err: expr) => {
+                my_try!(my_try!($exp.next().ok_or($err)).map_err(|x|ReadError::IoError(x)))
+            }
+        }
+        loop {
+            let chr = if let Some(chr) = self.last_chr {
+                chr
+            } else {
+                let next: Option<Result<u8, io::Error>> = self.file.next();
+                if let Some(c) = next {
+                    my_try!(c.map_err(ReadError::IoError))
+                } else {
+                    return None;
+                }
+            };
+            return Some(Ok(match chr {
                 b'(' => Event::StartList(false),
                 b'[' => Event::StartList(true),
                 b'\'' => Event::Quote,
                 b'`' => Event::Quasiquote,
-                b',' => try!(handle_splicing(file, Event::Unquote, Event::UnquoteSplicing)),
-                b'#' => match next!(file, ReadError::EOFAfterSharp) {
-                    b'.' => Event::ReadEval,
-                    b'\\' => {
-                        let byte = next!(file, ReadError::EOFAfterSharpBackslash);
-                        Event::Char(try!(char_from_stream_and_byte(file, byte)))
+                b',' => {
+                    my_try!(handle_splicing(self.file, Event::Unquote, Event::UnquoteSplicing)
+                                .map_err(ReadError::IoError))
+                }
+                b'#' => {
+                    match iter_next!(self.file, ReadError::EOFAfterSharp) {
+                        b'.' => Event::ReadEval,
+                        b'\\' => {
+                            let byte = iter_next!(self.file, ReadError::EOFAfterSharpBackslash);
+                            Event::Char(my_try!(char_from_stream_and_byte(self.file, byte)))
+                        }
+                        b't' => Event::True,
+                        b'f' => Event::False,
+                        b'\'' => Event::Syntax,
+                        b'`' => Event::Quasisyntax,
+                        b',' => {
+                            my_try!(handle_splicing(self.file,
+                                                    Event::Unsyntax,
+                                                    Event::UnsyntaxSplicing)
+                                        .map_err(ReadError::IoError))
+                        }
+                        b'(' => Event::StartVec,
+                        dispatch_char => {
+                            return Some(Err(ReadError::BadSharpMacro([dispatch_char as char,
+                                                                      '\0'])))
+                        }
                     }
-                    b't' => Event::True,
-                    b'f' => Event::False,
-                    b'\'' => Event::Syntax,
-                    b'`' => Event::Quasisyntax,
-                    b',' => try!(handle_splicing(file, Event::Unsyntax,
-                                                 Event::UnsyntaxSplicing)),
-                    b'(' => Event::StartVec,
-                    dispatch_char =>
-                        return Err(ReadError::BadSharpMacro([dispatch_char as char,
-                                                             '\0']))
-                },
+                }
                 b')' => Event::EndList(false),
                 b']' => Event::EndList(true),
-                b'"' => Event::Str(try!(read_escaped(file, StringOrSymbol::String))),
-                b'|' => Event::Symbol(try!(read_escaped(file, StringOrSymbol::Symbol))),
+                b'"' => Event::Str(my_try!(read_escaped(self.file, StringOrSymbol::String))),
+                b'|' => Event::Symbol(my_try!(read_escaped(self.file, StringOrSymbol::Symbol))),
                 b'\t'...b'\r' | b' ' => continue, // ASCII whitespace
-                
-            })
-        } else {
-            return Ok(Event::EOF);
+                val => {
+                    let chr = if val < 0x7F {
+                        val as char
+                    } else {
+                        my_try!(char_from_stream_and_byte(self.file, val))
+                    };
+                    if chr.is_whitespace() {
+                        continue;
+                    }
+                    let mut buf = String::new();
+                    buf.push(chr);
+                    loop {
+                        let chr = if let Some(x) = self.file.next() {
+                            my_try!(x.map_err(ReadError::IoError))
+                        } else {
+                            break;
+                        };
+                        match chr {
+                            b'\\' => buf.push(my_try!(process_escape(self.file))),
+                            b'|' => return Some(Err(ReadError::PipeInSymbol)),
+                            a @ b'"' |
+                            a @ b'\'' |
+                            a @ b'`' |
+                            a @ b',' |
+                            a @ b'(' |
+                            a @ b'[' |
+                            a @ b']' |
+                            a @ b')' |
+                            a @ b'{' |
+                            a @ b'}' => {
+                                self.last_chr = Some(a);
+                                break;
+                            }
+                            b'\t'...b'\r' | b' ' => break, // ASCII whitespace
+                            chr => {
+                                let unicode_char = my_try!(char_from_stream_and_byte(self.file,
+                                                                                     chr));
+                                if unicode_char.is_whitespace() {
+                                    break;
+                                }
+                                buf.push(unicode_char)
+                            }
+                        }
+                    }
+                    return Some(Ok(if &buf == "." {
+                        Event::Dot
+                    } else {
+                        Event::Symbol(buf)
+                    }));
+                }
+            }));
         }
     }
 }