origen_verilog 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 21754cb54ea4c8ce9b073264a796f2ff18e79740
+  data.tar.gz: 99caa65a1e1128d1cce33889e2333fc2c8df6b5a
+SHA512:
+  metadata.gz: 80d9f2446499b1be8cdc77cfb2d33ae04a3a01f2a26de74535653354648b2b1108840f557295b07c98314d303aae69c37cdc0557000fa410cfdd2443ac15e5db
+  data.tar.gz: d34de4b2019034a6dac31b6b316b6e4cfbf8a807e78e27445923813f644d4954853a32bcf0649d196f9ea157952f492ec6572087e51a49e6cc864e4300dd1f12

data/bin/fix_my_workspace

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby
+$VERBOSE = nil  # Don't care about world writable dir warnings and the like
+
+if $_fix_my_workspace_version_check
+  $_fix_my_workspace_version = '0.7.0'
+else
+  if File.exist?(File.expand_path('../../lib/origen.rb', __FILE__))
+    # If this script is being run from within an origen-core workspace, use that Origen-core,
+    # not the system-installed origen-core version.
+    $LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+    require 'origen'
+  else
+    # Use system-installed Origen (the gem in system Ruby)
+    require 'origen'
+  end
+
+  if !Origen.site_config.gem_manage_bundler
+    puts 'Sorry but you have opted to manage Bundler yourself via your Origen site config, and this means'
+    puts 'that I cannot make certain assumptions about how your workspace is configured.'
+    puts 'You will need to either resolve this problem yourself, or else change the value of'
+    puts 'gem_mange_bundler to true.'
+    puts 'See here for more details on how to do that: http://origen-sdk.org/origen/guides/starting/company/'
+
+  else
+    ENV['BUNDLE_GEMFILE'] = File.join(Origen.root, 'Gemfile')
+    ENV['BUNDLE_PATH'] = File.expand_path(Origen.site_config.gem_install_dir)
+    ENV['BUNDLE_BIN'] = File.join(Origen.root, 'lbin')
+
+    # Force copy system gems to local gems
+    if Origen.site_config.gem_use_from_system
+      local_gem_dir = "#{ENV['BUNDLE_PATH']}/ruby/#{Pathname.new(Gem.dir).basename}"
+      gem_dir = Pathname.new(Gem.dir)
+
+      Origen.site_config.gem_use_from_system.each do |gem, version|
+        begin
+          # This will raise an error if the system doesn't have this gem installed, that
+          # will be rescued below
+          spec = Gem::Specification.find_by_name(gem, version)
+
+          local_dir = File.join(local_gem_dir, Pathname.new(spec.gem_dir).relative_path_from(gem_dir))
+          FileUtils.mkdir_p local_dir
+          FileUtils.cp_r("#{spec.gem_dir}/.", local_dir)
+
+          local_file = Pathname.new(File.join(local_gem_dir, Pathname.new(spec.cache_file).relative_path_from(gem_dir)))
+          FileUtils.mkdir_p local_file.dirname
+          FileUtils.cp(spec.cache_file, local_file)
+
+          if spec.extension_dir && File.exist?(spec.extension_dir)
+            local_dir = File.join(local_gem_dir, Pathname.new(spec.extension_dir).relative_path_from(gem_dir))
+            FileUtils.mkdir_p local_dir
+            FileUtils.cp_r("#{spec.extension_dir}/.", local_dir)
+          end
+
+          local_file = Pathname.new(File.join(local_gem_dir, Pathname.new(spec.spec_file).relative_path_from(gem_dir)))
+          FileUtils.mkdir_p local_file.dirname
+          FileUtils.cp(spec.spec_file, local_file)
+
+        rescue Gem::LoadError
+          # This just means that one of the gems that should be copied from the system
+          # was not actually installed in the system, so nothing we can do about that here
+        end
+      end
+    end
+
+    # Delete lbin
+    FileUtils.rm_rf(ENV['BUNDLE_BIN']) if File.exist?(ENV['BUNDLE_BIN'])
+
+    # Run bundler with correct switches
+    cmd = "bundle install --gemfile #{ENV['BUNDLE_GEMFILE']} --binstubs #{ENV['BUNDLE_BIN']} --path #{ENV['BUNDLE_PATH']}"
+    `chmod o-w #{Origen.root}` # Stops some annoying world writable warnings during install
+    `chmod o-w #{Origen.root}/bin` if File.exist?("#{Origen.root}/bin")
+    `chmod o-w #{Origen.root}/.bin` if File.exist?("#{Origen.root}/.bin")
+
+    # Try again, this time updating the bundle
+    if system(cmd)
+      fixed = true
+    elsif system 'bundle update'
+      fixed = true
+    end
+
+    if File.exist?(ENV['BUNDLE_BIN'])
+      `chmod o-w #{ENV['BUNDLE_BIN']}`
+
+      # Make .bat versions of all executables, Bundler should really be doing this when running
+      # on windows
+      if Origen.os.windows?
+        Dir.glob("#{ENV['BUNDLE_BIN']}/*").each do |bin|
+          unless bin =~ /.bat$/
+            bat = "#{bin}.bat"
+            unless File.exist?(bat)
+              File.open(bat, 'w') { |f| f.write('@"ruby.exe" "%~dpn0" %*') }
+            end
+          end
+        end
+      end
+    end
+
+    system 'origen -v' if fixed
+  end
+end

