# EB ライブラリ

この文書は、EB ライブラリバージョン 4.4.3 に対応しています。

目次:

- はじめに
  - 電子ブックと EPWING について
  - 本書の構成について
- EB ライブラリの特徴
  - ヘッダファイル
  - 文字コード
  - 圧縮された書籍について
  - 遠隔ホスト上の書籍について
  - システムの要件
- プログラムのコンパイル方法
  - てっとり早いコンパイル方法
  - Autoconf を併用したコンパイル方法
  - EB ライブラリ本体のデバッグ
- ライブラリの初期化と後始末
  - サンプルプログラム
  - 関数の詳細
- CD-ROM 書籍と `EB_Book` オブジェクト
  - `EB_Book` オブジェクト
  - 遠隔ホストへの `eb_bind()`
  - サンプルプログラム
  - データ型の詳細
  - 関数の詳細
- エラー処理
  - エラーコードとエラーメッセージ
  - エラーに対する寛容さ
  - データ型の詳細
  - エラーコードの一覧
  - 関数の詳細
- 副本
  - 副本コード
  - 選択中の副本
  - サンプルプログラム
  - データ型の詳細
  - 関数の詳細
- 検索
  - 前方一致、後方一致、完全一致検索
  - 条件検索
  - クロス検索
  - 複合検索
  - 一致エントリの情報
  - 残っているエントリの取得
  - 重複エントリの削除
  - サンプルプログラム
  - データ型の詳細
  - 関数の詳細
- テキストデータ
  - テキストデータのシークと読み込み
  - テキストデータの内部形式
  - フック
  - フックと文字コードの関係
  - クロス検索の検索結果
  - 著作権表示
  - メニュー
  - 複合検索の候補一覧
  - 区切りコードの問題
  - サンプルプログラム
  - データ型の詳細
  - フック関数の詳細
  - フックコードの一覧
  - フックセット操作関数の詳細
  - 組み込みフック関数の詳細
  - テキストデータ操作関数の詳細
- 外字
  - 半角外字と全角外字
  - 外字の大きさと外字コード
  - 選択中の外字フォントの高さ
  - 外字フォントの取り出し
  - 外字フォントの変換
  - テキスト中の外字
  - データ型の詳細
  - 定数の詳細
  - 関数の詳細
  - サンプルプログラム
- バイナリデータ
  - モノクロ図版
  - カラー図版
  - 参照先付きカラー図版
  - WAVE (PCM) 音声
  - MPEG1 動画
  - 関数の詳細
- appendix データ
  - `EB_Appendix` オブジェクト
  - 副本
  - 本文の区切りコード
  - 外字の代替文字列
  - データ型の詳細
  - 関数の詳細
  - サンプルプログラム
- サーバ上の書籍一覧
  - `EB_BookList` オブジェクト
  - データ型の詳細
  - 関数の詳細
  - サンプルプログラム
- 索引
  - データ型の索引
  - 関数の索引
  - 定数の索引

Copyright (c) 2001-2006 Motoyuki Kasahara

## はじめに

EB ライブラリは CD-ROM 書籍にアクセスするための C のライブラリです。 UNIX 系 OS および Windows (2000以降) のシステム上で動作させることが できます。

EB ライブラリは EB, EBG, EBXA, EBXA-C, S-EBXA および EPWING 形式の CD-ROM 書籍に対応しています。 これらは、主に日本で販売されている辞書に使われています。 CD-ROM 書籍自体は ISO 9660 形式になっていますので、他の ISO 9660 形式 と同じ要領でマウントすることができます。

本書は、EB ライブラリを使ってアプリケーションプログラムを作成する 開発者向けに、ライブラリの仕様を解説した文書です。 そして、ライブラリの公式な参照マニュアルでもあります。 読み進めるにあたって、読者は EB ライブラリおよび CD-ROM 書籍の内部構造 について知っている必要はありませんが、電子ブックか EPWING を利用して、 実際に CD-ROM 書籍がどのようなものかを理解しておくことをお薦めします。 また、C 言語によるプログラミングについては、十分に理解していることを前提 とします。

本書の内容に沿って EB ライブラリを使ったアプリケーションプログラムを 作成するには、お使用いのシステムに EB ライブラリと C コンパイラを インストールしておいて下さい。 なお、本書では主に UNIX 系 OS を使用した場合について、記述しています。

EB ライブラリはフリーソフトウェアです。ソースコードおよびバイナリを、 いわゆる Modified BSD ライセンスの下で使用することが可能です。 (バージョン 4.1 よりも前のものは、GPL を採用していました。) 詳しくは、ソースコードに付属している COPYING という英文のファイルを参照 して下さい。

### 電子ブックと EPWING について

電子ブックと EPWING は、いずれも主に日本で使われている電子書籍の データ形式の名称で、CD-ROM に収めた形で数々の書籍が市販されています。 CD-ROM は ISO 9660 形式 なので、CD-ROM ドライブが扱えるシステムであれば、 容易にアクセスすることができます。 電子書籍のデータ形式とはいっても、実際は辞書向けに特化した構造となって おり、市販されている書籍も辞書の類が圧倒的に多いようです。

電子ブック、EPWING ともに、データ形式に関する規格の全容は一般公開されて いませんが、EPWING ついては規格の一部が日本工業規格 JIS X 4081 「電子出版検索データ構造」として公開されています。 さらに、EPWING と電子ブックのデータ形式は、酷似していることが知られて います。

EB ライブラリの開発者も、電子ブック、EPWING 規格の全容は知りません。 EB ライブラリでは JIS X 4081 の記述をもとに、電子ブック、EPWING を読める ようにしてあります。 しかしながら、規格の全容が分からない状態で開発しているため、残念ながら 一部に正しく読めない書籍が存在します。

### 本書の構成について

次章「EB ライブラリの特徴」では、EB ライブラリが対応している機能、対応 していない機能について、簡単に説明します。 また、ライブラリの概略に関して、最初に知っておいたほうが良いと思われる 事柄をいくつか説明しています。

さらに次の章「プログラムのコンパイル方法」では、EB ライブラリを利用した プログラムのコンパイル方法を説明します。 本書のサンプルプログラムをコンパイルするために必要な情報も、この章に 記してあります。

そして、その次の章「ライブラリの初期化と後始末」からが、実際の EB ライブラリのプログラミングの解説となります。 それぞれの章は、次のような節から構成されています。 ただし、章によっては一部の節がない場合もあります。

解説
  その章で解説する機能や概念についての基礎知識、EB ライブラリの仕様の 概要について解説しています。
サンプルプログラム
  「解説」ではプログラムの断片だけを示すことが多いので、動作可能な プログラムのサンプルをここで示します。
データ型の詳細
  データ型や関数、定数値などについての参照マニュアルです。

## EB ライブラリの特徴

前に述べたように、EB ライブラリは、電子ブック (EB, EBG, EBXA, EBXA-C, S-EBXA) と EPWING 形式の CD-ROM 書籍に対応しています。

EB ライブラリは、これらの CD-ROM 書籍に対して、次の処理を行うことが できます。

- 前方一致検索
- 後方一致検索
- 完全一致検索
- 条件検索
- 複合検索
- 見出しデータの取得
- 本文データの取得
- メニューの取得
- 著作権表示の取得
- カラー図版データの取得 (ただし EPWING のみ)
- モノクロ図版データの取得
- 外字データの取得
- 動画データの取得

この章では、EB ライブラリの概要に関して、あらかじめ知っておいて頂いた ほうが良いと思われるその他の事柄について、何点か説明します。

### ヘッダファイル

EB ライブラリには、いくつかのヘッダファイルが用意されています。

`appendix.h`
  appendix (付録) に関連した宣言、定義を行う。
`binary.h`
  バイナリデータに関連した宣言、定義を行う。
`eb.h`
  EB ライブラリの基本ヘッダファイル。
`error.h`
  エラーコードに関連した宣言、定義を行う。
`font.h`
  外字に関連した宣言、定義を行う。
`text.h`
  テキストデータ (本文、見出しなど) に関連した宣言、定義を行う。

これ以外にもいくつかのファイルがインストールされますが、上に挙げた ヘッダファイルから読み込まれるもので、アプリケーションプログラムが 直接読み込む必要はありません。

アプリケーションプログラムは、EB ライブラリを使う際にこのヘッダファイル をファイルの先頭付近で読み込みます。

>     #include <eb/eb.h>
>     #include <eb/error.h>

`eb.h` ではなく、`eb/eb.h` を読み込むようにして下さい。

### 文字コード

EB ライブラリでは、CD-ROM 書籍内のデータを文字列にしてアプリケーション に渡す際の文字コードを規定しています。

EBG (海外の電子ブック) については、データが ISO 8859-1 (ラテン文字 1、 ただし制御文字を除く) で書かれているため、データのやり取りも ISO 8859-1 で行います。 ただし、外字だけは 2 バイトで表現し、0x0101 〜 0x1efe の領域を使用します。 (外字領域の下位 16 ビットは 0x01 〜 0xfe の範囲を使用します。)

EBG, EBXA-C を除いた電子ブック、および EPWING については、データが JIS X 0208 (日本語のかな漢字) で書かれており、JIS X 0208 を 0x2121 〜 0x7e7e にマッピングし、0xa121 〜 0xfe7e を外字領域にしています (下図)。

>     　　　　　　　　　　　　　　　　上位８ビット

>     　　　　　　　　　００　２１　　　　７ｅ　ａ１　　　　ｆｅ
>     　　　　　　　００┌──┬─────┬──┬─────┬┐
>     　　　　　　　　　│　　│　　　　　│　　│　　　　　││
>     　　　　　　　２１├──┼─────┼──┼─────┼┤
>     　　　　　　　　　│　　│　　　　　│　　│　　　　　││
>     　　　　　　　　　│　　│ＪＩＳ　Ｘ│　　│　外字　　││
>     　　　　　　　　　│　　│０２０８　│　　│　　　　　││
>     　　　　　　　　　│　　│　　　　　│　　│　　　　　││
>     　　　　　　　７ｅ├──┼─────┼──┼─────┼┤
>     下位８ビット　　　│　　│　　　　　│　　│　　　　　││
>     　　　　　　　ａ１├──┼─────┼──┼─────┼┤
>     　　　　　　　　　│　　│　　　　　│　　│　　　　　││
>     　　　　　　　　　│　　│　　　　　│　　│　　　　　││
>     　　　　　　　　　│　　│　　　　　│　　│　　　　　││
>     　　　　　　　　　│　　│　　　　　│　　│　　　　　││
>     　　　　　　　ｆｅ├──┼─────┼──┼─────┼┤
>     　　　　　　　　　└──┴─────┴──┴─────┴┘

EB ライブラリでは JIS X 0208 部分を日本語 EUC (EUC-JP) にエンコード して、アプリケーションとのやり取りも日本語 EUC で行います。 したがって、JIS X 0208 部分は 0xa1a1 〜 0xfefe にマッピングされます。

EBXA-C (中日・日中辞書の電子ブック) については、データが JIS X 0208 (日本語のかな漢字) と GB 2312 (中国語の簡体字) で書かれており、 JIS X 0208 を 0x2121 〜 0x7e7e にマッピング、 GB 2312 を 0x21a1 〜 0x7efe にマッピングし、 0xa121 〜 0xfe7e を外字領域にしています (下図)。

>     　　　　　　　　　　　　　　　　上位８ビット

>     　　　　　　　　　００　２１　　　　７ｅ　ａ１　　　　ｆｅ
>     　　　　　　　００┌──┬─────┬──┬─────┬┐
>     　　　　　　　　　│　　│　　　　　│　　│　　　　　││
>     　　　　　　　２１├──┼─────┼──┼─────┼┤
>     　　　　　　　　　│　　│　　　　　│　　│　　　　　││
>     　　　　　　　　　│　　│ＪＩＳ　Ｘ│　　│　外字　　││
>     　　　　　　　　　│　　│０２０８　│　　│　　　　　││
>     　　　　　　　　　│　　│　　　　　│　　│　　　　　││
>     　　　　　　　７ｅ├──┼─────┼──┼─────┼┤
>     下位８ビット　　　│　　│　　　　　│　　│　　　　　││
>     　　　　　　　ａ１├──┼─────┼──┼─────┼┤
>     　　　　　　　　　│　　│　　　　　│　　│　　　　　││
>     　　　　　　　　　│　　│ＧＢ　　　│　　│　　　　　││
>     　　　　　　　　　│　　│２３１２　│　　│　　　　　││
>     　　　　　　　　　│　　│　　　　　│　　│　　　　　││
>     　　　　　　　ｆｅ├──┼─────┼──┼─────┼┤
>     　　　　　　　　　└──┴─────┴──┴─────┴┘

EB ライブラリでは、アプリケーションとのやり取りに使う文字コードは、 日本語 EUC および中国語 EUC (EUC-ZH) です。 したがって、そのままでは JIS X 0208 と GB 2312 が 0xa1a1 〜 0xfefe に マッピングされ、衝突してしまいます。 この問題をどう回避するのかは、アプリケーション側で決める必要があります (詳しくは、「フックと文字コードの関係」 を参照のこと)。

電子ブック、EPWING ともに、外字については、アプリケーション側でどう 扱うかを決める必要があります。 外字について詳しくは 「外字」 を参照のこと。

### 圧縮された書籍について

EB ライブラは、データを圧縮して収録した書籍を扱うことができます。 今のところ、次の 4 種類の圧縮方法に対応しています。

`ebzip` 圧縮形式
  EB ライブラリ独自の圧縮形式です。 付属の `ebzip` コマンドを使うと、この形式で圧縮した書籍を作れます。
EPWING V4, V5 形式
  市販の EPWING V4, V5 の書籍の一部に、この形式で圧縮したものがあります。
EPWING V6 形式
  市販の EPWING V6 の書籍の一部に、この形式で圧縮したものがあります。 EPWING V4, V5 形式の改良型です。
S-EBXA 形式
  市販の S-EBXA の書籍の一部に、この形式で圧縮したものがあります。

データの伸長は EB ライブラリ側で自動的に行われるため、 アプリケーションプログラムからは、アクセスしている書籍が圧縮されているか どうか分かりません。 アプリケーションプログラムは、書籍が圧縮されているかどうかで処理を変える 必要はありません。

### 遠隔ホスト上の書籍について

バージョン 4.0 から、EB ライブラリは他のホストの書籍にアクセスできる ようになりました。

遠隔アクセスの処理はすべて EB ライブラリ側で行われますので、 アプリケーションプログラムは、書籍が自分のホスト上にあるかどうかで、 EB ライブラリの呼び出し手順を変える必要はありません。

ただし、他のホストからアクセスすると、処理速度は非常に遅くなります。 そのため、効率良く処理できるよう、アプリケーションの処理方法を工夫すべき 状況が生じることはあるかも知れません。

### システムの要件

アプリケーションプログラムのコンパイルに用いるコンパイラには、 ANSI (ANSI X3.159-1989, ISO/IEC 9899-1990) 対応のものを対象としています。 また、システムには POSIX.1 (IEEE Std. 1003.2-1990, ISO/IEC 9945-1:1990) 準拠ないし互換のものを対象としています。

永らく EB ライブラリでは、古いコンパイラや UNIX 系システムへの対応も それなりに行われていましたが、バージョン 4.1 からは対応を打ち切っています。 特に ANSI 対応のコンパイラは必須ですので、ご注意ください。

## プログラムのコンパイル方法

本章では、EB ライブラリを利用したプログラムのコンパイルの仕方について、 2 通りの方法を説明します。

一つ目は、ごく私的な、小規模のプログラムをコンパイルする際に向いている てっとり早くコンパイルするための方法です。 EB ライブラリの使い方を覚える目的で簡単なプログラムを組む際は、こちら が良いでしょう。

二つ目は、EB ライブラリを組み込んだアプリケーションをフリーソフトウェア としてリリースする際に向いている方法です。 EB ライブラリには、GNU Autoconf, Automake, Libtool を併用する仕組みを 用意してありますので、これらを使ったコンパイル方法について説明します。

### てっとり早いコンパイル方法

アプリケーションプログラムをコンパイルする際は、ヘッダファイルの ディレクトリ位置を C コンパイラに教えてやる必要があるかも知れません。 一般に UNIX の C コンパイラでは、`-I` オプションで位置を指定 します。

>     cc -I/usr/local/include -c sample.c

`/usr/local/include/eb` ではなく、その一つ上を指定します (「ヘッダファイル」 を参照のこと)。

次に、リンクして実行バイナリを生成する工程ですが、 以下に記したライブラリの一部、もしくは全部をリンクします。 括弧内は、ライブラリのファイル名です (ただし、`.a` や `.so` といった接尾子は省略)。

EB ライブラリ (libeb)
  EB ライブラリの本体です。このライブラリは必須です。
zlib (libz)
  圧縮と伸長を行うライブラリです (詳しくは @url{http://www.gzip.org/zlib/})。 `ebzip` コマンドで圧縮した辞書を扱うために使います。 このライブラリは必須です。 EB ライブラリのソースコードには zlib も収録されています。 システムに zlib が インストールされていなければ、EB ライブラリを インストールする際に、zlib も自動的にインストールされます。
gettext ライブラリ (libintl)
  メッセージの国際化機能 (NLS) を提供するライブラリです メッセージの国際化機能を有効にして EB ライブラリをコンパイルしている 場合は、必要になるかも知れません。 gettext の実装は何種類かありますが、EB ライブラリで使用できるのは メッセージカタログの形式が GNU gettext 互換のものだけです。 メッセージの国際化機能を有効にしている場合でも、OS の標準 C ライブラリ として glibc を採用しているシステムでは、指定する必要はありません。
iconv ライブラリ
  文字コード変換のライブラリです。 gettext ライブラリをリンクする場合、一緒に必要となるかも知れません。 iconv の実装も何種類かあり、OS によっては最初から添付されています。

必要なライブラリファイルの名称を、C コンパイラに指定してやります。 加えて、ファイルの置かれているディレクトリ位置を、C コンパイラに教える 必要があるかも知れません。 一般に UNIX の C コンパイラでは、`-L` オプションでディレクトリ 位置を指定し、`-l` オプションでライブラリのファイル名を指定 します。

>     cc sample.o -L/usr/local/lib -leb -lz -lintl -liconv

ただし、共有ライブラリをリンクする場合は、実行時におけるライブラリの 検索パスも合わせて指定する必要があるかも知れません。

>     cc sample.o -R/usr/local/lib -L/usr/local/lib -leb -lz -lintl -liconv

C コンパイラの使い方に関しての詳細は、C コンパイラのマニュアルを参照 して下さい。

### Autoconf を併用したコンパイル方法

作業の前に、Autoconf, Automake, Libtool は、あらかじめインストールして おいて下さい。 Autoconf はバージョン 2.50 以降が必要です。

まず、アプリケーションプログラムの `configure.ac` (もしくは `configure.in`) に、次の行を加えます。

>     eb_LIB_EB4

マクロ `eb_LIB_EB4` は、EB ライブラリの使用に必要な一切の チェックを行い、さらに `configure` に次のオプションを追加 します。

>       --with-eb-conf=FILE     eb.conf file is FILE [SYSCONFDIR/eb.conf]

`eb.conf` は、EB ライブラリをインストールしたときの情報を記録 したファイルで、ライブラリと一緒にインストールされます。 `eb_LIB_EB4` はこのファイルを読み込んで、C コンパイラに 渡さなければいけないオプションなどの情報を得ます。 `--eb-conf-file` は、`eb.conf` のファイル名を 明示的に指定するオプションです。

マクロ `eb_LIB_EB4` は、`eb4.m4` というファイルで 提供されています。 EB ライブラリを `/usr/local` にインストールし、個々のファイル のインストール先を変更していなければ、`/usr/local/share/aclocal` にインストールされます。 この `eb4.m4` をソースコードの適当なディレクトリの下 (たとえば `m4`) にコピーして下さい。

`aclocal` コマンドで `aclocal.m4` を再生成する際は、 `-I` オプションでマクロファイルのディレクトリを指定します。

>     aclocal -I m4

加えて、トップディレクトリの `Makefile.am` の中にも `aclocal` へ渡すオプションを書いておきます。

>     ACLOCAL_AMFLAGS = -I m4

また、ソースコードのディレクトリに Libtool パッケージがまだ用意されて いなければ、用意します。 `libtoolize` コマンドを実行して下さい。 Libtool パッケージが、ソースコードのディレクトリにコピーされます。

>     libtoolize

最後に、コンパイルを行うディレクトリの `Makefile.am` ファイル の `_LDFLAGS` と `INCLUDES` に、次のような値を追加 します。

>     program_LDFLAGS = $(EBCONF_EBLIBS) $(EBCONF_ZLIBLIBS) $(EBCONF_INTLLIBS)
>     INCLUDES = $(EBCONF_EBINCS)

(`program_LDFLAGS` の `program` のところは、 アプリケーションプログラムの実際のコマンド名にします。)

### EB ライブラリ本体のデバッグ

「自分が作ったアプリケーションが正しく動かないのは、ひょっとすると EB ライブラリのバグが原因ではないか?」という疑問を抱き、EB ライブラリ の挙動を確認したいと思うことがあるかも知れません。

そのような場合は、環境変数 `EB_DEBUG` をセットした状態で アプリケーションを実行してみて下さい。 EB ライブラリは標準エラー出力に、次のようなログを (かなり大量ですが) 出力するようになります。

>     [EB] in: eb_set_font(book=0, font_code=0)
>     [EB] in: eb_load_narrow_font(book=0)
>     [EB] out: eb_load_narrow_font()
>     [EB] in: eb_load_wide_font(book=0)
>     [EB] out: eb_load_wide_font()
>     [EB] out: eb_set_font() = EB_SUCCESS

これらのログは、関数の呼び出し時の引数列、および関数からの戻り値を 示しています。 `ebfixlog` という Perl5 スクリプトを使うと、ログを整形すること ができます。 このスクリプトは、EB ライブラリのソースコードの `misc` ディレクトリに収められています。

`ebfixlog` は、コマンド行の引数として与えられたファイル (引数が指定されなければ標準入力) からメッセージデータを読み込み、 次のように字下げして出力します。

>     [EB] in: eb_set_font(book=0, font_code=0)
>     [EB]   in: eb_load_narrow_font(book=0)
>     [EB]   out: eb_load_narrow_font()
>     [EB]   in: eb_load_wide_font(book=0)
>     [EB]   out: eb_load_wide_font()
>     [EB] out: eb_set_font() = EB_SUCCESS

通常 `ebfixlog` スクリプトは、zio および ebnet と呼ばれる、 EB ライブラリでファイル入出力を受け持つ処理部のログは読み捨てるように なっています。 これにより、ログの量がかなり減ります。

zio は EB ライブラリの低レベル入出力の処理部で、頻繁に呼び出されます。 問題の原因を調べる際も、まずは読み捨てた方がライブラリの内部動作を追跡 しやすいでしょう。

`ebfixlog` の `-z` オプションを使うと、zio の メッセージを読み捨てずに出力するようになります。

ebnet は遠隔アクセスの入出力を処理する部分で、zio よりもさらに 下位レベルに位置します。 遠隔アクセスの挙動を追跡するとき以外は、読み捨てた方が良いと思います。

`ebfixlog` の `-n` オプションを使うと、ebnet, zio 両方のメッセージを読み捨てずに出力するようになります。

## ライブラリの初期化と後始末

この章からは、EB ライブラリのプログラミングについての解説になります。

まず、アプリケーションプログラムから EB ライブラリを利用するには、 最初にライブラリを初期化する必要があります。

ライブラリの初期化を行うには、`eb_initialize_library()` という関数を呼び出します。

>     if (eb_initialize_library() != EB_SUCCESS) {
>         printf("eb_initialize_library() failed\n");
>         exit(1);
>     }

同様に、ライブラリを使い終わったら、`eb_finalize_library()` という関数を呼び出して後始末をします。

>     eb_finalize_library();

### サンプルプログラム

>     /*                                                            -*- C -*-
>      * Copyright (c) 2001-2006  Motoyuki Kasahara
>      *
>      * Redistribution and use in source and binary forms, with or without
>      * modification, are permitted provided that the following conditions
>      * are met:
>      * 1. Redistributions of source code must retain the above copyright
>      *    notice, this list of conditions and the following disclaimer.
>      * 2. Redistributions in binary form must reproduce the above copyright
>      *    notice, this list of conditions and the following disclaimer in the
>      *    documentation and/or other materials provided with the distribution.
>      * 3. Neither the name of the project nor the names of its contributors
>      *    may be used to endorse or promote products derived from this software
>      *    without specific prior written permission.
>      *
>      * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
>      * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>      * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
>      * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
>      * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
>      * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
>      * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
>      * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
>      * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
>      * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
>      * SUCH DAMAGE.
>      */

>     /*
>      * 使用方法:
>      *     initexit
>      * 例:
>      *     initexit
>      * 説明:
>      *     EB ライブラリの初期化、後始末をしてみます。
>      *     プログラムの外側から見れば、これは何の意味もない動作です。
>      */
>     #include <stdio.h>
>     #include <stdlib.h>

>     #include <eb/eb.h>
>     #include <eb/error.h>

>     int
>     main(int argc, char *argv[])
>     {
>         EB_Error_Code error_code;

>         /* EB ライブラリを初期化。*/
>         error_code = eb_initialize_library();
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to initialize EB Library, %s: %s\n",
>                 argv[0], eb_error_message(error_code), argv[1]);
>             exit(1);
>         }

>         /* EB ライブラリの利用を終了。*/
>         eb_finalize_library();
>         exit(0);
>     }

### 関数の詳細

この項で説明している関数を使うには、`eb/eb.h` を読み込んで下さい。

>     #include <eb/eb.h>

#### `EB_Error_Code eb_initialize_library ()`

関数 `eb_initialize_library()` は、EB ライブラリを初期化します。 アプリケーションプログラムは、EB ライブラリの他の関数を呼ぶ前に、必ず 一回だけこの関数を呼ぶ必要があります。

メッセージの国際化機能 (NLS) を有効にして EB ライブラリをコンパイル した場合、`eb_initialize_library()` は `bindtextdomain()` を 呼び出します。 したがって、アプリケーションプログラムが `setlocale()` を 呼び出すのは、この関数を呼び出す前である必要があります。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、原因を示すエラーコードを返します。

ライブラリを初期化せずに、EB ライブラリの他の関数を呼んだ場合の動作は 未定義です。 また、すでに初期化を済ませた状態で、再度 `eb_initialize_library()` を呼んでもいけません。 呼んだ場合の動作は未定義です。

#### `void eb_finalize_library ()`

関数 `eb_finalize_library()` は、EB ライブラリを使い終わった 際の後始末を行います。 ただし、アプリケーションプログラム側で使用した `EB_Book`、`EB_Hookset`、`EB_Appendix` オブジェクトの後始末は行いません。 オブジェクトを後始末するには、それぞれ専用の関数 `eb_finalize_book()`、`eb_finalize_hookset()`、 `eb_finalize_appendix()` を各オブジェクトに対して別途 呼んでやる必要があります。

ライブラリの後始末をした後は、EB ライブラリのいかなる関数も呼んでは いけません。 呼んだ場合の動作は未定義です。

## CD-ROM 書籍と `EB_Book` オブジェクト

EB ライブラリでは、CD-ROM 書籍へのアクセスは、すべて `EB_Book` 型 のオブジェクトを介して行います。 したがって、ほとんどのアプリケーションプログラムは、本章で記述している 処理を必要とするはずです。

本章では `EB_Book` オブジェクトの初期化、後始末といった基本的な 取り扱い方について説明します。

### `EB_Book` オブジェクト

CD-ROM 書籍へアクセスするには、まず `EB_Book` 型のオブジェクトを 用意します。 同時に複数の CD-ROM 書籍にアクセスするなら、書籍一冊毎にオブジェクトを 作る必要があります。

>     EB_Book book;

もちろん、オブジェクトの領域は、`malloc()` で確保しても 構いません。

>     EB_Book *book_pointer;

>     book_pointer = (EB_Book *) malloc(sizeof(EB_Book));

`EB_Book` オブジェクトの中身 (変数 `book` の中身 および `book_pointer` の指す領域) はまだ初期化されていませんので、 次の要領でオブジェクトを初期化します。

>     eb_initialize_book(&book);
>     eb_initialize_book(book_pointer);

`eb_initialize()` へ渡す引数は `EB_Book` オブジェクト へのポインタであって、`EB_Book` オブジェクトそのものでは ないことに注意して下さい。 (EB ライブラリの他の関数も、すべてオブジェクトをポインタで渡します。)

CD-ROM 書籍を使うには、続いて `EB_Book` オブジェクトを CD-ROM 書籍の実体に結び付けます。 これは、関数 `eb_bind()` によって行います。

>     ＥＢ＿Ｂｏｏｋ　　　　　　　　　　　　ＣＤ−ＲＯＭ書籍
>     オブジェクト　　　　　　　　　　┌────────────┐
>     ┌───┐　　　　　　　　　　　│　　　　　　　　　　　　│
>     │　　　┝━━━━━━━━━━━┥　／ｍｎｔ／ｃｄｒｏｍ　│
>     └───┘　ｅｂ＿ｂｉｎｄ（）　│　　　　　　　　　　　　│
>     　　　　　　　　　　　　　　　　└────────────┘

実際のプログラムでは、次のようにします。

>     if (eb_bind(&book, "/mnt/cdrom") != EB_SUCCESS) {
>         printf("eb_bind() failed\n");
>         return;
>     }

`eb_bind()` に渡す書籍のパス (この例では `/mnt/cdrom`) は書籍のトップディレクトリ、つまり `catalog` または `catalogs` ファイルのあるディレクトリを指定します。

`EB_Book` オブジェクトを使い終わったら、 `eb_finalize_book()` を呼んで後始末をします。 オブジェクトは書籍との結び付きを解かれた状態に戻り、内部で割り当てられた メモリは解放され、開いていたファイルもすべて閉じられます。

>     eb_finalize_book(&book);
>     eb_finalize_book(book_pointer);

オブジェクトの領域を `malloc()` で確保した場合は、 `eb_finalize_book()` を呼んだ後ならば、オブジェクトの領域を 安全に解放することができます。

>     free(book_pointer);

### 遠隔ホストへの `eb_bind()`

前節で説明した `eb_bind()` を用いて、`EB_Book` オブジェクトを遠隔ホストの書籍に結びつけることができます。 これには、書籍のパスの代わりに、遠隔アクセス用の識別子を指定します。 識別子は、次のような形式をとります。

>     ebnet://ホスト:ポート/書籍名

ホスト は遠隔ホストの IP アドレスもしくはホスト名です。 ただし、IPv6 アドレスを指定する場合は、アドレスを `[` と `]` で囲む必要があります。 ポート は、そのホストが待ち受けているポートの番号です。 ホストが待ち受けているポートが標準の 22010 番であれば、:ポート の部分は省略可能です。

以下に `eb_bind()` のコード例を記します。

>     if (eb_bind(&book, "ebnet://localhost/cdrom") != EB_SUCCESS) {
>         printf("eb_bind() failed\n");
>         return;
>     }

### サンプルプログラム

このサンプルプログラムでは、CD-ROM 書籍の種類を調べるために、 `eb_disc_code()` という関数を使用しています。 この関数については、「関数の詳細」 を参照のこと。

>     /*                                                            -*- C -*-
>      * Copyright (c) 1999-2006  Motoyuki Kasahara
>      *
>      * Redistribution and use in source and binary forms, with or without
>      * modification, are permitted provided that the following conditions
>      * are met:
>      * 1. Redistributions of source code must retain the above copyright
>      *    notice, this list of conditions and the following disclaimer.
>      * 2. Redistributions in binary form must reproduce the above copyright
>      *    notice, this list of conditions and the following disclaimer in the
>      *    documentation and/or other materials provided with the distribution.
>      * 3. Neither the name of the project nor the names of its contributors
>      *    may be used to endorse or promote products derived from this software
>      *    without specific prior written permission.
>      *
>      * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
>      * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>      * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
>      * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
>      * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
>      * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
>      * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
>      * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
>      * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
>      * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
>      * SUCH DAMAGE.
>      */

>     /*
>      * 使用方法:
>      *     disctype <book-path>
>      * 例:
>      *     disctype /cdrom
>      * 説明:
>      *     <book-path> で指定された CD-ROM 書籍の種類が、EB か EPWING か
>      *     を調べて表示します。
>      */
>     #include <stdio.h>
>     #include <stdlib.h>

>     #include <eb/eb.h>
>     #include <eb/error.h>

>     int
>     main(int argc, char *argv[])
>     {
>         EB_Error_Code error_code;
>         EB_Book book;
>         EB_Disc_Code disc_code;

>         /* コマンド行引数をチェック。*/
>         if (argc != 2) {
>             fprintf(stderr, "Usage: %s book-path\n", argv[0]);
>             exit(1);
>         }

>         /* EB ライブラリと `book' を初期化。*/
>         error_code = eb_initialize_library();
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to initialize EB Library, %s: %s\n",
>                 argv[0], eb_error_message(error_code), argv[1]);
>             goto die;
>         }
>         eb_initialize_book(&book);

>         /* `book' を書籍に結び付ける。失敗したら終了。*/
>         error_code = eb_bind(&book, argv[1]);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to bind the book, %s: %s\n",
>                 argv[0], eb_error_message(error_code), argv[1]);
>             goto die;
>         }

>         /* 書籍の種類を調べて表示。*/
>         error_code = eb_disc_type(&book, &disc_code);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to get disc type, %s: %s\n",
>                 argv[0], eb_error_message(error_code), argv[1]);
>             goto die;
>         }

>         if (disc_code == EB_DISC_EB) {
>             fputs("EB\n", stdout);
>         } else if (disc_code == EB_DISC_EPWING) {
>             fputs("EPWING\n", stdout);
>         } else {
>             fputs("unknown\n", stdout);
>         }

>         /* 書籍と EB ライブラリの利用を終了。*/
>         eb_finalize_book(&book);
>         eb_finalize_library();
>         exit(0);

>         /* エラー発生で終了するときの処理。*/
>       die:
>         eb_finalize_book(&book);
>         eb_finalize_library();
>         exit(1);
>     }

### データ型の詳細

この節で説明しているデータ型を使うには、次のようにヘッダファイルを 読み込んで下さい。

>     #include <eb/eb.h>

#### `EB_Book` 型

`EB_Book` 型は、一冊の CD-ROM 書籍を表します。 CD-ROM 書籍へのアクセスは、すべてこの型のオブジェクトを介して行います。 同時に複数の CD-ROM 書籍にアクセスする際は、書籍一冊毎にオブジェクトを 作る必要があります。

`EB_Book` オブジェクトの操作は、すべて EB ライブラリが用意 している関数で行います。 アプリケーションプログラムは、直接 `EB_Book` オブジェクトの メンバを参照したり、セットしたりすべきではありません。

`EB_Book` オブジェクトを使用する際は、まずそのオブジェクトに 対して `eb_initialize_book()` を呼んで初期化しなくては なりません。

#### `EB_Disc_Code` 型

データ型 `EB_Disc_Code` は、CD-ROM 書籍の形式コードを表します。 現在のところ、次の値が定義されています。

`EB_DISC_EB`
  電子ブック (EB, EBG, EBXA, EBXA-C, S-EBXA) であることを表します。
`EB_DISC_EPWING`
  EPWING であることを表します。
`EB_DISC_INVALID`
  不正な形式コード値を表します。

この型は符合付き整数型の別名として定義されていますので、2 つのコードを 2 項演算子 `==` と `!=` で一致比較することができます。

#### `EB_Character_Code` 型

データ型 `EB_Character_Code` は、CD-ROM 書籍で使用される 文字コードを表します。 現在のところ、次の値が定義されています。

`EB_CHARCODE_ISO8859_1`
  ISO 8859-1 (ラテン文字 1) を使用していることを表します。 電子ブックの EBG はこれです。
`EB_CHARCODE_JISX0208`
  JIS X 0208 (日本語のかな漢字) を使用していることを表します。 EBG, EBXA-C 以外の電子ブック、および EPWING はすべてこれです。
`EB_CHARCODE_JISX0208_GB2312`
  JIS X 0208 (日本語のかな漢字) と GB 2312 (中国語の簡体字) を併用している ことを表します。 電子ブックの EBXA-C はこれです。
`EB_CHARCODE_INVALID`
  不正な文字コード値を表します。

この型は符合付き整数型の別名として定義されていますので、2 つのコードを 2 項演算子 `==` と `!=` で一致比較することができます。

### 関数の詳細

この節で説明している関数を使うには、次のようにヘッダファイルを読み込んで 下さい。

>     #include <eb/eb.h>

#### `void eb_initialize_book (EB_Book *book)`

関数 `eb_initialize_book()` は、book の指す `EB_Book` オブジェクトを初期化します。 `EB_Book` オブジェクトに対して EB ライブラリの他の関数を呼ぶ前に、 必ずそのオブジェクトを初期化しなくてはなりません。 初期化していないオブジェクトに対して、EB ライブラリの他の関数を呼んだ 場合の動作は未定義です。 また、すでに初期化したオブジェクトに対して、再度 `eb_initialize_book()` を呼んではいけません。 呼んだ場合の動作は未定義です。

#### `EB_Error_Code eb_bind (EB_Book *book, const char *path)`

関数 `eb_bind()` は、book の指す `EB_Book` オブジェクトを、パス path にある CD-ROM 書籍に結び付けます。 パスには、書籍のトップディレクトリか遠隔アクセス識別子を指定します。 書籍のトップディレクトリとは、`catalog` あるいは `catalogs` ファイルの存在するディレクトリを指します。

オブジェクトがすでに書籍に結び付いていた場合、その書籍との結び付きを 解いてから、path にある書籍に結び付けます。

成功すると、関数は `EB_SUCCESS` を返します。 このとき、副本は未選択の状態になります。 失敗すると、オブジェクトを書籍との結び付きを解かれた状態にして、原因 を示すエラーコードを返します。

path は、`EB_MAX_PATH_LENGTH` バイトに収まていなくては なりません。 さらに、path が相対パスのときは、絶対パスに変換した結果がこの長さ に収まっていなくてはなりません。 これを超えると、`EB_ERR_TOO_LONG_FILE_NAME` を返します。

#### `void eb_finalize_book (EB_Book *book)`

関数 `eb_finalize_book()` は、book が指す `EB_Book` オブジェクトの後始末を行います。

オブジェクトが割り当てて管理していたメモリはすべて解放され、 ファイルディスクリプタもすべて閉じられます。 オブジェクトが書籍と結び付いていた場合は、結び付きが解かれます。

後始末をしたオブジェクトに対して `eb_bind()` を呼ぶことで、 オブジェクトを再利用することができます。

