enclave 0.1.0

data/ext/enclave/mruby/mrbgems/hal-win-socket/src/socket_hal.c

@@ -0,0 +1,177 @@
+/*
+** socket_hal.c - Windows HAL implementation for mruby-socket
+**
+** See Copyright Notice in mruby.h
+**
+** Windows implementation for socket operations using Winsock APIs.
+** Supported platforms: Windows, MinGW
+*/
+
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0501 // need Windows XP or later
+#endif
+
+#include <mruby.h>
+#include <mruby/string.h>
+#include <mruby/class.h>
+#include <mruby/error.h>
+#include <mruby/presym.h>
+#include "socket_hal.h"
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+#include <errno.h>
+#include <string.h>
+
+/*
+ * Socket HAL Initialization/Finalization
+ */
+
+void
+mrb_hal_socket_init(mrb_state *mrb)
+{
+  WSADATA wsaData;
+  int result = WSAStartup(MAKEWORD(2, 2), &wsaData);
+  if (result != NO_ERROR) {
+    mrb_raise(mrb, mrb_class_get_id(mrb, MRB_SYM(RuntimeError)), "WSAStartup failed");
+  }
+}
+
+void
+mrb_hal_socket_final(mrb_state *mrb)
+{
+  (void)mrb;
+  WSACleanup();
+}
+
+/*
+ * Socket Control Operations
+ */
+
+int
+mrb_hal_socket_set_nonblock(mrb_state *mrb, int fd, int nonblock)
+{
+  (void)mrb;
+  u_long mode = nonblock ? 1 : 0;
+  int result = ioctlsocket(fd, FIONBIO, &mode);
+  if (result != NO_ERROR) {
+    return -1;
+  }
+  return 0;
+}
+
+/*
+ * Address Conversion Functions
+ */
+
+const char*
+mrb_hal_socket_inet_ntop(int af, const void *src, char *dst, size_t size)
+{
+  if (af == AF_INET) {
+    struct sockaddr_in in = {0};
+    in.sin_family = AF_INET;
+    memcpy(&in.sin_addr, src, sizeof(struct in_addr));
+    if (getnameinfo((struct sockaddr*)&in, sizeof(struct sockaddr_in),
+                    dst, (DWORD)size, NULL, 0, NI_NUMERICHOST) == 0) {
+      return dst;
+    }
+    return NULL;
+  }
+  else if (af == AF_INET6) {
+    struct sockaddr_in6 in = {0};
+    in.sin6_family = AF_INET6;
+    memcpy(&in.sin6_addr, src, sizeof(struct in6_addr));
+    if (getnameinfo((struct sockaddr*)&in, sizeof(struct sockaddr_in6),
+                    dst, (DWORD)size, NULL, 0, NI_NUMERICHOST) == 0) {
+      return dst;
+    }
+    return NULL;
+  }
+  return NULL;
+}
+
+int
+mrb_hal_socket_inet_pton(int af, const char *src, void *dst)
+{
+  struct addrinfo hints = {0};
+  hints.ai_family = af;
+  hints.ai_flags = AI_NUMERICHOST;
+
+  struct addrinfo *res;
+  if (getaddrinfo(src, NULL, &hints, &res) != 0) {
+    return 0;  /* Invalid address */
+  }
+
+  if (res == NULL) {
+    return 0;
+  }
+
+  if (af == AF_INET && res->ai_family == AF_INET) {
+    memcpy(dst, &((struct sockaddr_in*)res->ai_addr)->sin_addr, sizeof(struct in_addr));
+    freeaddrinfo(res);
+    return 1;
+  }
+  else if (af == AF_INET6 && res->ai_family == AF_INET6) {
+    memcpy(dst, &((struct sockaddr_in6*)res->ai_addr)->sin6_addr, sizeof(struct in6_addr));
+    freeaddrinfo(res);
+    return 1;
+  }
+
+  freeaddrinfo(res);
+  return 0;
+}
+
+/*
+ * Platform-Specific Socket Features
+ */
+
+mrb_value
+mrb_hal_socket_sockaddr_un(mrb_state *mrb, const char *path, size_t pathlen)
+{
+  (void)path;
+  (void)pathlen;
+  mrb_raise(mrb, mrb_class_get_id(mrb, MRB_SYM(NotImplementedError)),
+            "sockaddr_un unsupported on Windows");
+  return mrb_nil_value();
+}
+
+int
+mrb_hal_socket_socketpair(mrb_state *mrb, int domain, int type, int protocol, int sv[2])
+{
+  (void)mrb;
+  (void)domain;
+  (void)type;
+  (void)protocol;
+  (void)sv;
+  /* socketpair is not supported on Windows */
+  errno = ENOSYS;
+  return -1;
+}
+
+mrb_value
+mrb_hal_socket_unix_path(mrb_state *mrb, const char *sockaddr, size_t socklen)
+{
+  (void)sockaddr;
+  (void)socklen;
+  mrb_raise(mrb, mrb_class_get_id(mrb, MRB_SYM(NotImplementedError)),
+            "unix_path unsupported on Windows");
+  return mrb_nil_value();
+}
+
+/*
+ * Gem initialization
+ */
+
+void
+mrb_hal_win_socket_gem_init(mrb_state *mrb)
+{
+  (void)mrb;
+  /* HAL interface functions are called by mruby-socket gem */
+}
+
+void
+mrb_hal_win_socket_gem_final(mrb_state *mrb)
+{
+  (void)mrb;
+  /* Cleanup handled by mrb_hal_socket_final called from mruby-socket */
+}

