stuff

Author: takev

CMakeLists.txt

@@ -122,7 +122,6 @@ add_library(hk_objects OBJECT
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/datum.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/datum.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/defer.hpp"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/enum_variant.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/fixed_fifo.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/fixed_string.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/fqname.cpp"
@@ -201,6 +200,7 @@ if(BUILD_TESTING)
         "${CMAKE_CURRENT_SOURCE_DIR}/src/repository/repository_tests.cpp"
         "${CMAKE_CURRENT_SOURCE_DIR}/src/tokenizer/tokenizer_semicolon_tests.cpp"
         "${CMAKE_CURRENT_SOURCE_DIR}/src/tokenizer/tokenizer_tests.cpp"
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/defer_tests.cpp"
         "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/git_tests.cpp"
         "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/fqname_tests.cpp"
         "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/logic_tests.cpp"

doc/language/value_categories.md

@@ -0,0 +1,18 @@
+# Value Categories
+
+
+## Move properties
+
+Simple `class` and `enum` types have the following move-properties by default:
+
+ * memset: An object can be initialized by setting the members to pre-declared values.
+ * memcopy: An object can be copied/moved using a memory copy.
+ * memmove: An object can be moved by copying memory then clearing the old.
+ * memswap: An object can be swapped/moved by swapping memory.
+
+When a destructor is added to a type, the `memcopy` and `memmove` properties are disabled. `memswap` would
+almost always still work correctly.
+
+If a default-constructor is added to the type, the `memset` property is disabled.
+
+If you added a `__swap__()` function, `memswap` property is disabled

src/ast/module_declaration_node.hpp

@@ -4,7 +4,6 @@
 #include "top_declaration_node.hpp"
 #include "utility/fqname.hpp"
 #include "utility/semantic_version.hpp"
-#include "utility/enum_variant.hpp"
 #include <string>
 #include <filesystem>
 

src/utility/defer.hpp

@@ -4,23 +4,39 @@
 
 #include <concepts>
 #include <functional>
+#include <cassert>
 
 namespace hk {
 
+/** Defer execution till destruction.
+ * 
+ * Delay execution to the end of a function/block; useful for cleaning non-scoped variables
+ * with older C-style APIs.
+ */
 class defer {
 public:
+    /** If not cancelled, execute the deferred callable object.
+     */
     ~defer()
     {
         if (_f) {
             _f();
         }
     }
 
+    /** Construct with a callable object.
+     */
     [[nodiscard]] defer(std::function<void()> && arg) : _f(std::move(arg)) {}
+
+    /** Construct with a callable object.
+     */
     [[nodiscard]] defer(std::function<void()> const& arg) : _f(arg) {}
 
+    /** Cancel execution of the deferred execution.
+     */
     void cancel()
     {
+        assert(_f != nullptr);
         _f = nullptr;
     }
 

src/utility/defer_tests.cpp

@@ -0,0 +1,23 @@
+
+#include "defer.hpp"
+#include <hikotest/hikotest.hpp>
+
+TEST_SUITE(defer_suite) 
+{
+    TEST_CASE(simple) {
+        int i = 1;
+
+        {
+            auto const d1 = hk::defer([&]{
+                i += 8;
+            });
+
+            auto const d2 = hk::defer([&]{
+                i *= 3;
+            });
+        }
+
+        // If executed in the wrong order i == 27.
+        REQUIRE(i == 11);
+    }
+};

src/utility/enum_variant.hpp

@@ -4,37 +4,47 @@
 #include <cstdint>
 #include <utility>
 #include <exception>
+#include <string_view>
 
 namespace hk {
 
+/** Logic type.
+ * 
+ * This is a logic-type a smaller version of VHDL's std_logic.
+ * 
+ */
 enum class logic : uint8_t {
+    /** False */
     F,
+    /** True */
     T,
+    /** Error */
     X,
+    /** Don't Care (third state) */
     _,
 };
 
-template<size_t N>
-[[nodiscard]] constexpr auto make_logic_truth_table(char const *str)
+/** Calculate a truth-table and pack it into a integer.
+ * 
+ * @param str A set of values represented by '0', '1', 'X', '-'. The left
+ *            most character will places in the least significant 2 bits.
+ */
+[[nodiscard]] constexpr uint32_t make_logic_truth_table(std::string_view str)
 {
-    using int_type = std::conditional_t<N == 16, uint32_t, uint8_t>;
-    auto r = int_type{};
+    auto r = uint32_t{0};
 
-    for (auto i = N; i != 0; --i) {
+    for (auto i = str.size(); i != 0; --i) {
         r <<= 2;
         switch (str[i - 1]) {
-        case 'F':
         case '0':
             r |= std::to_underlying(logic::F);
             break;
-        case 'T':
         case '1':
             r |= std::to_underlying(logic::T);
             break;
         case 'X':
             r |= std::to_underlying(logic::X);
             break;
-        case '_':
         case '-':
             r |= std::to_underlying(logic::_);
             break;
@@ -45,11 +55,25 @@ template<size_t N>
     return r;
 }
 
-struct logic_binary_truth_table {
+/** Create a truth table for logic functions.
+ * 
+ */
+struct logic_truth_table {
     uint32_t _table;
 
-    [[nodiscard]] constexpr logic_binary_truth_table(char const str[17]) : _table(make_logic_truth_table<16>(str)) {}
-
+    /** Create a truth table.
+     * 
+     * @param str A set of values represented by '0', '1', 'X', '-'. The left
+     *            most character will places in the least significant 2 bits.
+     */
+    [[nodiscard]] constexpr logic_truth_table(std::string_view str) : _table(make_logic_truth_table(str)) {}
+
+    /** Extract a value from the table.
+     * 
+     * @param lhs Index on the minor axis.
+     * @param rhs Index on the major axis.
+     * @return The value at the given coordinates
+     */
     [[nodiscard]] constexpr logic operator[](logic lhs, logic rhs) const noexcept
     {
         auto tmp = _table;
@@ -58,13 +82,12 @@ struct logic_binary_truth_table {
         tmp &= 0b11;
         return static_cast<logic>(tmp);
     }
-};
-
-struct logic_unary_truth_table {
-    uint8_t _table;
-
-    [[nodiscard]] constexpr logic_unary_truth_table(char const str[5]) : _table(make_logic_truth_table<4>(str)) {}
 
+    /** Extract a value from the table.
+     * 
+     * @param lhs Index in the table.
+     * @return The value at the given index
+     */
     [[nodiscard]] constexpr logic operator[](logic rhs) const noexcept
     {
         auto tmp = _table;
@@ -107,7 +130,7 @@ struct logic_unary_truth_table {
  */
 [[nodiscard]] constexpr logic operator|(logic lhs, logic rhs) noexcept
 {
-    constexpr auto tt = logic_binary_truth_table{"01X-11X1XXXX-1X-"};
+    constexpr auto tt = logic_truth_table{"01X-11X1XXXX-1X-"};
     return tt[lhs, rhs];
 }
 
@@ -122,7 +145,7 @@ struct logic_unary_truth_table {
  */
 [[nodiscard]] constexpr logic operator&(logic lhs, logic rhs) noexcept
 {
-    constexpr auto tt = logic_binary_truth_table{"00X001X-XXXX0-X-"};
+    constexpr auto tt = logic_truth_table{"00X001X-XXXX0-X-"};
     return tt[lhs, rhs];
 }
 
@@ -137,7 +160,7 @@ struct logic_unary_truth_table {
  */
 [[nodiscard]] constexpr logic operator^(logic lhs, logic rhs) noexcept
 {
-    constexpr auto tt = logic_binary_truth_table{"01X-10X-XXXX--X-"};
+    constexpr auto tt = logic_truth_table{"01X-10X-XXXX--X-"};
     return tt[lhs, rhs];
 }
 
@@ -149,7 +172,7 @@ struct logic_unary_truth_table {
  */
 [[nodiscard]] constexpr logic operator~(logic rhs) noexcept
 {
-    constexpr auto tt = logic_unary_truth_table{"10X-"};
+    constexpr auto tt = logic_truth_table{"10X-"};
     return tt[rhs];
 }