dtr_core 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad7236ff8c846c7126d0d8e53f3d7cd5d6635eeefbca857dafdf22e85473cbe6
-  data.tar.gz: d8741a66894615c02d59be5ba8884f165acdcfdb045c2243c07c57c3116cb699
+  metadata.gz: ec65bed75c4955e0c231146f532fd7d1c35ed2e7617966681dce5718076ba0be
+  data.tar.gz: a192a2cc58e2b4dbdd6bae900751675236d1532fc869676badc0b79a043a33e7
 SHA512:
-  metadata.gz: 83a20837017ec8a60ae948918f6b1947332516248bac6f805bdfc12b7b2a5636d5f01157739c81167113a873218da6cf55b22c297e1903718c9913b29322f2f7
-  data.tar.gz: 42b2bd3b5ef207d88fe3a955a9358ea54270979115df12e10d2318d6d230c80e8d858979d9d91df91bd2158153dd93f0d2e8efd15e0e27c4f261dee6432d660d
+  metadata.gz: 703ec3bd6c1ffd80d0f872bd13351467819daa7dfd42737c33f90402fd66f11026e1d902e4e186449cdd913d4ee2db8489ccdb4b7afcb691f43c7c4cb4c2156e
+  data.tar.gz: 5a7fc13e8418ea5917ffa8aa70855922f920750e8b9ee6bde1b0d910daecbb567cf058ce3b819f2cdae4fff8ecd41858a89936c207693456e46b17a7db404386

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.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.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Rob Durst
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-09 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