Merge pull request #537 from tfussell/warning-and-memory

Fix compiler warnings and some valgrind problems

include/xlnt/workbook/calculation_properties.hpp

@@ -38,12 +38,12 @@ public:
     /// If this is older than the version of the Excel calculation engine opening
     /// the workbook, cell values will be recalculated.
     /// </summary>
-    std::size_t calc_id;
+    std::size_t calc_id = 0;
 
     /// <summary>
     /// If this is true, concurrent calculation will be enabled for the workbook.
     /// </summary>
-    bool concurrent_calc;
+    bool concurrent_calc = false;
 };
 
 inline bool operator==(const calculation_properties &lhs, const calculation_properties &rhs)

source/detail/default_case.hpp

@@ -28,7 +28,7 @@
 #define EXCEPT_ON_UNHANDLED_SWITCH_CASE
 
 #ifdef EXCEPT_ON_UNHANDLED_SWITCH_CASE
-#define default_case(default_value) throw xlnt::unhandled_switch_case();
+#define default_case(default_value) throw xlnt::unhandled_switch_case()
 #else
-#define default_case(default_value) return default_value;
+#define default_case(default_value) return default_value
 #endif

source/detail/implementations/workbook_impl.hpp

@@ -148,6 +148,10 @@ struct workbook_impl
         std::size_t lowest_edited;
         std::size_t rup_build;
 
+        file_version_t(): last_edited(0), lowest_edited(0), rup_build(0) {
+
+        }
+
         bool operator==(const file_version_t& rhs) const
         {
             return app_name == rhs.app_name

source/detail/serialization/xlsx_consumer.cpp

@@ -245,10 +245,7 @@ xlnt::detail::Cell parse_cell(xlnt::row_t row_arg, xml::parser *parser)
         }
         }
         // Prevents unhandled exceptions from being triggered.
-        for (auto &attr : parser->attribute_map())
+        parser->attribute_map();
-        {
-            (void)attr;
-        }
     }
     return c;
 }

source/detail/serialization/xlsx_producer.cpp

@@ -24,6 +24,7 @@
 #include <cmath>
 #include <numeric> // for std::accumulate
 #include <string>
+#include <type_traits>
 #include <unordered_set>
 
 #include <xlnt/cell/cell.hpp>