data/config/application.rb

@@ -0,0 +1,103 @@
+require 'origen'
+class OrigenVerilogApplication < Origen::Application
+
+  # See http://origen-sdk.org/origen/api/Origen/Application/Configuration.html
+  # for a full list of the configuration options available
+
+  # These attributes should never be changed, the duplication here will be resolved in future
+  # by condensing these attributes that do similar things
+  self.name       = "origen_verilog"
+  self.namespace  = "OrigenVerilog"
+  config.name     = "origen_verilog"
+  config.initials = "OrigenVerilog"
+  # Change this to point to the revision control repository for this plugin
+  config.rc_url = "git@github.com:Origen-SDK/origen_verilog.git"
+  config.release_externally = true
+
+  # To enable deployment of your documentation to a web server (via the 'origen web'
+  # command) fill in these attributes.
+  #config.web_directory = "git@github.com:Origen-SDK/Origen-SDK.github.io.git/origen_verilog"
+  #config.web_domain = "http://origen-sdk.org/origen_verilog"
+
+  # When false Origen will be less strict about checking for some common coding errors,
+  # it is recommended that you leave this to true for better feedback and easier debug.
+  # This will be the default setting in Origen v3.
+  config.strict_errors = true
+
+  # See: http://origen-sdk.org/origen/latest/guides/utilities/lint/
+  config.lint_test = {
+    # Require the lint tests to pass before allowing a release to proceed
+    run_on_tag: true,
+    # Auto correct violations where possible whenever 'origen lint' is run
+    auto_correct: true, 
+    # Limit the testing for large legacy applications
+    #level: :easy,
+    # Run on these directories/files by default
+    #files: ["lib", "config/application.rb"],
+  }
+
+  config.semantically_version = true
+
+  # An example of how to set application specific LSF parameters
+  #config.lsf.project = "msg.te"
+  
+  # An example of how to specify a prefix to add to all generated patterns
+  #config.pattern_prefix = "nvm"
+
+  # An example of how to add header comments to all generated patterns
+  #config.pattern_header do
+  #  cc "This is a pattern created by the example origen application"
+  #end
+
+  # By default all generated output will end up in ./output.
+  # Here you can specify an alternative directory entirely, or make it dynamic such that
+  # the output ends up in a setup specific directory. 
+  #config.output_directory do
+  #  "#{Origen.root}/output/#{$dut.class}"
+  #end
+
+  # Similarly for the reference files, generally you want to setup the reference directory
+  # structure to mirror that of your output directory structure.
+  #config.reference_directory do
+  #  "#{Origen.root}/.ref/#{$dut.class}"
+  #end
+ 
+  # This will automatically deploy your documentation after every tag
+  #def after_release_email(tag, note, type, selector, options)
+  #  command = "origen web compile --remote --api"
+  #  Dir.chdir Origen.root do
+  #    system command
+  #  end
+  #end
+
+  # Ensure that all tests pass before allowing a release to continue
+  #def validate_release
+  #  if !system("origen specs") || !system("origen examples")
+  #    puts "Sorry but you can't release with failing tests, please fix them and try again."
+  #    exit 1
+  #  else
+  #    puts "All tests passing, proceeding with release process!"
+  #  end
+  #end
+
+  # To enabled source-less pattern generation create a class (for example PatternDispatcher)
+  # to generate the pattern. This should return false if the requested pattern has been
+  # dispatched, otherwise Origen will proceed with looking up a pattern source as normal.
+  #def before_pattern_lookup(requested_pattern)
+  #  PatternDispatcher.new.dispatch_or_return(requested_pattern)
+  #end
+
+  # If you use pattern iterators you may come across the case where you request a pattern
+  # like this:
+  #   origen g example_pat_b0.atp
+  #
+  # However it cannot be found by Origen since the pattern name is actually example_pat_bx.atp
+  # In the case where the pattern cannot be found Origen will pass the name to this translator
+  # if it exists, and here you can make any substitutions to help Origen find the file you 
+  # want. In this example any instances of _b\d, where \d means a number, are replaced by
+  # _bx.
+  #config.pattern_name_translator do |name|
+  #  name.gsub(/_b\d/, "_bx")
+  #end
+
+end

