mrb_parser 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b96059708452f131c2ef1c44c20b13c163b687f9
+  data.tar.gz: 9df8a740b518b0b6cd628f9c026360213bd1c5a5
+SHA512:
+  metadata.gz: fdc2cd80c1e26c8b5eee9191c628398d71f757512d2cf202c208ab571af24760609a25b5993b840a9662a262bea230bc8e7bdb7be5c5330782cdb834f51ece9c
+  data.tar.gz: fe9035d908042c98ebc57d00d37ddc84da200a96cb81524b40118cf5ef7056e53b8a8cb9242cb30b3235604401394a1dfb247084bda47815d809789f0ed98650

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*~
+#*#

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mrb_parser.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Team Yamanekko
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# MrbParser: mrb file parser
+
+MrbParer is a parser library and command to parse mrb format, binary code format
+generated by mruby(mrbc).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mrb_parser'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mrb_parser
+
+## Usage
+
+MrbParser has a simple command: ``mrb_parser``.
+
+    $ mrb_parser sample.mrb
+
+To show more information, with ``-d`` option:
+
+    $ mrb_parser -d sample.mrb
+
+## TODO
+
+* support LINENO section (current implementation is broken)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/mrb_parser

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'mrb_parser'
+
+def usage
+  abort "usage: mrb_parser [-d] <mrb file>"
+end
+
+def main
+  if ARGV.size < 1 or ARGV.size > 2
+    usage
+  end
+
+  verbose = nil
+  filename = ARGV[0]
+  if filename == "-d"
+    filename = ARGV[1]
+    verbose = true
+  end
+
+  if !File.exist? filename
+    abort "#{filename}: file not found"
+  end
+
+  parser = MrbParser.new(filename)
+  parser.verbose = verbose
+  parser.parse
+  parser.dump
+end
+
+main

data/lib/mrb_parser/code_dump.rb

