carray 3.0.0 → 3.0.1

data/yard-stubs/ca_obj_array.rb

@@ -0,0 +1,385 @@
+# DOCUMENTATION ONLY — DO NOT REQUIRE.
+# Stubs for constructor methods defined in ext/ca_obj_array.c.
+# See yard-stubs/README.md and yard-stubs/STYLE.md.
+
+class CArray
+  # @!group Construction
+
+  # @overload initialize(data_type, shape)
+  #   Allocates a CArray of the given `data_type` and `shape`, with
+  #   storage left uninitialized (caller is expected to fill it).
+  #   @param data_type [Symbol, Integer, Class, String] element type.
+  #   @param shape [Array<Integer>] one extent per axis.
+  #   @return [self]
+  # @overload initialize(data_type, shape, bytes:)
+  #   For `data_type == :fixlen`, sets the per-element byte size.
+  #   Ignored for numeric types.
+  #   @param data_type [Symbol]
+  #   @param shape [Array<Integer>]
+  #   @param bytes [Integer]
+  #   @return [self]
+  # @overload initialize(data_type, shape) { value }
+  #   With a 0-arity block, calls the block once and broadcasts its
+  #   return value into every cell of the new array (scalar-fill fast
+  #   path). This is the dominant
+  #   `CArray.<type>(n) { value }` idiom.
+  #   @yieldreturn [Object] value to broadcast.
+  #   @return [self]
+  # @overload initialize(data_type, shape) { |*idx| ... }
+  #   With an n-arity block, calls the block once per cell with the
+  #   multi-dimensional index unpacked (`|i|` for 1-D, `|i, j|` for
+  #   2-D, etc.). The block's return value is stored at that cell.
+  #   @yieldparam idx [Array<Integer>] per-axis indices.
+  #   @yieldreturn [Object]
+  #   @return [self]
+  #
+  #   3.0 breaking: `CArray.new(MyStruct, ...)` no longer accepts a
+  #   user class as `data_type`. Use `CARecord.new(MyStruct, *shape)`
+  #   or define `class MyArr < CARecord; data_class MyStruct; end`.
+  def initialize(*); end
+
+  # @overload initialize_copy(other)
+  #   Implements `dup` / `clone` semantics: copies `other`'s
+  #   `data_type`, shape, mask, and element data into `self`. Result
+  #   is an independent entity.
+  #
+  #   Note that for views, `dup`/`clone` produce a new view sharing
+  #   the parent (Ruby shallow-copy semantics); use {#copy} when an
+  #   independent owned array is required.
+  #   @param other [CArray]
+  #   @return [self]
+  #   @api private
+  def initialize_copy(other); end
+
+  # @!endgroup
+
+  class << self
+    # @!group Construction (typed shorthands)
+    #
+    # `CArray.<type>` (no args) returns the typed class
+    # (`CArray::Float64`, `CArray::Int32`, ...). `CArray.<type>(*shape)`
+    # is a shorthand for `CArray.new(:<type>, shape)`. The shorthands
+    # accept the same optional block as `initialize`.
+
+    # @overload fixlen
+    #   Returns the typed class `CArray::Fixlen`.
+    #   @return [Class]
+    # @overload fixlen(*shape, bytes:) { ... }
+    #   Equivalent to `CArray.new(:fixlen, shape, bytes: bytes) { ... }`.
+    #   The `bytes:` keyword is required for `:fixlen`.
+    #   @param shape [Array<Integer>]
+    #   @param bytes [Integer]
+    #   @return [CArray]
+    def fixlen(*shape, bytes: nil); end
+
+    # @overload boolean
+    #   Returns the typed class `CArray::Boolean`.
+    #   @return [Class]
+    # @overload boolean(*shape) { ... }
+    #   Equivalent to `CArray.new(:boolean, shape) { ... }`.
+    #   @param shape [Array<Integer>]
+    #   @return [CArray]
+    def boolean(*shape); end
+
+    # @overload int8
+    #   Returns the typed class `CArray::Int8`.
+    #   @return [Class]
+    # @overload int8(*shape) { ... }
+    #   Equivalent to `CArray.new(:int8, shape) { ... }`.
+    #   @return [CArray]
+    def int8(*shape); end
+
+    # @overload uint8
+    #   Returns the typed class `CArray::UInt8`.
+    #   @return [Class]
+    # @overload uint8(*shape) { ... }
+    #   Equivalent to `CArray.new(:uint8, shape) { ... }`.
+    #   @return [CArray]
+    def uint8(*shape); end
+
+    # @overload int16
+    #   Returns the typed class `CArray::Int16`.
+    #   @return [Class]
+    # @overload int16(*shape) { ... }
+    #   Equivalent to `CArray.new(:int16, shape) { ... }`.
+    #   @return [CArray]
+    def int16(*shape); end
+
+    # @overload uint16
+    #   Returns the typed class `CArray::UInt16`.
+    #   @return [Class]
+    # @overload uint16(*shape) { ... }
+    #   Equivalent to `CArray.new(:uint16, shape) { ... }`.
+    #   @return [CArray]
+    def uint16(*shape); end
+
+    # @overload int32
+    #   Returns the typed class `CArray::Int32`.
+    #   @return [Class]
+    # @overload int32(*shape) { ... }
+    #   Equivalent to `CArray.new(:int32, shape) { ... }`.
+    #   @return [CArray]
+    def int32(*shape); end
+
+    # @overload uint32
+    #   Returns the typed class `CArray::UInt32`.
+    #   @return [Class]
+    # @overload uint32(*shape) { ... }
+    #   Equivalent to `CArray.new(:uint32, shape) { ... }`.
+    #   @return [CArray]
+    def uint32(*shape); end
+
+    # @overload int64
+    #   Returns the typed class `CArray::Int64`.
+    #   @return [Class]
+    # @overload int64(*shape) { ... }
+    #   Equivalent to `CArray.new(:int64, shape) { ... }`.
+    #   @return [CArray]
+    def int64(*shape); end
+
+    # @overload uint64
+    #   Returns the typed class `CArray::UInt64`.
+    #   @return [Class]
+    # @overload uint64(*shape) { ... }
+    #   Equivalent to `CArray.new(:uint64, shape) { ... }`.
+    #   @return [CArray]
+    def uint64(*shape); end
+
+    # @overload float32
+    #   Returns the typed class `CArray::Float32`.
+    #   @return [Class]
+    # @overload float32(*shape) { ... }
+    #   Equivalent to `CArray.new(:float32, shape) { ... }`.
+    #   @return [CArray]
+    def float32(*shape); end
+
+    # @overload float64
+    #   Returns the typed class `CArray::Float64`.
+    #   @return [Class]
+    # @overload float64(*shape) { ... }
+    #   Equivalent to `CArray.new(:float64, shape) { ... }`.
+    #   @return [CArray]
+    def float64(*shape); end
+
+    # @overload cmplx64
+    #   Returns the typed class `CArray::Cmplx64`.
+    #   @return [Class]
+    # @overload cmplx64(*shape) { ... }
+    #   Equivalent to `CArray.new(:cmplx64, shape) { ... }`.
+    #   @return [CArray]
+    def cmplx64(*shape); end
+
+    # @overload cmplx128
+    #   Returns the typed class `CArray::Cmplx128`.
+    #   @return [Class]
+    # @overload cmplx128(*shape) { ... }
+    #   Equivalent to `CArray.new(:cmplx128, shape) { ... }`.
+    #   @return [CArray]
+    def cmplx128(*shape); end
+
+    # @overload object
+    #   Returns the typed class `CArray::Object`.
+    #   @return [Class]
+    # @overload object(*shape) { ... }
+    #   Equivalent to `CArray.new(:object, shape) { ... }`.
+    #   @return [CArray]
+    def object(*shape); end
+
+    # @!endgroup
+
+    # @!group Construction (legacy-name aliases)
+
+    # @overload byte(*shape)
+    #   Alias of {.uint8}.
+    def byte(*shape); end
+
+    # @overload short(*shape)
+    #   Alias of {.int16}.
+    def short(*shape); end
+
+    # @overload int(*shape)
+    #   Alias of {.int32}.
+    def int(*shape); end
+
+    # @overload float(*shape)
+    #   Alias of {.float32}.
+    def float(*shape); end
+
+    # @overload double(*shape)
+    #   Alias of {.float64}.
+    def double(*shape); end
+
+    # @overload complex(*shape)
+    #   Alias of {.cmplx64}.
+    def complex(*shape); end
+
+    # @overload dcomplex(*shape)
+    #   Alias of {.cmplx128}.
+    def dcomplex(*shape); end
+
+    # @!endgroup
+
+    # @!group External memory wrapping
+
+    # @overload wrap(data_type, shape) { target }
+    #   Wraps an external memory block as a CAWrap. The block must
+    #   return a `target` object that defines `wrap_as_carray(obj)`,
+    #   which receives the freshly allocated CAWrap and is
+    #   responsible for setting its `ptr` field.
+    #
+    #   Use this when bridging to a memory source that does not
+    #   expose the MemoryView protocol (otherwise prefer
+    #   {.wrap_memory_view} / {.from_memory_view}).
+    #   @param data_type [Symbol]
+    #   @param shape [Array<Integer>]
+    #   @yieldreturn [#wrap_as_carray] external buffer holder.
+    #   @return [CAWrap]
+    def wrap(data_type, shape); end
+
+    # @!endgroup
+  end
+end
+
+class CScalar
+  # @!group Construction
+
+  # @overload initialize(data_type)
+  #   Allocates a CScalar (0-D CArray) of the given `data_type`.
+  #   @param data_type [Symbol, Integer, Class, String]
+  #   @return [self]
+  # @overload initialize(data_type, bytes:)
+  #   For `data_type == :fixlen`, sets the per-element byte size.
+  #   @param data_type [Symbol]
+  #   @param bytes [Integer]
+  #   @return [self]
+  # @overload initialize(data_type) { |scalar| ... }
+  #   Yields the freshly allocated scalar; the block's return value
+  #   is stored at the cell unless it is `scalar` itself.
+  #   @yieldparam scalar [CScalar]
+  #   @yieldreturn [Object]
+  #   @return [self]
+  def initialize(*); end
+
+  # @overload initialize_copy(other)
+  #   Copies `other`'s `data_type` and stored value into `self`.
+  #   @param other [CScalar]
+  #   @return [self]
+  #   @api private
+  def initialize_copy(other); end
+
+  # @!endgroup
+
+  class << self
+    # @!group Construction (typed shorthands)
+
+    # @overload fixlen(bytes:) { ... }
+    #   Equivalent to `CScalar.new(:fixlen, bytes: bytes) { ... }`.
+    #   @param bytes [Integer]
+    #   @return [CScalar]
+    def fixlen(bytes:); end
+
+    # @overload boolean { ... }
+    #   Equivalent to `CScalar.new(:boolean) { ... }`.
+    #   @return [CScalar]
+    def boolean; end
+
+    # @overload int8 { ... }
+    #   Equivalent to `CScalar.new(:int8) { ... }`.
+    #   @return [CScalar]
+    def int8; end
+
+    # @overload uint8 { ... }
+    #   Equivalent to `CScalar.new(:uint8) { ... }`.
+    #   @return [CScalar]
+    def uint8; end
+
+    # @overload int16 { ... }
+    #   Equivalent to `CScalar.new(:int16) { ... }`.
+    #   @return [CScalar]
+    def int16; end
+
+    # @overload uint16 { ... }
+    #   Equivalent to `CScalar.new(:uint16) { ... }`.
+    #   @return [CScalar]
+    def uint16; end
+
+    # @overload int32 { ... }
+    #   Equivalent to `CScalar.new(:int32) { ... }`.
+    #   @return [CScalar]
+    def int32; end
+
+    # @overload uint32 { ... }
+    #   Equivalent to `CScalar.new(:uint32) { ... }`.
+    #   @return [CScalar]
+    def uint32; end
+
+    # @overload int64 { ... }
+    #   Equivalent to `CScalar.new(:int64) { ... }`.
+    #   @return [CScalar]
+    def int64; end
+
+    # @overload uint64 { ... }
+    #   Equivalent to `CScalar.new(:uint64) { ... }`.
+    #   @return [CScalar]
+    def uint64; end
+
+    # @overload float32 { ... }
+    #   Equivalent to `CScalar.new(:float32) { ... }`.
+    #   @return [CScalar]
+    def float32; end
+
+    # @overload float64 { ... }
+    #   Equivalent to `CScalar.new(:float64) { ... }`.
+    #   @return [CScalar]
+    def float64; end
+
+    # @overload cmplx64 { ... }
+    #   Equivalent to `CScalar.new(:cmplx64) { ... }`.
+    #   @return [CScalar]
+    def cmplx64; end
+
+    # @overload cmplx128 { ... }
+    #   Equivalent to `CScalar.new(:cmplx128) { ... }`.
+    #   @return [CScalar]
+    def cmplx128; end
+
+    # @overload object { ... }
+    #   Equivalent to `CScalar.new(:object) { ... }`.
+    #   @return [CScalar]
+    def object; end
+
+    # @!endgroup
+
+    # @!group Construction (legacy-name aliases)
+
+    # @overload byte
+    #   Alias of {.uint8}.
+    def byte; end
+
+    # @overload short
+    #   Alias of {.int16}.
+    def short; end
+
+    # @overload int
+    #   Alias of {.int32}.
+    def int; end
+
+    # @overload float
+    #   Alias of {.float32}.
+    def float; end
+
+    # @overload double
+    #   Alias of {.float64}.
+    def double; end
+
+    # @overload complex
+    #   Alias of {.cmplx64}.
+    def complex; end
+
+    # @overload dcomplex
+    #   Alias of {.cmplx128}.
+    def dcomplex; end
+
+    # @!endgroup
+  end
+end

