leptris 1.9.201.0-arm-linux → 1.9.201.2-arm-linux

data/vendor-src/libleptris/benchmarks/xslt/scorecard_lxml.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+"""#682 XSLT scorecard: lxml/libxslt reference timings for the lane
+fixtures that lack a twin (heavy already has heavy_lxml.py).
+
+Mirrors the C benches exactly — same fixtures, same protocols: best of 9
+for dispatch/pred/valueof/subtree (transform keeps its bench_run
+mean-of-400). Compile once, apply-only timing. Run next to the C benches
+on the same machine:
+
+    python3 benchmarks/xslt/scorecard_lxml.py
+"""
+import copy
+import io
+import time
+
+from lxml import etree
+
+
+def best_of_9(fn):
+    fn()
+    best = float("inf")
+    for _ in range(9):
+        t0 = time.perf_counter()
+        fn()
+        best = min(best, (time.perf_counter() - t0) * 1000.0)
+    return best
+
+
+def gen_dispatch(books=2000):
+    # mirrors bench_dispatch.c
+    xml = io.BytesIO()
+    xml.write(b"<catalog>")
+    for i in range(books):
+        xml.write(
+            b"<book id='%d'><title>t</title><author>a</author></book>" % (i,)
+        )
+    xml.write(b"</catalog>")
+    xsl = (
+        b"<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>"
+        b"<xsl:template match='/'><out>"
+        b"<xsl:apply-templates select='//book'/></out></xsl:template>"
+        b"<xsl:template match='book[title]'><b id='{@id}'>"
+        b"<xsl:apply-templates select='*'/></b></xsl:template>"
+        b"<xsl:template match='title'><t><xsl:value-of select='.'/></t></xsl:template>"
+        b"<xsl:template match='author'><a><xsl:value-of select='.'/></a></xsl:template>"
+        b"</xsl:stylesheet>"
+    )
+    return xml.getvalue(), xsl
+
+
+def gen_pred(n=120, items=2400):
+    # mirrors bench_dispatch_pred.c
+    xml = io.BytesIO()
+    xml.write(b"<root>")
+    for i in range(items):
+        xml.write(b"<item k='%d' v='v%d'/>" % (i % n, i))
+    xml.write(b"</root>")
+    xsl = io.BytesIO()
+    xsl.write(
+        b"<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>"
+    )
+    for i in range(n):
+        xsl.write(
+            b"<xsl:template match=\"item[@k='%d']\"><o%d>"
+            b"<xsl:value-of select='@v'/></o%d></xsl:template>" % (i, i, i)
+        )
+    xsl.write(b"</xsl:stylesheet>")
+    return xml.getvalue(), xsl.getvalue()
+
+
+def gen_valueof(n=50000):
+    # mirrors bench_valueof.c
+    xml = io.BytesIO()
+    xml.write(b"<r>")
+    for _ in range(n):
+        xml.write(b"<t>abcdefgh</t>")
+    xml.write(b"</r>")
+    xsl = (
+        b"<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>"
+        b"<xsl:template match='/'>"
+        b"<xsl:for-each select='//t'>"
+        b"<xsl:value-of select='.'/>"
+        b"</xsl:for-each></xsl:template></xsl:stylesheet>"
+    )
+    return xml.getvalue(), xsl
+
+
+def gen_transform(books=499):
+    # mirrors benchmarks/xpath/bench_xslt_transform.c
+    xml = io.BytesIO()
+    xml.write(b"<catalog>")
+    for i in range(books):
+        xml.write(
+            b"<book id='%d' price='%d'><title>Book %d</title></book>"
+            % (i, i % 200, i)
+        )
+    xml.write(b"</catalog>")
+    xsl = (
+        b"<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform'"
+        b" version='1.0'><xsl:template match='/'>"
+        b"<out><xsl:for-each select=\"//book[@price > 100]\">"
+        b"<b><xsl:value-of select='@id'/></b></xsl:for-each></out>"
+        b"</xsl:template></xsl:stylesheet>"
+    )
+    return xml.getvalue(), xsl
+
+
+def gen_subtree(books=100):
+    # mirrors bench_subtree_copy.c
+    xml = io.BytesIO()
+    xml.write(b"<catalog version='2.0'>")
+    for i in range(books):
+        xml.write(
+            b"<book id='%d' lang='en'><title>Book %d</title>"
+            b"<author id='a%d'>Author %d</author>"
+            b"<price currency='USD'>%d.99</price></book>" % (i, i, i, i, i)
+        )
+    xml.write(b"</catalog>")
+    return xml.getvalue()
+
+
+def run_apply(name, xml_bytes, xsl_bytes):
+    doc = etree.parse(io.BytesIO(xml_bytes))
+    transform = etree.XSLT(etree.parse(io.BytesIO(xsl_bytes)))
+    transform(doc)
+    best = best_of_9(lambda: transform(doc))
+    print(f"lxml {name}: {best:.2f} ms (best of 9)")
+
+
+def main():
+    print(
+        f"lxml {etree.__version__} / libxml2 {etree.LIBXML_VERSION} / "
+        f"libxslt {etree.LIBXSLT_VERSION}"
+    )
+    run_apply("dispatch 2000 books", *gen_dispatch())
+    run_apply(
+        "pred-pattern dispatch 120 templates / 2400 items", *gen_pred()
+    )
+    run_apply("value-of . x50000", *gen_valueof())
+
+    doc = etree.parse(io.BytesIO(gen_transform()[0]))
+    transform = etree.XSLT(etree.parse(io.BytesIO(gen_transform()[1])))
+    transform(doc)
+    times = []
+    for _ in range(400):
+        t0 = time.perf_counter()
+        transform(doc)
+        times.append(time.perf_counter() - t0)
+    print(f"lxml xslt apply //book[@price>100] mean "
+          f"{sum(times) / len(times) * 1e6:.2f} us")
+
+    root = etree.parse(io.BytesIO(gen_subtree())).getroot()
+
+    def copy_200():
+        for _ in range(200):
+            copy.deepcopy(root)
+
+    copy_200()
+    best = float("inf")
+    for _ in range(9):
+        t0 = time.perf_counter()
+        copy_200()
+        best = min(best, (time.perf_counter() - t0) * 1000.0 / 200.0)
+    print(f"lxml element_copy 100-book subtree: {best:.3f} ms/copy "
+          f"(best of 9x200)")
+
+
+if __name__ == "__main__":
+    main()

