20 files changed, 54 insertions, 51 deletions
diff --git a/gr-fec/lib/alist.cc b/gr-fec/lib/alist.cc
index 9cedf42e99..b0a6ba34b3 100644
--- a/gr-fec/lib/alist.cc
+++ b/gr-fec/lib/alist.cc
@@ -12,9 +12,9 @@
 
 alist::alist(const char* fname) : data_ok(false) { read(fname); }
 
-std::vector<std::vector<char>> alist::get_matrix()
+std::vector<std::vector<uint8_t>> alist::get_matrix()
 {
-    std::vector<std::vector<char>> mat;
+    std::vector<std::vector<uint8_t>> mat;
     mat.resize(M);
     for (int i = 0; i < M; i++) {
         mat[i].resize(N);
diff --git a/gr-fec/lib/async_decoder_impl.cc b/gr-fec/lib/async_decoder_impl.cc
index 8848964f49..7188c23cc4 100644
--- a/gr-fec/lib/async_decoder_impl.cc
+++ b/gr-fec/lib/async_decoder_impl.cc
@@ -52,11 +52,10 @@ async_decoder_impl::async_decoder_impl(generic_decoder::sptr my_decoder,
 
     if (d_packed) {
         d_pack = new blocks::kernel::pack_k_bits(8);
-        set_msg_handler(d_in_port,
-                        boost::bind(&async_decoder_impl::decode_packed, this, _1));
+        set_msg_handler(d_in_port, [this](pmt::pmt_t msg) { this->decode_packed(msg); });
     } else {
         set_msg_handler(d_in_port,
-                        boost::bind(&async_decoder_impl::decode_unpacked, this, _1));
+                        [this](pmt::pmt_t msg) { this->decode_unpacked(msg); });
     }
 
     // The maximum frame size is set by the initial frame size of the decoder.
diff --git a/gr-fec/lib/async_encoder_impl.cc b/gr-fec/lib/async_encoder_impl.cc
index 8cb0992d5d..e8d24ad331 100644
--- a/gr-fec/lib/async_encoder_impl.cc
+++ b/gr-fec/lib/async_encoder_impl.cc
@@ -51,8 +51,7 @@ async_encoder_impl::async_encoder_impl(generic_encoder::sptr my_encoder,
     message_port_register_out(d_out_port);
 
     if (d_packed) {
-        set_msg_handler(d_in_port,
-                        boost::bind(&async_encoder_impl::encode_packed, this, _1));
+        set_msg_handler(d_in_port, [this](pmt::pmt_t msg) { this->encode_packed(msg); });
 
         d_unpack = new blocks::kernel::unpack_k_bits(8);
 
@@ -62,7 +61,7 @@ async_encoder_impl::async_encoder_impl(generic_encoder::sptr my_encoder,
 
     } else {
         set_msg_handler(d_in_port,
-                        boost::bind(&async_encoder_impl::encode_unpacked, this, _1));
+                        [this](pmt::pmt_t msg) { this->encode_unpacked(msg); });
     }
 
     if (d_packed || (strncmp(d_encoder->get_input_conversion(), "pack", 4) == 0)) {
diff --git a/gr-fec/lib/awgn_bp.cc b/gr-fec/lib/awgn_bp.cc
index 5d6d3bb6f8..43b73cf875 100644
--- a/gr-fec/lib/awgn_bp.cc
+++ b/gr-fec/lib/awgn_bp.cc
@@ -134,7 +134,7 @@ void awgn_bp::update_vars()
     }
 }
 
-std::vector<char> awgn_bp::get_estimate() { return estimate; }
+std::vector<uint8_t> awgn_bp::get_estimate() { return estimate; }
 
 void awgn_bp::compute_init_estimate(std::vector<float> rx_word)
 {
@@ -160,9 +160,9 @@ void awgn_bp::set_K(int k) { K = k; }
 
 int awgn_bp::get_K() { return K; }
 
-std::vector<char> awgn_bp::get_syndrome(std::vector<char> codeword)
+std::vector<uint8_t> awgn_bp::get_syndrome(std::vector<uint8_t> codeword)
 {
-    std::vector<char> synd;
+    std::vector<uint8_t> synd;
     synd.resize(N - K);
     GF2Vec in_bvec;
     in_bvec.set_vec(codeword);
@@ -172,9 +172,9 @@ std::vector<char> awgn_bp::get_syndrome(std::vector<char> codeword)
     return synd;
 }
 
-std::vector<char> awgn_bp::get_syndrome()
+std::vector<uint8_t> awgn_bp::get_syndrome()
 {
-    std::vector<char> synd;
+    std::vector<uint8_t> synd;
     synd.resize(N - K);
     GF2Vec in_bvec;
     in_bvec.set_vec(estimate);
@@ -184,9 +184,9 @@ std::vector<char> awgn_bp::get_syndrome()
     return synd;
 }
 
-bool awgn_bp::is_codeword(std::vector<char> codeword)
+bool awgn_bp::is_codeword(std::vector<uint8_t> codeword)
 {
-    std::vector<char> synd;
+    std::vector<uint8_t> synd;
     synd = get_syndrome(codeword);
     bool is_code;
     is_code = true;
@@ -200,7 +200,7 @@ bool awgn_bp::is_codeword(std::vector<char> codeword)
 
 bool awgn_bp::is_codeword()
 {
-    std::vector<char> synd;
+    std::vector<uint8_t> synd;
     synd = get_syndrome();
     bool is_code;
     is_code = true;
@@ -216,7 +216,7 @@ void awgn_bp::set_max_iterations(int k) { max_iterations = k; }
 
 int awgn_bp::get_max_iterations() { return max_iterations; }
 
-std::vector<char> awgn_bp::decode(std::vector<float> rx_word, int* niteration)
+std::vector<uint8_t> awgn_bp::decode(std::vector<float> rx_word, int* niteration)
 {
     *niteration = 0;
     compute_init_estimate(rx_word);
diff --git a/gr-fec/lib/cldpc.cc b/gr-fec/lib/cldpc.cc
index f4fb9f28a5..8a21d33c78 100644
--- a/gr-fec/lib/cldpc.cc
+++ b/gr-fec/lib/cldpc.cc
@@ -38,9 +38,9 @@ void cldpc::set_alist(const alist _list)
     K = N - rank_H;
 }
 
-std::vector<char> cldpc::get_systematic_bits(std::vector<char> in)
+std::vector<uint8_t> cldpc::get_systematic_bits(std::vector<uint8_t> in)
 {
-    std::vector<char> data;
+    std::vector<uint8_t> data;
     data.resize(K);
     int index;
     for (size_t i = 0; i < K; i++) {
@@ -58,9 +58,9 @@ void cldpc::print_permute()
     std::cout << "\n";
 }
 
-std::vector<char> cldpc::syndrome(const std::vector<char> in)
+std::vector<uint8_t> cldpc::syndrome(const std::vector<uint8_t> in)
 {
-    std::vector<char> synd;
+    std::vector<uint8_t> synd;
     synd.resize(rank_H);
     GF2Vec in_bvec;
     in_bvec.set_vec(in);
@@ -70,9 +70,9 @@ std::vector<char> cldpc::syndrome(const std::vector<char> in)
     return synd;
 }
 
-bool cldpc::is_codeword(const std::vector<char> in)
+bool cldpc::is_codeword(const std::vector<uint8_t> in)
 {
-    std::vector<char> synd;
+    std::vector<uint8_t> synd;
     synd = syndrome(in);
     bool is_code;
     is_code = true;
@@ -84,7 +84,7 @@ bool cldpc::is_codeword(const std::vector<char> in)
     return is_code;
 }
 
-std::vector<char> cldpc::encode(std::vector<char> dataword)
+std::vector<uint8_t> cldpc::encode(std::vector<uint8_t> dataword)
 {
     if (dataword.size() == K) {
         GF2Vec x(N);
@@ -103,7 +103,7 @@ std::vector<char> cldpc::encode(std::vector<char> dataword)
         return y.get_vec();
     } else {
         throw std::runtime_error("bad vector length!");
-        return std::vector<char>();
+        return std::vector<uint8_t>();
     }
 }
 
diff --git a/gr-fec/lib/depuncture_bb_impl.cc b/gr-fec/lib/depuncture_bb_impl.cc
index d282170040..d5a765f2a2 100644
--- a/gr-fec/lib/depuncture_bb_impl.cc
+++ b/gr-fec/lib/depuncture_bb_impl.cc
@@ -23,13 +23,17 @@
 namespace gr {
 namespace fec {
 
-depuncture_bb::sptr depuncture_bb::make(int puncsize, int puncpat, int delay, char symbol)
+depuncture_bb::sptr
+depuncture_bb::make(int puncsize, int puncpat, int delay, uint8_t symbol)
 {
     return gnuradio::get_initial_sptr(
         new depuncture_bb_impl(puncsize, puncpat, delay, symbol));
 }
 
-depuncture_bb_impl::depuncture_bb_impl(int puncsize, int puncpat, int delay, char symbol)
+depuncture_bb_impl::depuncture_bb_impl(int puncsize,
+                                       int puncpat,
+                                       int delay,
+                                       uint8_t symbol)
     : block("depuncture_bb",
             io_signature::make(1, 1, sizeof(unsigned char)),
             io_signature::make(1, 1, sizeof(unsigned char))),
@@ -62,7 +66,7 @@ depuncture_bb_impl::depuncture_bb_impl(int puncsize, int puncpat, int delay, cha
     set_fixed_rate(true);
     set_relative_rate((uint64_t)d_puncsize, (uint64_t)(d_puncsize - d_puncholes));
     set_output_multiple(d_puncsize);
-    // set_msg_handler(boost::bind(&depuncture_bb_impl::catch_msg, this, _1));
+    // set_msg_handler(<portname>, [this](pmt::pmt_t msg) { this->catch_msg(msg); });
 }
 
 depuncture_bb_impl::~depuncture_bb_impl() {}
diff --git a/gr-fec/lib/depuncture_bb_impl.h b/gr-fec/lib/depuncture_bb_impl.h
index 9be680eb36..4a7c1f0422 100644
--- a/gr-fec/lib/depuncture_bb_impl.h
+++ b/gr-fec/lib/depuncture_bb_impl.h
@@ -26,7 +26,7 @@ private:
     char d_sym;
 
 public:
-    depuncture_bb_impl(int puncsize, int puncpat, int delay = 0, char symbol = 127);
+    depuncture_bb_impl(int puncsize, int puncpat, int delay = 0, uint8_t symbol = 127);
     ~depuncture_bb_impl();
 
     int general_work(int noutput_items,
diff --git a/gr-fec/lib/gf2mat.cc b/gr-fec/lib/gf2mat.cc
index a41f42b486..d07c6e2f3d 100644
--- a/gr-fec/lib/gf2mat.cc
+++ b/gr-fec/lib/gf2mat.cc
@@ -24,7 +24,7 @@ GF2Mat::GF2Mat(int m, int n)
     }
 }
 
-GF2Mat::GF2Mat(std::vector<std::vector<char>> X)
+GF2Mat::GF2Mat(std::vector<std::vector<uint8_t>> X)
 {
     M = X.size();
     N = X[0].size();
@@ -179,4 +179,4 @@ GF2Mat GF2Mat::get_G(std::vector<int>& permute, int& rank)
     return G;
 }
 
-std::vector<std::vector<char>> GF2Mat::get_H() { return H; }
+std::vector<std::vector<uint8_t>> GF2Mat::get_H() { return H; }
diff --git a/gr-fec/lib/gf2vec.cc b/gr-fec/lib/gf2vec.cc
index 9f0153f6c8..0c12271b03 100644
--- a/gr-fec/lib/gf2vec.cc
+++ b/gr-fec/lib/gf2vec.cc
@@ -13,13 +13,13 @@
 
 GF2Vec::GF2Vec(int size) { vec.resize(size); }
 
-void GF2Vec::set_vec(const std::vector<char> in) { vec = in; }
+void GF2Vec::set_vec(const std::vector<uint8_t> in) { vec = in; }
 
-std::vector<char> GF2Vec::get_vec() { return vec; }
+std::vector<uint8_t> GF2Vec::get_vec() { return vec; }
 
 int GF2Vec::size() { return vec.size(); }
 
-char& GF2Vec::operator[](int i) { return vec[i]; }
+uint8_t& GF2Vec::operator[](int i) { return vec[i]; }
 
 GF2Vec operator+(GF2Vec a, GF2Vec b)
 {
@@ -40,7 +40,7 @@ GF2Vec GF2Vec::sub_vector(int from, int to)
     return x;
 }
 
-char operator*(GF2Vec a, GF2Vec b)
+uint8_t operator*(GF2Vec a, GF2Vec b)
 {
     char sum;
     sum = char(0);
diff --git a/gr-fec/lib/ldpc_decoder.cc b/gr-fec/lib/ldpc_decoder.cc
index 166e374d1d..2daa93aad3 100644
--- a/gr-fec/lib/ldpc_decoder.cc
+++ b/gr-fec/lib/ldpc_decoder.cc
@@ -84,8 +84,8 @@ void ldpc_decoder::generic_work(void* inBuffer, void* outBuffer)
         }
 
         int n_iterations = 0;
-        std::vector<char> estimate(d_spa.decode(rx, &n_iterations));
-        std::vector<char> data(d_code.get_systematic_bits(estimate));
+        std::vector<uint8_t> estimate(d_spa.decode(rx, &n_iterations));
+        std::vector<uint8_t> data(d_code.get_systematic_bits(estimate));
         memcpy(&out[j], &data[0], d_code.dimension());
         d_iterations = n_iterations;
 
diff --git a/gr-fec/lib/ldpc_encoder_impl.cc b/gr-fec/lib/ldpc_encoder_impl.cc
index 9ed72259e6..103cf38379 100644
--- a/gr-fec/lib/ldpc_encoder_impl.cc
+++ b/gr-fec/lib/ldpc_encoder_impl.cc
@@ -46,9 +46,9 @@ void ldpc_encoder_impl::generic_work(void* inBuffer, void* outBuffer)
 {
     const unsigned char* in = (const unsigned char*)inBuffer;
     unsigned char* out = (unsigned char*)outBuffer;
-    std::vector<char> inbuf(inputSize);
+    std::vector<uint8_t> inbuf(inputSize);
     memcpy(&inbuf[0], in, inputSize);
-    std::vector<char> coded(d_code.encode(inbuf));
+    std::vector<uint8_t> coded(d_code.encode(inbuf));
     memcpy(&out[0], &coded[0], coded.size());
 }
 
diff --git a/gr-fec/lib/polar_common.cc b/gr-fec/lib/polar_common.cc
index 589c7a5f8f..be765671b7 100644
--- a/gr-fec/lib/polar_common.cc
+++ b/gr-fec/lib/polar_common.cc
@@ -31,7 +31,7 @@ namespace code {
 polar_common::polar_common(int block_size,
                            int num_info_bits,
                            std::vector<int> frozen_bit_positions,
-                           std::vector<char> frozen_bit_values)
+                           std::vector<uint8_t> frozen_bit_values)
     : d_frozen_bit_positions(frozen_bit_positions),
       d_frozen_bit_values(frozen_bit_values),
       d_block_size(block_size),
diff --git a/gr-fec/lib/polar_decoder_common.cc b/gr-fec/lib/polar_decoder_common.cc
index 4a59cbfe3f..392451737e 100644
--- a/gr-fec/lib/polar_decoder_common.cc
+++ b/gr-fec/lib/polar_decoder_common.cc
@@ -27,7 +27,7 @@ const float polar_decoder_common::D_LLR_FACTOR = -2.19722458f;
 polar_decoder_common::polar_decoder_common(int block_size,
                                            int num_info_bits,
                                            std::vector<int> frozen_bit_positions,
-                                           std::vector<char> frozen_bit_values)
+                                           std::vector<uint8_t> frozen_bit_values)
     : polar_common(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values),
       d_frozen_bit_counter(0)
 {
diff --git a/gr-fec/lib/polar_decoder_sc.cc b/gr-fec/lib/polar_decoder_sc.cc
index 29493d4760..9d694bf3bb 100644
--- a/gr-fec/lib/polar_decoder_sc.cc
+++ b/gr-fec/lib/polar_decoder_sc.cc
@@ -26,7 +26,7 @@ namespace code {
 generic_decoder::sptr polar_decoder_sc::make(int block_size,
                                              int num_info_bits,
                                              std::vector<int> frozen_bit_positions,
-                                             std::vector<char> frozen_bit_values)
+                                             std::vector<uint8_t> frozen_bit_values)
 {
     return generic_decoder::sptr(new polar_decoder_sc(
         block_size, num_info_bits, frozen_bit_positions, frozen_bit_values));
@@ -35,7 +35,7 @@ generic_decoder::sptr polar_decoder_sc::make(int block_size,
 polar_decoder_sc::polar_decoder_sc(int block_size,
                                    int num_info_bits,
                                    std::vector<int> frozen_bit_positions,
-                                   std::vector<char> frozen_bit_values)
+                                   std::vector<uint8_t> frozen_bit_values)
     : polar_decoder_common(
           block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)
 {
diff --git a/gr-fec/lib/polar_decoder_sc_list.cc b/gr-fec/lib/polar_decoder_sc_list.cc
index 9067fdba67..7f537cde18 100644
--- a/gr-fec/lib/polar_decoder_sc_list.cc
+++ b/gr-fec/lib/polar_decoder_sc_list.cc
@@ -28,7 +28,7 @@ generic_decoder::sptr polar_decoder_sc_list::make(int max_list_size,
                                                   int block_size,
                                                   int num_info_bits,
                                                   std::vector<int> frozen_bit_positions,
-                                                  std::vector<char> frozen_bit_values)
+                                                  std::vector<uint8_t> frozen_bit_values)
 {
     return generic_decoder::sptr(new polar_decoder_sc_list(max_list_size,
                                                            block_size,
@@ -41,7 +41,7 @@ polar_decoder_sc_list::polar_decoder_sc_list(int max_list_size,
                                              int block_size,
                                              int num_info_bits,
                                              std::vector<int> frozen_bit_positions,
-                                             std::vector<char> frozen_bit_values)
+                                             std::vector<uint8_t> frozen_bit_values)
     : polar_decoder_common(
           block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)
 {
diff --git a/gr-fec/lib/polar_decoder_sc_systematic.cc b/gr-fec/lib/polar_decoder_sc_systematic.cc
index e743edabb2..20fbad2d38 100644
--- a/gr-fec/lib/polar_decoder_sc_systematic.cc
+++ b/gr-fec/lib/polar_decoder_sc_systematic.cc
@@ -30,7 +30,7 @@ generic_decoder::sptr polar_decoder_sc_systematic::make(
 polar_decoder_sc_systematic::polar_decoder_sc_systematic(
     int block_size, int num_info_bits, std::vector<int> frozen_bit_positions)
     : polar_decoder_common(
-          block_size, num_info_bits, frozen_bit_positions, std::vector<char>())
+          block_size, num_info_bits, frozen_bit_positions, std::vector<uint8_t>())
 {
     d_llr_vec = (float*)volk_malloc(sizeof(float) * block_size * (block_power() + 1),
                                     volk_get_alignment());
diff --git a/gr-fec/lib/polar_encoder.cc b/gr-fec/lib/polar_encoder.cc
index ad35c0cc37..568a0b8e5e 100644
--- a/gr-fec/lib/polar_encoder.cc
+++ b/gr-fec/lib/polar_encoder.cc
@@ -28,7 +28,7 @@ namespace code {
 generic_encoder::sptr polar_encoder::make(int block_size,
                                           int num_info_bits,
                                           std::vector<int> frozen_bit_positions,
-                                          std::vector<char> frozen_bit_values,
+                                          std::vector<uint8_t> frozen_bit_values,
                                           bool is_packed)
 {
     return generic_encoder::sptr(new polar_encoder(
@@ -38,7 +38,7 @@ generic_encoder::sptr polar_encoder::make(int block_size,
 polar_encoder::polar_encoder(int block_size,
                              int num_info_bits,
                              std::vector<int>& frozen_bit_positions,
-                             std::vector<char>& frozen_bit_values,
+                             std::vector<uint8_t>& frozen_bit_values,
                              bool is_packed)
     : polar_common(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values),
       d_is_packed(is_packed)
diff --git a/gr-fec/lib/polar_encoder_systematic.cc b/gr-fec/lib/polar_encoder_systematic.cc
index 1bff485504..b77f5e0730 100644
--- a/gr-fec/lib/polar_encoder_systematic.cc
+++ b/gr-fec/lib/polar_encoder_systematic.cc
@@ -30,7 +30,8 @@ generic_encoder::sptr polar_encoder_systematic::make(
 polar_encoder_systematic::polar_encoder_systematic(int block_size,
                                                    int num_info_bits,
                                                    std::vector<int> frozen_bit_positions)
-    : polar_common(block_size, num_info_bits, frozen_bit_positions, std::vector<char>())
+    : polar_common(
+          block_size, num_info_bits, frozen_bit_positions, std::vector<uint8_t>())
 {
     d_volk_syst_intermediate = (unsigned char*)volk_malloc(
         sizeof(unsigned char) * block_size, volk_get_alignment());
diff --git a/gr-fec/lib/puncture_bb_impl.cc b/gr-fec/lib/puncture_bb_impl.cc
index 54271b66f4..49f1bcfb55 100644
--- a/gr-fec/lib/puncture_bb_impl.cc
+++ b/gr-fec/lib/puncture_bb_impl.cc
@@ -60,7 +60,7 @@ puncture_bb_impl::puncture_bb_impl(int puncsize, int puncpat, int delay)
     set_fixed_rate(true);
     set_relative_rate((uint64_t)(d_puncsize - d_puncholes), (uint64_t)d_puncsize);
     set_output_multiple(d_puncsize - d_puncholes);
-    // set_msg_handler(boost::bind(&puncture_bb_impl::catch_msg, this, _1));
+    // set_msg_handler(<portname>, [this](pmt::pmt_t msg) { this->catch_msg(msg); });
 }
 
 puncture_bb_impl::~puncture_bb_impl() {}
diff --git a/gr-fec/lib/puncture_ff_impl.cc b/gr-fec/lib/puncture_ff_impl.cc
index a8f6c69b21..4b8c74f014 100644
--- a/gr-fec/lib/puncture_ff_impl.cc
+++ b/gr-fec/lib/puncture_ff_impl.cc
@@ -60,7 +60,7 @@ puncture_ff_impl::puncture_ff_impl(int puncsize, int puncpat, int delay)
     set_fixed_rate(true);
     set_relative_rate((uint64_t)(d_puncsize - d_puncholes), (uint64_t)d_puncsize);
     set_output_multiple(d_puncsize - d_puncholes);
-    // set_msg_handler(boost::bind(&puncture_ff_impl::catch_msg, this, _1));
+    // set_msg_handler(<portname>, [this](pmt::pmt_t msg) { this->catch_msg(msg); });
 }
 
 puncture_ff_impl::~puncture_ff_impl() {}