origen_testers 0.13.1 → 0.13.2

data/lib/origen_testers/igxl_based_tester/base/dc_specsets.rb

@@ -1,98 +1,98 @@
-module OrigenTesters
-  module IGXLBasedTester
-    class Base
-      class DCSpecsets
-        include ::OrigenTesters::Generator
-
-        attr_accessor :dc_specs
-        attr_accessor :dc_specsets
-
-        OUTPUT_PREFIX = 'SpecsDC'
-        # OUTPUT_POSTFIX = 'SpecsDC'
-
-        def initialize # :nodoc:
-          ## Hash Autovivification
-          l = ->(h, k) { h[k] = Hash.new(&l) }
-
-          @dc_specs = []
-          @dc_specsets = Hash.new(&l)
-        end
-
-        # Assigns a DC spec value object to the given variable for this specset
-        #   The attrs hash is expected to defined as follows:
-        #     attrs = {
-        #       specset:  :specset_name,    # if not defined, specset = :default
-        #                                   # Spec selectors that contain both the scope and value of the spec
-        #       nom:      { typ:  1.8 },    # typ is an example of the UFlex scope, nom is the spec selector
-        #       min:      { min:  1.7 },    # Users can defined any number of selectors in this fashion
-        #       max:      { max:  1.9 }
-        #     }
-        def add(spec, attrs = {})
-          attrs = {
-            specset: :default
-          }.merge(attrs)
-
-          specset = attrs.delete(:specset)
-
-          @dc_specs << spec unless @dc_specs.include?(spec)
-
-          attrs.each do |selector, value|
-            @dc_specsets[specset][spec][selector] = value
-          end
-        end
-
-        # Prepare the spec information for file output
-        def format_uflex_dc_spec(data, options = {})
-          options = {
-            spec: nil
-          }.update(options)
-
-          case options[:spec]
-          when /(voh|vol|vt|vcl|vch|vdd)/i
-            spec_type = 'volt'
-          when /(ioh|iol)/i
-            spec_type = 'curr'
-          else
-            spec_type = nil
-          end
-
-          case data
-          when NilClass
-            data_new = 0
-          when Fixnum, Float
-            case
-            when data == 0
-              data_new = data.to_s
-            when data.abs < 1e-6
-              data_new = (data * 1_000_000_000).round(4).to_s + '*nV' if spec_type == 'volt'
-              data_new = (data * 1_000_000_000).round(4).to_s + '*nA' if spec_type == 'curr'
-              data_new = data.to_s if spec_type.nil?
-            when data.abs < 1e-3
-              data_new = (data * 1_000_000).round(4).to_s + '*uV' if spec_type == 'volt'
-              data_new = (data * 1_000_000).round(4).to_s + '*uA' if spec_type == 'curr'
-              data_new = data.to_s if spec_type.nil?
-            when data.abs < 1
-              data_new = data.to_s + '*V' if spec_type == 'volt'
-              data_new = (data * 1_000).round(4).to_s + '*mA' if spec_type == 'curr'
-              data_new = data.to_s if spec_type.nil?
-            else
-              data_new = data.to_s + '*V' if spec_type == 'volt'
-              data_new = data.to_s + '*A' if spec_type == 'curr'
-              data_new = data.to_s if spec_type.nil?
-            end
-            data_new = data_new.gsub(/^/, '=')
-          when String
-            data_new = data.gsub(/^/, '=').gsub(/(\W)([a-zA-Z])/, '\1_\2')
-            # Remove underscores from unit designations
-            data_new.gsub!(/(\W)_(nV|uV|mV|V|nA|uA|mA|A)(\W)/i, '\1\2\3')
-            data_new.gsub!(/(\W)_(nV|uV|mV|V|nA|uA|mA|A)$/i, '\1\2')
-          else
-            Origen.log.error "Unknown class type (#{data.class}) for spec value:  #{data}"
-            fail
-          end
-          data_new
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class DCSpecsets
+        include ::OrigenTesters::Generator
+
+        attr_accessor :dc_specs
+        attr_accessor :dc_specsets
+
+        OUTPUT_PREFIX = 'SpecsDC'
+        # OUTPUT_POSTFIX = 'SpecsDC'
+
+        def initialize # :nodoc:
+          ## Hash Autovivification
+          l = ->(h, k) { h[k] = Hash.new(&l) }
+
+          @dc_specs = []
+          @dc_specsets = Hash.new(&l)
+        end
+
+        # Assigns a DC spec value object to the given variable for this specset
+        #   The attrs hash is expected to defined as follows:
+        #     attrs = {
+        #       specset:  :specset_name,    # if not defined, specset = :default
+        #                                   # Spec selectors that contain both the scope and value of the spec
+        #       nom:      { typ:  1.8 },    # typ is an example of the UFlex scope, nom is the spec selector
+        #       min:      { min:  1.7 },    # Users can defined any number of selectors in this fashion
+        #       max:      { max:  1.9 }
+        #     }
+        def add(spec, attrs = {})
+          attrs = {
+            specset: :default
+          }.merge(attrs)
+
+          specset = attrs.delete(:specset)
+
+          @dc_specs << spec unless @dc_specs.include?(spec)
+
+          attrs.each do |selector, value|
+            @dc_specsets[specset][spec][selector] = value
+          end
+        end
+
+        # Prepare the spec information for file output
+        def format_uflex_dc_spec(data, options = {})
+          options = {
+            spec: nil
+          }.update(options)
+
+          case options[:spec]
+          when /(voh|vol|vt|vcl|vch|vdd)/i
+            spec_type = 'volt'
+          when /(ioh|iol)/i
+            spec_type = 'curr'
+          else
+            spec_type = nil
+          end
+
+          case data
+          when NilClass
+            data_new = 0
+          when Fixnum, Float
+            case
+            when data == 0
+              data_new = data.to_s
+            when data.abs < 1e-6
+              data_new = (data * 1_000_000_000).round(4).to_s + '*nV' if spec_type == 'volt'
+              data_new = (data * 1_000_000_000).round(4).to_s + '*nA' if spec_type == 'curr'
+              data_new = data.to_s if spec_type.nil?
+            when data.abs < 1e-3
+              data_new = (data * 1_000_000).round(4).to_s + '*uV' if spec_type == 'volt'
+              data_new = (data * 1_000_000).round(4).to_s + '*uA' if spec_type == 'curr'
+              data_new = data.to_s if spec_type.nil?
+            when data.abs < 1
+              data_new = data.to_s + '*V' if spec_type == 'volt'
+              data_new = (data * 1_000).round(4).to_s + '*mA' if spec_type == 'curr'
+              data_new = data.to_s if spec_type.nil?
+            else
+              data_new = data.to_s + '*V' if spec_type == 'volt'
+              data_new = data.to_s + '*A' if spec_type == 'curr'
+              data_new = data.to_s if spec_type.nil?
+            end
+            data_new = data_new.gsub(/^/, '=')
+          when String
+            data_new = data.gsub(/^/, '=').gsub(/(\W)([a-zA-Z])/, '\1_\2')
+            # Remove underscores from unit designations
+            data_new.gsub!(/(\W)_(nV|uV|mV|V|nA|uA|mA|A)(\W)/i, '\1\2\3')
+            data_new.gsub!(/(\W)_(nV|uV|mV|V|nA|uA|mA|A)$/i, '\1\2')
+          else
+            Origen.log.error "Unknown class type (#{data.class}) for spec value:  #{data}"
+            fail
+          end
+          data_new
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/base/edge.rb

