bat 1.0.0

data/lib/Inv.rb

@@ -0,0 +1,9 @@
+# This class defines the Inverter part
+class Inv < TwoPorts
+  # This method returns the specific ABEL code to be output for this Inst object based on its connections on its input ports.
+  # These connections are defined in the abelout method of this object's superclass, TwoPorts.
+  def abelout
+    super
+    "#{self.name}p1 = !#{@p0};\n"
+  end
+end

data/lib/Mux2.rb

@@ -0,0 +1,25 @@
+# This class defines the 2-to-1 Multiplexer part
+class Mux2 < Inst
+  # This method is called when a new object is instantiated, it takes the name of the Inst object (name) as its only argument.
+  # It is responsible for defining applicable nodes, then calling its superclass, Inst, to complete other tasks. 
+  def initialize(name)
+    super(name,[0,1,2,3],[10])
+  end
+  
+  # This method defines the connections held by the ports of this object and returns the specific ABEL code to be output for this 
+  # object based on the connections on its input ports.
+  def abelout
+    # make these class variables just for consistency's sake
+    @p0 = self.get_port("p0").connections.collect{|p| p.name}.to_s
+    @p1 = self.get_port("p1").connections.collect{|p| p.name}.to_s
+    @p2 = self.get_port("p2").connections.collect{|p| p.name}.to_s
+    @p3 = self.get_port("p3").connections.collect{|p| p.name}.to_s
+    
+    s = ""
+    s << "\n\"active low enabled MUX2\nWHEN (#{@p0} == 1) THEN\n\t#{self.name}p10 = 0;\n"
+    s << "else WHEN (!#{@p0} & !#{@p1}) THEN\n\t#{self.name}p10 = #{@p2};\n"
+    s << "else WHEN (!#{@p0} & #{@p1}) THEN\n\t#{self.name}p10 = #{@p3};\n"        
+  end 
+end
+
+# TODO - need to handle empty nets!!

data/lib/Nand2.rb

@@ -0,0 +1,9 @@
+# This class defines the 2-Input NAND part
+class Nand2 < ThreePorts
+  # This method returns the specific ABEL code to be output for this Inst object based on its connections on its input ports.
+  # These connections are defined in the abelout method of this object's superclass, ThreePorts.
+  def abelout
+    super
+    "#{self.name}p2 = !(#{@p0} & #{@p1});\n"
+  end
+end

data/lib/Nand2c.rb

@@ -0,0 +1,9 @@
+# This class defines the 2-Input AND part
+class Nand2c < ThreePorts
+  # This method returns the specific ABEL code to be output for this Inst object based on its connections on its input ports.
+  # These connections are defined in the abelout method of this object's superclass, ThreePorts.
+  def abelout
+    super
+    "#{self.name}p2 = (#{@p0} & #{@p1});\n"
+  end  
+end

data/lib/Nand3.rb

@@ -0,0 +1,9 @@
+# This class defines the 3-Input NAND part
+class Nand3 < FourPorts
+  # This method returns the specific ABEL code to be output for this Inst object based on its connections on its input ports.
+  # These connections are defined in the abelout method of this object's superclass, FourPorts.
+  def abelout
+    super
+    "#{self.name}p3 = !(#{@p0} & #{@p1} & #{@p2});\n"
+  end  
+end

data/lib/Nand3c.rb

@@ -0,0 +1,9 @@
+# This class defines the 3-Input AND part
+class Nand3c < FourPorts
+  # This method returns the specific ABEL code to be output for this Inst object based on its connections on its input ports.
+  # These connections are defined in the abelout method of this object's superclass, FourPorts.
+  def abelout
+    super
+    "#{self.name}p3 = (#{@p0} & #{@p1} & #{@p2});\n"
+  end
+end

data/lib/Nand4.rb

@@ -0,0 +1,9 @@
+# This class defines the 4-Input NAND part
+class Nand4 < FivePorts 
+  # This method returns the specific ABEL code to be output for this Inst object based on its connections on its input ports.
+  # These connections are defined in the abelout method of this object's superclass, FivePorts.
+  def abelout
+    super
+    "#{self.name}p4 = !(#{@p0} & #{@p1} & #{@p2} & #{@p3});\n"
+  end
+end

data/lib/Nand4c.rb

@@ -0,0 +1,9 @@
+# This class defines the 4-Input AND part
+class Nand4c < FivePorts
+  # This method returns the specific ABEL code to be output for this Inst object based on its connections on its input ports.
+  # These connections are defined in the abelout method of this object's superclass, FivePorts.
+  def abelout
+    super
+    "#{self.name}p4 = (#{@p0} & #{@p1} & #{@p2} & #{@p3});\n"
+  end
+end

