Replace some C-style casts by C++ casts

src/algorithms/PVT/gnuradio_blocks/rtklib_pvt_cc.cc

@@ -1161,10 +1161,10 @@ int rtklib_pvt_cc::work (int noutput_items, gr_vector_const_void_star &input_ite
                                     for (unsigned int i = 0; i < d_nchannels; i++)
                                         {
                                             tmp_double = in[i][epoch].Pseudorange_m;
-                                            d_dump_file.write((char*)&tmp_double, sizeof(double));
+                                            d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                                             tmp_double = 0;
-                                            d_dump_file.write((char*)&tmp_double, sizeof(double));
-                                            d_dump_file.write((char*)&d_rx_time, sizeof(double));
+                                            d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
+                                            d_dump_file.write(reinterpret_cast<char*>(&d_rx_time), sizeof(double));
                                         }
                             }
                             catch (const std::ifstream::failure& e)

src/algorithms/PVT/libs/hybrid_ls_pvt.cc

@@ -361,28 +361,28 @@ bool hybrid_ls_pvt::get_PVT(std::map<int,Gnss_Synchro> gnss_observables_map, dou
                                     double tmp_double;
                                     //  PVT GPS time
                                     tmp_double = hybrid_current_time;
-                                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                                     // ECEF User Position East [m]
                                     tmp_double = rx_position_and_time(0);
-                                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                                     // ECEF User Position North [m]
                                     tmp_double = rx_position_and_time(1);
-                                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                                     // ECEF User Position Up [m]
                                     tmp_double = rx_position_and_time(2);
-                                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                                     // User clock offset [s]
                                     tmp_double = rx_position_and_time(3);
-                                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                                     // GEO user position Latitude [deg]
                                     tmp_double = this->get_latitude();
-                                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                                     // GEO user position Longitude [deg]
                                     tmp_double = this->get_longitude();
-                                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                                     // GEO user position Height [m]
                                     tmp_double = this->get_height();
-                                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                             }
                             catch (const std::ifstream::failure& e)
                             {

src/algorithms/PVT/libs/rtklib_solver.cc

@@ -336,28 +336,28 @@ bool rtklib_solver::get_PVT(const std::map<int,Gnss_Synchro> & gnss_observables_
                                     double tmp_double;
                                     //  PVT GPS time
                                     tmp_double = Rx_time;
-                                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                                     // ECEF User Position East [m]
                                     tmp_double = rx_position_and_time(0);
-                                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                                     // ECEF User Position North [m]
                                     tmp_double = rx_position_and_time(1);
-                                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                                     // ECEF User Position Up [m]
                                     tmp_double = rx_position_and_time(2);
-                                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                                     // User clock offset [s]
                                     tmp_double = rx_position_and_time(3);
-                                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                                     // GEO user position Latitude [deg]
                                     tmp_double = this->get_latitude();
-                                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                                     // GEO user position Longitude [deg]
                                     tmp_double = this->get_longitude();
-                                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                                     // GEO user position Height [m]
                                     tmp_double = this->get_height();
-                                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                             }
                             catch (const std::ifstream::failure& e)
                             {

src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.cc

@@ -253,17 +253,15 @@ void GpsL2MPcpsAcquisition::set_local_code()
             acquisition_cc_->set_local_code(code_);
         }
         
-//    //debug
-//    std::ofstream d_dump_file;
-//    std::stringstream filename;
-//    std::streamsize n = 2 * sizeof(float) * (code_length_); // complex file write
-//    filename.str("");
-//    filename << "../data/local_prn_sampled.dat";
-//    d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
-//    d_dump_file.write((char*)code_, n);
-//    d_dump_file.close();
-
-    //  }
+    //    //debug
+    //    std::ofstream d_dump_file;
+    //    std::stringstream filename;
+    //    std::streamsize n = 2 * sizeof(float) * (code_length_); // complex file write
+    //    filename.str("");
+    //    filename << "../data/local_prn_sampled.dat";
+    //    d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
+    //    d_dump_file.write(reinterpret_cast<char*>(code_), n);
+    //    d_dump_file.close();
 }
 
 

src/algorithms/acquisition/gnuradio_blocks/galileo_e5a_noncoherent_iq_acquisition_caf_cc.cc