@@ -0,0 +1,390 @@
+class MrbParser
+  class CodeDump
+
+    MAXARG_Bx = 0xffff
+    MAXARG_sBx = (MAXARG_Bx>>1)    ## `sBx' is signed
+
+    OP_NOP   = 0     # /*                                                             */
+    OP_MOVE  = 1     # /*      A B     R(A) := R(B)                                    */
+    OP_LOADL = 2     # /*     A Bx    R(A) := Lit(Bx)                                 */
+    OP_LOADI = 3     # /*     A sBx   R(A) := sBx                                     */
+    OP_LOADSYM = 4   # /*   A Bx    R(A) := Sym(Bx)                                 */
+    OP_LOADNIL = 5   # /*   A       R(A) := nil                                     */
+    OP_LOADSELF = 6  # /*  A       R(A) := self                                    */
+    OP_LOADT = 7     # /*     A       R(A) := true                                    */
+    OP_LOADF = 8     # /*     A       R(A) := false                                   */
+
+    OP_GETGLOBAL = 9 # /* A Bx    R(A) := getglobal(Sym(Bx))                      */
+    OP_SETGLOBAL =10 # /* A Bx    setglobal(Sym(Bx), R(A))                        */
+    OP_GETSPECIAL=11 # /*A Bx    R(A) := Special[Bx]                             */
+    OP_SETSPECIAL=12 # /*A Bx    Special[Bx] := R(A)                             */
+    OP_GETIV = 13    # /*     A Bx    R(A) := ivget(Sym(Bx))                          */
+    OP_SETIV = 14    # /*     A Bx    ivset(Sym(Bx),R(A))                             */
+    OP_GETCV = 15    # /*     A Bx    R(A) := cvget(Sym(Bx))                          */
+    OP_SETCV = 16    # /*     A Bx    cvset(Sym(Bx),R(A))                             */
+    OP_GETCONST = 17 # /*  A Bx    R(A) := constget(Sym(Bx))                       */
+    OP_SETCONST = 18 # /*  A Bx    constset(Sym(Bx),R(A))                          */
+    OP_GETMCNST = 19 # /*  A Bx    R(A) := R(A)::Sym(B)                            */
+    OP_SETMCNST = 20 # /*  A Bx    R(A+1)::Sym(B) := R(A)                          */
+    OP_GETUPVAR = 21 # /*  A B C   R(A) := uvget(B,C)                              */
+    OP_SETUPVAR = 22 # /*  A B C   uvset(B,C,R(A))                                 */
+
+    OP_JMP = 23      # /*       sBx     pc+=sBx                                         */
+    OP_JMPIF = 24    # /*     A sBx   if R(A) pc+=sBx                                 */
+    OP_JMPNOT = 25   # /*    A sBx   if !R(A) pc+=sBx                                */
+    OP_ONERR = 26    # /*     sBx     rescue_push(pc+sBx)                             */
+    OP_RESCUE = 27   # /*    A       clear(exc); R(A) := exception (ignore when A=0) */
+    OP_POPERR = 28   # /*    A       A.times{rescue_pop()}                           */
+    OP_RAISE = 29    # /*     A       raise(R(A))                                     */
+    OP_EPUSH = 30    # /*     Bx      ensure_push(SEQ[Bx])                            */
+    OP_EPOP = 31     # /*      A       A.times{ensure_pop().call}                      */
+
+    OP_SEND = 32     # /*      A B C   R(A) := call(R(A),mSym(B),R(A+1),...,R(A+C))    */
+    OP_SENDB = 33    # /*     A B C   R(A) := call(R(A),mSym(B),R(A+1),...,R(A+C),&R(A+C+1))*/
+    OP_FSEND = 34    # /*     A B C   R(A) := fcall(R(A),mSym(B),R(A+1),...,R(A+C-1)) */
+    OP_CALL = 35     # /*      A B C   R(A) := self.call(R(A),.., R(A+C))              */
+    OP_SUPER = 36    # /*     A B C   R(A) := super(R(A+1),... ,R(A+C-1))             */
+    OP_ARGARY = 37   # /*    A Bx    R(A) := argument array (16=6:1:5:4)             */
+    OP_ENTER = 38    # /*     Ax      arg setup according to flags (24=5:5:1:5:5:1:1) */
+    OP_KARG = 39     # /*      A B C   R(A) := kdict[mSym(B)]; if C kdict.rm(mSym(B))  */
+    OP_KDICT = 40    # /*     A C     R(A) := kdict                                   */
+
+    OP_RETURN = 41   # /*    A B     return R(A) (B=normal,in-block return/break)    */
+    OP_TAILCALL = 42 # /*  A B C   return call(R(A),mSym(B),*R(C))                 */
+    OP_BLKPUSH = 43  # /*   A Bx    R(A) := block (16=6:1:5:4)                      */
+
+    OP_ADD = 44      # /*       A B C   R(A) := R(A)+R(A+1) (mSyms[B]=:+,C=1)           */
+    OP_ADDI = 45     # /*      A B C   R(A) := R(A)+C (mSyms[B]=:+)                    */
+    OP_SUB = 46      # /*       A B C   R(A) := R(A)-R(A+1) (mSyms[B]=:-,C=1)           */
+    OP_SUBI = 47     # /*      A B C   R(A) := R(A)-C (mSyms[B]=:-)                    */
+    OP_MUL = 48      # /*       A B C   R(A) := R(A)*R(A+1) (mSyms[B]=:*,C=1)           */
+    OP_DIV = 49      # /*       A B C   R(A) := R(A)/R(A+1) (mSyms[B]=:/,C=1)           */
+    OP_EQ = 50       # /*        A B C   R(A) := R(A)==R(A+1) (mSyms[B]=:==,C=1)         */
+    OP_LT = 51       # /*        A B C   R(A) := R(A)<R(A+1)  (mSyms[B]=:<,C=1)          */
+    OP_LE = 52       # /*        A B C   R(A) := R(A)<=R(A+1) (mSyms[B]=:<=,C=1)         */
+    OP_GT = 53       # /*        A B C   R(A) := R(A)>R(A+1)  (mSyms[B]=:>,C=1)          */
+    OP_GE = 54       # /*        A B C   R(A) := R(A)>=R(A+1) (mSyms[B]=:>=,C=1)         */
+
+    OP_ARRAY = 55    # /*     A B C   R(A) := ary_new(R(B),R(B+1)..R(B+C))            */
+    OP_ARYCAT = 56   # /*    A B     ary_cat(R(A),R(B))                              */
+    OP_ARYPUSH = 57  # /*   A B     ary_push(R(A),R(B))                             */
+    OP_AREF = 58     # /*      A B C   R(A) := R(B)[C]                                 */
+    OP_ASET = 59     # /*      A B C   R(B)[C] := R(A)                                 */
+    OP_APOST = 60    # /*     A B C   *R(A),R(A+1)..R(A+C) := R(A)                    */
+
+    OP_STRING = 61   # /*    A Bx    R(A) := str_dup(Lit(Bx))                        */
+    OP_STRCAT = 62   # /*    A B     str_cat(R(A),R(B))                              */
+
+    OP_HASH = 63     # /*      A B C   R(A) := hash_new(R(B),R(B+1)..R(B+C))           */
+    OP_LAMBDA = 64   # /*    A Bz Cz R(A) := lambda(SEQ[Bz],Cm)                      */
+    OP_RANGE = 65    # /*     A B C   R(A) := range_new(R(B),R(B+1),C)                */
+
+    OP_OCLASS = 66   # /*    A       R(A) := ::Object                                */
+    OP_CLASS = 67    # /*     A B     R(A) := newclass(R(A),mSym(B),R(A+1))           */
+    OP_MODULE = 68   # /*    A B     R(A) := newmodule(R(A),mSym(B))                 */
+    OP_EXEC = 69     # /*      A Bx    R(A) := blockexec(R(A),SEQ[Bx])                 */
+    OP_METHOD = 70   # /*    A B     R(A).newmethod(mSym(B),R(A+1))                  */
+    OP_SCLASS = 71   # /*    A B     R(A) := R(B).singleton_class                    */
+    OP_TCLASS = 72   # /*    A       R(A) := target_class                            */
+
+    OP_DEBUG = 73    # /*     A       print R(A)                                      */
+    OP_STOP = 74     # /*              stop VM                                         */
+    OP_ERR = 75      # /*       Bx      raise RuntimeError with message Lit(Bx)         */
+
+    OP_RSVD1 = 76    # /*             reserved instruction #1                         */
+    OP_RSVD2 = 77    # /*             reserved instruction #2                         */
+    OP_RSVD3 = 78    # /*             reserved instruction #3                         */
+    OP_RSVD4 = 79    # /*             reserved instruction #4                         */
+    OP_RSVD5 = 80    # /*             reserved instruction #5                         */
+
+
+    OP_R_NORMAL = 0
+    OP_R_BREAK  = 1
+    OP_R_RETURN = 2
+
+    # 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
+
+    def initialize(irep)
+      @irep = irep
+    end
+
+    def opcode(code)
+      code & 0x7F
+    end
+
+    def getarg_a(code)
+      (code >> 23) & 0x1ff
+    end
+
+    def getarg_b(code)
+      (code >> 14) & 0x1ff
+    end
+
+    def getarg_c(code)
+      (code >> 7) & 0x7f
+    end
+
+    def getarg_bx(code)
+      (code >> 7) & 0xffff
+    end
+
+    def getarg_sbx(code)
+      getarg_bx(code) - MAXARG_sBx
+    end
+
+    def getarg_ax(code)
+      (code >> 7) & 0x1ffffff
+    end
+
+    def getarg_unpack_b(code, n1, n2)
+      (code >> (7 + n2)) & ((1 << n1)-1)
+    end
+
+    def getarg_unpack_c(code, n1, n2)
+      (code >> 7) & ((1 << n2)-1)
+    end
+
+    def getarg_b2(code)
+      getarg_unpack_b(code, 14, 2)
+    end
+
+    def getarg_c2(code)
+      getarg_unpack_c(code, 14, 2)
+    end
+
+
+    def dump(c, i)
+      printf("%03d ", i)
+      op = opcode(c)
+      case op
+      when OP_NOP
+        printf("OP_NOP\n")
+      when OP_MOVE
+        printf("OP_MOVE\tR%d\tR%d\n", getarg_a(c), getarg_b(c))
+      when OP_LOADL
+        printf("OP_LOADL\tR%d\tL(%d)\n", getarg_a(c), getarg_bx(c))
+      when OP_LOADI
+        printf("OP_LOADI\tR%d\t%d\n", getarg_a(c), getarg_sbx(c))
+      when OP_LOADSYM
+        printf("OP_LOADSYM\tR%d\t:%s\n", getarg_a(c),
+               @irep.syms[getarg_bx(c)])
+      when OP_LOADNIL
+        printf("OP_LOADNIL\tR%d\n", getarg_a(c))
+      when OP_LOADSELF
+        printf("OP_LOADSELF\tR%d\n", getarg_a(c))
+      when OP_LOADT
+        printf("OP_LOADT\tR%d\n", getarg_a(c))
+      when OP_LOADF
+        printf("OP_LOADF\tR%d\n", getarg_a(c))
+      when OP_GETGLOBAL
+        printf("OP_GETGLOBAL\tR%d\t:%s\n", getarg_a(c),
+               @irep.syms[getarg_bx(c)])
+      when OP_SETGLOBAL
+        printf("OP_SETGLOBAL\t:%s\tR%d\n",
+               @irep.syms[getarg_bx(c)],
+               getarg_a(c))
+      when OP_GETCONST
+        printf("OP_GETCONST\tR%d\t:%s\n", getarg_a(c),
+               @irep.syms[getarg_bx(c)])
+      when OP_SETCONST
+        printf("OP_SETCONST\t:%s\tR%d\n",
+               @irep.syms[getarg_bx(c)],
+               getarg_a(c))
+      when OP_GETMCNST
+        printf("OP_GETMCNST\tR%d\tR%d::%s\n", getarg_a(c), getarg_a(c),
+               @irep.syms[getarg_bx(c)])
+      when OP_SETMCNST
+        printf("OP_SETMCNST\tR%d::%s\tR%d\n", getarg_a(c)+1,
+               @irep.syms[getarg_bx(c)],
+               getarg_a(c))
+      when OP_GETIV
+        printf("OP_GETIV\tR%d\t%s\n", getarg_a(c),
+               @irep.syms[getarg_bx(c)])
+      when OP_SETIV
+        printf("OP_SETIV\t%s\tR%d\n",
+               @irep.syms[getarg_bx(c)],
+               getarg_a(c))
+      when OP_GETUPVAR
+        printf("OP_GETUPVAR\tR%d\t%d\t%d\n",
+               getarg_a(c), getarg_b(c), getarg_c(c))
+      when OP_SETUPVAR
+        printf("OP_SETUPVAR\tR%d\t%d\t%d\n",
+               getarg_a(c), getarg_b(c), getarg_c(c))
+      when OP_GETCV
+        printf("OP_GETCV\tR%d\t%s\n", getarg_a(c),
+               @irep.syms[getarg_bx(c)])
+      when OP_SETCV
+        printf("OP_SETCV\t%s\tR%d\n",
+               @irep.syms[getarg_bx(c)],
+               getarg_a(c))
+      when OP_JMP
+        printf("OP_JMP\t\t%03d\n", i+getarg_sbx(c))
+      when OP_JMPIF
+        printf("OP_JMPIF\tR%d\t%03d\n", getarg_a(c), i+getarg_sbx(c))
+      when OP_JMPNOT
+        printf("OP_JMPNOT\tR%d\t%03d\n", getarg_a(c), i+getarg_sbx(c));
+      when OP_SEND
+        printf("OP_SEND\tR%d\t:%s\t%d\n", getarg_a(c),
+               @irep.syms[getarg_b(c)],
+               getarg_c(c))
+      when OP_SENDB
+        printf("OP_SENDB\tR%d\t:%s\t%d\n", getarg_a(c),
+               @irep.syms[getarg_b(c)],
+               getarg_c(c))
+      when OP_TAILCALL
+        printf("OP_TAILCALL\tR%d\t:%s\t%d\n", getarg_a(c),
+               @irep.syms[getarg_b(c)],
+               getarg_c(c))
+      when OP_SUPER
+        printf("OP_SUPER\tR%d\t%d\n", getarg_a(c),
+               getarg_c(c))
+      when OP_ARGARY
+        printf("OP_ARGARY\tR%d\t%d:%d:%d:%d\n", getarg_a(c),
+               (getarg_bx(c)>>10)&0x3f,
+               (getarg_bx(c)>>9)&0x1,
+               (getarg_bx(c)>>4)&0x1f,
+               (getarg_bx(c)>>0)&0xf)
+
+      when OP_ENTER
+        printf("OP_ENTER\t%d:%d:%d:%d:%d:%d:%d\n",
+               (getarg_ax(c)>>18)&0x1f,
+               (getarg_ax(c)>>13)&0x1f,
+               (getarg_ax(c)>>12)&0x1,
+               (getarg_ax(c)>>7)&0x1f,
+               (getarg_ax(c)>>2)&0x1f,
+               (getarg_ax(c)>>1)&0x1,
+               getarg_ax(c) & 0x1)
+      when OP_RETURN
+        printf("OP_RETURN\tR%d", getarg_a(c))
+        case getarg_b(c)
+        when OP_R_NORMAL
+          printf("\n")
+        when OP_R_RETURN
+          printf("\treturn\n")
+        when OP_R_BREAK
+          printf("\tbreak\n")
+        else
+          printf("\tbroken\n")
+        end
+      when OP_BLKPUSH
+        printf("OP_BLKPUSH\tR%d\t%d:%d:%d:%d\n", getarg_a(c),
+               (getarg_bx(c)>>10)&0x3f,
+               (getarg_bx(c)>>9)&0x1,
+               (getarg_bx(c)>>4)&0x1f,
+               (getarg_bx(c)>>0)&0xf)
+
+      when OP_LAMBDA
+        printf("OP_LAMBDA\tR%d\tI(%+d)\t%d\n", getarg_a(c), getarg_b2(c), getarg_c2(c))
+      when OP_RANGE
+        printf("OP_RANGE\tR%d\tR%d\t%d\n", getarg_a(c), getarg_b(c), getarg_c(c))
+      when OP_METHOD
+        printf("OP_METHOD\tR%d\t:%s\n", getarg_a(c),
+               @irep.syms[getarg_b(c)])
+
+      when OP_ADD
+        printf("OP_ADD\tR%d\t:%s\t%d\n", getarg_a(c),
+               @irep.syms[getarg_b(c)],
+               getarg_c(c))
+      when OP_ADDI
+        printf("OP_ADDI\tR%d\t:%s\t%d\n", getarg_a(c),
+               @irep.syms[getarg_b(c)],
+               getarg_c(c))
+      when OP_SUB
+        printf("OP_SUB\tR%d\t:%s\t%d\n", getarg_a(c),
+               @irep.syms[getarg_b(c)],
+               getarg_c(c))
+      when OP_SUBI
+        printf("OP_SUBI\tR%d\t:%s\t%d\n", getarg_a(c),
+               @irep.syms[getarg_b(c)],
+               getarg_c(c))
+      when OP_MUL
+        printf("OP_MUL\tR%d\t:%s\t%d\n", getarg_a(c),
+               @irep.syms[getarg_b(c)],
+               getarg_c(c))
+      when OP_DIV
+        printf("OP_DIV\tR%d\t:%s\t%d\n", getarg_a(c),
+               @irep.syms[getarg_b(c)],
+               getarg_c(c))
+      when OP_LT
+        printf("OP_LT\tR%d\t:%s\t%d\n", getarg_a(c),
+               @irep.syms[getarg_b(c)],
+               getarg_c(c))
+      when OP_LE
+        printf("OP_LE\tR%d\t:%s\t%d\n", getarg_a(c),
+               @irep.syms[getarg_b(c)],
+               getarg_c(c))
+      when OP_GT
+        printf("OP_GT\tR%d\t:%s\t%d\n", getarg_a(c),
+               @irep.syms[getarg_b(c)],
+               getarg_c(c))
+      when OP_GE
+        printf("OP_GE\tR%d\t:%s\t%d\n", getarg_a(c),
+               @irep.syms[getarg_b(c)],
+               getarg_c(c))
+      when OP_EQ
+        printf("OP_EQ\tR%d\t:%s\t%d\n", getarg_a(c),
+               @irep.syms[getarg_b(c)],
+               getarg_c(c))
+
+      when OP_STOP
+        printf("OP_STOP\n")
+
+      when OP_ARRAY
+        printf("OP_ARRAY\tR%d\tR%d\t%d\n", getarg_a(c), getarg_b(c), getarg_c(c))
+      when OP_ARYCAT
+        printf("OP_ARYCAT\tR%d\tR%d\n", getarg_a(c), getarg_b(c))
+      when OP_ARYPUSH
+        printf("OP_ARYPUSH\tR%d\tR%d\n", getarg_a(c), getarg_b(c))
+      when OP_AREF
+        printf("OP_AREF\tR%d\tR%d\t%d\n", getarg_a(c), getarg_b(c), getarg_c(c))
+      when OP_APOST
+        printf("OP_APOST\tR%d\t%d\t%d\n", getarg_a(c), getarg_b(c), getarg_c(c))
+      when OP_STRING
+        s = @irep.pool[getarg_bx(c)]
+        printf("OP_STRING\tR%d\t%s\n", getarg_a(c), s)
+      when OP_STRCAT
+        printf("OP_STRCAT\tR%d\tR%d\n", getarg_a(c), getarg_b(c))
+      when OP_HASH
+        printf("OP_HASH\tR%d\tR%d\t%d\n", getarg_a(c), getarg_b(c), getarg_c(c))
+
+      when OP_OCLASS
+        printf("OP_OCLASS\tR%d\n", getarg_a(c))
+      when OP_CLASS
+        printf("OP_cLASS\tR%d\t:%s\n", getarg_a(c),
+               @irep.syms[getarg_b(c)])
+      when OP_MODULE
+        printf("OP_MODULE\tR%d\t:%s\n", getarg_a(c),
+               @irep.syms[getarg_b(c)])
+      when OP_EXEC
+        printf("OP_EXEC\tR%d\tI(%+d)\n", getarg_a(c), getarg_bx(c))
+      when OP_SCLASS
+        printf("OP_SCLASS\tR%d\tR%d\n", getarg_a(c), getarg_b(c))
+      when OP_TCLASS
+        printf("OP_TCLASS\tR%d\n", getarg_a(c))
+      when OP_ERR
+        printf("OP_ERR\tL(%d)\n", getarg_bx(c))
+      when OP_EPUSH
+        printf("OP_EPUSH\t:I(%+d)\n", getarg_bx(c))
+      when OP_ONERR
+        printf("OP_ONERR\t%03d\n", i+getarg_sbx(c))
+      when OP_RESCUE
+        printf("OP_RESCUE\tR%d\n", getarg_a(c))
+      when OP_RAISE
+        printf("OP_RAISE\tR%d\n", getarg_a(c))
+      when OP_POPERR
+        printf("OP_POPERR\t%d\n", getarg_a(c))
+      when OP_EPOP
+        printf("OP_EPOP\t%d\n", getarg_a(c))
+      else
+        printf("OP_unknown %d\t%d\t%d\t%d\n", opcode(c),
+               getarg_a(c), getarg_b(c), getarg_c(c))
+      end
+    end
+
+  end
+end

