enclave 0.1.0

data/ext/enclave/mruby/mrbgems/mruby-objectspace/test/objectspace.rb

@@ -0,0 +1,60 @@
+assert('ObjectSpace.count_objects') do
+  h = {}
+  f = Fiber.new {} if Object.const_defined?(:Fiber)
+  ObjectSpace.count_objects(h)
+  assert_kind_of(Hash, h)
+  assert_true(h.keys.all? {|x| x.is_a?(Symbol) || x.is_a?(Integer) })
+  assert_true(h.values.all? {|x| x.is_a?(Integer) })
+
+  assert_true(h.has_key?(:TOTAL))
+  assert_true(h.has_key?(:FREE))
+  assert_true(h.has_key?(:T_FIBER)) if Object.const_defined? :Fiber
+
+  assert_equal(h[:TOTAL] * 2, h.values.reduce(:+))
+
+  h = ObjectSpace.count_objects
+  assert_kind_of(Hash, h)
+  assert_true(h.keys.all? {|x| x.is_a?(Symbol) || x.is_a?(Integer) })
+  assert_true(h.values.all? {|x| x.is_a?(Integer) })
+
+  assert_raise(TypeError) { ObjectSpace.count_objects(1) }
+
+  h0 = {:T_FOO=>1000}
+  h = ObjectSpace.count_objects(h0)
+  assert_false(h0.has_key?(:T_FOO))
+
+  GC.start
+  h_after = {}
+  h_before = ObjectSpace.count_objects
+
+  objs = []
+  1000.times do
+    objs << {}
+  end
+  ObjectSpace.count_objects(h)
+  objs = nil
+  GC.start
+  ObjectSpace.count_objects(h_after)
+
+  assert_equal(h[:T_HASH], h_before[:T_HASH] + 1000)
+  assert_equal(h_after[:T_HASH], h_before[:T_HASH])
+end
+
+assert('ObjectSpace.each_object') do
+  objs = []
+  objs_count = ObjectSpace.each_object { |obj|
+    objs << obj
+  }
+  assert_equal objs.length, objs_count
+
+  arys = []
+  arys_count = ObjectSpace.each_object(Array) { |obj|
+    arys << obj
+  }
+  assert_equal arys.length, arys_count
+  assert_true arys.length < objs.length
+end
+
+assert 'Check class pointer of ObjectSpace.each_object.' do
+  assert_nothing_raised { ObjectSpace.each_object { |obj| !obj } }
+end

data/ext/enclave/mruby/mrbgems/mruby-os-memsize/README.md

@@ -0,0 +1,75 @@
+# mruby-os-memsize
+
+## Description
+
+The `mruby-os-memsize` mrbgem extends the `ObjectSpace` module in mruby, providing tools to inspect the approximate amount of heap memory allocated for objects. This can be useful for debugging memory usage and understanding the memory footprint of your mruby application.
+
+## Usage / API
+
+This gem adds two class methods to the `ObjectSpace` module:
+
+### `ObjectSpace.memsize_of(obj) -> Numeric`
+
+Returns the approximate amount of heap memory allocated for the given `obj` in bytes.
+
+- The returned value is platform-dependent, as it's based on the `size_t` type of the underlying C implementation.
+- Immediate values (e.g., integers, booleans, symbols) and some small, embedded objects (like short strings or small arrays that fit directly into an object pointer) will typically report a size of 0 or a very small, fixed size representing the object pointer itself.
+- The accuracy of the reported size can vary depending on the object's type and internal structure.
+
+**Example:**
+
+```ruby
+str = "This is a test string"
+array = [1, 2, 3, 4, 5]
+
+puts "Size of string: #{ObjectSpace.memsize_of(str)} bytes"
+puts "Size of array: #{ObjectSpace.memsize_of(array)} bytes"
+puts "Size of 123: #{ObjectSpace.memsize_of(123)}" # Likely 0
+puts "Size of :symbol: #{ObjectSpace.memsize_of(:symbol)}" # Likely 0
+
+class MyClass
+  def initialize
+    @data = "some internal data"
+  end
+end
+instance = MyClass.new
+puts "Size of MyClass instance: #{ObjectSpace.memsize_of(instance)}"
+```
+
+### `ObjectSpace.memsize_of_all([klass]) -> Numeric`
+
+Returns the total approximate heap memory allocated for all living objects in the mruby environment.
+
+- If an optional `klass` argument (a Class object) is provided, it returns the total memory size only for instances of that specific class.
+
+**Example:**
+
+```ruby
+# Get total memory size of all objects
+total_memory = ObjectSpace.memsize_of_all
+puts "Total heap memory used by all objects: #{total_memory} bytes"
+
+# Get total memory size for all String objects
+total_string_memory = ObjectSpace.memsize_of_all(String)
+puts "Total heap memory used by Strings: #{total_string_memory} bytes"
+
+class Person
+  def initialize(name)
+    @name = name
+  end
+end
+
+p1 = Person.new("Alice")
+p2 = Person.new("Bob")
+
+total_person_memory = ObjectSpace.memsize_of_all(Person)
+puts "Total heap memory used by Person instances: #{total_person_memory} bytes"
+```
+
+## License
+
+This mrbgem is released under the MIT License. (See `mrbgem.rake` for details within the mruby distribution).
+
+## Author
+
+mruby developers