data/ext/enclave/mruby/mrbgems/hal-win-task/README.md

@@ -0,0 +1,109 @@
+# hal-win-task
+
+Windows Hardware Abstraction Layer (HAL) implementation for mruby-task.
+
+## Description
+
+Provides timer and interrupt support for the mruby-task cooperative scheduler on Windows platforms. Uses multimedia timer (`timeSetEvent`/`timeKillEvent`) for periodic timer ticks, and `CRITICAL_SECTION` for interrupt protection.
+
+## Supported Platforms
+
+- Windows 7 and later
+- Windows Server 2008 R2 and later
+- All versions with multimedia timer support
+
+## Requirements
+
+- Windows operating system
+- Multimedia timer API (`winmm.lib`)
+- Visual C++, MinGW, or compatible compiler
+
+## Usage
+
+### Explicit HAL Selection (Recommended)
+
+```ruby
+MRuby::Build.new do |conf|
+  # ... other configuration ...
+
+  # Specify Windows HAL - automatically brings in mruby-task
+  conf.gem core: 'hal-win-task'
+end
+```
+
+### Auto-detection (Development)
+
+```ruby
+MRuby::Build.new do |conf|
+  # ... other configuration ...
+
+  # Auto-detects and selects hal-win-task on Windows platforms
+  conf.gem core: 'mruby-task'
+end
+```
+
+## Implementation Details
+
+### Timer Mechanism
+
+- Uses Windows multimedia timer (`timeSetEvent`) for periodic callbacks
+- Timer interval configured by `MRB_TICK_UNIT` (default: 4ms)
+- `TIME_KILL_SYNCHRONOUS` flag ensures clean timer shutdown
+- Requests 1ms timer resolution via `timeBeginPeriod(1)`
+
+### Interrupt Protection
+
+- Critical sections protected using `CRITICAL_SECTION` objects
+- Prevents race conditions during task queue modifications
+- `EnterCriticalSection`/`LeaveCriticalSection` used for mutual exclusion
+- Supports nested critical sections (automatic lock counting)
+
+### Multi-VM Support
+
+- Supports up to `MRB_TASK_MAX_VMS` concurrent mruby VM instances (default: 8)
+- Single shared timer ticks all registered VMs
+- Per-VM task counters optimize timer usage (timer disabled when idle)
+- Interlocked operations (`InterlockedIncrement`/`InterlockedDecrement`) for thread safety
+
+### Timer Optimization
+
+The implementation dynamically enables/disables the timer based on task state:
+
+- **Timer enabled** when: Multiple ready tasks OR any waiting tasks exist
+- **Timer disabled** when: Single task or all tasks dormant/suspended
+- Reduces CPU usage and power consumption when scheduler is idle
+
+## Configuration
+
+Override these macros in your build config if needed:
+
+```ruby
+conf.gem core: 'hal-win-task' do |spec|
+  # Custom tick interval (10ms instead of default 4ms)
+  spec.build.defines << 'MRB_TICK_UNIT=10'
+
+  # Custom timeslice (5 ticks instead of default 3)
+  spec.build.defines << 'MRB_TIMESLICE_TICK_COUNT=5'
+
+  # More concurrent VMs (16 instead of default 8)
+  spec.build.defines << 'MRB_TASK_MAX_VMS=16'
+end
+```
+
+## Known Limitations
+
+- Timer resolution typically limited to 1-2ms even with `timeBeginPeriod(1)`
+- Multimedia timers consume system resources (kernel timer objects)
+- Timer callbacks execute in separate thread context (handled internally)
+- Not suitable for hard real-time requirements
+- May interfere with other multimedia applications requesting different timer resolutions
+
+## See Also
+
+- `mruby-task` - Core task scheduler
+- `hal-posix-task` - POSIX/Unix HAL implementation
+- Task scheduler documentation: `mrbgems/mruby-task/README.md`
+
+## Build Notes
+
+The `winmm` library is automatically linked by the gem specification. No additional linker configuration is needed.

