dtr_core 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6eb9933172ea48536b0efceffe9e9e222a54e37f214b8041dc5edd40c01f2d6
-  data.tar.gz: 731d58a093c47bfd2b63f4ea884d4422d703b2c2ba47baacbda105bfb02e2264
+  metadata.gz: ec65bed75c4955e0c231146f532fd7d1c35ed2e7617966681dce5718076ba0be
+  data.tar.gz: a192a2cc58e2b4dbdd6bae900751675236d1532fc869676badc0b79a043a33e7
 SHA512:
-  metadata.gz: '04824f70c5646161afb24637f614f1ba2431414cc5f98b8847b15f74299ba563957586ba40a88d36847d1cfce649462199a42508a0d276397dbe3f38d1ee7e59'
-  data.tar.gz: 106a92f8de4ca9385d44f510dbb942b05d073bd2584d7dabbfe7d3003d348a121c21765da246e2c450a25df92cfb5151d1b541cf5b28029d96acd6ff1875c423
+  metadata.gz: 703ec3bd6c1ffd80d0f872bd13351467819daa7dfd42737c33f90402fd66f11026e1d902e4e186449cdd913d4ee2db8489ccdb4b7afcb691f43c7c4cb4c2156e
+  data.tar.gz: 5a7fc13e8418ea5917ffa8aa70855922f920750e8b9ee6bde1b0d910daecbb567cf058ce3b819f2cdae4fff8ecd41858a89936c207693456e46b17a7db404386

data/lib/dtr_core/contract.rb

@@ -55,31 +55,31 @@ module DTRCore
     end
 
     def state_to_s
-      return '' if @state.nil?
+      return '' if @state.nil? || @state.empty?
 
       "[State]:\n#{@state&.map(&:to_s)&.join("\n")}\n:[State]\n"
     end
 
     def interface_to_s
-      return '' if @state.nil?
+      return '' if @interface.nil? || @interface.empty?
 
       "[Interface]:\n#{@interface&.map(&:to_s)&.join("\n")}\n:[Interface]\n"
     end
 
     def user_defined_types_to_s
-      return '' if @user_defined_types.nil?
+      return '' if @user_defined_types.nil? || @user_defined_types.empty?
 
       "[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?
+      return '' if @helpers.nil? || @helpers.empty?
 
       "[Helpers]:\n#{@helpers&.map(&:to_s)&.join("\n")}\n:[Helpers]\n"
     end
 
     def non_translatables_to_s
-      return '' if @non_translatables.nil?
+      return '' if @non_translatables.nil? || @non_translatables.empty?
 
       "[NonTranslatable]:\n#{@non_translatables}\n:[NonTranslatable]"
     end

data/lib/dtr_core/function.rb

@@ -98,7 +98,8 @@ module DTRCore
         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
+        instruction[/\s*scope:\s*(?<all>[^\s\,]+)/, 1].to_i || 0,
+        instruction[/\sid:\s*(?<all>[^\s,]+)/, 1].to_i || 0
       )
 
       raise "Invalid instruction: #{instruction}" unless instruction.valid?

data/lib/dtr_core/graph/lcpbt_forrest.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module DTRCore
+  module Graph
+    class LCPBT_Forrest
+      attr_accessor :trees
+
+      def initialize
+        @trees = []
+      end
+
+      def add_tree(tree)
+        @trees << tree
+      end
+
+      def traverse
+        @trees.map(&:traverse)
+      end
+
+      def traverse_with_indentation
+        @trees.map(&:traverse_with_indentation)
+      end
+
+      # This represents a traversal through a unique path, covering all trees in the forest
+      # only once. This is useful for code generation.
+      def traverse_to_ids
+        id_map = {}
+        result = []
+
+        traverse
+          .map { |x| x.map(&:id) }
+          .each do |x|
+            sub_result = []
+            x.each do |y|
+              next if id_map[y]
+
+              sub_result << y
+              id_map[y] = true
+            end
+            result << sub_result
+          end
+
+        result
+      end
+
+      def code_generator_traverse(&block)
+        traverse_with_indentation
+          .map { |tree| tree.reverse.uniq.reverse.map(&block) }
+      end
+
+      def size
+        @trees.size
+      end
+
+      def all_paths_to(instruction_id)
+        @trees.map { |x| x.all_paths_to(instruction_id) }.flatten(1).compact
+      end
+    end
+  end
+end

