シェル上で雑にファイル変更を監視する

立ち上げっぱなしのシェル上で雑にファイル変更を監視するワンライナーが欲しくなった。

非機能要件はこんな感じだろうか?

  1. ミニマムなサーバ環境など、新規にツールを導入したくないケースを考慮して、手持ちのコマンドを組み合わせて実現する。
  2. 立ち上げっぱなしのシェル上で動けばよい。バックグラウンド実行や、シェルスクリプトへの組み込みなどは、全く考慮しない。
  3. 監視するファイルそのものにたいする読み取り権限はないが、当該ファイルが置かれているディレクトリの読み取り権限はある、というケースに対応する。
    • ls(1)でファイルの有無を確認できるがless(1)で中身を見ることはできない、みたいな状況。

最後の項目 (3) については、例えば一般ユーザ権限で/var/log内のログファイルを監視したい、みたいなシチュエーションだ。

手元のDebianの/var/log/btmpを例に取ると:

$ ls -l /var | grep -Fw log
drwxr-xr-x  8 root root  4096 Sep 27 00:00 log
$ ls -l /var/log/btmp
-rw-rw---- 1 root utmp 289920 Sep 30 09:43 /var/log/btmp
$ cat /var/log/btmp
cat: /var/log/btmp: Permission denied
$ _

一般ユーザでも/var/logは読み取り可能なので、ls(3)にて/var/log/btmpが存在することは確認できる。しかし/var/log/btmpそのもの(中身)は読み取ることができない。

試行錯誤の結果、最終的に出来上がったのはこんな感じ:

( file=/var/log/btmp; field=5-8; cycle=10; stat1=$(ls -l "$file" | tee /dev/tty | cut -d ' ' -f "$field"); while sleep "$cycle"; do stat2=$(ls -l "$file" | cut -d ' ' -f "$field"); if [ "$stat1" != "$stat2" ]; then ls -l "$file"; stat1=$stat2; fi; done )

見にくいので整理してコメントを付けるとこんな感じ:

(
  # 監視するファイル
  file=/var/log/btmp

  # 監視するフィールド。
  # 手元の `ls -l` の実行結果より決定する。
  # フィールドの指定方法は cut(1) のmanを参照。
  field=5-8

  # 監視する周期。
  # 指定方法は sleep(1) のmanを参照。
  cycle=10

  stat1=$(ls -l "$file" | tee /dev/tty | cut -d ' ' -f "$field")
  while sleep "$cycle"
  do
    stat2=$(ls -l "$file" | cut -d ' ' -f "$field")
    if [ "$stat1" != "$stat2" ]
    then
      ls -l "$file"
      stat1=$stat2
    fi
  done
)

ひとまずls -lの出力のうち以下のフィールドをチェックしている:

  • 第5フィールド:ファイルサイズ
  • 第6-8フィールド:ファイル更新日時

第1フィールドをチェックすればパーミッションの変更を、第3-4フィールドならUIDやGIDの変更を監視することも可能だろう。ただしsleep(1)でポーリングしているので、ポーリングの間に「パーミッションを一時的に変更→元に戻す」みたいな操作が行われた場合には捕捉できない。

文字通り「雑に」――ゆるふわに変更を監視する仕組みだ。環境依存なワンライナーだが、とりあえず手元の環境で動くのでヨシ!

GNOMEマインスイーパーにユニケージみを見た

何の因果かGNOMEマインスイーパーのスコアデータを解析したのだが、データの持たせ方がちょっとユニケージを感じさせるテイストだったのでメモしておく。

手元のUbuntuでは、スコアデータは~/.local/share/gnome-mines/scoresに置かれていた。

$ pushd ~/.local/share/gnome-mines/scores/
~/.local/share/gnome-mines/scores ~
$ ls -l
total 108
-rw-rw-r-- 1 fabrico fabrico 97042 Sep 26 12:43 16-16-40
-rw-rw-r-- 1 fabrico fabrico  7768 Jul 13  2025 8-8-10
$ _

解析した環境には16-16-40と8-8-10の2つのファイルが存在した。

GNOMEマインスイーパーで選択可能な難易度(?)は以下の4種類だ。

  1. 8×8(10個の地雷)
  2. 16×16(40個の地雷)
  3. 30×16(99個の地雷)
  4. カスタム

おそらく盤面の大きさと地雷の数の組み合わせごとにファイルを作成してスコアを保存しているのだろう。実際に16-16-40には上記 (2) のスコアが保存されていた。

スコアファイルの中身はテキストファイルだ。中身は1行1レコードの形式のテキストレコードで、空白文字で区切られた3つのフィールドで構成されている。

$ head -n 5 16-16-40 
200 1521968326 fabrico
207 1521968562 fabrico
192 1521968765 fabrico
177 1521969066 fabrico
157 1521969561 fabrico
$ tail -n 5 16-16-40 
84 1790391264 fabrico
85 1790391479 fabrico
97 1790391632 fabrico
95 1790391735 fabrico
73 1790394190 fabrico
$ _

軽く確認した感じ、各フィールドの意味は次の通りだ:

  1. クリアに要した時間(秒)
  2. クリアした時刻(UNIX時間)
  3. ベストタイム更新時のレコードなら任意のプレイヤー名、それ以外ならアカウント名

興味深いことに、スコアファイルにはゲームをクリアする度にレコードが追加されていく、一種のトランザクションであるようだ。つまり過去から現在に至る全てのクリア時のスコアが格納されている。仕組み上、スコアファイルは実質的に第2フィールドでソートされた状態となっており、かつ、おそらく第2フィールドはキー値としても利用可能だろう(システム時刻が巻き戻る可能性まで考えると、この2点は成立しなくなるが……)。

行数をカウントすればクリア回数が分かるし、先頭行と最終行の第2フィールドを見れば初回クリアと最新クリアの日時が分かる。

$ wc -l 16-16-40 
4253 16-16-40
$ head -n 1 16-16-40 
200 1521968326 fabrico
$ date -d @1521968326 '+%Y-%m-%d %H:%M:%S'
2018-03-25 17:58:46
$ tail -n 1 16-16-40 
73 1790394190 fabrico
$ date -d @1790394190 '+%Y-%m-%d %H:%M:%S'
2026-09-26 12:43:10
$ _

しかし、ずいぶん長い間マインスイーパーをしているな。他にすることはないのか、まったく……。

アプリ本体で確認できるハイスコアのデータはスコアファイルから生成されている。少なくともHEADのソースコードからはそう読み取れる。

ハイスコアのデータは10件で、クリアに要した時間の昇順だ。同じタイムのスコアが複数存在する場合は、クリアした時刻の昇順となる。

同じようなことをシェルで実現するなら、こんな感じだろうか? ちなみに第3フィールドが日付なのはハイスコア達成時にユーザー名の代わりに達成日を入力しているからだ。

$ LANG=C sort -k1,1n -s 16-16-40 | head -n 10
61 1790347486 20260925
63 1790386438 20260926
66 1662868452 20220911
66 1786520149 20260812
67 1790349740 20260926
68 1784422364 20260719
68 1786280555 20260809
69 1745649215 20250426
69 1747454724 20250517
69 1785658921 20260802

安直に考えるとsort(1)のオプションは-k1,1n -k2,2nとするべきかもしれないが、スコアファイルは「実質的に第2フィールドでソートされた状態」なので、-k1,1nで第1フィールドだけ見てソートさせつつ、-sの安定ソートによって第2フィールド以降は元々のレコード順で出力させてもよいだろう。

(論理的には、システム時刻が巻き戻る可能性は存在している訳で……その場合には第2フィールドに「適切ではない時刻」が記録されたレコーダーが追加されるかもしれないし、第2フィールドの値が重複する状態が発生するかもしれない。このようなケースまで考慮するならば、下手に第2フィールドでソートするよりも、スコアファイルにレコードが追加された順番の方が信頼できるだろう――スコアファイルが改ざんされない限りは)

この辺をGNOMEマインスイーパーではどうアプローチしているかというと、単純に「クリアに要した時間」だけ見てソートしている。使用しているGenericArrayのソート機能はGLib 2.32以降は安定ソートになっているようだ。そう考えるとsort -k1,1n -sは本家本元に近いアプローチなのかもしれない。

第2フィールドを見やすく変換するならこんな感じだろうか。ちなみに手元のawk(1)の実体はmawk(1)だ。

$ LANG=C sort -k1,1n -s 16-16-40 | head -n 10 | awk '{ $2 = strftime("%Y-%m-%dT%H:%M:%SJST", $2); print }'
61 2026-09-25T23:44:46JST 20260925
63 2026-09-26T10:33:58JST 20260926
66 2022-09-11T12:54:12JST 20220911
66 2026-08-12T16:35:49JST 20260812
67 2026-09-26T00:22:20JST 20260926
68 2026-07-19T09:52:44JST 20260719
68 2026-08-09T22:02:35JST 20260809
69 2025-04-26T15:33:35JST 20250426
69 2025-05-17T13:05:24JST 20250517
69 2026-08-02T17:22:01JST 20260802
$ _

それにしても、ハイスコア(上位10件)のデータだけ保存するのではなく、クリア時のスコアを全部保存しているとは思わなかった。もしかしたら、こういうデータの持たせ方をしているアプリは意外と多いのかもしれない。

Git for WindowsでGitHubの複垢に対応しつつパスフレーズ入力を省略したい

注文の多いタイトルである。概ね下記エントリの続き。

eel3.hatenablog.com

前回の時点で、「Git for Windows + PuTTY付属のPlink」の組み合わせでは、同一PCからGitHubの異なるアカウントのプライベートリポジトリにSSHでアクセスするのが難しい、ということが判明していた。毎回Pageantにたいして鍵の追加・削除を行うことで、常に「通信したいアカウントの鍵のみ登録されている」という状態を保てば何とかなるのだが、それは非常に面倒である。

GitHubの複垢対応については、OpenSSHを使う方法が有名だろう。例えば以下のような設定を~/.ssh/configに書いておき:

Host foo.github.com
    HostName github.com
    User git
    Port 22
    IdentityFile ~/.ssh/key/github_foo
    IdentitiesOnly yes
    AddKeysToAgent yes
    TCPKeepAlive yes

Host bar.github.com
    HostName github.com
    User git
    Port 22
    IdentityFile ~/.ssh/key/github_bar
    IdentitiesOnly yes
    AddKeysToAgent yes
    TCPKeepAlive yes

アカウントfooのリポジトリと通信する際にはfoo.github.comを、アカウントbarならbar.github.comを使う――といった塩梅である。

個人的に、この方法は好きではない。この手法はssh-agentに登録されている秘密鍵の情報を無視してIdentityFileで指定されている秘密鍵のファイルを読み込むものだ。その性質より、秘密鍵ファイル読み込みの度にパスフレーズの入力が求められる。要するに、リモートリポジトリとの通信が発生する処理を行うたびにパスフレーズを入力しなくてはならない。非常に面倒だ。

(少なくともWindows 11付属のOpenSSHでは毎回パスフレーズを入力する必要がある)

私が実現したいのは、こんなことだ:

  • 前提01:Windows 11上でGit for Windowsを使っている。
  • 前提02:GitHubのアカウントを2つ持っている(仕事用とプライベート用)。
  • やりたいこと:同じPC上で、GitHubの異なるアカウントのプライベートリポジトリと「パスフレーズ入力なしで」通信したい。

案01:片方はSSHで、もう片方はHTTPSで通信する