data/yard-stubs/ca_obj_bitarray.rb

@@ -0,0 +1,38 @@
+# DOCUMENTATION ONLY — DO NOT REQUIRE.
+# Stubs for CABitarray and CArray#bitarray defined in ext/ca_obj_bitarray.c.
+# See yard-stubs/README.md and yard-stubs/STYLE.md.
+
+# Per-bit expansion view of the parent.  Every parent cell is fanned
+# out into `parent.bytes * 8` boolean cells along a trailing bit
+# axis appended after the parent's own axes, so the view's shape is
+# `[*parent.shape, parent.bytes * 8]` and its `data_type` is
+# `:boolean`.
+#
+# On big-endian hosts the bit axis of a non-fixlen parent reflects
+# network byte order (parent bytes are walked in reverse within each
+# element); single-byte parents are linear on either endian.
+class CABitarray < CAView
+end
+
+class CArray
+  # @!group Views
+
+  # Returns a {CABitarray} view of `self`, exposing every bit of
+  # every parent cell as an individual boolean cell.  See
+  # {CABitarray} for the axis layout and endian handling.
+  #
+  # Aliased as `bits`.
+  #
+  # @overload bitarray
+  #   @return [CABitarray]
+  #   @raise [CADataTypeError] when `self.data_type` is a complex or
+  #     object type (bit-level access is not defined for those).
+  def bitarray; end
+
+  # Alias for {#bitarray}.
+  #
+  # @return [CABitarray]
+  def bits; end
+
+  # @!endgroup
+end

