「parser」の記事 - Crieit

# Racc
func_def : "func" IDENT "(" args ")" "{" stmts "}"
             {
                 _, fn_name, _, args, _, _, stmts, _, = val
                 result = ["func", fn_name, args, stmts]
             }

// Lrama
func_def : TS_KW_FUNC TS_IDENT TS_PAREN_L args TS_PAREN_R TS_SYM stmts TS_SYM
         // "func"    fn_name  "("        args ")"        "{"    stmts "}"
             {
                 NodeList* func_def = NodeList_new();
                 NodeList_add_str(func_def, "func");
                 NodeList_add_str(func_def, $2);
                 NodeList_add_list(func_def, $4);
                 NodeList_add_list(func_def, $7);

                 $$ = func_def;
             }

こんな感じで読み換えていきました。どちらも Yacc から派生した LALRパーサジェネレータなのでよく似ていますね。

メモ

1日くらいでババッと書いたものなので雑だったり手抜きで済ませている部分があります。一応動いてる、という程度の出来です。
- 警告もひとまず放置
Yacc, Bison もそのうち触ってみようと思いつつ結局今まで触らずじまいだった
- 今回ちょっとやってみて雰囲気が知れてよかった
- Rubyソースコード完全解説の第9章速習yacc を読んだらとりあえずなんとかなった
Rubyには慣れているけどCは分からないという状態で LALR パーサジェネレータに入門したい人は、まず Racc で入門するのが良いのではないかと思います。Ruby の知識だけで使えるので、いきなり Yacc や Bison や Lrama に挑戦するよりはお手軽かと。
- Racc の作者（青木峰郎さん）による解説本『Rubyを256倍使うための本無道編』もまだ中古で入手可能（Amazon）

この記事を読んだ人は（ひょっとしたら）こちらも読んでいます

Ruby/Racc: パース時のスタックの動きをFlameGraphっぽくビジュアライズする

Racc の気持ちが分かるように↓こういう図を描かせてみたもの。

Ruby: 入れ子の配列だけをパースできるパーサを作る（手書きの再帰下降パーサ）

メソッドの再帰呼び出しについてすでに知っていれば1時間もかからず書ける内容。比較的簡単で時間がかからないので、LALR パーサにこだわる事情がなければ先に再帰下降パーサで入門するのも良いと思います。

『RubyでつくるRuby』のMinRubyのパーサを書いた（手書きの再帰下降パーサ）

2023-01-22T17:38:20+09:00

これは Ruby Advent Calendar 2022 の25日目の記事です。

書籍 『RubyでつくるRuby ゼロから学びなおすプログラミング言語入門』（以下、 『RubyでつくるRuby』 ）で扱われているミニ言語 MinRuby のパーサを書いてみました。

『RubyでつくるRuby』は、Ruby を使った基本的なプログラミングの入門から始まり、後半ではミニ言語 MinRuby（Ruby のサブセット）のインタプリタを作って最終的に MinRuby言語で MinRuby インタプリタを書くところまでやってしまう、という内容の入門書です。

……と自分なりに内容紹介してみましたが、以下もあわせて参考にしていただければと思います。

書籍『Ruby でつくる Ruby』が発売されます - まめめも
- 著者の遠藤さん
『RubyでつくるRuby』の読み方（私論） - golden-luckyの日記
- ラムダノートの鹿野さん

RubyでつくるRuby ゼロから学びなおすプログラミング言語入門 – 技術書出版と販売のラムダノート

プログラミングを始めるなら、プログラミング言語を自分でつくってみるのがいちばん！最低限の機能なら、こんなに簡単にインタプリタを作れます。よくわからなかったプログラミングも、裏側の仕組みから分かってしまえば怖くない！　

2016年9月から2017年1月にかけてアスキーjpの「プログラミング＋」コーナーで連載された大好評のWebコンテンツ『Rubyで学ぶRuby』を、さらにわかりやすく紙版の書籍として編纂しなおして発売するものです。豊富なイラストもカラーで完全採録。

プログラミング初心者を想定して丁寧に解説してある
分量が多すぎず（144ページ）読み通しやすい
評価器にフォーカスしており、パーサはスコープ外
- パースは minruby gem にまかせる

たしか発売された頃に読んで「せっかくだからパーサも自作したい」と思った記憶があります。当時はパーサの作り方についての知識が足りずどうすればよいか分からなかったのですが、その後あれこれあって簡単なものなら作れるようになりました。

できたもの

https://github.com/sonota88/cookpad-hackarade-minruby/tree/recursive-descent-parser

  $ wc -l rcl_*.rb my_minruby_parser.rb 
   33 rcl_common.rb
   65 rcl_lexer.rb
  496 rcl_parser.rb
   17 my_minruby_parser.rb
  611 合計

一応動いてはいます。advent calendar には間に合った……リファクタリングなどは冬休み以降の宿題にします。

（2023-01-22 追記） interp.rb がパースできるようになりました。

動作例

  $ cat test3-4.rb
n = 1
while n < 100
  if n % 3 == 0
    if n % 5 == 0
      p("FizzBuzz")
    else
      p("Fizz")
    end
  else
    if n % 5 == 0
      p("Buzz")
    else
      p(n)
    end
  end
  n = n + 1
end

  $ ruby my_minruby_parser.rb test3-4.rb
[:stmts, [:var_assign, "n", [:lit, 1]],
 [:while,
  [:<, [:var_ref, "n"], [:lit, 100]],
  [:stmts,
   [:if,
    [:==, [:%, [:var_ref, "n"], [:lit, 3]], [:lit, 0]],
    [:if,
     [:==, [:%, [:var_ref, "n"], [:lit, 5]], [:lit, 0]],
     [:func_call, "p", [:lit, "FizzBuzz"]],
     [:func_call, "p", [:lit, "Fizz"]]],
    [:if,
     [:==, [:%, [:var_ref, "n"], [:lit, 5]], [:lit, 0]],
     [:func_call, "p", [:lit, "Buzz"]],
     [:func_call, "p", [:var_ref, "n"]]]],
   [:var_assign, "n", [:+, [:var_ref, "n"], [:lit, 1]]]]]]

cookpad-hackarade-minruby

まずは先行事例を軽く調べました。