#### `int eb_is_bound (EB_Book *book)`

関数 `eb_is_bound()` は、book が書籍に結び付いているか どうかを調べます。 結び付いていれば 1 を返し、そうでなければ 0 を返します。

#### `EB_Error_Code eb_path (EB_Book *book const char *path)`

関数 `eb_path()` は、book に結び付いている書籍のパス もしくは遠隔アクセス識別子を、path の指す領域に書き込みます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、path の指す領域に空文字列を書き込み、原因を示す エラーコードを返します。

book は、あらかじめ書籍に結び付いている必要があります。 結びついていない場合は、`EB_ERR_UNBOUND_BOOK` を返します。

path に書き込むパス名のバイト数は、最長で `EB_MAX_PATH_LENGTH` になります。 この長さは、末尾のナル文字を含みません。 関数が返すパスは正規化された形になっているので、`eb_bind()` に 渡したときのものと同じとは限りません。 たとえば、相対パスだった場合は、絶対パスに変換されます。

#### `EB_Error_Code eb_disc_type (EB_Book *book, EB_Disc_Code *disc_code)`

関数 `eb_disc_type()` は、book のディスクの形式を disc_code の指す領域に書き込みます。 書き込むディスクの形式の値は、`EB_Disc_Code` 型 (「[CD-ROM 書籍と `EB_Book` オブジェクト] データ型の詳細」 を参照のこと) のいずれかの定数値です。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、disc_code の指す領域に `EB_DISC_INVALID` を書き込み、原因を示すエラーコードを返します。

book は、あらかじめ書籍に結び付いていなければなりません。 結びついていない場合は、`EB_ERR_UNBOUND_BOOK` を返します。

#### `EB_Error_Code eb_character_code (EB_Book *book, EB_Character_Code *character_code)`

関数 `eb_character_code()` は、book が書かれている 文字コードを character_code の指す領域に書き込みます。 書き込む文字コードの値は、`EB_Character_Code` 型 (「[CD-ROM 書籍と `EB_Book` オブジェクト] データ型の詳細」 を参照のこと) のいずれかの定数値です。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、character_code の指す領域に `EB_CHARCODE_INVALID` を書き込み、原因を示すエラーコードを 返します。

book は、あらかじめ書籍に結び付いていなければなりません。 結びついていない場合は、`EB_ERR_UNBOUND_BOOK` を返します。

## エラー処理

EB ライブラリの関数の呼び出しは、常に成功するとは限りません。 たとえば、`EB_Book` オブジェクトを書籍に結びつける関数 `eb_bind()` には、引数として書籍のトップディレクトリを渡しますが、 存在しないディレクトリを指定した場合、処理は失敗に終わります。

一般にこうした事象は、ユーザが誤ったパスを指定したときに起こりますが、 メモリ不足のように、ユーザのミスが原因ではない失敗も起こりえます。

本章では、関数の呼び出しが失敗した場合の処理について説明します。

### エラーコードとエラーメッセージ

EB ライブラリの関数の多くは、戻り値として `EB_Error_Code` 型の値を返します。 処理が成功したときに返す値は `EB_SUCCESS` ですが、失敗したときは エラーの原因に応じて様々な値を返します。 このため、EB ライブラリでは次のような `EB_SUCCESS` との比較処理 がよく行われます。

>     EB_Error_Code error_code;

>     error_code = eb_bind(&book, "/mnt/cdrom");
>     if (error_code != EB_SUCCESS) {
>         printf("eb_bind() failed\n");
>         return;
>     }

エラーコードの値は、関数 `eb_error_message()` によって エラーメッセージに変換することもできます。 こうすることで、エラーの原因をアプリケーションプログラムのユーザに もう少し分かりやすく伝えることができます。

>     error_code = eb_bind(&book, "/mnt/cdrom");
>     if (error_code != EB_SUCCESS) {
>         printf("eb_bind() failed, %s\n",
>             eb_error_message(error_code));
>         return;
>     }

`error_code` が `EB_ERR_TOO_LONG_FILENAME` に セットされていれば、次のようなエラーメッセージが出力されます。

>     too long filename

あるいは、次のように日本語のメッセージかも知れません。

>     ファイル名が長すぎます

メッセージの国際化機能 (NLS) を無効にして EB ライブラリをコンパイル した場合は、常に英語のメッセージが返ります。 有効にした場合は、ロケールの設定によってどちらの言語のメッセージが 返るかが決まります。

本書ではプログラムを簡潔にするために、エラー処理は最低限しか行って いません。 けれども一般のアプリケーションプログラムでは、関数の呼び出しが成功 したかどうかを常にチェックし、処理が失敗した際はエラーメッセージを出力 して、ユーザにエラーの原因を伝えるのが望ましいといえます。

### エラーに対する寛容さ

`EB_Book` オブジェクトは、状態に関するパラメタをいくつか持って います。 オブジェクトが CD-ROM 書籍に結び付いているかどうかも、こうしたパラメタ のうちの一つです。

引数に `EB_Book` オブジェクトへのポインタを取る関数には、 あらかじめオブジェクトの特定のパラメタがセットされていることを前提と しているものもあります。 たとえば、`eb_path()` は、オブジェクトが書籍に結び付いていること を前提としています。 では、もしも書籍に結び付いていないオブジェクトを `eb_path()` に 渡したらどうなるでしょうか。

>     EB_Book book;
>     EB_Error_Code error_code;
>     char path[EB_MAX_PATH_LENGTH + 1];

>     eb_initialize_library();
>     eb_initialize(&book);
>     error_code = eb_path(&book, path);    /* どうなる? */

この場合、`eb_path()` は `EB_ERR_UNBOUND_BOOK` を 返します。 EB ライブラリの関数は、必要なパラメタがセットされていないオブジェクトを 検知して拒絶します。

しかしながら、参照マニュアルで明示されている場合を除いて、EB ライブラリ の関数は、与えられたポインタが `NULL` かどうかまでは調べません。 次のようなことをすると、プログラムを異常終了させてしまいます。

>     eb_bind(NULL, "/mnt/cdrom");    /* 異常終了! */
>     eb_bind(&book, NULL);           /* これも異常終了! */

### データ型の詳細

この節で説明しているデータ型を使うには、次のようにヘッダファイルを 読み込んで下さい。

>     #include <eb/error.h>

#### `EB_Error_Code` 型

データ型 `EB_Error_Code` は、EB ライブラリのエラーコードを 表します。 この型は符合付き整数型の別名として定義されていますので、2 つのコードを 2 項演算子 `==` と `!=` で一致比較することができます。

EB ライブラリでは、全部で `EB_NUMBER_OF_ERRORS` 個の フックコードを定義しています。 エラーコードの一覧については、 次の節 (「エラーコードの一覧」 を参照のこと) を参照して下さい。

### エラーコードの一覧

この節で説明しているエラーコードを使うには、次のようにヘッダファイルを 読み込んで下さい。

>     #include <eb/error.h>

#### 定数 `EB_SUCCESS`

成功。 エラーは起きていない。

#### 定数 `EB_ERR_MEMORY_EXHAUSTED`

EB ライブラリが `malloc()` を呼び出したが、`NULL` が返ってきた。

#### 定数 `EB_ERR_TOO_LONG_FILE_NAME`

与えられた書籍のパス名が長すぎる。

#### 定数 `EB_ERR_BAD_FILE_NAME`

書籍のパス名が不正である。

#### 定数 `EB_ERR_BAD_DIR_NAME`

ディレクトリ名が不正である。 (EB ライブラリの内部処理用なので、 このエラーコードがアプリケーションプログラムに返ることはありません。)

#### 定数 `EB_ERR_TOO_LONG_WORD`

与えられた検索語は長すぎる。

#### 定数 `EB_ERR_BAD_WORD`

与えられた検索語に不正な文字が含まれている。

#### 定数 `EB_ERR_EMPTY_WORD`

与えられた検索語は空である。

#### 定数 `EB_ERR_FAIL_GETCWD`

`getcwd()` もしくは `getwd()` が失敗した。

#### 定数 `EB_ERR_FAIL_OPEN_CAT`

EB ライブラリが、書籍のカタログファイルを開くことに失敗した。

#### 定数 `EB_ERR_FAIL_OPEN_CATAPP`

EB ライブラリが、appendix のカタログファイルを開くことに失敗した。

#### 定数 `EB_ERR_FAIL_OPEN_TEXT`

EB ライブラリが、書籍の本文ファイルを開くことに失敗した。

#### 定数 `EB_ERR_FAIL_OPEN_FONT`

EB ライブラリが、書籍の外字ファイルを開くことに失敗した。

#### 定数 `EB_ERR_FAIL_OPEN_APP`

EB ライブラリが、appendix ファイルを開くことに失敗した。

#### 定数 `EB_ERR_FAIL_OPEN_BINARY`

EB ライブラリが、バイナリデータファイルを開くことに失敗した。

#### 定数 `EB_ERR_FAIL_READ_CAT`

EB ライブラリが、書籍のカタログファイルを読み込むことに失敗した。

#### 定数 `EB_ERR_FAIL_READ_CATAPP`

EB ライブラリが、appendix のカタログファイルを読み込むことに失敗した。

#### 定数 `EB_ERR_FAIL_READ_TEXT`

EB ライブラリが、書籍の本文ファイルを読むことに失敗した。

#### 定数 `EB_ERR_FAIL_READ_FONT`

EB ライブラリが、書籍の外字ファイルを読み込むことに失敗した。

#### 定数 `EB_ERR_FAIL_READ_APP`

EB ライブラリが、appendix のメインファイルを読み込むことに失敗した。

#### 定数 `EB_ERR_FAIL_READ_BINARY`

EB ライブラリが、書籍のバイナリデータファイルを読み込むことに失敗した。

#### 定数 `EB_ERR_FAIL_SEEK_CAT`

EB ライブラリが、書籍のカタログファイルのシークに失敗した。

#### 定数 `EB_ERR_FAIL_SEEK_CATAPP`

EB ライブラリが、appendix のカタログファイルのシークに失敗した。

#### 定数 `EB_ERR_FAIL_SEEK_TEXT`

EB ライブラリが、書籍の本文ファイルのシークに失敗した。

#### 定数 `EB_ERR_FAIL_SEEK_FONT`

EB ライブラリが、書籍の外字ファイルのシークに失敗した。

#### 定数 `EB_ERR_FAIL_SEEK_APP`

EB ライブラリが、appendix のメインファイルのシークに失敗した。

#### 定数 `EB_ERR_FAIL_SEEK_BINARY`

EB ライブラリが、書籍のバイナリデータファイルのシークに失敗した。

#### 定数 `EB_ERR_UNEXP_CAT`

EB ライブラリが、書籍のカタログファイル内で、期待とは異なるデータ列を 見つけた。

#### 定数 `EB_ERR_UNEXP_CATAPP`

EB ライブラリが、appendix のカタログファイル内で、想定外のデータ列を 見つけた。

#### 定数 `EB_ERR_UNEXP_TEXT`

EB ライブラリが、書籍の本文ファイル内で、想定外のデータ列を見つけた。

#### 定数 `EB_ERR_UNEXP_FONT`

EB ライブラリが、書籍の外字ファイル内で、想定外のデータ列を見つけた。

#### 定数 `EB_ERR_UNEXP_APP`

EB ライブラリが、appendix のメインファイル内で、想定外のデータ列を 見つけた。

#### 定数 `EB_ERR_UNEXP_BINARY`

EB ライブラリが、書籍のバイナリデータファイル内で、想定外のデータ列を 見つけた。

#### 定数 `EB_ERR_UNBOUND_BOOK`

呼び出された EB ライブラリの関数は、書籍に結び付けられた `EB_Book` オブジェクトを引数にとるが、与えられたオブジェクトは 書籍に結び付けられていなかった。

#### 定数 `EB_ERR_UNBOUND_APP`

呼び出された EB ライブラリの関数は、appendix に結び付けられた `EB_Appendix` オブジェクトを引数にとるが、与えられた オブジェクトは appendix に結び付けられて いなかった。

#### 定数 `EB_ERR_NO_SUB`

書籍は副本を一つも持っていない。

#### 定数 `EB_ERR_NO_APPSUB`

appendix は副本を一つも持っていない。

#### 定数 `EB_ERR_NO_FONT`

選択中の副本は、外字を一種類も持っていない。

#### 定数 `EB_ERR_NO_TEXT`

選択中の副本は、本文データを持っていない。

#### 定数 `EB_ERR_NO_CUR_SUB`

呼び出された関数は、副本が選択されている `EB_Book` オブジェクトを引数としてとるが、与えられたオブジェクトでは選択されて いなかった。

#### 定数 `EB_ERR_NO_CUR_APPSUB`

呼び出された関数は、副本が選択されている `EB_Appendix` オブジェクトを引数にとるが、与えられたオブジェクトでは選択されて いなかった。

#### 定数 `EB_ERR_NO_CUR_FONT`

呼び出された関数は、外字が選択されている `EB_Book` オブジェクトを引数にとるが、与えられたオブジェクトでは選択されて いなかった。

#### 定数 `EB_ERR_NO_CUR_BINARY`

呼び出された関数は、バイナリデータの読み込み要求をセットしている `EB_Book` オブジェクトを引数にとるが、与えられたオブジェクトでは セットされていなかった。

#### 定数 `EB_ERR_NO_SUCH_SUB`

`EB_Book` オブジェクトと副本コードが関数に与えられたが、 `EB_Book` オブジェクトに結び付けられている書籍は、その 副本コードに一致する副本を持っていない。

#### 定数 `EB_ERR_NO_SUCH_APPSUB`

`EB_Appendix` オブジェクトと副本コードが関数に与えられたが、 `EB_Appendix` オブジェクトに結び付けられている appendix は、 その副本コードに一致する副本を持っていない。

#### 定数 `EB_ERR_NO_SUCH_FONT`

`EB_Book` オブジェクトと外字の縦のサイズが関数に与えられたが、 `EB_Book` オブジェクトに結びつけられていた書籍で選択中の副本は、 そのサイズの外字を持っていない。

#### 定数 `EB_ERR_NO_SUCH_CHAR_BMP`

`EB_Book` オブジェクトと文字番号が関数に与えられたが、 `EB_Book` オブジェクトに結び付けられていた書籍で選択中の副本は、 その番号の外字のビットマップデータを持っていない。

#### 定数 `EB_ERR_NO_SUCH_CHAR_TEXT`

`EB_Appendix` オブジェクトと文字番号が関数に与えられたが、 `EB_Appendix` オブジェクトに結び付けられている appendix で 選択中の副本は、その番号の外字の代替文字列を持っていない。

#### 定数 `EB_ERR_NO_SUCH_SEARCH`

選択中の副本は、指定された検索メソッドを持っていないので、検索は行えない。

#### 定数 `EB_ERR_NO_SUCH_HOOK`

不正なフックコードが関数に渡された。

#### 定数 `EB_ERR_NO_SUCH_BINARY`

指定された位置に、指定された形式のバイナリデータは存在しない。

#### 定数 `EB_ERR_DIFF_CONTENT`

アプリケーションプログラムからテキストデータの取得を要求されたが、指定 されたテキストデータの種類が、前回リクエストされたときと一致していない。

#### 定数 `EB_ERR_NO_PREV_SEARCH`

`eb_hit_list()` が呼び出されたが、アプリケーションプログラム から前もって検索のリクエストがなされていない。

#### 定数 `EB_ERR_NO_SUCH_MULTI_ID`

`EB_Book` オブジェクトと複合検索コードが関数に渡されたが、 結び付けられた書籍で選択中の副本は、そのコードに一致する複合検索を持って いない。

#### 定数 `EB_ERR_NO_SUCH_ENTRY_ID`

`EB_Book` オブジェクトと複合検索エントリコードが関数に 渡されたが、結び付けられた書籍で選択中の副本は、そのエントリコードに 一致する複合検索エントリを持っていない。

#### 定数 `EB_ERR_TOO_MANY_WORDS`

アプリケーションプログラムから条件検索もしくは複合検索の検索をリクエスト されたが、検索語の個数が多すぎる。

#### 定数 `EB_ERR_NO_WORD`

アプリケーションプログラムから条件検索もしくは複合検索の検索をリクエスト されたが、検索語がすべて空である。

#### 定数 `EB_ERR_NO_CANDIDATES`

`eb_multi_entry_candidates()` が呼び出されたが、 指定された複合検索エントリは、検索語の候補一覧データを持っていない。

#### 定数 `EB_ERR_END_OF_CONTENT`

`eb_forward_text()` あるいは `eb_backward_text()` で本文の頭出しを行おうとしたが、すでに本文の末尾ないし先頭に達していて、 それ以上先に進むことができなかった。

#### 定数 `EB_ERR_NO_PREV_SEEK`

あらかじめ `eb_seek_text()` でシークを行っていない状態で、 テキストデータの読み込みや頭出しを行おうとした。

#### 定数 `EB_ERR_EBNET_UNSUPPORTED`

この EB ライブラリは、遠隔ホストへのアクセスには対応していない。

#### 定数 `EB_ERR_EBNET_FAIL_CONNECT`

遠隔ホストへのアクセスを試みたが、サーバ (EBNETD) に接続できなかった。

#### 定数 `EB_ERR_EBNET_SERVER_BUSY`

遠隔ホストへの接続を行ったが、書籍にアクセスしているクライアントの数が すでに上限に達しているため、その書籍を利用できなかった。

#### 定数 `EB_ERR_EBNET_NO_PERMISSION`

遠隔ホストへの接続を行ったが、その書籍への利用権限がないため、サーバ からアクセスを拒否された。

#### 定数 `EB_ERR_UNBOUND_BOOKLIST`

呼び出された EB ライブラリの関数は、遠隔ホストに結び付けられた `EB_BookList` オブジェクトを引数にとるが、与えられたオブジェクト は遠隔ホストに結び付けられていなかった。

#### 定数 `EB_ERR_NO_SUCH_BOOK`

`EB_BookList` オブジェクトと書籍の要素番号を関数に渡されたが、 `EB_BookList` に結び付けられた遠隔ホスト上には、その要素番号に 該当する書籍は存在しない。

### 関数の詳細

この節で説明している関数を使うには、次のようにヘッダファイルを読み込んで 下さい。

>     #include <eb/error.h>

#### `const char *eb_error_string (EB_Error_Code error_code)`

関数 `eb_error_string()` は、エラーコード error_code を文字列に変換したものを返します。 文字列の文字コードは、ASCII になります。 たとえば、エラーコード値 `EB_SUCCESS` を渡すと文字列 `"EB_SUCCESS"` を返します。 未知のエラーコードを渡したときは、`"EB_ERR_UNKNOWN"` を返します。

#### `const char *eb_error_message (EB_Error_Code error_code)`

関数 `eb_error_message()` は、エラーコード error_code に対応したメッセージを文字列にして返します。 関数の返すメッセージは、英語か日本語になります。

国際化機能を有効にして EB ライブラリをコンパイルしていない場合は、常に 英語のメッセージを返します。 このときのメッセージの文字コードは、ASCII になります。

メッセージの国際化機能 (NLS) を有効にして EB ライブラリをコンパイル した場合は、ロケールの設定に応じてどちらの言語のメッセージを返すのか が決まります。 また、GNU gettext バージョン 0.36 以降では iconv() と連携することにより、 メッセージの文字コードもロケールに応じて変化します。 gettext が iconv() との連携を行わなければ、英語のメッセージは ASCII、 日本語のメッセージは日本語 EUC になります。 この関数の呼び出しによって、gettext のテキストドメインの設定は変化 しません。

未知のエラーコードを渡したときに返すメッセージは、英語では `"unknown error"`、日本語では `"未知のエラーです"` になります。

## 副本

紙に印刷された本では別々の書籍になっているものでも、電子ブックや EPWING では 1 枚の CD-ROM にまとめることができます。

たとえば、ある CD-ROM 書籍は、国語辞書、英々辞典、百科事典という 3 つ の (印刷された本で言うところの) 「書籍」を持っていることもあり得ます。 紛らわしさを避けるために、EB ライブラリではここで言う「書籍」のことを 副本 (subbook) と呼んでいます。

>     　　　ＣＤ−ＲＯＭ書籍
>     ┌─────────────┐
>     │　副本０：　［国語辞典］　│
>     │　副本１：　［英々辞典］　│
>     │　副本２：　［百科事典］　│
>     └─────────────┘

CD-ROM 書籍では、それぞれの副本はそれ自体が独立した書籍になっています。 また、副本のデータも、副本毎に別々のファイルに収められています。 したがって、EB ライブラリでも、アプリケーションプログラムの主要な処理 である単語の検索や本文データの取得などは、すべて副本単位で行うように なっています。

本章では、EB ライブラリでの副本の扱い方について説明します。

### 副本コード

EB ライブラリでは、それぞれの副本に対して 副本コード (subbook code) を割り当てます。 このコードは EB ライブラリが副本を識別するために用いますので、個々の 副本コードは、書籍内で同じものがないようになっています。

以下のソースコードは、`eb_subbook_list()` という関数の 使用例です。 この関数は、書籍内のすべての副本の副本コードを取得することができます。

>     /* book が EB_Book のオブジェクトで、すでに
>      * 書籍に結び付けられていると仮定しています。*/
>     EB_Subbook_Code sub_codes[EB_MAX_SUBBOOKS];
>     int sub_count;

>     if (eb_subbook_list(&book, sub_codes, &sub_count)
>         != EB_SUCCESS) {
>         printf("eb_subbook_list() failed\n");
>         return;
>     }

`eb_subbook_list()` が成功すると、書籍内のすべての副本コードが 配列 `sub_codes[]` に格納されます。 配列の先頭の副本コードは `sub_codes[0]` と表され、次の コードは `sub_codes[1]`、という具合になります。 副本の個数は、`sub_count` に格納されます。

個々の副本には、必ず題名が付けられています。 先頭の副本 (`sub_codes[0]`) の題名は、次のようにして 得ることができます。

>     char title[EB_MAX_TITLE_LENGTH + 1];

>     if (eb_subbook_title2(&book, sub_codes[0], title)
>         != EB_SUCCESS) {
>         printf("eb_subbook_title2() failed\n");
>         return;
>     }

`eb_subbook_title2()` の呼び出しが成功すると、 `title` に題名を表す文字列が格納されます。

蛇足ですが、(副本ではなく) CD-ROM の題名を取得する関数はありません。 なぜなら、題名を示すデータが CD-ROM の中には何処にもないからです。

### 選択中の副本

`EB_Book` オブジェクトは、結びつけられた CD-ROM 書籍の中の 任意の副本から一つ選んで、選択中の副本 (current subbook) として指定することができます。 複数の副本を、同時に選択することはできません。 単語の検索や、本文データの取得など、ほとんどの操作は、選択中の副本に 対してだけ行えます。

`eb_bind()` で `EB_Book` オブジェクトを書籍に 結び付けた直後は、いずれの副本も選択されていない状態になっています。

>     ＥＢ＿Ｂｏｏｋ　　　　　　　　　ＣＤ−ＲＯＭ書籍
>     オブジェクト
>     ┌────┐　　　　　　　┌─────────────┐
>     │選択中　│　　　　　　　│　副本０：　［国語辞典］　│
>     │の副本　│　　　　　　　│　副本１：　［英々辞典］　│
>     │＜なし＞│　　　　　　　│　副本２：　［百科事典］　│
>     └────┘　　　　　　　└─────────────┘

副本の選択を行うには、関数 `eb_set_subbook()` を使用します。 `eb_set_subbook()` は、引数として渡された副本コードに したがって副本を選択します。 以下は、先頭の副本 (`sub_codes[0]`) を選択する場合の例です。

>     /* book が EB_Book のオブジェクトで、すでに
>      * 書籍に結び付けられていると仮定しています。*/
>     EB_Subbook_Code sub_codes[EB_MAX_SUBBOOKS];
>     int sub_count;

>     if (eb_subbook_list(&book, sub_codes, &sub_count)
>         != EB_SUCCESS) {
>         printf("eb_subbook_list() failed\n");
>         return;
>     }
>     if (eb_set_subbook(&book, sub_codes[0]) != EB_SUCCESS) {
>         printf("eb_subbook_list() failed\n");
>         return;
>     }

成功すると、次のように副本が選択された状態になります。

>     ＥＢ＿Ｂｏｏｋ　　　　　　　　　ＣＤ−ＲＯＭ書籍
>     オブジェクト
>     ┌────┐　　　　　　　┌─────────────┐
>     │選択中　│　　┏━━━━┿━副本０：　［国語辞典］　│
>     │の副本　│　　┃　　　　│　副本１：　［英々辞典］　│
>     │　＊━━┿━━┛　　　　│　副本２：　［百科事典］　│
>     └────┘　　　　　　　└─────────────┘

### サンプルプログラム

>     /*                                                            -*- C -*-
>      * Copyright (c) 1999-2006  Motoyuki Kasahara
>      *
>      * Redistribution and use in source and binary forms, with or without
>      * modification, are permitted provided that the following conditions
>      * are met:
>      * 1. Redistributions of source code must retain the above copyright
>      *    notice, this list of conditions and the following disclaimer.
>      * 2. Redistributions in binary form must reproduce the above copyright
>      *    notice, this list of conditions and the following disclaimer in the
>      *    documentation and/or other materials provided with the distribution.
>      * 3. Neither the name of the project nor the names of its contributors
>      *    may be used to endorse or promote products derived from this software
>      *    without specific prior written permission.
>      *
>      * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
>      * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>      * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
>      * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
>      * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
>      * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
>      * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
>      * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
>      * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
>      * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
>      * SUCH DAMAGE.
>      */

>     /*
>      * 使用方法:
>      *     subbook <book-path>
>      * 例:
>      *     subbook /cdrom
>      * 説明:
>      *     <boook-path> で指定され CD-ROM 書籍に含まれているすべての副本の
>      *     題名を表示します。
>      */
>     #include <stdio.h>
>     #include <stdlib.h>

>     #include <eb/eb.h>
>     #include <eb/error.h>

>     int
>     main(int argc, char *argv[])
>     {
>         EB_Error_Code error_code;
>         EB_Book book;
>         EB_Subbook_Code subbook_list[EB_MAX_SUBBOOKS];
>         int subbook_count;
>         char title[EB_MAX_TITLE_LENGTH + 1];
>         int i;

>         /* コマンド行引数をチェック。*/
>         if (argc != 2) {
>             fprintf(stderr, "Usage: %s book-path\n", argv[0]);
>             exit(1);
>         }

>         /* EB ライブラリと `book' を初期化。*/
>         error_code = eb_initialize_library();
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to initialize EB Library, %s: %s\n",
>                 argv[0], eb_error_message(error_code), argv[1]);
>             goto die;
>         }
>         eb_initialize_book(&book);

>         /* 書籍を `book' に結び付ける。*/
>         error_code = eb_bind(&book, argv[1]);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to bind the book, %s: %s\n",
>                 argv[0], eb_error_message(error_code), argv[1]);
>             goto die;
>         }

>         /* 副本の一覧を取得。*/
>         error_code = eb_subbook_list(&book, subbook_list, &subbook_count);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to get the subbbook list, %s\n",
>                 argv[0], eb_error_message(error_code));
>             goto die;
>         }

>         /* 書籍に含まれている副本の題名を出力。*/
>         for (i = 0; i < subbook_count; i++) {
>             error_code = eb_subbook_title2(&book, subbook_list[i], title);
>             if (error_code != EB_SUCCESS) {
>                 fprintf(stderr, "%s: failed to get the title, %s\n",
>                     argv[0], eb_error_message(error_code));
>                 continue;
>             }
>             printf("%d: %s\n", i, title);
>         }

>         /* 書籍と EB ライブラリの利用を終了。*/
>         eb_finalize_book(&book);
>         eb_finalize_library();
>         exit(0);

>         /* エラー発生で終了するときの処理。*/
>       die:
>         eb_finalize_book(&book);
>         eb_finalize_library();
>         exit(1);
>     }

### データ型の詳細

この節で説明しているデータ型を使うには、次のようにヘッダファイルを 読み込んで下さい。

>     #include <eb/eb.h>

#### `EB_Subbook_Code` 型

データ型 `EB_Subbook_Code` は副本コードを表します。 一冊の書籍の中の副本は、それぞれ一意の副本コードを持っています。 この型は符合付き整数型の別名として定義されていますので、2 つのコードを 2 項演算子 `==` と `!=` で一致比較することが できます。

また、不正な副本コード値を表す `EB_SUBBOOK_INVALID` という 特別な副本コードが定義されています。 利用可能な副本に対して、この副本コードが割り当てられることはありません。

### 関数の詳細

この節で説明している関数を使うには、次のようにヘッダファイルを読み込んで 下さい。

>     #include <eb/eb.h>

#### `EB_Error_Code eb_load_all_subbooks (EB_Book *book)`

関数 `eb_load_all_subbooks()` は、book 内のすべての 副本を初期化します。 通常、副本の初期化は、その副本が初めて選択されたときに自動的に行われますが、 この関数は初期化を前倒しで行います。 初期化の対象となるのは、この関数を呼び出した時点でまだ初期化していない すべての副本です。 この関数は、スタンドアロンで動作するサーバアプリケーションなどで有効です。 クライアントからの接続を受ける前にこの関数を呼ぶことで、副本の初期化の ためにクライアントを待たせなくて済みます。

初期化の対象となったすべての副本の初期化に成功すれば、関数は `EB_SUCCESS` を返します。 一冊でも初期化に失敗した場合は、残りの副本の初期化を諦め、原因を示す エラーコードを返します。

book は、あらかじめ書籍に結び付けられていなくてはなりません。 結びついていない場合は、`EB_ERR_UNBOUND_BOOK` を返します。

この関数を呼び出すと、book は、副本を選択していない状態になります。

#### `EB_Error_Code eb_subbook_list (EB_Book *book, EB_Subbook_Code *subbook_list, int *subbook_count)`

関数 `eb_subbook_list()` は、book 内のすべて副本の 副本コードを `EB_Subbook_Code` 型の配列にして、 subbook_list の指す領域に書き込みます。 配列は、最大で `EB_MAX_SUBBOOKS` 個の要素を持ちます。 加えて、書籍が収録している副本の個数を subbook_count の指す 領域に書き込みます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、subbook_count の指す領域に 0 を書き込み、原因を 示すエラーコードを返します。

book は、あらかじめ書籍に結び付けられていなくてはなりません。 結びついていない場合は、`EB_ERR_UNBOUND_BOOK` を返します。

#### `EB_Error_Code eb_subbook (EB_Book *book, EB_Subbook_Code *subbook_code)`

関数 `eb_subbook()` は、book が選択中の副本の 副本コードを subbook_code の指す領域に書き込みます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、subbook_code の指す領域に `EB_SUBBOOK_INVALID` を書き込み、原因を示すエラーコードを 返します。

あらかじめ、book はいずれかの副本を選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_SUB` を返します。

#### `EB_Error_Code eb_subbook_title (EB_Book *book, char *title)`

関数 `eb_subbook_title()` は、book が選択中の副本の 題名を title の指す領域に文字列として書き込みます。 題名の文字列の長さは、最長で `EB_MAX_TITLE_LENGTH` バイトです。 この長さは、末尾のナル文字を含みません。

書籍の文字コード (「[CD-ROM 書籍と `EB_Book` オブジェクト] データ型の詳細」 を参照のこと) が `EB_CHARCODE_ISO8859_1` なら、題名を表す文字列は ISO 8859-1 になり、それ以外の文字コードなら日本語 EUC になります。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、title の指す領域に空文字列を書き込み、原因を示す エラーコードを返します。

あらかじめ、book 内のいずれかの副本が選択されていなくては なりません。 選択していない場合は、`EB_ERR_NO_CUR_SUB` を返します。

#### `EB_Error_Code eb_subbook_title2 (EB_Book *book, EB_Subbook_Code subbook_code, char *title)`

`eb_subbook_title()` と似ていますが、選択中の副本ではなく、 引数 subbook_code で指定された副本の題名を書き込む点が 異なります。

book は副本を選択していなくても構いませんが、あらかじめ書籍 に結び付けられていなければなりません。 結びついていない場合は、`EB_ERR_UNBOUND_BOOK` を返します。

#### `EB_Error_Code eb_subbook_directory (EB_Book *book, char *directory)`

関数 `eb_subbook_directory()` は、book 内で現在 選択中の副本のデータファイルを収めたディレクトリ名を、directory の指す領域に書き込みます。

ディレクトリ名の文字列の長さは、最長で `EB_MAX_DIRECTORY_NAME_LENGTH` バイトです。 この長さに、末尾のナル文字は含みません。 ディレクトリ名は ASCII の数字、英小文字、アンダースコアで構成されます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、directory の指す領域に空文字列を書き込み、原因に を示すエラーコードを返します。

あらかじめ、book 内のいずれかの副本が選択されていなくては なりません。 選択していない場合は、`EB_ERR_NO_CUR_SUB` を返します。

#### `EB_Error_Code eb_subbook_directory2 (EB_Book *book, EB_Subbook_Code subbook_code, char *directory)`

`eb_subbook_directory()` と似ていますが、選択中の副本ではなく、 引数 subbook_code で指定された副本のディレクトリ名を書き込む点 が異なります。

book は副本を選択していなくても構いませんが、あらかじめ 書籍に結び付けられていなければなりません。 結びついていない場合は、`EB_ERR_UNBOUND_BOOK` を返します。

#### `EB_Error_Code eb_set_subbook (EB_Book *book, EB_Subbook_Code code)`

関数 `eb_set_subbook()` は、book の副本 code を選択します。 すでに副本を選択していた場合は、いったん未選択の状態にしてから副本 subbook_code を選択します。

成功すると、関数は `EB_SUCCESS` を返します。 このとき、外字は未選択の状態となり、検索、テキストデータの読み込み、 バイナリデータの読み込みについての状態記録は、すべてリセットされます。 失敗すると、副本を未選択の状態にして、原因を示すエラーコードを返します。

あらかじめ、book は書籍に結び付けられていなければなりません。 結びついていない場合は、`EB_ERR_UNBOUND_BOOK` を返します。

#### `void eb_unset_subbook (EB_Book *book)`

関数 `eb_unset_subbook()` は、book が選択している 副本を未選択の状態にします。 book が書籍に結び付いていないか、副本が選択されていない場合は、 何もしません。

## 検索

CD-ROM 書籍において、検索は非常に重要な機能です。 EB ライブラリでは、次のような検索メソッドが利用できます。

- 前方一致検索 (word search)
- 後方一致検索 (end-word search)
- 完全一致検索 (exact-word search)
- 条件検索 (keyword search)
- クロス検索 (cross search)
- 複合検索 (multi search)

ただし、すべての CD-ROM 書籍、すべての副本で、ここに挙げたすべての 検索メソッドが利用可能なわけではありません。 副本の中には、いずれの検索メソッドも提供しないものも存在します。

EB ライブラリでは、検索を行うことができるのは、選択中の副本に対して だけです。

この章では、それぞれの検索メソッドの簡単な説明と、EB ライブラリでの 扱い方について説明します。

### 前方一致、後方一致、完全一致検索

前方一致、後方一致、完全一致検索は、いずれも一個の入力語に一致する エントリを探し出す検索メソッドです。

前方一致検索は、入力語と先頭部分が一致するエントリを検索します。 たとえば、「江戸」という語は、「江戸」「江戸時代」「江戸っ子」といった エントリに一致します。

後方一致検索は、入力語と末尾が一致するエントリを検索します。 たとえば、`bye' という語は、`bye'、`good bye'、`bye bye' といった エントリに一致します。

完全一致検索は、一個の検索語と完全に一致するエントリだけを検索します。

以下は、前方一致検索のプログラムの例です。 選択中の副本の中から、先頭が `librar` で始まるエントリを探して います。

>     /* book が EB_Book のオブジェクトで、すでに
>      * 書籍に結び付けられ、副本を選択中だと仮定しています。*/
>     #define MAX_HITS 50
>     EB_Hit hits[MAX_HITS];
>     int hit_count;

>     if (eb_search_word(&book, "librar") != EB_SUCCESS) {
>         printf("eb_search_word() failed\n");
>         return;
>     }
>     if (eb_hit_list(&book, MAX_HITS, hits, &hit_count)
>         != EB_SUCCESS) {
>         printf("eb_hit_list() failed\n");
>         return;
>     }

`eb_search_word()` は前方一致検索をリクエストする関数です。 この例では、`librar` という検索文字列を与えています。 ただし、この関数は一致したエントリを返すことはしません。

一致したエントリの取得は、続く `eb_hit_list()` 関数を 呼び出した際に行われます。 `eb_hit_list()` は一致したエントリの一覧を配列 `hits[]` の指す領域に書き込み、見つかった一致エントリの個数 を `&hit_count` の指す領域に書き込みます。 この例では、`eb_hit_list()` は最大で `MAX_HITS` (= 50) 個 のエントリを探します。 (つまり、50 個見つかったら検索を止めます。)

もし、選択中の副本が英々辞典だとすると、少なくとも `library` と `librarian` という 2 つのエントリに関する情報が得られる でしょう。 このとき、配列 `hits[]` は次のようになっています。 (ただし、`library` と `librarian` エントリの 順序は、下の絵とは異なっているかも知れません。)

>     ┌───────────┬───────────┬─
>     │　ｌｉｂｒａｒｉａｎ　│　　ｌｉｂｒａｒｙ　　│
>     └───────────┴───────────┴─
>     　　　ｈｉｔｓ［０］　　　　　ｈｉｔｓ［１］

`hits[]` の中身については、本章の後ろの節でもう少し詳しく 説明します。

ここまでは前方一致検索を例にとりましたが、後方一致の場合は `eb_search_word()` の代わりに `eb_search_endword()` を呼ぶようにします。 他はすべて同じです。

>     if (eb_search_endword(&book, "nalization") != EB_SUCCESS) {
>         printf("eb_search_endword() failed\n");
>         return;
>     }

完全一致の場合も同様です。 `eb_search_exactword()` を呼ぶようにする以外は、すべて同じ です。

>     if (eb_search_exactword(&book, "library") != EB_SUCCESS) {
>         printf("eb_search_exactword() failed\n");
>         return;
>     }

### 条件検索

条件検索は、複数個の入力語にすべて一致するエントリを検索します。 たとえば、英々辞典の条件検索では、入力語をすべて含んだ例文を検索する ようになっているかも知れません。

以下は、条件検索で `make`, `with` という語の双方と 一致するエントリを、選択中の副本の中から探し出すプログラムの断片です。

>     /* book が EB_Book のオブジェクトで、すでに
>      * 書籍に結び付けられ、副本を選択中だと仮定しています。*/
>     static const char *keywords[3] = {"make", "with", NULL};

