dtr_core 0.10.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad7236ff8c846c7126d0d8e53f3d7cd5d6635eeefbca857dafdf22e85473cbe6
-  data.tar.gz: d8741a66894615c02d59be5ba8884f165acdcfdb045c2243c07c57c3116cb699
+  metadata.gz: 63137198f11287cf84f4a62df74afb125146867e2379f59b73a6146840051748
+  data.tar.gz: d3967276a7b33fbd0e1db027754b22746e5e464a087445466417e79a1c4730e1
 SHA512:
-  metadata.gz: 83a20837017ec8a60ae948918f6b1947332516248bac6f805bdfc12b7b2a5636d5f01157739c81167113a873218da6cf55b22c297e1903718c9913b29322f2f7
-  data.tar.gz: 42b2bd3b5ef207d88fe3a955a9358ea54270979115df12e10d2318d6d230c80e8d858979d9d91df91bd2158153dd93f0d2e8efd15e0e27c4f261dee6432d660d
+  metadata.gz: 41066cf773aa89c5bcf005ca9306b5286f1c8a5d84e73d8a43feee2754c33c0f2228a8576c99d744a55e6d1e2554d55edace7d39494da3580f871e79ac4529a7
+  data.tar.gz: ca54b572bad2667dd337184ac9b5c74addcdf5290912e0efe8e707bc7cf545dc1ab098c0f9015b55f700aee46de5a5c8f8296e97333026840441ffe2f71250df

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.1
 platform: ruby
 authors:
 - Rob Durst
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-07-09 00:00:00.000000000 Z
+date: 2024-07-14 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
@@ -35,7 +38,7 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -50,8 +53,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.13
-signing_key:
+rubygems_version: 3.4.10
+signing_key: 
 specification_version: 4
 summary: Core smart contract intermediate language (Digicus Textual Representation)
   parser.