Fix compilation errors on MSVC.

ChenPi11 · ChenPi11 · commit 01c608976f6b · 2024-12-01T00:15:06.000+08:00
diff --git a/lib/iconv.c b/lib/iconv.c
@@ -44,7 +44,7 @@
  */
 #include "generated/aliases.h"
 
-const size_t TEMP_BUFFER_SIZE = 4096;
+#define TEMP_BUFFER_SIZE 4096
 
 _CPPP_API struct VersionInfo version = {VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH};
 
diff --git a/tests/buffer.hpp b/tests/buffer.hpp
@@ -78,7 +78,7 @@ class Buffer
         std::ofstream output_file{output_file_path, std::ios::binary | std::ios::trunc};
         if (!output_file.good())
         {
-            error(output_file_path, "Unable to open output file.");
+            error(output_file_path.string(), "Unable to open output file.");
         }
 
         output_file.write(buffer, size);
@@ -156,9 +156,9 @@ class Buffer
     {
         if (*this != other)
         {
-            error("compare_data", "The data is different.");
+            error("compare_assert", "The data is different.");
         }
-        success("compare_data", "The data is the same.");
+        success("compare_assert", "The data is the same.");
     }
 
     void write_stream(std::ostream &stream, bool newline = false, bool flush = true) const
@@ -199,7 +199,7 @@ class Buffer
         std::ifstream input_file{input_file_path, binary ? std::ios::binary : std::ios::in};
         if (!input_file.good())
         {
-            error(input_file_path, "Unable to open file " + input_file_path.string());
+            error(input_file_path.string(), "Unable to open file " + input_file_path.string());
         }
 
         std::size_t size = std::filesystem::file_size(input_file_path);
diff --git a/tests/check-stateless.cpp b/tests/check-stateless.cpp
@@ -39,12 +39,12 @@ void check2_pre_process(const std::filesystem::path &input_file_path, const std:
     std::ifstream input_file {input_file_path};
     if (!input_file.good())
     {
-        error(input_file_path, "Unable to open input file.");
+        error(input_file_path.string(), "Unable to open input file.");
     }
     std::ofstream output_file {output_file_path, std::ios::trunc};
     if (!output_file.good())
     {
-        error(output_file_path, "Unable to open output file.");
+        error(output_file_path.string(), "Unable to open output file.");
     }
 
     std::string line;
@@ -70,7 +70,7 @@ int main(int argc, char *argv[])
         print_stderr("Usage: check-stateless DATADIR CHARSET [--debug]\n");
         return EXIT_FAILURE;
     }