@@ -1,60 +1,60 @@
-module OrigenTesters
-  module IGXLBasedTester
-    class Base
-      class Edge
-        attr_accessor :d_src, :d_fmt, :d0_edge, :d1_edge, :d2_edge, :d3_edge  # Input pin timing information
-        attr_accessor :c_mode, :c1_edge, :c2_edge                             # Output pin timing information
-        attr_accessor :t_res, :clk_per
-
-        def initialize(options = {}) # :nodoc:
-          options = {
-            d_src:   'PAT',     # source of the channel drive data (e.g. pattern, drive_hi, drive_lo, etc.)
-            d_fmt:   'NR',      # drive data format (NR, RL, RH, etc.)
-            d0_edge: '',        # time at which the input drive is turned on
-            d1_edge: '',        # time of the initial data drive edge
-            d2_edge: '',        # time of the return format data drive edge
-            d3_edge: '',        # time at which the input drive is turned off
-            c_mode:  'Edge',    # output compare mode
-            c1_edge: '',        # time of the initial output compare edge
-            c2_edge: '',        # time of the final output compare edge (window compare)
-            t_res:   'Machine', # timing resolution (possibly ATE-specific)
-            clk_per: ''         # clock period equation - for use with MCG
-          }.merge(options)
-          @d_src    = options[:d_src]
-          @d_fmt    = options[:d_fmt]
-          @d0_edge  = options[:d0_edge]
-          @d1_edge  = options[:d1_edge]
-          @d2_edge  = options[:d2_edge]
-          @d3_edge  = options[:d3_edge]
-          @c_mode   = options[:c_mode]
-          @c1_edge  = options[:c1_edge]
-          @c2_edge  = options[:c2_edge]
-          @t_res    = options[:t_res]
-          @clk_per  = options[:clk_per]
-        end
-
-        def ==(edge)
-          if edge.is_a? Edge
-            d_src == edge.d_src &&
-              d_fmt == edge.d_fmt &&
-              d0_edge == edge.d0_edge &&
-              d1_edge == edge.d1_edge &&
-              d2_edge == edge.d2_edge &&
-              d3_edge == edge.d3_edge &&
-              c_mode == edge.c_mode &&
-              c1_edge == edge.c1_edge &&
-              c2_edge == edge.c2_edge &&
-              t_res == edge.t_res &&
-              clk_per == edge.clk_per
-          else
-            super
-          end
-        end
-
-        def platform
-          Origen.interface.platform
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Edge
+        attr_accessor :d_src, :d_fmt, :d0_edge, :d1_edge, :d2_edge, :d3_edge  # Input pin timing information
+        attr_accessor :c_mode, :c1_edge, :c2_edge                             # Output pin timing information
+        attr_accessor :t_res, :clk_per
+
+        def initialize(options = {}) # :nodoc:
+          options = {
+            d_src:   'PAT',     # source of the channel drive data (e.g. pattern, drive_hi, drive_lo, etc.)
+            d_fmt:   'NR',      # drive data format (NR, RL, RH, etc.)
+            d0_edge: '',        # time at which the input drive is turned on
+            d1_edge: '',        # time of the initial data drive edge
+            d2_edge: '',        # time of the return format data drive edge
+            d3_edge: '',        # time at which the input drive is turned off
+            c_mode:  'Edge',    # output compare mode
+            c1_edge: '',        # time of the initial output compare edge
+            c2_edge: '',        # time of the final output compare edge (window compare)
+            t_res:   'Machine', # timing resolution (possibly ATE-specific)
+            clk_per: ''         # clock period equation - for use with MCG
+          }.merge(options)
+          @d_src    = options[:d_src]
+          @d_fmt    = options[:d_fmt]
+          @d0_edge  = options[:d0_edge]
+          @d1_edge  = options[:d1_edge]
+          @d2_edge  = options[:d2_edge]
+          @d3_edge  = options[:d3_edge]
+          @c_mode   = options[:c_mode]
+          @c1_edge  = options[:c1_edge]
+          @c2_edge  = options[:c2_edge]
+          @t_res    = options[:t_res]
+          @clk_per  = options[:clk_per]
+        end
+
+        def ==(edge)
+          if edge.is_a? Edge
+            d_src == edge.d_src &&
+              d_fmt == edge.d_fmt &&
+              d0_edge == edge.d0_edge &&
+              d1_edge == edge.d1_edge &&
+              d2_edge == edge.d2_edge &&
+              d3_edge == edge.d3_edge &&
+              c_mode == edge.c_mode &&
+              c1_edge == edge.c1_edge &&
+              c2_edge == edge.c2_edge &&
+              t_res == edge.t_res &&
+              clk_per == edge.clk_per
+          else
+            super
+          end
+        end
+
+        def platform
+          Origen.interface.platform
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/base/edges.rb

@@ -1,24 +1,24 @@
-module OrigenTesters
-  module IGXLBasedTester
-    class Base
-      class Edges
-        include ::OrigenTesters::Generator
-
-        attr_accessor :edges
-
-        def initialize(options = {}) # :nodoc:
-          @edges = Hash.new do |h, k|
-            h[k] = {}
-          end
-        end
-
-        # Defines a new Edge object for the category and pin name
-        def add(grp, pin, options = {})
-          grp = grp.to_sym unless grp.is_a? Symbol
-          pin = pin.to_sym unless pin.is_a? Symbol
-          edges[grp][pin] = platform::Edge.new(options)
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Edges
+        include ::OrigenTesters::Generator
+
+        attr_accessor :edges
+
+        def initialize(options = {}) # :nodoc:
+          @edges = Hash.new do |h, k|
+            h[k] = {}
+          end
+        end
+
+        # Defines a new Edge object for the category and pin name
+        def add(grp, pin, options = {})
+          grp = grp.to_sym unless grp.is_a? Symbol
+          pin = pin.to_sym unless pin.is_a? Symbol
+          edges[grp][pin] = platform::Edge.new(options)
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/base/edgeset.rb

@@ -1,39 +1,39 @@
-module OrigenTesters
-  module IGXLBasedTester
-    class Base
-      class Edgeset
-        attr_accessor :period, :t_mode  # Edgeset information
-        attr_accessor :pins
-        attr_accessor :spec_sheet
-        attr_accessor :name
-
-        def initialize(name, pin, edge, attrs = {}) # :nodoc:
-          attrs = {
-            period:     '',        # tester cycle duration
-            t_mode:     '',        # timing mode (possibly ATE-specific)
-            spec_sheet: 'default'  # defines which specset sheet to put variables in (e.g. func, scan) when generating specset files
-          }.merge(attrs)
-          @period     = attrs[:period]
-          @t_mode     = attrs[:t_mode]
-          @spec_sheet = attrs[:spec_sheet]
-          @pins       = { pin => edge }
-          self.name = name
-        end
-
-        # Assigns a timing edge object to the given pin for this edgeset
-        def add_edge(pin, edge)
-          if @pins.key?(pin)
-            Origen.log.error "Pin #{pin} already exists in edgeset"
-            fail
-          else
-            @pins[pin] = edge
-          end
-        end
-
-        def platform
-          Origen.interface.platform
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Edgeset
+        attr_accessor :period, :t_mode  # Edgeset information
+        attr_accessor :pins
+        attr_accessor :spec_sheet
+        attr_accessor :name
+
+        def initialize(name, pin, edge, attrs = {}) # :nodoc:
+          attrs = {
+            period:     '',        # tester cycle duration
+            t_mode:     '',        # timing mode (possibly ATE-specific)
+            spec_sheet: 'default'  # defines which specset sheet to put variables in (e.g. func, scan) when generating specset files
+          }.merge(attrs)
+          @period     = attrs[:period]
+          @t_mode     = attrs[:t_mode]
+          @spec_sheet = attrs[:spec_sheet]
+          @pins       = { pin => edge }
+          self.name = name
+        end
+
+        # Assigns a timing edge object to the given pin for this edgeset
+        def add_edge(pin, edge)
+          if @pins.key?(pin)
+            Origen.log.error "Pin #{pin} already exists in edgeset"
+            fail
+          else
+            @pins[pin] = edge
+          end
+        end
+
+        def platform
+          Origen.interface.platform
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/base/edgesets.rb

@@ -1,130 +1,130 @@
-module OrigenTesters
-  module IGXLBasedTester
-    class Base
-      class Edgesets
-        include ::OrigenTesters::Generator
-
-        attr_accessor :es
-        attr_accessor :es_sheet_pins
-        attr_accessor :ts_basic
-
-        OUTPUT_PREFIX = 'ES'
-        # OUTPUT_POSTFIX = 'ES'
-
-        def initialize(options = {}) # :nodoc:
-          @es       = {}
-          @ts_basic = options[:timeset_basic]
-        end
-
-        def add(esname, pin, edge, options = {})
-          esname = esname.to_sym unless esname.is_a? Symbol
-          pin = pin.to_sym unless pin.is_a? Symbol
-          @es.key?(esname) ? @es[esname].add_edge(pin, edge) : @es[esname] = platform::Edgeset.new(esname, pin, edge, options)
-          @es_sheet_pins = options[:es_sheet_pins] unless @es_sheet_pins
-          @es
-        end
-
-        def finalize(options = {})
-        end
-
-        # Populate an array of pins based on the pin or pingroup
-        def get_pin_objects(grp)
-          pins = []
-          if Origen.top_level.pin(grp).is_a?(Origen::Pins::Pin) ||
-             Origen.top_level.pin(grp).is_a?(Origen::Pins::FunctionProxy)
-            pins << Origen.top_level.pin(grp)
-          elsif Origen.top_level.pin(grp).is_a?(Origen::Pins::PinCollection)
-            Origen.top_level.pin(grp).each do |pin|
-              pins << pin
-            end
-          else
-            Origen.log.error "Could not find pin class: #{grp}  #{Origen.top_level.pin(grp).class}"
-          end
-          pins
-        end
-
-        # Equality check to compare full contents of edge object
-        def edges_eql?(edge1, edge2)
-          edge1 == edge2
-        end
-
-        # Globally modify text within the edge object
-        def gsub_edges!(edge, old_val, new_val)
-          edge.d_src   = edge.d_src.gsub(/#{Regexp.escape(old_val)}/, new_val)
-          edge.d_fmt   = edge.d_fmt.gsub(/#{Regexp.escape(old_val)}/, new_val)
-          edge.d0_edge = edge.d0_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
-          edge.d1_edge = edge.d1_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
-          edge.d2_edge = edge.d2_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
-          edge.d3_edge = edge.d3_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
-          edge.c_mode  = edge.c_mode.gsub(/#{Regexp.escape(old_val)}/, new_val)
-          edge.c1_edge = edge.c1_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
-          edge.c2_edge = edge.c2_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
-          edge.t_res   = edge.t_res.gsub(/#{Regexp.escape(old_val)}/, new_val)
-          edge.clk_per = edge.clk_per.gsub(/#{Regexp.escape(old_val)}/, new_val)
-        end
-
-        # Prepare the edge information for ES/TS file output
-        def format_uflex_edge(data, line_cnt, options = {})
-          options = {
-            no_disable: false
-          }.merge(options)
-
-          if data !~ /^\s*$/
-            data = data.gsub(/^/, '=')
-          end
-          data = data.gsub(/(\W)([a-zA-Z])/, '\1_\2')
-
-          case data
-          when /_d0_edge|_d_on/
-            data = data.gsub(/_d0_edge|_d_on/, "F#{line_cnt}")
-          when /_d1_edge|_d_data/
-            data = data.gsub(/_d1_edge|_d_data/, "G#{line_cnt}")
-          when /_d2_edge|_dret/
-            data = data.gsub(/_d2_edge|_dret/, "H#{line_cnt}")
-          when /_d3_edge|_d_off/
-            data = data.gsub(/_d3_edge|_d_off/, "I#{line_cnt}")
-          when /_c1_edge|_c_open/
-            data = data.gsub(/_c1_edge|_c_open/, "K#{line_cnt}")
-          when /_c2_edge|_c_close/
-            data = data.gsub(/_c2_edge|_c_close/, "L#{line_cnt}")
-          when /^\s*$/
-            options[:no_disable] ? data = '' : data = 'disable'
-          else
-            data
-          end
-        end
-
-        # Prepare the edge information for TSB file output
-        def format_uflex_edge_tsb(data, line_cnt, options = {})
-          options = {
-            no_disable: false
-          }.merge(options)
-
-          if data !~ /^\s*$/
-            data = data.gsub(/^/, '=')
-          end
-          data = data.gsub(/(\W)([a-zA-Z])/, '\1_\2')
-
-          case data
-          when /_d0_edge|_d_on/
-            data = data.gsub(/_d0_edge|_d_on/, "I#{line_cnt}")
-          when /_d1_edge|_d_data/
-            data = data.gsub(/_d1_edge|_d_data/, "J#{line_cnt}")
-          when /_d2_edge|_dret/
-            data = data.gsub(/_d2_edge|_dret/, "K#{line_cnt}")
-          when /_d3_edge|_d_off/
-            data = data.gsub(/_d3_edge|_d_off/, "L#{line_cnt}")
-          when /_c1_edge|_c_open/
-            data = data.gsub(/_c1_edge|_c_open/, "N#{line_cnt}")
-          when /_c2_edge|_c_close/
-            data = data.gsub(/_c2_edge|_c_close/, "O#{line_cnt}")
-          when /^\s*$/
-            options[:no_disable] ? data = '' : data = 'disable'
-          else
-            data
-          end
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Edgesets
+        include ::OrigenTesters::Generator
+
+        attr_accessor :es
+        attr_accessor :es_sheet_pins
+        attr_accessor :ts_basic
+
+        OUTPUT_PREFIX = 'ES'
+        # OUTPUT_POSTFIX = 'ES'
+
+        def initialize(options = {}) # :nodoc:
+          @es       = {}
+          @ts_basic = options[:timeset_basic]
+        end
+
+        def add(esname, pin, edge, options = {})
+          esname = esname.to_sym unless esname.is_a? Symbol
+          pin = pin.to_sym unless pin.is_a? Symbol
+          @es.key?(esname) ? @es[esname].add_edge(pin, edge) : @es[esname] = platform::Edgeset.new(esname, pin, edge, options)
+          @es_sheet_pins = options[:es_sheet_pins] unless @es_sheet_pins
+          @es
+        end
+
+        def finalize(options = {})
+        end
+
+        # Populate an array of pins based on the pin or pingroup
+        def get_pin_objects(grp)
+          pins = []
+          if Origen.top_level.pin(grp).is_a?(Origen::Pins::Pin) ||
+             Origen.top_level.pin(grp).is_a?(Origen::Pins::FunctionProxy)
+            pins << Origen.top_level.pin(grp)
+          elsif Origen.top_level.pin(grp).is_a?(Origen::Pins::PinCollection)
+            Origen.top_level.pin(grp).each do |pin|
+              pins << pin
+            end
+          else
+            Origen.log.error "Could not find pin class: #{grp}  #{Origen.top_level.pin(grp).class}"
+          end
+          pins
+        end
+
+        # Equality check to compare full contents of edge object
+        def edges_eql?(edge1, edge2)
+          edge1 == edge2
+        end
+
+        # Globally modify text within the edge object
+        def gsub_edges!(edge, old_val, new_val)
+          edge.d_src   = edge.d_src.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.d_fmt   = edge.d_fmt.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.d0_edge = edge.d0_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.d1_edge = edge.d1_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.d2_edge = edge.d2_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.d3_edge = edge.d3_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.c_mode  = edge.c_mode.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.c1_edge = edge.c1_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.c2_edge = edge.c2_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.t_res   = edge.t_res.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.clk_per = edge.clk_per.gsub(/#{Regexp.escape(old_val)}/, new_val)
+        end
+
+        # Prepare the edge information for ES/TS file output
+        def format_uflex_edge(data, line_cnt, options = {})
+          options = {
+            no_disable: false
+          }.merge(options)
+
+          if data !~ /^\s*$/
+            data = data.gsub(/^/, '=')
+          end
+          data = data.gsub(/(\W)([a-zA-Z])/, '\1_\2')
+
+          case data
+          when /_d0_edge|_d_on/
+            data = data.gsub(/_d0_edge|_d_on/, "F#{line_cnt}")
+          when /_d1_edge|_d_data/
+            data = data.gsub(/_d1_edge|_d_data/, "G#{line_cnt}")
+          when /_d2_edge|_dret/
+            data = data.gsub(/_d2_edge|_dret/, "H#{line_cnt}")
+          when /_d3_edge|_d_off/
+            data = data.gsub(/_d3_edge|_d_off/, "I#{line_cnt}")
+          when /_c1_edge|_c_open/
+            data = data.gsub(/_c1_edge|_c_open/, "K#{line_cnt}")
+          when /_c2_edge|_c_close/
+            data = data.gsub(/_c2_edge|_c_close/, "L#{line_cnt}")
+          when /^\s*$/
+            options[:no_disable] ? data = '' : data = 'disable'
+          else
+            data
+          end
+        end
+
+        # Prepare the edge information for TSB file output
+        def format_uflex_edge_tsb(data, line_cnt, options = {})
+          options = {
+            no_disable: false
+          }.merge(options)
+
+          if data !~ /^\s*$/
+            data = data.gsub(/^/, '=')
+          end
+          data = data.gsub(/(\W)([a-zA-Z])/, '\1_\2')
+
+          case data
+          when /_d0_edge|_d_on/
+            data = data.gsub(/_d0_edge|_d_on/, "I#{line_cnt}")
+          when /_d1_edge|_d_data/
+            data = data.gsub(/_d1_edge|_d_data/, "J#{line_cnt}")
+          when /_d2_edge|_dret/
+            data = data.gsub(/_d2_edge|_dret/, "K#{line_cnt}")
+          when /_d3_edge|_d_off/
+            data = data.gsub(/_d3_edge|_d_off/, "L#{line_cnt}")
+          when /_c1_edge|_c_open/
+            data = data.gsub(/_c1_edge|_c_open/, "N#{line_cnt}")
+          when /_c2_edge|_c_close/
+            data = data.gsub(/_c2_edge|_c_close/, "O#{line_cnt}")
+          when /^\s*$/
+            options[:no_disable] ? data = '' : data = 'disable'
+          else
+            data
+          end
+        end
+      end
+    end
+  end
+end