Node:Introduction, Next:Invoking Flex, Previous:Top, Up:Top

Flex入門

この章では字句スキャン処理の概念を説明し、Flexのようなツールの必要性を示します。本章の後半ではFlexを使うことのできる状況について説明します。

UnixおよびCの世界では、ファイルは通常個々のバイトが連続したものとして扱われます。個々のバイトを集めてどのようにグループ化するかという点は、プログラマが決めることです。このような抽象化は非常に強力です。というのは、どのようなファイルであってもこの抽象化方法によって表現できるからです。しかしこの方法には短所もあり、プログラマはほとんど常に生のファイルに対して構造をあてはめなければなりません。言い換えると、ファイルをより意味のある部分に分割しなければならないということです。たとえば、コンパイラのある部分はファイルから連続した文字を受け取り、構文チェッカが理解することのできる構成要素、たとえば、数値、キーワード、文字列などにグループ化します。このようなことを行う理由は、コンパイラの言語パーサが処理を行うのは、連続した文字に対してではなく、その言語のシンボルが連続したものに対してだからです。

データベースアプリケーションや、バイナリファイルを扱うアプリケーションは、扱うデータに対してある固定されたフォーマットを持っていることが多く、そのフォーマットを使って入力データから意味を導き出します。テキストを入力するプログラムは通常これとは反対で、入力を単語やシンボルに分割しなければならないことが多いのですが、通常これらの単語やシンボルがどのように配置されているかを示す決まった構造というものは存在しません。したがって、テキスト処理を行うプログラムは、入力された情報を意味のあるシンボルに分割するために、字句解析もしくは字句スキャンと呼ばれる処理を行う部分を持っていることが多く、そこで入力情報の分割が行われます。このようなことを行う関数群のことを字句アナライザもしくは字句スキャナ、あるいは短く「スキャナ」と呼びます。

一般的に、スキャナを作成するのは、プログラマにとって難しいことでもおもしろいことでもないのですが、時間のかかる作業になることはあります。普及しているプログラミング言語のほとんどは、スキャナの作成を支援する機能が不十分です。というのは、連続した文字を単語、トークン、シンボルに分割する組み込みの機能を持っていないからです。通常はこのような仕事を行うライブラリルーチンが存在しますが、柔軟でなかったり、使いにくかったり、あるいは、ルーチンとのやり取りにあまりに多くのコードが必要になったりすることが多いために、実装上の細かな点によって根本的な問題が不明瞭にされてしまいます。

1つの良い例が、C言語で許されているすべての数値型（浮動小数点、整数、16進数、8進数）を処理するスキャナをC言語で記述する場合です。これは非常に難しいということはありませんが、でき上がったコードは通常美しいとはとてもいえないものになってしまうでしょうし、その保守や拡張は容易でないことが多いのです。

ほとんどのプログラマが即座に断言するように、他人の書いたコードを保守するのは通常あまり楽しい作業ではありません。さらに、美しくないコードを保守するのは、楽しいというにはほど遠いものです。このように、スキャナを書くことが退屈で、その保守が難しいとなると、スキャナの作成をより容易にしてくれる方法を考えようとした理由が読者にもおわかりいただけるでしょう。

Node:Problem Solving, Next:General Programming, Up:Introduction

問題解決手段としてのFlex

Flexはプログラマに対して、字句解析処理部分をきれいに記述し、その記述にしたがった効率的な字句スキャナを生成する方法を提供します。プログラマはFlexに対して、必要なスキャナに関する記述情報を提供します。 Flexはその記述情報を使って、C言語で書かれたスキャナを生成します。記述に使われる言語は高級言語であり、スキャナの記述に関してはC言語よりもはるかに適しています。その高級言語を使うことで、プログラマは、文字をどのようにグループ化し、グループ化が完了したときにどのようなアクションを発生させるかを指定できます。

注意：本書のほとんどの部分はFlex、Lexの両方を対象にしています。 Lexは（Flexには劣りますが）ほとんどのUnixシステム上にある標準のスキャナ生成ユーティリティです。両者の間に違いがある場合には、Flexを優先させています。 Lexについては標準Lexで簡単に説明しています。

ここでも1つの良い例がコンパイラです。前述のように、コンパイラの構文チェッカは、文字が連続したものではなく、言語文法の構成要素を表すトークンが連続したものを、入力として受け取る必要があります。 Flexはこのような場合に最適です。 Flexによって生成されたスキャナが構文チェッカとファイルの仲介役となり、構文チェッカが次の意味のあるトークンを要求するのを待ちます。 Flexはファイルを読み、プログラマが与える記述にしたがって文字をグループ化して、マッチしたトークンを返します。この処理は、スキャナもしくはパーサが終了するまで続きます。

Cのコンパイラを作成する場合、このようなことを行うために必要となるFlexの記述情報は、コードの行数にして100～300行ぐらいになるかもしれません。この記述情報のほとんどは、シンボルテーブルの管理、識別子の検索、型のマッピング、ある数の値などの追加情報の返却を行うための補助的なCコードになるでしょう。こうしたコード自体は記述情報の一部ではありませんが、通常、コンパイラによって必要とされるものです。

概念的にはFlexは、原材料（文字）を取り込み、消費者（パーサ等）がすぐに使うことができる完成品（トークン）を製造する工場のようなものです。

Node:General Programming, Previous:Problem Solving, Up:Introduction

一般的なプログラミングツールとしてのFlex

Flexはコンパイラにしか使えないということはありません。読者のコンピュータ上にある、ファイルを読み込んだり、なんらかの形で文字のグループを処理する必要のあるすべてのプログラム、特に、変換フィルタや言語ツールのことを考えてみてください。こうしたプログラムのほとんどすべてを、 Flex単体、もしくはFlexと他のツールの組み合わせによって作成することができます。

良い例の1つが文字数のカウントです。たとえば、ファイルの中の全行数、個々の文字の出現回数、 fooという単語の出現回数を調べるプログラムを作成したい場合です。標準的なツール（grep、sed、awk、perl等）で作成することも、C言語のプログラムを書いて作成することもできますが、 Flexで作成することも可能です。もう1つの例として、特定のキーワードを探す必要のある、メールリーダがあります。この場合でも、標準ツールで実現することも、FlexとC言語で実現することもできます。

Flexを使うことで、プログラマは、スキャナの開発やファイルを構成する文字の処理にかかる時間を大幅に減らすことができます。ほとんどの場合、Flexに対する入力情報は、既存のプログラミング言語で記述されたコードと比較して、より理解しやすく、少なくとも同程度の移植性があり、保守もより簡単です。それだけでなく、Flexでスキャナを開発するのにかかる時間は、既存のプログラミング言語で同等のスキャナを開発する場合と比べきわめて短くてすむので、 Flexは、プロトタイピングや、一度しか使わないプログラムやフィルタの開発に最適です。

Node:Invoking Flex, Next:Flex Descriptions, Previous:Introduction, Up:Top

Flexの起動

この章ではFlexを起動する基本的な方法を説明し、 Flexで使用可能なコマンドラインオプションを簡単に説明します。

Flexは記述情報を含むファイルを入力として受け取り、スキャナ機能を持つCのファイルに変換します。 Flexを起動するためのコマンド行は以下のようになります。

flex [-bcdfinpstvFILT8] [-C[efmF]] [-Sskeleton] [file ...]

一般的には、単にflexに続けて処理すべきファイル名を入力することで実行されます。

flex myfile.l

記述情報ファイル名の末尾の.lは、 myfileがFlexもしくはLexの記述ファイルであることを示す慣例的な方法です。名前付けの慣例としてもう1つよく見られるのが、末尾に.lexを使うことです。たとえば、以下のようになります。

flex myfile.lex

Flexは記述情報ファイル（myfile.l）を読み込み、そこに記述されたパターンを認識するスキャナ機能を持つlex.yy.cという名前のC言語ファイルを生成します。記述情報の中になんらかのエラーがあれば、 Flexは対応するエラーメッセージをstderrに出力します。

Node:Command Line Switches, Next:Command Line Switches (Flex 2.5), Up:Invoking Flex

コマンドラインオプション

Flexのコマンドラインオプションは以下のような意味を持ちます。

-b: -bオプションを指定するとlex.backtrackというファイルが生成されます。このファイルはスキャナの記述情報を最適化する際に使用されます。詳細については、See Optimizing for Speed。
-c: このオプションはPOSIXとの互換性のために提供されているだけで、実際には何もしません。 POSIXでは、 -cオプションはC言語によるアクションが使用されることを意味します。
-d: このオプションを指定するとデバッグが可能になります。これにより生成されるスキャナは、実行中にスキャナの状態情報をstderrに出力します。
-f: Flexに対してファストスキャナ（fast scanner）とフルスキャナ（full scanner）のどちらを生成するかを指示します。詳細については、See Table Compression and Scanner Speed。 -f（小文字）オプションと-F（大文字）オプションとは異なる効果を持つ点に注意してください。
-i: Flexに対して大文字、小文字を区別しないスキャナを生成するよう指示します。詳細については、See Case Insensitive Scanners。
-n: このオプションはFlexにとってはなんの意味も持たず、 POSIXとの互換性のためにのみ提供されています。 POSIXでは、このフラグは-vオプションによる出力を抑制するために使用されます。 POSIXでのデフォルトは、テーブルサイズが指定されないかぎりこのような出力を抑制します。 Flexではテーブルサイズは意味を持たないので、このフラグは冗長です。
-p: -pオプションが指定されると、 Flexは性能レポートをstderrに出力します。スキャナの性能を向上させる方法に関する解説については、 See Optimizing for Speed。
-s: Flexスキャナがマッチするものを見つけられなかった場合のデフォルトのアクションは、そのマッチされなかった入力情報をstdoutに出力することです。 -sオプションはこのようなアクションを抑制し、その代わりに入力情報がマッチしなかった時点でスキャナを異常終了させます。
-t: このオプションが指定された場合、 Flexは生成されたスキャナをファイルlex.yy.cにではなくstdoutに出力します。
-v: Flexに対して冗長モードで動作するよう指示します。
-F: Flexに対してファストスキャナを生成するよう指示します。詳細については、See スキャナの最適化。 -F（大文字）は-f（小文字）とは異なる効果を持つ点に注意してください。 -fと-Fの相違点に関する情報については、 See Table Compression and Scanner Speed。
-I: このオプションはFlexに対して対話型スキャナを生成するよう指示します。詳細については、See Interactive Scanners。
-L: デフォルトでは、デバッグを支援するために、 Flexは生成されたスキャナのコード中に#line指示子を書き込みます。このオプションによって#line指示子の書き込みは行われなくなります。
-T: Flexに対してトレースモードで動作するよう指示します。 Flexは多くのメッセージをstderrに出力するようになります。こうしたメッセージは、 Flexを非常によく理解しているユーザー以外には無意味でしょう。
-8: このオプションは、 Flexに対して8ビット入力を受け付けるスキャナを生成するよう指示します。
-C[efmF]: これらのオプションは、スキャン処理用のテーブルをどのように圧縮するかを制御します。詳細については、See スキャナの最適化。
-Sskeleton_file: Flexに対して、生成するスキャナのベースとしてskeleton_fileにより指定されるスケルトンファイルを使用するよう指示します。主に、Flex自体をデバッグするために使用されます。

Node:Command Line Switches (Flex 2.5), Previous:Command Line Switches, Up:Invoking Flex

コマンドラインオプション（Flex 2.5の補足情報）

Flex 2.5では、前節（Command Line Switches）で説明されていない、以下のオプションもサポートされています。

-h

Flexに対してコマンドラインオプションの要約情報を出力するよう指示します。

-l

AT&Tにより実装されたlexとの互換性を最大限に提供します。このオプションは、性能面でかなりの悪影響を及ぼします。また、このオプションを、-f、-F、-Cf、-CF、 -+オプションと同時に指定することはできません。 FlexとLexの（非）互換性の問題については、Flex and Lexを参照してください。

-w

このオプションが指定されると、Flexは警告メッセージを出力しません。

-B

Flexに対してバッチスキャナ（batch scanner）を生成するよう指示します。これは、対話型スキャナを生成するよう指示する-Iオプションの否定です。

-V

Flexに対してバージョン番号を出力するよう指示します。

-7

Flexに対して7ビットスキャナを生成するよう指示します。これは-8オプションの否定です。内部的に生成されるテーブルのサイズは-8オプションが指定された場合と比較して半分になりますが、生成されるスキャナは、8ビット文字を含む入力を処理できなくなります。 -Cf、-CFが指定されていない場合は、明示的に-7を指定しないかぎり、8ビットスキャナが生成されます。

-+

Flexに対してC++スキャナクラスを生成するよう指示します。 C++スキャナについては、Flex and C++ (Flex 2.5)を参照してください。

-?

Flexに対してコマンドラインオプションの要約情報を出力するよう指示します（-hオプションと同じです）。

-Ca

このオプションは、スキャン処理用のテーブルをlong intの配列として定義するようFlexに通知します（デフォルトではshort int型の配列となります）。 RISCマシンによっては、long intのほうが高速に処理されるため、スキャナの性能向上が期待できますが、その反面、テーブルのサイズは大きくなります。

-Cr

このオプションを指定して生成されたスキャナは、入力にread()システムコールを使います。デフォルトでは、対話型スキャナの場合はgetc()が、バッチ（非対話型）スキャナの場合はfread()が使われます。

-ofile

このオプションが指定されると、Flexは生成されたスキャナをfileによって指定されたファイルに出力します。デフォルトでは、スキャナはファイルlex.yy.cに出力されます。

-Pprefix

Flexによって生成されるスキャナのソースファイルの中では、大域変数や大域関数の名前の先頭に接頭辞yyが付けられます。このオプションが指定されると、yyの代わりに、 prefixによって指定される文字列が接頭辞として使用されます。また、-oオプションが指定されない場合のスキャナファイル名 lex.yy.cも、lex.prefix.cとなります。

以下に、このオプションにより影響を受ける名前の一覧を示します。

yy_create_buffer
yy_delete_buffer
yy_scan_buffer
yy_scan_string
yy_scan_bytes
yy_flex_debug
yy_init_buffer
yy_flush_buffer
yy_load_buffer_state
yy_switch_to_buffer
yyin
yyleng
yylex
yylineno
yyout
yyrestart
yytext
yywrap

