leptris 1.9.231.1 → 1.9.232.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d25743a8c9d06599ec09676d0e8eeff1b5cbdf002ba969c2453ca9ba28d6d7d
-  data.tar.gz: 0d205b589103d95d62664bbe0298769efdd199b75025c48a78133847b46d9b3d
+  metadata.gz: b5716284785d7f3ff534b89dbacab287b7479ffe7ab66609db4c0df0cdab2ad0
+  data.tar.gz: fa2e4f4a8ab6e5e2aed150b6ee246c63a5711853c72c33179012db27d6122a4d
 SHA512:
-  metadata.gz: 34e8b21544c92d33c6087c6b139ffe19e83db044f5135aaee300382250f4e408d04f8f3d283ec88b84a2025623d8c2deba77134bbaebbc87a359c61fc08df2e1
-  data.tar.gz: 3ce1244314927e7e048ca865b763e510e0e84c9055725fdf89814e89838badab7ea6ce1f539685eabfeb6994bd0912a63c2afa086a40a96ca4b94375cc538b13
+  metadata.gz: e2737c46a2462a96a9f98e17106fc7ca921d9f5718273b5a2a6abd424e6351feff2a3af1ac716ee5b54dda923cd68f9b8adc2f044935cc6838b24204474b727b
+  data.tar.gz: c3e1340928ec767dc669960b09e83c74f000b559c6a90607e5ec9a5316cc25077d6e7564c90fea50d4900180ce0fb6d1ceb33fc916753e252c7d452e17aaca64

data/CHANGELOG.md

@@ -5,6 +5,25 @@ All notable changes to Leptris will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.232.0] - 2026-09-24
+
+### Added
+
+- `Node#visit_entering` (libleptris #1332): the entering-only walk
+  — one C call yields `(node, true, depth)` exactly once per node,
+  halving the C→Ruby transitions against `#visit` for walks that
+  never acted on the leaving half. Same order and depths as
+  `#visit`; the native face falls back to the filtering visit on
+  pins predating #1332.
+
+### Performance — engine sync (1.9.232)
+
+- Vendored libleptris 1.9.232: the per-eval registry leak fix, the
+  range NaN fix, string-literal character-reference expansion, and
+  the plan-walker prefixed-name fix — moxml/lutaml hydration of
+  `w:*` elements resolves correctly with no binding-side change —
+  plus 907 new QT3-gated engine behaviors.
+
 ## [1.9.231.0] - 2026-09-23
 
 ### Fixed

data/Rakefile

@@ -8,7 +8,7 @@ RSpec::Core::RakeTask.new(:spec)
 # Pin for `rake compile` and the platform-gem builds. Keep in lockstep
 # with .github/workflows/build.yml (which calls `rake compile`) and the
 # CHANGELOG when libleptris releases.
-LIBLEPTRIS_VERSION = "1.9.231"
+LIBLEPTRIS_VERSION = "1.9.232"
 # Vendored alongside libleptris for fn:normalize-unicode (TODO
 # .restructure/20): built per platform with a RELOCATABLE @rpath
 # install name, loaded by ffi.rb before libleptris so the

data/ext/leptris/native/native.c

@@ -971,10 +971,39 @@ static VALUE nf_visit_binding(VALUE self, VALUE document, VALUE addr)
     st.klass_memo_flag =
         rb_obj_class(document) == c_iteration_scope ? Qfalse : Qtrue;
     st.for_visit = 1;
-    if (f_node_visit_entering)
-        f_node_visit_entering(st.self_ptr, visit_cb, &st);
-    else
-        f_node_visit(st.self_ptr, visit_cb, &st);
+    /* ALWAYS the two-event engine call: this seam backs the PUBLIC
+     * Node#visit, whose contract (specs since libleptris 1.9.20)
+     * is (node, entering, depth) enter/leave PAIRS. Entering-only
+     * walks belong to visit_entering_binding below — swapping the
+     * call here silently dropped every leaving callback and broke
+     * the contract. */
+    f_node_visit(st.self_ptr, visit_cb, &st);
+    if (st.err != Qnil)
+        rb_exc_raise(st.err);
+    return Qnil;
+}
+
+/* Entering-only walk (libleptris #1332): one callback per node.
+ * Yields the same (node, true, depth) shape as visit_binding — the
+ * entering argument is constant true here, but keeping the 3-arity
+ * yield lets a block be shared between the two walk modes. */
+static VALUE nf_visit_entering_binding(VALUE self, VALUE document,
+                                       VALUE addr)
+{
+    struct trav_state st;
+
+    (void)self;
+    if (!f_node_visit_entering)
+        return nf_visit_binding(self, document, addr);
+    resolve_binding_classes();
+    st.document = document;
+    st.err = Qnil;
+    st.self_ptr = (void *)(uintptr_t)NUM2ULL(addr);
+    st.cache = binding_cache_of(document);
+    st.klass_memo_flag =
+        rb_obj_class(document) == c_iteration_scope ? Qfalse : Qtrue;
+    st.for_visit = 1;
+    f_node_visit_entering(st.self_ptr, visit_cb, &st);
     if (st.err != Qnil)
         rb_exc_raise(st.err);
     return Qnil;
@@ -2739,6 +2768,8 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
                               nf_traverse_binding, 2);
     rb_define_module_function(m_native, "visit_binding",
                               nf_visit_binding, 2);
