普通に英単語の勉強にもなるので、もっとたくさん遊びたいのですが、本家は1日1単語に制限されているのがちょっと残念。そこで、今回はCUIでwordleもどきのアプリを作ってみました。

つくったアプリ

今回つくったアプリは、C言語の「C」・CUIの「C」を頭に付けて「cwordle」という名前にしました。

GitHub

GitHub - corgi0901/cwordle

Contribute to corgi0901/cwordle development by creating an account on GitHub.

プレイ中の画面はこんな感じ。C言語がコンパイルできて、コンソールから実行できる環境であれば大体動くとは思います。

今回は勉強がてら、ncurseを使って実装しているので、割とちゃんとしたゲームっぽく動きます。出題される英単語も毎回ランダムで変わるので、一日に何度でも遊べます。

出題される英単語のデータはパブリックドメインの辞書データを利用しているのですが、本家のwordleよりもずっと難しい気がします（汗。本家は出題される単語を絞っているだと思いますが、その基準も不明なのでとりあえずそのままに…。

CUIであれば、仕事しているフリして遊ぶことも可能です。
ちょっとした暇つぶしツールをお探しの方はよければ遊んでみてください。

ではでは

Copyright © 2026 Corgi Lab. ～備忘録のための技術ブログ～ All Rights Reserved.

手元にあるRaspberry Pi4＋Dockerならお手軽に立ち上げられるはずと着手したものの、意外とハマって大変だったので備忘録をまとめておきます。

環境

今回の環境は以下の構成になります。

• ハード：Raspberry Pi4 MobelB
• OS：Ubuntu Server 20.04

ラズパイへのUbuntu Serverのインストール方法は以下の記事にまとめています。

Corgi Lab. ～備忘録のための技術ブログ～

4 Pockets

RaspberryPi4でUbuntu Server 20.04を動かしてみた

新しい遊び道具として、RaspberryPi4（ModelB 4GBメモリ）を買いました。前モデルと比べて大幅に性能アップしているということで、学習用のLinux環境としても実用的なものになりそうです。ということで、今回はRaspbian（ラズパイの標準OS）ではなく、Ubuntu Serverをインストールして使ってみたいと思います(･∀･)OSイメージのダウンロードまずはUbuntu Serverのラズパイ用イメージを以下のページからダウンロードします。32bitと64bit両方のイメージが用意されていますが、特にこだわりがなければ64bit版で大丈夫です。2020/05/02時点...

Dockerのインストール

まずはDockerをインストールします。以下のコマンドを叩くだけです。

GitLabの立ち上げ

Docker上にGitLabを立ち上げます。まずは下準備として、GitLabの各種ファイルを保存するためのディレクトリを掘ります。ここでは例として、/var/docker/gitlabというディレクトリを掘りました。

続いて、以下のコマンドでGitLabのインスタンスを立ち上げます。GITLAB_HOMEには先で作成したディレクトリのパスを指定しましょう。

基本はGitLabの公式リファレンスに記載されている方法と同じですが、GitLab本体のイメージにサードパーティのものを使います。

というのも、ラズパイ4はCPUのアーキテクチャがARMなので、GitLabの公式イメージは動かすことができないためです。サードパーティー製なのであくまでも自己責任での使用になりますが、個人の学習用としては必要十分だと思います。

初回起動時は内部であれこれと処理が走るので、すぐにはアクセスできません。しばらく時間が経った後、ラズパイのIPアドレスにアクセスし、以下の画面が出れば起動は成功です。

管理者パスワードのリセット

本来であれば、初回起動時は管理者パスワードのリセットを求められるのですが、今回はそれが出ませんでした(´・ω・)

このままでは管理者ユーザーのパスワードが分からずにログインすることができません。そこで管理者パスワードを強制的にリセットします。

まずは、以下のコマンドでDocker上のGitLabコンテナに入ります。

コンテナ内に入れたら、以下を実行してrailsのコンソールを開きます。（すこし時間がかかります）

上記のようなコンソールが開いたら、まずは管理者ユーザーを取得します。管理者ユーザー=最初に登録されているユーザーです。

続いて、パスワードを上書きします。以下はpasswordとしていますが、お好みのものをどうぞ。