-+オプションが指定されている場合は、影響を受けるのはyywrapとyyFlexLexerの2つだけです。

このオプションにより、 yywrap()の名前が変更されてしまう点に注意してください。プログラムをリンクするためには、 prefixwrapという名前の関数を作成する必要があります。この関数を作成したくない場合には、スキャナ定義ファイルの中で、%option noyywrapを指定して、リンク時に-lflオプションを指定します。 %option指示子については、%option (Flex 2.5)を参照してください。

--help

Flexに対してコマンドラインオプションの要約情報を出力するよう指示します（-hオプションと同じです）。

--version

Flexに対してバージョン番号を出力するよう指示します（-Vオプションと同じです）。

Node:Flex Descriptions, Next:Interfacing to Flex, Previous:Invoking Flex, Up:Top

Flex記述言語

この章では、スキャナ定義の構成要素を説明し、その使用例を示します。 Flexを効率的に使用するためには、定義の個々の要素を完全に理解することが非常に重要です。したがって、初めてFlexを使うユーザーは、時間をかけて本章を読むことをおすすめします。

Flexスキャナ定義のほとんどの要素は、任意です。全体的な定義フォーマットは以下のようになります。

定義と初期Cコード
%%
ルール
%%
他のCコード

それぞれについて、以下において詳細に説明します。

Node:Comments, Next:Optional C Code, Up:Flex Descriptions

Cのコードを記述できるところには、どこにでもコメントを記述できます。コメントの書式は、Cのコメントの規則に従います。コメントは、記述情報に影響を及ぼすことはありません。 Cスタイルのコメントは以下のようになります。

/*
...
*/

これに加えて、Flexでは#で始まるコメントも許されます。しかし、このようなコメントはlex.yy.cにはコピーされないので、この形式のコメントの使用はおすすめできません。

注意：C以外の言語（たとえばPascal）のコードを生成するLexも存在します。このようなLexではコメントの書式はおそらく異なるでしょう。 Flexの場合はCのコードしか生成しません。

Node:Optional C Code, Next:Definitions, Previous:Comments, Up:Flex Descriptions

オプションのCコード

プログラマは、2つの異なる方法を用いて、スキャナの中に直接Cのコードを含めることができます。第1の方法は、「定義と初期Cコード」セクション（最初の%%より前の部分）にコードを含めることです。第2の方法は、「他のCコード」セクション（2番目の%%より後ろの部分）にコードを含めることです。どちらの場合も、コードはそのままlex.yy.cにコピーされるので、正当なコードでなければなりません。

第1のセクション中のCコードは以下の形式になります。

%{
   Cコード
   ...
%}

ここで%{...%}というペアが、 Cコードブロックの先頭と末尾を示すために使われています。この形式のコードと定義は、「定義と初期Cコード」セクションのどこにでも自由に記述できます。定義については次の節で説明します。

Cのコードが最初のカラムから始まるのでなければ、 %{...%}というペアは必要ありません。しかし普通は、わかりやすくするために記述しておいたほうがよいでしょう。もう1つのポイントは、#ifdefなどのように最左端のカラムから始まらなければならず、かつ、通常はスキャナ記述情報の先頭に置かれる必要のあるものが存在するという点です。こうした場合、%{...%}に囲まれていないと、 Flexはそれを定義の一部であるとみなすでしょう。これが、常に%{...%}を使うもう1つの理由です。

最後の（「他のCコード」）セクション内のコードは、そのままコピーされます。ここには特別な宣言は必要ありません。

Node:Definitions, Next:%%, Previous:Optional C Code, Up:Flex Descriptions

定義

定義セクションにおいて、プログラマは、ある文字のグループに一意な識別子を与え、その識別子がその文字グループに置き換えられるようにすることができます。定義は以下のような形式になります。

definition_name    definition

definition_nameは最初のカラムから始まらなければならず、そうしないとその定義はlex.yy.cにそのままコピーされてしまうということに注意してください。以下に一般的な定義をいくつかあげます。

DIGIT     [0-9]
LETTER    [a-z]
IDENT     [a-z_][a-z0-9_]*
ALPHANUM  {LETTER}|{DIGIT}

definition nameは、そのグループの一意な識別子でなければなりません。また、definitionはルールセクション（後述）において正当なものであればなんでもかまいません。ルールセクションや（上の例のALPHANUMの定義において示されるように）別の定義中において使われる場合には、定義は{ }によって囲まれていなければなりません。

FlexとLexの非常に重要な相違点に、定義を展開するとき、 Flexは字義どおりに丸かっこ( )で囲むのに対して、 Lexは囲まないという点があります。¹ これは、^、<<EOF>>、$、/を定義中に入れることができないことを意味しています。というのは、前述の文字は丸かっこ( )で囲まれた部分に入れることができないからです。詳細は、CharactersおよびFlex and Lexにおいて説明します。

たとえば、

FUNCTION ^[a-zA-Z_][a-zA-Z0-9_]*"("
%%
{FUNCTION}  printf("got a function\n");

は、以下のようなプログラミングスタイルを使っている場合の、 Cの関数宣言にマッチするように見えます。

int
foo()
{
   ...
}

しかし実際にはうまくいきません。というのは、{FUNCTION}が展開されると、

(^[a-zA-Z_][a-zA-Z0-9_]*)

のようになりますが、これは不正だからです。このような種類の問題に関する説明については、 Flex and POSIXを参照してください。

Node:%%, Next:Rules, Previous:Definitions, Up:Flex Descriptions

%%

2つのパーセント記号が、スキャナ記述情報のルールセクションの先頭と末尾を示します。すべてのFlex記述情報は、少なくともルールセクションの先頭を示す %%を含んでいなければなりません。

Node:Rules, Next:Pattern Matching, Previous:%%, Up:Flex Descriptions

ルール

ルールはFlexの心臓部です。ルールを書くことによって、プログラマは、スキャナが何を実行するべきであるかをFlexに通知します。

通常、ルールは2つの部分から構成されます。

pattern       actions

このうちpatternが何を認識するべきかを定義し、 actionsがその何かを認識したときに何を実行するべきであるかをスキャナに知らせます。 patternの部分は空白によって区切られます。これは、空白をマッチさせたい場合には、それを引用符で囲む必要があるということを意味しています。

スキャナは、マッチするものを2つ以上見つけた場合、以下の2つのルールを使ってどれを受け入れるかを決めます。

後続コンテキスト（trailing context）も含めてもっとも長いものを受け入れる。
マッチするものがすべて同じ長さの場合、スキャナ定義中に最初に記述されたものを受け入れる。

actionsは、空（コードなし）にするか、もしくは、1つ以上のCの文を含む単一のコード行、 {...}または%{...%}で囲まれた1行以上のコード、単一の垂直棒（|）のいずれかを記述できます。以下にいくつか例をあげます。

hi         |
bonjour    |
hello      printf("hello!\n");
goodbye    {  printf("goodbye!\n"); }
konnichiwa {
               line 1
               ...
               line n
           }
sayonara   printf("lex will not "); printf("print this\n");

どの行も複数の文を含むことができます。 |は、そのルールにマッチするものが見つかった場合、次に現れるルールのアクション部に記述されているアクションが実行されるべきであることをFlexに通知します。

注意：ほとんどのバージョンのLexは、 {と}のペアの外部では単一の文しか許しません（たとえば上記のsayonaraルールは許されません）。また、C以外の言語をターゲットにしているLexでは、{と}のペアは、たとえばPascalの場合のbegin...endのように、異なるシンボルに置き換える必要があるかもしれません。

ルールにマッチしなかった入力に対するデフォルトのアクションは、それをstdoutに出力することであり、一方、マッチしたパターンに対するデフォルトのアクションは、それを破棄することであるという点に注意してください。これは、もっとも単純なFlexの定義が

%%

であることを意味しています。これは、入力を変更せずそのままstdoutへ出力するものです。別の単純な例として以下のようなものがあります。

%%
foobar

この場合、入力の中からfoobarという文字の並びをすべて取り除き、取り除いた結果をstdoutに出力します。

Node:Pattern Matching, Next:Regular Expressions, Previous:Rules, Up:Flex Descriptions

パターンセクション

パターンセクションは、正規表現と呼ばれる仕組みを使って実際のマッチング処理を実行します。正規表現は、文字列、文字、文字集合（クラス）、および演算子から構成されています。正規表現を構成する要素については次節以降で説明します。また正規表現自体については、Regular Expressionsにおいて解説します。

Node:Characters, Next:Strings, Up:Pattern Matching

文字

いくつかの文字はFlexにとって特別の意味があり、その文字を単独で使ったのでは、その文字自体を表すことができません。以下に、Flexにおける特殊文字とその意味を表にして示します。

文字
Flexによる解釈
.
ピリオドは改行（\n）以外の任意の文字を表します。
\
バックスラッシュはエスケープ文字です。エスケープシーケンスはANSI Cのものと同じです。
[ ]
角かっこ[ ]は複数の文字を文字クラスにグループ化します。詳細については、See Flexにおける文字のグループ化。
^
文字クラスの内部では「^」は否定を意味します。詳細については、See Flexにおける文字のグループ化。文字クラスの外部では、「^」は行の先頭を意味し、ルールの先頭にのみ置くことができます。例を以下に示します。

[^AB]
否定クラスです。
^foo
行の先頭にあるfooという文字の並びにのみマッチします。
foo^
この場合、^は普通の文字であるとみなされます。このようなときには、希望どおりの結果が確実に得られるようにするために、特別な意味を持つ文字の前にバックスラッシュ\を置くのがよいでしょう。このような文字の並びをエスケープシーケンスと呼びます。エスケープシーケンスについてはこの節の最後で説明します。

-
ハイフンは文字クラスの内部において文字の範囲を表します。文字クラスの外部では、ハイフンはそれ自身を表します。詳細については、See Flexにおける文字のグループ化。
{ }
中かっこ{ }は、定義の参照、複数行のアクションの囲み、またはある範囲にわたる繰り返しの定義を行います。例をあげると、定義FOOがあって、それをルールの中で参照したい場合に{FOO}を使います。
与えられたパターンのある範囲にわたる繰り返しを定義するには、以下のような{ repetition list }を使います。
%%
f{2,5}  /* fの2回以上5回以下の繰り返し */
        /* にマッチ                      */
f{2,}   /* fの2回以上の繰り返しにマッチ */
f{2}    /* fの2回の繰り返しにマッチ     */
この用法の解釈において、 FlexとLexの間にはいくつかの相違点があります。詳細については、Flex and POSIXを参照してください。
( )
丸かっこ( )を使って優先順位を変更できます。また、定義が展開されるときには、その定義は暗黙のうちに丸かっこ( )で囲まれることに注意してください。² このため、Lexとは非互換なところがでてきます。この点については、Flex and POSIXとDefinitionsで説明しています。
""
二重引用符記号は文字列を表します。引用符の内側の文字列だけがマッチの対象になります。したがって、
%%
"string"
は"string"にではなく、stringにマッチします。
/
スラッシュは後続コンテキストを設定します。これは、あるパターンの後ろに特定の文字の並びが続く場合のみ、そのパターンを認識します。つまり、スラッシュ/は「ルックアヘッド（先読み）」演算子として機能します。例をあげると、

abcDEF
abcDEF を認識します。
abc/DEF
abcの後ろにDEFが続く場合に限り、abcを認識します。 DEFの部分は、まだ読まれてはいないかのように扱われ、マッチの対象になりません。

注意：1つのルールの中では/は1つだけ許されます。つまり、
abc/def/hijkl
は不正です。
< >
山かっこ< >はスタート状態を参照します。また、EOFシンボル（<<EOF>>）にも使われます。完全な説明については、 Start StatesとEnd-Of-File Rulesを参照してください。
? + *
?、+、*は、ある正規表現が出現できる回数を設定します。 ?は0回もしくは1回（その正規表現が現れることが必須ではないということ）を意味します。 +は1回以上を意味します。 *は0回以上を意味します。たとえば、

a?
0個もしくは1個のaにマッチします。
a+
1個以上のaにマッチします。
a*
0個以上のaにマッチします。
(ABC)+
ABCという文字の並びが1回以上続くものにマッチします。
[abQrS]?
0個もしくは1個の、（5つの文字abQrSから構成される）この文字クラスのメンバにマッチします。文字クラスに関する詳細については、 Flexにおける文字のグループ化を参照してください。
{NUM}*
0個以上のNUMにマッチします。ここでのNUMは定義です。定義に関する詳細については、Definitionsを参照してください。

|
OR演算子および特別なアクションを表します。たとえば、
   apples|oranges
はapplesもしくはorangesのいずれかにマッチし、
apples         |
oranges        printf("fruit!\n");
は、 applesとorangesの両方に対して同一のアクションを実行します。
$
ドル記号は行末を意味します。たとえば、
   end$
はその直後が行末である場合にのみendという文字の並びにマッチします。これは、後ろに続くのが行末のマーカである場合のみendにマッチする
   end/\n
とまったく同じです。

こうした文字のいずれかをその文字自身として表したい場合には、引用符で囲むか、（後に示す表で説明する）エスケープシーケンスとして表さなければなりません。

Flexには3種類のエスケープシーケンスがあります。それは、バックスラッシュ\に続けて8進数を使うもの、\xに続けて 16進数を使うもの、\letterという表記法によってある1文字または特別な表示不可の文字を表すものの3つです。 Cをよく知っている人であれば、この3つがANSI Cのエスケープシーケンスであることに気がつくでしょう。数値によるエスケープシーケンスは、100パーセント移植性があるわけではなく、保守を困難にするので避けるべきです。

以下に、文字の使用に関する要約を示します。ここでは、cが単一の文字を、NNNが8進定数を、 HHが16進定数を表します。

注意：いくつかのバージョンのLexでは、\0を正しく認識またはマッチしません。これは、\0がNUL、つまりC文字列の終端文字だからです。 Flexでは、NULをマッチの対象にしても問題はありませんが、性能には若干影響します。

さらに付け加えると、^演算子と<<EOF>>はルールの先頭にのみ置くことができます。また、これらと$、/は丸かっこ( )の内部に置くことはできません。このことはまた、定義の正当性にも影響を及ぼします。というのは、展開されるときに定義は字義どおりに丸かっこ( )で囲まれるからです。 ³ 詳細については、DefinitionsとFlex and POSIXを参照してください。

