diff options
Diffstat (limited to 'askama_derive')
| -rw-r--r-- | askama_derive/Cargo.toml | 4 | ||||
| -rw-r--r-- | askama_derive/src/parser.rs | 184 |
2 files changed, 93 insertions, 95 deletions
diff --git a/askama_derive/Cargo.toml b/askama_derive/Cargo.toml index bf0a1ac..26cd79d 100644 --- a/askama_derive/Cargo.toml +++ b/askama_derive/Cargo.toml @@ -20,7 +20,9 @@ gotham = [] [dependencies] askama_shared = { version = "0.8", path = "../askama_shared" } -nom = "4" +# default for features for nom don't work result in linker errors: +# https://github.com/rust-lang/rust/issues/62146 +nom = { version = "5", default-features = false, features = ["std"] } proc-macro2 = "1" quote = "1" syn = "1" diff --git a/askama_derive/src/parser.rs b/askama_derive/src/parser.rs index 7769ed4..1045090 100644 --- a/askama_derive/src/parser.rs +++ b/askama_derive/src/parser.rs @@ -96,12 +96,6 @@ impl<'a> Default for MatchParameters<'a> { } } -type Input<'a> = nom::types::CompleteByteSlice<'a>; -#[allow(non_snake_case)] -fn Input(input: &[u8]) -> Input { - nom::types::CompleteByteSlice(input) -} - fn split_ws_parts(s: &[u8]) -> Node { if s.is_empty() { let rs = str::from_utf8(&s).unwrap(); @@ -130,15 +124,16 @@ fn split_ws_parts(s: &[u8]) -> Node { #[derive(Debug)] enum ContentState { + Start, Any, Brace(usize), End(usize), } fn take_content<'a>( - i: Input<'a>, + i: &'a [u8], s: &'a Syntax<'a>, -) -> Result<(Input<'a>, Node<'a>), nom::Err<Input<'a>>> { +) -> Result<(&'a [u8], Node<'a>), nom::Err<(&'a [u8], nom::error::ErrorKind)>> { use crate::parser::ContentState::*; let bs = s.block_start.as_bytes()[0]; let be = s.block_start.as_bytes()[1]; @@ -147,10 +142,10 @@ fn take_content<'a>( let es = s.expr_start.as_bytes()[0]; let ee = s.expr_start.as_bytes()[1]; - let mut state = Any; + let mut state = Start; for (idx, c) in i.iter().enumerate() { state = match state { - Any => { + Start | Any => { if *c == bs || *c == es || *c == cs { Brace(idx) } else { @@ -170,30 +165,31 @@ fn take_content<'a>( break; } } + match state { - Any | Brace(_) => Ok((Input(&i[..0]), split_ws_parts(i.0))), - End(0) => Err(nom::Err::Error(error_position!( + Any | Brace(_) => Ok((&i[..0], split_ws_parts(i))), + Start | End(0) => Err(nom::Err::Error(error_position!( i, - nom::ErrorKind::Custom(0) + nom::error::ErrorKind::TakeUntil ))), - End(start) => Ok((Input(&i[start..]), split_ws_parts(&i[..start]))), + End(start) => Ok((&i[start..], split_ws_parts(&i[..start]))), } } -fn identifier(input: Input) -> Result<(Input, &str), nom::Err<Input>> { - if !nom::is_alphabetic(input[0]) && input[0] != b'_' && !non_ascii(input[0]) { +fn identifier(input: &[u8]) -> Result<(&[u8], &str), nom::Err<(&[u8], nom::error::ErrorKind)>> { + if !nom::character::is_alphabetic(input[0]) && input[0] != b'_' && !non_ascii(input[0]) { return Err(nom::Err::Error(error_position!( input, - nom::ErrorKind::Custom(0) + nom::error::ErrorKind::AlphaNumeric ))); } for (i, ch) in input.iter().enumerate() { - if i == 0 || nom::is_alphanumeric(*ch) || *ch == b'_' || non_ascii(*ch) { + if i == 0 || nom::character::is_alphanumeric(*ch) || *ch == b'_' || non_ascii(*ch) { continue; } - return Ok((Input(&input[i..]), str::from_utf8(&input[..i]).unwrap())); + return Ok((&input[i..], str::from_utf8(&input[..i]).unwrap())); } - Ok((Input(&input[1..]), str::from_utf8(&input[..1]).unwrap())) + Ok((&input[1..], str::from_utf8(&input[..1]).unwrap())) } #[inline] @@ -201,20 +197,20 @@ fn non_ascii(chr: u8) -> bool { chr >= 0x80 && chr <= 0xFD } -named!(expr_bool_lit<Input, Expr>, map!( +named!(expr_bool_lit<&[u8], Expr>, map!( alt!(tag!("true") | tag!("false")), |s| Expr::BoolLit(str::from_utf8(&s).unwrap()) )); -named!(num_lit<Input, &str>, map!(nom::digit, - |s| str::from_utf8(s.0).unwrap() +named!(num_lit<&[u8], &str>, map!(nom::character::complete::digit1, + |s| str::from_utf8(s).unwrap() )); -named!(expr_num_lit<Input, Expr>, map!(num_lit, +named!(expr_num_lit<&[u8], Expr>, map!(num_lit, |s| Expr::NumLit(s) )); -named!(expr_array_lit<Input, Expr>, +named!(expr_array_lit<&[u8], Expr>, delimited!( ws!(tag!("[")), map!(separated_nonempty_list!( @@ -225,34 +221,34 @@ named!(expr_array_lit<Input, Expr>, ) ); -named!(variant_num_lit<Input, MatchVariant>, map!(num_lit, +named!(variant_num_lit<&[u8], MatchVariant>, map!(num_lit, |s| MatchVariant::NumLit(s) )); -named!(param_num_lit<Input, MatchParameter>, map!(num_lit, +named!(param_num_lit<&[u8], MatchParameter>, map!(num_lit, |s| MatchParameter::NumLit(s) )); -named!(expr_str_lit<Input, Expr>, map!( +named!(expr_str_lit<&[u8], Expr>, map!( delimited!(char!('"'), take_until!("\""), char!('"')), |s| Expr::StrLit(str::from_utf8(&s).unwrap()) )); -named!(variant_str_lit<Input, MatchVariant>, map!( +named!(variant_str_lit<&[u8], MatchVariant>, map!( delimited!(char!('"'), is_not!("\""), char!('"')), |s| MatchVariant::StrLit(str::from_utf8(&s).unwrap()) )); -named!(param_str_lit<Input, MatchParameter>, map!( +named!(param_str_lit<&[u8], MatchParameter>, map!( delimited!(char!('"'), is_not!("\""), char!('"')), |s| MatchParameter::StrLit(str::from_utf8(&s).unwrap()) )); -named!(expr_var<Input, Expr>, map!(identifier, +named!(expr_var<&[u8], Expr>, map!(identifier, |s| Expr::Var(s)) ); -named!(expr_path<Input, Expr>, do_parse!( +named!(expr_path<&[u8], Expr>, do_parse!( start: call!(identifier) >> tag!("::") >> rest: separated_nonempty_list!(tag!("::"), identifier) >> @@ -263,18 +259,18 @@ named!(expr_path<Input, Expr>, do_parse!( }) )); -named!(variant_path<Input, MatchVariant>, +named!(variant_path<&[u8], MatchVariant>, map!( separated_nonempty_list!(tag!("::"), identifier), |path| MatchVariant::Path(path) ) ); -named!(target_single<Input, Target>, map!(identifier, +named!(target_single<&[u8], Target>, map!(identifier, |s| Target::Name(s) )); -named!(target_tuple<Input, Target>, delimited!( +named!(target_tuple<&[u8], Target>, delimited!( tag!("("), do_parse!( res: separated_list!(tag!(","), ws!(identifier)) >> @@ -284,25 +280,25 @@ named!(target_tuple<Input, Target>, delimited!( tag!(")") )); -named!(variant_name<Input, MatchVariant>, map!(identifier, +named!(variant_name<&[u8], MatchVariant>, map!(identifier, |s| MatchVariant::Name(s) )); -named!(param_name<Input, MatchParameter>, map!(identifier, +named!(param_name<&[u8], MatchParameter>, map!(identifier, |s| MatchParameter::Name(s) )); -named!(arguments<Input, Vec<Expr>>, delimited!( +named!(arguments<&[u8], Vec<Expr>>, delimited!( tag!("("), separated_list!(tag!(","), ws!(expr_any)), tag!(")") )); -named!(macro_arguments<Input, &str>, +named!(macro_arguments<&[u8], &str>, delimited!(char!('('), nested_parenthesis, char!(')')) ); -fn nested_parenthesis(i: Input) -> Result<(Input, &str), nom::Err<Input>> { +fn nested_parenthesis(i: &[u8]) -> Result<(&[u8], &str), nom::Err<(&[u8], nom::error::ErrorKind)>> { let mut nested = 0; let mut last = 0; let mut in_str = false; @@ -343,45 +339,45 @@ fn nested_parenthesis(i: Input) -> Result<(Input, &str), nom::Err<Input>> { } if nested == 0 { - Ok((Input(&i[last..]), str::from_utf8(&i[..last]).unwrap())) + Ok((&i[last..], str::from_utf8(&i[..last]).unwrap())) } else { Err(nom::Err::Error(error_position!( i, - nom::ErrorKind::Custom(0) + nom::error::ErrorKind::SeparatedNonEmptyList ))) } } -named!(parameters<Input, Vec<&str>>, delimited!( +named!(parameters<&[u8], Vec<&str>>, delimited!( tag!("("), separated_list!(tag!(","), ws!(identifier)), tag!(")") )); -named!(with_parameters<Input, MatchParameters>, do_parse!( +named!(with_parameters<&[u8], MatchParameters>, do_parse!( tag!("with") >> value: alt!(match_simple_parameters | match_named_parameters) >> (value) )); -named!(match_simple_parameters<Input, MatchParameters>, delimited!( +named!(match_simple_parameters<&[u8], MatchParameters>, delimited!( ws!(tag!("(")), map!(separated_list!(tag!(","), ws!(match_parameter)), |mps| MatchParameters::Simple(mps)), tag!(")") )); -named!(match_named_parameters<Input, MatchParameters>, delimited!( +named!(match_named_parameters<&[u8], MatchParameters>, delimited!( ws!(tag!("{")), map!(separated_list!(tag!(","), ws!(match_named_parameter)), |mps| MatchParameters::Named(mps)), tag!("}") )); -named!(expr_group<Input, Expr>, map!( +named!(expr_group<&[u8], Expr>, map!( delimited!(char!('('), expr_any, char!(')')), |s| Expr::Group(Box::new(s)) )); -named!(expr_single<Input, Expr>, alt!( +named!(expr_single<&[u8], Expr>, alt!( expr_bool_lit | expr_num_lit | expr_str_lit | @@ -392,20 +388,20 @@ named!(expr_single<Input, Expr>, alt!( expr_group )); -named!(match_variant<Input, MatchVariant>, alt!( +named!(match_variant<&[u8], MatchVariant>, alt!( variant_path | variant_name | variant_num_lit | variant_str_lit )); -named!(match_parameter<Input, MatchParameter>, alt!( +named!(match_parameter<&[u8], MatchParameter>, alt!( param_name | param_num_lit | param_str_lit )); -named!(match_named_parameter<Input, (&str, Option<MatchParameter>)>, do_parse!( +named!(match_named_parameter<&[u8], (&str, Option<MatchParameter>)>, do_parse!( name: identifier >> param: opt!(do_parse!( ws!(tag!(":")) >> @@ -415,14 +411,14 @@ named!(match_named_parameter<Input, (&str, Option<MatchParameter>)>, do_parse!( ((name, param)) )); -named!(attr<Input, (&str, Option<Vec<Expr>>)>, do_parse!( +named!(attr<&[u8], (&str, Option<Vec<Expr>>)>, do_parse!( tag!(".") >> attr: alt!(num_lit | identifier) >> args: opt!(arguments) >> (attr, args) )); -named!(expr_attr<Input, Expr>, do_parse!( +named!(expr_attr<&[u8], Expr>, do_parse!( obj: expr_single >> attrs: many0!(attr) >> ({ @@ -438,7 +434,7 @@ named!(expr_attr<Input, Expr>, do_parse!( }) )); -named!(expr_index<Input, Expr>, do_parse!( +named!(expr_index<&[u8], Expr>, do_parse!( obj: expr_attr >> key: opt!(do_parse!( ws!(tag!("[")) >> @@ -452,14 +448,14 @@ named!(expr_index<Input, Expr>, do_parse!( }) )); -named!(filter<Input, (&str, Option<Vec<Expr>>)>, do_parse!( +named!(filter<&[u8], (&str, Option<Vec<Expr>>)>, do_parse!( tag!("|") >> fname: identifier >> args: opt!(arguments) >> (fname, args) )); -named!(expr_filtered<Input, Expr>, do_parse!( +named!(expr_filtered<&[u8], Expr>, do_parse!( obj: expr_index >> filters: many0!(filter) >> ({ @@ -478,16 +474,16 @@ named!(expr_filtered<Input, Expr>, do_parse!( }) )); -named!(expr_unary<Input, Expr>, do_parse!( +named!(expr_unary<&[u8], Expr>, do_parse!( op: opt!(alt!(tag!("!") | tag!("-"))) >> expr: expr_filtered >> (match op { - Some(op) => Expr::Unary(str::from_utf8(op.0).unwrap(), Box::new(expr)), + Some(op) => Expr::Unary(str::from_utf8(op).unwrap(), Box::new(expr)), None => expr, }) )); -named!(expr_rust_macro<Input, Expr>, do_parse!( +named!(expr_rust_macro<&[u8], Expr>, do_parse!( mname: identifier >> tag!("!") >> args: macro_arguments >> @@ -496,12 +492,12 @@ named!(expr_rust_macro<Input, Expr>, do_parse!( macro_rules! expr_prec_layer { ( $name:ident, $inner:ident, $( $op:expr ),* ) => { - named!($name<Input, Expr>, do_parse!( + named!($name<&[u8], Expr>, do_parse!( left: $inner >> op_and_right: opt!(pair!(ws!(alt!($( tag!($op) )|*)), expr_any)) >> (match op_and_right { Some((op, right)) => Expr::BinOp( - str::from_utf8(op.0).unwrap(), Box::new(left), Box::new(right) + str::from_utf8(op).unwrap(), Box::new(left), Box::new(right) ), None => left, }) @@ -519,14 +515,14 @@ expr_prec_layer!(expr_compare, expr_bor, "==", "!=", ">=", ">", "<=", "<"); expr_prec_layer!(expr_and, expr_compare, "&&"); expr_prec_layer!(expr_or, expr_and, "||"); -named!(range_right<Input, Expr>, do_parse!( +named!(range_right<&[u8], Expr>, do_parse!( ws!(tag!("..")) >> incl: opt!(ws!(tag!("="))) >> right: opt!(expr_or) >> (Expr::Range(if incl.is_some() { "..=" } else { ".." }, None, right.map(Box::new))) )); -named!(expr_any<Input, Expr>, alt!( +named!(expr_any<&[u8], Expr>, alt!( range_right | do_parse!( left: expr_or >> @@ -538,7 +534,7 @@ named!(expr_any<Input, Expr>, alt!( expr_or )); -named_args!(expr_node<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!( +named_args!(expr_node<'a>(s: &'a Syntax<'a>) <&'a [u8], Node<'a>>, do_parse!( call!(tag_expr_start, s) >> pws: opt!(tag!("-")) >> expr: ws!(expr_any) >> @@ -547,7 +543,7 @@ named_args!(expr_node<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!( (Node::Expr(WS(pws.is_some(), nws.is_some()), expr)) )); -named!(block_call<Input, Node>, do_parse!( +named!(block_call<&[u8], Node>, do_parse!( pws: opt!(tag!("-")) >> ws!(tag!("call")) >> scope: opt!(do_parse!( @@ -561,13 +557,13 @@ named!(block_call<Input, Node>, do_parse!( (Node::Call(WS(pws.is_some(), nws.is_some()), scope, name, args)) )); -named!(cond_if<Input, Expr>, do_parse!( +named!(cond_if<&[u8], Expr>, do_parse!( ws!(tag!("if")) >> cond: ws!(expr_any) >> (cond) )); -named_args!(cond_block<'a>(s: &'a Syntax<'a>) <Input<'a>, Cond<'a>>, do_parse!( +named_args!(cond_block<'a>(s: &'a Syntax<'a>) <&'a [u8], Cond<'a>>, do_parse!( call!(tag_block_start, s) >> pws: opt!(tag!("-")) >> ws!(tag!("else")) >> @@ -578,7 +574,7 @@ named_args!(cond_block<'a>(s: &'a Syntax<'a>) <Input<'a>, Cond<'a>>, do_parse!( (WS(pws.is_some(), nws.is_some()), cond, block) )); -named_args!(block_if<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!( +named_args!(block_if<'a>(s: &'a Syntax<'a>) <&'a [u8], Node<'a>>, do_parse!( pws1: opt!(tag!("-")) >> cond: ws!(cond_if) >> nws1: opt!(tag!("-")) >> @@ -597,7 +593,7 @@ named_args!(block_if<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!( }) )); -named_args!(match_else_block<'a>(s: &'a Syntax<'a>) <Input<'a>, When<'a>>, do_parse!( +named_args!(match_else_block<'a>(s: &'a Syntax<'a>) <&'a [u8], When<'a>>, do_parse!( call!(tag_block_start, s) >> pws: opt!(tag!("-")) >> ws!(tag!("else")) >> @@ -607,7 +603,7 @@ named_args!(match_else_block<'a>(s: &'a Syntax<'a>) <Input<'a>, When<'a>>, do_pa (WS(pws.is_some(), nws.is_some()), None, MatchParameters::Simple(vec![]), block) )); -named_args!(when_block<'a>(s: &'a Syntax<'a>) <Input<'a>, When<'a>>, do_parse!( +named_args!(when_block<'a>(s: &'a Syntax<'a>) <&'a [u8], When<'a>>, do_parse!( call!(tag_block_start, s) >> pws: opt!(tag!("-")) >> ws!(tag!("when")) >> @@ -619,7 +615,7 @@ named_args!(when_block<'a>(s: &'a Syntax<'a>) <Input<'a>, When<'a>>, do_parse!( (WS(pws.is_some(), nws.is_some()), Some(variant), params.unwrap_or_default(), block) )); -named_args!(block_match<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!( +named_args!(block_match<'a>(s: &'a Syntax<'a>)<&'a [u8], Node<'a>>, do_parse!( pws1: opt!(tag!("-")) >> ws!(tag!("match")) >> expr: ws!(expr_any) >> @@ -658,7 +654,7 @@ named_args!(block_match<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!( }) )); -named!(block_let<Input, Node>, do_parse!( +named!(block_let<&[u8], Node>, do_parse!( pws: opt!(tag!("-")) >> ws!(tag!("let")) >> var: ws!(alt!(target_single | target_tuple)) >> @@ -675,7 +671,7 @@ named!(block_let<Input, Node>, do_parse!( }) )); -named_args!(block_for<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!( +named_args!(block_for<'a>(s: &'a Syntax<'a>) <&'a [u8], Node<'a>>, do_parse!( pws1: opt!(tag!("-")) >> ws!(tag!("for")) >> var: ws!(alt!(target_single | target_tuple)) >> @@ -693,13 +689,13 @@ named_args!(block_for<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!( WS(pws2.is_some(), nws2.is_some()))) )); -named!(block_extends<Input, Node>, do_parse!( +named!(block_extends<&[u8], Node>, do_parse!( ws!(tag!("extends")) >> name: ws!(expr_str_lit) >> (Node::Extends(name)) )); -named_args!(block_block<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!( +named_args!(block_block<'a>(s: &'a Syntax<'a>) <&'a [u8], Node<'a>>, do_parse!( pws1: opt!(tag!("-")) >> ws!(tag!("block")) >> name: ws!(identifier) >> @@ -716,7 +712,7 @@ named_args!(block_block<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!( WS(pws2.is_some(), nws2.is_some()))) )); -named!(block_include<Input, Node>, do_parse!( +named!(block_include<&[u8], Node>, do_parse!( pws: opt!(tag!("-")) >> ws!(tag!("include")) >> name: ws!(expr_str_lit) >> @@ -727,7 +723,7 @@ named!(block_include<Input, Node>, do_parse!( })) )); -named!(block_import<Input, Node>, do_parse!( +named!(block_import<&[u8], Node>, do_parse!( pws: opt!(tag!("-")) >> ws!(tag!("import")) >> name: ws!(expr_str_lit) >> @@ -740,7 +736,7 @@ named!(block_import<Input, Node>, do_parse!( }, scope)) )); -named_args!(block_macro<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!( +named_args!(block_macro<'a>(s: &'a Syntax<'a>) <&'a [u8], Node<'a>>, do_parse!( pws1: opt!(tag!("-")) >> ws!(tag!("macro")) >> name: ws!(identifier) >> @@ -768,7 +764,7 @@ named_args!(block_macro<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!( }) )); -named_args!(block_raw<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!( +named_args!(block_raw<'a>(s: &'a Syntax<'a>) <&'a [u8], Node<'a>>, do_parse!( pws1: opt!(tag!("-")) >> ws!(tag!("raw")) >> nws1: opt!(tag!("-")) >> @@ -786,7 +782,7 @@ named_args!(block_raw<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!( }) )); -named_args!(block_node<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!( +named_args!(block_node<'a>(s: &'a Syntax<'a>) <&'a [u8], Node<'a>>, do_parse!( call!(tag_block_start, s) >> contents: alt!( block_call | @@ -805,7 +801,7 @@ named_args!(block_node<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!( (contents) )); -named_args!(block_comment<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!( +named_args!(block_comment<'a>(s: &'a Syntax<'a>) <&'a [u8], Node<'a>>, do_parse!( call!(tag_comment_start, s) >> pws: opt!(tag!("-")) >> inner: take_until!(s.comment_end) >> @@ -813,25 +809,25 @@ named_args!(block_comment<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse (Node::Comment(WS(pws.is_some(), inner.len() > 1 && inner[inner.len() - 1] == b'-'))) )); -named_args!(parse_template<'a>(s: &'a Syntax<'a>)<Input<'a>, Vec<Node<'a>>>, many0!(alt!( - call!(take_content, s) | - call!(block_comment, s) | - call!(expr_node, s) | - call!(block_node, s) +named_args!(parse_template<'a>(s: &'a Syntax<'a>)<&'a [u8], Vec<Node<'a>>>, many0!(alt!( + complete!(call!(take_content, s)) | + complete!(call!(block_comment, s)) | + complete!(call!(expr_node, s)) | + complete!(call!(block_node, s)) ))); -named_args!(tag_block_start<'a>(s: &'a Syntax<'a>) <Input<'a>, Input<'a>>, tag!(s.block_start)); -named_args!(tag_block_end<'a>(s: &'a Syntax<'a>) <Input<'a>, Input<'a>>, tag!(s.block_end)); -named_args!(tag_comment_start<'a>(s: &'a Syntax<'a>) <Input<'a>, Input<'a>>, tag!(s.comment_start)); -named_args!(tag_comment_end<'a>(s: &'a Syntax<'a>) <Input<'a>, Input<'a>>, tag!(s.comment_end)); -named_args!(tag_expr_start<'a>(s: &'a Syntax<'a>) <Input<'a>, Input<'a>>, tag!(s.expr_start)); -named_args!(tag_expr_end<'a>(s: &'a Syntax<'a>) <Input<'a>, Input<'a>>, tag!(s.expr_end)); +named_args!(tag_block_start<'a>(s: &'a Syntax<'a>) <&'a [u8], &'a [u8]>, tag!(s.block_start)); +named_args!(tag_block_end<'a>(s: &'a Syntax<'a>) <&'a [u8], &'a [u8]>, tag!(s.block_end)); +named_args!(tag_comment_start<'a>(s: &'a Syntax<'a>) <&'a [u8], &'a [u8]>, tag!(s.comment_start)); +named_args!(tag_comment_end<'a>(s: &'a Syntax<'a>) <&'a [u8], &'a [u8]>, tag!(s.comment_end)); +named_args!(tag_expr_start<'a>(s: &'a Syntax<'a>) <&'a [u8], &'a [u8]>, tag!(s.expr_start)); +named_args!(tag_expr_end<'a>(s: &'a Syntax<'a>) <&'a [u8], &'a [u8]>, tag!(s.expr_end)); pub fn parse<'a>(src: &'a str, syntax: &'a Syntax<'a>) -> Vec<Node<'a>> { - match parse_template(Input(src.as_bytes()), syntax) { + match parse_template(src.as_bytes(), syntax) { Ok((left, res)) => { if !left.is_empty() { - let s = str::from_utf8(left.0).unwrap(); + let s = str::from_utf8(left).unwrap(); panic!("unable to parse template:\n\n{:?}", s); } else { res |