data/ext/enclave/mruby/mrbgems/mruby-os-memsize/mrbgem.rake

@@ -0,0 +1,10 @@
+MRuby::Gem::Specification.new('mruby-os-memsize') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'ObjectSpace memsize_of method'
+
+  spec.add_dependency('mruby-objectspace', :core => 'mruby-objectspace')
+  spec.add_test_dependency('mruby-metaprog', :core => 'mruby-metaprog')
+  spec.add_test_dependency('mruby-method', :core => 'mruby-method')
+  spec.add_test_dependency('mruby-fiber', :core => 'mruby-fiber')
+end

data/ext/enclave/mruby/mrbgems/mruby-os-memsize/src/memsize.c

@@ -0,0 +1,271 @@
+#include <mruby.h>
+#include <mruby/error.h>
+#include <mruby/gc.h>
+#include <mruby/hash.h>
+#include <mruby/class.h>
+#include <mruby/object.h>
+#include <mruby/numeric.h>
+#include <mruby/string.h>
+#include <mruby/array.h>
+#include <mruby/variable.h>
+#include <mruby/proc.h>
+#include <mruby/value.h>
+#include <mruby/range.h>
+#include <mruby/internal.h>
+
+static size_t
+os_memsize_of_irep(mrb_state* state, const struct mrb_irep *irep)
+{
+  size_t size = (irep->slen * sizeof(mrb_sym)) +
+                (irep->plen * sizeof(mrb_irep_pool)) +
+                (irep->ilen * sizeof(mrb_code)) +
+                (irep->rlen * sizeof(struct mrb_irep*));
+
+  for (int i = 0; i < irep->plen; i++) {
+    const mrb_irep_pool *p = &irep->pool[i];
+    if ((p->tt & IREP_TT_NFLAG) == 0) { /* string pool value */
+      size += (p->tt>>2);
+    }
+    else if (p->tt == IREP_TT_BIGINT) { /* bigint pool value */
+      size += p->u.str[0];
+    }
+  }
+
+  for (int i = 0; i < irep->rlen; i++) {
+    size += sizeof(struct mrb_irep); /* size of irep structure */
+    size += os_memsize_of_irep(state, irep->reps[i]);
+  }
+  return size;
+}
+
+static size_t
+os_memsize_of_method(mrb_state* mrb, mrb_value method_obj)
+{
+  mrb_value proc_value = mrb_obj_iv_get(mrb, mrb_obj_ptr(method_obj),
+                                        mrb_intern_lit(mrb, "_proc"));
+  if (mrb_nil_p(proc_value)) return 0;
+  struct RProc *proc = mrb_proc_ptr(proc_value);
+
+  size_t size = sizeof(struct RProc);
+  if (!MRB_PROC_CFUNC_P(proc)) size += os_memsize_of_irep(mrb, proc->body.irep);
+  return size;
+}
+
+static mrb_bool
+obj_is_kind_of_checked(mrb_state *mrb, mrb_value obj, const char *classname)
+{
+  mrb_value objclass = mrb_obj_value(mrb->object_class);
+
+  if (mrb_const_defined(mrb, objclass, mrb_intern_cstr(mrb, classname))) {
+    struct RClass *klass = mrb_class_get(mrb, classname);
+    return mrb_obj_is_kind_of(mrb, obj, klass);
+  }
+
+  return FALSE;
+}
+
+static size_t
+os_memsize_of_object(mrb_state* mrb, mrb_value obj)
+{
+  size_t size = 0;
+
+  switch(mrb_type(obj)) {
+    case MRB_TT_STRING:
+      size += mrb_objspace_page_slot_size();
+      if (!RSTR_EMBED_P(RSTRING(obj)) && !RSTR_SHARED_P(RSTRING(obj))) {
+        size += RSTRING_CAPA(obj);
+        size++; /* NUL terminator */
+      }
+      break;
+    case MRB_TT_CLASS:
+    case MRB_TT_MODULE:
+    case MRB_TT_SCLASS:
+    case MRB_TT_ICLASS:
+      size += mrb_class_mt_memsize(mrb, mrb_class_ptr(obj));
+      /* fall through */
+    case MRB_TT_EXCEPTION:
+    case MRB_TT_OBJECT: {
+      size += mrb_objspace_page_slot_size();
+      size += mrb_obj_iv_tbl_memsize(obj);
+      if (obj_is_kind_of_checked(mrb, obj, "UnboundMethod") ||
+          obj_is_kind_of_checked(mrb, obj, "Method")) {
+        size += os_memsize_of_method(mrb, obj);
+      }
+      break;
+    }
+    case MRB_TT_HASH: {
+      size += mrb_objspace_page_slot_size() +
+              mrb_hash_memsize(obj);
+      break;
+    }
+    case MRB_TT_STRUCT:
+    case MRB_TT_ARRAY: {
+      mrb_int len = RARRAY_LEN(obj);
+      /* Arrays that do not fit within an RArray perform a heap allocation
+      *  storing an array of pointers to the original objects*/
+      size += mrb_objspace_page_slot_size();
+      if (len > MRB_ARY_EMBED_LEN_MAX)
+        size += sizeof(mrb_value*) * len;
+      break;
+    }
+    case MRB_TT_PROC: {
+      struct RProc* proc = mrb_proc_ptr(obj);
+      size += mrb_objspace_page_slot_size();
+      size += MRB_ENV_LEN(proc->e.env) * sizeof(mrb_value);
+      if (!MRB_PROC_CFUNC_P(proc))
+        size += os_memsize_of_irep(mrb, proc->body.irep);
+      break;
+    }
+    case MRB_TT_RANGE:
+#ifndef MRB_RANGE_EMBED
+      size += mrb_objspace_page_slot_size() +
+              sizeof(struct mrb_range_edges);
+#endif
+      break;
+    case MRB_TT_FIBER: {
+      struct RFiber* f = (struct RFiber*)mrb_ptr(obj);
+      ptrdiff_t stack_size = f->cxt->stend - f->cxt->stbase;
+      ptrdiff_t ci_size = f->cxt->ciend - f->cxt->cibase;
+
+      size += mrb_objspace_page_slot_size() +
+        sizeof(struct mrb_context) +
+        sizeof(mrb_value) * stack_size +
+        sizeof(mrb_callinfo) * ci_size;
+      break;
+    }
+#ifndef MRB_NO_FLOAT
+    case MRB_TT_FLOAT:
+#endif
+    case MRB_TT_INTEGER:
+      if (mrb_immediate_p(obj))
+        break;
+    case MRB_TT_RATIONAL:
+#if defined(MRB_USE_RATIONAL)
+#if defined(MRB_INT64) && defined(MRB_32BIT)
+      size += sizeof(mrb_int)*2;
+#endif
+      size += mrb_objspace_page_slot_size();
+#endif
+      break;
+
+    case MRB_TT_COMPLEX:
+#if defined(MRB_USE_COMPLEX)
+#if defined(MRB_32BIT) && !defined(MRB_USE_FLOAT32)
+      size += sizeof(mrb_float)*2;
+#endif
+      size += mrb_objspace_page_slot_size();
+#endif
+      break;
+#if defined(MRB_USE_SET)
+    case MRB_TT_SET:
+      size += mrb_set_memsize(obj);
+      break;
+#endif
+    case MRB_TT_BIGINT:
+#if defined(MRB_USE_BIGINT)
+      size += mrb_bint_memsize(obj);
+      /* fall through */
+#endif
+    case MRB_TT_CDATA:
+    case MRB_TT_ISTRUCT:
+      size += mrb_objspace_page_slot_size();
+      break;
+    case MRB_TT_BACKTRACE:
+      size += ((struct RBacktrace*)mrb_obj_ptr(obj))->len * sizeof(struct mrb_backtrace_location);
+      break;
+    /*  zero heap size types.
+     *  immediate VM stack values, contained within mrb_state, or on C stack */
+    case MRB_TT_TRUE:
+    case MRB_TT_FALSE:
+    case MRB_TT_BREAK:
+    case MRB_TT_CPTR:
+    case MRB_TT_SYMBOL:
+    case MRB_TT_FREE:
+    case MRB_TT_UNDEF:
+    case MRB_TT_ENV:
+    /* never used, silences compiler warning
+     * not having a default: clause lets the compiler tell us when there is a new
+     * TT not accounted for */
+    case MRB_TT_MAXDEFINE:
+      break;
+  }
+  return size;
+}
+
+/*
+ *  call-seq:
+ *    ObjectSpace.memsize_of(obj) -> Numeric
+ *
+ *  Returns the amount of heap memory allocated for object in size_t units.
+ *
+ *  The return value depends on the definition of size_t on that platform,
+ *  therefore the value is not comparable across platform types.
+ *
+ *  Immediate values such as integers, booleans, symbols and unboxed float numbers
+ *  return 0. Additionally special objects which are small enough to fit inside an
+ *  object pointer, termed embedded objects, will return the size of the object pointer.
+ *  Strings and arrays below a compile-time defined size may be embedded.
+ */
+
+static mrb_value
+os_memsize_of(mrb_state *mrb, mrb_value self)
+{
+  mrb_value obj = mrb_get_arg1(mrb);
+
+  size_t total = os_memsize_of_object(mrb, obj);
+  return mrb_fixnum_value((mrb_int)total);
+}
+
+struct os_memsize_of_all_cb_data {
+  size_t t;
+  struct RClass *type;
+};
+
+static int
+os_memsize_of_all_cb(mrb_state *mrb, struct RBasic *obj, void *d)
+{
+  struct os_memsize_of_all_cb_data *data = (struct os_memsize_of_all_cb_data*)d;
+  switch (obj->tt) {
+  case MRB_TT_FREE: case MRB_TT_ENV:
+  case MRB_TT_BREAK: case MRB_TT_ICLASS:
+    /* internal objects that should not be counted */
+    return MRB_EACH_OBJ_OK;
+  default:
+    break;
+  }
+  /* skip Proc objects for methods */
+  if (obj->c == NULL) return 0;
+  if (data->type == NULL || mrb_obj_is_kind_of(mrb, mrb_obj_value(obj), data->type))
+    data->t += os_memsize_of_object(mrb, mrb_obj_value(obj));
+  return MRB_EACH_OBJ_OK;
+}
+
+/*
+ *  call-seq:
+ *    ObjectSpace.memsize_of_all([klass]) -> Numeric
+ *
+ *  Return consuming memory size of all living objects of type klass.
+ *
+ */
+
+static mrb_value
+os_memsize_of_all(mrb_state *mrb, mrb_value self)
+{
+  struct os_memsize_of_all_cb_data data = { 0 };
+  mrb_get_args(mrb, "|c", &data.type);
+  mrb_objspace_each_objects(mrb, os_memsize_of_all_cb, &data);
+  return mrb_fixnum_value((mrb_int)data.t);
+}
+
+void
+mrb_mruby_os_memsize_gem_init(mrb_state *mrb)
+{
+  struct RClass *os = mrb_module_get(mrb, "ObjectSpace");
+  mrb_define_class_method(mrb, os, "memsize_of", os_memsize_of, MRB_ARGS_REQ(1));
+  mrb_define_class_method(mrb, os, "memsize_of_all", os_memsize_of_all, MRB_ARGS_OPT(1));
+}
+
+void
+mrb_mruby_os_memsize_gem_final(mrb_state *mrb)
+{
+}

