vaporware-compiler 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 13390207490f478cdad891ae8c368d3fb3062c1b2005bdf331a25f3b2dc29dc4
+  data.tar.gz: 823150e9b1439dad476284f9b3ec00a8d86c427cd95d08f5ec19a75159cdf4f3
+SHA512:
+  metadata.gz: c6050037946286c6ddf340dada87bfa3847504feb1814bfd3e56bd5b467c5f30fe6a433d8d5372e7bc94722c09229c42a0bf17b0255ba8efc29d22fd696016b0
+  data.tar.gz: c45ee87e4728a90dbb6cfeb5b12c61048dd9ff82b6639d858cadbd211340f27c319ef0ab83fb43366deb1352b8d5912d8c6a0080ae0e6363b17df67421088e1d

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-03-05
+
+- Initial release

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in vaporware.gemspec
+gemspec
+
+gem "rake", "~> 13.0"

data/README.md

@@ -0,0 +1,3 @@
+# Vaporware
+
+it's the vaporware.

data/Rakefile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+task default: %i[test]
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/test*.rb']
+end

data/Steepfile

@@ -0,0 +1,12 @@
+D = Steep::Diagnostic
+#
+target :lib do
+  signature "sig"
+  check "lib"                       # Directory name
+  configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+  configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+  configure_code_diagnostics do |hash|             # You can setup everything yourself
+    hash[D::Ruby::NoMethod] = :information
+    hash[D::Ruby::UnknownConstant] = :information
+  end
+end

data/exe/vaporware

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require "vaporware"
+require "optparse"
+opt = OptionParser.new
+options = {}
+opt.on("-c", "--compiler [VAL]", "this option is selecting compiler precompiled file, default: gcc") { |v| options[:compiler] = v }
+opt.on("-D", "--debug") { |v| options[:debug] = v }
+opt.on("-o", "--objects [VAL]") { |v| options[:dest] = v }
+opt.on("--compiler-options[=VAL]", "compiler options") { |v| options[:compiler_options] = v.split(",") }
+opt.on("-s", "--shared") { |v| options[:shared] = v }
+
+begin
+  opt.parse!(ARGV)
+  raise "please compile target file" if ARGV.empty?
+rescue => e
+  STDERR.puts(e.message)
+  exit 1
+end
+
+Vaporware::Compiler.compile(ARGV.shift, **options)

data/lib/vaporware/version.rb

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

