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

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

@@ -0,0 +1,337 @@
+/**
+ * TurboPython Runtime - Ordered Set
+ *
+ * Hash set that preserves insertion order (matching Python's set implementation).
+ * Combines std::unordered_set for O(1) lookup with an intrusive doubly-linked
+ * list for insertion-order iteration.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <expected>
+#include <functional>
+#include <initializer_list>
+#include <unordered_map>
+#include <utility>
+
+#include "core.hpp"
+
+namespace tpy {
+
+template<typename T>
+class ordered_set {
+    struct Node {
+        T value;
+        Node* prev = nullptr;
+        Node* next = nullptr;
+
+        template<typename U>
+        explicit Node(U&& v) : value(std::forward<U>(v)) {}
+    };
+
+public:
+    // -- Iterator (insertion order) ------------------------------------------
+
+    template<bool IsConst>
+    class iterator_impl {
+        friend class ordered_set;
+        using NodePtr = std::conditional_t<IsConst, const Node*, Node*>;
+        NodePtr node_;
+
+        explicit iterator_impl(NodePtr n) : node_(n) {}
+
+    public:
+        iterator_impl() : node_(nullptr) {}
+
+        using iterator_category = std::forward_iterator_tag;
+        using difference_type = std::ptrdiff_t;
+        using value_type = T;
+        using reference = const T&;
+
+        const T& operator*() const { return node_->value; }
+
+        iterator_impl& operator++() { node_ = node_->next; return *this; }
+        iterator_impl operator++(int) { auto tmp = *this; node_ = node_->next; return tmp; }
+
+        bool operator==(const iterator_impl& o) const { return node_ == o.node_; }
+        bool operator!=(const iterator_impl& o) const { return node_ != o.node_; }
+    };
+
+    using iterator = iterator_impl<false>;
+    using const_iterator = iterator_impl<true>;
+
+    // -- Construction --------------------------------------------------------
+
+    ordered_set() = default;
+
+    ordered_set(std::initializer_list<T> init) {
+        for (auto& v : init) {
+            insert(v);
+        }
+    }
+
+    ordered_set(const ordered_set& other) {
+        for (auto* n = other.head_; n != nullptr; n = n->next) {
+            insert(n->value);
+        }
+    }
+
+    ordered_set(ordered_set&& other) noexcept
+        : table_(std::move(other.table_))
+        , head_(other.head_)
+        , tail_(other.tail_)
+    {
+        other.head_ = nullptr;
+        other.tail_ = nullptr;
+    }
+
+    ordered_set& operator=(const ordered_set& other) {
+        if (this != &other) {
+            clear();
+            for (auto* n = other.head_; n != nullptr; n = n->next) {
+                insert(n->value);
+            }
+        }
+        return *this;
+    }
+
+    ordered_set& operator=(ordered_set&& other) noexcept {
+        if (this != &other) {
+            clear();
+            table_ = std::move(other.table_);
+            head_ = other.head_;
+            tail_ = other.tail_;
+            other.head_ = nullptr;
+            other.tail_ = nullptr;
+        }
+        return *this;
+    }
+
+    ~ordered_set() {
+        clear();
+    }
+
+    // -- Capacity ------------------------------------------------------------
+
+    int32_t size() const { return static_cast<int32_t>(table_.size()); }
+    bool empty() const { return table_.empty(); }
+
+    // -- Modifiers -----------------------------------------------------------
+
+    bool insert(const T& value) {
+        auto it = table_.find(value);
+        if (it != table_.end()) return false;
+        auto* node = new Node(value);
+        link_back(node);
+        table_.emplace(value, node);
+        return true;
+    }
+
+    bool insert(T&& value) {
+        auto it = table_.find(value);
+        if (it != table_.end()) return false;
+        auto* node = new Node(std::move(value));
+        link_back(node);
+        table_.emplace(node->value, node);
+        return true;
+    }
+
+    bool erase(const T& value) {
+        auto it = table_.find(value);
+        if (it == table_.end()) return false;
+        Node* node = it->second;
+        table_.erase(it);
+        unlink(node);
+        delete node;
+        return true;
+    }
+
+    void clear() {
+        auto* n = head_;
+        while (n != nullptr) {
+            auto* next = n->next;
+            delete n;
+            n = next;
+        }
+        table_.clear();
+        head_ = nullptr;
+        tail_ = nullptr;
+    }
+
+    // -- Lookup --------------------------------------------------------------
+
+    bool contains(const T& value) const {
+        return table_.find(value) != table_.end();
+    }
+
+    // -- Iteration (insertion order) -----------------------------------------
+
+    iterator begin() { return iterator(head_); }
+    iterator end() { return iterator(nullptr); }
+    const_iterator begin() const { return const_iterator(head_); }
+    const_iterator end() const { return const_iterator(nullptr); }
+
+    // -- Python __iter__() support -------------------------------------------
+
+    // Defined in set_ops.hpp (needs native_iterator template)
+    inline auto __iter__() const;
+
+    // -- Comparison (order-independent, matching Python) ---------------------
+
+    bool operator==(const ordered_set& other) const {
+        if (table_.size() != other.table_.size()) return false;
+        for (auto* n = head_; n != nullptr; n = n->next) {
+            if (!other.contains(n->value)) return false;
+        }
+        return true;
+    }
+
+    bool operator!=(const ordered_set& other) const {
+        return !(*this == other);
+    }
+
+    // Python set comparison: <= means subset, < means strict subset, etc.
+    bool operator<=(const ordered_set& other) const {
+        if (table_.size() > other.table_.size()) return false;
+        for (auto* n = head_; n != nullptr; n = n->next) {
+            if (!other.contains(n->value)) return false;
+        }
+        return true;
+    }
+
+    bool operator<(const ordered_set& other) const {
+        return table_.size() < other.table_.size() && *this <= other;
+    }
+
+    bool operator>=(const ordered_set& other) const {
+        return other <= *this;
+    }
+
+    bool operator>(const ordered_set& other) const {
+        return other < *this;
+    }
+
+    // -- Front access (for pop) ----------------------------------------------
+
+    const T& front() const { return head_->value; }
+
+    void pop_front() {
+        Node* node = head_;
+        table_.erase(node->value);
+        unlink(node);
+        delete node;
+    }
+
+private:
+    void link_back(Node* node) {
+        node->prev = tail_;
+        node->next = nullptr;
+        if (tail_) {
+            tail_->next = node;
+        } else {
+            head_ = node;
+        }
+        tail_ = node;
+    }
+
+    void unlink(Node* node) {
+        if (node->prev) {
+            node->prev->next = node->next;
+        } else {
+            head_ = node->next;
+        }
+        if (node->next) {
+            node->next->prev = node->prev;
+        } else {
+            tail_ = node->prev;
+        }
+    }
+
+    template<typename> friend struct OwnIterSet;
+
+    std::unordered_map<T, Node*, std::hash<T>> table_;
+    Node* head_ = nullptr;
+    Node* tail_ = nullptr;
+};
+
+// Construct an ordered_set from move-only T types. Mirrors make_vector /
+// make_ordered_map: the initializer_list ctor stores elements as const,
+// forcing a copy of T -- this helper forwards each element into insert
+// so move-only values work in set literals once sema permits them.
+template<typename T, typename... Args>
+ordered_set<T> make_ordered_set(Args&&... args) {
+    ordered_set<T> s;
+    (s.insert(std::forward<Args>(args)), ...);
+    return s;
+}
+
+// ---------------------------------------------------------------------------
+// OwnIterSet -- drain iterator for ordered_set
+//
+// Owns a moved ordered_set and yields elements by move. O(1) construction
+// (hash table move is pointer swap). Implements both C++ range (begin/end
+// with move iterators) and the TurboPython Iterator protocol (__next__).
+// ---------------------------------------------------------------------------
+
+template<typename T>
+struct OwnIterSet {
+    ordered_set<T> data;
+    typename ordered_set<T>::Node* pos;
+
+    explicit OwnIterSet(ordered_set<T>&& s)
+        : data(std::move(s)), pos(data.head_) {}
+
+    OwnIterSet(const OwnIterSet&) = delete;
+    OwnIterSet& operator=(const OwnIterSet&) = delete;
+    OwnIterSet(OwnIterSet&&) = default;
+    OwnIterSet& operator=(OwnIterSet&&) = default;
+
+    // Move iterator: walks linked-list nodes, yields T&& (moved values).
+    // Single-pass: each dereference moves the value out of the node.
+    struct move_iter {
+        using Node = typename ordered_set<T>::Node;
+        Node* node_;
+
+        using iterator_category = std::input_iterator_tag;
+        using value_type = T;
+        using difference_type = std::ptrdiff_t;
+        using reference = T&&;
+
+        move_iter() : node_(nullptr) {}
+        explicit move_iter(Node* n) : node_(n) {}
+
+        T&& operator*() { return std::move(node_->value); }
+        move_iter& operator++() { node_ = node_->next; return *this; }
+        move_iter operator++(int) { auto tmp = *this; ++*this; return tmp; }
+        bool operator==(const move_iter& o) const { return node_ == o.node_; }
+        bool operator!=(const move_iter& o) const { return node_ != o.node_; }
+    };
+
+    // NativeIterable: range-based iteration with move semantics.
+    // Do not mix range-based (begin/end) and __next__-based iteration on the
+    // same instance -- both advance shared state and the result is undefined.
+    move_iter begin() { return move_iter(pos); }
+    move_iter end()   { return move_iter(nullptr); }
+
+    // TPy Iterator protocol
+    std::expected<T, StopIteration> __next__() {
+        if (pos == nullptr) return tpy::make_unexpected(StopIteration{});
+        T value = std::move(pos->value);
+        pos = pos->next;
+        return value;
+    }
+
+    OwnIterSet& __iter__() { return *this; }
+
+    friend std::ostream& operator<<(std::ostream& os, const OwnIterSet&) {
+        return os << "<own_iter_set>";
+    }
+};
+
+template<typename T>
+OwnIterSet<T> own_iter_set(ordered_set<T>&& s) {
+    return OwnIterSet<T>{std::move(s)};
+}
+
+}  // namespace tpy

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

@@ -0,0 +1,54 @@
+/**
+ * TurboPython Runtime - OwnIter
+ *
+ * Drain iterator for heap-backed containers (std::vector). Owns a moved
+ * vector and yields elements by move. O(1) construction (vector move is
+ * pointer swap). Unconsumed elements are destructed when OwnIter is dropped.
+ *
+ * Implements both C++ range (begin/end with move iterators) and the
+ * TurboPython Iterator protocol (__next__/__iter__).
+ */
+
+#pragma once
+
+#include "core.hpp"
+
+#include <expected>
+#include <iterator>
+#include <vector>
+
+namespace tpy {
+
+template<typename T>
+struct OwnIter {
+    std::vector<T> data;
+    std::size_t pos = 0;
+
+    explicit OwnIter(std::vector<T>&& v) : data(std::move(v)) {}
+
+    // NativeIterable: range-based iteration with move semantics.
+    // Do not mix range-based (begin/end) and __next__-based iteration on the
+    // same instance -- both advance shared state and the result is undefined.
+    auto begin() { return std::make_move_iterator(data.begin() + static_cast<std::ptrdiff_t>(pos)); }
+    auto end()   { return std::make_move_iterator(data.end()); }
+
+    // Iterator protocol
+    std::expected<T, StopIteration> __next__() {
+        if (pos >= data.size()) return tpy::make_unexpected(StopIteration{});
+        return std::move(data[pos++]);
+    }
+
+    OwnIter& __iter__() { return *this; }
+
+    friend std::ostream& operator<<(std::ostream& os, const OwnIter&) {
+        return os << "<own_iter>";
+    }
+};
+
+// Factory: create OwnIter from an rvalue vector.
+template<typename T>
+OwnIter<T> own_iter(std::vector<T>&& v) {
+    return OwnIter<T>{std::move(v)};
+}
+
+} // namespace tpy

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