再確認用のパスワードも入力しておきます。

最後にパスワードを保存すれば完了です。

これでGitLabにもログインできるようになりました。ユーザー名にroot、パスワードに先で設定したものを入れてログインできれば成功です！

いろいろハマるところがあって大変でしたが、なんとかGitLabを立ち上げることができました。興味のある方は試してみてはいかがでしょう？

ではでは

Copyright © 2026 Corgi Lab. ～備忘録のための技術ブログ～ All Rights Reserved.

SQL、テキストファイルなど選択肢は多々ありますが、shared_preferencesというパッケージを使えば簡単に実装することができます。

Dart packages

2 Users

65 Pockets

shared_preferences | Flutter Package

Flutter plugin for reading and writing simple key-value pairs. Wraps NSUserDefaults on iOS and SharedPreferences on Android.

下準備

まずはpubspec.yamlのdependenciesにshared_preferencesのパッケージを追加します。この記事を書いている時点での最新は2.0.6でした。

dependencies:
  shared_preferences: ^2.0.6

下準備はたったこれだけです。以降、アプリへの組み込みをしていきます。

アプリに組み込んでみる

インスタンスの取得

値を読み書きはSharedPreferencesのインスタンスを介して行います。インスタンスの取得処理は以下の通りです。ちなみに非同期関数になります。

SharedPreferences prefs = await SharedPreferences.getInstance();

値の読み書き

取得したインスタンスに対しては、値の型に応じたsetter/getterのAPIを使って中身にアクセスすることができます。Ver2.0.6時点では以下の型に対応しています。

内部的にはKey-Valueの形式で保存されているため、各APIはキーと値を指定する形になります。Intの場合、setter/getterはそれぞれ以下のように定義されています。

// Setter
Future setInt( String key, int value )

// Getter
int? getInt( String key )

実装してみる

これらを使って、実装してみるとこんな感じになります。このようにAPIをラップしてあげると使い勝手がよく便利です。

import 'package:shared_preferences/shared_preferences.dart';

const String _KEY_HOGE = "hogehoge";

Future<int> getHoge() async {
	SharedPreferences prefs = await SharedPreferences.getInstance();
	int ret = prefs.getInt(_KEY_HOGE ) ?? 0;
	return ret;
}

void setHoge(int value) async {
	final SharedPreferences prefs = await SharedPreferences.getInstance();
	await prefs.setInt(_KEY_HOGE, value);
}

これでアプリ内に設定値を保存できるようになりました。複雑なデータは保存できないものの、オン/オフや数値などの簡単なデータであればとても楽に扱うことができます。

自作アプリに設定値を作りたい方はぜひ試してみてはいかがでしょうか？

ではでは

Copyright © 2026 Corgi Lab. ～備忘録のための技術ブログ～ All Rights Reserved.

組み込みの現場ではその名前を聞くことが増えましたが、まだまだ日本ではドキュメントも乏しくイマイチ掴み所がありません。そこで、まずは使ってみようということでRaspberry Pi4のイメージをビルドしてみることにしました。

Yoctoとは？

まず、Yoctoって何？というお話しですが、簡単に言うと「オリジナルのディストリビューションを作れる仕組み」です。カーネルからユーザーランドに至るまで、Linux全体をカスタマイズしてビルドすることができます。

以下はYoctoの公式サイトから引用したワークフローの図です。

Build System（背景が水色のブロック）がYocto内部で実行される処理フローを表しています。ソースの取得→パッチ適用→ビルド→パッケージ化→イメージ作成という風に、必要なソースを外部から取得してビルドすることで柔軟なイメージ作成が可能になっています。

Raspberry Pi4のイメージを作ってみる

さっそくYoctoを試してみましょう。今回は、手元にある組み込みLinuxボードとしてRaspberry Pi4をターゲットとします。

下準備

ホスト環境はUbuntu18.04を使います。2021/4/18時点で、以下のOSがホスト環境として利用できるようです。

• • Ubuntu 16.04 (LTS) / 18.04 (LTS) / 20.04
  • Fedora 30 / 31 / 32
  • CentOS 7.x / 8.x
  • Debian GNU/Linux 8.x (Jessie) / 9.x (Stretch) / 10.x (Buster)
  • openSUSE Leap 15.1

