summaryrefslogtreecommitdiffstats
path: root/third_party/rust/scroll_derive/src/lib.rs
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:22:09 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:22:09 +0000
commit43a97878ce14b72f0981164f87f2e35e14151312 (patch)
tree620249daf56c0258faa40cbdcf9cfba06de2a846 /third_party/rust/scroll_derive/src/lib.rs
parentInitial commit. (diff)
downloadfirefox-43a97878ce14b72f0981164f87f2e35e14151312.tar.xz
firefox-43a97878ce14b72f0981164f87f2e35e14151312.zip
Adding upstream version 110.0.1.upstream/110.0.1upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/rust/scroll_derive/src/lib.rs')
-rw-r--r--third_party/rust/scroll_derive/src/lib.rs538
1 files changed, 538 insertions, 0 deletions
diff --git a/third_party/rust/scroll_derive/src/lib.rs b/third_party/rust/scroll_derive/src/lib.rs
new file mode 100644
index 0000000000..a2ba6692df
--- /dev/null
+++ b/third_party/rust/scroll_derive/src/lib.rs
@@ -0,0 +1,538 @@
+#![recursion_limit = "1024"]
+
+extern crate proc_macro;
+use proc_macro2;
+use quote::quote;
+
+use proc_macro::TokenStream;
+
+fn impl_field(ident: &proc_macro2::TokenStream, ty: &syn::Type) -> proc_macro2::TokenStream {
+ match *ty {
+ syn::Type::Array(ref array) => match array.len {
+ syn::Expr::Lit(syn::ExprLit {
+ lit: syn::Lit::Int(ref int),
+ ..
+ }) => {
+ let size = int.base10_parse::<usize>().unwrap();
+ quote! {
+ #ident: { let mut __tmp: #ty = [0u8.into(); #size]; src.gread_inout_with(offset, &mut __tmp, ctx)?; __tmp }
+ }
+ }
+ _ => panic!("Pread derive with bad array constexpr"),
+ },
+ syn::Type::Group(ref group) => impl_field(ident, &group.elem),
+ _ => {
+ quote! {
+ #ident: src.gread_with::<#ty>(offset, ctx)?
+ }
+ }
+ }
+}
+
+fn impl_struct(
+ name: &syn::Ident,
+ fields: &syn::punctuated::Punctuated<syn::Field, syn::Token![,]>,
+ generics: &syn::Generics,
+) -> proc_macro2::TokenStream {
+ let items: Vec<_> = fields
+ .iter()
+ .enumerate()
+ .map(|(i, f)| {
+ let ident = &f.ident.as_ref().map(|i| quote! {#i}).unwrap_or({
+ let t = proc_macro2::Literal::usize_unsuffixed(i);
+ quote! {#t}
+ });
+ let ty = &f.ty;
+ impl_field(ident, ty)
+ })
+ .collect();
+
+ let gl = &generics.lt_token;
+ let gp = &generics.params;
+ let gg = &generics.gt_token;
+ let gn = gp.iter().map(|param: &syn::GenericParam| match param {
+ syn::GenericParam::Type(ref t) => {
+ let ident = &t.ident;
+ quote! { #ident }
+ }
+ p => quote! { #p },
+ });
+ let gn = quote! { #gl #( #gn ),* #gg };
+ let gw = if !gp.is_empty() {
+ let gi = gp.iter().map(|param: &syn::GenericParam| match param {
+ syn::GenericParam::Type(ref t) => {
+ let ident = &t.ident;
+ quote! {
+ #ident : ::scroll::ctx::TryFromCtx<'a, ::scroll::Endian> + ::std::convert::From<u8> + ::std::marker::Copy,
+ ::scroll::Error : ::std::convert::From<< #ident as ::scroll::ctx::TryFromCtx<'a, ::scroll::Endian>>::Error>,
+ < #ident as ::scroll::ctx::TryFromCtx<'a, ::scroll::Endian>>::Error : ::std::convert::From<scroll::Error>
+ }
+ },
+ p => quote! { #p }
+ });
+ quote! { #( #gi ),* , }
+ } else {
+ quote! {}
+ };
+
+ quote! {
+ impl<'a, #gp > ::scroll::ctx::TryFromCtx<'a, ::scroll::Endian> for #name #gn where #gw #name #gn : 'a {
+ type Error = ::scroll::Error;
+ #[inline]
+ fn try_from_ctx(src: &'a [u8], ctx: ::scroll::Endian) -> ::scroll::export::result::Result<(Self, usize), Self::Error> {
+ use ::scroll::Pread;
+ let offset = &mut 0;
+ let data = Self { #(#items,)* };
+ Ok((data, *offset))
+ }
+ }
+ }
+}
+
+fn impl_try_from_ctx(ast: &syn::DeriveInput) -> proc_macro2::TokenStream {
+ let name = &ast.ident;
+ let generics = &ast.generics;
+ match ast.data {
+ syn::Data::Struct(ref data) => match data.fields {
+ syn::Fields::Named(ref fields) => impl_struct(name, &fields.named, generics),
+ syn::Fields::Unnamed(ref fields) => impl_struct(name, &fields.unnamed, generics),
+ _ => {
+ panic!("Pread can not be derived for unit structs")
+ }
+ },
+ _ => panic!("Pread can only be derived for structs"),
+ }
+}
+
+#[proc_macro_derive(Pread)]
+pub fn derive_pread(input: TokenStream) -> TokenStream {
+ let ast: syn::DeriveInput = syn::parse(input).unwrap();
+ let gen = impl_try_from_ctx(&ast);
+ gen.into()
+}
+
+fn impl_pwrite_field(ident: &proc_macro2::TokenStream, ty: &syn::Type) -> proc_macro2::TokenStream {
+ match ty {
+ syn::Type::Array(ref array) => match array.len {
+ syn::Expr::Lit(syn::ExprLit {
+ lit: syn::Lit::Int(ref int),
+ ..
+ }) => {
+ let size = int.base10_parse::<usize>().unwrap();
+ quote! {
+ for i in 0..#size {
+ dst.gwrite_with(&self.#ident[i], offset, ctx)?;
+ }
+ }
+ }
+ _ => panic!("Pwrite derive with bad array constexpr"),
+ },
+ syn::Type::Group(group) => impl_pwrite_field(ident, &group.elem),
+ _ => {
+ quote! {
+ dst.gwrite_with(&self.#ident, offset, ctx)?
+ }
+ }
+ }
+}
+
+fn impl_try_into_ctx(
+ name: &syn::Ident,
+ fields: &syn::punctuated::Punctuated<syn::Field, syn::Token![,]>,
+ generics: &syn::Generics,
+) -> proc_macro2::TokenStream {
+ let items: Vec<_> = fields
+ .iter()
+ .enumerate()
+ .map(|(i, f)| {
+ let ident = &f.ident.as_ref().map(|i| quote! {#i}).unwrap_or({
+ let t = proc_macro2::Literal::usize_unsuffixed(i);
+ quote! {#t}
+ });
+ let ty = &f.ty;
+ impl_pwrite_field(ident, ty)
+ })
+ .collect();
+
+ let gl = &generics.lt_token;
+ let gp = &generics.params;
+ let gg = &generics.gt_token;
+ let gn = gp.iter().map(|param: &syn::GenericParam| match param {
+ syn::GenericParam::Type(ref t) => {
+ let ident = &t.ident;
+ quote! { #ident }
+ }
+ p => quote! { #p },
+ });
+ let gn = quote! { #gl #( #gn ),* #gg };
+ let gwref = if !gp.is_empty() {
+ let gi = gp.iter().map(|param: &syn::GenericParam| match param {
+ syn::GenericParam::Type(ref t) => {
+ let ident = &t.ident;
+ quote! {
+ &'a #ident : ::scroll::ctx::TryIntoCtx<::scroll::Endian>,
+ ::scroll::Error: ::std::convert::From<<&'a #ident as ::scroll::ctx::TryIntoCtx<::scroll::Endian>>::Error>,
+ <&'a #ident as ::scroll::ctx::TryIntoCtx<::scroll::Endian>>::Error: ::std::convert::From<scroll::Error>
+ }
+ },
+ p => quote! { #p }
+ });
+ quote! { where #( #gi ),* }
+ } else {
+ quote! {}
+ };
+ let gw = if !gp.is_empty() {
+ let gi = gp.iter().map(|param: &syn::GenericParam| match param {
+ syn::GenericParam::Type(ref t) => {
+ let ident = &t.ident;
+ quote! {
+ #ident : ::scroll::ctx::TryIntoCtx<::scroll::Endian>,
+ ::scroll::Error: ::std::convert::From<<#ident as ::scroll::ctx::TryIntoCtx<::scroll::Endian>>::Error>,
+ <#ident as ::scroll::ctx::TryIntoCtx<::scroll::Endian>>::Error: ::std::convert::From<scroll::Error>
+ }
+ },
+ p => quote! { #p }
+ });
+ quote! { where Self: ::std::marker::Copy, #( #gi ),* }
+ } else {
+ quote! {}
+ };
+
+ quote! {
+ impl<'a, #gp > ::scroll::ctx::TryIntoCtx<::scroll::Endian> for &'a #name #gn #gwref {
+ type Error = ::scroll::Error;
+ #[inline]
+ fn try_into_ctx(self, dst: &mut [u8], ctx: ::scroll::Endian) -> ::scroll::export::result::Result<usize, Self::Error> {
+ use ::scroll::Pwrite;
+ let offset = &mut 0;
+ #(#items;)*;
+ Ok(*offset)
+ }
+ }
+
+ impl #gl #gp #gg ::scroll::ctx::TryIntoCtx<::scroll::Endian> for #name #gn #gw {
+ type Error = ::scroll::Error;
+ #[inline]
+ fn try_into_ctx(self, dst: &mut [u8], ctx: ::scroll::Endian) -> ::scroll::export::result::Result<usize, Self::Error> {
+ (&self).try_into_ctx(dst, ctx)
+ }
+ }
+ }
+}
+
+fn impl_pwrite(ast: &syn::DeriveInput) -> proc_macro2::TokenStream {
+ let name = &ast.ident;
+ let generics = &ast.generics;
+ match ast.data {
+ syn::Data::Struct(ref data) => match data.fields {
+ syn::Fields::Named(ref fields) => impl_try_into_ctx(name, &fields.named, generics),
+ syn::Fields::Unnamed(ref fields) => impl_try_into_ctx(name, &fields.unnamed, generics),
+ _ => {
+ panic!("Pwrite can not be derived for unit structs")
+ }
+ },
+ _ => panic!("Pwrite can only be derived for structs"),
+ }
+}
+
+#[proc_macro_derive(Pwrite)]
+pub fn derive_pwrite(input: TokenStream) -> TokenStream {
+ let ast: syn::DeriveInput = syn::parse(input).unwrap();
+ let gen = impl_pwrite(&ast);
+ gen.into()
+}
+
+fn size_with(
+ name: &syn::Ident,
+ fields: &syn::punctuated::Punctuated<syn::Field, syn::Token![,]>,
+ generics: &syn::Generics,
+) -> proc_macro2::TokenStream {
+ let items: Vec<_> = fields
+ .iter()
+ .map(|f| {
+ let ty = &f.ty;
+ match *ty {
+ syn::Type::Array(ref array) => {
+ let elem = &array.elem;
+ match array.len {
+ syn::Expr::Lit(syn::ExprLit {
+ lit: syn::Lit::Int(ref int),
+ ..
+ }) => {
+ let size = int.base10_parse::<usize>().unwrap();
+ quote! {
+ (#size * <#elem>::size_with(ctx))
+ }
+ }
+ _ => panic!("Pread derive with bad array constexpr"),
+ }
+ }
+ _ => {
+ quote! {
+ <#ty>::size_with(ctx)
+ }
+ }
+ }
+ })
+ .collect();
+
+ let gl = &generics.lt_token;
+ let gp = &generics.params;
+ let gg = &generics.gt_token;
+ let gn = gp.iter().map(|param: &syn::GenericParam| match param {
+ syn::GenericParam::Type(ref t) => {
+ let ident = &t.ident;
+ quote! { #ident }
+ }
+ p => quote! { #p },
+ });
+ let gn = quote! { #gl #( #gn ),* #gg };
+ let gw = if !gp.is_empty() {
+ let gi = gp.iter().map(|param: &syn::GenericParam| match param {
+ syn::GenericParam::Type(ref t) => {
+ let ident = &t.ident;
+ quote! {
+ #ident : ::scroll::ctx::SizeWith<::scroll::Endian>
+ }
+ }
+ p => quote! { #p },
+ });
+ quote! { where #( #gi ),* }
+ } else {
+ quote! {}
+ };
+
+ quote! {
+ impl #gl #gp #gg ::scroll::ctx::SizeWith<::scroll::Endian> for #name #gn #gw {
+ #[inline]
+ fn size_with(ctx: &::scroll::Endian) -> usize {
+ 0 #(+ #items)*
+ }
+ }
+ }
+}
+
+fn impl_size_with(ast: &syn::DeriveInput) -> proc_macro2::TokenStream {
+ let name = &ast.ident;
+ let generics = &ast.generics;
+ match ast.data {
+ syn::Data::Struct(ref data) => match data.fields {
+ syn::Fields::Named(ref fields) => size_with(name, &fields.named, generics),
+ syn::Fields::Unnamed(ref fields) => size_with(name, &fields.unnamed, generics),
+ _ => {
+ panic!("SizeWith can not be derived for unit structs")
+ }
+ },
+ _ => panic!("SizeWith can only be derived for structs"),
+ }
+}
+
+#[proc_macro_derive(SizeWith)]
+pub fn derive_sizewith(input: TokenStream) -> TokenStream {
+ let ast: syn::DeriveInput = syn::parse(input).unwrap();
+ let gen = impl_size_with(&ast);
+ gen.into()
+}
+
+fn impl_cread_struct(
+ name: &syn::Ident,
+ fields: &syn::punctuated::Punctuated<syn::Field, syn::Token![,]>,
+ generics: &syn::Generics,
+) -> proc_macro2::TokenStream {
+ let items: Vec<_> = fields.iter().enumerate().map(|(i, f)| {
+ let ident = &f.ident.as_ref().map(|i|quote!{#i}).unwrap_or({let t = proc_macro2::Literal::usize_unsuffixed(i); quote!{#t}});
+ let ty = &f.ty;
+ match *ty {
+ syn::Type::Array(ref array) => {
+ let arrty = &array.elem;
+ match array.len {
+ syn::Expr::Lit(syn::ExprLit { lit: syn::Lit::Int(ref int), ..}) => {
+ let size = int.base10_parse::<usize>().unwrap();
+ let incr = quote! { ::scroll::export::mem::size_of::<#arrty>() };
+ quote! {
+ #ident: {
+ let mut __tmp: #ty = [0u8.into(); #size];
+ for i in 0..__tmp.len() {
+ __tmp[i] = src.cread_with(*offset, ctx);
+ *offset += #incr;
+ }
+ __tmp
+ }
+ }
+ },
+ _ => panic!("IOread derive with bad array constexpr")
+ }
+ },
+ _ => {
+ let size = quote! { ::scroll::export::mem::size_of::<#ty>() };
+ quote! {
+ #ident: { let res = src.cread_with::<#ty>(*offset, ctx); *offset += #size; res }
+ }
+ }
+ }
+ }).collect();
+
+ let gl = &generics.lt_token;
+ let gp = &generics.params;
+ let gg = &generics.gt_token;
+ let gn = gp.iter().map(|param: &syn::GenericParam| match param {
+ syn::GenericParam::Type(ref t) => {
+ let ident = &t.ident;
+ quote! { #ident }
+ }
+ p => quote! { #p },
+ });
+ let gn = quote! { #gl #( #gn ),* #gg };
+ let gw = if !gp.is_empty() {
+ let gi = gp.iter().map(|param: &syn::GenericParam| match param {
+ syn::GenericParam::Type(ref t) => {
+ let ident = &t.ident;
+ quote! {
+ #ident : ::scroll::ctx::FromCtx<::scroll::Endian> + ::std::convert::From<u8> + ::std::marker::Copy
+ }
+ },
+ p => quote! { #p }
+ });
+ quote! { where #( #gi ),* , }
+ } else {
+ quote! {}
+ };
+
+ quote! {
+ impl #gl #gp #gg ::scroll::ctx::FromCtx<::scroll::Endian> for #name #gn #gw {
+ #[inline]
+ fn from_ctx(src: &[u8], ctx: ::scroll::Endian) -> Self {
+ use ::scroll::Cread;
+ let offset = &mut 0;
+ let data = Self { #(#items,)* };
+ data
+ }
+ }
+ }
+}
+
+fn impl_from_ctx(ast: &syn::DeriveInput) -> proc_macro2::TokenStream {
+ let name = &ast.ident;
+ let generics = &ast.generics;
+ match ast.data {
+ syn::Data::Struct(ref data) => match data.fields {
+ syn::Fields::Named(ref fields) => impl_cread_struct(name, &fields.named, generics),
+ syn::Fields::Unnamed(ref fields) => impl_cread_struct(name, &fields.unnamed, generics),
+ _ => {
+ panic!("IOread can not be derived for unit structs")
+ }
+ },
+ _ => panic!("IOread can only be derived for structs"),
+ }
+}
+
+#[proc_macro_derive(IOread)]
+pub fn derive_ioread(input: TokenStream) -> TokenStream {
+ let ast: syn::DeriveInput = syn::parse(input).unwrap();
+ let gen = impl_from_ctx(&ast);
+ gen.into()
+}
+
+fn impl_into_ctx(
+ name: &syn::Ident,
+ fields: &syn::punctuated::Punctuated<syn::Field, syn::Token![,]>,
+ generics: &syn::Generics,
+) -> proc_macro2::TokenStream {
+ let items: Vec<_> = fields
+ .iter()
+ .enumerate()
+ .map(|(i, f)| {
+ let ident = &f.ident.as_ref().map(|i| quote! {#i}).unwrap_or({
+ let t = proc_macro2::Literal::usize_unsuffixed(i);
+ quote! {#t}
+ });
+ let ty = &f.ty;
+ let size = quote! { ::scroll::export::mem::size_of::<#ty>() };
+ match *ty {
+ syn::Type::Array(ref array) => {
+ let arrty = &array.elem;
+ quote! {
+ let size = ::scroll::export::mem::size_of::<#arrty>();
+ for i in 0..self.#ident.len() {
+ dst.cwrite_with(self.#ident[i], *offset, ctx);
+ *offset += size;
+ }
+ }
+ }
+ _ => {
+ quote! {
+ dst.cwrite_with(self.#ident, *offset, ctx);
+ *offset += #size;
+ }
+ }
+ }
+ })
+ .collect();
+
+ let gl = &generics.lt_token;
+ let gp = &generics.params;
+ let gg = &generics.gt_token;
+ let gn = gp.iter().map(|param: &syn::GenericParam| match param {
+ syn::GenericParam::Type(ref t) => {
+ let ident = &t.ident;
+ quote! { #ident }
+ }
+ p => quote! { #p },
+ });
+ let gw = if !gp.is_empty() {
+ let gi = gp.iter().map(|param: &syn::GenericParam| match param {
+ syn::GenericParam::Type(ref t) => {
+ let ident = &t.ident;
+ quote! {
+ #ident : ::scroll::ctx::IntoCtx<::scroll::Endian> + ::std::marker::Copy
+ }
+ }
+ p => quote! { #p },
+ });
+ quote! { where #( #gi ),* }
+ } else {
+ quote! {}
+ };
+ let gn = quote! { #gl #( #gn ),* #gg };
+
+ quote! {
+ impl<'a, #gp > ::scroll::ctx::IntoCtx<::scroll::Endian> for &'a #name #gn #gw {
+ #[inline]
+ fn into_ctx(self, dst: &mut [u8], ctx: ::scroll::Endian) {
+ use ::scroll::Cwrite;
+ let offset = &mut 0;
+ #(#items;)*;
+ ()
+ }
+ }
+
+ impl #gl #gp #gg ::scroll::ctx::IntoCtx<::scroll::Endian> for #name #gn #gw {
+ #[inline]
+ fn into_ctx(self, dst: &mut [u8], ctx: ::scroll::Endian) {
+ (&self).into_ctx(dst, ctx)
+ }
+ }
+ }
+}
+
+fn impl_iowrite(ast: &syn::DeriveInput) -> proc_macro2::TokenStream {
+ let name = &ast.ident;
+ let generics = &ast.generics;
+ match ast.data {
+ syn::Data::Struct(ref data) => match data.fields {
+ syn::Fields::Named(ref fields) => impl_into_ctx(name, &fields.named, generics),
+ syn::Fields::Unnamed(ref fields) => impl_into_ctx(name, &fields.unnamed, generics),
+ _ => {
+ panic!("IOwrite can not be derived for unit structs")
+ }
+ },
+ _ => panic!("IOwrite can only be derived for structs"),
+ }
+}
+
+#[proc_macro_derive(IOwrite)]
+pub fn derive_iowrite(input: TokenStream) -> TokenStream {
+ let ast: syn::DeriveInput = syn::parse(input).unwrap();
+ let gen = impl_iowrite(&ast);
+ gen.into()
+}