tpy-lang 0.3.0.dev0__py3-none-any.whl

tpyc/_data/runtime/cpp/include/tpy/uninit_heap_storage.hpp

@@ -0,0 +1,277 @@
+/**
+ * TurboPython Runtime - UninitHeapStorage
+ *
+ * Heap-allocated uninitialized storage for T elements.
+ * Allocates raw memory for `capacity` elements via ::operator new.
+ * Caller is responsible for managing element lifetimes via
+ * construct() / destroy().
+ *
+ * Non-copyable but movable: copy would alias heap memory, move transfers ownership.
+ * To grow: allocate new storage, move elements over, destroy old, move-assign.
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <new>
+#include <span>
+#include <type_traits>
+#include <utility>
+
+#include "core.hpp"
+
+#ifndef NDEBUG
+#include <vector>
+#endif
+
+namespace tpy {
+
+template <typename T>
+class UninitHeapStorage {
+public:
+    UninitHeapStorage(uint32_t capacity)
+        : data_(static_cast<T*>(::operator new(sizeof(T) * capacity, std::align_val_t(alignof(T)))))
+        , capacity_(capacity)
+#ifndef NDEBUG
+        , alive_(capacity, false)
+#endif
+    {}
+
+    ~UninitHeapStorage() {
+#ifndef NDEBUG
+        for (std::size_t i = 0; i < capacity_; ++i) {
+            if (alive_[i]) {
+                tpy_panic("UninitHeapStorage destroyed with live elements");
+            }
+        }
+#endif
+        if (data_) {
+            ::operator delete(data_, std::align_val_t(alignof(T)));
+        }
+    }
+
+    // Non-copyable
+    UninitHeapStorage(const UninitHeapStorage&) = delete;
+    UninitHeapStorage& operator=(const UninitHeapStorage&) = delete;
+
+    // Movable (transfers ownership, source becomes empty)
+    UninitHeapStorage(UninitHeapStorage&& other) noexcept
+        : data_(other.data_)
+        , capacity_(other.capacity_)
+#ifndef NDEBUG
+        , alive_(std::move(other.alive_))
+#endif
+    {
+        other.data_ = nullptr;
+        other.capacity_ = 0;
+    }
+
+    UninitHeapStorage& operator=(UninitHeapStorage&& other) noexcept {
+        if (this != &other) {
+#ifndef NDEBUG
+            for (std::size_t i = 0; i < capacity_; ++i) {
+                if (alive_[i]) {
+                    tpy_panic("UninitHeapStorage move-assigned with live elements");
+                }
+            }
+#endif
+            if (data_) {
+                ::operator delete(data_, std::align_val_t(alignof(T)));
+            }
+            data_ = other.data_;
+            capacity_ = other.capacity_;
+#ifndef NDEBUG
+            alive_ = std::move(other.alive_);
+#endif
+            other.data_ = nullptr;
+            other.capacity_ = 0;
+        }
+        return *this;
+    }
+
+    void init(uint32_t i, T&& value) {
+#ifndef NDEBUG
+        if (i >= capacity_) {
+            tpy_panic("UninitHeapStorage::init index out of bounds");
+        }
+        if (alive_[i]) {
+            tpy_panic("UninitHeapStorage::init on already-alive slot");
+        }
+        alive_[i] = true;
+#endif
+        ::new (static_cast<void*>(&data_[i])) T(std::move(value));
+    }
+
+    void init(uint32_t i, const T& value) {
+#ifndef NDEBUG
+        if (i >= capacity_) {
+            tpy_panic("UninitHeapStorage::init index out of bounds");
+        }
+        if (alive_[i]) {
+            tpy_panic("UninitHeapStorage::init on already-alive slot");
+        }
+        alive_[i] = true;
+#endif
+        ::new (static_cast<void*>(&data_[i])) T(value);
+    }
+
+    void init0(T&& value) { init(0, std::move(value)); }
+    void init0(const T& value) { init(0, value); }
+
+    void drop(uint32_t i) {
+#ifndef NDEBUG
+        if (i >= capacity_) {
+            tpy_panic("UninitHeapStorage::drop index out of bounds");
+        }
+        if (!alive_[i]) {
+            tpy_panic("UninitHeapStorage::drop on dead slot");
+        }
+        alive_[i] = false;
+#endif
+        data_[i].~T();
+    }
+
+    void drop0() { drop(0); }
+
+    T& load(uint32_t i) {
+#ifndef NDEBUG
+        if (i >= capacity_) {
+            tpy_panic("UninitHeapStorage::load index out of bounds");
+        }
+        if (!alive_[i]) {
+            tpy_panic("UninitHeapStorage::load on dead slot");
+        }
+#endif
+        return data_[i];
+    }
+
+    const T& load(uint32_t i) const {
+#ifndef NDEBUG
+        if (i >= capacity_) {
+            tpy_panic("UninitHeapStorage::load index out of bounds");
+        }
+        if (!alive_[i]) {
+            tpy_panic("UninitHeapStorage::load on dead slot");
+        }
+#endif
+        return data_[i];
+    }
+
+    T& load0() { return load(0); }
+    const T& load0() const { return load(0); }
+
+    T take(uint32_t i) {
+#ifndef NDEBUG
+        if (i >= capacity_) {
+            tpy_panic("UninitHeapStorage::take index out of bounds");
+        }
+        if (!alive_[i]) {
+            tpy_panic("UninitHeapStorage::take on dead slot");
+        }
+        alive_[i] = false;
+#endif
+        T result = std::move(data_[i]);
+        data_[i].~T();
+        return result;
+    }
+
+    T take0() { return take(0); }
+
+    T* ptr() { return data_; }
+    const T* ptr() const { return data_; }
+
+    uint32_t capacity() const { return capacity_; }
+
+    void init_from_span(uint32_t start, std::span<const T> src) {
+#ifndef NDEBUG
+        if (start + src.size() > capacity_) {
+            tpy_panic("UninitHeapStorage::init_from_span: span exceeds capacity");
+        }
+        for (std::size_t i = 0; i < src.size(); ++i) {
+            if (alive_[start + i]) {
+                tpy_panic("UninitHeapStorage::init_from_span on already-alive slot");
+            }
+            alive_[start + i] = true;
+        }
+#endif
+        if constexpr (std::is_trivially_copyable_v<T>) {
+            std::memcpy(static_cast<void*>(&data_[start]), src.data(), src.size() * sizeof(T));
+        } else {
+            for (std::size_t i = 0; i < src.size(); ++i) {
+                ::new (static_cast<void*>(&data_[start + i])) T(src[i]);
+            }
+        }
+    }
+
+    void drop_n(uint32_t start, uint32_t count) {
+#ifndef NDEBUG
+        for (uint32_t i = 0; i < count; ++i) {
+            uint32_t idx = start + i;
+            if (idx >= capacity_) {
+                tpy_panic("UninitHeapStorage::drop_n index out of bounds");
+            }
+            if (!alive_[idx]) {
+                tpy_panic("UninitHeapStorage::drop_n on dead slot");
+            }
+            alive_[idx] = false;
+        }
+#endif
+        if constexpr (!std::is_trivially_destructible_v<T>) {
+            for (uint32_t i = 0; i < count; ++i) {
+                data_[start + i].~T();
+            }
+        }
+    }
+
+    void shift(uint32_t src, uint32_t dst, uint32_t count) {
+        if (count == 0 || src == dst) return;
+#ifndef NDEBUG
+        for (uint32_t i = 0; i < count; ++i) {
+            if (src + i >= capacity_ || dst + i >= capacity_) {
+                tpy_panic("UninitHeapStorage::shift index out of bounds");
+            }
+            if (!alive_[src + i]) {
+                tpy_panic("UninitHeapStorage::shift on dead source slot");
+            }
+        }
+        for (uint32_t i = 0; i < count; ++i) {
+            alive_[src + i] = false;
+        }
+        for (uint32_t i = 0; i < count; ++i) {
+            alive_[dst + i] = true;
+        }
+#endif
+        if constexpr (std::is_trivially_copyable_v<T>) {
+            std::memmove(static_cast<void*>(&data_[dst]),
+                         static_cast<const void*>(&data_[src]),
+                         static_cast<std::size_t>(count) * sizeof(T));
+        } else if (dst < src) {
+            for (uint32_t i = 0; i < count; ++i) {
+                ::new (static_cast<void*>(&data_[dst + i]))
+                    T(std::move(data_[src + i]));
+                data_[src + i].~T();
+            }
+        } else {
+            for (uint32_t i = count; i > 0; --i) {
+                uint32_t idx = i - 1;
+                ::new (static_cast<void*>(&data_[dst + idx]))
+                    T(std::move(data_[src + idx]));
+                data_[src + idx].~T();
+            }
+        }
+    }
+
+    // TODO: emplace(i, args...) for perfect-forwarding construction
+
+private:
+    T* data_;
+    uint32_t capacity_;
+
+#ifndef NDEBUG
+    std::vector<bool> alive_;
+#endif
+};
+
+} // namespace tpy

tpyc/_data/runtime/cpp/include/tpy/varargs.hpp

@@ -0,0 +1,174 @@
+/**
+ * TurboPython Runtime - varargs<T>
+ *
+ * Span-like view for *args parameters.
+ *
+ * Value types (is_value_type_v<T>): thin wrapper around contiguous T storage.
+ *   No indirection, no branches -- equivalent to std::span<T>.
+ *
+ * Non-value types: dual-mode view.
+ *   Direct mode: contiguous T storage (*list unpacking into vector/array).
+ *   Indirect mode: T* pointer array (individual args packed by address).
+ *   operator[] returns T& in both modes.
+ */
+
+#pragma once
+
+#include "type_traits.hpp"
+
+#include <array>
+#include <cstdint>
+#include <span>
+
+namespace tpy {
+
+// Primary template: non-value types (dual-mode)
+template<typename T, bool IsValue = is_value_type_v<T>>
+struct varargs {
+    T* direct_ = nullptr;
+    T* const* indirect_ = nullptr;
+    int32_t size_ = 0;
+
+    varargs() = default;
+
+    // Direct mode: contiguous T storage (*list unpacking)
+    varargs(std::span<T> s) : direct_(s.data()), size_(static_cast<int32_t>(s.size())) {}
+
+    template<size_t N>
+    varargs(std::array<T, N>& arr) : direct_(arr.data()), size_(static_cast<int32_t>(N)) {}
+
+    // Indirect mode: pointer array (individual args)
+    template<size_t N>
+    varargs(std::array<T*, N>& arr) : indirect_(arr.data()), size_(static_cast<int32_t>(N)) {}
+
+    // Readonly view of a mutable varargs<U> -- forwarding `*xs` where `xs` is a
+    // mutable `*args` param into a `readonly[...]` vararg. Present only when T
+    // is const. The pointer-array conversion (`U* const*` -> `const U* const*`,
+    // i.e. `T* const*`) is a plain implicit qualification conversion -- legal
+    // because the enclosing pointer level is already const -- not a reinterpret.
+    template<typename U = T, std::enable_if_t<std::is_const_v<U>, int> = 0>
+    varargs(const varargs<std::remove_const_t<U>>& o)
+        : direct_(o.direct_),
+          indirect_(o.indirect_),
+          size_(o.size_) {}
+
+    T& operator[](int32_t i) const {
+        return indirect_ ? *indirect_[i] : direct_[i];
+    }
+
+    int32_t size() const { return size_; }
+    bool empty() const { return size_ == 0; }
+
+    // Python-style slice preserving direct-vs-indirect mode. Returns another
+    // varargs of the same instantiation with adjusted pointers + size -- the
+    // only correct shape, since indirect-mode storage (`T* const*`) cannot be
+    // exposed as `std::span<T>`. Indices follow Python clamp semantics.
+    varargs slice(int32_t start, int32_t stop) const {
+        int32_t i = start;
+        int32_t j = stop;
+        if (i < 0) i += size_;
+        if (j < 0) j += size_;
+        if (i < 0) i = 0;
+        if (j < 0) j = 0;
+        if (i > size_) i = size_;
+        if (j > size_) j = size_;
+        varargs r;
+        if (i >= j) return r;
+        r.size_ = j - i;
+        if (direct_) r.direct_ = direct_ + i;
+        if (indirect_) r.indirect_ = indirect_ + i;
+        return r;
+    }
+
+    struct iterator {
+        T* direct_;
+        T* const* indirect_;
+
+        T& operator*() const { return indirect_ ? **indirect_ : *direct_; }
+
+        iterator& operator++() {
+            if (indirect_) ++indirect_; else ++direct_;
+            return *this;
+        }
+
+        bool operator==(const iterator& o) const {
+            return indirect_ ? indirect_ == o.indirect_ : direct_ == o.direct_;
+        }
+        bool operator!=(const iterator& o) const { return !(*this == o); }
+    };
+
+    iterator begin() const { return {direct_, indirect_}; }
+    iterator end() const {
+        return {direct_ ? direct_ + size_ : nullptr,
+                indirect_ ? indirect_ + size_ : nullptr};
+    }
+};
+
+// Value type specialization: direct only, no indirection overhead
+template<typename T>
+struct varargs<T, true> {
+    T* data_ = nullptr;
+    int32_t size_ = 0;
+
+    varargs() = default;
+
+    varargs(std::span<T> s) : data_(s.data()), size_(static_cast<int32_t>(s.size())) {}
+
+    template<size_t N>
+    varargs(std::array<T, N>& arr) : data_(arr.data()), size_(static_cast<int32_t>(N)) {}
+
+    // Readonly view of a mutable value-type varargs<U> (forwarding into a
+    // `readonly[...]` value-type vararg). Present only when T is const.
+    template<typename U = T, std::enable_if_t<std::is_const_v<U>, int> = 0>
+    varargs(const varargs<std::remove_const_t<U>>& o)
+        : data_(o.data_), size_(o.size_) {}
+
+    T& operator[](int32_t i) const { return data_[i]; }
+    int32_t size() const { return size_; }
+    bool empty() const { return size_ == 0; }
+    T* data() const { return data_; }
+
+    using iterator = T*;
+    T* begin() const { return data_; }
+    T* end() const { return data_ + size_; }
+};
+
+template<typename T, bool V>
+int32_t __len__(const varargs<T, V>& v) { return v.size(); }
+
+template<typename T, bool V>
+T& __getitem__(const varargs<T, V>& v, int32_t i) { return v[i]; }
+
+} // namespace tpy
+
+#include "container_ops.hpp"
+
+namespace tpy {
+
+// list_slice on a non-value varargs returns another varargs (preserving
+// direct-vs-indirect mode), not std::span<T> -- the generic Container
+// list_slice in container_ops.hpp would call `c.data()` which non-value
+// varargs intentionally doesn't expose (indirect storage is `T* const*`,
+// not contiguous T). The value-type varargs path stays on the generic
+// template via its own `data()` (defined in the value-type specialization).
+template<typename T>
+varargs<T, false> list_slice(varargs<T, false>& c, int32_t start, int32_t stop) {
+    return c.slice(start, stop);
+}
+
+template<typename T>
+varargs<T, false> list_slice(const varargs<T, false>& c, int32_t start, int32_t stop) {
+    return c.slice(start, stop);
+}
+
+template<typename T>
+varargs<T, false> list_slice(varargs<T, false>& c, BasicSlice sl) {
+    return c.slice(sl.start.value_or(0), sl.stop.value_or(SLICE_END));
+}
+
+template<typename T>
+varargs<T, false> list_slice(const varargs<T, false>& c, BasicSlice sl) {
+    return c.slice(sl.start.value_or(0), sl.stop.value_or(SLICE_END));
+}
+
+} // namespace tpy

