Sync computers

crates/std/src/ffi/c_str.rs

@@ -0,0 +1,7 @@
+//! [`CStr`], [`CString`], and related types.
+pub use alloc::ffi::c_str::FromVecWithNulError;
+pub use alloc::ffi::c_str::IntoStringError;
+pub use alloc::ffi::c_str::{CString, NulError};
+pub use core::ffi::c_str::CStr;
+pub use core::ffi::c_str::FromBytesUntilNulError;
+pub use core::ffi::c_str::FromBytesWithNulError;

crates/std/src/ffi/mod.rs

@@ -0,0 +1,184 @@
+//! Utilities related to FFI bindings.
+//!
+//! This module provides utilities to handle data across non-Rust
+//! interfaces, like other programming languages and the underlying
+//! operating system. It is mainly of use for FFI (Foreign Function
+//! Interface) bindings and code that needs to exchange C-like strings
+//! with other languages.
+//!
+//! # Overview
+//!
+//! Rust represents owned strings with the [`String`] type, and
+//! borrowed slices of strings with the [`str`] primitive. Both are
+//! always in UTF-8 encoding, and may contain nul bytes in the middle,
+//! i.e., if you look at the bytes that make up the string, there may
+//! be a `\0` among them. Both `String` and `str` store their length
+//! explicitly; there are no nul terminators at the end of strings
+//! like in C.
+//!
+//! C strings are different from Rust strings:
+//!
+//! * **Encodings** - Rust strings are UTF-8, but C strings may use
+//! other encodings. If you are using a string from C, you should
+//! check its encoding explicitly, rather than just assuming that it
+//! is UTF-8 like you can do in Rust.
+//!
+//! * **Character size** - C strings may use `char` or `wchar_t`-sized
+//! characters; please **note** that C's `char` is different from Rust's.
+//! The C standard leaves the actual sizes of those types open to
+//! interpretation, but defines different APIs for strings made up of
+//! each character type. Rust strings are always UTF-8, so different
+//! Unicode characters will be encoded in a variable number of bytes
+//! each. The Rust type [`char`] represents a '[Unicode scalar
+//! value]', which is similar to, but not the same as, a '[Unicode
+//! code point]'.
+//!
+//! * **Nul terminators and implicit string lengths** - Often, C
+//! strings are nul-terminated, i.e., they have a `\0` character at the
+//! end. The length of a string buffer is not stored, but has to be
+//! calculated; to compute the length of a string, C code must
+//! manually call a function like `strlen()` for `char`-based strings,
+//! or `wcslen()` for `wchar_t`-based ones. Those functions return
+//! the number of characters in the string excluding the nul
+//! terminator, so the buffer length is really `len+1` characters.
+//! Rust strings don't have a nul terminator; their length is always
+//! stored and does not need to be calculated. While in Rust
+//! accessing a string's length is an *O*(1) operation (because the
+//! length is stored); in C it is an *O*(*n*) operation because the
+//! length needs to be computed by scanning the string for the nul
+//! terminator.
+//!
+//! * **Internal nul characters** - When C strings have a nul
+//! terminator character, this usually means that they cannot have nul
+//! characters in the middle — a nul character would essentially
+//! truncate the string. Rust strings *can* have nul characters in
+//! the middle, because nul does not have to mark the end of the
+//! string in Rust.
+//!
+//! # Representations of non-Rust strings
+//!
+//! [`CString`] and [`CStr`] are useful when you need to transfer
+//! UTF-8 strings to and from languages with a C ABI, like Python.
+//!
+//! * **From Rust to C:** [`CString`] represents an owned, C-friendly
+//! string: it is nul-terminated, and has no internal nul characters.
+//! Rust code can create a [`CString`] out of a normal string (provided
+//! that the string doesn't have nul characters in the middle), and
+//! then use a variety of methods to obtain a raw <code>\*mut [u8]</code> that can
+//! then be passed as an argument to functions which use the C
+//! conventions for strings.
+//!
+//! * **From C to Rust:** [`CStr`] represents a borrowed C string; it
+//! is what you would use to wrap a raw <code>\*const [u8]</code> that you got from
+//! a C function. A [`CStr`] is guaranteed to be a nul-terminated array
+//! of bytes. Once you have a [`CStr`], you can convert it to a Rust
+//! <code>&[str]</code> if it's valid UTF-8, or lossily convert it by adding
+//! replacement characters.
+//!
+//! [`OsString`] and [`OsStr`] are useful when you need to transfer
+//! strings to and from the operating system itself, or when capturing
+//! the output of external commands. Conversions between [`OsString`],
+//! [`OsStr`] and Rust strings work similarly to those for [`CString`]
+//! and [`CStr`].
+//!
+//! * [`OsString`] losslessly represents an owned platform string. However, this
+//! representation is not necessarily in a form native to the platform.
+//! In the Rust standard library, various APIs that transfer strings to/from the operating
+//! system use [`OsString`] instead of plain strings. For example,
+//! [`env::var_os()`] is used to query environment variables; it
+//! returns an <code>[Option]<[OsString]></code>. If the environment variable
+//! exists you will get a <code>[Some]\(os_string)</code>, which you can
+//! *then* try to convert to a Rust string. This yields a [`Result`], so that
+//! your code can detect errors in case the environment variable did
+//! not in fact contain valid Unicode data.
+//!
+//! * [`OsStr`] losslessly represents a borrowed reference to a platform string.
+//! However, this representation is not necessarily in a form native to the platform.
+//! It can be converted into a UTF-8 Rust string slice in a similar way to
+//! [`OsString`].
+//!
+//! # Conversions
+//!
+//! ## On Unix
+//!
+//! On Unix, [`OsStr`] implements the
+//! <code>std::os::unix::ffi::[OsStrExt][unix.OsStrExt]</code> trait, which
+//! augments it with two methods, [`from_bytes`] and [`as_bytes`].
+//! These do inexpensive conversions from and to byte slices.
+//!
+//! Additionally, on Unix [`OsString`] implements the
+//! <code>std::os::unix::ffi::[OsStringExt][unix.OsStringExt]</code> trait,
+//! which provides [`from_vec`] and [`into_vec`] methods that consume
+//! their arguments, and take or produce vectors of [`u8`].
+//!
+//! ## On Windows
+//!
+//! An [`OsStr`] can be losslessly converted to a native Windows string. And
+//! a native Windows string can be losslessly converted to an [`OsString`].
+//!
+//! On Windows, [`OsStr`] implements the
+//! <code>std::os::windows::ffi::[OsStrExt][windows.OsStrExt]</code> trait,
+//! which provides an [`encode_wide`] method. This provides an
+//! iterator that can be [`collect`]ed into a vector of [`u16`]. After a nul
+//! characters is appended, this is the same as a native Windows string.
+//!
+//! Additionally, on Windows [`OsString`] implements the
+//! <code>std::os::windows:ffi::[OsStringExt][windows.OsStringExt]</code>
+//! trait, which provides a [`from_wide`] method to convert a native Windows
+//! string (without the terminating nul character) to an [`OsString`].
+//!
+//! ## Other platforms
+//!
+//! Many other platforms provide their own extension traits in a
+//! `std::os::*::ffi` module.
+//!
+//! ## On all platforms
+//!
+//! On all platforms, [`OsStr`] consists of a sequence of bytes that is encoded as a superset of
+//! UTF-8; see [`OsString`] for more details on its encoding on different platforms.
+//!
+//! For limited, inexpensive conversions from and to bytes, see [`OsStr::as_encoded_bytes`] and
+//! [`OsStr::from_encoded_bytes_unchecked`].
+//!
+//! For basic string processing, see [`OsStr::slice_encoded_bytes`].
+//!
+//! [Unicode scalar value]: https://www.unicode.org/glossary/#unicode_scalar_value
+//! [Unicode code point]: https://www.unicode.org/glossary/#code_point
+//! [`env::set_var()`]: crate::env::set_var "env::set_var"
+//! [`env::var_os()`]: crate::env::var_os "env::var_os"
+//! [unix.OsStringExt]: crate::os::unix::ffi::OsStringExt "os::unix::ffi::OsStringExt"
+//! [`from_vec`]: crate::os::unix::ffi::OsStringExt::from_vec "os::unix::ffi::OsStringExt::from_vec"
+//! [`into_vec`]: crate::os::unix::ffi::OsStringExt::into_vec "os::unix::ffi::OsStringExt::into_vec"
+//! [unix.OsStrExt]: crate::os::unix::ffi::OsStrExt "os::unix::ffi::OsStrExt"
+//! [`from_bytes`]: crate::os::unix::ffi::OsStrExt::from_bytes "os::unix::ffi::OsStrExt::from_bytes"
+//! [`as_bytes`]: crate::os::unix::ffi::OsStrExt::as_bytes "os::unix::ffi::OsStrExt::as_bytes"
+//! [`OsStrExt`]: crate::os::unix::ffi::OsStrExt "os::unix::ffi::OsStrExt"
+//! [windows.OsStrExt]: crate::os::windows::ffi::OsStrExt "os::windows::ffi::OsStrExt"
+//! [`encode_wide`]: crate::os::windows::ffi::OsStrExt::encode_wide "os::windows::ffi::OsStrExt::encode_wide"
+//! [`collect`]: crate::iter::Iterator::collect "iter::Iterator::collect"
+//! [windows.OsStringExt]: crate::os::windows::ffi::OsStringExt "os::windows::ffi::OsStringExt"
+//! [`from_wide`]: crate::os::windows::ffi::OsStringExt::from_wide "os::windows::ffi::OsStringExt::from_wide"
+pub mod c_str;
+pub use core::ffi::c_void;
+pub use core::ffi::{VaArgSafe, VaList};
+pub use core::ffi::{
+    c_char, c_double, c_float, c_int, c_long, c_longlong, c_schar, c_short, c_uchar, c_uint,
+    c_ulong, c_ulonglong, c_ushort,
+};
+pub use core::ffi::{c_ptrdiff_t, c_size_t, c_ssize_t};
+
+#[doc(inline)]
+pub use self::c_str::FromBytesUntilNulError;
+#[doc(inline)]
+pub use self::c_str::FromBytesWithNulError;
+#[doc(inline)]
+pub use self::c_str::FromVecWithNulError;
+#[doc(inline)]
+pub use self::c_str::IntoStringError;
+#[doc(inline)]
+pub use self::c_str::NulError;
+#[doc(inline)]
+pub use self::c_str::{CStr, CString};
+// #[doc(inline)]
+// pub use self::os_str::{OsStr, OsString};
+pub mod os_str;

