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

@@ -1,13 +1,13 @@
-# /
+*.lock
 *.bak
+*.bc
 *.d
+*.i
 *.o
-/benchmark/**/*.dat
-/benchmark/*.pdf
-/benchmark/*.png
 *.orig
 *.pdb
 *.rej
+*.s
 *.sav
 *.swp
 *.tmp
@@ -15,13 +15,23 @@
 .DS_Store
 .ccmalloc
 .svn
-/.git
+.vscode
+.yardoc
+.ccls*
+compile_flags.txt
+compile_commands.json
 cscope.files
 cscope.out
 tags
-/src/y.tab.c
+
+/.git
 /bin
 /build
 /mruby-source-*.gem
-doc/api
-.yardoc
+
+/benchmark/**/*.dat
+/benchmark/*.pdf
+/benchmark/*.png
+
+/doc/api
+/doc/capi

.travis.yml

@@ -1,20 +1,14 @@
 language: c
 
-sudo: false
-
-matrix:
-  include:
-    - os: linux
-      sudo: 9000
-    - 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
-env: MRUBY_CONFIG=travis_config.rb
-script: "./minirake all test"
+  - MRUBY_TARGET=travis
+
+script:
+  - rake gensym && rake -m && rake test

.yardopts

@@ -12,6 +12,6 @@ mrbgems/*/mrblib/**/*.rb
 mrbgems/*/include/**/*.h
 -
 AUTHORS
-MITL
+LICENSE
 CONTRIBUTING.md
 doc/guides/*.md

AUTHORS

@@ -1,5 +1,8 @@
-Original Authors "mruby developers" are:
-   Yukihiro Matsumoto
+This is the (likely incomplete) list of "mruby developers".
+If you submit a patch to mruby, please add your name to the end
+of this list.
+
+   Yukihiro Matsumoto (Matz)
    SCSK KYUSHU CORPORATION
    Kyushu Institute of Technology
    Network Applied Communication Laboratory, Inc.
@@ -38,3 +41,6 @@ Original Authors "mruby developers" are:
    Christopher Aue
    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
@@ -33,9 +33,16 @@ mruby should be highly portable to other systems and compilers. For this it is
 recommended to keep your code as close as possible to the C99 standard
 (http://www.open-std.org/jtc1/sc22/WG14/www/docs/n1256.pdf).
 
-Although we target C99, Visual C++ is also an important target for mruby. For
-this reason a declaration of a local variable has to be at the beginning of a
-scope block.
+Although we target C99, we've heard some compilers in the embedded environment
+still requires declarations of local variables to be at the beginning of a
+scope. Until we confirm the situation has changed, we use the old-style
+variable declaration.
+
+Visual C++ is also an important target for mruby (supported version is 2013 or
+later). For this reason features that are not supported by Visual C++ may not
+be used (e.g. `%z` of `strftime()`).
+
+NOTE: Old GCC requires `-std=gnu99` option to enable C99 support.
 
 #### Reduce library dependencies to a minimum
 
@@ -49,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)
@@ -65,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.

LEGAL

@@ -2,5 +2,5 @@ LEGAL NOTICE INFORMATION
 ------------------------
 
 All the files in this distribution are covered under the MIT license
-(see the file MITL) except some files mentioned below:
+(see the file LICENSE) except some files mentioned below:
 

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2018 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

@@ -3,7 +3,7 @@
 ## What is mruby
 
 mruby is the lightweight implementation of the Ruby language complying to (part
-of) the [ISO standard][ISO-standard]. Its syntax is Ruby 1.9 compatible.
+of) the [ISO standard][ISO-standard]. Its syntax is Ruby 2.x compatible.
 
 mruby can be linked and embedded within your application.  We provide the
 interpreter program "mruby" and the interactive mruby shell "mirb" as examples.
@@ -17,7 +17,9 @@ of the Ministry of Economy, Trade and Industry of Japan.
 
 ## How to get mruby
 
-The stable version 1.4.1 of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/archive/1.4.1.zip](https://github.com/mruby/mruby/archive/1.4.1.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,36 +32,51 @@ 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 [doc/guides/compile.md](doc/guides/compile.md) file.
+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
+
+There are two sets of documentation in mruby: the mruby API (generated by yard) and C API (Doxygen)
+
+To build both of them, simply go
+
+    rake doc
+
+You can also view them in your browser
+
+    rake view_api
+    rake view_capi
 
 ## How to customize mruby (mrbgems)
 
 mruby contains a package manager called *mrbgems*. To create extensions
 in C and/or Ruby you should create a *GEM*. For a documentation of how to
-use mrbgems consult the file [doc/guides/mrbgems.md](doc/guides/mrbgems.md). For example code of
-how to use mrbgems look into the folder *examples/mrbgems/*.
+use mrbgems consult the file [mrbgems.md](https://github.com/mruby/mruby/blob/master/doc/guides/mrbgems.md).
+For example code of how to use mrbgems look into the folder *examples/mrbgems/*.
 
 ## License
 
-mruby is released under the [MIT License](MITL).
+mruby is released under the [MIT License](https://github.com/mruby/mruby/blob/master/LICENSE).
 
 ## Note for License
 
@@ -88,5 +105,5 @@ file in your pull request.
 
 [ISO-standard]: http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=59579
 [build-status-img]: https://travis-ci.org/mruby/mruby.svg?branch=master
-[contribution-guidelines]: CONTRIBUTING.md
+[contribution-guidelines]: https://github.com/mruby/mruby/blob/master/CONTRIBUTING.md
 [travis-ci]: https://travis-ci.org/mruby/mruby

Rakefile

@@ -5,15 +5,22 @@ 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
 require "mruby-core-ext"
 require "mruby/build"
-require "mruby/gem"
 
 # 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
@@ -31,24 +38,33 @@ load "#{MRUBY_ROOT}/tasks/libmruby.rake"
 load "#{MRUBY_ROOT}/tasks/benchmark.rake"
 
 load "#{MRUBY_ROOT}/tasks/gitlab.rake"
+load "#{MRUBY_ROOT}/tasks/doc.rake"
+
+def install_D(src, dst)
+  rm_f dst
+  mkdir_p File.dirname(dst)
+  cp src, dst
+end
 
 ##############################
 # generic build targets, rules
 task :default => :all
 
 bin_path = ENV['INSTALL_DIR'] || "#{MRUBY_ROOT}/bin"
-FileUtils.mkdir_p bin_path, { :verbose => $verbose }
 
-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|
-    FileUtils.rm_f t.name, { :verbose => $verbose }
-    FileUtils.cp t.prerequisites.first, t.name, { :verbose => $verbose }
+    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|
@@ -57,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
 
@@ -65,7 +81,7 @@ MRuby.each_target do |target|
       exec = exefile("#{build_dir}/bin/#{bin}")
       objs = Dir.glob("#{current_dir}/tools/#{bin}/*.{c,cpp,cxx,cc}").map { |f| objfile(f.pathmap("#{current_build_dir}/tools/#{bin}/%n")) }
 
-      file exec => objs + [libfile("#{build_dir}/lib/libmruby")] do |t|
+      file exec => objs + target.libraries do |t|
         gem_flags = gems.map { |g| g.linker.flags }
         gem_flags_before_libraries = gems.map { |g| g.linker.flags_before_libraries }
         gem_flags_after_libraries = gems.map { |g| g.linker.flags_after_libraries }
@@ -78,20 +94,9 @@ MRuby.each_target do |target|
         install_path = MRuby.targets['host'].exefile("#{bin_path}/#{bin}")
 
         file install_path => exec do |t|
-          FileUtils.rm_f t.name, { :verbose => $verbose }
-          FileUtils.cp t.prerequisites.first, t.name, { :verbose => $verbose }
+          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|
-            FileUtils.rm_f t.name, { :verbose => $verbose }
-            FileUtils.cp t.prerequisites.first, t.name, { :verbose => $verbose }
-          end
-          depfiles += [ install_path ]
-        end
       else
         depfiles += [ exec ]
       end
@@ -99,8 +104,145 @@ 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.libfile("#{t.build_dir}/lib/libmruby")]
+  t.libraries
 }.flatten
 
 depfiles += MRuby.targets.reject { |n, t| n == 'host' }.map { |n, t|
@@ -115,38 +257,44 @@ task :all => depfiles do
   MRuby.each_target do
     print_build_summary
   end
+  MRuby::Lockfile.write
 end
 
 desc "run all mruby tests"
-task :test => ["all"] do
-  MRuby.each_target do
-    run_test if test_enabled?
+task :test
+MRuby.each_target do
+  if test_enabled?
+    t = :"test_#{self.name}"
+    task t => ["all"] do
+      run_test
+    end
+    task :test => t
+  end
+
+  if bintest_enabled?
+    t = :"bintest_#{self.name}"
+    task t => ["all"] do
+      run_bintest
+    end
+    task :test => t
   end
 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"] do
+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
-
-desc 'generate document'
-task :doc do
-  begin
-    sh "mrbdoc"
-  rescue
-    puts "ERROR: To generate documents, you should install yard-mruby gem."
-    puts "  $ gem install yard-mruby"
-  end
-end

TODO

@@ -2,8 +2,6 @@ Things to do (Things that are not done yet)
 
 * special variables ($1,$2..)
 * super in aliased methods
-* multi-assignment decomposing
-* keyword arguments in def statement
 
 Things to improve (Done but things to fix)
 

appveyor.yml

@@ -1,38 +1,46 @@
 version: "{build}"
 
-os: Visual Studio 2015
-
-clone_depth: 50
-
-
-cache:
-  - win_flex_bison-2.5.10.zip
-
+shallow_clone: true
 
 environment:
   matrix:
-    # Visual Studio 2015 64bit
-    - visualcpp: C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat
-      machine: amd64
+    - 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 2013 64bit
-    - visualcpp: C:\Program Files (x86)\Microsoft Visual Studio 12.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
 
+    - 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-2.5.10.zip 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 > nul
-
-
 build_script:
-  - set YACC=.\win_flex_bison\win_bison.exe
-  - set MRUBY_CONFIG=appveyor_config.rb
-  - ruby .\minirake test all
+  - 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

benchmark/bm_app_lc_fizzbuzz.rb

@@ -48,5 +48,4 @@ answer = to_array(solution).map do |p|
   to_string(p)
 end
 
-answer_str = answer.to_a
-# puts answer_str
+# puts answer

build_config.rb

@@ -1,151 +0,0 @@
-MRuby::Build.new do |conf|
-  # load specific toolchain settings
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # Use mrbgems
-  # conf.gem 'examples/mrbgems/ruby_extension_example'
-  # conf.gem 'examples/mrbgems/c_extension_example' do |g|
-  #   g.cc.flags << '-g' # append cflags in this gem
-  # end
-  # conf.gem 'examples/mrbgems/c_and_ruby_extension_example'
-  # conf.gem :core => 'mruby-eval'
-  # conf.gem :mgem => 'mruby-io'
-  # conf.gem :github => 'iij/mruby-io'
-  # conf.gem :git => 'git@github.com:iij/mruby-io.git', :branch => 'master', :options => '-v'
-
-  # include the default GEMs
-  conf.gembox 'default'
-  # C compiler settings
-  # conf.cc do |cc|
-  #   cc.command = ENV['CC'] || 'gcc'
-  #   cc.flags = [ENV['CFLAGS'] || %w()]
-  #   cc.include_paths = ["#{root}/include"]
-  #   cc.defines = %w(DISABLE_GEMS)
-  #   cc.option_include_path = '-I%s'
-  #   cc.option_define = '-D%s'
-  #   cc.compile_options = "%{flags} -MMD -o %{outfile} -c %{infile}"
-  # end
-
-  # mrbc settings
-  # conf.mrbc do |mrbc|
-  #   mrbc.compile_options = "-g -B%{funcname} -o-" # The -g option is required for line numbers
-  # end
-
-  # Linker settings
-  # conf.linker do |linker|
-  #   linker.command = ENV['LD'] || 'gcc'
-  #   linker.flags = [ENV['LDFLAGS'] || []]
-  #   linker.flags_before_libraries = []
-  #   linker.libraries = %w()
-  #   linker.flags_after_libraries = []
-  #   linker.library_paths = []
-  #   linker.option_library = '-l%s'
-  #   linker.option_library_path = '-L%s'
-  #   linker.link_options = "%{flags} -o %{outfile} %{objs} %{libs}"
-  # end
-
-  # Archiver settings
-  # conf.archiver do |archiver|
-  #   archiver.command = ENV['AR'] || 'ar'
-  #   archiver.archive_options = 'rs %{outfile} %{objs}'
-  # end
-
-  # Parser generator settings
-  # conf.yacc do |yacc|
-  #   yacc.command = ENV['YACC'] || 'bison'
-  #   yacc.compile_options = '-o %{outfile} %{infile}'
-  # end
-
-  # gperf settings
-  # conf.gperf do |gperf|
-  #   gperf.command = 'gperf'
-  #   gperf.compile_options = '-L ANSI-C -C -p -j1 -i 1 -g -o -t -N mrb_reserved_word -k"1,3,$" %{infile} > %{outfile}'
-  # end
-
-  # file extensions
-  # conf.exts do |exts|
-  #   exts.object = '.o'
-  #   exts.executable = '' # '.exe' if Windows
-  #   exts.library = '.a'
-  # end
-
-  # file separetor
-  # conf.file_separator = '/'
-
-  # bintest
-  # conf.enable_bintest
-end
-
-MRuby::Build.new('host-debug') do |conf|
-  # load specific toolchain settings
-
-  # 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'
-
-  # C compiler settings
-  conf.cc.defines = %w(MRB_ENABLE_DEBUG_HOOK)
-
-  # Generate mruby debugger command (require mruby-eval)
-  conf.gem :core => "mruby-bin-debugger"
-
-  # bintest
-  # conf.enable_bintest
-end
-
-MRuby::Build.new('test') do |conf|
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-  conf.enable_bintest
-  conf.enable_test
-
-  conf.gembox 'default'
-end
-
-#MRuby::Build.new('bench') do |conf|
-#  # Gets set by the VS command prompts.
-#  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-#    toolchain :visualcpp
-#  else
-#    toolchain :gcc
-#    conf.cc.flags << '-O3'
-#  end
-#
-#  conf.gembox 'default'
-#end
-
-# Define cross build settings
-# MRuby::CrossBuild.new('32bit') do |conf|
-#   toolchain :gcc
-#
-#   conf.cc.flags << "-m32"
-#   conf.linker.flags << "-m32"
-#
-#   conf.build_mrbtest_lib_only
-#
-#   conf.gem 'examples/mrbgems/c_and_ruby_extension_example'
-#
-#   conf.test_runner.command = 'env'
-# 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 (i.e. ```gcc```)
-* Linker (i.e. ```gcc```)
-* Archive utility (i.e. ```ar```)
-* Parser generator (i.e. ```bison```)
-* Ruby 1.8 or 1.9 (i.e. ```ruby``` or ```jruby```)
+* 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
 
@@ -79,25 +99,22 @@ toolchain :android
 ```
 
 Requires the custom standalone Android NDK and the toolchain path
-in ```ANDROID_STANDALONE_TOOLCHAIN```.
+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
 
 Some environments require a different file separator character. It is possible to
-set the character via ```conf.file_separator```.
+set the character via `conf.file_separator`.
 ```ruby
 conf.file_separator = '/'
 ```
@@ -119,7 +136,7 @@ end
 
 C Compiler has header searcher to detect installed library.
 
-If you need a include path of header file use ```search_header_path```:
+If you need a include path of header file use `search_header_path`:
 ```ruby
 # Searches ```iconv.h```.
 # If found it will return include path of the header file.
@@ -127,7 +144,7 @@ If you need a include path of header file use ```search_header_path```:
 fail 'iconv.h not found' unless conf.cc.search_header_path 'iconv.h'
 ```
 
-If you need a full file name of header file use ```search_header```:
+If you need a full file name of header file use `search_header`:
 ```ruby
 # Searches ```iconv.h```.
 # If found it will return full path of the header file.
@@ -136,11 +153,11 @@ iconv_h = conf.cc.search_header 'iconv.h'
 print "iconv.h found: #{iconv_h}\n"
 ```
 
-Header searcher uses compiler's ```include_paths``` by default.
+Header searcher uses compiler's `include_paths` by default.
 When you are using GCC toolchain (including clang toolchain since its base is gcc toolchain)
-it will use compiler specific include paths too. (For example ```/usr/local/include```, ```/usr/include```)
+it will use compiler specific include paths too. (For example `/usr/local/include`, `/usr/include`)
 
-If you need a special header search paths define a singleton method ```header_search_paths``` to C compiler:
+If you need a special header search paths define a singleton method `header_search_paths` to C compiler:
 ```ruby
 def conf.cc.header_search_paths
   ['/opt/local/include'] + include_paths
@@ -205,24 +222,40 @@ 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
 
 Configuration Mrbtest build process.
 
-If you want mrbtest.a only, You should set ```conf.build_mrbtest_lib_only```
+If you want mrbtest.a only, You should set `conf.build_mrbtest_lib_only`
 ```ruby
 conf.build_mrbtest_lib_only
 ```
@@ -230,9 +263,9 @@ conf.build_mrbtest_lib_only
 ### Bintest
 
 Tests for mrbgem tools using CRuby.
-To have bintests place \*.rb scripts to ```bintest/``` directory of mrbgems.
-See ```mruby-bin-*/bintest/*.rb``` if you need examples.
-If you want a temporary files use `tempfile` module of CRuby instead of ```/tmp/```.
+To have bintests place \*.rb scripts to `bintest/` directory of mrbgems.
+See `mruby-bin-*/bintest/*.rb` if you need examples.
+If you want a temporary files use `tempfile` module of CRuby instead of `/tmp/`.
 
 You can enable it with following:
 ```ruby
@@ -247,8 +280,8 @@ correctly. To support mrbgems written in C++, mruby can be
 configured to use C++ exception.
 
 There are two levels of C++ exception handling. The one is
-```enable_cxx_exception``` that enables C++ exception, but
-uses C ABI. The other is ```enable_cxx_abi``` where all
+`enable_cxx_exception` that enables C++ exception, but
+uses C ABI. The other is `enable_cxx_abi` where all
 files are compiled by C++ compiler.
 
 When you mix C++ code, C++ exception would be enabled automatically.
@@ -266,7 +299,7 @@ C++ exception, add following:
 conf.disable_cxx_exception
 ```
 and you will get an error when you try to use C++ gem.
-Note that it must be called before ```enable_cxx_exception``` or ```gem``` method.
+Note that it must be called before `enable_cxx_exception` or `gem` method.
 
 ### Debugging mode
 
@@ -276,17 +309,17 @@ conf.enable_debug
 ```
 
 When debugging mode is enabled
-* Macro ```MRB_DEBUG``` would be defined.
-	* Which means ```mrb_assert()``` macro is enabled.
-* Debug information of irep would be generated by ```mrbc```.
-	* Because ```-g``` flag would be added to ```mrbc``` runner.
+* Macro `MRB_DEBUG` would be defined.
+	* Which means `mrb_assert()` macro is enabled.
+* Debug information of irep would be generated by `mrbc`.
+	* Because `-g` flag would be added to `mrbc` runner.
     * You can have better backtrace of mruby scripts with this.
 
 ## Cross-Compilation
 
 mruby can also be cross-compiled from one platform to another. To
 achieve this the *build_config.rb* needs to contain an instance of
-```MRuby::CrossBuild```. This instance defines the compilation
+`MRuby::CrossBuild`. This instance defines the compilation
 tools and flags for the target platform. An example could look
 like this:
 ```ruby
@@ -298,12 +331,12 @@ MRuby::CrossBuild.new('32bit') do |conf|
 end
 ```
 
-All configuration options of ```MRuby::Build``` can also be used
-in ```MRuby::CrossBuild```.
+All configuration options of `MRuby::Build` can also be used
+in `MRuby::CrossBuild`.
 
 ### Mrbtest in Cross-Compilation
 
-In cross compilation, you can run ```mrbtest``` on emulator if
+In cross compilation, you can run `mrbtest` on emulator if
 you have it by changing configuration of test runner.
 ```ruby
 conf.test_runner do |t|
@@ -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)
@@ -350,15 +387,15 @@ in *build/host/src*)
 result will be stored in *build/host/src/y.tab.c*)
 * compile  *build/host/src/y.tab.c* to  *build/host/src/y.tab.o*
 * create *build/host/lib/libmruby_core.a* out of all object files (C only)
-* create ```build/host/bin/mrbc``` by compiling *tools/mrbc/mrbc.c* and
+* create `build/host/bin/mrbc` by compiling *tools/mrbc/mrbc.c* and
 linking with *build/host/lib/libmruby_core.a*
 * create *build/host/mrblib/mrblib.c* by compiling all \*.rb files
-under *mrblib* with ```build/host/bin/mrbc```
+under *mrblib* with `build/host/bin/mrbc`
 * compile *build/host/mrblib/mrblib.c* to *build/host/mrblib/mrblib.o*
 * create *build/host/lib/libmruby.a* out of all object files (C and Ruby)
-* create ```build/host/bin/mruby``` by compiling *mrbgems/mruby-bin-mruby/tools/mruby/mruby.c* and
+* create `build/host/bin/mruby` by compiling *mrbgems/mruby-bin-mruby/tools/mruby/mruby.c* and
 linking with *build/host/lib/libmruby.a*
-* create ```build/host/bin/mirb``` by compiling *mrbgems/mruby-bin-mirb/tools/mirb/mirb.c* and
+* create `build/host/bin/mirb` by compiling *mrbgems/mruby-bin-mirb/tools/mirb/mirb.c* and
 linking with *build/host/lib/libmruby.a*
 
 ```
@@ -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
 	   |   |
@@ -427,15 +468,15 @@ in *build/i386/src*)
 result will be stored in *build/i386/src/y.tab.c*)
 * cross-compile *build/i386/src/y.tab.c* to *build/i386/src/y.tab.o*
 * create *build/i386/mrblib/mrblib.c* by compiling all \*.rb files
-under *mrblib* with the native ```build/host/bin/mrbc```
+under *mrblib* with the native `build/host/bin/mrbc`
 * cross-compile *build/host/mrblib/mrblib.c* to *build/host/mrblib/mrblib.o*
 * create *build/i386/lib/libmruby.a* out of all object files (C and Ruby)
-* create ```build/i386/bin/mruby``` by cross-compiling *mrbgems/mruby-bin-mruby/tools/mruby/mruby.c* and
+* create `build/i386/bin/mruby` by cross-compiling *mrbgems/mruby-bin-mruby/tools/mruby/mruby.c* and
 linking with *build/i386/lib/libmruby.a*
-* create ```build/i386/bin/mirb``` by cross-compiling *mrbgems/mruby-bin-mirb/tools/mirb/mirb.c* and
+* create `build/i386/bin/mirb` by cross-compiling *mrbgems/mruby-bin-mirb/tools/mirb/mirb.c* and
 linking with *build/i386/lib/libmruby.a*
 * create *build/i386/lib/libmruby_core.a* out of all object files (C only)
-* create ```build/i386/bin/mrbc``` by cross-compiling *tools/mrbc/mrbc.c* and
+* create `build/i386/bin/mrbc` by cross-compiling *tools/mrbc/mrbc.c* and
 linking with *build/i386/lib/libmruby_core.a*
 
 ```
@@ -463,7 +504,7 @@ linking with *build/i386/lib/libmruby_core.a*
 ### Minimal Library
 
 To build a minimal mruby library you need to use the Cross Compiling
-feature due to the reason that there are functions (i.e. stdio) which
+feature due to the reason that there are functions (e.g. stdio) which
 can't be disabled for the main build.
 
 ```ruby
@@ -477,12 +518,12 @@ end
 
 This configuration defines a cross compile build called 'Minimal' which
 is using the GCC and compiles for the host machine. It also disables
-all usages of stdio and doesn't compile any binaries (i.e. mrbc).
+all usages of stdio and doesn't compile any binaries (e.g. mrbc).
 
 ## Test Environment
 
 mruby's build process includes a test environment. In case you start the testing
-of mruby, a native binary called ```mrbtest``` will be generated and executed.
+of mruby, a native binary called `mrbtest` will be generated and executed.
 This binary contains all test cases which are defined under *test/t*. In case
 of a cross-compilation an additional cross-compiled *mrbtest* binary is
 generated. You can copy this binary and run on your target system.

doc/guides/debugger.md

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

doc/guides/mrbconf.md

@@ -46,19 +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_INT16`
-* When defined `int16_t` will be defined as `mrb_int`.
+`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_INT32`
+* 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 `int64_t` will be defined as `mrb_int`.
-* Conflicts with `MRB_INT16`.
-* When `MRB_INT16` or `MRB_INT64` isn't defined `int`(most of the times 32-bit integer)
-will be defined as `mrb_int`.
+* 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.
 
@@ -115,7 +117,7 @@ largest value of required alignment.
 
 `MRB_NAN_BOXING`
 * If defined represent `mrb_value` in boxed `double`.
-* Conflicts with `MRB_USE_FLOAT`.
+* Conflicts with `MRB_USE_FLOAT32` and `MRB_NO_FLOAT`.
 
 `MRB_WORD_BOXING`
 * If defined represent `mrb_value` as a word.
@@ -126,6 +128,22 @@ largest value of required alignment.
 * Default value is `4`.
 * Specifies size of each segment in segment list.
 
+## Reduce heap memory configuration.
+
+`MRB_USE_LINK_TIME_RO_DATA_P`
+* Only available on ELF platforms.
+* If you specify the address of a read-only section when creating a symbol or string, that string will be used as it is.
+* Heap memory can be saved.
+* Uses `__ehdr_start` and `__init_array_start`.
+* It must be `__ehdr_start < data_addr < __init_array_start`.
+
+`MRB_USE_CUSTOM_RO_DATA_P`
+* Takes precedence over `MRB_USE_LINK_TIME_RO_DATA_P`.
+* Please try if `MRB_USE_LINK_TIME_RO_DATA_P` is not available.
+* The `mrb_ro_data_p()` function is implemented by the user in an arbitrary file.
+* The prototype declaration is `mrb_bool mrb_ro_data_p(const char *ptr)`.
+* Return `TRUE` if `ptr` is in read-only section, otherwise return `FALSE`.
+
 ## Other configuration.
 `MRB_UTF8_STRING`
 * Adds UTF-8 encoding support to character-oriented String instance methods.
@@ -144,3 +162,20 @@ largest value of required alignment.
 `MRB_STR_BUF_MIN_SIZE`
 * Default value is `128`.
 * Specifies initial capacity of `RString` created by `mrb_str_buf_new` function..
+
+`MRB_NO_METHOD_CACHE`
+* Disable method cache to save memory.
+
+`MRB_METHOD_CACHE_SIZE`
+* Default value is `256`.
+* Ignored if `MRB_NO_METHOD_CACHE` is defined.
+* Need to be the power of 2.
+
+`MRB_USE_METHOD_T_STRUCT`
+* Use C struct to represent `mrb_method_t`
+* 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`
+* Make it available `Symbols.all_symbols` in `mrbgems/mruby-symbol-ext`
+* Increase heap memory usage.

doc/guides/mrbgems.md

@@ -37,11 +37,16 @@ conf.gem :mgem => 'mruby-yaml'
 conf.gem :mgem => 'yaml' # 'mruby-' prefix could be omitted
 ```
 
+For specifying commit hash to checkout use `:checksum_hash` option:
+```ruby
+conf.gem mgem: 'mruby-redis', checksum_hash: '3446d19fc4a3f9697b5ddbf2a904f301c42f2f4e'
+```
+
 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.
 
@@ -179,11 +184,11 @@ Version requirement supports following operators:
 
 When more than one version requirements is passed, the dependency must satisfy all of it.
 
-You can have default gem to use as depedency when it's not defined in *build_config.rb*.
+You can have default gem to use as dependency when it's not defined in *build_config.rb*.
 When the last argument of `add_dependency` call is `Hash`, it will be treated as default gem information.
 Its format is same as argument of method `MRuby::Build#gem`, expect that it can't be treated as path gem location.
 
-When a special version of depedency is required,
+When a special version of dependency is required,
 use `MRuby::Build#gem` in *build_config.rb* to override default gem.
 
 If you have conflicting GEMs use the following method:
@@ -230,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

@@ -14,17 +14,17 @@ This document does not contain a complete list of limitations.
 Please help to improve it by submitting your findings.
 
 
-## ```1/2``` gives ```0.5```
+## `1/2` gives `0.5`
 
-Since mruby does not have ```Bignum```, bigger integers are represented
-by ```Float``` numbers. To enhance interoperability between ```Fixnum```
-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```.
+Since mruby does not have `Bignum`, bigger integers are represented
+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`.
 
-## ```Array``` passed to ```puts```
+## `Array` passed to `puts`
 
-Passing an Array to ```puts``` results in different output.
+Passing an Array to `puts` results in different output.
 
 ```ruby
 puts [1,2,3]
@@ -38,15 +38,15 @@ puts [1,2,3]
 3
 ```
 
-#### mruby [1.4.1 (2018-4-27)]
+#### mruby [2.1.2 (2020-08-06)]
 
 ```
 [1, 2, 3]
 ```
 
-## ```Kernel.raise``` in rescue clause
+## `Kernel.raise` in rescue clause
 
-```Kernel.raise``` without arguments does not raise the current exception within
+`Kernel.raise` without arguments does not raise the current exception within
 a rescue clause.
 
 ```ruby
@@ -59,21 +59,28 @@ end
 
 #### Ruby [ruby 2.0.0p645 (2015-04-13 revision 50299)]
 
-```ZeroDivisionError``` is raised.
+`ZeroDivisionError` is raised.
 
-#### mruby [1.4.1 (2018-4-27)]
+#### 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
+mruby's `Fiber` is implemented in a similar way to Lua's co-routine. This
 results in the consequence that you can't switch context within C functions.
-Only exception is ```mrb_fiber_yield``` at return.
+Only exception is `mrb_fiber_yield` at return.
 
-## ```Array``` does not support instance variables
+## `Array` does not support instance variables
 
-To reduce memory consumption ```Array``` does not support instance variables.
+To reduce memory consumption `Array` does not support instance variables.
 
 ```ruby
 class Liste < Array
@@ -87,16 +94,16 @@ p Liste.new "foobar"
 
 #### Ruby [ruby 2.0.0p645 (2015-04-13 revision 50299)]
 
-``` [] ```
+` [] `
 
-#### mruby [1.4.1 (2018-4-27)]
+#### mruby [2.1.2 (2020-08-06)]
 
-```ArgumentError``` is raised.
+`ArgumentError` is raised.
 
 ## Method visibility
 
 For simplicity reasons no method visibility (public/private/protected) is
-supported.
+supported. Those methods are defined but they are dummy methods.
 
 ```ruby
 class VisibleTest
@@ -119,17 +126,53 @@ false
 true
 ```
 
-#### mruby [1.4.1 (2018-4-27)]
+#### mruby [2.1.2 (2020-08-06)]
 
 ```
 true
 true
 ```
 
-## defined?
+### Visibility Declaration
 
-The ```defined?``` keyword is considered too complex to be fully
-implemented. It is recommended to use ```const_defined?``` and
+The declaration form of following visibility methods are not implemented.
+
+* `public`
+* `private`
+* `protected`
+* `module_function`
+
+Especially, `module_function` method is not dummy, but no declaration form.
+
+```
+module TestModule
+  module_function
+  def test_func
+    p 'test_func called'
+  end
+
+  test_func
+end
+
+p 'ok'
+```
+
+#### Ruby [ruby 2.5.5p157 (2019-03-15 revision 67260)]
+
+```
+ok
+```
+
+#### mruby [2.1.2 (2020-08-06)]
+
+```
+test.rb:8: undefined method 'test_func' (NoMethodError)
+```
+
+## `defined?`
+
+The `defined?` keyword is considered too complex to be fully
+implemented. It is recommended to use `const_defined?` and
 other reflection methods instead.
 
 ```ruby
@@ -142,11 +185,11 @@ defined?(Foo)
 nil
 ```
 
-#### mruby [1.4.1 (2018-4-27)]
+#### mruby [2.1.2 (2020-08-06)]
 
-```NameError``` is raised.
+`NameError` is raised.
 
-## ```alias``` on global variables
+## `alias` on global variables
 
 Aliasing a global variable works in CRuby but is not part
 of the ISO standard.
@@ -157,9 +200,9 @@ alias $a $__a__
 
 #### Ruby [ruby 2.0.0p645 (2015-04-13 revision 50299)]
 
-``` nil ```
+` nil `
 
-#### mruby [1.4.1 (2018-4-27)]
+#### mruby [2.1.2 (2020-08-06)]
 
 Syntax error
 
@@ -178,10 +221,85 @@ end
 
 #### Ruby [ruby 2.0.0p645 (2015-04-13 revision 50299)]
 
-```ArgumentError``` is raised.
-The re-defined ```+``` operator does not accept any arguments.
+`ArgumentError` is raised.
+The re-defined `+` operator does not accept any arguments.
 
-#### mruby [1.4.1 (2018-4-27)]
+#### mruby [2.1.2 (2020-08-06)]
 
-``` 'ab' ```
+` 'ab' `
 Behavior of the operator wasn't changed.
+
+## `Kernel#binding` is not supported
+
+`Kernel#binding` method is not supported.
+
+#### Ruby [ruby 2.5.1p57 (2018-03-29 revision 63029)]
+
+```
+$ ruby -e 'puts Proc.new {}.binding'
+#<Binding:0x00000e9deabb9950>
+```
+
+#### mruby [2.1.2 (2020-08-06)]
+
+```
+$ ./bin/mruby -e 'puts Proc.new {}.binding'
+trace (most recent call last):
+        [0] -e:1
+-e:1: undefined method 'binding' (NoMethodError)
+```
+
+## Keyword arguments
+
+mruby keyword arguments behave slightly different from CRuby 2.5
+to make the behavior simpler and less confusing. 
+
+#### Ruby [ruby 2.5.1p57 (2018-03-29 revision 63029)]
+
+```
+$ ruby -e 'def m(*r,**k) p [r,k] end; m("a"=>1,:b=>2)'
+[[{"a"=>1}], {:b=>2}]
+```
+
+#### mruby [mruby 2.1.2]
+
+```
+$ ./bin/mruby -e 'def m(*r,**k) p [r,k] end; m("a"=>1,:b=>2)'
+trace (most recent call last):
+	[0] -e:1
+-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
+def m(a,(b,c),d); p [a,b,c,d]; end
+m(1,[2,3],4)  # => [1,2,3,4]
+```
+Destructured arguments (`b` and `c` in above example) cannot be accessed
+from the default expression of optional arguments and keyword arguments,
+since actual assignment is done after the evaluation of those default
+expressions. Thus:
+
+```ruby
+def f(a,(b,c),d=b)
+  p [a,b,c,d]
+end
+f(1,[2,3])
+```
+
+CRuby gives `[1,2,3,nil]`. mruby raises `NoMethodError` for `b`.

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

@@ -0,0 +1,126 @@
+# The new bytecode
+
+We will reimplement VM to use 8bit instruction code. By
+bytecode, we mean real byte code. The whole purpose is
+reducing the memory consumption of mruby VM.
+
+# Instructions
+
+Instructions are bytes. There can be 256 instructions. Currently we
+have 94 instructions. Instructions can take 0 to 3 operands.
+
+## operands
+
+The size of operands can be either 8bits, 16bits or 24bits.
+In the table.1 below, the second field describes the size (and
+sign) of operands.
+
+* B: 8bit
+* S: 16bit
+* sS: signed 16bit
+* W: 24bit
+
+## table.1 Instruction Table
+
+| 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,30 +25,73 @@
 #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
+/* obsolete configuration */
+#if defined(MRB_USE_FLOAT)
+# define MRB_USE_FLOAT32
+#endif
+
+/* 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<<7)
+//#define MRB_METHOD_CACHE_SIZE (1<<8)
 
-/* add -DMRB_METHOD_TABLE_INLINE to reduce the size of method table */
-/* MRB_METHOD_TABLE_INLINE requires LSB of function pointers to be zero */
-/* you might need to specify --falign-functions=n (where n>1) */
-//#define MRB_METHOD_TABLE_INLINE
+/* 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
 
-/* add -DMRB_INT16 to use 16bit integer for mrb_int; conflict with MRB_INT64 */
-//#define MRB_INT16
+/* define on big endian machines; used by MRB_NAN_BOXING, etc. */
+#ifndef MRB_ENDIAN_BIG
+# if (defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN) || \
+     (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#  define MRB_ENDIAN_BIG
+# endif
+#endif
 
-/* add -DMRB_INT64 to use 64bit integer for mrb_int; conflict with MRB_INT16 */
+/* 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_INT16) && !defined(MRB_INT32) && !defined(MRB_INT64)
+#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
@@ -58,14 +101,8 @@
 # endif
 #endif
 
-/* represent mrb_value in boxed double; conflict with MRB_USE_FLOAT and MRB_WITHOUT_FLOAT */
-//#define MRB_NAN_BOXING
-
-/* define on big endian machines; used by MRB_NAN_BOXING */
-//#define MRB_ENDIAN_BIG
-
-/* represent mrb_value as a word (natural unit of data for the processor) */
-//#define MRB_WORD_BOXING
+/* call malloc_trim(0) from mrb_full_gc() */
+//#define MRB_USE_MALLOC_TRIM
 
 /* string class to handle UTF-8 encoding */
 //#define MRB_UTF8_STRING
@@ -76,12 +113,13 @@
 /* number of object per heap page */
 //#define MRB_HEAP_PAGE_SIZE 1024
 
-/* if _etext and _edata available, mruby can reduce memory used by symbols */
-//#define MRB_USE_ETEXT_EDATA
+/* if __ehdr_start is available, mruby can reduce memory used by symbols */
+//#define MRB_USE_LINK_TIME_RO_DATA_P
 
-/* do not use __init_array_start to determine readonly data section;
-   effective only when MRB_USE_ETEXT_EDATA is defined */
-//#define MRB_NO_INIT_ARRAY_START
+/* if MRB_USE_LINK_TIME_RO_DATA_P does not work,
+   you can try mrb_ro_data_p() that you have implemented yourself in any file;
+   prototype is `mrb_bool mrb_ro_data_p(const char *ptr)` */
+//#define MRB_USE_CUSTOM_RO_DATA_P
 
 /* turn off generational GC by default */
 //#define MRB_GC_TURN_OFF_GENERATIONAL
@@ -115,6 +153,7 @@
 
 /* -DMRB_ENABLE_XXXX to enable following features */
 //#define MRB_ENABLE_DEBUG_HOOK /* hooks for debugger */
+//#define MRB_ENABLE_ALL_SYMBOLS /* Symbols.all_symbols */
 
 /* end of configuration */
 
@@ -140,4 +179,58 @@
 # define TRUE 1
 #endif
 
+/*
+** mruby tuning profiles
+**/
+
+/* 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
+
+# ifndef MRB_STR_BUF_MIN_SIZE
+#  define MRB_STR_BUF_MIN_SIZE 32
+# endif
+
+# ifndef MRB_HEAP_PAGE_SIZE
+#  define MRB_HEAP_PAGE_SIZE 256
+# endif
+
+/* A profile for default mruby */
+#elif defined(MRB_BASELINE_PROFILE)
+
+/* A profile for desktop computers or workstations; rich memory! */
+#elif defined(MRB_MAIN_PROFILE)
+# ifndef MRB_METHOD_CACHE_SIZE
+#  define MRB_METHOD_CACHE_SIZE (1<<10)
+# endif
+
+# ifndef MRB_IV_SEGMENT_SIZE
+#  define MRB_IV_SEGMENT_SIZE 32
+# endif
+
+# ifndef MRB_HEAP_PAGE_SIZE
+#  define MRB_HEAP_PAGE_SIZE 4096
+# endif
+
+/* A profile for server; mruby vm is long life */
+#elif defined(MRB_HIGH_PROFILE)
+# ifndef MRB_METHOD_CACHE_SIZE
+#  define MRB_METHOD_CACHE_SIZE (1<<12)
+# endif
+
+# ifndef MRB_IV_SEGMENT_SIZE
+#  define MRB_IV_SEGMENT_SIZE 64
+# endif
+
+# ifndef MRB_HEAP_PAGE_SIZE
+#  define MRB_HEAP_PAGE_SIZE 4096
+# endif
+#endif
+
 #endif  /* MRUBYCONF_H */

include/mruby/array.h

@@ -1,5 +1,5 @@
-/*
-** mruby/array.h - Array class
+/**
+** @file mruby/array.h - Array class
 **
 ** See Copyright Notice in mruby.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;
-    mrb_value embed[MRB_ARY_EMBED_LEN_MAX];
+#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) (&((a)->as.embed[0]))
-
+#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))
@@ -199,6 +216,7 @@ MRB_API void mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val
  * @param other The array to replace it with.
  */
 MRB_API void mrb_ary_replace(mrb_state *mrb, mrb_value self, mrb_value other);
+MRB_API mrb_value mrb_ensure_array_type(mrb_state *mrb, mrb_value self);
 MRB_API mrb_value mrb_check_array_type(mrb_state *mrb, mrb_value self);
 
 /*
@@ -226,6 +244,23 @@ MRB_API mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item
  */
 MRB_API mrb_value mrb_ary_entry(mrb_value ary, mrb_int offset);
 
+/*
+ * Replace subsequence of an array.
+ *
+ * Equivalent to:
+ *
+ *      ary.shift
+ *
+ * @param mrb The mruby state reference.
+ * @param self The array from which the value will be shifted.
+ * @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);
+
 /*
  * Shifts the first element from the array.
  *
@@ -274,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

@@ -1,5 +1,5 @@
-/*
-** mruby/boxing_nan.h - nan boxing mrb_value definition
+/**
+** @file mruby/boxing_nan.h - nan boxing mrb_value definition
 **
 ** See Copyright Notice in mruby.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,13 +20,7 @@
 #endif
 
 #define MRB_FIXNUM_SHIFT 0
-#define MRB_TT_HAS_BASIC MRB_TT_OBJECT
-
-#ifdef MRB_ENDIAN_BIG
-#define MRB_ENDIAN_LOHI(a,b) a b
-#else
-#define MRB_ENDIAN_LOHI(a,b) b a
-#endif
+#define MRB_SYMBOL_SHIFT 0
 
 /* value representation by nan-boxing:
  *   float : FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF
@@ -36,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

@@ -1,5 +1,5 @@
-/*
-** mruby/boxing_no.h - unboxed mrb_value definition
+/**
+** @file mruby/boxing_no.h - unboxed mrb_value definition
 **
 ** See Copyright Notice in mruby.h
 */
@@ -8,30 +8,29 @@
 #define MRUBY_BOXING_NO_H
 
 #define MRB_FIXNUM_SHIFT 0
-#define MRB_TT_HAS_BASIC MRB_TT_OBJECT
+#define MRB_SYMBOL_SHIFT 0
+
+union mrb_value_union {
+#ifndef MRB_NO_FLOAT
+  mrb_float f;
+#endif
+  void *p;
+  mrb_int i;
+  mrb_sym sym;
+};
 
 typedef struct mrb_value {
-  union {
-#ifndef MRB_WITHOUT_FLOAT
-    mrb_float f;
-#endif
-    void *p;
-    mrb_int i;
-    mrb_sym sym;
-  } value;
+  union mrb_value_union 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
 
@@ -44,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

@@ -1,5 +1,5 @@
-/*
-** mruby/boxing_word.h - word boxing mrb_value definition
+/**
+** @file mruby/boxing_word.h - word boxing mrb_value definition
 **
 ** See Copyright Notice in mruby.h
 */
@@ -7,130 +7,191 @@
 #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;
 };
 
-#define MRB_FIXNUM_SHIFT 1
-#ifdef MRB_WITHOUT_FLOAT
-#define MRB_TT_HAS_BASIC MRB_TT_CPTR
-#else
-#define MRB_TT_HAS_BASIC MRB_TT_FLOAT
-#endif
-
 enum mrb_special_consts {
-  MRB_Qnil    = 0,
-  MRB_Qfalse  = 2,
-  MRB_Qtrue   = 4,
-  MRB_Qundef  = 6,
+  MRB_Qnil    =  0,
+  MRB_Qfalse  =  4,
+  MRB_Qtrue   = 12,
+  MRB_Qundef  = 20,
 };
 
-#define MRB_FIXNUM_FLAG   0x01
-#define MRB_SYMBOL_FLAG   0x0e
-#define MRB_SPECIAL_SHIFT 8
-
-typedef union mrb_value {
-  union {
-    void *p;
-    struct {
-      unsigned int i_flag : MRB_FIXNUM_SHIFT;
-      mrb_int i : (MRB_INT_BIT - MRB_FIXNUM_SHIFT);
-    };
-    struct {
-      unsigned int sym_flag : MRB_SPECIAL_SHIFT;
-      mrb_sym sym : (sizeof(mrb_sym) * CHAR_BIT);
-    };
-    struct RBasic *bp;
-#ifndef MRB_WITHOUT_FLOAT
-    struct RFloat *fp;
+#if defined(MRB_64BIT) && defined(MRB_INT32)
+#define MRB_FIXNUM_SHIFT        0
+#else
+#define MRB_FIXNUM_SHIFT        BOXWORD_FIXNUM_SHIFT
 #endif
-    struct RCptr *vp;
-  } value;
-  unsigned long w;
-} mrb_value;
+#define MRB_SYMBOL_SHIFT        BOXWORD_SYMBOL_SHIFT
 
-MRB_API mrb_value mrb_word_boxing_cptr_value(struct mrb_state*, void*);
-#ifndef MRB_WITHOUT_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);
+#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
 
-#ifndef MRB_WITHOUT_FLOAT
-#define mrb_float_pool(mrb,f) mrb_word_boxing_float_pool(mrb,f)
+#define BOXWORD_SHIFT_VALUE(o,n,t) \
+  (t)(((intptr_t)(o)) >> BOXWORD_##n##_SHIFT)
+#define BOXWORD_SET_SHIFT_VALUE(o,n,v) \
+  ((o) = (((uintptr_t)(v)) << BOXWORD_##n##_SHIFT) | BOXWORD_##n##_FLAG)
+#define BOXWORD_SHIFT_VALUE_P(o,n) \
+  (((o) & BOXWORD_##n##_MASK) == BOXWORD_##n##_FLAG)
+#define BOXWORD_OBJ_TYPE_P(o,n) \
+  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
+
+/*
+ * mrb_value representation:
+ *
+ *   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 (use only upper 32-bit as symbol value on 64-bit CPU)
+ *   object: ...PPPP P000 (any bits are 1)
+ */
+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;
+    )
+  };
 #endif
-
-#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
+  struct RBasic *bp;
+#ifndef MRB_NO_FLOAT
+  struct RFloat *fp;
 #endif
-#define mrb_fixnum(o)  ((mrb_int)(o).value.i)
-#define mrb_symbol(o)  (o).value.sym
+  struct RInteger *ip;
+  struct RCptr *vp;
+  uintptr_t w;
+};
 
-static inline enum mrb_vtype
-mrb_type(mrb_value o)
+static inline union mrb_value_
+mrb_val_union(mrb_value v)
 {
-  switch (o.w) {
-  case MRB_Qfalse:
-  case MRB_Qnil:
-    return MRB_TT_FALSE;
-  case MRB_Qtrue:
-    return MRB_TT_TRUE;
-  case MRB_Qundef:
-    return MRB_TT_UNDEF;
-  }
-  if (o.value.i_flag == MRB_FIXNUM_FLAG) {
-    return MRB_TT_FIXNUM;
-  }
-  if (o.value.sym_flag == MRB_SYMBOL_FLAG) {
-    return MRB_TT_SYMBOL;
-  }
-  return o.value.bp->tt;
+  union mrb_value_ x;
+  x.w = v;
+  return x;
 }
 
-#define mrb_bool(o)    ((o).w != MRB_Qnil && (o).w != MRB_Qfalse)
-#define mrb_fixnum_p(o) ((o).value.i_flag == MRB_FIXNUM_FLAG)
-#define mrb_undef_p(o) ((o).w == MRB_Qundef)
-#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
-
-#define BOXWORD_SET_VALUE(o, ttt, attr, v) do { \
-  switch (ttt) {\
-  case MRB_TT_FALSE:  (o).w = (v) ? MRB_Qfalse : MRB_Qnil; break;\
-  case MRB_TT_TRUE:   (o).w = MRB_Qtrue; break;\
-  case MRB_TT_UNDEF:  (o).w = MRB_Qundef; break;\
-  case MRB_TT_FIXNUM: (o).w = 0;(o).value.i_flag = MRB_FIXNUM_FLAG; (o).attr = (v); break;\
-  case MRB_TT_SYMBOL: (o).w = 0;(o).value.sym_flag = MRB_SYMBOL_FLAG; (o).attr = (v); break;\
-  default:            (o).w = 0; (o).attr = (v); if ((o).value.bp) (o).value.bp->tt = ttt; break;\
-  }\
-} while (0)
-
-#ifndef MRB_WITHOUT_FLOAT
-#define SET_FLOAT_VALUE(mrb,r,v) r = mrb_word_boxing_float_value(mrb, v)
+MRB_API mrb_value mrb_word_boxing_cptr_value(struct mrb_state*, void*);
+#ifndef MRB_NO_FLOAT
+MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float);
 #endif
-#define SET_CPTR_VALUE(mrb,r,v) r = mrb_word_boxing_cptr_value(mrb, v)
-#define SET_NIL_VALUE(r) BOXWORD_SET_VALUE(r, MRB_TT_FALSE, value.i, 0)
-#define SET_FALSE_VALUE(r) BOXWORD_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
-#define SET_TRUE_VALUE(r) BOXWORD_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
-#define SET_BOOL_VALUE(r,b) BOXWORD_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
-#define SET_INT_VALUE(r,n) BOXWORD_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n))
-#define SET_SYM_VALUE(r,v) BOXWORD_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))
-#define SET_OBJ_VALUE(r,v) BOXWORD_SET_VALUE(r, (((struct RObject*)(v))->tt), value.p, (v))
-#define SET_UNDEF_VALUE(r) BOXWORD_SET_VALUE(r, MRB_TT_UNDEF, value.i, 0)
+MRB_API mrb_value mrb_word_boxing_int_value(struct mrb_state*, mrb_int);
+
+#define mrb_immediate_p(o) ((o) & BOXWORD_IMMEDIATE_MASK || (o) == MRB_Qnil)
+
+#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)  mrb_val_union(o).sym
+#else
+#define mrb_symbol(o)  BOXWORD_SHIFT_VALUE(o, SYMBOL, mrb_sym)
+#endif
+#define mrb_bool(o)    (((o) & ~(unsigned long)MRB_Qfalse) != 0)
+
+#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) (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) == 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)
+#define mrb_string_p(o) BOXWORD_OBJ_TYPE_P(o, STRING)
+#define mrb_hash_p(o) BOXWORD_OBJ_TYPE_P(o, HASH)
+#define mrb_cptr_p(o) BOXWORD_OBJ_TYPE_P(o, CPTR)
+#define mrb_exception_p(o) BOXWORD_OBJ_TYPE_P(o, EXCEPTION)
+#define mrb_free_p(o) BOXWORD_OBJ_TYPE_P(o, FREE)
+#define mrb_object_p(o) BOXWORD_OBJ_TYPE_P(o, OBJECT)
+#define mrb_class_p(o) BOXWORD_OBJ_TYPE_P(o, CLASS)
+#define mrb_module_p(o) BOXWORD_OBJ_TYPE_P(o, MODULE)
+#define mrb_iclass_p(o) BOXWORD_OBJ_TYPE_P(o, ICLASS)
+#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_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_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) = 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(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) 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) = (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_INTEGER :
+         mrb_symbol_p(o) ? MRB_TT_SYMBOL :
+         mrb_undef_p(o)  ? MRB_TT_UNDEF :
+         mrb_val_union(o).bp->tt;
+}
 
 #endif  /* MRUBY_BOXING_WORD_H */

