dtr_core 0.5.6 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e53ede493820fa8b4b1ab11144e85fdd24299dd5cbed9d81d28f84598431e3bb
-  data.tar.gz: 58fb5680bfc4fcda2a064d4328288849e44e352eba01c6dcb4ba219e2af517dc
+  metadata.gz: 149908b637a12363b2de8ef8432c5348bb303756bf619e09ecd3530ca070973d
+  data.tar.gz: a4d642766c5e1bc759e87520de1f35288b6ef6920409a15238a4cdde60040a78
 SHA512:
-  metadata.gz: 1ed541c5bd2d6cd8ba969867d78fb5b4977eae04b9fb9124ef3178b8255565302626bf88979013a9c84cfa93e98871ee1cdf5bd19cd1e280ca68c0461ace2e86
-  data.tar.gz: 5456ed8bb4e25b422363a01a55f2c59465e83af83ca384ea5525d218009387402307256d6cfcf00e59ffca9992f29ac8cfdc79df2633fb7486f2cad2e03b11c0
+  metadata.gz: 4d81497276755f5d3921c40256864936be3d2b105091bf268a7f483e183668cb959c14d386672d8aad1118c1fc0c6564589893564e6eab203eadf4ac17f9ce62
+  data.tar.gz: 83771252da2ebc9d7cbdd15315aeaae226044de99be1cae842dc237db22cded37e027196f6eb57135fa34a67757dd451cf2de4bd53ff0e3e846d795248d99209

data/lib/dtr_core/common.rb

@@ -3,16 +3,18 @@
 module DTRCore
   # Common methods used by the DTRCore module.
   module Common
