Merge pull request #90 from DmitriiKuchevskii/GCC-10-build

Fixed complation issues and warnings to build with GCC-10

Author: huangminghuang

src/mfast/aggregate_ref.h

@@ -125,6 +125,7 @@ template <typename ConstRef> class make_aggregate_mref : public ConstRef {
                       instruction_cptr instruction);
 
   explicit make_aggregate_mref(const field_mref_base &other);
+  explicit make_aggregate_mref(const make_aggregate_mref &other) = default;
 
   field_mref operator[](size_t index) const;
 

src/mfast/coder/encoder/fast_encoder.cpp

@@ -50,8 +50,7 @@ struct fast_encoder_impl : simple_template_repo_t {
   }
 
   void visit(enum_cref cref) {
-    uint64_cref tmp;
-    std::memcpy(&tmp, &cref, sizeof(cref));
+    uint64_cref tmp{cref};
     this->visit(tmp);
   }
 

src/mfast/instructions/group_instruction.cpp

@@ -86,7 +86,7 @@ void group_field_instruction::construct_value(value_storage &storage,
   if (construct_subfields)
     construct_group_subfields(storage.of_group.content_, alloc);
   else
-    memset(storage.of_group.content_, 0, this->group_content_byte_count());
+    memset(reinterpret_cast<char*>(storage.of_group.content_), 0, this->group_content_byte_count());
 }
 
 void group_field_instruction::copy_construct_value(

src/mfast/instructions/templateref_instruction.cpp

@@ -29,8 +29,8 @@ void templateref_instruction::construct_value(
       from_inst->construct_group_subfields(storage.of_templateref.content_,
                                            alloc);
     else
-      memset(storage.of_templateref.content_, 0,
-             from_inst->group_content_byte_count());
+       memset(reinterpret_cast<char*>(storage.of_templateref.content_), 0,
+              from_inst->group_content_byte_count());
   } else {
     storage.of_templateref.content_ = nullptr;
   }

src/mfast/value_storage.h

@@ -9,6 +9,7 @@
 #include <stdint.h>
 #include <cstring>
 #include <array>
+#include <istream>
 
 namespace mfast {
 class template_instruction;

src/mfast/vector_ref.h

@@ -40,6 +40,7 @@ class vector_cref_base : public field_cref {
   typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
   vector_cref_base() {}
+  explicit vector_cref_base (const vector_cref_base&) = default;
   vector_cref_base(const value_storage *storage, instruction_cptr instruction)
       : field_cref(storage, instruction) {}
 

tests/decoder_operator_test.cpp

@@ -497,9 +497,9 @@ TEST_CASE("test the decoding of fast operator copy","[operator_copy_decode_test]
     inst.prev_value().present(false);    // // When the value is not present in the stream there are three cases depending on the state of the previous value:
     // // * empty – the value of the field is empty. If the field is optional the value is considered absent. It is a dynamic error [ERR D6] if the field is mandatory.
 
-    REQUIRE_THROWS_AS(decode_mref("\x80\x80", HAS_PMAP_BIT, result, CHANGE_PREVIOUS_VALUE),                                                                                  mfast::fast_error );
+    REQUIRE_THROWS_AS(decode_mref("\x80\x80", HAS_PMAP_BIT, result, CHANGE_PREVIOUS_VALUE),                                                                                  const mfast::fast_error& );
     inst.prev_value().present(false);
-    REQUIRE_THROWS_AS(decode_ext_mref("\x80\x80", HAS_PMAP_BIT, ext_mref<uint64_mref, copy_operator_tag, mandatory_with_initial_value_tag >(result), CHANGE_PREVIOUS_VALUE), mfast::fast_error );
+    REQUIRE_THROWS_AS(decode_ext_mref("\x80\x80", HAS_PMAP_BIT, ext_mref<uint64_mref, copy_operator_tag, mandatory_with_initial_value_tag >(result), CHANGE_PREVIOUS_VALUE), const mfast::fast_error& );
   }
 
   {
@@ -644,8 +644,8 @@ TEST_CASE("test the decoding of fast operator increment","[operator_increment_de
     inst.prev_value().present(false);
     // When the value is not present in the stream there are three cases depending on the state of the previous value:
     // * empty – the value of the field is empty. If the field is optional the value is considered absent. It is a dynamic error [ERR D6] if the field is mandatory.
-    REQUIRE_THROWS_AS(decode_mref("\x80\x80", HAS_PMAP_BIT, result, CHANGE_PREVIOUS_VALUE),                                                                                       mfast::fast_error);
-    REQUIRE_THROWS_AS(decode_ext_mref("\x80\x80", HAS_PMAP_BIT, ext_mref<uint64_mref, increment_operator_tag, mandatory_with_initial_value_tag >(result), CHANGE_PREVIOUS_VALUE), mfast::fast_error);
+    REQUIRE_THROWS_AS(decode_mref("\x80\x80", HAS_PMAP_BIT, result, CHANGE_PREVIOUS_VALUE),                                                                                       const mfast::fast_error&);
+    REQUIRE_THROWS_AS(decode_ext_mref("\x80\x80", HAS_PMAP_BIT, ext_mref<uint64_mref, increment_operator_tag, mandatory_with_initial_value_tag >(result), CHANGE_PREVIOUS_VALUE), const mfast::fast_error&);
   }
 
   {
@@ -980,10 +980,10 @@ TEST_CASE("test the decoding of fast operator delta for ascii string","[operator
     REQUIRE_THROWS_AS(decode_mref("\xC0\x86\x76\x61\x6C\x75\xE5",
                                   NO_PMAP_BIT,
                                   result,
-                                  CHANGE_PREVIOUS_VALUE),                mfast::fast_error);
+                                  CHANGE_PREVIOUS_VALUE),                const mfast::fast_error&);
     inst.prev_value().defined(false); // reset the previous value to undefined again
     REQUIRE_THROWS_AS(decode_ext_mref("\xC0\x86\x76\x61\x6C\x75\xE5", NO_PMAP_BIT, ext_mref<ascii_string_mref, delta_operator_tag, mandatory_without_initial_value_tag >(
-                                        result), CHANGE_PREVIOUS_VALUE), mfast::fast_error);
+                                        result), CHANGE_PREVIOUS_VALUE), const mfast::fast_error&);
 
     inst.destruct_value(storage, &alloc);
   }