Node:Strings, Next:Character Classes, Previous:Characters, Up:Pattern Matching

Flexにおける文字列

文字列とは、（常に、というわけではありませんが）多くの場合、引用符によって囲まれる文字のグループです。エスケープシーケンスが使われないかぎり、文字列には改行や表示不可の文字を含めることはできません。

-i オプション（詳細については、See Case Insensitive Scanners）を使わないかぎり、大文字／小文字の区別も含めた字義どおりの文字列に対してマッチが行われます。引用符付きの文字列については、引用符は認識される文字列には含まれません。

たとえば、

string
StrING
"STRING"
\"string\"

はすべて正当な文字列であり、最後のものは引用符も含めてマッチされます。 Flexにおいては文字列には引用符は必須ではありません。したがって、キーワードのグループにマッチさせる場合、

begin
end
pointer
 ...

と

"begin"
"end"
"pointer"
 ...

のいずれも正当です。

Node:Character Classes, Next:Character Class Expressions (Flex 2.5), Previous:Strings, Up:Pattern Matching

Flexにおける文字のグループ化

Flexでは、文字をグループ化して文字クラスにすることができます。文字クラスは、文字のグループを角かっこ[ ]で囲むことによって作成されます。どのような文字でも正当です（表示不可の文字についてはエスケープシーケンスを使います）。また、文字の範囲をハイフン-を使って指定できます。文字クラスがルールの中で使われている場合には、 Flexはそのクラスの任意のメンバとマッチさせ、あたかも単一文字が使われているかのように振る舞います。たとえば、

[a-z]
[A-Z]*

において、最初の例はaからzまでの任意の単一文字にマッチします。第2の例はAからZまでの任意の文字が0個以上並んだものにマッチします。

否定文字クラスを表す正規表現を書くこともできます。否定文字クラスは、（\nも含めて）文字クラスのメンバ以外であればなんにでもマッチします。これを行うには、否定すべきクラスの先頭に^を置きます（クラスの外部では ^は異なる意味を持つことに注意してください）。以下に、正当なクラスの例をいくつかあげます。

[abc]: a、b、cのいずれかにマッチします。
[abc\n]: a、b、c、\nのいずれかにマッチします。
[a-z]: ASCII値がaからzまでの範囲にある任意の文字、すなわち、任意の英小文字にマッチします。
[^a-z]: aからzまでの範囲にある文字以外の任意の文字にマッチします。
[ABcd]: A、B、c、dのいずれかにマッチします。

注意：Flex、およびいくつかのバージョンのLexは、クラス内における逆方向の範囲を扱うことができません。したがって、

%%
[z-a9-0]

はエラーメッセージを出力します。逆方向の範囲は指定しないでください。

Node:Character Class Expressions (Flex 2.5), Previous:Character Classes, Up:Pattern Matching

Flexにおける文字のグループ化（Flex 2.5の補足情報）

Flex 2.5では、文字クラスの中に文字クラス式を含めることができます。

文字クラス式は、形式的には、ある文字集合を識別する名前を [:と:]で囲んだものです。 Flex 2.5では、以下の文字クラス式が有効です。

[:alnum:] [:alpha:] [:blank:]
[:cntrl:] [:digit:] [:graph:]
[:lower:] [:print:] [:punct:]
[:space:] [:upper:] [:xdigit:]

文字クラス式[:XXX:]は、ANSI CのisXXX()関数がゼロ以外の値を返す文字の集合に対応します。唯一の例外は[:blank:]で、isblankは（POSIXでは定義されているものの） ANSI Cでは定義されていないため、Flexでは、マクロIS_BLANKを

#define IS_BLANK(c) ((c) == ' ' || (c) == '\t')

のように定義して、これが真となる文字の集合（すなわち、スペースとタブ）を文字クラス式[:blank:]に対応させています。

文字クラス式を使えば、

[a-zA-Z]
[0-9]

を

[[:alpha:]]
[[:digit:]]

と書くことができます。

また、文字クラスの中に複数の文字クラス式を含めることができるので、

[a-zA-Z0-9]

を、

[[:alpha:][:digit:]]

と書くこともできます（もっとも、この例の場合は、[[:alnum:]]と書くほうがよいでしょう）。

Node:Regular Expressions, Next:Start States, Previous:Pattern Matching, Up:Flex Descriptions

正規表現

Flexの文字、文字列、クラス、定義、および演算子を組み合わせることで、正規表現として知られているものが作られます。（基本単位が数と演算子である）数学表現と同じように、基本的な要素は単純なもの（文字、演算子、文字列、クラス、および定義）ですが、要素を組み合わせることでより複雑な表現式を作ることができます。たとえば、cは単一文字の正規表現で、cにマッチします。 ccは2つの正規表現をつないだものを含む正規表現で、 ccにマッチします。 c*は、単一文字の正規表現cと、それに続く演算子* から構成される正規表現で、0個以上のcにマッチします。正規表現の真のパワーは、個々の要素よりもむしろ、組み合わせ可能な方法の中にあります。

次の表は、Flexで利用可能な正規表現をすべて示したものです。ここで、cは（エスケープシーケンスを含む）任意の単一文字を、 rは任意の正規表現を、sは文字列を表します。表はグループ別に編成してあり、優先度のもっとも高いものがいちばん上にあります。

Unixにおいてパターン検索が必要な場合には正規表現がよく使われますが、アプリケーションが異なると、正規表現もよく似てはいるもののまったく同一ではないという点に注意してください。たとえば、Flex、egrep、Emacsはいずれもパターン検索のテンプレートとして正規表現を使いますが、それぞれが理解する正規表現は少しずつ異なります。特に、Flexでは定義が使われますが、egrepやEmacsでは使えませんし、 egrepやEmacsは単語の先頭と末尾にマッチさせるための\<と \>とを提供していますが、Flexは提供していません。さらに、Emacsはバッファの先頭に対するマッチングや「ファジー」なマッチングなどを行うための、特別な\letterシーケンスをほかにも数多く提供しています。

Node:Start States, Next:%option (Flex 2.5), Previous:Regular Expressions, Up:Flex Descriptions

スタート状態

なんらかの条件に基づいて、パターンマッチング処理のルールを活性化することが便利なときがあります。たとえば、いくつかのコンピュータ言語では、重複しているスキャンルールのあいまいさを取り除くのを支援するために、パース状態を使います。また、ある特定の入力が見つかった後でだけ、あるルールを活性化したいという場合があります。このような状況に対処するために、Flexはスタート条件またはスタート状態と呼ばれる単純なシステムを提供しています。

Node:Start States Explained, Next:Activating States, Up:Start States

スタート状態の説明

スタート状態は、あるルールがアクティブになるのはいつであるかをFlexに通知するブール値のようなものです。スタート状態は、定義セクションにおいて（排他的スタート状態の場合）%x 、または（包含的スタート状態の場合）%sを使って宣言されます。

%x start_state_name
%s start_state_name

start_state_nameは一意な名前でなければならない点に注意してください。つまり、他のスタート状態や定義が同じ名前を持ってはならないということです。スタート状態は、1つの状態の名前、または、カンマで区切られた複数の状態の名前を山かっこ< >で囲むことによって、ルールセクションで参照されます。スタート状態の参照はルールの先頭になければならず、 1つのルール中には1対の山かっこ< >のみ許されます。このことは、

%x state1
%s state2
%x state3 state4
%%
<state1>"foo"
<state2,state3,state4>"bar"

が正当であり、

integer [-+]?[0-9]*
%x integer
%s state1,state2,state3
%%
<integer>"foo"
"bar"<state1>
<state1>"bar"<state2,state3>

はすべて不当であることを意味しています。 integerについては同じ名前を持つ定義が存在し、それ以外のものについてはスタート状態の参照の位置が正しくないか、複数の参照が存在するからです。

これまでのところでは、Flexが異なる2種類のスタート状態をサポートしている事実から目をそらしてきました。 2つのスタート状態とは、包含的スタート状態（%s）と排他的スタート状態（%x）のことです。これら2つの相違点は、排他的スタート状態が活性化された場合は、その状態に属するルールだけが活性化されるのに対して、包含的スタート状態の場合は、その状態に属するルールとスタート状態への参照を持たないルールの両方が活性化されるという点にあります。この違いを示す例をあげると、以下のようになります。

%s state1
%%
<state1>"one" printf("two");
"three"       printf("four");

この場合、state1状態が活性化されている場合はoneをtwo に置き換え、state1状態が活性化されているか否かにかかわらず threeをfourに置き換えます。デフォルトのルールにより、その他のテキストはstdoutに出力されます。これに対して、

%x state1
%%
<state1>"one" printf("two");
"three"       printf("four");

は、state1状態が活性化されているときはoneをtwoに置き換え、 state1状態が活性化されていないときのみthreeをfour に置き換えます。デフォルトのルールにより、その他のテキストはstdoutに出力されます。

このことは、排他的スタート状態が使われる場合には、マッチしないテキストが stdoutに出力されてはならないのであれば、すべての可能な入力にマッチするルールを、個々の排他的スタート状態が持たなければならないことを意味しています。包含的スタート状態の場合は、あらゆる状態において有効な、スタート状態への参照を持たないルールを1つ持つ必要があります。

注意： 排他的スタート状態はPOSIXの一部であるにもかかわらず、 Lexではサポートしていません。

Node:Activating States, Next:Start State Notes, Previous:Start States Explained, Up:Start States

状態の活性化

スタート状態の名前を並べただけではあまり役に立ちません。つまり、スタート状態がいつ活性化されるのかということも制御しなければなりません。活性化は、アクションの中、または、記述情報内の追加のCコードを記述する領域の中において、BEGINを使うことで実現されます。使い方は以下のとおりです。

BEGIN(start_state_name);

例をあげると、以下のようになります。

%x COMMENT
%%
"{"            BEGIN(COMMENT);
<COMMENT>"$R"
<COMMENT>"$I"
<COMMENT>"$M"
    ...
<COMMENT>"}"   BEGIN(INITIAL);

この場合、Pascalのコメントの先頭部分を見つけるとCOMMENT状態に移行し、コンパイラオプションを認識するようになります。 BEGINは最初の%%の直後（最初のルールの前）において使うこともでき、この場合はyylex()は常に指定された状態で開始されます。

上の例においては、定義されていないINITIALという状態があることに注意してください。この状態は常に利用可能で、 活性化された状態が1つも存在しない時のスキャナの初期状態を表します。つまり、BEGIN(INITIAL)によって、スキャナの状態が効果的に（もちろん、その時点においてスキャンしている箇所を維持したまま）リセットされることを意味しています。

Node:Start State Notes, Next:Start State Notes (Flex 2.5), Previous:Activating States, Up:Start States

スタート状態に関する注意

以下に、スタート状態の使用に関する注意をいくつか示します。

特殊文字
1つのルールにおいては、単一のスタート状態、またはカンマで区切られたスタート状態のリストのみを使用することができます。また、こうしたスタート状態の指定はルールの先頭になければなりません。次に示すものは正当です。
```
%x state1
%s state2
%%
<state1> "something"
<state2> "another thing"
<state, state2> "something else"
```
しかし、次に示すものは不当です。
```
%x state1
%s state2
%%
wrong<state1>
<state1><state2>"wrong"
<state2>"wrong"<state1>
```
排他的スタート状態
排他的スタート状態は、他のすべての状態を「無効」にするので強力です。これは、スキャナの内部においてもう1つのスキャナを効果的に定義できることを意味しています。これによりたとえば、スタート状態しだいで、CとPascalの両方をスキャンするスキャナを定義することが理論的には可能になります。以下のようなコードが持つ効果を想像してみてください。
```
%x PASCAL
%x C
%%
<PASCAL>begin     return(OPEN_BLOCK);
<PASCAL>end       return(CLOSE_BLOCK);
<C>{              return(OPEN_BLOCK);
<C>}              return(CLOSE_BLOCK);
```
スタート状態の名前
前述のとおり、スタート状態はそれ自身の名前空間を持っていません。その理由は、スタート状態が#defineとほとんど同じ方法で整数値として定義されているからです。このことは、整数値と同様、スタート状態の「スタック」のようなものを作成可能であることを意味しています。たとえば、
```
%{
    int last_state[MAX_STATES]
    int state_count = 0;
%}
%x FOO BAR baz
%%
FOO        {
              last_state[state_count] = FOO;
              state_count++;
              BEGIN(baz);
           }
BAR        {
              last_state[state_count] = BAR;
              state_count++;
              BEGIN(baz);
           }
<baz>rule 1
     ...
<baz>rule n
<baz>END   {
              statecount--;
              BEGIN(last_state[statecount]);
           }
```
はFOOとBARの両方によってbaz状態を活性化させ、 <baz>ENDというルールによって1つ前の状態に戻します。こうした「状態スタック」は将来、Flexの特徴的な機能になるかもしれません。 ⁴

Node:Start State Notes (Flex 2.5), Next:Start State Example, Previous:Start State Notes, Up:Start States

スタート状態に関する注意（Flex 2.5の補足情報）

Flex 2.5では、以下の新機能を利用できます。

ワイルドカード
スタート状態<*>には特殊な意味があり、すべてのスタート状態にマッチします。
たとえば、
```
%x state1
%%
<state1>"one" printf("two");
<*>"three"    printf("four");
```
は、
```
%s state1
%%
<state1>"one" printf("two");
"three"	      printf("four");
```
と同じ意味になります。
現在のスタート状態
マクロYY_STARTにより、現在のスタート状態を参照できます。
前節（Start State Notes）の「スタート状態の名前」に示した例では、現在のスタート状態を配列last_stateに格納する処理を以下のように記述していますが、
```
FOO        {
              last_state[state_count] = FOO;
              ...
           }
```
この代入は、
```
              last_state[state_count] = YY_START;
```
のように書き換えることができます。
Lexとの互換性のために、YYSTATEが、 YY_STARTの別名として定義されています。
スタート状態のスコープ
スタート状態のスコープを定義できます。これにより、同じスタート状態において複数のルールが存在するときに、その個々のルールにスタート状態を指定する必要がなくなります。
スタート状態のスコープの形式は、以下のとおりです。
```
<start_states>{
...
}
```
ここで、start_statesは、単一のスタート状態、または、カンマで区切られたスタート状態のリストです。スタート状態のスコープの境界は、{と}によって指定されます。スタート状態のスコープを入れ子にすることも可能です。 Activating Statesに示した例を、スタート状態のスコープを使って書き直すと以下のようになります。
```
%x COMMENT
%%
"{"            BEGIN(COMMENT);
<COMMENT>{
    "$R"
    "$I"
    "$M"
    ...
    "}"        BEGIN(INITIAL);
}
```
スタート状態スタック
スキャナ定義ファイルで%option stackを指定すると、スタート状態スタックを利用できます。スタート状態スタックを操作するために、以下の関数が提供されています。