2つのアカウントの双方ともSSHで通信しようとすると問題があるのだから、片方はHTTPSにしてしまおう――というのは、若干の注意点があるものの、概ね悪くないアイデアである。

実際に、前回のエントリ以降、つい最近までこの方法で凌いていた。

この手法は、取り扱うリポジトリがそれ単体で完結しているならば、何事もなく機能するだろう。

問題は、例えばcloneしたリポジトリがサブモジュールとして別のプライベートリポジトリを参照していて、かつgit@github.comで始まるURLで登録されていた場合だろう。リポジトリ本体とはHTTPSで通信できるが、サブモジュールとはSSHで通信しなくてはならない。

完全に自分自身の管理下にあるリポジトリならば、自己責任の下でサブモジュールをHTTPSで登録し直してしまえばよいのだが……その辺の管轄権が自分には無い、なんてこともよくある話だ。

案02:片方はOpenSSHで、もう片方はPuTTY付属のPlinkで通信する

2つのアカウントの双方ともSSHで通信したい――ということで、強引だが「物理的に異なるSSH通信プログラム」を使うことで実現させてみた。

大雑把なアイデアとしては、例えばこんな感じ:

  • アカウントfooのリポジトリとの通信にはWindows 11付属のOpenSSHを使用する。ssh-agentにはアカウントfooの秘密鍵を登録しておく。
    • ~/.ssh/configのIdentitiesOnlyは無効化しておく。
  • アカウントbarのリポジトリとの通信にはPuTTY付属のPlinkを使用する。Pageantにはアカウントbarの秘密鍵を登録しておく。
  • git(1)を使う際に、環境変数GIT_SSHを用いてSSH通信に使用するプログラムを切り替える。

環境変数GIT_SSHを毎回操作するのは面倒なので、ラッパーとなるバッチファイルを用意した。

@echo off
:: wgit.bat: Git for Windows + OpenSSH for Windows

setlocal

set GIT_SSH=C:\Windows\System32\OpenSSH\ssh.exe
git %*

endlocal
@echo off
:: pgit.bat: Git for Windows + PuTTY (Plink)

setlocal

set GIT_SSH=C:\path\to\PuTTY\plink.exe
git %*

endlocal

これで、git(1)の代わりにwgit.batを使ってアカウントfooのリポジトリを操作し、pgit.batを使ってアカウントbarのリポジトリを操作する――といった次第である。

OpenSSH for Windowsが参照するssh-agentの情報と、Plinkが参照するPageantの情報は、全く別物である。それぞれにGitHubアカウントの秘密鍵を片方ずつ登録しておくことで、両方の秘密鍵を登録することで発生する鍵の不一致の問題を回避しつつ、ついでにパスフレーズ入力の省略も可能となる。

今回はOpenSSH for WindowsとPuTTY付属のPlinkを使用したが、第三の選択として、Git for Windows付属のssh.exeもありうるかもしれない(未検証)。

またWindowsネイティブ環境での利用に拘らなくてもOKならば、例えばアカウントfooはGit for Windowsで、アカウントbarはWSLのgit(1)で……みたいな方法も考えられるだろう。要は、物理的に異なるSSH通信プログラムを使えばよい訳だ。

まとめ

それにしても21世紀の4分の1以上が経過しているのに新たなバッチファイルを書くだなんて……PowerShellがちょっとばかし大仰なのが悪いよ(責任転嫁)。

大文字と小文字を同一視した時に同名となるファイルを探し出す

問題編

仮想マシン上に組み込みLinuxのクロスコンパイル環境を整えていた頃、カーネルモジュールをビルドするためにカーネルのソースを展開するにあたり、仮想HDDが膨れ上がるのを避けるためにWindowsの共有フォルダを使おうと試みたことがあった。残念なことに、カーネルソースの一部に「同じディレクトリに同じ名前のファイル(ただし大文字・小文字の違いあり)が存在する」という部分があり、共有フォルダ上に正しく展開できなかった。

ファイルシステムやOSにより、ファイル名の大文字・小文字を区別したりしなかったりする。FAT16、FAT32、HFS+は大文字と小文字を区別しない。NTFSは区別するが、Windows自体が互換性保持のために大文字と小文字を区別しないかのように振る舞う。macOSでは、HFS+ではなくHFSXを使えば大文字と小文字を区別するし、APFSではフォーマット時に大文字と小文字を区別するか否かを指定できるのだが、大文字と小文字を区別する環境では一部アプリケーションが正常に動作しない*1。Linuxや*BSDで既定のファイルシステムを使う分には大文字と小文字を区別してくれるはずだ。

大文字と小文字を区別する環境から区別しない環境にファイルを移動する際に、ファイル名の衝突が発覚する。この問題を事前に回避するために、大文字と小文字を同一視した時に同名となるファイルを検出したい。

解答編

簡単だと思っていたが、思わぬところに窪みがあった。

基本的には「全ファイル名をパス込みで列挙→重複行を取り出す」という作業となる。典型的な手段は「sort(1)してuniq(1)のオプション-dで重複行のみを取り出す」だ。この時、sort(1)もuniq(1)も大文字と小文字を区別せずに扱うことが可能ならば、目的を達成できるはずだ。

sort(1)はオプション-fにて大文字と小文字を区別せずにソートする。uniq(1)もオプション-iで大文字と小文字を区別せずに処理する。例えば、カレントディレクトリ以下の全ファイルについて対象のファイルを探したいなら、次のようにすればよい。

find . | sort -f | uniq -d -i

ちょっと残念なことに、このコードには移植性の問題がある。sort(1)のオプション-fはPOSIXに含まれているし、少なくともmacOS・Linux・*BSDにて使用可能だ。一方でuniq(1)のオプション-iはPOSIXには含まれていないし、NetBSDでは使用できない可能性がある(manに書かれていないため)。

sort(1)ないしuniq(1)に大文字と小文字を同一視するオプションが無い環境では、例えば次のような感じで対応すればよいだろう。

find . | tr '[A-Z]' '[a-z]' | sort | uniq -d

ここまでの例ではfind(1)でファイルを列挙していたが、現実には、最初に触れたように圧縮ファイルの展開時に問題が発覚するケースも多い。その場合はfind(1)ではなく、例えばtar(1)のオプション-tで圧縮ファイルの中身を列挙することになる。

つまり、ファイルの列挙元はケースバイケースだ。そこで「列挙されたファイル名をチェックする」部分をスクリプト化することにした。

#!/bin/sh
# -*- coding: utf-8-unix -*-
# vim:fileencoding=utf-8:ff=unix

exec sort -f "$@" | uniq -d -i
#!/bin/sh
# -*- coding: utf-8-unix -*-
# vim:fileencoding=utf-8:ff=unix

exec cat "$@" | tr '[A-Z]' '[a-z]' | sort | uniq -d

終わりに

最終的には、こんな感じになった。

https://github.com/eel3/eel3-scripts/blob/develop/bin/cidup

元々、異なるプラットフォーム間でファイルを移動する際に問題があるか否かを調べることが目的のツールだ。この場合、予め問題を最小化するために「ファイル名にはASCIIコードの範囲の英数記号文字だけを用いる」という運用をしていることが多いので、sort(1)の高速化を狙って「LANG=C」としても大抵は支障はないと思う。

あと「ファイル一覧」がテキストファイル化されているならば:

exec sort -f "$@" | tr '[A-Z]' '[a-z]' | uniq -d

――のように先頭にsort(1)を持ってくることで「sort(1)がマルチスレッドで動作する」ことによる高速化を期待できるかもしれない。しかし今回の問題に関しては、実際の運用ではfind(1)などの出力をパイプ経由でsort(1)に流し込むことが圧倒的に多く、その場合にsort(1)はマルチスレッドでは動作しない。なので、初手がcat(1)な実装でも実質的に何も問題はないように思う。

*1:HFS+/HFSXの時代には、HFSXにはAdobe製品がインストールできないことで知られていた。

足りない部分だけプログラムを書く

10年以上前に書いたhcaslという小ツールについて「これなあに?」と問い合わせが来た。備忘録として裏事情を含めて書き残しておこうと思う。

hcaslには元ネタとなる自作ツールがある。元ネタの自作ツールは、かつて「教えて! goo」が生きていた頃にプログラミングのカテゴリに登録された質問を見て個人的に実装してみた代物だ。

2000年代後半のことだが、当時の私はプログラミングを始めてから日が浅く、しかもC言語ぐらいしか使える言語が無かった。そこで一時期、修行の一環として、「教えて! goo」などの質問掲示板に投稿されたプログラミング系の質問を読んで解答となるプログラムをC言語で書く、といったことを繰り返していた。

パズル的な課題や、現在で言えば競プロで出てくるような問題が、自分自身の好みから外れていたこともあるが……修行において主眼に置いていた項目が「実用に耐えうる堅牢なコードを書く」「分かりやすく明快なコードを書く」「自分以外のプログラマがメンテしやすいコードを書く」であったこともあり、どちらかといえば「何かしら実用的な小ツールを作る」系の課題を求めていた。で、当時の質問掲示板には時々その手の質問が投稿されていたのだ。

Wayback Machineに当時の質問が残っていた:

若干エスパーしつつ内容をまとめると、DNAをACGTの4文字で表現したテキストファイル――恐らくFASTAフォーマットからヘッダ行を取り除いたようなものだと思われる――を入力としてk-merを生成して、その出現回数をカウントしたい、ということだろう。質問ではabcdの4文字で構成されたテキストファイルとされているが、実際にはDNAを構成する代表的な塩基を示すACGTの4文字で構成されていたはずだ(何しろ質問者は生化学系の分野の人らしいのだから)。部分配列の長さは8文字、つまり8-merの頻度解析である。

この課題を解くにあたり、最初に思いついたアイデアは「CLIアプリを2つ作ってパイプで連結する」だった。概ねこんな感じだ:

  1. CLIアプリ8merを実装する。8merは標準入力からテキストファイルを読み込み、8-merを「1行に1個」の形式で標準出力に書き出す。
  2. CLIアプリ8freqを実装する。8freqは標準入力から8merの出力を受け取り、8-merの出現回数をカウントして出力する。
  3. 上記のプログラムを./8mer <input.txt | ./8freqのようにパイプで組み合わせて使用する。

ここで言うCLIアプリ8merを見直して、任意の文字数の部分文字列を出力可能にしたのがhcaslだ。

当時も今も、2つに分割するアイデアは「性能面のボトルネックが問題とならなければ」悪くないアイデアだと考えている。

8merは単純に8-merを生成するだけだが、言い換えれば組み合わせるツール次第で「出現回数のカウント」以外の作業にも流用できる。当初は8-mer固定で流用性は低かったが、再実装したhcaslのように任意のk-merを生成できるのならば、流用可能な範囲は広がるはずだ。

8merもhcaslも、生成されたk-merの出力順序は入力データに依存する。もしも「入力シーケンスの中のどのあたりに出現したか?」という情報が必要なケースが存在するならば、そういった類の作業にも使えるはずだ。不要ならばsortなどの他のツールで整列させてしまえばよい。

また8freqについては、例えば出現回数が0の8-merを表示しなくても構わないのなら、Unix環境では./8mer <input.txt | sort | uniq -cと処理してしまえばよい。つまり8freqは不要となる。

出現回数が0の8-merも含めて結果を出力したい場合も、一時ファイルを使用して構わないならば、一般的なPOSIXコマンドの組み合わせで実現できる。8freqのような専用ツールを書く必要はない。

例えば以下のような感じに8-merの全パターンを網羅したソート済みファイル8-mer-all.txtを用意しておいて:

