origen 0.0.1 → 0.0.2

data/lib/origen/generator/pattern.rb

@@ -0,0 +1,356 @@
+module Origen
+  class Generator
+    class Pattern
+      include Comparator
+
+      class DummyIterator
+        def invoke(*_args)
+          yield
+        end
+
+        def enabled?(_options)
+          false
+        end
+      end
+
+      def log
+        Origen.log
+      end
+
+      # Returns the options passed to the current create block
+      def create_options
+        @create_options || {}
+      end
+
+      # The recommended way to create a pattern is to wrap it within a Pattern.create
+      # block, however occasionally the need may arise to manually open and close
+      # a pattern, this method can be used in that case in association with the close
+      # method.
+      #
+      # Pattern iterators are not supported when creating a pattern in this way.
+      def open(options = {})
+        if block_given?
+          create(options) do |*args|
+            yield(*args)
+          end
+        else
+          job.output_file_body = options.delete(:name).to_s if options[:name]
+
+          # Refresh the target to start all settings from scratch each time
+          # This is an easy way to reset all registered values
+          Origen.app.reload_target!(skip_first_time: true)
+
+          # Final call back to the project to allow it to make any pattern name specific
+          # configuration changes
+          Origen.app.listeners_for(:before_pattern).each do |listener|
+            listener.before_pattern(job.output_pattern_filename)
+          end
+
+          # Allow custom pattern postfix
+          unless options[:pat_postfix].to_s.empty?
+            job.output_pattern_filename = job.output_pattern_filename.sub(job.output_postfix + job.output_extension, "_#{options[:pat_postfix]}" + job.output_postfix + job.output_extension)
+          end
+
+          pattern_open(options)
+        end
+      end
+
+      def close(options = {})
+        pattern_close(options)
+      end
+
+      def create(options = {})
+        @create_options = options
+        unless Origen.tester
+          puts 'The current target has not instantiated a tester and pattern generation cannot run.'
+          puts 'Add something like this to your target file:'
+          puts ''
+          puts '  $tester = Origen::Tester::J750.new'
+          puts ''
+          exit 1
+        end
+        Origen.tester.generating = :pattern
+
+        job.output_file_body = options.delete(:name).to_s if options[:name]
+
+        # Order the iterators by the order that their enable keys appear in the options, pad
+        # any missing iterators with a dummy function...
+        iterators = options.map do |key, _val|
+          Origen.app.pattern_iterators.find { |iterator| iterator.key == key }
+        end.compact
+        iterators << DummyIterator.new while iterators.size < 10
+
+        args = []
+
+        # Couldn't get this to work fully dynamically, so hard-coded for 10 custom
+        # iterators for now, should be plenty for any application in the meantime.
+        # Should revisit this when time allows and remove this limitation by changing
+        # this to a recursive structure.
+        iterators[0].invoke(options) do |arg0|
+          args[0] = arg0
+          iterators[1].invoke(options) do |arg1|
+            args[1] = arg1
+            iterators[2].invoke(options) do |arg2|
+              args[2] = arg2
+              iterators[3].invoke(options) do |arg3|
+                args[3] = arg3
+                iterators[4].invoke(options) do |arg4|
+                  args[4] = arg4
+                  iterators[5].invoke(options) do |arg5|
+                    args[5] = arg5
+                    iterators[6].invoke(options) do |arg6|
+                      args[6] = arg6
+                      iterators[7].invoke(options) do |arg7|
+                        args[7] = arg7
+                        iterators[8].invoke(options) do |arg8|
+                          args[8] = arg8
+                          iterators[9].invoke(options) do |arg9|
+                            args[9] = arg9
+                            # Refresh the target to start all settings from scratch each time
+                            # This is an easy way to reset all registered values
+                            Origen.app.reload_target!(skip_first_time: true)
+
+                            # Final call back to the project to allow it to make any pattern name specific
+                            # configuration changes
+                            Origen.app.listeners_for(:before_pattern).each do |listener|
+                              listener.before_pattern(job.output_pattern_filename)
+                            end
+
+                            # Work out the final pattern name based on the current iteration
+                            job.reset_output_pattern_filename
+                            iterators.each_with_index do |iterator, i|
+                              if iterator.enabled?(options)
+                                job.output_pattern_filename =
+                                  iterator.pattern_name.call(job.output_pattern_filename, args[i])
+                              end
+                            end
+
+                            # Allow custom pattern postfix
+                            unless options[:pat_postfix].to_s.empty?
+                              job.output_pattern_filename = job.output_pattern_filename.sub(job.output_postfix + job.output_extension, "_#{options[:pat_postfix]}" + job.output_postfix + job.output_extension)
+                            end
+
+                            pattern_wrapper(iterators, args, options) do
+                              # Call iterator setups, whatever these return are passed to the pattern
+                              yield_items = []
+                              iterators.each_with_index do |iterator, i|
+                                if iterator.enabled?(options)
+                                  yield_items << iterator.setup.call(args[i])
+                                end
+                              end
+
+                              yield(*yield_items)
+                            end
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+        @create_options = nil
+      end # create
+
+      # Split a running Pattern.create block into multiple patterns.
+      #
+      # The output that has been generated up until the point where
+      # this is called will be written and a new pattern will be
+      # opened to contain the remainder of the pattern content
+      # generated by the block.
+      #
+      # Each additional pattern section created by calling this method
+      # will have '_partN' appended to the original pattern name.
+      def split(options = {})
+        @split_counter ||= 0
+        @split_counter += 1
+        name = job.output_file_body
+        pattern_close(options.merge(call_shutdown_callbacks: false))
+        if name =~ /part\d+/
+          name.gsub!(/part\d+/, "part#{@split_counter}")
+        else
+          name = "#{name}_part#{@split_counter}"
+        end
+        job.output_file_body = name
+        pattern_open(options.merge(call_startup_callbacks: false))
+      end
+
+      # This is called before each new pattern source is executed
+      #
+      # @api private
+      def reset
+        $desc = nil  # Clear the description
+      end
+
+      private
+
+      def job
+        # The only time the job is not present should be in a test situation, e.g.
+        # when calling Pattern.create within a spec test
+        Origen.app.current_job || Origen::Generator::Job.new('anonymous', testing: true)
+      end
+
+      def stage
+        Origen.generator.stage
+      end
+
+      def stats
+        Origen.app.stats
+      end
+
+      # Creates a header and footer for the pattern based on the current tester and any supplied options
+      def pattern_wrapper(iterators, args, options = {})
+        options[:iterators] = iterators
+        options[:args] = args
+        pattern_open(options)
+        yield      # Pass control back to the pattern source
+        pattern_close(options)
+      end
+
+      def header
+        Origen.tester.pre_header if Origen.tester.doc?
+        c2 '*' * 75
+        if $desc
+          c2 'DESCRIPTION:'
+          $desc.split(/\n/).each { |line| cc line }
+          c2 '*' * 75
+        end
+        c2 'GENERATED:'
+        c2 "  Time:    #{Origen.launch_time}"
+        c2 "  By:      #{Origen.current_user.name}"
+        c2 "  Command: origen g #{job.requested_pattern} -t #{Origen.target.file.basename}"
+        c2 '*' * 75
+        c2 'ENVIRONMENT:'
+        c2 '  Application'
+        c2 "    Vault:     #{Origen.config.vault}"
+        c2 "    Version:   #{Origen.app.version}"
+        c2 "    Workspace: #{Origen.root}"
+        c2 '  Origen'
+        c2 "    Vault:     #{Origen.vault}"
+        c2 "    Version:   #{Origen.version}"
+        c2 "    Workspace: #{Origen.top}"
+        c2 '*' * 75
+        if Origen.config.pattern_header
+          c2 '*' * 75
+        end
+        Origen.tester.close_text_block if Origen.tester.doc?
+      end
+
+      def pattern_open(options = {})
+        options = {
+          call_startup_callbacks: true
+        }.merge(options)
+
+        iterators = options.delete(:iterators) || []
+
+        args = options.delete(:args)
+
+        if Origen.tester.generate?
+          # Now the pattern name is established delete any existing versions of this pattern
+          # to make it clearer that something has gone wrong if there is an error generating the new one
+          unless job.test?
+            File.delete(job.output_pattern) if File.exist?(job.output_pattern)
+
+            if options[:inhibit]
+              log.info "Generating...  #{job.output_pattern_directory}/#{job.output_pattern_filename}".ljust(50)
+            else
+              log.info "Generating...  #{job.output_pattern_directory}/#{job.output_pattern_filename}".ljust(50)
+            end
+          end
+        end
+
+        Origen.tester.inhibit_comments = job.no_comments? if Origen.tester.respond_to?(:inhibit_comments=)
+
+        stage.reset!
+
+        stage.bank = options[:inhibit] ? :null : :body
+
+        if options.delete(:call_startup_callbacks)
+
+          skip_startup = false
+
+          # Call the iterator startup methods, if any of them return false/nil the standard
+          # startup callbacks will be skipped
+          iterators.each_with_index do |iterator, i|
+            if iterator.enabled?(options)
+              skip_startup = !iterator.startup.call(options, args[i]) || skip_startup
+            end
+          end
+
+          unless skip_startup || options[:skip_startup]
+            # Call startup callbacks
+            Origen.app.listeners_for(:startup).each do |listener|
+              listener.startup(options)
+            end
+          end
+
+        end
+      end
+
+      def pattern_close(options = {})
+        options = {
+          call_shutdown_callbacks: true
+        }.merge(options)
+
+        bank = options[:inhibit] ? :null : :body
+        stage.with_bank bank do
+          if options.delete(:call_shutdown_callbacks) && !options[:skip_shutdown]
+            # Call shutdown callbacks
+            Origen.app.listeners_for(:shutdown, top_level: :last).each do |listener|
+              listener.shutdown(options)
+            end
+          end
+
+          # Now the pattern has run call the render method if the tester uses a template
+          Origen.tester.render_template
+          Origen.tester.render_body
+        end
+
+        bank = options[:inhibit] ? :null : :footer
+        stage.with_bank bank do
+          Origen.tester.pattern_footer(options)
+          Origen.tester.render_footer
+        end
+
+        # Generate the pattern header, do this at the very end so that it can
+        # dynamically pick up what import subs are required and things like that
+        if Origen.tester.generate?
+          bank = options[:inhibit] ? :null : :header
+          stage.with_bank bank do
+            header
+            options[:pattern] = job.output_pattern_filename.sub(job.output_extension, '') # remove output extension
+            Origen.tester.pattern_header(options)
+            Origen.tester.render_header
+          end
+        end
+
+        unless options[:inhibit] || !Origen.tester.generate? || job.test?
+          stats.collect_for_pattern(job.output_pattern) do
+            File.open(job.output_pattern, 'w') do |f|
+              [:header, :body, :footer].each do |section|
+                Origen.tester.format(stage.bank(section), section) do |line|
+                  f.puts line
+                end
+              end
+            end
+          end
+
+          log.info ' '
+          log.info "Pattern vectors: #{stats.number_of_vectors_for(job.output_pattern).to_s.ljust(10)}"
+          log.info 'Execution time'.ljust(15) + ': %.6f' % stats.execution_time_for(job.output_pattern)
+          log.info '----------------------------------------------------------------------'
+          check_for_changes(job.output_pattern, job.reference_pattern)
+          stats.record_pattern_completion(job.output_pattern)
+        end
+
+        if Origen.tester.generate?
+          Origen.app.listeners_for(:pattern_generated).each do |listener|
+            listener.pattern_generated(Pathname.new(job.output_pattern))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/generator/pattern_finder.rb

