Remove bloat from VaArg, VaList and VaArgGet

Author: lucic71

libcc2rs/src/va_args.rs

@@ -13,54 +13,38 @@ pub enum VaArg {
     Ptr(AnyPtr),
 }
 
-macro_rules! impl_from {
-    ($ty:ty, $variant:ident) => {
+macro_rules! impl_va_arg_from {
+    (direct: $($ty:ty => $variant:ident),*) => {$(
         impl From<$ty> for VaArg {
-            fn from(v: $ty) -> Self {
-                VaArg::$variant(v)
-            }
+            fn from(v: $ty) -> Self { VaArg::$variant(v) }
         }
-    };
-    ($ty:ty => $variant:ident as $cast:ty) => {
+    )*};
+    (promote: $($ty:ty => $variant:ident as $cast:ty),*) => {$(
         impl From<$ty> for VaArg {
-            fn from(v: $ty) -> Self {
-                VaArg::$variant(v as $cast)
-            }
+            fn from(v: $ty) -> Self { VaArg::$variant(v as $cast) }
+        }
+    )*};
+    (ptr: $($ty:ty),*) => {$(
+        impl From<*mut $ty> for VaArg {
+            fn from(v: *mut $ty) -> Self { VaArg::RawPtr(v as *mut c_void) }
         }
-    };
+        impl From<*const $ty> for VaArg {
+            fn from(v: *const $ty) -> Self { VaArg::RawPtr(v as *mut c_void) }
+        }
+    )*};
 }
 
-impl_from!(i32, Int);
-impl_from!(u32, UInt);
-impl_from!(i64, Long);
-impl_from!(u64, ULong);
-impl_from!(f64, Double);
-
-// C promotion: char/short -> int, float -> double
-impl_from!(i8 => Int as i32);
-impl_from!(i16 => Int as i32);
-impl_from!(u8 => UInt as u32);
-impl_from!(u16 => UInt as u32);
-impl_from!(f32 => Double as f64);
-impl_from!(AnyPtr, Ptr);
+impl_va_arg_from!(direct: i32 => Int, u32 => UInt, i64 => Long, u64 => ULong, f64 => Double, AnyPtr => Ptr);
+impl_va_arg_from!(promote: i8 => Int as i32, i16 => Int as i32, u8 => UInt as u32, u16 => UInt as u32, f32 => Double as f64);
+impl_va_arg_from!(ptr: c_void, i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, usize, isize);
 
 impl<T: Clone + crate::reinterpret::ByteRepr + 'static> From<crate::rc::Ptr<T>> for VaArg {
     fn from(v: crate::rc::Ptr<T>) -> Self {
         VaArg::Ptr(v.to_any())
     }
 }
 
-macro_rules! impl_from_ptr {
-    ($($ty:ty),*) => {
-        $(
-            impl_from!(*mut $ty => RawPtr as *mut c_void);
-            impl_from!(*const $ty => RawPtr as *mut c_void);
-        )*
-    };
-}
-
-impl_from_ptr!(c_void, i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, usize, isize);
-
+#[derive(Clone, Copy, Default)]
 pub struct VaList<'a> {
     args: &'a [VaArg],
     pos: usize,
@@ -78,120 +62,59 @@ impl<'a> VaList<'a> {
     }
 }
 
-impl Default for VaList<'_> {
-    fn default() -> Self {
-        VaList { args: &[], pos: 0 }
-    }
-}
-
-impl Clone for VaList<'_> {
-    fn clone(&self) -> Self {
-        VaList {
-            args: self.args,
-            pos: self.pos,
-        }
-    }
-}
-
-fn get_int(v: &VaArg) -> i64 {
-    match v {
-        VaArg::Int(n) => *n as i64,
-        VaArg::UInt(n) => *n as i64,
-        VaArg::Long(n) => *n,
-        VaArg::ULong(n) => *n as i64,
-        _ => panic!("VaList::arg: expected integer, got different variant"),
-    }
-}
-
-fn get_uint(v: &VaArg) -> u64 {
-    match v {
-        VaArg::Int(n) => *n as u64,
-        VaArg::UInt(n) => *n as u64,
-        VaArg::Long(n) => *n as u64,
-        VaArg::ULong(n) => *n,
-        _ => panic!("VaList::arg: expected unsigned integer, got different variant"),
-    }
-}
-
-fn get_float(v: &VaArg) -> f64 {
-    match v {
-        VaArg::Double(n) => *n,
-        VaArg::Int(n) => *n as f64,
-        VaArg::Long(n) => *n as f64,
-        _ => panic!("VaList::arg: expected float, got different variant"),
-    }
-}
-
-fn get_ptr(v: &VaArg) -> *mut c_void {
-    match v {
-        VaArg::RawPtr(p) => *p,
-        _ => panic!("VaList::arg: expected pointer, got different variant"),
-    }
-}
-
 pub trait VaArgGet {
     fn get(v: &VaArg) -> Self;
 }
 
