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

Run fmt.sh

Browse Source
This commit is contained in:
jD91mZM2
2018-07-03 09:33:41 +02:00
parent aff5380723
commit 9c169a186f
21 changed files with 230 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/stdio/src/default.rs
+2 -2
View File
@@ -1,6 +1,6 @@
use core::sync::atomic::AtomicBool;
use core::cell::UnsafeCell;
use super::{constants, BUFSIZ, FILE, UNGET};
use core::cell::UnsafeCell;
use core::sync::atomic::AtomicBool;
struct GlobalFile(UnsafeCell<FILE>);
impl GlobalFile {
src/stdio/src/helpers.rs
+7 -7
View File
@@ -1,12 +1,12 @@
use super::{internal, BUFSIZ, FILE, UNGET};
use ralloc;
use core::{mem, ptr};
use core::sync::atomic::AtomicBool;
use platform::types::*;
use super::constants::*;
use super::{internal, BUFSIZ, FILE, UNGET};
use core::sync::atomic::AtomicBool;
use core::{mem, ptr};
use errno;
use fcntl::*;
use platform;
use errno;
use platform::types::*;
use ralloc;
/// Parse mode flags as a string and output a mode flags integer
pub unsafe fn parse_mode_flags(mode_str: *const c_char) -> i32 {
@@ -39,8 +39,8 @@ pub unsafe fn parse_mode_flags(mode_str: *const c_char) -> i32 {
/// Open a file with the file descriptor `fd` in the mode `mode`
pub unsafe fn _fdopen(fd: c_int, mode: *const c_char) -> Option<*mut FILE> {
use string::strchr;
use core::mem::size_of;
use string::strchr;
if *mode != b'r' as i8 && *mode != b'w' as i8 && *mode != b'a' as i8 {
platform::errno = errno::EINVAL;
return None;
src/stdio/src/lib.rs
+18 -18
View File
@@ -16,15 +16,15 @@ extern crate ralloc;
extern crate string;
extern crate va_list as vl;
use core::{str,ptr,mem};
use core::fmt::{self, Error, Result};
use core::fmt::Write as WriteFmt;
use core::fmt::{self, Error, Result};
use core::sync::atomic::{AtomicBool, Ordering};
use core::{mem, ptr, str};
use alloc::vec::Vec;
use errno::STR_ERROR;
use platform::types::*;
use platform::{c_str, errno, Read, Write};
use alloc::vec::Vec;
use vl::VaList as va_list;
mod printf;
@@ -44,14 +44,14 @@ mod internal;
/// This struct gets exposed to the C API.
///
pub struct FILE {
flags: i32,
read: Option<(usize, usize)>,
write: Option<(usize, usize, usize)>,
fd: c_int,
buf: Vec<u8>,
flags: i32,
read: Option<(usize, usize)>,
write: Option<(usize, usize, usize)>,
fd: c_int,
buf: Vec<u8>,
buf_char: i8,
lock: AtomicBool,
unget: usize,
lock: AtomicBool,
unget: usize,
}
impl FILE {
@@ -142,11 +142,7 @@ impl FILE {
unreachable!()
}
pub fn read(&mut self, buf: &mut [u8]) -> usize {
let adj = if self.buf.len() > 0 {
0
} else {
1
};
let adj = if self.buf.len() > 0 { 0 } else { 1 };
let mut file_buf = &mut self.buf[self.unget..];
let count = if buf.len() <= 1 + adj {
platform::read(self.fd, &mut file_buf)
@@ -357,7 +353,7 @@ pub extern "C" fn fgets(s: *mut c_char, n: c_int, stream: &mut FILE) -> *mut c_c
'outer: while stream.read(&mut []) == 0 && stream.flags & F_ERR == 0 {
if let Some((rpos, rend)) = stream.read {
let mut idiff = 0usize;
for _ in (0..(len-1) as usize).take_while(|x| rpos + x < rend) {
for _ in (0..(len - 1) as usize).take_while(|x| rpos + x < rend) {
let pos = (n - len) as usize;
st[pos] = stream.buf[rpos + idiff] as i8;
idiff += 1;
@@ -366,7 +362,7 @@ pub extern "C" fn fgets(s: *mut c_char, n: c_int, stream: &mut FILE) -> *mut c_c
break 'outer;
}
}
stream.read = Some((rpos+idiff, rend));
stream.read = Some((rpos + idiff, rend));
if len <= 1 {
break;
}
@@ -586,7 +582,11 @@ pub extern "C" fn fseeko(stream: &mut FILE, offset: off_t, whence: c_int) -> c_i
/// 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: Option<&fpos_t>) -> c_int {
fseek(stream, *pos.expect("You must specify a valid position"), SEEK_SET)
fseek(
stream,
*pos.expect("You must specify a valid position"),
SEEK_SET,
)
}
/// Get the current position of the cursor in the file
src/stdio/src/printf.rs
+3 -2
View File
@@ -1,7 +1,7 @@
use core::{slice, str};
use platform::{self, Write};
use platform::types::*;
use platform::{self, Write};
use vl::VaList;
pub unsafe fn printf<W: Write>(mut w: W, format: *const c_char, mut ap: VaList) -> c_int {
@@ -97,7 +97,8 @@ pub unsafe fn printf<W: Write>(mut w: W, format: *const c_char, mut ap: VaList)
'#' => Ok(()),
'0'...'9' => Ok(()),
_ => Ok(()),
}.is_err() {
}.is_err()
{
return -1;
}
} else if b == b'%' {
src/stdio/src/scanf.rs
+112 -62
View File
@@ -14,7 +14,7 @@ enum IntKind {
LongLong,
IntMax,
PtrDiff,
Size
Size,
}
/// Helper function for progressing a C string
@@ -28,7 +28,11 @@ unsafe fn next_byte(string: &mut *const c_char) -> Result<u8, c_int> {
}
}
unsafe fn inner_scanf<R: Read>(mut r: R, mut format: *const c_char, mut ap: VaList) -> Result<c_int, c_int> {
unsafe fn inner_scanf<R: Read>(
mut r: R,
mut format: *const c_char,
mut ap: VaList,
) -> Result<c_int, c_int> {
let mut matched = 0;
let mut byte = 0;
let mut skip_read = false;
@@ -37,9 +41,11 @@ unsafe fn inner_scanf<R: Read>(mut r: R, mut format: *const c_char, mut ap: VaLi
macro_rules! read {
() => {{
let n = r.read_u8(&mut byte);
if n { count += 1; }
if n {
count += 1;
}
n
}}
}};
}
macro_rules! maybe_read {
@@ -100,7 +106,7 @@ unsafe fn inner_scanf<R: Read>(mut r: R, mut format: *const c_char, mut ap: VaLi
} else {
match width.parse::<usize>() {
Ok(n) => Some(n),
Err(_) => return Err(-1)
Err(_) => return Err(-1),
}
};
@@ -117,7 +123,7 @@ unsafe fn inner_scanf<R: Read>(mut r: R, mut format: *const c_char, mut ap: VaLi
b'q' | b'L' => IntKind::LongLong,
b't' => IntKind::PtrDiff,
b'z' => IntKind::Size,
_ => break
_ => break,
};
c = next_byte(&mut format)?;
@@ -139,8 +145,9 @@ unsafe fn inner_scanf<R: Read>(mut r: R, mut format: *const c_char, mut ap: VaLi
} else if !read!() {
return Ok(matched);
}
},
b'd' | b'i' | b'o' | b'u' | b'x' | b'X' | b'f' | b'e' | b'g' | b'E' | b'a' | b'p' => {
}
b'd' | b'i' | b'o' | b'u' | b'x' | b'X' | b'f' | b'e' | b'g' | b'E' | b'a'
| b'p' => {
while (byte as char).is_whitespace() {
if !read!() {
return Ok(matched);
@@ -162,13 +169,18 @@ unsafe fn inner_scanf<R: Read>(mut r: R, mut format: *const c_char, mut ap: VaLi
let mut dot = false;
while width.map(|w| w > 0).unwrap_or(true)
&& ((byte >= b'0' && byte <= b'7')
|| (radix >= 10 && (byte >= b'8' && byte <= b'9'))
|| (float && !dot && byte == b'.')
|| (radix == 16 && ((byte >= b'a' && byte <= b'f')
|| (byte >= b'A' && byte <= b'F')))) {
if auto && n.is_empty() && byte == b'0'
&& width.map(|w| w > 0).unwrap_or(true) {
&& ((byte >= b'0' && byte <= b'7')
|| (radix >= 10 && (byte >= b'8' && byte <= b'9'))
|| (float && !dot && byte == b'.')
|| (radix == 16
&& ((byte >= b'a' && byte <= b'f')
|| (byte >= b'A' && byte <= b'F'))))
{
if auto
&& n.is_empty()
&& byte == b'0'
&& width.map(|w| w > 0).unwrap_or(true)
{
if !pointer {
radix = 8;
}
@@ -176,7 +188,9 @@ unsafe fn inner_scanf<R: Read>(mut r: R, mut format: *const c_char, mut ap: VaLi
if !read!() {
break;
}
if width.map(|w| w > 0).unwrap_or(true) && (byte == b'x' || byte == b'X') {
if width.map(|w| w > 0).unwrap_or(true)
&& (byte == b'x' || byte == b'X')
{
radix = 16;
width = width.map(|w| w - 1);
if width.map(|w| w > 0).unwrap_or(true) {
@@ -201,33 +215,37 @@ unsafe fn inner_scanf<R: Read>(mut r: R, mut format: *const c_char, mut ap: VaLi
}
macro_rules! parse_type {
(noformat $type:ident) => {
{
let n = if n.is_empty() { 0 as $type } else {
n.parse::<$type>()
.map_err(|_| 0)?
};
if !ignore {
*ap.get::<*mut $type>() = n;
matched += 1;
}
(noformat $type:ident) => {{
let n = if n.is_empty() {
0 as $type
} else {
n.parse::<$type>().map_err(|_| 0)?
};
if !ignore {
*ap.get::<*mut $type>() = n;
matched += 1;
}
}};
(c_double) => {
parse_type!(noformat c_double);
};
(c_double) => { parse_type!(noformat c_double); };
(c_float) => { parse_type!(noformat c_float); };
($type:ident) => { parse_type!($type, $type); };
($type:ident, $final:ty) => {
{
let n = if n.is_empty() { 0 as $type } else {
$type::from_str_radix(&n, radix)
.map_err(|_| 0)?
};
if !ignore {
*ap.get::<*mut $final>() = n as $final;
matched += 1;
}
(c_float) => {
parse_type!(noformat c_float);
};
($type:ident) => {
parse_type!($type, $type);
};
($type:ident, $final:ty) => {{
let n = if n.is_empty() {
0 as $type
} else {
$type::from_str_radix(&n, radix).map_err(|_| 0)?
};
if !ignore {
*ap.get::<*mut $final>() = n as $final;
matched += 1;
}
}
}};
}
if float {
@@ -277,10 +295,10 @@ unsafe fn inner_scanf<R: Read>(mut r: R, mut format: *const c_char, mut ap: VaLi
parse_type!(size_t)
} else {
parse_type!(ssize_t)
}
},
}
}
},
}
b's' => {
while (byte as char).is_whitespace() {
if !read!() {
@@ -307,7 +325,7 @@ unsafe fn inner_scanf<R: Read>(mut r: R, mut format: *const c_char, mut ap: VaLi
*ptr = 0;
matched += 1;
}
},
}
b'c' => {
let mut ptr: Option<*mut c_char> = if ignore { None } else { Some(ap.get()) };
@@ -326,7 +344,7 @@ unsafe fn inner_scanf<R: Read>(mut r: R, mut format: *const c_char, mut ap: VaLi
if ptr.is_some() {
matched += 1;
}
},
}
b'[' => {
c = next_byte(&mut format)?;
@@ -363,7 +381,8 @@ unsafe fn inner_scanf<R: Read>(mut r: R, mut format: *const c_char, mut ap: VaLi
let mut ptr: Option<*mut c_char> = if ignore { None } else { Some(ap.get()) };
while width.map(|w| w > 0).unwrap_or(true) && !invert == matches.contains(&byte) {
while width.map(|w| w > 0).unwrap_or(true) && !invert == matches.contains(&byte)
{
if let Some(ref mut ptr) = ptr {
**ptr = byte as c_char;
*ptr = ptr.offset(1);
@@ -380,13 +399,13 @@ unsafe fn inner_scanf<R: Read>(mut r: R, mut format: *const c_char, mut ap: VaLi
*ptr = 0;
matched += 1;
}
},
}
b'n' => {
if !ignore {
*ap.get::<*mut c_int>() = count as c_int;
}
},
_ => return Err(-1)
}
_ => return Err(-1),
}
if width != Some(0) && c != b'n' {
@@ -401,7 +420,7 @@ unsafe fn inner_scanf<R: Read>(mut r: R, mut format: *const c_char, mut ap: VaLi
pub unsafe fn scanf<R: Read>(r: R, format: *const c_char, ap: VaList) -> c_int {
match inner_scanf(r, format, ap) {
Ok(n) => n,
Err(n) => n
Err(n) => n,
}
}
@@ -420,7 +439,19 @@ macro_rules! va_primitives {
}
}
#[cfg(test)]
va_primitives!(c_uchar, c_ushort, c_uint, c_ulong, c_char, c_short, c_int, c_long, c_float, c_double, *mut c_void);
va_primitives!(
c_uchar,
c_ushort,
c_uint,
c_ulong,
c_char,
c_short,
c_int,
c_long,
c_float,
c_double,
*mut c_void
);
#[cfg(test)]
trait FromVoidPtr {
@@ -437,21 +468,31 @@ macro_rules! from_void_ptr {
}
}
#[cfg(test)]
from_void_ptr!(c_uchar, c_ushort, c_uint, c_ulong, c_char, c_short, c_int, c_long, c_float, c_double,
size_t, ssize_t, *mut c_void);
from_void_ptr!(
c_uchar,
c_ushort,
c_uint,
c_ulong,
c_char,
c_short,
c_int,
c_long,
c_float,
c_double,
size_t,
ssize_t,
*mut c_void
);
#[cfg(test)]
pub struct VaList<'a> {
args: &'a mut [&'a mut VaPrimitive],
i: usize
i: usize,
}
#[cfg(test)]
impl<'a> VaList<'a> {
pub fn new(args: &'a mut [&'a mut VaPrimitive]) -> VaList<'a> {
VaList {
args: args,
i: 0
}
VaList { args: args, i: 0 }
}
pub fn get<T: FromVoidPtr>(&mut self) -> T {
let ptr = T::from_void_ptr(self.args[self.i].as_mut_ptr());
@@ -462,17 +503,20 @@ impl<'a> VaList<'a> {
#[cfg(test)]
mod tests {
use super::*;
use core::ptr;
use platform::StringReader;
use super::*;
fn scanf<'a>(format: &str, args: &'a mut [&'a mut VaPrimitive], input: &str) -> c_int {
unsafe {
let mut format = format.to_string();
let format = format.as_bytes_mut();
let format = format.as_mut_ptr();
let out = super::inner_scanf(StringReader(input.as_bytes()), format as *mut c_char, VaList::new(args))
.expect("running test scanf failed");
let out = super::inner_scanf(
StringReader(input.as_bytes()),
format as *mut c_char,
VaList::new(args),
).expect("running test scanf failed");
out
}
}
@@ -490,7 +534,10 @@ mod tests {
let mut a: c_uint = 0;
let mut b: c_int = 0;
let mut c: c_int = 0;
assert_eq!(scanf("%x %i %i\0", &mut [&mut a, &mut b, &mut c], "12 0x345 010"), 3);
assert_eq!(
scanf("%x %i %i\0", &mut [&mut a, &mut b, &mut c], "12 0x345 010"),
3
);
assert_eq!(a, 0x12);
assert_eq!(b, 0x345);
assert_eq!(c, 0o10);
@@ -535,7 +582,10 @@ mod tests {
fn count() {
let mut a: c_int = 0;
let mut b: c_int = 0;
assert_eq!(scanf("test: %2i%n\0", &mut [&mut a, &mut b], "test: 0xFF"), 1);
assert_eq!(
scanf("test: %2i%n\0", &mut [&mut a, &mut b], "test: 0xFF"),
1
);
assert_eq!(a, 0);
assert_eq!(b, 8);
}