crates/std/src/io.rs

@@ -0,0 +1,22 @@
+use crate::fs::File;
+use io::IoBase;
+pub use io::Read;
+pub use io::Seek;
+pub use io::SeekFrom;
+pub use io::Write;
+
+pub struct Stdin;
+
+impl IoBase for Stdin {
+    type Error = ();
+}
+
+impl Read for Stdin {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+        unsafe { File::from_raw_fd(0).read(buf) }
+    }
+}
+
+pub fn stdin() -> Stdin {
+    Stdin
+}

crates/std/src/lib.rs

@@ -0,0 +1,242 @@
+#![no_std]
+#![allow(internal_features)]
+//
+// Language features:
+// tidy-alphabetical-start
+#![feature(alloc_error_handler)]
+#![feature(allocator_internals)]
+#![feature(allow_internal_unsafe)]
+#![feature(allow_internal_unstable)]
+#![feature(asm_experimental_arch)]
+#![feature(autodiff)]
+#![feature(cfg_sanitizer_cfi)]
+#![feature(cfg_target_thread_local)]
+#![feature(cfi_encoding)]
+#![feature(const_default)]
+#![feature(const_trait_impl)]
+#![feature(core_float_math)]
+#![feature(decl_macro)]
+#![feature(deprecated_suggestion)]
+#![feature(doc_cfg)]
+#![feature(doc_masked)]
+#![feature(doc_notable_trait)]
+#![feature(dropck_eyepatch)]
+#![feature(f16)]
+#![feature(f128)]
+#![feature(ffi_const)]
+#![feature(formatting_options)]
+#![feature(funnel_shifts)]
+#![feature(if_let_guard)]
+#![feature(intra_doc_pointers)]
+#![feature(iter_advance_by)]
+#![feature(iter_next_chunk)]
+#![feature(lang_items)]
+#![feature(link_cfg)]
+#![feature(linkage)]
+#![feature(macro_metavar_expr_concat)]
+#![feature(maybe_uninit_fill)]
+#![feature(min_specialization)]
+#![feature(must_not_suspend)]
+#![feature(needs_panic_runtime)]
+#![feature(negative_impls)]
+#![feature(never_type)]
+#![feature(optimize_attribute)]
+#![feature(prelude_import)]
+#![feature(rustc_attrs)]
+#![feature(rustdoc_internals)]
+// #![feature(staged_api)]
+#![feature(stmt_expr_attributes)]
+#![feature(strict_provenance_lints)]
+#![feature(thread_local)]
+#![feature(try_blocks)]
+#![feature(try_trait_v2)]
+#![feature(type_alias_impl_trait)]
+// tidy-alphabetical-end
+//
+// Library features (core):
+// tidy-alphabetical-start
+#![feature(bstr)]
+#![feature(bstr_internals)]
+#![feature(cast_maybe_uninit)]
+#![feature(cfg_select)]
+#![feature(char_internals)]
+#![feature(clone_to_uninit)]
+#![feature(const_convert)]
+#![feature(core_intrinsics)]
+#![feature(core_io_borrowed_buf)]
+#![feature(drop_guard)]
+#![feature(duration_constants)]
+#![feature(error_generic_member_access)]
+#![feature(error_iter)]
+#![feature(exact_size_is_empty)]
+#![feature(exclusive_wrapper)]
+#![feature(extend_one)]
+#![feature(float_algebraic)]
+// #![feature(float_gamma)]
+#![feature(float_minimum_maximum)]
+#![feature(fmt_internals)]
+#![feature(fn_ptr_trait)]
+#![feature(generic_atomic)]
+#![feature(hasher_prefixfree_extras)]
+#![feature(hashmap_internals)]
+#![feature(hint_must_use)]
+#![feature(int_from_ascii)]
+#![feature(ip)]
+#![feature(maybe_uninit_array_assume_init)]
+#![feature(panic_can_unwind)]
+#![feature(panic_internals)]
+#![feature(pin_coerce_unsized_trait)]
+#![feature(pointer_is_aligned_to)]
+#![feature(portable_simd)]
+#![feature(ptr_as_uninit)]
+#![feature(ptr_mask)]
+#![feature(random)]
+#![feature(slice_internals)]
+#![feature(slice_ptr_get)]
+#![feature(slice_range)]
+#![feature(slice_split_once)]
+#![feature(std_internals)]
+#![feature(str_internals)]
+#![feature(sync_unsafe_cell)]
+#![feature(temporary_niche_types)]
+#![feature(ub_checks)]
+#![feature(used_with_arg)]
+// tidy-alphabetical-end
+//
+// Library features (alloc):
+// tidy-alphabetical-start
+#![feature(alloc_layout_extra)]
+#![feature(allocator_api)]
+#![feature(clone_from_ref)]
+#![feature(get_mut_unchecked)]
+#![feature(map_try_insert)]
+#![feature(slice_concat_trait)]
+#![feature(thin_box)]
+#![feature(try_reserve_kind)]
+#![feature(try_with_capacity)]
+#![feature(unique_rc_arc)]
+#![feature(wtf8_internals)]
+// tidy-alphabetical-end
+//
+// Library features (unwind):
+// tidy-alphabetical-start
+// #![feature(panic_unwind)]
+// tidy-alphabetical-end
+//
+// Library features (std_detect):
+// tidy-alphabetical-start
+// #![feature(stdarch_internal)]
+// tidy-alphabetical-end
+//
+// Only for re-exporting:
+// tidy-alphabetical-start
+#![feature(assert_matches)]
+#![feature(async_iterator)]
+#![feature(c_variadic)]
+#![feature(cfg_accessible)]
+#![feature(cfg_eval)]
+#![feature(concat_bytes)]
+#![feature(const_format_args)]
+#![feature(custom_test_frameworks)]
+#![feature(edition_panic)]
+#![feature(format_args_nl)]
+#![feature(log_syntax)]
+#![feature(test)]
+#![feature(trace_macros)]
+// tidy-alphabetical-end
+//
+// Only used in tests/benchmarks:
+//
+// Only for const-ness:
+// tidy-alphabetical-start
+// #![feature(io_const_error)]
+// tidy-alphabetical-end
+//
+#![feature(c_size_t, unsafe_binders)]
+#![allow(clippy::doc_lazy_continuation, clippy::legacy_numeric_constants)]
+#![allow(stable_features, incomplete_features)]
+
+extern crate alloc;
+
+pub use core::any;
+pub use core::array;
+pub use core::async_iter;
+pub use core::cell;
+pub use core::char;
+pub use core::clone;
+pub use core::cmp;
+pub use core::convert;
+pub use core::default;
+pub use core::future;
+pub use core::hint;
+#[allow(deprecated, deprecated_in_future)]
+pub use core::i8;
+#[allow(deprecated, deprecated_in_future)]
+pub use core::i16;
+#[allow(deprecated, deprecated_in_future)]
+pub use core::i32;
+#[allow(deprecated, deprecated_in_future)]
+pub use core::i64;
+#[allow(deprecated, deprecated_in_future)]
+pub use core::i128;
+pub use core::intrinsics;
+#[allow(deprecated, deprecated_in_future)]
+pub use core::isize;
+pub use core::iter;
+pub use core::marker;
+pub use core::mem;
+pub use core::ops;
+pub use core::option;
+pub use core::pin;
+pub use core::ptr;
+pub use core::range;
+pub use core::result;
+#[allow(deprecated, deprecated_in_future)]
+pub use core::u8;
+#[allow(deprecated, deprecated_in_future)]
+pub use core::u16;
+#[allow(deprecated, deprecated_in_future)]
+pub use core::u32;
+#[allow(deprecated, deprecated_in_future)]
+pub use core::u64;
+#[allow(deprecated, deprecated_in_future)]
+pub use core::u128;
+pub use core::unsafe_binder;
+#[allow(deprecated, deprecated_in_future)]
+pub use core::usize;
+
+pub use alloc::borrow;
+pub use alloc::boxed;
+pub use alloc::fmt;
+pub use alloc::format;
+pub use alloc::rc;
+pub use alloc::slice;
+pub use alloc::str;
+pub use alloc::string;
+pub use alloc::vec;
+
+pub mod ffi;
+pub mod io;
+pub mod prelude;
+pub mod process;
+
+pub use shared::fs;
+pub use shared::syscall;
+
+#[macro_export]
+macro_rules! print {
+    ($($args:expr),*) => {
+        $crate::syscall::write_string_temp(&format!($($args),*))
+    };
+}
+#[macro_export]
+macro_rules! println {
+    () => {
+        $crate::print!("");
+        // $crate::print!("\n\r");
+    };
+    ($($args:expr),*) => {
+        $crate::print!($($args),*);
+        // $crate::println!();
+    };
+}