data/lib/dtr_core/graph/left_child_preferential_binary_tree.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module DTRCore
+  module Graph
+    class LeftChildPreferentialBinaryTree
+      attr_accessor :value, :left_child, :right_child, :tree_id
+
+      def initialize(value, indentation: 0)
+        @tree_id = SecureRandom.uuid
+        @indentation = indentation
+        @value = value
+        @left_child = nil
+        @right_child = nil
+      end
+
+      def set_left_child(node)
+        raise 'Left child already exists' if @left_child
+
+        @left_child = node
+      end
+
+      def set_right_child(node)
+        raise 'Right child already exists' if @right_child
+
+        @right_child = node
+      end
+
+      def traverse
+        result = []
+        result << @value
+        result += @left_child.traverse if @left_child
+        result += @right_child.traverse if @right_child
+        result
+      end
+
+      def traverse_with_indentation
+        result = []
+        result << [@value, @indentation]
+        result += @left_child.traverse_with_indentation if @left_child
+        result += @right_child.traverse_with_indentation if @right_child
+        result
+      end
+
+      def all_paths_to(instruction_id, cur_result: [])
+        if value.id == instruction_id
+          return cur_result.empty? ? [[instruction_id]] : cur_result + [instruction_id]
+        end
+
+        result = nil
+
+        if @left_child
+          left_child_traverse = @left_child.all_paths_to(instruction_id, cur_result: cur_result + [value.id])
+          result = left_child_traverse unless left_child_traverse.nil?
+        end
+
+        if @right_child
+          right_child_traverse = @right_child.all_paths_to(instruction_id, cur_result: cur_result + [value.id])
+          result = result.nil? ? right_child_traverse : [result, right_child_traverse]
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/dtr_core/graph/silviculturist.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module DTRCore
+  module Graph
+    class Silviculturist
+      attr_accessor :forrest
+
+      def initialize(instructions)
+        @instructions = instructions
+        @forrest = LCPBT_Forrest.new
+        @seen_instructions = {}
+      end
+
+      def make_forrest
+        index = 0
+        while index < @instructions.size
+          instructions = @instructions[index..]
+          scope = 0
+          tree = plant_trees(scope, instructions)
+          @forrest.add_tree(tree)
+
+          seen = true
+          while seen && index < @instructions.size
+            index += 1
+            seen = @instructions[index].nil? || @seen_instructions[@instructions[index].id]
+          end
+        end
+      end
+
+      def plant_trees(scope, instructions, from_id: nil, indentation: 0)
+        cur_instruction = instructions[0]
+
+        return nil if cur_instruction.nil?
+
+        if cur_instruction.scope != scope
+          return plant_trees(scope, instructions[1..], from_id: cur_instruction.id,
+                                                       indentation:)
+        end
+
+        return @seen_instructions[cur_instruction.id] if @seen_instructions[cur_instruction.id]
+
+        down_jump = cur_instruction.instruction == 'jump' && (
+          (cur_instruction.inputs.size == 1 && cur_instruction.inputs[0].to_i < scope) ||
+          (cur_instruction.inputs.size == 2 && cur_instruction.inputs[1].to_i < scope))
+
+        rest_of_instructions = instructions[1..]
+
+        tree = LeftChildPreferentialBinaryTree.new(cur_instruction,
+                                                   indentation: if down_jump
+                                                                  indentation - 1
+                                                                else
+                                                                  indentation
+                                                                end)
+        @seen_instructions[cur_instruction.id] = tree
+
+        case cur_instruction.instruction
+        when 'jump'
+          case cur_instruction.inputs.size
+          # unconditional jump
+          when 1
+            new_scope = cur_instruction.inputs[0].to_i
+
+            # halt when going back to 0
+            return tree if new_scope.zero?
+
+            tree.set_left_child(plant_trees(new_scope, rest_of_instructions, from_id: cur_instruction.id,
+                                                                             indentation: down_jump ? indentation - 1 : indentation + 1))
+          # conditional jump
+          when 2
+            # detour
+            new_scope = cur_instruction.inputs[1].to_i
+
+            tree.set_left_child(plant_trees(new_scope, rest_of_instructions,
+                                            from_id: cur_instruction.id, indentation: down_jump ? indentation - 1 : indentation + 1))
+            # continue
+            tree.set_right_child(plant_trees(scope, rest_of_instructions, from_id: cur_instruction.id,
+                                                                          indentation:))
+          # if-let
+          when 3
+            raise 'We do not yet support if-let statements'
+          end
+        # the way a goto works is that you want to drop out of the loop back to the scope you were at
+        # when you started the loop
+        when 'goto'
+          goto_target_id = cur_instruction.inputs[0].to_i
+          return_scope = @instructions.find { |x| x.id == goto_target_id }.scope
+
+          return tree if return_scope.zero?
+
+          # TODO: fix indentation
+          tree.set_left_child(plant_trees(return_scope.to_i, rest_of_instructions, from_id: cur_instruction.id,
+                                                                                   indentation:))
+        else
+          # left_child
+          tree.set_left_child(plant_trees(scope, rest_of_instructions, from_id: cur_instruction.id,
+                                                                       indentation:))
+        end
+
+        tree
+      end
+    end
+  end
+end

