Merge pull request #5094 from mruby-Forum/mruby3-preview

mruby 3.0.0-preview.

.github/workflows/build.yml

@@ -0,0 +1,106 @@
+name: Build & Test
+
+on: [push, pull_request]
+
+jobs:
+  Ubuntu-1604:
+    runs-on: ubuntu-16.04
+    env:
+      MRUBY_TARGET: travis
+    steps:
+    - uses: actions/checkout@v1
+    - name: apt
+      run: sudo apt install ruby gperf
+    - name: build and test
+      run: rake -m -j4 gensym all test
+
+  Ubuntu-1804-gcc:
+    runs-on: ubuntu-18.04
+    env:
+      MRUBY_TARGET: travis
+      CC: gcc
+      CXX: g++
+    steps:
+    - uses: actions/checkout@v1
+    - name: apt
+      run: sudo apt install ruby gperf gcc g++
+    - name: build and test
+      run: rake -m -j4 gensym all test
+
+  Ubuntu-1804-clang:
+    runs-on: ubuntu-18.04
+    env:
+      MRUBY_TARGET: travis
+      CC: clang
+      CXX: clang++
+    steps:
+    - uses: actions/checkout@v1
+    - name: apt
+      run: sudo apt install ruby gperf
+    - name: build and test
+      run: rake -m -j4 gensym all test
+
+  macOS:
+    runs-on: macos-latest
+    env:
+      MRUBY_TARGET: travis
+    steps:
+    - uses: actions/checkout@v1
+    - name: brew
+      run: brew install ruby gperf
+    - name: build and test
+      run: rake -m -j4 gensym all test
+
+  Windows-MinGW:
+    runs-on: windows-latest
+    env:
+      MRUBY_TARGET: travis
+      CFLAGS: -g -O1 -Wall -Wundef
+    steps:
+    - uses: actions/checkout@v1
+    - name: chocolatey
+      run: choco install -y ruby gperf
+    - name: build
+      run: rake -E 'STDOUT.sync=true' -j4 gensym all test
+
+  Windows-Cygwin:
+    runs-on: windows-latest
+    env:
+      MRUBY_TARGET: travis
+    steps:
+    - uses: actions/checkout@v1
+    - uses: actions/cache@v1
+      with:
+        path: C:\Users\runneradmin\AppData\Local\Temp\chocolatey
+        key: ${{ runner.os }}-cygwin-chocolatey-${{ matrix.os }}-${{ github.sha }}
+        restore-keys: |
+          ${{ runner.os }}-cygwin-chocolatey-${{ matrix.os }}-
+          ${{ runner.os }}-cygwin-chocolatey-
+    - name: chocolatey
+      run: choco install -y cygwin
+    - name: Install cygwin packages
+      shell: cmd
+      run: C:\tools\cygwin\cygwinsetup.exe -qgnNdO -R C:/tools/cygwin -l C:/tools/cygwin/package -s http://mirrors.kernel.org/sourceware/cygwin/ -P gcc-core,gcc-g++,make,gperf,ruby
+    - name: Set ENV
+      run: |
+        echo '::set-env name=PATH::C:\tools\cygwin\bin;C:\tools\cygwin\usr\bin'
+    - name: build and test
+      shell: cmd
+      run: C:\tools\cygwin\bin\ruby.exe /usr/bin/rake -E 'STDOUT.sync=true' -m gensym all test
+
+  Windows-VC:
+    runs-on: windows-latest
+    env:
+      MRUBY_TARGET: appveyor
+      # TODO(take-cheeze): Re-enable /O2
+      CFLAGS: "/c /nologo /W3 /we4013 /Zi /MD /D_CRT_SECURE_NO_WARNINGS"
+      CXXFLAGS: "/c /nologo /W3 /Zi /MD /EHs /D_CRT_SECURE_NO_WARNINGS"
+    steps:
+    - uses: actions/checkout@v1
+    - name: chocolatey
+      run: choco install -y ruby gperf
+    - name: build and test
+      shell: cmd
+      run: |
+        call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+        rake -E "STDOUT.sync=true" gensym all test

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,51 @@
+name: "Code scanning - action"
+
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: '0 19 * * 4'
+
+jobs:
+  CodeQL-Build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+      with:
+        # We must fetch at least the immediate parents so that if this is
+        # a pull request then we can checkout the head.
+        fetch-depth: 2
+
+    # If this run was triggered by a pull request event, then checkout
+    # the head of the pull request instead of the merge commit.
+    - run: git checkout HEAD^2
+      if: ${{ github.event_name == 'pull_request' }}
+      
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      # Override language selection by uncommenting this and choosing your languages
+      # with:
+      #   languages: go, javascript, csharp, python, cpp, java
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

.github/workflows/main.yml

@@ -0,0 +1,24 @@
+name: CIFuzz
+on: [pull_request]
+jobs:
+  Fuzzing:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Build Fuzzers
+      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'mruby'
+        dry-run: false
+    - name: Run Fuzzers
+      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'mruby'
+        fuzz-seconds: 600
+        dry-run: false
+    - name: Upload Crash
+      uses: actions/upload-artifact@v1
+      if: failure()
+      with:
+        name: artifacts
+        path: ./out/artifacts
+

.gitignore

@@ -17,6 +17,9 @@
 .svn
 .vscode
 .yardoc
+.ccls*
+compile_flags.txt
+compile_commands.json
 cscope.files
 cscope.out
 tags

.travis.yml

@@ -1,19 +1,14 @@
 language: c
 
-sudo: false
-
-matrix:
-  include:
-    - os: linux
-      sudo: false
-    - os: osx
-      osx_image: xcode7.1
-
-addons:
-  apt:
-    packages:
-      - gperf
+jobs:
+  - os: linux
+  - os: osx
+    before_install:
+      - HOMEBREW_NO_AUTO_UPDATE=1 HOMEBREW_NO_INSTALL_CLEANUP=1 brew install bison
+      - export PATH="/usr/local/opt/bison/bin:$PATH"
 
 env:
-  - MRUBY_CONFIG=travis_config.rb
-script: "./minirake -j4 all test"
+  - MRUBY_TARGET=travis
+
+script:
+  - rake gensym && rake -m && rake test

AUTHORS

@@ -42,3 +42,5 @@ of this list.
    Masahiro Wakame
    YAMAMOTO Masaya
    KOBAYASHI Shuji
+   RIZAL Reckordp
+   Rory O'Connell

CONTRIBUTING.md

@@ -9,7 +9,7 @@ things in mind before submitting your pull request:
 
 * Work on the latest possible state of **mruby/master**
 * Create a branch which is dedicated to your change
-* Test your changes before creating a pull request (```./minirake test```)
+* Test your changes before creating a pull request (```rake test```)
 * If possible write a test case which confirms your change
 * Don't mix several features or bug-fixes in one pull request
 * Create a meaningful commit message
@@ -56,7 +56,7 @@ on-demand.
 
 Use C++ style comments only for temporary comment e.g. commenting out some code lines.
 
-#### Insert a break after the method return value:
+#### Insert a break after the function return value:
 
     int
     main(void)
@@ -72,4 +72,5 @@ language itself. Please note the following hints for your Ruby code:
 #### Comply with the Ruby standard (ISO/IEC 30170:2012)
 
 mruby is currently targeting to execute Ruby code which complies to ISO/IEC
-30170:2012 (http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=59579).
+30170:2012 (http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=59579),
+unless there's a clear reason, e.g. the latest Ruby has changed behavior from ISO.

Doxyfile

@@ -6,7 +6,7 @@
 
 DOXYFILE_ENCODING      = UTF-8
 PROJECT_NAME           = "mruby"
-PROJECT_NUMBER         = 2.1.0
+PROJECT_NUMBER         = 2.1.2
 
 PROJECT_BRIEF          = "mruby is the lightweight implementation of the Ruby language"
 

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2019 mruby developers
+Copyright (c) 2020 mruby developers
 
 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the "Software"),

Makefile

@@ -1,8 +1,6 @@
 # mruby is using Rake (http://rake.rubyforge.org) as a build tool.
-# We provide a minimalistic version called minirake inside of our
-# codebase.
 
-RAKE = ruby ./minirake
+RAKE = rake
 
 all :
 	$(RAKE)

README.md

@@ -17,7 +17,9 @@ of the Ministry of Economy, Trade and Industry of Japan.
 
 ## How to get mruby
 