include/mruby/class.h

@@ -1,5 +1,5 @@
-/*
-** mruby/class.h - Class class
+/**
+** @file mruby/class.h - Class class
 **
 ** See Copyright Notice in mruby.h
 */
@@ -17,16 +17,13 @@ MRB_BEGIN_DECL
 struct RClass {
   MRB_OBJECT_HEADER;
   struct iv_tbl *iv;
-  struct kh_mt *mt;
+  struct mt_tbl *mt;
   struct RClass *super;
 };
 
 #define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
-#define RCLASS_SUPER(v)     (((struct RClass*)(mrb_ptr(v)))->super)
-#define RCLASS_IV_TBL(v)    (((struct RClass*)(mrb_ptr(v)))->iv)
-#define RCLASS_M_TBL(v)     (((struct RClass*)(mrb_ptr(v)))->mt)
 
-static inline struct RClass*
+MRB_INLINE struct RClass*
 mrb_class(mrb_state *mrb, mrb_value v)
 {
   switch (mrb_type(v)) {
@@ -38,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
@@ -53,42 +50,60 @@ mrb_class(mrb_state *mrb, mrb_value v)
   }
 }
 
-/* TODO: figure out where to put user flags */
-/* flags bits >= 18 is reserved */
-#define MRB_FLAG_IS_PREPENDED (1 << 19)
-#define MRB_FLAG_IS_ORIGIN (1 << 20)
+/* flags:
+   20: frozen
+   19: is_prepended
+   18: is_origin
+   17: is_inherited (used by method cache)
+   16: unused
+   0-15: instance type
+*/
+#define MRB_FL_CLASS_IS_PREPENDED (1 << 19)
+#define MRB_FL_CLASS_IS_ORIGIN (1 << 18)
 #define MRB_CLASS_ORIGIN(c) do {\