data/lib/mrb_parser/crc.rb

@@ -0,0 +1,32 @@
+class MrbParser
+
+  ##
+  # calculate CRC
+  #
+  # an Ruby port of src/crc.c in mruby
+  #
+  class CRC
+
+    CRC_16_CCITT = 0x11021  ## x^16+x^12+x^5+1
+    CRC_XOR_PATTERN = (CRC_16_CCITT << 8)
+    CRC_CARRY_BIT = 0x01000000
+    CHAR_BIT = 8
+
+    def self.calc_crc_16_ccitt(data0, nbytes, crc)
+      data = data0.unpack("C*")
+      crcwk = crc << 8
+      for ibyte in 0...nbytes
+        crcwk |= data[ibyte]
+        for ibit in 0...CHAR_BIT
+          crcwk <<= 1
+          carry = crcwk & CRC_CARRY_BIT
+          if carry.nonzero?
+            crcwk ^= CRC_XOR_PATTERN
+          end
+        end
+      end
+      return crcwk >> 8
+    end
+
+  end
+end

data/lib/mrb_parser/debug_info.rb

@@ -0,0 +1,76 @@
+class MrbParser
+  class DebugInfo
+
+    MRB_DEBUG_LINE_ARY  = 0
+    MRB_DEBUG_LINE_FLAT_MAP = 1
+
+    LINE_TYPE = ["ARY", "FLAT_MAP"]
+
+    attr_accessor :pc_count
+    attr_accessor :files
+    attr_accessor :debug_section
+    attr_accessor :irep_record
+    attr_reader :infos
+
+    def initialize(debug_section, irep_record)
+      @debug_section = debug_section
+      @irep_record = irep_record
+      irep_record.debug_info = self
+      @infos = []
+    end
+
+    def parse_record(parser)
+      @pc_count = parser.read_uint32
+      flen = parser.read_uint16
+      @files = []
+      flen.times do
+        file = DebugInfoFile.new
+        @files << file
+        file.start_pos = parser.read_uint32
+        filename_idx = parser.read_uint16
+        file.filename = @debug_section.filenames[filename_idx]
+
+        file.line_entry_count = parser.read_uint32
+        file.line_type = parser.read_uint8
+        case file.line_type
+        when MRB_DEBUG_LINE_ARY ## 0
+          file.line_ary = []
+          file.line_entry_count.times do
+            file.line_ary << parser.read_uint16
+          end
+        when MRB_DEBUG_LINE_FLAT_MAP ## 1
+          file.line_flat_map = []
+          file.line_entry_count.times do
+            start_pos = parser.read_uint32
+            line = parser.read_uint16
+            file.line_flat_map << {start_pos: start_pos, line: line}
+          end
+        else
+          raise
+        end
+      end
+      @irep_record.recs.each do |irep_record|
+        info = MrbParser::DebugInfo.new(@debug_section, irep_record)
+        @infos << info
+        info.parse_record(parser)
+      end
+      self
+    end
+
+    def printf_indent(n, *args)
+      print " "*n
+      printf *args
+    end
+
+    def dump(n = 2)
+      printf_indent n, "*** DEBUG INFO ***\n"
+      printf_indent n, "count: %d\n", @pc_count
+      printf_indent n, "files: %d\n", @files.size
+      @files.map{|file| file.dump(n+2)}
+      @infos.each do |debug_info|
+        debug_info.dump(n + 2)
+      end
+      printf_indent n, "*** ***\n"
+    end
+  end
+end

