Use references instead of pointers

src/lib/snarky/src/camlsnark_c/libsnark-caml/depends/libff/libff/algebra/fields/field_utils.hpp

@@ -18,11 +18,11 @@ namespace libff {
 // returns root of unity of order n (for n a power of 2), if one exists
 template<typename FieldT>
 typename std::enable_if<std::is_same<FieldT, Double>::value, FieldT>::type
-get_root_of_unity(const size_t n, bool* err);
+get_root_of_unity(const size_t n, bool &err);
 
 template<typename FieldT>
 typename std::enable_if<!std::is_same<FieldT, Double>::value, FieldT>::type
-get_root_of_unity(const size_t n, bool* err);
+get_root_of_unity(const size_t n, bool &err);
 
 template<typename FieldT>
 std::vector<FieldT> pack_int_vector_into_field_element_vector(const std::vector<size_t> &v, const size_t w);

src/lib/snarky/src/camlsnark_c/libsnark-caml/depends/libff/libff/algebra/fields/field_utils.tcc

@@ -16,11 +16,6 @@
 #include <libff/common/double.hpp>
 #include <libff/common/utils.hpp>
 
-#include <execinfo.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-
 namespace libff {
 
 template<typename FieldT>
@@ -31,7 +26,7 @@ FieldT coset_shift()
 
 template<typename FieldT>
 typename std::enable_if<std::is_same<FieldT, Double>::value, FieldT>::type
-get_root_of_unity(const size_t n, bool* err)
+get_root_of_unity(const size_t n, bool &err)
 {
     const double PI = 3.141592653589793238460264338328L;
 
@@ -44,16 +39,16 @@ get_root_of_unity(const size_t n, bool* err)
 
 template<typename FieldT>
 typename std::enable_if<!std::is_same<FieldT, Double>::value, FieldT>::type
-get_root_of_unity(const size_t n, bool* err)
+get_root_of_unity(const size_t n, bool &err)
 {
     const size_t logn = log2(n);
     if (n != (1u << logn)) {
-      *err = true;
+      err = true;
       return FieldT(1,1);
     }
 
     if (logn > FieldT::s) {
-      *err = true;
+      err = true;
       return FieldT(1,1);
     }
 

src/lib/snarky/src/camlsnark_c/libsnark-caml/depends/libfqfft/libfqfft/evaluation_domain/domains/arithmetic_sequence_domain.hpp

@@ -28,7 +28,7 @@ namespace libfqfft {
     FieldT arithmetic_generator;
     void do_precomputation();
 
-    arithmetic_sequence_domain(const size_t m, bool* err);
+    arithmetic_sequence_domain(const size_t m, bool &err);
 
     void FFT(std::vector<FieldT> &a);
     void iFFT(std::vector<FieldT> &a);

src/lib/snarky/src/camlsnark_c/libsnark-caml/depends/libfqfft/libfqfft/evaluation_domain/domains/arithmetic_sequence_domain.tcc

@@ -24,16 +24,16 @@
 namespace libfqfft {
 
 template<typename FieldT>
-arithmetic_sequence_domain<FieldT>::arithmetic_sequence_domain(const size_t m, bool* err) : evaluation_domain<FieldT>(m)
+arithmetic_sequence_domain<FieldT>::arithmetic_sequence_domain(const size_t m, bool &err) : evaluation_domain<FieldT>(m)
 {
   if (m <= 1) {
-    *err = true;
+    err = true;
     precomputation_sentinel = false;
     return;
   }
 
   if (FieldT::arithmetic_generator() == FieldT::zero()) {
-    *err = true;
+    err = true;
     precomputation_sentinel = false;
     return;
   }

src/lib/snarky/src/camlsnark_c/libsnark-caml/depends/libfqfft/libfqfft/evaluation_domain/domains/basic_radix2_domain.hpp

@@ -26,7 +26,7 @@ class basic_radix2_domain : public evaluation_domain<FieldT> {
 
     FieldT omega;
 
-    basic_radix2_domain(const size_t m, bool* err);
+    basic_radix2_domain(const size_t m, bool &err);
 
     void FFT(std::vector<FieldT> &a);
     void iFFT(std::vector<FieldT> &a);

src/lib/snarky/src/camlsnark_c/libsnark-caml/depends/libfqfft/libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc

@@ -23,15 +23,15 @@
 namespace libfqfft {
 
 template<typename FieldT>
-basic_radix2_domain<FieldT>::basic_radix2_domain(const size_t m, bool* err) : evaluation_domain<FieldT>(m)
+basic_radix2_domain<FieldT>::basic_radix2_domain(const size_t m, bool &err) : evaluation_domain<FieldT>(m)
 {
     if (m <= 1) {
-      *err = true;
+      err = true;
       omega = FieldT(1,1);
     } else if (!std::is_same<FieldT, libff::Double>::value) {
         const size_t logm = libff::log2(m);
         if (logm > (FieldT::s)) {
-          *err = true;
+          err = true;
           omega = FieldT(1,1);
         } else {
           omega = libff::get_root_of_unity<FieldT>(m, err);

src/lib/snarky/src/camlsnark_c/libsnark-caml/depends/libfqfft/libfqfft/evaluation_domain/domains/basic_radix2_domain_aux.tcc

@@ -190,7 +190,7 @@ std::vector<FieldT> _basic_radix2_evaluate_all_lagrange_polynomials(const size_t
     if (m != (1u << libff::log2(m))) throw DomainSizeException("expected m == (1u << log2(m))");
 
     bool err = false;
-    const FieldT omega = libff::get_root_of_unity<FieldT>(m, &err);
+    const FieldT omega = libff::get_root_of_unity<FieldT>(m, err);
     if (err) {
       throw DomainSizeException("Failed get_root_of_unity");
     }

src/lib/snarky/src/camlsnark_c/libsnark-caml/depends/libfqfft/libfqfft/evaluation_domain/domains/extended_radix2_domain.hpp

@@ -27,7 +27,7 @@ class extended_radix2_domain : public evaluation_domain<FieldT> {
     FieldT omega;
     FieldT shift;
 
-    extended_radix2_domain(const size_t m, bool* err);
+    extended_radix2_domain(const size_t m, bool &err);
 
     void FFT(std::vector<FieldT> &a);
     void iFFT(std::vector<FieldT> &a);

src/lib/snarky/src/camlsnark_c/libsnark-caml/depends/libfqfft/libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc

@@ -18,10 +18,10 @@
 namespace libfqfft {
 
 template<typename FieldT>
-extended_radix2_domain<FieldT>::extended_radix2_domain(const size_t m, bool* err) : evaluation_domain<FieldT>(m)
+extended_radix2_domain<FieldT>::extended_radix2_domain(const size_t m, bool &err) : evaluation_domain<FieldT>(m)
 {
     if (m <= 1) {
-      *err = true;
+      err = true;
       omega = FieldT(1,1);
       small_m = 0;
       shift = FieldT(1,1);
@@ -32,7 +32,7 @@ extended_radix2_domain<FieldT>::extended_radix2_domain(const size_t m, bool* err
     {
         const size_t logm = libff::log2(m);
         if (logm != (FieldT::s + 1))  {
-          *err = true;
+          err = true;
           omega = FieldT(1,1);
           small_m = 0;
           shift = FieldT(1,1);

src/lib/snarky/src/camlsnark_c/libsnark-caml/depends/libfqfft/libfqfft/evaluation_domain/domains/geometric_sequence_domain.hpp

@@ -27,7 +27,7 @@ namespace libfqfft {
     std::vector<FieldT> geometric_triangular_sequence;
     void do_precomputation();
 
-    geometric_sequence_domain(const size_t m, bool* err);
+    geometric_sequence_domain(const size_t m, bool &err);
 
     void FFT(std::vector<FieldT> &a);
     void iFFT(std::vector<FieldT> &a);

src/lib/snarky/src/camlsnark_c/libsnark-caml/depends/libfqfft/libfqfft/evaluation_domain/domains/geometric_sequence_domain.tcc

@@ -24,18 +24,18 @@
 namespace libfqfft {
 
 template<typename FieldT>
-geometric_sequence_domain<FieldT>::geometric_sequence_domain(const size_t m, bool* err) : evaluation_domain<FieldT>(m)
+geometric_sequence_domain<FieldT>::geometric_sequence_domain(const size_t m, bool &err) : evaluation_domain<FieldT>(m)
 {
   bool precomputation_sentinel;
 
   if (m <= 1) {
-    *err = true;
+    err = true;
     precomputation_sentinel = false;
     return;
   }
 
   if (FieldT::geometric_generator() == FieldT::zero()) {
-    *err = true;
+    err = true;
     precomputation_sentinel = false;
     return;
   }

src/lib/snarky/src/camlsnark_c/libsnark-caml/depends/libfqfft/libfqfft/evaluation_domain/domains/step_radix2_domain.hpp

@@ -29,7 +29,7 @@ class step_radix2_domain : public evaluation_domain<FieldT> {
     FieldT big_omega;
     FieldT small_omega;
 
-    step_radix2_domain(const size_t m, bool* err);
+    step_radix2_domain(const size_t m, bool &err);
 
     void FFT(std::vector<FieldT> &a);
     void iFFT(std::vector<FieldT> &a);

src/lib/snarky/src/camlsnark_c/libsnark-caml/depends/libfqfft/libfqfft/evaluation_domain/domains/step_radix2_domain.tcc

@@ -18,10 +18,10 @@
 namespace libfqfft {
 
 template<typename FieldT>
-step_radix2_domain<FieldT>::step_radix2_domain(const size_t m, bool* err) : evaluation_domain<FieldT>(m)
+step_radix2_domain<FieldT>::step_radix2_domain(const size_t m, bool& err) : evaluation_domain<FieldT>(m)
 {
     if (m <= 1) {
-      *err = true;
+      err = true;
       big_m = 0;
       small_m = 0;
       omega = FieldT(1,1);
@@ -34,15 +34,15 @@ step_radix2_domain<FieldT>::step_radix2_domain(const size_t m, bool* err) : eval
     small_m = m - big_m;
 
     if (small_m != 1ul<<libff::log2(small_m)) {
-      *err = true;
+      err = true;
       omega = FieldT(1,1);
       big_omega = FieldT(1,1);
       small_omega = FieldT(1,1);
       return;
     }
 
     omega = libff::get_root_of_unity<FieldT>(1ul<<libff::log2(m), err);
-    if (*err) {
+    if (err) {
       big_omega = omega;
       small_omega = omega;
       return;
@@ -81,7 +81,7 @@ void step_radix2_domain<FieldT>::FFT(std::vector<FieldT> &a)
     _basic_radix2_FFT(c, omega.squared());
 
     bool err = false;
-    auto root_of_unity_small_m = libff::get_root_of_unity<FieldT>(small_m, &err);
+    auto root_of_unity_small_m = libff::get_root_of_unity<FieldT>(small_m, err);
     if (err) {
       throw DomainSizeException("Failed to get_root_of_unity");
     }
@@ -108,7 +108,7 @@ void step_radix2_domain<FieldT>::iFFT(std::vector<FieldT> &a)
 
     _basic_radix2_FFT(U0, omega.squared().inverse());
     bool err = false;
-    auto root_of_unity_small_m = libff::get_root_of_unity<FieldT>(small_m, &err);
+    auto root_of_unity_small_m = libff::get_root_of_unity<FieldT>(small_m, err);
     if (err) {
       throw DomainSizeException("Failed get_root_of_unity");
     }

src/lib/snarky/src/camlsnark_c/libsnark-caml/depends/libfqfft/libfqfft/evaluation_domain/get_evaluation_domain.tcc

@@ -39,56 +39,56 @@ std::shared_ptr<evaluation_domain<FieldT> > get_evaluation_domain(const size_t m
     const size_t rounded_small = (1ul<<libff::log2(small));
 
     bool err = false;
-    auto basic = new basic_radix2_domain<FieldT>(min_size, &err);
+    auto basic = new basic_radix2_domain<FieldT>(min_size, err);
     if (!err) {
       result.reset(basic);
       return result;
     }
     err = false;
 
-    auto extended = new extended_radix2_domain<FieldT>(min_size, &err);
+    auto extended = new extended_radix2_domain<FieldT>(min_size, err);
     if (!err) {
       result.reset(extended);
       return result;
     }
     err = false;
 
-    auto step = new step_radix2_domain<FieldT>(min_size, &err);
+    auto step = new step_radix2_domain<FieldT>(min_size, err);
     if (!err) {
       result.reset(step);
       return result;
     }
     err = false;
 
-    auto basic2 = new basic_radix2_domain<FieldT>(big + rounded_small, &err);
+    auto basic2 = new basic_radix2_domain<FieldT>(big + rounded_small, err);
     if (!err) {
       result.reset(basic2);
       return result;
     }
     err = false;
 
-    auto extended2 = new extended_radix2_domain<FieldT>(big + rounded_small, &err);
+    auto extended2 = new extended_radix2_domain<FieldT>(big + rounded_small, err);
     if (!err) {
       result.reset(extended2);
       return result;
     }
     err = false;
 
-    auto step2 = new step_radix2_domain<FieldT>(big + rounded_small, &err);
+    auto step2 = new step_radix2_domain<FieldT>(big + rounded_small, err);
     if (!err) {
       result.reset(step2);
       return result;
     }
     err = false;
 
-    auto geometric = new geometric_sequence_domain<FieldT>(min_size, &err);
+    auto geometric = new geometric_sequence_domain<FieldT>(min_size, err);
     if (!err) {
       result.reset(geometric);
       return result;
     }
     err = false;
 
-    auto arithmetic = new arithmetic_sequence_domain<FieldT>(min_size, &err);
+    auto arithmetic = new arithmetic_sequence_domain<FieldT>(min_size, err);
     if (!err) {
       result.reset(arithmetic);
       return result;

src/lib/snarky/src/camlsnark_c/libsnark-caml/depends/libfqfft/libfqfft/polynomial_arithmetic/basic_operations.tcc

@@ -124,7 +124,7 @@ void _polynomial_multiplication_on_fft(std::vector<FieldT> &c, const std::vector
 {
     const size_t n = libff::get_power_of_two(a.size() + b.size() - 1);
     bool err = false;
-    FieldT omega = libff::get_root_of_unity<FieldT>(n, &err);
+    FieldT omega = libff::get_root_of_unity<FieldT>(n, err);
     if (err) {
       throw DomainSizeException("Failed root of unity");
     }