>     if (eb_search_word(&book, keywords) != EB_SUCCESS) {
>         printf("eb_search_word() failed\n");
>         return;
>     }

条件検索を行う関数は、`eb_search_keyword()` です。 前方一致、後方一致、完全一致検索の関数と基本的に扱い方は一緒ですが、 複数の入力語を受け付けるようになっています。 関数には、入力語の文字列 (へのポインタ) を配列にしたものを渡します。 配列の最後には `NULL` を置き、配列の終端を明示する必要が ある点に注意して下さい。

前方一致、後方一致、完全一致検索と同様に、`eb_search_keyword()` も検索のリクエストを行うだけで、一致したエントリの取得は行いません。 エントリの取得には、やはり同様に `eb_hit_list()` 関数を 使います。

>     EB_Hit hits[MAX_HITS];
>     int hit_count;

>     if (eb_hit_list(&book, MAX_HITS, hits, &hit_count)
>         != EB_SUCCESS) {
>         printf("eb_hit_list() failed\n");
>         return;
>     }

### クロス検索

クロス検索は、条件検索の亜種とも言うべき検索メソッドです。 EPWING や電子ブックをみても、どういうルールで使い分けがなされているのか 分からない程、両者は実によく似ています。

EB ライブラリでクロス検索を行う関数は `eb_search_cross()` ですが、使い方は条件検索の関数 `eb_search_keyword()` と まったく同じです。 使い方の詳細は、「条件検索」 をご覧下さい。

### 複合検索

複合検索は、条件検索と同じく、複数個の入力語にすべて一致するエントリを 検索しますが、個々の入力語にあらかじめ題目が付けられています。

また、前方一致、後方一致、完全一致、条件検索はすべて、各副本につき 一種類しかありませんが、複合検索だけは一つの副本の中で複数の種類が用意 されていることがあります。 たとえば、ある世界人名事典には、次のように人名検索用と頻出用語の検索用 の 2 種類の複合検索が用意されているかも知れません。

>     (複合検索その 1: 人名を検索する)
>         入力語 0: 国・地域
>         入力語 1: 時代
>         入力語 2: 性別
>         入力語 3: キーワード
>         入力語 4: キーワード

>     (複合検索その 2: 頻出用語を検索する)
>         入力語 0: 用語
>         入力語 1: キーワード
>         入力語 2: キーワード

この例のように、個々の複合検索は、入力語の題目だけでなく、入力語の数も まちまちです。 また、検索する際はすべての入力語を埋める必要はなく、少なくとも一個の 入力語が空でなければ、検索は成功します。

副本内の複合検索は、種類毎に 複合検索コード (multi search code) によって識別されます。 関数 `eb_multi_search_list()` を使うと、選択中の副本で利用可能 な複合検索の一覧が得られます。

>     /* book が EB_Book のオブジェクトで、すでに
>      * 書籍に結び付けられ、副本を選択中だと仮定しています。*/
>     EB_Multi_Search_Code multi_codes[EB_MAX_MULTI_SEARCHES];
>     int multi_count;

>     if (eb_multi_search_list(&book, multi_codes, &multi_count)
>         != EB_SUCCESS) {
>         printf("eb_multi_search_list() failed\n");
>         return;
>     }

この複合検索コードは、複合検索のための関数で必要となります。 たとえば、`eb_multi_title()` は、指定した複合検索の題名 (例:「人名検索」「頻出用語検索」) を取得する関数ですが、このときの 複合検索の指定には、複合検索コードを用います。 以下の例では、一覧の先頭に載っている複合検索 (`multi_codes[0]`) を指定しています。

>     char title[EB_MAX_MULTI_TITLE_LENGTH + 1];

>     if (eb_multi_title(&book, multi_codes[0], title)
>         != EB_SUCCESS) {
>         printf("eb_multi_title() failed\n");
>         return;
>     }

さらに関数によっては、複合検索コードに加えて、何番目の入力語かも指定 してやる必要があります。 たとえば、特定の入力語の題目を得る関数 `eb_multi_entry_label()` が、これに該当します。 0 番目の入力語 (つまり先頭の入力語) の題目を取得するには、次のように します。

>     char label[EB_MAX_MULTI_LABEL_LENGTH + 1];

>     if (eb_multi_entry_label(&book, multi_code[0], 0, label)
>         != EB_SUCCESS) {
>         printf("eb_multi_entry_label() failed\n");
>         return;
>     }

複合検索を行う関数は、`eb_search_multi()` です。 使い方は条件検索とほぼ同じで、入力語の文字列を配列にしたものを引数 として渡し、配列の最後には `NULL` を置いて下さい。 埋められていない入力語のところには、空文字列を置きます。

`eb_search_multi()` も検索のリクエストを行うだけで、一致した エントリの取得は行いません。 取得するには `eb_hit_list()` を使います。

>     EB_Hit hits[MAX_HITS];
>     int hit_count;

>     if (eb_hit_list(&book, MAX_HITS, hits, &hit_count)
>         != EB_SUCCESS) {
>         fprintf(stderr, "an error occurs.\n");
>         return;
>     }

なお、複合検索の入力語によっては 候補一覧 (candidates) があらじめ用意されていることがあります。 これは、入力語として有効な語をあらかじめ列挙しておき、 アプリケーションプログラムのユーザに選択させる仕組みです。 候補一覧については、この章ではなく「テキストデータ」の章で説明します (「複合検索の候補一覧」 を参照のこと)。

### 一致エントリの情報

`eb_hit_list()` は、リクエストされた検索 (前方一致、後方一致、 完全一致、条件、複合) に一致したエントリの情報と見つかったエントリの 個数を、それぞれ `EB_Hit` 型の配列領域および `int` 型の 領域に書き込みます。

>     /* book が EB_Book のオブジェクトで、すでに書籍に結び付け
>      * られ、副本を選択中だと仮定しています。*/
>     EB_Hit hits[MAX_HITS];
>     int hit_count;

>     if (eb_hit_list(&book, MAX_HITS, hits, &hit_count)
>         != EB_SUCCESS) {
>         fprintf(stderr, "an error occurs.\n");
>         return;
>     }

`EB_Hit` 配列の個々の要素には、一致したエントリの 見出し (heading) と 本文 (text) の開始位置が 書き込まれています。

>     　　　　　　　　　　　　　見出し
>     　　　　　　　　　　　　┌────────────┐
>     　ＥＢ＿Ｈｉｔ　　　┏━┿ｌｉｂｒａｒｉａｎ　ｎ．│
>     ┌───────┐　┃　└────────────┘
>     │ｈｅａｄｉｎｇ┿━┛　　本文
>     │　　　　　　　│　　　┌────────────────────┐
>     │　　　ｔｅｘｔ┿━━━┿ｌｉｂｒａｒｉａｎ　　　　　　　　　　　│
>     └───────┘　　　│ｎ．（１）Ａ　ｐｅｒｓｏｎ　ｗｈｏ　ｉｓ│
>     　　　　　　　　　　　　│ａ　ｓｐｅｃｉａｌｉｓｔ　ｉｎ　　　　　│
>     　　　　　　　　　　　　│ｌｉｂｒａｒｙ　ｗｏｒｋ．（２）．．．　│
>     　　　　　　　　　　　　└────────────────────┘

見出しと本文についてのより詳しい解説と取得方法については、 「テキストデータ」 を参照のこと。

### 残っているエントリの取得

前に述べたように、`eb_hit_list()` を呼び出すときは、一致する エントリを最大で何個まで探すのかを引数で指定します。 また、`eb_hit_list()` は処理が成功すると、実際に見つかった エントリの数をアプリケーションプログラムに教えます。

>     error_code = eb_hit_list(&book, MAX_HITS, hits, &hit_count);
>     if (error_code == EB_SUCCESS)
>         printf("%d entries found\n", hit_count);

指定した最大個数よりも多くの一致エントリが副本に存在している場合は、 `eb_hit_list()` を繰り返し呼び出すことで、残りのエントリを 取得することができます。

>     for (;;) {
>         if (eb_hit_list(&book, MAX_HITS, hits, &hit_count)
>             != EB_SUCCESS) {
>             fprintf(stderr, "an error occurs.\n");
>             return;
>         }
>         if (hit_count == 0)
>             break;
>         /* 取得した一致エントリの処理 */
>     }

一致エントリがもう残っていなければ、`eb_hit_list()` は `&hit_count` の指す領域に 0 を書き込んで、 `EB_SUCCESS` を返します。

ただし、途中で `eb_hit_list()` が失敗すると (`EB_SUCCESS` 以外の値を返すと)、検索リクエストに関する 状態記録はリセットされるため、一致エントリの取得をそれ以上続けることは できません。

### 重複エントリの削除

`eb_hit_list()` を用いて一致したエントリを取得すると、中身が 実質的に変わらないエントリが複数含まれていることがあります。 EB ライブラリは、こうした重複エントリの削除は行いません。 必要なら、アプリケーション側で行うことになります。

重複を完璧に取り除くなら、以下のすべての条件に一致するエントリを 重複エントリとみなし、二度目以降に出現したエントリを削除します。

- エントリの指す本文の位置が同じ
- エントリの指す見出しの文字列 (位置ではなく文字列そのもの) が同じ

(見出し文字列の取得方法については、 「テキストデータ」 を参照のこと。)

重複は、直前のエントリに対してのみ起こるとは限りません。 たとえば、`eb_hit_list()` で一致エントリが 50 個得られた場合、 最後の 50 個目は前方の 49 個と重複検査を行う必要があります。 したがって、全体ではエントリ同士の比較を 1 + 2 + ... + 49 = 1225 回 行うことになります。

書籍によっては重複エントリが取りきれない可能性もありますが、もう少し 簡単な方法もいくつかあります。 処理を簡単にする第一の方法は、重複エントリの判定条件を次のように変える ことです。

- エントリの指す本文の位置が同じ
- エントリの指す見出しの文字列の位置が同じ

さらに処理を簡単にするには、直前の 1個のエントリに対してだけ重複検査を 行うという方法もあります。 これなら、50 個の一致エントリに対して、比較は 49 回で済みます。 ただしこの方法は、書籍によってはまったく効果がありません。

### サンプルプログラム

>     /*                                                            -*- C -*-
>      * Copyright (c) 1999-2006  Motoyuki Kasahara
>      *
>      * Redistribution and use in source and binary forms, with or without
>      * modification, are permitted provided that the following conditions
>      * are met:
>      * 1. Redistributions of source code must retain the above copyright
>      *    notice, this list of conditions and the following disclaimer.
>      * 2. Redistributions in binary form must reproduce the above copyright
>      *    notice, this list of conditions and the following disclaimer in the
>      *    documentation and/or other materials provided with the distribution.
>      * 3. Neither the name of the project nor the names of its contributors
>      *    may be used to endorse or promote products derived from this software
>      *    without specific prior written permission.
>      *
>      * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
>      * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>      * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
>      * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
>      * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
>      * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
>      * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
>      * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
>      * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
>      * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
>      * SUCH DAMAGE.
>      */

>     /*
>      * 使用方法:
>      *     word <book-path> <subbook-index> <word>
>      * 例:
>      *     word /cdrom 0 apple
>      * 説明:
>      *     <book-path> で指定した CD-ROM 書籍の特定の副本の中から <word>
>      *     という単語を完全一致検索で探し、ヒットしたすべてのエントリの
>      *     見出しを表示します。
>      *
>      *     <subbook-index> には、検索対象の副本のインデックスを指定しま
>      *     す。インデックスは、書籍の最初の副本から順に 0、1、2 ... に
>      *     なります。
>      */
>     #include <stdio.h>
>     #include <stdlib.h>

>     #include <eb/eb.h>
>     #include <eb/error.h>
>     #include <eb/text.h>

>     #define MAX_HITS 50
>     #define MAXLEN_HEADING 127

>     int
>     main(int argc, char *argv[])
>     {
>         EB_Error_Code error_code;
>         EB_Book book;
>         EB_Subbook_Code subbook_list[EB_MAX_SUBBOOKS];
>         EB_Hit hits[MAX_HITS];
>         char heading[MAXLEN_HEADING + 1];
>         int subbook_count;
>         int subbook_index;
>         int hit_count;
>         ssize_t heading_length;
>         int i;

>         /* コマンド行引数をチェック。*/
>         if (argc != 4) {
>             fprintf(stderr, "Usage: %s book-path subbook-index word\n",
>                 argv[0]);
>             exit(1);
>         }

>         /* EB ライブラリと `book' を初期化。*/
>         eb_initialize_library();
>         eb_initialize_book(&book);

>         /* 書籍を `book' に結び付ける。*/
>         error_code = eb_bind(&book, argv[1]);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to bind the book, %s: %s\n",
>                 argv[0], eb_error_message(error_code), argv[1]);
>             goto die;
>         }

>         /* 副本の一覧を取得。*/
>         error_code = eb_subbook_list(&book, subbook_list, &subbook_count);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to get the subbbook list, %s\n",
>                 argv[0], eb_error_message(error_code));
>             goto die;
>         }

>         /* 副本のインデックスを取得。*/
>         subbook_index = atoi(argv[2]);

>         /*「現在の副本 (current subbook)」を設定。*/
>         error_code = eb_set_subbook(&book, subbook_list[subbook_index]);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to set the current subbook, %s\n",
>                 argv[0], eb_error_message(error_code));
>             goto die;
>         }

>         /* 単語検索のリクエストを送出。*/
>         error_code = eb_search_exactword(&book, argv[3]);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to search for the word, %s: %s\n",
>                 argv[0], eb_error_message(error_code), argv[3]);
>             goto die;
>         }

>         for (;;) {
>             /* 残っているヒットエントリを取得。*/
>             error_code = eb_hit_list(&book, MAX_HITS, hits, &hit_count);
>             if (error_code != EB_SUCCESS) {
>                 fprintf(stderr, "%s: failed to get hit entries, %s\n",
>                     argv[0], eb_error_message(error_code));
>                 goto die;
>             }
>             if (hit_count == 0)
>                 break;

>             for (i = 0; i < hit_count; i++) {
>                 /* 見出しの位置へ移動。*/
>                 error_code = eb_seek_text(&book, &(hits[i].heading));
>                 if (error_code != EB_SUCCESS) {
>                     fprintf(stderr, "%s: failed to seek the subbook, %s\n",
>                         argv[0], eb_error_message(error_code));
>                     goto die;
>                 }

>                 /* 見出しを取得して表示。*/
>                 error_code = eb_read_heading(&book, NULL, NULL, NULL,
>                     MAXLEN_HEADING, heading, &heading_length);
>                 if (error_code != EB_SUCCESS) {
>                     fprintf(stderr, "%s: failed to read the subbook, %s\n",
>                         argv[0], eb_error_message(error_code));
>                     goto die;
>                 }
>                 printf("%s\n", heading);
>             }
>         }

>         /* 書籍と EB ライブラリの利用を終了。*/
>         eb_finalize_book(&book);
>         eb_finalize_library();
>         exit(0);

>         /* エラー発生で終了するときの処理。*/
>       die:
>         eb_finalize_book(&book);
>         eb_finalize_library();
>         exit(1);
>     }

### データ型の詳細

この節で説明しているデータ型を使うには、次のようにヘッダファイルを 読み込んで下さい。

>     #include <eb/eb.h>

#### `EB_Hit` 型

`EB_Hit` は、検索に一致したエントリの情報を格納するための データ型です。 内部構造は、次のように定義されています。

>     typedef struct EB_Hit_Struct EB_Hit;

>     struct EB_Hit_Struct {
>         EB_Position heading;  /* 見出しの位置 */
>         EB_Position text;     /* 本文の位置   */
>     };

アプリケーションプログラムは、直接 `EB_Hit` オブジェクトの メンバを参照したり、セットしたりしても構いません。

#### `EB_Position` 型

データ型 `EB_Position` は、副本のデータの位置を表します。 内部構造は、次のように定義されています。

>     typedef struct EB_Position_Struct EB_Position;

>     struct EB_Position_Struct {
>         int page;     /* ページ番号 */
>         int offset;   /* ページ内のオフセット */
>     };

ページ番号は 1 から始まり、ページ内のオフセットは 0 〜 2047 の範囲と なります。 ただし、アプリケーションプログラムを作成する上で、このことを覚えておく 必要はありません。

アプリケーションプログラムは、直接 `EB_Position` オブジェクト のメンバを参照したり、セットしたりしても構いません。

#### `EB_Multi_Search_Code` 型

データ型 `EB_Multi_Search_Code` は複合検索コードを表します。 副本に用意されている複合検索は、それぞれ一意の複合検索コードを 持っています。 この型は符合付き整数型の別名として定義されていますので、2 つのコードを 2 項演算子 `==` と `!=` で一致比較することが できます。

また、不正な複合検索コード値を表す `EB_MULTI_INVALID` という 特別な副本コードが定義されています。 利用可能な複合検索に対して、この複合検索コードが割り当てられることは ありません。

### 関数の詳細

この節で説明している関数を使うには、次のようにヘッダファイルを読み込んで 下さい。

>     #include <eb/eb.h>

#### `int eb_have_word_search (EB_Book *book)`

#### `int eb_have_endword_search (EB_Book *book)`

#### `int eb_have_exactword_search (EB_Book *book)`

関数 `eb_have_word_search()` は、book が選択中の 副本で前方一致検索メソッドが利用可能どうかを調べます。 同様に `eb_have_endword_search()` は後方一致検索メソッドに ついて、`eb_have_exactword_search()` は完全一致検索メソッドに ついて利用可能どうかを調べます。

利用可能なら 1 を返します。 メソッドを持っていないか、そもそも副本が選択されていない場合は 0 を 返します。

#### `int eb_have_keyword_search (EB_Book *book)`

関数 `eb_have_keyword_search()` は、book が選択中の 副本で条件検索メソッドが利用可能どうかを調べます。

利用可能なら 1 を返します。 メソッドを持っていないか、そもそも副本が選択されていない場合は 0 を 返します。

#### `int eb_have_multi_search (EB_Book *book)`

関数 `eb_have_multi_search()` は、book が選択中の 副本で複合検索メソッドが利用可能どうかを調べます。

最低 1 種類でも利用可能なら 1 を返します。 メソッドを持っていないか、そもそも副本が選択されていない場合は 0 を 返します。

#### `EB_Error_Code eb_multi_search_list (EB_Book *book, EB_Multi_Search_Code *multi_list, int *multi_count)`

関数 `eb_multi_search_list()` は、book が選択中の 副本に用意されている複合検索を調べ、複合検索コードの一覧を `EB_Multi_Search_Code` 型の配列にして、multi_list の指す領域に書き込みます。 配列は、最大で `EB_MAX_MULTI_SEARCHES` 個の要素を持ちます。 加えて、複合検索の種類数を multi_count の指す領域に書き込みます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、subbook_count の指す領域に 0 を書き込み、原因を示す エラーコードを返します。

あらかじめ、book はいずれかの副本を選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_SUB` を返します。

#### `EB_Error_Code eb_multi_entry_count (EB_Book *book, EB_Multi_Search_Code multi_id, int *entry_count)`

関数 `eb_multi_search_list()` は、book が選択中の 副本に用意されている複合検索 multi_id について調べ、入力語の 個数を entry_count の指す領域に書き込みます。

成功すると、関数は `EB_SUCCESS` を返します。 このとき書き込まれる入力語の個数は、1 以上 `EB_MAX_MULTI_ENTRIES` 以下になります。 失敗すると、entry_count の指す領域には 0 を書き込み、原因を示す エラーコードを返します。

あらかじめ、book はいずれかの副本を選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_SUB` を返します。

#### `EB_Error_Code eb_multi_title (EB_Book *book, EB_Multi_Search_Code multi_id, char *title)`

関数 `eb_multi_search_list()` は、book が選択中の 副本に用意されている複合検索 multi_id の題名を title の指す領域に書き込みます。 題目は最長で `EB_MAX_MULTI_TITLE_LENGTH` バイトになります。 この長さに、ナル文字は含みません。

書籍の文字コード (「[CD-ROM 書籍と `EB_Book` オブジェクト] データ型の詳細」 を参照のこと) が `EB_CHARCODE_ISO8859_1` なら、題目を表す文字列は ISO 8859-1 になり、それ以外の文字コードなら日本語 EUC になります。

書籍によっては、複合検索は用意していても、複合検索の題名データを持って いないことがあります。 その場合、EB ライブラリが代わりに付けた題名が title に 書き込まれます。

書籍の文字コードが `EB_CHARCODE_ISO8859_1` なら、 EB ライブラリが付ける題名は、"Multi Search 1", "Multi Search 2", ... になります。 それ以外の文字コードであれば、題名は日本語 EUC で書かれた「複合検索 1」 「複合検索 2」... という文字列になります。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、label の指す領域には空文字列を書き込み、原因を示す エラーコードを返します。

あらかじめ、book はいずれかの副本を選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_SUB` を返します。

#### `EB_Error_Code eb_multi_entry_label (EB_Book *book, EB_Multi_Search_Code multi_id, int entry_index, char *label)`

関数 `eb_multi_search_list()` は、book が選択中の 副本に用意されている複合検索 multi_id について調べ、 entry_index 番目の検索語の題目を label の指す領域に 書き込みます。 entry_index は、先頭の検索語を 0 番目と数えます。 題目は最長で `EB_MAX_MULTI_LABEL_LENGTH` バイトになります。 この長さに、ナル文字は含みません。

書籍の文字コード (「[CD-ROM 書籍と `EB_Book` オブジェクト] データ型の詳細」 を参照のこと) が `EB_CHARCODE_ISO8859_1` なら、題目を表す文字列は ISO 8859-1 になり、それ以外の文字コードなら日本語 EUC になります。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、label の指す領域には空文字列を書き込み、原因を示す エラーコードを返します。

あらかじめ、book はいずれかの副本を選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_SUB` を返します。

#### `int eb_multi_entry_have_candidates (EB_Book *book, EB_Multi_Search_Code multi_id, int entry_index)`

関数 `eb_multi_search_list()` は、book が選択中の 副本に用意されている複合検索 multi_id について調べ、 entry_index 番目の検索語が候補一覧を持っているかどうか調べます。 entry_index は、先頭の検索語を 0 番目と数えます。

持っていれば 1 を返します。 持っていないか、そもそも副本が選択されていない場合、あるいは multi_id, や entry_index が不正な値だった場合は 0 を返します。

#### `EB_Error_Code eb_multi_entry_candidates (EB_Book *book, EB_Multi_Search_Code multi_id, int entry_index, EB_Position *position)`

関数 `eb_multi_search_list()` は、book が選択中の 副本に用意されている複合検索 multi_id について調べ、 entry_index 番目の検索語の候補一覧の位置を position の指す領域に書き込みます。 先頭の検索語が 0 番目になります。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、positin の指す領域には `eb_seek_text()` が必ず失敗する位置情報を書き込み、原因を示すエラーコードを返します。

あらかじめ、book はいずれかの副本を選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_SUB` を返します。

#### `EB_Error_Code eb_search_word (EB_Book *book, const char *input_word)`

#### `EB_Error_Code eb_search_endword (EB_Book *book, const char *input_word)`

#### `EB_Error_Code eb_search_exactword (EB_Book *book, const char *input_word)`

関数 `eb_search_word()` は、book が選択中の副本に 対する前方一致検索をリクエストします。 同様に `eb_search_endword()` は後方一致検索を、 `eb_search_exactword()` は完全一致検索をリクエストします。

検索する語は、引数 input_word で指定します。 ただし、これらの関数は検索をリクエストするだけで、一致したエントリの 情報を返すことはしません。 一致したエントリの取得には `eb_hit_list()` を使います。 関数は、成功すると `EB_SUCCESS` を返します。 失敗すると、原因を示すエラーコードを返します。 失敗すると、関数を呼び出す前にリクエストしていた検索の状態記録はリセット されますので、その状態のまま `eb_hit_list()` を呼び出しても、 やはり失敗に終わります。

書籍の文字コード (「[CD-ROM 書籍と `EB_Book` オブジェクト] データ型の詳細」 を参照のこと) が `EB_CHARCODE_ISO8859_1` なら、関数に渡す検索語は ISO 8859-1 で書かれていなければなりません。 それ以外の文字コードの場合は、日本語 EUC で書かれていなければなりません。 不正な文字番号を含んでいた場合、関数は `EB_ERR_BAD_WORD` を 返します。

加えて、検索語は 1 バイト以上、`EB_MAX_WORD_LENGTH` (= 255) バイト以下でなければなりません。 この長さに、ナル文字は含みません。 長すぎる場合は、`EB_ERR_TOO_LONG_WORD` を、 長さが 0 (空文字列) の場合は `EB_ERR_EMPTY_WORD` を返します。

あらかじめ、book はいずれかの副本を選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_SUB` を返します。 なお、一致するエントリが最低 1 個あるかどうかは、戻り値には影響しません。

#### `EB_Error_Code eb_search_keyword (EB_Book *book, const char * const input_words[])`

#### `EB_Error_Code eb_search_cross (EB_Book *book, const char * const input_words[])`

#### `EB_Error_Code eb_search_multi (EB_Book *book, EB_Multi_Search_Code multi_id, const char * const input_words[])`

関数 `eb_search_keyword()` は、book が選択中の 副本に対する条件検索をリクエストします。 同様に `eb_search_cross()` はクロス検索を、 `eb_search_multi()` は複合検索をそれぞれリクエストします。

検索する語は、引数 input_words で指定します。 条件検索と複合検索はいずれも複数個の検索語を受け付けますので、検索語を 配列にして渡します。 このとき、配列の末尾の要素には `NULL` を置き、配列の終端を 明示します。

いずれの関数も検索をリクエストするだけで、一致したエントリの情報を 返すことはしません。 一致したエントリの取得には `eb_hit_list()` を使います。 関数は、成功すると `EB_SUCCESS` を返します。 失敗すると、原因を示すエラーコードを返します。 失敗すると、関数を呼び出す前にリクエストしていた検索の状態記録はリセット されますので、その状態のまま `eb_hit_list()` を呼び出しても、 やはり失敗に終わります。

書籍の文字コード (「[CD-ROM 書籍と `EB_Book` オブジェクト] データ型の詳細」 を参照のこと) が `EB_CHARCODE_ISO8859_1` なら、関数に渡す検索語は ISO 8859-1 で書かれていなければなりません。 それ以外の文字コードの場合は、日本語 EUC で書かれていなければなりません。 不正な文字番号を含んでいた場合、関数は `EB_ERR_BAD_WORD` を 返します。

加えて、個々の検索語は `EB_MAX_WORD_LENGTH` (= 255) バイト以下 でなければなりません。 この長さに、ナル文字は含みません。 長すぎる場合は、`EB_ERR_TOO_LONG_WORD` を返します。 長さが 0 バイトの検索語は無視されますが、少なくとも 1 個の検索語は長さ が 1 以上ないといけません。 長さが 1 以上の検索語が 1 つもないときは、`EB_ERR_NO_WORD` を 返します。

末尾の NULL を除いた配列の要素数は、条件検索では `EB_MAX_KEYWORDS` 以下、クロス検索では `EB_MAX_CROSS_ENTRIES` 以下、 複合検索では `EB_MAX_MULTI_ENTRIES` 以下でなくては なりません。 個数が多すぎると `EB_ERRO_TOO_MANY_WORDS` を返します。 空文字列の要素を差し引いた個数ではなく、単純に渡された要素数が上限を 超えているとエラーになりますので、注意が必要です。

あらかじめ、book はいずれかの副本を選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_SUB` を返します。 なお、一致するエントリが最低 1 個あるかどうかは、戻り値には影響しません。

#### `EB_Error_Code eb_hit_list (EB_Book *book, int max_hit_count, EB_Hit *hit_list, int *hit_count)`

関数 `eb_hit_list()` は、あらかじめ以下のいずれかの関数で リクエストされた検索を実行し、一致したエントリを取得します。

- `eb_search_word()` (前方一致検索)
- `eb_search_endword()` (後方一致検索)
- `eb_search_exactword()` (完全一致検索)
- `eb_search_keyword()` (条件検索)
- `eb_search_cross()` (クロス検索)
- `eb_search_multi()` (複合検索)

したがって、この関数を呼ぶ前に、上記のいずれかの関数の呼び出しに成功して いなくてはなりません。

`eb_hit_list()` は最大で max_hit_count 個の 一致エントリを hit_list に書き込みます。 そして、書き込んだ一致エントリの数を hit_count が指す領域に 書き込みます。 それ以上の個数の一致エントリが存在する場合、残ったエントリの情報は、 この関数を繰り返し呼び出すことで得ることができます。

ただし、以下に挙げた関数を呼び出すと、リクエストした検索に関する状態記録 がリセットされますので、一致したエントリの取得は継続できなくなります。

- `eb_set_subbook()`
- `eb_unset_subbook()`
- `eb_load_all_subbooks()`
- `eb_bind()`
- `eb_finalize_book()`
- `eb_search_word()`
- `eb_search_endword()`
- `eb_search_exactword()`
- `eb_search_keyword()`
- `eb_search_cross()`
- `eb_search_multi()`

繰り返し呼んだ場合も、一致したエントリの情報はその都度 hit_list の先頭から書き込み、hit_count が指す領域に書き込む値も、その回 の `eb_hit_list()` の呼び出しで書き込んだ一致エントリの数に なります。

成功すると、この関数は `EB_SUCCESS` を返します。 たとえ一致したエントリがなくても、処理が正常に終了すれば、関数は `EB_SUCCESS` を返します。

失敗すると、hit_count が指す領域に 0 を書き込み、原因を示す エラーコードを返します。 この場合、リクエストしていた検索の状態記録はリセットされますので、 これ以上 `eb_hit_list()` を呼んで、残った一致エントリを取得 することはできなくなります。

あらかじめ、book はいずれかの副本を選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_SUB` を返します。 また、先に挙げた検索のリクエストが成功していない状態でこの関数を呼ぶと、 `EB_ERR_NO_PREV_SEARCH` を返します。

## テキストデータ

テキストデータの取得は、検索と並ぶ重要な機能です。

ここで言う テキストデータ (text data) は、 本文 (text body) という意味ではありません。 CD-ROM 書籍には確かに本文も存在しますが、本文と同じデータ形式を用いて 書かれたデータが数種類あります。 本書では、これらのデータをまとめてテキストデータと呼んでいます。 EB ライブラリが扱えるテキストデータの種類には、次のものがあります。

- 見出し
- 本文
- メニュー
- 著作権表示
- 複合検索の入力語の候補一覧

本章では、これらのテキストデータの取得と加工方法について説明します。

### テキストデータのシークと読み込み

UNIX でプログラムを組んだ経験のある方には、ファイルからデータを読み込む 際に用いる `lseek()`, `read()` というシステムコール をご存じの方も多いでしょう。

EB ライブラリでも、テキストデータの取得には、シーク (seek) と 読み込み (read) という 2 つの操作で行います。 ただし、EB ライブラリではファイルポインタやディスクリプタはなく、 `EB_Book` オブジェクトを通じてシークや読み込みの操作を行います。

また、シーク時に指定する位置も `off_t` 型ではなく、 `EB_Position` 型 (「[検索] データ型の詳細」 を参照のこと) のオブジェクトを用います。 たとえば、本文の先頭位置は、`eb_text()` という関数を使って 次のように取得できますが、このときも位置データは `EB_Position` 型オブジェクトに書き込まれます。

>     EB_Position position;

>     /* 関数の処理が成功すると、position に本文の開始位置が
>      * 書き込まれます。 */
>     if (eb_text(&book, &position) != EB_SUCCESS) {
>         fprintf(stderr, "an error occurs.\n");
>         return;
>     }

参考までに、`EB_Position` 型の内部構造は、次のようになっています。

>     typedef struct EB_Position_Struct EB_Position;

>     struct EB_Position_Struct {
>         int page;     /* ページ番号 */
>         int offset;   /* ページ内のオフセット */
>     };

検索して見つかった一致エントリの見出しや本文を読み込む際にも、位置情報 の指定には `EB_Position` 型が使われます。 一致したエントリの情報は、関数 `eb_hit_list()` によって `EB_Hit` という型のオブジェクトに書き込まれますが、 `EB_Hit` 型は次のように定義されています。 (詳しくは 「[検索] データ型の詳細」 を参照のこと。)

>     typedef struct {
>         EB_Position heading;   /* 見出しの位置 */
>         EB_Position text;      /* 本文の位置   */
>     } EB_Hit;

つまり、このときの見出しと本文の位置も、`EB_Position` 型で 表現されているのです。

では、実際のプログラムを例にして、シークと読み込みを行ってみます。 まずは、シークからです。 これには関数 `eb_seek_text()` を用います。 ここでもやはり、位置は `EB_Position` 型で渡します。

>     if (eb_seek_text(&book, &position) != EB_SUCCESS) {
>         fprintf(stderr, "an error occurs.\n");
>         return;
>     }

データの種類 (見出し、本文 ...) によらず、テキストデータのシークは すべて `eb_seek_text()` で行います。

ただし、`EB_Book` オブジェクトは、テキストデータの種類別に 読み込み位置を覚えているわけではなく、全種類のテキストデータで共有する 位置情報を一つ覚えているだけです。 たとえば、本文を読み込んだ後で、別の位置にシークして見出しを読み込むと、 `EB_Book` は本文の読み込み位置のことは忘れてしまいます。

さて、シークが終わったら、データを読み込みます。 読み込もうとするテキストデータの種類によって、使用する関数が異なります。 見出しだけは `eb_read_heading()` を使いますが、それ以外では `eb_read_text()` を使います。

以下は、`eb_read_text()` の使用例です。

>     #define MAX_LENGTH 1000
>     char buffer[MAX_LENGTH + 1];
>     ssize_t text_length;

>     if (eb_read_text(&book, NULL, NULL, NULL, MAX_LENGTH,
>         text, &text_length) != EB_SUCCESS) {
>         fprintf(stderr, "an error occurs.\n");
>         return;
>     }

成功すると、`text` にはテキストデータが、 `text_length` には実際に読み込んだバイト数が書き込まれます。 テキストは最大で `MAX_LENGTH` バイト書き込まれます。 テキストデータはさらにナル文字で終端されますので、`buffer` には もう 1 バイト分の領域が必要になります。

`eb_read_heading()` の呼び出し方も、`eb_read_text()` とまったく変わりません。

>     if (eb_read_heading(&book, NULL, NULL, NULL, MAX_LENGTH,
>         text, &text_length) != EB_SUCCESS) {
>         fprintf(stderr, "an error occurs.\n");
>         return;
>     }

`eb_read_text()` や `eb_read_heading()` で読み込んだ テキストデータは平文のテキストになっていて、ナル文字で終端されています。

>     printf("%s\n", text);   /* 出力してみる */

読み込みたいテキストデータが長すぎて、`eb_read_text()` あるいは `eb_read_heading()` を一回呼び出しただけでは全部 読み込めなかった場合は、再度呼び出すことで続きのデータを読み込むことが できます。

### テキストデータの内部形式

前節の例では、読み込んだテキストデータは、平文テキストになっていました。 けれども、CD-ROM 書籍内に平文テキストのデータが、そのまま収録されている わけではありません。

実際のテキストデータの例を、以下に示します。 左側のブロックは 16 進数でダンプした様子で、右側はそれを基に JIS X 0208 (日本語のかな漢字) の文字を表している部分を `[　]` という形に 直したものです。

>          (16進数によるダンプ)            (可能な部分をかな漢字に変換)
>     1f0900011f41010026321f611f042121   1f0900011f410100[Σ]1f611f04[　]
>     212721211f053e704a734a541f0a1f04   [：][　]1f05[情][報][編]1f0a1f04
>     214e1f0525372530255e1f04214f2121   [［]1f05[シ][グ][マ]1f04[］][　]
>     214a237323692367236d236121212370   [（][ｓ][ｉ][ｇ][ｍ][ａ][　][ｐ]
>     2372236f236a236523632374214b1f05   [ｒ][ｏ][ｊ][ｅ][ｃ][ｔ][）]1f05

右側のブロックを見ると、おおよそ平文に近い形でテキストデータが収められて いることが分かりますが、ところどころに「文字」ではないデータも含まれて います。

文字ではない部分は、すべて「エスケープシーケンス」と呼ばれるものです。 エスケープシーケンスとは、テキストデータを出力する際に、改行の禁止や 強調修飾といった制御情報を伝えるための仕組みです。 16 進数の `1f` が、エスケープシーケンスの開始を意味します。

参考までに、上のテキストデータで使われているエスケープシーケンスを すべて列挙すると、次のようになります。

`1f09 0001`
  字下げ (インデント) の量を指定。 (引数が 0001 なので、字下げ量は 1。)
`1f41 0100`
  検索キーの開始。 (引数 0100 の意味については、JIS X 4081 に記述がないため不明。)
`1f61`
  検索キーの終了。
`1f04`
  半角表示の開始。
`1f05`
  半角表示の終了。
`1f0a`
  改行

前節のプログラムで、読み込んだデータが平文テキストになっていたのは、 実は EB ライブラリが加工処理をしたからです。 つまり、「改行」のように平文テキストでも表現可能なエスケープシーケンス については処理し、「検索キーの開始」のように表現できないものについては 無視するようにして、平文テキストになるように加工していたのです。

しかし、平文テキストは表現力が乏しいので、元のデータには含まれている エスケープシーケンスの多くを無視することになってしまいます。 HTML のように、もっと表現力のある形式で出力するなら、無視せずに済む シーケンスを増やせそうです。 では、HTML 形式でテキストデータを取得する関数が EB ライブラリに用意されて いるかというと、残念ながらありません。

その代わりに、かなり手間はかかりますが、自由にテキストデータを加工できる ための仕組みが用意されています。 それが、次の節で説明する フック (hook) です。 フックを使うことで、テキストデータを柔軟に加工することができます。

### フック

特に何も指定しなければ、`eb_read_text()`, `eb_read_heading()` が返すテキストデータの加工は、あらかじめ 決められた通りの方法で行われます。 たとえば、「改行」のエスケープシーケンスに対しては、`\n` を 書き込むようになっています。

フック (hook) を使うと、こうした加工方法を変えることができます。 フックは、あらかじめ決められたフック設定位置に対して、フック関数を登録 することで有効になります。 フック関数が登録されていると、`eb_read_text()` や `eb_read_heading()` は、あらかじめ決まったやり方でデータを 書き込む代わりに、フック関数を呼び出します。 呼び出されたフック関数がデータの書き込み処理を行うことで、 `eb_read_text()` や `eb_read_heading()` から返る テキストデータが変化するというわけです。

EB ライブラリには、多数のフック設定位置が用意されています。 各エスケープシーケンスには、それぞれ専用にフックが用意されており、 それ以外にも文字のためのフックが存在します。 (どのようなフック設定位置があるか、詳しくは 「フックコードの一覧」 を参照のこと。)