Hackarade #04: Create Your Own Interpreter - クックパッド開発者ブログ

完全セルフホスト：MinRubyでパーサを書き、minruby gemに依存せずにinterp.rb単体でセルフホストするようにした

さすがのクックパッドさん。今回私はここまではやっていません。パーサを MinRuby で書くのもおもしろそう……。

同記事により、 mame/cookpad-hackarade-minruby というリポジトリでテストケースが用意されていることを知りました。ありがたく有効活用させていただきましょう。

mame/cookpad-hackarade-minruby: material for Cookpad's Hackarade #4

今回はこのテストケースを使い、自作パーサと minruby gem に同じ入力を与えて同じ結果になればヨシ！ということにしました。

方針

パーサ入門でよくある再帰下降パーサにしました。

専用のパーサライブラリを使うのに比べるとデメリットもあり本格的な言語実装ではあまり採用されない手法だと思いますが、入門者目線だと「全部自分で書いたぞ感」「全部把握できてる感覚」が得られるという、とても良い良さがあります。

（ちなみに、Rust製 Ruby 実装 ruruby のパーサは手書きだそうです。すごい……。）

ここで選択肢が2つあり、

(1) 何もないところから全部書く
(2) Ruccola のパーサを改造する

ちょっとだけ (1) を試した後、時間（というか計画性）がないこともあって (2) に切り替えました。
さて、Ruccola というのがスッと出てきましたね。これはなんでしょうか。

Ruccola とは

Ruccola は私が自分の勉強のために作っている素朴な自作プログラミング言語です。

https://github.com/sonota88/ruccola

最新の知見を盛り込んだキラリと光る言語……とかでは全然なく、現代の水準からするとかなり原始的なものです。自分の勉強用・入門用なので素朴でよいと割り切っています。

2021年にセルフホストできた（詳しくは↓の記事を参照）後も趣味の盆栽プログラミング的にちびちびと機能追加やリファクタリングを続けています。

素朴な自作言語Ruccolaのコンパイラをセルフホストした - Qiita

コンパイラを Ruby で書いている
Ruccola言語のコードの見た目は Ruby っぽい
なんとなくC言語っぽいものをイメージして作ったが、現時点では型がない（整数しかない）ので B言語や BCPL の方が近いのかも（詳しくないのでボンヤリした書き方）

ざっくり書くとこんな感じです。このうち「見た目は Ruby っぽい」というのがポイントで、Ruccola のパーサ（ 202-12-25 時点のソース）にいくつか手を加えれば MinRuby のパーサとして使えそうでした。

コード例です。以下は Ruccola言語で書いた cat コマンド。

def main()
  var EOF = -1;
  var c;

  while (true)
    c = getchar();
    if (c == EOF)
      break;
    end

    write(c, 1);
  end
end

だいたい Ruby ですね。中身は原始的なのに見た目は Ruby 風なので、書いているとちょっと不思議な気分になります。

作者の目にはだいたい Ruby と同じに見えますが、Ruby に慣れている方には次のような点が目に付くのではないでしょうか。

文末の ; （必須）
while の条件式を囲む ( ) （必須）
変数宣言の var（必須）

他にも関数呼び出しの ( )、関数定義の仮引数を囲む ( )、エントリポイントとなる main 関数も必須です。

自分が言語実装ビギナーなので、難しいことをしなくていいように Ruby の文法にいろいろ制限を加えてこうなっています。Ruby と完全にコンパチではありませんが、構文ハイライトやエディタのインデント支援は Ruby 向けのものがだいたいそのまま使えています。

ちなみに、Ruccola よりももっとコンパクトな mini-ruccola（元は vm2gol-v2 という名前だった）もあります。VM〜コンパイラを割と素朴に書いて1500行以下というもの。自分が欲しい（難しすぎず、簡単すぎず、読み書きに慣れている言語向けの）教材が見つけられず、じゃあ自分で作ってしまえとなって作ったもの。

https://github.com/sonota88/vm2gol-v2

以前週刊Railsウォッチで紹介していただきました。

週刊Railsウォッチ（20210209後編）Rubyでミニ言語処理系を作る、Kernel#getsの意外な機能、CSSのcontent-visibilityほか｜TechRacho by BPS株式会社

作った順番としては mini-ruccola の方が先で、最初にこっちで簡単なコンパイラ実装になんとか入門し、その後セルフホストに必要な機能を追加していく形で Ruccola を作っていきました。

主な変更点

演算子の優先順位

Ruccola では自分でも手に負えるようにいろいろと単純化しています。演算子の優先順位もそのひとつで、たとえば 1 + 2 * 3 という式は (1 + 2) * 3 として扱われます（単純に左結合とする）。

えっそれでいいの？と思いましたか？思いますよね。

言語処理系の解説を見ると必ずといっていいほど演算子の優先順位の話題が出てきて、自作言語を作るには避けて通れないトピックであるかのように思われます。私もある時までそう思い込んでいたのですが、実はそんなことはありません……と思うんですよね（微妙な自信のなさ）。

Ruccola では 1 + (2 * 3) と解釈させたい場合は明示的に括弧で優先順位を指定して 1 + (2 * 3) と書けばよい、ということにしています。たまに自分でも忘れていて素でびっくりします。まあ自分の勉強用の言語だからいいんですよこれで。最初から実装しなくてもよいので後回しにしています。Ruccola言語の記述力がまだ低いため、今入れてもコード量が膨れるデメリット（セルフホストしているのでばかにならず、下手に機能追加すると自分が困る）の方が大きそうで嫌かなという考えもあり。

ちなみに、似たような方針を採っている言語として VTL (Very Tiny Language) という言語があると後から知りました。仲間がいた……。

VTLでは，演算子の間に優先順位は存在せず，左から順番に演算が行われます．演算の順序を変えたい場合は括弧"()"をつけます．例えば，"2+3*4"の結果は"20"となり，"2+(3*4)"の結果は"14"となります．

あ、ていうか優先順位を明示する言語といえば Lisp があるじゃないか、とこの記事を書いていて今思い至りました。Lisp、心強いですね。

さて、Ruccola ではそれでいいとして、演算子の優先順位に対応しないと cookpad-hackarade-minruby のテストが通りません。なんとかしなければ。

