konpeito 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed1949148547cf4716d3405d71d9d79413d84201a699fefe98512ddb4202808e
-  data.tar.gz: cbcc7ecbea2a4c6edeab12fd5f20d5221e9dca2e379906c728d37e16b0168bea
+  metadata.gz: d513cebc5d3b0574c814b92901fbe2f4154e4ffc905da31c095abf9375bcaf34
+  data.tar.gz: 8becb035b3dc4e7aa9f2cb482fa658fcf4551ceeb734fba5c7727eb87e06babd
 SHA512:
-  metadata.gz: 8ad8a635a74b09378cacf342e14a9fdba84434d29d3657071a72fb42d800dd8cfe84bc5a9f66ca81fd48852b880f6896c8a4aff5d83c12be03a8cbf8208b5b5d
-  data.tar.gz: f1635c6083bd97079fff23d07e3fe5232eadaffc21aeccdc6718689569da8afe50eba3252a188eb2aff42318317ed0ec18e5d2e1b190ac63679c0b354a27c11d
+  metadata.gz: e37567409349ff5fe6c87802b89ffe2ecef3cd7b4b74fc332df6534e5c5e144b0d527d9f2d67d39c532dd117ebe35aa654e2779a4c10f6191f96b0a8fa9bb168
+  data.tar.gz: aef79cd03516814b259747bf9eaa0b449d692ca6568b6ecf9c4939e05ce279d7343d65caf8ceccc74e63094839e318bf5a855ea8b2d75e54f83d6e1e7f5ef6e8

data/CHANGELOG.md

@@ -5,7 +5,32 @@ All notable changes to Konpeito will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.9.0] - 2026-03-16
+
+### Added
+- **KUI widget expansion** (25→66 widgets): badge, avatar, progress_steps, number_stepper,
+  segmented_control, accordion, dropdown, tooltip, toast, alert/confirm dialog, slider,
+  switch, rating, textarea, color_picker, date_picker, grid, zstack, scaffold, wrap_panel,
+  nav_bar, bottom_nav, drawer, bottom_sheet, list_section, sortable_header, timeline,
+  skeleton, carousel_dots, and nested yield fix in mruby backend
+- **KUI Markdown renderer** with live window resize support
+- **KUI chart rendering**: bar, line, and pie charts
+- **KUI Castella-style theming**: style composition and theme presets
+  (dark, light, solarized, etc.)
+- **Basic IME support**: UTF-8 text buffers and CJK font loading
+- **TUI Markdown demo** and TUI build resize stubs
+- **Pomodoro Timer** KUI utility app
+- **KUI framework extensions** and two new example apps (café menu, dashboard)
+
+### Fixed
+- **case/when with integer constants** crashed with SIGSEGV
+- **Large draw functions** caused SIGSEGV in Pomodoro Timer (resolved by function splitting)
+- **Unboxed captures in escape-cells** caused GC SIGSEGV (now boxed before capture)
+- **Nested yield+block** caused SIGSEGV (re-enabled yield target stack)
+
+### Changed
+- KUI tutorial updated with new widget features
+- KUI documentation clarified as immediate-mode UI framework
 
 ## [0.8.0] - 2026-03-14
 
@@ -379,6 +404,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `%a{extern}` - external C struct wrappers
 - `%a{simd}` - SIMD vectorization
 
+[0.9.0]: https://github.com/i2y/konpeito/compare/v0.8.0...v0.9.0
 [0.8.0]: https://github.com/i2y/konpeito/compare/v0.7.1...v0.8.0
 [0.7.1]: https://github.com/i2y/konpeito/compare/v0.7.0...v0.7.1
 [0.7.0]: https://github.com/i2y/konpeito/compare/v0.6.0...v0.7.0

data/lib/konpeito/codegen/llvm_generator.rb

@@ -823,6 +823,13 @@ module Konpeito
         # We'll use rb_yield_values2 instead: VALUE rb_yield_values2(int argc, const VALUE *argv)
         @rb_yield_values2 = @mod.functions.add("rb_yield_values2", [LLVM::Int32, LLVM::Pointer(value_type)], value_type)
 