@@ -628,16 +628,16 @@ int galileo_e5a_noncoherentIQ_acquisition_caf_cc::general_work(int noutput_items
                                 {
                                     if (magt_IA >= magt_IB)
                                         {
-                                            d_dump_file.write((char*)d_magnitudeIA, n);
+                                            d_dump_file.write(reinterpret_cast<char*>(d_magnitudeIA), n);
                                         }
                                     else
                                         {
-                                            d_dump_file.write((char*)d_magnitudeIB, n);
+                                            d_dump_file.write(reinterpret_cast<char*>(d_magnitudeIB), n);
                                         }
                                 }
                             else
                                 {
-                                    d_dump_file.write((char*)d_magnitudeIA, n);
+                                    d_dump_file.write(reinterpret_cast<char*>(d_magnitudeIA), n);
                                 }
                             d_dump_file.close();
                         }
@@ -738,7 +738,7 @@ int galileo_e5a_noncoherentIQ_acquisition_caf_cc::general_work(int noutput_items
                             filename.str("");
                             filename << "../data/test_statistics_E5a_sat_" << d_gnss_synchro->PRN << "_CAF.dat";
                             d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
-                            d_dump_file.write((char*)d_CAF_vector, n);
+                            d_dump_file.write(reinterpret_cast<char*>(d_CAF_vector), n);
                             d_dump_file.close();
                         }
                     volk_gnsssdr_free(accum);

src/algorithms/acquisition/gnuradio_blocks/galileo_pcps_8ms_acquisition_cc.cc

@@ -342,7 +342,7 @@ int galileo_pcps_8ms_acquisition_cc::general_work(int noutput_items,
                                      <<"_" << d_gnss_synchro->Signal << "_sat_"
                                      << d_gnss_synchro->PRN << "_doppler_" <<  doppler << ".dat";
                             d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
-                            d_dump_file.write((char*)d_ifft->get_outbuf(), n); //write directly |abs(x)|^2 in this Doppler bin?
+                            d_dump_file.write(reinterpret_cast<char*>(d_ifft->get_outbuf()), n); //write directly |abs(x)|^2 in this Doppler bin?
                             d_dump_file.close();
                         }
                 }

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_cc.cc

@@ -428,7 +428,7 @@ int pcps_acquisition_cc::general_work(int noutput_items,
                             DLOG(INFO) << "Writing ACQ out to " << filename.str();
 
                             d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
-                            d_dump_file.write((char*)d_ifft->get_outbuf(), n); //write directly |abs(x)|^2 in this Doppler bin?
+                            d_dump_file.write(reinterpret_cast<char*>(d_ifft->get_outbuf()), n); //write directly |abs(x)|^2 in this Doppler bin?
                             d_dump_file.close();
                         }
                 }
@@ -470,7 +470,6 @@ int pcps_acquisition_cc::general_work(int noutput_items,
             consume_each(1);
             break;
         }
-
     }
 
     return noutput_items;

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fine_doppler_cc.cc

@@ -261,7 +261,7 @@ double pcps_acquisition_fine_doppler_cc::search_maximum()
                     << d_gnss_synchro->PRN << "_doppler_" <<  d_gnss_synchro->Acq_doppler_hz << ".dat";
             d_dump_file.open(filename.str().c_str(), std::ios::out
                     | std::ios::binary);
-            d_dump_file.write((char*)d_grid_data[index_doppler], n); //write directly |abs(x)|^2 in this Doppler bin?
+            d_dump_file.write(reinterpret_cast<char*>(d_grid_data[index_doppler]), n); //write directly |abs(x)|^2 in this Doppler bin?
             d_dump_file.close();
         }
 
