cuelang.org/go@v0.10.1/cue/interpreter/wasm/testdata/rust/struct/src/lib.rs (about)

     1  mod mem;
     2  
     3  #[repr(C)]
     4  pub struct Vector2 {
     5      x: f64,
     6      y: f64,
     7  }
     8  
     9  #[repr(C)]
    10  pub struct Vector3 {
    11      x: f64,
    12      y: f64,
    13      z: f64,
    14  }
    15  
    16  #[no_mangle]
    17  pub extern "C" fn magnitude2(v: &Vector2) -> f64 {
    18      (v.x.powi(2) + v.y.powi(2)).sqrt()
    19  }
    20  
    21  #[no_mangle]
    22  pub extern "C" fn magnitude3(v: &Vector3) -> f64 {
    23      (v.x.powi(2) + v.y.powi(2) + v.z.powi(2)).sqrt()
    24  }
    25  
    26  #[no_mangle]
    27  pub extern "C" fn normalize2(v: &Vector2) -> Vector2 {
    28      let l = magnitude2(v);
    29      Vector2 {
    30          x: v.x / l,
    31          y: v.y / l,
    32      }
    33  }
    34  
    35  #[no_mangle]
    36  pub extern "C" fn double3(v: &Vector3) -> Vector3 {
    37      Vector3 {
    38          x: v.x * 2.0,
    39          y: v.y * 2.0,
    40          z: v.z * 2.0,
    41      }
    42  }
    43  
    44  #[repr(C)]
    45  pub struct Cornucopia {
    46      b: bool,
    47      n0: i16,
    48      n1: u8,
    49      n2: i64,
    50  }
    51  
    52  #[no_mangle]
    53  pub extern "C" fn cornucopia(x: &Cornucopia) -> i64 {
    54      if x.b {
    55          return 42;
    56      }
    57      return x.n0 as i64 + x.n1 as i64 + x.n2;
    58  }
    59  
    60  #[repr(C)]
    61  pub struct Foo {
    62      b: bool,
    63      bar: Bar,
    64  }
    65  
    66  #[repr(C)]
    67  pub struct Bar {
    68      b: bool,
    69      baz: Baz,
    70      n: u16,
    71  }
    72  
    73  #[repr(C)]
    74  pub struct Baz {
    75      vec: Vector2,
    76  }
    77  
    78  #[no_mangle]
    79  pub extern "C" fn magnitude_foo(x: &Foo) -> f64 {
    80      magnitude2(&x.bar.baz.vec)
    81  }