-The stable version 2.1.0 of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/archive/2.1.0.zip](https://github.com/mruby/mruby/archive/2.1.0.zip)
+The preview version 3.0.0 of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/archive/3.0.0-preview.zip](https://github.com/mruby/mruby/archive/3.0.0-preview.zip)
+
+The stable version 2.1.2 of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/archive/2.1.2.zip](https://github.com/mruby/mruby/archive/2.1.2.zip)
 
 The latest development version of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/zipball/master](https://github.com/mruby/mruby/zipball/master)
 
@@ -30,25 +32,27 @@ You can also install and compile mruby using [ruby-install](https://github.com/p
 
 ## mruby home-page
 
-The URL of the mruby home-page is: [http://www.mruby.org](http://www.mruby.org).
+The URL of the mruby home-page is: https://mruby.org.
 
 ## Mailing list
 
-We don't have a mailing list, but you can use [GitHub issues](https://github.com/mruby/mruby).
+We don't have a mailing list, but you can use [GitHub issues](https://github.com/mruby/mruby/issues).
 
 ## How to compile and install (mruby and gems)
 
 See the [compile.md](https://github.com/mruby/mruby/blob/master/doc/guides/compile.md) file.
 
-## Running Tests
+## How to Build
 
-To run the tests, execute the following from the project's root directory.
+To build mruby, execute the following from the project's root directory.
 
-    $ make test
+  $ rake TARGET=<target> test
 
-Or
+The default `TARGET` is `host`. `TARGET` will be loaded from `target` directory.
 
-    $ ruby ./minirake test
+Note: `bison` bundled with MacOS is too old to compile `mruby`.
+Try `brew install bison` and follow the instuction shown to update
+the `$PATH` to compile `mruby`.
 
 ## Building documentation
 

Rakefile

@@ -5,6 +5,8 @@ MRUBY_ROOT = File.dirname(File.expand_path(__FILE__))
 MRUBY_BUILD_HOST_IS_CYGWIN = RUBY_PLATFORM.include?('cygwin')
 MRUBY_BUILD_HOST_IS_OPENBSD = RUBY_PLATFORM.include?('openbsd')
 
+Rake.verbose(false) if Rake.verbose == Rake::DSL::DEFAULT
+
 $LOAD_PATH << File.join(MRUBY_ROOT, "lib")
 
 # load build systems
@@ -12,7 +14,13 @@ require "mruby-core-ext"
 require "mruby/build"
 
 # load configuration file
-MRUBY_CONFIG = (ENV['MRUBY_CONFIG'] && ENV['MRUBY_CONFIG'] != '') ? ENV['MRUBY_CONFIG'] : "#{MRUBY_ROOT}/build_config.rb"
+if ENV['MRUBY_CONFIG']
+  MRUBY_CONFIG = ENV['MRUBY_CONFIG']
+  MRUBY_TARGET = File.basename(MRUBY_CONFIG, ".rb")
+else
+  MRUBY_TARGET = ENV['MRUBY_TARGET'] || ENV['TARGET'] || "host"
+  MRUBY_CONFIG = "#{MRUBY_ROOT}/target/#{MRUBY_TARGET}.rb"
+end
 load MRUBY_CONFIG
 
 # load basic rules
@@ -33,10 +41,9 @@ load "#{MRUBY_ROOT}/tasks/gitlab.rake"
 load "#{MRUBY_ROOT}/tasks/doc.rake"
 
 def install_D(src, dst)
-  opts = { :verbose => $verbose }
-  FileUtils.rm_f dst, opts
-  FileUtils.mkdir_p File.dirname(dst), opts
-  FileUtils.cp src, dst, opts
+  rm_f dst
+  mkdir_p File.dirname(dst)
+  cp src, dst
 end
 
 ##############################
@@ -45,15 +52,19 @@ task :default => :all
 
 bin_path = ENV['INSTALL_DIR'] || "#{MRUBY_ROOT}/bin"
 
-depfiles = MRuby.targets['host'].bins.map do |bin|
-  install_path = MRuby.targets['host'].exefile("#{bin_path}/#{bin}")
-  source_path = MRuby.targets['host'].exefile("#{MRuby.targets['host'].build_dir}/bin/#{bin}")
+if MRuby.targets['host']
+  target = MRuby.targets['host']
+  depfiles = target.bins.map do |bin|
+    install_path = target.exefile("#{bin_path}/#{bin}")
+    source_path = target.exefile("#{target.build_dir}/bin/#{bin}")
 
-  file install_path => source_path do |t|
-    install_D t.prerequisites.first, t.name
+    file install_path => source_path do |t|
+      install_D t.prerequisites.first, t.name
+    end
+    install_path
   end
-
-  install_path
+else
+  depfiles = []
 end
 
 MRuby.each_target do |target|
@@ -62,7 +73,7 @@ MRuby.each_target do |target|
     relative_from_root = gem.dir.relative_path_from(MRUBY_ROOT)
     current_build_dir = File.expand_path "#{build_dir}/#{relative_from_root}"
 
-    if current_build_dir !~ /^#{build_dir}/
+    if current_build_dir !~ /^#{Regexp.escape(build_dir)}/
       current_build_dir = "#{build_dir}/mrbgems/#{gem.name}"
     end
 
@@ -86,15 +97,6 @@ MRuby.each_target do |target|
           install_D t.prerequisites.first, t.name
         end
         depfiles += [ install_path ]
-      elsif target == MRuby.targets['host-debug']
-        unless MRuby.targets['host'].gems.map {|g| g.bins}.include?([bin])
-          install_path = MRuby.targets['host-debug'].exefile("#{bin_path}/#{bin}")
-
-          file install_path => exec do |t|
-            install_D t.prerequisites.first, t.name
-          end
-          depfiles += [ install_path ]
-        end
       else
         depfiles += [ exec ]
       end
@@ -102,6 +104,143 @@ MRuby.each_target do |target|
   end
 end
 
+mkdir_p "#{MRUBY_ROOT}/build"
+cfiles = (
+  Dir.glob("#{MRUBY_ROOT}/src/*.c")+
+  Dir.glob("#{MRUBY_ROOT}/mrbgems/**/*.c")+
+  Dir.glob("#{MRUBY_ROOT}/build/repos/**/{src,core}/*.c")
+).uniq
+rbfiles = (
+  Dir.glob("#{MRUBY_ROOT}/mrblib/**/*.rb")+
+  Dir.glob("#{MRUBY_ROOT}/mrbgems/*/mrblib/**/*.rb")+
+  Dir.glob("#{MRUBY_ROOT}/build/repos/**/mrblib/**/*.rb")
+).uniq
+psfiles = Dir.glob("#{MRUBY_ROOT}/{mrblib,mrbgems,build/repos}/**/presym")
+symbols = []
+psfiles.each do |file|
+  symbols += File.readlines(file).grep_v(/^# /)
+end
+symbols.each{|x| x.chomp!}
+presym_file="#{MRUBY_ROOT}/build/presym"
+op_table = {
+  "!" => "not",
+  "!=" => "neq",
+  "!~" => "nmatch",
+  "%" => "mod",
+  "&" => "and",
+  "&&" => "andand",
+  "*" => "mul",
+  "**" => "pow",
+  "+" => "add",
+  "+@" => "plus",
+  "-" => "sub",
+  "-@" => "minus",
+  "/" => "div",
+  "<" => "lt",
+  "<=" => "le",
+  "<<" => "lshift",
+  "<=>" => "cmp",
+  "==" => "eq",
+  "===" => "eqq",
+  "=~" => "match",
+  ">" => "gt",
+  ">=" => "ge",
+  ">>" => "rshift",
+  "[]" => "aref",
+  "[]=" => "aset",
+  "^" => "xor",
+  "`" => "tick",
+  "|" => "or",
+  "||" => "oror",
+  "~" => "neg",
+}
+
+file presym_file => cfiles+rbfiles+psfiles+[__FILE__] do
+  csymbols = cfiles.map do |f|
+    src = File.read(f)
+    src.gsub!(/\/\/.+(\n|$)/, "\n")
+    [src.scan(/intern_lit\([^\n"]*"([^\n "]*)"/),
+     src.scan(/mrb_define_method\([^\n"]*"([^\n"]*)"/),
+     src.scan(/mrb_define_class_method\([^\n"]*"([^\n"]*)"/),
+     src.scan(/mrb_define_class\([^\n"]*"([^\n"]*)"/),
+     src.scan(/mrb_define_module\([^\n"]*"([^\n"]*)"/),
+     src.scan(/mrb_define_module_function\([^\n"]*"([^\n"]*)"/),
+     src.scan(/mrb_define_const\([^\n"]*"([^\n"]*)"/),
+     src.scan(/mrb_define_global_const\([^\n"]*"([^\n"]*)"/),
+     src.scan(/MRB_SYM\((\w+)\)/),
+     src.scan(/MRB_QSYM\((\w+)\)/).map{|x,|
+       x.sub!(/_p$/, "?") || x.sub!(/_b$/, "!") || x.sub!(/_e$/, "=") || x.sub!(/^0_/, "@")  || x.sub!(/^00_/, "@@")
+     }.compact]
+  end
+  rbsymbols = rbfiles.map do |f|
+    src = File.read(f)
+    src.force_encoding(Encoding::BINARY)
+    [src.scan(/\bclass +([A-Z]\w*)/),
+     src.scan(/\bmodule +([A-Z]\w*)/),
+     src.scan(/\bdef +(\w+[!?=]?)/),
+     src.scan(/\balias +(\w+[!?]?)/),
+     src.scan(/\b([A-Z]\w*) *=[^=]/),
+     src.scan(/(\$[a-zA-Z_]\w*)/),
+     src.scan(/(\$[$!?0-9]\w*)/),
+     src.scan(/(@@?[a-zA-Z_]\w*)/),
+     src.scan(/[^.]\.([a-zA-Z_]\w*[!?]?)/),
+     src.scan(/\.([a-zA-Z_]\w* *=)/).map{|x|x.map{|s|s.gsub(' ', '')}},
+     src.scan(/\b([a-zA-Z_]\w*):/),
+     src.scan(/:([a-zA-Z_]\w*[!?=]?)/),
+     src.scan(/[\(\[\{ ]:"([^"]+)"/).map{|x|x.map{|s|s.gsub('\#', '#')}},
+     src.scan(/[ \(\[\{]:'([^']+)'/)
+    ]
+  end
+  symbols = (symbols+csymbols+rbsymbols+op_table.keys).flatten.compact.uniq.sort.map{|x| x.gsub("\n", '\n')}
+  presyms = File.readlines(presym_file) rescue []
+  presyms.each{|x| x.chomp!}
+  if presyms != symbols
+    File.write(presym_file, symbols.join("\n"))
+  end
+end
+
+presym_inc=presym_file+".inc"
+file presym_inc => presym_file do
+  presyms = File.readlines(presym_file)
+  presyms.each{|x| x.chomp!}
+  File.open(presym_inc, "w") do |f|
+    f.print "/* MRB_PRESYM_CSYM(sym, num) - symbol which is valid C id name */\n"
+    f.print "/* MRB_PRESYM_QSYM(name, sym, num) - symbol with alias name */\n"
+    f.print "/* MRB_PRESYM_SYM(name, num) - symbol which is not valid C id */\n"
+    presyms.each.with_index do |sym,i|
+      if sym.bytes.detect{|x|x>0x80} || /\A\$/ =~ sym
+        f.print "MRB_PRESYM_SYM(\"#{sym}\", #{i+1})\n"
+      elsif /\A\w+\Z/ =~ sym
+        f.print "MRB_PRESYM_CSYM(#{sym}, #{i+1})\n"
+      elsif op_table.key?(sym)
+        f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{op_table[sym]}, #{i+1})\n"
+      elsif /\A[A-Za-z_]\w*\?\Z/ =~ sym
+        s = sym.dup; s[-1] = "_p"
+        f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n"
+      elsif /\A[A-Za-z_]\w*\!\Z/ =~ sym
+        s = sym.dup; s[-1] = "_b"
+        f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n"
+      elsif /\A[A-Za-z_]\w*\=\Z/ =~ sym
+        s = sym.dup; s[-1] = "_e"
+        f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n"
+      elsif /\A@@/ =~ sym
+        s = sym.dup; s[0,2] = "00_"
+        f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n"
+      elsif /\A@/ =~ sym
+        s = sym.dup; s[0] = "0_"
+        f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n"
+      else
+        f.print "MRB_PRESYM_SYM(\"#{sym}\", #{i+1})\n"
+      end
+    end
+    f.print "#define MRB_PRESYM_MAX #{presyms.size}"
+  end
+end
+
+desc "preallocated symbols"
+task :gensym => presym_inc
+task :all => :gensym
+
 depfiles += MRuby.targets.map { |n, t|
   t.libraries
 }.flatten
@@ -144,16 +283,18 @@ end
 desc "clean all built and in-repo installed artifacts"
 task :clean do
   MRuby.each_target do |t|
-    FileUtils.rm_rf t.build_dir, { :verbose => $verbose }
+    rm_rf t.build_dir
   end
-  FileUtils.rm_f depfiles, { :verbose => $verbose }
+  rm_f depfiles
   puts "Cleaned up target build folder"
 end
 
 desc "clean everything!"
 task :deep_clean => ["clean", "clean_doc"] do
   MRuby.each_target do |t|
-    FileUtils.rm_rf t.gem_clone_dir, { :verbose => $verbose }
+    rm_rf t.gem_clone_dir
   end
+  rm_f presym_file
+  rm_f presym_inc
   puts "Cleaned up mrbgems build folder"
 end

appveyor.yml

@@ -1,42 +1,46 @@
 version: "{build}"
 
-os: Visual Studio 2017
-
 shallow_clone: true
 
-
-cache:
-  - win_flex_bison
-
-
 environment:
   matrix:
-    # Visual Studio 2017 64bit
-    - visualcpp: C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat
+    - job_name: Visual Studio 2019 64bit
+      visualcpp: C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars64.bat
+      appveyor_build_worker_image: Visual Studio 2019
 
-    # Visual Studio 2015 64bit
-    - visualcpp: C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat
-      machine: amd64
+    - job_name: Visual Studio 2019 32bit
+      visualcpp: C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars32.bat
+      appveyor_build_worker_image: Visual Studio 2019
 
-    # Visual Studio 2013 64bit
-    - visualcpp: C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\vcvarsall.bat
-      machine: amd64
+    - job_name: Visual Studio 2017 64bit
+      visualcpp: C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat
+      appveyor_build_worker_image: Visual Studio 2017
 
+    - job_name: Visual Studio 2017 32bit
+      visualcpp: C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars32.bat
+      appveyor_build_worker_image: Visual Studio 2017
+
+    - job_name: Visual Studio 2015 64bit
+      visualcpp: C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat
+      appveyor_build_worker_image: Visual Studio 2015
+      machine: x86_amd64
+
+    - job_name: Visual Studio 2015 32bit
+      visualcpp: C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat
+      appveyor_build_worker_image: Visual Studio 2015
+      machine: x86
 
 init:
   - call "%visualcpp%" %machine%
-  # For using Rubyinstaller's Ruby 2.4 64bit
-  - set PATH=C:\Ruby24-x64\bin;%PATH%
+  # For using Rubyins4aller's Ruby 2.6 64bit
+  # 2.6 is the highest supported Ruby version across all historical
+  # Visual Studio AppVeyor images. Ruby 2.7 is only on the 2019 image.
+  - set PATH=C:\Ruby26-x64\bin;%PATH%
   - ruby --version
 
 
-install:
-  - if not exist win_flex_bison (
-      appveyor DownloadFile "https://github.com/lexxmark/winflexbison/releases/download/v.2.5.10/win_flex_bison-2.5.10.zip" &
-      7z x -y -owin_flex_bison win_flex_bison-2.5.10.zip
-    )
-
 build_script:
-  - set YACC=.\win_flex_bison\win_bison.exe
-  - set MRUBY_CONFIG=appveyor_config.rb
+  - set MRUBY_TARGET=appveyor
+  - rake gensym
+  - rake -m all
   - rake -E $stdout.sync=true test

appveyor_config.rb

@@ -1,50 +0,0 @@
-MRuby::Build.new('debug') do |conf|
-  toolchain :visualcpp
-  enable_debug
-
-  # include all core GEMs
-  conf.gembox 'full-core'
-  conf.compilers.each do |c|
-    c.defines += %w(MRB_GC_STRESS MRB_GC_FIXED_ARENA MRB_METHOD_CACHE)
-  end
-
-  build_mrbc_exec
-end
-
-MRuby::Build.new('full-debug') do |conf|
-  toolchain :visualcpp
-  enable_debug
-
-  # include all core GEMs
-  conf.gembox 'full-core'
-  conf.cc.defines += %w(MRB_ENABLE_DEBUG_HOOK)
-
-  conf.enable_test
-end
-
-MRuby::Build.new do |conf|
-  toolchain :visualcpp
-
-  # include all core GEMs
-  conf.gembox 'full-core'
-  conf.compilers.each do |c|
-    c.defines += %w(MRB_GC_FIXED_ARENA)
-  end
-  conf.enable_bintest
-  conf.enable_test
-end
-
-MRuby::Build.new('cxx_abi') do |conf|
-  toolchain :visualcpp
-
-  conf.gembox 'full-core'
-  conf.compilers.each do |c|
-    c.defines += %w(MRB_GC_FIXED_ARENA)
-  end
-  conf.enable_bintest
-  conf.enable_test
-
-  enable_cxx_abi
-
-  build_mrbc_exec
-end

doc/guides/compile.md

@@ -6,41 +6,61 @@ binaries.
 ## Prerequisites
 
 To compile mruby out of the source code you need the following tools:
-* C Compiler (e.g. `gcc`)
-* Linker (e.g. `gcc`)
+* C Compiler (e.g. `gcc` or `clang`)
+* Linker (e.g. `gcc` or `clang`)
 * Archive utility (e.g. `ar`)
 * Parser generator (e.g. `bison`)
 * Ruby 2.0 or later (e.g. `ruby` or `jruby`)
 
+Note that `bison` bundled with MacOS is too old to compile `mruby`.
+Try `brew install bison` and follow the instuction shown to update
+the `$PATH` to compile `mruby`. We also encourage to upgrade `ruby`
+on MacOS in similar manner.
+
 Optional:
-* GIT (to update mruby source and integrate mrbgems easier)
+* git (to update mruby source and integrate mrbgems easier)
 * C++ compiler (to use GEMs which include \*.cpp, \*.cxx, \*.cc)
 * Assembler (to use GEMs which include \*.asm)
 
-## Usage
+## Build
+
+To compile `mruby`, just call `rake` inside of the mruby source
+root. To generate and execute the test tools call `rake test`. To
+clean all build files call `rake clean`. To see full command line on
+build, call `rake -v`.
+
+If you want to compile for the specific configuration, specify
+`MRUBY_TARGET` or `TARGET` environment variable, e.g
+
+```sh
+rake TAGRET=host
+```
+
+The default target is `host`.  The compilation target desciption files
+(with `.rb` suffix) are contained in the `target` directory.
+
+A build description file contains the build configuration of mruby and
+looks like the following for example:
 
-Inside of the root directory of the mruby source a file exists
-called *build_config.rb*. This file contains the build configuration
-of mruby and looks like this for example:
 ```ruby
 MRuby::Build.new do |conf|
   toolchain :gcc
 end
 ```
 
-All tools necessary to compile mruby can be set or modified here. In case
-you want to maintain an additional *build_config.rb* you can define a
-customized path using the *$MRUBY_CONFIG* environment variable.
-
-To compile just call `./minirake` inside of the mruby source root. To
-generate and execute the test tools call `./minirake test`. To clean
-all build files call `./minirake clean`. To see full command line on
-build, call `./minirake -v`.
+All tools necessary to compile mruby can be set or modified here. In
+case you want to try different configuration, you can create a new
+configuration file under `target` and specify the configuration using
+the `MRUBY_TARGET` environment variable.
 
 ## Build Configuration
 
-Inside of the *build_config.rb* the following options can be configured
-based on your environment.
+To create a new configuration, copy the existing configuration in the
+`target` directory, and modify it. We wish you submit a pull-request,
+once you created a new configuration for a new platform.
+
+Inside of the configuration file, the following options can be
+configured based on your environment.
 
 ### Toolchains
 
@@ -84,15 +104,12 @@ in `ANDROID_STANDALONE_TOOLCHAIN`.
 ### Binaries
 
 It is possible to select which tools should be compiled during the compilation
-process. The following tools can be selected:
-* mruby (mruby interpreter)
-* mirb (mruby interactive shell)
+process. For example, 
 
-To select them declare conf.gem as follows:
-```ruby
-conf.gem "#{root}/mrbgems/mruby-bin-mruby"
-conf.gem "#{root}/mrbgems/mruby-bin-mirb"
-```
+* `mruby`
+* `mirb`
+
+The configuration are done via `mrbgems`. See `Mrbgems` section.
 
 ### File Separator
 
@@ -205,17 +222,33 @@ end
 
 ### Mrbgems
 
-Integrate GEMs in the build process.
-```ruby
-# Integrate GEM with additional configuration
-conf.gem 'path/to/gem' do |g|
-  g.cc.flags << ...
-end
+`mruby` comes with the (sort of) packaging system named `mrbgems`. To
+specify `gem`, you can use `conf.gem` in the configuration file.
 
-# Integrate GEM without additional configuration
-conf.gem 'path/to/another/gem'
+```ruby
+# Integrate a bundled Gem you see in `mrbgems` directory
+conf.gem :core => 'mruby-something'
+
+# Integrate a Gem from GitHub
+conf.gem :github => 'someone/mruby-another'
+
+# Integrate a mruby binary Gem
+conf.gem :core => 'mruby-bin-mruby'
+
+# Integrate a interactive mruby binary Gem
+conf.gem :core => 'mruby-bin-mirb'
+
+# Integrate GemBox (set of Gems)
+conf.gembox "default"
 ```
 
+A GemBox is a set of Gems defined in `mrbgems/default.gembox` for example.
+It's just a set of `mrbgem` configurations.
+
+There is a `RubyGem` (gem for CRuby) named `mgem` that help you to
+manage `mrbgems`. Try `gem install mgem`. `mgem` can show you the list
+of registered `mrbgems`.
+
 See doc/mrbgems/README.md for more option about mrbgems.
 
 ### Mrbtest
@@ -323,6 +356,10 @@ root directory. The structure of this directory will look like this:
 
 	+- build
 	   |
+	   +-  presym         <- List of preallocated symbolx
+       |
+	   +-  presym.inc     <- C source file for preallocated symbols
+       |
 	   +-  host
 	       |
 	       +- bin          <- Binaries (mirb, mrbc and mruby)
@@ -374,6 +411,10 @@ In case of a cross-compilation to *i386* the *build* directory structure looks
 like this:
 
 	+- build
+	   |
+	   +-  presym         <- List of preallocated symbolx
+       |
+	   +-  presym.inc     <- C source file for preallocated symbols
 	   |
 	   +-  host
 	   |   |

doc/guides/debugger.md

@@ -38,7 +38,7 @@ To confirm mrdb was installed properly, run mrdb with the `--version` option:
 
 ```bash
 $ mrdb --version
-mruby 2.1.0 (2019-10-18)
+mruby 2.1.2 (2020-08-06)
 ```
 
 ## 2.2 Basic Operation

doc/guides/mrbconf.md

@@ -46,25 +46,21 @@ You can use mrbconfs with following ways:
 
 ## Primitive type configuration.
 
-`MRB_USE_FLOAT`
+`MRB_USE_FLOAT32`
 * When defined single precision floating point type(C type `float`) is used as `mrb_float`.
-* Else double precision floating point type(C type `double`) is used as `mrb_float`.
+* Otherwise double precision floating point type(C type `double`) is used as `mrb_float`.
 
-`MRB_WITHOUT_FLOAT`
+`MRB_NO_FLOAT`
 * When defined removes floating point numbers from mruby.
 * It makes mruby easier to handle in "Microcontroller without FPU" and "Kernel Space".
 
-`MRB_INT16`
-* When defined `int16_t` will be defined as `mrb_int`.
-* Conflicts with `MRB_INT32` and `MRB_INT64`.
-
 `MRB_INT32`
-* When defined, or both `MRB_INT16` and `MRB_INT64` are not defined on 32-bit CPU mode, `int32_t` will be defined as `mrb_int`.
-* Conflicts with `MRB_INT16` and `MRB_INT64`.
+* When defined, or `MRB_INT64` are not defined on 32-bit CPU mode, `mrb_int` will be defined as `int32_t`.
+* Conflicts with `MRB_INT64`.
 
 `MRB_INT64`
-* When defined, or both `MRB_INT16` and `MRB_INT32` are not defined on 64-bit CPU mode, `int64_t` will be defined as `mrb_int`.
-* Conflicts with `MRB_INT16` and `MRB_INT32`.
+* When defined, or `MRB_INT32` are not defined on 64-bit CPU mode, `mrb_int` will be defined as `int64_t`.
+* Conflicts with `MRB_INT32`.
 
 ## Garbage collector configuration.
 
@@ -121,7 +117,7 @@ largest value of required alignment.
 
 `MRB_NAN_BOXING`
 * If defined represent `mrb_value` in boxed `double`.
-* Conflicts with `MRB_USE_FLOAT` and `MRB_WITHOUT_FLOAT`.
+* Conflicts with `MRB_USE_FLOAT32` and `MRB_NO_FLOAT`.
 
 `MRB_WORD_BOXING`
 * If defined represent `mrb_value` as a word.
@@ -167,17 +163,17 @@ largest value of required alignment.
 * Default value is `128`.
 * Specifies initial capacity of `RString` created by `mrb_str_buf_new` function..
 
-`MRB_METHOD_CACHE`
-* Improve performance for method dispatch.
+`MRB_NO_METHOD_CACHE`
+* Disable method cache to save memory.
 
 `MRB_METHOD_CACHE_SIZE`
-* Default value is `128`.
-* Ignored if `MRB_METHOD_CACHE` is not defined.
+* Default value is `256`.
+* Ignored if `MRB_NO_METHOD_CACHE` is defined.
 * Need to be the power of 2.
 
-`MRB_METHOD_T_STRUCT`
+`MRB_USE_METHOD_T_STRUCT`
 * Use C struct to represent `mrb_method_t`
-* No `MRB_METHOD_T_STRUCT` requires highest 2 bits of function pointers to be zero
+* No `MRB_USE_METHOD_T_STRUCT` requires highest 2 bits of function pointers to be zero
 * Define this macro on machines that use higher bits of pointers
 
 `MRB_ENABLE_ALL_SYMBOLS`

doc/guides/mrbgems.md

@@ -45,8 +45,8 @@ conf.gem mgem: 'mruby-redis', checksum_hash: '3446d19fc4a3f9697b5ddbf2a904f301c4
 If there is missing dependencies, mrbgem dependencies solver will reference
 mrbgem from core or mgem-list.
 
-To pull all gems from remote GIT repository on build, call ```./minirake -p```,
-or ```./minirake --pull-gems```.
+To pull all gems from remote GIT repository on build, call ```rake -p```,
+or ```rake --pull-gems```.
 
 NOTE: `:bitbucket` option supports only git. Hg is unsupported in this version.
 
@@ -235,7 +235,7 @@ So it is recommended not to put GEM's local header files on include/.
 These exports are retroactive.
 For example: when B depends to C and A depends to B, A will get include paths exported by C.
 
-Exported include_paths are automatically appended to GEM local include_paths by Minirake.
+Exported include_paths are automatically appended to GEM local include_paths by rake.
 You can use `spec.export_include_paths` accessor if you want more complex build.
 
 

doc/limitations.md

@@ -17,7 +17,7 @@ Please help to improve it by submitting your findings.
 ## `1/2` gives `0.5`
 
 Since mruby does not have `Bignum`, bigger integers are represented
-by `Float` numbers. To enhance interoperability between `Fixnum`
+by `Float` numbers. To enhance interoperability between `Integer`
 and `Float`, mruby provides `Float#upto` and other iterating
 methods for the `Float` class.  As a side effect, `1/2` gives `0.5`
 not `0`.
@@ -38,7 +38,7 @@ puts [1,2,3]
 3
 ```
 
-#### mruby [2.1.0 (2019-10-18)]
+#### mruby [2.1.2 (2020-08-06)]
 
 ```
 [1, 2, 3]
@@ -61,10 +61,17 @@ end
 
 `ZeroDivisionError` is raised.
 
-#### mruby [2.1.0 (2019-10-18)]
+#### mruby [2.1.2 (2020-08-06)]
 
-No exception is raised.
+No exception is raised. Instead you have to do:
 
+```ruby
+begin
+  1 / 0
+rescue => e
+  raise e
+end
+```
 ## Fiber execution can't cross C function boundary
 
 mruby's `Fiber` is implemented in a similar way to Lua's co-routine. This
@@ -89,7 +96,7 @@ p Liste.new "foobar"
 
 ` [] `
 
-#### mruby [2.1.0 (2019-10-18)]
+#### mruby [2.1.2 (2020-08-06)]
 
 `ArgumentError` is raised.
 
@@ -119,7 +126,7 @@ false
 true
 ```
 
-#### mruby [2.1.0 (2019-10-18)]
+#### mruby [2.1.2 (2020-08-06)]
 
 ```
 true
@@ -156,7 +163,7 @@ p 'ok'
 ok
 ```
 
-#### mruby [2.1.0 (2019-10-18)]
+#### mruby [2.1.2 (2020-08-06)]
 
 ```
 test.rb:8: undefined method 'test_func' (NoMethodError)
@@ -178,7 +185,7 @@ defined?(Foo)
 nil
 ```
 
-#### mruby [2.1.0 (2019-10-18)]
+#### mruby [2.1.2 (2020-08-06)]
 
 `NameError` is raised.
 
@@ -195,7 +202,7 @@ alias $a $__a__
 
 ` nil `
 
-#### mruby [2.1.0 (2019-10-18)]
+#### mruby [2.1.2 (2020-08-06)]
 
 Syntax error
 
@@ -217,7 +224,7 @@ end
 `ArgumentError` is raised.
 The re-defined `+` operator does not accept any arguments.
 
-#### mruby [2.1.0 (2019-10-18)]
+#### mruby [2.1.2 (2020-08-06)]
 
 ` 'ab' `
 Behavior of the operator wasn't changed.
@@ -233,7 +240,7 @@ $ ruby -e 'puts Proc.new {}.binding'
 #<Binding:0x00000e9deabb9950>
 ```
 
-#### mruby [2.1.0 (2019-10-18)]
+#### mruby [2.1.2 (2020-08-06)]
 
 ```
 $ ./bin/mruby -e 'puts Proc.new {}.binding'
@@ -245,8 +252,7 @@ trace (most recent call last):
 ## Keyword arguments
 
 mruby keyword arguments behave slightly different from CRuby 2.5
-to make the behavior simpler and less confusing. Maybe in the
-future, the simpler behavior will be adopted to CRuby as well.
+to make the behavior simpler and less confusing. 
 
 #### Ruby [ruby 2.5.1p57 (2018-03-29 revision 63029)]
 
@@ -255,7 +261,7 @@ $ ruby -e 'def m(*r,**k) p [r,k] end; m("a"=>1,:b=>2)'
 [[{"a"=>1}], {:b=>2}]
 ```
 
-#### mruby [mruby 2.1.0]
+#### mruby [mruby 2.1.2]
 
 ```
 $ ./bin/mruby -e 'def m(*r,**k) p [r,k] end; m("a"=>1,:b=>2)'
@@ -264,6 +270,20 @@ trace (most recent call last):
 -e:1: keyword argument hash with non symbol keys (ArgumentError)
 ```
 
+## `nil?` redefinition in conditional expressions
+
+Redefinition of `nil?` is ignored in conditional expressions.
+
+```ruby
+a = "a"
+def a.nil?
+  true
+end
+puts(a.nil? ? "truthy" : "falsy")
+```
+
+Ruby outputs `falsy`. mruby outputs `truthy`.
+
 ## Argument Destructuring
 
 ```ruby
@@ -283,17 +303,3 @@ f(1,[2,3])
 ```
 
 CRuby gives `[1,2,3,nil]`. mruby raises `NoMethodError` for `b`.
-
-## `nil?` redefinition in conditional expressions
-
-Redefinition of `nil?` is ignored in conditional expressions.
-
-```ruby
-a = "a"
-def a.nil?
-  true
-end
-puts(a.nil? ? "truthy" : "falsy")
-```
-
-Ruby outputs `falsy`. mruby outputs `truthy`.

doc/mruby3.md

@@ -0,0 +1,108 @@
+User visible changes in `mruby3`
+===
+
+# Build System
+
+You can specify `TARGET` option to `rake` via a command line
+option, or via an environment variable, e.g.
+
+`rake TARGET=host all`
+
+or
+
+`TARGET=host rake all`
+
+It's much easier to switch multiple targets than the
+previous `build_config.rb` system.
+
+## `presym` target
+
+The first compilation of `mruby` may require generation of a
+static symbol table named `build/presym`. You can generate
+the table by `rake gensym`.
+
+## `target` directory
+
+Build target specification files are loaded from `target`
+directory. The default `TARGET` is `host` which is described
+in `target/host.rb`. There are many other targets for example:
+
+* `host-gprof`: compiles with `gprof` for performance tuning
+* `host-m32`: compiles in gcc 32bit mode on 64bit platforms
+* `boxing`: compiles all three boxing options
+* `clang-asan`: compiles with `clang`'s Address Sanitizer
+
+`target/host.rb` comes  with comments to help  writing a new
+target description.
+
+If you want to have your target description out of the
+source tree, you can specify the path to the description
+file in `MRUBY_CONFIG`.
+
+# Build Target Contribution
+
+When you write a new target description, please
+contribute. We welcome your contribution as a GitHub
+pull-request.
+
+# Languge Changes
+
+## New Syntax
+
+We have ported some new syntax from CRuby.
+
+* R-assignment (`12 => x`)
+* Numbered block parameter (`x.map{_1 * 2}`)
+* End-less `def` (`def double(x) = x*2`)
+
+# Configuration Options Changed
+
+Some configuration macro names are changed for consistency
+
+## `MRB_NO_FLOAT`
+
+Changed from `MRB_WITHOUT_FLOAT` to conform `USE_XXX` naming
+convention.
+
+## `MRB_USE_FLOAT32`
+
+Changed from `MRB_USE_FLOAT` to make sure `float` here means
+using single precision float, and not the opposite of
+`MRB_NO_FLOAT`.
+
+## `MRB_USE_METHOD_T_STRUCT`
+
+Changed from `MRB_METHOD_T_STRUCT`.
+
+To use `struct` version of `mrb_method_t`. More portable but consumes more memory.
+Turned on by default on 32bit platforms.
+
+## `MRB_NO_BOXING`
+
+Uses `struct` to represent `mrb_value`. Consumes more memory
+but easier to inveticate the internal and to debug. It used
+to be default `mrb_value` representation. Now the default is
+`MRB_WORD_BOXING`.
+
+## `MRB_WORD_BOXING`
+
+Pack `mrb_value` in an `intptr_t` integer. Consumes less
+memory compared to `MRB_NO_BOXING` especially on 32 bit
+platforms. `Fixnum` size is 31 bits so some integer values
+does not fit in `Fixnum` integers.
+
+## `MRB_NAN_BOXING`
+
+Pack `mrb_value` in a floating pointer number. Nothing
+changed from previous versions.
+
+## `MRB_USE_MALLOC_TRIM`
+
+Call `malloc_trim(0)` from mrb_full_gc() if this macro is defined.
+If you are using glibc malloc, this macro could reduce memory consumption.
+
+# Internal Changes
+
+## `Random` now use `xoshiro128++`.
+
+For better and faster random number generation.

doc/opcode.md

@@ -16,112 +16,111 @@ In the table.1 below, the second field describes the size (and
 sign) of operands.
 
 * B: 8bit
-* sB: signed 8bit
 * S: 16bit
 * sS: signed 16bit
 * W: 24bit
 
-First two byte operands may be extended to 16bit. When those byte
-operands are bigger than 256, the instruction will be prefixed by
-`OP_EXT1` (means 1st operand is 16bit) or `OP_EXT2` (means 2nd operand
-is 16bit) or `OP_EXT3` (means 1st and 2nd operands are 16bit).
-
-For instructions marked by `'`, `OP_EXT1` can be prefixed. For those
-with `"`, either `OP_EXT1` or `OP_EXT2` or `OP_EXT2` can be prefixed.
-
 ## table.1 Instruction Table
 
-| Instruction Name | Operand type | Semantics        	|
-|:-----------------|--------------|---------------------|
-| OP_NOP           | -            |                  	|
-| OP_MOVE"         | BB           | R(a) = R(b)      	
-| OP_LOADL"        | BB           | R(a) = Pool(b)   	
-| OP_LOADI"        | BsB          | R(a) = mrb_int(b)	
-| OP_LOADI_0'      | B            | R(a) = 0	
-| OP_LOADI_1'      | B            | R(a) = 1	
-| OP_LOADI_2'      | B            | R(a) = 2	
-| OP_LOADI_3'      | B            | R(a) = 3	
-| OP_LOADSYM"      | BB           | R(a) = Syms(b)	
-| OP_LOADNIL'      | B            | R(a) = nil	
-| OP_LOADSELF'     | B            | R(a) = self	
-| OP_LOADT'        | B            | R(a) = true	
-| OP_LOADF'        | B            | R(a) = false	
-| OP_GETGV"        | BB           | R(a) = getglobal(Syms(b))	
-| OP_SETGV"        | BB           | setglobal(Syms(b), R(a))	
-| OP_GETSV"        | BB           | R(a) = Special[b]	
-| OP_SETSV"        | BB           | Special[b] = R(a)	
-| OP_GETIV"        | BB           | R(a) = ivget(Syms(b))	
-| OP_SETIV"        | BB           | ivset(Syms(b),R(a))	
-| OP_GETCV"        | BB           | R(a) = cvget(Syms(b))	
-| OP_SETCV"        | BB           | cvset(Syms(b),R(a))	
-| OP_GETCONST"     | BB           | R(a) = constget(Syms(b))	
-| OP_SETCONST"     | BB           | constset(Syms(b),R(a))	
-| OP_GETMCNST"     | BB           | R(a) = R(a)::Syms(b)	
-| OP_SETMCNST"     | BB           | R(a+1)::Syms(b) = R(a)	
-| OP_GETUPVAR'     | BBB          | R(a) = uvget(b,c)	
-| OP_SETUPVAR'     | BBB          | uvset(b,c,R(a))	
-| OP_JMP           | S            | pc+=a	
-| OP_JMPIF'        | SB           | if R(b) pc+=a	
-| OP_JMPNOT'       | SB           | if !R(b) pc+=a	
-| OP_ONERR         | sS           | rescue_push(pc+a)	
-| OP_EXCEPT'       | B            | R(a) = exc	
-| OP_RESCUE"       | BB           | R(b) = R(a).isa?(R(b))	
-| OP_POPERR        | B            | a.times{rescue_pop()}	
-| OP_RAISE'        | B            | raise(R(a))	
-| OP_EPUSH'        | B            | ensure_push(SEQ[a])	
-| OP_EPOP          | B            | A.times{ensure_pop().call}	
-| OP_SENDV"        | BB           | R(a) = call(R(a),Syms(b),*R(a+1))	
-| OP_SENDVB"       | BB           | R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2))	
-| OP_SEND"         | BBB          | R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c))	
-| OP_SENDB"        | BBB          | R(a) = call(R(a),Syms(Bx),R(a+1),...,R(a+c),&R(a+c+1))	
-| OP_CALL'         | B            | R(a) = self.call(frame.argc, frame.argv)	
-| OP_SUPER'        | BB           | R(a) = super(R(a+1),... ,R(a+b+1))	
-| OP_ARGARY'       | BS           | R(a) = argument array (16=5:1:5:1:4)	
-| OP_ENTER         | W            | arg setup according to flags (23=5:5:1:5:5:1:1)	
-| OP_KARG"         | BB           | R(a) = kdict[Syms(Bx)]                          # todo	
-| OP_KARG2"        | BB           | R(a) = kdict[Syms(Bx)]; kdict.rm(Syms(b))       # todo	
-| OP_RETURN'       | B            | return R(a) (normal)	
-| OP_RETURN_BLK'   | B            | return R(a) (in-block return)	
-| OP_BREAK'        | B            | break R(a)	
-| OP_BLKPUSH'      | BS           | R(a) = block (16=5:1:5:1:4)	
-| OP_ADD"          | BB           | R(a) = R(a)+R(a+1)	
-| OP_ADDI"         | BBB          | R(a) = R(a)+mrb_int(c)	
-| OP_SUB"          | BB           | R(a) = R(a)-R(a+1)	
-| OP_SUBI"         | BB           | R(a) = R(a)-C	
-| OP_MUL"          | BB           | R(a) = R(a)*R(a+1)	
-| OP_DIV"          | BB           | R(a) = R(a)/R(a+1)	
-| OP_EQ"           | BB           | R(a) = R(a)==R(a+1)	
-| OP_LT"           | BB           | R(a) = R(a)<R(a+1)	
-| OP_LE"           | BB           | R(a) = R(a)<=R(a+1)	
-| OP_GT"           | BB           | R(a) = R(a)>R(a+1)	
-| OP_GE"           | BB           | R(a) = R(a)>=R(a+1)	
-| OP_ARRAY'        | BB           | R(a) = ary_new(R(a),R(a+1)..R(a+b))	
-| OP_ARRAY2"       | BB           | R(a) = ary_new(R(b),R(b+1)..R(b+c))	
-| OP_ARYCAT'       | B            | ary_cat(R(a),R(a+1))	
-| OP_ARYPUSH'      | B            | ary_push(R(a),R(a+1))	
-| OP_AREF'         | BB           | R(a) = R(a)[b]	
-| OP_ASET'         | BB           | R(a)[b] = R(a+1)	
-| OP_APOST'        | BB           | *R(a),R(A+1)..R(A+C) = R(a)[B..]	
-| OP_STRING"       | BB           | R(a) = str_dup(Lit(b))	
-| OP_STRCAT'       | B            | str_cat(R(a),R(a+1))	
-| OP_HASH'         | BB           | R(a) = hash_new(R(a),R(a+1)..R(a+b))	
-| OP_HASHADD'      | BB           | R(a) = hash_push(R(a),R(a+1)..R(a+b))	
-| OP_LAMBDA"       | BB           | R(a) = lambda(SEQ[b],OP_L_LAMBDA)	
-| OP_BLOCK"        | BB           | R(a) = lambda(SEQ[b],OP_L_BLOCK)	
-| OP_METHOD"       | BB           | R(a) = lambda(SEQ[b],OP_L_METHOD)	
-| OP_RANGE_INC'    | B            | R(a) = range_new(R(a),R(a+1),FALSE)	
-| OP_RANGE_EXC'    | B            | R(a) = range_new(R(a),R(a+1),TRUE)	
-| OP_OCLASS'       | B            | R(a) = ::Object	
-| OP_CLASS"        | BB           | R(a) = newclass(R(a),Syms(b),R(a+1))	
-| OP_MODULE"       | BB           | R(a) = newmodule(R(a),Syms(b))	
-| OP_EXEC"         | BB           | R(a) = blockexec(R(a),SEQ[b])	
-| OP_DEF"          | BB           | R(a).newmethod(Syms(b),R(a+1))	
-| OP_ALIAS'        | B            | alias_method(R(a),R(a+1),R(a+2))	
-| OP_UNDEF"        | BB           | undef_method(R(a),Syms(b))	
-| OP_SCLASS'       | B            | R(a) = R(a).singleton_class	
-| OP_TCLASS'       | B            | R(a) = target_class	
-| OP_ERR'          | B            | raise(RuntimeError, Lit(Bx))	
-| OP_EXT1          | -            | make 1st operand 16bit	
-| OP_EXT2          | -            | make 2nd operand 16bit	
-| OP_EXT3          | -            | make 1st and 2nd operands 16bit	
-| OP_STOP          | -            | stop VM	
+| Instruction Name | Operand type | Semantics                                              |
+|------------------|--------------|--------------------------------------------------------|
+| OP_NOP           | -            | no operation                                           |
+| OP_MOVE          | BB           | R(a) = R(b)                                            |
+| OP_LOADL         | BB           | R(a) = Pool(b)                                         |
+| OP_LOADI         | BB           | R(a) = mrb_int(b)                                      |
+| OP_LOADINEG      | BB           | R(a) = mrb_int(-b)                                     |
+| OP_LOADI__1      | B            | R(a) = mrb_int(-1)                                     |
+| OP_LOADI_0       | B            | R(a) = mrb_int(0)                                      |
+| OP_LOADI_1       | B            | R(a) = mrb_int(1)                                      |
+| OP_LOADI_2       | B            | R(a) = mrb_int(2)                                      |
+| OP_LOADI_3       | B            | R(a) = mrb_int(3)                                      |
+| OP_LOADI_4       | B            | R(a) = mrb_int(4)                                      |
+| OP_LOADI_5       | B            | R(a) = mrb_int(5)                                      |
+| OP_LOADI_6       | B            | R(a) = mrb_int(6)                                      |
+| OP_LOADI_7       | B            | R(a) = mrb_int(7)                                      |
+| OP_LOADI16       | BsS          | R(a) = mrb_int(b)                                      |
+| OP_LOADSYM       | BB           | R(a) = Syms(b)                                         |
+| OP_LOADNIL       | B            | R(a) = nil                                             |
+| OP_LOADSELF      | B            | R(a) = self                                            |
+| OP_LOADT         | B            | R(a) = true                                            |
+| OP_LOADF         | B            | R(a) = false                                           |
+| OP_GETGV         | BB           | R(a) = getglobal(Syms(b))                              |
+| OP_SETGV         | BB           | setglobal(Syms(b), R(a))                               |
+| OP_GETSV         | BB           | R(a) = Special[Syms(b)]                                |
+| OP_SETSV         | BB           | Special[Syms(b)] = R(a)                                |
+| OP_GETIV         | BB           | R(a) = ivget(Syms(b))                                  |
+| OP_SETIV         | BB           | ivset(Syms(b),R(a))                                    |
+| OP_GETCV         | BB           | R(a) = cvget(Syms(b))                                  |
+| OP_SETCV         | BB           | cvset(Syms(b),R(a))                                    |
+| OP_GETCONST      | BB           | R(a) = constget(Syms(b))                               |
+| OP_SETCONST      | BB           | constset(Syms(b),R(a))                                 |
+| OP_GETMCNST      | BB           | R(a) = R(a)::Syms(b)                                   |
+| OP_SETMCNST      | BB           | R(a+1)::Syms(b) = R(a)                                 |
+| OP_GETUPVAR      | BBB          | R(a) = uvget(b,c)                                      |
+| OP_SETUPVAR      | BBB          | uvset(b,c,R(a))                                        |
+| OP_JMP           | S            | pc=a                                                   |
+| OP_JMPIF         | BS           | if R(a) pc=b                                           |
+| OP_JMPNOT        | BS           | if !R(a) pc=b                                          |
+| OP_JMPNIL        | BS           | if R(a)==nil pc=b                                      |
+| OP_JMPUW         | S            | unwind_and_jump_to(a)                                  |
+| OP_EXCEPT        | B            | R(a) = exc                                             |
+| OP_RESCUE        | BB           | R(b) = R(a).isa?(R(b))                                 |
+| OP_RAISEIF       | B            | raise(R(a)) if R(a)                                    |
+| OP_SENDV         | BB           | R(a) = call(R(a),Syms(b),*R(a+1))                      |
+| OP_SENDVB        | BB           | R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2))              |
+| OP_SEND          | BBB          | R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c))            |
+| OP_SENDB         | BBB          | R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c),&R(a+c+1))  |
+| OP_CALL          | -            | R(0) = self.call(frame.argc, frame.argv)               |
+| OP_SUPER         | BB           | R(a) = super(R(a+1),... ,R(a+b+1))                     |
+| OP_ARGARY        | BS           | R(a) = argument array (16=5:1:5:1:4)                   |
+| OP_ENTER         | W            | arg setup according to flags (23=5:5:1:5:5:1:1)        |
+| OP_KEY_P         | BB           | R(a) = kdict.key?(Syms(b))                             |
+| OP_KEYEND        | -            | raise unless kdict.empty?                              |
+| OP_KARG          | BB           | R(a) = kdict[Syms(b)]; kdict.delete(Syms(b))           |
+| OP_RETURN        | B            | return R(a) (normal)                                   |
+| OP_RETURN_BLK    | B            | return R(a) (in-block return)                          |
+| OP_BREAK         | B            | break R(a)                                             |
+| OP_BLKPUSH       | BS           | R(a) = block (16=5:1:5:1:4)                            |
+| OP_ADD           | B            | R(a) = R(a)+R(a+1)                                     |
+| OP_ADDI          | BB           | R(a) = R(a)+mrb_int(b)                                 |
+| OP_SUB           | B            | R(a) = R(a)-R(a+1)                                     |
+| OP_SUBI          | BB           | R(a) = R(a)-mrb_int(b)                                 |
+| OP_MUL           | B            | R(a) = R(a)*R(a+1)                                     |
+| OP_DIV           | B            | R(a) = R(a)/R(a+1)                                     |
+| OP_EQ            | B            | R(a) = R(a)==R(a+1)                                    |
+| OP_LT            | B            | R(a) = R(a)<R(a+1)                                     |
+| OP_LE            | B            | R(a) = R(a)<=R(a+1)                                    |
+| OP_GT            | B            | R(a) = R(a)>R(a+1)                                     |
+| OP_GE            | B            | R(a) = R(a)>=R(a+1)                                    |
+| OP_ARRAY         | BB           | R(a) = ary_new(R(a),R(a+1)..R(a+b))                    |
+| OP_ARRAY2        | BBB          | R(a) = ary_new(R(b),R(b+1)..R(b+c))                    |
+| OP_ARYCAT        | B            | ary_cat(R(a),R(a+1))                                   |
+| OP_ARYPUSH       | B            | ary_push(R(a),R(a+1))                                  |
+| OP_ARYDUP        | B            | R(a) = ary_dup(R(a))                                   |
+| OP_AREF          | BBB          | R(a) = R(b)[c]                                         |
+| OP_ASET          | BBB          | R(a)[c] = R(b)                                         |
+| OP_APOST         | BBB          | *R(a),R(a+1)..R(a+c) = R(a)[b..]                       |
+| OP_INTERN        | B            | R(a) = intern(R(a))                                    |
+| OP_STRING        | BB           | R(a) = str_dup(Lit(b))                                 |
+| OP_STRCAT        | B            | str_cat(R(a),R(a+1))                                   |
+| OP_HASH          | BB           | R(a) = hash_new(R(a),R(a+1)..R(a+b))                   |
+| OP_HASHADD       | BB           | R(a) = hash_push(R(a),R(a+1)..R(a+b))                  |
+| OP_HASHCAT       | B            | R(a) = hash_cat(R(a),R(a+1))                           |
+| OP_LAMBDA        | BB           | R(a) = lambda(SEQ[b],OP_L_LAMBDA)                      |
+| OP_BLOCK         | BB           | R(a) = lambda(SEQ[b],OP_L_BLOCK)                       |
+| OP_METHOD        | BB           | R(a) = lambda(SEQ[b],OP_L_METHOD)                      |
+| OP_RANGE_INC     | B            | R(a) = range_new(R(a),R(a+1),FALSE)                    |
+| OP_RANGE_EXC     | B            | R(a) = range_new(R(a),R(a+1),TRUE)                     |
+| OP_OCLASS        | B            | R(a) = ::Object                                        |
+| OP_CLASS         | BB           | R(a) = newclass(R(a),Syms(b),R(a+1))                   |
+| OP_MODULE        | BB           | R(a) = newmodule(R(a),Syms(b))                         |
+| OP_EXEC          | BB           | R(a) = blockexec(R(a),SEQ[b])                          |
+| OP_DEF           | BB           | R(a).newmethod(Syms(b),R(a+1))                         |
+| OP_ALIAS         | BB           | alias_method(target_class,Syms(a),Syms(b))             |
+| OP_UNDEF         | B            | undef_method(target_class,Syms(a))                     |
+| OP_SCLASS        | B            | R(a) = R(a).singleton_class                            |
+| OP_TCLASS        | B            | R(a) = target_class                                    |
+| OP_DEBUG         | BBB          | print a,b,c                                            |
+| OP_ERR           | B            | raise(LocalJumpError, Lit(a))                          |
+| OP_STOP          | -            | stop VM                                                |
+|------------------|--------------|--------------------------------------------------------|

examples/mrbgems/c_and_ruby_extension_example/mrblib/example.rb

@@ -1,5 +1,5 @@
 module CRubyExtension
   def CRubyExtension.ruby_method
-    puts "A Ruby Extension"
+    puts "#{self}: A Ruby Extension"
   end
 end

examples/mrbgems/c_and_ruby_extension_example/src/example.c

@@ -1,10 +1,14 @@
 #include <mruby.h>
+#include <mruby/string.h>
 #include <stdio.h>
 
 static mrb_value
 mrb_c_method(mrb_state *mrb, mrb_value self)
 {
-  puts("A C Extension");
+  mrb_value self_str = mrb_str_to_str(mrb, self);
+
+  printf("%s: A C Extension\n", mrb_str_to_cstr(mrb, self_str));
+
   return self;
 }
 

examples/mrbgems/c_extension_example/src/example.c

@@ -1,10 +1,14 @@
 #include <mruby.h>
+#include <mruby/string.h>
 #include <stdio.h>
 
 static mrb_value
 mrb_c_method(mrb_state *mrb, mrb_value self)
 {
-  puts("A C Extension");
+  mrb_value self_str = mrb_str_to_str(mrb, self);
+
+  printf("%s: A C Extension\n", mrb_str_to_cstr(mrb, self_str));
+
   return self;
 }
 

examples/mrbgems/ruby_extension_example/mrblib/example.rb

@@ -1,5 +1,5 @@
 class RubyExtension
   def RubyExtension.ruby_method
-    puts "A Ruby Extension"
+    puts "#{self}: A Ruby Extension"
   end
 end

examples/targets/build_config_android_arm64-v8a.rb

@@ -1,26 +0,0 @@
-MRuby::Build.new do |conf|
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-end
-
-# Requires Android NDK r13 or later.
-MRuby::CrossBuild.new('android-arm64-v8a') do |conf|
-  params = {
-    :arch => 'arm64-v8a',
-    :platform => 'android-24',
-    :toolchain => :clang,
-  }
-  toolchain :android, params
-
-  conf.gembox 'default'
-end

examples/targets/build_config_android_armeabi.rb

@@ -1,26 +0,0 @@
-MRuby::Build.new do |conf|
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-end
-
-# Requires Android NDK r13 or later.
-MRuby::CrossBuild.new('android-armeabi') do |conf|
-  params = {
-    :arch => 'armeabi',
-    :platform => 'android-24',
-    :toolchain => :clang,
-  }
-  toolchain :android, params
-
-  conf.gembox 'default'
-end

include/mrbconf.h

@@ -25,45 +25,40 @@
 #endif
 
 /* configuration options: */
-/* add -DMRB_USE_FLOAT to use float instead of double for floating point numbers */
-//#define MRB_USE_FLOAT
+/* add -DMRB_USE_FLOAT32 to use float instead of double for floating point numbers */
+//#define MRB_USE_FLOAT32
 
 /* exclude floating point numbers */
-//#define MRB_WITHOUT_FLOAT
+//#define MRB_NO_FLOAT
 
-/* add -DMRB_METHOD_CACHE to use method cache to improve performance */
-//#define MRB_METHOD_CACHE
-/* size of the method cache (need to be the power of 2) */
-//#define MRB_METHOD_CACHE_SIZE (1<<7)
-
-/* add -DMRB_METHOD_T_STRUCT on machines that use higher bits of pointers */
-/* no MRB_METHOD_T_STRUCT requires highest 2 bits of function pointers to be zero */
-//#define MRB_METHOD_T_STRUCT
-
-/* add -DMRB_INT16 to use 16bit integer for mrb_int; conflict with MRB_INT32 and MRB_INT64 */
-//#define MRB_INT16
-
-/* add -DMRB_INT32 to use 32bit integer for mrb_int; conflict with MRB_INT16 and MRB_INT64;
-   Default for 32-bit CPU mode. */
-//#define MRB_INT32
-
-/* add -DMRB_INT64 to use 64bit integer for mrb_int; conflict with MRB_INT16 and MRB_INT32;
-   Default for 64-bit CPU mode. */
-//#define MRB_INT64
-
-/* if no specific integer type is chosen */
-#if !defined(MRB_INT16) && !defined(MRB_INT32) && !defined(MRB_INT64)
-# if defined(MRB_64BIT) && !defined(MRB_NAN_BOXING)
-/* Use 64bit integers on 64bit architecture (without MRB_NAN_BOXING) */
-#  define MRB_INT64
-# else
-/* Otherwise use 32bit integers */
-#  define MRB_INT32
-# endif
+/* obsolete configuration */
+#if defined(MRB_USE_FLOAT)
+# define MRB_USE_FLOAT32
 #endif
 
-#define MRB_COMPLEX_NUMBERS
-#define MRB_RATIONAL_NUMBERS
+/* obsolete configuration */
+#if defined(MRB_WITHOUT_FLOAT)
+# define MRB_NO_FLOAT
+#endif
+
+#if defined(MRB_USE_FLOAT32) && defined(MRB_NO_FLOAT)
+#error Cannot define MRB_USE_FLOAT32 and MRB_NO_FLOAT at the same time
+#endif
+
+/* add -DMRB_NO_METHOD_CACHE to disable method cache to save memory */
+//#define MRB_NO_METHOD_CACHE
+/* size of the method cache (need to be the power of 2) */
+//#define MRB_METHOD_CACHE_SIZE (1<<8)
+
+/* add -DMRB_USE_METHOD_T_STRUCT on machines that use higher bits of function pointers */
+/* no MRB_USE_METHOD_T_STRUCT requires highest 2 bits of function pointers to be zero */
+#ifndef MRB_USE_METHOD_T_STRUCT
+  // can't use highest 2 bits of function pointers at least on 32bit
+  // Windows and 32bit Linux.
+# ifdef MRB_32BIT
+#   define MRB_USE_METHOD_T_STRUCT
+# endif
+#endif
 
 /* define on big endian machines; used by MRB_NAN_BOXING, etc. */
 #ifndef MRB_ENDIAN_BIG
@@ -73,12 +68,42 @@
 # endif
 #endif
 
-/* represent mrb_value in boxed double; conflict with MRB_USE_FLOAT and MRB_WITHOUT_FLOAT */
+/* represent mrb_value in boxed double; conflict with MRB_USE_FLOAT32 and MRB_NO_FLOAT */
 //#define MRB_NAN_BOXING
 
 /* represent mrb_value as a word (natural unit of data for the processor) */
 //#define MRB_WORD_BOXING
 
+/* represent mrb_value as a struct; occupies 2 words */
+//#define MRB_NO_BOXING
+
+/* if no specific boxing type is chosen */
+#if !defined(MRB_NAN_BOXING) && !defined(MRB_WORD_BOXING) && !defined(MRB_NO_BOXING)
+# define MRB_WORD_BOXING
+#endif
+
+/* add -DMRB_INT32 to use 32bit integer for mrb_int; conflict with MRB_INT64;
+   Default for 32-bit CPU mode. */
+//#define MRB_INT32
+
+/* add -DMRB_INT64 to use 64bit integer for mrb_int; conflict with MRB_INT32;
+   Default for 64-bit CPU mode (unless using MRB_NAN_BOXING). */
+//#define MRB_INT64
+
+/* if no specific integer type is chosen */
+#if !defined(MRB_INT32) && !defined(MRB_INT64)
+# if defined(MRB_64BIT) && !defined(MRB_NAN_BOXING)
+/* Use 64bit integers on 64bit architecture (without MRB_NAN_BOXING) */
+#  define MRB_INT64
+# else
+/* Otherwise use 32bit integers */
+#  define MRB_INT32
+# endif
+#endif
+
+/* call malloc_trim(0) from mrb_full_gc() */
+//#define MRB_USE_MALLOC_TRIM
+
 /* string class to handle UTF-8 encoding */
 //#define MRB_UTF8_STRING
 
@@ -160,6 +185,10 @@
 
 /* A profile for micro controllers */
 #if defined(MRB_CONSTRAINED_BASELINE_PROFILE)
+# ifndef MRB_NO_METHOD_CACHE
+#  define MRB_NO_METHOD_CACHE
+# endif
+
 # ifndef KHASH_DEFAULT_SIZE
 #  define KHASH_DEFAULT_SIZE 16
 # endif
@@ -177,10 +206,6 @@
 
 /* A profile for desktop computers or workstations; rich memory! */
 #elif defined(MRB_MAIN_PROFILE)
-# ifndef MRB_METHOD_CACHE
-#  define MRB_METHOD_CACHE
-# endif
-
 # ifndef MRB_METHOD_CACHE_SIZE
 #  define MRB_METHOD_CACHE_SIZE (1<<10)
 # endif
@@ -195,10 +220,6 @@
 
 /* A profile for server; mruby vm is long life */
 #elif defined(MRB_HIGH_PROFILE)
-# ifndef MRB_METHOD_CACHE
-#  define MRB_METHOD_CACHE
-# endif
-
 # ifndef MRB_METHOD_CACHE_SIZE
 #  define MRB_METHOD_CACHE_SIZE (1<<12)
 # endif

include/mruby.h

@@ -1,7 +1,7 @@
 /*
 ** mruby - An embeddable Ruby implementation
 **
-** Copyright (c) mruby developers 2010-2019
+** Copyright (c) mruby developers 2010-2020
 **
 ** Permission is hereby granted, free of charge, to any person obtaining
 ** a copy of this software and associated documentation files (the
@@ -62,15 +62,38 @@
 #define mrb_assert_int_fit(t1,n,t2,max) ((void)0)
 #endif
 
-#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 201112L
-#define mrb_static_assert(exp, str) _Static_assert(exp, str)
+#if (defined __cplusplus && __cplusplus >= 201103L) || \
+    (defined _MSC_VER) || \
+    (defined __GXX_EXPERIMENTAL_CXX0X__)  /* for old G++/Clang++ */
+# define mrb_static_assert(exp, str) static_assert(exp, str)
+#elif defined __STDC_VERSION__ && \
+        ((__STDC_VERSION__ >= 201112L) || \
+         (defined __GNUC__ && __GNUC__ * 100 + __GNUC_MINOR__ >= 406))
+# define mrb_static_assert(exp, str) _Static_assert(exp, str)
 #else
-#define mrb_static_assert(exp, str) mrb_assert(exp)
+# /* alternative implementation of static_assert() */
+# define _mrb_static_assert_cat0(a, b) a##b
+# define _mrb_static_assert_cat(a, b) _mrb_static_assert_cat0(a, b)
+# ifdef __COUNTER__
+#  define _mrb_static_assert_id(prefix) _mrb_static_assert_cat(prefix, __COUNTER__)
+# else
+#  define _mrb_static_assert_id(prefix) _mrb_static_assert_cat(prefix, __LINE__)
+# endif
+# define mrb_static_assert(exp, str) \
+   struct _mrb_static_assert_id(_mrb_static_assert_) { char x[(exp) ? 1 : -1]; }
 #endif
+#define mrb_static_assert1(exp) mrb_static_assert(exp, #exp)
 
 #include "mrbconf.h"
 
-#ifndef MRB_WITHOUT_FLOAT
+#include <mruby/common.h>
+#include <mruby/value.h>
+#include <mruby/gc.h>
+#include <mruby/presym.h>
+#include <mruby/version.h>
+
+#ifndef MRB_NO_FLOAT
+#include <float.h>
 #ifndef FLT_EPSILON
 #define FLT_EPSILON (1.19209290e-07f)
 #endif
@@ -81,18 +104,13 @@
 #define LDBL_EPSILON (1.08420217248550443401e-19L)
 #endif
 
-#ifdef MRB_USE_FLOAT
+#ifdef MRB_USE_FLOAT32
 #define MRB_FLOAT_EPSILON FLT_EPSILON
 #else
 #define MRB_FLOAT_EPSILON DBL_EPSILON
 #endif
 #endif
 
-#include <mruby/common.h>
-#include <mruby/value.h>
-#include <mruby/gc.h>
-#include <mruby/version.h>
-
 /**
  * MRuby C API entry point
  */
@@ -129,15 +147,13 @@ typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t, void *ud);
 
 typedef struct {
   mrb_sym mid;
-  struct RProc *proc;
+  const struct RProc *proc;
   mrb_value *stackent;
-  uint16_t ridx;
-  uint16_t epos;
   struct REnv *env;
   const mrb_code *pc;           /* return address */
   const mrb_code *err;          /* error position */
-  int argc;
-  int acc;
+  mrb_int argc;
+  mrb_int acc;
   struct RClass *target_class;
 } mrb_callinfo;
 
@@ -159,22 +175,17 @@ struct mrb_context {
   mrb_callinfo *ci;
   mrb_callinfo *cibase, *ciend;
 
-  uint16_t *rescue;                       /* exception handler stack */
-  uint16_t rsize;
-  struct RProc **ensure;                  /* ensure handler stack */
-  uint16_t esize, eidx;
-
-  enum mrb_fiber_state status;
-  mrb_bool vmexec;
+  enum mrb_fiber_state status : 4;
+  mrb_bool vmexec : 1;
   struct RFiber *fib;
 };
 
 #ifdef MRB_METHOD_CACHE_SIZE
-# define MRB_METHOD_CACHE
+# undef MRB_NO_METHOD_CACHE
 #else
-/* default method cache size: 128 */
+/* default method cache size: 256 */
 /* cache size needs to be power of 2 */
-# define MRB_METHOD_CACHE_SIZE (1<<7)
+# define MRB_METHOD_CACHE_SIZE (1<<8)
 #endif
 
 /**
@@ -188,7 +199,7 @@ struct mrb_context {
  */
 typedef mrb_value (*mrb_func_t)(struct mrb_state *mrb, mrb_value self);
 
-#ifndef MRB_METHOD_T_STRUCT
+#ifndef MRB_USE_METHOD_T_STRUCT
 typedef uintptr_t mrb_method_t;
 #else
 typedef struct {
@@ -200,7 +211,7 @@ typedef struct {
 } mrb_method_t;
 #endif
 
-#ifdef MRB_METHOD_CACHE
+#ifndef MRB_NO_METHOD_CACHE
 struct mrb_cache_entry {
   struct RClass *c, *c0;
   mrb_sym mid;
@@ -234,10 +245,10 @@ typedef struct mrb_state {
   struct RClass *hash_class;
   struct RClass *range_class;
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   struct RClass *float_class;
 #endif
-  struct RClass *fixnum_class;
+  struct RClass *integer_class;
   struct RClass *true_class;
   struct RClass *false_class;
   struct RClass *nil_class;
@@ -246,7 +257,7 @@ typedef struct mrb_state {
 
   mrb_gc gc;
 
-#ifdef MRB_METHOD_CACHE
+#ifndef MRB_NO_METHOD_CACHE
   struct mrb_cache_entry cache[MRB_METHOD_CACHE_SIZE];
 #endif
 
@@ -259,8 +270,8 @@ typedef struct mrb_state {
 #endif
 
 #ifdef MRB_ENABLE_DEBUG_HOOK
-  void (*code_fetch_hook)(struct mrb_state* mrb, struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs);
-  void (*debug_op_hook)(struct mrb_state* mrb, struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs);
+  void (*code_fetch_hook)(struct mrb_state* mrb, const struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs);
+  void (*debug_op_hook)(struct mrb_state* mrb, const struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs);
 #endif
 
 #ifdef MRB_BYTECODE_DECODE_OPTION
@@ -283,7 +294,6 @@ typedef struct mrb_state {
   mrb_atexit_func *atexit_stack;
 #endif
   uint16_t atexit_stack_len;
-  uint16_t ecall_nest;                    /* prevent infinite recursive ecall() */
 } mrb_state;
 
 /**
@@ -308,6 +318,7 @@ typedef struct mrb_state {
  * @see mrb_define_class_under
  */
 MRB_API struct RClass *mrb_define_class(mrb_state *mrb, const char *name, struct RClass *super);
+MRB_API struct RClass *mrb_define_class_id(mrb_state *mrb, mrb_sym name, struct RClass *super);
 
 /**
  * Defines a new module.
@@ -317,7 +328,10 @@ MRB_API struct RClass *mrb_define_class(mrb_state *mrb, const char *name, struct
  * @return [struct RClass *] Reference to the newly defined module.
  */
 MRB_API struct RClass *mrb_define_module(mrb_state *mrb, const char *name);
+MRB_API struct RClass *mrb_define_module_id(mrb_state *mrb, mrb_sym name);
+
 MRB_API mrb_value mrb_singleton_class(mrb_state *mrb, mrb_value val);
+MRB_API struct RClass *mrb_singleton_class_ptr(mrb_state *mrb, mrb_value val);
 
 /**
  * Include a module in another class or module.
@@ -370,6 +384,7 @@ MRB_API void mrb_prepend_module(mrb_state *mrb, struct RClass *cla, struct RClas
  * @param aspec The method parameters declaration.
  */
 MRB_API void mrb_define_method(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t func, mrb_aspec aspec);
+MRB_API void mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec);
 
 /**
  * Defines a class method.
@@ -397,6 +412,7 @@ MRB_API void mrb_define_method(mrb_state *mrb, struct RClass *cla, const char *n
  * @param aspec The method parameters declaration.
  */
 MRB_API void mrb_define_class_method(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t fun, mrb_aspec aspec);
+MRB_API void mrb_define_class_method_id(mrb_state *mrb, struct RClass *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec);
 
 /**
  * Defines a singleton method
@@ -404,6 +420,7 @@ MRB_API void mrb_define_class_method(mrb_state *mrb, struct RClass *cla, const c
  * @see mrb_define_class_method
  */
 MRB_API void mrb_define_singleton_method(mrb_state *mrb, struct RObject *cla, const char *name, mrb_func_t fun, mrb_aspec aspec);
+MRB_API void mrb_define_singleton_method_id(mrb_state *mrb, struct RObject *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec);
 
 /**
  *  Defines a module function.
@@ -431,6 +448,7 @@ MRB_API void mrb_define_singleton_method(mrb_state *mrb, struct RObject *cla, co
  *  @param aspec The method parameters declaration.
  */
 MRB_API void mrb_define_module_function(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t fun, mrb_aspec aspec);
+MRB_API void mrb_define_module_function_id(mrb_state *mrb, struct RClass *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec);
 
 /**
  *  Defines a constant.
@@ -459,6 +477,7 @@ MRB_API void mrb_define_module_function(mrb_state *mrb, struct RClass *cla, cons
  *  @param val The value for the constant.
  */
 MRB_API void mrb_define_const(mrb_state* mrb, struct RClass* cla, const char *name, mrb_value val);
+MRB_API void mrb_define_const_id(mrb_state* mrb, struct RClass* cla, mrb_sym name, mrb_value val);
 
 /**
  * Undefines a method.
@@ -549,6 +568,7 @@ MRB_API void mrb_undef_method_id(mrb_state*, struct RClass*, mrb_sym);
  * @param name The name of the class method to be undefined.
  */
 MRB_API void mrb_undef_class_method(mrb_state *mrb, struct RClass *cls, const char *name);
+MRB_API void mrb_undef_class_method_id(mrb_state *mrb, struct RClass *cls, mrb_sym name);
 
 /**
  * Initialize a new object instance of c class.
@@ -650,6 +670,7 @@ MRB_API struct RClass * mrb_module_new(mrb_state *mrb);
  * @return [mrb_bool] A boolean value.
  */
 MRB_API mrb_bool mrb_class_defined(mrb_state *mrb, const char *name);
+MRB_API mrb_bool mrb_class_defined_id(mrb_state *mrb, mrb_sym name);
 
 /**
  * Gets a class.
@@ -657,7 +678,8 @@ MRB_API mrb_bool mrb_class_defined(mrb_state *mrb, const char *name);
  * @param name The name of the class.
  * @return [struct RClass *] A reference to the class.
 */
-MRB_API struct RClass * mrb_class_get(mrb_state *mrb, const char *name);
+MRB_API struct RClass* mrb_class_get(mrb_state *mrb, const char *name);
+MRB_API struct RClass* mrb_class_get_id(mrb_state *mrb, mrb_sym name);
 
 /**
  * Gets a exception class.
@@ -665,7 +687,8 @@ MRB_API struct RClass * mrb_class_get(mrb_state *mrb, const char *name);
  * @param name The name of the class.
  * @return [struct RClass *] A reference to the class.
 */
-MRB_API struct RClass * mrb_exc_get(mrb_state *mrb, const char *name);
+MRB_API struct RClass* mrb_exc_get_id(mrb_state *mrb, mrb_sym name);
+#define mrb_exc_get(mrb, name) mrb_exc_get_id(mrb, mrb_intern_cstr(mrb, name))
 
 /**
  * Returns an mrb_bool. True if inner class was defined, and false if the inner class was not defined.
@@ -697,6 +720,7 @@ MRB_API struct RClass * mrb_exc_get(mrb_state *mrb, const char *name);
  * @return [mrb_bool] A boolean value.
  */
 MRB_API mrb_bool mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, const char *name);
+MRB_API mrb_bool mrb_class_defined_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);
 
 /**
  * Gets a child class.
@@ -706,6 +730,7 @@ MRB_API mrb_bool mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, c
  * @return [struct RClass *] A reference to the class.
 */
 MRB_API struct RClass * mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name);
+MRB_API struct RClass * mrb_class_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);
 
 /**
  * Gets a module.
@@ -714,6 +739,7 @@ MRB_API struct RClass * mrb_class_get_under(mrb_state *mrb, struct RClass *outer
  * @return [struct RClass *] A reference to the module.
 */
 MRB_API struct RClass * mrb_module_get(mrb_state *mrb, const char *name);
+MRB_API struct RClass * mrb_module_get_id(mrb_state *mrb, mrb_sym name);
 
 /**
  * Gets a module defined under another module.
@@ -723,6 +749,8 @@ MRB_API struct RClass * mrb_module_get(mrb_state *mrb, const char *name);
  * @return [struct RClass *] A reference to the module.
 */
 MRB_API struct RClass * mrb_module_get_under(mrb_state *mrb, struct RClass *outer, const char *name);
+MRB_API struct RClass * mrb_module_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);
+
 /* a function to raise NotImplementedError with current method name */
 MRB_API void mrb_notimplement(mrb_state*);
 /* a function to be replacement of unimplemented method */
@@ -791,9 +819,11 @@ MRB_API mrb_bool mrb_obj_respond_to(mrb_state *mrb, struct RClass* c, mrb_sym mi
  * @return [struct RClass *] Reference to the newly defined class
  * @see mrb_define_class
  */
-MRB_API struct RClass * mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super);
+MRB_API struct RClass* mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super);
+MRB_API struct RClass* mrb_define_class_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name, struct RClass *super);
 
-MRB_API struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name);
+MRB_API struct RClass* mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name);
+MRB_API struct RClass* mrb_define_module_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);
 
 /**
  * Function requires n arguments.
@@ -857,11 +887,11 @@ MRB_API struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *o
  * | `S`  | {String}       | {mrb_value}       | when `!` follows, the value may be `nil`           |
  * | `A`  | {Array}        | {mrb_value}       | when `!` follows, the value may be `nil`           |
  * | `H`  | {Hash}         | {mrb_value}       | when `!` follows, the value may be `nil`           |
- * | `s`  | {String}       | char *, {mrb_int} | Receive two arguments; `s!` gives (`NULL`,`0`) for `nil`        |
- * | `z`  | {String}       | char *            | `NULL` terminated string; `z!` gives `NULL` for `nil`           |
+ * | `s`  | {String}       | const char *, {mrb_int} | Receive two arguments; `s!` gives (`NULL`,`0`) for `nil` |
+ * | `z`  | {String}       | const char *      | `NULL` terminated string; `z!` gives `NULL` for `nil` |
  * | `a`  | {Array}        | {mrb_value} *, {mrb_int} | Receive two arguments; `a!` gives (`NULL`,`0`) for `nil` |
- * | `f`  | {Fixnum}/{Float} | {mrb_float}       |                                                    |
- * | `i`  | {Fixnum}/{Float} | {mrb_int}         |                                                    |
+ * | `f`  | {Integer}/{Float} | {mrb_float}    |                                                    |
+ * | `i`  | {Integer}/{Float} | {mrb_int}      |                                                    |
  * | `b`  | boolean        | {mrb_bool}        |                                                    |
  * | `n`  | {String}/{Symbol} | {mrb_sym}         |                                                    |
  * | `d`  | data           | void *, {mrb_data_type} const | 2nd argument will be used to check data type so it won't be modified; when `!` follows, the value may be `nil` |
@@ -899,7 +929,7 @@ typedef const char *mrb_args_format;
  *      const char *kw_names[kw_num] = { "a", "b" };
  *      uint32_t kw_required = 0;
  *      mrb_value kw_values[kw_num];
- *      const mrb_kwargs kwargs = { kw_num, kw_values, kw_names, kw_required, NULL };
+ *      const mrb_kwargs kwargs = { kw_num, kw_required, kw_names, kw_values, NULL };
  *
  *      mrb_get_args(mrb, ":", &kwargs);
  *      if (mrb_undef_p(kw_values[0])) { kw_values[0] = mrb_fixnum_value(1); }
@@ -910,10 +940,10 @@ typedef const char *mrb_args_format;
  *
  *      mrb_value str, kw_rest;
  *      uint32_t kw_num = 3;
- *      const char *kw_names[kw_num] = { "x", "y", "z" };
+ *      const mrb_sym kw_names[kw_num] = { MRB_SYM(x), MRB_SYM(y), MRB_SYM(z) };
  *      uint32_t kw_required = 1;
  *      mrb_value kw_values[kw_num];
- *      const mrb_kwargs kwargs = { kw_num, kw_values, kw_names, kw_required, &kw_rest };
+ *      const mrb_kwargs kwargs = { kw_num, kw_required, kw_names, kw_values, &kw_rest };
  *
  *      mrb_get_args(mrb, "S:", &str, &kwargs);
  *      // or: mrb_get_args(mrb, ":S", &kwargs, &str);
@@ -924,11 +954,11 @@ typedef struct mrb_kwargs mrb_kwargs;
 
 struct mrb_kwargs
 {
-  uint32_t num;
-  mrb_value *values;
-  const char *const *table;
-  uint32_t required;
-  mrb_value *rest;
+  uint32_t num;                 /* number of keyword arguments */
+  uint32_t required;            /* number of required keyword arguments */
+  const mrb_sym *table;         /* C array of symbols for keyword names */
+  mrb_value *values;            /* keyword argument values */
+  mrb_value *rest;              /* keyword rest (dict) */
 };
 
 /**
@@ -956,8 +986,21 @@ mrb_get_mid(mrb_state *mrb) /* get method symbol */
  */
 MRB_API mrb_int mrb_get_argc(mrb_state *mrb);
 
+/**
+ * Retrieve an array of arguments from mrb_state.
+ *
+ * Correctly handles *splat arguments.
+ */
 MRB_API mrb_value* mrb_get_argv(mrb_state *mrb);
 
+/**
+ * Retrieve the first and only argument from mrb_state.
+ * Raises ArgumentError unless the number of arguments is exactly one.
+ *
+ * Correctly handles *splat arguments.
+ */
+MRB_API mrb_value mrb_get_arg1(mrb_state *mrb);
+
 /* `strlen` for character string literals (use with caution or `strlen` instead)
     Adjacent string literals are concatenated in C/C++ in translation phase 6.
     If `lit` is not one, the compiler will report a syntax error:
@@ -985,6 +1028,7 @@ MRB_API mrb_value* mrb_get_argv(mrb_state *mrb);
  *        FILE *fp = fopen("test.rb","r");
  *        mrb_value obj = mrb_load_file(mrb,fp);
  *        mrb_funcall(mrb, obj, "method_name", 1, mrb_fixnum_value(i));
+ *        mrb_funcall_id(mrb, obj, MRB_SYM(method_name), 1, mrb_fixnum_value(i));
  *        fclose(fp);
  *        mrb_close(mrb);
  *      }
@@ -997,6 +1041,7 @@ MRB_API mrb_value* mrb_get_argv(mrb_state *mrb);
  * @return [mrb_value] mruby function value.
  */
 MRB_API mrb_value mrb_funcall(mrb_state *mrb, mrb_value val, const char *name, mrb_int argc, ...);
+MRB_API mrb_value mrb_funcall_id(mrb_state *mrb, mrb_value val, mrb_sym mid, mrb_int argc, ...);
 /**
  * Call existing ruby functions. This is basically the type safe version of mrb_funcall.
  *
@@ -1006,15 +1051,14 @@ MRB_API mrb_value mrb_funcall(mrb_state *mrb, mrb_value val, const char *name, m
  *      int
  *      main()
  *      {
- *        mrb_int i = 99;
  *        mrb_state *mrb = mrb_open();
+ *        mrb_value obj = mrb_fixnum_value(1);
  *
  *        if (!mrb) { }
- *        mrb_sym m_sym = mrb_intern_lit(mrb, "method_name"); // Symbol for method.
  *
  *        FILE *fp = fopen("test.rb","r");
  *        mrb_value obj = mrb_load_file(mrb,fp);
- *        mrb_funcall_argv(mrb, obj, m_sym, 1, &obj); // Calling ruby function from test.rb.
+ *        mrb_funcall_argv(mrb, obj, MRB_SYM(method_name), 1, &obj); // Calling ruby function from test.rb.
  *        fclose(fp);
  *        mrb_close(mrb);
  *       }
@@ -1032,7 +1076,7 @@ MRB_API mrb_value mrb_funcall_argv(mrb_state *mrb, mrb_value val, mrb_sym name,
  */
 MRB_API mrb_value mrb_funcall_with_block(mrb_state *mrb, mrb_value val, mrb_sym name, mrb_int argc, const mrb_value *argv, mrb_value block);
 /**
- * Create a symbol
+ * Create a symbol from C string. But usually it's better to use MRB_SYM(sym) and MRB_QSYM(qsym).
  *
  * Example:
  *
@@ -1040,7 +1084,9 @@ MRB_API mrb_value mrb_funcall_with_block(mrb_state *mrb, mrb_value val, mrb_sym
  *     :pizza # => :pizza
  *
  *     // C style:
- *     mrb_sym m_sym = mrb_intern_lit(mrb, "pizza"); //  => :pizza
+ *     mrb_sym sym1 = mrb_intern_lit(mrb, "pizza"); //  => :pizza
+ *     mrb_sym sym2 = MRB_SYM(pizza);               //  => :pizza
+ *     mrb_sym sym3 = MRB_SYM(pizza_p);             //  => :pizza?
  *
  * @param mrb The current mruby state.
  * @param str The string to be symbolized
@@ -1049,8 +1095,14 @@ MRB_API mrb_value mrb_funcall_with_block(mrb_state *mrb, mrb_value val, mrb_sym
 MRB_API mrb_sym mrb_intern_cstr(mrb_state *mrb, const char* str);
 MRB_API mrb_sym mrb_intern(mrb_state*,const char*,size_t);
 MRB_API mrb_sym mrb_intern_static(mrb_state*,const char*,size_t);
-#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, lit, mrb_strlen_lit(lit))
+#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit))
 MRB_API mrb_sym mrb_intern_str(mrb_state*,mrb_value);
+/* mrb_intern_check series functions returns 0 if the symbol is not defined */
+MRB_API mrb_sym mrb_intern_check_cstr(mrb_state*,const char*);
+MRB_API mrb_sym mrb_intern_check(mrb_state*,const char*,size_t);
+MRB_API mrb_sym mrb_intern_check_str(mrb_state*,mrb_value);
+/* mrb_check_intern series functions returns nil if the symbol is not defined */
+/* otherwise returns mrb_value */
 MRB_API mrb_value mrb_check_intern_cstr(mrb_state*,const char*);
 MRB_API mrb_value mrb_check_intern(mrb_state*,const char*,size_t);
 MRB_API mrb_value mrb_check_intern_str(mrb_state*,mrb_value);
@@ -1148,10 +1200,9 @@ MRB_API void mrb_close(mrb_state *mrb);
 MRB_API void* mrb_default_allocf(mrb_state*, void*, size_t, void*);
 
 MRB_API mrb_value mrb_top_self(mrb_state *mrb);
-MRB_API mrb_value mrb_run(mrb_state *mrb, struct RProc* proc, mrb_value self);
-MRB_API mrb_value mrb_top_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep);
-MRB_API mrb_value mrb_vm_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep);
-MRB_API mrb_value mrb_vm_exec(mrb_state *mrb, struct RProc *proc, const mrb_code *iseq);
+MRB_API mrb_value mrb_top_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int stack_keep);
+MRB_API mrb_value mrb_vm_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int stack_keep);
+MRB_API mrb_value mrb_vm_exec(mrb_state *mrb, const struct RProc *proc, const mrb_code *iseq);
 /* compatibility macros */
 #define mrb_toplevel_run_keep(m,p,k) mrb_top_run((m),(p),mrb_top_self(m),(k))
 #define mrb_toplevel_run(m,p) mrb_toplevel_run_keep((m),(p),0)
@@ -1166,7 +1217,7 @@ MRB_API mrb_bool mrb_obj_equal(mrb_state *mrb, mrb_value a, mrb_value b);
 MRB_API mrb_bool mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
 MRB_API mrb_value mrb_convert_to_integer(mrb_state *mrb, mrb_value val, mrb_int base);
 MRB_API mrb_value mrb_Integer(mrb_state *mrb, mrb_value val);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 MRB_API mrb_value mrb_Float(mrb_state *mrb, mrb_value val);
 #endif
 MRB_API mrb_value mrb_inspect(mrb_state *mrb, mrb_value obj);
@@ -1199,12 +1250,15 @@ MRB_API void mrb_field_write_barrier(mrb_state *, struct RBasic*, struct RBasic*
 } while (0)
 MRB_API void mrb_write_barrier(mrb_state *, struct RBasic*);
 
-MRB_API mrb_value mrb_check_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method);
+MRB_API mrb_value mrb_type_convert(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method);
+#define mrb_convert_type(mrb, val, type, tname, method) mrb_type_convert(mrb, val, type, mrb_intern_lit(mrb, method))
+MRB_API mrb_value mrb_type_convert_check(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method);
+#define mrb_check_convert_type(mrb, val, type, tname, method) mrb_type_convert_check(mrb, val, type, mrb_intern_lit(mrb, method))
+
 MRB_API mrb_value mrb_any_to_s(mrb_state *mrb, mrb_value obj);
 MRB_API const char * mrb_obj_classname(mrb_state *mrb, mrb_value obj);
 MRB_API struct RClass* mrb_obj_class(mrb_state *mrb, mrb_value obj);
 MRB_API mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c);
-MRB_API mrb_value mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method);
 MRB_API mrb_bool mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c);
 MRB_API mrb_value mrb_obj_inspect(mrb_state *mrb, mrb_value self);
 MRB_API mrb_value mrb_obj_clone(mrb_state *mrb, mrb_value self);
@@ -1232,6 +1286,7 @@ MRB_API mrb_noreturn void mrb_raise(mrb_state *mrb, struct RClass *c, const char
 MRB_API mrb_noreturn void mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...);
 MRB_API mrb_noreturn void mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...);
 MRB_API mrb_noreturn void mrb_frozen_error(mrb_state *mrb, void *frozen_obj);
+MRB_API mrb_noreturn void mrb_argnum_error(mrb_state *mrb, mrb_int argc, int min, int max);
 MRB_API void mrb_warn(mrb_state *mrb, const char *fmt, ...);
 MRB_API mrb_noreturn void mrb_bug(mrb_state *mrb, const char *fmt, ...);
 MRB_API void mrb_print_backtrace(mrb_state *mrb);
@@ -1244,25 +1299,26 @@ MRB_API mrb_value mrb_vformat(mrb_state *mrb, const char *format, va_list ap);
    + those E_* macros requires mrb_state* variable named mrb.
    + exception objects obtained from those macros are local to mrb
 */
-#define E_RUNTIME_ERROR             (mrb_exc_get(mrb, "RuntimeError"))
-#define E_TYPE_ERROR                (mrb_exc_get(mrb, "TypeError"))
-#define E_ARGUMENT_ERROR            (mrb_exc_get(mrb, "ArgumentError"))
-#define E_INDEX_ERROR               (mrb_exc_get(mrb, "IndexError"))
-#define E_RANGE_ERROR               (mrb_exc_get(mrb, "RangeError"))
-#define E_NAME_ERROR                (mrb_exc_get(mrb, "NameError"))
-#define E_NOMETHOD_ERROR            (mrb_exc_get(mrb, "NoMethodError"))
-#define E_SCRIPT_ERROR              (mrb_exc_get(mrb, "ScriptError"))
-#define E_SYNTAX_ERROR              (mrb_exc_get(mrb, "SyntaxError"))
-#define E_LOCALJUMP_ERROR           (mrb_exc_get(mrb, "LocalJumpError"))
-#define E_REGEXP_ERROR              (mrb_exc_get(mrb, "RegexpError"))
-#define E_FROZEN_ERROR              (mrb_exc_get(mrb, "FrozenError"))
+#define E_RUNTIME_ERROR             (mrb_exc_get_id(mrb, MRB_SYM(RuntimeError)))
+#define E_TYPE_ERROR                (mrb_exc_get_id(mrb, MRB_SYM(TypeError)))
+#define E_ZERODIV_ERROR             (mrb_exc_get_id(mrb, MRB_SYM(ZeroDivisionError)))
+#define E_ARGUMENT_ERROR            (mrb_exc_get_id(mrb, MRB_SYM(ArgumentError)))
+#define E_INDEX_ERROR               (mrb_exc_get_id(mrb, MRB_SYM(IndexError)))
+#define E_RANGE_ERROR               (mrb_exc_get_id(mrb, MRB_SYM(RangeError)))
+#define E_NAME_ERROR                (mrb_exc_get_id(mrb, MRB_SYM(NameError)))
+#define E_NOMETHOD_ERROR            (mrb_exc_get_id(mrb, MRB_SYM(NoMethodError)))
+#define E_SCRIPT_ERROR              (mrb_exc_get_id(mrb, MRB_SYM(ScriptError)))
+#define E_SYNTAX_ERROR              (mrb_exc_get_id(mrb, MRB_SYM(SyntaxError)))
+#define E_LOCALJUMP_ERROR           (mrb_exc_get_id(mrb, MRB_SYM(LocalJumpError)))
+#define E_REGEXP_ERROR              (mrb_exc_get_id(mrb, MRB_SYM(RegexpError)))
+#define E_FROZEN_ERROR              (mrb_exc_get_id(mrb, MRB_SYM(FrozenError)))
 
-#define E_NOTIMP_ERROR              (mrb_exc_get(mrb, "NotImplementedError"))
-#ifndef MRB_WITHOUT_FLOAT
-#define E_FLOATDOMAIN_ERROR         (mrb_exc_get(mrb, "FloatDomainError"))
+#define E_NOTIMP_ERROR              (mrb_exc_get_id(mrb, MRB_SYM(NotImplementedError)))
+#ifndef MRB_NO_FLOAT
+#define E_FLOATDOMAIN_ERROR         (mrb_exc_get_id(mrb, MRB_SYM(FloatDomainError)))
 #endif
 
-#define E_KEY_ERROR                 (mrb_exc_get(mrb, "KeyError"))
+#define E_KEY_ERROR                 (mrb_exc_get_id(mrb, MRB_SYM(KeyError)))
 
 MRB_API mrb_value mrb_yield(mrb_state *mrb, mrb_value b, mrb_value arg);
 MRB_API mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv);
@@ -1281,7 +1337,7 @@ MRB_API void mrb_gc_register(mrb_state *mrb, mrb_value obj);
 MRB_API void mrb_gc_unregister(mrb_state *mrb, mrb_value obj);
 
 MRB_API mrb_value mrb_to_int(mrb_state *mrb, mrb_value val);
-#define mrb_int(mrb, val) mrb_fixnum(mrb_to_int(mrb, val))
+#define mrb_int(mrb, val) mrb_integer(mrb_to_int(mrb, val))
 /* string type checking (contrary to the name, it doesn't convert) */
 MRB_API mrb_value mrb_to_str(mrb_state *mrb, mrb_value val);
 MRB_API void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t);
@@ -1291,14 +1347,8 @@ MRB_INLINE void mrb_check_frozen(mrb_state *mrb, void *o)
   if (mrb_frozen_p((struct RBasic*)o)) mrb_frozen_error(mrb, o);
 }
 
-typedef enum call_type {
-  CALL_PUBLIC,
-  CALL_FCALL,
-  CALL_VCALL,
-  CALL_TYPE_MAX
-} call_type;
-
 MRB_API void mrb_define_alias(mrb_state *mrb, struct RClass *c, const char *a, const char *b);
+MRB_API void mrb_define_alias_id(mrb_state *mrb, struct RClass *c, mrb_sym a, mrb_sym b);
 MRB_API const char *mrb_class_name(mrb_state *mrb, struct RClass* klass);
 MRB_API void mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val);
 
@@ -1335,7 +1385,7 @@ MRB_API mrb_value mrb_fiber_alive_p(mrb_state *mrb, mrb_value fib);
  *
  * Implemented in mruby-fiber
  */
-#define E_FIBER_ERROR (mrb_exc_get(mrb, "FiberError"))
+#define E_FIBER_ERROR (mrb_exc_get_id(mrb, MRB_SYM(FiberError)))
 MRB_API void mrb_stack_extend(mrb_state*, mrb_int);
 
 /* memory pool implementation */

include/mruby/array.h

@@ -17,23 +17,32 @@ MRB_BEGIN_DECL
 
 typedef struct mrb_shared_array {
   int refcnt;
-  mrb_int len;
+  mrb_ssize len;
   mrb_value *ptr;
 } mrb_shared_array;
 
-#define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
+#if defined(MRB_32BIT) && defined(MRB_NO_BOXING)
+# define MRB_ARY_NO_EMBED
+# define MRB_ARY_EMBED_LEN_MAX 0
+#else
+# define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
+mrb_static_assert(MRB_ARY_EMBED_LEN_MAX > 0, "MRB_ARY_EMBED_LEN_MAX > 0");
+#endif
+
 struct RArray {
   MRB_OBJECT_HEADER;
   union {
     struct {
-      mrb_int len;
+      mrb_ssize len;
       union {
-        mrb_int capa;
+        mrb_ssize capa;
         mrb_shared_array *shared;
       } aux;
       mrb_value *ptr;
     } heap;
-    void *ary[3];
+#ifndef MRB_ARY_NO_EMBED
+    mrb_value ary[MRB_ARY_EMBED_LEN_MAX];
+#endif
   } as;
 };
 
@@ -41,13 +50,21 @@ struct RArray {
 #define mrb_ary_value(p)  mrb_obj_value((void*)(p))
 #define RARRAY(v)  ((struct RArray*)(mrb_ptr(v)))
 
+#ifdef MRB_ARY_NO_EMBED
+#define ARY_EMBED_P(a) 0
+#define ARY_UNSET_EMBED_FLAG(a) (void)0
+#define ARY_EMBED_LEN(a) 0
+#define ARY_SET_EMBED_LEN(a,len) (void)0
+#define ARY_EMBED_PTR(a) 0
+#else
 #define MRB_ARY_EMBED_MASK  7
 #define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
 #define ARY_UNSET_EMBED_FLAG(a) ((a)->flags &= ~(MRB_ARY_EMBED_MASK))
 #define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
 #define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1))
-#define ARY_EMBED_PTR(a) ((mrb_value*)(&(a)->as.ary))
-
+#define ARY_EMBED_PTR(a) ((a)->as.ary)
+#endif
+  
 #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(a)->as.heap.len)
 #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
 #define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
@@ -239,6 +256,7 @@ MRB_API mrb_value mrb_ary_entry(mrb_value ary, mrb_int offset);
  * @param head Beginning position of a replacement subsequence.
  * @param len Length of a replacement subsequence.
  * @param rpl The array of replacement elements.
+ *            It is possible to pass `mrb_undef_value()` instead of an empty array.
  * @return The receiver array.
  */
 MRB_API mrb_value mrb_ary_splice(mrb_state *mrb, mrb_value self, mrb_int head, mrb_int len, mrb_value rpl);
@@ -291,6 +309,9 @@ MRB_API mrb_value mrb_ary_join(mrb_state *mrb, mrb_value ary, mrb_value sep);
  */
 MRB_API mrb_value mrb_ary_resize(mrb_state *mrb, mrb_value ary, mrb_int new_len);
 
+/* helper functions */
+mrb_value mrb_ary_subseq(mrb_state *mrb, mrb_value ary, mrb_int beg, mrb_int len);
+
 MRB_END_DECL
 
 #endif  /* MRUBY_ARRAY_H */

include/mruby/boxing_nan.h

@@ -7,12 +7,12 @@
 #ifndef MRUBY_BOXING_NAN_H
 #define MRUBY_BOXING_NAN_H
 
-#ifdef MRB_USE_FLOAT
-# error ---->> MRB_NAN_BOXING and MRB_USE_FLOAT conflict <<----
+#ifdef MRB_USE_FLOAT32
+# error ---->> MRB_NAN_BOXING and MRB_USE_FLOAT32 conflict <<----
 #endif
 
-#ifdef MRB_WITHOUT_FLOAT
-# error ---->> MRB_NAN_BOXING and MRB_WITHOUT_FLOAT conflict <<----
+#ifdef MRB_NO_FLOAT
+# error ---->> MRB_NAN_BOXING and MRB_NO_FLOAT conflict <<----
 #endif
 
 #ifdef MRB_INT64
@@ -20,6 +20,7 @@
 #endif
 
 #define MRB_FIXNUM_SHIFT 0
+#define MRB_SYMBOL_SHIFT 0
 
 /* value representation by nan-boxing:
  *   float : FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF
@@ -29,67 +30,91 @@
  * In order to get enough bit size to save TT, all pointers are shifted 2 bits
  * in the right direction. Also, TTTTTT is the mrb_vtype + 1;
  */
-typedef struct mrb_value {
-  union {
-    mrb_float f;
-    union {
-      void *p;
-      struct {
-        MRB_ENDIAN_LOHI(
-          uint32_t ttt;
-          ,union {
-            mrb_int i;
-            mrb_sym sym;
-          };
-        )
-      };
-    } value;
+typedef uint64_t mrb_value;
+
+union mrb_value_ {
+  mrb_float f;
+  uint64_t u;
+#ifdef MRB_64BIT
+  void *p;
+#endif
+  struct {
+    MRB_ENDIAN_LOHI(
+      uint32_t ttt;
+      ,uint32_t i;
+    )
   };
-} mrb_value;
+};
 
-#define mrb_float_pool(mrb,f) mrb_float_value(mrb,f)
+static inline union mrb_value_
+mrb_val_union(mrb_value v)
+{
+  union mrb_value_ x;
+  x.u = v;
+  return x;
+}
 
-#define mrb_tt(o)       ((enum mrb_vtype)(((o).value.ttt & 0xfc000)>>14)-1)
-#define mrb_type(o)     (enum mrb_vtype)((uint32_t)0xfff00000 < (o).value.ttt ? mrb_tt(o) : MRB_TT_FLOAT)
-#define mrb_ptr(o)      ((void*)((((uintptr_t)0x3fffffffffff)&((uintptr_t)((o).value.p)))<<2))
-#define mrb_float(o)    (o).f
-#define mrb_cptr(o)     mrb_ptr(o)
-#define mrb_fixnum(o)   (o).value.i
-#define mrb_symbol(o)   (o).value.sym
+#define mrb_tt(o)       ((enum mrb_vtype)((mrb_val_union(o).ttt & 0xfc000)>>14)-1)
+#define mrb_type(o)     (enum mrb_vtype)((uint32_t)0xfff00000 < mrb_val_union(o).ttt ? mrb_tt(o) : MRB_TT_FLOAT)
+#define mrb_float(o)    mrb_val_union(o).f
+#define mrb_fixnum(o)   ((mrb_int)mrb_val_union(o).i)
+#define mrb_integer(o)  mrb_fixnum(o)
+#define mrb_symbol(o)   ((mrb_sym)mrb_val_union(o).i)
 
 #ifdef MRB_64BIT
+#define mrb_ptr(o)      ((void*)((((uintptr_t)0x3fffffffffff)&((uintptr_t)(mrb_val_union(o).p)))<<2))
+#define mrb_cptr(o)     (((struct RCptr*)mrb_ptr(o))->p)
 #define BOXNAN_SHIFT_LONG_POINTER(v) (((uintptr_t)(v)>>34)&0x3fff)
 #else
+#define mrb_ptr(o)      ((void*)mrb_val_union(o).i)
+#define mrb_cptr(o)     mrb_ptr(o)
 #define BOXNAN_SHIFT_LONG_POINTER(v) 0
 #endif
 
-#define BOXNAN_SET_VALUE(o, tt, attr, v) do {\
-  (o).attr = (v);\
-  (o).value.ttt = 0xfff00000 | (((tt)+1)<<14);\
+#define BOXNAN_SET_VALUE(o, tt, attr, v) do { \
+  union mrb_value_ mrb_value_union_variable; \
+  mrb_value_union_variable.attr = (v);\
+  mrb_value_union_variable.ttt = 0xfff00000 | (((tt)+1)<<14);\
+  o = mrb_value_union_variable.u;\
 } while (0)
 
+#ifdef MRB_64BIT
 #define BOXNAN_SET_OBJ_VALUE(o, tt, v) do {\
-  (o).value.p = (void*)((uintptr_t)(v)>>2);\
-  (o).value.ttt = (0xfff00000|(((tt)+1)<<14)|BOXNAN_SHIFT_LONG_POINTER(v));\
+  union mrb_value_ mrb_value_union_variable;\
+  mrb_value_union_variable.p = (void*)((uintptr_t)(v)>>2);\
+  mrb_value_union_variable.ttt = (0xfff00000|(((tt)+1)<<14)|BOXNAN_SHIFT_LONG_POINTER(v));\
+  o = mrb_value_union_variable.u;\
 } while (0)
+#else
+#define BOXNAN_SET_OBJ_VALUE(o, tt, v) BOXNAN_SET_VALUE(o, tt, i, (uint32_t)v)
+#endif
 
 #define SET_FLOAT_VALUE(mrb,r,v) do { \
-  if ((v) != (v)) { \
-    (r).value.ttt = 0x7ff80000; \
-    (r).value.i = 0; \
+  union mrb_value_ mrb_value_union_variable; \
+  if ((v) != (v)) { /* NaN */ \
+    mrb_value_union_variable.ttt = 0x7ff80000; \
+    mrb_value_union_variable.i = 0; \
   } \
   else { \
-    (r).f = v; \
-  }} while(0)
+    mrb_value_union_variable.f = (v); \
+  } \
+  r = mrb_value_union_variable.u; \
+} while(0)
 
-#define SET_NIL_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, value.i, 0)
-#define SET_FALSE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
-#define SET_TRUE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
-#define SET_BOOL_VALUE(r,b) BOXNAN_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
-#define SET_INT_VALUE(r,n) BOXNAN_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n))
-#define SET_SYM_VALUE(r,v) BOXNAN_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))
+#define SET_NIL_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, i, 0)
+#define SET_FALSE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, i, 1)
+#define SET_TRUE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_TRUE, i, 1)
+#define SET_BOOL_VALUE(r,b) BOXNAN_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, i, 1)
+#define SET_INT_VALUE(mrb, r,n) BOXNAN_SET_VALUE(r, MRB_TT_INTEGER, i, (uint32_t)(n))
+#define SET_FIXNUM_VALUE(r,n) BOXNAN_SET_VALUE(r, MRB_TT_INTEGER, i, (uint32_t)(n))
+#define SET_SYM_VALUE(r,v) BOXNAN_SET_VALUE(r, MRB_TT_SYMBOL, i, (uint32_t)(v))
 #define SET_OBJ_VALUE(r,v) BOXNAN_SET_OBJ_VALUE(r, (((struct RObject*)(v))->tt), (v))
-#define SET_CPTR_VALUE(mrb,r,v) BOXNAN_SET_OBJ_VALUE(r, MRB_TT_CPTR, v)
-#define SET_UNDEF_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_UNDEF, value.i, 0)
+#ifdef MRB_64BIT
+MRB_API mrb_value mrb_nan_boxing_cptr_value(struct mrb_state*, void*);
+#define SET_CPTR_VALUE(mrb,r,v) ((r) = mrb_nan_boxing_cptr_value(mrb, v))
+#else
+#define SET_CPTR_VALUE(mrb,r,v) BOXNAN_SET_VALUE(r, MRB_TT_CPTR, p, v)
+#endif
+#define SET_UNDEF_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_UNDEF, i, 0)
 
 #endif  /* MRUBY_BOXING_NAN_H */

include/mruby/boxing_no.h

@@ -8,9 +8,10 @@
 #define MRUBY_BOXING_NO_H
 
 #define MRB_FIXNUM_SHIFT 0
+#define MRB_SYMBOL_SHIFT 0
 
 union mrb_value_union {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   mrb_float f;
 #endif
   void *p;
@@ -23,16 +24,13 @@ typedef struct mrb_value {
   enum mrb_vtype tt;
 } mrb_value;
 
-#ifndef MRB_WITHOUT_FLOAT
-#define mrb_float_pool(mrb,f) mrb_float_value(mrb,f)
-#endif
-
 #define mrb_ptr(o)      (o).value.p
 #define mrb_cptr(o)     mrb_ptr(o)
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #define mrb_float(o)    (o).value.f
 #endif
 #define mrb_fixnum(o)   (o).value.i
+#define mrb_integer(o)  mrb_fixnum(o)
 #define mrb_symbol(o)   (o).value.sym
 #define mrb_type(o)     (o).tt
 
@@ -45,8 +43,9 @@ typedef struct mrb_value {
 #define SET_FALSE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
 #define SET_TRUE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
 #define SET_BOOL_VALUE(r,b) BOXNIX_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
-#define SET_INT_VALUE(r,n) BOXNIX_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n))
-#ifndef MRB_WITHOUT_FLOAT
+#define SET_INT_VALUE(mrb,r,n) BOXNIX_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n))
+#define SET_FIXNUM_VALUE(r,n) BOXNIX_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n))
+#ifndef MRB_NO_FLOAT
 #define SET_FLOAT_VALUE(mrb,r,v) BOXNIX_SET_VALUE(r, MRB_TT_FLOAT, value.f, (v))
 #endif
 #define SET_SYM_VALUE(r,v) BOXNIX_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))

include/mruby/boxing_word.h

@@ -7,24 +7,20 @@
 #ifndef MRUBY_BOXING_WORD_H
 #define MRUBY_BOXING_WORD_H
 
-#if defined(MRB_INT16)
-# error MRB_INT16 is too small for MRB_WORD_BOXING.
-#endif
-
 #if defined(MRB_INT64) && !defined(MRB_64BIT)
 #error MRB_INT64 cannot be used with MRB_WORD_BOXING in 32-bit mode.
 #endif
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 struct RFloat {
   MRB_OBJECT_HEADER;
   mrb_float f;
 };
 #endif
 
-struct RCptr {
+struct RInteger {
   MRB_OBJECT_HEADER;
-  void *p;
+  mrb_int i;
 };
 
 enum mrb_special_consts {
@@ -34,98 +30,115 @@ enum mrb_special_consts {
   MRB_Qundef  = 20,
 };
 
-#define MRB_FIXNUM_SHIFT    1
-#define MRB_SYMBOL_SHIFT    2
-#define MRB_FIXNUM_FLAG     (1 << (MRB_FIXNUM_SHIFT - 1))
-#define MRB_SYMBOL_FLAG     (1 << (MRB_SYMBOL_SHIFT - 1))
-#define MRB_FIXNUM_MASK     ((1 << MRB_FIXNUM_SHIFT) - 1)
-#define MRB_SYMBOL_MASK     ((1 << MRB_SYMBOL_SHIFT) - 1)
-#define MRB_IMMEDIATE_MASK  0x07
-
-#ifdef MRB_64BIT
-#define MRB_SYMBOL_BITSIZE  (sizeof(mrb_sym) * CHAR_BIT)
-#define MRB_SYMBOL_MAX      UINT32_MAX
+#if defined(MRB_64BIT) && defined(MRB_INT32)
+#define MRB_FIXNUM_SHIFT        0
 #else
-#define MRB_SYMBOL_BITSIZE  (sizeof(mrb_sym) * CHAR_BIT - MRB_SYMBOL_SHIFT)
-#define MRB_SYMBOL_MAX      (UINT32_MAX >> MRB_SYMBOL_SHIFT)
+#define MRB_FIXNUM_SHIFT        BOXWORD_FIXNUM_SHIFT
 #endif
+#define MRB_SYMBOL_SHIFT        BOXWORD_SYMBOL_SHIFT
+
+#define BOXWORD_FIXNUM_BIT_POS  1
+#define BOXWORD_SYMBOL_BIT_POS  2
+#define BOXWORD_FIXNUM_SHIFT    BOXWORD_FIXNUM_BIT_POS
+#ifdef MRB_64BIT
+#define BOXWORD_SYMBOL_SHIFT    0
+#else
+#define BOXWORD_SYMBOL_SHIFT    BOXWORD_SYMBOL_BIT_POS
+#endif
+#define BOXWORD_FIXNUM_FLAG     (1 << (BOXWORD_FIXNUM_BIT_POS - 1))
+#define BOXWORD_SYMBOL_FLAG     (1 << (BOXWORD_SYMBOL_BIT_POS - 1))
+#define BOXWORD_FIXNUM_MASK     ((1 << BOXWORD_FIXNUM_BIT_POS) - 1)
+#define BOXWORD_SYMBOL_MASK     ((1 << BOXWORD_SYMBOL_BIT_POS) - 1)
+#define BOXWORD_IMMEDIATE_MASK  0x07
 
 #define BOXWORD_SHIFT_VALUE(o,n,t) \
-  ((((t)(o).w)) >> MRB_##n##_SHIFT)
+  (t)(((intptr_t)(o)) >> BOXWORD_##n##_SHIFT)
 #define BOXWORD_SET_SHIFT_VALUE(o,n,v) \
-  ((o).w = (((unsigned long)(v)) << MRB_##n##_SHIFT) | MRB_##n##_FLAG)
+  ((o) = (((uintptr_t)(v)) << BOXWORD_##n##_SHIFT) | BOXWORD_##n##_FLAG)
 #define BOXWORD_SHIFT_VALUE_P(o,n) \
-  (((o).w & MRB_##n##_MASK) == MRB_##n##_FLAG)
+  (((o) & BOXWORD_##n##_MASK) == BOXWORD_##n##_FLAG)
 #define BOXWORD_OBJ_TYPE_P(o,n) \
-  (!mrb_immediate_p(o) && (o).value.bp->tt == MRB_TT_##n)
+  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
 
 /*
  * mrb_value representation:
  *
- *   nil   : ...0000 0000 (all bits are zero)
- *   false : ...0000 0100
+ *   nil   : ...0000 0000 (all bits are 0)
+ *   false : ...0000 0100 (mrb_fixnum(v) != 0)
  *   true  : ...0000 1100
  *   undef : ...0001 0100
  *   fixnum: ...IIII III1
- *   symbol: ...SSSS SS10 (high-order 32-bit are symbol value in 64-bit mode)
- *   object: ...PPPP P000
+ *   symbol: ...SSSS SS10 (use only upper 32-bit as symbol value on 64-bit CPU)
+ *   object: ...PPPP P000 (any bits are 1)
  */
-typedef union mrb_value {
-  union {
-    void *p;
+typedef uintptr_t mrb_value;
+union mrb_value_ {
+  void *p;
 #ifdef MRB_64BIT
-    /* use struct to avoid bit shift. */
-    struct {
-      MRB_ENDIAN_LOHI(
-        mrb_sym sym;
-        ,uint32_t sym_flag;
-      )
-    };
+  /* use struct to avoid bit shift. */
+  struct {
+    MRB_ENDIAN_LOHI(
+      mrb_sym sym;
+      ,uint32_t sym_flag;
+    )
+  };
 #endif
-    struct RBasic *bp;
-#ifndef MRB_WITHOUT_FLOAT
-    struct RFloat *fp;
+  struct RBasic *bp;
+#ifndef MRB_NO_FLOAT
+  struct RFloat *fp;
 #endif
-    struct RCptr *vp;
-  } value;
-  unsigned long w;
-} mrb_value;
+  struct RInteger *ip;
+  struct RCptr *vp;
+  uintptr_t w;
+};
+
+static inline union mrb_value_
+mrb_val_union(mrb_value v)
+{
+  union mrb_value_ x;
+  x.w = v;
+  return x;
+}
 
 MRB_API mrb_value mrb_word_boxing_cptr_value(struct mrb_state*, void*);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float);
-MRB_API mrb_value mrb_word_boxing_float_pool(struct mrb_state*, mrb_float);
 #endif
+MRB_API mrb_value mrb_word_boxing_int_value(struct mrb_state*, mrb_int);
 
-#ifndef MRB_WITHOUT_FLOAT
-#define mrb_float_pool(mrb,f) mrb_word_boxing_float_pool(mrb,f)
-#endif
+#define mrb_immediate_p(o) ((o) & BOXWORD_IMMEDIATE_MASK || (o) == MRB_Qnil)
 
-#define mrb_ptr(o)     (o).value.p
-#define mrb_cptr(o)    (o).value.vp->p
-#ifndef MRB_WITHOUT_FLOAT
-#define mrb_float(o)   (o).value.fp->f
+#define mrb_ptr(o)     mrb_val_union(o).p
+#define mrb_cptr(o)    mrb_val_union(o).vp->p
+#ifndef MRB_NO_FLOAT
+#define mrb_float(o)   mrb_val_union(o).fp->f
 #endif
 #define mrb_fixnum(o)  BOXWORD_SHIFT_VALUE(o, FIXNUM, mrb_int)
+MRB_INLINE mrb_int
+mrb_integer_func(mrb_value o) {
+  if (mrb_immediate_p(o)) return mrb_fixnum(o);
+  return mrb_val_union(o).ip->i;
+}
+#define mrb_integer(o) mrb_integer_func(o)
 #ifdef MRB_64BIT
-#define mrb_symbol(o)  (o).value.sym
+#define mrb_symbol(o)  mrb_val_union(o).sym
 #else
 #define mrb_symbol(o)  BOXWORD_SHIFT_VALUE(o, SYMBOL, mrb_sym)
 #endif
-#define mrb_bool(o)    (((o).w & ~(unsigned long)MRB_Qfalse) != 0)
+#define mrb_bool(o)    (((o) & ~(unsigned long)MRB_Qfalse) != 0)
 
-#define mrb_immediate_p(o) ((o).w & MRB_IMMEDIATE_MASK || (o).w == MRB_Qnil)
 #define mrb_fixnum_p(o) BOXWORD_SHIFT_VALUE_P(o, FIXNUM)
+#define mrb_integer_p(o) (BOXWORD_SHIFT_VALUE_P(o, FIXNUM)||BOXWORD_OBJ_TYPE_P(o, INTEGER))
 #ifdef MRB_64BIT
-#define mrb_symbol_p(o) ((o).value.sym_flag == MRB_SYMBOL_FLAG)
+#define mrb_symbol_p(o) (mrb_val_union(o).sym_flag == BOXWORD_SYMBOL_FLAG)
 #else
 #define mrb_symbol_p(o) BOXWORD_SHIFT_VALUE_P(o, SYMBOL)
 #endif
-#define mrb_undef_p(o) ((o).w == MRB_Qundef)
-#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
-#define mrb_false_p(o) ((o).w == MRB_Qfalse)
-#define mrb_true_p(o)  ((o).w == MRB_Qtrue)
-#ifndef MRB_WITHOUT_FLOAT
+#define mrb_undef_p(o) ((o) == MRB_Qundef)
+#define mrb_nil_p(o)  ((o) == MRB_Qnil)
+#define mrb_false_p(o) ((o) == MRB_Qfalse)
+#define mrb_true_p(o)  ((o) == MRB_Qtrue)
+#ifndef MRB_NO_FLOAT
 #define mrb_float_p(o) BOXWORD_OBJ_TYPE_P(o, FLOAT)
 #endif
 #define mrb_array_p(o) BOXWORD_OBJ_TYPE_P(o, ARRAY)
@@ -141,39 +154,44 @@ MRB_API mrb_value mrb_word_boxing_float_pool(struct mrb_state*, mrb_float);
 #define mrb_sclass_p(o) BOXWORD_OBJ_TYPE_P(o, SCLASS)
 #define mrb_proc_p(o) BOXWORD_OBJ_TYPE_P(o, PROC)
 #define mrb_range_p(o) BOXWORD_OBJ_TYPE_P(o, RANGE)
-#define mrb_file_p(o) BOXWORD_OBJ_TYPE_P(o, FILE)
 #define mrb_env_p(o) BOXWORD_OBJ_TYPE_P(o, ENV)
 #define mrb_data_p(o) BOXWORD_OBJ_TYPE_P(o, DATA)
 #define mrb_fiber_p(o) BOXWORD_OBJ_TYPE_P(o, FIBER)
 #define mrb_istruct_p(o) BOXWORD_OBJ_TYPE_P(o, ISTRUCT)
 #define mrb_break_p(o) BOXWORD_OBJ_TYPE_P(o, BREAK)
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
 #endif
 #define SET_CPTR_VALUE(mrb,r,v) ((r) = mrb_word_boxing_cptr_value(mrb, v))
-#define SET_UNDEF_VALUE(r) ((r).w = MRB_Qundef)
-#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
-#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
-#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
+#define SET_UNDEF_VALUE(r) ((r) = MRB_Qundef)
+#define SET_NIL_VALUE(r) ((r) = MRB_Qnil)
+#define SET_FALSE_VALUE(r) ((r) = MRB_Qfalse)
+#define SET_TRUE_VALUE(r) ((r) = MRB_Qtrue)
 #define SET_BOOL_VALUE(r,b) ((b) ? SET_TRUE_VALUE(r) : SET_FALSE_VALUE(r))
-#define SET_INT_VALUE(r,n) BOXWORD_SET_SHIFT_VALUE(r, FIXNUM, n)
+#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_word_boxing_int_value(mrb, n))
+#define SET_FIXNUM_VALUE(r,n) BOXWORD_SET_SHIFT_VALUE(r, FIXNUM, n)
 #ifdef MRB_64BIT
-#define SET_SYM_VALUE(r,v) ((r).value.sym = v, (r).value.sym_flag = MRB_SYMBOL_FLAG)
+#define SET_SYM_VALUE(r,v) do {\
+  union mrb_value_ mrb_value_union_variable;\
+  mrb_value_union_variable.sym = v;\
+  mrb_value_union_variable.sym_flag = BOXWORD_SYMBOL_FLAG;\
+  (r) = mrb_value_union_variable.w;\
+} while (0)
 #else
 #define SET_SYM_VALUE(r,n) BOXWORD_SET_SHIFT_VALUE(r, SYMBOL, n)
 #endif
-#define SET_OBJ_VALUE(r,v) ((r).value.p = v)
+#define SET_OBJ_VALUE(r,v) ((r) = (uintptr_t)v)
 
 MRB_INLINE enum mrb_vtype
 mrb_type(mrb_value o)
 {
   return !mrb_bool(o)    ? MRB_TT_FALSE :
          mrb_true_p(o)   ? MRB_TT_TRUE :
-         mrb_fixnum_p(o) ? MRB_TT_FIXNUM :
+         mrb_fixnum_p(o) ? MRB_TT_INTEGER :
          mrb_symbol_p(o) ? MRB_TT_SYMBOL :
          mrb_undef_p(o)  ? MRB_TT_UNDEF :
-         o.value.bp->tt;
+         mrb_val_union(o).bp->tt;
 }
 
 #endif  /* MRUBY_BOXING_WORD_H */

include/mruby/class.h

@@ -17,7 +17,7 @@ MRB_BEGIN_DECL
 struct RClass {
   MRB_OBJECT_HEADER;
   struct iv_tbl *iv;
-  struct kh_mt *mt;
+  struct mt_tbl *mt;
   struct RClass *super;
 };
 
@@ -35,9 +35,9 @@ mrb_class(mrb_state *mrb, mrb_value v)
     return mrb->true_class;
   case MRB_TT_SYMBOL:
     return mrb->symbol_class;
-  case MRB_TT_FIXNUM:
-    return mrb->fixnum_class;
-#ifndef MRB_WITHOUT_FLOAT
+  case MRB_TT_INTEGER:
+    return mrb->integer_class;
+#ifndef MRB_NO_FLOAT
   case MRB_TT_FLOAT:
     return mrb->float_class;
 #endif
@@ -73,13 +73,11 @@ mrb_class(mrb_state *mrb, mrb_value v)
 #define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
 #define MRB_INSTANCE_TT(c) (enum mrb_vtype)((c)->flags & MRB_INSTANCE_TT_MASK)
 
-MRB_API struct RClass* mrb_define_class_id(mrb_state*, mrb_sym, struct RClass*);
-MRB_API struct RClass* mrb_define_module_id(mrb_state*, mrb_sym);
 struct RClass *mrb_vm_define_class(mrb_state*, mrb_value, mrb_value, mrb_sym);
 struct RClass *mrb_vm_define_module(mrb_state*, mrb_value, mrb_sym);
 MRB_API void mrb_define_method_raw(mrb_state*, struct RClass*, mrb_sym, mrb_method_t);
-MRB_API void mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec);
 MRB_API void mrb_alias_method(mrb_state*, struct RClass *c, mrb_sym a, mrb_sym b);
+MRB_API void mrb_remove_method(mrb_state *mrb, struct RClass *c, mrb_sym sym);
 
 MRB_API mrb_method_t mrb_method_search_vm(mrb_state*, struct RClass**, mrb_sym);
 MRB_API mrb_method_t mrb_method_search(mrb_state*, struct RClass*, mrb_sym);
@@ -90,10 +88,22 @@ mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv);
 void mrb_class_name_class(mrb_state*, struct RClass*, struct RClass*, mrb_sym);
 mrb_bool mrb_const_name_p(mrb_state*, const char*, mrb_int);
 mrb_value mrb_class_find_path(mrb_state*, struct RClass*);
+mrb_value mrb_mod_to_s(mrb_state*, mrb_value);
 void mrb_gc_mark_mt(mrb_state*, struct RClass*);
 size_t mrb_gc_mark_mt_size(mrb_state*, struct RClass*);
 void mrb_gc_free_mt(mrb_state*, struct RClass*);
 
+#ifndef MRB_NO_METHOD_CACHE
+void mrb_mc_clear_by_class(mrb_state *mrb, struct RClass* c);
+#else
+#define mrb_mc_clear_by_class(mrb,c)
+#endif
+
+/* return non zero to break the loop */
+struct mt_elem;
+typedef int (mrb_mt_foreach_func)(mrb_state*,mrb_sym,struct mt_elem*,void*);
+MRB_API void mrb_mt_foreach(mrb_state*, struct RClass*, mrb_mt_foreach_func*, void*);
+
 MRB_END_DECL
 
 #endif  /* MRUBY_CLASS_H */

include/mruby/common.h

@@ -74,6 +74,19 @@ MRB_BEGIN_DECL
 #endif
 #endif
 
+/** Declare mingw versions */
+#if defined(__MINGW32__) || defined(__MINGW64__)
+# include <_mingw.h>
+# if defined(__MINGW64_VERSION_MAJOR)
+#  define MRB_MINGW64_VERSION  (__MINGW64_VERSION_MAJOR * 1000 + __MINGW64_VERSION_MINOR)
+# elif defined(__MINGW32_MAJOR_VERSION)
+#  define MRB_MINGW32_VERSION  (__MINGW32_MAJOR_VERSION * 1000 + __MINGW32_MINOR_VERSION)
+# endif
+# if defined(__MINGW32__) && !defined(__MINGW64__)
+#   define MRB_MINGW32_LEGACY
+# endif
+#endif
+
 MRB_END_DECL
 
 #endif  /* MRUBY_COMMON_H */

include/mruby/compile.h

@@ -33,7 +33,7 @@ typedef struct mrbc_context {
   mrb_bool no_exec:1;
   mrb_bool keep_lv:1;
   mrb_bool no_optimize:1;
-  mrb_bool on_eval:1;
+  const struct RProc *upper;
 
   size_t parser_nerr;
 } mrbc_context;
@@ -42,6 +42,7 @@ MRB_API mrbc_context* mrbc_context_new(mrb_state *mrb);
 MRB_API void mrbc_context_free(mrb_state *mrb, mrbc_context *cxt);
 MRB_API const char *mrbc_filename(mrb_state *mrb, mrbc_context *c, const char *s);
 MRB_API void mrbc_partial_hook(mrb_state *mrb, mrbc_context *c, int (*partial_hook)(struct mrb_parser_state*), void*data);
+MRB_API void mrbc_cleanup_local_variables(mrb_state *mrb, mrbc_context *c);
 
 /* AST node structure */
 typedef struct mrb_ast_node {
@@ -151,8 +152,8 @@ struct mrb_parser_state {
   mrb_ast_node *tree;
 
   mrb_bool no_optimize:1;
-  mrb_bool on_eval:1;
   mrb_bool capture_errors:1;
+  const struct RProc *upper;
   struct mrb_parser_message error_buffer[10];
   struct mrb_parser_message warn_buffer[10];
 
@@ -161,6 +162,7 @@ struct mrb_parser_state {
   uint16_t current_filename_index;
 
   struct mrb_jmpbuf* jmp;
+  mrb_ast_node *nvars;
 };
 
 MRB_API struct mrb_parser_state* mrb_parser_new(mrb_state*);
@@ -179,7 +181,15 @@ MRB_API struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,size_t
 MRB_API struct RProc* mrb_generate_code(mrb_state*, struct mrb_parser_state*);
 MRB_API mrb_value mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c);
 
-/* program load functions */
+/** program load functions 
+* Please note! Currently due to interactions with the GC calling these functions will 
+* leak one RProc object per function call.
+* To prevent this save the current memory arena before calling and restore the arena
+* right after, like so
+* int ai = mrb_gc_arena_save(mrb);
+* mrb_value status = mrb_load_string(mrb, buffer);
+* mrb_gc_arena_restore(mrb, ai);
+*/
 #ifndef MRB_DISABLE_STDIO
 MRB_API mrb_value mrb_load_file(mrb_state*,FILE*);
 MRB_API mrb_value mrb_load_file_cxt(mrb_state*,FILE*, mrbc_context *cxt);

include/mruby/debug.h

@@ -46,13 +46,13 @@ typedef struct mrb_irep_debug_info {
  * get line from irep's debug info and program counter
  * @return returns NULL if not found
  */
-MRB_API const char *mrb_debug_get_filename(mrb_state *mrb, mrb_irep *irep, ptrdiff_t pc);
+MRB_API const char *mrb_debug_get_filename(mrb_state *mrb, const mrb_irep *irep, ptrdiff_t pc);
 
 /*
  * get line from irep's debug info and program counter
  * @return returns -1 if not found
  */
-MRB_API int32_t mrb_debug_get_line(mrb_state *mrb, mrb_irep *irep, ptrdiff_t pc);
+MRB_API int32_t mrb_debug_get_line(mrb_state *mrb, const mrb_irep *irep, size_t pc);
 
 MRB_API mrb_irep_debug_info *mrb_debug_info_alloc(mrb_state *mrb, mrb_irep *irep);
 MRB_API mrb_irep_debug_info_file *mrb_debug_info_append_file(

include/mruby/dump.h

@@ -17,15 +17,12 @@
 MRB_BEGIN_DECL
 
 #define DUMP_DEBUG_INFO 1
-#define DUMP_ENDIAN_BIG 2
-#define DUMP_ENDIAN_LIL 4
-#define DUMP_ENDIAN_NAT 6
-#define DUMP_ENDIAN_MASK 6
 
-int mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size);
+int mrb_dump_irep(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size);
 #ifndef MRB_DISABLE_STDIO
-int mrb_dump_irep_binary(mrb_state*, mrb_irep*, uint8_t, FILE*);
-int mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep*, uint8_t flags, FILE *f, const char *initname);
+int mrb_dump_irep_binary(mrb_state*, const mrb_irep*, uint8_t, FILE*);
+int mrb_dump_irep_cfunc(mrb_state *mrb, const mrb_irep*, uint8_t flags, FILE *f, const char *initname);
+int mrb_dump_irep_cstruct(mrb_state *mrb, const mrb_irep*, uint8_t flags, FILE *f, const char *initname);
 mrb_irep *mrb_read_irep_file(mrb_state*, FILE*);
 MRB_API mrb_value mrb_load_irep_file(mrb_state*,FILE*);
 MRB_API mrb_value mrb_load_irep_file_cxt(mrb_state*, FILE*, mrbc_context*);
@@ -52,12 +49,16 @@ MRB_API mrb_irep *mrb_read_irep_buf(mrb_state*, const void*, size_t);
 
 /* Rite Binary File header */
 #define RITE_BINARY_IDENT              "RITE"
-#define RITE_BINARY_IDENT_LIL          "ETIR"
-#define RITE_BINARY_FORMAT_VER         "0006"
+/* Binary Format Version Major:Minor */
+/*   Major: Incompatible to prior versions */
+/*   Minor: Upper-compatible to prior versions */
+#define RITE_BINARY_MAJOR_VER          "01"
+#define RITE_BINARY_MINOR_VER          "00"
+#define RITE_BINARY_FORMAT_VER         RITE_BINARY_MAJOR_VER RITE_BINARY_MINOR_VER
 #define RITE_COMPILER_NAME             "MATZ"
 #define RITE_COMPILER_VERSION          "0000"
 
-#define RITE_VM_VER                    "0002"
+#define RITE_VM_VER                    "0300"
 
 #define RITE_BINARY_EOF                "END\0"
 #define RITE_SECTION_IREP_IDENT        "IREP"
@@ -70,7 +71,8 @@ MRB_API mrb_irep *mrb_read_irep_buf(mrb_state*, const void*, size_t);
 /* binary header */
 struct rite_binary_header {
   uint8_t binary_ident[4];    /* Binary Identifier */
-  uint8_t binary_version[4];  /* Binary Format Version */
+  uint8_t major_version[2];   /* Binary Format Major Version */
+  uint8_t minor_version[2];   /* Binary Format Minor Version */
   uint8_t binary_crc[2];      /* Binary CRC */
   uint8_t binary_size[4];     /* Binary Size */
   uint8_t compiler_name[4];   /* Compiler name */
@@ -106,17 +108,6 @@ struct rite_binary_footer {
   RITE_SECTION_HEADER;
 };
 
-static inline int
-bigendian_p()
-{
-  int i;
-  char *p;
-
-  i = 1;
-  p = (char*)&i;
-  return p[0]?0:1;
-}
-
 static inline size_t
 uint8_to_bin(uint8_t s, uint8_t *bin)
 {
@@ -142,16 +133,6 @@ uint32_to_bin(uint32_t l, uint8_t *bin)
   return sizeof(uint32_t);
 }
 
-static inline size_t
-uint32l_to_bin(uint32_t l, uint8_t *bin)
-{
-  bin[3] = (l >> 24) & 0xff;
-  bin[2] = (l >> 16) & 0xff;
-  bin[1] = (l >> 8) & 0xff;
-  bin[0] = l & 0xff;
-  return sizeof(uint32_t);
-}
-
 static inline uint32_t
 bin_to_uint32(const uint8_t *bin)
 {
@@ -161,15 +142,6 @@ bin_to_uint32(const uint8_t *bin)
          (uint32_t)bin[3];
 }
 
-static inline uint32_t
-bin_to_uint32l(const uint8_t *bin)
-{
-  return (uint32_t)bin[3] << 24 |
-         (uint32_t)bin[2] << 16 |
-         (uint32_t)bin[1] << 8  |
-         (uint32_t)bin[0];
-}
-
 static inline uint16_t
 bin_to_uint16(const uint8_t *bin)
 {

include/mruby/endian.h

@@ -0,0 +1,44 @@
+/**
+** @file mruby/endian.h - detect endian-ness
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_ENDIAN_H
+#define MRUBY_ENDIAN_H
+
+#include <limits.h>
+
+MRB_BEGIN_DECL
+
+#if !defined(BYTE_ORDER) && defined(__BYTE_ORDER__)
+# define BYTE_ORDER __BYTE_ORDER__
+#endif
+#if !defined(BIG_ENDIAN) && defined(__ORDER_BIG_ENDIAN__)
+# define BIG_ENDIAN __ORDER_BIG_ENDIAN__
+#endif
+#if !defined(LITTLE_ENDIAN) && defined(__ORDER_LITTLE_ENDIAN__)
+# define LITTLE_ENDIAN __ORDER_LITTLE_ENDIAN__
+#endif
+
+#ifdef BYTE_ORDER
+# if BYTE_ORDER == BIG_ENDIAN
+#  define littleendian 0
+# elif BYTE_ORDER == LITTLE_ENDIAN
+#  define littleendian 1
+# endif
+#endif
+#ifndef littleendian
+/* can't distinguish endian in compile time */
+static inline int
+check_little_endian(void)
+{
+  unsigned int n = 1;
+  return (*(unsigned char *)&n == 1);
+}
+#  define littleendian check_little_endian()
+#endif
+
+MRB_END_DECL
+
+#endif  /* MRUBY_ENDIAN_H */

include/mruby/error.h

@@ -23,7 +23,8 @@ struct RException {
 
 MRB_API void mrb_sys_fail(mrb_state *mrb, const char *mesg);
 MRB_API mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str);
-#define mrb_exc_new_str_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit))
+#define mrb_exc_new_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit))
+#define mrb_exc_new_str_lit(mrb, c, lit) mrb_exc_new_str_lit(mrb, c, lit)
 MRB_API mrb_value mrb_make_exception(mrb_state *mrb, mrb_int argc, const mrb_value *argv);
 MRB_API mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc);
 MRB_API mrb_value mrb_get_backtrace(mrb_state *mrb);
@@ -32,10 +33,10 @@ MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_va
 /* declaration for `fail` method */
 MRB_API mrb_value mrb_f_raise(mrb_state*, mrb_value);
 
-#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT) || defined(MRB_NAN_BOXING) || defined(MRB_WORD_BOXING)
+#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT32) || defined(MRB_NAN_BOXING) || defined(MRB_WORD_BOXING)
 struct RBreak {
   MRB_OBJECT_HEADER;
-  struct RProc *proc;
+  const struct RProc *proc;
   mrb_value val;
 };
 #define mrb_break_value_get(brk) ((brk)->val)
@@ -43,7 +44,7 @@ struct RBreak {
 #else
 struct RBreak {
   MRB_OBJECT_HEADER;
-  struct RProc *proc;
+  const struct RProc *proc;
   union mrb_value_union value;
 };
 #define RBREAK_VALUE_TT_MASK ((1 << 8) - 1)
@@ -52,7 +53,7 @@ mrb_break_value_get(struct RBreak *brk)
 {
   mrb_value val;
   val.value = brk->value;
-  val.tt = brk->flags & RBREAK_VALUE_TT_MASK;
+  val.tt = (enum mrb_vtype)(brk->flags & RBREAK_VALUE_TT_MASK);
   return val;
 }
 static inline void
@@ -62,10 +63,43 @@ mrb_break_value_set(struct RBreak *brk, mrb_value val)
   brk->flags &= ~RBREAK_VALUE_TT_MASK;
   brk->flags |= val.tt;
 }
-#endif  /* MRB_64BIT || MRB_USE_FLOAT || MRB_NAN_BOXING || MRB_WORD_BOXING */
+#endif  /* MRB_64BIT || MRB_USE_FLOAT32 || MRB_NAN_BOXING || MRB_WORD_BOXING */
 #define mrb_break_proc_get(brk) ((brk)->proc)
 #define mrb_break_proc_set(brk, p) ((brk)->proc = p)
 
+#define RBREAK_TAG_FOREACH(f) \
+  f(RBREAK_TAG_BREAK, 0) \
+  f(RBREAK_TAG_BREAK_UPPER, 1) \
+  f(RBREAK_TAG_BREAK_INTARGET, 2) \
+  f(RBREAK_TAG_RETURN_BLOCK, 3) \
+  f(RBREAK_TAG_RETURN, 4) \
+  f(RBREAK_TAG_RETURN_TOPLEVEL, 5) \
+  f(RBREAK_TAG_JUMP, 6) \
+  f(RBREAK_TAG_STOP, 7)
+
+#define RBREAK_TAG_DEFINE(tag, i) tag = i,
+enum {
+  RBREAK_TAG_FOREACH(RBREAK_TAG_DEFINE)
+};
+#undef RBREAK_TAG_DEFINE
+
+#define RBREAK_TAG_BIT          3
+#define RBREAK_TAG_BIT_OFF      8
+#define RBREAK_TAG_MASK         (~(~UINT32_C(0) << RBREAK_TAG_BIT))
+
+static inline uint32_t
+mrb_break_tag_get(struct RBreak *brk)
+{
+  return (brk->flags >> RBREAK_TAG_BIT_OFF) & RBREAK_TAG_MASK;
+}
+
+static inline void
+mrb_break_tag_set(struct RBreak *brk, uint32_t tag)
+{
+  brk->flags &= ~(RBREAK_TAG_MASK << RBREAK_TAG_BIT_OFF);
+  brk->flags |= (tag & RBREAK_TAG_MASK) << RBREAK_TAG_BIT_OFF;
+}
+
 /**
  * Protect
  *

include/mruby/gc.h

@@ -21,6 +21,7 @@ struct mrb_state;
 #define MRB_EACH_OBJ_BREAK 1
 typedef int (mrb_each_object_callback)(struct mrb_state *mrb, struct RBasic *obj, void *data);
 void mrb_objspace_each_objects(struct mrb_state *mrb, mrb_each_object_callback *callback, void *data);
+size_t mrb_objspace_page_slot_size(void);
 MRB_API void mrb_free_context(struct mrb_state *mrb, struct mrb_context *c);
 
 #ifndef MRB_GC_ARENA_SIZE

include/mruby/hash.h

@@ -23,6 +23,7 @@ struct RHash {
 #define mrb_hash_ptr(v)    ((struct RHash*)(mrb_ptr(v)))
 #define mrb_hash_value(p)  mrb_obj_value((void*)(p))
 
+size_t mrb_os_memsize_of_hash_table(mrb_value obj);
 MRB_API mrb_value mrb_hash_new_capa(mrb_state *mrb, mrb_int capa);
 MRB_API mrb_value mrb_ensure_hash_type(mrb_state *mrb, mrb_value hash);
 MRB_API mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value hash);
@@ -200,7 +201,7 @@ MRB_API void mrb_hash_merge(mrb_state *mrb, mrb_value hash1, mrb_value hash2);
 /* RHASH_TBL allocates st_table if not available. */
 #define RHASH(obj)   ((struct RHash*)(mrb_ptr(obj)))
 #define RHASH_TBL(h)          (RHASH(h)->ht)
-#define RHASH_IFNONE(h)       mrb_iv_get(mrb, (h), mrb_intern_lit(mrb, "ifnone"))
+#define RHASH_IFNONE(h)       mrb_iv_get(mrb, (h), MRB_SYM(ifnone))
 #define RHASH_PROCDEFAULT(h)  RHASH_IFNONE(h)
 
 #define MRB_HASH_DEFAULT      1

include/mruby/irep.h

@@ -16,28 +16,58 @@
 MRB_BEGIN_DECL
 
 enum irep_pool_type {
-  IREP_TT_STRING,
-  IREP_TT_FIXNUM,
-  IREP_TT_FLOAT,
+  IREP_TT_STR   = 0,          /* string (need free) */
+  IREP_TT_SSTR  = 2,          /* string (static) */
+  IREP_TT_INT32 = 1,          /* 32bit integer */
+  IREP_TT_INT64 = 3,          /* 64bit integer */
+  IREP_TT_FLOAT = 5,          /* float (double/float) */
 };
 
-struct mrb_locals {
-  mrb_sym name;
-  uint16_t r;
+#define IREP_TT_NFLAG 1       /* number (non string) flag */
+#define IREP_TT_SFLAG 2       /* static string flag */
+
+typedef struct mrb_pool_value {
+  uint32_t tt;     /* packed type and length (for string) */
+  union {
+    const char *str;
+    int32_t i32;
+#ifdef MRB_64BIT
+    int64_t i64;
+#endif
+    mrb_float f;
+  } u;
+} mrb_pool_value;
+
+enum mrb_catch_type {
+  MRB_CATCH_RESCUE = 0,
+  MRB_CATCH_ENSURE = 1,
+};
+
+struct mrb_irep_catch_handler {
+  uint8_t type;         /* enum mrb_catch_type */
+  uint8_t begin[2];     /* The starting address to match the hander. Includes this. */
+  uint8_t end[2];       /* The endpoint address that matches the hander. Not Includes this. */
+  uint8_t target[2];    /* The address to jump to if a match is made. */
 };
 
 /* Program data array struct */
 typedef struct mrb_irep {
   uint16_t nlocals;        /* Number of local variables */
   uint16_t nregs;          /* Number of register variables */
+  uint16_t clen;           /* Number of catch handlers */
   uint8_t flags;
 
   const mrb_code *iseq;
-  mrb_value *pool;
-  mrb_sym *syms;
-  struct mrb_irep **reps;
+  /*
+   * A catch handler table is placed after the iseq entity.
+   * The reason it doesn't add fields to the structure is to keep the mrb_irep structure from bloating.
+   * The catch handler table can be obtained with `mrb_irep_catch_handler_table(irep)`.
+   */
+  const mrb_pool_value *pool;
+  const mrb_sym *syms;
+  const struct mrb_irep * const *reps;
 
-  struct mrb_locals *lv;
+  const mrb_sym *lv;
   /* debug info */
   struct mrb_irep_debug_info* debug_info;
 
@@ -46,9 +76,21 @@ typedef struct mrb_irep {
 } mrb_irep;
 
 #define MRB_ISEQ_NO_FREE 1
+#define MRB_IREP_NO_FREE 2
+#define MRB_IREP_STATIC  (MRB_ISEQ_NO_FREE | MRB_IREP_NO_FREE)
 
 MRB_API mrb_irep *mrb_add_irep(mrb_state *mrb);
 
+/** load mruby bytecode functions
+* Please note! Currently due to interactions with the GC calling these functions will
+* leak one RProc object per function call.
+* To prevent this save the current memory arena before calling and restore the arena
+* right after, like so
+* int ai = mrb_gc_arena_save(mrb);
+* mrb_value status = mrb_load_irep(mrb, buffer);
+* mrb_gc_arena_restore(mrb, ai);
+*/
+
 /* @param [const uint8_t*] irep code, expected as a literal */
 MRB_API mrb_value mrb_load_irep(mrb_state*, const uint8_t*);
 
@@ -82,6 +124,17 @@ struct mrb_insn_data {
 
 struct mrb_insn_data mrb_decode_insn(const mrb_code *pc);
 
+static inline const struct mrb_irep_catch_handler *
+mrb_irep_catch_handler_table(const struct mrb_irep *irep)
+{
+  if (irep->clen > 0) {
+    return (const struct mrb_irep_catch_handler*)(irep->iseq + irep->ilen);
+  }
+  else {
+    return (const struct mrb_irep_catch_handler*)NULL;
+  }
+}
+
 MRB_END_DECL
 
 #endif  /* MRUBY_IREP_H */

include/mruby/istruct.h

@@ -21,7 +21,10 @@ MRB_BEGIN_DECL
 
 struct RIStruct {
   MRB_OBJECT_HEADER;
-  char inline_data[ISTRUCT_DATA_SIZE];
+  union {
+    intptr_t inline_alignment[3];
+    char inline_data[ISTRUCT_DATA_SIZE];
+  };
 };
 
 #define RISTRUCT(obj)         ((struct RIStruct*)(mrb_ptr(obj)))

include/mruby/khash.h

@@ -61,7 +61,6 @@ static const uint8_t __m_either[] = {0x03, 0x0c, 0x30, 0xc0};
   typedef struct kh_##name {                                            \
     khint_t n_buckets;                                                  \
     khint_t size;                                                       \
-    khint_t n_occupied;                                                 \
     uint8_t *ed_flags;                                                  \
     khkey_t *keys;                                                      \
     khval_t *vals;                                                      \
@@ -95,16 +94,25 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
    __hash_equal: hash comparation function
 */
 #define KHASH_DEFINE(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
-  void kh_alloc_##name(mrb_state *mrb, kh_##name##_t *h)                \
+  mrb_noreturn void mrb_raise_nomemory(mrb_state *mrb);                 \
+  int kh_alloc_simple_##name(mrb_state *mrb, kh_##name##_t *h)          \
   {                                                                     \
     khint_t sz = h->n_buckets;                                          \
     size_t len = sizeof(khkey_t) + (kh_is_map ? sizeof(khval_t) : 0);   \
-    uint8_t *p = (uint8_t*)mrb_malloc(mrb, sizeof(uint8_t)*sz/4+len*sz); \
-    h->size = h->n_occupied = 0;                                        \
+    uint8_t *p = (uint8_t*)mrb_malloc_simple(mrb, sizeof(uint8_t)*sz/4+len*sz); \
+    if (!p) { return 1; }                                               \
+    h->size = 0;                                                        \
     h->keys = (khkey_t *)p;                                             \
     h->vals = kh_is_map ? (khval_t *)(p+sizeof(khkey_t)*sz) : NULL;     \
     h->ed_flags = p+len*sz;                                             \
     kh_fill_flags(h->ed_flags, 0xaa, sz/4);                             \
+    return 0;                                                           \
+  }                                                                     \
+  void kh_alloc_##name(mrb_state *mrb, kh_##name##_t *h)                \
+  {                                                                     \
+    if (kh_alloc_simple_##name(mrb, h)) {                               \
+      mrb_raise_nomemory(mrb);                                          \
+    }                                                                   \
   }                                                                     \
   kh_##name##_t *kh_init_##name##_size(mrb_state *mrb, khint_t size) {  \
     kh_##name##_t *h = (kh_##name##_t*)mrb_calloc(mrb, 1, sizeof(kh_##name##_t)); \
@@ -112,7 +120,10 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
       size = KHASH_MIN_SIZE;                                            \
     khash_power2(size);                                                 \
     h->n_buckets = size;                                                \
-    kh_alloc_##name(mrb, h);                                            \
+    if (kh_alloc_simple_##name(mrb, h)) {                               \
+      mrb_free(mrb, h);                                                 \
+      mrb_raise_nomemory(mrb);                                          \
+    }                                                                   \
     return h;                                                           \
   }                                                                     \
   kh_##name##_t *kh_init_##name(mrb_state *mrb) {                       \
@@ -130,7 +141,7 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
     (void)mrb;                                                          \
     if (h && h->ed_flags) {                                             \
       kh_fill_flags(h->ed_flags, 0xaa, h->n_buckets/4);                 \
-      h->size = h->n_occupied = 0;                                      \
+      h->size = 0;                                                      \
     }                                                                   \
   }                                                                     \
   khint_t kh_get_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key)  \
@@ -174,7 +185,7 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
   khint_t kh_put_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key, int *ret) \
   {                                                                     \
     khint_t k, del_k, step = 0;                                         \
-    if (h->n_occupied >= khash_upper_bound(h)) {                        \
+    if (h->size >= khash_upper_bound(h)) {                              \
       kh_resize_##name(mrb, h, h->n_buckets*2);                         \
     }                                                                   \
     k = __hash_func(mrb,key) & khash_mask(h);                           \
@@ -204,7 +215,6 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
       h->keys[k] = key;                                                 \
       h->ed_flags[k/4] &= ~__m_empty[k%4];                              \
       h->size++;                                                        \
-      h->n_occupied++;                                                  \
       if (ret) *ret = 1;                                                \
       return k;                                                         \
     }                                                                   \

include/mruby/numeric.h

@@ -1,5 +1,5 @@
 /**
-** @file mruby/numeric.h - Numeric, Integer, Float, Fixnum class
+** @file mruby/numeric.h - Numeric, Integer, Float class
 **
 ** See Copyright Notice in mruby.h
 */
@@ -12,17 +12,17 @@
 /**
  * Numeric class and it's sub-classes.
  *
- * Integer, Float and Fixnum
+ * Integer and Float
  */
 MRB_BEGIN_DECL
 
-#define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_INT_MAX)
-#define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_INT_MIN)
+#define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_FIXNUM_MAX)
+#define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_FIXNUM_MIN)
 #define TYPED_FIXABLE(f,t) (TYPED_POSFIXABLE(f,t) && TYPED_NEGFIXABLE(f,t))
 #define POSFIXABLE(f) TYPED_POSFIXABLE(f,mrb_int)
 #define NEGFIXABLE(f) TYPED_NEGFIXABLE(f,mrb_int)
 #define FIXABLE(f) TYPED_FIXABLE(f,mrb_int)
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #ifdef MRB_INT64
 #define FIXABLE_FLOAT(f) ((f)>=-9223372036854775808.0 && (f)<9223372036854775808.0)
 #else
@@ -30,15 +30,15 @@ MRB_BEGIN_DECL
 #endif
 #endif
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 MRB_API mrb_value mrb_flo_to_fixnum(mrb_state *mrb, mrb_value val);
 #endif
 MRB_API mrb_value mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base);
 /* ArgumentError if format string doesn't match /%(\.[0-9]+)?[aAeEfFgG]/ */
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 MRB_API mrb_value mrb_float_to_str(mrb_state *mrb, mrb_value x, const char *fmt);
+MRB_API int mrb_float_to_cstr(mrb_state *mrb, char *buf, size_t len, const char *fmt, mrb_float f);
 MRB_API mrb_float mrb_to_flo(mrb_state *mrb, mrb_value x);
-MRB_API mrb_value mrb_int_value(mrb_state *mrb, mrb_float f);
 #endif
 
 MRB_API mrb_value mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y);
@@ -136,15 +136,15 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
     if (multiplicand > 0) {
       if (multiplier > MRB_INT_MAX / multiplicand) return TRUE;
     }
-    else {
+    else if (multiplicand < 0) {
       if (multiplicand < MRB_INT_MAX / multiplier) return TRUE;
     }
   }
-  else {
+  else if (multiplier < 0) {
     if (multiplicand > 0) {
       if (multiplier < MRB_INT_MAX / multiplicand) return TRUE;
     }
-    else {
+    else if (multiplicand < 0) {
       if (multiplier != 0 && multiplicand < MRB_INT_MAX / multiplier) return TRUE;
     }
   }
@@ -160,13 +160,13 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
 
 #endif
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 # include <stdint.h>
 # include <float.h>
 
 # define MRB_FLT_RADIX          FLT_RADIX
 
-# ifdef MRB_USE_FLOAT
+# ifdef MRB_USE_FLOAT32
 #  define MRB_FLT_MANT_DIG      FLT_MANT_DIG
 #  define MRB_FLT_EPSILON       FLT_EPSILON
 #  define MRB_FLT_DIG           FLT_DIG
@@ -177,7 +177,7 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
 #  define MRB_FLT_MAX           FLT_MAX
 #  define MRB_FLT_MAX_10_EXP    FLT_MAX_10_EXP
 
-# else /* not MRB_USE_FLOAT */
+# else /* not MRB_USE_FLOAT32 */
 #  define MRB_FLT_MANT_DIG      DBL_MANT_DIG
 #  define MRB_FLT_EPSILON       DBL_EPSILON
 #  define MRB_FLT_DIG           DBL_DIG
@@ -187,8 +187,8 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
 #  define MRB_FLT_MAX_EXP       DBL_MAX_EXP
 #  define MRB_FLT_MAX           DBL_MAX
 #  define MRB_FLT_MAX_10_EXP    DBL_MAX_10_EXP
-# endif /* MRB_USE_FLOAT */
-#endif /* MRB_WITHOUT_FLOAT */
+# endif /* MRB_USE_FLOAT32 */
+#endif /* MRB_NO_FLOAT */
 
 MRB_END_DECL
 

include/mruby/opcode.h

@@ -39,31 +39,4 @@ enum mrb_insn {
 #define FETCH_S() do {a=READ_S();} while (0)
 #define FETCH_W() do {a=READ_W();} while (0)
 
-/* with OP_EXT1 (1st 16bit) */
-#define FETCH_Z_1() FETCH_Z()
-#define FETCH_B_1() FETCH_S()
-#define FETCH_BB_1() do {a=READ_S(); b=READ_B();} while (0)
-#define FETCH_BBB_1() do {a=READ_S(); b=READ_B(); c=READ_B();} while (0)
-#define FETCH_BS_1() do {a=READ_S(); b=READ_S();} while (0)
-#define FETCH_S_1() FETCH_S()
-#define FETCH_W_1() FETCH_W()
-
-/* with OP_EXT2 (2nd 16bit) */
-#define FETCH_Z_2() FETCH_Z()
-#define FETCH_B_2() FETCH_B()
-#define FETCH_BB_2() do {a=READ_B(); b=READ_S();} while (0)
-#define FETCH_BBB_2() do {a=READ_B(); b=READ_S(); c=READ_B();} while (0)
-#define FETCH_BS_2() FETCH_BS()
-#define FETCH_S_2() FETCH_S()
-#define FETCH_W_2() FETCH_W()
-
-/* with OP_EXT3 (1st & 2nd 16bit) */
-#define FETCH_Z_3() FETCH_Z()
-#define FETCH_B_3() FETCH_B()
-#define FETCH_BB_3() do {a=READ_S(); b=READ_S();} while (0)
-#define FETCH_BBB_3() do {a=READ_S(); b=READ_S(); c=READ_B();} while (0)
-#define FETCH_BS_3() do {a=READ_S(); b=READ_S();} while (0)
-#define FETCH_S_3() FETCH_S()
-#define FETCH_W_3() FETCH_W()
-
 #endif  /* MRUBY_OPCODE_H */

include/mruby/ops.h

@@ -25,6 +25,7 @@ OPCODE(LOADI_4,    B)        /* R(a) = mrb_int(4) */
 OPCODE(LOADI_5,    B)        /* R(a) = mrb_int(5) */
 OPCODE(LOADI_6,    B)        /* R(a) = mrb_int(6) */
 OPCODE(LOADI_7,    B)        /* R(a) = mrb_int(7) */
+OPCODE(LOADI16,    BS)       /* R(a) = mrb_int(b) */
 OPCODE(LOADSYM,    BB)       /* R(a) = Syms(b) */
 OPCODE(LOADNIL,    B)        /* R(a) = nil */
 OPCODE(LOADSELF,   B)        /* R(a) = self */
@@ -48,13 +49,10 @@ OPCODE(JMP,        S)        /* pc=a */
 OPCODE(JMPIF,      BS)       /* if R(a) pc=b */
 OPCODE(JMPNOT,     BS)       /* if !R(a) pc=b */
 OPCODE(JMPNIL,     BS)       /* if R(a)==nil pc=b */
-OPCODE(ONERR,      S)        /* rescue_push(a) */
+OPCODE(JMPUW,      S)        /* unwind_and_jump_to(a) */
 OPCODE(EXCEPT,     B)        /* R(a) = exc */
 OPCODE(RESCUE,     BB)       /* R(b) = R(a).isa?(R(b)) */
-OPCODE(POPERR,     B)        /* a.times{rescue_pop()} */
-OPCODE(RAISE,      B)        /* raise(R(a)) */
-OPCODE(EPUSH,      B)        /* ensure_push(SEQ[a]) */
-OPCODE(EPOP,       B)        /* A.times{ensure_pop().call} */
+OPCODE(RAISEIF,    B)        /* raise(R(a)) if R(a) */
 OPCODE(SENDV,      BB)       /* R(a) = call(R(a),Syms(b),*R(a+1)) */
 OPCODE(SENDVB,     BB)       /* R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2)) */
 OPCODE(SEND,       BBB)      /* R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c)) */
@@ -92,8 +90,8 @@ OPCODE(APOST,      BBB)      /* *R(a),R(a+1)..R(a+c) = R(a)[b..] */
 OPCODE(INTERN,     B)        /* R(a) = intern(R(a)) */
 OPCODE(STRING,     BB)       /* R(a) = str_dup(Lit(b)) */
 OPCODE(STRCAT,     B)        /* str_cat(R(a),R(a+1)) */
-OPCODE(HASH,       BB)       /* R(a) = hash_new(R(a),R(a+1)..R(a+b)) */
-OPCODE(HASHADD,    BB)       /* R(a) = hash_push(R(a),R(a+1)..R(a+b)) */
+OPCODE(HASH,       BB)       /* R(a) = hash_new(R(a),R(a+1)..R(a+b*2-1)) */
+OPCODE(HASHADD,    BB)       /* R(a) = hash_push(R(a),R(a+1)..R(a+b*2)) */
 OPCODE(HASHCAT,    B)        /* R(a) = hash_cat(R(a),R(a+1)) */
 OPCODE(LAMBDA,     BB)       /* R(a) = lambda(SEQ[b],L_LAMBDA) */
 OPCODE(BLOCK,      BB)       /* R(a) = lambda(SEQ[b],L_BLOCK) */
@@ -111,7 +109,4 @@ OPCODE(SCLASS,     B)        /* R(a) = R(a).singleton_class */
 OPCODE(TCLASS,     B)        /* R(a) = target_class */
 OPCODE(DEBUG,      BBB)      /* print a,b,c */
 OPCODE(ERR,        B)        /* raise(LocalJumpError, Lit(a)) */
-OPCODE(EXT1,       Z)        /* make 1st operand 16bit */
-OPCODE(EXT2,       Z)        /* make 2nd operand 16bit */
-OPCODE(EXT3,       Z)        /* make 1st and 2nd operands 16bit */
 OPCODE(STOP,       Z)        /* stop VM */

include/mruby/presym.h

@@ -0,0 +1,25 @@
+/**
+** @file mruby/presym.h - Preallocated Symbols
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_PRESYM_H
+#define MRUBY_PRESYM_H
+
+#undef MRB_PRESYM_MAX
+#define MRB_PRESYM_CSYM(sym, num) MRB_PRESYM__##sym = (num<<1),
+#define MRB_PRESYM_QSYM(str, sym, num) MRB_PRESYM_q_##sym = (num<<1),
+#define MRB_PRESYM_SYM(sym, num) 
+
+enum mruby_presym {
+#include <../build/presym.inc>
+};
+
+#undef MRB_PRESYM_CSYM
+#undef MRB_PRESYM_QSYM
+#undef MRB_PRESYM_SYM
+
+#define MRB_SYM(sym) MRB_PRESYM__##sym
+#define MRB_QSYM(sym) MRB_PRESYM_q_##sym
+#endif  /* MRUBY_PRESYM_H */

include/mruby/proc.h

@@ -22,24 +22,29 @@ struct REnv {
   mrb_sym mid;
 };
 
-/* flags (21bits): 1(shared flag):10(cioff/bidx):10(stack_len) */
-#define MRB_ENV_SET_STACK_LEN(e,len) ((e)->flags = (((e)->flags & ~0x3ff)|((unsigned int)(len) & 0x3ff)))
-#define MRB_ENV_STACK_LEN(e) ((mrb_int)((e)->flags & 0x3ff))
-#define MRB_ENV_STACK_UNSHARED (1<<20)
-#define MRB_ENV_UNSHARE_STACK(e) ((e)->flags |= MRB_ENV_STACK_UNSHARED)
-#define MRB_ENV_STACK_SHARED_P(e) (((e)->flags & MRB_ENV_STACK_UNSHARED) == 0)
-#define MRB_ENV_BIDX(e) (((e)->flags >> 10) & 0x3ff)
-#define MRB_ENV_SET_BIDX(e,idx) ((e)->flags = (((e)->flags & ~(0x3ff<<10))|((unsigned int)(idx) & 0x3ff)<<10))
+/* flags (21bits): 1(close):1(touched):1(heap):8(cioff/bidx):8(stack_len) */
+#define MRB_ENV_SET_LEN(e,len) ((e)->flags = (((e)->flags & ~0xff)|((unsigned int)(len) & 0xff)))
+#define MRB_ENV_LEN(e) ((mrb_int)((e)->flags & 0xff))
+#define MRB_ENV_CLOSED (1<<20)
+#define MRB_ENV_TOUCHED (1<<19)
+#define MRB_ENV_HEAPED (1<<18)
+#define MRB_ENV_CLOSE(e) ((e)->flags |= MRB_ENV_CLOSED)
+#define MRB_ENV_TOUCH(e) ((e)->flags |= MRB_ENV_TOUCHED)
+#define MRB_ENV_HEAP(e) ((e)->flags |= MRB_ENV_HEAPED)
+#define MRB_ENV_HEAP_P(e) ((e)->flags & MRB_ENV_HEAPED)
+#define MRB_ENV_ONSTACK_P(e) (((e)->flags & MRB_ENV_CLOSED) == 0)
+#define MRB_ENV_BIDX(e) (((e)->flags >> 8) & 0xff)
+#define MRB_ENV_SET_BIDX(e,idx) ((e)->flags = (((e)->flags & ~(0xff<<8))|((unsigned int)(idx) & 0xff)<<8))
 
 void mrb_env_unshare(mrb_state*, struct REnv*);
 
 struct RProc {
   MRB_OBJECT_HEADER;
   union {
-    mrb_irep *irep;
+    const mrb_irep *irep;
     mrb_func_t func;
   } body;
-  struct RProc *upper;
+  const struct RProc *upper;
   union {
     struct RClass *target_class;
     struct REnv *env;
@@ -52,7 +57,7 @@ struct RProc {
 #define MRB_ASPEC_REST(a)         (((a) >> 12) & 0x1)
 #define MRB_ASPEC_POST(a)         (((a) >> 7) & 0x1f)
 #define MRB_ASPEC_KEY(a)          (((a) >> 2) & 0x1f)
-#define MRB_ASPEC_KDICT(a)        ((a) & (1<<1))
+#define MRB_ASPEC_KDICT(a)        (((a) >> 1) & 0x1)
 #define MRB_ASPEC_BLOCK(a)        ((a) & 1)
 
 #define MRB_PROC_CFUNC_FL 128
@@ -81,16 +86,13 @@ struct RProc {
 
 #define mrb_proc_ptr(v)    ((struct RProc*)(mrb_ptr(v)))
 
-struct RProc *mrb_proc_new(mrb_state*, mrb_irep*);
-struct RProc *mrb_closure_new(mrb_state*, mrb_irep*);
+struct RProc *mrb_proc_new(mrb_state*, const mrb_irep*);
+struct RProc *mrb_closure_new(mrb_state*, const mrb_irep*);
 MRB_API struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t);
 MRB_API struct RProc *mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals);
 void mrb_proc_copy(struct RProc *a, struct RProc *b);
 mrb_int mrb_proc_arity(const struct RProc *p);
 
-/* implementation of #send method */
-mrb_value mrb_f_send(mrb_state *mrb, mrb_value self);
-
 /* following functions are defined in mruby-proc-ext so please include it when using */
 MRB_API struct RProc *mrb_proc_new_cfunc_with_env(mrb_state *mrb, mrb_func_t func, mrb_int argc, const mrb_value *argv);
 MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx);
@@ -99,7 +101,8 @@ MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx);
 
 #define MRB_METHOD_FUNC_FL 1
 #define MRB_METHOD_NOARG_FL 2
-#ifndef MRB_METHOD_T_STRUCT
+
+#ifndef MRB_USE_METHOD_T_STRUCT
 
 #define MRB_METHOD_FUNC_P(m) (((uintptr_t)(m))&MRB_METHOD_FUNC_FL)
 #define MRB_METHOD_NOARG_P(m) (((uintptr_t)(m))&MRB_METHOD_NOARG_FL)
@@ -123,7 +126,7 @@ MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx);
 #define MRB_METHOD_PROC(m) ((m).proc)
 #define MRB_METHOD_UNDEF_P(m) ((m).proc==NULL)
 
-#endif /* MRB_METHOD_T_STRUCT */
+#endif /* MRB_USE_METHOD_T_STRUCT */
 
 #define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
 #define MRB_METHOD_CFUNC(m) (MRB_METHOD_FUNC_P(m)?MRB_METHOD_FUNC(m):((MRB_METHOD_PROC(m)&&MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m)))?MRB_PROC_CFUNC(MRB_METHOD_PROC(m)):NULL))
@@ -132,6 +135,8 @@ MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx);
 #include <mruby/khash.h>
 KHASH_DECLARE(mt, mrb_sym, mrb_method_t, TRUE)
 
+MRB_API mrb_value mrb_load_proc(mrb_state *mrb, const struct RProc *proc);
+
 MRB_END_DECL
 
 #endif  /* MRUBY_PROC_H */

include/mruby/string.h

@@ -23,9 +23,9 @@ struct RString {
   MRB_OBJECT_HEADER;
   union {
     struct {
-      mrb_int len;
+      mrb_ssize len;
       union {
-        mrb_int capa;
+        mrb_ssize capa;
         struct mrb_shared_string *shared;
         struct RString *fshared;
       } aux;
@@ -35,7 +35,7 @@ struct RString {
 };
 struct RStringEmbed {
   MRB_OBJECT_HEADER;
-  char ary[];
+  char ary[RSTRING_EMBED_LEN_MAX+1];
 };
 
 #define RSTR_SET_TYPE_FLAG(s, type) (RSTR_UNSET_TYPE_FLAG(s), (s)->flags |= MRB_STR_##type)
@@ -54,7 +54,7 @@ struct RStringEmbed {
     RSTR_SET_EMBED_LEN((s),(n));\
   }\
   else {\
-    (s)->as.heap.len = (mrb_int)(n);\
+    (s)->as.heap.len = (mrb_ssize)(n);\
   }\
 } while (0)
 #define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
@@ -92,9 +92,6 @@ struct RStringEmbed {
 # define RSTR_COPY_ASCII_FLAG(dst, src) (void)0
 #endif
 
-#define RSTR_POOL_P(s) ((s)->flags & MRB_STR_POOL)
-#define RSTR_SET_POOL_FLAG(s) ((s)->flags |= MRB_STR_POOL)
-
 /**
  * Returns a pointer from a Ruby string
  */
@@ -112,13 +109,11 @@ MRB_API mrb_int mrb_str_strlen(mrb_state*, struct RString*);
 #define MRB_STR_FSHARED   2
 #define MRB_STR_NOFREE    4
 #define MRB_STR_EMBED     8  /* type flags up to here */
-#define MRB_STR_POOL     16  /* status flags from here */
-#define MRB_STR_ASCII    32
+#define MRB_STR_ASCII    16
 #define MRB_STR_EMBED_LEN_SHIFT 6
-#define MRB_STR_EMBED_LEN_BITSIZE 5
-#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BITSIZE) - 1) << MRB_STR_EMBED_LEN_SHIFT)
-#define MRB_STR_TYPE_MASK (MRB_STR_POOL - 1)
-
+#define MRB_STR_EMBED_LEN_BIT 5
+#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
+#define MRB_STR_TYPE_MASK 15
 
 void mrb_gc_free_str(mrb_state*, struct RString*);
 
@@ -382,8 +377,9 @@ MRB_API double mrb_cstr_to_dbl(mrb_state *mrb, const char *s, mrb_bool badcheck)
 /**
  * Returns a converted string type.
  * For type checking, non converting `mrb_to_str` is recommended.
+ * obsolete: use `mrb_obj_as_string()` instead.
  */
-MRB_API mrb_value mrb_str_to_str(mrb_state *mrb, mrb_value str);
+#define mrb_str_to_str(mrb, str) mrb_obj_as_string(mrb, str)
 
 /**
  * Returns true if the strings match and false if the strings don't match.
@@ -447,7 +443,6 @@ MRB_API int mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2);
  */
 MRB_API char *mrb_str_to_cstr(mrb_state *mrb, mrb_value str);
 
-mrb_value mrb_str_pool(mrb_state *mrb, mrb_value str);
 uint32_t mrb_str_hash(mrb_state *mrb, mrb_value str);
 mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str);
 
@@ -465,7 +460,8 @@ mrb_bool mrb_str_beg_len(mrb_int str_len, mrb_int *begp, mrb_int *lenp);
 mrb_value mrb_str_byte_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len);
 
 #ifdef MRB_UTF8_STRING
-mrb_int mrb_utf8_len(const char *str, mrb_int byte_len);
+mrb_int mrb_utf8len(const char *str, const char *end);
+mrb_int mrb_utf8_strlen(const char *str, mrb_int byte_len);
 #endif
 
 MRB_END_DECL

include/mruby/throw.h

@@ -13,7 +13,9 @@
 # endif
 #endif
 
-#if defined(MRB_ENABLE_CXX_EXCEPTION) && defined(__cplusplus)
+#if defined(MRB_ENABLE_CXX_EXCEPTION)
+
+# if defined(__cplusplus)
 
 #define MRB_TRY(buf) try {
 #define MRB_CATCH(buf) } catch(mrb_jmpbuf_impl e) { if (e != (buf)->impl) { throw e; }
@@ -22,6 +24,10 @@
 #define MRB_THROW(buf) throw((buf)->impl)
 typedef mrb_int mrb_jmpbuf_impl;
 
+# else
+# error "need to be compiled with C++ compiler"
+# endif  /* __cplusplus */
+
 #else
 
 #include <setjmp.h>
@@ -46,9 +52,11 @@ typedef mrb_int mrb_jmpbuf_impl;
 struct mrb_jmpbuf {
   mrb_jmpbuf_impl impl;
 
-#if defined(MRB_ENABLE_CXX_EXCEPTION) && defined(__cplusplus)
+#if defined(MRB_ENABLE_CXX_EXCEPTION)
   static mrb_int jmpbuf_id;
+# if defined(__cplusplus)
   mrb_jmpbuf() : impl(jmpbuf_id++) {}
+# endif
 #endif
 };
 

include/mruby/value.h

@@ -34,10 +34,6 @@ typedef uint32_t mrb_sym;
 typedef uint8_t mrb_bool;
 struct mrb_state;
 
-#if defined(MRB_INT16) && defined(MRB_INT64)
-# error "You can't define MRB_INT16 and MRB_INT64 at the same time."
-#endif
-
 #if defined _MSC_VER && _MSC_VER < 1800
 # define PRIo64 "llo"
 # define PRId64 "lld"
@@ -58,24 +54,20 @@ struct mrb_state;
 #if defined(MRB_INT64)
   typedef int64_t mrb_int;
 # define MRB_INT_BIT 64
-# define MRB_INT_MIN (INT64_MIN>>MRB_FIXNUM_SHIFT)
-# define MRB_INT_MAX (INT64_MAX>>MRB_FIXNUM_SHIFT)
+# define MRB_INT_MIN INT64_MIN
+# define MRB_INT_MAX INT64_MAX
+# define MRB_FIXNUM_MIN (INT64_MIN>>MRB_FIXNUM_SHIFT)
+# define MRB_FIXNUM_MAX (INT64_MAX>>MRB_FIXNUM_SHIFT)
 # define MRB_PRIo PRIo64
 # define MRB_PRId PRId64
 # define MRB_PRIx PRIx64
-#elif defined(MRB_INT16)
-  typedef int16_t mrb_int;
-# define MRB_INT_BIT 16
-# define MRB_INT_MIN (INT16_MIN>>MRB_FIXNUM_SHIFT)
-# define MRB_INT_MAX (INT16_MAX>>MRB_FIXNUM_SHIFT)
-# define MRB_PRIo PRIo16
-# define MRB_PRId PRId16
-# define MRB_PRIx PRIx16
 #else
   typedef int32_t mrb_int;
 # define MRB_INT_BIT 32
-# define MRB_INT_MIN (INT32_MIN>>MRB_FIXNUM_SHIFT)
-# define MRB_INT_MAX (INT32_MAX>>MRB_FIXNUM_SHIFT)
+# define MRB_INT_MIN INT32_MIN
+# define MRB_INT_MAX INT32_MAX
+# define MRB_FIXNUM_MIN (INT32_MIN>>MRB_FIXNUM_SHIFT)
+# define MRB_FIXNUM_MAX (INT32_MAX>>MRB_FIXNUM_SHIFT)
 # define MRB_PRIo PRIo32
 # define MRB_PRId PRId32
 # define MRB_PRIx PRIx32
@@ -87,9 +79,9 @@ struct mrb_state;
 # define MRB_ENDIAN_LOHI(a,b) b a
 #endif
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 MRB_API double mrb_float_read(const char*, char**);
-#ifdef MRB_USE_FLOAT
+#ifdef MRB_USE_FLOAT32
   typedef float mrb_float;
 #else
   typedef double mrb_float;
@@ -102,7 +94,7 @@ MRB_API int mrb_msvc_vsnprintf(char *s, size_t n, const char *format, va_list ar
 MRB_API int mrb_msvc_snprintf(char *s, size_t n, const char *format, ...);
 # define vsnprintf(s, n, format, arg) mrb_msvc_vsnprintf(s, n, format, arg)
 # define snprintf(s, n, format, ...) mrb_msvc_snprintf(s, n, format, __VA_ARGS__)
-# if _MSC_VER < 1800 && !defined MRB_WITHOUT_FLOAT
+# if _MSC_VER < 1800 && !defined MRB_NO_FLOAT
 #  include <float.h>
 #  define isfinite(n) _finite(n)
 #  define isnan _isnan
@@ -115,34 +107,36 @@ static const unsigned int IEEE754_INFINITY_BITS_SINGLE = 0x7F800000;
 #endif
 
 enum mrb_vtype {
-  MRB_TT_FALSE = 0,   /*   0 */
-  MRB_TT_TRUE,        /*   1 */
-  MRB_TT_FLOAT,       /*   2 */
-  MRB_TT_FIXNUM,      /*   3 */
-  MRB_TT_SYMBOL,      /*   4 */
-  MRB_TT_UNDEF,       /*   5 */
-  MRB_TT_CPTR,        /*   6 */
-  MRB_TT_FREE,        /*   7 */
-  MRB_TT_OBJECT,      /*   8 */
-  MRB_TT_CLASS,       /*   9 */
-  MRB_TT_MODULE,      /*  10 */
-  MRB_TT_ICLASS,      /*  11 */
-  MRB_TT_SCLASS,      /*  12 */
-  MRB_TT_PROC,        /*  13 */
-  MRB_TT_ARRAY,       /*  14 */
-  MRB_TT_HASH,        /*  15 */
-  MRB_TT_STRING,      /*  16 */
-  MRB_TT_RANGE,       /*  17 */
-  MRB_TT_EXCEPTION,   /*  18 */
-  MRB_TT_FILE,        /*  19 */
-  MRB_TT_ENV,         /*  20 */
-  MRB_TT_DATA,        /*  21 */
-  MRB_TT_FIBER,       /*  22 */
-  MRB_TT_ISTRUCT,     /*  23 */
-  MRB_TT_BREAK,       /*  24 */
-  MRB_TT_MAXDEFINE    /*  25 */
+  MRB_TT_FALSE = 0,
+  MRB_TT_TRUE,
+  MRB_TT_FLOAT,
+  MRB_TT_INTEGER,
+  MRB_TT_SYMBOL,
+  MRB_TT_UNDEF,
+  MRB_TT_CPTR,
+  MRB_TT_FREE,
+  MRB_TT_OBJECT,
+  MRB_TT_CLASS,
+  MRB_TT_MODULE,
+  MRB_TT_ICLASS,
+  MRB_TT_SCLASS,
+  MRB_TT_PROC,
+  MRB_TT_ARRAY,
+  MRB_TT_HASH,
+  MRB_TT_STRING,
+  MRB_TT_RANGE,
+  MRB_TT_EXCEPTION,
+  MRB_TT_ENV,
+  MRB_TT_DATA,
+  MRB_TT_FIBER,
+  MRB_TT_ISTRUCT,
+  MRB_TT_BREAK,
+  MRB_TT_MAXDEFINE
 };
 
+/* for compatibility */
+#define MRB_TT_FIXNUM MRB_TT_INTEGER
+
 #include <mruby/object.h>
 
 #ifdef MRB_DOCUMENTATION_BLOCK
@@ -161,6 +155,13 @@ typedef void mrb_value;
 
 #endif
 
+#if defined(MRB_WORD_BOXING) || (defined(MRB_NAN_BOXING) && defined(MRB_64BIT))
+struct RCptr {
+  MRB_OBJECT_HEADER;
+  void *p;
+};
+#endif
+
 #if defined(MRB_NAN_BOXING)
 #include "boxing_nan.h"
 #elif defined(MRB_WORD_BOXING)
@@ -169,16 +170,25 @@ typedef void mrb_value;
 #include "boxing_no.h"
 #endif
 
-#if !defined(MRB_SYMBOL_BITSIZE)
-#define MRB_SYMBOL_BITSIZE (sizeof(mrb_sym) * CHAR_BIT)
-#define MRB_SYMBOL_MAX      UINT32_MAX
+#define MRB_SYMBOL_BIT (sizeof(mrb_sym) * CHAR_BIT - MRB_SYMBOL_SHIFT)
+#define MRB_SYMBOL_MAX (UINT32_MAX >> MRB_SYMBOL_SHIFT)
+
+#if INTPTR_MAX < MRB_INT_MAX
+  typedef intptr_t mrb_ssize;
+# define MRB_SSIZE_MAX (INTPTR_MAX>>MRB_FIXNUM_SHIFT)
+#else
+  typedef mrb_int mrb_ssize;
+# define MRB_SSIZE_MAX MRB_INT_MAX
 #endif
 
 #ifndef mrb_immediate_p
 #define mrb_immediate_p(o) (mrb_type(o) < MRB_TT_FREE)
 #endif
+#ifndef mrb_integer_p
+#define mrb_integer_p(o) (mrb_type(o) == MRB_TT_INTEGER)
+#endif
 #ifndef mrb_fixnum_p
-#define mrb_fixnum_p(o) (mrb_type(o) == MRB_TT_FIXNUM)
+#define mrb_fixnum_p(o) mrb_integer_p(o)
 #endif
 #ifndef mrb_symbol_p
 #define mrb_symbol_p(o) (mrb_type(o) == MRB_TT_SYMBOL)
@@ -195,7 +205,7 @@ typedef void mrb_value;
 #ifndef mrb_true_p
 #define mrb_true_p(o)  (mrb_type(o) == MRB_TT_TRUE)
 #endif
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #ifndef mrb_float_p
 #define mrb_float_p(o) (mrb_type(o) == MRB_TT_FLOAT)
 #endif
@@ -239,9 +249,6 @@ typedef void mrb_value;
 #ifndef mrb_range_p
 #define mrb_range_p(o) (mrb_type(o) == MRB_TT_RANGE)
 #endif
-#ifndef mrb_file_p
-#define mrb_file_p(o) (mrb_type(o) == MRB_TT_FILE)
-#endif
 #ifndef mrb_env_p
 #define mrb_env_p(o) (mrb_type(o) == MRB_TT_ENV)
 #endif
@@ -267,7 +274,7 @@ typedef void mrb_value;
  *
  * Takes a float and boxes it into an mrb_value
  */
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 MRB_INLINE mrb_value mrb_float_value(struct mrb_state *mrb, mrb_float f)
 {
   mrb_value v;
@@ -287,14 +294,19 @@ mrb_cptr_value(struct mrb_state *mrb, void *p)
 }
 
 /**
- * Returns a fixnum in Ruby.
- *
- * Takes an integer and boxes it into an mrb_value
+ * Returns an integer in Ruby.
  */
+MRB_INLINE mrb_value mrb_int_value(struct mrb_state *mrb, mrb_int i)
+{
+  mrb_value v;
+  SET_INT_VALUE(mrb, v, i);
+  return v;
+}
+
 MRB_INLINE mrb_value mrb_fixnum_value(mrb_int i)
 {
   mrb_value v;
-  SET_INT_VALUE(v, i);
+  SET_FIXNUM_VALUE(v, i);
   return v;
 }
 

include/mruby/variable.h

@@ -35,6 +35,7 @@ mrb_value mrb_vm_cv_get(mrb_state*, mrb_sym);
 void mrb_vm_cv_set(mrb_state*, mrb_sym, mrb_value);
 mrb_value mrb_vm_const_get(mrb_state*, mrb_sym);
 void mrb_vm_const_set(mrb_state*, mrb_sym, mrb_value);
+size_t mrb_obj_iv_tbl_memsize(mrb_state*, mrb_value);
 MRB_API mrb_value mrb_const_get(mrb_state*, mrb_value, mrb_sym);
 MRB_API void mrb_const_set(mrb_state*, mrb_value, mrb_sym, mrb_value);
 MRB_API mrb_bool mrb_const_defined(mrb_state*, mrb_value, mrb_sym);

include/mruby/version.h

@@ -27,7 +27,7 @@ MRB_BEGIN_DECL
 /*
  * The version of Ruby used by mruby.
  */
-#define MRUBY_RUBY_VERSION "2.0"
+#define MRUBY_RUBY_VERSION "3.0"
 
 /*
  * Ruby engine.
@@ -37,12 +37,12 @@ MRB_BEGIN_DECL
 /*
  * Major release version number.
  */
-#define MRUBY_RELEASE_MAJOR 2
+#define MRUBY_RELEASE_MAJOR 3
 
 /*
  * Minor release version number.
  */
-#define MRUBY_RELEASE_MINOR 1
+#define MRUBY_RELEASE_MINOR 0
 
 /*
  * Tiny release version number.
@@ -62,7 +62,7 @@ MRB_BEGIN_DECL
 /*
  * Release year.
  */
-#define MRUBY_RELEASE_YEAR 2019
+#define MRUBY_RELEASE_YEAR 2020
 
 /*
  * Release month.
@@ -72,7 +72,7 @@ MRB_BEGIN_DECL
 /*
  * Release day.
  */
-#define MRUBY_RELEASE_DAY 18
+#define MRUBY_RELEASE_DAY 16
 
 /*
  * Release date as a string.

lib/mruby-core-ext.rb

@@ -20,27 +20,8 @@ class String
   end
 end
 
-$pp_show = true
-
-if $verbose.nil?
-  if Rake.respond_to?(:verbose) && !Rake.verbose.nil?
-    if Rake.verbose.class == TrueClass
-      # verbose message logging
-      $pp_show = false
-    else
-      $pp_show = true
-      Rake.verbose(false)
-    end
-  else
-    # could not identify rake version
-    $pp_show = false
-  end
-else
-  $pp_show = false if $verbose
-end
-
 def _pp(cmd, src, tgt=nil, options={})
-  return unless $pp_show
+  return if Rake.verbose
 
   width = 5
   template = options[:indent] ? "%#{width*options[:indent]}s %s %s" : "%-#{width}s %s %s"

lib/mruby/build.rb

@@ -81,7 +81,8 @@ module MRuby
         @mrbc = Command::Mrbc.new(self)
 
         @bins = []
-        @gems, @libmruby_objs = MRuby::Gem::List.new, []
+        @gems = MRuby::Gem::List.new
+        @libmruby_objs = []
         @build_mrbtest_lib_only = false
         @cxx_exception_enabled = false
         @cxx_exception_disabled = false
@@ -95,11 +96,10 @@ module MRuby
         MRuby.targets[@name] = self
       end
 
-      MRuby::Build.current = MRuby.targets[@name]
-      MRuby.targets[@name].instance_eval(&block)
-
-      build_mrbc_exec if name == 'host'
-      build_mrbtest if test_enabled?
+      current = MRuby.targets[@name]
+      MRuby::Build.current = current
+      current.instance_eval(&block)
+      current.build_mrbtest if current.test_enabled?
     end
 
     def debug_enabled?
@@ -173,7 +173,7 @@ module MRuby
       obj = objfile(cxx_src) if obj.nil?
 
       file cxx_src => [src, __FILE__] do |t|
-        FileUtils.mkdir_p File.dirname t.name
+        mkdir_p File.dirname t.name
         IO.write t.name, <<EOS
 #define __STDC_CONSTANT_MACROS
 #define __STDC_LIMIT_MACROS
@@ -196,6 +196,7 @@ EOS
     end
 
     def enable_bintest
+      raise "bintest works only on 'host' target" unless name == "host"
       @enable_bintest = true
     end
 
@@ -246,9 +247,11 @@ EOS
     def mrbcfile
       return @mrbcfile if @mrbcfile
 
-      mrbc_build = MRuby.targets['host']
-      gems.each { |v| mrbc_build = self if v.name == 'mruby-bin-mrbc' }
-      @mrbcfile = mrbc_build.exefile("#{mrbc_build.build_dir}/bin/mrbc")
+      unless gems.detect {|v| v.name == 'mruby-bin-mrbc' }
+        build_mrbc_exec
+        gems.detect {|v| v.name == 'mruby-bin-mrbc' }.setup
+      end
+      @mrbcfile = self.exefile("#{self.build_dir}/bin/mrbc")
     end
 
     def compilers
@@ -276,14 +279,6 @@ EOS
       end
     end
 
-    def cygwin_filename(name)
-      if name.is_a?(Array)
-        name.flatten.map { |n| cygwin_filename(n) }
-      else
-        `cygpath -w "#{filename(name)}"`.strip
-      end
-    end
-
     def exefile(name)
       if name.is_a?(Array)
         name.flatten.map { |n| exefile(n) }
@@ -320,7 +315,7 @@ EOS
     end
 
     def verbose_flag
-      $verbose ? ' -v' : ''
+      Rake.verbose ? ' -v' : ''
     end
 
     def run_test
@@ -344,7 +339,8 @@ EOS
       puts "         Binaries: #{@bins.join(', ')}" unless @bins.empty?
       unless @gems.empty?
         puts "    Included Gems:"
-        @gems.map do |gem|
+        gems = @gems.sort_by { |gem| gem.name }
+        gems.each do |gem|
           gem_version = " - #{gem.version}" if gem.version != '0.0.0'
           gem_summary = " - #{gem.summary}" if gem.summary
           puts "             #{gem.name}#{gem_version}#{gem_summary}"
@@ -376,17 +372,29 @@ EOS
     attr_accessor :host_target, :build_target
 
     def initialize(name, build_dir=nil, &block)
+      unless MRuby.targets['host']
+        # add minimal 'host'
+        MRuby::Build.new('host') do |conf|
+          if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
+            toolchain :visualcpp
+          else
+            toolchain :gcc
+          end
+          conf.gem :core => 'mruby-bin-mrbc'
+        end
+      end
       @endian = nil
       @test_runner = Command::CrossTestRunner.new(self)
       super
     end
 
     def mrbcfile
-      MRuby.targets['host'].exefile("#{MRuby.targets['host'].build_dir}/bin/mrbc")
+      host = MRuby.targets['host']
+      host.exefile("#{host.build_dir}/bin/mrbc")
     end
 
     def run_test
-      @test_runner.runner_options << ' -v' if $verbose
+      @test_runner.runner_options << verbose_flag
       mrbtest = exefile("#{build_dir}/bin/mrbtest")
       if (@test_runner.command == nil)
         puts "You should run #{mrbtest} on target device."
@@ -395,26 +403,5 @@ EOS
         @test_runner.run(mrbtest)
       end
     end
-
-    def big_endian
-      if @endian
-        puts "Endian has already specified as #{@endian}."
-        return
-      end
-      @endian = :big
-      @mrbc.compile_options += ' -E'
-      compilers.each do |c|
-        c.defines += %w(MRB_ENDIAN_BIG)
-      end
-    end
-
-    def little_endian
-      if @endian
-        puts "Endian has already specified as #{@endian}."
-        return
-      end
-      @endian = :little
-      @mrbc.compile_options += ' -e'
-    end
   end # CrossBuild
 end # MRuby

lib/mruby/build/command.rb

@@ -4,7 +4,7 @@ module MRuby
   class Command
     include Rake::DSL
     extend Forwardable
-    def_delegators :@build, :filename, :objfile, :libfile, :exefile, :cygwin_filename
+    def_delegators :@build, :filename, :objfile, :libfile, :exefile
     attr_accessor :build, :command
 
     def initialize(build)
@@ -24,6 +24,14 @@ module MRuby
       target
     end
 
+    def shellquote(s)
+      if ENV['OS'] == 'Windows_NT'
+        "\"#{s}\""
+      else
+        "#{s}"
+      end
+    end
+
     NotFoundCommands = {}
 
     private
@@ -50,9 +58,9 @@ module MRuby
       @source_exts = source_exts
       @include_paths = ["#{MRUBY_ROOT}/include"]
       @defines = %w()
-      @option_include_path = '-I%s'
-      @option_define = '-D%s'
-      @compile_options = '%{flags} -o %{outfile} -c %{infile}'
+      @option_include_path = %q[-I"%s"]
+      @option_define = %q[-D"%s"]
+      @compile_options = %q[%{flags} -o "%{outfile}" -c "%{infile}"]
       @cxx_invalid_flags = []
     end
 
@@ -71,25 +79,16 @@ module MRuby
     def all_flags(_defines=[], _include_paths=[], _flags=[])
       define_flags = [defines, _defines].flatten.map{ |d| option_define % d }
       include_path_flags = [include_paths, _include_paths].flatten.map do |f|
-        if MRUBY_BUILD_HOST_IS_CYGWIN
-          option_include_path % cygwin_filename(f)
-        else
-          option_include_path % filename(f)
-        end
+        option_include_path % filename(f)
       end
       [flags, define_flags, include_path_flags, _flags].flatten.join(' ')
     end
 
     def run(outfile, infile, _defines=[], _include_paths=[], _flags=[])
-      FileUtils.mkdir_p File.dirname(outfile)
+      mkdir_p File.dirname(outfile)
       _pp "CC", infile.relative_path, outfile.relative_path
-      if MRUBY_BUILD_HOST_IS_CYGWIN
-        _run compile_options, { :flags => all_flags(_defines, _include_paths, _flags),
-                                :infile => cygwin_filename(infile), :outfile => cygwin_filename(outfile) }
-      else
-        _run compile_options, { :flags => all_flags(_defines, _include_paths, _flags),
-                                :infile => filename(infile), :outfile => filename(outfile) }
-      end
+      _run compile_options, { :flags => all_flags(_defines, _include_paths, _flags),
+                              :infile => filename(infile), :outfile => filename(outfile) }
     end
 
     def define_rules(build_dir, source_dir='')
@@ -134,18 +133,14 @@ module MRuby
     #
     # ==== Without <tt>-MP</tt> compiler flag
     #
-    #   /build/host/src/array.o: \
-    #     /src/array.c \
-    #     /include/mruby/common.h \
-    #     /include/mruby/value.h \
+    #   /build/host/src/array.o: /src/array.c \
+    #     /include/mruby/common.h /include/mruby/value.h \
     #     /src/value_array.h
     #
     # ==== With <tt>-MP</tt> compiler flag
     #
-    #   /build/host/src/array.o: \
-    #     /src/array.c \
-    #     /include/mruby/common.h \
-    #     /include/mruby/value.h \
+    #   /build/host/src/array.o: /src/array.c \
+    #     /include/mruby/common.h /include/mruby/value.h \
     #     /src/value_array.h
     #
     #   /include/mruby/common.h:
@@ -156,11 +151,18 @@ module MRuby
     #
     def get_dependencies(file)
       file = file.ext('d') unless File.extname(file) == '.d'
-      deps = []
-      if File.exist?(file)
-        File.foreach(file){|line| deps << $1 if /^ +(.*?)(?: *\\)?$/ =~ line}
-        deps.uniq!
-      end
+      return [MRUBY_CONFIG] unless File.exist?(file)
+
+      deps = File.read(file).gsub("\\\n ", "").split("\n").map do |dep_line|
+        # dep_line:
+        # - "/build/host/src/array.o:   /src/array.c   /include/mruby/common.h ..."
+        # - ""
+        # - "/include/mruby/common.h:"
+        dep_line.scan(/^\S+:\s+(.+)$/).flatten.map { |s| s.split(' ') }.flatten
+        # => ["/src/array.c", "/include/mruby/common.h" , ...]
+        #    []
+        #    []
+      end.flatten.uniq
       deps << MRUBY_CONFIG
     end
   end
@@ -176,18 +178,14 @@ module MRuby
       @flags_before_libraries, @flags_after_libraries = [], []
       @libraries = []
       @library_paths = []
-      @option_library = '-l%s'
-      @option_library_path = '-L%s'
-      @link_options = "%{flags} -o %{outfile} %{objs} %{flags_before_libraries} %{libs} %{flags_after_libraries}"
+      @option_library = %q[-l"%s"]
+      @option_library_path = %q[-L"%s"]
+      @link_options = %Q[%{flags} -o "%{outfile}" %{objs} %{flags_before_libraries} %{libs} %{flags_after_libraries}]
     end
 
     def all_flags(_library_paths=[], _flags=[])
       library_path_flags = [library_paths, _library_paths].flatten.map do |f|
-        if MRUBY_BUILD_HOST_IS_CYGWIN
-          option_library_path % cygwin_filename(f)
-        else
-          option_library_path % filename(f)
-        end
+        option_library_path % filename(f)
       end
       [flags, library_path_flags, _flags].flatten.join(' ')
     end
@@ -197,23 +195,15 @@ module MRuby
     end
 
     def run(outfile, objfiles, _libraries=[], _library_paths=[], _flags=[], _flags_before_libraries=[], _flags_after_libraries=[])
-      FileUtils.mkdir_p File.dirname(outfile)
+      mkdir_p File.dirname(outfile)
       library_flags = [libraries, _libraries].flatten.map { |d| option_library % d }
 
       _pp "LD", outfile.relative_path
-      if MRUBY_BUILD_HOST_IS_CYGWIN
-        _run link_options, { :flags => all_flags(_library_paths, _flags),
-                             :outfile => cygwin_filename(outfile) , :objs => cygwin_filename(objfiles).join(' '),
-                             :flags_before_libraries => [flags_before_libraries, _flags_before_libraries].flatten.join(' '),
-                             :flags_after_libraries => [flags_after_libraries, _flags_after_libraries].flatten.join(' '),
-                             :libs => library_flags.join(' ') }
-      else
-        _run link_options, { :flags => all_flags(_library_paths, _flags),
-                             :outfile => filename(outfile) , :objs => filename(objfiles).join(' '),
-                             :flags_before_libraries => [flags_before_libraries, _flags_before_libraries].flatten.join(' '),
-                             :flags_after_libraries => [flags_after_libraries, _flags_after_libraries].flatten.join(' '),
-                             :libs => library_flags.join(' ') }
-      end
+      _run link_options, { :flags => all_flags(_library_paths, _flags),
+                            :outfile => filename(outfile) , :objs => filename(objfiles).map{|f| %Q["#{f}"]}.join(' '),
+                            :flags_before_libraries => [flags_before_libraries, _flags_before_libraries].flatten.join(' '),
+                            :flags_after_libraries => [flags_after_libraries, _flags_after_libraries].flatten.join(' '),
+                            :libs => library_flags.join(' ') }
     end
   end
 
@@ -223,17 +213,13 @@ module MRuby
     def initialize(build)
       super
       @command = ENV['AR'] || 'ar'
-      @archive_options = 'rs %{outfile} %{objs}'
+      @archive_options = 'rs "%{outfile}" %{objs}'
     end
 
     def run(outfile, objfiles)
-      FileUtils.mkdir_p File.dirname(outfile)
+      mkdir_p File.dirname(outfile)
       _pp "AR", outfile.relative_path
-      if MRUBY_BUILD_HOST_IS_CYGWIN
-        _run archive_options, { :outfile => cygwin_filename(outfile), :objs => cygwin_filename(objfiles).join(' ') }
-      else
-        _run archive_options, { :outfile => filename(outfile), :objs => filename(objfiles).join(' ') }
-      end
+      _run archive_options, { :outfile => filename(outfile), :objs => filename(objfiles).map{|f| %Q["#{f}"]}.join(' ') }
     end
   end
 
@@ -243,11 +229,11 @@ module MRuby
     def initialize(build)
       super
       @command = 'bison'
-      @compile_options = '-o %{outfile} %{infile}'
+      @compile_options = %q[-o "%{outfile}" "%{infile}"]
     end
 
     def run(outfile, infile)
-      FileUtils.mkdir_p File.dirname(outfile)
+      mkdir_p File.dirname(outfile)
       _pp "YACC", infile.relative_path, outfile.relative_path
       _run compile_options, { :outfile => filename(outfile) , :infile => filename(infile) }
     end
@@ -259,11 +245,11 @@ module MRuby
     def initialize(build)
       super
       @command = 'gperf'
-      @compile_options = '-L ANSI-C -C -p -j1 -i 1 -g -o -t -N mrb_reserved_word -k"1,3,$" %{infile} > %{outfile}'
+      @compile_options = %q[-L ANSI-C -C -p -j1 -i 1 -g -o -t -N mrb_reserved_word -k"1,3,$" "%{infile}" > "%{outfile}"]
     end
 
     def run(outfile, infile)
-      FileUtils.mkdir_p File.dirname(outfile)
+      mkdir_p File.dirname(outfile)
       _pp "GPERF", infile.relative_path, outfile.relative_path
       _run compile_options, { :outfile => filename(outfile) , :infile => filename(infile) }
     end
@@ -271,44 +257,50 @@ module MRuby
 
   class Command::Git < Command
     attr_accessor :flags
-    attr_accessor :clone_options, :pull_options, :checkout_options, :reset_options
+    attr_accessor :clone_options, :pull_options, :checkout_options, :checkout_detach_options, :reset_options
 
     def initialize(build)
       super
       @command = 'git'
       @flags = %w[]
       @clone_options = "clone %{flags} %{url} %{dir}"
-      @pull_options = "--git-dir '%{repo_dir}/.git' --work-tree '%{repo_dir}' pull"
-      @checkout_options = "--git-dir '%{repo_dir}/.git' --work-tree '%{repo_dir}' checkout %{checksum_hash}"
-      @reset_options = "--git-dir '%{repo_dir}/.git' --work-tree '%{repo_dir}' reset %{checksum_hash}"
+      @pull_options = "--git-dir %{repo_dir}/.git --work-tree %{repo_dir} pull"
+      @checkout_options = "--git-dir %{repo_dir}/.git --work-tree %{repo_dir} checkout %{checksum_hash}"
+      @checkout_detach_options = "--git-dir %{repo_dir}/.git --work-tree %{repo_dir} checkout --detach %{checksum_hash}"
+      @reset_options = "--git-dir %{repo_dir}/.git --work-tree %{repo_dir} reset %{checksum_hash}"
     end
 
     def run_clone(dir, url, _flags = [])
       _pp "GIT", url, dir.relative_path
-      _run clone_options, { :flags => [flags, _flags].flatten.join(' '), :url => url, :dir => filename(dir) }
+      _run clone_options, { :flags => [flags, _flags].flatten.join(' '), :url => shellquote(url), :dir => shellquote(filename(dir)) }
     end
 
     def run_pull(dir, url)
       _pp "GIT PULL", url, dir.relative_path
-      _run pull_options, { :repo_dir => dir }
+      _run pull_options, { :repo_dir => shellquote(dir) }
     end
 
     def run_checkout(dir, checksum_hash)
-      _pp "GIT CHECKOUT", checksum_hash
-      _run checkout_options, { :checksum_hash => checksum_hash, :repo_dir => dir }
+      _pp "GIT CHECKOUT", dir, checksum_hash
+      _run checkout_options, { :checksum_hash => checksum_hash, :repo_dir => shellquote(dir) }
+    end
+
+    def run_checkout_detach(dir, checksum_hash)
+      _pp "GIT CHECKOUT DETACH", dir, checksum_hash
+      _run checkout_detach_options, { :checksum_hash => checksum_hash, :repo_dir => shellquote(dir) }
     end
 
     def run_reset_hard(dir, checksum_hash)
-      _pp "GIT RESET", checksum_hash
-      _run reset_options, { :checksum_hash => checksum_hash, :repo_dir => dir }
+      _pp "GIT RESET", dir, checksum_hash
+      _run reset_options, { :checksum_hash => checksum_hash, :repo_dir => shellquote(dir) }
     end
 
     def commit_hash(dir)
-      `#{@command} --git-dir '#{dir}/.git' --work-tree '#{dir}' rev-parse --verify HEAD`.strip
+      `#{@command} --git-dir #{shellquote(dir +'/.git')} --work-tree #{shellquote(dir)} rev-parse --verify HEAD`.strip
     end
 
     def current_branch(dir)
-      `#{@command} --git-dir '#{dir}/.git' --work-tree '#{dir}' rev-parse --abbrev-ref HEAD`.strip
+      `#{@command} --git-dir #{shellquote(dir + '/.git')} --work-tree #{shellquote(dir)} rev-parse --abbrev-ref HEAD`.strip
     end
   end
 
@@ -321,13 +313,15 @@ module MRuby
       @compile_options = "-B%{funcname} -o-"
     end
 
-    def run(out, infiles, funcname)
+    def run(out, infiles, funcname, cdump = true)
       @command ||= @build.mrbcfile
       infiles = [infiles].flatten
       infiles.each do |f|
         _pp "MRBC", f.relative_path, nil, :indent => 2
       end
-      IO.popen("#{filename @command} #{@compile_options % {:funcname => funcname}} #{filename(infiles).join(' ')}", 'r+') do |io|
+      cmd = %Q["#{filename @command}" #{cdump ? "-S" : ""} #{@compile_options % {:funcname => funcname}} #{filename(infiles).map{|f| %Q["#{f}"]}.join(' ')}]
+      puts cmd if Rake.verbose
+      IO.popen(cmd, 'r+') do |io|
         out.puts io.read
       end
       # if mrbc execution fail, drop the file

lib/mruby/build/load_gems.rb

@@ -13,13 +13,12 @@ module MRuby
     end
 
     def gem(gemdir, &block)
-      caller_dir = File.expand_path(File.dirname(/^(.*?):\d/.match(caller.first).to_a[1]))
-
       if gemdir.is_a?(Hash)
         gemdir = load_special_path_gem(gemdir)
       elsif GemBox.path && gemdir.is_a?(String)
         gemdir = File.expand_path(gemdir, File.dirname(GemBox.path))
       else
+        caller_dir = File.expand_path(File.dirname(caller(1,1)[0][/^(.*?):\d/,1]))
         gemdir = File.expand_path(gemdir, caller_dir)
       end
 
@@ -29,18 +28,19 @@ module MRuby
       Gem.current = nil
       load gemrake
       return nil unless Gem.current
+      current = Gem.current
 
-      Gem.current.dir = gemdir
-      Gem.current.build = self.is_a?(MRuby::Build) ? self : MRuby::Build.current
-      Gem.current.build_config_initializer = block
-      gems << Gem.current
+      current.dir = gemdir
+      current.build = self.is_a?(MRuby::Build) ? self : MRuby::Build.current
+      current.build_config_initializer = block
+      gems << current
 
       cxx_srcs = ['src', 'test', 'tools'].map do |subdir|
-        Dir.glob("#{Gem.current.dir}/#{subdir}/*.{cpp,cxx,cc}")
+        Dir.glob("#{current.dir}/#{subdir}/*.{cpp,cxx,cc}")
       end.flatten
       enable_cxx_exception unless cxx_srcs.empty?
 
-      Gem.current
+      current
     end
 
     def load_special_path_gem(params)
@@ -58,7 +58,7 @@ module MRuby
         if File.exist? mgem_list_dir
           git.run_pull mgem_list_dir, mgem_list_url if $pull_gems
         else
-          FileUtils.mkdir_p mgem_list_dir
+          mkdir_p mgem_list_dir
           git.run_clone mgem_list_dir, mgem_list_url, "--depth 1"
         end
 
@@ -87,28 +87,27 @@ module MRuby
 
         if File.exist?(gemdir)
           if $pull_gems
-            git.run_pull gemdir, url
             # Jump to the top of the branch
-            git.run_checkout(gemdir, branch)
-            git.run_reset_hard gemdir, "origin/#{branch}"
+            git.run_checkout gemdir, branch
+            git.run_pull gemdir, url
           elsif params[:checksum_hash]
-            git.run_reset_hard(gemdir, params[:checksum_hash])
+            git.run_checkout_detach gemdir, params[:checksum_hash]
           elsif lock
-            git.run_reset_hard(gemdir, lock['commit'])
+            git.run_checkout_detach gemdir, lock['commit']
           end
         else
           options = [params[:options]] || []
           options << "--recursive"
           options << "--branch \"#{branch}\""
           options << "--depth 1" unless params[:checksum_hash]
-          FileUtils.mkdir_p "#{gem_clone_dir}"
+          mkdir_p "#{gem_clone_dir}"
           git.run_clone gemdir, url, options
 
           # Jump to the specified commit
           if params[:checksum_hash]
-            git.run_reset_hard gemdir, params[:checksum_hash]
+            git.run_checkout_detach gemdir, params[:checksum_hash]
           elsif lock
-            git.run_reset_hard gemdir, lock['commit']
+            git.run_checkout_detach gemdir, lock['commit']
           end
         end
 

lib/mruby/gem.rb

@@ -47,12 +47,14 @@ module MRuby
         @version = "0.0.0"
         @mrblib_dir = "mrblib"
         @objs_dir = "src"
+        @dependencies = []
+        @conflicts = []
         MRuby::Gem.current = self
       end
 
       def setup
         return if defined?(@linker)  # return if already set up
-
+        
         MRuby::Gem.current = self
         MRuby::Build::COMMANDS.each do |command|
           instance_variable_set("@#{command}", @build.send(command).clone)
@@ -75,7 +77,6 @@ module MRuby
         @bins = []
 
         @requirements = []
-        @dependencies, @conflicts = [], []
         @export_include_paths = []
         @export_include_paths << "#{dir}/include" if File.directory? "#{dir}/include"
 
@@ -106,6 +107,15 @@ module MRuby
         define_gem_init_builder if @generate_functions
       end
 
+      def for_windows?
+        if build.kind_of?(MRuby::CrossBuild)
+          return %w(x86_64-w64-mingw32 i686-w64-mingw32).include?(build.host_target)
+        elsif build.kind_of?(MRuby::Build)
+          return ('A'..'Z').to_a.any? { |vol| Dir.exist?("#{vol}:") }
+        end
+        return false
+      end
+
       def add_dependency(name, *requirements)
         default_gem = requirements.last.kind_of?(Hash) ? requirements.pop : nil
         requirements = ['>= 0.0.0'] if requirements.empty?
@@ -157,7 +167,7 @@ module MRuby
       def define_gem_init_builder
         file objfile("#{build_dir}/gem_init") => [ "#{build_dir}/gem_init.c", File.join(dir, "mrbgem.rake") ]
         file "#{build_dir}/gem_init.c" => [build.mrbcfile, __FILE__] + [rbfiles].flatten do |t|
-          FileUtils.mkdir_p build_dir
+          mkdir_p build_dir
           generate_gem_init("#{build_dir}/gem_init.c")
         end
       end
@@ -165,20 +175,24 @@ module MRuby
       def generate_gem_init(fname)
         open(fname, 'w') do |f|
           print_gem_init_header f
-          build.mrbc.run f, rbfiles, "gem_mrblib_irep_#{funcname}" unless rbfiles.empty?
+          build.mrbc.run f, rbfiles, "gem_mrblib_#{funcname}_proc" unless rbfiles.empty?
           f.puts %Q[void mrb_#{funcname}_gem_init(mrb_state *mrb);]
           f.puts %Q[void mrb_#{funcname}_gem_final(mrb_state *mrb);]
           f.puts %Q[]
           f.puts %Q[void GENERATED_TMP_mrb_#{funcname}_gem_init(mrb_state *mrb) {]
           f.puts %Q[  int ai = mrb_gc_arena_save(mrb);]
+          f.puts %Q[  struct REnv *e;] unless rbfiles.empty?
           f.puts %Q[  mrb_#{funcname}_gem_init(mrb);] if objs != [objfile("#{build_dir}/gem_init")]
           unless rbfiles.empty?
-            f.puts %Q[  mrb_load_irep(mrb, gem_mrblib_irep_#{funcname});]
+            f.puts %Q[  mrb_load_proc(mrb, gem_mrblib_#{funcname}_proc);]
             f.puts %Q[  if (mrb->exc) {]
             f.puts %Q[    mrb_print_error(mrb);]
             f.puts %Q[    mrb_close(mrb);]
             f.puts %Q[    exit(EXIT_FAILURE);]
             f.puts %Q[  }]
+            f.puts %Q[  e = mrb->c->cibase->env;]
+            f.puts %Q[  mrb->c->cibase->env = NULL;]
+            f.puts %Q[  mrb_env_unshare(mrb, e);]
           end
           f.puts %Q[  mrb_gc_arena_restore(mrb, ai);]
           f.puts %Q[}]
@@ -202,9 +216,13 @@ module MRuby
 
       def print_gem_init_header(f)
         print_gem_comment(f)
-        f.puts %Q[#include <stdlib.h>] unless rbfiles.empty?
-        f.puts %Q[#include <mruby.h>]
-        f.puts %Q[#include <mruby/irep.h>] unless rbfiles.empty?
+        unless rbfiles.empty?
+          f.puts %Q[#include <stdlib.h>]
+          f.puts %Q[#include <mruby.h>]
+          f.puts %Q[#include <mruby/proc.h>]
+        else
+          f.puts %Q[#include <mruby.h>]
+        end
       end
 
       def print_gem_test_header(f)
@@ -212,7 +230,7 @@ module MRuby
         f.puts %Q[#include <stdio.h>]
         f.puts %Q[#include <stdlib.h>]
         f.puts %Q[#include <mruby.h>]
-        f.puts %Q[#include <mruby/irep.h>]
+        f.puts %Q[#include <mruby/proc.h>]
         f.puts %Q[#include <mruby/variable.h>]
         f.puts %Q[#include <mruby/hash.h>] unless test_args.empty?
       end

lib/mruby/lockfile.rb

@@ -26,7 +26,7 @@ module MRuby
       end
 
       def instance
-        @instance ||= new("#{MRUBY_CONFIG}.lock")
+        @instance ||= new("#{MRUBY_ROOT}/build/#{MRUBY_TARGET}.lock")
       end
     end
 
@@ -39,7 +39,7 @@ module MRuby
     end
 
     def write
-      locks = {"mruby_version" => mruby}
+      locks = {"mruby" => mruby}
       locks["builds"] = @builds if @builds
       File.write(@filename, YAML.dump(locks))
     end
@@ -54,6 +54,14 @@ module MRuby
                   end
     end
 
+    def shellquote(s)
+      if ENV['OS'] == 'Windows_NT'
+        "\"#{s}\""
+      else
+        "'#{s}'"
+      end
+    end
+
     def mruby
       mruby = {
         'version' => MRuby::Source::MRUBY_VERSION,
@@ -62,7 +70,7 @@ module MRuby
 
       git_dir = "#{MRUBY_ROOT}/.git"
       if File.directory?(git_dir)
-        mruby['git_commit'] = `git --git-dir '#{git_dir}' --work-tree '#{MRUBY_ROOT}' rev-parse --verify HEAD`.strip
+        mruby['git_commit'] = `git --git-dir #{shellquote(git_dir)} --work-tree #{shellquote(MRUBY_ROOT)} rev-parse --verify HEAD`.strip
       end
 
       mruby

lib/mruby/source.rb

@@ -6,7 +6,9 @@ module MRuby
     ROOT = Pathname.new(File.expand_path('../../../',__FILE__))
 
     # Reads a constant defined at version.h
-    MRUBY_READ_VERSION_CONSTANT = Proc.new { |name| ROOT.join('include','mruby','version.h').read.match(/^#define #{name} +"?([\w\. ]+)"?$/)[1] }
+    MRUBY_READ_VERSION_CONSTANT = Proc.new do |name|
+      ROOT.join('include','mruby','version.h').read.match(/^#define #{name} +"?([\w\. ]+)"?\r?$/)[1]
+    end
 
     MRUBY_RUBY_VERSION = MRUBY_READ_VERSION_CONSTANT['MRUBY_RUBY_VERSION']
     MRUBY_RUBY_ENGINE = MRUBY_READ_VERSION_CONSTANT['MRUBY_RUBY_ENGINE']

minirake

@@ -1,621 +1,2 @@
-#!/usr/bin/env ruby
-
-# Original is https://github.com/jimweirich/rake/
-# Copyright (c) 2003 Jim Weirich
-# License: MIT-LICENSE
-
-require 'getoptlong'
-require 'fileutils'
-
-$rake_fiber_table = {}
-$rake_jobs = 1
-$rake_failed = []
-
-class String
-  def ext(newext='')
-    return self.dup if ['.', '..'].include? self
-    if newext != ''
-      newext = (newext =~ /^\./) ? newext : ("." + newext)
-    end
-    self.chomp(File.extname(self)) << newext
-  end
-
-  def pathmap(spec=nil, &block)
-    return self if spec.nil?
-    result = ''
-    spec.scan(/%\{[^}]*\}-?\d*[sdpfnxX%]|%-?\d+d|%.|[^%]+/) do |frag|
-      case frag
-      when '%f'
-        result << File.basename(self)
-      when '%n'
-        result << File.basename(self).ext
-      when '%d'
-        result << File.dirname(self)
-      when '%x'
-        result << File.extname(self)
-      when '%X'
-        result << self.ext
-      when '%p'
-        result << self
-      when '%s'
-        result << (File::ALT_SEPARATOR || File::SEPARATOR)
-      when '%-'
-        # do nothing
-      when '%%'
-        result << "%"
-      when /%(-?\d+)d/
-        result << pathmap_partial($1.to_i)
-      when /^%\{([^}]*)\}(\d*[dpfnxX])/
-        patterns, operator = $1, $2
-        result << pathmap('%' + operator).pathmap_replace(patterns, &block)
-      when /^%/
-        fail ArgumentError, "Unknown pathmap specifier #{frag} in '#{spec}'"
-      else
-        result << frag
-      end
-    end
-    result
-  end
-end
-
-module MiniRake
-  class Task
-    TASKS = Hash.new
-    RULES = Array.new
-
-    # List of prerequisites for a task.
-    attr_reader :prerequisites
-
-    # Source dependency for rule synthesized tasks.  Nil if task was not
-    # sythesized from a rule.
-    attr_accessor :source
-
-    # Create a task named +task_name+ with no actions or prerequisites..
-    # use +enhance+ to add actions and prerequisites.
-    def initialize(task_name)
-      @name = task_name
-      @prerequisites = []
-      @actions = []
-    end
-
-    # Enhance a task with prerequisites or actions.  Returns self.
-    def enhance(deps=nil, &block)
-      @prerequisites |= deps if deps
-      @actions << block if block_given?
-      self
-    end
-
-    # Name of the task.
-    def name
-      @name.to_s
-    end
-
-    def done?; @done end
-    def running?; @running end
-
-    # Invoke the task if it is needed. Prerequisites are invoked first.
-    def invoke
-      puts "Invoke #{name} (already=[#{@already_invoked}], needed=[#{needed?}])" if $trace
-      return if @already_invoked
-      prerequisites = @prerequisites.collect{ |n| n.is_a?(Proc) ? n.call(name) : n }.flatten
-      prerequisites.each do |n|
-        t = Task[n]
-        unless t.done?
-          return prerequisites.select{|v| v = Task[v]; v && (!v.done? || !v.running?) }
-        end
-      end
-
-      @already_invoked = true
-
-      if needed?
-        @running = true
-        if $rake_root_fiber
-          return Fiber.new do
-            self.execute
-            $rake_root_fiber.transfer
-          end
-        else
-          self.execute
-        end
-      end
-
-      @done = true
-    end
-
-    # Execute the actions associated with this task.
-    def execute
-      puts "Execute #{name}" if $trace
-      self.class.enhance_with_matching_rule(name) if @actions.empty?
-      unless $dryrun
-        @actions.each { |act| act.call(self) }
-      end
-      @done = true
-      @running = false
-    end
-
-    # Is this task needed?
-    def needed?
-      true
-    end
-
-    # Timestamp for this task.  Basic tasks return the current time for
-    # their time stamp.  Other tasks can be more sophisticated.
-    def timestamp
-      Time.now
-    end
-
-    # Class Methods ----------------------------------------------------
-
-    class << self
-
-      # Clear the task list.  This cause rake to immediately forget all
-      # the tasks that have been assigned.  (Normally used in the unit
-      # tests.)
-      def clear
-        TASKS.clear
-        RULES.clear
-      end
-
-      # List of all defined tasks.
-      def tasks
-        TASKS.keys.sort.collect { |tn| Task[tn] }
-      end
-
-      # Return a task with the given name.  If the task is not currently
-      # known, try to synthesize one from the defined rules.  If no
-      # rules are found, but an existing file matches the task name,
-      # assume it is a file task with no dependencies or actions.
-      def [](task_name)
-        task_name = task_name.to_s
-        if task = TASKS[task_name]
-          return task
-        end
-        if task = enhance_with_matching_rule(task_name)
-          return task
-        end
-        if File.exist?(task_name)
-          return FileTask.define_task(task_name)
-        end
-        fail "Don't know how to rake #{task_name}"
-      end
-
-      # Define a task given +args+ and an option block.  If a rule with
-      # the given name already exists, the prerequisites and actions are
-      # added to the existing task.
-      def define_task(args, &block)
-        task_name, deps = resolve_args(args)
-        lookup(task_name).enhance([deps].flatten, &block)
-      end
-
-      # Define a rule for synthesizing tasks.
-      def create_rule(args, &block)
-        pattern, deps = resolve_args(args)
-        pattern = Regexp.new(Regexp.quote(pattern) + '$') if String === pattern
-        RULES << [pattern, deps, block]
-      end
-
-
-      # Lookup a task.  Return an existing task if found, otherwise
-      # create a task of the current type.
-      def lookup(task_name)
-        name = task_name.to_s
-        TASKS[name] ||= self.new(name)
-      end
-
-      # If a rule can be found that matches the task name, enhance the
-      # task with the prerequisites and actions from the rule.  Set the
-      # source attribute of the task appropriately for the rule.  Return
-      # the enhanced task or nil of no rule was found.
-      def enhance_with_matching_rule(task_name, level=0)
-        fail "Rule Recursion Too Deep: #{task_name}" if level >= 16
-        RULES.each do |pattern, extensions, block|
-          next unless  pattern && pattern.match(task_name)
-          sources = extensions.flat_map do |ext|
-            case ext
-            when /%/
-              task_name.pathmap(ext)
-            when %r{/}
-              ext
-            when /^\./
-              source = task_name.sub(pattern, ext)
-              source == ext ? task_name.ext(ext) : source
-            when String
-              ext
-            when Proc, Method
-              ext.arity == 1 ? ext.call(task_name) : ext.call
-            else
-              fail "Don't know how to handle rule dependent: #{ext.inspect}"
-            end
-          end
-          prereqs = sources.map do |source|
-            if File.exist?(source) || TASKS[source]
-              source
-            elsif parent = enhance_with_matching_rule(source, level + 1)
-              parent.name
-            else
-              break nil
-            end
-          end
-          if prereqs
-            task = FileTask.define_task(task_name => prereqs, &block)
-            task.source = prereqs.first
-            return task
-          end
-        end
-        nil
-      end
-
-      private
-
-      # Resolve the arguments for a task/rule.
-      def resolve_args(args)
-        case args
-        when Hash
-          fail "Too Many Task Names: #{args.keys.join(' ')}" if args.size > 1
-          fail "No Task Name Given" if args.size < 1
-          task_name = args.keys[0]
-          deps = args[task_name]
-          deps = [deps] if (String===deps) || (Regexp===deps) || (Proc===deps)
-        else
-          task_name = args
-          deps = []
-        end
-        [task_name, deps]
-      end
-    end
-  end
-
-
-  ######################################################################
-  class FileTask < Task
-    # Is this file task needed?  Yes if it doesn't exist, or if its time
-    # stamp is out of date.
-    def needed?
-      return true unless File.exist?(name)
-      prerequisites = @prerequisites.collect{ |n| n.is_a?(Proc) ? n.call(name) : n }.flatten
-      latest_prereq = prerequisites.collect{|n| Task[n].timestamp}.max
-      return false if latest_prereq.nil?
-      timestamp < latest_prereq
-    end
-
-    # Time stamp for file task.
-    def timestamp
-      return Time.at(0) unless File.exist?(name)
-      stat = File::stat(name.to_s)
-      stat.directory? ? Time.at(0) : stat.mtime
-    end
-  end
-
-  module DSL
-    # Declare a basic task.
-    def task(args, &block)
-      MiniRake::Task.define_task(args, &block)
-    end
-
-    # Declare a file task.
-    def file(args, &block)
-      MiniRake::FileTask.define_task(args, &block)
-    end
-
-    # Declare a set of files tasks to create the given directories on
-    # demand.
-    def directory(args, &block)
-      MiniRake::FileTask.define_task(args) do |t|
-        block.call(t) unless block.nil?
-        dir = args.is_a?(Hash) ? args.keys.first : args
-        (dir.split(File::SEPARATOR) + ['']).inject do |acc, part|
-          (acc + File::SEPARATOR).tap do |d|
-            Dir.mkdir(d) unless File.exists? d
-          end + part
-        end
-      end
-    end
-
-    # Declare a rule for auto-tasks.
-    def rule(args, &block)
-      MiniRake::Task.create_rule(args, &block)
-    end
-
-    # Write a message to standard out if $verbose is enabled.
-    def log(msg)
-      print "  " if $trace && $verbose
-      puts msg if $verbose
-    end
-
-    # Run the system command +cmd+.
-    def sh(cmd)
-      puts cmd if $verbose
-
-      if !$rake_root_fiber || Fiber.current == $rake_root_fiber
-        system(cmd) or fail "Command Failed: [#{cmd}]"
-        return
-      end
-
-      pid = Process.spawn(cmd)
-      $rake_fiber_table[pid] = {
-        fiber: Fiber.current,
-        command: cmd,
-        process_waiter: Process.detach(pid)
-      }
-      $rake_root_fiber.transfer
-    end
-
-    def desc(text)
-    end
-  end
-end
-
-Rake = MiniRake
-extend MiniRake::DSL
-
-
-######################################################################
-# Task Definition Functions ...
-
-######################################################################
-# Rake main application object.  When invoking +rake+ from the command
-# line, a RakeApp object is created and run.
-#
-class RakeApp
-  RAKEFILES = ['rakefile', 'Rakefile']
-
-  OPTIONS = [
-    ['--dry-run',  '-n', GetoptLong::NO_ARGUMENT,
-      "Do a dry run without executing actions."],
-    ['--help',     '-H', GetoptLong::NO_ARGUMENT,
-      "Display this help message."],
-    ['--libdir',   '-I', GetoptLong::REQUIRED_ARGUMENT,
-      "Include LIBDIR in the search path for required modules."],
-    ['--nosearch', '-N', GetoptLong::NO_ARGUMENT,
-      "Do not search parent directories for the Rakefile."],
-    ['--quiet',    '-q', GetoptLong::NO_ARGUMENT,
-      "Do not log messages to standard output (default)."],
-    ['--rakefile', '-f', GetoptLong::REQUIRED_ARGUMENT,
-      "Use FILE as the rakefile."],
-    ['--require',  '-r', GetoptLong::REQUIRED_ARGUMENT,
-      "Require MODULE before executing rakefile."],
-    ['--tasks',    '-T', GetoptLong::NO_ARGUMENT,
-      "Display the tasks and dependencies, then exit."],
-    ['--pull-gems','-p', GetoptLong::NO_ARGUMENT,
-      "Pull all git mrbgems."],
-    ['--trace',    '-t', GetoptLong::NO_ARGUMENT,
-      "Turn on invoke/execute tracing."],
-    ['--usage',    '-h', GetoptLong::NO_ARGUMENT,
-      "Display usage."],
-    ['--verbose',  '-v', GetoptLong::NO_ARGUMENT,
-      "Log message to standard output."],
-    ['--directory', '-C', GetoptLong::REQUIRED_ARGUMENT,
-      "Change executing directory of rakefiles."],
-    ['--jobs', '-j', GetoptLong::REQUIRED_ARGUMENT,
-      'Execute rake with parallel jobs.']
-  ]
-
-  # Create a RakeApp object.
-  def initialize
-    @rakefile = nil
-    @nosearch = false
-  end
-
-  # True if one of the files in RAKEFILES is in the current directory.
-  # If a match is found, it is copied into @rakefile.
-  def have_rakefile
-    RAKEFILES.each do |fn|
-      if File.exist?(fn)
-        @rakefile = fn
-        return true
-      end
-    end
-    return false
-  end
-
-  # Display the program usage line.
-  def usage
-      puts "rake [-f rakefile] {options} targets..."
-  end
-
-  # Display the rake command line help.
-  def help
-    usage
-    puts
-    puts "Options are ..."
-    puts
-    OPTIONS.sort.each do |long, short, mode, desc|
-      if mode == GetoptLong::REQUIRED_ARGUMENT
-        if desc =~ /\b([A-Z]{2,})\b/
-          long = long + "=#{$1}"
-        end
-      end
-      printf "  %-20s (%s)\n", long, short
-      printf "      %s\n", desc
-    end
-  end
-
-  # Display the tasks and dependencies.
-  def display_tasks
-    MiniRake::Task.tasks.each do |t|
-      puts "#{t.class} #{t.name}"
-      t.prerequisites.each { |pre| puts "    #{pre}" }
-    end
-  end
-
-  # Return a list of the command line options supported by the
-  # program.
-  def command_line_options
-    OPTIONS.collect { |lst| lst[0..-2] }
-  end
-
-  # Do the option defined by +opt+ and +value+.
-  def do_option(opt, value)
-    case opt
-    when '--dry-run'
-      $dryrun = true
-      $trace = true
-    when '--help'
-      help
-      exit
-    when '--libdir'
-      $:.push(value)
-    when '--nosearch'
-      @nosearch = true
-    when '--quiet'
-      $verbose = false
-    when '--rakefile'
-      RAKEFILES.clear
-      RAKEFILES << value
-    when '--require'
-      require value
-    when '--tasks'
-      $show_tasks = true
-    when '--pull-gems'
-      $pull_gems = true
-    when '--trace'
-      $trace = true
-    when '--usage'
-      usage
-      exit
-    when '--verbose'
-      $verbose = true
-    when '--version'
-      puts "rake, version #{RAKEVERSION}"
-      exit
-    when '--directory'
-      Dir.chdir value
-    when '--jobs'
-      $rake_jobs = [value.to_i, 1].max
-    else
-      fail "Unknown option: #{opt}"
-    end
-  end
-
-  # Read and handle the command line options.
-  def handle_options
-    $verbose = false
-    $pull_gems = false
-    opts = GetoptLong.new(*command_line_options)
-    opts.each { |opt, value| do_option(opt, value) }
-  end
-
-  # Run the +rake+ application.
-  def run
-    handle_options
-
-    unless $rake_root_fiber
-      require 'fiber'
-      $rake_root_fiber = Fiber.current
-    end
-
-    begin
-      here = Dir.pwd
-      while ! have_rakefile
-        Dir.chdir("..")
-        if Dir.pwd == here || @nosearch
-          fail "No Rakefile found (looking for: #{RAKEFILES.join(', ')})"
-        end
-        here = Dir.pwd
-      end
-      root_tasks = []
-      ARGV.each do |task_name|
-        if /^(\w+)=(.*)/.match(task_name)
-          ENV[$1] = $2
-        else
-          root_tasks << task_name
-        end
-      end
-      puts "(in #{Dir.pwd})"
-      $rakefile = @rakefile
-      load @rakefile
-      if $show_tasks
-        display_tasks
-      else
-        root_tasks.push("default") if root_tasks.empty?
-        # revese tasks for popping
-        root_tasks.reverse!
-
-        tasks = []
-        until root_tasks.empty?
-          root_name = root_tasks.pop
-          tasks << root_name
-          until tasks.empty?
-            task_name = tasks.pop
-            t = MiniRake::Task[task_name]
-            f = t.invoke
-
-            # append additional tasks to task queue
-            if f.kind_of?(Array)
-              tasks.push(*f)
-              tasks.uniq!
-            end
-
-            unless f.kind_of? Fiber
-              tasks.insert 0, task_name unless t.done?
-              if root_name == task_name
-                wait_process
-              end
-              next
-            end
-
-            wait_process while $rake_fiber_table.size >= $rake_jobs
-
-            f.transfer
-          end
-        end
-
-        wait_process until $rake_fiber_table.empty?
-      end
-    rescue Exception => e
-      begin
-        $rake_failed << e
-        wait_process until $rake_fiber_table.empty?
-      rescue Exception => next_e
-        e = next_e
-        retry
-      end
-    end
-
-    return if $rake_failed.empty?
-
-    puts "rake aborted!"
-    $rake_failed.each do |ex|
-      puts ex.message
-      if $trace || $verbose
-        puts ex.backtrace.join("\n")
-      else
-        puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
-      end
-    end
-    exit 1
-  end
-
-  def wait_process(count = 0)
-    dur = [0.0001 * (10 ** count), 1].min
-    sleep dur
-
-    exited = []
-    $rake_fiber_table.each do |pid, v|
-      exited << pid unless v[:process_waiter].alive?
-    end
-
-    exited.each do |pid|
-      ent = $rake_fiber_table.delete pid
-      st = ent[:process_waiter].value
-
-      # ignore process that isn't created by `sh` method
-      return if ent.nil?
-
-      if st.exitstatus != 0
-        raise "Command Failed: [#{ent[:command]}]"
-      end
-
-      fail 'task scheduling bug!' if $rake_fiber_table.size >= $rake_jobs
-
-      ent[:fiber].transfer
-    end
-
-    wait_process(count + 1) if !$rake_fiber_table.empty? && exited.empty?
-  end
-
-end
-
-if __FILE__ == $0 then
-  RakeApp.new.run
-end
+#! /usr/bin/env ruby
+exec "rake", *ARGV

mrbgems/default.gembox

@@ -5,6 +5,9 @@ MRuby::GemBox.new do |conf|
   # Use standard IO/File class
   conf.gem :core => "mruby-io"
 
+  # Use standard IO/File class
+  conf.gem :core => "mruby-socket"
+
   # Use standard Array#pack, String#unpack methods
   conf.gem :core => "mruby-pack"
 
@@ -71,6 +74,10 @@ MRuby::GemBox.new do |conf|
   # Use toplevel object (main) methods extension
   conf.gem :core => "mruby-toplevel-ext"
 
+  # Use Rational/Complex numbers
+  conf.gem :core => "mruby-rational"
+  conf.gem :core => "mruby-complex"
+
   # Generate mirb command
   conf.gem :core => "mruby-bin-mirb"
 
@@ -80,6 +87,9 @@ MRuby::GemBox.new do |conf|
   # Generate mruby-strip command
   conf.gem :core => "mruby-bin-strip"
 
+  # Generate mruby-config command
+  conf.gem :core => "mruby-bin-config"
+
   # Use Kernel module extension
   conf.gem :core => "mruby-kernel-ext"
 
@@ -89,6 +99,9 @@ MRuby::GemBox.new do |conf|
   # Use Method/UnboundMethod class
   conf.gem :core => "mruby-method"
 
+  # Use eval()
+  conf.gem :core => "mruby-eval"
+
   # Use mruby-compiler to build other mrbgems
   conf.gem :core => "mruby-compiler"
 end

mrbgems/mruby-array-ext/mrblib/array.rb

@@ -686,37 +686,6 @@ class Array
     satisfied ? low : nil
   end
 
-  ##
-  #  call-seq:
-  #     ary.delete_if { |item| block }  -> ary
-  #     ary.delete_if                   -> Enumerator
-  #
-  #  Deletes every element of +self+ for which block evaluates to +true+.
-  #
-  #  The array is changed instantly every time the block is called, not after
-  #  the iteration is over.
-  #
-  #  See also Array#reject!
-  #
-  #  If no block is given, an Enumerator is returned instead.
-  #
-  #     scores = [ 97, 42, 75 ]
-  #     scores.delete_if {|score| score < 80 }   #=> [97]
-
-  def delete_if(&block)
-    return to_enum :delete_if unless block
-
-    idx = 0
-    while idx < self.size do
-      if block.call(self[idx])
-        self.delete_at(idx)
-      else
-        idx += 1
-      end
-    end
-    self
-  end
-
   ##
   #  call-seq:
   #     ary.keep_if { |item| block } -> ary

mrbgems/mruby-array-ext/src/array.c

@@ -28,9 +28,8 @@ static mrb_value
 mrb_ary_assoc(mrb_state *mrb, mrb_value ary)
 {
   mrb_int i;
-  mrb_value v, k;
-
-  mrb_get_args(mrb, "o", &k);
+  mrb_value v;
+  mrb_value k = mrb_get_arg1(mrb);
 
   for (i = 0; i < RARRAY_LEN(ary); ++i) {
     v = mrb_check_array_type(mrb, RARRAY_PTR(ary)[i]);
@@ -59,9 +58,8 @@ static mrb_value
 mrb_ary_rassoc(mrb_state *mrb, mrb_value ary)
 {
   mrb_int i;
-  mrb_value v, value;
-
-  mrb_get_args(mrb, "o", &value);
+  mrb_value v;
+  mrb_value value = mrb_get_arg1(mrb);
 
   for (i = 0; i < RARRAY_LEN(ary); ++i) {
     v = RARRAY_PTR(ary)[i];
@@ -140,9 +138,8 @@ mrb_ary_slice_bang(mrb_state *mrb, mrb_value self)
   mrb_ary_modify(mrb, a);
 
   if (mrb_get_argc(mrb) == 1) {
-    mrb_value index;
+    mrb_value index = mrb_get_arg1(mrb);
 
-    mrb_get_args(mrb, "o|i", &index, &len);
     switch (mrb_type(index)) {
     case MRB_TT_RANGE:
       if (mrb_range_beg_len(mrb, index, &i, &len, ARY_LEN(a), TRUE) == MRB_RANGE_OK) {
@@ -151,11 +148,11 @@ mrb_ary_slice_bang(mrb_state *mrb, mrb_value self)
       else {
         return mrb_nil_value();
       }
-    case MRB_TT_FIXNUM:
-      val = mrb_funcall(mrb, self, "delete_at", 1, index);
+    case MRB_TT_INTEGER:
+      val = mrb_funcall_id(mrb, self, MRB_SYM(delete_at), 1, index);
       return val;
     default:
-      val = mrb_funcall(mrb, self, "delete_at", 1, index);
+      val = mrb_funcall_id(mrb, self, MRB_SYM(delete_at), 1, index);
       return val;
     }
   }

mrbgems/mruby-array-ext/test/array.rb

@@ -195,12 +195,6 @@ assert("Array#reverse_each") do
     b << i
   end
   assert_equal [ "d", "c", "b", "a" ], b
-
-  if Object.const_defined?(:Enumerator)
-    assert_equal [ "d", "c", "b", "a" ], a.reverse_each.to_a
-  else
-    true
-  end
 end
 
 assert("Array#rotate") do
@@ -305,19 +299,6 @@ end
 #assert("Array#bsearch_index") do
 #end
 
-assert("Array#delete_if") do
-  a = [1, 2, 3, 4, 5]
-  assert_equal [1, 2, 3, 4, 5], a.delete_if { false }
-  assert_equal [1, 2, 3, 4, 5], a
-
-  a = [1, 2, 3, 4, 5]
-  assert_equal [], a.delete_if { true }
-  assert_equal [], a
-
-  a = [ 1, 2, 3, 4, 5 ]
-  assert_equal [1, 2, 3], a.delete_if { |val| val > 3 }
-end
-
 assert("Array#keep_if") do
   a = [1, 2, 3, 4, 5]
   assert_equal [1, 2, 3, 4, 5], a.keep_if { true }

mrbgems/mruby-bin-config/mrbgem.rake

@@ -5,19 +5,22 @@ unless MRuby::Build.current.kind_of?(MRuby::CrossBuild)
     spec.author  = 'mruby developers'
     spec.summary = "#{name} command"
 
+    mruby_config_dir = "#{build.build_dir}/bin"
     mruby_config = name + (ENV['OS'] == 'Windows_NT' ? '.bat' : '')
-    mruby_config_path = "#{build.build_dir}/bin/#{mruby_config}"
+    mruby_config_path = "#{mruby_config_dir}/#{mruby_config}"
     make_cfg = "#{build.build_dir}/lib/libmruby.flags.mak"
     tmplt_path = "#{__dir__}/#{mruby_config}"
     build.bins << mruby_config
 
-    file mruby_config_path => [make_cfg, tmplt_path] do |t|
+    directory mruby_config_dir
+
+    file mruby_config_path => [mruby_config_dir, make_cfg, tmplt_path] do |t|
       config = Hash[File.readlines(make_cfg).map!(&:chomp).map! {|l|
         l.gsub('\\"', '"').split(' = ', 2).map! {|s| s.sub(/^(?=.)/, 'echo ')}
       }]
       tmplt = File.read(tmplt_path)
       File.write(t.name, tmplt.gsub(/(#{Regexp.union(*config.keys)})\b/, config))
-      FileUtils.chmod(0755, t.name)
+      chmod(0755, t.name)
     end
   end
 end

mrbgems/mruby-bin-debugger/bintest/print.rb

@@ -1,9 +1,10 @@
 require 'open3'
 require 'tempfile'
+require 'strscan'
 
 class BinTest_MrubyBinDebugger
-  @debug1=false
-  @debug2=true
+#  @debug1=false
+#  @debug2=true
   def self.test(rubysource, testcase)
     script, bin = Tempfile.new(['test', '.rb']), Tempfile.new(['test', '.mrb'])
 
@@ -19,10 +20,20 @@ class BinTest_MrubyBinDebugger
 
     stdin_data = testcase.map{|t| t[:cmd]}.join("\n") << "\n"
 
+    prompt = /^\(#{Regexp.escape(script.path)}:\d+\) /
     ["bin/mrdb #{script.path}","bin/mrdb -b #{bin.path}"].each do |cmd|
       o, s = Open3.capture2(cmd, :stdin_data => stdin_data)
+      scanner = StringScanner.new(o)
+      scanner.skip_until(prompt)
+      testcase.each do |tc|
+        exp = tc[:exp]
+        if exp
+          act = scanner.scan_until(/\n/)
+          break unless assert_operator act, :start_with?, exp
+        end
+        scanner.skip_until(prompt)
+      end
 
-      exp_vals = testcase.map{|t| t.fetch(:exp, nil)}
 =begin
 if @debug1
   o.split("\n").each_with_index do |i,actual|
@@ -41,14 +52,6 @@ end
         assert_true actual.include?(exp) unless exp.nil?
       end
 =end
-      idx = 0
-      exp_vals.each do |exp|
-        next if exp.nil?
-        idx = o.index(exp, idx)
-        assert_false idx.nil?
-        break unless idx
-        idx += 1
-      end
     end
   end
 end
@@ -90,8 +93,8 @@ assert('mruby-bin-debugger(print) error') do
 
   # test case
   tc = []
-  tc << {:cmd=>"p (1+2",  :exp=>'$1 = SyntaxError'}
-  tc << {:cmd=>"p bar",   :exp=>'$2 = (eval):2: undefined method'}
+  tc << {:cmd=>"p (1+2",  :exp=>'$1 = line 1: syntax error'}
+  tc << {:cmd=>"p bar",   :exp=>'$2 = undefined method'}
 
   BinTest_MrubyBinDebugger.test(src, tc)
 end
@@ -513,7 +516,7 @@ SRC
   tc << {:cmd=>'p a+1',   :exp=>'$1 = 2'}
   tc << {:cmd=>'p 2-b',   :exp=>'$2 = -3'}
   tc << {:cmd=>'p c * 3', :exp=>'$3 = 24'}
-  tc << {:cmd=>'p a/b',   :exp=>'$4 = 0.2'}
+  tc << {:cmd=>'p a/b',   :exp=>'$4 = 0'}
   tc << {:cmd=>'p c%b',   :exp=>'$5 = 3'}
   tc << {:cmd=>'p 2**10', :exp=>'$6 = 1024'}
   tc << {:cmd=>'p ~3',    :exp=>'$7 = -4'}
@@ -588,7 +591,7 @@ SRC
   tc << {:cmd=>'p foo=[foo,bar,baz]', :exp=>'$2 = ["foo", "bar", "baz"]'}
 
   tc << {:cmd=>'p undefined=-1',      :exp=>'$3 = -1'}
-  tc << {:cmd=>'p "#{undefined}"',    :exp=>'$4 = (eval):2: undefined method'}
+  tc << {:cmd=>'p "#{undefined}"',    :exp=>'$4 = undefined method'}
 
   BinTest_MrubyBinDebugger.test(src, tc)
 end
@@ -611,13 +614,13 @@ SRC
   tc << {:cmd=>'p a+=9',   :exp=>'$1 = 10'}
   tc << {:cmd=>'p b-=c',   :exp=>'$2 = 15'}
   tc << {:cmd=>'p bar*=2', :exp=>'$3 = "barbar"'}
-  tc << {:cmd=>'p a/=4',   :exp=>'$4 = 2.5'}
+  tc << {:cmd=>'p a/=4',   :exp=>'$4 = 2'}
   tc << {:cmd=>'p c%=4',   :exp=>'$5 = 2'}
 
   tc << {:cmd=>'p b&=0b0101', :exp=>'$6 = 5'}
   tc << {:cmd=>'p c|=0x10',   :exp=>'$7 = 18'}
 
-  tc << {:cmd=>'p "#{a} #{b} #{c}"',     :exp=>'$8 = "2.5 5 18"'}
+  tc << {:cmd=>'p "#{a} #{b} #{c}"',     :exp=>'$8 = "2 5 18"'}
   tc << {:cmd=>'p "#{foo}#{bar}#{baz}"', :exp=>'$9 = "foobarbarbaz"'}
 
   tc << {:cmd=>'p a,b,c=[10,20,30]',:exp=>'$10 = [10, 20, 30]'}
@@ -626,7 +629,7 @@ SRC
   tc << {:cmd=>'p [a,b]',           :exp=>'$13 = [20, 10]'}
 
   tc << {:cmd=>'p undefined=-1',    :exp=>'$14 = -1'}
-  tc << {:cmd=>'p "#{undefined}"',  :exp=>'$15 = (eval):2: undefined method'}
+  tc << {:cmd=>'p "#{undefined}"',  :exp=>'$15 = undefined method'}
 
   BinTest_MrubyBinDebugger.test(src, tc)
 end
@@ -679,13 +682,13 @@ SRC
   tc << {:cmd=>'p a+=9',   :exp=>'$1 = 10'}
   tc << {:cmd=>'p b-=c',   :exp=>'$2 = 15'}
   tc << {:cmd=>'p bar*=2', :exp=>'$3 = "barbar"'}
-  tc << {:cmd=>'p a/=4',   :exp=>'$4 = 2.5'}
+  tc << {:cmd=>'p a/=4',   :exp=>'$4 = 2'}
   tc << {:cmd=>'p c%=4',   :exp=>'$5 = 2'}
 
   tc << {:cmd=>'p b&=0b0101', :exp=>'$6 = 5'}
   tc << {:cmd=>'p c|=0x10',   :exp=>'$7 = 18'}
 
-  tc << {:cmd=>'p "#{a} #{b} #{c}"',     :exp=>'$8 = "2.5 5 18"'}
+  tc << {:cmd=>'p "#{a} #{b} #{c}"',     :exp=>'$8 = "2 5 18"'}
   tc << {:cmd=>'p "#{foo}#{bar}#{baz}"', :exp=>'$9 = "foobarbarbaz"'}
 
   tc << {:cmd=>'p a,b,c=[10,20,30]',:exp=>'$10 = [10, 20, 30]'}
@@ -694,8 +697,7 @@ SRC
   tc << {:cmd=>'p [a,b]',           :exp=>'$13 = [20, 10]'}
 
   tc << {:cmd=>'p undefined=-1',    :exp=>'$14 = -1'}
-  tc << {:cmd=>'p "#{undefined}"',  :exp=>'$15 = (eval):2: undefined method'}
+  tc << {:cmd=>'p "#{undefined}"',  :exp=>'$15 = undefined method'}
 
   BinTest_MrubyBinDebugger.test(src, tc)
 end
-

mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c

@@ -84,7 +84,7 @@ free_breakpoint(mrb_state *mrb, mrb_debug_breakpoint *bp)
 }
 
 static uint16_t
-check_file_lineno(mrb_state *mrb, struct mrb_irep *irep, const char *file, uint16_t lineno)
+check_file_lineno(mrb_state *mrb, const struct mrb_irep *irep, const char *file, uint16_t lineno)
 {
   mrb_irep_debug_info_file *info_file;
   uint16_t result = 0;
@@ -151,7 +151,7 @@ compare_break_method(mrb_state *mrb, mrb_debug_breakpoint *bp, struct RClass *cl
       }
 
       sc = mrb_class_get(mrb, method_p->class_name);
-      ssym = mrb_symbol(mrb_check_intern_cstr(mrb, method_p->method_name));
+      ssym = mrb_intern_check_cstr(mrb, method_p->method_name);
       m = mrb_method_search_vm(mrb, &sc, ssym);
       if (MRB_METHOD_UNDEF_P(m)) {
         return MRB_DEBUG_OK;
@@ -428,7 +428,7 @@ mrb_debug_disable_break_all(mrb_state *mrb, mrb_debug_context *dbg)
 }
 
 static mrb_bool
-check_start_pc_for_line(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, uint16_t line)
+check_start_pc_for_line(mrb_state *mrb, const mrb_irep *irep, const mrb_code *pc, uint16_t line)
 {
   if (pc > irep->iseq) {
     if (line == mrb_debug_get_line(mrb, irep, pc - irep->iseq - 1)) {

mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c

@@ -33,7 +33,7 @@ mrdb_check_syntax(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size
 mrb_value
 mrb_debug_eval(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size_t len, mrb_bool *exc, int direct_eval)
 {
-  void (*tmp)(struct mrb_state *, struct mrb_irep *, const mrb_code *, mrb_value *);
+  void (*tmp)(struct mrb_state *, const struct mrb_irep *, const mrb_code *, mrb_value *);
   mrb_value ruby_code;
   mrb_value s;
   mrb_value v;
@@ -67,7 +67,7 @@ mrb_debug_eval(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size_t
 
     recv = dbg->regs[0];
 
-    v =  mrb_funcall(mrb, recv, "instance_eval", 1, ruby_code);
+    v =  mrb_funcall_id(mrb, recv, MRB_SYM(instance_eval), 1, ruby_code);
   }
 
   if (exc) {

mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c

@@ -5,7 +5,6 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <stdio.h>
 #include <ctype.h>
 
 #include <mruby.h>
@@ -505,7 +504,7 @@ get_and_parse_command(mrb_state *mrb, mrdb_state *mrdb)
 }
 
 static int32_t
-check_method_breakpoint(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, mrb_value *regs)
+check_method_breakpoint(mrb_state *mrb, const mrb_irep *irep, const mrb_code *pc, mrb_value *regs)
 {
   struct RClass* c;
   mrb_sym sym;
@@ -546,7 +545,7 @@ check_method_breakpoint(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, mrb_
 }
 
 static void
-mrb_code_fetch_hook(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, mrb_value *regs)
+mrb_code_fetch_hook(mrb_state *mrb, const mrb_irep *irep, const mrb_code *pc, mrb_value *regs)
 {
   const char *file;
   int32_t line;

mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h

@@ -103,8 +103,8 @@ typedef struct mrb_debug_breakpoint {
 } mrb_debug_breakpoint;
 
 typedef struct mrb_debug_context {
-  struct mrb_irep *root_irep;
-  struct mrb_irep *irep;
+  const struct mrb_irep *root_irep;
+  const struct mrb_irep *irep;
   const mrb_code *pc;
   mrb_value *regs;
 

mrbgems/mruby-bin-debugger/tools/mrdb/mrdbconf.h

@@ -7,7 +7,11 @@
 #define MRDBCONF_H
 
 #ifndef MRB_ENABLE_DEBUG_HOOK
-# error Need 'MRB_ENABLE_DEBUG_HOOK' configuration in your 'build_config.rb'
+# error mruby-bin-debugger need 'MRB_ENABLE_DEBUG_HOOK' configuration in your 'build_config.rb'
+#endif
+
+#ifdef MRB_DISABLE_STDIO
+# error mruby-bin-debugger conflicts 'MRB_DISABLE_STDIO' configuration in your 'build_config.rb'
 #endif
 
 /* configuration options: */

mrbgems/mruby-bin-mirb/bintest/mirb.rb

@@ -32,3 +32,20 @@ EOS
   o, _ = Open3.capture2("bin/mirb -r #{lib.path}", :stdin_data => "Hoge.new.hoge\n")
   assert_true o.include?('=> :hoge')
 end
+
+assert('top level local variables are in file scope') do
+  lib = Tempfile.new('lib.rb')
+  lib.write <<-TESTLIB
+a = 1
+A = -> { a }
+  TESTLIB
+  lib.flush
+
+  o, _ = Open3.capture2("bin/mirb -r #{lib.path}", :stdin_data => <<-TESTCODE)
+a
+a = 5
+A.call
+  TESTCODE
+
+  assert_kind_of Integer, o =~ /\bundefined method 'a' \(NoMethodError\).*=> 5\b.*=> 1\b/m
+end

mrbgems/mruby-bin-mirb/tools/mirb/mirb.c

@@ -7,6 +7,11 @@
 */
 
 #include <mruby.h>
+
+#ifdef MRB_DISABLE_STDIO
+# error mruby-bin-mirb conflicts 'MRB_DISABLE_STDIO' configuration in your 'build_config.rb'
+#endif
+
 #include <mruby/array.h>
 #include <mruby/proc.h>
 #include <mruby/compile.h>
@@ -17,7 +22,6 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <stdio.h>
 #include <ctype.h>
 
 #include <signal.h>
@@ -100,13 +104,13 @@ p(mrb_state *mrb, mrb_value obj, int prompt)
   mrb_value val;
   char* msg;
 
-  val = mrb_funcall(mrb, obj, "inspect", 0);
+  val = mrb_funcall_id(mrb, obj, MRB_SYM(inspect), 0);
   if (prompt) {
     if (!mrb->exc) {
       fputs(" => ", stdout);
     }
     else {
-      val = mrb_funcall(mrb, mrb_obj_value(mrb->exc), "inspect", 0);
+      val = mrb_funcall_id(mrb, mrb_obj_value(mrb->exc), MRB_SYM(inspect), 0);
     }
   }
   if (!mrb_string_p(val)) {
@@ -491,12 +495,9 @@ main(int argc, char **argv)
 
   cxt = mrbc_context_new(mrb);
 
-#ifndef DISABLE_MIRB_UNDERSCORE
-  decl_lv_underscore(mrb, cxt);
-#endif
-
   /* Load libraries */
   for (i = 0; i < args.libc; i++) {
+    struct REnv *e;
     FILE *lfp = fopen(args.libv[i], "r");
     if (lfp == NULL) {
       printf("Cannot open library file. (%s)\n", args.libv[i]);
@@ -505,8 +506,16 @@ main(int argc, char **argv)
     }
     mrb_load_file_cxt(mrb, lfp, cxt);
     fclose(lfp);
+    e = mrb->c->cibase->env;
+    mrb->c->cibase->env = NULL;
+    mrb_env_unshare(mrb, e);
+    mrbc_cleanup_local_variables(mrb, cxt);
   }
 
+#ifndef DISABLE_MIRB_UNDERSCORE
+  decl_lv_underscore(mrb, cxt);
+#endif
+
   cxt->capture_errors = TRUE;
   cxt->lineno = 1;
   mrbc_filename(mrb, cxt, "(mirb)");
@@ -516,10 +525,7 @@ main(int argc, char **argv)
 
   while (TRUE) {
     char *utf8;
-    struct mrb_jmpbuf c_jmp;
 
-    MRB_TRY(&c_jmp);
-    mrb->jmp = &c_jmp;
     if (args.rfp) {
       if (fgets(last_code_line, sizeof(last_code_line)-1, args.rfp) != NULL)
         goto done;
@@ -645,8 +651,8 @@ main(int argc, char **argv)
         /* adjust stack length of toplevel environment */
         if (mrb->c->cibase->env) {
           struct REnv *e = mrb->c->cibase->env;
-          if (e && MRB_ENV_STACK_LEN(e) < proc->body.irep->nlocals) {
-            MRB_ENV_SET_STACK_LEN(e, proc->body.irep->nlocals);
+          if (e && MRB_ENV_LEN(e) < proc->body.irep->nlocals) {
+            MRB_ENV_SET_LEN(e, proc->body.irep->nlocals);
           }
         }
         /* pass a proc for evaluation */
@@ -663,7 +669,7 @@ main(int argc, char **argv)
         }
         else {
           /* no */
-          if (!mrb_respond_to(mrb, result, mrb_intern_lit(mrb, "inspect"))){
+          if (!mrb_respond_to(mrb, result, MRB_SYM(inspect))){
             result = mrb_any_to_s(mrb, result);
           }
           p(mrb, result, 1);
@@ -678,11 +684,6 @@ main(int argc, char **argv)
     }
     mrb_parser_free(parser);
     cxt->lineno++;
-    MRB_CATCH(&c_jmp) {
-      p(mrb, mrb_obj_value(mrb->exc), 0);
-      mrb->exc = 0;
-    }
-    MRB_END_EXC(&c_jmp);
   }
 
 #ifdef ENABLE_READLINE

mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c

@@ -1,7 +1,11 @@
-#include <stdio.h>
+#include <mruby.h>
+
+#ifdef MRB_DISABLE_STDIO
+# error mruby-bin-mrbc conflicts 'MRB_DISABLE_STDIO' configuration in your 'build_config.rb'
+#endif
+
 #include <stdlib.h>
 #include <string.h>
-#include <mruby.h>
 #include <mruby/compile.h>
 #include <mruby/dump.h>
 #include <mruby/proc.h>
@@ -16,6 +20,7 @@ struct mrbc_args {
   const char *prog;
   const char *outfile;
   const char *initname;
+  mrb_bool dump_struct  : 1;
   mrb_bool check_syntax : 1;
   mrb_bool verbose      : 1;
   mrb_bool remove_lv    : 1;
@@ -28,12 +33,11 @@ usage(const char *name)
   static const char *const usage_msg[] = {
   "switches:",
   "-c           check syntax only",
-  "-o<outfile>  place the output into <outfile>",
+  "-o<outfile>  place the output into <outfile>; required for multi-files",
   "-v           print version number, then turn on verbose mode",
   "-g           produce debugging information",
   "-B<symbol>   binary <symbol> output in C language format",
-  "-e           generate little endian iseq data",
-  "-E           generate big endian iseq data",
+  "-S           dump C struct (requires -B)",
   "--remove-lv  remove local variables",
   "--verbose    run at verbose mode",
   "--version    print the version",
@@ -42,7 +46,7 @@ usage(const char *name)
   };
   const char *const *p = usage_msg;
 
-  printf("Usage: %s [switches] programfile\n", name);
+  printf("Usage: %s [switches] programfile...\n", name);
   while (*p)
     printf("  %s\n", *p++);
 }
@@ -50,19 +54,26 @@ usage(const char *name)
 static char *
 get_outfilename(mrb_state *mrb, char *infile, const char *ext)
 {
-  size_t infilelen;
-  size_t extlen;
+  size_t ilen, flen, elen;
   char *outfile;
-  char *p;
+  char *p = NULL;
 
-  infilelen = strlen(infile);
-  extlen = strlen(ext);
-  outfile = (char*)mrb_malloc(mrb, infilelen + extlen + 1);
-  memcpy(outfile, infile, infilelen + 1);
+  ilen = strlen(infile);
+  flen = ilen;
   if (*ext) {
-    if ((p = strrchr(outfile, '.')) == NULL)
-      p = outfile + infilelen;
-    memcpy(p, ext, extlen + 1);
+    elen = strlen(ext);
+    if ((p = strrchr(infile, '.'))) {
+      ilen = p - infile;
+    }
+    flen += elen;
+  }
+  else {
+    flen = ilen;
+  }
+  outfile = (char*)mrb_malloc(mrb, flen+1);
+  strncpy(outfile, infile, ilen+1);
+  if (p) {
+    strncpy(outfile+ilen, ext, elen+1);
   }
 
   return outfile;
@@ -96,6 +107,9 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct mrbc_args *args)
           args->outfile = get_outfilename(mrb, argv[i] + 2, "");
         }
         break;
+      case 'S':
+        args->dump_struct = TRUE;
+        break;
       case 'B':
         if (argv[i][2] == '\0' && argv[i+1]) {
           i++;
@@ -120,10 +134,8 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct mrbc_args *args)
         args->flags |= DUMP_DEBUG_INFO;
         break;
       case 'E':
-        args->flags = DUMP_ENDIAN_BIG | (args->flags & ~DUMP_ENDIAN_MASK);
-        break;
       case 'e':
-        args->flags = DUMP_ENDIAN_LIL | (args->flags & ~DUMP_ENDIAN_MASK);
+        fprintf(stderr, "%s: -e/-E option no longer needed.\n", args->prog);
         break;
       case 'h':
         return -1;
@@ -156,10 +168,6 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct mrbc_args *args)
       break;
     }
   }
-  if (args->verbose && args->initname && (args->flags & DUMP_ENDIAN_MASK) == 0) {
-    fprintf(stderr, "%s: generating %s endian C file. specify -e/-E for cross compiling.\n",
-            args->prog, bigendian_p() ? "big" : "little");
-  }
   return i;
 }
 
@@ -183,7 +191,7 @@ partial_hook(struct mrb_parser_state *p)
     return -1;
   }
   fn = args->argv[args->idx++];
-  p->f = fopen(fn, "r");
+  p->f = fopen(fn, "rb");
   if (p->f == NULL) {
     fprintf(stderr, "%s: cannot open program file. (%s)\n", args->prog, fn);
     return -1;
@@ -210,7 +218,7 @@ load_file(mrb_state *mrb, struct mrbc_args *args)
   }
   else {
     need_close = TRUE;
-    if ((infile = fopen(input, "r")) == NULL) {
+    if ((infile = fopen(input, "rb")) == NULL) {
       fprintf(stderr, "%s: cannot open program file. (%s)\n", args->prog, input);
       return mrb_nil_value();
     }
@@ -235,13 +243,18 @@ static int
 dump_file(mrb_state *mrb, FILE *wfp, const char *outfile, struct RProc *proc, struct mrbc_args *args)
 {
   int n = MRB_DUMP_OK;
-  mrb_irep *irep = proc->body.irep;
+  const mrb_irep *irep = proc->body.irep;
 
   if (args->remove_lv) {
-    mrb_irep_remove_lv(mrb, irep);
+    mrb_irep_remove_lv(mrb, (mrb_irep*)irep);
   }
   if (args->initname) {
-    n = mrb_dump_irep_cfunc(mrb, irep, args->flags, wfp, args->initname);
+    if (args->dump_struct) {
+      n = mrb_dump_irep_cstruct(mrb, irep, args->flags, wfp, args->initname);
+    }
+    else {
+      n = mrb_dump_irep_cfunc(mrb, irep, args->flags, wfp, args->initname);
+    }
     if (n == MRB_DUMP_INVALID_ARGUMENT) {
       fprintf(stderr, "%s: invalid C language symbol name\n", args->initname);
     }

mrbgems/mruby-bin-mruby/bintest/mruby.rb

@@ -39,6 +39,11 @@ assert '$0 value' do
   assert_equal '"-e"', `#{cmd('mruby')} -e #{shellquote('p $0')}`.chomp
 end
 
+assert 'ARGV value' do
+  assert_mruby(%{["ab", "cde"]\n}, "", true, %w[-e p(ARGV) ab cde])
+  assert_mruby("[]\n", "", true, %w[-e p(ARGV)])
+end
+
 assert('float literal') do
   script, bin = Tempfile.new('test.rb'), Tempfile.new('test.mrb')
   File.write script.path, 'p [3.21, 2e308.infinite?, -2e308.infinite?]'
@@ -80,10 +85,8 @@ assert('mruby -c option') do
 end
 
 assert('mruby -d option') do
-  o = `#{cmd('mruby')} -e #{shellquote('p $DEBUG')}`
-  assert_equal "false\n", o
-  o = `#{cmd('mruby')} -d -e #{shellquote('p $DEBUG')}`
-  assert_equal "true\n", o
+  assert_mruby("false\n", "", true, ["-e", "p $DEBUG"])
+  assert_mruby("true\n", "", true, ["-dep $DEBUG"])
 end
 
 assert('mruby -e option (no code specified)') do
@@ -125,6 +128,20 @@ assert('mruby -r option (file not found)') do
   assert_mruby("", /\A.*: Cannot open library file: .*\n\z/, false, %w[-r _no_exists_])
 end
 
+assert('mruby -v option') do
+  ver_re = '\Amruby \d+\.\d+\.\d+ \(\d+-\d+-\d+\)\n'
+  assert_mruby(/#{ver_re}\z/, "", true, %w[-v])
+  assert_mruby(/#{ver_re}^[^\n]*NODE.*\n:end\n\z/m, "", true, %w[-v -e p(:end)])
+end
+
+assert('mruby --verbose option') do
+  assert_mruby(/\A[^\n]*NODE.*\n:end\n\z/m, "", true, %w[--verbose -e p(:end)])
+end
+
+assert('mruby --') do
+  assert_mruby(%{["-x", "1"]\n}, "", true, %w[-e p(ARGV) -- -x 1])
+end
+
 assert('mruby invalid short option') do
   assert_mruby("", /\A.*: invalid option -1 .*\n\z/, false, %w[-1])
 end
@@ -145,3 +162,24 @@ assert('codegen error') do
   code = "def f(#{(1..100).map{|n| "a#{n}"} * ","}); end"
   assert_mruby("", /\Acodegen error:.*\n\z/, false, ["-e", code])
 end
+
+assert('top level local variables are in file scope') do
+  arb, amrb = Tempfile.new('a.rb'), Tempfile.new('a.mrb')
+  brb, bmrb = Tempfile.new('b.rb'), Tempfile.new('b.mrb')
+  crb, cmrb = Tempfile.new('c.rb'), Tempfile.new('c.mrb')
+  drb, dmrb = Tempfile.new('d.rb'), Tempfile.new('d.mrb')
+
+  File.write arb.path, 'a = 1'
+  system "#{cmd('mrbc')} -g -o #{amrb.path} #{arb.path}"
+  File.write brb.path, 'p a'
+  system "#{cmd('mrbc')} -g -o #{bmrb.path} #{brb.path}"
+  assert_mruby("", /:1: undefined method 'a' \(NoMethodError\)\n\z/, false, ["-r", arb.path, brb.path])
+  assert_mruby("", /:1: undefined method 'a' \(NoMethodError\)\n\z/, false, ["-b", "-r", amrb.path, bmrb.path])
+
+  File.write crb.path, 'a, b, c = 1, 2, 3; A = -> { b = -2; [a, b, c] }'
+  system "#{cmd('mrbc')} -g -o #{cmrb.path} #{crb.path}"
+  File.write drb.path, 'a, b = 5, 6; p A.call; p a, b'
+  system "#{cmd('mrbc')} -g -o #{dmrb.path} #{drb.path}"
+  assert_mruby("[1, -2, 3]\n5\n6\n", "", true, ["-r", crb.path, drb.path])
+  assert_mruby("[1, -2, 3]\n5\n6\n", "", true, ["-b", "-r", cmrb.path, dmrb.path])
+end

mrbgems/mruby-bin-mruby/mrbgem.rake

@@ -4,7 +4,6 @@ MRuby::Gem::Specification.new('mruby-bin-mruby') do |spec|
   spec.summary = 'mruby command'
   spec.bins = %w(mruby)
   spec.add_dependency('mruby-compiler', :core => 'mruby-compiler')
-  spec.add_dependency('mruby-error', :core => 'mruby-error')
   spec.add_test_dependency('mruby-print', :core => 'mruby-print')
 
   if build.cxx_exception_enabled?

mrbgems/mruby-bin-mruby/tools/mruby/mruby.c

@@ -1,26 +1,40 @@
-#include <stdio.h>
+#include <mruby.h>
+
+#ifdef MRB_DISABLE_STDIO
+# error mruby-bin-mruby conflicts 'MRB_DISABLE_STDIO' configuration in your 'build_config.rb'
+#endif
+
 #include <stdlib.h>
 #include <string.h>
-#include <mruby.h>
 #include <mruby/array.h>
 #include <mruby/compile.h>
 #include <mruby/dump.h>
 #include <mruby/variable.h>
+#include <mruby/proc.h>
 
 struct _args {
   FILE *rfp;
-  char* cmdline;
+  char *cmdline;
   mrb_bool fname        : 1;
   mrb_bool mrbfile      : 1;
   mrb_bool check_syntax : 1;
   mrb_bool verbose      : 1;
+  mrb_bool version      : 1;
   mrb_bool debug        : 1;
   int argc;
-  char** argv;
+  char **argv;
   int libc;
   char **libv;
 };
 
+struct options {
+  int argc;
+  char **argv;
+  char *program;
+  char *opt;
+  char short_opt[2];
+};
+
 static void
 usage(const char *name)
 {
@@ -44,6 +58,64 @@ usage(const char *name)
     printf("  %s\n", *p++);
 }
 
+static void
+options_init(struct options *opts, int argc, char **argv)
+{
+  opts->argc = argc;
+  opts->argv = argv;
+  opts->program = *argv;
+  *opts->short_opt = 0;
+}
+
+static const char *
+options_opt(struct options *opts)
+{
+  /* concatenated short options (e.g. `-cv`) */
+  if (*opts->short_opt && *++opts->opt) {
+   short_opt:
+    opts->short_opt[0] = *opts->opt;
+    opts->short_opt[1] = 0;
+    return opts->short_opt;
+  }
+
+  while (++opts->argv, --opts->argc) {
+    opts->opt = *opts->argv;
+
+    /*  empty         || not start with `-`  || `-` */
+    if (!opts->opt[0] || opts->opt[0] != '-' || !opts->opt[1]) return NULL;
+
+    if (opts->opt[1] == '-') {
+      /* `--` */
+      if (!opts->opt[2]) {
+        ++opts->argv, --opts->argc;
+        return NULL;
+      }
+      /* long option */
+      opts->opt += 2;
+      *opts->short_opt = 0;
+      return opts->opt;
+    }
+    else {
+      /* short option */
+      ++opts->opt;
+      goto short_opt;
+    }
+  }
+  return NULL;
+}
+
+static const char *
+options_arg(struct options *opts)
+{
+  if (*opts->short_opt && opts->opt[1]) {
+    /* concatenated short option and option argument (e.g. `-rLIBRARY`) */
+    *opts->short_opt = 0;
+    return opts->opt + 1;
+  }
+  --opts->argc, ++opts->argv;
+  return opts->argc ? *opts->argv : NULL;
+}
+
 static char *
 dup_arg_item(mrb_state *mrb, const char *item)
 {
@@ -56,40 +128,24 @@ dup_arg_item(mrb_state *mrb, const char *item)
 static int
 parse_args(mrb_state *mrb, int argc, char **argv, struct _args *args)
 {
-  char **origargv = argv;
   static const struct _args args_zero = { 0 };
+  struct options opts[1];
+  const char *opt, *item;
 
   *args = args_zero;
-
-  for (argc--,argv++; argc > 0; argc--,argv++) {
-    char *item;
-    if (argv[0][0] != '-') break;
-
-    if (strlen(*argv) <= 1) {
-      argc--; argv++;
-      args->rfp = stdin;
-      break;
-    }
-
-    item = argv[0] + 1;
-    switch (*item++) {
-    case 'b':
+  options_init(opts, argc, argv);
+  while ((opt = options_opt(opts))) {
+    if (strcmp(opt, "b") == 0) {
       args->mrbfile = TRUE;
-      break;
-    case 'c':
+    }
+    else if (strcmp(opt, "c") == 0) {
       args->check_syntax = TRUE;
-      break;
-    case 'd':
+    }
+    else if (strcmp(opt, "d") == 0) {
       args->debug = TRUE;
-      break;
-    case 'e':
-      if (item[0]) {
-        goto append_cmdline;
-      }
-      else if (argc > 1) {
-        argc--; argv++;
-        item = argv[0];
-append_cmdline:
+    }
+    else if (strcmp(opt, "e") == 0) {
+      if ((item = options_arg(opts))) {
         if (!args->cmdline) {
           args->cmdline = dup_arg_item(mrb, item);
         }
@@ -106,59 +162,65 @@ append_cmdline:
         }
       }
       else {
-        fprintf(stderr, "%s: No code specified for -e\n", *origargv);
+        fprintf(stderr, "%s: No code specified for -e\n", opts->program);
         return EXIT_FAILURE;
       }
-      break;
-    case 'h':
-      usage(*origargv);
+    }
+    else if (strcmp(opt, "h") == 0) {
+      usage(opts->program);
       exit(EXIT_SUCCESS);
-    case 'r':
-      if (!item[0]) {
-        if (argc <= 1) {
-          fprintf(stderr, "%s: No library specified for -r\n", *origargv);
-          return EXIT_FAILURE;
+    }
+    else if (strcmp(opt, "r") == 0) {
+      if ((item = options_arg(opts))) {
+        if (args->libc == 0) {
+          args->libv = (char**)mrb_malloc(mrb, sizeof(char*));
         }
-        argc--; argv++;
-        item = argv[0];
-      }
-      if (args->libc == 0) {
-        args->libv = (char**)mrb_malloc(mrb, sizeof(char*));
+        else {
+          args->libv = (char**)mrb_realloc(mrb, args->libv, sizeof(char*) * (args->libc + 1));
+        }
+        args->libv[args->libc++] = dup_arg_item(mrb, item);
       }
       else {
-        args->libv = (char**)mrb_realloc(mrb, args->libv, sizeof(char*) * (args->libc + 1));
+        fprintf(stderr, "%s: No library specified for -r\n", opts->program);
+        return EXIT_FAILURE;
       }
-      args->libv[args->libc++] = dup_arg_item(mrb, item);
-      break;
-    case 'v':
-      if (!args->verbose) mrb_show_version(mrb);
-      args->verbose = TRUE;
-      break;
-    case '-':
-      if (strcmp((*argv) + 2, "version") == 0) {
+    }
+    else if (strcmp(opt, "v") == 0) {
+      if (!args->verbose) {
         mrb_show_version(mrb);
-        exit(EXIT_SUCCESS);
+        args->version = TRUE;
       }
-      else if (strcmp((*argv) + 2, "verbose") == 0) {
-        args->verbose = TRUE;
-        break;
-      }
-      else if (strcmp((*argv) + 2, "copyright") == 0) {
-        mrb_show_copyright(mrb);
-        exit(EXIT_SUCCESS);
-      }
-    default:
-      fprintf(stderr, "%s: invalid option %s (-h will show valid options)\n", *origargv, *argv);
+      args->verbose = TRUE;
+    }
+    else if (strcmp(opt, "version") == 0) {
+      mrb_show_version(mrb);
+      exit(EXIT_SUCCESS);
+    }
+    else if (strcmp(opt, "verbose") == 0) {
+      args->verbose = TRUE;
+    }
+    else if (strcmp(opt, "copyright") == 0) {
+      mrb_show_copyright(mrb);
+      exit(EXIT_SUCCESS);
+    }
+    else {
+      fprintf(stderr, "%s: invalid option %s%s (-h will show valid options)\n",
+              opts->program, opt[1] ? "--" : "-", opt);
       return EXIT_FAILURE;
     }
   }
 
-  if (args->rfp == NULL && args->cmdline == NULL) {
-    if (*argv == NULL) args->rfp = stdin;
+  argc = opts->argc; argv = opts->argv;
+  if (args->cmdline == NULL) {
+    if (*argv == NULL) {
+      if (args->version) exit(EXIT_SUCCESS);
+      args->rfp = stdin;
+    }
     else {
-      args->rfp = fopen(argv[0], args->mrbfile ? "rb" : "r");
+      args->rfp = strcmp(argv[0], "-") == 0 ?
+        stdin : fopen(argv[0], args->mrbfile ? "rb" : "r");
       if (args->rfp == NULL) {
-        fprintf(stderr, "%s: Cannot open program file: %s\n", *origargv, *argv);
+        fprintf(stderr, "%s: Cannot open program file: %s\n", opts->program, argv[0]);
         return EXIT_FAILURE;
       }
       args->fname = TRUE;
@@ -246,6 +308,7 @@ main(int argc, char **argv)
 
     /* Load libraries */
     for (i = 0; i < args.libc; i++) {
+      struct REnv *e;
       FILE *lfp = fopen(args.libv[i], args.mrbfile ? "rb" : "r");
       if (lfp == NULL) {
         fprintf(stderr, "%s: Cannot open library file: %s\n", *argv, args.libv[i]);
@@ -260,6 +323,10 @@ main(int argc, char **argv)
         v = mrb_load_file_cxt(mrb, lfp, c);
       }
       fclose(lfp);
+      e = mrb->c->cibase->env;
+      mrb->c->cibase->env = NULL;
+      mrb_env_unshare(mrb, e);
+      mrbc_cleanup_local_variables(mrb, c);
     }
 
     /* Load program */

mrbgems/mruby-bin-strip/tools/mruby-strip/mruby-strip.c

@@ -1,7 +1,11 @@
-#include <stdio.h>
+#include <mruby.h>
+
+#ifdef MRB_DISABLE_STDIO
+# error mruby-bin-strip conflicts 'MRB_DISABLE_STDIO' configuration in your 'build_config.rb'
+#endif
+
 #include <stdlib.h>
 #include <string.h>
-#include <mruby.h>
 #include <mruby/irep.h>
 #include <mruby/dump.h>
 

mrbgems/mruby-catch/mrbgem.rake

@@ -0,0 +1,5 @@
+MRuby::Gem::Specification.new('mruby-catch') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'Catch / Throw non-local Jump'
+end

mrbgems/mruby-catch/mrblib/catch.rb

@@ -0,0 +1,27 @@
+class ThrowCatchJump < Exception
+  def initialize(tag, val)
+    @tag = tag
+    @val = val
+    super("uncaught throw :#{tag}")
+  end
+  def _tag
+    @tag
+  end
+  def _val
+    @val
+  end
+end
+
+module Kernel
+  def catch(tag, &block)
+    block.call(tag)
+  rescue ThrowCatchJump => e
+    unless e._tag == tag
+      raise e
+    end
+    return e._val
+  end
+  def throw(tag, val=nil)
+    raise ThrowCatchJump.new(tag, val)
+  end
+end

mrbgems/mruby-class-ext/src/class.c

@@ -5,7 +5,11 @@
 static mrb_value
 mrb_mod_name(mrb_state *mrb, mrb_value self)
 {
-  return mrb_class_path(mrb, mrb_class_ptr(self));
+  mrb_value name =  mrb_class_path(mrb, mrb_class_ptr(self));
+  if (mrb_string_p(name)) {
+    MRB_SET_FROZEN_FLAG(mrb_basic_ptr(name));
+  }
+  return name;
 }
 
 static mrb_value
@@ -39,10 +43,15 @@ mrb_mod_module_exec(mrb_state *mrb, mrb_value self)
   const mrb_value *argv;
   mrb_int argc;
   mrb_value blk;
+  struct RClass *c;
 
   mrb_get_args(mrb, "*&!", &argv, &argc, &blk);
 
-  mrb->c->ci->target_class = mrb_class_ptr(self);
+  c = mrb_class_ptr(self);
+  if (mrb->c->ci->acc < 0) {
+    return mrb_yield_with_class(mrb, blk, argc, argv, self, c);
+  }
+  mrb->c->ci->target_class = c;
   return mrb_yield_cont(mrb, blk, self, argc, argv);
 }
 

mrbgems/mruby-compiler/core/node.h

@@ -51,6 +51,7 @@ enum node_type {
   NODE_IVAR,
   NODE_CONST,
   NODE_CVAR,
+  NODE_NVAR,
   NODE_NTH_REF,
   NODE_BACK_REF,
   NODE_MATCH,

mrbgems/mruby-compiler/mrbgem.rake

@@ -3,35 +3,33 @@ MRuby::Gem::Specification.new 'mruby-compiler' do |spec|
   spec.author  = 'mruby developers'
   spec.summary = 'mruby compiler library'
 
-  current_dir = spec.dir
-  current_build_dir = spec.build_dir
-
-  lex_def = "#{current_dir}/core/lex.def"
-  core_objs = Dir.glob("#{current_dir}/core/*.c").map { |f|
+  lex_def = "#{dir}/core/lex.def"
+  core_objs = Dir.glob("#{dir}/core/*.c").map { |f|
     next nil if build.cxx_exception_enabled? and f =~ /(codegen).c$/
-    objfile(f.pathmap("#{current_build_dir}/core/%n"))
+    objfile(f.pathmap("#{build_dir}/core/%n"))
   }.compact
 
   if build.cxx_exception_enabled?
     core_objs <<
-      build.compile_as_cxx("#{current_build_dir}/core/y.tab.c", "#{current_build_dir}/core/y.tab.cxx",
-                           objfile("#{current_build_dir}/y.tab"), ["#{current_dir}/core"]) <<
-      build.compile_as_cxx("#{current_dir}/core/codegen.c", "#{current_build_dir}/core/codegen.cxx")
+      build.compile_as_cxx("#{dir}/core/y.tab.c", "#{build_dir}/core/y.tab.cxx",
+                           objfile("#{build_dir}/y.tab"), ["#{dir}/core"]) <<
+      build.compile_as_cxx("#{dir}/core/codegen.c", "#{build_dir}/core/codegen.cxx")
   else
-    core_objs << objfile("#{current_build_dir}/core/y.tab")
-    file objfile("#{current_build_dir}/core/y.tab") => "#{current_build_dir}/core/y.tab.c" do |t|
-      cc.run t.name, t.prerequisites.first, [], ["#{current_dir}/core"]
+    core_objs << objfile("#{build_dir}/core/y.tab")
+    file objfile("#{build_dir}/core/y.tab") => "#{dir}/core/y.tab.c" do |t|
+      cc.run t.name, t.prerequisites.first, [], ["#{dir}/core"]
     end
   end
 
   # Parser
-  file "#{current_build_dir}/core/y.tab.c" => ["#{current_dir}/core/parse.y", lex_def] do |t|
-    FileUtils.mkdir_p File.dirname t.name
+  file "#{dir}/core/y.tab.c" => ["#{dir}/core/parse.y", lex_def] do |t|
     yacc.run t.name, t.prerequisites.first
+    content = File.read(t.name).gsub(/^#line +\d+ +"\K.*$/){$&.relative_path}
+    File.write(t.name, content)
   end
 
   # Lexical analyzer
-  file lex_def => "#{current_dir}/core/keywords" do |t|
+  file lex_def => "#{dir}/core/keywords" do |t|
     gperf.run t.name, t.prerequisites.first
   end
 

mrbgems/mruby-complex/mrbgem.rake

@@ -3,8 +3,5 @@ MRuby::Gem::Specification.new('mruby-complex') do |spec|
   spec.author  = 'mruby developers'
   spec.summary = 'Complex class'
 
-  spec.add_dependency 'mruby-metaprog', core: 'mruby-metaprog'
-  spec.add_dependency 'mruby-object-ext', core: 'mruby-object-ext'
-  spec.add_dependency 'mruby-numeric-ext', core: 'mruby-numeric-ext'
   spec.add_dependency 'mruby-math', core: 'mruby-math'
 end

mrbgems/mruby-complex/mrblib/complex.rb

@@ -8,7 +8,7 @@ class Complex < Numeric
   end
 
   def to_s
-    "#{real}#{'+' unless imaginary.negative?}#{imaginary}i"
+    "#{real}#{'+' unless imaginary < 0}#{imaginary}i"
   end
 
   def +@
@@ -56,7 +56,7 @@ class Complex < Numeric
     if rhs.is_a? Complex
       real == rhs.real && imaginary == rhs.imaginary
     elsif rhs.is_a? Numeric
-      imaginary.zero? && real == rhs
+      imaginary == 0 && real == rhs
     end
   end
 
@@ -104,16 +104,16 @@ class Complex < Numeric
 
   alias_method :imag, :imaginary
 
-  [Fixnum, Float].each do |cls|
+  [Integer, Float].each do |cls|
     [:+, :-, :*, :/, :==].each do |op|
-      cls.instance_exec do
-        original_operator_name = "__original_operator_#{op}_complex"
+      cls.instance_eval do
+        original_operator_name = :"__original_operator_#{op}_complex"
         alias_method original_operator_name, op
         define_method op do |rhs|
           if rhs.is_a? Complex
-            Complex(self).send(op, rhs)
+            Complex(self).__send__(op, rhs)
           else
-            send(original_operator_name, rhs)
+            __send__(original_operator_name, rhs)
           end
         end
       end

mrbgems/mruby-complex/src/complex.c

@@ -3,8 +3,8 @@
 #include <mruby/numeric.h>
 #include <math.h>
 
-#ifdef MRB_WITHOUT_FLOAT
-# error Complex conflicts 'MRB_WITHOUT_FLOAT' configuration in your 'build_config.rb'
+#ifdef MRB_NO_FLOAT
+# error Complex conflicts with 'MRB_NO_FLOAT' configuration
 #endif
 
 struct mrb_complex {
@@ -12,13 +12,13 @@ struct mrb_complex {
   mrb_float imaginary;
 };
 
-#ifdef MRB_USE_FLOAT
+#ifdef MRB_USE_FLOAT32
 #define F(x) x##f
 #else
 #define F(x) x
 #endif
 
-#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT)
+#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT32)
 
 #define COMPLEX_USE_ISTRUCT
 /* use TT_ISTRUCT */
@@ -69,7 +69,7 @@ complex_ptr(mrb_state *mrb, mrb_value v)
 static mrb_value
 complex_new(mrb_state *mrb, mrb_float real, mrb_float imaginary)
 {
-  struct RClass *c = mrb_class_get(mrb, "Complex");
+  struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Complex));
   struct mrb_complex *p;
   struct RBasic *comp = complex_alloc(mrb, c, &p);
   p->real = real;
@@ -122,7 +122,7 @@ complex_to_i(mrb_state *mrb, mrb_value self)
   if (p->imaginary != 0) {
     mrb_raisef(mrb, E_RANGE_ERROR, "can't convert %v into Float", self);
   }
-  return mrb_int_value(mrb, p->real);
+  return mrb_int_value(mrb, (mrb_int)p->real);
 }
 
 static mrb_value
@@ -174,7 +174,7 @@ div_pair(struct float_pair *q, struct float_pair const *a,
 static mrb_value
 complex_div(mrb_state *mrb, mrb_value self)
 {
-  mrb_value rhs;
+  mrb_value rhs = mrb_get_arg1(mrb);
   struct mrb_complex *a, *b;
   struct float_pair ar, ai, br, bi;
   struct float_pair br2, bi2;
@@ -183,7 +183,6 @@ complex_div(mrb_state *mrb, mrb_value self)
   struct float_pair ai_br, ar_bi;
   struct float_pair zr, zi;
 
-  mrb_get_args(mrb, "o", &rhs);
   a = complex_ptr(mrb, self);
   b = complex_ptr(mrb, rhs);
 
@@ -225,7 +224,7 @@ void mrb_mruby_complex_gem_init(mrb_state *mrb)
 #ifdef COMPLEX_USE_ISTRUCT
   mrb_assert(sizeof(struct mrb_complex) < ISTRUCT_DATA_SIZE);
 #endif
-  comp = mrb_define_class(mrb, "Complex", mrb_class_get(mrb, "Numeric"));
+  comp = mrb_define_class(mrb, "Complex", mrb_class_get_id(mrb, MRB_SYM(Numeric)));
 #ifdef COMPLEX_USE_ISTRUCT
   MRB_SET_INSTANCE_TT(comp, MRB_TT_ISTRUCT);
 #else

mrbgems/mruby-complex/test/complex.rb

@@ -56,11 +56,11 @@ end
 assert 'Complex#/' do
   assert_complex Complex(2, 3)  / Complex(2, 3) , (1                  + 0i)
   assert_complex Complex(900)   / Complex(1)    , (900                + 0i)
-  assert_complex Complex(-2, 9) / Complex(-9, 2), ((36 / 85)          - (77i / 85))
-  assert_complex Complex(9, 8)  / 4             , ((9 / 4)            + 2i)
+  assert_complex Complex(-2, 9) / Complex(-9, 2), ((36.0 / 85)        - (77i / 85))
+  assert_complex Complex(9, 8)  / 4             , ((9.0 / 4)          + 2i)
   assert_complex Complex(20, 9) / 9.8           , (2.0408163265306123 + 0.9183673469387754i)
   if 1e39.infinite? then
-    # MRB_USE_FLOAT in effect
+    # MRB_USE_FLOAT32 in effect
     ten = 1e21
     one = 1e20
   else
@@ -80,7 +80,7 @@ assert 'Complex#abs' do
   assert_float Complex(-1).abs,        1
   assert_float Complex(3.0, -4.0).abs, 5.0
   if 1e39.infinite? then
-    # MRB_USE_FLOAT in effect
+    # MRB_USE_FLOAT32 in effect
     exp = 125
   else
     exp = 1021

mrbgems/mruby-enumerator/mrblib/enumerator.rb

@@ -130,6 +130,7 @@ class Enumerator
     @feedvalue = nil
     @stop_exc = false
   end
+
   attr_accessor :obj, :meth, :args
   attr_reader :fib
 

mrbgems/mruby-enumerator/test/enumerator.rb

@@ -445,7 +445,7 @@ assert 'modifying existing methods' do
   }
 end
 
-assert 'Integral#times' do
+assert 'Integer#times' do
   a = 3
   b = a.times
   c = []

mrbgems/mruby-error/src/exception.c

@@ -8,7 +8,7 @@ mrb_protect(mrb_state *mrb, mrb_func_t body, mrb_value data, mrb_bool *state)
   struct mrb_jmpbuf *prev_jmp = mrb->jmp;
   struct mrb_jmpbuf c_jmp;
   mrb_value result = mrb_nil_value();
-  mrb_int ai = mrb_gc_arena_save(mrb);
+  int ai = mrb_gc_arena_save(mrb);
 
   if (state) { *state = FALSE; }
 
@@ -34,7 +34,7 @@ mrb_ensure(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_func_t ensure,
   struct mrb_jmpbuf *prev_jmp = mrb->jmp;
   struct mrb_jmpbuf c_jmp;
   mrb_value result;
-  mrb_int ai = mrb_gc_arena_save(mrb);
+  int ai = mrb_gc_arena_save(mrb);
 
   MRB_TRY(&c_jmp) {
     mrb->jmp = &c_jmp;
@@ -71,7 +71,7 @@ mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_fun
   mrb_value result;
   mrb_bool error_matched = FALSE;
   mrb_int i;
-  mrb_int ai = mrb_gc_arena_save(mrb);
+  int ai = mrb_gc_arena_save(mrb);
 
   MRB_TRY(&c_jmp) {
     mrb->jmp = &c_jmp;

mrbgems/mruby-eval/src/eval.c

@@ -9,221 +9,10 @@
 mrb_value mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p);
 mrb_value mrb_obj_instance_eval(mrb_state *mrb, mrb_value self);
 
-static struct mrb_irep *
-get_closure_irep(mrb_state *mrb, int level)
-{
-  struct RProc *proc = mrb->c->ci[-1].proc;
-
-  while (level--) {
-    if (!proc) return NULL;
-    proc = proc->upper;
-  }
-  if (!proc) return NULL;
-  if (MRB_PROC_CFUNC_P(proc)) {
-    return NULL;
-  }
-  return proc->body.irep;
-}
-
-/* search for irep lev above the bottom */
-static mrb_irep*
-search_irep(mrb_irep *top, int bnest, int lev, mrb_irep *bottom)
-{
-  int i;
-
-  for (i=0; i<top->rlen; i++) {
-    mrb_irep* tmp = top->reps[i];
-
-    if (tmp == bottom) return top;
-    tmp = search_irep(tmp, bnest-1, lev, bottom);
-    if (tmp) {
-      if (bnest == lev) return top;
-      return tmp;
-    }
-  }
-  return NULL;
-}
-
-static uint16_t
-search_variable(mrb_state *mrb, mrb_sym vsym, int bnest)
-{
-  mrb_irep *virep;
-  int level;
-  int pos;
-
-  for (level = 0; (virep = get_closure_irep(mrb, level)); level++) {
-    if (virep->lv == NULL) {
-      continue;
-    }
-    for (pos = 0; pos < virep->nlocals - 1; pos++) {
-      if (vsym == virep->lv[pos].name) {
-        return (pos+1)<<8 | (level+bnest);
-      }
-    }
-  }
-
-  return 0;
-}
-
-static int
-irep_argc(mrb_irep *irep)
-{
-  mrb_code c;
-
-  c = irep->iseq[0];
-  if (c == OP_ENTER) {
-    mrb_aspec ax = PEEK_W(irep->iseq+1);
-    /* extra 1 means a slot for block */
-    return MRB_ASPEC_REQ(ax)+MRB_ASPEC_OPT(ax)+MRB_ASPEC_REST(ax)+MRB_ASPEC_POST(ax)+1;
-  }
-  return 0;
-}
-
-static mrb_bool
-potential_upvar_p(struct mrb_locals *lv, uint16_t v, int argc, uint16_t nlocals)
-{
-  if (v >= nlocals) return FALSE;
-  /* skip arguments  */
-  if (v < argc+1) return FALSE;
-  return TRUE;
-}
-
-extern uint8_t mrb_insn_size[];
-extern uint8_t mrb_insn_size1[];
-extern uint8_t mrb_insn_size2[];
-extern uint8_t mrb_insn_size3[];
-
-static void
-patch_irep(mrb_state *mrb, mrb_irep *irep, int bnest, mrb_irep *top)
-{
-  int i;
-  uint32_t a;
-  uint16_t b;
-  uint8_t c;
-  mrb_code insn;
-  int argc = irep_argc(irep);
-  mrb_code *iseq = (mrb_code *)irep->iseq;
-
-  mrb_assert((irep->flags & MRB_ISEQ_NO_FREE) == 0);
-
-  for (i = 0; i < irep->ilen; ) {
-    insn = iseq[i];
-    switch(insn){
-    case OP_EPUSH:
-      b = PEEK_S(iseq+i+1);
-      patch_irep(mrb, irep->reps[b], bnest + 1, top);
-      break;
-
-    case OP_LAMBDA:
-    case OP_BLOCK:
-      a = PEEK_B(iseq+i+1);
-      b = PEEK_B(iseq+i+2);
-      patch_irep(mrb, irep->reps[b], bnest + 1, top);
-      break;
-
-    case OP_SEND:
-      b = PEEK_B(iseq+i+2);
-      c = PEEK_B(iseq+i+3);
-      if (c != 0) {
-        break;
-      }
-      else {
-        uint16_t arg = search_variable(mrb, irep->syms[b], bnest);
-        if (arg != 0) {
-          /* must replace */
-          iseq[i] = OP_GETUPVAR;
-          iseq[i+2] = arg >> 8;
-          iseq[i+3] = arg & 0xff;
-        }
-      }
-      break;
-
-    case OP_MOVE:
-      a = PEEK_B(iseq+i+1);
-      b = PEEK_B(iseq+i+2);
-      /* src part */
-      if (potential_upvar_p(irep->lv, b, argc, irep->nlocals)) {
-        uint16_t arg = search_variable(mrb, irep->lv[b - 1].name, bnest);
-        if (arg != 0) {
-          /* must replace */
-          iseq[i] = insn = OP_GETUPVAR;
-          iseq[i+2] = arg >> 8;
-          iseq[i+3] = arg & 0xff;
-        }
-      }
-      /* dst part */
-      if (potential_upvar_p(irep->lv, a, argc, irep->nlocals)) {
-        uint16_t arg = search_variable(mrb, irep->lv[a - 1].name, bnest);
-        if (arg != 0) {
-          /* must replace */
-          iseq[i] = insn = OP_SETUPVAR;
-          iseq[i+1] = (mrb_code)b;
-          iseq[i+2] = arg >> 8;
-          iseq[i+3] = arg & 0xff;
-        }
-      }
-      break;
-
-    case OP_GETUPVAR:
-      a = PEEK_B(iseq+i+1);
-      b = PEEK_B(iseq+i+2);
-      c = PEEK_B(iseq+i+3);
-      {
-        int lev = c+1;
-        mrb_irep *tmp = search_irep(top, bnest, lev, irep);
-        if (potential_upvar_p(tmp->lv, b, irep_argc(tmp), tmp->nlocals)) {
-          uint16_t arg = search_variable(mrb, tmp->lv[b-1].name, bnest);
-          if (arg != 0) {
-            /* must replace */
-            iseq[i] = OP_GETUPVAR;
-            iseq[i+2] = arg >> 8;
-            iseq[i+3] = arg & 0xff;
-          }
-        }
-      }
-      break;
-
-    case OP_SETUPVAR:
-      a = PEEK_B(iseq+i+1);
-      b = PEEK_B(iseq+i+2);
-      c = PEEK_B(iseq+i+3);
-      {
-        int lev = c+1;
-        mrb_irep *tmp = search_irep(top, bnest, lev, irep);
-        if (potential_upvar_p(tmp->lv, b, irep_argc(tmp), tmp->nlocals)) {
-          uint16_t arg = search_variable(mrb, tmp->lv[b-1].name, bnest);
-          if (arg != 0) {
-            /* must replace */
-            iseq[i] = OP_SETUPVAR;
-            iseq[i+1] = a;
-            iseq[i+2] = arg >> 8;
-            iseq[i+3] = arg & 0xff;
-          }
-        }
-      }
-      break;
-
-    case OP_EXT1:
-      insn = PEEK_B(iseq+i+1);
-      i += mrb_insn_size1[insn]+1;
-      continue;
-    case OP_EXT2:
-      insn = PEEK_B(iseq+i+1);
-      i += mrb_insn_size2[insn]+1;
-      continue;
-    case OP_EXT3:
-      insn = PEEK_B(iseq+i+1);
-      i += mrb_insn_size3[insn]+1;
-      continue;
-    }
-    i+=mrb_insn_size[insn];
-  }
-}
-
 void mrb_codedump_all(mrb_state*, struct RProc*);
 
 static struct RProc*
-create_proc_from_string(mrb_state *mrb, char *s, mrb_int len, mrb_value binding, const char *file, mrb_int line)
+create_proc_from_string(mrb_state *mrb, const char *s, mrb_int len, mrb_value binding, const char *file, mrb_int line)
 {
   mrbc_context *cxt;
   struct mrb_parser_state *p;
@@ -231,7 +20,7 @@ create_proc_from_string(mrb_state *mrb, char *s, mrb_int len, mrb_value binding,
   struct REnv *e;
   mrb_callinfo *ci; /* callinfo of eval caller */
   struct RClass *target_class = NULL;
-  int bidx;
+  mrb_int bidx;
 
   if (!mrb_nil_p(binding)) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "Binding of eval must be nil.");
@@ -243,7 +32,8 @@ create_proc_from_string(mrb_state *mrb, char *s, mrb_int len, mrb_value binding,
   mrbc_filename(mrb, cxt, file ? file : "(eval)");
   cxt->capture_errors = TRUE;
   cxt->no_optimize = TRUE;
-  cxt->on_eval = TRUE;
+  ci = (mrb->c->ci > mrb->c->cibase) ? mrb->c->ci - 1 : mrb->c->cibase;
+  cxt->upper = ci->proc && MRB_PROC_CFUNC_P(ci->proc) ? NULL : ci->proc;
 
   p = mrb_parse_nstring(mrb, s, len, cxt);
 
@@ -298,7 +88,7 @@ create_proc_from_string(mrb_state *mrb, char *s, mrb_int len, mrb_value binding,
       e->mid = ci->mid;
       e->stack = ci[1].stackent;
       e->cxt = mrb->c;
-      MRB_ENV_SET_STACK_LEN(e, ci->proc->body.irep->nlocals);
+      MRB_ENV_SET_LEN(e, ci->proc->body.irep->nlocals);
       bidx = ci->argc;
       if (ci->argc < 0) bidx = 2;
       else bidx += 1;
@@ -311,7 +101,6 @@ create_proc_from_string(mrb_state *mrb, char *s, mrb_int len, mrb_value binding,
   }
   proc->upper = ci->proc;
   mrb->c->ci->target_class = target_class;
-  patch_irep(mrb, proc->body.irep, 0, proc->body.irep);
   /* mrb_codedump_all(mrb, proc); */
 
   mrb_parser_free(p);
@@ -342,10 +131,10 @@ exec_irep(mrb_state *mrb, mrb_value self, struct RProc *proc)
 static mrb_value
 f_eval(mrb_state *mrb, mrb_value self)
 {
-  char *s;
+  const char *s;
   mrb_int len;
   mrb_value binding = mrb_nil_value();
-  char *file = NULL;
+  const char *file = NULL;
   mrb_int line = 1;
   struct RProc *proc;
 
@@ -365,9 +154,9 @@ f_instance_eval(mrb_state *mrb, mrb_value self)
   mrb_get_args(mrb, "*!&", &argv, &argc, &b);
 
   if (mrb_nil_p(b)) {
-    char *s;
+    const char *s;
     mrb_int len;
-    char *file = NULL;
+    const char *file = NULL;
     mrb_int line = 1;
     mrb_value cv;
     struct RProc *proc;
@@ -390,7 +179,7 @@ void
 mrb_mruby_eval_gem_init(mrb_state* mrb)
 {
   mrb_define_module_function(mrb, mrb->kernel_module, "eval", f_eval, MRB_ARGS_ARG(1, 3));
-  mrb_define_method(mrb, mrb_class_get(mrb, "BasicObject"), "instance_eval", f_instance_eval, MRB_ARGS_ARG(1, 2));
+  mrb_define_method(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), "instance_eval", f_instance_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
 }
 
 void

mrbgems/mruby-eval/test/eval.rb

@@ -130,3 +130,24 @@ Proc.new { foo }
 EOS
   }
 end
+
+assert('Calling the same method as the variable name') do
+  hoge = Object.new
+  def hoge.fuga
+    "Hit!"
+  end
+  assert_equal("Hit!") { fuga = "Miss!"; eval "hoge.fuga" }
+  assert_equal("Hit!") { fuga = "Miss!"; -> { eval "hoge.fuga" }.call }
+  assert_equal("Hit!") { -> { fuga = "Miss!"; eval "hoge.fuga" }.call }
+  assert_equal("Hit!") { fuga = "Miss!"; eval("-> { hoge.fuga }").call }
+end
+
+assert('Access numbered parameter from eval') do
+  hoge = Object.new
+  def hoge.fuga(a, &b)
+    b.call(a)
+  end
+  assert_equal(6) {
+    hoge.fuga(3) { _1 + eval("_1") }
+  }
+end

mrbgems/mruby-exit/src/mruby-exit.c

@@ -4,12 +4,17 @@
 static mrb_value
 f_exit(mrb_state *mrb, mrb_value self)
 {
-  mrb_int i = EXIT_SUCCESS;
+  mrb_value status = mrb_true_value();
+  int istatus;
+
+  mrb_get_args(mrb, "|o", &status);
+  istatus = mrb_true_p(status) ? EXIT_SUCCESS :
+            mrb_false_p(status) ? EXIT_FAILURE :
+            (int)mrb_int(mrb, status);
+  exit(istatus);
 
-  mrb_get_args(mrb, "|i", &i);
-  exit((int)i);
   /* not reached */
-  return mrb_nil_value();
+  return status;
 }
 
 void