+        # Nested yield: yield to the enclosing method's block from inside a block callback
+        @konpeito_yield_to_method_block = @mod.functions.add("konpeito_yield_to_method_block", [value_type], value_type)
+        @konpeito_yield_to_method_block_values = @mod.functions.add("konpeito_yield_to_method_block_values",
+          [LLVM::Int32, LLVM::Pointer(value_type)], value_type)
+        @konpeito_push_yield_target = @mod.functions.add("konpeito_push_yield_target", [], LLVM::Type.void)
+        @konpeito_pop_yield_target = @mod.functions.add("konpeito_pop_yield_target", [], LLVM::Type.void)
+
         # int rb_block_given_p(void) - check if block is given
         @rb_block_given_p = @mod.functions.add("rb_block_given_p", [], LLVM::Int32)
 
@@ -1767,6 +1774,15 @@ module Konpeito
           @builder.store(arena_idx, @mruby_gc_arena_alloca)
         end
 
+        # For mruby: if this function has yield inside block callbacks (nested yield),
+        # push the current method's block as the yield target so that nested callbacks
+        # can yield to the correct block instead of the innermost callback.
+        @needs_yield_target_pop = false
+        if @runtime == :mruby && function_has_nested_yield?(hir_func)
+          @builder.call(@konpeito_push_yield_target)
+          @needs_yield_target_pop = true
+        end
+
         # Insert profiling entry probe after parameter setup
         insert_profile_entry_probe(hir_func)
 
@@ -1796,6 +1812,10 @@ module Konpeito
       # For the mruby backend, restores the arena to the saved index and
       # protects the return value from GC before returning.
       def emit_ret(value)
+        # Pop yield target before return if this function pushed one
+        if @needs_yield_target_pop
+          @builder.call(@konpeito_pop_yield_target)
+        end
         if @mruby_gc_arena_alloca
           idx = @builder.load2(LLVM::Int32, @mruby_gc_arena_alloca, "_arena_r")
           @builder.call(@konpeito_gc_arena_restore, idx)
@@ -1807,6 +1827,32 @@ module Konpeito
         @builder.ret(value)
       end
 
+      # Check if a function has yield inside any block callback body (nested yield).
+      # Direct yield in the function body does NOT count (that uses rb_yield normally).
+      def function_has_nested_yield?(hir_func)
+        hir_func.body.each do |bb|
+          bb.instructions.each do |inst|
+            if inst.is_a?(HIR::Call) && inst.block
+              return true if block_body_contains_yield?(inst.block)
+            end
+          end
+        end
+        false
+      end
+
+      # Recursively check if a block body contains a Yield instruction.
+      def block_body_contains_yield?(block_def)
+        block_def.body.each do |bb|
+          bb.instructions.each do |inst|
+            return true if inst.is_a?(HIR::Yield)
+            if inst.is_a?(HIR::Call) && inst.block
+              return true if block_body_contains_yield?(inst.block)
+            end
+          end
+        end
+        false
+      end
+
       # Topologically sort blocks based on phi dependencies
       # Ensures blocks are generated after the blocks their phi nodes reference
       def sort_blocks_by_phi_dependencies(blocks)
@@ -4814,11 +4860,19 @@ module Konpeito
         if use_escape_cells
           esc_ary = @builder.call(@rb_ary_new_capa, LLVM::Int64.from_i(all_captures.size), "blk_esc_ary")
           all_captures.each do |cap|
+            cap_type = capture_types[cap.name] || :value
             val = if @variable_allocas[cap.name]
                     @builder.load2(value_type, @variable_allocas[cap.name], "blk_esc_#{cap.name}")
                   else
                     qnil
                   end
+            # Box unboxed values before pushing to the escape-cells Ruby Array.
+            # The GC scans array elements as mrb_values; a raw unboxed integer
+            # (e.g., from NativeArray) without fixnum tag bits would be
+            # misinterpreted as a heap pointer → SIGSEGV in gc_mark_children.
+            if cap_type != :value
+              val = convert_value(val, cap_type, :value)
+            end
             @builder.call(@rb_ary_push, esc_ary, val)
           end
 