data/config/boot.rb

@@ -0,0 +1,24 @@
+# This file is used to boot your plugin when it is running in standalone mode
+# from its own workspace - i.e. when the plugin is being developed.
+#
+# It will not be loaded when the plugin is imported by a 3rd party app - in that
+# case only lib/origen_verilog.rb is loaded.
+#
+# Therefore this file can be used to load anything extra that you need to boot
+# the development environment for this app. For example, this is typically used
+# to load some additional test classes to use your plugin APIs so that they can
+# be tested and/or interacted with in the console.
+require "origen_verilog"
+
+module OrigenVerilogDev
+  # Example of how to explicitly require a file
+  # require "origen_verilog_dev/my_file"
+    
+  # Load all files in the lib/origen_verilog_dev directory.
+  # Note that there is no problem from requiring a file twice (Ruby will ignore
+  # the second require), so if you have a file that must be required first, then
+  # explicitly require it up above and then let this take care of the rest.
+  Dir.glob("#{File.dirname(__FILE__)}/../lib/origen_verilog_dev/**/*.rb").sort.each do |file|
+    require file
+  end
+end

data/config/commands.rb

@@ -0,0 +1,89 @@
+# This file should be used to extend the origen with application specific commands
+
+# Map any command aliases here, for example to allow 'origen ex' to refer to a 
+# command called execute you would add a reference as shown below: 
+aliases ={
+#  "ex" => "execute",
+}
+
+# The requested command is passed in here as @command, this checks it against
+# the above alias table and should not be removed.
+@command = aliases[@command] || @command
+
+# Now branch to the specific task code
+case @command
+
+# (Working) example of how to create an application specific comment, here to generate
+# a tags file for you application to enable method definition lookup and similar within
+# editors/IDEs
+when "tags"  
+  # Here the logic is just written in-line, alternatively it could be written in a
+  # dedicated file and required here, e.g.
+  #require "origen_verilog/commands/my_command"    # Would load file lib/origen_verilog/commands/my_command.rb
+  Dir.chdir Origen.root do
+    system("ripper-tags -R")
+  end
+  # You must always exit upon successfully capturing and executing a command to prevent 
+  # control flowing back to Origen
+  exit 0
+
+when "build"
+  Dir.chdir Origen.root do
+    system 'lbin/tt --force grammars/verilog.treetop'
+    system 'lbin/tt --force grammars/preprocessor.treetop'
+  end
+  exit 0
+
+## Example of how to make a command to run unit tests, this simply invokes RSpec on
+## the spec directory
+when "specs"
+  ARGV.unshift "spec"
+  require "rspec"
+  require "rspec/autorun"
+  exit 0 # This will never be hit on a fail, RSpec will automatically exit 1
+
+## Example of how to make a command to run diff-based tests
+#when "examples", "test"
+#  Origen.load_application
+#  status = 0
+#
+#  # Compiler tests
+#  ARGV = %w(templates/example.txt.erb -t debug -r approved)
+#  load "origen/commands/compile.rb"
+#  # Pattern generator tests
+#  #ARGV = %w(some_pattern -t debug -r approved)
+#  #load "#{Origen.top}/lib/origen/commands/generate.rb"
+#
+#  if Origen.app.stats.changed_files == 0 &&
+#     Origen.app.stats.new_files == 0 &&
+#     Origen.app.stats.changed_patterns == 0 &&
+#     Origen.app.stats.new_patterns == 0
+#
+#    Origen.app.stats.report_pass
+#  else
+#    Origen.app.stats.report_fail
+#    status = 1
+#  end
+#  puts
+#  if @command == "test"
+#    Origen.app.unload_target!
+#    require "rspec"
+#    result = RSpec::Core::Runner.run(['spec'])
+#    status = status == 1 ? 1 : result
+#  end
+#  exit status  # Exit with a 1 on the event of a failure per std unix result codes
+
+# Always leave an else clause to allow control to fall back through to the
+# Origen command handler.
+else
+  # You probably want to also add the your commands to the help shown via
+  # origen -h, you can do this by assigning the required text to @application_commands
+  # before handing control back to Origen.
+  @application_commands = <<-EOT
+ tags         Build a tags file for this app
+ build        Build/compile the latest grammar files
+ specs        Run the specs (tests), -c will enable coverage
+  EOT
+# examples     Run the examples (tests), -c will enable coverage
+# test         Run both specs and examples, -c will enable coverage
+end 