@@ -400,14 +400,14 @@ int pcps_acquisition_fine_doppler_cc::estimate_Doppler(gr_vector_const_void_star
             //        filename << "../data/code_prn_" << d_gnss_synchro->PRN << ".dat";
             //        d_dump_file.open(filename.str().c_str(), std::ios::out
             //                | std::ios::binary);
-            //        d_dump_file.write((char*)code_replica, n); //write directly |abs(x)|^2 in this Doppler bin?
+            //        d_dump_file.write(reinterpret_cast<char*>(code_replica), n); //write directly |abs(x)|^2 in this Doppler bin?
             //        d_dump_file.close();
             //
             //        filename.str("");
             //        filename << "../data/signal_prn_" << d_gnss_synchro->PRN << ".dat";
             //        d_dump_file.open(filename.str().c_str(), std::ios::out
             //                | std::ios::binary);
-            //        d_dump_file.write((char*)in, n); //write directly |abs(x)|^2 in this Doppler bin?
+            //        d_dump_file.write(reinterpret_cast<char*>(in), n); //write directly |abs(x)|^2 in this Doppler bin?
             //        d_dump_file.close();
             //
             //
@@ -416,7 +416,7 @@ int pcps_acquisition_fine_doppler_cc::estimate_Doppler(gr_vector_const_void_star
             //        filename << "../data/fft_prn_" << d_gnss_synchro->PRN << ".dat";
             //        d_dump_file.open(filename.str().c_str(), std::ios::out
             //                | std::ios::binary);
-            //        d_dump_file.write((char*)p_tmp_vector, n); //write directly |abs(x)|^2 in this Doppler bin?
+            //        d_dump_file.write(reinterpret_cast<char*>(p_tmp_vector), n); //write directly |abs(x)|^2 in this Doppler bin?
             //        d_dump_file.close();
         }
 

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_sc.cc

@@ -395,7 +395,7 @@ int pcps_acquisition_sc::general_work(int noutput_items,
                             DLOG(INFO) << "Writing ACQ out to " << filename.str();
 
                             d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
-                            d_dump_file.write((char*)d_ifft->get_outbuf(), n); //write directly |abs(x)|^2 in this Doppler bin?
+                            d_dump_file.write(reinterpret_cast<char*>(d_ifft->get_outbuf()), n); //write directly |abs(x)|^2 in this Doppler bin?
                             d_dump_file.close();
                         }
                 }

src/algorithms/acquisition/gnuradio_blocks/pcps_assisted_acquisition_cc.cc

@@ -303,7 +303,7 @@ double pcps_assisted_acquisition_cc::search_maximum()
                      << "_" << d_gnss_synchro->Signal << "_sat_"
                      << d_gnss_synchro->PRN << "_doppler_" <<  d_gnss_synchro->Acq_doppler_hz << ".dat";
             d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
-            d_dump_file.write((char*)d_grid_data[index_doppler], n); //write directly |abs(x)|^2 in this Doppler bin?
+            d_dump_file.write(reinterpret_cast<char*>(d_grid_data[index_doppler]), n); //write directly |abs(x)|^2 in this Doppler bin?
             d_dump_file.close();
         }
 

src/algorithms/acquisition/gnuradio_blocks/pcps_cccwsr_acquisition_cc.cc

@@ -367,7 +367,7 @@ int pcps_cccwsr_acquisition_cc::general_work(int noutput_items,
                                      <<"_" << d_gnss_synchro->Signal << "_sat_"
                                      << d_gnss_synchro->PRN << "_doppler_" <<  doppler << ".dat";
                             d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
-                            d_dump_file.write((char*)d_ifft->get_outbuf(), n); //write directly |abs(x)|^2 in this Doppler bin?
+                            d_dump_file.write(reinterpret_cast<char*>(d_ifft->get_outbuf()), n); //write directly |abs(x)|^2 in this Doppler bin?
                             d_dump_file.close();
                         }
                 }

src/algorithms/acquisition/gnuradio_blocks/pcps_multithread_acquisition_cc.cc

@@ -284,7 +284,7 @@ void pcps_multithread_acquisition_cc::acquisition_core()
                              <<"_" << d_gnss_synchro->Signal << "_sat_"
                              << d_gnss_synchro->PRN << "_doppler_" <<  doppler << ".dat";
                     d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
-                    d_dump_file.write((char*)d_ifft->get_outbuf(), n); //write directly |abs(x)|^2 in this Doppler bin?
+                    d_dump_file.write(reinterpret_cast<char*>(d_ifft->get_outbuf()), n); //write directly |abs(x)|^2 in this Doppler bin?
                     d_dump_file.close();
                 }
         }

src/algorithms/acquisition/gnuradio_blocks/pcps_opencl_acquisition_cc.cc