void yy_push_state(int new_state)
現在のスタート状態をスタート状態スタックにプッシュし、 new_state状態に遷移します。
void yy_pop_state()
スタート状態スタックからスタート状態をポップし、そのポップされたスタート状態に遷移します。
int yy_top_state()
スタート状態スタックの先頭にあるスタート状態を返します（スタート状態スタックの内容は変更されません）。

前節（Start State Notes）の「スタート状態の名前」に示した例を、スタート状態スタックを使って書き直すと以下のようになります。
```
%option stack
%x FOO BAR baz
%%
FOO        {
              yy_push_state(baz);
           }
BAR        {
              yy_push_state(baz);
           }
<baz>rule 1
     ...
<baz>rule n
<baz>END   {
              yy_pop_state();
           }
```

Node:Start State Example, Previous:Start State Notes (Flex 2.5), Up:Start States

スタート状態の使用例

プログラミングにおいて、何かをする方法を学ぶのに最良の方法は、実際にそれをやってみることです。そのことに留意し、スタート状態をどのように使うことができるかを示す例を以下にあげます。

/*
 * dates.lex: 日付の異なる形式を識別するために
 *            スタート状態を使用する例
 */

%{
#include <ctype.h>

char month[20],dow[20],day[20],year[20];

%}
skip of|the|[ \t,]* /* この文字の並びを無視する */

mon  (mon(day)?)    /* 曜日の名前の長い形式と短い形式の */
tue  (tue(sday)?)   /* どちらにもマッチするように設定する */
wed  (wed(nesday)?)
thu  (thu(rsday)?)
fri  (fri(day)?)
sat  (sat(urday)?)
sun  (sun(day)?)
 /* 以下はすべての可能な曜日を表す */

day_of_the_week ({mon}|{tue}|{wed}|{thu}|{fri}|{sat}|{sun})

jan  (jan(uary)?)   /* すべての月について同様のことを行う */
feb  (feb(ruary)?)
mar  (mar(ch)?)
apr  (apr(il)?)
may  (may)
jun  (jun(e)?)
jul  (jul(y)?)
aug  (aug(ust)?)
sep  (sep(tember)?)
oct  (oct(ober)?)
nov  (nov(ember)?)
dec  (dec(ember)?)
 /* 以下はすべての可能な月の名前を表す */

first_half  ({jan}|{feb}|{mar}|{apr}|{may}|{jun})
second_half ({jul}|{aug}|{sep}|{oct}|{nov}|{dec})
month       {first_half}|{second_half}
 /*
  * 日、月、年の数値形式
  * これらは重複しているため、正しくパースするには、
  * スタート状態と日付の形式に関するある程度の知識
  * が必要であることに注意
  */

nday         [1-9]|[1-2][0-9]|3[0-1]
nmonth       [1-9]|1[0-2]
nyear        [0-9]{1,4}
 /* 年と日のための拡張子 */

year_ext    (ad|AD|bc|BC)?
day_ext     (st|nd|rd|th)?
  /*
   * このプログラムの最後にあるルールを使ってすべての無関係な
   * テキストを処理するために、非排他的なスタート状態を使う。
   * こうしないと、個々のスタート状態のブロックにルールを追加
   * しなければならなくなる。規模の大きいスキャナにおいては、
   * これは実行可能な選択肢であることが多い。なぜなら、ルール
   * の追加はスキャナのスピードに影響を与えないからである。
   * ここでは、簡潔さを優先させることにする
   */

%s LONG SHORT
%s DAY MONTH   /* 長い形式の日付のために追加した状態 */
%s YEAR_FIRST YEAR_LAST YFMONTH YLMONTH
%%

 /*
  * 曜日は常に最初に置かれ、後ろに続く日付の修飾子として
  * 機能するものと仮定される。よって、曜日は複数の日付形式
  * の間で共用可能である
  */

<LONG>{day_of_the_week} strcpy(dow,yytext);
 /*
  * 月-日-年という形式の日付を処理する
  * パース状態は
  * LONG->[月にマッチ]->DAY->LONG
  * のように遷移する
  */

<LONG>{month}         strcpy(month,yytext); BEGIN(DAY);
<DAY>{nday}{day_ext}  strcpy(day,yytext);   BEGIN(LONG);
 /*
  * 日-月-年という形式の日付を処理する
  * パース状態は
  * LONG->[日にマッチ]->MONTH->LONG
  * のように遷移する
  */

<LONG>{nday}{day_ext} strcpy(day,yytext);   BEGIN(MONTH);
<MONTH>{month}        strcpy(month,yytext); BEGIN(LONG);
 /*
  * 日付の年の部分は最後に置かれるものと考えられる。したがって、
  * 年を見つけたらパースされた日付を表示できる。もち
  * ろん、日付として不当なものであればゴミが出力されることになる
  */

<LONG>{nyear}{year_ext} {
                          printf("Long:\n");
                          printf("  DOW   : %s \n",dow);
                          printf("  Day   : %s \n",day);
                          printf("  Month : %s \n",month);
                          printf("  Year  : %s \n",yytext);
                          strcpy(dow,"");
                          strcpy(day,"");
                          strcpy(month,"");
                        }
 /*
  * 日-月-年という形式の日付を処理する
  * SHORT状態で数値形式の日を見つけた場合は、年が日付の最後の部分
  * になると仮定する
  * パース状態は
  * SHORT->[日にマッチ]->YEAR_LAST->YLMONTH->SHORT
  * のように遷移する
  */

<SHORT>{nday}        strcpy(day,yytext);  BEGIN(YEAR_LAST);
<YEAR_LAST>{nmonth}  strcpy(month,yytext);BEGIN(YLMONTH);
<YLMONTH>{nyear}     strcpy(year,yytext); BEGIN(SHORT);
 /*
  * 年-月-日という形式の日付を処理する
  * SHORT状態で数値形式の年を見つけた場合は、日が日付の最後の部分
  * になると仮定する
  * パース状態は
  * SHORT->[年にマッチ]->YEAR_FIRST->YFMONTH->SHORT
  * のように遷移する
  */

<SHORT>{nyear}        strcpy(year,yytext); BEGIN(YEAR_FIRST);
<YEAR_FIRST>{nmonth}  strcpy(month,yytext);BEGIN(YFMONTH);
<YFMONTH>{nday}       strcpy(day,yytext);  BEGIN(SHORT);
 /*
  * 数値形式の日付では、年は最初になることも最後になることも可能。
  * したがって、パースしたものをいつ表示すべきかを示すのに改行を使う
  */

<SHORT>\n               {
                          printf("Short:\n");
                          printf("  Day   : %s \n",day);
                          printf("  Month : %s \n",month);
                          printf("  Year  : %s \n",year);
                          strcpy(year,"");
                          strcpy(day,"");
                          strcpy(month,"");
                        }
 /*
  * 以下により、短い（数字）形式と長い（英数字）形式とを切り換える
  */

long\n     BEGIN(LONG);
short\n    BEGIN(SHORT);
 /*
  * 以下のルールは、無関係なテキストを見つけて破棄する
  * （マッチされたテキストはデフォルトではECHOされないが、
  *   マッチされなかったテキストはECHOされる。ピリオドは
  *   改行以外のすべての文字を見つける。改行は\nによって
  *   見つけられる）
  */

{skip}*
\n
.

この例は、さまざまな形式の日付をスキャンし、構成単位に分割します。たとえば、以下のものを正しくスキャンし、日付の個々の部分を識別します。

short
1989:12:23
1989:11:12
23:12:1989
11:12:1989
1989/12/23
1989/11/12
23/12/1989
11/12/1989
1989-12-23
1989-11-12
23-12-1989
11-12-1989
long
Friday the 5th of January, 1989
Friday, 5th of January, 1989
Friday, January 5th, 1989
Fri, January 5th, 1989
Fri, Jan 5th, 1989
Fri, Jan 5, 1989
FriJan 5, 1989
FriJan5, 1989
FriJan51989
Jan51989

ファイルの最初の部分では、月および日付の異なる部分に使われる数字形式を単に定義しています。この例では、ある特定の方法でスキャン処理が進行するよう強制するために、スタート状態を使います。たとえば、行の先頭で1989を見つければ、それが日と月の組み合わせではなく年であり、したがって、日付の次の部分が月に違いないことがわかり、スキャン処理がそのとおりに進むよう強制します。このことにより、非常に単純な状態駆動のパーサを効果的に作成したことになり、日付をその構成要素にうまく分割できるようになります（このスキャナの内部で起こっていることをフローチャートに描いてみれば、このことが明瞭に見てとれるでしょう）。

本書中の他のプログラム例と同様に、この例も

flex -i dates.lex
cc -o dates lex.yy.c -lfl

を実行することによりコンパイルできます。また、examplesサブディレクトリにおいて単にmake datesを実行することにより、コンパイルすることもできます。

Node:%option (Flex 2.5), Previous:Start States, Up:Flex Descriptions

%option（Flex 2.5の補足情報）

Flex 2.5では、スキャナ定義ファイルの中でさまざまなオプションを指定できます。オプションを指定するには、スキャナ定義ファイルの先頭（最初の%%よりも前の部分）に、%option指示子を記述します。

ほとんどの%option指示子は、以下の形式で指定されます。

%option option_name

オプションoption_nameの指定を無効にするためには、オプション名の前にnoを付けます。

%option nooption_name

以下に、コマンドラインオプションと同等の効果を持つ%option指示子を示します。各コマンドラインオプションの意味については、Command Line Switchesと Command Line Switches (Flex 2.5)を参照してください。

%option 7bit: -7オプション
%option 8bit: -8オプション
%option align: -Caオプション
%option backup: -bオプション
%option batch: -Bオプション
%option c++: -+オプション
%option caseful: -iオプションの否定
%option case-sensitive: -iオプションの否定
%option case-insensitive: -iオプション
%option caseless: -iオプション
%option debug: -dオプション
%option default: -sオプションの否定
%option ecs: -Ceオプション
%option fast: -Fオプション
%option full: -fオプション
%option interactive: -Iオプション
%option lex-compat: -lオプション
%option meta-ecs: -Cmオプション
%option output="file": -ofileオプション
%option perf-report: -pオプション
%option prefix="prefix": -Pprefixオプション
%option read: -Crオプション
%option stdout: -tオプション
%option verbose: -vオプション
%option warn: -wオプションの否定

次に、コマンドラインオプションでは代替できない%option指示子を示します。

%option array

yytextをcharの配列として定義します。これは、 %arrayと同じです。

%option always-interactive

入力を常に対話的に扱うスキャナを生成するよう指示します。これと%option never-interactiveのどちらも指定されない場合、生成されたスキャナは、ファイルをオープンするたびにisatty()を呼び出して、入力を対話的に（1文字ずつ）読み込むべきか否かを決定します。

%option main

生成されるスキャナに、以下のようなmain()関数を組み込むよう指示します。

int main()
	{
	yylex();
	return 0;
	}

これは、暗黙のうちに%option noyywrapを指定します。

%option never-interactive

入力を常に対話的に扱わないスキャナを生成するよう指示します。これと%option always-interactiveのどちらも指定されない場合、生成されたスキャナは、ファイルをオープンするたびにisatty()を呼び出して、入力を対話的に（1文字ずつ）読み込むべきか否かを決定します。

%option pointer

yytextをcharに対するポインタとして定義します。これは、%pointerと同じです。

%option reject

スキャナ定義ファイルの中でREJECTが使われていることを、Flexに通知します。 Flexは通常、定義ファイルの中でREJECTが使われているか否かを自分で調査しますが、この%option指示子の指定は、Flex自身による判定結果に優先します。

%option stack

スタート状態スタック（Start State Notes (Flex 2.5)を参照）を使用するためには、この%option指示子を指定しなければなりません。

%option stdinit

yyinをstdinで、yyoutをstdoutで、それぞれ初期化します。この%option指示子が指定されない場合、あるいは、%option nostdinitが指定された場合、 yyinとyyoutは、(FILE *)0（NULLポインタ）で初期化されます。

%option unput

%option nounputが指定されると、生成されるスキャナの中に、関数unput()が組み込まれません。 ⁵

%option yy_pop_state

%option noyy_pop_stateが指定されると、生成されるスキャナの中に、関数yy_pop_state()が組み込まれません。ただし、%option stackが指定されていない場合は、 %option noyy_pop_stateの指定の有無にかかわらず、関数yy_pop_state()は組み込まれません。

%option yy_push_state

%option noyy_push_stateが指定されると、生成されるスキャナの中に、関数yy_push_state()が組み込まれません。ただし、%option stackが指定されていない場合は、 %option noyy_push_stateの指定の有無にかかわらず、関数yy_push_state()は組み込まれません。

%option yy_scan_buffer

%option noyy_scan_bufferが指定されると、生成されるスキャナの中に、関数yy_scan_buffer()が組み込まれません。

%option yy_scan_bytes

%option noyy_scan_bytesが指定されると、生成されるスキャナの中に、関数yy_scan_bytes()が組み込まれません。

%option yy_scan_string

%option noyy_scan_stringが指定されると、生成されるスキャナの中に、関数yy_scan_string()が組み込まれません。

%option yy_top_state

%option noyy_top_stateが指定されると、生成されるスキャナの中に、関数yy_top_state()が組み込まれません。ただし、%option stackが指定されていない場合は、 %option noyy_top_stateの指定の有無にかかわらず、関数yy_top_state()は組み込まれません。

%option yyclass="classname"

これは、-+オプションが指定されている場合（すなわち、C++スキャナを生成する場合）にのみ有効です。これにより、classnameによって指定される名前のクラスが、 yyFlexLexerのサブクラスとして定義されます。実際にスキャン処理を実行するコードは、クラスclassnameのメンバ関数yylex()（classname::yylex()）に実装されます。詳細については、Flex and C++ (Flex 2.5)を参照してください。