data/config/version.rb

@@ -0,0 +1,8 @@
+module OrigenVerilog
+  MAJOR = 0
+  MINOR = 2
+  BUGFIX = 0
+  DEV = nil
+
+  VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')
+end

data/lib/origen_verilog.rb

@@ -0,0 +1,34 @@
+require 'origen'
+require_relative '../config/application.rb'
+module OrigenVerilog
+  # THIS FILE SHOULD ONLY BE USED TO LOAD RUNTIME DEPENDENCIES
+  # If this plugin has any development dependencies (e.g. dummy DUT or other models that are only used
+  # for testing), then these should be loaded from config/boot.rb
+
+  autoload :Parser,    'origen_verilog/parser'
+  autoload :Node,      'origen_verilog/node'
+  autoload :Processor, 'origen_verilog/processor'
+  autoload :TopLevel,  'origen_verilog/top_level'
+
+  module Verilog
+    autoload :Parser,    'origen_verilog/verilog/parser'
+    autoload :Node,      'origen_verilog/verilog/node'
+    autoload :Processor, 'origen_verilog/verilog/processor'
+    autoload :Writer,    'origen_verilog/verilog/writer'
+    autoload :Evaluator, 'origen_verilog/verilog/evaluator'
+  end
+  module Preprocessor
+    autoload :Parser,    'origen_verilog/preprocessor/parser'
+    autoload :Node,      'origen_verilog/preprocessor/node'
+    autoload :Processor, 'origen_verilog/preprocessor/processor'
+    autoload :Writer,    'origen_verilog/preprocessor/writer'
+  end
+
+  # Returns an AST for the given file
+  def self.parse_file(file, options = {})
+    # Evaluates all compiler directives
+    ast = Preprocessor::Parser.parse_file(file).process
+    # Now parse as verilog
+    Verilog::Parser.parse(ast.to_s)
+  end
+end

data/lib/origen_verilog/node.rb

@@ -0,0 +1,115 @@
+require 'ast'
+require 'treetop'
+module OrigenVerilog
+  class Node < ::AST::Node
+    attr_reader :input, :interval, :file
+
+    # Returns the value at the root of an AST node like this:
+    #
+    #   node # => (module-def
+    #               (module-name
+    #                 (SCALAR-ID "Instrument"))
+    #
+    #   node.value  # => "Instrument"
+    #
+    # No error checking is done and the caller is responsible for calling
+    # this only on compatible nodes
+    def value
+      val = children.first
+      val = val.children.first while val.respond_to?(:children)
+      val
+    end
+
+    # Returns the first child node of the given type that is found
+    def find(type)
+      nodes = find_all(type)
+      nodes.first
+    end
+
+    # Returns an array containing all child nodes of the given type(s)
+    def find_all(*types)
+      Extractor.new.process(self, types)
+    end
+
+    def line_number
+      input.line_of(interval.first)
+    end
+
+    def text_value
+      input[interval]
+    end
+
+    def directory
+      if file
+        Pathname.new(file).dirname
+      end
+    end
+
+    protected
+
+    # I'd rather see the true symbol
+    def fancy_type
+      @type
+    end
+  end
+
+  class Extractor
+    include ::AST::Processor::Mixin
+
+    attr_reader :types
+    attr_reader :results
+
+    def process(node, types = nil)
+      if types
+        @types = types
+        @results = []
+        # node = AST::Node.new(:wrapper, node) unless node.respond_to?(:to_ast)
+      end
+      super(node) if node.respond_to?(:to_ast)
+      results
+    end
+
+    def handler_missing(node)
+      @results << node if types.include?(node.type)
+      process_all(node.children)
+    end
+  end
+end
+
+# Some helpers to create the to_ast methods in syntax nodes
+module Treetop
+  def self.origen_verilog_parser=(klass)
+    @origen_verilog_parser = klass
+  end
+
+  def self.origen_verilog_parser
+    @origen_verilog_parser
+  end
+
+  module Runtime
+    class SyntaxNode
+      def n(type, *children)
+        properties = children.pop if children.last.is_a?(Hash)
+        properties ||= {}
+        properties[:input] ||= input
+        properties[:interval] ||= interval
+        properties[:file] ||= file
+        Treetop.origen_verilog_parser.node.new(type, children, properties || {})
+      end
+
+      def elements_to_ast(elmnts = elements)
+        elmnts.map do |e|
+          if e.respond_to?(:to_ast)
+            e.to_ast
+          elsif e.nonterminal? && !e.elements.empty?
+            elements_to_ast(e.elements)
+          end
+        end.compact.flatten
+      end
+
+      def file
+        Treetop.origen_verilog_parser.file
+      end
+    end
+  end
+end