data/lib/mrb_parser/debug_info_file.rb

@@ -0,0 +1,40 @@
+class MrbParser
+  class DebugInfoFile
+    attr_accessor :start_pos
+    attr_accessor :filename
+    attr_accessor :line_entry_count
+    attr_accessor :line_type
+
+    attr_accessor :line_flat_map
+    attr_accessor :line_ary
+
+    def initialize
+    end
+
+    def printf_indent(n, *args)
+      print " "*n
+      printf *args
+    end
+
+    def dump(n = 2)
+      printf_indent n, "*** DEBUG INFO FILE ***\n"
+      printf_indent n, "start: %d\n", @start_pos
+      printf_indent n, "fname: %s\n", @filename
+      printf_indent n, "line type: %d (%s)\n", @line_type,
+                                               MrbParser::DebugInfo::LINE_TYPE[@line_type]
+      printf_indent n, "lines: %d\n", @line_entry_count
+      case @line_type
+      when MrbParser::DebugInfo::MRB_DEBUG_LINE_ARY
+        @line_ary.each do |line|
+          printf_indent n, "  line: %d\n", line
+        end
+      when MrbParser::DebugInfo::MRB_DEBUG_LINE_FLAT_MAP
+        @line_flat_map.each do |map|
+          printf_indent n, "  line: %d, start_pos: %d\n", map[:line], map[:start_pos]
+        end
+      end
+
+      printf_indent n, "*** ***\n"
+    end
+  end
+end

