rust/example/example.rs

209 lines
3.3 KiB
Rust
Raw Normal View History

#![feature(no_core, unboxed_closures)]
2018-06-17 18:05:11 +02:00
#![no_core]
#![allow(dead_code)]
2018-06-17 18:05:11 +02:00
2018-07-24 14:10:53 +02:00
extern crate mini_core;
2018-06-17 18:05:11 +02:00
2018-07-24 14:10:53 +02:00
use mini_core::*;
2018-07-20 14:20:37 +02:00
fn abc(a: u8) -> u8 {
2018-06-17 18:05:11 +02:00
a * 2
}
fn bcd(b: bool, a: u8) -> u8 {
2018-06-17 18:05:11 +02:00
if b {
a * 2
} else {
a * 3
}
}
2018-06-17 19:10:00 +02:00
fn call() {
2018-06-17 19:10:00 +02:00
abc(42);
}
2018-06-18 18:39:07 +02:00
fn indirect_call() {
let f: fn() = call;
f();
}
2018-06-23 18:26:54 +02:00
enum BoolOption {
Some(bool),
None,
}
fn option_unwrap_or(o: BoolOption, d: bool) -> bool {
match o {
BoolOption::Some(b) => b,
BoolOption::None => d,
}
}
fn ret_42() -> u8 {
2018-06-23 18:26:54 +02:00
42
2018-06-18 18:39:07 +02:00
}
fn return_str() -> &'static str {
"hello world"
}
fn promoted_val() -> &'static u8 {
&(1 * 2)
}
fn cast_ref_to_raw_ptr(abc: &u8) -> *const u8 {
abc as *const u8
}
2018-07-18 15:17:22 +02:00
fn cmp_raw_ptr(a: *const u8, b: *const u8) -> bool {
a == b
}
2018-07-18 16:22:29 +02:00
fn int_cast(a: u16, b: i16) -> (u8, u16, u32, usize, i8, i16, i32, isize, u8, u32) {
2018-07-18 16:22:29 +02:00
(
a as u8, a as u16, a as u32, a as usize, a as i8, a as i16, a as i32, a as isize, b as u8,
b as u32,
2018-07-18 16:22:29 +02:00
)
}
2018-07-18 17:07:10 +02:00
2018-07-19 19:37:34 +02:00
fn char_cast(c: char) -> u8 {
c as u8
}
pub struct DebugTuple(());
2018-07-18 17:07:10 +02:00
fn debug_tuple() -> DebugTuple {
DebugTuple(())
}
2018-07-20 14:20:37 +02:00
fn size_of<T>() -> usize {
2019-02-06 18:49:59 +01:00
intrinsics::size_of::<T>()
}
fn use_size_of() -> usize {
size_of::<u64>()
2018-07-20 14:20:37 +02:00
}
unsafe fn use_copy_intrinsic(src: *const u8, dst: *mut u8) {
intrinsics::copy::<u8>(src, dst, 1);
}
unsafe fn use_copy_intrinsic_ref(src: *const u8, dst: *mut u8) {
let copy2 = &intrinsics::copy::<u8>;
2018-07-20 14:20:37 +02:00
copy2(src, dst, 1);
}
2018-07-21 18:44:34 +02:00
2019-02-06 18:49:59 +01:00
const ABC: u8 = 6 * 7;
2018-07-21 18:44:34 +02:00
fn use_const() -> u8 {
2019-02-06 18:49:59 +01:00
ABC
2018-07-21 18:44:34 +02:00
}
2018-07-20 13:38:49 +02:00
pub fn call_closure_3arg() {
(|_, _, _| {})(0u8, 42u16, 0u8)
}
pub fn call_closure_2arg() {
(|_, _| {})(0u8, 42u16)
2018-07-20 13:38:49 +02:00
}
2018-07-26 10:48:50 +02:00
struct IsNotEmpty;
impl<'a, 'b> FnOnce<(&'a &'b [u16],)> for IsNotEmpty {
type Output = (u8, u8);
#[inline]
extern "rust-call" fn call_once(mut self, arg: (&'a &'b [u16],)) -> (u8, u8) {
self.call_mut(arg)
}
}
impl<'a, 'b> FnMut<(&'a &'b [u16],)> for IsNotEmpty {
#[inline]
2019-02-06 18:49:59 +01:00
extern "rust-call" fn call_mut(&mut self, _arg: (&'a &'b [u16],)) -> (u8, u8) {
(0, 42)
}
}
pub fn call_is_not_empty() {
IsNotEmpty.call_once((&(&[0u16] as &[_]),));
}
2018-07-26 10:48:50 +02:00
fn eq_char(a: char, b: char) -> bool {
a == b
}
unsafe fn transmute(c: char) -> u32 {
intrinsics::transmute(c)
}
2018-07-29 17:22:40 +02:00
unsafe fn call_uninit() -> u8 {
intrinsics::uninit()
}
2018-08-08 10:39:10 +02:00
2018-08-22 15:38:10 +02:00
unsafe fn deref_str_ptr(s: *const str) -> &'static str {
2018-08-08 10:39:10 +02:00
&*s
2018-08-22 15:38:10 +02:00
}
2018-08-08 12:22:16 +02:00
fn use_array(arr: [u8; 3]) -> u8 {
arr[1]
}
2018-08-08 12:30:25 +02:00
fn repeat_array() -> [u8; 3] {
[0; 3]
}
fn array_as_slice(arr: &[u8; 3]) -> &[u8] {
arr
}
unsafe fn use_ctlz_nonzero(a: u16) -> u16 {
intrinsics::ctlz_nonzero(a)
}
2018-08-09 11:07:10 +02:00
fn ptr_as_usize(ptr: *const u8) -> usize {
ptr as usize
}
fn float_cast(a: f32, b: f64) -> (f64, f32) {
(a as f64, b as f32)
}
fn int_to_float(a: u8, b: i32) -> (f64, f32) {
(a as f64, b as f32)
}
fn make_array() -> [u8; 3] {
[42, 0, 5]
}
fn some_promoted_tuple() -> &'static (&'static str, &'static str) {
&("abc", "some")
}
2018-08-25 11:22:48 +02:00
fn index_slice(s: &[u8]) -> u8 {
s[2]
}
pub struct StrWrapper {
s: str,
}
fn str_wrapper_get(w: &StrWrapper) -> &str {
&w.s
}
fn i16_as_i8(a: i16) -> i8 {
a as i8
}
struct Unsized(u8, str);
fn get_sized_field_ref_from_unsized_type(u: &Unsized) -> &u8 {
&u.0
}
fn get_unsized_field_ref_from_unsized_type(u: &Unsized) -> &str {
&u.1
}