syntax_tree 5.1.0 → 5.2.0

data/lib/syntax_tree/yarv.rb

@@ -1,277 +1,8 @@
 # frozen_string_literal: true
 
-require "forwardable"
-
 module SyntaxTree
   # This module provides an object representation of the YARV bytecode.
   module YARV
-    class VM
-      class Jump
-        attr_reader :name
-
-        def initialize(name)
-          @name = name
-        end
-      end
-
-      class Leave
-        attr_reader :value
-
-        def initialize(value)
-          @value = value
-        end
-      end
-
-      class Frame
-        attr_reader :iseq, :parent, :stack_index, :_self, :nesting, :svars
-
-        def initialize(iseq, parent, stack_index, _self, nesting)
-          @iseq = iseq
-          @parent = parent
-          @stack_index = stack_index
-          @_self = _self
-          @nesting = nesting
-          @svars = {}
-        end
-      end
-
-      class TopFrame < Frame
-        def initialize(iseq)
-          super(iseq, nil, 0, TOPLEVEL_BINDING.eval("self"), [Object])
-        end
-      end
-
-      class BlockFrame < Frame
-        def initialize(iseq, parent, stack_index)
-          super(iseq, parent, stack_index, parent._self, parent.nesting)
-        end
-      end
-
-      class MethodFrame < Frame
-        attr_reader :name, :block
-
-        def initialize(iseq, parent, stack_index, _self, name, block)
-          super(iseq, parent, stack_index, _self, parent.nesting)
-          @name = name
-          @block = block
-        end
-      end
-
-      class ClassFrame < Frame
-        def initialize(iseq, parent, stack_index, _self)
-          super(iseq, parent, stack_index, _self, parent.nesting + [_self])
-        end
-      end
-
-      class FrozenCore
-        define_method("core#hash_merge_kwd") { |left, right| left.merge(right) }
-
-        define_method("core#hash_merge_ptr") do |hash, *values|
-          hash.merge(values.each_slice(2).to_h)
-        end
-
-        define_method("core#set_method_alias") do |clazz, new_name, old_name|
-          clazz.alias_method(new_name, old_name)
-        end
-
-        define_method("core#set_variable_alias") do |new_name, old_name|
-          # Using eval here since there isn't a reflection API to be able to
-          # alias global variables.
-          eval("alias #{new_name} #{old_name}", binding, __FILE__, __LINE__)
-        end
-
-        define_method("core#set_postexe") { |&block| END { block.call } }
-
-        define_method("core#undef_method") do |clazz, name|
-          clazz.undef_method(name)
-        end
-      end
-
-      FROZEN_CORE = FrozenCore.new.freeze
-
-      extend Forwardable
-
-      attr_reader :stack
-      def_delegators :stack, :push, :pop
-
-      attr_reader :frame
-      def_delegators :frame, :_self
-
-      def initialize
-        @stack = []
-        @frame = nil
-      end
-
-      ##########################################################################
-      # Helper methods for frames
-      ##########################################################################
-
-      def run_frame(frame)
-        # First, set the current frame to the given value.
-        @frame = frame
-
-        # Next, set up the local table for the frame. This is actually incorrect
-        # as it could use the values already on the stack, but for now we're
-        # just doing this for simplicity.
-        frame.iseq.local_table.size.times { push(nil) }
-
-        # Yield so that some frame-specific setup can be done.
-        yield if block_given?
-
-        # This hash is going to hold a mapping of label names to their
-        # respective indices in our instruction list.
-        labels = {}
-
-        # This array is going to hold our instructions.
-        insns = []
-
-        # Here we're going to preprocess the instruction list from the
-        # instruction sequence to set up the labels hash and the insns array.
-        frame.iseq.insns.each do |insn|
-          case insn
-          when Integer, Symbol
-            # skip
-          when InstructionSequence::Label
-            labels[insn.name] = insns.length
-          else
-            insns << insn
-          end
-        end
-
-        # Finally we can execute the instructions one at a time. If they return
-        # jumps or leaves we will handle those appropriately.
-        pc = 0
-        while pc < insns.length
-          insn = insns[pc]
-          pc += 1
-
-          case (result = insn.call(self))
-          when Jump
-            pc = labels[result.name]
-          when Leave
-            return result.value
-          end
-        end
-      ensure
-        @stack = stack[0...frame.stack_index]
-        @frame = frame.parent
-      end
-
-      def run_top_frame(iseq)
-        run_frame(TopFrame.new(iseq))
-      end
-
-      def run_block_frame(iseq, *args, &block)
-        run_frame(BlockFrame.new(iseq, frame, stack.length)) do
-          locals = [*args, block]
-          iseq.local_table.size.times do |index|
-            local_set(index, 0, locals.shift)
-          end
-        end
-      end
-
-      def run_class_frame(iseq, clazz)
-        run_frame(ClassFrame.new(iseq, frame, stack.length, clazz))
-      end
-
-      def run_method_frame(name, iseq, _self, *args, **kwargs, &block)
-        run_frame(
-          MethodFrame.new(iseq, frame, stack.length, _self, name, block)
-        ) do
-          locals = [*args, block]
-
-          if iseq.argument_options[:keyword]
-            # First, set up the keyword bits array.
-            keyword_bits =
-              iseq.argument_options[:keyword].map do |config|
-                kwargs.key?(config.is_a?(Array) ? config[0] : config)
-              end
-
-            iseq.local_table.locals.each_with_index do |local, index|
-              # If this is the keyword bits local, then set it appropriately.
-              if local.name == 2
-                locals.insert(index, keyword_bits)
-                next
-              end
-
-              # First, find the configuration for this local in the keywords
-              # list if it exists.
-              name = local.name
-              config =
-                iseq.argument_options[:keyword].find do |keyword|
-                  keyword.is_a?(Array) ? keyword[0] == name : keyword == name
-                end
-
-              # If the configuration doesn't exist, then the local is not a
-              # keyword local.
-              next unless config
-
-              if !config.is_a?(Array)
-                # required keyword
-                locals.insert(index, kwargs.fetch(name))
-              elsif !config[1].nil?
-                # optional keyword with embedded default value
-                locals.insert(index, kwargs.fetch(name, config[1]))
-              else
-                # optional keyword with expression default value
-                locals.insert(index, nil)
-              end
-            end
-          end
-
-          iseq.local_table.size.times do |index|
-            local_set(index, 0, locals.shift)
-          end
-        end
-      end
-
-      ##########################################################################
-      # Helper methods for instructions
-      ##########################################################################
-
-      def const_base
-        frame.nesting.last
-      end
-
-      def frame_at(level)
-        current = frame
-        level.times { current = current.parent }
-        current
-      end
-
-      def frame_svar
-        current = frame
-        current = current.parent while current.is_a?(BlockFrame)
-        current
-      end
-
-      def frame_yield
-        current = frame
-        current = current.parent until current.is_a?(MethodFrame)
-        current
-      end
-
-      def frozen_core
-        FROZEN_CORE
-      end
-
-      def jump(label)
-        Jump.new(label.name)
-      end
-
-      def leave
-        Leave.new(pop)
-      end
-
-      def local_get(index, level)
-        stack[frame_at(level).stack_index + index]
-      end
-
-      def local_set(index, level, value)
-        stack[frame_at(level).stack_index + index] = value
-      end
-    end
-
     # Compile the given source into a YARV instruction sequence.
     def self.compile(source, options = Compiler::Options.new)
       SyntaxTree.parse(source).accept(Compiler.new(options))

