Improve const correctness

src/algorithms/telemetry_decoder/libs/libswiftcnav/bits.c

@@ -85,12 +85,12 @@ uint32_t getbitu(const uint8_t *buff, uint32_t pos, uint8_t len)
  */
 int32_t getbits(const uint8_t *buff, uint32_t pos, uint8_t len)
 {
-    int32_t bits = (int32_t)getbitu(buff, pos, len);
+    const int32_t bits = (int32_t)getbitu(buff, pos, len);
 
     /* Sign extend, taken from:
      * http://graphics.stanford.edu/~seander/bithacks.html#VariableSignExtend
      */
-    int32_t m = 1U << (len - 1);
+    const int32_t m = 1U << (len - 1);
     return (bits ^ m) - m;
 }
 
@@ -161,9 +161,9 @@ void bitshl(void *buf, uint32_t size, uint32_t shift)
     unsigned char *dst = buf;                          /* Destination byte. */
     const unsigned char *src = dst + shift / CHAR_BIT; /* First source byte, possibly incomplete. */
 
-    uint32_t copy_bits = size * CHAR_BIT - shift; /* Number of bits to move */
+    const uint32_t copy_bits = size * CHAR_BIT - shift; /* Number of bits to move */
-    uint32_t byte_shift = copy_bits % CHAR_BIT;   /* Shift of data */
+    const uint32_t byte_shift = copy_bits % CHAR_BIT;   /* Shift of data */
-    uint32_t full_bytes = copy_bits / CHAR_BIT;   /* Number of bytes to move */
+    const uint32_t full_bytes = copy_bits / CHAR_BIT;   /* Number of bytes to move */
 
     if (0 == byte_shift)
         {
@@ -209,19 +209,19 @@ void bitshl(void *buf, uint32_t size, uint32_t shift)
 void bitcopy(void *dst, uint32_t dst_index, const void *src, uint32_t src_index,
     uint32_t count)
 {
-    uint32_t limit1 = count / 32;
+    const uint32_t limit1 = count / 32;
-    uint32_t limit2 = count % 32;
+    const uint32_t limit2 = count % 32;
     uint32_t idx = 0;
     for (idx = 0; idx < limit1; ++idx)
         {
-            uint32_t tmp = getbitu(src, src_index, 32);
+            const uint32_t tmp = getbitu(src, src_index, 32);
             setbitu(dst, dst_index, 32, tmp);
             src_index += 32;
             dst_index += 32;
         }
     if (0 != limit2)
         {
-            uint32_t tmp = getbitu(src, src_index, limit2);
+            const uint32_t tmp = getbitu(src, src_index, limit2);
             setbitu(dst, dst_index, limit2, tmp);
         }
 }

src/algorithms/telemetry_decoder/libs/libswiftcnav/cnav_msg.c

@@ -126,7 +126,7 @@ static void _cnav_rescan_preamble(cnav_v27_part_t *part)
             size_t j = 0;
             for (i = 1, j = part->n_decoded - GPS_CNAV_PREAMBLE_LENGTH; i < j; ++i)
                 {
-                    uint32_t c = getbitu(part->decoded, i, GPS_CNAV_PREAMBLE_LENGTH);
+                    const uint32_t c = getbitu(part->decoded, i, GPS_CNAV_PREAMBLE_LENGTH);
                     if (GPS_CNAV_PREAMBLE1 == c || GPS_CNAV_PREAMBLE2 == c)
                         {
                             part->preamble_seen = true;
@@ -182,7 +182,7 @@ static void _cnav_add_symbol(cnav_v27_part_t *part, uint8_t ch)
 
     /* Feed accumulated symbols into the buffer, reset the number of accumulated
      * symbols. */
-    v27_update(&part->dec, part->symbols, part->n_symbols / 2);
+    v27_update(&part->dec, part->symbols, (int)part->n_symbols / 2);
     part->n_symbols = 0;
 
     /* Decode N+M bits, where:
@@ -230,8 +230,8 @@ static void _cnav_add_symbol(cnav_v27_part_t *part, uint8_t ch)
                 {
                     /* We have collected 300 bits starting from message preamble. Now try
                      * to compute CRC-24Q */
-                    uint32_t crc = _cnav_compute_crc(part);
+                    const uint32_t crc = _cnav_compute_crc(part);
-                    uint32_t crc2 = _cnav_extract_crc(part);
+                    const uint32_t crc2 = _cnav_extract_crc(part);
 
                     if (part->message_lock)
                         {

src/algorithms/telemetry_decoder/libs/libswiftcnav/edc.c

@@ -108,7 +108,7 @@ uint32_t crc24q_bits(uint32_t crc, const uint8_t *buf, uint32_t n_bits, bool inv
 {
     uint16_t acc = 0;
     uint8_t b = 0;
-    uint32_t shift = 8 - n_bits % 8;
+    const uint32_t shift = 8 - n_bits % 8;
 
     uint32_t i = 0;
     for (i = 0; i < n_bits / 8; ++i)

src/algorithms/telemetry_decoder/libs/libswiftcnav/viterbi27.c

@@ -115,7 +115,6 @@ void v27_update(v27_t *v, const unsigned char *syms, int nbits)
     unsigned char sym0;
     unsigned char sym1;
     unsigned int *tmp;
-    int normalize = 0;
 
     while (nbits--)
         {
@@ -176,8 +175,6 @@ void v27_update(v27_t *v, const unsigned char *syms, int nbits)
                         {
                             v->new_metrics[i] -= minmetric;
                         }
-
-                    normalize += minmetric;
                 }
 
             /* Advance decision index */

src/algorithms/telemetry_decoder/libs/viterbi_decoder.cc

@@ -74,9 +74,6 @@ void Viterbi_Decoder::reset()
  */
 float Viterbi_Decoder::decode_block(const double input_c[], int output_u_int[], const int LL)
 {
-    int state;
-    int decoding_length_mismatch;
-
     VLOG(FLOW) << "decode_block(): LL=" << LL;
 
     // init
@@ -84,9 +81,9 @@ float Viterbi_Decoder::decode_block(const double input_c[], int output_u_int[],
     // do add compare select
     do_acs(input_c, LL + d_mm);
     // tail, no need to output -> traceback, but don't decode
-    state = do_traceback(d_mm);
+    const int state = do_traceback(d_mm);
     // traceback and decode
-    decoding_length_mismatch = do_tb_and_decode(d_mm, LL, state, output_u_int, d_indicator_metric);
+    const int decoding_length_mismatch = do_tb_and_decode(d_mm, LL, state, output_u_int, d_indicator_metric);
 
     VLOG(FLOW) << "decoding length mismatch: " << decoding_length_mismatch;
 
@@ -100,18 +97,15 @@ float Viterbi_Decoder::decode_continuous(const double sym[],
     const int nbits_requested,
     int& nbits_decoded)
 {
-    int state;
-    int decoding_length_mismatch;
-
     VLOG(FLOW) << "decode_continuous(): nbits_requested=" << nbits_requested;
 
     // do add compare select
     do_acs(sym, nbits_requested);
     // the ML sequence in the newest part of the trellis can not be decoded
     // since it depends on the future values -> traceback, but don't decode
-    state = do_traceback(traceback_depth);
+    const int state = do_traceback(traceback_depth);
     // traceback and decode
-    decoding_length_mismatch = do_tb_and_decode(traceback_depth, nbits_requested, state, bits, d_indicator_metric);
+    const int decoding_length_mismatch = do_tb_and_decode(traceback_depth, nbits_requested, state, bits, d_indicator_metric);
     nbits_decoded = nbits_requested + decoding_length_mismatch;
 
     VLOG(FLOW) << "decoding length mismatch (continuous decoding): " << decoding_length_mismatch;
@@ -193,11 +187,11 @@ int Viterbi_Decoder::do_acs(const double sym[], int nbits)
             /* step through all states */
             for (state_at_t = 0; state_at_t < d_states; state_at_t++)
                 {
-                    int next_state_if_0 = d_state0[state_at_t];
+                    const int next_state_if_0 = d_state0[state_at_t];
-                    int next_state_if_1 = d_state1[state_at_t];
+                    const int next_state_if_1 = d_state1[state_at_t];
 
                     /* hypothesis: info bit is a zero */
-                    float bm_0 = d_metric_c[d_out0[state_at_t]];
+                    const float bm_0 = d_metric_c[d_out0[state_at_t]];
                     metric = d_pm_t[state_at_t] + bm_0;  // path metric + zerobranch metric
 
                     /* store new metric if more than metric in storage */
@@ -210,7 +204,7 @@ int Viterbi_Decoder::do_acs(const double sym[], int nbits)
                         }
 
                     /* hypothesis: info bit is a one */
-                    float bm_1 = d_metric_c[d_out1[state_at_t]];
+                    const float bm_1 = d_metric_c[d_out1[state_at_t]];
                     metric = d_pm_t[state_at_t] + bm_1;  // path metric + onebranch metric
 
                     /* store new metric if more than metric in storage */
@@ -272,17 +266,14 @@ int Viterbi_Decoder::do_traceback(size_t traceback_length)
 int Viterbi_Decoder::do_tb_and_decode(int traceback_length, int requested_decoding_length, int state, int output_u_int[], float& indicator_metric)
 {
     int n_of_branches_for_indicator_metric = 500;
-    int t_out;
     std::deque<Prev>::iterator it;
-    int decoding_length_mismatch;
-    int overstep_length;
     int n_im = 0;
 
     VLOG(FLOW) << "do_tb_and_decode(): requested_decoding_length=" << requested_decoding_length;
     // decode only decode_length bits -> overstep newer bits which are too much
-    decoding_length_mismatch = static_cast<int>(d_trellis_paths.size()) - (traceback_length + requested_decoding_length);
+    const int decoding_length_mismatch = static_cast<int>(d_trellis_paths.size()) - (traceback_length + requested_decoding_length);
     VLOG(BLOCK) << "decoding_length_mismatch=" << decoding_length_mismatch;
-    overstep_length = decoding_length_mismatch >= 0 ? decoding_length_mismatch : 0;
+    const int overstep_length = decoding_length_mismatch >= 0 ? decoding_length_mismatch : 0;
     VLOG(BLOCK) << "overstep_length=" << overstep_length;
 
     for (it = d_trellis_paths.begin() + traceback_length;
@@ -290,7 +281,7 @@ int Viterbi_Decoder::do_tb_and_decode(int traceback_length, int requested_decodi
         {
             state = it->get_anchestor_state_of_current_state(state);
         }
-    t_out = static_cast<int>(d_trellis_paths.end() - (d_trellis_paths.begin() + traceback_length + overstep_length) - 1);  // requested_decoding_length-1;
+    int t_out = static_cast<int>(d_trellis_paths.end() - (d_trellis_paths.begin() + traceback_length + overstep_length) - 1);  // requested_decoding_length-1;
     indicator_metric = 0;
     for (it = d_trellis_paths.begin() + traceback_length + overstep_length; it < d_trellis_paths.end(); ++it)
         {
@@ -358,8 +349,7 @@ void Viterbi_Decoder::nsc_transit(int output_p[], int trans_p[], int input, cons
 {
     int nextstate[1];
     int state;
-    int states;
+    const int states = static_cast<int>(1U << (KK - 1)); /* The number of states: 2^mm */
-    states = static_cast<int>(1U << (KK - 1)); /* The number of states: 2^mm */
 
     /* Determine the output and next state for each possible starting state */
     for (state = 0; state < states; state++)
@@ -411,6 +401,7 @@ int Viterbi_Decoder::nsc_enc_bit(int state_out_p[], int input, int state_in,
     return (out);
 }
 
+
 /* function parity_counter()
 
  Description: Determines if a symbol has odd (1) or even (0) parity

src/algorithms/tracking/adapters/galileo_e5b_dll_pll_tracking.cc

@@ -41,7 +41,7 @@ GalileoE5bDllPllTracking::GalileoE5bDllPllTracking(
     DLOG(INFO) << "role " << role;
     trk_params.SetFromConfiguration(configuration, role);
 
-    auto vector_length = static_cast<int>(std::round(trk_params.fs_in / (GALILEO_E5B_CODE_CHIP_RATE_CPS / GALILEO_E5B_CODE_LENGTH_CHIPS)));
+    const auto vector_length = static_cast<int>(std::round(trk_params.fs_in / (GALILEO_E5B_CODE_CHIP_RATE_CPS / GALILEO_E5B_CODE_LENGTH_CHIPS)));
     trk_params.vector_length = vector_length;
     if (trk_params.extend_correlation_symbols < 1)
         {
@@ -58,7 +58,7 @@ GalileoE5bDllPllTracking::GalileoE5bDllPllTracking(
             std::cout << TEXT_RED << "WARNING: Galileo E5b. PLL or DLL narrow tracking bandwidth is higher than wide tracking one" << TEXT_RESET << '\n';
         }
     trk_params.system = 'E';
-    std::array<char, 3> sig_{'7', 'X', '\0'};
+    const std::array<char, 3> sig_{'7', 'X', '\0'};
     std::memcpy(trk_params.signal, sig_.data(), 3);
 
     // ################# Make a GNU Radio Tracking block object ################

src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc

@@ -693,7 +693,7 @@ void dll_pll_veml_tracking::start_tracking()
     else if (d_systemName == "Galileo" and d_signal_type == "7X")
         {
             volk_gnsssdr::vector<gr_complex> aux_code(d_code_length_chips);
-            std::array<char, 3> signal_type_ = {{'7', 'X', '\0'}};
+            const std::array<char, 3> signal_type_ = {{'7', 'X', '\0'}};
             galileo_e5_b_code_gen_complex_primary(aux_code, d_acquisition_gnss_synchro->PRN, signal_type_);
             if (d_trk_parameters.track_pilot)
                 {
@@ -1076,10 +1076,10 @@ void dll_pll_veml_tracking::run_dll_pll()
 
                     if (d_dll_filt_history.full())
                         {
-                            float avg_code_error_chips_s = static_cast<float>(std::accumulate(d_dll_filt_history.begin(), d_dll_filt_history.end(), 0.0)) / static_cast<float>(d_dll_filt_history.capacity());
+                            const float avg_code_error_chips_s = static_cast<float>(std::accumulate(d_dll_filt_history.begin(), d_dll_filt_history.end(), 0.0)) / static_cast<float>(d_dll_filt_history.capacity());
                             if (std::fabs(avg_code_error_chips_s) > 1.0)
                                 {
-                                    float carrier_doppler_error_hz = static_cast<float>(d_signal_carrier_freq) * avg_code_error_chips_s / static_cast<float>(d_code_chip_rate);
+                                    const float carrier_doppler_error_hz = static_cast<float>(d_signal_carrier_freq) * avg_code_error_chips_s / static_cast<float>(d_code_chip_rate);
                                     LOG(INFO) << "Detected and corrected carrier doppler error: " << carrier_doppler_error_hz << " [Hz] on sat " << Gnss_Satellite(d_systemName, d_acquisition_gnss_synchro->PRN);
                                     d_carrier_loop_filter.initialize(static_cast<float>(d_carrier_doppler_hz) - carrier_doppler_error_hz);
                                     d_corrected_doppler = true;

src/algorithms/tracking/libs/lock_detectors.cc

@@ -98,7 +98,7 @@ float cn0_m2m4_estimator(const gr_complex* Prompt_buffer, int length, float coh_
     float m_2 = 0.0;
     float m_4 = 0.0;
     float aux;
-    auto n = static_cast<float>(length);
+    const auto n = static_cast<float>(length);
     for (int i = 0; i < length; i++)
         {
             Psig += std::abs(Prompt_buffer[i].real());

src/algorithms/tracking/libs/tracking_2nd_DLL_filter.cc

@@ -30,7 +30,7 @@
 void Tracking_2nd_DLL_filter::calculate_lopp_coef(float* tau1, float* tau2, float lbw, float zeta, float k)
 {
     // Solve natural frequency
-    float Wn = lbw * 8.0F * zeta / (4.0F * zeta * zeta + 1.0F);
+    const float Wn = lbw * 8.0F * zeta / (4.0F * zeta * zeta + 1.0F);
     // solve for t1 & t2
     *tau1 = k / (Wn * Wn);
     *tau2 = 2.0F * zeta / Wn;

src/algorithms/tracking/libs/tracking_2nd_PLL_filter.cc

@@ -29,7 +29,7 @@
 void Tracking_2nd_PLL_filter::calculate_lopp_coef(float* tau1, float* tau2, float lbw, float zeta, float k)
 {
     // Solve natural frequency
-    float Wn = lbw * 8.0F * zeta / (4.0F * zeta * zeta + 1.0F);
+    const float Wn = lbw * 8.0F * zeta / (4.0F * zeta * zeta + 1.0F);
     // solve for t1 & t2
     *tau1 = k / (Wn * Wn);
     *tau2 = 2.0F * zeta / Wn;

src/algorithms/tracking/libs/tracking_FLL_PLL_filter.cc

@@ -105,8 +105,7 @@ float Tracking_FLL_PLL_filter::get_carrier_error(float FLL_discriminator, float
             /*
              * 2nd order PLL with 1st order FLL assist
              */
-            float pll_w_new;
+            const float pll_w_new = d_pll_w + PLL_discriminator * d_pll_w0p2 * correlation_time_s + FLL_discriminator * d_pll_w0f * correlation_time_s;
-            pll_w_new = d_pll_w + PLL_discriminator * d_pll_w0p2 * correlation_time_s + FLL_discriminator * d_pll_w0f * correlation_time_s;
             carrier_error_hz = 0.5F * (pll_w_new + d_pll_w) + d_pll_a2 * d_pll_w0p * PLL_discriminator;
             d_pll_w = pll_w_new;
             /* std::cout << " d_pll_w = " << carrier_error_hz << ", pll_w_new = " << pll_w_new

src/algorithms/tracking/libs/tracking_discriminators.cc

@@ -54,10 +54,8 @@ double phase_unwrap(double phase_rad)
  */
 double fll_four_quadrant_atan(gr_complex prompt_s1, gr_complex prompt_s2, double t1, double t2)
 {
-    float cross;
+    const float dot = prompt_s1.real() * prompt_s2.real() + prompt_s1.imag() * prompt_s2.imag();
-    float dot;
+    const float cross = prompt_s1.real() * prompt_s2.imag() - prompt_s2.real() * prompt_s1.imag();
-    dot = prompt_s1.real() * prompt_s2.real() + prompt_s1.imag() * prompt_s2.imag();
-    cross = prompt_s1.real() * prompt_s2.imag() - prompt_s2.real() * prompt_s1.imag();
     return std::atan2(cross, dot) / (t2 - t1);
 }
 
@@ -120,9 +118,9 @@ double pll_cloop_two_quadrant_atan(gr_complex prompt_s1)
  */
 double dll_nc_e_minus_l_normalized(gr_complex early_s1, gr_complex late_s1, float spc, float slope, float y_intercept)
 {
-    double P_early = std::abs(early_s1);
+    const double P_early = std::abs(early_s1);
-    double P_late = std::abs(late_s1);
+    const double P_late = std::abs(late_s1);
-    double E_plus_L = P_early + P_late;
+    const double E_plus_L = P_early + P_late;
     if (E_plus_L == 0.0)
         {
             return 0.0;
@@ -142,10 +140,9 @@ double dll_nc_e_minus_l_normalized(gr_complex early_s1, gr_complex late_s1, floa
  */
 double dll_nc_vemlp_normalized(gr_complex very_early_s1, gr_complex early_s1, gr_complex late_s1, gr_complex very_late_s1)
 {
-    double Early = std::sqrt(very_early_s1.real() * very_early_s1.real() + very_early_s1.imag() * very_early_s1.imag() + early_s1.real() * early_s1.real() + early_s1.imag() * early_s1.imag());
+    const double Early = std::sqrt(very_early_s1.real() * very_early_s1.real() + very_early_s1.imag() * very_early_s1.imag() + early_s1.real() * early_s1.real() + early_s1.imag() * early_s1.imag());
-    double Late = std::sqrt(late_s1.real() * late_s1.real() + late_s1.imag() * late_s1.imag() + very_late_s1.real() * very_late_s1.real() + very_late_s1.imag() * very_late_s1.imag());
+    const double Late = std::sqrt(late_s1.real() * late_s1.real() + late_s1.imag() * late_s1.imag() + very_late_s1.real() * very_late_s1.real() + very_late_s1.imag() * very_late_s1.imag());
-
+    const double E_plus_L = Early + Late;
-    double E_plus_L = Early + Late;
     if (E_plus_L == 0.0)
         {
             return 0.0;

src/algorithms/tracking/libs/tracking_loop_filter.cc

@@ -104,9 +104,9 @@ void Tracking_loop_filter::update_coefficients()
 
     // Natural frequency
     float wn;
-    float T = d_update_interval;
+    const float T = d_update_interval;
 
-    float zeta = 1.0F / std::sqrt(2.0F);
+    const float zeta = 1.0F / std::sqrt(2.0F);
 
     // The following is based on the bilinear transform approximation of
     // the analog integrator. The loop format is from Kaplan & Hegarty
@@ -167,8 +167,8 @@ void Tracking_loop_filter::update_coefficients()
             break;
         case 3:
             wn = d_noise_bandwidth / 0.7845F;  // From Kaplan
-            float a3 = 1.1;
+            const float a3 = 1.1;
-            float b3 = 2.4;
+            const float b3 = 2.4;
             g1 = wn * wn * wn;
             g2 = a3 * wn * wn;
             g3 = b3 * wn;