data/ext/enclave/mruby/mrbgems/hal-win-task/mrbgem.rake

@@ -0,0 +1,11 @@
+MRuby::Gem::Specification.new('hal-win-task') do |spec|
+  spec.license = 'MIT'
+  spec.authors = 'mruby developers'
+  spec.summary = 'Windows HAL for mruby-task'
+
+  # HAL gem depends on feature gem - brings in mruby-task automatically
+  spec.add_dependency 'mruby-task', core: 'mruby-task'
+
+  # Windows multimedia timer library
+  spec.linker.libraries << 'winmm'
+end

data/ext/enclave/mruby/mrbgems/hal-win-task/src/task_hal.c

@@ -0,0 +1,187 @@
+/*
+** task_hal.c - Windows HAL implementation for mruby-task
+**
+** See Copyright Notice in mruby.h
+**
+** Windows implementation using multimedia timer (timeSetEvent/timeKillEvent)
+** for periodic timer, and CRITICAL_SECTION for interrupt protection.
+**
+** Supported platforms: Windows (all versions with multimedia timer support)
+*/
+
+#include <mruby.h>
+#include "task_hal.h"
+#include <windows.h>
+#include <timeapi.h>
+#include <stdint.h>
+
+/* Multi-VM support */
+static mrb_state *vm_list[MRB_TASK_MAX_VMS];
+static volatile LONG vm_count = 0;
+static CRITICAL_SECTION irq_lock;
+static MMRESULT timer_id = 0;
+
+/* Multimedia timer callback - called periodically by Windows */
+static void CALLBACK
+timer_callback(UINT uID, UINT uMsg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
+{
+  int i;
+  (void)uID; (void)uMsg; (void)dwUser; (void)dw1; (void)dw2;
+
+  /* Tick all registered VMs */
+  EnterCriticalSection(&irq_lock);
+  for (i = 0; i < vm_count; i++) {
+    if (vm_list[i]) {
+      mrb_tick(vm_list[i]);
+    }
+  }
+  LeaveCriticalSection(&irq_lock);
+}
+
+/*
+ * HAL Interface Implementation
+ */
+
+void
+mrb_hal_task_init(mrb_state *mrb)
+{
+  int i;
+  LONG idx;
+
+  /* Initialize task state */
+  for (i = 0; i < 4; i++) {
+    mrb->task.queues[i] = NULL;
+  }
+  mrb->task.tick = 0;
+  mrb->task.wakeup_tick = UINT32_MAX;
+  mrb->task.switching = FALSE;
+
+  /* Initialize critical section on first VM */
+  if (vm_count == 0) {
+    InitializeCriticalSection(&irq_lock);
+  }
+
+  EnterCriticalSection(&irq_lock);
+
+  /* Check if this VM is already registered */
+  idx = -1;
+  for (i = 0; i < vm_count; i++) {
+    if (vm_list[i] == mrb) {
+      idx = i;
+      break;
+    }
+  }
+
+  /* Register new VM if not already present */
+  if (idx < 0) {
+    if (vm_count >= MRB_TASK_MAX_VMS) {
+      LeaveCriticalSection(&irq_lock);
+      mrb_raisef(mrb, E_RUNTIME_ERROR,
+                 "too many mrb_states with task scheduler (max: %d)",
+                 MRB_TASK_MAX_VMS);
+    }
+    vm_list[vm_count] = mrb;
+    InterlockedIncrement(&vm_count);
+  }
+
+  /* Start timer for first VM */
+  if (vm_count == 1) {
+    /* Request 1ms timer resolution */
+    timeBeginPeriod(1);
+
+    /* Create periodic timer with MRB_TICK_UNIT interval */
+    timer_id = timeSetEvent(
+      MRB_TICK_UNIT,           /* interval in milliseconds */
+      1,                        /* resolution in milliseconds */
+      timer_callback,           /* callback function */
+      0,                        /* user data */
+      TIME_PERIODIC | TIME_KILL_SYNCHRONOUS
+    );
+  }
+
+  LeaveCriticalSection(&irq_lock);
+}
+
+void
+mrb_task_enable_irq(void)
+{
+  LeaveCriticalSection(&irq_lock);
+}
+
+void
+mrb_task_disable_irq(void)
+{
+  EnterCriticalSection(&irq_lock);
+}
+
+void
+mrb_hal_task_idle_cpu(mrb_state *mrb)
+{
+  (void)mrb;
+  /* On Windows, just sleep briefly */
+  Sleep(MRB_TICK_UNIT);
+}
+
+void
+mrb_hal_task_sleep_us(mrb_state *mrb, mrb_int usec)
+{
+  (void)mrb;
+
+  /* Windows Sleep() takes milliseconds, convert from microseconds */
+  if (usec >= 0) {
+    Sleep((DWORD)(usec / 1000));
+  }
+}
+
+void
+mrb_hal_task_final(mrb_state *mrb)
+{
+  int i, j;
+
+  EnterCriticalSection(&irq_lock);
+
+  /* Find and remove this VM from the list */
+  for (i = 0; i < vm_count; i++) {
+    if (vm_list[i] == mrb) {
+      /* Shift remaining VMs down */
+      for (j = i; j < vm_count - 1; j++) {
+        vm_list[j] = vm_list[j + 1];
+      }
+      vm_list[vm_count - 1] = NULL;
+      InterlockedDecrement(&vm_count);
+      break;
+    }
+  }
+
+  /* Stop timer if last VM */
+  if (vm_count == 0) {
+    if (timer_id != 0) {
+      timeKillEvent(timer_id);
+      timeEndPeriod(1);
+      timer_id = 0;
+    }
+    LeaveCriticalSection(&irq_lock);
+    DeleteCriticalSection(&irq_lock);
+  }
+  else {
+    LeaveCriticalSection(&irq_lock);
+  }
+}
+
+/*
+ * Gem initialization (empty - HAL functions called by mruby-task)
+ */
+
+void
+mrb_hal_win_task_gem_init(mrb_state *mrb)
+{
+  (void)mrb;
+  /* HAL interface functions are called by mruby-task gem */
+}
+
+void
+mrb_hal_win_task_gem_final(mrb_state *mrb)
+{
+  (void)mrb;
+  /* Cleanup handled by mrb_hal_task_final called from mruby-task */
+}

data/ext/enclave/mruby/mrbgems/math.gembox

@@ -0,0 +1,12 @@
+# It also works with MRB_NO_STDIO.
+
+MRuby::GemBox.new do |conf|
+  # Use standard Math module
+  conf.gem :core => "mruby-math"
+
+  # Use Rational/Complex numbers
+  conf.gem :core => "mruby-rational"
+  conf.gem :core => "mruby-complex"
+  # Use Multi-precision Integer
+  conf.gem :core => "mruby-bigint"
+end

data/ext/enclave/mruby/mrbgems/metaprog.gembox

@@ -0,0 +1,21 @@
+# It also works with MRB_NO_STDIO and MRB_NO_FLOAT.
+
+MRuby::GemBox.new do |conf|
+  # Meta-programming features
+  conf.gem :core => "mruby-metaprog"
+
+  # Use Method/UnboundMethod class
+  conf.gem :core => "mruby-method"
+
+  # Use eval()
+  conf.gem :core => "mruby-eval"
+
+  # Use binding()
+  conf.gem :core => "mruby-binding"
+
+  # Use Proc#binding()
+  conf.gem :core => "mruby-proc-binding"
+
+  # Use mruby-compiler to build other mrbgems
+  conf.gem :core => "mruby-compiler"
+end

data/ext/enclave/mruby/mrbgems/mruby-array-ext/README.md

@@ -0,0 +1,87 @@
+# mruby-array-ext
+
+This mrbgem extends the `Array` class in mruby, providing a rich set of additional methods for array manipulation. These extensions enhance mruby's built-in array capabilities, offering functionalities commonly found in standard Ruby.
+
+## Functionality
+
+The `mruby-array-ext` gem adds the following methods to the `Array` class:
+
+### Set Operations
+
+- `uniq`: Returns a new array by removing duplicate values.
+- `uniq!`: Removes duplicate elements from self. Returns `nil` if no changes are made.
+- `-` (difference): Returns a new array that is a copy of the original array, removing any items that also appear in another array.
+- `|` (union): Returns a new array by joining this array with another array, removing duplicates.
+- `&` (intersection): Returns a new array containing elements common to two arrays, with no duplicates.
+- `difference`: Returns a new array that is a copy of the original array, removing all occurrences of any item that also appear in the specified other arrays.
+- `union`: Returns a new array by joining this array with other arrays, removing duplicates.
+- `intersection`: Returns a new array containing elements common to this array and specified other arrays, removing duplicates.
+- `intersect?`: Returns `true` if the array and another array have at least one element in common.
+
+### Element Manipulation and Access
+
+- `flatten`: Returns a new array that is a one-dimensional flattening of self.
+- `flatten!`: Flattens self in place. Returns `nil` if no modifications were made.
+- `fetch`: Tries to return the element at a given position. Throws an `IndexError` if the index is out of bounds, unless a default value or block is provided.
+- `fill`: Sets selected elements of self to a given object or the result of a block.
+- `compact`: Returns a copy of self with all `nil` elements removed.
+- `compact!`: Removes `nil` elements from self. Returns `nil` if no changes were made.
+- `rotate(count=1)`: Returns a new array by rotating self so that the element at `count` is the first element.
+- `rotate!(count=1)`: Rotates self in place.
+- `insert(index, obj...)`: Inserts the given values before the element with the given index.
+- `slice!(index)` / `slice!(start, length)` / `slice!(range)`: Deletes element(s) given by an index or range and returns the deleted object(s).
+- `at(index)`: Returns the element at `index`. Returns `nil` if the index is out of range.
+- `dig(idx, ...)`: Extracts a nested value specified by a sequence of indices.
+- `fetch_values(idx, ...)`: Returns an array containing the values associated with the given indexes. Raises `IndexError` if an index is not found, unless a block is provided.
+- `values_at(selector, ...)`: Returns an array containing the elements corresponding to the given selector(s).
+
+### Searching and Comparison
+
+- `assoc(obj)`: Searches through an array of arrays, comparing `obj` with the first element of each contained array. Returns the first matching contained array or `nil`.
+- `rassoc(obj)`: Searches through an array of arrays, comparing `obj` with the second element of each contained array. Returns the first matching contained array or `nil`.
+- `bsearch { |x| block }`: Finds a value from the array which meets the given condition using binary search.
+- `bsearch_index { |x| block }`: Finds the index of a value from the array which meets the given condition using binary search.
+
+### Iterators and Combinatorics
+
+- `reverse_each`: Calls the given block for each element in reverse order.
+- `permutation(n=self.size)`: Yields all permutations of length `n` of the elements of the array.
+- `combination(n)`: Yields all combinations of length `n` of elements from the array.
+- `product(*arys)`: Returns an array of all combinations of elements from self and the given arrays.
+- `repeated_combination(n)`: Yields all repeated combinations of length `n`.
+- `repeated_permutation(n)`: Yields all repeated permutations of length `n`.
+
+### Conversions and Other Utilities
+
+- `to_h`: Returns the result of interpreting the array as an array of `[key, value]` pairs.
+- `transpose`: Assumes that self is an array of arrays and transposes the rows and columns.
+
+### Filtering
+
+- `delete_if { |item| block }`: Deletes every element of self for which the block evaluates to `true`.
+- `reject! { |item| block }`: Equivalent to `delete_if`, but returns `nil` if no changes were made.
+- `keep_if { |item| block }`: Deletes every element of self for which the given block evaluates to `false`.
+- `select! { |item| block }`: Deletes elements for which the block returns a `false` value. Returns `self` if changes were made, otherwise `nil`.
+
+### Aliases
+
+- `append` (alias for `push`)
+- `prepend` (alias for `unshift`)
+- `filter!` (alias for `select!`)
+
+## Usage
+
+To use this gem, add it to your `build_config.rb` or `mrbgem.rake` file. For detailed examples of each method, please refer to the comments in the source code (`mrblib/array.rb` and `src/array.c`).
+
+Example:
+
+```ruby
+a = [1, 2, 2, 3, nil, 4]
+p a.compact #=> [1, 2, 2, 3, 4]
+p a.uniq    #=> [1, 2, 3, nil, 4]
+
+b = ["a", "b", "c"]
+p b.rotate #=> ["b", "c", "a"]
+```
+
+This gem is part of the mruby project.

data/ext/enclave/mruby/mrbgems/mruby-array-ext/mrbgem.rake

@@ -0,0 +1,5 @@
+MRuby::Gem::Specification.new('mruby-array-ext') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'Array class extension'
+end