bindef 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1b724be52120b58e47c96e9f4b07571290196299c8a2a3c8b09dceee182516ee
+  data.tar.gz: 5d3953bb96c9622dddbd31590931b181fac46c20e942a8b51e23ac34db41d4b5
+SHA512:
+  metadata.gz: d1d74f2d7167ec0eac702b3a57daae8e36da2f46b3877578abd5a33e9c7d1779a593ac2f812a704869356b55003c290d5e1592e2d1b1ac32e70a9a56ddce4689
+  data.tar.gz: c19b67e1c2908207e2cd447e38d7943225b804acfb0698c28cf4d31f55f0e197583435964be4c13b737994ab8768fc4e9f3d8430af8e1cbc5fdf656804922462

data/.yardopts

@@ -0,0 +1 @@
+--no-private --markup=markdown - *.md LICENSE

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 William Woodruff <william @ yossarian.net>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

data/README.md

@@ -0,0 +1,85 @@
+bindef
+========
+
+`bindef` is a DSL and command-line tool for building binary files.
+
+It's inspired by [t2b](https://github.com/thosakwe/t2b), but with a few crucial differences:
+
+* `bindef` scripts run within a Ruby process, making the DSL a strict superset of Ruby
+* Support for different (and multiple!) endians, string encodings, etc, is baked into the language
+* Reports common mistakes loudly as warnings (or errors, if severe enough)
+* Comes with a collection of user-selectable extensions for common binary formats (TLVs, control
+codes, etc.)
+
+## Syntax
+
+`bindef`'s syntax is stream-oriented, with two primary expressions: commands and pragmas.
+
+Commands cause `bindef` to emit data, while pragmas influence *how* commands act.
+
+Here's a simple `bindef` script that emits a unsigned 32-bit integer twice, in different endians:
+
+```ruby
+# `bindef` starts in little-endian, so this is redundant
+pragma endian: :little
+
+u32 0xFF000000
+
+# or `pragma :endian => :big`, if you prefer
+pragma endian: :big
+
+u32 0xFF000000
+```
+
+The [examples directory](examples/) has more. Read the [SYNTAX](SYNTAX.md) file for a
+complete listing of commands and pragmas.
+
+## Installation
+
+`bindef` is available via RubyGems:
+
+```bash
+$ gem install bindef
+$ bd -h
+```
+
+You can also run it directly from this repository:
+
+```bash
+$ ruby -Ilib ./bin/bd -h
+```
+
+## Usage
+
+In general, running a `bindef` script is as simple as:
+
+```bash
+$ bd < path/to/input.bd > path/to/output.bin
+```
+
+or:
+
+```bash
+$ bd -i path/to/input.bd -o /path/to/output.bin
+```
+
+You can also choose to enable one or more *extra* command sets via the `-e`, `--extra` flag:
+
+```bash
+# extra commands for building TLVs
+$ bd -e tlv < input.bd > output.bin
+
+# extra commands for ASCII control codes and string manipulation
+$ bd -e ctrl,string < input.bd > output.bin
+```
+
+## Design goals
+
+`bindef` should...
+
+* ...have no runtime dependencies other than the current stable Ruby
+* ...be easy to read, even without knowledge of Ruby's syntax
+* ...be easy to write, even without knowledge of Ruby's syntax
+* ...be easy for other programs to emit without being (too) aware of Ruby's syntax
+* ...be easy to debug, with warnings and errors for common mistakes (overflows, negative
+unsigned integers, etc.)

data/SYNTAX.md

