CStructParser 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3e07a5df41c9f0657cea7c81adc45ab49353e3f92c8e688dc22880e7dc89ebcd
+  data.tar.gz: 3473f7f32f3cdf1116f1fe0d02e550c899acfd9d6ae8eb22bb21a28944d050e9
+SHA512:
+  metadata.gz: a4160449ba037b6c1ea9ee734074118a99310f25c85771c94ff4f4a903ec8016c513345ad849f77165039cbbc9c146f1f584dd72ab0b13086e36274aa42fb39b
+  data.tar.gz: fde1f3e2de0ce8314d6fda2ca3cad45a37586f67e1b693fcbef30a21c478d545ce4a73fcd26b40357e9372e5d9c0d91d9712079ea35c36cfe8bcf5bc62fc00dd

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+
+## [0.1.0] - 2026-02-02
+
+- First release
+- Support for generating [FFI](https://github.com/ffi/ffi) and [BinData](https://github.com/dmendel/bindata) objects

data/README.md

@@ -0,0 +1,44 @@
+# CStructParser
+
+Parse C structs into usable Ruby objects like BinData records.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add CStructParser
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install CStructParser
+```
+
+## Usage
+
+### For usage with [FFI](https://github.com/ffi/ffi)
+```
+sourceCode = 'struct s { int a; float b; };' # Can be path to file aswell
+CStructParser.to_ffi(sourceCode)
+```
+
+### For usage with [BinData](https://github.com/dmendel/bindata)
+```
+CStructParser.to_bindata('stuff.h')
+```
+
+### Other use cases
+
+Not implemented, but should be quite simple to add support for other uses like [BinaryStruct](https://github.com/ManageIQ/binary_struct), `String#unpack` format etc.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/davispuh/CStructParser.

data/Rakefile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'yard'
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new(:spec) do |t|
+end
+
+YARD::Rake::YardocTask.new(:doc) do |t|
+end
+
+
+task default: :spec

data/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>

data/lib/cstruct_parser/bindata.rb

@@ -0,0 +1,102 @@
+require 'stringio'
+
+module CStructParser::BinData
+
+    TYPES = {
+        :bool        => :bit1,
+        :char        => :int8,
+        :s_char      => :int8,
+        :char_s      => :int8,
+        :u_char      => :uint8,
+        :short       => :int16,
+        :u_short     => :uint16,
+        :int         => :int32,
+        :u_int       => :uint32,
+        :long_long   => :int64,
+        :u_long_long => :uint64,
+        :float       => :float,
+        :double      => :double,
+        :long_double => :long_double
+    }
+
+    TYPES_32 = {
+        :long        => :int32,
+        :u_long      => :uint32
+    }
+
+    TYPES_64 = {
+        :long        => :int64,
+        :u_long      => :uint64
+    }
+
+    def self.toBinDataType(type, options)
+        if type.is_a?(FFIGenerate::Generator::PrimitiveType)
+            types = TYPES.merge(options[:long32] ? TYPES_32 : TYPES_64)
+            raise "Unknown primitive type #{type.clang_type}" unless types.include?(type.clang_type)
+            types[type.clang_type]
+        elsif type.is_a?(FFIGenerate::Generator::StringType)
+            :string
+        elsif type.is_a?(FFIGenerate::Generator::ArrayType)
+            :array
+        elsif type.is_a?(FFIGenerate::Generator::ByValueType)
+            type.name.to_ruby_downcase
+        elsif type.is_a?(FFIGenerate::Generator::StructOrUnion)
+            ('p' + type.ruby_name).to_sym
+        elsif type.is_a?(FFIGenerate::Generator::PointerType)
+            types = TYPES.merge(options[:long_32] ? TYPES_32 : TYPES_64)
+            typeName = type.ruby_name
+            typeName = 's_char' if typeName == 'schar'
+            typeName = 'u_char' if typeName == 'uchar'
+            typeName = 'u_short' if typeName == 'ushort'
+            typeName = 'u_int' if typeName == 'uint'
+            typeName = 'u_long' if typeName == 'ulong'
+            typeName = 'long_long' if typeName == 'longlong'
+            typeName = 'u_long_long' if typeName == 'ulonglong'
+            typeName = 'long_double' if typeName == 'longdouble'
+            typeName = types[typeName.to_sym].to_s if types.include?(typeName.to_sym)
+            ('p' * type.depth + typeName).to_sym
+        else
+            raise "Unexpected type #{type}"
+        end
+    end
+
+    def self.buildField(field, attributes, i, options, indent = 2)
+        params = []
+        if field[:type].is_a?(FFIGenerate::Generator::ArrayType)
+            typeName = 'array'
+            elementType = toBinDataType(field[:type].element_type, options)
+            params << ['type', ':' + elementType.to_s].join(': ')
+            params << ['initial_length', field[:type].constant_size].join(': ')
+        else
+            typeName = toBinDataType(field[:type], options)
+        end
+        if attributes[:aligned]
+            params << ['byte_align', attributes[:aligned]].join(': ')
+        end
+        fieldName = field[:name] ? field[:name].to_ruby_downcase : 'field' + (i + 1).to_s
+        comment = ''
+        comment = " # #{field[:comment].join(' ')}" unless field[:comment].empty?
+        ' ' * indent + "#{typeName} :#{fieldName}#{params.empty? ? '' : ', ' + params.join(', ')}#{comment}\n"
+    end
+
+    def self.generate_rb(declarations, options = {})
+        result = StringIO.new
+        indent = options[:indent].to_i
+        declarations.each do |declaration|
+            if declaration.is_a?(FFIGenerate::Generator::StructOrUnion)
+                name = declaration.name.format(:downcase, :camelcase, FFIGenerate::Generator::Name::RUBY_KEYWORDS)
+                classLine = "class #{name} < BinData::Record\n"
+                classLine += ' ' * indent + "endian :#{options[:endian]}\n"
+                classLine += ' ' * indent + "# TODO Choice/Union\n" if declaration.union?
+                result << classLine
+                declaration.fields.each_with_index do |field, i|
+                    fieldLine = buildField(field, declaration.attributes, i, options, declaration.union? && i > 0 ? 0 : indent)
+                    fieldLine = ' ' * indent + '# ' + fieldLine if declaration.union? && i > 0
+                    result << fieldLine
+                end
+                result << "end\n\n"
+            end
+        end
+        result.string
+    end
+end

data/lib/cstruct_parser/parser.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'ffi_generator'
+require 'stringio'
+require 'tempfile'
+require_relative 'bindata'
+
+module CStructParser
+    class Parser
+
+        attr_reader :generator
+
+        def initialize(options = {})
+            @options = { module_name: 'CStructModule', endian: :little, indent: 2 }.merge(options)
+            @generator = nil
+        end
+
+        def load!(headers)
+            @options[:headers] = headers
+            @options[:headers] = [@options[:headers]] unless @options[:headers].is_a?(Array)
+            @generator = FFIGenerate::Generator.new(@options)
+            @generator.declarations
+            @generator
+        end
+
+        def parse!(data)
+            if isFile(data)
+                load!(data)
+            else
+                Tempfile.create('struct.h') do |file|
+                    file.write(data)
+                    file.flush
+                    load!(file.path)
+                end
+            end
+            @generator
+        end
+
+        def declarations
+            return nil unless @generator
+            @generator.declarations
+        end
+
+        def to_ffi
+            @generator.generate_rb
+        end
+
+        def to_bindata
+            BinData.generate_rb(@generator.declarations, @options)
+        end
+
+        def to_pack
+            # TODO
+            # Ruby String#unpack / Array#pack format
+            raise 'Not Implemented!'
+        end
+
+        def to_binarystruct
+            # TODO
+            # https://github.com/ManageIQ/binary_struct
+            raise 'Not Implemented!'
+        end
+
+        protected
+
+        def isFile(data)
+            data.to_s.lines.count == 1 && File.exist?(data.to_s)
+        end
+    end
+end

data/lib/cstruct_parser/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CStructParser
+    VERSION = '0.1.0'
+end

data/lib/cstruct_parser.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'cstruct_parser/version'
+require_relative 'cstruct_parser/parser'
+
+
+module CStructParser
+    class Error < StandardError; end
+
+    def self.load(headers, options = {})
+        parser = Parser.new(options)
+        parser.load!(headers)
+        parser
+    end
+
+    def self.parse(data, options = {})
+        parser = Parser.new(options)
+        parser.parse!(data)
+        parser
+    end
+
+    def self.to_ffi(data, options = {})
+        self.parse(data, options).to_ffi
+    end
+
+    def self.to_bindata(data, options = {})
+        self.parse(data, options).to_bindata
+    end
+
+    def self.to_pack(data, options = {})
+        self.parse(data, options).to_pack
+    end
+
+    def self.to_binarystruct(data, options = {})
+        self.parse(data, options).to_binarystruct
+    end
+
+end

data/sig/CStructParser.rbs

@@ -0,0 +1,4 @@
+module CStructParser
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: CStructParser
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dāvis Mosāns
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi_generator
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- Rakefile
+- UNLICENSE
+- lib/cstruct_parser.rb
+- lib/cstruct_parser/bindata.rb
+- lib/cstruct_parser/parser.rb
+- lib/cstruct_parser/version.rb
+- sig/CStructParser.rbs
+homepage: https://github.com/davispuh/CStructParser
+licenses:
+- UNLICENSE
+metadata:
+  homepage_uri: https://github.com/davispuh/CStructParser
+  source_code_uri: https://github.com/davispuh/CStructParser
+  changelog_uri: https://github.com/davispuh/CStructParser/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.5
+specification_version: 4
+summary: Parse C structs into usable Ruby structs such as BinData
+test_files: []