data/lib/dtr_core/instruction.rb

@@ -3,26 +3,29 @@
 module DTRCore
   # Instruction class
   class Instruction
-    attr_reader :instruction, :inputs, :assign, :scope
+    attr_reader :instruction, :inputs, :assign, :scope, :id
 
-    def initialize(instruction, inputs, assign, scope)
+    def initialize(instruction, inputs, assign, scope, id)
       @instruction = instruction
       @inputs = inputs
       @assign = assign
       @scope = scope
+      @id = id
     end
 
     def ==(other)
       instruction == other.instruction &&
         inputs == other.inputs &&
         assign == other.assign &&
-        scope == other.scope
+        scope == other.scope &&
+        id == other.id
     end
 
     def to_s
-      "{ instruction: #{instruction}, " \
+      assignment = @assign.nil? ? '' : "assign: #{@assign}, "
+      "{ id: #{id}, instruction: #{instruction}, " \
         "input: (#{inputs&.join(', ')}), " \
-        "assign: #{assign}, scope: #{scope} }"
+        "#{assignment}scope: #{scope} }"
     end
 
     def to_json(*_args)
@@ -30,7 +33,8 @@ module DTRCore
         instruction:,
         inputs:,
         assign:,
-        scope:
+        scope:,
+        id:
       }.to_json
     end
 

data/lib/dtr_core.rb

@@ -12,4 +12,11 @@ module DTRCore
   autoload :InstructionValidator, 'dtr_core/instruction_validator'
   autoload :Instruction, 'dtr_core/instruction'
   autoload :UserDefinedType, 'dtr_core/user_defined_type'
+
+  # A graph is a collection of nodes and edges representing the structure of a DTR file.
+  module Graph
+    autoload :LCPBT_Forrest, 'dtr_core/graph/lcpbt_forrest'
+    autoload :LeftChildPreferentialBinaryTree, 'dtr_core/graph/left_child_preferential_binary_tree'
+    autoload :Silviculturist, 'dtr_core/graph/silviculturist'
+  end
 end

metadata

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