Yoctoを動かす事前準備として、必要なパッケージをインストールします。Yoctoの公式マニュアルにOSごとのインストールコマンドが記載されているため、素直にそれに従います。

Yocto本体＋ラズパイ向け設定の取得

続いて、Yocto本体（poky）を取得します。

pokyだけではラズパイ向けイメージのビルドに対応していません。そこで、ラズパイ向けのレイヤー（設定の集まりみたいなもの）を取り込みます。

ビルド前設定

レイヤーの取り込みができたら、いよいよビルドに入ります。

まずは以下のコマンドでpokyをセットアップします。このコマンドを実行すると、カレントディレクトリがpoky/buildに移動します。

ここからは下準備として、各種設定ファイルの書き換えをします。まずはconf/bblayers.confにラズパイ用レイヤー（赤字部分）を追加します。

続いて、ビルドターゲットをラズパイに変更します。conf/local.confにターゲットの設定（赤字部分）を追加します。

ここまでで下準備は完了です。あとはビルドを始めるだけ！

ビルド実行

以下のコマンドでビルドを開始します。必要最小限の機能のみをビルドする場合はcore-image-minimalを指定すると良いようです。

ここからはひたすら待ちます。CPU4コア・メモリ4GBのマシンで約4時間近くかかりました。

コンソールを見ていると、次々にパッケージがビルドされていく様子を見れて面白いです。先述したワークフローに従ってビルドが進行されていくのが分かります。

完成したイメージをラズパイで動かす

できあがったイメージをラズパイ本体で動かしてみます。

ビルドされたイメージはpoky/build/tmp/deploy/images/raspberrypi4-64下にあります。拡張子がwic.bz2のファイルがそれです。

このファイルを取り出して展開すると、拡張子がwicのファイルが出てきます。これをEtcherなどの書き込みツールでSDカードに書き込むだけです。

あとは書き込んだSDカードをラズパイに挿して起動できれば大成功です。

まとめ

今回はただ動かしただけですが、イチからLinux全体をビルドできたと考えるとちょっと面白いですね！Yoctoの神髄であるオリジナルのディストリビューション作成については、今後挑戦してみたいと思います。

ではでは

Copyright © 2026 Corgi Lab. ～備忘録のための技術ブログ～ All Rights Reserved.

ということで、今回は比較演算子を実装していきます。基本的には四則演算と変わりないのであまり難しくはありません。

比較演算子の仕様

比較演算子を実装する前に、その仕様について少し考えておきます。

比較演算子の結果は真偽の2値ですが、データ上は真を1、偽を0で表すこととします。こうした理由は特にないのですが、一番直感的に分かりやすい形にしました。処理系の中で統一されていれば問題ないので、0/1でなくてもOKです。

実装してみる

トークナイザ

トークナイズの処理はこれまでと変わらずですが、==（等価）や<=（以下）は2文字で1つの演算子になるので、＝（代入）や<（未満）と間違えて解釈されないように注意します。

この場合、最長一致で見つけていくのが良いので、以下のように処理の順番を1文字の演算子よりも先に持ってくるようにします。

〜省略〜

else if(strncmp(input, "<=", 2) == 0){
	Token token = { TK_RESERVED, input, 2 };
	tokens.push_back(token);
	input += 2;
}
else if(strncmp(input, "<", 1) == 0){
	Token token = { TK_RESERVED, input, 1 };
	tokens.push_back(token);
	input++;
}

〜省略〜

構文解析器

新しい演算子を追加するので、生成規則にもそれらを追加します。修正後の生成規則はこんな感じです。

新しい生成規則としてcompareを追加し、これまでの規則中のaddをそれに置き換えています。というのも、比較演算子の優先順位は四則演算よりも低いので、構文解析時には優先的に展開される必要があるためです。これにより、1+2<1+3のような式も正しく処理することができます。

続いて実装ですが、ノード種別の追加は==、!=、<、<=だけで十分です。>と>=については、<と<=の左辺と右辺を入れ替えて評価するだけでよいためです。