data/ext/enclave/mruby/mrbgems/mruby-os-memsize/test/memsize.rb

@@ -0,0 +1,63 @@
+assert 'ObjectSpace.memsize_of' do
+  # immediate literals
+  int_size = ObjectSpace.memsize_of 1
+  assert_equal int_size, 0, 'int zero'
+
+  sym_size = ObjectSpace.memsize_of :foo
+  assert_equal sym_size, 0, 'sym zero'
+
+  assert_equal ObjectSpace.memsize_of(true), int_size
+  assert_equal ObjectSpace.memsize_of(false), int_size
+
+  assert_not_equal ObjectSpace.memsize_of('a'), 0, 'memsize of str'
+
+  if __ENCODING__ == "UTF-8"
+    assert_not_equal ObjectSpace.memsize_of("こんにちは世界"), 0, 'memsize of utf8 str'
+  end
+
+  # class defs
+  class_obj_size = ObjectSpace.memsize_of Class
+  assert_not_equal class_obj_size, 0, 'Class obj not zero'
+
+  empty_class_def_size = ObjectSpace.memsize_of Class.new
+  assert_not_equal empty_class_def_size, 0, 'Class def not zero'
+
+  proc_size = ObjectSpace.memsize_of Proc.new { x = 1; x }
+  assert_not_equal proc_size, 0
+
+  class_with_methods = Class.new do
+    def foo
+      a = 0
+      a + 1
+    end
+  end
+
+  m_size = ObjectSpace.memsize_of class_with_methods.instance_method(:foo)
+  assert_not_equal m_size, 0, 'method size not zero'
+
+  # collections
+  empty_array_size = ObjectSpace.memsize_of []
+  assert_not_equal empty_array_size, 0, 'empty array size not zero'
+  assert_operator empty_array_size, :<, ObjectSpace.memsize_of(Array.new(16)), 'large array size greater than embed'
+
+  # fiber
+  empty_fiber_size = ObjectSpace.memsize_of(Fiber.new {})
+  assert_not_equal empty_fiber_size, 0, 'empty fiber not zero'
+
+  #hash
+  assert_not_equal ObjectSpace.memsize_of({}), 0, 'empty hash size not zero'
+end
+
+assert 'ObjectSpace.memsize_of_all' do
+  foo_class = Class.new do
+    def initialize
+      @a = 'a'
+      @b = 'b'
+    end
+  end
+
+  foos = Array.new(10) { foo_class.new }
+  foo_size = ObjectSpace.memsize_of(foos.first)
+
+  assert_equal ObjectSpace.memsize_of_all(foo_class), foo_size * foos.size, 'Memsize of all instance'
+end

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