-  if (c->flags & MRB_FLAG_IS_PREPENDED) {\
-    c = c->super;\
-    while (!(c->flags & MRB_FLAG_IS_ORIGIN)) {\
-      c = c->super;\
+  if ((c)->flags & MRB_FL_CLASS_IS_PREPENDED) {\
+    (c) = (c)->super;\
+    while (!((c)->flags & MRB_FL_CLASS_IS_ORIGIN)) {\
+      (c) = (c)->super;\
     }\
   }\
 } while (0)
-#define MRB_FLAG_IS_INHERITED (1 << 21)
+#define MRB_FL_CLASS_IS_INHERITED (1 << 17)
 #define MRB_INSTANCE_TT_MASK (0xFF)
-#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)
+#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);
-MRB_API struct RClass *mrb_vm_define_class(mrb_state*, mrb_value, mrb_value, mrb_sym);
-MRB_API struct RClass *mrb_vm_define_module(mrb_state*, mrb_value, 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 *mrb, struct RClass *c, mrb_sym a, mrb_sym b);
+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);
 
 MRB_API struct RClass* mrb_class_real(struct RClass* cl);
+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

@@ -1,5 +1,5 @@
-/*
-**"common.h - mruby common platform definition"
+/**
+** @file common.h - mruby common platform definition"
 **
 ** See Copyright Notice in mruby.h
 */
@@ -7,6 +7,11 @@
 #ifndef MRUBY_COMMON_H
 #define MRUBY_COMMON_H
 
+#ifdef __APPLE__
+  #ifndef __TARGETCONDITIONALS__
+  #include "TargetConditionals.h"
+  #endif
+#endif
 
 #ifdef __cplusplus
 #ifdef MRB_ENABLE_CXX_ABI
@@ -29,7 +34,7 @@
 MRB_BEGIN_DECL
 
 /** Declare a function that never returns. */
-#if __STDC_VERSION__ >= 201112L
+#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 201112L
 # define mrb_noreturn _Noreturn
 #elif defined __GNUC__ && !defined __STRICT_ANSI__
 # define mrb_noreturn __attribute__((noreturn))
@@ -49,14 +54,15 @@ MRB_BEGIN_DECL
 #endif
 
 /** Declare a function as always inlined. */
-#if defined(_MSC_VER)
-# define MRB_INLINE static __inline
-#else
-# define MRB_INLINE static inline
+#if defined _MSC_VER && _MSC_VER < 1900
+# ifndef __cplusplus
+#  define inline __inline
+# endif
 #endif
-
+#define MRB_INLINE static inline
 
 /** Declare a public MRuby API function. */
+#ifndef MRB_API
 #if defined(MRB_BUILD_AS_DLL)
 #if defined(MRB_CORE) || defined(MRB_LIB)
 # define MRB_API __declspec(dllexport)
@@ -66,6 +72,20 @@ MRB_BEGIN_DECL
 #else
 # define MRB_API extern
 #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
 

include/mruby/compile.h

@@ -1,5 +1,5 @@
-/*
-** mruby/compile.h - mruby parser
+/**
+** @file mruby/compile.h - mruby parser
 **
 ** See Copyright Notice in mruby.h
 */
@@ -24,7 +24,7 @@ typedef struct mrbc_context {
   mrb_sym *syms;
   int slen;
   char *filename;
-  short lineno;
+  uint16_t lineno;
   int (*partial_hook)(struct mrb_parser_state*);
   void *partial_data;
   struct RClass *target_class;
@@ -33,6 +33,7 @@ typedef struct mrbc_context {
   mrb_bool no_exec:1;
   mrb_bool keep_lv:1;
   mrb_bool no_optimize:1;
+  const struct RProc *upper;
 
   size_t parser_nerr;
 } mrbc_context;
@@ -41,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 {
@@ -66,7 +68,7 @@ enum mrb_lex_state_enum {
 
 /* saved error message */
 struct mrb_parser_message {
-  int lineno;
+  uint16_t lineno;
   int column;
   char* message;
 };
@@ -104,7 +106,7 @@ struct mrb_parser_heredoc_info {
   mrb_ast_node *doc;
 };
 
-#define MRB_PARSER_TOKBUF_MAX 65536
+#define MRB_PARSER_TOKBUF_MAX (UINT16_MAX-1)
 #define MRB_PARSER_TOKBUF_SIZE 256
 
 /* parser structure */
@@ -117,8 +119,8 @@ struct mrb_parser_state {
   FILE *f;
 #endif
   mrbc_context *cxt;
-  char const *filename;
-  int lineno;
+  mrb_sym filename_sym;
+  uint16_t lineno;
   int column;
 
   enum mrb_lex_state_enum lstate;
@@ -142,7 +144,6 @@ struct mrb_parser_state {
   mrb_ast_node *heredocs_from_nextline;
   mrb_ast_node *parsing_heredoc;
   mrb_ast_node *lex_strterm_before_heredoc;
-  mrb_bool heredoc_end_now:1; /* for mirb */
 
   void *ylval;
 
@@ -152,14 +153,16 @@ struct mrb_parser_state {
 
   mrb_bool no_optimize:1;
   mrb_bool capture_errors:1;
+  const struct RProc *upper;
   struct mrb_parser_message error_buffer[10];
   struct mrb_parser_message warn_buffer[10];
 
   mrb_sym* filename_table;
-  size_t filename_table_length;
-  int current_filename_index;
+  uint16_t filename_table_length;
+  uint16_t current_filename_index;
 
   struct mrb_jmpbuf* jmp;
+  mrb_ast_node *nvars;
 };
 
 MRB_API struct mrb_parser_state* mrb_parser_new(mrb_state*);
@@ -167,7 +170,7 @@ MRB_API void mrb_parser_free(struct mrb_parser_state*);
 MRB_API void mrb_parser_parse(struct mrb_parser_state*,mrbc_context*);
 
 MRB_API void mrb_parser_set_filename(struct mrb_parser_state*, char const*);
-MRB_API char const* mrb_parser_get_filename(struct mrb_parser_state*, uint16_t idx);
+MRB_API mrb_sym mrb_parser_get_filename(struct mrb_parser_state*, uint16_t idx);
 
 /* utility functions */
 #ifndef MRB_DISABLE_STDIO
@@ -178,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/data.h

@@ -1,5 +1,5 @@
-/*
-** mruby/data.h - Data class
+/**
+** @file mruby/data.h - Data class
 **
 ** See Copyright Notice in mruby.h
 */
@@ -39,10 +39,11 @@ MRB_API struct RData *mrb_data_object_alloc(mrb_state *mrb, struct RClass* klass
 #define Data_Wrap_Struct(mrb,klass,type,ptr)\
   mrb_data_object_alloc(mrb,klass,ptr,type)
 
-#define Data_Make_Struct(mrb,klass,strct,type,sval,data) do { \
-  sval = mrb_malloc(mrb, sizeof(strct));                     \
-  { static const strct zero = { 0 }; *sval = zero; };\
-  data = Data_Wrap_Struct(mrb,klass,type,sval);\
+#define Data_Make_Struct(mrb,klass,strct,type,sval,data_obj) do { \
+  (data_obj) = Data_Wrap_Struct(mrb,klass,type,NULL);\
+  (sval) = (strct *)mrb_malloc(mrb, sizeof(strct));                     \
+  { static const strct zero = { 0 }; *(sval) = zero; };\
+  (data_obj)->data = (sval);\
 } while (0)
 
 #define RDATA(obj)         ((struct RData *)(mrb_ptr(obj)))
@@ -62,10 +63,10 @@ MRB_API void *mrb_data_check_get_ptr(mrb_state *mrb, mrb_value, const mrb_data_t
   *(void**)&sval = mrb_data_get_ptr(mrb, obj, type); \
 } while (0)
 
-static inline void
+MRB_INLINE void
 mrb_data_init(mrb_value v, void *ptr, const mrb_data_type *type)
 {
-  mrb_assert(mrb_type(v) == MRB_TT_DATA);
+  mrb_assert(mrb_data_p(v));
   DATA_PTR(v) = ptr;
   DATA_TYPE(v) = type;
 }

include/mruby/debug.h

@@ -1,5 +1,5 @@
-/*
-** mruby/debug.h - mruby debug info
+/**
+** @file mruby/debug.h - mruby debug info
 **
 ** See Copyright Notice in mruby.h
 */
@@ -26,7 +26,6 @@ typedef struct mrb_irep_debug_info_line {
 
 typedef struct mrb_irep_debug_info_file {
   uint32_t start_pos;
-  const char *filename;
   mrb_sym filename_sym;
   uint32_t line_entry_count;
   mrb_debug_line_type line_type;
@@ -47,18 +46,19 @@ 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_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_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_file *mrb_debug_info_append_file(
-    mrb_state *mrb, mrb_irep *irep,
-    uint32_t start_pos, uint32_t end_pos);
 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(
+    mrb_state *mrb, mrb_irep_debug_info *info,
+    const char *filename, uint16_t *lines,
+    uint32_t start_pos, uint32_t end_pos);
 MRB_API void mrb_debug_info_free(mrb_state *mrb, mrb_irep_debug_info *d);
 
 MRB_END_DECL

include/mruby/dump.h

@@ -1,5 +1,5 @@
-/*
-** mruby/dump.h - mruby binary dumper (mrbc binary format)
+/**
+** @file mruby/dump.h - mruby binary dumper (mrbc binary format)
 **
 ** See Copyright Notice in mruby.h
 */
@@ -17,20 +17,18 @@
 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*);
 #endif
 MRB_API mrb_irep *mrb_read_irep(mrb_state*, const uint8_t*);
+MRB_API mrb_irep *mrb_read_irep_buf(mrb_state*, const void*, size_t);
 
 /* dump/load error code
  *
@@ -51,16 +49,19 @@ MRB_API mrb_irep *mrb_read_irep(mrb_state*, const uint8_t*);
 
 /* Rite Binary File header */
 #define RITE_BINARY_IDENT              "RITE"
-#define RITE_BINARY_IDENT_LIL          "ETIR"
-#define RITE_BINARY_FORMAT_VER         "0004"
+/* 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                    "0000"
+#define RITE_VM_VER                    "0300"
 
 #define RITE_BINARY_EOF                "END\0"
 #define RITE_SECTION_IREP_IDENT        "IREP"
-#define RITE_SECTION_LINENO_IDENT      "LINE"
 #define RITE_SECTION_DEBUG_IDENT       "DBG\0"
 #define RITE_SECTION_LV_IDENT          "LVAR"
 
@@ -70,7 +71,8 @@ MRB_API mrb_irep *mrb_read_irep(mrb_state*, const uint8_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 */
@@ -92,10 +94,6 @@ struct rite_section_irep_header {
   uint8_t rite_version[4];    /* Rite Instruction Specification Version */
 };
 
-struct rite_section_lineno_header {
-  RITE_SECTION_HEADER;
-};
-
 struct rite_section_debug_header {
   RITE_SECTION_HEADER;
 };
@@ -110,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)
 {
@@ -146,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)
 {
@@ -165,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

@@ -1,5 +1,5 @@
-/*
-** mruby/error.h - Exception class
+/**
+** @file mruby/error.h - Exception class
 **
 ** See Copyright Notice in mruby.h
 */
@@ -23,32 +23,94 @@ 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);
 MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_value args, const char *fmt, ...);
 
-/* declaration for fail method */
+/* declaration for `fail` method */
 MRB_API mrb_value mrb_f_raise(mrb_state*, mrb_value);
 
+#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)
+#define mrb_break_value_set(brk, v) ((brk)->val = v)
+#else
+struct RBreak {
+  MRB_OBJECT_HEADER;
+  const struct RProc *proc;
+  union mrb_value_union value;
+};
+#define RBREAK_VALUE_TT_MASK ((1 << 8) - 1)
+static inline mrb_value
+mrb_break_value_get(struct RBreak *brk)
+{
+  mrb_value val;
+  val.value = brk->value;
+  val.tt = (enum mrb_vtype)(brk->flags & RBREAK_VALUE_TT_MASK);
+  return val;
+}
+static inline void
+mrb_break_value_set(struct RBreak *brk, mrb_value val)
+{
+  brk->value = val.value;
+  brk->flags &= ~RBREAK_VALUE_TT_MASK;
+  brk->flags |= val.tt;
+}
+#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
  *
- * @mrbgem mruby-error
+ * Implemented in the mruby-error mrbgem
  */
 MRB_API mrb_value mrb_protect(mrb_state *mrb, mrb_func_t body, mrb_value data, mrb_bool *state);
 
 /**
  * Ensure
  *
- * @mrbgem mruby-error
+ * Implemented in the mruby-error mrbgem
  */
 MRB_API mrb_value mrb_ensure(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
                              mrb_func_t ensure, mrb_value e_data);
@@ -56,7 +118,7 @@ MRB_API mrb_value mrb_ensure(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
 /**
  * Rescue
  *
- * @mrbgem mruby-error
+ * Implemented in the mruby-error mrbgem
  */
 MRB_API mrb_value mrb_rescue(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
                              mrb_func_t rescue, mrb_value r_data);
@@ -64,7 +126,7 @@ MRB_API mrb_value mrb_rescue(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
 /**
  * Rescue exception
  *
- * @mrbgem mruby-error
+ * Implemented in the mruby-error mrbgem
  */
 MRB_API mrb_value mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
                                         mrb_func_t rescue, mrb_value r_data,

include/mruby/gc.h

@@ -1,5 +1,5 @@
-/*
-** mruby/gc.h - garbage collector for mruby
+/**
+** @file mruby/gc.h - garbage collector for mruby
 **
 ** See Copyright Notice in mruby.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

@@ -1,5 +1,5 @@
-/*
-** mruby/hash.h - Hash class
+/**
+** @file mruby/hash.h - Hash class
 **
 ** See Copyright Notice in mruby.h
 */
@@ -8,7 +8,6 @@
 #define MRUBY_HASH_H
 
 #include "common.h"
-#include <mruby/khash.h>
 
 /**
  * Hash class
@@ -18,13 +17,16 @@ MRB_BEGIN_DECL
 struct RHash {
   MRB_OBJECT_HEADER;
   struct iv_tbl *iv;
-  struct kh_ht *ht;
+  struct htable *ht;
 };
 
 #define mrb_hash_ptr(v)    ((struct RHash*)(mrb_ptr(v)))
 #define mrb_hash_value(p)  mrb_obj_value((void*)(p))
 
-MRB_API mrb_value mrb_hash_new_capa(mrb_state*, mrb_int);
+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);
 
 /*
  * Initializes a new hash.
@@ -74,7 +76,7 @@ MRB_API mrb_value mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key);
  *
  * Equivalent to:
  *
- *     hash.hash_key?(key) ? hash[key] : def
+ *     hash.key?(key) ? hash[key] : def
  *
  * @param mrb The mruby state reference.
  * @param hash The target hash.
@@ -94,7 +96,7 @@ MRB_API mrb_value mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key,
  * @param mrb The mruby state reference.
  * @param hash The target hash.
  * @param key The key to delete.
- * @return The deleted value.
+ * @return The deleted value. This value is not protected from GC. Use `mrb_gc_protect()` if necessary.
  */
 MRB_API mrb_value mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key);
 
@@ -110,7 +112,19 @@ MRB_API mrb_value mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value
  * @return An array with the keys of the hash.
  */
 MRB_API mrb_value mrb_hash_keys(mrb_state *mrb, mrb_value hash);
-MRB_API mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value hash);
+/*
+ * Check if the hash has the key.
+ *
+ * Equivalent to:
+ *
+ *     hash.key?(key)
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @param key The key to check existence.
+ * @return True if the hash has the key
+ */
+MRB_API mrb_bool mrb_hash_key_p(mrb_state *mrb, mrb_value hash, mrb_value key);
 
 /*
  * Check if the hash is empty
@@ -123,7 +137,7 @@ MRB_API mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value hash);
  * @param self The target hash.
  * @return True if the hash is empty, false otherwise.
  */
-MRB_API mrb_value mrb_hash_empty_p(mrb_state *mrb, mrb_value self);
+MRB_API mrb_bool mrb_hash_empty_p(mrb_state *mrb, mrb_value self);
 
 /*
  * Gets an array of values.
@@ -151,21 +165,44 @@ MRB_API mrb_value mrb_hash_values(mrb_state *mrb, mrb_value hash);
  */
 MRB_API mrb_value mrb_hash_clear(mrb_state *mrb, mrb_value hash);
 
-/* declaration of struct kh_ht */
-/* be careful when you touch the internal */
-typedef struct {
-  mrb_value v;
-  mrb_int n;
-} mrb_hash_value;
+/*
+ * Get hash size.
+ *
+ * Equivalent to:
+ *
+ *      hash.size
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @return The hash size.
+ */
+MRB_API mrb_int mrb_hash_size(mrb_state *mrb, mrb_value hash);
 
-KHASH_DECLARE(ht, mrb_value, mrb_hash_value, TRUE)
+/*
+ * Copies the hash.
+ *
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @return The copy of the hash
+ */
+MRB_API mrb_value mrb_hash_dup(mrb_state *mrb, mrb_value hash);
+
+/*
+ * Merges two hashes. The first hash will be modified by the
+ * second hash.
+ *
+ * @param mrb The mruby state reference.
+ * @param hash1 The target hash.
+ * @param hash2 Updating hash
+ */
+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)
-MRB_API struct kh_ht * mrb_hash_tbl(mrb_state *mrb, mrb_value hash);
 
 #define MRB_HASH_DEFAULT      1
 #define MRB_HASH_PROC_DEFAULT 2
@@ -177,6 +214,10 @@ void mrb_gc_mark_hash(mrb_state*, struct RHash*);
 size_t mrb_gc_mark_hash_size(mrb_state*, struct RHash*);
 void mrb_gc_free_hash(mrb_state*, struct RHash*);
 
+/* return non zero to break the loop */
+typedef int (mrb_hash_foreach_func)(mrb_state *mrb, mrb_value key, mrb_value val, void *data);
+MRB_API void mrb_hash_foreach(mrb_state *mrb, struct RHash *hash, mrb_hash_foreach_func *func, void *p);
+
 MRB_END_DECL
 
 #endif  /* MRUBY_HASH_H */

include/mruby/irep.h

@@ -1,5 +1,5 @@
-/*
-** mruby/irep.h - mrb_irep structure
+/**
+** @file mruby/irep.h - mrb_irep structure
 **
 ** See Copyright Notice in mruby.h
 */
@@ -16,46 +16,124 @@
 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;
 
-  mrb_code *iseq;
-  mrb_value *pool;
-  mrb_sym *syms;
-  struct mrb_irep **reps;
+  const mrb_code *iseq;
+  /*
+   * 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 */
-  mrb_bool own_filename;
-  const char *filename;
-  uint16_t *lines;
   struct mrb_irep_debug_info* debug_info;
 
-  int ilen, plen, slen, rlen, refcnt;
+  uint16_t ilen, plen, slen, rlen;
+  uint32_t refcnt;
 } 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*);
+
+/*
+ * @param [const void*] irep code
+ * @param [size_t] size of irep buffer. If -1 is given, it is considered unrestricted.
+ */
+MRB_API mrb_value mrb_load_irep_buf(mrb_state*, const void*, size_t);
+
+/* @param [const uint8_t*] irep code, expected as a literal */
 MRB_API mrb_value mrb_load_irep_cxt(mrb_state*, const uint8_t*, mrbc_context*);
+
+/*
+ * @param [const void*] irep code
+ * @param [size_t] size of irep buffer. If -1 is given, it is considered unrestricted.
+ */
+MRB_API mrb_value mrb_load_irep_buf_cxt(mrb_state*, const void*, size_t, mrbc_context*);
+
 void mrb_irep_free(mrb_state*, struct mrb_irep*);
 void mrb_irep_incref(mrb_state*, struct mrb_irep*);
 void mrb_irep_decref(mrb_state*, struct mrb_irep*);
 void mrb_irep_cutref(mrb_state*, struct mrb_irep*);
+void mrb_irep_remove_lv(mrb_state *mrb, mrb_irep *irep);
+
+struct mrb_insn_data {
+  uint8_t insn;
+  uint16_t a;
+  uint16_t b;
+  uint8_t c;
+};
+
+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
 

include/mruby/istruct.h

@@ -1,5 +1,5 @@
-/*
-** mruby/istruct.h - Inline structures
+/**
+** @file mruby/istruct.h - Inline structures
 **
 ** See Copyright Notice in mruby.h
 */
@@ -19,12 +19,15 @@ MRB_BEGIN_DECL
 
 #define ISTRUCT_DATA_SIZE (sizeof(void*) * 3)
 
-struct RIstruct {
+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)))
+#define RISTRUCT(obj)         ((struct RIStruct*)(mrb_ptr(obj)))
 #define ISTRUCT_PTR(obj)      (RISTRUCT(obj)->inline_data)
 
 MRB_INLINE mrb_int mrb_istruct_size()

include/mruby/khash.h

@@ -1,5 +1,5 @@
-/*
-** mruby/khash.c - Hash for mruby
+/**
+** @file mruby/khash.h - Hash for mruby
 **
 ** See Copyright Notice in mruby.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 @@
-/*
-** mruby/numeric.h - Numeric, Integer, Float, Fixnum class
+/**
+** @file mruby/numeric.h - Numeric, Integer, Float class
 **
 ** See Copyright Notice in mruby.h
 */
@@ -12,34 +12,38 @@
 /**
  * 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
-#define FIXABLE_FLOAT(f) TYPED_FIXABLE(f,double)
+#ifndef MRB_NO_FLOAT
+#ifdef MRB_INT64
+#define FIXABLE_FLOAT(f) ((f)>=-9223372036854775808.0 && (f)<9223372036854775808.0)
+#else
+#define FIXABLE_FLOAT(f) TYPED_FIXABLE(f,mrb_float)
+#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);
 #endif
 
-mrb_value mrb_fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y);
-mrb_value mrb_fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y);
-mrb_value mrb_fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y);
-mrb_value mrb_num_div(mrb_state *mrb, mrb_value x, mrb_value y);
+MRB_API mrb_value mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y);
+MRB_API mrb_value mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y);
+MRB_API mrb_value mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y);
 
 #ifndef __has_builtin
   #define __has_builtin(x) 0
@@ -132,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;
     }
   }
@@ -156,6 +160,36 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
 
 #endif
 
+#ifndef MRB_NO_FLOAT
+# include <stdint.h>
+# include <float.h>
+
+# define MRB_FLT_RADIX          FLT_RADIX
+
+# ifdef MRB_USE_FLOAT32
+#  define MRB_FLT_MANT_DIG      FLT_MANT_DIG
+#  define MRB_FLT_EPSILON       FLT_EPSILON
+#  define MRB_FLT_DIG           FLT_DIG
+#  define MRB_FLT_MIN_EXP       FLT_MIN_EXP
+#  define MRB_FLT_MIN           FLT_MIN
+#  define MRB_FLT_MIN_10_EXP    FLT_MIN_10_EXP
+#  define MRB_FLT_MAX_EXP       FLT_MAX_EXP
+#  define MRB_FLT_MAX           FLT_MAX
+#  define MRB_FLT_MAX_10_EXP    FLT_MAX_10_EXP
+
+# 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
+#  define MRB_FLT_MIN_EXP       DBL_MIN_EXP
+#  define MRB_FLT_MIN           DBL_MIN
+#  define MRB_FLT_MIN_10_EXP    DBL_MIN_10_EXP
+#  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_FLOAT32 */
+#endif /* MRB_NO_FLOAT */
+
 MRB_END_DECL
 
 #endif  /* MRUBY_NUMERIC_H */

include/mruby/object.h

@@ -1,5 +1,5 @@
-/*
-** mruby/object.h - mruby object definition
+/**
+** @file mruby/object.h - mruby object definition
 **
 ** See Copyright Notice in mruby.h
 */
@@ -8,25 +8,24 @@
 #define MRUBY_OBJECT_H
 
 #define MRB_OBJECT_HEADER \
-  enum mrb_vtype tt:8;\
-  uint32_t color:3;\
-  uint32_t flags:21;\
-  struct RClass *c;\
-  struct RBasic *gcnext
-
-#define MRB_FLAG_TEST(obj, flag) ((obj)->flags & flag)
+  struct RClass *c;       \
+  struct RBasic *gcnext;  \
+  enum mrb_vtype tt:8;    \
+  uint32_t color:3;       \
+  uint32_t flags:21
 
+#define MRB_FLAG_TEST(obj, flag) ((obj)->flags & (flag))
 
 struct RBasic {
   MRB_OBJECT_HEADER;
 };
 #define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
 
