[[mrubyを読む]]
 
 #contents
 
 *はじめに [#ha2d1f6f]
 
 スクリプト解析は文字列を解析する関数とファイルを解析する関数がありますが、それらの違いは所詮、入力の違いなのでmrb_parse_string()をスクリプト解析のエントリポイントとして読み進めていきたいと思います。
 
 *mrb_parse_nstring(src/parse.y) [#k3c722a6]
 
 mrb_parse_string()は渡された文字列をstrlenしてmrb_parse_nstring()に渡しているだけなのでmrb_parse_nstring()を見てみましょう。
 
 #code(C){{
 parser_state*
 mrb_parse_nstring(mrb_state *mrb, const char *s, size_t len)
 {
   parser_state *p;
 
   p = mrb_parser_new(mrb);
   if (!p) return 0;
   p->s = s;
   p->send = s + len;
 
   mrb_parser_parse(p);
   return p;
 }
 }}
 
 スクリプト解析で鍵となるのはmrb_parser_state構造体のようです。mrb_parser_stateはinclude/compile.hに書かれています。なお、上記ではparser_stateになっていますが、parser_stateはmrb_parser_stateをtypedefしたものです。
 
 （もうちょい説明を書く）
 
 *解析してみる [#a48d3327]
 
 具体的にスクリプトをNODEに変換してみましょう。対象とするスクリプトは[[Ruby1.9のスクリプト解析>Ruby1.9/スクリプト解析を読む]]で変換してみたものと同じスクリプトを使います((余談ですが、2012/5/29時点でKernel#randが実装されていないため、スクリプトを実行するとNoMethodErrorになります:-P))。
 
  class MonteCarlo
    def pi(n)
      count = 0
      (1..n).each do
        x = rand
        y = rand
        if x * x + y * y <= 1
          count += 1
        end
      end
      (count.to_f / n) * 4
    end
  end
  
  n = 10000 * 10000
  pi = MonteCarlo.new.pi(n)
  puts "pi = #{pi}"
 
 bin/mrubyは--verboseオプションを付けるとNODEツリーがダンプされます((実行コードもダンプされますがそれは次で取り上げます))。上記のスクリプトを食わせると以下のNODEツリーが出力されました。
 
  $ ./mruby.exe -c --verbose ../../montecarlo.rb
  NODE_SCOPE:
    local variables:
      n
      pi
    NODE_BEGIN:
      NODE_CLASS:
        :MonteCarlo
        body:
          NODE_BEGIN:
            NODE_DEF:
              pi
              local variables:
                n
                              count
              mandatory args:
                NODE_ARG n
              NODE_BEGIN:
                NODE_ASGN:
                  lhs:
                    NODE_LVAR count
                  rhs:
                    NODE_INT 0 base 10
                NODE_CALL:
                  NODE_BEGIN:
                    NODE_DOT2:
                      NODE_INT 1 base 10
                      NODE_LVAR n
                  method='each' (170)
                  args:
                  block:
                    NODE_BLOCK:
                      body:
                        NODE_BEGIN:
                          NODE_ASGN:
                            lhs:
                              NODE_LVAR x
                            rhs:
                              NODE_CALL:
                                NODE_SELF
                                method='rand' (330)
                          NODE_ASGN:
                            lhs:
                              NODE_LVAR y
                            rhs:
                              NODE_CALL:
                                NODE_SELF
                                method='rand' (330)
                          NODE_IF:
                            cond:
                              NODE_CALL:
                                NODE_CALL:
                                  NODE_CALL:
                                    NODE_LVAR x
                                    method='*' (80)
                                    args:
                                      NODE_LVAR x
                                  method='+' (76)
                                  args:
                                    NODE_CALL:
                                      NODE_LVAR y
                                      method='*' (80)
                                      args:
                                        NODE_LVAR y
                                method='<=' (300)
                                args:
                                  NODE_INT 1 base 10
                            then:
                              NODE_BEGIN:
                                NODE_OP_ASGN:
                                  lhs:
                                    NODE_LVAR count
                                  op='+' (76)
                                  NODE_INT 1 base 10
                NODE_CALL:
                  NODE_BEGIN:
                    NODE_CALL:
                      NODE_CALL:
                        NODE_LVAR count
                        method='to_f' (109)
                      method='/' (148)
                      args:
                        NODE_LVAR n
                  method='*' (80)
                  args:
                    NODE_INT 4 base 10
      NODE_ASGN:
        lhs:
          NODE_LVAR n
        rhs:
          NODE_CALL:
            NODE_INT 10000 base 10
            method='*' (80)
            args:
              NODE_INT 10000 base 10
      NODE_ASGN:
        lhs:
          NODE_LVAR pi
        rhs:
          NODE_CALL:
            NODE_CALL:
              NODE_CONST MonteCarlo
              method='new' (6)
            method='pi' (326)
            args:
              NODE_LVAR n
      NODE_CALL:
        NODE_SELF
        method='puts' (286)
        args:
          NODE_DSTR
            NODE_STR "pi = " len 5
            NODE_BEGIN:
              NODE_LVAR pi
            NODE_STR "" len 0
 
 それではどういうルールを通ることでこのようなNODEツリーが構築されるのかを追っていくことにします。
 
 （執筆中）
トップ   新規 一覧 単語検索 最終更新   ヘルプ   最終更新のRSS