data/lib/vaporware.rb

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+require_relative "vaporware/version"
+require "parser/current"
+
+module Vaporware
+  class Error < StandardError; end
+  # Your code goes here...
+  class Compiler
+    REGISTER = %w(r9 r8 rcx rdx rsi rdi).reverse
+    attr_reader :ast, :_precompile, :debug, :seq, :defined_variables, :doned, :main, :shared, :defined_methods
+    def self.compile(source, compiler: "gcc", dest: "tmp", debug: false, compiler_options: ["-O0"], shared: false)
+      _precompile = "#{dest}.s"
+      s = new(source, _precompile: _precompile, debug:, shared:)
+      s.compile(compiler:, compiler_options:)
+    end
+
+    def initialize(source, _precompile: "tmp.s", debug: false, shared: false)
+      @_precompile, @debug, @seq, @shared = _precompile, debug, 0, shared
+      @defined_methods = Set.new
+      @defined_variables = Set.new
+      @doned = Set.new
+      src = File.read(File.expand_path(source))
+      @ast = Parser::CurrentRuby.parse(src)
+      @main = false
+    end
+
+    def compile(compiler: "gcc", compiler_options: ["-O0"])
+      puts ast if debug
+
+      register_var_and_method(ast)
+
+      output = File.open(_precompile, "w")
+      # prologue
+      output.puts ".intel_syntax noprefix"
+      if defined_methods.empty?
+        @main = true
+        output.puts ".globl main"
+        output.puts "main:"
+        output.puts "  push rbp"
+        output.puts "  mov rbp, rsp"
+        output.puts "  sub rsp, #{defined_variables.size * 8}"
+        gen(ast, output)
+        # epilogue
+        gen_epilogue(output)
+      else
+        gen_prologue_methods(output)
+        output.puts ".globl main" unless shared
+        gen(ast, output)
+        # epilogue
+        gen_epilogue(output)
+      end
+      output.close
+      compiler_options += compile_shared_option if shared
+      call_compiler(compiler:, compiler_options:)
+    end
+
+    private
+
+    def compile_shared_option = %w(-shared -fPIC)
+
+    def register_var_and_method(node)
+      return unless node.kind_of?(Parser::AST::Node)
+      type = node.type
+      if variable_or_method?(type)
+        name, _ = node.children
+        name = [:lvasgn, :arg].include?(type) ? "lvar_#{name}".to_sym : name
+        type == :def ? @defined_methods << name : @defined_variables << name
+      end
+      node.children.each { |n| register_var_and_method(n) }
+    end
+
+    def already_build_methods? = defined_methods.sort == @doned.to_a.sort
+    def variable_or_method?(type) = [:lvasgn, :arg, :def].include?(type)
+
+    def call_compiler(output: _precompile, compiler: "gcc", compiler_options: ["-O0"])
+      base_name = File.basename(output, ".*")
+      name = shared ? "lib#{base_name}.so" : base_name
+      compile_commands = [compiler, *compiler_options, "-o", name, output].compact
+      IO.popen(compile_commands).close
+
+      puts File.read(output) if debug
+      nil
+    end
+
+    def gen_epilogue(output)
+      output.puts "  mov rsp, rbp"
+      output.puts "  pop rbp"
+      output.puts "  ret"
+    end
+
+    def gen_prologue_methods(output)
+      defined_methods.each do |name|
+        output.puts ".globl #{name}"
+        output.puts ".type #{name}, @function" if shared
+      end
+      nil
+    end
+
+    def gen_define_method_prologue(node, output)
+      output.puts "  push rbp"
+      output.puts "  mov rbp, rsp"
+      output.puts "  sub rsp, #{lvar_offset(nil) * 8}"
+      _name, args, _block = node.children
+      args.children.each_with_index do |_, i|
+        output.puts "  mov [rbp-#{(i + 1) * 8}], #{REGISTER[i]}"
+      end
+      nil
+    end
+
+    def gen_method(method, node, output)
+      output.puts "#{method}:"
+      gen_define_method_prologue(node, output)
+      node.children.each do |child|
+        next unless child.kind_of?(Parser::AST::Node)
+        gen(child, output, true)
+      end
+      gen_ret(output)
+      @doned << method
+      nil
+    end
+
+    def gen_args(node, output)
+      node.children.each do |child|
+        name = "arg_#{child.children.first}".to_sym
+        gen_lvar(name, output)
+        output.puts "  pop rax"
+        output.puts "  mov rax, [rax]"
+        output.puts "  push rax"
+      end
+    end
+
+    def gen_call_method(node, output, method_tree)
+      output.puts "  mov rax, rsp"
+      output.puts "  mov rdi, 16"
+      output.puts "  cqo"
+      output.puts "  idiv rdi"
+      output.puts "  mov rax, 0"
+      output.puts "  cmp rdi, 0"
+      output.puts "  jne .Lprecall#{seq}"
+      output.puts "  push 0"
+      output.puts "  mov rax, 1"
+      output.puts ".Lprecall#{seq}:"
+      output.puts "  push rax"
+      _, name, *args = node.children
+      args.each_with_index do |arg, i|
+        gen(arg, output, method_tree)
+        output.puts "  pop #{REGISTER[i]}"
+      end
+
+      output.puts "  call #{name}"
+      output.puts "  pop rdi"
+      output.puts "  cmp rdi, 0"
+      output.puts "  je .Lpostcall#{seq}"
+      output.puts "  pop rdi"
+      output.puts ".Lpostcall#{seq}:"
+      output.puts "  push rax"
+      @seq += 1
+      nil
+    end
+
+    def gen_comp(op, output)
+      output.puts "  cmp rax, rdi"
+      output.puts "  #{op} al"
+      output.puts "  movzb rax, al"
+      output.puts "  push rax"
+      nil
+    end
+
+    def gen_lvar(var, output)
+      output.puts "  mov rax, rbp"
+      output.puts "  sub rax, #{lvar_offset(var) * 8}"
+      output.puts "  push rax"
+      nil
+    end
+
+    def lvar_offset(var)
+      return @defined_variables.size if var.nil?
+      @defined_variables.find_index(var).then do |i|
+        raise "unknown local variable...: #{var}" if i.nil?
+        i + 1
+      end
+    end
+
+    def gen_ret(output)
+      output.puts "  pop rax"
+      output.puts "  mov rsp, rbp"
+      output.puts "  pop rbp"
+      output.puts "  ret"
+    end
+
+    def gen(node, output, method_tree = false)
+      return unless node.kind_of?(Parser::AST::Node)
+      type = node.type
+      center = case type
+      when :int
+        output.puts "  push #{node.children.last}"
+        return
+      when :begin
+        node.children.each do |child|
+          if already_build_methods? && !@main
+            return if shared
+            output.puts "main:"
+            output.puts "  push rbp"
+            output.puts "  mov rbp, rsp"
+            output.puts "  sub rsp, 0"
+            output.puts "  push rax"
+            @main = true
+          end
+          gen(child, output)
+        end
+        return
+      when :def
+        name, _ = node.children
+        gen_method(name, node, output)
+        return
+      when :args
+        gen_args(node, output)
+        return
+      when :lvar
+        return if method_tree
+        name = "lvar_#{node.children.last}".to_sym
+        gen_lvar(name, output)
+        # lvar
+        output.puts "  pop rax"
+        output.puts "  mov rax, [rax]"
+        output.puts "  push rax"
+        return
+      when :lvasgn
+        left, right = node.children
+
+        # rvar
+        name = "lvar_#{left}".to_sym
+        gen_lvar(name, output)
+        gen(right, output, method_tree)
+
+        output.puts "  pop rdi"
+        output.puts "  pop rax"
+        output.puts "  mov [rax], rdi"
+        output.puts "  push rdi"
+        output.puts "  pop rax"
+        return
+      when :if
+        cond, tblock, fblock = node.children
+        gen(cond, output)
+        output.puts "  pop rax"
+        output.puts "  push rax"
+        output.puts "  cmp rax, 0"
+        if fblock
+          output.puts "  je .Lelse#{seq}"
+          gen(tblock, output, method_tree)
+          gen_ret(output)
+          output.puts "  jmp .Lend#{seq}"
+          output.puts ".Lelse#{seq}:"
+          gen(fblock, output, method_tree)
+          gen_ret(output)
+          output.puts ".Lend#{seq}:"
+        else
+          output.puts "  je .Lend#{seq}"
+          gen(tblock, output, method_tree)
+          gen_ret(output)
+          output.puts ".Lend#{seq}:"
+        end
+        @seq += 1
+        return
+      when :while
+        cond, tblock = node.children
+        output.puts ".Lbegin#{seq}:"
+        gen(cond, output, method_tree)
+        output.puts "  pop rax"
+        output.puts "  push rax"
+        output.puts "  cmp rax, 0"
+        output.puts "  je .Lend#{seq}"
+        gen(tblock, output, method_tree)
+        output.puts "  jmp .Lbegin#{seq}"
+        output.puts ".Lend#{seq}:"
+        @seq += 1
+        return
+      when :send
+        left, center, right = node.children
+        gen(left, output, method_tree) unless left.nil?
+        if left.nil?
+          gen_call_method(node, output, method_tree)
+        else
+          gen(right, output, method_tree)
+          output.puts "  pop rdi"
+        end
+        output.puts "  pop rax"
+        center
+      end
+
+      case center
+      when :+
+        output.puts "  add rax, rdi"
+        output.puts "  push rax"
+      when :-
+        output.puts "  sub rax, rdi"
+        output.puts "  push rax"
+      when :*
+        output.puts "  imul rax, rdi"
+        output.puts "  push rax"
+      when :/
+        output.puts "  cqo"
+        output.puts "  idiv rdi"
+        output.puts "  push rax"
+      when :==
+        gen_comp("sete", output)
+      when :!=
+        gen_comp("setne", output)
+      when :<
+        gen_comp("setl", output)
+      when :<=
+        gen_comp("setle", output)
+      end
+    end
+  end
+end

