vhdl_parser 0.1

data/lib/vhdl_parser.rb

@@ -0,0 +1,115 @@
+require 'vhdl_parser/magic'
+require 'vhdl_parser/utility'
+require 'vhdl_parser/extractor'
+require 'vhdl_parser/entity'
+require 'vhdl_parser/port'
+require 'vhdl_parser/generic'
+require 'vhdl_parser/package'
+
+
+module VHDL_Parser
+
+  class << self
+  end
+
+  def self.parse_file(filename)
+    string = File.read(filename)
+    self.parse(string)
+  end
+
+  def self.parse(vhdl_string)
+    info = vhdl_string.match /entity\s+(.*)\s+is\s+(?:generic\s*\((.*)\);)?\s*port\s*\((.*)\);\s*end\s*\1;/im
+
+    generics =  info[2].split("\n").compact.delete_if { |s| s.strip.empty? }
+    generics.map! { |s| s.strip!}
+    generics.delete_if { |l| l.match /^--/}
+
+    ports =  info[3].split("\n").compact.delete_if { |s| s.strip.empty? }
+    ports.map! { |s| s.strip!}
+    ports.delete_if { |l| l.match /^--/}
+    
+    @entity = Entity.new
+    @entity.name = info[1]
+
+    
+    self.parse_generics(generics)
+    self.parse_ports(ports)
+
+    @entity.process_generics
+
+    return @entity
+  end
+
+  def self.parse_package_file(filename)
+    string = File.read(filename)
+    self.parse_package(string)
+  end
+
+  def self.parse_package(string)
+    package = Package.new
+
+    constants = Extractor.extract_package_constants(string)
+    constants.each do |c|
+      package.constants[c[0]] = c[2]
+    end
+    package.process
+    package
+  end
+
+  private
+
+  def self.parse_generics(generic_array)
+    generic_array.each do |g|
+      names = Extractor.extract_name(g)
+      names.each do |n|
+        generic = Generic.new
+        generic.name = n
+        generic.type = Extractor.extract_type(g)
+
+        if generic.type == "integer"
+          sizes = Extractor.extract_range(g)
+        else
+          sizes = Extractor.extract_size(g)
+        end
+
+        unless sizes.nil?
+          generic.left = sizes[1]
+          generic.size_dir = sizes[2]
+          generic.right = sizes[3]
+        end
+
+        generic.comment = Extractor.extract_comment(g)
+
+        generic.value = Extractor.extract_value(g)
+
+        @entity.generics.push generic
+      end
+    end
+  end
+
+  def self.parse_ports(port_array)
+    port_array.each do |l|
+      names = Extractor.extract_name(l)
+      names.each do |n|
+        port = Port.new
+        port.name = n
+        port.direction = Extractor.extract_direction(l)
+        port.type = Extractor.extract_type(l)
+        if port.type == "integer"
+          sizes = Extractor.extract_range(l)
+        else
+          sizes = Extractor.extract_size(l)
+        end
+
+        unless sizes.nil?
+          port.left = sizes[1]
+          port.size_dir = sizes[2]
+          port.right = sizes[3]
+        end
+        port.comment = Extractor.extract_comment(l)
+        @entity.ports.push(port)
+      end
+    end
+  end
+
+end

data/lib/vhdl_parser/entity.rb

@@ -0,0 +1,67 @@
+module VHDL_Parser
+  class Entity
+
+    attr_accessor :name
+    attr_reader :ports, :generics
+
+    def initialize
+      @ports = Array.new
+      @generics = Array.new
+    end
+
+
+    def to_s
+      out = name + "\n"
+      @generics.each { |p| out += "\t" + p.to_s}
+      out += "\n\n"
+      @ports.each { |p| out += "\t" + p.to_s}
+      out
+    end
+
+
+    def merge_package(package)
+      # TODO: do some type checking
+      @generics.each do |g|
+        package.constants.each do |k,v|
+          unless g.value.nil?
+            g.value = Utility.sub_constants(g.value, k, v)
+          end
+
+          unless g.left.nil?
+            g.left = Utility.sub_constants(g.left, k, v)
+          end
+
+          unless g.right.nil?
+            g.right = Utility.sub_constants(g.right, k, v)
+          end
+        end
+      end
+
+      @ports.each do |p|
+        package.constants.each do |k,v|
+          unless p.left.nil?
+            p.left = Utility.sub_constants(p.left, k, v)
+          end
+
+          unless p.right.nil?
+            p.right = Utility.sub_constants(p.right, k, v)
+          end
+        end
+      end
+    end
+
+    def process_generics
+      @ports.each do |p|
+        @generics.each do |g|
+          unless p.left.nil?
+            p.left = Utility.sub_constants(p.left, g.name, g.value)
+          end
+          unless p.right.nil?
+            p.right = Utility.sub_constants(p.right, g.name, g.value)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/vhdl_parser/extractor.rb