@@ -0,0 +1,130 @@
+`bindef` syntax
+===============
+
+As mentioned in the [README](README.md), `bindef` has two primary expressions: *commands* and
+*pragmas*.
+
+This page documents the default commands and all pragmas.
+
+## Commands
+
+`bindef` has commands for emitting integers, floating-point numbers, and strings.
+
+All commands take a *value*. That value can be literal or a Ruby expression.
+
+### Integers
+
+The integer commands map directly to their `stdint.h` types: a `u8` is a `uint8_t`,
+an `i64` is an `int64_t`, and so on.
+
+```ruby
+# Emits a uint8_t with the value 127.
+u8 127
+
+# Emits a int32_t with the value 0.
+i32 0
+
+# Produces a warning (negative value used with unsigned command), but still works.
+u16 -100
+
+# Produces an error (value too large for command).
+i16 (2**32) - 1
+```
+
+### Floating-point numbers
+
+There are two floating-point commands: `f32` for single-precision, and `f64` for double-precision.
+
+```ruby
+# Transparent promotion of an integer to a float.
+f32 0
+
+# Ruby floating-point constants work..
+f64 Math::PI
+f64 Float::INFINITY
+```
+
+### Strings
+
+There is only one string command: `str`. `str` does *not* add a terminating NUL, a newline, or
+anything else to the specified string.
+
+```ruby
+str "hello world!"
+
+# Add a terminating NUL.
+str "look ma, a C-string!\x00"
+
+# Ruby's string interpolation works.
+foo = "bar baz quux"
+str "#{foo}!\n"
+```
+
+## Pragmas
+
+Pragmas tell `bindef` *how* to emit commands. They tell commands what endianness they should
+use, what encoding strings are in, and how loud to be about warnings and informational messages.
+
+Pragmas are global settings, meaning that setting one will cause it to remain set until explicitly
+changed to another value. This can be tedious to keep track of (and makes it easy to introduce
+transposition bugs), so the `pragma` expression provides a block form:
+
+```ruby
+# Changes the verbosity setting to true, but only for the duration of the block.
+pragma verbose: true do
+  str "foo"
+end
+```
+
+### `verbose`
+
+Default: `false`.
+
+Tells `bindef` how verbose to be. Verbose messages are prefixed with `V: ` and are logged to
+`stderr`.
+
+### `warnings`
+
+Default: `true`.
+
+Tells `bindef` whether or not to emit warnings, which are nonfatal (unlike errors). Warning
+messages are prefixed with `W: ` and are logged to `stderr`.
+
+```ruby
+# Or use the block form above.
+pragma warnings: false
+u8 -127
+pragma warnings: true
+```
+
+### `endian`
+
+Default: `:little`.
+
+Tells `bindef` which endianness to use when emitting integers and floats.
+
+```ruby
+pragma endian: :big
+u16 0x00FF
+u16 0xFF00
+```
+
+### `encoding`
+
+Default: `"utf-8"`
+
+Tells `bindef` how to encode the strings it emits via `str`.
+
+```ruby
+pragma encoding: "ascii"
+str "this is a plain old ASCII string"
+
+pragma encoding: "utf-8"
+str "this👏is👏a👏utf-8👏string"
+
+pragma encoding: "utf-32"
+str "this is a waste of space"
+```
+
+`encoding` expects a lowercase string, and can take any of the
+[encodings supported by Ruby](https://ruby-doc.org/core/Encoding.html#method-c-name_list).

data/bin/bd

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+
+require "bindef"
+
+options = {
+  input: STDIN,
+  output: STDOUT,
+  error: STDERR,
+  verbose: false,
+  warnings: true,
+}
+
+at_exit do
+  %i[input output error].each { |io| options[io].close }
+end
+
+OptionParser.new do |parser|
+  parser.banner = "Usage: bd [options]"
+
+  parser.on "-i", "--input FILE", String, "Read input from FILE (default: stdin)" do |input|
+    abort("Error: No such file: #{input}") unless File.file?(input)
+    options[:input] = File.open(input, "r")
+  end
+
+  parser.on "-o", "--output FILE", String, "Write output to FILE (default: stderr)" do |output|
+    abort("Error: #{output} exists, not overwriting") if File.file?(output)
+    options[:output] = File.open(output, "wb")
+  end
+
+  parser.on "-v", "--verbose", "Write verbose/debugging information to stderr" do
+    options[:verbose] = true
+  end
+
+  parser.on "-W", "--no-warnings", "Suppress warning messages" do
+    options[:warnings] = false
+  end
+
+  parser.on "-e", "--extra ext1,ext2,ext3", Array, "Extra command set(s) to load" do |extras|
+    extras.each { |e| require "bindef/extras/#{e}" }
+  end
+end.parse!
+
+bindef = Bindef.new(options[:output],
+                    options[:error],
+                    verbose: options[:verbose],
+                    warnings: options[:warnings])
+
+options[:error].puts "W: output looks like a tty" if options[:output].tty? && options[:verbose]
+
+begin
+  bindef.instance_eval options[:input].read, "input", 1
+rescue Bindef::EvaluationError => e
+  options[:error].puts "E: #{e.message}"
+  # Pop the main and instance_eval scopes off of the backtrace.
+  e.backtrace.pop 2
+  raise e
+end

data/lib/bindef.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require_relative "bindef/version"
+require_relative "bindef/schemas"
+require_relative "bindef/exceptions"
+
+# The primary namespace for {Bindef}.
+class Bindef
+  include Bindef::Schemas
+
+  # @return [Hash] the map of current pragma settings
+  attr_reader :pragmas
+
+  # @api private
+  def initialize(output = STDOUT, error = STDERR, verbose: false, warnings: true)
+    @output = output
+    @error = error
+    @pragmas = DEFAULT_PRAGMAS.dup.update(verbose: verbose, warnings: warnings)
+  end
+
+  # Writes a message to the error I/O if verbose mode is enabled.
+  # @note Uses the `:verbose` {#pragma}
+  # @param msg [String] the message to write
+  # @return [void]
+  # @api private
+  def verbose(msg)
+    @error.puts "V: #{msg}" if @pragmas[:verbose]
+  end
+
+  # Writes a warning message to the error I/O.
+  # @param msg [String] the warning message to write
+  # @return [void]
+  # @api private
+  def warning(msg)
+    @error.puts "W: #{msg}" if @pragmas[:warnings]
+  end
+
+  # Ensures that the given integer number can be represented within the given width of bits.
+  # @param num [Integer] the number to test
+  # @param width [Integer] the bit width to test against
+  # @return [void]
+  # @raise [CommandError] if the number is wider than `width` bits
+  # @api private
+  def validate_int_width!(num, width)
+    raise CommandError, "width of #{num} exceeds #{width} bits" if num.bit_length > width
+  end
+
+  # Builds a string containing the given value packed into the given format.
+  # @param value [Object] the value to emit
+  # @param fmt [String] the `Array#pack` format to emit it in
+  def blobify(value, fmt)
+    [value].pack(fmt)
+  end
+
+  # Emits the given blob of data.
+  # @param blob [String] the data to emit
+  # @return [void]
+  # @api private
+  def emit(blob)
+    @output << blob
+  end
+
+  # Captures unknown commands and raises an appropriate error.
+  # @api private
+  def method_missing(*args)
+    raise CommandError, "unknown command: #{args.join(" ")}"
+  end
+
+  # Changes the values of the given pragma keys.
+  # @see PRAGMA_SCHEMA
+  # @param hsh [Hash] the keys and values to update the pragma state with
+  # @yield [void] A temporary scope for the pragma changes, if a block is given
+  # @return [void]
+  # @example
+  #  pragma verbose: true # changes the `:verbose` pragma to `true` for the remainder of the script
+  #  pragma encoding: "utf-16" { str "foobar" } # changes the `:encoding` pragma for the block only
+  def pragma(**hsh)
+    old_pragmas = pragmas.dup
+
+    hsh.each do |key, value|
+      raise PragmaError, "unknown pragma: #{key}" unless @pragmas.key? key
+      raise PragmaError, "bad pragma value: #{value}" unless PRAGMA_SCHEMA[key].include?(value)
+
+      pragmas[key] = value
+    end
+
+    if block_given?
+      yield
+      pragmas.replace old_pragmas
+    end
+  end
+
+  # Emits a string.
+  # @note Uses the `:encoding` {#pragma}
+  # @param string [String] the string to emit
+  # @return [void]
+  def str(string)
+    enc_string = string.encode pragmas[:encoding]
+    blob = blobify enc_string, "a#{enc_string.bytesize}"
+
+    yield blob if block_given?
+
+    emit blob
+  end
+
+  # Emits a `float`.
+  # @param num [Numeric] the number to emit
+  # @return [void]
+  def f32(num)
+    # NOTE: All floats are double-precision in Ruby, so I don't have a good
+    # (read: simple) way to validate single-precision floats yet.
+
+    fmt = pragmas[:endian] == :big ? "g" : "e"
+    blob = blobify num, fmt
+
+    yield blob if block_given?
+
+    emit blob
+  end
+
+  # Emits a `double`.
+  # @param num [Numeric] the number to emit
+  # @return [void]
+  def f64(num)
+    raise CommandError, "#{num} is an invalid double-precision float" if num.to_f.nan?
+
+    fmt = pragmas[:endian] == :big ? "G" : "E"
+
+    blob = blobify num, fmt
+
+    yield blob if block_given?
+
+    emit blob
+  end
+
+  # Emits a `uint8_t`.
+  # @param num [Integer] the number to emit
+  # @return [void]
+  def u8(num)
+    warning "#{num} in u8 command is negative" if num.negative?
+    validate_int_width! num, 8
+
+    blob = blobify num, "C"
+
+    yield blob if block_given?
+
+    emit blob
+  end
+
+  # Emits a `int8_t`.
+  # @param num [Integer] the number to emit
+  # @return [void]
+  def i8(num)
+    validate_int_width! num, 8
+
+    blob = blobify num, "c"
+
+    yield blob if block_given?
+
+    emit blob
+  end
+
+  # @!method u16(num)
+  #   Emits a `uint16_t`.
+  #   @note Uses the `:endian` {#pragma}
+  #   @param num [Integer] the number to emit
+  #   @return [void]
+  # @!method u32(num)
+  #   Emits a `uint32_t`.
+  #   @note Uses the `:endian` {#pragma}
+  #   @param num [Integer] the number to emit
+  #   @return [void]
+  # @!method u64(num)
+  #   Emits a `uint64_t`.
+  #   @note Uses the `:endian` {#pragma}
+  #   @param num [Integer] the number to emit
+  #   @return [void]
+  # @!method i16(num)
+  #   Emits a `int16_t`.
+  #   @note Uses the `:endian` {#pragma}
+  #   @param num [Integer] the number to emit
+  #   @return [void]
+  # @!method i32(num)
+  #   Emits a `int32_t`.
+  #   @note Uses the `:endian` {#pragma}
+  #   @param num [Integer] the number to emit
+  #   @return [void]
+  # @!method i64(num)
+  #   Emits a `int64_t`.
+  #   @note Uses the `:endian` {#pragma}
+  #   @param num [Integer] the number to emit
+  #   @return [void]
+  ENDIANDED_INTEGER_COMMAND_MAP.each do |cmd, fmt|
+    define_method cmd do |num, &block|
+      warning "#{num} in #{cmd} command is negative" if num.negative? && cmd[0] == "u"
+      validate_int_width! num, cmd[1..-1].to_i
+
+      end_fmt = pragmas[:endian] == :big ? "#{fmt}>" : "#{fmt}<"
+
+      blob = blobify num, end_fmt
+
+      # Fun fact: You can't use `yield` in `define_method`.
+      block&.call(blob)
+
+      emit blob
+    end
+  end
+end

data/lib/bindef/exceptions.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Bindef
+  # The base exception for all {Bindef} errors.
+  class BindefError < RuntimeError
+  end
+
+  # Raised during an error in evaluation.
+  class EvaluationError < BindefError
+  end
+
+  # Raised during an error in pragma evaluation.
+  class PragmaError < EvaluationError
+  end
+
+  # Raised during an error in command evaluation.
+  class CommandError < EvaluationError
+  end
+end

data/lib/bindef/extras.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "extras/string"
+require_relative "extras/int128"
+require_relative "extras/tlv"
+require_relative "extras/ctrl"
+
+class Bindef
+  # Extra (optional) commands.
+  module Extras
+  end
+end

data/lib/bindef/extras/ctrl.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Bindef
+  module Extras
+    # Helpers for {Extras::Ctrl}.
+    module CtrlHelper
+      # A sequential list of symbolic names for control codes.
+      # @api private
+      CONTROL_NAMES = %i[
+        nul soh stx etx eot enq ack bel bs ht lf vt ff cr so si dle dc1 dc2 dc3 dc4 nak syn etb
+        can em sub esc fs gs rs us
+      ].freeze
+
+      # A mapping of symbolic names for control codes to their numeric values.
+      # @api private
+      CONTROL_MAP = CONTROL_NAMES.zip(0x00..0x1F).to_h.freeze
+    end
+
+    # Potentially useful control character commands.
+    module Ctrl
+      CtrlHelper::CONTROL_MAP.each do |cmd, value|
+        define_method cmd do
+          u8 value
+        end
+      end
+    end
+  end
+
+  include Extras::Ctrl
+end

data/lib/bindef/extras/int128.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class Bindef
+  module Extras
+    # Potentially useful 128-bit integer emission commands.
+    module Int128
+      # Emits a `__uint128_t`.
+      # @note Uses the `:endian` {Bindef#pragma}
+      # @param num [Integer] the number to emit
+      # @return [void]
+      def u128(num)
+        upper = num >> 64
+        lower = num & (2**64 - 1)
+
+        if pragmas[:endian] == big
+          u64 upper
+          u64 lower
+        else
+          u64 lower
+          u64 upper
+        end
+      end
+
+      # Emits a `__int128_t`.
+      # @note Uses the `:endian` {Bindef#pragma}
+      # @param num [Integer] the number to emit
+      # @return [void]
+      def i128(num)
+        upper = num >> 64
+        lower = num & (2**64 - 1)
+
+        if pragmas[:endian] == big
+          i64 upper
+          u64 lower
+        else
+          u64 lower
+          i64 upper
+        end
+      end
+    end
+  end
+
+  include Extras::Int128
+end

data/lib/bindef/extras/string.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class Bindef
+  module Extras
+    # Potentially useful extra string emission commands.
+    module String
+      # Emits a null-terminated string.
+      # @note Like {Bindef#str}, uses the `:encoding` {Bindef#pragma}
+      # @param string [String] the string to emit
+      # @return [void]
+      # @example
+      #  strz "foobar" # Emits "foobar\x00"
+      def strz(string)
+        str string
+        str "\0"
+      end
+
+      # Emits a string, NUL-padded up to the given length in bytes.
+      # @note Like {Bindef#str}, uses the `:encoding` {Bindef#pragma}
+      # @param string [String] the string to emit
+      # @param maxpad [Integer] the maximum number of padding NULs
+      # @return [void]
+      # @example
+      #  strnz "foo", 5 # Emits "foo\x00\x00"
+      def strnz(string, maxpad)
+        pad = maxpad
+
+        str string do |enc_string|
+          pad = maxpad - enc_string.bytesize
+        end
+
+        raise CommandError, "maxpad < encoded string len" if pad.negative?
+
+        # Reset our encoding temporarily, to make sure we emit the right number of NULs.
+        pragma encoding: "utf-8" do
+          str("\x00" * pad)
+        end
+      end
+
+      # Emits a length-prefixed string.
+      # @note Like {Bindef#str}, uses the `:encoding` {Bindef#pragma}
+      # @note Like {Bindef#u16} and wider, the `:endian` {Bindef#pragma}
+      # @param int_fmt [Symbol] the width of the length prefix, as one of the integer commands
+      # @param string [String] the string to emit
+      # @return [void]
+      # @example
+      #  lstr :u8, "foo" # Emits "\x03foo"
+      def lstr(int_fmt, string)
+        str string do |enc_string|
+          send int_fmt, enc_string.bytesize
+        end
+      end
+    end
+  end
+
+  include Extras::String
+end

data/lib/bindef/extras/tlv.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class Bindef
+  module Extras
+    # Potentially useful TLV (tag-length-value) commands.
+    #
+    # Writing a single sufficiently generic TLV command without
+    # really abusing Ruby's syntax is hard. Instead, we provide
+    # specialized commands for empirically common TLV widths.
+    module TLV
+      # Emit a `uint8_t` type, a `uint8_t` length, and a value.
+      # @param type [Integer] the type number
+      # @param hsh [Hash] a mapping of `command => value`
+      # @example
+      #  tlv_u8 1, u32: 0xFF00FF00 # Emits: "\x01\x04\xFF\x00\xFF\x00"
+      #  tlv_u8 2, str: "hello" # Emits: "\x02\x05hello"
+      def tlv_u8(type, hsh)
+        u8 type
+
+        cmd, value = hsh.shift
+
+        send cmd, value do |blob|
+          u8 blob.bytesize
+        end
+      end
+
+      # Emit a `uint16_t` type, a `uint16_t` length, and a value.
+      # @param type [Integer] the type number
+      # @param hsh [Hash] a mapping of `command => value`
+      # @see tlv_u8
+      def tlv_u16(type, hsh)
+        u16 type
+
+        cmd, value = hsh.shift
+
+        send cmd, value do |blob|
+          u16 blob.bytesize
+        end
+      end
+
+      # Emit a `uint32_t` type, a `uint32_t` length, and a value.
+      # @param type [Integer] the type number
+      # @param hsh [Hash] a mapping of `command => value`
+      # @see tlv_u8
+      def tlv_u32(type, hsh)
+        u32 type
+
+        cmd, value = hsh.shift
+
+        send cmd, value do |blob|
+          u32 blob.bytesize
+        end
+      end
+    end
+  end
+
+  include Extras::TLV
+end

data/lib/bindef/schemas.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Bindef
+  # Schemas used to validate commands and pragmas throughout {Bindef}.
+  module Schemas
+    # A mapping of valid pragma keys to lists of valid pragma values.
+    PRAGMA_SCHEMA = {
+      verbose: [true, false],
+      warnings: [true, false],
+      endian: %i[big little],
+      encoding: Encoding.name_list.map(&:downcase),
+    }.freeze
+
+    # The default pragma settings.
+    DEFAULT_PRAGMAS = {
+      verbose: false,
+      warnings: true,
+      endian: :little,
+      encoding: "utf-8",
+    }.freeze
+
+    # A map of endianded integer commands to `Array#pack` formats.
+    # @api private
+    ENDIANDED_INTEGER_COMMAND_MAP = {
+      u16: "S",
+      u32: "L",
+      u64: "Q",
+      i16: "s",
+      i32: "l",
+      i64: "q",
+    }.freeze
+  end
+end

data/lib/bindef/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Bindef
+  # The current {Bindef} version.
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: bindef
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- William Woodruff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-08-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.9
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.9
+description: 
+email: william@yossarian.net.com
+executables:
+- bd
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- LICENSE
+- README.md
+- SYNTAX.md
+- bin/bd
+- lib/bindef.rb
+- lib/bindef/exceptions.rb
+- lib/bindef/extras.rb
+- lib/bindef/extras/ctrl.rb
+- lib/bindef/extras/int128.rb
+- lib/bindef/extras/string.rb
+- lib/bindef/extras/tlv.rb
+- lib/bindef/schemas.rb
+- lib/bindef/version.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: bindef - A DSL and command-line tool for generating binary files
+test_files: []