yruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b7ea42800360e25a4e07044414522e6db405ac3a49c638de709682a37e179e4a
+  data.tar.gz: '06669269c7f3bdddd63984276ef5e0efd88cbcd704e47881e79936c2496ab937'
+SHA512:
+  metadata.gz: 3f301b9319a04cf8fb011d170b35c791e980a4b613e8a67a32d1469c50aef0b78d1f18570ef1af98d03cb584bfb9ddd424bfc7bb25cc101fddaf7e89a744b016
+  data.tar.gz: 4b97d1b57a82adc478e482b27e18c9ba4dd4d6bb80f8105efd0a8bb717075f7f16cf4917b7298c5aeb78f2a69c833478b8f901abfa830c76b7e888aebb1e8d59

data/README.md

@@ -0,0 +1,199 @@
+# YRuby
+
+YRuby is a Ruby virtual machine implementation based on CRuby's YARV (Yet Another Ruby VM) architecture. It parses Ruby source code with the [Prism](https://github.com/ruby/prism) gem and executes it through a stack-based bytecode interpreter.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'yruby'
+```
+
+Or install it directly:
+
+```
+$ gem install yruby
+```
+
+## Requirements
+
+- Ruby >= 3.3.0
+- [prism](https://rubygems.org/gems/prism) ~> 1.0
+
+## Usage
+
+### Basic Usage
+
+```ruby
+require 'yruby'
+
+vm = YRuby.new
+
+vm.exec("1 + 2")           # => 3
+vm.exec("if true; 42; end") # => 42
+```
+
+Each call to `exec` is independent — the VM state is reinitialized on every call.
+
+### API
+
+#### `YRuby.new(parser = YRuby::Parser.new) -> YRuby`
+
+Creates a new VM instance. Uses the default Prism-based parser if none is provided.
+
+| Parameter | Type           | Description                                  |
+|-----------|----------------|----------------------------------------------|
+| `parser`  | `YRuby::Parser` | Parser instance to use for parsing (optional) |
+
+#### `YRuby#exec(source) -> Object`
+
+Parses and executes the given Ruby source string, returning the result of the last evaluated expression.
+
+| Parameter | Type     | Description                  |
+|-----------|----------|------------------------------|
+| `source`  | `String` | Ruby source code to execute  |
+
+```ruby
+vm = YRuby.new
+
+# Literals
+vm.exec("42")           # => 42
+vm.exec("nil")          # => nil
+vm.exec("true")         # => true
+
+# Arithmetic
+vm.exec("1 + 2")        # => 3
+vm.exec("10 - 3")       # => 7
+vm.exec("4 * 5")        # => 20
+vm.exec("10 / 2")       # => 5
+
+# Local variables
+vm.exec(<<~RUBY)        # => 11
+  a = 10
+  a + 1
+RUBY
+
+# Conditionals
+vm.exec(<<~RUBY)        # => 1
+  if true
+    1
+  else
+    2
+  end
+RUBY
+
+vm.exec(<<~RUBY)        # => 2
+  if false
+    1
+  elsif true
+    2
+  end
+RUBY
+
+# Method definition and call
+vm.exec(<<~RUBY)        # => 3
+  def add(a, b)
+    a + b
+  end
+  add(1, 2)
+RUBY
+```
+
+#### `YRuby::Parser#parse(source) -> Prism::ParseResult`
+
+Parses Ruby source code and returns a Prism AST result. This is used internally by `YRuby#exec` and is rarely needed directly.
+
+#### `YRuby::Iseq.iseq_new_main(ast) -> YRuby::Iseq`
+
+Compiles a Prism AST into an instruction sequence for the top-level scope.
+
+#### `YRuby::Iseq.iseq_new_method(def_node) -> YRuby::Iseq`
+
+Compiles a method definition node into an instruction sequence.
+
+#### `YRuby::Iseq#disasm -> String`
+
+Returns a human-readable disassembly of the instruction sequence. Useful for debugging and learning.
+
+```ruby
+parser = YRuby::Parser.new
+iseq = YRuby::Iseq.iseq_new_main(parser.parse("1 + 2"))
+puts iseq.disasm
+# 0000 putobject          1
+# 0002 putobject          2
+# 0004 opt_plus
+# 0005 leave
+```
+
+## Supported Ruby Features
+
+| Feature                        | Example                                      |
+|-------------------------------|----------------------------------------------|
+| Integer literals              | `42`, `0`, `-1`                              |
+| Boolean / nil literals        | `true`, `false`, `nil`                       |
+| Arithmetic operators          | `a + b`, `a - b`, `a * b`, `a / b`          |
+| Local variable read/write     | `a = 1; a`                                   |
+| `if` / `else` / `elsif`       | `if cond; ...; elsif ...; else; ...; end`    |
+| `if` as expression            | `x = if true; 1; else; 2; end`              |
+| Method definition             | `def add(a, b); a + b; end`                  |
+| Method call                   | `add(1, 2)`                                  |
+| Multiple statements           | `1; 2; 3`                                    |
+
+## Instruction Set
+
+YRuby implements the following YARV-like instructions:
+
+| Instruction              | Operands    | Description                                   |
+|--------------------------|-------------|-----------------------------------------------|
+| `putobject`              | `value`     | Push a constant value onto the stack          |
+| `putnil`                 | —           | Push `nil` onto the stack                     |
+| `putself`                | —           | Push the current receiver onto the stack      |
+| `dup`                    | —           | Duplicate the top of the stack                |
+| `getlocal`               | `idx`       | Push a local variable value onto the stack    |
+| `setlocal`               | `idx`       | Pop and store a value into a local variable   |
+| `opt_plus`               | —           | Pop two values and push their sum             |
+| `opt_minus`              | —           | Pop two values and push their difference      |
+| `opt_mult`               | —           | Pop two values and push their product         |
+| `opt_div`                | —           | Pop two values and push their quotient        |
+| `branchunless`           | `offset`    | Jump if the popped value is falsy             |
+| `jump`                   | `offset`    | Unconditional jump                            |
+| `definemethod`           | `mid, iseq` | Register a method on the current object       |
+| `opt_send_without_block` | `cd`        | Dispatch a method call                        |
+| `leave`                  | —           | Exit the current frame and return a value     |
+
+## Architecture
+
+```
+Source Code → Parser (Prism) → AST → Compile → Iseq → VM Execution → Result
+```
+
+### CRuby Mapping
+
+The internal structure mirrors CRuby's implementation:
+
+```
+lib/
+├── yruby.rb              # vm.c, vm_exec.c   — VM core and execution loop
+└── yruby/
+    ├── core.rb           # vm_core.h         — ExecutionContext, ControlFrame
+    ├── insnhelper.rb     # vm_insnhelper.c   — stack/frame/env operations
+    ├── parser.rb         # parse.y           — Prism wrapper
+    ├── compile.rb        # compile.c         — AST → bytecode compiler
+    ├── iseq.rb           # iseq.c / iseq.h   — instruction sequence
+    ├── rclass.rb         #                   — class and method table
+    ├── robject.rb        #                   — object instances
+    ├── insns.rb          # insns.def         — instruction aggregation
+    └── insns/            # insns.def         — individual instruction classes
+```
+
+## Development
+
+```
+$ bundle install
+$ bundle exec rake test
+```
+
+## License
+
+[MIT](LICENSE)