%option yylineno

入力の行数をカウントして大域変数yylinenoに保持するスキャナを生成するよう指示します。

%option yymore

スキャナ定義ファイルの中でyymore()が使われていることをFlexに通知します。 Flexは通常、定義ファイルの中でyymore()が使われているか否かを自分で調査しますが、この%option指示子の指定は、Flex自身による判定結果に優先します。

%option yywrap

%option noyywrapが指定されると、yywrap()はマクロとして、

#define yywrap() 1

のように定義されます。この結果、ファイルの終端を検出したときに、スキャナは、ほかにスキャンすべきファイルは存在しないと判断するようになります。

Node:Interfacing to Flex, Next:Other Flex Features, Previous:Flex Descriptions, Up:Top

Flexとのインターフェイス

この章ではCおよびBisonと一緒にFlexを使う方法を説明します。 ⁶ C、Bisonのそれぞれについて非常に細かい説明が必要なため、本章は2つの部分に分かれています。その両方に、全般的なインターフェイス概念に関する節とプログラム例を示す節があります。

Node:Flex and C, Next:Flex and C (Flex 2.5), Up:Interfacing to Flex

FlexとC

Flexに対するCの主要なインターフェイスは、以下にあげるルーチンと変数によるものです。以下の節を読む際には、いくつかの細かな部分でFlexとLexとの間に相違点があるということを意識しておいてください。 Lexが提供していない関数がいくつかありますし、宣言の内容が違うものもあります。こうした相違点は、通常大きな問題にはなりません。というのは、相違のある関数は一般的にはあまり使われていないからです。相違点に関する詳細については、Flex and LexおよびFlex and POSIX を参照してください。

関数

説明とプログラム例

yylex()

yylex()は実際のスキャン処理を行う関数です。ファイル（デフォルトはstdin）を読み込み、パターンマッチングを行い、パターンに関連付けされたアクションを実行します。デフォルトでは、入力の終端に達するまでマッチングを行い、終端に達したところでゼロを返します（returnを使って、呼び出し側のプログラムにほかの値を返すことは可能です。これは、Flex and Bisonで説明しています）。したがって、インターフェイスを提供する簡単な方法の1つは、オプションのCコード領域の1つに以下のようなコードを追加することです。

#include <stdio.h>

int main(argc,argv)
int argc;
char *argv;
{
   yylex();
}

しかしこのような場合には、Flexライブラリ（-lfl）もしくはLexライブラリ（-ll）のいずれかをリンクして、そこからこれと同じようなmain()関数を取り込むことができます。この場合は、スキャナは単にファイルをスキャンして、ルールに関連付けされたアクションを実行するだけであるという点に注意してください。

yylex()の使い方としてもう1つよく見られるのが、マッチされたものがなんであるかを示す値を返させることです。これは、アクションにreturn文を追加することで行われます。 return文を見つけると、 yylex()は指定された値を返します。これが、 BisonによるパーサがFlexによるスキャナから情報を獲得する方法です。

ルールの中に、マッチされたテキストが何を表しているかを示すコードを返す return文があれば、以下のようなインターフェイスを使うことができます。

#include <stdio.h>

int main(argc,argv)
int argc;
char *argv;
{
   int return_code;
   while((return_code = yylex()) != 0){
       switch(return_code){
       case KEYWORD1:
          /* 何かを行う */
          break;
       case KEYWORD2:
          /* 何か別のことを行う */
          break;
            ...
       case KEYWORDn:
       }
   }
}

yylexのデフォルトの定義はint yylex(void)ですが、これはYY_DECLマクロを使うことによって変更できます。例を示すと、以下のコードはyylex()の名前をgettok()に、型をcharに対するポインタ型に変更し、パラメータbufferを受け取るように指定します。

#undef   YY_DECL
#define  YY_DECL char *gettok(char *buffer)

注意：ANSI対応でないCを使っている場合は以下のように定義しなければなりません。

#define YY_DECL char *gettok(buffer) \
                      char *buffer;

言い換えると、再宣言はターゲットとなるCコンパイラにとって正当な関数宣言でなければなりません。さらに、この再宣言は、ファイルの先頭にあるオプションのCコード領域になければならないという点に注意してください。

yyin

yyinは、 yylex()が文字を読み込む元となるファイルです。デフォルトはstdinですが、fopen()を使って変更できます。 yyinを読み込むデフォルトの方法は、複数文字から成るブロックを一度に読むというものです。これは、YY_INPUTマクロによって変更できます。 YY_INPUTマクロは、ファイルではなく文字列をスキャンするためのスキャナを生成するのに便利です。 YY_INPUTを定義する方法は以下のとおりです。

YY_INPUT(buffer,result,max_size)

ここで、bufferは入力バッファ、resultは読み込まれた文字数がセットされる変数、max_sizeはbufferのサイズです。以下に、一度に1文字ずつ読み込むという入力方法に変更する再定義の例を示します。この方法を使うとかなり遅くなるので、おすすめはできません。

#undef   YY_INPUT
#define  YY_INPUT(buffer,result,max_size) \
         {\
            buffer[0] = getchar();\
            if(buffer[0] == EOF)\
               result = YY_NULL;\
            else\
               result = 1;\
         }

注意：この再宣言は、ファイルの先頭にあるオプションの Cコード領域になければなりません。

yyout

yyoutはスキャナがECHOの出力を書き込むファイルです。デフォルトはstdoutですが、これもfopen()を呼び出すことで変更できます。

yytext

yytextは最後にマッチされた文字列、つまり最後に認識されたトークンを含む大域変数です。 yytextの正しい外部定義は、Lexの場合のcharの配列とは異なり、 charに対するポインタ型である点に注意してください。 ⁷ つまり、yytextは

extern char yytext[];

ではなく、常に

extern char *yytext;

のように宣言されなければならないということです。

このようになっている理由は性能です。 yytextが配列であると、スキャナ中でそれを操作するコードは、コピー処理をたくさん行う必要があります。これに対してyytextがポインタである場合には、このようなことは必要ありません。

通常は、yytextは変更すべきではありません。 yytextの内容が変更される必要がある場合には、代わりのバッファが使われるべきです（examplesサブディレクトリの yymore2.lexファイルでは、yytextを直接操作する技法が示されています。ただし、このようなやり方はおすすめできません）。

yyleng

yylengは、最後に認識されたトークンの長さを保持する大域変数です。

yywrap()

yywrapは、yyinの終端に達したときに呼び出される関数です。この関数がTRUE（ゼロ以外）を返すとスキャナは終了し、FALSE（ゼロ）を返すと、yyinが次の入力ファイルを指すように設定されたものと仮定して、スキャン処理が続行されます。

現在のところyywrap()は、常に1を返すよう定義されているマクロです。このため、再定義するには、まず最初に#undefで定義解除しなければなりません。 Lexでは、yywrap()は関数です。 Flexも将来のある時点で、これを関数として定義することになるでしょう。 ⁸

yymore()

yymore() は、次に認識されるトークンでyytextの内容を更新するのではなく、その時点の yytextの内容の後ろにそのトークンを追加するようFlexに通知する関数です。したがって、以下の例に対してfoobarという文字の並びを入力として与えると、 stdoutにfoofoobarという文字の並びが書き込まれます。

%%
foo    ECHO; yymore();
bar    ECHO;

これは、まずfooルールによってfooという文字の並びが認識されて ECHOされ、次にbarという文字の並びが認識されてyytextの内容の後ろに追加された後に、foobarという文字の並びがECHO されるからです。

もう少し現実的な例を取り上げましょう。以下のコードは複数行の文字列を処理するのにyymore()を使っています。

/*
 *  yymore.lex: yymore()を有効に使う例
 */

%{
#include <memory.h>
void yyerror(char *message)
{
  printf("Error: %s\n",message);
}

%}
%x STRING

%%
\"   BEGIN(STRING);

<STRING>[^\\\n"]* yymore();
<STRING><<EOF>> {
              yyerror("EOF in string.");
              BEGIN(INITIAL);
            }
<STRING>\n  {
              yyerror("Unterminated string.");
              BEGIN(INITIAL);
            }
<STRING>\\\n yymore(); /* 複数行にわたる
                        * 文字列を処理する
                        */
<STRING>\"  {
              yytext[yyleng-1] = '\0';
              printf("string = \"%s\"",yytext);
              BEGIN(INITIAL);
            }
%%

この例では、エスケープシーケンスの変換がまったく行われていないので、文字列に対してさらに処理が必要である点に注意してください。この例は、文字列リテラルの処理において、エスケープシーケンスを処理する、より役に立つ形式に拡張されます。

yyless(n)

yyless()は、yymore()とほぼ反対のことを行うものです。この関数は、最初のn文字以外のすべてを戻します。戻された文字の並びは、次のトークンをマッチするのに使われ、yylengと yytextには、この変化を反映した値が設定されます。引数nにゼロを指定してyyless()を呼び出すと、全入力データが戻され、スキャナは（BEGIN、またはそれに類似のものでデフォルトの動作が変更されないかぎり）無限ループに入ります。たとえば、次のコードにfoobarという文字の並びを入力として与えると、 foobarbarという文字の並びが出力されます。

%%
foobar      ECHO; yyless(3);
[a-z]+      ECHO;

これは、foobarが認識されECHOされた後に、 barが戻されるからです。となると、次にマッチするのは（[a-z]+というルールでマッチされる） barだけで、これが次にECHOされることになります。

input()

input()は、yyinから次の文字を取って返す関数です。これは、標準的なFlexルールシステムを使ったのではうまく扱えないケースを処理するのによく使われます。たとえば、ほとんどの言語におけるコメントは、これを使って処理することができます。これを使う理由は、

%%
"/*".*"*/"

が、ピリオドが改行以外の任意の文字にマッチしてしまうために複数行にわたるコメントをうまく処理できず、また、

%%
"/*"[.\n]*"*/"

は、文字クラスが任意の文字にマッチしてしまうために、バッファをオーバーフローさせるか、さもなければファイルの内容をすべて読み込んでしまうからです（実際には、排他的スタート状態を使うことで、こうしたことを非常にエレガントな方法で処理できます。プログラム例については、役に立つコード集を参照してください。しかし、POSIXによりサポートされているにもかかわらず、ここで必要になるいくつかの機能をLexが提供していないために、この方法には移植性がありません）。 Cのコメントは以下のようにして移植性のある方法で処理できます。

%%
"/*" {
        int a,b;

        a = input();
        while(a != EOF){
          b = input();
          if(a == '*' && b == '/'){
            break;
           }else{
            a = b;
           }
         }
        if(a == EOF){
          error_message("EOF in comment");
        }
      }

注意：スキャナがC++コンパイラを使ってコンパイルされる場合は、この関数inputはyyinputという名前になります。これは、inputという名前が同一名のC++ストリームと衝突するからです。また、Flexではinput()はyytextの内容を破壊しますが、 Lexではyytextは変更されずそのまま残ります。これは将来のリリースで修正される予定です。

unput(c)

unput()は、文字cが次にスキャンされる文字になるように、文字cを入力ストリームに置く関数です。たとえば、

%%
foo  unput('b');

はfooをbで置き換えます。これは、fooにマッチしてbを戻し、このbが次にスキャンされる文字になるからです。デフォルトのルールにより、bはstdoutに書き込まれます。

1つの文字が次にスキャンされる文字になるということには1つ微妙な点があって、それは、文字列を入力ストリームに置きたい場合には、逆順に行わなければならないということです。以下に例を示します。

foobar  {
           char  *baz = "baz";
           int   i    = strlen(baz)-1;

           while(i >= 0){
              unput(baz[i]);
              i--;
           }
        }

これは、foobarがマッチされたときに、入力ストリームにbazを置きます。以下は、してはならないことを示す例です。

/*
 * unput.l : unput()を使って行ってはならない
 *           処理の例
 */

%{
#include <stdio.h>

void putback_yytext(void);
%}
%%
foobar   putback_yytext();
raboof   putback_yytext();
%%
void putback_yytext(void)
{
    int   i;
    int   l = strlen(yytext);
    char  buffer[YY_BUF_SIZE];

    strcpy(buffer,yytext);
    printf("Got: %s\n",yytext);
    for(i=0; i<l; i++){
       unput(buffer[i]);
    }
}

この例にfoobarを入力として与えると、まずfoobarにマッチし、次にraboofにマッチする無限ループに陥ります。

注意：input()と同様にunput()もyytextの内容を破壊します。⁹つまり、 yytextから文字情報を返したい場合には、上の例に示されるように、まずyytextの内容をコピーしなければならないことを意味しています。

yyterminate()

アクションの中で呼び出されると、yyterminate()はスキャナの実行を終了させ、その後にyylex()が0を返します。この後は、yyrestart()が呼び出されないかぎり、 yylex()を呼び出してもすぐに復帰してしまいます。

yyrestart(file)

yyrestart()は、スキャナの実行を再開するようFlexに通知する関数です。これは引数を1つだけ、すなわち、スキャンの対象となるファイル（通常はyyin）を取ります。これは、EOFを処理するために使うこともできますし、また、Flexに割り込みをかけ、その後に再開させることができるようにするために使うこともできます（Flexスキャナは再入可能ではないので、このようなことが必要になります）。

YY_NEW_FILE

yyinが新しいファイルを指すよう変更され、処理が継続されるべきであるということをFlexに通知するマクロです。 ¹⁰ 以下に例を示します。

/*
 * cat.lex: YY_NEW_FILEの使用例
 */

%{
#include <stdio.h>
#define ERRORMESS "Unable to open %s\n"

char **names = NULL;
int  current = 1;
%}
%%
<<EOF>> {
         current += 1;
         if(names[current] != NULL){
            yyin = fopen(names[current],"r");
            if(yyin == NULL){
              fprintf(stderr,ERRORMESS,
                       names[current]);
              yyterminate();
            }
            YY_NEW_FILE;
         } else {
           yyterminate();
         }
        }
%%
int main(int argc, char **argv)
{
  if(argc < 2){
     fprintf(stderr,"Usage: cat files....\n");
     exit(1);
  }
  names = argv;
  yyin = fopen(names[current],"r");
  if(yyin == NULL){
    fprintf(stderr,ERRORMESS,names[current]);
    yyterminate();
  }
  yylex();
}