data/lib/origen_verilog/parser.rb

@@ -0,0 +1,43 @@
+require 'treetop'
+require 'origen_verilog/node'
+module OrigenVerilog
+  class Parser
+    def self.parse_file(path, options = {})
+      parse(File.read(path), options.merge(file: path))
+    end
+
+    def self.parse(data, options = {})
+      # This will be appended to all nodes if supplied
+      @file = options[:file]
+      Treetop.origen_verilog_parser = self
+      tree = parser.parse(data)
+
+      # If the AST is nil then there was an error during parsing
+      # we need to report a simple error message to help the user
+      if tree.nil? && !options[:quiet]
+        parser.failure_reason =~ /^(Expected .+) (after|at)/m
+        @last_error_msg = []
+        @last_error_msg << "#{Regexp.last_match(1).gsub("\n", '$NEWLINE')}:" if Regexp.last_match(1)
+        if parser.failure_line >= data.lines.to_a.size
+          @last_error_msg << 'EOF'
+        else
+          @last_error_msg << data.lines.to_a[parser.failure_line - 1].gsub("\t", ' ')
+        end
+        @last_error_msg << "#{'~' * (parser.failure_column - 1)}^"
+        puts "Failed parsing Verilog file: #{file}"
+        puts @last_error_msg
+      end
+      if tree
+        tree.to_ast
+      end
+    end
+
+    def self.last_error_msg
+      @last_error_msg || []
+    end
+
+    def self.file
+      @file
+    end
+  end
+end

data/lib/origen_verilog/preprocessor/node.rb

@@ -0,0 +1,19 @@
+module OrigenVerilog
+  module Preprocessor
+    class Node < OrigenVerilog::Node
+      def process(file = nil, env = {})
+        file, env = nil, file if file.is_a?(Hash)
+        ast = Processor.new.run(self, env)
+        if file
+          Writer.new.run(file, ast)
+        else
+          ast
+        end
+      end
+
+      def to_s
+        Writer.new.to_s(self)
+      end
+    end
+  end
+end

data/lib/origen_verilog/preprocessor/parser.rb

@@ -0,0 +1,19 @@
+require 'treetop'
+module OrigenVerilog
+  module Preprocessor
+    # Responsible for parsing a Verilog file to an AST
+    class Parser < OrigenVerilog::Parser
+      def self.node
+        OrigenVerilog::Preprocessor::Node
+      end
+
+      def self.parser
+        @parser ||= begin
+          require "#{Origen.root!}/grammars/verilog"
+          require "#{Origen.root!}/grammars/preprocessor"
+          GrammarParser.new
+        end
+      end
+    end
+  end
+end

data/lib/origen_verilog/preprocessor/processor.rb

