2016-04-20 13:17:11 +02:00
|
|
|
// Copyright 2015, 2016 Ethcore (UK) Ltd.
|
|
|
|
// This file is part of Parity.
|
|
|
|
|
|
|
|
// Parity is free software: you can redistribute it and/or modify
|
|
|
|
// it under the terms of the GNU General Public License as published by
|
|
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
|
|
// (at your option) any later version.
|
|
|
|
|
|
|
|
// Parity is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
// GNU General Public License for more details.
|
|
|
|
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
|
|
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
use aster;
|
|
|
|
|
|
|
|
use syntax::ast::{
|
|
|
|
MetaItem,
|
|
|
|
Item,
|
|
|
|
ImplItemKind,
|
|
|
|
ImplItem,
|
|
|
|
MethodSig,
|
|
|
|
Arg,
|
|
|
|
PatKind,
|
|
|
|
FunctionRetTy,
|
|
|
|
Ty,
|
|
|
|
TraitRef,
|
|
|
|
Ident,
|
|
|
|
Generics,
|
|
|
|
};
|
|
|
|
|
|
|
|
use syntax::ast;
|
|
|
|
use syntax::codemap::Span;
|
|
|
|
use syntax::ext::base::{Annotatable, ExtCtxt};
|
|
|
|
use syntax::ext::build::AstBuilder;
|
|
|
|
use syntax::ptr::P;
|
|
|
|
|
|
|
|
pub struct Error;
|
|
|
|
|
|
|
|
pub fn expand_serialization_implementation(
|
|
|
|
cx: &mut ExtCtxt,
|
|
|
|
span: Span,
|
|
|
|
meta_item: &MetaItem,
|
|
|
|
annotatable: &Annotatable,
|
|
|
|
push: &mut FnMut(Annotatable)
|
|
|
|
) {
|
|
|
|
let item = match *annotatable {
|
|
|
|
Annotatable::Item(ref item) => item,
|
|
|
|
_ => {
|
|
|
|
cx.span_err(meta_item.span, "`#[derive(Binary)]` may only be applied to structs and enums");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
let builder = aster::AstBuilder::new().span(span);
|
|
|
|
|
|
|
|
let impl_item = match serialize_item(cx, &builder, &item) {
|
|
|
|
Ok(item) => item,
|
|
|
|
Err(Error) => {
|
|
|
|
// An error occured, but it should have been reported already.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
push(Annotatable::Item(impl_item))
|
|
|
|
}
|
|
|
|
|
|
|
|
fn serialize_item(
|
|
|
|
cx: &ExtCtxt,
|
|
|
|
builder: &aster::AstBuilder,
|
|
|
|
item: &Item,
|
|
|
|
) -> Result<P<ast::Item>, Error> {
|
|
|
|
let generics = match item.node {
|
|
|
|
ast::ItemKind::Struct(_, ref generics) => generics,
|
|
|
|
ast::ItemKind::Enum(_, ref generics) => generics,
|
|
|
|
_ => {
|
|
|
|
cx.span_err(
|
|
|
|
item.span,
|
2016-04-20 17:02:17 +02:00
|
|
|
"`#[derive(Binary)]` may only be applied to structs and enums");
|
2016-04-20 13:17:11 +02:00
|
|
|
return Err(Error);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
let ty = builder.ty().path()
|
2016-04-20 17:02:17 +02:00
|
|
|
.segment(item.ident).with_generics(generics.clone()).build()
|
2016-04-20 13:17:11 +02:00
|
|
|
.build();
|
|
|
|
|
2016-04-20 17:02:17 +02:00
|
|
|
let where_clause = &generics.where_clause;
|
2016-04-20 13:17:11 +02:00
|
|
|
|
|
|
|
let binary_expressions = try!(binary_expr(cx,
|
|
|
|
&builder,
|
|
|
|
&item,
|
2016-04-20 17:02:17 +02:00
|
|
|
&generics,
|
2016-04-20 13:17:11 +02:00
|
|
|
ty.clone()));
|
|
|
|
|
2016-04-20 17:02:17 +02:00
|
|
|
let (size_expr, read_expr, write_expr) =
|
|
|
|
(binary_expressions.size, binary_expressions.read, binary_expressions.write);
|
|
|
|
|
2016-04-20 13:17:11 +02:00
|
|
|
Ok(quote_item!(cx,
|
2016-04-20 17:02:17 +02:00
|
|
|
impl $generics ::ipc::BinaryConvertable for $ty $where_clause {
|
2016-04-20 13:17:11 +02:00
|
|
|
fn size(&self) -> usize {
|
|
|
|
$size_expr
|
|
|
|
}
|
|
|
|
|
2016-04-20 18:01:53 +02:00
|
|
|
fn to_bytes(&self, buffer: &mut [u8]) -> Result<(), BinaryConvertError> {
|
2016-04-20 13:17:11 +02:00
|
|
|
$write_expr
|
|
|
|
}
|
|
|
|
|
2016-04-20 18:01:53 +02:00
|
|
|
fn from_bytes(buffer: &[u8]) -> Result<Self, BinaryConvertError> {
|
|
|
|
//$read_expr
|
|
|
|
Err(::ipc::BinaryConvertError)
|
2016-04-20 13:17:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
).unwrap())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn binary_expr(
|
|
|
|
cx: &ExtCtxt,
|
|
|
|
builder: &aster::AstBuilder,
|
|
|
|
item: &Item,
|
|
|
|
impl_generics: &ast::Generics,
|
|
|
|
ty: P<ast::Ty>,
|
|
|
|
) -> Result<BinaryExpressions, Error> {
|
|
|
|
match item.node {
|
|
|
|
ast::ItemKind::Struct(ref variant_data, _) => {
|
2016-04-20 14:55:08 +02:00
|
|
|
binary_expr_item_struct(
|
2016-04-20 13:17:11 +02:00
|
|
|
cx,
|
|
|
|
builder,
|
|
|
|
impl_generics,
|
|
|
|
ty,
|
|
|
|
item.span,
|
|
|
|
variant_data,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
ast::ItemKind::Enum(ref enum_def, _) => {
|
|
|
|
binary_expr_enum(
|
|
|
|
cx,
|
|
|
|
builder,
|
|
|
|
item.ident,
|
|
|
|
impl_generics,
|
|
|
|
ty,
|
2016-04-20 17:02:17 +02:00
|
|
|
item.span,
|
2016-04-20 13:17:11 +02:00
|
|
|
enum_def,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
_ => {
|
|
|
|
cx.span_bug(item.span,
|
2016-04-20 17:02:17 +02:00
|
|
|
"expected ItemStruct or ItemEnum in #[derive(Binary)]");
|
|
|
|
Err(Error)
|
2016-04-20 13:17:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
struct BinaryExpressions {
|
2016-04-20 14:55:08 +02:00
|
|
|
pub size: P<ast::Expr>,
|
2016-04-20 17:02:17 +02:00
|
|
|
pub write: P<ast::Expr>,
|
2016-04-20 14:55:08 +02:00
|
|
|
pub read: P<ast::Expr>,
|
2016-04-20 13:17:11 +02:00
|
|
|
}
|
|
|
|
|
2016-04-20 14:55:08 +02:00
|
|
|
fn binary_expr_struct(
|
2016-04-20 13:17:11 +02:00
|
|
|
cx: &ExtCtxt,
|
|
|
|
builder: &aster::AstBuilder,
|
|
|
|
ty: P<ast::Ty>,
|
2016-04-20 14:55:08 +02:00
|
|
|
fields: &[ast::StructField],
|
2016-04-20 17:02:17 +02:00
|
|
|
value_ident: Option<ast::Ident>,
|
2016-04-20 14:55:08 +02:00
|
|
|
) -> Result<BinaryExpressions, Error> {
|
2016-04-20 17:02:17 +02:00
|
|
|
let size_exprs: Vec<P<ast::Expr>> = fields.iter().enumerate().map(|(index, field)| {
|
2016-04-20 18:01:53 +02:00
|
|
|
let index_ident = builder.id(format!("__field{}", index));
|
2016-04-20 17:02:17 +02:00
|
|
|
value_ident.and_then(|x| Some(quote_expr!(cx, $x . $index_ident .size())))
|
|
|
|
.unwrap_or_else(|| quote_expr!(cx, $index_ident .size()))
|
|
|
|
}).collect();
|
2016-04-20 14:55:08 +02:00
|
|
|
|
|
|
|
let mut total_size_expr = size_exprs[0].clone();
|
2016-04-20 17:02:17 +02:00
|
|
|
for index in 1..size_exprs.len() {
|
|
|
|
let next_expr = size_exprs[index].clone();
|
2016-04-20 14:55:08 +02:00
|
|
|
total_size_expr = quote_expr!(cx, $total_size_expr + $next_expr);
|
|
|
|
}
|
|
|
|
|
2016-04-20 17:02:17 +02:00
|
|
|
let mut write_stmts = Vec::<ast::Stmt>::new();
|
|
|
|
write_stmts.push(quote_stmt!(cx, let mut offset = 0usize;).unwrap());
|
|
|
|
for (index, field) in fields.iter().enumerate() {
|
|
|
|
let size_expr = &size_exprs[index];
|
|
|
|
write_stmts.push(quote_stmt!(cx, let next_line = offset + $size_expr; ).unwrap());
|
|
|
|
match value_ident {
|
|
|
|
Some(x) => {
|
2016-04-20 18:01:53 +02:00
|
|
|
let index_ident = builder.id(format!("{}", index));
|
2016-04-20 17:02:17 +02:00
|
|
|
write_stmts.push(
|
2016-04-20 18:01:53 +02:00
|
|
|
quote_stmt!(cx, $x . $index_ident .to_bytes(&mut buffer[offset..next_line]);).unwrap())
|
2016-04-20 17:02:17 +02:00
|
|
|
},
|
|
|
|
None => {
|
2016-04-20 18:01:53 +02:00
|
|
|
let index_ident = builder.id(format!("__field{}", index));
|
2016-04-20 17:02:17 +02:00
|
|
|
write_stmts.push(
|
2016-04-20 18:01:53 +02:00
|
|
|
quote_stmt!(cx, $index_ident .to_bytes(&mut buffer[offset..next_line]);).unwrap())
|
2016-04-20 17:02:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
write_stmts.push(quote_stmt!(cx, offset = next_line; ).unwrap());
|
|
|
|
};
|
2016-04-20 14:55:08 +02:00
|
|
|
|
2016-04-20 13:17:11 +02:00
|
|
|
Ok(BinaryExpressions {
|
2016-04-20 14:55:08 +02:00
|
|
|
size: total_size_expr,
|
2016-04-20 18:01:53 +02:00
|
|
|
write: quote_expr!(cx, { $write_stmts; Ok(()) } ),
|
|
|
|
read: quote_expr!(cx, Err(::ipc::BinaryConvertError)),
|
2016-04-20 17:02:17 +02:00
|
|
|
})
|
2016-04-20 13:17:11 +02:00
|
|
|
}
|
|
|
|
|
2016-04-20 14:55:08 +02:00
|
|
|
fn binary_expr_item_struct(
|
2016-04-20 13:17:11 +02:00
|
|
|
cx: &ExtCtxt,
|
|
|
|
builder: &aster::AstBuilder,
|
|
|
|
impl_generics: &ast::Generics,
|
|
|
|
ty: P<ast::Ty>,
|
|
|
|
span: Span,
|
|
|
|
variant_data: &ast::VariantData,
|
|
|
|
) -> Result<BinaryExpressions, Error> {
|
|
|
|
match *variant_data {
|
|
|
|
ast::VariantData::Tuple(ref fields, _) => {
|
2016-04-20 14:55:08 +02:00
|
|
|
binary_expr_struct(
|
2016-04-20 13:17:11 +02:00
|
|
|
cx,
|
|
|
|
&builder,
|
|
|
|
ty,
|
|
|
|
fields,
|
2016-04-20 17:02:17 +02:00
|
|
|
Some(builder.id("self")),
|
2016-04-20 13:17:11 +02:00
|
|
|
)
|
|
|
|
}
|
|
|
|
ast::VariantData::Struct(ref fields, _) => {
|
2016-04-20 14:55:08 +02:00
|
|
|
binary_expr_struct(
|
2016-04-20 13:17:11 +02:00
|
|
|
cx,
|
|
|
|
&builder,
|
|
|
|
ty,
|
|
|
|
fields,
|
2016-04-20 17:02:17 +02:00
|
|
|
Some(builder.id("self")),
|
2016-04-20 13:17:11 +02:00
|
|
|
)
|
2016-04-20 17:02:17 +02:00
|
|
|
},
|
|
|
|
_ => {
|
2016-04-20 18:01:53 +02:00
|
|
|
cx.span_bug(span,
|
|
|
|
&format!("#[derive(Binary)] Unsupported struct content, expected tuple/struct, found: {:?}",
|
|
|
|
variant_data));
|
2016-04-20 17:02:17 +02:00
|
|
|
Err(Error)
|
|
|
|
},
|
2016-04-20 13:17:11 +02:00
|
|
|
}
|
|
|
|
}
|
2016-04-20 14:55:08 +02:00
|
|
|
|
|
|
|
fn binary_expr_enum(
|
|
|
|
cx: &ExtCtxt,
|
|
|
|
builder: &aster::AstBuilder,
|
|
|
|
type_ident: Ident,
|
|
|
|
impl_generics: &ast::Generics,
|
|
|
|
ty: P<ast::Ty>,
|
2016-04-20 17:02:17 +02:00
|
|
|
span: Span,
|
2016-04-20 14:55:08 +02:00
|
|
|
enum_def: &ast::EnumDef,
|
|
|
|
) -> Result<BinaryExpressions, Error> {
|
|
|
|
let arms: Vec<_> = try!(
|
|
|
|
enum_def.variants.iter()
|
|
|
|
.enumerate()
|
|
|
|
.map(|(variant_index, variant)| {
|
|
|
|
binary_expr_variant(
|
|
|
|
cx,
|
|
|
|
builder,
|
|
|
|
type_ident,
|
|
|
|
impl_generics,
|
|
|
|
ty.clone(),
|
2016-04-20 17:02:17 +02:00
|
|
|
span,
|
2016-04-20 14:55:08 +02:00
|
|
|
variant,
|
|
|
|
variant_index,
|
|
|
|
)
|
|
|
|
})
|
|
|
|
.collect()
|
|
|
|
);
|
|
|
|
|
|
|
|
let (size_arms, write_arms, read_arms) = (
|
2016-04-20 17:02:17 +02:00
|
|
|
arms.iter().map(|x| x.size.clone()).collect::<Vec<ast::Arm>>(),
|
|
|
|
arms.iter().map(|x| x.write.clone()).collect::<Vec<ast::Arm>>(),
|
|
|
|
arms.iter().map(|x| x.read.clone()).collect::<Vec<ast::Arm>>());
|
2016-04-20 14:55:08 +02:00
|
|
|
|
|
|
|
Ok(BinaryExpressions {
|
2016-04-20 18:01:53 +02:00
|
|
|
size: quote_expr!(cx, 1usize + match *self { $size_arms }),
|
2016-04-20 17:02:17 +02:00
|
|
|
write: quote_expr!(cx, match *self { $write_arms }; ),
|
2016-04-20 14:55:08 +02:00
|
|
|
read: quote_expr!(cx, match *self { $read_arms }),
|
2016-04-20 17:02:17 +02:00
|
|
|
})
|
2016-04-20 14:55:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
struct BinaryArm {
|
2016-04-20 17:02:17 +02:00
|
|
|
size: ast::Arm,
|
|
|
|
write: ast::Arm,
|
|
|
|
read: ast::Arm,
|
2016-04-20 14:55:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
fn binary_expr_variant(
|
|
|
|
cx: &ExtCtxt,
|
|
|
|
builder: &aster::AstBuilder,
|
|
|
|
type_ident: Ident,
|
|
|
|
generics: &ast::Generics,
|
|
|
|
ty: P<ast::Ty>,
|
2016-04-20 17:02:17 +02:00
|
|
|
span: Span,
|
2016-04-20 14:55:08 +02:00
|
|
|
variant: &ast::Variant,
|
|
|
|
variant_index: usize,
|
|
|
|
) -> Result<BinaryArm, Error> {
|
2016-04-20 17:02:17 +02:00
|
|
|
let type_name = ::syntax::print::pprust::ty_to_string(&ty);
|
2016-04-20 14:55:08 +02:00
|
|
|
|
|
|
|
let variant_ident = variant.node.name;
|
|
|
|
|
|
|
|
match variant.node.data {
|
2016-04-20 18:01:53 +02:00
|
|
|
ast::VariantData::Unit(_) => {
|
|
|
|
let pat = builder.pat().path()
|
|
|
|
.id(type_ident).id(variant_ident)
|
|
|
|
.build();
|
|
|
|
|
|
|
|
Ok(BinaryArm {
|
|
|
|
size: quote_arm!(cx, $pat => { 0usize } ),
|
|
|
|
write: quote_arm!(cx, $pat => { Ok(()) } ),
|
|
|
|
read: quote_arm!(cx, $pat => { } ),
|
|
|
|
})
|
|
|
|
},
|
2016-04-20 14:55:08 +02:00
|
|
|
ast::VariantData::Tuple(ref fields, _) => {
|
|
|
|
let field_names: Vec<ast::Ident> = (0 .. fields.len())
|
|
|
|
.map(|i| builder.id(format!("__field{}", i)))
|
|
|
|
.collect();
|
|
|
|
|
|
|
|
let pat = builder.pat().enum_()
|
|
|
|
.id(type_ident).id(variant_ident).build()
|
|
|
|
.with_pats(
|
|
|
|
field_names.iter()
|
|
|
|
.map(|field| builder.pat().ref_id(field))
|
|
|
|
)
|
|
|
|
.build();
|
|
|
|
|
|
|
|
let binary_expr = try!(binary_expr_struct(
|
|
|
|
cx,
|
|
|
|
&builder,
|
|
|
|
ty,
|
|
|
|
fields,
|
|
|
|
None,
|
|
|
|
));
|
|
|
|
|
2016-04-20 17:02:17 +02:00
|
|
|
let (size_expr, write_expr, read_expr) = (binary_expr.size, vec![binary_expr.write], binary_expr.read);
|
2016-04-20 14:55:08 +02:00
|
|
|
|
2016-04-20 18:01:53 +02:00
|
|
|
let variant_index_ident = builder.id(format!("{}", variant_index));
|
2016-04-20 14:55:08 +02:00
|
|
|
Ok(BinaryArm {
|
2016-04-20 17:02:17 +02:00
|
|
|
size: quote_arm!(cx, $pat => { $size_expr } ),
|
2016-04-20 18:01:53 +02:00
|
|
|
write: quote_arm!(cx, $pat => { buffer[0] = $variant_index_ident; let buffer = &mut buffer[1..]; $write_expr } ),
|
2016-04-20 17:02:17 +02:00
|
|
|
read: quote_arm!(cx, $pat => { $read_expr } ),
|
2016-04-20 14:55:08 +02:00
|
|
|
})
|
|
|
|
}
|
|
|
|
ast::VariantData::Struct(ref fields, _) => {
|
|
|
|
let field_names: Vec<_> = (0 .. fields.len())
|
|
|
|
.map(|i| builder.id(format!("__field{}", i)))
|
|
|
|
.collect();
|
|
|
|
|
|
|
|
let pat = builder.pat().struct_()
|
|
|
|
.id(type_ident).id(variant_ident).build()
|
|
|
|
.with_pats(
|
|
|
|
field_names.iter()
|
|
|
|
.zip(fields.iter())
|
2016-04-20 17:02:17 +02:00
|
|
|
.map(|(id, field)|(field.ident.unwrap(), builder.pat().ref_id(id))))
|
2016-04-20 14:55:08 +02:00
|
|
|
.build();
|
|
|
|
|
|
|
|
|
|
|
|
let binary_expr = try!(binary_expr_struct(
|
|
|
|
cx,
|
|
|
|
&builder,
|
|
|
|
ty,
|
|
|
|
fields,
|
|
|
|
None,
|
|
|
|
));
|
|
|
|
|
2016-04-20 17:02:17 +02:00
|
|
|
let (size_expr, write_expr, read_expr) = (binary_expr.size, vec![binary_expr.write], binary_expr.read);
|
2016-04-20 14:55:08 +02:00
|
|
|
Ok(BinaryArm {
|
2016-04-20 17:02:17 +02:00
|
|
|
size: quote_arm!(cx, $pat => { $size_expr } ),
|
|
|
|
write: quote_arm!(cx, $pat => { $write_expr } ),
|
|
|
|
read: quote_arm!(cx, $pat => { $read_expr } ),
|
2016-04-20 14:55:08 +02:00
|
|
|
})
|
2016-04-20 17:02:17 +02:00
|
|
|
},
|
2016-04-20 18:01:53 +02:00
|
|
|
// _ => {
|
|
|
|
// cx.span_bug(span,
|
|
|
|
// &format!("#[derive(Binary)] Unsupported enum variant content, expected tuple/struct, found: {:?}",
|
|
|
|
// variant));
|
|
|
|
// Err(Error)
|
|
|
|
// },
|
2016-04-20 14:55:08 +02:00
|
|
|
}
|
|
|
|
}
|