script_core 0.2.2 → 0.2.7

data/ext/enterprise_script_service/mruby/appveyor.yml

@@ -4,20 +4,23 @@ os: Visual Studio 2017
 
 shallow_clone: true
 
-
-cache:
-  - win_flex_bison
-
-
 environment:
   matrix:
     # Visual Studio 2017 64bit
     - visualcpp: C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat
 
+    # Visual Studio 2017 32bit
+    - visualcpp: C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvarsall.bat
+      machine: x86
+
     # Visual Studio 2015 64bit
     - visualcpp: C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat
       machine: amd64
 
+    # Visual Studio 2015 32bit
+    - visualcpp: C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat
+      machine: x86
+
     # Visual Studio 2013 64bit
     - visualcpp: C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\vcvarsall.bat
       machine: amd64
@@ -30,13 +33,7 @@ init:
   - ruby --version
 
 
-install:
-  - if not exist win_flex_bison (
-      appveyor DownloadFile "https://github.com/lexxmark/winflexbison/releases/download/v.2.5.10/win_flex_bison-2.5.10.zip" &
-      7z x -y -owin_flex_bison win_flex_bison-2.5.10.zip
-    )
-
 build_script:
-  - set YACC=.\win_flex_bison\win_bison.exe
   - set MRUBY_CONFIG=appveyor_config.rb
+  - rake -m
   - rake -E $stdout.sync=true test

data/ext/enterprise_script_service/mruby/appveyor_config.rb

@@ -1,3 +1,9 @@
+def setup_option(conf)
+  conf.cc.flags[0].delete("/Zi") unless ENV['CFLAGS']
+  conf.cxx.flags[0].delete("/Zi") unless ENV['CFLAGS'] || ENV['CXXFLAGS']
+  conf.linker.flags << "/DEBUG:NONE" unless ENV['LDFLAGS']
+end
+
 MRuby::Build.new('full-debug') do |conf|
   toolchain :visualcpp
   enable_debug
@@ -5,6 +11,7 @@
   # include all core GEMs
   conf.gembox 'full-core'
   conf.cc.defines += %w(MRB_GC_STRESS MRB_METHOD_CACHE MRB_ENABLE_DEBUG_HOOK)
+  setup_option(conf)
 
   conf.enable_test
 end
@@ -17,6 +24,7 @@
   conf.compilers.each do |c|
     c.defines += %w(MRB_GC_FIXED_ARENA)
   end
+  setup_option(conf)
   conf.enable_bintest
   conf.enable_test
 end
@@ -28,6 +36,7 @@
   conf.compilers.each do |c|
     c.defines += %w(MRB_GC_FIXED_ARENA)
   end
+  setup_option(conf)
   conf.enable_bintest
   conf.enable_test
 

data/ext/enterprise_script_service/mruby/build_config.rb

@@ -30,9 +30,9 @@
   #   cc.flags = [ENV['CFLAGS'] || %w()]
   #   cc.include_paths = ["#{root}/include"]
   #   cc.defines = %w()
-  #   cc.option_include_path = '-I%s'
+  #   cc.option_include_path = %q[-I"%s"]
   #   cc.option_define = '-D%s'
-  #   cc.compile_options = "%{flags} -MMD -o %{outfile} -c %{infile}"
+  #   cc.compile_options = %Q[%{flags} -MMD -o "%{outfile}" -c "%{infile}"]
   # end
 
   # mrbc settings
@@ -50,25 +50,25 @@
   #   linker.library_paths = []
   #   linker.option_library = '-l%s'
   #   linker.option_library_path = '-L%s'
-  #   linker.link_options = "%{flags} -o %{outfile} %{objs} %{libs}"
+  #   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}'
+  #   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}'
+  #   yacc.compile_options = %q[-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}'
+  #   gperf.compile_options = %q[-L ANSI-C -C -p -j1 -i 1 -g -o -t -N mrb_reserved_word -k"1,3,$" "%{infile}" > "%{outfile}"]
   # end
 
   # file extensions

data/ext/enterprise_script_service/mruby/doc/guides/compile.md

@@ -6,12 +6,16 @@ binaries.
 ## Prerequisites
 
 To compile mruby out of the source code you need the following tools:
-* C Compiler (e.g. `gcc`)
-* Linker (e.g. `gcc`)
+* C Compiler (e.g. `gcc` or `clang`)
+* Linker (e.g. `gcc` or `clang`)
 * Archive utility (e.g. `ar`)
 * Parser generator (e.g. `bison`)
 * Ruby 2.0 or later (e.g. `ruby` or `jruby`)
 