data/yard-stubs/ca_obj_bitfield.rb

@@ -0,0 +1,43 @@
+# DOCUMENTATION ONLY — DO NOT REQUIRE.
+# Stubs for CABitfield and CArray#bitfield defined in ext/ca_obj_bitfield.c.
+# See yard-stubs/README.md and yard-stubs/STYLE.md.
+
+# Bit-field extraction view: each cell of `self` carries a contiguous
+# bit field of the parent, exposed as an unsigned-integer (or boolean
+# when the field is 1 bit wide) CArray of the same shape.  Writes
+# through the view are read-modify-write against the parent — bits
+# outside the field are preserved.
+class CABitfield < CAView
+end
+
+class CArray
+  # @!group Views
+
+  # Returns a {CABitfield} view of `self`.  Each parent cell is
+  # treated as a bag of bits; `range` selects a contiguous slice of
+  # those bits, and the resulting view exposes that slice as a cell
+  # of the returned array.
+  #
+  # `range` may be an integer (a single bit — the resulting view has
+  # `data_type :boolean`) or a `Range` covering the bit positions.
+  # The `data_type` of the view is chosen from the bit width:
+  # 1 bit → `:boolean`, 2..8 → `:uint8`, 9..16 → `:uint16`,
+  # 17..32 → `:uint32`, 33..64 → `:uint64`.
+  #
+  # `type` is accepted but currently ignored (the width-derived type
+  # is always used).
+  #
+  # @overload bitfield(range, type = nil)
+  #   @param range [Integer, Range] bit position (single bit) or bit
+  #     range within one parent cell.
+  #   @param type [Symbol, nil] reserved, currently ignored.
+  #   @return [CABitfield]
+  #   @raise [IndexError] when `range` extends past the parent's bit
+  #     width, when the range has a step != 1, or when the bit length
+  #     is outside `1..64`.
+  #   @raise [ArgumentError] when the derived bit length exceeds the
+  #     resolved data type.
+  def bitfield(range, type = nil); end
+
+  # @!endgroup
+end