// ノード関連の定義
typedef enum {
	ND_NUM,			// 数値
	〜省略〜
	ND_EQ,			// ==
	ND_NEQ,			// !=
	ND_LESS,		// <
	ND_EQLESS,		// <=
} NodeKind;

構文木を作る処理もこの通り、左辺と右辺の入れ替えで対応します。

〜省略〜

else if(consume("<")){
	node = new Node{ ND_LESS, addNode, add()};
}
else if(consume("<=")){
	node = new Node{ ND_EQLESS, addNode, add()};
}
else if(consume(">")){
	node = new Node{ ND_LESS, add(), addNode}; // 右左辺を入れ替え
}
else if(consume(">=")){
	node = new Node{ ND_EQLESS, add(), addNode}; // 右左辺を入れ替え
}

〜省略〜

コード生成器

コード生成についても構文解析と同じく、==、!=、<、<=に対応した各命令を新たに定義します。

// 命令関連の定義
typedef enum {
	〜省略〜
	OP_EQ,			// ==
	OP_NEQ,			// !=
	OP_LESS,		// <
	OP_EQLESS,		// <=
	〜省略〜
} OP_CODE;

実行系（仮想マシン）

仮想マシンについては、新規追加した各命令に対する実処理を実装するだけです。特に四則演算と変わりません。比較結果がスタックにPushされます。

〜省略〜

case OP_EQ:
{
	push(reg[op->operand] == reg[op->operand2]);
	break;
}
case OP_NEQ:
{
	push(reg[op->operand] != reg[op->operand2]);
	break;
}
case OP_LESS:
{
	push(reg[op->operand] < reg[op->operand2]);
	break;
}
case OP_EQLESS:
{
	push(reg[op->operand] <= reg[op->operand2]);
	break;
}

〜省略〜

これで比較演算子を扱えるようになりました。今はまだ使いどころがないですが、次回以降で制御構文を実装すると、これらの演算子が活きてくることになります。

今回の実装は以下のコミットです。全コードはこちらをご覧くださいm(_ _)m

比較演算子を実装（112716a）

ではでは

Copyright © 2026 Corgi Lab. ～備忘録のための技術ブログ～ All Rights Reserved.

これまでは四則演算など、電卓レベルの機能実装に取り組んでいましたが、いよいよ変数を扱えるようにしていきたいと思います。これでかなりプログラミング言語っぽくなるかも(・∀・)

今回は新しい仕組みを入れたりと、割と修正がごちゃごちゃしてしまったので、うまくまとめきれていません。ごめんなさい…。

変数の実装について

これまでは即値しか扱っていなかったので、「値が登場すればそれをスタックに積む」という単純な仕組みで事足りていました。しかし、変数を扱うためには、どこかに値を覚えておいて、それを読み書きする仕組みが必要になります。

まず、変数の保存場所ですが、今回はスタックを使います。ただ、変数自体をPush/Popするのではなく、スタックの先頭領域を変数置き場として間借りします（下図）。

「C言語のローカル変数はスタックにある」なんていう話を聞きますが、それとほぼ同等の仕組みです。読み書きについては、各変数のスタック中のアドレスに対して行うようにします。

実装してみる

トークナイザ

この処理系では、変数名のルールを以下のようにします。

• 開始文字がa~z, A~Z, _のいずれかであること
• 途中の文字はa~z, A~Z, 0~9, _のいずれかであること
• 他の予約語と一致しないこと

実装自体は難しくないので割愛します。「他の予約語と一致しないこと」というルールがあるので、変数は最後にトークナイズするように注意します。

構文解析器

今回は変数の宣言と代入を実現したいので、生成規則は以下のようにしました。

変数を表すidentという記号を定義して、exprという新しい生成規則を追加しました。これで、変数＝式という代入式を扱えるようになります。

実装としては、変数そのものを表すノード（ND_IDENT）と、代入を表すノード（ND_ASSIGN）の2つを新規に定義します。

// ノード関連の定義
typedef enum {
	ND_NUM,			// 数値
	ND_ADD,			// +
	ND_SUB,			// -
	ND_MUL,			// *
	ND_DIV,			// /
	ND_ASSIGN,		// =
	ND_IDENT,		// 識別子
} NodeKind;