AAAAAAAA
AAAAAAAC
AAAAAAAG
AAAAAAAT
AAAAAACA
AAAAAACC

(中略)

TTTTTTGG
TTTTTTGT
TTTTTTTA
TTTTTTTC
TTTTTTTG
TTTTTTTT

先述のsort | uniq -cとの組み合わせで得られた8-merの出現回数の結果とjoinしてしまえばよい:

# 分かりやすく分割して書くとこんな感じ。
#
# 8-mer-all.txtの各行の形式 : `<8-mer>`
# 8-freq.txtの各行の形式 : `<出現回数> <8-mer>`
#
# join(1) のオプション:
# * `-1 1 -2 2` より、8-mer-all.txtの1列目と8-freq.txtの2列目をキーとして結合する。
# * `-o 0,2.1` より、出力の形式は `<キーとする列> <8-freq.txtの1列目>`、
#   すなわち `<8-mer> <8-freq.txtの<出現回数>>` とする。
#   ちなみに `-o 1.1,2.1` と指定してもよい。
# * `-a 1` より、キーが一致しなかった場合には、
#   該当する8-mer-all.txtの列を出力させる。
#   これにより全ての `<8-mer>` が必ず出力されることになる。
# * `-e 0` より、出力時に「空のフィールド」があったら `0` を出力させる。
#   `-a 1` との組み合わせより、キーが一致しなかった場合に
#   `<8-freq.txtの<出現回数>>` の代わりに `0` が出力される。
#   すなわち `<8-mer> <0>` となる。
#
./8mer <input.txt | sort | uniq -c >8-freq.txt
join -a 1 -e 0 -o 0,2.1 -1 1 -2 2 8-mer-all.txt 8-freq.txt

# ワンライナー化したバージョン:
./8mer <input.txt |
sort |
uniq -c |
join -a 1 -e 0 -o 0,2.1 -1 1 -2 2 8-mer-all.txt -

この件から得られる教訓は何だろうか? それは「足りない部分だけプログラムを書く」ということだ。

とかく我らサンデープログラマはせっかちですぐに手を動かしたくなるものだが、一呼吸いれてから解くべき課題を注意深く観察してみると、本当にコードを書かなくてはならない部分は少なく、残りの大半は既存のツールの組み合わせで済んでしまう、といったケースは意外と多い。

今回の件で言えば、8merにあたる機能は用意する必要があったが、8freqについては実装せずに済ます余地があった。実装する範囲が狭まれば作業が楽になるし、バグを仕込んでしまう可能性も少なくなるはずだ。

その上で、「足りない部分だけプログラムを書く」にあたり、他のプログラムと容易に組み合わせられるように設計する必要がある。そうしなければ、他のプログラムと連携できない。

8merもhcaslもテキストフィルタだ。Unix環境においては様々なコマンドと組み合わせて扱うことができるだろう。

職業プログラマの場合は諸事情により「他の出来合いのプログラムと組み合せる」ことが厳禁なことも多いが、個人的な課題を解決するためのプログラミングにおいては、その辺の自由度は高いはずだ。

……まあ、今となっては生化学も含めてどこもかしこもPythonを使っているだろうから、hcaslなんてお呼びじゃないだろう。

蛇足:ちなみに8merやhcaslを実装した際の裏テーマは「入力ファイルに書かれているテキストが無茶苦茶長くても異常終了しない」だった。元の質問に入力ファイルの最大サイズの指定が無かったので、ヒトゲノムを基準として約32億文字のテキストが突っ込まれてもハングアップしない(ただし処理完了まで無茶苦茶時間がかかるけど……)ように実装した。ここまでデータ量が多い場合には、sort | uniq -cと組み合せると大変な事態に陥りそうなので、出現回数をカウントするために8freqのような専用ツールを実装する意味があるはずだ。

今までどのくらいプログラミング言語を触ってきたか(3秒で挫折したものものも含む) Ver.18

2026-06-27現在のステータス。昨年(2025-06-30)から1年経て、こうなっている。

eel3.hatenablog.com

なおCSS、HTML、XMLはひとまず除外する。人工言語ではあるけれども「プログラミング言語」という括りに含められるか否かは議論が分かれる気がする。*1

まあでも、XMLについてはメタ言語だから――XSLTみたいに、XML上に構築されたものがプログラミング言語的なことはあるよね。MSBuildのXMLスキーマもプログラミング言語っぽい部分があったりするし。

よく使っている

AWK (Gawk)
単純なテキストレコードの処理はAWKで十分間に合う。今の時代、自作ツールをnawkやGNU awk単体で実装するのは苦行すぎて*2皆無なものの、シェルスクリプトやMakefileにAWKのコードを埋め込むなどして他のコマンドと組み合わせて使う機会は依然として多い。シェル上でワンライナーでテキスト処理する時にも重宝している。これはこれで十分AWKらしい使い方ではないだろうか? ところで、はやくオプション--csvが使える処理系が広まってくれないかなあ……。
C++
最近のお仕事の主力言語で、C言語のコードをC++に移行する作業も多いのだが、しかし未だに本職のC++使いのレベルに到達できていない。もともと「C++11以降は非常に便利で、ホスト環境ではbetter Cでも使う価値がある」と思っていたのだが、最近はそこそこ新しいC++仕様に準拠したコンパイラを使える環境にいることもあり、より便利な機能を積極的に使えるようになった。嬉しい反面、旧来のアプローチとどう併用したらよいのか、試行錯誤が続いている。正規表現とスレッドとファイルシステムが標準ライブラリに加わったので、あとはソケット(低水準ネットワークAPI)をサポートしてくれないだろうか。低水準の処理を行いつつも便利な機能で実装時間を短縮できる点は便利で、少なくともシステムプログラム言語としての利点だと思う。だけど機能多すぎ/複雑すぎなところはなんとかならないものか。強力な反面、使い手を選ぶ言語だ。
C言語
お仕事での主力言語だった――ここ最近は仕事では使っていない(C++のコードの一部にC言語寄りのコードを埋め込むことはあるけど)。時々、仕事以外で触れる機会があり、その際にはなるべく最近の仕様に触れるようにしている。シンプルかつ低水準の世界が垣間見れるところが割と好きだが、同時にどうしようもなく面倒にも感じる。最近の他の言語と比較すると、シンプルすぎて安全機構が欠けているし、標準の便利機能も少ないので、入門用の言語としては薦められないが……一方でモダンな言語とは「変数とメモリ」まわりの概念モデルが全く異なるために、モダンな言語でプログラミング入門した人が後からC言語を学ぼうとした時に「変数とメモリ」についてのメンタルモデルと概念モデルの食い違いに悩む姿も見ているので、何というか、C言語から入門するのも、C言語以外で入門してからC言語を学ぶのも、どちらも大変ですな。
make (Makefile)
プログラミング言語に含まれるかどうか不明だが、DSL扱いで……いやGNU Makeはそこそこプログラミング言語的か。GNU Make 4.0はさらにプログラミング言語的だな、特にGNU Guileなところが。GNU MakeとNMAKEが主力。昔は稀にNetBSD Make(pmake)を使うこともあった。3者いずれも独自拡張アリアリで使っている。もう素のmakeではMakefileを書けない :) 最近はLinux向けツールのインストール・スクリプトを書く時にシェルスクリプト(特にBashアリアリとか)や高水準なスクリプト言語(Pythonとか)が選ばれがちで、なかなかMakefileを見かけることが少なくて、ちょっとだけ寂しさを感じている。いやでも「ファイルを入力として、別のファイルを生成する」系の作業のタスクランナーとしては、makeはまだまだ使えると思うのだ。
Objective-C, Objective-C++
時代はSwiftだと言われて久しい――どころか場所によっては「Flutter + Dartがメインで、Swiftはサブ」みたいなこともありそうだけど、どっこいObjective-CとObjective-C++は生きている。というかSwiftのコードにC++で書かれたライブラリを直接組み込むことができない以上、両者を繋げるグルー言語として生き残ることになるよね。一定以上のリアルタイム性が求められるアプリをSwiftだけで書くのは厳しくて、どうしても部分的にC言語やC++を使うことになり、グルー言語としてObjective-Cが召喚されることになる。最近流行の言語と比べると良くも悪くも80年代的だが、アプリケーションプログラミング用としてはC言語よりマシだし、C++ほど複雑怪奇*3ではない。そしてC言語やC++で書かれた既存のライブラリをそのまま使える。Objective-Cのハイブリッドな所は好きだが、Objective-C++はハイブリッドすぎて――C++のクラスとObjective-Cのクラスを、C++のラムダ式とObjective-Cのブロック構文を同時に使うのは大変だ。便利ではあるんだけどね。
Python
CLIの小ツールを作る際の主要言語となりつつある。コードは型ヒントありありである。Pythonではlazyなスタイルでのコーディングが許されず、整然とコードを記述する必要がある。その辺は、Perl 5やRubyとは随分と雰囲気が異なるように思う。特に、インデントが必須な言語仕様であるために、シェルスクリプトに埋め込んで使うのが苦痛だ。Pythonだけでコードを書く分には気にならないのだが……。
シェルスクリプト (/bin/sh)
プログラミング言語に含まれるかどうか不明だが……いや、私的にはシェルスクリプトは立派なプログラミング言語だ。基本的な用途は、バッチファイルと同じくちょっとした自動化や複数コマンドを組み合わせて使うときのラッパーだが、実現できる内容は遥かに多い。言語本体(?)がバッチファイルよりも高機能だし、Unixユーザランドはコマンドが充実している。その意味では、WindowsではMSYSよりもCygwinで――いやむしろWSL(Windows Subsystem for Linux)で環境構築すべきだろう。Cygwinでは、主要な処理をシェルスクリプトで記述しておき、bashからはシェルスクリプトを利用し、コマンドプロンプトではラッパーのバッチファイル経由でシェルスクリプトを叩く使い方をしている。ただWindows上では処理速度が妙に遅くなる点が不満だ。まあしかし、Unixのシェルは言語設計もシステム開発技法も未成熟だった大昔に「プアな環境でも問題なく動作する、プログラマブルな対話型コマンドインタプリタ」として開発された代物なので、言語設計の研究が進んでから作られたプログラミング言語と比較してはならない。なお自分自身が落とし穴に嵌らないようにShellCheckを活用すべし。

あまり使っていない

