「自作言語」の記事 - 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 パーサにこだわる事情がなければ先に再帰下降パーサで入門するのも良いと思います。

シェルスクリプト（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に移植した

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でかんたんな自作言語のパーサを書いた

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

（初心者が）RubyでオレオレVMとアセンブラとコード生成器を2週間で作ってライフゲームを動かした話

2021-06-07T18:46:10+09:00

（Qiitaに書いた記事のクロス投稿です。元の記事公開日は 2019-05-04 です。）

きれいにまとまってないですが、箇条書き＋α程度で雑にメモ。

TechRacho さんの週刊Railsウォッチ（20210209後編）で紹介されました（ありがとうございます 🙏）。こちらもあわせて読んでいただけるとよいかと。

週刊Railsウォッチ（20210209後編）Rubyでミニ言語処理系を作る、Kernel#getsの意外な機能、CSSのcontent-visibilityほか｜TechRacho（テックラッチョ）〜エンジニアの「？」を「！」に〜｜BPS株式会社

できたもの

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

2018年5月のゴールデンウィーク残り2日というところ（5/5）で思い立って初めて、 5/18 完成。
- もっと早く公開したかったんですが仕事が忙しくて燃え尽きたりしていて結局1年かかってしまいました。
- 去年の言語実装 Advent Calendar に超初心者枠で参加しようかと考えてたんですが、間に合わず……。
それを原型を損ねない程度に名前を変えたり最終的に不要になった部分を消したりしたものです。
実装言語は Ruby。いちばん慣れていてサッと始められるので。

完成直後（ライフゲームが最初に動いた時点）の状態も見られるようにタグを付けています。
https://github.com/sonota88/vm2gol-v1/tree/20180518

汚いしひどいコードなので正直恥ずかしいんですが、この状態も生々しくてコンテンツとしては面白いかもしれません。やけくそか。ヒマな人向け。

※ その後作り直した v2 もあります。その後の改良も加わったものが見たい、パーサまで揃ったものが見たいという方はこちらを見てください。
※ (2021-02-21 追記) v2 にいくつか機能を足してセルフホストできるようになりました。

製作過程のメモ

どういうステップを踏んで何を実装していったか、具体的な話はこちらに書きました。あまり省略せずにその都度 diff を貼っていくスタイルです。

https://memo88.hatenablog.com/entry/2019/05/04/234516

動かし方

サードパーティなライブラリへの依存はなく、Ruby（と標準ライブラリ）だけあれば動きます。

# コード生成
ruby vgcg.rb gol.vgt.json > gol.vga.yaml

# アセンブル
ruby vgasm.rb gol.vga.yaml > gol.vge.yaml

# VMで実行
ruby vgvm.rb gol.vge.yaml

これらの処理をまとめて行うために run.sh というシェルスクリプトを使って動かしていました。

./run.sh gol.vgt.json

概要

VM

600行弱
CPU
- レジスタは a, b, c, d, pc, sp, bp, zf, of
  - c, d, of は途中で不要になった
- 命令セット … x86 っぽいオレオレ
- 数値演算は Ruby に丸投げ
メモリ
- ただの Ruby の配列。整数 or 文字列（！）のどちらかが入る。
- 3つの領域に分けた
  - メイン領域（機械語コードを配置する場所）
  - スタック領域
  - VRAM領域
- 配列の添字がそのままアドレス

機械語コード

こういう YAML ファイル。バイナリではなくテキストですが、機械語のつもり。

---
- call
- 1029
- exit
- label
- vram_set
- push
- bp
- cp
- sp
- bp
- sub_sp
- 1
- set_reg_a
- "[bp+4]"
- set_reg_b
- "[bp+2]"
- mult_ab
- cp
- reg_a
...

これを YAML.load_file したものをそのままメインメモリ領域にズボッと入れる。富豪的。
こういうものなので、「バイトコード」とは言えないかなと思って「機械語コード」と呼んでます
- 実在するCPU向けではなくオレオレVM向けなので「仮想機械語〜」のように呼ぶのがより適切？

アセンブラ・アセンブリコード

アセンブリコードも YAML。

- call main
- exit
- label to_vi
- push bp
- cp sp bp
- sub sp 1
- sub sp 1
- sub sp 1
- set_reg_d [bp+4]
- set_reg_a [bp+2]
- cp reg_d reg_b
- mult_ab
- cp reg_a [bp-3]
- set_reg_d [bp-3]
- set_reg_a [bp+3]
- cp reg_d reg_b
- add_ab_v2
- cp reg_a [bp-1]
...