あとは生成規則に従って解析処理を実装すればOK。ここまでは割と単純です。

コード生成器

コード生成に関しては、変数の扱いがややこしいです。というのも、変数は置き場所（式の左辺 or 右辺）や、前後の文脈次第でその意味が変わります。

例えば、num=1という式の場合、numは代入先として解釈されるので、その評価値はアドレスです。一方、ret = num+1という式の場合は、numの評価値はそれが保持する値になります。

いま現在の生成規則では、代入式の左辺に来たときだけ変数をアドレスとして解釈すれば良さそうです。それ以外は全て値として解釈します。

ここからは実装です。まず、変数を表す構造体を以下のように定義します。変数名とその長さに加え、その変数のスタック上での位置（アドレス相当）を持たせました。そして、同一変数に対しては同じアドレスでアクセスできるように、変数のリストも定義しておきます。

// 変数定義
typedef struct {
	char* name;		// 変数名
	int len;		// 名前長
	int	offset;		// データ格納先のオフセット
} Variable;

vector vars;

また、変数に対する読み書きを実現するために、新しい命令としてLOADとSTOREを定義します。LOADはメモリ（スタック中）からレジスタへの値コピー、STOREはその逆です。

typedef enum {
	OP_PUSH,		// Push（レジスタ値）
	OP_PUSH_I,		// Push（即値）
	OP_POP,			// Pop
	OP_ADD,			// 加算
	OP_SUB,			// 減算
	OP_MUL,			// 乗算
	OP_DIV,			// 除算
	OP_STORE,		// レジスタ→メモリへの書き込み
	OP_LOAD,		// メモリ→レジスタへの読み込み
} OP_CODE;

そして、代入と識別子に対するコード生成を抜き出すと以下のようになります。

case ND_ASSIGN:
	gen_var(node->left);
	gen(node->right);

	operations.push_back( Operation{ OP_POP, REG_GR1 } );
	operations.push_back( Operation{ OP_POP, REG_GR0 } );
	operations.push_back( Operation{ OP_STORE, REG_GR0, REG_GR1 } );
	operations.push_back( Operation{ OP_PUSH, REG_GR1 } );

	break;

case ND_IDENT:
	gen_var(node);

	operations.push_back( Operation{ OP_POP, REG_GR0 } );
	operations.push_back( Operation{ OP_LOAD, REG_GR1, REG_GR0 } );
	operations.push_back( Operation{ OP_PUSH, REG_GR1 } );

	break;

途中に登場するgen_varという関数は識別子ノード専用の関数です。そのノードが示す変数のアドレスをスタックに積みます。

それ以降は、代入式であればアドレスに対するSTORE、それ以外であればアドレスからの値のLOADという形で命令列を出力します。

実行系（仮想マシン）

最後に実行系ですが、今回はスタックを変数領域とそれ以外で分けることにしたので、その境目を示す値が必要です。そこで、その値をベースポインタという名前で扱うことにし、いまは固定でスタックの先頭から16個先としました。つまり、使える変数は最大で16個までです。

DWORD* bp;					// ベースポインタ
sp = &stack[16];

途中、解説をかなり端折ったところもありますが、これで変数を扱うことができるようになりました。まだまだ実装は粗いですが、これで1つのチェックポイントは通過できたかなと思います。

今回の実装は以下のコミットになります。コード全体はこちらをご覧くださいm(_ _)m

変数の実装（dd7ed9e）

次回以降は制御構文の実装を視野に機能を追加していく予定です。

ではでは

Copyright © 2026 Corgi Lab. ～備忘録のための技術ブログ～ All Rights Reserved.

前回までで括弧を含んだ四則演算ができるようになりましたが、このままでは単なる電卓止まりです。ということで、今回は複数の式を連続して実行できる仕組みを実装していきたいと思います。

生成規則を考える

これまでは入力全体を1つの式として解釈していましたが、今回は式の区切りを定義して複数の式として解釈できるようにします。

C言語だと「;」や「,」が区切り文字として使われますが、開発中の言語（rook）では「,」と「\n（改行）」を区切り文字とします。それを踏まえて生成規則を考えると、こんな感じになります。