これについては自分にとって今回初めてという訳ではなく、以前単体で履修していたのでした。

四則演算と剰余のみのexprコマンドをRubyで作ってみた

これを組み込めばいけるはず。

test1-4.rb と test1-5.rb の間の飛躍が大きかったので小さなテストを追加しながら進めました。

まずは一番優先順位の低い 1 == 2 から
二番目に優先順位の低い < を右側に加えた 1 == 2 < 3
...
1 == 2 < 3 + 4 * 5 が (1 == (2 < (3 + (4 * 5)))) と解釈できればOK
ここまでできたら test1-5.rb が通る

という流れで進めることで意外とすんなり書き換え完了しました。

参考: 演算子式 (Ruby 3.1 リファレンスマニュアル)

優先順位まわりについては書籍『Rubyで作る奇妙なプログラミング言語』もおすすめです。私はこの本の写経で入門しました。

if と case

Ruccola では if 文は case 文のシンタックスシュガーという扱いになっています。「case文が動けば if文はそのサブセット扱いにできるよね」という、大は小を兼ねる的な素朴な発想によるものです。あと Ruccola の前身の mini-ruccola は最初はパーサがなくて構文木を手書きするところからスタートしたため、その都合もあります。

MinRuby では逆になっていて、 case 式は内部的に入れ子の if 式としてパースされます（『RubyでつくるRuby』 p85）。ここは今回『RubyでつくるRuby』を読み返してなるほどと思ったところでした。

改行の扱い

Ruccola では現時点では if文の条件式全体を囲む括弧は省略不可です（case文、while文も同様）。また、代入や関数呼び出しなどの文の末尾にはセミコロンが必須です。改行はスペースと同じように字句解析の段階で捨てています。

if (i == 10)
  p(1);
end

一方 MinRuby では条件式を囲む括弧や関数呼び出しなどの末尾のセミコロンは省略可能です。改行の考慮が必要そう。

if i == 10
  p(1)
end

改行を考慮したパースはこれまで経験がなく不確実な部分でしたが、結論からいえば特別な対応は不要で、適当に改行を読み飛ばすだけで cookpad-hackarade-minruby のテストは通りました（というか試しにやってみたら字句解析の段階で全部捨てても大丈夫だった）。

今の実装では、式とみなせるまとまりの次に二項演算子が来たら「まだ式の続きがあるな」と判断し、そうでなければ「いったんそこで式が終わっているな」と判断する、という動作になっています。
たとえば上のコード例だと i == 10 の次に p というトークンが来ています。これは二項演算子ではありませんから、ここで式の区切りと判断され、i == 10 と p 以降は別のまとまりだということになります。

i == 10 + ...
        ^ 二項演算子なのでまだ式が続いていると判断

i == 10 p ...
        ^ 二項演算子ではないので p からは別のまとまり

あくまで cookpad-hackarade-minruby のテストのカバー範囲と今回作ったパーサの実装の組み合わせでは問題なかったというだけで、Ruby に近づけていこうとするとどこかでちゃんとした対応が必要になってくるでしょうね。

配列・ハッシュ

Ruccola では配列リテラルや配列の要素にアクセスするための専用の構文は（まだ）ありません。ハッシュはサポート予定なし。

なので配列・ハッシュまわりは新たに書きました。ここはすんなり書けてしまって特に書くことがありません。

TODO

if, case まわりがいいかげんなのでもうちょいちゃんとやる
interp.rb をパースできるようにする（ここまではやりたい）

（2023-01-22 追記）上記2つ完了しました。「これで完璧！」というものではありませんが、とりあえず interp.rb はパースできています。

おわりに

以上のように自作言語 Ruccola のパーサにいくつかの変更を加えることで MinRuby のパーサを作ることができました（ただし cookpad-hackarade-minruby のテストを通すところまで）。

以前から MinRuby のパーサ作れないかなーとボンヤリ考えていたのでこの機会に実現できてよかったです。

以下、おまけ的な雑多な話題・メモなどです。

おまけ

再帰下降パーサについて

再帰下降パーサについては書籍やウェブに解説がたくさんありますので「再帰下降パーサ」「再帰下降構文解析」などで調べてください。英語だと recursive descent parser です。

今回作ったものはパーサだけで 500行くらいありますし、再帰下降パーサの一番最初の入門用としてはちょっと大きいかもしれません。そういう場合は分解してちょっとずつ手を付けるのがおすすめです。

くりかえしの構造
- 関数定義の仮引数、関数呼び出し時の引数、演算子を含む式、配列リテラル、ハッシュリテラルなど、いろんなところで登場する
- 数 のあとに , 数 をくりかえし
- 例: 1, 2, 3
- 数 のあとに 演算子数 のくりかえし
- 例: 1 + 2 + 3
[[]], [[[]]] のような入れ子の構造
演算子の優先順位

上の方でも書いたように、演算子の優先順位は後回しにできますから、先にそれ以外の部分を作ってから後付けで追加するのもよいと思います。

「MinRuby のパーサを書いてみたいけどいきなり全部書くのは無理そう……また今度にしよう」と思った方は、まず次のような簡単なものから手を付けてみるのはどうでしょう。どちらも50行くらいです。

入れ子の配列だけをパースできるパーサを作る（手書きの再帰下降パーサ）
- ((), (())) のような入れ子の括弧だけをパースできるパーサ。コード例があった方がよさそうと思って簡単なものを昨日急いで書きました。
- n年前の自分に「これで入門しろ」「最初はこれでいいと思うよ」といって送りつけるとしたらこれ
正規表現エンジン（ロブ・パイクのバックトラック実装）をRubyで写経した
- バックトラック方式の正規表現エンジンもおすすめです。こっちも手軽。手軽だけどおもしろい。再帰下降パーサに考え方が似ています。

MinRuby 関連

今回調べていて見つけたもの。

https://speakerdeck.com/m_seki/extend-your-own-programming-language-rubykaigi-2018

MinRuby に末尾呼び出し最適化を実装する話や Rinda + MinRuby の話。

https://matsubara0507.github.io/posts/2019-05-16-minruby-with-patternmatch.html

