ffidb 0.12.0

data/lib/ffidb/symbol_table.rb

@@ -0,0 +1,90 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'symbolic'
+
+module FFIDB
+  module SymbolTable
+    include Enumerable
+
+    ##
+    # @return [Array<Type>]
+    def types
+      self.each_type.to_a
+    end
+
+    ##
+    # @yield  [type]
+    # @yieldparam [type] Type
+    # @return [Enumerator]
+    def each_type(&block)
+      return self.to_enum(:each_type) unless block_given?
+      types = {}
+      self.each_function do |function| # TODO: each_symbol
+        types[function.type.to_s] ||= function.type
+        function.parameters.each_value do |parameter|
+          types[parameter.type.to_s] ||= parameter.type
+        end
+      end
+      types.values.sort.each(&block)
+    end
+
+    ##
+    # @yield  [symbol]
+    # @yieldparam [symbol] Symbolic
+    # @return [Enumerator]
+    def each_symbol(&block)
+      return self.to_enum(:each_symbol) unless block_given?
+      self.each_typedef(&block)
+      self.each_enum(&block)
+      self.each_struct(&block)
+      self.each_union(&block)
+      self.each_function(&block)
+    end
+    alias_method :each, :each_symbol
+
+    ##
+    # @yield  [typedef]
+    # @yieldparam [symbol] Symbolic
+    # @return [Enumerator]
+    def each_typedef(&block)
+      return self.to_enum(:each_typedef) unless block_given?
+      self.typedefs.each(&block)
+    end
+
+    ##
+    # @yield  [enum]
+    # @yieldparam [enum] Enum
+    # @return [Enumerator]
+    def each_enum(&block)
+      return self.to_enum(:each_enum) unless block_given?
+      self.enums.each(&block)
+    end
+
+    ##
+    # @yield  [struct]
+    # @yieldparam [struct] Struct
+    # @return [Enumerator]
+    def each_struct(&block)
+      return self.to_enum(:each_struct) unless block_given?
+      self.structs.each(&block)
+    end
+
+    ##
+    # @yield  [union]
+    # @yieldparam [union] Union
+    # @return [Enumerator]
+    def each_union(&block)
+      return self.to_enum(:each_union) unless block_given?
+      self.unions.each(&block)
+    end
+
+    ##
+    # @yield  [function]
+    # @yieldparam [function] Function
+    # @return [Enumerator]
+    def each_function(&block)
+      return self.to_enum(:each_function) unless block_given?
+      self.functions.each(&block)
+    end
+  end # SymbolTable
+end # FFIDB

data/lib/ffidb/symbolic.rb

@@ -0,0 +1,67 @@
+# This is free and unencumbered software released into the public domain.
+
+module FFIDB
+  module Symbolic
+    include Comparable
+
+    ##
+    # @param  [Symbolic] other
+    # @return [Integer]
+    def <=>(other)
+      self.name <=> other.name
+    end
+
+    ##
+    # @return [Symbol]
+    def kind
+      case
+        when self.typedef? then :typedef
+        when self.enum? then :enum
+        when self.struct? then :struct
+        when self.union? then :union
+        when self.function? then :function
+      end
+    end
+
+    ##
+    # @return [Integer]
+    def kind_weight
+      case
+        when self.typedef? then 1
+        when self.enum? then 2
+        when self.struct? then 3
+        when self.union? then 4
+        when self.function? then 5
+      end
+    end
+
+    ##
+    # @return [Boolean]
+    def typedef?() return false end
+
+    ##
+    # @return [Boolean]
+    def enum?() return false end
+
+    ##
+    # @return [Boolean]
+    def struct?() return false end
+
+    ##
+    # @return [Boolean]
+    def union?() return false end
+
+    ##
+    # @return [Boolean]
+    def function?() return false end
+
+    ##
+    # @return [String]
+    def to_yaml
+      h = self.to_h
+      h.transform_keys!(&:to_s)
+      h.transform_values! { |v| v.is_a?(Hash) ? v.transform_keys!(&:to_s) : v }
+      YAML.dump(h).gsub!("---\n", "--- !#{self.kind}\n")
+    end
+  end # Symbolic
+end # FFIDB

