hdl 1.0.0

data/README.md

@@ -0,0 +1,127 @@
+## HDL
+
+A parser and emulator for a minimalist [hardware description language](http://en.wikipedia.org/wiki/Hardware_description_language).
+
+## Chips
+
+Here's an example definition of a chip called 'and.hdl':
+
+```ruby
+# and.hdl
+inputs  a, b
+outputs out
+
+nand(a=a, b=b, out=x)
+nand(a=x, b=x, out=out)
+```
+
+The equivalent circuit diagram is:
+
+!['and' gate from 'nand'](http://upload.wikimedia.org/wikipedia/commons/1/16/AND_from_NAND.svg)
+
+## Tables
+
+The above chip references another chip called 'nand'.
+
+Here's its definition, as a truth table:
+
+```ruby
+# nand.hdl
+inputs  a, b
+outputs out
+
+| a | b | out |
+| 0 | 0 |  1  |
+| 0 | 1 |  1  |
+| 1 | 0 |  1  |
+| 1 | 1 |  0  |
+```
+
+If you'd prefer, you can use 'T' and 'F'.
+
+## Ruby
+
+Now that we've satisfied the 'nand' dependency, we can write some Ruby:
+
+```ruby
+require "hdl"
+
+chip = HDL.load("and")
+chip.evaluate(a: true, b: false)
+#=> { out: false }
+```
+
+The 'nand' chip is automatically loaded when it is referenced.
+
+## Path
+
+By default, chips in the current directory will be discovered.
+
+You can expand this search by adding to your path:
+
+```ruby
+HDL.path << "chips"
+```
+
+## Parsing
+
+If you'd rather parse your chips directly in Ruby, you can do so with:
+
+```ruby
+chip = HDL.parse(name, definition)
+```
+
+This might be useful if you're storing definitions in a database.
+
+## Miscellaneous
+
+Here are some useful methods for querying properties of chips:
+
+```ruby
+chip.name
+#=> "and"
+
+chip.path
+#=> "./and.hdl"
+
+chip.inputs
+#=> [:a, :b]
+
+chip.outputs
+#=> [:out]
+
+chip.internal
+#=> [:x]
+
+chip.components
+#=> { #<HDL::Chip nand> => 2 }
+
+chip.primitive? # Does this chip contain a truth table?
+#=> false
+
+chip.primitives
+#=> [#<HDL::Chip nand>]
+
+chip.dependents # Chips that this chip uses.
+#=> [#<HDL::Chip nand>]
+
+chip.dependees # Chips that use this chip.
+#=> []
+```
+
+## Contribution
+
+I'm not an electronics engineer. If you are, you could probably build in all kinds of cool features and optimisations.
+
+Here a few features that might be in the pipeline:
+
+* Let me build a CNF expression for a chip
+* Query method for circuit fan-outs for chips
+* Evaluate and return outputs with internal pins
+* Support for buses, mostly for convenience
+* Pushing stricter validations to parse time
+* Cleaner decoupling between the parser and evaluator
+
+If you'd like to build any of these features, I'd be super grateful. Send me a pull request, or open an issue.
+
+You should follow me on [twitter](http://twitter.com/cpatuzzo).

data/lib/hdl/base.rb

@@ -0,0 +1,24 @@
+module HDL
+  class << self
+
+    def version
+      "1.0.0"
+    end
+
+    def path
+      Loader.path
+    end
+
+    def load(name)
+      Loader.load(name, :force => true)
+    end
+
+    def parse(name, definition)
+      Loader.load(name,
+        :force => true,
+        :definition => definition
+      )
+    end
+
+  end
+end

data/lib/hdl/chip/schema_chip/evaluator.rb

@@ -0,0 +1,141 @@
+class HDL::SchemaChip::Evaluator
+
+  def initialize(chip, schema)
+    @chip   = chip
+    @schema = schema
+    @parts  = partition_io
+    @order  = evaluation_order(@parts, chip.inputs)
+
+    check_multi_internal!
+  end
+
+  def evaluate(pins)
+    results = @order.inject(pins) do |known_pins, i|
+      known_pins.merge(evaluate_line(@parts[i], known_pins))
+    end
+
+    filter_outputs(results)
+  end
+
+  private
+  def evaluate_line(line, pins)
+    chip, inputs, outputs = line
+
+    chip_in  = connect_inputs(inputs, pins)
+    chip_out = chip.evaluate(chip_in)
+
+    connect_outputs(outputs, chip_out)
+  end
+
+  def connect_inputs(inputs, pins)
+    is_bool = lambda { |x| [true, false].include?(x) }
+
+    inputs.inject({}) do |hash, (dest, source)|
+      value = is_bool[source] ? source : pins[source]
+      hash.merge(dest => value)
+    end
+  end
+
+  def connect_outputs(outputs, pins)
+    outputs.inject({}) do |hash, (dest, source)|
+      hash.merge(source => pins[dest])
+    end
+  end
+
+  def filter_outputs(pins)
+    f = pins.select { |k, _| @chip.outputs.include?(k) }
+    Hash[f]
+  end
+
+  def evaluation_order(schema_lines, known_pins, first_call = true)
+    schema_lines = schema_lines.each_with_index if first_call
+
+    known, unknown = schema_lines.partition do |line, _|
+      all_inputs_known?(line, known_pins)
+    end
+
+    known_outputs = known.map do |line, _|
+      outputs_for_line(line)
+    end.flatten
+
+    check_for_new_information!(known_outputs, unknown)
+
+    if unknown.any?
+      # Recursive case.
+      next_pins = known_pins + known_outputs
+      tail = evaluation_order(unknown, next_pins, false)
+    else
+      # Base case.
+      tail = []
+    end
+
+    known_indexes = known.map(&:last)
+    known_indexes + tail
+  end
+
+  def all_inputs_known?(line, known_pins)
+    _, inputs, _ = line
+    inputs.values.all? do |pin|
+      (known_pins + [true, false]).include?(pin)
+    end
+  end
+
+  def partition_io
+    @schema.map do |line|
+      chip_name   = line.keys.first
+      wiring      = line.values.first
+      dest_pins   = wiring.keys
+      source_pins = wiring.values
+      chip        = fetch_chip(chip_name)
+
+      inputs, outputs = wiring.partition do |dest, source|
+        chip.inputs.include?(dest)
+      end
+
+      [chip, Hash[inputs], Hash[outputs]]
+    end
+  end
+
+  def outputs_for_line(line)
+    line.last.values
+  end
+
+  def check_for_new_information!(information, unknown)
+    if information.empty?
+      p = unknown.map do |(chip, _, _), exp|
+        { (exp + 1) => chip.name }.inspect
+      end.join(", ")
+
+      if unknown.size == 1
+        err = "Unknown internal pin for expression: #{p}"
+      else
+        err = "Unknowable internal pins for expressions: #{p}"
+      end
+
+      raise CircularError, err
+    end
+  end
+
+  # We can't check this at parse time because we
+  # don't know which are getters/setters.
+  def check_multi_internal!
+    set_pins = @parts.map do |_, _, outputs|
+      outputs.values
+    end.flatten
+
+    repetitions = set_pins.select { |p| set_pins.count(p) > 1 }.uniq
+    if repetitions.size == 1
+      err = "The internal pin `#{repetitions.first}' is set multiple times"
+      raise ParseError, err
+    elsif repetitions.size > 1
+      list = repetitions.join(', ')
+      err = "These internal pins are set multiple times: #{list}"
+      raise ParseError, err
+    end
+  end
+
+  def fetch_chip(name)
+    HDL::Loader.load(name)
+  end
+
+end

data/lib/hdl/chip/schema_chip.rb

@@ -0,0 +1,74 @@
+class HDL::SchemaChip < HDL::Chip
+
+  def initialize(name, path, data)
+    super
+    @schema = data[:schema]
+    create_dependencies
+    load_dependencies(:dependents)
+    evaluate_some_expression
+  end
+
+  def internal
+    wiring_values - inputs - outputs - [true, false]
+  end
+
+  def components
+    chips = component_names.map do |name|
+      HDL::Loader.load(name)
+    end
+
+    freq = frequencies(chips)
+    hashes = [freq] + chips.map(&:components)
+
+    hashes.inject({}) do |acc, hash|
+      acc.merge(hash) { |_, a, b| a + b }
+    end
+  end
+
+  def primitive?
+    false
+  end
+
+  def evaluate(pins = {})
+    check_pins!(pins)
+    evaluator.evaluate(pins)
+  end
+
+  private
+  def create_dependencies
+    component_names.each do |dep|
+      HDL::Dependency.create(name, dep.to_s)
+    end
+  end
+
+  def component_names
+    @schema.map(&:keys).flatten
+  end
+
+  def wiring
+    @schema.map(&:values).flatten
+  end
+
+  def wiring_values
+    wiring.map(&:values).flatten.uniq
+  end
+
+  def evaluator
+    @evaluator ||= Evaluator.new(self, @schema)
+  end
+
+  def frequencies(array)
+    array.inject(Hash.new(0)) do |hash, element|
+      hash[element] += 1
+      hash
+    end
+  end
+
+  # Check upfront if there are circular problems
+  # by evaluating something on the chip.
+  def evaluate_some_expression
+    pins = Hash[inputs.zip(inputs.map { true })]
+    evaluate(pins)
+  end
+
+end

data/lib/hdl/chip/table_chip.rb

@@ -0,0 +1,39 @@
+class HDL::TableChip < HDL::Chip
+
+  def initialize(name, path, data)
+    super
+    @table = data[:table]
+  end
+
+  def internal
+    []
+  end
+
+  def components
+    {}
+  end
+
+  def primitive?
+    true
+  end
+
+  def evaluate(pins = {})
+    check_pins!(pins)
+
+    row = find_row(pins)
+    select_outputs(row)
+  end
+
+  private
+  def find_row(pins)
+    @table.detect do |row|
+      inputs.all? { |i| row[i] == pins[i] }
+    end
+  end
+
+  def select_outputs(row)
+    filtered = row.select { |p, _| outputs.include?(p) }
+    Hash[filtered]
+  end
+
+end

data/lib/hdl/chip.rb

@@ -0,0 +1,41 @@
+class HDL::Chip
+
+  attr_reader :name, :path, :inputs, :outputs
+
+  def initialize(name, path, data)
+    @name    = name.to_s
+    @path    = path
+    @inputs  = data[:inputs]
+    @outputs = data[:outputs]
+  end
+
+  def inspect
+    "#<HDL::Chip #{name}>"
+  end
+
+  def primitives
+    dependents.select { |d| d.primitive? }
+  end
+
+  def dependents
+    load_dependencies(:dependents)
+  end
+
+  def dependees
+    load_dependencies(:dependees)
+  end
+
+  private
+  def load_dependencies(type)
+    deps = HDL::Dependency.send("#{type}_for", name)
+    deps.map { |d| HDL::Loader.load(d) }
+  end
+
+  def check_pins!(pins)
+    unless pins.keys.to_set == inputs.to_set
+      err = "Expecting inputs #{inputs.inspect}, given #{pins.keys.inspect}"
+      raise ArgumentError, err
+    end
+  end
+
+end

data/lib/hdl/dependency.rb

@@ -0,0 +1,70 @@
+class HDL::Dependency
+  class << self
+
+    # dependee depends on dependent
+
+    def create(dependee, dependent)
+      check_for_cycles!(dependee, dependent)
+      set << { dependee => dependent }
+    end
+
+    def all
+      set
+    end
+
+    def where(filter = {})
+      scope = all
+
+      if (f = filter[:dependee])
+        scope = scope.select { |h| h.keys.first == f }
+      end
+
+      if (f = filter[:dependent])
+        scope = scope.select { |h| h.values.first == f }
+      end
+
+
+      scope
+    end
+
+    # What does the dependee depend on?
+    def dependents_for(dependee)
+      recursive_ancestors_for(dependee, :dependee, :values)
+    end
+
+    # What depends on the dependent?
+    def dependees_for(dependent)
+      recursive_ancestors_for(dependent, :dependent, :keys)
+    end
+
+    private
+    def set
+      @dependencies ||= Set.new
+    end
+
+    def check_for_cycles!(dependee, dependent)
+      if dependee == dependent
+        err = "'#{dependee}` cannot depend on itself"
+      elsif dependees_for(dependee).include?(dependent)
+        err = "'#{dependee}` and '#{dependent}` depend on each other"
+      end
+
+      raise CircularError, err if err
+    end
+
+    def recursive_ancestors_for(object, type, side_of_hash)
+      hashes = where(type => object)
+      children = hashes.map(&side_of_hash).flatten
+
+      ancestors = children.to_set
+      children.each do |c|
+        ancestors += recursive_ancestors_for(
+          c, type, side_of_hash
+        )
+      end
+      ancestors.to_a
+    end
+
+    class ::CircularError < StandardError; end
+  end
+end

data/lib/hdl/loader.rb

@@ -0,0 +1,58 @@
+class HDL::Loader
+  class << self
+
+    def path
+      @path ||= ["."]
+    end
+    attr_writer :path
+
+    def load(name, options = {})
+      memoize(name, options[:force]) do
+        name = name.to_s
+
+        if (d = options[:definition])
+          raw = d
+          path = nil
+        else
+          file = file_from_path(name)
+          raw  = file.read
+          path = file.path
+        end
+
+        data = HDL::Parser.parse(raw)
+
+        if data[:table]
+          klass = HDL::TableChip
+        else
+          klass = HDL::SchemaChip
+        end
+
+        klass.new(name, path, data)
+      end
+    end
+
+    private
+    def memoize(key, override, &block)
+      @memo ||= {}
+
+      if @memo.has_key?(key) && !override
+        @memo[key]
+      else
+        @memo[key] = yield
+      end
+    end
+
+    def file_from_path(name)
+      path.each do |p|
+        q = File.join(p, name) + ".hdl"
+        return File.new(q) if File.exists?(q)
+      end
+
+      err = "Could not locate chip definition for `#{name}'"
+      raise FileNotFound, err
+    end
+
+    class ::FileNotFound < StandardError; end
+
+  end
+end

data/lib/hdl/parser/grammar/hdl.treetop

@@ -0,0 +1,17 @@
+grammar HDL
+  include Pins
+  include Schema
+  include Table
+
+  rule hdl
+    ws? pins ws body:(schema / table) ws? {
+      def structured
+        {
+          :inputs => pins.input_array,
+          :outputs => pins.output_array,
+          body.key => body.to_array
+        }
+      end
+    }
+  end
+end

data/lib/hdl/parser/grammar/pins.treetop

@@ -0,0 +1,23 @@
+grammar Pins
+  include Vars
+
+  rule pins
+    inputs ws outputs {
+      def input_array
+        inputs.vars.to_array
+      end
+
+      def output_array
+        outputs.vars.to_array
+      end
+    }
+  end
+
+  rule inputs
+    "inputs" ws vars
+  end
+
+  rule outputs
+    "outputs" ws vars
+  end
+end

data/lib/hdl/parser/grammar/schema.treetop

@@ -0,0 +1,49 @@
+grammar Schema
+  include Vars
+
+  rule schema
+    (ws? chip)+ {
+      def to_array
+        names  = TreeWalker.walk(self, :name)
+        hashes = TreeWalker.walk(self, :to_hash)
+
+        names.zip(hashes).map { |n, h| { n => h } }
+      end
+
+      def key
+        :schema
+      end
+    }
+  end
+
+  rule chip
+    var "(" arguments ")" {
+      def name
+        var.to_sym
+      end
+    }
+  end
+
+  rule arguments
+    argument ("," arguments)* ws? {
+      def to_hash
+        lefts  = TreeWalker.walk(self, :left)
+        rights = TreeWalker.walk(self, :right)
+
+        Hash[lefts.zip(rights)]
+      end
+    }
+  end
+
+  rule argument
+    ws? l:var ws? "=" ws? r:(var / boolean) {
+      def left
+        l.to_sym
+      end
+
+      def right
+        r.respond_to?(:to_sym) ? r.to_sym : r.to_bool
+      end
+    }
+  end
+end

data/lib/hdl/parser/grammar/table.treetop

@@ -0,0 +1,42 @@
+grammar Table
+  include Vars
+
+  rule table
+    header rows:(ws? row)+ {
+      def to_array
+        headers = header.header_cells.to_array
+        data = TreeWalker.walk(rows, :to_array)
+
+        data.map { |d| Hash[headers.zip(d)] }
+      end
+
+      def key
+        :table
+      end
+    }
+  end
+
+  rule header
+    "|" header_cells "|"
+  end
+
+  rule row
+    "|" row_cells "|"
+  end
+
+  rule header_cells
+    ws? var ws? ("|" header_cells)* {
+      def to_array
+        TreeWalker.walk(self, :to_sym)
+      end
+    }
+  end
+
+  rule row_cells
+    ws? boolean ws? ("|" row_cells)* {
+      def to_array
+        TreeWalker.walk(self, :to_bool)
+      end
+    }
+  end
+end

data/lib/hdl/parser/grammar/vars.treetop

@@ -0,0 +1,33 @@
+grammar Vars
+  rule vars
+    var ("," ws? vars)* {
+      def to_array
+        TreeWalker.walk(self, :to_sym)
+      end
+    }
+  end
+
+  rule var
+    [a-z] [a-z0-9_]* {
+      def to_sym
+        text_value.to_sym
+      end
+    }
+  end
+
+  rule boolean
+    [01TF] {
+      def to_bool
+        ["1", "T"].include?(text_value)
+      end
+    }
+  end
+
+  rule ws
+    ([ \t\r\n] / comment)+
+  end
+
+  rule comment
+    "#" (!"\n" .)* "\n"
+  end
+end

data/lib/hdl/parser/tree_walker.rb

@@ -0,0 +1,13 @@
+class TreeWalker
+  def self.walk(element, method)
+    array = []
+
+    if element.respond_to?(method)
+      array << element.send(method)
+    elsif !element.terminal?
+      array += element.elements.map { |e| walk(e, method) }.flatten(1)
+    end
+
+    array
+  end
+end

data/lib/hdl/parser/validator/input_validator.rb

@@ -0,0 +1,13 @@
+class HDL::Parser::Validator::InputValidator < HDL::Parser::Validator
+
+  def validate!
+    intersection = @hash[:inputs] & @hash[:outputs]
+    if intersection.size == 1
+      raise "`#{intersection.first}' is both an input and an output"
+    elsif intersection.size > 1
+      pins = intersection.map { |p| "`#{p}'" }.join(", ")
+      raise "These pins are both inputs and outputs: #{pins}"
+    end
+  end
+
+end

data/lib/hdl/parser/validator/schema_validator.rb

@@ -0,0 +1,44 @@
+class HDL::Parser::Validator::SchemaValidator < HDL::Parser::Validator
+
+  def validate!
+    inputs!
+    outputs!
+  end
+
+  private
+  def inputs!
+    inputs = @hash[:inputs]
+    disconnected_inputs = inputs - connected_pins
+    disconnected_pins_error(disconnected_inputs, "input")
+  end
+
+  def outputs!
+    outputs = @hash[:outputs]
+    disconnected_outputs = outputs - connected_pins
+    disconnected_pins_error(disconnected_outputs, "output")
+
+    repetitions = outputs.select { |o| connected_pins.count(o) > 1 }
+    if repetitions.size == 1
+      raise "The output `#{repetitions.first}' is connected multiple times"
+    elsif repetitions.size > 1
+      list = repetitions.join(', ')
+      raise "These outputs are connected multiple times: #{list}"
+    end
+  end
+
+  def connected_pins
+    schema = @hash[:schema]
+    wiring = schema.map(&:values).flatten
+    wiring.map(&:values).flatten
+  end
+
+  def disconnected_pins_error(disconnected_pins, type)
+    if disconnected_pins.size == 1
+      raise "The #{type} `#{disconnected_pins.first}' is not connected"
+    elsif disconnected_pins.size > 1
+      list = disconnected_pins.join(", ")
+      raise "The following #{type}s are not connected: #{list}"
+    end
+  end
+
+end

data/lib/hdl/parser/validator/table_validator.rb

@@ -0,0 +1,42 @@
+class HDL::Parser::Validator::TableValidator < HDL::Parser::Validator
+
+  def validate!
+    headers!
+    combinations!
+  end
+
+  private
+  def headers!
+    external_pins = @hash[:inputs] + @hash[:outputs]
+    table_headers = @hash[:table].first.keys
+
+    unless external_pins.to_set == table_headers.to_set
+      raise "expecting table headers #{external_pins.join(",")}, got #{table_headers.join(",")}"
+    end
+  end
+
+  def combinations!
+    inputs = @hash[:inputs]
+
+    combi = @hash[:table].inject([]) do |acc, row|
+      only_inputs = row.select { |k, _| inputs.include?(k) }
+      acc + [Hash[only_inputs]]
+    end
+
+    repetitions = combi.select { |c| combi.count(c) > 1 }.uniq
+    if repetitions.size == 1
+      raise "The row for #{repetitions.first.inspect} appears multiple times"
+    elsif repetitions.size > 1
+      list = repetitions.map(&:inspect).join(', ')
+      raise "These rows appear multiple times: #{list}"
+    end
+
+    required_size = 2 ** inputs.size
+    given_size = combi.size
+    unless given_size == required_size
+      rows = given_size > 1 ? "rows were" : "row was"
+      raise "#{given_size} #{rows} given, but #{required_size} rows are required"
+    end
+  end
+
+end

data/lib/hdl/parser/validator.rb

@@ -0,0 +1,28 @@
+class HDL::Parser::Validator
+
+  def self.validate!(hash)
+    new(hash).validate!
+  end
+
+  def initialize(hash)
+    @hash = hash
+  end
+
+  def validate!
+    InputValidator.validate!(@hash)
+
+    if @hash[:schema]
+      validator = SchemaValidator
+    else
+      validator = TableValidator
+    end
+
+    validator.validate!(@hash)
+  end
+
+  private
+  def raise(string)
+    super(ParseError.new(string))
+  end
+
+end

data/lib/hdl/parser.rb

@@ -0,0 +1,17 @@
+class HDL::Parser
+  def self.parse(definition)
+    parser = HDLParser.new
+
+    ast = parser.parse(definition)
+    if ast.nil?
+      raise ParseError, parser.failure_reason
+    end
+
+    structured_data = ast.structured
+    Validator.validate!(structured_data)
+
+    structured_data
+  end
+
+  class ::ParseError < StandardError; end
+end

data/lib/hdl.rb

@@ -0,0 +1,21 @@
+require "set"
+require "polyglot"
+require "treetop"
+require "hdl/base"
+require "hdl/loader"
+require "hdl/dependency"
+require "hdl/chip"
+require "hdl/chip/schema_chip"
+require "hdl/chip/schema_chip/evaluator"
+require "hdl/chip/table_chip"
+require "hdl/parser"
+require "hdl/parser/validator"
+require "hdl/parser/validator/input_validator"
+require "hdl/parser/validator/schema_validator"
+require "hdl/parser/validator/table_validator"
+require "hdl/parser/tree_walker.rb"
+require "hdl/parser/grammar/vars"
+require "hdl/parser/grammar/pins"
+require "hdl/parser/grammar/table"
+require "hdl/parser/grammar/schema"
+require "hdl/parser/grammar/hdl"

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification 
+name: hdl
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Chris Patuzzo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-06-02 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: treetop
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: polyglot
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: A parser and emulator for a minimalist hardware description language.
+email: chris@patuzzo.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- lib/hdl.rb
+- lib/hdl/chip.rb
+- lib/hdl/chip/schema_chip/evaluator.rb
+- lib/hdl/chip/schema_chip.rb
+- lib/hdl/chip/table_chip.rb
+- lib/hdl/base.rb
+- lib/hdl/dependency.rb
+- lib/hdl/parser/validator.rb
+- lib/hdl/parser/tree_walker.rb
+- lib/hdl/parser/grammar/pins.treetop
+- lib/hdl/parser/grammar/hdl.treetop
+- lib/hdl/parser/grammar/schema.treetop
+- lib/hdl/parser/grammar/table.treetop
+- lib/hdl/parser/grammar/vars.treetop
+- lib/hdl/parser/validator/table_validator.rb
+- lib/hdl/parser/validator/input_validator.rb
+- lib/hdl/parser/validator/schema_validator.rb
+- lib/hdl/loader.rb
+- lib/hdl/parser.rb
+has_rdoc: true
+homepage: https://github.com/cpatuzzo/hdl
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: HDL
+test_files: []
+