data/lib/mrb_parser/debug_section.rb

@@ -0,0 +1,43 @@
+require 'mrb_parser/debug_info'
+require 'mrb_parser/debug_info_file'
+
+class MrbParser
+  class DebugSection < Section
+
+    attr_accessor :debug_info
+    attr_accessor :filenames
+
+    def initialize(*)
+      super
+    end
+
+    def parse_record(parser)
+      rec = parser.irep_section.rec
+      @debug_info = MrbParser::DebugInfo.new(self, rec)
+      @debug_info.parse_record(parser)
+    end
+
+    def parse_body(parser)
+      filenames_len = parser.read_uint16
+      @filenames = []
+      filenames_len.times do
+        @filenames << parser.read_n16string
+      end
+      parse_record(parser)
+      self
+    end
+
+    def dump
+      printf "*** DEBUG SECTION ***\n"
+      printf "secID: %s\n", @signature
+      printf "size : %s\n", @size
+      printf "files: %d\n", @filenames.size
+      @filenames.each do |fname|
+        printf "  filename: %s\n", fname
+      end
+      @debug_info.dump
+      printf "*** ***\n"
+    end
+
+  end
+end

data/lib/mrb_parser/end_section.rb

@@ -0,0 +1,21 @@
+class MrbParser
+  class EndSection < Section
+    def initialize(*)
+      super
+    end
+
+    def parse_body(parser)
+    end
+
+    def end?
+      true
+    end
+
+    def dump
+      printf "*** END SECTION ***\n"
+      printf "secID: %s\n", @signature
+      printf "size : %s\n", @size
+      printf "*** ***\n"
+    end
+  end
+end