DOSバッチファイル
プログラミング言語に含まれるかどうか不明だが、含めてしまう。ちょっとした自動化や、複数ツールを組み合わせて使うときのラッパーとして、今でもよく使う。コマンドプロンプトはシバン(shebang)に対応していないので、スクリプト言語で書いたツールを起動するラッパーとしても多用している。意外と色々なコマンドが用意されているので、単純にそれらを叩く分には十分だが――言語機能がショボいので、バッチファイルでifやforのような制御構文系コマンドが必要になってきたら、何か決定的に間違えていないか、考え直すようにしている。
Ruby
自作ツールを実装する時、最近はPythonを使うことが多いのだが、時々Rubyを選択することもある。多言語化(文字エンコーディング)が絡むテキスト処理や、処理速度は考慮しなくてよいが桁あふれが気になる数値計算を行う場合だ。あとirb(1)も時々使っている。to_s(16)やto_s(2)で基数変換して表示できるところが割と好き。
Scheme
GaucheのWindowsネイティブ環境用バイナリは実験版だが、私が触る分には何の支障もない*4ことに気づいて久しい今日この頃。REPLを常時3つぐらい立ち上げているのだが、いずれも電卓代わりにしかしていない。REPLに貼り付けるコードもSchemeとCommon LispのどちらでもOKな四則演算に毛が生えた代物である。より本格的にUTF-8な環境に移行したら、大手を振ってGaucheでフィルタを書きたいなあ。
sed
プログラミング言語に含まれるかどうか不明だが、DSL扱いで*5。テキスト処理用。シェルスクリプトやMakefileにて他のコマンドと組み合わせて使う。というか正規表現でのテキスト置換以外の機能を使った記憶が……あったな、dとiとpと=とブレースによるグループ化ぐらいだが。私の技術レベルではsedでFizzBuzzを書けないので、sedで難しい処理を記述しないようにしている。
Swift
「コンパイラによる強力な型推論と型安全性のチェック」がお仕事用のメジャーな言語にまで降りてきたという点で、Swiftは静的型付け言語界のJavaScript*6だと思っている。でもユーザ数的には、Kotlinが「静的型付け言語界のJavaScript」ポジションなのかもしれない。割と好感が持てる言語だが、知識が中途半端にKotlinとごった煮になっているので、ついうっかりif式を書こうとしてコンパイルエラーになったり、「varとval」と「varとlet」の振る舞いの差異につまづいたりしてしまう*7。
Windows PowerShell
Windows 11に移行したこともあり、少しずつPowerShell Coreを触り始めている。しかし今までに書いたスクリプトは以前としてv5.1で動かしている。スクリプト言語としてのPowerShellは、オブジェクト指向で.NET Frameworkを叩けてダイナミックスコープでスクリプトブロック(という名の無名関数)と、無茶でピーキーで完全にプログラマ向けな代物だ。Microsoftもよくもこんなエライ代物を出したよね。コマンドプロンプトの代替という観点では、外部ツールとの親和性が微妙にイマイチな気がする(特に文字コードとか)。でもPowerShell内で閉じている分には問題ない。私の手元では「Windows専用のGUI付き小ツールを作るためのスクリプト言語」か「Excel COMとか叩く用のスクリプト言語」か「Windows Serverの管理スクリプトを書くためのスクリプト言語」扱いしている。ところで、いい加減『Windows PowerShell イン アクション』並みの言語解説書の最新バージョン対応版を出版してくれないだろうか。

最近使ってないが、縁は切れてない

bash
最近はデフォルトシェルがbashな環境も多いので、自分用のツールぐらいは素の/bin/shではなくbashで書いても大丈夫な気がしてきた。shよりbashの方が遥かに便利だからなあ――PerlやRuby等には負けるけど。bashでスクリプトを書くときの唯一の欠点は、メジャーバージョンごとの差異や各ディストリでのビルドオプションの違いにより、同じbashという名前でも実は千差万別なところだと思う。PerlやRubyのバージョンは気にするけど、これがシェルになると意外とバージョンに無頓着になってしまう。なんでだろう?
Go
寡作ながらもいくつか小ツールを書いてみたが、標準ライブラリが充実しているコンパイラ型言語っていいっすね。C言語に比べればC++の標準ライブラリも充実しているが、どちらかといえばプリミティブな機能が中心だ。PythonやRubyばりの標準ライブラリを抱えているGoには及ばない。その辺は、やはりCプログラマ(特にCでフィルタやデーモンの類を書く層)には受けそうな言語だと思う。並列処理周り(goroutines)とかARM対応とかが気になる。ソフトリアルタイム限定だが「組み込みLinux + Goで書いたデーモン」とかどうだろう? ただメモリを食うらしいという噂がどうなったか気になる――64bit環境では解消されるという話だったようだが、32bit環境でも解消されるようになったのだろうか? 組み込みでは現時点では逆立ちしたって64bit CPUはありえないからなあ、スマホやタブレット以外では。
Kotlin
本格的にAndroidアプリ開発に関わるようになったのがGoogle I/O 2017直後の過渡期なので、JavaよりもKotlinでの経験値の方が多い。モダンな「強い静的型付け」の、割とええ感じの言語やね。ただ、使い始めが「Swift 3をつまみ食いして半年以上経ってからKotlinをつまみ食いした」みたいな経緯だったこともあり、未だに両者の概念・機能が頭の中でごった煮になっている。それと、NDK絡みの作業が多いので、C++17・Java 7/8・Kotlinを行ったり来たり。泣けるぜ。Swiftもそうだが、最近のメジャーな「強い静的型付け」の言語は「開発環境込み」で高い生産性とコードの安全性を両立させる方向に進んでいる気がする。
Lua
Wiresharkのパケット解析スクリプトを書いたことも、C言語で書かれたUnixデーモンの設定ファイル用に処理系を組み込んだこともあった*8。あれから数年経ったが、今はどんな感じなんだろう?
Perl 5
時々、やむをえない事情で触ることがある。だが基本的によく分からない。何というか、あの記号の羅列っぽさに中々慣れないというか、自分は余りに自由度が高すぎる言語は苦手だと気づいたというか。(言語仕様に慣れているなら)半ば使い捨てなテキストフィルタとかをさっと書くに分には悪くない言語だと思うのだけど。
SQL
生まれて初めて触れたプログラミング言語その3ぐらいに位置する。組み込みの人なのでSQLとは無縁だと思っていたが、まさかTransact-SQLを少しだけ触ることになるとは。最近はAndroidアプリ絡みでSQLiteに触れることもあるが、AndroidXのRoom経由だったり、ContentResolverのqueryだったりと、フルセットのSQL文ではなく局所局所でDSL的に使う感じである。
Tcl/Tk
Tclは書き方を忘れた頃にテキスト処理ツールを書いている気がする。Tclは結構独特な言語だ。構文がシェルスクリプトばりに全てコマンドだったり、値が全て文字列だったり、実はリスト構造だったり、意外とTCPソケット通信が得意だったり……。それでも慣れれば結構使いやすい。意外とプロトタイピングに向いている気がする。8.6以降ではオブジェクト指向プログラミングもOKだが、それよりも例外処理用のtry末尾呼び出しの最適化用のtailcallの方が興味深い。しかし、これからメジャーになる可能性は低そうだ。Tkは……小規模なGUIツールをさくっと構築できるところは便利だが、Webアプリ全盛の時代にどれだけ訴求力があるのやら。
Visual Basic .NET
Visual Basic .NET 2003で書かれたコードを時々メンテ中。流石に開発環境はVisual Studio 2013移行したけど。
XSLT
よく考えてみたら生まれて初めて触れたプログラミング言語その4ぐらいに位置する言語だった。縁が切れたと思いきや、仕事でXHTMLから特定要素を抜き出す作業に使うことがあったり……。XMLからテキストレコードに変換してしまえば、後はUnix流テキストフィルタの世界が待っている。餅は餅屋というもので、定型的なXMLの変換はXSLTで記述するべきか。唯一気に入らないのは、xsl:sortでアルファベットの大文字と小文字を区別してソートすることができないこと。ぐぬぬぬ。

これから(また)使うかもしれない

bison (yacc)
プログラミング言語に含まれるかどうか不明だが、DSL扱いで。やっぱり構文解析系統のコードを自作するのは割に合わない――だなんてうそぶきつつ、LALR法とか全く知らないままに、既存のyaccのコードを切り貼りして遊んでみた。簡易電卓レベルだが便利さを体感しつつ、さっそくtypo 1文字で痛い目(shift/reduce)に遭った。とりあえず、flexと組み合わせた上でのエラー処理(エラーメッセージの改善)が課題だ。
C#
かつて、勉強を兼ねてC# 2.0を少し触ろうとするも未完に終わり、数年後にあらためてVisual Studio 2013をインストールして少しだけ触った*9けどほんの少しだけで終わった過去をもつ私。変数の型推論・ラムダ式・LINQ・デフォルト引数は便利だなあと思っていたら、いつの間にかC# 8.0になってKotlinやSwiftに見られる流行を取り入れてますな。おっちゃん、付いてくのが大変だよ。.NET Frameworkの機能数は反則ものだが、所々に微妙に抽象化が行き過ぎたAPIが見られるのは気のせいだろうか? それにしても、クラスが必須ではないC言語やC++に慣れてしまった弊害か、アプリケーション・メインエントリすらclass内に定義しなくてはならないC#には、なかなか慣れない。
Common Lisp
2009年に勉強しようと思い立ったものの、未だに進んでいない。階乗とかハノイの塔とかiotaぐらいは書いたが、目標は「ちょっとしたツールを自作する」だ。まだ道は遠い。最近は時々CLISPを簡易電卓代わりにしている。
F#
OCamlは「Windows上で日本語を扱う」という視点では処理系がちょっと微妙なので、いっそのことF#に乗り換えようかと……。『実践F#』が積読状態になっている。
flex (lex)
プログラミング言語に含まれるかどうか不明だが、DSL扱いで。字句解析用のツールという印象が強かったのだが、よく考えてみたら、flexは「sed(1)のよくある使い方」と同様に「正規表現でパターンマッチング --> 何らかのアクション」という内容を記述するためのツールだった。ただ単に、「何らかのアクション」をC言語で書けることと、flex自体ではパターンマッチングをせずに「パターンマッチングするC言語のコード」を生成することが少々風変わりなだけ。grep(1)やsed(1)その他で小ツールを実装して運用しつつ、性能が求められたらflexで専用ツール化する――とか考えたけど、普通にgrep(1)やsed(1)を使う方が高速だった。
Forth
pForthをMinGWでビルドしたので処理系は手元にある。スタック指向の言語はいつか勉強したい。
Free Pascal
お試しで触っているのだが、微妙にDelphi/Free Pascal初心者(ただし他言語の経験者)向けの良い資料が少なくて難儀している。玉石混交なのだ。いっそのこと『OBJECT PASCAL HANDBOOK: マルチデバイス開発ツ-ルDelphiのためのプログラミング言語完全ガイド』を買ってしまおうかしら……と思っていたら絶版っぽい。
Java
生まれて初めて触れたプログラミング言語その2。実のところ、職業プログラマとして本格的に使用することは一生ないと思っていた。Androidアプリ開発も、Kotlin採用後に本腰入れて関わるようになったので、Kotlinメインだ。だが、なぜかぬるい感じに時々Javaのコードを触っている。先にコレクションの操作方法が充実した他の言語を学んでからJavaを本格的に触るようになったので、Java 8以降のStream APIが使えないと身体が拒否反応を示す。少なくとも、構文の見た目こそ保守的なオブジェクト指向プログラミング・スタイルで書かれたC++に似ているけど、中身はC++とは似ても似つかない代物だということは体感している。
JavaScript(クライアントサイド)
ものすごく久しぶりにクライアントサイドJavaScriptのコード触った――いまどき珍しい、DOM直叩きスタイルだけど。収穫は、最近のECMAScriptのスタイルに触れたぐらいだろうか? フレームワークもTypeScriptも触っていないので、クライアントサイド開発のスキルは依然として賞味期限切れのままだ。:JavaScript(サーバサイド?):初めてお仕事でNode.js向けのJavaScriptのコードを触った。Web開発の外の人からみた印象としては、ブラウザ以外のJavaScript処理系はNode.jsに収斂しちゃった感があるなあ――Denoもあるけど、エコシステム的に今後どうなるんだろう?
LOGO
そういえばLOGOを触ったことがない。とりあえずUCBLogo(Berkeley Logo)だろうか? Windows上でUCBLogoばりにGUI無しで動作する処理系はないだろうか?
m4
その昔テキスト処理用に触ろうとして、Windows用のどの処理系も日本語の置換に何かしらの問題を抱えていたので泣く泣く諦めた。思うところがあって改めて少し触ってみたが――なるほど、確かに中毒性のある言語*10だ。
OCaml
Common Lispを勉強するはずが、いつの間にか触っていた言語。一応、階乗ぐらいは書いた。時間が取れたらもうちょっとしっかりと勉強したいが、面倒なのでF#に移行しようか検討中。
PostScript
これかForthか、どちらに手を出すべきか? 悩ましい。
Prolog
『7つの言語、7つの世界』の地図の色分けプログラムには衝撃を受けた。何というか「正しい問い」を見つけられるか否かが肝なのか。この辺は、根底の部分でAlloyに通じる何かがあるように思う。ひとまず、Prologで論理プログラミングと宣言的なスタイルに慣れておけば、形式手法にて「論理で宣言的に」記述するときに戸惑いが減るのではないかと期待している。
Rust
仕事柄「C/C++の次のシステムプログラミング言語」はそれなりに興味の対象で、今のお仕事的にはGo言語やD言語よりもRustがド直球の本命に近いはず……まあ、本筋とは外れたところでGo言語を使うことになるとか、そういうパターンはありそうだけど。ちなみに、これら3言語と同列にSwiftが挙げられることもあるようだが、個人的見解としては、システムプログラミング言語としてのSwiftには全く期待していない。あれは、Appleというしがらみからは逃れられないでしょうな。
VBA (Visual Basic for Applications)
今までVBAから逃げ回っていて、今のところ追いつかれてはいないのだが、どこかで使う(というか解読する)ことになりそうな予感。たぶん、Excel VBA 8割にAccess VBA 2割ぐらいかなあ。

