Refactoring

examples/acme_parser.rs

@@ -1,5 +1,6 @@
 use std::str::Chars;
 use std::iter::Peekable;
+use std::rc::Rc;
 
 extern crate datafusion_sql;
 
@@ -62,43 +63,58 @@ impl SQLTokenizer<AcmeToken> for AcmeTokenizer {
     }
 }
 
-struct AcmeParser<'a> {
+struct AcmeParser {
-    chars: Peekable<Chars<'a>>
+    tokenizer: Rc<SQLTokenizer<AcmeToken>>
 }
+//
+//impl<'a> AcmeParser<'a> {
+//
+//    pub fn new(sql: &'a str) -> Self {
+//        AcmeParser {
+//            chars: sql.chars().peekable()
+//        }
+//    }
+//}
 
-impl<'a> AcmeParser<'a> {
+impl SQLParser<AcmeToken, AcmeExpr> for AcmeParser {
-
-    pub fn new(sql: &'a str) -> Self {
-        AcmeParser {
-            chars: sql.chars().peekable()
-        }
-    }
-}
-
-impl<'a> SQLParser<AcmeToken, AcmeExpr> for AcmeParser<'a> {
 
     fn parse_prefix(&mut self) -> Result<Box<SQLExpr<AcmeExpr>>, ParserError<AcmeToken>> {
         unimplemented!()
     }
 
-    fn parse_infix(&mut self, left: &SQLExpr<AcmeExpr>, precedence: usize) -> Result<Option<Box<SQLExpr<AcmeExpr>>>, ParserError<AcmeToken>> {
+    fn parse_infix(&mut self, left: &SQLExpr<AcmeExpr>, _precedence: usize) -> Result<Option<Box<SQLExpr<AcmeExpr>>>, ParserError<AcmeToken>> {
         unimplemented!()
     }
 }
 
-
 fn main() {
 
     let sql = "1 + !! 5 * 2";
 
-    let acme_parser = AcmeParser::new(sql);
+//    let acme_parser = AcmeParser::new(sql);
 
 
     //acme_parser
 
-//    let mut acme_tokenizer = AcmeTokenizer {
+    let mut acme_tokenizer: Rc<SQLTokenizer<AcmeToken>> = Rc::new(AcmeTokenizer {
-//        generic: ANSISQLTokenizer { }
+        generic: ANSISQLTokenizer { }
-//    };
+    });
+
+    let mut acme_parser: Rc<SQLParser<AcmeToken, AcmeExpr>> = Rc::new(AcmeParser {
+        tokenizer: acme_tokenizer.clone()
+    });
+
+//    let mut pratt_parser = Rc::new(PrattParser {
+//        chars: sql.chars().peekable(),
+//        tokenizer: acme_tokenizer.clone(),
+//        parser: acme_parser.clone()
+//    });
+
+    let mut chars = sql.chars().peekable();
+
+    let expr = parse_expr(acme_tokenizer, acme_parser, &mut chars);
+
+    println!("Parsed: {:?}", expr);
 //
 //    let tokens = tokenize(&sql, &mut acme_tokenizer).unwrap();
 //

src/ansi/parser.rs

@@ -29,7 +29,7 @@ impl<'a, TokenType, ExprType> SQLParser<TokenType, ExprType> for ANSISQLParser<'
         }
     }
 
-    fn parse_infix(&mut self, left: &SQLExpr<ExprType>, precedence: usize) -> Result<Option<Box<SQLExpr<ExprType>>>, ParserError<TokenType>> {
+    fn parse_infix(&mut self, _left: &SQLExpr<ExprType>, _precedence: usize) -> Result<Option<Box<SQLExpr<ExprType>>>, ParserError<TokenType>> {
         unimplemented!()
     }
 }

src/ansi/tokenizer.rs

@@ -10,11 +10,11 @@ pub struct ANSISQLTokenizer {}
 impl<TokenType> SQLTokenizer<TokenType> for ANSISQLTokenizer
     where TokenType: Debug + PartialEq {
 
-    fn precedence(&self, token: &SQLToken<TokenType>) -> usize {
+    fn precedence(&self, _token: &SQLToken<TokenType>) -> usize {
         unimplemented!()
     }
 
-    fn peek_token(&self, chars: &mut Peekable<Chars>) -> Result<Option<SQLToken<TokenType>>, TokenizerError<TokenType>> {
+    fn peek_token(&self, _chars: &mut Peekable<Chars>) -> Result<Option<SQLToken<TokenType>>, TokenizerError<TokenType>> {
         unimplemented!()
     }
 

src/parser.rs

@@ -117,37 +117,43 @@ pub trait SQLParser<TokenType, ExprType>
 }
 
 
-
+pub fn parse_expr<'a, TokenType, ExprType>(_tokenizer: Rc<SQLTokenizer<TokenType>>, _parser: Rc<SQLParser<TokenType, ExprType>>, _chars: &mut Peekable<Chars<'a>>)
-struct PrattParser<'a, TokenType, ExprType> {
+    -> Result<Box<SQLExpr<ExprType>>, ParserError<TokenType>> where TokenType: Debug + PartialEq, ExprType: Debug {
-    chars: Peekable<Chars<'a>>,
+    unimplemented!()
-    tokenizer: Rc<SQLTokenizer<TokenType>>,
-    parser: SQLParser<TokenType, ExprType>
 }
 
-impl<'a, TokenType, ExprType> PrattParser<'a, TokenType, ExprType>
-    where TokenType: Debug + PartialEq, ExprType: Debug {
 
-    fn parse_expr(&mut self) -> Result<Box<SQLExpr<ExprType>>, ParserError<TokenType>> {
+//pub struct PrattParser<'a, TokenType, ExprType> {
-
+//    chars: Peekable<Chars<'a>>,
-        let precedence: usize = 0;
+//    tokenizer: Rc<SQLTokenizer<TokenType>>,
-
+//    parser: Rc<SQLParser<TokenType, ExprType>>
-        let mut expr = self.parser.parse_prefix()?;
+//}
-
+//
-        while let Some(token) = self.tokenizer.peek_token(&mut self.chars)? {
+//impl<'a, TokenType, ExprType> PrattParser<'a, TokenType, ExprType>
-
+//    where TokenType: Debug + PartialEq, ExprType: Debug {
-            let next_precedence = self.tokenizer.precedence(&token);
+//
-
+//    pub fn parse_expr(&mut self) -> Result<Box<SQLExpr<ExprType>>, ParserError<TokenType>> {
-            if precedence >= next_precedence {
+//
-                break;
+//        let precedence: usize = 0;
-            }
+//        let parser_ref = self.parser.as_ref();
-
+//
-            expr = self.parser.parse_infix(&expr, next_precedence)?.unwrap(); //TODO: fix me
+//        let mut expr = parser_ref.parse_prefix()?;
-        }
+//
-
+//        while let Some(token) = self.tokenizer.peek_token(&mut self.chars)? {
-        Ok(expr)
+//
-    }
+//            let next_precedence = self.tokenizer.precedence(&token);
-
+//
-}
+//            if precedence >= next_precedence {
+//                break;
+//            }
+//
+//            expr = parser_ref.parse_infix(&expr, next_precedence)?.unwrap(); //TODO: fix me
+//        }
+//
+//        Ok(expr)
+//    }
+//
+//}
 
 //    fn parse_prefix(&mut self) -> Result<Box<SQLExpr>, ParserError> {
 //