programの生成規則を修正しただけです。addが「,」または「\n」区切りで連続して現れる形にしています。

実装してみる

入力が複数の式になったので、実装も各所を修正する必要があります。具体的には、

• 構文解析の結果はノードのリストとする
• コード生成は各ノードに対して順に生成するようにする

という修正が必要です。

構文解析器

構文解析器は、先述したようにノードのリストとして解析結果を返すようにします。programの生成規則に対応した処理の中で、解析結果を詰めていくようにすればOKです。

vector<Node*> Parser::program(void)
{
	vector<Node*> nodes;

	nodes.push_back(add());

	while(consume(",") || consume("\n")){
		nodes.push_back(add());
	}

	return nodes;
};

コード生成

コード生成は構文解析器の結果（ノード）を1つ1つ処理していけばよいだけですが、1つだけ注意が必要なことがあります。

スタックマシンでは、1つの式の評価結果がスタックトップに残されます。そのため、複数の式を連続して実行したときには、その分だけスタックに評価結果が残されてしまいます。

これを避けるために、1つの式（ノード）に対応した命令列の最後に、スタックから値をポップする命令を追加するようにします（下記コードの8行目）。今回は汎用レジスタ（GR0）に結果を退避するようにしました。

vector<Operation> Generator::codegen(vector<Node*> &nodes)
{
	vector<Node*>::iterator node;

	for(node = nodes.begin(); node != nodes.end(); node++){
		gen(*node);
		operations.push_back( Operation{ OP_POP, REG_GR0 } );
	}

	return operations;
};

これで連続した式を実行できるようになったため、

のようなカンマ区切りの式や

のような改行区切りの入力が扱えるようになりました。まだ変数が扱えないのでプログラムっぽくはないですが、電卓止まりからちょっとステップアップしましたね(・∀・)。今回の実装のコミットは以下になります。

連続した式の実行に対応（95c14f7）

いよいよ、次回は変数に対応させていきたいと思います。

ではでは

Copyright © 2026 Corgi Lab. ～備忘録のための技術ブログ～ All Rights Reserved.

括弧を含む計算

これまでの実装では、乗除算は必ず加減算に先立って実行されます。しかし、それでは不十分なので、括弧を含む計算（例：（1+2)*3）を実行できるようにします。

生成規則をいじる

今回も構文解析器の生成規則を修正することで、括弧付きの計算に対応させます。前回の乗除算を実装した際には、乗除算が加減算より深くで展開されるように生成規則を変えることで、計算の優先順位を表現しました。今回も考え方は同じです。

まず、前回までの生成規則はこちら。

そして、括弧付きの計算に対応した生成規則が以下になります。

primaryという新しい生成規則を定義し、mulの中にあったnumをそれに置き換えています。primaryはnumと並列で括弧付きのaddを定義しているため、「括弧付きの計算が一番深い＝一番優先度が高い」という規則になっています。

実装はこれまでと変わらずなので割愛しますが、気になる方は以下のコミットをご覧ください。

括弧付きの計算に対応（47d1b06）

単項演算子（+と-）

括弧付きの計算は実行できるようになりましたが、これだけでは-5+3や1++3のような式が計算できません。これらを扱うためには単項演算子としての+と-を実装する必要があります。

生成規則をいじる

こちらも生成規則をいじることで解決したいのですが、ややこしいのが加減算の+と-との棲み分けです。文字は同じでも、式中の位置や文脈によって解釈が変わるので、それを上手に生成規則に落とし込む必要があります。

最初はこんな規則を考えましたが、結論から言うとダメでした。

括弧付きの計算で作ったprimaryの規則中、+付きのnumと-付きのnumを入れることでパッと見うまくいっていたのですが、-(1+3)のような式がパースできないことに気づき、ボツになりました(´・ω・)

括弧付きの計算にも対応しようと思うと、primaryの定義を

とすれば良いのですが、ちょっと冗長です。そこで、unaryという定義を追加して以下のようにするとすっきりします。

生成規則中の？は、直前の項目が0回または1回登場するという意味です。unaryだけを抜き出すと、実装はこんな感じになりました。