data/vendor-src/libleptris/bindings/ruby/leptris.gemspec

@@ -0,0 +1,22 @@
+# leptris.gemspec — Ruby FFI binding for libleptris.
+
+Gem::Specification.new do |spec|
+  spec.name          = 'leptris'
+  spec.version       = '0.3.0'
+  spec.summary       = 'Ruby FFI binding for libleptris XML parser'
+  spec.description   = 'Fast XML parsing, XPath evaluation, and SAX ' \
+                       'via libleptris. Pure C99 core with Ruby FFI.'
+  spec.authors       = ['Ribose Inc.']
+  spec.email         = ['open.source@ribose.com']
+  spec.homepage      = 'https://github.com/leptris/leptris'
+  spec.license       = 'MIT'
+
+  spec.files         = Dir['lib/**/*.rb']
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'ffi', '~> 1.0'
+
+  spec.add_development_dependency 'rspec', '~> 3.0'
+
+  spec.required_ruby_version = '>= 2.7'
+end

data/vendor-src/libleptris/bindings/ruby/lib/leptris/document.rb

@@ -0,0 +1,60 @@
+# lib/leptris/document.rb — Leptris::Document wraps LeptrisDocument.
+#
+# Documents own the entire DOM tree + memory pool.  Callers MUST call
+# #free when done (or let the process exit clean up).  No GC finalizer
+# is used because the FFI pointer can't distinguish "already freed"
+# from "valid" in a finalizer proc, leading to double-free crashes.
+
+module Leptris
+  class Document
+    attr_reader :ptr
+
+    def self.parse(xml)
+      raise ArgumentError, 'xml must be a String' unless xml.is_a?(String)
+      status = FFI::MemoryPointer.new(:int)
+      doc = Leptris.leptris_parse_string(xml, xml.bytesize, status)
+      raise Error, "Parse failed (status=#{status.read_int})" if doc.nil? || doc.null?
+      new(doc)
+    end
+
+    def initialize(ptr)
+      @ptr = ptr
+      @freed = false
+    end
+
+    def root
+      element_ptr = Leptris.leptris_document_root(@ptr)
+      return nil if element_ptr.nil? || element_ptr.null?
+      Element.new(element_ptr, self)
+    end
+
+    def serialize(options = nil)
+      result = Leptris.leptris_document_serialize(@ptr, nil)
+      return nil if result.nil? || result.null?
+      str = result.read_string
+      Leptris.leptris_free_string(result)
+      str
+    end
+
+    def process_xinclude(base_url = nil)
+      rc = Leptris.leptris_xinclude_process(@ptr, base_url)
+      raise Error, 'XInclude processing failed' if rc != Leptris::LEPTRIS_OK
+      self
+    end
+
+    def xpath(expression, context = nil)
+      XPath.evaluate(self, context, expression)
+    end
+
+    def free
+      return if @freed
+      Leptris.leptris_document_free(@ptr)
+      @freed = true
+      @ptr = nil
+    end
+
+    def freed?
+      @freed
+    end
+  end
+end

data/vendor-src/libleptris/bindings/ruby/lib/leptris/element.rb

@@ -0,0 +1,86 @@
+# lib/leptris/element.rb — Leptris::Element wraps LeptrisElement.
+#
+# Elements are owned by their parent Document.  They are never freed
+# directly — freeing the Document frees the entire tree.
+
+module Leptris
+  class Element
+    attr_reader :ptr
+
+    def initialize(ptr, document)
+      @ptr = ptr
+      @document = document
+    end
+
+    def name
+      Leptris.leptris_element_name(@ptr)
+    end
+
+    def text
+      Leptris.leptris_element_text(@ptr)
+    end
+
+    def [](attr_name)
+      Leptris.leptris_element_attribute(@ptr, attr_name)
+    end
+
+    def attribute_count
+      Leptris.leptris_element_attribute_count(@ptr)
+    end
+
+    # Yields [name, value] for every attribute in document order.
+    # Handle-based iteration — O(n) total where index-based access
+    # re-walks the list per call.
+    def each_attribute
+      return enum_for(:each_attribute) unless block_given?
+      attr = Leptris.leptris_element_first_attribute(@ptr)
+      until attr.nil? || attr.null?
+        yield [Leptris.leptris_attribute_get_name(attr),
+               Leptris.leptris_attribute_get_value(@ptr, attr)]
+        attr = Leptris.leptris_attribute_next(attr)
+      end
+    end
+
+    def parent
+      p = Leptris.leptris_element_parent(@ptr)
+      return nil if p.nil? || p.null?
+      Element.new(p, @document)
+    end
+
+    def first_child_element
+      c = Leptris.leptris_element_first_child_any(@ptr)
+      return nil if c.nil? || c.null?
+      Element.new(c, @document)
+    end
+
+    def child_count
+      Leptris.leptris_element_child_count(@ptr)
+    end
+
+    def each_child_element
+      return enum_for(:each_child_element) unless block_given?
+      child = first_child_element
+      while child
+        yield child
+        child = child.next_sibling_element
+      end
+    end
+
+    def next_sibling_element
+      node = Leptris.leptris_element_as_node(@ptr)
+      sibling = Leptris.leptris_node_next_sibling(node)
+      return nil if sibling.nil? || sibling.null?
+      elem = Leptris.leptris_node_as_element(sibling)
+      return nil if elem.nil? || elem.null?
+      Element.new(elem, @document)
+    end
+
+    def to_node
+      Node.new(Leptris.leptris_element_as_node(@ptr), @document)
+    end
+
+    def inspect
+      "<Leptris::Element #{name}>"
+    end
+  end
+end