data/lib/Nor2.rb

@@ -0,0 +1,9 @@
+# This class defines the 2-Input NOR part
+class Nor2 < ThreePorts
+  # This method returns the specific ABEL code to be output for this Inst object based on its connections on its input ports.
+  # These connections are defined in the abelout method of this object's superclass, ThreePorts.  
+  def abelout
+    super
+    "#{self.name}p2 = !(#{@p0} # #{@p1});\n"
+  end
+end

data/lib/Nor2c.rb

@@ -0,0 +1,9 @@
+# This class defines the 2-Input OR part
+class Nor2c < ThreePorts
+  # This method returns the specific ABEL code to be output for this Inst object based on its connections on its input ports.
+  # These connections are defined in the abelout method of this object's superclass, ThreePorts.
+  def abelout
+    super
+    "#{self.name}p2 = (#{@p0} # #{@p1});\n"
+  end  
+end

data/lib/Nor3.rb

@@ -0,0 +1,9 @@
+# This class defines the 3-Input NOR part
+class Nor3 < FourPorts
+  # This method returns the specific ABEL code to be output for this Inst object based on its connections on its input ports.
+  # These connections are defined in the abelout method of this object's superclass, FourPorts.
+  def abelout
+    super
+    "#{self.name}p3 = !(#{@p0} # #{@p1} # #{@p2});\n"
+  end  
+end

data/lib/OnePort.rb

@@ -0,0 +1,11 @@
+# This class is the superclass for all one port Inst objects.
+# Vdd, Input, Gnd, and Output inherit from this class.
+
+class OnePort < Inst
+  # This method is called when a new object is instantiated, it takes the name of the Inst object (name) as its only argument.
+  # It is responsible for calling its superclass Inst and passing to it the correct number of input ports and output ports to
+  # be created, it also instructs Inst to not designate nodes for output ports of objects which inherit from this class.   
+  def initialize(name,inputs = [],outputs = [0])
+    super(name,inputs,outputs,false)
+  end
+end

data/lib/Output.rb

@@ -0,0 +1,17 @@
+# This class defines the Output port instance.
+class Output < OnePort
+  # This method is called when a new object is instantiated, it takes the name of the Inst object (name) as its only argument.
+  # It is responsible for defining applicable output pins, then calling its superclass, OnePort, to complete other tasks.   
+  def initialize(name)
+    super(name,[0],[])
+    self.outputs = "#{self.name}p0\tpin;\n"
+  end
+  
+  # This method defines the connections held by the ports of this object and returns the specific ABEL code to be output for this 
+  # object based on the connections on its input port.
+  def abelout
+    # make this a class variable just for consistency's sake
+    @p0 = self.get_port("p0").connections.collect{|p| p.name}.to_s
+    "#{self.name}p0 = #{@p0};\n"
+  end
+end

data/lib/ParseHelper.rb