それぞれのフック設定位置は、フックコード (hook code) と 呼ばれるコード値で識別されます。 たとえば、前述の「改行」のエスケープシーケンスに対応するフックコード は `EB_HOOK_NEWLINE` になります。

アプリケーションプログラムがフックを扱うには、フックの集合である フックセット (hook set) を用意します。 これは、EB ライブラリで利用可能なすべてのフック設定位置に対して、どの フック関数を使うのかを記録するためのオブジェクトです。

では、実際にどうやってフックセットを扱うのか、説明していきましょう。 フックセットは `EB_Hookset` 型のオブジェクトで表しますので、 まず `EB_Hookset` オブジェクトを用意します。

>     EB_Hookset hookset;

`EB_Hookset` オブジェクトは、`EB_Book` オブジェクト と同様に、使用前に必ず初期化する必要があります。

>     eb_initialize_hookset(&hookset);

実際のフック関数は、次のようなものになります。 この例では、フック関数の中で `eb_write_text_string()` という 関数を呼び出して、`<br>` という文字列をテキストデータ として書き込んでいます。

>     EB_Error_Code
>     hook_newline(EB_Book *book, EB_Appendix *appendix, void *container,
>         EB_Hook_Code code, int argc, const unsigned int *argv) {
>         eb_write_text_string(book, "<br>");
>         return 0;
>     }

関数 `eb_set_hook()` を用いることで、このフック関数を フックセットに登録することができます。 ただし、まず `EB_Hook` という型のオブジェクトにいったん フックコードとフック関数を設定し、それを `eb_set_hook()` を 渡してやる必要があります。 ここでは、「改行」を表すエスケープシーケンスに対して、上記のフック関数 を登録してみます。

>     EB_Hook hook;

>     hook.code = EB_HOOK_NEWLINE;   # フックコードをセット
>     hook.function = hook_newline;  # フック関数をセット
>     eb_set_hook(&hookset, &hook);

なお、同じフック設定位置 (フックコード) に複数回フック関数を登録しても、 有効になるのは最後に登録したものだけですので、注意して下さい。 フック関数として `NULL` を指定すると、登録されているフックが 解除されます。

関数 `eb_set_hooks()` (最後に `s` が付く) を使えば、 複数のフック関数を一度に登録できます。

>     static const EB_Hook hooks[] = {
>         {EB_HOOK_NEWLINE,        hook_newline},
>         {EB_HOOK_SET_INDENT,     hook_set_indent},
>         {EB_HOOK_WIDE_JISX0208,  hook_set_jisx0208},
>         {EB_HOOK_NULL,           NULL}
>     };

>     eb_set_hooks(&hookset, &hooks);

配列の末尾を明示するために、`EB_HOOK_NULL` という特殊な フックコードを置きます。 この点も注意して下さい。

こうしてフック関数を登録したフックセットを、`eb_raed_text()`, `eb_raed_heading()` への引数として渡します。 前節までの例では、`NULL` を渡していましたが、代わりに `&hookset` を渡してみます。

>     if (eb_read_text(&book, NULL, &hookset, NULL, MAX_LENGTH,
>         text, &text_length) != EB_SUCCESS) {
>         fprintf(stderr, "an error occurs.\n");
>         return;
>     }

これによって、テキストデータ中に改行を表すエスケープシーケンスがあると、 `\n` の代わりに `<br>` という文字列が 書き込まれるようになります。

`EB_Hookset` オブジェクトを使い終わったら、 `eb_finalize_hookset()` を呼んで後始末をします。

>     eb_finalize_hookset(&hookset);

### フックと文字コードの関係

前節では、エスケープシーケンスに対するフックを例にとりましたが、この他 にも、EB ライブラリには文字に対するフックが用意されています。

`EB_HOOK_ISO8859_1`
  ISO 8859-1 (ラテン文字 1) 文字へのフック。ただし制御文字を除きます。 引数として、ISO 8859-1 の文字番号がフック関数に渡されます。
`EB_HOOK_NARROW_JISX0208`
  半角の JIS X 0208 (日本語のかな漢字) 文字へのフック。 引数として、日本語 EUC で表現した場合の文字番号が、フック関数に渡されます。
`EB_HOOK_WIDE_JISX0208`
  全角の JIS X 0208 (日本語のかな漢字) 文字へのフック。 引数として、日本語 EUC で表現した場合の文字番号が、フック関数に渡されます。
`EB_HOOK_GB2312`
  GB 2312 (中国語の簡体字) 文字へのフック。 引数として、中国語 EUC で表現した場合の文字番号が、フック関数に渡されます。
`EB_HOOK_NARROW_FONT`
  半角の外字へのフック。 引数として、外字の文字番号が、フック関数に渡されます。
`EB_HOOK_WIDE_FONT`
  半角の外字へのフック。 引数として、外字の文字番号が、フック関数に渡されます。

いずれも、その文字がテキストデータ中に現れる度に、フック関数が呼び出され ます。

上の記述を見ても分かるように、フック関数に渡される文字番号は、書籍の文字 コードに応じて、ISO 8859-1, 日本語 EUC、中国語 EUC のいずれかの文字コード で表現されたものになります。

フック関数を登録しなければ、その文字番号がテキストデータとしてそのまま 書き込まれます。

もし、アプリケーションプログラムが、EB ライブラリの内部コードとは異なる 文字コードを使用したい場合は、これらのフックのフック関数を登録して、 コード変換処理をするのも手です。 ただし、一文字毎にフック関数が呼び出されるので、相応の負荷がかかります。

また、EBXA-C を扱うには、特別な処理が必要です。 EBXA-C では、文字コードとして GB 2312 と JIS X 0208 が使われますが (「文字コード」 を参照のこと)、EB ライブラリによる標準の処理 では、どちらも 0xa1a1 〜 0xfefe にマッピングされて衝突するため、最低 でもどちらか一方をフックして文字の表現方法を変えないと、正しく出力 できません。

### クロス検索の検索結果

すでに 「検索」 の章で述べたように、CD-ROM 書籍 には前方一致検索、後方一致検索といった複数の検索メソッドがあります。 EB ライブラリで検索を行うと、どの検索メソッドでも、一致したエントリの 情報は、以下のような `EB_Hit` 型のオブジェクトとして 受け取ります。

>     typedef struct {
>         EB_Position heading;   /* 見出しの位置 */
>         EB_Position text;      /* 本文の位置   */
>     } EB_Hit;

しかしクロス検索では、`EB_Hit` の見出しと本文の位置は まったく同じになります。 したがって、見出しと本文のテキストデータを読み込むには、他の検索メソッド のようにそれぞれの位置にシークして読み込むというやり方ではうまく いきません。

以下に、クロス検索の見出しと本文を読み込むプログラム例を示します。

>     /* 見出し位置へのシークを行う */
>     if (eb_seek_text(&book, &hits[0].heading) != EB_SUCCESS) {
>         fprintf(stderr, "an error occurs.\n");
>         return;
>     }
>     /* 見出しの読み込みを行う */
>     if (eb_read_heading(&book, NULL, NULL, NULL, MAX_LENGTH,
>         heading, &heading_length) != EB_SUCCESS) {
>         fprintf(stderr, "an error occurs.\n");
>         return;
>     }
>     /* 先ほど読み込んだ見出しの、次の部分へ飛ぶ */
>     if (eb_forward_heading(&book) != EB_SUCCESS) {
>         fprintf(stderr, "an error occurs.\n");
>         return;
>     }
>     /* 本文の読み込みを行う */
>     if (eb_read_heading(&book, NULL, NULL, NULL, MAX_LENGTH,
>         text, &text_length) != EB_SUCCESS) {
>         fprintf(stderr, "an error occurs.\n");
>         return;
>     }

クロス検索でも、見出しの内容を読み込む方法は他の検索メソッドと変わり はなく、`eb_read_heading()` を使います。 変わっているのは、本文の読み込みです。 `eb_read_text()` ではなく、`eb_read_heading()` を使います。 見出しを読み込むための関数 `eb_read_heading()` を、本文を 読み込むために呼ぶというのは奇妙な話ですが、これはクロス検索の本文が 見出しと同じ形式になっているためです。 通常、見出しは一行程度しか書かれていませんが、実際のところクロス検索 の本文も一行程度しかありません。

また、本文は見出しのすぐ後に書かれているため、上記のように見出しを 読み込んだ後で `eb_forward_heading()` という関数を呼び、 その後で本文を読み込むためにもう一度 `eb_read_heading()` を 呼ぶという変わった手順を踏みます。

本文だけが必要で見出しが要らなければ、シーク直後に `eb_forward_heading()` を呼ぶようにします。 その後で `eb_read_heading()` を呼ぶと、本文を読み込みます。

### 著作権表示

先に記したように、テキストデータには何種類かあり、その中に 著作権表示 (copyright notice) というものがあります。 名前の通り、著作権表示に関するテキストデータを収めたものです。

一般に、著作権表示は本文とはまったく独立したデータとして用意されます。 したがって、本文を先頭から末尾まで読んでみても、著作権表示はどこにも 見つかりません。

選択中の副本について、著作権表示の開始位置を知るには `eb_copyright()` を使います。 この関数は、副本が著作権表示を持っていなければ `EB_ERR_NO_SUCH_SEARCH` を返しますので、著作権表示の有無も 同時に分かります。 (開始位置は取得せずに、有無だけを調べたいときは、 `eb_have_copyright()` という関数が使えます。)

>     EB_Position position;
>     EB_Error_Code err;

>     err = eb_copyright(&book, &position);
>     if (err == EB_ERR_NO_SUCH_SEARCH) {
>         /* 著作権表示はない */
>     } else if (err != EB_SUCCESS) {
>         /* それ以外のエラー */
>        return;
>     }

後は、得られた位置 (`position`) にシークして、 `eb_read_text()` でテキストデータを読み込みます。

### メニュー

本文とは独立したテキストデータとしては、著作権表示の他に メニュー (menu) というものがあります。 メニューは、主に本文の補助となるデータを収録しています。 代表的なものでは、「前書き (序)」「凡例」といったものが挙げられます。

メニューでは「別項目参照」というエスケープシーケンスを多用して、階層的 な構造になっているのが一般的です。 このエスケープシーケンスには、参照先のテキストの位置が記録されています。

たとえば、ある CD-ROM 書籍のメニューが次のようになっていたとします。 この例では、メニューには 3 つの項目があります。

>      * 序文
>      * 表記について
>      * 奥付

メニューのそれぞれの項目には、参照先があります。 テキストデータの内部表現では、「序文」「表記について」「奥付」の それぞれの文字列の前後に別項目参照開始および終了エスケープシーケンスが 付いた形になっています。 視覚的に分かるように記すと、次のような形になっています。

>      * <別項目参照開始シーケンス> "序文" <別項目参照終了シーケンス>
>      * <別項目参照開始シーケンス> "表記" <別項目参照終了シーケンス>
>      * <別項目参照開始シーケンス> "奥付" <別項目参照終了シーケンス>

HTML の書き方を知っているなら、`a` タグと言えば分かるのでは ないかと思います。

>     <a href="./index.html">EB ライブラリのホームページ</a>

ただし、参照先の位置情報は終了シーケンス側に記載されますので、この点は HTML とは逆になります。 蛇足ですが、別位置参照はメニューだけでなく、本文でも一般的に使用されます。

別項目参照開始および終了シーケンスに対して、それぞれフック `EB_HOOK_BEGIN_REFERENCE` と `EB_HOOK_END_REFERENCE` が用意されています。 参照先の位置情報は、終了シーケンスへのフック関数に対して、引数として 渡されます。 たとえば、`EB_HOOK_END_REFERENCE` へのフック関数の冒頭では、 次のようにすると良いかも知れません。

>     EB_Error_Code
>     hook_end_ref(EB_Book *book, EB_Appendix *appendix, void *container,
>         EB_Hook_Code code, int argc, const unsigned int *argv)
>     {
>         EB_Position position;

>         position.page = argv[1];    # 参照先のページ番号
>         position.offset = argv[2];  # 参照先のオフセット

参照先は、メニューの第 2 層となります。 この書籍の「奥付」の参照先を辿ったら、次のような表記になっていました。

>     ○○堂出版社 新国語辞典 第 2 版 (EPWING 版)
>     第 1 版 発行 1988年 2月
>     第 2 版 発行 1999年 11月
>     第 2 版 (EPWING 版) 発行 2000年 2月

同様に「序文」「表記に付いて」の参照先についても、こうした文章データ が用意されていました。 図示すると、メニューの階層は次のようになります。

>     　　　　　　　　　　　　┌─────┐
>     第１層　　　　　　　　　│メニュー　│
>     　　　　　　　　　　　　└──┰──┘
>     　　　　　　　　　　　　　　　┃
>     　　　　　　　┏━━━━━━━╋━━━━━━━┓
>     　　　　　　　┃　　　　　　　┃　　　　　　　┃
>     　　　　┌──┸──┐　┌──┸──┐　┌──┸──┐
>     第２層　│メニュー　│　│メニュー　│　│メニュー　│
>     　　　　└─────┘　└─────┘　└─────┘

この辞書の例では、メニューはここで終わりになっていますが、書籍によっては さらに第 3 層、第 4 層と続く場合もあります。 また、メニュー全体が均一の階層数になっているとは限りません。 メニューの参照先が本文や著作権表示になっていることもあります。

選択中の副本について、(第 1 層の) メニューの開始位置 を知るには `eb_menu()` を使います。 この関数は、副本がメニューを持っていなければ `EB_ERR_NO_SUCH_SEARCH` を返しますので、メニューの有無も同時に 分かります。 (開始位置は取得せずに、有無だけを調べたいときは、 `eb_have_menu()` という関数が使えます。)

>     EB_Position position;
>     EB_Error_Code err;

>     err = eb_menu(&book, &position);
>     if (err == EB_ERR_NO_SUCH_SEARCH) {
>         /* メニューはない */
>     } else if (err != EB_SUCCESS) {
>         /* それ以外のエラー */
>        return;
>     }

後は、得られた位置 (`position`) にシークして、 `eb_read_text()` でテキストデータを読み込みます。

### 複合検索の候補一覧

「複合検索」(「複合検索」 を参照のこと) のところで述べたように、 複合検索では、入力語に 候補一覧 (candidates) が用意されている ことがあります。 これは、入力語として有効な語をあらかじめ列挙しておき、 アプリケーションプログラムのユーザに選択させる仕組みです。

たとえば、人名を検索するのために、次のような複合検索があったとします。

>     入力語 0: 国・地域
>     入力語 1: 時代
>     入力語 2: 性別
>     入力語 3: キーワード
>     入力語 4: キーワード

このうち、入力語 3 の「性別」には、入力語として有効な語は「男」と「女」 の 2 つしかないでしょう。 このように、入力語として有効な語が限られている場合に、候補一覧が用意 されていることがあります。

候補一覧は検索のためのデータではありますが、内部構造はテキストデータ そのものです。 ユーザに対して候補を列記した示したテキストを示し、その中の一つを選択 してもらうようになっています。

しかも、候補一覧のデータ構造はメニューと非常に似ており、メニューの ような階層構造を持っています (「メニュー」 を参照のこと)。 たとえば、上の複合検索の入力語 2 「国・地域」にも候補の一覧を設けると したら、最初の階層は次のようになるかも知れません。

>     * 日本 (→選択)
>     * 日本以外のアジア (→詳細)
>     * ヨーロッパ (→詳細)
>     * 北アメリカ (→詳細)
>     * その他 (→詳細)

「日本」を選ぶと、そこで入力語が決定されたことになります。しかし、 それ以外の項目についてはさらに細かく分類された選択肢が用意されて います。 ここでは、「北アメリカ」を選んでみましょう。 すると、さらに次のような候補一覧のデータが提示されます。

>     * アメリカ (→選択)
>     * カナダ (→選択)

ここで、「アメリカ」「カナダ」を選ぶと、入力語が決定されます。

次に実際に、EB ライブラリを使ってこうした候補一覧を扱う方法について 説明します。 まず、アプリケーションプログラムは、複合検索の入力語が候補一覧を持って いるかどうかを、確認する必要があるでしょう。 `eb_multi_entry_candidates()` を使うと、候補一覧データの開始位置 を取得することができます。 この関数は、候補一覧を持っていなければ `EB_ERR_NO_CANDIDATES` を 返しますので、候補一覧の有無も分かります。 (開始位置は取得せずに、有無だけを調べたいときは、 `eb_multi_entry_have_candidates()` という関数が使えます。)

>     EB_Position position;
>     EB_Error_Code err;

>     /* mulit_id, entry_id で、どの複合検索の
>      * 何番目の入力語について確認するのかを指定します。*/
>     err = eb_multi_entry_candidates(&book, multi_id, entry_id, &position);
>     if (err == EB_ERR_NO_CANDIDATES) {
>         /* この入力語には、候補一覧が用意されていない */
>        return;
>     } else if (err != EB_SUCCESS) {
>         /* それ以外のエラー */
>        return;
>     }

後は、得られた位置 (`position`) にシークして、 `eb_read_text()` でテキストデータを読み込みます。 読み込んだテキストでは、候補となる語のそれぞれが候補開始と終了を表す エスケープシーケンスに挟まれた形になっています。

>     * <候補開始シーケンス> "日本" <候補終了シーケンス>
>     * <候補開始シーケンス> "日本以外のアジア" <候補終了シーケンス>
>     * <候補開始シーケンス> "ヨーロッパ" <候補終了シーケンス>
>     * <候補開始シーケンス> "北アメリカ" <候補終了シーケンス>
>     * <候補開始シーケンス> "その他" <候補終了シーケンス>

候補開始シーケンスに対しては、フックとして `EB_HOOK_BEGIN_CANDIDATE` が用意されています。 終了シーケンスに対するフックは 2 種類あって、さらに次の階層へ続く場合 に呼ばれる `EB_HOOK_END_CANDIDATE_GROUP` と、その語がそのまま 入力語の候補となる場合に呼ばれる `EB_HOOK_END_GROUP_LEAF` に 分かれています。

次の階層のデータの開始位置は、終了シーケンスのフック関数に、引数として 渡ってきます。 (この点もメニューと同様なので、メニューの解説を参考にして下さい。)

終了シーケンスに対するフック関数の中では、`eb_current_candidate()` という関数が使えます。 この関数は、開始シーケンスと終了シーケンスの間に挟まれた「候補」の文字列 (ポインタ) を返します。

>     const char *candidate;

>     candidate = eb_current_candidate(book);

### 区切りコードの問題

本文は、先頭から末尾まで一本の繋がったデータ列になっています。 英語辞典なら、最初の単語 `A' から最後の `zzz' までの説明が、すべて一つの 「本文」の中に書かれることになります。

一般に、アプリケーションプログラムがある単語を検索した際は、本文の中から その単語を説明した部分だけを抜き出して出力することになるでしょう。 たとえば、`dictionary' という単語を引いた場合、次のような文章が出力される 事が期待されます。 その次や、次の次の単語の説明まで延々と表示されることを、おそらく大半の ユーザは望まない筈です。

>     dictionary [名] (複: dictionaries)
>     辞典、事典
>     [類義] lexicon, glossary (用語辞典), encyclopedia (百科事典)

しかし、困ったことに CD-ROM 書籍には、単語の説明の終わりを示す印 (エスケープシーケンス) が定義されていません。 つまり、ある語の説明部分を正確に抜き出すことは、電子ブックや EPWING では 不可能なのです。

しかしながら、幸いにも市販の書籍の多くには、単語の説明の終了位置にだけ 出現する、特有のエスケープシーケンスが存在します。 もちろん、このエスケープシーケンスは本来「単語の説明の終了」を示すもの ではなく別の用途として用いるのですが、「終了位置」として代用できる という意味です。

EB ライブラリでは、この「終了位置」の印に使えるエスケープシーケンスの ことを、区切りコード (stop code) と呼んでいます。 EB ライブラリは区切りコードを自動判定する機能を持っていますが、判定は 完璧ではないので外れることもあります。 外れると本文が途中で途切れたり、本文の続きが延々と出力されたりします。

その場合は、明示的に appendix (詳しくは ebappendix コマンドのマニュアル の「appendix (付録) とは」を参照のこと) で区切りコードを指定することによって回避できる書籍もありますが、 残念ながら区切りコードがまったく存在しない書籍も少数ながら存在します。 区切りコードを持たない書籍に対して、有効な対処方法は今のところありません。

`eb_read_text()` による本文の取得では、区切りコードが検出された 時点で読み込みを止めます。 さらに繰り返し `eb_read_text()` を呼んでも、区切りコードより先の 本文は読み込めません。

区切りコードを検出したかどうかの判定には、`eb_is_text_stopped()` を使います。 この関数は、最後に読み込みを行ったテキストデータの中に、区切りコードを 検出していれば 1 を返します。

本文以外のテキストデータにも区切りコードの概念は存在しますので、 `eb_is_text_stopped()` を使って区切りコードを検出できます。 しかし、本文以外では EB ライブラリが確実に区切りを判別できますので、 誤判定の問題は起きません。

見出しにおける区切りは、それぞれの単語の見出しの終了位置となります。 メニューおよび複合検索の候補一覧では、階層化された個々のメニューデータ の終了位置で区切りと判定されます。 (同一階層に複数個のメニューデータがあっても、個々のメニューデータで 区切られます。) 著作権表示では、全文の終了位置で区切りと判定されます。

### サンプルプログラム

>     /*                                                            -*- C -*-
>      * Copyright (c) 1999-2006  Motoyuki Kasahara
>      *
>      * Redistribution and use in source and binary forms, with or without
>      * modification, are permitted provided that the following conditions
>      * are met:
>      * 1. Redistributions of source code must retain the above copyright
>      *    notice, this list of conditions and the following disclaimer.
>      * 2. Redistributions in binary form must reproduce the above copyright
>      *    notice, this list of conditions and the following disclaimer in the
>      *    documentation and/or other materials provided with the distribution.
>      * 3. Neither the name of the project nor the names of its contributors
>      *    may be used to endorse or promote products derived from this software
>      *    without specific prior written permission.
>      *
>      * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
>      * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>      * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
>      * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
>      * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
>      * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
>      * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
>      * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
>      * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
>      * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
>      * SUCH DAMAGE.
>      */

>     /*
>      * 使用方法:
>      *     text <book-path> <subbook-index> <number>
>      * 例:
>      *     text /cdrom 0 10
>      * 説明:
>      *     <book-path> で指定した CD-ROM 書籍から特定の副本を選び、本文
>      *     の先頭から <number> 個分の単語の説明を出力します。
>      *
>      *     <subbook-index> には、検索対象の副本のインデックスを指定しま
>      *     す。インデックスは、書籍の最初の副本から順に 0、1、2 ... に
>      *     なります。
>      */
>     #include <stdio.h>
>     #include <stdlib.h>

>     #include <eb/eb.h>
>     #include <eb/error.h>
>     #include <eb/text.h>

>     #define MAXLEN_TEXT 1023

>     int
>     main(int argc, char *argv[])
>     {
>         EB_Error_Code error_code;
>         EB_Book book;
>         EB_Subbook_Code subbook_list[EB_MAX_SUBBOOKS];
>         int subbook_count;
>         int subbook_index;
>         EB_Position text_position;
>         char text[MAXLEN_TEXT + 1];
>         ssize_t text_length;
>         int text_count;
>         int i;

>         /* コマンド行引数をチェック。*/
>         if (argc != 4) {
>             fprintf(stderr, "Usage: %s book-path subbook-index number\n",
>                 argv[0]);
>             exit(1);
>         }
>         text_count = atoi(argv[3]);

>         /* EB ライブラリと `book' を初期化。*/
>         eb_initialize_library();
>         eb_initialize_book(&book);

>         /* 書籍を `book' に結び付ける。*/
>         error_code = eb_bind(&book, argv[1]);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to bind the book, %s: %s\n",
>                 argv[0], eb_error_message(error_code), argv[1]);
>             goto die;
>         }

>         /* 副本の一覧を取得。*/
>         error_code = eb_subbook_list(&book, subbook_list, &subbook_count);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to get the subbbook list, %s\n",
>                 argv[0], eb_error_message(error_code));
>             goto die;
>         }

>         /* 副本のインデックスを取得。*/
>         subbook_index = atoi(argv[2]);

>         /*「現在の副本 (current subbook)」を設定。*/
>         error_code = eb_set_subbook(&book, subbook_list[subbook_index]);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to set the current subbook, %s\n",
>                 argv[0], eb_error_message(error_code));
>             goto die;
>         }

>         /* テキストの開始位置を取得。*/
>         error_code = eb_text(&book, &text_position);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to get text information, %s\n",
>                 argv[0], eb_error_message(error_code));
>             goto die;
>         }

>         /* テキストをシーク。*/
>         error_code = eb_seek_text(&book, &text_position);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to seek text, %s\n",
>                 argv[0], eb_error_message(error_code));
>             goto die;
>         }

>         i = 0;
>         while (i < text_count) {
>             /* テキストを取得。*/
>             error_code = eb_read_text(&book, NULL, NULL, NULL, MAXLEN_TEXT,
>                 text, &text_length);
>             if (error_code != EB_SUCCESS) {
>                 fprintf(stderr, "%s: failed to read text, %s\n",
>                     argv[0], eb_error_message(error_code));
>                 goto die;
>             }
>             fputs(text, stdout);

>             if (!eb_is_text_stopped(&book))
>                 continue;

>             fputs("\n----------------------------------------\n", stdout);

>             /* 次の単語の説明へ移動。*/
>             error_code = eb_forward_text(&book, NULL);
>             if (error_code == EB_ERR_END_OF_CONTENT)
>                 fputs("\n[END]\n", stdout);
>             else if (error_code != EB_SUCCESS) {
>                 fprintf(stderr, "%s: failed to read text, %s\n",
>                     argv[0], eb_error_message(error_code));
>                 goto die;
>             }
>             i++;
>         }

>         /* 書籍と EB ライブラリの利用を終了。*/
>         eb_finalize_book(&book);
>         eb_finalize_library();
>         exit(0);

>         /* エラー発生で終了するときの処理。*/
>       die:
>         eb_finalize_book(&book);
>         eb_finalize_library();
>         exit(1);
>     }

### データ型の詳細

この節で説明しているデータ型を使うには、次のようにヘッダファイルを 読み込んで下さい。

>     #include <eb/eb.h>

#### `EB_Hook_Code` 型

データ型 `EB_Hook_Hook` は、フックの設定位置コードを表します。

この型は符合付き整数型の別名として定義されていますので、2 つのコードを 2 項演算子 `==` と `!=` で一致比較することができます。

EB ライブラリでは、全部で `EB_NUMBER_OF_HOOKS` 個のフックコード を定義しています。 定義されている設定位置コードの一覧については、 次の節 (「フックコードの一覧」 を参照のこと) を参照して下さい。

#### `EB_Hook` 型

データ型 `EB_Hook` は、フックコードとそれに対応するフック関数 の組を表します。 内部構造は、次のように定義されています。

>     typedef struct EB_Hook_Struct EB_Hook;

>     struct EB_Hook_Struct {
>         EB_Hook_Code code;
>         EB_Error_Code (*FUNC)(EB_Book *, EB_Appendix *, void *,
>             EB_Hook_Code, int, const unsigned int *);
>     };

アプリケーションプログラムは、直接 `EB_Hook` オブジェクトの メンバを参照したり、セットしたりしても構いません。

#### `EB_Hookset` 型

データ型 `EB_Hookset` は、フック一式を表します。 EB ライブラリで利用可能なすべてのフック設定位置に対して、どのような フック関数を指定するのかを記録するための型です。

`EB_Hookiset` オブジェクトの操作は、すべて EB ライブラリが用意 している関数で行います。 アプリケーションプログラムは、直接 `EB_Hookset` オブジェクトの メンバを参照したり、セットしたりすべきではありません。

`EB_Hookset` オブジェクトを使用する際は、まずそのオブジェクトに 対して `eb_initialize_hookset()` を呼んで初期化しなくては なりません。

### フック関数の詳細

この節では、フック関数の仕様について記します。

まず、フック関数を呼び出す `eb_read_text()` および `eb_read_heading()` のプロトタイプは次のようになっています。

>     EB_Error_Code
>     eb_read_text(EB_Book *book, EB_Appendix *appendix,
>         EB_Hookset *hookset, void *container, size_t text_max_length,
>         char *text, ssize_t *text_length)

一方、フック関数のプロトタイプは、次のようになっています。

>     EB_Error_Code
>     hook_function(EB_Book *book, EB_Appendix *appendix, void *container,
>         EB_Hook_Code code, int argc, const unsigned int *argv);

引数 book, appendix, container は、 `eb_read_text()` あるいは `eb_read_heading()` に 渡された値がそのままフック関数にも渡ってきます。

appendix というのは、書籍に対する補助データを提供するオブジェクト です (appendix (付録) について詳しくは ebappendix コマンドのマニュアル の「appendix (付録) とは」を参照のこと)。

引数 container は、アプリケーションプログラムからフック関数に 何かデータを渡したいときに使います。

最後の argc と argv には、加工前のテキストデータが 渡されます。 文字に対するフックでは、文字コード番号が渡ってきます。 エスケープシーケンスに対するフックでは、そのシーケンス自体のコード (`1f` で始まるコード) と、もしあればエスケープシーケンスへの 引数をが渡ってきます。 個々のフックにおいて、argc と argv にどうような値が 渡ってくるのか、詳しくは 「フックコードの一覧」 を参照のこと。

フック関数の中から次に挙げる関数を呼び出すことで、テキストデータへの 書き込みを行うことができます。

- `eb_write_text()`
- `eb_write_text_string()`
- `eb_write_text_byte1()`
- `eb_write_text_byte2()`

これらの関数の仕様に関して詳しくは 「[テキストデータ] 関数の詳細」 を参照のこと。

フック関数が `EB_SUCCESS` 以外の値を返すと、フック関数を 呼び出した `eb_read_text()`, `eb_read_heading()` はエラーが発生したものと見なし、そのエラーコードをそのまま アプリケーションプログラムに返します。

フック関数の中では、book に対して以下の関数を呼び出しては いけません。 呼び出したときの動作は、未定義です。

- `eb_seek_text()`
- `eb_read_text()`
- `eb_read_heading()`
- `eb_read_rawtext()`
- `eb_forward_text()`
- `eb_backward_text()`
- `eb_set_subbook()`
- `eb_unset_subbook()`
- `eb_load_all_subbook()`
- `eb_bind()`
- `eb_finalize_book()`
- `eb_finalize_library()`

### フックコードの一覧

この節で説明しているフックコードを使うには、次のようにヘッダファイルを 読み込んで下さい。

>     #include <eb/text.h>

#### 定数 `EB_HOOK_NULL`

`EB_HOOK_NULL` は厳密にはフックではなく、 `eb_set_hooks()` で複数のフック関数を登録する際に、 `EB_Hook` 配列の末尾の要素を示すために用います。 このフックコードに対して、フック関数は登録できません。

詳しくは、「[テキストデータ] フック関数の詳細」 を参照のこと。

#### 定数 `EB_HOOK_INITIALIZE`

`EB_HOOK_INITIALIZE` は、`eb_seek_text()` を 呼び出した直後の最初の `eb_read_text()`, `eb_read_heading()` の呼び出し時に処理されます。 何か初期化処理をしたいときに、使うと良いでしょう。

このフックが、フック関数に渡す `argc` は 0 です。 フック関数を登録していない状態では、このフックはテキストデータに何も 書き込みません。

#### 定数 `EB_HOOK_BEGIN_NARROW`

#### 定数 `EB_HOOK_END_NARROW`

`EB_HOOK_BEGIN_NARROW` および `EB_HOOK_END_NARROW` は、半角表示の開始と終了を表すエスケープシーケンスに対するフックです。

どちらのフックも、フック関数に渡す `argc` は 1 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `EB_HOOK_BEGIN_NARROW` なら `0x1f04`、 `EB_HOOK_END_NARROW` なら `0x1f05` になります。

フック関数を登録していない状態では、これらのフックはテキストデータに何も 書き込みません。

#### 定数 `EB_HOOK_BEGIN_SUBSCRIPT`

#### 定数 `EB_HOOK_END_SUBSCRIPT`

`EB_HOOK_BEGIN_SUBSCRIPT` および `EB_HOOK_END_SUBSCRIPT` は、下付き表示の開始と終了を表す エスケープシーケンスに対するフックです。

どちらのフックも、フック関数に渡す `argc` は 1 です。 `argv[0]` の値はエスケープシーケンスのコードそのもので、 `EB_HOOK_BEGIN_SUBSCRIPT` なら `0x1f06`、 `EB_HOOK_END_SUBSCRIPT` なら `0x1f07` になります。

フック関数を登録していない状態では、これらのフックはテキストデータに 何も書き込みません。

#### 定数 `EB_HOOK_SET_INDENT`

`EB_HOOK_SET_INDENT` は、テキストデータの行頭の字下げ指定を 表すエスケープシーケンスに対するフックです。

このフックが、フック関数に渡す `argc` は 2 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f09` になります。 `argv[1]` が、字下げの量を表します。

字下げの量の単位が、何であるのかは不明です。 また、字下げ量の最小値は、0 の場合と 1 の場合の二通りがあります。 いずれにしろ、字下げは 1 ずつ増えたり減ったりします。

フック関数を登録していない状態では、このフックはテキストデータに何も 書き込みません。

#### 定数 `EB_HOOK_NEWLINE`

`EB_HOOK_SET_NEWLINE` は、改行を表すエスケープシーケンスに 対するフックです。

ただし、`eb_read_heading()` (見出しの読み込み) による処理では、 改行を表すエスケープシーケンスは区切りコードとしても扱われます。 そのため、エスケープシーケンスが見つかってもこのフックの処理は行われず、 ただちに読み込み処理は終了します。

このフックが、フック関数に渡す `argc` は 1 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f0a` になります。

フック関数を登録していない状態では、このフックはテキストデータに何も 書き込みませんが、`eb_initialize_hookset()` で `EB_Hook` オブジェクトを初期化すると、フック関数として `eb_hook_newline()` が自動的に登録されます。

#### 定数 `EB_HOOK_BEGIN_SUPERSCRIPT`

#### 定数 `EB_HOOK_END_SUPERSCRIPT`

`EB_HOOK_BEGIN_SUPERSCRIPT` および `EB_HOOK_END_SUPERSCRIPT` は、上付き表示の開始と終了を表す エスケープシーケンスに対するフックです。

どちらのフックも、フック関数に渡す `argc` は 1 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `EB_HOOK_BEGIN_SUPERSCRIPT` なら `0x1f0e`、 `EB_HOOK_END_SUPERSCRIPT` なら `0x1f0f` になります。

フック関数を登録していない状態では、これらのフックはテキストデータに何も 書き込みません。

#### 定数 `EB_HOOK_BEGIN_NO_NEWLINE`

#### 定数 `EB_HOOK_END_NO_NEWLINE`

`EB_HOOK_BEGIN_NO_NEWLINE` および `EB_HOOK_END_NO_NEWLINE` は、改行禁止の開始と終了を表す エスケープシーケンスに対するフックです。

どちらのフックも、フック関数に渡す `argc` は 1 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `EB_HOOK_BEGIN_NO_NEWLINE` なら `0x1f10`、 `EB_HOOK_END_NO_NEWLINE` なら `0x1f11` になります。

フック関数を登録していない状態では、これらのフックはテキストデータに何も 書き込みません。

#### 定数 `EB_HOOK_BEGIN_EMPHASIS`

#### 定数 `EB_HOOK_END_EMPHASIS`

`EB_HOOK_BEGIN_EMPHASIS` および `EB_HOOK_END_EMPHASIS` は、強調表示の開始と終了を表すエスケープシーケンスに対するフックです。

どちらのフックも、フック関数に渡す `argc` は 1 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `EB_HOOK_BEGIN_EMPHASIS` なら `0x1f12`、 `EB_HOOK_END_EMPHASIS` なら `0x1f13` になります。

フック関数を登録していない状態では、これらのフックはテキストデータに何も 書き込みません。

#### 定数 `EB_HOOK_BEGIN_CANDIDATE`

#### 定数 `EB_HOOK_END_CANDIDATE_LEAF`

#### 定数 `EB_HOOK_END_CANDIDATE_GROUP`

`EB_HOOK_BEGIN_CANDIDATE` は、複合検索の候補となる語の開始を 表すエスケープシーケンスに対するフックです。

それに対して、終了を表すエスケープシーケンスに対するフックは 2 種類 あります。 一つは `EB_HOOK_END_CANDIDATE_LEAF` で、候補となる語が実際に 検索の入力語として使えるものであることを示します。 もう一つは `EB_HOOK_END_CANDIDATE_GROUP` で、候補となる語は さらに細かい選択肢に分かれていることを示します。 (したがって、候補となる語を検索の入力語として使うことはできません。)

フック `EB_HOOK_BEGIN_CANDIDATES` が、フック関数に渡す `argc` は 1 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f43` になります。

フック `EB_HOOK_END_CANDIDATE_LEAF` および `EB_HOOK_END_CANDIDATE_GROUP` が、フック関数に渡す `argc` は 3 です。 どちらのフックも、`argv[0]` はエスケープシーケンスのコード そのもので、`0x1f63` になります。 フック `EB_HOOK_END_CANDIDATE_GROUP` の `argv[1]` と `argv[2]` は、次の階層の候補一覧データの開始ページ番号と オフセットです。 これは、`EB_Position` オブジェクト (「[検索] データ型の詳細」 を参照のこと) の `page` および `offset` メンバの値に相当します。 フック `EB_HOOK_END_CANDIDATE_LEAF` では、`argv[1]`, `argv[2]` は 2 つとも 0 になっています。

フック関数を登録していない状態では、これらのフックはテキストデータに何も 書き込みません。

#### 定数 `EB_HOOK_BEGIN_REFERENCE`

#### 定数 `EB_HOOK_END_REFERENCE`

`EB_HOOK_BEGIN_REFERENCE` および `EB_HOOK_END_REFERENCE` は、別位置のテキストデータの参照開始と 終了を表すエスケープシーケンスに対するフックです。

フック `EB_HOOK_BEGIN_REFERENCE` が、フック関数に渡す `argc` は 2 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f42` になります。 `argv[1]` の意味は不明です。