data/vendor-src/libleptris/bindings/ruby/lib/leptris/error.rb

@@ -0,0 +1,6 @@
+# lib/leptris/error.rb — Exception class for Leptris errors.
+
+module Leptris
+  class Error < StandardError
+  end
+end

data/vendor-src/libleptris/bindings/ruby/lib/leptris/node.rb

@@ -0,0 +1,73 @@
+# lib/leptris/node.rb — Leptris::Node wraps LeptrisNodeRef for generic
+# tree traversal (all node types, not just elements).
+
+module Leptris
+  class Node
+    attr_reader :ptr
+
+    def initialize(ptr, document)
+      @ptr = ptr
+      @document = document
+    end
+
+    def type
+      Leptris.leptris_node_get_type(@ptr)
+    end
+
+    def element?
+      type == Leptris::NODE_ELEMENT
+    end
+
+    def text?
+      type == Leptris::NODE_TEXT
+    end
+
+    def comment?
+      type == Leptris::NODE_COMMENT
+    end
+
+    def cdata?
+      type == Leptris::NODE_CDATA
+    end
+
+    def pi?
+      type == Leptris::NODE_PI
+    end
+
+    def content
+      case type
+      when Leptris::NODE_TEXT     then Leptris.leptris_text_node_get_content(@ptr)
+      when Leptris::NODE_COMMENT  then Leptris.leptris_comment_node_get_content(@ptr)
+      when Leptris::NODE_CDATA    then Leptris.leptris_cdata_node_get_content(@ptr)
+      else nil
+      end
+    end
+
+    def first_child
+      c = Leptris.leptris_node_first_child(@ptr)
+      return nil if c.nil? || c.null?
+      Node.new(c, @document)
+    end
+
+    def next_sibling
+      s = Leptris.leptris_node_next_sibling(@ptr)
+      return nil if s.nil? || s.null?
+      Node.new(s, @document)
+    end
+
+    def child_count
+      Leptris.leptris_node_child_count(@ptr)
+    end
+
+    def as_element
+      return nil unless element?
+      elem = Leptris.leptris_node_as_element(@ptr)
+      return nil if elem.nil? || elem.null?
+      Element.new(elem, @document)
+    end
+
+    def inspect
+      "<Leptris::Node type=#{type}>"
+    end
+  end
+end

data/vendor-src/libleptris/bindings/ruby/lib/leptris/sax.rb