@@ -0,0 +1,140 @@
+# mruby-pack
+
+The `mruby-pack` mrbgem enhances mruby by providing `Array#pack` and `String#unpack` methods. These methods facilitate the conversion between Ruby data types (specifically arrays and strings) and binary data representations, offering a powerful way to handle binary data.
+
+## Installation
+
+Add the line below into your build configuration:
+
+```ruby
+conf.gem :core => 'mruby-pack'
+```
+
+There is no dependency on other mrbgems.
+
+## `Array#pack`
+
+The `Array#pack` method converts an array into a binary string. It takes a template string as an argument, which dictates how each element in the array should be converted and packed into the resulting binary string. The template string consists of directives, where each directive specifies the type and format of the data to be packed.
+
+**Example:**
+
+```ruby
+arr = [65, 66, 67]
+binary_string = arr.pack("ccc") # Packs three 8-bit signed integers
+# binary_string will be "ABC"
+
+arr2 = [72, 101, 108, 108, 111]
+binary_string2 = arr2.pack("C*") # Packs all elements as 8-bit unsigned integers
+# binary_string2 will be "Hello"
+
+arr3 = [0x1234, 0x5678]
+binary_string3 = arr3.pack("S>2") # Packs two 16-bit unsigned integers, big-endian
+# binary_string3 will be "\x12\x34\x56\x78" (depending on native endianness if S is used without > or <)
+# Using "n2" would be more explicit for network (big-endian) byte order:
+# binary_string3 = arr3.pack("n2") # Packs two 16-bit unsigned, network (big-endian) byte order
+# binary_string3 will be "\x12\x34\x56\x78"
+```
+
+## `String#unpack`
+
+The `String#unpack` method performs the reverse operation of `Array#pack`. It takes a binary string and a template string as input. It extracts data from the binary string according to the directives in the template and converts it into an array of Ruby objects.
+
+**Example:**
+
+```ruby
+binary_data = "test"
+arr = binary_data.unpack("aaaa")
+# arr will be ["t", "e", "s", "t"]
+
+binary_data2 = "\x01\x02\x03"
+arr2 = binary_data2.unpack("C3") # Unpacks three 8-bit unsigned integers
+# arr2 will be [1, 2, 3]
+
+binary_data3 = "Hello\x00World"
+arr3 = binary_data3.unpack("Z*Z*") # Unpacks two null-terminated strings
+# arr3 will be ["Hello", "World"]
+
+# BER (Basic Encoding Rules) example
+arr4 = [127, 128, 16383]
+binary_data4 = arr4.pack("w*") # BER-encodes integers of varying sizes
+# binary_data4 will contain BER-compressed data
+arr4_unpacked = binary_data4.unpack("w*") # Decodes BER data back to integers
+# arr4_unpacked will be [127, 128, 16383]
+```
+
+## Supported Template Directives
+
+The template string is a sequence of characters that specify the type and format of the data to be packed or unpacked. Each directive can be followed by a count (e.g., "C4" for four 8-bit unsigned integers) or `*` to consume all remaining items/bytes.
+
+Here is a list of supported template characters and their meanings:
+
+| Directive | Description                                                                                             |
+| --------- | ------------------------------------------------------------------------------------------------------- |
+| `A`       | Arbitrary binary string (space padded, count is width)                                                  |
+| `a`       | Arbitrary binary string (null padded, count is width)                                                   |
+| `B`       | Bit string (descending bit order)                                                                       |
+| `b`       | Bit string (ascending bit order)                                                                        |
+| `C`       | 8-bit unsigned integer (unsigned char)                                                                  |
+| `c`       | 8-bit signed integer (signed char)                                                                      |
+| `D`, `d`  | Double-precision float, native format (64-bit)                                                          |
+| `E`       | Double-precision float, little-endian (64-bit)                                                          |
+| `e`       | Single-precision float, little-endian (32-bit)                                                          |
+| `F`, `f`  | Single-precision float, native format (32-bit)                                                          |
+| `G`       | Double-precision float, network (big-endian) byte order (64-bit)                                        |
+| `g`       | Single-precision float, network (big-endian) byte order (32-bit)                                        |
+| `H`       | Hex string (high nibble first)                                                                          |
+| `h`       | Hex string (low nibble first)                                                                           |
+| `I`       | Unsigned integer, native endian (`unsigned int` in C)                                                   |
+| `i`       | Signed integer, native endian (`int` in C)                                                              |
+| `J`       | Unsigned integer, native endian (`uintptr_t` in C)                                                      |
+| `j`       | Signed integer, native endian (`intptr_t` in C)                                                         |
+| `L`       | 32-bit unsigned integer, native endian (`uint32_t`)                                                     |
+| `l`       | 32-bit signed integer, native endian (`int32_t`)                                                        |
+| `m`       | Base64 encoded string (see RFC 2045, count is input bytes for pack, output chars for unpack)            |
+| `N`       | 32-bit unsigned integer, network (big-endian) byte order                                                |
+| `n`       | 16-bit unsigned integer, network (big-endian) byte order                                                |
+| `Q`       | 64-bit unsigned integer, native endian (`uint64_t`)                                                     |
+| `q`       | 64-bit signed integer, native endian (`int64_t`)                                                        |
+| `S`       | 16-bit unsigned integer, native endian (`uint16_t`) (Use `S>` for big-endian, `S<` for little-endian)   |
+| `s`       | 16-bit signed integer, native endian (`int16_t`) (Use `s>` for big-endian, `s<` for little-endian)      |
+| `u`       | UU-encoded string (Unix-to-Unix encoding)                                                               |
+| `U`       | UTF-8 character                                                                                         |
+| `V`       | 32-bit unsigned integer, VAX (little-endian) byte order                                                 |
+| `v`       | 16-bit unsigned integer, VAX (little-endian) byte order                                                 |
+| `w`       | BER-compressed integer (variable length encoding)                                                       |
+| `x`       | Null byte (skip forward one byte)                                                                       |
+| `X`       | Back up one byte                                                                                        |
+| `Z`       | Null-terminated string (when unpacking, reads until NULL; when packing, appends a NULL if count is `*`) |
+| `@`       | Moves to absolute position (offset from the beginning of the string)                                    |
+
+**Modifiers:**
+
+Some directives can be followed by modifiers that affect their behavior:
+
+- `>`: Big-endian (for `S`, `s`, `L`, `l`, `Q`, `q`, etc., when native order is not desired).
+- `<`: Little-endian (for `S`, `s`, `L`, `l`, `Q`, `q`, etc., when native order is not desired).
+
+These modifiers are typically used with integer and float types to specify byte order explicitly. For network byte order (big-endian), directives like `n` (16-bit) and `N` (32-bit) are commonly used.
+
+## License
+
+Copyright (c) 2012 Internet Initiative Japan Inc.
+Copyright (c) 2017 mruby developers
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

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

@@ -0,0 +1,5 @@
+MRuby::Gem::Specification.new('mruby-pack') do |spec|
+  spec.license = 'MIT'
+  spec.authors = ['Internet Initiative Japan Inc.', 'mruby developers']
+  spec.summary = 'Array#pack and String#unpack method'
+end