今は全く使っていない

Active Basic
VBScripを触りだした影響で、時々思い出しては弄くっていた。ほんの少しだけ触って放置して、すっかり忘れてからまた触る――これを繰り返していた気がする。なので毎度初めて触るのと同じ状態だった。String型をバシバシ使用 :)
Alloy
形式手法の中では比較的カジュアルに使えそうなので期待中。入門書も処理系も入手した。私の場合、先に何か論理型の言語をかじった方がよいのかも。
bc
その昔、Windows標準の電卓アプリの代わりに使おうとして色々あって挫折した。今はirbかclisp/goshで計算しているからなあ。
CASL II
生まれて初めて触れたプログラミング言語その1。何だかんだで、後でCプログラマになってからも低水準での思考ツールとして微妙に役に立っている。まあ考えるための言語であって実用言語ではない。仮に実用的な処理系*11があったとしても余りに命令がシンプル過ぎて悶絶するなあ、なんてFizzBuzzしてみて思った。
Clojure, Scala
JDKがなくてもJava APIを叩くスクリプトを書けるので非常に便利。Scalaの型推論とか、便利っすね。言語仕様はJavaよりも好みだ。とはいえ、IoT時代にJava VMベースでどこまでメインストリームに居残ることができるのか? ちょっと興味深い。サーバサイドに活路を見出すのだろうか?
COBOL
FizzBuzzするためだけにOpenCOBOL 1.0をWindows上に用意して触ってみた。なんというか、COBOLの名前と生まれた時代が示すように基幹業務(というかお金や帳簿が絡んでくるところ)向けの言語だよなあ、といった感じ。COBOL 2002のフリーフォーマットを採用するだけでも使い勝手が変わる気がしたが、世の中にはまだ広まらないのだろうか。
CoffeeScript
仕事で使う予定はない。RubyやPythonその他の影響を受けているだけあり、その手のスクリプト言語っぽい感じでコードを書けるので、慣れれば素のJavaScriptで直接コーディングするよりは楽だ。しかし標準ライブラリ回りや処理系絡みの機能やサードパーティのライブラリなど、結局はJavaScriptを知らないとCoffeeScriptでコードを書けないと思う。それに生成されたJavaScriptのコードを見て「うわぁ、これあまり効率的でないなあ」と感じる時もあって、高速化が必要な部分では生成されるコードを気にしながら記述したりCoffeeScriptを諦めてJavaScriptで書くことになるので、やはりJavaScriptを知らないとマズイ。とはいえ便利なのは確かだ。CoffeeScriptのコードは即Node.jsで実行できるので、その辺りから「CoffeeScriptでテキストフィルタ」的な文化が生まれると面白いかも。気になるのはECMAScript 6の存在で、今までCoffeeScript独自の機能だった部分の多くがES6で取り込まれるので、今後ES6対応が進むにつれてCoffeeScriptの立場がどうなっていくのか、少々興味深い。
Coq
ソフトウェアの基礎が気になるので、処理系だけ入手。
D言語 2.x
仕事柄「C/C++の次のシステムプログラミング言語」はそれなりに興味の対象で、Go言語ほどではないが、D言語も気になる存在だ。D言語はシンタックスがC・C++に近いだけでなく、コーディングしている時のアプローチ・判断についても、CやC++での流儀がそこそこ通用しやすい気がする。少なくとも、Go言語でコーディングするよりは、文化的背景の違いによるモヤモヤは感じにくい。あと、標準ライブラリを使ってテキストフィルタを書いたところ、エラー処理を1~2ヶ所のtry - catchにスッキリまとめることができて、ちょっと驚いた。throwされる例外のメッセージ文字列が、ちょうどよい塩梅の内容だったため、メッセージを変更する(いったんcatchして、再throwする)必要がなかった。ちょっと残念なのは、マルチバイト対応だが……。
Emacs Lisp
「.emacsにコピペ」限定で。Common LispやSchemeを触ったためか、何となく内容を追えるようになってきた気がしていたが、勘違いだった。
Fortran
Fortran 90やFortran 95あたりは結構近代的な言語だと思う。用途次第ではC言語よりもFortranの方が遥かにマシな選択だろう。配列がらみの処理はFortranの方が得意だし、言語機能としてのモジュール化の方法はC言語には存在しない。可変長な文字列の扱いに微妙な制限がある点はマイナスな気もするが、まあ基本的に数値計算プログラム用の言語だからなあ。
GDB (GNU Debugger)
……いやGDBはデバッガとして使っているが、GDBのスクリプトを書く機会は(FizzBuzz以外に)ない。勉強不足なだけかもしれない。
Groovy
JDKがなくてもJava APIを叩くスクリプトを書けるので非常に便利。動的型付け言語っぽくいくもよし、@CompileStaticや@TypeCheckedで型推論するもよし。言語仕様はJavaよりも好みだ。コンソールアプリを書く人としては、オプション引数解析用の機能を標準で持っている点で、GroovyはClojureやScalaよりもポイントが高い*12。個人的には、IoT時代に「Java VMベース」の言語としてどこに活路を見出すのが、興味深く見守りたいところ。やはりサーバサイドだろうか?
HSP (Hot Soup Processor)
FizzBuzzで楽しんでみたが、何というか他言語経験者には受けが悪そうな命令体系だと思う。もっとも初心者がプログラミングという行為に深入りせずにWindows用のGUIな何かを作る分には、あの命令体系でも十分な気がしないでもない。ところで元々は「HSPで職業プログラマ的な良いコードを書くと、どんな感じになるか?」というネタを思いついて処理系を用意したのだけど、そちらは全く進展がないまま。
Io
プロトタイプベースである点を除けば、何となくSmalltalk的であるような――公式ドキュメントらしきIo Programming Guideでも影響を受けた言語として真っ先にSmalltalkが挙げられているから、あながち思い違いでもないだろう。今更ながら『7つの言語 7つの世界』のIoの章を読み終えたので、ちょっとしたコード片を書いているが……Windows版のバイナリが古いためか、リファレンス通りなのに動作しないコードに直面している。
JScript on WSH
他人が使うテキスト処理ツールの実装に使って以来、時々触ってきた。Windows用の配布可能な小ツールを実装する時の定番言語だった。でもそろそろ潮時だろう。HTAと組み合わせてクライアントサイドJavaScriptなノリで簡易なGUIツールを実装できる点も、PowerShell + WPF + XAMLで代替できそうだ。他のメリットは「JavaScript(ECMAScript)でフィルタを書ける」だったが、WSHのなかなか目的にたどり着けないオブジェクト階層にイライラするよりも、Node.jsやPhantomJSを使ったほうが精神衛生的にマシだ。
Object REXX
思うところがあって処理系とIBM謹製のドキュメントを入手したものの、そこから先の進展は無いまま。ReginaでClassic REXXっぽい感じで触っているからなあ。
Oz
『Scheme手習い』の次はCTMCP片手にOzで勉強かなあ。道は遠いな……。
Processing
入門書も処理系も入手して、あとは弄る時間をつくるだけ。
QML
宣伝文句のとおり、QMLはGUIの記述に非常に向いている。それも、単に標準のUI部品(エレメント)を使うだけでなく、少し改造して使うとか、オリジナルのUI部品を作って使うとか、それらを別のアプリケーションに使いまわすとか、そういう時に威力を発揮する。あと、プロパティバインディングやレイアウトのアンカー指定など、画面サイズの変更に追随するUIを作りやすい機能も揃っている。JavaScriptでちょっとした処理も記述できる――とはいえ、やりすぎるとパフォーマンスの罠が……。少なくとも、JavaScriptでゴリゴリコードを書くのはQML的ではない。QMLは宣言的に、シンプルに書くものだ。力技でロジックでゴリ押しすると、色々と罠に嵌る言語だ。
REXX
Open Object REXXの処理系を入手したのに、何故かReginaを入れてClassic REXXっぽい方向に走っていた。何というか、COMコンポーネントや.NET Frameworkと無関係でいられるのなら、バッチファイルの代替としてはREXXあたりがほどよい塩梅だと感じる。しかし最近流行の言語とは随分と勝手が違うし、日本語の情報も少ない。メインフレーム以外の世界で流行る可能性は少ないだろう。
Smalltalk (Squeak, Pharo)
Smalltalkは有名な古典的プログラミング言語だというのに、触ったことがない。ということでSqueakとPharoの処理系のみ準備完了。うーん、「環境」付きなのが気になる――言語を弄くる基準が「コンソール上でテキストフィルタ」という変な人種な私だからなあ。
Smalltalk (GNU Smalltalk)
個人の思想信条による理由よりSqueakとPharoにわだかまりを感じてしまう変人なので、邪道だと思いつつもコンソールでテキスト処理もOKなGNU Smalltalkも用意してみた。これで言語としてのSmalltalkの勉強に集中できる……か?
T4 Text Template
「へえ、こんなものがVisual Studioに入っていたのか。機能多すぎで色々と便利なツールを見逃しているんだな、やっぱり」と思いつつ触ってみた。テンプレート変換の用途ではピカ一だと思う。ただ処理系を手に入れる方法が「Visual Studioをインストールする」or「MonoDevelopをインストールする」なので、何となく「単体で手軽に使えるツール」ではないというイメージが……。まあC#やVBで処理を記述するので、それらの処理系が必要だという面での制約なのだろう。
VBScript on WSH
JScriptほどではないが「Windows上で他人も使えるツールを書くためのLL」扱いしていた言語。Windows Server管理の関係で触っていた。というかWebで入手可能なWSHのサンプルの大半がVBScriptで書かれていたり、ADSI関連のコレクションをJScriptで舐めれなかったりして、結局は必要に駆られて使用することに。明快に記述できる文法は評価に値するが、スクリプト言語としては少々冗長だ。配列は自動拡張しないし、組み込み関数はプリミティブ気味だし、冗長気味な文法との合わせ技でコードがさらに冗長になっていく……。文法や言語仕様の詳細なドキュメントが見つからないのだが、どこにあるのだろうか?*13
Vim script
少し触ってみた分には、exコマンドの拡張(=コマンドの羅列)とは気づかない程度にはプログラミング言語らしいと思う。とはいえ妙なところで嵌ったり微妙に一貫性のない部分があったりするので、その辺りで好き嫌いが別れる気がする。
秀丸マクロ
7年ほど秀丸エディタを使っていたが、マクロを書く機会はなかった。一念発起してFizzBuzzしてみて感じたのは、最近の便利な言語に慣れた身としては色々とモヤモヤ感がある言語仕様だということ(歴史的経緯的に仕方ないのだが)。とはいえちょっとした拡張ツール的なものを手軽に作れそうではあった。

