vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removed all function pointers in FILE, moved internal functions to be member functions of FILE, made relevant *mut FILEs into &mut FILE and made suitable functions safe again

Browse Source
This commit is contained in:
Tom Almeida
2018-03-18 00:20:21 +08:00
parent d7965f2598
commit c24d1e2b36
4 changed files with 360 additions and 378 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/stdio/src/default.rs
-9
View File
@@ -19,9 +19,6 @@ static mut default_stdin: FILE = FILE {
buf_char: -1,
unget: UNGET,
lock: AtomicBool::new(false),
write: None,
read: Some(internal::stdio_read),
seek: None,
};
#[allow(non_upper_case_globals)]
@@ -41,9 +38,6 @@ static mut default_stdout: FILE = FILE {
buf_char: b'\n' as i8,
unget: 0,
lock: AtomicBool::new(false),
write: Some(internal::stdio_write),
read: None,
seek: None,
};
#[allow(non_upper_case_globals)]
@@ -63,9 +57,6 @@ static mut default_stderr: FILE = FILE {
buf_char: -1,
unget: 0,
lock: AtomicBool::new(false),
write: Some(internal::stdio_write),
read: None,
seek: None,
};
// Don't ask me how the casting below works, I have no idea
src/stdio/src/helpers.rs
+48 -60
View File
@@ -1,5 +1,4 @@
use super::{internal, BUFSIZ, FILE, UNGET};
use compiler_builtins::mem::memset;
use stdlib::calloc;
use core::{mem, ptr};
use core::sync::atomic::AtomicBool;
@@ -78,82 +77,71 @@ pub unsafe fn _fdopen(fd: c_int, mode: *const c_char) -> *mut FILE {
buf_char: -1,
unget: UNGET,
lock: AtomicBool::new(false),
write: Some(internal::stdio_write),
read: Some(internal::stdio_read),
seek: Some(internal::stdio_seek),
};
file
}
/// Write buffer `buf` of length `l` into `stream`
pub unsafe fn fwritex(buf: *const u8, l: size_t, stream: *mut FILE) -> size_t {
use compiler_builtins::mem::memcpy;
let mut buf = buf;
pub fn fwritex(buf: *const u8, l: size_t, stream: &mut FILE) -> size_t {
use core::ptr::copy_nonoverlapping;
use core::slice;
let buf: &'static [u8] = unsafe { slice::from_raw_parts(buf, l) };
let mut l = l;
if let Some(stream_write) = (*stream).write {
if (*stream).wend.is_null() && !internal::to_write(stream) {
// We can't write to this stream
return 0;
}
if l > (*stream).wend as usize - (*stream).wpos as usize {
// We can't fit all of buf in the buffer
return stream_write(stream, buf, l);
}
let mut advance = 0;
let i = if (*stream).buf_char >= 0 {
let mut i = l;
while i > 0 && *buf.offset(i as isize - 1) != b'\n' {
i -= 1;
}
if i > 0 {
let n = stream_write(stream, buf, i);
if n < i {
return n;
}
buf = buf.add(i);
l -= i;
}
i
} else {
0
};
memcpy((*stream).wpos, buf, l);
(*stream).wpos = (*stream).wpos.add(l);
l + i
} else {
if stream.wend.is_null() && !stream.can_write() {
// We can't write to this stream
0
return 0;
}
if l > stream.wend as usize - stream.wpos as usize {
// We can't fit all of buf in the buffer
return stream.write(buf);
}
let i = if stream.buf_char >= 0 {
let mut i = l;
while i > 0 && buf[i - 1] != b'\n' {
i -= 1;
}
if i > 0 {
let n = stream.write(buf);
if n < i {
return n;
}
advance += i;
l -= i;
}
i
} else {
0
};
unsafe {
// Copy and reposition
copy_nonoverlapping(&buf[advance..] as *const _ as *const u8, stream.wpos, l);
stream.wpos = stream.wpos.add(l);
}
l + i
}
/// Flush `stream` without locking it.
pub unsafe fn fflush_unlocked(stream: *mut FILE) -> c_int {
if (*stream).wpos > (*stream).wbase {
if let Some(f) = (*stream).write {
f(stream, ptr::null(), 0);
if (*stream).wpos.is_null() {
return -1;
}
} else {
pub fn fflush_unlocked(stream: &mut FILE) -> c_int {
if stream.wpos > stream.wbase {
stream.write(&[]);
if stream.wpos.is_null() {
return -1;
}
}
if (*stream).rpos < (*stream).rend {
if let Some(s) = (*stream).seek {
s(
stream,
(*stream).rpos as i64 - (*stream).rend as i64,
SEEK_CUR,
);
}
if stream.rpos < stream.rend {
stream.seek(stream.rpos as i64 - stream.rend as i64, SEEK_CUR);
}
(*stream).wpos = ptr::null_mut();
(*stream).wend = ptr::null_mut();
(*stream).wbase = ptr::null_mut();
(*stream).rpos = ptr::null_mut();
(*stream).rend = ptr::null_mut();
stream.wpos = ptr::null_mut();
stream.wend = ptr::null_mut();
stream.wbase = ptr::null_mut();
stream.rpos = ptr::null_mut();
stream.rend = ptr::null_mut();
0
}
src/stdio/src/internal.rs
+11 -145
View File
@@ -3,151 +3,17 @@ use platform;
use platform::types::*;
use core::{mem, ptr, slice};
pub fn stdio_read(stream: *mut FILE, buf: *mut u8, size: usize) -> usize {
unsafe {
let mut buff = slice::from_raw_parts_mut(buf, size - !((*stream).buf_size == 0) as usize);
let mut file_buf = slice::from_raw_parts_mut((*stream).buf, (*stream).buf_size);
let mut file = platform::FileReader((*stream).fd);
let count = if buff.len() == 0 {
file.read(&mut file_buf)
pub fn ftello(stream: &mut FILE) -> off_t {
let pos = stream.seek(
0,
if (stream.flags & constants::F_APP > 0) && stream.wpos > stream.wbase {
constants::SEEK_END
} else {
file.read(&mut buff) + file.read(&mut file_buf)
};
mem::forget(buff);
mem::forget(file_buf);
if count <= 0 {
(*stream).flags |= if count == 0 {
constants::F_EOF
} else {
constants::F_ERR
};
return 0;
}
if count as usize <= size {
return count as usize;
}
(*stream).rpos = (*stream).buf;
(*stream).rend = (*stream).buf.offset(count);
*buf.offset(size as isize - 1) = *(*stream).rpos;
(*stream).rpos = (*stream).rpos.add(1);
constants::SEEK_CUR
},
);
if pos < 0 {
return pos;
}
size
}
pub fn stdio_write(stream: *mut FILE, buf: *const u8, size: usize) -> usize {
unsafe {
let len = (*stream).wpos as usize - (*stream).wbase as usize;
let mut advance = 0;
let mut f_buf = slice::from_raw_parts((*stream).wbase, len);
let mut buff = slice::from_raw_parts(buf, size);
let mut f_filled = false;
let mut rem = f_buf.len() + buff.len();
let mut file = platform::FileWriter((*stream).fd);
loop {
let mut count = if f_filled {
file.write(&f_buf[advance..])
} else {
file.write(&f_buf[advance..]) + file.write(buff)
};
if count == rem as isize {
(*stream).wend = (*stream).buf.add((*stream).buf_size - 1);
(*stream).wpos = (*stream).buf;
(*stream).wbase = (*stream).buf;
return size;
}
if count < 0 {
(*stream).wpos = ptr::null_mut();
(*stream).wbase = ptr::null_mut();
(*stream).wend = ptr::null_mut();
(*stream).flags |= constants::F_ERR;
return 0;
}
rem -= count as usize;
if count as usize > len {
count -= len as isize;
f_buf = buff;
f_filled = true;
advance = 0;
}
advance += count as usize;
}
}
}
pub unsafe fn to_read(stream: *mut FILE) -> bool {
if (*stream).flags & constants::F_BADJ > 0 {
// Static and needs unget region
(*stream).buf = (*stream).buf.add((*stream).unget);
(*stream).flags &= !constants::F_BADJ;
}
if (*stream).wpos > (*stream).wbase {
if let Some(f) = (*stream).write {
f(stream, ptr::null(), 0);
}
}
(*stream).wpos = ptr::null_mut();
(*stream).wbase = ptr::null_mut();
(*stream).wend = ptr::null_mut();
if (*stream).flags & constants::F_NORD > 0 {
(*stream).flags |= constants::F_ERR;
return true;
}
(*stream).rpos = (*stream).buf.offset((*stream).buf_size as isize - 1);
(*stream).rend = (*stream).buf.offset((*stream).buf_size as isize - 1);
if (*stream).flags & constants::F_EOF > 0 {
true
} else {
false
}
}
pub unsafe fn to_write(stream: *mut FILE) -> bool {
if (*stream).flags & constants::F_BADJ > 0 {
// Static and needs unget region
(*stream).buf = (*stream).buf.add((*stream).unget);
(*stream).flags &= !constants::F_BADJ;
}
if (*stream).flags & constants::F_NOWR > 0 {
(*stream).flags &= constants::F_ERR;
return false;
}
(*stream).rpos = ptr::null_mut();
(*stream).rend = ptr::null_mut();
(*stream).wpos = (*stream).buf;
(*stream).wbase = (*stream).buf;
(*stream).wend = (*stream).buf.offset((*stream).buf_size as isize - 1);
return true;
}
pub unsafe fn ftello(stream: *mut FILE) -> off_t {
if let Some(s) = (*stream).seek {
let pos = s(
stream,
0,
if ((*stream).flags & constants::F_APP > 0) && (*stream).wpos > (*stream).wbase {
constants::SEEK_END
} else {
constants::SEEK_CUR
},
);
if pos < 0 {
return pos;
}
pos - ((*stream).rend as i64 - (*stream).rpos as i64)
+ ((*stream).wpos as i64 - (*stream).wbase as i64)
} else {
-1
}
}
#[cfg(target_os = "linux")]
pub fn stdio_seek(stream: *mut FILE, off: off_t, whence: c_int) -> off_t {
unsafe { platform::lseek((*stream).fd, off, whence) }
}
#[cfg(target_os = "redox")]
pub fn stdio_seek(stream: *mut FILE, off: off_t, whence: c_int) -> off_t {
unsafe { platform::lseek((*stream).fd, off as isize, whence as usize) as off_t }
pos - (stream.rend as i64 - stream.rpos as i64) + (stream.wpos as i64 - stream.wbase as i64)
}
src/stdio/src/lib.rs
+301 -164
View File
@@ -13,7 +13,7 @@ extern crate va_list as vl;
use core::str;
use core::ptr;
use core::fmt::Write;
use core::fmt::{Error, Result, Write};
use core::sync::atomic::{AtomicBool, Ordering};
use platform::types::*;
@@ -33,9 +33,6 @@ mod helpers;
mod internal;
/// The structure of this struct is likely to change.
/// all of the _pos pointers are likely to change to isize offsets and its possible that the
/// function pointers will be removed
#[repr(C)]
pub struct FILE {
flags: c_int,
@@ -50,15 +47,140 @@ pub struct FILE {
buf_char: i8,
lock: AtomicBool,
unget: size_t,
write: Option<(fn(*mut FILE, *const u8, usize) -> size_t)>,
read: Option<(fn(*mut FILE, *mut u8, usize) -> size_t)>,
seek: Option<(fn(*mut FILE, off_t, c_int) -> off_t)>,
}
impl FILE {
pub fn can_read(&mut self) -> bool {
if self.flags & constants::F_BADJ > 0 {
// Static and needs unget region
self.buf = unsafe { self.buf.add(self.unget) };
self.flags &= !constants::F_BADJ;
}
if self.wpos > self.wbase {
self.write(&[]);
}
self.wpos = ptr::null_mut();
self.wbase = ptr::null_mut();
self.wend = ptr::null_mut();
if self.flags & constants::F_NORD > 0 {
self.flags |= constants::F_ERR;
return false;
}
self.rpos = unsafe { self.buf.offset(self.buf_size as isize - 1) };
self.rend = unsafe { self.buf.offset(self.buf_size as isize - 1) };
if self.flags & constants::F_EOF > 0 {
false
} else {
true
}
}
pub fn can_write(&mut self) -> bool {
if self.flags & constants::F_BADJ > 0 {
// Static and needs unget region
self.buf = unsafe { self.buf.add(self.unget) };
self.flags &= !constants::F_BADJ;
}
if self.flags & constants::F_NOWR > 0 {
self.flags &= constants::F_ERR;
return false;
}
// Buffer repositioning
self.rpos = ptr::null_mut();
self.rend = ptr::null_mut();
self.wpos = self.buf;
self.wbase = self.buf;
self.wend = unsafe { self.buf.offset(self.buf_size as isize - 1) };
return true;
}
pub fn write(&mut self, to_write: &[u8]) -> usize {
use core::slice;
use core::mem;
let len = self.wpos as usize - self.wbase as usize;
let mut advance = 0;
let mut f_buf: &'static _ = unsafe { slice::from_raw_parts(self.wbase, len) };
let mut f_filled = false;
let mut rem = f_buf.len() + to_write.len();
loop {
let mut count = if f_filled {
platform::write(self.fd, &f_buf[advance..])
} else {
platform::write(self.fd, &f_buf[advance..]) + platform::write(self.fd, to_write)
};
if count == rem as isize {
self.wend = unsafe { self.buf.add(self.buf_size - 1) };
self.wpos = self.buf;
self.wbase = self.buf;
return to_write.len();
}
if count < 0 {
self.wpos = ptr::null_mut();
self.wbase = ptr::null_mut();
self.wend = ptr::null_mut();
self.flags |= constants::F_ERR;
return 0;
}
rem -= count as usize;
if count as usize > len {
count -= len as isize;
f_buf = unsafe { mem::transmute(to_write) };
f_filled = true;
advance = 0;
}
advance += count as usize;
}
}
pub fn read(&mut self, buf: &mut [u8]) -> usize {
use core::slice;
// let buff = slice::from_raw_parts_mut(buf, size - !((*stream).buf_size == 0) as usize);
let adj = !(self.buf_size == 0) as usize;
let mut file_buf: &'static mut _ =
unsafe { slice::from_raw_parts_mut(self.buf, self.buf_size) };
let count = if buf.len() <= 1 + adj {
platform::read(self.fd, file_buf)
} else {
platform::read(self.fd, buf) + platform::read(self.fd, file_buf)
};
if count <= 0 {
self.flags |= if count == 0 {
constants::F_EOF
} else {
constants::F_ERR
};
return 0;
}
if count as usize <= buf.len() - adj {
return count as usize;
}
unsafe {
// Adjust pointers
self.rpos = self.buf;
self.rend = self.buf.offset(count);
buf[buf.len() - 1] = *self.rpos;
self.rpos = self.rpos.add(1);
}
buf.len()
}
pub fn seek(&self, off: off_t, whence: c_int) -> off_t {
unsafe { platform::lseek(self.fd, off, whence) }
}
}
impl Write for FILE {
fn write_str(&mut self, s: &str) -> Result {
let s = s.as_bytes();
if self.write(s) != s.len() {
Err(Error)
} else {
Ok(())
}
}
}
/// Clears EOF and ERR indicators on a stream
#[no_mangle]
pub unsafe extern "C" fn clearerr(stream: *mut FILE) {
(*stream).flags &= !(F_EOF & F_ERR);
pub extern "C" fn clearerr(stream: &mut FILE) {
stream.flags &= !(F_EOF & F_ERR);
}
#[no_mangle]
@@ -76,37 +198,39 @@ pub extern "C" fn cuserid(s: *mut c_char) -> *mut c_char {
/// descriptor will be closed, so if it is important that the file be written to, use `fflush()`
/// prior to using this function.
#[no_mangle]
pub unsafe extern "C" fn fclose(stream: *mut FILE) -> c_int {
pub extern "C" fn fclose(stream: &mut FILE) -> c_int {
use stdlib::free;
flockfile(stream);
let r = helpers::fflush_unlocked(stream) | platform::close((*stream).fd);
if (*stream).flags & constants::F_PERM == 0 {
let r = helpers::fflush_unlocked(stream) | platform::close(stream.fd);
if stream.flags & constants::F_PERM == 0 {
// Not one of stdin, stdout or stderr
free(stream as *mut _);
unsafe {
free(stream as *mut _ as *mut _);
}
}
r
}
/// Open a file from a file descriptor
#[no_mangle]
pub unsafe extern "C" fn fdopen(fildes: c_int, mode: *const c_char) -> *mut FILE {
helpers::_fdopen(fildes, mode)
pub extern "C" fn fdopen(fildes: c_int, mode: *const c_char) -> *mut FILE {
unsafe { helpers::_fdopen(fildes, mode) }
}
/// Check for EOF
#[no_mangle]
pub unsafe extern "C" fn feof(stream: *mut FILE) -> c_int {
pub extern "C" fn feof(stream: &mut FILE) -> c_int {
flockfile(stream);
let ret = (*stream).flags & F_EOF;
let ret = stream.flags & F_EOF;
funlockfile(stream);
ret
}
/// Check for ERR
#[no_mangle]
pub unsafe extern "C" fn ferror(stream: *mut FILE) -> c_int {
pub extern "C" fn ferror(stream: &mut FILE) -> c_int {
flockfile(stream);
let ret = (*stream).flags & F_ERR;
let ret = stream.flags & F_ERR;
funlockfile(stream);
ret
}
@@ -115,7 +239,7 @@ pub unsafe extern "C" fn ferror(stream: *mut FILE) -> c_int {
/// Ensure the file is unlocked before calling this function, as it will attempt to lock the file
/// itself.
#[no_mangle]
pub unsafe extern "C" fn fflush(stream: *mut FILE) -> c_int {
pub unsafe extern "C" fn fflush(stream: &mut FILE) -> c_int {
flockfile(stream);
let ret = helpers::fflush_unlocked(stream);
@@ -126,7 +250,7 @@ pub unsafe extern "C" fn fflush(stream: *mut FILE) -> c_int {
/// Get a single char from a stream
#[no_mangle]
pub unsafe extern "C" fn fgetc(stream: *mut FILE) -> c_int {
pub extern "C" fn fgetc(stream: &mut FILE) -> c_int {
flockfile(stream);
let c = getc_unlocked(stream);
funlockfile(stream);
@@ -135,46 +259,58 @@ pub unsafe extern "C" fn fgetc(stream: *mut FILE) -> c_int {
/// Get the position of the stream and store it in pos
#[no_mangle]
pub unsafe extern "C" fn fgetpos(stream: *mut FILE, pos: *mut fpos_t) -> c_int {
pub extern "C" fn fgetpos(stream: &mut FILE, pos: *mut fpos_t) -> c_int {
let off = internal::ftello(stream);
if off < 0 {
return -1;
}
(*pos) = off;
unsafe {
(*pos) = off;
}
0
}
/// Get a string from the stream
#[no_mangle]
pub unsafe extern "C" fn fgets(s: *mut c_char, n: c_int, stream: *mut FILE) -> *mut c_char {
pub extern "C" fn fgets(s: *mut c_char, n: c_int, stream: &mut FILE) -> *mut c_char {
use string::memchr;
use compiler_builtins::mem::memcpy;
use core::ptr::copy_nonoverlapping;
flockfile(stream);
let mut ptr = s as *mut u8;
let mut n = n;
if n <= 1 {
funlockfile(stream);
if n == 0 {
return ptr::null_mut();
}
(*s) = b'\0' as i8;
unsafe {
(*s) = b'\0' as i8;
}
return s;
}
while n > 0 {
let z = memchr(
(*stream).rpos as *const c_void,
b'\n' as c_int,
(*stream).rend as usize - (*stream).rpos as usize,
) as *mut u8;
let z = unsafe {
memchr(
stream.rpos as *const c_void,
b'\n' as c_int,
stream.rend as usize - stream.rpos as usize,
) as *mut u8
};
let k = if z.is_null() {
(*stream).rend as usize - (*stream).rpos as usize
stream.rend as usize - stream.rpos as usize
} else {
z as usize - (*stream).rpos as usize + 1
z as usize - stream.rpos as usize + 1
};
let k = if k as i32 > n { n as usize } else { k };
memcpy(ptr, (*stream).rpos, k);
(*stream).rpos = (*stream).rpos.add(k);
ptr = ptr.add(k);
unsafe {
// Copy
copy_nonoverlapping(stream.rpos, ptr, k);
// Reposition pointers
stream.rpos = stream.rpos.add(k);
ptr = ptr.add(k);
}
n -= k as i32;
if !z.is_null() || n < 1 {
break;
@@ -184,14 +320,21 @@ pub unsafe extern "C" fn fgets(s: *mut c_char, n: c_int, stream: *mut FILE) -> *
break;
}
n -= 1;
*ptr = c as u8;
ptr = ptr.add(1);
unsafe {
// Pointer stuff
*ptr = c as u8;
ptr = ptr.add(1);
}
if c as u8 == b'\n' {
break;
}
}
if !s.is_null() {
*ptr = 0;
unsafe {
*ptr = 0;
}
}
funlockfile(stream);
s
@@ -199,17 +342,17 @@ pub unsafe extern "C" fn fgets(s: *mut c_char, n: c_int, stream: *mut FILE) -> *
/// Get the underlying file descriptor
#[no_mangle]
pub unsafe extern "C" fn fileno(stream: *mut FILE) -> c_int {
pub extern "C" fn fileno(stream: &mut FILE) -> c_int {
flockfile(stream);
funlockfile(stream);
(*stream).fd
stream.fd
}
/// Lock the file
/// Do not call any functions other than those with the `_unlocked` postfix while the file is
/// locked
#[no_mangle]
pub unsafe extern "C" fn flockfile(file: *mut FILE) {
pub extern "C" fn flockfile(file: &mut FILE) {
while ftrylockfile(file) != 0 {}
}
@@ -244,7 +387,7 @@ pub unsafe extern "C" fn fopen(filename: *const c_char, mode: *const c_char) ->
/// Insert a character into the stream
#[no_mangle]
pub unsafe extern "C" fn fputc(c: c_int, stream: *mut FILE) -> c_int {
pub extern "C" fn fputc(c: c_int, stream: &mut FILE) -> c_int {
flockfile(stream);
let c = putc_unlocked(c, stream);
funlockfile(stream);
@@ -253,48 +396,44 @@ pub unsafe extern "C" fn fputc(c: c_int, stream: *mut FILE) -> c_int {
/// Insert a string into a stream
#[no_mangle]
pub unsafe extern "C" fn fputs(s: *const c_char, stream: *mut FILE) -> c_int {
pub extern "C" fn fputs(s: *const c_char, stream: &mut FILE) -> c_int {
extern "C" {
fn strlen(s: *const c_char) -> size_t;
}
let len = strlen(s);
let len = unsafe { strlen(s) };
(fwrite(s as *const c_void, 1, len, stream) == len) as c_int - 1
}
/// Read `nitems` of size `size` into `ptr` from `stream`
#[no_mangle]
pub unsafe extern "C" fn fread(
ptr: *mut c_void,
size: usize,
nitems: usize,
stream: *mut FILE,
) -> usize {
use compiler_builtins::mem::memcpy;
pub extern "C" fn fread(ptr: *mut c_void, size: usize, nitems: usize, stream: &mut FILE) -> usize {
use core::ptr::copy_nonoverlapping;
use core::slice;
let mut dest = ptr as *mut u8;
let len = size * nitems;
let mut l = len as isize;
flockfile(stream);
if (*stream).rend > (*stream).rpos {
if stream.rend > stream.rpos {
// We have some buffered data that can be read
let diff = (*stream).rend as usize - (*stream).rpos as usize;
let diff = stream.rend as usize - stream.rpos as usize;
let k = if diff < l as usize { diff } else { l as usize };
memcpy(dest, (*stream).rpos, k);
(*stream).rpos = (*stream).rpos.add(k);
dest = dest.add(k);
unsafe {
// Copy data
copy_nonoverlapping(stream.rpos, dest, k);
// Reposition pointers
stream.rpos = stream.rpos.add(k);
dest = dest.add(k);
}
l -= k as isize;
}
while l > 0 {
let k = if internal::to_read(stream) {
let k = if !stream.can_read() {
0
} else {
if let Some(f) = (*stream).read {
f(stream, dest, l as usize)
} else {
0
}
stream.read(unsafe { slice::from_raw_parts_mut(dest, l as usize) })
};
if k == 0 {
@@ -303,7 +442,10 @@ pub unsafe extern "C" fn fread(
}
l -= k as isize;
dest = dest.add(k);
unsafe {
// Reposition
dest = dest.add(k);
}
}
funlockfile(stream);
@@ -311,47 +453,45 @@ pub unsafe extern "C" fn fread(
}
#[no_mangle]
pub unsafe extern "C" fn freopen(
pub extern "C" fn freopen(
filename: *const c_char,
mode: *const c_char,
stream: *mut FILE,
stream: &mut FILE,
) -> *mut FILE {
let mut flags = helpers::parse_mode_flags(mode);
let mut flags = unsafe { helpers::parse_mode_flags(mode) };
flockfile(stream);
helpers::fflush_unlocked(stream);
if filename.is_null() {
// Reopen stream in new mode
if flags & fcntl::O_CLOEXEC > 0 {
fcntl::sys_fcntl((*stream).fd, fcntl::F_SETFD, fcntl::FD_CLOEXEC);
fcntl::sys_fcntl(stream.fd, fcntl::F_SETFD, fcntl::FD_CLOEXEC);
}
flags &= !(fcntl::O_CREAT | fcntl::O_EXCL | fcntl::O_CLOEXEC);
if fcntl::sys_fcntl((*stream).fd, fcntl::F_SETFL, flags) < 0 {
if fcntl::sys_fcntl(stream.fd, fcntl::F_SETFL, flags) < 0 {
funlockfile(stream);
fclose(stream);
return ptr::null_mut();
}
} else {
let new = fopen(filename, mode);
let new = unsafe { fopen(filename, mode) };
if new.is_null() {
funlockfile(stream);
fclose(stream);
return ptr::null_mut();
}
if (*new).fd == (*stream).fd {
(*new).fd = -1;
} else if platform::dup2((*new).fd, (*stream).fd) < 0
|| fcntl::sys_fcntl((*stream).fd, fcntl::F_SETFL, flags & fcntl::O_CLOEXEC) < 0
let new = unsafe { &mut *new }; // Should be safe, new is not null
if new.fd == stream.fd {
new.fd = -1;
} else if platform::dup2(new.fd, stream.fd) < 0
|| fcntl::sys_fcntl(stream.fd, fcntl::F_SETFL, flags & fcntl::O_CLOEXEC) < 0
{
fclose(new);
funlockfile(stream);
fclose(stream);
return ptr::null_mut();
}
(*stream).flags = ((*stream).flags & constants::F_PERM) | (*new).flags;
(*stream).read = (*new).read;
(*stream).write = (*new).write;
(*stream).seek = (*new).seek;
stream.flags = (stream.flags & constants::F_PERM) | new.flags;
fclose(new);
}
funlockfile(stream);
@@ -360,7 +500,7 @@ pub unsafe extern "C" fn freopen(
/// Seek to an offset `offset` from `whence`
#[no_mangle]
pub unsafe extern "C" fn fseek(stream: *mut FILE, offset: c_long, whence: c_int) -> c_int {
pub extern "C" fn fseek(stream: &mut FILE, offset: c_long, whence: c_int) -> c_int {
if fseeko(stream, offset as off_t, whence) != -1 {
return 0;
}
@@ -369,53 +509,47 @@ pub unsafe extern "C" fn fseek(stream: *mut FILE, offset: c_long, whence: c_int)
/// Seek to an offset `offset` from `whence`
#[no_mangle]
pub unsafe extern "C" fn fseeko(stream: *mut FILE, offset: off_t, whence: c_int) -> c_int {
pub extern "C" fn fseeko(stream: &mut FILE, offset: off_t, whence: c_int) -> c_int {
let mut off = offset;
flockfile(stream);
// Adjust for what is currently in the buffer
if whence == SEEK_CUR {
off -= ((*stream).rend as usize - (*stream).rpos as usize) as i64;
off -= (stream.rend as usize - stream.rpos as usize) as i64;
}
if (*stream).wpos > (*stream).wbase {
if let Some(f) = (*stream).write {
f(stream, ptr::null(), 0);
if (*stream).wpos.is_null() {
return -1;
}
}
}
(*stream).wpos = ptr::null_mut();
(*stream).wend = ptr::null_mut();
(*stream).wbase = ptr::null_mut();
if let Some(s) = (*stream).seek {
if s(stream, off, whence) < 0 {
if stream.wpos > stream.wbase {
stream.write(&[]);
if stream.wpos.is_null() {
return -1;
}
} else {
}
stream.wpos = ptr::null_mut();
stream.wend = ptr::null_mut();
stream.wbase = ptr::null_mut();
if stream.seek(off, whence) < 0 {
return -1;
}
(*stream).rpos = ptr::null_mut();
(*stream).rend = ptr::null_mut();
(*stream).flags &= !F_EOF;
stream.rpos = ptr::null_mut();
stream.rend = ptr::null_mut();
stream.flags &= !F_EOF;
funlockfile(stream);
0
}
/// Seek to a position `pos` in the file from the beginning of the file
#[no_mangle]
pub unsafe extern "C" fn fsetpos(stream: *mut FILE, pos: *const fpos_t) -> c_int {
pub unsafe extern "C" fn fsetpos(stream: &mut FILE, pos: *const fpos_t) -> c_int {
fseek(stream, *pos as off_t, SEEK_SET)
}
/// Get the current position of the cursor in the file
#[no_mangle]
pub unsafe extern "C" fn ftell(stream: *mut FILE) -> c_long {
pub unsafe extern "C" fn ftell(stream: &mut FILE) -> c_long {
ftello(stream) as c_long
}
/// Get the current position of the cursor in the file
#[no_mangle]
pub unsafe extern "C" fn ftello(stream: *mut FILE) -> off_t {
pub extern "C" fn ftello(stream: &mut FILE) -> off_t {
flockfile(stream);
let pos = internal::ftello(stream);
funlockfile(stream);
@@ -424,25 +558,23 @@ pub unsafe extern "C" fn ftello(stream: *mut FILE) -> off_t {
/// Try to lock the file. Returns 0 for success, 1 for failure
#[no_mangle]
pub unsafe extern "C" fn ftrylockfile(file: *mut FILE) -> c_int {
(*file)
.lock
.compare_and_swap(false, true, Ordering::Acquire) as c_int
pub extern "C" fn ftrylockfile(file: &mut FILE) -> c_int {
file.lock.compare_and_swap(false, true, Ordering::Acquire) as c_int
}
/// Unlock the file
#[no_mangle]
pub unsafe extern "C" fn funlockfile(file: *mut FILE) {
(*file).lock.store(false, Ordering::Release);
pub extern "C" fn funlockfile(file: &mut FILE) {
file.lock.store(false, Ordering::Release);
}
/// Write `nitems` of size `size` from `ptr` to `stream`
#[no_mangle]
pub unsafe extern "C" fn fwrite(
pub extern "C" fn fwrite(
ptr: *const c_void,
size: usize,
nitems: usize,
stream: *mut FILE,
stream: &mut FILE,
) -> usize {
let l = size * nitems;
let nitems = if size == 0 { 0 } else { nitems };
@@ -458,7 +590,7 @@ pub unsafe extern "C" fn fwrite(
/// Get a single char from a stream
#[no_mangle]
pub unsafe extern "C" fn getc(stream: *mut FILE) -> c_int {
pub extern "C" fn getc(stream: &mut FILE) -> c_int {
flockfile(stream);
let c = getc_unlocked(stream);
funlockfile(stream);
@@ -468,24 +600,22 @@ pub unsafe extern "C" fn getc(stream: *mut FILE) -> c_int {
/// Get a single char from `stdin`
#[no_mangle]
pub unsafe extern "C" fn getchar() -> c_int {
fgetc(stdin)
fgetc(&mut *stdin)
}
/// Get a char from a stream without locking the stream
#[no_mangle]
pub unsafe extern "C" fn getc_unlocked(stream: *mut FILE) -> c_int {
if (*stream).rpos < (*stream).rend {
let ret = *(*stream).rpos as c_int;
(*stream).rpos = (*stream).rpos.add(1);
ret
pub extern "C" fn getc_unlocked(stream: &mut FILE) -> c_int {
if stream.rpos < stream.rend {
unsafe {
let ret = *stream.rpos as c_int;
stream.rpos = stream.rpos.add(1);
ret
}
} else {
if let Some(read) = (*stream).read {
let mut c = 0u8;
if !internal::to_read(stream) && read(stream, &mut c, 1) == 1 {
c as c_int
} else {
-1
}
let mut c = [0u8; 1];
if stream.can_read() && stream.read(&mut c) == 1 {
c[0] as c_int
} else {
-1
}
@@ -495,19 +625,19 @@ pub unsafe extern "C" fn getc_unlocked(stream: *mut FILE) -> c_int {
/// Get a char from `stdin` without locking `stdin`
#[no_mangle]
pub unsafe extern "C" fn getchar_unlocked() -> c_int {
getc_unlocked(stdin)
getc_unlocked(&mut *stdin)
}
/// Get a string from `stdin`
#[no_mangle]
pub unsafe extern "C" fn gets(s: *mut c_char) -> *mut c_char {
use core::i32;
fgets(s, i32::MAX, stdin)
fgets(s, i32::MAX, &mut *stdin)
}
/// Get an integer from `stream`
#[no_mangle]
pub unsafe extern "C" fn getw(stream: *mut FILE) -> c_int {
pub extern "C" fn getw(stream: &mut FILE) -> c_int {
use core::mem;
let mut ret: c_int = 0;
if fread(
@@ -524,7 +654,7 @@ pub unsafe extern "C" fn getw(stream: *mut FILE) -> c_int {
}
#[no_mangle]
pub extern "C" fn pclose(stream: *mut FILE) -> c_int {
pub extern "C" fn pclose(stream: &mut FILE) -> c_int {
unimplemented!();
}
@@ -547,7 +677,7 @@ pub extern "C" fn popen(command: *const c_char, mode: *const c_char) -> *mut FIL
/// Put a character `c` into `stream`
#[no_mangle]
pub unsafe extern "C" fn putc(c: c_int, stream: *mut FILE) -> c_int {
pub extern "C" fn putc(c: c_int, stream: &mut FILE) -> c_int {
flockfile(stream);
let ret = putc_unlocked(c, stream);
funlockfile(stream);
@@ -557,31 +687,31 @@ pub unsafe extern "C" fn putc(c: c_int, stream: *mut FILE) -> c_int {
/// Put a character `c` into `stdout`
#[no_mangle]
pub unsafe extern "C" fn putchar(c: c_int) -> c_int {
fputc(c, stdout)
fputc(c, &mut *stdout)
}
/// Put a character `c` into `stream` without locking `stream`
#[no_mangle]
pub unsafe extern "C" fn putc_unlocked(c: c_int, stream: *mut FILE) -> c_int {
if c as i8 != (*stream).buf_char && (*stream).wpos < (*stream).wend {
*(*stream).wpos = c as u8;
(*stream).wpos = (*stream).wpos.add(1);
c
pub extern "C" fn putc_unlocked(c: c_int, stream: &mut FILE) -> c_int {
if c as i8 != stream.buf_char && stream.wpos < stream.wend {
unsafe {
*stream.wpos = c as u8;
stream.wpos = stream.wpos.add(1);
c
}
} else {
if let Some(write) = (*stream).write {
if (*stream).wend.is_null() && internal::to_write(stream) {
-1
} else if c as i8 != (*stream).buf_char && (*stream).wpos < (*stream).wend {
*(*stream).wpos = c as u8;
(*stream).wpos = (*stream).wpos.add(1);
c
} else if write(stream, &c as *const i32 as *const _, 1) != 1 {
-1
} else {
if stream.wend.is_null() && stream.can_write() {
-1
} else if c as i8 != stream.buf_char && stream.wpos < stream.wend {
unsafe {
*stream.wpos = c as u8;
stream.wpos = stream.wpos.add(1);
c
}
} else {
} else if stream.write(&[c as u8]) != 1 {
-1
} else {
c
}
}
}
@@ -589,13 +719,13 @@ pub unsafe extern "C" fn putc_unlocked(c: c_int, stream: *mut FILE) -> c_int {
/// Put a character `c` into `stdout` without locking `stdout`
#[no_mangle]
pub unsafe extern "C" fn putchar_unlocked(c: c_int) -> c_int {
putc_unlocked(c, stdout)
putc_unlocked(c, &mut *stdout)
}
/// Put a string `s` into `stdout`
#[no_mangle]
pub unsafe extern "C" fn puts(s: *const c_char) -> c_int {
let ret = (fputs(s, stdout) > 0) || (putchar_unlocked(b'\n' as c_int) > 0);
let ret = (fputs(s, &mut *stdout) > 0) || (putchar_unlocked(b'\n' as c_int) > 0);
if ret {
0
} else {
@@ -605,7 +735,7 @@ pub unsafe extern "C" fn puts(s: *const c_char) -> c_int {
/// Put an integer `w` into `stream`
#[no_mangle]
pub unsafe extern "C" fn putw(w: c_int, stream: *mut FILE) -> c_int {
pub extern "C" fn putw(w: c_int, stream: &mut FILE) -> c_int {
use core::mem;
fwrite(&w as *const i32 as _, mem::size_of_val(&w), 1, stream) as i32 - 1
}
@@ -629,16 +759,16 @@ pub extern "C" fn rename(old: *const c_char, new: *const c_char) -> c_int {
/// Rewind `stream` back to the beginning of it
#[no_mangle]
pub unsafe extern "C" fn rewind(stream: *mut FILE) {
pub extern "C" fn rewind(stream: &mut FILE) {
fseeko(stream, 0, SEEK_SET);
flockfile(stream);
(*stream).flags &= !F_ERR;
stream.flags &= !F_ERR;
funlockfile(stream);
}
/// Reset `stream` to use buffer `buf`. Buffer must be `BUFSIZ` in length
#[no_mangle]
pub extern "C" fn setbuf(stream: *mut FILE, buf: *mut c_char) {
pub extern "C" fn setbuf(stream: &mut FILE, buf: *mut c_char) {
unsafe {
setvbuf(
stream,
@@ -650,9 +780,10 @@ pub extern "C" fn setbuf(stream: *mut FILE, buf: *mut c_char) {
}
/// Reset `stream` to use buffer `buf` of size `size`
/// If this isn't the meaning of unsafe, idk what is
#[no_mangle]
pub unsafe extern "C" fn setvbuf(
stream: *mut FILE,
stream: &mut FILE,
buf: *mut c_char,
mode: c_int,
size: usize,
@@ -692,22 +823,24 @@ pub extern "C" fn tmpnam(s: *mut c_char) -> *mut c_char {
/// Push character `c` back onto `stream` so it'll be read next
#[no_mangle]
pub unsafe extern "C" fn ungetc(c: c_int, stream: *mut FILE) -> c_int {
pub extern "C" fn ungetc(c: c_int, stream: &mut FILE) -> c_int {
if c < 0 {
c
} else {
flockfile(stream);
if (*stream).rpos.is_null() {
internal::to_read(stream);
if stream.rpos.is_null() {
stream.can_read();
}
if (*stream).rpos.is_null() || (*stream).rpos <= (*stream).buf.sub((*stream).unget) {
if stream.rpos.is_null() || stream.rpos <= unsafe { stream.buf.sub(stream.unget) } {
funlockfile(stream);
return -1;
}
(*stream).rpos = (*stream).rpos.sub(1);
*(*stream).rpos = c as u8;
(*stream).flags &= !F_EOF;
unsafe {
stream.rpos = stream.rpos.sub(1);
*stream.rpos = c as u8;
}
stream.flags &= !F_EOF;
funlockfile(stream);
c
@@ -715,13 +848,13 @@ pub unsafe extern "C" fn ungetc(c: c_int, stream: *mut FILE) -> c_int {
}
#[no_mangle]
pub unsafe extern "C" fn vfprintf(file: *mut FILE, format: *const c_char, ap: va_list) -> c_int {
printf::printf(platform::FileWriter((*file).fd), format, ap)
pub unsafe extern "C" fn vfprintf(file: &mut FILE, format: *const c_char, ap: va_list) -> c_int {
printf::printf(file, format, ap)
}
#[no_mangle]
pub unsafe extern "C" fn vprintf(format: *const c_char, ap: va_list) -> c_int {
vfprintf(stdout, format, ap)
vfprintf(&mut *stdout, format, ap)
}
#[no_mangle]
@@ -731,12 +864,16 @@ pub unsafe extern "C" fn vsnprintf(
format: *const c_char,
ap: va_list,
) -> c_int {
printf::printf(platform::StringWriter(s as *mut u8, n as usize), format, ap)
printf::printf(
&mut platform::StringWriter(s as *mut u8, n as usize),
format,
ap,
)
}
#[no_mangle]
pub unsafe extern "C" fn vsprintf(s: *mut c_char, format: *const c_char, ap: va_list) -> c_int {
printf::printf(platform::UnsafeStringWriter(s as *mut u8), format, ap)
printf::printf(&mut platform::UnsafeStringWriter(s as *mut u8), format, ap)
}
/*