new pso_packet implementation

psopacket/src/lib.rs

@@ -1,11 +1,374 @@
+// TODO: try less hard, just mem::transmute all this junk away
+// TODO: PSOPacketData derive
+
 #![recursion_limit="256"]
 
 extern crate proc_macro;
 
 use proc_macro::TokenStream;
-use syn::{parse_macro_input, ItemStruct};
+use syn::{parse_macro_input, ItemStruct, Meta, NestedMeta, Attribute};
 use quote::quote;
 
+
+
+#[derive(Debug)]
+enum AttrMeta {
+    Utf8,
+    Utf16,
+    NoDebug,
+}
+
+
+
+#[derive(Debug)]
+enum AttrType {
+    Value(syn::PathSegment, syn::Ident, Option<AttrMeta>),
+    Array(syn::PathSegment, syn::Ident, usize, Option<AttrMeta>),
+}
+
+fn generate_struct_def(name: syn::Ident, attrs: &Vec<AttrType>) -> proc_macro2::TokenStream {
+    let mut struct_def = Vec::new();
+    for attr in attrs {
+        let element = match attr {
+            AttrType::Value(ty, name, _) => {
+                quote!(#name: #ty)
+            },
+            AttrType::Array(ty, name, len, _) => {
+                quote!(#name: [#ty; #len])
+            }
+        };
+        struct_def.push(element);
+    }
+
+    quote! {
+        struct #name {
+            #(#struct_def),*
+        }
+    }
+}
+
+
+fn generate_psopacket_impl(pkt_cmd: u16, name: syn::Ident, attrs: &Vec<AttrType>, include_flag: bool) -> proc_macro2::TokenStream {
+    let mut from_bytes = Vec::new();
+    for attr in attrs {
+        let element = match attr {
+            AttrType::Value(ty, name, _) => {
+                let type_str = ty.ident.to_string();
+                if type_str == "Vec" {
+                    let vec_type = match &ty.arguments {
+                        syn::PathArguments::AngleBracketed(arg) => {
+                            match &arg.args[0] {
+                                syn::GenericArgument::Type(typ) => {
+                                    match &typ {
+                                        syn::Type::Path(path) => {
+                                            Some(path.path.segments[0].ident.clone())
+                                        }
+                                        _ => None
+                                    }
+                                }
+                                _ => None,
+                            }
+                        }
+                        _ => None
+                    }.unwrap();
+
+                    quote! {
+                        #name: {
+                            let mut tmp = Vec::new();
+
+                            for _ in 0..flag  {
+                                //#name: <#ty as PSOPacketData>::from_bytes(&mut cur)?,
+                                tmp.push(<#vec_type as PSOPacketData>::from_bytes(&mut cur)?);
+                            }
+                            tmp
+                        }
+                    }
+                }
+                else {
+                    quote! {
+                        #name: <#ty as PSOPacketData>::from_bytes(&mut cur)?,
+                    }
+                }
+            },
+            AttrType::Array(ty, name, len, _) => {
+                let array_init = (0..*len).map(|_k| quote! {
+                    #ty::from_bytes(&mut cur)?,
+                });
+                quote! {
+                    #name: [#(#array_init)*],
+                }
+            }
+        };
+        from_bytes.push(element);
+    }
+
+    let mut as_bytes = Vec::new();
+    for attr in attrs {
+        let element = match attr {
+            AttrType::Value(ty, name, _) => {
+                let type_str = ty.ident.to_string();
+                if type_str == "Vec" {
+                    quote! {
+                        flag = self.#name.len() as u32;
+                        for i in self.#name.iter()  {
+                            buf.extend_from_slice(&PSOPacketData::as_bytes(i));
+                        }
+                    }
+                }
+                else {
+                    quote! {
+                        buf.extend_from_slice(&PSOPacketData::as_bytes(&self.#name));
+                    }
+                }
+            },
+            AttrType::Array(_ty, name, len, _) => {
+                quote! {
+                    for i in 0..#len {
+                        buf.extend_from_slice(&self.#name[i].as_bytes());
+                    }
+                }
+            }
+        };
+        as_bytes.push(element);
+    }
+
+    quote! {
+        impl PSOPacket for #name {
+            fn from_bytes(data: &[u8]) -> Result<#name, PacketParseError> {
+                let mut cur = std::io::Cursor::new(data);
+                let mut b: [u8; 2] = [0; 2];
+                cur.read(&mut b).unwrap();
+                let len = u16::from_le_bytes(b);
+                cur.read(&mut b).unwrap();
+                let cmd = u16::from_le_bytes(b);
+                let mut f: [u8; 4] = [0; 4];
+
+                let flag = if #include_flag {
+                    cur.read(&mut f).unwrap();
+                    u32::from_le_bytes(f)
+                }
+                else { 0 };
+
+                if cmd != #pkt_cmd {
+                    return Err(PacketParseError::WrongPacketCommand);
+                }
+
+                if len as usize != data.len() {
+                    return Err(PacketParseError::WrongPacketSize(len, data.len()));
+                }
+
+                let result = Ok(#name {
+                    #(#from_bytes)*
+                });
+
+                if cur.position() as usize != data.len() {
+                    return Err(PacketParseError::DataStructNotLargeEnough(cur.position(), data.len()));
+                }
+
+                result
+            }
+
+            fn as_bytes(&self) -> Vec<u8> {
+                let mut buf = Vec::new();
+                let mut flag = 0;
+                #(#as_bytes)*
+
+                while buf.len() % 4 != 0 {
+                    buf.push(0);
+                }
+
+                let pkt_len = (buf.len() + 8) as u16;
+                let mut prebuf: Vec<u8> = Vec::new();
+
+                prebuf.extend_from_slice(&u16::to_le_bytes(pkt_len));
+                prebuf.extend_from_slice(&u16::to_le_bytes(#pkt_cmd));
+                if #include_flag {
+                    prebuf.extend_from_slice(&u32::to_le_bytes(flag));
+                }
+                prebuf.append(&mut buf);
+                prebuf
+            }
+        }
+    }
+}
+
+fn generate_debug_impl(name: syn::Ident, attrs: &Vec<AttrType>) -> proc_macro2::TokenStream {
+    let mut dbg_write = Vec::new();
+    for attr in attrs {
+        let element = match attr {
+            AttrType::Value(ty, name, _meta) => {
+                let ident_str = name.to_string();
+                let type_str = ty.ident.to_string();
+                quote! {
+                    write!(f, "    {} {}: {:?}\n", #ident_str, #type_str, self.#name)?;
+                }
+            },
+            AttrType::Array(ty, name, len, meta) => {
+                let ident_str = name.to_string();
+                let type_str = ty.ident.to_string();
+                if let Some(meta) = meta {
+                    match meta {
+                        AttrMeta::Utf8 => {
+                            quote! {
+                                match std::str::from_utf8(&self.#name) {
+                                    Ok(v) => write!(f, "    {} [utf8; {}]: {:?}\n", #ident_str, #len, v)?,
+                                    Err(_) => write!(f, "    {} [{}; {}]: {:?}\n", #ident_str, #type_str, #len, self.#name.to_vec())?,
+                                };
+                            }
+                        },
+                        AttrMeta::Utf16 => {
+                            quote! {
+                                match String::from_utf16(&self.#name) {
+                                    Ok(v) => write!(f, "    {} [utf16; {}]: {:?}\n", #ident_str, #len, v)?,
+                                    Err(_) => write!(f, "    {} [{}; {}]: {:?}\n", #ident_str, #type_str, #len, self.#name.to_vec())?,
+                                };
+                            }
+                        },
+                        _ => quote! { write!(f, "    {} [{}; {}]: {:?}\n", #ident_str, #type_str, #len, self.#name.to_vec())?; }
+                    }
+                }
+                else {
+                    quote! { write!(f, "    {} [{}; {}]: {:?}\n", #ident_str, #type_str, #len, self.#name.to_vec())?; }
+                }
+            }
+        };
+        dbg_write.push(element);
+    }
+    let name_str = name.to_string();
+    quote! {
+        impl std::fmt::Debug for #name {
+            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+                write!(f, "packet {} {{\n", #name_str)?;
+                #(#dbg_write)*
+                write!(f, "}}")
+            }
+        }
+    }
+}
+
+
+fn generate_partialeq_impl(name: syn::Ident, attrs: &Vec<AttrType>) -> proc_macro2::TokenStream {
+    let mut partialeq = Vec::new();
+    for attr in attrs {
+        let element = match attr {
+            AttrType::Value(_, name, _) => {
+                quote! {
+                    if self.#name!= other.#name {
+                        return false;
+                    }
+                }
+            },
+            AttrType::Array(_, name, _, _) => {
+                quote! {
+                    if self.#name[..] != other.#name[..] {
+                        return false;
+                    }
+                }
+
+            }
+        };
+        partialeq.push(element);
+    }
+    quote! {
+        impl std::cmp::PartialEq for #name {
+            fn eq(&self, other: &Self) -> bool {
+                #(#partialeq)*
+                true
+            }
+        }
+    }
+
+}
+
+#[proc_macro_attribute]
+pub fn pso_packet2(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let args = parse_macro_input!(attr as syn::AttributeArgs);
+    let mut cmd = 0;
+    let mut flag = true;
+    let mut debug = true;
+    let mut from_bytes = true;
+    let mut as_bytes = true;
+    for a in args {
+        match &a {
+            NestedMeta::Lit(lit) => {
+                if let syn::Lit::Int(litint) = lit {
+                    cmd = litint.base10_parse().unwrap();
+                }
+            },
+            NestedMeta::Meta(k) => {
+                if let syn::Meta::Path(syn::Path {segments, ..}) = k {
+                    match segments[0].ident.to_string().as_str() {
+                        "no_flag" => flag = false,
+                        "no_debug" => debug = false,
+                        "no_from" => from_bytes = false,
+                        "no_as" => as_bytes = false,
+                        _ => {
+                            return syn::Error::new(segments[0].ident.span(), "unknown macro param").to_compile_error().into();
+                        }
+                    }
+                }
+            },
+        }
+    }
+
+    let mut attrs = Vec::new();
+    let pkt_struct = parse_macro_input!(item as ItemStruct);
+
+    let mut must_be_last = false;
+    for field in pkt_struct.fields.iter() {
+        if must_be_last {
+            return syn::Error::new(field.ident.as_ref().unwrap().span(), "variables can not follow Vec or String").to_compile_error().into();
+        }
+        let mut attr_meta = None;
+        for attr in &field.attrs {
+            attr_meta = match attr.path.segments[0].ident.to_string().as_str() {
+                "utf8" => Some(AttrMeta::Utf8),
+                "utf16" => Some(AttrMeta::Utf16),
+                "nodebug" => Some(AttrMeta::NoDebug),
+                _ => None
+            }
+        }
+        match &field.ty {
+            syn::Type::Array(ty) => {
+                if let (syn::Type::Path(ref ty), syn::Expr::Lit(ref lit)) = (&*ty.elem, &ty.len) {
+                    if let syn::Lit::Int(ref int) = lit.lit {
+                        attrs.push(AttrType::Array(ty.path.segments[0].clone(),
+                                                   field.ident.as_ref().unwrap().clone(),
+                                                   int.base10_parse().unwrap(),
+                                                   attr_meta
+                        ))
+                    }
+                }
+            },
+            syn::Type::Path(ty) => {
+                let type_str = ty.path.segments[0].ident.to_string();
+                if type_str == "String" || type_str == "Vec"{
+                    must_be_last = true;
+                }
+                attrs.push(AttrType::Value(ty.path.segments[0].clone(),
+                                           field.ident.as_ref().unwrap().clone(),
+                                           attr_meta))
+            },
+            _ => {}
+        }
+    }
+
+    let struct_def = generate_struct_def(pkt_struct.ident.clone(), &attrs);
+    let psopacket_impl = generate_psopacket_impl(cmd, pkt_struct.ident.clone(), &attrs, flag);
+    let debug_impl =  generate_debug_impl(pkt_struct.ident.clone(), &attrs);
+    let partialeq_impl =  generate_partialeq_impl(pkt_struct.ident.clone(), &attrs);
+
+    let q = quote!{
+        #[derive(Clone)]
+        #struct_def
+        #psopacket_impl
+        #debug_impl
+        #partialeq_impl
+    };
+
+    q.into()
+}
+
 #[proc_macro_attribute]
 pub fn pso_packet(attr: TokenStream, item: TokenStream) -> TokenStream {
     let arg = parse_macro_input!(attr as syn::LitInt);