examples/example.rs

   1 #![feature(no_core, unboxed_closures)]
   2 #![no_core]
   3 #![allow(dead_code)]
   4
   5 extern crate mini_core;
   6
   7 use mini_core::*;
   8
   9 fn abc(a: u8) -> u8 {
  10     a * 2
  11 }
  12
  13 fn bcd(b: bool, a: u8) -> u8 {
  14     if b {
  15         a * 2
  16     } else {
  17         a * 3
  18     }
  19 }
  20
  21 // FIXME make calls work
  22 fn call() {
  23     abc(42);
  24 }
  25
  26 fn indirect_call() {
  27     let f: fn() = call;
  28     f();
  29 }
  30
  31 enum BoolOption {
  32     Some(bool),
  33     None,
  34 }
  35
  36 /*
  37 fn option_unwrap_or(o: BoolOption, d: bool) -> bool {
  38     match o {
  39         BoolOption::Some(b) => b,
  40         BoolOption::None => d,
  41     }
  42 }
  43 */
  44
  45 fn ret_42() -> u8 {
  46     42
  47 }
  48
  49 fn return_str() -> &'static str {
  50     "hello world"
  51 }
  52
  53 fn promoted_val() -> &'static u8 {
  54     &(1 * 2)
  55 }
  56
  57 fn cast_ref_to_raw_ptr(abc: &u8) -> *const u8 {
  58     abc as *const u8
  59 }
  60
  61 fn cmp_raw_ptr(a: *const u8, b: *const u8) -> bool {
  62     a == b
  63 }
  64
  65 /*fn int_cast(a: u16, b: i16) -> (u8, u16, u32, usize, i8, i16, i32, isize, u8, u32) {
  66     (
  67         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,
  68         b as u32,
  69     )
  70 }*/
  71
  72 fn char_cast(c: char) -> u8 {
  73     c as u8
  74 }
  75
  76 struct DebugTuple(());
  77
  78 fn debug_tuple() -> DebugTuple {
  79     DebugTuple(())
  80 }
  81
  82 fn size_of<T>() -> usize {
  83     unsafe { intrinsics::size_of::<T>() }
  84 }
  85
  86 fn use_size_of() -> usize {
  87     size_of::<u64>()
  88 }
  89
  90 /*unsafe fn use_copy_intrinsic(src: *const u8, dst: *mut u8) {
  91     intrinsics::copy::<u8>(src, dst, 1);
  92 }*/
  93
  94 /*unsafe fn use_copy_intrinsic_ref(src: *const u8, dst: *mut u8) {
  95     let copy2 = &copy::<u8>;
  96     copy2(src, dst, 1);
  97 }*/
  98
  99 const Abc: u8 = 6 * 7;
 100
 101 fn use_const() -> u8 {
 102     Abc
 103 }
 104
 105 fn call_closure_3arg() {
 106     (|_, _, _| {})(0u8, 42u16, 0u8)
 107 }
 108
 109 fn call_closure_2arg() {
 110     (|_, _| {})(0u8, 42u16)
 111 }
 112
 113 struct IsNotEmpty;
 114
 115 impl<'a, 'b> FnOnce<(&'a &'b [u16],)> for IsNotEmpty {
 116     type Output = bool;
 117
 118     #[inline]
 119     extern "rust-call" fn call_once(mut self, arg: (&'a &'b [u16],)) -> bool {
 120         self.call_mut(arg)
 121     }
 122 }
 123
 124 impl<'a, 'b> FnMut<(&'a &'b [u16],)> for IsNotEmpty {
 125     #[inline]
 126     extern "rust-call" fn call_mut(&mut self, arg: (&'a &'b [u16],)) -> bool {
 127         true
 128     }
 129 }
 130
 131 fn eq_char(a: char, b: char) -> bool {
 132     a == b
 133 }
 134
 135 unsafe fn transmute(c: char) -> u32 {
 136     intrinsics::transmute(c)
 137 }
 138
 139 unsafe fn call_uninit() -> u8 {
 140     intrinsics::uninit()
 141 }
 142
 143 // TODO: enable when fat pointers are supported
 144 unsafe fn deref_str_ptr(s: *const str) -> &'static str {
 145     &*s
 146 }
 147
 148 fn use_array(arr: [u8; 3]) -> u8 {
 149     arr[1]
 150 }
 151
 152 fn repeat_array() -> [u8; 3] {
 153     [0; 3]
 154 }
 155
 156 fn array_as_slice(arr: &[u8; 3]) -> &[u8] {
 157     arr
 158 }
 159
 160 /*unsafe fn use_ctlz_nonzero(a: u16) -> u16 {
 161     intrinsics::ctlz_nonzero(a)
 162 }*/
 163
 164 fn ptr_as_usize(ptr: *const u8) -> usize {
 165     ptr as usize
 166 }
 167
 168 fn float_cast(a: f32, b: f64) -> (f64, f32) {
 169     (a as f64, b as f32)
 170 }
 171
 172 /*fn int_to_float(a: u8, b: i32) -> (f64, f32) {
 173     (a as f64, b as f32)
 174 }*/
 175
 176 fn make_array() -> [u8; 3] {
 177     [42, 0, 5]
 178 }
 179
 180 fn some_promoted_tuple() -> &'static (&'static str, &'static str) {
 181     &("abc", "some")
 182 }
 183
 184 fn index_slice(s: &[u8]) -> u8 {
 185     s[2]
 186 }
 187
 188 pub struct StrWrapper {
 189     s: str,
 190 }
 191
 192 fn str_wrapper_get(w: &StrWrapper) -> &str {
 193     &w.s
 194 }