ECHO

yytextの内容をyyoutに書き込むマクロです。

REJECT

REJECTは、その時点においてマッチしているものを受け入れず、次にもっともよくマッチするものを受け入れるようスキャナに通知するマクロです。スキャナはマッチするものの中で最長のものを探し、マッチするものが2つあってその長さが同じ場合は、記述ファイルにおいて最初に定義されているほうを選択します。つまり、認識されるテキストの長さは、同一の長さになることも短くなることもあるということを意味しています。 REJECTを使った後は、yytextとyylengは新しい値を取ります。 REJECTに関して知っておくべき重要な点が2つあります。 1つは、REJECTは分岐命令であり、決して返ってこないので、 REJECTの後ろに記述されたアクションは実行されないということです。もう1つは、REJECTとファストテーブル（fast table、-F）は一緒に使うことはできないということです。以下に簡単な例を示します。

/*
 * reject.lex: REJECTとunput()を悪用する例
 */

%%
UNIX   {
            unput('U'); unput('N');
            unput('G'); unput('\0');
            REJECT;
       }
GNU    printf("GNU is Not Unix!\n");
%%

この例は、新方式のテキスト代替の技法を示しています。 UNIXにマッチするものが見つかると、unput()によって GNUという文字の並びが戻され、その時点におけるスキャンバッファの内容が上書きされます。次にREJECTにより分岐が行われ、別のものにマッチするようスキャナに対して通知が行われます。 GNUがバッファに書き込まれたので、これが次にマッチされ、そのアクションが実行されます。以下に、起こりうる結果の例を示します。

UNIX return
GNU is Not Unix!

実際のところは、FlexにおいてREJECTの用途はほんの少ししかありません。上記以外では、重複するパターンや状態の変更に使うことができます。例を示すと、以下のようになります。

nday         [1-9]|[1-2][0-9]|3[0-1]
nmonth       [1-9]|1[0-2]
nyear        [0-9]{1,4}

%x DAY MONTH YEAR
%%

{nday}           BEGIN(DAY);   REJECT;
<DAY>{nday}
     ...
{nmonth}         BEGIN(MONTH); REJECT;
<MONTH>{nday}
     ...
{nyear}          BEGIN(YEAR);  REJECT;
<YEAR>{nday}
     ...

この例では、日付の形式は重複しており、最初に認識された構成要素によって、どのように日付をパースするのかを決定します。しかし、この例はやや不自然な感じがします。というのは、ちょっと考えれば、REJECTを使わずに、より効率的なスキャナにすることができるからです。これは、スタート状態の使用例に示しています。

BEGIN

BEGINは、スキャナをある特定のスタート状態にするためのマクロです。 BEGINに続く名前はスタート状態の名前です。たとえば、

%x FLOAT
%%
floats   BEGIN(FLOAT)
<FLOAT>some_rule some_action
       ...

は、 floatsという単語がマッチしたときに、スタート状態をFLOATに設定します（詳細については、see Start States Explained）。

YY_USER_ACTION

YY_USER_ACTIONは、ルールセクション中のどのアクションよりも前に実行されるアクションを定義するマクロです。これは、以下の例で示すように、yytextの内容の小文字から大文字への変換などを行うのに役に立ちます。

/*
 * user_act.lex: YY_USER_ACTIONを使う
 *               ユーザーアクションの例
 */

%{

#include <ctype.h>

void user_action(void);
#define YY_USER_ACTION user_action();

%}

%%

.*         ECHO;
\n         ECHO;

%%
/*
 * このユーザーアクションはすべての文字を
 * 単に大文字に変換する
 */

void user_action(void)
{
  int loop;

  for(loop=0; loop<yyleng; loop++){
    if(islower(yytext[loop])){
       yytext[loop] = toupper(yytext[loop]);
    }
  }
}

これは、すべての入力文字を単に大文字に変換してECHOします。 YY_USER_ACTIONのデフォルトの設定では、何も実行されません。

YY_USER_INIT

YY_USER_INITは、スキャン処理が開始される前に実行されるアクションを定義するマクロです。基本的には、main()関数の中で、yylex()を呼び出す文の前に同様のコードを記述するのと同じことです。以下に簡単な例を示します。

/*
 * userinit.lex: YY_USER_INITを使う例
 */

%{
#define YY_USER_INIT open_input_file()

extern FILE *yyin;
void open_input_file(void)
{
  char *file_name,buffer[1024];

  yyin      = NULL;
  while(yyin == NULL){
    printf("Input file: ");
    file_name = fgets(buffer,1024,stdin);
    if(file_name){
      file_name[strlen(file_name)-1] = '\0';
      yyin = fopen(file_name,"r");
      if(yyin == NULL){
        printf("Unable to open \"%s\"\n",
               file_name);
      }
    } else {
      printf("stdin\n");
      yyin = stdin;
      break;
    }
  }
}

%}
%%

これは、ファイルがオープンされるかEOFが検出されるまで、入力ファイル名を入力するようユーザーに催促します。 EOFが検出された場合は、入力元はデフォルトでstdinになります。これは以下と同じことです。

/*
 * この例は、前の例と同じことをYY_USER_INITを
 * 使わずに行う
 */

%{
void open_input_file(void)
{
  char *file_name,buffer[1024];

  yyin      = NULL;
  while(yyin == NULL){
    printf("Input file: ");
    file_name = fgets(buffer,1024,stdin);
    if(file_name){
      file_name[strlen(file_name)-1] = '\0';
      yyin = fopen(file_name,"r");
      if(yyin == NULL){
        printf("Unable to open \"%s\"\n",
               file_name);
      }
    } else {
      printf("stdin\n");
      yyin = stdin;
      break;
    }
  }
}

%}
%%
%%
int main(int argc, char *argv[])
{
   open_input_file();
   yylex();
}

YY_BREAK

YY_BREAKはマクロです。インターフェイス的な機能というよりも、むしろ生成されるコードを変更するために使うことができるものです。

スキャナ中において、すべてのアクションは1つの大きなswitch文の要素であり、デフォルトでCのbreak;文に置き換えられるYY_BREAK によって区切られます。ルールのアクション部が多くのreturn文を含んでいる場合、コンパイラが statement not reachedというエラーメッセージをたくさん出力するかもしれません。 YY_BREAKを再定義することによって、この警告メッセージの出力を止めることが可能です。再定義は、セミコロンを含む正当なCの文でなければなりません。
注意：YY_BREAKを再定義して空にするのであれば、アクションの最後は必ずreturn;かbreak;になるようにしてください。

Node:Flex and C (Flex 2.5), Next:An Example of Flex and C, Previous:Flex and C, Up:Interfacing to Flex

FlexとC（Flex 2.5の補足情報）

Flex 2.5では、前節（Flex and C）で説明されていない、以下のマクロもサポートされています。

yy_set_interactive(is_interactive): カレントバッファを、対話的なものとみなすか、非対話的なものとみなすかを制御します。引数is_interactiveにゼロ以外の値を渡すと、カレントバッファは対話的なものとみなされ、ゼロを渡すと、非対話的なものとみなされます。 yy_set_interactive()による指定は、%option always-interactiveや %option never-interactiveによる指定に優先します。このマクロは、バッファからのスキャン処理が始まるよりも前に呼び出されなければなりません。
yy_set_bol(at_bol): バッファは、さまざまなコンテキスト情報を保持しています。たとえば、行頭を表す^を含むルールが適用されるのは、バッファ内の現在位置が実際に行の先頭である場合だけですが、現在位置が行の先頭にあるか否かという情報は、バッファのコンテキスト情報として保持されています。
マクロyy_set_bol()は、バッファ内の現在位置が行の先頭にあるか否かを表すコンテキスト情報を設定します。引数にゼロ以外の値を渡すと、バッファ内の現在位置は行の先頭である、というコンテキスト情報がセットされます。したがって、次にトークンのマッチ処理が行われるときには、行頭を表す^を含むルールの適用が試みられます。逆に、引数にゼロを渡すと、バッファ内の現在位置は行の先頭ではないことになり、次にトークンのマッチ処理が行われるときには、行頭を表す^を含むルールの適用が試みられなくなります。
YY_AT_BOL(): 次にトークンのマッチ処理が行われるときに、行頭を表す^を含むルールの適用が試みられるようなコンテキスト情報がセットされている場合には、ゼロ以外の値を返します。それ以外の場合は、ゼロを返します。

Node:An Example of Flex and C, Next:Flex and Bison, Previous:Flex and C (Flex 2.5), Up:Interfacing to Flex

FlexとCの簡単なプログラム例

ある単語が現れたときに、それを別の単語に置き換える必要が生じることがよくあります。たとえば、ある名前が現れるたびに、それをある1つの環境変数の値で置き換えてくれるユーティリティを作るとしましょう。そして、以下のようなことができるように、そのユーティリティがフィルタとして動作するようにさせます。

nick% myname   < infile | more
nick% myname   < infile > outfile

以下に、こうしたことを実現する方法を示すFlexファイルの簡単な例をあげます。

/*
 * myname.lex : トークンの置き換えを行うFlexプログラム
 *              のサンプル
 */

%%

%NAME     { printf("%s",getenv("LOGNAME")); }
%HOST     { printf("%s",getenv("HOST"));    }
%HOSTTYPE { printf("%s",getenv("HOSTTYPE"));}
%HOME     { printf("%s",getenv("HOME"));    }

%%

このソースファイルはexamplesサブディレクトリにあり、その名前はmyname.lexです。これをビルドするには、examplesサブディレクトリに移動して make mynameを実行するか、以下を実行します。

flex myname.lex
cc lex.yy.c -o myname -lfl

ここで-lflは、リンカに対してFlexライブラリをリンクするよう通知します。現在のところ、Flexライブラリにはデフォルトのmain()関数だけが含まれています。将来のバージョンのFlexでは、他の関数も含まれるようになるでしょう。 Flexライブラリがインストールされていない場合は、この部分は-llでなければなりません。

いずれの場合でも、最終的にはmynameという名前の実行ファイルが生成されるはずです。これは、以下のような変換処理を実行するフィルタです。

%NAME: ユーザーのログイン名に置き換えられます。
%HOST: ユーザーのホストコンピュータ名に置き換えられます。
%HOSTTYPE: ユーザーのホストコンピュータのマシンタイプに置き換えられます。
%HOME: ユーザーのホームディレクトリを表すパスに置き換えられます。

したがって、以下のような内容を持つファイルmyname.txtを作成して、

Hello, my name is %NAME.  Actually
"%NAME" isn't my real name, it is the
alias I use when I'm on %HOST, which
is the %HOSTTYPE I use.  My HOME
directory is %HOME.

以下を実行すると、

myname < myname.txt

以下のテキストに似たものがstdoutへ書き込まれます。

Hello, my name is foobar.  Actually
"foobar" isn't my real name, it is the
alias I use when I'm on baz, which
is the cray I use.  My HOME
directory is /home/foo/foobar.

このプログラムがうまく動作するのは、yyinとyyoutがデフォルトでは stdin、stdoutにそれぞれ割り当てられ、かつ、デフォルトのアクションがyyinの内容をyyoutにコピーするからです。また、個々のルールに対応する唯一のアクションが単一行で記述されているため、 { }は必要ではないことに注意してください。このような場合には、アクションを{ }で囲むか否かは、個人的な好みの問題になります。

これが、引用符で囲まれた部分にあるものも含めて、指定された名前が現れるところ すべてにマッチしたことに気がつきましたか？　 Flexにおいては、引用符で囲まれた部分にあるものにマッチさせたくない場合には、それに対応するルールを作成することにより、そうしないよう明示的にFlexに通知しなければなりません。以下に例を示します。

/*
 * myname2.lex : トークンの置き換えを行うFlexプログラムの例
 */

%{
#include <stdio.h>
%}