@@ -0,0 +1,64 @@
+module VHDL_Parser
+  class Extractor
+
+    def self.extract_name(string)
+      names = string.split(":").map! { |e| e.strip}
+      names[0].split(/\s*,\s*/)
+    end
+
+    def self.extract_direction(string)
+      res = string.match(/:\s*(in|out|inout)/)
+      if res[1]
+        return res[1]
+      end
+      ""
+    end
+
+    def self.extract_type(string)
+      res =  string.match(/:\s*(?:in|out|inout)?\s+(\w+)/i)
+      if res[1]
+        return res[1]
+      end
+      ""
+    end
+
+    def self.extract_size(string)
+      res = string.match(/\((.*?)\s+(downto|to)\s+(.+?)\)/i)
+      if res 
+        return res
+      end
+      ""
+    end
+
+    def self.extract_range(string)
+      res = string.match(/range\s+(.*?)\s+(downto|to)\s+([-a-z0-9_]*)/i)
+      if res 
+        return res
+      end
+      ""
+    end
+
+    def self.extract_comment(string)
+      res = string.match(/--(.*)$/)
+      if res && res[0]
+        return res[0]
+      end
+      ""
+    end
+
+    def self.extract_package_constants(string)
+      body = string.match(/package\s+(.*)\s+is\s+(.*)\s*end\s*\1;/im)
+      name = body[1]
+      constants = body[2]
+      constants.scan /constant\s+(\w+)\s*:\s*(\w+)\s*:=\s*(.*);/i
+    end
+
+    def self.extract_value(string)
+      res = string.match /:=\s*([xo"0-9a-z_]*)/i
+      if res && res[1]
+        return res[1]
+      end
+      ""
+    end
+  end
+end

data/lib/vhdl_parser/generic.rb

@@ -0,0 +1,28 @@
+module VHDL_Parser
+  class Generic
+    attr_accessor :name, :value, :type, :size, :left, :right, :size_dir, :comment
+
+    def initialize
+      @left = 0
+      @right = 0
+      @size_dir = "downto"
+    end
+
+    def to_s
+      name.ljust(15) + "\t" +
+      type + " " + 
+      size + "\t:= " + 
+      value + "\t" +
+      comment +
+      "\n"
+    end
+
+    def size
+      unless @left.nil?
+        "(#{@left} #{@size_dir} #{@right})"
+      else
+        ""
+      end
+    end
+  end
+end

data/lib/vhdl_parser/magic.rb

@@ -0,0 +1,5 @@
+class String
+  def is_numeric?
+    true if Float(self) rescue false
+  end
+end

data/lib/vhdl_parser/package.rb

@@ -0,0 +1,22 @@
+module VHDL_Parser
+  class Package
+
+    attr_accessor :constants
+
+    def initialize
+      @constants = Hash.new
+    end
+
+    def to_s
+      @constants.to_s
+    end
+
+    def process
+      @constants.each do |k,v|
+        @constants.each do |k2,v2|
+          @constants[k2] = Utility.sub_constants(v2, k, v)
+        end
+      end
+    end
+  end
+end

data/lib/vhdl_parser/port.rb

@@ -0,0 +1,27 @@
+module VHDL_Parser
+  class Port
+    attr_accessor :name, :direction, :comment, :type, :size, :left, :right, :size_dir
+
+    def initialize
+      @left = 0
+      @right = 0
+      @size_dir = "downto"
+    end
+
+    def to_s
+      name.ljust(15) + "\t" +
+      direction + "\t" + 
+      type + " " + 
+      size + "\t" + 
+      comment + "\n"
+    end
+
+    def size
+      unless @left.nil?
+        "(#{@left} #{@size_dir} #{@right})"
+      else
+        ""
+      end
+    end
+  end
+end

data/lib/vhdl_parser/utility.rb

@@ -0,0 +1,34 @@
+module VHDL_Parser
+  class Utility
+    def self.sub_constants(target, key, value)
+      # first get all the words of the size. That could be
+      # a number or a constant.
+      words = target.to_s.scan /\w+/
+      ret = ""  
+      words.each do |w|
+        # if a word matches the key and it's not numeric, it must 
+        # be a constant that we want to replace
+        if w.eql?(key) and not w.is_numeric?
+          # so replace it here with the given value
+          ret = target.gsub(w,value).to_s
+        end
+      end
+
+      # now eval the result. If a constant has been replaced with a 
+      # value, it could be something like "8-1", so eval that into 7.
+      # In case it's still a constant, catch the NameError but ignore it;
+      # chances are the constant will be replaced later.
+      begin
+        # since we're eval'ing here, do some basic cleanup to prevent badness.
+        # Specifically, replace anything that's not a number or basic math
+        # function with 'xx', since those should trigger the exception anyway.
+        foreval = ret.gsub(/[^-+*\/\d\(\)\s]/,'xx')
+        ret = eval(foreval)
+      rescue NameError => e
+      end
+      # if nothing was replaced, we get nil, so instead of returning nil,
+      # just return the original target, meaning this was just a noop.
+      ret.nil? ? target.to_s : ret
+    end
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: vhdl_parser
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Christoph Koehler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-30 00:00:00.000000000 Z
+dependencies: []
+description: ! "VHDL Parser parses an VHDL entity and provides a Ruby\n  interface
+  to access all its information."
+email: christoph@zerodeviation.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/vhdl_parser/entity.rb
+- lib/vhdl_parser/extractor.rb
+- lib/vhdl_parser/generic.rb
+- lib/vhdl_parser/magic.rb
+- lib/vhdl_parser/package.rb
+- lib/vhdl_parser/port.rb
+- lib/vhdl_parser/utility.rb
+- lib/vhdl_parser.rb
+homepage: http://rubygems.org/gems/vhdl_parser
+licenses: []
+post_install_message: Hi there
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: VHDL Entity Parser
+test_files: []