data/lib/syntax_tree.rb

@@ -37,6 +37,7 @@ require_relative "syntax_tree/yarv/instructions"
 require_relative "syntax_tree/yarv/legacy"
 require_relative "syntax_tree/yarv/local_table"
 require_relative "syntax_tree/yarv/assembler"
+require_relative "syntax_tree/yarv/vm"
 
 # Syntax Tree is a suite of tools built on top of the internal CRuby parser. It
 # provides the ability to generate a syntax tree from source, as well as the

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: syntax_tree
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 5.2.0
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-29 00:00:00.000000000 Z
+date: 2023-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prettier_print
@@ -99,6 +99,7 @@ email:
 - kddnewton@gmail.com
 executables:
 - stree
+- yarv
 extensions: []
 extra_rdoc_files: []
 files:
@@ -108,6 +109,7 @@ files:
 - ".github/workflows/gh-pages.yml"
 - ".github/workflows/main.yml"
 - ".gitignore"
+- ".gitmodules"
 - ".rubocop.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
@@ -122,6 +124,7 @@ files:
 - config/rubocop.yml
 - doc/logo.svg
 - exe/stree
+- exe/yarv
 - lib/syntax_tree.rb
 - lib/syntax_tree/basic_visitor.rb
 - lib/syntax_tree/cli.rb
@@ -158,6 +161,7 @@ files:
 - lib/syntax_tree/yarv/instructions.rb
 - lib/syntax_tree/yarv/legacy.rb
 - lib/syntax_tree/yarv/local_table.rb
+- lib/syntax_tree/yarv/vm.rb
 - syntax_tree.gemspec
 homepage: https://github.com/kddnewton/syntax_tree
 licenses:
@@ -179,7 +183,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.21
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: A parser based on ripper