@@ -4916,8 +4970,9 @@ module Konpeito
         # Set @in_block_callback so nested proc creation uses GC-safe escape-cells mode.
         # Reset mruby constant cache — LLVM values are scoped per function, so
         # cached %qnil/%qtrue from the parent function are invalid here.
-        # Clear GC arena alloca — callbacks don't own their own arena scope.
         @in_block_callback = true
+
+        # Clear GC arena alloca — callbacks run under the caller's arena scope.
         @mruby_gc_arena_alloca = nil
         @variables = {}
         @variable_types = {}
@@ -4936,13 +4991,21 @@ module Konpeito
             captures.each_with_index do |capture, i|
               val = @builder.call(@rb_ary_entry, ary_val,
                                   LLVM::Int64.from_i(i), "esc_#{capture.name}")
+              # Values were boxed when pushed to the escape-cells array
+              # (to prevent GC from misinterpreting raw unboxed integers as
+              # heap pointers).  Unbox them back to their original type.
+              cap_type = capture_types[capture.name] || :value
+              if cap_type != :value
+                val = convert_value(val, :value, cap_type)
+              end
               # Store in an alloca so LoadLocal/StoreLocal can use it normally.
               # Writes to this alloca stay local (no back-write to the GC array),
               # which is correct for snapshots from a returned outer scope.
-              cap_alloca = @builder.alloca(value_type, "esc_alloca_#{capture.name}")
+              llvm_type = type_tag_to_llvm_type(cap_type)
+              cap_alloca = @builder.alloca(llvm_type, "esc_alloca_#{capture.name}")
               @builder.store(val, cap_alloca)
               @variable_allocas[capture.name] = cap_alloca
-              @variable_types[capture.name] = capture_types[capture.name] || :value
+              @variable_types[capture.name] = cap_type
             end
           else
             # data2 is a pointer to array of VALUE* (pointers to captured variables).
@@ -5149,10 +5212,7 @@ module Konpeito
               # Return the last value in the block, or Qnil
               # For while_exit blocks, the last instruction loads the break value
               if last_instr
-                result_val = last_instr
-                # Box unboxed values before returning
-                result_type = :value  # Default
-                @builder.ret(result_val)
+                @builder.ret(last_instr)
               else
                 @builder.ret(qnil)
               end
@@ -7982,15 +8042,20 @@ module Konpeito
       end
 
       def generate_yield(inst)
+        # When yield is inside a block callback, use the yield target stack
+        # to reach the enclosing method's block instead of the innermost callback.
+        yield_fn = @in_block_callback ? @konpeito_yield_to_method_block : @rb_yield
+        yield_values_fn = @in_block_callback ? @konpeito_yield_to_method_block_values : @rb_yield_values2
+
         result = if inst.args.empty?
           # yield with no arguments - pass Qnil
-          @builder.call(@rb_yield, qnil)
+          @builder.call(yield_fn, qnil)
         elsif inst.args.size == 1
           # yield with single argument — must be boxed VALUE for rb_yield
           arg_value = get_value_as_ruby(inst.args.first)
-          @builder.call(@rb_yield, arg_value)
+          @builder.call(yield_fn, arg_value)
         else
-          # yield with multiple arguments - use rb_yield_values2
+          # yield with multiple arguments
           argc = LLVM::Int32.from_i(inst.args.size)
 
           # Allocate array on stack
@@ -8004,7 +8069,7 @@ module Konpeito
 
           # Cast to VALUE*
           argv_ptr = @builder.bit_cast(argv, LLVM::Pointer(value_type))
-          @builder.call(@rb_yield_values2, argc, argv_ptr)
+          @builder.call(yield_values_fn, argc, argv_ptr)
         end
 
         @variables[inst.result_var] = result if inst.result_var