data/lib/yruby/compile.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+class YRuby
+  class Compile
+    def iseq_compile_node(iseq, node)
+      @index_lookup_table = {}
+      insert_local_index(@index_lookup_table, node.locals)
+      iseq_set_local_table(iseq, node.locals)
+      compile_node(iseq, node)
+    end
+
+    def iseq_compile_method(iseq, def_node)
+      @index_lookup_table = {}
+      insert_local_index(@index_lookup_table, def_node.locals)
+      iseq_set_local_table(iseq, def_node.locals)
+
+      if def_node.body
+        compile_node(iseq, def_node.body)
+      else
+        iseq.emit(YRuby::Insns::Putnil)
+      end
+    end
+
+    private
+
+    def insert_local_index(index_lookup_table, locals)
+      locals.reverse_each.with_index do |local, index|
+        index_lookup_table[local] = index
+      end
+    end
+
+    def iseq_set_local_table(iseq, locals)
+      iseq.local_table_size = locals.size
+      iseq.local_table = locals.dup
+    end
+
+    def compile_node(iseq, node)
+      case node
+      when Prism::ProgramNode
+        compile_node(iseq, node.statements)
+      when Prism::StatementsNode
+        node.body.each { |stmt| compile_node(iseq, stmt) }
+      when Prism::IntegerNode
+        iseq.emit(YRuby::Insns::Putobject, node.value)
+      when Prism::NilNode
+        iseq.emit(YRuby::Insns::Putnil)
+      when Prism::TrueNode
+        iseq.emit(YRuby::Insns::Putobject, true)
+      when Prism::FalseNode
+        iseq.emit(YRuby::Insns::Putobject, false)
+      when Prism::CallNode
+        compile_call_node(iseq, node)
+      when Prism::ArgumentsNode
+        node.arguments.each { |arg| compile_node(iseq, arg) }
+      when Prism::LocalVariableWriteNode
+        compile_node(iseq, node.value)
+        iseq.emit(YRuby::Insns::Dup)
+        idx = @index_lookup_table[node.name]
+        iseq.emit(YRuby::Insns::Setlocal, idx)
+      when Prism::LocalVariableReadNode
+        idx = @index_lookup_table[node.name]
+        iseq.emit(YRuby::Insns::Getlocal, idx)
+      when Prism::IfNode
+        compile_conditional_node(iseq, node)
+      when Prism::DefNode
+        compile_def_node(iseq, node)
+      else
+        raise "Unknown node: #{node.class}"
+      end
+    end
+
+    def compile_call_node(iseq, node)
+      if node.receiver.nil?
+        iseq.emit(YRuby::Insns::Putself)
+        argc = 0
+        if node.arguments
+          compile_node(iseq, node.arguments)
+          argc = node.arguments.arguments.size
+        end
+        cd = CallData.new(mid: node.name, argc:)
+        iseq.emit(YRuby::Insns::OptSendWithoutBlock, cd)
+      else
+        compile_node(iseq, node.receiver)
+        compile_node(iseq, node.arguments)
+
+        case node.name
+        when :+; iseq.emit(YRuby::Insns::OptPlus)
+        when :-; iseq.emit(YRuby::Insns::OptMinus)
+        when :*; iseq.emit(YRuby::Insns::OptMult)
+        when :/; iseq.emit(YRuby::Insns::OptDiv)
+        else
+          raise "Unknown operator: #{node.name}"
+        end
+      end
+    end
+
+    def compile_def_node(iseq, node)
+      method_iseq = YRuby::Iseq.iseq_new_method(node)
+      iseq.emit(YRuby::Insns::Definemethod, node.name, method_iseq)
+      iseq.emit(YRuby::Insns::Putobject, node.name)
+    end
+
+    def compile_conditional_node(iseq, node)
+      compile_node(iseq, node.predicate)
+      branchunless_pc = iseq.size
+      iseq.emit_placeholder(YRuby::Insns::Branchunless::LEN)
+
+      # then statements
+      compile_node(iseq, node.statements)
+
+      then_end_pc = iseq.size
+      iseq.emit_placeholder(YRuby::Insns::Jump::LEN)
+
+      else_label = iseq.size
+      branchunless_offset = else_label - (branchunless_pc + YRuby::Insns::Branchunless::LEN)
+      iseq.patch_at!(branchunless_pc, YRuby::Insns::Branchunless, branchunless_offset)
+
+      # elsif / else statements
+      case node.subsequent
+      when Prism::IfNode
+        compile_conditional_node(iseq, node.subsequent)
+      when Prism::ElseNode
+        compile_node(iseq, node.subsequent.statements)
+      end
+
+      end_label = iseq.size
+      jump_offset = end_label - (then_end_pc + YRuby::Insns::Jump::LEN)
+      iseq.patch_at!(then_end_pc, YRuby::Insns::Jump, jump_offset)
+    end
+  end
+end