@@ -469,7 +469,7 @@ void pcps_opencl_acquisition_cc::acquisition_core_volk()
                              <<"_" << d_gnss_synchro->Signal << "_sat_"
                              << d_gnss_synchro->PRN << "_doppler_" <<  doppler << ".dat";
                     d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
-                    d_dump_file.write((char*)d_ifft->get_outbuf(), n); //write directly |abs(x)|^2 in this Doppler bin?
+                    d_dump_file.write(reinterpret_cast<char*>(d_ifft->get_outbuf()), n); //write directly |abs(x)|^2 in this Doppler bin?
                     d_dump_file.close();
                 }
         }
@@ -631,7 +631,7 @@ void pcps_opencl_acquisition_cc::acquisition_core_opencl()
                              << "_" << d_gnss_synchro->Signal << "_sat_"
                              << d_gnss_synchro->PRN << "_doppler_" <<  doppler << ".dat";
                     d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
-                    d_dump_file.write((char*)d_ifft->get_outbuf(), n); //write directly |abs(x)|^2 in this Doppler bin?
+                    d_dump_file.write(reinterpret_cast<char*>(d_ifft->get_outbuf()), n); //write directly |abs(x)|^2 in this Doppler bin?
                     d_dump_file.close();
                 }
         }

src/algorithms/acquisition/gnuradio_blocks/pcps_quicksync_acquisition_cc.cc

@@ -479,7 +479,7 @@ int pcps_quicksync_acquisition_cc::general_work(int noutput_items,
                                     << "_" << d_gnss_synchro->Signal << "_sat_"
                                     << d_gnss_synchro->PRN << "_doppler_" <<  doppler << ".dat";
                             d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
-                            d_dump_file.write((char*)d_magnitude_folded, n); //write directly |abs(x)|^2 in this Doppler bin?
+                            d_dump_file.write(reinterpret_cast<char*>(d_magnitude_folded), n); //write directly |abs(x)|^2 in this Doppler bin?
                             d_dump_file.close();
                         }
                 }
@@ -489,12 +489,10 @@ int pcps_quicksync_acquisition_cc::general_work(int noutput_items,
                     if (d_test_statistics > d_threshold)
                         {
                             d_state = 2; // Positive acquisition
-
                         }
                     else if (d_well_count == d_max_dwells)
                         {
                             d_state = 3; // Negative acquisition
-
                         }
                 }
             else

src/algorithms/acquisition/gnuradio_blocks/pcps_tong_acquisition_cc.cc

@@ -357,7 +357,7 @@ int pcps_tong_acquisition_cc::general_work(int noutput_items,
                                      <<"_" << d_gnss_synchro->Signal << "_sat_"
                                      << d_gnss_synchro->PRN << "_doppler_" <<  doppler << ".dat";
                             d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
-                            d_dump_file.write((char*)d_ifft->get_outbuf(), n); //write directly |abs(x)|^2 in this Doppler bin?
+                            d_dump_file.write(reinterpret_cast<char*>(d_ifft->get_outbuf()), n); //write directly |abs(x)|^2 in this Doppler bin?
                             d_dump_file.close();
                         }
                 }

src/algorithms/telemetry_decoder/gnuradio_blocks/galileo_e1b_telemetry_decoder_cc.cc

@@ -452,11 +452,11 @@ int galileo_e1b_telemetry_decoder_cc::general_work (int noutput_items __attribut
                 double tmp_double;
                 unsigned long int tmp_ulong_int;
                 tmp_double = d_TOW_at_current_symbol;
-                d_dump_file.write((char*)&tmp_double, sizeof(double));
+                d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                 tmp_ulong_int = current_symbol.Tracking_sample_counter;
-                d_dump_file.write((char*)&tmp_ulong_int, sizeof(unsigned long int));
+                d_dump_file.write(reinterpret_cast<char*>(&tmp_ulong_int), sizeof(unsigned long int));
                 tmp_double = 0;
-                d_dump_file.write((char*)&tmp_double, sizeof(double));
+                d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
             }
             catch (const std::ifstream::failure & e)
             {
@@ -465,7 +465,7 @@ int galileo_e1b_telemetry_decoder_cc::general_work (int noutput_items __attribut
         }
 
     // remove used symbols from history
-    if (d_symbol_history.size()>required_symbols)
+    if (d_symbol_history.size() > required_symbols)
         {
             d_symbol_history.pop_front();
         }

src/algorithms/telemetry_decoder/gnuradio_blocks/galileo_e5a_telemetry_decoder_cc.cc

@@ -511,11 +511,11 @@ int galileo_e5a_telemetry_decoder_cc::general_work (int noutput_items __attribut
                     double tmp_double;
                     unsigned long int tmp_ulong_int;
                     tmp_double = d_TOW_at_current_symbol;
-                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                     tmp_ulong_int = current_synchro_data.Tracking_sample_counter;
-                    d_dump_file.write((char*)&tmp_ulong_int, sizeof(unsigned long int));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_ulong_int), sizeof(unsigned long int));
                     tmp_double = d_TOW_at_Preamble;