パーサは「木を組み立てる」処理がメインなのでパターンマッチの出番はそんなにありませんが、評価器は「木を使う」処理がメインなのでパターンマッチを使うといい感じに書けますね。

mal (Make a Lisp)

https://github.com/kanaka/mal

Lisp に興味のある方には mal（Make a Lisp）もおすすめです。ちょうど『RubyでつくるRuby』の Lisp 版といった感じで、簡単な Lisp インタプリタを作ってセルフホストするまでが11ステップに分かれており、テストを通しながら作っていきます。入門者向けのシンプルな実装ですが、マクロや例外機構、末尾呼び出しの最適化まで含まれています。すでに Ruby 版の実装（主な部分は500行程度）もリポジトリに含まれていますから、そのまま写経してもいいですし、自力で書いて詰まったときに参考にすることもできます。

ちなみに私は一度 Ruby で写経した後 LibreOffice Basic で書くということをやりました。

LibreOffice BasicでLispインタプリタ（mal）を書いた - Qiita

PicoRuby

入門者向けに作られているものではありませんが、Ruby 関連の小さめの処理系というと PicoRuby がありますね。

https://github.com/picoruby

https://github.com/picoruby/mruby-pico-compiler

この記事の前日（2022-12-24）に開発者募集されていました。

【お誘い】PicoRubyの開発者を募集しています · picoruby/picoruby Wiki

Ruby よりは小さくて難しくなさそう？？読めそうだったら参考のためにソース読んでみようかな……と思いつつまだ何もできていません。

Lemon というパーサジェネレータを使ってるんですね。Lemon 知らなかった。SQLite が使っているものだそうです。

雑多

mini-ruccola のパーサを Racc と Parslet を使って書いたもの。

自作言語のコンパイラにオレオレアセンブリではなくx86_64アセンブリを生成させる（関数呼び出しと足し算だけ） - Qiita

コンパイラ作ったらやはりこれもやっておきたい、ということで（ちょっとだけ）やったみたもの。RISC-V 版や WebAssembly 版もやってみたい。

Ruby＋DXOpalでリレー式論理回路シミュレータを自作して1bit CPUまで動かした - Qiita

言語処理系をやるとさらに下のレイヤーも気になってきますよね？ということでついでに紹介。これも楽しかったです。Ruby（と DXOpal）で作れます！

今年 Ruby 関連で書いたもの

せっかくのアドベントカレンダーなので今年書いたものも並べてみます。

Parsletでかんたんな自作言語のパーサを書いた

2021-11-06T07:02:42+09:00

＜自作言語処理系の説明用テンプレ＞

自分がコンパイラ実装に入門するために作った素朴なトイ言語とその処理系です。簡単に概要を書くと下記のような感じ。

リポジトリ: github.com/sonota88/vm2gol-v2
小規模: コンパイラ部分は 1,000 行程度
pure Ruby / 標準ライブラリ以外への依存なし
独自VM向けにコンパイルする
ライフゲームのために必要な機能だけ
- 変数宣言、代入、反復、条件分岐、関数呼び出し
- 演算子: +, *, ==, != のみ（優先順位なし）
- 型なし（値は整数のみ）
作ったときに書いた備忘記事
- RubyでオレオレVMとアセンブラとコード生成器を2週間で作ってライフゲームを動かした話
- Rubyでかんたんな自作言語のコンパイラを作った
Ruby 以外の言語への移植（コンパイラ部分のみ）
セルフホスト版（別リポジトリ）

＜説明用テンプレおわり＞

もともとパーサ部分は手書きの再帰下降パーサでしたが、PEGベースのパーサライブラリ Parslet 版を作ってみました。

できたもの

vgparser_parslet.rb を追加したブランチです。

https://github.com/sonota88/vm2gol-v2/tree/alt_parser_parslet

ここでは雰囲気程度ということで Parser クラスのみ貼ります。全体は GitHub の方で見てください。transform なども合わせると全体は 340 行くらいです。

Parslet を使うのは今回初めてで、まだ慣れてなくて、こなれていない感じがします。もっといい書き方ができそう。