*1:「HTML5 + CSS」の組み合わせなら、チューリング完全の疑惑があったり、JavaScript使わずにCSSでWebチャットを作った猛者がいたりと、色々と怪しいのだけど。

*2:「独立性の高い単体のツールを実装する」という視点では、現代ではAWKよりも便利な言語が山ほどある。

*3:少なくともC++の言語/ライブラリ仕様は私の手には余る。自分が把握している範囲の機能でコードを書くのは好きなのだけど。

*4:支障がある部分を触るほど深入りするには、あと20年ぐらい掛かるのではないか?

*5:これでもsedはチューリング完全な言語だと証明されているらしい。

*6:私の認識では、JavaScriptは、第一級関数やクロージャがお仕事用のメジャーな言語に組み込まれて、少なくない人が使う契機となった言語だ。

*7:Kotlinのvalは「再代入不可の変数」だ(定数はconstで定義する)。Kotlinのプリミティブ型以外のデータ型はclass(つまり参照型)なので、valで定義した変数を破壊的操作する行為は割と普通だと思う。一方でSwiftのletは定数であるし、値型が中心の言語仕様である影響かstructやenum(つまり値型として振る舞うデータ型)が多用されるので、letで定義した変数を破壊的操作できるケースとできないケースが生じる。

*8:Windowsのことを考えなければ、自前でライブラリをビルドしてアプリに組み込むのは結構簡単だった。

*9:言語仕様的にはC# 5.0の環境だが、ライブラビまわりはC# 4.0相当だったはず。

*10:m4はマクロプロセッサなのでプログラミング言語ではないはずだけど……。

*11:――といってもシミュレータだけど。

*12:ClojureやScalaに関しては、同様の機能を私が見逃している可能性も高いのだが。

*13:MSDNの資料では物足りない。もうちょっと掘り下げた内容のものが欲しい。

malloc/newは遅い、ならどうすればよいか?

C/C++でのプログラミング歴が長くなると、肌感覚としてmalloc(3)やnewが遅いということが分かってくるものだ。

そもそも、21世紀の4分の1が経過したのに未だにC/C++を使っている連中(私もそうだ)の多くは、リアルタイム性に関して一定以上の要求を抱えるソフトウェアを書いている。実行速度を気にしざるを得ない環境に身を置いている。

フリースタンディング環境が主戦場ならば、malloc(3)を使えるようにするために面倒な下準備が必要だ(実はそれだけ複雑で面倒な仕組みなのだ、動的メモリ確保は)ということを知っているはずだ。

malloc(3)を組み込むための作業でsbrk(2)の存在に気付く人もいるだろう。フリースタンディング環境ならいざ知らず、ホスト環境でのsbrk(2)は、古典的にはシステムコール――カーネルモードで動作する代物だ*1。モダンなUnix環境ではsbrk(2)ではなくmmap(2)が用いられるが、これまたシステムコールだ。毎回ではないものの、システムコールが呼ばれる可能性があるならば、実行速度の面で不利を抱える可能性はあるよね――という想像はできる。

もちろん、普通に開発環境に付属してくるmalloc(3)やfree(3)には、高速化のためにある程度のチューニングが施されている。

それでも、だ。

ホスト環境が主戦場の場合に、具体的なmalloc(3)やnewの所用時間を把握している人こそ少ないものの*2、しかし「ホットスポットとなっている関数内で毎回malloc(3) / free(3)を繰り返していたコードを書き直したら処理時間が半分になった」みたいな事象の経験者は結構多いものだ。

malloc(3)やnewのようなプリミティブな動的メモリ確保の機能を直接使ってなくても、例えばホットスポットの関数の自動変数でstd::vectorのような「内部で動的メモリ確保を行うデータ型」を使用していて、似たような遅さの問題を抱えていることもある。

この辺の感覚はGCありの言語とは異なる。

GCアリアリのモダン言語は、処理系(仮想マシン)やランタイムライブラリ込みで高速化のための工夫がなされている。動的メモリ確保に関していえば、GCの仕組み上メモリ解放が先送りされる効果がある*3。インスタンスの枠を越えて確保済み領域の再利用が試みられる可能性もあるだろう*4。

C/C++には、そんな便利な仕組みはない。動的メモリ確保に関して言えば、高速化に結びつくような分厚い抽象化層はデフォルトでは用意されておらず、モダン言語と比較してプリミティブで薄い抽象化層の上で下位層の事情を勘案しながらガンバリズム――というのがC/C++プログラマの宿命なのかもしれない。

動的メモリ確保が遅いのなら、どう対応すればよいだろうか?

一般に、C/C++プログラマは以下のアプローチを模索するだろう。

  1. 動的に確保しない。静的メモリ確保に置き換える。
  2. 動的メモリ確保の回数を減らす。
  3. より高速なmalloc(3)の実装に切り替える。
  4. malloc(3)を自作する。

まず考えるべきなのは (1) と (2) だ。大抵はこの範囲で解決できる。

(1) や (2) を経たうえで、それでも問題が解決しない場合に登場するのが (3) と (4) だろう。

動的に確保しない。静的メモリ確保に置き換える。

静的メモリ確保への置き換えの例でありがちなのは「一時作業用のバッファ領域」だ。処理するデータ数の上限が不明ならばstd::vectorあたりを使うしかないが、上限が存在するならCスタイル配列やstd::arrayで代替する余地がある。C++26以降ではstd::inplace_vectorという選択肢もある。

注意点として、静的メモリ確保を使用するなら「どこにメモリが確保されるか?」という点を気にしなくてはならない。

一般に、関数内のブロックスコープにstatic指定子を付けずに定義した変数は自動変数となり、関数呼び出し時にスタック領域に確保される。OSにもよるが、スレッドに割り当てられるスタック領域のデフォルトサイズはあまり大きくない。なので、巨大なオブジェクトを自動変数として定義すると、容易にスタックオーバーフローを引き起こしてしまう。

自動変数以外には静的変数があるが、こちらは深く考えずに使用すると関数のリエントラント性の問題を引き起す。ある関数の中で静的変数を直接参照・変更してしまうと、その関数はリエントラントではなくなってしまう。

書いているプログラムの構造上、リエントラントでなくても問題ない関数なら、それで構わないだろう。しかし複数のスレッド・コンテキストから実行されうる関数ならば、例えば関数の開始から終了までの期間をミューテックス/バイナリセマフォ/クリティカルセクションで排他して、逐次再使用可能にする必要があるだろう(そして排他によるブロッキングが悪影響とならないことを検討・検証しなくてはならない)。

動的メモリ確保の回数を減らす。

もう少し手軽で、しかし手練れなC/C++プログラマなら暗黙のうちに選択しているだろう手法が「動的メモリ確保の回数を減らす」だ。

先ほど「ホットスポットとなっている関数内で毎回malloc(3) / free(3)を繰り返」す例を持ち出したが、もしもその関数が何らかのクラスのメンバ関数(メソッド)であり、かつリエントラント性を考えなくてもよいのなら、メンバ変数(インスタンス変数)にして使い回せばよいだろう。

ホスト環境においては、realloc(3)をサイズを縮小する方向で使う分には、内部処理が高速なことを期待しても罰は当たらないことが多い。サイズを拡大する場合には、再確保するサイズを指数関数的に増やしていくことでrealloc(3)の呼び出し回数を減らせるかもしれない(この手法はstd::vectorの実装にも見られたはずだ)。関数内で毎回malloc(3)してfree(3)するよりも、必要に応じてrealloc(3)を交えつつ再利用した方が、その関数が繰り返し呼び出された場合にトータルの処理時間が短くなる可能性がある。

C++での類似例はstd::vectorだろうか? メンバ関数の自動変数として定義するのではなく、メンバ変数として定義して使い回すのだ。std::vectorは高速化のために「確保したメモリ領域を解放せずに再利用する」という挙動をとる。なので、使い回すことでstd::vector内部での動的メモリ確保の回数が減り、高速化につながる可能性がある。少なくとも関数呼び出しの度にメモリの確保と解放が行われるよりはマシだろう。

もう少し手の込んだ手法としては、オブジェクトプールやメモリプールも考えられる。事前に、特定のデータ型向けにまとまったメモリ領域を確保しておき、確保済み領域から切り出して使用する。使い終わった領域は後で再利用される。

オブジェクトプールは万能ではない。どちらかと言えば、実装するソフトウェアの性質よりオブジェクトプールが有効だと判断した場合に、特定のオブジェクトの管理において採用する、というアプローチが主流だ。

元来、C/C++の動的メモリ確保に関する抽象化層はプリミティブで薄い。オブジェクトプールの採用は、抽象化層を厚くしようという試みに他ならない。そして効果的な「厚い抽象化層」を設けるのは非常に大変な作業である。GCありの言語の設計・実装者は多大なコストをかけて厚い抽象化層を整備しているのである。

まあ、実際にオブジェクトプールを採用するとなったなら、C言語はいざ知らずC++ではallocatorやmemory_resourceなどの小技を効かせられる余地がある――それが良いのか悪いのか、私には判断できないが。

より高速なmalloc(3)の実装に切り替える

動的メモリ確保に起因するパフォーマンスの問題があるが、ここまでに挙げた方法では解決しきれない、あるいは巨大で歴史のあるコードベースなので手を入れるにも限界がある――といった場合に、malloc(3)の実装の置き換えを検討することがある。

標準的なmalloc(3)の実装は汎用的で、かつ安定している。一方で、特定の環境や用途向けにチューニングが施されている訳ではない。

ということで、特に大規模なソフトウェア・システム向けにカスタマイズされたmalloc(3)の実装が出回っている。オープンソースでの有名どころだと、以下が挙げられる。

残念ながら、これらの実装は銀の弾丸ではない。malloc(3)の実装を切り替えたとしても、大抵のケースでは性能差は微々たるものである。なぜならば、ボトルネックが別の場所に存在するからだ。

要するに、ボトルネックが動的メモリ確保に起因していることが判明していて、かつ、色々と手を尽くしたが限界に突き当たった場合に、初めてmalloc(3)を疑うべきだろう。多くのシチュエーションではmalloc(3)ではなくコードを書いた人(時に自分自身)が悪いものだ。

malloc(3)を自作する

「より高速なmalloc(3)の実装に切り替える」の亜種として、malloc(3)の自作がある。

そもそも汎用かつ高速なmalloc(3)には限界があって、本当に高速化したいなら用途ごとにmalloc(3)を書け――なんて話がある。私は寡聞にして知らないが、おそらく特定の領域においては実用的なmalloc(3)を自作した人がちらほら存在するはずだ。

※C言語だと「malloc(3)を自作する」となるが、C++ではallocatorの自作で済むことが多い気がする。