-    def strip_and_remove_quotes(str)
-      str.strip.gsub(/['"]/, '')
-    end
-
     def split_strip_select(some_list)
       some_list&.split("\n")&.map(&:strip)&.select { |x| x.length.positive? }
     end
 
-    def first_match_for_content(pattern)
-      content.match(pattern)&.captures&.first
+    def capture_section(pattern)
+      captures = content.match(pattern)&.captures
+
+      if content.scan(pattern).length > 1
+        raise 'Multiple captures found for a section.'
+      elsif captures
+        captures&.first
+      end
     end
 
     def clean_name(definition)

data/lib/dtr_core/contract.rb

@@ -3,31 +3,34 @@
 module DTRCore
   # Represents a contract in a DTR file.
   class Contract
-    attr_reader :functions, :name, :state, :user_defined_types
+    attr_reader :helpers, :interface, :name, :state, :user_defined_types
 
-    def initialize(name, state, functions, user_defined_types)
+    def initialize(name, state, interface, user_defined_types, helpers)
       @name = name
       @state = state
-      @functions = functions
+      @interface = interface
       @user_defined_types = user_defined_types
+      @helpers = helpers
     end
 
     def self.from_dtr(filepath)
       parser = DTRCore::Parser.new(filepath)
 
-      new(parser.name_section, parser.state_section, parser.function_section, parser.user_defined_types_section)
+      new(parser.name_section, parser.state_section, parser.interface_section, parser.user_defined_types_section,
+          parser.helpers_section)
     end
 
     def self.from_dtr_raw(content)
       parser = DTRCore::Parser.new('', content:)
 
-      new(parser.name_section, parser.state_section, parser.function_section, parser.user_defined_types_section)
+      new(parser.name_section, parser.state_section, parser.interface_section, parser.user_defined_types_section,
+          parser.helpers_section)
     end
 
     def ==(other)
       name == other.name &&
         state == other.state &&
-        functions == other.functions &&
+        interface == other.interface &&
         user_defined_types == other.user_defined_types
     end
 
@@ -36,8 +39,9 @@ module DTRCore
 
       return_string += name_to_s
       return_string += "#{state_to_s}\n"
-      return_string += functions_to_s
+      return_string += interface_to_s
       return_string += user_defined_types_to_s
+      return_string += helpers_to_s
 
       return_string
     end
@@ -51,19 +55,25 @@ module DTRCore
     def state_to_s
       return '' if @state.nil?
 
-      "[State]:\n#{@state&.map(&:to_s)&.join("\n")}\n"
+      "[State]:\n#{@state&.map(&:to_s)&.join("\n")}\n:[State]\n"
     end
 
-    def functions_to_s
+    def interface_to_s
       return '' if @state.nil?
 
-      "[InternalFunctions]:\n#{@functions&.map(&:to_s)&.join("\n")}\n:[InternalFunctions]\n"
+      "[Interface]:\n#{@interface&.map(&:to_s)&.join("\n")}\n:[Interface]\n"
     end
 
     def user_defined_types_to_s
       return '' if @user_defined_types.nil?
 
-      "[UserDefinedTypes]:\n#{@user_defined_types&.map(&:to_s)&.join("\n")}\n:[UserDefinedTypes]\n"
+      "[User Defined Types]:\n#{@user_defined_types&.map(&:to_s)&.join("\n")}\n:[User Defined Types]\n"
+    end
+
+    def helpers_to_s
+      return '' if @helpers.nil?
+
+      "[Helpers]:\n#{@helpers&.map(&:to_s)&.join("\n")}\n:[Helpers]\n"
     end
   end
 end

data/lib/dtr_core/function.rb

@@ -65,7 +65,8 @@ module DTRCore
     end
 
     def output_to_s
-      return "" if output.nil?
+      return '' if output.nil?
+
       "    * Output: #{output}\n"
     end
 
@@ -75,19 +76,13 @@ module DTRCore
       return_string += "    * Instructions:\n"
       return_string += "      $\n"
       @instructions.each do |x|
-        return_string += "        #{single_instruction_to_s(x)}\n"
+        return_string += "        #{x}\n"
       end
       return_string += "      $\n"
 
       return_string
     end
 
-    def single_instruction_to_s(ins)
-      "{ instruction: #{ins[:instruction]}," \
-        "input: (#{ins[:inputs]&.join(', ')}), " \
-        "assign: #{ins[:assign]}, scope: #{ins[:scope]} }\n"
-    end
-
     def format_function_inputs(inputs)
       return [] if inputs.nil?
 
@@ -99,12 +94,16 @@ module DTRCore
     end
 
     def parse_function_instruction(instruction)
-      {
-        instruction: instruction[/instruction:\s*(?<all>[^\s,]+)/, 1],
-        inputs: parse_function_instruction_input(instruction),
-        assign: instruction[/\s*assign:\s*(?<all>[^\s\,]+)/, 1],
-        scope: instruction[/\s*scope:\s*(?<all>[^\s\,]+)/, 1].to_i || 0
-      }
+      instruction = DTRCore::Instruction.new(
+        instruction[/instruction:\s*(?<all>[^\s,]+)/, 1],
+        parse_function_instruction_input(instruction),
+        instruction[/\s*assign:\s*(?<all>[^\s\,]+)/, 1],
+        instruction[/\s*scope:\s*(?<all>[^\s\,]+)/, 1].to_i || 0
+      )
+
+      raise "Invalid instruction: #{instruction}" unless instruction.valid?
+
+      instruction
     end
 
     def parse_function_instruction_input(definition)

data/lib/dtr_core/instruction.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module DTRCore
+  # Instruction class
+  class Instruction
+    attr_reader :instruction, :inputs, :assign, :scope
+
+    def initialize(instruction, inputs, assign, scope)
+      @instruction = instruction
+      @inputs = inputs
+      @assign = assign
+      @scope = scope
+    end
+
+    def ==(other)
+      instruction == other.instruction &&
+        inputs == other.inputs &&
+        assign == other.assign &&
+        scope == other.scope
+    end
+
+    def to_s
+      "{ instruction: #{instruction}," \
+        "input: (#{inputs&.join(', ')}), " \
+        "assign: #{assign}, scope: #{scope} }"
+    end
+
+    def valid?
+      DTRCore::InstructionValidator.new(self).valid?
+    end
+  end
+end

data/lib/dtr_core/instruction_validator.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'dtr_core/common'
+
+module DTRCore
+  # Instruction validator for DTR types.
+  class InstructionValidator
+    include ::DTRCore::Common
+
+    def initialize(instruction)
+      @instruction = instruction
+
+      validate_input!
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/MethodLength
+    def valid?
+      return false unless scope_valid?
+
+      case @instruction.instruction
+      when 'assign', 'evaluate', 'print'
+        validate_basic_operation!
+      when 'exit_with_message', 'return'
+        validate_terminating_operation!
+      when 'and', 'or'
+        validate_logical_operation!
+      when 'goto', 'jump', 'end_of_iteration_check', 'label'
+        validate_control_flow_operation!
+      when 'field', 'instantiate_object'
+        validate_object_operation!
+      when 'add', 'subtract', 'multiply', 'divide'
+        validate_binary_operation!
+      else
+        false
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    private
+
+    def validate_input!
+      raise 'Missing Instruction.' if @instruction.nil?
+      raise 'Instruction name missing.' if @instruction.instruction.nil?
+      raise 'Instruction missing scope.' if @instruction.scope.nil?
+    end
+
+    def scope_valid?
+      @instruction.scope >= 0
+    end
+
+    def validate_basic_operation!
+      true
+    end
+
+    def validate_terminating_operation!
+      true
+    end
+
+    def validate_logical_operation!
+      @instruction.inputs&.length == 2
+    end
+
+    def validate_control_flow_operation!
+      true
+    end
+
+    def validate_object_operation!
+      true
+    end
+
+    def validate_binary_operation!
+      @instruction.inputs&.length == 2
+    end
+  end
+end

data/lib/dtr_core/number.rb

@@ -2,22 +2,13 @@
 
 module DTRCore
   module Number
-    MIN_U32 = 0
-    MAX_U32 = (2**32) - 1
+    MIN_Integer = -2**31
+    MAX_Integer = (2**31) - 1
 
-    MIN_U64 = 0
-    MAX_U64 = (2**64) - 1
+    MIN_BigInteger = -2**255
+    MAX_BigInteger = (2**255) - 1
 
-    MIN_U256 = 0
-    MAX_U256 = (2**256) - 1
-
-    MIN_I32 = -2**31
-    MAX_I32 = (2**31) - 1
-
-    MIN_I64 = -2**63
-    MAX_I64 = (2**63) - 1
-
-    MIN_I256 = -2**255
-    MAX_I256 = (2**255) - 1
+    MIN_Float = -2**31
+    MAX_Float = (2**31) - 1
   end
 end

data/lib/dtr_core/parser.rb

@@ -23,7 +23,7 @@ module DTRCore
     def name_section
       return @name_section if @name_section
 
-      name_section = first_match_for_content(/\[Contract\]:\s*(.+)/)
+      name_section = capture_section(/\[Contract\]:\s*(.+)/)
 
       raise 'Missing contract name.' if name_section.nil?
 
@@ -33,7 +33,7 @@ module DTRCore
     def state_section
       return @state_definitions if @state_definitions
 
-      state_section = first_match_for_content(/\[State\]:\s*((?:\s*\*\s*\[.+?\]\n(?:\s*\*.+\n?)*)*)/)
+      state_section = capture_section(/\[State\]:\s*((?:\s*\*\s*\[.+?\]\n(?:\s*\*.+\n?)*)*)\s*:\[State\]/)
 
       return nil if state_section.nil?
 
@@ -46,29 +46,29 @@ module DTRCore
       @state_section ||= state_definitions
     end
 
-    def function_section
+    def interface_section
       return @function_definitions if @function_definitions
 
-      function_section = first_match_for_content(/\[InternalFunctions\]:(?<all>.*):\[InternalFunctions\]/m)
+      interface_section = capture_section(/\[Interface\]:(?<all>.*):\[Interface\]/m)
 
-      return nil if function_section.nil?
+      return nil if interface_section.nil?
 
-      function_definitions = function_section.split('-()').map do |x|
+      function_definitions = interface_section.split('-()').map do |x|
         DTRCore::Function.from_definition(x.strip.to_s)
       end
 
       function_definitions.reject! { |x| x.name.nil? }
 
-      raise 'Empty function section.' if function_definitions.empty?
+      raise 'Empty interface section.' if function_definitions.empty?
 
-      @function_section ||= function_definitions
+      @interface_section ||= function_definitions
     end
 
     def user_defined_types_section
       return @user_defined_types if @user_defined_types
 
       user_defined_types_regex = /\[User Defined Types\]:([\s\S]*?)\s*:\[User Defined Types\]/
-      user_defined_types_section_parsed_out = first_match_for_content(user_defined_types_regex)
+      user_defined_types_section_parsed_out = capture_section(user_defined_types_regex)
 
       return nil if user_defined_types_section_parsed_out.nil?
 
@@ -79,5 +79,23 @@ module DTRCore
 
       @user_defined_types_section ||= user_defined_types
     end
+
+    def helpers_section
+      return @function_definitions if @function_definitions
+
+      helpers_section = capture_section(/\[Helpers\]:(?<all>.*)\s*:\[Helpers\]/m)
+
+      return nil if helpers_section.nil?
+
+      function_definitions = helpers_section.split('-()').map do |x|
+        DTRCore::Function.from_definition(x.strip.to_s)
+      end
+
+      function_definitions.reject! { |x| x.name.nil? }
+
+      raise 'Empty helpers section.' if function_definitions.empty?
+
+      @helpers_section ||= function_definitions
+    end
   end
 end

data/lib/dtr_core/supported_attributes.rb

@@ -1,98 +1,81 @@
 # frozen_string_literal: true
 
+# rubocop:disable Layout/LineLength
 module DTRCore
   module SupportedAttributes
     # Supported Instructions for DTR.
     ## Instruction Categories ##
     INSTRUCTION_CATEGORY_BASIC = 'basic'
-    INSTRUCTION_CATEGORY_STATE = 'state'
-    INSTRUCTION_CATEGORY_UNTYPED = 'untyped'
-    INSTRUCTION_CATEGORY_NUMERIC = 'numeric'
-    INSTRUCTION_CATEGORY_STRING = 'string'
-    INSTRUCTION_CATEGORY_ENVIRONMENT = 'environment'
-    INSTRUCTION_CATEGORY_METHODS = 'methods'
-    INSTRUCTION_CATEGORY_OBJECTS = 'objects'
-    INSTRUCTION_CATEGORY_CONDITIONAL = 'conditional'
+    INSTRUCTION_CATEGORY_BINARY = 'binary'
+    INSTRUCTION_CATEGORY_CONTROL_FLOW = 'control_flow'
+    INSTRUCTION_CATEGORY_TERMINATING = 'terminating'
     INSTRUCTION_CATEGORY_LOGICAL = 'logical'
+    INSTRUCTION_CATEGORY_OBJECT = 'object'
     INSTRUCTION_CATEGORIES = [
       INSTRUCTION_CATEGORY_BASIC,
-      INSTRUCTION_CATEGORY_STATE,
-      INSTRUCTION_CATEGORY_UNTYPED,
-      INSTRUCTION_CATEGORY_NUMERIC,
-      INSTRUCTION_CATEGORY_STRING,
-      INSTRUCTION_CATEGORY_ENVIRONMENT,
-      INSTRUCTION_CATEGORY_METHODS,
-      INSTRUCTION_CATEGORY_OBJECTS,
-      INSTRUCTION_CATEGORY_CONDITIONAL,
-      INSTRUCTION_CATEGORY_LOGICAL
+      INSTRUCTION_CATEGORY_BINARY,
+      INSTRUCTION_CATEGORY_CONTROL_FLOW,
+      INSTRUCTION_CATEGORY_TERMINATING,
+      INSTRUCTION_CATEGORY_LOGICAL,
+      INSTRUCTION_CATEGORY_OBJECT
     ].freeze
     ## Instructions ##
     INSTRUCTIONS = [
-      # basic operations
-      { name: 'return', description: 'Return a value from a function.', category: INSTRUCTION_CATEGORY_BASIC },
-      { name: 'assign', description: 'Assign a value to a variable.', category: INSTRUCTION_CATEGORY_BASIC },
-      { name: 'panic', description: 'Exit, quickly, and loudly.', category: INSTRUCTION_CATEGORY_BASIC },
-      # state operations
-      { name: 'fetch_state', description: 'Fetch a value from the state.', category: INSTRUCTION_CATEGORY_STATE },
-      { name: 'save_state', description: 'Save a value to the state.', category: INSTRUCTION_CATEGORY_STATE },
-      # untyped operations
-      { name: 'add', description: 'Add two things of unknown types together.', category: INSTRUCTION_CATEGORY_UNTYPED },
-      { name: 'add_and_assign',
-        description: 'Add two things of unknown types together and then assign to the first one.',
-        category: INSTRUCTION_CATEGORY_UNTYPED },
-      { name: 'subtract', description: 'Subtract two things of unknown types together.',
-        category: INSTRUCTION_CATEGORY_UNTYPED },
-      { name: 'divide', description: 'Divide two things of unknown types together.',
-        category: INSTRUCTION_CATEGORY_UNTYPED },
-      { name: 'multiply', description: 'Multiply two things of unknown types together.',
-        category: INSTRUCTION_CATEGORY_UNTYPED },
-      # numeric operations
-      { name: 'add_numbers', description: 'Add two numbers.', category: INSTRUCTION_CATEGORY_NUMERIC },
-      { name: 'subtract_numbers', description: 'Subtract two numbers.', category: INSTRUCTION_CATEGORY_NUMERIC },
-      { name: 'multiply_numbers', description: 'Multiply two numbers.', category: INSTRUCTION_CATEGORY_NUMERIC },
-      { name: 'divide_numbers', description: 'Divide two numbers.', category: INSTRUCTION_CATEGORY_NUMERIC },
-      # string operations
-      { name: 'add_strings', description: 'Concatenate two strings.', category: INSTRUCTION_CATEGORY_STRING },
-      # environment operations
-      { name: 'contract_address', description: 'Get the contract address.',
-        category: INSTRUCTION_CATEGORY_ENVIRONMENT },
-      # method operations
-      { name: 'evaluate', description: 'Evaluate a method. Method name is the first input and arguments follow',
-        category: INSTRUCTION_CATEGORY_METHODS },
-      # object operations
-      { name: 'field', description: 'Reference an object field.', category: INSTRUCTION_CATEGORY_OBJECTS },
-      { name: 'initialize_udt', description: 'Instantiate UDT object.', category: INSTRUCTION_CATEGORY_OBJECTS },
-      # conditional operations
-      { name: 'conditional_jump', description: 'Jump to a label if first input is true.',
-        category: INSTRUCTION_CATEGORY_CONDITIONAL },
-      { name: 'unconditional_jump', description: 'Jump to a no matter what.',
-        category: INSTRUCTION_CATEGORY_CONDITIONAL },
-      # logical operations
-      { name: 'and', description: 'Logical AND.', category: INSTRUCTION_CATEGORY_LOGICAL },
-      { name: 'or', description: 'Logical OR.', category: INSTRUCTION_CATEGORY_LOGICAL }
+      { name: 'assign', description: 'given some input value, assign to ASSIGN_NAME',
+        category: INSTRUCTION_CATEGORY_BASIC },
+      { name: 'evaluate',
+        description: 'given a method name and 0 or more inputs, execute method. At this time, evaluate is a fairly loose catch-all for not explicitly defined operations', category: INSTRUCTION_CATEGORY_BASIC },
+      { name: 'print', description: 'given some value, print it to standard out',
+        category: INSTRUCTION_CATEGORY_BASIC },
+
+      { name: 'exit_with_message', description: 'immediately end execution, returning message',
+        category: INSTRUCTION_CATEGORY_TERMINATING },
+      { name: 'return', description: 'return from function with input value',
+        category: INSTRUCTION_CATEGORY_TERMINATING },
+
+      { name: 'and', description: 'lassign to ASSIGN_NAME result of “and-ing” two values',
+        category: INSTRUCTION_CATEGORY_LOGICAL },
+      { name: 'or', description: 'assign to ASSIGN_NAME result of “or-ing” two values',
+        category: INSTRUCTION_CATEGORY_LOGICAL },
+
+      { name: 'goto',
+        description: 'conditional if two inputs. In this case, first input is the condition to evaluate. If that is true, or there is only one input, move in code to the first input (a label name)', category: INSTRUCTION_CATEGORY_CONTROL_FLOW },
+      { name: 'jump',
+        description: 'conditional if two inputs. In this case, first input is the condition to evaluate. If that is true, or there is only one input, jump to scope level', category: INSTRUCTION_CATEGORY_CONTROL_FLOW },
+      { name: 'end_of_iteration_check',
+        description: 'check on input to see if at end of iteration. Return result to ASSIGN_NAME', category: INSTRUCTION_CATEGORY_CONTROL_FLOW },
+      { name: 'label', description: 'a named location within the instruction set for a given function',
+        category: INSTRUCTION_CATEGORY_CONTROL_FLOW },
+
+      { name: 'field', description: 'access a field on an object and assign result to ASSIGN_NAME',
+        category: INSTRUCTION_CATEGORY_OBJECT },
+      { name: 'instantiate_object',
+        description: 'initialize an object by first passing in the type of object and the passing in each initial values for its fields. Supported types here include: Dictionary, List, Range, Tuple, and UDT. For UDTs, the second input is the name of the UDT.', category: INSTRUCTION_CATEGORY_OBJECT },
+
+      { name: 'add', description: 'assign to ASSIGN_NAME result of adding two value',
+        category: INSTRUCTION_CATEGORY_BINARY },
+      { name: 'subtract', description: 'assign to ASSIGN_NAME result of subtracting two value',
+        category: INSTRUCTION_CATEGORY_BINARY },
+      { name: 'multiply', description: 'assign to ASSIGN_NAME result of multiplying two value',
+        category: INSTRUCTION_CATEGORY_BINARY },
+      { name: 'divide', description: 'assign to ASSIGN_NAME result of dividing two value',
+        category: INSTRUCTION_CATEGORY_BINARY }
     ].freeze
 
     # Supported Types for DTR.
-    TYPES = [
-      # basic types
-      'address',
-      'boolean',
-      # string types
-      'symbol',
-      # collection types
-      'array',
-      'map',
-      # numeric types
-      ## signed
-      'i32',
-      'i64',
-      'i128',
-      'i256',
-      ## unsigned
-      'u32',
-      'u64',
-      'u128',
-      'u256'
+    TYPES = %w[
+      Dictionary
+      List
+      Range
+      Tuple
+      UDT
+      Address
+      BigInteger
+      Boolean
+      Float
+      Integer
+      String
     ].freeze
   end
 end
+# rubocop:enable Layout/LineLength

data/lib/dtr_core/type_validator.rb

@@ -13,31 +13,79 @@ module DTRCore
     end
 
     def validate_then_coerce_initial_value!
+      validate_input!
+
+      return validate_integer! if %w[Integer BigInteger Float].include?(@type_name)
+      return validate_string! if ['String'].include?(@type_name)
+      return validate_address! if ['Address'].include?(@type_name)
+      return validate_boolean! if ['Boolean'].include?(@type_name)
+
+      raise 'Missing Invalid Type Name.'
+    end
+
+    private
+
+    def validate_input!
       raise 'Missing Type Name.' if @type_name.nil?
       raise 'Missing Initial Value.' if @initial_value.nil?
+    end
 
-      case @type_name
-      when 'I32', 'I64', 'I256', 'U32', 'U64', 'U256'
-        validate_numeric!
-
-      # TODO: check type
-      when 'Symbol', 'String'
-        strip_and_remove_quotes(@initial_value)
-      else
-        raise 'Missing Invalid Type Name.'
+    # TODO: implement deeper validation for Address type
+    # TODO: confirm this works for non-Stellar addresses
+    def validate_address!
+      raise "Invalid initial value for Address: #{@initial_value}. Wrong type." unless @initial_value.length == 56
+
+      @initial_value
+    end
+
+    def validate_string!
+      unless @initial_value.is_a?(String) && @initial_value.match(/".*"/)
+        raise "Invalid initial value for String: #{@initial_value}. Wrong type."
       end
+
+      @initial_value.strip
     end
 
-    private
+    def validate_boolean!
+      unless %w[true
+                false].include?(@initial_value)
+        raise "Invalid initial value for Boolean: #{@initial_value}. Wrong type."
+      end
 
-    def validate_numeric!
-      raise 'Invalid initial value for type. Wrong type.' unless @initial_value =~ (/^[\-\.\d]\d*(\.?\d*)*/)
+      @initial_value == 'true'
+    end
+
+    def validate_integer!
+      unless @initial_value =~ (/^[\-\.\d]\d*(\.?\d*)*/)
+        raise "Invalid initial value for #{@type_name}: #{@initial_value}. Wrong type."
+      end
 
       raise "Invalid initial value for type #{@type_name}. Out of range." unless @initial_value.to_i.between?(
         DTRCore::Number.const_get(:"MIN_#{@type_name}"), DTRCore::Number.const_get(:"MAX_#{@type_name}")
       )
 
-      @initial_value.to_i
+      handle_each_numeric_type!
+    end
+
+    def handle_each_numeric_type!
+      case @type_name
+      when 'Integer', 'BigInteger'
+        raise "Invalid initial value for #{@type_name}: #{@initial_value}. Wrong type." unless non_float_integer?
+
+        @initial_value.to_i
+      when 'Float'
+        raise "Invalid initial value for #{@type_name}: #{@initial_value}. Wrong type." unless floaty_float?
+
+        @initial_value.to_f
+      end
+    end
+
+    def non_float_integer?
+      @initial_value =~ (/^[\-\.\d]\d*(\.?\d*)*/) && !@initial_value.include?('.')
+    end
+
+    def floaty_float?
+      @initial_value =~ (/^[\-\.\d]\d*(\.?\d*)*/) && @initial_value.include?('.')
     end
   end
 end

data/lib/dtr_core/user_defined_type.rb

@@ -38,7 +38,7 @@ module DTRCore
     end
 
     def to_s
-      "#{name} { #{attributes.map { |x| "#{x[:name]}: #{x[:type]}" }.join("\n")} }"
+      "\t* (#{name})\n\t{\n#{@attributes.map { |x| "\t\t#{x[:name]}: #{x[:type]}" }.join("\n")}\n\t}"
     end
 
     def ==(other)

data/lib/dtr_core.rb

@@ -9,5 +9,7 @@ module DTRCore
   autoload :State, 'dtr_core/state'
   autoload :SupportedAttributes, 'dtr_core/supported_attributes'
   autoload :TypeValidator, 'dtr_core/type_validator'
+  autoload :InstructionValidator, 'dtr_core/instruction_validator'
+  autoload :Instruction, 'dtr_core/instruction'
   autoload :UserDefinedType, 'dtr_core/user_defined_type'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dtr_core
 version: !ruby/object:Gem::Version
-  version: 0.5.6
+  version: 0.6.2
 platform: ruby
 authors:
 - Rob Durst
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-07 00:00:00.000000000 Z
+date: 2024-06-17 00:00:00.000000000 Z
 dependencies: []
 description: Core smart contract intermediate language (Digicus Textual Representation)
   parser.
@@ -22,6 +22,8 @@ files:
 - lib/dtr_core/common.rb
 - lib/dtr_core/contract.rb
 - lib/dtr_core/function.rb
+- lib/dtr_core/instruction.rb
+- lib/dtr_core/instruction_validator.rb
 - lib/dtr_core/number.rb
 - lib/dtr_core/parser.rb
 - lib/dtr_core/state.rb