Node* Parser::unary(void)
{
	if(consume("+")){
		return primary();
	}
	else if(consume("-")){
		Node* zero = new Node();
		zero->kind = ND_NUM;
		zero->val = 0;
		Node* node = new Node{ ND_SUB, zero, primary() };
		return node;
	}
	else{
		return primary();
	}
};

+については特に何もしなくてOKですが、-については0からの引き算として実装しています。全実装は以下をご覧ください。

単項演算子の実装

これで、整数レベルの四則演算はすべてカバーできるようになりました。簡単な電卓レベルまで進化したことになるので、ちょっと嬉しいですね。

次回からはもう少し言語処理系っぽい機能を入れ込んでいこうと思います。

ではでは

Copyright © 2026 Corgi Lab. ～備忘録のための技術ブログ～ All Rights Reserved.

実装してみる

今回の実装において、トークナイザ・コード生成器・実行系（仮想マシン）については加減算のときと変わりません。単純に各種定義を追加して、それを扱えるようにしてあげるだけです。

一方、構文解析器についてはちょっとややこしいので、そこだけ解説します。

構文解析器

加減算では演算の優先順位がなかったので、単純に左結合（＝左から順に計算していく）で処理していけばOKでした。しかし、乗除算が入ると演算の優先順位が生まれるので、これを上手くさばくには工夫が必要です。

今回は優先度を考慮した生成規則を考えることで、これを解決していきます。前回までの生成規則は以下の通りです。

この定義に従って構文木を展開する順序と、実行時の処理順（評価順）を比較すると、以下のような感じになります。

• 構文木の展開順：program → add → num
• 実行時の処理順：num → add → program

このように、両者の順序は真逆になります。つまり、生成規則上で深くにあればあるほど、実行時には優先的に評価されます。この考え方を使えば、生成規則を以下のようにすることで、乗除算は実現可能です。

新たにmulという乗除算の規則を追加し、add中のnumをmulに置き換えました。こうすることで、加減算よりも深くで乗除算が展開されるため、実行時の優先度は乗除算の方が高くなります。

コードはこれまで通り、ノード種別の追加と上記の生成規則に対応した処理を実装するだけなので割愛します。

これで、乗除算を含んだ式を扱えるようになりました。以前に言語処理系の自作にチャレンジしたときは、この優先度にとても悩まされたのですが、生成規則でそれを解決するという方法にちょっと感動してしまいました。当時はそんなことは知らなかったので思いつきもしませんでしたが、やっぱり勉強は大事ですね…。

今回の実装のコミットは以下です。コード全体はこちらをご覧くださいm(_ _)m

乗除算の実装（3862655）

ではでは

Copyright © 2026 Corgi Lab. ～備忘録のための技術ブログ～ All Rights Reserved.

実装してみる

トークナイザ

前回までのトークナイザでは数値しか扱うことができないので、「＋」や「-」などの記号をトークン化できるようにします。

まずは、トークン定義を追加します。加算と減算それぞれで追加しても良いのですが、後段の構文解析で特に区別する必要がないので、演算子という形で一括りにします。

// トークン関連の定義
typedef enum {
	TK_NUM,			// 数値
	TK_OP,			// 演算子
	TK_EOF,			// 終端
} TokenKind;

続いて、トークナイズの実処理です。「＋」や「-」などの記号を見つけたらそこでトークン化するだけなので、以下のようなコードを追加します。

if(strncmp(input, "+", 1) == 0){
	Token token = { TK_OP, input, 1 };
	tokens.push_back(token);
	input++;
}

構文解析器

次は構文解析です。ここも前回は数値1つだけでしたが、今回は左辺と右辺を持った木構造を作る必要があります。

まずは、加減算を考慮した生成規則を考えます。BNF（っぽいもの）を使って書くとこんな感じです。

今回は新たにaddという規則を追加しました。定義の中に出てくる｜は「OR」の意味、＊は0回以上の繰り返しの意味です。加減算を含む式は、「数値＋数値」か「数値-数値」が連続している形になるので、この定義で表現できることになります。

このあたりの考え方は、私が参考にしているオンラインブック「低レイヤを知りたい人のためのCコンパイラ作成入門」がとてもわかりやすいので、ぜひ読んでみてください。