-/* flags bits >= 18 is reserved */
-#define MRB_FLAG_IS_FROZEN (1 << 18)
-#define MRB_FROZEN_P(o) ((o)->flags & MRB_FLAG_IS_FROZEN)
-#define MRB_SET_FROZEN_FLAG(o) ((o)->flags |= MRB_FLAG_IS_FROZEN)
-#define MRB_UNSET_FROZEN_FLAG(o) ((o)->flags &= ~MRB_FLAG_IS_FROZEN)
+#define MRB_FL_OBJ_IS_FROZEN (1 << 20)
+#define MRB_FROZEN_P(o) ((o)->flags & MRB_FL_OBJ_IS_FROZEN)
+#define MRB_SET_FROZEN_FLAG(o) ((o)->flags |= MRB_FL_OBJ_IS_FROZEN)
+#define MRB_UNSET_FROZEN_FLAG(o) ((o)->flags &= ~MRB_FL_OBJ_IS_FROZEN)
+#define mrb_frozen_p(o) MRB_FROZEN_P(o)
 
 struct RObject {
   MRB_OBJECT_HEADER;
@@ -34,7 +33,6 @@ struct RObject {
 };
 #define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
 
-#define mrb_immediate_p(x) (mrb_type(x) < MRB_TT_HAS_BASIC)
 #define mrb_special_const_p(x) mrb_immediate_p(x)
 
 struct RFiber {

include/mruby/opcode.h

@@ -1,5 +1,5 @@
-/*
-** mruby/opcode.h - RiteVM operation codes
+/**
+** @file mruby/opcode.h - RiteVM operation codes
 **
 ** See Copyright Notice in mruby.h
 */
@@ -7,145 +7,10 @@
 #ifndef MRUBY_OPCODE_H
 #define MRUBY_OPCODE_H
 
-#define MAXARG_Bx        (0xffff)
-#define MAXARG_sBx       (MAXARG_Bx>>1)         /* 'sBx' is signed */
-
-/* instructions: packed 32 bit      */
-/* -------------------------------  */
-/*     A:B:C:OP = 9: 9: 7: 7        */
-/*      A:Bx:OP =    9:16: 7        */
-/*        Ax:OP =      25: 7        */
-/*   A:Bz:Cz:OP = 9:14: 2: 7        */
-
-#define GET_OPCODE(i)            ((int)(((mrb_code)(i)) & 0x7f))
-#define GETARG_A(i)              ((int)((((mrb_code)(i)) >> 23) & 0x1ff))
-#define GETARG_B(i)              ((int)((((mrb_code)(i)) >> 14) & 0x1ff))
-#define GETARG_C(i)              ((int)((((mrb_code)(i)) >>  7) & 0x7f))
-#define GETARG_Bx(i)             ((int)((((mrb_code)(i)) >>  7) & 0xffff))
-#define GETARG_sBx(i)            ((int)(GETARG_Bx(i)-MAXARG_sBx))
-#define GETARG_Ax(i)             ((int32_t)((((mrb_code)(i)) >>  7) & 0x1ffffff))
-#define GETARG_UNPACK_b(i,n1,n2) ((int)((((mrb_code)(i)) >> (7+(n2))) & (((1<<(n1))-1))))
-#define GETARG_UNPACK_c(i,n1,n2) ((int)((((mrb_code)(i)) >> 7) & (((1<<(n2))-1))))
-#define GETARG_b(i)              GETARG_UNPACK_b(i,14,2)
-#define GETARG_c(i)              GETARG_UNPACK_c(i,14,2)
-
-#define MKOPCODE(op)          ((op) & 0x7f)
-#define MKARG_A(c)            ((mrb_code)((c) & 0x1ff) << 23)
-#define MKARG_B(c)            ((mrb_code)((c) & 0x1ff) << 14)
-#define MKARG_C(c)            (((c) & 0x7f) <<  7)
-#define MKARG_Bx(v)           ((mrb_code)((v) & 0xffff) << 7)
-#define MKARG_sBx(v)          MKARG_Bx((v)+MAXARG_sBx)
-#define MKARG_Ax(v)           ((mrb_code)((v) & 0x1ffffff) << 7)
-#define MKARG_PACK(b,n1,c,n2) ((((b) & ((1<<n1)-1)) << (7+n2))|(((c) & ((1<<n2)-1)) << 7))
-#define MKARG_bc(b,c)         MKARG_PACK(b,14,c,2)
-
-#define MKOP_A(op,a)        (MKOPCODE(op)|MKARG_A(a))
-#define MKOP_AB(op,a,b)     (MKOP_A(op,a)|MKARG_B(b))
-#define MKOP_ABC(op,a,b,c)  (MKOP_AB(op,a,b)|MKARG_C(c))
-#define MKOP_ABx(op,a,bx)   (MKOP_A(op,a)|MKARG_Bx(bx))
-#define MKOP_Bx(op,bx)      (MKOPCODE(op)|MKARG_Bx(bx))
-#define MKOP_sBx(op,sbx)    (MKOPCODE(op)|MKARG_sBx(sbx))
-#define MKOP_AsBx(op,a,sbx) (MKOP_A(op,a)|MKARG_sBx(sbx))
-#define MKOP_Ax(op,ax)      (MKOPCODE(op)|MKARG_Ax(ax))
-#define MKOP_Abc(op,a,b,c)  (MKOP_A(op,a)|MKARG_bc(b,c))
-
-enum {
-  /*-----------------------------------------------------------------------
-  operation code  operand description
-  ------------------------------------------------------------------------*/
-  OP_NOP=0,/*                                                             */
-  OP_MOVE,/*      A B     R(A) := R(B)                                    */
-  OP_LOADL,/*     A Bx    R(A) := Pool(Bx)                                */
-  OP_LOADI,/*     A sBx   R(A) := sBx                                     */
-  OP_LOADSYM,/*   A Bx    R(A) := Syms(Bx)                                */
-  OP_LOADNIL,/*   A       R(A) := nil                                     */
-  OP_LOADSELF,/*  A       R(A) := self                                    */
-  OP_LOADT,/*     A       R(A) := true                                    */
-  OP_LOADF,/*     A       R(A) := false                                   */
-
-  OP_GETGLOBAL,/* A Bx    R(A) := getglobal(Syms(Bx))                     */
-  OP_SETGLOBAL,/* A Bx    setglobal(Syms(Bx), R(A))                       */
-  OP_GETSPECIAL,/*A Bx    R(A) := Special[Bx]                             */
-  OP_SETSPECIAL,/*A Bx    Special[Bx] := R(A)                             */
-  OP_GETIV,/*     A Bx    R(A) := ivget(Syms(Bx))                         */
-  OP_SETIV,/*     A Bx    ivset(Syms(Bx),R(A))                            */
-  OP_GETCV,/*     A Bx    R(A) := cvget(Syms(Bx))                         */
-  OP_SETCV,/*     A Bx    cvset(Syms(Bx),R(A))                            */
-  OP_GETCONST,/*  A Bx    R(A) := constget(Syms(Bx))                      */
-  OP_SETCONST,/*  A Bx    constset(Syms(Bx),R(A))                         */
-  OP_GETMCNST,/*  A Bx    R(A) := R(A)::Syms(Bx)                          */
-  OP_SETMCNST,/*  A Bx    R(A+1)::Syms(Bx) := R(A)                        */
-  OP_GETUPVAR,/*  A B C   R(A) := uvget(B,C)                              */
-  OP_SETUPVAR,/*  A B C   uvset(B,C,R(A))                                 */
-
-  OP_JMP,/*       sBx     pc+=sBx                                         */
-  OP_JMPIF,/*     A sBx   if R(A) pc+=sBx                                 */
-  OP_JMPNOT,/*    A sBx   if !R(A) pc+=sBx                                */
-  OP_ONERR,/*     sBx     rescue_push(pc+sBx)                             */
-  OP_RESCUE,/*    A B C   if A (if C exc=R(A) else R(A) := exc);
-                          if B R(B) := exc.isa?(R(B)); clear(exc)         */
-  OP_POPERR,/*    A       A.times{rescue_pop()}                           */
-  OP_RAISE,/*     A       raise(R(A))                                     */
-  OP_EPUSH,/*     Bx      ensure_push(SEQ[Bx])                            */
-  OP_EPOP,/*      A       A.times{ensure_pop().call}                      */
-
-  OP_SEND,/*      A B C   R(A) := call(R(A),Syms(B),R(A+1),...,R(A+C))    */
-  OP_SENDB,/*     A B C   R(A) := call(R(A),Syms(B),R(A+1),...,R(A+C),&R(A+C+1))*/
-  OP_FSEND,/*     A B C   R(A) := fcall(R(A),Syms(B),R(A+1),...,R(A+C-1)) */
-  OP_CALL,/*      A       R(A) := self.call(frame.argc, frame.argv)       */
-  OP_SUPER,/*     A C     R(A) := super(R(A+1),... ,R(A+C+1))             */
-  OP_ARGARY,/*    A Bx    R(A) := argument array (16=6:1:5:4)             */
-  OP_ENTER,/*     Ax      arg setup according to flags (23=5:5:1:5:5:1:1) */
-  OP_KARG,/*      A B C   R(A) := kdict[Syms(B)]; if C kdict.rm(Syms(B))  */
-  OP_KDICT,/*     A C     R(A) := kdict                                   */
-
-  OP_RETURN,/*    A B     return R(A) (B=normal,in-block return/break)    */
-  OP_TAILCALL,/*  A B C   return call(R(A),Syms(B),*R(C))                 */
-  OP_BLKPUSH,/*   A Bx    R(A) := block (16=6:1:5:4)                      */
-
-  OP_ADD,/*       A B C   R(A) := R(A)+R(A+1) (Syms[B]=:+,C=1)            */
-  OP_ADDI,/*      A B C   R(A) := R(A)+C (Syms[B]=:+)                     */
-  OP_SUB,/*       A B C   R(A) := R(A)-R(A+1) (Syms[B]=:-,C=1)            */
-  OP_SUBI,/*      A B C   R(A) := R(A)-C (Syms[B]=:-)                     */
-  OP_MUL,/*       A B C   R(A) := R(A)*R(A+1) (Syms[B]=:*,C=1)            */
-  OP_DIV,/*       A B C   R(A) := R(A)/R(A+1) (Syms[B]=:/,C=1)            */
-  OP_EQ,/*        A B C   R(A) := R(A)==R(A+1) (Syms[B]=:==,C=1)          */
-  OP_LT,/*        A B C   R(A) := R(A)<R(A+1)  (Syms[B]=:<,C=1)           */
-  OP_LE,/*        A B C   R(A) := R(A)<=R(A+1) (Syms[B]=:<=,C=1)          */
-  OP_GT,/*        A B C   R(A) := R(A)>R(A+1)  (Syms[B]=:>,C=1)           */
-  OP_GE,/*        A B C   R(A) := R(A)>=R(A+1) (Syms[B]=:>=,C=1)          */
-
-  OP_ARRAY,/*     A B C   R(A) := ary_new(R(B),R(B+1)..R(B+C))            */
-  OP_ARYCAT,/*    A B     ary_cat(R(A),R(B))                              */
-  OP_ARYPUSH,/*   A B     ary_push(R(A),R(B))                             */
-  OP_AREF,/*      A B C   R(A) := R(B)[C]                                 */
-  OP_ASET,/*      A B C   R(B)[C] := R(A)                                 */
-  OP_APOST,/*     A B C   *R(A),R(A+1)..R(A+C) := R(A)                    */
-
-  OP_STRING,/*    A Bx    R(A) := str_dup(Lit(Bx))                        */
-  OP_STRCAT,/*    A B     str_cat(R(A),R(B))                              */
-
-  OP_HASH,/*      A B C   R(A) := hash_new(R(B),R(B+1)..R(B+C))           */
-  OP_LAMBDA,/*    A Bz Cz R(A) := lambda(SEQ[Bz],Cz)                      */
-  OP_RANGE,/*     A B C   R(A) := range_new(R(B),R(B+1),C)                */
-
-  OP_OCLASS,/*    A       R(A) := ::Object                                */
-  OP_CLASS,/*     A B     R(A) := newclass(R(A),Syms(B),R(A+1))           */
-  OP_MODULE,/*    A B     R(A) := newmodule(R(A),Syms(B))                 */
-  OP_EXEC,/*      A Bx    R(A) := blockexec(R(A),SEQ[Bx])                 */
-  OP_METHOD,/*    A B     R(A).newmethod(Syms(B),R(A+1))                  */
-  OP_SCLASS,/*    A B     R(A) := R(B).singleton_class                    */
-  OP_TCLASS,/*    A       R(A) := target_class                            */
-
-  OP_DEBUG,/*     A B C   print R(A),R(B),R(C)                            */
-  OP_STOP,/*              stop VM                                         */
-  OP_ERR,/*       Bx      raise RuntimeError with message Lit(Bx)         */
-
-  OP_RSVD1,/*             reserved instruction #1                         */
-  OP_RSVD2,/*             reserved instruction #2                         */
-  OP_RSVD3,/*             reserved instruction #3                         */
-  OP_RSVD4,/*             reserved instruction #4                         */
-  OP_RSVD5,/*             reserved instruction #5                         */
+enum mrb_insn {
+#define OPCODE(x,_) OP_ ## x,
+#include "mruby/ops.h"
+#undef OPCODE
 };
 
 #define OP_L_STRICT  1
@@ -158,4 +23,20 @@ enum {
 #define OP_R_BREAK  1
 #define OP_R_RETURN 2
 
+#define PEEK_B(pc) (*(pc))
+#define PEEK_S(pc) ((pc)[0]<<8|(pc)[1])
+#define PEEK_W(pc) ((pc)[0]<<16|(pc)[1]<<8|(pc)[2])
+
+#define READ_B() PEEK_B(pc++)
+#define READ_S() (pc+=2, PEEK_S(pc-2))
+#define READ_W() (pc+=3, PEEK_W(pc-3))
+
+#define FETCH_Z() /* nothing */
+#define FETCH_B() do {a=READ_B();} while (0)
+#define FETCH_BB() do {a=READ_B(); b=READ_B();} while (0)
+#define FETCH_BBB() do {a=READ_B(); b=READ_B(); c=READ_B();} while (0)
+#define FETCH_BS() do {a=READ_B(); b=READ_S();} while (0)
+#define FETCH_S() do {a=READ_S();} while (0)
+#define FETCH_W() do {a=READ_W();} while (0)
+
 #endif  /* MRUBY_OPCODE_H */

include/mruby/ops.h

@@ -0,0 +1,112 @@
+/* operand types:
+   + Z: no operand (Z,Z,Z,Z)
+   + B: 8bit (B,S,B,B)
+   + BB: 8+8bit (BB,SB,BS,SS)
+   + BBB: 8+8+8bit (BBB,SBB,BSB,SSB)
+   + BS: 8+16bit (BS,SS,BS,BS)
+   + S: 16bit (S,S,S,S)
+   + W: 24bit (W,W,W,W)
+*/
+
+/*-----------------------------------------------------------------------
+operation code    operands      semantics
+------------------------------------------------------------------------*/
+OPCODE(NOP,        Z)        /* no operation */
+OPCODE(MOVE,       BB)       /* R(a) = R(b) */
+OPCODE(LOADL,      BB)       /* R(a) = Pool(b) */
+OPCODE(LOADI,      BB)       /* R(a) = mrb_int(b) */
+OPCODE(LOADINEG,   BB)       /* R(a) = mrb_int(-b) */
+OPCODE(LOADI__1,   B)        /* R(a) = mrb_int(-1) */
+OPCODE(LOADI_0,    B)        /* R(a) = mrb_int(0) */
+OPCODE(LOADI_1,    B)        /* R(a) = mrb_int(1) */
+OPCODE(LOADI_2,    B)        /* R(a) = mrb_int(2) */
+OPCODE(LOADI_3,    B)        /* R(a) = mrb_int(3) */
+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 */
+OPCODE(LOADT,      B)        /* R(a) = true */
+OPCODE(LOADF,      B)        /* R(a) = false */
+OPCODE(GETGV,      BB)       /* R(a) = getglobal(Syms(b)) */
+OPCODE(SETGV,      BB)       /* setglobal(Syms(b), R(a)) */
+OPCODE(GETSV,      BB)       /* R(a) = Special[Syms(b)] */
+OPCODE(SETSV,      BB)       /* Special[Syms(b)] = R(a) */
+OPCODE(GETIV,      BB)       /* R(a) = ivget(Syms(b)) */
+OPCODE(SETIV,      BB)       /* ivset(Syms(b),R(a)) */
+OPCODE(GETCV,      BB)       /* R(a) = cvget(Syms(b)) */
+OPCODE(SETCV,      BB)       /* cvset(Syms(b),R(a)) */
+OPCODE(GETCONST,   BB)       /* R(a) = constget(Syms(b)) */
+OPCODE(SETCONST,   BB)       /* constset(Syms(b),R(a)) */
+OPCODE(GETMCNST,   BB)       /* R(a) = R(a)::Syms(b) */
+OPCODE(SETMCNST,   BB)       /* R(a+1)::Syms(b) = R(a) */
+OPCODE(GETUPVAR,   BBB)      /* R(a) = uvget(b,c) */
+OPCODE(SETUPVAR,   BBB)      /* uvset(b,c,R(a)) */
+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(JMPUW,      S)        /* unwind_and_jump_to(a) */
+OPCODE(EXCEPT,     B)        /* R(a) = exc */
+OPCODE(RESCUE,     BB)       /* R(b) = R(a).isa?(R(b)) */
+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)) */
+OPCODE(SENDB,      BBB)      /* R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c),&R(a+c+1)) */
+OPCODE(CALL,       Z)        /* R(0) = self.call(frame.argc, frame.argv) */
+OPCODE(SUPER,      BB)       /* R(a) = super(R(a+1),... ,R(a+b+1)) */
+OPCODE(ARGARY,     BS)       /* R(a) = argument array (16=m5:r1:m5:d1:lv4) */
+OPCODE(ENTER,      W)        /* arg setup according to flags (23=m5:o5:r1:m5:k5:d1:b1) */
+OPCODE(KEY_P,      BB)       /* R(a) = kdict.key?(Syms(b))                      # todo */
+OPCODE(KEYEND,     Z)        /* raise unless kdict.empty?                       # todo */
+OPCODE(KARG,       BB)       /* R(a) = kdict[Syms(b)]; kdict.delete(Syms(b))    # todo */
+OPCODE(RETURN,     B)        /* return R(a) (normal) */
+OPCODE(RETURN_BLK, B)        /* return R(a) (in-block return) */
+OPCODE(BREAK,      B)        /* break R(a) */
+OPCODE(BLKPUSH,    BS)       /* R(a) = block (16=m5:r1:m5:d1:lv4) */
+OPCODE(ADD,        B)        /* R(a) = R(a)+R(a+1) */
+OPCODE(ADDI,       BB)       /* R(a) = R(a)+mrb_int(b) */
+OPCODE(SUB,        B)        /* R(a) = R(a)-R(a+1) */
+OPCODE(SUBI,       BB)       /* R(a) = R(a)-mrb_int(b) */
+OPCODE(MUL,        B)        /* R(a) = R(a)*R(a+1) */
+OPCODE(DIV,        B)        /* R(a) = R(a)/R(a+1) */
+OPCODE(EQ,         B)        /* R(a) = R(a)==R(a+1) */
+OPCODE(LT,         B)        /* R(a) = R(a)<R(a+1) */
+OPCODE(LE,         B)        /* R(a) = R(a)<=R(a+1) */
+OPCODE(GT,         B)        /* R(a) = R(a)>R(a+1) */
+OPCODE(GE,         B)        /* R(a) = R(a)>=R(a+1) */
+OPCODE(ARRAY,      BB)       /* R(a) = ary_new(R(a),R(a+1)..R(a+b)) */
+OPCODE(ARRAY2,     BBB)      /* R(a) = ary_new(R(b),R(b+1)..R(b+c)) */
+OPCODE(ARYCAT,     B)        /* ary_cat(R(a),R(a+1)) */
+OPCODE(ARYPUSH,    B)        /* ary_push(R(a),R(a+1)) */
+OPCODE(ARYDUP,     B)        /* R(a) = ary_dup(R(a)) */
+OPCODE(AREF,       BBB)      /* R(a) = R(b)[c] */
+OPCODE(ASET,       BBB)      /* R(a)[c] = R(b) */
+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*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) */
+OPCODE(METHOD,     BB)       /* R(a) = lambda(SEQ[b],L_METHOD) */
+OPCODE(RANGE_INC,  B)        /* R(a) = range_new(R(a),R(a+1),FALSE) */
+OPCODE(RANGE_EXC,  B)        /* R(a) = range_new(R(a),R(a+1),TRUE) */
+OPCODE(OCLASS,     B)        /* R(a) = ::Object */
+OPCODE(CLASS,      BB)       /* R(a) = newclass(R(a),Syms(b),R(a+1)) */
+OPCODE(MODULE,     BB)       /* R(a) = newmodule(R(a),Syms(b)) */
+OPCODE(EXEC,       BB)       /* R(a) = blockexec(R(a),SEQ[b]) */
+OPCODE(DEF,        BB)       /* R(a).newmethod(Syms(b),R(a+1)) */
+OPCODE(ALIAS,      BB)       /* alias_method(target_class,Syms(a),Syms(b)) */
+OPCODE(UNDEF,      B)        /* undef_method(target_class,Syms(a)) */
+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(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

@@ -1,5 +1,5 @@
-/*
-** mruby/proc.h - Proc class
+/**
+** @file mruby/proc.h - Proc class
 **
 ** See Copyright Notice in mruby.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
@@ -69,11 +74,11 @@ struct RProc {
 #define MRB_PROC_SET_TARGET_CLASS(p,tc) do {\
   if (MRB_PROC_ENV_P(p)) {\
     (p)->e.env->c = (tc);\
-    mrb_field_write_barrier(mrb, (struct RBasic*)(p)->e.env, (struct RBasic*)tc);\
+    mrb_field_write_barrier(mrb, (struct RBasic*)(p)->e.env, (struct RBasic*)(tc));\
   }\
   else {\
     (p)->e.target_class = (tc);\
-    mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)tc);\
+    mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)(tc));\
   }\
 } while (0)
 #define MRB_PROC_SCOPE 2048
@@ -81,43 +86,47 @@ 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);
-
-/* implementation of #send method */
-MRB_API mrb_value mrb_f_send(mrb_state *mrb, mrb_value self);
+mrb_int mrb_proc_arity(const struct RProc *p);
 
 /* 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_func_t, mrb_int, const mrb_value*);
-MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state*, mrb_int);
+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);
 /* old name */
 #define mrb_cfunc_env_get(mrb, idx) mrb_proc_cfunc_env_get(mrb, idx)
 
-#ifdef MRB_METHOD_TABLE_INLINE
+#define MRB_METHOD_FUNC_FL 1
+#define MRB_METHOD_NOARG_FL 2
+
+#ifndef MRB_USE_METHOD_T_STRUCT
 
-#define MRB_METHOD_FUNC_FL ((uintptr_t)1)
 #define MRB_METHOD_FUNC_P(m) (((uintptr_t)(m))&MRB_METHOD_FUNC_FL)
-#define MRB_METHOD_FUNC(m) ((mrb_func_t)((uintptr_t)(m)&(~MRB_METHOD_FUNC_FL)))
-#define MRB_METHOD_FROM_FUNC(m,fn) m=(mrb_method_t)((struct RProc*)((uintptr_t)(fn)|MRB_METHOD_FUNC_FL))
-#define MRB_METHOD_FROM_PROC(m,pr) m=(mrb_method_t)(struct RProc*)(pr)
+#define MRB_METHOD_NOARG_P(m) (((uintptr_t)(m))&MRB_METHOD_NOARG_FL)
+#define MRB_METHOD_NOARG_SET(m) ((m)=(mrb_method_t)(((uintptr_t)(m))|MRB_METHOD_NOARG_FL))
+#define MRB_METHOD_FUNC(m) ((mrb_func_t)((uintptr_t)(m)>>2))
+#define MRB_METHOD_FROM_FUNC(m,fn) ((m)=(mrb_method_t)((((uintptr_t)(fn))<<2)|MRB_METHOD_FUNC_FL))
+#define MRB_METHOD_FROM_PROC(m,pr) ((m)=(mrb_method_t)(pr))
 #define MRB_METHOD_PROC_P(m) (!MRB_METHOD_FUNC_P(m))
 #define MRB_METHOD_PROC(m) ((struct RProc*)(m))
 #define MRB_METHOD_UNDEF_P(m) ((m)==0)
 
 #else
 
-#define MRB_METHOD_FUNC_P(m) ((m).func_p)
+#define MRB_METHOD_FUNC_P(m) ((m).flags&MRB_METHOD_FUNC_FL)
+#define MRB_METHOD_NOARG_P(m) ((m).flags&MRB_METHOD_NOARG_FL)
 #define MRB_METHOD_FUNC(m) ((m).func)
-#define MRB_METHOD_FROM_FUNC(m,fn) do{(m).func_p=TRUE;(m).func=(fn);}while(0)
-#define MRB_METHOD_FROM_PROC(m,pr) do{(m).func_p=FALSE;(m).proc=(pr);}while(0)
+#define MRB_METHOD_NOARG_SET(m) do{(m).flags|=MRB_METHOD_NOARG_FL;}while(0)
+#define MRB_METHOD_FROM_FUNC(m,fn) do{(m).flags=MRB_METHOD_FUNC_FL;(m).func=(fn);}while(0)
+#define MRB_METHOD_FROM_PROC(m,pr) do{(m).flags=0;(m).proc=(pr);}while(0)
 #define MRB_METHOD_PROC_P(m) (!MRB_METHOD_FUNC_P(m))
 #define MRB_METHOD_PROC(m) ((m).proc)
 #define MRB_METHOD_UNDEF_P(m) ((m).proc==NULL)
 
-#endif /* MRB_METHOD_TABLE_INLINE */
+#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))
@@ -126,6 +135,8 @@ MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state*, mrb_int);
 #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/range.h

@@ -1,5 +1,5 @@
-/*
-** mruby/range.h - Range class
+/**
+** @file mruby/range.h - Range class
 **
 ** See Copyright Notice in mruby.h
 */
@@ -14,20 +14,43 @@
  */
 MRB_BEGIN_DECL
 
+#if defined(MRB_NAN_BOXING) && defined(MRB_64BIT) || defined(MRB_WORD_BOXING)
+# define MRB_RANGE_EMBED
+#endif
+
+#ifdef MRB_RANGE_EMBED
+struct RRange {
+  MRB_OBJECT_HEADER;
+  mrb_value beg;
+  mrb_value end;
+  mrb_bool excl;
+};
+# define mrb_gc_free_range(mrb, p) ((void)0)
+# define RANGE_BEG(p) ((p)->beg)
+# define RANGE_END(p) ((p)->end)
+#else
 typedef struct mrb_range_edges {
   mrb_value beg;
   mrb_value end;
 } mrb_range_edges;
-
 struct RRange {
   MRB_OBJECT_HEADER;
   mrb_range_edges *edges;
-  mrb_bool excl : 1;
+  mrb_bool excl;
 };
+# define mrb_gc_free_range(mrb, p) mrb_free(mrb, (p)->edges)
+# define RANGE_BEG(p) ((p)->edges->beg)
+# define RANGE_END(p) ((p)->edges->end)
+#endif
 
-MRB_API struct RRange* mrb_range_ptr(mrb_state *mrb, mrb_value v);
-#define mrb_range_raw_ptr(v) ((struct RRange*)mrb_ptr(v))
-#define mrb_range_value(p)  mrb_obj_value((void*)(p))
+#define mrb_range_beg(mrb, r) RANGE_BEG(mrb_range_ptr(mrb, r))
+#define mrb_range_end(mrb, r) RANGE_END(mrb_range_ptr(mrb, r))
+#define mrb_range_excl_p(mrb, r) RANGE_EXCL(mrb_range_ptr(mrb, r))
+#define mrb_range_raw_ptr(r) ((struct RRange*)mrb_ptr(r))
+#define mrb_range_value(p) mrb_obj_value((void*)(p))
+#define RANGE_EXCL(p) ((p)->excl)
+
+MRB_API struct RRange* mrb_range_ptr(mrb_state *mrb, mrb_value range);
 
 /*
  * Initializes a Range.
@@ -41,8 +64,15 @@ MRB_API struct RRange* mrb_range_ptr(mrb_state *mrb, mrb_value v);
  */
 MRB_API mrb_value mrb_range_new(mrb_state *mrb, mrb_value start, mrb_value end, mrb_bool exclude);
 
-MRB_API mrb_int mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, mrb_int len, mrb_bool trunc);
+enum mrb_range_beg_len {
+  MRB_RANGE_TYPE_MISMATCH = 0,  /* (failure) not range */
+  MRB_RANGE_OK = 1,             /* (success) range */
+  MRB_RANGE_OUT = 2             /* (failure) out of range */
+};
+
+MRB_API enum mrb_range_beg_len mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, mrb_int len, mrb_bool trunc);
 mrb_value mrb_get_values_at(mrb_state *mrb, mrb_value obj, mrb_int olen, mrb_int argc, const mrb_value *argv, mrb_value (*func)(mrb_state*, mrb_value, mrb_int));