class Parser < Parslet::Parser
  rule(:comment) {
    str("//") >>
    (str("\n").absent? >> any).repeat >>
    str("\n")
  }

  rule(:spaces) {
    (
      match('[ \n]') | comment
    ).repeat(1)
  }
  rule(:spaces?) { spaces.maybe }

  rule(:lparen   ) { str("(") >> spaces? }
  rule(:rparen   ) { str(")") >> spaces? }
  rule(:lbrace   ) { str("{") >> spaces? }
  rule(:rbrace   ) { str("}") >> spaces? }
  rule(:comma    ) { str(",") >> spaces? }
  rule(:semicolon) { str(";") >> spaces? }
  rule(:equal    ) { str("=") >> spaces? }

  rule(:ident) {
    (
      match('[_a-z]') >> match('[_a-z0-9]').repeat
    ).as(:ident_) >> spaces?
  }

  rule(:int) {
    (
      str("-").maybe >>
      (
        (match('[1-9]') >> match('[0-9]').repeat) |
        str("0")
      )
    ).as(:int_) >> spaces?
  }

  rule(:string) {
    str('"') >>
    ((str('"').absent? >> any).repeat).as(:string_) >>
    str('"') >> spaces?
  }

  rule(:arg) { ident | int }
  rule(:args) {
    (
      (
        arg.as(:arg_) >>
        (comma >> arg.as(:arg_)).repeat
      ).maybe
    ).as(:args_)
  }

  rule(:factor) {
    (
      lparen >> expr.as(:factor_expr_) >> rparen
    ).as(:factor_) |
    int |
    ident
  }

  rule(:binop) {
    (
      str("+") | str("*") | str("==") | str("!=")
    ).as(:binop_) >> spaces?
  }

  rule(:expr) {
    (
      factor.as(:lhs_) >>
      (binop.as(:binop_) >> factor.as(:rhs_)).repeat(1)
    ).as(:expr_) |
    factor
  }

  rule(:stmt_return) {
    (
      str("return") >>
      (spaces >> expr.as(:return_expr_)).maybe >>
      semicolon
    ).as(:stmt_return_)
  }

  rule(:stmt_var) {
    (
      str("var") >> spaces >> ident.as(:var_name_) >>
      (equal >> expr.as(:expr_)).maybe >>
      semicolon
    ).as(:stmt_var_)
  }

  rule(:stmt_set) {
    (
      str("set") >> spaces >>
      ident.as(:var_name_) >> equal >> expr.as(:expr_) >>
      semicolon
    ).as(:stmt_set_)
  }

  rule(:funcall) {
    (
      ident.as(:fn_name_) >>
      lparen >> args.as(:args_) >> rparen
    ).as(:funcall_)
  }

  rule(:stmt_call) {
    (
      str("call") >> spaces >>
      funcall >>
      semicolon
    ).as(:stmt_call_)
  }

  rule(:stmt_call_set) {
    (
      str("call_set") >> spaces >>
      ident.as(:var_name_) >> equal >> funcall.as(:funcall_) >>
      semicolon
    ).as(:stmt_call_set_)
  }

  rule(:stmt_while) {
    (
      str("while") >> spaces? >>
      lparen >> expr.as(:expr_) >> rparen >>
      lbrace >> stmts.as(:stmts_) >> rbrace
    ).as(:stmt_while_)
  }

  rule(:when_clause) {
    (
      str("when") >> spaces? >>
      lparen >> expr.as(:expr_) >> rparen >>
      lbrace >> stmts.as(:stmts_) >> rbrace
    ).as(:when_clause_)
  }

  rule(:stmt_case) {
    (
      str("case") >> spaces >>
      when_clause.repeat.as(:when_clauses_)
    ).as(:stmt_case_)
  }

  rule(:stmt_vm_comment) {
    (
      str("_cmt") >>
      lparen >> string.as(:cmt_) >> rparen >>
      semicolon
    ).as(:stmt_vm_comment_)
  }

  rule(:stmt_debug) {
    (
      str("_debug") >> lparen >> rparen >> semicolon
    ).as(:stmt_debug_)
  }

  rule(:stmt) {
    stmt_return     |
    stmt_var        |
    stmt_set        |
    stmt_call       |
    stmt_call_set   |
    stmt_while      |
    stmt_case       |
    stmt_vm_comment |
    stmt_debug
  }

  rule(:stmts) {
    (stmt.repeat).as(:stmts_)
  }

  rule(:func_def) {
    (
      str("func") >> spaces >>
      ident.as(:fn_name_) >>
      lparen >> args.as(:fn_args_) >> rparen >>
      lbrace >> stmts.as(:fn_stmts_) >> rbrace
    ).as(:func_def_)
  }

  rule(:top_stmt) {
    func_def.as(:top_stmt_)
  }

  rule(:program) {
    spaces? >> (top_stmt.repeat).as(:top_stmts_)
  }

  root(:program)
end

メモ

PEGベースのパーサを使ったことがなかったので、今回触ってみて雰囲気が知れてよかった
[ruby] Parsletで構文解析する[その1] - Qiita 〜その3 までを読むと基本的な使い方はほぼ分かる。ありがとうございます :pray:
他には github.com/kschiess/parslet の example/ に入っているサンプルを見て参考にしたり
- json.rb や string_parser.rb など
もう少し大きめのサンプルとして thnad を参考にしたり

「○○以外の文字の連続」

今回書いたものでいえば、コメント（改行以外の文字の連続）や文字列（" 以外の文字の連続）の部分。

match で正規表現が使えるので最初はこのように書いていました:

match('[^\n]').repeat

これでも動きます。ただ、公式のサンプルを見ると absent? と any を組み合わせていたので、それに倣って次のように書きました。こういうのは知らないと何をやってるのかわかりにくいかも。

(str("\n").absent? >> any).repeat

この記事を読んだ人はこちらの記事も読んでいます（たぶん）

Raccでかんたんな自作言語のパーサを書いた

Raccでかんたんな自作言語のパーサを書いた

2021-11-03T08:04:56+09:00

＜自作言語処理系の説明用テンプレ＞

自分がコンパイラ実装に入門するために作った素朴なトイ言語とその処理系です。簡単に概要を書くと下記のような感じ。

小規模: コンパイラ部分は 1,000 行程度
pure Ruby / 標準ライブラリ以外への依存なし
独自VM向けにコンパイルする
ライフゲームのために必要な機能だけ
- 変数宣言、代入、反復、条件分岐、関数呼び出し
- 演算子: +, *, ==, != のみ（優先順位なし）
- 型なし（値は整数のみ）
Ruby 以外の言語への移植（コンパイラ部分のみ）
セルフホスト版（別リポジトリ）

下記も参照してください。

＜説明用テンプレおわり＞

もともとパーサ部分は手書きの再帰下降パーサでしたが、Racc 版を作ってみました。

Racc で四則演算のパーサを作る方法は分かったがもう少しプログラム言語らしきものを扱っているサンプルを見たいとか、パースしたそばから実行する方式（インタプリタ方式）ではなく構文木が欲しいんだけど、という感じの人には参考になるかもしれません（昔の自分に送ってあげたい）。

できたもの

vgparser_racc.y を追加したブランチです。

github.com/sonota88/vm2gol-v2/tree/alt_parser_racc

300行弱なので全部貼ってもいいのですが、雰囲気程度ということで途中を省略したものを貼ります。全体は GitHub の方で見てください。

class Parser

  prechigh
    left "+" "*"
  preclow

rule

  program:
    top_stmts
      {
        top_stmts = val[0]
        result = ["top_stmts", *top_stmts]
      }

  top_stmts:
    top_stmt
      {
        top_stmt = val[0]
        result = [top_stmt]
      }
  | top_stmts top_stmt
      {
        top_stmts, top_stmt = val
        result = [*top_stmts, top_stmt]
      }

  top_stmt:
    func_def

  func_def:
    "func" IDENT "(" args ")" "{" stmts "}"
      {
        _, fn_name, _, args, _, _, stmts, _, = val
        result = ["func", fn_name, args, stmts]
      }

  args:
    # nothing
      {
        result = []
      }
  | arg
      {
        arg = val[0]
        result = [arg]
      }
  | args "," arg
      {
        args, _, arg = val
        result = [*args, arg]
      }

  arg:
    IDENT | INT

  stmts:
    # nothing
      {
        result = []
      }
  | stmt
      {
        stmt = val[0]
        result = [stmt]
      }
  | stmts stmt
      {
        stmts, stmt = val
        result = [*stmts, stmt]
      }

  stmt:
    stmt_var
  | stmt_set
  | stmt_return
  | stmt_call
  | stmt_call_set
  | stmt_while
  | stmt_case
  | stmt_vm_comment
  | stmt_debug

  stmt_var:
    "var" IDENT ";"
      {
        _, ident, _ = val
        result = ["var", ident]
      }
  | "var" IDENT "=" expr ";"
      {
        _, ident, _, expr = val
        result = ["var", ident, expr]
      }

