Parse interpolated strings

src/dreammaker/ast.rs

@@ -242,7 +242,9 @@ pub enum Term {
     /// The current proc's return value (`.`).
     ReturnValue,
     /// A use of the `call()()` primitive.
-    DynamicCall(Vec<Expression>, Vec<Expression>)
+    DynamicCall(Vec<Expression>, Vec<Expression>),
+    /// An interpolated string, alternating string/expr/string/expr.
+    InterpString(String, Vec<(Expression, String)>),
 }
 
 impl From<Expression> for Term {

src/dreammaker/parser.rs

@@ -418,7 +418,7 @@ impl<I> Parser<I> where
                 }));
                 let _parameters = parameters.into_iter().filter_map(|x| x).collect::<Vec<_>>();
                 let _body = require!(self.block());
-                println!("proc/{:?} ({:?}) {:?}", path, _parameters, _body);
+                println!("proc/{:?} ({:?}) {:#?}", path, _parameters, _body);
                 SUCCESS
             }
             other => {
@@ -776,6 +776,24 @@ impl<I> Parser<I> where
                 Term::Expr(Box::new(expr))
             },
 
+            Token::InterpStringBegin(begin) => {
+                let mut parts = Vec::new();
+                loop {
+                    let expr = require!(self.expression(false));
+                    match self.next("interpolated string part")? {
+                        Token::InterpStringPart(part) => {
+                            parts.push((expr, part));
+                        },
+                        Token::InterpStringEnd(end) => {
+                            parts.push((expr, end));
+                            break;
+                        },
+                        _ => return self.parse_error(),
+                    }
+                }
+                Term::InterpString(begin, parts)
+            },
+
             other => return self.try_another(other),
         })
     }