bliftax 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 629ed1deeccb6405f838c9867ca6a1f83872c2d6
+  data.tar.gz: f6d15136e5044fbf828e0ebf143dc43b7c8247e5
+SHA512:
+  metadata.gz: 26642f82d331d02108f63e891805f80066addea67c88f726f5b21ef67a544feebc72b77ecdcff557dc9efe6ea2b270abb3de6f863b433ca8936200f4e7a97607
+  data.tar.gz: 7e93b46f18ec3a43880f9eb001726de378d8adfcc2cf0c5594510b7636f524ed4c8a92e71d6dc022f9d5a3bae3756a6436f464eb342f118c8fb34ab6e9b4897c

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.swp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.2
+before_install: gem install bundler -v 1.10.4

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in blif.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Naoki Mizuno
+
+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,82 @@
+# Bliftax
+
+This is a simple library that parses a
+[BLIF](https://www.ece.cmu.edu/~ee760/760docs/blif.pdf) file and does
+operations used in logic optimization algorithms described in Chapter 4.10.2
+in the book _Fundamentals of Digital Logic with Verilog Design_ by Stephen
+Brown and Zvonko Vranesic.
+
+As usual, thanks to the [Faker](https://github.com/stympy/faker) gem for
+partially naming this gem.
+
+## Installation
+
+    $ bundle install
+    $ rake install
+
+## Usage
+
+This gem currently only supports the following declarations for BLIF:
+
+```
+.model
+.inputs
+.outputs
+.names
+.latch
+.clock
+```
+
+Following is the list of main features of this gem:
+
+* star operators
+* sharp operators
+* coverage check (b is covered by a)
+* finding minterms that an implicant covers
+* finding the cost of an implicant
+
+Here is an example usage of this gem.
+
+```ruby
+require 'bliftax'
+
+model = Bliftax.new('path/to/blif_file')
+model.gates.each do |gate|
+  next if gate.implicants.size < 2
+
+  starred = gate[0] * gate[1]
+  sharped = gate[0].sharp(gate[1])
+end
+
+model.gates.each do |gate|
+  gate.implicants.combination(2).each do |a, b|
+    c = a * b
+    covered = c.covers?(a)
+  end
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then,
+run `rake rspec` 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 tags, 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/NigoroJr/bliftax.
+
+## License
+
+The gem is available as open source under the terms of the [MIT
+License](http://opensource.org/licenses/MIT).
+
+## Author
+Naoki Mizuno

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "bliftax"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bliftax.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bliftax/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bliftax"
+  spec.version       = Bliftax::VERSION
+  spec.authors       = ["Naoki Mizuno"]
+  spec.email         = ["nigorojr@gmail.com"]
+
+  spec.summary       = 'A library that parses BLIF files and do logic optimization'
+  spec.homepage      = 'https://github.com/NigoroJr/bliftax'
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

data/lib/bliftax/gate.rb

@@ -0,0 +1,70 @@
+require 'bliftax/implicant'
+
+class Bliftax
+  # Represents one logic gate in the BLIF file
+  class Gate
+
+    attr_reader :input_labels, :output_label
+    attr_accessor :implicants
+
+    # Initializes this gate with the labels for inputs and output.
+    #
+    # @param labels [Array] the label names for the inputs and output. The
+    #   last element in the Array is the output label.
+    def initialize(labels)
+      (*@input_labels, @output_label) = labels
+      @implicants = []
+    end
+
+    # Adds an Implicant to this gate.
+    #
+    # @param implicant [Implicant, String, Array<Implicant, String>] the
+    #   implicant to add. If a String is passed, it is considered to be a
+    #   two-token string with the first being the input bits and the second
+    #   being the output bit. For example, '010 1' represents the three inputs
+    #   being 0, 1, 0 and the output being 1 in this case. If an Array is
+    #   given, it will add all of the implicants.
+    def add_implicant(implicant)
+      case implicant
+      when Implicant
+        @implicants << implicant
+      when String
+        @implicants << Implicant.new(@input_labels, @output_label, implicant)
+      when Array
+        # Recursive call
+        implicant.each { |i| add(i) }
+      end
+    end
+    alias_method :<<, :add_implicant
+
+    # Returns the specified implicant.
+    #
+    # @param index [Integer] the index of the implicant.
+    #
+    # @return [Implicant] the specified implicant.
+    def [](index)
+      @implicants[index]
+    end
+
+    # Returns the size of the inputs.
+    #
+    # @return [Integer] the size of the inputs.
+    def input_size
+      @input_labels.size
+    end
+
+    # Returns a string representation of this gate in BLIF format.
+    #
+    # @return [String] this gate in BLIF format
+    def to_blif
+      str = format(".names %s %s\n",
+                   @input_labels.join(SPACE),
+                   @output_label)
+      @implicants.each do |implicant|
+        str += format("%s\n", implicant.to_blif)
+      end
+
+      str
+    end
+  end
+end

data/lib/bliftax/implicant/bit.rb

@@ -0,0 +1,54 @@
+class Bliftax
+  class Implicant
+    # A class that represents one bit of an implicant
+    class Bit
+      ON = '1'
+      OFF = '0'
+      # Don't care
+      DC = '-'
+      EPSILON = 'E'
+      NULL = 'N'
+
+      attr_accessor :label, :bit, :type
+
+      INPUT = :input
+      OUTPUT = :output
+
+      # Creates a new Bit instance.
+      #
+      # @param label [String] the label corresponding to this bit.
+      # @param bit [String] the bit (can be 1, 0, -, E, or N).
+      # @param type [Symbol] the type of this bit (input or output).
+      def initialize(label, bit, type)
+        fail 'Label has to be a String' unless label.is_a?(String)
+        fail 'Bit has to be a String' unless bit.is_a?(String)
+
+        @label = label
+        @bit = bit
+        @type = type
+      end
+
+      # Checks for equality.
+      #
+      # @param other [Object] whatever to compare against
+      def ==(other)
+        @bit == other.bit && @type == other.type
+      end
+      alias_method :eql?, :==
+
+      # Returns the hash value of this instance.
+      #
+      # @return [Integer] the hash value of this instance.
+      def hash
+        [@bit, @type].hash
+      end
+
+      # Return the string version of this bit.
+      #
+      # @return [String] string representation of this bit.
+      def to_s
+        format '%-6s %-8s %s', @type.to_s.upcase, @label, @bit
+      end
+    end
+  end
+end

data/lib/bliftax/implicant.rb

@@ -0,0 +1,344 @@
+require 'set'
+require 'bliftax/implicant/bit'
+
+class Bliftax
+  # A class that represents an implicant of a gate.
+  class Implicant
+    # Look-up tables for the star and sharp operators
+    # +---+---+---+---+
+    # |A/B| 0 | 1 | - |
+    # +---+---+---+---+
+    # | 0 |   |   |   |
+    # +---+---+---+---+
+    # | 1 |   |   |   |
+    # +---+---+---+---+
+    # | - |   |   |   |
+    # +---+---+---+---+
+    #
+    # Use it like: STAR_TABLE[a.bit][b.bit]
+    STAR_TABLE = {
+      Bit::OFF => {
+        Bit::OFF => Bit::OFF,
+        Bit::ON  => Bit::NULL,
+        Bit::DC  => Bit::OFF
+      },
+      Bit::ON => {
+        Bit::OFF => Bit::NULL,
+        Bit::ON  => Bit::ON,
+        Bit::DC  => Bit::ON
+      },
+      Bit::DC => {
+        Bit::OFF => Bit::OFF,
+        Bit::ON  => Bit::ON,
+        Bit::DC  => Bit::DC
+      }
+    }
+    SHARP_TABLE = {
+      Bit::OFF => {
+        Bit::OFF => Bit::EPSILON,
+        Bit::ON  => Bit::NULL,
+        Bit::DC  => Bit::EPSILON
+      },
+      Bit::ON => {
+        Bit::OFF => Bit::NULL,
+        Bit::ON  => Bit::EPSILON,
+        Bit::DC  => Bit::EPSILON
+      },
+      Bit::DC => {
+        Bit::OFF => Bit::ON,
+        Bit::ON  => Bit::OFF,
+        Bit::DC  => Bit::EPSILON
+      }
+    }
+
+    attr_reader :inputs, :output
+
+    def initialize(input_labels, output_label, str, is_null = false)
+      @is_null = is_null
+
+      return if str.empty?
+
+      (input_bits, output_bit) = parse_bits(str)
+
+      fail 'Input bit size mismatch' if input_labels.size != input_bits.size
+
+      @inputs = []
+      input_labels.each_with_index do |label, i|
+        @inputs << Bit.new(label, input_bits.at(i), Bit::INPUT)
+      end
+
+      @output = Bit.new(output_label, output_bit, Bit::OUTPUT)
+    end
+
+    # The Star-operator.
+    # As described in Chapter 4.10 in the Fundamentals of Digital Logic with
+    # Verilog Design,
+    #
+    # A * B = C
+    #
+    # where
+    #
+    # * C = NULL if A_i * B_i = NULL for more than one i
+    # * Otherwise, C_i = A_i * B_i when A_i * B_i != NULL, and C_i = x (don't
+    #   care) for the coordinate where A_i * B_i = NULL
+    def star(rhs)
+      # Sanity check
+      unless @inputs.size == rhs.inputs.size
+        fail 'Two operands must have equal size for *-operator'
+      end
+      unless bits_valid?(@inputs.map(&:bit))
+        fail 'Bad bit in LHS operand of star operator'
+      end
+      unless bits_valid?(rhs.inputs.map(&:bit))
+        fail 'Bad bit in RHS operand of star operator'
+      end
+
+      result_bits = []
+      @inputs.zip(rhs.inputs).each do |a, b|
+        result_bits << STAR_TABLE[a.bit][b.bit]
+      end
+
+      result_is_null = result_bits.count(Bit::NULL) > 1
+      unless result_is_null
+        # C_i = DC if A_i * B_i == NULL
+        result_bits.map! { |b| b == Bit::NULL ? Bit::DC : b }
+      end
+
+      # Construct a Implicant instance
+      Implicant.new(@inputs.map(&:label),
+                    @output.label,
+                    bit_str(result_bits),
+                    result_is_null)
+    end
+    alias_method :*, :star
+
+    # The Sharp-operator.
+    # Described in Chapter 4.10.1 in the Fundamentals of Digital Logic with
+    # Verilog Design.
+    #
+    # A # B = C
+    #
+    # where
+    #
+    # * C = A if A_i # B_i = NULL for some i
+    # * C = NULL if A_i # B_i = EPSILON for all i
+    # * Otherwise, C = union of A_i = B_i' (negated) if A_i = x and B_i != x
+    #
+    # @param rhs [Implicant] the right hand side of the operation
+    #
+    # @return [Set<Implicant>] Note that the set size could be 1.
+    def sharp(rhs)
+      unless @inputs.size == rhs.inputs.size
+        fail 'Two operands must have equal size for sharp operator'
+      end
+      unless bits_valid?(@inputs.map(&:bit))
+        fail 'Bad bit in LHS operand of sharp operator'
+      end
+      unless bits_valid?(rhs.inputs.map(&:bit))
+        fail 'Bad bit in RHS operand of sharp operator'
+      end
+
+      result_bits = []
+      @inputs.zip(rhs.inputs).each do |a, b|
+        result_bits << SHARP_TABLE[a.bit][b.bit]
+      end
+
+      # C = A if A_i # B_i = NULL for some i
+      return Set.new([self]) if result_bits.any? { |bit| bit == Bit::NULL }
+
+      # C = NULL if A_i # B_i = EPSILON for all i
+      result_is_null = result_bits.all? { |bit| bit == Bit::EPSILON }
+      return Set.new([Implicant.make_null]) if result_is_null
+
+      # Set of Implicant to return
+      result_set = Set.new
+
+      @inputs.zip(rhs.inputs).each_with_index do |(a, b), i|
+        # Check for A_i == DC and B_i != DC
+        if a.bit == Bit::DC && b.bit != Bit::DC
+          copy = @inputs.map(&:bit)
+          copy[i] = b.bit == Bit::ON ? Bit::OFF : Bit::ON
+          in_labels = @inputs.map(&:label)
+          result = Implicant.new(in_labels, @output.label, bit_str(copy))
+          result_set.add(result)
+        end
+      end
+
+      result_set
+    end
+
+    # Finds the possible minterms that this implicant can represent.
+    # For example, a bit string of 101 can only represent m_5, but 10- can
+    # represent m_4 and m_5.
+    #
+    # @return [Set<Integer>] a set of minterms.
+    def minterms
+      set = Set.new
+
+      bits = @inputs.map(&:bit)
+      num_dc = bits.count(Bit::DC)
+      str = bits.join
+      # There are 2**num_dc combinations
+      (2**num_dc).times do |i|
+        str_copy = str.dup
+
+        # Convert to binary form and pad with 0
+        cnt_str = i.to_s(2).rjust(num_dc, '0')
+        cnt_str.split('').each do |b|
+          str_copy = str_copy.sub(Bit::DC, b)
+        end
+        set.add(str_copy.to_i(2))
+      end
+
+      set
+    end
+
+    # Returns the cost of this implicant.
+    # A cost refers to the size of the cube, meaning how many don't-cares this
+    # implicant has. For example, an implicant '1-00' has a cost of 3, whereas
+    # '1--0' has a cost of 2.
+    #
+    # @return [Integer] the cost of this implicant.
+    def cost
+      @inputs.size - @inputs.map(&:bit).count(Bit::DC)
+    end
+
+    # Checks if this implicant covers the given implicant.
+    # Implicant a covers b if all bit combinations that b can describe can
+    # also be described by a.
+    #
+    # @param other [Implicant] the implicant to be compared against.
+    #
+    # @return [true, false] true if this covers the given implicant, false
+    #   otherwise.
+    def covers?(other)
+      fail 'Argument must be an Implicant' unless other.is_a?(Implicant)
+
+      @inputs.zip(other.inputs).each do |a, b|
+        return false unless a.bit == b.bit || a.bit == Bit::DC
+      end
+
+      true
+    end
+
+    def null?
+      @is_null
+    end
+
+    # Checks for equality.
+    #
+    # @param other [Object] whatever to compare against
+    def ==(other)
+      @inputs == other.inputs && @output == other.output
+    end
+    alias_method :eql?, :==
+
+    # Returns the hash value of this instance.
+    #
+    # @return [Integer] the hash value of this instance.
+    def hash
+      [@inputs, @output].hash
+    end
+
+    # Return the string version of this implicant.
+    #
+    # @param show [:input, :output, :labels, Array<:input, :output, :labels>]
+    #   what to show. If Array is used, corresponding information is appended.
+    #
+    # @return [String] string representation of this implicant.
+    def to_s(show = [:input])
+      show = [show] unless show.is_a?(Array)
+
+      tokens = []
+
+      if show.include?(:labels)
+        # Only show the labels
+        if show == [:labels]
+          return [@inputs.map(&:label), @output.label].join(Bliftax::SPACE)
+        end
+
+        if show.include?(:input)
+          tokens << 'INPUTS'
+          @inputs.each do |b|
+            tokens << format('%-8s %s', b.label, b.bit)
+          end
+        end
+        if show.include?(:output)
+          tokens << 'OUTPUT'
+          tokens << format('%-8s %s', @output.label, @output.bit)
+        end
+
+        return tokens.join("\n") + "\n"
+      end
+
+      tokens << @inputs.map(&:bit).join if show.include?(:input)
+      tokens << @output.bit if show.include?(:output)
+      tokens.join(Bliftax::SPACE)
+    end
+
+    # Returns the string representation of this implicant.
+    #
+    # @return [String] the string representation of this implicant in BLIF
+    #   format.
+    def to_blif
+      format '%s %s', @inputs.map(&:bit).join, @output.bit
+    end
+
+    # Creates a new NULL Implicant.
+    #
+    # @return [Implicant] a null Implicant
+    def self.make_null
+      Implicant.new([], Bliftax::EMPTY, Bliftax::EMPTY, true)
+    end
+
+    private
+
+    # Parses the bit string and returns the bits for inputs and outputs.
+    #
+    # @param str [String] the string representation of the input and output
+    #   bits. Input and output bits must be separated by a whitespace.
+    #
+    # @return [Array] contains exactly two elements, the first being the input
+    #   bits in String and the second being the output bit in String.
+    #
+    # @example Parse a String representation of bits.
+    #   parse_bits('010 1')
+    #   # => [['0', '1', '0'], '1']
+    def parse_bits(str)
+      is_single = str.split(' ').size == 1
+
+      # Constant gate (likely vcc or gnd)
+      if is_single
+        input_bits = []
+        output_bit = str
+      else
+        # Parse strings that look like "0001 1"
+        (input_bits, output_bit) = str.split(' ')
+        input_bits = input_bits.split('')
+      end
+
+      [input_bits, output_bit]
+    end
+
+    # Checks whether all the bits are either 1, 0, or DC.
+    #
+    # @param bits [Array<String>]
+    #
+    # @return [true, false] true if all the bits are 1, 0, or DC.
+    def bits_valid?(bits)
+      bits.all? do |bit|
+        [Bit::ON, Bit::OFF, Bit::DC].any? { |b| bit == b }
+      end
+    end
+
+    # Returns the BLIF-style representation of this implicant.
+    # This method assumes that the output bit is 1 because BLIF only states
+    # combinations that result in output of 1.
+    #
+    # @return [String] representation of the bits in this implicant. The
+    #   output bit is separated from the input bits by one space.
+    def bit_str(bits)
+      format '%s 1', bits.join
+    end
+  end
+end

data/lib/bliftax/version.rb

@@ -0,0 +1,3 @@
+class Bliftax
+  VERSION = '0.1.0'
+end

data/lib/bliftax.rb

@@ -0,0 +1,191 @@
+require 'bliftax/gate'
+require 'bliftax/implicant'
+require 'bliftax/version'
+
+# A class that parses a BLIF file.
+class Bliftax
+  attr_accessor :name, :inputs, :outputs, :latches, :clocks, :gates
+
+  # Declarations for BLIF
+  MODEL = '.model'
+  INPUTS = '.inputs'
+  OUTPUTS = '.outputs'
+  NAMES = '.names'
+  LATCH = '.latch'
+  CLOCK = '.clock'
+  END_MODEL = '.end'
+
+  # One space
+  SPACE = ' '
+  # Empty string
+  EMPTY = ''
+
+  # Initializes the object.
+  #
+  # @param str [String] filename or text to parse
+  def initialize(str = nil)
+    @latches = []
+    @clocks = []
+    @gates = []
+
+    parse(str) unless str.nil?
+  end
+
+  # Parses a BLIF file.
+  #
+  # @param str [String] filename or the text to parse.
+  #
+  # @return [Bliftax] the parsed BLIF file.
+  def parse(str)
+    fh = File.exist?(str) ? File.open(str) : StringIO.new(str)
+    lines = read_continuous_lines(fh)
+
+    lines.each_with_index do |line, i|
+      (decl, *following) = line.split(SPACE)
+
+      case decl
+      when MODEL
+        @name = following.first
+      when INPUTS
+        @inputs = following
+      when OUTPUTS
+        @outputs = following
+      when NAMES
+        @gates << parse_gate(following, lines, i + 1)
+      when LATCH
+        @latches << following
+      when CLOCK
+        @clocks << following
+      when END_MODEL
+        break
+      when /^[^\.]/
+        next
+      else
+        fail "Unknown decl encountered: I don't understand `#{decl}' :("
+      end
+    end
+
+    self
+  end
+
+  # Parse one gate from the input.
+  #
+  # @param labels [Array<String>] labels of the inputs and output.
+  # @param lines [Array<String>] all the lines in the current BLIF file.
+  # @param i [Integer] index of in lines to start from.
+  #
+  # @return [Gate] the gate that was parsed.
+  def parse_gate(labels, lines, i)
+    gate = Gate.new(labels)
+
+    loop do
+      # If no truth table exists, then that's all 0
+      bit_str = lines[i].start_with?('.') ? Implicant::Bit::OFF : lines[i]
+      gate.add_implicant(bit_str)
+
+      i += 1
+
+      break if lines[i].nil? || lines[i].empty? || lines[i].start_with?('.')
+    end
+
+    gate
+  end
+
+  # Returns a string representation of this gate in BLIF format.
+  #
+  # @return [String] this gate in BLIF format
+  def to_blif
+    in_labels = @inputs.join(SPACE)
+    out_labels = @outputs.join(SPACE)
+    str = <<-EOF
+.model #{@name}
+.inputs #{in_labels}
+.outputs #{out_labels}
+    EOF
+
+    @gates.each do |gate|
+      str << gate.to_blif
+    end
+
+    @latches.each do |l|
+      str << format(".latch %s\n", l.join(SPACE))
+    end
+
+    @clocks.each do |c|
+      str << format(".clock %s\n", c.join(SPACE))
+    end
+
+    str << ".end\n"
+  end
+
+  # Duplicates this object.
+  #
+  # @return the deep copy of this object.
+  def dup
+    copy = Bliftax.new
+    copy.name = @name.dup
+    copy.inputs = @inputs.dup
+    copy.outputs = @outputs.dup
+    copy.latches = @latches.dup
+    copy.clocks = @clocks.dup
+    copy.gates = @gates.dup
+    copy
+  end
+
+  private
+
+  # Reads in the BLIF file creating an Array with each element being the
+  # logical line (removing comments and joining lines that end with
+  # backslash with the next line).
+  #
+  # @param fh [IO] File handle
+  #
+  # @return [Array] each element being the logical lines with comments and
+  #   backslashes removed. Lines ending with a backslash gets joined with the
+  #   next line.
+  def read_continuous_lines(fh)
+    # Read in the entire BLIF file into an array so that
+    # we can "peek" into the future.
+    lines = []
+    fh.each_line do |line|
+      line.chomp!
+
+      # Skip comment lines
+      next if line.start_with?('#')
+      next if line.strip.empty?
+
+      continuous_lines = []
+      loop do
+        line = strip_comments(line)
+        continuous_lines << strip_trailing_backslash(line)
+
+        # If line ends with a backslash, there's more to come
+        break unless line.end_with?('\\')
+
+        line = fh.gets.chomp
+      end
+
+      lines << continuous_lines.join(SPACE).strip
+    end
+
+    lines
+  end
+
+  # Removes the trailing comments from a string.
+  #
+  # @param str [String] the original string
+  #
+  # @return [String] string with the trailing whitespace and comments removed
+  def strip_comments(str)
+    str.sub(/\s*\#.*$/, EMPTY).strip
+  end
+
+  # Removes the trailing backslash from a string.
+  #
+  # @param str [String] the original string
+  #
+  # @return [String] string with the trailing backslash removed
+  def strip_trailing_backslash(str)
+    str.sub(/\\/, EMPTY)
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: bliftax
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Naoki Mizuno
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.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'
+description: 
+email:
+- nigorojr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- bliftax.gemspec
+- lib/bliftax.rb
+- lib/bliftax/gate.rb
+- lib/bliftax/implicant.rb
+- lib/bliftax/implicant/bit.rb
+- lib/bliftax/version.rb
+homepage: https://github.com/NigoroJr/bliftax
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A library that parses BLIF files and do logic optimization
+test_files: []
+has_rdoc: