cosmos 3.5.1 → 3.5.2

data/lib/cosmos/tools/table_manager/table.rb

@@ -1,70 +1,70 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 Ball Aerospace & Technologies Corp.
-# All Rights Reserved.
-#
-# This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'cosmos'
-require 'cosmos/tools/table_manager/table_item'
-
-module Cosmos
-
-  # Table extends Packet by adding more attributes relative to
-  # displaying binary data in a gui.
-  class Table < Packet
-    attr_accessor :num_rows
-    attr_accessor :num_columns
-    attr_reader :name
-    attr_reader :type
-    attr_reader :table_id
-    attr_reader :filename
-
-    # Constructor for a TableDefinition
-    def initialize(name, description, type, endianness, table_id, filename)
-      super('TABLE', name, endianness, description, '', TableItem)
-      @name = name
-      @type = type
-      @table_id = table_id
-      @filename = filename
-      @num_columns = 0
-      @num_rows = 0
-      @num_columns = 1 if @type == :ONE_DIMENSIONAL
-    end
-
-    # Calls define_item in Packet but also incrememts @num_columns
-    # if this table is a REPEATING table.
-    def create_param(name, bit_offset, bit_size, type, description, range, default, display_type, editable)
-      @num_columns += 1 if @type == :TWO_DIMENSIONAL
-      item = define_item(name, bit_offset, bit_size, type)
-      item.description = description
-      item.range = range
-      item.default = default
-      item.display_type = display_type
-      item.editable = editable
-      item
-    end
-
-    # Calls define_packet_item in GenericPacket to duplicate the passed in packet
-    # item. name_extension is concatenated with the orignal item name to make it
-    # unique.
-    def duplicate_item(item, name_extension, bit_offset)
-      new_item = define_item("#{item.name[0...-1]}#{name_extension}",
-                             bit_offset, item.bit_size, item.data_type, item.array_size,
-                             item.endianness, item.overflow,
-                             item.format_string, item.read_conversion,
-                             item.write_conversion, item.id_value)
-      new_item.description = item.description
-      new_item.range = item.range
-      new_item.display_type = item.display_type
-      new_item.editable = item.editable
-      new_item.states = item.states
-      new_item.constraint = item.constraint
-      new_item
-    end
-  end # class Table
-
-end # module Cosmos
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos'
+require 'cosmos/tools/table_manager/table_item'
+
+module Cosmos
+
+  # Table extends Packet by adding more attributes relative to
+  # displaying binary data in a gui.
+  class Table < Packet
+    attr_accessor :num_rows
+    attr_accessor :num_columns
+    attr_reader :name
+    attr_reader :type
+    attr_reader :table_id
+    attr_reader :filename
+
+    # Constructor for a TableDefinition
+    def initialize(name, description, type, endianness, table_id, filename)
+      super('TABLE', name, endianness, description, '', TableItem)
+      @name = name
+      @type = type
+      @table_id = table_id
+      @filename = filename
+      @num_columns = 0
+      @num_rows = 0
+      @num_columns = 1 if @type == :ONE_DIMENSIONAL
+    end
+
+    # Calls define_item in Packet but also incrememts @num_columns
+    # if this table is a REPEATING table.
+    def create_param(name, bit_offset, bit_size, type, description, range, default, display_type, editable)
+      @num_columns += 1 if @type == :TWO_DIMENSIONAL
+      item = define_item(name, bit_offset, bit_size, type)
+      item.description = description
+      item.range = range
+      item.default = default
+      item.display_type = display_type
+      item.editable = editable
+      item
+    end
+
+    # Calls define_packet_item in GenericPacket to duplicate the passed in packet
+    # item. name_extension is concatenated with the orignal item name to make it
+    # unique.
+    def duplicate_item(item, name_extension, bit_offset)
+      new_item = define_item("#{item.name[0...-1]}#{name_extension}",
+                             bit_offset, item.bit_size, item.data_type, item.array_size,
+                             item.endianness, item.overflow,
+                             item.format_string, item.read_conversion,
+                             item.write_conversion, item.id_value)
+      new_item.description = item.description
+      new_item.range = item.range
+      new_item.display_type = item.display_type
+      new_item.editable = item.editable
+      new_item.states = item.states
+      new_item.constraint = item.constraint
+      new_item
+    end
+  end # class Table
+
+end # module Cosmos

data/lib/cosmos/tools/table_manager/table_config.rb

@@ -1,764 +1,764 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 Ball Aerospace & Technologies Corp.
-# All Rights Reserved.
-#
-# This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'cosmos'
-require 'cosmos/tools/table_manager/table'
-
-module Cosmos
-
-  # TableConfig provides capabilities to read an ascii file that defines the
-  # table parameters in a system and create a set of Tables for each.
-  class TableConfig
-
-    # Constructor for a TableConfig
-    def initialize
-      @ordered_tables = nil
-      @tables = nil
-      @current_name = nil
-      @current_table = nil
-      @current_parameter = nil
-      @cur_bit_offset = 0
-      @default_count = 0
-      @item_definitions = nil
-      @table_names = nil
-    end
-
-    # Processes a file and adds in the tables defined in the file
-    def process(filename)
-      building_generic_conversion = false
-      converted_type = nil
-      converted_bit_size = nil
-      proc_text = ''
-
-      Logger.info "Processing table config in file '#{filename}'"
-
-      unless test ?f, filename
-        Logger.error "File does not exist"
-        raise "ERROR! Table config file #{filename} does not exist!"
-      end
-
-      parser = ConfigParser.new
-      parser.parse_file(filename) do |keyword, parameters|
-        next unless keyword
-        if building_generic_conversion
-          case keyword
-          # Complete a generic conversion
-          when 'GENERIC_READ_CONVERSION_END', 'GENERIC_WRITE_CONVERSION_END', 'CONSTRAINT_END'
-            parser.verify_num_parameters(0, 0, keyword)
-            @current_parameter.read_conversion =
-              GenericConversion.new(proc_text,
-                                    converted_type,
-                                    converted_bit_size) if keyword.include? "READ"
-            @current_parameter.write_conversion =
-              GenericConversion.new(proc_text,
-                                    converted_type,
-                                    converted_bit_size) if keyword.include? "WRITE"
-            @current_parameter.constraint =
-              GenericConversion.new(proc_text,
-                                    converted_type,
-                                    converted_bit_size) if keyword.include? "CONSTRAINT"
-            building_generic_conversion = false
-          # Add the current config.line to the conversion being built
-          else
-            proc_text << parser.line << "\n"
-          end # case keyword
-
-        else # not building generic conversion
-
-          case keyword
-          # Start the definition of a generic conversion.
-          # All config.lines following this config.line are considered part
-          # of the conversion until an end of conversion marker is found
-          when 'GENERIC_READ_CONVERSION_START', 'GENERIC_WRITE_CONVERSION_START', 'CONSTRAINT_START'
-            usage = "#{keyword} <Converted Type (optional)> <Converted Bit Size (optional)>"
-            parser.verify_num_parameters(0, 2, usage)
-            proc_text = ''
-            building_generic_conversion = true
-            converted_type = nil
-            converted_bit_size = nil
-            if parameters[0]
-              converted_type = parameters[0].upcase.intern
-              raise parser.error("Invalid converted_type: #{converted_type}.") unless [:INT, :UINT, :FLOAT, :STRING, :BLOCK].include? converted_type
-            end
-            converted_bit_size = Integer(parameters[1]) if parameters[1]
-
-          when 'TABLEFILE'
-            parser.verify_num_parameters(1, 1, "#{keyword} <File name>")
-            process(File.join(File.dirname(filename), parameters[0]))
-
-          when 'TABLE'
-            usage = "TABLE <Table Name> <Table Description> <ONE_DIMENSIONAL or TWO_DIMENSIONAL> <BIG_ENDIAN or LITTLE_ENDIAN> <Identifier>"
-            parser.verify_num_parameters(5, nil, usage)
-            begin
-              # locals declared for readability
-              name = parameters[0]
-              description = parameters[1]
-              type = read_table_type(parameters[2])
-              endianness = read_endianness(parameters[3])
-              if parameters[5].nil?
-                table_id = Integer(parameters[4])
-              else
-                table_id = []
-                parameters[4..-1].each {|parameter| table_id << Integer(parameter)}
-              end
-
-              start_new_table(name, description, type, endianness, table_id, filename)
-            rescue ArgumentError => err
-              raise parser.error("#{err.message} with #{keyword}.\nUSAGE: #{usage}")
-            end
-
-          when 'PARAMETER'
-            usage = "PARAMETER <Parameter Name> <Parameter Description> <Data Type> <Bit Size> <Display Type> <Minimum Value> <Maximum Value> <Default Value - Only in ONE_DIMENTIONAL>"
-            parser.verify_num_parameters(7, 8, usage)
-            finish_parameter()
-            if @current_table
-              @current_table.num_rows += 1
-
-              begin
-                if @current_table.type == :TWO_DIMENSIONAL
-                  parameters[0] = "#{parameters[0]}0"
-                end
-                # locals declared for readability
-                name = parameters[0]
-                if @current_table.items[name.upcase]
-                  raise ArgumentError, "The name \"#{name}\" was already defined"
-                end
-                description = parameters[1]
-                type = read_item_type(parameters[2])
-                bit_size = parameters[3].to_i
-                display_type, editable = read_display_type(parameters[4], type)
-                if type == :BLOCK
-                  range = nil
-                elsif type == :STRING
-                  range = convert_to_range(parameters[5], parameters[6], :UINT, 0)
-                else
-                  range = convert_to_range(parameters[5], parameters[6], type, bit_size)
-                end
-                if @current_table.type == :ONE_DIMENSIONAL
-                  default = convert_to_type(parameters[7], type)
-                else # TWO_DIMENSIONAL defaults are set by the DEFAULT keyword
-                  default = 0
-                end
-
-                @current_parameter = @current_table.create_param(name, @cur_bit_offset,
-                  bit_size, type, description, range, default, display_type, editable)
-                @cur_bit_offset += parameters[3].to_i
-              rescue ArgumentError => err
-                raise parser.error("#{err.message} with #{keyword}.\nUSAGE: #{usage}")
-              end
-            end
-
-          when 'STATE'
-            usage = "STATE <Key> <Value>"
-            parser.verify_num_parameters(2, 2, usage)
-            begin
-              # locals declared for readability
-              state_name = parameters[0]
-              state_value = convert_to_type(parameters[1], @current_parameter.data_type)
-
-              @current_parameter.states ||= {}
-              @current_parameter.states[state_name.upcase] = state_value
-            rescue ArgumentError => err
-              raise parser.error("#{err.message} with #{keyword}.\nUSAGE: #{usage}")
-            end
-
-          when 'DEFAULT'
-            usage = "DEFAULT <Value1> <Value2> ... <ValueN>"
-            # if this is our first default value for a TWO_DIMENSIONAL table
-            # then we redefine the default values
-            if @default_count == 0
-              @item_definitions = Array.new(@current_table.sorted_items)
-              index = 0
-              @item_definitions.each do |item_def|
-                set_item_default_value(item_def, parameters[index])
-                index += 1
-              end
-
-              @current_table.num_rows = 1
-
-            # more default values have been given so copy all the parameters from
-            # the first row and reset the defaults
-            else
-              index = 0
-
-              @item_definitions.each do |item_def|
-                new_item = @current_table.duplicate_item(item_def,
-                                                                @default_count,
-                                                                @cur_bit_offset)
-                @cur_bit_offset += item_def.bit_size
-                set_item_default_value(new_item, parameters[index])
-                index += 1
-              end
-              @current_table.num_rows += 1
-            end # end else for if @default_count == 1
-
-            @default_count += 1
-
-          when 'POLY_READ_CONVERSION'
-            parser.verify_num_parameters(2, nil, "#{keyword} <C0> ... <CX>")
-            @current_parameter.read_conversion = PolynomialConversion.new(parameters[0..-1])
-
-          when 'POLY_WRITE_CONVERSION'
-            parser.verify_num_parameters(2, nil, "#{keyword} <C0> ... <CX>")
-            @current_parameter.write_conversion = PolynomialConversion.new(parameters[0..-1])
-
-          else
-            unknown_keyword(parser, keyword, parameters)
-          end # end case parameters[0]
-        end # end else for generic conversion
-      end # end loop
-
-      # Handle last packet
-      finish_table()
-
-    ensure
-      file.close if defined? file and file
-    end
-
-    # Sets the given item definition's default parameter to the default value
-    # given. This function does conversions based on the display_type of the item.
-    def set_item_default_value(item_def, default = nil)
-      begin
-        # If no default was passed use the definition default
-        if default == nil
-          default = item_def.default
-        end
-        if item_def.display_type == :STATE
-          begin
-            val = item_def.states.key(Integer(default))
-          rescue
-            val = default
-          end
-          @current_table.write(item_def.name, val)
-          item_def.default = @current_table.read(item_def.name, :RAW)
-        else
-          item_def.default = convert_to_type(default, item_def.data_type)
-        end
-      rescue
-        Logger.error "Setting #{item_def.name} to #{default} failed! Using #{item_def.range.first} for the default value."
-        item_def.default = item_def.range.first
-      end
-    end
-
-    # Classes extending table_definition should override this function to add
-    # new keyword processing. Ensure super() is called after processing new
-    # keywords so the default behavior of raising an ArgumentError is maintained.
-    def unknown_keyword(parser, keyword, parameters)
-      raise parser.error("Unknown keyword '#{keyword}'.", nil) if keyword
-    end
-
-    # Returns a specific Table
-    def get_table(name)
-      @tables[name]
-    end
-
-    # Returns an array of all the Tables in the definition file
-    def get_all_tables
-      @ordered_tables
-    end
-
-    # Returns an array of all the table names in the definition file
-    def get_table_names
-      @table_names
-    end
-
-    # Returns a default-value representation of an item to be printed in a DEF file
-    def item_to_def_string(table, item_def)
-      result = ""
-      case item_def.display_type
-      when :STATE
-        if table.type == :ONE_DIMENSIONAL
-          result = table.read(item_def.name, :RAW).to_s
-        else
-          result = table.read(item_def.name).to_s
-        end
-      when :DEC, :STRING, :NONE
-        result = table.read(item_def.name).to_s
-      when :CHECK
-        result = table.read(item_def.name, :RAW).to_s
-      when :HEX
-        result = format_hex(table, item_def)
-      end
-
-      return result
-    end
-
-    # Update all default values in the definition file on disk with current values
-    def commit_default_values(table)
-      new_file_data = ""
-      table_found = false
-      default_count = 0
-      table_parameters = []
-      parser = ConfigParser.new
-      parser.parse_file(table.filename) do |keyword, parameters|
-        line = parser.line
-
-        case keyword
-        when 'TABLE'
-          name = parameters[0].remove_quotes
-          if name == table.name
-            table_found = true
-          else
-            table_found = false
-          end
-
-        when 'PARAMETER'
-          if table_found
-            name = parameters[0].remove_quotes
-            if table.type == :ONE_DIMENSIONAL
-              item = table.get_item(name)
-
-              # update the default value (in case the user tries to reset default values)
-              item.default = table.read(name, :RAW)
-
-              # determine what the new default value will look like as printed in the DEF file
-              new_default = item_to_def_string(table, item)
-
-              # scan to the beginning of the default value
-              line_index = line.index(keyword) # skip to start of keyword
-              line_index = line.index(parameters[0], line_index+keyword.length) # skip to start of first param
-              (1..7).each do |index|
-                line_index = line.index(parameters[index], line_index+parameters[index-1].length) # skip to start of next param
-              end
-
-              # rebuild the line in 3 parts:
-              # everything up to the old default value
-              # the new default value
-              # everything after the old default value
-              line = line[0...line_index] + new_default + line[(line_index+parameters[7].length)..-1]
-            else
-              table_parameters << name
-            end
-          end
-
-        when 'DEFAULT'
-          if table_found
-            line_index = line.index(keyword)
-            previous_word = keyword
-            table_parameters.each_with_index do |param_name, index|
-              item_name = "#{param_name}#{default_count}"
-              item = table.get_item(item_name)
-
-              # update the default value (in case the user tries to reset default values)
-              item.default = table.read(item_name, :RAW)
-
-              # determine what the new default value will look like as printed in the DEF file
-              new_default = item_to_def_string(table, item)
-              if new_default.index(" ")
-                new_default = '"' + new_default + '"'
-              end
-
-              # scan to the beginning of the default value
-              line_index = line.index(parameters[index], line_index+previous_word.length)
-
-              # rebuild the line in 3 parts:
-              # everything up to the old default value
-              # the new default value
-              # everything after the old default value
-              line = line[0...line_index] + new_default + line[(line_index+parameters[index].length)..-1]
-
-              # update previous_word so that we can find the next value
-              previous_word = new_default
-            end
-
-            # count the row so that we know what the item_name is next time we see DEFAULT
-            default_count += 1
-          end
-        end
-
-        new_file_data << (line + "\n")
-
-      end # end loop
-
-      # ok, now replace the old def file with the new one
-      File.open(table.filename, "w") do |file|
-        file.puts new_file_data
-      end
-    end
-
-#    # Return the entire table_definition file for the given table name as a string
-#    def print_table(name)
-#      tdef = @tables[name]
-#      tstr = ""
-#      if tdef.table_id.class != Array
-#        tstr << "TABLE \"#{tdef.name}\" \"#{tdef.description}\" #{convert_table_type(tdef.type)} #{convert_endianness(tdef.get_endianness)} #{tdef.table_id}\n"
-#      else
-#        tstr << "TABLE \"#{tdef.name}\" \"#{tdef.description}\" #{convert_table_type(tdef.type)} #{convert_endianness(tdef.get_endianness)} #{tdef.table_id.join(' ')}\n"
-#      end
-#      if tdef.type == :ONE_DIMENSIONAL
-#        tdef.sorted_items.each do |item|
-#          tstr << create_item_string(item, tdef.type)
-#        end
-#      else # TWO_DIMENSIONAL
-#        tdef.num_columns.times do |column|
-#          item_def = tdef.sorted_items[column]
-#          tstr << create_item_string(item_def, tdef.type)
-#        end
-#
-#        index = 0
-#        tdef.sorted_items.each do |item|
-#          if index % tdef.num_columns == 0
-#            tstr << "\n  DEFAULT "
-#          end
-#          case item.display_type
-#            when :DEC
-#              default = item.default
-#            when :STATE
-#              default = "\"#{item.default}\""
-#            when :HEX
-#              default = "0x#{item.default.to_s(16)}"
-#          end
-#          tstr << "#{default} "
-#          index += 1
-#        end
-#      end # end else # TWO_DIMENSIONAL
-#      tstr
-#    end # end print_table(name)
-
-    def format_hex(table, item_def)
-      case item_def.bit_size
-        when 8
-          x = sprintf("%02X", table.read(item_def.name).to_s)
-          # if the number was negative x will have .. and possibly another
-          # F in the string which we remove by taking the last 4 digits
-          x = /\w{2}$/.match(x)[0]
-        when 16
-          x = sprintf("%04X", table.read(item_def.name).to_s)
-          # if the number was negative x will have .. and possibly another
-          # F in the string which we remove by taking the last 4 digits
-          x = /\w{4}$/.match(x)[0]
-        else
-          x = sprintf("%08X", table.read(item_def.name).to_s)
-          # if the number was negative x will have .. and possibly another
-          # F in the string which we remove by taking the last 8 digits
-          x = /\w{8}$/.match(x)[0]
-      end
-      return "0x%X" % Integer("0x#{x}") # convert to Integer
-    end
-
-    #############################################################################
-    protected
-    #############################################################################
-
-#    # helper function to print_table to get states, constraint, read_conversion,
-#    # and write_conversion that may be associated with an item in the table
-#    def create_item_string(item, type)
-#      tstr = ""
-#      case item.display_type
-#      when :DEC
-#        min = item.range.first
-#        max = item.range.last
-#        default = item.default
-#      when :STATE
-#        min = item.range.first
-#        max = item.range.last
-#        default = item.states[item.default]
-#      when :HEX
-#        min = "0x#{item.range.first.to_s(16)}"
-#        max = "0x#{item.range.last.to_s(16)}"
-#        default = "0x#{item.default.to_s(16)}"
-#      end
-#
-#      name = item.name
-#      display = convert_display_type(item.display_type, item.editable)
-#      tstr << "  PARAMETER \"#{name}\" \"#{item.description}\" #{convert_item_type(item.data_type)} #{item.bit_size} #{display} #{min} #{max}"
-#      if type == :ONE_DIMENSIONAL
-#        tstr << " #{default}\n"
-#      else # TWO_DIMENSIONAL
-#        tstr << "\n"
-#      end
-#
-#      if item.states
-#        item.states.each do |key, value|
-#          tstr << "    STATE \"#{key}\" #{value}\n"
-#        end
-#      end
-#      if item.constraint
-#        tstr << "    CONSTRAINT_START\n"
-#        tstr << item.constraint.code
-#        tstr << "    CONSTRAINT_END\n"
-#      end
-#      if item.read_conversion
-#        if item.read_conversion.class == PolynomialConversion
-#          tstr << "    POLY_READ_CONVERSION #{item.read_conversion.code}\n"
-#        else
-#          tstr << "    GENERIC_READ_CONVERSION_START\n"
-#          tstr << item.read_conversion.code
-#          tstr << "    GENERIC_READ_CONVERSION_END\n"
-#        end
-#      end
-#      if not item.write_conversion.nil?
-#        if item.write_conversion.class == PolynomialConversion
-#          tstr << "    POLY_WRITE_CONVERSION #{item.write_conversion.code}\n"
-#        else
-#          tstr << "    GENERIC_WRITE_CONVERSION_START\n"
-#          tstr << item.write_conversion.code
-#          tstr << "    GENERIC_WRITE_CONVERSION_END\n"
-#        end
-#      end
-#      tstr
-#    end
-
-    # Finish Updating parameter in packet
-    def finish_parameter
-      unless @current_parameter.nil?
-        @current_table.set_item(@current_parameter)
-      end
-    end
-
-    # Start processing a new packet
-    def start_new_table(name, description, type, endianness, table_id, filename)
-      finish_table
-      @current_table = Table.new(name, description, type, endianness, table_id, filename)
-      @current_name = name
-      @default_count = 0
-    end
-
-    # Add current packet into hash if it exists
-    def finish_table
-      finish_parameter
-      if @current_table
-        Logger.info "finish_table #{@current_name}"
-        if @current_table.num_rows
-          if @tables.nil? or @table_names.nil? or @ordered_tables.nil?
-            @tables = {}
-            @table_names = []
-            @ordered_tables = []
-          end
-          @tables[@current_name] = @current_table
-          @table_names << @current_name
-          @ordered_tables << @current_table
-        end
-        @current_table = nil
-        @current_parameter = nil
-        @cur_bit_offset = 0
-      end
-    end
-
-    # Convert the table type string to a value
-    def read_table_type(str)
-      str.upcase!
-      case str
-      when 'ONE_DIMENSIONAL'
-        :ONE_DIMENSIONAL
-      when 'TWO_DIMENSIONAL'
-        :TWO_DIMENSIONAL
-      else
-        raise ArgumentError, "Unknown table type:#{str}! Must be ONE_DIMENSIONAL or TWO_DIMENSIONAL"
-      end
-    end
-
-    # Convert the table type value to a string
-    def convert_table_type(type)
-      case type
-      when :ONE_DIMENSIONAL
-        'ONE_DIMENSIONAL'
-      when :TWO_DIMENSIONAL
-        'TWO_DIMENSIONAL'
-      else
-        raise ArgumentError, "Unknown table type:#{type}!"
-      end
-    end
-
-    # Convert the endianness string to a value
-    def read_endianness(str)
-      str.upcase!
-      case str
-      when 'BIG_ENDIAN'
-        :BIG_ENDIAN
-      when 'LITTLE_ENDIAN'
-        :LITTLE_ENDIAN
-      else
-        raise ArgumentError, "Unknown endianness:#{str}! Must be BIG_ENDIAN or LITTLE_ENDIAN"
-      end
-    end
-
-    # Convert the endianness value to a string
-    def convert_endianness(endianness)
-      case endianness
-      when :BIG_ENDIAN
-        'BIG_ENDIAN'
-      when :LITTLE_ENDIAN
-        'LITTLE_ENDIAN'
-      else
-        raise ArgumentError, "Unknown endianness:#{endianness}!"
-      end
-    end
-
-    # Process a item type string into a value
-    def read_item_type(str)
-      str.upcase!
-      case str
-      when 'INT'
-        :INT
-      when 'UINT'
-        :UINT
-      when 'FLOAT'
-        :FLOAT
-      when 'STRING'
-        :STRING
-      when 'BLOCK'
-        :BLOCK
-      else
-        raise ArgumentError, "Unknown type:#{str}! Must be INT, UINT, FLOAT, STRING, or BLOCK"
-      end
-    end
-
-    # Process a item type value into a string
-    def convert_item_type(type)
-      case type
-      when :INT
-        'INT'
-      when :UINT
-        'UINT'
-      when :FLOAT
-        'FLOAT'
-      when :STRING
-        'STRING'
-      when :BLOCK
-        'BLOCK'
-      else
-        raise ArgumentError, "Unknown type:#{type}!"
-      end
-    end
-
-    # Convert a string to the correct item type
-    def convert_to_type(val, type)
-      raise ArgumentError, "Value is not defined" if val.nil?
-      begin
-        case type
-        when :INT, :UINT
-          val = Integer(val)
-        when :FLOAT
-          val = Float(val)
-        when :STRING, :BLOCK
-          val = val.to_s
-        end
-      rescue
-        begin
-          val = eval(val)
-        rescue
-          case type
-          when :INT
-            type_name = 'INT'
-          when :UINT
-            type_name = 'UINT'
-          when :FLOAT
-            type_name = 'FLOAT'
-          end
-          raise ArgumentError, "Error evaluating value:#{val} of type:#{type_name}"
-        end
-      end
-      val
-    end
-
-    # Convert the given minimum and maximum values of the given type and bit_size
-    # into a valid Ruby range: min..max. The function verifies the range is not
-    # backwards and that the minimum and maximum values make sense for the given
-    # type and bit_size. For example, a maximum of 256 doesn't make sense for a UINT8.
-    def convert_to_range(min, max, type, bit_size)
-      min = convert_to_type(min, type)
-      max = convert_to_type(max, type)
-      range = min..max
-
-      # First check for backwards ranges
-      if min > max
-        raise ArgumentError, "Min:#{min} can't be larger than max:#{max} in range"
-      end
-
-      case type
-        # No case for FLOAT because if the type is a float the range
-        # can be anything since you can't set a range wider than that allowed by a float
-        when :UINT
-          # First check for a negative range which doesn't make sense for UINT
-          if min < 0 or max < 0
-            raise ArgumentError, "Negative value in UINT range doesn't make sense"
-          end
-          if (bit_size == 8  and max > 255) or
-             (bit_size == 16 and max > 65535) or
-             (bit_size == 32 and max > 4294967295)
-            raise ArgumentError, "Max value of #{max} in UINT range doesn't make sense"
-          end
-        when :INT
-          if (bit_size == 8  and (min < -128 or max > 127)) or
-             (bit_size == 16 and (min < -32768 or max > 32767)) or
-             (bit_size == 32 and (min < -2147483648 or max > 2147483647))
-            raise ArgumentError, "Max value of #{max} in INT range doesn't make sense"
-          end
-      end
-      range
-    end
-
-    # Convert a display type string to the type value
-    def read_display_type(display_type, value_type)
-      editable = true
-      display_type.upcase!
-
-      if /-U/ =~ display_type
-        editable = false
-        display_type.sub!(/-U/,"")
-      end
-
-      case display_type
-      when 'DEC'
-        display_type = :DEC
-      when 'HEX'
-        display_type = :HEX
-      when 'STATE'
-        display_type = :STATE
-      when 'CHECK'
-        display_type = :CHECK
-      when 'STRING'
-        display_type = :STRING
-      when 'NONE'
-        display_type = :NONE
-        editable = false
-      else
-        raise ArgumentError, "Unknown display type:#{display_type}! Must be DEC, DEC-U, HEX, HEX-U, STATE, STATE-U, CHECK, CHECK-U, STRING or NONE"
-      end
-
-      if value_type ==:STRING && display_type != :STRING
-        raise ArgumentError, "STRING items must have a display type of STRING"
-      end
-      if value_type == :BLOCK && display_type != :NONE
-        raise ArgumentError, "BLOCK items must have a display type of NONE"
-      end
-
-      return display_type, editable
-    end
-
-    # Convert display type value to a display type string
-    def convert_display_type(type, editable)
-      display =
-      case type
-      when :DEC
-        'DEC'
-      when :HEX
-        'HEX'
-      when :STATE
-        'STATE'
-      when :CHECK
-        'CHECK'
-      when :STRING
-        'STRING'
-      when :NONE
-        'NONE'
-      else
-        raise ArgumentError, "Unkown display type:#{type}!"
-      end
-      if not editable
-        display << "-U"
-      end
-      display
-    end
-
-  end # class TableConfig
-
-end # module Cosmos
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos'
+require 'cosmos/tools/table_manager/table'
+
+module Cosmos
+
+  # TableConfig provides capabilities to read an ascii file that defines the
+  # table parameters in a system and create a set of Tables for each.
+  class TableConfig
+
+    # Constructor for a TableConfig
+    def initialize
+      @ordered_tables = nil
+      @tables = nil
+      @current_name = nil
+      @current_table = nil
+      @current_parameter = nil
+      @cur_bit_offset = 0
+      @default_count = 0
+      @item_definitions = nil
+      @table_names = nil
+    end
+
+    # Processes a file and adds in the tables defined in the file
+    def process(filename)
+      building_generic_conversion = false
+      converted_type = nil
+      converted_bit_size = nil
+      proc_text = ''
+
+      Logger.info "Processing table config in file '#{filename}'"
+
+      unless test ?f, filename
+        Logger.error "File does not exist"
+        raise "ERROR! Table config file #{filename} does not exist!"
+      end
+
+      parser = ConfigParser.new
+      parser.parse_file(filename) do |keyword, parameters|
+        next unless keyword
+        if building_generic_conversion
+          case keyword
+          # Complete a generic conversion
+          when 'GENERIC_READ_CONVERSION_END', 'GENERIC_WRITE_CONVERSION_END', 'CONSTRAINT_END'
+            parser.verify_num_parameters(0, 0, keyword)
+            @current_parameter.read_conversion =
+              GenericConversion.new(proc_text,
+                                    converted_type,
+                                    converted_bit_size) if keyword.include? "READ"
+            @current_parameter.write_conversion =
+              GenericConversion.new(proc_text,
+                                    converted_type,
+                                    converted_bit_size) if keyword.include? "WRITE"
+            @current_parameter.constraint =
+              GenericConversion.new(proc_text,
+                                    converted_type,
+                                    converted_bit_size) if keyword.include? "CONSTRAINT"
+            building_generic_conversion = false
+          # Add the current config.line to the conversion being built
+          else
+            proc_text << parser.line << "\n"
+          end # case keyword
+
+        else # not building generic conversion
+
+          case keyword
+          # Start the definition of a generic conversion.
+          # All config.lines following this config.line are considered part
+          # of the conversion until an end of conversion marker is found
+          when 'GENERIC_READ_CONVERSION_START', 'GENERIC_WRITE_CONVERSION_START', 'CONSTRAINT_START'
+            usage = "#{keyword} <Converted Type (optional)> <Converted Bit Size (optional)>"
+            parser.verify_num_parameters(0, 2, usage)
+            proc_text = ''
+            building_generic_conversion = true
+            converted_type = nil
+            converted_bit_size = nil
+            if parameters[0]
+              converted_type = parameters[0].upcase.intern
+              raise parser.error("Invalid converted_type: #{converted_type}.") unless [:INT, :UINT, :FLOAT, :STRING, :BLOCK].include? converted_type
+            end
+            converted_bit_size = Integer(parameters[1]) if parameters[1]
+
+          when 'TABLEFILE'
+            parser.verify_num_parameters(1, 1, "#{keyword} <File name>")
+            process(File.join(File.dirname(filename), parameters[0]))
+
+          when 'TABLE'
+            usage = "TABLE <Table Name> <Table Description> <ONE_DIMENSIONAL or TWO_DIMENSIONAL> <BIG_ENDIAN or LITTLE_ENDIAN> <Identifier>"
+            parser.verify_num_parameters(5, nil, usage)
+            begin
+              # locals declared for readability
+              name = parameters[0]
+              description = parameters[1]
+              type = read_table_type(parameters[2])
+              endianness = read_endianness(parameters[3])
+              if parameters[5].nil?
+                table_id = Integer(parameters[4])
+              else
+                table_id = []
+                parameters[4..-1].each {|parameter| table_id << Integer(parameter)}
+              end
+
+              start_new_table(name, description, type, endianness, table_id, filename)
+            rescue ArgumentError => err
+              raise parser.error("#{err.message} with #{keyword}.\nUSAGE: #{usage}")
+            end
+
+          when 'PARAMETER'
+            usage = "PARAMETER <Parameter Name> <Parameter Description> <Data Type> <Bit Size> <Display Type> <Minimum Value> <Maximum Value> <Default Value - Only in ONE_DIMENTIONAL>"
+            parser.verify_num_parameters(7, 8, usage)
+            finish_parameter()
+            if @current_table
+              @current_table.num_rows += 1
+
+              begin
+                if @current_table.type == :TWO_DIMENSIONAL
+                  parameters[0] = "#{parameters[0]}0"
+                end
+                # locals declared for readability
+                name = parameters[0]
+                if @current_table.items[name.upcase]
+                  raise ArgumentError, "The name \"#{name}\" was already defined"
+                end
+                description = parameters[1]
+                type = read_item_type(parameters[2])
+                bit_size = parameters[3].to_i
+                display_type, editable = read_display_type(parameters[4], type)
+                if type == :BLOCK
+                  range = nil
+                elsif type == :STRING
+                  range = convert_to_range(parameters[5], parameters[6], :UINT, 0)
+                else
+                  range = convert_to_range(parameters[5], parameters[6], type, bit_size)
+                end
+                if @current_table.type == :ONE_DIMENSIONAL
+                  default = convert_to_type(parameters[7], type)
+                else # TWO_DIMENSIONAL defaults are set by the DEFAULT keyword
+                  default = 0
+                end
+
+                @current_parameter = @current_table.create_param(name, @cur_bit_offset,
+                  bit_size, type, description, range, default, display_type, editable)
+                @cur_bit_offset += parameters[3].to_i
+              rescue ArgumentError => err
+                raise parser.error("#{err.message} with #{keyword}.\nUSAGE: #{usage}")
+              end
+            end
+
+          when 'STATE'
+            usage = "STATE <Key> <Value>"
+            parser.verify_num_parameters(2, 2, usage)
+            begin
+              # locals declared for readability
+              state_name = parameters[0]
+              state_value = convert_to_type(parameters[1], @current_parameter.data_type)
+
+              @current_parameter.states ||= {}
+              @current_parameter.states[state_name.upcase] = state_value
+            rescue ArgumentError => err
+              raise parser.error("#{err.message} with #{keyword}.\nUSAGE: #{usage}")
+            end
+
+          when 'DEFAULT'
+            usage = "DEFAULT <Value1> <Value2> ... <ValueN>"
+            # if this is our first default value for a TWO_DIMENSIONAL table
+            # then we redefine the default values
+            if @default_count == 0
+              @item_definitions = Array.new(@current_table.sorted_items)
+              index = 0
+              @item_definitions.each do |item_def|
+                set_item_default_value(item_def, parameters[index])
+                index += 1
+              end
+
+              @current_table.num_rows = 1
+
+            # more default values have been given so copy all the parameters from
+            # the first row and reset the defaults
+            else
+              index = 0
+
+              @item_definitions.each do |item_def|
+                new_item = @current_table.duplicate_item(item_def,
+                                                                @default_count,
+                                                                @cur_bit_offset)
+                @cur_bit_offset += item_def.bit_size
+                set_item_default_value(new_item, parameters[index])
+                index += 1
+              end
+              @current_table.num_rows += 1
+            end # end else for if @default_count == 1
+
+            @default_count += 1
+
+          when 'POLY_READ_CONVERSION'
+            parser.verify_num_parameters(2, nil, "#{keyword} <C0> ... <CX>")
+            @current_parameter.read_conversion = PolynomialConversion.new(parameters[0..-1])
+
+          when 'POLY_WRITE_CONVERSION'
+            parser.verify_num_parameters(2, nil, "#{keyword} <C0> ... <CX>")
+            @current_parameter.write_conversion = PolynomialConversion.new(parameters[0..-1])
+
+          else
+            unknown_keyword(parser, keyword, parameters)
+          end # end case parameters[0]
+        end # end else for generic conversion
+      end # end loop
+
+      # Handle last packet
+      finish_table()
+
+    ensure
+      file.close if defined? file and file
+    end
+
+    # Sets the given item definition's default parameter to the default value
+    # given. This function does conversions based on the display_type of the item.
+    def set_item_default_value(item_def, default = nil)
+      begin
+        # If no default was passed use the definition default
+        if default == nil
+          default = item_def.default
+        end
+        if item_def.display_type == :STATE
+          begin
+            val = item_def.states.key(Integer(default))
+          rescue
+            val = default
+          end
+          @current_table.write(item_def.name, val)
+          item_def.default = @current_table.read(item_def.name, :RAW)
+        else
+          item_def.default = convert_to_type(default, item_def.data_type)
+        end
+      rescue
+        Logger.error "Setting #{item_def.name} to #{default} failed! Using #{item_def.range.first} for the default value."
+        item_def.default = item_def.range.first
+      end
+    end
+
+    # Classes extending table_definition should override this function to add
+    # new keyword processing. Ensure super() is called after processing new
+    # keywords so the default behavior of raising an ArgumentError is maintained.
+    def unknown_keyword(parser, keyword, parameters)
+      raise parser.error("Unknown keyword '#{keyword}'.", nil) if keyword
+    end
+
+    # Returns a specific Table
+    def get_table(name)
+      @tables[name]
+    end
+
+    # Returns an array of all the Tables in the definition file
+    def get_all_tables
+      @ordered_tables
+    end
+
+    # Returns an array of all the table names in the definition file
+    def get_table_names
+      @table_names
+    end
+
+    # Returns a default-value representation of an item to be printed in a DEF file
+    def item_to_def_string(table, item_def)
+      result = ""
+      case item_def.display_type
+      when :STATE
+        if table.type == :ONE_DIMENSIONAL
+          result = table.read(item_def.name, :RAW).to_s
+        else
+          result = table.read(item_def.name).to_s
+        end
+      when :DEC, :STRING, :NONE
+        result = table.read(item_def.name).to_s
+      when :CHECK
+        result = table.read(item_def.name, :RAW).to_s
+      when :HEX
+        result = format_hex(table, item_def)
+      end
+
+      return result
+    end
+
+    # Update all default values in the definition file on disk with current values
+    def commit_default_values(table)
+      new_file_data = ""
+      table_found = false
+      default_count = 0
+      table_parameters = []
+      parser = ConfigParser.new
+      parser.parse_file(table.filename) do |keyword, parameters|
+        line = parser.line
+
+        case keyword
+        when 'TABLE'
+          name = parameters[0].remove_quotes
+          if name == table.name
+            table_found = true
+          else
+            table_found = false
+          end
+
+        when 'PARAMETER'
+          if table_found
+            name = parameters[0].remove_quotes
+            if table.type == :ONE_DIMENSIONAL
+              item = table.get_item(name)
+
+              # update the default value (in case the user tries to reset default values)
+              item.default = table.read(name, :RAW)
+
+              # determine what the new default value will look like as printed in the DEF file
+              new_default = item_to_def_string(table, item)
+
+              # scan to the beginning of the default value
+              line_index = line.index(keyword) # skip to start of keyword
+              line_index = line.index(parameters[0], line_index+keyword.length) # skip to start of first param
+              (1..7).each do |index|
+                line_index = line.index(parameters[index], line_index+parameters[index-1].length) # skip to start of next param
+              end
+
+              # rebuild the line in 3 parts:
+              # everything up to the old default value
+              # the new default value
+              # everything after the old default value
+              line = line[0...line_index] + new_default + line[(line_index+parameters[7].length)..-1]
+            else
+              table_parameters << name
+            end
+          end
+
+        when 'DEFAULT'
+          if table_found
+            line_index = line.index(keyword)
+            previous_word = keyword
+            table_parameters.each_with_index do |param_name, index|
+              item_name = "#{param_name}#{default_count}"
+              item = table.get_item(item_name)
+
+              # update the default value (in case the user tries to reset default values)
+              item.default = table.read(item_name, :RAW)
+
+              # determine what the new default value will look like as printed in the DEF file
+              new_default = item_to_def_string(table, item)
+              if new_default.index(" ")
+                new_default = '"' + new_default + '"'
+              end
+
+              # scan to the beginning of the default value
+              line_index = line.index(parameters[index], line_index+previous_word.length)
+
+              # rebuild the line in 3 parts:
+              # everything up to the old default value
+              # the new default value
+              # everything after the old default value
+              line = line[0...line_index] + new_default + line[(line_index+parameters[index].length)..-1]
+
+              # update previous_word so that we can find the next value
+              previous_word = new_default
+            end
+
+            # count the row so that we know what the item_name is next time we see DEFAULT
+            default_count += 1
+          end
+        end
+
+        new_file_data << (line + "\n")
+
+      end # end loop
+
+      # ok, now replace the old def file with the new one
+      File.open(table.filename, "w") do |file|
+        file.puts new_file_data
+      end
+    end
+
+#    # Return the entire table_definition file for the given table name as a string
+#    def print_table(name)
+#      tdef = @tables[name]
+#      tstr = ""
+#      if tdef.table_id.class != Array
+#        tstr << "TABLE \"#{tdef.name}\" \"#{tdef.description}\" #{convert_table_type(tdef.type)} #{convert_endianness(tdef.get_endianness)} #{tdef.table_id}\n"
+#      else
+#        tstr << "TABLE \"#{tdef.name}\" \"#{tdef.description}\" #{convert_table_type(tdef.type)} #{convert_endianness(tdef.get_endianness)} #{tdef.table_id.join(' ')}\n"
+#      end
+#      if tdef.type == :ONE_DIMENSIONAL
+#        tdef.sorted_items.each do |item|
+#          tstr << create_item_string(item, tdef.type)
+#        end
+#      else # TWO_DIMENSIONAL
+#        tdef.num_columns.times do |column|
+#          item_def = tdef.sorted_items[column]
+#          tstr << create_item_string(item_def, tdef.type)
+#        end
+#
+#        index = 0
+#        tdef.sorted_items.each do |item|
+#          if index % tdef.num_columns == 0
+#            tstr << "\n  DEFAULT "
+#          end
+#          case item.display_type
+#            when :DEC
+#              default = item.default
+#            when :STATE
+#              default = "\"#{item.default}\""
+#            when :HEX
+#              default = "0x#{item.default.to_s(16)}"
+#          end
+#          tstr << "#{default} "
+#          index += 1
+#        end
+#      end # end else # TWO_DIMENSIONAL
+#      tstr
+#    end # end print_table(name)
+
+    def format_hex(table, item_def)
+      case item_def.bit_size
+        when 8
+          x = sprintf("%02X", table.read(item_def.name).to_s)
+          # if the number was negative x will have .. and possibly another
+          # F in the string which we remove by taking the last 4 digits
+          x = /\w{2}$/.match(x)[0]
+        when 16
+          x = sprintf("%04X", table.read(item_def.name).to_s)
+          # if the number was negative x will have .. and possibly another
+          # F in the string which we remove by taking the last 4 digits
+          x = /\w{4}$/.match(x)[0]
+        else
+          x = sprintf("%08X", table.read(item_def.name).to_s)
+          # if the number was negative x will have .. and possibly another
+          # F in the string which we remove by taking the last 8 digits
+          x = /\w{8}$/.match(x)[0]
+      end
+      return "0x%X" % Integer("0x#{x}") # convert to Integer
+    end
+
+    #############################################################################
+    protected
+    #############################################################################
+
+#    # helper function to print_table to get states, constraint, read_conversion,
+#    # and write_conversion that may be associated with an item in the table
+#    def create_item_string(item, type)
+#      tstr = ""
+#      case item.display_type
+#      when :DEC
+#        min = item.range.first
+#        max = item.range.last
+#        default = item.default
+#      when :STATE
+#        min = item.range.first
+#        max = item.range.last
+#        default = item.states[item.default]
+#      when :HEX
+#        min = "0x#{item.range.first.to_s(16)}"
+#        max = "0x#{item.range.last.to_s(16)}"
+#        default = "0x#{item.default.to_s(16)}"
+#      end
+#
+#      name = item.name
+#      display = convert_display_type(item.display_type, item.editable)
+#      tstr << "  PARAMETER \"#{name}\" \"#{item.description}\" #{convert_item_type(item.data_type)} #{item.bit_size} #{display} #{min} #{max}"
+#      if type == :ONE_DIMENSIONAL
+#        tstr << " #{default}\n"
+#      else # TWO_DIMENSIONAL
+#        tstr << "\n"
+#      end
+#
+#      if item.states
+#        item.states.each do |key, value|
+#          tstr << "    STATE \"#{key}\" #{value}\n"
+#        end
+#      end
+#      if item.constraint
+#        tstr << "    CONSTRAINT_START\n"
+#        tstr << item.constraint.code
+#        tstr << "    CONSTRAINT_END\n"
+#      end
+#      if item.read_conversion
+#        if item.read_conversion.class == PolynomialConversion
+#          tstr << "    POLY_READ_CONVERSION #{item.read_conversion.code}\n"
+#        else
+#          tstr << "    GENERIC_READ_CONVERSION_START\n"
+#          tstr << item.read_conversion.code
+#          tstr << "    GENERIC_READ_CONVERSION_END\n"
+#        end
+#      end
+#      if not item.write_conversion.nil?
+#        if item.write_conversion.class == PolynomialConversion
+#          tstr << "    POLY_WRITE_CONVERSION #{item.write_conversion.code}\n"
+#        else
+#          tstr << "    GENERIC_WRITE_CONVERSION_START\n"
+#          tstr << item.write_conversion.code
+#          tstr << "    GENERIC_WRITE_CONVERSION_END\n"
+#        end
+#      end
+#      tstr
+#    end
+
+    # Finish Updating parameter in packet
+    def finish_parameter
+      unless @current_parameter.nil?
+        @current_table.set_item(@current_parameter)
+      end
+    end
+
+    # Start processing a new packet
+    def start_new_table(name, description, type, endianness, table_id, filename)
+      finish_table
+      @current_table = Table.new(name, description, type, endianness, table_id, filename)
+      @current_name = name
+      @default_count = 0
+    end
+
+    # Add current packet into hash if it exists
+    def finish_table
+      finish_parameter
+      if @current_table
+        Logger.info "finish_table #{@current_name}"
+        if @current_table.num_rows
+          if @tables.nil? or @table_names.nil? or @ordered_tables.nil?
+            @tables = {}
+            @table_names = []
+            @ordered_tables = []
+          end
+          @tables[@current_name] = @current_table
+          @table_names << @current_name
+          @ordered_tables << @current_table
+        end
+        @current_table = nil
+        @current_parameter = nil
+        @cur_bit_offset = 0
+      end
+    end
+
+    # Convert the table type string to a value
+    def read_table_type(str)
+      str.upcase!
+      case str
+      when 'ONE_DIMENSIONAL'
+        :ONE_DIMENSIONAL
+      when 'TWO_DIMENSIONAL'
+        :TWO_DIMENSIONAL
+      else
+        raise ArgumentError, "Unknown table type:#{str}! Must be ONE_DIMENSIONAL or TWO_DIMENSIONAL"
+      end
+    end
+
+    # Convert the table type value to a string
+    def convert_table_type(type)
+      case type
+      when :ONE_DIMENSIONAL
+        'ONE_DIMENSIONAL'
+      when :TWO_DIMENSIONAL
+        'TWO_DIMENSIONAL'
+      else
+        raise ArgumentError, "Unknown table type:#{type}!"
+      end
+    end
+
+    # Convert the endianness string to a value
+    def read_endianness(str)
+      str.upcase!
+      case str
+      when 'BIG_ENDIAN'
+        :BIG_ENDIAN
+      when 'LITTLE_ENDIAN'
+        :LITTLE_ENDIAN
+      else
+        raise ArgumentError, "Unknown endianness:#{str}! Must be BIG_ENDIAN or LITTLE_ENDIAN"
+      end
+    end
+
+    # Convert the endianness value to a string
+    def convert_endianness(endianness)
+      case endianness
+      when :BIG_ENDIAN
+        'BIG_ENDIAN'
+      when :LITTLE_ENDIAN
+        'LITTLE_ENDIAN'
+      else
+        raise ArgumentError, "Unknown endianness:#{endianness}!"
+      end
+    end
+
+    # Process a item type string into a value
+    def read_item_type(str)
+      str.upcase!
+      case str
+      when 'INT'
+        :INT
+      when 'UINT'
+        :UINT
+      when 'FLOAT'
+        :FLOAT
+      when 'STRING'
+        :STRING
+      when 'BLOCK'
+        :BLOCK
+      else
+        raise ArgumentError, "Unknown type:#{str}! Must be INT, UINT, FLOAT, STRING, or BLOCK"
+      end
+    end
+
+    # Process a item type value into a string
+    def convert_item_type(type)
+      case type
+      when :INT
+        'INT'
+      when :UINT
+        'UINT'
+      when :FLOAT
+        'FLOAT'
+      when :STRING
+        'STRING'
+      when :BLOCK
+        'BLOCK'
+      else
+        raise ArgumentError, "Unknown type:#{type}!"
+      end
+    end
+
+    # Convert a string to the correct item type
+    def convert_to_type(val, type)
+      raise ArgumentError, "Value is not defined" if val.nil?
+      begin
+        case type
+        when :INT, :UINT
+          val = Integer(val)
+        when :FLOAT
+          val = Float(val)
+        when :STRING, :BLOCK
+          val = val.to_s
+        end
+      rescue
+        begin
+          val = eval(val)
+        rescue
+          case type
+          when :INT
+            type_name = 'INT'
+          when :UINT
+            type_name = 'UINT'
+          when :FLOAT
+            type_name = 'FLOAT'
+          end
+          raise ArgumentError, "Error evaluating value:#{val} of type:#{type_name}"
+        end
+      end
+      val
+    end
+
+    # Convert the given minimum and maximum values of the given type and bit_size
+    # into a valid Ruby range: min..max. The function verifies the range is not
+    # backwards and that the minimum and maximum values make sense for the given
+    # type and bit_size. For example, a maximum of 256 doesn't make sense for a UINT8.
+    def convert_to_range(min, max, type, bit_size)
+      min = convert_to_type(min, type)
+      max = convert_to_type(max, type)
+      range = min..max
+
+      # First check for backwards ranges
+      if min > max
+        raise ArgumentError, "Min:#{min} can't be larger than max:#{max} in range"
+      end
+
+      case type
+        # No case for FLOAT because if the type is a float the range
+        # can be anything since you can't set a range wider than that allowed by a float
+        when :UINT
+          # First check for a negative range which doesn't make sense for UINT
+          if min < 0 or max < 0
+            raise ArgumentError, "Negative value in UINT range doesn't make sense"
+          end
+          if (bit_size == 8  and max > 255) or
+             (bit_size == 16 and max > 65535) or
+             (bit_size == 32 and max > 4294967295)
+            raise ArgumentError, "Max value of #{max} in UINT range doesn't make sense"
+          end
+        when :INT
+          if (bit_size == 8  and (min < -128 or max > 127)) or
+             (bit_size == 16 and (min < -32768 or max > 32767)) or
+             (bit_size == 32 and (min < -2147483648 or max > 2147483647))
+            raise ArgumentError, "Max value of #{max} in INT range doesn't make sense"
+          end
+      end
+      range
+    end
+
+    # Convert a display type string to the type value
+    def read_display_type(display_type, value_type)
+      editable = true
+      display_type.upcase!
+
+      if /-U/ =~ display_type
+        editable = false
+        display_type.sub!(/-U/,"")
+      end
+
+      case display_type
+      when 'DEC'
+        display_type = :DEC
+      when 'HEX'
+        display_type = :HEX
+      when 'STATE'
+        display_type = :STATE
+      when 'CHECK'
+        display_type = :CHECK
+      when 'STRING'
+        display_type = :STRING
+      when 'NONE'
+        display_type = :NONE
+        editable = false
+      else
+        raise ArgumentError, "Unknown display type:#{display_type}! Must be DEC, DEC-U, HEX, HEX-U, STATE, STATE-U, CHECK, CHECK-U, STRING or NONE"
+      end
+
+      if value_type ==:STRING && display_type != :STRING
+        raise ArgumentError, "STRING items must have a display type of STRING"
+      end
+      if value_type == :BLOCK && display_type != :NONE
+        raise ArgumentError, "BLOCK items must have a display type of NONE"
+      end
+
+      return display_type, editable
+    end
+
+    # Convert display type value to a display type string
+    def convert_display_type(type, editable)
+      display =
+      case type
+      when :DEC
+        'DEC'
+      when :HEX
+        'HEX'
+      when :STATE
+        'STATE'
+      when :CHECK
+        'CHECK'
+      when :STRING
+        'STRING'
+      when :NONE
+        'NONE'
+      else
+        raise ArgumentError, "Unkown display type:#{type}!"
+      end
+      if not editable
+        display << "-U"
+      end
+      display
+    end
+
+  end # class TableConfig
+
+end # module Cosmos