Loading

Paste #pabiqyq5x

  1. use std::iter::*;
  2. use std::io::{self, Read};
  3.  
  4. #[derive(Debug, Copy, Clone)]
  5. enum Token {
  6.     Num(i32),
  7.     Plus,
  8.     Minus,
  9.     Mul,
  10.     Div,
  11.     LParen,
  12.     RParen,
  13. }
  14.  
  15. struct Lexer<T> where T: Iterator<Item = char> {
  16.     stream: Peekable<T>
  17. }
  18.  
  19. impl<T> Iterator for Lexer<T> where T: Iterator<Item = char> {
  20.     type Item = Token;
  21.     fn next(&mut self) -> Option<Token> {
  22.         while let Some(&c) = self.stream.peek() {
  23.             if c.is_whitespace() {
  24.                 self.stream.next();
  25.             } else {
  26.                 break;
  27.             }
  28.         }
  29.         self.stream.next().and_then(|c| match c {
  30.             '+' => Some(Token::Plus),
  31.             '-' => Some(Token::Minus),
  32.             '*' => Some(Token::Mul),
  33.             '/' => Some(Token::Div),
  34.             '(' => Some(Token::LParen),
  35.             ')' => Some(Token::RParen),
  36.             c if c.is_digit(10) => {
  37.                 let mut s = String::new();
  38.                 s.push(c);
  39.                 while let Some(&c) = self.stream.peek() {
  40.                     if !c.is_digit(10) { break; }
  41.                     s.push(self.stream.next().unwrap());
  42.                 }
  43.                 Some(Token::Num(s.parse().expect("Failed to parse a Num")))
  44.             },
  45.             _ => None // FIXME: report an error somehow?
  46.         })
  47.     }
  48. }
  49.  
  50. struct Parser<T> where T: Iterator<Item = Token> {
  51.     lexer: Peekable<T>
  52. }
  53.  
  54. impl<T> Parser<T> where T: Iterator<Item = Token> {
  55.     // entry point
  56.     fn parse_expression(&mut self) -> Result<i32, &'static str> {
  57.        let res = try!(self.parse_e());
  58.        match self.lexer.next() {
  59.            None => Ok(res),
  60.            Some(_) => Err("expected EOF")
  61.        }
  62.    }
  63.    fn parse_e(&mut self) -> Result<i32, &'static str> {
  64.         let mut res = try!(self.parse_t());
  65.         loop {
  66.             match self.lexer.peek() {
  67.                 Some(&Token::Plus) => {
  68.                     self.lexer.next();
  69.                     res += try!(self.parse_t());
  70.                 },
  71.                 Some(&Token::Minus) => {
  72.                     self.lexer.next();
  73.                     res -= try!(self.parse_t());
  74.                 },
  75.                 _ => return Ok(res)
  76.             }
  77.         }
  78.     }
  79.     fn parse_t(&mut self) -> Result<i32, &'static str> {
  80.        let mut res = try!(self.parse_f());
  81.        loop {
  82.            match self.lexer.peek() {
  83.                Some(&Token::Mul) => {
  84.                    self.lexer.next();
  85.                    res *= try!(self.parse_f());
  86.                },
  87.                Some(&Token::Div) => {
  88.                    self.lexer.next();
  89.                    res /= try!(self.parse_f());
  90.                },
  91.                _ => return Ok(res)
  92.            }
  93.        }
  94.    }
  95.    fn parse_f(&mut self) -> Result<i32, &'static str> {
  96.         match try!(self.lexer.next().ok_or("unexpected EOF")) {
  97.             Token::LParen => {
  98.                 let res = try!(self.parse_e());
  99.                 match try!(self.lexer.next().ok_or("unexpected EOF")) {
  100.                     Token::RParen => Ok(res),
  101.                     _ => Err("missing )")
  102.                 }
  103.             },
  104.             Token::Num(res) => Ok(res),
  105.             _ => Err("expected either Num or LParen")
  106.         }
  107.     }
  108. }
  109.  
  110. fn main() {
  111.     let mut buffer = String::new();
  112.     io::stdin().read_to_string(&mut buffer).expect("failed to read input string");
  113.     let lexer = Lexer { stream: buffer.chars().peekable() };
  114.     let mut parser = Parser { lexer: lexer.peekable() };
  115.     match parser.parse_expression() {
  116.         Ok(res) => println!("Result: {}", res),
  117.         Err(message) => println!("Error: {}", message)
  118.     }
  119. }