@@ -0,0 +1,115 @@
+module OrigenVerilog
+  module Preprocessor
+    class Processor < OrigenVerilog::Processor
+      def run(ast, env)
+        @env = env
+        process(ast)
+      end
+
+      def on_include(node)
+        path = node.to_a[0]
+        file = path if File.exist?(path)
+        unless file
+          dir = ([Dir.pwd] + Array(env[:source_dirs])).find do |dir|
+            f = File.join(dir, path)
+            File.exist?(f)
+          end
+          file = File.join(dir, path) if dir
+        end
+        unless file
+          puts "The file #{path} could not be found!"
+          puts "#{node.file}:#{node.line_number}"
+          exit 1
+        end
+        inline process(Parser.parse_file(file)).children
+      end
+
+      def on_define(node)
+        n = node.find(:name)
+        name = n.to_a[0]
+        if a = n.find(:arguments)
+          args = a.to_a
+        end
+        if n = node.find(:text)
+          text = n.to_a.first
+        end
+        env[name] = Define.new(name: name, args: args, text: text)
+        nil
+      end
+
+      def on_undef(node)
+        env[node.to_a[0]] = nil
+      end
+
+      def on_ifdef(node)
+        elsif_nodes = node.find_all(:elsif)
+        else_node = node.find(:else)
+        enable, *nodes = *node
+        if node.type == :ifdef ? env[enable] : !env[enable]
+          inline(process_all(nodes))
+        else
+          elsif_nodes.each do |elsif_node|
+            enable, *nodes = *elsif_node
+            if env[enable]
+              return inline(process_all(nodes))
+            end
+          end
+          if else_node
+            inline(process_all(else_node.children))
+          end
+        end
+      end
+      alias_method :on_ifndef, :on_ifdef
+
+      def on_macro_reference(node)
+        if define = env[node.to_a[0]]
+          if a = node.find(:arguments)
+            args = a.to_a
+          end
+          node.updated(:text_block, [define.value(node, args)])
+
+        else
+          puts "A reference has been made to macro #{node.to_a[0]} but it hasn't been defined yet!"
+          puts "#{node.file}:#{node.line_number}"
+          exit 1
+        end
+      end
+
+      def on_else(node)
+        # Do nothing, will be processed by the ifdef handler if required
+      end
+      alias_method :on_elsif, :on_else
+
+      private
+
+      class Define
+        attr_reader :name, :args, :text
+
+        def initialize(options)
+          @name = options[:name]
+          @args = options[:args] || []
+          @text = options[:text]
+        end
+
+        def value(node, arguments)
+          return '' unless text
+          arguments = Array(arguments)
+          unless args.size == arguments.size
+            puts "Macro #{node.to_a[0]} required #{args.size} arguments, but only #{arguments.size} have been given!"
+            puts "#{node.file}:#{node.line_number}"
+            exit 1
+          end
+          t = text
+          args.each_with_index do |a, i|
+            t = t.gsub(a, arguments[i])
+          end
+          t
+        end
+      end
+
+      def env
+        @env
+      end
+    end
+  end
+end

data/lib/origen_verilog/preprocessor/writer.rb

@@ -0,0 +1,35 @@
+module OrigenVerilog
+  module Preprocessor
+    class Writer < OrigenVerilog::Processor
+      # Write the given ast to the given file
+      def run(file, ast)
+        File.open(file, 'w') do |file|
+          @file = file
+          process(ast)
+        end
+      end
+
+      # Write the given ast to a string and returns it
+      def to_s(ast)
+        @file = ''
+        process(ast)
+        @file
+      end
+
+      def on_text_block(node)
+        if f.is_a?(String)
+          f << node.to_a[0]
+        else
+          f.write(node.to_a[0])
+        end
+      end
+      alias_method :on_comment, :on_text_block
+
+      private
+
+      def f
+        @file
+      end
+    end
+  end
+end

data/lib/origen_verilog/processor.rb

@@ -0,0 +1,67 @@
+require 'ast'
+module OrigenVerilog
+  # The base processor, this provides a default handler for
+  # all node types and will not make any changes to the AST,
+  # i.e. an equivalent AST will be returned by the process method.
+  #
+  # Child classes of this should be used to implement additional
+  # processors to modify or otherwise work with the AST.
+  #
+  # @see http://www.rubydoc.info/gems/ast/2.0.0/AST/Processor
+  class Processor
+    include ::AST::Processor::Mixin
+
+    def run(node)
+      process(node)
+    end
+
+    # Override the default implementation of this, to allow arrays
+    # to be returned and when a handler returns nil the node is removed
+    def process(node)
+      return if node.nil?
+      return node unless node.respond_to?(:to_ast)
+
+      node = node.to_ast
+
+      # Invoke a specific handler
+      on_handler = :"on_#{node.type}"
+      if respond_to? on_handler
+        new_node = send on_handler, node
+      else
+        new_node = handler_missing(node)
+      end
+
+      new_node if new_node
+    end
+
+    # Some of our processors remove a wrapping node from the AST, returning
+    # a node of type :inline containing the children which should be inlined.
+    # Here we override the default version of this method to deal with handlers
+    # that return an inline node in place of a regular node.
+    def process_all(nodes)
+      results = []
+      nodes.to_a.each do |node|
+        n = process(node)
+        if n
+          if n.is_a?(Inline)
+            results += n
+          else
+            results << n
+          end
+        end
+      end
+      results
+    end
+
+    def handler_missing(node)
+      node.updated(nil, process_all(node.children))
+    end
+
+    def inline(nodes)
+      Inline.new(nodes)
+    end
+
+    class Inline < ::Array
+    end
+  end
+end

