591 lines
20 KiB
Rust
591 lines
20 KiB
Rust
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;
|
|
use proc_macro2::TokenStream;
|
|
use quote::quote;
|
|
|
|
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, offset + 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, offset + 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, offset + 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, offset + 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 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, yunq::message::MESSAGE_IDENT)?;
|
|
buf.write_at(offset + 4, core_size)?;
|
|
buf.write_at(offset + 8, next_extension)?;
|
|
buf.write_at(offset + 12, 0_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: &[z_cap_t],
|
|
) -> Result<Self, ZError>
|
|
where
|
|
Self: Sized,
|
|
{
|
|
if buf.at::<u32>(offset)? != yunq::message::MESSAGE_IDENT {
|
|
mammoth::debug!("Expected IDENT at offest {:#x}, got {:#x}", offset, buf.at::<u32>(offset)?);
|
|
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| to_path(&f.field_type));
|
|
|
|
let serialize = generate_serialize(message);
|
|
let parse = generate_parse(message);
|
|
quote! {
|
|
#[derive(PartialEq, Eq, Clone, Debug)]
|
|
pub struct #name {
|
|
#(pub #field_names: #field_types),*
|
|
}
|
|
|
|
impl YunqMessage for #name {
|
|
#serialize
|
|
|
|
#parse
|
|
}
|
|
}
|
|
}
|
|
|
|
fn generate_method(method: &Method) -> TokenStream {
|
|
let id = proc_macro2::Literal::u64_suffixed(method.number);
|
|
let name = ident(&method.name.to_case(Case::Snake));
|
|
let maybe_req = method.request.clone().map(|r| ident(&r));
|
|
let maybe_resp = method.response.clone().map(|r| ident(&r));
|
|
match (maybe_req, maybe_resp) {
|
|
(Some(req), Some(resp)) => quote! {
|
|
pub fn #name (&mut self, req: & #req) -> Result<#resp, ZError> {
|
|
yunq::client::call_endpoint(#id, req, &mut self.byte_buffer, &self.endpoint_cap)
|
|
}
|
|
},
|
|
(Some(req), None) => quote! {
|
|
pub fn #name (&mut self, req: & #req) -> Result<yunq::message::Empty, ZError> {
|
|
yunq::client::call_endpoint(#id, req, &mut self.byte_buffer, &self.endpoint_cap)
|
|
}
|
|
},
|
|
(None, Some(resp)) => quote! {
|
|
pub fn #name (&mut self) -> Result<#resp, ZError> {
|
|
yunq::client::call_endpoint(#id, &yunq::message::Empty{}, &mut self.byte_buffer, &self.endpoint_cap)
|
|
}
|
|
},
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn generate_client(interface: &Interface) -> TokenStream {
|
|
let client_name = interface.name.clone() + "Client";
|
|
let name = ident(&client_name);
|
|
let methods = interface.methods.iter().map(generate_method);
|
|
quote! {
|
|
pub struct #name {
|
|
endpoint_cap: Capability,
|
|
byte_buffer: ByteBuffer<0x1000>,
|
|
}
|
|
|
|
impl #name {
|
|
pub fn new(endpoint_cap: Capability) -> Self {
|
|
Self {
|
|
endpoint_cap,
|
|
byte_buffer: ByteBuffer::new(),
|
|
}
|
|
}
|
|
#(#methods)*
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
fn generate_server_case(method: &Method) -> TokenStream {
|
|
let id = proc_macro2::Literal::u64_suffixed(method.number);
|
|
let name = ident(&method.name.to_case(Case::Snake));
|
|
let maybe_req = method.request.clone().map(|r| ident(&r));
|
|
let maybe_resp = method.response.clone().map(|r| ident(&r));
|
|
match (maybe_req, maybe_resp) {
|
|
(Some(req), Some(_)) => quote! {
|
|
#id => {
|
|
let req = #req::parse_from_request(byte_buffer, cap_buffer)?;
|
|
let resp = self.handler.#name(req)?;
|
|
cap_buffer.clear();
|
|
let resp_len = resp.serialize_as_request(0, byte_buffer, cap_buffer)?;
|
|
Ok(resp_len)
|
|
},
|
|
},
|
|
(Some(req), None) => quote! {
|
|
#id => {
|
|
let req = #req::parse_from_request(byte_buffer, cap_buffer)?;
|
|
self.handler.#name(req)?;
|
|
cap_buffer.clear();
|
|
// TODO: Implement serialization for EmptyMessage so this is less hacky.
|
|
yunq::message::serialize_error(byte_buffer, ZError::from(0));
|
|
Ok(0x10)
|
|
},
|
|
},
|
|
(None, Some(_)) => quote! {
|
|
#id => {
|
|
let resp = self.handler.#name()?;
|
|
cap_buffer.clear();
|
|
let resp_len = resp.serialize_as_request(0, byte_buffer, cap_buffer)?;
|
|
Ok(resp_len)
|
|
},
|
|
},
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn generate_server_method(method: &Method) -> TokenStream {
|
|
let name = ident(&method.name.to_case(Case::Snake));
|
|
let maybe_req = method.request.clone().map(|r| ident(&r));
|
|
let maybe_resp = method.response.clone().map(|r| ident(&r));
|
|
match (maybe_req, maybe_resp) {
|
|
(Some(req), Some(resp)) => quote! {
|
|
fn #name (&mut self, req: #req) -> Result<#resp, ZError>;
|
|
},
|
|
(Some(req), None) => quote! {
|
|
fn #name (&mut self, req: #req) -> Result<(), ZError>;
|
|
},
|
|
(None, Some(resp)) => quote! {
|
|
fn #name (&mut self) -> Result<#resp, ZError>;
|
|
},
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn generate_server(interface: &Interface) -> TokenStream {
|
|
let server_name = ident(&(interface.name.clone() + "Server"));
|
|
let server_trait = ident(&(interface.name.clone() + "ServerHandler"));
|
|
let server_trait_methods = interface.methods.iter().map(generate_server_method);
|
|
let server_match_cases = interface.methods.iter().map(generate_server_case);
|
|
quote! {
|
|
pub trait #server_trait {
|
|
#(#server_trait_methods)*
|
|
}
|
|
|
|
pub struct #server_name<T: #server_trait> {
|
|
endpoint_cap: Capability,
|
|
handler: T
|
|
}
|
|
|
|
impl<T: #server_trait> #server_name<T> {
|
|
pub fn new(handler: T) -> Result<Self, ZError> {
|
|
Ok(Self {
|
|
endpoint_cap: syscall::endpoint_create()?,
|
|
handler,
|
|
})
|
|
}
|
|
}
|
|
|
|
impl<T: #server_trait> yunq::server::YunqServer for #server_name<T> {
|
|
fn endpoint_cap(&self) -> &Capability {
|
|
&self.endpoint_cap
|
|
}
|
|
|
|
fn handle_request(
|
|
&mut self,
|
|
method_number: u64,
|
|
byte_buffer: &mut ByteBuffer<1024>,
|
|
cap_buffer: &mut Vec<z_cap_t>,
|
|
) -> Result<usize, ZError> {
|
|
match method_number {
|
|
#(#server_match_cases)*
|
|
|
|
_ => Err(ZError::UNIMPLEMENTED)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn generate_async_server_case(method: &Method) -> TokenStream {
|
|
let id = proc_macro2::Literal::u64_suffixed(method.number);
|
|
let name = ident(&method.name.to_case(Case::Snake));
|
|
let maybe_req = method.request.clone().map(|r| ident(&r));
|
|
let maybe_resp = method.response.clone().map(|r| ident(&r));
|
|
match (maybe_req, maybe_resp) {
|
|
(Some(req), Some(_)) => quote! {
|
|
#id => {
|
|
let req = #req::parse_from_request(byte_buffer, cap_buffer)?;
|
|
let resp = self.handler.#name(req).await?;
|
|
cap_buffer.clear();
|
|
let resp_len = resp.serialize_as_request(0, byte_buffer, cap_buffer)?;
|
|
Ok(resp_len)
|
|
},
|
|
},
|
|
(Some(req), None) => quote! {
|
|
#id => {
|
|
let req = #req::parse_from_request(byte_buffer, cap_buffer)?;
|
|
self.handler.#name(req).await?;
|
|
cap_buffer.clear();
|
|
// TODO: Implement serialization for EmptyMessage so this is less hacky.
|
|
yunq::message::serialize_error(byte_buffer, ZError::from(0));
|
|
Ok(0x10)
|
|
},
|
|
},
|
|
(None, Some(_)) => quote! {
|
|
#id => {
|
|
let resp = self.handler.#name().await?;
|
|
cap_buffer.clear();
|
|
let resp_len = resp.serialize_as_request(0, byte_buffer, cap_buffer)?;
|
|
Ok(resp_len)
|
|
},
|
|
},
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn generate_async_server_method(method: &Method) -> TokenStream {
|
|
let name = ident(&method.name.to_case(Case::Snake));
|
|
let maybe_req = method.request.clone().map(|r| ident(&r));
|
|
let maybe_resp = method.response.clone().map(|r| ident(&r));
|
|
match (maybe_req, maybe_resp) {
|
|
(Some(req), Some(resp)) => quote! {
|
|
fn #name (&self, req: #req) -> impl Future<Output= Result<#resp, ZError>> + Sync + Send;
|
|
},
|
|
(Some(req), None) => quote! {
|
|
fn #name (&self, req: #req) -> impl Future<Output = Result<(), ZError>> + Sync + Send;
|
|
},
|
|
(None, Some(resp)) => quote! {
|
|
fn #name (&self) -> impl Future<Output = Result<#resp, ZError>> + Sync + Send;
|
|
},
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn generate_async_server(interface: &Interface) -> TokenStream {
|
|
let server_name = ident(&(String::from("Async") + &interface.name.clone() + "Server"));
|
|
let server_trait = ident(&(String::from("Async") + &interface.name.clone() + "ServerHandler"));
|
|
let server_trait_methods = interface.methods.iter().map(generate_async_server_method);
|
|
let server_match_cases = interface.methods.iter().map(generate_async_server_case);
|
|
quote! {
|
|
pub trait #server_trait {
|
|
#(#server_trait_methods)*
|
|
}
|
|
|
|
pub struct #server_name<T: #server_trait> {
|
|
endpoint_cap: Capability,
|
|
handler: T
|
|
}
|
|
|
|
impl<T: #server_trait> #server_name<T> {
|
|
pub fn new(handler: T) -> Result<Self, ZError> {
|
|
Ok(Self {
|
|
endpoint_cap: syscall::endpoint_create()?,
|
|
handler,
|
|
})
|
|
}
|
|
}
|
|
|
|
impl<T: #server_trait + Send + Sync + 'static> yunq::server::AsyncYunqServer for #server_name<T> {
|
|
fn endpoint_cap(&self) -> &Capability {
|
|
&self.endpoint_cap
|
|
}
|
|
|
|
async fn handle_request(
|
|
&self,
|
|
method_number: u64,
|
|
byte_buffer: &mut ByteBuffer<1024>,
|
|
cap_buffer: &mut Vec<z_cap_t>,
|
|
) -> Result<usize, ZError> {
|
|
match method_number {
|
|
#(#server_match_cases)*
|
|
|
|
_ => Err(ZError::UNIMPLEMENTED)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn generate_interface(interface: &Interface) -> TokenStream {
|
|
let client = generate_client(interface);
|
|
let server = generate_server(interface);
|
|
let async_server = generate_async_server(interface);
|
|
quote! {
|
|
#client
|
|
|
|
#server
|
|
|
|
#async_server
|
|
}
|
|
}
|
|
|
|
fn any_strings(ast: &[Decl]) -> bool {
|
|
ast.iter()
|
|
.filter_map(|decl| match decl {
|
|
Decl::Message(m) => Some(m),
|
|
_ => None,
|
|
})
|
|
.flat_map(|message| message.fields.iter())
|
|
.any(|field| field.field_type.inner_type == Type::String)
|
|
}
|
|
|
|
fn any_interfaces(ast: &[Decl]) -> bool {
|
|
ast.iter().any(|decl| matches!(decl, Decl::Interface(_)))
|
|
}
|
|
|
|
pub fn generate_code(ast: &[Decl]) -> String {
|
|
let str_imports = if any_strings(ast) {
|
|
quote! {
|
|
use alloc::string::String;
|
|
use alloc::string::ToString;
|
|
}
|
|
} else {
|
|
quote! {}
|
|
};
|
|
|
|
let interface_imports = if any_interfaces(ast) {
|
|
quote! {
|
|
use core::future::Future;
|
|
use mammoth::cap::Capability;
|
|
use mammoth::syscall;
|
|
}
|
|
} else {
|
|
quote! {}
|
|
};
|
|
|
|
let prelude = quote! {
|
|
|
|
extern crate alloc;
|
|
|
|
use alloc::vec::Vec;
|
|
use mammoth::zion::z_cap_t;
|
|
use mammoth::zion::ZError;
|
|
#[allow(unused_imports)]
|
|
use yunq::ByteBuffer;
|
|
use yunq::YunqMessage;
|
|
|
|
#str_imports
|
|
|
|
#interface_imports
|
|
|
|
};
|
|
|
|
let message_decls = ast
|
|
.iter()
|
|
.filter_map(|decl| match decl {
|
|
Decl::Message(m) => Some(m),
|
|
_ => None,
|
|
})
|
|
.map(generate_message);
|
|
|
|
let interface_decls = ast
|
|
.iter()
|
|
.filter_map(|decl| match decl {
|
|
Decl::Interface(i) => Some(i),
|
|
_ => None,
|
|
})
|
|
.map(generate_interface);
|
|
|
|
let output = quote! {
|
|
#prelude
|
|
|
|
#(#message_decls)*
|
|
|
|
#(#interface_decls)*
|
|
}
|
|
.to_string();
|
|
|
|
let tokens = syn::parse_file(&output).unwrap_or_else(|e| {
|
|
println!("{}", output);
|
|
panic!("{}", e);
|
|
});
|
|
|
|
prettyplease::unparse(&tokens)
|
|
}
|