@@ -0,0 +1,155 @@
+module Origen
+  class Generator
+    # The pattern finder is responsible for finding patterns in the pattern
+    # directory, allowing the user to create any number of pattern files
+    # in any number of sub directories without having to declare them.
+    class PatternFinder
+      def find(name, options)
+        # If the pattern is a fully qualified path to a Ruby file, then just run that:
+        if File.exist?(name) && name.strip =~ /\.rb$/
+          return check(name, options)
+        end
+
+        name = File.basename(name)
+        @requested_pattern = name   # Remember what was originally asked for in case
+        # it needs to be output in an error message
+
+        # Strip the prefix if exists
+        if Origen.config.pattern_prefix && name =~ /^#{Origen.config.pattern_prefix}_/
+          name.gsub!(/^#{Origen.config.pattern_prefix}_/, '')
+        end
+
+        # Strip the extension if present
+        name.gsub!(/\.\w+$/, '')
+
+        # Strip the postfix if exists
+        if Origen.config.pattern_postfix && name =~ /_#{Origen.config.pattern_postfix}$/
+          name.gsub!(/_#{Origen.config.pattern_postfix}$/, '')
+        end
+
+        # Otherwise see what can be found...
+        return :skip unless proceed_with_pattern?(name) # The application has elected not to run this pattern
+
+        pats = matching_patterns(name)
+        # If the pattern is not found in current plugin and current app then look into other included plugins as well
+        if pats.size == 0
+          pats = all_matches(name)
+        end
+
+        if pats.size == 0
+          # If a pattern can't be found see if it is because the real pattern name is actually
+          # a substituted value.
+          # Don't want to do this up front since it is possible that some patterns
+          # will actually have an explicit value in the name.
+          translation = Origen.config.pattern_name_translator(name)
+          if translation
+            if translation.is_a?(Hash)
+              name = translation[:source]
+            else
+              name = translation
+              translation = nil
+            end
+          end
+          return :skip unless proceed_with_pattern?(name) # The application has elected not to run this pattern
+          pats = matching_patterns(name)
+          if pats.size == 0
+            pats = all_matches(name)
+          end
+        end
+
+        # Last chance see if the supplied name works, this could happen if the user normally
+        # substitutes the name in before_pattern but here they have a pattern that
+        # actually includes the bit that is normally sub'd out
+        if pats.size == 0
+          pats = matching_patterns(@requested_pattern)
+          if pats.size == 0
+            pats = all_matches(@requested_pattern)
+          end
+        end
+
+        if pats.size == 0
+          fail "Can't find: #{@requested_pattern}"
+        elsif pats.size > 1
+          ambiguous_error(pats)
+        else
+
+          if translation
+            translation.merge(pattern: check(pats.first, options))
+          else
+            check(pats.first, options)
+          end
+        end
+      end
+
+      def matching_patterns(name)
+        # Remove extension in case it is something else, e.g. .atp
+        name = name.gsub(/\..*$/, '')
+        matches = []
+        # First look into the current plugin
+        if current_plugin_pattern_path
+          matches = Dir.glob("#{current_plugin_pattern_path}/**/#{name}.rb").sort
+          # If the current plugin does  not include the pattern then look into the current app
+          if matches.size == 0
+            matches = Dir.glob("#{pattern_directory}/**/#{name}.rb").sort # <= this does not include symlinks
+          end
+        else
+          matches = Dir.glob("#{pattern_directory}/**/#{name}.rb").sort # <= this does not include symlinks
+        end
+
+        matches
+      end
+
+      def current_plugin_pattern_path
+        if Origen.current_plugin.name && Origen.current_plugin.instance.config.shared
+          File.join Origen.current_plugin.instance.root,
+                    Origen.current_plugin.instance.config.shared[:patterns] || Origen.current_plugin.instance.config.shared[:pattern]
+        end
+      end
+
+      def all_matches(name)
+        name = name.gsub(/\..*$/, '')
+        matches = Dir.glob("#{pattern_directory}/**{,/*/**}/#{name}.rb").sort # Takes symlinks into consideration
+        matches.flatten.uniq
+      end
+
+      def pattern_directory
+        Origen.config.pattern_directory
+      end
+
+      # Check with the application that it wishes to run the given pattern
+      def proceed_with_pattern?(name)
+        Origen.config.proceed_with_pattern(name)
+      end
+
+      def check(path, options = {})
+        file_plugin = Origen.import_manager.path_within_a_plugin(path)
+        if file_plugin
+          if Origen.current_plugin.name
+            if file_plugin == Origen.current_plugin.name
+              return proceed_with_pattern?(path) ? path : :skip
+            elsif !options[:current_plugin]
+              Origen.current_plugin.temporary = file_plugin
+              return proceed_with_pattern?(path) ? path : :skip
+            else
+              puts "The requested pattern is from plugin #{file_plugin} and current system plugin is set to plugin #{Origen.current_plugin.name}!"
+              fail 'Incorrect plugin error!'
+            end
+          else
+            Origen.current_plugin.temporary = file_plugin
+            return proceed_with_pattern?(path) ? path : :skip
+          end
+        else
+          return proceed_with_pattern?(path) ? path : :skip
+        end
+      end
+
+      def ambiguous_error(pats)
+        if Origen.running_locally?
+          Origen.log.info 'The following patterns match:'
+          Origen.log.info pats
+        end
+        fail "Ambiguous name: #{@requested_pattern}"
+      end
+    end
+  end
+end

data/lib/origen/generator/pattern_iterator.rb

@@ -0,0 +1,55 @@
+module Origen
+  class Generator
+    class PatternIterator
+      attr_accessor :key
+
+      def invoke(options, &block)
+        if enabled?(options)
+          @loop.call(options[key], &block)
+        else
+          yield
+        end
+      end
+
+      def loop(&block)
+        @loop = block
+      end
+
+      def setup(&block)
+        if block
+          @setup = block
+        elsif @setup
+          @setup
+        # Setup is optional for an iterator, return something to keep the caller happy
+        else
+          ->(arg) { arg }
+        end
+      end
+
+      def startup(&block)
+        if block
+          @startup = block
+        elsif @startup
+          @startup
+        # Startup is optional for an iterator, return something to keep the caller happy
+        else
+          ->(_options, arg) { arg }
+        end
+      end
+
+      def pattern_name(&block)
+        if block
+          @pattern_name = block
+        elsif @pattern_name
+          @pattern_name
+        else
+          fail "pattern_name must be defined for iterator: #{key}"
+        end
+      end
+
+      def enabled?(options)
+        options.keys.include?(key)
+      end
+    end
+  end
+end

data/lib/origen/generator/renderer.rb

@@ -0,0 +1,113 @@
+module Origen
+  class Generator
+    # Handles the recursive rendering and importing of sub templates
+    # and source files
+    module Renderer
+      def render(file, options = {}, &block)
+        file = Origen.file_handler.clean_path_to_sub_template(file)
+        current_pipeline << { file: file, options: options,
+                              placeholder: placeholder, block: block,
+                              indent: options[:indent] || 0
+                            }
+        if block_given?
+          self.current_buffer += current_pipeline.last[:placeholder] + "\n"
+        end
+        current_pipeline.last[:placeholder]
+      end
+      alias_method :import, :render
+
+      def placeholder
+        @ix ||= 0
+        @ix += 1
+        "_origen_render_placeholder_#{@ix}"
+      end
+
+      def options
+        @current_options ||= {}
+      end
+
+      def pipeline
+        @pipeline ||= []
+        @pipeline << [] if @pipeline.empty?
+        @pipeline
+      end
+
+      def current_pipeline
+        pipeline.last
+      end
+
+      # Insert rendered content into any placeholders
+      def insert(content)
+        while current_pipeline.size > 0
+          current = current_pipeline.pop
+          pipeline << []
+          @current_options = current[:options]
+          self.current_buffer = ''
+          output = compile(current[:file],
+                           sub_template: true,
+                           block:        current[:block]
+                          )
+          if current[:indent] && current[:indent] > 0
+            indent = ' ' * current[:indent]
+            output = output.split("\n").map { |l| indent + l }.join("\n")
+          end
+          @current_options = nil
+          content = insert_content(content, current[:placeholder], output)
+        end
+        pipeline.pop
+        # Always give back a string, this is what existing callers expect
+        #
+        # Possible this could in future run into problems if the whole file cannot be read
+        # into memory, but we can cross that path when we come to it
+        if content.is_a?(Pathname)
+          c = content.read
+          content.delete
+          c
+        else
+          content
+        end
+      end
+
+      def insert_content(current, placeholder, content)
+        # Start using the disk for storing the output rather than memory
+        # once it starts to exceed this length
+        max_length = 1_000_000
+        if current.is_a?(Pathname) || content.is_a?(Pathname) ||
+           ((current.length + content.length) > max_length)
+          unless current.is_a?(Pathname)
+            t = temporary_file
+            t.open('w') { |f| f.puts current }
+            current = t
+          end
+          new = temporary_file
+          new.open('w') do |new_f|
+            current.each_line do |line|
+              if line.strip == placeholder
+                if content.is_a?(Pathname)
+                  content.each_line do |line|
+                    new_f.puts line
+                  end
+                  content.delete
+                else
+                  new_f.puts content.chomp
+                end
+              else
+                new_f.puts line
+              end
+            end
+          end
+          current.delete
+          new
+        else
+          current.sub(/ *#{placeholder}/, content)
+        end
+      end
+
+      # Returns a Pathname to a uniquely named temporary file
+      def temporary_file
+        # Ensure this is unique so that is doesn't clash with parallel compile processes
+        Pathname.new "#{Origen.root}/tmp/compiler_#{Process.pid}_#{Time.now.to_f}"
+      end
+    end
+  end
+end