@@ -836,7 +837,7 @@ void xlsx_producer::write_rich_text(const std::string &ns, const xlnt::rich_text
                 if (run.second.get().has_size())
                 {
                     write_start_element(ns, "sz");
-                    write_attribute("val", run.second.get().size());
+                    write_attribute<double>("val", run.second.get().size());
                     write_end_element(ns, "sz");
                 }
 
@@ -1024,7 +1025,7 @@ void xlsx_producer::write_font(const font &f)
     if (f.has_size())
     {
         write_start_element(xmlns, "sz");
-        write_attribute("val", f.size());
+        write_attribute<double>("val", f.size());
         write_end_element(xmlns, "sz");
     }
 
@@ -1098,33 +1099,33 @@ void xlsx_producer::write_fill(const fill &f)
 
         if (gradient.degree() != 0.)
         {
-            write_attribute("degree", gradient.degree());
+            write_attribute<double>("degree", gradient.degree());
         }
 
         if (gradient.left() != 0.)
         {
-            write_attribute("left", gradient.left());
+            write_attribute<double>("left", gradient.left());
         }
 
         if (gradient.right() != 0.)
         {
-            write_attribute("right", gradient.right());
+            write_attribute<double>("right", gradient.right());
         }
 
         if (gradient.top() != 0.)
         {
-            write_attribute("top", gradient.top());
+            write_attribute<double>("top", gradient.top());
         }
 
         if (gradient.bottom() != 0.)
         {
-            write_attribute("bottom", gradient.bottom());
+            write_attribute<double>("bottom", gradient.bottom());
         }
 
         for (const auto &stop : gradient.stops())
         {
             write_start_element(xmlns, "stop");
-            write_attribute("position", stop.first);
+            write_attribute<double>("position", stop.first);
             write_start_element(xmlns, "color");
             write_color(stop.second);
             write_end_element(xmlns, "color");
@@ -2376,21 +2377,21 @@ void xlsx_producer::write_worksheet(const relationship &rel)
 
     if (format_properties.base_col_width.is_set())
     {
-        write_attribute("baseColWidth",
+        write_attribute<double>("baseColWidth",
             format_properties.base_col_width.get());
     }
     if (format_properties.default_column_width.is_set())
     {
-        write_attribute("defaultColWidth",
+        write_attribute<double>("defaultColWidth",
             format_properties.default_column_width.get());
     }
 
-    write_attribute("defaultRowHeight",
+    write_attribute<double>("defaultRowHeight",
         format_properties.default_row_height);
 
     if (format_properties.dy_descent.is_set())
     {
-        write_attribute(xml::qname(xmlns_x14ac, "dyDescent"),
+        write_attribute<double>(xml::qname(xmlns_x14ac, "dyDescent"),
             format_properties.dy_descent.get());
     }
 
@@ -2543,7 +2544,7 @@ void xlsx_producer::write_worksheet(const relationship &rel)
 
             if (props.dy_descent.is_set())
             {
-                write_attribute(xml::qname(xmlns_x14ac, "dyDescent"), props.dy_descent.get());
+                write_attribute<double>(xml::qname(xmlns_x14ac, "dyDescent"), props.dy_descent.get());
             }
         }
 
@@ -2813,12 +2814,12 @@ void xlsx_producer::write_worksheet(const relationship &rel)
     {
         write_start_element(xmlns, "pageMargins");
 
-        write_attribute("left", ws.page_margins().left());
+        write_attribute<double>("left", ws.page_margins().left());
-        write_attribute("right", ws.page_margins().right());
+        write_attribute<double>("right", ws.page_margins().right());
-        write_attribute("top", ws.page_margins().top());
+        write_attribute<double>("top", ws.page_margins().top());
-        write_attribute("bottom", ws.page_margins().bottom());
+        write_attribute<double>("bottom", ws.page_margins().bottom());
-        write_attribute("header", ws.page_margins().header());
+        write_attribute<double>("header", ws.page_margins().header());
-        write_attribute("footer", ws.page_margins().footer());
+        write_attribute<double>("footer", ws.page_margins().footer());
 
         write_end_element(xmlns, "pageMargins");
     }

source/detail/serialization/xlsx_producer.hpp

@@ -178,11 +178,18 @@ private:
         current_part_serializer_->attribute(name, value);
     }
 
-    void write_attribute(const std::string &name, double value)
+    template <typename T, typename std::enable_if<std::is_floating_point<T>::value, T>::type* = nullptr>
+    void write_attribute(const std::string &name, T value)
     {
         current_part_serializer_->attribute(name, converter_.serialise(value));
     }
 
+    template <typename T, typename std::enable_if<std::is_integral<T>::value, T>::type* = nullptr>
+    void write_attribute(const std::string &name, T value)
+    {
+        current_part_serializer_->attribute(name, std::to_string(value));
+    }
+
     // qname attribute name
     // not integer or float type
     template <typename T, typename = typename std::enable_if<!std::is_convertible<T, double>::value>::type>
@@ -191,11 +198,18 @@ private:
         current_part_serializer_->attribute(name, value);
     }
 
-    void write_attribute(const xml::qname &name, double value)
+    template <typename T, typename std::enable_if<std::is_floating_point<T>::value, T>::type* = nullptr>
+    void write_attribute(const xml::qname &name, T value)
     {
         current_part_serializer_->attribute(name, converter_.serialise(value));
     }
 
+    template <typename T, typename std::enable_if<std::is_integral<T>::value, T>::type* = nullptr>
+    void write_attribute(const xml::qname &name, T value)
+    {
+        current_part_serializer_->attribute(name, std::to_string(value));
+    }
+
 
     template <typename T>
     void write_characters(T characters, bool preserve_whitespace = false)

source/utils/time.cpp

@@ -117,9 +117,8 @@ double time::to_number() const
     microseconds += static_cast<std::uint64_t>(minute * 1e6 * 60);
     auto microseconds_per_hour = static_cast<std::uint64_t>(1e6) * 60 * 60;
     microseconds += static_cast<std::uint64_t>(hour) * microseconds_per_hour;
-    auto number = microseconds / (24.0 * microseconds_per_hour);
+    auto number = static_cast<double>(microseconds) / (24.0 * static_cast<double>(microseconds_per_hour));
-    auto hundred_billion = static_cast<std::uint64_t>(1e9) * 100;
+    number = std::floor(number * 100e9 + 0.5) / 100e9;
-    number = std::floor(number * hundred_billion + 0.5) / hundred_billion;
 
     return number;
 }

source/utils/timedelta.cpp

@@ -44,9 +44,8 @@ double timedelta::to_number() const
     total_microseconds += static_cast<std::uint64_t>(minutes * 1e6 * 60);
     auto microseconds_per_hour = static_cast<std::uint64_t>(1e6) * 60 * 60;
     total_microseconds += static_cast<std::uint64_t>(hours) * microseconds_per_hour;
-    auto number = total_microseconds / (24.0 * microseconds_per_hour);
+    auto number = static_cast<double>(total_microseconds) / (24.0 * static_cast<double>(microseconds_per_hour));
-    auto hundred_billion = static_cast<std::uint64_t>(1e9) * 100;
+    number = std::floor(number * 100e9 + 0.5) / 100e9;
-    number = std::floor(number * hundred_billion + 0.5) / hundred_billion;
     number += days;
 
     return number;

source/workbook/workbook.cpp

@@ -414,7 +414,11 @@ workbook workbook::empty()
     wb.extended_property(xlnt::extended_property::hyperlinks_changed, false);
     wb.extended_property(xlnt::extended_property::app_version, "15.0300");
 
-    auto file_version = detail::workbook_impl::file_version_t{"xl", 6, 6, 26709};
+    detail::workbook_impl::file_version_t file_version;
+    file_version.app_name = "xl";
+    file_version.last_edited = 6;
+    file_version.lowest_edited = 6;
+    file_version.rup_build = 26709;
     wb.d_->file_version_ = file_version;
 
     xlnt::workbook_view wb_view;

third-party/miniz/miniz.c

@@ -3076,7 +3076,7 @@ static FILE *mz_freopen(const char *pPath, const char *pMode, FILE *pStream)
 #define MZ_DELETE_FILE remove
 
 #else
-#pragma message("Using fopen, ftello, fseeko, stat() etc. path for file I/O - this path may not support large files.")
+//#pragma message("Using fopen, ftello, fseeko, stat() etc. path for file I/O - this path may not support large files.")
 #ifndef MINIZ_NO_TIME
 #include <utime.h>
 #endif