data/lib/origen_verilog/top_level.rb

@@ -0,0 +1,28 @@
+module OrigenVerilog
+  class TopLevel
+    include Origen::TopLevel
+
+    attr_reader :name
+
+    def initialize(options = {})
+      @name = options[:ast].to_a[0]
+
+      options[:ast].pins.each do |node|
+        name = node.to_a.last
+        if node.type == :input_declaration
+          direction = :input
+        elsif node.type == :ouput_declaration
+          direction = :output
+        else
+          direction = :io
+        end
+        if r = node.find(:range)
+          size = r.to_a[0] - r.to_a[1] + 1
+        else
+          size = 1
+        end
+        add_pin name, direction: direction, size: size
+      end
+    end
+  end
+end

data/lib/origen_verilog/verilog/evaluator.rb

@@ -0,0 +1,17 @@
+module OrigenVerilog
+  module Verilog
+    class Evaluator < OrigenVerilog::Processor
+      def run(ast)
+        ast.updated(nil, process_all(ast.children))
+      end
+
+      def on_decimal_number(node)
+        process(node.value)
+      end
+
+      def on_constant_primary(node)
+        process(node.value)
+      end
+    end
+  end
+end

data/lib/origen_verilog/verilog/node.rb

@@ -0,0 +1,48 @@
+module OrigenVerilog
+  module Verilog
+    class Node < OrigenVerilog::Node
+      def process(file = nil, env = {})
+        file, env = nil, file if file.is_a?(Hash)
+        ast = Processor.new.run(self, env)
+        if file
+          Writer.new.run(file, ast)
+        else
+          ast
+        end
+      end
+
+      # Returns an array containing the names of all top-level modules in
+      # the AST
+      def module_names
+        find_all(:module_declaration).map { |n| n.to_a[0] }
+      end
+
+      # Returns an array containing the AST node for all modules in the AST
+      def modules
+        find_all(:module_declaration)
+      end
+
+      # Returns the AST node for the module with the given name
+      def module(name)
+        find_all(:module_declaration).find { |n| n.to_a[0].to_s == name.to_s }
+      end
+
+      # Returns an array containing all input, output and inout AST nodes
+      def pins
+        find_all(:input_declaration, :output_declaration, :inout_declaration)
+      end
+
+      # Evaluates all functions and turns numbers into Ruby literals
+      def evaluate
+        Evaluator.new.run(self)
+      end
+
+      def to_top_level
+        unless type == :module_declaration
+          fail 'Currently only modules support the to_model method'
+        end
+        TopLevel.new(ast: evaluate)
+      end
+    end
+  end
+end

data/lib/origen_verilog/verilog/parser.rb

@@ -0,0 +1,18 @@
+require 'treetop'
+module OrigenVerilog
+  module Verilog
+    # Responsible for parsing a Verilog file to an AST
+    class Parser < OrigenVerilog::Parser
+      def self.node
+        OrigenVerilog::Verilog::Node
+      end
+
+      def self.parser
+        @parser ||= begin
+          require "#{Origen.root!}/grammars/verilog"
+          GrammarParser.new
+        end
+      end
+    end
+  end
+end

data/lib/origen_verilog/verilog/processor.rb

@@ -0,0 +1,16 @@
+module OrigenVerilog
+  module Verilog
+    class Processor < OrigenVerilog::Processor
+      def run(ast, env)
+        @env = env
+        process(ast)
+      end
+
+      private
+
+      def env
+        @env
+      end
+    end
+  end
+end

data/lib/origen_verilog/verilog/writer.rb

@@ -0,0 +1,6 @@
+module OrigenVerilog
+  module Verilog
+    class Writer < OrigenVerilog::Processor
+    end
+  end
+end