data/rbs_collection.lock.yaml

@@ -0,0 +1,18 @@
+---
+sources:
+- type: git
+  name: ruby/gem_rbs_collection
+  revision: 12631190e75c631eca0908ecc8c03bcfd78c0c99
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems
+path: ".gem_rbs_collection"
+gems:
+- name: ast
+  version: '2.4'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 12631190e75c631eca0908ecc8c03bcfd78c0c99
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+gemfile_lock_path: Gemfile.lock

data/rbs_collection.yaml

@@ -0,0 +1,22 @@
+# Download sources
+sources:
+  - name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+# A directory to install the downloaded RBSs
+path: .gem_rbs_collection
+
+gems:
+  # Skip loading rbs gem's RBS.
+  # It's unnecessary if you don't use rbs as a library.
+  - name: steep
+    ignore: true
+  - name: rbs
+    ignore: true
+  - name: vaporware
+    ignore: true
+  - name: parser
+  - name: set
+    ignore: true

data/sample/else.rb

@@ -0,0 +1,5 @@
+if 0
+  1
+else
+  2
+end

data/sample/fiddle.rb

@@ -0,0 +1,7 @@
+require "fiddle/import"
+
+module X
+  extend Fiddle::Importer
+  dlload "./libtmp.so"
+  extern "int aibo()"
+end