data/lib/mrb_parser/error.rb

@@ -0,0 +1,3 @@
+class MrbParser
+  class Error < StandardError; end
+end

data/lib/mrb_parser/header.rb

@@ -0,0 +1,59 @@
+require 'mrb_parser/crc'
+class MrbParser
+  class Header
+
+    attr_reader :signature, :version, :crc, :size,
+                :compiler_name, :compiler_version
+
+    def self.parse(parser)
+      header = Header.new()
+      header.parse(parser)
+    end
+
+    def initialize
+    end
+
+    def parse(parser)
+      @signature = parser.read_chars(4)
+      @version = parser.read_chars(4)
+      @crc = parser.read_uint16
+      @crc_verified = check_crc(parser)
+      @size = parser.read_uint32
+      @compiler_name = parser.read_chars(4)
+      @compiler_version = parser.read_chars(4)
+
+      if parser.verbose
+        if !valid?
+          STDERR.print "** [WARN] This header seems to be invalid. **\n"
+        end
+      end
+
+      self
+    end
+
+    def check_crc(parser)
+      pos = parser.pos
+      rest_data = parser.read(nil)
+      parser.seek(pos)
+      checksum = MrbParser::CRC.calc_crc_16_ccitt(rest_data, rest_data.size, 0)
+      @crc == checksum
+    end
+
+
+    def valid?
+      @signature == "RITE" && @version == "0002" && @crc_verified
+    end
+
+    def dump
+      printf "*** BINARY HEADER ***\n"
+      printf "secID: %s\n", @signature
+      printf "ver  : %s\n", @version
+      printf "crc  : 0x%04x (%s)\n", @crc, @crc_verified
+      printf "size : 0x%08x\n", @size
+      printf "compiler:\n"
+      printf "  name: %s\n", @compiler_name
+      printf "  ver : %s\n", @compiler_version
+      printf "*** ***\n"
+    end
+  end
+end

