use proc_macro2::{Literal, TokenStream};
use quote::quote;
use super::body::{Bind, Item, Own, Walk};
use super::cursor::{consumed_nothing, take};
use super::env::Env;
use super::patch::{Target, derived_value, fits, too_narrow};
use super::table::{Row, deferred_type, span_of_kind};
use super::text::{text_decode, text_unpad, text_write};
use crate::root::Prelude;
use crate::walk::tokens::ident;
use crate::walk::{Derived, doc_attr, kind_ty, path};
use crate::{Error, Kind, Len, Root, Segment};
pub(super) struct WithCtx {
pub(super) decode: TokenStream,
pub(super) encode: TokenStream,
}
pub(super) fn discovered_read(
kind: &Kind,
what: &str,
ctx: Option<&WithCtx>,
root: &Root,
) -> Result<TokenStream, Error> {
let Prelude { boxed, .. } = root.prelude();
match kind {
Kind::Msg { ty, boxed: b, .. } => {
let p = path(ty);
let carry = b.then(|| quote! { let __e = #boxed::new(__e); });
let stated = ctx.map_or_else(|| quote!(()), |c| c.decode.clone());
Ok(quote! {
let (__e, __used) =
<#p as #root::Message>::decode_with_nested(&__body[__at..], __depth + 1, #stated)
.map_err(|__err| __err.rebased(__at))?;
#carry
})
}
Kind::Var { ty } => {
let p = path(ty);
Ok(quote! {
let (__e, __used) = <#p as #root::VarCodec>::decode(&__body[__at..])
.map_err(|__e| match __e.rebased(__at) {
#root::ParseError::Malformed { at, .. } => {
#root::ParseError::Malformed { field: #what, at }
}
__other => __other,
})?;
})
}
Kind::Text { len: Len::Until { terminator }, codec } => {
let term = Literal::u8_unsuffixed(*terminator);
let decode = text_decode(codec, what, root);
Ok(quote! {
let (__e, __used) = {
let __rest = &__body[__at..];
let __end = __rest
.iter()
.position(|__b| *__b == #term)
.ok_or(#root::ParseError::Malformed { field: #what, at: __at })?;
let __s = &__rest[..__end];
(#decode, __end + 1)
};
})
}
Kind::Text { len: Len::Bytes(n), codec } => {
let lit = Literal::usize_unsuffixed(*n);
let bytes = take("e!(#lit), root);
let decode = text_decode(codec, what, root);
let unpad = text_unpad();
Ok(quote! {
let (__e, __used) = {
let __s = #bytes;
#unpad
(#decode, #lit)
};
})
}
Kind::Text { len, .. } => Err(Error::Refused(format!(
"text element with length {len:?} does not delimit itself. \
Use a fixed byte count or a terminator"
))),
other => Err(Error::Refused(format!("unsupported collection element {other:?}"))),
}
}
pub(super) fn value_read(
env: &Env,
owner: &str,
field: &str,
kind: &Kind,
ctx: Option<&WithCtx>,
root: &Root,
) -> Result<TokenStream, Error> {
let ident = ident(field);
match kind {
Kind::Text { len: Len::Field { by, cap, .. }, codec } => {
let decode = text_decode(codec, field, root);
let n = env.stated_n(owner, "#[count]", by, *cap)?;
let by = by.field.as_str();
Ok(quote! {
#n
let __end = __at
.checked_add(__n)
.ok_or(#root::ParseError::Malformed { field: #by, at: __at })?;
let #ident = {
let __s = __body.get(__at..__end).ok_or(#root::ParseError::Short {
need_bytes: __end,
got_bytes: __body.len(),
at: __at,
})?;
#decode
};
__at = __end;
})
}
Kind::Text { len: Len::Fill, codec } => {
let decode = text_decode(codec, field, root);
Ok(quote! {
let #ident = {
let __s = &__body[__at..];
#decode
};
__at = __body.len();
})
}
Kind::Msg { .. } | Kind::Var { .. } | Kind::Text { .. } => {
let read = discovered_read(kind, field, ctx, root)?;
let empty = matches!(kind, Kind::Var { .. }).then(|| consumed_nothing(field, root));
Ok(quote! {
#read
#empty
let #ident = __e;
__at += __used;
})
}
other => Err(Error::Refused(format!(
"`{field}`: a value segment must be self-delimiting, and {other:?} has a fixed width"
))),
}
}
fn value_write_derived(
field: &str,
kind: &Kind,
d: &Derived,
own: Own,
root: &Root,
) -> Result<TokenStream, Error> {
let Kind::Var { ty } = kind else {
return Err(Error::Refused(format!(
"`{field}`: this field's value is derived, but {kind:?} is not an integer. \
Declare an integer"
)));
};
let p = path(ty);
let n = derived_value(d, own, field, root);
let fits = fits(Target::Field("e!(#p), 0), &n, &too_narrow(field, d.what()), root);
Ok(quote! {
{
#fits
let __derived = <#p as #root::WireInt>::from_i64(#n);
#root::VarCodec::encode(&__derived, out)?;
}
})
}
pub(super) fn value_write(
field: &str,
kind: &Kind,
held: TokenStream,
by_ref: TokenStream,
ctx: Option<&WithCtx>,
root: &Root,
) -> Result<TokenStream, Error> {
match kind {
Kind::Var { .. } => Ok(quote! {
#root::VarCodec::encode(#by_ref, out)?;
}),
Kind::Msg { ty, .. } => {
let p = path(ty);
let stated = match ctx {
Some(WithCtx { encode, .. }) => quote!(#encode),
None => quote!(()),
};
Ok(quote! {
<#p as #root::Message>::encode_into_with(#by_ref, out, #stated)?;
})
}
Kind::Text { len, codec } => Ok(text_write((field, held), len, codec, root)),
other => Err(Error::Refused(format!(
"`{field}`: a value segment must be self-delimiting, and {other:?} has a fixed width"
))),
}
}
impl Walk<'_> {
pub(super) fn with_ctx(&self, kind: &Kind, own: Own) -> Result<Option<WithCtx>, Error> {
let (root, owner) = (self.root, self.owner);
let Kind::Msg { ty, with, .. } = kind else { return Ok(None) };
if with.is_empty() {
return Ok(None);
}
let p = path(ty);
let mut read = Vec::new();
let mut held = Vec::new();
for name in with {
if self.is_param(name) {
let id = ident(name);
read.push(quote!(__ctx.#id));
held.push(quote!(__ctx.#id));
continue;
}
let Some(access) = self.env.number(name) else {
return Err(Error::Refused(format!(
"{owner}: `#[with({name})]`: `{name}` is not an earlier integer field or a parameter. \
Name one of those"
)));
};
read.push(access.clone());
held.push(own.get(name));
}
let ctx = quote!(<#p as #root::Message>::Ctx::new);
Ok(Some(WithCtx { decode: quote!(#ctx(#(#read),*)), encode: quote!(#ctx(#(#held),*)) }))
}
pub(super) fn value(
&mut self,
item: &mut Item<'_>,
own: Own,
seg: &Segment,
last: bool,
) -> Result<(), Error> {
let Segment::Value { name: field, kind, doc, .. } = seg else {
unreachable!("just matched")
};
let ident = ident(field);
let ty = kind_ty(kind, self.root);
let d = doc_attr(doc);
self.public_fields.extend(quote! { #d pub #ident: #ty, });
self.binds.push(Bind { name: ident.clone(), ty, value: quote!(#ident) });
self.rows.push(Row::new(field, span_of_kind(kind)).decoded_by(deferred_type(kind)));
let ctx = self.with_ctx(kind, own)?;
self.parse_steps.extend(value_read(
&self.env,
self.owner,
field,
kind,
ctx.as_ref(),
self.root,
)?);
let write = match self.derived.iter().find(|(df, _)| df == field) {
Some((_, d)) => value_write_derived(field, kind, d, own, self.root)?,
None => value_write(
field,
kind,
own.get(field),
own.by_ref(field),
ctx.as_ref(),
self.root,
)?,
};
let write = match kind {
Kind::Text { len: Len::Field { by, .. }, .. } => match self.param_number(by) {
Some(stated) => {
let msg = format!(
"field `{field}`: the text's byte length is not what parameter `{}` \
states. Decode would read a different string",
by.field
);
quote! {
let __text_start = out.len();
#write
::core::assert!(
(out.len() - __text_start) as ::core::primitive::i64 == #stated,
#msg
);
}
}
None => write,
},
_ => write,
};
self.byte_steps.extend(write);
self.held_message(item, field, kind, last)?;
if kind.is_integer() {
self.env.bind(field, quote!(#ident));
}
Ok(())
}
}