Add Stmt and incorporate meta statements

This helps split up expressions, meta calls (like includes) that can be
expanded into more expressions.

Signed-off-by: Alek Ratzloff <alekratz@gmail.com>

src/syn/parser.rs

@@ -83,16 +83,46 @@ impl<'t> Parser<'t> {
         }
     }
 
-    /// Gets all expressions until EOF is reached, or until a quote end is reached.
-    pub fn next_expr_list(&mut self) -> Result<Vec<SpExpr>> {
-        let mut exprs = Vec::new();
+    pub fn next_stmt_list(&mut self) -> Result<Vec<SpStmt>> {
+        let mut stmts = Vec::new();
         while let Some(peek) = self.peek()? {
             match peek.inner() {
                 Token::RQuote => break,
-                _ => exprs.push(self.next_expr()?),
+                _ => stmts.push(self.next_stmt()?),
+            }
+        }
+
+        Ok(stmts)
+    }
+
+    pub fn next_stmt(&mut self) -> Result<SpStmt> {
+        match self.peek()? {
+            Some(peek) if *peek.inner() == Token::Meta => self.next_meta(),
+            _ => {
+                let expr = self.next_expr()?;
+                let span = expr.span();
+                Ok(SpStmt::new(span, Stmt::Expr(expr)))
+            }
+        }
+    }
+
+    pub fn next_meta(&mut self) -> Result<SpStmt> {
+        let (meta_span, _token) = self.expect_any_token(&[Token::Meta])?.into_split();
+        let text = meta_span.text_at(self.lexer.text());
+        match text {
+            "%include" => {
+                // get the include location string
+                let (path_span, _token) = self.expect_any_token(&[Token::Str])?.into_split();
+                let path = unescape_string(path_span.text_at(self.lexer.text()));
+                Ok(SpStmt::new(meta_span.union(path_span), Stmt::Include(path)))
+            }
+            _ => {
+                todo!(
+                    "put a warning message here for an unknown meta statement {:?}",
+                    text
+                )
             }
         }
-        Ok(exprs)
     }
 
     pub fn next_expr(&mut self) -> Result<SpExpr> {
@@ -109,10 +139,10 @@ impl<'t> Parser<'t> {
 
     pub fn next_quote(&mut self) -> Result<SpExpr> {
         let start = self.expect_any_token(&[Token::LQuote])?;
-        let exprs = self.next_expr_list()?;
+        let stmts = self.next_stmt_list()?;
         let end = self.expect_any_token(&[Token::RQuote])?;
         let span = start.span().union(end.span());
-        Ok(SpExpr::new(span, Expr::Quote(exprs)))
+        Ok(SpExpr::new(span, Expr::Quote(stmts)))
     }
 
     pub fn next_atom(&mut self) -> Result<SpAtom> {
@@ -217,7 +247,7 @@ macro_rules! make_quote {
 macro_rules! make_quote_vec {
     ($($expr:expr),+ $(,)?) => {{
         vec![$(
-            SpExpr::new(Default::default(), $expr)
+            SpStmt::new(Default::default(), Stmt::Expr(SpExpr::new(Default::default(), $expr)))
         ),+]
     }};
 }