data/lib/tasks/origen_verilog.rake

@@ -0,0 +1,6 @@
+# You can define any Rake tasks to support your application here (or in any file
+# ending in .rake in this directory).
+#
+# Rake (Ruby Make) is very useful for creating build scripts, see this short video
+# for a quick introduction:
+# http://railscasts.com/episodes/66-custom-rake-tasks

data/templates/web/index.md.erb

@@ -0,0 +1,37 @@
+% render "layouts/basic.html" do
+
+%# HTML tags can be embedded in mark down files if you want to do specific custom
+%# formatting like this, but in most cases that is not required.
+<h1><%= Origen.app.namespace %> <span style="font-size: 14px">(<%= Origen.app.version %>)</span></h1>
+
+### Purpose
+
+This plugin...
+
+### How To Install
+
+In your Gemfile add:
+
+~~~ruby
+gem "<%= Origen.app.name %>"
+~~~
+
+or if your application is a plugin, then add this to your <code>.gemspec</code>
+
+~~~ruby
+spec.add_runtime_dependency "<%= Origen.app.name %>", ">= <%= Origen.app.version %>"
+~~~
+
+__NOTE:__  In the case of a plugin, you will also need to <code>require '<%= Origen.app.name %>'</code> somewhere in your environment.
+
+
+### How To Use
+
+Add quickstart documentation here...
+
+
+### How To Setup a Development Environment
+
+Describe how a developer would setup a new workspace for this plugin...
+
+% end

data/templates/web/layouts/_basic.html.erb

@@ -0,0 +1,13 @@
+---
+title: <%= options[:title] || Origen.config.name %>
+---
+<%= render "partials/navbar.html", tab: options[:tab] %>
+
+<div class="row">
+%# The markdown attribute is important if you are going to include content written
+%# in markdown, without this is will be included verbatim
+  <div class="span12" markdown="1">
+<%= yield %>    
+
+</div>
+</div>

data/templates/web/partials/_navbar.html.erb

@@ -0,0 +1,20 @@
+<nav class="navbar navbar-inverse navbar-fixed-top">
+  <div class="container">
+    <div class="navbar-header">
+      <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">
+        <span class="sr-only">Toggle navigation</span>
+        <span class="icon-bar"></span>
+        <span class="icon-bar"></span>
+        <span class="icon-bar"></span>
+      </button>
+      <a class="navbar-brand" href="<%= path "/" %>">Home</a>
+    </div>
+    <div id="navbar" class="collapse navbar-collapse">
+      <ul class="nav navbar-nav">
+        <li class="<%= options[:tab] == :api ? 'active' : '' %>"><a href="<%= path "/api/" %>">API</a></li>
+        <li class="<%= options[:tab] == :release ? 'active' : '' %>"><a href="<%= path "/release_notes" %>">Release Notes</a></li>
+      </ul>
+      <%= import "origen/web/logo.html" %>
+    </div><!--/.nav-collapse -->
+  </div>
+</nav>

data/templates/web/release_notes.md.erb

@@ -0,0 +1,5 @@
+% render "layouts/basic.html", tab: :release do
+
+<%= render "#{Origen.root}/doc/history" %>
+
+% end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: origen_verilog
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Stephen McGinty
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- stephen.f.mcginty@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/fix_my_workspace
+- config/application.rb
+- config/boot.rb
+- config/commands.rb
+- config/version.rb
+- lib/origen_verilog.rb
+- lib/origen_verilog/node.rb
+- lib/origen_verilog/parser.rb
+- lib/origen_verilog/preprocessor/node.rb
+- lib/origen_verilog/preprocessor/parser.rb
+- lib/origen_verilog/preprocessor/processor.rb
+- lib/origen_verilog/preprocessor/writer.rb
+- lib/origen_verilog/processor.rb
+- lib/origen_verilog/top_level.rb
+- lib/origen_verilog/verilog/evaluator.rb
+- lib/origen_verilog/verilog/node.rb
+- lib/origen_verilog/verilog/parser.rb
+- lib/origen_verilog/verilog/processor.rb
+- lib/origen_verilog/verilog/writer.rb
+- lib/tasks/origen_verilog.rake
+- templates/web/index.md.erb
+- templates/web/layouts/_basic.html.erb
+- templates/web/partials/_navbar.html.erb
+- templates/web/release_notes.md.erb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.11
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: A parser and generator for Verilog (IEEE 1364)
+test_files: []