2
          
          require 'origen'
        
      
        

          2
          
          require_relative '../config/application.rb'
        
      
        

          
          
          
        
      
        

          2
          
          require 'active_support/concern'
        
      
        

          2
          
          require 'require_all'
        
      
        

          2
          
          require 'pathname'
        
      
        

          2
          
          require 'origen_testers/origen_ext/generator/pattern'
        
      
        

          2
          
          require 'origen_testers/origen_ext/generator/flow'
        
      
        

          2
          
          require 'origen_testers/origen_ext/generator/resources'
        
      
        

          2
          
          require 'origen_testers/origen_ext/application/runner'
        
      
        

          2
          
          require 'origen_testers/origen_ext/generator'
        
      
        

          
          
          
        
      
        

          2
          
          module OrigenTesters
        
      
        

          2
          
            autoload :CommandBasedTester, 'origen_testers/command_based_tester'
        
      
        

          2
          
            autoload :VectorBasedTester,  'origen_testers/vector_based_tester'
        
      
        

          2
          
            autoload :Vector,             'origen_testers/vector'
        
      
        

          2
          
            autoload :VectorPipeline,     'origen_testers/vector_pipeline'
        
      
        

          2
          
            autoload :Interface,          'origen_testers/interface'
        
      
        

          2
          
            autoload :Generator,          'origen_testers/generator'
        
      
        

          2
          
            autoload :Parser,             'origen_testers/parser'
        
      
        

          2
          
            autoload :BasicTestSetups,    'origen_testers/basic_test_setups'
        
      
        

          2
          
            autoload :ProgramGenerators,  'origen_testers/program_generators'
        
      
        

          2
          
            autoload :Flow,               'origen_testers/flow'
        
      
        

          2
          
            autoload :NoInterface,        'origen_testers/no_interface'
        
      
        

          2
          
            autoload :MemoryStyle,        'origen_testers/memory_style'
        
      
        

          2
          
            autoload :ATP,                'origen_testers/atp'
        
      
        

          2
          
            autoload :Charz,              'origen_testers/charz'
        
      
        

          
          
          
        
      
        

          
          
            # not yet autoload :Time,     'origen_testers/time'
        
      
        

          
          
          
        
      
        

          
          
            # The documentation tester model has been removed, but this keeps some
        
      
        

          
          
            # legacy code working e.g. $tester.is_a?(OrigenTesters::Doc)
        
      
        

          2
          
            class Doc
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            def self.program
        
      
        

          
          
              f = "#{Flow::PROGRAM_MODELS_DIR}/#{Origen.target.name}"
        
      
        

          
          
              if File.exist?(f)
        
      
        

          
          
                ATP::Program.load(f)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            require 'origen_testers/decompiler'
        
      
        

          2
          
            extend Decompiler::API
        
      
        

          
          
          end
        
      
        

          2
          
          autoload :ATP, 'origen_testers/atp_deprecation'
        
      
        

          
          
          
        
      
        

          2
          
          require 'origen_testers/igxl_based_tester'
        
      
        

          2
          
          require 'origen_testers/smartest_based_tester'
        
      
        

          2
          
          require 'origen_testers/stil_based_tester'
        
      
        

          2
          
          require 'origen_testers/labview_based_tester'
        
      
        

          2
          
          require 'origen_testers/pattern_compilers'
        
      
        

          2
          
          require 'origen_testers/pattern_compilers/runner'
        
      
        

          
          
          
        
      
        

          2
          
          require 'origen_testers/callback_handlers'
        
      
        

          2
          
          require 'origen_testers/origen_ext/pins/pin'
        
      
        

          2
          
          require 'origen_testers/origen_ext/pins/pin_collection'
        
      
        

          2
          
          require 'origen_testers/origen_ext/pins/timing'
        
      
        

          2
          
          require 'origen_testers/origen_ext/pins/timing/timeset'
        
      
    
  

    

      
        

          2
          
          module OrigenTesters
        
      
        

          
          
            # This module implements the basic set of methods that a tester must have
        
      
        

          
          
            # in order for Origen to talk to it.
        
      
        

          
          
            #
        
      
        

          
          
            # They can be overridden by tester specific classes and who may go on to add
        
      
        

          
          
            # additional methods of their own.
        
      
        

          
          
            #
        
      
        

          
          
            # Essentially this API means that any class that includes Origen::Tester will
        
      
        

          
          
            # function as a tester, although it might not do very much!
        
      
        

          2
          
            module API
        
      
        

          2
          
              attr_accessor :includes
        
      
        

          2
          
              attr_accessor :comment_level
        
      
        

          2
          
              attr_accessor :generating
        
      
        

          
          
          
        
      
        

          
          
              # Get/Set the overlay style
        
      
        

          
          
              #
        
      
        

          
          
              # This method changes the way overlay is handled.
        
      
        

          
          
              # The default value and possible settings is dependent on the individual tester.
        
      
        

          
          
              #
        
      
        

          
          
              # @example
        
      
        

          
          
              #   tester.overlay_style = :label
        
      
        

          2
          
              attr_accessor :overlay_style
        
      
        

          
          
          
        
      
        

          
          
              # Get/Set the capture style
        
      
        

          
          
              #
        
      
        

          
          
              # This method changes the way tester.store() implements the store
        
      
        

          
          
              # The default value and possible settings is dependent on the individual tester.
        
      
        

          
          
              #
        
      
        

          
          
              # @example
        
      
        

          
          
              #   tester.capture_style = :hram
        
      
        

          2
          
              attr_accessor :capture_style
        
      
        

          
          
          
        
      
        

          2
          
              def name
        
      
        

          408
          
                @name || self.class
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def generate?
        
      
        

          568
          
                true
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def generating_pattern?
        
      
        

          
          
                @generating == :pattern
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def generating_program?
        
      
        

          
          
                @generating == :program
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def pat_extension
        
      
        

          2265
          
                @pat_extension || 'txt'
        
      
        

          
          
              end
        
      
        

          2
          
              alias_method :pattern_extension, :pat_extension
        
      
        

          
          
          
        
      
        

          2
          
              def comment_char=(val)
        
      
        

          
          
                @comment_char = val
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def comment_char
        
      
        

          20799
          
                @comment_char || '//'
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def program_comment_char=(val)
        
      
        

          
          
                @program_comment_char = val
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def program_comment_char
        
      
        

          194
          
                @program_comment_char || comment_char
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def pattern_header(*args)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def pattern_footer(*args)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def step_comment_prefix
        
      
        

          3922
          
                @step_comment_prefix || '##'
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def is_vector_based?
        
      
        

          39
          
                return @vector_based if defined?(@vector_based)
        
      
        

          39
          
                true
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def is_command_based?
        
      
        

          
          
                !is_vector_based?
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def j750?
        
      
        

          3387
          
                is_a?(OrigenTesters::IGXLBasedTester::J750)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def j750_hpt?
        
      
        

          210
          
                is_a?(OrigenTesters::IGXLBasedTester::J750_HPT)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def v93k?
        
      
        

          33507
          
                is_a?(OrigenTesters::SmartestBasedTester::V93K)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def ultraflex?
        
      
        

          3110
          
                is_a?(OrigenTesters::IGXLBasedTester::UltraFLEX)
        
      
        

          
          
              end
        
      
        

          2
          
              alias_method :uflex?, :ultraflex?
        
      
        

          
          
          
        
      
        

          2
          
              def igxl?
        
      
        

          6
          
                j750? || j750_hpt? || ultraflex?
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def stil?
        
      
        

          10
          
                is_a?(OrigenTesters::StilBasedTester::Base)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def d10?
        
      
        

          
          
                is_a?(OrigenTesters::StilBasedTester::D10)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def link?
        
      
        

          
          
                !!(self.class.to_s =~ /^OrigenLink::/)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def pxie6570?
        
      
        

          10
          
                is_a?(OrigenTesters::LabVIEWBasedTester::Pxie6570)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def doc?
        
      
        

          2843
          
                false
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def smt7?
        
      
        

          258
          
                v93k? && smt_version.to_s[0] == '7'
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def smt8?
        
      
        

          21424
          
                v93k? && smt_version.to_s[0] == '8'
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def annotate(msg, options = {})
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def diff_friendly_output=(value)
        
      
        

          
          
                @diff_friendly_output = value
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def diff_friendly_output?
        
      
        

          2931
          
                !!@diff_friendly_output
        
      
        

          
          
              end
        
      
        

          2
          
              alias_method :diff_friendly_output, :diff_friendly_output?
        
      
        

          
          
          
        
      
        

          
          
              # Ignore fails on the given pins for the duration of the given block, this
        
      
        

          
          
              # has the effect of temporarily setting the states of the given pins to
        
      
        

          
          
              # don't care.
        
      
        

          2
          
              def ignore_fails(*pins)
        
      
        

          4
          
                pins.each(&:suspend)
        
      
        

          4
          
                yield
        
      
        

          4
          
                pins.each(&:resume)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Output a comment in the pattern, normally you would not call this directly
        
      
        

          
          
              # and instead use these shorthand methods:
        
      
        

          
          
              #   cc "Some comment"
        
      
        

          
          
              #   ss "A single line step comment"
        
      
        

          
          
              #   step_comment do
        
      
        

          
          
              #       cc "A multi line"
        
      
        

          
          
              #       cc "step comment"
        
      
        

          
          
              #   end
        
      
        

          2
          
              def c1(msg, options = {})
        
      
        

          9055
          
                PatSeq.add_thread(msg) unless options[:no_thread_id]
        
      
        

          9055
          
                prefix = comment_char + ' '
        
      
        

          9055
          
                prefix += step_comment_prefix + ' ' if @step_comment_on
        
      
        

          9055
          
                if Origen.tester.generating == :program
        
      
        

          33
          
                  cc_coms = OrigenTesters::Flow.cc_comments
        
      
        

          
          
                  # cc call must be on line directly before test method
        
      
        

          33
          
                  line_number = caller_locations(2, 1)[0].lineno + 1
        
      
        

          33
          
                  unless cc_coms[line_number]
        
      
        

          2
          
                    cc_coms[line_number] = []
        
      
        

          
          
                  end
        
      
        

          33
          
                  cc_coms[line_number] << msg
        
      
        

          
          
                else
        
      
        

          9022
          
                  push_comment(prefix + msg.to_s)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def c2(msg, options = {})
        
      
        

          3124
          
                c1(msg, options)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def pattern_section(msg)
        
      
        

          
          
                if generating_program?
        
      
        

          
          
                  yield
        
      
        

          
          
                else
        
      
        

          
          
                  step_comment(msg)
        
      
        

          
          
                  yield
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def ss(msg = nil)
        
      
        

          802
          
                div = step_comment_prefix.length
        
      
        

          802
          
                div = 1 if div == 0
        
      
        

          802
          
                c1(step_comment_prefix * (70 / div), no_thread_id: true)
        
      
        

          802
          
                @step_comment_on = true
        
      
        

          802
          
                if block_given?
        
      
        

          266
          
                  yield
        
      
        

          
          
                else
        
      
        

          536
          
                  c1(msg)
        
      
        

          
          
                end
        
      
        

          802
          
                @step_comment_on = false
        
      
        

          802
          
                if $_testers_enable_vector_comments
        
      
        

          
          
                  timestamp = " #{execution_time_in_ns}ns #{step_comment_prefix}"
        
      
        

          
          
                  str = step_comment_prefix * (70 / div)
        
      
        

          
          
                  c1(str.sub(/#{step_comment_prefix}{#{timestamp.length - 1}}$/, timestamp), no_thread_id: true)
        
      
        

          
          
                else
        
      
        

          802
          
                  c1(step_comment_prefix * (70 / div), no_thread_id: true)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def snip(number, options = {})
        
      
        

          
          
                yield
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Allows a section to be run without actually generating any vectors. This can be useful
        
      
        

          
          
              # to ensure the pin states end up as they otherwise would have if the section had been run.
        
      
        

          
          
              # Classic example of this is a subroutine pattern, wrap this around a call to the startup
        
      
        

          
          
              # routine to ensure the pin states are as they would have been immediately after the startup.
        
      
        

          
          
              # ==== Example
        
      
        

          
          
              #   # Setup state as if I had run startup without actually doing so
        
      
        

          
          
              #   $tester.inhibit_vectors_and_comments do
        
      
        

          
          
              #       $soc.startup
        
      
        

          
          
              #       $top.startup
        
      
        

          
          
              #   end
        
      
        

          2
          
              def inhibit_vectors_and_comments
        
      
        

          11
          
                inhibit_vectors = @inhibit_vectors
        
      
        

          11
          
                inhibit_comments = @inhibit_comments
        
      
        

          11
          
                @inhibit_vectors = true
        
      
        

          11
          
                @inhibit_comments = true
        
      
        

          11
          
                yield
        
      
        

          11
          
                @inhibit_vectors = inhibit_vectors      # Restore to their initial state
        
      
        

          11
          
                @inhibit_comments = inhibit_comments
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Generate a vector.
        
      
        

          
          
              # Calling this method will generate a vector in the output pattern based on the
        
      
        

          
          
              # current pin states and timeset.
        
      
        

          2
          
              def cycle(options = {})
        
      
        

          
          
                options = {
        
      
        

          51882
          
                  microcode: '',
        
      
        

          
          
                  timeset:   current_timeset,
        
      
        

          
          
                  pin_vals:  current_pin_vals,
        
      
        

          
          
                  repeat:    nil
        
      
        

          
          
                }.merge(options)
        
      
        

          
          
          
        
      
        

          51882
          
                unless timeset.period_in_ns?
        
      
        

          1
          
                  fail "You must supply a period_in_ns to timeset '#{timeset.name}' before you can cycle the tester!"
        
      
        

          
          
                end
        
      
        

          51881
          
                timeset.cycled = true
        
      
        

          51881
          
                if PatSeq.thread
        
      
        

          404
          
                  PatSeq.thread.cycle(options)
        
      
        

          
          
                else
        
      
        

          51477
          
                  if any_clocks_running?
        
      
        

          
          
                    update_running_clocks
        
      
        

          
          
                    if options[:repeat]
        
      
        

          
          
                      slice_repeats(options).each do |slice|
        
      
        

          
          
                        options[:repeat] = slice[0]
        
      
        

          
          
                        delay(options.delete(:repeat), options) do |options|
        
      
        

          
          
                          push_vector(options)
        
      
        

          
          
                        end
        
      
        

          
          
                        slice[1].each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
        
      
        

          
          
                        options[:pin_vals] = current_pin_vals
        
      
        

          
          
                      end
        
      
        

          
          
                      pins_need_toggling.each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
        
      
        

          
          
                    else
        
      
        

          
          
                      push_vector(options)
        
      
        

          
          
                      pins_need_toggling.each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
        
      
        

          
          
                    end
        
      
        

          
          
                  else
        
      
        

          51477
          
                    if options[:repeat]
        
      
        

          1607
          
                      delay(options.delete(:repeat), options) do |options|
        
      
        

          1890
          
                        push_vector(options)
        
      
        

          
          
                      end
        
      
        

          
          
                    else
        
      
        

          49870
          
                      push_vector(options)
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def import_test_time(file, options = {})
        
      
        

          
          
                puts "Sorry but an importer doesn't exist for: #{Origen.tester.class}"
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def any_clocks_running?
        
      
        

          51477
          
                @clocks_running.nil? ? false : @clocks_running.count > 0
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def clocks_running
        
      
        

          
          
                @clocks_running
        
      
        

          
          
              end
        
      
        

          2
          
              alias_method :running_clocks, :clocks_running
        
      
        

          
          
          
        
      
        

          2
          
              def push_running_clock(pin)
        
      
        

          
          
                @clocks_running.nil? ? @clocks_running = { pin.name.to_s => pin } : @clocks_running[pin.name.to_s] = pin
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def pop_running_clock(pin)
        
      
        

          
          
                fail "ERROR: No clocks running, doesn't make sense to pop one" unless any_clocks_running?
        
      
        

          
          
                @clocks_running.delete(pin.name.to_s)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def slice_repeats(options = {})
        
      
        

          
          
                slices = {}
        
      
        

          
          
                repeat_ary = []
        
      
        

          
          
                clocks_running.each do |name, clock_pin|
        
      
        

          
          
                  if clock_pin.next_edge < (cycle_count + options[:repeat])
        
      
        

          
          
                    if clock_pin.respond_to?(:duty_cycles)
        
      
        

          
          
                      d0, d1 = clock_pin.duty_cycles
        
      
        

          
          
                    else
        
      
        

          
          
                      # keep legacy support for older pin_clock styling, supports only 50% duty-cycle
        
      
        

          
          
                      d0 = clock_pin.half_period
        
      
        

          
          
                      d1 = clock_pin.half_period
        
      
        

          
          
                    end
        
      
        

          
          
                    pin_slices = (clock_pin.next_edge..(cycle_count + options[:repeat])).step(d0 + d1).to_a
        
      
        

          
          
                    pin_slices += ((clock_pin.next_edge + d0)..(cycle_count + options[:repeat])).step(d0 + d1).to_a
        
      
        

          
          
                    pin_slices.sort!
        
      
        

          
          
                    pin_slices.insert(0, cycle_count)
        
      
        

          
          
                  else
        
      
        

          
          
                    pin_slices = [cycle_count]
        
      
        

          
          
                  end
        
      
        

          
          
                  pin_slices.each do |cycle|
        
      
        

          
          
                    slices[cycle].nil? ? slices[cycle] = name : slices[cycle] = "#{slices[cycle]},#{name}"
        
      
        

          
          
                  end
        
      
        

          
          
                  slices[cycle_count + options[:repeat]] = '' if pin_slices[-1] != cycle_count + options[:repeat]
        
      
        

          
          
                end
        
      
        

          
          
                slices.keys.sort.each do |edge_cycles|
        
      
        

          
          
                  # puts "Toggle #{slices[edge_cycles]} on #{edge_cycles}"
        
      
        

          
          
                  repeat_ary.push([edge_cycles, slices[edge_cycles].split(',')])
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                (repeat_ary.count - 1).downto(1).each { |i| repeat_ary[i][0] = repeat_ary[i][0] - repeat_ary[i - 1][0] }
        
      
        

          
          
                repeat_ary[1..-1]
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def pins_need_toggling
        
      
        

          
          
                toggle_ary = []
        
      
        

          
          
                clocks_running.each do |name, clock_pin|
        
      
        

          
          
                  toggle_ary.push("#{name}") if clock_pin.next_edge == cycle_count
        
      
        

          
          
                end
        
      
        

          
          
                toggle_ary
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def update_running_clocks
        
      
        

          
          
                clocks_running.each do |name, clock_pin|
        
      
        

          
          
                  clock_pin.update_clock
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def transaction
        
      
        

          
          
                yield
        
      
        

          
          
                true
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def source_memory_config
        
      
        

          37
          
                @source_memory_config ||= {}
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def capture_memory_config
        
      
        

          26
          
                @capture_memory_config ||= {}
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Configure source memory to a non-default setting
        
      
        

          
          
              #
        
      
        

          
          
              # This method changes the way the instruments statement gets rendered
        
      
        

          
          
              # if the tester's source memory is used.
        
      
        

          
          
              #
        
      
        

          
          
              # @example
        
      
        

          
          
              #   tester.source_memory :default do |mem|
        
      
        

          
          
              #     mem.pin :tdi, size: 32, format: :long
        
      
        

          
          
              #   end
        
      
        

          
          
              #
        
      
        

          
          
              # If called without a block, this method will return
        
      
        

          
          
              # the instance of type OrigenTesters::MemoryStyle for
        
      
        

          
          
              # the corresponding memory type
        
      
        

          
          
              #
        
      
        

          
          
              # @example
        
      
        

          
          
              #   mem_style = tester.source_memory(:default)
        
      
        

          
          
              #   mem_style.contained_pins.each do |pin|
        
      
        

          
          
              #     attributes_hash = mem_style.accumulate_attributes(pin)
        
      
        

          
          
              #
        
      
        

          
          
              #   end
        
      
        

          2
          
              def source_memory(type = :default)
        
      
        

          15
          
                type = :subroutine if type == :default
        
      
        

          15
          
                source_memory_config[type] = OrigenTesters::MemoryStyle.new unless source_memory_config.key?(type)
        
      
        

          15
          
                if block_given?
        
      
        

          7
          
                  yield source_memory_config[type]
        
      
        

          
          
                else
        
      
        

          8
          
                  source_memory_config[type]
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Configure capture memory to a non-default setting
        
      
        

          
          
              #
        
      
        

          
          
              # This method changes the way the instruments statement gets rendered
        
      
        

          
          
              # if the tester's capture memory is used.
        
      
        

          
          
              #
        
      
        

          
          
              # @example
        
      
        

          
          
              #   tester.capture_memory :default do |mem|
        
      
        

          
          
              #     mem.pin :tdo, size: 32, format: :long
        
      
        

          
          
              #   end
        
      
        

          
          
              #
        
      
        

          
          
              # If called without a block, this method will return
        
      
        

          
          
              # the instance of type OrigenTesters::MemoryStyle for
        
      
        

          
          
              # the corresponding memory type
        
      
        

          
          
              #
        
      
        

          
          
              # @example
        
      
        

          
          
              #   mem_style = tester.capture_memory(:default)
        
      
        

          
          
              #   if mem_style.contains_pin?(:tdo)
        
      
        

          
          
              #     attributes_hash = mem_style.accumulate_attributes(:tdo)
        
      
        

          
          
              #
        
      
        

          
          
              #   end
        
      
        

          2
          
              def capture_memory(type = :default)
        
      
        

          10
          
                type = :hram if type == :default
        
      
        

          10
          
                capture_memory_config[type] = OrigenTesters::MemoryStyle.new unless capture_memory_config.key?(type)
        
      
        

          10
          
                if block_given?
        
      
        

          6
          
                  yield capture_memory_config[type]
        
      
        

          
          
                else
        
      
        

          4
          
                  capture_memory_config[type]
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          module OrigenTesters::ATP
        
      
        

          2
          
            autoload :Program, 'origen_testers/atp/program'
        
      
        

          2
          
            autoload :Flow, 'origen_testers/atp/flow'
        
      
        

          2
          
            autoload :Processor, 'origen_testers/atp/processor'
        
      
        

          2
          
            autoload :Validator, 'origen_testers/atp/validator'
        
      
        

          2
          
            autoload :Runner, 'origen_testers/atp/runner'
        
      
        

          2
          
            autoload :Formatter, 'origen_testers/atp/formatter'
        
      
        

          2
          
            autoload :Parser, 'origen_testers/atp/parser'
        
      
        

          2
          
            autoload :FlowAPI, 'origen_testers/atp/flow_api'
        
      
        

          
          
          
        
      
        

          2
          
            module AST
        
      
        

          2
          
              autoload :Node, 'origen_testers/atp/ast/node'
        
      
        

          2
          
              autoload :Extractor, 'origen_testers/atp/ast/extractor'
        
      
        

          
          
          
        
      
        

          
          
              # This is a shim to help backwards compatibility with ATP v0
        
      
        

          2
          
              module Builder
        
      
        

          2
          
                class LazyObject < ::BasicObject
        
      
        

          2
          
                  def initialize(&callable)
        
      
        

          2
          
                    @callable = callable
        
      
        

          
          
                  end
        
      
        

          
          
          
        
      
        

          2
          
                  def __target_object__
        
      
        

          
          
                    @__target_object__ ||= @callable.call
        
      
        

          
          
                  end
        
      
        

          
          
          
        
      
        

          2
          
                  def method_missing(method_name, *args, &block)
        
      
        

          
          
                    __target_object__.send(method_name, *args, &block)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Some trickery to lazy load this to fire a deprecation warning if an app references it
        
      
        

          2
          
                CONDITION_KEYS ||= LazyObject.new do
        
      
        

          
          
                  Origen.log.deprecate 'ATP::AST::Builder::CONDITION_KEYS is frozen and is no longer maintained, consider switching to ATP::Flow::CONDITION_KEYS.keys for similar functionality'
        
      
        

          
          
                  [:if_enabled, :enabled, :enable_flag, :enable, :if_enable, :unless_enabled, :not_enabled,
        
      
        

          
          
                   :disabled, :disable, :unless_enable, :if_failed, :unless_passed, :failed, :if_passed,
        
      
        

          
          
                   :unless_failed, :passed, :if_ran, :if_executed, :unless_ran, :unless_executed, :job,
        
      
        

          
          
                   :jobs, :if_job, :if_jobs, :unless_job, :unless_jobs, :if_any_failed, :unless_all_passed,
        
      
        

          
          
                   :if_all_failed, :unless_any_passed, :if_any_passed, :unless_all_failed, :if_all_passed,
        
      
        

          
          
                   :unless_any_failed, :if_flag, :unless_flag, :whenever, :whenever_all, :whenever_any]
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Processors actually modify the AST to clean and optimize the user input
        
      
        

          
          
            # and to implement the flow control API
        
      
        

          2
          
            module Processors
        
      
        

          2
          
              autoload :Condition,    'origen_testers/atp/processors/condition'
        
      
        

          2
          
              autoload :Relationship, 'origen_testers/atp/processors/relationship'
        
      
        

          2
          
              autoload :PreCleaner, 'origen_testers/atp/processors/pre_cleaner'
        
      
        

          2
          
              autoload :Marshal, 'origen_testers/atp/processors/marshal'
        
      
        

          2
          
              autoload :AddIDs, 'origen_testers/atp/processors/add_ids'
        
      
        

          2
          
              autoload :AddSetResult, 'origen_testers/atp/processors/add_set_result'
        
      
        

          2
          
              autoload :FlowID, 'origen_testers/atp/processors/flow_id'
        
      
        

          2
          
              autoload :EmptyBranchRemover, 'origen_testers/atp/processors/empty_branch_remover'
        
      
        

          2
          
              autoload :AppendTo, 'origen_testers/atp/processors/append_to'
        
      
        

          2
          
              autoload :Flattener, 'origen_testers/atp/processors/flattener'
        
      
        

          2
          
              autoload :RedundantConditionRemover, 'origen_testers/atp/processors/redundant_condition_remover'
        
      
        

          2
          
              autoload :ElseRemover, 'origen_testers/atp/processors/else_remover'
        
      
        

          2
          
              autoload :OnPassFailRemover, 'origen_testers/atp/processors/on_pass_fail_remover'
        
      
        

          2
          
              autoload :ApplyPostGroupActions, 'origen_testers/atp/processors/apply_post_group_actions'
        
      
        

          2
          
              autoload :OneFlagPerTest, 'origen_testers/atp/processors/one_flag_per_test'
        
      
        

          2
          
              autoload :FlagOptimizer, 'origen_testers/atp/processors/flag_optimizer'
        
      
        

          2
          
              autoload :AdjacentIfCombiner, 'origen_testers/atp/processors/adjacent_if_combiner'
        
      
        

          2
          
              autoload :ContinueImplementer, 'origen_testers/atp/processors/continue_implementer'
        
      
        

          2
          
              autoload :ExtractSetFlags, 'origen_testers/atp/processors/extract_set_flags'
        
      
        

          2
          
              autoload :SubFlowRemover, 'origen_testers/atp/processors/sub_flow_remover'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Summarizers extract summary data from the given AST
        
      
        

          2
          
            module Summarizers
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Validators are run on the processed AST to check it for common errors or
        
      
        

          
          
            # logical issues that will prevent it being rendered to a test program format
        
      
        

          2
          
            module Validators
        
      
        

          2
          
              autoload :DuplicateIDs, 'origen_testers/atp/validators/duplicate_ids'
        
      
        

          2
          
              autoload :MissingIDs, 'origen_testers/atp/validators/missing_ids'
        
      
        

          2
          
              autoload :Condition, 'origen_testers/atp/validators/condition'
        
      
        

          2
          
              autoload :Jobs, 'origen_testers/atp/validators/jobs'
        
      
        

          2
          
              autoload :Flags, 'origen_testers/atp/validators/flags'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Formatters are run on the processed AST to display the flow or to render
        
      
        

          
          
            # it to a different format
        
      
        

          2
          
            module Formatters
        
      
        

          2
          
              autoload :Basic,   'origen_testers/atp/formatters/basic'
        
      
        

          2
          
              autoload :Datalog, 'origen_testers/atp/formatters/datalog'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Maintains a unique ID counter to ensure that all nodes get a unique ID
        
      
        

          2
          
            def self.next_id
        
      
        

          17915
          
              @next_id ||= 0
        
      
        

          17915
          
              @next_id += 1
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          require 'ast'
        
      
        

          2
          
          module OrigenTesters::ATP
        
      
        

          2
          
            module AST
        
      
        

          2
          
              class Extractor
        
      
        

          2
          
                include ::AST::Processor::Mixin
        
      
        

          
          
          
        
      
        

          2
          
                attr_reader :types
        
      
        

          2
          
                attr_reader :results
        
      
        

          
          
          
        
      
        

          2
          
                def process(node, types = nil)
        
      
        

          9051
          
                  if types
        
      
        

          26
          
                    @types = types
        
      
        

          26
          
                    @results = []
        
      
        

          
          
                    # node = AST::Node.new(:wrapper, node) unless node.respond_to?(:to_ast)
        
      
        

          
          
                  end
        
      
        

          9051
          
                  super(node) if node.respond_to?(:to_ast)
        
      
        

          9051
          
                  results
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          2
          
                def handler_missing(node)
        
      
        

          4920
          
                  @results << node if types.include?(node.type)
        
      
        

          4920
          
                  process_all(node.children)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          require 'ast'
        
      
        

          2
          
          module OrigenTesters::ATP
        
      
        

          2
          
            module AST
        
      
        

          2
          
              class Node < ::AST::Node
        
      
        

          2
          
                attr_reader :file, :line_number, :description, :properties
        
      
        

          2
          
                attr_accessor :id
        
      
        

          
          
          
        
      
        

          2
          
                def initialize(type, children = [], properties = {})
        
      
        

          66540
          
                  @properties = properties
        
      
        

          
          
                  # Always use strings instead of symbols in the AST, makes serializing
        
      
        

          
          
                  # back and forward to a string easier
        
      
        

          435876
          
                  children = children.map { |c| c.is_a?(Symbol) ? c.to_s : c }
        
      
        

          66540
          
                  super type, children, properties
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          2
          
                def _dump(depth)
        
      
        

          
          
                  # this strips the @strip information from the instance
        
      
        

          
          
                  # d = { type: type, children: children, properties: properties }
        
      
        

          18447
          
                  d = { klass:       self.class,
        
      
        

          
          
                        id:          id,
        
      
        

          
          
                        file:        file,
        
      
        

          
          
                        line_number: line_number,
        
      
        

          
          
                        description: description,
        
      
        

          
          
                        type:        type,
        
      
        

          
          
                        children:    Processors::Marshal.new.process_all(children),
        
      
        

          
          
                        properties:  properties
        
      
        

          
          
                      }
        
      
        

          18447
          
                  Marshal.dump(d, depth)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          2
          
                def self._load(str)
        
      
        

          13
          
                  d = Marshal.load(str)
        
      
        

          13
          
                  p = d[:properties]
        
      
        

          13
          
                  p[:id] = d[:id]
        
      
        

          13
          
                  p[:file] = d[:file]
        
      
        

          13
          
                  p[:line_number] = d[:line_number]
        
      
        

          13
          
                  p[:description] = d[:description]
        
      
        

          13
          
                  n = d[:klass].new(d[:type], d[:children], p)
        
      
        

          13
          
                  n
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          2
          
                def source
        
      
        

          11
          
                  if file
        
      
        

          11
          
                    "#{file}:#{line_number}"
        
      
        

          
          
                  else
        
      
        

          
          
                    '<Sorry, lost the source file info, please include an example if you report as a bug>'
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Returns true if the node carries source file data, retrieve it via the source method
        
      
        

          2
          
                def has_source?
        
      
        

          
          
                  !!file
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Create a new node from the given S-expression (a string)
        
      
        

          2
          
                def self.from_sexp(sexp)
        
      
        

          2
          
                  @parser ||= Parser.new
        
      
        

          2
          
                  @parser.string_to_ast(sexp)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Adds an empty node of the given type to the children unless another
        
      
        

          
          
                # node of the same type is already present
        
      
        

          2
          
                def ensure_node_present(type, *child_nodes)
        
      
        

          19394
          
                  if children.any? { |n| n.type == type }
        
      
        

          890
          
                    self
        
      
        

          
          
                  else
        
      
        

          3677
          
                    if !child_nodes.empty?
        
      
        

          51
          
                      node = updated(type, child_nodes)
        
      
        

          
          
                    else
        
      
        

          3626
          
                      node = updated(type, [])
        
      
        

          
          
                    end
        
      
        

          3677
          
                    updated(nil, children + [node])
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # 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
        
      
        

          2
          
                def value
        
      
        

          25599
          
                  val = children.first
        
      
        

          25599
          
                  val = val.children.first while val.respond_to?(:children)
        
      
        

          25599
          
                  val
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Add the given nodes to the children
        
      
        

          2
          
                def add(*nodes)
        
      
        

          564
          
                  updated(nil, children + nodes)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Remove the given nodes (or types) from the children
        
      
        

          2
          
                def remove(*nodes)
        
      
        

          784
          
                  nodes = nodes.map do |node|
        
      
        

          840
          
                    if node.is_a?(Symbol)
        
      
        

          110
          
                      find_all(node)
        
      
        

          
          
                    else
        
      
        

          730
          
                      node
        
      
        

          
          
                    end
        
      
        

          
          
                  end.flatten.compact
        
      
        

          784
          
                  updated(nil, children - nodes)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Returns the first child node of the given type(s) that is found
        
      
        

          2
          
                def find(*types)
        
      
        

          156137
          
                  children.find { |c| types.include?(c.try(:type)) }
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Returns an array containing all child nodes of the given type(s), by default only considering
        
      
        

          
          
                # the immediate children of the node on which this was called.
        
      
        

          
          
                #
        
      
        

          
          
                # To find all children of the given type by recursively searching through all child nodes, pass
        
      
        

          
          
                # recursive: true when calling this method.
        
      
        

          2
          
                def find_all(*types)
        
      
        

          3398
          
                  options = types.pop if types.last.is_a?(Hash)
        
      
        

          3398
          
                  options ||= {}
        
      
        

          3398
          
                  if options[:recursive]
        
      
        

          15
          
                    Extractor.new.process(self, types)
        
      
        

          
          
                  else
        
      
        

          15491
          
                    children.select { |c| types.include?(c.try(:type)) }
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Returns an array containing all flags which are set within the given node
        
      
        

          2
          
                def set_flags
        
      
        

          84
          
                  Processors::ExtractSetFlags.new.run(self)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Returns a copy of node with any sub-flow nodes removed
        
      
        

          2
          
                def excluding_sub_flows
        
      
        

          85
          
                  Processors::SubFlowRemover.new.run(self)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Returns true if the node contains any nodes of the given type(s) or if any
        
      
        

          
          
                # of its children do.
        
      
        

          
          
                # To consider only direct children of this node use: node.find_all(*types).empty?
        
      
        

          2
          
                def contains?(*types)
        
      
        

          7
          
                  !Extractor.new.process(self, types).empty?
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          module OrigenTesters::ATP
        
      
        

          
          
            # Implements the main user API for building and interacting
        
      
        

          
          
            # with an abstract test program
        
      
        

          2
          
            class Flow
        
      
        

          2
          
              attr_reader :program, :name
        
      
        

          
          
          
        
      
        

          
          
              CONDITION_KEYS = {
        
      
        

          2
          
                if_enabled:              :if_enabled,
        
      
        

          
          
                if_enable:               :if_enabled,
        
      
        

          
          
                enabled:                 :if_enabled,
        
      
        

          
          
                enable_flag:             :if_enabled,
        
      
        

          
          
                enable:                  :if_enabled,
        
      
        

          
          
          
        
      
        

          
          
                unless_enabled:          :unless_enabled,
        
      
        

          
          
                not_enabled:             :unless_enabled,
        
      
        

          
          
                disabled:                :unless_enabled,
        
      
        

          
          
                disable:                 :unless_enabled,
        
      
        

          
          
                unless_enable:           :unless_enabled,
        
      
        

          
          
          
        
      
        

          
          
                if_failed:               :if_failed,
        
      
        

          
          
                unless_passed:           :if_failed,
        
      
        

          
          
                failed:                  :if_failed,
        
      
        

          
          
          
        
      
        

          
          
                if_passed:               :if_passed,
        
      
        

          
          
                unless_failed:           :if_passed,
        
      
        

          
          
                passed:                  :if_passed,
        
      
        

          
          
          
        
      
        

          
          
                if_any_failed:           :if_any_failed,
        
      
        

          
          
                unless_all_passed:       :if_any_failed,
        
      
        

          
          
          
        
      
        

          
          
                if_all_failed:           :if_all_failed,
        
      
        

          
          
                unless_any_passed:       :if_all_failed,
        
      
        

          
          
          
        
      
        

          
          
                if_any_passed:           :if_any_passed,
        
      
        

          
          
                unless_all_failed:       :if_any_passed,
        
      
        

          
          
          
        
      
        

          
          
                if_all_passed:           :if_all_passed,
        
      
        

          
          
                unless_any_failed:       :if_all_passed,
        
      
        

          
          
          
        
      
        

          
          
                if_ran:                  :if_ran,
        
      
        

          
          
                if_executed:             :if_ran,
        
      
        

          
          
          
        
      
        

          
          
                unless_ran:              :unless_ran,
        
      
        

          
          
                unless_executed:         :unless_ran,
        
      
        

          
          
          
        
      
        

          
          
                job:                     :if_job,
        
      
        

          
          
                jobs:                    :if_job,
        
      
        

          
          
                if_job:                  :if_job,
        
      
        

          
          
                if_jobs:                 :if_job,
        
      
        

          
          
          
        
      
        

          
          
                unless_job:              :unless_job,
        
      
        

          
          
                unless_jobs:             :unless_job,
        
      
        

          
          
          
        
      
        

          
          
                if_flag:                 :if_flag,
        
      
        

          
          
          
        
      
        

          
          
                unless_flag:             :unless_flag,
        
      
        

          
          
          
        
      
        

          
          
                whenever:                :whenever,
        
      
        

          
          
                whenever_all:            :whenever_all,
        
      
        

          
          
                whenever_any:            :whenever_any,
        
      
        

          
          
          
        
      
        

          
          
                group:                   :group,
        
      
        

          
          
          
        
      
        

          
          
                if_any_site_failed:      :if_any_sites_failed,
        
      
        

          
          
                if_any_sites_failed:     :if_any_sites_failed,
        
      
        

          
          
                unless_all_sites_passed: :if_any_sites_failed,
        
      
        

          
          
          
        
      
        

          
          
                if_all_sites_failed:     :if_all_sites_failed,
        
      
        

          
          
                unless_any_sites_passed: :if_all_sites_failed,
        
      
        

          
          
                unless_any_site_passed:  :if_all_sites_failed,
        
      
        

          
          
          
        
      
        

          
          
                if_any_site_passed:      :if_any_sites_passed,
        
      
        

          
          
                if_any_sites_passed:     :if_any_sites_passed,
        
      
        

          
          
                unless_all_sites_failed: :if_any_sites_passed,
        
      
        

          
          
          
        
      
        

          
          
                if_all_sites_passed:     :if_all_sites_passed,
        
      
        

          
          
                unless_any_sites_failed: :if_all_sites_passed,
        
      
        

          
          
                unless_any_site_failed:  :if_all_sites_passed
        
      
        

          
          
              }
        
      
        

          
          
          
        
      
        

          2
          
              CONDITION_NODE_TYPES = CONDITION_KEYS.values.uniq
        
      
        

          
          
          
        
      
        

          2
          
              RELATIONAL_OPERATORS = [:eq, :ne, :lt, :le, :gt, :ge]
        
      
        

          
          
          
        
      
        

          2
          
              def initialize(program, name = nil, options = {})
        
      
        

          251
          
                name, options = nil, name if name.is_a?(Hash)
        
      
        

          251
          
                @source_file = []
        
      
        

          251
          
                @source_line_number = []
        
      
        

          251
          
                @description = []
        
      
        

          251
          
                @program = program
        
      
        

          251
          
                @name = name
        
      
        

          251
          
                extract_meta!(options) do
        
      
        

          251
          
                  @pipeline = [n1(:flow, n1(:name, name))]
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # @api private
        
      
        

          2
          
              def marshal_dump
        
      
        

          107
          
                [@name, @program, Processors::Marshal.new.process(raw)]
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # @api private
        
      
        

          2
          
              def marshal_load(array)
        
      
        

          
          
                @name, @program, raw = array
        
      
        

          
          
                @pipeline = [raw]
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Returns the raw AST
        
      
        

          2
          
              def raw
        
      
        

          364
          
                n = nil
        
      
        

          364
          
                @pipeline.reverse_each do |node|
        
      
        

          364
          
                  if n
        
      
        

          
          
                    n = node.updated(nil, node.children + [n])
        
      
        

          
          
                  else
        
      
        

          364
          
                    n = node
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          364
          
                n
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Returns a processed/optimized AST, this is the one that should be
        
      
        

          
          
              # used to build and represent the given test flow
        
      
        

          2
          
              def ast(options = {})
        
      
        

          
          
                options = {
        
      
        

          133
          
                  apply_relationships:          true,
        
      
        

          
          
                  # Supply a unique ID to append to all IDs
        
      
        

          
          
                  unique_id:                    nil,
        
      
        

          
          
                  # Set to :smt, or :igxl
        
      
        

          
          
                  optimization:                 :runner,
        
      
        

          
          
                  # When true, will remove set_result nodes in an on_fail branch which contains a continue
        
      
        

          
          
                  implement_continue:           true,
        
      
        

          
          
                  # When false, this will not optimize the use of a flag by nesting a dependent test within
        
      
        

          
          
                  # the parent test's on_fail branch if the on_fail contains a continue
        
      
        

          
          
                  optimize_flags_when_continue: true,
        
      
        

          
          
                  # These options are not intended for application use, but provide the ability to
        
      
        

          
          
                  # turn off certain processors during test cases
        
      
        

          
          
                  add_ids:                      true,
        
      
        

          
          
                  optimize_flags:               true,
        
      
        

          
          
                  one_flag_per_test:            true,
        
      
        

          
          
                  include_sub_flows:            true
        
      
        

          
          
                }.merge(options)
        
      
        

          
          
                ###############################################################################
        
      
        

          
          
                ## Common pre-processing and validation
        
      
        

          
          
                ###############################################################################
        
      
        

          133
          
                ast = Processors::PreCleaner.new.run(raw)
        
      
        

          133
          
                Validators::DuplicateIDs.new(self).run(ast)
        
      
        

          132
          
                Validators::MissingIDs.new(self).run(ast)
        
      
        

          131
          
                Validators::Jobs.new(self).run(ast)
        
      
        

          128
          
                Validators::Flags.new(self).run(ast)
        
      
        

          
          
                # Ensure everything has an ID, this helps later if condition nodes need to be generated
        
      
        

          127
          
                ast = Processors::AddIDs.new.run(ast) if options[:add_ids]
        
      
        

          127
          
                ast = Processors::FlowID.new.run(ast, options[:unique_id]) if options[:unique_id]
        
      
        

          127
          
                ast = Processors::SubFlowRemover.new.run(ast) unless options[:include_sub_flows]
        
      
        

          
          
          
        
      
        

          
          
                ###############################################################################
        
      
        

          
          
                ## Optimization for a C-like flow target, e.g. V93K
        
      
        

          
          
                ###############################################################################
        
      
        

          127
          
                if options[:optimization] == :smt || options[:optimization] == :runner
        
      
        

          
          
                  # This applies all the relationships by setting flags in the referenced test and
        
      
        

          
          
                  # changing all if_passed/failed type nodes to if_flag type nodes
        
      
        

          83
          
                  ast = Processors::Relationship.new.run(ast) if options[:apply_relationships]
        
      
        

          83
          
                  ast = Processors::Condition.new.run(ast)
        
      
        

          83
          
                  unless options[:optimization] == :runner
        
      
        

          58
          
                    ast = Processors::ContinueImplementer.new.run(ast) if options[:implement_continue]
        
      
        

          
          
                  end
        
      
        

          83
          
                  if options[:optimize_flags]
        
      
        

          83
          
                    ast = Processors::FlagOptimizer.new.run(ast, optimize_when_continue: options[:optimize_flags_when_continue])
        
      
        

          
          
                  end
        
      
        

          83
          
                  ast = Processors::AdjacentIfCombiner.new.run(ast)
        
      
        

          
          
          
        
      
        

          
          
                ###############################################################################
        
      
        

          
          
                ## Optimization for a row-based target, e.g. UltraFLEX
        
      
        

          
          
                ###############################################################################
        
      
        

          44
          
                elsif options[:optimization] == :igxl
        
      
        

          
          
                  # Un-nest everything embedded in else nodes
        
      
        

          26
          
                  ast = Processors::ElseRemover.new.run(ast)
        
      
        

          
          
                  # Un-nest everything embedded in on_pass/fail nodes except for binning and
        
      
        

          
          
                  # flag setting
        
      
        

          26
          
                  ast = Processors::OnPassFailRemover.new.run(ast)
        
      
        

          
          
                  # This applies all the relationships by setting flags in the referenced test and
        
      
        

          
          
                  # changing all if_passed/failed type nodes to if_flag type nodes
        
      
        

          26
          
                  ast = Processors::Relationship.new.run(ast) if options[:apply_relationships]
        
      
        

          26
          
                  ast = Processors::Condition.new.run(ast)
        
      
        

          26
          
                  ast = Processors::ApplyPostGroupActions.new.run(ast)
        
      
        

          26
          
                  ast = Processors::OneFlagPerTest.new.run(ast) if options[:one_flag_per_test]
        
      
        

          26
          
                  ast = Processors::RedundantConditionRemover.new.run(ast)
        
      
        

          
          
          
        
      
        

          
          
                ###############################################################################
        
      
        

          
          
                ## Not currently used, more of a test case
        
      
        

          
          
                ###############################################################################
        
      
        

          18
          
                elsif options[:optimization] == :flat
        
      
        

          
          
                  # Un-nest everything embedded in else nodes
        
      
        

          4
          
                  ast = Processors::ElseRemover.new.run(ast)
        
      
        

          
          
                  # Un-nest everything embedded in on_pass/fail nodes except for binning and
        
      
        

          
          
                  # flag setting
        
      
        

          4
          
                  ast = Processors::OnPassFailRemover.new.run(ast)
        
      
        

          4
          
                  ast = Processors::Condition.new.run(ast)
        
      
        

          4
          
                  ast = Processors::Flattener.new.run(ast)
        
      
        

          
          
          
        
      
        

          
          
                ###############################################################################
        
      
        

          
          
                ## Default Optimization
        
      
        

          
          
                ###############################################################################
        
      
        

          
          
                else
        
      
        

          14
          
                  ast = Processors::Condition.new.run(ast)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                ###############################################################################
        
      
        

          
          
                ## Common cleanup
        
      
        

          
          
                ###############################################################################
        
      
        

          
          
                # Removes any empty on_pass and on_fail branches
        
      
        

          127
          
                ast = Processors::EmptyBranchRemover.new.run(ast)
        
      
        

          127
          
                ast
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Indicate the that given flags should be considered volatile (can change at any time), which will
        
      
        

          
          
              # prevent them from been touched by the optimization algorithms
        
      
        

          2
          
              def volatile(*flags)
        
      
        

          10
          
                options = flags.pop if flags.last.is_a?(Hash)
        
      
        

          10
          
                flags = flags.flatten
        
      
        

          10
          
                @pipeline[0] = add_volatile_flags(@pipeline[0], flags)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Indicate the that given flags should keep state between units
        
      
        

          
          
              # prevent them from being in the initialization block
        
      
        

          
          
              # these flags will be the user's responsibility to initialize
        
      
        

          2
          
              def add_global_flag(*flags)
        
      
        

          8
          
                options = flags.pop if flags.last.is_a?(Hash)
        
      
        

          8
          
                flags = flags.flatten
        
      
        

          8
          
                @pipeline[0] = add_global_flag_to_node(@pipeline[0], flags)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Record a description for a bin number
        
      
        

          2
          
              def describe_bin(number, description, options = {})
        
      
        

          2
          
                @pipeline[0] = add_bin_description(@pipeline[0], number, description, type: :hard)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Record a description for a softbin number
        
      
        

          2
          
              def describe_soft_bin(number, description, options = {})
        
      
        

          2
          
                @pipeline[0] = add_bin_description(@pipeline[0], number, description, type: :soft)
        
      
        

          
          
              end
        
      
        

          2
          
              alias_method :describe_softbin, :describe_soft_bin
        
      
        

          
          
          
        
      
        

          
          
              # Group all tests generated within the given block
        
      
        

          
          
              #
        
      
        

          
          
              # @example
        
      
        

          
          
              #   flow.group "RAM Tests" do
        
      
        

          
          
              #     flow.test ...
        
      
        

          
          
              #     flow.test ...
        
      
        

          
          
              #   end
        
      
        

          2
          
              def group(name, options = {}, &block)
        
      
        

          
          
                # The idiomatic way of creating a group in SMT8 is a sub-flow
        
      
        

          242
          
                if tester.try(:smt8?)
        
      
        

          28
          
                  extract_meta!(options) do
        
      
        

          28
          
                    apply_conditions(options) do
        
      
        

          28
          
                      parent, sub_flow = *::Flow._sub_flow(name, options, &block)
        
      
        

          28
          
                      path = sub_flow.output_file.relative_path_from(Origen.file_handler.output_directory)
        
      
        

          28
          
                      ast = sub_flow.atp.raw
        
      
        

          28
          
                      name, *children = *ast
        
      
        

          28
          
                      nodes = [name]
        
      
        

          28
          
                      nodes << id(options[:id]) if options[:id]
        
      
        

          28
          
                      nodes << n1(:path, path.to_s)
        
      
        

          28
          
                      nodes += children
        
      
        

          28
          
                      ast = ast.updated :sub_flow, nodes,
        
      
        

          
          
                                        file:        options.delete(:source_file) || source_file,
        
      
        

          
          
                                        line_number: options.delete(:source_line_number) || source_line_number,
        
      
        

          
          
                                        description: options.delete(:description) || description
        
      
        

          28
          
                      ast
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                else
        
      
        

          214
          
                  extract_meta!(options) do
        
      
        

          214
          
                    apply_conditions(options) do
        
      
        

          214
          
                      children = [n1(:name, name)]
        
      
        

          214
          
                      children << n1(:bypass, options[:bypass]) if options[:bypass]
        
      
        

          214
          
                      if options[:comment] || options[:description] || options[:desc]
        
      
        

          4
          
                        children << n1(:comment, options[:comment] || options[:description] || options[:desc])
        
      
        

          
          
                      end
        
      
        

          214
          
                      children << id(options[:id]) if options[:id]
        
      
        

          214
          
                      children << on_fail(options[:on_fail]) if options[:on_fail]
        
      
        

          214
          
                      children << on_pass(options[:on_pass]) if options[:on_pass]
        
      
        

          214
          
                      g = n(:group, children)
        
      
        

          428
          
                      append_to(g) { yield }
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Add a test line to the flow
        
      
        

          
          
              #
        
      
        

          
          
              # @param [String, Symbol] the name of the test
        
      
        

          
          
              # @param [Hash] options a hash to describe the test's attributes
        
      
        

          
          
              # @option options [Symbol] :id A unique test ID
        
      
        

          
          
              # @option options [String] :description A description of what the test does, usually formatted in markdown
        
      
        

          
          
              # @option options [Hash] :on_fail What action to take if the test fails, e.g. assign a bin
        
      
        

          
          
              # @option options [Hash] :on_pass What action to take if the test passes
        
      
        

          
          
              # @option options [Hash] :conditions What conditions must be met to execute the test
        
      
        

          2
          
              def test(instance, options = {})
        
      
        

          3124
          
                extract_meta!(options) do
        
      
        

          3124
          
                  apply_conditions(options) do
        
      
        

          3124
          
                    if options[:on_fail].is_a?(Proc)
        
      
        

          14
          
                      before_on_fail = options.delete(:on_fail)
        
      
        

          
          
                    end
        
      
        

          3124
          
                    if options[:on_pass].is_a?(Proc)
        
      
        

          8
          
                      before_on_pass = options.delete(:on_pass)
        
      
        

          
          
                    end
        
      
        

          
          
                    # Allows any continue, bin, or soft bin argument passed in at the options top-level to be assumed
        
      
        

          
          
                    # to be the action to take if the test fails
        
      
        

          3124
          
                    if b = options.delete(:bin)
        
      
        

          537
          
                      options[:on_fail] ||= {}
        
      
        

          537
          
                      options[:on_fail][:bin] = b
        
      
        

          
          
                    end
        
      
        

          3124
          
                    if b = options.delete(:bin_description)
        
      
        

          3
          
                      options[:on_fail] ||= {}
        
      
        

          3
          
                      options[:on_fail][:bin_description] = b
        
      
        

          
          
                    end
        
      
        

          3124
          
                    if b = options.delete(:bin_attrs)
        
      
        

          4
          
                      options[:on_fail] ||= {}
        
      
        

          4
          
                      options[:on_fail][:bin_attrs] = b
        
      
        

          
          
                    end
        
      
        

          3124
          
                    if b = options.delete(:softbin) || b = options.delete(:sbin) || b = options.delete(:soft_bin)
        
      
        

          199
          
                      options[:on_fail] ||= {}
        
      
        

          199
          
                      options[:on_fail][:softbin] = b
        
      
        

          
          
                    end
        
      
        

          3124
          
                    if b = options.delete(:softbin_description) || options.delete(:sbin_description) || options.delete(:soft_bin_description)
        
      
        

          2
          
                      options[:on_fail] ||= {}
        
      
        

          2
          
                      options[:on_fail][:softbin_description] = b
        
      
        

          
          
                    end
        
      
        

          3124
          
                    if options.delete(:continue)
        
      
        

          92
          
                      options[:on_fail] ||= {}
        
      
        

          92
          
                      options[:on_fail][:continue] = true
        
      
        

          
          
                    end
        
      
        

          3124
          
                    if options.key?(:delayed)
        
      
        

          1
          
                      options[:on_fail] ||= {}
        
      
        

          1
          
                      options[:on_fail][:delayed] = options.delete(:delayed)
        
      
        

          
          
                    end
        
      
        

          3124
          
                    if f = options.delete(:flag_pass)
        
      
        

          
          
                      options[:on_pass] ||= {}
        
      
        

          
          
                      options[:on_pass][:set_flag] = f
        
      
        

          
          
                    end
        
      
        

          3124
          
                    if f = options.delete(:flag_fail)
        
      
        

          
          
                      options[:on_fail] ||= {}
        
      
        

          
          
                      options[:on_fail][:set_flag] = f
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          3124
          
                    children = [n1(:object, instance)]
        
      
        

          
          
          
        
      
        

          3124
          
                    name = (options[:name] || options[:tname] || options[:test_name])
        
      
        

          3124
          
                    unless name
        
      
        

          
          
                      # Starting in Ruby3 type Symbol responds to name
        
      
        

          3104
          
                      unless instance.is_a?(Symbol)
        
      
        

          2447
          
                        [:name, :tname, :test_name].each do |m|
        
      
        

          7341
          
                          name ||= instance.respond_to?(m) ? instance.send(m) : nil
        
      
        

          
          
                        end
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          3124
          
                    children << n1(:name, name) if name
        
      
        

          
          
          
        
      
        

          3124
          
                    num = (options[:number] || options[:num] || options[:tnum] || options[:test_number])
        
      
        

          3124
          
                    unless num
        
      
        

          492
          
                      [:number, :num, :tnum, :test_number].each do |m|
        
      
        

          1968
          
                        num ||= instance.respond_to?(m) ? instance.send(m) : nil
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          3124
          
                    children << number(num) if num
        
      
        

          
          
          
        
      
        

          3124
          
                    children << id(options[:id]) if options[:id]
        
      
        

          
          
          
        
      
        

          3124
          
                    if levels = options[:level] || options[:levels]
        
      
        

          2
          
                      levels = [levels] unless levels.is_a?(Array)
        
      
        

          2
          
                      levels.each do |l|
        
      
        

          3
          
                        children << level(l[:name], l[:value], l[:unit] || l[:units])
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          3124
          
                    lims = options[:limit] || options[:limits]
        
      
        

          3124
          
                    if lims || options[:lo] || options[:low] || options[:hi] || options[:high]
        
      
        

          1497
          
                      if lims == :none || lims == 'none'
        
      
        

          1
          
                        children << n0(:nolimits)
        
      
        

          
          
                      else
        
      
        

          1496
          
                        lims = Array(lims) unless lims.is_a?(Array)
        
      
        

          1496
          
                        if lo = options[:lo] || options[:low]
        
      
        

          11
          
                          lims << { value: lo, rule: :gte }
        
      
        

          
          
                        end
        
      
        

          1496
          
                        if hi = options[:hi] || options[:high]
        
      
        

          11
          
                          lims << { value: hi, rule: :lte }
        
      
        

          
          
                        end
        
      
        

          1496
          
                        lims.each do |l|
        
      
        

          188
          
                          if l.is_a?(Hash)
        
      
        

          188
          
                            children << n(:limit, [l[:value], l[:rule], l[:unit] || l[:units], l[:selector]])
        
      
        

          
          
                          end
        
      
        

          
          
                        end
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          3124
          
                    if pins = options[:pin] || options[:pins]
        
      
        

          7
          
                      pins = [pins] unless pins.is_a?(Array)
        
      
        

          7
          
                      pins.each do |p|
        
      
        

          8
          
                        if p.is_a?(Hash)
        
      
        

          3
          
                          children << pin(p[:name])
        
      
        

          
          
                        else
        
      
        

          5
          
                          children << pin(p)
        
      
        

          
          
                        end
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          3124
          
                    if pats = options[:pattern] || options[:patterns]
        
      
        

          2
          
                      pats = [pats] unless pats.is_a?(Array)
        
      
        

          2
          
                      pats.each do |p|
        
      
        

          3
          
                        if p.is_a?(Hash)
        
      
        

          1
          
                          children << pattern(p[:name], p[:path])
        
      
        

          
          
                        else
        
      
        

          2
          
                          children << pattern(p)
        
      
        

          
          
                        end
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          3124
          
                    if options[:meta]
        
      
        

          1
          
                      attrs = []
        
      
        

          3
          
                      options[:meta].each { |k, v| attrs << attribute(k, v) }
        
      
        

          1
          
                      children << n(:meta, attrs)
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          3124
          
                    if options[:test_text]
        
      
        

          10
          
                      children << n(:test_text, [options[:test_text]])
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          3124
          
                    if subs = options[:sub_test] || options[:sub_tests]
        
      
        

          6
          
                      subs = [subs] unless subs.is_a?(Array)
        
      
        

          6
          
                      subs.each do |s|
        
      
        

          12
          
                        children << s.updated(:sub_test, nil)
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          3124
          
                    if before_on_fail
        
      
        

          14
          
                      on_fail_node = on_fail(before_on_fail)
        
      
        

          14
          
                      if options[:on_fail]
        
      
        

          1
          
                        on_fail_node = on_fail_node.updated(nil, on_fail_node.children + on_fail(options[:on_fail]).children)
        
      
        

          
          
                      end
        
      
        

          14
          
                      children << on_fail_node
        
      
        

          
          
                    else
        
      
        

          3110
          
                      children << on_fail(options[:on_fail]) if options[:on_fail]
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          3124
          
                    if before_on_pass
        
      
        

          8
          
                      on_pass_node = on_pass(before_on_pass)
        
      
        

          8
          
                      if options[:on_pass]
        
      
        

          
          
                        on_pass_node = on_pass_node.updated(nil, on_pass_node.children + on_pass(options[:on_pass]).children)
        
      
        

          
          
                      end
        
      
        

          8
          
                      children << on_pass_node
        
      
        

          
          
                    else
        
      
        

          3116
          
                      children << on_pass(options[:on_pass]) if options[:on_pass]
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          3124
          
                    children << priority(options[:priority]) if options[:priority]
        
      
        

          
          
          
        
      
        

          3124
          
                    save_conditions
        
      
        

          3124
          
                    n(:test, children)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Equivalent to calling test, but returns a sub_test node instead of adding it to the flow.
        
      
        

          
          
              #
        
      
        

          
          
              # This is a helper to create sub_tests for inclusion in a top-level test node.
        
      
        

          2
          
              def sub_test(instance, options = {})
        
      
        

          24
          
                temp = append_to(n0(:temp)) { test(instance, options) }
        
      
        

          12
          
                temp.children.first.updated(:sub_test, nil)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def sub_flow(flow_node, options = {})
        
      
        

          28
          
                name, *children = *flow_node
        
      
        

          28
          
                if options[:path]
        
      
        

          26
          
                  children = [name] + [n1(:path, options[:path])] + children
        
      
        

          
          
                else
        
      
        

          2
          
                  children = [name] + children
        
      
        

          
          
                end
        
      
        

          28
          
                apply_conditions(options) do
        
      
        

          28
          
                  flow_node.updated(:sub_flow, children)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def add_auxiliary_flow(name, options = {})
        
      
        

          2
          
                if tester.smt8?
        
      
        

          2
          
                  if name.to_s != options[:path].split('.').last.to_s
        
      
        

          
          
                    fail "Auxiliary flow path does not end in '#{name}'. The path instead is '#{options[:path]}'. Please update the path to align with the provided name."
        
      
        

          
          
                  end
        
      
        

          2
          
                  extract_meta!(options) do
        
      
        

          2
          
                    apply_conditions(options) do
        
      
        

          2
          
                      n2(:auxiliary_flow, n1(:name, name), n1(:path, options[:path]))
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                else
        
      
        

          
          
                  fail 'Auxiliary flow API is only usable in SMT8.'
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def bin(number, options = {})
        
      
        

          100
          
                if number.is_a?(Hash)
        
      
        

          
          
                  fail 'The bin number must be passed as the first argument'
        
      
        

          
          
                end
        
      
        

          100
          
                options[:bin_description] ||= options.delete(:description)
        
      
        

          100
          
                extract_meta!(options) do
        
      
        

          100
          
                  apply_conditions(options) do
        
      
        

          100
          
                    options[:type] ||= :fail
        
      
        

          100
          
                    options[:bin] = number
        
      
        

          100
          
                    options[:softbin] ||= options[:soft_bin] || options[:sbin]
        
      
        

          100
          
                    set_result(options[:type], options)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def pass(number, options = {})
        
      
        

          23
          
                if number.is_a?(Hash)
        
      
        

          
          
                  fail 'The bin number must be passed as the first argument'
        
      
        

          
          
                end
        
      
        

          23
          
                options[:type] = :pass
        
      
        

          23
          
                bin(number, options)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def cz(instance, cz_setup, options = {})
        
      
        

          17
          
                extract_meta!(options) do
        
      
        

          17
          
                  apply_conditions(options) do
        
      
        

          17
          
                    node = n1(:cz, cz_setup)
        
      
        

          34
          
                    append_to(node) { test(instance, options) }
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          2
          
              alias_method :characterize, :cz
        
      
        

          
          
          
        
      
        

          
          
              # Append a log message line to the flow
        
      
        

          2
          
              def log(message, options = {})
        
      
        

          718
          
                extract_meta!(options) do
        
      
        

          718
          
                  apply_conditions(options) do
        
      
        

          718
          
                    n1(:log, message.to_s)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Enable a flow control variable
        
      
        

          2
          
              def enable(var, options = {})
        
      
        

          13
          
                extract_meta!(options) do
        
      
        

          13
          
                  apply_conditions(options) do
        
      
        

          13
          
                    n1(:enable, var)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Disable a flow control variable
        
      
        

          2
          
              def disable(var, options = {})
        
      
        

          7
          
                extract_meta!(options) do
        
      
        

          7
          
                  apply_conditions(options) do
        
      
        

          7
          
                    n1(:disable, var)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def set_flag(flag, options = {})
        
      
        

          19
          
                extract_meta!(options) do
        
      
        

          19
          
                  apply_conditions(options) do
        
      
        

          19
          
                    set_flag_node(flag)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def unset_flag(flag, options = {})
        
      
        

          7
          
                extract_meta!(options) do
        
      
        

          7
          
                  apply_conditions(options) do
        
      
        

          7
          
                    unset_flag_node(flag)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def add_flag(flag, options = {})
        
      
        

          13
          
                extract_meta!(options) do
        
      
        

          13
          
                  apply_conditions(options) do
        
      
        

          13
          
                    add_flag_node(flag)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def set(var, val, options = {})
        
      
        

          16
          
                extract_meta!(options) do
        
      
        

          16
          
                  apply_conditions(options) do
        
      
        

          16
          
                    n2(:set, var, val)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Insert explicitly rendered content in to the flow
        
      
        

          2
          
              def render(str, options = {})
        
      
        

          17
          
                extract_meta!(options) do
        
      
        

          17
          
                  apply_conditions(options) do
        
      
        

          17
          
                    n1(:render, str)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def continue(options = {})
        
      
        

          1
          
                extract_meta!(options) do
        
      
        

          1
          
                  apply_conditions(options) do
        
      
        

          1
          
                    n0(:continue)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Execute the given flow in the console
        
      
        

          2
          
              def run(options = {})
        
      
        

          
          
                Formatters::Datalog.run_and_format(ast, options)
        
      
        

          
          
                nil
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Returns true if the test context generated from the supplied options + existing condition
        
      
        

          
          
              # wrappers, is different from that which was applied to the previous test.
        
      
        

          2
          
              def context_changed?(options)
        
      
        

          21
          
                options[:_dont_delete_conditions_] = true
        
      
        

          21
          
                last_conditions != clean_conditions(open_conditions + [extract_conditions(options)])
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def whenever(*expressions, &block)
        
      
        

          9
          
                if expressions.last.is_a?(Hash)
        
      
        

          9
          
                  options = expressions.pop
        
      
        

          
          
                else
        
      
        

          
          
                  options = {}
        
      
        

          
          
                end
        
      
        

          9
          
                flow_control_method(:whenever, expressions, options, &block)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def loop(*args, &block)
        
      
        

          24
          
                unless args[0].keys.include?(:from) && args[0].keys.include?(:to)
        
      
        

          
          
                  fail 'Loop must specify :from, :to'
        
      
        

          
          
                end
        
      
        

          
          
                # assume 1 if :step not provided
        
      
        

          24
          
                unless args[0].keys.include?(:step)
        
      
        

          4
          
                  args[0][:step] = 1
        
      
        

          
          
                end
        
      
        

          
          
                # assume 1 if :test_num_inc not provided
        
      
        

          24
          
                unless args[0].keys.include?(:test_num_inc)
        
      
        

          23
          
                  args[0][:test_num_inc] = 1
        
      
        

          
          
                end
        
      
        

          
          
                # Add node for set of flag to be used for loop
        
      
        

          24
          
                unless args[0][:var].nil?
        
      
        

          23
          
                  unless tester.smt8?
        
      
        

          9
          
                    set(args[0][:var], 0)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          24
          
                extract_meta!(options) do
        
      
        

          24
          
                  apply_conditions(options) do
        
      
        

          
          
                    # always pass 5-element array to loop node to simplify downstream parser
        
      
        

          
          
                    #   element, 'var', will be nil if not specified by loop call
        
      
        

          24
          
                    params = [args[0][:from], args[0][:to], args[0][:step], args[0][:var], args[0][:test_num_inc]]
        
      
        

          
          
          
        
      
        

          24
          
                    node = n(:loop, params)
        
      
        

          48
          
                    node = append_to(node) { block.call }
        
      
        

          24
          
                    node
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              RELATIONAL_OPERATORS.each do |method|
        
      
        

          
          
                define_method method do |*args, &block|
        
      
        

          25
          
                  options = args.pop if args.last.is_a?(Hash)
        
      
        

          25
          
                  unless args.size == 2
        
      
        

          
          
                    fail "Format for relational operation must match: ':<operator>(var1, var2)'"
        
      
        

          
          
                  end
        
      
        

          25
          
                  n2(method.to_sym, args[0], args[1])
        
      
        

          12
          
                end unless method_defined?(method)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Define handlers for all of the flow control block methods, unless a custom one has already
        
      
        

          
          
              # been defined above
        
      
        

          2
          
              CONDITION_KEYS.keys.each do |method|
        
      
        

          
          
                define_method method do |*flags, &block|
        
      
        

          609
          
                  if flags.last.is_a?(Hash)
        
      
        

          609
          
                    options = flags.pop
        
      
        

          
          
                  else
        
      
        

          
          
                    options = {}
        
      
        

          
          
                  end
        
      
        

          609
          
                  if flags.include? nil
        
      
        

          1
          
                    Origen.log.error("Found Nil flag passed to the '#{method}' method, ensure the flag is passed as a String or a Symbol!")
        
      
        

          1
          
                    fail
        
      
        

          
          
                  end
        
      
        

          608
          
                  flags = flags.first if flags.size == 1
        
      
        

          
          
                  # Legacy option provided by OrigenTesters that permits override of a block enable method by passing
        
      
        

          
          
                  # an :or option with a true value
        
      
        

          608
          
                  if (CONDITION_KEYS[method] == :if_enabled || CONDITION_KEYS[method] || :unless_enabled) && options[:or]
        
      
        

          11
          
                    block.call
        
      
        

          
          
                  else
        
      
        

          597
          
                    flow_control_method(CONDITION_KEYS[method], flags, options, &block)
        
      
        

          
          
                  end
        
      
        

          104
          
                end unless method_defined?(method)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def inspect
        
      
        

          
          
                "<OrigenTesters::ATP::Flow:#{object_id} #{name}>"
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def ids(options = {})
        
      
        

          13
          
                OrigenTesters::ATP::AST::Extractor.new.process(raw, [:id]).map { |node| node.to_a[0] }
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              private
        
      
        

          
          
          
        
      
        

          2
          
              def description
        
      
        

          17943
          
                @description.last
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def source_file
        
      
        

          17943
          
                @source_file.last
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def source_line_number
        
      
        

          17943
          
                @source_line_number.last
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def flow_control_method(name, flag, options = {}, &block)
        
      
        

          606
          
                extract_meta!(options) do
        
      
        

          606
          
                  if flag.is_a?(Array)
        
      
        

          111
          
                    if name == :if_passed
        
      
        

          
          
                      fail 'if_passed only accepts one ID, use if_any_passed or if_all_passed for multiple IDs'
        
      
        

          
          
                    end
        
      
        

          111
          
                    if name == :if_failed
        
      
        

          
          
                      fail 'if_failed only accepts one ID, use if_any_failed or if_all_failed for multiple IDs'
        
      
        

          
          
                    end
        
      
        

          111
          
                    if name == :if_any_sites_failed || name == :if_all_sites_failed || name == :if_any_sites_passed || name == :if_all_sites_passed
        
      
        

          
          
                      fail "#{name} currently only accepts one ID, please create a ticket here if you need this functionality: https://github.com/Origen-SDK/origen_testers/issues"
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          606
          
                  apply_conditions(options) do
        
      
        

          606
          
                    if block
        
      
        

          590
          
                      node = n1(name, flag)
        
      
        

          590
          
                      open_conditions << [name, flag]
        
      
        

          1180
          
                      node = append_to(node) { block.call }
        
      
        

          590
          
                      open_conditions.pop
        
      
        

          
          
                    else
        
      
        

          16
          
                      unless options[:then] || options[:else]
        
      
        

          
          
                        fail "You must supply a :then or :else option when calling #{name} like this!"
        
      
        

          
          
                      end
        
      
        

          16
          
                      node = n1(name, flag)
        
      
        

          16
          
                      if options[:then]
        
      
        

          32
          
                        node = append_to(node) { options[:then].call }
        
      
        

          
          
                      end
        
      
        

          16
          
                      if options[:else]
        
      
        

          16
          
                        e = n0(:else)
        
      
        

          32
          
                        e = append_to(e) { options[:else].call }
        
      
        

          16
          
                        node = node.updated(nil, node.children + [e])
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          606
          
                    node
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def apply_conditions(options, node = nil)
        
      
        

          
          
                # Applying the current context, means to append to the same node as the last time, this
        
      
        

          
          
                # means that the next node will pick up the exact same condition context as the previous one
        
      
        

          4954
          
                if options[:context] == :current
        
      
        

          20
          
                  node = yield
        
      
        

          20
          
                  found = false
        
      
        

          20
          
                  @pipeline = @pipeline.map do |parent|
        
      
        

          46
          
                    p = Processors::AppendTo.new
        
      
        

          46
          
                    n = p.run(parent, node, @last_append.id)
        
      
        

          46
          
                    found ||= p.succeeded?
        
      
        

          46
          
                    n
        
      
        

          
          
                  end
        
      
        

          20
          
                  unless found
        
      
        

          
          
                    fail 'The request to apply the current context has failed, this is likely a bug in OrigenTesters::ATP'
        
      
        

          
          
                  end
        
      
        

          20
          
                  node
        
      
        

          
          
                else
        
      
        

          4934
          
                  conditions = extract_conditions(options)
        
      
        

          4934
          
                  open_conditions << conditions
        
      
        

          4934
          
                  node = yield
        
      
        

          4934
          
                  open_conditions.pop
        
      
        

          
          
          
        
      
        

          4934
          
                  update_last_append = !condition_node?(node)
        
      
        

          
          
          
        
      
        

          4934
          
                  conditions.each do |key, value|
        
      
        

          767
          
                    if key == :group
        
      
        

          2
          
                      node = n2(key, n1(:name, value.to_s), node)
        
      
        

          
          
                    else
        
      
        

          765
          
                      node = n2(key, value, node)
        
      
        

          
          
                    end
        
      
        

          767
          
                    if update_last_append
        
      
        

          699
          
                      @last_append = node
        
      
        

          699
          
                      update_last_append = false
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
          
        
      
        

          4934
          
                  append(node)
        
      
        

          4934
          
                  node
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def save_conditions
        
      
        

          3124
          
                @last_conditions = clean_conditions(open_conditions.dup)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def last_conditions
        
      
        

          21
          
                @last_conditions || {}
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def open_conditions
        
      
        

          14193
          
                @open_conditions ||= []
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def clean_conditions(conditions)
        
      
        

          3145
          
                result = {}.with_indifferent_access
        
      
        

          3145
          
                conditions.each do |cond|
        
      
        

          6930
          
                  if cond.is_a?(Array)
        
      
        

          1108
          
                    if cond.size != 2
        
      
        

          
          
                      fail 'Something has gone wrong in OrigenTesters::ATP!'
        
      
        

          
          
                    else
        
      
        

          1108
          
                      result[cond[0]] = cond[1].to_s if cond[1]
        
      
        

          
          
                    end
        
      
        

          
          
                  else
        
      
        

          6517
          
                    cond.each { |k, v| result[k] = v.to_s if v }
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          3145
          
                result
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def extract_conditions(options)
        
      
        

          4955
          
                conditions = {}
        
      
        

          4955
          
                delete_from_options = !options.delete(:_dont_delete_conditions_)
        
      
        

          4955
          
                options.each do |key, value|
        
      
        

          10147
          
                  if CONDITION_KEYS[key]
        
      
        

          773
          
                    options.delete(key) if delete_from_options
        
      
        

          773
          
                    key = CONDITION_KEYS[key]
        
      
        

          773
          
                    if conditions[key] && value
        
      
        

          
          
                      fail "Multiple values assigned to flow condition #{key}" unless conditions[key] == value
        
      
        

          
          
                    else
        
      
        

          773
          
                      conditions[key] = value if value
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          4955
          
                conditions
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def append(node)
        
      
        

          4934
          
                @last_append = @pipeline.last unless condition_node?(node)
        
      
        

          4934
          
                n = @pipeline.pop
        
      
        

          4934
          
                @pipeline << n.updated(nil, n.children + [node])
        
      
        

          4934
          
                @pipeline.last
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Append all nodes generated within the given block to the given node
        
      
        

          
          
              # instead of the top-level flow node
        
      
        

          2
          
              def append_to(node)
        
      
        

          911
          
                @pipeline << node
        
      
        

          911
          
                yield
        
      
        

          911
          
                @pipeline.pop
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def condition_node?(node)
        
      
        

          9868
          
                !!CONDITION_KEYS[node.type]
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def extract_meta!(options)
        
      
        

          5177
          
                @source_file << options.delete(:source_file)
        
      
        

          5177
          
                @source_line_number << options.delete(:source_line_number)
        
      
        

          5177
          
                @description << options.delete(:description)
        
      
        

          5177
          
                yield
        
      
        

          5177
          
                @source_file.pop
        
      
        

          5177
          
                @source_line_number.pop
        
      
        

          5177
          
                @description.pop
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def id(name)
        
      
        

          683
          
                n1(:id, name)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def priority(name)
        
      
        

          1
          
                n1(:priority, name)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def on_fail(options = {})
        
      
        

          619
          
                if options.is_a?(Proc)
        
      
        

          14
          
                  node = n0(:on_fail)
        
      
        

          28
          
                  append_to(node) { options.call }
        
      
        

          
          
                else
        
      
        

          605
          
                  children = []
        
      
        

          605
          
                  if options[:bin] || options[:softbin]
        
      
        

          543
          
                    fail_opts = { bin: options[:bin], softbin: options[:softbin] }
        
      
        

          543
          
                    fail_opts[:bin_description] = options[:bin_description] if options[:bin_description]
        
      
        

          543
          
                    fail_opts[:softbin_description] = options[:softbin_description] if options[:softbin_description]
        
      
        

          543
          
                    fail_opts[:bin_attrs] = options[:bin_attrs] if options[:bin_attrs]
        
      
        

          543
          
                    children << set_result(:fail, fail_opts)
        
      
        

          
          
                  end
        
      
        

          605
          
                  if options[:set_run_flag] || options[:set_flag]
        
      
        

          51
          
                    children << set_flag_node(options[:set_run_flag] || options[:set_flag])
        
      
        

          
          
                  end
        
      
        

          605
          
                  children << n0(:continue) if options[:continue]
        
      
        

          605
          
                  children << n1(:delayed, !!options[:delayed]) if options.key?(:delayed)
        
      
        

          605
          
                  children << n1(:render, options[:render]) if options[:render]
        
      
        

          605
          
                  n(:on_fail, children)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def on_pass(options = {})
        
      
        

          8
          
                if options.is_a?(Proc)
        
      
        

          8
          
                  node = n0(:on_pass)
        
      
        

          16
          
                  append_to(node) { options.call }
        
      
        

          
          
                else
        
      
        

          
          
                  children = []
        
      
        

          
          
                  if options[:bin] || options[:softbin]
        
      
        

          
          
                    pass_opts = { bin: options[:bin], softbin: options[:softbin] }
        
      
        

          
          
                    pass_opts[:bin_description] = options[:bin_description] if options[:bin_description]
        
      
        

          
          
                    pass_opts[:softbin_description] = options[:softbin_description] if options[:softbin_description]
        
      
        

          
          
                    pass_opts[:bin_attrs] = options[:bin_attrs] if options[:bin_attrs]
        
      
        

          
          
                    children << set_result(:pass, pass_opts)
        
      
        

          
          
                  end
        
      
        

          
          
                  if options[:set_run_flag] || options[:set_flag]
        
      
        

          
          
                    children << set_flag_node(options[:set_run_flag] || options[:set_flag])
        
      
        

          
          
                  end
        
      
        

          
          
                  children << n0(:continue) if options[:continue]
        
      
        

          
          
                  children << n1(:render, options[:render]) if options[:render]
        
      
        

          
          
                  n(:on_pass, children)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def pattern(name, path = nil)
        
      
        

          3
          
                if path
        
      
        

          1
          
                  n2(:pattern, name, path)
        
      
        

          
          
                else
        
      
        

          2
          
                  n1(:pattern, name)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def attribute(name, value)
        
      
        

          2
          
                n2(:attribute, name, value)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def level(name, value, units = nil)
        
      
        

          3
          
                if units
        
      
        

          1
          
                  n(:level, [name, value, units])
        
      
        

          
          
                else
        
      
        

          2
          
                  n2(:level, name, value)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def pin(name)
        
      
        

          8
          
                n1(:pin, name)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def set_result(type, options = {})
        
      
        

          643
          
                children = []
        
      
        

          643
          
                children << type
        
      
        

          643
          
                if options[:bin] && options[:bin_description]
        
      
        

          13
          
                  children << n2(:bin, options[:bin], options[:bin_description])
        
      
        

          
          
                else
        
      
        

          630
          
                  children << n1(:bin, options[:bin]) if options[:bin]
        
      
        

          
          
                end
        
      
        

          643
          
                if options[:softbin] && options[:softbin_description]
        
      
        

          2
          
                  children << n2(:softbin, options[:softbin], options[:softbin_description])
        
      
        

          
          
                else
        
      
        

          641
          
                  children << n1(:softbin, options[:softbin]) if options[:softbin]
        
      
        

          
          
                end
        
      
        

          643
          
                if options[:bin_attrs]
        
      
        

          4
          
                  options[:bin_attrs].each do |key, val|
        
      
        

          4
          
                    children << n1(key, val)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          643
          
                n(:set_result, children)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def number(val)
        
      
        

          2720
          
                n1(:number, val.to_i)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def set_flag_node(flag)
        
      
        

          70
          
                n1(:set_flag, flag)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def unset_flag_node(flag)
        
      
        

          7
          
                n1(:unset_flag, flag)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def add_flag_node(flag)
        
      
        

          13
          
                n1(:add_flag, flag)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Ensures the flow ast has a volatile node, then adds the
        
      
        

          
          
              # given flags to it
        
      
        

          2
          
              def add_volatile_flags(node, flags)
        
      
        

          10
          
                name, *nodes = *node
        
      
        

          10
          
                if nodes[0] && nodes[0].type == :volatile
        
      
        

          2
          
                  v = nodes.shift
        
      
        

          
          
                else
        
      
        

          8
          
                  v = n0(:volatile)
        
      
        

          
          
                end
        
      
        

          14
          
                existing = v.children.map { |f| f.type == :flag ? f.value : nil }.compact
        
      
        

          10
          
                new = []
        
      
        

          10
          
                flags.each do |flag|
        
      
        

          13
          
                  new << n1(:flag, flag) unless existing.include?(flag)
        
      
        

          
          
                end
        
      
        

          10
          
                v = v.updated(nil, v.children + new)
        
      
        

          10
          
                node.updated(nil, [name, v] + nodes)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Ensures the flow ast has a global node, then adds the
        
      
        

          
          
              # given flags to it
        
      
        

          2
          
              def add_global_flag_to_node(node, flags)
        
      
        

          8
          
                name, *nodes = *node
        
      
        

          8
          
                if nodes[0] && nodes[0].type == :global
        
      
        

          1
          
                  v = nodes.shift
        
      
        

          
          
                else
        
      
        

          7
          
                  v = n0(:global)
        
      
        

          
          
                end
        
      
        

          10
          
                existing = v.children.map { |f| f.type == :flag ? f.value : nil }.compact
        
      
        

          8
          
                new = []
        
      
        

          8
          
                flags.each do |flag|
        
      
        

          9
          
                  new << n1(:flag, flag) unless existing.include?(flag)
        
      
        

          
          
                end
        
      
        

          8
          
                v = v.updated(nil, v.children + new)
        
      
        

          8
          
                node.updated(nil, [name, v] + nodes)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Ensures the flow ast has a bin descriptions node, then adds the
        
      
        

          
          
              # given description to it
        
      
        

          2
          
              def add_bin_description(node, number, description, options)
        
      
        

          4
          
                @existing_bin_descriptions ||= { soft: {}, hard: {} }
        
      
        

          4
          
                return node if @existing_bin_descriptions[options[:type]][number]
        
      
        

          4
          
                @existing_bin_descriptions[options[:type]][number] = true
        
      
        

          4
          
                name, *nodes = *node
        
      
        

          4
          
                if nodes[0] && nodes[0].type == :volatile
        
      
        

          2
          
                  v = nodes.shift
        
      
        

          
          
                else
        
      
        

          2
          
                  v = nil
        
      
        

          
          
                end
        
      
        

          4
          
                if nodes[0] && nodes[0].type == :bin_descriptions
        
      
        

          2
          
                  d = nodes.shift
        
      
        

          
          
                else
        
      
        

          2
          
                  d = n0(:bin_descriptions)
        
      
        

          
          
                end
        
      
        

          4
          
                d = d.updated(nil, d.children + [n2(options[:type], number, description)])
        
      
        

          4
          
                node.updated(nil, [name, v, d].compact + nodes)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def n(type, children, options = {})
        
      
        

          17915
          
                options[:file] ||= options.delete(:source_file) || source_file
        
      
        

          17915
          
                options[:line_number] ||= options.delete(:source_line_number) || source_line_number
        
      
        

          17915
          
                options[:description] ||= options.delete(:description) || description
        
      
        

          
          
                # Guarantee that each node has a unique meta-ID, in case we need to ever search
        
      
        

          
          
                # for it
        
      
        

          17915
          
                options[:id] = OrigenTesters::ATP.next_id
        
      
        

          17915
          
                OrigenTesters::ATP::AST::Node.new(type, children, options)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def n0(type, options = {})
        
      
        

          165
          
                n(type, [], options)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def n1(type, arg, options = {})
        
      
        

          12106
          
                n(type, [arg], options)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def n2(type, arg1, arg2, options = {})
        
      
        

          834
          
                n(type, [arg1, arg2], options)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end