tpyc/_data/runtime/cpp/include/tpy/variant_ref.hpp

@@ -0,0 +1,118 @@
+/**
+ * Pointer-variant utilities for non-value union types.
+ *
+ * Non-value unions (e.g. Dog | Cat where members are records) use a two-layer
+ * representation:
+ *   - Storage: std::variant<Dog, Cat>        (owns values)
+ *   - Reference: std::variant<Dog*, Cat*>    (borrows values)
+ *
+ * to_ptr_variant() converts a storage variant reference into a pointer variant.
+ * std::monostate members (representing None in nullable unions) pass through.
+ */
+
+#pragma once
+
+#include <variant>
+#include <type_traits>
+
+namespace tpy {
+
+namespace detail {
+
+// Map T -> T*, but monostate -> monostate
+template<typename T>
+struct ptr_of { using type = T*; };
+
+template<>
+struct ptr_of<std::monostate> { using type = std::monostate; };
+
+// Map T -> const T*, but monostate -> monostate
+template<typename T>
+struct const_ptr_of { using type = const T*; };
+
+template<>
+struct const_ptr_of<std::monostate> { using type = std::monostate; };
+
+// Try to convert alternative I: if active, emplace pointer into result.
+// Returns true (short-circuits fold) on match.
+template<std::size_t I, typename Result, typename Variant>
+bool try_emplace_ptr(Result& r, Variant& v) {
+    if (v.index() != I) return false;
+    using Alt = std::variant_alternative_t<I, std::remove_cvref_t<Variant>>;
+    if constexpr (std::is_same_v<Alt, std::monostate>) {
+        r.template emplace<I>(std::monostate{});
+    } else {
+        r.template emplace<I>(&std::get<I>(v));
+    }
+    return true;
+}
+
+template<typename Result, typename Variant, std::size_t... Is>
+Result to_ptr_variant_impl(Variant& v, std::index_sequence<Is...>) {
+    Result r;
+    (try_emplace_ptr<Is>(r, v) || ...);
+    return r;
+}
+
+} // namespace detail
+
+// Convert std::variant<Ts...>& -> std::variant<Ts*...> (monostate passthrough)
+template<typename... Ts>
+std::variant<typename detail::ptr_of<Ts>::type...>
+to_ptr_variant(std::variant<Ts...>& v) {
+    using Result = std::variant<typename detail::ptr_of<Ts>::type...>;
+    return detail::to_ptr_variant_impl<Result>(v, std::index_sequence_for<Ts...>{});
+}
+
+// Convert const std::variant<Ts...>& -> std::variant<const Ts*...> (monostate passthrough)
+template<typename... Ts>
+std::variant<typename detail::const_ptr_of<Ts>::type...>
+to_const_ptr_variant(const std::variant<Ts...>& v) {
+    using Result = std::variant<typename detail::const_ptr_of<Ts>::type...>;
+    return detail::to_ptr_variant_impl<Result>(v, std::index_sequence_for<Ts...>{});
+}
+
+// Convert mutable pointer variant to const pointer variant:
+// std::variant<T*...> -> std::variant<const T*...>
+// Handles monostate (nullable unions) by passing it through.
+namespace detail {
+template<typename Result>
+struct to_const_visitor {
+    template<typename T>
+    Result operator()(T* p) const { return static_cast<const T*>(p); }
+    Result operator()(std::monostate m) const { return m; }
+};
+} // namespace detail
+
+template<typename Result, typename... Alts>
+Result ptr_variant_to_const(const std::variant<Alts...>& v) {
+    return std::visit(detail::to_const_visitor<Result>{}, v);
+}
+
+// Reverse: convert pointer variant to value variant (copies active member).
+// Used when storing into fields/containers that own their values.
+// ValueVariant = target type (e.g. std::variant<Dog, Cat>)
+// PtrVariant = source type (e.g. std::variant<Dog*, Cat*>)
+namespace detail {
+
+// Visitor that converts each pointer alternative to its value type.
+// Constructs the Result variant directly, avoiding default-construction
+// (which would require the first alternative to be default-constructible).
+template<typename Result>
+struct deref_visitor {
+    template<typename T>
+    Result operator()(T* p) const { return Result{*p}; }
+
+    Result operator()(std::monostate) const { return Result{std::monostate{}}; }
+};
+
+} // namespace detail
+
+// Convert pointer variant to value variant: to_value_variant<std::variant<Dog,Cat>>(pv)
+// Caller must specify the target value-variant type explicitly.
+template<typename ValueVariant, typename... PtrAlts>
+ValueVariant to_value_variant(const std::variant<PtrAlts...>& v) {
+    return std::visit(detail::deref_visitor<ValueVariant>{}, v);
+}
+
+} // namespace tpy

