Tiny cleanups

Author: nazar-pc

bindings/rust/src/lib.rs

@@ -94,11 +94,16 @@ impl blst_fp12 {
         if n_elems != p.len() || n_elems == 0 {
             panic!("inputs' lengths mismatch");
         }
-        let qs: [*const _; 2] = [&q[0], ptr::null()];
-        let ps: [*const _; 2] = [&p[0], ptr::null()];
+        let qs = [q.as_ptr(), ptr::null()];
+        let ps = [p.as_ptr(), ptr::null()];
         let mut out = MaybeUninit::<blst_fp12>::uninit();
         unsafe {
-            blst_miller_loop_n(out.as_mut_ptr(), &qs[0], &ps[0], n_elems);
+            blst_miller_loop_n(
+                out.as_mut_ptr(),
+                qs.as_ptr(),
+                ps.as_ptr(),
+                n_elems,
+            );
             out.assume_init()
         }
     }

bindings/rust/src/pippenger-no_std.rs

@@ -52,9 +52,9 @@ macro_rules! pippenger_mult_impl {
                     points: Vec::with_capacity(npoints),
                 };
 
-                let p: [*const $point; 2] = [&points[0], ptr::null()];
+                let p = [points.as_ptr(), ptr::null()];
                 unsafe {
-                    $to_affines(&mut ret.points[0], &p[0], npoints);
+                    $to_affines(ret.points.as_mut_ptr(), p.as_ptr(), npoints);
                     ret.points.set_len(npoints);
                 }
                 ret
@@ -68,19 +68,18 @@ macro_rules! pippenger_mult_impl {
                     panic!("scalars length mismatch");
                 }
 
-                let p: [*const $point_affine; 2] =
-                    [&self.points[0], ptr::null()];
-                let s: [*const u8; 2] = [&scalars[0], ptr::null()];
+                let p = [self.points.as_ptr(), ptr::null()];
+                let s = [scalars.as_ptr(), ptr::null()];
 
                 let mut ret = <$point>::default();
                 unsafe {
                     let mut scratch: Vec<u64> =
                         Vec::with_capacity($scratch_sizeof(npoints) / 8);
                     $multi_scalar_mult(
                         &mut ret,
-                        &p[0],
+                        p.as_ptr(),
                         npoints,
-                        &s[0],
+                        s.as_ptr(),
                         nbits,
                         scratch.as_mut_ptr(),
                     );
@@ -91,9 +90,9 @@ macro_rules! pippenger_mult_impl {
             pub fn add(&self) -> $point {
                 let npoints = self.points.len();
 
-                let p: [*const _; 2] = [&self.points[0], ptr::null()];
+                let p = [self.points.as_ptr(), ptr::null()];
                 let mut ret = <$point>::default();
-                unsafe { $add(&mut ret, &p[0], npoints) };
+                unsafe { $add(&mut ret, p.as_ptr(), npoints) };
 
                 ret
             }

bindings/rust/src/pippenger.rs

@@ -215,11 +215,11 @@ macro_rules! pippenger_mult_impl {
                             unsafe {
                                 $tile_mult(
                                     grid[work].1.as_ptr(),
-                                    &p[0],
+                                    p.as_ptr(),
                                     grid[work].0.dx,
-                                    &s[0],
+                                    s.as_ptr(),
                                     nbits,
-                                    &mut scratch[0],
+                                    scratch.as_mut_ptr(),
                                     y,
                                     window,
                                 );
@@ -273,7 +273,7 @@ macro_rules! pippenger_mult_impl {
                 if ncpus < 2 || npoints < 384 {
                     let p = [self.points.as_ptr(), ptr::null()];
                     let mut ret = <$point>::default();
-                    unsafe { $add(&mut ret, &p[0], npoints) };
+                    unsafe { $add(&mut ret, p.as_ptr(), npoints) };
                     return ret;
                 }
 
@@ -302,7 +302,7 @@ macro_rules! pippenger_mult_impl {
                             }
                             unsafe {
                                 let mut t = MaybeUninit::<$point>::uninit();
-                                $add(t.as_mut_ptr(), &p[0], chunk);
+                                $add(t.as_mut_ptr(), p.as_ptr(), chunk);
                                 $add_or_double(&mut acc, &acc, t.as_ptr());
                             };
                             processed += 1;