-                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
             }
             catch (const std::ifstream::failure & e)
             {

src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.cc

@@ -377,11 +377,11 @@ int gps_l1_ca_telemetry_decoder_cc::general_work (int noutput_items __attribute_
                      double tmp_double;
                      unsigned long int tmp_ulong_int;
                      tmp_double = d_TOW_at_current_symbol;
-                     d_dump_file.write((char*)&tmp_double, sizeof(double));
+                     d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                      tmp_ulong_int = current_symbol.Tracking_sample_counter;
-                     d_dump_file.write((char*)&tmp_ulong_int, sizeof(unsigned long int));
+                     d_dump_file.write(reinterpret_cast<char*>(&tmp_ulong_int), sizeof(unsigned long int));
                      tmp_double = d_TOW_at_Preamble;
-                     d_dump_file.write((char*)&tmp_double, sizeof(double));
+                     d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
              }
              catch (const std::ifstream::failure & e)
              {
@@ -390,7 +390,7 @@ int gps_l1_ca_telemetry_decoder_cc::general_work (int noutput_items __attribute_
          }
 
      // remove used symbols from history
-     if (d_symbol_history.size()>required_symbols)
+     if (d_symbol_history.size() > required_symbols)
          {
              d_symbol_history.pop_front();
          }

src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l2c_telemetry_decoder_cc.cc

@@ -184,11 +184,11 @@ int gps_l2c_telemetry_decoder_cc::general_work (int noutput_items __attribute__(
                     double tmp_double;
                     unsigned long int tmp_ulong_int;
                     tmp_double = d_TOW_at_current_symbol;
-                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                     tmp_ulong_int = current_synchro_data.Tracking_sample_counter;
-                    d_dump_file.write((char*)&tmp_ulong_int, sizeof(unsigned long int));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_ulong_int), sizeof(unsigned long int));
                     tmp_double = d_TOW_at_Preamble;
-                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
             }
             catch (const std::ifstream::failure & e)
             {

src/algorithms/tracking/gnuradio_blocks/galileo_e1_tcp_connector_tracking_cc.cc

@@ -466,40 +466,40 @@ int Galileo_E1_Tcp_Connector_Tracking_cc::general_work (int noutput_items __attr
             try
             {
                     // EPR
-                    d_dump_file.write((char*)&tmp_VE, sizeof(float));
-                    d_dump_file.write((char*)&tmp_E, sizeof(float));
-                    d_dump_file.write((char*)&tmp_P, sizeof(float));
-                    d_dump_file.write((char*)&tmp_L, sizeof(float));
-                    d_dump_file.write((char*)&tmp_VL, sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_VE), sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_E), sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_P), sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_L), sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_VL), sizeof(float));
                     // PROMPT I and Q (to analyze navigation symbols)
-                    d_dump_file.write((char*)&prompt_I, sizeof(float));
-                    d_dump_file.write((char*)&prompt_Q, sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&prompt_I), sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&prompt_Q), sizeof(float));
                     // PRN start sample stamp
-                    d_dump_file.write((char*)&d_sample_counter, sizeof(unsigned long int));
+                    d_dump_file.write(reinterpret_cast<char*>(&d_sample_counter), sizeof(unsigned long int));
                     // accumulated carrier phase
-                    d_dump_file.write((char*)&d_acc_carrier_phase_rad, sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&d_acc_carrier_phase_rad), sizeof(float));
 
                     // carrier and code frequency