+void mrb_gc_mark_range(mrb_state *mrb, struct RRange *r);
 
 MRB_END_DECL
 

include/mruby/re.h

@@ -1,5 +1,5 @@
-/*
-** mruby/re.h - Regexp class
+/**
+** @file mruby/re.h - Regexp class
 **
 ** See Copyright Notice in mruby.h
 */

include/mruby/string.h

@@ -1,5 +1,5 @@
-/*
-** mruby/string.h - String class
+/**
+** @file mruby/string.h - String class
 **
 ** See Copyright Notice in mruby.h
 */
@@ -16,43 +16,53 @@ MRB_BEGIN_DECL
 
 extern const char mrb_digitmap[];
 
-#define RSTRING_EMBED_LEN_MAX ((mrb_int)(sizeof(void*) * 3 - 1))
+#define RSTRING_EMBED_LEN_MAX \
+  ((mrb_int)(sizeof(void*) * 3 + sizeof(void*) - 32 / CHAR_BIT - 1))
 
 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;
       char *ptr;
     } heap;
-    char ary[RSTRING_EMBED_LEN_MAX + 1];
   } as;
 };
+struct RStringEmbed {
+  MRB_OBJECT_HEADER;
+  char ary[RSTRING_EMBED_LEN_MAX+1];
+};
+
+#define RSTR_SET_TYPE_FLAG(s, type) (RSTR_UNSET_TYPE_FLAG(s), (s)->flags |= MRB_STR_##type)
+#define RSTR_UNSET_TYPE_FLAG(s) ((s)->flags &= ~(MRB_STR_TYPE_MASK|MRB_STR_EMBED_LEN_MASK))
 
 #define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
 #define RSTR_SET_EMBED_FLAG(s) ((s)->flags |= MRB_STR_EMBED)
 #define RSTR_UNSET_EMBED_FLAG(s) ((s)->flags &= ~(MRB_STR_EMBED|MRB_STR_EMBED_LEN_MASK))
 #define RSTR_SET_EMBED_LEN(s, n) do {\
   size_t tmp_n = (n);\
-  s->flags &= ~MRB_STR_EMBED_LEN_MASK;\
-  s->flags |= (tmp_n) << MRB_STR_EMBED_LEN_SHIFT;\
+  (s)->flags &= ~MRB_STR_EMBED_LEN_MASK;\
+  (s)->flags |= (tmp_n) << MRB_STR_EMBED_LEN_SHIFT;\
 } while (0)
 #define RSTR_SET_LEN(s, n) do {\
   if (RSTR_EMBED_P(s)) {\
     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)
 #define RSTR_EMBED_LEN(s)\
   (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
-#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? (s)->as.ary : (s)->as.heap.ptr)
+#define RSTR_EMBEDDABLE_P(len) ((len) <= RSTRING_EMBED_LEN_MAX)
+
+#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
 #define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
 #define RSTR_CAPA(s) (RSTR_EMBED_P(s) ? RSTRING_EMBED_LEN_MAX : (s)->as.heap.aux.capa)
 
@@ -68,10 +78,21 @@ struct RString {
 #define RSTR_SET_NOFREE_FLAG(s) ((s)->flags |= MRB_STR_NOFREE)
 #define RSTR_UNSET_NOFREE_FLAG(s) ((s)->flags &= ~MRB_STR_NOFREE)
 
-#define RSTR_POOL_P(s) ((s)->flags & MRB_STR_POOL)
-#define RSTR_SET_POOL_FLAG(s) ((s)->flags |= MRB_STR_POOL)
+#ifdef MRB_UTF8_STRING
+# define RSTR_ASCII_P(s) ((s)->flags & MRB_STR_ASCII)
+# define RSTR_SET_ASCII_FLAG(s) ((s)->flags |= MRB_STR_ASCII)
+# define RSTR_UNSET_ASCII_FLAG(s) ((s)->flags &= ~MRB_STR_ASCII)
+# define RSTR_WRITE_ASCII_FLAG(s, v) (RSTR_UNSET_ASCII_FLAG(s), (s)->flags |= v)
+# define RSTR_COPY_ASCII_FLAG(dst, src) RSTR_WRITE_ASCII_FLAG(dst, RSTR_ASCII_P(src))
+#else
+# define RSTR_ASCII_P(s) (void)0
+# define RSTR_SET_ASCII_FLAG(s) (void)0
+# define RSTR_UNSET_ASCII_FLAG(s) (void)0
+# define RSTR_WRITE_ASCII_FLAG(s, v) (void)0
+# define RSTR_COPY_ASCII_FLAG(dst, src) (void)0
+#endif
 
-/*
+/**
  * Returns a pointer from a Ruby string
  */
 #define mrb_str_ptr(s)       ((struct RString*)(mrb_ptr(s)))
@@ -82,32 +103,36 @@ struct RString {
 #define RSTRING_CAPA(s)      RSTR_CAPA(RSTRING(s))
 #define RSTRING_END(s)       (RSTRING_PTR(s) + RSTRING_LEN(s))
 MRB_API mrb_int mrb_str_strlen(mrb_state*, struct RString*);
+#define RSTRING_CSTR(mrb,s)  mrb_string_cstr(mrb, s)
 
 #define MRB_STR_SHARED    1
 #define MRB_STR_FSHARED   2
 #define MRB_STR_NOFREE    4
-#define MRB_STR_POOL      8
-#define MRB_STR_NO_UTF   16
-#define MRB_STR_EMBED    32
-#define MRB_STR_EMBED_LEN_MASK 0x7c0
+#define MRB_STR_EMBED     8  /* type flags up to here */
+#define MRB_STR_ASCII    16
 #define MRB_STR_EMBED_LEN_SHIFT 6
+#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*);
-MRB_API void mrb_str_modify(mrb_state*, struct RString*);
 
-/*
+MRB_API void mrb_str_modify(mrb_state *mrb, struct RString *s);
+/* mrb_str_modify() with keeping ASCII flag if set */
+MRB_API void mrb_str_modify_keep_ascii(mrb_state *mrb, struct RString *s);
+
+/**
  * Finds the index of a substring in a string
  */
-MRB_API mrb_int mrb_str_index(mrb_state*, mrb_value, const char*, mrb_int, mrb_int);
+MRB_API mrb_int mrb_str_index(mrb_state *mrb, mrb_value str, const char *p, mrb_int len, mrb_int offset);
 #define mrb_str_index_lit(mrb, str, lit, off) mrb_str_index(mrb, str, lit, mrb_strlen_lit(lit), off);
 
-/*
- * Appends self to other. Returns self as a concatnated string.
+/**
+ * Appends self to other. Returns self as a concatenated string.
  *
  *
- *  Example:
+ * Example:
  *
- *     !!!c
  *     int
  *     main(int argc,
  *          char **argv)
@@ -126,35 +151,33 @@ MRB_API mrb_int mrb_str_index(mrb_state*, mrb_value, const char*, mrb_int, mrb_i
  *       str1 = mrb_str_new_lit(mrb, "abc");
  *       str2 = mrb_str_new_lit(mrb, "def");
  *
- *       // Concatnates str2 to str1.
+ *       // Concatenates str2 to str1.
  *       mrb_str_concat(mrb, str1, str2);
  *
- *      // Prints new Concatnated Ruby string.
- *      mrb_p(mrb, str1);
+ *       // Prints new Concatenated Ruby string.
+ *       mrb_p(mrb, str1);
  *
- *      mrb_close(mrb);
- *      return 0;
- *    }
+ *       mrb_close(mrb);
+ *       return 0;
+ *     } 
  *
- *
- *  Result:
+ * Result:
  *
  *     => "abcdef"
  *
- * @param [mrb_state] mrb The current mruby state.
- * @param [mrb_value] self String to concatenate.
- * @param [mrb_value] other String to append to self.
+ * @param mrb The current mruby state.
+ * @param self String to concatenate.
+ * @param other String to append to self.
  * @return [mrb_value] Returns a new String appending other to self.
  */
-MRB_API void mrb_str_concat(mrb_state*, mrb_value, mrb_value);
+MRB_API void mrb_str_concat(mrb_state *mrb, mrb_value self, mrb_value other);
 
-/*
+/**
  * Adds two strings together.
  *
  *
- *  Example:
+ * Example:
  *
- *     !!!c
  *     int
  *     main(int argc,
  *          char **argv)
@@ -178,55 +201,54 @@ MRB_API void mrb_str_concat(mrb_state*, mrb_value, mrb_value);
  *       mrb_p(mrb, a);
  *       mrb_p(mrb, b);
  *
- *       // Concatnates both Ruby strings.
+ *       // Concatenates both Ruby strings.
  *       c = mrb_str_plus(mrb, a, b);
  *
- *      // Prints new Concatnated Ruby string.
- *      mrb_p(mrb, c);
+ *       // Prints new Concatenated Ruby string.
+ *       mrb_p(mrb, c);
  *
- *      mrb_close(mrb);
- *      return 0;
- *    }
+ *       mrb_close(mrb);
+ *       return 0;
+ *     }
  *
  *
- *  Result:
+ * Result:
  *
  *     => "abc"  # First string
  *     => "def"  # Second string
- *     => "abcdef" # First & Second concatnated.
+ *     => "abcdef" # First & Second concatenated.
  *
- * @param [mrb_state] mrb The current mruby state.
- * @param [mrb_value] a First string to concatenate.
- * @param [mrb_value] b Second string to concatenate.
+ * @param mrb The current mruby state.
+ * @param a First string to concatenate.
+ * @param b Second string to concatenate.
  * @return [mrb_value] Returns a new String containing a concatenated to b.
  */
-MRB_API mrb_value mrb_str_plus(mrb_state*, mrb_value, mrb_value);
+MRB_API mrb_value mrb_str_plus(mrb_state *mrb, mrb_value a, mrb_value b);
 
-/*
+/**
  * Converts pointer into a Ruby string.
  *
- * @param [mrb_state] mrb The current mruby state.
- * @param [void*] p The pointer to convert to Ruby string.
+ * @param mrb The current mruby state.
+ * @param p The pointer to convert to Ruby string.
  * @return [mrb_value] Returns a new Ruby String.
  */
-MRB_API mrb_value mrb_ptr_to_str(mrb_state *, void*);
+MRB_API mrb_value mrb_ptr_to_str(mrb_state *mrb, void *p);
 
-/*
+/**
  * Returns an object as a Ruby string.
  *
- * @param [mrb_state] mrb The current mruby state.
- * @param [mrb_value] obj An object to return as a Ruby string.
+ * @param mrb The current mruby state.
+ * @param obj An object to return as a Ruby string.
  * @return [mrb_value] An object as a Ruby string.
  */
 MRB_API mrb_value mrb_obj_as_string(mrb_state *mrb, mrb_value obj);
 
-/*
+/**
  * Resizes the string's length. Returns the amount of characters
  * in the specified by len.
  *
  * Example:
  *
- *     !!!c
  *     int
  *     main(int argc,
  *          char **argv)
@@ -251,21 +273,20 @@ MRB_API mrb_value mrb_obj_as_string(mrb_state *mrb, mrb_value obj);
  *
  * Result:
  *
- *     => "Hello"
+ *      => "Hello"
  *
- * @param [mrb_state] mrb The current mruby state.
- * @param [mrb_value] str The Ruby string to resize.
- * @param [mrb_value] len The length.
+ * @param mrb The current mruby state.
+ * @param str The Ruby string to resize.
+ * @param len The length.
  * @return [mrb_value] An object as a Ruby string.
  */
 MRB_API mrb_value mrb_str_resize(mrb_state *mrb, mrb_value str, mrb_int len);
 
-/*
+/**
  * Returns a sub string.
  *
- *  Example:
+ * Example:
  *
- *     !!!c
  *     int
  *     main(int argc,
  *     char const **argv)
@@ -291,99 +312,103 @@ MRB_API mrb_value mrb_str_resize(mrb_state *mrb, mrb_value str, mrb_int len);
  *       return 0;
  *     }
  *
- *  Result:
+ * Result:
  *
  *     => "He"
  *
- * @param [mrb_state] mrb The current mruby state.
- * @param [mrb_value] str Ruby string.
- * @param [mrb_int] beg The beginning point of the sub-string.
- * @param [mrb_int] len The end point of the sub-string.
+ * @param mrb The current mruby state.
+ * @param str Ruby string.
+ * @param beg The beginning point of the sub-string.
+ * @param len The end point of the sub-string.
  * @return [mrb_value] An object as a Ruby sub-string.
  */
 MRB_API mrb_value mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len);
 
-/*
+/**
  * Returns a Ruby string type.
  *
  *
- * @param [mrb_state] mrb The current mruby state.
- * @param [mrb_value] str Ruby string.
+ * @param mrb The current mruby state.
+ * @param str Ruby string.
  * @return [mrb_value] A Ruby string.
  */
+MRB_API mrb_value mrb_ensure_string_type(mrb_state *mrb, mrb_value str);
+MRB_API mrb_value mrb_check_string_type(mrb_state *mrb, mrb_value str);
+/* obsolete: use mrb_ensure_string_type() instead */
 MRB_API mrb_value mrb_string_type(mrb_state *mrb, mrb_value str);
 
-MRB_API mrb_value mrb_check_string_type(mrb_state *mrb, mrb_value str);
+
 MRB_API mrb_value mrb_str_new_capa(mrb_state *mrb, size_t capa);
 MRB_API mrb_value mrb_str_buf_new(mrb_state *mrb, size_t capa);
 
-MRB_API const char *mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr);
+/* NULL terminated C string from mrb_value */
+MRB_API const char *mrb_string_cstr(mrb_state *mrb, mrb_value str);
+/* NULL terminated C string from mrb_value; `str` will be updated */
+MRB_API const char *mrb_string_value_cstr(mrb_state *mrb, mrb_value *str);
+/* obslete: use RSTRING_PTR() */
 MRB_API const char *mrb_string_value_ptr(mrb_state *mrb, mrb_value str);
-/*
- * Returns the length of the Ruby string.
- *
- *
- * @param [mrb_state] mrb The current mruby state.
- * @param [mrb_value] str Ruby string.
- * @return [mrb_int] The length of the passed in Ruby string.
- */
+/* obslete: use RSTRING_LEN() */
 MRB_API mrb_int mrb_string_value_len(mrb_state *mrb, mrb_value str);
 
-/*
+/**
  * Duplicates a string object.
  *
  *
- * @param [mrb_state] mrb The current mruby state.
- * @param [mrb_value] str Ruby string.
+ * @param mrb The current mruby state.
+ * @param str Ruby string.
  * @return [mrb_value] Duplicated Ruby string.
  */
 MRB_API mrb_value mrb_str_dup(mrb_state *mrb, mrb_value str);
 
-/*
+/**
  * Returns a symbol from a passed in Ruby string.
  *
- * @param [mrb_state] mrb The current mruby state.
- * @param [mrb_value] self Ruby string.
+ * @param mrb The current mruby state.
+ * @param self Ruby string.
  * @return [mrb_value] A symbol.
  */
 MRB_API mrb_value mrb_str_intern(mrb_state *mrb, mrb_value self);
 
 MRB_API mrb_value mrb_str_to_inum(mrb_state *mrb, mrb_value str, mrb_int base, mrb_bool badcheck);
+MRB_API mrb_value mrb_cstr_to_inum(mrb_state *mrb, const char *s, mrb_int base, mrb_bool badcheck);
 MRB_API double mrb_str_to_dbl(mrb_state *mrb, mrb_value str, mrb_bool badcheck);
+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.
  *
- * @param [mrb_state] mrb The current mruby state.
- * @param [mrb_value] str1 Ruby string to compare.
- * @param [mrb_value] str2 Ruby string to compare.
+ * @param mrb The current mruby state.
+ * @param str1 Ruby string to compare.
+ * @param str2 Ruby string to compare.
  * @return [mrb_value] boolean value.
  */
 MRB_API mrb_bool mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2);
 
-/*
- * Returns a concated string comprised of a Ruby string and a C string.
+/**
+ * Returns a concatenated string comprised of a Ruby string and a C string.
  *
- * @param [mrb_state] mrb The current mruby state.
- * @param [mrb_value] str Ruby string.
- * @param [const char *] ptr A C string.
- * @param [size_t] len length of C string.
+ * @param mrb The current mruby state.
+ * @param str Ruby string.
+ * @param ptr A C string.
+ * @param len length of C string.
  * @return [mrb_value] A Ruby string.
  * @see mrb_str_cat_cstr
  */
 MRB_API mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len);
 
-/*
- * Returns a concated string comprised of a Ruby string and a C string.
+/**
+ * Returns a concatenated string comprised of a Ruby string and a C string.
  *
- * @param [mrb_state] mrb The current mruby state.
- * @param [mrb_value] str Ruby string.
- * @param [const char *] ptr A C string.
+ * @param mrb The current mruby state.
+ * @param str Ruby string.
+ * @param ptr A C string.
  * @return [mrb_value] A Ruby string.
  * @see mrb_str_cat
  */
@@ -391,17 +416,17 @@ MRB_API mrb_value mrb_str_cat_cstr(mrb_state *mrb, mrb_value str, const char *pt
 MRB_API mrb_value mrb_str_cat_str(mrb_state *mrb, mrb_value str, mrb_value str2);
 #define mrb_str_cat_lit(mrb, str, lit) mrb_str_cat(mrb, str, lit, mrb_strlen_lit(lit))
 
-/*
+/**
  * Adds str2 to the end of str1.
  */
 MRB_API mrb_value mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2);
 
-/*
+/**
  * Returns 0 if both Ruby strings are equal. Returns a value < 0 if Ruby str1 is less than Ruby str2. Returns a value > 0 if Ruby str2 is greater than Ruby str1.
  */
 MRB_API int mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2);
 
-/*
+/**
  * Returns a newly allocated C string from a Ruby string.
  * This is an utility function to pass a Ruby string to C library functions.
  *
@@ -412,29 +437,33 @@ MRB_API int mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2);
  * - Caller can modify returned string without affecting Ruby string
  *   (e.g. it can be used for mkstemp(3)).
  *
- * @param [mrb_state *] mrb The current mruby state.
- * @param [mrb_value] str Ruby string. Must be an instance of String.
+ * @param mrb The current mruby state.
+ * @param str Ruby string. Must be an instance of String.
  * @return [char *] A newly allocated C string.
  */
 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);
 
-/*
+/**
  * Returns a printable version of str, surrounded by quote marks, with special characters escaped.
  */
 mrb_value mrb_str_inspect(mrb_state *mrb, mrb_value str);
 
-void mrb_noregexp(mrb_state *mrb, mrb_value self);
-void mrb_regexp_check(mrb_state *mrb, mrb_value obj);
-
 /* For backward compatibility */
 #define mrb_str_cat2(mrb, str, ptr) mrb_str_cat_cstr(mrb, str, ptr)
 #define mrb_str_buf_cat(mrb, str, ptr, len) mrb_str_cat(mrb, str, ptr, len)
 #define mrb_str_buf_append(mrb, str, str2) mrb_str_cat_str(mrb, str, str2)
 
+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_utf8len(const char *str, const char *end);
+mrb_int mrb_utf8_strlen(const char *str, mrb_int byte_len);
+#endif
+
 MRB_END_DECL
 
 #endif  /* MRUBY_STRING_H */

include/mruby/throw.h

@@ -1,5 +1,5 @@
-/*
-** mruby/throw.h - mruby exception throwing handler
+/**
+** @file mruby/throw.h - mruby exception throwing handler
 **
 ** See Copyright Notice in mruby.h
 */
@@ -13,15 +13,21 @@
 # endif
 #endif
 
-#if defined(MRB_ENABLE_CXX_EXCEPTION) && defined(__cplusplus)
+#if defined(MRB_ENABLE_CXX_EXCEPTION)
 
-#define MRB_TRY(buf) do { try {
+# if defined(__cplusplus)
+
+#define MRB_TRY(buf) try {
 #define MRB_CATCH(buf) } catch(mrb_jmpbuf_impl e) { if (e != (buf)->impl) { throw e; }
-#define MRB_END_EXC(buf)  } } while(0)
+#define MRB_END_EXC(buf)  }
 
 #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>
@@ -34,9 +40,9 @@ typedef mrb_int mrb_jmpbuf_impl;
 #define MRB_LONGJMP longjmp
 #endif
 
-#define MRB_TRY(buf) do { if (MRB_SETJMP((buf)->impl) == 0) {
+#define MRB_TRY(buf) if (MRB_SETJMP((buf)->impl) == 0) {
 #define MRB_CATCH(buf) } else {
-#define MRB_END_EXC(buf) } } while(0)
+#define MRB_END_EXC(buf) }
 
 #define MRB_THROW(buf) MRB_LONGJMP((buf)->impl, 1);
 #define mrb_jmpbuf_impl jmp_buf
@@ -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

@@ -1,5 +1,5 @@
-/*
-** mruby/value.h - mruby value definitions
+/**
+** @file mruby/value.h - mruby value definitions
 **
 ** See Copyright Notice in mruby.h
 */
@@ -9,28 +9,43 @@
 
 #include "common.h"
 
-/**
+/*
  * MRuby Value definition functions and macros.
  */
 MRB_BEGIN_DECL
 
+/**
+ * mruby Symbol.
+ * @class mrb_sym
+ *
+ * You can create an mrb_sym by simply using mrb_str_intern() or mrb_intern_cstr()
+ */
 typedef uint32_t mrb_sym;
+
+/**
+ * mruby Boolean.
+ * @class mrb_bool
+ *
+ *
+ * Used internally to represent boolean. Can be TRUE or FALSE.
+ * Not to be confused with Ruby's boolean classes, which can be
+ * obtained using mrb_false_value() and mrb_true_value()
+ */
 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"
+# define PRIu64 "llu"
 # define PRIx64 "llx"
 # define PRIo16 "ho"
 # define PRId16 "hd"
+# define PRIu16 "hu"
 # define PRIx16 "hx"
 # define PRIo32 "o"
 # define PRId32 "d"
+# define PRIu32 "u"
 # define PRIx32 "x"
 #else
 # include <inttypes.h>
@@ -39,33 +54,34 @@ 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
 #endif
 
+#ifdef MRB_ENDIAN_BIG
+# define MRB_ENDIAN_LOHI(a,b) a b
+#else
+# 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;
@@ -73,15 +89,12 @@ MRB_API double mrb_float_read(const char*, char**);
 #endif
 
 #if defined _MSC_VER && _MSC_VER < 1900
-# ifndef __cplusplus
-#  define inline __inline
-# endif
 # include <stdarg.h>
 MRB_API int mrb_msvc_vsnprintf(char *s, size_t n, const char *format, va_list arg);
 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
@@ -94,34 +107,36 @@ static const unsigned int IEEE754_INFINITY_BITS_SINGLE = 0x7F800000;
 #endif
 
 enum mrb_vtype {
-  MRB_TT_FALSE = 0,   /*   0 */
-  MRB_TT_FREE,        /*   1 */
-  MRB_TT_TRUE,        /*   2 */
-  MRB_TT_FIXNUM,      /*   3 */
-  MRB_TT_SYMBOL,      /*   4 */
-  MRB_TT_UNDEF,       /*   5 */
-  MRB_TT_FLOAT,       /*   6 */
-  MRB_TT_CPTR,        /*   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
@@ -140,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)
@@ -148,8 +170,28 @@ typedef void mrb_value;
 #include "boxing_no.h"
 #endif
 
+#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)
 #endif
 #ifndef mrb_undef_p
 #define mrb_undef_p(o) (mrb_type(o) == MRB_TT_UNDEF)
@@ -157,25 +199,82 @@ typedef void mrb_value;
 #ifndef mrb_nil_p
 #define mrb_nil_p(o)  (mrb_type(o) == MRB_TT_FALSE && !mrb_fixnum(o))
 #endif
+#ifndef mrb_false_p
+#define mrb_false_p(o) (mrb_type(o) == MRB_TT_FALSE && !!mrb_fixnum(o))
+#endif
+#ifndef mrb_true_p
+#define mrb_true_p(o)  (mrb_type(o) == MRB_TT_TRUE)
+#endif
+#ifndef MRB_NO_FLOAT
+#ifndef mrb_float_p
+#define mrb_float_p(o) (mrb_type(o) == MRB_TT_FLOAT)
+#endif
+#endif
+#ifndef mrb_array_p
+#define mrb_array_p(o) (mrb_type(o) == MRB_TT_ARRAY)
+#endif
+#ifndef mrb_string_p
+#define mrb_string_p(o) (mrb_type(o) == MRB_TT_STRING)
+#endif
+#ifndef mrb_hash_p
+#define mrb_hash_p(o) (mrb_type(o) == MRB_TT_HASH)
+#endif
+#ifndef mrb_cptr_p
+#define mrb_cptr_p(o) (mrb_type(o) == MRB_TT_CPTR)
+#endif
+#ifndef mrb_exception_p
+#define mrb_exception_p(o) (mrb_type(o) == MRB_TT_EXCEPTION)
+#endif
+#ifndef mrb_free_p
+#define mrb_free_p(o) (mrb_type(o) == MRB_TT_FREE)
+#endif
+#ifndef mrb_object_p
+#define mrb_object_p(o) (mrb_type(o) == MRB_TT_OBJECT)
+#endif
+#ifndef mrb_class_p
+#define mrb_class_p(o) (mrb_type(o) == MRB_TT_CLASS)
+#endif
+#ifndef mrb_module_p
+#define mrb_module_p(o) (mrb_type(o) == MRB_TT_MODULE)
+#endif
+#ifndef mrb_iclass_p
+#define mrb_iclass_p(o) (mrb_type(o) == MRB_TT_ICLASS)
+#endif
+#ifndef mrb_sclass_p
+#define mrb_sclass_p(o) (mrb_type(o) == MRB_TT_SCLASS)
+#endif
+#ifndef mrb_proc_p
+#define mrb_proc_p(o) (mrb_type(o) == MRB_TT_PROC)
+#endif
+#ifndef mrb_range_p
+#define mrb_range_p(o) (mrb_type(o) == MRB_TT_RANGE)
+#endif
+#ifndef mrb_env_p
+#define mrb_env_p(o) (mrb_type(o) == MRB_TT_ENV)
+#endif
+#ifndef mrb_data_p
+#define mrb_data_p(o) (mrb_type(o) == MRB_TT_DATA)
+#endif
+#ifndef mrb_fiber_p
+#define mrb_fiber_p(o) (mrb_type(o) == MRB_TT_FIBER)
+#endif
+#ifndef mrb_istruct_p
+#define mrb_istruct_p(o) (mrb_type(o) == MRB_TT_ISTRUCT)
+#endif
+#ifndef mrb_break_p
+#define mrb_break_p(o) (mrb_type(o) == MRB_TT_BREAK)
+#endif
 #ifndef mrb_bool
 #define mrb_bool(o)   (mrb_type(o) != MRB_TT_FALSE)
 #endif
-#ifndef MRB_WITHOUT_FLOAT
-#define mrb_float_p(o) (mrb_type(o) == MRB_TT_FLOAT)
-#endif
-#define mrb_symbol_p(o) (mrb_type(o) == MRB_TT_SYMBOL)
-#define mrb_array_p(o) (mrb_type(o) == MRB_TT_ARRAY)
-#define mrb_string_p(o) (mrb_type(o) == MRB_TT_STRING)
-#define mrb_hash_p(o) (mrb_type(o) == MRB_TT_HASH)
-#define mrb_cptr_p(o) (mrb_type(o) == MRB_TT_CPTR)
-#define mrb_exception_p(o) (mrb_type(o) == MRB_TT_EXCEPTION)
 #define mrb_test(o)   mrb_bool(o)
-MRB_API mrb_bool mrb_regexp_p(struct mrb_state*, mrb_value);
 
-/*
+/**
  * Returns a float in Ruby.
+ *
+ * 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;
@@ -185,7 +284,7 @@ MRB_INLINE mrb_value mrb_float_value(struct mrb_state *mrb, mrb_float f)
 }
 #endif
 
-static inline mrb_value
+MRB_INLINE mrb_value
 mrb_cptr_value(struct mrb_state *mrb, void *p)
 {
   mrb_value v;
@@ -194,17 +293,24 @@ mrb_cptr_value(struct mrb_state *mrb, void *p)
   return v;
 }
 
-/*
- * Returns a fixnum in Ruby.
+/**
+ * Returns an integer in Ruby.
  */
-MRB_INLINE mrb_value mrb_fixnum_value(mrb_int i)
+MRB_INLINE mrb_value mrb_int_value(struct mrb_state *mrb, mrb_int i)
 {
   mrb_value v;
-  SET_INT_VALUE(v, i);
+  SET_INT_VALUE(mrb, v, i);
   return v;
 }
 
-static inline mrb_value
+MRB_INLINE mrb_value mrb_fixnum_value(mrb_int i)
+{
+  mrb_value v;
+  SET_FIXNUM_VALUE(v, i);
+  return v;
+}
+
+MRB_INLINE mrb_value
 mrb_symbol_value(mrb_sym i)
 {
   mrb_value v;
@@ -212,7 +318,7 @@ mrb_symbol_value(mrb_sym i)
   return v;
 }
 
-static inline mrb_value
+MRB_INLINE mrb_value
 mrb_obj_value(void *p)
 {
   mrb_value v;
@@ -222,8 +328,7 @@ mrb_obj_value(void *p)
   return v;
 }
 
-
-/*
+/**
  * Get a nil mrb_value object.
  *
  * @return
@@ -236,7 +341,7 @@ MRB_INLINE mrb_value mrb_nil_value(void)
   return v;
 }
 
-/*
+/**
  * Returns false in Ruby.
  */
 MRB_INLINE mrb_value mrb_false_value(void)
@@ -246,7 +351,7 @@ MRB_INLINE mrb_value mrb_false_value(void)
   return v;
 }
 