data/lib/yruby/core.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'iseq'
+require_relative 'compile'
+require_relative 'insns'
+require_relative 'parser'
+require_relative 'insnhelper'
+
+class YRuby
+  STACK_SIZE = 128.freeze
+
+  FRAME_TYPE_TOP = :top
+  FRAME_TYPE_METHOD = :method
+
+  ControlFrame = Struct.new(:iseq, :pc, :sp, :ep, :type, :self_value, keyword_init: true)
+  ExecutionContext = Struct.new(:stack, :stack_size, :cfp, :frames, keyword_init: true)
+
+  CallData = Struct.new(:mid, :argc, keyword_init: true)
+end

data/lib/yruby/insnhelper.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+class YRuby
+  module InsnHelper
+    extend Forwardable
+
+    def_delegators :ec, :cfp, :cfp=, :stack, :stack=, :frames
+
+    module Macros
+      # Value Stack
+      def push(x)
+        set_sv(x)
+        inc_sp(1)
+      end
+
+      def topn(x)
+        stack[cfp.sp - x]
+      end
+
+      def pop
+        cfp.sp -= 1
+        val = stack[cfp.sp]
+        stack[cfp.sp] = nil
+        val
+      end
+
+      # PC
+      def add_pc(x)
+        cfp.pc += x
+      end
+
+      # environment pointer
+      def get_ep
+        cfp.ep
+      end
+
+      # SP
+      def set_sv(x)
+        stack[cfp.sp] = x
+      end
+
+      def inc_sp(x)
+        cfp.sp += x
+      end
+    end
+
+    # Control Frame
+    def push_frame(iseq:, type: FRAME_TYPE_TOP, self_value: nil, sp:)
+      sp = sp + iseq.local_table_size
+      ep = sp - 1
+
+      cf = ControlFrame.new(iseq:, pc: 0, sp:, ep:, type:, self_value:)
+      frames.push(cf)
+      self.cfp = cf
+    end
+
+    def pop_frame
+      frames.pop
+      self.cfp = frames.last
+    end
+
+    # Environment Pointer
+    def env_read(index)
+      stack[get_ep + index]
+    end
+
+    def env_write(index, value)
+      stack[get_ep + index] = value
+    end
+
+    def define_method(mid, iseq)
+      klass = cfp.self_value.klass
+
+      klass.add_method_iseq(mid, iseq)
+    end
+
+    def call_iseq_setup(recv, argc, method_iseq)
+      argv_index = cfp.sp - argc
+      recv_index = argv_index - 1
+
+      cfp.sp = recv_index
+
+      push_frame(
+        iseq: method_iseq,
+        type: FRAME_TYPE_METHOD,
+        self_value: recv,
+        sp: argv_index
+      )
+
+      local_only_size = method_iseq.local_table_size - method_iseq.argc
+      local_only_size.times do |i|
+        env_write(-i, nil)
+      end
+    end
+
+    def sendish(cd)
+      argc = cd.argc
+      recv = topn(argc + 1)
+
+      klass = recv.klass
+      method_iseq = klass.search_method(cd.mid)
+
+      raise "undefined method #{cd.mid}" if method_iseq.nil?
+
+      call_iseq_setup(recv, argc, method_iseq)
+    end
+  end
+end