`EB_HOOK_END_REFERENCE` が、フック関数に渡す `argc` は 3 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f62` になります。 `argv[1]` と `argv[2]` は、参照先のページ番号と オフセットです。 これは、`EB_Position` オブジェクト (「[検索] データ型の詳細」 を参照のこと) の `page` および `offset` メンバの値に相当します。

フック関数を登録していない状態では、これらのフックはテキストデータに何も 書き込みません。

#### 定数 `EB_HOOK_BEGIN_KEYWORD`

#### 定数 `EB_HOOK_END_KEYWORD`

`EB_HOOK_BEGIN_KEYWORD` および `EB_HOOK_END_KEYWORD` は、 検索キーの開始と終了を表すエスケープシーケンスに対するフックです。

フック `EB_HOOK_BEGIN_KEYWORD` が、フック関数に渡す `argc` は 2 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f41` になります。 `argv[1]` の意味は不明です。

`EB_HOOK_END_KEYWORD` は、フック関数に 1 個の引数を渡します。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f61` になります。

フック関数を登録していない状態では、これらのフックはテキストデータに何も 書き込みません。

#### 定数 `EB_HOOK_BEGIN_DECORATION`

#### 定数 `EB_HOOK_END_DECORATION`

`EB_HOOK_BEGIN_DECORATION` および `EB_HOOK_END_DECORATION` は、文字修飾の開始と終了を表す エスケープシーケンスに対するフックです。

フック `EB_HOOK_BEGIN_DECORATION` が、フック関数に渡す `argc` は 2 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1fe0` になります。 `argv[1]` の意味は不明です。

`EB_HOOK_END_KEYWORD` は、フック関数に 1 個の引数を渡します。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1fe1` になります。

フック関数を登録していない状態では、これらのフックはテキストデータに何も 書き込みません。

#### 定数 `EB_HOOK_NARROW_FONT`

#### 定数 `EB_HOOK_WIDE_FONT`

`EB_HOOK_NARROW_FONT` および `EB_HOOK_WIDE_FONT` は、 それぞれ半角外字と全角外字に対するフックです。

どちらのフックも、フック関数に渡す `argc` は 1 です。 `argv[0]` は、外字の文字番号を表します。

フック関数を登録していない状態では、このフックはテキストデータに何も 書き込みませんが、`eb_initialize_hookset()` で `EB_Hook` オブジェクトを初期化すると、フック関数として `eb_hook_narrow_character_text()` および `eb_hook_wide_character_text()` が自動的に登録されます。

#### 定数 `EB_HOOK_ISO8859_1`

`EB_HOOK_ISO8859_1` は、ISO 8859-1 (ラテン文字 1) 文字に対する フックです。

このフックが、フック関数に渡す `argc` は 1 です。 `argv[0]` は、ISO 8859-1 の文字番号を表します。

フック関数を登録していない状態では、`argv[0]` の値をそのまま テキストデータに書き込みます。 つまり、文字はそのまま ISO 8859-1 として、1 バイト書き込まれます。

このフックが利用されるのは、処理中の書籍の文字コードが `EB_CHARCODE_ISO8859_1` の場合だけです。

#### 定数 `EB_HOOK_NARROW_JISX0208`

#### 定数 `EB_HOOK_WIDE_JISX0208`

`EB_HOOK_NARROW_JISX0208` と `EB_HOOK_WIDE_JISX0208` は、半角および全角の JIS X 0208 (日本語のかな漢字) 文字に対するフックです。

どちらのフックも、フック関数に渡す `argc` は 1 です。 `argv[0]` は、JIS X 0208 の文字を日本語 EUC で表現したときの 文字番号を表します。

フック関数を登録していない状態では、`argv[0]` の値をそのまま テキストデータに書き込みます。 つまり、文字はそのまま日本語 EUC として、2 バイト書き込まれます。

このフックが利用されるのは、 処理中の書籍の文字コードが `EB_CHARCODE_JISX0208` か `EB_CHARCODE_JISX0208_GB2312` の場合だけです。

#### 定数 `EB_HOOK_GB2312`

`EB_HOOK_GB2312` は、GB 2312 (中国語の簡体字) 文字に対する フックです。

このフックが、フック関数に渡す `argc` は 1 です。 `argv[0]` は、GB 2312 の文字を中国語 EUC で表現したときの 文字番号を表します。

フック関数を登録していない状態では、`argv[0]` の値をそのまま テキストデータに書き込みます。 つまり、文字はそのまま中国語 EUC として、2 バイト書き込まれます。

このフックが利用されるのは、処理中の書籍の文字コードが `EB_CHARCODE_JISX0208_GB2312` の場合だけです。

#### 定数 `EB_HOOK_BEGIN_MONO_GRAPHIC`

#### 定数 `EB_HOOK_END_MONO_GRAPHIC`

`EB_HOOK_BEGIN_MONO_GRAPHIC` および `EB_HOOK_END_MONO_GRAPIHC` は、モノクロ図版の開始と終了を 表すエスケープシーケンスに対するフックです。

フック `EB_HOOK_BEGIN_MONO_GRAPHIC` が、フック関数に渡す `argc` は 4 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f32` か `0x1f44` のいずれかになります。 `argv[2]` と `argv[3]` は、図版の高さと幅 (ピクセル数) を意味します。 ただし、電子ブックのモノクロ図版 (最初の引数が `0x1f32` の 場合) には、図版の高さと幅の情報が欠けているので、値はどちらも 0 に なります。 `argv[1]` の意味は不明です。

`EB_HOOK_END_MONO_GRAPHIC` が、フック関数に渡す `argc` は 3 です。 `argv[0]` は、エスケープシーケンスのコードそのものです。 `EB_HOOK_BEGIN_MONO_GRAPHIC` の `argv[0]` が `0x1f32` なら、`EB_HOOK_END_MONO_GRAPHIC` の `argv[0]` は `0x1f52` になり、`0x1f44` なら `0x1f64` になります。 `argv[1]` と `argv[2]` は、図版データのページ番号 とオフセットです。 これは、`EB_Position` オブジェクト (「[検索] データ型の詳細」 を参照のこと) の `page` および `offset` メンバの値に相当します。

図版データの取り出し方については、「モノクロ図版」 を参照してください。

フック関数を登録していない状態では、これらのフックはテキストデータに何も 書き込みません。

#### 定数 `EB_HOOK_BEGIN_GRAY_GRAPHIC`

#### 定数 `EB_HOOK_END_GRAY_GRAPHIC`

これらのフック名称は、グレースケール図版のために予約されていますが、 本バージョンの EB ライブラリではまだ対応していません。

#### 定数 `EB_HOOK_BEGIN_COLOR_BMP`

#### 定数 `EB_HOOK_BEGIN_COLOR_JPEG`

#### 定数 `EB_HOOK_END_COLOR_GRAPHIC`

`EB_HOOK_BEGIN_COLOR_BMP` と `EB_HOOK_COLOR_JPEG` は、それぞれ BMP 形式と JPEG 形式のカラー図版の開始を表す エスケープシーケンスに対するフックです。 開始のフックは BMP と JPEG とでフックが分かれていますが、終了の フックは共通で、`EB_HOOK_END_COLOR_GRAPIHC` になります。

フック `EB_HOOK_BEGIN_COLOR_BMP` と `EB_HOOK_COLOR_JPEG` が、フック関数に渡す `argc` は 4 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f4d` になります。 `argv[2]` と `argv[3]` は、図版の幅と高さ (ピクセル数) を意味します。 `argv[1]` の意味は不明です。

フック `EB_HOOK_END_COLOR_BMP` が、フック関数に渡す `argc` は 3 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f6d` になります。 `argv[1]` と `argv[2]` は、図版データのページ番号 とオフセットです。 これは、`EB_Position` オブジェクト (「[検索] データ型の詳細」 を参照のこと) の `page` および `offset` メンバの値に相当します。

図版データの取り出し方については、「カラー図版」 を参照してください。

フック関数を登録していない状態では、これらのフックはテキストデータに何も 書き込みません。

#### 定数 `EB_HOOK_BEGIN_IN_COLOR_BMP`

#### 定数 `EB_HOOK_BEGIN_IN_COLOR_JPEG`

#### 定数 `EB_HOOK_END_IN_COLOR_GRAPHIC`

`EB_HOOK_BEGIN_IN_COLOR_BMP` と `EB_HOOK_IN_COLOR_JPEG` は、 それぞれ BMP 形式と JPEG 形式のインラインカラー図版の開始を表す エスケープシーケンスに対するフックです。 開始のフックは BMP と JPEG とでフックが分かれていますが、終了の フックは共通で、`EB_HOOK_END_IN_COLOR_GRAPIHC` になります。

フック `EB_HOOK_BEGIN_IN_COLOR_BMP` と `EB_HOOK_IN_COLOR_JPEG` が、フック関数に渡す `argc` は 4 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f3c` になります。 `argv[2]` と `argv[3]` は、図版の幅と高さ (ピクセル数) を意味します。 `argv[1]` の意味は不明です。

フック `EB_HOOK_END_IN_COLOR_BMP` が、フック関数に渡す `argc` は 3 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f5c` になります。 `argv[1]` と `argv[2]` は、図版データのページ番号と オフセットです。 これは、`EB_Position` オブジェクト (「[検索] データ型の詳細」 を参照のこと) の `page` および `offset` メンバの値に相当します。

図版データの取り出し方については、「カラー図版」 を参照してください。

フック関数を登録していない状態では、これらのフックはテキストデータに何も 書き込みません。

#### 定数 `EB_HOOK_BEGIN_CLICKABLE_AREA`

#### 定数 `EB_HOOK_END_CLICKABLE_AREA`

`EB_HOOK_BEGIN_CLICKABLE_AREA` は、カラー図版およびインラインカラー図版内の特定矩形領域に対して、参照先情報を表現した開始エスケープシーケンスに対するフックです。 同様に、`EB_HOOK_END_CLICKABLE_AREA` は終了エスケープシーケンスに対するフックです。

フック `EB_HOOK_BEGIN_CLICKABLE_AREA` が、フック関数に渡す `argc` は 7 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f4f` になります。 `argv[1]` と `argv[2]` は、それぞれ矩形領域の開始 x, y 座標を表します。 それぞれ矩形領域の開始 x, y 座標を表します。 カラー図版の左上の座標が (0, 0) です。 同様に、`argv[3]` と `argv[4]` が図版の右方向への 幅と、下方向への高さを表します。 最後の `argv[5]` と `argv[6]` が参照先のページ番号 とオフセットとなります。

>     　　　　　　　　　参照先付きカラー図版
>     （０，０）
>     　　┌─────────────────────┐
>     　　│　　　　　　　　　　　　　　　　　　　　　│
>     　　│（ｘ，ｙ）　　　　　　　　　　　　　　　　│
>     　　│　　┌　─　─　─　─　─　─　┐　　　　│
>     　　│　　│　　　　　　　　　高さ↑　│　　　　│
>     　　│　　　　　　　　　　　　　　│　　　　　　│
>     　　│　　│　　矩形領域　　　　　│　│　　　　│
>     　　│　　　　　　　　　　　　　　│　　　　　　│
>     　　│　　│　　　　　　　　　　　│　│　　　　│
>     　　│　　　　　　　幅　　　　　　│　　　　　　│
>     　　│　　│←──────────┼→│　　　　│
>     　　│　　　　　　　　　　　　　　↓　　　　　　│
>     　　│　　└　─　─　─　─　─　─　┘　　　　│
>     　　│　　　　　　　　　　　　　　　　　　　　　│
>     　　└─────────────────────┘

`EB_HOOK_END_CLICKABLE_AREA` が、フック関数に渡す `argc` は 1 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f6f` になります。

参照先情報の取り出し方については、 「参照先付きカラー図版」 を参照して下さい。

フック関数を登録していない状態では、これらのフックはテキストデータに何も 書き込みません。

#### 定数 `EB_HOOK_BEGIN_WAVE`

#### 定数 `EB_HOOK_END_WAVE`

`EB_HOOK_BEGIN_WAVE` および `EB_HOOK_END_WAVE` は、 WAVE (PCM) 形式の音声データの開始と終了を表すエスケープシーケンスに対する フックです。

フック `EB_HOOK_BEGIN_WAVE` が、フック関数に渡す `argc` は 6 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f4a` になります。 `argv[2]` と `argv[3]` は音声データの開始位置の ページ番号とオフセット、`argv[4]` と `argv[5]` は 終了位置のページ番号とオフセットをそれぞれ表します。 `argv[1]` の意味は不明です。

`EB_HOOK_END_WAVE` が、フック関数に渡す `argc` は 1 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f6a` になります。

音声データの取り出し方については、「WAVE 音声」 を参照して下さい。

フック関数を登録していない状態では、これらのフックはテキストデータに何も 書き込みません。

#### 定数 `EB_HOOK_BEGIN_MPEG`

#### 定数 `EB_HOOK_END_MPEG`

`EB_HOOK_BEGIN_MPEG` および `EB_HOOK_END_MPEG` は、 MPEG 形式の動画データの開始と終了を表すエスケープシーケンスに対するフック です。

フック `EB_HOOK_BEGIN_MPEG` が、フック関数に渡す `argc` は 6 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f39` になります。 `argv[2]` 〜 `argv[5]` は、動画データのファイル名を エンコードした数値列になります。 `argv[1]` の意味は不明です。

`EB_HOOK_END_MPEG` が、フック関数に渡す `argc` は 1 です。 `argv[0]` はエスケープシーケンスのコードそのもので、 `0x1f59` になります。

動画データの取り出し方については、「MPEG 動画」 を参照して下さい。

フック関数を登録していない状態では、これらのフックはテキストデータに何も 書き込みません。

### フックセット操作関数の詳細

この節で説明している関数を使うには、次のようにヘッダファイルを読み込んで 下さい。

>     #include <eb/text.h>

#### `void eb_initialize_hookset (EB_Hookset *hookset)`

関数 `initialize_hookset()` は、hookset の指す `EB_Hookset` オブジェクトを初期化します。 `EB_Hookiset` オブジェクトに対して EB ライブラリの他の関数を 呼ぶ前に、 必ずそのオブジェクトを初期化しなくてはなりません。 初期化していないオブジェクトに対して、EB ライブラリの他の関数を呼んだ 場合の動作は未定義です。 また、すでに初期化したオブジェクトに対して、再度 `eb_initialize_hookset()` を呼んではいけません。 呼んだ場合の動作は未定義です。

この関数は、各フックの初期値を次のようにセットします。

フック | フック関数
`EB_HOOK_NARROW_JISX0208` | `eb_hook_euc_to_ascii()`
`EB_HOOK_NARROW_FONT` | `eb_hook_narrow_character_text()`
`EB_HOOK_WIDE_FONT` | `eb_hook_wide_character_text()`
`EB_HOOK_NEWLINE` | `eb_hook_newline()`
上記以外のフック | `NULL` (フック関数なし)

#### `EB_Error_Code eb_finalize_hookset (EB_Hookset *hookset)`

関数 `eb_finalize_hookset()` は、hookset が指す `EB_Hooksest` オブジェクトの後始末を行います。

オブジェクトが割り当てて管理していたメモリは、すべて解放されます。 すべてのフックには、フック関数として `NULL` がセットされます。

後始末をしたオブジェクトに対して `eb_set_hook()`, `eb_set_hooks()` を呼ぶことで、オブジェクトを再利用することができます。

#### `EB_Error_Code eb_set_hook (EB_Hookset *hookset, const EB_Hook *hook)`

関数 `eb_set_hook()` は、hookset が指す `EB_Hooksest` オブジェクトに、フック関数を一つ登録します。 登録するフックの種類とフック関数は、hook で指定します。

同じフックコードに複数回フック関数を登録しても、有効になるのは最後に 登録したものだけですので、注意して下さい。 フック関数として `NULL` を指定すると、登録されているフックが 解除されます。

成功すると、この関数は `EB_SUCCESS` を返します。 失敗すると、原因を示すエラーコードを返します。

#### `EB_Error_Code eb_set_hooks (EB_Hookset *hookset, const EB_Hook *hooks)`

この関数は `eb_set_hook()` に似ていますが、任意の個数の フック関数を一度に登録できる点が異なります。

登録するフックの種類とフック関数は、hooks で指定します。 hooks は `EB_Hook` オブジェクトの配列 (の先頭) を 指していなければなりません。 また、この配列の末尾には、フックコード `EB_HOOK_NULL` をセット した `EB_Hook` オブジェクトを配列要素として置く必要があります。

`eb_set_hooks()` は、配列の先頭から順番に、指定されたフックコード に対してフック関数を登録していきます。 エラーが発生すると、残りのフックの登録はせずに、原因を示すエラーコード をただちに返します。 すべてのフック関数の登録に成功すると、`EB_SUCCESS` を返します。

### 組み込みフック関数の詳細

EB ライブラリは、基本的なフック関数をいくつか用意しています。 本節では、これらのフック関数についての仕様を解説します。

この節で説明している関数を使うには、次のようにヘッダファイルを読み込んで 下さい。

>     #include <eb/text.h>

いずれのフック関数も、引数 appendix と container に `NULL` を渡されても、動作に支障はないようになっています。

#### `EB_Error_Code eb_hook_euc_to_ascii (EB_Book *book, EB_Appendix *appendix, void *container, EB_Hook_Code code, int argc, const unsigned int *argv)`

`eb_hook_euc_to_ascii()` は、フックコード `EB_HOOK_NARROW_JISX0208` (半角 JIS X 0208 文字) のための フック関数です。

`EB_Hookset` オブジェクトを関数 `eb_initialiez_hookset()` で初期化すると、この関数が自動的に 登録されます。

このフック関数は、`argv[0]` として渡された JIS X 0208 の文字 (エンコーディングは日本語 EUC) を調べ、対応する ASCII 文字が存在すれば その ASCII 文字をテキストデータとして書き込み、なければ JIS X 0208 の 文字をそのまま書き込みます。

常に `EB_SUCCESS` を返します。

#### `EB_Error_Code eb_hook_narrow_character_text (EB_Book *book, EB_Appendix *appendix, void *container, EB_Hook_Code code, int argc, const unsigned int *argv)`

#### `EB_Error_Code eb_hook_wide_character_text (EB_Book *book, EB_Appendix *appendix, void *container, EB_Hook_Code code, int argc, const unsigned int *argv)`

`eb_hook_narrow_character_text()` は、フックコード `EB_HOOK_NARROW_FONT` (半角外字) のためのフック関数です。 同様に `eb_hook_wide_character_text()` は、フックコード `EB_HOOK_WIDE_FONT` (全角外字) のためのフック関数です。

`EB_Hookset` オブジェクトを関数 `eb_initialiez_hookset()` で初期化すると、これらの関数が自動的 に登録されます。

この関数は、appendix の選択中している副本が、 `argv[0]` として渡された外字の代替文字列を持っているかどうか 調べます。 持っていればその文字列をテキストデータとして書き込み、持っていなければ `<?>` という文字列を書き込みます。

appendix が `NULL` の場合や、付録が副本を選択中で ない場合も、代替文字列を持っていないものとして扱います。

この関数は、常に `EB_SUCCESS` を返します。

#### `EB_Error_Code eb_hook_newline (EB_Book *book, EB_Appendix *appendix, void *container, EB_Hook_Code code, int argc, const unsigned int *argv)`

`eb_hook_narrow_newline()` は、フックコード `EB_HOOK_NEWLINE` (改行) のためのフック関数です。

`EB_Hookset` オブジェクトを関数 `eb_initialiez_hookset()` で初期化すると、これらの関数が自動的 に登録されます。

この関数は、テキストデータに `\n` を書き込みます。 常に `EB_SUCCESS` を返します。

#### `EB_Error_Code eb_hook_empty (EB_Book *book, EB_Appendix *appendix, void *container, EB_Hook_Code code, int argc, const unsigned int *argv)`

`eb_hook_empty()` は、何もしないフック関数です。 常に `EB_SUCCESS` を返します。

### テキストデータ操作関数の詳細

この節で説明している関数を使うには、次のようにヘッダファイルを読み込んで 下さい。

>     #include <eb/text.h>

#### `int eb_have_text (EB_Book *book)`

#### `int eb_have_menu (EB_Book *book)`

#### `int eb_have_copyright (EB_Book *book)`

関数 `eb_have_text()` は、book の選択している副本が、 本文を持っているかどうかを調べます。 同様に、`eb_have_menu()` はメニューを持っているかどうか、 `eb_have_copyright()` は著作権表示を持っているかどうか調べます。

いずれの関数も、持っていれば 1 を返し、持っていなければ 0 を返します。 book が副本を選択していない場合も 0 を返します。

#### `EB_Error_Code eb_text (EB_Book *book, EB_Position *position)`

#### `EB_Error_Code eb_menu (EB_Book *book, EB_Position *position)`

#### `EB_Error_Code eb_copyright (EB_Book *book, EB_Position *position)`

関数 `eb_text()` は、book が選択している副本の本文 の開始位置を position の指す領域に書き込みます。 同様に、`eb_menu()` はメニューの開始位置を、 `eb_have_copyright()` は著作権表示の開始位置を書き込みます。

成功すると、これらの関数は `EB_SUCCESS` を返します。 失敗すると、position に必ずシークが失敗する位置を書き込んで、 原因を示すエラーコードを返します。

あらかじめ、book 内のいずれかの副本が選択されていなくては なりません。 book が副本を選択していなければ、`EB_ERR_NO_CUR_SUB` を返します。 選択中の副本が、対象となるテキストデータを持っていなければ、 `EB_ERR_NO_SUCH_SEARCH` を返します。

#### `EB_Error_Code eb_seek_text (EB_Book *book, const EB_Position *position)`

関数 `eb_seek_text()` は、book が選択している副本の テキストデータファイルをシークします。 シーク位置は position で指定します。 このとき、position は常にファイルの先頭からの位置として解釈 されます。 (相対位置へのシーク機能は、EB ライブラリにはありません。)

シークを行うと、それまでに行った読み込みの状態記録がリセットされます。 `eb_read_text()`, `eb_read_heading()`, `eb_read_rawtext()` を用いてテキストデータを読み込むには、 前もってこの関数を呼び出しておく必要があります。

成功すると、この関数は `EB_SUCCESS` を返します。 失敗すると、原因を示すエラーコードを返します。

あらかじめ、book 内のいずれかの副本が選択されていなくては なりません。 book が副本を選択していなければ、`EB_ERR_NO_CUR_SUB` を返します。 選択中の副本にテキストデータが存在しないときは、`EB_ERR_NO_TEXT` を返します。

なお、書籍によっては、テキストデータを収めたファイルには他のデータも 一緒に格納されていることがありますが、テキスト以外のデータにアクセス しても、テキストデータの現在位置、読み込みに関する状態記録は変化しません。

#### `EB_Error_Code eb_tell_text (EB_Book *book, EB_Position *position)`

関数 `eb_seek_text()` は、book が選択している副本の テキストデータファイルの現在のアクセス位置を返します。

成功すると、position の指す領域に現在のアクセス位置を書き込み、 `EB_SUCCESS` を返します。 失敗すると、シークが必ず失敗する位置を書き込み、原因を示すエラーコード を返します。

あらかじめ、book 内のいずれかの副本が選択されていなくては なりません。 book が副本を選択していなければ、`EB_ERR_NO_CUR_SUB` を返します。 選択中の副本にテキストデータが存在しないときは、`EB_ERR_NO_TEXT` を返します。

#### `EB_Error_Code eb_read_text (EB_Book *book, EB_Appendix *appendix, EB_Hookset *hookset, void *container, size_t text_max_length, char *text, ssize_t *text_length)`

#### `EB_Error_Code eb_read_heading (EB_Book *book, EB_Appendix *appendix, EB_Hookset *hookset, void *container, size_t text_max_length, char *text, ssize_t *text_length)`

関数 `eb_read_text()` と `eb_read_heading()` は、 book が選択している副本のテキストデータファイルの現在のアクセス位置からデータ を読み込みます。 `eb_read_heading()` は見出しの読み込みに用い、 `eb_read_text()` はそれ以外のテキストデータの読み込みに用います。

読み込まれたテキストデータは、必要に応じて文字コードの変換 (「文字コード」 を参照のこと) が行われた後に、hookset の指すフックセットにしたがって加工されます。 hookset が `NULL` のときは、代わりに EB ライブラリ側 で用意している 標準のフックセット (default hookset) が 用いられます。 このフックセットは、`eb_initialize_hookset()` によって 初期化しただけのフックセットと等価です。

フックセットによって加工された後に、テキストデータは text の 指す領域に書き込まれ、書き込んだバイト数が text_length の指す 領域に書き込まれます。 text はナル文字で終端されますが、text_length には ナル文字の分は勘定に入れません。 テキストデータは、text_max_length で指定されたバイト数を超えて 書き込むことはありません。 ただし、text_max_length にもナル文字の分は勘定に入っていません ので、text は text_max_length + 1 バイト分のデータ を格納できる大きさが必要です。

どちらの関数も、成功すれば `EB_SUCCESS` を返し、失敗すれば text_length の指す領域に 0 を書き込んで原因を示すエラーコード を返します。

あらかじめ、book 内のいずれかの副本が選択されていなくては なりません。 book が副本を選択していなければ、`EB_ERR_NO_CUR_SUB` を返します。

また、`eb_read_text()` と `eb_read_heading()` を 呼び出すには、 あらかじめ `eb_seek_text()` の呼び出しを成功させ、テキストデータ のアクセス位置がセットされた状態にしておかなくてはなりません。 シークをせずに呼び出すと、`EB_ERR_NO_PREV_SEEK` を返します。

逆に一度シークすれば、区切りコードが検出されるまでの間なら、関数を 繰り返し呼ぶことでテキストデータの続きを読み込むことができます。 区切りコードが検出されると、関数を呼び出しても読み込みは行われません。 その場合でも、他にエラーが発生しなければ `EB_SUCCESS` が返り、 text には空文字列が書き込まれます。

ただし、一度 `eb_read_text()` を呼び出してテキストデータを 読み込み始めたら、繰り返し呼び出す際も、`eb_read_text()` を 使わなければなりません。 途中から `eb_read_heading()` および後述の `eb_read_rawtext()` に切り替えて呼び出すと `EB_ERR_DIFF_CONTENT` エラーが返ります。 関数 `eb_read_heading()` についても同様です。 この制限は、再度 `eb_seek_text()` を呼び出すか、 `eb_set_subbook()` で副本を選択し直すまで続きます。

渡された appendix が区切りコードの情報を持った副本を選択中 であれば、本文の区切りコードとしてその値を使用します。 それ以外の場合は、`eb_read_text()` が区切りコードを自動判別を 試みます。 ただし、この判定は完璧なものではないので、書籍によっては変な位置で本文 が切れてしまうかも知れません。 (本文以外のテキストデータに関しては、このような問題は起きません。)

引数 container は、アプリケーションプログラムからフック関数に データを渡すためのものです。 `eb_read_text()`, `eb_read_heading()` では、直接 この引数の値を参照することはありません。

引数 appendix, container は、そのままフック関数に 渡されます。 これらの引数は `NULL` でも構いません。 (呼び出されるフック関数で支障がなければ。)

なお、フック関数や `eb_read_text()`, `eb_read_heading()` 自身が文字ないしエスケープシーケンス一個分に対するデータを書き込もうと したときに、text に十分な空き領域がないということが起こり 得ます。 その場合、関数は途中まで text に書き込むことはせずに、 いったん処理を終えて戻ります。 したがって、マルチバイト文字のデータが途中で切れたりすることはありません。

書き込めなかった分は、当然ながら text_length の勘定には 入りません。 書き込めなかったデータは book 内部に保存されているので、 もう一度 `eb_read_text()`, `eb_read_heading()` を 呼び出すと、前回の呼び出しで書き込めなかったデータがまず text の先頭に書き込まれます。 書き込んだデータは text_length の勘定に入ります。

ただし、`book` が保存しているデータの長さが text_max_length を超えていると、何も書き込まずに関数は終了 します。 このとき、書き込めなかったデータは引き続き保存されます。 つまり、`text_max_length` があまりに小さく、かつ保持している データのほうが長いと、何度呼び出しても `text` への書き込みが 進みませんので、注意が必要です。

`eb_seek_text()` を呼び出すか、`eb_set_subbook()` で副本を選択し直すと、保存していたデータは破棄されます。

#### `EB_Error_Code eb_read_rawtext (EB_Book *book, size_t text_max_length, char *text, ssize_t *text_length)`

関数 `eb_read_rawtext()` は、book が選択している 副本のテキストデータファイルの現在のアクセス位置からデータを読み込みます。

`eb_read_text()` と似ていますが、この関数はフックセットによる データの加工や文字コードの変換を一切行わず、データを内部表現のまま返します。 読み込むテキストデータの種類は、何であっても構いません。

読み込んだテキストデータは text の指す領域に書き込まれ、 書き込んだバイト数が text_length の指す領域に書き込まれます。 テキストデータは、text_max_length で指定されたバイト数を超えて 書き込むことはありません。 ただし、`eb_read_text()` と異なり、text はナル文字 で終端されません。 マルチバイト文字やエスケープシーケンスの途中で text の残り領域 が足りなくなった場合も、途中までは書き込みます。

処理が成功すれば `EB_SUCCESS` を返し、失敗すれば text_length の指す領域に 0 を書き込んで原因を示すエラーコード を返します。

あらかじめ、book 内のいずれかの副本が選択されていなくては なりません。 book が副本を選択していなければ、`EB_ERR_NO_CUR_SUB` を返します。

また、この関数を呼び出すには、あらかじめ `eb_seek_text()` の 呼び出しを成功させ、テキストデータのアクセス位置がセットされた状態にして おかなくてはなりません。 シークをせずに呼び出すと、`EB_ERR_NO_PREV_SEEK` を返します。

この関数は、繰り返し呼び出すことで、前回読み込んだテキストデータの続き を読み込むことができます。 ただし、区切りコードの検出を行いませんので、ひたすら呼び出しを続けると、 テキストデータファイルの末尾まで行ってしまいます。

一度 `eb_read_rawtext()` を呼び出してテキストデータを読み込み 始めたら、繰り返し呼び出す際も、`eb_read_rawtext()` を 使わなければなりません。 途中から、`eb_read_text()` や `eb_read_heading()` に 切り替えると、 `EB_ERR_DIFF_CONTENT` エラーが返ります。 この制限は、再度 `eb_seek_text()` を呼び出すか、 `eb_set_subbook()` で副本を選択し直すまで続きます。

#### `int eb_is_text_stopped (EB_Book *book)`

関数 `eb_is_text_stopped()` は、最後に読み込んだテキストデータ が末尾に達したかどうかを判定します。

book が選択中の副本で、最後に `eb_read_text()` または `eb_read_heading()` でテキストデータを読み込んだ際に、 区切りコードを検出したか、テキストデータ全体の一番後ろの位置に達して 読み込みを終えていれば、この関数は 1 を返します。 それ以外のときは、0 を返します。

book が副本を選択していない場合や、選択中の副本にテキストデータ が存在しない場合も 0 が返ります。

`eb_read_text()` または `eb_read_heading()` で テキストデータを読み込んでいない場合も、同様に 0 が返ります。 テキストデータを読み込んだ後であっても、テキストデータの読み込みに関する 状態記録をリセットする関数 (eb_read_text() の項を参照) を呼んでしまうと、 読み込んでいないと見なされますので、注意して下さい。

通常はこの関数を使わなくても、`eb_read_text()` や `eb_read_heading()` が 0 を返したら、テキストデータの末尾に 達したとみなして差し支えないでしょう。 ただしその際は、引数 `text_max_length` の値を十分大きく取って 下さい。

#### `EB_Error_Code eb_write_text_byte1 (EB_Book *book, int byte1)`

#### `EB_Error_Code eb_write_text_byte2 (EB_Book *book, int byte1, int byte2)`

#### `EB_Error_Code eb_write_text_string (EB_Book *book, const char *string)`

#### `EB_Error_Code eb_write_text (EB_Book *book, const char *stream, size_t stream_length)`

これらの関数は、いずれもフック関数の中から、テキストデータを書き込む ために用います。 書き込むデータの種類によって、使い分けて下さい。

`eb_write_text_byte1()` は、byte1 で指定した 1 バイトの値を書き込みます。 `eb_write_text_byte2()` は、byte1, byte2 で指定した 2 バイトを書き込みます。 `eb_write_text_string()` は、string で指定した 文字列を書き込みます。 `eb_write_text()` は、stream から始まる長さ stream_length バイトのバイト列を書き込みます。

どの関数も、成功すると `EB_SUCCESS` を返し、失敗すると原因を 示すエラーコードを返します。

最終的に、書き込んだテキストデータは、フック関数の呼び出し元である `eb_read_text()`, `eb_read_heading()` から アプリケーションプログラムに渡されます。

フック関数として呼び出されていないときに、これらの関数を呼び出した場合 の動作は未定義です。

#### `const char *eb_current_candidate (EB_Book *book)`

関数 `eb_current_candidate()` は、アクセス中のテキストデータの 現在位置に書かれている、複合検索の候補となる語を返します。

返す文字列の長さは、最長で `EB_MAX_WORD_LENGTH` バイトになります。 ただし、この長さにナル文字は含みません。

この関数は非常に特殊で、複合検索の候補となる語の終了を意味する エスケープシーケンスへのフックである `EB_HOOK_END_CANDIDATE_LEAF` および `EB_HOOK_END_CANDIDATE_GROUP` に対するフック関数の中で のみ呼び出すことができます。 それ以外の場所で呼び出したときの動作は、未定義です。

この関数の呼び出し方ですが、フック関数に渡ってきた `EB_Book` オブジェクト (へのポインタ) を、そのままこの関数に引数として渡して やります。

book の文字コード (「[CD-ROM 書籍と `EB_Book` オブジェクト] データ型の詳細」 を参照のこと) が `EB_CHARCODE_ISO8859_1` なら、関数の返す文字列は ISO 8859-1 になり、それ以外の文字コードの場合は日本語 EUC になります。 関数の返す文字列は、他のフックによる加工処理の影響を受けません。 文字コードの変換を行う以外は、内部データをそのまま返します。

なお、この関数が返した文字列を参照できるのは、フック関数から戻るまでの 間だけですので、注意して下さい。

#### `EB_Error_Code eb_forward_text (EB_Book *book, EB_Appendix *appendix)`

#### `EB_Error_Code eb_backward_text (EB_Book *book, EB_Appendix *appendix)`

関数 `eb_forward_text()` と `eb_backward_text()` は、 book が選択している副本の本文のアクセス位置を前後に移動させ、 本文の区切りコードを単位とした頭出しを行います。 ちょうど、音楽 CD の曲の頭出しと同じです。

`eb_forward_text()` は本文の末尾方向に向かってアクセス位置を 進め、`eb_backward_text()` は先頭方向に向かってアクセス位置を 戻します。

`eb_forward_text()` の呼び出しでは、アクセス位置は必ず次の語の 説明の開始位置まで移動します。 それに対して `eb_backward_text()` の呼び出しでは、移動先が状態 によって異なります。 もし、現在のアクセス位置がその単語の説明の先頭にあるときは、 `eb_backward_text()` の呼び出しによって、一つ前の単語の説明の 先頭にアクセス位置が移動します。 アクセス位置が単語の説明の途中や末尾にあるときは、その単語の説明の 先頭に移動します。

この関数は、成功すると `EB_SUCCESS` を返し、失敗すると原因を示す エラーコードを返します。

あらかじめ、book 内のいずれかの副本が選択されていなくては なりません。 book が副本を選択していなければ、`EB_ERR_NO_CUR_SUB` を返します。

加えて、これらの関数を呼び出すには、あらかじめ `eb_seek_text()` か `eb_read_text()` を呼び出しが成功していないといけません。 (`eb_read_text()` の呼び出しを成功させるには、さらに前もって `eb_seek_text()` の呼び出しを成功させることが条件となります。)

`eb_read_text()` ではなく、`eb_read_heading()` や `eb_read_rawtext()` の呼び出しに成功した後でこの関数を 呼び出すと、`EB_ERR_DIFF_CONTENT` を返します。 また、前もって `eb_seek_text()` でシークせずにこの関数を 呼び出すと、`EB_ERR_NO_PREV_SEEK` を返します。

本文データの末尾や先頭に達してしまって、その方向にもう本文がないときは、 `EB_ERR_END_OF_CONTENT` を返します。

appendix が `NULL` ではなく、区切りコードの情報を 持った副本を選択中であれば、本文の区切りコードとしてその値を使用します。 それ以外の場合は、`eb_read_text()` と同じ方法で区切りコードの 自動判別を試みます。

アクセス位置上にあるのがメニューや著作権表示のように、本文以外の テキストデータであっても構いません。 ただし、本文以外のテキストデータの内部には、頭出し位置がデータの 先頭位置にしかありませんので、この関数が役に立つ状況はほとんど ありません。

(メニューでは、個々の階層のメニューデータが、それぞれ独立した テキストデータになっているため、頭出しを行っても前後のメニューデータへは 移動できません。 複合検索の候補一覧も同様です。)

#### `EB_Error_Code eb_forward_heading (EB_Book *book)`

関数 `eb_forward_heading()` は、book が選択している 副本の見出しのアクセス位置を後に移動させ、見出しの区切りを単位とした頭出し を行います。

本文の頭出しを行う関数 `eb_forward_text()` の見出し版です。 ただし、見出しで頭出しを行う機会は、クロス検索の本文取得に限られるため、 `eb_backward_heading()` という関数は用意していません。

この関数を呼ぶと、アクセス位置が次の見出しの開始位置まで移動します。 (クロス検索では、見出し領域の中に「見出し」と「本文」が交互に書かれて いますが、データ構造上「本文」と「見出し」は区別が付きません。 アクセス位置がクロス検索の見出し領域内の場合、この関数を呼ぶと最も近い 「見出し」もしくは「本文」の開始位置まで移動します。)

`eb_read_heading()` ではなく、`eb_read_text()` や `eb_read_rawtext()` の呼び出しに成功した後でこの関数を 呼び出すと、`EB_ERR_DIFF_CONTENT` を返します。 また、前もって `eb_seek_text()` でシークせずにこの関数を 呼び出すと、`EB_ERR_NO_PREV_SEEK` を返します。

この関数は、成功すると `EB_SUCCESS` を返し、失敗すると原因を示す エラーコードを返します。

クロス検索以外の検索メソッドの見出しの格納位置に対して、この関数を 呼ぶことも可能ですが、そのような必要に迫られる機会はないでしょう。

## 外字

文字コードに収録されていない、私的に定義した文字のことを、俗に「外字」 と言います。 外字として定義した個々の文字を識別するために、文字コードに収録された 文字とは重複しない位置に、各文字の文字番号に割り振るのが普通です。 (割り当てる文字番号の詳細については、「文字コード」 を参照のこと。)

市販の電子ブック、EPWING でも、ほとんどが外字を使っています。 外字の定義状況は書籍同士でバラバラで、まったく統一感はありません。 つまり、同じ文字番号を使っていても、定義されている外字は書籍によって 違います。 外字は副本毎に定義することが可能ですが、一つの CD-ROM 書籍内でも副本に よって定義が異なることも珍しくありません。 副本によっては、数百から数千の外字を定義していることもあります。

CD-ROM 書籍では、定義した外字の字形データ (つまりフォント) を用意して います。 フォントはビットマップデータであり、書籍によっては大きさの異なる数種類 のフォントを用意しています。

逆に言えば、外字に対して提供されるデータは、フォントだけです。 ある文字番号を割り当てられた外字が、漢字なのか、発音記号なのか、 そういった補助的な情報は用意されていません。 アプリケーションプログラムが外字をサポートするためには、外字のフォント をそのまま表示する以外に方法はないでしょう。

### 半角外字と全角外字

CD-ROM 書籍における外字には、「全角外字」「半角外字」の二種類があります。 全角外字は用意されているフォントの横と縦の長さがおよそ 1:1 になっており、 半角外字では 1:2 になっています。

>     　　　　　　全角外字　　　　　　　　　　半角外字
>     　　　　（１６×１６）　　　　　　　　（８×１６）
>     □□□□□□□□□□□□□□□□　　□□□□□□□□
>     □□□□□□□□□□□□□□□□　　□□■■□■□□
>     □□□■■■■■■□□□■□□□　　□□□□■□□□
>     □□□□□□□□■□■□■□□□　　□□□■■□□□
>     □□□□■□□■□□■□■□□□　　□□■□□■□□
>     □□□□■□□■■■■■■□□□　　□■□□□■□□
>     □□■■■■■□□□■□■□□□　　□□□■□■□□
>     □□□□□□□□□□■□■□□□　　□□■□■■□□
>     □□□■□□□□□□□□■□□□　　□■□□□■□□
>     □□□■□□□□□□□□■□□□　　□■□□□■□□
>     □□□■■■■■■■■■■□□□　　□■□□□■□□
>     □□□■□□□□□□□□■□□□　　□■□□□■□□
>     □□□■□□□□□□□□■□□□　　□■□□□■□□
>     □□□■■■■■■■■■■□□□　　□■□□□■□□
>     □□□□□□□□□□□□□□□□　　□□■■■□□□
>     □□□□□□□□□□□□□□□□　　□□□□□□□□

テキストデータには、半角表示の開始と終了を表すエスケープシーケンスが あり (「テキストデータの内部形式」 を参照のこと)、 開始と終了の間に置かれたものは半角外字、それ以外のところなら全角外字に なります。

文字番号は同じでも、字形が全角と半角ではまったく異なることもあります ので、外字の文字番号だけから、全角と半角のどちらかを判断することは できません。 かならず、前方に半角開始のエスケープシーケンスが出現していたかどうか という情報に基づいて判断しないといけません。

ただし、全角か半角かの判定は EB ライブラリ側で行いますので、 アプリケーションプログラムが文脈の解析を行う必要はありません。

CD-ROM 書籍の副本には、半角外字あるいは全角外字のどちらか一方だけを 定義しているものもありますし、両方とも定義しているものもあります。

### 外字の大きさと外字コード

各副本には、定義している外字のフォントがビットマップ形式で収録されて います。 フォントの大きさは、縦のピクセル数を基準にすると 16, 24, 30, 48 の 4 種類があり、全角外字、半角外字それぞれのフォントの大きさ (横のピクセル数×縦のピクセル数) は次の通りになります。

縦のピクセル数 | 全角全角 | 半角外字
16 | 16x16 | 8x16
24 | 24x24 | 16x24
30 | 32x30 | 16x30
48 | 48x48 | 24x48

ただし、すべての副本でこれら 4 種類のフォントを用意しているわけでは ありません。 縦が 16 ピクセルのものは必ず用意されていますが、それ以外はないことも 珍しくありません。 (外字がまったく定義されていなければ、16 ピクセルのフォントも用意され ません。)

EB ライブラリでは、このように縦方向のピクセル数、つまり フォントの高さ (font height) を基準に、外字フォントの大きさを 区別しています。 そして、それぞれのフォントの高さ (16, 24, 30, 48) に対して、 外字コード (font code) というものを割り当てています。 フォントの高さを指定する際は、必ずこの外字コードを使います。

縦のピクセル数 | 外字コード
16 | `EB_FONT_16`
24 | `EB_FONT_24`
30 | `EB_FONT_30`
48 | `EB_FONT_48`

### 選択中の外字フォントの高さ

`EB_Book` オブジェクトで選択中の副本が用意している外字フォント の高さの中から一つ選んで、 選択中の外字フォントの高さ (current font height) として指定する ことができます。 EB ライブラリで外字のフォントデータ (ビットマップデータ) を取り出すには、 外字フォントの高さをあらかじめ選択しておく必要があります。

選択するには、関数 `eb_set_font()` を使います。 以下のプログラムは、高さ 24 ピクセルのフォントを選択する場合の例です。

>     /* book が EB_Book のオブジェクトで、すでに
>      * 書籍に結び付けられ、副本を選択中だと仮定しています。*/
>     if (eb_set_font(&book, EB_FONT_24) != EB_SUCCESS) {
>         printf("eb_set_font_() failed\n");
>         return;
>     }

このプログラムでは、高さ 24 ピクセルのフォントを選択中の副本が用意して いるものと仮定していますが、実際には用意していない副本も珍しくありません。 もし、副本が高さ 24 ピクセルのフォントを用意していなければ、 `eb_set_font()` は `EB_ERR_NO_SUCH_FONT` を返します。

しかし、外字を選択する前に、前もってその副本が用意しているフォントを 知りたいときもあります。 これには、2 通りの方法があります。

まず 1 つ目は、選択中の副本が用意しているフォントの高さの一覧を `eb_font_list()` で取得する方法です。 これは、副本コードの一覧を取得する `eb_subbook_list()` と 使い方が良く似ています。

>     EB_Font_Code font_list[EB_MAX_FONTS];
>     int font_count;
>     int i;

>     if (eb_font_list(&book, font_list, &font_count) != EB_SUCCESS) {
>         printf("eb_font_list() failed\n");
>         return;
>     }

>     for (i = 0; i < font_count; i++) {
>         if (font_list[i] == EB_FONT_24)
>             printf("this subbook has EB_FONT_24\n");
>     }

2 つ目は、`eb_have_font()` を使うやり方です。 この関数は、特定の高さのフォントを、選択中の副本が用意しているかどうか 調べることができます。

>     if (eb_have_font(&book, EB_FONT_24)) {
>         printf("this subbook has EB_FONT_24\n");
>     }

また、選択中の副本が半角外字、全角外字を定義しているかどうかは、それぞれ `eb_have_narrow_font()`, `eb_have_wide_font()` を使って調べることができます。

>     if (eb_have_narrow_font(&book))
>         printf("this subbook has narrow font\n");
>     if (eb_have_wide_font(&book))
>         printf("this subbook has wide font\n");

なお、あらかじめ副本を選択しておかないと、外字の高さは選択できないので 注意して下さい。 `eb_set_subbook()` で選択中の副本を切り替えると、外字フォント の高さは常に未選択の状態に戻ります。

### 外字フォントの取り出し

外字の高さを選択した状態であれば、外字のフォントデータ (ビットマップデータ) を取り出すことができます。

フォントデータを取り出す関数は、 全角外字なら `eb_wide_font_character_bitmap()`、 半角外字なら `eb_narrow_font_character_bitmap()` です。

全角外字 `0xa121` のフォントデータを取り出すプログラムは、 次のようになります。 半角外字の場合は、呼び出す関数名が変わるだけです。

>     /* book が EB_Book のオブジェクトで、すでに
>      * 書籍に結び付けられ、副本と外字の高さを選択中だと仮定しています。*/
>     char bitmap[EB_SIZE_WIDE_FONT_48];

>     if (eb_wide_font_character_bitmap(book, 0xa121, bitmap)
>         != EB_SUCCESS) {
>         return;
>     }

ここでは、`bitmap` にフォントデータを格納しています。 `bitmap` の領域として `EB_SIZE_WIDE_FONT_48` バイトを確保していますが、これは高さ 48 ピクセルの外字データを格納する ために必要なサイズを表します。

フォントデータのサイズは、外字の高さに応じて一定です。 高さ 48 ピクセルは外字の中でも最大のサイズなので、このサイズの領域を 用意すれば、どの高さの外字でも格納できます。

外字データは、ビットマップ形式のデータになっています。 背景色をビット値 0, 前景色をビット値 1 として、各ピクセルの値を並べて あります。 並び方ですが、左上からまずは右に向かってピクセルを拾っていき、左端まで 来たら一つ下の段に降りて、また右方向にピクセルを拾います。 以下、一番下の段までこれを繰り返します。

ただし、バイト内では、128, 64, 32, ...1 の桁の順にビット値を格納して います。 つまり、128 の桁は一番左のピクセル、1 の桁は一番右のピクセルに対応 します。

以下に、16x16 の全角外字のビットマップの例と、そのバイト列を記します。 背景色が□、前景色が■です。

>     □□□□□□□□□□□□□□□□　　0x00, 0x00,
>     □□□□□□□□□□□□□□□□　　0x00, 0x00,
>     □□□■■■■■■□□□■□□□　　0x1f, 0x88,
>     □□□□□□□□■□■□■□□□　　0x00, 0xc8,
>     □□□□■□□■□□■□■□□□　　0x09, 0x28,
>     □□□□■□□■■■■■■□□□　　0x09, 0xf8,
>     □□■■■■■□□□■□■□□□　　0x3e, 0x28,
>     □□□□□□□□□□■□■□□□　　0x00, 0x28,
>     □□□■□□□□□□□□■□□□　　0x10, 0x08,
>     □□□■□□□□□□□□■□□□　　0x10, 0x08,
>     □□□■■■■■■■■■■□□□　　0x1f, 0xf8,
>     □□□■□□□□□□□□■□□□　　0x18, 0x08,
>     □□□■□□□□□□□□■□□□　　0x18, 0x08,
>     □□□■■■■■■■■■■□□□　　0x1f, 0xf8,
>     □□□□□□□□□□□□□□□□　　0x00, 0x00,
>     □□□□□□□□□□□□□□□□　　0x00, 0x00,

### 外字フォントの変換

EB ライブラリには、外字のビットマップデータを XBM, XPM, GIF, BMP, PNG の各画像形式に変換する関数が用意されています。 変換を行う関数は、次の 5 つです。

`eb_bitmap_to_xbm()` | XBM への変換
`eb_bitmap_to_xpm()` | XPM への変換
`eb_bitmap_to_gif()` | GIF への変換
`eb_bitmap_to_bmp()` | BMP への変換
`eb_bitmap_to_png()` | PNG への変換

どの関数も呼び出し方は同じですが、ここでは XBM への変換のプログラム例 を示します。

>     /* bitmap に高さ 16 の全角外字のビットマップデータが格納
>      * されていると仮定しています。*/
>     char bitmap[EB_SIZE_WIDE_FONT_16];
>     char xbm[EB_SIZE_WIDE_FONT_16_XBM];
>     size_t xbmsize;

>     if (eb_wide_font_character_bitmap(bitmap, EB_WIDTH_WIDE_FONT_16,
>         EB_HEIGHT_FONT_16, xbm, &xbmsize) != EB_SUCCESS) {
>         return;
>     }

XPM, GIF, PNG への変換では、前景色は黒、背景色は透明になります。 BMP への変換では、前景色は黒、背景色は白になります。 XBM はモノクロ図版用のデータ形式なので、色の設定はありません。

### テキスト中の外字

外字はテキストデータ (本文、メニューなど) の中で使われています。

アプリケーションプログラムが、テキストデータ中に出現する外字を識別して 処理を行うには、外字に対するフックを設定して、フック関数の中で処理する ことになります。

外字に対するフックは、全角外字に対する `EB_HOOK_WIDE_FONT` と 半角外字に対する `EB_HOOK_NARROW_FONT` の二種類があります。 いずれも、外字が一字出現する度に、設定したフック関数を呼び出します。

フックの扱い方については、「フックコードの一覧」 を参照のこと。

### データ型の詳細

この節で説明しているデータ型を使うには、次のようにヘッダファイルを 読み込んで下さい。

>     #include <eb/eb.h>

#### `EB_Font_Code` 型

外字コードは、外字の高さ (ピクセル数) を表します。 現在のところ、定義されている高さは次の通りです。

- `EB_FONT_16`
- `EB_FONT_24`
- `EB_FONT_30`
- `EB_FONT_48`
- `EB_FONT_INVALID`

外字コードの実体は整数値ですが、`EB_FONT_16` の値は 16 では ありません。 他も同様ですので、注意して下さい。

`EB_FONT_INVALID` は特別な外字コードで、不正な外字コード値を 表すために用います。

### 定数の詳細

この節で説明している定数を使うには、次のようにヘッダファイルを 読み込んで下さい。

>     #include <eb/font.h>

#### 定数 `EB_WIDTH_NARROW_FONT_16`

#### 定数 `EB_WIDTH_NARROW_FONT_24`

#### 定数 `EB_WIDTH_NARROW_FONT_30`

#### 定数 `EB_WIDTH_NARROW_FONT_48`

#### 定数 `EB_WIDTH_WIDE_FONT_16`

#### 定数 `EB_WIDTH_WIDE_FONT_24`

#### 定数 `EB_WIDTH_WIDE_FONT_30`

#### 定数 `EB_WIDTH_WIDE_FONT_48`

これらの定数は、半角、全角およびそれぞれの高さ (外字コード) の外字一個 分の幅 (横方向のピクセル数) を `int` 型で表しています。

#### 定数 `EB_HEIGHT_NARROW_FONT_16`

#### 定数 `EB_HEIGHT_NARROW_FONT_24`

#### 定数 `EB_HEIGHT_NARROW_FONT_30`

#### 定数 `EB_HEIGHT_NARROW_FONT_48`

#### 定数 `EB_HEIGHT_WIDE_FONT_16`

#### 定数 `EB_HEIGHT_WIDE_FONT_24`

#### 定数 `EB_HEIGHT_WIDE_FONT_30`

#### 定数 `EB_HEIGHT_WIDE_FONT_48`

これらの定数は、半角、全角およびそれぞれの高さ (外字コード) の外字一個分 の縦方向のピクセル数を `int` 型で表しています。

`EB_HEIGHT_NARROW_FONT_16` および `EB_HEIGHT_WIDE_FONT_16` の実際の値は 16 です。 (外字コード `EB_FONT_16` の実際の値は 16 ではありませんので、 注意して下さい。)

#### 定数 `EB_SIZE_NARROW_FONT_16`

#### 定数 `EB_SIZE_NARROW_FONT_24`

#### 定数 `EB_SIZE_NARROW_FONT_30`

#### 定数 `EB_SIZE_NARROW_FONT_48`

#### 定数 `EB_SIZE_WIDE_FONT_16`

#### 定数 `EB_SIZE_WIDE_FONT_24`

#### 定数 `EB_SIZE_WIDE_FONT_30`

#### 定数 `EB_SIZE_WIDE_FONT_48`

これらの定数は、半角、全角およびそれぞれの高さ (外字コード) の外字一個分 のビットマップデータを格納するのに必要な領域の大きさを表しています。 値は `int` 型で、単位はバイトです。

#### 定数 `EB_SIZE_NARROW_FONT_16_XBM`

#### 定数 `EB_SIZE_NARROW_FONT_24_XBM`

#### 定数 `EB_SIZE_NARROW_FONT_30_XBM`

#### 定数 `EB_SIZE_NARROW_FONT_48_XBM`

#### 定数 `EB_SIZE_WIDE_FONT_16_XBM`

#### 定数 `EB_SIZE_WIDE_FONT_24_XBM`

#### 定数 `EB_SIZE_WIDE_FONT_30_XBM`

#### 定数 `EB_SIZE_WIDE_FONT_48_XBM`

これらの定数は、半角、全角およびそれぞれの高さ (外字コード) の外字一個分 のビットマップデータを `eb_bitmap_to_xbm()` を用いて XBM 形式 に変換する際に、変換後の XBM 形式のデータの大きさを表しています。 値は `int` 型で、単位はバイトです。

#### 定数 `EB_SIZE_NARROW_FONT_16_XPM`

#### 定数 `EB_SIZE_NARROW_FONT_24_XPM`

#### 定数 `EB_SIZE_NARROW_FONT_30_XPM`

#### 定数 `EB_SIZE_NARROW_FONT_48_XPM`

#### 定数 `EB_SIZE_WIDE_FONT_16_XPM`

#### 定数 `EB_SIZE_WIDE_FONT_24_XPM`

#### 定数 `EB_SIZE_WIDE_FONT_30_XPM`

#### 定数 `EB_SIZE_WIDE_FONT_48_XPM`

これらの定数は、半角、全角およびそれぞれの高さ (外字コード) の外字一個分 のビットマップデータを `eb_bitmap_to_xpm()` を用いて XPM 形式 に変換する際に、変換後の XPM 形式のデータの大きさを表しています。 値は `int` 型で、単位はバイトです。

#### 定数 `EB_SIZE_NARROW_FONT_16_GIF`

#### 定数 `EB_SIZE_NARROW_FONT_24_GIF`

#### 定数 `EB_SIZE_NARROW_FONT_30_GIF`

#### 定数 `EB_SIZE_NARROW_FONT_48_GIF`

#### 定数 `EB_SIZE_WIDE_FONT_16_GIF`

#### 定数 `EB_SIZE_WIDE_FONT_24_GIF`

#### 定数 `EB_SIZE_WIDE_FONT_30_GIF`

#### 定数 `EB_SIZE_WIDE_FONT_48_GIF`

これらの定数は、半角、全角およびそれぞれの高さ (外字コード) の外字一個分 のビットマップデータを `eb_bitmap_to_gif()` を用いて GIF 形式 に変換する際に、変換後の GIF 形式のデータの大きさを表しています。 値は `int` 型で、単位はバイトです。

#### 定数 `EB_SIZE_NARROW_FONT_16_BMP`

#### 定数 `EB_SIZE_NARROW_FONT_24_BMP`

#### 定数 `EB_SIZE_NARROW_FONT_30_BMP`

#### 定数 `EB_SIZE_NARROW_FONT_48_BMP`

#### 定数 `EB_SIZE_WIDE_FONT_16_BMP`

#### 定数 `EB_SIZE_WIDE_FONT_24_BMP`

#### 定数 `EB_SIZE_WIDE_FONT_30_BMP`

#### 定数 `EB_SIZE_WIDE_FONT_48_BMP`

これらの定数は、半角、全角およびそれぞれの高さ (外字コード) の外字一個分 のビットマップデータを `eb_bitmap_to_bmp()` を用いて BMP 形式 に変換する際に、変換後の BMP 形式のデータの大きさを表しています。 値は `int` 型で、単位はバイトです。

#### 定数 `EB_SIZE_NARROW_FONT_16_PNG`

#### 定数 `EB_SIZE_NARROW_FONT_24_PNG`

#### 定数 `EB_SIZE_NARROW_FONT_30_PNG`

#### 定数 `EB_SIZE_NARROW_FONT_48_PNG`

#### 定数 `EB_SIZE_WIDE_FONT_16_PNG`

#### 定数 `EB_SIZE_WIDE_FONT_24_PNG`

#### 定数 `EB_SIZE_WIDE_FONT_30_PNG`

#### 定数 `EB_SIZE_WIDE_FONT_48_PNG`

これらの定数は、半角、全角およびそれぞれの高さ (外字コード) の外字一個分 のビットマップデータを `eb_bitmap_to_png()` を用いて PNG 形式 に変換する際に、変換後の PNG 形式のデータの大きさを表しています。 値は `int` 型で、単位はバイトです。

### 関数の詳細

この節で説明している関数を使うには、次のようにヘッダファイルを読み込んで 下さい。

>     #include <eb/font.h>

#### `EB_Error_Code eb_font (EB_Book *book, EB_Font_Code *font_code)`

関数 `eb_font()` は、選択している副本において、選択中の 外字フォントの高さを表す外字コードを font_code の指す領域に 書き込みます。

成功すると関数は `EB_SUCCESS` を返します。 失敗すると font_code の指す領域に `EB_FONT_INVALID` を書き込み、原因を示すエラーコードを返します。

あらかじめ、外字フォントの高さが選択されていなければなりません。 外字が選択されていなければ、`EB_ERR_NO_CUR_FONT` を返します。 副本そのものを選択していない場合も、同様です。

#### `EB_Error_Code eb_set_font (EB_Book *book, EB_Font_Code font_code)`

関数 `eb_set_font()` は、選択中の副本における外字フォントの 高さをセットします。 セットする外字フォントの「高さ」は、対応する外字コードを引数 font_code で指定します。

この関数は、成功すると `EB_SUCCESS` を返し、指定した「高さ」が 「選択中の外字フォントの高さ」となります。 すでに外字フォントの高さを選択していた場合は、いったん未選択の状態に してからあらためて font_code を選択します。

失敗すると原因を示すエラーコードを返し、外字フォントの高さは未選択の 状態になります。

あらかじめ、book 内のいずれかの副本が選択されていなくては なりません。 book が副本を選択していなければ、`EB_ERR_NO_CUR_SUB` を返します。 また、その副本が持っていない外字フォントの高さが指定されると、 `EB_ERR_NO_SUCH_FONT` を返します。

#### `void eb_unset_font (EB_Book *book)`

関数 `eb_unset_font()` は、選択中の外字フォントの高さを未選択 の状態に戻します。 book が書籍に結び付いていない場合や副本が選択されていない場合、 もしくは外字フォントの高さが選択されていない場合は何もしません。

#### `EB_Error_Code eb_font_list (EB_Book *book, EB_Font_Code *font_list, int *font_count)`

関数 `eb_font_list()` は、選択中の副本が定義している外字の 高さの一覧を `EB_Font_Code` 型の配列にして、font_list の指す領域に書き込みます。

配列は、最大で `EB_MAX_FONTS` 個の要素を持ちます。 加えて、書籍が収録している副本の個数を font_count の指す領域に 書き込みます。 (現在のバージョンでは 、`EB_MAX_FONTS` の値は 4 になっています。 高さ 16, 24, 30, 48 ピクセルの 4 種類です。)

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、font_count の指す領域に 0 を書き込み、原因を示す エラーコードを返します。

あらかじめ、book 内のいずれかの副本が選択されていなくては なりません。 book が副本を選択していなければ、`EB_ERR_NO_CUR_SUB` を返します。

#### `int eb_have_font (EB_Book *book, EB_Font_Code font_code)`

関数 `eb_font()` は、font_code で指定した高さの 外字フォントを、選択中の副本が持っているかどうかを調べます。

持っていれば 1 を返し、持っていなければ 0 を返します。 book が副本を選択していない場合も 0 を返します。

#### `EB_Error_Code eb_font_height (EB_Book *book, int *height)`

関数 `eb_font_height()` は、book が選択中の 外字フォントの高さ (縦方向のピクセル数) を height の指す領域に 書き込みます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、height の指す領域に 0 を書き込み、原因を示す エラーコードを返します。

あらかじめ、book は外字フォントの高さを選択していなくては なりません。 選択していない場合は、`EB_ERR_NO_CUR_FONT` を返します。

#### `EB_Error_Code eb_font_height2 (EB_Font_Code font_code, int *height)`

`eb_font_height()` と似ていますが、選択中の副本ではなく、引数 font_height で指定された外字コードの高さ (縦方向のピクセル数) を書き込む点が異なります。

#### `int eb_have_narrow_font (EB_Book *book)`

#### `int eb_have_wide_font (EB_Book *book)`

関数 `eb_have_narrow_font()` は、選択中の副本が半角外字を定義 しているかどうかを調べます。 同様に、関数 `eb_have_wide_font()` は、全角外字を定義しているか どうかを調べます。

定義していれば 1 を、定義していなければ 0 を返します。 book が副本を選択していない場合も 0 を返します。

#### `EB_Error_Code eb_narrow_font_width (EB_Book *book, int *width)`

#### `EB_Error_Code eb_wide_font_width (EB_Book *book, int *width)`

関数 `eb_narrow_font_width()` は、book が選択中の 外字フォントの高さにおける半角外字の幅 (横方向のピクセル数) を、 height の指す領域に書き込みます。 同様に、`eb_wide_font_width()` は全角外字の幅を書き込みます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、width の指す領域に 0 を書き込み、原因を示す エラーコードを返します。

あらかじめ、book は外字の高さを選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_FONT` を返します。