@@ -0,0 +1,189 @@
+# lib/leptris/sax.rb — Leptris::SAX provides event-driven parsing.
+#
+# Two surfaces over the C SAX API (leptris/sax/sax.h):
+#
+#   Leptris::SAX.parse(xml, handlers)   — one-shot parse of a String.
+#   Leptris::SAX::Parser                — incremental feed() for streams.
+#
+# handlers is a Hash of procs keyed by event name. All keys are
+# optional; unset callbacks are not passed to C at all:
+#
+#   :start_document          -> ()
+#   :end_document            -> ()
+#   :start_element           -> (name, attrs_hash)
+#   :end_element             -> (name)
+#   :characters              -> (text)
+#   :comment                 -> (text)
+#   :cdata                   -> (text)
+#   :processing_instruction  -> (target, data)
+#   :start_prefix_mapping    -> (prefix, uri)
+#   :end_prefix_mapping      -> (prefix)
+#   :error                   -> (message, line, column)
+#
+# All strings handed to Ruby are UTF-8 copies (read out of the C
+# callback scope before it returns).
+
+module Leptris
+  module SAX
+    # C struct LeptrisSAXHandler — 11 function pointers, same order
+    # as sax.h.
+    class HandlerStruct < FFI::Struct
+      layout(
+        :start_document,         Leptris.find_type(:sax_start_document),
+        :end_document,           Leptris.find_type(:sax_end_document),
+        :start_element,          Leptris.find_type(:sax_start_element),
+        :end_element,            Leptris.find_type(:sax_end_element),
+        :characters,             Leptris.find_type(:sax_characters),
+        :comment,                Leptris.find_type(:sax_comment),
+        :cdata,                  Leptris.find_type(:sax_cdata),
+        :processing_instruction, Leptris.find_type(:sax_pi),
+        :start_prefix_mapping,   Leptris.find_type(:sax_prefix_mapping),
+        :end_prefix_mapping,     Leptris.find_type(:sax_end_prefix),
+        :error,                  Leptris.find_type(:sax_error)
+      )
+    end
+
+    # C-side argument lists after user_data, per event.
+    C_ARGS = {
+      start_document: [],
+      end_document: [],
+      start_element: %i[string pointer],
+      end_element: [:string],
+      characters: %i[pointer size_t],
+      comment: [:string],
+      cdata: [:string],
+      processing_instruction: %i[string string],
+      start_prefix_mapping: %i[string string],
+      end_prefix_mapping: [:string],
+      error: %i[string int int]
+    }.freeze
+    private_constant :C_ARGS
+
+    # Bridges C callbacks into Ruby handler procs.
+    #
+    # user_data pattern: C hands back an opaque pointer we chose. We
+    # pass the address of a small FFI::MemoryPointer unique per
+    # bridge; REGISTRY maps that address back to this object. The
+    # Ruby object itself is never exposed to C, so the GC can move
+    # it freely. The registry entry (and with it the anchor and the
+    # FFI::Function objects) stays alive exactly as long as C can
+    # still fire callbacks — until #release.
+    class Bridge
+      REGISTRY = {}
+
+      attr_reader :anchor
+
+      def initialize(handlers)
+        @handlers = handlers
+        @anchor = FFI::MemoryPointer.new(:char, 1)
+        @struct = HandlerStruct.new
+        REGISTRY[@anchor.address] = self
+
+        C_ARGS.each do |event, c_args|
+          handler = handlers[event]
+          next unless handler
+          @struct[event] = FFI::Function.new(:void, [:pointer] + c_args) do |user_data, *args|
+            bridge = REGISTRY[user_data.address]
+            bridge.fire(event, handler, args) if bridge
+          end
+        end
+      end
+
+      # The struct pointer to hand to C as LeptrisSAXHandler*.
+      def pointer
+        @struct
+      end
+
+      def fire(event, handler, args)
+        case event
+        when :start_element
+          handler.call(str(args[0]), Bridge.read_attrs(args[1]))
+        when :characters
+          handler.call(args[0].get_bytes(0, args[1]).force_encoding(Encoding::UTF_8))
+        else
+          handler.call(*args.map { |a| a.is_a?(String) ? str(a) : a })
+        end
+      end
+
+      def str(s)
+        s.force_encoding(Encoding::UTF_8)
+      end
+
+      # attrs is a NULL-terminated char** of name/value pairs:
+      # [name1, value1, name2, value2, ..., NULL].
+      def self.read_attrs(attrs)
+        return {} if attrs.null?
+        step = FFI.type_size(:pointer)
+        out = {}
+        i = 0
+        while (name_p = attrs.get_pointer(i)) && !name_p.null?
+          value_p = attrs.get_pointer(i + step)
+          out[name_p.read_string.force_encoding(Encoding::UTF_8)] =
+            value_p.null? ? nil : value_p.read_string.force_encoding(Encoding::UTF_8)
+          i += 2 * step
+        end
+        out
+      end
+
+      def release
+        REGISTRY.delete(@anchor.address)
+      end
+    end
+    private_constant :Bridge
+
+    # One-shot SAX parse of a String.
+    #
+    # Returns true on success. Raises Leptris::Error when parsing
+    # fails; the :error handler (if any) observes the failure
+    # before the raise.
+    def self.parse(xml, handlers = {})
+      raise ArgumentError, 'xml must be a String' unless xml.is_a?(String)
+
+      bridge = Bridge.new(handlers)
+      rc = Leptris.leptris_sax_parse(
+        xml, xml.bytesize, bridge.pointer, bridge.anchor
+      )
+      bridge.release
+      raise Error, 'SAX parse failed' if rc != 0
+      true
+    end
+
+    # Incremental SAX parser for streaming input.
+    #
+    #   parser = Leptris::SAX::Parser.new(handlers, streaming: true)
+    #   io.each_chunk { |chunk| parser.feed(chunk) }
+    #   parser.feed('', final: true)
+    #   parser.free
+    #
+    # streaming: true enables the constant-memory state machine
+    # (leptris_sax_parser_set_streaming); the default matches the C
+    # default (buffer chunks, parse on the final feed).
+    class Parser
+      def initialize(handlers = {}, streaming: false)
+        @bridge = Bridge.new(handlers)
+        @parser = Leptris.leptris_sax_parser_create(
+          @bridge.pointer, @bridge.anchor
+        )
+        raise Error, 'SAX parser creation failed' if @parser.null?
+        if streaming
+          rc = Leptris.leptris_sax_parser_set_streaming(@parser, 1)
+          raise Error, 'SAX streaming mode rejected' if rc != 0
+        end
+      end
+
+      def feed(chunk, final: false)
+        raise ArgumentError, 'chunk must be a String' unless chunk.is_a?(String)
+        Leptris.leptris_sax_parser_feed(
+          @parser, chunk, chunk.bytesize, final ? 1 : 0
+        )
+      end
+
+      def free
+        return unless @parser
+        Leptris.leptris_sax_parser_free(@parser)
+        @parser = nil
+        @bridge.release
+      end
+    end
+  end
+end

