120 lines
3.8 KiB
Rust
120 lines
3.8 KiB
Rust
extern crate byteorder;
|
|
|
|
pub mod basic;
|
|
pub mod record;
|
|
pub mod records;
|
|
pub mod elements;
|
|
pub mod library;
|
|
|
|
use crate::library::read_library;
|
|
|
|
use byteorder::{ByteOrder, BigEndian};
|
|
use std::mem::size_of;
|
|
use std::ffi::{CStr, OsStr, c_char};
|
|
use std::os::unix::ffi::OsStrExt;
|
|
use std::str;
|
|
use std::fs;
|
|
use std::path::Path;
|
|
|
|
use arrow::ffi::{to_ffi, FFI_ArrowArray, FFI_ArrowSchema};
|
|
use arrow::array::Array;
|
|
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn read_path(
|
|
cpath: *const c_char,
|
|
arr: *mut FFI_ArrowArray,
|
|
schema: *mut FFI_ArrowSchema,
|
|
) {
|
|
let cstr = unsafe { CStr::from_ptr(cpath) };
|
|
let path: &Path;
|
|
if cfg!(unix) {
|
|
let osstr = OsStr::from_bytes(cstr.to_bytes());
|
|
path = osstr.as_ref();
|
|
} else if cfg!(windows) {
|
|
let ustr = str::from_utf8(cstr.to_bytes()).expect("Non-UTF8 paths are not supported");
|
|
path = ustr.as_ref();
|
|
} else {
|
|
panic!("Unsupported OS");
|
|
}
|
|
|
|
let input = fs::read(path).expect("File read failed");
|
|
let (_input, struct_arr) = read_library(&input).expect("Read failed");
|
|
(*arr, *schema) = to_ffi(&struct_arr.to_data()).unwrap();
|
|
}
|
|
|
|
|
|
macro_rules! impl_i16be {
|
|
( $tt:ty, $arr:ident, $size:ident ) => {
|
|
{
|
|
let sl = unsafe { std::slice::from_raw_parts_mut($arr, $size) };
|
|
for xx in sl.iter_mut() {
|
|
if *xx < i16::MIN as $tt { return *xx }
|
|
if *xx > i16::MAX as $tt { return *xx }
|
|
|
|
let mut buf = [0; size_of::<$tt>()];
|
|
BigEndian::write_i16(&mut buf, *xx as i16);
|
|
*xx = <$tt>::from_le_bytes(buf);
|
|
}
|
|
0 as $tt
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
macro_rules! impl_i32be {
|
|
( $tt:ty, $arr:ident, $size:ident ) => {
|
|
{
|
|
let sl = unsafe { std::slice::from_raw_parts_mut($arr, $size) };
|
|
for xx in sl.iter_mut() {
|
|
if *xx < i32::MIN as $tt { return *xx }
|
|
if *xx > i32::MAX as $tt { return *xx }
|
|
|
|
let mut buf = [0; size_of::<$tt>()];
|
|
BigEndian::write_i32(&mut buf, *xx as i32);
|
|
*xx = <$tt>::from_le_bytes(buf);
|
|
}
|
|
0 as $tt
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn f64_to_i16(arr: *mut f64, size: usize) -> f64 { impl_i16be!(f64, arr, size) }
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn f64_to_i32(arr: *mut f64, size: usize) -> f64 { impl_i32be!(f64, arr, size) }
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn f32_to_i16(arr: *mut f32, size: usize) -> f32 { impl_i16be!(f32, arr, size) }
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn f32_to_i32(arr: *mut f32, size: usize) -> f32 { impl_i32be!(f32, arr, size) }
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn u64_to_i16(arr: *mut u64, size: usize) -> u64 { impl_i16be!(u64, arr, size) }
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn u64_to_i32(arr: *mut u64, size: usize) -> u64 { impl_i32be!(u64, arr, size) }
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn i64_to_i16(arr: *mut i64, size: usize) -> i64 { impl_i16be!(i64, arr, size) }
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn i64_to_i32(arr: *mut i64, size: usize) -> i64 { impl_i32be!(i64, arr, size) }
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn u32_to_i16(arr: *mut u32, size: usize) -> u32 { impl_i16be!(u32, arr, size) }
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn u32_to_i32(arr: *mut u32, size: usize) -> u32 { impl_i32be!(u32, arr, size) }
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn i32_to_i16(arr: *mut i32, size: usize) -> i32 { impl_i16be!(i32, arr, size) }
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn i32_to_i32(arr: *mut i32, size: usize) -> i32 { impl_i32be!(i32, arr, size) }
|
|
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn u16_to_i16(arr: *mut u16, size: usize) -> u16 { impl_i16be!(u16, arr, size) }
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn i16_to_i16(arr: *mut i16, size: usize) -> i16 { impl_i16be!(i16, arr, size) }
|
|
|