data/lib/yruby/insns/base.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class YRuby
+  module Insns
+    class Base
+      LEN = 1
+
+      def self.call(vm)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/yruby/insns/branchunless.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class YRuby
+  module Insns
+    class Branchunless < Base
+      LEN = 2
+
+      def self.call(vm, dst)
+        val = vm.topn(1)
+        vm.pop
+
+        vm.add_pc(dst) unless val
+      end
+    end
+  end
+end

data/lib/yruby/insns/definemethod.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class YRuby
+  module Insns
+    class Definemethod < Base
+      LEN = 3
+
+      def self.call(vm, mid, iseq)
+        vm.define_method(mid, iseq)
+      end
+    end
+  end
+end

data/lib/yruby/insns/dup.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class YRuby
+  module Insns
+    class Dup < Base
+      def self.call(vm)
+        val = vm.topn(1)
+        vm.push(val)
+      end
+    end
+  end
+end

data/lib/yruby/insns/getlocal.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class YRuby
+  module Insns
+    class Getlocal < Base
+      LEN = 2
+
+      def self.call(vm, idx)
+        val = vm.env_read(-idx)
+        vm.push(val)
+      end
+    end
+  end
+end

data/lib/yruby/insns/jump.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class YRuby
+  module Insns
+    class Jump < Base
+      LEN = 2
+
+      def self.call(vm, dst)
+        vm.add_pc(dst)
+      end
+    end
+  end
+end

data/lib/yruby/insns/leave.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class YRuby
+  module Insns
+    class Leave < Base
+      def self.call(vm)
+        val = vm.topn(1)
+        vm.pop
+
+        type = vm.cfp.type
+        vm.pop_frame
+
+        case type
+        when YRuby::FRAME_TYPE_METHOD
+          vm.push(val)
+        when YRuby::FRAME_TYPE_TOP
+          throw :finish, val
+        end
+      end
+    end
+  end
+end