data/vendor-src/libleptris/bindings/ruby/lib/leptris/xpath.rb

@@ -0,0 +1,44 @@
+# lib/leptris/xpath.rb — Leptris::XPath evaluates XPath expressions.
+#
+# Results are typed: number, string, boolean, or nodeset.  Nodeset
+# results return Element objects; scalar results return the native
+# Ruby type.
+
+module Leptris
+  module XPath
+    RESULT_NODESET  = 0
+    RESULT_BOOLEAN  = 1
+    RESULT_NUMBER   = 2
+    RESULT_STRING   = 3
+
+    def self.evaluate(document, context_element, expression)
+      ctx_ptr = context_element ? context_element.ptr : nil
+      result = Leptris.leptris_xpath_eval(document.ptr, ctx_ptr, expression)
+      raise Error, 'XPath evaluation failed' if result.nil? || result.null?
+
+      type = Leptris.leptris_xpath_result_type(result)
+      value = case type
+              when RESULT_NUMBER  then Leptris.leptris_xpath_result_number(result)
+              when RESULT_STRING
+                ptr = Leptris.leptris_xpath_result_string(result)
+                str = ptr.read_string
+                Leptris.leptris_free_string(ptr)
+                str
+              when RESULT_BOOLEAN
+                # Boolean is encoded as number internally.
+                Leptris.leptris_xpath_result_number(result) != 0
+              when RESULT_NODESET
+                count = Leptris.leptris_xpath_result_count(result)
+                (0...count).map do |i|
+                  elem = Leptris.leptris_xpath_result_get(result, i)
+                  Element.new(elem, document)
+                end
+              else
+                nil
+              end
+
+      Leptris.leptris_xpath_result_free(result)
+      value
+    end
+  end
+end