#### `EB_Error_Code eb_narrow_font_width2 (EB_Font_Code font_code, int *width)`

#### `EB_Error_Code eb_wide_font_width2 (EB_Font_Code font_code, int *width)`

`eb_narrow_font_width()`, `eb_wide_font_width()` と 似ていますが、選択中の副本ではなく、引数font_height で指定された 外字コードの幅 (横方向のピクセル数) を書き込む点が異なります。

#### `EB_Error_Code eb_narrow_font_size (EB_Book *book, size_t *size)`

#### `EB_Error_Code eb_wide_font_size (EB_Book *book, size_t *size)`

関数 `eb_narrow_font_size()` は、book が選択中の 外字フォントの高さにおける半角外字一個分のデータサイズ (バイト数) を、 size の指す領域に書き込みます。 同様に、`eb_wide_font_size()` は全角外字のサイズを書き込みます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、size の指す領域に 0 を書き込み、原因を示す エラーコードを返します。

あらかじめ、book は外字フォントの高さを選択していなくては なりません。 選択していない場合は、`EB_ERR_NO_CUR_FONT` を返します。

#### `EB_Error_Code eb_narrow_font_size2 (EB_Font_Code font_code, size_t *size)`

#### `EB_Error_Code eb_wide_font_size2 (EB_Font_Code font_code, size_t *size)`

`eb_narrow_font_size()`, `eb_wide_font_size()` と 似ていますが、選択中の副本ではなく、引数 font_height で指定 された外字コードの外字一個分のデータサイズを書き込む点が異なります。

#### `EB_Error_Code eb_narrow_font_start (EB_Book *book, int *start)`

#### `EB_Error_Code eb_wide_font_start (EB_Book *book, int *start)`

関数 `eb_narrow_font_start()` は、book が選択中の 副本における半角外字の先頭の文字番号 (半角外字の文字番号の中で最小のもの) を、start の指す領域に書き込みます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、原因を示すエラーコードを返します。

あらかじめ、book は副本を選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_SUB` を返します。 副本が半角外字を定義していない場合は、`EB_ERR_NO_CUR_FONT` を 返します。

関数 `eb_wide_font_start()` は、半角外字ではなく全角外字に ついて調べるという点を除いて、`eb_narrow_font_start()` と同じ です。

#### `EB_Error_Code eb_narrow_font_end (EB_Book *book, int *end)`

#### `EB_Error_Code eb_wide_font_end (EB_Book *book, int *end)`

関数 `eb_narrow_font_end()` は、book が選択中の副本 における半角外字の最後の文字番号 (半角外字の文字番号の中で最大のもの) を、 start の指す領域に書き込みます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、原因を示すエラーコードを返します。

あらかじめ、book は副本を選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_SUB` を返します。 副本が半角外字を定義していない場合は、`EB_ERR_NO_CUR_FONT` を 返します。

関数 `eb_wide_font_end()` は、半角外字ではなく全角外字について 調べるという点を除いて、`eb_narrow_font_end()` と同じです。

#### `EB_Error_Code eb_narrow_font_character_bitmap (EB_Book *book, int character_number, char *bitmap)`

#### `EB_Error_Code eb_wide_font_character_bitmap (EB_Book *book, int character_number, char *bitmap)`

関数 `eb_narrow_font_character_bitmap()` は、book が選択中の副本で定義している、半角外字のビットマップデータを取り出します。 取り出す外字の文字番号を、character_number で指定します。

成功すると、関数はビットマップデータを bitmap の指す領域に 書き込み、`EB_SUCCESS` を返します。 失敗すると、bitmap の指す領域に空文字列を書き込み、原因を示す エラーコードを返します。

あらかじめ、book は外字フォントの高さを選択していなくては なりません。 選択していない場合は、`EB_ERR_NO_CUR_FONT` を返します。 副本が半角外字を定義していない場合も、やはり `EB_ERR_NO_CUR_FONT` を返します。 文字番号 character_number が外字の定義範囲外にある場合は、 `EB_ERR_NO_SUCH_CHAR_BMP` を返します。

関数 `eb_wide_font_character_bitmap()` は、半角外字ではなく 全角外字のビットマップデータを取り出すという点を除いて、 `eb_narrow_font_character_bitmap()` と同じです。

ビットマップデータの形式については、 「外字フォントの取り出し」 を参照のこと。

#### `EB_Error_Code eb_forward_narrow_font_character (EB_Book *book, int n, int *character_number)`

#### `EB_Error_Code eb_forward_wide_font_character (EB_Book *book, int n, int *character_number)`

関数 `eb_forward_narrow_font_character()` は、book が選択中の副本で定義されている半角外字の文字番号 character_number のn 個後ろに位置する外字の文字番号を取得します。

まず、関数を呼び出す際に、character_number の指す領域に 文字番号を書き込んでおきます。 関数の処理が成功すると、戻ったときに n 個分だけ後方の文字番号 に書き換わっています。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、原因を示すエラーコードを返します。

あらかじめ、book は副本を選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_SUB` を返します。 副本が半角外字を持っていない場合は、`EB_ERR_NO_CUR_FONT` を 返します。

n 個後ろにもう外字がない場合や、呼び出した際に character_number の指す領域に書き込んであった文字番号が外字の 定義範囲外にある場合は `EB_ERR_NO_SUCH_CHAR_BMP` を返します。

n には負の数を指定することもできます。 この場合、次の呼び出しと等価になります。

>     /* n < 0 とする */
>     eb_backward_narrow_font_character (book, -n, character_number);

関数 `eb_forward_wide_font_character()` は、半角外字ではなく 全角外字について操作するという点を除いて、 `eb_forward_narrow_font_character()` と同じです。

#### `EB_Error_Code eb_backward_narrow_font_character (EB_Book *book, int n, int *character_number)`

#### `EB_Error_Code eb_backward_wide_font_character (EB_Book *book, int n, int *character_number)`

関数 `eb_backward_narrow_font_character()` は `eb_forward_narrow_font_character()` とはちょうど逆の関数です。 book が選択中の副本で定義されている半角外字の文字番号 character_number の n 個前方に位置する外字の 文字番号を取得します。

同様に、`eb_backward_wide_font_character()` は、全角外字に ついて n 個前方の外字の文字番号を取得する関数で、 `eb_forward_wide_font_character()` と反対の関数です。

n には負の数を指定することも可能で、それぞれ次の呼び出しと 等価になります。

>     /* 半角外字の場合 (n < 0) */
>     eb_forward_narrow_font_character (book, -n, character_number);

>     /* 全角外字の場合 (n < 0) */
>     eb_forward_wide_font_character (book, -n, character_number);

#### `EB_Error_Code eb_narrow_font_xbm_size (EB_Font_Code height, size_t *size)`

#### `EB_Error_Code eb_narrow_font_xpm_size (EB_Font_Code height, size_t *size)`

#### `EB_Error_Code eb_narrow_font_gif_size (EB_Font_Code height, size_t *size)`

#### `EB_Error_Code eb_narrow_font_bmp_size (EB_Font_Code height, size_t *size)`

#### `EB_Error_Code eb_narrow_font_png_size (EB_Font_Code height, size_t *size)`

#### `EB_Error_Code eb_wide_font_xbm_size (EB_Font_Code height, size_t *size)`

#### `EB_Error_Code eb_wide_font_xpm_size (EB_Font_Code height, size_t *size)`

#### `EB_Error_Code eb_wide_font_gif_size (EB_Font_Code height, size_t *size)`

#### `EB_Error_Code eb_wide_font_bmp_size (EB_Font_Code height, size_t *size)`

#### `EB_Error_Code eb_wide_font_png_size (EB_Font_Code height, size_t *size)`

最初の 5 つの関数 (`eb_narrow_font_xbm_size()` 〜 `eb_narrow_font_png_size()`) は、外字コード height の半角外字一個のビットマップを XBM, XPM, GIF, BMP, PNG 形式にそれぞれ変換 したときのデータサイズを size の指す領域に書き込みます。

同様に、後ろの 5 つの関数 (`eb_wide_font_xbm_size()` 〜 `eb_wide_font_png_size()`) は、全角外字を変換したときの データサイズを書き込みます。

いずれの関数も、成功すると `EB_SUCCESS` を返します。 失敗すると、size の指す領域に 0 を書き込み、原因を示す エラーコードを返します。

#### `EB_Error_Code eb_bitmap_to_xbm (const char *bitmap, int width, int height, char *image, size_t *image_length)`

#### `EB_Error_Code eb_bitmap_to_xpm (const char *bitmap, int width, int height, char *image, size_t *image_length)`

#### `EB_Error_Code eb_bitmap_to_gif (const char *bitmap, int width, int height, char *image, size_t *image_length)`

#### `EB_Error_Code eb_bitmap_to_bmp (const char *bitmap, int width, int height, char *image, size_t *image_length)`

#### `EB_Error_Code eb_bitmap_to_png (const char *bitmap, int width, int height, char *image, size_t *image_length)`

これら 5 つの関数は、`eb_narrow_font_character()` または `eb_wide_font_character()` で取り出した外字のビットマップを XBM, XPM, GIF, BMP, PNG 形式にそれぞれ変換します。

ビットマップデータの指す領域を bitmap で指定し、ビットマップの 高さと幅を width, height で渡します。

関数の呼び出しから戻ると、image の指す領域に変換後のデータが 書き込まれ、image_length の指す領域に変換後のデータの大きさが 書き込まれます。

XPM, GIF, PNG への変換では、前景色は黒、背景色は透明になります。 BMP への変換では、前景色は黒、背景色は白になります。 XBM はモノクロ図版用のデータ形式なので、色の設定はありません。

### サンプルプログラム

>     /*                                                            -*- C -*-
>      * Copyright (c) 2002-2006  Motoyuki Kasahara
>      *
>      * Redistribution and use in source and binary forms, with or without
>      * modification, are permitted provided that the following conditions
>      * are met:
>      * 1. Redistributions of source code must retain the above copyright
>      *    notice, this list of conditions and the following disclaimer.
>      * 2. Redistributions in binary form must reproduce the above copyright
>      *    notice, this list of conditions and the following disclaimer in the
>      *    documentation and/or other materials provided with the distribution.
>      * 3. Neither the name of the project nor the names of its contributors
>      *    may be used to endorse or promote products derived from this software
>      *    without specific prior written permission.
>      *
>      * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
>      * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>      * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
>      * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
>      * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
>      * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
>      * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
>      * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
>      * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
>      * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
>      * SUCH DAMAGE.
>      */

>     /*
>      * 使用方法:
>      *     font <book-path> <subbook-index>
>      * 例:
>      *     font /cdrom 0
>      * 説明:
>      *     <book-path> で指定した CD-ROM 書籍から特定の副本を選び、その
>      *     副本が定義している半角外字 (高さ 16 ピクセル) をすべてアスキー
>      *     アートで表示します。
>      *
>      *     その副本が、高さ 16 ピクセルの半角外字を定義していないと、エ
>      *     ラーになります。
>      *
>      *     <subbook-index> には、検索対象の副本のインデックスを指定しま
>      *     す。インデックスは、書籍の最初の副本から順に 0、1、2 ... に
>      *     なります。
>      */
>     #include <stdio.h>
>     #include <stdlib.h>

>     #include <eb/eb.h>
>     #include <eb/error.h>
>     #include <eb/font.h>

>     int
>     main(int argc, char *argv[])
>     {
>         EB_Error_Code error_code;
>         EB_Book book;
>         EB_Subbook_Code subbook_list[EB_MAX_SUBBOOKS];
>         int subbook_count;
>         int subbook_index;
>         int font_start;
>         unsigned char bitmap[EB_SIZE_NARROW_FONT_16];
>         int i, j;

>         /* コマンド行引数をチェック。*/
>         if (argc != 3) {
>             fprintf(stderr, "Usage: %s book-path subbook-index\n",
>                 argv[0]);
>             exit(1);
>         }

>         /* EB ライブラリと `book' を初期化。*/
>         eb_initialize_library();
>         eb_initialize_book(&book);

>         /* 書籍を `book' に結び付ける。*/
>         error_code = eb_bind(&book, argv[1]);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to bind the book, %s: %s\n",
>                 argv[0], eb_error_message(error_code), argv[1]);
>             goto die;
>         }

>         /* 副本の一覧を取得。*/
>         error_code = eb_subbook_list(&book, subbook_list, &subbook_count);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to get the subbbook list, %s\n",
>                 argv[0], eb_error_message(error_code));
>             goto die;
>         }

>         /* 副本のインデックスを取得。*/
>         subbook_index = atoi(argv[2]);

>         /*「現在の副本 (current subbook)」を設定。*/
>         error_code = eb_set_subbook(&book, subbook_list[subbook_index]);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to set the current subbook, %s\n",
>                 argv[0], eb_error_message(error_code));
>             goto die;
>         }

>         /*「現在の外字の大きさ」を設定。*/
>         if (eb_set_font(&book, EB_FONT_16) < 0) {
>             fprintf(stderr, "%s: failed to set the font size, %s\n",
>                 argv[0], eb_error_message(error_code));
>             goto die;
>         }

>         /* 外字の開始位置を取得。*/
>         error_code = eb_narrow_font_start(&book, &font_start);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to get font information, %s\n",
>                 argv[0], eb_error_message(error_code));
>             goto die;
>         }

>         i = font_start;
>         for (;;) {
>             /* 外字のビットマップデータを取得。*/
>             error_code = eb_narrow_font_character_bitmap(&book, i,
>                 (char *)bitmap);
>             if (error_code != EB_SUCCESS) {
>                 fprintf(stderr, "%s: failed to get font data, %s\n",
>                     argv[0], eb_error_message(error_code));
>                 goto die;
>             }

>             /* ビットマップをアスキーアートにして出力。*/
>             printf("code point=%04x\n", i);
>             for (j = 0; j < 16; j++) {
>                 fputc((bitmap[j] & 0x80) ? '*' : ' ', stdout);
>                 fputc((bitmap[j] & 0x40) ? '*' : ' ', stdout);
>                 fputc((bitmap[j] & 0x20) ? '*' : ' ', stdout);
>                 fputc((bitmap[j] & 0x10) ? '*' : ' ', stdout);
>                 fputc((bitmap[j] & 0x08) ? '*' : ' ', stdout);
>                 fputc((bitmap[j] & 0x04) ? '*' : ' ', stdout);
>                 fputc((bitmap[j] & 0x02) ? '*' : ' ', stdout);
>                 fputc((bitmap[j] & 0x01) ? '*' : ' ', stdout);
>                 fputc('\n', stdout);
>             }
>             fputs("--------\n", stdout);

>             /* 外字の文字番号を一つ進める。*/
>             error_code = eb_forward_narrow_font_character(&book, 1, &i);
>             if (error_code != EB_SUCCESS)
>                 break;
>         }