tpyc/_data/runtime/cpp/src/stdlib/socket_impl.cpp

@@ -0,0 +1,104 @@
+// Out-of-line helpers for TPy's `socket` stdlib module.
+//
+// Exists because:
+//   * struct addrinfo's field order is not portable across Linux and
+//     BSD/macOS (ai_addr and ai_canonname are swapped). Declaring it at
+//     @native(binding="C") level would only work on one platform family.
+//     tpy_resolve_ipv4 walks the list here and hands back a flat 4-byte
+//     IPv4 address.
+//   * `errno` and gai_strerror need `<errno.h>` / `<netdb.h>`, whose
+//     macros we keep out of every TPy-generated TU by hiding them
+//     behind these helpers.
+//
+// Everything else in the socket module binds libc directly via @native
+// against the forward decls in runtime/cpp/include/tpy/stdlib/socket_h.hpp.
+//
+// We intentionally do NOT `#include` socket_h.hpp here: its libc forward
+// decls (using `void*` sockaddr pointers, no `noexcept`) conflict with
+// the real libc decls the system headers bring in. ABI consistency for
+// the three `tpy_*` symbols is maintained manually -- trivial with three
+// short signatures, and the only alternative is duplicating two parallel
+// header variants.
+
+#include <cerrno>
+#include <cstdint>
+#include <cstring>
+#include <string>
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+
+namespace {
+
+// Thread-local so two threads running concurrent resolves don't stomp
+// each other's error messages. The buffer is a fixed size because
+// gai_strerror / strerror messages are short; we copy to decouple the
+// returned pointer from libc's internal buffer reuse.
+thread_local char g_resolve_err[256] = {0};
+
+void set_resolve_error(const char* msg) {
+    if (msg == nullptr) {
+        g_resolve_err[0] = '\0';
+        return;
+    }
+    std::strncpy(g_resolve_err, msg, sizeof(g_resolve_err) - 1);
+    g_resolve_err[sizeof(g_resolve_err) - 1] = '\0';
+}
+
+}  // namespace
+
+extern "C" {
+
+int tpy_resolve_ipv4(const std::uint8_t* host, std::uint64_t host_len,
+                     std::uint8_t out[4]) {
+    // getaddrinfo requires a null-terminated C string. TPy `str` is
+    // std::string_view -- not guaranteed terminated -- so copy into a
+    // local std::string. reinterpret_cast<const char*> because TPy
+    // binding types string bytes as uint8_t* but std::string takes char*;
+    // the underlying bytes are identical.
+    std::string host_s(reinterpret_cast<const char*>(host), host_len);
+
+    addrinfo hints{};
+    hints.ai_family = AF_INET;
+    hints.ai_socktype = SOCK_STREAM;
+
+    addrinfo* res = nullptr;
+    int rc = getaddrinfo(host_s.c_str(), nullptr, &hints, &res);
+    if (rc != 0) {
+        set_resolve_error(gai_strerror(rc));
+        return -1;
+    }
+    if (res == nullptr) {
+        // getaddrinfo returned 0 but no results -- shouldn't happen,
+        // but guard anyway.
+        set_resolve_error("no addresses returned");
+        return -1;
+    }
+    if (res->ai_addr == nullptr) {
+        // Defensive: with AF_INET + SOCK_STREAM hints every returned
+        // entry should carry a sockaddr_in in ai_addr. A broken or
+        // custom resolver library could in theory break this
+        // invariant; fail cleanly rather than dereference null.
+        freeaddrinfo(res);
+        set_resolve_error("getaddrinfo returned entry with null ai_addr");
+        return -1;
+    }
+    // Copy the first A-record's 4 bytes. `sin_addr.s_addr` is already in
+    // network byte order, which is what the caller wants for sockaddr_in.
+    auto* sin = reinterpret_cast<sockaddr_in*>(res->ai_addr);
+    std::memcpy(out, &sin->sin_addr, 4);
+    freeaddrinfo(res);
+    set_resolve_error(nullptr);
+    return 0;
+}
+
+int tpy_errno() {
+    return errno;
+}
+
+const char* tpy_last_resolve_error() {
+    return g_resolve_err;
+}
+
+}  // extern "C"