-    bool debug;
+    bool debug = false;
     if (argc == 4)
     {
         debug = true;
diff --git a/tests/sort.hpp b/tests/sort.hpp
@@ -26,13 +26,14 @@
 
 #include <algorithm>
 #include <fstream>
+#include <filesystem>
 #include <string>
 #include <vector>
 
 #include "output.hpp"
 #include "utils.hpp"
 
-inline void sort_file(const std::string &file_name, const std::string &output_file_name)
+inline void sort_file(const std::filesystem::path &file_name, const std::filesystem::path &output_file_name)
 {
     std::vector<std::string> lines;
 
diff --git a/tests/table-from.hpp b/tests/table-from.hpp
@@ -199,7 +199,7 @@ inline void table_from(const std::filesystem::path &save_file_path, const std::s
     std::ofstream save_file{save_file_path, std::ios::out | std::ios::trunc};
     if (!save_file.good())
     {
-        error(save_file_path, "Cannot open save file.");
+        error(save_file_path.string(), "Cannot open save file.");
     }
 
     iconv_t cd = iconv_open("UCS-4-INTERNAL", charset.c_str());
@@ -211,7 +211,7 @@ inline void table_from(const std::filesystem::path &save_file_path, const std::s
     unsigned int out[3];
     unsigned char buf[4];
     unsigned int i[4];
-    int result;
+
     run_table_from_test(cd, i, 0, out, buf, bmp_only, save_file);
 
     iconv_close(cd);
diff --git a/tests/table-to.hpp b/tests/table-to.hpp
@@ -44,7 +44,7 @@ inline void table_to(const std::filesystem::path &save_file_path, const std::str
     std::ofstream save_file{save_file_path, std::ios::out | std::ios::trunc};
     if (!save_file.good())
     {
-        error(save_file_path, "Cannot open save file.");
+        error(save_file_path.string(), "Cannot open save file.");
     }
 
     iconv_t cd = iconv_open(charset.c_str(), "UCS-4-INTERNAL");
diff --git a/tests/tests.cmake b/tests/tests.cmake
@@ -26,6 +26,10 @@ set_target_properties(check-stateful         PROPERTIES RUNTIME_OUTPUT_DIRECTORY
 set_target_properties(check-stateless        PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${output_testsdir}" )
 set_target_properties(sort                   PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${output_testsdir}" )
 
+macro(convert_to_crlf input_file output_file)
+    file(READ ${input_file} file_content)
+    file(WRITE ${output_file} "${file_content}")
+endmacro()
 
 # Test macro
 macro(test state encoding)
@@ -39,14 +43,19 @@ endmacro(test)
 set(TEST_DATA_DIR "${output_testsdir}/data")
 
 # Copy data directory.
-if (NOT EXISTS "${TEST_DATA_DIR}")
+if (NOT EXISTS "${TEST_DATA_DIR}" OR TRUE)
     file(MAKE_DIRECTORY "${TEST_DATA_DIR}")
     file(GLOB_RECURSE TEST_DATA_FILES "${CMAKE_CURRENT_SOURCE_DIR}/tests/data/*")
 
     foreach(TEST_FILE ${TEST_DATA_FILES})
         if(NOT IS_DIRECTORY "${TEST_FILE}")
             get_filename_component(TEST_FILE_NAME "${TEST_FILE}" NAME)
-            file(COPY_FILE "${TEST_FILE}" "${TEST_DATA_DIR}/${TEST_FILE_NAME}")
+            if ("${TEST_FILE_NAME}" MATCHES "\\.TXT$" AND (WIN32 OR WINCE OR WINDOWS_PHONE OR WINDOWS_STORE))
+                # On Windows, copy the text-only file as CR LF.
+                convert_to_crlf("${TEST_FILE}" "${TEST_DATA_DIR}/${TEST_FILE_NAME}")
+            else()
+                file(COPY_FILE "${TEST_FILE}" "${TEST_DATA_DIR}/${TEST_FILE_NAME}")
+            endif()
         endif()
     endforeach()
     unset(TEST_DATA_FILES)
diff --git a/tests/uniq-u.hpp b/tests/uniq-u.hpp
@@ -188,18 +188,21 @@ static void uniq_u(const std::filesystem::path& infile, std::filesystem::path& o
     char *prevfield, *thisfield;
     size_t prevlen, thislen;
     int match_count = 0;
+    std::string tmp;
 
-    FILE *istream = std::fopen(infile.c_str(), "r");
+    tmp = infile.string();
+    FILE *istream = std::fopen(tmp.c_str(), "r");
     if (istream == nullptr)
     {
-        print_stderr("uniq-u: Error while opening {}\n", infile);
+        print_stderr("uniq-u: Error while opening {}\n", tmp);
         error("fopen", "File open error.");
     }
 
-    FILE *ostream = std::fopen(outfile.c_str(), "w");
+    tmp = outfile.string();
+    FILE *ostream = std::fopen(tmp.c_str(), "w");
     if (ostream == nullptr)
     {
-        print_stderr("uniq-u: Error while opening {}\n", outfile);
+        print_stderr("uniq-u: Error while opening {}\n", tmp);
         error("fopen", "File open error.");
     }
 
@@ -254,13 +257,15 @@ static void uniq_u(const std::filesystem::path& infile, std::filesystem::path& o
 closefiles:
     if (std::ferror(istream) || std::fclose(istream) == EOF)
     {
-        print_stderr("uniq-u: Error while reading {}\n", infile);
+        tmp = infile.string();
+        print_stderr("uniq-u: Error while reading {}\n", tmp);
         error("fclose", "I/O Error.");
     }
 
     if (ferror(ostream) || fclose(ostream) == EOF)
     {
-        print_stderr("uniq-u: Error while writing {}\n", outfile);
+        tmp = outfile.string();
+        print_stderr("uniq-u: Error while writing {}\n", tmp);
         error("fclose", "I/O Error.");
     }
 
diff --git a/tests/utils.hpp b/tests/utils.hpp
@@ -66,7 +66,7 @@ inline void write_all(const std::filesystem::path &output_file_path, const std::
                               std::ios::binary | std::ios::ate | (append ? std::ios::app : std::ios::trunc)};
     if (!output_file.good())
     {
-        error(output_file_path, "Unable to open output file.");
+        error(output_file_path.string(), "Unable to open output file.");
     }
 
     output_file.write(buffer.data(), buffer.size());
@@ -86,7 +86,7 @@ inline void write_all(const std::filesystem::path &output_file_path, const Buffe
                               std::ios::binary | std::ios::ate | (append ? std::ios::app : std::ios::trunc)};
     if (!output_file.good())
     {
-        error(output_file_path, "Unable to open output file.");
+        error(output_file_path.string(), "Unable to open output file.");
     }
 
     output_file.write(buffer.data(), buffer.size);
@@ -103,7 +103,7 @@ inline void merge_files(const std::vector<std::filesystem::path> &files, const s
     std::ofstream output_file{output_file_path, std::ios::binary | std::ios::trunc};
     if (!output_file.good())
     {
-        error(output_file_path, "Unable to open output file.");
+        error(output_file_path.string(), "Unable to open output file.");
     }
 
     for (const auto &file : files)

Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ class Buffer`
`78`	`78`	`std::ofstream output_file{output_file_path, std::ios::binary \| std::ios::trunc};`
`79`	`79`	`if (!output_file.good())`
`80`	`80`	`{`
`81`		`- error(output_file_path, "Unable to open output file.");`
	`81`	`+ error(output_file_path.string(), "Unable to open output file.");`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`output_file.write(buffer, size);`
`@@ -156,9 +156,9 @@ class Buffer`
`156`	`156`	`{`
`157`	`157`	`if (*this != other)`
`158`	`158`	`{`
`159`		`- error("compare_data", "The data is different.");`
	`159`	`+ error("compare_assert", "The data is different.");`
`160`	`160`	`}`
`161`		`- success("compare_data", "The data is the same.");`
	`161`	`+ success("compare_assert", "The data is the same.");`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`void write_stream(std::ostream &stream, bool newline = false, bool flush = true) const`
`@@ -199,7 +199,7 @@ class Buffer`
`199`	`199`	`std::ifstream input_file{input_file_path, binary ? std::ios::binary : std::ios::in};`
`200`	`200`	`if (!input_file.good())`
`201`	`201`	`{`
`202`		`- error(input_file_path, "Unable to open file " + input_file_path.string());`
	`202`	`+ error(input_file_path.string(), "Unable to open file " + input_file_path.string());`
`203`	`203`	`}`
`204`	`204`
`205`	`205`	`std::size_t size = std::filesystem::file_size(input_file_path);`
Original file line number	Diff line number	Diff line change
`@@ -39,12 +39,12 @@ void check2_pre_process(const std::filesystem::path &input_file_path, const std:`
`39`	`39`	`std::ifstream input_file {input_file_path};`
`40`	`40`	`if (!input_file.good())`
`41`	`41`	`{`
`42`		`- error(input_file_path, "Unable to open input file.");`
	`42`	`+ error(input_file_path.string(), "Unable to open input file.");`
`43`	`43`	`}`
`44`	`44`	`std::ofstream output_file {output_file_path, std::ios::trunc};`
`45`	`45`	`if (!output_file.good())`
`46`	`46`	`{`
`47`		`- error(output_file_path, "Unable to open output file.");`
	`47`	`+ error(output_file_path.string(), "Unable to open output file.");`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`std::string line;`
`@@ -70,7 +70,7 @@ int main(int argc, char *argv[])`
`70`	`70`	`print_stderr("Usage: check-stateless DATADIR CHARSET [--debug]\n");`
`71`	`71`	`return EXIT_FAILURE;`
`72`	`72`	`}`
`73`		`- bool debug;`
	`73`	`+ bool debug = false;`
`74`	`74`	`if (argc == 4)`
`75`	`75`	`{`
`76`	`76`	`debug = true;`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ inline void table_to(const std::filesystem::path &save_file_path, const std::str`
`44`	`44`	`std::ofstream save_file{save_file_path, std::ios::out \| std::ios::trunc};`
`45`	`45`	`if (!save_file.good())`
`46`	`46`	`{`
`47`		`- error(save_file_path, "Cannot open save file.");`
	`47`	`+ error(save_file_path.string(), "Cannot open save file.");`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`iconv_t cd = iconv_open(charset.c_str(), "UCS-4-INTERNAL");`
Original file line number	Diff line number	Diff line change
`@@ -188,18 +188,21 @@ static void uniq_u(const std::filesystem::path& infile, std::filesystem::path& o`
`188`	`188`	`char prevfield, thisfield;`
`189`	`189`	`size_t prevlen, thislen;`
`190`	`190`	`int match_count = 0;`
	`191`	`+ std::string tmp;`
`191`	`192`
`192`		`- FILE *istream = std::fopen(infile.c_str(), "r");`
	`193`	`+ tmp = infile.string();`
	`194`	`+ FILE *istream = std::fopen(tmp.c_str(), "r");`
`193`	`195`	`if (istream == nullptr)`
`194`	`196`	`{`
`195`		`- print_stderr("uniq-u: Error while opening {}\n", infile);`
	`197`	`+ print_stderr("uniq-u: Error while opening {}\n", tmp);`
`196`	`198`	`error("fopen", "File open error.");`
`197`	`199`	`}`
`198`	`200`
`199`		`- FILE *ostream = std::fopen(outfile.c_str(), "w");`
	`201`	`+ tmp = outfile.string();`
	`202`	`+ FILE *ostream = std::fopen(tmp.c_str(), "w");`
`200`	`203`	`if (ostream == nullptr)`
`201`	`204`	`{`
`202`		`- print_stderr("uniq-u: Error while opening {}\n", outfile);`
	`205`	`+ print_stderr("uniq-u: Error while opening {}\n", tmp);`
`203`	`206`	`error("fopen", "File open error.");`
`204`	`207`	`}`
`205`	`208`
`@@ -254,13 +257,15 @@ static void uniq_u(const std::filesystem::path& infile, std::filesystem::path& o`
`254`	`257`	`closefiles:`
`255`	`258`	`if (std::ferror(istream) \|\| std::fclose(istream) == EOF)`
`256`	`259`	`{`
`257`		`- print_stderr("uniq-u: Error while reading {}\n", infile);`
	`260`	`+ tmp = infile.string();`
	`261`	`+ print_stderr("uniq-u: Error while reading {}\n", tmp);`
`258`	`262`	`error("fclose", "I/O Error.");`
`259`	`263`	`}`
`260`	`264`
`261`	`265`	`if (ferror(ostream) \|\| fclose(ostream) == EOF)`
`262`	`266`	`{`
`263`		`- print_stderr("uniq-u: Error while writing {}\n", outfile);`
	`267`	`+ tmp = outfile.string();`
	`268`	`+ print_stderr("uniq-u: Error while writing {}\n", tmp);`
`264`	`269`	`error("fclose", "I/O Error.");`
`265`	`270`	`}`
`266`	`271`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ inline void write_all(const std::filesystem::path &output_file_path, const std::`
`66`	`66`	`std::ios::binary \| std::ios::ate \| (append ? std::ios::app : std::ios::trunc)};`
`67`	`67`	`if (!output_file.good())`
`68`	`68`	`{`
`69`		`- error(output_file_path, "Unable to open output file.");`
	`69`	`+ error(output_file_path.string(), "Unable to open output file.");`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`output_file.write(buffer.data(), buffer.size());`
`@@ -86,7 +86,7 @@ inline void write_all(const std::filesystem::path &output_file_path, const Buffe`
`86`	`86`	`std::ios::binary \| std::ios::ate \| (append ? std::ios::app : std::ios::trunc)};`
`87`	`87`	`if (!output_file.good())`
`88`	`88`	`{`
`89`		`- error(output_file_path, "Unable to open output file.");`
	`89`	`+ error(output_file_path.string(), "Unable to open output file.");`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`output_file.write(buffer.data(), buffer.size);`
`@@ -103,7 +103,7 @@ inline void merge_files(const std::vector<std::filesystem::path> &files, const s`
`103`	`103`	`std::ofstream output_file{output_file_path, std::ios::binary \| std::ios::trunc};`
`104`	`104`	`if (!output_file.good())`
`105`	`105`	`{`
`106`		`- error(output_file_path, "Unable to open output file.");`
	`106`	`+ error(output_file_path.string(), "Unable to open output file.");`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`for (const auto &file : files)`