value model

Author: takev

doc/language/syntax/attributes.md

@@ -4,26 +4,35 @@
 
 [_fqname_](fqname.md) __(__ `(` [_argument_list_](argument_list.md) `)` __)?__
 
+
 ## Semantics
 
 If the [_fqname_](fqname.md) is a single name,
 then this attribute is required. A required attribute must be handled by the compiler.
 If the compiler does not know how to handle the attribute it is an error.
 
-If the [_fqname_](fqname.md) has the `std` prefix
+If the [_fqname_](fqname.md) has the `std.` prefix
 it is a well-known optional attribute. These attributes don't change the semantic
 meaning of the program, instead they are directives to the compiler to create
 better code.
 
 Other prefixes are attributes that are handled by specific compilers. Compilers
 should ignore any attributes that do not match their own prefix.
 
-### abi()
+### abi(x)
 Make this function available for linking with an application written in a
 different language; using a different ABI (Application Binary Interface).
 
- - __c__: Use the C ABI.
- - __cpp__: Use the C++ ABI.
+On a type this will change how the memory layout is for an object.
+
+ - "c": Use the C ABI. (same as aligned)
+ - "c++": Use the C++ ABI. (same as aligned)
+ - "aligned": Keep members in a struct in given order, and align members.
+ - "reorder": Reorder members in a struct, pack while maintaining alignment. (default)
+ - "pack": Keep members in a struct in given order, ignore natural alignment of members. This will
+           cause member access to use possible slower, but valid, unaligned access.
+ - "compress": Use niche-mask to further compress members in a struct. Access to members may
+               require shifts and masks. 
 
 ### no_return
 This function will not return.
@@ -37,22 +46,24 @@ Pre-condition is checked before calling the function.
 ### post()
 Post-condition is checked after calling the function.
 
+A post-condition on a type will run after an object is modified.
+
 
 ### std.no_inline
 Calls to this function are never inlined.
 
 This is a strong optimization lever:
  - It reduces code size by not inlining the code, which will reduce
-   code-cache usage.
+   instruction-cache usage.
  - It significantly reduce register pressure, which will reduce the
    amount of reads/writes to memory. And may in turn reduce size of the
    code; which in turn may allow more inlining.
 
-### std.depricated, std.depricated()
+### std.depricated, std.depricated(msg)
 This function is depricated print a warning. A reason for deprication can
 be passed as a constant-string.
 
-### std.discard
+### std.discard, std.discard(msg)
 The return value of this function is allowed to be discarded by the caller.
 
 Discarding a return value is:

src/values/builtin_long.hpp

@@ -0,0 +1,20 @@
+
+#pragma once
+
+#include "symbol.hpp"
+#include <stdint.h>
+
+namespace hk::builtin {
+
+using int_reg_t = intptr_t;
+
+struct builtin_long : public symbol_type {
+    union {
+        int_reg_t value = 0;
+        int_reg_t *ptr;
+    };
+    uint32_t size = 0;
+    uint32_t capacity = 0;
+};
+
+}

src/values/builtin_long_interval.hpp

@@ -0,0 +1,14 @@
+
+#pragma once
+
+#include "long.hpp"
+
+namespace hk::builtin {
+
+struct long_interval : public symbol_type {
+    builtin_long lo;
+    builtin_long hi;
+};
+
+
+}

src/values/symbol.hpp

@@ -0,0 +1,31 @@
+
+#pragma once
+
+#include <memory>
+
+namespace hk {
+
+struct symbol_type;
+
+struct symbol_value_base {
+    virtual ~symbol_value_base() = default;
+
+    std::unique_ptr<symbol_type> type;
+};
+
+template<typename T>
+struct symbol_value : public symbol_value_base {
+    T value;
+};
+
+template<typename T>
+struct symbol_type : public symbol_value<T> {
+
+};
+
+struct symbol_instance {
+    symbol_type type;
+    symbol_value_base value;
+};
+
+}

src/values/symbol_table.cpp

@@ -1,18 +1,22 @@
 
 #include "symbol_table.hpp"
 #include "utility/algorithm.hpp"
+#include <algorithm>
 
 namespace hk {
 
-symbol_table::symbol_table(std::span<symbol_table const*> tables)
+symbol_table::symbol_table(std::span<symbol_table const*> tables) : _tables()
 {
-    auto tables_ = std::vector<container_type const*>{};
-    tables_.reserve(tables.size());
+    auto const size = std::accumulate(tables.begin(), tables.end(), 0uz, [](auto const& item) {
+        return item.size();
+    });
+    _tables.reserve(size)
+
     for (auto const& table : tables) {
-        tables_.push_back(std::addressof(table->_table));
+        _table.append_range(*table);
     }
 
-    multi_merge(tables_, _table);
+    std::sort(_tables.begin(), _tables.end());
 }
 
 hk::symbol *symbol_table::add(fqname name, std::shared_ptr<hk::symbol> symbol)