From d62ed4e5ba36af9714e1b0fe4b7895c04f57a709 Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Fri, 6 Dec 2019 10:13:41 +0000 Subject: [PATCH 1/9] Added VS2019 project --- test/vs2019/.gitignore | 7 + test/vs2019/.vs/etl/v15/.gitignore | 1 + test/vs2019/cpp.hint | 8 + test/vs2019/etl.sln | 61 ++ test/vs2019/etl.vcxproj | 1276 ++++++++++++++++++++++++++ test/vs2019/etl.vcxproj.filters | 1342 ++++++++++++++++++++++++++++ 6 files changed, 2695 insertions(+) create mode 100644 test/vs2019/.gitignore create mode 100644 test/vs2019/.vs/etl/v15/.gitignore create mode 100644 test/vs2019/cpp.hint create mode 100644 test/vs2019/etl.sln create mode 100644 test/vs2019/etl.vcxproj create mode 100644 test/vs2019/etl.vcxproj.filters diff --git a/test/vs2019/.gitignore b/test/vs2019/.gitignore new file mode 100644 index 00000000..e3cb4a54 --- /dev/null +++ b/test/vs2019/.gitignore @@ -0,0 +1,7 @@ +/random_clcg.csv +/random_lcg.csv +/random_lsfr.csv +/random_mwc.csv +/random_xorshift.csv +/random_pcg.csv +/random_hash.csv diff --git a/test/vs2019/.vs/etl/v15/.gitignore b/test/vs2019/.vs/etl/v15/.gitignore new file mode 100644 index 00000000..83235bb7 --- /dev/null +++ b/test/vs2019/.vs/etl/v15/.gitignore @@ -0,0 +1 @@ +*.VC.opendb diff --git a/test/vs2019/cpp.hint b/test/vs2019/cpp.hint new file mode 100644 index 00000000..507337f7 --- /dev/null +++ b/test/vs2019/cpp.hint @@ -0,0 +1,8 @@ +// Hint files help the Visual Studio IDE interpret Visual C++ identifiers +// such as names of functions and macros. +// For more information see https://go.microsoft.com/fwlink/?linkid=865984 +#define ETL_CONSTEXPR +#define ETL_CONSTEXPR_IF +#define ETL_DELETE +#define ETL_NOEXCEPT +#define ETL_NOEXCEPT_EXPR diff --git a/test/vs2019/etl.sln b/test/vs2019/etl.sln new file mode 100644 index 00000000..d3579259 --- /dev/null +++ b/test/vs2019/etl.sln @@ -0,0 +1,61 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 15 +VisualStudioVersion = 15.0.26403.3 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "etl", "etl.vcxproj", "{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug 64|Win32 = Debug 64|Win32 + Debug 64|x64 = Debug 64|x64 + Debug LLVM No STL|Win32 = Debug LLVM No STL|Win32 + Debug LLVM No STL|x64 = Debug LLVM No STL|x64 + Debug LLVM|Win32 = Debug LLVM|Win32 + Debug LLVM|x64 = Debug LLVM|x64 + Debug No STL|Win32 = Debug No STL|Win32 + Debug No STL|x64 = Debug No STL|x64 + Debug No Unit Tests|Win32 = Debug No Unit Tests|Win32 + Debug No Unit Tests|x64 = Debug No Unit Tests|x64 + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug 64|Win32.ActiveCfg = Debug No Unit Tests|Win32 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug 64|Win32.Build.0 = Debug No Unit Tests|Win32 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug 64|x64.ActiveCfg = Debug64|x64 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug 64|x64.Build.0 = Debug64|x64 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM No STL|Win32.ActiveCfg = DebugLLVMNoSTL|Win32 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM No STL|Win32.Build.0 = DebugLLVMNoSTL|Win32 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM No STL|x64.ActiveCfg = DebugLLVMNoSTL|x64 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM No STL|x64.Build.0 = DebugLLVMNoSTL|x64 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM|Win32.ActiveCfg = Debug LLVM|Win32 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM|Win32.Build.0 = Debug LLVM|Win32 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM|x64.ActiveCfg = Debug LLVM|x64 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM|x64.Build.0 = Debug LLVM|x64 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug No STL|Win32.ActiveCfg = DebugNoSTL|Win32 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug No STL|Win32.Build.0 = DebugNoSTL|Win32 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug No STL|x64.ActiveCfg = DebugNoSTL|x64 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug No STL|x64.Build.0 = DebugNoSTL|x64 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug No Unit Tests|Win32.ActiveCfg = Debug No Unit Tests|Win32 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug No Unit Tests|Win32.Build.0 = Debug No Unit Tests|Win32 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug No Unit Tests|x64.ActiveCfg = Debug No Unit Tests|x64 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug No Unit Tests|x64.Build.0 = Debug No Unit Tests|x64 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug|Win32.ActiveCfg = Debug|Win32 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug|Win32.Build.0 = Debug|Win32 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug|x64.ActiveCfg = Debug|x64 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug|x64.Build.0 = Debug|x64 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Release|Win32.ActiveCfg = Release|Win32 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Release|Win32.Build.0 = Release|Win32 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Release|x64.ActiveCfg = Release|x64 + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {0E35F961-E9EF-40C4-8E3E-2EC79B1D44B8} + EndGlobalSection +EndGlobal diff --git a/test/vs2019/etl.vcxproj b/test/vs2019/etl.vcxproj new file mode 100644 index 00000000..0481a010 --- /dev/null +++ b/test/vs2019/etl.vcxproj @@ -0,0 +1,1276 @@ + + + + + Debug Clang + Win32 + + + Debug Clang + x64 + + + Debug LLVM + Win32 + + + Debug LLVM + x64 + + + Debug64 + Win32 + + + Debug64 + x64 + + + Debug No Unit Tests + Win32 + + + Debug No Unit Tests + x64 + + + DebugLLVMNoSTL + Win32 + + + DebugLLVMNoSTL + x64 + + + DebugNoSTL + Win32 + + + DebugNoSTL + x64 + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB} + Win32Proj + unittest + etl + 10.0.17134.0 + + + + Application + true + v141 + Unicode + + + Application + true + v141 + Unicode + + + Application + true + llvm + Unicode + + + Application + true + llvm + Unicode + + + Application + true + v141_clang_c2 + Unicode + + + Application + true + v141 + Unicode + + + Application + true + v141 + Unicode + + + Application + true + v141 + Unicode + + + Application + true + v141 + Unicode + + + Application + true + v141 + Unicode + + + Application + true + v141 + Unicode + + + Application + true + v141 + Unicode + + + Application + true + v141 + Unicode + + + Application + true + v141 + Unicode + + + Application + false + v141 + true + Unicode + + + Application + false + v141 + true + Unicode + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + true + true + \$(IntDir) + + + true + true + \$(IntDir) + + + false + true + \$(IntDir) + + + false + true + \$(IntDir) + + + false + true + \$(IntDir) + + + true + true + + + true + true + + + true + true + + + true + true + + + true + true + + + true + true + \$(IntDir) + + + true + true + + + true + true + + + true + true + + + false + true + + + false + true + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + ../../../unittest-cpp/UnitTest++/;../../include;../../include/etl/c;../../test + + + false + stdcpp17 + + + Console + true + + + $(OutDir)\etl.exe + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;_SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING;ETL_NO_STL;%(PreprocessorDefinitions) + ../../../unittest-cpp/UnitTest++/;../../include;../../include/etl/c;../../test + + + false + stdcpp17 + + + Console + true + + + $(OutDir)\etl.exe + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + ../../../unittest-cpp/UnitTest++/;../../include;../../include/etl/c;../../test + + + false + stdcpp17 + false + ProgramDatabase + -Wno-self-assign %(AdditionalOptions) + + + Console + false + + + "$(OutDir)etl.exe" + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;ETL_NO_STL;%(PreprocessorDefinitions) + ../../../unittest-cpp/UnitTest++/;../../include;../../include/etl/c;../../test + + + false + stdcpp17 + false + ProgramDatabase + -Wno-self-assign %(AdditionalOptions) + + + Console + false + + + "$(OutDir)etl.exe" + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + ../../../unittest-cpp/UnitTest++/;../../include;../../include/etl/c;../../test + + + false + stdcpp17 + false + FullDebug + Default + + + Console + false + + + "$(OutDir)etl.exe" + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + ../../../unittest-cpp/UnitTest++/;../../include;../../include/etl/c;../../test + + + false + stdcpp17 + false + FullDebug + Default + + + Console + false + + + "$(OutDir)etl.exe" + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + ../../unittest-cpp/UnitTest++/;../../include/etl;../../include/etl/c;../../test + + + false + stdcpp14 + + + Console + true + + + $(OutDir)\etl.exe + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + ../../unittest-cpp/UnitTest++/;../../include/etl;../../include/etl/c;../../test + + + false + stdcpp14 + + + Console + true + + + $(OutDir)\etl.exe + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + ../../unittest-cpp/UnitTest++/;../../include/etl;../../include/etl/c;../../test + + + false + stdcpp14 + + + Console + true + + + $(OutDir)\etl.exe + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + ../../unittest-cpp/UnitTest++/;../../include/etl;../../include/etl/c;../../test + + + false + stdcpp14 + + + Console + true + + + $(OutDir)\etl.exe + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + ../../unittest-cpp/UnitTest++/;../../include/etl;../../include/etl/c;../../test + + + false + stdcpp14 + + + Console + true + + + $(OutDir)\etl.exe + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + ../../../unittest-cpp\UnitTest++;../../include;../../include/etl/c;../../test + + + false + stdcpp14 + + + Console + true + + + $(OutDir)\etl.exe + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + ../../unittest-cpp/UnitTest++/;../../include/etl;../../include/etl/c;../../test + + + false + stdcpp14 + + + Console + true + + + $(OutDir)\etl.exe + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + ../../../unittest-cpp/UnitTest++/;../../include;../../include/etl/c;../../test + + + stdcpp17 + + + Console + true + + + + + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + ../../unittest-cpp/UnitTest++/;../../src;../../src/c;../../test + + + + + Console + true + + + + + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + ../../unittest-cpp/UnitTest++/;../../src + false + + + Console + true + true + true + + + $(OutDir)\etl.exe + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + ../../unittest-cpp/UnitTest++/;../../src + false + + + Console + true + true + true + + + $(OutDir)\etl.exe + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ../../../unittest-cpp + ../../../unittest-cpp + false + false + + + + + + + + + + + + + + + + + + false + false + false + false + false + false + false + false + false + false + false + false + false + false + false + false + false + false + + + + + + + + true + true + + + true + true + + + false + false + false + false + false + false + false + false + false + false + false + false + false + false + false + false + + + + + + + + + + + false + false + false + false + false + false + false + false + false + false + false + false + false + false + + + false + false + false + false + false + false + false + false + false + false + false + false + false + false + + + false + false + false + false + false + false + false + false + false + false + false + false + false + false + + + false + false + false + false + false + false + false + false + false + false + false + false + false + false + + + false + false + false + false + false + false + false + false + false + false + false + false + false + false + + + + + + + + false + false + false + false + false + false + false + false + false + false + false + false + false + false + false + false + + + true + true + false + false + false + false + false + false + false + false + false + false + false + false + false + false + + + + + + + + + + + + + + + + false + false + false + false + false + false + false + false + false + false + false + false + false + false + false + false + + + + + + + + + + + + + + + + + + + true + true + + + + + + + + true + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/test/vs2019/etl.vcxproj.filters b/test/vs2019/etl.vcxproj.filters new file mode 100644 index 00000000..47a5caf4 --- /dev/null +++ b/test/vs2019/etl.vcxproj.filters @@ -0,0 +1,1342 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + {ecfaf316-dc6d-4dc1-9838-24061047ad63} + + + {53c3a373-0496-4db0-a981-86bf14a1fac9} + + + {107d7e33-580f-4dc5-be11-a4b2076c2c10} + + + {dc39d09c-75c9-453f-8feb-9631a200c0f4} + + + {ab41d19f-82fe-4974-a73b-16aebfa1d03f} + + + {d56ca96b-66e1-46cb-83fd-1cd72c51d962} + + + {1c55dd7d-c04b-428c-810b-dd3a08fc4c65} + + + {7028012c-30c4-4993-b2d9-3b1521a610ae} + + + {6be3bc76-e17c-4be0-8b0b-d1053e1a1761} + + + {c1264f38-22fa-4fcb-8cab-f254b1290eab} + + + {39015d44-a7cb-47f0-a7dd-27714f852363} + + + {1c95b9c1-96c0-4c1e-8e5a-e6680d88276c} + + + {0a77d88b-f9f0-456a-be4b-c0a0ce6b437b} + + + {e4a699ae-e7f3-418e-bf9f-211c21f7f4b2} + + + {7371282e-fddc-4269-891b-e909f74ff8e9} + + + {3353062c-e8dc-4095-b7cf-d11fc952263e} + + + {4d08353c-b393-47c7-a9eb-c9f2f8c25887} + + + {0bcdf7f9-8e2b-4f70-932b-bde56404f421} + + + {86dc2850-2ddf-4582-9908-2436a1aa6e86} + + + {0d093ee6-686c-4c9e-856e-bdf7075ff7a6} + + + {da88d71d-e5ea-4c26-9807-94616d31addb} + + + + + ETL\Utilities + + + ETL\Utilities + + + ETL\Utilities + + + ETL\Containers + + + ETL\Containers + + + ETL\Containers + + + ETL\Containers + + + ETL\Containers + + + ETL\Utilities + + + ETL\Utilities + + + ETL\Utilities + + + ETL\Utilities + + + ETL\Utilities + + + ETL\Utilities + + + ETL\Patterns + + + ETL\Patterns + + + ETL\Utilities + + + ETL\Containers + + + ETL\Containers + + + ETL\Maths + + + ETL\Maths + + + ETL\Maths + + + ETL\Maths + + + ETL\Maths + + + ETL\Maths + + + ETL\Containers + + + ETL\Containers + + + ETL\Containers + + + ETL\Utilities + + + ETL\Utilities + + + ETL\Containers + + + ETL\Maths + + + ETL\Utilities + + + ETL\Utilities + + + ETL\Containers + + + ETL\Maths + + + ETL\Maths + + + ETL\Maths + + + ETL\Utilities + + + ETL\Utilities + + + ETL\Utilities + + + ETL\Maths + + + ETL\Maths + + + ETL\Maths + + + ETL\Maths + + + ETL\Containers + + + ETL\Utilities + + + ETL\Utilities + + + ETL\Containers + + + ETL\Maths + + + ETL\Containers + + + ETL\Containers + + + ETL\Utilities + + + ETL\Containers + + + ETL\Containers + + + ETL\Containers + + + ETL\Containers + + + ETL\Containers + + + ETL\Maths + + + ETL\Maths + + + Source Files + + + ETL\Maths + + + ETL\Containers + + + ETL\Containers + + + ETL\Containers + + + ETL\Utilities + + + ETL\Containers + + + ETL\Containers + + + ETL\Containers + + + ETL\Containers + + + ETL\Utilities + + + ETL\Utilities + + + ETL\Private + + + ETL\Utilities + + + ETL\Containers + + + ETL\Utilities + + + ETL\Containers + + + ETL\Containers + + + ETL\Utilities + + + ETL\Utilities + + + ETL\Utilities + + + ETL\Utilities + + + ETL\Containers + + + ETL\Containers + + + ETL\Containers + + + ETL\Containers + + + ETL\Frameworks + + + ETL\Frameworks + + + ETL\Containers + + + ETL\Frameworks\Generators + + + ETL\Frameworks\Generators + + + ETL\Utilities\Generators + + + ETL\Utilities\Generators + + + ETL\Utilities\Generators + + + ETL\Frameworks + + + ETL\Frameworks + + + ETL\Frameworks + + + ETL\Frameworks + + + ETL\Frameworks + + + ETL\Maths + + + ETL\Utilities + + + ETL\Utilities + + + ETL\Maths + + + ETL\Utilities + + + ETL\Utilities\Generators + + + ETL\Utilities + + + ETL\Frameworks + + + ETL\Frameworks + + + ETL\Frameworks + + + ETL\Utilities + + + ETL\Profiles + + + ETL\Profiles + + + ETL\Profiles + + + ETL\Profiles + + + ETL\Profiles + + + ETL\Profiles + + + Source Files + + + ETL\Profiles + + + ETL\Profiles + + + ETL\Profiles + + + ETL\Profiles + + + ETL\Profiles + + + ETL\Utilities\Atomic + + + ETL\Containers + + + ETL\Containers + + + ETL\Containers + + + ETL\Containers\Generators + + + ETL\Utilities + + + ETL\Utilities\Atomic + + + ETL\Utilities\Atomic + + + ETL\Containers + + + ETL\Containers + + + ETL\Containers + + + ETL\Utilities\Mutex + + + ETL\Utilities\Mutex + + + ETL\Utilities\Mutex + + + ETL\Utilities + + + ETL\Maths + + + ETL\Maths + + + ETL\Utilities + + + ETL\Utilities\Generators + + + ETL\Utilities + + + ETL\Maths + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + ETL\Maths + + + ETL\Profiles + + + ETL\Private + + + ETL\STL\Alternate + + + ETL\STL\Alternate + + + ETL\STL + + + ETL\Profiles + + + ETL\Profiles + + + ETL\Profiles + + + ETL\Profiles + + + ETL\Profiles + + + ETL\STL\Alternate + + + ETL\STL + + + ETL\STL + + + ETL\STL\Alternate + + + ETL\STL + + + ETL\STL\Alternate + + + ETL\STL + + + ETL\Maths + + + Source Files + + + ETL\Utilities\Atomic + + + ETL\Utilities + + + ETL\Private + + + ETL\Private + + + ETL\Private + + + ETL\Frameworks + + + ETL\Maths + + + ETL\Maths + + + ETL\Maths + + + ETL\Maths + + + Source Files + + + ETL\Frameworks + + + ETL\Maths + + + ETL\Containers + + + ETL\Utilities + + + ETL\Private + + + ETL\Containers + + + ETL\Utilities + + + ETL\Frameworks + + + ETL\Strings + + + ETL\Strings + + + ETL\Strings + + + ETL\Strings + + + ETL\Strings + + + ETL\Strings + + + ETL\Strings + + + ETL\Strings + + + ETL\Strings + + + ETL\Strings + + + ETL\Strings + + + ETL\Strings + + + ETL\Strings + + + ETL\Strings + + + ETL\Strings + + + ETL\Utilities + + + ETL\Profiles + + + ETL\Profiles + + + ETL\Profiles + + + ETL\Profiles + + + ETL\Profiles + + + ETL\Containers + + + ETL\Private + + + ETL\Private + + + ETL\Private + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++ + + + UnitTest++\Win32 + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + + Resource Files + + + Resource Files\Generators + + + Resource Files\Generators + + + Resource Files\Generators + + + Resource Files\Generators + + + Resource Files\Generators + + + Resource Files\Generators + + + Resource Files\Generators + + + Resource Files\Generators + + + Resource Files\Images + + + Resource Files\Images + + + Resource Files\Generators + + + + Resource Files + + + + + Resource Files + + + Resource Files + + + Resource Files\Make + + + Source Files + + + Resource Files + + + + + Resource Files\Images + + + Resource Files\Images + + + Resource Files\Images + + + Resource Files\Images + + + Resource Files\Images + + + Resource Files\Images + + + \ No newline at end of file From b5184d903e589c8406d96293baf38de154876c5b Mon Sep 17 00:00:00 2001 From: Rolan Reznik Date: Fri, 6 Dec 2019 12:16:53 +0200 Subject: [PATCH 2/9] Make string optimization (#179) * Add NO_STL std::reverse implementation (#174) Follows the example implementation on [1]. [1] https://en.cppreference.com/w/cpp/algorithm/reverse * Merge remote-tracking branch 'origin/feature/no_stl_unit_tests' into development # Conflicts: # include/etl/stl/alternate/algorithm.h # include/etl/stl/alternate/iterator.h # include/etl/version.h # library.json # library.properties # support/Release notes.txt # test/test_no_stl_algorithm.cpp # test/test_no_stl_iterator.cpp # test/vs2017/etl.vcxproj * Fix merge function duplication * Merge remote-tracking branch 'origin/development' # Conflicts: # include/etl/private/choose_pair_types.h # include/etl/private/choose_tag_types.h # include/etl/version.h # library.json # library.properties # support/Release notes.txt * Update README.md * make_string optimisation. String length is calculated in compile time, no need to use strlen. --- README.md | 1 + include/etl/cstring.h | 2 +- include/etl/u16string.h | 2 +- include/etl/u32string.h | 2 +- include/etl/wstring.h | 2 +- 5 files changed, 5 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 5f8a211b..10437ee1 100644 --- a/README.md +++ b/README.md @@ -6,6 +6,7 @@ AppVeyor ![build status](https://gitlab.com/ETLCPP/etl/badges/master/build.svg) [![Codacy Badge](https://api.codacy.com/project/badge/Grade/3c14cd918ccf40008d0bcd7b083d5946)](https://www.codacy.com/manual/jwellbelove/etl?utm_source=github.com&utm_medium=referral&utm_content=ETLCPP/etl&utm_campaign=Badge_Grade) [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT) +[![Github All Releases](https://img.shields.io/github/downloads/ETLCPP/etl/total.svg)]() **Motivation** diff --git a/include/etl/cstring.h b/include/etl/cstring.h index 6812e2a8..122cdb3b 100644 --- a/include/etl/cstring.h +++ b/include/etl/cstring.h @@ -258,7 +258,7 @@ namespace etl template etl::string make_string(const char (&text) [MAX_SIZE]) { - return etl::string(text); + return etl::string(text, MAX_SIZE - 1); } } diff --git a/include/etl/u16string.h b/include/etl/u16string.h index f52417eb..3dd33aab 100644 --- a/include/etl/u16string.h +++ b/include/etl/u16string.h @@ -258,7 +258,7 @@ namespace etl template etl::u16string make_string(const char16_t (&text) [MAX_SIZE]) { - return etl::u16string(text); + return etl::u16string(text, MAX_SIZE - 1); } } diff --git a/include/etl/u32string.h b/include/etl/u32string.h index 3eec812e..7c01c7a7 100644 --- a/include/etl/u32string.h +++ b/include/etl/u32string.h @@ -258,7 +258,7 @@ namespace etl template etl::u32string make_string(const char32_t (&text) [MAX_SIZE]) { - return etl::u32string(text); + return etl::u32string(text, MAX_SIZE - 1); } } diff --git a/include/etl/wstring.h b/include/etl/wstring.h index 9b28eef2..c2533037 100644 --- a/include/etl/wstring.h +++ b/include/etl/wstring.h @@ -259,7 +259,7 @@ namespace etl template etl::wstring make_string(const wchar_t (&text) [MAX_SIZE]) { - return etl::wstring(text); + return etl::wstring(text, MAX_SIZE - 1); } } From b8708722ae3f9e00202db230655234f5a8b96a75 Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Fri, 6 Dec 2019 10:17:27 +0000 Subject: [PATCH 3/9] Backup copy of appveyor.yml --- appveyor.yml | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 appveyor.yml diff --git a/appveyor.yml b/appveyor.yml new file mode 100644 index 00000000..b4f4dc4c --- /dev/null +++ b/appveyor.yml @@ -0,0 +1,23 @@ +version: 1.0.{build} +branches: + only: + - master +image: Visual Studio 2017 +configuration: +- Debug +- DebugNoSTL +clone_folder: c:\projects\etl +install: +- cmd: git submodule update --init --recursive +before_build: +- cmd: git clone https://github.com/unittest-cpp/unittest-cpp.git c:\projects\unittest-cpp +build: + project: test/vs2017/etl.vcxproj + verbosity: minimal +notifications: +- provider: Webhook + url: https://hooks.slack.com/services/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 + method: POST + on_build_success: true + on_build_failure: true + on_build_status_changed: true \ No newline at end of file From 58805d76ccaa7e2f989998265825699e8b5564de Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Fri, 6 Dec 2019 10:25:29 +0000 Subject: [PATCH 4/9] Merge remote-tracking branch 'origin/development' into feature/add_circle-ci_support --- README.md | 1 + include/etl/cstring.h | 2 +- include/etl/u16string.h | 2 +- include/etl/u32string.h | 2 +- include/etl/wstring.h | 2 +- 5 files changed, 5 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 5f8a211b..10437ee1 100644 --- a/README.md +++ b/README.md @@ -6,6 +6,7 @@ AppVeyor ![build status](https://gitlab.com/ETLCPP/etl/badges/master/build.svg) [![Codacy Badge](https://api.codacy.com/project/badge/Grade/3c14cd918ccf40008d0bcd7b083d5946)](https://www.codacy.com/manual/jwellbelove/etl?utm_source=github.com&utm_medium=referral&utm_content=ETLCPP/etl&utm_campaign=Badge_Grade) [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT) +[![Github All Releases](https://img.shields.io/github/downloads/ETLCPP/etl/total.svg)]() **Motivation** diff --git a/include/etl/cstring.h b/include/etl/cstring.h index 6812e2a8..122cdb3b 100644 --- a/include/etl/cstring.h +++ b/include/etl/cstring.h @@ -258,7 +258,7 @@ namespace etl template etl::string make_string(const char (&text) [MAX_SIZE]) { - return etl::string(text); + return etl::string(text, MAX_SIZE - 1); } } diff --git a/include/etl/u16string.h b/include/etl/u16string.h index f52417eb..3dd33aab 100644 --- a/include/etl/u16string.h +++ b/include/etl/u16string.h @@ -258,7 +258,7 @@ namespace etl template etl::u16string make_string(const char16_t (&text) [MAX_SIZE]) { - return etl::u16string(text); + return etl::u16string(text, MAX_SIZE - 1); } } diff --git a/include/etl/u32string.h b/include/etl/u32string.h index 3eec812e..7c01c7a7 100644 --- a/include/etl/u32string.h +++ b/include/etl/u32string.h @@ -258,7 +258,7 @@ namespace etl template etl::u32string make_string(const char32_t (&text) [MAX_SIZE]) { - return etl::u32string(text); + return etl::u32string(text, MAX_SIZE - 1); } } diff --git a/include/etl/wstring.h b/include/etl/wstring.h index 9b28eef2..c2533037 100644 --- a/include/etl/wstring.h +++ b/include/etl/wstring.h @@ -259,7 +259,7 @@ namespace etl template etl::wstring make_string(const wchar_t (&text) [MAX_SIZE]) { - return etl::wstring(text); + return etl::wstring(text, MAX_SIZE - 1); } } From 06429e140b406db85c4b0db2d383fa79f5766da8 Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Fri, 6 Dec 2019 10:25:56 +0000 Subject: [PATCH 5/9] Initial CircleCI configuration --- .circleci/config.yml | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 .circleci/config.yml diff --git a/.circleci/config.yml b/.circleci/config.yml new file mode 100644 index 00000000..28e75cee --- /dev/null +++ b/.circleci/config.yml @@ -0,0 +1,26 @@ +version: 2 + +jobs: + build: + docker: + - image: "debian:stretch" + steps: + - checkout + - run: + name: Installing SUDO + command: 'apt-get update && apt-get install -y sudo && rm -rf /var/lib/apt/lists/*' + - run: + name: Installing GCC + command: 'apt-get update && apt-get install -y gcc g++' + - run: + name: Install CMAKE + command: 'apt-get update && sudo apt-get install -y cmake' + - run: + name: Creating Build Files + command: 'cmake -H. -Bbuild' + - run: + name: Creating Binary Files + command: 'cmake --build build' + - run: + name: ETL Unit Testing + command: './bin/etl' \ No newline at end of file From 3649f839f5bf04a05f805be819723f2f028065c9 Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Fri, 6 Dec 2019 12:39:31 +0000 Subject: [PATCH 6/9] Merge remote-tracking branch 'origin/feature/make_string_with_capacity' into development # Conflicts: # include/etl/cstring.h # include/etl/u16string.h # include/etl/u32string.h # include/etl/wstring.h --- README.md | 1 + include/etl/cstring.h | 13 ++++++-- include/etl/u16string.h | 9 ++++++ include/etl/u32string.h | 9 ++++++ include/etl/version.h | 2 +- include/etl/wstring.h | 9 ++++++ library.json | 2 +- library.properties | 2 +- support/Release notes.txt | 8 +++++ test/codeblocks/ETL.cbp | 1 + test/test_make_string.cpp | 66 +++++++++++++++++++++++++++++++++++++++ test/test_string_char.cpp | 12 ++++++- 12 files changed, 128 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 10437ee1..978d25d3 100644 --- a/README.md +++ b/README.md @@ -5,6 +5,7 @@ AppVeyor [![Build status](https://ci.appveyor.com/api/projects/status/b7jgecv7unqjw4u0/branch/master?svg=true)](https://ci.appveyor.com/project/jwellbelove/etl/branch/master) ![build status](https://gitlab.com/ETLCPP/etl/badges/master/build.svg) [![Codacy Badge](https://api.codacy.com/project/badge/Grade/3c14cd918ccf40008d0bcd7b083d5946)](https://www.codacy.com/manual/jwellbelove/etl?utm_source=github.com&utm_medium=referral&utm_content=ETLCPP/etl&utm_campaign=Badge_Grade) +![GitHub release (latest by date)](https://img.shields.io/github/v/release/jwellbelove/etl) [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT) [![Github All Releases](https://img.shields.io/github/downloads/ETLCPP/etl/total.svg)]() diff --git a/include/etl/cstring.h b/include/etl/cstring.h index 122cdb3b..93a559df 100644 --- a/include/etl/cstring.h +++ b/include/etl/cstring.h @@ -237,7 +237,7 @@ namespace etl size_t operator()(const etl::istring& text) const { return etl::private_hash::generic_hash(reinterpret_cast(&text[0]), - reinterpret_cast(&text[text.size()])); + reinterpret_cast(&text[text.size()])); } }; @@ -247,7 +247,7 @@ namespace etl size_t operator()(const etl::string& text) const { return etl::private_hash::generic_hash(reinterpret_cast(&text[0]), - reinterpret_cast(&text[text.size()])); + reinterpret_cast(&text[text.size()])); } }; #endif @@ -260,6 +260,15 @@ namespace etl { return etl::string(text, MAX_SIZE - 1); } + + //*************************************************************************** + /// Make string with max capacity from string literal or char array + //*************************************************************************** + template + etl::string make_string_with_capacity(const char(&text)[SIZE]) + { + return etl::string(text, SIZE - 1); + } } #include "private/minmax_pop.h" diff --git a/include/etl/u16string.h b/include/etl/u16string.h index 3dd33aab..0da8209c 100644 --- a/include/etl/u16string.h +++ b/include/etl/u16string.h @@ -260,6 +260,15 @@ namespace etl { return etl::u16string(text, MAX_SIZE - 1); } + + //*************************************************************************** + /// Make string with max capacity from string literal or char array + //*************************************************************************** + template + etl::u16string make_string_with_capacity(const char16_t(&text)[SIZE]) + { + return etl::u16string(text, SIZE - 1); + } } #include "private/minmax_pop.h" diff --git a/include/etl/u32string.h b/include/etl/u32string.h index 7c01c7a7..34fad1a3 100644 --- a/include/etl/u32string.h +++ b/include/etl/u32string.h @@ -260,6 +260,15 @@ namespace etl { return etl::u32string(text, MAX_SIZE - 1); } + + //*************************************************************************** + /// Make string with max capacity from string literal or char array + //*************************************************************************** + template + etl::u32string make_string_with_capacity(const char32_t(&text)[SIZE]) + { + return etl::u32string(text, SIZE - 1); + } } #include "private/minmax_pop.h" diff --git a/include/etl/version.h b/include/etl/version.h index 3f91e496..3f6458c0 100644 --- a/include/etl/version.h +++ b/include/etl/version.h @@ -38,7 +38,7 @@ SOFTWARE. ///\ingroup utilities #define ETL_VERSION_MAJOR 15 -#define ETL_VERSION_MINOR 2 +#define ETL_VERSION_MINOR 3 #define ETL_VERSION_PATCH 0 #define ETL_VERSION ETL_STRINGIFY(ETL_VERSION_MAJOR) "." ETL_STRINGIFY(ETL_VERSION_MINOR) "." ETL_STRINGIFY(ETL_VERSION_PATCH) diff --git a/include/etl/wstring.h b/include/etl/wstring.h index c2533037..f85275ed 100644 --- a/include/etl/wstring.h +++ b/include/etl/wstring.h @@ -261,6 +261,15 @@ namespace etl { return etl::wstring(text, MAX_SIZE - 1); } + + //*************************************************************************** + /// Make string with max capacity from string literal or char array + //*************************************************************************** + template + etl::wstring make_string_with_capacity(const wchar_t(&text)[SIZE]) + { + return etl::wstring(text, SIZE - 1); + } } #include "private/minmax_pop.h" diff --git a/library.json b/library.json index 477ce514..c2e9281e 100644 --- a/library.json +++ b/library.json @@ -1,6 +1,6 @@ { "name": "Embedded Template Library", - "version": "15.2.0", + "version": "15.3.0", "authors": { "name": "John Wellbelove", "email": "" diff --git a/library.properties b/library.properties index 3bb62455..0a327d6e 100644 --- a/library.properties +++ b/library.properties @@ -1,5 +1,5 @@ name=Embedded Template Library -version=15.2.0 +version=15.3.0 author= John Wellbelove maintainer=John Wellbelove license=MIT diff --git a/support/Release notes.txt b/support/Release notes.txt index fe0d467e..abc768f1 100644 --- a/support/Release notes.txt +++ b/support/Release notes.txt @@ -1,3 +1,11 @@ +=============================================================================== +15.3.0 +Added etl::make_string_with_capacity + +=============================================================================== +15.2.1 +Compile time optimisations to etl::make_string + =============================================================================== 15.2.0 Added function adaptors and removed built-in sort functions from indirect_vector. diff --git a/test/codeblocks/ETL.cbp b/test/codeblocks/ETL.cbp index 3ce6a93c..46869784 100644 --- a/test/codeblocks/ETL.cbp +++ b/test/codeblocks/ETL.cbp @@ -430,6 +430,7 @@ + diff --git a/test/test_make_string.cpp b/test/test_make_string.cpp index 2bd432b0..08ba1c24 100644 --- a/test/test_make_string.cpp +++ b/test/test_make_string.cpp @@ -73,5 +73,71 @@ namespace CHECK(Equal(std::u16string(u"Hello World"), ctext)); CHECK(Equal(std::u32string(U"Hello World"), ctext)); } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_make_string_with_capacity) + { + constexpr size_t CAPACITY = 20; + size_t length = strlen("Hello World"); + + auto ctext = etl::make_string_with_capacity("Hello World"); + auto wtext = etl::make_string_with_capacity(L"Hello World"); + auto u16text = etl::make_string_with_capacity(u"Hello World"); + auto u32text = etl::make_string_with_capacity(U"Hello World"); + + CHECK_EQUAL(CAPACITY, ctext.max_size()); + CHECK_EQUAL(length, ctext.size()); + CHECK(!ctext.truncated()); + + CHECK_EQUAL(CAPACITY, wtext.max_size()); + CHECK_EQUAL(length, wtext.size()); + CHECK(!wtext.truncated()); + + CHECK_EQUAL(CAPACITY, u16text.max_size()); + CHECK_EQUAL(length, u16text.size()); + CHECK(!u16text.truncated()); + + CHECK_EQUAL(CAPACITY, u32text.max_size()); + CHECK_EQUAL(length, u32text.size()); + CHECK(!u32text.truncated()); + + CHECK(Equal(std::string("Hello World"), ctext)); + CHECK(Equal(std::wstring(L"Hello World"), ctext)); + CHECK(Equal(std::u16string(u"Hello World"), ctext)); + CHECK(Equal(std::u32string(U"Hello World"), ctext)); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_make_string_with_capacity_truncated) + { + constexpr size_t CAPACITY = 10; + size_t length = strlen("Hello World"); + + auto ctext = etl::make_string_with_capacity("Hello World"); + auto wtext = etl::make_string_with_capacity(L"Hello World"); + auto u16text = etl::make_string_with_capacity(u"Hello World"); + auto u32text = etl::make_string_with_capacity(U"Hello World"); + + CHECK_EQUAL(CAPACITY, ctext.max_size()); + CHECK_EQUAL(length - 1, ctext.size()); + CHECK(ctext.truncated()); + + CHECK_EQUAL(CAPACITY, wtext.max_size()); + CHECK_EQUAL(length - 1, wtext.size()); + CHECK(wtext.truncated()); + + CHECK_EQUAL(CAPACITY, u16text.max_size()); + CHECK_EQUAL(length - 1, u16text.size()); + CHECK(u16text.truncated()); + + CHECK_EQUAL(CAPACITY, u32text.max_size()); + CHECK_EQUAL(length - 1, u32text.size()); + CHECK(u32text.truncated()); + + CHECK(Equal(std::string("Hello Worl"), ctext)); + CHECK(Equal(std::wstring(L"Hello Worl"), ctext)); + CHECK(Equal(std::u16string(u"Hello Worl"), ctext)); + CHECK(Equal(std::u32string(U"Hello Worl"), ctext)); + } }; } diff --git a/test/test_string_char.cpp b/test/test_string_char.cpp index c1b0f8a5..075cb82b 100644 --- a/test/test_string_char.cpp +++ b/test/test_string_char.cpp @@ -81,7 +81,6 @@ namespace { SetupFixture() { - initial_text = STR("Hello World"); initial_text = STR("Hello World"); insert_text = STR("Insert"); less_text = STR("Hello Vorld"); @@ -253,6 +252,17 @@ namespace CHECK(text.truncated()); } + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_constructor_from_literal) + { + Text text(STR("Hello World")); + + bool is_equal = Equal(initial_text, text); + CHECK(is_equal); + CHECK(text.size() == SIZE); + CHECK(!text.empty()); + } + //************************************************************************* TEST_FIXTURE(SetupFixture, test_copy_constructor) { From 703fe0f92bf8450e549a68a56fc395272637d68f Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Wed, 11 Dec 2019 12:57:50 +0000 Subject: [PATCH 7/9] Changes to alternate STL limits.h for ARM5 compiler compatibility --- include/etl/stl/alternate/limits.h | 157 +++++++---------------------- include/etl/version.h | 2 +- library.json | 2 +- library.properties | 2 +- support/Release notes.txt | 4 + 5 files changed, 42 insertions(+), 125 deletions(-) diff --git a/include/etl/stl/alternate/limits.h b/include/etl/stl/alternate/limits.h index dc0f9a21..ec8df96a 100644 --- a/include/etl/stl/alternate/limits.h +++ b/include/etl/stl/alternate/limits.h @@ -51,18 +51,18 @@ namespace etlstd enum float_round_style { - round_indeterminate = -1, - round_toward_zero = 0, - round_to_nearest = 1, - round_toward_infinity = 2, + round_indeterminate = -1, + round_toward_zero = 0, + round_to_nearest = 1, + round_toward_infinity = 2, round_toward_neg_infinity = 3, }; enum float_denorm_style { denorm_indeterminate = -1, - denorm_absent = 0, - denorm_present = 1 + denorm_absent = 0, + denorm_present = 1 }; //*************************************************************************** @@ -76,66 +76,42 @@ namespace etlstd static ETL_CONST int max_digits10 = 0; static ETL_CONST bool is_integer = true; - static ETL_CONST bool is_exact = true; + static ETL_CONST bool is_exact = true; static ETL_CONST int radix = 2; static ETL_CONSTEXPR T epsilon() { return 0; } static ETL_CONSTEXPR T round_error() { return 0; } - static ETL_CONST int digits = (CHAR_BIT * sizeof(T)) - (etl::is_signed::value ? 1 : 0); + static ETL_CONST int digits = (CHAR_BIT * sizeof(T)) - (etl::is_signed::value ? 1 : 0); static ETL_CONST int digits10 = ETL_LOG2(digits); static ETL_CONST bool is_signed = etl::is_signed::value; - static ETL_CONST int min_exponent = 0; + static ETL_CONST int min_exponent = 0; static ETL_CONST int min_exponent10 = 0; - static ETL_CONST int max_exponent = 0; + static ETL_CONST int max_exponent = 0; static ETL_CONST int max_exponent10 = 0; - static ETL_CONST bool has_infinity = false; - static ETL_CONST bool has_quiet_NaN = false; - static ETL_CONST bool has_signaling_NaN = false; + static ETL_CONST bool has_infinity = false; + static ETL_CONST bool has_quiet_NaN = false; + static ETL_CONST bool has_signaling_NaN = false; static ETL_CONST float_denorm_style has_denorm = denorm_absent; - static ETL_CONST bool has_denorm_loss = false; + static ETL_CONST bool has_denorm_loss = false; static ETL_CONSTEXPR T infinity() { return 0; } static ETL_CONSTEXPR T quiet_NaN() { return 0; } static ETL_CONSTEXPR T signaling_NaN() { return 0; } static ETL_CONSTEXPR T denorm_min() { return 0; } - static ETL_CONST bool is_iec559 = false; + static ETL_CONST bool is_iec559 = false; static ETL_CONST bool is_bounded = true; - static ETL_CONST bool is_modulo = etl::is_unsigned::value; + static ETL_CONST bool is_modulo = etl::is_unsigned::value; static ETL_CONST bool traps = false; static ETL_CONST bool tinyness_before = false; static ETL_CONST float_round_style round_style = round_toward_zero; }; - template ETL_CONST bool etl_integral_type::is_specialized; - template ETL_CONST int etl_integral_type::digits; - template ETL_CONST int etl_integral_type::digits10; - template ETL_CONST int etl_integral_type::max_digits10; - template ETL_CONST bool etl_integral_type::is_signed; - template ETL_CONST bool etl_integral_type::is_integer; - template ETL_CONST bool etl_integral_type::is_exact; - template ETL_CONST int etl_integral_type::radix; - template ETL_CONST int etl_integral_type::min_exponent; - template ETL_CONST int etl_integral_type::min_exponent10; - template ETL_CONST int etl_integral_type::max_exponent; - template ETL_CONST int etl_integral_type::max_exponent10; - template ETL_CONST bool etl_integral_type::has_infinity; - template ETL_CONST bool etl_integral_type::has_quiet_NaN; - template ETL_CONST bool etl_integral_type::has_signaling_NaN; - template ETL_CONST float_denorm_style etl_integral_type::has_denorm; - template ETL_CONST bool etl_integral_type::has_denorm_loss; - template ETL_CONST bool etl_integral_type::is_iec559; - template ETL_CONST bool etl_integral_type::is_bounded; - template ETL_CONST bool etl_integral_type::is_modulo; - template ETL_CONST bool etl_integral_type::traps; - template ETL_CONST bool etl_integral_type::tinyness_before; - template ETL_CONST float_round_style etl_integral_type::round_style; - //*************************************************************************** // Base for floating point types. template @@ -144,9 +120,9 @@ namespace etlstd public: static ETL_CONST bool is_specialized = true; - static ETL_CONST bool is_signed = true; + static ETL_CONST bool is_signed = true; static ETL_CONST bool is_integer = false; - static ETL_CONST bool is_exact = false; + static ETL_CONST bool is_exact = false; static ETL_CONST int radix = 2; @@ -170,23 +146,6 @@ namespace etlstd static ETL_CONST float_round_style round_style = round_to_nearest; }; - template ETL_CONST bool etl_floating_point_type::is_specialized; - template ETL_CONST bool etl_floating_point_type::is_signed; - template ETL_CONST bool etl_floating_point_type::is_integer; - template ETL_CONST bool etl_floating_point_type::is_exact; - template ETL_CONST int etl_floating_point_type::radix; - template ETL_CONST bool etl_floating_point_type::has_infinity; - template ETL_CONST bool etl_floating_point_type::has_quiet_NaN; - template ETL_CONST bool etl_floating_point_type::has_signaling_NaN; - template ETL_CONST float_denorm_style etl_floating_point_type::has_denorm; - template ETL_CONST bool etl_floating_point_type::has_denorm_loss; - template ETL_CONST bool etl_floating_point_type::is_iec559; - template ETL_CONST bool etl_floating_point_type::is_bounded; - template ETL_CONST bool etl_floating_point_type::is_modulo; - template ETL_CONST bool etl_floating_point_type::traps; - template ETL_CONST bool etl_floating_point_type::tinyness_before; - template ETL_CONST float_round_style etl_floating_point_type::round_style; - //*************************************************************************** // Default template @@ -242,30 +201,6 @@ namespace etlstd static ETL_CONST float_round_style round_style = round_toward_zero; }; - ETL_CONST bool numeric_limits::is_specialized; - ETL_CONST int numeric_limits::digits; - ETL_CONST int numeric_limits::digits10; - ETL_CONST int numeric_limits::max_digits10; - ETL_CONST bool numeric_limits::is_signed; - ETL_CONST bool numeric_limits::is_integer; - ETL_CONST bool numeric_limits::is_exact; - ETL_CONST int numeric_limits::radix; - ETL_CONST int numeric_limits::min_exponent; - ETL_CONST int numeric_limits::min_exponent10; - ETL_CONST int numeric_limits::max_exponent; - ETL_CONST int numeric_limits::max_exponent10; - ETL_CONST bool numeric_limits::has_infinity; - ETL_CONST bool numeric_limits::has_quiet_NaN; - ETL_CONST bool numeric_limits::has_signaling_NaN; - ETL_CONST float_denorm_style numeric_limits::has_denorm; - ETL_CONST bool numeric_limits::has_denorm_loss; - ETL_CONST bool numeric_limits::is_iec559; - ETL_CONST bool numeric_limits::is_bounded; - ETL_CONST bool numeric_limits::is_modulo; - ETL_CONST bool numeric_limits::traps; - ETL_CONST bool numeric_limits::tinyness_before; - ETL_CONST float_round_style numeric_limits::round_style; - //*************************************************************************** // char template<> @@ -273,9 +208,9 @@ namespace etlstd { public: - static ETL_CONSTEXPR char min() { return CHAR_MIN; } - static ETL_CONSTEXPR char max() { return CHAR_MAX; } - static ETL_CONSTEXPR char lowest() { return CHAR_MIN; } + static ETL_CONSTEXPR char min() { return char(CHAR_MIN); } + static ETL_CONSTEXPR char max() { return char(CHAR_MAX); } + static ETL_CONSTEXPR char lowest() { return char(CHAR_MIN); } }; //*************************************************************************** @@ -302,6 +237,7 @@ namespace etlstd static ETL_CONSTEXPR signed char lowest() { return SCHAR_MIN; } }; +#if (ETL_NO_LARGE_CHAR_SUPPORT == false) //*************************************************************************** // char16_t template<> @@ -325,6 +261,7 @@ namespace etlstd static ETL_CONSTEXPR char32_t max() { return UINT_LEAST32_MAX; } static ETL_CONSTEXPR char32_t lowest() { return 0; } }; +#endif //*************************************************************************** // wchar_t @@ -447,24 +384,16 @@ namespace etlstd static ETL_CONSTEXPR float epsilon() { return FLT_EPSILON; } static ETL_CONSTEXPR float denorm_min() { return FLT_MIN; } - static ETL_CONST int digits = FLT_MANT_DIG; - static ETL_CONST int digits10 = FLT_DIG; + static ETL_CONST int digits = FLT_MANT_DIG; + static ETL_CONST int digits10 = FLT_DIG; static ETL_CONST int max_digits10 = ETL_LOG2(FLT_MANT_DIG) + 2; - static ETL_CONST int min_exponent = FLT_MIN_EXP; + static ETL_CONST int min_exponent = FLT_MIN_EXP; static ETL_CONST int min_exponent10 = FLT_MIN_10_EXP; - static ETL_CONST int max_exponent = FLT_MAX_EXP; + static ETL_CONST int max_exponent = FLT_MAX_EXP; static ETL_CONST int max_exponent10 = FLT_MAX_10_EXP; }; - ETL_CONST int numeric_limits::digits; - ETL_CONST int numeric_limits::max_digits10; - ETL_CONST int numeric_limits::digits10; - ETL_CONST int numeric_limits::min_exponent; - ETL_CONST int numeric_limits::min_exponent10; - ETL_CONST int numeric_limits::max_exponent; - ETL_CONST int numeric_limits::max_exponent10; - //*************************************************************************** // double template<> @@ -478,24 +407,16 @@ namespace etlstd static ETL_CONSTEXPR double epsilon() { return DBL_EPSILON; } static ETL_CONSTEXPR double denorm_min() { return DBL_MIN; } - static ETL_CONST int digits = DBL_MANT_DIG; - static ETL_CONST int digits10 = DBL_DIG; + static ETL_CONST int digits = DBL_MANT_DIG; + static ETL_CONST int digits10 = DBL_DIG; static ETL_CONST int max_digits10 = ETL_LOG2(DBL_MANT_DIG) + 2; - static ETL_CONST int min_exponent = DBL_MIN_EXP; + static ETL_CONST int min_exponent = DBL_MIN_EXP; static ETL_CONST int min_exponent10 = DBL_MIN_10_EXP; - static ETL_CONST int max_exponent = DBL_MAX_EXP; + static ETL_CONST int max_exponent = DBL_MAX_EXP; static ETL_CONST int max_exponent10 = DBL_MAX_10_EXP; }; - ETL_CONST int numeric_limits::digits; - ETL_CONST int numeric_limits::max_digits10; - ETL_CONST int numeric_limits::digits10; - ETL_CONST int numeric_limits::min_exponent; - ETL_CONST int numeric_limits::min_exponent10; - ETL_CONST int numeric_limits::max_exponent; - ETL_CONST int numeric_limits::max_exponent10; - //*************************************************************************** // long double template<> @@ -509,23 +430,15 @@ namespace etlstd static ETL_CONSTEXPR long double epsilon() { return LDBL_EPSILON; } static ETL_CONSTEXPR long double denorm_min() { return LDBL_MIN; } - static ETL_CONST int digits = LDBL_MANT_DIG; - static ETL_CONST int digits10 = LDBL_DIG; + static ETL_CONST int digits = LDBL_MANT_DIG; + static ETL_CONST int digits10 = LDBL_DIG; static ETL_CONST int max_digits10 = ETL_LOG2(LDBL_MANT_DIG) + 2; - static ETL_CONST int min_exponent = LDBL_MIN_EXP; + static ETL_CONST int min_exponent = LDBL_MIN_EXP; static ETL_CONST int min_exponent10 = LDBL_MIN_10_EXP; - static ETL_CONST int max_exponent = LDBL_MAX_EXP; + static ETL_CONST int max_exponent = LDBL_MAX_EXP; static ETL_CONST int max_exponent10 = LDBL_MAX_10_EXP; }; - - ETL_CONST int numeric_limits::digits; - ETL_CONST int numeric_limits::max_digits10; - ETL_CONST int numeric_limits::digits10; - ETL_CONST int numeric_limits::min_exponent; - ETL_CONST int numeric_limits::min_exponent10; - ETL_CONST int numeric_limits::max_exponent; - ETL_CONST int numeric_limits::max_exponent10; } #endif diff --git a/include/etl/version.h b/include/etl/version.h index 3f6458c0..64abbb3b 100644 --- a/include/etl/version.h +++ b/include/etl/version.h @@ -39,7 +39,7 @@ SOFTWARE. #define ETL_VERSION_MAJOR 15 #define ETL_VERSION_MINOR 3 -#define ETL_VERSION_PATCH 0 +#define ETL_VERSION_PATCH 1 #define ETL_VERSION ETL_STRINGIFY(ETL_VERSION_MAJOR) "." ETL_STRINGIFY(ETL_VERSION_MINOR) "." ETL_STRINGIFY(ETL_VERSION_PATCH) #define ETL_VERSION_W ETL_STRINGIFY(ETL_VERSION_MAJOR) L"." ETL_STRINGIFY(ETL_VERSION_MINOR) L"." ETL_STRINGIFY(ETL_VERSION_PATCH) diff --git a/library.json b/library.json index c2e9281e..b2399ec0 100644 --- a/library.json +++ b/library.json @@ -1,6 +1,6 @@ { "name": "Embedded Template Library", - "version": "15.3.0", + "version": "15.3.1", "authors": { "name": "John Wellbelove", "email": "" diff --git a/library.properties b/library.properties index 0a327d6e..55396e07 100644 --- a/library.properties +++ b/library.properties @@ -1,5 +1,5 @@ name=Embedded Template Library -version=15.3.0 +version=15.3.1 author= John Wellbelove maintainer=John Wellbelove license=MIT diff --git a/support/Release notes.txt b/support/Release notes.txt index abc768f1..de5c0872 100644 --- a/support/Release notes.txt +++ b/support/Release notes.txt @@ -1,3 +1,7 @@ +=============================================================================== +15.3.1 +Changes to alternate STL limits.h for ARM5 compiler compatibility + =============================================================================== 15.3.0 Added etl::make_string_with_capacity From 7e5a4e1efef2f877fb7c963a8058a8981576550e Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Thu, 12 Dec 2019 12:18:51 +0000 Subject: [PATCH 8/9] Merge remote-tracking branch 'origin/crc-ccitt-xmodem' into development # Conflicts: # README.md --- README.md | 2 +- images/etl.ico | Bin 0 -> 1150 bytes images/etl.png | Bin 0 -> 20267 bytes images/etl.pspimage | Bin 0 -> 11544 bytes images/etl.xar | Bin 0 -> 28896 bytes images/etl16.png | Bin 0 -> 15993 bytes images/etl32.png | Bin 0 -> 19081 bytes images/etl48.png | Bin 0 -> 24217 bytes images/favicon.ico | Bin 0 -> 1150 bytes include/etl/crc16.h | 78 +-- include/etl/crc16_aug_ccitt.h | 49 ++ include/etl/crc16_ccitt.h | 76 +-- include/etl/crc16_genibus.h | 49 ++ include/etl/crc16_kermit.h | 76 +-- include/etl/crc16_modbus.h | 92 +--- include/etl/crc16_usb.h | 51 ++ include/etl/crc16_x25.h | 49 ++ include/etl/crc16_xmodem.h | 49 ++ include/etl/crc32.h | 94 +--- include/etl/crc32_bzip2.h | 49 ++ include/etl/crc32_c.h | 94 +--- include/etl/crc32_mpeg2.h | 49 ++ include/etl/crc32_posix.h | 49 ++ include/etl/crc64_ecma.h | 126 +---- include/etl/crc8_ccitt.h | 79 +-- include/etl/crc8_rohc.h | 49 ++ include/etl/private/crc16_poly_0x1021_.h | 212 +++++++ include/etl/private/crc16_poly_0x8005.h | 212 +++++++ include/etl/private/crc32_poly_0x04c11db7.h | 212 +++++++ include/etl/private/crc32_poly_0x1edc6f41.h | 212 +++++++ .../private/crc64_poly_0x42f0e1eba9ea3693.h | 242 ++++++++ include/etl/private/crc8_poly_0x07.h | 212 +++++++ include/etl/version.h | 4 +- library.json | 2 +- library.properties | 2 +- support/Release notes.txt | 5 + test/test_crc.cpp | 521 ++++++++++++++++++ test/vs2017/etl.vcxproj | 16 + test/vs2017/etl.vcxproj.filters | 54 ++ 39 files changed, 2362 insertions(+), 704 deletions(-) create mode 100644 images/etl.ico create mode 100644 images/etl.png create mode 100644 images/etl.pspimage create mode 100644 images/etl.xar create mode 100644 images/etl16.png create mode 100644 images/etl32.png create mode 100644 images/etl48.png create mode 100644 images/favicon.ico create mode 100644 include/etl/crc16_aug_ccitt.h create mode 100644 include/etl/crc16_genibus.h create mode 100644 include/etl/crc16_usb.h create mode 100644 include/etl/crc16_x25.h create mode 100644 include/etl/crc16_xmodem.h create mode 100644 include/etl/crc32_bzip2.h create mode 100644 include/etl/crc32_mpeg2.h create mode 100644 include/etl/crc32_posix.h create mode 100644 include/etl/crc8_rohc.h create mode 100644 include/etl/private/crc16_poly_0x1021_.h create mode 100644 include/etl/private/crc16_poly_0x8005.h create mode 100644 include/etl/private/crc32_poly_0x04c11db7.h create mode 100644 include/etl/private/crc32_poly_0x1edc6f41.h create mode 100644 include/etl/private/crc64_poly_0x42f0e1eba9ea3693.h create mode 100644 include/etl/private/crc8_poly_0x07.h diff --git a/README.md b/README.md index 978d25d3..3429ac9b 100644 --- a/README.md +++ b/README.md @@ -3,12 +3,12 @@ Embedded Template Library (ETL) AppVeyor [![Build status](https://ci.appveyor.com/api/projects/status/b7jgecv7unqjw4u0/branch/master?svg=true)](https://ci.appveyor.com/project/jwellbelove/etl/branch/master) -![build status](https://gitlab.com/ETLCPP/etl/badges/master/build.svg) [![Codacy Badge](https://api.codacy.com/project/badge/Grade/3c14cd918ccf40008d0bcd7b083d5946)](https://www.codacy.com/manual/jwellbelove/etl?utm_source=github.com&utm_medium=referral&utm_content=ETLCPP/etl&utm_campaign=Badge_Grade) ![GitHub release (latest by date)](https://img.shields.io/github/v/release/jwellbelove/etl) [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT) [![Github All Releases](https://img.shields.io/github/downloads/ETLCPP/etl/total.svg)]() + **Motivation** C++ is a great language to use for embedded applications and templates are a powerful aspect. The standard library can offer a great deal of well tested functionality, but there are some parts of the standard library that do not fit well with deterministic behaviour and limited resource requirements. These limitations usually preclude the use of dynamically allocated memory and containers with open ended sizes. diff --git a/images/etl.ico b/images/etl.ico new file mode 100644 index 0000000000000000000000000000000000000000..fe0e36656ce6391b77d697e96925fc43bbdd03b6 GIT binary patch literal 1150 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 ZnO$$=8Zq}{0B09;aG#II(>nk literal 0 HcmV?d00001 diff --git a/images/etl.pspimage b/images/etl.pspimage new file mode 100644 index 0000000000000000000000000000000000000000..a5329e63b7d3ef3fa5a4a7f010343d07226fd1e3 GIT binary patch literal 11544 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 AH~;_u literal 0 HcmV?d00001 diff --git a/images/etl.xar b/images/etl.xar new file mode 100644 index 0000000000000000000000000000000000000000..cbfaa863b4e107c0393945fa6b67ddc39eb0b685 GIT binary patch literal 28896 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 Oe0<^L&#is1|Nb9*K*@Um literal 0 HcmV?d00001 diff --git a/images/etl16.png b/images/etl16.png new file mode 100644 index 0000000000000000000000000000000000000000..44cad996510bf6dcd0beb8ad5e024b331bb9c86a GIT binary patch literal 15993 zcmeI3Z)_Y#6~Lb_cAOYHDa2_S=il|}2&ZMew|Bm?Z#iFO>;$`TiE$j+NkMdPZ_Zxj z?)G}Owl9`YQ%Go=3JH)1H zcJH6Zz9E7lzU)YEZ{NImZ)ScoZ*ITLOT&l1*wWP21OP2Vg99V@`w*2)8}Yes!Bp^P zb7t^(4q(e4sMP)7i7mSTLYKACabrCCWm(lzol0Dfk+ zj}=$OcUmoa+*T9gWUr@>cIY0D4!isHEO7@qgMunalDj+9DFu4`zQE_)KCcuIy&+NZ z3SLQ;yt2>hE*4Lu3E#rmctRc-I8^KowO-GpVPs@coSB*Fobh++*$Gh!g+ij&C;EH> zwh(fs(uR^3(z(a%Af-41B&TMzjG^giH;t>r^eLm)s^UP1{8xta6bkG zuTSuGk4oLLKP3ACC#wAIMvQw@k86ojRqlSl8yxk94c_K)34m$A~I)D?UY#;$2-r%qzu&o>(mA3#w|++wHT^MWfa3YeEm`>J&{6 z3~iqzab3mmm0<<&j8KD$PaystNsuHG5JGXOOHhJ-zuMKMNPZtq!yac|LM$ZtCE{0u!Jt~|Vx2H+x*F7SxIIr* zZCl*D)=_qpJiEHKWJqe(k(5!gIYJYz*Hg;4@)=e>qNtCRxU!}? ztg>g(OwU*%rAkC{o5u8~i66stjP|D2vMW|S=Ho50QSAX#olUG2t(4~z8N zPip^zHOMK`|J@2aSVH}0E5IH}|GyQe>|J$INl%b?L@aIFQpJNUn!S{(^Qn}hYx6Hm z|AS=AUEEBHl`~RUTvJ!+*=|2hb1*q&wGRcoSnx{)OVPF3%(@=uyH=Z7*NW${v}Q!` z6txD*R9AV?KT7*hKZ@UUBoYh+{DH8@RqQ zqNBZ3RbO9L`q{PkZHJ$gV)?srO=gzQu21r%GNVs2Dih1;gaN`=9b9}qjMc%#0O6|+ zEfmC4@KpyFpATboa4|sms)LKqhp{@i7$AJr!NuppSRGsp5Wec*;`3pw4lV`= zUv+Tt`7l-o7XyT^I=J|J7^{Pe0m4@uTzo!^)xpI8;j0cVJ|D*F;9`LARR*bS5xJtCQ0M<%o)6g zIUT=r1n+RV)xnV{!0dj2)87KPZ{qK}08?IoTh9Q_GW6N~xIGZt?EQeEr7F z8#?~{GXe{@{%YAiUS5XK3E+Dq*kKefXge!(ob>goU*Tkw)=u}nAb z!SH+F<H)h82A5-O~pC=B;o>5Ue)W_wI#`0|&rF zD9>KK3L$KB7A?O+`J>gM`0$ZCg`TH~`H@+>eE#XDt?ALJP-&pk+37b&zik%kH$L11 zSKpX}MI#BDTeidbwl)|e1TMbz8ocr5o46_~&{`zVZ*8@H>EqVz+xGigZ^1{!+9h1#23*tneONJu@(9W=P=+sGhOZh1+?|_) zvuDqO%jE)}&xaO(SI?b;@tZec>BIM7_UD&i$L+fS$6hoGu)D{^VAjxZQLLc{Mn-B< z{SYm3G+}y`TLl*#Hr=9&C=nDF%Ihe9x^Mv=^>}bb?VvvQ9M)hN8-sDw_qRO^mk{v2 z_U%@C+lbHKqnt*OQC>#5{`T8&?bJqmV6cjDcJd8+|^ zJdg4l6a!^13T1Qpy{iBVbMSoO25NR${9xYRi7U&{()ws0EWB$c(|xonC_hG_8Azx2 ztG_J5_r5d*<~6u-N9%>jmczEE#7oPd%zW^t+a`ylL literal 0 HcmV?d00001 diff --git a/images/etl32.png b/images/etl32.png new file mode 100644 index 0000000000000000000000000000000000000000..3d5f9369d33c1984877ca38ab29d662b7c3db362 GIT binary patch literal 19081 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 E59?JFa{vGU literal 0 HcmV?d00001 diff --git a/images/favicon.ico b/images/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..2cf75c1d8fd21319ad87182ae6f301ee04e66f98 GIT binary patch literal 1150 zcma)*F-(&|6vwY<3zk%hX(ayLxS`!k#=6A36zW0CcySsOc8St}O z8Acboah$O>#@HDE7d#a|3>(I~&65?xTs-BKK;e7RSE{EEa}D^xMCnshE4|blrLX#6 zU0iuNP$;G}G9EJ!QvHPu|M$TK&_gcQKF!Z9Qe$H+#(?l=>G+wV2F&{tym_Y+A z-rgngboaV3ujR+3&33<3LL?99xh)VH@kKJhiO?ty+x>BU+_-Fvb|EEbiTqXu2SN-u_N(Dy*! z0nGu(k=e{h*B8j+xk#ZbfWWX71 zCr9|VxSO|FI%)D!8Q=DlGMNP#o6TnBw}-=F^7{jnNa)nmB=-3k_yv6%^r!iopo{y4 zdZp&5VQuY!s+)lod)x=T=$}!ZPYiNP^9j<%MsPNFD4nikSzlk3XD80j=@jc8RoYot zrt~9NzrU{koX%C5AQG97ag{x=Ds8QQRR8kbfBN@qf0xu>i~oei2%10YLP*dMq*zgGe~dnxTe+yg;A;pMN#9eis} i+>HPj2R?8fRAQ7pz}?@$_o&AXJG;zS+FkYhkNpEi=KzlY literal 0 HcmV?d00001 diff --git a/include/etl/crc16.h b/include/etl/crc16.h index 43632a39..a742acd7 100644 --- a/include/etl/crc16.h +++ b/include/etl/crc16.h @@ -31,12 +31,8 @@ SOFTWARE. #ifndef ETL_CRC16_INCLUDED #define ETL_CRC16_INCLUDED -#include - #include "platform.h" -#include "frame_check_sequence.h" - -#include "stl/iterator.h" +#include "private/crc16_poly_0x8005.h" #if defined(ETL_COMPILER_KEIL) #pragma diag_suppress 1300 @@ -47,77 +43,7 @@ SOFTWARE. namespace etl { - //*************************************************************************** - /// CRC16 policy. - /// Calculates CRC16 using polynomial 0x8005. - //*************************************************************************** - struct crc_policy_16 - { - typedef uint16_t value_type; - - inline uint16_t initial() const - { - return 0; - } - - inline uint16_t add(uint16_t crc, uint8_t value) const - { - const uint16_t CRC16[256] = - { - 0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, 0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440, - 0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40, 0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841, - 0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40, 0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41, - 0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641, 0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040, - 0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240, 0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441, - 0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41, 0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840, - 0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41, 0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40, - 0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640, 0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041, - 0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240, 0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441, - 0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41, 0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840, - 0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41, 0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40, - 0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640, 0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041, - 0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241, 0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440, - 0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40, 0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841, - 0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40, 0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41, - 0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641, 0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040 - }; - - return (crc >> 8) ^ CRC16[(crc ^ value) & 0xFF]; - } - - inline uint16_t final(uint16_t crc) const - { - return crc; - } - }; - - //************************************************************************* - /// CRC16 - //************************************************************************* - class crc16 : public etl::frame_check_sequence - { - public: - - //************************************************************************* - /// Default constructor. - //************************************************************************* - crc16() - { - this->reset(); - } - - //************************************************************************* - /// Constructor from range. - /// \param begin Start of the range. - /// \param end End of the range. - //************************************************************************* - template - crc16(TIterator begin, const TIterator end) - { - this->reset(); - this->add(begin, end); - } - }; + typedef crc16_poly_0x8005<0x0000U, 0x0000U, true> crc16; } #endif diff --git a/include/etl/crc16_aug_ccitt.h b/include/etl/crc16_aug_ccitt.h new file mode 100644 index 00000000..6725b57d --- /dev/null +++ b/include/etl/crc16_aug_ccitt.h @@ -0,0 +1,49 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2019 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_CRC16_AUG_CCITT_INCLUDED +#define ETL_CRC16_AUG_CCITT_INCLUDED + +#include "platform.h" +#include "private/crc16_poly_0x1021_.h" + +#if defined(ETL_COMPILER_KEIL) +#pragma diag_suppress 1300 +#endif + +///\defgroup crc16_aug_ccitt 16 bit CRC AUG CCITT calculation +///\ingroup crc + +namespace etl +{ + typedef crc16_poly_0x1021<0x1D0FU, 0x0000U, false> crc16_aug_ccitt; +} + +#endif diff --git a/include/etl/crc16_ccitt.h b/include/etl/crc16_ccitt.h index 9853ed70..66d1638f 100644 --- a/include/etl/crc16_ccitt.h +++ b/include/etl/crc16_ccitt.h @@ -34,9 +34,7 @@ SOFTWARE. #include #include "platform.h" -#include "frame_check_sequence.h" - -#include "stl/iterator.h" +#include "private/crc16_poly_0x1021_.h" #if defined(ETL_COMPILER_KEIL) #pragma diag_suppress 1300 @@ -47,77 +45,7 @@ SOFTWARE. namespace etl { - //*************************************************************************** - /// CRC16 CCITT policy. - /// Calculates CRC16 CCITT using polynomial 0x1021 - //*************************************************************************** - struct crc_policy_16_ccitt - { - typedef uint16_t value_type; - - inline uint16_t initial() const - { - return 0xFFFF; - } - - inline uint16_t add(uint16_t crc, uint8_t value) const - { - static const uint16_t CRC_CCITT[] = - { - 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, - 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, - 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, - 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, - 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, - 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, - 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, - 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, - 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, - 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, - 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, - 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, - 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, - 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, - 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, - 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 - }; - - return (crc << 8) ^ CRC_CCITT[((crc >> 8) ^ value) & 0xFF]; - } - - inline uint16_t final(uint16_t crc) const - { - return crc; - } - }; - - //************************************************************************* - /// CRC16 CCITT - //************************************************************************* - class crc16_ccitt : public etl::frame_check_sequence - { - public: - - //************************************************************************* - /// Default constructor. - //************************************************************************* - crc16_ccitt() - { - this->reset(); - } - - //************************************************************************* - /// Constructor from range. - /// \param begin Start of the range. - /// \param end End of the range. - //************************************************************************* - template - crc16_ccitt(TIterator begin, const TIterator end) - { - this->reset(); - this->add(begin, end); - } - }; + typedef crc16_poly_0x1021<0xFFFFU, 0x0000U, false> crc16_ccitt; } #endif diff --git a/include/etl/crc16_genibus.h b/include/etl/crc16_genibus.h new file mode 100644 index 00000000..876c0246 --- /dev/null +++ b/include/etl/crc16_genibus.h @@ -0,0 +1,49 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2019 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_CRC16_GENIBUS_INCLUDED +#define ETL_CRC16_GENIBUS_INCLUDED + +#include "platform.h" +#include "private/crc16_poly_0x1021_.h" + +#if defined(ETL_COMPILER_KEIL) +#pragma diag_suppress 1300 +#endif + +///\defgroup crc16_aug_ccitt 16 bit CRC GENIBUS calculation +///\ingroup crc + +namespace etl +{ + typedef crc16_poly_0x1021<0xFFFFU, 0xFFFFU, false> crc16_genibus; +} + +#endif diff --git a/include/etl/crc16_kermit.h b/include/etl/crc16_kermit.h index 2de2b2da..cdf878b2 100644 --- a/include/etl/crc16_kermit.h +++ b/include/etl/crc16_kermit.h @@ -34,9 +34,7 @@ SOFTWARE. #include #include "platform.h" -#include "frame_check_sequence.h" - -#include "stl/iterator.h" +#include "private/crc16_poly_0x1021_.h" #if defined(ETL_COMPILER_KEIL) #pragma diag_suppress 1300 @@ -47,77 +45,7 @@ SOFTWARE. namespace etl { - //*************************************************************************** - /// CRC16 Kermit policy. - /// Calculates CRC16 Kermit using polynomial 0x1021 - //*************************************************************************** - struct crc_policy_16_kermit - { - typedef uint16_t value_type; - - inline uint16_t initial() const - { - return 0; - } - - inline uint16_t add(uint16_t crc, uint8_t value) const - { - static const uint16_t CRC_KERMIT[] = - { - 0x0000, 0x1189, 0x2312, 0x329B, 0x4624, 0x57AD, 0x6536, 0x74BF, 0x8C48, 0x9DC1, 0xAF5A, 0xBED3, 0xCA6C, 0xDBE5, 0xE97E, 0xF8F7, - 0x1081, 0x0108, 0x3393, 0x221A, 0x56A5, 0x472C, 0x75B7, 0x643E, 0x9CC9, 0x8D40, 0xBFDB, 0xAE52, 0xDAED, 0xCB64, 0xF9FF, 0xE876, - 0x2102, 0x308B, 0x0210, 0x1399, 0x6726, 0x76AF, 0x4434, 0x55BD, 0xAD4A, 0xBCC3, 0x8E58, 0x9FD1, 0xEB6E, 0xFAE7, 0xC87C, 0xD9F5, - 0x3183, 0x200A, 0x1291, 0x0318, 0x77A7, 0x662E, 0x54B5, 0x453C, 0xBDCB, 0xAC42, 0x9ED9, 0x8F50, 0xFBEF, 0xEA66, 0xD8FD, 0xC974, - 0x4204, 0x538D, 0x6116, 0x709F, 0x0420, 0x15A9, 0x2732, 0x36BB, 0xCE4C, 0xDFC5, 0xED5E, 0xFCD7, 0x8868, 0x99E1, 0xAB7A, 0xBAF3, - 0x5285, 0x430C, 0x7197, 0x601E, 0x14A1, 0x0528, 0x37B3, 0x263A, 0xDECD, 0xCF44, 0xFDDF, 0xEC56, 0x98E9, 0x8960, 0xBBFB, 0xAA72, - 0x6306, 0x728F, 0x4014, 0x519D, 0x2522, 0x34AB, 0x0630, 0x17B9, 0xEF4E, 0xFEC7, 0xCC5C, 0xDDD5, 0xA96A, 0xB8E3, 0x8A78, 0x9BF1, - 0x7387, 0x620E, 0x5095, 0x411C, 0x35A3, 0x242A, 0x16B1, 0x0738, 0xFFCF, 0xEE46, 0xDCDD, 0xCD54, 0xB9EB, 0xA862, 0x9AF9, 0x8B70, - 0x8408, 0x9581, 0xA71A, 0xB693, 0xC22C, 0xD3A5, 0xE13E, 0xF0B7, 0x0840, 0x19C9, 0x2B52, 0x3ADB, 0x4E64, 0x5FED, 0x6D76, 0x7CFF, - 0x9489, 0x8500, 0xB79B, 0xA612, 0xD2AD, 0xC324, 0xF1BF, 0xE036, 0x18C1, 0x0948, 0x3BD3, 0x2A5A, 0x5EE5, 0x4F6C, 0x7DF7, 0x6C7E, - 0xA50A, 0xB483, 0x8618, 0x9791, 0xE32E, 0xF2A7, 0xC03C, 0xD1B5, 0x2942, 0x38CB, 0x0A50, 0x1BD9, 0x6F66, 0x7EEF, 0x4C74, 0x5DFD, - 0xB58B, 0xA402, 0x9699, 0x8710, 0xF3AF, 0xE226, 0xD0BD, 0xC134, 0x39C3, 0x284A, 0x1AD1, 0x0B58, 0x7FE7, 0x6E6E, 0x5CF5, 0x4D7C, - 0xC60C, 0xD785, 0xE51E, 0xF497, 0x8028, 0x91A1, 0xA33A, 0xB2B3, 0x4A44, 0x5BCD, 0x6956, 0x78DF, 0x0C60, 0x1DE9, 0x2F72, 0x3EFB, - 0xD68D, 0xC704, 0xF59F, 0xE416, 0x90A9, 0x8120, 0xB3BB, 0xA232, 0x5AC5, 0x4B4C, 0x79D7, 0x685E, 0x1CE1, 0x0D68, 0x3FF3, 0x2E7A, - 0xE70E, 0xF687, 0xC41C, 0xD595, 0xA12A, 0xB0A3, 0x8238, 0x93B1, 0x6B46, 0x7ACF, 0x4854, 0x59DD, 0x2D62, 0x3CEB, 0x0E70, 0x1FF9, - 0xF78F, 0xE606, 0xD49D, 0xC514, 0xB1AB, 0xA022, 0x92B9, 0x8330, 0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78 - }; - - return (crc >> 8) ^ CRC_KERMIT[(crc ^ value) & 0xFF]; - } - - inline uint16_t final(uint16_t crc) const - { - return crc; - } - }; - - //************************************************************************* - /// CRC16 Kermit - //************************************************************************* - class crc16_kermit : public etl::frame_check_sequence - { - public: - - //************************************************************************* - /// Default constructor. - //************************************************************************* - crc16_kermit() - { - this->reset(); - } - - //************************************************************************* - /// Constructor from range. - /// \param begin Start of the range. - /// \param end End of the range. - //************************************************************************* - template - crc16_kermit(TIterator begin, const TIterator end) - { - this->reset(); - this->add(begin, end); - } - }; + typedef crc16_poly_0x1021<0x0000U, 0x0000U, true> crc16_kermit; } #endif diff --git a/include/etl/crc16_modbus.h b/include/etl/crc16_modbus.h index cd0814ac..e61d339a 100644 --- a/include/etl/crc16_modbus.h +++ b/include/etl/crc16_modbus.h @@ -34,9 +34,7 @@ SOFTWARE. #include #include "platform.h" -#include "frame_check_sequence.h" - -#include "stl/iterator.h" +#include "private/crc16_poly_0x8005.h" #if defined(ETL_COMPILER_KEIL) #pragma diag_suppress 1300 @@ -47,93 +45,7 @@ SOFTWARE. namespace etl { - //*************************************************************************** - /// CRC16 MODBUS policy. - /// Calculates CRC16 MODBUS using polynomial 0x - //*************************************************************************** - struct crc_policy_16_modbus - { - typedef uint16_t value_type; - - inline uint16_t initial() const - { - return 0xFFFF; - } - - inline uint16_t add(uint16_t crc, uint8_t value) const - { - static const uint16_t ETL_CRC_MODBUS[] = - { - 0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, - 0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440, - 0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40, - 0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841, - 0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40, - 0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41, - 0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641, - 0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040, - 0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240, - 0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441, - 0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41, - 0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840, - 0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41, - 0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40, - 0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640, - 0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041, - 0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240, - 0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441, - 0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41, - 0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840, - 0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41, - 0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40, - 0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640, - 0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041, - 0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241, - 0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440, - 0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40, - 0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841, - 0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40, - 0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41, - 0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641, - 0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040 - }; - - return (crc >> 8) ^ ETL_CRC_MODBUS[(crc ^ value) & 0xFF]; - } - - inline uint16_t final(uint16_t crc) const - { - return crc; - } - }; - - //************************************************************************* - /// CRC16 MODBUS - //************************************************************************* - class crc16_modbus : public etl::frame_check_sequence - { - public: - - //************************************************************************* - /// Default constructor. - //************************************************************************* - crc16_modbus() - { - this->reset(); - } - - //************************************************************************* - /// Constructor from range. - /// \param begin Start of the range. - /// \param end End of the range. - //************************************************************************* - template - crc16_modbus(TIterator begin, const TIterator end) - { - this->reset(); - this->add(begin, end); - } - }; + typedef crc16_poly_0x8005<0xFFFFU, 0x0000U, true> crc16_modbus; } #endif diff --git a/include/etl/crc16_usb.h b/include/etl/crc16_usb.h new file mode 100644 index 00000000..0538eb58 --- /dev/null +++ b/include/etl/crc16_usb.h @@ -0,0 +1,51 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2018 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_CRC16_USB_INCLUDED +#define ETL_CRC16_USB_INCLUDED + +#include + +#include "platform.h" +#include "private/crc16_poly_0x8005.h" + +#if defined(ETL_COMPILER_KEIL) +#pragma diag_suppress 1300 +#endif + +///\defgroup crc16_modbus 16 bit CRC USB calculation +///\ingroup crc + +namespace etl +{ + typedef crc16_poly_0x8005<0xFFFFU, 0xFFFFU, true> crc16_usb; +} + +#endif diff --git a/include/etl/crc16_x25.h b/include/etl/crc16_x25.h new file mode 100644 index 00000000..e2ec150b --- /dev/null +++ b/include/etl/crc16_x25.h @@ -0,0 +1,49 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2019 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_CRC16_X25_INCLUDED +#define ETL_CRC16_X25_INCLUDED + +#include "platform.h" +#include "private/crc16_poly_0x1021_.h" + +#if defined(ETL_COMPILER_KEIL) +#pragma diag_suppress 1300 +#endif + +///\defgroup crc16_aug_ccitt 16 bit CRC X25 calculation +///\ingroup crc + +namespace etl +{ + typedef crc16_poly_0x1021<0xFFFFU, 0xFFFFU, true> crc16_x25; +} + +#endif diff --git a/include/etl/crc16_xmodem.h b/include/etl/crc16_xmodem.h new file mode 100644 index 00000000..3c0f6ec4 --- /dev/null +++ b/include/etl/crc16_xmodem.h @@ -0,0 +1,49 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2019 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_CRC16_XMODEM_INCLUDED +#define ETL_CRC16_XMODEM_INCLUDED + +#include "platform.h" +#include "private/crc16_poly_0x1021_.h" + +#if defined(ETL_COMPILER_KEIL) +#pragma diag_suppress 1300 +#endif + +///\defgroup crc16_xmodem 16 bit CRC XMODEM calculation +///\ingroup crc + +namespace etl +{ + typedef crc16_poly_0x1021<0x0000U, 0x0000U, false> crc16_xmodem; +} + +#endif diff --git a/include/etl/crc32.h b/include/etl/crc32.h index 10d35a99..463f3e38 100644 --- a/include/etl/crc32.h +++ b/include/etl/crc32.h @@ -31,12 +31,8 @@ SOFTWARE. #ifndef ETL_CRC32_INCLUDED #define ETL_CRC32_INCLUDED -#include - #include "platform.h" -#include "frame_check_sequence.h" - -#include "stl/iterator.h" +#include "private/crc32_poly_0x04c11db7.h" #if defined(ETL_COMPILER_KEIL) #pragma diag_suppress 1300 @@ -47,93 +43,7 @@ SOFTWARE. namespace etl { - //*************************************************************************** - /// CRC32 policy. - /// Calculates CRC32 using polynomial 0x04C11DB7. - //*************************************************************************** - struct crc_policy_32 - { - typedef uint32_t value_type; - - inline uint32_t initial() const - { - return 0xFFFFFFFF; - } - - inline uint32_t add(uint32_t crc, uint8_t value) const - { - static const uint32_t CRC32[] = - { - 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, - 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, - 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, - 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, - 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, - 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, - 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, - 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, - 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, - 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, - 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, - 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, - 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, - 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, - 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, - 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, - 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, - 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, - 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, - 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, - 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, - 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, - 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, - 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, - 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, - 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, - 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, - 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, - 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, - 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, - 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, - 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D - }; - - return (crc >> 8) ^ CRC32[(crc ^ value) & 0xFF]; - } - - inline uint32_t final(uint32_t crc) const - { - return crc ^ 0xFFFFFFFF; - } - }; - - //************************************************************************* - /// CRC32 - //************************************************************************* - class crc32 : public etl::frame_check_sequence - { - public: - - //************************************************************************* - /// Default constructor. - //************************************************************************* - crc32() - { - this->reset(); - } - - //************************************************************************* - /// Constructor from range. - /// \param begin Start of the range. - /// \param end End of the range. - //************************************************************************* - template - crc32(TIterator begin, const TIterator end) - { - this->reset(); - this->add(begin, end); - } - }; + typedef crc32_poly_0x04c11db7<0xFFFFFFFFU, 0xFFFFFFFFU, true> crc32; } #endif diff --git a/include/etl/crc32_bzip2.h b/include/etl/crc32_bzip2.h new file mode 100644 index 00000000..488b297e --- /dev/null +++ b/include/etl/crc32_bzip2.h @@ -0,0 +1,49 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2019 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_CRC32_BZIP2_INCLUDED +#define ETL_CRC32_BZIP2_INCLUDED + +#include "platform.h" +#include "private/crc32_poly_0x04c11db7.h" + +#if defined(ETL_COMPILER_KEIL) +#pragma diag_suppress 1300 +#endif + +///\defgroup crc32 BZIP2 32 bit CRC calculation +///\ingroup crc + +namespace etl +{ + typedef crc32_poly_0x04c11db7<0xFFFFFFFFU, 0xFFFFFFFFU, false> crc32_bzip2; +} + +#endif diff --git a/include/etl/crc32_c.h b/include/etl/crc32_c.h index e21aa76e..fb012be6 100644 --- a/include/etl/crc32_c.h +++ b/include/etl/crc32_c.h @@ -31,12 +31,8 @@ SOFTWARE. #ifndef ETL_CRC32_C_INCLUDED #define ETL_CRC32_C_INCLUDED -#include - #include "platform.h" -#include "frame_check_sequence.h" - -#include "stl/iterator.h" +#include "private/crc32_poly_0x1edc6f41.h" #if defined(ETL_COMPILER_KEIL) #pragma diag_suppress 1300 @@ -47,93 +43,7 @@ SOFTWARE. namespace etl { - //*************************************************************************** - /// CRC32_C policy. - /// Calculates CRC32_C using polynomial 0x1EDC6F41. - //*************************************************************************** - struct crc_policy_32_c - { - typedef uint32_t value_type; - - inline uint32_t initial() const - { - return 0xFFFFFFFF; - } - - inline uint32_t add(uint32_t crc, uint8_t value) const - { - static const uint32_t CRC32_C[] = - { - 0x00000000L, 0xF26B8303L, 0xE13B70F7L, 0x1350F3F4L, 0xC79A971FL, 0x35F1141CL, 0x26A1E7E8L, 0xD4CA64EBL, - 0x8AD958CFL, 0x78B2DBCCL, 0x6BE22838L, 0x9989AB3BL, 0x4D43CFD0L, 0xBF284CD3L, 0xAC78BF27L, 0x5E133C24L, - 0x105EC76FL, 0xE235446CL, 0xF165B798L, 0x030E349BL, 0xD7C45070L, 0x25AFD373L, 0x36FF2087L, 0xC494A384L, - 0x9A879FA0L, 0x68EC1CA3L, 0x7BBCEF57L, 0x89D76C54L, 0x5D1D08BFL, 0xAF768BBCL, 0xBC267848L, 0x4E4DFB4BL, - 0x20BD8EDEL, 0xD2D60DDDL, 0xC186FE29L, 0x33ED7D2AL, 0xE72719C1L, 0x154C9AC2L, 0x061C6936L, 0xF477EA35L, - 0xAA64D611L, 0x580F5512L, 0x4B5FA6E6L, 0xB93425E5L, 0x6DFE410EL, 0x9F95C20DL, 0x8CC531F9L, 0x7EAEB2FAL, - 0x30E349B1L, 0xC288CAB2L, 0xD1D83946L, 0x23B3BA45L, 0xF779DEAEL, 0x05125DADL, 0x1642AE59L, 0xE4292D5AL, - 0xBA3A117EL, 0x4851927DL, 0x5B016189L, 0xA96AE28AL, 0x7DA08661L, 0x8FCB0562L, 0x9C9BF696L, 0x6EF07595L, - 0x417B1DBCL, 0xB3109EBFL, 0xA0406D4BL, 0x522BEE48L, 0x86E18AA3L, 0x748A09A0L, 0x67DAFA54L, 0x95B17957L, - 0xCBA24573L, 0x39C9C670L, 0x2A993584L, 0xD8F2B687L, 0x0C38D26CL, 0xFE53516FL, 0xED03A29BL, 0x1F682198L, - 0x5125DAD3L, 0xA34E59D0L, 0xB01EAA24L, 0x42752927L, 0x96BF4DCCL, 0x64D4CECFL, 0x77843D3BL, 0x85EFBE38L, - 0xDBFC821CL, 0x2997011FL, 0x3AC7F2EBL, 0xC8AC71E8L, 0x1C661503L, 0xEE0D9600L, 0xFD5D65F4L, 0x0F36E6F7L, - 0x61C69362L, 0x93AD1061L, 0x80FDE395L, 0x72966096L, 0xA65C047DL, 0x5437877EL, 0x4767748AL, 0xB50CF789L, - 0xEB1FCBADL, 0x197448AEL, 0x0A24BB5AL, 0xF84F3859L, 0x2C855CB2L, 0xDEEEDFB1L, 0xCDBE2C45L, 0x3FD5AF46L, - 0x7198540DL, 0x83F3D70EL, 0x90A324FAL, 0x62C8A7F9L, 0xB602C312L, 0x44694011L, 0x5739B3E5L, 0xA55230E6L, - 0xFB410CC2L, 0x092A8FC1L, 0x1A7A7C35L, 0xE811FF36L, 0x3CDB9BDDL, 0xCEB018DEL, 0xDDE0EB2AL, 0x2F8B6829L, - 0x82F63B78L, 0x709DB87BL, 0x63CD4B8FL, 0x91A6C88CL, 0x456CAC67L, 0xB7072F64L, 0xA457DC90L, 0x563C5F93L, - 0x082F63B7L, 0xFA44E0B4L, 0xE9141340L, 0x1B7F9043L, 0xCFB5F4A8L, 0x3DDE77ABL, 0x2E8E845FL, 0xDCE5075CL, - 0x92A8FC17L, 0x60C37F14L, 0x73938CE0L, 0x81F80FE3L, 0x55326B08L, 0xA759E80BL, 0xB4091BFFL, 0x466298FCL, - 0x1871A4D8L, 0xEA1A27DBL, 0xF94AD42FL, 0x0B21572CL, 0xDFEB33C7L, 0x2D80B0C4L, 0x3ED04330L, 0xCCBBC033L, - 0xA24BB5A6L, 0x502036A5L, 0x4370C551L, 0xB11B4652L, 0x65D122B9L, 0x97BAA1BAL, 0x84EA524EL, 0x7681D14DL, - 0x2892ED69L, 0xDAF96E6AL, 0xC9A99D9EL, 0x3BC21E9DL, 0xEF087A76L, 0x1D63F975L, 0x0E330A81L, 0xFC588982L, - 0xB21572C9L, 0x407EF1CAL, 0x532E023EL, 0xA145813DL, 0x758FE5D6L, 0x87E466D5L, 0x94B49521L, 0x66DF1622L, - 0x38CC2A06L, 0xCAA7A905L, 0xD9F75AF1L, 0x2B9CD9F2L, 0xFF56BD19L, 0x0D3D3E1AL, 0x1E6DCDEEL, 0xEC064EEDL, - 0xC38D26C4L, 0x31E6A5C7L, 0x22B65633L, 0xD0DDD530L, 0x0417B1DBL, 0xF67C32D8L, 0xE52CC12CL, 0x1747422FL, - 0x49547E0BL, 0xBB3FFD08L, 0xA86F0EFCL, 0x5A048DFFL, 0x8ECEE914L, 0x7CA56A17L, 0x6FF599E3L, 0x9D9E1AE0L, - 0xD3D3E1ABL, 0x21B862A8L, 0x32E8915CL, 0xC083125FL, 0x144976B4L, 0xE622F5B7L, 0xF5720643L, 0x07198540L, - 0x590AB964L, 0xAB613A67L, 0xB831C993L, 0x4A5A4A90L, 0x9E902E7BL, 0x6CFBAD78L, 0x7FAB5E8CL, 0x8DC0DD8FL, - 0xE330A81AL, 0x115B2B19L, 0x020BD8EDL, 0xF0605BEEL, 0x24AA3F05L, 0xD6C1BC06L, 0xC5914FF2L, 0x37FACCF1L, - 0x69E9F0D5L, 0x9B8273D6L, 0x88D28022L, 0x7AB90321L, 0xAE7367CAL, 0x5C18E4C9L, 0x4F48173DL, 0xBD23943EL, - 0xF36E6F75L, 0x0105EC76L, 0x12551F82L, 0xE03E9C81L, 0x34F4F86AL, 0xC69F7B69L, 0xD5CF889DL, 0x27A40B9EL, - 0x79B737BAL, 0x8BDCB4B9L, 0x988C474DL, 0x6AE7C44EL, 0xBE2DA0A5L, 0x4C4623A6L, 0x5F16D052L, 0xAD7D5351L - }; - - return (crc >> 8) ^ CRC32_C[(crc ^ value) & 0xFF]; - } - - inline uint32_t final(uint32_t crc) const - { - return crc ^ 0xFFFFFFFF; - } - }; - - //************************************************************************* - /// CRC32_C - //************************************************************************* - class crc32_c : public etl::frame_check_sequence - { - public: - - //************************************************************************* - /// Default constructor. - //************************************************************************* - crc32_c() - { - this->reset(); - } - - //************************************************************************* - /// Constructor from range. - /// \param begin Start of the range. - /// \param end End of the range. - //************************************************************************* - template - crc32_c(TIterator begin, const TIterator end) - { - this->reset(); - this->add(begin, end); - } - }; + typedef crc32_poly_0x1edc6f41<0xFFFFFFFFU, 0xFFFFFFFFU, true> crc32_c; } #endif diff --git a/include/etl/crc32_mpeg2.h b/include/etl/crc32_mpeg2.h new file mode 100644 index 00000000..d085c212 --- /dev/null +++ b/include/etl/crc32_mpeg2.h @@ -0,0 +1,49 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2019 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_CRC32_MPEG2_INCLUDED +#define ETL_CRC32_MPEG2_INCLUDED + +#include "platform.h" +#include "private/crc32_poly_0x04c11db7.h" + +#if defined(ETL_COMPILER_KEIL) +#pragma diag_suppress 1300 +#endif + +///\defgroup crc32 MPEG2 32 bit CRC calculation +///\ingroup crc + +namespace etl +{ + typedef crc32_poly_0x04c11db7<0xFFFFFFFFU, 0x00000000U, false> crc32_mpeg2; +} + +#endif diff --git a/include/etl/crc32_posix.h b/include/etl/crc32_posix.h new file mode 100644 index 00000000..1219248a --- /dev/null +++ b/include/etl/crc32_posix.h @@ -0,0 +1,49 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2019 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_CRC32_POSIX_INCLUDED +#define ETL_CRC32_POSIX_INCLUDED + +#include "platform.h" +#include "private/crc32_poly_0x04c11db7.h" + +#if defined(ETL_COMPILER_KEIL) +#pragma diag_suppress 1300 +#endif + +///\defgroup crc32 POSIX 32 bit CRC calculation +///\ingroup crc + +namespace etl +{ + typedef crc32_poly_0x04c11db7<0x00000000U, 0xFFFFFFFFU, false> crc32_posix; +} + +#endif diff --git a/include/etl/crc64_ecma.h b/include/etl/crc64_ecma.h index edbdaebb..a7d263a3 100644 --- a/include/etl/crc64_ecma.h +++ b/include/etl/crc64_ecma.h @@ -31,12 +31,8 @@ SOFTWARE. #ifndef ETL_CRC64_ECMA_INCLUDED #define ETL_CRC64_ECMA_INCLUDED -#include - #include "platform.h" -#include "frame_check_sequence.h" - -#include "stl/iterator.h" +#include "private/crc64_poly_0x42f0e1eba9ea3693.h" #if defined(ETL_COMPILER_KEIL) #pragma diag_suppress 1300 @@ -47,125 +43,7 @@ SOFTWARE. namespace etl { - //*************************************************************************** - /// CRC64 policy. - /// Calculates CRC64 ECMA using polynomial 0x42F0E1EBA9EA3693. - //*************************************************************************** - struct crc_policy_64_ecma - { - typedef uint64_t value_type; - - inline uint64_t initial() const - { - return 0; - } - - inline uint64_t add(uint64_t crc, uint8_t value) const - { - static const uint64_t CRC64_ECMA[] = - { - 0x0000000000000000, 0x42F0E1EBA9EA3693, 0x85E1C3D753D46D26, 0xC711223CFA3E5BB5, - 0x493366450E42ECDF, 0x0BC387AEA7A8DA4C, 0xCCD2A5925D9681F9, 0x8E224479F47CB76A, - 0x9266CC8A1C85D9BE, 0xD0962D61B56FEF2D, 0x17870F5D4F51B498, 0x5577EEB6E6BB820B, - 0xDB55AACF12C73561, 0x99A54B24BB2D03F2, 0x5EB4691841135847, 0x1C4488F3E8F96ED4, - 0x663D78FF90E185EF, 0x24CD9914390BB37C, 0xE3DCBB28C335E8C9, 0xA12C5AC36ADFDE5A, - 0x2F0E1EBA9EA36930, 0x6DFEFF5137495FA3, 0xAAEFDD6DCD770416, 0xE81F3C86649D3285, - 0xF45BB4758C645C51, 0xB6AB559E258E6AC2, 0x71BA77A2DFB03177, 0x334A9649765A07E4, - 0xBD68D2308226B08E, 0xFF9833DB2BCC861D, 0x388911E7D1F2DDA8, 0x7A79F00C7818EB3B, - 0xCC7AF1FF21C30BDE, 0x8E8A101488293D4D, 0x499B3228721766F8, 0x0B6BD3C3DBFD506B, - 0x854997BA2F81E701, 0xC7B97651866BD192, 0x00A8546D7C558A27, 0x4258B586D5BFBCB4, - 0x5E1C3D753D46D260, 0x1CECDC9E94ACE4F3, 0xDBFDFEA26E92BF46, 0x990D1F49C77889D5, - 0x172F5B3033043EBF, 0x55DFBADB9AEE082C, 0x92CE98E760D05399, 0xD03E790CC93A650A, - 0xAA478900B1228E31, 0xE8B768EB18C8B8A2, 0x2FA64AD7E2F6E317, 0x6D56AB3C4B1CD584, - 0xE374EF45BF6062EE, 0xA1840EAE168A547D, 0x66952C92ECB40FC8, 0x2465CD79455E395B, - 0x3821458AADA7578F, 0x7AD1A461044D611C, 0xBDC0865DFE733AA9, 0xFF3067B657990C3A, - 0x711223CFA3E5BB50, 0x33E2C2240A0F8DC3, 0xF4F3E018F031D676, 0xB60301F359DBE0E5, - 0xDA050215EA6C212F, 0x98F5E3FE438617BC, 0x5FE4C1C2B9B84C09, 0x1D14202910527A9A, - 0x93366450E42ECDF0, 0xD1C685BB4DC4FB63, 0x16D7A787B7FAA0D6, 0x5427466C1E109645, - 0x4863CE9FF6E9F891, 0x0A932F745F03CE02, 0xCD820D48A53D95B7, 0x8F72ECA30CD7A324, - 0x0150A8DAF8AB144E, 0x43A04931514122DD, 0x84B16B0DAB7F7968, 0xC6418AE602954FFB, - 0xBC387AEA7A8DA4C0, 0xFEC89B01D3679253, 0x39D9B93D2959C9E6, 0x7B2958D680B3FF75, - 0xF50B1CAF74CF481F, 0xB7FBFD44DD257E8C, 0x70EADF78271B2539, 0x321A3E938EF113AA, - 0x2E5EB66066087D7E, 0x6CAE578BCFE24BED, 0xABBF75B735DC1058, 0xE94F945C9C3626CB, - 0x676DD025684A91A1, 0x259D31CEC1A0A732, 0xE28C13F23B9EFC87, 0xA07CF2199274CA14, - 0x167FF3EACBAF2AF1, 0x548F120162451C62, 0x939E303D987B47D7, 0xD16ED1D631917144, - 0x5F4C95AFC5EDC62E, 0x1DBC74446C07F0BD, 0xDAAD56789639AB08, 0x985DB7933FD39D9B, - 0x84193F60D72AF34F, 0xC6E9DE8B7EC0C5DC, 0x01F8FCB784FE9E69, 0x43081D5C2D14A8FA, - 0xCD2A5925D9681F90, 0x8FDAB8CE70822903, 0x48CB9AF28ABC72B6, 0x0A3B7B1923564425, - 0x70428B155B4EAF1E, 0x32B26AFEF2A4998D, 0xF5A348C2089AC238, 0xB753A929A170F4AB, - 0x3971ED50550C43C1, 0x7B810CBBFCE67552, 0xBC902E8706D82EE7, 0xFE60CF6CAF321874, - 0xE224479F47CB76A0, 0xA0D4A674EE214033, 0x67C58448141F1B86, 0x253565A3BDF52D15, - 0xAB1721DA49899A7F, 0xE9E7C031E063ACEC, 0x2EF6E20D1A5DF759, 0x6C0603E6B3B7C1CA, - 0xF6FAE5C07D3274CD, 0xB40A042BD4D8425E, 0x731B26172EE619EB, 0x31EBC7FC870C2F78, - 0xBFC9838573709812, 0xFD39626EDA9AAE81, 0x3A28405220A4F534, 0x78D8A1B9894EC3A7, - 0x649C294A61B7AD73, 0x266CC8A1C85D9BE0, 0xE17DEA9D3263C055, 0xA38D0B769B89F6C6, - 0x2DAF4F0F6FF541AC, 0x6F5FAEE4C61F773F, 0xA84E8CD83C212C8A, 0xEABE6D3395CB1A19, - 0x90C79D3FEDD3F122, 0xD2377CD44439C7B1, 0x15265EE8BE079C04, 0x57D6BF0317EDAA97, - 0xD9F4FB7AE3911DFD, 0x9B041A914A7B2B6E, 0x5C1538ADB04570DB, 0x1EE5D94619AF4648, - 0x02A151B5F156289C, 0x4051B05E58BC1E0F, 0x87409262A28245BA, 0xC5B073890B687329, - 0x4B9237F0FF14C443, 0x0962D61B56FEF2D0, 0xCE73F427ACC0A965, 0x8C8315CC052A9FF6, - 0x3A80143F5CF17F13, 0x7870F5D4F51B4980, 0xBF61D7E80F251235, 0xFD913603A6CF24A6, - 0x73B3727A52B393CC, 0x31439391FB59A55F, 0xF652B1AD0167FEEA, 0xB4A25046A88DC879, - 0xA8E6D8B54074A6AD, 0xEA16395EE99E903E, 0x2D071B6213A0CB8B, 0x6FF7FA89BA4AFD18, - 0xE1D5BEF04E364A72, 0xA3255F1BE7DC7CE1, 0x64347D271DE22754, 0x26C49CCCB40811C7, - 0x5CBD6CC0CC10FAFC, 0x1E4D8D2B65FACC6F, 0xD95CAF179FC497DA, 0x9BAC4EFC362EA149, - 0x158E0A85C2521623, 0x577EEB6E6BB820B0, 0x906FC95291867B05, 0xD29F28B9386C4D96, - 0xCEDBA04AD0952342, 0x8C2B41A1797F15D1, 0x4B3A639D83414E64, 0x09CA82762AAB78F7, - 0x87E8C60FDED7CF9D, 0xC51827E4773DF90E, 0x020905D88D03A2BB, 0x40F9E43324E99428, - 0x2CFFE7D5975E55E2, 0x6E0F063E3EB46371, 0xA91E2402C48A38C4, 0xEBEEC5E96D600E57, - 0x65CC8190991CB93D, 0x273C607B30F68FAE, 0xE02D4247CAC8D41B, 0xA2DDA3AC6322E288, - 0xBE992B5F8BDB8C5C, 0xFC69CAB42231BACF, 0x3B78E888D80FE17A, 0x7988096371E5D7E9, - 0xF7AA4D1A85996083, 0xB55AACF12C735610, 0x724B8ECDD64D0DA5, 0x30BB6F267FA73B36, - 0x4AC29F2A07BFD00D, 0x08327EC1AE55E69E, 0xCF235CFD546BBD2B, 0x8DD3BD16FD818BB8, - 0x03F1F96F09FD3CD2, 0x41011884A0170A41, 0x86103AB85A2951F4, 0xC4E0DB53F3C36767, - 0xD8A453A01B3A09B3, 0x9A54B24BB2D03F20, 0x5D45907748EE6495, 0x1FB5719CE1045206, - 0x919735E51578E56C, 0xD367D40EBC92D3FF, 0x1476F63246AC884A, 0x568617D9EF46BED9, - 0xE085162AB69D5E3C, 0xA275F7C11F7768AF, 0x6564D5FDE549331A, 0x279434164CA30589, - 0xA9B6706FB8DFB2E3, 0xEB46918411358470, 0x2C57B3B8EB0BDFC5, 0x6EA7525342E1E956, - 0x72E3DAA0AA188782, 0x30133B4B03F2B111, 0xF7021977F9CCEAA4, 0xB5F2F89C5026DC37, - 0x3BD0BCE5A45A6B5D, 0x79205D0E0DB05DCE, 0xBE317F32F78E067B, 0xFCC19ED95E6430E8, - 0x86B86ED5267CDBD3, 0xC4488F3E8F96ED40, 0x0359AD0275A8B6F5, 0x41A94CE9DC428066, - 0xCF8B0890283E370C, 0x8D7BE97B81D4019F, 0x4A6ACB477BEA5A2A, 0x089A2AACD2006CB9, - 0x14DEA25F3AF9026D, 0x562E43B4931334FE, 0x913F6188692D6F4B, 0xD3CF8063C0C759D8, - 0x5DEDC41A34BBEEB2, 0x1F1D25F19D51D821, 0xD80C07CD676F8394, 0x9AFCE626CE85B507 - }; - - return (crc << 8) ^ CRC64_ECMA[((crc >> 56) ^ value) & 0xFF]; - } - - inline uint64_t final(uint64_t crc) const - { - return crc; - } - }; - - //************************************************************************* - /// CRC64 ECMA - //************************************************************************* - class crc64_ecma : public etl::frame_check_sequence - { - public: - - //************************************************************************* - /// Default constructor. - //************************************************************************* - crc64_ecma() - { - this->reset(); - } - - //************************************************************************* - /// Constructor from range. - /// \param begin Start of the range. - /// \param end End of the range. - //************************************************************************* - template - crc64_ecma(TIterator begin, const TIterator end) - { - this->reset(); - this->add(begin, end); - } - }; + typedef crc64_poly_0x42f0e1eba9ea3693<0x0000000000000000U, 0x0000000000000000U, false> crc64_ecma; } #endif diff --git a/include/etl/crc8_ccitt.h b/include/etl/crc8_ccitt.h index 2dd17d1c..3c807f99 100644 --- a/include/etl/crc8_ccitt.h +++ b/include/etl/crc8_ccitt.h @@ -31,13 +31,8 @@ SOFTWARE. #ifndef ETL_CRC8_CCITT_INCLUDED #define ETL_CRC8_CCITT_INCLUDED -#include - #include "platform.h" -#include "frame_check_sequence.h" - -#include "stl/algorithm.h" -#include "stl/iterator.h" +#include "private/crc8_poly_0x07.h" #if defined(ETL_COMPILER_KEIL) #pragma diag_suppress 1300 @@ -48,77 +43,7 @@ SOFTWARE. namespace etl { - //*************************************************************************** - /// CRC8 CCITT policy. - /// Calculates CRC8 CCITT using polynomial 0x07. - //*************************************************************************** - struct crc_policy_8_ccitt - { - typedef uint8_t value_type; - - inline uint8_t initial() const - { - return 0; - } - - inline uint8_t add(uint8_t crc, uint8_t value) const - { - static const uint8_t CRC8_CCITT[256] = - { - 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15, 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D, - 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65, 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D, - 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5, 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD, - 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85, 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD, - 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2, 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA, - 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2, 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A, - 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32, 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A, - 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42, 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A, - 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C, 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4, - 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC, 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4, - 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C, 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44, - 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C, 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34, - 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B, 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63, - 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B, 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13, - 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB, 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83, - 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB, 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3 - }; - - return CRC8_CCITT[crc ^ value]; - } - - inline uint8_t final(uint8_t crc) const - { - return crc; - } - }; - - //************************************************************************* - /// CRC8 CCITT - //************************************************************************* - class crc8_ccitt : public etl::frame_check_sequence - { - public: - - //************************************************************************* - /// Default constructor. - //************************************************************************* - crc8_ccitt() - { - this->reset(); - } - - //************************************************************************* - /// Constructor from range. - /// \param begin Start of the range. - /// \param end End of the range. - //************************************************************************* - template - crc8_ccitt(TIterator begin, const TIterator end) - { - this->reset(); - this->add(begin, end); - } - }; + typedef crc8_poly_0x07<0x00U, 0x00U, false> crc8_ccitt; } #endif diff --git a/include/etl/crc8_rohc.h b/include/etl/crc8_rohc.h new file mode 100644 index 00000000..9fdede5d --- /dev/null +++ b/include/etl/crc8_rohc.h @@ -0,0 +1,49 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2019 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_CRC8_ROHC_INCLUDED +#define ETL_CRC8_ROHC_INCLUDED + +#include "platform.h" +#include "private/crc8_poly_0x07.h" + +#if defined(ETL_COMPILER_KEIL) +#pragma diag_suppress 1300 +#endif + +///\defgroup crc8_ccitt 8 bit CRC calculation +///\ingroup crc + +namespace etl +{ + typedef crc8_poly_0x07<0xFF, 0x00, true, true> crc8_rohc; +} + +#endif diff --git a/include/etl/private/crc16_poly_0x1021_.h b/include/etl/private/crc16_poly_0x1021_.h new file mode 100644 index 00000000..08cdcfab --- /dev/null +++ b/include/etl/private/crc16_poly_0x1021_.h @@ -0,0 +1,212 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2019 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_CRC16_POLY_0X1021_INCLUDED +#define ETL_CRC16_POLY_0X1021_INCLUDED + +#include + +#include "../platform.h" +#include "../frame_check_sequence.h" +#include "../binary.h" + +#include "../stl/iterator.h" + +#if defined(ETL_COMPILER_KEIL) +#pragma diag_suppress 1300 +#endif + +///\defgroup crc16_ccitt 16 bit CRC Poly 0x1021 calculation +///\ingroup crc + +namespace etl +{ + //*************************************************************************** + class crc16_table_poly_0x1021 + { + protected: + + crc16_table_poly_0x1021() + : table(get_table()) + { + } + + static const uint16_t * const get_table() + { + static const uint16_t table[256] = + { + 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, + 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, + 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, + 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, + 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, + 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, + 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, + 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, + 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, + 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, + 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, + 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, + 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, + 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, + 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, + 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 + }; + + return table; + } + + const uint16_t * const table; + }; + + //*************************************************************************** + class crc16_table_poly_0x1021_reflected + { + protected: + + crc16_table_poly_0x1021_reflected() + : table(get_table()) + { + } + + static const uint16_t * const get_table() + { + static const uint16_t table[256] = + { + 0x0000, 0x1189, 0x2312, 0x329B, 0x4624, 0x57AD, 0x6536, 0x74BF, 0x8C48, 0x9DC1, 0xAF5A, 0xBED3, 0xCA6C, 0xDBE5, 0xE97E, 0xF8F7, + 0x1081, 0x0108, 0x3393, 0x221A, 0x56A5, 0x472C, 0x75B7, 0x643E, 0x9CC9, 0x8D40, 0xBFDB, 0xAE52, 0xDAED, 0xCB64, 0xF9FF, 0xE876, + 0x2102, 0x308B, 0x0210, 0x1399, 0x6726, 0x76AF, 0x4434, 0x55BD, 0xAD4A, 0xBCC3, 0x8E58, 0x9FD1, 0xEB6E, 0xFAE7, 0xC87C, 0xD9F5, + 0x3183, 0x200A, 0x1291, 0x0318, 0x77A7, 0x662E, 0x54B5, 0x453C, 0xBDCB, 0xAC42, 0x9ED9, 0x8F50, 0xFBEF, 0xEA66, 0xD8FD, 0xC974, + 0x4204, 0x538D, 0x6116, 0x709F, 0x0420, 0x15A9, 0x2732, 0x36BB, 0xCE4C, 0xDFC5, 0xED5E, 0xFCD7, 0x8868, 0x99E1, 0xAB7A, 0xBAF3, + 0x5285, 0x430C, 0x7197, 0x601E, 0x14A1, 0x0528, 0x37B3, 0x263A, 0xDECD, 0xCF44, 0xFDDF, 0xEC56, 0x98E9, 0x8960, 0xBBFB, 0xAA72, + 0x6306, 0x728F, 0x4014, 0x519D, 0x2522, 0x34AB, 0x0630, 0x17B9, 0xEF4E, 0xFEC7, 0xCC5C, 0xDDD5, 0xA96A, 0xB8E3, 0x8A78, 0x9BF1, + 0x7387, 0x620E, 0x5095, 0x411C, 0x35A3, 0x242A, 0x16B1, 0x0738, 0xFFCF, 0xEE46, 0xDCDD, 0xCD54, 0xB9EB, 0xA862, 0x9AF9, 0x8B70, + 0x8408, 0x9581, 0xA71A, 0xB693, 0xC22C, 0xD3A5, 0xE13E, 0xF0B7, 0x0840, 0x19C9, 0x2B52, 0x3ADB, 0x4E64, 0x5FED, 0x6D76, 0x7CFF, + 0x9489, 0x8500, 0xB79B, 0xA612, 0xD2AD, 0xC324, 0xF1BF, 0xE036, 0x18C1, 0x0948, 0x3BD3, 0x2A5A, 0x5EE5, 0x4F6C, 0x7DF7, 0x6C7E, + 0xA50A, 0xB483, 0x8618, 0x9791, 0xE32E, 0xF2A7, 0xC03C, 0xD1B5, 0x2942, 0x38CB, 0x0A50, 0x1BD9, 0x6F66, 0x7EEF, 0x4C74, 0x5DFD, + 0xB58B, 0xA402, 0x9699, 0x8710, 0xF3AF, 0xE226, 0xD0BD, 0xC134, 0x39C3, 0x284A, 0x1AD1, 0x0B58, 0x7FE7, 0x6E6E, 0x5CF5, 0x4D7C, + 0xC60C, 0xD785, 0xE51E, 0xF497, 0x8028, 0x91A1, 0xA33A, 0xB2B3, 0x4A44, 0x5BCD, 0x6956, 0x78DF, 0x0C60, 0x1DE9, 0x2F72, 0x3EFB, + 0xD68D, 0xC704, 0xF59F, 0xE416, 0x90A9, 0x8120, 0xB3BB, 0xA232, 0x5AC5, 0x4B4C, 0x79D7, 0x685E, 0x1CE1, 0x0D68, 0x3FF3, 0x2E7A, + 0xE70E, 0xF687, 0xC41C, 0xD595, 0xA12A, 0xB0A3, 0x8238, 0x93B1, 0x6B46, 0x7ACF, 0x4854, 0x59DD, 0x2D62, 0x3CEB, 0x0E70, 0x1FF9, + 0xF78F, 0xE606, 0xD49D, 0xC514, 0xB1AB, 0xA022, 0x92B9, 0x8330, 0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78 + }; + + return table; + } + + const uint16_t * const table; + }; + + //*************************************************************************** + /// CRC16 Poly 0x1021 policy. + /// Calculates CRC16 using polynomial 0x1021 + //*************************************************************************** + template + struct crc16_policy_poly_0x1021 : public crc16_table_poly_0x1021 + { + typedef uint16_t value_type; + + //************************************************************************* + ETL_CONSTEXPR uint16_t initial() const + { + return INITIAL; + } + + //************************************************************************* + uint16_t add(uint16_t crc, uint8_t value) const + { + return (crc << 8) ^ table[((crc >> 8) ^ value) & 0xFF]; + } + + //************************************************************************* + inline uint16_t final(uint16_t crc) const + { + return crc ^ XOR_OUT; + } + }; + + //*************************************************************************** + /// CRC16 Poly 0x1021 reflected policy specialisation. + //*************************************************************************** + template + struct crc16_policy_poly_0x1021 : public crc16_table_poly_0x1021_reflected + { + typedef uint16_t value_type; + + //************************************************************************* + ETL_CONSTEXPR uint16_t initial() const + { + return INITIAL; + } + + //************************************************************************* + uint16_t add(uint16_t crc, uint8_t value) const + { + return (crc >> 8) ^ table[(crc ^ value) & 0xFF]; + } + + //************************************************************************* + uint16_t final(uint16_t crc) const + { + return crc ^ XOR_OUT; + } + }; + + //************************************************************************* + /// CRC16 Poly 0x1021 + //************************************************************************* + template + class crc16_poly_0x1021 : public etl::frame_check_sequence > + { + public: + + //************************************************************************* + /// Default constructor. + //************************************************************************* + crc16_poly_0x1021() + { + this->reset(); + } + + //************************************************************************* + /// Constructor from range. + /// \param begin Start of the range. + /// \param end End of the range. + //************************************************************************* + template + crc16_poly_0x1021(TIterator begin, const TIterator end) + { + this->reset(); + this->add(begin, end); + } + }; +} + +#endif diff --git a/include/etl/private/crc16_poly_0x8005.h b/include/etl/private/crc16_poly_0x8005.h new file mode 100644 index 00000000..44dfcf60 --- /dev/null +++ b/include/etl/private/crc16_poly_0x8005.h @@ -0,0 +1,212 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2018 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_CRC16_POLY_0X8005_INCLUDED +#define ETL_CRC16_POLY_0X8005_INCLUDED + +#include + +#include "../platform.h" +#include "../frame_check_sequence.h" +#include "../binary.h" + +#include "../stl/iterator.h" + +#if defined(ETL_COMPILER_KEIL) +#pragma diag_suppress 1300 +#endif + +///\defgroup crc16_ccitt 16 bit CRC Poly 0x8005 calculation +///\ingroup crc + +namespace etl +{ + //*************************************************************************** + class crc16_table_poly_0x8005 + { + protected: + + crc16_table_poly_0x8005() + : table(get_table()) + { + } + + static const uint16_t * const get_table() + { + static const uint16_t table[256] = + { + 0x0000, 0x8005, 0x800F, 0x000A, 0x801B, 0x001E, 0x0014, 0x8011, 0x8033, 0x0036, 0x003C, 0x8039, 0x0028, 0x802D, 0x8027, 0x0022, + 0x8063, 0x0066, 0x006C, 0x8069, 0x0078, 0x807D, 0x8077, 0x0072, 0x0050, 0x8055, 0x805F, 0x005A, 0x804B, 0x004E, 0x0044, 0x8041, + 0x80C3, 0x00C6, 0x00CC, 0x80C9, 0x00D8, 0x80DD, 0x80D7, 0x00D2, 0x00F0, 0x80F5, 0x80FF, 0x00FA, 0x80EB, 0x00EE, 0x00E4, 0x80E1, + 0x00A0, 0x80A5, 0x80AF, 0x00AA, 0x80BB, 0x00BE, 0x00B4, 0x80B1, 0x8093, 0x0096, 0x009C, 0x8099, 0x0088, 0x808D, 0x8087, 0x0082, + 0x8183, 0x0186, 0x018C, 0x8189, 0x0198, 0x819D, 0x8197, 0x0192, 0x01B0, 0x81B5, 0x81BF, 0x01BA, 0x81AB, 0x01AE, 0x01A4, 0x81A1, + 0x01E0, 0x81E5, 0x81EF, 0x01EA, 0x81FB, 0x01FE, 0x01F4, 0x81F1, 0x81D3, 0x01D6, 0x01DC, 0x81D9, 0x01C8, 0x81CD, 0x81C7, 0x01C2, + 0x0140, 0x8145, 0x814F, 0x014A, 0x815B, 0x015E, 0x0154, 0x8151, 0x8173, 0x0176, 0x017C, 0x8179, 0x0168, 0x816D, 0x8167, 0x0162, + 0x8123, 0x0126, 0x012C, 0x8129, 0x0138, 0x813D, 0x8137, 0x0132, 0x0110, 0x8115, 0x811F, 0x011A, 0x810B, 0x010E, 0x0104, 0x8101, + 0x8303, 0x0306, 0x030C, 0x8309, 0x0318, 0x831D, 0x8317, 0x0312, 0x0330, 0x8335, 0x833F, 0x033A, 0x832B, 0x032E, 0x0324, 0x8321, + 0x0360, 0x8365, 0x836F, 0x036A, 0x837B, 0x037E, 0x0374, 0x8371, 0x8353, 0x0356, 0x035C, 0x8359, 0x0348, 0x834D, 0x8347, 0x0342, + 0x03C0, 0x83C5, 0x83CF, 0x03CA, 0x83DB, 0x03DE, 0x03D4, 0x83D1, 0x83F3, 0x03F6, 0x03FC, 0x83F9, 0x03E8, 0x83ED, 0x83E7, 0x03E2, + 0x83A3, 0x03A6, 0x03AC, 0x83A9, 0x03B8, 0x83BD, 0x83B7, 0x03B2, 0x0390, 0x8395, 0x839F, 0x039A, 0x838B, 0x038E, 0x0384, 0x8381, + 0x0280, 0x8285, 0x828F, 0x028A, 0x829B, 0x029E, 0x0294, 0x8291, 0x82B3, 0x02B6, 0x02BC, 0x82B9, 0x02A8, 0x82AD, 0x82A7, 0x02A2, + 0x82E3, 0x02E6, 0x02EC, 0x82E9, 0x02F8, 0x82FD, 0x82F7, 0x02F2, 0x02D0, 0x82D5, 0x82DF, 0x02DA, 0x82CB, 0x02CE, 0x02C4, 0x82C1, + 0x8243, 0x0246, 0x024C, 0x8249, 0x0258, 0x825D, 0x8257, 0x0252, 0x0270, 0x8275, 0x827F, 0x027A, 0x826B, 0x026E, 0x0264, 0x8261, + 0x0220, 0x8225, 0x822F, 0x022A, 0x823B, 0x023E, 0x0234, 0x8231, 0x8213, 0x0216, 0x021C, 0x8219, 0x0208, 0x820D, 0x8207, 0x0202 + }; + + return table; + } + + const uint16_t * const table; + }; + + //*************************************************************************** + class crc16_table_poly_0x8005_reflected + { + protected: + + crc16_table_poly_0x8005_reflected() + : table(get_table()) + { + } + + static const uint16_t * const get_table() + { + static const uint16_t table[256] = + { + 0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, 0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440, + 0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40, 0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841, + 0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40, 0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41, + 0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641, 0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040, + 0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240, 0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441, + 0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41, 0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840, + 0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41, 0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40, + 0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640, 0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041, + 0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240, 0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441, + 0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41, 0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840, + 0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41, 0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40, + 0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640, 0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041, + 0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241, 0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440, + 0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40, 0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841, + 0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40, 0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41, + 0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641, 0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040 + }; + + return table; + } + + const uint16_t * const table; + }; + + //*************************************************************************** + /// CRC16 Poly 0x8005 policy. + /// Calculates CRC16 using polynomial 0x8005 + //*************************************************************************** + template + struct crc16_policy_poly_0x8005 : public crc16_table_poly_0x8005 + { + typedef uint16_t value_type; + + //************************************************************************* + ETL_CONSTEXPR uint16_t initial() const + { + return INITIAL; + } + + //************************************************************************* + uint16_t add(uint16_t crc, uint8_t value) const + { + return (crc << 8) ^ table[((crc >> 8) ^ value) & 0xFF]; + } + + //************************************************************************* + inline uint16_t final(uint16_t crc) const + { + return crc ^ XOR_OUT; + } + }; + + //*************************************************************************** + /// CRC16 Poly 0x8005 reflected policy. + //*************************************************************************** + template + struct crc16_policy_poly_0x8005< INITIAL, XOR_OUT, true> : public crc16_table_poly_0x8005_reflected + { + typedef uint16_t value_type; + + //************************************************************************* + ETL_CONSTEXPR uint16_t initial() const + { + return INITIAL; + } + + //************************************************************************* + uint16_t add(uint16_t crc, uint8_t value) const + { + return (crc >> 8) ^ table[(crc ^ value) & 0xFF]; + } + + //************************************************************************* + inline uint16_t final(uint16_t crc) const + { + return crc ^ XOR_OUT; + } + }; + + //************************************************************************* + /// CRC16 Poly 0x8005 + //************************************************************************* + template + class crc16_poly_0x8005 : public etl::frame_check_sequence > + { + public: + + //************************************************************************* + /// Default constructor. + //************************************************************************* + crc16_poly_0x8005() + { + this->reset(); + } + + //************************************************************************* + /// Constructor from range. + /// \param begin Start of the range. + /// \param end End of the range. + //************************************************************************* + template + crc16_poly_0x8005(TIterator begin, const TIterator end) + { + this->reset(); + this->add(begin, end); + } + }; +} + +#endif diff --git a/include/etl/private/crc32_poly_0x04c11db7.h b/include/etl/private/crc32_poly_0x04c11db7.h new file mode 100644 index 00000000..cdbdb5f3 --- /dev/null +++ b/include/etl/private/crc32_poly_0x04c11db7.h @@ -0,0 +1,212 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2018 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_CRC16_TABLE_POLY_0X04C11DB7_INCLUDED +#define ETL_CRC16_TABLE_POLY_0X04C11DB7_INCLUDED + +#include + +#include "../platform.h" +#include "../frame_check_sequence.h" +#include "../binary.h" + +#include "../stl/iterator.h" + +#if defined(ETL_COMPILER_KEIL) +#pragma diag_suppress 1300 +#endif + +///\defgroup crc32_poly 0x04C11DB7 32 bit CRC Poly 0x04C11DB7 calculation +///\ingroup crc + +namespace etl +{ + //*************************************************************************** + class crc32_table_poly_0x04c11db7 + { + protected: + + crc32_table_poly_0x04c11db7() + : table(get_table()) + { + } + + static const uint32_t * const get_table() + { + static const uint32_t table[256] = + { + 0x00000000, 0x04C11DB7, 0x09823B6E, 0x0D4326D9, 0x130476DC, 0x17C56B6B, 0x1A864DB2, 0x1E475005, 0x2608EDB8, 0x22C9F00F, 0x2F8AD6D6, 0x2B4BCB61, 0x350C9B64, 0x31CD86D3, 0x3C8EA00A, 0x384FBDBD, + 0x4C11DB70, 0x48D0C6C7, 0x4593E01E, 0x4152FDA9, 0x5F15ADAC, 0x5BD4B01B, 0x569796C2, 0x52568B75, 0x6A1936C8, 0x6ED82B7F, 0x639B0DA6, 0x675A1011, 0x791D4014, 0x7DDC5DA3, 0x709F7B7A, 0x745E66CD, + 0x9823B6E0, 0x9CE2AB57, 0x91A18D8E, 0x95609039, 0x8B27C03C, 0x8FE6DD8B, 0x82A5FB52, 0x8664E6E5, 0xBE2B5B58, 0xBAEA46EF, 0xB7A96036, 0xB3687D81, 0xAD2F2D84, 0xA9EE3033, 0xA4AD16EA, 0xA06C0B5D, + 0xD4326D90, 0xD0F37027, 0xDDB056FE, 0xD9714B49, 0xC7361B4C, 0xC3F706FB, 0xCEB42022, 0xCA753D95, 0xF23A8028, 0xF6FB9D9F, 0xFBB8BB46, 0xFF79A6F1, 0xE13EF6F4, 0xE5FFEB43, 0xE8BCCD9A, 0xEC7DD02D, + 0x34867077, 0x30476DC0, 0x3D044B19, 0x39C556AE, 0x278206AB, 0x23431B1C, 0x2E003DC5, 0x2AC12072, 0x128E9DCF, 0x164F8078, 0x1B0CA6A1, 0x1FCDBB16, 0x018AEB13, 0x054BF6A4, 0x0808D07D, 0x0CC9CDCA, + 0x7897AB07, 0x7C56B6B0, 0x71159069, 0x75D48DDE, 0x6B93DDDB, 0x6F52C06C, 0x6211E6B5, 0x66D0FB02, 0x5E9F46BF, 0x5A5E5B08, 0x571D7DD1, 0x53DC6066, 0x4D9B3063, 0x495A2DD4, 0x44190B0D, 0x40D816BA, + 0xACA5C697, 0xA864DB20, 0xA527FDF9, 0xA1E6E04E, 0xBFA1B04B, 0xBB60ADFC, 0xB6238B25, 0xB2E29692, 0x8AAD2B2F, 0x8E6C3698, 0x832F1041, 0x87EE0DF6, 0x99A95DF3, 0x9D684044, 0x902B669D, 0x94EA7B2A, + 0xE0B41DE7, 0xE4750050, 0xE9362689, 0xEDF73B3E, 0xF3B06B3B, 0xF771768C, 0xFA325055, 0xFEF34DE2, 0xC6BCF05F, 0xC27DEDE8, 0xCF3ECB31, 0xCBFFD686, 0xD5B88683, 0xD1799B34, 0xDC3ABDED, 0xD8FBA05A, + 0x690CE0EE, 0x6DCDFD59, 0x608EDB80, 0x644FC637, 0x7A089632, 0x7EC98B85, 0x738AAD5C, 0x774BB0EB, 0x4F040D56, 0x4BC510E1, 0x46863638, 0x42472B8F, 0x5C007B8A, 0x58C1663D, 0x558240E4, 0x51435D53, + 0x251D3B9E, 0x21DC2629, 0x2C9F00F0, 0x285E1D47, 0x36194D42, 0x32D850F5, 0x3F9B762C, 0x3B5A6B9B, 0x0315D626, 0x07D4CB91, 0x0A97ED48, 0x0E56F0FF, 0x1011A0FA, 0x14D0BD4D, 0x19939B94, 0x1D528623, + 0xF12F560E, 0xF5EE4BB9, 0xF8AD6D60, 0xFC6C70D7, 0xE22B20D2, 0xE6EA3D65, 0xEBA91BBC, 0xEF68060B, 0xD727BBB6, 0xD3E6A601, 0xDEA580D8, 0xDA649D6F, 0xC423CD6A, 0xC0E2D0DD, 0xCDA1F604, 0xC960EBB3, + 0xBD3E8D7E, 0xB9FF90C9, 0xB4BCB610, 0xB07DABA7, 0xAE3AFBA2, 0xAAFBE615, 0xA7B8C0CC, 0xA379DD7B, 0x9B3660C6, 0x9FF77D71, 0x92B45BA8, 0x9675461F, 0x8832161A, 0x8CF30BAD, 0x81B02D74, 0x857130C3, + 0x5D8A9099, 0x594B8D2E, 0x5408ABF7, 0x50C9B640, 0x4E8EE645, 0x4A4FFBF2, 0x470CDD2B, 0x43CDC09C, 0x7B827D21, 0x7F436096, 0x7200464F, 0x76C15BF8, 0x68860BFD, 0x6C47164A, 0x61043093, 0x65C52D24, + 0x119B4BE9, 0x155A565E, 0x18197087, 0x1CD86D30, 0x029F3D35, 0x065E2082, 0x0B1D065B, 0x0FDC1BEC, 0x3793A651, 0x3352BBE6, 0x3E119D3F, 0x3AD08088, 0x2497D08D, 0x2056CD3A, 0x2D15EBE3, 0x29D4F654, + 0xC5A92679, 0xC1683BCE, 0xCC2B1D17, 0xC8EA00A0, 0xD6AD50A5, 0xD26C4D12, 0xDF2F6BCB, 0xDBEE767C, 0xE3A1CBC1, 0xE760D676, 0xEA23F0AF, 0xEEE2ED18, 0xF0A5BD1D, 0xF464A0AA, 0xF9278673, 0xFDE69BC4, + 0x89B8FD09, 0x8D79E0BE, 0x803AC667, 0x84FBDBD0, 0x9ABC8BD5, 0x9E7D9662, 0x933EB0BB, 0x97FFAD0C, 0xAFB010B1, 0xAB710D06, 0xA6322BDF, 0xA2F33668, 0xBCB4666D, 0xB8757BDA, 0xB5365D03, 0xB1F740B4 + }; + + return table; + } + + const uint32_t * const table; + }; + + //*************************************************************************** + class crc32_table_poly_0x04c11db7_reflected + { + protected: + + crc32_table_poly_0x04c11db7_reflected() + : table(get_table()) + { + } + + static const uint32_t * const get_table() + { + static const uint32_t table[256] = + { + 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, + 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, + 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, + 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, + 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, + 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, + 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, + 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, + 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, + 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, + 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, + 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, + 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, + 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, + 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, + 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D + }; + + return table; + } + + const uint32_t * const table; + }; + + //*************************************************************************** + /// CRC32 Poly 0x04C11DB7 policy. + /// Calculates CRC32 using polynomial 0x04C11DB7 + //*************************************************************************** + template + struct crc32_policy_poly_0x04c11db7 : public crc32_table_poly_0x04c11db7 + { + typedef uint32_t value_type; + + //************************************************************************* + ETL_CONSTEXPR uint32_t initial() const + { + return INITIAL; + } + + //************************************************************************* + uint32_t add(uint32_t crc, uint8_t value) const + { + return (crc << 8) ^ table[((crc >> 24) ^ value) & 0xFF]; + } + + //************************************************************************* + uint32_t final(uint32_t crc) const + { + return crc ^ XOR_OUT; + } + }; + + //*************************************************************************** + /// CRC32 Poly 0x04C11DB7 reflected policy specialisation. + //*************************************************************************** + template + struct crc32_policy_poly_0x04c11db7 : public crc32_table_poly_0x04c11db7_reflected + { + typedef uint32_t value_type; + + //************************************************************************* + ETL_CONSTEXPR uint32_t initial() const + { + return INITIAL; + } + + //************************************************************************* + uint32_t add(uint32_t crc, uint8_t value) const + { + return (crc >> 8) ^ table[(crc ^ value) & 0xFF]; + } + + //************************************************************************* + uint32_t final(uint32_t crc) const + { + return crc ^ XOR_OUT; + } + }; + + //************************************************************************* + /// CRC32 Poly 0x04C11DB7 + //************************************************************************* + template + class crc32_poly_0x04c11db7 : public etl::frame_check_sequence > + { + public: + + //************************************************************************* + /// Default constructor. + //************************************************************************* + crc32_poly_0x04c11db7() + { + this->reset(); + } + + //************************************************************************* + /// Constructor from range. + /// \param begin Start of the range. + /// \param end End of the range. + //************************************************************************* + template + crc32_poly_0x04c11db7(TIterator begin, const TIterator end) + { + this->reset(); + this->add(begin, end); + } + }; +} + +#endif diff --git a/include/etl/private/crc32_poly_0x1edc6f41.h b/include/etl/private/crc32_poly_0x1edc6f41.h new file mode 100644 index 00000000..51c6e323 --- /dev/null +++ b/include/etl/private/crc32_poly_0x1edc6f41.h @@ -0,0 +1,212 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2019 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_CRC16_TABLE_POLY_0X1EDC6F41_INCLUDED +#define ETL_CRC16_TABLE_POLY_0X1EDC6F41_INCLUDED + +#include + +#include "../platform.h" +#include "../frame_check_sequence.h" +#include "../binary.h" + +#include "../stl/iterator.h" + +#if defined(ETL_COMPILER_KEIL) +#pragma diag_suppress 1300 +#endif + +///\defgroup crc32_poly 0x1EDC6F41 32 bit CRC Poly 0x1EDC6F41 calculation +///\ingroup crc + +namespace etl +{ + //*************************************************************************** + class crc32_table_poly_0x1edc6f41 + { + protected: + + crc32_table_poly_0x1edc6f41() + : table(get_table()) + { + } + + static const uint32_t * const get_table() + { + static const uint32_t table[256] = + { + 0x00000000, 0xC0C1D64F, 0xEF0EDC87, 0x2FCF0AC8, 0xF8E959E3, 0x38288FAC, 0x17E78564, 0xD726532B, 0xF31A9B51, 0x33DB4D1E, 0x1C1447D6, 0xDCD59199, 0x0BF3C2B2, 0xCB3214FD, 0xE4FD1E35, 0x243CC87A, + 0xF6E37A08, 0x3622AC47, 0x19EDA68F, 0xD92C70C0, 0x0E0A23EB, 0xCECBF5A4, 0xE104FF6C, 0x21C52923, 0x05F9E159, 0xC5383716, 0xEAF73DDE, 0x2A36EB91, 0xFD10B8BA, 0x3DD16EF5, 0x121E643D, 0xD2DFB272, + 0x7B71BD04, 0xBBB06B4B, 0x947F6183, 0x54BEB7CC, 0x8398E4E7, 0x435932A8, 0x6C963860, 0xAC57EE2F, 0x886B2655, 0x48AAF01A, 0x6765FAD2, 0xA7A42C9D, 0x70827FB6, 0xB043A9F9, 0x9F8CA331, 0x5F4D757E, + 0x8D92C70C, 0x4D531143, 0x629C1B8B, 0xA25DCDC4, 0x757B9EEF, 0xB5BA48A0, 0x9A754268, 0x5AB49427, 0x7E885C5D, 0xBE498A12, 0x918680DA, 0x51475695, 0x866105BE, 0x46A0D3F1, 0x696FD939, 0xA9AE0F76, + 0x3DB8DE82, 0xFD7908CD, 0xD2B60205, 0x1277D44A, 0xC5518761, 0x0590512E, 0x2A5F5BE6, 0xEA9E8DA9, 0xCEA245D3, 0x0E63939C, 0x21AC9954, 0xE16D4F1B, 0x364B1C30, 0xF68ACA7F, 0xD945C0B7, 0x198416F8, + 0xCB5BA48A, 0x0B9A72C5, 0x2455780D, 0xE494AE42, 0x33B2FD69, 0xF3732B26, 0xDCBC21EE, 0x1C7DF7A1, 0x38413FDB, 0xF880E994, 0xD74FE35C, 0x178E3513, 0xC0A86638, 0x0069B077, 0x2FA6BABF, 0xEF676CF0, + 0x46C96386, 0x8608B5C9, 0xA9C7BF01, 0x6906694E, 0xBE203A65, 0x7EE1EC2A, 0x512EE6E2, 0x91EF30AD, 0xB5D3F8D7, 0x75122E98, 0x5ADD2450, 0x9A1CF21F, 0x4D3AA134, 0x8DFB777B, 0xA2347DB3, 0x62F5ABFC, + 0xB02A198E, 0x70EBCFC1, 0x5F24C509, 0x9FE51346, 0x48C3406D, 0x88029622, 0xA7CD9CEA, 0x670C4AA5, 0x433082DF, 0x83F15490, 0xAC3E5E58, 0x6CFF8817, 0xBBD9DB3C, 0x7B180D73, 0x54D707BB, 0x9416D1F4, + 0x1EDC6F41, 0xDE1DB90E, 0xF1D2B3C6, 0x31136589, 0xE63536A2, 0x26F4E0ED, 0x093BEA25, 0xC9FA3C6A, 0xEDC6F410, 0x2D07225F, 0x02C82897, 0xC209FED8, 0x152FADF3, 0xD5EE7BBC, 0xFA217174, 0x3AE0A73B, + 0xE83F1549, 0x28FEC306, 0x0731C9CE, 0xC7F01F81, 0x10D64CAA, 0xD0179AE5, 0xFFD8902D, 0x3F194662, 0x1B258E18, 0xDBE45857, 0xF42B529F, 0x34EA84D0, 0xE3CCD7FB, 0x230D01B4, 0x0CC20B7C, 0xCC03DD33, + 0x65ADD245, 0xA56C040A, 0x8AA30EC2, 0x4A62D88D, 0x9D448BA6, 0x5D855DE9, 0x724A5721, 0xB28B816E, 0x96B74914, 0x56769F5B, 0x79B99593, 0xB97843DC, 0x6E5E10F7, 0xAE9FC6B8, 0x8150CC70, 0x41911A3F, + 0x934EA84D, 0x538F7E02, 0x7C4074CA, 0xBC81A285, 0x6BA7F1AE, 0xAB6627E1, 0x84A92D29, 0x4468FB66, 0x6054331C, 0xA095E553, 0x8F5AEF9B, 0x4F9B39D4, 0x98BD6AFF, 0x587CBCB0, 0x77B3B678, 0xB7726037, + 0x2364B1C3, 0xE3A5678C, 0xCC6A6D44, 0x0CABBB0B, 0xDB8DE820, 0x1B4C3E6F, 0x348334A7, 0xF442E2E8, 0xD07E2A92, 0x10BFFCDD, 0x3F70F615, 0xFFB1205A, 0x28977371, 0xE856A53E, 0xC799AFF6, 0x075879B9, + 0xD587CBCB, 0x15461D84, 0x3A89174C, 0xFA48C103, 0x2D6E9228, 0xEDAF4467, 0xC2604EAF, 0x02A198E0, 0x269D509A, 0xE65C86D5, 0xC9938C1D, 0x09525A52, 0xDE740979, 0x1EB5DF36, 0x317AD5FE, 0xF1BB03B1, + 0x58150CC7, 0x98D4DA88, 0xB71BD040, 0x77DA060F, 0xA0FC5524, 0x603D836B, 0x4FF289A3, 0x8F335FEC, 0xAB0F9796, 0x6BCE41D9, 0x44014B11, 0x84C09D5E, 0x53E6CE75, 0x9327183A, 0xBCE812F2, 0x7C29C4BD, + 0xAEF676CF, 0x6E37A080, 0x41F8AA48, 0x81397C07, 0x561F2F2C, 0x96DEF963, 0xB911F3AB, 0x79D025E4, 0x5DECED9E, 0x9D2D3BD1, 0xB2E23119, 0x7223E756, 0xA505B47D, 0x65C46232, 0x4A0B68FA, 0x8ACABEB5 + }; + + return table; + } + + const uint32_t * const table; + }; + + //*************************************************************************** + class crc32_table_poly_0x1edc6f41_reflected + { + protected: + + crc32_table_poly_0x1edc6f41_reflected() + : table(get_table()) + { + } + + static const uint32_t * const get_table() + { + static const uint32_t table[256] = + { + 0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4, 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB, 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B, 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24, + 0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B, 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384, 0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54, 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B, + 0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A, 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35, 0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5, 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA, + 0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45, 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A, 0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A, 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595, + 0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48, 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957, 0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687, 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198, + 0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927, 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38, 0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8, 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7, + 0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096, 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789, 0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859, 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46, + 0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9, 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6, 0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36, 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829, + 0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C, 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93, 0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043, 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C, + 0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3, 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC, 0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C, 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033, + 0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652, 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D, 0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D, 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982, + 0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D, 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622, 0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2, 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED, + 0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530, 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F, 0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF, 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0, + 0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F, 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540, 0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90, 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F, + 0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE, 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1, 0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321, 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E, + 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81, 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E, 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E, 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351 + }; + + return table; + } + + const uint32_t * const table; + }; + + //*************************************************************************** + /// CRC32 Poly 0x1EDC6F41 policy. + /// Calculates CRC32 using polynomial 0x1EDC6F41 + //*************************************************************************** + template + struct crc32_policy_poly_0x1edc6f41 : public crc32_table_poly_0x1edc6f41 + { + typedef uint32_t value_type; + + //************************************************************************* + ETL_CONSTEXPR uint32_t initial() const + { + return INITIAL; + } + + //************************************************************************* + uint32_t add(uint32_t crc, uint8_t value) const + { + return (crc << 8) ^ table[((crc >> 24) ^ value) & 0xFF]; + } + + //************************************************************************* + uint32_t final(uint32_t crc) const + { + return crc ^ XOR_OUT; + } + }; + + //*************************************************************************** + /// CRC32 Poly 0x1EDC6F41 reflected policy specialisation. + //*************************************************************************** + template + struct crc32_policy_poly_0x1edc6f41 : public crc32_table_poly_0x1edc6f41_reflected + { + typedef uint32_t value_type; + + //************************************************************************* + ETL_CONSTEXPR uint32_t initial() const + { + return INITIAL; + } + + //************************************************************************* + uint32_t add(uint32_t crc, uint8_t value) const + { + return (crc >> 8) ^ table[(crc ^ value) & 0xFF]; + } + + //************************************************************************* + uint32_t final(uint32_t crc) const + { + return crc ^ XOR_OUT; + } + }; + + //************************************************************************* + /// CRC32 Poly 0x1EDC6F41 + //************************************************************************* + template + class crc32_poly_0x1edc6f41 : public etl::frame_check_sequence > + { + public: + + //************************************************************************* + /// Default constructor. + //************************************************************************* + crc32_poly_0x1edc6f41() + { + this->reset(); + } + + //************************************************************************* + /// Constructor from range. + /// \param begin Start of the range. + /// \param end End of the range. + //************************************************************************* + template + crc32_poly_0x1edc6f41(TIterator begin, const TIterator end) + { + this->reset(); + this->add(begin, end); + } + }; +} + +#endif diff --git a/include/etl/private/crc64_poly_0x42f0e1eba9ea3693.h b/include/etl/private/crc64_poly_0x42f0e1eba9ea3693.h new file mode 100644 index 00000000..c1760ddd --- /dev/null +++ b/include/etl/private/crc64_poly_0x42f0e1eba9ea3693.h @@ -0,0 +1,242 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2019 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_CRC16_TABLE_POLY_0X42F0E1EBA9EA3693_INCLUDED +#define ETL_CRC16_TABLE_POLY_0X42F0E1EBA9EA3693_INCLUDED + +#include + +#include "../platform.h" +#include "../frame_check_sequence.h" +#include "../binary.h" + +#include "../stl/iterator.h" + +#if defined(ETL_COMPILER_KEIL) +#pragma diag_suppress 1300 +#endif + +///\defgroup crc64_poly 0x42F0E1EBA9EA3693 64 bit CRC Poly 0x42F0E1EBA9EA3693 calculation +///\ingroup crc + +namespace etl +{ + //*************************************************************************** + class crc64_table_poly_0x42f0e1eba9ea3693 + { + protected: + + crc64_table_poly_0x42f0e1eba9ea3693() + : table(get_table()) + { + } + + static const uint64_t * const get_table() + { + static const uint64_t table[256] = + { + 0x0000000000000000, 0x42F0E1EBA9EA3693, 0x85E1C3D753D46D26, 0xC711223CFA3E5BB5, 0x493366450E42ECDF, 0x0BC387AEA7A8DA4C, 0xCCD2A5925D9681F9, 0x8E224479F47CB76A, + 0x9266CC8A1C85D9BE, 0xD0962D61B56FEF2D, 0x17870F5D4F51B498, 0x5577EEB6E6BB820B, 0xDB55AACF12C73561, 0x99A54B24BB2D03F2, 0x5EB4691841135847, 0x1C4488F3E8F96ED4, + 0x663D78FF90E185EF, 0x24CD9914390BB37C, 0xE3DCBB28C335E8C9, 0xA12C5AC36ADFDE5A, 0x2F0E1EBA9EA36930, 0x6DFEFF5137495FA3, 0xAAEFDD6DCD770416, 0xE81F3C86649D3285, + 0xF45BB4758C645C51, 0xB6AB559E258E6AC2, 0x71BA77A2DFB03177, 0x334A9649765A07E4, 0xBD68D2308226B08E, 0xFF9833DB2BCC861D, 0x388911E7D1F2DDA8, 0x7A79F00C7818EB3B, + 0xCC7AF1FF21C30BDE, 0x8E8A101488293D4D, 0x499B3228721766F8, 0x0B6BD3C3DBFD506B, 0x854997BA2F81E701, 0xC7B97651866BD192, 0x00A8546D7C558A27, 0x4258B586D5BFBCB4, + 0x5E1C3D753D46D260, 0x1CECDC9E94ACE4F3, 0xDBFDFEA26E92BF46, 0x990D1F49C77889D5, 0x172F5B3033043EBF, 0x55DFBADB9AEE082C, 0x92CE98E760D05399, 0xD03E790CC93A650A, + 0xAA478900B1228E31, 0xE8B768EB18C8B8A2, 0x2FA64AD7E2F6E317, 0x6D56AB3C4B1CD584, 0xE374EF45BF6062EE, 0xA1840EAE168A547D, 0x66952C92ECB40FC8, 0x2465CD79455E395B, + 0x3821458AADA7578F, 0x7AD1A461044D611C, 0xBDC0865DFE733AA9, 0xFF3067B657990C3A, 0x711223CFA3E5BB50, 0x33E2C2240A0F8DC3, 0xF4F3E018F031D676, 0xB60301F359DBE0E5, + 0xDA050215EA6C212F, 0x98F5E3FE438617BC, 0x5FE4C1C2B9B84C09, 0x1D14202910527A9A, 0x93366450E42ECDF0, 0xD1C685BB4DC4FB63, 0x16D7A787B7FAA0D6, 0x5427466C1E109645, + 0x4863CE9FF6E9F891, 0x0A932F745F03CE02, 0xCD820D48A53D95B7, 0x8F72ECA30CD7A324, 0x0150A8DAF8AB144E, 0x43A04931514122DD, 0x84B16B0DAB7F7968, 0xC6418AE602954FFB, + 0xBC387AEA7A8DA4C0, 0xFEC89B01D3679253, 0x39D9B93D2959C9E6, 0x7B2958D680B3FF75, 0xF50B1CAF74CF481F, 0xB7FBFD44DD257E8C, 0x70EADF78271B2539, 0x321A3E938EF113AA, + 0x2E5EB66066087D7E, 0x6CAE578BCFE24BED, 0xABBF75B735DC1058, 0xE94F945C9C3626CB, 0x676DD025684A91A1, 0x259D31CEC1A0A732, 0xE28C13F23B9EFC87, 0xA07CF2199274CA14, + 0x167FF3EACBAF2AF1, 0x548F120162451C62, 0x939E303D987B47D7, 0xD16ED1D631917144, 0x5F4C95AFC5EDC62E, 0x1DBC74446C07F0BD, 0xDAAD56789639AB08, 0x985DB7933FD39D9B, + 0x84193F60D72AF34F, 0xC6E9DE8B7EC0C5DC, 0x01F8FCB784FE9E69, 0x43081D5C2D14A8FA, 0xCD2A5925D9681F90, 0x8FDAB8CE70822903, 0x48CB9AF28ABC72B6, 0x0A3B7B1923564425, + 0x70428B155B4EAF1E, 0x32B26AFEF2A4998D, 0xF5A348C2089AC238, 0xB753A929A170F4AB, 0x3971ED50550C43C1, 0x7B810CBBFCE67552, 0xBC902E8706D82EE7, 0xFE60CF6CAF321874, + 0xE224479F47CB76A0, 0xA0D4A674EE214033, 0x67C58448141F1B86, 0x253565A3BDF52D15, 0xAB1721DA49899A7F, 0xE9E7C031E063ACEC, 0x2EF6E20D1A5DF759, 0x6C0603E6B3B7C1CA, + 0xF6FAE5C07D3274CD, 0xB40A042BD4D8425E, 0x731B26172EE619EB, 0x31EBC7FC870C2F78, 0xBFC9838573709812, 0xFD39626EDA9AAE81, 0x3A28405220A4F534, 0x78D8A1B9894EC3A7, + 0x649C294A61B7AD73, 0x266CC8A1C85D9BE0, 0xE17DEA9D3263C055, 0xA38D0B769B89F6C6, 0x2DAF4F0F6FF541AC, 0x6F5FAEE4C61F773F, 0xA84E8CD83C212C8A, 0xEABE6D3395CB1A19, + 0x90C79D3FEDD3F122, 0xD2377CD44439C7B1, 0x15265EE8BE079C04, 0x57D6BF0317EDAA97, 0xD9F4FB7AE3911DFD, 0x9B041A914A7B2B6E, 0x5C1538ADB04570DB, 0x1EE5D94619AF4648, + 0x02A151B5F156289C, 0x4051B05E58BC1E0F, 0x87409262A28245BA, 0xC5B073890B687329, 0x4B9237F0FF14C443, 0x0962D61B56FEF2D0, 0xCE73F427ACC0A965, 0x8C8315CC052A9FF6, + 0x3A80143F5CF17F13, 0x7870F5D4F51B4980, 0xBF61D7E80F251235, 0xFD913603A6CF24A6, 0x73B3727A52B393CC, 0x31439391FB59A55F, 0xF652B1AD0167FEEA, 0xB4A25046A88DC879, + 0xA8E6D8B54074A6AD, 0xEA16395EE99E903E, 0x2D071B6213A0CB8B, 0x6FF7FA89BA4AFD18, 0xE1D5BEF04E364A72, 0xA3255F1BE7DC7CE1, 0x64347D271DE22754, 0x26C49CCCB40811C7, + 0x5CBD6CC0CC10FAFC, 0x1E4D8D2B65FACC6F, 0xD95CAF179FC497DA, 0x9BAC4EFC362EA149, 0x158E0A85C2521623, 0x577EEB6E6BB820B0, 0x906FC95291867B05, 0xD29F28B9386C4D96, + 0xCEDBA04AD0952342, 0x8C2B41A1797F15D1, 0x4B3A639D83414E64, 0x09CA82762AAB78F7, 0x87E8C60FDED7CF9D, 0xC51827E4773DF90E, 0x020905D88D03A2BB, 0x40F9E43324E99428, + 0x2CFFE7D5975E55E2, 0x6E0F063E3EB46371, 0xA91E2402C48A38C4, 0xEBEEC5E96D600E57, 0x65CC8190991CB93D, 0x273C607B30F68FAE, 0xE02D4247CAC8D41B, 0xA2DDA3AC6322E288, + 0xBE992B5F8BDB8C5C, 0xFC69CAB42231BACF, 0x3B78E888D80FE17A, 0x7988096371E5D7E9, 0xF7AA4D1A85996083, 0xB55AACF12C735610, 0x724B8ECDD64D0DA5, 0x30BB6F267FA73B36, + 0x4AC29F2A07BFD00D, 0x08327EC1AE55E69E, 0xCF235CFD546BBD2B, 0x8DD3BD16FD818BB8, 0x03F1F96F09FD3CD2, 0x41011884A0170A41, 0x86103AB85A2951F4, 0xC4E0DB53F3C36767, + 0xD8A453A01B3A09B3, 0x9A54B24BB2D03F20, 0x5D45907748EE6495, 0x1FB5719CE1045206, 0x919735E51578E56C, 0xD367D40EBC92D3FF, 0x1476F63246AC884A, 0x568617D9EF46BED9, + 0xE085162AB69D5E3C, 0xA275F7C11F7768AF, 0x6564D5FDE549331A, 0x279434164CA30589, 0xA9B6706FB8DFB2E3, 0xEB46918411358470, 0x2C57B3B8EB0BDFC5, 0x6EA7525342E1E956, + 0x72E3DAA0AA188782, 0x30133B4B03F2B111, 0xF7021977F9CCEAA4, 0xB5F2F89C5026DC37, 0x3BD0BCE5A45A6B5D, 0x79205D0E0DB05DCE, 0xBE317F32F78E067B, 0xFCC19ED95E6430E8, + 0x86B86ED5267CDBD3, 0xC4488F3E8F96ED40, 0x0359AD0275A8B6F5, 0x41A94CE9DC428066, 0xCF8B0890283E370C, 0x8D7BE97B81D4019F, 0x4A6ACB477BEA5A2A, 0x089A2AACD2006CB9, + 0x14DEA25F3AF9026D, 0x562E43B4931334FE, 0x913F6188692D6F4B, 0xD3CF8063C0C759D8, 0x5DEDC41A34BBEEB2, 0x1F1D25F19D51D821, 0xD80C07CD676F8394, 0x9AFCE626CE85B507 + }; + + return table; + } + + const uint64_t * const table; + }; + + //*************************************************************************** + class crc64_table_poly_0x42f0e1eba9ea3693_reflected + { + crc64_table_poly_0x42f0e1eba9ea3693_reflected() + : table(get_table()) + { + } + + static const uint64_t * const get_table() + { + static const uint64_t table[256] = + { + 0x0000000000000000, 0xC96C5795D7870F42, 0x64B62BCAEBC387A1, 0xADDA7C5F3C4488E3, 0xFB374270A266CC92, 0x325B15E575E1C3D0, 0x9F8169BA49A54B33, 0x56ED3E2F9E224471, + 0x7D9BA13851336649, 0xB4F7F6AD86B4690B, 0x192D8AF2BAF0E1E8, 0xD041DD676D77EEAA, 0x86ACE348F355AADB, 0x4FC0B4DD24D2A599, 0xE21AC88218962D7A, 0x2B769F17CF112238, + 0xF7A18709FF1EBC66, 0x3ECDD09C2899B324, 0x9317ACC314DD3BC7, 0x5A7BFB56C35A3485, 0x0C96C5795D7870F4, 0xC5FA92EC8AFF7FB6, 0x6820EEB3B6BBF755, 0xA14CB926613CF817, + 0x8A3A2631AE2DDA2F, 0x435671A479AAD56D, 0xEE8C0DFB45EE5D8E, 0x27E05A6E926952CC, 0x710D64410C4B16BD, 0xB86133D4DBCC19FF, 0x15BB4F8BE788911C, 0xDCD7181E300F9E5E, + 0x7BD0C384FF8F5E33, 0xB2BC941128085171, 0x1F66E84E144CD992, 0xD60ABFDBC3CBD6D0, 0x80E781F45DE992A1, 0x498BD6618A6E9DE3, 0xE451AA3EB62A1500, 0x2D3DFDAB61AD1A42, + 0x064B62BCAEBC387A, 0xCF273529793B3738, 0x62FD4976457FBFDB, 0xAB911EE392F8B099, 0xFD7C20CC0CDAF4E8, 0x34107759DB5DFBAA, 0x99CA0B06E7197349, 0x50A65C93309E7C0B, + 0x8C71448D0091E255, 0x451D1318D716ED17, 0xE8C76F47EB5265F4, 0x21AB38D23CD56AB6, 0x774606FDA2F72EC7, 0xBE2A516875702185, 0x13F02D374934A966, 0xDA9C7AA29EB3A624, + 0xF1EAE5B551A2841C, 0x3886B22086258B5E, 0x955CCE7FBA6103BD, 0x5C3099EA6DE60CFF, 0x0ADDA7C5F3C4488E, 0xC3B1F050244347CC, 0x6E6B8C0F1807CF2F, 0xA707DB9ACF80C06D, + 0xF4843657A840A05B, 0x3DE861C27FC7AF19, 0x90321D9D438327FA, 0x595E4A08940428B8, 0x0FB374270A266CC9, 0xC6DF23B2DDA1638B, 0x6B055FEDE1E5EB68, 0xA26908783662E42A, + 0x891F976FF973C612, 0x4073C0FA2EF4C950, 0xEDA9BCA512B041B3, 0x24C5EB30C5374EF1, 0x7228D51F5B150A80, 0xBB44828A8C9205C2, 0x169EFED5B0D68D21, 0xDFF2A94067518263, + 0x0325B15E575E1C3D, 0xCA49E6CB80D9137F, 0x67939A94BC9D9B9C, 0xAEFFCD016B1A94DE, 0xF812F32EF538D0AF, 0x317EA4BB22BFDFED, 0x9CA4D8E41EFB570E, 0x55C88F71C97C584C, + 0x7EBE1066066D7A74, 0xB7D247F3D1EA7536, 0x1A083BACEDAEFDD5, 0xD3646C393A29F297, 0x85895216A40BB6E6, 0x4CE50583738CB9A4, 0xE13F79DC4FC83147, 0x28532E49984F3E05, + 0x8F54F5D357CFFE68, 0x4638A2468048F12A, 0xEBE2DE19BC0C79C9, 0x228E898C6B8B768B, 0x7463B7A3F5A932FA, 0xBD0FE036222E3DB8, 0x10D59C691E6AB55B, 0xD9B9CBFCC9EDBA19, + 0xF2CF54EB06FC9821, 0x3BA3037ED17B9763, 0x96797F21ED3F1F80, 0x5F1528B43AB810C2, 0x09F8169BA49A54B3, 0xC094410E731D5BF1, 0x6D4E3D514F59D312, 0xA4226AC498DEDC50, + 0x78F572DAA8D1420E, 0xB199254F7F564D4C, 0x1C4359104312C5AF, 0xD52F0E859495CAED, 0x83C230AA0AB78E9C, 0x4AAE673FDD3081DE, 0xE7741B60E174093D, 0x2E184CF536F3067F, + 0x056ED3E2F9E22447, 0xCC0284772E652B05, 0x61D8F8281221A3E6, 0xA8B4AFBDC5A6ACA4, 0xFE5991925B84E8D5, 0x3735C6078C03E797, 0x9AEFBA58B0476F74, 0x5383EDCD67C06036, + 0xB32E4CBE03A75F6F, 0x7A421B2BD420502D, 0xD7986774E864D8CE, 0x1EF430E13FE3D78C, 0x48190ECEA1C193FD, 0x8175595B76469CBF, 0x2CAF25044A02145C, 0xE5C372919D851B1E, + 0xCEB5ED8652943926, 0x07D9BA1385133664, 0xAA03C64CB957BE87, 0x636F91D96ED0B1C5, 0x3582AFF6F0F2F5B4, 0xFCEEF8632775FAF6, 0x5134843C1B317215, 0x9858D3A9CCB67D57, + 0x448FCBB7FCB9E309, 0x8DE39C222B3EEC4B, 0x2039E07D177A64A8, 0xE955B7E8C0FD6BEA, 0xBFB889C75EDF2F9B, 0x76D4DE52895820D9, 0xDB0EA20DB51CA83A, 0x1262F598629BA778, + 0x39146A8FAD8A8540, 0xF0783D1A7A0D8A02, 0x5DA24145464902E1, 0x94CE16D091CE0DA3, 0xC22328FF0FEC49D2, 0x0B4F7F6AD86B4690, 0xA6950335E42FCE73, 0x6FF954A033A8C131, + 0xC8FE8F3AFC28015C, 0x0192D8AF2BAF0E1E, 0xAC48A4F017EB86FD, 0x6524F365C06C89BF, 0x33C9CD4A5E4ECDCE, 0xFAA59ADF89C9C28C, 0x577FE680B58D4A6F, 0x9E13B115620A452D, + 0xB5652E02AD1B6715, 0x7C0979977A9C6857, 0xD1D305C846D8E0B4, 0x18BF525D915FEFF6, 0x4E526C720F7DAB87, 0x873E3BE7D8FAA4C5, 0x2AE447B8E4BE2C26, 0xE388102D33392364, + 0x3F5F08330336BD3A, 0xF6335FA6D4B1B278, 0x5BE923F9E8F53A9B, 0x9285746C3F7235D9, 0xC4684A43A15071A8, 0x0D041DD676D77EEA, 0xA0DE61894A93F609, 0x69B2361C9D14F94B, + 0x42C4A90B5205DB73, 0x8BA8FE9E8582D431, 0x267282C1B9C65CD2, 0xEF1ED5546E415390, 0xB9F3EB7BF06317E1, 0x709FBCEE27E418A3, 0xDD45C0B11BA09040, 0x14299724CC279F02, + 0x47AA7AE9ABE7FF34, 0x8EC62D7C7C60F076, 0x231C512340247895, 0xEA7006B697A377D7, 0xBC9D3899098133A6, 0x75F16F0CDE063CE4, 0xD82B1353E242B407, 0x114744C635C5BB45, + 0x3A31DBD1FAD4997D, 0xF35D8C442D53963F, 0x5E87F01B11171EDC, 0x97EBA78EC690119E, 0xC10699A158B255EF, 0x086ACE348F355AAD, 0xA5B0B26BB371D24E, 0x6CDCE5FE64F6DD0C, + 0xB00BFDE054F94352, 0x7967AA75837E4C10, 0xD4BDD62ABF3AC4F3, 0x1DD181BF68BDCBB1, 0x4B3CBF90F69F8FC0, 0x8250E80521188082, 0x2F8A945A1D5C0861, 0xE6E6C3CFCADB0723, + 0xCD905CD805CA251B, 0x04FC0B4DD24D2A59, 0xA9267712EE09A2BA, 0x604A2087398EADF8, 0x36A71EA8A7ACE989, 0xFFCB493D702BE6CB, 0x521135624C6F6E28, 0x9B7D62F79BE8616A, + 0x3C7AB96D5468A107, 0xF516EEF883EFAE45, 0x58CC92A7BFAB26A6, 0x91A0C532682C29E4, 0xC74DFB1DF60E6D95, 0x0E21AC88218962D7, 0xA3FBD0D71DCDEA34, 0x6A978742CA4AE576, + 0x41E11855055BC74E, 0x888D4FC0D2DCC80C, 0x2557339FEE9840EF, 0xEC3B640A391F4FAD, 0xBAD65A25A73D0BDC, 0x73BA0DB070BA049E, 0xDE6071EF4CFE8C7D, 0x170C267A9B79833F, + 0xCBDB3E64AB761D61, 0x02B769F17CF11223, 0xAF6D15AE40B59AC0, 0x6601423B97329582, 0x30EC7C140910D1F3, 0xF9802B81DE97DEB1, 0x545A57DEE2D35652, 0x9D36004B35545910, + 0xB6409F5CFA457B28, 0x7F2CC8C92DC2746A, 0xD2F6B4961186FC89, 0x1B9AE303C601F3CB, 0x4D77DD2C5823B7BA, 0x841B8AB98FA4B8F8, 0x29C1F6E6B3E0301B, 0xE0ADA17364673F59 + }; + + return table; + } + + const uint64_t * const table; + }; + + //*************************************************************************** + /// CRC64 Poly 0x42F0E1EBA9EA3693 policy. + /// Calculates CRC64 using polynomial 0x42F0E1EBA9EA3693 + //*************************************************************************** + template + struct crc64_policy_poly_0x42f0e1eba9ea3693 : public crc64_table_poly_0x42f0e1eba9ea3693 + { + typedef uint64_t value_type; + + //************************************************************************* + ETL_CONSTEXPR uint64_t initial() const + { + return INITIAL; + } + + //************************************************************************* + uint64_t add(uint64_t crc, uint8_t value) const + { + return (crc << 8) ^ table[((crc >> 56) ^ value) & 0xFF]; + } + + //************************************************************************* + uint64_t final(uint64_t crc) const + { + return crc ^ XOR_OUT; + } + }; + + //*************************************************************************** + /// CRC64 Poly 0x42F0E1EBA9EA3693 reflected policy specialisation. + //*************************************************************************** + template + struct crc64_policy_poly_0x42f0e1eba9ea3693 : public crc64_table_poly_0x42f0e1eba9ea3693_reflected + { + typedef uint64_t value_type; + + //************************************************************************* + ETL_CONSTEXPR uint64_t initial() const + { + return INITIAL; + } + + //************************************************************************* + uint64_t add(uint64_t crc, uint8_t value) const + { + return (crc >> 8) ^ table[(crc ^ value) & 0xFF]; + } + + //************************************************************************* + uint64_t final(uint64_t crc) const + { + return crc ^ XOR_OUT; + } + }; + + //************************************************************************* + /// CRC64 Poly 0x42F0E1EBA9EA3693 + //************************************************************************* + template + class crc64_poly_0x42f0e1eba9ea3693 : public etl::frame_check_sequence > + { + public: + + //************************************************************************* + /// Default constructor. + //************************************************************************* + crc64_poly_0x42f0e1eba9ea3693() + { + this->reset(); + } + + //************************************************************************* + /// Constructor from range. + /// \param begin Start of the range. + /// \param end End of the range. + //************************************************************************* + template + crc64_poly_0x42f0e1eba9ea3693(TIterator begin, const TIterator end) + { + this->reset(); + this->add(begin, end); + } + }; +} + +#endif diff --git a/include/etl/private/crc8_poly_0x07.h b/include/etl/private/crc8_poly_0x07.h new file mode 100644 index 00000000..181fcc99 --- /dev/null +++ b/include/etl/private/crc8_poly_0x07.h @@ -0,0 +1,212 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2019 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_CRC8_POLY_0x07_INCLUDED +#define ETL_CRC8_POLY_0x07_INCLUDED + +#include + +#include "../platform.h" +#include "../frame_check_sequence.h" +#include "../binary.h" + +#include "../stl/iterator.h" + +#if defined(ETL_COMPILER_KEIL) +#pragma diag_suppress 1300 +#endif + +///\defgroup crc8_poly_0x07 8 bit CRC Poly 0x07 calculation +///\ingroup crc + +namespace etl +{ + //*************************************************************************** + class crc8_table_poly_0x07 + { + protected: + + crc8_table_poly_0x07() + : table(get_table()) + { + } + + static const uint8_t * const get_table() + { + static const uint8_t table[256] = + { + 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15, 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D, + 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65, 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D, + 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5, 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD, + 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85, 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD, + 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2, 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA, + 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2, 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A, + 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32, 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A, + 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42, 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A, + 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C, 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4, + 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC, 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4, + 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C, 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44, + 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C, 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34, + 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B, 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63, + 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B, 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13, + 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB, 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83, + 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB, 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3 + }; + + return table; + } + + const uint8_t * const table; + }; + + //*************************************************************************** + class crc8_table_poly_0x07_reflected + { + protected: + + crc8_table_poly_0x07_reflected() + : table(get_table()) + { + } + + static const uint8_t * const get_table() + { + static const uint8_t table[256] = + { + 0x00, 0x31, 0x62, 0x53, 0xC4, 0xF5, 0xA6, 0x97, 0xB9, 0x88, 0xDB, 0xEA, 0x7D, 0x4C, 0x1F, 0x2E, + 0x43, 0x72, 0x21, 0x10, 0x87, 0xB6, 0xE5, 0xD4, 0xFA, 0xCB, 0x98, 0xA9, 0x3E, 0x0F, 0x5C, 0x6D, + 0x86, 0xB7, 0xE4, 0xD5, 0x42, 0x73, 0x20, 0x11, 0x3F, 0x0E, 0x5D, 0x6C, 0xFB, 0xCA, 0x99, 0xA8, + 0xC5, 0xF4, 0xA7, 0x96, 0x01, 0x30, 0x63, 0x52, 0x7C, 0x4D, 0x1E, 0x2F, 0xB8, 0x89, 0xDA, 0xEB, + 0x3D, 0x0C, 0x5F, 0x6E, 0xF9, 0xC8, 0x9B, 0xAA, 0x84, 0xB5, 0xE6, 0xD7, 0x40, 0x71, 0x22, 0x13, + 0x7E, 0x4F, 0x1C, 0x2D, 0xBA, 0x8B, 0xD8, 0xE9, 0xC7, 0xF6, 0xA5, 0x94, 0x03, 0x32, 0x61, 0x50, + 0xBB, 0x8A, 0xD9, 0xE8, 0x7F, 0x4E, 0x1D, 0x2C, 0x02, 0x33, 0x60, 0x51, 0xC6, 0xF7, 0xA4, 0x95, + 0xF8, 0xC9, 0x9A, 0xAB, 0x3C, 0x0D, 0x5E, 0x6F, 0x41, 0x70, 0x23, 0x12, 0x85, 0xB4, 0xE7, 0xD6, + 0x7A, 0x4B, 0x18, 0x29, 0xBE, 0x8F, 0xDC, 0xED, 0xC3, 0xF2, 0xA1, 0x90, 0x07, 0x36, 0x65, 0x54, + 0x39, 0x08, 0x5B, 0x6A, 0xFD, 0xCC, 0x9F, 0xAE, 0x80, 0xB1, 0xE2, 0xD3, 0x44, 0x75, 0x26, 0x17, + 0xFC, 0xCD, 0x9E, 0xAF, 0x38, 0x09, 0x5A, 0x6B, 0x45, 0x74, 0x27, 0x16, 0x81, 0xB0, 0xE3, 0xD2, + 0xBF, 0x8E, 0xDD, 0xEC, 0x7B, 0x4A, 0x19, 0x28, 0x06, 0x37, 0x64, 0x55, 0xC2, 0xF3, 0xA0, 0x91, + 0x47, 0x76, 0x25, 0x14, 0x83, 0xB2, 0xE1, 0xD0, 0xFE, 0xCF, 0x9C, 0xAD, 0x3A, 0x0B, 0x58, 0x69, + 0x04, 0x35, 0x66, 0x57, 0xC0, 0xF1, 0xA2, 0x93, 0xBD, 0x8C, 0xDF, 0xEE, 0x79, 0x48, 0x1B, 0x2A, + 0xC1, 0xF0, 0xA3, 0x92, 0x05, 0x34, 0x67, 0x56, 0x78, 0x49, 0x1A, 0x2B, 0xBC, 0x8D, 0xDE, 0xEF, + 0x82, 0xB3, 0xE0, 0xD1, 0x46, 0x77, 0x24, 0x15, 0x3B, 0x0A, 0x59, 0x68, 0xFF, 0xCE, 0x9D, 0xAC + }; + + return table; + } + + const uint8_t * const table; + }; + + //*************************************************************************** + /// CRC8 Poly 0x07 policy. + /// Calculates CRC8 using polynomial 0x07 + //*************************************************************************** + template + struct crc8_policy_poly_0x07 : public crc8_table_poly_0x07 + { + typedef uint8_t value_type; + + //************************************************************************* + ETL_CONSTEXPR uint8_t initial() const + { + return INITIAL; + } + + //************************************************************************* + uint8_t add(uint8_t crc, uint8_t value) const + { + return table[crc ^ value]; + } + + //************************************************************************* + uint8_t final(uint8_t crc) const + { + return crc ^ XOR_OUT; + } + }; + + //*************************************************************************** + /// CRC8 Poly 0x07 reflected policy specialisation. + //*************************************************************************** + template + struct crc8_policy_poly_0x07 : public crc8_table_poly_0x07_reflected + { + typedef uint8_t value_type; + + //************************************************************************* + ETL_CONSTEXPR uint8_t initial() const + { + return INITIAL; + } + + //************************************************************************* + uint8_t add(uint8_t crc, uint8_t value) const + { + return table[crc ^ value]; + } + + //************************************************************************* + uint8_t final(uint8_t crc) const + { + return crc ^ XOR_OUT; + } + }; + + //************************************************************************* + /// CRC8 Poly 0x07 + //************************************************************************* + template + class crc8_poly_0x07 : public etl::frame_check_sequence > + { + public: + + //************************************************************************* + /// Default constructor. + //************************************************************************* + crc8_poly_0x07() + { + this->reset(); + } + + //************************************************************************* + /// Constructor from range. + /// \param begin Start of the range. + /// \param end End of the range. + //************************************************************************* + template + crc8_poly_0x07(TIterator begin, const TIterator end) + { + this->reset(); + this->add(begin, end); + } + }; +} + +#endif diff --git a/include/etl/version.h b/include/etl/version.h index 64abbb3b..6b3a1072 100644 --- a/include/etl/version.h +++ b/include/etl/version.h @@ -38,8 +38,8 @@ SOFTWARE. ///\ingroup utilities #define ETL_VERSION_MAJOR 15 -#define ETL_VERSION_MINOR 3 -#define ETL_VERSION_PATCH 1 +#define ETL_VERSION_MINOR 4 +#define ETL_VERSION_PATCH 0 #define ETL_VERSION ETL_STRINGIFY(ETL_VERSION_MAJOR) "." ETL_STRINGIFY(ETL_VERSION_MINOR) "." ETL_STRINGIFY(ETL_VERSION_PATCH) #define ETL_VERSION_W ETL_STRINGIFY(ETL_VERSION_MAJOR) L"." ETL_STRINGIFY(ETL_VERSION_MINOR) L"." ETL_STRINGIFY(ETL_VERSION_PATCH) diff --git a/library.json b/library.json index b2399ec0..8dbb6aa5 100644 --- a/library.json +++ b/library.json @@ -1,6 +1,6 @@ { "name": "Embedded Template Library", - "version": "15.3.1", + "version": "15.4.0", "authors": { "name": "John Wellbelove", "email": "" diff --git a/library.properties b/library.properties index 55396e07..b4b2e6d6 100644 --- a/library.properties +++ b/library.properties @@ -1,5 +1,5 @@ name=Embedded Template Library -version=15.3.1 +version=15.4.0 author= John Wellbelove maintainer=John Wellbelove license=MIT diff --git a/support/Release notes.txt b/support/Release notes.txt index de5c0872..3c121b78 100644 --- a/support/Release notes.txt +++ b/support/Release notes.txt @@ -1,3 +1,8 @@ +=============================================================================== +15.4.0 +Refactored CRC classes for better code sharing and reduced resource requirements +Added new CRC definitions + =============================================================================== 15.3.1 Changes to alternate STL limits.h for ARM5 compiler compatibility diff --git a/test/test_crc.cpp b/test/test_crc.cpp index c5adaf02..59108323 100644 --- a/test/test_crc.cpp +++ b/test/test_crc.cpp @@ -36,11 +36,24 @@ SOFTWARE. #include "etl/crc8_ccitt.h" #include "etl/crc16.h" #include "etl/crc16_ccitt.h" +#include "etl/crc16_aug_ccitt.h" #include "etl/crc16_kermit.h" #include "etl/crc16_modbus.h" +#include "etl/crc16_usb.h" +#include "etl/crc16_xmodem.h" +#include "etl/crc16_genibus.h" +#include "etl/crc16_x25.h" #include "etl/crc32.h" +#include "etl/crc32_c.h" +#include "etl/crc32_bzip2.h" +#include "etl/crc32_mpeg2.h" +#include "etl/crc32_posix.h" #include "etl/crc64_ecma.h" +//***************************************************************************** +// The results for these tests were created from https://crccalc.com/ +//***************************************************************************** + namespace { SUITE(test_crc) @@ -325,6 +338,286 @@ namespace CHECK_EQUAL(crc1, crc3); } + //************************************************************************* + TEST(test_crc16_usb) + { + std::string data("123456789"); + + uint16_t crc = etl::crc16_usb(data.begin(), data.end()); + + CHECK_EQUAL(0xB4C8, crc); + } + + //************************************************************************* + TEST(test_crc16_usb_add_values) + { + std::string data("123456789"); + + etl::crc16_usb crc_calculator; + + for (size_t i = 0; i < data.size(); ++i) + { + crc_calculator.add(data[i]); + } + + uint16_t crc = crc_calculator; + + CHECK_EQUAL(0xB4C8, crc); + } + + //************************************************************************* + TEST(test_crc16_usb_add_range) + { + std::string data("123456789"); + + etl::crc16_usb crc_calculator; + + crc_calculator.add(data.begin(), data.end()); + + uint16_t crc = crc_calculator.value(); + + CHECK_EQUAL(0xB4C8, crc); + } + + //************************************************************************* + TEST(test_crc16_usb_add_range_endian) + { + std::vector data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; + std::vector data2 = { 0x04030201, 0x08070605 }; + std::vector data3 = { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; + + uint16_t crc1 = etl::crc16_usb(data1.begin(), data1.end()); + uint16_t crc2 = etl::crc16_usb((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size())); + CHECK_EQUAL(crc1, crc2); + + uint16_t crc3 = etl::crc16_usb(data3.rbegin(), data3.rend()); + CHECK_EQUAL(crc1, crc3); + } + + //************************************************************************* + TEST(test_crc16_xmodem) + { + std::string data("123456789"); + + uint16_t crc = etl::crc16_xmodem(data.begin(), data.end()); + + CHECK_EQUAL(0x31C3, crc); + } + + //************************************************************************* + TEST(test_crc16_xmodem_add_values) + { + std::string data("123456789"); + + etl::crc16_xmodem crc_calculator; + + for (size_t i = 0; i < data.size(); ++i) + { + crc_calculator.add(data[i]); + } + + uint16_t crc = crc_calculator; + + CHECK_EQUAL(0x31C3, crc); + } + + //************************************************************************* + TEST(test_crc16_xmodem_add_range) + { + std::string data("123456789"); + + etl::crc16_xmodem crc_calculator; + + crc_calculator.add(data.begin(), data.end()); + + uint16_t crc = crc_calculator.value(); + + CHECK_EQUAL(0x31C3, crc); + } + + //************************************************************************* + TEST(test_crc16_xmodem_add_range_endian) + { + std::vector data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; + std::vector data2 = { 0x04030201, 0x08070605 }; + std::vector data3 = { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; + + uint16_t crc1 = etl::crc16_xmodem(data1.begin(), data1.end()); + uint16_t crc2 = etl::crc16_xmodem((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size())); + CHECK_EQUAL(crc1, crc2); + + uint16_t crc3 = etl::crc16_xmodem(data3.rbegin(), data3.rend()); + CHECK_EQUAL(crc1, crc3); + } + + //************************************************************************* + TEST(test_crc16_aug_ccitt) + { + std::string data("123456789"); + + uint16_t crc = etl::crc16_aug_ccitt(data.begin(), data.end()); + + CHECK_EQUAL(0xE5CC, crc); + } + + //************************************************************************* + TEST(test_crc16_aug_ccitt_add_values) + { + std::string data("123456789"); + + etl::crc16_aug_ccitt crc_calculator; + + for (size_t i = 0; i < data.size(); ++i) + { + crc_calculator.add(data[i]); + } + + uint16_t crc = crc_calculator; + + CHECK_EQUAL(0xE5CC, crc); + } + + //************************************************************************* + TEST(test_crc16_aug_ccitt_add_range) + { + std::string data("123456789"); + + etl::crc16_aug_ccitt crc_calculator; + + crc_calculator.add(data.begin(), data.end()); + + uint16_t crc = crc_calculator.value(); + + CHECK_EQUAL(0xE5CC, crc); + } + + //************************************************************************* + TEST(test_crc16_aug_ccitt_add_range_endian) + { + std::vector data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; + std::vector data2 = { 0x04030201, 0x08070605 }; + std::vector data3 = { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; + + uint16_t crc1 = etl::crc16_aug_ccitt(data1.begin(), data1.end()); + uint16_t crc2 = etl::crc16_aug_ccitt((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size())); + CHECK_EQUAL(crc1, crc2); + + uint16_t crc3 = etl::crc16_aug_ccitt(data3.rbegin(), data3.rend()); + CHECK_EQUAL(crc1, crc3); + } + + //************************************************************************* + TEST(test_crc16_genibus) + { + std::string data("123456789"); + + uint16_t crc = etl::crc16_genibus(data.begin(), data.end()); + + CHECK_EQUAL(0xD64E, crc); + } + + //************************************************************************* + TEST(test_crc16_genibus_add_values) + { + std::string data("123456789"); + + etl::crc16_genibus crc_calculator; + + for (size_t i = 0; i < data.size(); ++i) + { + crc_calculator.add(data[i]); + } + + uint16_t crc = crc_calculator; + + CHECK_EQUAL(0xD64E, crc); + } + + //************************************************************************* + TEST(test_crc16_genibus_add_range) + { + std::string data("123456789"); + + etl::crc16_genibus crc_calculator; + + crc_calculator.add(data.begin(), data.end()); + + uint16_t crc = crc_calculator.value(); + + CHECK_EQUAL(0xD64E, crc); + } + + //************************************************************************* + TEST(test_crc16_genibus_add_range_endian) + { + std::vector data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; + std::vector data2 = { 0x04030201, 0x08070605 }; + std::vector data3 = { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; + + uint16_t crc1 = etl::crc16_genibus(data1.begin(), data1.end()); + uint16_t crc2 = etl::crc16_genibus((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size())); + CHECK_EQUAL(crc1, crc2); + + uint16_t crc3 = etl::crc16_genibus(data3.rbegin(), data3.rend()); + CHECK_EQUAL(crc1, crc3); + } + + //************************************************************************* + TEST(test_crc16_x25) + { + std::string data("123456789"); + + uint16_t crc = etl::crc16_x25(data.begin(), data.end()); + + CHECK_EQUAL(0x906E, crc); + } + + //************************************************************************* + TEST(test_crc16_x25_add_values) + { + std::string data("123456789"); + + etl::crc16_x25 crc_calculator; + + for (size_t i = 0; i < data.size(); ++i) + { + crc_calculator.add(data[i]); + } + + uint16_t crc = crc_calculator; + + CHECK_EQUAL(0x906E, crc); + } + + //************************************************************************* + TEST(test_crc16_x25_add_range) + { + std::string data("123456789"); + + etl::crc16_x25 crc_calculator; + + crc_calculator.add(data.begin(), data.end()); + + uint16_t crc = crc_calculator.value(); + + CHECK_EQUAL(0x906E, crc); + } + + //************************************************************************* + TEST(test_crc16_x25_add_range_endian) + { + std::vector data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; + std::vector data2 = { 0x04030201, 0x08070605 }; + std::vector data3 = { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; + + uint16_t crc1 = etl::crc16_x25(data1.begin(), data1.end()); + uint16_t crc2 = etl::crc16_x25((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size())); + CHECK_EQUAL(crc1, crc2); + + uint16_t crc3 = etl::crc16_x25(data3.rbegin(), data3.rend()); + CHECK_EQUAL(crc1, crc3); + } + //************************************************************************* TEST(test_crc32) { @@ -382,6 +675,234 @@ namespace CHECK_EQUAL(crc1, crc3); } + //************************************************************************* + TEST(test_crc32_c) + { + std::string data("123456789"); + + uint32_t crc = etl::crc32_c(data.begin(), data.end()); + + CHECK_EQUAL(0xE3069283, crc); + } + + //************************************************************************* + TEST(test_crc32_c_add_values) + { + std::string data("123456789"); + + etl::crc32_c crc_calculator; + + for (size_t i = 0; i < data.size(); ++i) + { + crc_calculator.add(data[i]); + } + + uint32_t crc = crc_calculator; + + + CHECK_EQUAL(0xE3069283, crc); + } + + //************************************************************************* + TEST(test_crc32_c_add_range) + { + std::string data("123456789"); + + etl::crc32_c crc_calculator; + + crc_calculator.add(data.begin(), data.end()); + + uint32_t crc = crc_calculator.value(); + + CHECK_EQUAL(0xE3069283, crc); + } + + //************************************************************************* + TEST(test_crc32_c_add_range_endian) + { + std::vector data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; + std::vector data2 = { 0x04030201, 0x08070605 }; + std::vector data3 = { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; + + uint32_t crc1 = etl::crc32_c(data1.begin(), data1.end()); + uint32_t crc2 = etl::crc32_c((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size())); + CHECK_EQUAL(crc1, crc2); + + uint32_t crc3 = etl::crc32_c(data3.rbegin(), data3.rend()); + CHECK_EQUAL(crc1, crc3); + } + + //************************************************************************* + TEST(test_crc32_bzip2) + { + std::string data("123456789"); + + uint32_t crc = etl::crc32_bzip2(data.begin(), data.end()); + + CHECK_EQUAL(0xFC891918, crc); + } + + //************************************************************************* + TEST(test_crc32_bzip2_add_values) + { + std::string data("123456789"); + + etl::crc32_bzip2 crc_calculator; + + for (size_t i = 0; i < data.size(); ++i) + { + crc_calculator.add(data[i]); + } + + uint32_t crc = crc_calculator; + + + CHECK_EQUAL(0xFC891918, crc); + } + + //************************************************************************* + TEST(test_crc32_bzip2_add_range) + { + std::string data("123456789"); + + etl::crc32_bzip2 crc_calculator; + + crc_calculator.add(data.begin(), data.end()); + + uint32_t crc = crc_calculator.value(); + + CHECK_EQUAL(0xFC891918, crc); + } + + //************************************************************************* + TEST(test_crc32_bzip2_add_range_endian) + { + std::vector data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; + std::vector data2 = { 0x04030201, 0x08070605 }; + std::vector data3 = { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; + + uint32_t crc1 = etl::crc32_bzip2(data1.begin(), data1.end()); + uint32_t crc2 = etl::crc32_bzip2((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size())); + CHECK_EQUAL(crc1, crc2); + + uint32_t crc3 = etl::crc32_bzip2(data3.rbegin(), data3.rend()); + CHECK_EQUAL(crc1, crc3); + } + + //************************************************************************* + TEST(test_crc32_posix) + { + std::string data("123456789"); + + uint32_t crc = etl::crc32_posix(data.begin(), data.end()); + + CHECK_EQUAL(0x765E7680, crc); + } + + //************************************************************************* + TEST(test_crc32_posix_add_values) + { + std::string data("123456789"); + + etl::crc32_posix crc_calculator; + + for (size_t i = 0; i < data.size(); ++i) + { + crc_calculator.add(data[i]); + } + + uint32_t crc = crc_calculator; + + + CHECK_EQUAL(0x765E7680, crc); + } + + //************************************************************************* + TEST(test_crc32_posix_add_range) + { + std::string data("123456789"); + + etl::crc32_posix crc_calculator; + + crc_calculator.add(data.begin(), data.end()); + + uint32_t crc = crc_calculator.value(); + + CHECK_EQUAL(0x765E7680, crc); + } + + //************************************************************************* + TEST(test_crc32_posix_add_range_endian) + { + std::vector data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; + std::vector data2 = { 0x04030201, 0x08070605 }; + std::vector data3 = { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; + + uint32_t crc1 = etl::crc32_posix(data1.begin(), data1.end()); + uint32_t crc2 = etl::crc32_posix((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size())); + CHECK_EQUAL(crc1, crc2); + + uint32_t crc3 = etl::crc32_posix(data3.rbegin(), data3.rend()); + CHECK_EQUAL(crc1, crc3); + } + + //************************************************************************* + TEST(test_crc32_mpeg2) + { + std::string data("123456789"); + + uint32_t crc = etl::crc32_mpeg2(data.begin(), data.end()); + + CHECK_EQUAL(0x0376E6E7, crc); + } + + //************************************************************************* + TEST(test_crc32_mpeg2_add_values) + { + std::string data("123456789"); + + etl::crc32_mpeg2 crc_calculator; + + for (size_t i = 0; i < data.size(); ++i) + { + crc_calculator.add(data[i]); + } + + uint32_t crc = crc_calculator; + + + CHECK_EQUAL(0x0376E6E7, crc); + } + + //************************************************************************* + TEST(test_crc32_mpeg2_add_range) + { + std::string data("123456789"); + + etl::crc32_mpeg2 crc_calculator; + + crc_calculator.add(data.begin(), data.end()); + + uint32_t crc = crc_calculator.value(); + + CHECK_EQUAL(0x0376E6E7, crc); + } + + //************************************************************************* + TEST(test_crc32_mpeg2_add_range_endian) + { + std::vector data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; + std::vector data2 = { 0x04030201, 0x08070605 }; + std::vector data3 = { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; + + uint32_t crc1 = etl::crc32_mpeg2(data1.begin(), data1.end()); + uint32_t crc2 = etl::crc32_mpeg2((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size())); + CHECK_EQUAL(crc1, crc2); + + uint32_t crc3 = etl::crc32_mpeg2(data3.rbegin(), data3.rend()); + CHECK_EQUAL(crc1, crc3); + } + //************************************************************************* TEST(test_crc64_ecma) { diff --git a/test/vs2017/etl.vcxproj b/test/vs2017/etl.vcxproj index 0481a010..483c5cad 100644 --- a/test/vs2017/etl.vcxproj +++ b/test/vs2017/etl.vcxproj @@ -710,8 +710,17 @@ + + + + + + + + + @@ -729,6 +738,12 @@ + + + + + + @@ -1253,6 +1268,7 @@ + diff --git a/test/vs2017/etl.vcxproj.filters b/test/vs2017/etl.vcxproj.filters index 47a5caf4..285dce65 100644 --- a/test/vs2017/etl.vcxproj.filters +++ b/test/vs2017/etl.vcxproj.filters @@ -76,6 +76,12 @@ {da88d71d-e5ea-4c26-9807-94616d31addb} + + {0eaad66f-3ce3-4952-8ae8-c935e6aa7c1d} + + + {0d5824b1-3ef9-43e0-b2d5-15d6246b843e} + @@ -795,6 +801,51 @@ ETL\Private + + ETL\Private + + + ETL\Private + + + ETL\Private + + + ETL\Private + + + ETL\Private + + + ETL\Private + + + ETL\Maths + + + ETL\Maths + + + ETL\Maths + + + ETL\Maths + + + ETL\Maths + + + ETL\Maths + + + ETL\Maths + + + ETL\Maths + + + ETL\Maths + @@ -1301,6 +1352,9 @@ Resource Files + + Resource Files + From 0acbdb98b296c6d5ac37a00da18ed74bf2346df9 Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Thu, 12 Dec 2019 20:42:37 +0000 Subject: [PATCH 9/9] Refactored CRC classes for better code sharing and reduced resource requirements. --- include/etl/private/crc16_poly_0x1021_.h | 44 +++++-------------- include/etl/private/crc16_poly_0x8005.h | 44 +++++-------------- include/etl/private/crc32_poly_0x04c11db7.h | 44 +++++-------------- include/etl/private/crc32_poly_0x1edc6f41.h | 44 +++++-------------- .../private/crc64_poly_0x42f0e1eba9ea3693.h | 42 +++++------------- include/etl/private/crc8_poly_0x07.h | 44 +++++-------------- 6 files changed, 72 insertions(+), 190 deletions(-) diff --git a/include/etl/private/crc16_poly_0x1021_.h b/include/etl/private/crc16_poly_0x1021_.h index 08cdcfab..793009d6 100644 --- a/include/etl/private/crc16_poly_0x1021_.h +++ b/include/etl/private/crc16_poly_0x1021_.h @@ -48,17 +48,15 @@ SOFTWARE. namespace etl { + //*************************************************************************** + /// Table and add value. //*************************************************************************** class crc16_table_poly_0x1021 { - protected: + public: - crc16_table_poly_0x1021() - : table(get_table()) - { - } - - static const uint16_t * const get_table() + //************************************************************************* + uint16_t add(uint16_t crc, uint8_t value) const { static const uint16_t table[256] = { @@ -80,23 +78,19 @@ namespace etl 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 }; - return table; + return (crc << 8) ^ table[((crc >> 8) ^ value) & 0xFF]; } - - const uint16_t * const table; }; + //*************************************************************************** + /// Table and add value. //*************************************************************************** class crc16_table_poly_0x1021_reflected { - protected: + public: - crc16_table_poly_0x1021_reflected() - : table(get_table()) - { - } - - static const uint16_t * const get_table() + //************************************************************************* + uint16_t add(uint16_t crc, uint8_t value) const { static const uint16_t table[256] = { @@ -118,10 +112,8 @@ namespace etl 0xF78F, 0xE606, 0xD49D, 0xC514, 0xB1AB, 0xA022, 0x92B9, 0x8330, 0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78 }; - return table; + return (crc >> 8) ^ table[(crc ^ value) & 0xFF]; } - - const uint16_t * const table; }; //*************************************************************************** @@ -139,12 +131,6 @@ namespace etl return INITIAL; } - //************************************************************************* - uint16_t add(uint16_t crc, uint8_t value) const - { - return (crc << 8) ^ table[((crc >> 8) ^ value) & 0xFF]; - } - //************************************************************************* inline uint16_t final(uint16_t crc) const { @@ -166,12 +152,6 @@ namespace etl return INITIAL; } - //************************************************************************* - uint16_t add(uint16_t crc, uint8_t value) const - { - return (crc >> 8) ^ table[(crc ^ value) & 0xFF]; - } - //************************************************************************* uint16_t final(uint16_t crc) const { diff --git a/include/etl/private/crc16_poly_0x8005.h b/include/etl/private/crc16_poly_0x8005.h index 44dfcf60..86f61343 100644 --- a/include/etl/private/crc16_poly_0x8005.h +++ b/include/etl/private/crc16_poly_0x8005.h @@ -48,17 +48,15 @@ SOFTWARE. namespace etl { + //*************************************************************************** + /// Table and add value. //*************************************************************************** class crc16_table_poly_0x8005 { - protected: + public: - crc16_table_poly_0x8005() - : table(get_table()) - { - } - - static const uint16_t * const get_table() + //************************************************************************* + uint16_t add(uint16_t crc, uint8_t value) const { static const uint16_t table[256] = { @@ -80,23 +78,19 @@ namespace etl 0x0220, 0x8225, 0x822F, 0x022A, 0x823B, 0x023E, 0x0234, 0x8231, 0x8213, 0x0216, 0x021C, 0x8219, 0x0208, 0x820D, 0x8207, 0x0202 }; - return table; + return (crc << 8) ^ table[((crc >> 8) ^ value) & 0xFF]; } - - const uint16_t * const table; }; + //*************************************************************************** + /// Table and add value. //*************************************************************************** class crc16_table_poly_0x8005_reflected { - protected: + public: - crc16_table_poly_0x8005_reflected() - : table(get_table()) - { - } - - static const uint16_t * const get_table() + //************************************************************************* + uint16_t add(uint16_t crc, uint8_t value) const { static const uint16_t table[256] = { @@ -118,10 +112,8 @@ namespace etl 0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641, 0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040 }; - return table; + return (crc >> 8) ^ table[(crc ^ value) & 0xFF]; } - - const uint16_t * const table; }; //*************************************************************************** @@ -139,12 +131,6 @@ namespace etl return INITIAL; } - //************************************************************************* - uint16_t add(uint16_t crc, uint8_t value) const - { - return (crc << 8) ^ table[((crc >> 8) ^ value) & 0xFF]; - } - //************************************************************************* inline uint16_t final(uint16_t crc) const { @@ -166,12 +152,6 @@ namespace etl return INITIAL; } - //************************************************************************* - uint16_t add(uint16_t crc, uint8_t value) const - { - return (crc >> 8) ^ table[(crc ^ value) & 0xFF]; - } - //************************************************************************* inline uint16_t final(uint16_t crc) const { diff --git a/include/etl/private/crc32_poly_0x04c11db7.h b/include/etl/private/crc32_poly_0x04c11db7.h index cdbdb5f3..142d30e6 100644 --- a/include/etl/private/crc32_poly_0x04c11db7.h +++ b/include/etl/private/crc32_poly_0x04c11db7.h @@ -48,17 +48,15 @@ SOFTWARE. namespace etl { + //*************************************************************************** + /// Table and add value. //*************************************************************************** class crc32_table_poly_0x04c11db7 { - protected: + public: - crc32_table_poly_0x04c11db7() - : table(get_table()) - { - } - - static const uint32_t * const get_table() + //************************************************************************* + uint32_t add(uint32_t crc, uint8_t value) const { static const uint32_t table[256] = { @@ -80,23 +78,19 @@ namespace etl 0x89B8FD09, 0x8D79E0BE, 0x803AC667, 0x84FBDBD0, 0x9ABC8BD5, 0x9E7D9662, 0x933EB0BB, 0x97FFAD0C, 0xAFB010B1, 0xAB710D06, 0xA6322BDF, 0xA2F33668, 0xBCB4666D, 0xB8757BDA, 0xB5365D03, 0xB1F740B4 }; - return table; + return (crc << 8) ^ table[((crc >> 24) ^ value) & 0xFF]; } - - const uint32_t * const table; }; + //*************************************************************************** + /// Table and add value. //*************************************************************************** class crc32_table_poly_0x04c11db7_reflected { - protected: + public: - crc32_table_poly_0x04c11db7_reflected() - : table(get_table()) - { - } - - static const uint32_t * const get_table() + //************************************************************************* + uint32_t add(uint32_t crc, uint8_t value) const { static const uint32_t table[256] = { @@ -118,10 +112,8 @@ namespace etl 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D }; - return table; + return (crc >> 8) ^ table[(crc ^ value) & 0xFF]; } - - const uint32_t * const table; }; //*************************************************************************** @@ -139,12 +131,6 @@ namespace etl return INITIAL; } - //************************************************************************* - uint32_t add(uint32_t crc, uint8_t value) const - { - return (crc << 8) ^ table[((crc >> 24) ^ value) & 0xFF]; - } - //************************************************************************* uint32_t final(uint32_t crc) const { @@ -166,12 +152,6 @@ namespace etl return INITIAL; } - //************************************************************************* - uint32_t add(uint32_t crc, uint8_t value) const - { - return (crc >> 8) ^ table[(crc ^ value) & 0xFF]; - } - //************************************************************************* uint32_t final(uint32_t crc) const { diff --git a/include/etl/private/crc32_poly_0x1edc6f41.h b/include/etl/private/crc32_poly_0x1edc6f41.h index 51c6e323..969bdcc6 100644 --- a/include/etl/private/crc32_poly_0x1edc6f41.h +++ b/include/etl/private/crc32_poly_0x1edc6f41.h @@ -48,17 +48,15 @@ SOFTWARE. namespace etl { + //*************************************************************************** + /// Table and add value. //*************************************************************************** class crc32_table_poly_0x1edc6f41 { - protected: + public: - crc32_table_poly_0x1edc6f41() - : table(get_table()) - { - } - - static const uint32_t * const get_table() + //************************************************************************* + uint32_t add(uint32_t crc, uint8_t value) const { static const uint32_t table[256] = { @@ -80,23 +78,19 @@ namespace etl 0xAEF676CF, 0x6E37A080, 0x41F8AA48, 0x81397C07, 0x561F2F2C, 0x96DEF963, 0xB911F3AB, 0x79D025E4, 0x5DECED9E, 0x9D2D3BD1, 0xB2E23119, 0x7223E756, 0xA505B47D, 0x65C46232, 0x4A0B68FA, 0x8ACABEB5 }; - return table; + return (crc << 8) ^ table[((crc >> 24) ^ value) & 0xFF]; } - - const uint32_t * const table; }; + //*************************************************************************** + /// Table and add value. //*************************************************************************** class crc32_table_poly_0x1edc6f41_reflected { - protected: + public: - crc32_table_poly_0x1edc6f41_reflected() - : table(get_table()) - { - } - - static const uint32_t * const get_table() + //************************************************************************* + uint32_t add(uint32_t crc, uint8_t value) const { static const uint32_t table[256] = { @@ -118,10 +112,8 @@ namespace etl 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81, 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E, 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E, 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351 }; - return table; + return (crc >> 8) ^ table[(crc ^ value) & 0xFF]; } - - const uint32_t * const table; }; //*************************************************************************** @@ -139,12 +131,6 @@ namespace etl return INITIAL; } - //************************************************************************* - uint32_t add(uint32_t crc, uint8_t value) const - { - return (crc << 8) ^ table[((crc >> 24) ^ value) & 0xFF]; - } - //************************************************************************* uint32_t final(uint32_t crc) const { @@ -166,12 +152,6 @@ namespace etl return INITIAL; } - //************************************************************************* - uint32_t add(uint32_t crc, uint8_t value) const - { - return (crc >> 8) ^ table[(crc ^ value) & 0xFF]; - } - //************************************************************************* uint32_t final(uint32_t crc) const { diff --git a/include/etl/private/crc64_poly_0x42f0e1eba9ea3693.h b/include/etl/private/crc64_poly_0x42f0e1eba9ea3693.h index c1760ddd..83f46d48 100644 --- a/include/etl/private/crc64_poly_0x42f0e1eba9ea3693.h +++ b/include/etl/private/crc64_poly_0x42f0e1eba9ea3693.h @@ -48,17 +48,15 @@ SOFTWARE. namespace etl { + //*************************************************************************** + /// Table and add value. //*************************************************************************** class crc64_table_poly_0x42f0e1eba9ea3693 { - protected: + public: - crc64_table_poly_0x42f0e1eba9ea3693() - : table(get_table()) - { - } - - static const uint64_t * const get_table() + //************************************************************************* + uint64_t add(uint64_t crc, uint8_t value) const { static const uint64_t table[256] = { @@ -96,21 +94,19 @@ namespace etl 0x14DEA25F3AF9026D, 0x562E43B4931334FE, 0x913F6188692D6F4B, 0xD3CF8063C0C759D8, 0x5DEDC41A34BBEEB2, 0x1F1D25F19D51D821, 0xD80C07CD676F8394, 0x9AFCE626CE85B507 }; - return table; + return (crc << 8) ^ table[((crc >> 56) ^ value) & 0xFF]; } - - const uint64_t * const table; }; + //*************************************************************************** + /// Table and add value. //*************************************************************************** class crc64_table_poly_0x42f0e1eba9ea3693_reflected { - crc64_table_poly_0x42f0e1eba9ea3693_reflected() - : table(get_table()) - { - } + public: - static const uint64_t * const get_table() + //************************************************************************* + uint64_t add(uint64_t crc, uint8_t value) const { static const uint64_t table[256] = { @@ -148,10 +144,8 @@ namespace etl 0xB6409F5CFA457B28, 0x7F2CC8C92DC2746A, 0xD2F6B4961186FC89, 0x1B9AE303C601F3CB, 0x4D77DD2C5823B7BA, 0x841B8AB98FA4B8F8, 0x29C1F6E6B3E0301B, 0xE0ADA17364673F59 }; - return table; + return (crc >> 8) ^ table[(crc ^ value) & 0xFF]; } - - const uint64_t * const table; }; //*************************************************************************** @@ -169,12 +163,6 @@ namespace etl return INITIAL; } - //************************************************************************* - uint64_t add(uint64_t crc, uint8_t value) const - { - return (crc << 8) ^ table[((crc >> 56) ^ value) & 0xFF]; - } - //************************************************************************* uint64_t final(uint64_t crc) const { @@ -196,12 +184,6 @@ namespace etl return INITIAL; } - //************************************************************************* - uint64_t add(uint64_t crc, uint8_t value) const - { - return (crc >> 8) ^ table[(crc ^ value) & 0xFF]; - } - //************************************************************************* uint64_t final(uint64_t crc) const { diff --git a/include/etl/private/crc8_poly_0x07.h b/include/etl/private/crc8_poly_0x07.h index 181fcc99..558ea003 100644 --- a/include/etl/private/crc8_poly_0x07.h +++ b/include/etl/private/crc8_poly_0x07.h @@ -48,17 +48,15 @@ SOFTWARE. namespace etl { + //*************************************************************************** + /// //*************************************************************************** class crc8_table_poly_0x07 { - protected: + public: - crc8_table_poly_0x07() - : table(get_table()) - { - } - - static const uint8_t * const get_table() + //************************************************************************* + uint8_t add(uint8_t crc, uint8_t value) const { static const uint8_t table[256] = { @@ -80,23 +78,19 @@ namespace etl 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB, 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3 }; - return table; + return table[crc ^ value]; } - - const uint8_t * const table; }; + //*************************************************************************** + /// //*************************************************************************** class crc8_table_poly_0x07_reflected { - protected: + public: - crc8_table_poly_0x07_reflected() - : table(get_table()) - { - } - - static const uint8_t * const get_table() + //************************************************************************* + uint8_t add(uint8_t crc, uint8_t value) const { static const uint8_t table[256] = { @@ -118,10 +112,8 @@ namespace etl 0x82, 0xB3, 0xE0, 0xD1, 0x46, 0x77, 0x24, 0x15, 0x3B, 0x0A, 0x59, 0x68, 0xFF, 0xCE, 0x9D, 0xAC }; - return table; + return table[crc ^ value]; } - - const uint8_t * const table; }; //*************************************************************************** @@ -139,12 +131,6 @@ namespace etl return INITIAL; } - //************************************************************************* - uint8_t add(uint8_t crc, uint8_t value) const - { - return table[crc ^ value]; - } - //************************************************************************* uint8_t final(uint8_t crc) const { @@ -166,12 +152,6 @@ namespace etl return INITIAL; } - //************************************************************************* - uint8_t add(uint8_t crc, uint8_t value) const - { - return table[crc ^ value]; - } - //************************************************************************* uint8_t final(uint8_t crc) const {