lex.dd

Ddoc

$(SPEC_S 字句の構成,

	Dでは、
	字句解析は構文解析や意味解析とは独立しています。
	字句解析器は文法に従ってソーステキストをトークンに分解しますが、
	Dの字句解析の文法は、
	特殊な規則をできる限り減らしてあるので、
	正確で高速な解析器が簡単に書けるようになっています。
	各トークンは、
	C や C++に慣れた人にはわかりやすいものです。

<h3>ソースコードのテキスト</h3>

	D のソースコードは以下のいずれかの形式のテキストファイルです:

	$(LIST
	ASCII,
	UTF-8,
	UTF-16BE,
	UTF-16LE,
	UTF-32BE,
	UTF-32LE
	)

	UTF-8 は昔ながらの 7-bit ASCII のスーパーセットです。
	以下の UTF BOM
	 (Byte Order Mark) 
	がソースの先頭に置かれていても構いません：
	<p>

	$(TABLE2 UTF Byte Order Mark,
	$(THEAD 形式, BOM)
	$(TROW UTF-8, EF BB BF)
	$(TROW UTF-16BE, FE FF)
	$(TROW UTF-16LE, FF FE)
	$(TROW UTF-32BE, 00 00 FE FF)
	$(TROW UTF-32LE, FF FE 00 00)
	$(TROW ASCII, BOMなし)
	)

	$(P ソースファイルが BOM で始まらない場合は、
	最初の２文字は必ず U0000007F 以下でなければなりません。)

	$(P 二連文字(digraph)や三連文字(trigraph)はDには存在しません。)

	$(P ソーステキストは
	Unicode $(GLINK Character) の列へとデコードされ、
	解釈されます。$(GLINK Character) は、以下に分類されます:

	$(GLINK WhiteSpace),
	$(GLINK EndOfLine),
	$(GLINK Comment),
	$(GLINK SpecialTokenSequence),
	$(GLINK Token),
	そして最後に $(GLINK EndOfFile)。
	)

	$(P トークンへ分解する際には、最長一致戦略を用います。つまり、
	字句解析器はできるだけ長いトークンを探そうとします。
	例えば
	<code>&gt;&gt;</code> は右シフトトークンであって、
	２個の不等号トークンとは解釈しません。この規則の例外は、
	浮動小数点数リテラルとして読めるトークンに挟まれた .. です。
	例えば 1..2 は、.. が先頭の
	 1 と空白で区切られているかのように解釈されます。
	)

<h3>文字集合</h3>

$(GRAMMAR
$(GNAME Character)
    $(I 任意の Unicode 文字)
)

<h3>ファイル終端</h3>

$(GRAMMAR
$(GNAME EndOfFile):
    $(I 物理的なファイル終端)
    \u0000
    \u001A
)

	どれかが一番最初に出現した点をソースの終端とします。

<h3>行終端</h3>

$(GRAMMAR
$(GNAME EndOfLine):
    \u000D
    \u000A
    \u000D \u000A
    \u2028
    \u2029
    $(GLINK EndOfFile)
)

	バックスラッシュで行を分けることはできません。
	１行の文字数に制限はありません。

<h3>空白</h3>

$(GRAMMAR
$(GNAME WhiteSpace):
    $(GLINK Space)
    $(GLINK Space) $(I WhiteSpace)

$(GNAME Space):
    \u0020
    \u0009
    \u000B
    \u000C
)


<h3>$(LNAME2 comment, コメント)</h3>

$(GRAMMAR
$(GNAME Comment):
    $(GLINK BlockComment)
    $(GLINK LineComment)
    $(GLINK NestingBlockComment)

$(GNAME BlockComment)
    $(B /*) $(GLINK Characters) $(B */)

$(GNAME LineComment)
    $(B //) $(GLINK Characters) $(GLINK EndOfLine)

$(GNAME NestingBlockComment):
    $(B /+) $(GLINK NestingBlockCommentCharacters) $(B +/)

$(GNAME NestingBlockCommentCharacters):
    $(GLINK NestingBlockCommentCharacter)
    $(GLINK NestingBlockCommentCharacter) $(I NestingBlockCommentCharacters)

$(GNAME NestingBlockCommentCharacter):
    $(GLINK Character)
    $(GLINK NestingBlockComment)

$(GNAME Characters):
    $(GLINK Character)
    $(GLINK Character) $(I Characters)
)

	$(P Dには三種類のコメントがあります：)

	$(OL
	$(LI ネストしないブロックコメント)
	$(LI 行コメント)
	$(LI ネストできるブロックコメント)
	)

	$(P
	文字列とコメントの中身はトークン分けされません。従って、
	文字列中に埋め込まれたコメント開始記号ではコメント扱いになりませんし、
	コメント内に埋め込まれた引用符では文字列扱いになりません。
	"/+" コメントの中の "/+" をのぞき、
	コメント中のコメント開始記号も
	単純に無視されます。
	)

-------------
a = /+ // +/ 1;    // 'a = 1;' として解析される
a = /+ "+/" +/ 1"; // 'a = " +/ 1";' として解析される
a = /+ /* +/ */ 3; // 'a = */ 3;' として解析される
-------------

	コメントを間に挟むと、トークンは分割されます。例えば
	<code>abc/**/def</code> は２つのトークン $(D abc) と $(D def) です。
	１つの $(D abcdef) ではありません。

<h3>トークン</h3>

$(GRAMMAR
$(GNAME Token):
    $(GLINK Identifier)
    $(GLINK StringLiteral)
    $(GLINK CharacterLiteral)
    $(GLINK IntegerLiteral)
    $(GLINK FloatLiteral)
    $(GLINK Keyword)
    $(B /)
    $(B /=)
    $(B .)
    $(B ..)
    $(B ...)
    $(B &)
    $(B &=)
    $(B &&)
    $(B |)
    $(B |=)
    $(B ||)
    $(B -)
    $(B -=)
    $(B --)
    $(B +)
    $(B +=)
    $(B ++)
    $(B &lt;)
    $(B &lt;=)
    $(B &lt;&lt;)
    $(B &lt;&lt;=)
    $(B &lt;&gt;)
    $(B &lt;&gt;=)
    $(B &gt;)
    $(B &gt;=)
    $(B &gt;&gt;=)
    $(B &gt;&gt;&gt;=)
    $(B &gt;&gt;)
    $(B &gt;&gt;&gt;)
    $(B !)
    $(B !=)
    $(B !&lt;&gt;)
    $(B !&lt;&gt;=)
    $(B !&lt;)
    $(B !&lt;=)
    $(B !&gt;)
    $(B !&gt;=)
    $(B $(LPAREN))
    $(B $(RPAREN))
    $(B [)
    $(B ])
    $(B {)
    $(B })
    $(B ?)
    $(B ,)
    $(B ;)
    $(B :)
    $(B $)
    $(B =)
    $(B ==)
    $(B *)
    $(B *=)
    $(B %)
    $(B %=)
    $(B ^)
    $(B ^=)
    $(V2 $(B ^^))
    $(V2 $(B ^^=))
    $(B ~)
    $(B ~=)
    $(V2 $(B @))
    $(V2 $(B =>))
    $(V2 $(B #))
)

<h3>識別子</h3>

$(GRAMMAR
$(GNAME Identifier):
    $(GLINK IdentifierStart)
    $(GLINK IdentifierStart) $(GLINK IdentifierChars)

$(GNAME IdentifierChars):
    $(GLINK IdentifierChar)
    $(GLINK IdentifierChar) $(I IdentifierChars)

$(GNAME IdentifierStart):
    $(B _)
    $(I Letter)
    $(I UniversalAlpha)

$(GNAME IdentifierChar):
    $(GLINK IdentifierStart)
    $(B 0)
    $(GLINK NonZeroDigit)
)


	識別子はアルファベットか $(B _)、または普遍基本文字(Universal Alpha)で始まり、
	アルファベット、
	$(B _)、数字、普遍基本文字の列が後ろに続いたものです。
	普遍基本文字は ISO/IEC 9899:1999(E) Appendix D. (C99標準です) に
	Universal character names for identifiers として定義されています。
	識別子は大文字小文字を区別します。長さに制限はありません。
	$(B __) (2個のアンダースコア)で始まる識別子は処理系側に予約されています。

<h3>String Literals</h3>

$(GRAMMAR
$(GNAME StringLiteral):
    $(GLINK WysiwygString)
    $(GLINK AlternateWysiwygString)
    $(GLINK DoubleQuotedString)
$(V1
    $(GLINK EscapeSequence))
    $(GLINK HexString)
$(V2
    $(GLINK DelimitedString)
    $(GLINK TokenString))

$(GNAME WysiwygString):
    $(B r") $(GLINK WysiwygCharacters) $(B ") $(GLINK StringPostfix)<sub>opt</sub>

$(GNAME AlternateWysiwygString):
    $(B `) $(GLINK WysiwygCharacters) $(B `) $(GLINK StringPostfix)<sub>opt</sub>

$(GNAME WysiwygCharacters):
    $(GLINK WysiwygCharacter)
    $(GLINK WysiwygCharacter) $(I WysiwygCharacters)

$(GNAME WysiwygCharacter):
    $(GLINK Character)
    $(GLINK EndOfLine)

$(GNAME DoubleQuotedString):
    $(B ") $(GLINK DoubleQuotedCharacters) $(B ") $(GLINK StringPostfix)<sub>opt</sub>

$(GNAME DoubleQuotedCharacters):
    $(GLINK DoubleQuotedCharacter)
    $(GLINK DoubleQuotedCharacter) $(I DoubleQuotedCharacters)

$(GNAME DoubleQuotedCharacter):
    $(GLINK Character)
    $(GLINK EscapeSequence)
    $(GLINK EndOfLine)

$(GNAME EscapeSequence):
    $(B \')
    $(B \")
    $(B \?)
    $(B \\)
    $(B \a)
    $(B \b)
    $(B \f)
    $(B \n)
    $(B \r)
    $(B \t)
    $(B \v)
    $(B \) $(GLINK EndOfFile)
    $(B \x) $(GLINK HexDigit) $(GLINK HexDigit)
    $(B \) $(GLINK OctalDigit)
    $(B \) $(GLINK OctalDigit) $(GLINK OctalDigit)
    $(B \) $(GLINK OctalDigit) $(GLINK OctalDigit) $(GLINK OctalDigit)
    $(B \u) $(GLINK HexDigit) $(GLINK HexDigit) $(GLINK HexDigit) $(GLINK HexDigit)
    $(B \U) $(GLINK HexDigit) $(GLINK HexDigit) $(GLINK HexDigit) $(GLINK HexDigit) $(GLINK HexDigit) $(GLINK HexDigit) $(GLINK HexDigit) $(GLINK HexDigit)
    $(GLINK2 entity, NamedCharacterEntity)

$(GNAME HexString):
    $(B x") $(GLINK HexStringChars) $(B ") $(GLINK StringPostfix)<sub>opt</sub>

$(GNAME HexStringChars):
    $(GLINK HexStringChar)
    $(GLINK HexStringChar) $(I HexStringChars)

$(GNAME HexStringChar):
    $(GLINK HexDigit)
    $(GLINK WhiteSpace)
    $(GLINK EndOfLine)

$(GNAME StringPostfix):
    $(B c)
    $(B w)
    $(B d)

$(V2
$(GNAME DelimitedString):
    $(B q") $(I Delimiter) $(GLINK WysiwygCharacters) $(I MatchingDelimiter) $(B ")

$(GNAME TokenString):
    $(B q{) $(GLINK Token)s $(B })
)
)

	$(P
	文字列リテラルの種類としては、二重引用符やWYSIWYG引用符で囲まれた
	文字列、エスケープシーケンス、
	$(V2 デリミタ指定文字列、トークン文字列、)
	16進文字列があります。
	)

	$(P どの文字列リテラルの中でも $(GLINK EndOfLine) は単一の
	\n という文字と解釈されます。)

<h4>WYSIWYG文字列</h4>

	$(P WYSIWYG "what you see is what you get"
	文字列は r" と " で囲みます。
	r" と " の間の全ての文字は
	文字列として扱われます。
	この中ではエスケープシーケンスは使用できません。 
	)

---------------
r"hello"
r"c:\root\foo.exe"
r"ab\n" // ４文字
        // 'a', 'b', '\', 'n'
---------------

	$(P
	WYSIWYG文字には、バッククォート ` を使った表現もあります。
	この ` 文字はキーボードによっては存在しなかったり、
	フォントによっては普通の引用符 ' と区別できないことがあります。
	このため ` が使用されることはまれですが、"
	を含む文字列を書くには便利です。
	)

---------------
`hello`
`c:\root\foo.exe`
`ab\n`  // ４文字
        // 'a', 'b', '\', 'n'
---------------

<h4>二重引用符文字列</h4>

	二重引用符 "" の中では、おなじみの \ を使った記法で
	エスケープシーケンスを使うことができます。

---------------
"hello"
"c:\\root\\foo.exe"
"ab\n"   // ３文字の文字列 
         // 'a', 'b', 改行
"ab
"        // これも３文字の文字列 
         // 'a', 'b', 改行
---------------

$(V1
<h4>エスケープ文字列</h4>

	$(P \から始まる文字の並びはエスケープシーケンスになります。
	隣り合ったエスケープ文字列は連結されます。
	)

$(TABLE1
$(TROW \n,			改行文字)
$(TROW \t,			タブ文字)
$(TROW \",			二重引用符)
$(TROW \012,			8進表記)
$(TROW \x1A,			16進表記)
$(TROW \u1234,			wchar 文字)
$(TROW \U00101234,		dchar 文字)
$(TROW \&amp;reg;,		&reg; dchar 文字)
$(TROW \r\n,			復帰改行)
)

	$(P 未定義のエスケープシーケンスはエラーとなります。
	文字列リテラルはUTF文字の組み合わせであると定義されていますが、
	8進/16進エスケープシーケンスを用いることで、
	任意のバイナリデータを挿入することも可能です。
	一方でエスケープシーケンス \u と \U では、
	有効な UTF 文字のみが挿入できます。
	)
)

<h4>16進文字列</h4>

	$(P 16進文字列は、16進データを使って文字列リテラルを記述する方法です。
	16進データは有効なUTF文字である必要はありません。
	)

--------------
x"0A"              // "\x0A" と同じ
x"00 FBCD 32FD 0A" // 
               // "\x00\xFB\xCD\x32\xFD\x0A" と同じ
--------------

	空白や改行文字は無視されるので、
	16進データを整形して並べることができます。
	16進文字の個数は２の倍数でなくてはなりません。
	<p>

	演算子 $(D ~) でつなげられているか、
	あるいは単純に並べて書かれている文字列どうしは結合されます：

--------------
"hello " ~ "world" ~ $(V1 \n)$(V2 "\n") // 文字列
       // 'h','e','l','l','o',' ',
       // 'w','o','r','l','d',改行   となる
--------------

	以下は全て同じ意味です：

-----------------
"ab" "c"
r"ab" r"c"
r"a" "bc"
"a" ~ "b" ~ "c"
$(V1 \x61"bc")
-----------------

	$(P 追加の $(I StringPostfix) 文字によって、
	文字列リテラルの型を文脈から推論させるのではなく、明示的に指定できます。
	これは、あいまいなく型を推論することが不可能なとき、例えば
	文字列の型によるオーバーロードがあるときなどに役に立ちます。
	postfixと対応する型はそれぞれ：
	)

$(V1
	$(TABLE2 文字列リテラル後置文字,
	$(THEAD Postfix, 型, 別名)
	$(TROW $(B c), $(D char[]), $(D string))
	$(TROW $(B w), $(D wchar[]), $(D wstring))
	$(TROW $(B d), $(D dchar[]), $(D dstring))
	)
)
$(V2
	$(TABLE2 文字列リテラル後置文字,
	$(THEAD Postfix, 型, 別名)
	$(TROW $(B c), $(D immutable(char)[]), $(D string))
	$(TROW $(B w), $(D immutable(wchar)[]), $(D wstring))
	$(TROW $(B d), $(D immutable(dchar)[]), $(D dstring))
	)
)
---
"hello"c  // string
"hello"w  // wstring
"hello"d  // dstring
---

	$(P 文字列はまず UTF-8 の文字列として読み込まれ、
	postfix
	文字を見て whar や dchar に変換されます。)

	$(P 文字列リテラルは読み取り専用です。文字列リテラルへの書き込みは、
	全てが検出されるとは限りませんが、未定義動作となります。)

$(V2
<h4>デリミタ指定文字列</h4>

	$(P デリミタ指定文字列では、いろいろな形式のデリミタを使用することができます。
	デリミタは、文字を使う場合も識別子を使う場合も、
	余計な空白なしで " の直後に続ける必要があります。
	終了デリミタも、
	" の直前に空白なしで置くようにします。
	$(I nesting delimiter) はネスト可能で、
	以下のいずれかの文字を使用できます:
	)

	$(TABLE2 Nesting Delimiters,
	$(THEAD 開始デリミタ, 終了デリミタ)
	$(TROW [, ])
	$(TROW $(LPAREN), $(RPAREN))
	$(TROW &lt;, &gt;)
	$(TROW {, })
	)

---
q"(foo(xxx))"   // "foo(xxx)"
q"[foo{]"       // "foo{"
---

	$(P デリミタとして識別子を使用する場合、
	最初の識別子の直後に改行を続けます。また、
	最後の閉じ識別子としては先頭の識別子と同じものを
	行頭に書きます:
	)
---
writefln(q"EOS
This
is a multi-line
heredoc string
EOS"
);
---
	$(P T先頭の識別子の直後の改行は文字列には含まれませんが、
	最後の閉じ識別子の直前の改行は
	文字列に含まれます。閉じ識別子は、
    行の左端にその識別子だけの行として配置される必要があります。
	)

	$(P それ以外の場合は、
	マッチするデリミタはデリミタ文字と完全に一致します:)

---
q"/foo]/"       // "foo]"
q"/abc/def/"    // error
---

<h4>トークン文字列</h4>

	$(P トークン文字列は $(B q{) で始まり
	$(B }) で終わります。この間にはDで有効なトークンのみを記述することが出来ます。
	トークン $(B {) と $(B }) はネストできます。
	表現する文字列は、括弧の中に記述されたトークンの、
	コメントも含めた全文字の列となります。
	)

---
q{foo}              // "foo"
q{/*}*/ }           // "/*}*/ "
q{ foo(q{hello}); } // " foo(q{hello}); "
q{ __TIME__ }       // " __TIME__ " になる。つまり、時刻で置き換えられることはない
q{ __EOF__ }        // エラー。__EOF__ はトークンではなくファイル終端
---

)

<h3>$(LNAME2 characterliteral, 文字リテラル)</h3>

$(GRAMMAR
$(GNAME CharacterLiteral):
    $(B ') $(GLINK SingleQuotedCharacter) $(B ')

$(GNAME SingleQuotedCharacter):
    $(GLINK Character)
    $(GLINK EscapeSequence)
)

	文字リテラルは、１文字分の文字かエスケープシーケンスです。
	一重引用符 ' ' でくくられます。

<h3>$(LNAME2 integerliteral, 整数リテラル)</h3>

$(GRAMMAR
$(GNAME IntegerLiteral):
    $(GLINK Integer)
    $(GLINK Integer) $(I IntegerSuffix)

$(GNAME Integer):
    $(GLINK DecimalInteger)
    $(GLINK BinaryInteger)
$(V1    $(GLINK OctalInteger)
)    $(GLINK HexadecimalInteger)

$(GNAME IntegerSuffix):
    $(B L)
    $(B u)
    $(B U)
    $(B Lu)
    $(B LU)
    $(B uL)
    $(B UL)

$(GNAME DecimalInteger):
    $(B 0)
    $(GLINK NonZeroDigit)
    $(GLINK NonZeroDigit) $(I DecimalDigitsUS)

$(GNAME BinaryInteger):
    $(GLINK BinPrefix) $(GLINK BinaryDigits)

$(GNAME BinPrefix):
    $(B 0b)
    $(B 0B)

$(V1 $(GNAME OctalInteger):
    $(B 0) $(GLINK OctalDigitsUS)

)$(GNAME HexadecimalInteger):
    $(GLINK HexPrefix) $(GLINK HexDigitsNoSingleUS)

$(GNAME NonZeroDigit):
    $(B 1)
    $(B 2)
    $(B 3)
    $(B 4)
    $(B 5)
    $(B 6)
    $(B 7)
    $(B 8)
    $(B 9)

$(GNAME DecimalDigits):
    $(GLINK DecimalDigit)
    $(GLINK DecimalDigit) $(I DecimalDigits)

$(GNAME DecimalDigitsUS):
    $(GLINK DecimalDigitUS)
    $(GLINK DecimalDigitUS) $(I DecimalDigitsUS)

$(GNAME DecimalDigitsNoSingleUS):
    $(GLINK DecimalDigit)
    $(GLINK DecimalDigit) $(GLINK DecimalDigitsUS)
    $(GLINK DecimalDigitsUS) $(GLINK DecimalDigit)

$(GNAME DecimalDigitsNoStartingUS):
    $(GLINK DecimalDigit)
    $(GLINK DecimalDigit) $(GLINK DecimalDigitsUS)

$(GNAME DecimalDigit):
    $(B 0)
    $(GLINK NonZeroDigit)

$(GNAME DecimalDigitUS):
    $(GLINK DecimalDigit)
    $(B _)

$(GNAME BinaryDigitsUS):
    $(GLINK BinaryDigitUS)
    $(GLINK BinaryDigitUS) $(I BinaryDigitsUS)

$(GNAME BinaryDigit):
    $(B 0)
    $(B 1)

$(GNAME BinaryDigitUS):
    $(GLINK BinaryDigit)
    $(B _)

$(GNAME OctalDigits):
    $(GLINK OctalDigit)
    $(GLINK OctalDigit) $(I OctalDigits)

$(GNAME OctalDigitsUS):
    $(GLINK OctalDigitUS)
    $(GLINK OctalDigitUS) $(I OctalDigitsUS)

$(GNAME OctalDigit):
    $(B 0)
    $(B 1)
    $(B 2)
    $(B 3)
    $(B 4)
    $(B 5)
    $(B 6)
    $(B 7)

$(GNAME OctalDigitUS):
    $(GLINK OctalDigit)
    $(B _)

$(GNAME HexDigits):
    $(GLINK HexDigit)
    $(GLINK HexDigit) $(I HexDigits)

$(GNAME HexDigitsUS):
    $(GLINK HexDigitUS)
    $(GLINK HexDigitUS) $(I HexDigitsUS)

$(GNAME HexDigitsNoSingleUS):
    $(GLINK HexDigit)
    $(GLINK HexDigit) $(GLINK HexDigitsUS)
    $(GLINK HexDigitsUS) $(GLINK HexDigit)

$(GNAME HexDigit):
    $(GLINK DecimalDigit)
    $(GLINK HexLetter)

$(GNAME HexLetter):
    $(B a)
    $(B b)
    $(B c)
    $(B d)
    $(B e)
    $(B f)
    $(B A)
    $(B B)
    $(B C)
    $(B D)
    $(B E)
    $(B F)
    $(B _)
)

	$(P 整数は10進,2進,8進,16進のどれかの記法で表記します。)

	$(P 10進整数は、0,1,..,9の並びです。)

	$(P $(LNAME2 binary-literals, 2進整数) は
	$(SINGLEQUOTE 0b) で始まる0,1の並びです。
	)

	$(V1 $(P 8進整数は $(SINGLEQUOTE 0) で始まる0,1,..,7の並びです。))

	$(V2 $(P C 形式の8進整数リテラルは、十進表記と不注意で混ぜてしまう可能性が非常に高いものです。
	これは文字列リテラルの中でのみ完全にサポートされています。
	D では、コンパイル時に解釈される8進リテラルは $(FULL_XREF conv, octal)
	テンプレートとして提供しており、$(D octal!167) のように使います。))

	$(P 16進整数は、
	$(SINGLEQUOTE 0x) で始まる 0,1,..,9,A,..,F,a,..,f の並びです。
	)

	$(P 整数の途中に文字 $(SINGLEQUOTE _) を入れることができます。
	この文字は単に無視されます。
	長いリテラルの整形に、例えば1000単位の区切りとしてなどで役に立ちます。
	)

-------------
123_456       // 123456
1_2_3_4_5_6_  // 123456
-------------

	$(P 整数の後ろに $(SINGLEQUOTE L) または
	$(SINGLEQUOTE u) や $(SINGLEQUOTE U)、あるいはその両方が続くことがあります。
	小文字の $(SINGLEQUOTE l) は使えません。
	)

	$(P 整数の型は次のように決定されます：)

	$(TABLE2 10進リテラルの型,

	$(THEAD 10進リテラル, 型)
	$(TROW 0 .. 2_147_483_647, int)
	$(TROW 2_147_483_648 .. 9_223_372_036_854_775_807L, long)

	$(THEAD $(ARGS 10進リテラル, 接尾辞L), 型)
	$(TROW 0L .. 9_223_372_036_854_775_807L, long)

	$(THEAD $(ARGS 10進リテラル, 接尾辞U), 型)
	$(TROW 0U .. 4_294_967_296U, uint)
	$(TROW 4_294_967_296U .. 18_446_744_073_709_551_615UL, ulong)

	$(THEAD $(ARGS 10進リテラル, 接尾辞UL), 型)
	$(TROW 0UL .. 18_446_744_073_709_551_615UL, ulong)

	$(THEAD 非10進リテラル, 型)
	$(TROW 0x0 .. 0x7FFF_FFFF, int)
	$(TROW 0x8000_0000 .. 0xFFFF_FFFF, uint)
	$(TROW 0x1_0000_0000 .. 0x7FFF_FFFF_FFFF_FFFF, long)
	$(TROW 0x8000_0000_0000_0000 .. 0xFFFF_FFFF_FFFF_FFFF, ulong)

	$(THEAD $(ARGS 非10進リテラル, 接尾辞L), 型)
	$(TROW 0x0L .. 0x7FFF_FFFF_FFFF_FFFFL, long)
	$(TROW 0x8000_0000_0000_0000L .. 0xFFFF_FFFF_FFFF_FFFFL, ulong)

	$(THEAD $(ARGS 非10進リテラル, 接尾辞U), 型)
	$(TROW 0x0U .. 0xFFFF_FFFFU, uint)
	$(TROW 0x1_0000_0000UL .. 0xFFFF_FFFF_FFFF_FFFFUL, ulong)

	$(THEAD $(ARGS 非10進リテラル, 接尾辞UL), 型)
	$(TROW 0x0UL .. 0xFFFF_FFFF_FFFF_FFFFUL, ulong)

	)


<h3>$(LNAME2 floatliteral, 浮動小数点数リテラル)</h3>

$(GRAMMAR
$(GNAME FloatLiteral):
    $(GLINK Float)
    $(GLINK Float) $(GLINK Suffix)
    $(GLINK Integer) $(GLINK ImaginarySuffix)
    $(GLINK Integer) $(GLINK FloatSuffix) $(GLINK ImaginarySuffix)
    $(GLINK Integer) $(GLINK RealSuffix) $(GLINK ImaginarySuffix)

$(GNAME Float):
    $(GLINK DecimalFloat)
    $(GLINK HexFloat)

$(GNAME DecimalFloat):
    $(GLINK LeadingDecimal) $(B .)
    $(GLINK LeadingDecimal) $(B .) $(GLINK DecimalDigits)
    $(GLINK DecimalDigits) $(B .) $(GLINK DecimalDigitsNoSingleUS) $(GLINK DecimalExponent)
    $(B .) $(GLINK DecimalInteger)
    $(B .) $(GLINK DecimalInteger) $(GLINK DecimalExponent)
    $(GLINK LeadingDecimal) $(GLINK DecimalExponent)

$(GNAME DecimalExponent)
    $(GLINK DecimalExponentStart) $(GLINK DecimalDigitsNoSingleUS)

$(GNAME DecimalExponentStart)
    $(B e)
    $(B E)
    $(B e+)
    $(B E+)
    $(B e-)
    $(B E-)

$(GNAME HexFloat):
    $(GLINK HexPrefix) $(GLINK HexDigitsNoSingleUS) $(B .) $(GLINK HexDigitsNoSingleUS) $(GLINK HexExponent)
    $(GLINK HexPrefix) $(B .) $(GLINK HexDigitsNoSingleUS) $(GLINK HexExponent)
    $(GLINK HexPrefix) $(GLINK HexDigitsNoSingleUS) $(GLINK HexExponent)

$(GNAME HexPrefix):
    $(B 0x)
    $(B 0X)

$(GNAME HexExponent):
    $(GLINK HexExponentStart) $(GLINK DecimalDigitsNoSingleUS)

$(GNAME HexExponentStart):
    $(B p)
    $(B P)
    $(B p+)
    $(B P+)
    $(B p-)
    $(B P-)


$(GNAME Suffix):
    $(GLINK FloatSuffix)
    $(GLINK RealSuffix)
    $(GLINK ImaginarySuffix)
    $(GLINK FloatSuffix) $(GLINK ImaginarySuffix)
    $(GLINK RealSuffix) $(GLINK ImaginarySuffix)

$(GNAME FloatSuffix):
    $(B f)
    $(B F)

$(GNAME RealSuffix):
    $(B L)

$(GNAME ImaginarySuffix):
    $(B i)

$(GNAME LeadingDecimal):
    $(GLINK DecimalInteger)
    $(B 0) $(GLINK DecimalDigitsNoSingleUS)
)

	$(P 浮動小数点数は、10進または16進表記が可能です。)

	$(P 16進浮動小数は $(B 0x) で始まり、
	指数部は $(B p)
	か $(B P)  のうしろに
	2 の指数を表す数を続けたものです。
	)

	$(P 浮動小数点数リテラルの途中に文字 $(SINGLEQUOTE _) を入れることができ、
	この文字は単に無視されます。
	長いリテラルを整形して読みやすくするのに役立ちます。
	例えば、1000単位の区切りとしてなど：
	)

---------
123_456.567_8         // 123456.5678
1_2_3_4_5_6_._5_6_7_8 // 123456.5678
1_2_3_4_5_6_._5e-6_   // 123456.5e-6
---------

	$(P 接尾辞のない浮動小数点数はdouble型です。
	浮動小数点数には接尾辞 $(B f), $(B F),
	$(B L) のうちどれか一つを付けることができます。
	$(B f) と $(B F) は値がfloat型であることを示し、
	$(B L) はreal型であることを示します。
	)

	$(P 接尾辞 $(B i) があれば、
	$(I ireal) (虚数) 型です。
	)

	$(P 例：)

---------
0x1.FFFFFFFFFFFFFp1023 // double.max
0x1p-52                // double.epsilon
1.175494351e-38F       // float.min
6.3i                   // idouble 6.3
6.3fi                  // ifloat 6.3
6.3Li                  // ireal 6.3
---------

	$(P Iリテラルが型の表現可能な範囲を超えていると、
	エラーになります。
	リテラルの示す値の下位桁が丸められるのはエラーではありません。
	)

	$(P 複素数リテラルはトークンではなく、意味解析によって
	実数と虚数トークンが組み合わせられます。
	)

---------
4.5 + 6.2i  // 複素数 (phased out)
---------

<h3>予約語</h3>

	以下が予約された識別子です：

$(GRAMMAR
$(GNAME Keyword):
    $(B abstract)
    $(B alias)
    $(B align)
    $(B asm)
    $(B assert)
    $(B auto)

    $(B body)
    $(B bool)
    $(B break)
    $(B byte)

    $(B case)
    $(B cast)
    $(B catch)
    $(B cdouble)
    $(B cent)
    $(B cfloat)
    $(B char)
    $(B class)
    $(B const)
    $(B continue)
    $(B creal)

    $(B dchar)
    $(B debug)
    $(B default)
    $(B delegate)
    $(B delete)
    $(B deprecated)
    $(B do)
    $(B double)

    $(B else)
    $(B enum)
    $(B export)
    $(B extern)

    $(B false)
    $(B final)
    $(B finally)
    $(B float)
    $(B for)
    $(B foreach)
    $(B foreach_reverse)
    $(B function)

    $(B goto)

    $(B idouble)
    $(B if)
    $(B ifloat)
$(V2
     $(B immutable)
)    $(B import)
    $(B in)
    $(B inout)
    $(B int)
    $(B interface)
    $(B invariant)
    $(B ireal)
    $(B is)

    $(B lazy)
    $(B long)

    $(B macro)
    $(B mixin)
    $(B module)

    $(B new)
$(V2
     $(B nothrow)
)    $(B null)

    $(B out)
    $(B override)

    $(B package)
    $(B pragma)
    $(B private)
    $(B protected)
    $(B public)
$(V2
     $(B pure)
)
    $(B real)
    $(B ref)
    $(B return)

    $(B scope)
$(V2
     $(B shared)
)    $(B short)
    $(B static)
    $(B struct)
    $(B super)
    $(B switch)
    $(B synchronized)

    $(B template)
    $(B this)
    $(B throw)
    $(B true)
    $(B try)
    $(B typedef)
    $(B typeid)
    $(B typeof)

    $(B ubyte)
    $(B ucent)
    $(B uint)
    $(B ulong)
    $(B union)
    $(B unittest)
    $(B ushort)

    $(B version)
    $(B void)
    $(B volatile)

    $(B wchar)
    $(B while)
    $(B with)
$(V2
     $(B __FILE__)
    $(B __LINE__)
    $(B __gshared)
    $(B __thread)
    $(B __traits))
)

<h3>$(LNAME2 specialtokens, 特殊トークン)</h3>

	$(P
	特殊トークンは、
	以下の表に従って別のトークンへと置換されます：
	)

	$(TABLE2 特殊トークン,
	$(THEAD 特殊トークン, 置換後...)
$(V1
	$(TROW $(CODE __FILE__), ソースファイルの名前の文字列リテラル)
	$(TROW $(CODE __LINE__), ソース上の行番号を表す整数)
)
	$(TROW $(CODE __DATE__), コンパイルした日にちの文字列リテラル "$(I mmm dd yyyy)")
$(V2
	$(TROW $(CODE __EOF__), このトークンの出現をファイルの終端として扱う)
)
	$(TROW $(CODE __TIME__), コンパイルした時刻の文字列リテラル "$(I hh:mm:ss)")
	$(TROW $(CODE __TIMESTAMP__), コンパイルした日時の文字列リテラル "$(I www mmm dd hh:mm:ss yyyy)")
	$(TROW $(CODE __VENDOR__), $(ARGS コンパイラベンダ名文字列。例えば "Digital Mars D"))
	$(TROW $(CODE __VERSION__), $(ARGS コンパイラのバージョン番号を表す整数。例えば 2001))
	)

<h3>$(LNAME2 Special Token Sequence, 特殊トークン列)</h3>

$(GRAMMAR
$(GNAME SpecialTokenSequence):
    $(B # line) $(GLINK IntegerLiteral) $(GLINK EndOfLine)
    $(B # line) $(GLINK IntegerLiteral) $(GLINK Filespec) $(GLINK EndOfLine)

$(GNAME Filespec):
    $(B ") $(GLINK Characters) $(B ")
)

	$(P 特殊トークン列は、トークン列のどの位置にでも登場でき、
	字句解析器によって処理されます。
	構文解析には影響しません。
	)

	$(P 現在の所、特殊トークン列は $(D #line) 一つだけです。
	)

	$(P これによって、次の行の行番号は $(GLINK IntegerLiteral) に、
	ファイル名は（もしあれば） $(GLINK Filespec)
	に設定されます。
	ソースファイル名と行番号は、
	エラーメッセージや
	デバッガ用のシンボルとして使用されています。
	)

	$(P 例：
	)

-----------------
int #line 6 "foo\bar"
x;  // ここがファイル foo\bar の6行目扱いになる
-----------------

	$(P バックスラッシュ文字は
	$(GLINK Filespec) 文字列の中では特別扱いされないことにご注意下さい。
	)
)

Macros:
	TITLE=字句の構成
	WIKI=Lex
        CATEGORY_SPEC=$0

	FULL_XREF = <a href="phobos/std_$1.html#$2">$(D std.$1.$2)</a>