parser appears to work (oh my)

3 files changed, 221 insertions, 1 deletions

diff --git a/src/lang/mod.rs b/src/lang/mod.rs
index 8256f34..14a9202 100644
--- a/src/lang/mod.rs
+++ b/src/lang/mod.rs
@@ -1,6 +1,10 @@
 pub mod tokenizer;
 pub use self::tokenizer::Tokenizer;
+pub mod parser;
+pub use self::parser::Parser;
 
+// NB: No Eq due to embedded f32
+#[derive(Debug,PartialEq,Clone)]
 pub enum Token {
     Ident(String),
     Integer(isize),
@@ -10,3 +14,31 @@ pub enum Token {
     EOF,
 }
 
+#[derive(Debug,PartialEq,Eq,Clone,Copy)]
+pub enum TokType {
+    Ident,
+    Integer,
+    Float,
+    Oper,
+    String,
+    EOF,
+}
+
+impl Token {
+    pub fn to_type(&self) -> TokType {
+        match *self {
+            Token::Ident(_) => TokType::Ident,
+            Token::Integer(_) => TokType::Integer,
+            Token::Float(_) => TokType::Float,
+            Token::Oper(_) => TokType::Oper,
+            Token::String(_) => TokType::String,
+            Token::EOF => TokType::EOF,
+        }
+    }
+}
+
+impl<'a> From<&'a Token> for TokType {
+    fn from(tok: &'a Token) -> TokType {
+        tok.to_type()
+    }
+}
diff --git a/src/lang/parser.rs b/src/lang/parser.rs
new file mode 100644
index 0000000..d068b07
--- /dev/null
+++ b/src/lang/parser.rs
@@ -0,0 +1,175 @@
+use std::{mem, fmt};
+use std::error::Error;
+use std::collections::HashMap;
+use super::*;
+use synth::*;
+
+#[derive(Debug)]
+pub enum ErrorKind {
+    Unexpected(TokType, TokType),
+    ExpectedOp(char, TokType),
+    UnknownGen(String),
+}
+
+#[derive(Debug)]
+pub struct ErrorType {
+    pub kind: ErrorKind,
+    desc: String,
+}
+
+impl ErrorType {
+    pub fn new(kind: ErrorKind) -> ErrorType {
+        let mut ret = ErrorType {
+            kind: kind,
+            desc: "".to_string(),
+        };
+
+        ret.desc = match &ret.kind {
+            &ErrorKind::Unexpected(found, expected) => format!("Found {:?}, expected {:?}", found, expected),
+            &ErrorKind::ExpectedOp(c, found) => format!("Expected {:?}, found {:?}", c, found),
+            &ErrorKind::UnknownGen(ref s) => format!("Unknown generator name {}", s),
+        };
+
+        ret
+    }
+
+    pub fn with_description(kind: ErrorKind, desc: String) -> ErrorType {
+        ErrorType {
+            kind: kind,
+            desc: desc,
+        }
+    }
+}
+
+impl Error for ErrorType {
+    fn description<'a>(&'a self) -> &'a str {
+        &self.desc
+    }
+}
+
+impl fmt::Display for ErrorType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        write!(f, "{}", self.description())
+    }
+}
+
+pub struct Parser<T: Iterator<Item=char>> {
+    tzr: Tokenizer<T>,
+    token: Token,
+    pushback: Option<Token>,
+    factories: HashMap<String, &'static GeneratorFactory>,
+}
+
+impl<T: Iterator<Item=char>> Parser<T> {
+    pub fn new(mut tzr: Tokenizer<T>) -> Result<Parser<T>, Box<Error>> {
+        let token = tzr.next_token()?;
+        Ok(Parser {
+            tzr: tzr,
+            token: token,
+            pushback: None,
+            factories: all_factories(),
+        })
+    }
+
+    pub fn push_back(&mut self, tok: Token) {
+        match self.pushback {
+            None => {
+                self.pushback = Some(mem::replace(&mut self.token, tok));
+            },
+            Some(_) => panic!("too many pushbacks on Parser"),
+        }
+    }
+
+    pub fn expect(&mut self, ty: TokType) -> Result<Token, Box<Error>> {
+        if ty == self.token.to_type() {
+            Ok(mem::replace(&mut self.token, match self.pushback {
+                Some(_) => mem::replace(&mut self.pushback, None).unwrap(),
+                None => self.tzr.next_token()?,
+            }))
+        } else {
+            Err(ErrorType::new(ErrorKind::Unexpected(self.token.to_type(), ty)).into())
+        }
+    }
+
+    pub fn expect_ident(&mut self) -> Result<String, Box<Error>> {
+        match self.expect(TokType::Ident)? {
+            Token::Ident(s) => Ok(s),
+            _ => unreachable!(),
+        }
+    }
+
+    pub fn expect_op(&mut self, oper: char) -> Result<(), Box<Error>> {
+        match self.token {
+            Token::Oper(c) if c == oper => { self.expect(TokType::Oper)?; Ok(()) },
+            _ => Err(ErrorType::new(ErrorKind::ExpectedOp(oper, self.token.to_type())).into()),
+        }
+    }
+
+    pub fn parse(&mut self) -> Result<GenBox, Box<Error>> {
+        self.parse_gen()
+    }
+
+    pub fn parse_gen(&mut self) -> Result<GenBox, Box<Error>> {
+        let name = self.expect_ident()?;
+
+        self.expect_op('(')?;
+        let mut params: FactoryParameters = Default::default();
+        let mut ctr = 0;
+        loop {
+            if self.expect_op(')').is_ok() {
+                break;
+            }
+            let (nm, vl, new_ctr) = self.parse_param(ctr)?;
+            params.vars.insert(nm, vl);
+            ctr = new_ctr;
+
+            if self.expect_op(',').is_err() {
+                eprintln!("No comma: {:?}", self.token);
+                self.expect_op(')')?;
+                break;
+            }
+        }
+
+        let factory = match self.factories.get(&name) {
+            Some(fac) => fac,
+            None => return Err(ErrorType::new(ErrorKind::UnknownGen(name)).into()),
+        };
+        factory.new(&mut params).map_err(Into::into)
+    }
+
+    pub fn parse_param(&mut self, pos: usize) -> Result<(String, ParamValue, usize), Box<Error>> {
+        let mut ctr = pos;
+        let name = match self.expect_ident() {
+            Ok(nm) => {
+                if self.expect_op('=').is_ok() {
+                    nm
+                } else {
+                    match &self.token {
+                        &Token::Oper(c) if c == '(' => {
+                            self.push_back(Token::Ident(nm));
+                            ctr += 1;
+                            (ctr - 1).to_string()
+                        },
+                        _ => return Err(ErrorType::new(ErrorKind::Unexpected(self.token.to_type(), TokType::Ident)).into()),
+                    }
+                }
+            },
+            Err(_) => {
+                ctr += 1;
+                (ctr - 1).to_string()
+            },
+        };
+
+        let ret = match self.token {
+            Token::Integer(v) => Ok((name, ParamValue::Integer(v), ctr)),
+            Token::Float(v) => Ok((name, ParamValue::Float(v), ctr)),
+            Token::String(ref v) => Ok((name, ParamValue::String(v.clone()), ctr)),
+            Token::Ident(_) => return Ok((name, ParamValue::Generator(self.parse_gen()?), ctr)),
+            _ => return Err(ErrorType::new(ErrorKind::Unexpected(self.token.to_type(), TokType::Ident)).into()),
+        };
+
+        let tp = self.token.to_type();
+        self.expect(tp);
+        ret
+    }
+}
diff --git a/src/lang/tokenizer.rs b/src/lang/tokenizer.rs
index d1b34e0..4f2858c 100644
--- a/src/lang/tokenizer.rs
+++ b/src/lang/tokenizer.rs
@@ -173,13 +173,20 @@ impl<T: Iterator<Item=char>> Tokenizer<T> {
         }
     }
 
-    fn next_token(&mut self) -> Result<Token, ErrorType> {
+    pub fn next_token(&mut self) -> Result<Token, ErrorType> {
+        let res = self._next_token();
+        eprintln!("next_token: {:?}", res);
+        res
+    }
+
+    fn _next_token(&mut self) -> Result<Token, ErrorType> {
         let mut c = self.next_char();
         if c == None {
             return Ok(Token::EOF);
         }
         let mut cc = c.unwrap();
 
+        /* Whitespace */
         while cc.is_whitespace() {
             c = self.next_char();
             if c == None {
@@ -315,10 +322,16 @@ impl<T: Iterator<Item=char>> Tokenizer<T> {
                     radix = 16;
                 } else if ncc == self.lexemes.esc_oct {
                     radix = 8;
+                } else if ncc == self.lexemes.radix_point {
+                    floating = true;
+                    buffer.push(cc);
+                    buffer.push(ncc);
                 } else {
                     buffer.push(cc);
                     buffer.push(ncc);
                 }
+            } else {
+                buffer.push(cc);
             }
 
             loop {