@@ -8889,6 +8954,10 @@ module Konpeito
           # String === arg: Use rb_str_equal
           return inline_string_case_eq(receiver, arg)
         elsif receiver_hir.is_a?(HIR::ConstantLookup)
+          if is_integer_type?(receiver_hir.type)
+            # Integer constant (e.g. OP_ADD = 1) === arg: VALUE equality check
+            return inline_value_case_eq(receiver, arg)
+          end
           # Class/Module === arg: Use rb_obj_is_kind_of
           return inline_class_case_eq(receiver, arg)
         end
@@ -8926,6 +8995,13 @@ module Konpeito
         @builder.select(result_bool, qtrue, qfalse)
       end
 
+      # Inline VALUE equality check for integer constants (e.g. OP_ADD = 1)
+      # Since CRuby/mruby Fixnums are immediate values, VALUE equality == numeric equality
+      def inline_value_case_eq(receiver, arg)
+        eq_bool = @builder.icmp(:eq, receiver, arg)
+        @builder.select(eq_bool, qtrue, qfalse)
+      end
+
       # Inline String === arg comparison
       def inline_string_case_eq(receiver, arg)
         # Use rb_str_equal which returns Qtrue/Qfalse

data/lib/konpeito/codegen/mruby_backend.rb

@@ -129,6 +129,8 @@ module Konpeito
         lines << "/* Block stack for rb_yield/rb_block_given_p support */"
         lines << "extern void konpeito_push_block(mrb_value block);"
         lines << "extern void konpeito_pop_block(void);"
+        lines << "extern void konpeito_push_yield_target(void);"
+        lines << "extern void konpeito_pop_yield_target(void);"
         lines << ""
 
         # Collect NativeClasses from RBS loader

data/lib/konpeito/codegen/mruby_helpers.c

@@ -96,6 +96,90 @@ void konpeito_pop_block(void) {
     }
 }
 