>         /* 書籍と EB ライブラリの利用を終了。*/
>         eb_finalize_book(&book);
>         eb_finalize_library();
>         exit(0);

>         /* エラー発生で終了するときの処理。*/
>       die:
>         eb_finalize_book(&book);
>         eb_finalize_library();
>         exit(1);
>     }

## バイナリデータ

バイナリデータ (binary data) とは、 図版や動画、音声といったマルチメディアデータのことを指します。 バイナリデータは、必ずテキストデータ (「テキストデータ」 を参照のこと) から参照される形で利用されます。

今のところ EB ライブラリでは、全種類のバイナリデータを取り扱うことが できるわけではありません。 電子ブックで扱えるのは、2 階調のモノクロ図版と、カラー図版 (JPEG) だけ です。 EPWING では、モノクロ図版、カラー図版 (BMP および JPEG) に加えて、 WAVE (PCM) 音声、MPEG 動画を扱うことができます。

ただし、EB ライブラリが提供しているのは、こうしたバイナリデータを CD-ROM 書籍から取得する機能だけです。 表示したり再生したりする機能は用意していませんので、注意して下さい。

アプリケーションは、英和辞書や国語辞書といった辞書だけを対象にするなら、 バイナリデータの表示や再生には対応しなくても支障はありません。 しかし一方では、図鑑や数式の表現にモノクロ図版を使っている数学辞典の ように、対応しないと不便なものもあります。 バイナリデータの表示や再生の機能を実装するかどうかは、アプリケーション の対象辞書をどの範囲までにするのかによって決めると良いでしょう。

以下、この章では種類別にバイナリデータの扱い方について説明します。

バイナリデータの種類毎にデータの取り出し方は微妙に異なりますが (これは データの収録方法が微妙に異なっているからに他なりません)、おおよそ手順 は、次のようなものになります。

1. テキストデータのフックを用いて、バイナリデータの参照情報を取得する。
2. `eb_binary_set_...()` 関数を呼び出して、指定した位置の バイナリデータをこれから読み込む旨を EB ライブラリに伝える。
3. `eb_read_binary()` で実際にデータを読み込む。

テキストデータと同様に、バイナリデータも副本に属するデータ ですので、副本を選択していないと取得することはできません。 バイナリデータの読み込みには、テキストデータとは別の ファイルディスクリプタが割り当てられます。 したがって、双方を交互に読み込んでも、動作には影響はありません。

### モノクロ図版

2 階調のモノクロ図版は、電子ブック、EPWING 双方に存在し、EB ライブラリ ではどちらも扱うことができます。 (電子ブックに存在する 16 階調のモノクロ図版は、今のところ EB ライブラリ では対応していません。)

モノクロ図版データの内部形式は外字と同じですが、EB ライブラリでは、 1 ピクセルに 1bit を割り当てた BMP 形式に変換してアプリケーションに 渡すようにしています。 したがって、アプリケーションからは、あたかも BMP の図版データが収録 されているようにみえます。

テキストデータ内からは、バイナリデータであるモノクロ図版を参照する形 をとります。 モノクロ図版を取り出すには、この参照情報が必要です。 参照情報の取得は、テキストデータ処理時に、モノクロ図版の開始と終了を 表すエスケープシーケンスへのフック `EB_HOOK_BEGIN_MONO_GRAPHIC` と `EB_HOOK_END_MONO_GRAPHIC` を用いて行います。

フック `EB_HOOK_BEGIN_MONO_GRAPHIC` がフック関数に渡す引数 (`argv`) は 4 つあり、このうちの `argv[2]` と `argv[3]` が図版の幅と高さ (ピクセル数) を意味します。

また、フック `EB_HOOK_END_MONO_GRAPHIC` がフック関数に渡す 引数は 3 つで、`argv[1]` と `argv[2]` が、 図版データのページ番号とオフセットになります。

モノクロ図版を取得するには、上記のフックから得た図版のページ番号と オフセット、および幅と高さを記憶しておきます。

次に、`eb_set_binary_mono_graphic()` を呼び出して、これから モノクロ図版のデータを取得することを EB ライブラリに伝えます。 `eb_set_binary_mono_graphic()` への引数には、 `EB_Book` オブジェクトと、先ほど得た図版へのページ番号、 オフセット、幅、高さを渡します。 `EB_Book` オブジェクトは、これから取り出そうとしている図版を 収録している副本をあらかじめ選択しておく必要があります。

>     /* eb_set_binary_mono_graphic() の関数プロトタイプ */
>     EB_Error_Code
>     eb_set_binary_mono_graphic(EB_Book *book, EB_Position *position,
>         int width, int height);

電子ブックでは、フック関数に渡される幅と高さの値は 0 になっていますが、 そのまま `eb_set_binary_mono_graphic()` に渡します。 (EPWING では 0 を渡してはいけません。)

以上で図版データの取得準備ができたので、データを読み込みます。 これには、`eb_read_binary()` を使います。

>     #define MAX_LENGTH 1000
>     char bitmap[MAX_LENGTH];
>     ssize_t bitmap_length;

>     if (eb_read_binary(&book, MAX_LENGTH, bitmap, &bitmap_length)
>         != EB_SUCCESS) {
>         fprintf(stderr, "an error occurs.\n");
>         return;
>     }

成功すると、読み込んだ図版データが `bitmap` に書き込まれ、 何バイト書き込んだのかが `bitmap_length` に書き込まれます。 書き込まれるバイト数は、最大で `MAX_LENGTH` バイトです。

必ずしも一回の `eb_read_binary()` の呼び出しで図版データを 終端まで読み込む必要はなく、関数を繰り返し呼び出せば、前回の続きを 読み込むことができます。 `eb_read_binary()` は、図版データの終端まで来るとそれ以上 データは読み込みませんので、`eb_read_binary()` が 0 を返した 時点で図版データが終端したことを認識できます。

### カラー図版

カラー図版は、電子ブックでは JPEG 形式、EPWING では JPEG と BMP (DIB) 形式のものが使用されています。 EB ライブラリはこれらをすべて扱うことができますが、電子ブックへの対応 は限定的なものになっています。(詳しくは後述します。)

カラー図版のデータを取り出すには、モノクロ図版と同様にテキストデータ からカラー図版への参照情報をフックを通じて取得し、続いて実際に カラー図版のデータを読み込むという手順になります。

`eb_set_binary_color_graphic()` を呼び出して、これから アプリケーションがカラー図版のデータを取得しようとしていることを EB ライブラリに伝えます。 `eb_set_binary_color_graphic()` への引数には、 `EB_Book` オブジェクトに加えて、カラー図版のページ番号と オフセットを渡します。

>     /* eb_set_binary_color_graphic() の関数プロトタイプ */
>     EB_Error_Code
>     eb_set_binary_color_graphic(EB_Book *book, EB_Position *position);

`EB_Book` オブジェクトは、これから取り出そうとしている図版を 収録している副本をあらかじめ選択しておきます。 カラー図版のページ番号とオフセットの情報は、カラー図版の開始と終了を表す エスケープシーケンスへのフックから得ます。 フックは、インライン表示用と非インライン用の 2 種類があり、さらに それぞれ開始フックが JPEG 用と BMP 用に分かれています。

`EB_HOOK_BEGIN_COLOR_BMP`
`EB_HOOK_BEGIN_COLOR_JPEG`
  非インライン用 BMP, JPEG の開始フック
`EB_HOOK_END_COLOR_GRAPHIC`
  非インライン用カラー図版 (BMP, JPEG 共通) の終了フック
`EB_HOOK_BEGIN_IN_COLOR_BMP`
`EB_HOOK_BEGIN_IN_COLOR_JPEG`
  インライン用 BMP, JPEG の開始フック
`EB_HOOK_END_IN_COLOR_GRAPHIC`
  非インライン用カラー図版 (BMP, JPEG 共通) の終了フック

非インライン用の終了フック `EB_HOOK_END_GRAPHIC` では、 フック関数に渡す引数の `argv[2]` と `argv[3]` が、 図版データのページ番号とオフセットになりますので、これを `eb_set_binary_color_graphic()` に渡してやります。 同様に、インライン用の終了フック `EB_HOOK_END_IN_GRAPHIC` では、`argv[2]` と `argv[3]` がページ番号と オフセットですので、これを渡します。

後は、実際にカラー図版のデータを取り出します。 これには、モノクロ図版と同様に `eb_read_binary()` を用います。 使い方はまったく一緒ですので、詳しくは 「モノクロ図版」 を参照してください。

ただし、電子ブックのカラー図版については、データの終了位置が来ても EB ライブラリは読み込みを止めないという制限事項があります。 これは、データの大きさに関する情報が記されていないためで、データの 終端位置は、アプリケーションが JPEG のデータをデコードして割り出すしか ありません。

### 参照先付きカラー図版

カラー図版には、画像内の特定の矩形領域に参照先の情報を付け加えたものが あります。 HTML におけるクリッカブル・イメージ (clickable image) とほぼ同じで、その 矩形領域内にマウスポインタがある間にマウスをクリックすると、あらかじめ 決められたリンク先に画面が遷移するという仕掛けです。 リンク先となる矩形領域は、画像一つに対して複数個登録できます。

>     　　　　　　　参照先付きカラー図版の例
>     ┌────────────────────────┐
>     │┌　─　─　─　─　┐　　┌　─　─　─　─　┐│
>     │　　　　　　　　　　　　　　　　　　　　　　　　│
>     ││　　矩形領域１　　│　　│　　矩形領域２　　││
>     │　　　　　　　　　　　　　　　　　　　　　　　　│
>     │└　─　─　─　─　┘　　└　─　─　─　─　┘│
>     │　　　　　　　　　　　　　　　　　　　　　　　　│
>     │┌　─　─　─　─　┐　　　　　　　　　　　　　│
>     │　　　　　　　　　　　　　　　　　　　　　　　　│
>     ││　　矩形領域３　　│　　　　　　図版　　　　　│
>     │　　　　　　　　　　　　　　　　　　　　　　　　│
>     │└　─　─　─　─　┘　　　　　　　　　　　　　│
>     └────────────────────────┘

参照先付きカラー図版の取り扱い方は、通常のカラー図版を拡張した形と なります。通常のカラー図版の場合では、たとえば JPEG の非インライン 画像では、次のような順番でフックが呼び出されます。

1. `EB_HOOK_BEGIN_COLOR_JPEG` (非インライン用 JPEG 開始)
2. `EB_HOOK_END_COLOR_GRAPHIC` (非インライン用 JPEG 終了)

これに対して参照先付きのカラー図版では、この2つのフックの間に、矩形領域 情報に関するフックが挿入されます。

1. `EB_HOOK_BEGIN_COLOR_JPEG` (非インライン用 JPEG 開始)
2. `EB_HOOK_BEGIN_CLICKABLE_AREA` (矩形領域1 開始)
3. `EB_HOOK_END_CLICKABLE_AREA` (矩形領域1 終了)
4. `EB_HOOK_BEGIN_CLICKABLE_AREA` (矩形領域2 開始)
5. `EB_HOOK_END_CLICKABLE_AREA` (矩形領域2 終了)
   以下、矩形領域3、矩形領域4 ... と矩形領域の個数分だけ続く。
6. `EB_HOOK_END_COLOR_GRAPHIC` (非インライン用 JPEG 終了)

矩形領域に関する具体的な情報は、`EB_HOOK_BEGIN_CLICKABLE_AREA` (開始フック) のほうで取得します。 フック関数に渡す引数の `argv[1]` と `argv[2]` が、 それぞれ矩形領域の開始 x, y 座標を表します。 カラー図版の左上の座標が (0, 0) です。 同様に、`argv[3]` と `argv[4]` が矩形領域の右方向 への幅と、下方向への高さを表します。 最後の `argv[5]` と `argv[6]` が参照先のページ番号 とオフセットとなります。

アプリケーションが参照先付きカラー図版に対応しない場合は、矩形領域の 開始情報と終了情報を無視することになります。 これにより、図版は通常の (参照先を持たない) カラー図版とまったく同じく 扱われます。

### WAVE (PCM) 音声

WAVE (PCM) 形式の音声データは EPWING にだけ存在します。 (代わりに電子ブックには CD-DA 形式の音声データがありますが、EB ライブラリ では対応していません。)

WAVE 形式の音声データを取り出すには、まずテキストデータ中から WAVE 音声 の参照情報を得ます。 参照開始と終了を表すエスケープシーケンスへのフック `EB_HOOK_BEGIN_WAVE` と `EB_HOOK_END_WAVE` が それぞれありますので、これを用います。

フック `EB_HOOK_BEGIN_WAVE` がフック関数に渡す引数のうち、 `argv[2]` と `argv[3]` が音声データの開始位置の ページ番号とオフセット、`argv[4]` と `argv[5]` が 終了位置のページ番号とオフセットとなります。

この開始位置と終了位置を関数 `eb_set_binary_wave()` に渡して、 その位置にある音声データをこれから取り出すことを EB ライブラリに伝えます。

>     /* eb_set_binary_wave() の関数プロトタイプ */
>     EB_Error_Code
>     eb_set_binary_wave(EB_Book *book, EB_Position *start_position,
>     EB_Position *end_position);

そして後は、実際に音声データを取り出します。 これには、他のバイナリデータと同様に `eb_read_binary()` を 用います。 `eb_read_binary()` の使い方は、 「モノクロ図版」 を参照のこと を参照してください。

### MPEG1 動画

MPEG1 形式の動画データは EPWING にだけ存在します。 動画データは EPWING の CD-ROM の movie というディレクトリの下に、 動画毎に一個のファイルにした形で収められています。

テキストデータ中に存在する、MPEG データの参照開始と終了を表す エスケープシーケンスへのフック `EB_HOOK_BEGIN_MPEG` と `EB_HOOK_END_MPEG` を使用することで、参照先の MPEG の ファイル名を取得できます。

具体的には、フック `EB_HOOK_BEGIN_MPEG` がフック関数に渡す 引数のうち、`argv[2]` 〜 `argv[5]` が合わせて一つ のファイル名を表すようになっています。

MPEG 動画のデータを得るには、このファイル名を `eb_set_binary_mpeg()` に渡して、そのファイルの動画データを これから取り出す旨を EB ライブラリに伝えます。 ファイル名は、次のようにして `argv + 2` (`&argv[2]` でも同じ) を渡します。

>     if (eb_set_binary_mpeg(&book, argv + 2) != EB_SUCCESS) {
>         fprintf(stderr, "an error occurs.\n");
>         return;
>     }

後は、実際に動画データを取り出します。 これには、やはり他のバイナリデータと同様に `eb_read_binary()` を用います。 `eb_read_binary()` の使い方については、 「モノクロ図版」 を参照のこと を参照してください。

### 関数の詳細

この節で説明している関数を使うには、次のようにヘッダファイルを読み込んで 下さい。

>     #include <eb/binary.h>

#### `EB_Error_Code eb_set_binary_mono_graphic (EB_Book *book, const EB_Position *position, int width, height)`

関数 `eb_set_binary_mono_graphic()` は、モノクロ図版のデータを これから取得しようとしていることを EB ライブラリに伝えます。 引数 position は図版の位置、width, height には図版の幅と高さを渡します。 これらの情報は、図版の参照元であるテキストデータに記載されており、通常は フック関数を通じて得るようにします。 ただし、電子ブックでは幅と高さの値の情報がテキストデータに記されていない ため、0 を渡すことになります。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、原因に応じたエラーコードを返します。

あらかじめ、図版を取り出そうとしている副本を選択しておかなければ なりません。 book が副本を選択していなければ、`EB_ERR_NO_CUR_SUB` を返します。 図版の位置、幅、高さの値が明らかにおかしいと EB ライブラリが判断した ときは、`EB_ERR_NO_SUCH_BINARY` を返します。

この関数は、実際に図版データを読み込むことはしません。 読み込みには、`eb_read_binary()` を用います。 モノクロ図版のデータは、1 ピクセルに 1bit を割り当てた BMP 形式になって います。

#### `EB_Error_Code eb_set_binary_color_graphic (EB_Book *book, const EB_Position *position)`

関数 `eb_set_binary_color_graphic()` は、EPWING のカラー図版の データをこれから取得しようとしていることを EB ライブラリに伝えます。 引数 position は図版の位置を渡します。 位置の情報は、図版の参照元であるテキストデータに記載されており、通常は フック関数を通じて得るようにします。

成功すると、関数は `EB_SUCCESS` を返します。

あらかじめ、図版を取り出そうとしている副本を選択しておかなければ なりません。 book が副本を選択していなければ、`EB_ERR_NO_CUR_SUB` を返します。 図版の位置が明らかにおかしいと EB ライブラリが判断したときは、 `EB_ERR_NO_SUCH_BINARY` を返します。

この関数は、実際に図版データを読み込むことはしません。 読み込みには、`eb_read_binary()` を用います。 カラー図版データは、JPEG か BMP (DIB) のいずかの形式になっています。

#### `EB_Error_Code eb_set_binary_wave (EB_Book *book, const EB_Position *start_position, EB_Position *end_position)`

関数 `eb_set_binary_wave()` は、WAVE (PCM) 形式の音声のデータ をこれから取得しようとしていることを EB ライブラリに伝えます。 引数 start_position と end_position には音声データ の開始位置を渡します。 位置の情報は、音声データの参照元であるテキストデータに記載されており、 通常はフック関数を通じて得るようにします。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、原因に応じたエラーコードを返します。

あらかじめ、音声データを取り出そうとしている副本を選択しておかなければ なりません。 book が副本を選択していなければ、`EB_ERR_NO_CUR_SUB` を 返します。 音声データの位置が明らかにおかしいと EB ライブラリが判断したときは、 `EB_ERR_NO_SUCH_BINARY` を返します。

この関数は、実際に音声データを読み込むことはしません。 読み込みには、`eb_read_binary()` を用います。

#### `EB_Error_Code eb_set_binary_mpeg (EB_Book *book, const unsigned int *argv)`

関数 `eb_set_binary_mpeg()` は、MPEG1 形式の動画のデータを これから取得しようとしていることを EB ライブラリに伝えます。 引数 argv には動画データのファイル名を渡します。 ただし、このファイル名は文字列ではなく、フック関数 `EB_HOOK_BEGIN_MPEG` に渡された引数 `argv[2]` 〜 `argv[5]` の部分を渡します。 つまり、フック関数の引数 `argv + 2` を、 `eb_set_binary_mpeg()` への引数 argv として 渡します。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、原因に応じたエラーコードを返します。

あらかじめ、動画データを取り出そうとしている副本を選択しておかなければ なりません。 book が副本を選択していなければ、`EB_ERR_NO_CUR_SUB` を返します。 存在しない動画ファイル名を EB ライブラリが判断したときは、 `EB_ERR_NO_SUCH_BINARY` を返します。

成功すると、関数は `EB_SUCCESS` を返します。

この関数は、実際に動画データを読み込むことはしません。 読み込みには、`eb_read_binary()` を用います。

#### `EB_Error_Code eb_read_binary (EB_Book *book, size_t binary_max_length, char *binary, ssize_t *binary_length)`

関数 `eb_read_binary()` は、バイナリデータを読み込みます。 読み込もうとしているバイナリデータは、事前に

- `eb_set_binary_mono_graphic()`
- `eb_set_binary_color_graphic()`
- `eb_set_binary_wave()`
- `eb_set_binary_mpeg()`

のいずれかの関数で、EB ライブラリに通知しておく必要があります。

読み込んだデータは引数 binary の指す先の領域に書き込まれます。 また、このとき書き込まれたバイト数は、binary_length の指す 先の領域にセットされます。 ただし、書き込まれるバイト数は、最長でも引数 binary_max_length に指定した値までとなります。

この関数は、特に読み込んだデータの終端にナル文字を付加するような事は しません。 読み込まれるデータもバイナリ形式なので、途中にナル文字が出現する事も あります。

この関数を一回呼び出しだだけで、バイナリデータ全体を一気に取得する 必要はありません。 繰り返し呼び出せば、前回の続きからデータが読み込まれます。

ただし、以下に挙げた関数を呼び出すと、バイナリデータの読み込みに関する 状態記録がリセットされますので、それ以上の読み込みはできなくなります。

- `eb_set_subbook()`
- `eb_unset_subbook()`
- `eb_load_all_subbooks()`
- `eb_bind()`
- `eb_finalize_book()`
- `eb_set_binary_mono_graphic()`
- `eb_set_binary_color_graphic()`
- `eb_set_binary_wave()`
- `eb_set_binary_mpeg()`

`eb_read_binary()` を繰り返し呼んだ場合、バイナリデータは その都度 binary の先頭から書き込まれ、*binary_length の値も、その回の `eb_read_binary()` の呼び出しで書き込まれた バイト数になります。

データの終端に来ると、それ以上この関数を呼んでも関数は binary には何も書き込まず、*binary_length に 0 を書き込み、 `EB_SUCCESS` を返します。

成功すると、この関数は `EB_SUCCESS` を返します。 失敗すると、binary_length が指す領域に -1 を書き込み、原因を 示すエラーコードを返します。 この場合、バイナリデータの読み込み状態の記録がリセットされますので、 データの続きを読み込むことはできなくなります。

あらかじめ、book はいずれかの副本を選択していなくては なりません。 選択していない場合は、`EB_ERR_NO_CUR_SUB` を返します。 また、冒頭に挙げた関数の呼び出しが成功していない状態でこの関数を呼ぶと、 `EB_ERR_NO_CUR_BINARY` を返します。

#### `EB_Error_Code eb_compose_movie_file_name (const unsigned int *argv, char *composed_file_name)`

関数 `eb_compose_movie_file_name()` は、動画データのファイル名 を通常の文字列に変換します。

EB ライブラリでは、動画データのファイル名はフック関数 `EB_HOOK_BEGIN_MPEG` に渡された 4 つの int 型引数 (`argv[2]` 〜 `argv[5]`) によって表現されます。

動画データを読み込む際は、これをそのまま `eb_set_binary_mpeg()` に渡せば良いのですが、ファイル名を通常の文字列で得たい場合は、この関数を 用います。 たとえば、個々の動画に一意の ID のようなものを振りたい場合は、ファイル 名を ID として使うと良いかも知れません。 なお、この関数で変換して得られるファイル名にはパスが含まれていません。

フック関数の引数 `argv + 2` をこの関数への引数 argv として渡すと、composed_file_name が指す先の領域に、文字列形式 に変換されたファイル名が格納されます。 ファイル名は最長で `EB_MAX_DIRECTORY_NAME_LENGTH` (= 8) バイト になります。 この長さには終端のナル文字の分を含んでいませんので、格納領域にはもう 1 バイト余裕が要ります。

なお、格納されたファイル名は、実際に存在するファイル名とは若干異なって いる可能性があります。 たとえば、英字の大文字と小文字、接尾子の有無などの違いがこれに当たります。 この関数は、あくまで文字列に機械的に変換するだけなので、ファイルが実在 するかどうかのチェックはしません。

成功すると、関数は `EB_SUCCESS` を返します。

#### `EB_Error_Code eb_compose_movie_path_name (EB_Book *book, const unsigned int *argv, char *composed_path_name)`

関数 `eb_compose_movie_path_name()` は、動画データのファイル名 を通常の文字列に変換します。 働きは、前述の関数 `eb_compose_movie_file_name()` に良く 似ていますが、`eb_compose_movie_path_name()` が返すファイル名 は、絶対パスの形式になっている点が異なります。

また、`eb_compose_movie_path_name()` では、ファイル名が実在 するかどうかのチェックを行うという点も、大きな違いです。 ファイル名を文字列に変換した上で、英字の大文字と小文字の違いや接尾子の 有無は、実在のファイルに合わせて調整したものを返します。 したがって、パスを除いた部分で比較しても、 `eb_compose_movie_file_name()` が返すファイル名とは必ずしも 一致しません。

引数 `book` は、動画ファイルを収録している副本を選択して おかなければなりません。 副本を選択していなければ、`EB_ERR_NO_CUR_SUB` を返します。

引数 `argv` の意味は、`eb_compose_movie_file_name()` と同じです。

ファイル名の変換が成功すると、関数は composed_path_name が 指す先の領域に、文字列形式に変換された動画ファイル名を格納し、 `EB_SUCCESS` を返します。 ファイル名は最長で `EB_MAX_PATH_LENGTH` バイトになります。 この長さには終端のナル文字の分を含んでいませんので、格納領域にはもう 1 バイト余裕が要ります。

ファイル名が実在しないと、`EB_ERR_BAD_FILE_NAME` を返します。

#### `EB_Error_Code eb_decompose_movie_file_name (unsigned int *argv, const char *composed_file_name)`

関数 `eb_compose_movie_file_name()` は、 `eb_compose_movie_file_name()` とちょうど逆の働きをします。 つまり、通常の文字列に変換された動画データのファイル名 composed_file_name を、4 つの int 型引数 argv に 戻します。 したがって、argv の指す領域は、少なくとも int 型の値を 4 つ 格納できる大きさが必要です。

成功すると、関数は `EB_SUCCESS` を返します。

## appendix データ

appendix (付録) とは CD-ROM 書籍の補助データの ことです。 appendix は CD-ROM 書籍の出版社から提供されているものではなく、 EB ライブラリに固有のものです。 `ebappendix` コマンドを用いて生成します (詳しくは ebappendix コマンドのマニュアル の「appendix (付録) とは」を参照のこと)。

appendix は以下のデータを CD-ROM 書籍に対して提供します。

- 本文の区切りコード
- 外字の代替文字列

appendix のレイアウトは CD-ROM 書籍のものとよく似ています。 トップディレクトリには `catalog` もしくは `catalogs` ファイルが存在し、各副本のデータは対応する サブディレクトリに配置されています。

アプリケーションは appendix に対応し、本文の区切りコードの情報を使える ようにすることをお薦めします。 外字の代替文字列については、外字のフォントをそのまま表示できるので あれば、対応する必要性はかなり乏しいですが、本文の区切りコードは、 扱えないと正しく本文を表示できない書籍に対応できません (区切りコードについては、「区切りコードの問題」 を参照のこと)。

### `EB_Appendix` オブジェクト

CD-ROM 書籍本体を扱うには `EB_Book` オブジェクトを 用いましたが、appendix を扱うには `EB_Appendix` オブジェクト を使います。 `EB_Appendix` オブジェクトを操作するための関数は、 `EB_Book` のものとは異なりますが、操作手順はよく似ています。

`EB_Appendix` オブジェクトは、個々の appendix に対して 1 個 ずつ作る必要があります。

>     EB_Appendix app;

もちろん、オブジェクトの領域は、`malloc()` で確保しても 構いません。

>     EB_Appendix *app_pointer;

>     app_pointer = (EB_Appendix *) malloc(sizeof(EB_Appendix));

オブジェクトは、使う前に必ず `eb_initialize_appendix()` という関数で中身を初期化しなくてはなりません。 `EB_Book` オブジェクトでも `eb_initialize_book()` で初期化する必要がありましたが、それと同じです。

>     eb_initialize_appendix(&app);
>     eb_initialize_appendix(app_pointer);

続いて、オブジェクトを appendix の実体に結び付けるために、 `eb_bind_appendix()` を呼び出します。 これは、`EB_Book` オブジェクトの `eb_bind()` に 相当します。

>     ＥＢ＿Ａｐｐｅｎｄｉｘ　　　　　　　　　　ａｐｐｅｎｄｉｘ
>     オブジェクト　　　　　　　　　　　　┌────────────┐
>     ┌───┐　　　　　　　　　　　　　│　　　　　　　　　　　　│
>     │　　　┝━━━━━━━━━━━━━┥　／ｍｎｔ／ｄｉｃｔ　　│
>     └───┘　ｅｂ＿ｂｉｎｄ　　　　　│　　　　　　　　　　　　│
>     　　　　　　＿ａｐｐｅｎｄｉｘ（）　└────────────┘

実際のプログラムでは、次のようにします。

>     if (eb_bind_appendix(&app, "/mnt/dict") != EB_SUCCESS) {
>         printf("eb_bind_appendix() failed\n");
>         return;
>     }

`eb_bind_appendix()` に渡す appendix のパス (この例では `/mnt/dict`) は appendix のトップディレクトリ、 つまり `catalog` または `catalogs` ファイルのある ディレクトリを指定します。 パスには、遠隔アクセス識別子 (例: `ebnet://localhost/dict.app`) を指定することも可能です。

`EB_Appendix` オブジェクトを使い終わったら、 `eb_finalize_appendix()` を呼んで後始末をします。 オブジェクトは appendix との結び付きを解かれた状態に戻り、 内部で割り当てられたメモリは解放され、開いていたファイルもすべて 閉じられます。

>     eb_finalize_appendix(&app);
>     eb_finalize_appendix(app_pointer);

オブジェクトの領域を `malloc()` で確保した場合は、 `eb_finalize_appendix()` を呼んだ後ならば、オブジェクトの 領域を安全に解放することができます。

>     free(app_pointer);

### 副本

CD-ROM と同様に、appendix にも副本が存在します。 appendix の副本も、副本コードを使って識別します。 個々の副本コードは、appendix 内で同じものがないようになっています。

CD-ROM 書籍内のすべての副本の副本コードを取得する関数として `eb_subbook_list()` がありましたが、appendix にも `eb_appendix_subbook_list()` という同様の関数があります。

>     /* app が EB_Appendix のオブジェクトで、
>      * すでに書籍に結び付けられていると仮定しています。*/
>     EB_Subbook_Code sub_codes[EB_MAX_SUBBOOKS];
>     int sub_count;

>     if (eb_appendix_subbook_list(&app, sub_codes, &sub_count)
>         != EB_SUCCESS) {
>         printf("eb_appendix_subbook_list() failed\n");
>         return;
>     }

`eb_appendix_subbook_list()` が成功すると、書籍内のすべての 副本コードが 配列 `sub_codes[]` に格納されます。 配列の先頭の副本コードは `sub_codes[0]` と表され、次の コードは `sub_codes[1]`、という具合になります。 副本の個数は、`sub_count` に格納されます。

`EB_Book` と同様に `EB_Appendix` オブジェクト でも、結びつけられた CD-ROM 書籍の中の任意の副本から一つ選んで、 選択中の副本 (current subbook) として指定することができます。 複数の副本を、同時に選択することはできません。 区切りコードや外字の代替文字列といった appendix 内のデータへのアクセス は、選択中の副本に対してだけ行えます。

以下は、先頭の副本 (`sub_codes[0]`) を選択する場合の例です。

>     /* app が EB_Appendix のオブジェクトで、
>      * すでに書籍に結び付けられていると仮定しています。*/
>     if (eb_set_appendix_subbook(&app, sub_codes[0]) != EB_SUCCESS) {
>         printf("eb_subbook_list() failed\n");
>         return;
>     }

`eb_bind_appendix()` で `EB_Appendix` オブジェクト を appendix に結び付けた直後は、いずれの副本も選択されていない状態に なっています。

### 本文の区切りコード

CD-ROM 書籍によっては、EB ライブラリが本文の表示を正しい位置で 止められないことがあります (詳しくは、「区切りコードの問題」 を参照のこと)。 これは、本文の区切りコードの推測を EB ライブラリが誤ったために起こる のですが、appendix データを使うことで、正しい区切りコードを EB ライブラリ に教えてやることができます。

CD-ROM 書籍の本文を取得する関数 `eb_read_text()` は 第 2 引数に `EB_Appendix *` をとるのですが、ここに appendix オブジェクトを渡してやるようにします。

>     /* book, app は、それぞれ EB_Book
>      * および EB_Appendix のオブジェクトで、どちらもすでに
>      * 副本を選択中と仮定しています。*/
>     #define MAX_LENGTH 1000
>     char buffer[MAX_LENGTH + 1];
>     ssize_t text_length;

>     if (eb_read_text(&book, &app, NULL, NULL, MAX_LENGTH,
>         text, &text_length) != EB_SUCCESS) {
>         fprintf(stderr, "an error occurs.\n");
>         return;
>     }

`eb_read_text()` は、渡された appendix オブジェクトが副本を 選択済みで、かつ区切りコードの情報を持っていれば、その区切りコードを 使用します。

### 外字の代替文字列

CD-ROM 書籍は、定義している外字の情報としてフォントのデータしか用意して いません。 つまり、その外字がどのような文字なのかをユーザに分かるようにするには、 アプリケーションがフォントを表示するしかありません。 しかしこれでは、テキストインターフェースを用いたアプリケーションでは、 本文中の外字の部分がまったく分かりません。 外字を多用している書籍では、本文が解読不能に近い状態になるかも知れません。

そこで EB ライブラリでは、外字の代替となる文字列を appendix 内で定義 できるようにしています。 appendix が用意されている場合に限り、アプリケーションは外字のフォント を描画する代わりにその代替文字列を出力することにすれば、 テキストインターフェースを用いたアプリケーションでも書籍が読み易く なります。

appendix に定義されている代替文字列を取り出す関数は、2 つあります。 半角外字用の `eb_narrow_alt_character_text()` と全角外字用の `eb_wide_alt_character_text()` です。 どちらも、使い方は変わりません。

以下の例では、半角外字の文字番号 0xa121 に対する代替文字列を `buffer` に格納しています。

>     /* app が EB_Appendix のオブジェクトで、
>      * すでに副本を選択中であると仮定しています。*/
>     char buffer[EB_MAX_ALTERNATION_TEXT_LENGTH + 1];

>     if (eb_narrow_alt_character_text(&app, buffer, 0xa121)
>         != EB_SUCCESS) {
>         printf("eb_narrow_alt_character_text() failed\n");
>         return;
>     }

外字は個々の副本に対して定義されているので、代替文字列を取り出すには、 あらかじめ副本を選択しておく必要があります。 外字のフォントを取り出す際は、これに加えて外字の「高さ」も選択しておく 必要がありましたが、代替文字列には高さの概念がないので必要ありません。

代替文字列は最長で `EB_MAX_ALTERNATION_TEXT_LENGTH` バイト (= 31 バイト) です。 ただし、この長さにはナル文字の分は含んでいないので、`buffer` はもう 1 バイト分余裕を持たせています。

### データ型の詳細

この節で説明しているデータ型を使うには、次のようにヘッダファイルを 読み込んで下さい。

>     #include <eb/appendix.h>

#### `EB_Appendix` 型

`EB_Appendix` 型は、一冊の CD-ROM 書籍を表します。 CD-ROM 書籍へのアクセスは、すべてこの型のオブジェクトを介して行います。 同時に複数の CD-ROM 書籍にアクセスする際は、書籍一冊毎にオブジェクトを 作る必要があります。

`EB_Appendix` オブジェクトの操作は、すべて EB ライブラリが 用意している関数で行います。 アプリケーションプログラムは、直接 `EB_Appendix` オブジェクト のメンバを参照したり、セットしたりすべきではありません。

`EB_Appendix` オブジェクトを使用する際は、まずそのオブジェクト に対して `eb_initialize_book()` を呼んで初期化しなくては なりません。

### 関数の詳細

この節で説明している関数を使うには、次のようにヘッダファイルを読み込んで 下さい。

>     #include <eb/appendix.h>

#### `void eb_initialize_appendix (EB_Appendix *app)`

関数 `eb_initialize_appendix()` は、app の指す `EB_Appendix` オブジェクトを初期化します。 `EB_Appendix` オブジェクトに対して EB ライブラリの他の関数を 呼ぶ前に、必ずそのオブジェクトを初期化しなくてはなりません。 初期化していないオブジェクトに対して、EB ライブラリの他の関数を呼んだ 場合の動作は未定義です。 また、すでに初期化したオブジェクトに対して、 再度 `eb_initialize_appendix()` を呼んではいけません。 呼んだ場合の動作は未定義です。

#### `void eb_finalize_appendix (EB_Appendix *app)`

関数 `eb_finalize_appendix()` は、app が指す `EB_Appendix` オブジェクトの後始末を行います。

オブジェクトが割り当てて管理していたメモリはすべて解放され、 ファイルディスクリプタもすべて閉じられます。 オブジェクトが appendix と結び付いていた場合は、結び付きが解かれます。

後始末をしたオブジェクトに対して `eb_bind_appendix()` を呼ぶことで、 オブジェクトを再利用することができます。

#### `EB_Error_Code eb_bind_appendix (EB_Appendix *app, const char *path)`

関数 `eb_bind_appendix()` は、app の指す `EB_Appendix` オブジェクトを、パス path にある appendix に結び付けます。 パスには、appendix のトップディレクトリか遠隔アクセス識別子を指定します。 appendix のトップディレクトリとは、`catalog` あるいは `catalogs` ファイルの存在するディレクトリを指します。

オブジェクトがすでにappendix に結び付いていた場合、その appendix との 結び付きを解いてから、path にある appendix に結び付けます。

成功すると、関数は `EB_SUCCESS` を返します。 このとき、副本は未選択の状態になります。 失敗すると、オブジェクトを appendix との結び付きを解かれた状態にして、 原因を示すエラーコードを返します。

path は、`EB_MAX_PATH_LENGTH` バイトに収まて いなくてはなりません。 さらに、path が相対パスのときは、絶対パスに変換した結果が この長さに収まっていなくてはなりません。 これを超えると、`EB_ERR_TOO_LONG_FILE_NAME` を返します。

#### `int eb_is_appendix_bound (EB_Appendix *app)`

関数 `eb_is_appendix_bound()` は、app が appendix に 結び付いているかどうかを調べます。 結び付いていれば 1 を返し、そうでなければ 0 を返します。

#### `EB_Error_Code eb_appendix_path (EB_Appendix *app, char *path)`

関数 `eb_appendix_path()` は、app に結び付いている appendix のパスもしくは遠隔アクセス識別子を、path の指す領域 に書き込みます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、path の指す領域に空文字列を書き込み、原因を示す エラーコードを返します。

app は、あらかじめ書籍に結び付いている必要があります。 結びついていない場合は、`EB_ERR_UNBOUND_BOOK` を返します。

path に書き込むパス名のバイト数は、最長で `EB_MAX_PATH_LENGTH` になります。 この長さは、末尾のナル文字を含みません。 関数が返すパスは正規化された形になっているので、 `eb_bind_appendix()` に渡したときのものと同じとは限りません。 たとえば、相対パスだった場合は、絶対パスに変換されます。

#### `EB_Error_Code eb_load_all_appendix_subbooks (EB_Appendix *app)`