-/*
+/**
  * Returns true in Ruby.
  */
 MRB_INLINE mrb_value mrb_true_value(void)
@@ -256,7 +361,7 @@ MRB_INLINE mrb_value mrb_true_value(void)
   return v;
 }
 
-static inline mrb_value
+MRB_INLINE mrb_value
 mrb_bool_value(mrb_bool boolean)
 {
   mrb_value v;
@@ -264,7 +369,7 @@ mrb_bool_value(mrb_bool boolean)
   return v;
 }
 
-static inline mrb_value
+MRB_INLINE mrb_value
 mrb_undef_value(void)
 {
   mrb_value v;
@@ -272,34 +377,25 @@ mrb_undef_value(void)
   return v;
 }
 
-#ifdef MRB_USE_ETEXT_EDATA
-#if (defined(__APPLE__) && defined(__MACH__))
-#include <mach-o/getsect.h>
-static inline mrb_bool
-mrb_ro_data_p(const char *p)
-{
-  return (const char*)get_etext() < p && p < (const char*)get_edata();
-}
-#else
-extern char _etext[];
-#ifdef MRB_NO_INIT_ARRAY_START
-extern char _edata[];
+#if defined(MRB_USE_ETEXT_EDATA) && !defined(MRB_USE_LINK_TIME_RO_DATA_P)
+# ifdef __GNUC__
+#  warning MRB_USE_ETEXT_EDATA is deprecated. Define MRB_USE_LINK_TIME_RO_DATA_P instead.
+# endif
+# define MRB_USE_LINK_TIME_RO_DATA_P
+#endif
 
-static inline mrb_bool
-mrb_ro_data_p(const char *p)
-{
-  return _etext < p && p < _edata;
-}
-#else
+#if defined(MRB_USE_CUSTOM_RO_DATA_P)
+/* If you define `MRB_USE_CUSTOM_RO_DATA_P`, you must implement `mrb_ro_data_p()`. */
+mrb_bool mrb_ro_data_p(const char *p);
+#elif defined(MRB_USE_LINK_TIME_RO_DATA_P)
+extern char __ehdr_start[];
 extern char __init_array_start[];
 
 static inline mrb_bool
 mrb_ro_data_p(const char *p)
 {
-  return _etext < p && p < (char*)&__init_array_start;
+  return __ehdr_start < p && p < __init_array_start;
 }
-#endif
-#endif
 #else
 # define mrb_ro_data_p(p) FALSE
 #endif

include/mruby/variable.h

@@ -1,5 +1,5 @@
-/*
-** mruby/variable.h - mruby variables
+/**
+** @file mruby/variable.h - mruby variables
 **
 ** See Copyright Notice in mruby.h
 */
@@ -31,19 +31,18 @@ struct global_entry {
 
 mrb_value mrb_vm_special_get(mrb_state*, mrb_sym);
 void mrb_vm_special_set(mrb_state*, mrb_sym, mrb_value);
-mrb_value mrb_vm_iv_get(mrb_state*, mrb_sym);
-void mrb_vm_iv_set(mrb_state*, mrb_sym, mrb_value);
 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);
 MRB_API void mrb_const_remove(mrb_state*, mrb_value, mrb_sym);
 
-MRB_API mrb_bool mrb_iv_p(mrb_state *mrb, mrb_sym sym);
-MRB_API void mrb_iv_check(mrb_state *mrb, mrb_sym sym);
+MRB_API mrb_bool mrb_iv_name_sym_p(mrb_state *mrb, mrb_sym sym);
+MRB_API void mrb_iv_name_sym_check(mrb_state *mrb, mrb_sym sym);
 MRB_API mrb_value mrb_obj_iv_get(mrb_state *mrb, struct RObject *obj, mrb_sym sym);
 MRB_API void mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v);
 MRB_API mrb_bool mrb_obj_iv_defined(mrb_state *mrb, struct RObject *obj, mrb_sym sym);
@@ -99,18 +98,15 @@ MRB_API void mrb_gv_set(mrb_state *mrb, mrb_sym sym, mrb_value val);
  *
  * Example:
  *
- *     !!!ruby
  *     # Ruby style
  *     $value = nil
  *
- *     !!!c
  *     // C style
  *     mrb_sym sym = mrb_intern_lit(mrb, "$value");
  *     mrb_gv_remove(mrb, sym);
  *
  * @param mrb The mruby state reference
  * @param sym The name of the global variable
- * @param val The value of the global variable
  */
 MRB_API void mrb_gv_remove(mrb_state *mrb, mrb_sym sym);
 
@@ -119,12 +115,14 @@ MRB_API void mrb_mod_cv_set(mrb_state *mrb, struct RClass * c, mrb_sym sym, mrb_
 MRB_API void mrb_cv_set(mrb_state *mrb, mrb_value mod, mrb_sym sym, mrb_value v);
 MRB_API mrb_bool mrb_cv_defined(mrb_state *mrb, mrb_value mod, mrb_sym sym);
 mrb_value mrb_obj_iv_inspect(mrb_state*, struct RObject*);
+void mrb_obj_iv_set_force(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v);
 mrb_value mrb_mod_constants(mrb_state *mrb, mrb_value mod);
 mrb_value mrb_f_global_variables(mrb_state *mrb, mrb_value self);
 mrb_value mrb_obj_instance_variables(mrb_state*, mrb_value);
 mrb_value mrb_mod_class_variables(mrb_state*, mrb_value);
 mrb_value mrb_mod_cv_get(mrb_state *mrb, struct RClass * c, mrb_sym sym);
 mrb_bool mrb_mod_cv_defined(mrb_state *mrb, struct RClass * c, mrb_sym sym);
+mrb_bool mrb_ident_p(const char *s, mrb_int len);
 
 /* GC functions */
 void mrb_gc_mark_gv(mrb_state*);
@@ -133,6 +131,10 @@ void mrb_gc_mark_iv(mrb_state*, struct RObject*);
 size_t mrb_gc_mark_iv_size(mrb_state*, struct RObject*);
 void mrb_gc_free_iv(mrb_state*, struct RObject*);
 
+/* return non zero to break the loop */
+typedef int (mrb_iv_foreach_func)(mrb_state*,mrb_sym,mrb_value,void*);
+MRB_API void mrb_iv_foreach(mrb_state *mrb, mrb_value obj, mrb_iv_foreach_func *func, void *p);
+
 MRB_END_DECL
 
 #endif  /* MRUBY_VARIABLE_H */

include/mruby/version.h

@@ -1,5 +1,5 @@
-/*
-** mruby/version.h - mruby version definition
+/**
+** @file mruby/version.h - mruby version definition
 **
 ** See Copyright Notice in mruby.h
 */
@@ -27,7 +27,7 @@ MRB_BEGIN_DECL
 /*
  * The version of Ruby used by mruby.
  */
-#define MRUBY_RUBY_VERSION "1.9"
+#define MRUBY_RUBY_VERSION "3.0"
 
 /*
  * Ruby engine.
@@ -37,17 +37,17 @@ MRB_BEGIN_DECL
 /*
  * Major release version number.
  */
-#define MRUBY_RELEASE_MAJOR 1
+#define MRUBY_RELEASE_MAJOR 3
 
 /*
  * Minor release version number.
  */
-#define MRUBY_RELEASE_MINOR 4
+#define MRUBY_RELEASE_MINOR 0
 
 /*
  * Tiny release version number.
  */
-#define MRUBY_RELEASE_TEENY 1
+#define MRUBY_RELEASE_TEENY 0
 
 /*
  * The mruby version.
@@ -62,22 +62,36 @@ MRB_BEGIN_DECL
 /*
  * Release year.
  */
-#define MRUBY_RELEASE_YEAR 2018
+#define MRUBY_RELEASE_YEAR 2020
 
 /*
  * Release month.
  */
-#define MRUBY_RELEASE_MONTH 4
+#define MRUBY_RELEASE_MONTH 10
 
 /*
  * Release day.
  */
-#define MRUBY_RELEASE_DAY 27
+#define MRUBY_RELEASE_DAY 16
 
 /*
  * Release date as a string.
  */
-#define MRUBY_RELEASE_DATE MRB_STRINGIZE(MRUBY_RELEASE_YEAR) "-" MRB_STRINGIZE(MRUBY_RELEASE_MONTH) "-" MRB_STRINGIZE(MRUBY_RELEASE_DAY)
+#define MRUBY_RELEASE_DATE    \
+  MRUBY_RELEASE_YEAR_STR "-"  \
+  MRUBY_RELEASE_MONTH_STR "-" \
+  MRUBY_RELEASE_DAY_STR
+#define MRUBY_RELEASE_YEAR_STR MRB_STRINGIZE(MRUBY_RELEASE_YEAR)
+#if MRUBY_RELEASE_MONTH < 10
+#define MRUBY_RELEASE_MONTH_STR "0" MRB_STRINGIZE(MRUBY_RELEASE_MONTH)
+#else
+#define MRUBY_RELEASE_MONTH_STR MRB_STRINGIZE(MRUBY_RELEASE_MONTH)
+#endif
+#if MRUBY_RELEASE_DAY < 10
+#define MRUBY_RELEASE_DAY_STR "0" MRB_STRINGIZE(MRUBY_RELEASE_DAY)
+#else
+#define MRUBY_RELEASE_DAY_STR MRB_STRINGIZE(MRUBY_RELEASE_DAY)
+#endif
 
 /*
  * The year mruby was first created.
@@ -92,9 +106,9 @@ MRB_BEGIN_DECL
 /*
  * mruby's version, and release date.
  */
-#define MRUBY_DESCRIPTION      \
-  "mruby " MRUBY_VERSION       \
-  " (" MRUBY_RELEASE_DATE ") " \
+#define MRUBY_DESCRIPTION     \
+  "mruby " MRUBY_VERSION      \
+  " (" MRUBY_RELEASE_DATE ")" \
 
 /*
  * mruby's copyright information.

lib/mruby-core-ext.rb

@@ -1,3 +1,5 @@
+autoload :Pathname, 'pathname'
+
 class Object
   class << self
     def attr_block(*syms)
@@ -16,62 +18,10 @@ class String
   def relative_path
     relative_path_from(Dir.pwd)
   end
-
-  # Compatible with 1.9 on 1.8
-  def %(params)
-    if params.is_a?(Hash)
-      str = self.clone
-      params.each do |k, v|
-        str.gsub!("%{#{k}}") { v }
-      end
-      str
-    else
-      if params.is_a?(Array)
-        sprintf(self, *params)
-      else
-        sprintf(self, params)
-      end
-    end
-  end
-end
-
-class Symbol
-  # Compatible with 1.9 on 1.8
-  def to_proc
-    proc { |obj, *args| obj.send(self, *args) }
-  end
-end
-
-module Enumerable
-  # Compatible with 1.9 on 1.8
-  def each_with_object(memo)
-    return to_enum :each_with_object, memo unless block_given?
-    each { |obj| yield obj, memo }
-    memo
-  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

@@ -1,7 +1,11 @@
+require "mruby-core-ext"
 require "mruby/build/load_gems"
 require "mruby/build/command"
 
 module MRuby
+  autoload :Gem, "mruby/gem"
+  autoload :Lockfile, "mruby/lockfile"
+
   class << self
     def targets
       @targets ||= {}
@@ -22,7 +26,6 @@ module MRuby
 
     def initialize(name, &block)
       @name, @initializer = name.to_s, block
-      MRuby::Toolchain.toolchains ||= {}
       MRuby::Toolchain.toolchains[@name] = self
     end
 
@@ -30,13 +33,8 @@ module MRuby
       conf.instance_exec(conf, params, &@initializer)
     end
 
-    def self.load
-      Dir.glob("#{MRUBY_ROOT}/tasks/toolchains/*.rake").each do |file|
-        Kernel.load file
-      end
-    end
+    self.toolchains = {}
   end
-  Toolchain.load
 
   class Build
     class << self
@@ -45,9 +43,11 @@ module MRuby
     include Rake::DSL
     include LoadGems
     attr_accessor :name, :bins, :exts, :file_separator, :build_dir, :gem_clone_dir
-    attr_reader :libmruby, :gems, :toolchains
+    attr_reader :libmruby_objs, :gems, :toolchains, :gem_dir_to_repo_url
     attr_writer :enable_bintest, :enable_test
 
+    alias libmruby libmruby_objs
+
     COMPILERS = %w(cc cxx objc asm)
     COMMANDS = COMPILERS + %w(linker archiver yacc gperf git exts mrbc)
     attr_block MRuby::Build::COMMANDS
@@ -68,7 +68,7 @@ module MRuby
 
         @file_separator = '/'
         @build_dir = "#{build_dir}/#{@name}"
-        @gem_clone_dir = "#{build_dir}/mrbgems"
+        @gem_clone_dir = "#{build_dir}/repos/#{@name}"
         @cc = Command::Compiler.new(self, %w(.c))
         @cxx = Command::Compiler.new(self, %w(.cc .cxx .cpp))
         @objc = Command::Compiler.new(self, %w(.m))
@@ -81,23 +81,29 @@ module MRuby
         @mrbc = Command::Mrbc.new(self)
 
         @bins = []
-        @gems, @libmruby = MRuby::Gem::List.new, []
+        @gems = MRuby::Gem::List.new
+        @libmruby_objs = []
         @build_mrbtest_lib_only = false
         @cxx_exception_enabled = false
         @cxx_exception_disabled = false
         @cxx_abi_enabled = false
         @enable_bintest = false
         @enable_test = false
+        @enable_lock = true
         @toolchains = []
+        @gem_dir_to_repo_url = {}
 
         MRuby.targets[@name] = self
       end
 
-      MRuby::Build.current = MRuby.targets[@name]
-      MRuby.targets[@name].instance_eval(&block)
+      current = MRuby.targets[@name]
+      MRuby::Build.current = current
+      current.instance_eval(&block)
+      current.build_mrbtest if current.test_enabled?
+    end
 
-      build_mrbc_exec if name == 'host'
-      build_mrbtest if test_enabled?
+    def debug_enabled?
+      @enable_debug
     end
 
     def enable_debug
@@ -108,6 +114,16 @@ module MRuby
         end
       end
       @mrbc.compile_options += ' -g'
+
+      @enable_debug = true
+    end
+
+    def disable_lock
+      @enable_lock = false
+    end
+
+    def lock_enabled?
+      Lockfile.enabled? && @enable_lock
     end
 
     def disable_cxx_exception
@@ -147,19 +163,17 @@ module MRuby
       compilers.each { |c|
         c.defines += %w(MRB_ENABLE_CXX_EXCEPTION MRB_ENABLE_CXX_ABI)
         c.flags << c.cxx_compile_flag
+        c.flags = c.flags.flatten - c.cxx_invalid_flags.flatten
       }
-      compilers.each { |c| c.flags << c.cxx_compile_flag }
       linker.command = cxx.command if toolchains.find { |v| v == 'gcc' }
       @cxx_abi_enabled = true
     end
 
     def compile_as_cxx src, cxx_src, obj = nil, includes = []
-      src = File.absolute_path src
-      cxx_src = File.absolute_path cxx_src
       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
@@ -167,7 +181,7 @@ module MRuby
 #ifndef MRB_ENABLE_CXX_ABI
 extern "C" {
 #endif
-#include "#{src}"
+#include "#{File.absolute_path src}"
 #ifndef MRB_ENABLE_CXX_ABI
 }
 #endif
@@ -182,6 +196,7 @@ EOS
     end
 
     def enable_bintest
+      raise "bintest works only on 'host' target" unless name == "host"
       @enable_bintest = true
     end
 
@@ -190,10 +205,15 @@ EOS
     end
 
     def toolchain(name, params={})
-      tc = Toolchain.toolchains[name.to_s]
-      fail "Unknown #{name} toolchain" unless tc
+      name = name.to_s
+      tc = Toolchain.toolchains[name] || begin
+        path = "#{MRUBY_ROOT}/tasks/toolchains/#{name}.rake"
+        fail "Unknown #{name} toolchain" unless File.exist?(path)
+        load path
+        Toolchain.toolchains[name]
+      end
       tc.setup(self, params)
-      @toolchains.unshift name.to_s
+      @toolchains.unshift name
     end
 
     def primary_toolchain
@@ -220,12 +240,18 @@ EOS
       gem :core => 'mruby-bin-mrbc'
     end
 
+    def locks
+      Lockfile.build(@name)
+    end
+
     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
@@ -249,23 +275,18 @@ EOS
       if name.is_a?(Array)
         name.flatten.map { |n| filename(n) }
       else
-        '"%s"' % name.gsub('/', file_separator)
-      end
-    end
-
-    def cygwin_filename(name)
-      if name.is_a?(Array)
-        name.flatten.map { |n| cygwin_filename(n) }
-      else
-        '"%s"' % `cygpath -w "#{filename(name)}"`.strip
+        name.gsub('/', file_separator)
       end
     end
 
     def exefile(name)
       if name.is_a?(Array)
         name.flatten.map { |n| exefile(n) }
-      else
+      elsif File.extname(name).empty?
         "#{name}#{exts.executable}"
+      else
+        # `name` sometimes have (non-standard) extension (e.g. `.bat`).
+        name
       end
     end
 
@@ -293,18 +314,22 @@ EOS
       @build_mrbtest_lib_only
     end
 
+    def verbose_flag
+      Rake.verbose ? ' -v' : ''
+    end
+
     def run_test
       puts ">>> Test #{name} <<<"
       mrbtest = exefile("#{build_dir}/bin/mrbtest")
-      sh "#{filename mrbtest.relative_path}#{$verbose ? ' -v' : ''}"
+      sh "#{filename mrbtest.relative_path}#{verbose_flag}"
       puts
-      run_bintest if bintest_enabled?
     end
 
     def run_bintest
+      puts ">>> Bintest #{name} <<<"
       targets = @gems.select { |v| File.directory? "#{v.dir}/bintest" }.map { |v| filename v.dir }
       targets << filename(".") if File.directory? "./bintest"
-      sh "ruby test/bintest.rb #{targets.join ' '}"
+      sh "ruby test/bintest.rb#{verbose_flag} #{targets.join ' '}"
     end
 
     def print_build_summary
@@ -314,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}"
@@ -324,6 +350,18 @@ EOS
       puts "================================================"
       puts
     end
+
+    def libmruby_static
+      libfile("#{build_dir}/lib/libmruby")
+    end
+
+    def libmruby_core_static
+      libfile("#{build_dir}/lib/libmruby_core")
+    end
+
+    def libraries
+      [libmruby_static]
+    end
   end # Build
 
   class CrossBuild < Build
@@ -334,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."
@@ -353,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
@@ -41,7 +49,7 @@ module MRuby
   class Command::Compiler < Command
     attr_accessor :flags, :include_paths, :defines, :source_exts
     attr_accessor :compile_options, :option_define, :option_include_path, :out_ext
-    attr_accessor :cxx_compile_flag, :cxx_exception_flag
+    attr_accessor :cxx_compile_flag, :cxx_exception_flag, :cxx_invalid_flags
 
     def initialize(build, source_exts=[])
       super(build)
@@ -50,9 +58,10 @@ 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
 
     alias header_search_paths include_paths
@@ -67,28 +76,19 @@ module MRuby
       path && build.filename("#{path}/#{name}").sub(/^"(.*)"$/, '\1')
     end
 
-    def all_flags(_defineds=[], _include_paths=[], _flags=[])
-      define_flags = [defines, _defineds].flatten.map{ |d| option_define % d }
+    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, _defineds=[], _include_paths=[], _flags=[])
-      FileUtils.mkdir_p File.dirname(outfile)
+    def run(outfile, infile, _defines=[], _include_paths=[], _flags=[])
+      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(_defineds, _include_paths, _flags),
-                                :infile => cygwin_filename(infile), :outfile => cygwin_filename(outfile) }
-      else
-        _run compile_options, { :flags => all_flags(_defineds, _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='')
@@ -127,13 +127,43 @@ module MRuby
     end
 
     private
+
+    #
+    # === Example of +.d+ file
+    #
+    # ==== Without <tt>-MP</tt> compiler flag
+    #
+    #   /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 \
+    #     /src/value_array.h
+    #
+    #   /include/mruby/common.h:
+    #
+    #   /include/mruby/value.h:
+    #
+    #   /src/value_array.h:
+    #
     def get_dependencies(file)
       file = file.ext('d') unless File.extname(file) == '.d'
-      if File.exist?(file)
-        File.read(file).gsub("\\\n ", "").scan(/^\S+:\s+(.+)$/).flatten.map {|s| s.split(' ') }.flatten
-      else
-        []
-      end + [ MRUBY_CONFIG ]
+      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
 
@@ -148,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
@@ -169,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
 
@@ -195,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
 
@@ -215,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
@@ -231,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
@@ -243,36 +257,50 @@ module MRuby
 
   class Command::Git < Command
     attr_accessor :flags
-    attr_accessor :clone_options, :pull_options, :checkout_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 = "pull"
-      @checkout_options = "checkout %{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)
-      root = Dir.pwd
-      Dir.chdir dir
       _pp "GIT PULL", url, dir.relative_path
-      _run pull_options
-      Dir.chdir root
+      _run pull_options, { :repo_dir => shellquote(dir) }
     end
 
     def run_checkout(dir, checksum_hash)
-      root = Dir.pwd
-      Dir.chdir dir
-      _pp "GIT CHECKOUT", checksum_hash
-      _run checkout_options, { :checksum_hash => checksum_hash }
-      Dir.chdir root
+      _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", dir, checksum_hash
+      _run reset_options, { :checksum_hash => checksum_hash, :repo_dir => shellquote(dir) }
+    end
+
+    def commit_hash(dir)
+      `#{@command} --git-dir #{shellquote(dir +'/.git')} --work-tree #{shellquote(dir)} rev-parse --verify HEAD`.strip
+    end
+
+    def current_branch(dir)
+      `#{@command} --git-dir #{shellquote(dir + '/.git')} --work-tree #{shellquote(dir)} rev-parse --abbrev-ref HEAD`.strip
     end
   end
 
@@ -285,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
 
@@ -83,27 +83,41 @@ module MRuby
         # by default the 'master' branch is used
         branch = params[:branch] ? params[:branch] : 'master'
 
+        lock = locks[url] if lock_enabled?
+
         if File.exist?(gemdir)
           if $pull_gems
+            # Jump to the top of the branch
+            git.run_checkout gemdir, branch
             git.run_pull gemdir, url
-          else
-            gemdir
+          elsif params[:checksum_hash]
+            git.run_checkout_detach gemdir, params[:checksum_hash]
+          elsif lock
+            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_checkout_detach gemdir, params[:checksum_hash]
+          elsif lock
+            git.run_checkout_detach gemdir, lock['commit']
+          end
         end
 
-        if params[:checksum_hash]
-          # Jump to the specified commit
-          git.run_checkout gemdir, params[:checksum_hash]
-        else
-          # Jump to the top of the branch
-          git.run_checkout gemdir, branch if $pull_gems
+        if lock_enabled?
+          @gem_dir_to_repo_url[gemdir] = url unless params[:path]
+          locks[url] = {
+            'url' => url,
+            'branch' => git.current_branch(gemdir),
+            'commit' => git.commit_hash(gemdir),
+          }
         end
 
         gemdir << "/#{params[:path]}" if params[:path]

lib/mruby/gem.rb

@@ -1,7 +1,6 @@
-require 'pathname'
 require 'forwardable'
-require 'tsort'
-require 'shellwords'
+autoload :TSort, 'tsort'
+autoload :Shellwords, 'shellwords'
 
 module MRuby
   module Gem
@@ -48,10 +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)
@@ -63,7 +66,7 @@ module MRuby
           objfile(f.relative_path_from(@dir).to_s.pathmap("#{build_dir}/%X"))
         end
 
-        @test_rbfiles = Dir.glob("#{dir}/test/**/*.rb")
+        @test_rbfiles = Dir.glob("#{dir}/test/**/*.rb").sort
         @test_objs = Dir.glob("#{dir}/test/*.{c,cpp,cxx,cc,m,asm,s,S}").map do |f|
           objfile(f.relative_path_from(dir).to_s.pathmap("#{build_dir}/%X"))
         end
@@ -74,7 +77,6 @@ module MRuby
         @bins = []
 
         @requirements = []
-        @dependencies, @conflicts = [], []
         @export_include_paths = []
         @export_include_paths << "#{dir}/include" if File.directory? "#{dir}/include"
 
@@ -87,9 +89,12 @@ module MRuby
           fail "#{name || dir} required to set name, license(s) and author(s)"
         end
 
-        build.libmruby << @objs
+        build.libmruby_objs << @objs
 
         instance_eval(&@build_config_initializer) if @build_config_initializer
+
+        repo_url = build.gem_dir_to_repo_url[dir]
+        build.locks[repo_url]['version'] = version if repo_url
       end
 
       def setup_compilers
@@ -102,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?
@@ -110,17 +124,13 @@ module MRuby
       end
 
       def add_test_dependency(*args)
-        add_dependency(*args) if build.test_enabled?
+        add_dependency(*args) if build.test_enabled? || build.bintest_enabled?
       end
 
       def add_conflict(name, *req)
         @conflicts << {:gem => name, :requirements => req.empty? ? nil : req}
       end
 
-      def self.bin=(bin)
-        @bins = [bin].flatten
-      end
-
       def build_dir
         "#{build.build_dir}/mrbgems/#{name}"
       end
@@ -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
@@ -269,16 +287,18 @@ module MRuby
       # ~> compare algorithm
       #
       # Example:
+      #    ~> 2     means >= 2.0.0 and < 3.0.0
       #    ~> 2.2   means >= 2.2.0 and < 3.0.0
-      #    ~> 2.2.0 means >= 2.2.0 and < 2.3.0
+      #    ~> 2.2.2 means >= 2.2.2 and < 2.3.0
       def twiddle_wakka_ok?(other)
         gr_or_eql = (self <=> other) >= 0
-        still_minor = (self <=> other.skip_minor) < 0
-        gr_or_eql and still_minor
+        still_major_or_minor = (self <=> other.skip_major_or_minor) < 0
+        gr_or_eql and still_major_or_minor
       end
 
-      def skip_minor
+      def skip_major_or_minor
         a = @ary.dup
+        a << 0 if a.size == 1 # ~> 2 can also be represented as ~> 2.0
         a.slice!(-1)
         a[-1] = a[-1].succ
         a
@@ -334,26 +354,26 @@ module MRuby
       end
 
       def generate_gem_table build
-        gem_table = @ary.reduce({}) { |res,v| res[v.name] = v; res }
+        gem_table = each_with_object({}) { |spec, h| h[spec.name] = spec }
 
-        default_gems = []
+        default_gems = {}
         each do |g|
           g.dependencies.each do |dep|
-            default_gems << default_gem_params(dep) unless gem_table.key? dep[:gem]
+            default_gems[dep[:gem]] ||= default_gem_params(dep)
           end
         end
 
         until default_gems.empty?
-          def_gem = default_gems.pop
+          def_name, def_gem = default_gems.shift
+          next if gem_table[def_name]
 
-          spec = build.gem def_gem[:default]
-          fail "Invalid gem name: #{spec.name} (Expected: #{def_gem[:gem]})" if spec.name != def_gem[:gem]
+          spec = gem_table[def_name] = build.gem(def_gem[:default])
+          fail "Invalid gem name: #{spec.name} (Expected: #{def_name})" if spec.name != def_name
           spec.setup
 
           spec.dependencies.each do |dep|
-            default_gems << default_gem_params(dep) unless gem_table.key? dep[:gem]
+            default_gems[dep[:gem]] ||= default_gem_params(dep)
           end
-          gem_table[spec.name] = spec
         end
 
         each do |g|
@@ -428,7 +448,8 @@ module MRuby
       end
 
       def import_include_paths(g)
-        gem_table = @ary.reduce({}) { |res,v| res[v.name] = v; res }
+        gem_table = each_with_object({}) { |spec, h| h[spec.name] = spec }
+
         g.dependencies.each do |dep|
           dep_g = gem_table[dep[:gem]]
           # We can do recursive call safely
@@ -454,5 +475,6 @@ module MRuby
     def new(&block); block.call(self); end
     def config=(obj); @config = obj; end
     def gem(gemdir, &block); @config.gem(gemdir, &block); end
+    def gembox(gemfile); @config.gembox(gemfile); end
   end # GemBox
 end # MRuby

lib/mruby/lockfile.rb

@@ -0,0 +1,81 @@
+autoload :YAML, 'yaml'
+
+module MRuby
+  autoload :Source, 'mruby/source'
+
+  class Lockfile
+    class << self
+      def enable
+        @enabled = true
+      end
+
+      def disable
+        @enabled = false
+      end
+
+      def enabled?
+        @enabled
+      end
+
+      def build(target_name)
+        instance.build(target_name)
+      end
+
+      def write
+        instance.write if enabled?
+      end
+
+      def instance
+        @instance ||= new("#{MRUBY_ROOT}/build/#{MRUBY_TARGET}.lock")
+      end
+    end
+
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def build(target_name)
+      read[target_name] ||= {}
+    end
+
+    def write
+      locks = {"mruby" => mruby}
+      locks["builds"] = @builds if @builds
+      File.write(@filename, YAML.dump(locks))
+    end
+
+    private
+
+    def read
+      @builds ||= if File.exist?(@filename)
+                    YAML.load_file(@filename)["builds"] || {}
+                  else
+                    {}
+                  end
+    end
+
+    def shellquote(s)
+      if ENV['OS'] == 'Windows_NT'
+        "\"#{s}\""
+      else
+        "'#{s}'"
+      end
+    end
+
+    def mruby
+      mruby = {
+        'version' => MRuby::Source::MRUBY_VERSION,
+        'release_no' => MRuby::Source::MRUBY_RELEASE_NO,
+      }
+
+      git_dir = "#{MRUBY_ROOT}/.git"
+      if File.directory?(git_dir)
+        mruby['git_commit'] = `git --git-dir #{shellquote(git_dir)} --work-tree #{shellquote(MRUBY_ROOT)} rev-parse --verify HEAD`.strip
+      end
+
+      mruby
+    end
+
+    enable
+  end
+end

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,484 +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'
-
-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
-
-    # Invoke the task if it is needed.  Prerequites are invoked first.
-    def invoke
-      puts "Invoke #{name} (already=[#{@already_invoked}], needed=[#{needed?}])" if $trace
-      return if @already_invoked
-      @already_invoked = true
-      prerequisites = @prerequisites.collect{ |n| n.is_a?(Proc) ? n.call(name) : n }.flatten
-      prerequisites.each { |n| Task[n].invoke }
-      execute if needed?
-    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
-    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)
-        RULES.each do |pattern, extensions, block|
-          if pattern.match(task_name)
-            ext = extensions.first
-            deps = extensions[1..-1]
-            case ext
-            when String
-              source = task_name.sub(/\.[^.]*$/, ext)
-            when Proc
-              source = ext.call(task_name)
-            else
-              fail "Don't know how to handle rule dependent: #{ext.inspect}"
-            end
-            if File.exist?(source)
-              task = FileTask.define_task({task_name => [source]+deps}, &block)
-              task.source = source
-              return task
-            end
-          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
-      system(cmd) or fail "Command Failed: [#{cmd}]"
-    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."]
-  ]
-
-  # 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
-    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
-    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
-      tasks = []
-      ARGV.each do |task_name|
-        if /^(\w+)=(.*)/.match(task_name)
-          ENV[$1] = $2
-        else
-          tasks << task_name
-        end
-      end
-      puts "(in #{Dir.pwd})"
-      $rakefile = @rakefile
-      load @rakefile
-      if $show_tasks
-        display_tasks
-      else
-        tasks.push("default") if tasks.size == 0
-        tasks.each do |task_name|
-          MiniRake::Task[task_name].invoke
-        end
-      end
-    rescue Exception => ex
-      puts "rake aborted!"
-      puts ex.message
-      if $trace
-        puts ex.backtrace.join("\n")
-      else
-        puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
-      end
-      exit 1
-    end
-  end
-end
-
-if __FILE__ == $0 then
-  RakeApp.new.run
-end
+#! /usr/bin/env ruby
+exec "rake", *ARGV