data/yard-stubs/ca_obj_block.rb

@@ -0,0 +1,73 @@
+# DOCUMENTATION ONLY — DO NOT REQUIRE.
+# Stubs for CABlock accessors and address helpers defined in
+# ext/ca_obj_block.c.  The CABlock class shell lives in
+# yard-stubs/ruby_carray.rb.
+# See yard-stubs/README.md and yard-stubs/STYLE.md.
+
+class CABlock
+  # @!group Block geometry
+
+  # @overload size0
+  #   Returns the parent dimension sizes that the block is carved
+  #   from (one Integer per axis).  Distinct from `shape`, which is
+  #   the block's own shape (= `count` after step / stride logic).
+  #   @return [Array<Integer>]
+  def size0; end
+
+  # @overload start
+  #   Returns the starting index of the block within the parent, per
+  #   axis.
+  #   @return [Array<Integer>]
+  def start; end
+
+  # @overload step
+  #   Returns the per-axis step (stride in parent index units) the
+  #   block walks the parent with.
+  #   @return [Array<Integer>]
+  def step; end
+
+  # @overload count
+  #   Returns the per-axis number of elements the block exposes.
+  #   Same as `shape`.
+  #   @return [Array<Integer>]
+  def count; end
+
+  # @overload offset
+  #   Returns the block's base flat offset into the parent (in
+  #   element units), set at construction and adjusted as start[]
+  #   moves.
+  #   @return [Integer]
+  def offset; end
+
+  # @!endgroup
+
+  # @!group Address mapping
+
+  # @overload idx2addr0(*idx)
+  #   Maps a per-axis view index tuple to the corresponding flat
+  #   address into the parent (= "addr0").  Useful for projecting a
+  #   view-local coordinate back onto the parent's buffer.
+  #   @param idx [Array<Integer>] one Integer per axis;
+  #     `idx.length == self.ndim` is required.
+  #   @return [Integer]
+  #   @raise [ArgumentError] when the number of args does not equal
+  #     `self.ndim`.
+  #   @raise [IndexError] when any `idx[k]` is out of range for the
+  #     block's `shape[k]`.
+  def idx2addr0(*idx); end
+
+  # @overload index2addr0(*idx)
+  #   Alias of {#idx2addr0}.
+  def index2addr0(*idx); end
+
+  # @overload addr2addr0(addr)
+  #   Flat-address variant of {#idx2addr0}.  Unravels the block-local
+  #   flat `addr` into a multi-dim index, then maps that to the
+  #   parent's flat address.
+  #   @param addr [Integer] block-local flat address
+  #     (`0...self.elements`).
+  #   @return [Integer]
+  def addr2addr0(addr); end
+
+  # @!endgroup
+end