+    rb_define_module_function(m_native, "visit_entering_binding",
+                              nf_visit_entering_binding, 2);
     rb_define_module_function(m_native, "fast_text_content",
                               nf_fast_text_content, 1);
     rb_define_module_function(m_native, "fast_comment_content",

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.231.1"
+  VERSION = "1.9.232.0"
 end

data/lib/leptris/xml/ffi.rb

@@ -447,6 +447,10 @@ attach_function :leptris_parse_string,
       # node walks the document child chain.
       attach_function :leptris_node_visit,
         [:leptris_node_ref, :pointer, :pointer], :void
+      # Entering-only walk (libleptris #1332): one callback per
+      # node. Rides the engine pin that ships it.
+      attach_function :leptris_node_visit_entering,
+        [:leptris_node_ref, :pointer, :pointer], :void
       # Document-level PIs (v1.6.0): not tree nodes — enumerate via
       # these accessors only.
       attach_function :leptris_document_pi_count,

data/lib/leptris/xml/node.rb

@@ -545,6 +545,34 @@ class Leptris::XML::Node
     self
   end
 
+  # Visits the subtree with ONE C call, yielding ONCE per node
+  # (leptris_node_visit_entering, libleptris #1332): every node —
+  # elements included — yields (node, true, depth) exactly once, on
+  # entering. Halves the C-callback invocations against #visit for
+  # walks that never acted on the leaving half (the family-walk
+  # shape); the halving happens in the engine, not in a per-node
+  # Ruby filter. Same order and depths as #visit; read-only.
+  #
+  #     root.visit_entering { |node, entering, depth| ... }
+  def visit_entering(&block)
+    return enum_for(:visit_entering) unless block
+    ensure_alive!
+    if @addr_reads_fast
+      Leptris::XML::Native.visit_entering_binding(@document,
+                                                  @c_address, &block)
+      return self
+    end
+    document = @document
+    visitor = ::FFI::Function.new(
+      :void, [:pointer, :pointer, :int, :int], blocking: true) do |_, node_ptr, entering, depth|
+      block.call(
+        Leptris::XML::Node.wrap(node_ptr, document),
+        entering == 1, depth)
+    end
+    Leptris::XML::FFI.leptris_node_visit_entering(c_ptr, visitor, nil)
+    self
+  end
+
   # Walks the subtree in post-order DFS (matches Nokogiri's
   # semantics): the receiver, its descendants, nothing else.
   #

data/vendor-src/README.md

@@ -1,7 +1,7 @@
 Sources vendored in this gem (recompile rights; the ruby
 variant builds them at install via extconf.rb):
 
-- libleptris v1.9.231
+- libleptris v1.9.232
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## [Unreleased]
 
+## [1.9.232] - 2026-09-24
+
+### Added
+
+- QT3 corpus slice 4 — sequence-edit + codepoint families, 501 gated cases; seq member fidelity fixes (xquery)
+- entering-only visit mode — leptris_node_visit_entering (#1332) (dom)
+
+### Fixed
+
+- range A to B with an empty operand yields the empty sequence (xpath)
+- expand character and predefined entity references in string literals (xpath)
+- prefixed wire names bind namespaced elements (XSD-002 fallout) (descriptor)
+
+
+
 ## [1.9.231] - 2026-09-23
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(leptris
-    VERSION 1.9.231
+    VERSION 1.9.232
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

data/vendor-src/libleptris/src/include/leptris/descriptor.h

@@ -98,7 +98,11 @@ typedef struct {
 } leptris_attr_plan;
 
 typedef struct {
-    const char* wire_name; /* XML element name as it appears on the wire */
+    const char* wire_name; /* XML element name as it appears on the wire:
+                            * the prefixed form ("w:b") binds that literal
+                            * prefix+local pair; the bare local form ("b")
+                            * binds by local name and lets ns_form do the
+                            * namespace work */
     uint8_t kind;          /* LeptrisPlanKind */
     uint8_t type_tag;      /* host-defined; echoed back verbatim */
     int32_t child_plan_index; /* NESTED: index into leptris_plan_spec.plans;

data/vendor-src/libleptris/src/include/leptris.h

@@ -1195,6 +1195,23 @@ LEPTRIS_API void leptris_node_visit(LeptrisNodeRef root,
                                     LeptrisNodeVisitor visitor,
                                     void* user_data);
 
+/**
+ * Entering-only subtree visitation (issue #1332)
+ *
+ * Same walk as leptris_node_visit — document order, same depths —
+ * but the callback fires ONCE per node, on entering. Elements are
+ * not re-visited after their subtree. Halves the C-callback
+ * invocations for consumers that only act on entering=1 (the lazy
+ * family-walk shape).
+ *
+ * @param root Subtree root (any node kind, or a document node)
+ * @param visitor Callback per node (may be NULL — no-op)
+ * @param user_data Opaque context for the callback
+ */
+LEPTRIS_API void leptris_node_visit_entering(LeptrisNodeRef root,
+                                             LeptrisNodeVisitor visitor,
+                                             void* user_data);
+
 /**
  * Count the document's top-level processing instructions
  *

data/vendor-src/libleptris/src/leptris/descriptor/plan.c

@@ -440,6 +440,29 @@ LEPTRIS_API void leptris_plan_free(LeptrisPlan plan) { dp_plan_free(plan); }
 /* ---- walk ------------------------------------------------------- */
 
 /* Namespace binding for a child element against a row's target form. */
+/* Child-row wire-name match. The ABI documents wire_name as "the
+ * XML element name as it appears on the wire": a row may carry the
+ * PREFIXED form ("w:b") or the bare local name ("b"). Rows with a
+ * colon bind prefix+local (literal prefix, per the wire contract);
+ * bare rows keep the historical local-name match with the row's
+ * ns_form doing the namespace work. The old matcher compared the
+ * local name only, so every prefixed row — the shape hosts
+ * compiling from xsd:QName schemas emit — silently bound nothing
+ * and whole subtrees hydrated empty (XSD-002 fallout). */
+static int dp_wire_name_matches(LeptrisElement child,
+                                const char* wire_name) {
+    const char* local = NULL;
+    const char* prefix = NULL;
+    leptris_element_expanded_name(child, &local, &prefix, NULL);
+    if (!wire_name || !local) return 0;
+    const char* colon = strchr(wire_name, ':');
+    if (!colon) return strcmp(local, wire_name) == 0;
+    size_t plen = (size_t)(colon - wire_name);
+    return prefix != NULL && strlen(prefix) == plen &&
+           strncmp(prefix, wire_name, plen) == 0 &&
+           strcmp(local, colon + 1) == 0;
+}
+
 static int dp_ns_binds(LeptrisElement elem, uint8_t ns_form,
                        const char* ns_uri, int lenient) {
     const char* local = NULL;
@@ -617,9 +640,8 @@ static int dp_walk_children(LeptrisElement elem, const dp_plan* plan,
                 if (leptris_node_get_type(n) != LEPTRIS_NODE_TYPE_ELEMENT)
                     continue;
                 LeptrisElement child = (LeptrisElement)n;
-                const char* local = NULL;
-                leptris_element_expanded_name(child, &local, NULL, NULL);
-                if (!local || strcmp(local, row->wire_name) != 0) continue;
+                if (!dp_wire_name_matches(child, row->wire_name))
+                    continue;
                 if (!dp_ns_binds(child, target->ns_form, target->ns_uri,
                                  lenient))
                     continue;
@@ -666,9 +688,7 @@ static int dp_walk_children(LeptrisElement elem, const dp_plan* plan,
             if (leptris_node_get_type(n) != LEPTRIS_NODE_TYPE_ELEMENT)
                 continue;
             LeptrisElement child = (LeptrisElement)n;
-            const char* local = NULL;
-            leptris_element_expanded_name(child, &local, NULL, NULL);
-            if (!local || strcmp(local, row->wire_name) != 0) continue;
+            if (!dp_wire_name_matches(child, row->wire_name)) continue;
             /* #1272: same-wire-name claim — if a previous row bound
              * this node, skip it. */
             int rank = -1;

data/vendor-src/libleptris/src/leptris/dom/node.c

@@ -389,18 +389,20 @@ void leptris_node_set_next_sibling(LeptrisNode* node, LeptrisNode* sibling) {
  * lazily from the callback instead of materializing per-level
  * NodeSet/Array allocations. */
 static void node_visit_rec(LeptrisNode* n, int depth,
-                           LeptrisNodeVisitor visitor, void* user_data) {
+                           LeptrisNodeVisitor visitor, void* user_data,
+                           int entering_only) {
     int is_elem = (n->type == LEPTRIS_NODE_TYPE_ELEMENT);
     visitor(user_data, (LeptrisNodeRef)n, 1, depth);
     if (!is_elem) return;
     for (LeptrisNode* c = leptris_elem_first_child((LeptrisElement)n); c;
          c = leptris_node_get_next_sibling(c))
-        node_visit_rec(c, depth + 1, visitor, user_data);
-    visitor(user_data, (LeptrisNodeRef)n, 0, depth);
+        node_visit_rec(c, depth + 1, visitor, user_data, entering_only);
+    if (!entering_only)
+        visitor(user_data, (LeptrisNodeRef)n, 0, depth);
 }
 
-void leptris_node_visit(LeptrisNodeRef root, LeptrisNodeVisitor visitor,
-                        void* user_data) {
+static void node_visit_impl(LeptrisNodeRef root, LeptrisNodeVisitor visitor,
+                            void* user_data, int entering_only) {
     if (!root || !visitor) return;
     if (root->type == LEPTRIS_NODE_TYPE_DOCUMENT) {
         /* Document root: children = the document child chain (#580),
@@ -413,8 +415,23 @@ void leptris_node_visit(LeptrisNodeRef root, LeptrisNodeVisitor visitor,
         if (!start) start = (LeptrisNode*)d->root;
         for (LeptrisNode* c = start; c;
              c = leptris_node_get_next_sibling(c))
-            node_visit_rec(c, 0, visitor, user_data);
+            node_visit_rec(c, 0, visitor, user_data, entering_only);
         return;
     }
-    node_visit_rec((LeptrisNode*)root, 0, visitor, user_data);
+    node_visit_rec((LeptrisNode*)root, 0, visitor, user_data,
+                   entering_only);
+}
+
+void leptris_node_visit(LeptrisNodeRef root, LeptrisNodeVisitor visitor,
+                        void* user_data) {
+    node_visit_impl(root, visitor, user_data, 0);
+}
+
+/* Issue #1332: entering-only mode — one callback per node. The
+ * family-walk consumers all discard the leaving half of
+ * leptris_node_visit; this skips those invocations at the source. */
+void leptris_node_visit_entering(LeptrisNodeRef root,
+                                 LeptrisNodeVisitor visitor,
+                                 void* user_data) {
+    node_visit_impl(root, visitor, user_data, 1);
 }

data/vendor-src/libleptris/src/leptris/xpath/evaluator_operators.c

@@ -12,6 +12,7 @@
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <limits.h>
 /* ---- ISO 8601 dayTimeDuration value model (op:duration batch,
  * lever 6 stage-2). Durations ride the STRING lexicon; these
  * helpers give arithmetic and comparisons a typed view. Strictly
@@ -2037,8 +2038,8 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
         struct leptris_xpath_result* hi_r =
             evaluate_expr(ctx, ast->children[1]);
         if (!hi_r) { xpath_result_free(lo_r); return NULL; }
-        long lo = (long)xpath_to_number(lo_r);
-        long hi = (long)xpath_to_number(hi_r);
+        double lod = xpath_to_number(lo_r);
+        double hid = xpath_to_number(hi_r);
         xpath_result_free(lo_r);
         xpath_result_free(hi_r);
 
@@ -2046,12 +2047,25 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
         if (!out) return NULL;
         out->owns_synthetic_text = 1;
         out->is_sequence = 1;
-        for (long v = lo; v <= hi && v - lo < 100000; v++) {
-            char buf[28];
-            int l = snprintf(buf, sizeof buf, "\x03N%ld", v);
-            XPathTextNode* tn = synth_text(buf, (size_t)l);
-            if (!tn) break;
-            xpath_nodeset_add(out, tn);
+        /* XPath 2.0+: an empty (NaN) operand yields the empty
+         * sequence — never cast NaN to long (UB: arm64 gives 0,
+         * x86 gives INT32/64_MIN, so the "range" silently became
+         * a 75/100000-item sequence; cbcl-codepoints-to-string-020).
+         * Huge finite values clamp instead of UB-casting. */
+        if (!isnan(lod) && !isnan(hid)) {
+            long lo = lod > 9.0e18 ? LONG_MAX
+                    : lod < -9.0e18 ? LONG_MIN
+                    : (long)lod;
+            long hi = hid > 9.0e18 ? LONG_MAX
+                    : hid < -9.0e18 ? LONG_MIN
+                    : (long)hid;
+            for (long v = lo; v <= hi && v - lo < 100000; v++) {
+                char buf[28];
+                int l = snprintf(buf, sizeof buf, "\x03N%ld", v);
+                XPathTextNode* tn = synth_text(buf, (size_t)l);
+                if (!tn) break;
+                xpath_nodeset_add(out, tn);
+            }
         }
         struct leptris_xpath_result* result =
             xpath_result_new(XPATH_RESULT_NODESET);

data/vendor-src/libleptris/src/leptris/xpath/functions.c

@@ -763,7 +763,12 @@ static int de_item_equal(DeItem* a, DeItem* b) {
     if (a->kind != b->kind) return 0;
     switch (a->kind) {
         case 0: return de_node_equal(a->node, b->node);
-        case 1: return a->num == b->num;
+        case 1: {
+            /* deep-equal is atomic-eq based: NaN compares equal to
+             * NaN (F&O 17.4.1 — unlike the eq operator). */
+            if (isnan(a->num) && isnan(b->num)) return 1;
+            return a->num == b->num;
+        }
         case 2: {
             const char* as = a->str ? a->str : (a->borrow ? a->borrow : "");
             const char* bs = b->str ? b->str : (b->borrow ? b->borrow : "");
@@ -843,17 +848,33 @@ static struct leptris_xpath_result* xpath_func_deep_equal(XPathContext* context,
         return NULL;
     }
 
-    enum { CAP = 64 };
-    DeItem ia[CAP], ib[CAP];
-    size_t na = de_collect(a, ia, CAP);
-    size_t nb = de_collect(b, ib, CAP);
+    /* Growable item arrays: corpus sequences run to tens of
+     * thousands of members (cbcl roundtrips over 65536 to 100000);
+     * a fixed cap silently compares a prefix. */
+    size_t capa = a->type == XPATH_RESULT_NODESET && a->value.nodeset_value
+        ? a->value.nodeset_value->count : 1;
+    size_t capb = b->type == XPATH_RESULT_NODESET && b->value.nodeset_value
+        ? b->value.nodeset_value->count : 1;
+    DeItem* ia = (DeItem*)malloc((capa ? capa : 1) * sizeof(DeItem));
+    DeItem* ib = (DeItem*)malloc((capb ? capb : 1) * sizeof(DeItem));
+    if (!ia || !ib) {
+        free(ia);
+        free(ib);
+        xpath_result_free(a);
+        xpath_result_free(b);
+        return NULL;
+    }
+    size_t na = de_collect(a, ia, capa);
+    size_t nb = de_collect(b, ib, capb);
 
     int equal = na == nb;
-    for (size_t i = 0; equal && i < na && i < CAP; i++)
+    for (size_t i = 0; equal && i < na; i++)
         equal = de_item_equal(&ia[i], &ib[i]);
 
-    for (size_t i = 0; i < na && i < CAP; i++) de_item_clear(&ia[i]);
-    for (size_t i = 0; i < nb && i < CAP; i++) de_item_clear(&ib[i]);
+    for (size_t i = 0; i < na; i++) de_item_clear(&ia[i]);
+    for (size_t i = 0; i < nb; i++) de_item_clear(&ib[i]);
+    free(ia);
+    free(ib);
     xpath_result_free(a);
     xpath_result_free(b);
 

data/vendor-src/libleptris/src/leptris/xpath/functions_ext31.c

@@ -59,7 +59,20 @@ static void seq_push_str(struct leptris_xpath_result* seq, const char* s) {
 
 static void seq_push_num(struct leptris_xpath_result* seq, double d) {
     char* s = xpath_number_to_string(d);
-    seq_push_str(seq, s ? s : "");
+    if (!s) return;
+    /* "\x03N" marks numeric members — same discipline as the
+     * sequence constructor: per-member type checks (deep-equal,
+     * instance of) must see a NUMBER, not a string that happens
+     * to look like one. String consumers strip the marker. */
+    size_t sl = strlen(s);
+    char* marked = (char*)malloc(sl + 3);
+    if (marked) {
+        marked[0] = '\x03';
+        marked[1] = 'N';
+        memcpy(marked + 2, s, sl + 1);
+        seq_push_str(seq, marked);
+        free(marked);
+    }
     free(s);
 }
 
@@ -71,6 +84,11 @@ static char* scalar_str(const struct leptris_xpath_result* r) {
             return leptris_strdup(r->value.string_value
                                       ? r->value.string_value : "");
         case XPATH_RESULT_NUMBER: {
+            /* int64 fidelity: an xs:integer-sourced number must
+             * string exactly — the double roundtrip prints
+             * 830993497117024304 as 8.30993e+17. */
+            if (r->is_int)
+                return xpath_int_to_string(r->int_value);
             char* s = xpath_number_to_string(r->value.number_value);
             return s ? s : leptris_strdup("");
         }
@@ -222,6 +240,13 @@ static struct leptris_xpath_result* fn_subsequence(XPathContext* ctx,
     if (sv) leptris_xpath_result_free(sv);
     struct leptris_xpath_result* out = seq_new();
     if (out) {
+        /* F&O: a negative $length yields the empty sequence
+         * (K-SeqSubsequenceFunc-5) — len < 0 is NOT the "to end"
+         * sentinel here. */
+        if (n >= 3 && ld < 0) {
+            free_items(items, cnt);
+            return out;
+        }
         long start = (long)sd;
         long len = (n >= 3) ? (ld != ld ? -1 : (long)ld) : -1;
         seq_from_items(out, items, cnt, start, len);
@@ -257,6 +282,10 @@ static struct leptris_xpath_result* fn_insert_before(XPathContext* ctx,
     size_t icnt;
     char** ins = collect_items(ctx, args, n, 2, &icnt);
     struct leptris_xpath_result* out = seq_new();
+    /* F&O: position < 1 inserts at 1; a position beyond the tail
+     * inserts at the end (K-SeqInsertBeforeFunc-5/10/14/15). */
+    if (at < 1) at = 1;
+    if (at > (long)cnt + 1) at = (long)cnt + 1;
     if (out && ins) {
         for (long k = 1; k <= (long)(cnt + icnt); k++) {
             if (k == at)