[Yunq] Create repeated field implementations in rust.

yunq/rust/src/codegen.rs

@@ -1,4 +1,5 @@
-use crate::parser::{Decl, Interface, Message, Method};
+use crate::parser::{Decl, Interface, Message, Method, Type};
+use crate::parser::{Field, FieldType};
 use convert_case::{Case, Casing};
 use proc_macro2::Ident;
 use proc_macro2::Span;
@@ -9,19 +10,237 @@ fn ident(s: &str) -> Ident {
     Ident::new(s, Span::call_site())
 }
 
+fn to_path(field_type: &FieldType) -> TokenStream {
+    let rust_type = ident(&field_type.inner_type.rust_type());
+    if field_type.repeated {
+        quote! {
+            Vec::<#rust_type>
+        }
+    } else {
+        quote! {
+            #rust_type
+        }
+    }
+}
+
+fn serialize_field(field: &Field) -> proc_macro2::TokenStream {
+    let ind = field.number as usize;
+    let name = ident(&field.name);
+    if field.field_type.repeated {
+        match &field.field_type.inner_type {
+            Type::String => unimplemented!(),
+            Type::Capability => unimplemented!(),
+            Type::U64 => quote! {
+                {
+                    let rep_offset = next_extension;
+                    let rep_len = self.#name.len() as u32;
+                    next_extension = yunq::message::serialize_repeated(buf, next_extension as usize, &self.#name)? as u32;
+
+                    buf.write_at(yunq::message::field_offset(offset, #ind), rep_offset)?;
+                    buf.write_at(yunq::message::field_offset(offset, #ind) + 4, rep_len)?;
+                }
+            },
+            Type::I64 => unimplemented!(),
+            Type::Bytes => unimplemented!(),
+            Type::Message(_) => quote! {
+                {
+                    let rep_offset = next_extension;
+                    let rep_len = self.#name.len() as u32;
+                    next_extension = yunq::message::serialize_repeated_message(buf, next_extension as usize, &self.#name, caps)? as u32;
+
+                    buf.write_at(yunq::message::field_offset(offset, #ind), rep_offset)?;
+                    buf.write_at(yunq::message::field_offset(offset, #ind) + 4, rep_len)?;
+                }
+            },
+        }
+    } else {
+        match &field.field_type.inner_type {
+            Type::String => quote! {
+                {
+                    let str_offset = next_extension;
+                    let str_length = self.#name.len() as u32;
+
+                    buf.write_str_at(offset + next_extension as usize, &self.#name)?;
+                    next_extension += str_length;
+
+                    buf.write_at(yunq::message::field_offset(offset, #ind), str_offset)?;
+                    buf.write_at(yunq::message::field_offset(offset, #ind) + 4, str_length)?;
+                }
+            },
+            Type::Capability => quote! {
+                {
+                    let cap_ind = caps.len();
+                    caps.push(self.#name);
+
+                    buf.write_at(yunq::message::field_offset(offset, #ind), cap_ind as u64)?;
+                }
+            },
+            Type::U64 => quote! {
+                {
+                    buf.write_at(yunq::message::field_offset(offset, #ind), self.#name)?;
+                }
+            },
+            Type::I64 => quote! {
+                {
+                    buf.write_at(yunq::message::field_offset(offset, #ind), self.#name)?;
+                }
+            },
+            Type::Message(_) => quote! {
+                {
+                    let msg_offset = next_extension;
+                    let msg_length = self.#name.serialize(buf, offset + next_extension as usize, caps)? as u32;
+                    next_extension += msg_length;
+
+                    buf.write_at(yunq::message::field_offset(offset, #ind), msg_offset)?;
+                    buf.write_at(yunq::message::field_offset(offset, #ind) + 4, msg_length)?;
+                }
+            },
+            Type::Bytes => unimplemented!(),
+        }
+    }
+}
+
+fn parse_field(field: &Field) -> TokenStream {
+    let ind = field.number as usize;
+    let name = ident(&field.name);
+    if field.field_type.repeated {
+        match &field.field_type.inner_type {
+            Type::String => unimplemented!(),
+            Type::Capability => unimplemented!(),
+            Type::U64 => quote! {
+                let #name = {
+                    let rep_offset = buf.at::<u32>(yunq::message::field_offset(offset, #ind))?;
+                    let rep_len = buf.at::<u32>(yunq::message::field_offset(offset, #ind) + 4)?;
+
+                    yunq::message::parse_repeated(buf, rep_offset as usize, rep_len as usize)?
+                };
+            },
+            Type::I64 => unimplemented!(),
+            Type::Bytes => unimplemented!(),
+            Type::Message(_s) => quote! {
+                let #name = {
+                    let rep_offset = buf.at::<u32>(yunq::message::field_offset(offset, #ind))?;
+                    let rep_len = buf.at::<u32>(yunq::message::field_offset(offset, #ind) + 4)?;
+
+                    yunq::message::parse_repeated_message(buf, rep_offset as usize, rep_len as usize, &caps)?
+                };
+            },
+        }
+    } else {
+        match &field.field_type.inner_type {
+            Type::String => quote! {
+                let #name = {
+                    let str_offset = buf.at::<u32>(yunq::message::field_offset(offset, #ind))?;
+                    let str_length = buf.at::<u32>(yunq::message::field_offset(offset, #ind) + 4)?;
+
+                    buf.str_at(offset + str_offset as usize, str_length as usize)?.to_string()
+                };
+            },
+            Type::Capability => quote! {
+                let #name = {
+                    let cap_ind = buf.at::<u64>(yunq::message::field_offset(offset, #ind))?;
+                    caps[cap_ind as usize]
+                };
+            },
+            Type::U64 => quote! {
+                let #name = buf.at::<u64>(yunq::message::field_offset(offset, #ind))?;
+            },
+            Type::I64 => quote! {
+                let #name = buf.at::<i64>(yunq::message::field_offset(offset, #ind))?;
+            },
+            Type::Bytes => {
+                unimplemented!();
+            }
+            Type::Message(s) => {
+                let m_type = ident(&s);
+                quote! {
+                    let #name = {
+                        let msg_offset = buf.at::<u32>(yunq::message::field_offset(offset, #ind))? as usize;
+
+                        #m_type::parse(buf, offset + msg_offset, caps)?
+                    };
+                }
+            }
+        }
+    }
+}
+
+fn generate_serialize(message: &Message) -> TokenStream {
+    let num_fields = message.fields.len();
+    let serializers = message.fields.iter().map(serialize_field);
+    quote! {
+        #[allow(unused_variables)] // caps may be unused.
+        fn serialize<const N: usize>(
+            &self,
+            buf: &mut yunq::ByteBuffer<N>,
+            offset: usize,
+            caps: &mut alloc::vec::Vec<z_cap_t>,
+        ) -> Result<usize, ZError> {
+            let num_fields = #num_fields;
+            let core_size: u32 = (yunq::message::MESSAGE_HEADER_SIZE + 8 * num_fields) as u32;
+            #[allow(unused_mut)]
+            let mut next_extension = core_size;
+
+            #(#serializers)*
+
+            buf.write_at(offset + 0, yunq::message::MESSAGE_IDENT)?;
+            buf.write_at(offset + 4, core_size)?;
+            buf.write_at(offset + 8, next_extension)?;
+            buf.write_at(offset + 12, 0 as u32)?;
+            Ok(next_extension as usize)
+        }
+    }
+}
+
+fn generate_parse(message: &Message) -> TokenStream {
+    let field_names = message.fields.iter().map(|field| ident(&field.name));
+    let parsers = message.fields.iter().map(parse_field);
+    quote! {
+        #[allow(unused_variables)] // caps may be unused.
+        fn parse<const N: usize>(
+            buf: &yunq::ByteBuffer<N>,
+            offset: usize,
+            caps: &alloc::vec::Vec<z_cap_t>,
+            ) -> Result<Self, ZError>
+        where
+            Self: Sized,
+        {
+            if buf.at::<u32>(offset + 0)? != yunq::message::MESSAGE_IDENT {
+                return Err(ZError::INVALID_ARGUMENT);
+            }
+            // TODO: Parse core size.
+            // TODO: Parse extension size.
+            // TODO: Check CRC32
+            // TODO: Parse options.
+
+            #(#parsers)*
+
+            Ok(Self {
+                #(#field_names),*
+            })
+
+        }
+    }
+}
+
 fn generate_message(message: &Message) -> TokenStream {
     let name = ident(&message.name);
     let field_names = message.fields.iter().map(|f| ident(&f.name));
-    let field_types = message
-        .fields
-        .iter()
-        .map(|f| Ident::new(f.field_type.rust_type(), Span::call_site()));
+    let field_types = message.fields.iter().map(|f| to_path(&f.field_type));
+
+    let serialize = generate_serialize(message);
+    let parse = generate_parse(message);
     quote! {
-        #[derive(YunqMessage, PartialEq, Eq)]
+        #[derive(PartialEq, Eq)]
         pub struct #name {
             #(pub #field_names: #field_types),*
         }
 
+        impl YunqMessage for #name {
+            #serialize
+
+            #parse
+        }
     }
 }
 
@@ -199,20 +418,29 @@ pub fn generate_code(ast: &Vec<Decl>) -> String {
 
     extern crate alloc;
 
-    use alloc::boxed::Box;
     use alloc::string::String;
     use alloc::string::ToString;
     use alloc::vec::Vec;
-    use core::ffi::c_void;
-    use mammoth::syscall;
-    use mammoth::thread;
-    use mammoth::cap::Capability;
     use mammoth::zion::z_cap_t;
     use mammoth::zion::ZError;
     use yunq::ByteBuffer;
     use yunq::YunqMessage;
+
+
+    // Used only by modules with an interface.
+    #[allow(unused_imports)]
+    use alloc::boxed::Box;
+    #[allow(unused_imports)]
+    use core::ffi::c_void;
+    #[allow(unused_imports)]
+    use mammoth::cap::Capability;
+    #[allow(unused_imports)]
+    use mammoth::syscall;
+    #[allow(unused_imports)]
+    use mammoth::thread;
+    #[allow(unused_imports)]
     use yunq::server::YunqServer;
-    use yunq_derive::YunqMessage;
+
     };
 
     let message_decls = ast
@@ -240,5 +468,10 @@ pub fn generate_code(ast: &Vec<Decl>) -> String {
     }
     .to_string();
 
-    prettyplease::unparse(&syn::parse_file(&output).unwrap())
+    let tokens = syn::parse_file(&output).unwrap_or_else(|e| {
+        println!("{}", output);
+        panic!("{}", e);
+    });
+
+    prettyplease::unparse(&tokens)
 }

yunq/rust/src/parser.rs

@@ -17,24 +17,33 @@ pub enum Type {
 }
 
 impl Type {
-    pub fn rust_type(&self) -> &str {
+    pub fn rust_type(&self) -> String {
         match self {
-            Type::U64 => "u64",
-            Type::I64 => "i64",
-            Type::String => "String",
-            Type::Bytes => "Vec<u8>",
-            Type::Capability => "z_cap_t",
-            Type::Message(s) => s,
+            Type::U64 => "u64".to_string(),
+            Type::I64 => "i64".to_string(),
+            Type::String => "String".to_string(),
+            Type::Bytes => "Vec<u8>".to_string(),
+            Type::Capability => "z_cap_t".to_string(),
+            Type::Message(s) => s.clone(),
         }
     }
 }
 
-impl Display for Type {
+#[derive(Clone)]
+pub struct FieldType {
+    pub repeated: bool,
+    pub inner_type: Type,
+}
+
+impl Display for FieldType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.repeated {
+            write!(f, "repeated ")?;
+        }
         write!(
             f,
             "{}",
-            match self {
+            match &self.inner_type {
                 Type::U64 => "u64",
                 Type::I64 => "i64",
                 Type::String => "string",
@@ -63,10 +72,9 @@ impl TryFrom<&String> for Type {
 
 #[derive(Clone)]
 pub struct Field {
-    pub field_type: Type,
+    pub field_type: FieldType,
     pub name: String,
     pub number: u64,
-    pub repeated: bool,
 }
 
 #[derive(Clone)]
@@ -118,12 +126,11 @@ impl Debug for Decl {
             Decl::Message(m) => {
                 writeln!(f, "Message {}", m.name)?;
                 for field in &m.fields {
-                    let typestr = if field.repeated {
-                        format!("repeated {}", field.field_type)
-                    } else {
-                        field.field_type.to_string()
-                    };
-                    writeln!(f, "\t{}: {} ({})", field.number, field.name, typestr)?;
+                    writeln!(
+                        f,
+                        "\t{}: {} ({})",
+                        field.number, field.name, field.field_type
+                    )?;
                 }
             }
             Decl::Interface(i) => {
@@ -220,10 +227,12 @@ impl<'a> Parser<'a> {
         self.consume_token_type(TokenType::Semicolon)?;
 
         Ok(Field {
-            field_type: parsed_type,
+            field_type: FieldType {
+                inner_type: parsed_type,
+                repeated,
+            },
             name: name_identifier,
             number,
-            repeated,
         })
     }
 
@@ -357,7 +366,7 @@ impl<'a> Parser<'a> {
             }
             field_names.insert(field.name.clone());
 
-            if let Type::Message(name) = &field.field_type {
+            if let Type::Message(name) = &field.field_type.inner_type {
                 if !self.type_map.contains_key(name) {
                     return Err(format!(
                         "Unknown type '{}' on field '{}' in message '{}'",