data/lib/yruby/insns/opt_div.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class YRuby
+  module Insns
+    class OptDiv < Base
+      def self.call(vm)
+        recv = vm.topn(2)
+        arg = vm.topn(1)
+        vm.pop
+        vm.pop
+        vm.push(recv / arg)
+      end
+    end
+  end
+end

data/lib/yruby/insns/opt_minus.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class YRuby
+  module Insns
+    class OptMinus < Base
+      def self.call(vm)
+        recv = vm.topn(2)
+        arg = vm.topn(1)
+        vm.pop
+        vm.pop
+        vm.push(recv - arg)
+      end
+    end
+  end
+end

data/lib/yruby/insns/opt_mult.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class YRuby
+  module Insns
+    class OptMult < Base
+      def self.call(vm)
+        recv = vm.topn(2)
+        arg = vm.topn(1)
+        vm.pop
+        vm.pop
+        vm.push(recv * arg)
+      end
+    end
+  end
+end

data/lib/yruby/insns/opt_plus.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class YRuby
+  module Insns
+    class OptPlus < Base
+      def self.call(vm)
+        recv = vm.topn(2)
+        arg = vm.topn(1)
+        vm.pop
+        vm.pop
+        vm.push(recv + arg)
+      end
+    end
+  end
+end

data/lib/yruby/insns/opt_send_without_block.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class YRuby
+  module Insns
+    class OptSendWithoutBlock < Base
+      LEN = 2
+
+      def self.call(vm, cd)
+        vm.sendish(cd)
+      end
+    end
+  end
+end

data/lib/yruby/insns/putnil.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class YRuby
+  module Insns
+    class Putnil < Base
+      def self.call(vm)
+        vm.push(nil)
+      end
+    end
+  end
+end

data/lib/yruby/insns/putobject.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class YRuby
+  module Insns
+    class Putobject < Base
+      LEN = 2
+
+      def self.call(vm, value)
+        vm.push(value)
+      end
+    end
+  end
+end

data/lib/yruby/insns/putself.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class YRuby
+  module Insns
+    class Putself < Base
+      def self.call(vm)
+        vm.push(vm.cfp.self_value)
+      end
+    end
+  end
+end

data/lib/yruby/insns/setlocal.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class YRuby
+  module Insns
+    class Setlocal < Base
+      LEN = 2
+
+      def self.call(vm, idx)
+        val = vm.pop
+        vm.env_write(-idx, val)
+      end
+    end
+  end
+end

data/lib/yruby/insns.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'insns/base'
+require_relative 'insns/putobject'
+require_relative 'insns/putnil'
+require_relative 'insns/leave'
+require_relative 'insns/opt_plus'
+require_relative 'insns/opt_minus'
+require_relative 'insns/opt_mult'
+require_relative 'insns/opt_div'
+require_relative 'insns/getlocal'
+require_relative 'insns/setlocal'
+require_relative 'insns/dup'
+require_relative 'insns/branchunless'
+require_relative 'insns/jump'
+require_relative 'insns/definemethod'
+require_relative 'insns/putself'
+require_relative 'insns/opt_send_without_block'

data/lib/yruby/iseq.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+class YRuby
+  class Iseq
+    class << self
+      def iseq_new_main(ast)
+        node = ast.value
+
+        iseq = new
+
+        Compile.new.iseq_compile_node(iseq, node)
+
+        iseq.emit(Insns::Leave)
+
+        iseq
+      end
+
+      def iseq_new_method(def_node)
+        iseq = new
+
+        Compile.new.iseq_compile_method(iseq, def_node)
+
+        iseq.emit(Insns::Leave)
+
+        params = def_node.parameters
+        iseq.argc = params ? params.requireds.size : 0
+
+        iseq
+      end
+    end
+
+    attr_accessor :local_table, :local_table_size, :argc
+
+    def initialize
+      @iseq_encoded = []
+      @local_table = []
+      @local_table_size = 0
+      @argc = 0
+    end
+
+    def emit(insn_class, *operands)
+      @iseq_encoded << insn_class
+      operands.each { |op| @iseq_encoded << op }
+    end
+
+    def emit_placeholder(len)
+      len.times { @iseq_encoded << nil }
+    end
+
+    def patch_at!(pc, insn_class, *operands)
+      @iseq_encoded[pc] = insn_class
+      operands.each_with_index do |op, i|
+        @iseq_encoded[pc + 1 + i] = op
+      end
+    end
+
+    def fetch(pc)
+      @iseq_encoded[pc]
+    end
+
+    def size
+      @iseq_encoded.size
+    end
+
+    def disasm
+      lines = []
+      lines << "== disasm: #<ISeq:<main>@<compiled>:1> =="
+
+      pc = 0
+      while pc < @iseq_encoded.size
+        insn_class = @iseq_encoded[pc]
+        len = insn_class::LEN
+        operands = @iseq_encoded[pc + 1, len - 1]
+        name = insn_class.name.split('::').last.downcase
+        if operands.empty?
+          lines << format("%04d %s", pc, name)
+        else
+          lines << format("%04d %s %s", pc, name, operands.map(&:inspect).join(', '))
+        end
+        pc += len
+      end
+
+      lines.join("\n")
+    end
+  end
+end