+/* Forward declarations for yield target stack and nested yield support */
+static mrb_value konpeito_get_block(void);
+static konpeito_native_cb_entry *konpeito_get_native_cb(void);
+mrb_value rb_yield(mrb_value val);
+mrb_value rb_yield_values2(int argc, const mrb_value *argv);
+
+/* ================================================================
+ * Yield target stack for nested yield
+ *
+ * When a method receives a block and its body (via nested block
+ * callbacks) calls yield, the global block stack top points to the
+ * innermost callback, not the method's block.
+ *
+ * The yield target stack captures the block at method entry so that
+ * yield inside any nested callback can find the correct target.
+ * ================================================================ */
+
+static mrb_value konpeito_yield_target_block[KONPEITO_MAX_BLOCK_STACK];
+static konpeito_native_cb_entry konpeito_yield_target_native[KONPEITO_MAX_BLOCK_STACK];
+static int konpeito_yield_target_depth = 0;
+
+void konpeito_push_yield_target(void) {
+    if (konpeito_yield_target_depth < KONPEITO_MAX_BLOCK_STACK) {
+        /* Capture the current top of block_stack as the yield target */
+        konpeito_yield_target_block[konpeito_yield_target_depth] = konpeito_get_block();
+        konpeito_native_cb_entry *native = konpeito_get_native_cb();
+        if (native) {
+            konpeito_yield_target_native[konpeito_yield_target_depth] = *native;
+        } else {
+            konpeito_yield_target_native[konpeito_yield_target_depth].func = NULL;
+        }
+        konpeito_yield_target_depth++;
+    }
+}
+
+void konpeito_pop_yield_target(void) {
+    if (konpeito_yield_target_depth > 0) {
+        konpeito_yield_target_depth--;
+    }
+}
+
+/* Yield to the enclosing method's block (not the immediate callback).
+ * Used by yield inside block callbacks to propagate correctly. */
+mrb_value konpeito_yield_to_method_block(mrb_value val) {
+    mrb_state *mrb = konpeito_mrb_state;
+
+    if (konpeito_yield_target_depth > 0) {
+        konpeito_native_cb_entry *target =
+            &konpeito_yield_target_native[konpeito_yield_target_depth - 1];
+        if (target->func) {
+            mrb_value argv[1];
+            argv[0] = val;
+            return target->func(val, target->data2, 1, argv);
+        }
+        mrb_value block = konpeito_yield_target_block[konpeito_yield_target_depth - 1];
+        if (!mrb_nil_p(block)) {
+            return mrb_funcall(mrb, block, "call", 1, val);
+        }
+    }
+
+    /* Fallback to normal yield */
+    return rb_yield(val);
+}
+
+mrb_value konpeito_yield_to_method_block_values(int argc, const mrb_value *argv) {
+    mrb_state *mrb = konpeito_mrb_state;
+
+    if (konpeito_yield_target_depth > 0) {
+        konpeito_native_cb_entry *target =
+            &konpeito_yield_target_native[konpeito_yield_target_depth - 1];
+        if (target->func) {
+            mrb_value yielded = (argc > 0) ? argv[0] : mrb_nil_value();
+            return target->func(yielded, target->data2, argc, argv);
+        }
+        mrb_value block = konpeito_yield_target_block[konpeito_yield_target_depth - 1];
+        if (!mrb_nil_p(block)) {
+            mrb_sym call_sym = mrb_intern_cstr(mrb, "call");
+            return mrb_funcall_argv(mrb, block, call_sym, argc, argv);
+        }
+    }
+
+    return rb_yield_values2(argc, argv);
+}
+
 static mrb_value konpeito_get_block(void) {
     if (konpeito_block_stack_depth > 0) {
         return konpeito_block_stack[konpeito_block_stack_depth - 1];
@@ -1052,3 +1136,26 @@ void konpeito_mrb_data_init(mrb_value obj, void *ptr, const mrb_data_type *type)
 
 /* mrb_top_self wrapper */
 mrb_value konpeito_mrb_top_self(mrb_state *mrb) { return mrb_top_self(mrb); }
+
+/* ================================================================
+ * Live resize bridge — calls Ruby _kui_resize_frame() from C
+ * ================================================================ */
+
+/* Forward declaration from clay_native.c */
+typedef void (*clay_frame_fn)(void);
+extern void konpeito_clay_set_resize_frame_fn(clay_frame_fn fn);
+
+static void konpeito_resize_frame_bridge(void) {
+    mrb_state *mrb = konpeito_mrb_state;
+    if (!mrb) return;
+    int ai = mrb_gc_arena_save(mrb);
+    mrb_funcall(mrb, mrb_top_self(mrb), "_kui_resize_frame", 0);
+    if (mrb->exc) {
+        mrb->exc = NULL;  /* swallow errors during resize */
+    }
+    mrb_gc_arena_restore(mrb, ai);
+}
+
+void konpeito_register_resize_callback(void) {
+    konpeito_clay_set_resize_frame_fn(konpeito_resize_frame_bridge);
+}

data/lib/konpeito/stdlib/clay/clay.rb

@@ -26,6 +26,7 @@ module Clay
   def self.layout(dir, pl, pr, pt, pb, gap, swt, swv, sht, shv, ax, ay) end
   def self.bg(r, g, b, a, corner_radius) end
   def self.border(r, g, b, a, top, right, bottom, left, corner_radius) end
+  def self.set_custom(chart_id) end
   def self.scroll(horizontal, vertical) end
   def self.floating(ox, oy, z, att_elem, att_parent) end
 
@@ -33,6 +34,7 @@ module Clay
   def self.text(text, font_id, font_size, r, g, b, a, wrap) end
   def self.set_measure_text_raylib() end
   def self.load_font(path, size) end
+  def self.load_font_cjk(path, size) end
 
   # Render Command Access
   def self.cmd_type(index) end
@@ -48,10 +50,18 @@ module Clay
   def self.cmd_font_id(index) end
   def self.cmd_font_size(index) end
   def self.cmd_corner_radius(index) end
+  def self.cmd_ix(index) end
+  def self.cmd_iy(index) end
+  def self.cmd_iw(index) end
+  def self.cmd_ih(index) end
+  def self.cmd_custom_data(index) end
   def self.cmd_border_width_top(index) end
 
   # Bulk Rendering
   def self.render_raylib() end
+  def self.set_bg_color(r, g, b) end
+  def self.is_resizing() end
+  def self.register_resize_callback() end
 
   # Scroll
   def self.update_scroll(dx, dy, dt) end

data/lib/konpeito/stdlib/clay/clay.rbs

@@ -70,6 +70,10 @@ module Clay
   %a{cfunc: "konpeito_clay_border"}
   def self.border: (Float r, Float g, Float b, Float a, Integer top, Integer right, Integer bottom, Integer left, Float corner_radius) -> void
 
+  # Custom element (chart placeholder)
+  %a{cfunc: "konpeito_clay_set_custom"}
+  def self.set_custom: (Integer chart_id) -> void
+
   # Scroll/clip configuration
   %a{cfunc: "konpeito_clay_scroll"}
   def self.scroll: (Integer horizontal, Integer vertical) -> void
@@ -92,6 +96,10 @@ module Clay
   %a{cfunc: "konpeito_clay_load_font"}
   def self.load_font: (String path, Integer size) -> Integer
 
+  # Load a font file with CJK glyph ranges and return its font_id
+  %a{cfunc: "konpeito_clay_load_font_cjk"}
+  def self.load_font_cjk: (String path, Integer size) -> Integer
+
   # ── Render Command Access ──
 
   %a{cfunc: "konpeito_clay_cmd_type"}
@@ -133,6 +141,22 @@ module Clay
   %a{cfunc: "konpeito_clay_cmd_corner_radius"}
   def self.cmd_corner_radius: (Integer index) -> Float
 
+  # Integer bounding box accessors (for chart rendering)
+  %a{cfunc: "konpeito_clay_cmd_ix"}
+  def self.cmd_ix: (Integer index) -> Integer
+
+  %a{cfunc: "konpeito_clay_cmd_iy"}
+  def self.cmd_iy: (Integer index) -> Integer
+
+  %a{cfunc: "konpeito_clay_cmd_iw"}
+  def self.cmd_iw: (Integer index) -> Integer
+
+  %a{cfunc: "konpeito_clay_cmd_ih"}
+  def self.cmd_ih: (Integer index) -> Integer
+
+  %a{cfunc: "konpeito_clay_cmd_custom_data"}
+  def self.cmd_custom_data: (Integer index) -> Integer
+
   %a{cfunc: "konpeito_clay_cmd_border_width_top"}
   def self.cmd_border_width_top: (Integer index) -> Integer
 
@@ -142,6 +166,18 @@ module Clay
   %a{cfunc: "konpeito_clay_render_raylib"}
   def self.render_raylib: () -> void
 
+  # Store background color for live resize re-render
+  %a{cfunc: "konpeito_clay_set_bg_color"}
+  def self.set_bg_color: (Integer r, Integer g, Integer b) -> void
+
+  # Check if currently in a resize callback
+  %a{cfunc: "konpeito_clay_is_resizing"}
+  def self.is_resizing: () -> Integer
+
+  # Register live resize callback bridge
+  %a{cfunc: "konpeito_register_resize_callback"}
+  def self.register_resize_callback: () -> void
+
   # ── Scroll Update ──
 
   %a{cfunc: "konpeito_clay_update_scroll"}
@@ -210,4 +246,10 @@ module Clay
 
   %a{cfunc: "konpeito_clay_text_char"}
   def self.text_char: (Integer ch, Integer fid, Integer fsz, Float r, Float g, Float b) -> void
+
+  %a{cfunc: "konpeito_clay_textbuf_get_char"}
+  def self.textbuf_get_char: (Integer id, Integer pos) -> Integer
+
+  %a{cfunc: "konpeito_clay_textbuf_set_str"}
+  def self.textbuf_set_str: (Integer id, String str, Integer len) -> void
 end