-                    d_dump_file.write((char*)&d_carrier_doppler_hz, sizeof(float));
-                    d_dump_file.write((char*)&d_code_freq_chips, sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&d_carrier_doppler_hz), sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&d_code_freq_chips), sizeof(float));
 
                     //PLL commands
-                    d_dump_file.write((char*)&tmp_float, sizeof(float));
-                    d_dump_file.write((char*)&carr_error_filt_hz, sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_float), sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&carr_error_filt_hz), sizeof(float));
 
                     //DLL commands
-                    d_dump_file.write((char*)&tmp_float, sizeof(float));
-                    d_dump_file.write((char*)&code_error_filt_chips, sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_float), sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&code_error_filt_chips), sizeof(float));
 
                     // CN0 and carrier lock test
-                    d_dump_file.write((char*)&d_CN0_SNV_dB_Hz, sizeof(float));
-                    d_dump_file.write((char*)&d_carrier_lock_test, sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&d_CN0_SNV_dB_Hz), sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&d_carrier_lock_test), sizeof(float));
 
                     // AUX vars (for debug purposes)
                     tmp_float = d_rem_code_phase_samples;
-                    d_dump_file.write((char*)&tmp_float, sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_float), sizeof(float));
                     tmp_double = static_cast<double>(d_sample_counter + d_current_prn_length_samples);
-                    d_dump_file.write((char*)&tmp_double, sizeof(double));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
 
                     // PRN
                     unsigned int prn_ = d_acquisition_gnss_synchro->PRN;

src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_tcp_connector_tracking_cc.cc

@@ -502,38 +502,38 @@ int Gps_L1_Ca_Tcp_Connector_Tracking_cc::general_work (int noutput_items __attri
             try
             {
                     // EPR
-                    d_dump_file.write((char*)&tmp_E, sizeof(float));
-                    d_dump_file.write((char*)&tmp_P, sizeof(float));
-                    d_dump_file.write((char*)&tmp_L, sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_E), sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_P), sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_L), sizeof(float));
                     // PROMPT I and Q (to analyze navigation symbols)
-                    d_dump_file.write((char*)&prompt_I, sizeof(float));
-                    d_dump_file.write((char*)&prompt_Q, sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&prompt_I), sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&prompt_Q), sizeof(float));
                     // PRN start sample stamp
                     //tmp_float=(float)d_sample_counter;
-                    d_dump_file.write((char*)&d_sample_counter, sizeof(unsigned long int));
+                    d_dump_file.write(reinterpret_cast<char*>(&d_sample_counter), sizeof(unsigned long int));
                     // accumulated carrier phase
-                    d_dump_file.write((char*)&d_acc_carrier_phase_rad, sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&d_acc_carrier_phase_rad), sizeof(float));
 
                     // carrier and code frequency
-                    d_dump_file.write((char*)&d_carrier_doppler_hz, sizeof(float));
-                    d_dump_file.write((char*)&d_code_freq_hz, sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&d_carrier_doppler_hz), sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&d_code_freq_hz), sizeof(float));
 
                     //PLL commands
-                    d_dump_file.write((char*)&carr_error, sizeof(float));
-                    d_dump_file.write((char*)&carr_nco, sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&carr_error), sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&carr_nco), sizeof(float));
 
                     //DLL commands
-                    d_dump_file.write((char*)&code_error, sizeof(float));
-                    d_dump_file.write((char*)&code_nco, sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&code_error), sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&code_nco), sizeof(float));
 
                     // CN0 and carrier lock test
-                    d_dump_file.write((char*)&d_CN0_SNV_dB_Hz, sizeof(float));
-                    d_dump_file.write((char*)&d_carrier_lock_test, sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&d_CN0_SNV_dB_Hz), sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&d_carrier_lock_test), sizeof(float));
 
                     // AUX vars (for debug purposes)
                     tmp_float = 0;
-                    d_dump_file.write((char*)&tmp_float, sizeof(float));
-                    d_dump_file.write((char*)&d_sample_counter_seconds, sizeof(double));
+                    d_dump_file.write(reinterpret_cast<char*>(&tmp_float), sizeof(float));
+                    d_dump_file.write(reinterpret_cast<char*>(&d_sample_counter_seconds), sizeof(double));
 
                     // PRN
                     unsigned int prn_ = d_acquisition_gnss_synchro->PRN;