data/yard-stubs/ca_obj_byte_swap.rb

@@ -0,0 +1,56 @@
+# DOCUMENTATION ONLY — DO NOT REQUIRE.
+# Stubs for CAByteSwap and CArray#swap_bytes / #endian defined in
+# ext/ca_obj_byte_swap.c.
+# See yard-stubs/README.md and yard-stubs/STYLE.md.
+
+# Byte-order-reversed view of the parent.  Same shape and byte
+# width as the parent; each cell exposes the byte-reversed
+# interpretation.  For primitive numeric parents `CArray#swap_bytes`
+# routes through `CAMonOp` instead, so a CAByteSwap instance is
+# usually seen only for `CA_FIXLEN` parents.
+#
+# Writes through the view flow back to the parent on detach
+# (byte-swap is involutive).
+class CAByteSwap < CAView
+end
+
+class CArray
+  # @!group Views
+
+  # Returns a lazy view of `self` whose cells are byte-swapped
+  # versions of the parent cells.  Materialises on attach.
+  # Primitive numeric parents get a `CAMonOp` view; `CA_FIXLEN`
+  # parents (with or without a data_class) get a {CAByteSwap} view.
+  #
+  # For eager copy semantics use `arr.swap_bytes.to_ca`.  The
+  # in-place idiom is `ca[] = ca.swap_bytes`; there is no
+  # `swap_bytes!`.
+  #
+  # @overload swap_bytes
+  #   @return [CArray] byte-swapped view of `self`.
+  #   @raise [CADataTypeError] when `self.data_type` is `CA_OBJECT`
+  #     (object arrays cannot be byte-swapped).
+  def swap_bytes; end
+
+  # Returns a view of `self` in the requested byte order.
+  #
+  # `byte_order` is one of:
+  # - `:preserve` / `:native` — identity, since CArrays are stored
+  #   host-endian.
+  # - `:big` — identity on big-endian hosts, otherwise a byte-swap
+  #   view.
+  # - `:little` — identity on little-endian hosts, otherwise a
+  #   byte-swap view.
+  #
+  # The keyword set matches `BulkMemoryView.from(producer, endian:)`.
+  #
+  # @overload endian(byte_order)
+  #   @param byte_order [Symbol] one of `:preserve`, `:native`,
+  #     `:big`, `:little`.
+  #   @return [CArray] `self` or a byte-swap view.
+  #   @raise [ArgumentError] when `byte_order` is not one of the
+  #     accepted symbols.
+  def endian(byte_order); end
+
+  # @!endgroup
+end