mrbgems/default.gembox

@@ -1,7 +1,13 @@
 MRuby::GemBox.new do |conf|
+  # Meta-programming features
+  conf.gem :core => "mruby-metaprog"
+
   # 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"
 
@@ -68,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"
 
@@ -77,12 +87,21 @@ 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"
 
   # Use class/module extension
   conf.gem :core => "mruby-class-ext"
 
+  # 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/mrbgem.rake

@@ -2,5 +2,4 @@ MRuby::Gem::Specification.new('mruby-array-ext') do |spec|
   spec.license = 'MIT'
   spec.author  = 'mruby developers'
   spec.summary = 'Array class extension'
-  spec.add_test_dependency 'mruby-enumerator', core: 'mruby-enumerator'
 end

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

@@ -1,29 +1,4 @@
 class Array
-  ##
-  # call-seq:
-  #    Array.try_convert(obj) -> array or nil
-  #
-  # Tries to convert +obj+ into an array, using +to_ary+ method.
-  # converted array or +nil+ if +obj+ cannot be converted for any reason.
-  # This method can be used to check if an argument is an array.
-  #
-  #    Array.try_convert([1])   #=> [1]
-  #    Array.try_convert("1")   #=> nil
-  #
-  #    if tmp = Array.try_convert(arg)
-  #      # the argument is an array
-  #    elsif tmp = String.try_convert(arg)
-  #      # the argument is a string
-  #    end
-  #
-  def self.try_convert(obj)
-    if obj.respond_to?(:to_ary)
-      obj.to_ary
-    else
-      nil
-    end
-  end
-
   ##
   # call-seq:
   #    ary.uniq!                -> ary or nil
@@ -41,23 +16,19 @@ class Array
   #    c.uniq! { |s| s.first } # => [["student", "sam"], ["teacher", "matz"]]
   #
   def uniq!(&block)
-    ary = self.dup
-    result = []
+    hash = {}
     if block
-      hash = {}
-      while ary.size > 0
-        val = ary.shift
+      self.each do |val|
         key = block.call(val)
-        hash[key] = val unless hash.has_key?(key)
-      end
-      hash.each_value do |value|
-        result << value
+        hash[key] = val unless hash.key?(key)
       end
+      result = hash.values
     else
-      while ary.size > 0
-        result << ary.shift
-        ary.delete(result.last)
+      hash = {}
+      self.each do |val|
+        hash[val] = val
       end
+      result = hash.keys
     end
     if result.size == self.size
       nil
@@ -117,6 +88,22 @@ class Array
     array
   end
 
+  ##
+  # call-seq:
+  #    ary.difference(other_ary1, other_ary2, ...)   -> new_ary
+  #
+  # Returns a new array that is a copy of the original array, removing all
+  # occurrences of any item that also appear in +other_ary+. The order is
+  # preserved from the original array.
+  #
+  def difference(*args)
+    ary = self
+    args.each do |x|
+      ary = ary - x
+    end
+    ary
+  end
+
   ##
   # call-seq:
   #    ary | other_ary     -> new_ary
@@ -134,6 +121,25 @@ class Array
     ary.uniq! or ary
   end
 
+  ##
+  # call-seq:
+  #    ary.union(other_ary,...)  -> new_ary
+  #
+  # Set Union---Returns a new array by joining this array with
+  # <i>other_ary</i>, removing duplicates.
+  #
+  #    ["a", "b", "c"].union(["c", "d", "a"], ["a", "c", "e"])
+  #           #=> ["a", "b", "c", "d", "e"]
+  #
+  def union(*args)
+    ary = self.dup
+    args.each do |x|
+      ary.concat(x)
+      ary.uniq!
+    end
+    ary
+  end
+
   ##
   # call-seq:
   #    ary & other_ary      -> new_ary
@@ -167,6 +173,24 @@ class Array
     array
   end
 
+  ##
+  # call-seq:
+  #    ary.intersection(other_ary,...)  -> new_ary
+  #
+  # Set Intersection---Returns a new array containing elements common to
+  # this array and <i>other_ary</i>s, removing duplicates. The order is
+  # preserved from the original array.
+  #
+  #    [1, 2, 3].intersection([3, 4, 1], [1, 3, 5])  #=> [1, 3]
+  #
+  def intersection(*args)
+    ary = self
+    args.each do |x|
+      ary = ary & x
+    end
+    ary
+  end
+
   ##
   # call-seq:
   #    ary.flatten -> new_ary
@@ -276,7 +300,6 @@ class Array
     self
   end
 
-  NONE=Object.new
   ##
   #  call-seq:
   #     ary.fetch(index)                    -> obj
@@ -301,7 +324,7 @@ class Array
   #                              #=> "100 is out of bounds"
   #
 
-  def fetch(n=nil, ifnone=NONE, &block)
+  def fetch(n, ifnone=NONE, &block)
     warn "block supersedes default value argument" if !n.nil? && ifnone != NONE && block
 
     idx = n
@@ -663,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
@@ -782,16 +774,6 @@ class Array
     nil
   end
 
-  ##
-  #  call-seq:
-  #     ary.to_ary -> ary
-  #
-  #  Returns +self+.
-  #
-  def to_ary
-    self
-  end
-
   ##
   # call-seq:
   #   ary.dig(idx, ...)                 -> object
@@ -836,12 +818,11 @@ class Array
   #  a.permutation(0).to_a #=> [[]] # one permutation of length 0
   #  a.permutation(4).to_a #=> []   # no permutations of length 4
   def permutation(n=self.size, &block)
-    size = self.size
     return to_enum(:permutation, n) unless block
-    return if n > size
+    size = self.size
     if n == 0
-       yield []
-    else
+      yield []
+    elsif 0 < n && n <= size
       i = 0
       while i<size
         result = [self[i]]
@@ -856,6 +837,7 @@ class Array
         i += 1
       end
     end
+    self
   end
 
   ##
@@ -882,9 +864,8 @@ class Array
   #    a.combination(5).to_a  #=> []   # no combinations of length 5
 
   def combination(n, &block)
-    size = self.size
     return to_enum(:combination, n) unless block
-    return if n > size
+    size = self.size
     if n == 0
        yield []
     elsif n == 1
@@ -893,7 +874,7 @@ class Array
         yield [self[i]]
         i += 1
       end
-    else
+    elsif n <= size
       i = 0
       while i<size
         result = [self[i]]
@@ -903,6 +884,7 @@ class Array
         i += 1
       end
     end
+    self
   end
 
   ##
@@ -911,7 +893,7 @@ class Array
   #
   # Assumes that self is an array of arrays and transposes the rows and columns.
   #
-  # If the length of the subarrays don’t match, an IndexError is raised.
+  # If the length of the subarrays don't match, an IndexError is raised.
   #
   # Examples:
   #
@@ -924,12 +906,41 @@ class Array
     column_count = nil
     self.each do |row|
       raise TypeError unless row.is_a?(Array)
-      column_count ||= row.count
-      raise IndexError, 'element size differs' unless column_count == row.count
+      column_count ||= row.size
+      raise IndexError, 'element size differs' unless column_count == row.size
     end
 
     Array.new(column_count) do |column_index|
       self.map { |row| row[column_index] }
     end
   end
+
+  ##
+  #  call-seq:
+  #    ary.to_h                ->   Hash
+  #    ary.to_h{|item| ... }   ->   Hash
+  #
+  # Returns the result of interpreting <i>aray</i> as an array of
+  # <tt>[key, value]</tt> pairs. If a block is given, it should
+  # return <tt>[key, value]</tt> pairs to construct a hash.
+  #
+  #     [[:foo, :bar], [1, 2]].to_h
+  #       # => {:foo => :bar, 1 => 2}
+  #     [1, 2].to_h{|x| [x, x*2]}
+  #       # => {1 => 2, 2 => 4}
+  #
+  def to_h(&blk)
+    h = {}
+    self.each do |v|
+      v = blk.call(v) if blk
+      raise TypeError, "wrong element type #{v.class}" unless Array === v
+      raise ArgumentError, "wrong array length (expected 2, was #{v.length})" unless v.length == 2
+      h[v[0]] = v[1]
+    end
+    h
+  end
+
+  alias append push
+  alias prepend unshift
+  alias filter! select!
 end

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,13 +58,12 @@ 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];
-    if (mrb_type(v) == MRB_TT_ARRAY &&
+    if (mrb_array_p(v) &&
         RARRAY_LEN(v) > 1 &&
         mrb_equal(mrb, RARRAY_PTR(v)[1], value))
       return v;
@@ -106,49 +104,6 @@ mrb_ary_values_at(mrb_state *mrb, mrb_value self)
   return mrb_get_values_at(mrb, self, RARRAY_LEN(self), argc, argv, mrb_ary_ref);
 }
 
-/*
- *  call-seq:
- *     ary.to_h   ->   Hash
- *
- *  Returns the result of interpreting <i>aray</i> as an array of
- *  <tt>[key, value]</tt> paris.
- *
- *      [[:foo, :bar], [1, 2]].to_h
- *        # => {:foo => :bar, 1 => 2}
- *
- */
-
-static mrb_value
-mrb_ary_to_h(mrb_state *mrb, mrb_value ary)
-{
-  mrb_int i;
-  mrb_value v, hash;
-
-  hash = mrb_hash_new_capa(mrb, 0);
-
-  for (i = 0; i < RARRAY_LEN(ary); ++i) {
-    mrb_value elt = RARRAY_PTR(ary)[i];
-    v = mrb_check_array_type(mrb, elt);
-
-    if (mrb_nil_p(v)) {
-      mrb_raisef(mrb, E_TYPE_ERROR, "wrong element type %S at %S (expected array)",
-                 mrb_str_new_cstr(mrb,  mrb_obj_classname(mrb, elt)),
-                 mrb_fixnum_value(i)
-      );
-    }
-
-    if (RARRAY_LEN(v) != 2) {
-      mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong array length at %S (expected 2, was %S)",
-                 mrb_fixnum_value(i),
-                 mrb_fixnum_value(RARRAY_LEN(v))
-      );
-    }
-
-    mrb_hash_set(mrb, hash, RARRAY_PTR(v)[0], RARRAY_PTR(v)[1]);
-  }
-
-  return hash;
-}
 
 /*
  *  call-seq:
@@ -175,7 +130,7 @@ static mrb_value
 mrb_ary_slice_bang(mrb_state *mrb, mrb_value self)
 {
   struct RArray *a = mrb_ary_ptr(self);
-  mrb_int i, j, k, len, alen = ARY_LEN(a);
+  mrb_int i, j, k, len, alen;
   mrb_value val;
   mrb_value *ptr;
   mrb_value ary;
@@ -183,28 +138,28 @@ 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, alen, TRUE) == 1) {
+      if (mrb_range_beg_len(mrb, index, &i, &len, ARY_LEN(a), TRUE) == MRB_RANGE_OK) {
         goto delete_pos_len;
       }
       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;
     }
   }
 
   mrb_get_args(mrb, "ii", &i, &len);
  delete_pos_len:
+  alen = ARY_LEN(a);
   if (i < 0) i += alen;
   if (i < 0 || alen < i) return mrb_nil_value();
   if (len < 0) return mrb_nil_value();
@@ -236,8 +191,7 @@ mrb_mruby_array_ext_gem_init(mrb_state* mrb)
   mrb_define_method(mrb, a, "at",     mrb_ary_at,     MRB_ARGS_REQ(1));
   mrb_define_method(mrb, a, "rassoc", mrb_ary_rassoc, MRB_ARGS_REQ(1));
   mrb_define_method(mrb, a, "values_at", mrb_ary_values_at, MRB_ARGS_ANY());
-  mrb_define_method(mrb, a, "to_h",   mrb_ary_to_h, MRB_ARGS_REQ(0));
-  mrb_define_method(mrb, a, "slice!", mrb_ary_slice_bang,   MRB_ARGS_ANY());
+  mrb_define_method(mrb, a, "slice!", mrb_ary_slice_bang,   MRB_ARGS_ARG(1,1));
 }
 
 void

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

@@ -1,11 +1,21 @@
 ##
 # Array(Ext) Test
 
-assert("Array.try_convert") do
-  assert_nil Array.try_convert(0)
-  assert_nil Array.try_convert(nil)
-  assert_equal [], Array.try_convert([])
-  assert_equal [1,2,3], Array.try_convert([1,2,3])
+def assert_permutation_combination(exp, receiver, meth, *args)
+  act = []
+  ret = receiver.__send__(meth, *args) { |v| act << v }
+  assert "assert_#{meth}" do
+    assert_equal(exp, act.sort)
+    assert_same(receiver, ret)
+  end
+end
+
+def assert_permutation(exp, receiver, *args)
+  assert_permutation_combination(exp, receiver, :permutation, *args)
+end
+
+def assert_combination(exp, receiver, *args)
+  assert_permutation_combination(exp, receiver, :combination, *args)
 end
 
 assert("Array#assoc") do
@@ -75,6 +85,22 @@ assert("Array#|") do
   assert_equal [1, 2, 3, 1], a
 end
 
+assert("Array#union") do
+  a = [1, 2, 3, 1]
+  b = [1, 4]
+  c = [1, 5]
+
+  assert_equal [1, 2, 3, 4, 5], a.union(b,c)
+end
+
+assert("Array#difference") do
+  a = [1, 2, 3, 1, 6, 7]
+  b = [1, 4, 6]
+  c = [1, 5, 7]
+
+  assert_equal [2, 3], a.difference(b,c)
+end
+
 assert("Array#&") do
   a = [1, 2, 3, 1]
   b = [1, 4]
@@ -85,6 +111,14 @@ assert("Array#&") do
   assert_equal [1, 2, 3, 1], a
 end
 
+assert("Array#intersection") do
+  a = [1, 2, 3, 1, 8, 6, 7, 8]
+  b = [1, 4, 6, 8]
+  c = [1, 5, 7, 8]
+
+  assert_equal [1, 8], a.intersection(b,c)
+end
+
 assert("Array#flatten") do
   assert_equal [1, 2, "3", {4=>5}, :'6'],    [1, 2, "3", {4=>5}, :'6'].flatten
   assert_equal [1, 2, 3, 4, 5, 6], [1, 2,    [3, 4, 5], 6].flatten
@@ -161,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
@@ -267,22 +295,9 @@ assert("Array#bsearch") do
   end
 end
 
-assert("Array#bsearch_index") do
-  # tested through Array#bsearch
-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
+# tested through Array#bsearch
+#assert("Array#bsearch_index") do
+#end
 
 assert("Array#keep_if") do
   a = [1, 2, 3, 4, 5]
@@ -330,27 +345,11 @@ assert('Array#to_h') do
   assert_raise(ArgumentError) { [[1]].to_h }
 end
 
-assert('Array#to_h (Modified)') do
-  class A
-    def to_ary
-      $a.clear
-      nil
-    end
-  end
-  $a = [A.new]
-  assert_raise(TypeError) { $a.to_h }
-end
-
 assert("Array#index (block)") do
   assert_nil (1..10).to_a.index { |i| i % 5 == 0 and i % 7 == 0 }
   assert_equal 34, (1..100).to_a.index { |i| i % 5 == 0 and i % 7 == 0 }
 end
 
-assert("Array#to_ary") do
-  assert_equal [], [].to_ary
-  assert_equal [1,2,3], [1,2,3].to_ary
-end
-
 assert("Array#dig") do
   h = [[[1]], 0]
   assert_equal(1, h.dig(0, 0, 0))
@@ -384,30 +383,24 @@ end
 
 assert("Array#permutation") do
   a = [1, 2, 3]
-  assert_equal([[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]],
-               a.permutation.to_a)
-  assert_equal([[1],[2],[3]],
-               a.permutation(1).to_a)
-  assert_equal([[1,2],[1,3],[2,1],[2,3],[3,1],[3,2]],
-               a.permutation(2).to_a)
-  assert_equal([[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]],
-               a.permutation(3).to_a)
-  assert_equal([[]], a.permutation(0).to_a)
-  assert_equal([], a.permutation(4).to_a)
+  assert_permutation([[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]], a)
+  assert_permutation([[1],[2],[3]], a, 1)
+  assert_permutation([[1,2],[1,3],[2,1],[2,3],[3,1],[3,2]], a, 2)
+  assert_permutation([[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]], a, 3)
+  assert_permutation([[]], a, 0)
+  assert_permutation([], a, 4)
+  assert_permutation([], a, -1)
 end
 
 assert("Array#combination") do
   a = [1, 2, 3, 4]
-  assert_equal([[1],[2],[3],[4]],
-               a.combination(1).to_a)
-  assert_equal([[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]],
-               a.combination(2).to_a)
-  assert_equal([[1,2,3],[1,2,4],[1,3,4],[2,3,4]],
-               a.combination(3).to_a)
-  assert_equal([[1,2,3,4]],
-               a.combination(4).to_a)
-  assert_equal([[]], a.combination(0).to_a)
-  assert_equal([], a.combination(5).to_a)
+  assert_combination([[1],[2],[3],[4]], a, 1)
+  assert_combination([[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]], a, 2)
+  assert_combination([[1,2,3],[1,2,4],[1,3,4],[2,3,4]], a, 3)
+  assert_combination([[1,2,3,4]], a, 4)
+  assert_combination([[]], a, 0)
+  assert_combination([], a, 5)
+  assert_combination([], a, -1)
 end
 
 assert('Array#transpose') do
@@ -418,5 +411,5 @@ assert('Array#transpose') do
   assert_equal([[1], [2], [3]].transpose, [[1,2,3]])
   assert_equal([[1,2], [3,4], [5,6]].transpose, [[1,3,5], [2,4,6]])
   assert_raise(TypeError) { [1].transpose }
-  assert_raise(IndexError) { [[1], [2,3,4]].transpose } 
+  assert_raise(IndexError) { [[1], [2,3,4]].transpose }
 end

mrbgems/mruby-bin-config/mrbgem.rake

@@ -0,0 +1,26 @@
+unless MRuby::Build.current.kind_of?(MRuby::CrossBuild)
+  MRuby::Gem::Specification.new('mruby-bin-config') do |spec|
+    name = 'mruby-config'
+    spec.license = 'MIT'
+    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 = "#{mruby_config_dir}/#{mruby_config}"
+    make_cfg = "#{build.build_dir}/lib/libmruby.flags.mak"
+    tmplt_path = "#{__dir__}/#{mruby_config}"
+    build.bins << mruby_config
+
+    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))
+      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
@@ -317,7 +320,7 @@ TestConstNameSubClass.new.m()
 bp = nil
 SRC
 
-  # todo: wait for 'break' to be implimented
+  # todo: wait for 'break' to be implemented
   tc = []
   9.times { tc << {:cmd=>"s"} }
   tc << {:cmd=>"p CONST", :exp=>"super class"}
@@ -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(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;
@@ -93,8 +93,10 @@ check_file_lineno(struct mrb_irep *irep, const char *file, uint16_t lineno)
   uint16_t i;
 
   for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) {
+    const char *filename;
     info_file = irep->debug_info->files[f_idx];
-    if (!strcmp(info_file->filename, file)) {
+    filename = mrb_sym_name_len(mrb, info_file->filename_sym, NULL);
+    if (!strcmp(filename, file)) {
       result = MRB_DEBUG_BP_FILE_OK;
 
       fix_lineno = check_lineno(info_file, lineno);
@@ -103,7 +105,7 @@ check_file_lineno(struct mrb_irep *irep, const char *file, uint16_t lineno)
       }
     }
     for (i=0; i < irep->rlen; ++i) {
-      result  |= check_file_lineno(irep->reps[i], file, lineno);
+      result  |= check_file_lineno(mrb, irep->reps[i], file, lineno);
       if (result == (MRB_DEBUG_BP_FILE_OK | MRB_DEBUG_BP_LINENO_OK)) {
         return result;
       }
@@ -124,7 +126,7 @@ compare_break_method(mrb_state *mrb, mrb_debug_breakpoint *bp, struct RClass *cl
   mrb_debug_methodpoint *method_p;
   mrb_bool is_defined;
 
-  method_name = mrb_sym2name(mrb, method_sym);
+  method_name = mrb_sym_name(mrb, method_sym);
 
   method_p = &bp->point.methodpoint;
   if (strcmp(method_p->method_name, method_name) == 0) {
@@ -149,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;
@@ -185,7 +187,7 @@ mrb_debug_set_break_line(mrb_state *mrb, mrb_debug_context *dbg, const char *fil
   }
 
   /* file and lineno check (line type mrb_debug_line_ary only.) */
