talon_one 5.0.0 → 7.0.0

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/ffi-1.17.0-arm64-darwin/lib/ffi/tools/generator.rb

@@ -0,0 +1,105 @@
+require 'ffi/tools/struct_generator'
+require 'ffi/tools/const_generator'
+
+module FFI
+
+  ##
+  # Generate files with C structs for FFI::Struct and C constants.
+  #
+  # == A simple example
+  #
+  # In file +zlib.rb.ffi+:
+  #   module Zlib
+  #     @@@
+  #     constants do |c|
+  #       c.include "zlib.h"
+  #       c.const :ZLIB_VERNUM
+  #     end
+  #     @@@
+  #
+  #     class ZStream < FFI::Struct
+  #
+  #       struct do |s|
+  #         s.name "struct z_stream_s"
+  #         s.include "zlib.h"
+  #
+  #         s.field :next_in,   :pointer
+  #         s.field :avail_in,  :uint
+  #         s.field :total_in,  :ulong
+  #       end
+  #       @@@
+  #     end
+  #   end
+  #
+  # Translate the file:
+  #   require "ffi/tools/generator"
+  #   FFI::Generator.new "zlib.rb.ffi", "zlib.rb"
+  #
+  # Generates the file +zlib.rb+ with constant values and offsets:
+  #   module Zlib
+  #   ZLIB_VERNUM = 4784
+  #
+  #   class ZStream < FFI::Struct
+  #     layout :next_in, :pointer, 0,
+  #            :avail_in, :uint, 8,
+  #            :total_in, :ulong, 16
+  #   end
+  #
+  # @see FFI::Generator::Task for easy integration in a Rakefile
+  class Generator
+
+    def initialize(ffi_name, rb_name, options = {})
+      @ffi_name = ffi_name
+      @rb_name = rb_name
+      @options = options
+      @name = File.basename rb_name, '.rb'
+
+      file = File.read @ffi_name
+
+      new_file = file.gsub(/^( *)@@@(.*?)@@@/m) do
+        @constants = []
+        @structs = []
+
+        indent = $1
+        original_lines = $2.count "\n"
+
+        instance_eval $2, @ffi_name, $`.count("\n")
+
+        new_lines = []
+        @constants.each { |c| new_lines << c.to_ruby }
+        @structs.each { |s| new_lines << s.generate_layout }
+
+        new_lines = new_lines.join("\n").split "\n" # expand multiline blocks
+        new_lines = new_lines.map { |line| indent + line }
+
+        padding = original_lines - new_lines.length
+        new_lines += [nil] * padding if padding >= 0
+
+        new_lines.join "\n"
+      end
+
+      open @rb_name, 'w' do |f|
+        f.puts "# This file is generated from `#{@ffi_name}'. Do not edit."
+        f.puts
+        f.puts new_file
+      end
+    end
+
+    def constants(options = {}, &block)
+      @constants << FFI::ConstGenerator.new(@name, @options.merge(options), &block)
+    end
+
+    def struct(options = {}, &block)
+      @structs << FFI::StructGenerator.new(@name, @options.merge(options), &block)
+    end
+
+    ##
+    # Utility converter for constants
+
+    def to_s
+      proc { |obj| obj.to_s.inspect }
+    end
+
+  end
+end
+

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/ffi-1.17.0-arm64-darwin/lib/ffi/tools/generator_task.rb

@@ -0,0 +1,32 @@
+require 'ffi/tools/generator'
+require 'rake'
+require 'rake/tasklib'
+
+##
+# Add Rake tasks that generate files with C structs for FFI::Struct and C constants.
+#
+# @example a simple example for your Rakefile
+#   require "ffi/tools/generator_task"
+#   # Add a task to generate my_object.rb out of my_object.rb.ffi
+#   FFI::Generator::Task.new ["my_object.rb"], cflags: "-I/usr/local/mylibrary"
+#
+# The generated files are also added to the 'clear' task.
+#
+# @see FFI::Generator for a description of the file content
+class FFI::Generator::Task < Rake::TaskLib
+
+  def initialize(rb_names, options={})
+    task :clean do rm_f rb_names end
+
+    rb_names.each do |rb_name|
+      ffi_name = "#{rb_name}.ffi"
+
+      file rb_name => ffi_name do |t|
+        puts "Generating #{rb_name}..." if Rake.application.options.trace
+
+        FFI::Generator.new ffi_name, rb_name, options
+      end
+    end
+  end
+
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/ffi-1.17.0-arm64-darwin/lib/ffi/tools/struct_generator.rb