ジャンプ先などのアドレス指定が実アドレスでなくラベル名になっている他は、内容的には上の機械語コードとほぼ同じ。
アセンブラは 60行弱
実アドレスへの変換以外にアセンブラでやっているのは入れ子の構造を flatten して1次元にしてるくらい。
- この 1次元化の処理も削っても良かったかも（そうすれば CPU 部分もさらに簡略化できる（そこまでやると簡略化しすぎという気も））

パースをサボるために YAML にしたものの、インデントなどで構造を把握しやすくした方が良かったかなと思います。こんな感じで:

  call main
  exit
label vram_set
  push bp
  cp sp bp
  sub_sp 1
  ...

この程度なら行ごとに line.strip.split(" ") で済みそう（v2 ではそうしています）。

コード生成器・高水準言語部分

コード生成器は 600行弱。

コード生成器に与える高水準言語相当のコードは、フォーマットとしてはJSON（ただし、 // でのコメントあり）。

["stmts"

 // バッファ配列用
 ,["func"
   ,"to_vi"
   ,["w", "x", "y", "offset"]
   ,[
      ["var", "vi"] // vram index
     ,["var", "vi_buf"]

...

  ,["func"
    // 関数名
   ,"main"
    // 引数
   ,[]
    // 本体
   ,[
      ["_debug", "start ----"]
     ,["var", "w"]
     ,["set", "w", 5]
     ,["var", "h"]
     ,["set", "h", 5]

     // 配列の初期化 5x5, グライダー / x, y, val
     ,["set", "vram[1]", 1]
     ,["set", "vram[7]", 1]
     ,["set", "vram[10]", 1]
     ,["set", "vram[11]", 1]
     ,["set", "vram[12]", 1]

     // メインループ
     ,["var", "cnt"]
     ,["while", ["eq", 1, 1], [
       ["set", "cnt", ["+", "cnt", 1]]

       // gen_next_step
       ,["call", "gen_next_step_loop", "w", "h"]

       // バッファの内容で置換
       ,["call", "replace_with_buf_v2"]
     ]]

    ]
  ]
]

これを JSON.parse すれば構文木がゲットできる。ずるい。
S式ですねー
C言語のような何かを想定したオレオレ
変数の型は数値のみ
中間コード生成はやってません。素朴に構文木を辿ってアセンブリコードに変換していくだけ。

グラフィック

ライフゲームなので2次元のグラフィック表示が必要
VRAM はサイズ 50 の配列で、これを半分に分けて（片方は次世代生成用のバッファ）、それぞれを縦横 5x5 としてターミナルに print するだけ。かわいい。

---- memory (vram) ----
..... .....
@.@.. ..@..
.@@.. @.@..
.@... .@@..
..... .....

VRAM といいつつ、1個の配列専用のヒープ領域みたいなものでもあり、なんとなくずるい気がしますが、とにかくこれでやりました。
- VRAM ではなくヒープ領域的なものであり、そこを覗き見ているだけだ、ということにしてもいい？どうなんでしょう。
- 「VRAMっていうのはこういうものだ」という知識がないので……
- ↑ この、よく分かってなさをお楽しみください……

方針

期限は2週間
理論とかを全部理解してから作ろうとしない
CPU の専門家やアセンブラの専門家やコンパイラの専門家になりたいのではない
とにかく動けばいい
調べものは最小限
- これは意識的にそうした。極力調べずに（＝どうしても分からなかったらそのとき最低限調べる）、それまでに聞きかじったボンヤリした知識を動員して憶測で適当にやる。
- 寄り道しない・脇道にそれない
不可欠でない部分はさくっと捨てる
- 「不可欠」というのは、「今回自分が知りたいこと」「完走するのに最低限必要なもの」「後からすげかえたりするのが難しそうなもの」くらいの意味
VM〜コード生成部分を作る
- 加算器部分からは作らない。前にちょっとやったので。
- 高級言語のパース部分はやらない。なんとなくだけど知ってるので。
汚くていい
- 自分が学習して満足できればよい。自分の中に知見なり経験値なりが貯まればよい。
- できたものはゴミでよい。どうせずっと使い続けるものではない。
作りつつその都度ブログ書いていくのもライブ感あって良さそうとも考えたけど、これもスピードが落ちそうなのでボツ。外部公開のことは考えないことに。
- 途中で更新止まると悲しいし
達人プログラマーでいうところの曳光弾。あれをやる。
- 自分の性格的にもその方が向いてる（早く見通しを得て不安をなくして余裕を得たい）

少し例えが暴力的でしたが、この手は新規プロジェクト、特に今まで構築されたことがないようなものを実現する場合に適用することができます。あなたは射撃手のように暗闇の目標を狙わなければならないのです。元になるシステムが存在していない場合、ユーザーの要求は曖昧なものとなります。さらに、不慣れなアルゴリズム、開発技法、言語、ライブラリを使って、未知の世界に直面していくことになるのです。また、プロジェクトの完了まで長い期間がかかるため、作業環境も変化していく可能性が高いでしょう。

（達人プログラマーピアソン・エデュケーション版 p48）

「正しく」やる時間がない人間は、重要な箇所だけに集中して枝葉を無視する。その結果、いくつかの細かい点は次のバージョンに回そうと計画する。ここで注意する点は、次のバージョンなど永久に作られないかもしれないということだ。しかし、「足りない部分は後でなんとかすればいい」と思い込むことで、脇道に迷い込むことを避けられる。それはまた、初期バージョンの細かな欠点についてのよい言い訳にもなる。

（UNIXという考え方 p34）

なぜ2週間か

頓挫するから。
平日昼間は仕事だし、夜・朝もそんなに時間使えないし、土日もいろいろやることある。
これまでの経験でも、長期化するとなんか仕事が忙しくなってきて中断してそれっきりとか、他におもしろそう（で簡単そうなもの）なものを見つけてそっちをやり始めて逃避したりで結局頓挫するパターンが多くて身に染みているから。絶対頓挫する。100%頓挫する。自信を持って断言できる。
で、いったんオレオレの適当な方法で動くものを作れば、その後で「正しいやり方」の解説を見聞きしたときに「あーなるほど、似たようなことやってたわ～」とか「こうすれば良かったのかーっ」ってなるはず。それでよい。それは2週間を終えた後でよい。
とにかく頓挫だけはしたくなかった。頓挫しないことが最も重要な意思決定方針。

感想

おもしろかった！！！！
楽しかった！！！！！
！！！！！！！！
十分自己満足できた（大事）！！！！
コード生成～VM実行部分に対するイメージがだいぶ解像度上がった感じ
全部いっぺんに作ったの良かった
- たとえば既存の何か（たとえば x86 だとか GNU as だとか）に合わせて作ろうとすると調べるのに時間取られる
- 下位レイヤーのことを全部知ってるし、何が起こってるか全部把握できる（なぜなら自分で作ってるから）
- 謎挙動は発生するけど、自分が書いた1000行ちょっとのコードのどこかに必ず原因がある
- ダンプでも何でもできるし、なんなら下位レイヤーを自分の都合のよいように決めて変えてしまえばよい
下から上に向かって作ったの良かった
- 低水準から高水準へ向かう発展の歴史を辿るような流れになっていて、おもしろい
- 上位レイヤーがなぜこうなっているのか？（下位レイヤーによる制約）が自然な流れで分かる
- つねに下位レイヤーのドッグフーディングをしている感じ。
  「動くものがなかなかできなくてつまらない」にはならなかった。
目標をライフゲームにしたの良かった
- 仕様や機能が必要かの判断で悩まなくて済む・無駄なものを作らなくて済む
- ライフゲームを動かすのに必要そうだったらやる。必要なさそうだったらやらない。
- 簡単すぎず、難しすぎず、ちょうどよい負荷（自分にとって）
Turing Complete FM の内容がちょびっと分かるようになった！！気がする！！！！！！！
これでやっと nand2tetris やふつパイラの入り口に立ったぞ……
10年前の自分に送りつけて「教材作ってあげたから今すぐやれ」「Ruby とエディタとターミナルだけあればできるから」と言いたい
- 他の人に薦められるかというと微妙（オレオレなので）

困ったこと

教材の問題

どれが（自分にとって）良い教材なのか分からない
入門者だし、界隈の事情に詳しくないので判断基準がない
現代の最先端のもの、専門家（を目指している人）向けのものは難しすぎる
- いきなり 64bit の世界から始まるし
昔のCPU向けのものだと今のものより素朴で入りやすいのでは？とか、現代のものでも組み込み向けはどうかな？などと思って調べたりもしたけど、資料の探し方もよく分からないし、ある程度知識のある人向けに書かれていたりしてよく分からない（効率がとても悪い）
- TCFM #29 で hikalium さんが「道が見えるようになるためには一回そこに行ってみないと分からない」という話をされてましたが、ほんとそれ
- ブートストラップ問題
- 昔のものだとそもそも実行環境どうするの？ってとこから始めないといけない。エミュレータがあっても、まずはその使い方を知らないといけない。
目移りする
- 「x86 でやることにしようかな」 → 「あ、なんか良さげな解説見つけた…けど ARM 向けだなあ…」みたいになってなかなかターゲットを決められない（例は適当です）
結局エイヤでオレオレすることに
どのみち自分に完全にぴったりな教材は存在しないので、教材を自分で作るみたいになった

入れ子の式

x = (2 * (3 + 4)) のように入れ子になっている式を

 ,["var", "x"] // 変数の宣言
 ,["set", "x", ["*", 2, ["+", 3, 4]]]

みたいに書きたくてあれこれ検討したものの、まじめに取り組むと何日か溶けそうな気がしたため

 ,["var", "temp"]
 ,["set", "temp", ["+", 3, 4]]
 ,["var", "x"]
 ,["set", "x", ["*", 2, "temp"]]

のように一時変数を使う形にして回避しました。うーん、これは悔しい。

自動テスト

これはちょっとした賭けでしたが、テストコードは書かずに進めました
- できあがりがどういう形になるのか分からない状態でのスタートだったため、下手にテストコードを書いてしまうとそっちの修正で時間取られそうな気がして……
- 既存の仕様に準拠するならともかく、今回は上から下までオレオレで、作りながら仕様が変わっていくと予想された（実際はあまり変わらなかったけど、それも作ってみないと分からないので）
バグが出ると「やっぱり書いておけばよかったかな……」とは思ったものの、結果的にはなんとかなった
- 運が良かった
とはいえ、まったくの無策だった訳ではなく、↓ のようなことはしていました
- 動作確認程度のちょっとしたものはその都度書いたり
- 生成されたアセンブリコード・機械語コードのファイルも git のトラッキング対象にしておいて、壊れていないことを git diff で確かめたり

どういう状態から始めたか

CPU

CPU のことをよく知らなかったので 2016年末～2017年頭頃に何冊か流し読みして、半加算器動かして足し算できる、みたいなのは書いてみた（この頃はアセンブラ、コード生成器まで作る気はなかった）。

マンガでわかるCPU
自作エミュレータで学ぶx86アーキテクチャ
- 達人出版会
CPUの創りかた
30日でできる！　OS自作入門
- 達人出版会
- CPUの本ではないですがなんとなく流れでこの頃に読みました。アセンブリ部分もあるし今回のをやるのに参考になっていると思います。

※なので、2週間でまったくのゼロから始めたわけではなくて、構想期間が1,2年くらいあり、その間に本やネットであれこれ読んだりいろいろ妄想したりしてました。その上で、考えても埒が明かないのでやっぱり実際に書いてみよう！となった、という流れです。

アセンブリ

聞きかじりでなんとなく知ってるくらい。
アセンブリ言語でプログラムを書いたことはない。
mov があって比較とジャンプとかするらしいぞ、くらい。
なるほど分かったぞそれを組み合わせればいろいろできるんだな！？くらいの認識。

コンパイラ

パーサ部分はなんとなくは知ってる
だいぶ前に読んだ（両方ともさらっと読んだだけで実際には自分で書いたりしてない）（どっちも青木さんの本ですね）:
- Rubyを256倍使うための本無道編
- ふつうのコンパイラをつくろう
  - これを読んだときは構文解析部分に興味があったので後半（コード生成の部分）は読んでなかった気がする
BNFで文法定義して構文木作って何かやるんでしょ？ …何かというのはつまり、えーとアセンブリ言語のコードを生成する（？）んですよね、で、具体的にどうやるかというと…（分からない

という感じ。つまり、半加算器～構文木の間で何が起こっているのかが分かっていなかった。

C言語どのくらい知ってる？

学生の頃は趣味プログラムをCで書いてた
十数年前なのでもうだいぶ忘れた
- 当時入門書として読んでいたのは前橋さんの C言語体当たり学習徹底入門で、この本＋αくらいの知識
OpenGL で3Dグラフィック描いたりとかはしてたけどクリティカルなメモリ管理が必要なものはあまり書いてなかったはず
その後 Ruby を使うようになり、趣味プログラムの99%くらいは Ruby で用が足りるのでC言語で書かなくなった

元ネタ・きっかけなど

nand2tetris

https://www.nand2tetris.org/
- 日本語版の書籍はコンピュータシステムの理論と実装
企画というか発想の元はこれ
たしか 2016年頃に知って、読んだ
最初に nand2tetris のコンセプトを知ったときは、 2週間〜1ヶ月くらい根詰めればどうにかなるかなあと甘い期待を抱いたけど無理で、
流し読みだけでやめてしまっていた
もっと簡略化した教材かなと思ってたけど、思ったよりきっちり進めてくスタイルの、教科書っぽい本だった
問題をもっと簡単にしてハードルを下げまくらないといけない

ライフゲームならテトリスより簡単そう（ユーザからの入力もない）だし、簡単な割には面白い動きが生成されるので自己満足度高そう。「ライフゲームが動いたら嬉しいだろうなぁ…」と、完成したときの満足感をモワモワ～と妄想しつつ……

rebuild.fm るいさんゲスト回（2016-08-09）

Rebuild: 153: Connecting The Dots (rui314)

40分あたりから 8cc の話。インクリメンタルに作ると良いという話。これを聞いたとき、やっぱりそうですよねえ、そうだろうなあと思った記憶があります。明らかに当企画のきっかけの一つです。

その後 Turing Complete FM が始まり、なんか楽しそうなのでやってみたい！という気分が盛り上がりました。

TODO

時間とやる気が揃ったら続きをやりたい。下記は「今回やってないこと」「今回捨てた・削ったもの」のリストでもあります。

nand から作って nand2gol にする
- (2020-05-03) 1bit CPU 作るところまではやりました: リレー式論理回路シミュレータを自作して1bit CPUまで動かした
VM
- [bp+1] とかを VM が直接（正規表現で…）解釈しているので、もうちょっと機械語っぽく
高級言語・コンパイラ部分
- 入れ子の式の計算をできるようにする
  - 今回回避してしまったので、最低限ここまではちゃんとやりたい
  - (2019-12-15) できるようにしました
- 配列
- 構造体
- ポインタ
- 再帰
- 型
- 字句解析・構文解析（ちゃんとCっぽいフォーマットのソースをパースする）
  - (2020-05-04) パーサも作りました
グラフィック
- あると楽しい
リンカ
OS
- 難しそう
- いろいろ削りまくればあるいは……？

ざっくり工程

まず簡単なVM
メモリにプログラムを直接書く
ファイルからロードするようにする
機械語コード書きつつ
- 命令を追加していく
- アセンブラを作ってラベルを実アドレスに変換
- 条件分岐、ループ、サブルーチンなど、必要そうなものを用意
ある程度できてきたらコード生成器を作りだす
- 変数、条件分岐、ループ、関数などをアセンブリコードに変換
部品が揃ってきたらライフゲームを動かす

ざっくり書くとこんな感じですが、実際は行きつ戻りつしていて、終盤でもライフゲーム書きながらVM部分を修正したりしてました。

こちらで製作過程を書いていますので詳しくはそっちを見ていただければと思います。

その他の参考書籍など

v1 を作る前〜作っている時に読んだもの

つくって学ぶプログラミング言語 RubyによるScheme処理系の実装 - 達人出版会
RubyでつくるRuby ゼロから学びなおすプログラミング言語入門（紙書籍＋PDF版） – 技術書出版と販売のラムダノート
32ビットコンピュータをやさしく語るはじめて読む486【委託】 - 達人出版会
ひとりでCPUとエミュレータとコンパイラを作る Advent Calendar 2017 - Qiita
- 下の方が半導体から始まっていて、すごいなーと思いながら読んでいました。
- > 最適化は理解の敵
くじけちゃいけない！マシン語入門平塚憲晴 : 平塚憲晴 : Free Download, Borrow, and Streaming : Internet Archive
- MSX

v1 を作った後に読んだもの

※流し読み含む

低レイヤを知りたい人のためのCコンパイラ作成入門
速攻MinCamlコンパイラ概説
Compiler basics (1): lisp to assembly | notes.eatonphil.com
- JavaScript
Rubyのしくみ　Ruby Under a Microscope | Ohmsha
- この本に限らず、Ruby の VM の話もうっすら分かるようになって良かった
Rubyで作る奇妙なプログラミング言語　プレミアムブックス版 | マイナビブックス
- 達人出版会
- 2019-03 頃に読んだ
- この本の存在は昔から知ってはいましたが、 esoteric language というのは上級者の遊戯であって自分にはハードルが高そうというイメージがあり、なんとなく読まずに過ごしてきました。しかし、今実際に読んでみると、難解そうに見えるのは表面だけで、中身は良い意味で普通の（汎用的な、使い回しの効く）言語処理系の話です。コードもコンパクトですし、もっと早く読んでいればよかった。先に読んで写経でもしていれば、 vm2gol の内容ももう少し違ったものになっていたかもしれません。

ブックマーク

その他 Ruby 関連で書いたもの

https://memo88.hatenablog.com/archive/category/Ruby

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 が絡むあたりとか）
あと細かい話がいろいろあった気がするけど、作った後このエントリを書くまで他のことをしていたら忘れてしまった……
今回はあんまり余裕なかったので実験的な要素はなし