-  result = check_file_lineno(dbg->root_irep, file, lineno);
+  result = check_file_lineno(mrb, dbg->root_irep, file, lineno);
   if (result == 0) {
     return MRB_DEBUG_BREAK_INVALID_FILE;
   }
@@ -426,10 +428,10 @@ mrb_debug_disable_break_all(mrb_state *mrb, mrb_debug_context *dbg)
 }
 
 static mrb_bool
-check_start_pc_for_line(mrb_irep *irep, 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(irep, pc - irep->iseq - 1)) {
+    if (line == mrb_debug_get_line(mrb, irep, pc - irep->iseq - 1)) {
       return FALSE;
     }
   }
@@ -447,7 +449,7 @@ mrb_debug_check_breakpoint_line(mrb_state *mrb, mrb_debug_context *dbg, const ch
     return MRB_DEBUG_INVALID_ARGUMENT;
   }
 
-  if (!check_start_pc_for_line(dbg->irep, dbg->pc, line)) {
+  if (!check_start_pc_for_line(mrb, dbg->irep, dbg->pc, line)) {
     return MRB_DEBUG_OK;
   }
 

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

@@ -181,7 +181,7 @@ mrb_debug_get_source(mrb_state *mrb, mrdb_state *mrdb, const char *srcpath, cons
   else srcname = filename;
 
   search_path[0] = srcpath;
-  search_path[1] = dirname(mrb, mrb_debug_get_filename(mrdb->dbg->irep, 0));
+  search_path[1] = dirname(mrb, mrb_debug_get_filename(mrb, mrdb->dbg->irep, 0));
   search_path[2] = ".";
 
   for (i = 0; i < 3; i++) {

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

@@ -31,9 +31,9 @@ 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)
+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 *, 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;
@@ -48,6 +48,11 @@ mrb_debug_eval(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size_t
     v = mrb_obj_value(mrb->exc);
     mrb->exc = 0;
   }
+  else if (direct_eval) {
+    recv = dbg->regs[0];
+
+    v = mrb_funcall(mrb, recv, expr, 0);
+  }
   else {
     /*
      * begin
@@ -62,14 +67,14 @@ 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) {
     *exc = mrb_obj_is_kind_of(mrb, v, mrb->eException_class);
   }
 
-  s = mrb_funcall(mrb, v, "inspect", 0);
+  s = mrb_inspect(mrb, v);
 
   /* enable code_fetch_hook */
   mrb->code_fetch_hook = tmp;

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

@@ -8,6 +8,6 @@
 #include <mruby.h>
 #include "mrdb.h"
 
-mrb_value mrb_debug_eval(mrb_state*, mrb_debug_context*, const char*, size_t, mrb_bool*);
+mrb_value mrb_debug_eval(mrb_state*, mrb_debug_context*, const char*, size_t, mrb_bool*, int);
 
 #endif /* APIPRINT_H_ */

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

@@ -242,7 +242,7 @@ info_break_select(mrb_state *mrb, mrdb_state *mrdb)
 }
 
 mrb_debug_bptype
-parse_breakcommand(mrdb_state *mrdb, const char **file, uint32_t *line, char **cname, char **method)
+parse_breakcommand(mrb_state *mrb, mrdb_state *mrdb, const char **file, uint32_t *line, char **cname, char **method)
 {
   mrb_debug_context *dbg = mrdb->dbg;
   char *args;
@@ -274,7 +274,7 @@ parse_breakcommand(mrdb_state *mrdb, const char **file, uint32_t *line, char **c
       STRTOUL(l, body);
       if (l <= 65535) {
         *line = l;
-        *file = (body == args)? mrb_debug_get_filename(dbg->irep, dbg->pc - dbg->irep->iseq): args;
+        *file = (body == args)? mrb_debug_get_filename(mrb, dbg->irep, dbg->pc - dbg->irep->iseq): args;
       }
       else {
         puts(BREAK_ERR_MSG_RANGEOVER);
@@ -332,7 +332,7 @@ dbgcmd_break(mrb_state *mrb, mrdb_state *mrdb)
   char *method = NULL;
   int32_t ret;
 
-  type = parse_breakcommand(mrdb, &file, &line, &cname, &method);
+  type = parse_breakcommand(mrb, mrdb, &file, &line, &cname, &method);
   switch (type) {
     case MRB_DEBUG_BPTYPE_LINE:
       ret = mrb_debug_set_break_line(mrb, dbg, file, line);

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

@@ -81,6 +81,12 @@ static help_msg help_msg_list[] = {
     "Status of specified breakpoints (all user-settable breakpoints if no argument).\n"
     "Arguments are breakpoint numbers with spaces in between.\n"
   },
+  {
+    "i[nfo]", "l[ocals]", "Print name of local variables",
+    "Usage: info locals\n"
+    "\n"
+    "Print name of local variables.\n"
+  },
   {
     "l[ist]", NULL, "List specified line",
     "Usage: list\n"
@@ -495,7 +501,7 @@ dbgcmd_quit(mrb_state *mrb, mrdb_state *mrdb)
 
   if (mrdb->dbg->xm == DBG_QUIT) {
     struct RClass *exc;
-    exc = mrb_define_class(mrb, "DebuggerExit", mrb_class_get(mrb, "Exception"));
+    exc = mrb_define_class(mrb, "DebuggerExit", mrb->eException_class);
     mrb_raise(mrb, exc, "Exit mrdb.");
   }
   return DBGST_PROMPT;

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

@@ -18,7 +18,6 @@ dbgcmd_print(mrb_state *mrb, mrdb_state *mrdb)
 {
   mrb_value expr;
   mrb_value result;
-  mrb_value s;
   uint8_t wcnt;
   int ai;
 
@@ -36,11 +35,12 @@ dbgcmd_print(mrb_state *mrb, mrdb_state *mrdb)
     expr = mrb_str_cat_cstr(mrb, expr, mrdb->words[wcnt]);
   }
 
-  result = mrb_debug_eval(mrb, mrdb->dbg, RSTRING_PTR(expr), RSTRING_LEN(expr), NULL);
+  result = mrb_debug_eval(mrb, mrdb->dbg, RSTRING_PTR(expr), RSTRING_LEN(expr), NULL, 0);
 
   /* $print_no = result */
-  s = mrb_str_cat_lit(mrb, result, "\0");
-  printf("$%lu = %s\n", (unsigned long)mrdb->print_no++, RSTRING_PTR(s));
+  printf("$%lu = ", (unsigned long)mrdb->print_no++);
+  fwrite(RSTRING_PTR(result), RSTRING_LEN(result), 1, stdout);
+  putc('\n', stdout);
 
   if (mrdb->print_no == 0) {
     mrdb->print_no = 1;
@@ -56,3 +56,26 @@ dbgcmd_eval(mrb_state *mrb, mrdb_state *mrdb)
 {
   return dbgcmd_print(mrb, mrdb);
 }
+
+dbgcmd_state
+dbgcmd_info_local(mrb_state *mrb, mrdb_state *mrdb)
+{
+  mrb_value result;
+  mrb_value s;
+  int ai;
+
+  ai = mrb_gc_arena_save(mrb);
+
+  result = mrb_debug_eval(mrb, mrdb->dbg, "local_variables", 0, NULL, 1);
+
+  s = mrb_str_cat_lit(mrb, result, "\0");
+  printf("$%lu = %s\n", (unsigned long)mrdb->print_no++, RSTRING_PTR(s));
+
+  if (mrdb->print_no == 0) {
+    mrdb->print_no = 1;
+  }
+
+  mrb_gc_arena_restore(mrb, ai);
+
+  return DBGST_PROMPT;
+}

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

@@ -19,7 +19,7 @@ dbgcmd_run(mrb_state *mrb, mrdb_state *mrdb)
     if (dbg->xphase == DBG_PHASE_RUNNING){
       struct RClass *exc;
       puts("Start it from the beginning.");
-      exc = mrb_define_class(mrb, "DebuggerRestart", mrb_class_get(mrb, "Exception"));
+      exc = mrb_define_class(mrb, "DebuggerRestart", mrb->eException_class);
       mrb_raise(mrb, exc, "Restart mrdb.");
     }
   }

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>
@@ -52,6 +51,7 @@ static const debug_command debug_command_list[] = {
   {"eval",      NULL,           2, 0, 0, DBGCMD_EVAL,           dbgcmd_eval},            /* ev[al] */
   {"help",      NULL,           1, 0, 1, DBGCMD_HELP,           dbgcmd_help},            /* h[elp] */
   {"info",      "breakpoints",  1, 1, 1, DBGCMD_INFO_BREAK,     dbgcmd_info_break},      /* i[nfo] b[reakpoints] */
+  {"info",      "locals",       1, 1, 0, DBGCMD_INFO_LOCAL,     dbgcmd_info_local},      /* i[nfo] l[ocals] */
   {"list",      NULL,           1, 0, 1, DBGCMD_LIST,           dbgcmd_list},            /* l[ist] */
   {"print",     NULL,           1, 0, 0, DBGCMD_PRINT,          dbgcmd_print},           /* p[rint] */
   {"quit",      NULL,           1, 0, 0, DBGCMD_QUIT,           dbgcmd_quit},            /* q[uit] */
@@ -504,12 +504,13 @@ get_and_parse_command(mrb_state *mrb, mrdb_state *mrdb)
 }
 
 static int32_t
-check_method_breakpoint(mrb_state *mrb, mrb_irep *irep, 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;
   int32_t bpno;
   mrb_bool isCfunc;
+  struct mrb_insn_data insn;
 
   mrb_debug_context *dbg = mrb_debug_context_get(mrb);
 
@@ -517,11 +518,12 @@ check_method_breakpoint(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, mrb_value
   bpno = dbg->method_bpno;
   dbg->method_bpno = 0;
 
-  switch(GET_OPCODE(*pc)) {
+  insn = mrb_decode_insn(pc);
+  switch(insn.insn) {
     case OP_SEND:
     case OP_SENDB:
-      c = mrb_class(mrb, regs[GETARG_A(*pc)]);
-      sym = irep->syms[GETARG_B(*pc)];
+      c = mrb_class(mrb, regs[insn.a]);
+      sym = irep->syms[insn.b];
       break;
     case OP_SUPER:
       c = mrb->c->ci->target_class->super;
@@ -543,7 +545,7 @@ check_method_breakpoint(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, mrb_value
 }
 
 static void
-mrb_code_fetch_hook(mrb_state *mrb, mrb_irep *irep, 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;
@@ -566,8 +568,8 @@ mrb_code_fetch_hook(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, mrb_value *reg
     dbg->xphase = DBG_PHASE_RUNNING;
   }
 
-  file = mrb_debug_get_filename(irep, pc - irep->iseq);
-  line = mrb_debug_get_line(irep, pc - irep->iseq);
+  file = mrb_debug_get_filename(mrb, irep, pc - irep->iseq);
+  line = mrb_debug_get_line(mrb, irep, pc - irep->iseq);
 
   switch (dbg->xm) {
   case DBG_STEP:

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

@@ -23,6 +23,7 @@ typedef enum debug_command_id {
   DBGCMD_STEP,
   DBGCMD_BREAK,
   DBGCMD_INFO_BREAK,
+  DBGCMD_INFO_LOCAL,
   DBGCMD_WATCH,
   DBGCMD_INFO_WATCH,
   DBGCMD_ENABLE,
@@ -102,9 +103,9 @@ typedef struct mrb_debug_breakpoint {
 } mrb_debug_breakpoint;
 
 typedef struct mrb_debug_context {
-  struct mrb_irep *root_irep;
-  struct mrb_irep *irep;
-  mrb_code *pc;
+  const struct mrb_irep *root_irep;
+  const struct mrb_irep *irep;
+  const mrb_code *pc;
   mrb_value *regs;
 
   const char *prvfile;
@@ -151,6 +152,7 @@ dbgcmd_state dbgcmd_next(mrb_state*, mrdb_state*);
 /* cmdbreak.c */
 dbgcmd_state dbgcmd_break(mrb_state*, mrdb_state*);
 dbgcmd_state dbgcmd_info_break(mrb_state*, mrdb_state*);
+dbgcmd_state dbgcmd_info_local(mrb_state*, mrdb_state*);
 dbgcmd_state dbgcmd_delete(mrb_state*, mrdb_state*);
 dbgcmd_state dbgcmd_enable(mrb_state*, mrdb_state*);
 dbgcmd_state dbgcmd_disable(mrb_state*, mrdb_state*);

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

@@ -6,6 +6,14 @@
 #ifndef MRDBCONF_H
 #define MRDBCONF_H
 
+#ifndef MRB_ENABLE_DEBUG_HOOK
+# 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: */
 /* maximum size for command buffer */
 #define MAX_COMMAND_LINE 1024

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

@@ -10,3 +10,42 @@ assert('regression for #1563') do
   o, s = Open3.capture2('bin/mirb', :stdin_data => "a=1;b=2;c=3\nb\nc")
   assert_true o.include?('=> 3')
 end
+
+assert('mirb -d option') do
+  o, _ = Open3.capture2('bin/mirb', :stdin_data => "$DEBUG\n")
+  assert_true o.include?('=> false')
+  o, _ = Open3.capture2('bin/mirb -d', :stdin_data => "$DEBUG\n")
+  assert_true o.include?('=> true')
+end
+
+assert('mirb -r option') do
+  lib = Tempfile.new('lib.rb')
+  lib.write <<EOS
+class Hoge
+  def hoge
+    :hoge
+  end
+end
+EOS
+  lib.flush
+
+  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

@@ -6,9 +6,22 @@
 ** immediately. It's a REPL...
 */
 
+#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>
+#include <mruby/dump.h>
+#include <mruby/string.h>
+#include <mruby/variable.h>
+#include <mruby/throw.h>
+
 #include <stdlib.h>
 #include <string.h>
-#include <stdio.h>
 #include <ctype.h>
 
 #include <signal.h>
@@ -49,12 +62,6 @@
 #define SIGJMP_BUF jmp_buf
 #endif
 
-#include <mruby.h>
-#include <mruby/array.h>
-#include <mruby/proc.h>
-#include <mruby/compile.h>
-#include <mruby/string.h>
-
 #ifdef ENABLE_READLINE
 
 static const char history_file_name[] = ".mirb_history";
@@ -97,19 +104,19 @@ 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)) {
     val = mrb_obj_as_string(mrb, obj);
   }
-  msg = mrb_locale_from_utf8(RSTRING_PTR(val), RSTRING_LEN(val));
+  msg = mrb_locale_from_utf8(RSTRING_PTR(val), (int)RSTRING_LEN(val));
   fwrite(msg, strlen(msg), 1, stdout);
   mrb_locale_free(msg);
   putc('\n', stdout);
@@ -124,10 +131,6 @@ is_code_block_open(struct mrb_parser_state *parser)
 
   /* check for heredoc */
   if (parser->parsing_heredoc != NULL) return TRUE;
-  if (parser->heredoc_end_now) {
-    parser->heredoc_end_now = FALSE;
-    return FALSE;
-  }
 
   /* check for unterminated string */
   if (parser->lex_strterm) return TRUE;
@@ -219,8 +222,11 @@ is_code_block_open(struct mrb_parser_state *parser)
 struct _args {
   FILE *rfp;
   mrb_bool verbose      : 1;
+  mrb_bool debug        : 1;
   int argc;
   char** argv;
+  int libc;
+  char **libv;
 };
 
 static void
@@ -228,6 +234,8 @@ usage(const char *name)
 {
   static const char *const usage_msg[] = {
   "switches:",
+  "-d           set $DEBUG to true (same as `mruby -d`)",
+  "-r library   same as `mruby -r`",
   "-v           print version number, then run in verbose mode",
   "--verbose    run in verbose mode",
   "--version    print the version",
@@ -236,14 +244,24 @@ usage(const char *name)
   };
   const char *const *p = usage_msg;
 
-  printf("Usage: %s [switches]\n", name);
+  printf("Usage: %s [switches] [programfile] [arguments]\n", name);
   while (*p)
     printf("  %s\n", *p++);
 }
 
+static char *
+dup_arg_item(mrb_state *mrb, const char *item)
+{
+  size_t buflen = strlen(item) + 1;
+  char *buf = (char*)mrb_malloc(mrb, buflen);
+  memcpy(buf, item, buflen);
+  return buf;
+}
+
 static int
 parse_args(mrb_state *mrb, int argc, char **argv, struct _args *args)
 {
+  char **origargv = argv;
   static const struct _args args_zero = { 0 };
 
   *args = args_zero;
@@ -254,6 +272,26 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct _args *args)
 
     item = argv[0] + 1;
     switch (*item++) {
+    case 'd':
+      args->debug = TRUE;
+      break;
+    case 'r':
+      if (!item[0]) {
+        if (argc <= 1) {
+          printf("%s: No library specified for -r\n", *origargv);
+          return EXIT_FAILURE;
+        }
+        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);
+      break;
     case 'v':
       if (!args->verbose) mrb_show_version(mrb);
       args->verbose = TRUE;
@@ -299,6 +337,12 @@ cleanup(mrb_state *mrb, struct _args *args)
   if (args->rfp)
     fclose(args->rfp);
   mrb_free(mrb, args->argv);
+  if (args->libc) {
+    while (args->libc--) {
+      mrb_free(mrb, args->libv[args->libc]);
+    }
+    mrb_free(mrb, args->libv);
+  }
   mrb_close(mrb);
 }
 
@@ -333,7 +377,7 @@ check_keyword(const char *buf, const char *word)
   size_t len = strlen(word);
 
   /* skip preceding spaces */
-  while (*p && isspace((unsigned char)*p)) {
+  while (*p && ISSPACE(*p)) {
     p++;
   }
   /* check keyword */
@@ -343,7 +387,7 @@ check_keyword(const char *buf, const char *word)
   p += len;
   /* skip trailing spaces */
   while (*p) {
-    if (!isspace((unsigned char)*p)) return 0;
+    if (!ISSPACE(*p)) return 0;
     p++;
   }
   return 1;
@@ -366,6 +410,26 @@ ctrl_c_handler(int signo)
 }
 #endif
 
+#ifndef DISABLE_MIRB_UNDERSCORE
+void decl_lv_underscore(mrb_state *mrb, mrbc_context *cxt)
+{
+  struct RProc *proc;
+  struct mrb_parser_state *parser;
+
+  parser = mrb_parse_string(mrb, "_=nil", cxt);
+  if (parser == NULL) {
+    fputs("create parser state error\n", stderr);
+    mrb_close(mrb);
+    exit(EXIT_FAILURE);
+  }
+
+  proc = mrb_generate_code(mrb, parser);
+  mrb_vm_run(mrb, proc, mrb_top_self(mrb), 0);
+
+  mrb_parser_free(parser);
+}
+#endif
+
 int
 main(int argc, char **argv)
 {
@@ -413,6 +477,7 @@ main(int argc, char **argv)
     }
   }
   mrb_define_global_const(mrb, "ARGV", ARGV);
+  mrb_gv_set(mrb, mrb_intern_lit(mrb, "$DEBUG"), mrb_bool_value(args.debug));
 
 #ifdef ENABLE_READLINE
   history_path = get_history_path(mrb);
@@ -429,6 +494,28 @@ main(int argc, char **argv)
   print_hint();
 
   cxt = mrbc_context_new(mrb);
+
+  /* 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]);
+      cleanup(mrb, &args);
+      return EXIT_FAILURE;
+    }
+    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)");
@@ -502,8 +589,7 @@ main(int argc, char **argv)
     MIRB_LINE_FREE(line);
 #endif
 
-done:
-
+  done:
     if (code_block_open) {
       if (strlen(ruby_code)+strlen(last_code_line) > sizeof(ruby_code)-1) {
         fputs("concatenated input string too long\n", stderr);
@@ -542,13 +628,13 @@ done:
         /* warning */
         char* msg = mrb_locale_from_utf8(parser->warn_buffer[0].message, -1);
         printf("line %d: %s\n", parser->warn_buffer[0].lineno, msg);
-        mrb_utf8_free(msg);
+        mrb_locale_free(msg);
       }
       if (0 < parser->nerr) {
         /* syntax error */
         char* msg = mrb_locale_from_utf8(parser->error_buffer[0].message, -1);
         printf("line %d: %s\n", parser->error_buffer[0].lineno, msg);
-        mrb_utf8_free(msg);
+        mrb_locale_free(msg);
       }
       else {
         /* generate bytecode */
@@ -565,8 +651,8 @@ done:
         /* 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 */
@@ -583,10 +669,13 @@ done:
         }
         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);
+#ifndef DISABLE_MIRB_UNDERSCORE
+          *(mrb->c->stack + 1) = result;
+#endif
         }
       }
       ruby_code[0] = '\0';
@@ -604,6 +693,12 @@ done:
 
   if (args.rfp) fclose(args.rfp);
   mrb_free(mrb, args.argv);
+  if (args.libv) {
+    for (i = 0; i < args.libc; ++i) {
+      mrb_free(mrb, args.libv[i]);
+    }
+    mrb_free(mrb, args.libv);
+  }
   mrbc_context_free(mrb, cxt);
   mrb_close(mrb);
 

mrbgems/mruby-bin-mrbc/mrbgem.rake

@@ -8,7 +8,7 @@ MRuby::Gem::Specification.new 'mruby-bin-mrbc' do |spec|
   exec = exefile("#{build.build_dir}/bin/mrbc")
   mrbc_objs = Dir.glob("#{spec.dir}/tools/mrbc/*.c").map { |f| objfile(f.pathmap("#{spec.build_dir}/tools/mrbc/%n")) }.flatten
 
-  file exec => mrbc_objs + [libfile("#{build.build_dir}/lib/libmruby_core")] do |t|
+  file exec => mrbc_objs + [build.libmruby_core_static] do |t|
     build.linker.run t.name, t.prerequisites
   end
 

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,8 +20,10 @@ 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;
   unsigned int flags    : 4;
 };
 
@@ -27,12 +33,12 @@ 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",
   "--copyright  print the copyright",
@@ -40,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++);
 }
@@ -48,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;
@@ -69,7 +82,6 @@ get_outfilename(mrb_state *mrb, char *infile, const char *ext)
 static int
 parse_args(mrb_state *mrb, int argc, char **argv, struct mrbc_args *args)
 {
-  char *outfile = NULL;
   static const struct mrbc_args args_zero = { 0 };
   int i;
 
@@ -84,7 +96,7 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct mrbc_args *args)
       case 'o':
         if (args->outfile) {
           fprintf(stderr, "%s: an output file is already specified. (%s)\n",
-                  args->prog, outfile);
+                  args->prog, args->outfile);
           return -1;
         }
         if (argv[i][2] == '\0' && argv[i+1]) {
@@ -95,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++;
@@ -119,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;
@@ -142,6 +155,10 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct mrbc_args *args)
           mrb_show_copyright(mrb);
           exit(EXIT_SUCCESS);
         }
+        else if (strcmp(argv[i] + 2, "remove-lv") == 0) {
+          args->remove_lv = TRUE;
+          break;
+        }
         return -1;
       default:
         return i;
@@ -151,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;
 }
 
@@ -178,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;
@@ -205,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();
     }
@@ -230,10 +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, (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-config/mrbgem.rake

@@ -1,30 +0,0 @@
-module MRuby
-  class Build
-    def exefile(name)
-      if name.is_a?(Array)
-        name.flatten.map { |n| exefile(n) }
-      elsif name !~ /\./
-        "#{name}#{exts.executable}"
-      else
-        name
-      end
-    end
-  end
-end
-
-MRuby.each_target do
-  next if kind_of? MRuby::CrossBuild
-
-  mruby_config = 'mruby-config' + (ENV['OS'] == 'Windows_NT' ? '.bat' : '')
-  mruby_config_path = "#{build_dir}/bin/#{mruby_config}"
-  @bins << mruby_config
-
-  file mruby_config_path => libfile("#{build_dir}/lib/libmruby") do |t|
-    FileUtils.copy "#{File.dirname(__FILE__)}/#{mruby_config}", t.name
-    config = Hash[open("#{build_dir}/lib/libmruby.flags.mak").read.split("\n").map {|x| a = x.split(/\s*=\s*/, 2); [a[0], a[1].gsub('\\"', '"') ]}]
-    IO.write(t.name, File.open(t.name) {|f|
-      f.read.gsub (/echo (MRUBY_CFLAGS|MRUBY_LIBS|MRUBY_LDFLAGS_BEFORE_LIBS|MRUBY_LDFLAGS|MRUBY_LIBMRUBY_PATH)/) {|x| config[$1].empty? ? '' : "echo #{config[$1]}"}
-    })
-    FileUtils.chmod(0755, t.name)
-  end
-end