「コンパイラ」の記事 - Crieit

シェルスクリプト（Bashスクリプト）でかんたんな自作言語のコンパイラを書いた

2021-12-21T07:40:58+09:00

シェルスクリプト Advent Calendar 2021
https://qiita.com/advent-calendar/2021/shellscript
の20日目の記事です。

Bashがある環境ならどこでも自作言語で書いたプログラムをコンパイルできるようになりました。

できたもの

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

いろいろと雑なのですが、アドベントカレンダーの期日があるのでとりあえず公開します。

サイズはこんな感じ。

$ wc -l {lexer,parser,codegen}.sh lib/*.sh
  220 lexer.sh
  655 parser.sh
  525 codegen.sh
   42 lib/common.sh
  193 lib/json.sh
  284 lib/utils.sh
 1919 合計

動かし方の例

echo '
func add(a, b) {
  return a + b;
}

func main() {
  var one = 1;
  var result;
  call_set result = add(one, 2);
}
' | ./lexer.sh | ./parser.sh | ./codegen.sh

# ↓アセンブリが出力される
  call main
  exit
label add
  push bp
  cp sp bp
  cp [bp:2] reg_a
  push reg_a
  cp [bp:3] reg_a
  push reg_a
  pop reg_b
  pop reg_a
  add_ab
  cp bp sp
  pop bp
  ret
label main
  push bp
  cp sp bp
  sub_sp 1
  cp 1 reg_a
  cp reg_a [bp:-1]
  sub_sp 1
  cp 2 reg_a
  push reg_a
  cp [bp:-1] reg_a
  push reg_a
  _cmt call~~add
  call add
  add_sp 2
  cp reg_a [bp:-2]
  cp bp sp
  pop bp
  ret
# (snip)

移植元

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

Bashスクリプト版のベースになっているバージョンは tag:62 のあたり

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

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

小規模: コンパイラ部分は 1,000 行程度
pure Ruby / 標準ライブラリ以外のライブラリ不要
x86風の自作VM向けにコンパイルする
ライフゲームのために必要な機能だけ
- 変数宣言、代入、反復、条件分岐、関数定義
- 演算子: +, *, ==, != のみ（優先順位は ( ) で明示）
- 型なし（値は符号付き整数のみ）
作ったときに書いた備忘記事
- RubyでオレオレVMとアセンブラとコード生成器を2週間で作ってライフゲームを動かした話
- Rubyでかんたんな自作言語のコンパイラを作った
本体には含めていない後付けの機能など
- 真偽値リテラル / break / if/else / 単項マイナス / Racc などを使って書いたパーサの別実装
Ruby 以外の言語への移植
- コンパイラ部分のみ
- Python, Java, TypeScript など、2021-12-19 の時点では 20言語
セルフホスト版
製作過程を知りたい場合は製作メモを見てください

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

メモ

文字列

下記の記事のおかげでなんとかなりました。ありがとうございます 🙏

シェルスクリプトはバイナリを扱えない。さてどうしよう…… - Qiita

バイト単位で16進数表現との相互変換さえできてしまえば、あとは煮るなり焼くなり思いのまま、です。

データ構造

[
  123, "fdsa",
  [
    11, "FDSA",
    []
  ]
]

のような、リストの要素として整数、文字列、リストを持たせることができる再帰的なデータ構造が必要です。Bashスクリプトの配列は単純な値を入れる分にはいいのですが、ネストしたリストを扱うことができなさそうでした。

（※ いつもならこういうことをやりたくなった段階で別の言語で書くことを検討しますが、今回は Bashスクリプトで書くこと自体が目的です）

そこで、ひとまず下記のようにしました。もっと良いやり方がある気がします。

リストの要素にあたるデータの表現はこんな感じ。

# 整数
"int:-123"

# 文字列
"str:fdsa"

# リスト
"list:1"

先頭に型を表すタグを付けた1行の文字列
文字列の値（str:... の ... の部分）は改行を含まない（レキサで捨てる）ため、改行についての考慮は不要
list: の後に続く数字はリストID

たとえば ["+", 1, -2] というリストは次のように3行の文字列で表せます。1行がリストの要素1つに対応します。

"str:+
int:1
int:-2
"

この文字列をグローバルな配列変数に入れて管理する形にしました。要素のインデックスがリストIDに対応します。

たとえば、入れ子のあるリスト ["+", 1, ["*", 2, 3]] は次のようになります。

# GLOBAL[0]
"str:*
int:2
int:3
"

# GLOBAL[1]
"str:+
int:1
list:0
"

パフォーマンスの問題は別途ありますが、要するに下記のような操作ができるインターフェイスが用意できればOK。

リストの要素数を求める
リストからn番目の要素を読み書きする
リストの要素の型を判別する
リストの要素の値を取りだす

関数からの値の返却

関数 myfunc から標準出力に出力して result="$(myfunc)" のようにコマンド置換で受け取る方法だと不都合な点が2つあります。

(1) 末尾の改行の有無を制御しにくい
- シェルスクリプトにはコマンド出力を変数に入れると末尾の改行が全部消えてしまう罠がある！ - Qiita に書かれている通り
(2) 呼び出した関数内でグローバル変数を更新できない
- コマンド置換だとサブシェルになるので

ちょっと悩みましたが、結局下記の方式に落ち着きました。

関数からの戻り値の受け渡し用のグローバル変数 RV1 を用意する
$(...) で囲まずに普通に関数を呼び出す
関数側では、返したい値を RV1 に代入する
呼び出し元では、関数呼び出しの直後に RV1 から移し替える

単純な例として、文字列を２つ受け取って連結した文字列を返す関数。

# return value
RV1=

myfunc() {
  RV1="${1}${2}"
}

myfunc "foo" "bar"
retval="$RV1"

こうですね。単にこのパターンで書けばよいだけなので頭は使わなくてよいです。無心に書いていくとコンパイラができあがります。並行処理とかやってないですし、関数から戻った直後で受け取る約束さえ守っていれば問題は起こりません。

全然スマートじゃなくてなんじゃこりゃって感じのソリューションですけど、この方法にも良いところがあって、RV2, RV3, ... と増やすことで複数の値をいくらでも返すことができます。あと、コマンド置換よりはオーバーヘッドが小さいかもしれません（未確認）。

関数の中でグローバル変数を書き換える実際の例としてはリストの生成処理があります。ヒープにリスト用の領域を確保して、リストを指し示すポインタを返すようなイメージです。

new_list() {
  new_gid
  local self_=$RV1
  GLOBAL[$self_]=""

  RV1=$self_
}

new_list
list1_=$RV1

Ruby で書くとしたらこんな感じ。

def new_list
  self_ = new_gid() # 新しいインデックスを採番
  $GLOBAL[self_] = ""
  return self_
end

list_ = new_list()

というわけで、かんたんなコンパイラを書くことにより、Bashスクリプトにおける

文字列処理
データ構造（入れ子のあるリスト）
関数からの値の返却

についてのノウハウが新たに得られました。めでたしめでたし。

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

Perlでかんたんな自作言語のコンパイラを書いた

なでしこ3でかんたんな自作言語のコンパイラを書いた

素朴な自作言語のコンパイラをLibreOffice Basicに移植した

PHPでかんたんな自作言語のコンパイラを書いた

2021-09-18T09:58:36+09:00

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

やっつけなので汚いです。ライフゲームのコンパイルが通ったのでヨシ、という程度の雑なものです。

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

移植元

自作言語の概要などについてもこちらを参照してください。

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

大元は Ruby 版なのですが、実質的には Perl版からの移植です。

ベースになっているバージョン: tag:50 のあたり
（追記 2021-09-18: ステップ60 の修正まで適用しました）

作り方はここに全部書いています（Ruby 版のものですが）: vm2gol v2 製作メモ

メモ

主な部分のサイズ（2021-09-18 現在）:

$ wc -l {lexer,parser,codegen}.php lib/utils.php 
   66 lexer.php
  536 parser.php
  423 codegen.php
   42 lib/utils.php
 1067 合計

PHP を書くのは今回が初めて
さらっと文法を見た感じ Perl に近そうだったので、
Perl版をコピーして書き換えていった
- 割と機械的に置き換え
- my を消して
- sub => function
- elsif => elseif
- 正規表現はダブルクォートで囲んで preg_match にして
- ……などなど
- Perl → PHP という流れで進んだのは良かった
Emacs に php-mode を追加するのがめんどくさかったので perl-mode で書いてた
クラスも普通に使えるし、 int と string の型の判別もできるし、 Perl より楽ちんという印象。
正直なところあまり書くことがないです……。

今回の実験コーナー。

これまで Dart への移植のときに set を不要にし、Java への移植のときに call を不要にし、Perl への移植のときに call_set を不要にしてきました。

これらを全部適用するとどうなるか trial ブランチ
でやってみました。

とりあえず parse_stmt() の分岐のとこだけ貼ってみます。

str_eq("set"     )) { return parse_set();        }
    # if     ($t->str_eq("call"    )) { return parse_call();       }
    # elseif ($t->str_eq("call_set")) { return parse_call_set();   }
    elseif ($t->str_eq("return"  )) { return parse_return();     }
    elseif ($t->str_eq("while"   )) { return parse_while();      }
    elseif ($t->str_eq("case"    )) { return parse_case();       }
    elseif ($t->str_eq("_cmt"    )) { return parse_vm_comment(); }
    else {
        if (
               $t->kind_eq("ident")
            && peek(1)->is("sym", "=")
        ) {
            if (
                   peek(2)->kind_eq("ident")
                && peek(3)->is("sym", "(")
            ) {
                return parse_call_set();
            } else {
                return parse_set();
            }
        } elseif (
               $t->kind_eq("ident")
            && peek(1)->is("sym", "(")
        ) {
            return parse_call();
        } else {
            throw not_yet_impl($t);
        }
    }

個別に試していたときはそれぞれの個別のことだけ考えてやればよかったのが、3つを同時に満たそうとして else に押し込めてとりあえずこうなった、というものです。ちょっと野暮ったいですが peek(n) で先読みしてやればなんとかなるようです。

funcall を expr に含めるとかするともうちょっとすっきりする気がします。

vgコードはこんな感じ。ここまでやるとかなり普通の言語っぽい（というか JavaScript っぽい）見た目になりますね。

func main() {
  var w = 5; // 盤面の幅
  var h = 5; // 盤面の高さ

  // 初期状態の設定
  vram_set(w, 1, 0, 1);
  vram_set(w, 2, 1, 1);
  vram_set(w, 0, 2, 1);
  vram_set(w, 1, 2, 1);
  vram_set(w, 2, 2, 1);

  var gen_limit = 0;
  var gen = 1;
  while (gen != gen_limit) {
    make_next_gen(w, h);
    replace_with_buf();
    gen = gen + 1;
  }
}

他の言語への移植

| PHP | github | 2020-09-18 |
-->

記事	リポジトリ	日付
Haskell	github	2021-06-28
OCaml	github	2021-06-26
Pascal	github	2021-05-22
Julia	github	2021-05-03
Rust	github	2021-04-07
Crystal	github	2021-03-27
Pric（セルフホスト）	github	2021-02-21
Kotlin	github	2021-01-14
Zig	github	2021-01-07
LibreOffice Basic	github	2020-12-14
Go	github	2020-09-25
C♭	github	2020-09-13
Perl	github	2020-09-08
C	github	2020-09-06
Java	github	2020-08-30
Dart	github	2020-08-22
Python	github	2020-08-19
TypeScript (Deno)	github	2020-08-15

Perlでかんたんな自作言語のコンパイラを書いた

2021-09-14T07:28:41+09:00

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

20年ぶりくらいに Perl のコードを書きました。やっつけなので汚いです。ライフゲームのコンパイルが通ったのでヨシ、という程度の雑なものです。

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

移植元

Rubyで素朴な自作言語のコンパイラを作った
（自作言語の概要などについてはこちらを参照してください）

ベースになっているバージョン: tag:49 のあたり
（追記 2021-09-11: ステップ60の修正まで適用しました）

作り方はここに全部書いています（Ruby 版のものですが）: vm2gol v2 製作メモ

ただ、Ruby 版よりは主に C言語版を見ながら書き写していました。クラスを使わなかったのもあり、C言語版に近いところも多いです。

メモ

20年ぶりくらいといっても、当時はちょっと入門した程度だったしもうほとんど忘れてるので
ほぼゼロから再入門といった感じ
でも 2日（日曜＋月曜）でなんとか完成した。殴り書きです。
配列・ハッシュとリファレンスが絡むあたりが最初よく分からなかった
- まず配列の要素数の取り方が分からないとか、for my $x (@$xs) { ... } の @ がなくて動かないとか、たぶん初心者あるある
数と文字列の区別がない（シェルスクリプトっぽい）のをどうするかちょっと悩んだ。データの型を見て処理を分岐しているところがあるので。
- ハッシュでラッパーオブジェクトみたいなものを作ってどうにかした（ lib/Val.pm ）。
- 最初は C言語版のときの NodeList, NodeItem 構造体を使う書き方にすれば何も考えずに機械的に移植できそうと思ったけど、あれはあれでリストの処理が煩雑・大げさで、配列で済むならその方がシンプルなので、最低限文字列と数だけ判別できるようにした。
クラスの使い方もちょっと調べてみたけど、もうちょっと Perl 力が上がった状態で使わないと逆に回り道っぽくなりそうな気がして、 C言語版の「構造体＋関数群のセット」方式でやってしまった

my $foo = ... をいっぱい書かないといけなくてさすがに面倒だったので途中で次のような Emacs Lisp を書いて Ctrl + Alt + M で入力できるようにしたり。yasnippet でも良かったかも。

(add-hook
 'perl-mode-hook
 '(lambda ()
    (local-set-key (kbd "C-M-m")
                   (lambda ()
                     (interactive)
                       (insert "my $ = ;")
                       (backward-char 4)))))

Dart版で call、Java版で set を不要にした流れで、今回は call_set キーワードを不要にしてみました。同じ要領でできますね、ということが分かりました。

（追記 2021-04-09: この修正はいったん revert しましたが、一応 trial ブランチに残してあります。）

sub parse_stmt {
    my $t = peek(0);

    if (Token::is($t, "sym", "}")) {
        return -1;
    }

    if    (Token::str_eq($t, "func"    )) { return parse_func();       }
    elsif (Token::str_eq($t, "var"     )) { return parse_var();        }
    elsif (Token::str_eq($t, "set"     )) { return parse_set();        }
    elsif (Token::str_eq($t, "call"    )) { return parse_call();       }
    # elsif (Token::str_eq($t, "call_set")) { return parse_call_set();   }
    elsif (Token::str_eq($t, "return"  )) { return parse_return();     }
    elsif (Token::str_eq($t, "while"   )) { return parse_while();      }
    elsif (Token::str_eq($t, "case"    )) { return parse_case();       }
    elsif (Token::str_eq($t, "_cmt"    )) { return parse_vm_comment(); }
    else {
        if (Token::kind_eq($t, "ident")) {
            return parse_call_set();
        } else {
            p_e("parse_stmt", $t);
            die "not_yet_impl";
        }
    }
}

（追記 2021-08-30: その後の修正により、下記の部分はなくなりました）

それと、今回はコード生成処理のアレ、何度も似たようなのが出てきて鬱陶しかった部分をためしにサブルーチンに抽出して共通化してみました。うーん。どうでしょう。どうしようかな。とりあえず名前が微妙。

名前が微妙な上に上手い抽象でもない気がする……となるとこれはメソッド抽出すべきではないパターンのように思えます。いい解決法が見つかるまで本家の Ruby版には取り込めなさそう。とはいえコーディングの手間・退屈さは減らせるので、移植版では気軽に使っていこうかなと。

sub to_asm_str {
    my $fn_arg_names = shift;
    my $lvar_names = shift;
    my $val = shift;

    if (Utils::is_arr($val)) {
        return undef;
    } elsif (Val::kind_eq($val, "int")) {
        return $val->{"val"};
    } elsif (Val::kind_eq($val, "str")) {
        my $str = $val->{"val"};
        if (0 <= str_arr_index($fn_arg_names, $str)) {
            return to_fn_arg_ref($fn_arg_names, $str);
        } elsif (0 <= str_arr_index($lvar_names, $str)) {
            return to_lvar_ref($lvar_names, $str);
        } else {
            return undef;
        }
    } else {
        return undef;
    }
}

呼び出し箇所は6箇所。それなりに使いまわせているようではあります。

vgcg.pl:132:    $push_arg = to_asm_str($fn_arg_names, $lvar_names, $val);
vgcg.pl:240:    $push_arg = to_asm_str($fn_arg_names, $lvar_names, $fn_arg);
vgcg.pl:304:    $src_val = to_asm_str($fn_arg_names, $lvar_names, $expr);
vgcg.pl:316:                    my $vram_ref = to_asm_str($fn_arg_names, $lvar_names, sval($vram_arg));
vgcg.pl:342:            my $vram_ref = to_asm_str($fn_arg_names, $lvar_names, sval($vram_arg));
vgcg.pl:375:                my $vram_ref = to_asm_str([], $lvar_names, sval($vram_arg));

他の言語への移植

記事	リポジトリ	日付
Haskell	github	2021-06-28
OCaml	github	2021-06-26
Pascal	github	2021-05-22
Julia	github	2021-05-03
Rust	github	2021-04-07
Crystal	github	2021-03-27
Pric（セルフホスト）	github	2021-02-21
Kotlin	github	2021-01-14
Zig	github	2021-01-07
LibreOffice Basic	github	2020-12-14
Go	github	2020-09-25
PHP	github	2020-09-18
C♭	github	2020-09-13
C	github	2020-09-06
Java	github	2020-08-30
Dart	github	2020-08-22
Python	github	2020-08-19
TypeScript (Deno)	github	2020-08-15

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

2021-06-21T19:23:12+09:00

自作言語 Ruccola のコンパイラがセルフホストできました！

https://github.com/sonota88/ruccola/tree/main/selfhost

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

※ 最初は Pric という名前だったのですが、 Ruccola に変更しました。以下、修正できていない箇所は読み替えてください。

概要

これまでのあらすじ

これまで vm2gol（virtual machine to game of life）というプロジェクト名で以下のようなことをやってきました。

(2018) RubyでオレオレVMとアセンブラとコード生成器を2週間で作ってライフゲームを動かした話
- vm2gol-v1
- 高水準言語の代わりに構文木を直接書き、それをコンパイルして VM で動かすところまで
- ライフゲームだけコンパイル + 実行できればOK
- 雑、汚い
(2019〜) Rubyで素朴な自作言語のコンパイラを作った
- vm2gol-v2
- v1 のリライト版（機能的にはほぼ同じ）にフロントエンド部分を追加したもの
(2020〜) vm2gol-v2 をいろんな言語に移植
- アセンブラ・VM は除いてコンパイラ部分のみ
- TypeScript / Python / Dart / Java / C / Perl / C♭ / PHP / Go / LibreOffice Basic / Zig / Kotlin / Crystal / Rust / Julia / Pascal / OCaml ... 気が向けば続く予定

今回のセルフホスト編は何もないところから全部書いたわけではなく、すでに v2 がある状態から出発しています。

概観

※ 独自VM向けなので「仮想機械語」と呼ぶべきかもしれませんが、この記事では単に「機械語」とします。
※ 図ではコンパイラが直接機械語を出力しているように見えますが、実際はアセンブルの過程があります。説明の簡略化のために省略しています。

T図式でも描いてみました。図の「Pric M」は Pric VM 向けの機械語。

規模

第2世代コンパイラのサイズ（行数）はこのくらい（2021-05-25 現在）:

$ wc -l lexer.pric parser.pric codegen.pric \
>   lib/json.pric lib/std.pric lib/types.pric lib/words.pric
  250 lexer.pric
  973 parser.pric
 1325 codegen.pric
  170 lib/json.pric
  536 lib/std.pric
  466 lib/types.pric
  305 lib/words.pric
 4025 合計

# 補助ツール的なもの
$ wc -l check.rb preproc.rb
 110 check.rb
  19 preproc.rb
 129 合計

バージョンと世代

以下、v2/v3 と第1世代/第2世代という表現が出てくるので先に説明しておきます。

バージョン: 言語仕様＝機能セットの違い
- Pric v2: ライフゲームはコンパイルできる。セルフホストはできない。
- Pric v3: セルフホストに必要な機能を v2 に足したもの
世代: 記述言語の違い
- 第1世代コンパイラ: Ruby で書いたもの
- 第2世代コンパイラ: Pric で書いたもの

※ 今回作った v3 ではライフゲーム（game of life）専用ではなくなるのと、やっぱり呼びやすい名前がほしくなって Pric という名前を付けました。 vm2gol ＝ Pric （プロジェクト名・言語名）という雑な捉え方でだいたい大丈夫です。 vm2gol がコードネームで Pric が正式名みたいな雰囲気。

工程

ステップ (1) 第1世代 v2 コンパイラにセルフホストに必要な機能を追加

第1世代なのでここは Ruby のコードの修正です。どのような機能を追加したかについては後述。

できたもの: 第1世代-v3 なコンパイラ

ステップ (2) Pric 言語 v3 でコンパイラ v2 を書く

別の言い方でいえば:

コンパイラ v2 を Pric 言語 v3 に移植
ステップ (1) で作った第1世代-v3 なコンパイラで第2世代-v2 なコンパイラをコンパイルできるようにする

ここからは Pric 言語でもりもり書いていきます。
第2世代コンパイラはこの時点では v2 の機能しかサポートしておらず、ライフゲームはコンパイルできますがセルフホストはまだできません。

v2 コンパイラの移植作業はこれまで何度もやってきていてだいぶ慣れています。Pric 版に一番近い C 言語版もすでにありますし、実装で悩んだら C言語版を見ながら移植していけばOK。また、これまでの移植の過程で整備されてきたテスト用データもそのまま使えます。

できたもの: 第2世代-v2 なコンパイラ

ステップ (3) 第2世代コンパイラ v2 を v3 にしていく

やることはだいたいステップ (1) と同じ。

できたもの: 第2世代-v3 なコンパイラ … これができれば完成

ステップ (2) の移植作業はこれまでやってきた移植作業と同じようにやればいい。

ステップ (3) は Ruby で (1) をやったことを繰り返して Pric で同じように書けばいい。

というわけで、全体の中ではステップ (1) が今回の目玉でした。今回自分にとって一番収穫の大きかったのがステップ (1)。

(1) ができた時点で (3) で何をやればいいか大体の目星が付き、後はやっていけば終わるなという感じで割と気楽に進めていきました。とはいえ、退屈な作業ということはなく、自作の言語でこれくらいの分量のプログラムを書くのは初めての経験でしたから、 (2) も (3) も十分新鮮でおもしろかったです。

方針

セルフホストに必要かどうかで機能を選ぶ
- v1 では「ライフゲームのコンパイルに必要か？」で決めていたが、
  今回も同様に「セルフホストに必要か？」で判断する。
- なるべく寄り道しない / まずは曳光弾を通す / 後回しにできるものは後回し
  - ここらへんも v1 のときと同じ。目標を絞って集中し、長期化させないように。
  - 「とにかくセルフホストできれば細かいところはどうでもいい」くらいの気持ちで
  - セルフホストすることが目的で機能追加はそのための手段
- 後回しにした機能については後述の「TODO」の節を参照
なるべく少ない機能で
- ミニマル・シンプルに作りたい気持ち
- 禁欲的に / ケチケチと
- (1) で機能を盛りすぎると (3) が大変になりそう
  - ステップ (1) で機能を追加するとき、つねに「これを追加するとステップ(3) で大変にならないか？」と考える。ステップ (3) の負担がなるべく小さくなるように意識する。
  - DQNEO さんの minigo のセルフホストの話などで大変そうな話を見聞きしていたのが影響していると思います。先達の経験談、ありがたや……。
適宜 C言語を参考にするが、あくまで参考程度。C への準拠にはこだわらない。
自作言語でセルフホストするのは今回初めてなので、無理しない。適宜ハードルを下げる。
- 空間効率、速度効率は気にせず富豪的に。開発効率的に辛くなってきたらそのときなんとかする。先回りしすぎないように。
- なるべく凝ったことをせず、多少冗長な書き方だったり遅い書き方でもよいので確実に動きそうな方に倒す（そこらへんの改善はセルフホストできた後でやればよい）

セルフホストに必要な機能

はっきり決めていたわけではありませんが、基本的には C言語版に近い感じになるのかなとイメージしていました。
そうすると、 C言語版では使っていて Pric v2 にない機能をリストアップしていけば、それが v3 で追加すべき機能の候補ということになります。

入出力
ポインタ
ヒープ / malloc
配列
文字列
構造体
グローバル変数
プリプロセッサ
- ファイル分割 / #include
- マクロ / #define

ざっとこんなところかなあとぼんやり考えて、後は作りながら決めていきました。
以下、思い出しながらそれぞれについて書いてみました。

※ 以下は説明のために整理していて、実際に考えたり作った順番とは多少違いがあります。

※ ちなみに、私はC言語はずっと前にちょっとやった程度でだいぶ忘れています。素人が書いていると思って読んでいただきたく……勘違い・浅い理解・不正確な記述などあると思います。

入出力

1文字ずつ読み書き。これは必要。
VM に命令を追加: read, write

入り口と出口で文字と数（アスキーコード）との変換を行い、コンパイル処理本体で扱っているのはすべて単なる数（整数）となるイメージです。

"def main()\n ..."

↓ read

100 101 102 32 109 97 105 110 40 41 10 ...

↓コンパイル

32 32 99 97 108 108 32 109 97 105 110 ...

↓ write

"  call main\n  exit\n ..." （アセンブリコード）

こうやって見てみると、コンパイラがやっていることは「ある数の並びを別の数の並びに変換する」処理だと見ることができます。おもしろいですね。結局それしかやっていないというか。

それはさておき、出力ができるようになると print デバッグができるようになります。また、出力を検証する形でテストできるようになり、これだけでもだいぶ進歩を感じるものです。「おっ、この機能ができたらアレとアレができるようになるじゃん！」という、ブートストラップの楽しさ。

hello world はこんな感じ。こんなのでも動くと嬉しい。

def putchar(c)
  write(c, 1);
end

def main()
  putchar( 72); # H
  putchar(101); # e
  putchar(108); # l
  putchar(108); # l
  putchar(111); # o
  putchar( 44); # ,
  putchar( 32); # (SPACE)
  putchar( 87); # W
  putchar(111); # o
  putchar(114); # r
  putchar(108); # l
  putchar(100); # d
  putchar( 33); # !
  putchar( 10); # (LF)
end

比較演算子

演算子としては小なり < だけ追加しました。これだけ追加すれば、 v2 からある ==、!= と組み合わせてあれこれできます。

VM にレジスタを追加: sf （sign flag）
VM に命令を追加: jump_g ... x86 の jg 命令を参考に

ファイル分割

#include lib/std.pric

のような行を探し、指定されているファイルを読み込んでその場に埋め込むスクリプトを Ruby で書きました。
が、これは単に cat コマンドで繋げるだけもよかったですね。そうしておけばさらに簡略化できた。

※ 機能として挙げましたが、この部分はコンパイラの本体に含めず、補助ツールの類である（セルフホストの対象外）ということにしました。

アドレス演算子・デリファレンス演算子

C の & と *

ステップ (1) の中ではここがキモ
- キモといいつつちょっと怪しいので改めて整理したい……
「ふつうのコンパイラをつくろう」を読み返す
- デリファレンス演算が左辺にあるときと右辺にあるときの違い
chibicc や cbc の出力するアセンブリを観察
- なるべく最適化されていないアセンブリ出力を見たい
- Compiler Explorer もお手軽・便利
アドレス演算のために VM に lea 命令を追加
- x86 の lea 命令を参考に
「ポインタがある」というか「アドレス演算とデリファレンス演算と、アドレスの入った変数がある」といった雰囲気（一緒？）

デリファレンスの括弧の中の部分は単なる式ということにしています。

*( some_addr_ + 2 )
   ^^^^^^^^^^^^^^
   この部分は単なる式

途中紆余曲折があって *(some_addr_, 2) のような書き方を試したりしましたが、括弧の中にはただの式を書くことにして単純化し、C っぽい見た目に落ち着きました。

デリファレンス演算の視点（？）では「とにかく何か値（式の評価結果＝アドレス）が渡されるので、そのアドレスが指している場所を操作対象とする」のように考えればよい、ということに。

（余談）乗算の * と被るのでデリファレンス演算子には別の記号を使うのはどうかと考えて ^ にしてみたり、前置じゃなくて後置にするのはどうだろう？と考えて ( ... )^ にしてみたり……という試みが途中ありました。

下手な考え休むに似たりかと思いきや、Pascal ではそのように書くのだと後から知りました。図らずも似たところに辿りついていたようでちょっとおもしろかったです。

他には addr(some_var), deref(addr_expr) のように普通の関数っぽい構文にしてしまう、という案もありました。パースは少し楽になりそうですが、視認性が悪そう（普通の関数と見分けにくそう）な気がしてボツに。

ヒープ / malloc

メモリのスタック領域として使っていた部分のうち、アドレスの小さい方の端をヒープとしました。

malloc もまじめに作らないといけないのかなと思ってあれこれ調べていたんですが、単に確保した分だけカーソルを動かすだけなら簡単で私でもすぐ作れそうね、じゃあそれで、ということになりました。

※ bump allocator とか stack allocator と呼ばれている方式だそうです。参考: Allocator Designs | Writing an OS in Rust

というわけで allocate 関数の中身はこれだけ。

def allocate(g_, size)
  # 変更前のカーソル位置
  var head_addr = *(g_ + GO_ALLOC_CURSOR());
  # 変更後のカーソル位置
  var next_addr = *(g_ + GO_ALLOC_CURSOR()) + size;
  # カーソル位置を更新
  *(g_ + GO_ALLOC_CURSOR()) = next_addr;

  # スタックと衝突していないかチェック
  check_heap_stack_overlap(g_);

  # 確保した領域の始点アドレスを返す
  return head_addr;
end

（g_ はグローバル変数構造体のアドレス。後述。）

free はありません（C言語版でも free してなかった）。ここは富豪的に。
富豪的にやってどのくらいメモリが必要だったかというと、最終的には番地の数で 2,600,000 となりました。1 byte/番地で換算すると約 2.6 MB。

あと、ヒープとスタックの衝突を Pric コードのレイヤーで検出する作りにしていて、そのためにレジスタ sp の値を取得する組み込み関数を追加しました。ここはちょっとやっつけ。

配列

配列は作る前からイメージがあって特に詰まらずに作れました。
「低レイヤを知りたい人のためのCコンパイラ作成入門」にならって、普通のローカル変数と同じようにスタックに置きます。

構造体の配列を使いたい場合は構造体のデータそのものは持たせず、ポインタというかアドレスを持たせる形で使います。もしデータそのものを持たせるとしたら各要素のオフセットの計算は自前でやらないとダメ（言語によるサポートはない）。

配列変数名[添字] で配列の要素にアクセスする構文を一度用意して、ステップ (1) では実装までしましたが、ステップ (3) でやることが増えるので取りやめにして実装も削除しました。

デリファレンス演算子があれば

a = *(xs_ + 1);
*(xs_ + 1) = 2;

のように配列の要素を読み書きできます。つまりポインタ演算のシンタックスシュガーなわけですね。
機能はなるべく少なくしたいという方針に沿って、今回は [] 演算子は取りやめにして実装も削除しました。

ただし、「これは配列を扱っているんだぞ」という意図を表すために実際は下記のような関数を介して操作するようにしています。

def aset(array_, i, val)
  *(array_ + i) = val;
end

def aget(array_, i)
  return *(array_, i);
end

Pric 言語で書けるものに関してはこのようにユーティリティ関数を作っていきました。

それで、結局配列のために手を加える必要があったのは

変数宣言時に幅を考慮（スタックポインタを幅1つ分ではなく配列の長さの分ずらす）
変数名からスタック上の位置を割り出す際に配列変数の幅を考慮

これだけといえばこれだけですね。
「配列という機能を追加した」というよりは「変数の幅の考慮とポインタ演算を組み合わせることによって配列の操作に相当する操作ができるようになった」という感覚です。

文字列

配列があればOK。プログラマ（私）が「これは文字列なのだ」と思い込むことにより文字列として扱うことができます。

たとえば C だったらこのように書くところを、

char str[] = "hello";

Pric では次のように書きます。

var [6]str;
aset(&str, 0, 104); # h
aset(&str, 1, 101); # e
aset(&str, 2, 108); # l
aset(&str, 3, 108); # l
aset(&str, 4, 111); # o
aset(&str, 5,   0); # (NUL)

さすがに毎回手で書くのは面倒なので適当なスクリプトで生成してターミナルからエディタに貼り付けていました。

また、コード上での行数が多くて邪魔なのと、複数箇所で同じ文字列を使うケースがあることから、実際は次のように文字列に値を詰める処理を関数にして使っています。

var [6]s_hello; set_s_hello(&s_hello);

ちなみに、文字列関連の何かを調べていたときに Pascal の文字列（先頭に文字列長を持つ）について知りました。Pascal 方式の方がバグが発生しにくそうな感じがしてちょっとなびきかけましたが、ひとまず C に寄せました（Pascal よりは C の方がなじみがあるため）。

構造体

構造体のサイズ分の領域の確保ができて、
起点と、各メンバのオフセットと幅が扱えて、
あとはポインタ演算ができれば読み書きできる

心の目で見ると構造体のようなものに見える何か。これもすでにある機能でまかなえてしまいます。

構造体のデータはヒープに置いていていますが、これはそういう制約がある訳ではなくとりあえずのルールです。たぶんスタックにも置けるはず。

some_struct.some_member や some_struct->some_member のような構文は用意せず、操作用のインターフェイスとなる関数を作ってその中でごにょごにょしています。
例を挙げると以下は List 構造体の size メンバの値を返す getter 関数です。アドレスがあればそれで操作できるぞい、というノリ。

def List_size(self_)
  var size = *(self_ + LIST__SIZE());
  return size;
end

# 呼び出し側
# C でいえば list_->size に相当
var list_size = List_size(list_);

結局、メモリ上の位置とデータがあって操作がある、ということでしょうか（それはそう）。

グローバルな定数

関数はどこ（他のどの関数）からでも呼び出せますから、固定値を返す関数があればグローバルな定数と等価なものとして扱えます。マクロのような仕組みを追加しなくても、すでにある関数を使えばOK。じゃあそれで。

※ ということにしましたが、コンパイラの機能に含めないことにしてプリプロセッサでやってしまってもよかったかも。

たとえば 1つ前の「構造体」の節のコード例に出てくる LIST__SIZE() がこれです。

グローバル変数

たとえば ELF だと .data セクションや .bss セクションに置く、という話があります。
しかし、その方向で進めるとなるとアセンブリ・機械語のファイルのフォーマットやメモリレイアウトも考えないといけなくなります。話が大きくなってハードルが上がってしまう（完成までの道のりが長くなってしまう）ように思われました。

そこで、グローバル変数に関してもすでにある機能でなんとかできないかと。

要するに

どこでも使えて
読み書き両方できる

という要件を満たせれば、その何かをグローバル変数相当のものとして使えます。

そこで思いついたのが、エントリポイントである main 関数で構造体を1つ用意して、そのアドレスを関数の引数でバケツリレーしていく方法です。よし、じゃあそれで。

機能追加まとめ

入出力: 追加した
比較演算子: < だけ追加した
ファイル分割: セルフホストの対象外とした
アドレス演算子・デリファレンス演算子: 追加した
ヒープ / malloc: ほぼ追加なし
配列: 幅を考慮して変数を扱えるようにした
文字列: 追加なし
構造体: 追加なし
グローバルな定数: 追加なし
グローバル変数: 追加なし

こうして見てみると、今回は

アドレス演算子・デリファレンス演算子を使って間接参照ができるようになった
メモリ上のある範囲をまとめて扱えるようになり、間接参照と組み合わせて配列・文字列・構造体相当のデータが扱えるようになった

ことの比重が大きく、これらを利用することでできることの幅がかなり広がった、と振り返ることができそうです。

また、グローバルな定数や配列・構造体操作用の関数に加えて -, <=, &&, || などの演算子も関数でなんとかしていて、関数があることでなんとかなっている部分も多いですね。関数えらい。抽象化の力。

感想など

v1 のときほどのがんばりは必要なく（そういう意味では盛り上がりに若干欠け）比較的落ち着いて進めた感じでしたが、
それはそれでOK。十分楽しく、達成感もありました！
先にC言語版を作っていたのが結果として良かった。ここで悩まずに済んだのも大きかった。
今回セルフホストまで達成できましたが、思い返してみれば
一度 v1 を作ったことが足がかりとなり、視界が開けて「自走できるようになった感」が得られたように思います。
がんばって v1 作って良かったなあとしみじみ。
ステップ (1) の部分は単純に知識・経験が得られてよかった（低レイヤーの知識がまたちょっと増えた）
- メモリ操作用言語でメモリ操作している、みたいな感覚が体験できた
（今回は）構造体や文字列など、いろんなものを「見立て」でなんとかしている。つまり、概念は開発者（＝自分）の頭の中にある。「これ不便だからこうしたら便利じゃね？」みたいなアイデア（シンタックスシュガーなど）も同様。
- 現在使われている言語の機能も、かつて開発者の頭の中にあったものが歴史を経て少しずつコードに落とされてきたものの蓄積……と考えると感慨深いものがありますね。今もいろんな人の頭の中に未来の便利機能のアイデアが眠っているのでしょう。
節目で何度か言語処理系Slackで進捗報告してリアクションをいただけたのがたいへん励みになりました。ありがとうございました。

TODO

まずは文字列リテラル（に相当する部分）を静的なデータとして使いまわせるようにするところから手を付けたいですね。
おそらくここが速度的に一番のボトルネックになっているので、ここをなんとかするだけでかなり速くなって、後が楽になるんじゃないかと。

パッと思いつくもの、やりたいなーと思いつつ自重していたのはこのあたり:

文字列リテラル
配列アクセス演算子 []
演算子の優先順位
- 明示的に ( ) で囲めば済むので結局今回もお流れとなった
演算子の追加 -, /, %, >, !, &&, etc.
&&, || の短絡評価
まともな構造体
まともなグローバル変数
型
関数の途中での return
break/continue
その他、雑多な改善: リファクタリング・最適化

あんまり詳しく考えてないですが、C に近づいていくのかなあ。

v1, v2 では初心者向け教材っぽくしたくて（想定読者＝どうやってコンパイラを作ればいいのか分からなかった頃の自分）「なるべくベタな仕様・見た目にしたい」「高度な機能や独自色をなるべく入れない」という気持ちがあったのですが、v3 ではその縛りは外してしまってもいいかなと思っています。

というわけで本体は以上で終わりです。以下、苦労話や枝葉な部分のメモです。

苦労話

遅い

lexer, parser, codegen を全部コンパイルすると現状では 15分くらいかかります（第2世代コンパイラが育つに連れて伸びていき、最終的にこのくらい）。
ふつうに辛いのですが、終盤ではゴールが近いと分かっていたので下手にジタバタせず逃げ切りました。特に対策せず、実行して待ってる間に部屋の掃除、実行して部屋の掃除、を繰り返していました。部屋がちょっときれいになりました。

※ 「TODO」の節で書いたようにこれから速くしていく予定です

配列の範囲外アクセス

プログラムが大きくなってくるとアセンブリや機械語やメモリのダンプを見てもさっぱり分からん……ので git reset --hard して歩幅を小さくしてやり直して、それで8割くらいはなんとかなった気がします。残りの2割はがんばってなんとか。gdb とか便利なものがないのでここはちょっと辛いですね。

ただ、長くても数時間くらいでなんとかなるレベルで、バグの原因が判明するまで何日もかかるということはありませんでした。
なるべく複雑なことをしないように作っていたのが良かったかもしれません。

エラー発生時にスタックトレースが見れない

print デバッグなどでがんばる……。

ある関数で配列の範囲外アクセスが原因と思われるエラーが発生し、おそらく呼び出し元で範囲指定をミスしており、そして呼び出し元がたくさんあり、まず呼び出し元の特定が必要……のようなパターン。

セルフホスト達成後に試したところ、VM などにちょいと細工をするだけでスタックトレースを見られるようにできました。若干チート感がありますが、これはさっさとやっておけばよかったかも。

関数呼び出し時の引数の個数のまちがい

これは結構鬱陶しくて、よく間違えるのと、個数が違うのが原因だと分かりにくく不毛だったため、さすがに対策しました。
構文木の段階で関数の定義と呼び出しを突き合わせてチェックする数十行程度のスクリプトを、これは補助ツールだから……と言い訳しつつ Ruby で書き、パース処理とコード生成処理の間に挟みました。
すごく原始的な静的解析でしょうか。

おまけ・細かい話

v2 から v3 への変更のうち、セルフホストにはそんなに関係ない部分、その他。

case 文の else

v2 には else がなく

case
when ...
  # ...
when (0 == 0) # else の代わり
  # ...
end

のように書いていたところを、次のように else で書けるようにしました。

case
when ...
  # ...
else
  # ...
end

if 文

case文があれば if文はなくていいかなと思っていたのですが

あればあったでちょっと書きやすい
少しの手間（数行の変更）で実現できそう

ということで書けるようにしました。

レキサで処理しています。if が来たら case when の2つのトークンに変換するだけ。

if ( ... ) ... end
↓ 変換
case when ( ... ) ... end

これだけで else 節のある if文も書けるようになります。

if ( ... )
  # ...
else
  # ...
end

↓ 変換

case when ( ... )
  # ...
else
  # ...
end

Ruby っぽい見た目に変更

すでにここまで貼ったコード片で見てきた通りで、 Ruby っぽい見た目に変えてみました。見た目は Ruby っぽいけど中身は C っぽい、ちょっと不思議な書き味です。

これはなんとなくできそうだったので、試してみて、なんとなくこうなったというものです。
v2 とのギャップを小さくするために JavaScript っぽい構文に戻そうかなとも考えていましたが、元に戻すのが億劫になるところまで進めてしまって、めんどくさくなって結局そのままという。

アドレス演算子、デリファレンス演算子があるため Ruby と文法コンパチにはなっていないと思います。

ポインタ変数

コードの見た目だけでは通常の変数なのかアドレスが入ってる変数なのか、使用箇所を見ても宣言を見ても分かりません。

var a; # 普通の整数が入る
var b; # アドレスが入る

そこで、見た目で瞬時に判別できるように、アドレスが入っている変数には末尾に _ を付けています。

def foo(
  arg1, # 普通の変数
  arg2_ # アドレスが入っている
)
  # ...
end

foo(
  a, # 普通の整数を渡している
  b_ # アドレスを渡している
);

というわけでおまけコーナーは以上です。また何か思い出したら追記するかもしれません。

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のブックマーク - はてなブックマーク

Pascalでかんたんな自作言語のコンパイラを書いた

2021-05-23T06:37:49+09:00

Pascal 初めて書きました。処理系は Free Pascal です。
いつもの通りでライフゲームのコンパイルが通ったのでヨシ、という程度の雑なものです。

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

移植元

ライフゲームのプログラムだけコンパイルできればOKという簡単なコンパイラです。Ruby 版だとコンパイラ部分だけで 1000行くらい。
ベースになっているバージョンはステップ 58 のあたり

メモ

主な部分のサイズ（行数）はこんな感じ。

$ wc -l *.pas lib/*.pas
  491 codegen.pas
  153 lexer.pas
  533 parser.pas
  184 lib/json.pas
  222 lib/types.pas
  195 lib/utils.pas
 1778 合計

※ VB はほとんど書いたことがなく、一方 LibreOffice Basic の方は多少書いたことあるので、以下では LibreOffice Basic を挙げていますが、たぶん VB でも大体似た感じだと思います。

ちなみに少し前に LibreOffice Basic で書いたもの:

自分が知っているものの中では C と LibreOffice Basic の中間みたいな印象
- Pascal + 動的型 → （VB） → LibreOffice Basic という流れ？
string 型があって文字列の扱いは C より楽
Emacs に pascal-mode をインストール……しなくてもすでに入っていた（インストールした記憶がないので最初から入ってた？）
- デフォルト設定だとインデントがスペース3つ
今回は fpc をインストールした Docker イメージを使うようにしてみた
処理系に配慮された整理された文法になっていて、たとえば C コンパイラを作るより Pascal コンパイラを作る方がハードルが低そう（コンパイラというか主に構文解析部分？）
- 教育的、というか元々教育目的として生まれた言語だそう
- 言語処理系自作に興味がある人は触れておいて損はなさそう
- 書籍『コンパイラ作りながら学ぶ』の PL/0' も Pascal 系の言語

Pascal は今まで触れる機会がなくて全然知らない文化圏という意識でいたのですが、実際触ってみると完全に異文化ということもなくて、自分が書いたことのある言語でいえば LibreOffice Basic が近いです（とりあえず見た目は）。

たとえば整数を2つ受け取って足した結果を返す関数は次のようになります。

// Pascal

function add(a : integer; b : integer) : integer;
begin
  add := a + b;
end;

' LibreOffice Basic

function add(a, b)
  add = a + b
end function

return 返り値 ではなく 関数名 = 返り値 と書く
返り値の有無で sub（Pascal では procedure）と function を使い分ける
関数・プロシージャ呼び出し時に引数がない場合は括弧を省略可

といったあたりが Pascal 由来と思われます。構造体の扱いも似ているような？

書いているときの感触としては「LibreOffice Basic の変数に型が付いて、文法はなんとなく似ていて、低水準の操作ができる」みたいな感じでした。

LibreOffice Basic 以外でも、JavaScript の with も Pascal 由来かな？とか、Go の := も Pascal 由来かな？とか、 Scala や Rust、Zig など、コロンで区切って型を後置するのも Pascal 由来かな？といった感じで、他の言語への影響と思われる（※確認はしていなくて、あくまで「思われる」という程度）要素がいろいろあって面白かったです。

Kuin の言語仕様の解説にも Pascal への言及がちらほら出てきますね。たとえば「Kuin言語仕様3 演算子」など。

参考

Pascal入門 (全18回) - プログラミングならドットインストール
- とりあえず最初にこれを見るのがおすすめ
変数の代入演算子と等価演算子について - Qiita
(2019) 世界のプログラミング言語(22) 今も改良が続くPascal/Delphi言語の栄枯盛衰 | TECH+
(2015) Pascalは過小評価されている | スラドデベロッパー

他の言語への移植

記事	リポジトリ	日付
Julia	github	2021-05-03
Rust	github	2021-04-07
Crystal	github	2021-03-27
Kotlin	github	2021-01-14
Zig	github	2021-01-07
LibreOffice Basic	github	2020-12-14
Go	github	2020-09-25
PHP	github	2020-09-18
C♭	github	2020-09-13
Perl	github	2020-09-08
C	github	2020-09-06
Java	github	2020-08-30
Dart	github	2020-08-22
Python	github	2020-08-19
TypeScript (Deno)	github	2020-08-15

Juliaでかんたんな自作言語のコンパイラを書いた

2021-05-10T04:15:28+09:00

とりあえず触って慣れようということで、何も分からないところからいきなり作り初めてその都度調べるという感じで雑に書いてみました。

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

移植元

ライフゲームのプログラムだけコンパイルできればOKという簡単なコンパイラです。
ベースになっているバージョン: tag:57 のあたり

メモ

できあがりサイズ（行数）は Ruby 版と同じくらい。

$ wc -l *.jl lib/*.jl
  359 codegen.jl
  113 lexer.jl
  360 parser.jl
  107 lib/json.jl
   56 lib/utils.jl
  995 合計

Ruby のような動的言語で書くのと似たフィーリングで書けました。

ただし、こういうのはダメで、

xs = ["a"]
push!(xs, 1) # xs に整数を追加
#=> ERROR: LoadError: MethodError: Cannot `convert` an object of type Int64 to an object of type String

次のように型について教えてあげないといけない、なんて場面はあったり。

xs = Any["a"]
push!(xs, 1)

今回のおためし。
ブランチ: trial

今回は case 文のネストを減らしてみました。
おためしというか v3 ですでに適用済みになっていて、 v2 にも取り込もうかなと考えているもの。

// before

case {
  (current_val == 0) {
    case {
      (count == 3) {
        set next_val = 1;
      }
    }
  (0 == 0) {
    case {
      (count == 2) {
        set next_val = 1;
      }
      (count == 3) {
        set next_val = 1;
      }
    }
  }
}

// after

case
when (current_val == 0) {
  case
  when (count == 3) {
    set next_val = 1;
  }
when (0 == 0) {
  case
  when (count == 2) {
    set next_val = 1;
  }
  when (count == 3) {
    set next_val = 1;
  }
}

{ 〜 } が1段なくなるため、ネストが減り、行数も減ってちょっとコンパクトになります。

ついでに、when 句の先頭にキーワード when を置くようにしてみました。パーサの都合としてはあってもなくてもほとんど違いはなく、 when を置いた方がなんとなく見た目的に落ち着きがよいかな、という程度の理由です。

他の言語への移植

上から新しい順。

素朴な自作言語のコンパイラをRustに移植した

2021-04-10T06:46:21+09:00

移植一覧に戻る

やっつけなので汚いです。ライフゲームのコンパイルが通ったのでヨシ、というレベルの雑なものです。

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

移植元

ベースになっているバージョン: tag:56 のあたり

メモ

理解は後回しにして、かっこ悪い書き方でもいいのでとにかく完成まで持って行く……といういつも通りの方針で、時間をかけすぎないように。理解は後でゆっくり。まずは手を動かして慣れる。
Tour of Rust
- 情報量が多すぎずよく整理されていて、一番最初にこれを読めばよかった
借用とかムーブとか
- このくらいのプログラムを書いて動かせる程度には分かってきた、はず。
  でもけっこう怪しい。
ライフタイム
- まだよく分かっていなくて、コンパイルが通らなかったらライフタイムが絡まない書き方にして回避したりしている
連結リストが難しそうだったので
Vec で管理する方式にしてとりあえず回避
レキサの入力文字列は最初に Vec にして使い回し
- C版や Zig版のように単純なバイト列として扱ってもよかったが、
  せっかくなので UTF-8 文字列として扱ってみた

TODO

気が向いたらあとで

List にノードID ではなくノードを直接持たせる
List のイテレータ対応

素朴な自作言語のコンパイラをCrystalに移植した

2021-03-28T06:15:18+09:00

Crystal が 1.0 になりましたね 🎉

めでたい。

というわけで（といいつつ少し前から作っていたのですが）移植しました。例によってライフゲームのコンパイルが通ったのでヨシ、という程度の雑なものです。

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

移植元

ベースになっているバージョン: tag:56 のあたり

メモ

is_a? で型を調べて分岐させると型が制限される。ここらへんは自分が知ってる中では TypeScript が近い。
- https://ja.crystal-lang.org/reference/syntax_and_semantics/if_varis_a.html
ユニオン型からのキャスト: as
- https://ja.crystal-lang.org/reference/syntax_and_semantics/as.html
of による型の指定
- > これは推論された型を置き換えるので、生成時には同じ型しか入っていないけれど、あとで別の型が入ってくるような場合に対応できます。
  https://ja.crystal-lang.org/reference/syntax_and_semantics/literals/array.html
String からシンボルへの変換
- できなさそうだった
- https://ja.crystal-lang.org/reference/syntax_and_semantics/literals/symbol.html
- https://crystal-lang.org/api/1.0.0/String.html
グローバル変数は使えない
- > しかし Crystal にグローバル変数はありません。代わりにクラス変数や定数を使ってください。
  https://crystal-jp.github.io/introducing-crystal/chapters/03-syntax.html
レキサの出力も ["kw", "func", 1] のような JSON にしてみた。少し冗長になるけど、扱いが楽になるので良さそう。これは Ruby 版にフィードバックしようかな。

素朴な自作言語のコンパイラをDartに移植した

2021-03-22T05:03:43+09:00

移植一覧に戻る

Dart で書いてみました。やっつけなので汚いです。Dart よく知らないけどライフゲームが動いたのでヨシ、というレベルのものです。

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

移植元

ベースになっているバージョン: tag:46 のあたり

追記 2021-03-21: Dart のバージョンアップ（2.9.1 => 2.12.0）に合わせて修正
- null safety まわりを適当に修正
追記 2021-03-21: ステップ56 の修正まで適用しました

メモ

アセンブラ・VM は移植対象から外しました。Ruby 版のものを使います。
トークナイザとパーサを分けてみた
テストのステップを細かくした
ファイルを直接まじめに読まなくても、標準入力が読めればあとはシェルスクリプトでラップしてあげたりすればいいので、もうそれでいいかなという気持ちになった。

Dart でプログラムを書くのは今回初めてでしたが、JavaScript と Java あたりを知っていればかなりスムーズに書き始められるなーという感想でした。引っかかるところがほとんどなかったです（今回書いた範囲では）。適当にググりながら 1日で書けてしまいました。

今回の実験的な要素としては、パーサをいじって set を不要にしてみました。

（追記 2021-03-21: この修正はいったん revert しましたが、一応 trial ブランチに残してあります。）

 func main() {
   var a;
-  set a = 42;
+  a = 42;
 }

文の先頭の set で判別するのをやめて、識別子だったら parseSet_v2() を呼ぶ。もうちょっとめんどくさいかなと思ってましたが、これだけだったら意外と簡単ですね。

List parseSet_v2() {
  // consume("set"); ... これが不要になる
  final t = peek();
  pos++;
  final varName = t.value;
  consume("=");
  final expr = parseExpr();
  consume(";");
  return ["set", varName, expr];
}

List parseStmt() {
  final t = peek();

  if (t.value == "}") {
    return null;
  }

  if      (t.value == "func"    ) { return parseFunc();      } 
  // ...
  // else if (t.value == "set"     ) { return parseSet();       }
  // ...
  else if (t.value == "_cmt"    ) { return parseVmComment(); }
  else {
    if (t.type == "ident") {
      return parseSet_v2();
    } else {
      throw notYetImpl([ t ]);
    }
  }
}

素朴な自作言語のコンパイラをTypeScript（Deno）に移植した

2021-03-10T05:00:58+09:00

移植一覧に戻る

TypeScript 入門というか、とりあえず何か書いて慣れようと思って書いてみました。やっつけなので汚いです。TypeScript まだよく分からないけどなんか動いたのでヨシ、というレベルのものです。
（※ 2020-08-15 に書いた記事のクロス投稿です）

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

移植元

ベースになっているバージョン: tag:45 のあたり

（201-03-06 追記: step 55 の修正まで適用しました。それに伴い、アセンブラ・VM 関連のコードを old_version ディレクトリに移動しました。全部修正すると大変なので）

メモ

YAML/JSON ライブラリへの依存をなくしてみた
- vge コードは YAML ではなく簡単な独自フォーマットにして自力でパースするようにした
- 単に行ごとに読んで文字列か数かを判別できればよい
- vgt コード（JSON）も自力でパースしてみた
Ruby 版で作った出力データがすでにあるので、
それに一致するように未実装部分を潰していくだけ。
ゼロから作っていた Ruby 版のときに比べたら遥かに楽。
今回もなんとなく VM → アセンブラ → コード生成器 → パーサ
の順で作ってしまって、インクリメンタルな作り方を試せばかったな……と作り終わってから思った

素朴な自作言語のコンパイラをKotlinに移植した

2021-01-15T05:11:53+09:00

移植一覧に戻る

Kotlin に移植してみました。やっつけなので汚いです。ライフゲームのコンパイルが通ったのでヨシ、というレベルのものです。

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

移植元

ベースになっているバージョン: tag:51 のあたり

メモ

Java版からコピーしてきて修正してできあがり。3日くらい。
Kotlin は仕事で少しだけ使って、あと少し前に「標準入力を読んで行ごとに処理」と「四則演算と剰余のみのexprコマンドをKotlinで作ってみた」を書いたくらいのほぼ初心者
Java と Scala の中間みたいな印象

今回の実験は配列変数の宣言。trial ブランチで試してみました。

確認用のコードです。今回の実験ではとりあえずこれだけコンパイルできれば OK。

// declare_array.vg.txt

func main() {
  var xs[22];
}

AST がこんな感じ。お試しなので適当。

$ ( \
>   cat declare_array.vg.txt \
>   | ./run.sh tokenize \
>   | ./run.sh parse \
> ) 2>/dev/null
[
  "top_stmts",
  [
    "func",
    "main",
    [

    ],
    [
      [
        "var_array",
        "xs",
        22
      ]
    ]
  ]
]

アセンブリコードがこんな感じ。

$ ( \
>   cat declare_array.vg.txt \
>   | ./run.sh tokenize \
>   | ./run.sh parse \
>   | ./run.sh codegen \
> ) 2>/dev/null
  call main
  exit

label main
  push bp
  cp sp bp

  # 関数の処理本体
  sub_sp 22 # ... 配列のサイズ分の領域を確保する

  cp bp sp
  pop bp
  ret

これだけだったら少し修正するだけで済みました。

次のようなコードはまだ正しく動くようにコンパイルできません。

func main() {
  var xs[22];
  var a = 11;
}

配列がスタック上で占有している幅を考慮しないといけないのに、それをまだやってないからです。これをやろうとするとたぶんあちこち修正しないといけなくなるので、それはまた今度ということで。

素朴な自作言語のコンパイラをZigに移植した

2021-01-07T23:57:33+09:00

移植一覧に戻る

※ 一部内容が古いです。二重管理が煩雑なためオリジナルのブログ記事の方だけ加筆修正しています。

やっつけなので汚いです。ライフゲームのコンパイルが通ったのでヨシ、というレベルのものです。

Zig（ziglang）を触り始めて1週間くらいの人が雑に書いたものですので、「お手本にできそうな Zig のコード」「かっこいい Zig のコード」を求めている人には参考にならないと思います。

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

移植元

ベースになっているバージョン: tag:50 のあたり

メモ

C と Go の中間、GC のない Go みたいな印象
sentinel-terminated な配列もなるほど便利そうと思って使ってみたが、通常の配列とは別の型になって煩雑なのと、サイズ固定な配列の出番が実はほとんどなかったので、後から普通の配列＋スライスで書き直していった
例外の扱いも Go とは違ったアプローチでおもしろい。最初は試しに使っていたが、お遊びプログラムなのでまじめにやる必要ないかと思い直し、これも後から使わないように（Java でいえば検査例外をその場で RuntimeException に包んで投げ直す感じに）書き変えた。単に煩雑さを避けるのを優先した形なのでほんとはちゃんとハンドリングすべきと思います。
型まわりの理解がまだいまいち（配列や const が絡むあたりとか）
あと細かい話がいろいろあった気がするけど、作った後このエントリを書くまで他のことをしていたら忘れてしまった……
今回はあんまり余裕なかったので実験的な要素はなし