data/lib/mrb_parser/irep_record.rb

@@ -0,0 +1,109 @@
+require 'mrb_parser/code_dump'
+
+class MrbParser
+  class IrepRecord
+
+    IREP_TT_STRING = 0
+    IREP_TT_FIXNUM = 1
+    IREP_TT_FLOAT  = 2
+
+    MRB_DUMP_NULL_SYM_LEN = 0xFFFF
+
+    attr_accessor :debug_info
+    attr_reader :recs
+    attr_reader :syms
+    attr_reader :pool
+
+    def initialize
+    end
+
+    def parse_record(parser)
+      @section_size = parser.read_uint32
+      @nlocals = parser.read_uint16
+      @nregs = parser.read_uint16
+      rlen = parser.read_uint16
+      parse_iseq(parser)
+      parse_pool(parser)
+      parse_symbol(parser)
+      @recs = []
+      rlen.times do |i|
+        rec = IrepRecord.new()
+        @recs[i] = rec.parse_record(parser)
+      end
+      self
+    end
+
+    def parse_iseq(parser)
+      ilen = parser.read_uint32
+      @iseq = []
+      ilen.times do |i|
+        @iseq << parser.read_uint32
+      end
+    end
+
+    def parse_pool(parser)
+      plen = parser.read_uint32
+      @pool = []
+      plen.times do |i|
+        type = parser.read_uint8
+        str = parser.read_n16string
+        case type
+        when IREP_TT_FIXNUM
+          @pool[i] = Integer(str)
+        when IREP_TT_FLOAT
+          @pool[i] = Float(str)
+        when IREP_TT_STRING
+          @pool[i] = str
+        else
+          @pool[i] = nil
+        end
+      end
+    end
+
+    def parse_symbol(parser)
+      slen = parser.read_uint32
+      @syms = []
+      slen.times do |i|
+        len = parser.read_uint16
+        if len == MRB_DUMP_NULL_SYM_LEN
+          @syms[i] = nil
+          next
+        end
+        @syms[i] = parser.read_chars(len)
+        terminater = parser.read_uint8 ## skip NULL byte
+      end
+    end
+
+    def printf_indent(n, *args)
+      print " "*n
+      printf *args
+    end
+
+    def dump(n = 2)
+      code_dump = MrbParser::CodeDump.new(self)
+      printf_indent n, "*** IREP RECORD ***\n"
+      printf_indent n, "locals: %d\n", @nlocals
+      printf_indent n, "regs  : %d\n", @nregs
+      printf_indent n, "iseqs : %d\n", @iseq.size
+      @iseq.each_with_index do |code, i|
+        printf_indent n, "  code: %08x\n", code
+        printf_indent n, "        "
+        code_dump.dump(code, i)
+      end
+      printf_indent n, "pools : %d\n", @pool.size
+      @pool.each do |pool|
+        printf_indent n, "  pool: %s\n", pool.inspect
+      end
+      printf_indent n, "syms  : %d\n", @syms.size
+      @syms.each do |item|
+        printf_indent n, "  sym: %s\n", item.inspect
+      end
+      printf_indent n, "ireps : %d\n", @recs.size
+      @recs.each do |rec|
+        rec.dump(n+2)
+      end
+      printf_indent n, "*** ***\n"
+    end
+  end
+end
+

data/lib/mrb_parser/irep_section.rb

@@ -0,0 +1,34 @@
+require 'mrb_parser/irep_record'
+class MrbParser
+  class IrepSection < Section
+
+    attr_reader :rec
+
+    def initialize(*)
+      super
+    end
+
+    def parse_body(parser)
+      @vm_version = parser.read_chars(4)
+      @rec = parse_record(parser)
+      parser.irep_section = self
+      self
+    end
+
+    def parse_record(parser)
+      rec = MrbParser::IrepRecord.new
+      rec.parse_record(parser)
+      rec
+    end
+
+    def dump
+      printf "*** IREP SECTION ***\n"
+      printf "secID : %s\n", @signature
+      printf "size  : %s\n", @size
+      printf "vm ver: %s\n", @vm_version
+      @rec.dump
+      printf "*** ***\n"
+    end
+
+  end
+end

data/lib/mrb_parser/lineno_section.rb

@@ -0,0 +1,35 @@
+class MrbParser
+  class LinenoSection < Section
+    def initialize(*)
+      super
+    end
+
+    def parse_body(parser, irep_record = nil)
+      record_size = parser.read_uint32
+      @filename = parser.read_n16string
+      @niseq = parser.read_uint32
+      @lines = []
+      @niseq.times do |i|
+        line = parser.read_uint16
+        @lines << line
+      end
+
+      unless irep_record
+        irep_record = parser.irep_section.rec
+      end
+      irep_record.debug_info = self
+
+      irep_record.recs.each do |rec|
+        parse_body(parser, rec)
+      end
+    end
+
+    def dump
+      printf "*** LINENO SECTION ***\n"
+      printf "secID : %s\n", @signature
+      printf "size  : %s\n", @size
+      printf "*** ***\n"
+    end
+
+  end
+end