@@ -0,0 +1,195 @@
+require 'tempfile'
+
+module FFI
+
+  ##
+  # Generates an FFI Struct layout.
+  #
+  # Given the @@@ portion in:
+  #
+  #   class Zlib::ZStream < FFI::Struct
+  #     @@@
+  #     name "struct z_stream_s"
+  #     include "zlib.h"
+  #
+  #     field :next_in,   :pointer
+  #     field :avail_in,  :uint
+  #     field :total_in,  :ulong
+  #
+  #     # ...
+  #     @@@
+  #   end
+  #
+  # StructGenerator will create the layout:
+  #
+  #   layout :next_in, :pointer, 0,
+  #          :avail_in, :uint, 4,
+  #          :total_in, :ulong, 8,
+  #          # ...
+  #
+  # StructGenerator does its best to pad the layout it produces to preserve
+  # line numbers.  Place the struct definition as close to the top of the file
+  # for best results.
+
+  class StructGenerator
+    @options = {}
+    attr_accessor :size
+    attr_reader   :fields
+
+    def initialize(name, options = {})
+      @name = name
+      @struct_name = nil
+      @includes = []
+      @fields = []
+      @found = false
+      @size = nil
+
+      if block_given? then
+        yield self
+        calculate self.class.options.merge(options)
+      end
+    end
+    def self.options=(options)
+      @options = options
+    end
+    def self.options
+      @options
+    end
+    def calculate(options = {})
+      binary = File.join Dir.tmpdir, "rb_struct_gen_bin_#{Process.pid}"
+
+      raise "struct name not set" if @struct_name.nil?
+
+      Tempfile.open("#{@name}.struct_generator") do |f|
+        f.puts "#include <stdio.h>"
+
+        @includes.each do |inc|
+          f.puts "#include <#{inc}>"
+        end
+
+        f.puts "#include <stddef.h>\n\n"
+        f.puts "int main(int argc, char **argv)\n{"
+        f.puts "  #{@struct_name} s;"
+        f.puts %[  printf("sizeof(#{@struct_name}) %u\\n", (unsigned int) sizeof(#{@struct_name}));]
+
+        @fields.each do |field|
+          f.puts <<-EOF
+    printf("#{field.name} %u %u\\n", (unsigned int) offsetof(#{@struct_name}, #{field.name}),
+           (unsigned int) sizeof(s.#{field.name}));
+  EOF
+        end
+
+        f.puts "\n  return 0;\n}"
+        f.flush
+
+        cc = ENV['CC'] || 'gcc'
+        output = `#{cc} #{options[:cppflags]} #{options[:cflags]} -D_DARWIN_USE_64_BIT_INODE -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -x c -Wall -Werror #{f.path} -o #{binary} 2>&1`
+
+        unless $?.success? then
+          @found = false
+          output = output.split("\n").map { |l| "\t#{l}" }.join "\n"
+          raise "Compilation error generating struct #{@name} (#{@struct_name}):\n#{output}"
+        end
+      end
+
+      output = `#{binary}`.split "\n"
+      File.unlink(binary + (FFI::Platform.windows? ? ".exe" : ""))
+      sizeof = output.shift
+      unless @size
+        m = /\s*sizeof\([^)]+\) (\d+)/.match sizeof
+        @size = m[1]
+      end
+
+      line_no = 0
+      output.each do |line|
+        md = line.match(/.+ (\d+) (\d+)/)
+        @fields[line_no].offset = md[1].to_i
+        @fields[line_no].size   = md[2].to_i
+
+        line_no += 1
+      end
+
+      @found = true
+    end
+
+    def field(name, type=nil)
+      field = Field.new(name, type)
+      @fields << field
+      return field
+    end
+
+    def found?
+      @found
+    end
+
+    def dump_config(io)
+      io.puts "rbx.platform.#{@name}.sizeof = #{@size}"
+
+      @fields.each { |field| io.puts field.to_config(@name) }
+    end
+
+    def generate_layout
+      buf = ""
+
+      @fields.each_with_index do |field, i|
+        if buf.empty?
+          buf << "layout :#{field.name}, :#{field.type}, #{field.offset}"
+        else
+          buf << "       :#{field.name}, :#{field.type}, #{field.offset}"
+        end
+
+        if i < @fields.length - 1
+          buf << ",\n"
+        end
+      end
+
+      buf
+    end
+
+    def get_field(name)
+      @fields.find { |f| name == f.name }
+    end
+
+    def include(i)
+      @includes << i
+    end
+
+    def name(n)
+      @struct_name = n
+    end
+
+  end
+
+  ##
+  # A field in a Struct.
+
+  class StructGenerator::Field
+
+    attr_reader :name
+    attr_reader :type
+    attr_reader :offset
+    attr_accessor :size
+
+    def initialize(name, type)
+      @name = name
+      @type = type
+      @offset = nil
+      @size = nil
+    end
+
+    def offset=(o)
+      @offset = o
+    end
+
+    def to_config(name)
+      buf = []
+      buf << "rbx.platform.#{name}.#{@name}.offset = #{@offset}"
+      buf << "rbx.platform.#{name}.#{@name}.size = #{@size}"
+      buf << "rbx.platform.#{name}.#{@name}.type = #{@type}" if @type
+      buf
+    end
+
+  end
+
+end
+

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/ffi-1.17.0-arm64-darwin/lib/ffi/tools/types_generator.rb

@@ -0,0 +1,137 @@
+require 'tempfile'
+
+module FFI
+
+  # @private
+  class TypesGenerator
+
+    ##
+    # Maps different C types to the C type representations we use
+
+    TYPE_MAP = {
+               "char" => :char,
+        "signed char" => :char,
+      "__signed char" => :char,
+      "unsigned char" => :uchar,
+
+               "short"     => :short,
+        "signed short"     => :short,
+        "signed short int" => :short,
+      "unsigned short"     => :ushort,
+      "unsigned short int" => :ushort,
+
+               "int" => :int,
+        "signed int" => :int,
+      "unsigned int" => :uint,
+
+               "long" => :long,
+               "long int" => :long,
+        "signed long" => :long,
+        "signed long int" => :long,
+      "unsigned long" => :ulong,
+      "unsigned long int" => :ulong,
+      "long unsigned int" => :ulong,
+
+               "long long"     => :long_long,
+               "long long int" => :long_long,
+        "signed long long"     => :long_long,
+        "signed long long int" => :long_long,
+      "unsigned long long"     => :ulong_long,
+      "unsigned long long int" => :ulong_long,
+
+      "char *" => :string,
+      "void *" => :pointer,
+    }
+
+    def self.generate(options = {})
+      typedefs = nil
+      Tempfile.open 'ffi_types_generator' do |io|
+        io.puts <<-C
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/types.h>
+#if !(defined(WIN32))
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/resource.h>
+#endif
+        C
+
+        io.close
+        cc = ENV['CC'] || 'gcc'
+        cmd = "#{cc} -E -x c #{options[:cppflags]} -D_DARWIN_USE_64_BIT_INODE -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -c"
+        if options[:input]
+          typedefs = File.read(options[:input])
+        elsif options[:remote]
+          typedefs = `ssh #{options[:remote]} #{cmd} - < #{io.path}`
+        else
+          typedefs = `#{cmd} #{io.path}`
+        end
+      end
+
+      code = []
+
+      typedefs.each_line do |type|
+        # We only care about single line typedef
+        next unless type =~ /typedef/
+        # Ignore unions or structs
+        next if type =~ /union|struct/
+
+        # strip off the starting typedef and ending ;
+        type.gsub!(/^(.*typedef\s*)/, "")
+        type.gsub!(/\s*;\s*$/, "")
+
+        parts = type.split(/\s+/)
+        def_type   = parts.join(" ")
+
+        # GCC does mapping with __attribute__ stuf, also see
+        # http://hal.cs.berkeley.edu/cil/cil016.html section 16.2.7.  Problem
+        # with this is that the __attribute__ stuff can either occur before or
+        # after the new type that is defined...
+        if type =~ /__attribute__/
+          if parts.last =~ /__QI__|__HI__|__SI__|__DI__|__word__/
+
+            # In this case, the new type is BEFORE __attribute__ we need to
+            # find the final_type as the type before the part that starts with
+            # __attribute__
+            final_type = ""
+            parts.each do |p|
+              break if p =~ /__attribute__/
+              final_type = p
+            end
+          else
+            final_type = parts.pop
+          end
+
+          def_type = case type
+                     when /__QI__/   then "char"
+                     when /__HI__/   then "short"
+                     when /__SI__/   then "int"
+                     when /__DI__/   then "long long"
+                     when /__word__/ then "long"
+                     else                 "int"
+                     end
+
+          def_type = "unsigned #{def_type}" if type =~ /unsigned/
+        else
+          final_type = parts.pop
+          def_type   = parts.join(" ")
+        end
+
+        if type = TYPE_MAP[def_type]
+          code << "rbx.platform.typedef.#{final_type} = #{type}"
+          TYPE_MAP[final_type] = TYPE_MAP[def_type]
+        else
+          # Fallback to an ordinary pointer if we don't know the type
+          if def_type =~ /\*/
+            code << "rbx.platform.typedef.#{final_type} = pointer"
+            TYPE_MAP[final_type] = :pointer
+          end
+        end
+      end
+
+      code.sort.join("\n")
+    end
+  end
+end
+

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/ffi-1.17.0-arm64-darwin/lib/ffi/types.rb

@@ -0,0 +1,222 @@
+#
+# Copyright (C) 2008-2010 Wayne Meissner
+# Copyright (c) 2007, 2008 Evan Phoenix
+#
+# This file is part of ruby-ffi.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the Ruby FFI project nor the names of its contributors
+#   may be used to endorse or promote products derived from this software
+#   without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+# see {file:README}
+module FFI
+
+  # Unless custom_typedefs already defined in the C-ext?
+  unless defined?(custom_typedefs)
+    # Truffleruby and JRuby don't support Ractor so far.
+    # So they don't need separation between builtin and custom types.
+    def self.custom_typedefs
+      TypeDefs
+    end
+    writable_typemap = true
+  end
+
+  class << self
+
+    private :custom_typedefs
+
+    # @param [Type, DataConverter, Symbol] old type definition used by {FFI.find_type}
+    # @param [Symbol] add new type definition's name to add
+    # @return [Type]
+    # Add a definition type to type definitions.
+    #
+    # The type definition is local per Ractor.
+    def typedef(old, add)
+      tm = custom_typedefs
+      tm[add] = find_type(old)
+    end
+
+    # (see FFI.typedef)
+    def add_typedef(old, add)
+      typedef old, add
+    end
+
+    private def __typedef(old, add)
+      TypeDefs[add] = find_type(old, TypeDefs)
+    end
+
+    # @param [Type, DataConverter, Symbol] name
+    # @param [Hash] type_map if nil, {FFI::TypeDefs} is used
+    # @return [Type]
+    # Find a type in +type_map+ ({FFI::TypeDefs}, by default) from
+    # a type objet, a type name (symbol). If +name+ is a {DataConverter},
+    # a new {Type::Mapped} is created.
+    def find_type(name, type_map = nil)
+      if name.is_a?(Type)
+        name
+
+      elsif type_map&.has_key?(name)
+        type_map[name]
+
+      elsif (tm=custom_typedefs).has_key?(name)
+        tm[name]
+
+      elsif TypeDefs.has_key?(name)
+        TypeDefs[name]
+
+      elsif name.is_a?(DataConverter)
+        # Add a typedef so next time the converter is used, it hits the cache
+        tm = (type_map || custom_typedefs)
+        tm[name] = Type::Mapped.new(name)
+      else
+        raise TypeError, "unable to resolve type '#{name}'"
+      end
+    end
+
+    # @param type +type+ is an instance of class accepted by {FFI.find_type}
+    # @return [Integer]
+    # Get +type+ size, in bytes.
+    def type_size(type)
+      find_type(type).size
+    end
+  end
+
+  # List of type definitions
+  TypeDefs.merge!({
+      # The C void type; only useful for function return types
+      :void => Type::VOID,
+
+      # C boolean type
+      :bool => Type::BOOL,
+
+      # C nul-terminated string
+      :string => Type::STRING,
+
+      # C signed char
+      :char => Type::CHAR,
+      # C unsigned char
+      :uchar => Type::UCHAR,
+
+      # C signed short
+      :short => Type::SHORT,
+      # C unsigned short
+      :ushort => Type::USHORT,
+
+      # C signed int
+      :int => Type::INT,
+      # C unsigned int
+      :uint => Type::UINT,
+
+      # C signed long
+      :long => Type::LONG,
+
+      # C unsigned long
+      :ulong => Type::ULONG,
+
+      # C signed long long integer
+      :long_long => Type::LONG_LONG,
+
+      # C unsigned long long integer
+      :ulong_long => Type::ULONG_LONG,
+
+      # C single precision float
+      :float => Type::FLOAT,
+
+      # C double precision float
+      :double => Type::DOUBLE,
+
+      # C long double
+      :long_double => Type::LONGDOUBLE,
+
+      # Native memory address
+      :pointer => Type::POINTER,
+
+      # 8 bit signed integer
+      :int8 => Type::INT8,
+      # 8 bit unsigned integer
+      :uint8 => Type::UINT8,
+
+      # 16 bit signed integer
+      :int16 => Type::INT16,
+      # 16 bit unsigned integer
+      :uint16 => Type::UINT16,
+
+      # 32 bit signed integer
+      :int32 => Type::INT32,
+      # 32 bit unsigned integer
+      :uint32 => Type::UINT32,
+
+      # 64 bit signed integer
+      :int64 => Type::INT64,
+      # 64 bit unsigned integer
+      :uint64 => Type::UINT64,
+
+      :buffer_in => Type::BUFFER_IN,
+      :buffer_out => Type::BUFFER_OUT,
+      :buffer_inout => Type::BUFFER_INOUT,
+
+      # Used in function prototypes to indicate the arguments are variadic
+      :varargs => Type::VARARGS,
+  })
+
+  # This will convert a pointer to a Ruby string (just like `:string`), but
+  # also allow to work with the pointer itself. This is useful when you want
+  # a Ruby string already containing a copy of the data, but also the pointer
+  # to the data for you to do something with it, like freeing it, in case the
+  # library handed the memory off to the caller (Ruby-FFI).
+  #
+  # It's {typedef}'d as +:strptr+.
+  class StrPtrConverter
+    extend DataConverter
+    native_type Type::POINTER
+
+    # @param [Pointer] val
+    # @param ctx not used
+    # @return [Array(String, Pointer)]
+    # Returns a [ String, Pointer ] tuple so the C memory for the string can be freed
+    def self.from_native(val, ctx)
+      [ val.null? ? nil : val.get_string(0), val ]
+    end
+  end
+
+  __typedef(StrPtrConverter, :strptr)
+
+  # Load all the platform dependent types
+  begin
+    File.open(File.join(Platform::CONF_DIR, 'types.conf'), "r") do |f|
+      prefix = "rbx.platform.typedef."
+      f.each_line { |line|
+        if line.index(prefix) == 0
+          new_type, orig_type = line.chomp.slice(prefix.length..-1).split(/\s*=\s*/)
+          __typedef(orig_type.to_sym, new_type.to_sym)
+        end
+      }
+    end
+    __typedef :pointer, :caddr_t
+  rescue Errno::ENOENT
+  end
+
+  FFI.make_shareable(TypeDefs) unless writable_typemap
+end