まあ、世の中には「高速なmalloc(3)の実装」が複数存在していて、どれも徹底的なチューニングが施されている。これらを出し抜くのは大変だ。おのずと「今、書いているソフトウェア」に特化した設計・実装を推し進めることになるのだが、しかし解くべき課題を抽象化して俯瞰した際に「全くもって新しい問題」であるケースは驚くほど少ない。大抵は先人がすでに遭遇した問題であり――要するに自分が取り組んでいるソフトウェアにマッチしたmalloc(3)の実装が既に存在している可能性がある。

今はGitHub等で自作コードを公開している人も多いからなあ。

結局どうすればよいの?

分野にもよるだろうけど、普通に仕事でC/C++のコードを書いている分には:

  • 動的に確保しない。静的メモリ確保に置き換える。
  • 動的メモリ確保の回数を減らす。

この2点で何とかなることが多い。自前のallocatorを書くにしても、大抵はオブジェクトプールとかで済む。

この2つの方針を愚直に守ってきたけどもう限界だ、という場合にmalloc(3)の実装を置き換えることを検討することになる。そして、そこまで到達することは少ないだろう。

*1:ただしLinuxではsbrk(2)はシステムコールではなくライブラリ関数で、brk(2)のラッパーとして実装されている。

*2:注意:所用時間を把握している人が皆無だとは言っていない。偶に知っている人がいるから困ってしまう。

*3:その分ドツボに嵌ることもあるが。

*4:実際に、JavaのJVMやPythonのCPythonには、数値や文字列用のメモリプールが組み込まれているようだ。

「後でソースコードを整理する」は十中八九実現しない

一気呵成に「とりあえず動く」というレベルのコードを書いてしまい、後で整理しようとする――というパターンの開発を何度か見かけたことがあるのだが、その多くが結局整理されないままか、整理不十分なまま代々引き継がれていき、後進が苦労する羽目となっていった。

観察した範囲では、大抵は以下の3パターンが原因で失敗するようだ。

  1. 「後で」の頃にはコード整理のコストをかける余裕がなくなっていた
  2. 「後で」の頃には手遅れなほど汚くなっていた
  3. 「後で」の頃には担当者が変わっていた

アジャイルではない、従来的な開発スタイルの場合、「後で」のタイミングは大抵「開発期間の後期」になり、他にやるべきことが多々あるために、コード整理は後回しにされがちだ。そして往々にして、結局は整理されないままリリースされてしまうだろう。

また、「とりあえず動く」の度合いも開発者の力量に左右される部分がある。単純な「式や文のリファクタリング」とか、クラスや関数にヘッダコメントが無いので書くとか、そういったレベルで済むのならよいだろう。しかしデータ構造などの内部設計の根幹に関わる部分に問題があるならば、実質的にコード整理ではなく再実装となり、作業コストが跳ね上がってしまう。モジュール間のインターフェースに問題があるならば、複数のモジュールを巻き込んだ大掛かりな変更作業となるだろう。

厄介なのは、モジュールにたいする大掛かりな変更は、時に単体テストではカバーできない破壊的な「振る舞いの変化」を生んでしまうことがある、ということだ。例えばコールバック関数を経由して外部に何らかの通知を行うモジュールの場合、モジュール内部の大掛かりな変更によって、意図せず「異常系のコールバック通知の順序やタイミング」が変化してしまうことがある。外部のモジュールが従前の動作に基づいたアンドキュメントな仕様――例えば「このタイミングでエラーがコールバック通知される」という前提による実装をしていたなら、複数のモジュールを組み合わせて試験しないとエンバグに気づかないだろう。そして残念なことに、モジュールを組み合わせて試験しても気づかず見過ごしてしまう可能性が大いにある。

ここまでに挙げたような問題があるものの、それでも自分が書いたコードについて自分自身で始末をつけるならば、まだマシなのだ。長期に渡るプロジェクトではメンバーの入れ替えが発生することがある。後から入ってきた開発者には、前任者の頭の中は見えない。前任者が書いた「とりあえず動く」の品質レベルが非常に悪く、かつ解析の助けとなるような外部資料も存在しないとなれば、そのコードはアンタッチャブルとなるだろう。

結局のところ、後でソースコードを整理することができるのは:

  1. コード整理のコストをかける時間的余裕がある。
  2. 「とりあえず動く」レベルといえども、そこそこ品質が保たれているコードである。
  3. コードを書いた人と整理する人が同じ(もしくは書いた人がすぐ近くにいる)。

――という条件全てを満たしている場合だ。もちろん例外もあるが、例外は例外らしく外れ値と見做すべきだろう。

そして残念ながら「上記の条件全てを満たす」こと自体も例外、つまり外れ値だ。後でソースコードを整理しよう、だなんて滅多に考えるものではない。

WindowsでVimを使う環境を再構築した

事ここに至りWindowsのCLI上にコーディング環境を構築せんと大号令をかけたのである。

Windows Terminalが組み込まれ、Unix環境のX Window Systemで端末エミュレータを使うのと似たような作業環境を構築できるようになった。そうなると、自然に「ちょっとしたコーディングもCLI環境上でできるようにしたいなあ」という要求が生じるものである。

まあしかし、MS-DOSからWindowsへの移行を経て、Windows向けのテキストエディタは軒並みGUIアプリになってしまった。特に、日本語環境という世界的に見ても特異な文字エンコーディング多発地帯において、己の半身となりうるCLIのエディタはごくわずかだろう。

Vimを選んだのにはいくつか理由がある:

  1. 日本語Windows環境での文字エンコーディングの扱いの点で実績がある。
  2. 元々Vim 香り屋版を使っていた。
  3. LinuxやmacOSで使用していた「自分好みの設定」があり、流用可能だった。

(1) だけならEmacsという選択肢もあった。

ここ数年はVisual Studio Codeを使っているが、それよりも前にはVimを多用していた時期もあった。香り屋版とはVim 6時代からの付き合いである。

問題は「Vim 6時代からの付き合い」という点だ。Vimにプラグイン機能が組み込まれる遥か前に色々と弄った環境という「秘伝のたれ」に、新たにビルドされた香り屋版のバイナリという「新しいたれ」を継ぎ足してきたため、色々と限界だった。

ということで、公式バイナリで新規に環境構築することにした。ベースとなる_vimrcはLinuxやmacOSで使っていた最小構成の.vimrcを流用した。

ついでにLSPにも対応させた(LinuxやmacOSでは使っていない)。プラグインの組み込みはこんな感じ:

" XXX ホームディレクトリではなくvim.exeと同じディレクトリ上のvimfilesに色々置く。
call plug#begin($VIM . '/vimfiles/plugged')

Plug 'prabirshrestha/vim-lsp'
Plug 'mattn/vim-lsp-settings'

Plug 'vim-denops/denops.vim'
Plug 'Shougo/ddc.vim'
Plug 'Shougo/ddc-around'
Plug 'LumaKernel/ddc-file'
Plug 'shun/ddc-vim-lsp'
Plug 'Shougo/ddc-converter_remove_overlap'
Plug 'Shougo/ddc-matcher_head'
Plug 'Shougo/ddc-sorter_rank'
Plug 'Shougo/pum.vim'
Plug 'Shougo/ddc-ui-pum'

call plug#end()

LSPについてはC/C++のみ設定している。

let g:lsp_settings_servers_dir = $VIM . '/vimfiles/etc/lsp'

let g:lsp_settings = {
\   'clangd': {
\     'cmd': [
\       g:lsp_settings_servers_dir . '/clangd/clangd',
\       '--clang-tidy',
\       '--enable-config'
\     ],
\   }
\ }

補完とポップアップ表示まわりはddc.vimとpum.vimの組み合わせを採用した。

call ddc#custom#patch_global('sources', [
\   'around',
\   'file',
\   'vim-lsp'
\ ])
call ddc#custom#patch_global('sourceOptions', {
\   'around': {'mark': 'around'},
\   'file': {
\     'mark': 'file',
\     'isVolatile': v:true, 
\     'forceCompletionPattern': '\S/\S*'
\   },
\   'vim-lsp': {
\     'mark': 'LSP', 
\     'matchers': ['matcher_head'],
\     'forceCompletionPattern': '\.|:|->|"\w+/*'
\   },
\   '_': {
\     'converters': ['converter_remove_overlap'],
\     'matchers': ['matcher_head'],
\     'sorters': ['sorter_rank']
\   },
\ })
call ddc#custom#patch_global(#{
\   ui: 'pum',
\   autoCompleteEvents: ['InsertEnter', 'TextChangedI', 'TextChangedP'],
\ })
call ddc#custom#patch_filetype(['ps1', 'dosbatch', 'autohotkey', 'registry'], {
\   'sourceOptions': {
\     'file': {'forceCompletionPattern': '\S\\\S*'},
\   },
\   'sourceParams': {
\     'file': {'mode': 'win32'},
\   }
\ })
call ddc#enable()

補完候補については、矢印キーやCtrl-n/Ctrl-pで操作した場合にはポップアップ上の候補の選択だけ変更するようにした。以下のような感じの設定で、よくあるGUIテキストエディタで補完候補を選択・決定・取り消しする操作と似た感じになる。

inoremap <expr> <CR>  pum#visible() ? "<Cmd>call pum#map#confirm()<CR>" : "<CR>"
inoremap <expr> <ESC> pum#visible() ? "<Cmd>call pum#map#cancel()<CR>"  : "<ESC>"

inoremap <expr> <Tab>   pum#visible() ? "<Cmd>call pum#map#insert_relative(+1)<CR>" : "<Tab>"
inoremap <expr> <S-Tab> pum#visible() ? "<Cmd>call pum#map#insert_relative(-1)<CR>" : "<S-Tab>"
inoremap <expr> <Down>  pum#visible() ? "<Cmd>call pum#map#select_relative(+1)<CR>" : "<Down>"
inoremap <expr> <Up>    pum#visible() ? "<Cmd>call pum#map#select_relative(-1)<CR>" : "<Up>"
inoremap <expr> <C-n>   pum#visible() ? "<Cmd>call pum#map#select_relative(+1)<CR>" : "<C-n>"
inoremap <expr> <C-p>   pum#visible() ? "<Cmd>call pum#map#select_relative(-1)<CR>" : "<C-p>"

inoremap <expr> <PageDown> pum#visible() ? "<Cmd>call pum#map#select_relative_page(+1)<CR>" : "<PageDown>"
inoremap <expr> <PageUp>   pum#visible() ? "<Cmd>call pum#map#select_relative_page(-1)<CR>" : "<PageUp>"

さて、上記の設定にて、Vim 9.2.0ではいい感じに利用できているのだが、Vim 9.2.0125との組み合わせだと少々問題があるようだ(おま環案件かもしれないが)。

pum#map#select_relative()で選択候補を変更した時、内部での候補の変更は正常に動作しているようなのだが、見た目として「どこ候補を選択しているか?」が分からなくなってしまった。

Vim 9.2.0の時点では、選択候補の表示中の「マッチしていない文字列」の部分の色が変化することで、ぱっと見でどの候補を選択しているかを識別できた。Vim 9.2.0125では、この「色の変化」が無くなってしまったため、どの候補を選択しているか分からないのだ。ただし、内部での「どの候補を選択しているか?」という情報は正しく切り替わっている。

この現象について報告したいのだが、如何せんddc.vimとpum.vimの部分はあれもこれもプラグインだらけであるし、組み合わせに関する設定をあれこれ.vimrcに書く代物なので、ある程度問題の切り分けを行わないと報告先すら覚束ない。ということで放置している。

追伸

Microsoft Editにシンタックスハイライト機能が組み込まれていたなら、それをそのまま使い続けただろう。でも残念ながら組み込まれていない。