data/lib/yruby/parser.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'prism'
+
+class YRuby
+  class Parser
+    def parse(source)
+      result = Prism.parse(source)
+
+      result
+    end
+  end
+end

data/lib/yruby/rclass.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class YRuby
+  class RClass
+    def initialize
+      @m_tbl = {}
+    end
+
+    def add_method_iseq(mid, iseq)
+      @m_tbl[mid] = iseq
+    end
+
+    def search_method(mid)
+      @m_tbl[mid]
+    end
+  end
+end

data/lib/yruby/robject.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class YRuby
+  class RObject
+    attr_reader :klass
+
+    def initialize(klass)
+      @klass = klass
+    end
+  end
+end

data/lib/yruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class YRuby
+  VERSION = "0.1.0"
+end

data/lib/yruby.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'yruby/version'
+require_relative 'yruby/core'
+require_relative 'yruby/rclass'
+require_relative 'yruby/robject'
+
+class YRuby
+  include InsnHelper
+  include InsnHelper::Macros
+
+  attr_reader :ec
+
+  def initialize(parser = Parser.new)
+    @parser = parser
+  end
+
+  def exec(source)
+    init
+
+    ast = @parser.parse(source)
+
+    iseq = Iseq.iseq_new_main(ast)
+
+    exec_core(iseq)
+  end
+
+  private
+
+  def init
+    stack = Array.new(STACK_SIZE)
+    frames = []
+    @ec = ExecutionContext.new(stack:, stack_size: STACK_SIZE, frames:)
+    @top_self = RObject.new(RClass.new)
+  end
+
+  def exec_core(iseq)
+    push_frame(iseq:, type: FRAME_TYPE_TOP, self_value: @top_self, sp: 0)
+
+    catch(:finish) do
+      loop do
+        insn_class = cfp.iseq.fetch(cfp.pc)
+        len = insn_class::LEN
+        operands = (1...len).map { |i| cfp.iseq.fetch(cfp.pc + i) }
+        add_pc(len)
+        insn_class.call(self, *operands)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: yruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yuhi-Sato
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: YRuby is a Ruby virtual machine implementation based on CRuby's YARV
+  (Yet Another Ruby VM) architecture. It parses Ruby source code with the Prism gem
+  and executes it through a stack-based bytecode interpreter.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/yruby.rb
+- lib/yruby/compile.rb
+- lib/yruby/core.rb
+- lib/yruby/insnhelper.rb
+- lib/yruby/insns.rb
+- lib/yruby/insns/base.rb
+- lib/yruby/insns/branchunless.rb
+- lib/yruby/insns/definemethod.rb
+- lib/yruby/insns/dup.rb
+- lib/yruby/insns/getlocal.rb
+- lib/yruby/insns/jump.rb
+- lib/yruby/insns/leave.rb
+- lib/yruby/insns/opt_div.rb
+- lib/yruby/insns/opt_minus.rb
+- lib/yruby/insns/opt_mult.rb
+- lib/yruby/insns/opt_plus.rb
+- lib/yruby/insns/opt_send_without_block.rb
+- lib/yruby/insns/putnil.rb
+- lib/yruby/insns/putobject.rb
+- lib/yruby/insns/putself.rb
+- lib/yruby/insns/setlocal.rb
+- lib/yruby/iseq.rb
+- lib/yruby/parser.rb
+- lib/yruby/rclass.rb
+- lib/yruby/robject.rb
+- lib/yruby/version.rb
+homepage: https://github.com/Yuhi-Sato/yruby
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Yet Another Ruby VM - a YARV-based Ruby virtual machine implementation
+test_files: []