data/lib/ffidb/sysexits.rb

@@ -0,0 +1,21 @@
+# This is free and unencumbered software released into the public domain.
+
+module FFIDB
+  module Sysexits
+    EX_USAGE       = 64
+    EX_DATAERR     = 65
+    EX_NOINPUT     = 66
+    EX_NOUSER      = 67
+    EX_NOHOST      = 68
+    EX_UNAVAILABLE = 69
+    EX_SOFTWARE    = 70
+    EX_OSERR       = 71
+    EX_OSFILE      = 72
+    EX_CANTCREAT   = 73
+    EX_IOERR       = 74
+    EX_TEMPFAIL    = 75
+    EX_PROTOCOL    = 76
+    EX_NOPERM      = 77
+    EX_CONFIG      = 78
+  end # Sysexits
+end # FFIDB

data/lib/ffidb/type.rb

@@ -0,0 +1,214 @@
+# This is free and unencumbered software released into the public domain.
+
+module FFIDB
+  class Type < ::Struct.new(:spec)
+    include Comparable
+
+    ##
+    # @param  [String, #to_s] spec
+    # @return [Type]
+    def self.for(type_spec)
+      return type_spec if type_spec.is_a?(Type)
+      self.new(type_spec)
+    end
+
+    ##
+    # @param [String, #to_s] spec
+    def initialize(spec)
+      super(spec.to_s)
+    end
+
+    ##
+    # @param  [Type] other
+    # @return [Integer]
+    def <=>(other) self.spec <=> other.spec end
+
+    ##
+    # @return [Boolean]
+    def const_qualified?
+      self.spec.start_with?('const ')
+    end
+
+    ##
+    # @return [Boolean]
+    def atomic?
+      self.bool? || self.integer? || self.floating_point? || self.pointer? || nil # TODO
+    end
+
+    ##
+    # @return [Boolean]
+    def void?
+      self.spec == 'void'
+    end
+
+    ##
+    # @return [Boolean]
+    def bool?
+      self.spec == '_Bool'
+    end
+
+    ##
+    # @return [Boolean]
+    def enum?
+      !(self.pointer?) && self.spec.start_with?('enum ')
+    end
+
+    ##
+    # @return [Boolean]
+    def struct?
+      !(self.pointer?) && (self.spec.start_with?('struct ') || self.spec.start_with?('const struct '))
+    end
+
+    ##
+    # @return [Boolean]
+    def union?
+      !(self.pointer?) && (self.spec.start_with?('union ') || self.spec.start_with?('const union '))
+    end
+
+    ##
+    # @return [Boolean]
+    def integer?
+      case self.spec
+        when 'char', 'short', 'int', 'long', 'long long' then true
+        when 'unsigned char', 'unsigned short', 'unsigned int', 'unsigned long', 'unsigned long long' then true
+        when 'size_t', 'wchar_t' then true # <stddef.h>
+        when 'ssize_t', 'off_t' then true  # <sys/types.h>
+        when /^u?int\d+_t$/ then true
+        else false
+      end
+    end
+
+    ##
+    # @return [Boolean]
+    def signed_integer?
+      return false unless self.integer?
+      case self.spec
+        when 'char', 'short', 'int', 'long', 'long long' then true
+        when 'wchar_t' then nil  # <stddef.h>
+        when 'ssize_t' then true # <sys/types.h>
+        when /^int\d+_t$/ then true
+        else false
+      end
+    end
+
+    ##
+    # @return [Boolean]
+    def unsigned_integer?
+      return false unless self.integer?
+      return true if self.spec.start_with?('u')
+      case self.spec
+        when 'unsigned char', 'unsigned short', 'unsigned int', 'unsigned long', 'unsigned long long' then true
+        when 'size_t' then true # <stddef.h>
+        when 'wchar_t' then nil # <stddef.h>
+        when 'off_t' then true  # <sys/types.h>
+        when /^uint\d+_t$/ then true
+        else false
+      end
+    end
+
+    ##
+    # @return [Boolean]
+    def floating_point?
+      case self.spec
+        when 'float', 'double', 'long double' then true
+        else false
+      end
+    end
+
+    ##
+    # @return [Boolean]
+    def array?
+      self.spec.include?('[')
+    end
+
+    ##
+    # @return [Type]
+    def array_type
+      if self.array?
+        self.class.for(self.spec.gsub(/\s+(\[[^\]]+\])/, ''))
+      end
+    end
+
+    ##
+    # @return [Integer]
+    def array_size
+      if self.array?
+        (/\[([^\]]+)\]/ =~ self.spec) && $1.to_i
+      end
+    end
+
+    ##
+    # @return [Boolean]
+    def pointer?
+      self.spec.end_with?('*') ||
+      self.array_pointer?      ||
+      self.function_pointer?   ||
+      case self.spec
+        when 'intptr_t', 'uintptr_t' then true
+        when 'va_list' then true
+        else false
+      end
+    end
+
+    ##
+    # @return [Boolean]
+    def array_pointer?
+      self.spec.end_with?('[]')
+    end
+
+    ##
+    # @return [Boolean]
+    def enum_pointer?
+      self.pointer? && self.spec.start_with?('enum ')
+    end
+
+    ##
+    # @return [Boolean]
+    def struct_pointer?
+      self.pointer? && (self.spec.start_with?('struct ') || self.spec.start_with?('const struct '))
+    end
+
+    ##
+    # @return [Boolean]
+    def union_pointer?
+      self.pointer? && (self.spec.start_with?('union ') || self.spec.start_with?('const union '))
+    end
+
+    ##
+    # @return [Boolean]
+    def function_pointer?
+      self.spec.include?('(*)')
+    end
+
+    ##
+    # @return [Integer, Range, nil]
+    def sizeof
+      nil # TODO
+    end
+    alias_method :size, :sizeof
+
+    ##
+    # @return [Integer, Range, nil]
+    def alignof
+      nil # TODO
+    end
+
+    ##
+    # @return [String]
+    def to_s
+      self.spec
+    end
+
+    ##
+    # @return [Hash<Symbol, Object>]
+    def to_h
+      {spec: self.spec}
+    end
+
+    ##
+    # @return [String]
+    def inspect
+      "#{self.class}(#{self.spec.inspect})"
+    end
+  end # Type
+end # FFIDB