-macro_rules! impl_get_int {
-    ($($ty:ty),*) => {
-        $(impl VaArgGet for $ty {
-            fn get(v: &VaArg) -> Self { get_int(v) as $ty }
-        })*
-    };
-}
-
-macro_rules! impl_get_uint {
-    ($($ty:ty),*) => {
-        $(impl VaArgGet for $ty {
-            fn get(v: &VaArg) -> Self { get_uint(v) as $ty }
-        })*
-    };
-}
-
-macro_rules! impl_get_ptr {
-    ($($ty:ty),*) => {
-        $(impl VaArgGet for $ty {
-            fn get(v: &VaArg) -> Self { get_ptr(v) as $ty }
-        })*
-    };
-}
-
-impl_get_int!(i8, i16, i32, i64);
-impl_get_uint!(u8, u16, u32, u64);
-
-impl VaArgGet for f32 {
-    fn get(v: &VaArg) -> Self {
-        get_float(v) as f32
-    }
-}
-
-impl VaArgGet for f64 {
-    fn get(v: &VaArg) -> Self {
-        get_float(v)
-    }
-}
-
-macro_rules! impl_get_ptr {
-    ($($ty:ty),*) => {
-        $(
-            impl VaArgGet for *mut $ty {
-                fn get(v: &VaArg) -> Self { get_ptr(v) as *mut $ty }
+macro_rules! impl_va_arg_get {
+    (int: $($ty:ty),*) => {$(
+        impl VaArgGet for $ty {
+            fn get(v: &VaArg) -> Self {
+                match v {
+                    VaArg::Int(n) => *n as Self,
+                    VaArg::UInt(n) => *n as Self,
+                    VaArg::Long(n) => *n as Self,
+                    VaArg::ULong(n) => *n as Self,
+                    _ => panic!("VaArgGet: expected integer"),
+                }
             }
-            impl VaArgGet for *const $ty {
-                fn get(v: &VaArg) -> Self { get_ptr(v) as *const $ty }
+        }
+    )*};
+    (float: $($ty:ty),*) => {$(
+        impl VaArgGet for $ty {
+            fn get(v: &VaArg) -> Self {
+                match v {
+                    VaArg::Double(n) => *n as Self,
+                    VaArg::Int(n) => *n as Self,
+                    VaArg::Long(n) => *n as Self,
+                    _ => panic!("VaArgGet: expected float"),
+                }
+            }
+        }
+    )*};
+    (ptr: $($ty:ty),*) => {$(
+        impl VaArgGet for *mut $ty {
+            fn get(v: &VaArg) -> Self {
+                match v { VaArg::RawPtr(p) => *p as Self, _ => panic!("VaArgGet: expected pointer") }
             }
-        )*
-    };
+        }
+        impl VaArgGet for *const $ty {
+            fn get(v: &VaArg) -> Self {
+                match v { VaArg::RawPtr(p) => *p as Self, _ => panic!("VaArgGet: expected pointer") }
+            }
+        }
+    )*};
 }
 
-impl_get_ptr!(c_void, i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, usize, isize);
+impl_va_arg_get!(int: i8, i16, i32, i64, u8, u16, u32, u64);
+impl_va_arg_get!(float: f32, f64);
+impl_va_arg_get!(ptr: c_void, i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, usize, isize);
 
 impl<T: 'static> VaArgGet for crate::rc::Ptr<T> {
     fn get(v: &VaArg) -> Self {
         match v {
-            VaArg::Ptr(any) => any.cast::<T>().expect("VaList::arg: Ptr type mismatch"),
-            _ => panic!("VaList::arg: expected Ptr, got different variant"),
+            VaArg::Ptr(any) => any.cast::<T>().expect("VaArgGet: Ptr type mismatch"),
+            _ => panic!("VaArgGet: expected Ptr"),
         }
     }
 }