# ... 途中省略 ...

---- header

require "json"
require_relative "common"

---- inner

def next_token
  @tokens.shift
end

def to_token(line)
  token = Token.from_line(line)
  return nil if token.nil?

  if token.kind == :int
    Token.new(token.kind, token.value.to_i)
  else
    token
  end
end

def read_tokens(src)
  tokens = []

  src.each_line do |line|
    token = to_token(line)
    next if token.nil?

    tokens << token
  end

  tokens
end

def to_racc_token(token)
  kind =
    case token.kind
    when :ident then :IDENT
    when :int   then :INT
    when :str   then :STR
    else
      token.value
    end

  [kind, token.value]
end

def parse(src)
  tokens = read_tokens(src)
  @tokens = tokens.map { |token| to_racc_token(token) }
  @tokens << [false, false]

  do_parse()
end

---- footer

if $0 == __FILE__
  ast = Parser.new.parse(ARGF.read)
  puts JSON.pretty_generate(ast)
end

実行の例

入力とするプログラムの例です。

// sample.vg.txt
func main() {
  return 1 + (2 * 3);
}

次のように実行するとASTに変換できます。

## vgparser_racc.rb を生成
$ bundle exec racc -t -o vgparser_racc.rb vgparser_racc.y

$ ruby vglexer.rb sample.vg.txt > tmp/tokens.txt
$ ruby vgparser_racc.rb tmp/tokens.txt 
[
  "top_stmts",
  [
    "func",
    "main",
    [

    ],
    [
      [
        "return",
        [
          "+",
          1,
          [
            "*",
            2,
            3
          ]
        ]
      ]
    ]
  ]
]

スタックの動きを見てみる

せっかく Racc を使っているので、適当なサンプルコード（下記）をパースさせてスタックの動きを図にしてみました。

func add(a, b) {
  var c = a + b;
  return c;
}

func main() {
  var x = -1;
  var i = 0;

  while (i != 10) {
    case when (i == 1) {
      call_set x = add(i, x);
    } when (i == 2) {
      set x = 1 + 2;
    } when (1) {
      set x = 1 + (2 * 3);
    }

    set i = i + 1;
  }
}

図の描き方については Ruby/Racc: パース時のスタックの動きをFlameGraphっぽくビジュアライズするを参照。

左端の、全体の 1/5 くらいの小さめの山が add 関数で、残りが main 関数ですね。

メモ

レキサはすでにあるのでそれを流用した
- to_racc_token メソッドで Token オブジェクトを Racc が期待する形式に変換
1時間くらいで書けた。これより大きめの SQL パーサを少し前にすでに書いていてある程度慣れていたのと、パーサのテストがそのまま使えたのが良かった。

この記事を読んだ人はこちらの記事も読んでいます（たぶん）

Parsletでかんたんな自作言語のパーサを書いた

Rubyでかんたんな自作言語のコンパイラを作った

2021-06-14T06:43:44+09:00

※ Qiitaに書いた記事のクロス投稿です。

RubyでオレオレVMとアセンブラとコード生成器を2週間で作ってライフゲームを動かした話の続きです。このときスコープ外にしていたフロントエンド部分（高水準言語から構文木への変換部分）をやっと書きました。3日くらいでできたのでさっさとやっておけばよかった。

パーサまで揃っていなかったため仕方なく「コード生成器を作った」という表現にしていましたが、ここまでやったら「コンパイラを作った」と言っていいはず！

※ ブログに書いていたものを引っ越してきました。元の記事公開日は 2020-05-04 です。

パーサ
- https://github.com/sonota88/vm2gol-v2/blob/41/vgparser.rb
ライフゲームのコード
- https://github.com/sonota88/vm2gol-v2/blob/41/gol.vg.txt

※ 2020-05-04 時点のものです。その後の改良も加わったものが見たい場合は mainブランチを見てください。
※ パーサ以外の部分をどうやって作ったか知りたい方はこちらをどうぞ
※ 他の言語にも移植していますので Ruby わからんという方はこちらもどうぞ（2021-06-15 現在での移植先: TypeScript, Python, Dart, Java, C, Perl, C♭, PHP, Go, LibreOffice Basic, Zig, Kotlin, Pric, Crystal, Rust, Julia, Pascal）

ふつうの手書き再帰下降パーサ
- 400行ちょっと
難しいことはしない
- 再帰下降パーサを実際に書くのは今回が初めてなので
- まずはハードルを下げて「とにかく動く」ところまで持って行く
  - 下げ過ぎた気がしなくもない
- 構文木を割とそのままマッピングしていて、気の利いた変換とかはやってない
- 式の優先順位は考慮しない
  - 明示的に括弧を書く
  - 気が向いたら後でやる
ベタな文法でよい / 高度な機能や独自色をなるべく入れないようにしたい
- 初心者向け教材っぽくしておきたい気持ち
汎用ではない
- ライフゲームだけコンパイルできればよい
エラーハンドリングは適当
- ライフゲームだけコンパイルできればよい
ふつうの文法でふつうの再帰下降パーサなので、あまり書くことがないです……

文法サンプル

見ての通り、特にひねりのない感じです。パッと見では JavaScript に近いでしょうか。

set, call, call_set は明示的に書きます。

// コメント

// 関数定義
func add(a, b) {
  // return（返り値は省略可）
  return a + b;
}