GUIになるが、最近色々と進化しているメモ帳も、シンタックスハイライトには未対応だ。

今日日テキストファイルを使う理由の大半はMarkdownなりプログラミング言語なりで「構造化された文字列」を記述することなのだから、シンタックスハイライトの需要は多い気がするのだけどなあ。

C言語で書かれたソースコードをC++化する

C言語で書かれたソースコードをC++化する作業に関わったので、メモを残しておく。

前提条件

  • 主にC++やC言語で構成されたアプリケーションにおいて、中間層に位置するコンポーネントの1つとして、C言語で書かれたライブラリがある。
  • このライブラリは今後も積極的に手が加えられることが見込まれるが、さすがにC言語では色々と厳しくなってきたので、C++に移行する。
    • このコンポーネントを挟む上位層も下位層もC言語ないしC++で書かれている。現状ではC/C++以外の言語を選択することは適切ではないと判断した。
  • C++化の初期段階として、まずは公開インタフェースは既存の(C言語の)ままに、内部実装を「Better C」化することにした。
    • つまり、ヘッダファイルには極力手を入れず、ソースファイルを弄っていく。
    • 余裕があれば、公開インタフェースについても多少のC++化を行うかもしれない。
  • C++の言語仕様としてはC++20以降を想定する。

作業の流れ

  1. 最低限のC++化(C言語からC++への置き換え)
  2. 機械的に対応可能な「Better C」化
  3. 必要に応じて:
    • より高度なC++化
    • 公開インタフェースのC++化

最低限のC++化(C言語からC++への置き換え)

まずはBetter C化を行うための土台作りから。

  1. ソースファイルのサフィックス(拡張子)を.cから.cppに変更する。同時に、使用しているビルドシステムに登録されているソースファイル名のサフィックスも変更する。
    • サフィックスについては、対象プロジェクトに応じて.cpp以外の形式も検討する。
    • 興味深いことに、伝統的なmake(1)を用いるプロジェクトにおいては、Makefileの書き方次第では「ソースファイル名の変更に伴う対応」が不要な場合もある。
  2. 公開インタフェースについて、外部にCリンケージとして見せるようにする。
    1. ヘッダファイルで公開している関数・変数の宣言にextern "C"を付与する。
    2. ソースファイル中の公開関数・グローバル変数の定義にextern "C"を付与する。
  3. ソースコード内のインクルードディレクティブについて、必要に応じてextern "C"を付与する。
    • C言語で書かれたライブラリのヘッダファイルの中には、時々「C言語以外で書かれたソースファイルに取り込まれること」を想定していないものがある。
  4. この段階で一度、C++コンパイラでコンパイルしてみる。
    1. コンパイルエラーが発生した場合には、該当する部分を確認して修正する。C言語からC++に移行する場合には、次のような点が問題となりやすい。
      • ポインタ型の型変換。型チェックの強化にともない、C言語ではセーフだった「ポインタ型から、別のポインタ型への変換」まわりでエラーとなることが意外とある。
      • 整数型から列挙型への型変換。型チェックの強化により、明示的なキャストが必要となった。
      • 型定義のネスト。構造体の定義中で別の構造体/共用体/列挙体を定義している場合、C言語とC++では名前のスコープが異なることが原因でコンパイルエラーとなることがある。
    2. エラーにはならないが警告がでることもある。この場合も、該当する部分を確認して修正する。
      • 型チェックまわりで警告がでるようになることが多い、という印象がある。
  5. コンパイルエラーや警告メッセージへの対応を行うことで、最低限の「C言語からC++への置き換え」が完了する。

機械的に対応可能な「Better C」化

以下の対応はソースファイルにたいしてのみ実施する(外部には引き続き「C言語時代のAPI」をそのまま公開するため、ヘッダファイルはBetter C化しない)。

  1. インクルードしている標準ライブラリのヘッダファイル名をC++のものに置き換える。
    • 例えば#include <string.h>を#include <cstring>に置き換える、みたいなこと。
  2. NULLマクロからnullptrキーワードに置き換える。
  3. climitsやcstdintなどに定義されていマクロ定数からstd::numeric_limitsの静的メンバ関数への置き換えを検討する。
  4. 不要なtypedefを削除する。
    • 例えばstruct FooをFooとだけ記述するためにtypedef struct Foo Foo;と定義することは、C++では不要である。構造体だけでなく、共用体や列挙体でも同じくtypedefは不要となる。
  5. typedefから「usingを使用した型エイリアス」に移行する。
  6. 構造体と共用体の定義にfinal指定子を付けて派生を禁止する。
    • C言語時代に定義された構造体や共用体は、派生元となることを想定した実装になっていないので、ひとまず明示的に派生を禁止しておく。
    • 後で必要に応じてfinalを止めて派生を解禁していく。
  7. 関数の宣言・定義にnoexceptキーワードを付けて「例外を送出しない」ことを明示する。
    • C言語時代に定義された関数が例外を送出することはない……はず。なのでひとまず明示しておく。
    • C++化を進めていく過程で例外が発生するようになった場合は:
      • コンポーネント内部の非公開関数では、例外を送出する可能性が出てきた関数からnoexceptキーワードを削除する。
      • コンポーネントの外部に公開される関数では、try-catchを使って例外が外に出ないようにしつつ、何かしら問題が発生したことを別の方法(例えば戻り値のエラーコードなど)で通知するようにする。なぜならば、元々C言語で実装されていたコンポーネントを使う側では、例外が送出されることを想定していない(だってC言語だよ?)可能性が高いからである。
  8. 関数の定義にて、ビルド時に未使用の引数についての警告が出力されないように(void) foo;みたいなことをしているケースにおいて、引数リストから仮引数の名前を削除する(型名は残す)方法に置き換えることを検討する。
    • C++では合法である。
  9. 非公開関数やファイルスコープ変数を無名名前空間に移動した上で、static指定子を削除する。
  10. 明示的な型キャストをCスタイルからC++スタイルに置き換える。
  11. 定数の定義をプリプロセッサ(マクロ)からconstexprに置き換える。
  12. 列挙体に基底の整数型を指定することを検討する。
    • enum classじゃない従来式のenumでも型指定できる。
  13. 従来の列挙体からenum class(スコープを持つ列挙体)への置き換えを検討する。
  14. ローカル変数を宣言している部分について、型名からautoへの置き換えを検討する。
  15. 非公開関数の引数について、ポインタから参照への置き換えを検討する。
  16. (C99よりも前のコードベースの場合)独自のブーリアン型からboolへの置き換えを検討する。
  17. (優先度:低)コメントをCスタイルからC++スタイルに置き換える。
    • 1行コメントなどは正規表現で変換しやすい。
    • 装飾を伴うヘッダコメントの類は機械的な変換が難しいので、あえて対応せず既存のままとする。

より高度なC++化

ここから先は、機械的な対応が難しく、少し大掛かりな変更となるので、慎重に進める。引き続きソースファイルにたいしてのみ実施する。

  1. POD (Plain Old Data) でなくても構わない構造体・共用体について:
    1. memset(3)によるゼロ埋めから、コンストラクタ呼び出し時の初期化(非静的メンバ変数の初期化も含む)への置き換えを検討する。
      • メンバ変数の値を初期値に戻すようなメンバ関数(例えばclearやresetみたいなやつ)を定義して使用する、でもよい。
    2. 比較演算などの特定の処理について、関数呼び出しから演算子オーバーロードへの置き換えを検討する。
      • algorithmなどの標準ライブラリの機能と組み合わせやすくなる。
  2. 一時的な用途の複合型として構造体を定義して使用している部分について、std::tupleやstd::pairなどへの置き換えを検討する。
  3. C言語文字列からstd::stringやstd::string_viewへの置き換えを検討する。
    • リテラル構文についても検討する。
  4. 組込み配列からstd::arrayなどのコンテナへの置き換えを検討する。
  5. 従来のmalloc(3)/free(3)でオブジェクトを管理している部分について、スマートポインタの導入を検討する。
  6. スレッド間の同期用プリミティブとして「volatileな整数型」を使っている部分をstd::atomicに置き換える。
    • 必要に応じて「適切なメモリオーダー」を指定することも検討する。
  7. 「任意の型のオブジェクトへの参照」を引き渡すためにvoid *を用いている部分について、std::anyやstd::variantへの置き換えを検討する。
  8. スコープを超えて「任意の型のオブジェクト」を引き渡すためにvoid *と動的メモリを用いている部分について、std::anyやstd::variantを用いて実体を引き渡すことを検討する。
  9. 関数ポインタから関数オブジェクトへの置き換えを検討する。
    • 関数ポインタ型からstd::functionに置き換える。
    • 関数を定義するのではなく、ラムダ式を用いてインラインに定義する。
  10. ブロックスコープを用いて「関数内のごく一部で使用する変数」を定義して使用している部分について、状況次第でif・switch・範囲forの初期化式を用いる方法への置き換えを検討する。
  11. 従来のfor文を用いてシーケンスを辿っているコードについて、以下への置き換えを検討する。
    1. 標準ライブラリのalgorithmの機能。
    2. 標準ライブラリのnumericの機能。
    3. 範囲for
  12. 論理的に同じ機能を提供する関数群があり、関数名の衝突を避けるために異なる名前を付けていた場合に:
    1. 関数の多重定義(オーバーロード)を利用して、関数名を統一することを検討する。
    2. 関数内の式・文の論理構造まで同一(異なるのはデータ型だけ)である場合には、関数テンプレートを利用して、関数の実装を含めて統一することを検討する。
  13. 関数形式マクロからインライン関数や関数テンプレートへの置き換えを検討する。
  14. 独自実装の機能から、標準ライブラリで提供されている類似機能への置き換えを検討する。
  15. 環境依存の機能から、標準ライブラリで提供されている類似機能への置き換えを検討する。
    • 例えばスレッド関連、正規表現、疑似乱数など。

公開インタフェースのC++化

C言語のコードから利用されることが無ければ、公開インタフェースをC++化してもよいだろう。

外部への影響が少ない変更
  1. インクルードしている標準ライブラリのヘッダファイル名をC++のものに置き換える。
  2. 公開インタフェースをC++リンケージ化する。
  3. 不要なtypedefを削除する。
  4. typedefから「usingを使用した型エイリアス」に移行する。
  5. 構造体と共用体の定義にfinal指定子を付けて派生を禁止する。
  6. 定数の定義をプリプロセッサ(マクロ)からconstexprに置き換える。
  7. 列挙体に基底の整数型を指定することを検討する。
外部への影響が避けられない小変更
  1. モジュール名をプレフィックスとして用いている場合に、名前空間の利用を検討する。
    • 例えばfoo_Initializeならfoo::Initialize。
  2. 従来の列挙体からenum class(スコープを持つ列挙体)への置き換えを検討する。
  3. (C99よりも前のコードベースの場合)独自のブーリアン型からboolへの置き換えを検討する。
  4. POD (Plain Old Data) でなくても構わない構造体・共用体について、コンストラクタの実装を検討する。メンバ変数の値を初期値に戻すようなメンバ関数でもよい。
  5. 関数ポインタから関数オブジェクトへの置き換えを検討する。
  6. 関数の引数について、ポインタから参照への置き換えを検討する。

その他

元々の「C言語で実装した際の基本設計・基本構造」を保ちながらC++化するため、局所的にはC++らしいコードになるものの、全体としてはBetter Cな感じになる。

やはり最初からC++ありきで設計した場合とは違ってくるよね。