関数 `eb_load_all_appendix_subbooks()` は、app 内 のすべての副本を初期化します。 通常、副本の初期化は、その副本が初めて選択されたときに自動的に 行われますが、この関数は初期化を前倒しで行います。 初期化の対象となるのは、この関数を呼び出した時点でまだ初期化していない すべての副本です。 この関数は、スタンドアロンで動作するサーバアプリケーションなどで有効です。 クライアントからの接続を受ける前にこの関数を呼ぶことで、副本の初期化の ためにクライアントを待たせなくて済みます。

初期化の対象となったすべての副本の初期化に成功すれば、関数は `EB_SUCCESS` を返します。 一冊でも初期化に失敗した場合は、残りの副本の初期化を諦め、原因を示す エラーコードを返します。

app は、あらかじめ appendix に結び付けられていなくては なりません。 結びついていない場合は、`EB_ERR_UNBOUND_APP` を返します。

この関数を呼び出すと、app は、副本を選択していない状態に なります。

#### `EB_Error_Code eb_appendix_subbook_list (EB_Book *app, EB_Subbook_Code *subbook_list, int *subbook_count)`

関数 `eb_appendix_subbook_list()` は、app 内の すべて副本の副本コードを `EB_Subbook_Code` 型の配列にして、 subbook_list の指す領域に書き込みます。 配列は、最大で `EB_MAX_SUBBOOKS` 個の要素を持ちます。 加えて、appendix が収録している副本の個数を subbook_count の 指す領域に書き込みます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、subbook_count の指す領域に 0 を書き込み、原因を 示すエラーコードを返します。

app は、あらかじめ appendix に結び付けられていなくては なりません。 結びついていない場合は、`EB_ERR_UNBOUND_APP` を返します。

#### `EB_Error_Code eb_appendix_subbook (EB_Book *app, EB_Subbook_Code *subbook_code)`

関数 `eb_appendix_subbook()` は、app が選択中の 副本の副本コードを subbook_code の指す領域に書き込みます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、subbook_code の指す領域に `EB_SUBBOOK_INVALID` を書き込み、原因を示すエラーコードを 返します。

あらかじめ、app はいずれかの副本を選択していなくては なりません。 選択していない場合は、`EB_ERR_NO_CUR_APPSUB` を返します。

#### `EB_Error_Code eb_appendix_subbook_directory (EB_Book *app, char *directory)`

関数 `eb_appendix_subbook_directory()` は、app 内 で現在選択中の副本のデータファイルを収めたディレクトリ名を、 directory の指す領域に書き込みます。

ディレクトリ名の文字列の長さは、最長で `EB_MAX_DIRECTORY_NAME_LENGTH` バイトです。 この長さに、末尾のナル文字は含みません。 ディレクトリ名は ASCII の数字、英小文字、アンダースコアで構成されます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、directory の指す領域に空文字列を書き込み、原因に を示すエラーコードを返します。

あらかじめ、app 内のいずれかの副本が選択されていなくては なりません。 選択していない場合は、`EB_ERR_NO_CUR_APPSUB` を返します。

#### `EB_Error_Code eb_appendix_subbook_directory2 (EB_Book *app, EB_Subbook_Code subbook_code, char *directory)`

`eb_appendix_subbook_directory()` と似ていますが、選択中の 副本ではなく、引数 subbook_code で指定された副本の ディレクトリ名を書き込む点が異なります。

app は副本を選択していなくても構いませんが、あらかじめ appendix に結び付けられていなければなりません。 結びついていない場合は、`EB_ERR_UNBOUND_APP` を返します。

#### `EB_Error_Code eb_set_appendix_subbook (EB_Book *app, EB_Subbook_Code code)`

関数 `eb_set_appendix_subbook()` は、app の副本 code を選択します。 すでに副本を選択していた場合は、いったん未選択の状態にしてから副本 subbook_code を選択します。

成功すると、関数は `EB_SUCCESS` を返します。 このとき、外字は未選択の状態となり、検索、テキストデータの読み込み、 バイナリデータの読み込みについての状態記録は、すべてリセットされます。 失敗すると、副本を未選択の状態にして、原因を示すエラーコードを返します。

あらかじめ、app は appendix に結び付けられていなければ なりません。 結びついていない場合は、`EB_ERR_UNBOUND_APP` を返します。

#### `void eb_unset_appendix_subbook (EB_Book *app)`

関数 `eb_unset_appendix_subbook()` は、app が選択 している副本を未選択の状態にします。 app が appendix に結び付いていないか、副本が選択されていない 場合は、何もしません。

#### `int eb_have_stop_code (EB_Book *app)`

関数 `eb_have_stop_code()` は、app が選択中の副本で 区切りコードが定義されているかどうかを調べます。

定義していれば 1 を返します。 定義していないか、そもそも副本が選択されていない場合は 0 を返します。

#### `EB_Error_Code eb_stop_code (EB_Book *app, int *stop_code)`

関数 `eb_stop_code()` は、app が選択中の副本で定義 している区切りコードを stop_code の指す領域に書き込みます。 stop_code[0], stop_code[1] に、区切りコードの値 としてそれぞれ `0x0000` 〜 `0xffff` が書き込まれます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、関数は stop_code[0] と stop_code[1] に `-1` を書き込み、原因を示すエラーコードを返します。

あらかじめ、app は副本を選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_APPSUB` を返します。 副本が区切りコードを定義していない場合は、`EB_ERR_NO_STOPCODE` を返します。

#### `int eb_have_narrow_alt (EB_Book *app)`

#### `int eb_have_wide_alt (EB_Book *app)`

関数 `eb_have_narrow_alt()` は、選択中の副本が半角外字に対する 代替文字列を定義しているかどうかを調べます。 同様に、関数 `eb_have_wide_alt()` は、全角外字に対する 代替文字列を定義しているかどうかを調べます。

定義していれば 1 を、定義していなければ 0 を返します。 app が副本を選択していない場合も 0 を返します。

#### `EB_Error_Code eb_narrow_alt_start (EB_Book *app, int *start)`

#### `EB_Error_Code eb_wide_alt_start (EB_Book *app, int *start)`

関数 `eb_narrow_alt_start()` は、app が選択中の副本 における半角外字に対する代替文字列の定義範囲を調べ、先頭の文字番号 (半角外字の文字番号の中で最小のもの) を start の指す領域に 書き込みます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、原因を示すエラーコードを返します。

あらかじめ、app は副本を選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_APPSUB` を返します。 副本が半角外字に対する代替文字列を定義していない場合は、 `EB_ERR_NO_ALT` を返します。

関数 `eb_wide_font_start()` は、半角外字ではなく全角外字に ついて調べるという点を除いて、`eb_narrow_font_start()` と同じ です。

#### `EB_Error_Code eb_narrow_alt_end (EB_Book *app, int *end)`

#### `EB_Error_Code eb_wide_alt_end (EB_Book *app, int *end)`

関数 `eb_narrow_alt_end()` は、app が選択中の副本 における半角外字に対する代替文字列の定義範囲を調べ、最後の文字番号 (半角外字の文字番号の中で最大のもの) を start の指す領域に 書き込みます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、原因を示すエラーコードを返します。

あらかじめ、app は副本を選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_APPSUB` を返します。 副本が半角外字に対する代替文字列を定義していない場合は、 `EB_ERR_NO_ALT` を返します。

関数 `eb_wide_font_start()` は、半角外字ではなく全角外字に ついて調べるという点を除いて、`eb_narrow_font_start()` と同じ です。

#### `EB_Error_Code eb_narrow_alt_character_text (EB_Book *app, int `character_number`, char *text)`

#### `EB_Error_Code eb_wide_alt_character_text (EB_Book *app, int `character_number`, char *text)`

関数 `eb_narrow_alt_character_text()` は、book が 選択中の副本で定義している、半角外字の代替文字列を取り出します。 外字の文字番号を、character_number で指定します。

成功すると、関数は代替文字列を text の指す領域に書き込み、 `EB_SUCCESS` を返します。 失敗すると、text の指す領域に空文字列を書き込み、原因を示す エラーコードを返します。

代替文字列は最長で `EB_MAX_ALTERNATION_TEXT_LENGTH` バイト (= 31 バイト) です。 ただし、この長さにはナル文字の分は含んでいないので、text の 領域にはもう 1 バイト分必要です。

代替文字列がどの文字コードで書かれているかは、appendix の中には 記録されていません。 しかし、appendix は必ず特定の書籍に対応して作成されるものなので、書籍の 文字コードから次のように判断すれば、問題ないでしょう。

- 書籍が ISO 8859-1 で書かれている場合は、代替文字列も ISO 8859-1
- それ以外の場合、代替文字列は日本語 EUC

あらかじめ、app は副本を選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_APPSUB` を返します。 文字番号 character_number が外字の定義範囲外にある場合は、 `EB_ERR_NO_SUCH_CHAR_TEXT` を返します。

副本が半角外字に対する代替文字列を (character_number に限らず まったく) 定義していない場合は、`EB_ERR_NO_ALT` を返します。 そうではなく、一部の文字番号については半角外字に対する代替文字列を 定義しているものの、character_number に対する代替文字列は 存在しない場合、関数は `EB_SUCCESS` を返し、text の指す領域には空文字列が書き込まれます。

関数 `eb_wide_alt_character_text()` は、半角外字ではなく 全角外字に対する代替文字列を取り出すという点を除いて、 `eb_narrow_alt_character_text()` と同じです。

#### `EB_Error_Code eb_backward_narrow_alt_character (EB_Book *book, int n, int *character_number)`

#### `EB_Error_Code eb_backward_wide_alt_character (EB_Book *book, int n, int *character_number)`

関数 `eb_forward_narrow_alt_character()` は、app が選択中の副本において定義されている、半角外字に対する代替文字列の 文字番号 character_number の n 個後ろに位置する 文字の文字番号を取得します。

まず、関数を呼び出す際に、character_number の指す領域に 文字番号を書き込んでおきます。 関数の処理が成功すると、戻ったときに n 個分だけ後方の文字番号 に書き換わっています。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、原因を示すエラーコードを返します。

あらかじめ、app は副本を選択していなくてはなりません。 選択していない場合は、`EB_ERR_NO_CUR_APPSUB` を返します。 副本が半角外字に対する代替文字列を定義していない場合は、 `EB_ERR_NO_ALT` を返します。

n 個後ろにもう外字がない場合や、呼び出した際に character_number の指す領域に書き込んであった文字番号が外字の 定義範囲外にある場合は `EB_ERR_NO_SUCH_CHAR_TEXT` を返します。

n には負の数を指定することもできます。 この場合、次の呼び出しと等価になります。

>     /* n < 0 とする */
>     eb_backward_narrow_font_character (book, -n, character_number);

関数 `eb_forward_wide_alt_character()` は、半角外字ではなく 全角外字について操作するという点を除いて、 `eb_forward_narrow_alt_character()` と同じです。

### サンプルプログラム

>     /*                                                            -*- C -*-
>      * Copyright (c) 2003-2006  Motoyuki Kasahara
>      *
>      * Redistribution and use in source and binary forms, with or without
>      * modification, are permitted provided that the following conditions
>      * are met:
>      * 1. Redistributions of source code must retain the above copyright
>      *    notice, this list of conditions and the following disclaimer.
>      * 2. Redistributions in binary form must reproduce the above copyright
>      *    notice, this list of conditions and the following disclaimer in the
>      *    documentation and/or other materials provided with the distribution.
>      * 3. Neither the name of the project nor the names of its contributors
>      *    may be used to endorse or promote products derived from this software
>      *    without specific prior written permission.
>      *
>      * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
>      * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>      * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
>      * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
>      * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
>      * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
>      * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
>      * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
>      * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
>      * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
>      * SUCH DAMAGE.
>      */

>     /*
>      * 使用方法:
>      *     font <appendix-path> <subbook-index>
>      * 例:
>      *     font /cdrom 0
>      * 説明:
>      *     <appendix-path> で指定した appendix から特定の副本を選び、そ
>      *     の副本が定義している半角外字の代替文字列をすべて表示します。
>      *
>      *     その appendix が、半角外字の代替文字列を定義していないと、エ
>      *     ラーになります。
>      *
>      *     <subbook-index> には、操作対象の副本のインデックスを指定しま
>      *     す。インデックスは、書籍の最初の副本から順に 0、1、2 ... に
>      *     なります。
>      */
>     #include <stdio.h>
>     #include <stdlib.h>

>     #include <eb/eb.h>
>     #include <eb/error.h>
>     #include <eb/appendix.h>

>     int
>     main(int argc, char *argv[])
>     {
>         EB_Error_Code error_code;
>         EB_Appendix app;
>         EB_Subbook_Code subbook_list[EB_MAX_SUBBOOKS];
>         int subbook_count;
>         int subbook_index;
>         int alt_start;
>         char text[EB_MAX_ALTERNATION_TEXT_LENGTH + 1];
>         int i;

>         /* コマンド行引数をチェック。*/
>         if (argc != 3) {
>             fprintf(stderr, "Usage: %s appendix-path subbook-index\n",
>                 argv[0]);
>             exit(1);
>         }

>         /* EB ライブラリと `app' を初期化。*/
>         eb_initialize_library();
>         eb_initialize_appendix(&app);

>         /* appendix を `app' に結び付ける。*/
>         error_code = eb_bind_appendix(&app, argv[1]);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to bind the app, %s: %s\n",
>                 argv[0], eb_error_message(error_code), argv[1]);
>             goto die;
>         }

>         /* 副本の一覧を取得。*/
>         error_code = eb_appendix_subbook_list(&app, subbook_list,
>             &subbook_count);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to get the subbook list, %s\n",
>                 argv[0], eb_error_message(error_code));
>             goto die;
>         }

>         /* 副本のインデックスを取得。*/
>         subbook_index = atoi(argv[2]);

>         /*「現在の副本 (current subbook)」を設定。*/
>         if (eb_set_appendix_subbook(&app, subbook_list[subbook_index])
>             < 0) {
>             fprintf(stderr, "%s: failed to set the current subbook, %s\n",
>                 argv[0], eb_error_message(error_code));
>             goto die;
>         }

>         /* 外字の開始位置を取得。*/
>         error_code = eb_narrow_alt_start(&app, &alt_start);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to get font information, %s\n",
>                 argv[0], eb_error_message(error_code));
>             goto die;
>         }

>         i = alt_start;
>         for (;;) {
>             /* 外字の代替文字列を取得。*/
>             error_code = eb_narrow_alt_character_text(&app, i, text);
>             if (error_code != EB_SUCCESS) {
>                 fprintf(stderr, "%s: failed to get font data, %s\n",
>                     argv[0], eb_error_message(error_code));
>                 goto die;
>             }

>             /* 取得した代替文字列を出力。*/
>             printf("%04x: %s\n", i, text);

>             /* 外字の文字番号を一つ進める。*/
>             error_code = eb_forward_narrow_alt_character(&app, 1, &i);
>             if (error_code != EB_SUCCESS)
>                 break;
>         }

>         /* appendix と EB ライブラリの利用を終了。*/
>         eb_finalize_appendix(&app);
>         eb_finalize_library();
>         exit(0);

>         /* エラー発生で終了するときの処理。*/
>       die:
>         eb_finalize_appendix(&app);
>         eb_finalize_library();
>         exit(1);
>     }

## サーバ上の書籍一覧

EBNET サーバから遠隔アクセスを行う際、サーバがそのクライアントに対して アクセスを許可している書籍や appendix データの一覧を取得することが できます。

このとき、EBNET サーバを指定する遠隔アクセス記述子には、特定の書籍や appendix データに対するアクセスとは異なり、書籍名は指定しません。 すなわち、一般形は次のようになります。

>     ebnet://ホスト:ポート/

末尾の `/' はなくても構いません。 `:` とそれに続くポート番号は省略可能で、その場合は 22010 番ポートを利用することを意味します。

ebinfo コマンドの --book-list オプション指定時の挙動は、EB ライブラリ のこの機能によって実装されています。 (ebinfo についての詳細は、 @pxref{Book list on EBNET server, , EBNET サーバの書籍一覧, ebinfo-ja, ebinfo-ja}。)

>     % ebinfo --book-list ebnet://localhost
>     名前             題名
>     encycl           ブラウンコンサイス百科事典
>     encycl.app       ブラウンコンサイス百科事典 (appendix)
>     crossword        クロスワードパズル辞典
>     travel           ワールドトラベルガイド

名前の末尾が `.app` になっているものは appendix データで、 その他は書籍本体です。 この例の書籍 `encycl` に対してアクセスするなら、 遠隔アクセス識別子は `ebnet://localhost/encycl` になります。

なお、クライアントに対してアクセスを許可していない書籍や appendix データ は、サーが側で一覧から除外されます。

### `EB_BookList` オブジェクト

EBNET サーバの提供する書籍および appendix データの一覧を取得するには、 まず `EB_BookList` 型のオブジェクトを用意する必要があります。

>     EB_BookList bl;

オブジェクトの領域は、`malloc()` で確保しても構いません。

>     EB_BookList *bl_pointer;

>     bl_pointer = (EB_BookList *) malloc(sizeof(EB_BookList));

`EB_Book` オブジェクトと同様に、`EB_BookList` オブジェクトも使う前に中身を初期化する必要があります。 これは、`eb_initialize_booklist()` という関数で行います。

>     eb_initialize_booklist(&bl);
>     eb_initialize_booklist(bl_pointer);

初期化が完了したら、特定のサーバとオブジェクトを結びつけます。 たとえば、`ebnet://localhost` で表されるサーバに対して、 オブジェクトを結びつけるには次のようにします。

>     if (eb_bind_booklist(&bl, "ebnet://localhost") != EB_SUCCESS) {
>         printf("eb_bind_booklist() failed\n");
>         return;
>     }

これはちょうど、`EB_Book` オブジェクトに対して `eb_bind()` を呼ぶのと同じです。

こうして、ようやく書籍一覧の情報を取り出すことができます。 これには `eb_booklist_book_count()`, `eb_booklist_book_name()`, `eb_booklist_book_title()` という 3 つの関数を使用します。 これらの関数はそれぞれ、クライアントがアクセス可能な書籍の数、各書籍 および appendix データの名称 (アクセス識別子として指定する名前)、各書籍 と appendix データの題名を得ることができます。

>     char *name, *title;
>     int count, i;

>     count = eb_booklist_book_count(&bl);
>     for (i = 0; i < count; i++) {
>         if (eb_booklist_book_name(&bl, i, &name) != EB_SUCCESS) {
>             printf("eb_booklist_book_name(%d) failed\n", i);
>             return;
>         }
>         if (eb_booklist_book_title(&bl, i, &title) != EB_SUCCESS) {
>             printf("eb_booklist_book_title(%d) failed\n", i);
>             return;
>         }
>         printf("name = %s, title = %s\n", name, title);
>     }

`EB_BookList` オブジェクトを使い終わったら、必ず後始末を 行います。

>     eb_finalize_booklist(&bl);
>     eb_finalize_booklist(bl_pointer);

オブジェクトの領域を `malloc()` で確保した場合は、 `eb_finalize_booklist()` を呼んだ後ならば、オブジェクトの領域 を安全に解放することができます。

>     free(bl_pointer);

### データ型の詳細

この節で説明しているデータ型を使うには、次のようにヘッダファイルを 読み込んで下さい。

>     #include <eb/booklist.h>

#### `EB_BookList` 型

`EB_BookList` 型は、EBNET サーバ上が使っている書籍および appendix の一覧を取得する際に用いるオクジェクトの型です。

`EB_BookList` オブジェクトを使用する際は、まずそのオブジェクト に対して `eb_initialize_booklist()` を呼んで初期化する必要が あります。

### 関数の詳細

この節で説明している関数を使うには、次のようにヘッダファイルを読み込んで 下さい。

>     #include <eb/booklist.h>

#### `void eb_initialize_booklist (EB_BookList *bl)`

関数 `eb_initialize_booklist()` は、bl の指す `EB_BookList` オブジェクトを初期化します。 `EB_BookList` オブジェクトに対して EB ライブラリの他の関数を 呼ぶ前に、必ずそのオブジェクトを初期化しなくてはなりません。 初期化していないオブジェクトに対して、EB ライブラリの他の関数を呼んだ 場合の動作は未定義です。 また、すでに初期化したオブジェクトに対して、 再度 `eb_initialize_booklist()` を呼んではいけません。 呼んだ場合の動作は未定義です。

#### `EB_Error_Code eb_bind_booklist (EB_BookList *bl, const char *path)`

関数 `eb_bind_booklist()` は、app の指す `EB_BookList` オブジェクトを、遠隔アクセス記述子 path で指定された EBNET サーバに結び付けます。

オブジェクトがすでにサーバに結び付いていた場合、そのサーバとの結び付き を解いてから、path にあるサーバに結び付けます。

成功すると、関数は `EB_SUCCESS` を返します。 失敗すると、オブジェクトをサーバとの結び付きを解かれた状態にして、原因 を示すエラーコードを返します。

path は、`EB_MAX_PATH_LENGTH` バイトに収まて いなくてはなりません。 これを超えると、`EB_ERR_TOO_LONG_FILE_NAME` を返します。 また、書籍名を指定していない遠隔アクセス記述子でなければなりません。 それ以外の形式だと、`EB_ERR_BAD_FILE_NAME` を返します。

使用している EB ライブラリのバイナリが、遠隔アクセスに非対応のもので ある場合、`EB_ERR_EBNET_UNSUPPORTED` が返ります。

#### `void eb_finalize_booklist (EB_BookList *bl)`

関数 `eb_finalize_booklist()` は、bl が指す `EB_BookList` オブジェクトの後始末を行います。

オブジェクトが割り当てて管理していたメモリはすべて解放され、 ファイルディスクリプタもすべて閉じられます。 オブジェクトが EBNET サーバと結び付いていた場合は、結び付きが解かれます。

後始末をしたオブジェクトに対して `eb_bind_booklist()` を呼ぶ ことで、オブジェクトを再利用することができます。

#### `int eb_booklist_book_count (EB_BookList *bl)`

関数 `eb_booklist_book_count()` は、EBNET サーバがこの クライアントに対してアクセスを許可している書籍および appendix データの数 を取得します。

オブジェクト bl の指す `EB_BookList` オブジェクトは、 あらかじめ EBNET サーバに結びついている必要があります。 結びついていない場合は、`EB_ERR_UNBOUND_BOOKLIST` を返します。

#### `EB_Error_Code eb_booklist_book_name (EB_BookList *bl, int i, char **name)`

#### `EB_Error_Code eb_booklist_book_title (EB_BookList *bl, int i, char **title)`

関数 `eb_booklist_book_name()` は、EBNET サーバの書籍や appendix データの名称を取得します。 ここで言う「名称」とは、遠隔アクセス識別子で指定する書籍名のことです。 つまり、`ebnet://localhost/dict` の `dict` の部分 を指します。 同様に、関数 `eb_booklist_book_title()` は、書籍や appendix の題名を取得します。

いずれの関数も、EBNET サーバ上の何番目の書籍もしくは appendix の情報を 取得するのかを、引数 i で指定します。 先頭は 1 番目ではなく 0 番目になります。

成功すると、関数は書籍の名称、題名へのポインタを *name, *title に書き込み、`EB_SUCCESS` を返します。 なお、このポインタ値は オブジェクト `bl` が保持している 文字列を指すようになっています。 `bl` に対して `eb_finalize_booklist()` を呼んで しまうと、この文字列も参照不可能になってしまいますので、注意して下さい。

オブジェクト bl の指す `EB_BookList` オブジェクト は、あらかじめ EBNET サーバに結びついている必要があります。 結びついていない場合は、`EB_ERR_UNBOUND_BOOKLIST` を返します。 また、i は 0 以上かつサーバが提供している書籍および appendix の総数未満でなければなりません。 これ以外の値のときは、`EB_ERR_NO_SUCH_BOOK` が返ります。

### サンプルプログラム

>     /*                                                            -*- C -*-
>      * Copyright (c) 2003-2006  Motoyuki Kasahara
>      *
>      * Redistribution and use in source and binary forms, with or without
>      * modification, are permitted provided that the following conditions
>      * are met:
>      * 1. Redistributions of source code must retain the above copyright
>      *    notice, this list of conditions and the following disclaimer.
>      * 2. Redistributions in binary form must reproduce the above copyright
>      *    notice, this list of conditions and the following disclaimer in the
>      *    documentation and/or other materials provided with the distribution.
>      * 3. Neither the name of the project nor the names of its contributors
>      *    may be used to endorse or promote products derived from this software
>      *    without specific prior written permission.
>      *
>      * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
>      * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>      * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
>      * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
>      * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
>      * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
>      * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
>      * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
>      * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
>      * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
>      * SUCH DAMAGE.
>      */

>     /*
>      * 使用方法:
>      *     booklist <remote-access-ideintifier>
>      * 例:
>      *     booklist ebnet://localhost
>      * 説明:
>      *     <remote-access-ideintifier> で指定した EBNET サーバに接続し
>      *     て、サーバの提供する書籍、appendix の一覧を表示します。
>      */
>     #include <stdio.h>
>     #include <stdlib.h>

>     #include <eb/eb.h>
>     #include <eb/error.h>
>     #include <eb/booklist.h>

>     int
>     main(int argc, char *argv[])
>     {
>         EB_Error_Code error_code;
>         EB_BookList bl;
>         int book_count;
>         char *name, *title;
>         int i;

>         /* コマンド行引数をチェック。*/
>         if (argc != 2) {
>             fprintf(stderr, "Usage: %s book-path remote-access-identifier\n",
>                 argv[0]);
>             exit(1);
>         }

>         /* EB ライブラリと `bl' を初期化。*/
>         eb_initialize_library();
>         eb_initialize_booklist(&bl);

>         /* EBNET サーバを `bl' に結び付ける。*/
>         error_code = eb_bind_booklist(&bl, argv[1]);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to bind the EBNET server, %s: %s\n",
>                 argv[0], eb_error_message(error_code), argv[1]);
>             goto die;
>         }

>         /* サーバ上の書籍、appendix の個数を取得。*/
>         error_code = eb_booklist_book_count(&bl, &book_count);
>         if (error_code != EB_SUCCESS) {
>             fprintf(stderr, "%s: failed to get the number of books, %s\n",
>                 argv[0], eb_error_message(error_code));
>             goto die;
>         }

>         for (i = 0; i < book_count; i++) {
>             /* 書籍、appendix の名称を取得。*/
>             error_code = eb_booklist_book_name(&bl, i, &name);
>             if (error_code != EB_SUCCESS) {
>                 fprintf(stderr, "%s: failed to get book name #%d, %s\n",
>                     argv[0], i, eb_error_message(error_code));
>                 goto die;
>             }

>             /* 書籍、appendix の題名を取得。*/
>             error_code = eb_booklist_book_name(&bl, i, &title);
>             if (error_code != EB_SUCCESS) {
>                 fprintf(stderr, "%s: failed to get book title #%d, %s\n",
>                     argv[0], i, eb_error_message(error_code));
>                 goto die;
>             }

>             printf("%-20s  %s\n", name, title);
>         }

>         /* `bl' と EB ライブラリの利用を終了。*/
>         eb_finalize_booklist(&bl);
>         eb_finalize_library();
>         exit(0);

>         /* エラー発生で終了するときの処理。*/
>       die:
>         eb_finalize_booklist(&bl);
>         eb_finalize_library();
>         exit(1);
>     }

## 索引

### データ型の索引

型名の先頭の `EB_` は省略しています。

A
  Appendix
B
  Book
  BookList
D
  Disc_Code
E
  EB_Character_Code
  Error_Code
F
  Font_Code
H
  Hit
  Hook
  Hook_Code
  Hookset
M
  Multi_Search_Code
P
  Position
S
  Subbook_Code

### 関数の索引

関数名の先頭の `eb_` は省略しています。

A
  appendix_path
  appendix_subbook
  appendix_subbook_directory
  appendix_subbook_directory2
  appendix_subbook_list
B
  backward_narrow_alt_character
  backward_narrow_font_character
  backward_text
  backward_wide_alt_character
  backward_wide_font_character
  bind
  bind_appendix
  bind_booklist
  bitmap_to_bmp
  bitmap_to_gif
  bitmap_to_png
  bitmap_to_xbm
  bitmap_to_xpm
  booklist_book_count
  booklist_book_name
  booklist_book_title
C
  character_code
  compose_movie_file_name
  compose_movie_path_name
  copyright
  current_candidate
D
  decompose_movie_file_name
  disc_type
E
  error_message
  error_string
F
  finalize_appendix
  finalize_book
  finalize_booklist
  finalize_hookset
  finalize_library
  font
  font_height
  font_height2
  font_list
  forward_heading
  forward_narrow_font_character
  forward_text
  forward_wide_font_character
H
  have_copyright
  have_endword_search
  have_exactword_search
  have_font
  have_keyword_search
  have_menu
  have_multi_search
  have_narrow_alt
  have_narrow_font
  have_stop_code
  have_text
  have_wide_alt
  have_wide_font
  have_word_search
  hit_list
  hook_empty
  hook_euc_to_ascii
  hook_narrow_character_text
  hook_newline
  hook_wide_character_text
I
  initialize_appendix
  initialize_book
  initialize_booklist
  initialize_hookset
  initialize_library
  is_appendix_bound
  is_bound
  is_text_stopped
L
  load_all_appendix_subbooks
  load_all_subbooks
M
  menu
  multi_entry_candidates
  multi_entry_count
  multi_entry_have_candidates
  multi_entry_label
  multi_search_list
  multi_title
N
  narrow_alt_character_text
  narrow_alt_end
  narrow_alt_start
  narrow_font_bmp_size
  narrow_font_character_bitmap
  narrow_font_end
  narrow_font_gif_size
  narrow_font_png_size
  narrow_font_size
  narrow_font_size2
  narrow_font_start
  narrow_font_width
  narrow_font_width2
  narrow_font_xbm_size
  narrow_font_xpm_size
P
  path
R
  read_binary
  read_heading
  read_rawtext
  read_text
S
  search_cross
  search_endword
  search_exactword
  search_keyword
  search_multi
  search_word
  seek_text
  set_appendix_subbook
  set_binary_color_graphic
  set_binary_mono_graphic
  set_binary_mpeg
  set_binary_wave
  set_font
  set_hook
  set_hooks
  set_subbook
  stop_code
  subbook
  subbook_directory
  subbook_directory2
  subbook_list
  subbook_title
  subbook_title2
T
  tell_text
  text
U
  unset_appendix_subbook
  unset_font
  unset_subbook
W
  wide_alt_character_text
  wide_alt_end
  wide_alt_start
  wide_font_bmp_size
  wide_font_character_bitmap
  wide_font_end
  wide_font_gif_size
  wide_font_png_size
  wide_font_size
  wide_font_size2
  wide_font_start
  wide_font_width
  wide_font_width2
  wide_font_xbm_size
  wide_font_xpm_size
  write_text
  write_text_byte1
  write_text_byte2
  write_text_string

### 定数の索引

定数名の先頭の `EB_` は省略しています。

E
  ERR_BAD_DIR_NAME
  ERR_BAD_FILE_NAME
  ERR_BAD_WORD
  ERR_DIFF_CONTENT
  ERR_EBNET_FAIL_CONNECT
  ERR_EBNET_NO_PERMISSION
  ERR_EBNET_SERVER_BUSY
  ERR_EBNET_UNSUPPORTED
  ERR_EMPTY_WORD
  ERR_END_OF_CONTENT
  ERR_FAIL_GETCWD
  ERR_FAIL_OPEN_APP
  ERR_FAIL_OPEN_BINARY
  ERR_FAIL_OPEN_CAT
  ERR_FAIL_OPEN_CATAPP
  ERR_FAIL_OPEN_FONT
  ERR_FAIL_OPEN_TEXT
  ERR_FAIL_READ_APP
  ERR_FAIL_READ_BINARY
  ERR_FAIL_READ_CAT
  ERR_FAIL_READ_CATAPP
  ERR_FAIL_READ_FONT
  ERR_FAIL_READ_TEXT
  ERR_FAIL_SEEK_APP
  ERR_FAIL_SEEK_BINARY
  ERR_FAIL_SEEK_CAT
  ERR_FAIL_SEEK_CATAPP
  ERR_FAIL_SEEK_FONT
  ERR_FAIL_SEEK_TEXT
  ERR_MEMORY_EXHAUSTED
  ERR_NO_APPSUB
  ERR_NO_CANDIDATES
  ERR_NO_CUR_APPSUB
  ERR_NO_CUR_BINARY
  ERR_NO_CUR_FONT
  ERR_NO_CUR_SUB
  ERR_NO_FONT
  ERR_NO_PREV_SEARCH
  ERR_NO_PREV_SEEK
  ERR_NO_SUB
  ERR_NO_SUCH_APPSUB
  ERR_NO_SUCH_BINARY
  ERR_NO_SUCH_BOOK
  ERR_NO_SUCH_CHAR_BMP
  ERR_NO_SUCH_CHAR_TEXT
  ERR_NO_SUCH_ENTRY_ID
  ERR_NO_SUCH_FONT
  ERR_NO_SUCH_HOOK
  ERR_NO_SUCH_MULTI_ID
  ERR_NO_SUCH_SEARCH
  ERR_NO_SUCH_SUB
  ERR_NO_TEXT
  ERR_NO_WORD
  ERR_TOO_LONG_FILE_NAME
  ERR_TOO_LONG_WORD
  ERR_TOO_MANY_WORDS
  ERR_UNBOUND_APP
  ERR_UNBOUND_BOOK
  ERR_UNBOUND_BOOKLIST
  ERR_UNEXP_APP
  ERR_UNEXP_BINARY
  ERR_UNEXP_CAT
  ERR_UNEXP_CATAPP
  ERR_UNEXP_FONT
  ERR_UNEXP_TEXT
H
  HEIGHT_NARROW_FONT_16
  HEIGHT_NARROW_FONT_24
  HEIGHT_NARROW_FONT_30
  HEIGHT_NARROW_FONT_48
  HEIGHT_WIDE_FONT_16
  HEIGHT_WIDE_FONT_24
  HEIGHT_WIDE_FONT_30
  HEIGHT_WIDE_FONT_48
  HOOK_BEGIN_CANDIDATE
  HOOK_BEGIN_CLICKABLE_AREA
  HOOK_BEGIN_COLOR_BMP
  HOOK_BEGIN_COLOR_JPEG
  HOOK_BEGIN_DECORATION
  HOOK_BEGIN_EMPHASIS
  HOOK_BEGIN_GRAY_GRAPHIC
  HOOK_BEGIN_IN_COLOR_BMP
  HOOK_BEGIN_IN_COLOR_JPEG
  HOOK_BEGIN_KEYWORD
  HOOK_BEGIN_MONO_GRAPHIC
  HOOK_BEGIN_MPEG
  HOOK_BEGIN_NARROW
  HOOK_BEGIN_NO_NEWLINE
  HOOK_BEGIN_REFERENCE
  HOOK_BEGIN_SUBSCRIPT
  HOOK_BEGIN_SUPERSCRIPT
  HOOK_BEGIN_WAVE
  HOOK_END_CANDIDATE_GROUP
  HOOK_END_CANDIDATE_LEAF
  HOOK_END_CLICKABLE_AREA
  HOOK_END_COLOR_GRAPHIC
  HOOK_END_DECORATION
  HOOK_END_EMPHASIS
  HOOK_END_GRAY_GRAPHIC
  HOOK_END_IN_COLOR_GRAPHIC
  HOOK_END_KEYWORD
  HOOK_END_MONO_GRAPHIC
  HOOK_END_MPEG
  HOOK_END_NARROW
  HOOK_END_NO_NEWLINE
  HOOK_END_REFERENCE
  HOOK_END_SUBSCRIPT
  HOOK_END_SUPERSCRIPT
  HOOK_END_WAVE
  HOOK_GB2312
  HOOK_INITIALIZE
  HOOK_ISO8859_1
  HOOK_NARROW_FONT
  HOOK_NARROW_JISX0208
  HOOK_NEWLINE
  HOOK_NULL
  HOOK_SET_INDENT
  HOOK_WIDE_FONT
  HOOK_WIDE_JISX0208
S
  SIZE_NARROW_FONT_16
  SIZE_NARROW_FONT_16_BMP
  SIZE_NARROW_FONT_16_GIF
  SIZE_NARROW_FONT_16_PNG
  SIZE_NARROW_FONT_16_XBM
  SIZE_NARROW_FONT_16_XPM
  SIZE_NARROW_FONT_24
  SIZE_NARROW_FONT_24_BMP
  SIZE_NARROW_FONT_24_GIF
  SIZE_NARROW_FONT_24_PNG
  SIZE_NARROW_FONT_24_XBM
  SIZE_NARROW_FONT_24_XPM
  SIZE_NARROW_FONT_30
  SIZE_NARROW_FONT_30_BMP
  SIZE_NARROW_FONT_30_GIF
  SIZE_NARROW_FONT_30_PNG
  SIZE_NARROW_FONT_30_XBM
  SIZE_NARROW_FONT_30_XPM
  SIZE_NARROW_FONT_48
  SIZE_NARROW_FONT_48_BMP
  SIZE_NARROW_FONT_48_GIF
  SIZE_NARROW_FONT_48_PNG
  SIZE_NARROW_FONT_48_XBM
  SIZE_NARROW_FONT_48_XPM
  SIZE_WIDE_FONT_16
  SIZE_WIDE_FONT_16_BMP
  SIZE_WIDE_FONT_16_GIF
  SIZE_WIDE_FONT_16_PNG
  SIZE_WIDE_FONT_16_XBM
  SIZE_WIDE_FONT_16_XPM
  SIZE_WIDE_FONT_24
  SIZE_WIDE_FONT_24_BMP
  SIZE_WIDE_FONT_24_GIF
  SIZE_WIDE_FONT_24_PNG
  SIZE_WIDE_FONT_24_XBM
  SIZE_WIDE_FONT_24_XPM
  SIZE_WIDE_FONT_30
  SIZE_WIDE_FONT_30_BMP
  SIZE_WIDE_FONT_30_GIF
  SIZE_WIDE_FONT_30_PNG
  SIZE_WIDE_FONT_30_XBM
  SIZE_WIDE_FONT_30_XPM
  SIZE_WIDE_FONT_48
  SIZE_WIDE_FONT_48_BMP
  SIZE_WIDE_FONT_48_GIF
  SIZE_WIDE_FONT_48_PNG
  SIZE_WIDE_FONT_48_XBM
  SIZE_WIDE_FONT_48_XPM
  SUCCESS
W
  WIDTH_NARROW_FONT_16
  WIDTH_NARROW_FONT_24
  WIDTH_NARROW_FONT_30
  WIDTH_NARROW_FONT_48
  WIDTH_WIDE_FONT_16
  WIDTH_WIDE_FONT_24
  WIDTH_WIDE_FONT_30
  WIDTH_WIDE_FONT_48