natalie_parser 1.0.0

data/include/tm/macros.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#define TM_UNREACHABLE()                                                      \
+    {                                                                         \
+        fprintf(stderr, "panic: unreachable in %s#%d\n", __FILE__, __LINE__); \
+        abort();                                                              \
+    }
+
+#define TM_NOT_YET_IMPLEMENTED(msg, ...)                                                          \
+    {                                                                                             \
+        fprintf(stderr, "NOT YET IMPLEMENTED in %s#%d: " msg, __FILE__, __LINE__, ##__VA_ARGS__); \
+        fprintf(stderr, "\n");                                                                    \
+        abort();                                                                                  \
+    }
+
+#define TM_UNUSED(var) (void)var

data/include/tm/optional.hpp

@@ -0,0 +1,223 @@
+#pragma once
+
+#include <assert.h>
+#include <stdio.h>
+
+namespace TM {
+
+template <typename T>
+class Optional {
+public:
+    /**
+     * Constructs a new Optional with a value.
+     *
+     * ```
+     * auto obj = Thing(1);
+     * auto opt = Optional<Thing>(obj);
+     * assert(opt);
+     * ```
+     */
+    Optional(T value)
+        : m_present { true }
+        , m_value { value } { }
+
+    /**
+     * Constructs a new Optional without a value.
+     *
+     * ```
+     * auto opt = Optional<Thing>();
+     * assert_not(opt);
+     * ```
+     */
+    Optional()
+        : m_present { false } { }
+
+    /**
+     * Copies the given Optional.
+     *
+     * ```
+     * auto obj = Thing(1);
+     * auto opt1 = Optional<Thing>(obj);
+     * auto opt2 = Optional<Thing>(opt1);
+     * assert_eq(obj, opt1.value());
+     * assert_eq(obj, opt2.value());
+     * ```
+     */
+    Optional(const Optional &other)
+        : m_present { other.m_present } {
+        if (m_present)
+            m_value = other.m_value;
+    }
+
+    ~Optional() {
+        clear();
+    }
+
+    /**
+     * Overwrites this Optional with the given one.
+     *
+     * ```
+     * auto obj1 = Thing(1);
+     * auto obj2 = Thing(2);
+     * auto opt1 = Optional<Thing>(obj1);
+     * auto opt2 = Optional<Thing>(obj2);
+     * opt1 = opt2;
+     * assert_eq(obj2, opt1.value());
+     * assert_eq(obj2, opt2.value());
+     * ```
+     */
+    Optional<T> &operator=(const Optional<T> &other) {
+        m_present = other.m_present;
+        if (m_present)
+            m_value = other.m_value;
+        return *this;
+    }
+
+    /**
+     * Overwrites this Optional with the given moved value.
+     *
+     * ```
+     * auto obj1 = Thing(1);
+     * auto obj2 = Thing(2);
+     * auto opt = Optional<Thing>(obj1);
+     * opt = std::move(obj2);
+     * assert_eq(obj2, opt.value());
+     * ```
+     */
+    Optional<T> &operator=(T &&value) {
+        m_present = true;
+        m_value = value;
+        return *this;
+    }
+
+    /**
+     * Returns a reference to the underlying value.
+     *
+     * ```
+     * auto obj = Thing(1);
+     * auto opt = Optional<Thing>(obj);
+     * assert_eq(obj, opt.value());
+     * ```
+     *
+     * This method aborts if the value not present.
+     *
+     * ```should_abort
+     * auto opt = Optional<Thing>();
+     * opt.value();
+     * ```
+     */
+    T &value() {
+        assert(m_present);
+        return m_value;
+    }
+
+    /**
+     * Returns a reference to the underlying value.
+     *
+     * ```
+     * auto obj = Thing(1);
+     * auto opt = Optional<Thing>(obj);
+     * assert_eq(obj, opt.value());
+     * ```
+     *
+     * This method aborts if the value not present.
+     *
+     * ```should_abort
+     * auto opt = Optional<Thing>();
+     * opt.value();
+     * ```
+     */
+    T const &value() const {
+        assert(m_present);
+        return m_value;
+    }
+
+    /**
+     * Returns a reference to the underlying value or
+     * the given fallback value.
+     *
+     * ```
+     * auto obj = Thing(1);
+     * auto opt = Optional<Thing>(obj);
+     * assert_eq(Thing(1), opt.value_or(Thing(2)));
+     * ```
+     *
+     * If we don't have a value present, then the fallback
+     * is returned.
+     *
+     * ```
+     * auto opt = Optional<Thing>();
+     * assert_eq(Thing(2), opt.value_or(Thing(2)));
+     * ```
+     */
+    T const &value_or(const T &fallback) const {
+        if (present())
+            return value();
+        else
+            return fallback;
+    }
+
+    /**
+     * Returns a reference to the underlying value.
+     *
+     * ```
+     * auto obj = Thing(1);
+     * auto opt = Optional<Thing>(obj);
+     * assert_eq(obj, *opt);
+     * ```
+     *
+     * This method aborts if the value not present.
+     *
+     * ```should_abort
+     * auto opt = Optional<Thing>();
+     * *opt;
+     * ```
+     */
+    T operator*() {
+        assert(m_present);
+        return m_value;
+    }
+
+    /**
+     * Sets the Optional to not present.
+     *
+     * ```
+     * auto opt = Optional<Thing>(Thing(1));
+     * assert(opt);
+     * opt.clear();
+     * assert_not(opt);
+     * ```
+     */
+    void clear() { m_present = false; }
+
+    /**
+     * Returns true if the Optional contains a value.
+     *
+     * ```
+     * auto opt1 = Optional<Thing>(Thing(1));
+     * auto opt2 = Optional<Thing>();
+     * assert(opt1);
+     * assert_not(opt2);
+     * ```
+     */
+    operator bool() const { return m_present; }
+
+    /**
+     * Returns true if the Optional contains a value.
+     *
+     * ```
+     * auto opt1 = Optional<Thing>(Thing(1));
+     * auto opt2 = Optional<Thing>();
+     * assert(opt1.present());
+     * assert_not(opt2.present());
+     * ```
+     */
+    bool present() const { return m_present; }
+
+private:
+    bool m_present;
+
+    T m_value {};
+};
+
+}

data/include/tm/owned_ptr.hpp

@@ -0,0 +1,186 @@
+#pragma once
+
+#include <assert.h>
+
+namespace TM {
+
+template <typename T>
+class OwnedPtr {
+public:
+    /**
+     * Constructs a null OwnedPtr.
+     *
+     * ```
+     * auto ptr = OwnedPtr<Thing>();
+     * assert(!ptr);
+     * ```
+     */
+    OwnedPtr()
+        : m_ptr { nullptr } { }
+
+    /**
+     * Constructs an OwnedPtr with the given raw pointer.
+     *
+     * ```
+     * auto ptr = OwnedPtr<Thing>(new Thing(1));
+     * assert(ptr);
+     * ```
+     *
+     * Alternative syntax:
+     *
+     * ```
+     * OwnedPtr<Thing> ptr = new Thing(1);
+     * assert(ptr);
+     * ```
+     */
+    OwnedPtr(T *ptr)
+        : m_ptr { ptr } { }
+
+    ~OwnedPtr() {
+        delete m_ptr;
+    }
+
+    OwnedPtr(const OwnedPtr &other) = delete;
+
+    /**
+     * Moves the given OwnedPtr's raw pointer into a
+     * new OwnedPtr and invalidates the old one
+     * (sets it to nullptr).
+     *
+     * ```
+     * OwnedPtr<Thing> obj1 = new Thing(1);
+     * OwnedPtr<Thing> obj2 = std::move(obj1);
+     * assert(!obj1);
+     * assert(obj2);
+     * ```
+     */
+    OwnedPtr(OwnedPtr &&other)
+        : m_ptr { other.m_ptr } {
+        other.m_ptr = nullptr;
+    }
+
+    /**
+     * Overwrites this OwnedPtr with a new raw pointer,
+     * destroying our existing held object, if any.
+     *
+     * ```
+     * auto obj1 = new Thing(1);
+     * auto ptr = OwnedPtr<Thing>(obj1);
+     * ptr = new Thing(2);
+     * // obj1 has been destroyed
+     * ```
+     */
+    OwnedPtr<T> &operator=(T *ptr) {
+        if (ptr != m_ptr)
+            delete m_ptr;
+        m_ptr = ptr;
+        return *this;
+    }
+
+    OwnedPtr<T> &operator=(const OwnedPtr<T> &other) = delete;
+
+    /**
+     * Returns true if this OwnedPtr is not null.
+     *
+     * ```
+     * auto ptr1 = OwnedPtr<Thing>(new Thing(1));
+     * auto ptr2 = OwnedPtr<Thing>();
+     * assert(ptr1);
+     * assert(!ptr2);
+     * ```
+     */
+    operator bool() const {
+        return !!m_ptr;
+    }
+
+    /**
+     * Returns a reference to the underlying raw pointer.
+     *
+     * ```
+     * auto raw = new Thing(1);
+     * auto ptr = OwnedPtr<Thing>(raw);
+     * assert_eq(*raw, *ptr);
+     * ```
+     *
+     * This method aborts if the pointer is null.
+     *
+     * ```should_abort
+     * auto ptr = OwnedPtr<Thing>();
+     * *ptr;
+     * ```
+     */
+    const T &operator*() const {
+        assert(m_ptr);
+        return *m_ptr;
+    }
+
+    /**
+     * Returns a reference to the underlying raw pointer.
+     *
+     * ```
+     * auto raw = new Thing(1);
+     * auto ptr = OwnedPtr<Thing>(raw);
+     * assert_eq(*raw, ptr.ref());
+     * ```
+     *
+     * This method aborts if the pointer is null.
+     *
+     * ```should_abort
+     * auto ptr = OwnedPtr<Thing>();
+     * ptr.ref();
+     * ```
+     */
+    T &ref() const {
+        assert(m_ptr);
+        return *m_ptr;
+    }
+
+    /**
+     * Dereferences the underlying raw pointer for
+     * chained member reference.
+     *
+     * ```
+     * auto raw = new Thing(1);
+     * auto ptr = OwnedPtr<Thing>(raw);
+     * assert_eq(1, ptr->value());
+     * ```
+     *
+     * This method aborts if the pointer is null.
+     *
+     * ```should_abort
+     * auto ptr = OwnedPtr<Thing>();
+     * ptr->value();
+     * ```
+     */
+    T *operator->() const {
+        assert(m_ptr);
+        return m_ptr;
+    }
+
+    /**
+     * Returns the underlying raw pointer and
+     * releases ownership. When this OwnedPtr is
+     * destroyed later, the underlying pointer will
+     * not be deleted.
+     *
+     * ```
+     * Thing *ptr;
+     * {
+     *     OwnedPtr<Thing> op = new Thing(1);
+     *     ptr = op.release();
+     * }
+     * assert(ptr);
+     * delete ptr;
+     * ```
+     */
+    T *release() {
+        auto ptr = m_ptr;
+        m_ptr = nullptr;
+        return ptr;
+    }
+
+private:
+    T *m_ptr;
+};
+
+}

data/include/tm/recursion_guard.hpp

@@ -0,0 +1,156 @@
+#pragma once
+
+#include "tm/defer.hpp"
+#include "tm/hashmap.hpp"
+#include <assert.h>
+
+namespace TM {
+
+class RecursionGuard {
+public:
+    /**
+     * Constructs a new RecursionGuard that guards against
+     * calling the same code recursively in relation to the given
+     * object pointer.
+     *
+     * ```
+     * auto obj = Thing(1);
+     * RecursionGuard guard { &obj };
+     * ```
+     */
+    RecursionGuard(void *instance)
+        : m_instance { instance } {
+        assert(m_instance);
+    }
+
+    /**
+     * Runs the given lambda or callable type, passing boolean true
+     * if the object was seen already.
+     *
+     * ```
+     * auto obj = Thing(1);
+     * RecursionGuard guard { &obj };
+     *
+     * guard.run([&](bool is_recursive) {
+     *     if (is_recursive) {
+     *         printf("recursive!\n");
+     *     } else {
+     *         printf("normal work here, possibly recursive\n");
+     *     }
+     * });
+     * ```
+     */
+    template <typename F>
+    auto run(F callback) {
+        if (seen())
+            return callback(true);
+
+        mark();
+        Defer on_close([&]() { clear(); });
+        return callback(false);
+    }
+
+private:
+    void *m_instance { nullptr };
+
+    bool seen() {
+        return s_did_run.get(m_instance) != nullptr;
+    }
+
+    void mark() {
+        s_did_run.set(m_instance);
+    }
+
+    void clear() {
+        s_did_run.remove(m_instance);
+    }
+
+    static inline TM::Hashmap<void *> s_did_run {};
+};
+
+class PairedRecursionGuard {
+public:
+    /**
+     * Constructs a new PairedRecursionGuard that guards against
+     * calling the same code recursively in relation to the given
+     * two object pointers. This guards against mutual recursion.
+     *
+     * ```
+     * auto obj1 = Thing(1);
+     * auto obj2 = Thing(2);
+     * PairedRecursionGuard guard { &obj1, &obj2 };
+     * ```
+     */
+    PairedRecursionGuard(void *instance, void *other_instance)
+        : m_instance { instance }
+        , m_other_instance { other_instance } {
+        assert(m_instance);
+        assert(m_other_instance);
+    }
+
+    /**
+     * Runs the given lambda or callable type, passing boolean true
+     * if the object pair was seen already.
+     *
+     * ```
+     * auto obj1 = Thing(1);
+     * auto obj2 = Thing(2);
+     * PairedRecursionGuard guard { &obj1, &obj2 };
+     *
+     * guard.run([&](bool is_recursive) {
+     *     if (is_recursive) {
+     *         printf("recursive!\n");
+     *     } else {
+     *         printf("normal work here, possibly recursive\n");
+     *     }
+     * });
+     * ```
+     */
+    template <typename F>
+    auto run(F callback) {
+        if (seen())
+            return callback(true);
+
+        mark();
+        Defer on_close([&]() { clear(); });
+        return callback(false);
+    }
+
+private:
+    void *m_instance { nullptr };
+    void *m_other_instance { nullptr };
+
+    bool seen() {
+        auto companions = s_did_run.get(m_instance);
+        if (!companions)
+            return false;
+        return companions->get(m_other_instance) != nullptr;
+    }
+
+    void mark() {
+        auto companions = s_did_run.get(m_instance);
+        if (!companions) {
+            companions = new TM::Hashmap<void *> {};
+            s_did_run.put(m_instance, companions);
+        }
+        companions->set(m_other_instance);
+        return;
+    }
+
+    void clear() {
+        auto companions = s_did_run.get(m_instance);
+        if (!companions) {
+            s_did_run.remove(m_instance);
+            return;
+        }
+        companions->remove(m_other_instance);
+        if (companions->is_empty()) {
+            delete companions;
+            s_did_run.remove(m_instance);
+        }
+    }
+
+    static inline TM::Hashmap<void *, TM::Hashmap<void *> *> s_did_run {};
+};
+
+}