From 54e491840d4098bce7d57c461609135a3eb4871a Mon Sep 17 00:00:00 2001 From: bunnie Date: Mon, 7 Mar 2022 13:17:58 +0800 Subject: [PATCH 1/6] stash to work on an aes api bug --- Cargo.lock | 23 +++++++++++++++++++++++ Cargo.toml | 1 + buildpush.ps1 | 3 ++- xtask/src/main.rs | 18 +++++++++++++++++- 4 files changed, 43 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 64a032dd0..f672d314c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -840,6 +840,29 @@ dependencies = [ "backtrace", ] +[[package]] +name = "ffi-sys" +version = "0.1.0" +dependencies = [ + "cc", +] + +[[package]] +name = "ffi-test" +version = "0.1.0" +dependencies = [ + "ffi-sys", + "log", + "log-server", + "num-derive", + "num-traits", + "susres", + "ticktimer-server", + "utralib", + "xous", + "xous-names", +] + [[package]] name = "filetime" version = "0.2.14" diff --git a/Cargo.toml b/Cargo.toml index d28461924..03e3afce2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -89,6 +89,7 @@ members = [ "apps/ball", "apps/repl", "services/libstd-test", + "services/ffi-test", "kernel", ] resolver = "2" diff --git a/buildpush.ps1 b/buildpush.ps1 index 9e3b285a4..210b673f7 100644 --- a/buildpush.ps1 +++ b/buildpush.ps1 @@ -3,7 +3,8 @@ # set RUSTFLAGS=--remap-path-prefix=F:\largework\rust-win\code\xous-core\=build # $env:RUSTFLAGS="--remap-path-prefix=$(Get-Location)=build" -cargo xtask app-image ball repl +# cargo xtask app-image ball repl +cargo xtask ffi-test # cargo xtask minimal precursors/soc.svd CertUtil -hashfile precursors/bbram-test1.nky MD5 diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 87257e560..3532f1fac 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -90,7 +90,6 @@ fn main() -> Result<(), Box> { "xous-names", "trng", "llio", - "test-stub", "susres", "com", ]; @@ -157,6 +156,7 @@ fn main() -> Result<(), Box> { "com", "graphics-server", "keyboard", + "spinor", ]; let aestest_pkgs = ["ticktimer-server", "log-server", "aes-test"]; @@ -210,6 +210,22 @@ fn main() -> Result<(), Box> { renode_image(false, &pkgs, extra_packages.as_slice(), None, Some(&["--features", "renode-bypass"]))?; } + Some("ffi-test") => { + let mut args = env::args(); + args.nth(1); + let mut pkgs = hw_pkgs.to_vec(); + pkgs.push("ffi-test"); + let args: Vec = args.collect(); + let mut extra_packages = vec![]; + for program in &args { + extra_packages.push(program.as_str()); + } + build_hw_image(false, Some("./precursors/soc.svd".to_string()), + &pkgs, None, None, None, &[], Some(&["--features", "renode-bypass"]))? + + //renode_image(false, &pkgs, extra_packages.as_slice(), + //None, Some(&["--features", "renode-bypass"]))?; + } Some("libstd-net") => { let mut args = env::args(); args.nth(1); From b464c8e66140c1addf6b62775b6b5dac85105ffd Mon Sep 17 00:00:00 2001 From: bunnie Date: Mon, 7 Mar 2022 14:00:19 +0800 Subject: [PATCH 2/6] shoot, this was missing from earlier commits. lost some state. --- services/ffi-test/Cargo.toml | 24 + services/ffi-test/src/api.rs | 7 + services/ffi-test/src/bindings.rs | 132 +++ services/ffi-test/src/lib.rs | 33 + services/ffi-test/src/main.rs | 64 ++ services/ffi-test/sys/Cargo.toml | 12 + services/ffi-test/sys/build.rs | 40 + services/ffi-test/sys/ffi/ffi.c | 61 ++ services/ffi-test/sys/ffi/libc.c | 1678 +++++++++++++++++++++++++++++ services/ffi-test/sys/ffi/libc.h | 49 + services/ffi-test/sys/ffi/scanf.c | 578 ++++++++++ services/ffi-test/sys/src/lib.rs | 9 + 12 files changed, 2687 insertions(+) create mode 100644 services/ffi-test/Cargo.toml create mode 100644 services/ffi-test/src/api.rs create mode 100644 services/ffi-test/src/bindings.rs create mode 100644 services/ffi-test/src/lib.rs create mode 100644 services/ffi-test/src/main.rs create mode 100644 services/ffi-test/sys/Cargo.toml create mode 100644 services/ffi-test/sys/build.rs create mode 100644 services/ffi-test/sys/ffi/ffi.c create mode 100644 services/ffi-test/sys/ffi/libc.c create mode 100644 services/ffi-test/sys/ffi/libc.h create mode 100644 services/ffi-test/sys/ffi/scanf.c create mode 100644 services/ffi-test/sys/src/lib.rs diff --git a/services/ffi-test/Cargo.toml b/services/ffi-test/Cargo.toml new file mode 100644 index 000000000..4695c0589 --- /dev/null +++ b/services/ffi-test/Cargo.toml @@ -0,0 +1,24 @@ +[package] +name = "ffi-test" +version = "0.1.0" +authors = ["bunnie "] +edition = "2018" +description = "FFI test integration" + +# Dependency policy: fully specify dependencies to the minor version number +[dependencies] +xous = { path = "../../xous-rs" } +log-server = { path = "../log-server" } +ticktimer-server = { path = "../ticktimer-server" } +xous-names = { path = "../xous-names" } +log = "0.4.14" +num-derive = {version = "0.3.3", default-features = false} +num-traits = {version = "0.2.14", default-features = false} +susres = {path = "../susres"} +ffi-sys = {path = "sys"} + +[target.'cfg(not(any(windows,unix)))'.dependencies] +utralib = { path = "../../utralib"} + +[features] +default = [] diff --git a/services/ffi-test/src/api.rs b/services/ffi-test/src/api.rs new file mode 100644 index 000000000..eb46671f5 --- /dev/null +++ b/services/ffi-test/src/api.rs @@ -0,0 +1,7 @@ +pub(crate) const SERVER_NAME_FFITEST: &str = "_FfiTest Server_"; + +#[allow(dead_code)] +#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)] +pub(crate) enum Opcode { + Quit +} diff --git a/services/ffi-test/src/bindings.rs b/services/ffi-test/src/bindings.rs new file mode 100644 index 000000000..782ca964c --- /dev/null +++ b/services/ffi-test/src/bindings.rs @@ -0,0 +1,132 @@ +#![cfg_attr(target_os = "none", no_std)] +#![allow(nonstandard_style)] + +pub type c_char = i8; +pub type c_schar = i8; +pub type c_uchar = u8; +pub type c_short = i16; +pub type c_ushort = u16; +pub type c_int = i32; +pub type c_uint = u32; +pub type c_long = i32; +pub type c_ulong = u32; +pub type c_longlong = i64; +pub type c_ulonglong = u64; +pub type c_float = f32; +pub type c_double = f64; +pub type c_void = core::ffi::c_void; + +extern "C" { + pub fn add_one(a: i32) -> i32; +} + +extern "C" { + pub fn malloc_test() -> i32; +} + +static mut PUTC_BUF: Vec:: = Vec::new(); +#[export_name = "libc_putchar"] +pub unsafe extern "C" fn libc_putchar( + c: c_char, +) { + let char = c as u8; + if char != 0xa && char != 0xd { + PUTC_BUF.push(char); + } else { + let s = String::from_utf8_lossy(&PUTC_BUF); + log::info!("ffi-test: {}", s); + PUTC_BUF.clear(); + } +} + +static mut C_HEAP: Vec::> = Vec::new(); +#[export_name = "malloc"] +pub unsafe extern "C" fn malloc( + size: c_uint +) -> *mut c_void { + // note: we might need to use `Pin` to keep the data from moving around in the heap, if we see weird behavior + // happening + let checked_size = if size == 0 { + 1 // at least 1 element so we can get a pointer to pass back + } else { + size + }; + let mut alloc: Vec:: = Vec::with_capacity(checked_size as usize); + for _ in 0..checked_size { + alloc.push(0); + } + let ptr = alloc.as_mut_ptr(); + // store a reference to the allocated vector, under the theory that this keeps it from going out of scope + C_HEAP.push(alloc); + log::info!("allocated: {:x}({})#{}", ptr as usize, size, C_HEAP.len()); + + ptr as *mut c_void +} + +#[export_name = "free"] +pub unsafe extern "C" fn free( + ptr: *mut c_void +) { + let mut region_index: Option = None; + for (index, region) in C_HEAP.iter().enumerate() { + if region.as_ptr() as usize == ptr as usize { + region_index = Some(index); + break; + } + } + match region_index { + Some(index) => { + let mut removed = C_HEAP.remove(index); + log::info!("free success: {:x}({})#{}", ptr as usize, removed.len(), C_HEAP.len()); + removed.clear(); + } + None => { + log::info!("free failed, debug! Requested free: {:x}", ptr as usize); + for region in C_HEAP.iter() { + log::info!(" {:x}({})", region.as_ptr() as usize, region.len()); + } + } + } +} + +#[export_name = "realloc"] +pub unsafe extern "C" fn realloc( + ptr: *mut c_void, + size: c_uint +) -> *mut c_void { + let mut region_index: Option = None; + for (index, region) in C_HEAP.iter().enumerate() { + if region.as_ptr() as usize == ptr as usize { + region_index = Some(index); + break; + } + } + match region_index { + Some(index) => { + log::info!("realloc/free success: {:x}", ptr as usize); + let mut old = C_HEAP.remove(index); + old.clear(); + let checked_size = if size == 0 { + 1 // at least 1 element so we have a pointer we can pass back + } else { + size + }; + let mut alloc: Vec:: = Vec::with_capacity(checked_size as usize); + let ret_ptr = alloc.as_mut_ptr(); + for (&src, dst) in old.iter().zip(alloc.iter_mut()) { + *dst = src; + } + C_HEAP.push(alloc); + log::info!("realloc/allocated: {:x}", ret_ptr as usize); + + ret_ptr as *mut c_void + } + None => { + log::info!("realloc failed, debug! Requested realloc: {:x}({})", ptr as usize, size); + for region in C_HEAP.iter() { + log::info!(" {:x}({})", region.as_ptr() as usize, region.len()); + } + return ::core::ptr::null::() as *mut c_void + } + } +} diff --git a/services/ffi-test/src/lib.rs b/services/ffi-test/src/lib.rs new file mode 100644 index 000000000..3f0444afa --- /dev/null +++ b/services/ffi-test/src/lib.rs @@ -0,0 +1,33 @@ +#![cfg_attr(target_os = "none", no_std)] + +pub mod api; +use xous::{CID, send_message}; +use num_traits::ToPrimitive; + +pub struct FfiTest { + conn: CID, +} +impl FfiTest { + pub fn new(xns: &xous_names::XousNames) -> Result { + REFCOUNT.fetch_add(1, Ordering::Relaxed); + let conn = xns.request_connection_blocking(api::SERVER_NAME_FFITEST).expect("Can't connect to FfiTest server"); + Ok(FfiTest { + conn + }) + } +} + +use core::sync::atomic::{AtomicU32, Ordering}; +static REFCOUNT: AtomicU32 = AtomicU32::new(0); +impl Drop for FfiTest { + fn drop(&mut self) { + // the connection to the server side must be reference counted, so that multiple instances of this object within + // a single process do not end up de-allocating the CID on other threads before they go out of scope. + // Note to future me: you want this. Don't get rid of it because you think, "nah, nobody will ever make more than one copy of this object". + if REFCOUNT.fetch_sub(1, Ordering::Relaxed) == 1 { + unsafe{xous::disconnect(self.conn).unwrap();} + } + // if there was object-specific state (such as a one-time use server for async callbacks, specific to the object instance), + // de-allocate those items here. They don't need a reference count because they are object-specific + } +} \ No newline at end of file diff --git a/services/ffi-test/src/main.rs b/services/ffi-test/src/main.rs new file mode 100644 index 000000000..dca818036 --- /dev/null +++ b/services/ffi-test/src/main.rs @@ -0,0 +1,64 @@ +#![cfg_attr(target_os = "none", no_std)] +#![cfg_attr(target_os = "none", no_main)] + +extern crate ffi_sys; + +mod api; +use api::*; +pub mod bindings; +pub use bindings::*; + +use num_traits::FromPrimitive; + +use utralib::utra::ticktimer; + +#[xous::xous_main] +fn xmain() -> ! { + log_server::init_wait().unwrap(); + log::set_max_level(log::LevelFilter::Trace); + log::info!("my PID is {}", xous::process::id()); + + log::info!("creating xns"); + let xns = xous_names::XousNames::new().unwrap(); + let mut a = 0; + for _ in 0..5 { + a = unsafe{add_one(a)}; + log::info!("ffi test: {}", a); + } + log::info!("malloc test result: {}", unsafe{malloc_test()}); + + log::info!("registering with xns"); + let ffitest_sid = xns.register_name(api::SERVER_NAME_FFITEST, None).expect("can't register server"); + log::trace!("registered with NS -- {:?}", ffitest_sid); + + // spawn a small thread that keeps the watchdog timer from firing and lets us know other things didn't crash + std::thread::spawn({ + move || { + let tt = ticktimer_server::Ticktimer::new().unwrap(); + let mut state = 0; + loop { + tt.sleep_ms(2500).unwrap(); + log::info!("keepalive {}", state); + state += 1; + } + } + }); + + loop { + let msg = xous::receive_message(ffitest_sid).unwrap(); + match FromPrimitive::from_usize(msg.body.id()) { + Some(Opcode::Quit) => { + break + } + _ => { + log::info!("couldn't convert opcode {:?}", msg); + } + } + } + // clean up our program + log::trace!("main loop exit, destroying servers"); + xns.unregister_server(ffitest_sid).unwrap(); + xous::destroy_server(ffitest_sid).unwrap(); + log::trace!("quitting"); + xous::terminate_process(0) +} diff --git a/services/ffi-test/sys/Cargo.toml b/services/ffi-test/sys/Cargo.toml new file mode 100644 index 000000000..1c34844ee --- /dev/null +++ b/services/ffi-test/sys/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "ffi-sys" +version = "0.1.0" +authors = ["bunnie "] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] + +[build-dependencies] +cc = "1.0" \ No newline at end of file diff --git a/services/ffi-test/sys/build.rs b/services/ffi-test/sys/build.rs new file mode 100644 index 000000000..22379f901 --- /dev/null +++ b/services/ffi-test/sys/build.rs @@ -0,0 +1,40 @@ +extern crate cc; + +use std::env::set_var; + +fn main() { + set_var("CC", "riscv64-unknown-elf-gcc"); // set the compiler to what's installed on the system + + let espeak_srcs = vec![ + "ffi/ffi.c", + "ffi/libc.c", + "ffi/scanf.c", + ]; + let espeak_includes = vec![ + "./", + // "espeak-ng/src", + // "espeak-ng/src/include/compat", + // "espeak-ng/src/include/espeak", + // "espeak-ng/src/include/espeak-ng", + // "espeak-ng/src/ucd-tools/src/include", + // "espeak-ng/src/include", + ]; + + let mut base_config = cc::Build::new(); + base_config.target("riscv32imac-unknown-none-elf"); + + for inc in espeak_includes { + base_config.include(inc); + } + base_config.include("C:\\Users\\bunnie\\riscv64\\riscv64-unknown-elf\\include"); + base_config.include("C:\\Users\\bunnie\\riscv64\\riscv64-unknown-elf\\include\\sys"); + base_config.include("C:\\Users\\bunnie\\riscv64\\riscv64-unknown-elf\\include\\machine"); + base_config.include("C:\\Users\\bunnie\\riscv64\\riscv64-unknown-elf\\include\\bits"); + + for src in espeak_srcs { + base_config.file(src); + } + base_config.define("XOUS", None); + base_config.define("NO_STD", None); + base_config.compile("libffi.a"); +} diff --git a/services/ffi-test/sys/ffi/ffi.c b/services/ffi-test/sys/ffi/ffi.c new file mode 100644 index 000000000..3fbe36289 --- /dev/null +++ b/services/ffi-test/sys/ffi/ffi.c @@ -0,0 +1,61 @@ +#include +#include "libc.h" + +int add_one(int a) { + printf("ffi adding one to %d\n\r", a); + return a + 1; +} + +/* returns an array of arrays of char*, all of which NULL */ +char ***alloc_matrix(unsigned rows, unsigned columns) { + char ***matrix = malloc(rows * sizeof(char **)); + unsigned row = 0; + unsigned column = 0; + if (!matrix) return NULL; + + for (row = 0; row < rows; row++) { + matrix[row] = calloc(columns, sizeof(char *)); + if (!matrix[row]) return NULL; + for (column = 0; column < columns; column++) { + matrix[row][column] = NULL; + } + } + return matrix; +} + +/* deallocates an array of arrays of char*, calling free() on each */ +void free_matrix(char ***matrix, unsigned rows, unsigned columns) { + unsigned row = 0; + unsigned column = 0; + for (row = 0; row < rows; row++) { + for (column = 0; column < columns; column++) { + printf("column %d row %d\n", column, row); + free(matrix[row][column]); + } + free(matrix[row]); + } + free(matrix); +} + +int malloc_test() { + int i; + + int randomnumber; + int size = 32; + void *p[size]; + for (i = 0; i < size; i++) { + randomnumber = rand() % 10; + p[i] = malloc(32 * 32 * randomnumber); + } + + for (i = size-1; i >= 0; i--) { + free(p[i]); + } + /* + int x = 6; + char *** matrix = alloc_matrix(x, x); + if (matrix == NULL) return 1; + free_matrix(matrix, x, x); + */ + return (0); +} diff --git a/services/ffi-test/sys/ffi/libc.c b/services/ffi-test/sys/ffi/libc.c new file mode 100644 index 000000000..0fefef167 --- /dev/null +++ b/services/ffi-test/sys/ffi/libc.c @@ -0,0 +1,1678 @@ +#ifdef LOCAL_TEST +#include "../config.h" +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "libc.h" + +void _putchar(char c) { +#ifdef LOCAL_TEST + putchar(c); +#else + libc_putchar(c); +#endif +} + +#define RAND48_SEED_0 (0x330e) +#define RAND48_SEED_1 (0xabcd) +#define RAND48_SEED_2 (0x1234) +#define RAND48_MULT_0 (0xe66d) +#define RAND48_MULT_1 (0xdeec) +#define RAND48_MULT_2 (0x0005) +#define RAND48_ADD (0x000b) +unsigned short __rand48_seed[3] = { + RAND48_SEED_0, + RAND48_SEED_1, + RAND48_SEED_2 +}; +unsigned short __rand48_mult[3] = { + RAND48_MULT_0, + RAND48_MULT_1, + RAND48_MULT_2 +}; +unsigned short __rand48_add = RAND48_ADD; +void +__dorand48(unsigned short xseed[3]) +{ + unsigned long accu; + unsigned short temp[2]; + accu = (unsigned long) __rand48_mult[0] * (unsigned long) xseed[0] + + (unsigned long) __rand48_add; + temp[0] = (unsigned short) accu; /* lower 16 bits */ + accu >>= sizeof(unsigned short) * 8; + accu += (unsigned long) __rand48_mult[0] * (unsigned long) xseed[1] + + (unsigned long) __rand48_mult[1] * (unsigned long) xseed[0]; + temp[1] = (unsigned short) accu; /* middle 16 bits */ + accu >>= sizeof(unsigned short) * 8; + accu += __rand48_mult[0] * xseed[2] + __rand48_mult[1] * xseed[1] + __rand48_mult[2] * xseed[0]; + xseed[0] = temp[0]; + xseed[1] = temp[1]; + xseed[2] = (unsigned short) accu; +} +long +rand(void) +{ + __dorand48(__rand48_seed); + return ((long) __rand48_seed[2] << 15) + ((long) __rand48_seed[1] >> 1); +} +// much code ganked from https://android.googlesource.com/platform/bionic/+/ics-mr0/libc/ (BSD 3-clause) + +#define CTYPE_NUM_CHARS 256 +const char _ctype_[1 + CTYPE_NUM_CHARS] = { + 0, + _C, _C, _C, _C, _C, _C, _C, _C, + _C, _C|_S, _C|_S, _C|_S, _C|_S, _C|_S, _C, _C, + _C, _C, _C, _C, _C, _C, _C, _C, + _C, _C, _C, _C, _C, _C, _C, _C, + _S|(char)_B, _P, _P, _P, _P, _P, _P, _P, + _P, _P, _P, _P, _P, _P, _P, _P, + _N, _N, _N, _N, _N, _N, _N, _N, + _N, _N, _P, _P, _P, _P, _P, _P, + _P, _U|_X, _U|_X, _U|_X, _U|_X, _U|_X, _U|_X, _U, + _U, _U, _U, _U, _U, _U, _U, _U, + _U, _U, _U, _U, _U, _U, _U, _U, + _U, _U, _U, _P, _P, _P, _P, _P, + _P, _L|_X, _L|_X, _L|_X, _L|_X, _L|_X, _L|_X, _L, + _L, _L, _L, _L, _L, _L, _L, _L, + _L, _L, _L, _L, _L, _L, _L, _L, + /* determine printability based on the IS0 8859 8-bit standard */ + _L, _L, _L, _P, _P, _P, _P, _C, + _C, _C, _C, _C, _C, _C, _C, _C, /* 80 */ + _C, _C, _C, _C, _C, _C, _C, _C, /* 88 */ + _C, _C, _C, _C, _C, _C, _C, _C, /* 90 */ + _C, _C, _C, _C, _C, _C, _C, _C, /* 98 */ + _P, _P, _P, _P, _P, _P, _P, _P, /* A0 */ + _P, _P, _P, _P, _P, _P, _P, _P, /* A8 */ + _P, _P, _P, _P, _P, _P, _P, _P, /* B0 */ + _P, _P, _P, _P, _P, _P, _P, _P, /* B8 */ + _P, _P, _P, _P, _P, _P, _P, _P, /* C0 */ + _P, _P, _P, _P, _P, _P, _P, _P, /* C8 */ + _P, _P, _P, _P, _P, _P, _P, _P, /* D0 */ + _P, _P, _P, _P, _P, _P, _P, _P, /* D8 */ + _P, _P, _P, _P, _P, _P, _P, _P, /* E0 */ + _P, _P, _P, _P, _P, _P, _P, _P, /* E8 */ + _P, _P, _P, _P, _P, _P, _P, _P, /* F0 */ + _P, _P, _P, _P, _P, _P, _P, _P /* F8 */ +}; +//const char *_ctype_ = _C_ctype_; + +// 'ntoa' conversion buffer size, this must be big enough to hold one converted +// numeric number including padded zeros (dynamically created on stack) +// default: 32 byte +#ifndef PRINTF_NTOA_BUFFER_SIZE +#define PRINTF_NTOA_BUFFER_SIZE 32U +#endif + +// 'ftoa' conversion buffer size, this must be big enough to hold one converted +// float number including padded zeros (dynamically created on stack) +// default: 32 byte +#ifndef PRINTF_FTOA_BUFFER_SIZE +#define PRINTF_FTOA_BUFFER_SIZE 32U +#endif + +// support for the floating point type (%f) +// default: activated +#ifndef PRINTF_DISABLE_SUPPORT_FLOAT +#define PRINTF_SUPPORT_FLOAT +#endif + +// support for exponential floating point notation (%e/%g) +// default: activated +#ifndef PRINTF_DISABLE_SUPPORT_EXPONENTIAL +#define PRINTF_SUPPORT_EXPONENTIAL +#endif + +// define the default floating point precision +// default: 6 digits +#ifndef PRINTF_DEFAULT_FLOAT_PRECISION +#define PRINTF_DEFAULT_FLOAT_PRECISION 6U +#endif + +// define the largest float suitable to print with %f +// default: 1e9 +#ifndef PRINTF_MAX_FLOAT +#define PRINTF_MAX_FLOAT 1e9 +#endif + +// support for the long long types (%llu or %p) +// default: activated +#ifndef PRINTF_DISABLE_SUPPORT_LONG_LONG +#define PRINTF_SUPPORT_LONG_LONG +#endif + +// support for the ptrdiff_t type (%t) +// ptrdiff_t is normally defined in as long or long long type +// default: activated +#ifndef PRINTF_DISABLE_SUPPORT_PTRDIFF_T +#define PRINTF_SUPPORT_PTRDIFF_T +#endif + +/////////////////////////////////////////////////////////////////////////////// + +// internal flag definitions +#define FLAGS_ZEROPAD (1U << 0U) +#define FLAGS_LEFT (1U << 1U) +#define FLAGS_PLUS (1U << 2U) +#define FLAGS_SPACE (1U << 3U) +#define FLAGS_HASH (1U << 4U) +#define FLAGS_UPPERCASE (1U << 5U) +#define FLAGS_CHAR (1U << 6U) +#define FLAGS_SHORT (1U << 7U) +#define FLAGS_LONG (1U << 8U) +#define FLAGS_LONG_LONG (1U << 9U) +#define FLAGS_PRECISION (1U << 10U) +#define FLAGS_ADAPT_EXP (1U << 11U) + +int local_errno = 134; // ENOTSUP + +int* __errno(void) { + return &local_errno; +} +wchar_t * +wcschr(const wchar_t *s, wchar_t c) +{ + while (*s != c && *s != L'\0') + s++; + if (*s == c) + return ((wchar_t *)s); + return (NULL); +} +size_t +wcslen(const wchar_t *s) +{ + const wchar_t *p; + p = s; + while (*p) + p++; + return p - s; +} +int +strncmp(const char *s1, const char *s2, size_t n) +{ + if (n == 0) + return (0); + do { + if (*s1 != *s2++) + return (*(unsigned char *)s1 - *(unsigned char *)--s2); + if (*s1++ == 0) + break; + } while (--n != 0); + return (0); +} +char * +strstr(const char *s, const char *find) +{ + char c, sc; + size_t len; + if ((c = *find++) != 0) { + len = strlen(find); + do { + do { + if ((sc = *s++) == 0) + return (NULL); + } while (sc != c); + } while (strncmp(s, find, len) != 0); + s--; + } + return ((char *)s); +} +char * +strchr (register const char *s, int c) +{ + do { + if (*s == c) + { + return (char*)s; + } + } while (*s++); + return (0); +} + +char * +strcpy(char *to, const char *from) +{ + char *save = to; + for (; (*to = *from) != '\0'; ++from, ++to); + return(save); +} + +int +strcmp(const char *s1, const char *s2) +{ + while (*s1 == *s2++) + if (*s1++ == 0) + return (0); + return (*(unsigned char *)s1 - *(unsigned char *)--s2); +} + +char * +strcat(char *s, const char *append) +{ + char *save = s; + for (; *s; ++s); + while ((*s++ = *append++) != '\0'); + return(save); +} + +void * +memcpy (void *dest, const void *src, size_t len) +{ + char *d = dest; + const char *s = src; + while (len--) + *d++ = *s++; + return dest; +} + +void * +memset (void *dest, int val, size_t len) +{ + unsigned char *ptr = dest; + while (len-- > 0) + *ptr++ = val; + return dest; +} + +size_t +strlen(const char *str) +{ + const char *s; + for (s = str; *s; ++s) + ; + return (s - str); +} + +char * +strdup(const char *str) +{ + size_t siz; + char *copy; + siz = strlen(str) + 1; + if ((copy = malloc(siz)) == NULL) + return(NULL); + (void)memcpy(copy, str, siz); + return(copy); +} + +char * +strncpy(char *dst, const char *src, size_t n) +{ + if (n != 0) { + char *d = dst; + const char *s = src; + do { + if ((*d++ = *s++) == 0) { + /* NUL pad the remaining n-1 bytes */ + while (--n != 0) + *d++ = 0; + break; + } + } while (--n != 0); + } + return (dst); +} + +long +strtol(const char *nptr, char **endptr, int base) +{ + const char *s; + long acc, cutoff; + int c; + int neg, any, cutlim; + /* + * Skip white space and pick up leading +/- sign if any. + * If base is 0, allow 0x for hex and 0 for octal, else + * assume decimal; if base is already 16, allow 0x. + */ + s = nptr; + do { + c = (unsigned char) *s++; + } while (isspace(c)); + if (c == '-') { + neg = 1; + c = *s++; + } else { + neg = 0; + if (c == '+') + c = *s++; + } + if ((base == 0 || base == 16) && + c == '0' && (*s == 'x' || *s == 'X')) { + c = s[1]; + s += 2; + base = 16; + } + if (base == 0) + base = c == '0' ? 8 : 10; + /* + * Compute the cutoff value between legal numbers and illegal + * numbers. That is the largest legal value, divided by the + * base. An input number that is greater than this value, if + * followed by a legal input character, is too big. One that + * is equal to this value may be valid or not; the limit + * between valid and invalid numbers is then based on the last + * digit. For instance, if the range for longs is + * [-2147483648..2147483647] and the input base is 10, + * cutoff will be set to 214748364 and cutlim to either + * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated + * a value > 214748364, or equal but the next digit is > 7 (or 8), + * the number is too big, and we will return a range error. + * + * Set any if any `digits' consumed; make it negative to indicate + * overflow. + */ + cutoff = neg ? LONG_MIN : LONG_MAX; + cutlim = cutoff % base; + cutoff /= base; + if (neg) { + if (cutlim > 0) { + cutlim -= base; + cutoff += 1; + } + cutlim = -cutlim; + } + for (acc = 0, any = 0;; c = (unsigned char) *s++) { + if (isdigit(c)) + c -= '0'; + else if (isalpha(c)) + c -= isupper(c) ? 'A' - 10 : 'a' - 10; + else + break; + if (c >= base) + break; + if (any < 0) + continue; + if (neg) { + if (acc < cutoff || (acc == cutoff && c > cutlim)) { + any = -1; + acc = LONG_MIN; + errno = ERANGE; + } else { + any = 1; + acc *= base; + acc -= c; + } + } else { + if (acc > cutoff || (acc == cutoff && c > cutlim)) { + any = -1; + acc = LONG_MAX; + errno = ERANGE; + } else { + any = 1; + acc *= base; + acc += c; + } + } + } + if (endptr != 0) + *endptr = (char *) (any ? s - 1 : nptr); + return (acc); +} + +unsigned long +strtoul(const char *nptr, char **endptr, int base) +{ + const char *s; + unsigned long acc, cutoff; + int c; + int neg, any, cutlim; + /* + * See strtol for comments as to the logic used. + */ + s = nptr; + do { + c = (unsigned char) *s++; + } while (isspace(c)); + if (c == '-') { + neg = 1; + c = *s++; + } else { + neg = 0; + if (c == '+') + c = *s++; + } + if ((base == 0 || base == 16) && + c == '0' && (*s == 'x' || *s == 'X')) { + c = s[1]; + s += 2; + base = 16; + } + if (base == 0) + base = c == '0' ? 8 : 10; + cutoff = ULONG_MAX / (unsigned long)base; + cutlim = ULONG_MAX % (unsigned long)base; + for (acc = 0, any = 0;; c = (unsigned char) *s++) { + if (isdigit(c)) + c -= '0'; + else if (isalpha(c)) + c -= isupper(c) ? 'A' - 10 : 'a' - 10; + else + break; + if (c >= base) + break; + if (any < 0) + continue; + if (acc > cutoff || (acc == cutoff && c > cutlim)) { + any = -1; + acc = ULONG_MAX; + errno = ERANGE; + } else { + any = 1; + acc *= (unsigned long)base; + acc += c; + } + } + if (neg && any > 0) + acc = -acc; + if (endptr != 0) + *endptr = (char *) (any ? s - 1 : nptr); + return (acc); +} + +uintmax_t +strtoumax(const char *nptr, char **endptr, int base) +{ + const char *s; + uintmax_t acc, cutoff; + int c; + int neg, any, cutlim; + /* + * See strtoq for comments as to the logic used. + */ + s = nptr; + do { + c = (unsigned char) *s++; + } while (isspace(c)); + if (c == '-') { + neg = 1; + c = *s++; + } else { + neg = 0; + if (c == '+') + c = *s++; + } + if ((base == 0 || base == 16) && + c == '0' && (*s == 'x' || *s == 'X')) { + c = s[1]; + s += 2; + base = 16; + } + if (base == 0) + base = c == '0' ? 8 : 10; + /* BIONIC: avoid division and modulo for common cases */ +#define CASE_BASE(x) \ + case x: cutoff = UINTMAX_MAX / x; \ + cutlim = UINTMAX_MAX % x; \ + break + switch (base) { + CASE_BASE(8); + CASE_BASE(10); + CASE_BASE(16); + default: + cutoff = UINTMAX_MAX / base; + cutlim = UINTMAX_MAX % base; + } + for (acc = 0, any = 0;; c = (unsigned char) *s++) { + if (isdigit(c)) + c -= '0'; + else if (isalpha(c)) + c -= isupper(c) ? 'A' - 10 : 'a' - 10; + else + break; + if (c >= base) + break; + if (any < 0) + continue; + if (acc > cutoff || (acc == cutoff && c > cutlim)) { + any = -1; + acc = UINTMAX_MAX; + errno = ERANGE; + } else { + any = 1; + acc *= (uintmax_t)base; + acc += c; + } + } + if (neg && any > 0) + acc = -acc; + if (endptr != 0) + *endptr = (char *) (any ? s - 1 : nptr); + return (acc); +} +static inline int digitval(int ch) +{ + unsigned d; + d = (unsigned)(ch - '0'); + if (d < 10) return (int)d; + d = (unsigned)(ch - 'a'); + if (d < 6) return (int)(d+10); + d = (unsigned)(ch - 'A'); + if (d < 6) return (int)(d+10); + return -1; +} +uintmax_t +strntoumax(const char *nptr, char **endptr, int base, size_t n) +{ + const unsigned char* p = (const unsigned char *)nptr; + const unsigned char* end = p + n; + int minus = 0; + uintmax_t v = 0; + int d; + /* skip leading space */ + while (p < end && isspace(*p)) + p++; + /* Single optional + or - */ + if (p < end) { + char c = p[0]; + if ( c == '-' || c == '+' ) { + minus = (c == '-'); + p++; + } + } + if ( base == 0 ) { + if ( p+2 < end && p[0] == '0' && (p[1] == 'x' || p[1] == 'X') ) { + p += 2; + base = 16; + } else if ( p+1 < end && p[0] == '0' ) { + p += 1; + base = 8; + } else { + base = 10; + } + } else if ( base == 16 ) { + if ( p+2 < end && p[0] == '0' && (p[1] == 'x' || p[1] == 'X') ) { + p += 2; + } + } + while ( p < end && (d = digitval(*p)) >= 0 && d < base ) { + v = v*base + d; + p += 1; + } + if ( endptr ) + *endptr = (char *)p; + return minus ? -v : v; +} +intmax_t strntoimax(const char *nptr, char **endptr, int base, size_t n) +{ + return (intmax_t) strntoumax(nptr, endptr, base, n); +} +intmax_t +strtoimax(const char *nptr, char **endptr, int base) +{ + const char *s; + intmax_t acc, cutoff; + int c; + int neg, any, cutlim; + /* + * Skip white space and pick up leading +/- sign if any. + * If base is 0, allow 0x for hex and 0 for octal, else + * assume decimal; if base is already 16, allow 0x. + */ + s = nptr; + do { + c = (unsigned char) *s++; + } while (isspace(c)); + if (c == '-') { + neg = 1; + c = *s++; + } else { + neg = 0; + if (c == '+') + c = *s++; + } + if ((base == 0 || base == 16) && + c == '0' && (*s == 'x' || *s == 'X')) { + c = s[1]; + s += 2; + base = 16; + } + if (base == 0) + base = c == '0' ? 8 : 10; + /* + * Compute the cutoff value between legal numbers and illegal + * numbers. That is the largest legal value, divided by the + * base. An input number that is greater than this value, if + * followed by a legal input character, is too big. One that + * is equal to this value may be valid or not; the limit + * between valid and invalid numbers is then based on the last + * digit. For instance, if the range for intmax_t is + * [-9223372036854775808..9223372036854775807] and the input base + * is 10, cutoff will be set to 922337203685477580 and cutlim to + * either 7 (neg==0) or 8 (neg==1), meaning that if we have + * accumulated a value > 922337203685477580, or equal but the + * next digit is > 7 (or 8), the number is too big, and we will + * return a range error. + * + * Set any if any `digits' consumed; make it negative to indicate + * overflow. + */ + /* BIONIC: avoid division and module for common cases */ +#define CASE_BASE2(x) \ + case x: \ + if (neg) { \ + cutlim = INTMAX_MIN % x; \ + cutoff = INTMAX_MIN / x; \ + } else { \ + cutlim = INTMAX_MAX % x; \ + cutoff = INTMAX_MAX / x; \ + }; \ + break + + switch (base) { + case 4: + if (neg) { + cutlim = (int)(INTMAX_MIN % 4); + cutoff = INTMAX_MIN / 4; + } else { + cutlim = (int)(INTMAX_MAX % 4); + cutoff = INTMAX_MAX / 4; + } + break; + CASE_BASE2(8); + CASE_BASE2(10); + CASE_BASE2(16); + default: + cutoff = neg ? INTMAX_MIN : INTMAX_MAX; + cutlim = cutoff % base; + cutoff /= base; + } +#undef CASE_BASE + + if (neg) { + if (cutlim > 0) { + cutlim -= base; + cutoff += 1; + } + cutlim = -cutlim; + } + for (acc = 0, any = 0;; c = (unsigned char) *s++) { + if (isdigit(c)) + c -= '0'; + else if (isalpha(c)) + c -= isupper(c) ? 'A' - 10 : 'a' - 10; + else + break; + if (c >= base) + break; + if (any < 0) + continue; + if (neg) { + if (acc < cutoff || (acc == cutoff && c > cutlim)) { + any = -1; + acc = INTMAX_MIN; + errno = ERANGE; + } else { + any = 1; + acc *= base; + acc -= c; + } + } else { + if (acc > cutoff || (acc == cutoff && c > cutlim)) { + any = -1; + acc = INTMAX_MAX; + errno = ERANGE; + } else { + any = 1; + acc *= base; + acc += c; + } + } + } + if (endptr != 0) + *endptr = (char *) (any ? s - 1 : nptr); + return (acc); +} +int atoi(const char* s) +{ + return (int)strtoimax(s, NULL, 10); +} + +int memcmp(const void *s1, const void *s2, size_t n) +{ + const unsigned char* p1 = s1; + const unsigned char* end1 = p1 + n; + const unsigned char* p2 = s2; + int d = 0; + for (;;) { + if (d || p1 >= end1) break; + d = (int)*p1++ - (int)*p2++; + if (d || p1 >= end1) break; + d = (int)*p1++ - (int)*p2++; + if (d || p1 >= end1) break; + d = (int)*p1++ - (int)*p2++; + if (d || p1 >= end1) break; + d = (int)*p1++ - (int)*p2++; + } + return d; +} + +char * +strtok(char *s, const char *delim) +{ + static char *last; + return strtok_r(s, delim, &last); +} +char * +strtok_r(char *s, const char *delim, char **last) +{ + char *spanp; + int c, sc; + char *tok; + if (s == NULL && (s = *last) == NULL) + return (NULL); + /* + * Skip (span) leading delimiters (s += strspn(s, delim), sort of). + */ +cont: + c = *s++; + for (spanp = (char *)delim; (sc = *spanp++) != 0;) { + if (c == sc) + goto cont; + } + if (c == 0) { /* no non-delimiter characters */ + *last = NULL; + return (NULL); + } + tok = s - 1; + /* + * Scan token (scan for delimiters: s += strcspn(s, delim), sort of). + * Note that delim must have one NUL; we stop if we see that, too. + */ + for (;;) { + c = *s++; + spanp = (char *)delim; + do { + if ((sc = *spanp++) == c) { + if (c == 0) + s = NULL; + else + s[-1] = 0; + *last = s; + return (tok); + } + } while (sc != 0); + } + /* NOTREACHED */ +} + +// from https://github.com/mpaland/printf +// output function type +typedef void (*out_fct_type)(char character, void* buffer, size_t idx, size_t maxlen); + + +// wrapper (used as buffer) for output function type +typedef struct { + void (*fct)(char character, void* arg); + void* arg; +} out_fct_wrap_type; + + +// internal buffer output +static inline void _out_buffer(char character, void* buffer, size_t idx, size_t maxlen) +{ + if (idx < maxlen) { + ((char*)buffer)[idx] = character; + } +} + + +// internal null output +static inline void _out_null(char character, void* buffer, size_t idx, size_t maxlen) +{ + (void)character; (void)buffer; (void)idx; (void)maxlen; +} + + +// internal _putchar wrapper +static inline void _out_char(char character, void* buffer, size_t idx, size_t maxlen) +{ + (void)buffer; (void)idx; (void)maxlen; + if (character) { + _putchar(character); + } +} + + +// internal output function wrapper +static inline void _out_fct(char character, void* buffer, size_t idx, size_t maxlen) +{ + (void)idx; (void)maxlen; + if (character) { + // buffer is the output fct pointer + ((out_fct_wrap_type*)buffer)->fct(character, ((out_fct_wrap_type*)buffer)->arg); + } +} + + +// internal secure strlen +// \return The length of the string (excluding the terminating 0) limited by 'maxsize' +static inline unsigned int _strnlen_s(const char* str, size_t maxsize) +{ + const char* s; + for (s = str; *s && maxsize--; ++s); + return (unsigned int)(s - str); +} + + +// internal test if char is a digit (0-9) +// \return true if char is a digit +static inline bool _is_digit(char ch) +{ + return (ch >= '0') && (ch <= '9'); +} + + +// internal ASCII string to unsigned int conversion +static unsigned int _atoi(const char** str) +{ + unsigned int i = 0U; + while (_is_digit(**str)) { + i = i * 10U + (unsigned int)(*((*str)++) - '0'); + } + return i; +} + + +// output the specified string in reverse, taking care of any zero-padding +static size_t _out_rev(out_fct_type out, char* buffer, size_t idx, size_t maxlen, const char* buf, size_t len, unsigned int width, unsigned int flags) +{ + const size_t start_idx = idx; + + // pad spaces up to given width + if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) { + for (size_t i = len; i < width; i++) { + out(' ', buffer, idx++, maxlen); + } + } + + // reverse string + while (len) { + out(buf[--len], buffer, idx++, maxlen); + } + + // append pad spaces up to given width + if (flags & FLAGS_LEFT) { + while (idx - start_idx < width) { + out(' ', buffer, idx++, maxlen); + } + } + + return idx; +} + + +// internal itoa format +static size_t _ntoa_format(out_fct_type out, char* buffer, size_t idx, size_t maxlen, char* buf, size_t len, bool negative, unsigned int base, unsigned int prec, unsigned int width, unsigned int flags) +{ + // pad leading zeros + if (!(flags & FLAGS_LEFT)) { + if (width && (flags & FLAGS_ZEROPAD) && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) { + width--; + } + while ((len < prec) && (len < PRINTF_NTOA_BUFFER_SIZE)) { + buf[len++] = '0'; + } + while ((flags & FLAGS_ZEROPAD) && (len < width) && (len < PRINTF_NTOA_BUFFER_SIZE)) { + buf[len++] = '0'; + } + } + + // handle hash + if (flags & FLAGS_HASH) { + if (!(flags & FLAGS_PRECISION) && len && ((len == prec) || (len == width))) { + len--; + if (len && (base == 16U)) { + len--; + } + } + if ((base == 16U) && !(flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) { + buf[len++] = 'x'; + } + else if ((base == 16U) && (flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) { + buf[len++] = 'X'; + } + else if ((base == 2U) && (len < PRINTF_NTOA_BUFFER_SIZE)) { + buf[len++] = 'b'; + } + if (len < PRINTF_NTOA_BUFFER_SIZE) { + buf[len++] = '0'; + } + } + + if (len < PRINTF_NTOA_BUFFER_SIZE) { + if (negative) { + buf[len++] = '-'; + } + else if (flags & FLAGS_PLUS) { + buf[len++] = '+'; // ignore the space if the '+' exists + } + else if (flags & FLAGS_SPACE) { + buf[len++] = ' '; + } + } + + return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags); +} + + +// internal itoa for 'long' type +static size_t _ntoa_long(out_fct_type out, char* buffer, size_t idx, size_t maxlen, unsigned long value, bool negative, unsigned long base, unsigned int prec, unsigned int width, unsigned int flags) +{ + char buf[PRINTF_NTOA_BUFFER_SIZE]; + size_t len = 0U; + + // no hash for 0 values + if (!value) { + flags &= ~FLAGS_HASH; + } + + // write if precision != 0 and value is != 0 + if (!(flags & FLAGS_PRECISION) || value) { + do { + const char digit = (char)(value % base); + buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10; + value /= base; + } while (value && (len < PRINTF_NTOA_BUFFER_SIZE)); + } + + return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags); +} + + +// internal itoa for 'long long' type +#if defined(PRINTF_SUPPORT_LONG_LONG) +static size_t _ntoa_long_long(out_fct_type out, char* buffer, size_t idx, size_t maxlen, unsigned long long value, bool negative, unsigned long long base, unsigned int prec, unsigned int width, unsigned int flags) +{ + char buf[PRINTF_NTOA_BUFFER_SIZE]; + size_t len = 0U; + + // no hash for 0 values + if (!value) { + flags &= ~FLAGS_HASH; + } + + // write if precision != 0 and value is != 0 + if (!(flags & FLAGS_PRECISION) || value) { + do { + const char digit = (char)(value % base); + buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10; + value /= base; + } while (value && (len < PRINTF_NTOA_BUFFER_SIZE)); + } + + return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags); +} +#endif // PRINTF_SUPPORT_LONG_LONG + + +#if defined(PRINTF_SUPPORT_FLOAT) + +#if defined(PRINTF_SUPPORT_EXPONENTIAL) +// forward declaration so that _ftoa can switch to exp notation for values > PRINTF_MAX_FLOAT +static size_t _etoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags); +#endif + + +// internal ftoa for fixed decimal floating point +static size_t _ftoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags) +{ + char buf[PRINTF_FTOA_BUFFER_SIZE]; + size_t len = 0U; + double diff = 0.0; + + // powers of 10 + static const double pow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 }; + + // test for special values + if (value != value) + return _out_rev(out, buffer, idx, maxlen, "nan", 3, width, flags); + if (value < -DBL_MAX) + return _out_rev(out, buffer, idx, maxlen, "fni-", 4, width, flags); + if (value > DBL_MAX) + return _out_rev(out, buffer, idx, maxlen, (flags & FLAGS_PLUS) ? "fni+" : "fni", (flags & FLAGS_PLUS) ? 4U : 3U, width, flags); + + // test for very large values + // standard printf behavior is to print EVERY whole number digit -- which could be 100s of characters overflowing your buffers == bad + if ((value > PRINTF_MAX_FLOAT) || (value < -PRINTF_MAX_FLOAT)) { +#if defined(PRINTF_SUPPORT_EXPONENTIAL) + return _etoa(out, buffer, idx, maxlen, value, prec, width, flags); +#else + return 0U; +#endif + } + + // test for negative + bool negative = false; + if (value < 0) { + negative = true; + value = 0 - value; + } + + // set default precision, if not set explicitly + if (!(flags & FLAGS_PRECISION)) { + prec = PRINTF_DEFAULT_FLOAT_PRECISION; + } + // limit precision to 9, cause a prec >= 10 can lead to overflow errors + while ((len < PRINTF_FTOA_BUFFER_SIZE) && (prec > 9U)) { + buf[len++] = '0'; + prec--; + } + + int whole = (int)value; + double tmp = (value - whole) * pow10[prec]; + unsigned long frac = (unsigned long)tmp; + diff = tmp - frac; + + if (diff > 0.5) { + ++frac; + // handle rollover, e.g. case 0.99 with prec 1 is 1.0 + if (frac >= pow10[prec]) { + frac = 0; + ++whole; + } + } + else if (diff < 0.5) { + } + else if ((frac == 0U) || (frac & 1U)) { + // if halfway, round up if odd OR if last digit is 0 + ++frac; + } + + if (prec == 0U) { + diff = value - (double)whole; + if ((!(diff < 0.5) || (diff > 0.5)) && (whole & 1)) { + // exactly 0.5 and ODD, then round up + // 1.5 -> 2, but 2.5 -> 2 + ++whole; + } + } + else { + unsigned int count = prec; + // now do fractional part, as an unsigned number + while (len < PRINTF_FTOA_BUFFER_SIZE) { + --count; + buf[len++] = (char)(48U + (frac % 10U)); + if (!(frac /= 10U)) { + break; + } + } + // add extra 0s + while ((len < PRINTF_FTOA_BUFFER_SIZE) && (count-- > 0U)) { + buf[len++] = '0'; + } + if (len < PRINTF_FTOA_BUFFER_SIZE) { + // add decimal + buf[len++] = '.'; + } + } + + // do whole part, number is reversed + while (len < PRINTF_FTOA_BUFFER_SIZE) { + buf[len++] = (char)(48 + (whole % 10)); + if (!(whole /= 10)) { + break; + } + } + + // pad leading zeros + if (!(flags & FLAGS_LEFT) && (flags & FLAGS_ZEROPAD)) { + if (width && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) { + width--; + } + while ((len < width) && (len < PRINTF_FTOA_BUFFER_SIZE)) { + buf[len++] = '0'; + } + } + + if (len < PRINTF_FTOA_BUFFER_SIZE) { + if (negative) { + buf[len++] = '-'; + } + else if (flags & FLAGS_PLUS) { + buf[len++] = '+'; // ignore the space if the '+' exists + } + else if (flags & FLAGS_SPACE) { + buf[len++] = ' '; + } + } + + return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags); +} + + +#if defined(PRINTF_SUPPORT_EXPONENTIAL) +// internal ftoa variant for exponential floating-point type, contributed by Martijn Jasperse +static size_t _etoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags) +{ + // check for NaN and special values + if ((value != value) || (value > DBL_MAX) || (value < -DBL_MAX)) { + return _ftoa(out, buffer, idx, maxlen, value, prec, width, flags); + } + + // determine the sign + const bool negative = value < 0; + if (negative) { + value = -value; + } + + // default precision + if (!(flags & FLAGS_PRECISION)) { + prec = PRINTF_DEFAULT_FLOAT_PRECISION; + } + + // determine the decimal exponent + // based on the algorithm by David Gay (https://www.ampl.com/netlib/fp/dtoa.c) + union { + uint64_t U; + double F; + } conv; + + conv.F = value; + int exp2 = (int)((conv.U >> 52U) & 0x07FFU) - 1023; // effectively log2 + conv.U = (conv.U & ((1ULL << 52U) - 1U)) | (1023ULL << 52U); // drop the exponent so conv.F is now in [1,2) + // now approximate log10 from the log2 integer part and an expansion of ln around 1.5 + int expval = (int)(0.1760912590558 + exp2 * 0.301029995663981 + (conv.F - 1.5) * 0.289529654602168); + // now we want to compute 10^expval but we want to be sure it won't overflow + exp2 = (int)(expval * 3.321928094887362 + 0.5); + const double z = expval * 2.302585092994046 - exp2 * 0.6931471805599453; + const double z2 = z * z; + conv.U = (uint64_t)(exp2 + 1023) << 52U; + // compute exp(z) using continued fractions, see https://en.wikipedia.org/wiki/Exponential_function#Continued_fractions_for_ex + conv.F *= 1 + 2 * z / (2 - z + (z2 / (6 + (z2 / (10 + z2 / 14))))); + // correct for rounding errors + if (value < conv.F) { + expval--; + conv.F /= 10; + } + + // the exponent format is "%+03d" and largest value is "307", so set aside 4-5 characters + unsigned int minwidth = ((expval < 100) && (expval > -100)) ? 4U : 5U; + + // in "%g" mode, "prec" is the number of *significant figures* not decimals + if (flags & FLAGS_ADAPT_EXP) { + // do we want to fall-back to "%f" mode? + if ((value >= 1e-4) && (value < 1e6)) { + if ((int)prec > expval) { + prec = (unsigned)((int)prec - expval - 1); + } + else { + prec = 0; + } + flags |= FLAGS_PRECISION; // make sure _ftoa respects precision + // no characters in exponent + minwidth = 0U; + expval = 0; + } + else { + // we use one sigfig for the whole part + if ((prec > 0) && (flags & FLAGS_PRECISION)) { + --prec; + } + } + } + + // will everything fit? + unsigned int fwidth = width; + if (width > minwidth) { + // we didn't fall-back so subtract the characters required for the exponent + fwidth -= minwidth; + } else { + // not enough characters, so go back to default sizing + fwidth = 0U; + } + if ((flags & FLAGS_LEFT) && minwidth) { + // if we're padding on the right, DON'T pad the floating part + fwidth = 0U; + } + + // rescale the float value + if (expval) { + value /= conv.F; + } + + // output the floating part + const size_t start_idx = idx; + idx = _ftoa(out, buffer, idx, maxlen, negative ? -value : value, prec, fwidth, flags & ~FLAGS_ADAPT_EXP); + + // output the exponent part + if (minwidth) { + // output the exponential symbol + out((flags & FLAGS_UPPERCASE) ? 'E' : 'e', buffer, idx++, maxlen); + // output the exponent value + idx = _ntoa_long(out, buffer, idx, maxlen, (expval < 0) ? -expval : expval, expval < 0, 10, 0, minwidth-1, FLAGS_ZEROPAD | FLAGS_PLUS); + // might need to right-pad spaces + if (flags & FLAGS_LEFT) { + while (idx - start_idx < width) out(' ', buffer, idx++, maxlen); + } + } + return idx; +} +#endif // PRINTF_SUPPORT_EXPONENTIAL +#endif // PRINTF_SUPPORT_FLOAT + + +// internal vsnprintf +static int _vsnprintf(out_fct_type out, char* buffer, const size_t maxlen, const char* format, va_list va) +{ + unsigned int flags, width, precision, n; + size_t idx = 0U; + + if (!buffer) { + // use null output function + out = _out_null; + } + + while (*format) + { + // format specifier? %[flags][width][.precision][length] + if (*format != '%') { + // no + out(*format, buffer, idx++, maxlen); + format++; + continue; + } + else { + // yes, evaluate it + format++; + } + + // evaluate flags + flags = 0U; + do { + switch (*format) { + case '0': flags |= FLAGS_ZEROPAD; format++; n = 1U; break; + case '-': flags |= FLAGS_LEFT; format++; n = 1U; break; + case '+': flags |= FLAGS_PLUS; format++; n = 1U; break; + case ' ': flags |= FLAGS_SPACE; format++; n = 1U; break; + case '#': flags |= FLAGS_HASH; format++; n = 1U; break; + default : n = 0U; break; + } + } while (n); + + // evaluate width field + width = 0U; + if (_is_digit(*format)) { + width = _atoi(&format); + } + else if (*format == '*') { + const int w = va_arg(va, int); + if (w < 0) { + flags |= FLAGS_LEFT; // reverse padding + width = (unsigned int)-w; + } + else { + width = (unsigned int)w; + } + format++; + } + + // evaluate precision field + precision = 0U; + if (*format == '.') { + flags |= FLAGS_PRECISION; + format++; + if (_is_digit(*format)) { + precision = _atoi(&format); + } + else if (*format == '*') { + const int prec = (int)va_arg(va, int); + precision = prec > 0 ? (unsigned int)prec : 0U; + format++; + } + } + + // evaluate length field + switch (*format) { + case 'l' : + flags |= FLAGS_LONG; + format++; + if (*format == 'l') { + flags |= FLAGS_LONG_LONG; + format++; + } + break; + case 'h' : + flags |= FLAGS_SHORT; + format++; + if (*format == 'h') { + flags |= FLAGS_CHAR; + format++; + } + break; +#if defined(PRINTF_SUPPORT_PTRDIFF_T) + case 't' : + flags |= (sizeof(ptrdiff_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG); + format++; + break; +#endif + case 'j' : + flags |= (sizeof(intmax_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG); + format++; + break; + case 'z' : + flags |= (sizeof(size_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG); + format++; + break; + default : + break; + } + + // evaluate specifier + switch (*format) { + case 'd' : + case 'i' : + case 'u' : + case 'x' : + case 'X' : + case 'o' : + case 'b' : { + // set the base + unsigned int base; + if (*format == 'x' || *format == 'X') { + base = 16U; + } + else if (*format == 'o') { + base = 8U; + } + else if (*format == 'b') { + base = 2U; + } + else { + base = 10U; + flags &= ~FLAGS_HASH; // no hash for dec format + } + // uppercase + if (*format == 'X') { + flags |= FLAGS_UPPERCASE; + } + + // no plus or space flag for u, x, X, o, b + if ((*format != 'i') && (*format != 'd')) { + flags &= ~(FLAGS_PLUS | FLAGS_SPACE); + } + + // ignore '0' flag when precision is given + if (flags & FLAGS_PRECISION) { + flags &= ~FLAGS_ZEROPAD; + } + + // convert the integer + if ((*format == 'i') || (*format == 'd')) { + // signed + if (flags & FLAGS_LONG_LONG) { +#if defined(PRINTF_SUPPORT_LONG_LONG) + const long long value = va_arg(va, long long); + idx = _ntoa_long_long(out, buffer, idx, maxlen, (unsigned long long)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags); +#endif + } + else if (flags & FLAGS_LONG) { + const long value = va_arg(va, long); + idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned long)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags); + } + else { + const int value = (flags & FLAGS_CHAR) ? (char)va_arg(va, int) : (flags & FLAGS_SHORT) ? (short int)va_arg(va, int) : va_arg(va, int); + idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned int)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags); + } + } + else { + // unsigned + if (flags & FLAGS_LONG_LONG) { +#if defined(PRINTF_SUPPORT_LONG_LONG) + idx = _ntoa_long_long(out, buffer, idx, maxlen, va_arg(va, unsigned long long), false, base, precision, width, flags); +#endif + } + else if (flags & FLAGS_LONG) { + idx = _ntoa_long(out, buffer, idx, maxlen, va_arg(va, unsigned long), false, base, precision, width, flags); + } + else { + const unsigned int value = (flags & FLAGS_CHAR) ? (unsigned char)va_arg(va, unsigned int) : (flags & FLAGS_SHORT) ? (unsigned short int)va_arg(va, unsigned int) : va_arg(va, unsigned int); + idx = _ntoa_long(out, buffer, idx, maxlen, value, false, base, precision, width, flags); + } + } + format++; + break; + } +#if defined(PRINTF_SUPPORT_FLOAT) + case 'f' : + case 'F' : + if (*format == 'F') flags |= FLAGS_UPPERCASE; + idx = _ftoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags); + format++; + break; +#if defined(PRINTF_SUPPORT_EXPONENTIAL) + case 'e': + case 'E': + case 'g': + case 'G': + if ((*format == 'g')||(*format == 'G')) flags |= FLAGS_ADAPT_EXP; + if ((*format == 'E')||(*format == 'G')) flags |= FLAGS_UPPERCASE; + idx = _etoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags); + format++; + break; +#endif // PRINTF_SUPPORT_EXPONENTIAL +#endif // PRINTF_SUPPORT_FLOAT + case 'c' : { + unsigned int l = 1U; + // pre padding + if (!(flags & FLAGS_LEFT)) { + while (l++ < width) { + out(' ', buffer, idx++, maxlen); + } + } + // char output + out((char)va_arg(va, int), buffer, idx++, maxlen); + // post padding + if (flags & FLAGS_LEFT) { + while (l++ < width) { + out(' ', buffer, idx++, maxlen); + } + } + format++; + break; + } + + case 's' : { + const char* p = va_arg(va, char*); + unsigned int l = _strnlen_s(p, precision ? precision : (size_t)-1); + // pre padding + if (flags & FLAGS_PRECISION) { + l = (l < precision ? l : precision); + } + if (!(flags & FLAGS_LEFT)) { + while (l++ < width) { + out(' ', buffer, idx++, maxlen); + } + } + // string output + while ((*p != 0) && (!(flags & FLAGS_PRECISION) || precision--)) { + out(*(p++), buffer, idx++, maxlen); + } + // post padding + if (flags & FLAGS_LEFT) { + while (l++ < width) { + out(' ', buffer, idx++, maxlen); + } + } + format++; + break; + } + + case 'p' : { + width = sizeof(void*) * 2U; + flags |= FLAGS_ZEROPAD | FLAGS_UPPERCASE; +#if defined(PRINTF_SUPPORT_LONG_LONG) + const bool is_ll = sizeof(uintptr_t) == sizeof(long long); + if (is_ll) { + idx = _ntoa_long_long(out, buffer, idx, maxlen, (uintptr_t)va_arg(va, void*), false, 16U, precision, width, flags); + } + else { +#endif + idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned long)((uintptr_t)va_arg(va, void*)), false, 16U, precision, width, flags); +#if defined(PRINTF_SUPPORT_LONG_LONG) + } +#endif + format++; + break; + } + + case '%' : + out('%', buffer, idx++, maxlen); + format++; + break; + + default : + out(*format, buffer, idx++, maxlen); + format++; + break; + } + } + + // termination + out((char)0, buffer, idx < maxlen ? idx : maxlen - 1U, maxlen); + + // return written chars without terminating \0 + return (int)idx; +} + + +/////////////////////////////////////////////////////////////////////////////// + +int printf_(const char* format, ...) +{ + va_list va; + va_start(va, format); + char buffer[1]; + const int ret = _vsnprintf(_out_char, buffer, (size_t)-1, format, va); + va_end(va); + return ret; +} + + +int sprintf_(char* buffer, const char* format, ...) +{ + va_list va; + va_start(va, format); + const int ret = _vsnprintf(_out_buffer, buffer, (size_t)-1, format, va); + va_end(va); + return ret; +} + + +int snprintf_(char* buffer, size_t count, const char* format, ...) +{ + va_list va; + va_start(va, format); + const int ret = _vsnprintf(_out_buffer, buffer, count, format, va); + va_end(va); + return ret; +} + + +int vprintf_(const char* format, va_list va) +{ + char buffer[1]; + return _vsnprintf(_out_char, buffer, (size_t)-1, format, va); +} + + +int vsnprintf_(char* buffer, size_t count, const char* format, va_list va) +{ + return _vsnprintf(_out_buffer, buffer, count, format, va); +} + +typedef long word; /* "word" used for optimal copy speed */ +#define wsize sizeof(word) +#define wmask (wsize - 1) + +#ifdef MEMCOPY +void * +memcpy(void *dst0, const void *src0, size_t length) +#else +#ifdef MEMMOVE +void * +memmove(void *dst0, const void *src0, size_t length) +#else +void +bcopy(const void *src0, void *dst0, size_t length) +#endif +#endif +{ + char *dst = dst0; + const char *src = src0; + size_t t; + if (length == 0 || dst == src) /* nothing to do */ + goto done; + /* + * Macros: loop-t-times; and loop-t-times, t>0 + */ +#define TLOOP(s) if (t) TLOOP1(s) +#define TLOOP1(s) do { s; } while (--t) + if ((unsigned long)dst < (unsigned long)src) { + /* + * Copy forward. + */ + t = (long)src; /* only need low bits */ + if ((t | (long)dst) & wmask) { + /* + * Try to align operands. This cannot be done + * unless the low bits match. + */ + if ((t ^ (long)dst) & wmask || length < wsize) + t = length; + else + t = wsize - (t & wmask); + length -= t; + TLOOP1(*dst++ = *src++); + } + /* + * Copy whole words, then mop up any trailing bytes. + */ + t = length / wsize; + TLOOP(*(word *)dst = *(word *)src; src += wsize; dst += wsize); + t = length & wmask; + TLOOP(*dst++ = *src++); + } else { + /* + * Copy backwards. Otherwise essentially the same. + * Alignment works as before, except that it takes + * (t&wmask) bytes to align, not wsize-(t&wmask). + */ + src += length; + dst += length; + t = (long)src; + if ((t | (long)dst) & wmask) { + if ((t ^ (long)dst) & wmask || length <= wsize) + t = length; + else + t &= wmask; + length -= t; + TLOOP1(*--dst = *--src); + } + t = length / wsize; + TLOOP(src -= wsize; dst -= wsize; *(word *)dst = *(word *)src); + t = length & wmask; + TLOOP(*--dst = *--src); + } +done: +#if defined(MEMCOPY) || defined(MEMMOVE) + return (dst0); +#else + return; +#endif +} \ No newline at end of file diff --git a/services/ffi-test/sys/ffi/libc.h b/services/ffi-test/sys/ffi/libc.h new file mode 100644 index 000000000..0f2824fae --- /dev/null +++ b/services/ffi-test/sys/ffi/libc.h @@ -0,0 +1,49 @@ +#include +#include + +wchar_t *wcschr(const wchar_t *s, wchar_t c); +size_t wcslen(const wchar_t *s); +char *strstr(const char *s, const char *find); +char* strcpy(char *, const char *); +char* strchr(const char *, int); +int strcmp(const char *, const char *); +char* strcat(char *, const char *); +char* strdup(const char *); +char* strncpy(char *, const char *, size_t); +int atoi(const char *); + +int memcmp(const void *, const void *, size_t); +void * memcpy (void *dest, const void *src, size_t len); +void * memset (void *dest, int val, size_t len); +size_t strlen(const char *); + +#define sprintf sprintf_ +int sprintf_(char* buffer, const char* format, ...); + +#define snprintf snprintf_ +int snprintf_(char* buffer, size_t count, const char* format, ...); + +#define printf printf_ +int printf_(const char* format, ...); + +char *strtok(char *s, const char *delim); +int sscanf(const char *, const char *, ...); +char *strtok_r(char *s, const char *delim, char **last); +intmax_t strtoimax(const char *nptr, char **endptr, int base); +unsigned long strtoul(const char *nptr, char **endptr, int base); +long strtol(const char *nptr, char **endptr, int base); +void bcopy(const void *src0, void *dst0, size_t length); + +// this is a lie, we don't have an errno, but we always return...something. +int* __errno(void); + +extern void* malloc(size_t); +void* calloc(size_t, size_t); +extern void* realloc(void *, size_t); +extern void free(void *); + +extern void libc_putchar(char c); +void _putchar(char c); + +#define RAND_MAX 0x7fffffff +long rand(void); \ No newline at end of file diff --git a/services/ffi-test/sys/ffi/scanf.c b/services/ffi-test/sys/ffi/scanf.c new file mode 100644 index 000000000..f6eee8d2b --- /dev/null +++ b/services/ffi-test/sys/ffi/scanf.c @@ -0,0 +1,578 @@ +#include "libc.h" +#include +#include +#include + +#include +#include +#include + +#define BUF 32 /* Maximum length of numeric string. */ + +/* + * Flags used during conversion. + */ +#define LONG 0x01 /* l: long or double */ +#define SHORT 0x04 /* h: short */ +#define SUPPRESS 0x08 /* *: suppress assignment */ +#define POINTER 0x10 /* p: void * (as hex) */ +#define NOSKIP 0x20 /* [ or c: do not skip blanks */ +#define LONGLONG 0x400 /* ll: long long (+ deprecated q: quad) */ +#define SHORTSHORT 0x4000 /* hh: char */ +#define UNSIGNED 0x8000 /* %[oupxX] conversions */ + +/* + * The following are used in numeric conversions only: + * SIGNOK, NDIGITS, DPTOK, and EXPOK are for floating point; + * SIGNOK, NDIGITS, PFXOK, and NZDIGITS are for integral. + */ +#define SIGNOK 0x40 /* +/- is (still) legal */ +#define NDIGITS 0x80 /* no digits detected */ + +#define DPTOK 0x100 /* (float) decimal point is still legal */ +#define EXPOK 0x200 /* (float) exponent (e+3, etc) still legal */ + +#define PFXOK 0x100 /* 0x prefix is (still) legal */ +#define NZDIGITS 0x200 /* no zero digits detected */ + +/* + * Conversion types. + */ +#define CT_CHAR 0 /* %c conversion */ +#define CT_CCL 1 /* %[...] conversion */ +#define CT_STRING 2 /* %s conversion */ +#define CT_INT 3 /* %[dioupxX] conversion */ + +static const unsigned char *__sccl(char *, const unsigned char *); +int vsscanf(const char *inp, char const *fmt0, va_list ap); + +int +sscanf(const char *ibuf, const char *fmt, ...) +{ + va_list ap; + int ret; + + va_start(ap, fmt); + ret = vsscanf(ibuf, fmt, ap); + va_end(ap); + return(ret); +} + +int +vsscanf(const char *inp, char const *fmt0, va_list ap) +{ + int inr; + const unsigned char *fmt = (const unsigned char *)fmt0; + int c; /* character from format, or conversion */ + size_t width; /* field width, or 0 */ + char *p; /* points into all kinds of strings */ + int n; /* handy integer */ + int flags; /* flags as defined above */ + char *p0; /* saves original value of p when necessary */ + int nassigned; /* number of fields assigned */ + int nconversions; /* number of conversions */ + int nread; /* number of characters consumed from fp */ + int base; /* base argument to conversion function */ + char ccltab[256]; /* character class table for %[...] */ + char buf[BUF]; /* buffer for numeric conversions */ + + /* `basefix' is used to avoid `if' tests in the integer scanner */ + static short basefix[17] = + { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; + + inr = strlen(inp); + + nassigned = 0; + nconversions = 0; + nread = 0; + base = 0; /* XXX just to keep gcc happy */ + for (;;) { + c = *fmt++; + if (c == 0) + return (nassigned); + if (isspace(c)) { + while (inr > 0 && isspace(*inp)) + nread++, inr--, inp++; + continue; + } + if (c != '%') + goto literal; + width = 0; + flags = 0; + /* + * switch on the format. continue if done; + * break once format type is derived. + */ +again: c = *fmt++; + switch (c) { + case '%': +literal: + if (inr <= 0) + goto input_failure; + if (*inp != c) + goto match_failure; + inr--, inp++; + nread++; + continue; + + case '*': + flags |= SUPPRESS; + goto again; + case 'l': + if (flags & LONG) { + flags &= ~LONG; + flags |= LONGLONG; + } else + flags |= LONG; + goto again; + case 'q': + flags |= LONGLONG; /* not quite */ + goto again; + case 'h': + if (flags & SHORT) { + flags &= ~SHORT; + flags |= SHORTSHORT; + } else + flags |= SHORT; + goto again; + + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + width = width * 10 + c - '0'; + goto again; + + /* + * Conversions. + */ + case 'd': + c = CT_INT; + base = 10; + break; + + case 'i': + c = CT_INT; + base = 0; + break; + + case 'o': + c = CT_INT; + flags |= UNSIGNED; + base = 8; + break; + + case 'u': + c = CT_INT; + flags |= UNSIGNED; + base = 10; + break; + + case 'X': + case 'x': + flags |= PFXOK; /* enable 0x prefixing */ + c = CT_INT; + flags |= UNSIGNED; + base = 16; + break; + + case 's': + c = CT_STRING; + break; + + case '[': + fmt = __sccl(ccltab, fmt); + flags |= NOSKIP; + c = CT_CCL; + break; + + case 'c': + flags |= NOSKIP; + c = CT_CHAR; + break; + + case 'p': /* pointer format is like hex */ + flags |= POINTER | PFXOK; + c = CT_INT; + flags |= UNSIGNED; + base = 16; + break; + } + + /* + * We have a conversion that requires input. + */ + if (inr <= 0) + goto input_failure; + + /* + * Consume leading white space, except for formats + * that suppress this. + */ + if ((flags & NOSKIP) == 0) { + while (isspace(*inp)) { + nread++; + if (--inr > 0) + inp++; + else + goto input_failure; + } + /* + * Note that there is at least one character in + * the buffer, so conversions that do not set NOSKIP + * can no longer result in an input failure. + */ + } + + /* + * Do the conversion. + */ + switch (c) { + + case CT_CHAR: + /* scan arbitrary characters (sets NOSKIP) */ + if (width == 0) + width = 1; + if (flags & SUPPRESS) { + size_t sum = 0; + for (;;) { + if ((n = inr) < (int)width) { + sum += n; + width -= n; + inp += n; + if (sum == 0) + goto input_failure; + break; + } else { + sum += width; + inr -= width; + inp += width; + break; + } + } + nread += sum; + } else { + bcopy(inp, va_arg(ap, char *), width); + inr -= width; + inp += width; + nread += width; + nassigned++; + } + nconversions++; + break; + + case CT_CCL: + /* scan a (nonempty) character class (sets NOSKIP) */ + if (width == 0) + width = (size_t)~0; /* `infinity' */ + /* take only those things in the class */ + if (flags & SUPPRESS) { + n = 0; + while (ccltab[(unsigned char)*inp]) { + n++, inr--, inp++; + if (--width == 0) + break; + if (inr <= 0) { + if (n == 0) + goto input_failure; + break; + } + } + if (n == 0) + goto match_failure; + } else { + p0 = p = va_arg(ap, char *); + while (ccltab[(unsigned char)*inp]) { + inr--; + *p++ = *inp++; + if (--width == 0) + break; + if (inr <= 0) { + if (p == p0) + goto input_failure; + break; + } + } + n = p - p0; + if (n == 0) + goto match_failure; + *p = 0; + nassigned++; + } + nread += n; + nconversions++; + break; + + case CT_STRING: + /* like CCL, but zero-length string OK, & no NOSKIP */ + if (width == 0) + width = (size_t)~0; + if (flags & SUPPRESS) { + n = 0; + while (!isspace(*inp)) { + n++, inr--, inp++; + if (--width == 0) + break; + if (inr <= 0) + break; + } + nread += n; + } else { + p0 = p = va_arg(ap, char *); + while (!isspace(*inp)) { + inr--; + *p++ = *inp++; + if (--width == 0) + break; + if (inr <= 0) + break; + } + *p = 0; + nread += p - p0; + nassigned++; + } + nconversions++; + continue; + + case CT_INT: + /* scan an integer as if by the conversion function */ +#ifdef hardway + if (width == 0 || width > sizeof(buf) - 1) + width = sizeof(buf) - 1; +#else + /* size_t is unsigned, hence this optimisation */ + if (--width > sizeof(buf) - 2) + width = sizeof(buf) - 2; + width++; +#endif + flags |= SIGNOK | NDIGITS | NZDIGITS; + for (p = buf; width; width--) { + c = *inp; + /* + * Switch on the character; `goto ok' + * if we accept it as a part of number. + */ + switch (c) { + + /* + * The digit 0 is always legal, but is + * special. For %i conversions, if no + * digits (zero or nonzero) have been + * scanned (only signs), we will have + * base==0. In that case, we should set + * it to 8 and enable 0x prefixing. + * Also, if we have not scanned zero digits + * before this, do not turn off prefixing + * (someone else will turn it off if we + * have scanned any nonzero digits). + */ + case '0': + if (base == 0) { + base = 8; + flags |= PFXOK; + } + if (flags & NZDIGITS) + flags &= ~(SIGNOK|NZDIGITS|NDIGITS); + else + flags &= ~(SIGNOK|PFXOK|NDIGITS); + goto ok; + + /* 1 through 7 always legal */ + case '1': case '2': case '3': + case '4': case '5': case '6': case '7': + base = basefix[base]; + flags &= ~(SIGNOK | PFXOK | NDIGITS); + goto ok; + + /* digits 8 and 9 ok iff decimal or hex */ + case '8': case '9': + base = basefix[base]; + if (base <= 8) + break; /* not legal here */ + flags &= ~(SIGNOK | PFXOK | NDIGITS); + goto ok; + + /* letters ok iff hex */ + case 'A': case 'B': case 'C': + case 'D': case 'E': case 'F': + case 'a': case 'b': case 'c': + case 'd': case 'e': case 'f': + /* no need to fix base here */ + if (base <= 10) + break; /* not legal here */ + flags &= ~(SIGNOK | PFXOK | NDIGITS); + goto ok; + + /* sign ok only as first character */ + case '+': case '-': + if (flags & SIGNOK) { + flags &= ~SIGNOK; + goto ok; + } + break; + + /* x ok iff flag still set & 2nd char */ + case 'x': case 'X': + if (flags & PFXOK && p == buf + 1) { + base = 16; /* if %i */ + flags &= ~PFXOK; + goto ok; + } + break; + } + + /* + * If we got here, c is not a legal character + * for a number. Stop accumulating digits. + */ + break; + ok: + /* + * c is legal: store it and look at the next. + */ + *p++ = c; + if (--inr > 0) + inp++; + else + break; /* end of input */ + } + /* + * If we had only a sign, it is no good; push + * back the sign. If the number ends in `x', + * it was [sign] '0' 'x', so push back the x + * and treat it as [sign] '0'. + */ + if (flags & NDIGITS) { + if (p > buf) { + inp--; + inr++; + } + goto match_failure; + } + c = ((unsigned char *)p)[-1]; + if (c == 'x' || c == 'X') { + --p; + inp--; + inr++; + } + if ((flags & SUPPRESS) == 0) { + unsigned long res; + + *p = 0; + if ((flags & UNSIGNED) == 0) + res = strtol(buf, (char **)NULL, base); + else + res = strtoul(buf, (char **)NULL, base); + if (flags & POINTER) + *va_arg(ap, void **) = + (void *)(uintptr_t)res; + else if (flags & SHORTSHORT) + *va_arg(ap, char *) = res; + else if (flags & SHORT) + *va_arg(ap, short *) = res; + else if (flags & LONG) + *va_arg(ap, long *) = res; + else + *va_arg(ap, int *) = res; + nassigned++; + } + nread += p - buf; + nconversions++; + break; + + } + } +input_failure: + return (nconversions != 0 ? nassigned : -1); +match_failure: + return (nassigned); +} + +/* + * Fill in the given table from the scanset at the given format + * (just after `['). Return a pointer to the character past the + * closing `]'. The table has a 1 wherever characters should be + * considered part of the scanset. + */ +static const unsigned char * +__sccl(char *tab, const unsigned char *fmt) +{ + int c, n, v; + + /* first `clear' the whole table */ + c = *fmt++; /* first char hat => negated scanset */ + if (c == '^') { + v = 1; /* default => accept */ + c = *fmt++; /* get new first char */ + } else + v = 0; /* default => reject */ + + /* XXX: Will not work if sizeof(tab*) > sizeof(char) */ + memset((void *) tab, v, 256); + + if (c == 0) + return (fmt - 1);/* format ended before closing ] */ + + /* + * Now set the entries corresponding to the actual scanset + * to the opposite of the above. + * + * The first character may be ']' (or '-') without being special; + * the last character may be '-'. + */ + v = 1 - v; + for (;;) { + tab[c] = v; /* take character c */ +doswitch: + n = *fmt++; /* and examine the next */ + switch (n) { + + case 0: /* format ended too soon */ + return (fmt - 1); + + case '-': + /* + * A scanset of the form + * [01+-] + * is defined as `the digit 0, the digit 1, + * the character +, the character -', but + * the effect of a scanset such as + * [a-zA-Z0-9] + * is implementation defined. The V7 Unix + * scanf treats `a-z' as `the letters a through + * z', but treats `a-a' as `the letter a, the + * character -, and the letter a'. + * + * For compatibility, the `-' is not considerd + * to define a range if the character following + * it is either a close bracket (required by ANSI) + * or is not numerically greater than the character + * we just stored in the table (c). + */ + n = *fmt; + if (n == ']' || n < c) { + c = '-'; + break; /* resume the for(;;) */ + } + fmt++; + /* fill in the range */ + do { + tab[++c] = v; + } while (c < n); + c = n; + /* + * Alas, the V7 Unix scanf also treats formats + * such as [a-c-e] as `the letters a through e'. + * This too is permitted by the standard.... + */ + goto doswitch; + break; + + case ']': /* end of scanset */ + return (fmt); + + default: /* just another character */ + c = n; + break; + } + } + /* NOTREACHED */ +} \ No newline at end of file diff --git a/services/ffi-test/sys/src/lib.rs b/services/ffi-test/sys/src/lib.rs new file mode 100644 index 000000000..eaa440a94 --- /dev/null +++ b/services/ffi-test/sys/src/lib.rs @@ -0,0 +1,9 @@ +#![allow(nonstandard_style)] + +#[cfg(test)] +mod tests { + #[test] + fn it_works() { + assert_eq!(2 + 2, 4); + } +} \ No newline at end of file From 199ce642b3810ed2a712032db6524cdd30dcc105 Mon Sep 17 00:00:00 2001 From: bunnie Date: Mon, 7 Mar 2022 14:02:19 +0800 Subject: [PATCH 3/6] ok this is the version that works, let's start from here. --- services/ffi-test/sys/ffi/libc.c | 810 ++----------------------------- xtask/src/main.rs | 3 +- 2 files changed, 55 insertions(+), 758 deletions(-) diff --git a/services/ffi-test/sys/ffi/libc.c b/services/ffi-test/sys/ffi/libc.c index 0fefef167..495496cf3 100644 --- a/services/ffi-test/sys/ffi/libc.c +++ b/services/ffi-test/sys/ffi/libc.c @@ -1,6 +1,3 @@ -#ifdef LOCAL_TEST -#include "../config.h" -#endif #include #include #include @@ -22,56 +19,13 @@ #include "libc.h" void _putchar(char c) { -#ifdef LOCAL_TEST - putchar(c); -#else - libc_putchar(c); -#endif + libc_putchar(c); +} +void* calloc(size_t nmemb, size_t size) { + // the underlying malloc will clear to 0 + return malloc(nmemb * size); } -#define RAND48_SEED_0 (0x330e) -#define RAND48_SEED_1 (0xabcd) -#define RAND48_SEED_2 (0x1234) -#define RAND48_MULT_0 (0xe66d) -#define RAND48_MULT_1 (0xdeec) -#define RAND48_MULT_2 (0x0005) -#define RAND48_ADD (0x000b) -unsigned short __rand48_seed[3] = { - RAND48_SEED_0, - RAND48_SEED_1, - RAND48_SEED_2 -}; -unsigned short __rand48_mult[3] = { - RAND48_MULT_0, - RAND48_MULT_1, - RAND48_MULT_2 -}; -unsigned short __rand48_add = RAND48_ADD; -void -__dorand48(unsigned short xseed[3]) -{ - unsigned long accu; - unsigned short temp[2]; - accu = (unsigned long) __rand48_mult[0] * (unsigned long) xseed[0] + - (unsigned long) __rand48_add; - temp[0] = (unsigned short) accu; /* lower 16 bits */ - accu >>= sizeof(unsigned short) * 8; - accu += (unsigned long) __rand48_mult[0] * (unsigned long) xseed[1] + - (unsigned long) __rand48_mult[1] * (unsigned long) xseed[0]; - temp[1] = (unsigned short) accu; /* middle 16 bits */ - accu >>= sizeof(unsigned short) * 8; - accu += __rand48_mult[0] * xseed[2] + __rand48_mult[1] * xseed[1] + __rand48_mult[2] * xseed[0]; - xseed[0] = temp[0]; - xseed[1] = temp[1]; - xseed[2] = (unsigned short) accu; -} -long -rand(void) -{ - __dorand48(__rand48_seed); - return ((long) __rand48_seed[2] << 15) + ((long) __rand48_seed[1] >> 1); -} -// much code ganked from https://android.googlesource.com/platform/bionic/+/ics-mr0/libc/ (BSD 3-clause) #define CTYPE_NUM_CHARS 256 const char _ctype_[1 + CTYPE_NUM_CHARS] = { @@ -110,7 +64,11 @@ const char _ctype_[1 + CTYPE_NUM_CHARS] = { _P, _P, _P, _P, _P, _P, _P, _P, /* F0 */ _P, _P, _P, _P, _P, _P, _P, _P /* F8 */ }; -//const char *_ctype_ = _C_ctype_; + +/////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////// +// printf // 'ntoa' conversion buffer size, this must be big enough to hold one converted // numeric number including padded zeros (dynamically created on stack) @@ -163,8 +121,6 @@ const char _ctype_[1 + CTYPE_NUM_CHARS] = { #define PRINTF_SUPPORT_PTRDIFF_T #endif -/////////////////////////////////////////////////////////////////////////////// - // internal flag definitions #define FLAGS_ZEROPAD (1U << 0U) #define FLAGS_LEFT (1U << 1U) @@ -184,634 +140,7 @@ int local_errno = 134; // ENOTSUP int* __errno(void) { return &local_errno; } -wchar_t * -wcschr(const wchar_t *s, wchar_t c) -{ - while (*s != c && *s != L'\0') - s++; - if (*s == c) - return ((wchar_t *)s); - return (NULL); -} -size_t -wcslen(const wchar_t *s) -{ - const wchar_t *p; - p = s; - while (*p) - p++; - return p - s; -} -int -strncmp(const char *s1, const char *s2, size_t n) -{ - if (n == 0) - return (0); - do { - if (*s1 != *s2++) - return (*(unsigned char *)s1 - *(unsigned char *)--s2); - if (*s1++ == 0) - break; - } while (--n != 0); - return (0); -} -char * -strstr(const char *s, const char *find) -{ - char c, sc; - size_t len; - if ((c = *find++) != 0) { - len = strlen(find); - do { - do { - if ((sc = *s++) == 0) - return (NULL); - } while (sc != c); - } while (strncmp(s, find, len) != 0); - s--; - } - return ((char *)s); -} -char * -strchr (register const char *s, int c) -{ - do { - if (*s == c) - { - return (char*)s; - } - } while (*s++); - return (0); -} -char * -strcpy(char *to, const char *from) -{ - char *save = to; - for (; (*to = *from) != '\0'; ++from, ++to); - return(save); -} - -int -strcmp(const char *s1, const char *s2) -{ - while (*s1 == *s2++) - if (*s1++ == 0) - return (0); - return (*(unsigned char *)s1 - *(unsigned char *)--s2); -} - -char * -strcat(char *s, const char *append) -{ - char *save = s; - for (; *s; ++s); - while ((*s++ = *append++) != '\0'); - return(save); -} - -void * -memcpy (void *dest, const void *src, size_t len) -{ - char *d = dest; - const char *s = src; - while (len--) - *d++ = *s++; - return dest; -} - -void * -memset (void *dest, int val, size_t len) -{ - unsigned char *ptr = dest; - while (len-- > 0) - *ptr++ = val; - return dest; -} - -size_t -strlen(const char *str) -{ - const char *s; - for (s = str; *s; ++s) - ; - return (s - str); -} - -char * -strdup(const char *str) -{ - size_t siz; - char *copy; - siz = strlen(str) + 1; - if ((copy = malloc(siz)) == NULL) - return(NULL); - (void)memcpy(copy, str, siz); - return(copy); -} - -char * -strncpy(char *dst, const char *src, size_t n) -{ - if (n != 0) { - char *d = dst; - const char *s = src; - do { - if ((*d++ = *s++) == 0) { - /* NUL pad the remaining n-1 bytes */ - while (--n != 0) - *d++ = 0; - break; - } - } while (--n != 0); - } - return (dst); -} - -long -strtol(const char *nptr, char **endptr, int base) -{ - const char *s; - long acc, cutoff; - int c; - int neg, any, cutlim; - /* - * Skip white space and pick up leading +/- sign if any. - * If base is 0, allow 0x for hex and 0 for octal, else - * assume decimal; if base is already 16, allow 0x. - */ - s = nptr; - do { - c = (unsigned char) *s++; - } while (isspace(c)); - if (c == '-') { - neg = 1; - c = *s++; - } else { - neg = 0; - if (c == '+') - c = *s++; - } - if ((base == 0 || base == 16) && - c == '0' && (*s == 'x' || *s == 'X')) { - c = s[1]; - s += 2; - base = 16; - } - if (base == 0) - base = c == '0' ? 8 : 10; - /* - * Compute the cutoff value between legal numbers and illegal - * numbers. That is the largest legal value, divided by the - * base. An input number that is greater than this value, if - * followed by a legal input character, is too big. One that - * is equal to this value may be valid or not; the limit - * between valid and invalid numbers is then based on the last - * digit. For instance, if the range for longs is - * [-2147483648..2147483647] and the input base is 10, - * cutoff will be set to 214748364 and cutlim to either - * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated - * a value > 214748364, or equal but the next digit is > 7 (or 8), - * the number is too big, and we will return a range error. - * - * Set any if any `digits' consumed; make it negative to indicate - * overflow. - */ - cutoff = neg ? LONG_MIN : LONG_MAX; - cutlim = cutoff % base; - cutoff /= base; - if (neg) { - if (cutlim > 0) { - cutlim -= base; - cutoff += 1; - } - cutlim = -cutlim; - } - for (acc = 0, any = 0;; c = (unsigned char) *s++) { - if (isdigit(c)) - c -= '0'; - else if (isalpha(c)) - c -= isupper(c) ? 'A' - 10 : 'a' - 10; - else - break; - if (c >= base) - break; - if (any < 0) - continue; - if (neg) { - if (acc < cutoff || (acc == cutoff && c > cutlim)) { - any = -1; - acc = LONG_MIN; - errno = ERANGE; - } else { - any = 1; - acc *= base; - acc -= c; - } - } else { - if (acc > cutoff || (acc == cutoff && c > cutlim)) { - any = -1; - acc = LONG_MAX; - errno = ERANGE; - } else { - any = 1; - acc *= base; - acc += c; - } - } - } - if (endptr != 0) - *endptr = (char *) (any ? s - 1 : nptr); - return (acc); -} - -unsigned long -strtoul(const char *nptr, char **endptr, int base) -{ - const char *s; - unsigned long acc, cutoff; - int c; - int neg, any, cutlim; - /* - * See strtol for comments as to the logic used. - */ - s = nptr; - do { - c = (unsigned char) *s++; - } while (isspace(c)); - if (c == '-') { - neg = 1; - c = *s++; - } else { - neg = 0; - if (c == '+') - c = *s++; - } - if ((base == 0 || base == 16) && - c == '0' && (*s == 'x' || *s == 'X')) { - c = s[1]; - s += 2; - base = 16; - } - if (base == 0) - base = c == '0' ? 8 : 10; - cutoff = ULONG_MAX / (unsigned long)base; - cutlim = ULONG_MAX % (unsigned long)base; - for (acc = 0, any = 0;; c = (unsigned char) *s++) { - if (isdigit(c)) - c -= '0'; - else if (isalpha(c)) - c -= isupper(c) ? 'A' - 10 : 'a' - 10; - else - break; - if (c >= base) - break; - if (any < 0) - continue; - if (acc > cutoff || (acc == cutoff && c > cutlim)) { - any = -1; - acc = ULONG_MAX; - errno = ERANGE; - } else { - any = 1; - acc *= (unsigned long)base; - acc += c; - } - } - if (neg && any > 0) - acc = -acc; - if (endptr != 0) - *endptr = (char *) (any ? s - 1 : nptr); - return (acc); -} - -uintmax_t -strtoumax(const char *nptr, char **endptr, int base) -{ - const char *s; - uintmax_t acc, cutoff; - int c; - int neg, any, cutlim; - /* - * See strtoq for comments as to the logic used. - */ - s = nptr; - do { - c = (unsigned char) *s++; - } while (isspace(c)); - if (c == '-') { - neg = 1; - c = *s++; - } else { - neg = 0; - if (c == '+') - c = *s++; - } - if ((base == 0 || base == 16) && - c == '0' && (*s == 'x' || *s == 'X')) { - c = s[1]; - s += 2; - base = 16; - } - if (base == 0) - base = c == '0' ? 8 : 10; - /* BIONIC: avoid division and modulo for common cases */ -#define CASE_BASE(x) \ - case x: cutoff = UINTMAX_MAX / x; \ - cutlim = UINTMAX_MAX % x; \ - break - switch (base) { - CASE_BASE(8); - CASE_BASE(10); - CASE_BASE(16); - default: - cutoff = UINTMAX_MAX / base; - cutlim = UINTMAX_MAX % base; - } - for (acc = 0, any = 0;; c = (unsigned char) *s++) { - if (isdigit(c)) - c -= '0'; - else if (isalpha(c)) - c -= isupper(c) ? 'A' - 10 : 'a' - 10; - else - break; - if (c >= base) - break; - if (any < 0) - continue; - if (acc > cutoff || (acc == cutoff && c > cutlim)) { - any = -1; - acc = UINTMAX_MAX; - errno = ERANGE; - } else { - any = 1; - acc *= (uintmax_t)base; - acc += c; - } - } - if (neg && any > 0) - acc = -acc; - if (endptr != 0) - *endptr = (char *) (any ? s - 1 : nptr); - return (acc); -} -static inline int digitval(int ch) -{ - unsigned d; - d = (unsigned)(ch - '0'); - if (d < 10) return (int)d; - d = (unsigned)(ch - 'a'); - if (d < 6) return (int)(d+10); - d = (unsigned)(ch - 'A'); - if (d < 6) return (int)(d+10); - return -1; -} -uintmax_t -strntoumax(const char *nptr, char **endptr, int base, size_t n) -{ - const unsigned char* p = (const unsigned char *)nptr; - const unsigned char* end = p + n; - int minus = 0; - uintmax_t v = 0; - int d; - /* skip leading space */ - while (p < end && isspace(*p)) - p++; - /* Single optional + or - */ - if (p < end) { - char c = p[0]; - if ( c == '-' || c == '+' ) { - minus = (c == '-'); - p++; - } - } - if ( base == 0 ) { - if ( p+2 < end && p[0] == '0' && (p[1] == 'x' || p[1] == 'X') ) { - p += 2; - base = 16; - } else if ( p+1 < end && p[0] == '0' ) { - p += 1; - base = 8; - } else { - base = 10; - } - } else if ( base == 16 ) { - if ( p+2 < end && p[0] == '0' && (p[1] == 'x' || p[1] == 'X') ) { - p += 2; - } - } - while ( p < end && (d = digitval(*p)) >= 0 && d < base ) { - v = v*base + d; - p += 1; - } - if ( endptr ) - *endptr = (char *)p; - return minus ? -v : v; -} -intmax_t strntoimax(const char *nptr, char **endptr, int base, size_t n) -{ - return (intmax_t) strntoumax(nptr, endptr, base, n); -} -intmax_t -strtoimax(const char *nptr, char **endptr, int base) -{ - const char *s; - intmax_t acc, cutoff; - int c; - int neg, any, cutlim; - /* - * Skip white space and pick up leading +/- sign if any. - * If base is 0, allow 0x for hex and 0 for octal, else - * assume decimal; if base is already 16, allow 0x. - */ - s = nptr; - do { - c = (unsigned char) *s++; - } while (isspace(c)); - if (c == '-') { - neg = 1; - c = *s++; - } else { - neg = 0; - if (c == '+') - c = *s++; - } - if ((base == 0 || base == 16) && - c == '0' && (*s == 'x' || *s == 'X')) { - c = s[1]; - s += 2; - base = 16; - } - if (base == 0) - base = c == '0' ? 8 : 10; - /* - * Compute the cutoff value between legal numbers and illegal - * numbers. That is the largest legal value, divided by the - * base. An input number that is greater than this value, if - * followed by a legal input character, is too big. One that - * is equal to this value may be valid or not; the limit - * between valid and invalid numbers is then based on the last - * digit. For instance, if the range for intmax_t is - * [-9223372036854775808..9223372036854775807] and the input base - * is 10, cutoff will be set to 922337203685477580 and cutlim to - * either 7 (neg==0) or 8 (neg==1), meaning that if we have - * accumulated a value > 922337203685477580, or equal but the - * next digit is > 7 (or 8), the number is too big, and we will - * return a range error. - * - * Set any if any `digits' consumed; make it negative to indicate - * overflow. - */ - /* BIONIC: avoid division and module for common cases */ -#define CASE_BASE2(x) \ - case x: \ - if (neg) { \ - cutlim = INTMAX_MIN % x; \ - cutoff = INTMAX_MIN / x; \ - } else { \ - cutlim = INTMAX_MAX % x; \ - cutoff = INTMAX_MAX / x; \ - }; \ - break - - switch (base) { - case 4: - if (neg) { - cutlim = (int)(INTMAX_MIN % 4); - cutoff = INTMAX_MIN / 4; - } else { - cutlim = (int)(INTMAX_MAX % 4); - cutoff = INTMAX_MAX / 4; - } - break; - CASE_BASE2(8); - CASE_BASE2(10); - CASE_BASE2(16); - default: - cutoff = neg ? INTMAX_MIN : INTMAX_MAX; - cutlim = cutoff % base; - cutoff /= base; - } -#undef CASE_BASE - - if (neg) { - if (cutlim > 0) { - cutlim -= base; - cutoff += 1; - } - cutlim = -cutlim; - } - for (acc = 0, any = 0;; c = (unsigned char) *s++) { - if (isdigit(c)) - c -= '0'; - else if (isalpha(c)) - c -= isupper(c) ? 'A' - 10 : 'a' - 10; - else - break; - if (c >= base) - break; - if (any < 0) - continue; - if (neg) { - if (acc < cutoff || (acc == cutoff && c > cutlim)) { - any = -1; - acc = INTMAX_MIN; - errno = ERANGE; - } else { - any = 1; - acc *= base; - acc -= c; - } - } else { - if (acc > cutoff || (acc == cutoff && c > cutlim)) { - any = -1; - acc = INTMAX_MAX; - errno = ERANGE; - } else { - any = 1; - acc *= base; - acc += c; - } - } - } - if (endptr != 0) - *endptr = (char *) (any ? s - 1 : nptr); - return (acc); -} -int atoi(const char* s) -{ - return (int)strtoimax(s, NULL, 10); -} - -int memcmp(const void *s1, const void *s2, size_t n) -{ - const unsigned char* p1 = s1; - const unsigned char* end1 = p1 + n; - const unsigned char* p2 = s2; - int d = 0; - for (;;) { - if (d || p1 >= end1) break; - d = (int)*p1++ - (int)*p2++; - if (d || p1 >= end1) break; - d = (int)*p1++ - (int)*p2++; - if (d || p1 >= end1) break; - d = (int)*p1++ - (int)*p2++; - if (d || p1 >= end1) break; - d = (int)*p1++ - (int)*p2++; - } - return d; -} - -char * -strtok(char *s, const char *delim) -{ - static char *last; - return strtok_r(s, delim, &last); -} -char * -strtok_r(char *s, const char *delim, char **last) -{ - char *spanp; - int c, sc; - char *tok; - if (s == NULL && (s = *last) == NULL) - return (NULL); - /* - * Skip (span) leading delimiters (s += strspn(s, delim), sort of). - */ -cont: - c = *s++; - for (spanp = (char *)delim; (sc = *spanp++) != 0;) { - if (c == sc) - goto cont; - } - if (c == 0) { /* no non-delimiter characters */ - *last = NULL; - return (NULL); - } - tok = s - 1; - /* - * Scan token (scan for delimiters: s += strcspn(s, delim), sort of). - * Note that delim must have one NUL; we stop if we see that, too. - */ - for (;;) { - c = *s++; - spanp = (char *)delim; - do { - if ((sc = *spanp++) == c) { - if (c == 0) - s = NULL; - else - s[-1] = 0; - *last = s; - return (tok); - } - } while (sc != 0); - } - /* NOTREACHED */ -} - -// from https://github.com/mpaland/printf // output function type typedef void (*out_fct_type)(char character, void* buffer, size_t idx, size_t maxlen); @@ -1596,83 +925,50 @@ int vsnprintf_(char* buffer, size_t count, const char* format, va_list va) return _vsnprintf(_out_buffer, buffer, count, format, va); } -typedef long word; /* "word" used for optimal copy speed */ -#define wsize sizeof(word) -#define wmask (wsize - 1) +/////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////// +// rand -#ifdef MEMCOPY -void * -memcpy(void *dst0, const void *src0, size_t length) -#else -#ifdef MEMMOVE -void * -memmove(void *dst0, const void *src0, size_t length) -#else +#define RAND48_SEED_0 (0x330e) +#define RAND48_SEED_1 (0xabcd) +#define RAND48_SEED_2 (0x1234) +#define RAND48_MULT_0 (0xe66d) +#define RAND48_MULT_1 (0xdeec) +#define RAND48_MULT_2 (0x0005) +#define RAND48_ADD (0x000b) +unsigned short __rand48_seed[3] = { + RAND48_SEED_0, + RAND48_SEED_1, + RAND48_SEED_2 +}; +unsigned short __rand48_mult[3] = { + RAND48_MULT_0, + RAND48_MULT_1, + RAND48_MULT_2 +}; +unsigned short __rand48_add = RAND48_ADD; void -bcopy(const void *src0, void *dst0, size_t length) -#endif -#endif +__dorand48(unsigned short xseed[3]) { - char *dst = dst0; - const char *src = src0; - size_t t; - if (length == 0 || dst == src) /* nothing to do */ - goto done; - /* - * Macros: loop-t-times; and loop-t-times, t>0 - */ -#define TLOOP(s) if (t) TLOOP1(s) -#define TLOOP1(s) do { s; } while (--t) - if ((unsigned long)dst < (unsigned long)src) { - /* - * Copy forward. - */ - t = (long)src; /* only need low bits */ - if ((t | (long)dst) & wmask) { - /* - * Try to align operands. This cannot be done - * unless the low bits match. - */ - if ((t ^ (long)dst) & wmask || length < wsize) - t = length; - else - t = wsize - (t & wmask); - length -= t; - TLOOP1(*dst++ = *src++); - } - /* - * Copy whole words, then mop up any trailing bytes. - */ - t = length / wsize; - TLOOP(*(word *)dst = *(word *)src; src += wsize; dst += wsize); - t = length & wmask; - TLOOP(*dst++ = *src++); - } else { - /* - * Copy backwards. Otherwise essentially the same. - * Alignment works as before, except that it takes - * (t&wmask) bytes to align, not wsize-(t&wmask). - */ - src += length; - dst += length; - t = (long)src; - if ((t | (long)dst) & wmask) { - if ((t ^ (long)dst) & wmask || length <= wsize) - t = length; - else - t &= wmask; - length -= t; - TLOOP1(*--dst = *--src); - } - t = length / wsize; - TLOOP(src -= wsize; dst -= wsize; *(word *)dst = *(word *)src); - t = length & wmask; - TLOOP(*--dst = *--src); - } -done: -#if defined(MEMCOPY) || defined(MEMMOVE) - return (dst0); -#else - return; -#endif + unsigned long accu; + unsigned short temp[2]; + accu = (unsigned long) __rand48_mult[0] * (unsigned long) xseed[0] + + (unsigned long) __rand48_add; + temp[0] = (unsigned short) accu; /* lower 16 bits */ + accu >>= sizeof(unsigned short) * 8; + accu += (unsigned long) __rand48_mult[0] * (unsigned long) xseed[1] + + (unsigned long) __rand48_mult[1] * (unsigned long) xseed[0]; + temp[1] = (unsigned short) accu; /* middle 16 bits */ + accu >>= sizeof(unsigned short) * 8; + accu += __rand48_mult[0] * xseed[2] + __rand48_mult[1] * xseed[1] + __rand48_mult[2] * xseed[0]; + xseed[0] = temp[0]; + xseed[1] = temp[1]; + xseed[2] = (unsigned short) accu; +} +long +rand(void) +{ + __dorand48(__rand48_seed); + return ((long) __rand48_seed[2] << 15) + ((long) __rand48_seed[1] >> 1); } \ No newline at end of file diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 3532f1fac..24c6e3f8b 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -213,7 +213,8 @@ fn main() -> Result<(), Box> { Some("ffi-test") => { let mut args = env::args(); args.nth(1); - let mut pkgs = hw_pkgs.to_vec(); + //let mut pkgs = hw_pkgs.to_vec(); + let mut pkgs = gfx_dev_pkgs.to_vec(); pkgs.push("ffi-test"); let args: Vec = args.collect(); let mut extra_packages = vec![]; From 3878208a8b789a8f608ef33dc621e34931b8448a Mon Sep 17 00:00:00 2001 From: bunnie Date: Mon, 7 Mar 2022 14:54:18 +0800 Subject: [PATCH 4/6] found the problem...mem* functions are provided in Rust the libc implementation was overriding key Rust symbols by re-implementing mem* calls. "oops". --- services/ffi-test/src/bindings.rs | 6 +- services/ffi-test/sys/build.rs | 1 + services/ffi-test/sys/ffi/ffi.c | 35 ++ services/ffi-test/sys/ffi/libc_split.c | 651 +++++++++++++++++++++++++ 4 files changed, 690 insertions(+), 3 deletions(-) create mode 100644 services/ffi-test/sys/ffi/libc_split.c diff --git a/services/ffi-test/src/bindings.rs b/services/ffi-test/src/bindings.rs index 782ca964c..062ca59ed 100644 --- a/services/ffi-test/src/bindings.rs +++ b/services/ffi-test/src/bindings.rs @@ -105,7 +105,6 @@ pub unsafe extern "C" fn realloc( Some(index) => { log::info!("realloc/free success: {:x}", ptr as usize); let mut old = C_HEAP.remove(index); - old.clear(); let checked_size = if size == 0 { 1 // at least 1 element so we have a pointer we can pass back } else { @@ -113,9 +112,10 @@ pub unsafe extern "C" fn realloc( }; let mut alloc: Vec:: = Vec::with_capacity(checked_size as usize); let ret_ptr = alloc.as_mut_ptr(); - for (&src, dst) in old.iter().zip(alloc.iter_mut()) { - *dst = src; + for &src in old.iter() { + alloc.push(src); } + old.clear(); C_HEAP.push(alloc); log::info!("realloc/allocated: {:x}", ret_ptr as usize); diff --git a/services/ffi-test/sys/build.rs b/services/ffi-test/sys/build.rs index 22379f901..8cb10a09f 100644 --- a/services/ffi-test/sys/build.rs +++ b/services/ffi-test/sys/build.rs @@ -8,6 +8,7 @@ fn main() { let espeak_srcs = vec![ "ffi/ffi.c", "ffi/libc.c", + "ffi/libc_split.c", "ffi/scanf.c", ]; let espeak_includes = vec![ diff --git a/services/ffi-test/sys/ffi/ffi.c b/services/ffi-test/sys/ffi/ffi.c index 3fbe36289..4821c0ea6 100644 --- a/services/ffi-test/sys/ffi/ffi.c +++ b/services/ffi-test/sys/ffi/ffi.c @@ -51,6 +51,41 @@ int malloc_test() { for (i = size-1; i >= 0; i--) { free(p[i]); } + + char *foo = malloc(200); + for (i = 0; i < 200; i++) { + foo[i] = (char)i; + } + char *bar = malloc(200); + memcpy(bar, foo, 200); + if (memcmp(foo, bar, 200) != 0) { + printf("fail on alloc and copy\n"); + } else { + printf("pass on alloc and copy\n"); + } + char *baz = realloc(foo, 300); + int mresult = memcmp(baz, bar, 200); + if (mresult != 0) { + printf("fail on realloc copy: %d\n", mresult); + for (i = 0; i < 200; i++) { + if (bar[i] != baz[i]) { + printf(" fail bar[%d](%d) != baz[%d](%d)\n", i, bar[i], i, baz[i]); + } + } + } else { + printf("pass on realloc copy \n"); + } + memset(baz, 42, 300); + int pass = 1; + for (i = 0; i < 300; i++) { + if (baz[i] != 42) { + printf("fail on memset\n"); + pass = 0; + } + } + if (pass == 1) { + printf("memset passed\n"); + } /* int x = 6; char *** matrix = alloc_matrix(x, x); diff --git a/services/ffi-test/sys/ffi/libc_split.c b/services/ffi-test/sys/ffi/libc_split.c new file mode 100644 index 000000000..389132df3 --- /dev/null +++ b/services/ffi-test/sys/ffi/libc_split.c @@ -0,0 +1,651 @@ +#ifdef LOCAL_TEST +#include "../config.h" +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "libc.h" + +/* +void * +memcpy (void *dest, const void *src, size_t len) +{ + char *d = dest; + const char *s = src; + while (len--) + *d++ = *s++; + return dest; +} + +void * +memset (void *dest, int val, size_t len) +{ + unsigned char *ptr = dest; + while (len-- > 0) + *ptr++ = val; + return dest; +} + +int memcmp(const void *s1, const void *s2, size_t n) +{ + const unsigned char* p1 = s1; + const unsigned char* end1 = p1 + n; + const unsigned char* p2 = s2; + int d = 0; + for (;;) { + if (d || p1 >= end1) break; + d = (int)*p1++ - (int)*p2++; + if (d || p1 >= end1) break; + d = (int)*p1++ - (int)*p2++; + if (d || p1 >= end1) break; + d = (int)*p1++ - (int)*p2++; + if (d || p1 >= end1) break; + d = (int)*p1++ - (int)*p2++; + } + return d; +} +*/ + +wchar_t * +wcschr(const wchar_t *s, wchar_t c) +{ + while (*s != c && *s != L'\0') + s++; + if (*s == c) + return ((wchar_t *)s); + return (NULL); +} +size_t +wcslen(const wchar_t *s) +{ + const wchar_t *p; + p = s; + while (*p) + p++; + return p - s; +} +int +strncmp(const char *s1, const char *s2, size_t n) +{ + if (n == 0) + return (0); + do { + if (*s1 != *s2++) + return (*(unsigned char *)s1 - *(unsigned char *)--s2); + if (*s1++ == 0) + break; + } while (--n != 0); + return (0); +} +char * +strstr(const char *s, const char *find) +{ + char c, sc; + size_t len; + if ((c = *find++) != 0) { + len = strlen(find); + do { + do { + if ((sc = *s++) == 0) + return (NULL); + } while (sc != c); + } while (strncmp(s, find, len) != 0); + s--; + } + return ((char *)s); +} +char * +strchr (register const char *s, int c) +{ + do { + if (*s == c) + { + return (char*)s; + } + } while (*s++); + return (0); +} + +char * +strcpy(char *to, const char *from) +{ + char *save = to; + for (; (*to = *from) != '\0'; ++from, ++to); + return(save); +} + +int +strcmp(const char *s1, const char *s2) +{ + while (*s1 == *s2++) + if (*s1++ == 0) + return (0); + return (*(unsigned char *)s1 - *(unsigned char *)--s2); +} + +char * +strcat(char *s, const char *append) +{ + char *save = s; + for (; *s; ++s); + while ((*s++ = *append++) != '\0'); + return(save); +} + +size_t +strlen(const char *str) +{ + const char *s; + for (s = str; *s; ++s) + ; + return (s - str); +} + +char * +strdup(const char *str) +{ + size_t siz; + char *copy; + siz = strlen(str) + 1; + if ((copy = malloc(siz)) == NULL) + return(NULL); + (void)memcpy(copy, str, siz); + return(copy); +} + +char * +strncpy(char *dst, const char *src, size_t n) +{ + if (n != 0) { + char *d = dst; + const char *s = src; + do { + if ((*d++ = *s++) == 0) { + /* NUL pad the remaining n-1 bytes */ + while (--n != 0) + *d++ = 0; + break; + } + } while (--n != 0); + } + return (dst); +} + +long +strtol(const char *nptr, char **endptr, int base) +{ + const char *s; + long acc, cutoff; + int c; + int neg, any, cutlim; + /* + * Skip white space and pick up leading +/- sign if any. + * If base is 0, allow 0x for hex and 0 for octal, else + * assume decimal; if base is already 16, allow 0x. + */ + s = nptr; + do { + c = (unsigned char) *s++; + } while (isspace(c)); + if (c == '-') { + neg = 1; + c = *s++; + } else { + neg = 0; + if (c == '+') + c = *s++; + } + if ((base == 0 || base == 16) && + c == '0' && (*s == 'x' || *s == 'X')) { + c = s[1]; + s += 2; + base = 16; + } + if (base == 0) + base = c == '0' ? 8 : 10; + /* + * Compute the cutoff value between legal numbers and illegal + * numbers. That is the largest legal value, divided by the + * base. An input number that is greater than this value, if + * followed by a legal input character, is too big. One that + * is equal to this value may be valid or not; the limit + * between valid and invalid numbers is then based on the last + * digit. For instance, if the range for longs is + * [-2147483648..2147483647] and the input base is 10, + * cutoff will be set to 214748364 and cutlim to either + * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated + * a value > 214748364, or equal but the next digit is > 7 (or 8), + * the number is too big, and we will return a range error. + * + * Set any if any `digits' consumed; make it negative to indicate + * overflow. + */ + cutoff = neg ? LONG_MIN : LONG_MAX; + cutlim = cutoff % base; + cutoff /= base; + if (neg) { + if (cutlim > 0) { + cutlim -= base; + cutoff += 1; + } + cutlim = -cutlim; + } + for (acc = 0, any = 0;; c = (unsigned char) *s++) { + if (isdigit(c)) + c -= '0'; + else if (isalpha(c)) + c -= isupper(c) ? 'A' - 10 : 'a' - 10; + else + break; + if (c >= base) + break; + if (any < 0) + continue; + if (neg) { + if (acc < cutoff || (acc == cutoff && c > cutlim)) { + any = -1; + acc = LONG_MIN; + errno = ERANGE; + } else { + any = 1; + acc *= base; + acc -= c; + } + } else { + if (acc > cutoff || (acc == cutoff && c > cutlim)) { + any = -1; + acc = LONG_MAX; + errno = ERANGE; + } else { + any = 1; + acc *= base; + acc += c; + } + } + } + if (endptr != 0) + *endptr = (char *) (any ? s - 1 : nptr); + return (acc); +} + +unsigned long +strtoul(const char *nptr, char **endptr, int base) +{ + const char *s; + unsigned long acc, cutoff; + int c; + int neg, any, cutlim; + /* + * See strtol for comments as to the logic used. + */ + s = nptr; + do { + c = (unsigned char) *s++; + } while (isspace(c)); + if (c == '-') { + neg = 1; + c = *s++; + } else { + neg = 0; + if (c == '+') + c = *s++; + } + if ((base == 0 || base == 16) && + c == '0' && (*s == 'x' || *s == 'X')) { + c = s[1]; + s += 2; + base = 16; + } + if (base == 0) + base = c == '0' ? 8 : 10; + cutoff = ULONG_MAX / (unsigned long)base; + cutlim = ULONG_MAX % (unsigned long)base; + for (acc = 0, any = 0;; c = (unsigned char) *s++) { + if (isdigit(c)) + c -= '0'; + else if (isalpha(c)) + c -= isupper(c) ? 'A' - 10 : 'a' - 10; + else + break; + if (c >= base) + break; + if (any < 0) + continue; + if (acc > cutoff || (acc == cutoff && c > cutlim)) { + any = -1; + acc = ULONG_MAX; + errno = ERANGE; + } else { + any = 1; + acc *= (unsigned long)base; + acc += c; + } + } + if (neg && any > 0) + acc = -acc; + if (endptr != 0) + *endptr = (char *) (any ? s - 1 : nptr); + return (acc); +} + +uintmax_t +strtoumax(const char *nptr, char **endptr, int base) +{ + const char *s; + uintmax_t acc, cutoff; + int c; + int neg, any, cutlim; + /* + * See strtoq for comments as to the logic used. + */ + s = nptr; + do { + c = (unsigned char) *s++; + } while (isspace(c)); + if (c == '-') { + neg = 1; + c = *s++; + } else { + neg = 0; + if (c == '+') + c = *s++; + } + if ((base == 0 || base == 16) && + c == '0' && (*s == 'x' || *s == 'X')) { + c = s[1]; + s += 2; + base = 16; + } + if (base == 0) + base = c == '0' ? 8 : 10; + /* BIONIC: avoid division and modulo for common cases */ +#define CASE_BASE(x) \ + case x: cutoff = UINTMAX_MAX / x; \ + cutlim = UINTMAX_MAX % x; \ + break + switch (base) { + CASE_BASE(8); + CASE_BASE(10); + CASE_BASE(16); + default: + cutoff = UINTMAX_MAX / base; + cutlim = UINTMAX_MAX % base; + } + for (acc = 0, any = 0;; c = (unsigned char) *s++) { + if (isdigit(c)) + c -= '0'; + else if (isalpha(c)) + c -= isupper(c) ? 'A' - 10 : 'a' - 10; + else + break; + if (c >= base) + break; + if (any < 0) + continue; + if (acc > cutoff || (acc == cutoff && c > cutlim)) { + any = -1; + acc = UINTMAX_MAX; + errno = ERANGE; + } else { + any = 1; + acc *= (uintmax_t)base; + acc += c; + } + } + if (neg && any > 0) + acc = -acc; + if (endptr != 0) + *endptr = (char *) (any ? s - 1 : nptr); + return (acc); +} +static inline int digitval(int ch) +{ + unsigned d; + d = (unsigned)(ch - '0'); + if (d < 10) return (int)d; + d = (unsigned)(ch - 'a'); + if (d < 6) return (int)(d+10); + d = (unsigned)(ch - 'A'); + if (d < 6) return (int)(d+10); + return -1; +} +uintmax_t +strntoumax(const char *nptr, char **endptr, int base, size_t n) +{ + const unsigned char* p = (const unsigned char *)nptr; + const unsigned char* end = p + n; + int minus = 0; + uintmax_t v = 0; + int d; + /* skip leading space */ + while (p < end && isspace(*p)) + p++; + /* Single optional + or - */ + if (p < end) { + char c = p[0]; + if ( c == '-' || c == '+' ) { + minus = (c == '-'); + p++; + } + } + if ( base == 0 ) { + if ( p+2 < end && p[0] == '0' && (p[1] == 'x' || p[1] == 'X') ) { + p += 2; + base = 16; + } else if ( p+1 < end && p[0] == '0' ) { + p += 1; + base = 8; + } else { + base = 10; + } + } else if ( base == 16 ) { + if ( p+2 < end && p[0] == '0' && (p[1] == 'x' || p[1] == 'X') ) { + p += 2; + } + } + while ( p < end && (d = digitval(*p)) >= 0 && d < base ) { + v = v*base + d; + p += 1; + } + if ( endptr ) + *endptr = (char *)p; + return minus ? -v : v; +} +intmax_t strntoimax(const char *nptr, char **endptr, int base, size_t n) +{ + return (intmax_t) strntoumax(nptr, endptr, base, n); +} +intmax_t +strtoimax(const char *nptr, char **endptr, int base) +{ + const char *s; + intmax_t acc, cutoff; + int c; + int neg, any, cutlim; + /* + * Skip white space and pick up leading +/- sign if any. + * If base is 0, allow 0x for hex and 0 for octal, else + * assume decimal; if base is already 16, allow 0x. + */ + s = nptr; + do { + c = (unsigned char) *s++; + } while (isspace(c)); + if (c == '-') { + neg = 1; + c = *s++; + } else { + neg = 0; + if (c == '+') + c = *s++; + } + if ((base == 0 || base == 16) && + c == '0' && (*s == 'x' || *s == 'X')) { + c = s[1]; + s += 2; + base = 16; + } + if (base == 0) + base = c == '0' ? 8 : 10; + /* + * Compute the cutoff value between legal numbers and illegal + * numbers. That is the largest legal value, divided by the + * base. An input number that is greater than this value, if + * followed by a legal input character, is too big. One that + * is equal to this value may be valid or not; the limit + * between valid and invalid numbers is then based on the last + * digit. For instance, if the range for intmax_t is + * [-9223372036854775808..9223372036854775807] and the input base + * is 10, cutoff will be set to 922337203685477580 and cutlim to + * either 7 (neg==0) or 8 (neg==1), meaning that if we have + * accumulated a value > 922337203685477580, or equal but the + * next digit is > 7 (or 8), the number is too big, and we will + * return a range error. + * + * Set any if any `digits' consumed; make it negative to indicate + * overflow. + */ + /* BIONIC: avoid division and module for common cases */ +#define CASE_BASE2(x) \ + case x: \ + if (neg) { \ + cutlim = INTMAX_MIN % x; \ + cutoff = INTMAX_MIN / x; \ + } else { \ + cutlim = INTMAX_MAX % x; \ + cutoff = INTMAX_MAX / x; \ + }; \ + break + + switch (base) { + case 4: + if (neg) { + cutlim = (int)(INTMAX_MIN % 4); + cutoff = INTMAX_MIN / 4; + } else { + cutlim = (int)(INTMAX_MAX % 4); + cutoff = INTMAX_MAX / 4; + } + break; + CASE_BASE2(8); + CASE_BASE2(10); + CASE_BASE2(16); + default: + cutoff = neg ? INTMAX_MIN : INTMAX_MAX; + cutlim = cutoff % base; + cutoff /= base; + } +#undef CASE_BASE + + if (neg) { + if (cutlim > 0) { + cutlim -= base; + cutoff += 1; + } + cutlim = -cutlim; + } + for (acc = 0, any = 0;; c = (unsigned char) *s++) { + if (isdigit(c)) + c -= '0'; + else if (isalpha(c)) + c -= isupper(c) ? 'A' - 10 : 'a' - 10; + else + break; + if (c >= base) + break; + if (any < 0) + continue; + if (neg) { + if (acc < cutoff || (acc == cutoff && c > cutlim)) { + any = -1; + acc = INTMAX_MIN; + errno = ERANGE; + } else { + any = 1; + acc *= base; + acc -= c; + } + } else { + if (acc > cutoff || (acc == cutoff && c > cutlim)) { + any = -1; + acc = INTMAX_MAX; + errno = ERANGE; + } else { + any = 1; + acc *= base; + acc += c; + } + } + } + if (endptr != 0) + *endptr = (char *) (any ? s - 1 : nptr); + return (acc); +} +int atoi(const char* s) +{ + return (int)strtoimax(s, NULL, 10); +} + +char * +strtok(char *s, const char *delim) +{ + static char *last; + return strtok_r(s, delim, &last); +} +char * +strtok_r(char *s, const char *delim, char **last) +{ + char *spanp; + int c, sc; + char *tok; + if (s == NULL && (s = *last) == NULL) + return (NULL); + /* + * Skip (span) leading delimiters (s += strspn(s, delim), sort of). + */ +cont: + c = *s++; + for (spanp = (char *)delim; (sc = *spanp++) != 0;) { + if (c == sc) + goto cont; + } + if (c == 0) { /* no non-delimiter characters */ + *last = NULL; + return (NULL); + } + tok = s - 1; + /* + * Scan token (scan for delimiters: s += strcspn(s, delim), sort of). + * Note that delim must have one NUL; we stop if we see that, too. + */ + for (;;) { + c = *s++; + spanp = (char *)delim; + do { + if ((sc = *spanp++) == c) { + if (c == 0) + s = NULL; + else + s[-1] = 0; + *last = s; + return (tok); + } + } while (sc != 0); + } + /* NOTREACHED */ +} From d1a471b51c5c54f4ad35b782703320d6b54e4fc0 Mon Sep 17 00:00:00 2001 From: bunnie Date: Tue, 8 Mar 2022 00:17:16 +0800 Subject: [PATCH 5/6] clean up the ffi-test library for integration to main checked all licenses, added some comments, etc. --- services/ffi-test/src/lib.rs | 5 +- services/ffi-test/src/main.rs | 2 - services/ffi-test/sys/build.rs | 18 ++------ services/ffi-test/sys/ffi/ffi.c | 38 +-------------- services/ffi-test/sys/ffi/libc.c | 9 ++-- services/ffi-test/sys/ffi/libc.h | 3 +- services/ffi-test/sys/ffi/libc_split.c | 64 +++++++++++--------------- services/ffi-test/sys/ffi/scanf.c | 59 ++++++++++++++++++++++++ 8 files changed, 100 insertions(+), 98 deletions(-) diff --git a/services/ffi-test/src/lib.rs b/services/ffi-test/src/lib.rs index 3f0444afa..041ef210e 100644 --- a/services/ffi-test/src/lib.rs +++ b/services/ffi-test/src/lib.rs @@ -1,8 +1,9 @@ #![cfg_attr(target_os = "none", no_std)] pub mod api; -use xous::{CID, send_message}; -use num_traits::ToPrimitive; +use xous::CID; + +/// A test stub for checking FFI integration routines. pub struct FfiTest { conn: CID, diff --git a/services/ffi-test/src/main.rs b/services/ffi-test/src/main.rs index dca818036..03d67c924 100644 --- a/services/ffi-test/src/main.rs +++ b/services/ffi-test/src/main.rs @@ -10,8 +10,6 @@ pub use bindings::*; use num_traits::FromPrimitive; -use utralib::utra::ticktimer; - #[xous::xous_main] fn xmain() -> ! { log_server::init_wait().unwrap(); diff --git a/services/ffi-test/sys/build.rs b/services/ffi-test/sys/build.rs index 8cb10a09f..7b2911db9 100644 --- a/services/ffi-test/sys/build.rs +++ b/services/ffi-test/sys/build.rs @@ -5,34 +5,24 @@ use std::env::set_var; fn main() { set_var("CC", "riscv64-unknown-elf-gcc"); // set the compiler to what's installed on the system - let espeak_srcs = vec![ + let ffi_srcs = vec![ "ffi/ffi.c", "ffi/libc.c", "ffi/libc_split.c", "ffi/scanf.c", ]; - let espeak_includes = vec![ + let ffi_includes = vec![ "./", - // "espeak-ng/src", - // "espeak-ng/src/include/compat", - // "espeak-ng/src/include/espeak", - // "espeak-ng/src/include/espeak-ng", - // "espeak-ng/src/ucd-tools/src/include", - // "espeak-ng/src/include", ]; let mut base_config = cc::Build::new(); base_config.target("riscv32imac-unknown-none-elf"); - for inc in espeak_includes { + for inc in ffi_includes { base_config.include(inc); } - base_config.include("C:\\Users\\bunnie\\riscv64\\riscv64-unknown-elf\\include"); - base_config.include("C:\\Users\\bunnie\\riscv64\\riscv64-unknown-elf\\include\\sys"); - base_config.include("C:\\Users\\bunnie\\riscv64\\riscv64-unknown-elf\\include\\machine"); - base_config.include("C:\\Users\\bunnie\\riscv64\\riscv64-unknown-elf\\include\\bits"); - for src in espeak_srcs { + for src in ffi_srcs { base_config.file(src); } base_config.define("XOUS", None); diff --git a/services/ffi-test/sys/ffi/ffi.c b/services/ffi-test/sys/ffi/ffi.c index 4821c0ea6..97df7033f 100644 --- a/services/ffi-test/sys/ffi/ffi.c +++ b/services/ffi-test/sys/ffi/ffi.c @@ -6,37 +6,6 @@ int add_one(int a) { return a + 1; } -/* returns an array of arrays of char*, all of which NULL */ -char ***alloc_matrix(unsigned rows, unsigned columns) { - char ***matrix = malloc(rows * sizeof(char **)); - unsigned row = 0; - unsigned column = 0; - if (!matrix) return NULL; - - for (row = 0; row < rows; row++) { - matrix[row] = calloc(columns, sizeof(char *)); - if (!matrix[row]) return NULL; - for (column = 0; column < columns; column++) { - matrix[row][column] = NULL; - } - } - return matrix; -} - -/* deallocates an array of arrays of char*, calling free() on each */ -void free_matrix(char ***matrix, unsigned rows, unsigned columns) { - unsigned row = 0; - unsigned column = 0; - for (row = 0; row < rows; row++) { - for (column = 0; column < columns; column++) { - printf("column %d row %d\n", column, row); - free(matrix[row][column]); - } - free(matrix[row]); - } - free(matrix); -} - int malloc_test() { int i; @@ -86,11 +55,6 @@ int malloc_test() { if (pass == 1) { printf("memset passed\n"); } - /* - int x = 6; - char *** matrix = alloc_matrix(x, x); - if (matrix == NULL) return 1; - free_matrix(matrix, x, x); - */ + return (0); } diff --git a/services/ffi-test/sys/ffi/libc.c b/services/ffi-test/sys/ffi/libc.c index 495496cf3..5a9a6e8c9 100644 --- a/services/ffi-test/sys/ffi/libc.c +++ b/services/ffi-test/sys/ffi/libc.c @@ -26,7 +26,8 @@ void* calloc(size_t nmemb, size_t size) { return malloc(nmemb * size); } - +// ctype table from https://android.googlesource.com/platform/bionic/+/779585f/libc/stdlib/ctype_.c +// openBSD licensed #define CTYPE_NUM_CHARS 256 const char _ctype_[1 + CTYPE_NUM_CHARS] = { 0, @@ -68,7 +69,7 @@ const char _ctype_[1 + CTYPE_NUM_CHARS] = { /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// -// printf +// printf is from https://github.com/mpaland/printf (MIT license) // 'ntoa' conversion buffer size, this must be big enough to hold one converted // numeric number including padded zeros (dynamically created on stack) @@ -966,9 +967,9 @@ __dorand48(unsigned short xseed[3]) xseed[1] = temp[1]; xseed[2] = (unsigned short) accu; } -long +int rand(void) { __dorand48(__rand48_seed); - return ((long) __rand48_seed[2] << 15) + ((long) __rand48_seed[1] >> 1); + return ((int) __rand48_seed[2] << 15) + ((int) __rand48_seed[1] >> 1); } \ No newline at end of file diff --git a/services/ffi-test/sys/ffi/libc.h b/services/ffi-test/sys/ffi/libc.h index 0f2824fae..2c4c9b0b1 100644 --- a/services/ffi-test/sys/ffi/libc.h +++ b/services/ffi-test/sys/ffi/libc.h @@ -45,5 +45,4 @@ extern void free(void *); extern void libc_putchar(char c); void _putchar(char c); -#define RAND_MAX 0x7fffffff -long rand(void); \ No newline at end of file +int rand(void); \ No newline at end of file diff --git a/services/ffi-test/sys/ffi/libc_split.c b/services/ffi-test/sys/ffi/libc_split.c index 389132df3..891585786 100644 --- a/services/ffi-test/sys/ffi/libc_split.c +++ b/services/ffi-test/sys/ffi/libc_split.c @@ -21,45 +21,35 @@ #include "libc.h" +// libc code lifted from the android open source project https://android.googlesource.com/platform/bionic/+/ics-mr0/libc /* -void * -memcpy (void *dest, const void *src, size_t len) -{ - char *d = dest; - const char *s = src; - while (len--) - *d++ = *s++; - return dest; -} + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ -void * -memset (void *dest, int val, size_t len) -{ - unsigned char *ptr = dest; - while (len-- > 0) - *ptr++ = val; - return dest; -} - -int memcmp(const void *s1, const void *s2, size_t n) -{ - const unsigned char* p1 = s1; - const unsigned char* end1 = p1 + n; - const unsigned char* p2 = s2; - int d = 0; - for (;;) { - if (d || p1 >= end1) break; - d = (int)*p1++ - (int)*p2++; - if (d || p1 >= end1) break; - d = (int)*p1++ - (int)*p2++; - if (d || p1 >= end1) break; - d = (int)*p1++ - (int)*p2++; - if (d || p1 >= end1) break; - d = (int)*p1++ - (int)*p2++; - } - return d; -} -*/ wchar_t * wcschr(const wchar_t *s, wchar_t c) diff --git a/services/ffi-test/sys/ffi/scanf.c b/services/ffi-test/sys/ffi/scanf.c index f6eee8d2b..19a8846fd 100644 --- a/services/ffi-test/sys/ffi/scanf.c +++ b/services/ffi-test/sys/ffi/scanf.c @@ -7,6 +7,65 @@ #include #include +// scanf code is from https://opensource.apple.com/source/xnu/xnu-792/libkern/stdio/scanf.c.auto.html +/* + * Copyright (c) 2004 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this + * file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/*- + * Copyright (c) 1990, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + #define BUF 32 /* Maximum length of numeric string. */ /* From 6d697691dbf8f4c2dfd055928c2a8256aea1edc9 Mon Sep 17 00:00:00 2001 From: bunnie Date: Tue, 8 Mar 2022 00:19:27 +0800 Subject: [PATCH 6/6] add doc string for ffi-test --- xtask/src/main.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 24c6e3f8b..2aa183602 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -223,7 +223,6 @@ fn main() -> Result<(), Box> { } build_hw_image(false, Some("./precursors/soc.svd".to_string()), &pkgs, None, None, None, &[], Some(&["--features", "renode-bypass"]))? - //renode_image(false, &pkgs, extra_packages.as_slice(), //None, Some(&["--features", "renode-bypass"]))?; } @@ -451,6 +450,7 @@ Various debug configurations: pddb-dev PDDB testing only for live hardware pddb-hosted PDDB testing in a hosted environment pddb-ci PDDB config for CI testing (eg: TRNG->deterministic for reproducible errors) + ffi-test builds an image for testing C-FFI bindings and integration " )