data/sample/hello.rb

@@ -0,0 +1 @@
+puts "hello"

data/sample/if.rb

@@ -0,0 +1,3 @@
+a = 1
+b = 1
+1 if a == b

data/sample/method.rb

@@ -0,0 +1,2 @@
+def aibo = 10
+def bibo = 11

data/sample/plus.rb

@@ -0,0 +1 @@
+((1 + 2) * 3) / (5-4)

data/sample/variable.rb

@@ -0,0 +1,4 @@
+a = 1
+b = 2
+c = (a + b) / 3
+c

data/sample/while.rb

@@ -0,0 +1,11 @@
+a = 0
+b = 1
+c = a + b
+n = 1
+while n < 9
+  a = b
+  b = c
+  c = a + b
+  n = n + 1
+end
+c

data/sig/vaporware.rbs

@@ -0,0 +1,57 @@
+module Vaporware
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  class Error
+  end
+  class Compiler
+    REGISTER: Array[String]
+    # instance variables
+    @_precompile: String
+    @debug: bool
+    @doned: Set[Symbol]
+    @defined_methods: Set[Symbol]
+    @defined_variables: Set[Symbol]
+    @seq: Integer
+    @main: bool
+    @shared: bool
+
+    # temporarily using untyped types since parser.gem's rbs information is unchecked.
+    @ast: untyped
+
+    # attr reader for instance variables
+    def _precompile: -> String
+    def ast: -> untyped # Parser::AST::Node
+    def defined_methods: -> Set[Symbol]
+    def defined_variables: -> Set[Symbol]
+    def debug: -> bool
+    def doned: -> Set[Symbol]
+    def seq: -> Integer
+    def shared: -> bool
+
+    # class methods
+    def self.compile: (String, ?compiler: String, ?dest: String, ?debug: bool, ?compiler_options: Array[String], ?shared: bool) -> nil
+    def initialize: (String, ?_precompile: String, ?debug: bool, ?shared: bool) -> untyped
+
+    # instance methods
+    def compile: (?compiler: String, ?compiler_options: Array[String]) -> nil
+
+    # instance private methods
+    def already_build_methods?: -> bool
+    def call_compiler: (?output: String, ?compiler: String, ?compiler_options: Array[String]) -> nil
+    def compile_shared_option: () -> Array[String]
+    def gen: (untyped, File, ?bool) -> nil
+    def gen_args: (untyped, File) -> nil
+    def gen_call_method: (untyped, File, bool) -> nil
+    def gen_comp: (String, File) -> nil
+    def gen_lvar: (untyped, File) -> nil
+    def gen_method: (Symbol, untyped, File) -> nil
+    def gen_define_method_prologue: (untyped, File) -> nil
+    def gen_epilogue: (File) -> nil
+    def gen_prologue: (untyped, File) -> nil
+    def gen_prologue_methods: (File) -> nil
+    def gen_ret: (File) -> nil
+    def lvar_offset: (Symbol | nil) -> Integer
+    def register_var_and_method: (untyped) -> nil
+    def variable_or_method?: (Symbol) -> bool
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: vaporware-compiler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- MATSUMOTO, Katsuyoshi
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-05-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: steep
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Vaporware is the vaporware.
+email:
+- github@katsyoshi.org
+executables:
+- vaporware
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- Steepfile
+- exe/vaporware
+- lib/vaporware.rb
+- lib/vaporware/version.rb
+- rbs_collection.lock.yaml
+- rbs_collection.yaml
+- sample/else.rb
+- sample/fiddle.rb
+- sample/hello.rb
+- sample/if.rb
+- sample/method.rb
+- sample/plus.rb
+- sample/variable.rb
+- sample/while.rb
+- sig/vaporware.rbs
+homepage:
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Vaporware is the vaporware.
+test_files: []