@@ -1117,10 +1117,10 @@ TEST_CASE("test the decoding of fast operator delta for unicode string","[operat
 
     // result.as("initial_value");
     REQUIRE_THROWS_AS(decode_mref("\xC0\x86\x85\x76\x61\x6C\x75\x65", NO_PMAP_BIT, result, CHANGE_PREVIOUS_VALUE),
-                      mfast::fast_error );
+                      const mfast::fast_error& );
     REQUIRE_THROWS_AS(decode_ext_mref("\xC0\x86\x85\x76\x61\x6C\x75\x65", NO_PMAP_BIT,
                                       ext_mref<unicode_string_mref, delta_operator_tag, mandatory_without_initial_value_tag >(result), CHANGE_PREVIOUS_VALUE),
-                      mfast::fast_error );
+                      const mfast::fast_error& );
     inst.destruct_value(storage, &alloc);
   }
 
@@ -1224,7 +1224,7 @@ TEST_CASE("test the decoding of fast operator tail for ascii string","[operator_
     //  undefined – the base value is the initial value if present in the instruction context. Otherwise a type dependant default base value is used.
     result.as("initial_string");
     REQUIRE(decode_mref("\x80\x80", HAS_PMAP_BIT, result, CHANGE_PREVIOUS_VALUE) );
-    memset(const_cast<value_storage*>(&inst.prev_value()), 0, sizeof(value_storage));
+    memset(reinterpret_cast<char*>(const_cast<value_storage*>(&inst.prev_value()))  , 0, sizeof(value_storage));
     ascii_string_mref prev(&alloc, &inst.prev_value(), &inst);
 
     // change the previous value to "ABCDE" so we can verified the case with defined previous value
@@ -1256,7 +1256,7 @@ TEST_CASE("test the decoding of fast operator tail for ascii string","[operator_
     //  undefined – the value of the field is the initial value that also becomes the new previous value.
     // It is a dynamic error [ERR D6] if the instruction context has no initial value.
 
-    REQUIRE_THROWS_AS(decode_mref("\x80\x80", HAS_PMAP_BIT, result, CHANGE_PREVIOUS_VALUE), mfast::fast_error );
+    REQUIRE_THROWS_AS(decode_mref("\x80\x80", HAS_PMAP_BIT, result, CHANGE_PREVIOUS_VALUE), const mfast::fast_error& );
 
     inst.destruct_value(storage, &alloc);
   }

tests/encoder_operator_test.cpp

@@ -528,12 +528,12 @@ TEST_CASE("test the encoding of fast operator copy","[operator_copy_encode_test]
     inst.prev_value().present(false);    // // When the value is not present in the stream there are three cases depending on the state of the previous value:
     // // * empty – the value of the field is empty. If the field is optional the value is considered absent. It is a dynamic error [ERR D6] if the field is mandatory.
 
-    REQUIRE_THROWS_AS( encode_mref("\x80", result, CHANGE_PREVIOUS_VALUE), mfast::fast_error );
+    REQUIRE_THROWS_AS( encode_mref("\x80", result, CHANGE_PREVIOUS_VALUE), const mfast::fast_error& );
     inst.prev_value().present(false);    // // When the value is not present in the stream there are three cases depending on the state of the previous value:
     REQUIRE_THROWS_AS( encode_ext_cref("\x80",
                                        ext_cref<uint64_cref, copy_operator_tag, mandatory_with_initial_value_tag>(result),
                                        CHANGE_PREVIOUS_VALUE, &allocator )
-                       , mfast::fast_error );
+                       , const mfast::fast_error& );
   }
 
   {
@@ -687,12 +687,12 @@ TEST_CASE("test the encoding of fast operator increment","[operator_increment_en
     inst.prev_value().present(false);
     // When the value is not present in the stream there are three cases depending on the state of the previous value:
     // * empty – the value of the field is empty. If the field is optional the value is considered absent. It is a dynamic error [ERR D6] if the field is mandatory.
-    REQUIRE_THROWS_AS( encode_mref("\x80\x80", result, CHANGE_PREVIOUS_VALUE), mfast::fast_error);
+    REQUIRE_THROWS_AS( encode_mref("\x80\x80", result, CHANGE_PREVIOUS_VALUE), const mfast::fast_error&);
     inst.prev_value().present(false);
     REQUIRE_THROWS_AS( encode_ext_cref("\x80\x80",
                                        ext_cref<uint64_cref, increment_operator_tag, mandatory_with_initial_value_tag>(result),
                                        CHANGE_PREVIOUS_VALUE, &allocator ),
-                       mfast::fast_error);
+                       const mfast::fast_error&);
   }
 
   {

tests/fast_istream_test.cpp

@@ -25,6 +25,10 @@
 #include <stdexcept>
 #include "byte_stream.h"
 
+template <typename T, size_t N>
+char (&array_size_helper(const T (&)[N]))[N];
+#define ARRAY_SIZE(a)  sizeof(array_size_helper(a))
+
 using namespace mfast;
 
 template <typename T>
@@ -76,7 +80,7 @@ TEST_CASE("test the fast decoding of integers","[int32_test]")
 
   { // check decoding null
     char data[] = "\x80";
-    fast_istreambuf sb(data, 3);
+    fast_istreambuf sb(data, ARRAY_SIZE(data));
     fast_istream strm(&sb);
 
     uint32_t value;
@@ -122,9 +126,9 @@ TEST_CASE("test the fast decoding of ascii string","[ascii_string_test]")
   REQUIRE(decode_string( "\x40\x40\xC0", true, "\x40\x40\xC0",  3));
   REQUIRE(decode_string( "\x40\x40\xC0", false, "\x40\x40\xC0",  3));
 
-  REQUIRE_THROWS_AS(decode_string("\x00\xC0", false, nullptr, 0),    mfast::fast_error );
-  REQUIRE_THROWS_AS(decode_string("\x00\xC0", true, nullptr, 0),     mfast::fast_error );
-  REQUIRE_THROWS_AS(decode_string("\x00\x00\xC0", true, nullptr, 0), mfast::fast_error );
+  REQUIRE_THROWS_AS(decode_string("\x00\xC0", false, nullptr, 0),    const mfast::fast_error& );
+  REQUIRE_THROWS_AS(decode_string("\x00\xC0", true, nullptr, 0),     const mfast::fast_error& );
+  REQUIRE_THROWS_AS(decode_string("\x00\x00\xC0", true, nullptr, 0), const mfast::fast_error& );
 }
 
 bool

tests/field_ref_test.cpp

@@ -108,7 +108,7 @@ TEST_CASE("test the operations of interger_field","[integer_field_test]")
 #ifndef EMSCRIPTEN
     {
       helper.save_previous_value(ref);
-      REQUIRE_THROWS_AS(helper.delta_base_value_of(ref), mfast::fast_error);
+      REQUIRE_THROWS_AS(helper.delta_base_value_of(ref), const mfast::fast_error&);
     }
 #endif
     {
@@ -307,7 +307,7 @@ TEST_CASE("test the operations of decimal_field without mantissa instruction","[
     {
       ref.omit();
       helper.save_previous_value(ref);
-      REQUIRE_THROWS_AS(helper.delta_base_value_of(ref), mfast::fast_error);
+      REQUIRE_THROWS_AS(helper.delta_base_value_of(ref), const mfast::fast_error&);
     }
 #endif
     {
@@ -588,7 +588,7 @@ TEST_CASE("test the operations of string_field","[string_field_test]")
 #ifndef EMSCRIPTEN
     {
       helper.save_previous_value(ref);
-      REQUIRE_THROWS_AS(helper.delta_base_value_of(ref), mfast::fast_error);
+      REQUIRE_THROWS_AS(helper.delta_base_value_of(ref), const mfast::fast_error&);
     }
 #endif
     {