klamath-rs/src/lib.rs

extern crate byteorder;

pub mod basic;
pub mod record;
pub mod records;
pub mod elements;
pub mod library;


use rust_util::ToInt2BE;
use rust_util::ToInt4BE;


macro_rules! mkfun {
    ( $fname:ident, $tt:ty, $elfn:ident ) => {
        #[no_mangle]
        pub extern "C" fn $fname(arr: *mut $tt, size: usize) -> $tt {
            let sl = unsafe { std::slice::from_raw_parts_mut(arr, size) };
            for xx in sl.iter_mut() {
                let res = <$tt>::$elfn(*xx);
                match res {
                    Err(cc) => return cc,
                    Ok(cc) => { *xx = cc; },
                }
            }
            0 as $tt
        }
    }
}


mkfun!(f64_to_i16, f64, convert_to_i2be);
mkfun!(f32_to_i16, f32, convert_to_i2be);
mkfun!(i64_to_i16, i64, convert_to_i2be);
mkfun!(u64_to_i16, u64, convert_to_i2be);
mkfun!(i32_to_i16, i32, convert_to_i2be);
mkfun!(u32_to_i16, u32, convert_to_i2be);
mkfun!(i16_to_i16, i16, convert_to_i2be);
mkfun!(u16_to_i16, u16, convert_to_i2be);

mkfun!(f64_to_i32, f64, convert_to_i4be);
mkfun!(f32_to_i32, f32, convert_to_i4be);
mkfun!(i64_to_i32, i64, convert_to_i4be);
mkfun!(u64_to_i32, u64, convert_to_i4be);
mkfun!(i32_to_i32, i32, convert_to_i4be);
mkfun!(u32_to_i32, u32, convert_to_i4be);


mod rust_util {
    use byteorder::{ByteOrder, BigEndian};
    use std::mem::size_of;

    pub trait ToInt2BE {
        fn convert_to_i2be(ii: Self) -> Result<Self, Self> where Self: Sized;
    }

    pub trait ToInt4BE {
        fn convert_to_i4be(ii: Self) -> Result<Self, Self> where Self: Sized;
    }

    macro_rules! impl_i2be {
        ( $tt:ty ) => {
            impl ToInt2BE for $tt {
                fn convert_to_i2be(ii: $tt) -> Result<$tt, $tt> {
                    if ii < i16::MIN as $tt { return Err(ii); }
                    if ii > i16::MAX as $tt { return Err(ii); }

                    let mut buf = [0; size_of::<$tt>()];
                    BigEndian::write_i16(&mut buf, ii as i16);
                    Ok(<$tt>::from_le_bytes(buf))
                }
            }
        }
    }

    macro_rules! impl_i4be {
        ( $tt:ty ) => {
            impl ToInt4BE for $tt {
                fn convert_to_i4be(ii: $tt) -> Result<$tt, $tt> {
                    if ii < i32::MIN as $tt { return Err(ii); }
                    if ii > i32::MAX as $tt { return Err(ii); }

                    let mut buf = [0; size_of::<$tt>()];
                    BigEndian::write_i32(&mut buf, ii as i32);
                    Ok(<$tt>::from_le_bytes(buf))
                }
            }
        }
    }

    impl_i2be!(f64);
    impl_i4be!(f64);

    impl_i2be!(f32);
    impl_i4be!(f32);

    impl_i2be!(i64);
    impl_i4be!(i64);
    impl_i2be!(u64);
    impl_i4be!(u64);

    impl_i2be!(i32);
    impl_i4be!(i32);
    impl_i2be!(u32);
    impl_i4be!(u32);

    impl_i2be!(i16);
    impl_i2be!(u16);

    // Does not fit
    //impl_i4be!(i16);
    //impl_i4be!(u16);
    //
    //impl_i2be!(i8);
    //impl_i4be!(i8);
    //impl_i2be!(u8);
    //impl_i4be!(u8);

}