生成規則が定義できたら、それに従ってトークン列をパースする処理を実装します。まずはノードとして、加算・減算それぞれの定義を追加します。

// ノード関連の定義
typedef enum {
	ND_NUM,			// 数値
	ND_ADD,			// +
	ND_SUB,			// -
} NodeKind;

続いてパース処理です。前回同様、生成規則をそのまま落とし込む形で実装します。

Node* Parser::program(void)
{
	return add();
};

Node* Parser::num(void)
{
	Node* node = new Node();
	node->kind = ND_NUM;
	node->val = atoi(token->str);
	token++;
	return node;
};

Node* Parser::add(void)
{
	Node* node = num();

	while(1){
		if(consume("+")){
			node = new Node{ ND_ADD, node, num() };
		}
		else if(consume("-")){
			node = new Node{ ND_SUB, node, num() };
		}
		else{
			return node;
		}
	}
};

正直なところ、ここも先述したオンラインブックの実装を参考（というか、ほぼ丸パクリ）にしました。

どうしてこの実装で構文木が作れるのかしばらく分からなかったのですが、「左結合＝左の枝が深くなっていくように木を伸ばす」という視点で見たら、なんとなく納得がいきました。う〜ん、難しい…。

コード生成器＋実行系（仮想マシン）

次はコード生成と実行系（仮想マシン）です。スタックマシンにおいて加減算は、

• スタックの上から2つ値を取り出す（ポップする）
• 取り出した値を加算・減算した結果をスタックに積む

という流れで処理されます。前回まではスタックに積む（プッシュ）しか実装していないので、ポップ・加算・減算の3つを新規に実装する必要があります。

まず、仮想マシンに新しい仕組みを実装します。先述したように、加減算は「スタックからデータを取り出す」という処理が入るので、取り出した値を記憶する仕組みが必要です。

実際のCPUでは、こうした用途のために汎用レジスタというものがあります。そこで、今回は仮想マシンに汎用レジスタを実装します。いまのところ、加減算の左辺用と右辺用の2つがあれば良いので、以下のようなレジスタ定義を追加しておきます。

// レジスタ関連定義
typedef enum {
	REG_GR0 = 0,
	REG_GR1,
	REG_NUM,		// レジスタ数
} REG_NAME;

そして、仮想マシン内に汎用レジスタとして使える領域を実装すれば準備OKです。

DWORD reg[REG_NUM];	// レジスタ

続いて命令まわりです。命令定義の追加に加えて、命令そのものに第2のオペランドを追加します。加減算の右辺値を指定するためです。

// 命令関連の定義
typedef enum {
	OP_PUSH,		// Push
	OP_POP,			// Pop
	OP_ADD,			// 加算
	OP_SUB,			// 減算
} OP_CODE;

typedef struct {
	BYTE opcode;	// オペコード
	DWORD operand;	// オペランド
	DWORD operand2;	// 第2オペランド
} Operation;

これを踏まえての命令生成処理ですが、加算の場合は以下のような実装を追加すればOKです。

case ND_ADD:
	codegen(node->left);
	codegen(node->right);

	operations.push_back( Operation{ OP_POP, REG_GR0 } );
	operations.push_back( Operation{ OP_POP, REG_GR1 } );
	operations.push_back( Operation{ OP_ADD, REG_GR0, REG_GR1 } );

	break;

ノードの左辺値と右辺値を先に展開することがポイントです。こうすることで、実行時にスタックに左辺値と右辺値の評価結果が積まれている状態にできるので、あとはポップ命令と加算命令を出力すればOKです。

最後に仮想マシン内で、追加した命令に対する実処理を実装します。例えば、加算は以下のような感じです。オペランドで指定された2つのレジスタを足してスタックに積みます。

case OP_ADD:
{
	push(reg[op->operand] + reg[op->operand2]);
	break;
}

これで加減算を処理できるようになりました。ちょっとは言語処理系っぽくなったかなと思います。

今回のコードのコミットは以下です。コード全体はこちらをご覧くださいm(_ _)m

加減算を実装（5be1d97）

ではでは

Copyright © 2026 Corgi Lab. ～備忘録のための技術ブログ～ All Rights Reserved.