data/yard-stubs/ca_obj_fake.rb

@@ -0,0 +1,31 @@
+# DOCUMENTATION ONLY — DO NOT REQUIRE.
+# Stubs for methods defined in ext/ca_obj_fake.c.
+# See yard-stubs/README.md and yard-stubs/STYLE.md.
+
+# CAFace-family data_type reinterpret view.  Presents its parent with a
+# different `data_type` (and, for `:fixlen`, a different `bytes`);
+# reads and writes cast on the fly.  Storage is shared with the
+# parent.
+class CAFake < CAView
+end
+
+class CArray
+  # @!group Views
+  # @overload fake(data_type, bytes: 0)
+  #   Returns a {CAFake} view of `self` whose element type is
+  #   `data_type` (and `bytes:` for `:fixlen`).  Reads and writes go
+  #   through the cast table, so the returned view shares storage
+  #   with `self` but exposes it under a different data_type.
+  #   A Face refuses: its cells do not mean their storage bytes, so
+  #   reading them under another type hands back what the surface exists to
+  #   hide. Use {CArray#to_type} for the values, or `face.parent.fake` to
+  #   reinterpret the storage on purpose. A Numeric Face, whose surface *is*
+  #   its storage, is unaffected.
+  #   @param data_type [Symbol, Integer, Class, String]
+  #   @param bytes [Integer] element byte size for `:fixlen`.
+  #   @return [CAFake]
+  #   @raise [TypeError] when `self` is a Face and the request would read its
+  #     storage under another type.
+  def fake(data_type, bytes: 0); end
+  # @!endgroup
+end

data/yard-stubs/ca_obj_farray.rb

@@ -0,0 +1,32 @@
+# DOCUMENTATION ONLY — DO NOT REQUIRE.
+# Stubs for CAFarray and CArray#farray defined in ext/ca_obj_farray.c.
+# See yard-stubs/README.md and yard-stubs/STYLE.md.
+
+# Column-major (Fortran-order) view of a row-major parent.  Pure
+# `CAStride` typedef: the parent's bytes are reread with dimension
+# order reversed (`view.shape[k] == parent.shape[ndim-1-k]`).  No
+# data is copied; writes go through to the parent.
+class CAFarray < CAStride
+end
+
+# Mask companion of {CAFarray}.
+# @private
+class CAFarrayMask < CAFarray
+end
+
+class CArray
+  # @!group Views
+
+  # @overload farray
+  #   Returns a {CAFarray} view of `self` that exposes the same memory
+  #   in column-major (Fortran) order.  The shape is `self.shape`
+  #   reversed; element `view[i_0, ..., i_{n-1}]` aliases parent
+  #   element `self[i_{n-1}, ..., i_0]`.
+  #
+  #   Useful for interop with column-major consumers (LAPACK, Fortran
+  #   libraries) without copying.
+  #   @return [CAFarray]
+  def farray; end
+
+  # @!endgroup
+end