2020-01-17 16:23:21 -05:00
|
|
|
use std::iter::Peekable;
|
|
|
|
use std::vec::IntoIter;
|
|
|
|
|
2020-01-18 19:54:47 -05:00
|
|
|
use crate::common::{Pos, Printer, Scope, Symbol};
|
2020-01-18 23:55:11 -05:00
|
|
|
use crate::function::{eat_call_args, eat_func_args, CallArgs, FuncArgs};
|
2020-01-17 08:14:10 -05:00
|
|
|
use crate::selector::Selector;
|
2020-01-18 19:54:47 -05:00
|
|
|
use crate::utils::devour_whitespace;
|
|
|
|
use crate::{eat_expr, Expr, RuleSet, Stmt, Token, TokenKind};
|
2020-01-12 20:15:40 -05:00
|
|
|
|
|
|
|
#[derive(Debug, Clone)]
|
|
|
|
pub struct Mixin {
|
|
|
|
scope: Scope,
|
|
|
|
args: FuncArgs,
|
2020-01-17 08:14:10 -05:00
|
|
|
body: Peekable<IntoIter<Token>>,
|
2020-01-12 20:15:40 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Mixin {
|
|
|
|
pub fn new(scope: Scope, args: FuncArgs, body: Vec<Token>) -> Self {
|
2020-01-17 21:20:56 -05:00
|
|
|
let body = body.into_iter().peekable();
|
2020-01-18 21:15:09 -05:00
|
|
|
Mixin { scope, args, body }
|
2020-01-12 20:15:40 -05:00
|
|
|
}
|
|
|
|
|
2020-01-18 19:54:47 -05:00
|
|
|
pub fn from_tokens<I: Iterator<Item = Token>>(
|
|
|
|
toks: &mut Peekable<I>,
|
|
|
|
scope: &Scope,
|
|
|
|
) -> Result<(String, Mixin), Printer> {
|
|
|
|
let Token { pos, .. } = toks
|
|
|
|
.next()
|
|
|
|
.expect("this must exist because we have already peeked");
|
|
|
|
devour_whitespace(toks);
|
2020-01-19 01:01:02 -05:00
|
|
|
let name = match toks.next() {
|
|
|
|
Some(Token {
|
|
|
|
kind: TokenKind::Ident(s),
|
|
|
|
..
|
|
|
|
}) => s,
|
|
|
|
_ => {
|
|
|
|
return Err(Printer::Error(
|
|
|
|
pos,
|
|
|
|
String::from("expected identifier after mixin declaration"),
|
|
|
|
))
|
|
|
|
}
|
2020-01-18 19:54:47 -05:00
|
|
|
};
|
|
|
|
devour_whitespace(toks);
|
|
|
|
let args = match toks.next() {
|
|
|
|
Some(Token {
|
|
|
|
kind: TokenKind::Symbol(Symbol::OpenParen),
|
|
|
|
..
|
|
|
|
}) => eat_func_args(toks),
|
|
|
|
Some(Token {
|
|
|
|
kind: TokenKind::Symbol(Symbol::OpenCurlyBrace),
|
|
|
|
..
|
|
|
|
}) => FuncArgs::new(),
|
|
|
|
_ => return Err(Printer::Error(pos, String::from("expected `(` or `{`"))),
|
|
|
|
};
|
|
|
|
|
|
|
|
let mut nesting = 1;
|
|
|
|
let mut body = Vec::new();
|
|
|
|
|
|
|
|
while nesting > 0 {
|
|
|
|
if let Some(tok) = toks.next() {
|
|
|
|
match &tok.kind {
|
2020-01-19 01:01:02 -05:00
|
|
|
TokenKind::Symbol(Symbol::OpenCurlyBrace)
|
|
|
|
// interpolation token eats the opening brace but not the closing
|
|
|
|
| TokenKind::Interpolation => nesting += 1,
|
|
|
|
TokenKind::Symbol(Symbol::CloseCurlyBrace) => nesting -= 1,
|
|
|
|
_ => {}
|
|
|
|
}
|
2020-01-18 19:54:47 -05:00
|
|
|
body.push(tok)
|
|
|
|
} else {
|
|
|
|
return Err(Printer::Error(pos, String::from("unexpected EOF")));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok((name, Mixin::new(scope.clone(), args, body)))
|
|
|
|
}
|
|
|
|
|
2020-01-18 20:24:28 -05:00
|
|
|
pub fn args(mut self, args: &CallArgs) -> Mixin {
|
2020-01-19 10:58:38 -05:00
|
|
|
for (idx, arg) in self.args.0.iter().enumerate() {
|
|
|
|
let val = match args.get(&format!("{}", idx)) {
|
2020-01-19 12:10:35 -05:00
|
|
|
Some(v) => v.clone(),
|
2020-01-19 10:58:38 -05:00
|
|
|
None => match args.get(&arg.name) {
|
2020-01-19 12:10:35 -05:00
|
|
|
Some(v) => v.clone(),
|
2020-01-19 10:58:38 -05:00
|
|
|
None => arg.default.clone().expect("missing variable!"),
|
|
|
|
},
|
|
|
|
};
|
|
|
|
self.scope.vars.insert(arg.name.clone(), val);
|
2020-01-17 14:44:55 -05:00
|
|
|
}
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2020-01-19 00:10:37 -05:00
|
|
|
pub fn call(mut self, super_selector: &Selector) -> Result<Vec<Stmt>, (Pos, String)> {
|
2020-01-18 21:15:09 -05:00
|
|
|
self.eval(super_selector)
|
2020-01-18 09:03:38 -05:00
|
|
|
}
|
|
|
|
|
2020-01-19 00:10:37 -05:00
|
|
|
pub fn eval(&mut self, super_selector: &Selector) -> Result<Vec<Stmt>, (Pos, String)> {
|
2020-01-17 08:14:10 -05:00
|
|
|
let mut stmts = Vec::new();
|
2020-01-18 23:55:11 -05:00
|
|
|
while let Some(expr) = eat_expr(&mut self.body, &self.scope, super_selector)? {
|
2020-01-17 08:14:10 -05:00
|
|
|
match expr {
|
|
|
|
Expr::Style(s) => stmts.push(Stmt::Style(s)),
|
2020-01-19 00:10:37 -05:00
|
|
|
Expr::Include(..) | Expr::MixinDecl(..) | Expr::Debug(..) | Expr::Warn(..) => {
|
|
|
|
todo!()
|
|
|
|
}
|
2020-01-18 21:15:09 -05:00
|
|
|
Expr::Selector(selector) => {
|
|
|
|
let rules = self.eval(&super_selector.zip(&selector))?;
|
2020-01-17 08:14:10 -05:00
|
|
|
stmts.push(Stmt::RuleSet(RuleSet {
|
|
|
|
super_selector: super_selector.clone(),
|
2020-01-18 21:15:09 -05:00
|
|
|
selector,
|
2020-01-17 08:14:10 -05:00
|
|
|
rules,
|
|
|
|
}));
|
2020-01-12 20:15:40 -05:00
|
|
|
}
|
2020-01-17 08:14:10 -05:00
|
|
|
Expr::VariableDecl(name, val) => {
|
2020-01-18 21:15:09 -05:00
|
|
|
self.scope.vars.insert(name, val);
|
2020-01-14 19:34:13 -05:00
|
|
|
}
|
2020-01-17 08:14:10 -05:00
|
|
|
Expr::MultilineComment(s) => stmts.push(Stmt::MultilineComment(s)),
|
2020-01-12 20:15:40 -05:00
|
|
|
}
|
|
|
|
}
|
2020-01-17 21:42:51 -05:00
|
|
|
Ok(stmts)
|
2020-01-12 20:15:40 -05:00
|
|
|
}
|
|
|
|
}
|
2020-01-18 23:55:11 -05:00
|
|
|
|
|
|
|
pub fn eat_include<I: Iterator<Item = Token>>(
|
|
|
|
toks: &mut Peekable<I>,
|
|
|
|
scope: &Scope,
|
|
|
|
super_selector: &Selector,
|
2020-01-19 00:10:37 -05:00
|
|
|
) -> Result<Vec<Stmt>, (Pos, String)> {
|
2020-01-18 23:55:11 -05:00
|
|
|
toks.next();
|
|
|
|
devour_whitespace(toks);
|
|
|
|
let Token { kind, pos } = toks
|
|
|
|
.next()
|
|
|
|
.expect("this must exist because we have already peeked");
|
|
|
|
let name = match kind {
|
|
|
|
TokenKind::Ident(s) => s,
|
2020-01-19 00:10:37 -05:00
|
|
|
_ => return Err((pos, String::from("expected identifier"))),
|
2020-01-18 23:55:11 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
devour_whitespace(toks);
|
|
|
|
|
|
|
|
let args = if let Some(tok) = toks.next() {
|
|
|
|
match tok.kind {
|
|
|
|
TokenKind::Symbol(Symbol::SemiColon) => CallArgs::new(),
|
|
|
|
TokenKind::Symbol(Symbol::OpenParen) => eat_call_args(toks),
|
2020-01-19 00:10:37 -05:00
|
|
|
_ => return Err((pos, String::from("expected `(` or `;`"))),
|
2020-01-18 23:55:11 -05:00
|
|
|
}
|
|
|
|
} else {
|
2020-01-19 00:10:37 -05:00
|
|
|
return Err((pos, String::from("unexpected EOF")));
|
2020-01-18 23:55:11 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
devour_whitespace(toks);
|
|
|
|
|
|
|
|
if !args.is_empty() {
|
|
|
|
if let Some(tok) = toks.next() {
|
|
|
|
assert_eq!(tok.kind, TokenKind::Symbol(Symbol::SemiColon));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
devour_whitespace(toks);
|
|
|
|
|
|
|
|
let mixin = match scope.mixins.get(&name) {
|
|
|
|
Some(m) => m.clone(),
|
2020-01-19 00:10:37 -05:00
|
|
|
_ => return Err((pos, String::from("expected identifier"))),
|
2020-01-18 23:55:11 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
let rules = mixin.args(&args).call(super_selector)?;
|
|
|
|
Ok(rules)
|
|
|
|
}
|