Add code for absint

Author: UplinkCoder

semantic/absint.c

@@ -0,0 +1 @@
+#include "metac_value_table.c"

semantic/metac_value_table.c

@@ -0,0 +1,134 @@
+#include "metac_value_table.h"
+
+const metac_node_ptr_t empty_node = {~0u};
+
+static inline bool IsFilled(metac_value_table_slot_t slot)
+{
+    return slot.HashKey != 0;
+}
+
+void ValueTable_Init_(metac_value_table_t* table, uint32_t slotCountLog2, metac_alloc_t* alloc,
+                      const char* file, uint32_t line)
+{
+    table->SlotCount_Log2 = slotCountLog2;
+    const uint32_t maxSlots = (1 << table->SlotCount_Log2);
+    table->Slots = cast(metac_value_table_slot_t*)
+        Allocator_Calloc_(alloc, sizeof(metac_value_table_slot_t), maxSlots, file, line);
+    table->SlotsUsed = 0;
+ 
+
+void ValueTable_Free(metac_value_table_t* table)
+{
+    static const metac_value_table_t zeroTable = {0};
+    (*table) = zeroTable;
+}
+
+metac_node_ptr_t GetOrAddValue(metac_value_table_t* table, metac_node_ptr_t keyNode, metac_node_ptr_t valueNode)
+{
+    metac_node_ptr_t result = {0};
+
+    const uint32_t slotIndexMask = ((1 << table->SlotCount_Log2) - 1);
+    const uint32_t initialSlotIndex = (keyNodeHash & slotIndexMask);
+    uint32_t displacement = 0;
+
+    for (uint32_t slotIndex = initialSlotIndex; (++slotIndex & slotIndexMask) != initialSlotIndex;)
+    {
+        metac_value_table_slot_t* slot = &table->Slots[(slotIndex - 1) & slotIndexMask];
+
+        if (slot->HashKey == keyNodeHash)
+        {
+            if (slot->KeyNode.v == keyNode.v)
+            {
+                result = slot->ValueNode;
+#ifdef REFCOUNT
+                slot->RefCount++;
+#endif
+                break;
+            }
+        }
+        else if (slot->HashKey == 0)
+        {
+            result = valueNode;
+            slot->HashKey = keyNodeHash;
+            slot->KeyNode = keyNode;
+            slot->ValueNode = valueNode;
+#ifdef REFCOUNT
+            slot->RefCount = 1;
+            slot->Displacement = displacement;
+#endif
+            table->SlotsUsed++;
+            break;
+        }
+        displacement++;
+    }
+    return result;
+}
+
+int32_t ValueTable_HasKey(metac_value_table_t* table, uint32_t keyNodeHash, metac_node_ptr_t keyNode)
+{
+    int32_t result = -1;
+    const uint32_t slotIndexMask = ((1 << table->SlotCount_Log2) - 1);
+    const uint32_t initialSlotIndex = (keyNodeHash & slotIndexMask);
+
+    for (uint32_t slotIndex = initialSlotIndex; (++slotIndex & slotIndexMask) != initialSlotIndex;)
+    {
+        int32_t idx = (int32_t)((slotIndex - 1) & slotIndexMask);
+        metac_value_table_slot_t slot = table->Slots[idx];
+
+        if (slot.HashKey == 0)
+            break;
+        if (slot.HashKey == keyNodeHash && slot.KeyNode.v == keyNode.v)
+        {
+            result = idx;
+            break;
+        }
+    }
+
+    return result;
+}
+
+metac_node_ptr_t IsValueInTable(metac_value_table_t* table, uint32_t keyNodeHash, metac_node_ptr_t keyNode)
+{
+    metac_node_ptr_t result = {0};
+    const uint32_t slotIndexMask = ((1 << table->SlotCount_Log2) - 1);
+    const uint32_t initialSlotIndex = (keyNodeHash & slotIndexMask);
+
+    for (uint32_t slotIndex = initialSlotIndex; (++slotIndex & slotIndexMask) != initialSlotIndex;)
+    {
+        metac_value_table_slot_t slot = table->Slots[(slotIndex - 1) & slotIndexMask];
+
+        if (slot.HashKey == 0)
+            return result;
+        if (slot.HashKey == keyNodeHash && slot.KeyNode.v == keyNode.v)
+        {
+            result = slot.ValueNode;
+            return result;
+        }
+    }
+
+    return result;
+}
+
+metac_value_table_slot_t* ValueTableLookup(metac_value_table_t* table, uint32_t keyNodeHash, metac_node_ptr_t keyNode, metac_node_ptr_t valueNode)
+{
+    const uint32_t slotIndexMask = ((1 << table->SlotCount_Log2) - 1);
+    const uint32_t initialSlotIndex = (keyNodeHash & slotIndexMask);
+
+    for (uint32_t slotIndex = initialSlotIndex; (++slotIndex & slotIndexMask) != initialSlotIndex;)
+    {
+        uint32_t lookupIdx = (slotIndex - 1) & slotIndexMask;
+        metac_value_table_slot_t slot = table->Slots[lookupIdx];
+
+        if (slot.HashKey == 0)
+            return 0;
+        if (slot.HashKey == keyNodeHash && slot.KeyNode.v == keyNode.v && slot.ValueNode.v == valueNode.v)
+            return table->Slots + lookupIdx;
+    }
+
+    return 0;
+}
+
+bool IsInValueTable(metac_value_table_t* table, uint32_t keyNodeHash, metac_node_ptr_t keyNode, metac_node_ptr_t valueNode)
+{
+    return ValueTableLookup(table, keyNodeHash, keyNode, valueNode) != 0;
+}

semantic/metac_value_table.h

@@ -0,0 +1,51 @@
+#ifndef _METAC_VALUE_TABLE_H_
+#define _METAC_VALUE_TABLE_H_
+#include "../parser/metac_node.h"
+
+typedef struct metac_alloc_t metac_alloc_t;
+
+// Define a generic metac_node_ptr_t structure to hold metac_node_t mappings
+typedef struct metac_node_ptr_t
+{
+    uint32_t v;
+} metac_node_ptr_t;
+
+extern const metac_node_ptr_t empty_node;
+
+// The slot structure stores the mapping from one metac_node_t to another
+typedef struct metac_value_table_slot_t
+{
+    metac_node_t KeyNode;   // The key node in the mapping
+    metac_node_t ValueNode; // The value node it maps to
+
+#ifdef REFCOUNT
+    uint32_t RefCount;          // Optional reference counting
+    uint32_t Displacement;      // Displacement for handling hash collisions
+#endif
+} metac_value_table_slot_t;
+
+// The main table structure that holds the slots and manages memory
+typedef struct metac_value_table_t
+{
+    metac_value_table_slot_t* Slots;   // Array of slots for storing mappings
+    uint32_t SlotCount_Log2;           // Log2 of the number of slots (for hashing)
+    uint32_t SlotsUsed;                // Number of slots currently used
+
+    metac_alloc_t* Allocator;          // Allocator used for managing table memory
+} metac_value_table_t;
+
+#pragma pack(push, 1)
+// File header structure to represent the value table in a serialized form
+typedef struct value_table_file_header_t
+{
+    uint32_t NumberOfSlots;       // Total number of slots
+    uint32_t SizeofSlot;          // Size of each slot
+    uint32_t OffsetSlots;         // Offset to the slots in the file
+    uint32_t OffsetValues;        // Offset to the value nodes in the file
+
+    uint32_t Version;             // Version of the serialized format
+    uint32_t LengthShift;         // Shift used to determine table growth
+    uint32_t HeaderCommentSize;   // Size of any comments or metadata in the header
+} value_table_file_header_t;
+#pragma pack(pop)
+#endif