@@ -0,0 +1,192 @@
+// Pascal Graph SDL2 display layer.
+//
+// Optional companion to the pure-TPy Pascal Graph unit. Compiled in when
+// `--dsl-opt pascal.sdl=on` (or `auto` finds libsdl2-dev). The frontend
+// plugin injects calls to the entry points below around the Pascal source
+// (initgraph -> open, delay/setvisualpage -> present, closegraph ->
+// show_blocking + closegraph + close_window) so animated TP7 programs
+// render live in a window rather than as one final snapshot.
+//
+// The Pascal Graph runtime owns the pixel buffer + does all drawing
+// (Tier A/B/C primitives are pure TPy). This file is a thin display
+// adapter -- window/renderer/texture creation, pixel upload, event
+// pumping, teardown.
+
+#pragma once
+
+#include <SDL2/SDL.h>
+
+#include <cstdint>
+#include <vector>
+
+
+namespace tpy::pascal {
+
+// Module-level SDL handles. Held in a function-local static so we can
+// keep the API as free functions matching the TPy `@native` shape. The
+// program is single-threaded at the Pascal level, so a single global
+// is fine; nested initgraph/closegraph cycles work because
+// `sdl_close_window` resets everything.
+struct SdlGfxState {
+    SDL_Window* win = nullptr;
+    SDL_Renderer* ren = nullptr;
+    SDL_Texture* tex = nullptr;
+    int width = 0;
+    int height = 0;
+    bool user_quit = false;
+};
+
+inline SdlGfxState& sdl_gfx_state() {
+    static SdlGfxState s;
+    return s;
+}
+
+// Pump any pending SDL events so the OS keeps treating the window as
+// responsive. Sets `user_quit` if the user has tried to close the
+// window or pressed any key. Non-blocking; safe to call from any
+// hook.
+inline void sdl_pump_events() {
+    SdlGfxState& s = sdl_gfx_state();
+    SDL_Event ev;
+    while (SDL_PollEvent(&ev) != 0) {
+        if (ev.type == SDL_QUIT) {
+            s.user_quit = true;
+        } else if (ev.type == SDL_KEYDOWN) {
+            s.user_quit = true;
+        } else if (ev.type == SDL_WINDOWEVENT
+                   && ev.window.event == SDL_WINDOWEVENT_CLOSE) {
+            s.user_quit = true;
+        }
+    }
+}
+
+// Open the SDL window for a `width`x`height` canvas. Idempotent --
+// calling twice with the same dimensions is a no-op; calling with
+// different dimensions reopens. Silent no-op on any SDL failure --
+// the Pascal program's PPM snapshot fallback still gets written at
+// CloseGraph, so users without a working SDL2 setup don't end up
+// empty-handed.
+inline void sdl_open_window(std::int32_t width, std::int32_t height) {
+    SdlGfxState& s = sdl_gfx_state();
+    if (width <= 0 || height <= 0) {
+        return;
+    }
+    if (s.win != nullptr && s.width == width && s.height == height) {
+        return;
+    }
+    // Different dimensions on a re-init -> tear down and reopen.
+    if (s.win != nullptr) {
+        if (s.tex != nullptr) { SDL_DestroyTexture(s.tex); }
+        if (s.ren != nullptr) { SDL_DestroyRenderer(s.ren); }
+        SDL_DestroyWindow(s.win);
+        s.tex = nullptr; s.ren = nullptr; s.win = nullptr;
+    }
+    if (SDL_WasInit(SDL_INIT_VIDEO) == 0) {
+        if (SDL_Init(SDL_INIT_VIDEO) != 0) {
+            return;
+        }
+    }
+    // Scale up by 2x so a 320x200 BGI canvas renders at 640x400
+    // (closer to readable on a modern display). The texture stays at
+    // the canvas size; SDL's RenderCopy stretches it to the window.
+    const int win_w = width * 2;
+    const int win_h = height * 2;
+    s.win = SDL_CreateWindow(
+        "TurboPython Pascal Graph",
+        SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
+        win_w, win_h, SDL_WINDOW_SHOWN);
+    if (s.win == nullptr) {
+        return;
+    }
+    s.ren = SDL_CreateRenderer(s.win, -1, 0);
+    if (s.ren == nullptr) {
+        SDL_DestroyWindow(s.win); s.win = nullptr;
+        return;
+    }
+    s.tex = SDL_CreateTexture(
+        s.ren, SDL_PIXELFORMAT_RGB888,
+        SDL_TEXTUREACCESS_STREAMING, width, height);
+    if (s.tex == nullptr) {
+        SDL_DestroyRenderer(s.ren); s.ren = nullptr;
+        SDL_DestroyWindow(s.win); s.win = nullptr;
+        return;
+    }
+    s.width = width;
+    s.height = height;
+    s.user_quit = false;
+    sdl_pump_events();
+}
+
+// Upload the current pixel buffer and present it. Pumps SDL events so
+// the OS keeps the window responsive. Non-blocking. Auto-opens the
+// window if it isn't open yet (lets a program call `sdl_present`
+// without an explicit `sdl_open_window` -- the frontend injects the
+// open call after initgraph but a malformed sequence shouldn't
+// silently drop frames).
+inline void sdl_present(std::int32_t width, std::int32_t height,
+                        const std::vector<std::int32_t>& pixels) {
+    SdlGfxState& s = sdl_gfx_state();
+    if (width <= 0 || height <= 0) {
+        return;
+    }
+    if (static_cast<std::size_t>(width) * static_cast<std::size_t>(height)
+            != pixels.size()) {
+        return;
+    }
+    if (s.win == nullptr || s.width != width || s.height != height) {
+        sdl_open_window(width, height);
+        if (s.win == nullptr) {
+            return;
+        }
+    }
+    SDL_UpdateTexture(s.tex, nullptr, pixels.data(),
+                      static_cast<int>(width * sizeof(std::int32_t)));
+    SDL_RenderClear(s.ren);
+    SDL_RenderCopy(s.ren, s.tex, nullptr, nullptr);
+    SDL_RenderPresent(s.ren);
+    sdl_pump_events();
+}
+
+// Present the final canvas and block until the user closes the
+// window or presses any key. If the user already quit during an
+// earlier present (`user_quit` set), returns immediately so the
+// program can finish teardown without re-blocking.
+inline void sdl_show_blocking(std::int32_t width, std::int32_t height,
+                              const std::vector<std::int32_t>& pixels) {
+    sdl_present(width, height, pixels);
+    SdlGfxState& s = sdl_gfx_state();
+    if (s.win == nullptr) {
+        return;
+    }
+    if (s.user_quit) {
+        return;
+    }
+    SDL_Event ev;
+    while (SDL_WaitEvent(&ev) != 0) {
+        if (ev.type == SDL_QUIT
+            || ev.type == SDL_KEYDOWN
+            || (ev.type == SDL_WINDOWEVENT
+                && ev.window.event == SDL_WINDOWEVENT_CLOSE)) {
+            s.user_quit = true;
+            return;
+        }
+    }
+}
+
+// Destroy the window / renderer / texture and shut down SDL video.
+// Idempotent -- safe to call from cleanup paths even when the window
+// failed to open.
+inline void sdl_close_window() {
+    SdlGfxState& s = sdl_gfx_state();
+    if (s.tex != nullptr) { SDL_DestroyTexture(s.tex); s.tex = nullptr; }
+    if (s.ren != nullptr) { SDL_DestroyRenderer(s.ren); s.ren = nullptr; }
+    if (s.win != nullptr) { SDL_DestroyWindow(s.win); s.win = nullptr; }
+    s.width = 0;
+    s.height = 0;
+    s.user_quit = false;
+    if (SDL_WasInit(SDL_INIT_VIDEO) != 0) {
+        SDL_Quit();
+    }
+}
+
+}  // namespace tpy::pascal