data/lib/ffidb/typedef.rb

@@ -0,0 +1,38 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'symbolic'
+require_relative 'type'
+
+module FFIDB
+  class Typedef < ::Struct.new(:name, :type, :comment)
+    include Symbolic
+
+    ##
+    # @param  [Symbol, #to_sym] name
+    # @param  [Type] type
+    # @param  [String, #to_s] comment
+    def initialize(name, type, comment = nil)
+      super(name.to_sym, Type.for(type), comment&.to_s)
+    end
+
+    ##
+    # @return [Boolean]
+    def typedef?() return true end
+
+    ##
+    # @return [String]
+    def to_s
+      "typedef #{self.type} #{self.name}"
+    end
+
+    ##
+    # @return [Hash<Symbol, Type>]
+    def to_h
+      {
+        name: self.name.to_s,
+        type: self.type.to_s,
+        comment: self.comment,
+      }.delete_if { |k, v| v.nil? }
+    end
+  end # Typedef
+end # FFIDB

data/lib/ffidb/union.rb

@@ -0,0 +1,37 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'symbolic'
+
+module FFIDB
+  class Union < ::Struct.new(:name, :fields, :comment)
+    include Symbolic
+
+    ##
+    # @param  [Symbol, #to_sym] name
+    # @param  [Map<Symbol, Type>] fields
+    # @param  [String, #to_s] comment
+    def initialize(name, fields = {}, comment = nil)
+      super(name.to_sym, fields || {}, comment&.to_s)
+    end
+
+    ##
+    # @return [Boolean]
+    def union?() return true end
+
+    ##
+    # @return [String]
+    def to_s
+      "union #{self.name}"
+    end
+
+    ##
+    # @return [Hash<Symbol, Type>]
+    def to_h
+      {
+        name: self.name.to_s,
+        comment: self.comment,
+        fields: self.fields,
+      }.delete_if { |k, v| v.nil? }
+    end
+  end # Union
+end # FFIDB