data/lib/mrb_parser/section.rb

@@ -0,0 +1,51 @@
+class MrbParser
+  class Section
+
+    require 'mrb_parser/irep_section'
+    require 'mrb_parser/lineno_section'
+    require 'mrb_parser/debug_section'
+    require 'mrb_parser/end_section'
+
+    BINARY_EOF        = "END\0"
+    IREP_IDENTIFIER   = "IREP"
+    LINENO_IDENTIFIER = "LINE"
+    DEBUG_IDENTIFIER  = "DBG\0"
+
+    attr_reader :signature, :size
+
+    def initialize(signature = nil, size = nil)
+      @signature = signature
+      @size = size
+    end
+
+    def self.parse(parser)
+      section = MrbParser::Section.new
+      section.parse(parser)
+    end
+
+    def parse(parser)
+      signature = parser.read_chars(4)
+      size = parser.read_uint32
+      case signature
+      when IREP_IDENTIFIER
+        section = MrbParser::IrepSection
+      when LINENO_IDENTIFIER
+        section = MrbParser::LinenoSection
+      when DEBUG_IDENTIFIER
+        section = MrbParser::DebugSection
+      when BINARY_EOF
+        section = MrbParser::EndSection
+      else
+        raise MrbParser::Error, "cannot parse; invalid section signature: '#{signature}'"
+      end
+      sec = section.new(signature, size)
+      sec.parse_body(parser)
+      sec
+    end
+
+    def end?
+      false
+    end
+
+  end
+end

data/lib/mrb_parser/utils.rb

@@ -0,0 +1,45 @@
+class MrbParser
+  module Utils
+    def read(n)
+      @data.read(n)
+    end
+
+    def pos
+      @data.pos
+    end
+
+    def seek(n)
+      @data.seek(n)
+    end
+
+    def read_format(pat, n)
+      byteseq = @data.read(n)
+      val = byteseq.unpack(pat)[0]
+      if @verbose
+        p [@data, n, val]
+      end
+      val
+    end
+
+    def read_uint8
+      read_format("C1", 1)
+    end
+
+    def read_uint16
+      read_format("n1", 2)
+    end
+
+    def read_uint32
+      read_format("N1", 4)
+    end
+
+    def read_chars(n)
+      read_format("a#{n}", n)
+    end
+
+    def read_n16string
+      len = read_uint16
+      read_format("a#{len}", len)
+    end
+  end
+end

data/lib/mrb_parser/version.rb

@@ -0,0 +1,3 @@
+class MrbParser
+  VERSION = "0.0.1"
+end

data/lib/mrb_parser.rb

@@ -0,0 +1,44 @@
+require 'mrb_parser/header'
+require 'mrb_parser/section'
+require 'mrb_parser/error'
+require "mrb_parser/version"
+require "mrb_parser/utils"
+
+class MrbParser
+  include MrbParser::Utils
+
+  attr_accessor :verbose
+  attr_accessor :irep_section
+  attr_reader :header, :sections
+
+  def self.parse(filename)
+    parser = MrbParser.new(filename)
+    parser.parse
+  end
+
+  def initialize(filename)
+    @filename = filename
+    @data = nil
+    @irep_section = nil
+    @sections = []
+  end
+
+  def parse
+    @data = File.open(@filename)
+    @header = MrbParser::Header.parse(self)
+
+    while true
+      section = MrbParser::Section.parse(self)
+      @sections << section
+      break if section.end?
+    end
+  end
+
+  def dump
+    @header.dump
+    @sections.each do |section|
+      section.dump
+    end
+  end
+
+end

data/mrb_parser.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mrb_parser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mrb_parser"
+  spec.version       = MrbParser::VERSION
+  spec.authors       = ["yamanekko"]
+  spec.email         = ["yamanekko@tatsu-zine.com"]
+  spec.description   = %q{simple library to parse mrb file, mruby bytecode file.}
+  spec.summary       = %q{mrb (mruby bytecode) parser}
+  spec.homepage      = "https://github.com/yamanekko/mrb_parser"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../lib/mrb_parser'

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: mrb_parser
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- yamanekko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: simple library to parse mrb file, mruby bytecode file.
+email:
+- yamanekko@tatsu-zine.com
+executables:
+- mrb_parser
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/mrb_parser
+- lib/mrb_parser.rb
+- lib/mrb_parser/code_dump.rb
+- lib/mrb_parser/crc.rb
+- lib/mrb_parser/debug_info.rb
+- lib/mrb_parser/debug_info_file.rb
+- lib/mrb_parser/debug_section.rb
+- lib/mrb_parser/end_section.rb
+- lib/mrb_parser/error.rb
+- lib/mrb_parser/header.rb
+- lib/mrb_parser/irep_record.rb
+- lib/mrb_parser/irep_section.rb
+- lib/mrb_parser/lineno_section.rb
+- lib/mrb_parser/section.rb
+- lib/mrb_parser/utils.rb
+- lib/mrb_parser/version.rb
+- mrb_parser.gemspec
+- spec/spec_helper.rb
+homepage: https://github.com/yamanekko/mrb_parser
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0.rc.1
+signing_key: 
+specification_version: 4
+summary: mrb (mruby bytecode) parser
+test_files:
+- spec/spec_helper.rb