// main 関数は必須
func main() {
  // ローカル変数宣言
  var a;

  // ローカル変数宣言＋初期化
  var b = 1;

  // ローカル変数への代入
  set a = 2;

  // 関数呼び出し
  call add(1, 2);

  // 関数呼び出して返り値をローカル変数に代入
  call_set c = add(1, 2);

  // while
  while (a != 10) {
    // ...
  }

  // case
  case {
    (a == 1) {
      // ...
    }
    (a == 2) {
      // ... 
    }
    (0 == 0) { // else の代わり
      // ... 
    }
  }

  // VMコメント
  _cmt("...");
}

コンパイルからVMでの実行までの流れ

足し算をする関数を呼び出して結果を受け取るだけのサンプルで高水準言語から機械語までの変換の流れを具体的に見てみます。

高水準言語:

func add(a, b) {
  var result = a + b;
  return result;
}

func main() {
  var result;
  call_set result = add(1, 2);
}

↓ ruby vgparser.rb add.vg.txt > add.vgt.json で AST に変換（実際の出力は改行が多くて冗長なので下記は手動で整形しています）

[
  "stmts",
  [
    "func", "add", ["a", "b"],
    [
      ["var", "result", ["+", "a", "b"]],
      ["return", "result"]
    ]
  ],
  [
    "func", "main", [],
    [
      ["var", "result"],
      ["call_set", "result", ["add", 1, 2]]
    ]
  ]
]

↓ ruby vgcg.rb add.vgt.json > add.vga.txt でアセンブリコードに変換

  call main
  exit

label add
  push bp
  cp sp bp

  # 関数の処理本体
  sub_sp 1
  push [bp+2]
  push [bp+3]
  pop reg_b
  pop reg_a
  add_ab
  cp reg_a [bp-1]
  cp [bp-1] reg_a

  cp bp sp
  pop bp
  ret

label main
  push bp
  cp sp bp

  # 関数の処理本体
  sub_sp 1
  push 2
  push 1
  _cmt call_setadd
  call add
  add_sp 2
  cp reg_a [bp-1]

  cp bp sp
  pop bp
  ret

↓ ruby vgasm.rb add.vga.txt > add.vge.yaml で機械語コードに変換

---
- call
- 35
- exit
- label
- add
- push
- bp
- cp
- sp
- bp
- sub_sp
- 1
- push
- "[bp+2]"
- push
- "[bp+3]"
- pop
- reg_b
- pop
- reg_a
- add_ab
- cp
- reg_a
- "[bp-1]"
- cp
- "[bp-1]"
- reg_a
- cp
- bp
- sp
- pop
- bp
- ret
- label
- main
- push
- bp
- cp
- sp
- bp
- sub_sp
- 1
- push
- 2
- push
- 1
- _cmt
- call_setadd
- call
- 5
- add_sp
- 2
- cp
- reg_a
- "[bp-1]"
- cp
- bp
- sp
- pop
- bp
- ret

（2021-01-11 追記）
この機械語コードのフォーマットは1命令1行となるようにその後変更しました: vm2gol v2 （51）機械語コードのフォーマットを固定長風に変更
（追記ここまで）

あとは STEP= ruby vgvm.rb add.vge.yaml とすると VM で1命令ずつステップ実行できます。

また、これまでと同様に run.sh を使って ./run.sh gol.vg.txt のように実行すると
パース → コード生成 → アセンブル → VMで実行
がまとめて実行できます。

2020-06-25 追記

節目っぽいのでこの時点での行数を数えてみました。空行やコメントだけの行も含めた単純な行数です。

   14 common.rb
   63 vgasm.rb
  474 vgcg.rb
  433 vgparser.rb
  491 vgvm.rb
 1475 合計

思ったより少ない。2,000行超えてるかなと思ってましたが。

gol.vg.txt と、コンパイル・アセンブルで生成される AST・アセンブリコード・機械語コードも行数を見てみます。

  208 gol.vg.txt
  874 tmp/gol.vgt.json
  693 tmp/gol.vga.txt
 1299 tmp/gol.vge.yaml

フーン、という感じですね（気の利いた感想が出てこなかった）。

その後の変更

けっこういいかげんなところがあるので後から修正しています。

vm2gol v2 （47）引数のパースの厳密化など

（2021-02-21 追記）いくつか機能を足してセルフホストできるようになりました。

https://github.com/sonota88/pric

参考

Parserに関するsonota88のブックマーク - はてなブックマーク

Ruby/Racc: パース時のスタックの動きをFlameGraphっぽくビジュアライズする

2021-01-10T08:38:01+09:00

（少し前に同じ記事を投稿していましたが、すぐに次の記事を投稿するとモバイル版では一覧で（折りたたまれて）見えなくなるようだったので一度引っ込めて投稿し直しました。まだ Crieit に慣れてないのでご容赦くださいませ……）

（↓これは FlameGraph に描かせたもの）

こういう図を描いてみました。

手順

準備

説明用の簡単なサンプルです。1 + 2 のような入力を受理するパーサ。

ログ出力のために @yydebug, @racc_debug_out を設定しておきます。

# sample_add.y

class Parser

rule
  expr: INT "+" INT
  {
    puts "expression found"
    result = val
  }
end

---- inner

def initialize
  # parser.rb を使ったときにデバッグ情報を出力する
  @yydebug = true
  # デバッグ情報の出力先をファイルに変更（デフォルトでは標準エラー出力） …… これは必須ではない
  @racc_debug_out = File.open("debug.log", "wb")
end

def next_token
  @tokens.shift
end

def parse(src)
  @tokens = src.split(" ").map do |s|
    case s
    when /^\d+$/ then [:INT, s.to_i]
    else              [s, s]
    end
  end
  @tokens << [false, false]

  do_parse
end

---- footer

src = ARGV[0]
result = Parser.new().parse(src)
puts "result: " + result.inspect

-t (--debug) オプションを付けて racc コマンドを実行。

# パーサを生成
racc -t -o parser.rb sample_add.y

生成されたパーサを実行すると次のような内容が debug.log に出力されます。

$ ruby parser.rb "1 + 2"
expression found
result: [1, "+", 2]

$ head -30 debug.log  
read    :INT(INT) 1

shift   INT
        [ (INT 1) ]

goto    2
        [ 0 2 ]

read    "+"("+") "+"

shift   "+"
        [ (INT 1) ("+" "+") ]

goto    4
        [ 0 2 4 ]

read    :INT(INT) 2