%x STRING
%%
\"                ECHO; BEGIN(STRING);
<STRING>[^\"\n]*  ECHO;
<STRING>\"        ECHO; BEGIN(INITIAL);
%NAME     { printf("%s",getenv("LOGNAME")); }
%HOST     { printf("%s",getenv("HOST"));    }
%HOSTTYPE { printf("%s",getenv("HOSTTYPE"));}
%HOME     { printf("%s",getenv("HOME"));    }

この例では、排他的スタート状態を使って、文字列中のテキストが変更されることのないようにしています。この例もexamplesサブディレクトリにあるもので、その名前はmyname2.lexです。

Node:Flex and Bison, Next:Another Example of Flex and Bison, Previous:An Example of Flex and C, Up:Interfacing to Flex

FlexとBison

Bisonは、Flexと同様、ある記述情報を受け取って、それをもとにCのコードを生成するプログラムです。両者の違いは、 BisonがCやPascalのような言語の文法に関する記述情報を入力として受け取り、その記述情報からパーサを生成する点にあります。 FlexとBisonを結合することにより、言語の字句解析と構文解析の両方を処理できるようになります（これは、コンパイラデザインにおいてもっとも容易に自動化できる部分です）。

生成されるパーサが機能するためには、 Bisonはyylex()という関数を必要とします。この関数はユーザーによって提供され、呼び出されたときに、パースされている言語のある要素を表す整数値をBisonに返します。 Flexにおいてスキャン処理を行うルーチンはyylex()であり、デフォルトでは整数値を返します。これにより、FlexとBisonを一緒に使うのは非常に簡単になります。

警告： 以下の節では、読者がBisonの基本的なパーサの宣言を理解しているものと仮定します。 Bisonを使った経験のない人には、パーサの定義は混乱をもたらす可能性がありますので、先に進む前にぜひBisonのマニュアル¹¹を読んでください。 Bisonに興味のない人は、この節全体を飛ばしてもかまいません。

Node:Interfacing Flex and Bison, Next:YYSTYPE and yylval, Up:Flex and Bison

FlexとBisonのインターフェイス

FlexとBisonの間で情報を渡す基本的な方法は、関数yylex()を使うことです。これは、Flexにより生成されるスキャナにおいて、スキャン処理を実行する関数の名前です。 Flexの入力ファイルのアクション部分においてreturn文を使うことによって、単なる0や1以外の値を返すことができます。この方法で、 yylex()は最後に認識されたトークンを表す整数値を返すことができます。

Bisonを-dオプション付きで使うと、 Bisonは.tab.hという拡張子を持つファイルを生成します。このファイルには、記述情報中にある正当なトークンの1つ1つに対する一意な定義情報が含まれます。この出力情報は、特にスキャナによって使用されることを想定して設計されています。このファイルをFlexにより生成されたスキャナに含めることで、 2つのプログラムの間に非常に明確なインターフェイスを作ることができます。例として、以下にBisonのファイルを示します。このファイルの名前をexpr.yとしましょう。

/*
 * expr.y : Bisonマニュアル中の例に基づく
 *          Bisonによる簡単な表現式パーサ
 */

%{
#include <stdio.h>
#include <math.h>

%}
%union {
   float val;
}

%token NUMBER
%token PLUS MINUS MULT DIV EXPON
%token EOL
%token LB RB
%left  MINUS PLUS
%left  MULT DIV
%right EXPON

%type  <val> exp NUMBER
%%
input   :
        | input line
        ;
line    : EOL
        | exp EOL { printf("%g\n",$1);}
exp     : NUMBER                 { $$ = $1;        }
        | exp PLUS  exp          { $$ = $1 + $3;   }
        | exp MINUS exp          { $$ = $1 - $3;   }
        | exp MULT  exp          { $$ = $1 * $3;   }
        | exp DIV   exp          { $$ = $1 / $3;   }
        | MINUS  exp %prec MINUS { $$ = -$2;       }
        | exp EXPON exp          { $$ = pow($1,$3);}
        | LB exp RB              { $$ = $2;        }
        ;

%%
void yyerror(char *s)
{
  printf("%s\n",s);
}
int main()
{
  yyparse();
}

これは非常に簡単な計算機の文法定義です。

-y -dオプション付きで呼び出されると、 Bisonはy.tab.hというファイルを生成します。このファイルには以下のような定義が含まれます。

typedef union  {
   float val;
} YYSTYPE;
extern YYSTYPE yylval;
#define NUMBER  258
#define PLUS    259
#define MINUS   260
#define MULT    261
#define DIV     262
#define EXPON   263
#define EOL     264
#define LB      265
#define RB      266

Flexがトークンの値を正しくBisonに返すことができるように、（#includeを使って）これをスキャナに含めることができます。そのコードは以下のようなものになります。

/*
 * expr.lex : 簡単な表現式パーサのためのスキャナ
 */

%{
#include "y.tab.h"
%}

%%
[0-9]+     { yylval.val = atof(yytext);
             return(NUMBER);
           }
[0-9]+\.[0-9]+ {
             sscanf(yytext,"%f",&yylval.val);
             return(NUMBER);
           }
"+"        return(PLUS);
"-"        return(MINUS);
"*"        return(MULT);
"/"        return(DIV);
"^"        return(EXPON);
"("        return(LB);
")"        return(RB);
\n         return(EOL);
.          { yyerror("Illegal character");
             return(EOL);
           }
%%

上記のファイルは、以下のようにしてコンパイルできます。

bison -d -y expr.y
flex -I  expr.lex
cc -o expr y.tab.c lex.yy.c alloca.c

また、この例のソースが手元にあれば、examplesサブディレクトリにおいて make exprを実行するだけでコンパイルできます。どちらの方法でも、exprという名前の簡単な計算機が生成されます。これは以下のような表現式をパースして、その結果を出力します。

1 + 2 * (199*2)

これを見ておわかりのように、この種のインターフェイスは非常に柔軟であり、かつ、保守も非常に容易です。（トークンを定義する名前が変わらないかぎり）BisonとFlexの間のインターフェイスを変更することなく、Flex、Bisonいずれの入力情報においても、機能の追加や削除、定義やコードの変更を行うことが可能です。

この例では、FlexとBisonの間で情報を渡すための別の方法を導入していることに注意してください。この例では、数字の値をBisonに返すのにyylvalを使っています。これについては次の節でより詳しく説明します。ここではとりあえず、return文の使い方を覚えてください。

注意：これは単純な例です。表現式のパース処理についてより詳しく知りたい方は、 Bisonのマニュアルを参照してください。

Node:YYSTYPE and yylval, Previous:Interfacing Flex and Bison, Up:Flex and Bison

YYSTYPEとyylval

FlexからBisonに対して、単なる整数値以上の情報を渡す必要の生じることがよくあります。たとえば、コンパイラにおいては、どのような種類のトークンが認識されたかだけではなく、そのトークンの値についても知る必要のある場合がよくあります。文字列、文字、および数値定数などが良い例です。ここで問題なのは、どのようにしてFlexにこうした情報を返させるかです。

その答えは、Bisonが持っている%union文です。これは、YYSTYPEという型を定義するものです。 YYSTYPEは、パーサ定義中において使われるすべての正当なデータ型の共用体（union）です。 Bisonが現在のパース状態に関連づけたデータを保存するために使う、 YYSTYPE型の変数yylvalというものがあり、Flexからyylval に値を設定することができるので、トークンの型だけでなく、それ以上の情報を Bisonに返すことができます。

Bisonにおいて%unionを宣言して-dオプションを使うと、Bisonは .tab.hという拡張子を持つファイルを作成して、そこにトークンの定義情報だけでなく、YYSTYPEとyylvalの宣言も含めます。したがって、yylvalにアクセスするためにしなければならないことは、 Flexの定義情報の中にこの.tab.hファイルをインクルードすることだけです。これは、追加のCコードセクションにおける定義の先頭でインクルードしなければなりません（see Interfacing Flex and Bison）。

注意：初期のバージョンのBisonは、自動的にYYSTYPEと yylvalの宣言を生成しません。この場合には、より新しいバージョンのBisonを入手するか、もしくは、Flexの定義ファイルの先頭においてYYSTYPEとyylvalを宣言する必要があります。

Node:Another Example of Flex and Bison, Next:Flex and C++ (Flex 2.5), Previous:Flex and Bison, Up:Interfacing to Flex

FlexとBisonのもう1つのプログラム例

コードを読むのは、プログラミングのしかたを学ぶ良い方法です。そこで、Flex、Bisonのインターフェイス例をもう1つ示すことにします。次の例では、拡張してデータベースを操作するために使うことができるような、小規模な言語のための簡単なパーサを作ります。

Node:The Database Language, Next:The Implementation, Up:Another Example of Flex and Bison

インターフェイス言語

データベースとのインターフェイス言語は、英語の非常に小さなサブセットになります。文法はおおよそ以下のようになります。

command_list     ::= sentence {sentence ...}
sentence         ::= verb_phrase noun_phrase position_phrase
                     adverb period
verb_phrase      ::= VERB | adverb VERB
noun_phrase      ::= declared_noun | qualified_noun | noun
declared_noun    ::= declarator NOUN
declarator       ::= THIS | THAT | THE | THOSE
qualified_noun   ::= qualifier NOUN
qualifier        ::= SOME | MANY | ALL { declarator } NOUN
position_phrase  ::= position declarator NOUN  | empty
position         ::= IN | ON | AT
adverb           ::= ADVERB | empty

結果として作成されるプログラムは、以下のような文章を受け付けます。

FIND MEN
QUICKLY FIND MEN
FIND ALL MEN ON THE NETWORK
QUICKLY FIND ALL MEN ON THE NETWORK
FIND ALL MEN ON THE NETWORK QUICKLY

この例では、BisonとFlexの間のインターフェイスが明確に示されるよう、文章の簡単な解析結果が表示されます。このプログラムを試しに実行してみると、その表示結果は大体以下のようになります。

% front
FIND MEN
I understand that sentence.
VP = FIND
NP = MEN
PP =
AD =
QUICKLY FIND ALL THE MEN ON THE NETWORK
I understand that sentence.
VP = QUICKLY FIND
NP = ALL THE MEN
PP = ON THE NETWORK
AD =
^C
%

これは特別便利なものではありません。というのは、これは文章の構成要素を表示する以外に何も行わないからです。しかし、そこには拡張のためのフックもありますし、一般的な技法も示されています。より一般的な形式の文章を受け付けるよう、この例を拡張してみてください。ほとんどの場合、文章は動詞句（VERB）と名詞句（NOUN）に分割できますが、所有格名詞や名詞の後ろに名詞が続く場合など、文章を構成する他の要素も許容されるようにする必要があります（FIND ALL JONE'S CAT NAMESのような文章をどうやってパースするかを想像してみてください）。 Bisonの文法やその使い方に関する詳しい説明については、Bisonのマニュアルを参照してください。

Node:The Implementation, Next:Notes on the Implementation, Previous:The Database Language, Up:Another Example of Flex and Bison

実装：コマンド文パーサ

すでに、小規模な言語については説明しました。次にそれを実装してみることにしましょう。以下のファイルがこれを実現します。

注意：これはあくまでも1つの例としてみてください。特に文法の部分は、英語のパース処理としてはあまり良い例ではありません。

以下はBisonのファイルです。 %unionの部分、および、yylvalにアクセスするために$$と $nを使う方法に注目してください。

/* Cコードはファイルの先頭で提供する */

%{

#include <stdio.h>
#include <string.h>

extern int  yylexlinenum;  /* lex.yy.cに存在する */
extern char *yytext;       /* カレントトークン   */

%}
/* キーワードと予約語がここから始まる */

%union{                    /* これはデータの共用体 */
    char   name[128];      /* 名前                 */
}
/*------------- 予約語 ------------------*/

%token PERIOD
%token NEWLINE
%token POSITIONAL
%token VERB
%token ADVERB
%token PROPER_NOUN
%token NOUN
%token DECLARATIVE
%token CONDITIONAL

%type  <name> declarative
%type  <name> verb_phrase
%type  <name> noun_phrase
%type  <name> position_phrase
%type  <name> adverb
%type  <name> POSITIONAL VERB ADVERB PROPER_NOUN
%type  <name> NOUN DECLARATIVE CONDITIONAL

%%
sentence_list : sentence
              | sentence_list NEWLINE sentence
              ;

sentence : verb_phrase noun_phrase position_phrase
           adverb period
           {
             printf("I understand that sentence.\n");
             printf("VP = %s \n",$1);
             printf("NP = %s \n",$2);
             printf("PP = %s \n",$3);
             printf("AD = %s \n",$4);
           }
         | { yyerror("That's a strange sentence!");  }
         ;
position_phrase : POSITIONAL  declarative PROPER_NOUN
                  {
                    sprintf($$,"%s %s %s",$1,$2,$3);
                  }
                | /* 空 */ { strcpy($$,""); }
                ;

verb_phrase : VERB { strcpy($$,$1); strcat($$," "); }
            | adverb VERB
              {
                sprintf($$,"%s %s",$1,$2);
              }
            ;
adverb : ADVERB      { strcpy($$,$1); }
       | /* 空 */    { strcpy($$,""); }
       ;
noun_phrase : DECLARATIVE NOUN
              {
                sprintf($$,"%s %s",$1,$2);
              }
            | CONDITIONAL declarative NOUN
              {
                sprintf($$,"%s %s %s",$1,$2,$3);
              }
            | NOUN { strcpy($$,$1); strcat($$," "); }
            ;
declarative : DECLARATIVE { strcpy($$,$1); }
            | /* 空 */    { strcpy($$,""); }
            ;
period : /* 空 */
       | PERIOD
       ;

%%
/* main()およびyyerror()関数を提供する */

void main(int argc, char **argv)
{
  yyparse();       /* ファイルをパースする */
}
int yyerror(char *message)
{
  extern FILE *yyout;

  fprintf(yyout,"\nError at line %5d.  (%s) \n",
                     yylexlinenum,message);
}

以下はFlexのファイルです。文字列が渡される方法に注意してください。これは最適化された方法ではありませんが、もっとも理解しやすい方法です。

%{
#include <stdio.h>
#include <string.h>
#include "y.tab.h"      /* これはBisonにより生成される */
#define TRUE  1
#define FALSE 0
#define copy_and_return(token_type) \
         { \
             strcpy(yylval.name,yytext);\
             return(token_type); \
         }

int yylexlinenum = 0;  /* 行数カウント用 */
%}
%%
   /* 字句解析ルールがここから始まる */

MEN|WOMEN|STOCKS|TREES      copy_and_return(NOUN)
MISTAKES|GNUS|EMPLOYEES     copy_and_return(NOUN)
LOSERS|USERS|CARS|WINDOWS   copy_and_return(NOUN)
DATABASE|NETWORK|FSF|GNU    copy_and_return(PROPER_NOUN)
COMPANY|HOUSE|OFFICE|LPF    copy_and_return(PROPER_NOUN)
THE|THIS|THAT|THOSE         copy_and_return(DECLARATIVE)

ALL|FIRST|LAST              copy_and_return(CONDITIONAL)
FIND|SEARCH|SORT|ERASE|KILL copy_and_return(VERB)
ADD|REMOVE|DELETE|PRINT     copy_and_return(VERB)

QUICKLY|SLOWLY|CAREFULLY    copy_and_return(ADVERB)
IN|AT|ON|AROUND|INSIDE|ON   copy_and_return(POSITIONAL)

"."                         return(PERIOD);
"\n"                        yylexlinenum++; return(NEWLINE);
.
%%

これらのファイルは、以下を実行することでコンパイルできます。

% bison -d front.y
% flex -I front.lex
% cc -o front alloca.c front.tab.c lex.yy.c

または、この例のソースが手元にあれば、 examplesサブディレクトリにおいてmake frontを実行することでもコンパイルできます。

注意：Bisonパーサはalloca.cというファイルを必要とします。このファイルはexamplesサブディレクトリにあります。 Bisonの代わりにyaccを使うのであれば、このファイルは必要ありません。

Node:Notes on the Implementation, Previous:The Implementation, Up:Another Example of Flex and Bison

実装に関する注意

以下に実装に関する注意を示します。

YYSTYPE と yylval
yylvalがFlexからアクセスされる方法に注目してください。 Bison文法においてパースツリーの上位にデータを渡す方法については、 Bisonのマニュアルに説明されていますが、 Flexに対してはなんの影響も持ちません。整数値、浮動小数点数値、および他の任意の型のデータも同様の方法で返すことができます。
トークン値の返却
この例では、トークンの型と値の両方がBisonからアクセスできるように、トークンの値と文字列の値の両方がBisonに返されていることに注意してください。
BisonとFlex
BisonとFlexがいかにうまく調和しているかに注目してください。データを交換するためのコード以外に、インターフェイスのためのコードは一切ありません。 Bisonはyylex()を呼び出し、スキャナがトークン定義を提供しています。

Node:Flex and C plus plus (Flex 2.5), Previous:Another Example of Flex and Bison, Up:Interfacing to Flex

FlexとC++（Flex 2.5の補足情報）

Flex 2.5では、Flexに対するC++インターフェイスが提供されています。

FlexのC++インターフェイスを使うためには、Flex実行時に-+オプションを指定するか、スキャナ定義ファイルの中で%option c++を指定する必要があります。これにより、C++のスキャナクラスを実装するlex.yy.ccというファイルが生成されます。

lex.yy.ccは、Flexが提供するFlexLexer.hをインクルードします。このFlexLexer.hの中に、C++スキャナクラスの実装に利用される2つのC++クラス（FlexLexerとyyFlexLexer）が定義されています。

FlexLexerは、C++スキャナクラスが実装すべきインターフェイスを構成する抽象仮想関数を定義するクラスです。

FlexLexerの持つメンバを以下に示します。

char* yytext: 最後に認識された文字列（トークン）を保持します。
int yyleng: 最後に認識された文字列（トークン）の長さを保持します。
int yylineno: %option yylinenoが指定されている場合は、入力された行数を保持します。それ以外の場合は、固定値1を持ちます。
int yy_flex_debug: この値がゼロ以外の場合、C++スキャナはデバッグ出力を行います。

次に、FlexLexerの持つメンバ関数のうち、抽象仮想関数ではないものを以下に示します。

const char* YYText(): メンバyytextの値を返します。
int YYLeng(): メンバyylengの値を返します。
int yylex(istream* new_in, ostream* new_out = 0): new_inとnew_outを引数に指定して、メンバ関数switch_streams() を呼び出した後、メンバ関数int yylex(void)を呼び出します。
int lineno() const: メンバyylinenoの値を返します。
int debug() const: メンバyy_flex_debugの値を返します。
void set_debug(int flag): flagをメンバyy_flex_debugに代入します。¹²

次に、FlexLexerの持つ抽象仮想メンバ関数を列挙します。

void yy_switch_to_buffer(struct yy_buffer_state* new_buffer)
struct yy_buffer_state* yy_create_buffer(istream* s, int size)
void yy_delete_buffer(struct yy_buffer_state* b)
void yyrestart(istream* s)
int yylex()
void switch_streams(istream* new_in = 0, ostream* new_out = 0)

最初の5つのメンバ関数は、FlexのCインターフェイスにおける同名の関数と同等の機能を実現します。 Cインターフェイスでは、FILE*となっていた引数の型が、 istream*となっている点に注意してください。最後のswitch_streams()は、入出力ストリームの切り替えを行います。これらの抽象仮想メンバ関数の定義は、サブクラスyyFlexLexer において与えられ、そのコードはlex.yy.ccの中に生成されます。

yyFlexLexerは、 FlexLexerのサブクラスです。デフォルトの状態では、yyFlexLexerのインスタンスを生成して、 yylex()メンバ関数を呼び出すことによって、スキャナの処理が実行されます。以下に例を示します。

int main( int /* argc */, char** /* argv */ )
    {
    FlexLexer* lexer = new yyFlexLexer;
    while(lexer->yylex() != 0)
        ;
    return 0;
    }

これは、Cインターフェイスにおける、以下のコードに対応します。

int main( int /* argc */, char** /* argv */ )
    {
    yylex();
    return 0;
    }

スキャナ定義ファイルの中に%option yyclass="classname"を指定すると、 lex.yy.ccにclassname::yylex()が生成されます。クラスclassnameをyyFlexLexerのサブクラスとして定義することによって、classnameのインスタンスを使ってスキャン処理を実行できます。クラスclassnameを定義する際、以下に示す、yyFlexLexerの持つ protectedメンバ関数を再定義することによって、スキャナの振る舞いを変更できます。

int LexerInput(char* buf, int max_size): これを再定義することによって、スキャナの入力処理を変更できます。最大max_sizeバイトの文字を入力してbufの指す領域にセットし、実際に入力したバイト数を戻り値とします。入力を対話的に扱う場合と扱わない場合で、処理内容を変更する必要がある場合は、 #ifdef YY_INTERACTIVEを使います。
void LexerOutput(const char* buf, int size): これを再定義することによって、スキャナの出力処理を変更できます。 bufの指す領域にあるsizeバイトの文字を出力します。
void LexerError(const char* msg): これを再定義することによって、エラーメッセージの出力処理を変更できます。エラーメッセージは、引数msgで渡されます。

スキャン処理に関わるすべてのコンテキスト情報は、 yyFlexLexerのインスタンスの内部に閉じています。このことは、C++スキャナクラスを使うことによって、再入可能なスキャナを生成することが可能であることを意味しています。

複数のC++スキャナクラスを生成して、1つの実行プログラムにリンクすることも可能です。これを行うには、Flex起動時に-Pprefixオプションを指定するか、スキャナ定義ファイルの中に%option prefix="prefix"を指定することにより、yyFlexLexerの名前をprefixFlexLexerに変更します。 prefixFlexLexerクラスを使うソースファイルの中では、以下のようにしてFlexLexer.hをインクルードすることによって、 prefixFlexLexer（実際にはyyFlexLexer）の定義を参照する必要があります。

#undef yyFlexLexer
#define yyFlexLexer prefixFlexLexer
#include <FlexLexer.h>

Node:Other Flex Features, Next:Optimization, Previous:Interfacing to Flex, Up:Top

Flexの他の特徴

ここでは、Lexが提供していない機能や一般にはあまり使われない機能を説明します。 Flexはほぼ100パーセントLex互換ですが、Lexよりも後に実装されたため、性能的により優れており、また、広範な用途に使えるスキャナをより簡単に作成することができるよう、特別な機能を提供しています。

Node:Case Insensitive Scanners, Next:Interactive Scanners, Up:Other Flex Features

大文字／小文字を区別しないスキャナ

多くの言語は、その識別子において大文字／小文字を区別しません（Pascal、 BASIC、FORTRANなど）。 Lexにも、大文字／小文字を区別しないスキャナを指定するための方法がありますが、それらは概して美しくなく、理解するのも困難です。個々の文字を置き換えてくれる定義を、長いリストにして作成できますし、すべての識別子を受け付ける1つのルールを作成し、そのルールにおいて大文字／小文字を変換してから、トークンの種類を返すようにすることも可能です。以下のコードは、この2つの方法を示すものです。定義を使うのであれば、次のようになります。

A [aA]
B [bB]
 ...
Z [zZ]
%%
{B}{E}{G}{I}{N}      return(BEGIN_SYM);
{E}{N}{D}            return(END_SYM);

これに似た操作をサブルーチンで実行するのであれば、以下のようにします。

ALPHA      [a-zA-Z]
NUM        [0-9]
ALPHANUM   {ALPHA}|{NUM}
%%
{ALPHA}{ALPHANUM}*     return(convert_and_lookup(yytext));

もっともこれは、関数呼び出しの必要があるため、効率が悪くなります（Flexでは、パターンの複雑さは大して影響しません）。

ほかにもこれと同じことを行う方法がありますが、いずれもエレガントではありません。

Node:The -i Switch, Up:Case Insensitive Scanners

`-i`オプション

Flexは、この問題を簡単に解決するための方法を提供しています。コマンドラインで-iオプションを使うことによって、入力情報の大文字／小文字を区別しないスキャナを生成するよう、Flexに対して通知することができます。つまり、Flexでは上記のようなテクニックを使う必要がないということを意味しています。たとえば、

%%
begin        return(BEGIN_SYM);
end          return(END_SYM);

は、 -iオプションを使うことによって、BEGIN、begin、 BeGiN、およびこれ以外のすべての大文字／小文字の組み合わせにマッチします。これは、Lexにおいて同様のことを行うための方法よりも、はるかに簡単です。

-iオプションには1つ注意すべき点があります。それは、スキャナが大文字／小文字を区別しないだけで、その 変換まではしてくれないということです。つまり、Pascalにおいてシンボル名をハッシュしたいような場合、自分でシンボル名を大文字または小文字に変換しなければならないことを意味しています。そうしないと、FOOとfooは異なるものとして扱われます。これは、シンボルを保存するルーチンの中で対処できますし、 YY_USER_ACTIONを使うことによって対処することもできます。これを実現する方法の例については、Flex and Cにおける YY_USER_ACTIONの説明を参照してください。

Node:Interactive Scanners, Next:Table Compression and Scanner Speed, Previous:Case Insensitive Scanners, Up:Other Flex Features

`-I`オプション：対話型スキャナ

Flexの問題として、どのルールを適用するかを決定する前に、入力情報中の次の1文字を先読みする必要があるということがあります。対話的ではない使い方をする場合には問題になりませんが、 Flexを使ってユーザーから直接入力文字を受け取るような場合には、問題になることがあります。

このような例を2つあげると、1つはシェルとやり取りする場合、もう1つはデータベースのフロントエンドとやり取りする場合です。通常のアクションは、改行が入力の終わりを表すというもので、改行自身は一種の「中身のない文」として受け付けるのが望ましいのですが、通常のFlexスキャナではこれは可能ではありません。 Flexが常に先読みをするという事実は、改行が認識されるためにはユーザーが次の行を入力しなければならないということを意味しています（すなわち、単一の改行は、それだけでは認識されず、他の文字が入力される必要があるということです）。これはシェル上ではまったく望ましくありません。

Flexにはこれを回避する方法があります。コマンドラインで-Iオプションを使うと、Flexは、必要な場合にしか先読みをしない特別な対話型スキャナを生成します。この種のスキャナは、ユーザーからの入力を直接受け取るのに適していますが、若干の性能低下を引き起こすかもしれません。

注意：-Iオプションは、-f、-F、-Cf、または-CFフラグと一緒に使うことはできません。つまり、先読みができないことからくる性能低下に加えて、パーサも性能向上のために最適化することができないということを意味しています。

-Iオプションにおけるマイナス面は、通常はごくわずかなので、入力情報がどこからくるのかが確かではなく、性能向上のための最適化を施す可能性を諦めてもかまわないのであれば、コマンドラインで -Iオプションを使ったほうがよいでしょう。

Node:Table Compression and Scanner Speed, Next:Translation Tables, Previous:Interactive Scanners, Up:Other Flex Features

テーブルの圧縮とスキャナのスピード

テーブルの圧縮とスピードの面では、 FlexはLexの能力をはるかに上回っています。 Flexは、使われるオプションに応じて、Lexよりもはるかに高速なテーブル、あるいは、はるかに小さなテーブルを生成できます。この節では、利用可能なオプションと各オプションがスピードにもたらす影響について説明します。一般に、テーブルが圧縮されるほど、そのスピードは遅くなります。 Flexでは、こうしたオプションをコマンドラインで指定します。オプションは以下のとおりです。¹³

-fまたは-Cf

フルテーブル（full table）を生成します。このテーブルはまったく圧縮されず、サイズが大きくなりますが、スピードは速くなります。このオプションが指定された場合は、アクションの部分にREJECT を使うことはできない点に注意してください。

注意：-fフラグと-Fフラグでは、生成するテーブルに相違があります。 -fフラグはフルテーブル（full table）を生成し、 -Fフラグはファストテーブル（fast table）を生成します。ファストテーブルとは、スピードを最大限にするよう最適化されたテーブル形式であり、一方、フルテーブルには最適化は一切施されません。結果はよく似ていますが、テーブルサイズは大きく異なる可能性があります。

-Fまたは-CF

ファストテーブル（fast table）形式を用いてテーブルを生成します。一般に、このテーブルのスピードは先に説明したフルテーブルとほとんど同じですが、使われるパターンに応じて、そのサイズは小さくも大きくもなる可能性があります。原則として、すべての識別子をキャッチするルールのほかにキーワードの一覧も持つファイルに対しては、-fオプションを使うべきです。たとえば、

ALPHA     [a-zA-Z]
NUM       [0-9]
ALPHANUM  {ALPHA}|{NUM}
%%
begin                  return(BEGIN_SYM);
  ...  rules and actions ...
end                    return(END_SYM);
{ALPHA}{ALPHANUM}* return(IDENTIFIER);

は-fフラグを使って処理すべきであり、

{ALPHA}{ALPHANUM}* {ECHO;
                    return(lookup(yytext));}

は-Fフラグを使って処理すべきです。これらのオプションが指定されている場合は、アクションの部分にREJECTを使うことができない点に注意してください。

-Ce

このオプションを使うと、性能にはわずかしか影響を及ぼさずに、テーブルのサイズをかなり小さくすることができます。 -Ceが使われると、 Flexは同等クラス（equivalence classes）を作成します。同等クラスとは、同一の方法で使われる文字のグループです。たとえば、使われる数字が集合[0-9]の範囲に限定されるのであれば、 0から9までの数は同等クラスの中に置かれることになります。

-Cfe、-CFe

同等クラスを持つファストテーブルです。このオプションによって生成されたスキャナもまた高速であり、かつ、 -Cfあるいは-CFを指定して生成されたスキャナと比較して、サイズもはるかに小さくなる可能性があります。サイズまたはスピードの一方を優先させる必要がないのであれば、これは良い組み合わせです。

-Cm

メタ同等クラス（meta-equivalence classes）を使用します。これは、一緒に使われることが多い文字の集合、または（同等クラスが使われている場合には）同等クラスです。同等クラスを使う場合よりも性能はさらに悪くなりますが、これは多くの場合、テーブルサイズを小さくするのに非常に効果的な方法です。

-Cem

デフォルトのテーブル圧縮です。このオプションで生成されるスキャナは、Flexが生成するスキャナの中で事実上もっとも小さく、かつ、もっとも性能の劣るものになります。

-C

-Cオプション単体では、同等クラスやメタ同等クラスを使わずにテーブルを圧縮します。

注意：-Cxxオプションは、コマンドライン上には1つだけ指定すべきです。というのは、このうち最後に見つかったオプションだけが実際の効果を持つからです。したがって、

flex -Cf -Cem foo.l

は、Flexに-Cemオプションを使わせることになります。

Flexのデフ