crates/std/src/prelude.rs

@@ -0,0 +1,54 @@
+pub mod rust_2024 {
+    pub use crate::print;
+    pub use crate::println;
+    pub use alloc::borrow::ToOwned;
+    pub use alloc::format;
+    pub use alloc::string::String;
+    pub use alloc::vec;
+
+    extern crate alloc;
+
+    struct GlobalAllocator;
+
+    #[core::prelude::v1::global_allocator]
+    static GLOBAL_ALLOCATOR: GlobalAllocator = GlobalAllocator;
+
+    unsafe impl core::alloc::GlobalAlloc for GlobalAllocator {
+        unsafe fn alloc(&self, layout: core::alloc::Layout) -> *mut u8 {
+            crate::syscall::alloc(layout)
+        }
+
+        unsafe fn dealloc(&self, ptr: *mut u8, layout: core::alloc::Layout) {
+            crate::syscall::dealloc(ptr, layout)
+        }
+    }
+
+    #[panic_handler]
+    fn panic(_panic_info: &core::panic::PanicInfo) -> ! {
+        // TODO print
+        loop {}
+    }
+
+    /// # Safety
+    /// `argc` and `argv` are passed by the kernel
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn _start(argc: isize, argv: *const *const u8) -> isize {
+        unsafe extern "Rust" {
+            fn main(argc: isize, argv: *const *const u8) -> isize;
+        }
+
+        unsafe { main(argc, argv) }
+    }
+
+    #[lang = "start"]
+    pub fn lang_start<T: crate::process::Termination + 'static>(
+        main: fn() -> T,
+        argc: isize,
+        argv: *const *const u8,
+        _sigpipe: u8,
+    ) -> isize {
+        println!("{}", argc);
+        println!("{:?}", argv);
+        main().report().to_isize()
+    }
+}

crates/std/src/process.rs

@@ -0,0 +1,29 @@
+pub struct ExitCode(isize);
+
+impl ExitCode {
+    pub const SUCCESS: ExitCode = ExitCode(0);
+
+    pub fn to_isize(self) -> isize {
+        self.0
+    }
+}
+
+#[lang = "termination"]
+pub trait Termination {
+    /// Is called to get the representation of the value as status code.
+    /// This status code is returned to the operating system.
+    fn report(self) -> ExitCode;
+}
+
+impl Termination for () {
+    #[inline]
+    fn report(self) -> ExitCode {
+        ExitCode::SUCCESS
+    }
+}
+impl Termination for isize {
+    #[inline]
+    fn report(self) -> ExitCode {
+        ExitCode(self)
+    }
+}