+Note that `bison` bundled with MacOS is too old to compile `mruby`.
+Try `brew install bison` and follow the instuction shown to update
+the `$PATH` to compile `mruby`.
+
 Optional:
 * GIT (to update mruby source and integrate mrbgems easier)
 * C++ compiler (to use GEMs which include \*.cpp, \*.cxx, \*.cc)

data/ext/enterprise_script_service/mruby/doc/guides/debugger.md

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

data/ext/enterprise_script_service/mruby/doc/guides/mrbconf.md

@@ -54,17 +54,13 @@ You can use mrbconfs with following ways:
 * When defined removes floating point numbers from mruby.
 * It makes mruby easier to handle in "Microcontroller without FPU" and "Kernel Space".
 
-`MRB_INT16`
-* When defined `int16_t` will be defined as `mrb_int`.
-* Conflicts with `MRB_INT32` and `MRB_INT64`.
-
 `MRB_INT32`
-* When defined, or both `MRB_INT16` and `MRB_INT64` are not defined on 32-bit CPU mode, `int32_t` will be defined as `mrb_int`.
-* Conflicts with `MRB_INT16` and `MRB_INT64`.
+* When defined, or `MRB_INT64` are not defined on 32-bit CPU mode, `mrb_int` will be defined as `int32_t`.
+* Conflicts with `MRB_INT64`.
 
 `MRB_INT64`
-* When defined, or both `MRB_INT16` and `MRB_INT32` are not defined on 64-bit CPU mode, `int64_t` will be defined as `mrb_int`.
-* Conflicts with `MRB_INT16` and `MRB_INT32`.
+* When defined, or `MRB_INT32` are not defined on 64-bit CPU mode, `mrb_int` will be defined as `int64_t`.
+* Conflicts with `MRB_INT32`.
 
 ## Garbage collector configuration.
 

data/ext/enterprise_script_service/mruby/doc/limitations.md

@@ -38,7 +38,7 @@ puts [1,2,3]
 3
 ```
 
-#### mruby [2.1.0 (2019-11-19)]
+#### mruby [2.1.2 (2020-08-06)]
 
 ```
 [1, 2, 3]
@@ -61,7 +61,7 @@ end
 
 `ZeroDivisionError` is raised.
 
-#### mruby [2.1.0 (2019-11-19)]
+#### mruby [2.1.2 (2020-08-06)]
 
 No exception is raised.
 
@@ -89,7 +89,7 @@ p Liste.new "foobar"
 
 ` [] `
 
-#### mruby [2.1.0 (2019-11-19)]
+#### mruby [2.1.2 (2020-08-06)]
 
 `ArgumentError` is raised.
 
@@ -119,7 +119,7 @@ false
 true
 ```
 
-#### mruby [2.1.0 (2019-11-19)]
+#### mruby [2.1.2 (2020-08-06)]
 
 ```
 true
@@ -156,7 +156,7 @@ p 'ok'
 ok
 ```
 
-#### mruby [2.1.0 (2019-11-19)]
+#### mruby [2.1.2 (2020-08-06)]
 
 ```
 test.rb:8: undefined method 'test_func' (NoMethodError)
@@ -178,7 +178,7 @@ defined?(Foo)
 nil
 ```
 
-#### mruby [2.1.0 (2019-11-19)]
+#### mruby [2.1.2 (2020-08-06)]
 
 `NameError` is raised.
 
@@ -195,7 +195,7 @@ alias $a $__a__
 
 ` nil `
 
-#### mruby [2.1.0 (2019-11-19)]
+#### mruby [2.1.2 (2020-08-06)]
 
 Syntax error
 
@@ -217,7 +217,7 @@ end
 `ArgumentError` is raised.
 The re-defined `+` operator does not accept any arguments.
 
-#### mruby [2.1.0 (2019-11-19)]
+#### mruby [2.1.2 (2020-08-06)]
 
 ` 'ab' `
 Behavior of the operator wasn't changed.
@@ -233,7 +233,7 @@ $ ruby -e 'puts Proc.new {}.binding'
 #<Binding:0x00000e9deabb9950>
 ```
 
-#### mruby [2.1.0 (2019-11-19)]
+#### mruby [2.1.2 (2020-08-06)]
 
 ```
 $ ./bin/mruby -e 'puts Proc.new {}.binding'
@@ -255,7 +255,7 @@ $ ruby -e 'def m(*r,**k) p [r,k] end; m("a"=>1,:b=>2)'
 [[{"a"=>1}], {:b=>2}]
 ```
 
-#### mruby [mruby 2.1.0]
+#### mruby [mruby 2.1.2]
 
 ```
 $ ./bin/mruby -e 'def m(*r,**k) p [r,k] end; m("a"=>1,:b=>2)'

data/ext/enterprise_script_service/mruby/doc/opcode.md

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