shift   INT
        [ (INT 1) ("+" "+") (INT 2) ]

goto    6
        [ 0 2 4 6 ]

reduce  INT "+" INT --> expr
        [ (expr [1, "+", 2]) ]

goto    1
        [ 0 1 ]

スタックの部分だけ欲しいので、 grep してみましょうか。

$ grep '\[ (' debug.log 
        [ (INT 1) ]
        [ (INT 1) ("+" "+") ]
        [ (INT 1) ("+" "+") (INT 2) ]
        [ (expr [1, "+", 2]) ]
        [ (expr [1, "+", 2]) ($end false) ]
        [ (expr [1, "+", 2]) ($end false) ($end false) ]

軽く眺める程度ならこれだけでいいかもしれませんね。で、もっと複雑になったときにきれいに表示して見たい……ということで次へ。

パースしやすいログを出力する

ログに出力されたスタックの情報を使いたいのですが、そのままではパースしづらそうです。まじめにやろうとすると、これ用のパーサが必要になってしまいます（上の例のような簡単なものであればそんなに難しくなさそうですが）。

そこで、横着して最初からパースしやすいフォーマットで出力することにしました。

スタックの情報をどこで出力しているか調べると、ここ（Racc::Parser#racc_print_stacks）です。
https://github.com/ruby/racc/blob/v1.5.2/lib/racc/parser.rb#L604-L611
嬉しいことに単独のメソッドになっています。

※ ちなみに呼び出し元を追っていくと分かりますが、スタックの実体は
Racc::Parser#racc_tstack
Racc::Parser#racc_vstack
です（それぞれ記号と値のスタック）。

racc コマンドの出力は Racc::Parser を継承したクラスになるので、parser.y の inner セクションに racc_print_stacks メソッドを書いておくと動作をオーバーライドできます。

……というわけで、下記のようにしました。スタックの情報だけ JSON で別ファイルに出力します。

---- header

require "json"

---- inner

def initialize
  # ...
  @racc_stack_out = File.open("stack.log", "wb")
end

# Override Racc::Parser#racc_print_stacks
def racc_print_stacks(tstack, vstack)
  super(tstack, vstack)
  stack = tstack.zip(vstack).map { |t, v| [racc_token2str(t), v] }
  @racc_stack_out.puts JSON.generate(stack)
end

$ ruby parser.rb "1 + 2"
expression found
result: [1, "+", 2]

$ cat stack.log 
[["INT",1]]
[["INT",1],["\"+\"","+"]]
[["INT",1],["\"+\"","+"],["INT",2]]
[["expr",[1,"+",2]]]
[["expr",[1,"+",2]],["$end",false]]
[["expr",[1,"+",2]],["$end",false],["$end",false]]

これでパースしやすくなりました 👌

仕込み部分のまとめ

ここまでのポイントをまとめておきます。

@yydebug = true
@racc_debug_out を設定
- これは必須ではないが、標準エラー出力に出てほしくなければファイルなど別の出力先を設定しておく
Racc::Parser#racc_print_stacks をオーバーライド
racc コマンドに -t (--debug) オプションを付けてパーサを生成

図に変換する

ここまでできたら、あとは stack.log を図に変換するだけ。

ruby stack_graph.rb stack.log > stack_graph.html

stack_graph.rb は 160行くらい（2021-01-04 時点）の簡単なスクリプトです。

出力された HTML をブラウザで開くとこういう図が表示されます。x軸が処理の経過の方向、y軸がスタックが伸びる方向です。

※ この例では、 INT や expr など定型的なものはパレット指定、それ以外はランダムに色を決めています。

https://github.com/sonota88/racc-stack-graph

このリポジトリを git clone して ./run.sh sample_add.y "1 + 2" で試せます（パーサの生成 → パーサの実行 → 図の生成をまとめて実行）。

例1: 左結合・右結合の違いを見てみる

せっかくなので他の例も見てみましょう。

まずは左結合と右結合の違い。他の部分は同じなので class Parser ... end の部分だけ示します。

# sample_lr.y

class Parser

  prechigh
    left "+"
    # right "+"
  preclow

rule

  program: expr
  {
    puts "program found"
    result = val[0]
  }

  expr:
    INT
  | expr "+" expr { result = val }

end

./run.sh sample_lr.y "1 + 2 + 3"

1 + 2 が来た時点ですぐ還元（reduce）され、次に expr + 3 となったときにまた還元されています。

右結合に変えてみるとこう。パースの結果が [1, "+", [2, "+", 3]] になります。

最初の 1 + 2 までシフト（shift）した時点では 1 + 2 の還元は発生せず、さらにスタックが積み上がったところで 2 + 3 が還元され、その後で 1 + expr が還元されています。

例2: SQL

もう少し大きめの実際的なものということで、別件で作っているSQLパーサの例。select句、from句、…… と順番に還元され、最後に全体が1個の select文に還元されている様子です。

次のような入力を与えました。動作確認用なので内容は適当。

select
  123, 'str', null
  ,t1.a
  ,max(b)
  ,(
    case
      when a = 1 then 2
      else 3
    end
  ) as foo
from
  db1 . table1 as t1
  left outer join db2 . table2 as t2
    on  (
          t2 . a = t1 . a
      and t2 . b = t1 . b
    )
    and t2.a = t1.a
where
      a = 123
  and b <> 456
  and c in (1, 2)
group by a, b
order by a, b
limit 10
;

FlameGraph に渡してみる

stack.log をちょっと加工すると FlameGraph に渡せるのでは？と後から気づいてやってみました（この節は後から追記しました）。

# to_flamegraph.rb

require "json"

File.open(ARGV[0]).each_line do |line|
  labels = JSON.parse(line).map { |t, _| t.to_s.gsub(";", "(semicolon)") }
  puts labels.join(";") + " 1"
end

ruby to_flamegraph.rb stack.log | path/to/flamegraph.pl > flamegraph.svg

できますね 😃

FlameGraph で生成した SVG だと、キーワードにマッチする部分のハイライトや一部分のズーム表示といったインタラクティブな機能が利用できて便利。

参考: ディスク使用量をFlameGraphで可視化する - ( ꒪⌓꒪) ゆるよろ日記

バージョン

racc 1.5.2