@@ -0,0 +1,80 @@
+# This module defines a number of helper methods that assist the Parser class in completing its task. 
+module ParseHelper  
+  # Takes a string (str) as input and returns true if the given string has matching sets of parentheses, otherwise it returns false.
+  def self.parens_check(str)
+    str.count("(") == str.count(")")
+  end
+  
+  # Takes an integer (numports) and the name of an Inst (instname) and returns an array of Inst names properly formatted
+  # to take into account the fact that the Inst has multiple bits.
+  def self.member_inst_names(numports,instname)
+    p = 0
+    a = []
+    # while we have not reached the number of ports
+    while p < numports
+      # add a port name to the array
+      addstr = "#{instname}m#{p}"
+      a << addstr
+      p+=1
+    end
+    # return the array
+    a
+  end
+  
+  # Takes a string (str) that defines a netlist and a hash of all existing Inst objects (insts) as input and produces an array of unique port
+  # names that are defined as connections in that netlist.
+  def self.get_port_names(str,insts)
+    a = []
+    i = 0
+    s=""
+    # while we are not at the end of the line
+    while i < str.length
+      # append current character to a new string
+      s << str[i].chr
+      # if the parens match append it to an array
+      if parens_check(s)
+        a << self.parse_port_names(s,insts)
+        s = ""
+      end
+      # keep checking
+      i+=1
+    end
+    # return the array (use uniq to get rid of duplicate bufz ports)
+    a.uniq
+  end
+  
+  # Takes a string of a portname (str) as input and returns an array where the first element is the name of the Inst object
+  # to which the port belongs, and the second element is the port it represents on the given Inst.
+  def self.portname_split(str)
+    a = []
+    if str =~ /(\w+)((p\d+\z|out\z))/
+    a[0] = $1
+    a[1] = $2
+    else
+      raise "Invalid EDF"
+    end
+    a
+  end  
+  
+  private
+  
+  def self.parse_port_names(str,insts)
+    # if we are dealing with an instance (as defined in the EDF)
+    if str =~ /(\(portRef\s)(\w+)(\s\(instanceRef\s)(\w+)/
+      # if it is a bufz fake out portname to match output pin name
+      if insts["#{$4.downcase}"].class.to_s.downcase == "bufz" && !%w[p0 p1 p2 p3 p4 p5 p6].find {|d| d == $2.downcase}
+        "#{$4.downcase}out" 
+      else
+       "#{$4.downcase}#{$2.downcase}"
+      end
+    # if we are dealing with a port (as defined in the EDF) of a multi-membered Inst
+    elsif str =~ /(\(portRef\s\(member\s)(\w+)(\s)(\d+)/
+      "#{$2.downcase}m#{$4}p0"
+    # if we are dealing with a port (as defined in the EDF) of a standard Inst
+    elsif str =~ /(\(portRef\s)(\w+)/
+      "#{$2.downcase}p0"
+    else
+      raise "Invalid EDF"
+    end  
+  end
+end

data/lib/Parser.rb

@@ -0,0 +1,137 @@
+# This class handles all parsing operations for this application. It makes extensive use of the ParseHelper module to accomplish this.
+class Parser
+  # Takes an array of lines (filearray) - presumably from an EDF file - and parses them, dynamically creating a data structure
+  # by defining the connections between Inst objects as they are created. 
+  def parse(filearray)
+    # read through our array to find and store the start and end points
+    filearray.each_with_index do |line,index|
+      line.strip!
+      # store linecounts as indexes into the array (zero based)
+      @startline = index if line =~ /interface/
+      if line =~ /design root/
+        @endline = index - 2 
+        break
+      end
+    end
+
+    # chop invalid parts off of array
+    filearray = filearray.slice(@startline..@endline)
+
+    arrplace = 0
+    arrlength = filearray.length - 1
+    valid_edf = []
+    tmpstr = ""
+    @insts = {}
+    while arrplace <= arrlength
+      # see if we have a keyword on the current line  
+      if filearray[arrplace] =~ /\A\(port\s+|\A\(instance|\A\(net/
+        # we do, see if its parens are matched
+        if ParseHelper.parens_check(filearray[arrplace])
+          # they are, so put the string into the array
+          valid_edf << filearray[arrplace]
+        else
+          # they are not, so write the array location to a temp string
+          tmpstr << filearray[arrplace]
+          # see if we are at the end of the array
+          break if arrplace + 1 >= arrlength
+          # if not keep trying to match parens
+          arrplace += 1
+          tmpstr << filearray[arrplace]
+          # replace this with paren check
+          while !ParseHelper.parens_check(tmpstr)
+            break if arrplace + 1 >= arrlength
+            arrplace += 1
+            tmpstr << filearray[arrplace]
+          end
+          valid_edf << tmpstr
+          tmpstr = ""
+        end
+        # look at next place
+        arrplace += 1
+      else
+        arrplace += 1
+      end
+    end
+
+    valid_edf.each do |l|
+      # for the first keyword port
+      if l =~ /\A\(port\s+/
+        # if there are multiple members
+        if l =~ /(\w+)(\s+)(\d+)(\(direction)(\s)(input|output)/
+          instnum = $3.to_i
+          insttype = $6.capitalize
+          instname = $1.downcase
+          # generate names for each member
+          inames = ParseHelper.member_inst_names(instnum,instname)
+          # puts "Creating #{instnum} Insts of type #{insttype} named #{inames.join(", ")}"
+          # create the inst objects of the proper type and store in insts hash
+          inames.each do |i|
+            @insts[i] = Object.const_get(insttype).new(i)
+          end
+        # if there are no members
+        elsif l =~ /(\w+)(\s)(\(direction)(\s)(input|output)/
+          insttype = $5.capitalize
+          instname = $1.downcase
+          # puts "Creating an Inst of type #{insttype} named #{instname}"
+          # create the inst objects of the proper type and store in insts hash
+          @insts["#{instname}"] = Object.const_get(insttype).new(instname)
+        else
+          throw "Error Parsing Ports"
+        end
+      # for the second keyword, "instance"
+      elsif l =~ /(\A\(instance\s+)(\w+)(\(viewRef)(\s)(viewnamedefault\(cellRef)(\s)(\w+)/
+        insttype = $7.capitalize
+        instname = $2.downcase
+        # create the inst objects of the proper type and store them in the hash
+        # puts "Creating an Inst of type #{insttype} named #{instname}"
+        @insts["#{instname}"] = Object.const_get(insttype).new(instname)
+      elsif l =~ /(\A\(net\sNet\d+\(joined)(.*)/
+        # get the names for the joined ports in individual arrays
+        # make this get_port_names method modify names for bufz ports on the fly
+        ports = ParseHelper.get_port_names($2,@insts)
+        # look for output ports to find the master
+        # if inst type is bufz then automatically set it as a masterport
+        # I have the inst name and the port name availible to me separately
+        outputports = []
+        inputports = []
+        unless ports.length <= 1
+        ports.each do |p|
+          # split portnames into inst name and port name
+          splitport = ParseHelper.portname_split(p) 
+          # if the portname is out we have a bufz output port
+          if splitport[1] == "out"
+            # we know this is an output so add it to output
+            outputports << p
+          # otherwise check to see if this might be a output port of another type
+          elsif @insts[splitport[0]].get_port(splitport[1]).type == "out"
+            # we know this is an output so add it to output
+            outputports << p
+          else
+            # otherwise it is an input
+            inputports << p
+          end
+        end
+        
+        # this assumes there is only one input port
+        # since bufz is treated as a unit this should be true
+        # if it is not there will be errors - but they will be the fault
+        # of the circuit designer
+        op = ParseHelper.portname_split(outputports.first)
+        inputports.each do |p|
+          # puts "Cross-Connecting #{op} to #{p}"
+          # convert port names to separate inst names and port names
+          ip = ParseHelper.portname_split(p)
+          # cross connect ports
+          # puts "connecting #{ip[0]} on #{ip[1]} to #{op[0]} on #{op[1]}"
+          @insts[ip[0]].get_port(ip[1]).add_connection(@insts[op[0]].get_port(op[1]))
+          # puts "connecting #{op[0]} on #{op[1]} to #{ip[0]} on #{ip[1]}"
+          @insts[op[0]].get_port(op[1]).add_connection(@insts[ip[0]].get_port(ip[1]))
+        end
+        end
+      else
+        throw "Error Parsing Nets/Instances"
+      end
+    end
+    @insts
+  end  
+end

data/lib/Port.rb

@@ -0,0 +1,24 @@
+# This class defines the Port object. Ports are instantiated each time an Inst object is created and they correspond to 
+# the conecptual "ports" found on each Inst. They are connected to other ports via a connection list, these connections
+# are built by the Parser component and in sum form the data structure which models the digital circuit described by the
+# input EDF file.
+
+class Port  
+  attr_accessor :inst, :type, :name, :connections
+  
+  # This method is called each time a new Port object is instantiated. It takes a string argument for the Inst it
+  # belongs to (inst); the type of port it is, either input or output, (type); and its name (name), a concatenation
+  # of the name of the Inst to which it belongs and the port which it is representing.
+  def initialize(inst, type, name)
+    self.inst = inst
+    self.connections = []
+    self.type = type
+    self.name = name
+  end
+  
+  # This method takes the name of another port as a string (port) and appends it to an array which holds the connection
+  # list attribute (connections) for the given port.
+  def add_connection(port)
+    self.connections << port
+  end    
+end

data/lib/ThreePorts.rb

@@ -0,0 +1,17 @@
+# This class is the superclass for all three port Inst objects
+# Nor2, Nand2c, Xor2, Nand2, and Nor2c inherit from this class
+
+class ThreePorts < Inst
+  # This method is called when a new object is instantiated, it takes the name of the Inst object (name) as its only argument.
+  # It is responsible for calling its superclass Inst and passing to it the correct number of input ports and output ports to
+  # be created.  
+  def initialize(name)
+    super(name,[0,1],[2])
+  end                                       
+
+  # This method defines the connections held by the ports for this object's subclasses.
+  def abelout
+    @p0 = self.get_port("p0").connections.collect{|p| p.name}.to_s
+    @p1 = self.get_port("p1").connections.collect{|p| p.name}.to_s
+  end
+end

data/lib/TwoPorts.rb

@@ -0,0 +1,16 @@
+# This class is the superclass for all two port Inst objects
+# Inv and Buf1 inherit from this class
+
+class TwoPorts < Inst
+  # This method is called when a new object is instantiated, it takes the name of the Inst object (name) as its only argument.
+  # It is responsible for calling its superclass Inst and passing to it the correct number of input ports and output ports to
+  # be created. 
+  def initialize(name)
+    super(name,[0],[1])
+  end
+
+  # This method defines the connections held by the ports for this object's subclasses.  
+  def abelout
+    @p0 = self.get_port("p0").connections.collect{|p| p.name}.to_s
+  end  
+end