Diff for /gnujdoc/bison-1.28/bison-ja.texinfo between versions 1.1 and 1.2

version 1.1, 1999/08/07 05:46:24 version 1.2, 1999/08/08 07:52:42
Line 94  instead of in the original English. Line 94  instead of in the original English.
 @shorttitlepage Bison  @shorttitlepage Bison
 @end ifset  @end ifset
 @titlepage  @titlepage
 @c @title Bison  
 @title Bison入門  @title Bison入門
 @subtitle The YACC-compatible Parser Generator  @subtitle YACC互換構文解析器生成ツール
 @c @subtitle YACC互換構文解析器生成ツール  
 @subtitle @value{UPDATED}, Bison Version @value{VERSION}  @subtitle @value{UPDATED}, Bison Version @value{VERSION}
 @author by Charles Donnelly and Richard Stallman  @author by Charles Donnelly and Richard Stallman
Line 145  Cover art by Etienne Suvasa. Line 143  Cover art by Etienne Suvasa.
 @page  @page
 @c =====================================================================  
 @node Top, Introduction, (dir), (dir)  @node Top, Introduction, (dir), (dir)
 @ifinfo  @ifinfo
Line 317  Bisonの実行 Line 314  Bisonの実行
 * VMS Invocation::    VMSでのBisonのコマンド構文.  * VMS Invocation::    VMSでのBisonのコマンド構文.
 @end menu  @end menu
 @c =====================================================================  
 @node Introduction, Conditions, Top, Top  @node Introduction, Conditions, Top, Top
 @c @unnumbered Introduction  
 @unnumbered まえがき  @unnumbered まえがき
 @cindex introduction  @cindex introduction
 @cindex まえがき  @cindex まえがき
 @c @dfn{Bison} is a general-purpose parser generator that converts a  
 @c grammar description for an LALR(1) context-free grammar into a C  
 @c program to parse that grammar.  Once you are proficient with Bison,  
 @c you may use it to develop a wide range of language parsers, from those  
 @c used in simple desk calculators to complex programming languages.  
 Bisonは、LALR(1)文脈自由文法の文法定義を、  Bisonは、LALR(1)文脈自由文法の文法定義を、
 その文法を解析するためのCで書かれたプログラムに変換する、  その文法を解析するためのCで書かれたプログラムに変換する、
 汎用の構文解析器生成ツールです。  汎用の構文解析器生成ツールです。
Line 337  Bisonは、LALR(1)文脈自由文法の文法定義を Line 326  Bisonは、LALR(1)文脈自由文法の文法定義を
 簡単な電卓から複雑なプログラミング言語まで、  簡単な電卓から複雑なプログラミング言語まで、
 広い範囲の言語解析器を開発できるようになるでしょう。  広い範囲の言語解析器を開発できるようになるでしょう。
 @c Bison is upward compatible with Yacc: all properly-written Yacc grammars  
 @c ought to work with Bison with no change.  Anyone familiar with Yacc  
 @c should be able to use Bison with little trouble.  You need to be fluent in  
 @c C programming in order to use Bison or to understand this manual.  
 BisonはYaccの上位互換です。  BisonはYaccの上位互換です。
 正しく書かれたすべてのYacc文法を、変更なくBisonで処理できます。  正しく書かれたすべてのYacc文法を、変更なくBisonで処理できます。
 Yaccに親しんでいるすべての人は、ちょっと考えるだけで、  Yaccに親しんでいるすべての人は、ちょっと考えるだけで、
Line 349  Bisonを使えるようになるでしょう。 Line 333  Bisonを使えるようになるでしょう。
 Bisonを使い、本書を理解するためには、  Bisonを使い、本書を理解するためには、
 C言語に精通している必要があります。  C言語に精通している必要があります。
 @c We begin with tutorial chapters that explain the basic concepts of using  
 @c Bison and show three explained examples, each building on the last.  If you  
 @c don't know Bison or Yacc, start by reading these chapters.  Reference  
 @c chapters follow which describe specific aspects of Bison in detail.  
 1章と2章は入門の章です。1章では、Bisonを使うための基本的な概念を説明し、  1章と2章は入門の章です。1章では、Bisonを使うための基本的な概念を説明し、
 2章では3つの具体例を示します。  2章では3つの具体例を示します。
 BisonやYaccを知らない方は、  BisonやYaccを知らない方は、
 1章から読みはじめてください。  1章から読みはじめてください。
 3章以降では、Bisonの仕様を詳細に解説します。  3章以降では、Bisonの仕様を詳細に解説します。
 @c Bison was written primarily by Robert Corbett; Richard Stallman made it  
 @c Yacc-compatible.  Wilfred Hansen of Carnegie Mellon University added  
 @c multicharacter string literals and other features.  
 Bisonは、最初にRobert Corbettによって開発され、  Bisonは、最初にRobert Corbettによって開発され、
 Richard StallmanがYacc互換にしました。  Richard StallmanがYacc互換にしました。
 カーネギーメロン大学のWilfred Hansenが、  カーネギーメロン大学のWilfred Hansenが、
 文字列リテラル@footnote{【訳注】2文字以上の文字列、たとえば@samp{==}を、  文字列リテラル@footnote{【訳注】2文字以上の文字列、たとえば@samp{==}を、
 トークン名に使う機能。}といくつかの機能を追加しました。  トークン名に使う機能。}といくつかの機能を追加しました。
 @c This edition corresponds to version @value{VERSION} of Bison.  
 本書は、Bisonのバージョン@value{VERSION}に基づいています。  本書は、Bisonのバージョン@value{VERSION}に基づいています。
 @unnumberedsec 日本語訳にあたって  @unnumberedsec 日本語訳にあたって
Line 397  gnujdoc の詳細は、 Line 371  gnujdoc の詳細は、
 @uref{http://duff.kuicr.kyoto-u.ac.jp/%7Eokuji/gnujdoc/}  @uref{http://duff.kuicr.kyoto-u.ac.jp/%7Eokuji/gnujdoc/}
 を参照してください。  を参照してください。
 @c =====================================================================  
 @node Conditions, Copying, Introduction, Top  @node Conditions, Copying, Introduction, Top
 @c @unnumbered Conditions for Using Bison  
 @unnumbered Bisonの利用条件  @unnumbered Bisonの利用条件
 @c As of Bison version 1.24, we have changed the distribution terms for  
 @c @code{yyparse} to permit using Bison's output in non-free programs.  
 @c Formerly, Bison parsers could be used only in programs that were free  
 @c software.  
 Bisonバージョン1.24において、フリーでないプログラムへのBisonの出力の  Bisonバージョン1.24において、フリーでないプログラムへのBisonの出力の
 利用を許可するために、@code{yyparse}の配布条件を変えました。  利用を許可するために、@code{yyparse}の配布条件を変えました。
 それまでは、Bisonによって生成された構文解析器は、  それまでは、Bisonによって生成された構文解析器は、
 フリーソフトウェアのプログラム中でのみ、利用可能でした。  フリーソフトウェアのプログラム中でのみ、利用可能でした。
 @c The other GNU programming tools, such as the GNU C compiler, have never  
 @c had such a requirement.  They could always be used for non-free  
 @c software.  The reason Bison was different was not due to a special  
 @c policy decision; it resulted from applying the usual General Public  
 @c License to all of the Bison source code.  
 GNU Cコンパイラなど他のGNUプログランミングツールには、  GNU Cコンパイラなど他のGNUプログランミングツールには、
 このような制限がありません。  このような制限がありません。
 それらは、いつでも、フリーでないソフトウェアの開発に利用できます。  それらは、いつでも、フリーでないソフトウェアの開発に利用できます。
 Bisonの利用条件が異なっていた理由は、特別な政治的判断によるものではありません。  Bisonの利用条件が異なっていた理由は、特別な政治的判断によるものではありません。
 BisonのすべてのソースコードにGPLを適用した結果です。  BisonのすべてのソースコードにGPLを適用した結果です。
 @c The output of the Bison utility---the Bison parser file---contains a  
 @c verbatim copy of a sizable piece of Bison, which is the code for the  
 @c @code{yyparse} function.  (The actions from your grammar are inserted  
 @c into this function at one point, but the rest of the function is not  
 @c changed.)  When we applied the GPL terms to the code for @code{yyparse},  
 @c the effect was to restrict the use of Bison output to free software.  
 Bisonの出力であるBison構文解析器ファイルには、  Bisonの出力であるBison構文解析器ファイルには、
 @code{yyparse}関数のためのコードである、  @code{yyparse}関数のためのコードである、
 かなりの量のBisonのソースコードの一部分が、そのまま含まれます  かなりの量のBisonのソースコードの一部分が、そのまま含まれます
Line 439  Bisonの出力であるBison構文解析器ファイル Line 393  Bisonの出力であるBison構文解析器ファイル
 われわれFSFが@code{yyparse}のコードにGPLを適用した結果、  われわれFSFが@code{yyparse}のコードにGPLを適用した結果、
 Bisonの出力をフリーソフトウェアのみに利用するという制約ができたのです。  Bisonの出力をフリーソフトウェアのみに利用するという制約ができたのです。
 @c We didn't change the terms because of sympathy for people who want to  
 @c make software proprietary.  @strong{Software should be free.}  But we  
 @c concluded that limiting Bison's use to free software was doing little to  
 @c encourage people to make other software free.  So we decided to make the  
 @c practical conditions for using Bison match the practical conditions for  
 @c using the other GNU tools.  
 ソフトウェアを専売しようとする人々への思いやりによって、  ソフトウェアを専売しようとする人々への思いやりによって、
 われわれが条件を変えることはありませんでした。  われわれが条件を変えることはありませんでした。
 @strong{ソフトウェアはフリーであるべきです。}  @strong{ソフトウェアはフリーであるべきです。}
Line 456  Bisonの出力をフリーソフトウェアのみに利 Line 403  Bisonの出力をフリーソフトウェアのみに利
 Bisonの現実的な利用条件を決定することにしました。  Bisonの現実的な利用条件を決定することにしました。
 @c =============================================================  
 @c = <using 引地さんが管理するGPLの日本語訳>  @c = <using 引地さんが管理するGPLの日本語訳>
 @c =============================================================  
 @node Copying, Concepts, Conditions, Top  @node Copying, Concepts, Conditions, Top
 @c @center Version 2, June 1991  
 @unnumbered GNU一般公有使用許諾書  @unnumbered GNU一般公有使用許諾書
 @center 1991年6月 バージョン2.0   @center 1991年6月 バージョン2.0 
Line 469  Bisonの現実的な利用条件を決定することに Line 412  Bisonの現実的な利用条件を決定することに
 Copyright @copyright{} 1989, 1991 Free Software Foundation, Inc.  Copyright @copyright{} 1989, 1991 Free Software Foundation, Inc.
 59 Temple Place - Suite 330, Boston, MA  02111-1307  USA  59 Temple Place - Suite 330, Boston, MA  02111-1307  USA
 @c Everyone is permitted to copy and distribute verbatim copies  
 @c of this license document, but changing it is not allowed.  
 何人も、以下の内容を変更しないでそのまま複写する場合に限り、  何人も、以下の内容を変更しないでそのまま複写する場合に限り、
 本使用許諾書を複製したり頒布することができます。  本使用許諾書を複製したり頒布することができます。
 @end display  @end display
 @c @unnumberedsec Preamble  
 @unnumberedsec はじめに  @unnumberedsec はじめに
 @c   The licenses for most software are designed to take away your  
 @c freedom to share and change it.  By contrast, the GNU General Public  
 @c License is intended to guarantee your freedom to share and change free  
 @c software---to make sure the software is free for all its users.  This  
 @c General Public License applies to most of the Free Software  
 @c Foundation's software and to any other program whose authors commit to  
 @c using it.  (Some other Free Software Foundation software is covered by  
 @c the GNU Library General Public License instead.)  You can apply it to  
 @c your programs, too.  
  ほとんどのソフトウェアの使用許諾は、ソフトウェアを共有し、   ほとんどのソフトウェアの使用許諾は、ソフトウェアを共有し、
 変更するユーザの自由を奪うことを意図しています。  変更するユーザの自由を奪うことを意図しています。
 それに対して、我々のGNU一般公有使用許諾は、  それに対して、我々のGNU一般公有使用許諾は、
Line 501  Copyright @copyright{} 1989, 1991 Free S Line 432  Copyright @copyright{} 1989, 1991 Free S
 本許諾書ではなく、GNUライブラリ一般公有使用許諾で保護されます。)  本許諾書ではなく、GNUライブラリ一般公有使用許諾で保護されます。)
 あなたは自分のプログラムにもこれを適用できます。  あなたは自分のプログラムにもこれを適用できます。
 @c   When we speak of free software, we are referring to freedom, not  
 @c price.  Our General Public Licenses are designed to make sure that you  
 @c have the freedom to distribute copies of free software (and charge for  
 @c this service if you wish), that you receive source code or can get it  
 @c if you want it, that you can change the software or use pieces of it  
 @c in new free programs; and that you know you can do these things.  
  我々がフリー・ソフトウェアについて言う場合は   我々がフリー・ソフトウェアについて言う場合は
 自由のことに言及しているのであって、価格のことではありません。  自由のことに言及しているのであって、価格のことではありません。
 我々の一般公有使用許諾の各条項は、次の事柄を確実に実現することを  我々の一般公有使用許諾の各条項は、次の事柄を確実に実現することを
Line 525  Copyright @copyright{} 1989, 1991 Free S Line 450  Copyright @copyright{} 1989, 1991 Free S
 以上の各内容を行なうことができるということをユーザ自身が知っていること。  以上の各内容を行なうことができるということをユーザ自身が知っていること。
 @end itemize  @end itemize
 @c   To protect your rights, we need to make restrictions that forbid  
 @c anyone to deny you these rights or to ask you to surrender the rights.  
 @c These restrictions translate to certain responsibilities for you if you  
 @c distribute copies of the software, or if you modify it.  
  このようなユーザの権利を守るために、我々は、   このようなユーザの権利を守るために、我々は、
 何人もこれらの権利を否定したり、あるいは放棄するように  何人もこれらの権利を否定したり、あるいは放棄するように
 ユーザに求めることはできないという制限条項を設ける必要があります。  ユーザに求めることはできないという制限条項を設ける必要があります。
 これらの制限条項は、ユーザが、フリー・ソフトウェアの複製物を  これらの制限条項は、ユーザが、フリー・ソフトウェアの複製物を
 頒布したり変更しようとする場合には、そのユーザ自身が守るべき義務ともなります。  頒布したり変更しようとする場合には、そのユーザ自身が守るべき義務ともなります。
 @c   For example, if you distribute copies of such a program, whether  
 @c gratis or for a fee, you must give the recipients all the rights that  
 @c you have.  You must make sure that they, too, receive or can get the  
 @c source code.  And you must show them these terms so they know their  
 @c rights.  
  例えば、あなたがフリー・ソフトウェアの複製物を頒布する場合、   例えば、あなたがフリー・ソフトウェアの複製物を頒布する場合、
 有償か無償かにかかわらず、  有償か無償かにかかわらず、
 あなたは自分の持っている権利を全て相手に与えなければなりません。  あなたは自分の持っている権利を全て相手に与えなければなりません。
Line 548  Copyright @copyright{} 1989, 1991 Free S Line 464  Copyright @copyright{} 1989, 1991 Free S
 さらにあなたは、彼らが自分たちの権利を知るように、  さらにあなたは、彼らが自分たちの権利を知るように、
 これらの条項を知らしめなければなりません。  これらの条項を知らしめなければなりません。
 @c   We protect your rights with two steps: (1) copyright the software, and  
 @c (2) offer you this license which gives you legal permission to copy,  
 @c distribute and/or modify the software.  
  我々は次の2つの方法でユーザの権利を守ります。   我々は次の2つの方法でユーザの権利を守ります。
 (1)ソフトウェアに著作権を主張し、  (1)ソフトウェアに著作権を主張し、
 (2)本使用許諾の条項の下で  (2)本使用許諾の条項の下で
 ソフトウェアを複製・頒布・変更する権利をユーザに与えます。  ソフトウェアを複製・頒布・変更する権利をユーザに与えます。
 @c   Also, for each author's protection and ours, we want to make certain  
 @c that everyone understands that there is no warranty for this free  
 @c software.  If the software is modified by someone else and passed on, we  
 @c want its recipients to know that what they have is not the original, so  
 @c that any problems introduced by others will not reflect on the original  
 @c authors' reputations.  
  また、各作成者や我々自身を守るために、   また、各作成者や我々自身を守るために、
 本フリー・ソフトウェアが無保証であることを  本フリー・ソフトウェアが無保証であることを
 全ての人々が了解している必要があります。  全ての人々が了解している必要があります。
Line 571  Copyright @copyright{} 1989, 1991 Free S Line 478  Copyright @copyright{} 1989, 1991 Free S
 それは、他人の関与によって原開発者に対する評価が  それは、他人の関与によって原開発者に対する評価が
 影響されないようにするためです。  影響されないようにするためです。
 @c   Finally, any free program is threatened constantly by software  
 @c patents.  We wish to avoid the danger that redistributors of a free  
 @c program will individually obtain patent licenses, in effect making the  
 @c program proprietary.  To prevent this, we have made it clear that any  
 @c patent must be licensed for everyone's free use or not licensed at all.  
  最後に、どのフリー・プログラムもソフトウェア特許に絶えず脅かされています。   最後に、どのフリー・プログラムもソフトウェア特許に絶えず脅かされています。
 我々は、フリー・プログラムの再頒布者が個人的に特許権を取得し、  我々は、フリー・プログラムの再頒布者が個人的に特許権を取得し、
 事実上そのプログラムを自分の財産にしてしまうという危険を  事実上そのプログラムを自分の財産にしてしまうという危険を
Line 585  Copyright @copyright{} 1989, 1991 Free S Line 487  Copyright @copyright{} 1989, 1991 Free S
 あるいは何人に対しても全く使用させないかの、  あるいは何人に対しても全く使用させないかの、
 いずれかにすべきであることを明らかにしてきました。  いずれかにすべきであることを明らかにしてきました。
 @c   The precise terms and conditions for copying, distribution and  
 @c modification follow.  
  複写・頒布・変更に対する正確な条項と条件を次に示します。   複写・頒布・変更に対する正確な条項と条件を次に示します。
 @iftex  @iftex
 @unnumberedsec GNU一般公有使用許諾の下での複製、頒布、変更に関する条項と条件  @unnumberedsec GNU一般公有使用許諾の下での複製、頒布、変更に関する条項と条件
 @end iftex  @end iftex
 @ifinfo  @ifinfo
 @center GNU一般公有使用許諾の下での複製、頒布、変更に関する条項と条件  @center GNU一般公有使用許諾の下での複製、頒布、変更に関する条項と条件
 @end ifinfo  @end ifinfo
 @enumerate 1  @enumerate 1
 @item  @item
 @c This License applies to any program or other work which contains  
 @c a notice placed by the copyright holder saying it may be distributed  
 @c under the terms of this General Public License.  The ``Program'', below,  
 @c refers to any such program or work, and a ``work based on the Program''  
 @c means either the Program or any derivative work under copyright law:  
 @c that is to say, a work containing the Program or a portion of it,  
 @c either verbatim or with modifications and/or translated into another  
 @c language.  (Hereinafter, translation is included without limitation in  
 @c the term ``modification''.)  Each licensee is addressed as ``you''.  
 本使用許諾は、本一般公有使用許諾の各条項に従って頒布されるという  本使用許諾は、本一般公有使用許諾の各条項に従って頒布されるという
 著作権者からの告知文が表示されているプログラムやその他の作成物に適用されます。  著作権者からの告知文が表示されているプログラムやその他の作成物に適用されます。
 以下において「プログラム」とは、そのようなプログラムや作成物を指すものとし、  以下において「プログラム」とは、そのようなプログラムや作成物を指すものとし、
Line 619  Copyright @copyright{} 1989, 1991 Free S Line 508  Copyright @copyright{} 1989, 1991 Free S
 (以下、言語変換は「変更」という用語の中に無条件に含まれるものとします。)  (以下、言語変換は「変更」という用語の中に無条件に含まれるものとします。)
 本使用許諾によって許諾を受ける者を「あなた」と呼びます。   本使用許諾によって許諾を受ける者を「あなた」と呼びます。 
 @c Activities other than copying, distribution and modification are not  
 @c covered by this License; they are outside its scope.  The act of  
 @c running the Program is not restricted, and the output from the Program  
 @c is covered only if its contents constitute a work based on the  
 @c Program (independent of having been made by running the Program).  
 @c Whether that is true depends on what the Program does.  
 複製、頒布、変更以外の行為は本使用許諾の対象としません。  複製、頒布、変更以外の行為は本使用許諾の対象としません。
 それらは本使用許諾の範囲外です。  それらは本使用許諾の範囲外です。
 「プログラム」を実行させる行為に関して制約はありません。  「プログラム」を実行させる行為に関して制約はありません。
Line 634  Copyright @copyright{} 1989, 1991 Free S Line 517  Copyright @copyright{} 1989, 1991 Free S
 これが当てはまるかどうかは、「プログラム」が何をするものかに依ります。  これが当てはまるかどうかは、「プログラム」が何をするものかに依ります。
 @item  @item
 @c You may copy and distribute verbatim copies of the Program's  
 @c source code as you receive it, in any medium, provided that you  
 @c conspicuously and appropriately publish on each copy an appropriate  
 @c copyright notice and disclaimer of warranty; keep intact all the  
 @c notices that refer to this License and to the absence of any warranty;  
 @c and give any other recipients of the Program a copy of this License  
 @c along with the Program.  
 あなたは、どのような媒体上へ複製しようとする場合であっても、  あなたは、どのような媒体上へ複製しようとする場合であっても、
 入手した「プログラム」のソース・コードを  入手した「プログラム」のソース・コードを
 そのままの内容で複写した上で適正な著作権表示と保証の放棄を明確、  そのままの内容で複写した上で適正な著作権表示と保証の放棄を明確、
Line 650  Copyright @copyright{} 1989, 1991 Free S Line 526  Copyright @copyright{} 1989, 1991 Free S
 また、「プログラム」の頒布先に対しては、  また、「プログラム」の頒布先に対しては、
 「プログラム」と共に本使用許諾書の写しを渡してください。  「プログラム」と共に本使用許諾書の写しを渡してください。
 @c You may charge a fee for the physical act of transferring a copy, and  
 @c you may at your option offer warranty protection in exchange for a fee.  
 複製物の引き渡しに要する実費は請求することができます。  複製物の引き渡しに要する実費は請求することができます。
 また、あなた独自の保証を行なう場合はそれを有償とすることができます。  また、あなた独自の保証を行なう場合はそれを有償とすることができます。
 @item  @item
 @c You may modify your copy or copies of the Program or any portion  
 @c of it, thus forming a work based on the Program, and copy and  
 @c distribute such modifications or work under the terms of Section 1  
 @c above, provided that you also meet all of these conditions:  
 次の各条件を全て満たしている限り、あなたは、  次の各条件を全て満たしている限り、あなたは、
 「プログラム」又はその一部分を変更して「プログラム生成物」とすることができ、  「プログラム」又はその一部分を変更して「プログラム生成物」とすることができ、
 さらに、変更版や右作成物を上記第2項に従って複製又は頒布することもできます。  さらに、変更版や右作成物を上記第2項に従って複製又は頒布することもできます。
 @enumerate a  @enumerate a
 @item  @item
 @c You must cause the modified files to carry prominent notices  
 @c stating that you changed the files and the date of any change.  
 ファイルを変更した旨とその変更日とを、変更したファイル上に明確に表示すること。  ファイルを変更した旨とその変更日とを、変更したファイル上に明確に表示すること。
 @item  @item
 @c You must cause any work that you distribute or publish, that in  
 @c whole or in part contains or is derived from the Program or any  
 @c part thereof, to be licensed as a whole at no charge to all third  
 @c parties under the terms of this License.  
 変更したか否かを問わず、凡そ「プログラム」  変更したか否かを問わず、凡そ「プログラム」
 又はその一部分を内部に組み込んでいるか  又はその一部分を内部に組み込んでいるか
 又はそれから派生した生成物を頒布する場合には、  又はそれから派生した生成物を頒布する場合には、
 その全体を本使用許諾の条項に従って第三者へ無償で使用許諾すること。  その全体を本使用許諾の条項に従って第三者へ無償で使用許諾すること。
 @item  @item
 @c If the modified program normally reads commands interactively  
 @c when run, you must cause it, when started running for such  
 @c interactive use in the most ordinary way, to print or display an  
 @c announcement including an appropriate copyright notice and a  
 @c notice that there is no warranty (or else, saying that you provide  
 @c a warranty) and that users may redistribute the program under  
 @c these conditions, and telling the user how to view a copy of this  
 @c License.  (Exception: if the Program itself is interactive but  
 @c does not normally print such an announcement, your work based on  
 @c the Program is not required to print an announcement.)  
 変更したプログラムが実行時に通常の対話的な方法で  変更したプログラムが実行時に通常の対話的な方法で
 コマンドを読むようになっているとすれば、  コマンドを読むようになっているとすれば、
 最も普通の方法で対話的にそのプログラムを実行する時に、  最も普通の方法で対話的にそのプログラムを実行する時に、
Line 711  Copyright @copyright{} 1989, 1991 Free S Line 565  Copyright @copyright{} 1989, 1991 Free S
 @end itemize  @end itemize
 @end enumerate  @end enumerate
 @c These requirements apply to the modified work as a whole.  If  
 @c identifiable sections of that work are not derived from the Program,  
 @c and can be reasonably considered independent and separate works in  
 @c themselves, then this License, and its terms, do not apply to those  
 @c sections when you distribute them as separate works.  But when you  
 @c distribute the same sections as part of a whole which is a work based  
 @c on the Program, the distribution of the whole must be on the terms of  
 @c this License, whose permissions for other licensees extend to the  
 @c entire whole, and thus to each and every part regardless of who wrote it.  
 これらの要件は変更された作成物にも全て適用されます。  これらの要件は変更された作成物にも全て適用されます。
 その変更版の或る部分が「プログラム」の派生物ではなく、  その変更版の或る部分が「プログラム」の派生物ではなく、
 しかもそれ自体独立で異なる作成物だと合理的に考えられる場合、  しかもそれ自体独立で異なる作成物だと合理的に考えられる場合、
Line 732  Copyright @copyright{} 1989, 1991 Free S Line 577  Copyright @copyright{} 1989, 1991 Free S
 結果として、誰が書いたかにかかわらず、  結果として、誰が書いたかにかかわらず、
 全ての部分に本使用許諾が適用されなければなりません。  全ての部分に本使用許諾が適用されなければなりません。
 @c Thus, it is not the intent of this section to claim rights or contest  
 @c your rights to work written entirely by you; rather, the intent is to  
 @c exercise the right to control the distribution of derivative or  
 @c collective works based on the Program.  
 このように、本条項の意図するところは、  このように、本条項の意図するところは、
 完全にあなたによって書かれた作成物について、権利を要求したり、  完全にあなたによって書かれた作成物について、権利を要求したり、
 あなたと権利関係を争うことではありません。  あなたと権利関係を争うことではありません。
 むしろその目的は、作成物が「プログラム生成物」  むしろその目的は、作成物が「プログラム生成物」
 である場合にその派生物や集合物の頒布を規制することにあります。  である場合にその派生物や集合物の頒布を規制することにあります。
 @c In addition, mere aggregation of another work not based on the Program  
 @c with the Program (or with a work based on the Program) on a volume of  
 @c a storage or distribution medium does not bring the other work under  
 @c the scope of this License.  
 さらに、「プログラム」(又は「プログラム生成物」)と  さらに、「プログラム」(又は「プログラム生成物」)と
 「プログラム生成物」とはならない他のプログラムとを、  「プログラム生成物」とはならない他のプログラムとを、
 単に保管や頒布のために同一の媒体上にまとめて記録したとしても、  単に保管や頒布のために同一の媒体上にまとめて記録したとしても、
 本使用許諾は他のプログラムには適用されません。  本使用許諾は他のプログラムには適用されません。
 @item  @item
 @c You may copy and distribute the Program (or a work based on it,  
 @c under Section 2) in object code or executable form under the terms of  
 @c Sections 1 and 2 above provided that you also do one of the following:  
 あなたは、以下のうちいずれか1つを満たす限り、  あなたは、以下のうちいずれか1つを満たす限り、
 上記第2項及び第3項に従って「プログラム」  上記第2項及び第3項に従って「プログラム」
 (又は、上記第3項で言及している「プログラム生成物」)を  (又は、上記第3項で言及している「プログラム生成物」)を
Line 762  Copyright @copyright{} 1989, 1991 Free S Line 596  Copyright @copyright{} 1989, 1991 Free S
 @enumerate a  @enumerate a
 @item  @item
 @c Accompany it with the complete corresponding machine-readable  
 @c source code, which must be distributed under the terms of Sections  
 @c 1 and 2 above on a medium customarily used for software interchange; or,  
 対応する機械読み取り可能なソース・コード一式を一緒に引き渡すこと。  対応する機械読み取り可能なソース・コード一式を一緒に引き渡すこと。
 その場合、そのソース・コードの引き渡しは上記第2項及び第3項に従って、  その場合、そのソース・コードの引き渡しは上記第2項及び第3項に従って、
 通常ソフトウェアの交換に用いられる媒体で行なわれること。  通常ソフトウェアの交換に用いられる媒体で行なわれること。
 @item  @item
 @c Accompany it with a written offer, valid for at least three  
 @c years, to give any third party, for a charge no more than your  
 @c cost of physically performing source distribution, a complete  
 @c machine-readable copy of the corresponding source code, to be  
 @c distributed under the terms of Sections 1 and 2 above on a medium  
 @c customarily used for software interchange; or,  
 少なくとも3年間の有効期間を定め、  少なくとも3年間の有効期間を定め、
 且つその期間内であれば対応する機械読み取り可能なソース・コード一式の複製を、  且つその期間内であれば対応する機械読み取り可能なソース・コード一式の複製を、
 ソース頒布に関わる実費以上の対価を要求せずに提供する旨、  ソース頒布に関わる実費以上の対価を要求せずに提供する旨、
Line 784  Copyright @copyright{} 1989, 1991 Free S Line 609  Copyright @copyright{} 1989, 1991 Free S
 第三者に一緒に引き渡すこと。  第三者に一緒に引き渡すこと。
 @item  @item
 @c Accompany it with the information you received as to the offer  
 @c to distribute corresponding source code.  (This alternative is  
 @c allowed only for noncommercial distribution and only if you  
 @c received the program in object code or executable form with such  
 @c an offer, in accord with Subsection b above.)  
 対応するソース・コード頒布の申し出に際して、  対応するソース・コード頒布の申し出に際して、
 あなたが得た情報を一緒に引き渡すこと。  あなたが得た情報を一緒に引き渡すこと。
 (この選択肢は、営利を目的としない頒布であって、  (この選択肢は、営利を目的としない頒布であって、
Line 797  Copyright @copyright{} 1989, 1991 Free S Line 617  Copyright @copyright{} 1989, 1991 Free S
 プログラムしか入手していない場合に限り適用される選択項目です。)  プログラムしか入手していない場合に限り適用される選択項目です。)
 @end enumerate  @end enumerate
 @c The source code for a work means the preferred form of the work for  
 @c making modifications to it.  For an executable work, complete source  
 @c code means all the source code for all modules it contains, plus any  
 @c associated interface definition files, plus the scripts used to  
 @c control compilation and installation of the executable.  However, as a  
 @c special exception, the source code distributed need not include  
 @c anything that is normally distributed (in either source or binary  
 @c form) with the major components (compiler, kernel, and so on) of the  
 @c operating system on which the executable runs, unless that component  
 @c itself accompanies the executable.  
 なお、ソース・コードとは、変更作業に適した記述形式を指します。  なお、ソース・コードとは、変更作業に適した記述形式を指します。
 また、実行可能形式のファイルに対応するソース・コード一式とは、  また、実行可能形式のファイルに対応するソース・コード一式とは、
 それに含まれる全モジュールに対応する全てのソース・コード、  それに含まれる全モジュールに対応する全てのソース・コード、
Line 818  Copyright @copyright{} 1989, 1991 Free S Line 628  Copyright @copyright{} 1989, 1991 Free S
 その構成要素自体が実行形式に付随していない場合に限り、  その構成要素自体が実行形式に付随していない場合に限り、
 頒布されるソース・コードに含める必要はありません。  頒布されるソース・コードに含める必要はありません。
 @c If distribution of executable or object code is made by offering  
 @c access to copy from a designated place, then offering equivalent  
 @c access to copy the source code from the same place counts as  
 @c distribution of the source code, even though third parties are not  
 @c compelled to copy the source along with the object code.  
 実行可能形式またはオブジェクト・コードの頒布が、  実行可能形式またはオブジェクト・コードの頒布が、
 指示された場所からの複製のためのアクセス権の賦与である場合、  指示された場所からの複製のためのアクセス権の賦与である場合、
 同じ場所からのソース・コードの複製のための同等なアクセス権を賦与すれば、  同じ場所からのソース・コードの複製のための同等なアクセス権を賦与すれば、
Line 830  Copyright @copyright{} 1989, 1991 Free S Line 635  Copyright @copyright{} 1989, 1991 Free S
 ソース・コードを頒布したものとみなします。  ソース・コードを頒布したものとみなします。
 @item  @item
 @c You may not copy, modify, sublicense, or distribute the Program  
 @c except as expressly provided under this License.  Any attempt  
 @c otherwise to copy, modify, sublicense or distribute the Program is  
 @c void, and will automatically terminate your rights under this License.  
 @c However, parties who have received copies, or rights, from you under  
 @c this License will not have their licenses terminated so long as such  
 @c parties remain in full compliance.  
 本使用許諾が明示的に許諾している場合を除き、あなたは、  本使用許諾が明示的に許諾している場合を除き、あなたは、
 「プログラム」を複製、変更、サブライセンス、頒布することができません。  「プログラム」を複製、変更、サブライセンス、頒布することができません。
 本使用許諾に従わずに「プログラム」を複製、変更、サブライセンス、  本使用許諾に従わずに「プログラム」を複製、変更、サブライセンス、
Line 847  Copyright @copyright{} 1989, 1991 Free S Line 645  Copyright @copyright{} 1989, 1991 Free S
 引続き有効な使用権限を持つものとします。  引続き有効な使用権限を持つものとします。
 @item  @item
 @c You are not required to accept this License, since you have not  
 @c signed it.  However, nothing else grants you permission to modify or  
 @c distribute the Program or its derivative works.  These actions are  
 @c prohibited by law if you do not accept this License.  Therefore, by  
 @c modifying or distributing the Program (or any work based on the  
 @c Program), you indicate your acceptance of this License to do so, and  
 @c all its terms and conditions for copying, distributing or modifying  
 @c the Program or works based on it.  
 あなたはまだ同意の印として署名していないので、  あなたはまだ同意の印として署名していないので、
 本使用許諾を受け入れる必要はありません。  本使用許諾を受け入れる必要はありません。
 しかし、あなたに「プログラム」又はその派生物を変更又は再頒布する許可を  しかし、あなたに「プログラム」又はその派生物を変更又は再頒布する許可を
Line 867  Copyright @copyright{} 1989, 1991 Free S Line 657  Copyright @copyright{} 1989, 1991 Free S
 関するこれらの条項と条件の全てを受け入れたことを示します。  関するこれらの条項と条件の全てを受け入れたことを示します。
 @item  @item
 @c Each time you redistribute the Program (or any work based on the  
 @c Program), the recipient automatically receives a license from the  
 @c original licensor to copy, distribute or modify the Program subject to  
 @c these terms and conditions.  You may not impose any further  
 @c restrictions on the recipients' exercise of the rights granted herein.  
 @c You are not responsible for enforcing compliance by third parties to  
 @c this License.  
 あなたが「プログラム」(又はその「プログラム生成物」)を再頒布すると自動的に、  あなたが「プログラム」(又はその「プログラム生成物」)を再頒布すると自動的に、
 その受領者は、元の使用許諾者から、本使用許諾の条項に従って「プログラム」を  その受領者は、元の使用許諾者から、本使用許諾の条項に従って「プログラム」を
 複製、頒布、変更することを内容とする使用許諾を受けたものとします。  複製、頒布、変更することを内容とする使用許諾を受けたものとします。
Line 882  Copyright @copyright{} 1989, 1991 Free S Line 665  Copyright @copyright{} 1989, 1991 Free S
 あなたには、第三者に本使用許諾の受け入れを強いる責任はありません。  あなたには、第三者に本使用許諾の受け入れを強いる責任はありません。
 @item  @item
 @c If, as a consequence of a court judgment or allegation of patent  
 @c infringement or for any other reason (not limited to patent issues),  
 @c conditions are imposed on you (whether by court order, agreement or  
 @c otherwise) that contradict the conditions of this License, they do not  
 @c excuse you from the conditions of this License.  If you cannot  
 @c distribute so as to satisfy simultaneously your obligations under this  
 @c License and any other pertinent obligations, then as a consequence you  
 @c may not distribute the Program at all.  For example, if a patent  
 @c license would not permit royalty-free redistribution of the Program by  
 @c all those who receive copies directly or indirectly through you, then  
 @c the only way you could satisfy both it and this License would be to  
 @c refrain entirely from distribution of the Program.  
 裁判所の判決、又は特許侵害の申し立て、又は(特許問題に限らない)  裁判所の判決、又は特許侵害の申し立て、又は(特許問題に限らない)
 何らかの理由の結果として、あなたに課せられた条件が本使用許諾と  何らかの理由の結果として、あなたに課せられた条件が本使用許諾と
 相入れないものであったとしても(裁判所の命令、契約、その他によるものであれ)、  相入れないものであったとしても(裁判所の命令、契約、その他によるものであれ)、
Line 906  Copyright @copyright{} 1989, 1991 Free S Line 677  Copyright @copyright{} 1989, 1991 Free S
 あなたがかかる特許上の要請と本使用許諾の両方を満足させる方法は、  あなたがかかる特許上の要請と本使用許諾の両方を満足させる方法は、
 「プログラム」の頒布を完全に断念することだけです。  「プログラム」の頒布を完全に断念することだけです。
 @c If any portion of this section is held invalid or unenforceable under  
 @c any particular circumstance, the balance of the section is intended to  
 @c apply and the section as a whole is intended to apply in other  
 @c circumstances.  
 本条項の或る部分が何らかの特別な状況下で無効または適用不可能になった場合、  本条項の或る部分が何らかの特別な状況下で無効または適用不可能になった場合、
 本条項のその他の残りの部分が適用されるように意図されており、また、  本条項のその他の残りの部分が適用されるように意図されており、また、
 本条項は全体としてその他の状況に当てはまるように意図されています。  本条項は全体としてその他の状況に当てはまるように意図されています。
 @c It is not the purpose of this section to induce you to infringe any  
 @c patents or other property right claims or to contest validity of any  
 @c such claims; this section has the sole purpose of protecting the  
 @c integrity of the free software distribution system, which is  
 @c implemented by public license practices.  Many people have made  
 @c generous contributions to the wide range of software distributed  
 @c through that system in reliance on consistent application of that  
 @c system; it is up to the author/donor to decide if he or she is willing  
 @c to distribute software through any other system and a licensee cannot  
 @c impose that choice.  
 本条項の目的は、特許やその他の財産権を侵害したり、  本条項の目的は、特許やその他の財産権を侵害したり、
 そのような権利に基づく主張の妥当性を争うようにあなたに  そのような権利に基づく主張の妥当性を争うようにあなたに
 勧めることではありません。  勧めることではありません。
Line 936  Copyright @copyright{} 1989, 1991 Free S Line 693  Copyright @copyright{} 1989, 1991 Free S
 頒布したいと決めることは彼らの自由意志であり、  頒布したいと決めることは彼らの自由意志であり、
 使用許諾を受ける者はその選択を強いることはできません。  使用許諾を受ける者はその選択を強いることはできません。
 @c This section is intended to make thoroughly clear what is believed to  
 @c be a consequence of the rest of this License.  
 本条項は、本使用許諾の他の条項の意味内容が何であるかを  本条項は、本使用許諾の他の条項の意味内容が何であるかを
 完全に明らかにすることを意図しています。  完全に明らかにすることを意図しています。
 @item  @item
 @c If the distribution and/or use of the Program is restricted in  
 @c certain countries either by patents or by copyrighted interfaces, the  
 @c original copyright holder who places the Program under this License  
 @c may add an explicit geographical distribution limitation excluding  
 @c those countries, so that distribution is permitted only in or among  
 @c countries not thus excluded.  In such case, this License incorporates  
 @c the limitation as if written in the body of this License.  
 「プログラム」の頒布・使用が、ある国において特許又は著作権で  「プログラム」の頒布・使用が、ある国において特許又は著作権で
 保護されたインタフェースのどちらかで制限される場合、  保護されたインタフェースのどちらかで制限される場合、
 「プログラム」を本使用許諾下においた原著作権保持者は、  「プログラム」を本使用許諾下においた原著作権保持者は、
Line 959  Copyright @copyright{} 1989, 1991 Free S Line 707  Copyright @copyright{} 1989, 1991 Free S
 あたかも書かれているかのように本使用許諾の中に組み入れられるものとします。  あたかも書かれているかのように本使用許諾の中に組み入れられるものとします。
 @item  @item
 @c The Free Software Foundation may publish revised and/or new versions  
 @c of the General Public License from time to time.  Such new versions will  
 @c be similar in spirit to the present version, but may differ in detail to  
 @c address new problems or concerns.  
 Free Software Foundation は随時、本一般公有使用許諾の改訂版、  Free Software Foundation は随時、本一般公有使用許諾の改訂版、
 又は新版を公表することがあります。  又は新版を公表することがあります。
 そのような新しいバージョンは、  そのような新しいバージョンは、
 現行のバージョンと基本的に変わるところはありませんが、  現行のバージョンと基本的に変わるところはありませんが、
 新しい問題や懸案事項に対応するために細部では異なるかもしれません。  新しい問題や懸案事項に対応するために細部では異なるかもしれません。
 @c Each version is given a distinguishing version number.  If the Program  
 @c specifies a version number of this License which applies to it and ``any  
 @c later version'', you have the option of following the terms and conditions  
 @c either of that version or of any later version published by the Free  
 @c Software Foundation.  If the Program does not specify a version number of  
 @c this License, you may choose any version ever published by the Free Software  
 @c Foundation.  
 各バージョンは、バージョン番号によって区別します。  各バージョンは、バージョン番号によって区別します。
 「プログラム」中に本使用許諾のバージョン番号の指定がある場合は、  「プログラム」中に本使用許諾のバージョン番号の指定がある場合は、
 その指定されたバージョンか、又はその後にFree Software Foundationから  その指定されたバージョンか、又はその後にFree Software Foundationから
Line 985  Free Software Foundation は随時、本一般 Line 722  Free Software Foundation は随時、本一般
 Free Software Foundation が公表したどのバージョンでも選択することができます。  Free Software Foundation が公表したどのバージョンでも選択することができます。
 @item  @item
 @c If you wish to incorporate parts of the Program into other free  
 @c programs whose distribution conditions are different, write to the author  
 @c to ask for permission.  For software which is copyrighted by the Free  
 @c Software Foundation, write to the Free Software Foundation; we sometimes  
 @c make exceptions for this.  Our decision will be guided by the two goals  
 @c of preserving the free status of all derivatives of our free software and  
 @c of promoting the sharing and reuse of software generally.  
 「プログラム」の一部を頒布条件の異なる他のフリー・プログラムに  「プログラム」の一部を頒布条件の異なる他のフリー・プログラムに
 組み込みたい場合は、その開発者に書面で許可を求めてください。   組み込みたい場合は、その開発者に書面で許可を求めてください。 
 Free Software Foundation が著作権を持っているソフトウェアについては、  Free Software Foundation が著作権を持っているソフトウェアについては、
Line 1003  Free Software Foundation へ書面を提出し Line 733  Free Software Foundation へ書面を提出し
 広く促進させることです。  広く促進させることです。
 @iftex  @iftex
 @c @heading NO WARRANTY  
 @heading 無保証  @heading 無保証
 @end iftex  @end iftex
 @ifinfo  @ifinfo
 @c @center NO WARRANTY  
 @center 無保証  @center 無保証
 @end ifinfo  @end ifinfo
 @item  @item
 「プログラム」は無償で使用許諾されますので、適用法令の範囲内で、  「プログラム」は無償で使用許諾されますので、適用法令の範囲内で、
 「プログラム」の保証は一切ありません。  「プログラム」の保証は一切ありません。
 著作権者やその他の第三者は全く無保証で「そのまま」の状態で、且つ、  著作権者やその他の第三者は全く無保証で「そのまま」の状態で、且つ、
Line 1032  Free Software Foundation へ書面を提出し Line 751  Free Software Foundation へ書面を提出し
 それに伴う一切の派生費用や修理・訂正に要する費用は全てあなたの負担とします。  それに伴う一切の派生費用や修理・訂正に要する費用は全てあなたの負担とします。
 @item  @item
 適用法令の定め、又は書面による合意がある場合を除き、  適用法令の定め、又は書面による合意がある場合を除き、
 著作権者や上記許諾を受けて「プログラム」の変更・再頒布を為し得る第三者は、  著作権者や上記許諾を受けて「プログラム」の変更・再頒布を為し得る第三者は、
 「プログラム」を使用したこと、  「プログラム」を使用したこと、
Line 1054  Free Software Foundation へ書面を提出し Line 764  Free Software Foundation へ書面を提出し
 @end enumerate  @end enumerate
 @iftex  @iftex
 @heading 以上  @heading 以上
 @end iftex  @end iftex
 @ifinfo  @ifinfo
 @center 以上  @center 以上
 @end ifinfo  @end ifinfo
Line 1086  Free Software Foundation へ書面を提出し Line 794  Free Software Foundation へ書面を提出し
 @end itemize  @end itemize
 @page  @page
 @c @unnumberedsec How to Apply These Terms to Your New Programs  
 @unnumberedsec あなたの新しいプログラムにこれらの条項を適用する方法  @unnumberedsec あなたの新しいプログラムにこれらの条項を適用する方法
 @c   If you develop a new program, and you want it to be of the greatest  
 @c possible use to the public, the best way to achieve this is to make it  
 @c free software which everyone can redistribute and change under these terms.  
  あなたが新しくプログラムを作成し、それを公用に供したい場合は、   あなたが新しくプログラムを作成し、それを公用に供したい場合は、
 プログラムをフリー・ソフトウェアにして、  プログラムをフリー・ソフトウェアにして、
 全ての人々が以上の各条項に従ってこれを再頒布や変更をすることが  全ての人々が以上の各条項に従ってこれを再頒布や変更をすることが
 できるようにするのが最良の方法です。  できるようにするのが最良の方法です。
 @c   To do so, attach the following notices to the program.  It is safest  
 @c to attach them to the start of each source file to most effectively  
 @c convey the exclusion of warranty; and each file should have at least  
 @c the ``copyright'' line and a pointer to where the full notice is found.  
  そうするためには、プログラムに以下の表示をしてください。   そうするためには、プログラムに以下の表示をしてください。
 その場合、無保証であるということを最も効果的に伝えるために、  その場合、無保証であるということを最も効果的に伝えるために、
 ソース・ファイルの冒頭にその全文を表示すれば最も安全ですが、  ソース・ファイルの冒頭にその全文を表示すれば最も安全ですが、
Line 1108  Free Software Foundation へ書面を提出し Line 808  Free Software Foundation へ書面を提出し
 アドレスへのポインタだけはファイル上に表示しておいてください。  アドレスへのポインタだけはファイル上に表示しておいてください。
 @smallexample  @smallexample
 @c @var{one line to give the program's name and an idea of what it does.}  
 @c Copyright (C) 19@var{yy}  @var{name of author}  
 @var{プログラム名とどんな動作をするものかについての簡単な説明の行}  @var{プログラム名とどんな動作をするものかについての簡単な説明の行}
 Copyright(C) 19○○年、@var{著作権者名}  Copyright(C) 19○○年、@var{著作権者名}
 @c This program is free software; you can redistribute it and/or  
 @c modify it under the terms of the GNU General Public License  
 @c as published by the Free Software Foundation; either version 2  
 @c of the License, or (at your option) any later version.  
 本プログラムはフリー・ソフトウェアです。  本プログラムはフリー・ソフトウェアです。
 あなたは、Free Software Foundationが公表したGNU 一般公有使用許諾の  あなたは、Free Software Foundationが公表したGNU 一般公有使用許諾の
 「バージョン2」或いはそれ以降の各バージョンの中からいずれかを選択し、  「バージョン2」或いはそれ以降の各バージョンの中からいずれかを選択し、
 そのバージョンが定める条項に従って本プログラムを  そのバージョンが定める条項に従って本プログラムを
 再頒布または変更することができます。  再頒布または変更することができます。
 @c This program is distributed in the hope that it will be useful,  
 @c but WITHOUT ANY WARRANTY; without even the implied warranty of  
 @c GNU General Public License for more details.  
 本プログラムは有用とは思いますが、頒布にあたっては、  本プログラムは有用とは思いますが、頒布にあたっては、
 市場性及び特定目的適合性についての暗黙の保証を含めて、  市場性及び特定目的適合性についての暗黙の保証を含めて、
 いかなる保証も行ないません。  いかなる保証も行ないません。
 詳細についてはGNU 一般公有使用許諾書をお読みください。  詳細についてはGNU 一般公有使用許諾書をお読みください。
 @c You should have received a copy of the GNU General Public License along  
 @c with this program; if not, write to the Free Software Foundation, Inc.,  
 @c 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.  
 あなたは、本プログラムと一緒にGNU一般公有使用許諾の写しを  あなたは、本プログラムと一緒にGNU一般公有使用許諾の写しを
 受け取っているはずです。  受け取っているはずです。
 そうでない場合は、@*  そうでない場合は、@*
Line 1143  Boston, MA 02111-1307, USA Line 830  Boston, MA 02111-1307, USA
 へ手紙を書いてください。  へ手紙を書いてください。
 @end smallexample  @end smallexample
 @c Also add information on how to contact you by electronic and paper mail.  
 また、ユーザが電子メイルや書信であなたと連絡をとる方法についての情報も  また、ユーザが電子メイルや書信であなたと連絡をとる方法についての情報も
 書き添えてください。  書き添えてください。
 @c If the program is interactive, make it output a short notice like this  
 @c when it starts in an interactive mode:  
 プログラムが対話的に動作する場合は、  プログラムが対話的に動作する場合は、
 対話モードで起動した時に次のような短い告知文が表示されるようにしてください。  対話モードで起動した時に次のような短い告知文が表示されるようにしてください。
 @smallexample  @smallexample
 @c Gnomovision version 69, Copyright (C) 19@var{yy} @var{name of author}  
 @c Gnomovision comes with ABSOLUTELY NO WARRANTY; for details  
 @c type `show w'.  This is free software, and you are welcome  
 @c to redistribute it under certain conditions; type `show c'   
 @c for details.  
 Gnomovision バージョン69、Copyright(C)19○○年 @var{著作権者名}  Gnomovision バージョン69、Copyright(C)19○○年 @var{著作権者名}
 Gnomovision は完全に無保証です。詳細は show w とタイプしてください。  Gnomovision は完全に無保証です。詳細は show w とタイプしてください。
 これはフリー・ソフトウェアなので、特定の条件の下でこれを再頒布する  これはフリー・ソフトウェアなので、特定の条件の下でこれを再頒布する
 ことができます。詳細は show c とタイプしてください。  ことができます。詳細は show c とタイプしてください。
 @end smallexample  @end smallexample
 @c The hypothetical commands @samp{show w} and @samp{show c} should show  
 @c the appropriate parts of the General Public License.  Of course, the  
 @c commands you use may be called something other than @samp{show w} and  
 @c @samp{show c}; they could even be mouse-clicks or menu items---whatever  
 @c suits your program.  
 上記の@samp{show w}や@samp{show c}は各々、  上記の@samp{show w}や@samp{show c}は各々、
 本一般公有使用許諾の関連する部分を表示するコマンドを指します。  本一般公有使用許諾の関連する部分を表示するコマンドを指します。
 もちろん、あなたが使うこれらのコマンドは@samp{show w}や@samp{show c}といった  もちろん、あなたが使うこれらのコマンドは@samp{show w}や@samp{show c}といった
Line 1176  Gnomovision は完全に無保証です。詳細は s Line 850  Gnomovision は完全に無保証です。詳細は s
 さらに、それらのコマンドはあなたのプログラムに合わせる為に、  さらに、それらのコマンドはあなたのプログラムに合わせる為に、
 マウスでクリックしたりメニュー形式にすることもできます。  マウスでクリックしたりメニュー形式にすることもできます。
 @c You should also get your employer (if you work as a programmer) or your  
 @c school, if any, to sign a ``copyright disclaimer'' for the program, if  
 @c necessary.  Here is a sample; alter the names:  
 また、必要と認めた場合には、あなたの雇い主  また、必要と認めた場合には、あなたの雇い主
 (あなたがプログラマとして働いている場合)や在籍する学校から、  (あなたがプログラマとして働いている場合)や在籍する学校から、
 そのプログラムに対する「著作権放棄」を認めた署名入りの書面を入手してください。  そのプログラムに対する「著作権放棄」を認めた署名入りの書面を入手してください。
Line 1186  Gnomovision は完全に無保証です。詳細は s Line 857  Gnomovision は完全に無保証です。詳細は s
 @smallexample  @smallexample
 @group  @group
 @c Yoyodyne, Inc., hereby disclaims all copyright  
 @c interest in the program `Gnomovision'  
 @c (which makes passes at compilers) written   
 @c by James Hacker.  
 Yoyodyne, Inc. は、James Hacker が開発したプログラム`Gnomovision'   Yoyodyne, Inc. は、James Hacker が開発したプログラム`Gnomovision' 
 (コンパイラにつなげるプログラム)についての著作権法上の全ての権利を放棄する。  (コンパイラにつなげるプログラム)についての著作権法上の全ての権利を放棄する。
 @c @var{signature of Ty Coon}, 1 April 1989  
 @c Ty Coon, President of Vice  
 @var{Ty Coon の署名}, 1 April 1989  @var{Ty Coon の署名}, 1 April 1989
 Ty Coon, 副社長  Ty Coon, 副社長
 @end group  @end group
 @end smallexample  @end smallexample
 @c This General Public License does not permit incorporating your program into  
 @c proprietary programs.  If your program is a subroutine library, you may  
 @c consider it more useful to permit linking proprietary applications with the  
 @c library.  If this is what you want to do, use the GNU Library General  
 @c Public License instead of this License.  
 本一般公有使用許諾は、あなたのプログラムを財産権の対象となっている  本一般公有使用許諾は、あなたのプログラムを財産権の対象となっている
 他のプログラムに組み込むことは認めていません。  他のプログラムに組み込むことは認めていません。
 あなたのプログラムがサブルーチン・ライブラリであって、  あなたのプログラムがサブルーチン・ライブラリであって、
 あなたがそのライブラリを財産権の対象となっている他のアプリケーションと  あなたがそのライブラリを財産権の対象となっている他のアプリケーションと
 リンクさせることによって、さらに有用なものにしようとする場合には、  リンクさせることによって、さらに有用なものにしようとする場合には、
 本使用許諾書の代わりに、GNUライブラリ一般公有使用許諾書に従ってください。  本使用許諾書の代わりに、GNUライブラリ一般公有使用許諾書に従ってください。
 @c =============================================================  
 @c = 以上のGPLの日本語訳に関しての問い合わせは、以下のアドレスに  @c = 以上のGPLの日本語訳に関しての問い合わせは、以下のアドレスに
 @c = お願いいたします。  @c = お願いいたします。
 @c = mieko@gnu.org もしくは hikichi@gnu.org  @c = mieko@gnu.org もしくは hikichi@gnu.org
 @c =============================================================  
 @node Concepts, Examples, Copying, Top  @node Concepts, Examples, Copying, Top
 @c @chapter The Concepts of Bison  
 @chapter Bisonの概念  @chapter Bisonの概念
 @c This chapter introduces many of the basic concepts without which the  
 @c details of Bison will not make sense.  If you do not already know how to  
 @c use Bison or Yacc, we suggest you start by reading this chapter carefully.  
 この章では、Bisonの詳細を理解するのに欠くことのできない、  この章では、Bisonの詳細を理解するのに欠くことのできない、
 多くの基礎概念を説明します。  多くの基礎概念を説明します。
 まだBisonやyaccの使い方を知らない方は、  まだBisonやyaccの使い方を知らない方は、
Line 1247  Yoyodyne, Inc. は、James Hacker が開発し Line 900  Yoyodyne, Inc. は、James Hacker が開発し
 @end menu  @end menu
 @c =====================================================================  
 @node Language and Grammar, Grammar in Bison,  , Concepts  @node Language and Grammar, Grammar in Bison,  , Concepts
 @c @section Languages and Context-Free Grammars  
 @section 言語と文脈自由文法  @section 言語と文脈自由文法
 @cindex context-free grammar  @cindex context-free grammar
 @cindex grammar, context-free  @cindex grammar, context-free
 @cindex 文脈自由文法  @cindex 文脈自由文法
 @cindex 文法  @cindex 文法
 @c In order for Bison to parse a language, it must be described by a  
 @c @dfn{context-free grammar}.  This means that you specify one or more  
 @c @dfn{syntactic groupings} and give rules for constructing them from their  
 @c parts.  For example, in the C language, one kind of grouping is called an  
 @c `expression'.  One rule for making an expression might be, ``An expression  
 @c can be made of a minus sign and another expression''.  Another would be,  
 @c ``An expression can be an integer''.  As you can see, rules are often  
 @c recursive, but there must be at least one rule which leads out of the  
 @c recursion.  
 Bisonが言語を解析するためには、その言語が  Bisonが言語を解析するためには、その言語が
 @dfn{文脈自由文法(context-free grammar)}で記述されている必要があります。  @dfn{文脈自由文法(context-free grammar)}で記述されている必要があります。
Line 1280  Bisonが言語を解析するためには、その言語 Line 922  Bisonが言語を解析するためには、その言語
 @cindex BNF  @cindex BNF
 @cindex Backus-Naur form  @cindex Backus-Naur form
 @cindex バッカス-ナウア記法  @cindex バッカス-ナウア記法
 @c The most common formal system for presenting such rules for humans to read  
 @c is @dfn{Backus-Naur Form} or ``BNF'', which was developed in order to  
 @c specify the language Algol 60.  Any grammar expressed in BNF is a  
 @c context-free grammar.  The input to Bison is essentially machine-readable  
 @c BNF.  
 このような規則を人間が読めるように表現する、もっとも一般的な形式的な方法は、  このような規則を人間が読めるように表現する、もっとも一般的な形式的な方法は、
 @dfn{バッカス-ナウア記法(Backus-Naur form)}略して``BNF''です。  @dfn{バッカス-ナウア記法(Backus-Naur form)}略して``BNF''です。
Line 1292  Bisonが言語を解析するためには、その言語 Line 929  Bisonが言語を解析するためには、その言語
 BNFで表現された任意の言語は、文脈自由言語です。  BNFで表現された任意の言語は、文脈自由言語です。
 Bisonへの入力は、本質的には、機械可読なBNFです。  Bisonへの入力は、本質的には、機械可読なBNFです。
 @c Not all context-free languages can be handled by Bison, only those  
 @c that are LALR(1).  In brief, this means that it must be possible to  
 @c tell how to parse any portion of an input string with just a single  
 @c token of look-ahead.  Strictly speaking, that is a description of an  
 @c LR(1) grammar, and LALR(1) involves additional restrictions that are  
 @c hard to explain simply; but it is rare in actual practice to find an  
 @c LR(1) grammar that fails to be LALR(1).  @xref{Mystery Conflicts, ,  
 @c Mysterious Reduce/Reduce Conflicts}, for more information on this.  
 すべての文脈自由言語をBisonで扱えるわけではありません。  すべての文脈自由言語をBisonで扱えるわけではありません。
 LALR(1)だけを扱えます。  LALR(1)だけを扱えます。
 簡単に説明すると、ちょうど1個のトークンを先読みすることによって、  簡単に説明すると、ちょうど1個のトークンを先読みすることによって、
Line 1322  LALR(1)には簡単に説明できない追加の制限 Line 950  LALR(1)には簡単に説明できない追加の制限
 @cindex トークン  @cindex トークン
 @cindex 文法グループ  @cindex 文法グループ
 @cindex グループ  @cindex グループ
 @c In the formal grammatical rules for a language, each kind of syntactic unit  
 @c or grouping is named by a @dfn{symbol}.  Those which are built by grouping  
 @c smaller constructs according to grammatical rules are called  
 @c @dfn{nonterminal symbols}; those which can't be subdivided are called  
 @c @dfn{terminal symbols} or @dfn{token types}.  We call a piece of input  
 @c corresponding to a single terminal symbol a @dfn{token}, and a piece  
 @c corresponding to a single nonterminal symbol a @dfn{grouping}.@refill  
 ある言語についての形式文法的な規則では、  ある言語についての形式文法的な規則では、
 文法的な単位またはグループを@dfn{記号(symbol)}と呼びます。  文法的な単位またはグループを@dfn{記号(symbol)}と呼びます。
Line 1339  LALR(1)には簡単に説明できない追加の制限 Line 960  LALR(1)には簡単に説明できない追加の制限
 本書では、1個の終端記号に対応する入力の一部分を@dfn{トークン(token)}、  本書では、1個の終端記号に対応する入力の一部分を@dfn{トークン(token)}、
 1個の非終端記号に対応する入力の一部分を@dfn{グループ(grouping)}と呼びます。  1個の非終端記号に対応する入力の一部分を@dfn{グループ(grouping)}と呼びます。
 @c We can use the C language as an example of what symbols, terminal and  
 @c nonterminal, mean.  The tokens of C are identifiers, constants (numeric and  
 @c string), and the various keywords, arithmetic operators and punctuation  
 @c marks.  So the terminal symbols of a grammar for C include `identifier',  
 @c `number', `string', plus one symbol for each keyword, operator or  
 @c punctuation mark: `if', `return', `const', `static', `int', `char',  
 @c `plus-sign', `open-brace', `close-brace', `comma' and many more.  (These  
 @c tokens can be subdivided into characters, but that is a matter of  
 @c lexicography, not grammar.)  
 何が終端記号で何が非終端記号かを示すために、  何が終端記号で何が非終端記号かを示すために、
 例としてC言語を使います。  例としてC言語を使います。
 Cのトークンは、識別子、定数(数値または文字列)、さまざまな予約語、  Cのトークンは、識別子、定数(数値または文字列)、さまざまな予約語、
Line 1361  C言語の終端記号には、「識別子」、「数値 Line 972  C言語の終端記号には、「識別子」、「数値
 (これらのトークンは文字に分解できますが、  (これらのトークンは文字に分解できますが、
 それは文法の問題ではなく、字句解析の問題です)。  それは文法の問題ではなく、字句解析の問題です)。
 @c Here is a simple C function subdivided into tokens:  
 次の例は、トークンに分解されたCの関数です。  次の例は、トークンに分解されたCの関数です。
 @example  @example
 @c int             /* @r{keyword `int'} */  
 @c square (x)      /* @r{identifier, open-paren,} */  
 @c                 /* @r{identifier, close-paren} */  
 @c      int x;     /* @r{keyword `int', identifier, semicolon} */  
 @c @{               /* @r{open-brace} */  
 @c   return x * x; /* @r{keyword `return', identifier,} */  
 @c                 /* @r{asterisk, identifier, semicolon} */  
 @c @}               /* @r{close-brace} */  
 int             /* @r{予約語 `int'} */  int             /* @r{予約語 `int'} */
 square (x)      /* @r{識別子, 開きかっこ,} */  square (x)      /* @r{識別子, 開きかっこ,} */
                 /* @r{識別子, 閉じかっこ} */                  /* @r{識別子, 閉じかっこ} */
Line 1384  square (x)      /* @r{識別子, 開きかっこ Line 985  square (x)      /* @r{識別子, 開きかっこ
 @}               /* @r{閉じブレース} */  @}               /* @r{閉じブレース} */
 @end example  @end example
 @c The syntactic groupings of C include the expression, the statement, the  
 @c declaration, and the function definition.  These are represented in the  
 @c grammar of C by nonterminal symbols `expression', `statement',  
 @c `declaration' and `function definition'.  The full grammar uses dozens of  
 @c additional language constructs, each with its own nonterminal symbol, in  
 @c order to express the meanings of these four.  The example above is a  
 @c function definition; it contains one declaration, and one statement.  In  
 @c the statement, each @samp{x} is an expression and so is @samp{x * x}.  
 Cの文法的なグループには、式、文、宣言、関数定義が含まれます。  Cの文法的なグループには、式、文、宣言、関数定義が含まれます。
 これらは、Cの文法で、非終端記号、「式」、「文」、「宣言」、  これらは、Cの文法で、非終端記号、「式」、「文」、「宣言」、
 「関数定義」として表されます。  「関数定義」として表されます。
Line 1402  Cの文法的なグループには、式、文、宣言、 Line 994  Cの文法的なグループには、式、文、宣言、
 文の中で、それぞれの@samp{x}は式であり、  文の中で、それぞれの@samp{x}は式であり、
 @samp{x * x}も式です。  @samp{x * x}も式です。
 @c Each nonterminal symbol must have grammatical rules showing how it is made  
 @c out of simpler constructs.  For example, one kind of C statement is the  
 @c @code{return} statement; this would be described with a grammar rule which  
 @c reads informally as follows:  
 それぞれの非終端記号には、それがより単純な構成要素からどのように作られるか  それぞれの非終端記号には、それがより単純な構成要素からどのように作られるか
 示すために、文法規則が必要です。  示すために、文法規則が必要です。
 たとえば、Cの文の1つである@code{return}文について、  たとえば、Cの文の1つである@code{return}文について、
 文法規則を形式ばらずに書くと、次のようになります。  文法規則を形式ばらずに書くと、次のようになります。
 @quotation  @quotation
 @c A `statement' can be made of a `return' keyword, an `expression' and a  
 @c `semicolon'.  
 「文」は、キーワード「@code{return}」、「式」、「セミコロン」から  「文」は、キーワード「@code{return}」、「式」、「セミコロン」から
 作ることができる。  作ることができる。
 @end quotation  @end quotation
 @noindent  @noindent
 @c There would be many other rules for `statement', one for each kind of  
 @c statement in C.  
 Cの各種の文について、「文」には多くの他の規則があるでしょう。  Cの各種の文について、「文」には多くの他の規則があるでしょう。
 @cindex start symbol  @cindex start symbol
 @cindex 開始記号  @cindex 開始記号
 @c One nonterminal symbol must be distinguished as the special one which  
 @c defines a complete utterance in the language.  It is called the @dfn{start  
 @c symbol}.  In a compiler, this means a complete input program.  In the C  
 @c language, the nonterminal symbol `sequence of definitions and declarations'  
 @c plays this role.  
 1つの非終端記号が、言語の全体を表現するように、  1つの非終端記号が、言語の全体を表現するように、
 特別なものとして識別される必要があります。  特別なものとして識別される必要があります。
 これを@dfn{開始記号(start symbol)}と呼びます。  これを@dfn{開始記号(start symbol)}と呼びます。
 コンパイラでは、これは完全な入力プログラムを意味します。  コンパイラでは、これは完全な入力プログラムを意味します。
 C言語では、非終端記号「定義と宣言の並び」が、この働きをします。  C言語では、非終端記号「定義と宣言の並び」が、この働きをします。
 @c For example, @samp{1 + 2} is a valid C expression---a valid part of a C  
 @c program---but it is not valid as an @emph{entire} C program.  In the  
 @c context-free grammar of C, this follows from the fact that `expression' is  
 @c not the start symbol.  
 たとえば、@samp{1 + 2}は有効なCの式で、  たとえば、@samp{1 + 2}は有効なCの式で、
 Cのプログラムの有効な一部分ですが、  Cのプログラムの有効な一部分ですが、
 Cプログラム@emph{全体}としては無効です。  Cプログラム@emph{全体}としては無効です。
 したがって、Cの文脈自由文法では、「式」は開始記号でないとわかります。  したがって、Cの文脈自由文法では、「式」は開始記号でないとわかります。
 @c The Bison parser reads a sequence of tokens as its input, and groups the  
 @c tokens using the grammar rules.  If the input is valid, the end result is  
 @c that the entire token sequence reduces to a single grouping whose symbol is  
 @c the grammar's start symbol.  If we use a grammar for C, the entire input  
 @c must be a `sequence of definitions and declarations'.  If not, the parser  
 @c reports a syntax error.  
 Bison構文解析器は、入力としてトークンの列を読み、  Bison構文解析器は、入力としてトークンの列を読み、
 文法規則を使ってトークンをグループにします。  文法規則を使ってトークンをグループにします。
 もし入力が有効であれば、最終的な結果として、トークンの列全体が  もし入力が有効であれば、最終的な結果として、トークンの列全体が
Line 1464  Bison構文解析器は、入力としてトークンの Line 1029  Bison構文解析器は、入力としてトークンの
 もしそうでなければ、構文解析器が文法エラーを報告します。  もしそうでなければ、構文解析器が文法エラーを報告します。
 @c =====================================================================  
 @node Grammar in Bison, Semantic Values, Language and Grammar, Concepts  @node Grammar in Bison, Semantic Values, Language and Grammar, Concepts
 @c @section From Formal Rules to Bison Input  
 @section 形式規則からBisonの入力へ  @section 形式規則からBisonの入力へ
 @cindex Bison grammar  @cindex Bison grammar
 @cindex Bison 文法  @cindex Bison 文法
Line 1474  Bison構文解析器は、入力としてトークンの Line 1037  Bison構文解析器は、入力としてトークンの
 @cindex formal grammar  @cindex formal grammar
 @cindex 形式文法  @cindex 形式文法
 @c A formal grammar is a mathematical construct.  To define the language  
 @c for Bison, you must write a file expressing the grammar in Bison syntax:  
 @c a @dfn{Bison grammar} file.  @xref{Grammar File, ,Bison Grammar Files}.  
 形式文法(formal grammer)は、数学的な構成です。  形式文法(formal grammer)は、数学的な構成です。
 Bisonのために言語を定義するためには、Bisonの書式で文法を記述した  Bisonのために言語を定義するためには、Bisonの書式で文法を記述した
 @dfn{Bison文法(Bison grammer)}ファイルを書く必要があります。  @dfn{Bison文法(Bison grammer)}ファイルを書く必要があります。
 @xref{Grammar File, ,Bison Grammar Files}。  @xref{Grammar File, ,Bison Grammar Files}。
 @c A nonterminal symbol in the formal grammar is represented in Bison input  
 @c as an identifier, like an identifier in C.  By convention, it should be  
 @c in lower case, such as @code{expr}, @code{stmt} or @code{declaration}.  
 形式文法の中での1つの非終端記号は、Bisonの入力の中で、  形式文法の中での1つの非終端記号は、Bisonの入力の中で、
 Cの識別子のような、1つの識別子として表現されます。  Cの識別子のような、1つの識別子として表現されます。
 @code{expr}、@code{stmt}、@code{declaration}のように、  @code{expr}、@code{stmt}、@code{declaration}のように、
 通常、非終端記号は小文字で書きます。  通常、非終端記号は小文字で書きます。
 @c The Bison representation for a terminal symbol is also called a @dfn{token  
 @c type}.  Token types as well can be represented as C-like identifiers.  By  
 @c convention, these identifiers should be upper case to distinguish them from  
 @c nonterminals: for example, @code{INTEGER}, @code{IDENTIFIER}, @code{IF} or  
 @c @code{RETURN}.  A terminal symbol that stands for a particular keyword in  
 @c the language should be named after that keyword converted to upper case.  
 @c The terminal symbol @code{error} is reserved for error recovery.  
 @c @xref{Symbols}.  
 終端記号に対するBisonの表現は、  終端記号に対するBisonの表現は、
 @dfn{トークン型(token type)}ともいいます。  @dfn{トークン型(token type)}ともいいます。
 トークン型は、C言語で使われるような識別子であるかもしれません。  トークン型は、C言語で使われるような識別子であるかもしれません。
Line 1513  Cの識別子のような、1つの識別子として表現 Line 1059  Cの識別子のような、1つの識別子として表現
 終端記号@code{error}は、エラーからの回復処理のために予約されています。  終端記号@code{error}は、エラーからの回復処理のために予約されています。
 @xref{Symbols}。  @xref{Symbols}。
 @c A terminal symbol can also be represented as a character literal, just like  
 @c a C character constant.  You should do this whenever a token is just a  
 @c single character (parenthesis, plus-sign, etc.): use that same character in  
 @c a literal as the terminal symbol for that token.  
 ある終端記号は、C言語の文字定数のような、1文字リテラルを表している  ある終端記号は、C言語の文字定数のような、1文字リテラルを表している
 かもしれません。  かもしれません。
 トークンがちょうど1文字である(たとえば、かっこ、プラス記号など)ならば必ず、  トークンがちょうど1文字である(たとえば、かっこ、プラス記号など)ならば必ず、
 そのトークンに対する終端記号として、同じ文字を使うべきです。  そのトークンに対する終端記号として、同じ文字を使うべきです。
 @c A third way to represent a terminal symbol is with a C string constant  
 @c containing several characters.  @xref{Symbols}, for more information.  
 終端記号を表す第3の方法は、何文字かを含むC言語の文字列定数です。  終端記号を表す第3の方法は、何文字かを含むC言語の文字列定数です。
 詳細は@xref{Symbols}。  詳細は@xref{Symbols}。
 @c The grammar rules also have an expression in Bison syntax.  For example,  
 @c here is the Bison rule for a C @code{return} statement.  The semicolon in  
 @c quotes is a literal character token, representing part of the C syntax for  
 @c the statement; the naked semicolon, and the colon, are Bison punctuation  
 @c used in every rule.  
 文法規則は、Bisonの文法の中で、もう1つの式を持ちます。  文法規則は、Bisonの文法の中で、もう1つの式を持ちます。
 たとえば、C言語の@code{return}文に対するBisonの規則があります。  たとえば、C言語の@code{return}文に対するBisonの規則があります。
 クォート(')で囲まれたセミコロンは、文に対するC言語の文法の一部分を表す、  クォート(')で囲まれたセミコロンは、文に対するC言語の文法の一部分を表す、
Line 1548  stmt:   RETURN expr ';' Line 1080  stmt:   RETURN expr ';'
 @end example  @end example
 @noindent  @noindent
 @c @xref{Rules, ,Syntax of Grammar Rules}.  
 @xref{Rules, ,Syntax of Grammar Rules}。  @xref{Rules, ,Syntax of Grammar Rules}。
 @c =====================================================================  
 @node Semantic Values, Semantic Actions, Grammar in Bison, Concepts  @node Semantic Values, Semantic Actions, Grammar in Bison, Concepts
 @c @section Semantic Values  
 @section 意味値  @section 意味値
 @cindex semantic value  @cindex semantic value
 @cindex value, semantic  @cindex value, semantic
 @cindex 意味値  @cindex 意味値
 @cindex 値  @cindex 値
 @c A formal grammar selects tokens only by their classifications: for example,  
 @c if a rule mentions the terminal symbol `integer constant', it means that  
 @c @emph{any} integer constant is grammatically valid in that position.  The  
 @c precise value of the constant is irrelevant to how to parse the input: if  
 @c @samp{x+4} is grammatical then @samp{x+1} or @samp{x+3989} is equally  
 @c grammatical.@refill  
 形式文法は、トークンを分類法に基づいてのみ、選びます。  形式文法は、トークンを分類法に基づいてのみ、選びます。
 たとえば、ある規則が`integer constant'という終端記号について言及するならば、  たとえば、ある規則が`integer constant'という終端記号について言及するならば、
 それは、文法的にそこに現れてよい@emph{任意の}整数型定数を意味します。  それは、文法的にそこに現れてよい@emph{任意の}整数型定数を意味します。
Line 1575  stmt:   RETURN expr ';' Line 1097  stmt:   RETURN expr ';'
 もし、@samp{x+4}が文法的に正しいならば、@samp{x+1}も、@samp{x+3989}も、  もし、@samp{x+4}が文法的に正しいならば、@samp{x+1}も、@samp{x+3989}も、
 同様に文法的に正しいのです。  同様に文法的に正しいのです。
 @c But the precise value is very important for what the input means once it is  
 @c parsed.  A compiler is useless if it fails to distinguish between 4, 1 and  
 @c 3989 as constants in the program!  Therefore, each token in a Bison grammar  
 @c has both a token type and a @dfn{semantic value}.  @xref{Semantics, ,Defining@c  Language Semantics},  
 @c for details.  
 しかし、いったん解析されれば、入力にとって正確な値はきわめて重要です。  しかし、いったん解析されれば、入力にとって正確な値はきわめて重要です。
 プログラム中の定数として4と1と3989を区別できないコンパイラは、  プログラム中の定数として4と1と3989を区別できないコンパイラは、
 役に立ちません。  役に立ちません。
Line 1588  stmt:   RETURN expr ';' Line 1104  stmt:   RETURN expr ';'
 @dfn{意味値(semantic value)}を持ちます。詳細については、  @dfn{意味値(semantic value)}を持ちます。詳細については、
 @xref{Semantics, ,Defining Language Semantics}。  @xref{Semantics, ,Defining Language Semantics}。
 @c The token type is a terminal symbol defined in the grammar, such as  
 @c @code{INTEGER}, @code{IDENTIFIER} or @code{','}.  It tells everything  
 @c you need to know to decide where the token may validly appear and how to  
 @c group it with other tokens.  The grammar rules know nothing about tokens  
 @c except their types.@refill  
 トークン型は、@code{INTEGER}、@code{IDENTIFIER}、@code{','}のように、  トークン型は、@code{INTEGER}、@code{IDENTIFIER}、@code{','}のように、
 文法の中で定義される終端記号です。  文法の中で定義される終端記号です。
 これは、そのトークンが正しい位置に現れているか確かめ、  これは、そのトークンが正しい位置に現れているか確かめ、
Line 1601  stmt:   RETURN expr ';' Line 1111  stmt:   RETURN expr ';'
 すべての情報を含んでいます。  すべての情報を含んでいます。
 文法規則は、トークンの型以外の何も知りません。  文法規則は、トークンの型以外の何も知りません。
 @c The semantic value has all the rest of the information about the  
 @c meaning of the token, such as the value of an integer, or the name of an  
 @c identifier.  (A token such as @code{','} which is just punctuation doesn't  
 @c need to have any semantic value.)  
 意味値は、トークンに関する、たとえば、整数の値や識別子の名前のような、  意味値は、トークンに関する、たとえば、整数の値や識別子の名前のような、
 トークン型以外のあらゆる情報を持っています  トークン型以外のあらゆる情報を持っています
 (@code{','}のような区切り記号であるトークンは、  (@code{','}のような区切り記号であるトークンは、
 意味値を持つ必要がありません)。  意味値を持つ必要がありません)。
 @c For example, an input token might be classified as token type  
 @c @code{INTEGER} and have the semantic value 4.  Another input token might  
 @c have the same token type @code{INTEGER} but value 3989.  When a grammar  
 @c rule says that @code{INTEGER} is allowed, either of these tokens is  
 @c acceptable because each is an @code{INTEGER}.  When the parser accepts the  
 @c token, it keeps track of the token's semantic value.  
 たとえば、ある入力されたトークンは、トークン型が@code{INTEGER}で、  たとえば、ある入力されたトークンは、トークン型が@code{INTEGER}で、
 意味値が4であると分類されるかもしれません。  意味値が4であると分類されるかもしれません。
 別の入力されたトークンは、同じ@code{INTEGER}型で、  別の入力されたトークンは、同じ@code{INTEGER}型で、
Line 1626  stmt:   RETURN expr ';' Line 1124  stmt:   RETURN expr ';'
 どちらのトークンも@code{INTEGER}型なので、受け入れられます。  どちらのトークンも@code{INTEGER}型なので、受け入れられます。
 構文解析器は、トークンを受け入れるときに、その意味値を記憶します。  構文解析器は、トークンを受け入れるときに、その意味値を記憶します。
 @c Each grouping can also have a semantic value as well as its nonterminal  
 @c symbol.  For example, in a calculator, an expression typically has a  
 @c semantic value that is a number.  In a compiler for a programming  
 @c language, an expression typically has a semantic value that is a tree  
 @c structure describing the meaning of the expression.  
 それぞれのグループ化は、それに対応する非終端記号とともに、意味値を持てます。  それぞれのグループ化は、それに対応する非終端記号とともに、意味値を持てます。
 たとえば、電卓の中では、1つの式は、通常、数値である意味値を持ちます。  たとえば、電卓の中では、1つの式は、通常、数値である意味値を持ちます。
 プログラミング言語のコンパイラの中では、1つの式は、通常、  プログラミング言語のコンパイラの中では、1つの式は、通常、
 式の意味を表す木構造の意味値を持ちます。  式の意味を表す木構造の意味値を持ちます。
 @c =====================================================================  
 @node Semantic Actions, Bison Parser, Semantic Values, Concepts  @node Semantic Actions, Bison Parser, Semantic Values, Concepts
 @c @section Semantic Actions  
 @section 意味アクション  @section 意味アクション
 @cindex semantic actions  @cindex semantic actions
 @cindex actions, semantic  @cindex actions, semantic
 @cindex 意味アクション  @cindex 意味アクション
 @cindex アクション  @cindex アクション
 @c In order to be useful, a program must do more than parse input; it must  
 @c also produce some output based on the input.  In a Bison grammar, a grammar  
 @c rule can have an @dfn{action} made up of C statements.  Each time the  
 @c parser recognizes a match for that rule, the action is executed.  
 @c @xref{Actions}.  
 役に立つようにするためには、プログラムは、入力を解析するだけでなく、  役に立つようにするためには、プログラムは、入力を解析するだけでなく、
 入力に基づくなんらかの出力を生成する必要があります。  入力に基づくなんらかの出力を生成する必要があります。
 Bison文法の中では、文法規則は、  Bison文法の中では、文法規則は、
Line 1660  Cで書かれた@dfn{アクション(action)}を Line 1144  Cで書かれた@dfn{アクション(action)}を
 そのルールへのマッチを構文解析器が認識するたびに、アクションが実行されます。  そのルールへのマッチを構文解析器が認識するたびに、アクションが実行されます。
 @xref{Actions}  @xref{Actions}
 @c Most of the time, the purpose of an action is to compute the semantic value  
 @c of the whole construct from the semantic values of its parts.  For example,  
 @c suppose we have a rule which says an expression can be the sum of two  
 @c expressions.  When the parser recognizes such a sum, each of the  
 @c subexpressions has a semantic value which describes how it was built up.  
 @c The action for this rule should create a similar sort of value for the  
 @c newly recognized larger expression.  
 多くの場合に、アクションの目的は、部品の意味値から全体の意味値を  多くの場合に、アクションの目的は、部品の意味値から全体の意味値を
 計算することです。  計算することです。
 たとえば、1つの式とは2つの式の和でありうると仮定します。  たとえば、1つの式とは2つの式の和でありうると仮定します。
Line 1676  Cで書かれた@dfn{アクション(action)}を Line 1152  Cで書かれた@dfn{アクション(action)}を
 アクションは、新しく認識された合成式について、  アクションは、新しく認識された合成式について、
 同様の意味値を構成するべきです。  同様の意味値を構成するべきです。
 @c For example, here is a rule that says an expression can be the sum of  
 @c two subexpressions:  
 以下に、1つの式が2つの部分式の和となる規則の例を示します。  以下に、1つの式が2つの部分式の和となる規則の例を示します。
 @example  @example
Line 1686  expr: expr '+' expr   @{ $$ = $1 + $3; @ Line 1159  expr: expr '+' expr   @{ $$ = $1 + $3; @
         ;          ;
 @end example  @end example
 @c @noindent  
 @c The action says how to produce the semantic value of the sum expression  
 @c from the values of the two subexpressions.  
 このアクションは、2個の部分式の値から、  このアクションは、2個の部分式の値から、
 式の和の意味値を生成する方法を示しています。  式の和の意味値を生成する方法を示しています。
 @c =====================================================================  
 @node Bison Parser, Stages, Semantic Actions, Concepts  @node Bison Parser, Stages, Semantic Actions, Concepts
 @c @section Bison Output: the Parser File  
 @section Bisonの出力――構文解析器ファイル  @section Bisonの出力――構文解析器ファイル
 @cindex Bison parser  @cindex Bison parser
 @cindex Bison utility  @cindex Bison utility
Line 1707  expr: expr '+' expr   @{ $$ = $1 + $3; @ Line 1174  expr: expr '+' expr   @{ $$ = $1 + $3; @
 @cindex 字句解析器  @cindex 字句解析器
 @cindex 構文解析器  @cindex 構文解析器
 @c When you run Bison, you give it a Bison grammar file as input.  The output  
 @c is a C source file that parses the language described by the grammar.  
 @c This file is called a @dfn{Bison parser}.  Keep in mind that the Bison  
 @c utility and the Bison parser are two distinct programs: the Bison utility  
 @c is a program whose output is the Bison parser that becomes part of your  
 @c program.  
 Bisonを使うときには、入力としてBison文法ファイルを指定します。  Bisonを使うときには、入力としてBison文法ファイルを指定します。
 文法で記述された言語を解析する、Cのソースファイルが出力になります。  文法で記述された言語を解析する、Cのソースファイルが出力になります。
 このファイルを@dfn{Bison構文解析器(Bison parser)}と呼びます。  このファイルを@dfn{Bison構文解析器(Bison parser)}と呼びます。
Line 1722  BisonユーティリティとBison構文解析器は、 Line 1182  BisonユーティリティとBison構文解析器は、
 Bisonユーティリティの出力がBison構文解析器で、  Bisonユーティリティの出力がBison構文解析器で、
 あなたのプログラムの一部分になるのです。  あなたのプログラムの一部分になるのです。
 @c The job of the Bison parser is to group tokens into groupings according to  
 @c the grammar rules---for example, to build identifiers and operators into  
 @c expressions.  As it does this, it runs the actions for the grammar rules it  
 @c uses.  
 Bison構文解析器の仕事は、文法規則に従って、トークンをグループ化することです。  Bison構文解析器の仕事は、文法規則に従って、トークンをグループ化することです。
 たとえば、識別子と演算子から式を組み立てます。  たとえば、識別子と演算子から式を組み立てます。
 このために、文法規則に対応するアクションを実行します。  このために、文法規則に対応するアクションを実行します。
 @c The tokens come from a function called the @dfn{lexical analyzer} that you  
 @c must supply in some fashion (such as by writing it in C).  The Bison parser  
 @c calls the lexical analyzer each time it wants a new token.  It doesn't know  
 @c what is ``inside'' the tokens (though their semantic values may reflect  
 @c this).  Typically the lexical analyzer makes the tokens by parsing  
 @c characters of text, but Bison does not depend on this.    
 トークンは、@dfn{字句解析器(lexical analyzer)}と呼ばれる関数によって得られ、  トークンは、@dfn{字句解析器(lexical analyzer)}と呼ばれる関数によって得られ、
 その関数を(Cで書くような)なんらかの方法で与える必要があります。  その関数を(Cで書くような)なんらかの方法で与える必要があります。
 Bison構文解析器は、新しいトークンを必要とするたびに、  Bison構文解析器は、新しいトークンを必要とするたびに、
Line 1748  Bison構文解析器は、トークンの「内部」が Line 1196  Bison構文解析器は、トークンの「内部」が
 Bisonはその方法を知りません。  Bisonはその方法を知りません。
 @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}。  @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}。
 @c The Bison parser file is C code which defines a function named  
 @c @code{yyparse} which implements that grammar.  This function does not make  
 @c a complete C program: you must supply some additional functions.  One is  
 @c the lexical analyzer.  Another is an error-reporting function which the  
 @c parser calls to report an error.  In addition, a complete C program must  
 @c start with a function called @code{main}; you have to provide this, and  
 @c arrange for it to call @code{yyparse} or the parser will never run.  
 @c @xref{Interface, ,Parser C-Language Interface}.  
 Bison構文解析器ファイルは、Cのプログラムで、@code{yyparse}という名前の、  Bison構文解析器ファイルは、Cのプログラムで、@code{yyparse}という名前の、
 文法を実装する関数を定義します。  文法を実装する関数を定義します。
 この関数は、完全なCのプログラムを構成しません。  この関数は、完全なCのプログラムを構成しません。
Line 1768  Bison構文解析器ファイルは、Cのプログラム Line 1207  Bison構文解析器ファイルは、Cのプログラム
 これを補って、そこから@code{yyparse}を呼び出してください。  これを補って、そこから@code{yyparse}を呼び出してください。
 @xref{Interface, ,Parser C-Language Interface}。  @xref{Interface, ,Parser C-Language Interface}。
 @c Aside from the token type names and the symbols in the actions you  
 @c write, all variable and function names used in the Bison parser file  
 @c begin with @samp{yy} or @samp{YY}.  This includes interface functions  
 @c such as the lexical analyzer function @code{yylex}, the error reporting  
 @c function @code{yyerror} and the parser function @code{yyparse} itself.  
 @c This also includes numerous identifiers used for internal purposes.  
 @c Therefore, you should avoid using C identifiers starting with @samp{yy}  
 @c or @samp{YY} in the Bison grammar file except for the ones defined in  
 @c this manual.  
 あなたが書くアクションの中でのトークンの型名と記号に関係なく、  あなたが書くアクションの中でのトークンの型名と記号に関係なく、
 Bison構文解析器の中で使われるすべての変数と関数の名前は、  Bison構文解析器の中で使われるすべての変数と関数の名前は、
 @samp{yy}または@samp{YY}で始まります。  @samp{yy}または@samp{YY}で始まります。
Line 1789  Bison文法ファイルの中で@samp{yy}または@s Line 1218  Bison文法ファイルの中で@samp{yy}または@s
 Cの識別子の利用は避けるべきです。  Cの識別子の利用は避けるべきです。
 @c =====================================================================  
 @node Stages, Grammar Layout, Bison Parser, Concepts  @node Stages, Grammar Layout, Bison Parser, Concepts
 @c @section Stages in Using Bison  
 @section Bisonを使う手順  @section Bisonを使う手順
 @cindex stages in using Bison  @cindex stages in using Bison
 @cindex using Bison  @cindex using Bison
 @cindex 使用方法  @cindex 使用方法
 @cindex Bisonの使用方法  @cindex Bisonの使用方法
 @c The actual language-design process using Bison, from grammar specification  
 @c to a working compiler or interpreter, has these parts:  
 Bisonを使って、文法の定義から実際に動くコンパイラやインタープリタを作るまでの、  Bisonを使って、文法の定義から実際に動くコンパイラやインタープリタを作るまでの、
 言語設計手順は、次のようになります。  言語設計手順は、次のようになります。
 @enumerate  @enumerate
 @item  @item
 @c Formally specify the grammar in a form recognized by Bison  
 @c (@pxref{Grammar File, ,Bison Grammar Files}).  
 @c For each grammatical rule in the language,  
 @c describe the action that is to be taken when an instance of that rule  
 @c is recognized.  The action is described by a sequence of C statements.  
 Bisonが認識できる形式で、文法を形式的に指定します  Bisonが認識できる形式で、文法を形式的に指定します
 (@pxref{Grammar File, ,Bison Grammar Files})。  (@pxref{Grammar File, ,Bison Grammar Files})。
 言語の各文法規則に対して、  言語の各文法規則に対して、
Line 1820  Bisonが認識できる形式で、文法を形式的に Line 1238  Bisonが認識できる形式で、文法を形式的に
 アクションは、C言語の文の並びで書きます。  アクションは、C言語の文の並びで書きます。
 @item  @item
 @c Write a lexical analyzer to process input and pass tokens to the  
 @c parser.  The lexical analyzer may be written by hand in C  
 @c (@pxref{Lexical, ,The Lexical Analyzer Function @code{yylex}}).  It could als@c o be produced using Lex, but the use  
 @c of Lex is not discussed in this manual.  
 入力を処理し、トークンを構文解析器に渡すために、字句解析器を書きます。  入力を処理し、トークンを構文解析器に渡すために、字句解析器を書きます。
 字句解析器は、Cで手作業で書いてもかまいません  字句解析器は、Cで手作業で書いてもかまいません
 (@pxref{Lexical, ,The Lexical Analyzer Function @code{yylex}})。  (@pxref{Lexical, ,The Lexical Analyzer Function @code{yylex}})。
Line 1832  Lexを使って生成することも可能ですが、本 Line 1245  Lexを使って生成することも可能ですが、本
 していません。  していません。
 @item  @item
 @c Write a controlling function that calls the Bison-produced parser.  
 Bisonが生成した構文解析器を呼び出す、制御関数を書きます。  Bisonが生成した構文解析器を呼び出す、制御関数を書きます。
 @item  @item
 @c Write error-reporting routines.  
 エラー報告関数を書きます。  エラー報告関数を書きます。
 @end enumerate  @end enumerate
 @c To turn this source code as written into a runnable program, you  
 @c must follow these steps:  
 このソースプログラムを実行可能なプログラムにするために、  このソースプログラムを実行可能なプログラムにするために、
 次の手順が必要です。  次の手順が必要です。
 @enumerate  @enumerate
 @item  @item
 @c Run Bison on the grammar to produce the parser.  
 構文解析器を生成するために、Bisonを実行します。  構文解析器を生成するために、Bisonを実行します。
 @item  @item
 @c Compile the code output by Bison, as well as any other source files.  
 Bisonが生成したソースプログラムとその他のソースプログラムを、  Bisonが生成したソースプログラムとその他のソースプログラムを、
 コンパイルします。  コンパイルします。
 @item  @item
 @c Link the object files to produce the finished product.  
 オブジェクトファイルをリンクして、最終的なプログラムを得ます。  オブジェクトファイルをリンクして、最終的なプログラムを得ます。
 @end enumerate  @end enumerate
 @c =====================================================================  
 @node Grammar Layout,  , Stages, Concepts  @node Grammar Layout,  , Stages, Concepts
 @c @section The Overall Layout of a Bison Grammar  
 @section Bison文法の全体像  @section Bison文法の全体像
 @cindex grammar file  @cindex grammar file
 @cindex file format  @cindex file format
Line 1880  Bisonが生成したソースプログラムとその他 Line 1278  Bisonが生成したソースプログラムとその他
 @cindex 文法ファイル  @cindex 文法ファイル
 @cindex ファイル書式  @cindex ファイル書式
 @c The input file for the Bison utility is a @dfn{Bison grammar file}.  The  
 @c general form of a Bison grammar file is as follows:  
 Bisonユーティリティへの入力は、  Bisonユーティリティへの入力は、
 @dfn{Bison文法ファイル(Bison grammar file)}です。  @dfn{Bison文法ファイル(Bison grammar file)}です。
 Bison文法ファイルの一般的な書式は、次のとおりです。  Bison文法ファイルの一般的な書式は、次のとおりです。
 @example  @example
 %@{  %@{
 @c @var{C declarations}  
 @var{C宣言部(C declarations)}  @var{C宣言部(C declarations)}
 %@}  %@}
 @c @var{Bison declarations}  
 @var{Bison宣言部(Bison declarations)}  @var{Bison宣言部(Bison declarations)}
 %%  %%
 @c @var{Grammar rules}  
 @var{文法規則部(Grammar rules)}  @var{文法規則部(Grammar rules)}
 %%  %%
 @c @var{Additional C code}  
 @var{追加のCプログラム部(Additional C code)}  @var{追加のCプログラム部(Additional C code)}
 @end example  @end example
 @c @noindent  
 @c The @samp{%%}, @samp{%@{} and @samp{%@}} are punctuation that appears  
 @c in every Bison grammar file to separate the sections.  
 Bison文法ファイル中の@samp{%%}、@samp{%@{}、@samp{%@}}は、  Bison文法ファイル中の@samp{%%}、@samp{%@{}、@samp{%@}}は、
 ファイルを節に分ける区切り記号です。  ファイルを節に分ける区切り記号です。
 @c The C declarations may define types and variables used in the actions.  
 @c You can also use preprocessor commands to define macros used there, and use  
 @c @code{#include} to include header files that do any of these things.  
 @dfn{C宣言部}では、  @dfn{C宣言部}では、
 アクションの中で使われる型と変数を定義できます。  アクションの中で使われる型と変数を定義できます。
 マクロを定義するためのプリプロセッサディレクティブや、  マクロを定義するためのプリプロセッサディレクティブや、
 ヘッダファイルをインクルードするための@code{#include}命令も使用できます。  ヘッダファイルをインクルードするための@code{#include}命令も使用できます。
 @c The Bison declarations declare the names of the terminal and nonterminal  
 @c symbols, and may also describe operator precedence and the data types of  
 @c semantic values of various symbols.  
 @dfn{Bison宣言部}には、終端記号、非終端記号、さらに、  @dfn{Bison宣言部}には、終端記号、非終端記号、さらに、
 演算子の優先順位、さまざまな記号の意味値のデータ型を記述できます。  演算子の優先順位、さまざまな記号の意味値のデータ型を記述できます。
 @c The grammar rules define how to construct each nonterminal symbol from its  
 @c parts.  
 @dfn{文法規則部}では、各非終端記号をその部品から組み立てる方法を  @dfn{文法規則部}では、各非終端記号をその部品から組み立てる方法を
 定義します。  定義します。
 @c The additional C code can contain any C code you want to use.  Often the  
 @c definition of the lexical analyzer @code{yylex} goes here, plus subroutines  
 @c called by the actions in the grammar rules.  In a simple program, all the  
 @c rest of the program can go here.  
 @dfn{追加のCプログラム部}には、  @dfn{追加のCプログラム部}には、
 あなたが望むCプログラムを記述できます。  あなたが望むCプログラムを記述できます。
 よく字句解析関数@code{yylex}や  よく字句解析関数@code{yylex}や
Line 1946  Bison文法ファイル中の@samp{%%}、@samp{%@ Line 1317  Bison文法ファイル中の@samp{%%}、@samp{%@
 残りのプログラム全部を書きます。  残りのプログラム全部を書きます。
 @c =====================================================================  
 @node Examples, Grammar File, Concepts, Top  @node Examples, Grammar File, Concepts, Top
 @c @chapter Examples  
 @chapter 例  @chapter 例
 @cindex simple examples  @cindex simple examples
 @cindex examples, simple  @cindex examples, simple
 @cindex 単純な例  @cindex 単純な例
 @cindex 例  @cindex 例
 @c Now we show and explain three sample programs written using Bison: a  
 @c reverse polish notation calculator, an algebraic (infix) notation  
 @c calculator, and a multi-function calculator.  All three have been tested  
 @c under BSD Unix 4.3; each produces a usable, though limited, interactive  
 @c desk-top calculator.  
 本章では、Bison文法を使って書いた例を3つ示します。  本章では、Bison文法を使って書いた例を3つ示します。
 逆ポーランド記法電卓、算術(中置)記法電卓、多機能電卓です。  逆ポーランド記法電卓、算術(中置)記法電卓、多機能電卓です。
 すべてBSD UNIX 4.3上でテストしました。  すべてBSD UNIX 4.3上でテストしました。
 限定的ではありますが、対話的な電卓として利用可能です。  限定的ではありますが、対話的な電卓として利用可能です。
 @c These examples are simple, but Bison grammars for real programming  
 @c languages are written the same way.  
 これらの例は単純ですが、現実のプログラミング言語に対する  これらの例は単純ですが、現実のプログラミング言語に対する
 Bison文法も、書き方は同じです。  Bison文法も、書き方は同じです。
Line 1989  Bison文法も、書き方は同じです。 Line 1349  Bison文法も、書き方は同じです。
 @end menu  @end menu
 @c =====================================================================  
 @node RPN Calc, Infix Calc,  , Examples  @node RPN Calc, Infix Calc,  , Examples
 @c @section Reverse Polish Notation Calculator  
 @section 逆ポーランド記法電卓  @section 逆ポーランド記法電卓
 @cindex reverse polish notation  @cindex reverse polish notation
 @cindex polish notation calculator  @cindex polish notation calculator
Line 2000  Bison文法も、書き方は同じです。 Line 1358  Bison文法も、書き方は同じです。
 @cindex 逆ポーランド記法  @cindex 逆ポーランド記法
 @cindex 電卓  @cindex 電卓
 @c The first example is that of a simple double-precision @dfn{reverse polish  
 @c notation} calculator (a calculator using postfix operators).  This example  
 @c provides a good starting point, since operator precedence is not an issue.  
 @c The second example will illustrate how operator precedence is handled.  
 最初の例は、@dfn{逆ポーランド記法(reverse polish notation)}を使う  最初の例は、@dfn{逆ポーランド記法(reverse polish notation)}を使う
 倍精度の電卓で、演算子を後に書きます。  倍精度の電卓で、演算子を後に書きます。
 この例は、演算子の優先順位の問題がないので、入門には適しています。  この例は、演算子の優先順位の問題がないので、入門には適しています。
 第2の例では、演算子の優先順位をどのように扱うかを示します。  第2の例では、演算子の優先順位をどのように扱うかを示します。
 @c The source code for this calculator is named @file{rpcalc.y}.  The  
 @c @samp{.y} extension is a convention used for Bison input files.  
 この電卓のソースファイルを@file{rpcalc.y}とします。  この電卓のソースファイルを@file{rpcalc.y}とします。
 Bisonの入力ファイルには、通常@samp{.y}という拡張子を付けます。  Bisonの入力ファイルには、通常@samp{.y}という拡張子を付けます。
Line 2027  Bisonの入力ファイルには、通常@samp{.y}と Line 1377  Bisonの入力ファイルには、通常@samp{.y}と
 @end menu  @end menu
 @c =====================================================================  
 @node Rpcalc Decls, Rpcalc Rules,  , RPN Calc  @node Rpcalc Decls, Rpcalc Rules,  , RPN Calc
 @c @subsection Declarations for @code{rpcalc}  
 @subsection @code{rpcalc}のための宣言  @subsection @code{rpcalc}のための宣言
 @c Here are the C and Bison declarations for the reverse polish notation  
 @c calculator.  As in C, comments are placed between @samp{/*@dots{}*/}.  
 逆ポーランド記法電卓のためのCとBisonの宣言を示します。  逆ポーランド記法電卓のためのCとBisonの宣言を示します。
 Cと同様に@samp{/*@dots{}*/}はコメントです。  Cと同様に@samp{/*@dots{}*/}はコメントです。
 @example  @example
 @c /* Reverse polish notation calculator. */  
 /* 逆ポーランド記法電卓 */  /* 逆ポーランド記法電卓 */
 %@{  %@{
Line 2049  Cと同様に@samp{/*@dots{}*/}はコメントで Line 1393  Cと同様に@samp{/*@dots{}*/}はコメントで
 %token NUM  %token NUM
 @c %% /* Grammar rules and actions follow */  
 %% /* 文法規則とアクションが続く */  %% /* 文法規則とアクションが続く */
 @end example  @end example
 @c The C declarations section  
 @c (@pxref{C Declarations, ,The C Declarations Section}) contains two  
 @c preprocessor directives.  
 C宣言部(@pxref{C Declarations, ,The C Declarations Section})には、  C宣言部(@pxref{C Declarations, ,The C Declarations Section})には、
 2つのプリプロセッサディレクティブがあります。  2つのプリプロセッサディレクティブがあります。
 @c The @code{#define} directive defines the macro @code{YYSTYPE}, thus  
 @c specifying the C data type for semantic values of both tokens and groupings  
 @c (@pxref{Value Type, ,Data Types of Semantic Values}).  
 @c The Bison parser will use whatever type  
 @c @code{YYSTYPE} is defined as; if you don't define it, @code{int} is the  
 @c default.  Because we specify @code{double}, each token and each expression  
 @c has an associated value, which is a floating point number.  
 @code{#define}ディレクティブで、トークンとグループの意味値に対する  @code{#define}ディレクティブで、トークンとグループの意味値に対する
 Cのデータ型を指定するために、マクロ@code{YYSTYPE}を定義します  Cのデータ型を指定するために、マクロ@code{YYSTYPE}を定義します
 (@pxref{Value Type, ,Data Types of Semantic Values})。  (@pxref{Value Type, ,Data Types of Semantic Values})。
Line 2076  Bison構文解析器は、@code{YYSTYPE}に定義 Line 1407  Bison構文解析器は、@code{YYSTYPE}に定義
 各トークンと式は、浮動小数点数である記録値を持つので、  各トークンと式は、浮動小数点数である記録値を持つので、
 ここでは@code{double}を指定します。  ここでは@code{double}を指定します。
 @c The @code{#include} directive is used to declare the exponentiation  
 @c function @code{pow}.  
 べき乗関数@code{pow}の宣言を使うために、  べき乗関数@code{pow}の宣言を使うために、
 @code{#include}ディレクティブを使っています。  @code{#include}ディレクティブを使っています。
 @c The second section, Bison declarations, provides information to Bison  
 @c about the token types  
 @c (@pxref{Bison Declarations, ,The Bison Declarations Section}).  
 @c Each terminal symbol that is  
 @c not a single-character literal must be declared here.  (Single-character  
 @c literals normally don't need to be declared.)  In this example, all the  
 @c arithmetic operators are designated by single-character literals, so the  
 @c only terminal symbol that needs to be declared is @code{NUM}, the token  
 @c type for numeric constants.  
 第2の部、Bison宣言は、Bisonのためにトークン型についての情報を用意します  第2の部、Bison宣言は、Bisonのためにトークン型についての情報を用意します
 (@pxref{Bison Declarations, ,The Bison Declarations Section})。  (@pxref{Bison Declarations, ,The Bison Declarations Section})。
 1文字リテラルでない終端記号は、ここで宣言する必要があります  1文字リテラルでない終端記号は、ここで宣言する必要があります
Line 2101  Bison構文解析器は、@code{YYSTYPE}に定義 Line 1419  Bison構文解析器は、@code{YYSTYPE}に定義
 終端記号として宣言します。  終端記号として宣言します。
 @c =====================================================================  
 @node Rpcalc Rules, Rpcalc Lexer, Rpcalc Decls, RPN Calc  @node Rpcalc Rules, Rpcalc Lexer, Rpcalc Decls, RPN Calc
 @c @subsection Grammar Rules for @code{rpcalc}  
 @subsection @code{rpcalc}のための文法規則  @subsection @code{rpcalc}のための文法規則
 @c Here are the grammar rules for the reverse polish notation calculator.  
 逆ポーランド記法電卓のための文法規則を示します。  逆ポーランド記法電卓のための文法規則を示します。
 @example  @example
 @c input:    /* empty */  
 input:    /* 空 */  input:    /* 空 */
         | input line          | input line
 ;  ;
Line 2125  exp:      NUM             @{ $$ = $1;    Line 1438  exp:      NUM             @{ $$ = $1;   
         | exp exp '-'     @{ $$ = $1 - $2;    @}          | exp exp '-'     @{ $$ = $1 - $2;    @}
         | exp exp '*'     @{ $$ = $1 * $2;    @}          | exp exp '*'     @{ $$ = $1 * $2;    @}
         | exp exp '/'     @{ $$ = $1 / $2;    @}          | exp exp '/'     @{ $$ = $1 / $2;    @}
 @c       /* Exponentiation */  
       /* べき乗関数 */        /* べき乗関数 */
         | exp exp '^'     @{ $$ = pow ($1, $2); @}          | exp exp '^'     @{ $$ = pow ($1, $2); @}
 @c      /* Unary minus    */  
       /* 単項のマイナス    */        /* 単項のマイナス    */
         | exp 'n'         @{ $$ = -$1;        @}          | exp 'n'         @{ $$ = -$1;        @}
 ;  ;
 %%  %%
 @end example  @end example
 @c The groupings of the rpcalc ``language'' defined here are the expression  
 @c (given the name @code{exp}), the line of input (@code{line}), and the  
 @c complete input transcript (@code{input}).  Each of these nonterminal  
 @c symbols has several alternate rules, joined by the @samp{|} punctuator  
 @c which is read as ``or''.  The following sections explain what these rules  
 @c mean.  
 ここで定義されるrpcalc「言語」のグループは、  ここで定義されるrpcalc「言語」のグループは、
 式(@code{exp})と、入力行(@code{line})と、  式(@code{exp})と、入力行(@code{line})と、
 完全な入力の写し(@code{input})です。  完全な入力の写し(@code{input})です。
Line 2149  exp:      NUM             @{ $$ = $1;    Line 1453  exp:      NUM             @{ $$ = $1;   
 いくつかの規則があります。  いくつかの規則があります。
 以下の項で、これらの規則の意味を説明します。  以下の項で、これらの規則の意味を説明します。
 @c The semantics of the language is determined by the actions taken when a  
 @c grouping is recognized.  The actions are the C code that appears inside  
 @c braces.  @xref{Actions}.  
 言語の意味は、グループが認識されたときのアクションによって決まります。  言語の意味は、グループが認識されたときのアクションによって決まります。
 アクションとは、ブレースで囲まれたCのプログラムです。  アクションとは、ブレースで囲まれたCのプログラムです。
 @xref{Actions}。  @xref{Actions}。
 @c You must specify these actions in C, but Bison provides the means for  
 @c passing semantic values between the rules.  In each action, the  
 @c pseudo-variable @code{$$} stands for the semantic value for the grouping  
 @c that the rule is going to construct.  Assigning a value to @code{$$} is the  
 @c main job of most actions.  The semantic values of the components of the  
 @c rule are referred to as @code{$1}, @code{$2}, and so on.  
 これらのアクションをCで書く必要がありますが、  これらのアクションをCで書く必要がありますが、
 Bisonには規則の間で意味値を受け渡しする方法があります。  Bisonには規則の間で意味値を受け渡しする方法があります。
 それぞれのアクションで、擬似変数@code{$$}は、  それぞれのアクションで、擬似変数@code{$$}は、
Line 2179  Bisonには規則の間で意味値を受け渡しする Line 1472  Bisonには規則の間で意味値を受け渡しする
 @end menu  @end menu
 @c =====================================================================  
 @node Rpcalc Input, Rpcalc Line,  , Rpcalc Rules  @node Rpcalc Input, Rpcalc Line,  , Rpcalc Rules
 @c @subsubsection Explanation of @code{input}  
 @subsubsection @code{input}の説明  @subsubsection @code{input}の説明
 @c Consider the definition of @code{input}:  
 @code{input}の定義について考えます。  @code{input}の定義について考えます。
 @example  @example
 @c input:    /* empty */  
 input:    /* 空 */  input:    /* 空 */
         | input line          | input line
 ;  ;
 @end example  @end example
 @c This definition reads as follows: ``A complete input is either an empty  
 @c string, or a complete input followed by an input line''.  Notice that  
 @c ``complete input'' is defined in terms of itself.  This definition is said  
 @c to be @dfn{left recursive} since @code{input} appears always as the  
 @c leftmost symbol in the sequence.  @xref{Recursion, ,Recursive Rules}.  
 この定義の意味は、「完全な入力とは、空文字列であるか、あるいは、  この定義の意味は、「完全な入力とは、空文字列であるか、あるいは、
 完全な入力に入力行が続いたものである」ということです。  完全な入力に入力行が続いたものである」ということです。
 「完全な入力」が、それ自身を使って定義されていることに注意してください。  「完全な入力」が、それ自身を使って定義されていることに注意してください。
Line 2208  input:    /* 空 */ Line 1490  input:    /* 空 */
 このような定義を@dfn{左再帰(left recursive)}と呼びます。  このような定義を@dfn{左再帰(left recursive)}と呼びます。
 @xref{Recursion, ,Recursive Rules}。  @xref{Recursion, ,Recursive Rules}。
 @c The first alternative is empty because there are no symbols between the  
 @c colon and the first @samp{|}; this means that @code{input} can match an  
 @c empty string of input (no tokens).  We write the rules this way because it  
 @c is legitimate to type @kbd{Ctrl-d} right after you start the calculator.  
 @c It's conventional to put an empty alternative first and write the comment  
 @c @samp{/* empty */} in it.  
 最初の選択肢は、@samp{:}と@samp{|}の間に記号がないので空です。  最初の選択肢は、@samp{:}と@samp{|}の間に記号がないので空です。
 これは、(トークンを含まない)空の入力文字列にマッチします。  これは、(トークンを含まない)空の入力文字列にマッチします。
 電卓を起動した直後に@kbd{Ctrl-d} @footnote{【訳注】UNIXの標準的なコンソールの  電卓を起動した直後に@kbd{Ctrl-d} @footnote{【訳注】UNIXの標準的なコンソールの
Line 2223  input:    /* 空 */ Line 1498  input:    /* 空 */
 通常、空に対応する選択肢を最初に置き、そこに@samp{/* 空 */}と  通常、空に対応する選択肢を最初に置き、そこに@samp{/* 空 */}と
 書きます。  書きます。
 @c The second alternate rule (@code{input line}) handles all nontrivial input.  
 @c It means, ``After reading any number of lines, read one more line if  
 @c possible.''  The left recursion makes this rule into a loop.  Since the  
 @c first alternative matches empty input, the loop can be executed zero or  
 @c more times.  
 2つめの選択肢である規則(@code{input line})は、  2つめの選択肢である規則(@code{input line})は、
 自明(空)でないすべての入力を扱います。  自明(空)でないすべての入力を扱います。
 その意味は、「任意の数の行を読み込んだ後で、もし可能ならば、  その意味は、「任意の数の行を読み込んだ後で、もし可能ならば、
Line 2237  input:    /* 空 */ Line 1506  input:    /* 空 */
 最初の選択肢が空の入力にマッチするので、  最初の選択肢が空の入力にマッチするので、
 0回以上任意の回数の繰り返しになります。  0回以上任意の回数の繰り返しになります。
 @c The parser function @code{yyparse} continues to process input until a  
 @c grammatical error is seen or the lexical analyzer says there are no more  
 @c input tokens; we will arrange for the latter to happen at end of file.  
 構文解析器関数@code{yyparse}は、文法エラーが発生するか、あるいは、  構文解析器関数@code{yyparse}は、文法エラーが発生するか、あるいは、
 字句解析器がもうトークンがないと判定するまで、  字句解析器がもうトークンがないと判定するまで、
 入力の処理を続けます。  入力の処理を続けます。
 ファイルの終わりで起きることについては、後で考慮します。  ファイルの終わりで起きることについては、後で考慮します。
 @c =====================================================================  
 @node Rpcalc Line, Rpcalc Expr, Rpcalc Input, Rpcalc Rules  @node Rpcalc Line, Rpcalc Expr, Rpcalc Input, Rpcalc Rules
 @c @subsubsection Explanation of @code{line}  
 @subsubsection @code{line}の説明  @subsubsection @code{line}の説明
 @c Now consider the definition of @code{line}:  
 次に、@code{line}の定義について考えます。  次に、@code{line}の定義について考えます。
 @example  @example
Line 2262  line:     '\n' Line 1523  line:     '\n'
 ;  ;
 @end example  @end example
 @c The first alternative is a token which is a newline character; this means  
 @c that rpcalc accepts a blank line (and ignores it, since there is no  
 @c action).  The second alternative is an expression followed by a newline.  
 @c This is the alternative that makes rpcalc useful.  The semantic value of  
 @c the @code{exp} grouping is the value of @code{$1} because the @code{exp} in  
 @c question is the first symbol in the alternative.  The action prints this  
 @c value, which is the result of the computation the user asked for.  
 最初の選択肢は、改行文字であるトークンです。  最初の選択肢は、改行文字であるトークンです。
 これは、rpcalcが空行を受け入れ、それに対応するアクションがないので、  これは、rpcalcが空行を受け入れ、それに対応するアクションがないので、
 無視することを示します。  無視することを示します。
Line 2280  line:     '\n' Line 1533  line:     '\n'
 アクションは、問い合わされた計算の結果である、  アクションは、問い合わされた計算の結果である、
 この値を表示します。  この値を表示します。
 @c This action is unusual because it does not assign a value to @code{$$}.  As  
 @c a consequence, the semantic value associated with the @code{line} is  
 @c uninitialized (its value will be unpredictable).  This would be a bug if  
 @c that value were ever used, but we don't use it: once rpcalc has printed the  
 @c value of the user's input line, that value is no longer needed.  
 このアクションは、値を@code{$$}に代入しないので、例外的です。  このアクションは、値を@code{$$}に代入しないので、例外的です。
 したがって、@code{line}に対応する意味値は、初期化されず、  したがって、@code{line}に対応する意味値は、初期化されず、
 その値は予想できなくなります。  その値は予想できなくなります。
Line 2294  line:     '\n' Line 1541  line:     '\n'
 その値はもはや必要ありません。  その値はもはや必要ありません。
 @c =====================================================================  
 @node Rpcalc Expr,  , Rpcalc Line, Rpcalc Rules  @node Rpcalc Expr,  , Rpcalc Line, Rpcalc Rules
 @c @subsubsection Explanation of @code{expr}  
 @subsubsection @code{expr}の説明  @subsubsection @code{expr}の説明
 @c The @code{exp} grouping has several rules, one for each kind of expression.  
 @c The first rule handles the simplest expressions:  
 @c those that are just numbers.  
 @c The second handles an addition-expression, which looks like two expressions  
 @c followed by a plus-sign.  The third handles subtraction, and so on.  
 @code{exp}グループは、いくつかの規則を持ち、  @code{exp}グループは、いくつかの規則を持ち、
 それぞれが式の種類に対応しています。  それぞれが式の種類に対応しています。
 最初の規則は、数値そのものであるもっとも単純な式を処理します。  最初の規則は、数値そのものであるもっとも単純な式を処理します。
Line 2319  exp:      NUM Line 1558  exp:      NUM
         ;          ;
 @end example  @end example
 @c We have used @samp{|} to join all the rules for @code{exp}, but we could  
 @c equally well have written them separately:  
 すべての@code{exp}規則をまとめるために@samp{|}を使っていますが、  すべての@code{exp}規則をまとめるために@samp{|}を使っていますが、
 次のように別々に書くことも可能です。  次のように別々に書くことも可能です。
Line 2332  exp:      exp exp '-'     @{ $$ = $1 - $ Line 1568  exp:      exp exp '-'     @{ $$ = $1 - $
         @dots{}          @dots{}
 @end example  @end example
 @c Most of the rules have actions that compute the value of the expression in  
 @c terms of the value of its parts.  For example, in the rule for addition,  
 @c @code{$1} refers to the first component @code{exp} and @code{$2} refers to  
 @c the second one.  The third component, @code{'+'}, has no meaningful  
 @c associated semantic value, but if it had one you could refer to it as  
 @c @code{$3}.  When @code{yyparse} recognizes a sum expression using this  
 @c rule, the sum of the two subexpressions' values is produced as the value of  
 @c the entire expression.  @xref{Actions}.  
 規則のほとんどは、式の部品の値から式の値を計算するための、  規則のほとんどは、式の部品の値から式の値を計算するための、
 アクションを持っています。  アクションを持っています。
 たとえば、加算のための規則では、@code{$1}は式の第1の部品を、  たとえば、加算のための規則では、@code{$1}は式の第1の部品を、
Line 2351  exp:      exp exp '-'     @{ $$ = $1 - $ Line 1578  exp:      exp exp '-'     @{ $$ = $1 - $
 式全体の値として、2個の部分式の値の和が生成されます。  式全体の値として、2個の部分式の値の和が生成されます。
 @xref{Actions}。  @xref{Actions}。
 @c You don't have to give an action for every rule.  When a rule has no  
 @c action, Bison by default copies the value of @code{$1} into @code{$$}.  
 @c This is what happens in the first rule (the one that uses @code{NUM}).  
 すべての規則に対してアクションを書く必要はありません。  すべての規則に対してアクションを書く必要はありません。
 アクションを省略すると、Bisonは@code{$1}の値を@code{$$}に複写します。  アクションを省略すると、Bisonは@code{$1}の値を@code{$$}に複写します。
 第1の規則では、@code{NUM}の値をそのまま複写するために、  第1の規則では、@code{NUM}の値をそのまま複写するために、
 このようになっています。  このようになっています。
 @c The formatting shown here is the recommended convention, but Bison does  
 @c not require it.  You can add or change whitespace as much as you wish.  
 @c For example, this:  
 ここで示したリストは、望ましい書式ですが、  ここで示したリストは、望ましい書式ですが、
 Bisonがこのように要求するわけではありません。  Bisonがこのように要求するわけではありません。
 必要に応じて、空白、タブ、改行を置けます。  必要に応じて、空白、タブ、改行を置けます。
Line 2373  Bisonがこのように要求するわけではありま Line 1592  Bisonがこのように要求するわけではありま
 exp   : NUM | exp exp '+' @{$$ = $1 + $2; @} | @dots{}  exp   : NUM | exp exp '+' @{$$ = $1 + $2; @} | @dots{}
 @end example  @end example
 @c @noindent  
 @c means the same thing as this:  
 これは、次のリストと等価です。  これは、次のリストと等価です。
 @example  @example
Line 2384  exp:      NUM Line 1600  exp:      NUM
         | @dots{}          | @dots{}
 @end example  @end example
 @c @noindent  
 @c The latter, however, is much more readable.  
 しかし、後者のほうが可読性が優れています。  しかし、後者のほうが可読性が優れています。
 @c =====================================================================  
 @node Rpcalc Lexer, Rpcalc Main, Rpcalc Rules, RPN Calc  @node Rpcalc Lexer, Rpcalc Main, Rpcalc Rules, RPN Calc
 @c @subsection The @code{rpcalc} Lexical Analyzer  
 @subsection @code{rpcalc}字句解析器  @subsection @code{rpcalc}字句解析器
 @cindex writing a lexical analyzer  @cindex writing a lexical analyzer
 @cindex lexical analyzer, writing  @cindex lexical analyzer, writing
 @cindex 字句解析器  @cindex 字句解析器
 @c The lexical analyzer's job is low-level parsing: converting characters or  
 @c sequences of characters into tokens.  The Bison parser gets its tokens by  
 @c calling the lexical analyzer.  
 @c @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}.  
 字句解析器の仕事は、低水準の構文解析で、文字または文字列を  字句解析器の仕事は、低水準の構文解析で、文字または文字列を
 トークンに変換します。  トークンに変換します。
 Bison構文解析器は、字句解析器を呼び出してトークンを得ます。  Bison構文解析器は、字句解析器を呼び出してトークンを得ます。
 @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}。  @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}。
 @c Only a simple lexical analyzer is needed for the RPN calculator.  This  
 @c lexical analyzer skips blanks and tabs, then reads in numbers as  
 @c @code{double} and returns them as @code{NUM} tokens.  Any other character  
 @c that isn't part of a number is a separate token.  Note that the token-code  
 @c for such a single-character token is the character itself.  
 RPN(逆ポーランド記法)電卓には、簡単な字句解析器のみが必要です。  RPN(逆ポーランド記法)電卓には、簡単な字句解析器のみが必要です。
 この字句解析器は、空白とタブを読み飛ばし、  この字句解析器は、空白とタブを読み飛ばし、
 数値を読み込んで@code{double}型の@code{NUM}トークンとして返します。  数値を読み込んで@code{double}型の@code{NUM}トークンとして返します。
 数値の一部分ではないその他の文字は、独立のトークンです。  数値の一部分ではないその他の文字は、独立のトークンです。
 1文字トークンのトークン符号はその文字自身であることに注意してください。  1文字トークンのトークン符号はその文字自身であることに注意してください。
 @c The return value of the lexical analyzer function is a numeric code which  
 @c represents a token type.  The same text used in Bison rules to stand for  
 @c this token type is also a C expression for the numeric code for the type.  
 @c This works in two ways.  If the token type is a character literal, then its  
 @c numeric code is the ASCII code for that character; you can use the same  
 @c character literal in the lexical analyzer to express the number.  If the  
 @c token type is an identifier, that identifier is defined by Bison as a C  
 @c macro whose definition is the appropriate number.  In this example,  
 @c therefore, @code{NUM} becomes a macro for @code{yylex} to use.  
 字句解析関数の戻り値は、トークン型を表す数値です。  字句解析関数の戻り値は、トークン型を表す数値です。
 Bison規則の中でトークン型を表すために使われる文字列と同じものが、  Bison規則の中でトークン型を表すために使われる文字列と同じものが、
 その型の数値符号を表すCの式でもあります。  その型の数値符号を表すCの式でもあります。
Line 2442  Bison規則の中でトークン型を表すために使 Line 1632  Bison規則の中でトークン型を表すために使
 したがって、この例では、@code{NUM}は、@code{yylex}のために使える  したがって、この例では、@code{NUM}は、@code{yylex}のために使える
 マクロにもなります。  マクロにもなります。
 @c The semantic value of the token (if it has one) is stored into the global  
 @c variable @code{yylval}, which is where the Bison parser will look for it.  
 @c (The C data type of @code{yylval} is @code{YYSTYPE}, which was defined  
 @c at the beginning of the grammar;  
 @c @pxref{Rpcalc Decls, ,Declarations for @code{rpcalc}}.)  
 トークンの意味値は、もし存在すれば、大域変数@code{yylval}に記憶され、  トークンの意味値は、もし存在すれば、大域変数@code{yylval}に記憶され、
 Bison構文解析器はそこを見にいきます  Bison構文解析器はそこを見にいきます
 (@code{yylval}のCデータ型は、文法の最初で定義される@code{YYSTYPE}です。  (@code{yylval}のCデータ型は、文法の最初で定義される@code{YYSTYPE}です。
 @pxref{Rpcalc Decls, ,Declarations for @code{rpcalc}})。  @pxref{Rpcalc Decls, ,Declarations for @code{rpcalc}})。
 @c A token type code of zero is returned if the end-of-file is encountered.  
 @c (Bison recognizes any nonpositive value as indicating the end of the  
 @c input.)  
 ファイルの終わりに達すると、トークン型のコード0が返されます  ファイルの終わりに達すると、トークン型のコード0が返されます
 (Bisonは、正でない任意の値を入力の終わりと認識します)。  (Bisonは、正でない任意の値を入力の終わりと認識します)。
 @c Here is the code for the lexical analyzer:  
 字句解析器のプログラムの例を示します。  字句解析器のプログラムの例を示します。
 @example  @example
 @group  @group
 @c /* Lexical analyzer returns a double floating point   
 @c    number on the stack and the token NUM, or the ASCII  
 @c    character read if not a number.  Skips all blanks  
 @c    and tabs, returns 0 for EOF. */  
 /*  /*
  * 字句解析器は、数値を読めば、double型の値をスタックに積んで   * 字句解析器は、数値を読めば、double型の値をスタックに積んで
  * トークン「NUM」を返し、数値以外を読めば、その文字のアスキー符号を返す。   * トークン「NUM」を返し、数値以外を読めば、その文字のアスキー符号を返す。
Line 2484  yylex () Line 1658  yylex ()
 @{  @{
   int c;    int c;
 @c   /* skip white space  */  
   /* 空白類を読み飛ばす  */    /* 空白類を読み飛ばす  */
   while ((c = getchar ()) == ' ' || c == '\t')      while ((c = getchar ()) == ' ' || c == '\t')  
     ;      ;
 @end group  @end group
 @group  @group
 @c  /* process numbers   */  
   /* 数値を処理する   */    /* 数値を処理する   */
   if (c == '.' || isdigit (c))                    if (c == '.' || isdigit (c))                
     @{      @{
Line 2510  yylex () Line 1682  yylex ()
 @end example  @end example
 @c =====================================================================  
 @node Rpcalc Main, Rpcalc Error, Rpcalc Lexer, RPN Calc  @node Rpcalc Main, Rpcalc Error, Rpcalc Lexer, RPN Calc
 @c @subsection The Controlling Function  
 @subsection 制御関数  @subsection 制御関数
 @cindex controlling function  @cindex controlling function
 @cindex main function in simple example  @cindex main function in simple example
Line 2520  yylex () Line 1690  yylex ()
 @cindex 単純な例のmain関数  @cindex 単純な例のmain関数
 @cindex main関数  @cindex main関数
 @c In keeping with the spirit of this example, the controlling function is  
 @c kept to the bare minimum.  The only requirement is that it call  
 @c @code{yyparse} to start the process of parsing.  
 この例の精神に則って、制御関数は、飾りのない最小限のものです。  この例の精神に則って、制御関数は、飾りのない最小限のものです。
 唯一必要なことは、構文解析の処理を始めるために、  唯一必要なことは、構文解析の処理を始めるために、
 @code{yyparse}関数を呼び出すことです。  @code{yyparse}関数を呼び出すことです。
Line 2552  int main () Line 1718  int main ()
 @end example  @end example
 }  }
 @c =====================================================================  
 @node Rpcalc Error, Rpcalc Gen, Rpcalc Main, RPN Calc  @node Rpcalc Error, Rpcalc Gen, Rpcalc Main, RPN Calc
 @c @subsection The Error Reporting Routine  
 @subsection エラー報告関数  @subsection エラー報告関数
 @cindex error reporting routine  @cindex error reporting routine
 @cindex エラー報告関数  @cindex エラー報告関数
 @c When @code{yyparse} detects a syntax error, it calls the error reporting  
 @c function @code{yyerror} to print an error message (usually but not always  
 @c @code{"parse error"}).  It is up to the programmer to supply @code{yyerror}  
 @c (@pxref{Interface, ,Parser C-Language Interface}),  
 @c so here is the definition we will use:  
 @code{yyparse}は、構文エラーを検出すると、エラーメッセージ  @code{yyparse}は、構文エラーを検出すると、エラーメッセージ
 (必ずそうとはかぎりませんが、通常は@code{"parse error"})を  (必ずそうとはかぎりませんが、通常は@code{"parse error"})を
 表示するために、エラー報告関数@code{yyerror}を呼び出します。  表示するために、エラー報告関数@code{yyerror}を呼び出します。
Line 2573  int main () Line 1731  int main ()
 @group  @group
 #include <stdio.h>  #include <stdio.h>
 @c yyerror (s)  /* Called by yyparse on error */  
 yyerror (s)  /* エラーが起きるとyyparseから呼び出される */  yyerror (s)  /* エラーが起きるとyyparseから呼び出される */
      char *s;       char *s;
 @{  @{
Line 2582  yyerror (s)  /* エラーが起きるとyyparse Line 1739  yyerror (s)  /* エラーが起きるとyyparse
 @end group  @end group
 @end example  @end example
 @c After @code{yyerror} returns, the Bison parser may recover from the error  
 @c and continue parsing if the grammar contains a suitable error rule  
 @c (@pxref{Error Recovery}).  Otherwise, @code{yyparse} returns nonzero.  We  
 @c have not written any error rules in this example, so any invalid input will  
 @c cause the calculator program to exit.  This is not clean behavior for a  
 @c real calculator, but it is adequate in the first example.  
 @code{yyerror}から戻った後に、Bison構文解析器は、  @code{yyerror}から戻った後に、Bison構文解析器は、
 文法に適切なエラー規則(@pxref{Error Recovery})があれば、  文法に適切なエラー規則(@pxref{Error Recovery})があれば、
 エラーから回復し、解析を継続できます。  エラーから回復し、解析を継続できます。
Line 2599  yyerror (s)  /* エラーが起きるとyyparse Line 1749  yyerror (s)  /* エラーが起きるとyyparse
 最初の例としては十分です。  最初の例としては十分です。
 @c =====================================================================  
 @node Rpcalc Gen, Rpcalc Compile, Rpcalc Error, RPN Calc  @node Rpcalc Gen, Rpcalc Compile, Rpcalc Error, RPN Calc
 @c @subsection Running Bison to Make the Parser  
 @subsection 構文解析器を生成するためにBisonを実行  @subsection 構文解析器を生成するためにBisonを実行
 @cindex running Bison (introduction)  @cindex running Bison (introduction)
 @cindex Bisonの実行  @cindex Bisonの実行
 @c Before running Bison to produce a parser, we need to decide how to arrange  
 @c all the source code in one or more source files.  For such a simple example,  
 @c the easiest thing is to put everything in one file.  The definitions of  
 @c @code{yylex}, @code{yyerror} and @code{main} go at the end, in the  
 @c ``additional C code'' section of the file  
 @c (@pxref{Grammar Layout, ,The Overall Layout of a Bison Grammar}).  
 構文解析器を生成するためにBisonを実行する前に、  構文解析器を生成するためにBisonを実行する前に、
 1つ以上のソースファイルのすべてをどのように整えるか、  1つ以上のソースファイルのすべてをどのように整えるか、
 決める必要があります。  決める必要があります。
Line 2622  yyerror (s)  /* エラーが起きるとyyparse Line 1763  yyerror (s)  /* エラーが起きるとyyparse
 ファイルの「追加のCコード」部の最後に置きます  ファイルの「追加のCコード」部の最後に置きます
 (@pxref{Grammar Layout, ,The Overall Layout of a Bison Grammar})。  (@pxref{Grammar Layout, ,The Overall Layout of a Bison Grammar})。
 @c For a large project, you would probably have several source files, and use  
 @c @code{make} to arrange to recompile them.  
 大きなプロジェクトでは、ソースコードを複数のファイルに分け、  大きなプロジェクトでは、ソースコードを複数のファイルに分け、
 まとめてリコンパイルするために@code{make}を使うでしょう。  まとめてリコンパイルするために@code{make}を使うでしょう。
 @c With all the source in a single file, you use the following command to  
 @c convert it into a parser file:  
 1つのファイルにすべてのソースが入っているならば、  1つのファイルにすべてのソースが入っているならば、
 次のコマンドで、それを構文解析器ファイルに変換できます。  次のコマンドで、それを構文解析器ファイルに変換できます。
Line 2638  yyerror (s)  /* エラーが起きるとyyparse Line 1773  yyerror (s)  /* エラーが起きるとyyparse
 bison @var{file_name}.y  bison @var{file_name}.y
 @end example  @end example
 @c @noindent  
 @c In this example the file was called @file{rpcalc.y} (for ``Reverse Polish  
 @c CALCulator'').  Bison produces a file named @file{@var{file_name}.tab.c},  
 @c removing the @samp{.y} from the original file name. The file output by  
 @c Bison contains the source code for @code{yyparse}.  The additional  
 @c functions in the input file (@code{yylex}, @code{yyerror} and @code{main})  
 @c are copied verbatim to the output.  
 この例では、ファイルは@file{rpcalc.y}(逆ポーランド記法電卓)と  この例では、ファイルは@file{rpcalc.y}(逆ポーランド記法電卓)と
 呼ばれています。Bisonは、元のファイル名から@samp{.y}を取り除いて、  呼ばれています。Bisonは、元のファイル名から@samp{.y}を取り除いて、
 @file{@var{file_name}.tab.c}というファイルを生成します。  @file{@var{file_name}.tab.c}というファイルを生成します。
Line 2654  Bisonが出力したファイルには、@code{yypar Line 1781  Bisonが出力したファイルには、@code{yypar
 出力にそのまま複写されます。  出力にそのまま複写されます。
 @c =====================================================================  
 @node Rpcalc Compile,  , Rpcalc Gen, RPN Calc  @node Rpcalc Compile,  , Rpcalc Gen, RPN Calc
 @c @subsection Compiling the Parser File  
 @subsection 構文解析器ファイルのコンパイル  @subsection 構文解析器ファイルのコンパイル
 @cindex compiling the parser  @cindex compiling the parser
 @cindex コンパイル  @cindex コンパイル
 @c Here is how to compile and run the parser file:  
 構文解析器ファイルをコンパイルする方法を示します。  構文解析器ファイルをコンパイルする方法を示します。
 @footnote{【訳注】UNIX上で@code{cc}コマンドを使ってコンパイルする方法を示します。}  @footnote{【訳注】UNIX上で@code{cc}コマンドを使ってコンパイルする方法を示します。}
 @example  @example
 @group  @group
 @c # @r{List files in current directory.}  
 # @r{カレントディレクトリのファイルの一覧を見る。}  # @r{カレントディレクトリのファイルの一覧を見る。}
 % ls  % ls
 rpcalc.tab.c  rpcalc.y  rpcalc.tab.c  rpcalc.y
 @end group  @end group
 @group  @group
 @c # @r{Compile the Bison parser.}  
 # @r{Bison構文解析器をコンパイルする。}  # @r{Bison構文解析器をコンパイルする。}
 @c # @r{@samp{-lm} tells compiler to search math library for @code{pow}.}  
 # @r{数学ライブラリ内の@code{pow}関数をリンクするために@samp{-lm}を指定する。}  # @r{数学ライブラリ内の@code{pow}関数をリンクするために@samp{-lm}を指定する。}
 % cc rpcalc.tab.c -lm -o rpcalc  % cc rpcalc.tab.c -lm -o rpcalc
 @end group  @end group
 @group  @group
 @c # @r{List files again.}  
 # @r{再び、ファイルの一覧を見る。}  # @r{再び、ファイルの一覧を見る。}
 % ls  % ls
 rpcalc  rpcalc.tab.c  rpcalc.y  rpcalc  rpcalc.tab.c  rpcalc.y
 @end group  @end group
 @end example  @end example
 @c The file @file{rpcalc} now contains the executable code.  Here is an  
 @c example session using @code{rpcalc}.  
 できた@file{rpcalc}ファイルは、実行可能プログラムです。  できた@file{rpcalc}ファイルは、実行可能プログラムです。
 @code{rpcalc}を実行させる例を示します。  @code{rpcalc}を実行させる例を示します。
Line 2702  rpcalc  rpcalc.tab.c  rpcalc.y Line 1818  rpcalc  rpcalc.tab.c  rpcalc.y
 13  13
 3 7 + 3 4 5 *+-  3 7 + 3 4 5 *+-
 -13  -13
 @c 3 7 + 3 4 5 * + - n              @r{Note the unary minus, @samp{n}}  
 3 7 + 3 4 5 * + - n              @r{単項マイナスを示す@samp{n}に注意}  3 7 + 3 4 5 * + - n              @r{単項マイナスを示す@samp{n}に注意}
 13  13
 5 6 / 4 n +  5 6 / 4 n +
 -3.166666667  -3.166666667
 @c 3 4 ^                            @r{Exponentiation}  
 3 4 ^                            @r{べき乗関数}  3 4 ^                            @r{べき乗関数}
 81  81
 @c ^D                               @r{End-of-file indicator}  
 ^D                               @r{入力の終わり}  ^D                               @r{入力の終わり}
 %  %
 @end example  @end example
 @c =====================================================================  
 @node Infix Calc, Simple Error Recovery, RPN Calc, Examples  @node Infix Calc, Simple Error Recovery, RPN Calc, Examples
 @c @section Infix Notation Calculator: @code{calc}  
 @section 中間記法電卓:@code{calc}  @section 中間記法電卓:@code{calc}
 @cindex infix notation calculator  @cindex infix notation calculator
 @cindex calc  @cindex calc
 @cindex calculator, infix notation  @cindex calculator, infix notation
 @cindex 中間記法  @cindex 中間記法
 @c We now modify rpcalc to handle infix operators instead of postfix.  Infix  
 @c notation involves the concept of operator precedence and the need for  
 @c parentheses nested to arbitrary depth.  Here is the Bison code for  
 @c @file{calc.y}, an infix desk-top calculator.  
 後置記法演算子に代わって中間記法演算子を扱うように  後置記法演算子に代わって中間記法演算子を扱うように
 rpcalcを変更します。  rpcalcを変更します。
 中間記法には、演算子の優先順位の概念と、  中間記法には、演算子の優先順位の概念と、
Line 2738  rpcalcを変更します。 Line 1844  rpcalcを変更します。
 @file{calc.y}を示します。  @file{calc.y}を示します。
 @example  @example
 @c /* Infix notation calculator--calc */  
 /* 中間記法電卓 -- calc */  /* 中間記法電卓 -- calc */
 %@{  %@{
Line 2746  rpcalcを変更します。 Line 1851  rpcalcを変更します。
 #include <math.h>  #include <math.h>
 %@}  %@}
 @c /* BISON Declarations */  
 /* BISON宣言 */  /* BISON宣言 */
 %token NUM  %token NUM
 %left '-' '+'  %left '-' '+'
 %left '*' '/'  %left '*' '/'
 @c %left NEG     /* negation--unary minus */  
 %left NEG     /* negation--単項マイナス */  %left NEG     /* negation--単項マイナス */
 @c %right '^'    /* exponentiation        */  
 %right '^'    /* べき乗関数        */  %right '^'    /* べき乗関数        */
 @c /* Grammar follows */  
 /* 文法規則が続く */  /* 文法規則が続く */
 %%  %%
 @c input:    /* empty string */  
 input:    /* 空文字列 */  input:    /* 空文字列 */
         | input line          | input line
 ;  ;
Line 2780  exp:      NUM                @{ $$ = $1; Line 1880  exp:      NUM                @{ $$ = $1;
 %%  %%
 @end example  @end example
 @c @noindent  
 @c The functions @code{yylex}, @code{yyerror} and @code{main} can be the same  
 @c as before.  
 @code{yylex}、@code{yyerror}、@code{main}関数は、  @code{yylex}、@code{yyerror}、@code{main}関数は、
 前の例のものと同じです。  前の例のものと同じです。
 @c There are two important new features shown in this code.  
 このプログラムには、2つの重要な特徴があります。  このプログラムには、2つの重要な特徴があります。
 @c In the second section (Bison declarations), @code{%left} declares token  
 @c types and says they are left-associative operators.  The declarations  
 @c @code{%left} and @code{%right} (right associativity) take the place of  
 @c @code{%token} which is used to declare a token type name without  
 @c associativity.  (These tokens are single-character literals, which  
 @c ordinarily don't need to be declared.  We declare them here to specify  
 @c the associativity.)  
 第2の部分(Bison宣言部)では、  第2の部分(Bison宣言部)では、
 @code{%left}がトークンの型とそれが左結合演算子であると宣言します。  @code{%left}がトークンの型とそれが左結合演算子であると宣言します。
 宣言@code{%left}と@code{%right}(右結合演算子)は、  宣言@code{%left}と@code{%right}(右結合演算子)は、
Line 2807  exp:      NUM                @{ $$ = $1; Line 1893  exp:      NUM                @{ $$ = $1;
 (1文字のリテラルであるトークンは、通常、宣言する必要がありません。  (1文字のリテラルであるトークンは、通常、宣言する必要がありません。
 ここでは、結合性を宣言します)。  ここでは、結合性を宣言します)。
 @c Operator precedence is determined by the line ordering of the  
 @c declarations; the higher the line number of the declaration (lower on  
 @c the page or screen), the higher the precedence.  Hence, exponentiation  
 @c has the highest precedence, unary minus (@code{NEG}) is next, followed  
 @c by @samp{*} and @samp{/}, and so on.  
 @c @xref{Precedence, ,Operator Precedence}.  
 演算子の優先順位は、宣言が書かれる行の順序で決まります。  演算子の優先順位は、宣言が書かれる行の順序で決まります。
 後から宣言された演算子ほど、高い優先順位を持ちます。  後から宣言された演算子ほど、高い優先順位を持ちます。
 したがって、べき乗の優先順位がもっとも高く、  したがって、べき乗の優先順位がもっとも高く、
 単項の負(@code{NEG})、「@samp{*}」と「@samp{/}」と続きます。  単項の負(@code{NEG})、「@samp{*}」と「@samp{/}」と続きます。
 @xref{Precedence, ,Operator Precedence}。  @xref{Precedence, ,Operator Precedence}。
 @c The other important new feature is the @code{%prec} in the grammar section  
 @c for the unary minus operator.  The @code{%prec} simply instructs Bison that  
 @c the rule @samp{| '-' exp} has the same precedence as @code{NEG}---in this  
 @c case the next-to-highest.  
 @c @xref{Contextual Precedence, ,Context-Dependent Precedence}.  
 もう1つの重要な特徴は、単項の負の演算子のために文法部分にある  もう1つの重要な特徴は、単項の負の演算子のために文法部分にある
 @code{%prec}です。  @code{%prec}です。
 @code{%prec}は、単純にBisonに対して、規則@samp{| '-' exp}は  @code{%prec}は、単純にBisonに対して、規則@samp{| '-' exp}は
 @code{NEG}と同じ優先順位を持つように指示し、  @code{NEG}と同じ優先順位を持つように指示し、
 この例ではどちらも2番目に高い優先順位を持ちます。  この例ではどちらも2番目に高い優先順位を持ちます。
 @c Here is a sample run of @file{calc.y}:  
 以下は@file{calc.y}の実行例です。  以下は@file{calc.y}の実行例です。
 @need 500  @need 500
Line 2848  exp:      NUM                @{ $$ = $1; Line 1919  exp:      NUM                @{ $$ = $1;
 @end example  @end example
 @c =====================================================================  
 @node Simple Error Recovery, Multi-function Calc, Infix Calc, Examples  @node Simple Error Recovery, Multi-function Calc, Infix Calc, Examples
 @c @section Simple Error Recovery  
 @section 単純なエラー回復  @section 単純なエラー回復
 @cindex error recovery, simple  @cindex error recovery, simple
 @cindex エラー回復  @cindex エラー回復
 @c Up to this point, this manual has not addressed the issue of @dfn{error  
 @c recovery}---how to continue parsing after the parser detects a syntax  
 @c error.  All we have handled is error reporting with @code{yyerror}.  Recall  
 @c that by default @code{yyparse} returns after calling @code{yyerror}.  This  
 @c means that an erroneous input line causes the calculator program to exit.  
 @c Now we show how to rectify this deficiency.  
 今まで、本書では、@dfn{エラー回復(error recovery)}、  今まで、本書では、@dfn{エラー回復(error recovery)}、
 つまり、構文エラーを検出した後で構文解析を続ける方法については  つまり、構文エラーを検出した後で構文解析を続ける方法については
 言及していませんでした。  言及していませんでした。
Line 2871  exp:      NUM                @{ $$ = $1; Line 1933  exp:      NUM                @{ $$ = $1;
 つまり、エラーを含む入力行が、電卓プログラムを終了させます。  つまり、エラーを含む入力行が、電卓プログラムを終了させます。
 この欠陥をどのように改善するか示しましょう。  この欠陥をどのように改善するか示しましょう。
 @c The Bison language itself includes the reserved word @code{error}, which  
 @c may be included in the grammar rules.  In the example below it has  
 @c been added to one of the alternatives for @code{line}:  
 Bison言語の文法規則には、予約語@code{error}があります。  Bison言語の文法規則には、予約語@code{error}があります。
 次の例では、@code{line}に対する選択肢群に@code{error}を追加する  次の例では、@code{line}に対する選択肢群に@code{error}を追加する
 方法を示します。  方法を示します。
Line 2888  line:     '\n' Line 1946  line:     '\n'
 @end group  @end group
 @end example  @end example
 @c This addition to the grammar allows for simple error recovery in the event  
 @c of a parse error.  If an expression that cannot be evaluated is read, the  
 @c error will be recognized by the third rule for @code{line}, and parsing  
 @c will continue.  (The @code{yyerror} function is still called upon to print  
 @c its message as well.)  The action executes the statement @code{yyerrok}, a  
 @c macro defined automatically by Bison; its meaning is that error recovery is  
 @c complete (@pxref{Error Recovery}).  Note the difference between  
 @c @code{yyerrok} and @code{yyerror}; neither one is a misprint.@refill  
 文法へのこの追加によって、構文解析エラーが発生した場合に、  文法へのこの追加によって、構文解析エラーが発生した場合に、
 簡単なエラー回復が可能になります。  簡単なエラー回復が可能になります。
 評価不可能な式が読み込まれると、  評価不可能な式が読み込まれると、
Line 2909  Bisonによって自動的に定義されるマクロで Line 1958  Bisonによって自動的に定義されるマクロで
 これはエラー回復の完了を意味します(@pxref{Error Recovery})。  これはエラー回復の完了を意味します(@pxref{Error Recovery})。
 @code{yyerrok}と@code{yyerror}の違いに注意してください。  @code{yyerrok}と@code{yyerror}の違いに注意してください。
 @c This form of error recovery deals with syntax errors.  There are other  
 @c kinds of errors; for example, division by zero, which raises an exception  
 @c signal that is normally fatal.  A real calculator program must handle this  
 @c signal and use @code{longjmp} to return to @code{main} and resume parsing  
 @c input lines; it would also have to discard the rest of the current line of  
 @c input.  We won't discuss this issue further because it is not specific to  
 @c Bison programs.  
 この形式のエラー回復は、構文エラーを扱います。  この形式のエラー回復は、構文エラーを扱います。
 他の種類のエラーもあります。  他の種類のエラーもあります。
 たとえば、0による除算は、例外シグナルを発生し、通常は致命的です。  たとえば、0による除算は、例外シグナルを発生し、通常は致命的です。
Line 2927  Bisonによって自動的に定義されるマクロで Line 1968  Bisonによって自動的に定義されるマクロで
 本書では解説しません。  本書では解説しません。
 @c =====================================================================  
 @node Multi-function Calc, Exercises, Simple Error Recovery, Examples  @node Multi-function Calc, Exercises, Simple Error Recovery, Examples
 @c @section Multi-Function Calculator: @code{mfcalc}  
 @section 多機能電卓:@code{mfcalc}  @section 多機能電卓:@code{mfcalc}
 @cindex multi-function calculator  @cindex multi-function calculator
 @cindex mfcalc  @cindex mfcalc
Line 2937  Bisonによって自動的に定義されるマクロで Line 1976  Bisonによって自動的に定義されるマクロで
 @cindex 多機能電卓  @cindex 多機能電卓
 @cindex 電卓, 多機能  @cindex 電卓, 多機能
 @c Now that the basics of Bison have been discussed, it is time to move on to  
 @c a more advanced problem.  The above calculators provided only five  
 @c functions, @samp{+}, @samp{-}, @samp{*}, @samp{/} and @samp{^}.  It would  
 @c be nice to have a calculator that provides other mathematical functions such  
 @c as @code{sin}, @code{cos}, etc.  
 Bisonの基礎についての説明が終わったので、より高度な話題に移りましょう。  Bisonの基礎についての説明が終わったので、より高度な話題に移りましょう。
 前述の電卓は、5種類の機能、@samp{+}、@samp{-}、@samp{*}、@samp{/}、  前述の電卓は、5種類の機能、@samp{+}、@samp{-}、@samp{*}、@samp{/}、
 @samp{^}を持っています。  @samp{^}を持っています。
 この電卓に、その他の数学関数、たとえば、@code{sin}、@code{cos}などを  この電卓に、その他の数学関数、たとえば、@code{sin}、@code{cos}などを
 追加するとよいでしょう。  追加するとよいでしょう。
 @c It is easy to add new operators to the infix calculator as long as they are  
 @c only single-character literals.  The lexical analyzer @code{yylex} passes  
 @c back all non-number characters as tokens, so new grammar rules suffice for  
 @c adding a new operator.  But we want something more flexible: built-in  
 @c functions whose syntax has this form:  
 中間記法電卓への新しい演算子の追加は、  中間記法電卓への新しい演算子の追加は、
 その演算子が1文字リテラルならば簡単です。  その演算子が1文字リテラルならば簡単です。
 字句解析器@code{yylex}は、数値以外のすべての文字をトークンとして渡すので、  字句解析器@code{yylex}は、数値以外のすべての文字をトークンとして渡すので、
Line 2962  Bisonの基礎についての説明が終わったので Line 1989  Bisonの基礎についての説明が終わったので
 しかし、次のような表記方法の、より柔軟な組み込み関数が必要です。  しかし、次のような表記方法の、より柔軟な組み込み関数が必要です。
 @example  @example
 @c @var{function_name} (@var{argument})  
 @var{関数名} (@var{引数})  @var{関数名} (@var{引数})
 @end example  @end example
 @c @noindent  
 @c At the same time, we will add memory to the calculator, by allowing you  
 @c to create named variables, store values in them, and use them later.  
 @c Here is a sample session with the multi-function calculator:  
 さらに、電卓にメモリを追加し、名前付き変数を作り、そこに値を記憶し、  さらに、電卓にメモリを追加し、名前付き変数を作り、そこに値を記憶し、
 後で使えるようにしましょう。  後で使えるようにしましょう。
 以下に多機能電卓を使う作業の例を示します。  以下に多機能電卓を使う作業の例を示します。
Line 2992  exp(ln(beta1)) Line 2013  exp(ln(beta1))
 %  %
 @end example  @end example
 @c Note that multiple assignment and nested function calls are permitted.  
 複数の代入@footnote{【訳注】例の@samp{alpha = beta1 = 2.3}}と  複数の代入@footnote{【訳注】例の@samp{alpha = beta1 = 2.3}}と
 関数の入れ子@footnote{【訳注】例の@samp{exp(ln(beta1))}}が  関数の入れ子@footnote{【訳注】例の@samp{exp(ln(beta1))}}が
Line 3005  exp(ln(beta1)) Line 2025  exp(ln(beta1))
 @end menu  @end menu
 @c =====================================================================  
 @node Mfcalc Decl, Mfcalc Rules,  , Multi-function Calc  @node Mfcalc Decl, Mfcalc Rules,  , Multi-function Calc
 @c @subsection Declarations for @code{mfcalc}  
 @subsection @code{mfcalc}のための定義  @subsection @code{mfcalc}のための定義
 @c Here are the C and Bison declarations for the multi-function calculator.  
 以下には、多機能電卓のための、CとBisonの宣言があります。  以下には、多機能電卓のための、CとBisonの宣言があります。
 @smallexample  @smallexample
 %@{  %@{
 @c #include <math.h>  /* For math functions, cos(), sin(), etc. */  
 #include <math.h>  /* cos(), sin()などの数学関数のため */  #include <math.h>  /* cos(), sin()などの数学関数のため */
 @c #include "calc.h"  /* Contains definition of `symrec'        */  
 #include "calc.h"  /* `symrec'の定義を含む             */  #include "calc.h"  /* `symrec'の定義を含む             */
 %@}  %@}
 %union @{  %union @{
 @c double     val;  /* For returning numbers.                   */  
 double     val;    /* 数値を返すため                   */  double     val;    /* 数値を返すため                   */
 @c symrec  *tptr;   /* For returning symbol-table pointers      */  
 symrec  *tptr;     /* 記号表へのポインタを返すため     */  symrec  *tptr;     /* 記号表へのポインタを返すため     */
 @}  @}
 @c %token <val>  NUM        /* Simple double precision number   */  
 %token <val>  NUM        /* 単純な倍精度数値 */  %token <val>  NUM        /* 単純な倍精度数値 */
 @c %token <tptr> VAR FNCT   /* Variable and Function            */  
 %token <tptr> VAR FNCT   /* 変数と関数       */  %token <tptr> VAR FNCT   /* 変数と関数       */
 %type  <val>  exp  %type  <val>  exp
 %right '='  %right '='
 %left '-' '+'  %left '-' '+'
 %left '*' '/'  %left '*' '/'
 @c %left NEG     /* Negation--unary minus */  
 %left NEG     /* 否定 -- 単項の負 */  %left NEG     /* 否定 -- 単項の負 */
 @c %right '^'    /* Exponentiation        */  
 %right '^'    /* べき乗           */  %right '^'    /* べき乗           */
 @c /* Grammar follows */  
 /* 文法が続く */  /* 文法が続く */
 %%  %%
 @end smallexample  @end smallexample
 @c The above grammar introduces only two new features of the Bison language.  
 @c These features allow semantic values to have various data types  
 @c (@pxref{Multiple Types, ,More Than One Value Type}).  
 この文法の導入部分では、Bison言語の新しい2つの機能を使っています。  この文法の導入部分では、Bison言語の新しい2つの機能を使っています。
 これらの機能によって、意味値がいろいろなデータ型を持てます  これらの機能によって、意味値がいろいろなデータ型を持てます
 (@pxref{Multiple Types, ,More Than One Value Type})。  (@pxref{Multiple Types, ,More Than One Value Type})。
 @c The @code{%union} declaration specifies the entire list of possible types;  
 @c this is instead of defining @code{YYSTYPE}.  The allowable types are now  
 @c double-floats (for @code{exp} and @code{NUM}) and pointers to entries in  
 @c the symbol table.  @xref{Union Decl, ,The Collection of Value Types}.  
 @code{%union}宣言は、@code{YYSTYPE}の定義の代わりで、  @code{%union}宣言は、@code{YYSTYPE}の定義の代わりで、
 可能な型の一覧を指定します。  可能な型の一覧を指定します。
 ここで許される型は、(@code{exp}と@code{NUM}のための)倍精度浮動小数点型と、  ここで許される型は、(@code{exp}と@code{NUM}のための)倍精度浮動小数点型と、
 記号表の項目へのポインタです。  記号表の項目へのポインタです。
 @xref{Union Decl, ,The Collection of Value Types}。  @xref{Union Decl, ,The Collection of Value Types}。
 @c Since values can now have various types, it is necessary to associate a  
 @c type with each grammar symbol whose semantic value is used.  These symbols  
 @c are @code{NUM}, @code{VAR}, @code{FNCT}, and @code{exp}.  Their  
 @c declarations are augmented with information about their data type (placed  
 @c between angle brackets).  
 値がいろいろな型を持つことができるので、  値がいろいろな型を持つことができるので、
 意味値を使うそれぞれの文法記号に対して、  意味値を使うそれぞれの文法記号に対して、
 型を関連づける必要があります。  型を関連づける必要があります。
Line 3080  symrec  *tptr;     /* 記号表へのポインタ Line 2072  symrec  *tptr;     /* 記号表へのポインタ
 それらの宣言は、不等号で囲まれた(@samp{<...>})データ型に関する  それらの宣言は、不等号で囲まれた(@samp{<...>})データ型に関する
 情報を付加されています。  情報を付加されています。
 @c The Bison construct @code{%type} is used for declaring nonterminal symbols,  
 @c just as @code{%token} is used for declaring token types.  We have not used  
 @c @code{%type} before because nonterminal symbols are normally declared  
 @c implicitly by the rules that define them.  But @code{exp} must be declared  
 @c explicitly so we can specify its value type.  
 @c @xref{Type Decl, ,Nonterminal Symbols}.  
 Bisonは、ちょうど@code{%token}がトークン型の宣言に使われるのと同じように、  Bisonは、ちょうど@code{%token}がトークン型の宣言に使われるのと同じように、
 @code{%type}が非終端記号の宣言に使われるようにします。  @code{%type}が非終端記号の宣言に使われるようにします。
 非終端記号は通常それらを定義する規則によって暗黙に宣言されるので、  非終端記号は通常それらを定義する規則によって暗黙に宣言されるので、
Line 3096  Bisonは、ちょうど@code{%token}がトークン Line 2081  Bisonは、ちょうど@code{%token}がトークン
 @xref{Type Decl, ,Nonterminal Symbols}。  @xref{Type Decl, ,Nonterminal Symbols}。
 @c =====================================================================  
 @node Mfcalc Rules, Mfcalc Symtab, Mfcalc Decl, Multi-function Calc  @node Mfcalc Rules, Mfcalc Symtab, Mfcalc Decl, Multi-function Calc
 @c @subsection Grammar Rules for @code{mfcalc}  
 @subsection @code{mfcalc}のための文法規則  @subsection @code{mfcalc}のための文法規則
 @c Here are the grammar rules for the multi-function calculator.  
 @c Most of them are copied directly from @code{calc}; three rules,  
 @c those which mention @code{VAR} or @code{FNCT}, are new.  
 多機能電卓のための文法規則を示します。  多機能電卓のための文法規則を示します。
 大部分は、@code{calc}の文法規則からの複写です。  大部分は、@code{calc}の文法規則からの複写です。
 @code{VAR}、@code{FUNCT}に関連する3つの規則が新しいものです。  @code{VAR}、@code{FUNCT}に関連する3つの規則が新しいものです。
 @smallexample  @smallexample
 @c input:   /* empty */  
 input:   /* 空 */  input:   /* 空 */
         | input line          | input line
 ;  ;
Line 3133  exp:      NUM                @{ $$ = $1; Line 2111  exp:      NUM                @{ $$ = $1;
         | exp '^' exp        @{ $$ = pow ($1, $3);               @}          | exp '^' exp        @{ $$ = pow ($1, $3);               @}
         | '(' exp ')'        @{ $$ = $2;                         @}          | '(' exp ')'        @{ $$ = $2;                         @}
 ;  ;
 @c /* End of grammar */  
 /* 文法の終わり */  /* 文法の終わり */
 %%  %%
 @end smallexample  @end smallexample
 @c =====================================================================  
 @node Mfcalc Symtab,  , Mfcalc Rules, Multi-function Calc  @node Mfcalc Symtab,  , Mfcalc Rules, Multi-function Calc
 @c @subsection The @code{mfcalc} Symbol Table  
 @subsection @code{mfcalc}の記号表  @subsection @code{mfcalc}の記号表
 @cindex symbol table example  @cindex symbol table example
 @cindex 記号表の例  @cindex 記号表の例
 @c The multi-function calculator requires a symbol table to keep track of the  
 @c names and meanings of variables and functions.  This doesn't affect the  
 @c grammar rules (except for the actions) or the Bison declarations, but it  
 @c requires some additional C functions for support.  
 変数と関数の名前と意味を保持するために、  変数と関数の名前と意味を保持するために、
 多機能電卓は記号表を必要とします。  多機能電卓は記号表を必要とします。
 これは、アクションを除く文法規則とBison宣言には影響しませんが、  これは、アクションを除く文法規則とBison宣言には影響しませんが、
 追加のCの関数がいくつか必要です。  追加のCの関数がいくつか必要です。
 @c The symbol table itself consists of a linked list of records.  Its  
 @c definition, which is kept in the header @file{calc.h}, is as follows.  It  
 @c provides for either functions or variables to be placed in the table.  
 記号表は、レコードのリンクリストからなります。  記号表は、レコードのリンクリストからなります。
 その定義は、後述の、ヘッダファイル@file{calc.h}にあります。  その定義は、後述の、ヘッダファイル@file{calc.h}にあります。
 関数と変数の両方を表に置くことができます。  関数と変数の両方を表に置くことができます。
 @smallexample  @smallexample
 @group  @group
 @c /* Data type for links in the chain of symbols.      */  
 /* 記号表のリンクを表すデータ型                 */  /* 記号表のリンクを表すデータ型                 */
 struct symrec  struct symrec
 @{  @{
 @c  char *name;  /* name of symbol                     */  
   char *name;  /* 記号の名前                    */    char *name;  /* 記号の名前                    */
 @c  int type;    /* type of symbol: either VAR or FNCT */  
   int type;    /* 記号の種類:VARまたはFNCT     */    int type;    /* 記号の種類:VARまたはFNCT     */
   union @{    union @{
 @c    double var;           /* value of a VAR          */  
     double var;           /* VARの値            */      double var;           /* VARの値            */
 @c    double (*fnctptr)();  /* value of a FNCT         */  
     double (*fnctptr)();  /* FNCTの値           */      double (*fnctptr)();  /* FNCTの値           */
   @} value;    @} value;
 @c  struct symrec *next;    /* link field              */  
   struct symrec *next;    /* 次の項目へのリンク */    struct symrec *next;    /* 次の項目へのリンク */
 @};  @};
 @end group  @end group
Line 3188  struct symrec Line 2148  struct symrec
 @group  @group
 typedef struct symrec symrec;  typedef struct symrec symrec;
 @c /* The symbol table: a chain of `struct symrec'.     */  
 /* `struct symrec'のリンクである記号表          */  /* `struct symrec'のリンクである記号表          */
 extern symrec *sym_table;  extern symrec *sym_table;
Line 3197  symrec *getsym (); Line 2156  symrec *getsym ();
 @end group  @end group
 @end smallexample  @end smallexample
 @c The new version of @code{main} includes a call to @code{init_table}, a  
 @c function that initializes the symbol table.  Here it is, and  
 @c @code{init_table} as well:  
 新しい@code{main}関数は、記号表を初期化する関数である  新しい@code{main}関数は、記号表を初期化する関数である
 @code{init_table}を呼びます。  @code{init_table}を呼びます。
 @code{main}と@code{init_table}を以下に示します。  @code{main}と@code{init_table}を以下に示します。
Line 3217  main () Line 2172  main ()
 @end group  @end group
 @group  @group
 @c yyerror (s)  /* Called by yyparse on error */  
 yyerror (s)  /* エラーがあるとyyparseから呼び出される */  yyerror (s)  /* エラーがあるとyyparseから呼び出される */
      char *s;       char *s;
 @{  @{
Line 3243  struct init arith_fncts[] Line 2197  struct init arith_fncts[]
       0, 0        0, 0
     @};      @};
 @c /* The symbol table: a chain of `struct symrec'.  */  
 /* 記号表:`struct symrec'のリスト       */  /* 記号表:`struct symrec'のリスト       */
 symrec *sym_table = (symrec *)0;  symrec *sym_table = (symrec *)0;
 @end group  @end group
 @group  @group
 @c init_table ()  /* puts arithmetic functions in table. */  
 init_table ()  /* 数学関数を表に登録する */  init_table ()  /* 数学関数を表に登録する */
 @{  @{
   int i;    int i;
Line 3263  init_table ()  /* 数学関数を表に登録する Line 2215  init_table ()  /* 数学関数を表に登録する
 @end group  @end group
 @end smallexample  @end smallexample
 @c By simply editing the initialization list and adding the necessary include  
 @c files, you can add additional functions to the calculator.  
 単純に初期化リストを編集して、必要なインクルードファイルを追加するだけで、  単純に初期化リストを編集して、必要なインクルードファイルを追加するだけで、
 電卓に関数を追加できます。  電卓に関数を追加できます。
 @c Two important functions allow look-up and installation of symbols in the  
 @c symbol table.  The function @code{putsym} is passed a name and the type  
 @c (@code{VAR} or @code{FNCT}) of the object to be installed.  The object is  
 @c linked to the front of the list, and a pointer to the object is returned.  
 @c The function @code{getsym} is passed the name of the symbol to look up.  If  
 @c found, a pointer to that symbol is returned; otherwise zero is returned.  
 記号表に記号を登録して検索するために、2個の重要な関数があります。  記号表に記号を登録して検索するために、2個の重要な関数があります。
 関数@code{putsym}は、登録すべきオブジェクトの  関数@code{putsym}は、登録すべきオブジェクトの
 名前と型(@code{VAR}や@code{FNCT})を渡されます。  名前と型(@code{VAR}や@code{FNCT})を渡されます。
Line 3296  putsym (sym_name,sym_type) Line 2238  putsym (sym_name,sym_type)
   ptr->name = (char *) malloc (strlen (sym_name) + 1);    ptr->name = (char *) malloc (strlen (sym_name) + 1);
   strcpy (ptr->name,sym_name);    strcpy (ptr->name,sym_name);
   ptr->type = sym_type;    ptr->type = sym_type;
 @c  ptr->value.var = 0; /* set value to 0 even if fctn.  */  
   ptr->value.var = 0; /* 関数の場合にも値を0にする */    ptr->value.var = 0; /* 関数の場合にも値を0にする */
   ptr->next = (struct symrec *)sym_table;    ptr->next = (struct symrec *)sym_table;
   sym_table = ptr;    sym_table = ptr;
Line 3316  getsym (sym_name) Line 2257  getsym (sym_name)
 @}  @}
 @end smallexample  @end smallexample
 @c The function @code{yylex} must now recognize variables, numeric values, and  
 @c the single-character arithmetic operators.  Strings of alphanumeric  
 @c characters with a leading nondigit are recognized as either variables or  
 @c functions depending on what the symbol table says about them.  
 今度の関数@code{yylex}は、変数、数値、1文字の算術演算子を  今度の関数@code{yylex}は、変数、数値、1文字の算術演算子を
 認識する必要があります。  認識する必要があります。
 英字で始まり英数字からなる文字列は、記号表にどう書かれているかに応じて、  英字で始まり英数字からなる文字列は、記号表にどう書かれているかに応じて、
 変数と関数のどちらとも認識されます。  変数と関数のどちらとも認識されます。
 @c The string is passed to @code{getsym} for look up in the symbol table.  If  
 @c the name appears in the table, a pointer to its location and its type  
 @c (@code{VAR} or @code{FNCT}) is returned to @code{yyparse}.  If it is not  
 @c already in the table, then it is installed as a @code{VAR} using  
 @c @code{putsym}.  Again, a pointer and its type (which must be @code{VAR}) is  
 @c returned to @code{yyparse}.@refill  
 文字列は、記号表を検索するために@code{getsym}に渡されます。  文字列は、記号表を検索するために@code{getsym}に渡されます。
 もし名前が表にあれば、その場所へのポインタと  もし名前が表にあれば、その場所へのポインタと
 名前の型(@code{VAR}または@code{FNCT})が、  名前の型(@code{VAR}または@code{FNCT})が、
Line 3342  getsym (sym_name) Line 2271  getsym (sym_name)
 そして、ポインタと型(この場合には必ず@code{VAR})が  そして、ポインタと型(この場合には必ず@code{VAR})が
 @code{yyparse}に返されます。  @code{yyparse}に返されます。
 @c No change is needed in the handling of numeric values and arithmetic  
 @c operators in @code{yylex}.  
 @code{yylex}の中で、数値と算術演算子の扱いに関する部分は、  @code{yylex}の中で、数値と算術演算子の扱いに関する部分は、
 変更する必要がありません。  変更する必要がありません。
Line 3355  yylex () Line 2281  yylex ()
 @{  @{
   int c;    int c;
 @c  /* Ignore whitespace, get first nonwhite character.  */  
   /* 空白を読み飛ばし、空白以外を得る         */    /* 空白を読み飛ばし、空白以外を得る         */
   while ((c = getchar ()) == ' ' || c == '\t');    while ((c = getchar ()) == ' ' || c == '\t');
Line 3364  yylex () Line 2289  yylex ()
 @end group  @end group
 @group  @group
 @c  /* Char starts a number => parse the number.         */  
   /* 数値を読む   */    /* 数値を読む   */
   if (c == '.' || isdigit (c))    if (c == '.' || isdigit (c))
     @{      @{
Line 3375  yylex () Line 2299  yylex ()
 @end group  @end group
 @group  @group
 @c  /* Char starts an identifier => read the name.       */  
   /* 識別子を読む */    /* 識別子を読む */
   if (isalpha (c))    if (isalpha (c))
     @{      @{
Line 3386  yylex () Line 2309  yylex ()
 @end group  @end group
 @group  @group
 @c      /* Initially make the buffer long enough  
 @c         for a 40-character symbol name.  */  
       /* バッファの長さの初期値は40文字       */        /* バッファの長さの初期値は40文字       */
       if (length == 0)        if (length == 0)
         length = 40, symbuf = (char *)malloc (length + 1);          length = 40, symbuf = (char *)malloc (length + 1);
Line 3397  yylex () Line 2318  yylex ()
 @end group  @end group
 @group  @group
         @{          @{
 @c          /* If buffer is full, make it bigger.        */  
           /* あふれたのでバッファを大きくする */            /* あふれたのでバッファを大きくする */
           if (i == length)            if (i == length)
             @{              @{
               length *= 2;                length *= 2;
               symbuf = (char *)realloc (symbuf, length + 1);                symbuf = (char *)realloc (symbuf, length + 1);
             @}              @}
 @c          /* Add this character to the buffer.         */  
           /* 文字をバッファに変える           */            /* 文字をバッファに変える           */
           symbuf[i++] = c;            symbuf[i++] = c;
 @c          /* Get another character.                    */  
           /* 次の文字を読む                   */            /* 次の文字を読む                   */
           c = getchar ();            c = getchar ();
         @}          @}
Line 3427  yylex () Line 2345  yylex ()
       return s->type;        return s->type;
     @}      @}
 @c  /* Any other character is a token by itself.        */  
   /* その他の文字は文字リテラルトークン       */    /* その他の文字は文字リテラルトークン       */
   return c;    return c;
 @}  @}
 @end group  @end group
 @end smallexample  @end smallexample
 @c This program is both powerful and flexible. You may easily add new  
 @c functions, and it is a simple job to modify this code to install predefined  
 @c variables such as @code{pi} or @code{e} as well.  
 このプログラムは、強力かつ柔軟です。  このプログラムは、強力かつ柔軟です。
 新しい関数の追加は簡単です。  新しい関数の追加は簡単です。
 @code{pi}や@code{e}のようにあらかじめ定義された変数を追加するために  @code{pi}や@code{e}のようにあらかじめ定義された変数を追加するために
 プログラムを変更することは、簡単な仕事でしょう。  プログラムを変更することは、簡単な仕事でしょう。
 @c =====================================================================  
 @node Exercises,  , Multi-function Calc, Examples  @node Exercises,  , Multi-function Calc, Examples
 @c @section Exercises  
 @section 練習問題  @section 練習問題
 @cindex exercises  @cindex exercises
 @cindex 練習問題  @cindex 練習問題
 @enumerate  @enumerate
 @item  @item
 @c Add some new functions from @file{math.h} to the initialization list.  
 @file{math.h}にある関数のいくつかを、初期化リストに追加しなさい。  @file{math.h}にある関数のいくつかを、初期化リストに追加しなさい。
 @item  @item
 @c Add another array that contains constants and their values.  Then  
 @c modify @code{init_table} to add these constants to the symbol table.  
 @c It will be easiest to give the constants type @code{VAR}.  
 定数の名前と値を記憶する別の配列を追加しなさい。  定数の名前と値を記憶する別の配列を追加しなさい。
 そして、@code{init_table}を変更し、定数を記号表に追加しなさい。  そして、@code{init_table}を変更し、定数を記号表に追加しなさい。
 定数に型@code{VAR}を与えれば簡単でしょう。  定数に型@code{VAR}を与えれば簡単でしょう。
 @item  @item
 @c Make the program report an error if the user refers to an  
 @c uninitialized variable in any way except to store a value in it.  
 初期化されていない変数について、値を書き込むのではなく、  初期化されていない変数について、値を書き込むのではなく、
 値を使おうとするとエラーを報告するように、プログラムを改良しなさい。  値を使おうとするとエラーを報告するように、プログラムを改良しなさい。
 @end enumerate  @end enumerate
 @c =====================================================================  
 @node Grammar File, Interface, Examples, Top  @node Grammar File, Interface, Examples, Top
 @c @chapter Bison Grammar Files  
 @chapter Bison文法ファイル  @chapter Bison文法ファイル
 @c Bison takes as input a context-free grammar specification and produces a  
 @c C-language function that recognizes correct instances of the grammar.  
 Bisonは、文脈自由文法の仕様を入力として受け取り、  Bisonは、文脈自由文法の仕様を入力として受け取り、
 その文法の正しいインスタンスを認識する、  その文法の正しいインスタンスを認識する、
 C言語の関数を生成します。  C言語の関数を生成します。
 @c The Bison grammar input file conventionally has a name ending in @samp{.y}.  
 Bison文法ファイルの名前は、通常@samp{.y}で終わります。  Bison文法ファイルの名前は、通常@samp{.y}で終わります。
 @menu  @menu
Line 3503  Bison文法ファイルの名前は、通常@samp{.y} Line 2398  Bison文法ファイルの名前は、通常@samp{.y}
 @end menu  @end menu
 @c =====================================================================  
 @node Grammar Outline, Symbols,  , Grammar File  @node Grammar Outline, Symbols,  , Grammar File
 @c @section Outline of a Bison Grammar  
 @section Bison文法の概要  @section Bison文法の概要
 @c A Bison grammar file has four main sections, shown here with the  
 @c appropriate delimiters:  
 Bison文法ファイルは4つの主要な部分からなります。  Bison文法ファイルは4つの主要な部分からなります。
 それらを、適切な区切り文字とともに示します。  それらを、適切な区切り文字とともに示します。
 @example  @example
 %@{  %@{
 @c @var{C declarations}  
 @var{C宣言部(C declarations)}  @var{C宣言部(C declarations)}
 %@}  %@}
 @c @var{Bison declarations}  
 @var{Bison宣言部(Bison declarations)}  @var{Bison宣言部(Bison declarations)}
 %%  %%
 @c @var{Grammar rules}  
 @var{文法規則部(Grammar rules)}  @var{文法規則部(Grammar rules)}
 %%  %%
 @c @var{Additional C code}  
 @var{追加のCプログラム部(Additional C code)}  @var{追加のCプログラム部(Additional C code)}
 @end example  @end example
 @c Comments enclosed in @samp{/* @dots{} */} may appear in any of the sections.  
 @samp{/* @dots{} */}で囲まれたコメントは、どの部分にも書けます。  @samp{/* @dots{} */}で囲まれたコメントは、どの部分にも書けます。
Line 3544  Bison文法ファイルは4つの主要な部分からな Line 2430  Bison文法ファイルは4つの主要な部分からな
 @end menu  @end menu
 @c =====================================================================  
 @node C Declarations, Bison Declarations,  , Grammar Outline  @node C Declarations, Bison Declarations,  , Grammar Outline
 @c @subsection The C Declarations Section  
 @subsection C宣言部  @subsection C宣言部
 @cindex C declarations section  @cindex C declarations section
 @cindex declarations, C  @cindex declarations, C
 @cindex C宣言部  @cindex C宣言部
 @cindex 宣言, C  @cindex 宣言, C
 @c The @var{C declarations} section contains macro definitions and  
 @c declarations of functions and variables that are used in the actions in the  
 @c grammar rules.  These are copied to the beginning of the parser file so  
 @c that they precede the definition of @code{yyparse}.  You can use  
 @c @samp{#include} to get the declarations from a header file.  If you don't  
 @c need any C declarations, you may omit the @samp{%@{} and @samp{%@}}  
 @c delimiters that bracket this section.  
 @dfn{C宣言部(C declarations)}には、マクロ定義と、文法定義のアクションで  @dfn{C宣言部(C declarations)}には、マクロ定義と、文法定義のアクションで
 使うための関数と変数の宣言があります。  使うための関数と変数の宣言があります。
Line 3570  C宣言がまったく必要ない場合は、この部分 Line 2447  C宣言がまったく必要ない場合は、この部分
 @samp{%@{}と@samp{%@}}を省略できます。  @samp{%@{}と@samp{%@}}を省略できます。
 @c =====================================================================  
 @node Bison Declarations, Grammar Rules, C Declarations, Grammar Outline  @node Bison Declarations, Grammar Rules, C Declarations, Grammar Outline
 @c @subsection The Bison Declarations Section  
 @subsection Bison宣言部  @subsection Bison宣言部
 @cindex Bison declarations (introduction)  @cindex Bison declarations (introduction)
 @cindex declarations, Bison (introduction)  @cindex declarations, Bison (introduction)
 @cindex Bison宣言(導入)  @cindex Bison宣言(導入)
 @cindex 宣言, Bison(導入)  @cindex 宣言, Bison(導入)
 @c The @var{Bison declarations} section contains declarations that define  
 @c terminal and nonterminal symbols, specify precedence, and so on.  
 @c In some simple grammars you may not need any declarations.  
 @c @xref{Declarations, ,Bison Declarations}.  
 @dfn{Bison宣言部(Bison declarations)}は、終端記号と非終端記号の宣言、  @dfn{Bison宣言部(Bison declarations)}は、終端記号と非終端記号の宣言、
 演算子の優先順位の指定などを含みます。  演算子の優先順位の指定などを含みます。
 単純な例では、宣言を省略できます。  単純な例では、宣言を省略できます。
 @xref{Declarations, ,Bison Declarations}。  @xref{Declarations, ,Bison Declarations}。
 @c =====================================================================  
 @node Grammar Rules, C Code, Bison Declarations, Grammar Outline  @node Grammar Rules, C Code, Bison Declarations, Grammar Outline
 @c @subsection The Grammar Rules Section  
 @subsection 文法規則部  @subsection 文法規則部
 @cindex grammar rules section  @cindex grammar rules section
 @cindex rules section for grammar  @cindex rules section for grammar
 @cindex 文法規則部  @cindex 文法規則部
 @cindex 規則部,文法に対する  @cindex 規則部,文法に対する
 @c The @dfn{grammar rules} section contains one or more Bison grammar  
 @c rules, and nothing else.  @xref{Rules, ,Syntax of Grammar Rules}.  
 @dfn{文法規則部(grammar rules)}は、1つ以上のBison文法規則を含み、  @dfn{文法規則部(grammar rules)}は、1つ以上のBison文法規則を含み、
 それ以外は含みません。  それ以外は含みません。
 @xref{Rules, ,Syntax of Grammar Rules}。  @xref{Rules, ,Syntax of Grammar Rules}。
 @c There must always be at least one grammar rule, and the first  
 @c @samp{%%} (which precedes the grammar rules) may never be omitted even  
 @c if it is the first thing in the file.  
 少なくとも1つの文法規則が存在する必要があります。  少なくとも1つの文法規則が存在する必要があります。
 また、文法規則より先に@samp{%%}が必要で、  また、文法規則より先に@samp{%%}が必要で、
 もしそれ以前に何も記述されていなくても、省略できません。  もしそれ以前に何も記述されていなくても、省略できません。
 @c =====================================================================  
 @node C Code,  , Grammar Rules, Grammar Outline  @node C Code,  , Grammar Rules, Grammar Outline
 @c @subsection The Additional C Code Section  
 @subsection 追加のCプログラム部  @subsection 追加のCプログラム部
 @cindex additional C code section  @cindex additional C code section
 @cindex C code, section for additional  @cindex C code, section for additional
 @cindex 追加のCプログラム部  @cindex 追加のCプログラム部
 @cindex Cプログラム, 追加の  @cindex Cプログラム, 追加の
 @c The @var{additional C code} section is copied verbatim to the end of  
 @c the parser file, just as the @var{C declarations} section is copied to  
 @c the beginning.  This is the most convenient place to put anything  
 @c that you want to have in the parser file but which need not come before  
 @c the definition of @code{yyparse}.  For example, the definitions of  
 @c @code{yylex} and @code{yyerror} often go here.  
 @c @xref{Interface, ,Parser C-Language Interface}.  
 @dfn{追加のCプログラム部(additional C code)}は、@dfn{C宣言部}が構文解析器ファイルの先頭に複写  @dfn{追加のCプログラム部(additional C code)}は、@dfn{C宣言部}が構文解析器ファイルの先頭に複写
 されるのと同じように、構文解析器ファイルの末尾にそのまま複写されます。  されるのと同じように、構文解析器ファイルの末尾にそのまま複写されます。
 構文解析器ファイル中に置く必要があって、  構文解析器ファイル中に置く必要があって、
Line 3640  C宣言がまったく必要ない場合は、この部分 Line 2491  C宣言がまったく必要ない場合は、この部分
 よくここに置かれます。  よくここに置かれます。
 @xref{Interface, ,Parser C-Language Interface}。  @xref{Interface, ,Parser C-Language Interface}。
 @c If the last section is empty, you may omit the @samp{%%} that separates it  
 @c from the grammar rules.  
 もし直前の部が空ならば、文法規則と区別するための  もし直前の部が空ならば、文法規則と区別するための
 @samp{%%}を省略できます。  @samp{%%}を省略できます。
 @c The Bison parser itself contains many static variables whose names start  
 @c with @samp{yy} and many macros whose names start with @samp{YY}.  It is a  
 @c good idea to avoid using any such names (except those documented in this  
 @c manual) in the additional C code section of the grammar file.  
 Bison構文解析器は、名前が@samp{yy}で始まる多くの静的変数と、  Bison構文解析器は、名前が@samp{yy}で始まる多くの静的変数と、
 名前が@samp{YY}で始まる多くのマクロを含んでいます。  名前が@samp{YY}で始まる多くのマクロを含んでいます。
 本書で解説しているものを意図的に使う場合を除いて、  本書で解説しているものを意図的に使う場合を除いて、
 そのような名前を文法ファイルの追加のCプログラム部で使うのは避けるべきです。  そのような名前を文法ファイルの追加のCプログラム部で使うのは避けるべきです。
 @c =====================================================================  
 @node Symbols, Rules, Grammar Outline, Grammar File  @node Symbols, Rules, Grammar Outline, Grammar File
 @c @section Symbols, Terminal and Nonterminal  
 @section 記号、終端と非終端  @section 記号、終端と非終端
 @cindex nonterminal symbol  @cindex nonterminal symbol
 @cindex terminal symbol  @cindex terminal symbol
Line 3670  Bison構文解析器は、名前が@samp{yy}で始ま Line 2511  Bison構文解析器は、名前が@samp{yy}で始ま
 @cindex トークン型  @cindex トークン型
 @cindex 記号  @cindex 記号
 @c @dfn{Symbols} in Bison grammars represent the grammatical classifications  
 @c of the language.  
 Bison文法の@dfn{記号(symbols)}は、  Bison文法の@dfn{記号(symbols)}は、
 言語の文法的分類を表現します。  言語の文法的分類を表現します。
 @c A @dfn{terminal symbol} (also known as a @dfn{token type}) represents a  
 @c class of syntactically equivalent tokens.  You use the symbol in grammar  
 @c rules to mean that a token in that class is allowed.  The symbol is  
 @c represented in the Bison parser by a numeric code, and the @code{yylex}  
 @c function returns a token type code to indicate what kind of token has been  
 @c read.  You don't need to know what the code value is; you can use the  
 @c symbol to stand for it.  
 @dfn{終端記号(terminal symbol)}  @dfn{終端記号(terminal symbol)}
 (@dfn{トークン型(tokens types)}ともいいます)は、  (@dfn{トークン型(tokens types)}ともいいます)は、
 構文的に等価なトークンのクラスを表します。  構文的に等価なトークンのクラスを表します。
Line 3694  Bison文法の@dfn{記号(symbols)}は、 Line 2524  Bison文法の@dfn{記号(symbols)}は、
 トークン番号を返します。  トークン番号を返します。
 これを表す記号を知っていればよく、その番号を知っている必要はありません。  これを表す記号を知っていればよく、その番号を知っている必要はありません。
 @c A @dfn{nonterminal symbol} stands for a class of syntactically equivalent  
 @c groupings.  The symbol name is used in writing grammar rules.  
 @c By convention, it should be all lower case.  
 @dfn{非終端記号(nonterminal symbol)}は、  @dfn{非終端記号(nonterminal symbol)}は、
 構文的に等価なグループを表現します。  構文的に等価なグループを表現します。
 記号名は文法規則の記述に使われます。  記号名は文法規則の記述に使われます。
 通常、非終端記号名を小文字で書きます。  通常、非終端記号名を小文字で書きます。
 @c Symbol names can contain letters, digits (not at the beginning),  
 @c underscores and periods.  Periods make sense only in nonterminals.  
 記号名は、英字、先頭以外での数字、下線記号(@samp{_})とピリオドからなります。  記号名は、英字、先頭以外での数字、下線記号(@samp{_})とピリオドからなります。
 ピリオド記号(@samp{.})は、非終端記号の名前には使えますが、  ピリオド記号(@samp{.})は、非終端記号の名前には使えますが、
 終端記号の名前には使えません。  終端記号の名前には使えません。
 @c There are three ways of writing terminal symbols in the grammar:  
 文法中で終端記号を記述するには3種類の方法があります。  文法中で終端記号を記述するには3種類の方法があります。
 @itemize @bullet  @itemize @bullet
 @item  @item
 @c A @dfn{named token type} is written with an identifier, like an  
 @c identifier in C.  By convention, it should be all upper case.  Each  
 @c such name must be defined with a Bison declaration such as  
 @c @code{%token}.  @xref{Token Decl, ,Token Type Names}.  
 @dfn{名前付きトークン型(named token type)}を、  @dfn{名前付きトークン型(named token type)}を、
 C言語における識別子と同様な、識別子とともに書きます。  C言語における識別子と同様な、識別子とともに書きます。
 通常、大文字で書きます。  通常、大文字で書きます。
Line 3734  C言語における識別子と同様な、識別子とと Line 2550  C言語における識別子と同様な、識別子とと
 @cindex 文字トークン  @cindex 文字トークン
 @cindex リテラルトークン  @cindex リテラルトークン
 @cindex 1文字リテラル  @cindex 1文字リテラル
 @c A @dfn{character token type} (or @dfn{literal character token}) is  
 @c written in the grammar using the same syntax used in C for character  
 @c constants; for example, @code{'+'} is a character token type.  A  
 @c character token type doesn't need to be declared unless you need to  
 @c specify its semantic value data type (@pxref{Value Type, ,Data Types of  
 @c Semantic Values}), associativity, or precedence (@pxref{Precedence,  
 @c ,Operator Precedence}).  
 @dfn{文字トークン型(character token type)}、  @dfn{文字トークン型(character token type)}、
 すなわち@dfn{リテラル文字トークン(literal character token)}は、  すなわち@dfn{リテラル文字トークン(literal character token)}は、
 C言語の文字定数と同じ構文で書かれ、  C言語の文字定数と同じ構文で書かれ、
Line 3751  C言語の文字定数と同じ構文で書かれ、 Line 2559  C言語の文字定数と同じ構文で書かれ、
 指定する必要がなければ、  指定する必要がなければ、
 文字トークン型を宣言する必要はありません。  文字トークン型を宣言する必要はありません。
 @c By convention, a character token type is used only to represent a  
 @c token that consists of that particular character.  Thus, the token  
 @c type @code{'+'} is used to represent the character @samp{+} as a  
 @c token.  Nothing enforces this convention, but if you depart from it,  
 @c your program will confuse other readers.  
 通常、文字トークン型は、特別な文字@footnote{【訳注】英数字以外の文字。}から  通常、文字トークン型は、特別な文字@footnote{【訳注】英数字以外の文字。}から
 なるトークンを表すためだけに使います。  なるトークンを表すためだけに使います。
 たとえば、トークン型@code{'+'}を、  たとえば、トークン型@code{'+'}を、
Line 3764  C言語の文字定数と同じ構文で書かれ、 Line 2566  C言語の文字定数と同じ構文で書かれ、
 このようにする義務はありませんが、そうしないと、  このようにする義務はありませんが、そうしないと、
 あなたが書いたプログラムを読む人が混乱するでしょう。  あなたが書いたプログラムを読む人が混乱するでしょう。
 @c All the usual escape sequences used in character literals in C can be  
 @c used in Bison as well, but you must not use the null character as a  
 @c character literal because its ASCII code, zero, is the code @code{yylex}  
 @c returns for end-of-input (@pxref{Calling Convention, ,Calling Convention  
 @c for @code{yylex}}).  
 C言語の文字リテラルで使われる通常のエスケープシーケンス  C言語の文字リテラルで使われる通常のエスケープシーケンス
 @footnote{【訳注】@samp{\}に続く表現。}を、Bisonでも使えます。  @footnote{【訳注】@samp{\}に続く表現。}を、Bisonでも使えます。
 しかし、@code{'\0'}だけはASCII符号の0を表し、  しかし、@code{'\0'}だけはASCII符号の0を表し、
Line 3784  C言語の文字リテラルで使われる通常のエス Line 2580  C言語の文字リテラルで使われる通常のエス
 @cindex 文字列トークン  @cindex 文字列トークン
 @cindex リテラル文字列トークン  @cindex リテラル文字列トークン
 @cindex 複数文字リテラル  @cindex 複数文字リテラル
 @c A @dfn{literal string token} is written like a C string constant; for  
 @c example, @code{"<="} is a literal string token.  A literal string token  
 @c doesn't need to be declared unless you need to specify its semantic  
 @c value data type (@pxref{Value Type}), associativity, precedence  
 @c (@pxref{Precedence}).  
 @dfn{リテラル文字列トークン(literal string token)}は、  @dfn{リテラル文字列トークン(literal string token)}は、
 C言語における文字列定数と同様に書きます。  C言語における文字列定数と同様に書きます。
 たとえば、@code{"<="}がリテラル文字列トークンです。  たとえば、@code{"<="}がリテラル文字列トークンです。
Line 3798  C言語における文字列定数と同様に書きます Line 2588  C言語における文字列定数と同様に書きます
 指定する必要がなければ、  指定する必要がなければ、
 リテラル文字列トークンを宣言する必要はありません。  リテラル文字列トークンを宣言する必要はありません。
 @c You can associate the literal string token with a symbolic name as an  
 @c alias, using the @code{%token} declaration (@pxref{Token Decl, ,Token  
 @c Declarations}).  If you don't do that, the lexical analyzer has to  
 @c retrieve the token number for the literal string token from the  
 @c @code{yytname} table (@pxref{Calling Convention}).  
 @code{%token}宣言(@pxref{Token Decl, ,Token Declarations})を使って、  @code{%token}宣言(@pxref{Token Decl, ,Token Declarations})を使って、
 リテラル文字列トークンを、記号名の別名として関連づけられます。  リテラル文字列トークンを、記号名の別名として関連づけられます。
 そうしないと、字句解析器は、  そうしないと、字句解析器は、
 @code{yytname}表(@pxref{Calling Convention})を使って、  @code{yytname}表(@pxref{Calling Convention})を使って、
 リテラル文字列トークンからトークン番号を検索する必要があります。  リテラル文字列トークンからトークン番号を検索する必要があります。
 @c @strong{WARNING}: literal string tokens do not work in Yacc.  
 @strong{【警告】}@code{yacc}ではリテラル文字列トークンを使えません。  @strong{【警告】}@code{yacc}ではリテラル文字列トークンを使えません。
 @c By convention, a literal string token is used only to represent a token  
 @c that consists of that particular string.  Thus, you should use the token  
 @c type @code{"<="} to represent the string @samp{<=} as a token.  Bison  
 @c does not enforces this convention, but if you depart from it, people who  
 @c read your program will be confused.  
 通常、特殊文字の列からなるトークンの表現にのみ、  通常、特殊文字の列からなるトークンの表現にのみ、
 リテラル文字列トークンを使います。  リテラル文字列トークンを使います。
 たとえば、トークンとしての@samp{<=}を表すために、  たとえば、トークンとしての@samp{<=}を表すために、
Line 3827  C言語における文字列定数と同様に書きます Line 2603  C言語における文字列定数と同様に書きます
 そうする義務はありませんが、そうしないと、  そうする義務はありませんが、そうしないと、
 あなたが書いたプログラムを読む人が混乱するでしょう。  あなたが書いたプログラムを読む人が混乱するでしょう。
 @c All the escape sequences used in string literals in C can be used in  
 @c Bison as well.  A literal string token must contain two or more  
 @c characters; for a token containing just one character, use a character  
 @c token (see above).  
 C言語で使えるエスケープシーケンスはすべてBisonでも使えます。  C言語で使えるエスケープシーケンスはすべてBisonでも使えます。
 リテラル文字列トークンは、2文字以上からなります。  リテラル文字列トークンは、2文字以上からなります。
 もし、トークンが1文字ならば、前述の1文字トークンを使ってください。  もし、トークンが1文字ならば、前述の1文字トークンを使ってください。
 @end itemize  @end itemize
 @c How you choose to write a terminal symbol has no effect on its  
 @c grammatical meaning.  That depends only on where it appears in rules and  
 @c on when the parser function returns that symbol.  
 終端記号を書く方法は、終端記号の文法的意味に関係なく、  終端記号を書く方法は、終端記号の文法的意味に関係なく、
 規則の中に現れる位置と、  規則の中に現れる位置と、
 構文解析器関数が記号を返す方法に関係します。  構文解析器関数が記号を返す方法に関係します。
 @c The value returned by @code{yylex} is always one of the terminal symbols  
 @c (or 0 for end-of-input).  Whichever way you write the token type in the  
 @c grammar rules, you write it the same way in the definition of @code{yylex}.  
 @c The numeric code for a character token type is simply the ASCII code for  
 @c the character, so @code{yylex} can use the identical character constant to  
 @c generate the requisite code.  Each named token type becomes a C macro in  
 @c the parser file, so @code{yylex} can use the name to stand for the code.  
 @c (This is why periods don't make sense in terminal symbols.)    
 @c @xref{Calling Convention, ,Calling Convention for @code{yylex}}.  
 @code{yylex}が返す値は、終端記号のどれかを表し、  @code{yylex}が返す値は、終端記号のどれかを表し、
 入力の終わりでは0です。  入力の終わりでは0です。
 文法規則の中でどの方法でトークン型を書いても、  文法規則の中でどの方法でトークン型を書いても、
Line 3867  C言語で使えるエスケープシーケンスはすべ Line 2624  C言語で使えるエスケープシーケンスはすべ
 これが、終端記号の名前にピリオド記号を使えない理由です。  これが、終端記号の名前にピリオド記号を使えない理由です。
 @xref{Calling Convention, ,Calling Convention for @code{yylex}}。  @xref{Calling Convention, ,Calling Convention for @code{yylex}}。
 @c If @code{yylex} is defined in a separate file, you need to arrange for the  
 @c token-type macro definitions to be available there.  Use the @samp{-d}  
 @c option when you run Bison, so that it will write these macro definitions  
 @c into a separate header file @file{@var{name}.tab.h} which you can include  
 @c in the other source files that need it.  @xref{Invocation, ,Invoking Bison}.  
 @code{yylex}が構文解析器と別のソースファイルの中に書かれる場合には、  @code{yylex}が構文解析器と別のソースファイルの中に書かれる場合には、
 そこでトークン型マクロ定義を使えるように準備する必要があります。  そこでトークン型マクロ定義を使えるように準備する必要があります。
 @samp{-d}オプションを付けてBisonを実行してください。  @samp{-d}オプションを付けてBisonを実行してください。
Line 3880  C言語で使えるエスケープシーケンスはすべ Line 2631  C言語で使えるエスケープシーケンスはすべ
 必要に応じて別のソースファイルからインクルードできます。  必要に応じて別のソースファイルからインクルードできます。
 @xref{Invocation, ,Invoking Bison}。  @xref{Invocation, ,Invoking Bison}。
 @c The symbol @code{error} is a terminal symbol reserved for error recovery  
 @c (@pxref{Error Recovery}); you shouldn't use it for any other purpose.  
 @c In particular, @code{yylex} should never return this value.  
 記号@code{error}は、エラー回復用に予約された終端記号(@pxref{Error Recovery})  記号@code{error}は、エラー回復用に予約された終端記号(@pxref{Error Recovery})
 で、他の目的に使うべきではありません。  で、他の目的に使うべきではありません。
 実際に、@code{yylex}がこの値を返すことは決してありません。  実際に、@code{yylex}がこの値を返すことは決してありません。
 @c =====================================================================  
 @node Rules, Recursion, Symbols, Grammar File  @node Rules, Recursion, Symbols, Grammar File
 @c @section Syntax of Grammar Rules  
 @section 文法規則の構文  @section 文法規則の構文
 @cindex rule syntax  @cindex rule syntax
 @cindex grammar rule syntax  @cindex grammar rule syntax
Line 3900  C言語で使えるエスケープシーケンスはすべ Line 2645  C言語で使えるエスケープシーケンスはすべ
 @cindex 文法規則の構文  @cindex 文法規則の構文
 @cindex 構文, 文法規則  @cindex 構文, 文法規則
 @c A Bison grammar rule has the following general form:  
 Bison文法規則は、一般的に次の書式です。  Bison文法規則は、一般的に次の書式です。
 @example  @example
Line 3911  Bison文法規則は、一般的に次の書式です。 Line 2654  Bison文法規則は、一般的に次の書式です。
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c where @var{result} is the nonterminal symbol that this rule describes  
 @c and @var{components} are various terminal and nonterminal symbols that  
 @c are put together by this rule (@pxref{Symbols}).    
 @c For example,  
 @var{result}は、この規則が記述する非終端記号で、  @var{result}は、この規則が記述する非終端記号で、
 @var{components}は、この規則で一緒に置かれるさまざまな  @var{components}は、この規則で一緒に置かれるさまざまな
 終端および非終端記号です。  終端および非終端記号です。
Line 3930  exp:      exp '+' exp Line 2666  exp:      exp '+' exp
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c says that two groupings of type @code{exp},  
 @c with a @samp{+} token in between,  
 @c can be combined into a larger grouping of type @code{exp}.  
 この例では、@samp{+}トークンを間にはさんで  この例では、@samp{+}トークンを間にはさんで
 型@code{exp}の2つのグループ化が行われ、  型@code{exp}の2つのグループ化が行われ、
 型@code{exp}のより大きなグループができます。  型@code{exp}のより大きなグループができます。
 @c Whitespace in rules is significant only to separate symbols.  You can add  
 @c extra whitespace as you wish.  
 規則の中の空白@footnote{【訳注】任意の数の空白文字、タブ符号、改行符号。}は、  規則の中の空白@footnote{【訳注】任意の数の空白文字、タブ符号、改行符号。}は、
 記号を分けるだけの意味を持ちます。  記号を分けるだけの意味を持ちます。
 必要に応じて、余分な空白を書いてもかまいません。  必要に応じて、余分な空白を書いてもかまいません。
 @c Scattered among the components can be @var{actions} that determine  
 @c the semantics of the rule.  An action looks like this:  
 @var{components}の周辺にあるものは、  @var{components}の周辺にあるものは、
 規則の意味を決定する@var{アクション(action)}になることができます。  規則の意味を決定する@var{アクション(action)}になることができます。
 アクションは、次のようになります。  アクションは、次のようになります。
Line 3957  exp:      exp '+' exp Line 2682  exp:      exp '+' exp
 @{@var{C statements}@}  @{@var{C statements}@}
 @end example  @end example
 @c @noindent  
 @c Usually there is only one action and it follows the components.  
 @c @xref{Actions}.  
 通常、1つだけのアクションと、それに続く@var{components}があります。  通常、1つだけのアクションと、それに続く@var{components}があります。
 @xref{Actions}。  @xref{Actions}。
 @findex |  @findex |
 @c Multiple rules for the same @var{result} can be written separately or can  
 @c be joined with the vertical-bar character @samp{|} as follows:  
 同一の@var{result}に対する複数の規則は、  同一の@var{result}に対する複数の規則は、
 別々に書くこともできますし、  別々に書くこともできますし、
 次の例のように縦線記号@samp{|}で区切ってまとめて書くことも可能です。  次の例のように縦線記号@samp{|}で区切ってまとめて書くことも可能です。
Line 3991  exp:      exp '+' exp Line 2709  exp:      exp '+' exp
 @end example  @end example
 @end iftex  @end iftex
 @c @noindent  
 @c They are still considered distinct rules even when joined in this way.  
 まとめて書いても、それぞれの規則は別々のものとみなされます。  まとめて書いても、それぞれの規則は別々のものとみなされます。
 @c If @var{components} in a rule is empty, it means that @var{result} can  
 @c match the empty string.  For example, here is how to define a  
 @c comma-separated sequence of zero or more @code{exp} groupings:  
 もし、規則中の@var{components}が空ならば、  もし、規則中の@var{components}が空ならば、
 @var{result}が空の列にマッチできることを意味します。  @var{result}が空の列にマッチできることを意味します。
 例として、カンマで区切られた0個以上の@code{exp}のグループを  例として、カンマで区切られた0個以上の@code{exp}のグループを
Line 4007  exp:      exp '+' exp Line 2718  exp:      exp '+' exp
 @example  @example
 @group  @group
 @c expseq:   /* empty */  
 expseq:   /* 空 */  expseq:   /* 空 */
         | expseq1          | expseq1
         ;          ;
Line 4020  expseq1:  exp Line 2730  expseq1:  exp
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c It is customary to write a comment @samp{/* empty */} in each rule  
 @c with no components.  
 空の@var{component}を持つ規則には、通常  空の@var{component}を持つ規則には、通常
 @samp{/* 空 */}という注釈を書きます。  @samp{/* 空 */}という注釈を書きます。
 @c =====================================================================  
 @node Recursion, Semantics, Rules, Grammar File  @node Recursion, Semantics, Rules, Grammar File
 @c @section Recursive Rules  
 @section 再帰的規則  @section 再帰的規則
 @cindex recursive rule  @cindex recursive rule
 @cindex 再帰的規則  @cindex 再帰的規則
 @c A rule is called @dfn{recursive} when its @var{result} nonterminal appears  
 @c also on its right hand side.  Nearly all Bison grammars need to use  
 @c recursion, because that is the only way to define a sequence of any number  
 @c of somethings.  Consider this recursive definition of a comma-separated  
 @c sequence of one or more expressions:  
 @var{result}である非終端記号が規則の右側にも現れる場合に、  @var{result}である非終端記号が規則の右側にも現れる場合に、
 その規則は@dfn{再帰的(recursive)}であるといいます。  その規則は@dfn{再帰的(recursive)}であるといいます。
 Bison文法の大部分は再帰的規則を使います。  Bison文法の大部分は再帰的規則を使います。
Line 4061  expseq1:  exp Line 2759  expseq1:  exp
 @cindex 左再帰  @cindex 左再帰
 @cindex 右再帰  @cindex 右再帰
 @c @noindent  
 @c Since the recursive use of @code{expseq1} is the leftmost symbol in the  
 @c right hand side, we call this @dfn{left recursion}.  By contrast, here  
 @c the same construct is defined using @dfn{right recursion}:  
 @code{expseq1}で使われている再帰は、規則の右側の中でもっとも左側にあるので、  @code{expseq1}で使われている再帰は、規則の右側の中でもっとも左側にあるので、
 このような再帰を@dfn{左再帰(left recursion)}と呼びます。  このような再帰を@dfn{左再帰(left recursion)}と呼びます。
 逆に、同じ構造を@dfn{右再帰(right recursion)}を使って書いてみます。  逆に、同じ構造を@dfn{右再帰(right recursion)}を使って書いてみます。
Line 4078  expseq1:  exp Line 2771  expseq1:  exp
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c Any kind of sequence can be defined using either left recursion or  
 @c right recursion, but you should always use left recursion, because it  
 @c can parse a sequence of any number of elements with bounded stack  
 @c space.  Right recursion uses up space on the Bison stack in proportion  
 @c to the number of elements in the sequence, because all the elements  
 @c must be shifted onto the stack before the rule can be applied even  
 @c once.  @xref{Algorithm, ,The Bison Parser Algorithm }, for  
 @c further explanation of this.  
 あらゆる並びを、左再帰を使っても、右再帰を使っても、定義できます。  あらゆる並びを、左再帰を使っても、右再帰を使っても、定義できます。
 しかし、限られたスタック容量で任意の数の並びを走査できるので、  しかし、限られたスタック容量で任意の数の並びを走査できるので、
 つねに左再帰を使うべきです。  つねに左再帰を使うべきです。
Line 4098  expseq1:  exp Line 2781  expseq1:  exp
 @cindex mutual recursion  @cindex mutual recursion
 @cindex 相互再帰  @cindex 相互再帰
 @c @dfn{Indirect} or @dfn{mutual} recursion occurs when the result of the  
 @c rule does not appear directly on its right hand side, but does appear  
 @c in rules for other nonterminals which do appear on its right hand  
 @c side.    
 規則の結果が直接その右側には含まれず、  規則の結果が直接その右側には含まれず、
 右側にある非終端記号の中に含まれるとき、  右側にある非終端記号の中に含まれるとき、
 @dfn{間接(indirect)}すなわち@dfn{相互(mutual)}再帰が起きます。  @dfn{間接(indirect)}すなわち@dfn{相互(mutual)}再帰が起きます。
 @c For example:  
 例を示します。  例を示します。
 @example  @example
Line 4125  primary:  constant Line 2801  primary:  constant
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c defines two mutually-recursive nonterminals, since each refers to the  
 @c other.  
 この例では、それぞれの規則が互いに参照しているので、  この例では、それぞれの規則が互いに参照しているので、
 2個の相互再帰が定義されています。  2個の相互再帰が定義されています。
 @c =====================================================================  
 @node Semantics, Declarations, Recursion, Grammar File  @node Semantics, Declarations, Recursion, Grammar File
 @c @section Defining Language Semantics  
 @section 言語の意味の定義  @section 言語の意味の定義
 @cindex defining language semantics  @cindex defining language semantics
 @cindex language semantics, defining   @cindex language semantics, defining 
 @cindex 言語の意味の定義  @cindex 言語の意味の定義
 @cindex 定義, 言語の意味  @cindex 定義, 言語の意味
 @c The grammar rules for a language determine only the syntax.  The semantics  
 @c are determined by the semantic values associated with various tokens and  
 @c groupings, and by the actions taken when various groupings are recognized.  
 言語に対する文法規則は、文法だけを決めます。  言語に対する文法規則は、文法だけを決めます。
 意味は、各種のトークンとグループ化に対応する意味値により、  意味は、各種のトークンとグループ化に対応する意味値により、
 各種のグループ化が認識されるときに、決定されます。  各種のグループ化が認識されるときに、決定されます。
 @c For example, the calculator calculates properly because the value  
 @c associated with each expression is the proper number; it adds properly  
 @c because the action for the grouping @w{@samp{@var{x} + @var{y}}} is to add  
 @c the numbers associated with @var{x} and @var{y}.  
 電卓の例では、式のそれぞれに対応する値が適切な数値なので、  電卓の例では、式のそれぞれに対応する値が適切な数値なので、
 電卓は正確に計算できます。  電卓は正確に計算できます。
 グループ@w{@samp{@var{x} + @var{y}}}に  グループ@w{@samp{@var{x} + @var{y}}}に
Line 4171  primary:  constant Line 2832  primary:  constant
 @end menu  @end menu
 @c =====================================================================  
 @node Value Type, Multiple Types,  , Semantics  @node Value Type, Multiple Types,  , Semantics
 @c @subsection Data Types of Semantic Values  
 @subsection データ型と意味値  @subsection データ型と意味値
 @cindex semantic value type  @cindex semantic value type
 @cindex value type, semantic  @cindex value type, semantic
Line 4184  primary:  constant Line 2843  primary:  constant
 @cindex 意味値のデータ型  @cindex 意味値のデータ型
 @cindex 省略時データ型  @cindex 省略時データ型
 @c In a simple program it may be sufficient to use the same data type for  
 @c the semantic values of all language constructs.  This was true in the  
 @c RPN and infix calculator examples  
 @c (@pxref{RPN Calc, ,Reverse Polish Notation Calculator}).  
 単純なプログラムでは、言語の要素のすべての意味値に対して同じデータ型を  単純なプログラムでは、言語の要素のすべての意味値に対して同じデータ型を
 使えば十分です。  使えば十分です。
 逆ポーランド記法と中間記法電卓の例では、そうでした  逆ポーランド記法と中間記法電卓の例では、そうでした
 (@pxref{RPN Calc, ,Reverse Polish Notation Calculator})。  (@pxref{RPN Calc, ,Reverse Polish Notation Calculator})。
 @c Bison's default is to use type @code{int} for all semantic values.  To  
 @c specify some other type, define @code{YYSTYPE} as a macro, like this:  
 特に指定しないと、Bisonはすべての意味値に対して@code{int}型を使います。  特に指定しないと、Bisonはすべての意味値に対して@code{int}型を使います。
 他の型を使うには、次の例のように、マクロ@code{YYSTYPE}を定義します。  他の型を使うには、次の例のように、マクロ@code{YYSTYPE}を定義します。
Line 4204  primary:  constant Line 2855  primary:  constant
 #define YYSTYPE double  #define YYSTYPE double
 @end example  @end example
 @c @noindent  
 @c This macro definition must go in the C declarations section of the grammar  
 @c file (@pxref{Grammar Outline, ,Outline of a Bison Grammar}).  
 このマクロ定義は、文法ファイルのC宣言部に置く必要があります  このマクロ定義は、文法ファイルのC宣言部に置く必要があります
 (@pxref{Grammar Outline, ,Outline of a Bison Grammar})。  (@pxref{Grammar Outline, ,Outline of a Bison Grammar})。
 @c =====================================================================  
 @node Multiple Types, Actions, Value Type, Semantics  @node Multiple Types, Actions, Value Type, Semantics
 @c @subsection More Than One Value Type  
 @subsection 複数の値型  @subsection 複数の値型
 @c In most programs, you will need different data types for different kinds  
 @c of tokens and groupings.  For example, a numeric constant may need type  
 @c @code{int} or @code{long}, while a string constant needs type @code{char *},  
 @c and an identifier might need a pointer to an entry in the symbol table.  
 多くのプログラムでは、異なる種類のトークンとグループに対して、  多くのプログラムでは、異なる種類のトークンとグループに対して、
 異なるデータ型が必要です。  異なるデータ型が必要です。
 たとえば、数値定数は@code{int}型や@code{long}型を必要とし、  たとえば、数値定数は@code{int}型や@code{long}型を必要とし、
 文字列定数は@code{char *}型を必要とし、  文字列定数は@code{char *}型を必要とし、
 識別子は記号表の項目へのポインタを必要とするでしょう。  識別子は記号表の項目へのポインタを必要とするでしょう。
 @c To use more than one data type for semantic values in one parser, Bison  
 @c requires you to do two things:  
 同一の構文解析器内で、意味値に対して2つ以上のデータ型を使うには、  同一の構文解析器内で、意味値に対して2つ以上のデータ型を使うには、
 次の2項目が必要です。  次の2項目が必要です。
 @itemize @bullet  @itemize @bullet
 @item  @item
 @c Specify the entire collection of possible data types, with the  
 @c @code{%union} Bison declaration  
 @c (@pxref{Union Decl, ,The Collection of Value Types}).  
 Bison宣言の@code{%union}で、考えられるデータ型全体の集合を指定します  Bison宣言の@code{%union}で、考えられるデータ型全体の集合を指定します
 (@pxref{Union Decl, ,The Collection of Value Types})。  (@pxref{Union Decl, ,The Collection of Value Types})。
 @item  @item
 @c Choose one of those types for each symbol (terminal or nonterminal)  
 @c for which semantic values are used.  This is done for tokens with the  
 @c @code{%token} Bison declaration  
 @c (@pxref{Token Decl, ,Token Type Names}) and for groupings  
 @c with the @code{%type} Bison declaration  
 @c (@pxref{Type Decl, ,Nonterminal Symbols}).  
 終端または非終端記号のそれぞれについて、  終端または非終端記号のそれぞれについて、
 その意味値を使うために、上記の型のどれか1つを選びます。  その意味値を使うために、上記の型のどれか1つを選びます。
 トークンに対する型の指定には、Bison宣言の@code{%token}を使います  トークンに対する型の指定には、Bison宣言の@code{%token}を使います
Line 4260  Bison宣言の@code{%union}で、考えられるデ Line 2886  Bison宣言の@code{%union}で、考えられるデ
 @end itemize  @end itemize
 @c =====================================================================  
 @node Actions, Action Types, Multiple Types, Semantics  @node Actions, Action Types, Multiple Types, Semantics
 @c @subsection Actions  
 @subsection アクション  @subsection アクション
 @cindex action  @cindex action
 @cindex アクション  @cindex アクション
 @vindex $$  @vindex $$
 @vindex $@var{n}  @vindex $@var{n}
 @c An action accompanies a syntactic rule and contains C code to be executed  
 @c each time an instance of that rule is recognized.  The task of most actions  
 @c is to compute a semantic value for the grouping built by the rule from the  
 @c semantic values associated with tokens or smaller groupings.  
 文法規則にともなうアクションは、その規則が認識されるたびに実行される  文法規則にともなうアクションは、その規則が認識されるたびに実行される
 Cのプログラムからなります。  Cのプログラムからなります。
 アクションの仕事のほとんどは、関連するトークンまたは小さいグループから  アクションの仕事のほとんどは、関連するトークンまたは小さいグループから
 規則にしたがって構成されるグループの、意味値の計算です。  規則にしたがって構成されるグループの、意味値の計算です。
 @c An action consists of C statements surrounded by braces, much like a  
 @c compound statement in C.  It can be placed at any position in the rule; it  
 @c is executed at that position.  Most rules have just one action at the end  
 @c of the rule, following all the components.  Actions in the middle of a rule  
 @c are tricky and used only for special  
 @c purposes (@pxref{Mid-Rule Actions, ,Actions in Mid-Rule}).  
 アクションは、Cの複文のように、ブレースで囲まれたCの文からなります。  アクションは、Cの複文のように、ブレースで囲まれたCの文からなります。
 アクションは、規則のどの場所にも置け、その場所で実行されます。  アクションは、規則のどの場所にも置け、その場所で実行されます。
 規則のほとんどは、規則の終わりの構成要素の並びの後に、  規則のほとんどは、規則の終わりの構成要素の並びの後に、
Line 4293  Cのプログラムからなります。 Line 2905  Cのプログラムからなります。
 規則の途中に置かれたアクションは、手の込んだ方法で特別な目的に使われます  規則の途中に置かれたアクションは、手の込んだ方法で特別な目的に使われます
 (@pxref{Mid-Rule Actions, ,Actions in Mid-Rule})。  (@pxref{Mid-Rule Actions, ,Actions in Mid-Rule})。
 @c The C code in an action can refer to the semantic values of the components  
 @c matched by the rule with the construct @code{$@var{n}}, which stands for  
 @c the value of the @var{n}th component.  The semantic value for the grouping  
 @c being constructed is @code{$$}.  (Bison translates both of these constructs  
 @c into array element references when it copies the actions into the parser  
 @c file.)  
 アクションの中のCで書かれたプログラムは、  アクションの中のCで書かれたプログラムは、
 規則の第@var{n}番目の要素に対応する意味値を、  規則の第@var{n}番目の要素に対応する意味値を、
 @code{$@var{n}}という書式で参照できます。  @code{$@var{n}}という書式で参照できます。
Line 4308  Cのプログラムからなります。 Line 2913  Cのプログラムからなります。
 アクションが構文解析器ファイルに複写されるときに、Bisonは、  アクションが構文解析器ファイルに複写されるときに、Bisonは、
 上記の構成要素を配列要素への参照に変換します。  上記の構成要素を配列要素への参照に変換します。
 @c Here is a typical example:  
 例を示します。  例を示します。
 @example  @example
Line 4320  exp:    @dots{} Line 2923  exp:    @dots{}
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c This rule constructs an @code{exp} from two smaller @code{exp} groupings  
 @c connected by a plus-sign token.  In the action, @code{$1} and @code{$3}  
 @c refer to the semantic values of the two component @code{exp} groupings,  
 @c which are the first and third symbols on the right hand side of the rule.  
 @c The sum is stored into @code{$$} so that it becomes the semantic value of  
 @c the addition-expression just recognized by the rule.  If there were a  
 @c useful semantic value associated with the @samp{+} token, it could be  
 @c referred to as @code{$2}.@refill  
 この規則は、加算記号で結び付けられた2つの小さい@code{exp}グループから、  この規則は、加算記号で結び付けられた2つの小さい@code{exp}グループから、
 1つの@code{exp}を構成します。  1つの@code{exp}を構成します。
 このアクションの中で、@code{$1}と@code{$3}は、  このアクションの中で、@code{$1}と@code{$3}は、
Line 4343  exp:    @dots{} Line 2936  exp:    @dots{}
 @cindex default action  @cindex default action
 @cindex 省略時アクション  @cindex 省略時アクション
 @c If you don't specify an action for a rule, Bison supplies a default:  
 @c @w{@code{$$ = $1}.}  Thus, the value of the first symbol in the rule becomes  
 @c the value of the whole rule.  Of course, the default rule is valid only  
 @c if the two data types match.  There is no meaningful default action for  
 @c an empty rule; every empty rule must have an explicit action unless the  
 @c rule's value does not matter.  
 規則に対してアクションを指定しなければ、Bisonは、  規則に対してアクションを指定しなければ、Bisonは、
 省略時アクション@w{@code{$$ = $1}}を補います。  省略時アクション@w{@code{$$ = $1}}を補います。
 したがって、規則の最初の記号の値が規則全体の値になります。  したがって、規則の最初の記号の値が規則全体の値になります。
Line 4358  exp:    @dots{} Line 2944  exp:    @dots{}
 すべての空規則は、その規則の値が必要ならば、  すべての空規則は、その規則の値が必要ならば、
 明示的なアクションを持つ必要があります。  明示的なアクションを持つ必要があります。
 @c @code{$@var{n}} with @var{n} zero or negative is allowed for reference  
 @c to tokens and groupings on the stack @emph{before} those that match the  
 @c current rule.  This is a very risky practice, and to use it reliably  
 @c you must be certain of the context in which the rule is applied.  Here  
 @c is a case in which you can use this reliably:  
 @code{$@var{n}}の@var{n}は0または負が許され、  @code{$@var{n}}の@var{n}は0または負が許され、
 現在の規則にマッチする@emph{前に}スタックに積まれていた  現在の規則にマッチする@emph{前に}スタックに積まれていた
 トークンとグループの意味値を参照します。  トークンとグループの意味値を参照します。
Line 4379  foo:      expr bar '+' expr  @{ @dots{}  Line 2959  foo:      expr bar '+' expr  @{ @dots{} 
 @end group  @end group
 @group  @group
 @c bar:      /* empty */  
 bar:      /* 空 */  bar:      /* 空 */
         @{ previous_expr = $0; @}          @{ previous_expr = $0; @}
         ;          ;
 @end group  @end group
 @end example  @end example
 @c As long as @code{bar} is used only in the fashion shown here, @code{$0}  
 @c always refers to the @code{expr} which precedes @code{bar} in the  
 @c definition of @code{foo}.  
 @code{bar}がここに書かれた方法でのみ使われるならば、  @code{bar}がここに書かれた方法でのみ使われるならば、
 @code{foo}の定義の中で@code{bar}より前の  @code{foo}の定義の中で@code{bar}より前の
 @code{expr}の値を@code{$0}が参照します。  @code{expr}の値を@code{$0}が参照します。
 @c =====================================================================  
 @node Action Types, Mid-Rule Actions, Actions, Semantics  @node Action Types, Mid-Rule Actions, Actions, Semantics
 @c @subsection Data Types of Values in Actions  
 @subsection アクション中の値のデータ型  @subsection アクション中の値のデータ型
 @cindex action data types  @cindex action data types
 @cindex data types in actions  @cindex data types in actions
 @cindex アクションのデータ型  @cindex アクションのデータ型
 @cindex データ型, アクション  @cindex データ型, アクション
 @c If you have chosen a single data type for semantic values, the @code{$$}  
 @c and @code{$@var{n}} constructs always have that data type.  
 すべての意味値に対して同一のデータ型を使っているのならば、  すべての意味値に対して同一のデータ型を使っているのならば、
 @code{$$}と@code{$@var{n}}はそのデータ型を持ちます。  @code{$$}と@code{$@var{n}}はそのデータ型を持ちます。
 @c If you have used @code{%union} to specify a variety of data types, then you  
 @c must declare a choice among these types for each terminal or nonterminal  
 @c symbol that can have a semantic value.  Then each time you use @code{$$} or  
 @c @code{$@var{n}}, its data type is determined by which symbol it refers to  
 @c in the rule.  In this example,@refill  
 さまざまなデータ型を指定するために@code{%union}を使っているならば、  さまざまなデータ型を指定するために@code{%union}を使っているならば、
 意味値を持つ終端記号と非終端記号のそれぞれに対して、  意味値を持つ終端記号と非終端記号のそれぞれに対して、
 データ型の中から適切なものを選ぶように宣言する必要があります。  データ型の中から適切なものを選ぶように宣言する必要があります。
Line 4432  exp:    @dots{} Line 2996  exp:    @dots{}
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c @code{$1} and @code{$3} refer to instances of @code{exp}, so they all  
 @c have the data type declared for the nonterminal symbol @code{exp}.  If  
 @c @code{$2} were used, it would have the data type declared for the  
 @c terminal symbol @code{'+'}, whatever that might be.@refill  
 @code{$1}と@code{$3}は@code{exp}という種類の記号を参照するので、  @code{$1}と@code{$3}は@code{exp}という種類の記号を参照するので、
 @code{$1}と@code{$3}は、非終端記号@code{exp}に対して宣言された  @code{$1}と@code{$3}は、非終端記号@code{exp}に対して宣言された
 データ型を持ちます。  データ型を持ちます。
 もし、@code{$2}が使われるならば、どのような型であれ、  もし、@code{$2}が使われるならば、どのような型であれ、
 終端記号@code{+}に対して宣言されたデータ型が使われます。  終端記号@code{+}に対して宣言されたデータ型が使われます。
 @c Alternatively, you can specify the data type when you refer to the value,  
 @c by inserting @samp{<@var{type}>} after the @samp{$} at the beginning of the  
 @c reference.  For example, if you have defined types as shown here:  
 別の方法として、値を参照するときにそのデータ型を指定できます。  別の方法として、値を参照するときにそのデータ型を指定できます。
 そのためには、参照のための@samp{$}記号の後に@samp{<@var{type}>}を  そのためには、参照のための@samp{$}記号の後に@samp{<@var{type}>}を
 挿入します。例を示します。  挿入します。例を示します。
Line 4461  exp:    @dots{} Line 3015  exp:    @dots{}
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c then you can write @code{$<itype>1} to refer to the first subunit of the  
 @c rule as an integer, or @code{$<dtype>1} to refer to it as a double.  
 この場合に、@code{$<itype>1}と書けば、  この場合に、@code{$<itype>1}と書けば、
 最初の要素を@code{int}型として参照でき、@code{$<dtype>1}と書けば、  最初の要素を@code{int}型として参照でき、@code{$<dtype>1}と書けば、
 @code{double}型として参照できます。  @code{double}型として参照できます。
 @c =====================================================================  
 @node Mid-Rule Actions,  , Action Types, Semantics  @node Mid-Rule Actions,  , Action Types, Semantics
 @c @subsection Actions in Mid-Rule  
 @subsection 規則の途中のアクション  @subsection 規則の途中のアクション
 @cindex actions in mid-rule  @cindex actions in mid-rule
 @cindex mid-rule actions  @cindex mid-rule actions
 @cindex 規則の途中のアクション  @cindex 規則の途中のアクション
 @cindex アクション, 規則の途中  @cindex アクション, 規則の途中
 @c Occasionally it is useful to put an action in the middle of a rule.  
 @c These actions are written just like usual end-of-rule actions, but they  
 @c are executed before the parser even recognizes the following components.  
 まれに、アクションを規則の途中に置くと便利な場合があります。  まれに、アクションを規則の途中に置くと便利な場合があります。
 これらのアクションは、通常の規則の終わりに置かれたアクションと同様に  これらのアクションは、通常の規則の終わりに置かれたアクションと同様に
 記述されますが、構文解析器が後に続く要素を認識する前に実行されます。  記述されますが、構文解析器が後に続く要素を認識する前に実行されます。
 @c A mid-rule action may refer to the components preceding it using  
 @c @code{$@var{n}}, but it may not refer to subsequent components because  
 @c it is run before they are parsed.  
 規則の途中のアクションは、そのアクションよりも前にある要素を  規則の途中のアクションは、そのアクションよりも前にある要素を
 @code{$@var{n}}を使って参照できますが、後に続く要素は  @code{$@var{n}}を使って参照できますが、後に続く要素は
 まだ構文解析されていないので参照できません。  まだ構文解析されていないので参照できません。
 @c The mid-rule action itself counts as one of the components of the rule.  
 @c This makes a difference when there is another action later in the same rule  
 @c (and usually there is another at the end): you have to count the actions  
 @c along with the symbols when working out which number @var{n} to use in  
 @c @code{$@var{n}}.  
 規則の途中のアクション自身は、規則の要素の1つとして数えられます。  規則の途中のアクション自身は、規則の要素の1つとして数えられます。
 同じ規則の中に別のアクションが続く場合(通常は最後)に問題が起きます。  同じ規則の中に別のアクションが続く場合(通常は最後)に問題が起きます。
 @code{$@var{n}}に使う番号@var{n}に  @code{$@var{n}}に使う番号@var{n}に
 規則の途中のアクションを数えるのを忘れないように注意してください。  規則の途中のアクションを数えるのを忘れないように注意してください。
 @c The mid-rule action can also have a semantic value.  The action can set  
 @c its value with an assignment to @code{$$}, and actions later in the rule  
 @c can refer to the value using @code{$@var{n}}.  Since there is no symbol  
 @c to name the action, there is no way to declare a data type for the value  
 @c in advance, so you must use the @samp{$<@dots{}>} construct to specify a  
 @c data type each time you refer to this value.  
 規則の途中のアクションは、意味値を持てます。  規則の途中のアクションは、意味値を持てます。
 そのアクションは、@code{$$}への代入で値を定め、  そのアクションは、@code{$$}への代入で値を定め、
 後に続くアクションの中で、@code{$@var{n}}で値を参照できます。  後に続くアクションの中で、@code{$@var{n}}で値を参照できます。
Line 4521  exp:    @dots{} Line 3048  exp:    @dots{}
 そこで、アクションの意味を参照するときに、  そこで、アクションの意味を参照するときに、
 @samp{$<@dots{}>}を使ってデータ型を指定する必要があります。  @samp{$<@dots{}>}を使ってデータ型を指定する必要があります。
 @c There is no way to set the value of the entire rule with a mid-rule  
 @c action, because assignments to @code{$$} do not have that effect.  The  
 @c only way to set the value for the entire rule is with an ordinary action  
 @c at the end of the rule.  
 規則の途中のアクションでは、@code{$$}への代入が規則の値に関係しないので、  規則の途中のアクションでは、@code{$$}への代入が規則の値に関係しないので、
 規則全体の値を設定する方法はありません。  規則全体の値を設定する方法はありません。
 規則全体の値を設定する唯一の方法は、  規則全体の値を設定する唯一の方法は、
 規則の最後に置かれた通常のアクションです。  規則の最後に置かれた通常のアクションです。
 @c Here is an example from a hypothetical compiler, handling a @code{let}  
 @c statement that looks like @samp{let (@var{variable}) @var{statement}} and  
 @c serves to create a variable named @var{variable} temporarily for the  
 @c duration of @var{statement}.  To parse this construct, we must put  
 @c @var{variable} into the symbol table while @var{statement} is parsed, then  
 @c remove it afterward.  Here is how it is done:  
 架空のコンパイラの例を示します。  架空のコンパイラの例を示します。
 ここでは、@samp{let (@var{variable}) @var{statement}}のような書式の  ここでは、@samp{let (@var{variable}) @var{statement}}のような書式の
 @code{let}文を使え、@var{statement}の持続期間中に一時的に  @code{let}文を使え、@var{statement}の持続期間中に一時的に
Line 4558  stmt:   LET '(' var ')' Line 3073  stmt:   LET '(' var ')'
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c As soon as @samp{let (@var{variable})} has been recognized, the first  
 @c action is run.  It saves a copy of the current semantic context (the  
 @c list of accessible variables) as its semantic value, using alternative  
 @c @code{context} in the data-type union.  Then it calls  
 @c @code{declare_variable} to add the new variable to that list.  Once the  
 @c first action is finished, the embedded statement @code{stmt} can be  
 @c parsed.  Note that the mid-rule action is component number 5, so the  
 @c @samp{stmt} is component number 6.  
 @samp{let (@var{variable})}が認識されるとすぐに、  @samp{let (@var{variable})}が認識されるとすぐに、
 最初のアクションが実行されます。  最初のアクションが実行されます。
 そのアクションは、現在の意味文脈、すなわち参照可能な変数の表の複製を、  そのアクションは、現在の意味文脈、すなわち参照可能な変数の表の複製を、
Line 4579  stmt:   LET '(' var ')' Line 3084  stmt:   LET '(' var ')'
 規則の途中のアクションが5番目の要素であることに注意してください。  規則の途中のアクションが5番目の要素であることに注意してください。
 したがって、@samp{stmt}は6番目の要素になります。  したがって、@samp{stmt}は6番目の要素になります。
 @c After the embedded statement is parsed, its semantic value becomes the  
 @c value of the entire @code{let}-statement.  Then the semantic value from the  
 @c earlier action is used to restore the prior list of variables.  This  
 @c removes the temporary @code{let}-variable from the list so that it won't  
 @c appear to exist while the rest of the program is parsed.  
 後続する文が解析されると、その意味値が@code{let}文全体の意味値になります。  後続する文が解析されると、その意味値が@code{let}文全体の意味値になります。
 そして、最初のアクションの意味値は、  そして、最初のアクションの意味値は、
 変数の表を元に戻すために使われます。  変数の表を元に戻すために使われます。
 そこで、@code{let}文中での一時変数が表から削除され、  そこで、@code{let}文中での一時変数が表から削除され、
 構文解析されるプログラムの残りの部分では一時変数が存在しません。  構文解析されるプログラムの残りの部分では一時変数が存在しません。
 @c Taking action before a rule is completely recognized often leads to  
 @c conflicts since the parser must commit to a parse in order to execute the  
 @c action.  For example, the following two rules, without mid-rule actions,  
 @c can coexist in a working parser because the parser can shift the open-brace  
 @c token and look at what follows before deciding whether there is a  
 @c declaration or not:  
 構文解析器は、アクションを実行する順序を決めるために、  構文解析器は、アクションを実行する順序を決めるために、
 構文解析する必要があるので、  構文解析する必要があるので、
 規則が完全に認識される前にアクションを実行することは、  規則が完全に認識される前にアクションを実行することは、
Line 4615  compound: '@{' declarations statements ' Line 3107  compound: '@{' declarations statements '
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c But when we add a mid-rule action as follows, the rules become nonfunctional:  
 しかし、次の例のように、規則の途中のアクションを加えると、  しかし、次の例のように、規則の途中のアクションを加えると、
 この規則は働かなくなります。  この規則は働かなくなります。
Line 4631  compound: @{ prepare_for_local_variables Line 3121  compound: @{ prepare_for_local_variables
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c Now the parser is forced to decide whether to run the mid-rule action  
 @c when it has read no farther than the open-brace.  In other words, it  
 @c must commit to using one rule or the other, without sufficient  
 @c information to do it correctly.  (The open-brace token is what is called  
 @c the @dfn{look-ahead} token at this time, since the parser is still  
 @c deciding what to do about it.  @xref{Look-Ahead, ,Look-Ahead Tokens}.)  
 ここでは、開きブレースを見つけた時点で、  ここでは、開きブレースを見つけた時点で、
 規則の途中のアクションを実行する必要があるかどうかの決定を迫られます。  規則の途中のアクションを実行する必要があるかどうかの決定を迫られます。
 言い換えれば、正しく判断するための十分な情報なしに、  言い換えれば、正しく判断するための十分な情報なしに、
Line 4647  compound: @{ prepare_for_local_variables Line 3129  compound: @{ prepare_for_local_variables
 何をすべきか決定する途中なので、@dfn{先読み(look-ahead)}トークンと  何をすべきか決定する途中なので、@dfn{先読み(look-ahead)}トークンと
 呼ばれます。@xref{Look-Ahead, ,Look-Ahead Tokens}。  呼ばれます。@xref{Look-Ahead, ,Look-Ahead Tokens}。
 @c You might think that you could correct the problem by putting identical  
 @c actions into the two rules, like this:  
 次のように同一のアクションを置くことで、  次のように同一のアクションを置くことで、
 この問題を解決できるように思えるかもしれません。  この問題を解決できるように思えるかもしれません。
Line 4663  compound: @{ prepare_for_local_variables Line 3142  compound: @{ prepare_for_local_variables
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c But this does not help, because Bison does not realize that the two actions  
 @c are identical.  (Bison never tries to understand the C code in an action.)  
 しかし、Bisonには2つのアクションが同一であるかどうかわからないので、  しかし、Bisonには2つのアクションが同一であるかどうかわからないので、
 問題は解決しません。  問題は解決しません。
 Bisonは、アクションの中のCで書かれたプログラムを、  Bisonは、アクションの中のCで書かれたプログラムを、
 決して解釈しようとしません。  決して解釈しようとしません。
 @c If the grammar is such that a declaration can be distinguished from a  
 @c statement by the first token (which is true in C), then one solution which  
 @c does work is to put the action after the open-brace, like this:  
 C言語のように、最初のトークンによって文と宣言を区別できるような  C言語のように、最初のトークンによって文と宣言を区別できるような
 文法ならば、実現可能な解決方法の1つは、次の例のように、  文法ならば、実現可能な解決方法の1つは、次の例のように、
 開きブレースの後にアクションを置くことです。  開きブレースの後にアクションを置くことです。
Line 4689  compound: '@{' @{ prepare_for_local_vari Line 3160  compound: '@{' @{ prepare_for_local_vari
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c Now the first token of the following declaration or statement,  
 @c which would in any case tell Bison which rule to use, can still do so.  
 これで、続く宣言または文の最初のトークンによって、  これで、続く宣言または文の最初のトークンによって、
 Bisonがどちらの規則を使うべきかわかります。  Bisonがどちらの規則を使うべきかわかります。
 @c Another solution is to bury the action inside a nonterminal symbol which  
 @c serves as a subroutine:  
 別の解決方法は、サブルーチンとして働く非終端記号の内側に、  別の解決方法は、サブルーチンとして働く非終端記号の内側に、
 アクションを埋め込むことです。  アクションを埋め込むことです。
 @example  @example
 @group  @group
 @c subroutine: /* empty */  
 subroutine: /* 空 */  subroutine: /* 空 */
           @{ prepare_for_local_variables (); @}            @{ prepare_for_local_variables (); @}
         ;          ;
Line 4720  compound: subroutine Line 3183  compound: subroutine
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c Now Bison can execute the action in the rule for @code{subroutine} without  
 @c deciding which rule for @code{compound} it will eventually use.  Note that  
 @c the action is now at the end of its rule.  Any mid-rule action can be  
 @c converted to an end-of-rule action in this way, and this is what Bison  
 @c actually does to implement mid-rule actions.  
 これで、Bisonは@code{compound}に対してどちらの規則を使うべきか決めずに、  これで、Bisonは@code{compound}に対してどちらの規則を使うべきか決めずに、
 @code{subroutine}に対する規則中のアクションを実行できます。  @code{subroutine}に対する規則中のアクションを実行できます。
 任意の規則中のアクションは、この方法によって、  任意の規則中のアクションは、この方法によって、
Line 4735  compound: subroutine Line 3191  compound: subroutine
 規則中のアクションという機能が実現されています。  規則中のアクションという機能が実現されています。
 @c =====================================================================  
 @node Declarations, Multiple Parsers, Semantics, Grammar File  @node Declarations, Multiple Parsers, Semantics, Grammar File
 @c @section Bison Declarations  
 @section Bison宣言  @section Bison宣言
 @cindex declarations, Bison  @cindex declarations, Bison
 @cindex Bison declarations  @cindex Bison declarations
 @cindex 宣言, Bison  @cindex 宣言, Bison
 @cindex Bison宣言  @cindex Bison宣言
 @c The @dfn{Bison declarations} section of a Bison grammar defines the symbols  
 @c used in formulating the grammar and the data types of semantic values.  
 @c @xref{Symbols}.  
 Bison文法ファイルの@dfn{Bison宣言(Bison declarations)}部では、  Bison文法ファイルの@dfn{Bison宣言(Bison declarations)}部では、
 文法の定式化に使う記号を定義し、意味値のデータ型を定義します。  文法の定式化に使う記号を定義し、意味値のデータ型を定義します。
 @xref{Symbols}。  @xref{Symbols}。
 @c All token type names (but not single-character literal tokens such as  
 @c @code{'+'} and @code{'*'}) must be declared.  Nonterminal symbols must be  
 @c declared if you need to specify which data type to use for the semantic  
 @c value (@pxref{Multiple Types, ,More Than One Value Type}).  
 @code{'+'}や@code{'*'}のような1文字リテラルトークンを除く  @code{'+'}や@code{'*'}のような1文字リテラルトークンを除く
 すべてのトークンの型名を宣言する必要があります。  すべてのトークンの型名を宣言する必要があります。
 非終端記号については、その意味値に対してどのデータ型を使うか  非終端記号については、その意味値に対してどのデータ型を使うか
 指定したければ、宣言する必要があります  指定したければ、宣言する必要があります
 (@pxref{Multiple Types, ,More Than One Value Type})。  (@pxref{Multiple Types, ,More Than One Value Type})。
 @c The first rule in the file also specifies the start symbol, by default.  
 @c If you want some other symbol to be the start symbol, you must declare  
 @c it explicitly  
 @c (@pxref{Language and Grammar, ,Languages and Context-Free Grammars}).  
 特に指定しないと、文法ファイル中の最初の規則は、  特に指定しないと、文法ファイル中の最初の規則は、
 開始記号を特定します。  開始記号を特定します。
 他の記号を開始記号にしたければ、明示的に宣言する必要があります  他の記号を開始記号にしたければ、明示的に宣言する必要があります
Line 4785  Bison文法ファイルの@dfn{Bison宣言(Bison Line 3225  Bison文法ファイルの@dfn{Bison宣言(Bison
 @end menu  @end menu
 @c =====================================================================  
 @node Token Decl, Precedence Decl,  , Declarations  @node Token Decl, Precedence Decl,  , Declarations
 @c @subsection Token Type Names  
 @subsection トークン型名  @subsection トークン型名
 @cindex declaring token type names  @cindex declaring token type names
 @cindex token type names, declaring  @cindex token type names, declaring
Line 4797  Bison文法ファイルの@dfn{Bison宣言(Bison Line 3235  Bison文法ファイルの@dfn{Bison宣言(Bison
 @cindex トークン型名, 宣言  @cindex トークン型名, 宣言
 @cindex リテラル文字列トークンの宣言  @cindex リテラル文字列トークンの宣言
 @c The basic way to declare a token type name (terminal symbol) is as follows:  
 トークン型名、すなわち終端記号を、基本的には次のように宣言します。  トークン型名、すなわち終端記号を、基本的には次のように宣言します。
 @example  @example
 %token @var{name}  %token @var{name}
 @end example  @end example
 @c Bison will convert this into a @code{#define} directive in  
 @c the parser, so that the function @code{yylex} (if it is in this file)  
 @c can use the name @var{name} to stand for this token type's code.  
 Bisonは、これを、構文解析器の中の@code{#define}ディレクティブに変換します。  Bisonは、これを、構文解析器の中の@code{#define}ディレクティブに変換します。
 したがって、関数@code{yylex}が構文解析器ファイルの中にあれば、  したがって、関数@code{yylex}が構文解析器ファイルの中にあれば、
 そこで名前@var{name}をこのトークン型を表すために使えます。  そこで名前@var{name}をこのトークン型を表すために使えます。
 @c Alternatively, you can use @code{%left}, @code{%right}, or @code{%nonassoc}  
 @c instead of @code{%token}, if you wish to specify precedence.  
 @c @xref{Precedence Decl, ,Operator Precedence}.  
 優先順位を指定したければ、@code{%token}の代わりに、  優先順位を指定したければ、@code{%token}の代わりに、
 @code{%left}、@code{%right}、@code{%nonassoc}のどれかを使います。  @code{%left}、@code{%right}、@code{%nonassoc}のどれかを使います。
 @xref{Precedence Decl, ,Operator Precedence}。  @xref{Precedence Decl, ,Operator Precedence}。
 @c You can explicitly specify the numeric code for a token type by appending  
 @c an integer value in the field immediately following the token name:  
 トークンの名前の直後に整数値を書くことで、  トークンの名前の直後に整数値を書くことで、
 そのトークン型に対応する数値符号を明示的に指定できます。  そのトークン型に対応する数値符号を明示的に指定できます。
Line 4831  Bisonは、これを、構文解析器の中の@code{# Line 3256  Bisonは、これを、構文解析器の中の@code{#
 %token NUM 300  %token NUM 300
 @end example  @end example
 @c @noindent  
 @c It is generally best, however, to let Bison choose the numeric codes for  
 @c all token types.  Bison will automatically select codes that don't conflict  
 @c with each other or with ASCII characters.  
 しかし、Bisonにすべてのトークン型に対する数値符号の割り当てをまかせる  しかし、Bisonにすべてのトークン型に対する数値符号の割り当てをまかせる
 ことがいちばんです。Bisonは、トークン型どうしやASCII文字符号と  ことがいちばんです。Bisonは、トークン型どうしやASCII文字符号と
 衝突が起きないように、自動的に数値符号を割り当てます。  衝突が起きないように、自動的に数値符号を割り当てます。
 @c In the event that the stack type is a union, you must augment the  
 @c @code{%token} or other token declaration to include the data type  
 @c alternative delimited by angle-brackets  
 @c (@pxref{Multiple Types, ,More Than One Value Type}).    
 スタック型が共用体である場合には、  スタック型が共用体である場合には、
 @code{%token}あるいは他のトークン宣言に、  @code{%token}あるいは他のトークン宣言に、
 小なり記号と大なり記号で区切った型名を追加する必要があります  小なり記号と大なり記号で区切った型名を追加する必要があります
 (@pxref{Multiple Types, ,More Than One Value Type})。  (@pxref{Multiple Types, ,More Than One Value Type})。
 @c For example:  
 例を示します。  例を示します。
 @example  @example
 @group  @group
 @c %union @{              /* define stack type */  
 %union @{              /* スタックのデータ型を定義する */  %union @{              /* スタックのデータ型を定義する */
   double val;    double val;
   symrec *tptr;    symrec *tptr;
 @}  @}
 @c %token <val> NUM      /* define token NUM and its type */  
 %token <val> NUM      /* トークン「NUM」とその型を定義する */  %token <val> NUM      /* トークン「NUM」とその型を定義する */
 @end group  @end group
 @end example  @end example
 @c You can associate a literal string token with a token type name by  
 @c writing the literal string at the end of a @code{%token}  
 @c declaration which declares the name.  For example:  
 トークン型名を宣言する@code{%token}宣言の末尾に  トークン型名を宣言する@code{%token}宣言の末尾に
 リテラル文字列を書くことで、リテラル文字列トークンと  リテラル文字列を書くことで、リテラル文字列トークンと
 トークン型名を関連づけできます。  トークン型名を関連づけできます。
Line 4878  Bisonは、これを、構文解析器の中の@code{# Line 3285  Bisonは、これを、構文解析器の中の@code{#
 %token arrow "=>"  %token arrow "=>"
 @end example  @end example
 @c @noindent  
 @c For example, a grammar for the C language might specify these names with  
 @c equivalent literal string tokens:  
 C言語に対する文法では、次の例のように、  C言語に対する文法では、次の例のように、
 等価なリテラル文字列トークンに名前を指定しています。  等価なリテラル文字列トークンに名前を指定しています。
Line 4891  C言語に対する文法では、次の例のように、 Line 3294  C言語に対する文法では、次の例のように、
 %left  OR  "<="  %left  OR  "<="
 @end example  @end example
 @c @noindent  
 @c Once you equate the literal string and the token name, you can use them  
 @c interchangeably in further declarations or the grammar rules.  The  
 @c @code{yylex} function can use the token name or the literal string to  
 @c obtain the token type code number (@pxref{Calling Convention}).  
 リテラル文字列とトークン名を等価にすれば、それ以降の文法規則の  リテラル文字列とトークン名を等価にすれば、それ以降の文法規則の
 宣言の中で、両者を同様に使えます。  宣言の中で、両者を同様に使えます。
 @code{yylex}関数は、トークン型の数値符号を得るために、  @code{yylex}関数は、トークン型の数値符号を得るために、
Line 4904  C言語に対する文法では、次の例のように、 Line 3301  C言語に対する文法では、次の例のように、
 (@pxref{Calling Convention})。  (@pxref{Calling Convention})。
 @c =====================================================================  
 @node Precedence Decl, Union Decl, Token Decl, Declarations  @node Precedence Decl, Union Decl, Token Decl, Declarations
 @c @subsection Operator Precedence  
 @subsection 演算子の優先順位  @subsection 演算子の優先順位
 @cindex precedence declarations  @cindex precedence declarations
 @cindex declaring operator precedence  @cindex declaring operator precedence
Line 4915  C言語に対する文法では、次の例のように、 Line 3310  C言語に対する文法では、次の例のように、
 @cindex 宣言, 演算子の優先順位  @cindex 宣言, 演算子の優先順位
 @cindex 演算子の優先順位  @cindex 演算子の優先順位
 @c Use the @code{%left}, @code{%right} or @code{%nonassoc} declaration to  
 @c declare a token and specify its precedence and associativity, all at  
 @c once.  These are called @dfn{precedence declarations}.  
 @c @xref{Precedence, ,Operator Precedence},  
 @c for general information on operator precedence.  
 トークンの宣言とトークンの優先順位および結合規則の指定をまとめて行いたいならば、  トークンの宣言とトークンの優先順位および結合規則の指定をまとめて行いたいならば、
 @code{%left}、@code{%right}、@code{%nonassoc}のどれかを使います。  @code{%left}、@code{%right}、@code{%nonassoc}のどれかを使います。
 これらは、@dfn{優先順位宣言(precedence declarations)}と呼ばれます。  これらは、@dfn{優先順位宣言(precedence declarations)}と呼ばれます。
 演算子の優先順位の詳細については、  演算子の優先順位の詳細については、
 @xref{Precedence, ,Operator Precedence}。  @xref{Precedence, ,Operator Precedence}。
 @c The syntax of a precedence declaration is the same as that of  
 @c @code{%token}: either  
 優先順位宣言の構文は、@code{%token}を使う宣言の構文と同じです。  優先順位宣言の構文は、@code{%token}を使う宣言の構文と同じです。
 @example  @example
 %left @var{symbols}@dots{}  %left @var{symbols}@dots{}
 @end example  @end example
 @c @noindent  
 @c or  
 次のようにも書けます。  次のようにも書けます。
 @example  @example
 %left <@var{type}> @var{symbols}@dots{}  %left <@var{type}> @var{symbols}@dots{}
 @end example  @end example
 @c And indeed any of these declarations serves the purposes of @code{%token}.  
 @c But in addition, they specify the associativity and relative precedence for  
 @c all the @var{symbols}:  
 これらの宣言は、@code{%token}を使う宣言が目的とする  これらの宣言は、@code{%token}を使う宣言が目的とする
 すべての機能を持っています。  すべての機能を持っています。
 それに加えて、次のように結合性と、すべての@var{symbols}についての優先順位を指定します。  それに加えて、次のように結合性と、すべての@var{symbols}についての優先順位を指定します。
 @itemize @bullet  @itemize @bullet
 @item  @item
 @c The associativity of an operator @var{op} determines how repeated uses  
 @c of the operator nest: whether @samp{@var{x} @var{op} @var{y} @var{op}  
 @c @var{z}} is parsed by grouping @var{x} with @var{y} first or by  
 @c grouping @var{y} with @var{z} first.  @code{%left} specifies  
 @c left-associativity (grouping @var{x} with @var{y} first) and  
 @c @code{%right} specifies right-associativity (grouping @var{y} with  
 @c @var{z} first).  @code{%nonassoc} specifies no associativity, which  
 @c means that @samp{@var{x} @var{op} @var{y} @var{op} @var{z}} is  
 @c considered a syntax error.  
 演算子@var{op}の結合性は、この演算子が繰り返し使われた場合の  演算子@var{op}の結合性は、この演算子が繰り返し使われた場合の
 動作を指定します。つまり、@samp{@var{x} @var{op} @var{y} @var{op} @var{z}}が  動作を指定します。つまり、@samp{@var{x} @var{op} @var{y} @var{op} @var{z}}が
 構文解析された場合に、最初に@var{x}と@var{y}がグループ化されるか、  構文解析された場合に、最初に@var{x}と@var{y}がグループ化されるか、
Line 4977  C言語に対する文法では、次の例のように、 Line 3346  C言語に対する文法では、次の例のように、
 構文エラーとみなされます。  構文エラーとみなされます。
 @item  @item
 @c The precedence of an operator determines how it nests with other operators.  
 @c All the tokens declared in a single precedence declaration have equal  
 @c precedence and nest together according to their associativity.  
 @c When two tokens declared in different precedence declarations associate,  
 @c the one declared later has the higher precedence and is grouped first.  
 演算子の優先順位は、その演算子が他の演算子とともに使われた場合の  演算子の優先順位は、その演算子が他の演算子とともに使われた場合の
 動作を指定します。同一の優先順位宣言で宣言されたすべてのトークンは、  動作を指定します。同一の優先順位宣言で宣言されたすべてのトークンは、
 同じ優先順位を持ち、その結合性にしたがって処理されます。  同じ優先順位を持ち、その結合性にしたがって処理されます。
Line 4992  C言語に対する文法では、次の例のように、 Line 3355  C言語に対する文法では、次の例のように、
 @end itemize  @end itemize
 @c =====================================================================  
 @node Union Decl, Type Decl, Precedence Decl, Declarations  @node Union Decl, Type Decl, Precedence Decl, Declarations
 @c @subsection The Collection of Value Types  
 @subsection 値型の集合  @subsection 値型の集合
 @cindex declaring value types  @cindex declaring value types
 @cindex value types, declaring  @cindex value types, declaring
Line 5002  C言語に対する文法では、次の例のように、 Line 3363  C言語に対する文法では、次の例のように、
 @cindex 値型の宣言  @cindex 値型の宣言
 @cindex 宣言, 値型  @cindex 宣言, 値型
 @c The @code{%union} declaration specifies the entire collection of possible  
 @c data types for semantic values.  The keyword @code{%union} is followed by a  
 @c pair of braces containing the same thing that goes inside a @code{union} in  
 @c C.    
 @code{%union}宣言は、意味値に対して可能なデータ型すべての集合を指定します。  @code{%union}宣言は、意味値に対して可能なデータ型すべての集合を指定します。
 キーワード@code{%union}に続いて、C言語における共用体の宣言と同様に、  キーワード@code{%union}に続いて、C言語における共用体の宣言と同様に、
 ブレースで囲んだ宣言の並びを書きます。  ブレースで囲んだ宣言の並びを書きます。
 @c For example:  
 例を示します。  例を示します。
 @example  @example
Line 5024  C言語に対する文法では、次の例のように、 Line 3378  C言語に対する文法では、次の例のように、
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c This says that the two alternative types are @code{double} and @code{symrec  
 @c *}.  They are given names @code{val} and @code{tptr}; these names are used  
 @c in the @code{%token} and @code{%type} declarations to pick one of the types  
 @c for a terminal or nonterminal symbol  
 @c (@pxref{Type Decl, ,Nonterminal Symbols}).  
 これは、2つの選択可能な型@code{double}と@code{symrec *}があると、  これは、2つの選択可能な型@code{double}と@code{symrec *}があると、
 宣言しています。  宣言しています。
 それぞれの型には、名前@code{val}と@code{tptr}が与えられています。  それぞれの型には、名前@code{val}と@code{tptr}が与えられています。
Line 5038  C言語に対する文法では、次の例のように、 Line 3385  C言語に対する文法では、次の例のように、
 終端記号あるいは非終端記号に対する型を選ぶために使えます  終端記号あるいは非終端記号に対する型を選ぶために使えます
 (@pxref{Type Decl, ,Nonterminal Symbols})。  (@pxref{Type Decl, ,Nonterminal Symbols})。
 @c Note that, unlike making a @code{union} declaration in C, you do not write  
 @c a semicolon after the closing brace.  
 C言語での共用体宣言とは異なり、閉じブレースの後にセミコロンを  C言語での共用体宣言とは異なり、閉じブレースの後にセミコロンを
 @emph{書いてはいけない}ことに注意してください。  @emph{書いてはいけない}ことに注意してください。
 @c =====================================================================  
 @node Type Decl, Expect Decl, Union Decl, Declarations  @node Type Decl, Expect Decl, Union Decl, Declarations
 @c @subsection Nonterminal Symbols  
 @subsection 非終端記号  @subsection 非終端記号
 @cindex declaring value types, nonterminals  @cindex declaring value types, nonterminals
 @cindex value types, nonterminals, declaring  @cindex value types, nonterminals, declaring
Line 5056  C言語での共用体宣言とは異なり、閉じブレ Line 3398  C言語での共用体宣言とは異なり、閉じブレ
 @cindex 宣言, 非終端記号の値型  @cindex 宣言, 非終端記号の値型
 @cindex 非終端記号, 値型の宣言  @cindex 非終端記号, 値型の宣言
 @c @noindent  
 @c When you use @code{%union} to specify multiple value types, you must  
 @c declare the value type of each nonterminal symbol for which values are  
 @c used.  This is done with a @code{%type} declaration, like this:  
 @code{%union}を複数の値型を指定するために使うならば、  @code{%union}を複数の値型を指定するために使うならば、
 値を持つ各非終端記号の値型を宣言する必要があります。  値を持つ各非終端記号の値型を宣言する必要があります。
 そのためには、次のように@code{%type}宣言を使います。  そのためには、次のように@code{%type}宣言を使います。
Line 5069  C言語での共用体宣言とは異なり、閉じブレ Line 3406  C言語での共用体宣言とは異なり、閉じブレ
 %type <@var{type}> @var{nonterminal}@dots{}  %type <@var{type}> @var{nonterminal}@dots{}
 @end example  @end example
 @c @noindent  
 @c Here @var{nonterminal} is the name of a nonterminal symbol, and @var{type}  
 @c is the name given in the @code{%union} to the alternative that you want  
 @c (@pxref{Union Decl, ,The Collection of Value Types}).  
 @c You can give any number of nonterminal symbols in  
 @c the same @code{%type} declaration, if they have the same value type.  Use  
 @c spaces to separate the symbol names.  
 ここで、@var{nonterminal}は非終端記号の名前で、  ここで、@var{nonterminal}は非終端記号の名前で、
 @var{type}は@code{%union}で指定した名前の中からあなたが選んだものです  @var{type}は@code{%union}で指定した名前の中からあなたが選んだものです
 (@pxref{Union Decl, ,The Collection of Value Types})。  (@pxref{Union Decl, ,The Collection of Value Types})。
Line 5084  C言語での共用体宣言とは異なり、閉じブレ Line 3413  C言語での共用体宣言とは異なり、閉じブレ
 1つの@code{%type}宣言の中に記述できます。  1つの@code{%type}宣言の中に記述できます。
 その場合、記号名を空白で区切ってください。  その場合、記号名を空白で区切ってください。
 @c You can also declare the value type of a terminal symbol.  To do this,  
 @c use the same @code{<@var{type}>} construction in a declaration for the  
 @c terminal symbol.  All kinds of token declarations allow  
 @c @code{<@var{type}>}.  
 同様に終端記号の値型の宣言も可能です。  同様に終端記号の値型の宣言も可能です。
 そのためには、終端記号の宣言の中で、同じ@code{<@var{type}>}の  そのためには、終端記号の宣言の中で、同じ@code{<@var{type}>}の
 書式を使います。  書式を使います。
 すべてのトークン宣言で、@code{<@var{type}>}が許可されています。  すべてのトークン宣言で、@code{<@var{type}>}が許可されています。
 @c =====================================================================  
 @node Expect Decl, Start Decl, Type Decl, Declarations  @node Expect Decl, Start Decl, Type Decl, Declarations
 @c @subsection Suppressing Conflict Warnings  
 @subsection 衝突警告の回避  @subsection 衝突警告の回避
 @cindex suppressing conflict warnings  @cindex suppressing conflict warnings
 @cindex preventing warnings about conflicts  @cindex preventing warnings about conflicts
Line 5109  C言語での共用体宣言とは異なり、閉じブレ Line 3431  C言語での共用体宣言とは異なり、閉じブレ
 @cindex 警告, 衝突  @cindex 警告, 衝突
 @cindex 衝突, 警告の回避  @cindex 衝突, 警告の回避
 @c Bison normally warns if there are any conflicts in the grammar  
 @c (@pxref{Shift/Reduce, ,Shift/Reduce Conflicts}),  
 @c but most real grammars have harmless shift/reduce  
 @c conflicts which are resolved in a predictable way and would be difficult to  
 @c eliminate.  It is desirable to suppress the warning about these conflicts  
 @c unless the number of conflicts changes.  You can do this with the  
 @c @code{%expect} declaration.  
 文法の中に衝突(@pxref{Shift/Reduce, ,Shift/Reduce Conflicts})があると、  文法の中に衝突(@pxref{Shift/Reduce, ,Shift/Reduce Conflicts})があると、
 Bisonは通常警告を表示します。  Bisonは通常警告を表示します。
 しかし、実際の文法のほとんどは、無害なシフト還元衝突を含み、  しかし、実際の文法のほとんどは、無害なシフト還元衝突を含み、
Line 5125  Bisonは通常警告を表示します。 Line 3439  Bisonは通常警告を表示します。
 抑制させるべきです。  抑制させるべきです。
 そのために、@code{%expect}宣言を使います。  そのために、@code{%expect}宣言を使います。
 @c The declaration looks like this:  
 次のように宣言します。  次のように宣言します。
 @example  @example
 %expect @var{n}  %expect @var{n}
 @end example  @end example
 @c Here @var{n} is a decimal integer.  The declaration says there should be no  
 @c warning if there are @var{n} shift/reduce conflicts and no reduce/reduce  
 @c conflicts.  The usual warning is given if there are either more or fewer  
 @c conflicts, or if there are any reduce/reduce conflicts.  
 ここで、@var{n}は10進の整数です。  ここで、@var{n}は10進の整数です。
 この宣言によって、@var{n}個のシフト還元衝突があって、  この宣言によって、@var{n}個のシフト還元衝突があって、
 還元/還元衝突がなければ、警告が表示されません。  還元/還元衝突がなければ、警告が表示されません。
 シフト還元衝突の数が@var{n}でなかったり、  シフト還元衝突の数が@var{n}でなかったり、
 1つでも還元/還元衝突があった場合は、通常の警告が表示されます。  1つでも還元/還元衝突があった場合は、通常の警告が表示されます。
 @c In general, using @code{%expect} involves these steps:  
 一般に、次のような手順で@code{%expect}を使います。  一般に、次のような手順で@code{%expect}を使います。
 @itemize @bullet  @itemize @bullet
 @item  @item
 @c Compile your grammar without @code{%expect}.  Use the @samp{-v} option  
 @c to get a verbose list of where the conflicts occur.  Bison will also  
 @c print the number of conflicts.  
 @code{%expect}なしで文法ファイルをコンパイルします。  @code{%expect}なしで文法ファイルをコンパイルします。
 衝突が起こる位置の詳細な目録を得るために、@samp{-v}オプションを指定します。  衝突が起こる位置の詳細な目録を得るために、@samp{-v}オプションを指定します。
 Bisonは、衝突の数も表示します。  Bisonは、衝突の数も表示します。
 @item  @item
 @c Check each of the conflicts to make sure that Bison's default  
 @c resolution is what you really want.  If not, rewrite the grammar and  
 @c go back to the beginning.  
 衝突のそれぞれについて、Bisonの省略時の解決方法が、  衝突のそれぞれについて、Bisonの省略時の解決方法が、
 あなたの望みどおりであるか、確かめます。  あなたの望みどおりであるか、確かめます。
 もし不都合があれば、文法ファイルを書き直して、最初に戻ります。  もし不都合があれば、文法ファイルを書き直して、最初に戻ります。
 @item  @item
 @c Add an @code{%expect} declaration, copying the number @var{n} from the  
 @c number which Bison printed.  
 Bisonが表示した衝突の数@var{n}を書き写して、  Bisonが表示した衝突の数@var{n}を書き写して、
 @code{%expect}宣言を追加します。  @code{%expect}宣言を追加します。
 @end itemize  @end itemize
 @c Now Bison will stop annoying you about the conflicts you have checked, but  
 @c it will warn you again if changes in the grammar result in additional  
 @c conflicts.  
 すると、Bisonはチェックした衝突について文句をいわなくなりますが、  すると、Bisonはチェックした衝突について文句をいわなくなりますが、
 文法ファイルを書き換えて衝突の数が変わると、  文法ファイルを書き換えて衝突の数が変わると、
 再び警告を表示します。  再び警告を表示します。
 @c =====================================================================  
 @node Start Decl, Pure Decl, Expect Decl, Declarations  @node Start Decl, Pure Decl, Expect Decl, Declarations
 @c @subsection The Start-Symbol  
 @subsection 開始記号  @subsection 開始記号
 @cindex declaring the start symbol  @cindex declaring the start symbol
 @cindex start symbol, declaring  @cindex start symbol, declaring
Line 5197  Bisonが表示した衝突の数@var{n}を書き写し Line 3485  Bisonが表示した衝突の数@var{n}を書き写し
 @cindex 宣言, 開始記号  @cindex 宣言, 開始記号
 @cindex 省略時開始記号  @cindex 省略時開始記号
 @c Bison assumes by default that the start symbol for the grammar is the first  
 @c nonterminal specified in the grammar specification section.  The programmer  
 @c may override this restriction with the @code{%start} declaration as follows:  
 Bisonは、文法定義部にある最初の非終端記号を、  Bisonは、文法定義部にある最初の非終端記号を、
 省略時の開始記号と仮定します。  省略時の開始記号と仮定します。
 次のような@code{%start}宣言で、明示的に開始記号を指定できます。  次のような@code{%start}宣言で、明示的に開始記号を指定できます。
Line 5210  Bisonは、文法定義部にある最初の非終端記 Line 3494  Bisonは、文法定義部にある最初の非終端記
 @end example  @end example
 @c =====================================================================  
 @node Pure Decl, Decl Summary, Start Decl, Declarations  @node Pure Decl, Decl Summary, Start Decl, Declarations
 @c @subsection A Pure (Reentrant) Parser  
 @subsection 純粋(再入可能)構文解析器  @subsection 純粋(再入可能)構文解析器
 @cindex reentrant parser  @cindex reentrant parser
 @cindex pure parser  @cindex pure parser
Line 5220  Bisonは、文法定義部にある最初の非終端記 Line 3502  Bisonは、文法定義部にある最初の非終端記
 @cindex 再入可能構文解析器  @cindex 再入可能構文解析器
 @cindex 純粋構文解析器  @cindex 純粋構文解析器
 @c A @dfn{reentrant} program is one which does not alter in the course of  
 @c execution; in other words, it consists entirely of @dfn{pure} (read-only)  
 @c code.  Reentrancy is important whenever asynchronous execution is possible;  
 @c for example, a nonreentrant program may not be safe to call from a signal  
 @c handler.  In systems with multiple threads of control, a nonreentrant  
 @c program must be called only within interlocks.  
 @dfn{再入可能(reentrant)}プログラムとは、進路を変えないプログラム、  @dfn{再入可能(reentrant)}プログラムとは、進路を変えないプログラム、
 いいかえれば、完全に@dfn{純粋な(pure)}(読み出し専用)コードからなる  いいかえれば、完全に@dfn{純粋な(pure)}(読み出し専用)コードからなる
 プログラムです。  プログラムです。
Line 5237  Bisonは、文法定義部にある最初の非終端記 Line 3512  Bisonは、文法定義部にある最初の非終端記
 シグナルハンドラから呼び出すことは危険です。マルチスレッド制御システムでは、  シグナルハンドラから呼び出すことは危険です。マルチスレッド制御システムでは、
 再入不能プログラムはインターロックからしか呼び出せません。  再入不能プログラムはインターロックからしか呼び出せません。
 @c  Normally, Bison generates a parser which is not reentrant.  This is  
 @c  suitable for most uses, and it permits compatibility with YACC.  (The  
 @c  standard YACC interfaces are inherently nonreentrant, because they use  
 @c  statically allocated variables for communication with @code{yylex},  
 @c  including @code{yylval} and @code{yylloc}.)  
 通常は、Bisonは再入可能でない構文解析器を生成します。  通常は、Bisonは再入可能でない構文解析器を生成します。
 これはほとんどの使用に合い、YACCとの互換性も保ちます。  これはほとんどの使用に合い、YACCとの互換性も保ちます。
 (標準のYACCインターフェースは継続的に非再入可能であります。  (標準のYACCインターフェースは継続的に非再入可能であります。
Line 5252  Bisonは、文法定義部にある最初の非終端記 Line 3521  Bisonは、文法定義部にある最初の非終端記
 メモリ上の固定番地に置かれるという意味。}  メモリ上の固定番地に置かれるという意味。}
 を使うからです。  を使うからです。
 @c  Alternatively, you can generate a pure, reentrant parser.  The Bison  
 @c  declaration @code{%pure_parser} says that you want the parser to be  
 @c  reentrant.  It looks like this:  
 代わりに、純粋な、再入可能な構文解析器を生成することができます。  代わりに、純粋な、再入可能な構文解析器を生成することができます。
 次のような@code{%pure_parser} Bison宣言は、  次のような@code{%pure_parser} Bison宣言は、
 再入可能な構文解析器を生成します。  再入可能な構文解析器を生成します。
Line 5264  Bisonは、文法定義部にある最初の非終端記 Line 3529  Bisonは、文法定義部にある最初の非終端記
 %pure_parser  %pure_parser
 @end example  @end example
 @c  The result is that the communication variables @code{yylval} and  
 @c  @code{yylloc} become local variables in @code{yyparse}, and a different  
 @c  calling convention is used for the lexical analyzer function  
 @c  @code{yylex}.  @xref{Pure Calling, ,Calling Conventions for Pure  
 @c  Parsers}, for the details of this.  The variable @code{yynerrs} also  
 @c  becomes local in @code{yyparse} (@pxref{Error Reporting, ,The Error  
 @c  Reporting Function @code{yyerror}}).  The convention for calling  
 @c  @code{yyparse} itself is unchanged.  
 この宣言によって、上記の2個の通信用変数@code{yylval}と@code{yylloc}が、  この宣言によって、上記の2個の通信用変数@code{yylval}と@code{yylloc}が、
 @code{yyparse}の局所変数になり、  @code{yyparse}の局所変数になり、
 @code{yylex}字句解析関数を呼び出す方法が変わります。  @code{yylex}字句解析関数を呼び出す方法が変わります。
Line 5281  Bisonは、文法定義部にある最初の非終端記 Line 3537  Bisonは、文法定義部にある最初の非終端記
 (@pxref{Error Reporting, ,The Error Reporting Function @code{yyerror}})。  (@pxref{Error Reporting, ,The Error Reporting Function @code{yyerror}})。
 @code{yypase}関数自体を呼び出す方法は変わりません。  @code{yypase}関数自体を呼び出す方法は変わりません。
 @c  Whether the parser is pure has nothing to do with the grammar rules.  
 @c  You can generate either a pure parser or a nonreentrant parser from any  
 @c  valid grammar.  
 解析器が純粋かどうかは文法規則には全く関係しません。  解析器が純粋かどうかは文法規則には全く関係しません。
 全ての有効な文法から、純粋な解析器と非再入可能な解析器の  全ての有効な文法から、純粋な解析器と非再入可能な解析器の
 どちらかを生成するこができます。  どちらかを生成するこができます。
 @c =====================================================================  
 @node Decl Summary,  , Pure Decl, Declarations  @node Decl Summary,  , Pure Decl, Declarations
 @c @subsection Bison Declaration Summary  
 @subsection Bison宣言の要約  @subsection Bison宣言の要約
 @cindex Bison declaration summary  @cindex Bison declaration summary
 @cindex declaration summary  @cindex declaration summary
Line 5300  Bisonは、文法定義部にある最初の非終端記 Line 3550  Bisonは、文法定義部にある最初の非終端記
 @cindex 宣言の要約  @cindex 宣言の要約
 @cindex 要約, Bison宣言  @cindex 要約, Bison宣言
 @c Here is a summary of all Bison declarations:  
 Bison宣言の要約を示します。  Bison宣言の要約を示します。
 @table @code  @table @code
 @item %union  @item %union
 @c Declare the collection of data types that semantic values may have  
 @c (@pxref{Union Decl, ,The Collection of Value Types}).  
 意味値が持ちうるデータ型の集合を宣言します  意味値が持ちうるデータ型の集合を宣言します
 (@pxref{Union Decl, ,The Collection of Value Types})。  (@pxref{Union Decl, ,The Collection of Value Types})。
 @item %token  @item %token
 @c Declare a terminal symbol (token type name) with no precedence  
 @c or associativity specified (@pxref{Token Decl, ,Token Type Names}).  
 優先順位と結合性を指定せずに、終端記号(トークン型名)を宣言します  優先順位と結合性を指定せずに、終端記号(トークン型名)を宣言します
 (@pxref{Token Decl, ,Token Type Names})。  (@pxref{Token Decl, ,Token Type Names})。
 @item %right  @item %right
 @c Declare a terminal symbol (token type name) that is right-associative  
 @c (@pxref{Precedence Decl, ,Operator Precedence}).  
 右結合的な終端記号(トークン型名)を宣言します  右結合的な終端記号(トークン型名)を宣言します
 (@pxref{Precedence Decl, ,Operator Precedence})。  (@pxref{Precedence Decl, ,Operator Precedence})。
 @item %left  @item %left
 @c Declare a terminal symbol (token type name) that is left-associative  
 @c (@pxref{Precedence Decl, ,Operator Precedence}).  
 左結合的な終端記号(トークン型名)を宣言します  左結合的な終端記号(トークン型名)を宣言します
 (@pxref{Precedence Decl, ,Operator Precedence})。  (@pxref{Precedence Decl, ,Operator Precedence})。
 @item %nonassoc  @item %nonassoc
 @c Declare a terminal symbol (token type name) that is nonassociative  
 @c (using it in a way that would be associative is a syntax error)  
 @c (@pxref{Precedence Decl, ,Operator Precedence}).  
 結合性がない、つまり、結合して使おうとすると構文エラーになる、  結合性がない、つまり、結合して使おうとすると構文エラーになる、
 終端記号(トークン型名)を宣言します  終端記号(トークン型名)を宣言します
 (@pxref{Precedence Decl, ,Operator Precedence})。  (@pxref{Precedence Decl, ,Operator Precedence})。
 @item %type  @item %type
 @c Declare the type of semantic values for a nonterminal symbol  
 @c (@pxref{Type Decl, ,Nonterminal Symbols}).  
 非終端記号に対する意味値の型を宣言します  非終端記号に対する意味値の型を宣言します
 (@pxref{Type Decl, ,Nonterminal Symbols})。  (@pxref{Type Decl, ,Nonterminal Symbols})。
 @item %start  @item %start
 @c Specify the grammar's start symbol (@pxref{Start Decl, ,The Start-Symbol}).  
 文法の開始記号を宣言します  文法の開始記号を宣言します
 (@pxref{Start Decl, ,The Start-Symbol})。  (@pxref{Start Decl, ,The Start-Symbol})。
 @item %expect  @item %expect
 @c Declare the expected number of shift-reduce conflicts  
 @c (@pxref{Expect Decl, ,Suppressing Conflict Warnings}).  
 予想されるシフト還元衝突の数を宣言します  予想されるシフト還元衝突の数を宣言します
 (@pxref{Expect Decl, ,Suppressing Conflict Warnings})。  (@pxref{Expect Decl, ,Suppressing Conflict Warnings})。
 @item %pure_parser  @item %pure_parser
 @c Request a pure (reentrant) parser program  
 @c (@pxref{Pure Decl, ,A Pure (Reentrant) Parser}).  
 純粋な(再入可能な)構文解析器を生成します  純粋な(再入可能な)構文解析器を生成します
 (@pxref{Pure Decl, ,A Pure (Reentrant) Parser})。  (@pxref{Pure Decl, ,A Pure (Reentrant) Parser})。
 @item %no_lines  @item %no_lines
 @c Don't generate any @code{#line} preprocessor commands in the parser  
 @c file.  Ordinarily Bison writes these commands in the parser file so that  
 @c the C compiler and debuggers will associate errors and object code with  
 @c your source file (the grammar file).  This directive causes them to  
 @c associate errors with the parser file, treating it an independent source  
 @c file in its own right.  
 構文解析器ファイルに、@code{#line}プリプロセッサディレクティブを生成しません。  構文解析器ファイルに、@code{#line}プリプロセッサディレクティブを生成しません。
 Bisonは、通常、Cコンパイラとデバッガがエラーとあなたのソースファイル  Bisonは、通常、Cコンパイラとデバッガがエラーとあなたのソースファイル
 (文法ファイル)を関連づけられるように、構文解析器ファイルに  (文法ファイル)を関連づけられるように、構文解析器ファイルに
Line 5385  Bisonは、通常、Cコンパイラとデバッガがエ Line 3600  Bisonは、通常、Cコンパイラとデバッガがエ
 みなすことを意味します。  みなすことを意味します。
 @item %raw  @item %raw
 @c The output file @file{@var{name}.h} normally defines the tokens with  
 @c Yacc-compatible token numbers.  If this option is specified, the  
 @c internal Bison numbers are used instead.  (Yacc-compatible numbers start  
 @c at 257 except for single character tokens; Bison assigns token numbers  
 @c sequentially for all tokens starting at 3.)  
 通常、出力ファイル@file{@var{name}.h}は、  通常、出力ファイル@file{@var{name}.h}は、
 Yacc互換トークン番号を定義します。  Yacc互換トークン番号を定義します。
 このオプションが指定されると、代わりに、Bison内部の番号が使われます  このオプションが指定されると、代わりに、Bison内部の番号が使われます
Line 5398  Yacc互換トークン番号を定義します。 Line 3607  Yacc互換トークン番号を定義します。
 Bison内部のトークン番号は常に3から始まる連番になります)。  Bison内部のトークン番号は常に3から始まる連番になります)。
 @item %token_table  @item %token_table
 @c Generate an array of token names in the parser file.  The name of the  
 @c array is @code{yytname}; @code{yytname[@var{i}]} is the name of the  
 @c token whose internal Bison token code number is @var{i}.  The first three  
 @c elements of @code{yytname} are always @code{"$"}, @code{"error"}, and  
 @c @code{"$illegal"}; after these come the symbols defined in the grammar  
 @c file.  
 構文解析器ファイルの中に、トークン名の表を生成します。  構文解析器ファイルの中に、トークン名の表を生成します。
 その表の名前は@code{yytname}で、@code{yytname[@var{i}]}が  その表の名前は@code{yytname}で、@code{yytname[@var{i}]}が
 Bison内部トークン番号@var{i}のトークンの名前です。  Bison内部トークン番号@var{i}のトークンの名前です。
 最初の3個の要素は常に、@code{"$"}、@code{"error"}、@code{"$illegal"}で、  最初の3個の要素は常に、@code{"$"}、@code{"error"}、@code{"$illegal"}で、
 この後に文法ファイルで定義された記号が続きます。  この後に文法ファイルで定義された記号が続きます。
 @c For single-character literal tokens and literal string tokens, the name  
 @c in the table includes the single-quote or double-quote characters: for  
 @c example, @code{"'+'"} is a single-character literal and @code{"\"<=\""}  
 @c is a literal string token.  All the characters of the literal string  
 @c token appear verbatim in the string found in the table; even  
 @c double-quote characters are not escaped.  For example, if the token  
 @c consists of three characters @samp{*"*}, its string in @code{yytname}  
 @c contains @samp{"*"*"}.  (In C, that would be written as  
 @c @code{"\"*\"*\""}).  
 表の中で、1文字リテラルトークンにはシングルクォート記号が、  表の中で、1文字リテラルトークンにはシングルクォート記号が、
 文字列リテラルトークンにはダブルクォート記号が含まれます。  文字列リテラルトークンにはダブルクォート記号が含まれます。
 たとえば、@code{"'+'"}は1文字リテラルトークンで、  たとえば、@code{"'+'"}は1文字リテラルトークンで、
Line 5431  Bison内部トークン番号@var{i}のトークンの Line 3623  Bison内部トークン番号@var{i}のトークンの
 @code{yytname}中の文字列は@samp{"*"*"}となります  @code{yytname}中の文字列は@samp{"*"*"}となります
 (Cでは@code{"\"*\"*\""}と書きます)。  (Cでは@code{"\"*\"*\""}と書きます)。
 @c When you specify @code{%token_table}, Bison also generates macro  
 @c definitions for macros @code{YYNTOKENS}, @code{YYNNTS}, and  
 @c @code{YYNRULES}, and @code{YYNSTATES}:  
 @code{%token_table}を指定すると、Bisonは、マクロ  @code{%token_table}を指定すると、Bisonは、マクロ
 @code{YYNTOKENS}、@code{YYNNTS}、@code{YYNRULES}、@code{YYNSTATES}の  @code{YYNTOKENS}、@code{YYNNTS}、@code{YYNRULES}、@code{YYNSTATES}の
 定義も生成します。  定義も生成します。
 @table @code  @table @code
 @c The highest token number, plus one.  
 最大のトークン番号+1。  最大のトークン番号+1。
 @item YYNNTS  @item YYNNTS
 @c The number of non-terminal symbols.  
 非終端記号の数。  非終端記号の数。
 @c The number of grammar rules,  
 文法規則の数。  文法規則の数。
 @c The number of parser states (@pxref{Parser States}).  
 構文解析器の状態の数(@pxref{Parser States})。  構文解析器の状態の数(@pxref{Parser States})。
 @end table  @end table
 @end table  @end table
 @c =====================================================================  
 @node Multiple Parsers,, Declarations, Grammar File  @node Multiple Parsers,, Declarations, Grammar File
 @c @section Multiple Parsers in the Same Program  
 @section 同一プログラム中の複数の構文解析器  @section 同一プログラム中の複数の構文解析器
 @c Most programs that use Bison parse only one language and therefore contain  
 @c only one Bison parser.  But what if you want to parse more than one  
 @c language with the same program?  Then you need to avoid a name conflict  
 @c between different definitions of @code{yyparse}, @code{yylval}, and so on.  
 Bisonを使うプログラムのほとんどは、言語を1つだけ構文解析し、  Bisonを使うプログラムのほとんどは、言語を1つだけ構文解析し、
 したがって、Bison構文解析器を1つだけ含みます。  したがって、Bison構文解析器を1つだけ含みます。
 しかし、1つのプログラムで2種類以上の言語を構文解析したいときは、  しかし、1つのプログラムで2種類以上の言語を構文解析したいときは、
 どうすればよいでしょうか? そうするためには、@code{yyparse}、@code{yylval}  どうすればよいでしょうか? そうするためには、@code{yyparse}、@code{yylval}
 などの2重定義の衝突を防ぐ必要があります。  などの2重定義の衝突を防ぐ必要があります。
 @c The easy way to do this is to use the option @samp{-p @var{prefix}}  
 @c (@pxref{Invocation, ,Invoking Bison}).   
 @c This renames the interface functions and  
 @c variables of the Bison parser to start with @var{prefix} instead of  
 @c @samp{yy}.  You can use this to give each parser distinct names that do  
 @c not conflict.  
 これを容易にする方法が、オプション@samp{-p @var{prefix}}の利用です  これを容易にする方法が、オプション@samp{-p @var{prefix}}の利用です
 (@pxref{Invocation, ,Invoking Bison})。  (@pxref{Invocation, ,Invoking Bison})。
 これによって、Bison構文解析器のインターフェイス関数と変数の名前が、  これによって、Bison構文解析器のインターフェイス関数と変数の名前が、
 @samp{yy}で始まる代わりに@var{prefix}で始まります。  @samp{yy}で始まる代わりに@var{prefix}で始まります。
 これでそれぞれの構文解析器に、衝突しないような異なる名前を与えられます。  これでそれぞれの構文解析器に、衝突しないような異なる名前を与えられます。
 @c The precise list of symbols renamed is @code{yyparse}, @code{yylex},  
 @c @code{yyerror}, @code{yynerrs}, @code{yylval}, @code{yychar} and  
 @c @code{yydebug}.  For example, if you use @samp{-p c}, the names become  
 @c @code{cparse}, @code{clex}, and so on.  
 変更される名前は、  変更される名前は、
 @code{yyparse}、@code{yylex}、@code{yyerror}、@code{yynerrs}、  @code{yyparse}、@code{yylex}、@code{yyerror}、@code{yynerrs}、
 @code{yylval}、@code{yychar}、@code{yydebug}で全部です。  @code{yylval}、@code{yychar}、@code{yydebug}で全部です。
 たとえば、@samp{-p c}オプションを使えば、これらの名前は、  たとえば、@samp{-p c}オプションを使えば、これらの名前は、
 @code{cparse}、@code{clex}などに変わります。  @code{cparse}、@code{clex}などに変わります。
 @c @strong{All the other variables and macros associated with Bison are not  
 @c renamed.} These others are not global; there is no conflict if the same  
 @c name is used in different parsers.  For example, @code{YYSTYPE} is not  
 @c renamed, but defining this in different ways in different parsers causes  
 @c no trouble (@pxref{Value Type, ,Data Types of Semantic Values}).  
 @strong{Bisonに関連する上記以外の変数とマクロのすべての  @strong{Bisonに関連する上記以外の変数とマクロのすべての
 名前は変わりません。}これらは、広域ではないので、  名前は変わりません。}これらは、広域ではないので、
 異なる構文解析器で同じ名前が使われても衝突しません。  異なる構文解析器で同じ名前が使われても衝突しません。
Line 5510  Bisonを使うプログラムのほとんどは、言語 Line 3668  Bisonを使うプログラムのほとんどは、言語
 この定義は構文解析器ごとに異なる方法で行われるので、問題ありません  この定義は構文解析器ごとに異なる方法で行われるので、問題ありません
 (@pxref{Value Type, ,Data Types of Semantic Values})。  (@pxref{Value Type, ,Data Types of Semantic Values})。
 @c The @samp{-p} option works by adding macro definitions to the beginning  
 @c of the parser source file, defining @code{yyparse} as  
 @c @code{@var{prefix}parse}, and so on.  This effectively substitutes one  
 @c name for the other in the entire parser file.  
 @samp{-p}オプションは、さらに、構文解析器ソースファイルの始めで、  @samp{-p}オプションは、さらに、構文解析器ソースファイルの始めで、
 @code{yyparse}を@code{@var{prefix}parse}と定義するように、  @code{yyparse}を@code{@var{prefix}parse}と定義するように、
 マクロを定義します。  マクロを定義します。
 この結果、構文解析器ソースファイル全体で、ある名前を別の名前に変えます。  この結果、構文解析器ソースファイル全体で、ある名前を別の名前に変えます。
 @c =====================================================================  
 @node Interface, Algorithm, Grammar File, Top  @node Interface, Algorithm, Grammar File, Top
 @c @chapter Parser C-Language Interface  
 @chapter 構文解析器のC言語インターフェイス  @chapter 構文解析器のC言語インターフェイス
 @cindex C-language interface  @cindex C-language interface
 @cindex interface  @cindex interface
 @cindex C言語インターフェイス  @cindex C言語インターフェイス
 @cindex インターフェイス  @cindex インターフェイス
 @c The Bison parser is actually a C function named @code{yyparse}.  Here we  
 @c describe the interface conventions of @code{yyparse} and the other  
 @c functions that it needs to use.  
 Bison構文解析器の正体は、@code{yyparse}という名前のCの関数です。  Bison構文解析器の正体は、@code{yyparse}という名前のCの関数です。
 ここでは、@code{yyparse}とほかに使う必要がある関数の間の  ここでは、@code{yyparse}とほかに使う必要がある関数の間の
 インターフェイスの方法を示します。  インターフェイスの方法を示します。
 @c Keep in mind that the parser uses many C identifiers starting with  
 @c @samp{yy} and @samp{YY} for internal purposes.  If you use such an  
 @c identifier (aside from those in this manual) in an action or in additional  
 @c C code in the grammar file, you are likely to run into trouble.  
 構文解析器の内部では、多くの@samp{yy}または@samp{YY}で始まるCの識別子が  構文解析器の内部では、多くの@samp{yy}または@samp{YY}で始まるCの識別子が
 使われていることに注意してください。  使われていることに注意してください。
 本書で説明しているものを除いて、そのような識別子を  本書で説明しているものを除いて、そのような識別子を
Line 5558  Bison構文解析器の正体は、@code{yyparse} Line 3700  Bison構文解析器の正体は、@code{yyparse}
 @end menu  @end menu
 @c =====================================================================  
 @node Parser Function, Lexical,  , Interface  @node Parser Function, Lexical,  , Interface
 @c @section The Parser Function @code{yyparse}  
 @section 構文解析器関数@code{yyparse}  @section 構文解析器関数@code{yyparse}
 @findex yyparse  @findex yyparse
 @c You call the function @code{yyparse} to cause parsing to occur.  This  
 @c function reads tokens, executes actions, and ultimately returns when it  
 @c encounters end-of-input or an unrecoverable syntax error.  You can also  
 @c write an action which directs @code{yyparse} to return immediately without  
 @c reading further.  
 構文解析を始めるには、関数@code{yyparse}を呼び出します。  構文解析を始めるには、関数@code{yyparse}を呼び出します。
 この関数は、トークンを読み、アクションを実行し、最後には入力ファイルの  この関数は、トークンを読み、アクションを実行し、最後には入力ファイルの
 終わりに達するか回復不可能な構文エラーに達して、戻ります。  終わりに達するか回復不可能な構文エラーに達して、戻ります。
 読み込みを打ち切って@code{yyparse}関数から戻るような  読み込みを打ち切って@code{yyparse}関数から戻るような
 アクションを書くことも可能です。  アクションを書くことも可能です。
 @c The value returned by @code{yyparse} is 0 if parsing was successful (return  
 @c is due to end-of-input).  
 構文解析が成功する、つまり入力ファイルの終わりに達すると、  構文解析が成功する、つまり入力ファイルの終わりに達すると、
 @code{yyparse}からの戻り値が0になります。  @code{yyparse}からの戻り値が0になります。
 @c The value is 1 if parsing failed (return is due to a syntax error).  
 構文解析が失敗する、つまり構文エラーが発生すると、  構文解析が失敗する、つまり構文エラーが発生すると、
 戻り値が1になります。  戻り値が1になります。
 @c In an action, you can cause immediate return from @code{yyparse} by using  
 @c these macros:  
 アクションの中で、次のマクロを使って、  アクションの中で、次のマクロを使って、
 @code{yyparse}からただちに戻れます。  @code{yyparse}からただちに戻れます。
 @table @code  @table @code
 @findex YYACCEPT  @findex YYACCEPT
 @c Return immediately with value 0 (to report success).  
 成功の印である戻り値0をともなって、ただちに戻ります。  成功の印である戻り値0をともなって、ただちに戻ります。
 @item YYABORT  @item YYABORT
 @findex YYABORT  @findex YYABORT
 @c Return immediately with value 1 (to report failure).  
 失敗の印である戻り値1をともなって、ただちに戻ります。  失敗の印である戻り値1をともなって、ただちに戻ります。
 @end table  @end table
 @c =====================================================================  
 @node Lexical, Error Reporting, Parser Function, Interface  @node Lexical, Error Reporting, Parser Function, Interface
 @c @section The Lexical Analyzer Function @code{yylex}  
 @section 字句解析器関数@code{yylex}  @section 字句解析器関数@code{yylex}
 @findex yylex  @findex yylex
 @cindex lexical analyzer  @cindex lexical analyzer
 @cindex 字句解析器  @cindex 字句解析器
 @c The @dfn{lexical analyzer} function, @code{yylex}, recognizes tokens from  
 @c the input stream and returns them to the parser.  Bison does not create  
 @c this function automatically; you must write it so that @code{yyparse} can  
 @c call it.  The function is sometimes referred to as a lexical scanner.  
 @dfn{字句解析器(lexical analyzer)}関数@code{yylex}は、  @dfn{字句解析器(lexical analyzer)}関数@code{yylex}は、
 入力からトークンを認識し、構文解析器に返します。  入力からトークンを認識し、構文解析器に返します。
 Bisonはこの関数を自動的に生成しないので、  Bisonはこの関数を自動的に生成しないので、
 @code{yyparse}から呼び出されるように@code{yylex}を書く必要があります。  @code{yyparse}から呼び出されるように@code{yylex}を書く必要があります。
 関数@code{yylex}は``lexical scanner''と呼ばれることもあります。  関数@code{yylex}は``lexical scanner''と呼ばれることもあります。
 @c In simple programs, @code{yylex} is often defined at the end of the Bison  
 @c grammar file.  If @code{yylex} is defined in a separate source file, you  
 @c need to arrange for the token-type macro definitions to be available there.  
 @c To do this, use the @samp{-d} option when you run Bison, so that it will  
 @c write these macro definitions into a separate header file  
 @c @file{@var{name}.tab.h} which you can include in the other source files  
 @c that need it.  @xref{Invocation, ,Invoking Bison}.@refill  
 単純なプログラムでは、よく文法ファイルの最後で@code{yylex}を  単純なプログラムでは、よく文法ファイルの最後で@code{yylex}を
 定義します。@code{yylex}が別のソースファイルの中で定義する場合は、  定義します。@code{yylex}が別のソースファイルの中で定義する場合は、
 そこでトークン型マクロ定義を使えるように準備する必要があります。  そこでトークン型マクロ定義を使えるように準備する必要があります。
Line 5654  Bisonはこの関数を自動的に生成しないので Line 3763  Bisonはこの関数を自動的に生成しないので
 @end menu  @end menu
 @c =====================================================================  
 @node Calling Convention, Token Values,  , Lexical  @node Calling Convention, Token Values,  , Lexical
 @c @subsection Calling Convention for @code{yylex}  
 @subsection @code{yylex}を呼び出す方法  @subsection @code{yylex}を呼び出す方法
 @c The value that @code{yylex} returns must be the numeric code for the type  
 @c of token it has just found, or 0 for end-of-input.  
 @code{yylex}が返す値は、見つかったトークンの型に対する番号で、  @code{yylex}が返す値は、見つかったトークンの型に対する番号で、
 入力ファイルの終わりに達した場合には0を返します。  入力ファイルの終わりに達した場合には0を返します。
 @c When a token is referred to in the grammar rules by a name, that name  
 @c in the parser file becomes a C macro whose definition is the proper  
 @c numeric code for that token type.  So @code{yylex} can use the name  
 @c to indicate that type.  @xref{Symbols}.  
 トークンが文法規則の中で名前で参照される場合、  トークンが文法規則の中で名前で参照される場合、
 構文解析器ファイルの中でのその名前は、  構文解析器ファイルの中でのその名前は、
 トークン型に対する適切な番号にCのマクロとして定義されます。  トークン型に対する適切な番号にCのマクロとして定義されます。
 したがって、@code{yylex}は型を示すためにその名前を使用できます。  したがって、@code{yylex}は型を示すためにその名前を使用できます。
 @xref{Symbols}。  @xref{Symbols}。
 @c When a token is referred to in the grammar rules by a character literal,  
 @c the numeric code for that character is also the code for the token type.  
 @c So @code{yylex} can simply return that character code.  The null character  
 @c must not be used this way, because its code is zero and that is what  
 @c signifies end-of-input.  
 文法規則の中でトークンが1文字リテラルとして参照される場合には、  文法規則の中でトークンが1文字リテラルとして参照される場合には、
 その文字の文字符号がトークン型に対する番号でもあります。  その文字の文字符号がトークン型に対する番号でもあります。
 そこで、@code{yylex}は、単純に文字符号を返します。  そこで、@code{yylex}は、単純に文字符号を返します。
 しかし、戻り値0は入力ファイルの終わりを意味するので、  しかし、戻り値0は入力ファイルの終わりを意味するので、
 ヌル文字(@code{'\0'})の文字符号を返してはいけません。  ヌル文字(@code{'\0'})の文字符号を返してはいけません。
 @c Here is an example showing these things:  
 以下に例を示します。  以下に例を示します。
 @example  @example
 yylex ()  yylex ()
 @{  @{
   @dots{}    @dots{}
 @c   if (c == EOF)     /* Detect end of file. */  
   if (c == EOF)     /* ファイルの終わりか調べる。 */    if (c == EOF)     /* ファイルの終わりか調べる。 */
     return 0;      return 0;
   @dots{}    @dots{}
   if (c == '+' || c == '-')    if (c == '+' || c == '-')
 @c     return c;      /* Assume token type for `+' is '+'. */  
     return c;      /* `+' に対するトークン型が '+' であると仮定する。 */      return c;      /* `+' に対するトークン型が '+' であると仮定する。 */
   @dots{}    @dots{}
 @c   return INT;      /* Return the type of the token. */  
   return INT;      /* トークン型を返す。 */    return INT;      /* トークン型を返す。 */
   @dots{}    @dots{}
 @}  @}
 @end example  @end example
 @c @noindent  
 @c This interface has been designed so that the output from the @code{lex}  
 @c utility can be used without change as the definition of @code{yylex}.  
 このようなインターフェイスは、  このようなインターフェイスは、
 @code{lex}が生成した字句解析器を、  @code{lex}が生成した字句解析器を、
 @code{yylex}の定義を変えずに使えるように設計されています。  @code{yylex}の定義を変えずに使えるように設計されています。
 @c If the grammar uses literal string tokens, there are two ways that  
 @c @code{yylex} can determine the token type codes for them:  
 文法規則が文字列リテラルトークンを使っている場合には、  文法規則が文字列リテラルトークンを使っている場合には、
 @code{yylex}がそれに対するトークン型番号を使う、  @code{yylex}がそれに対するトークン型番号を使う、
 2つの方法があります。  2つの方法があります。
 @itemize @bullet  @itemize @bullet
 @item  @item
 @c If the grammar defines symbolic token names as aliases for the  
 @c literal string tokens, @code{yylex} can use these symbolic names like  
 @c all others.  In this case, the use of the literal string tokens in  
 @c the grammar file has no effect on @code{yylex}.  
 文法が文字列リテラルトークンに対する別名として記号トークン名を  文法が文字列リテラルトークンに対する別名として記号トークン名を
 定義しているならば、@code{yylex}はその記号名を他のトークンの記号名と  定義しているならば、@code{yylex}はその記号名を他のトークンの記号名と
 同様に使えます。この場合、文法ファイルの中での文字列リテラルトークンの  同様に使えます。この場合、文法ファイルの中での文字列リテラルトークンの
 利用は、@code{yylex}にまったく影響しません。  利用は、@code{yylex}にまったく影響しません。
 @item  @item
 @c @code{yylex} can find the multi-character token in the @code{yytname}  
 @c table.  The index of the token in the table is the token type's code.  
 @c The name of a multi-character token is recorded in @code{yytname} with a  
 @c double-quote, the token's characters, and another double-quote.  The  
 @c token's characters are not escaped in any way; they appear verbatim in  
 @c the contents of the string in the table.  
 @code{yylex}は、@code{yytname}表の中で、  @code{yylex}は、@code{yytname}表の中で、
 複数文字トークンを見つけられます。  複数文字トークンを見つけられます。
 トークンに対する表の添え字は、そのトークン型の番号です。  トークンに対する表の添え字は、そのトークン型の番号です。
Line 5753  yylex () Line 3822  yylex ()
 トークンに含まれる文字はエスケープされず、  トークンに含まれる文字はエスケープされず、
 表の中の文字列にそのまま書き込まれています。  表の中の文字列にそのまま書き込まれています。
 @c Here's code for looking up a token in @code{yytname}, assuming that the  
 @c characters of the token are stored in @code{token_buffer}.  
 トークンを構成する文字列が@code{token_buffer}に記憶されていると仮定して、  トークンを構成する文字列が@code{token_buffer}に記憶されていると仮定して、
 @code{yytname}からトークンを探し出すプログラムを示します。  @code{yytname}からトークンを探し出すプログラムを示します。
Line 5772  for (i = 0; i < YYNTOKENS; i++) Line 3838  for (i = 0; i < YYNTOKENS; i++)
   @}    @}
 @end smallexample  @end smallexample
 @c The @code{yytname} table is generated only if you use the  
 @c @code{%token_table} declaration.  @xref{Decl Summary}.  
 @code{yytname}表は、@code{%token_table}宣言をした場合にのみ生成されます。  @code{yytname}表は、@code{%token_table}宣言をした場合にのみ生成されます。
 @xref{Decl Summary}。  @xref{Decl Summary}。
 @end itemize  @end itemize
 @c =====================================================================  
 @node Token Values, Token Positions, Calling Convention, Lexical  @node Token Values, Token Positions, Calling Convention, Lexical
 @c @subsection Semantic Values of Tokens  
 @subsection トークンの意味値  @subsection トークンの意味値
 @vindex yylval  @vindex yylval
 @c In an ordinary (nonreentrant) parser, the semantic value of the token must  
 @c be stored into the global variable @code{yylval}.  When you are using  
 @c just one data type for semantic values, @code{yylval} has that type.  
 @c Thus, if the type is @code{int} (the default), you might write this in  
 @c @code{yylex}:  
 通常の再入可能でない構文解析器では、  通常の再入可能でない構文解析器では、
 トークンの意味値が広域変数@code{yylval}に代入される必要があります。  トークンの意味値が広域変数@code{yylval}に代入される必要があります。
 意味値に対してただ1つのデータ型を使っている場合には、  意味値に対してただ1つのデータ型を使っている場合には、
Line 5803  for (i = 0; i < YYNTOKENS; i++) Line 3858  for (i = 0; i < YYNTOKENS; i++)
 @example  @example
 @group  @group
   @dots{}    @dots{}
 @c   yylval = value;  /* Put value onto Bison stack. */  
   yylval = value;  /* 値をBisonスタックに積む。 */    yylval = value;  /* 値をBisonスタックに積む。 */
 @c   return INT;      /* Return the type of the token. */  
   return INT;      /* トークン型を返す。 */    return INT;      /* トークン型を返す。 */
   @dots{}    @dots{}
 @end group  @end group
 @end example  @end example
 @c When you are using multiple data types, @code{yylval}'s type is a union  
 @c made from the @code{%union} declaration  
 @c (@pxref{Union Decl, ,The Collection of Value Types}).  So when  
 @c you store a token's value, you must use the proper member of the union.  
 @c If the @code{%union} declaration looks like this:  
 複数のデータ型を使っている場合には、  複数のデータ型を使っている場合には、
 @code{%union}宣言で作られた共用体が@code{yylval}の型になります  @code{%union}宣言で作られた共用体が@code{yylval}の型になります
 (@pxref{Union Decl, ,The Collection of Value Types})。  (@pxref{Union Decl, ,The Collection of Value Types})。
Line 5834  for (i = 0; i < YYNTOKENS; i++) Line 3881  for (i = 0; i < YYNTOKENS; i++)
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c then the code in @code{yylex} might look like this:  
 すると、@code{yylex}の中のプログラムは次のようになります。  すると、@code{yylex}の中のプログラムは次のようになります。
 @example  @example
 @group  @group
   @dots{}    @dots{}
 @c   yylval.intval = value; /* Put value onto Bison stack. */  
   yylval.intval = value; /* 値をBisonスタックに積む。 */    yylval.intval = value; /* 値をBisonスタックに積む。 */
 @c   return INT;          /* Return the type of the token. */  
   return INT;          /* トークン型を返す。 */    return INT;          /* トークン型を返す。 */
   @dots{}    @dots{}
 @end group  @end group
 @end example  @end example
 @c =====================================================================  
 @node Token Positions, Pure Calling, Token Values, Lexical  @node Token Positions, Pure Calling, Token Values, Lexical
 @c @subsection Textual Positions of Tokens  
 @subsection トークンのテキスト中の位置  @subsection トークンのテキスト中の位置
 @vindex yylloc  @vindex yylloc
 @c If you are using the @samp{@@@var{n}}-feature  
 @c (@pxref{Action Features, ,Special Features for Use in Actions}) in  
 @c actions to keep track of the textual locations of tokens and groupings,  
 @c then you must provide this information in @code{yylex}.  The function  
 @c @code{yyparse} expects to find the textual location of a token just parsed  
 @c in the global variable @code{yylloc}.  So @code{yylex} must store the  
 @c proper data in that variable.  The value of @code{yylloc} is a structure  
 @c and you need only initialize the members that are going to be used by the  
 @c actions.  The four members are called @code{first_line},  
 @c @code{first_column}, @code{last_line} and @code{last_column}.  Note that  
 @c the use of this feature makes the parser noticeably slower.  
 アクションの中で@samp{@@@var{n}}機能  アクションの中で@samp{@@@var{n}}機能
 (@pxref{Action Features, ,Special Features for Use in Actions})を  (@pxref{Action Features, ,Special Features for Use in Actions})を
 使っている場合には、トークンとグループのテキスト中の位置を  使っている場合には、トークンとグループのテキスト中の位置を
Line 5883  for (i = 0; i < YYNTOKENS; i++) Line 3911  for (i = 0; i < YYNTOKENS; i++)
 この機能を使うと、構文解析器が著しく遅くなることに注意してください。  この機能を使うと、構文解析器が著しく遅くなることに注意してください。
 @tindex YYLTYPE  @tindex YYLTYPE
 @c The data type of @code{yylloc} has the name @code{YYLTYPE}.  
 @code{yylloc}のデータ型は、@code{YYLTYPE}という名前を持っています。  @code{yylloc}のデータ型は、@code{YYLTYPE}という名前を持っています。
 @c =====================================================================  
 @node Pure Calling,  , Token Positions, Lexical  @node Pure Calling,  , Token Positions, Lexical
 @c @subsection Calling Conventions for Pure Parsers  
 @subsection 再入可能構文解析器を呼び出す方法  @subsection 再入可能構文解析器を呼び出す方法
 @c When you use the Bison declaration @code{%pure_parser} to request a  
 @c pure, reentrant parser, the global communication variables @code{yylval}  
 @c and @code{yylloc} cannot be used.  (@xref{Pure Decl, ,A Pure (Reentrant)  
 @c Parser}.)  In such parsers the two global variables are replaced by  
 @c pointers passed as arguments to @code{yylex}.  You must declare them as  
 @c shown here, and pass the information back by storing it through those  
 @c pointers.  
 純粋な、つまり再入可能な、構文解析器を生成するために、  純粋な、つまり再入可能な、構文解析器を生成するために、
 @code{%pure_parser}をBison宣言すると、広域変数@code{yylval}と  @code{%pure_parser}をBison宣言すると、広域変数@code{yylval}と
 @code{yylloc}を使えなくなります  @code{yylloc}を使えなくなります
Line 5916  yylex (lvalp, llocp) Line 3932  yylex (lvalp, llocp)
      YYLTYPE *llocp;       YYLTYPE *llocp;
 @{  @{
   @dots{}    @dots{}
 @c   *lvalp = value;  /* Put value onto Bison stack.  */  
   *lvalp = value;  /* 値をBisonスタックに積む。  */    *lvalp = value;  /* 値をBisonスタックに積む。  */
 @c   return INT;      /* Return the type of the token.  */  
   return INT;      /* トークン型を返す。 */    return INT;      /* トークン型を返す。 */
   @dots{}    @dots{}
 @}  @}
 @end example  @end example
 @c If the grammar file does not use the @samp{@@} constructs to refer to  
 @c textual positions, then the type @code{YYLTYPE} will not be defined.  In  
 @c this case, omit the second argument; @code{yylex} will be called with  
 @c only one argument.  
 文法ファイルがテキスト中の位置を参照するための@samp{@@}機能を  文法ファイルがテキスト中の位置を参照するための@samp{@@}機能を
 使っていない場合は、@code{YYLTYPE}は定義されません。  使っていない場合は、@code{YYLTYPE}は定義されません。
 この場合、第2引数を省略し、@code{yylex}は  この場合、第2引数を省略し、@code{yylex}は
 1個の引数をともなって呼び出されます。  1個の引数をともなって呼び出されます。
 @c If you use a reentrant parser, you can optionally pass additional  
 @c parameter information to it in a reentrant way.  To do so, define the  
 @c macro @code{YYPARSE_PARAM} as a variable name.  This modifies the  
 @c @code{yyparse} function to accept one argument, of type @code{void *},  
 @c with that name.  
 再入可能な構文解析器を使っている場合、  再入可能な構文解析器を使っている場合、
 再入可能な方法で構文解析器に追加の引数を渡す方法があります。  再入可能な方法で構文解析器に追加の引数を渡す方法があります。
 そのためには、マクロ@code{YYPARSE_PARAM}を変数名として定義します。  そのためには、マクロ@code{YYPARSE_PARAM}を変数名として定義します。
 すると、関数@code{yyparse}は、定義された名前で、型が@code{void *}の  すると、関数@code{yyparse}は、定義された名前で、型が@code{void *}の
 追加の引数を受け取ります。  追加の引数を受け取ります。
 @c When you call @code{yyparse}, pass the address of an object, casting the  
 @c address to @code{void *}.  The grammar actions can refer to the contents  
 @c of the object by casting the pointer value back to its proper type and  
 @c then dereferencing it.  Here's an example.  Write this in the parser:  
 @code{yyparse}を呼び出すときに、オブジェクトの番地を  @code{yyparse}を呼び出すときに、オブジェクトの番地を
 @code{void *}型にキャストして渡します。  @code{void *}型にキャストして渡します。
 文法のアクションは、ポインタを適切な型へのポインタへキャストし、  文法のアクションは、ポインタを適切な型へのポインタへキャストし、
Line 5970  struct parser_control Line 3968  struct parser_control
 %@}  %@}
 @end example  @end example
 @c @noindent  
 @c Then call the parser like this:  
 次のように構文解析器を呼び出します。  次のように構文解析器を呼び出します。
 @example  @example
Line 5985  struct parser_control Line 3981  struct parser_control
 @{  @{
   struct parser_control foo;    struct parser_control foo;
 @c  @dots{}  /* @r{Store proper data in @code{foo}.}  */  
   @dots{}  /* @r{@code{foo}に正しいデータを記憶}  */    @dots{}  /* @r{@code{foo}に正しいデータを記憶}  */
   value = yyparse ((void *) &foo);    value = yyparse ((void *) &foo);
   @dots{}    @dots{}
 @}  @}
 @end example  @end example
 @c @noindent  
 @c In the grammar actions, use expressions like this to refer to the data:  
 文法アクションの中では、データを参照するために次のような式を使います。  文法アクションの中では、データを参照するために次のような式を使います。
 @example  @example
Line 6002  struct parser_control Line 3994  struct parser_control
 @end example  @end example
 @vindex YYLEX_PARAM  @vindex YYLEX_PARAM
 @c If you wish to pass the additional parameter data to @code{yylex},  
 @c define the macro @code{YYLEX_PARAM} just like @code{YYPARSE_PARAM}, as  
 @c shown here:  
 @code{yylex}に追加の引数を渡したい場合には、  @code{yylex}に追加の引数を渡したい場合には、
 @code{YYPARSE_PARAM}と同様に、マクロ@code{YYLEX_PARAM}を定義します。  @code{YYPARSE_PARAM}と同様に、マクロ@code{YYLEX_PARAM}を定義します。
 例を示します。  例を示します。
Line 6023  struct parser_control Line 4011  struct parser_control
 %@}  %@}
 @end example  @end example
 @c You should then define @code{yylex} to accept one additional  
 @c argument---the value of @code{parm}.  (This makes either two or three  
 @c arguments in total, depending on whether an argument of type  
 @c @code{YYLTYPE} is passed.)  You can declare the argument as a pointer to  
 @c the proper object type, or you can declare it as @code{void *} and  
 @c access the contents as shown above.  
 そして、@code{yylex}が追加の引数、@code{parm}の値を受け取るように、  そして、@code{yylex}が追加の引数、@code{parm}の値を受け取るように、
 @code{yylex}を定義する必要があります  @code{yylex}を定義する必要があります
 (型@code{YYLTYPE}のどの引数が渡されるかに応じて、  (型@code{YYLTYPE}のどの引数が渡されるかに応じて、
Line 6037  struct parser_control Line 4018  struct parser_control
 引数を正しいオブジェクト型として宣言できます。すなわち@code{void *}として  引数を正しいオブジェクト型として宣言できます。すなわち@code{void *}として
 宣言し、上記の番地を参照できます。  宣言し、上記の番地を参照できます。
 @c You can use @samp{%pure_parser} to request a reentrant parser without  
 @c also using @code{YYPARSE_PARAM}.  Then you should call @code{yyparse}  
 @c with no arguments, as usual.  
 @code{YYPARSE_PARAM}を使わずに、@samp{%pure_parser}を使って、  @code{YYPARSE_PARAM}を使わずに、@samp{%pure_parser}を使って、
 再入可能な構文解析器を生成することも可能です。  再入可能な構文解析器を生成することも可能です。
 その場合、引数をつけずに@code{yyparse}を呼び出すべきです。  その場合、引数をつけずに@code{yyparse}を呼び出すべきです。
 @c =====================================================================  
 @node Error Reporting, Action Features, Lexical, Interface  @node Error Reporting, Action Features, Lexical, Interface
 @c @section The Error Reporting Function @code{yyerror}  
 @section エラー報告関数@code{yyerror}  @section エラー報告関数@code{yyerror}
 @cindex error reporting function  @cindex error reporting function
 @findex yyerror  @findex yyerror
Line 6058  struct parser_control Line 4033  struct parser_control
 @cindex 構文解析エラー  @cindex 構文解析エラー
 @cindex 文法エラー  @cindex 文法エラー
 @c The Bison parser detects a @dfn{parse error} or @dfn{syntax error}  
 @c whenever it reads a token which cannot satisfy any syntax rule.  A  
 @c action in the grammar can also explicitly proclaim an error, using the  
 @c macro @code{YYERROR}  
 @c (@pxref{Action Features, ,Special Features for Use in Actions}).  
 Bison構文解析器は、文法規則に適合しないトークンを読むたびに、  Bison構文解析器は、文法規則に適合しないトークンを読むたびに、
 @dfn{構文解析エラー(parse error)}すなわち@dfn{文法エラー(syntax error)}を  @dfn{構文解析エラー(parse error)}すなわち@dfn{文法エラー(syntax error)}を
 検出します。文法中のアクションは、マクロ@code{YYERROR}を使って、  検出します。文法中のアクションは、マクロ@code{YYERROR}を使って、
 明示的にエラーを示せます  明示的にエラーを示せます
 (@pxref{Action Features, ,Special Features for Use in Actions})。  (@pxref{Action Features, ,Special Features for Use in Actions})。
 @c The Bison parser expects to report the error by calling an error  
 @c reporting function named @code{yyerror}, which you must supply.  It is  
 @c called by @code{yyparse} whenever a syntax error is found, and it  
 @c receives one argument.  For a parse error, the string is normally  
 @c @w{@code{"parse error"}}.  
 Bison構文解析器は、@code{yyerror}という名前の関数を使って、  Bison構文解析器は、@code{yyerror}という名前の関数を使って、
 エラーを報告するようになっています。  エラーを報告するようになっています。
 事前に用意が必要な  事前に用意が必要な
Line 6084  Bison構文解析器は、@code{yyerror}という Line 4047  Bison構文解析器は、@code{yyerror}という
 構文解析エラーに対して、引数の文字列は通常@w{@code{"parse error"}}です。  構文解析エラーに対して、引数の文字列は通常@w{@code{"parse error"}}です。
 @c If you define the macro @code{YYERROR_VERBOSE} in the Bison declarations  
 @c section (@pxref{Bison Declarations, ,The Bison Declarations Section}),  
 @c then Bison provides a more verbose  
 @c and specific error message string instead of just plain @w{@code{"parse  
 @c error"}}.  It doesn't matter what definition you use for  
 @c @code{YYERROR_VERBOSE}, just whether you define it.  
 Bison定義部(@pxref{Bison Declarations, ,The Bison Declarations Section})で、  Bison定義部(@pxref{Bison Declarations, ,The Bison Declarations Section})で、
 マクロ@code{YYERROR_VERBOSE}を定義すると、  マクロ@code{YYERROR_VERBOSE}を定義すると、
 @w{@code{"parse error"}}の代わりに、  @w{@code{"parse error"}}の代わりに、
 エラーを詳細に報告する文字列が用意されます。  エラーを詳細に報告する文字列が用意されます。
 マクロ@code{YYERROR_VERBOSE}の定義はなんでもかまいません。  マクロ@code{YYERROR_VERBOSE}の定義はなんでもかまいません。
 @c The parser can detect one other kind of error: stack overflow.  This  
 @c happens when the input contains constructions that are very deeply  
 @c nested.  It isn't likely you will encounter this, since the Bison  
 @c parser extends its stack automatically up to a very large limit.  But  
 @c if overflow happens, @code{yyparse} calls @code{yyerror} in the usual  
 @c fashion, except that the argument string is @w{@code{"parser stack  
 @c overflow"}}.  
 構文解析器は、もう1種類のエラーであるスタックオーバーフローを検出する  構文解析器は、もう1種類のエラーであるスタックオーバーフローを検出する
 可能性があります。これは、入力がきわめて深い入れ子からなっていると  可能性があります。これは、入力がきわめて深い入れ子からなっていると
 起こることがあります。Bison構文解析器は自動的にスタックの限界を大きく拡張し  起こることがあります。Bison構文解析器は自動的にスタックの限界を大きく拡張し
Line 6113  Bison定義部(@pxref{Bison Declarations,  Line 4061  Bison定義部(@pxref{Bison Declarations, 
 @w{@code{"parser stack overflow"}}という  @w{@code{"parser stack overflow"}}という
 文字列の引数をともなって、@code{yyerror}が呼び出されます。  文字列の引数をともなって、@code{yyerror}が呼び出されます。
 @c The following definition suffices in simple programs:  
 単純なプログラムでは、次の例のように@code{yyerror}を定義できます。  単純なプログラムでは、次の例のように@code{yyerror}を定義できます。
 @example  @example
Line 6129  yyerror (s) Line 4075  yyerror (s)
 @end group  @end group
 @end example  @end example
 @c After @code{yyerror} returns to @code{yyparse}, the latter will attempt  
 @c error recovery if you have written suitable error recovery grammar rules  
 @c (@pxref{Error Recovery}).  If recovery is impossible, @code{yyparse} will  
 @c immediately return 1.  
 @code{yyerror}から戻った後、@code{yyparse}は、  @code{yyerror}から戻った後、@code{yyparse}は、
 適切なエラー回復文法規則(@pxref{Error Recovery})があれば、  適切なエラー回復文法規則(@pxref{Error Recovery})があれば、
 エラーからの回復を試みます。  エラーからの回復を試みます。
 もし、回復が不可能ならば、@code{yyparse}は即座に1を返します。  もし、回復が不可能ならば、@code{yyparse}は即座に1を返します。
 @vindex yynerrs  @vindex yynerrs
 @c The variable @code{yynerrs} contains the number of syntax errors  
 @c encountered so far.  Normally this variable is global; but if you  
 @c request a pure parser  
 @c (@pxref{Pure Decl, ,A Pure (Reentrant) Parser}) then it is a local variable  
 @c which only the actions can access.  
 変数@code{yynerrs}には、それまでに出くわした文法エラーの数が記憶されています。  変数@code{yynerrs}には、それまでに出くわした文法エラーの数が記憶されています。
 通常、この変数は広域変数です。  通常、この変数は広域変数です。
 しかし、再入可能な構文解析器(@pxref{Pure Decl, ,A Pure (Reentrant) Parser})  しかし、再入可能な構文解析器(@pxref{Pure Decl, ,A Pure (Reentrant) Parser})
 を生成した場合には、アクションからのみ参照可能な局所変数になります。  を生成した場合には、アクションからのみ参照可能な局所変数になります。
 @c =====================================================================  
 @node Action Features,  , Error Reporting, Interface  @node Action Features,  , Error Reporting, Interface
 @c @section Special Features for Use in Actions  
 @section アクション中で使える特別な機能  @section アクション中で使える特別な機能
 @cindex summary, action features  @cindex summary, action features
 @cindex action fetures summary  @cindex action fetures summary
 @cindex 要約, アクション  @cindex 要約, アクション
 @cindex アクションの要約  @cindex アクションの要約
 @c Here is a table of Bison constructs, variables and macros that  
 @c are useful in actions.  
 ここの表では、アクション中で有用な、Bisonの構造物、変数、  ここの表では、アクション中で有用な、Bisonの構造物、変数、
 マクロを示します。  マクロを示します。
 @table @samp  @table @samp
 @item $$  @item $$
 @c Acts like a variable that contains the semantic value for the  
 @c grouping made by the current rule.  @xref{Actions}.  
 現在の規則で作られるグループに対する意味値を保持する変数のように働きます。  現在の規則で作られるグループに対する意味値を保持する変数のように働きます。
 @xref{Actions}。  @xref{Actions}。
 @item $@var{n}  @item $@var{n}
 @c Acts like a variable that contains the semantic value for the  
 @c @var{n}th component of the current rule.  @xref{Actions}.  
 現在の規則の@var{n}番目の構成要素に対する意味値を保持する変数のように  現在の規則の@var{n}番目の構成要素に対する意味値を保持する変数のように
 働きます。@xref{Actions}。  働きます。@xref{Actions}。
 @item $<@var{typealt}>$  @item $<@var{typealt}>$
 @c Like @code{$$} but specifies alternative @var{typealt} in the union  
 @c specified by the @code{%union} declaration.  
 @c @xref{Action Types, ,Data Types of Values in Actions}.  
 @code{$$}に似ていますが、@code{%union}宣言で指定された共用体の中の  @code{$$}に似ていますが、@code{%union}宣言で指定された共用体の中の
 @var{typealt}を選びます。  @var{typealt}を選びます。
 @xref{Action Types, ,Data Types of Values in Actions}。  @xref{Action Types, ,Data Types of Values in Actions}。
 @item $<@var{typealt}>@var{n}  @item $<@var{typealt}>@var{n}
 @c Like @code{$@var{n}} but specifies alternative @var{typealt} in the  
 @c union specified by the @code{%union} declaration.    
 @c @xref{Action Types, ,Data Types of Values in Actions}.@refill  
 @code{$@var{n}}に似ていますが、@code{%union}宣言で指定された共用体の中の  @code{$@var{n}}に似ていますが、@code{%union}宣言で指定された共用体の中の
 @var{typealt}を選びます。  @var{typealt}を選びます。
 @xref{Action Types, ,Data Types of Values in Actions}。  @xref{Action Types, ,Data Types of Values in Actions}。
 @item YYABORT;  @item YYABORT;
 @c Return immediately from @code{yyparse}, indicating failure.  
 @c @xref{Parser Function, ,The Parser Function @code{yyparse}}.  
 @code{yyparse}からただちに戻り、失敗を示します。  @code{yyparse}からただちに戻り、失敗を示します。
 @xref{Parser Function, ,The Parser Function @code{yyparse}}。  @xref{Parser Function, ,The Parser Function @code{yyparse}}。
 @item YYACCEPT;  @item YYACCEPT;
 @c Return immediately from @code{yyparse}, indicating success.  
 @c @xref{Parser Function, ,The Parser Function @code{yyparse}}.  
 @code{yyparse}からただちに戻り、成功を示します。  @code{yyparse}からただちに戻り、成功を示します。
 @xref{Parser Function, ,The Parser Function @code{yyparse}}。  @xref{Parser Function, ,The Parser Function @code{yyparse}}。
 @item YYBACKUP (@var{token}, @var{value});  @item YYBACKUP (@var{token}, @var{value});
 @findex YYBACKUP  @findex YYBACKUP
 @c Unshift a token.  This macro is allowed only for rules that reduce  
 @c a single value, and only when there is no look-ahead token.  
 @c It installs a look-ahead token with token type @var{token} and  
 @c semantic value @var{value}; then it discards the value that was  
 @c going to be reduced by this rule.  
 トークンを逆シフトします。  トークンを逆シフトします。
 1個の値を還元する規則の中で、先読みトークンがない場合にのみ、  1個の値を還元する規則の中で、先読みトークンがない場合にのみ、
 このマクロが使えます。  このマクロが使えます。
 このマクロは、トークン型が@var{token}で意味値が@var{value}のトークンを、  このマクロは、トークン型が@var{token}で意味値が@var{value}のトークンを、
 先読みトークンとして格納し、この規則で還元されるはずだった値を捨てます。  先読みトークンとして格納し、この規則で還元されるはずだった値を捨てます。
 @c If the macro is used when it is not valid, such as when there is  
 @c a look-ahead token already, then it reports a syntax error with  
 @c a message @samp{cannot back up} and performs ordinary error  
 @c recovery.  
 先読みトークンがすでにあるような、このマクロが無効な状況で  先読みトークンがすでにあるような、このマクロが無効な状況で
 このマクロを使うと、メッセージ@samp{cannnot back up}をともなう  このマクロを使うと、メッセージ@samp{cannnot back up}をともなう
 文法エラーが報告され、通常のエラー回復が行われます。  文法エラーが報告され、通常のエラー回復が行われます。
 @c In either case, the rest of the action is not executed.  
 どちらの場合も、アクションの残りの部分は実行されません。  どちらの場合も、アクションの残りの部分は実行されません。
 @item YYEMPTY  @item YYEMPTY
 @vindex YYEMPTY  @vindex YYEMPTY
 @c Value stored in @code{yychar} when there is no look-ahead token.  
 先読みトークンがない場合に、変数@code{yychar}に記憶されている値です。  先読みトークンがない場合に、変数@code{yychar}に記憶されている値です。
 @item YYERROR;  @item YYERROR;
 @findex YYERROR  @findex YYERROR
 @c Cause an immediate syntax error.  This statement initiates error  
 @c recovery just as if the parser itself had detected an error; however, it  
 @c does not call @code{yyerror}, and does not print any message.  If you  
 @c want to print an error message, call @code{yyerror} explicitly before  
 @c the @samp{YYERROR;} statement.  @xref{Error Recovery}.  
 ただちに文法エラーを発生させます。この文は、構文解析器がエラーを検出したように  ただちに文法エラーを発生させます。この文は、構文解析器がエラーを検出したように
 エラー回復を始めますが、@code{yyerror}を呼び出さず、  エラー回復を始めますが、@code{yyerror}を呼び出さず、
 メッセージは表示されません。  メッセージは表示されません。
Line 6263  yyerror (s) Line 4152  yyerror (s)
 @xref{Error Recovery}。  @xref{Error Recovery}。
 @c This macro stands for an expression that has the value 1 when the parser  
 @c is recovering from a syntax error, and 0 the rest of the time.  
 @c @xref{Error Recovery}.  
 このマクロの値は、字句解析器が文法エラーからの回復中ならば1、  このマクロの値は、字句解析器が文法エラーからの回復中ならば1、
 そうでなければ0です。  そうでなければ0です。
 @xref{Error Recovery}。  @xref{Error Recovery}。
 @item yychar  @item yychar
 @c Variable containing the current look-ahead token.  (In a pure parser,  
 @c this is actually a local variable within @code{yyparse}.)  When there is  
 @c no look-ahead token, the value @code{YYEMPTY} is stored in the variable.  
 @c @xref{Look-Ahead, ,Look-Ahead Tokens}.  
 現在の先読みトークンを含んでいる変数です  現在の先読みトークンを含んでいる変数です
 (再入可能構文解析器では、@code{yyparse}の局所変数です)。  (再入可能構文解析器では、@code{yyparse}の局所変数です)。
 先読みトークンがない場合には、この変数に  先読みトークンがない場合には、この変数に
Line 6284  yyerror (s) Line 4164  yyerror (s)
 @xref{Look-Ahead, ,Look-Ahead Tokens}。  @xref{Look-Ahead, ,Look-Ahead Tokens}。
 @item yyclearin;  @item yyclearin;
 @c Discard the current look-ahead token.  This is useful primarily in  
 @c error rules.  @xref{Error Recovery}.  
 現在の先読みトークンを捨てます。エラー規則の中で有用です。  現在の先読みトークンを捨てます。エラー規則の中で有用です。
 @xref{Error Recovery}。  @xref{Error Recovery}。
 @item yyerrok;  @item yyerrok;
 @c Resume generating error messages immediately for subsequent syntax  
 @c errors.  This is useful primarily in error rules.    
 @c @xref{Error Recovery}.  
 後に続く文法エラーに対して、エラーメッセージの生成を再開します。  後に続く文法エラーに対して、エラーメッセージの生成を再開します。
 これは、エラー規則で特に重要です。  これは、エラー規則で特に重要です。
 @xref{Error Recovery}。  @xref{Error Recovery}。
 @item @@@var{n}  @item @@@var{n}
 @findex @@@var{n}  @findex @@@var{n}
 @c Acts like a structure variable containing information on the line  
 @c numbers and column numbers of the @var{n}th component of the current  
 @c rule.  The structure has four members, like this:  
 現在の規則の第@var{n}要素の、行番号と列番号を含む、  現在の規則の第@var{n}要素の、行番号と列番号を含む、
 配列変数のように働きます。  配列変数のように働きます。
 次のようなメンバがあります。  次のようなメンバがあります。
Line 6316  struct @{ Line 4185  struct @{
 @};  @};
 @end example  @end example
 @c  Thus, to get the starting line number of the third component, you would  
 @c  use @samp{@@3.first_line}.  
 たとえば、第3要素の開始行番号を知るには、  たとえば、第3要素の開始行番号を知るには、
 @samp{@@3.first_line}とします。  @samp{@@3.first_line}とします。
 @c In order for the members of this structure to contain valid information,  
 @c you must make @code{yylex} supply this information about each token.  
 @c If you need only certain members, then @code{yylex} need only fill in  
 @c those members.  
 この構造体のメンバを有効な情報にするためには、  この構造体のメンバを有効な情報にするためには、
 @code{yylex}がそれぞれのトークンに対して、  @code{yylex}がそれぞれのトークンに対して、
 情報を提供する必要があります。  情報を提供する必要があります。
Line 6335  struct @{ Line 4196  struct @{
 @footnote{【訳注】@code{yylex}は、変数@code{yylloc}に、  @footnote{【訳注】@code{yylex}は、変数@code{yylloc}に、
 トークンの位置情報を代入します。}  トークンの位置情報を代入します。}
 @c The use of this feature makes the parser noticeably slower.  
 この機能を使うと、字句解析器が著しく遅くなります。  この機能を使うと、字句解析器が著しく遅くなります。
 @end table  @end table
 @c =====================================================================  
 @node Algorithm, Error Recovery, Interface, Top  @node Algorithm, Error Recovery, Interface, Top
 @c @chapter The Bison Parser Algorithm   
 @chapter Bison構文解析器のアルゴリズム  @chapter Bison構文解析器のアルゴリズム
 @cindex Bison parser algorithm   @cindex Bison parser algorithm 
 @cindex algorithm of parser  @cindex algorithm of parser
Line 6357  struct @{ Line 4214  struct @{
 @cindex 構文解析器のスタック  @cindex 構文解析器のスタック
 @cindex スタック, 構文解析器  @cindex スタック, 構文解析器
 @c As Bison reads tokens, it pushes them onto a stack along with their  
 @c semantic values.  The stack is called the @dfn{parser stack}.  Pushing a  
 @c token is traditionally called @dfn{shifting}.  
 Bison構文解析器は、トークンを読むと、トークンの意味値とともにスタックに積みます。  Bison構文解析器は、トークンを読むと、トークンの意味値とともにスタックに積みます。
 このスタックを@dfn{構文解析器スタック(parser stack)}と呼びます。  このスタックを@dfn{構文解析器スタック(parser stack)}と呼びます。
 トークンをスタックに積むことを、伝統的に  トークンをスタックに積むことを、伝統的に
 @dfn{シフト(shifting)}と呼びます。  @dfn{シフト(shifting)}と呼びます。
 @c For example, suppose the infix calculator has read @samp{1 + 5 *}, with a  
 @c @samp{3} to come.  The stack will have four elements, one for each token  
 @c that was shifted.  
 たとえば、中間記法電卓が、@samp{1 + 5 *}をすでに読んでいて、  たとえば、中間記法電卓が、@samp{1 + 5 *}をすでに読んでいて、
 @samp{3}を受け取ったと仮定します。  @samp{3}を受け取ったと仮定します。
 スタックには4個の要素があり、トークンそれぞれがシフトされています。  スタックには4個の要素があり、トークンそれぞれがシフトされています。
 @c But the stack does not always have an element for each token read.  When  
 @c the last @var{n} tokens and groupings shifted match the components of a  
 @c grammar rule, they can be combined according to that rule.  This is called  
 @c @dfn{reduction}.  Those tokens and groupings are replaced on the stack by a  
 @c single grouping whose symbol is the result (left hand side) of that rule.  
 @c Running the rule's action is part of the process of reduction, because this  
 @c is what computes the semantic value of the resulting grouping.  
 しかし、スタックに常に読み込まれたトークンそれぞれに対する  しかし、スタックに常に読み込まれたトークンそれぞれに対する
 要素があるわけではありません。  要素があるわけではありません。
 最後の@var{n}個のトークンとグループが文法規則に当てはまる場合には、  最後の@var{n}個のトークンとグループが文法規則に当てはまる場合には、
Line 6392  Bison構文解析器は、トークンを読むと、ト Line 4233  Bison構文解析器は、トークンを読むと、ト
 規則のアクションの実行は、結果のグループの意味値を計算するので、  規則のアクションの実行は、結果のグループの意味値を計算するので、
 還元の手順の1つです。  還元の手順の1つです。
 @c For example, if the infix calculator's parser stack contains this:  
 たとえば、中間記法電卓の構文解析器スタックの内容は次のようになります。  たとえば、中間記法電卓の構文解析器スタックの内容は次のようになります。
 @example  @example
 1 + 5 * 3  1 + 5 * 3
 @end example  @end example
 @c @noindent  
 @c and the next input token is a newline character, then the last three  
 @c elements can be reduced to 15 via the rule:  
 そして、入力された次のトークンが改行符号ならば、  そして、入力された次のトークンが改行符号ならば、
 次の規則に従って、最後の3個の要素が15に還元されます。  次の規則に従って、最後の3個の要素が15に還元されます。
Line 6411  Bison構文解析器は、トークンを読むと、ト Line 4246  Bison構文解析器は、トークンを読むと、ト
 expr: expr '*' expr;  expr: expr '*' expr;
 @end example  @end example
 @c @noindent  
 @c Then the stack contains just these three elements:  
 そして、スタックは3個の要素を持ちます。  そして、スタックは3個の要素を持ちます。
 @example  @example
 1 + 15  1 + 15
 @end example  @end example
 @c @noindent  
 @c At this point, another reduction can be made, resulting in the single value  
 @c 16.  Then the newline token can be shifted.  
 この時点で、別の還元が可能になり、1個の値16を得ます。  この時点で、別の還元が可能になり、1個の値16を得ます。
 そして、改行符号がシフトされます。  そして、改行符号がシフトされます。
 @c The parser tries, by shifts and reductions, to reduce the entire input down  
 @c to a single grouping whose symbol is the grammar's start-symbol  
 @c (@pxref{Language and Grammar, ,Languages and Context-Free Grammars}).  
 構文解析器は、シフトと還元によって、入力全体を  構文解析器は、シフトと還元によって、入力全体を
 文法の開始記号である1個のグループに還元しようとします  文法の開始記号である1個のグループに還元しようとします
 (@pxref{Language and Grammar, ,Languages and Context-Free Grammars})。  (@pxref{Language and Grammar, ,Languages and Context-Free Grammars})。
 @c This kind of parser is known in the literature as a bottom-up parser.  
 この種類の構文解析器は、ボトムアップ構文解析器として知られています。  この種類の構文解析器は、ボトムアップ構文解析器として知られています。
 @menu  @menu
Line 6453  expr: expr '*' expr; Line 4275  expr: expr '*' expr;
 @end menu  @end menu
 @c =====================================================================  
 @node Look-Ahead, Shift/Reduce,  , Algorithm  @node Look-Ahead, Shift/Reduce,  , Algorithm
 @c @section Look-Ahead Tokens  
 @section 先読みトークン  @section 先読みトークン
 @cindex look-ahead token  @cindex look-ahead token
 @cindex 先読みトークン  @cindex 先読みトークン
 @c The Bison parser does @emph{not} always reduce immediately as soon as the  
 @c last @var{n} tokens and groupings match a rule.  This is because such a  
 @c simple strategy is inadequate to handle most languages.  Instead, when a  
 @c reduction is possible, the parser sometimes ``looks ahead'' at the next  
 @c token in order to decide what to do.  
 Bison構文解析器は、必ずしも文法規則に適合する最後の@var{n}個のトークン  Bison構文解析器は、必ずしも文法規則に適合する最後の@var{n}個のトークン
 またはグループが見つかるとすぐに還元を行う@emph{わけではありません}。  またはグループが見つかるとすぐに還元を行う@emph{わけではありません}。
 そのような単純な方法は、多くの言語の処理に適さないからです。  そのような単純な方法は、多くの言語の処理に適さないからです。
 その代わりに、還元が可能な場合に、構文解析器は次のトークンを  その代わりに、還元が可能な場合に、構文解析器は次のトークンを
 「先読み」し、次に何をするべきかを決定します。  「先読み」し、次に何をするべきかを決定します。
 @c When a token is read, it is not immediately shifted; first it becomes the  
 @c @dfn{look-ahead token}, which is not on the stack.  Now the parser can  
 @c perform one or more reductions of tokens and groupings on the stack, while  
 @c the look-ahead token remains off to the side.  When no more reductions  
 @c should take place, the look-ahead token is shifted onto the stack.  This  
 @c does not mean that all possible reductions have been done; depending on the  
 @c token type of the look-ahead token, some rules may choose to delay their  
 @c application.  
 トークンが読まれると、それはすぐにシフトされるのではなく、  トークンが読まれると、それはすぐにシフトされるのではなく、
 まず、@dfn{先読みトークン(look-ahead token)}になり、  まず、@dfn{先読みトークン(look-ahead token)}になり、
 スタックには置かれません。  スタックには置かれません。
Line 6492  Bison構文解析器は、必ずしも文法規則に適 Line 4297  Bison構文解析器は、必ずしも文法規則に適
 先読みトークンのトークン型に応じて、  先読みトークンのトークン型に応じて、
 いくつかの規則は適用を遅らされているかもしれません。  いくつかの規則は適用を遅らされているかもしれません。
 @c Here is a simple case where look-ahead is needed.  These three rules define  
 @c expressions which contain binary addition operators and postfix unary  
 @c factorial operators (@samp{!}), and allow parentheses for grouping.  
 先読みが必要な簡単な例を示します。  先読みが必要な簡単な例を示します。
 下記の3個の規則は、2項加算演算子、単項階乗演算子(@samp{!})、  下記の3個の規則は、2項加算演算子、単項階乗演算子(@samp{!})、
 グループのためのかっこを含みます。  グループのためのかっこを含みます。
Line 6515  term:     '(' expr ')' Line 4316  term:     '(' expr ')'
 @end group  @end group
 @end example  @end example
 @c Suppose that the tokens @w{@samp{1 + 2}} have been read and shifted; what  
 @c should be done?  If the following token is @samp{)}, then the first three  
 @c tokens must be reduced to form an @code{expr}.  This is the only valid  
 @c course, because shifting the @samp{)} would produce a sequence of symbols  
 @c @w{@code{term ')'}}, and no rule allows this.  
 トークン@w{@samp{1 + 2}}が読み込まれてシフトされているときに、  トークン@w{@samp{1 + 2}}が読み込まれてシフトされているときに、
 何が起きるでしょうか。もし、続くトークンが@samp{)}ならば、  何が起きるでしょうか。もし、続くトークンが@samp{)}ならば、
 最初の3個のトークンは@code{expr}の形式に還元される必要があります。  最初の3個のトークンは@code{expr}の形式に還元される必要があります。
Line 6528  term:     '(' expr ')' Line 4323  term:     '(' expr ')'
 なぜならば、@samp{)}をシフトして、@w{@code{term ')'}}という記号列も  なぜならば、@samp{)}をシフトして、@w{@code{term ')'}}という記号列も
 生成可能ですが、どの規則もそのような記号列を許していないからです。  生成可能ですが、どの規則もそのような記号列を許していないからです。
 @c If the following token is @samp{!}, then it must be shifted immediately so  
 @c that @w{@samp{2 !}} can be reduced to make a @code{term}.  If instead the  
 @c parser were to reduce before shifting, @w{@samp{1 + 2}} would become an  
 @c @code{expr}.  It would then be impossible to shift the @samp{!} because  
 @c doing so would produce on the stack the sequence of symbols @code{expr  
 @c '!'}.  No rule allows that sequence.  
 もし、続くトークンが@samp{!}ならば、それはただちにシフトされる必要があり、  もし、続くトークンが@samp{!}ならば、それはただちにシフトされる必要があり、
 @w{@samp{2 !}}から@code{term}が還元されます。  @w{@samp{2 !}}から@code{term}が還元されます。
 そうではなく、構文解析器がシフトの前に還元していれば、  そうではなく、構文解析器がシフトの前に還元していれば、
Line 6544  term:     '(' expr ')' Line 4332  term:     '(' expr ')'
 そのような記号列は許されません。  そのような記号列は許されません。
 @vindex yychar  @vindex yychar
 @c The current look-ahead token is stored in the variable @code{yychar}.  
 @c @xref{Action Features, ,Special Features for Use in Actions}.  
 現在の先読みトークンは、変数@code{yychar}に記憶されています  現在の先読みトークンは、変数@code{yychar}に記憶されています
 @xref{Action Features, ,Special Features for Use in Actions}。  @xref{Action Features, ,Special Features for Use in Actions}。
 @c =====================================================================  
 @node Shift/Reduce, Precedence, Look-Ahead, Algorithm  @node Shift/Reduce, Precedence, Look-Ahead, Algorithm
 @c @section Shift/Reduce Conflicts  
 @section シフト還元衝突  @section シフト還元衝突
 @cindex conflicts  @cindex conflicts
 @cindex shift/reduce conflicts  @cindex shift/reduce conflicts
Line 6564  term:     '(' expr ')' Line 4347  term:     '(' expr ')'
 @cindex ぶらさがりelse  @cindex ぶらさがりelse
 @cindex else, ぶらさがり  @cindex else, ぶらさがり
 @c Suppose we are parsing a language which has if-then and if-then-else  
 @c statements, with a pair of rules like this:  
 次の2個の規則で定められる、``if-then''と``if-then-else''文を持つ  次の2個の規則で定められる、``if-then''と``if-then-else''文を持つ
 言語の構文解析について考えます。  言語の構文解析について考えます。
Line 6579  if_stmt: Line 4359  if_stmt:
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c Here we assume that @code{IF}, @code{THEN} and @code{ELSE} are  
 @c terminal symbols for specific keyword tokens.  
 ここで、@code{IF}、@code{THEN}、@code{ELSE}は、  ここで、@code{IF}、@code{THEN}、@code{ELSE}は、
 キーワードトークンを表す終端記号であると仮定します。  キーワードトークンを表す終端記号であると仮定します。
 @c When the @code{ELSE} token is read and becomes the look-ahead token, the  
 @c contents of the stack (assuming the input is valid) are just right for  
 @c reduction by the first rule.  But it is also legitimate to shift the  
 @c @code{ELSE}, because that would lead to eventual reduction by the second  
 @c rule.  
 @code{ELSE}トークンが読まれて先読みトークンになったときに、  @code{ELSE}トークンが読まれて先読みトークンになったときに、
 入力が正しいと仮定して、スタックの内容はちょうど  入力が正しいと仮定して、スタックの内容はちょうど
 最初の規則で還元される右辺になっています。  最初の規則で還元される右辺になっています。
 しかし、いずれ起こるはずの第2の規則の還元のために、  しかし、いずれ起こるはずの第2の規則の還元のために、
 @code{ELSE}トークンをシフトすることも有効です。  @code{ELSE}トークンをシフトすることも有効です。
 @c This situation, where either a shift or a reduction would be valid, is  
 @c called a @dfn{shift/reduce conflict}.  Bison is designed to resolve  
 @c these conflicts by choosing to shift, unless otherwise directed by  
 @c operator precedence declarations.  To see the reason for this, let's  
 @c contrast it with the other alternative.  
 この、シフトと還元の両方が有効な場合を、  この、シフトと還元の両方が有効な場合を、
 @dfn{シフト還元衝突(shift/reduce conflict)}と呼びます。  @dfn{シフト還元衝突(shift/reduce conflict)}と呼びます。
 Bisonは、演算子優先規則宣言で特に指定されていないかぎり、  Bisonは、演算子優先規則宣言で特に指定されていないかぎり、
 シフトを選ぶことで衝突を解決するように設計されています。  シフトを選ぶことで衝突を解決するように設計されています。
 この理由を理解するために、別の選択肢と比較してみましょう。  この理由を理解するために、別の選択肢と比較してみましょう。
 @c Since the parser prefers to shift the @code{ELSE}, the result is to attach  
 @c the else-clause to the innermost if-statement, making these two inputs  
 @c equivalent:  
 構文解析器は@code{ELSE}のシフトを選ぶので、その結果、  構文解析器は@code{ELSE}のシフトを選ぶので、その結果、
 else節はもっとも内側のif文に対応し、次の2つの入力は等価になります。  else節はもっとも内側のif文に対応し、次の2つの入力は等価になります。
Line 6623  if x then if y then win (); else lose; Line 4383  if x then if y then win (); else lose;
 if x then do; if y then win (); else lose; end;  if x then do; if y then win (); else lose; end;
 @end example  @end example
 @c But if the parser chose to reduce when possible rather than shift, the  
 @c result would be to attach the else-clause to the outermost if-statement,  
 @c making these two inputs equivalent:  
 しかし、字句解析器がシフトでなく還元を選ぶと、その結果、  しかし、字句解析器がシフトでなく還元を選ぶと、その結果、
 else節がもっとも外側のif文に対応し、次の2つの入力は等価になります。  else節がもっとも外側のif文に対応し、次の2つの入力は等価になります。
Line 6636  if x then if y then win (); else lose; Line 4392  if x then if y then win (); else lose;
 if x then do; if y then win (); end; else lose;  if x then do; if y then win (); end; else lose;
 @end example  @end example
 @c The conflict exists because the grammar as written is ambiguous: either  
 @c parsing of the simple nested if-statement is legitimate.  The established  
 @c convention is that these ambiguities are resolved by attaching the  
 @c else-clause to the innermost if-statement; this is what Bison accomplishes  
 @c by choosing to shift rather than reduce.  (It would ideally be cleaner to  
 @c write an unambiguous grammar, but that is very hard to do in this case.)  
 @c This particular ambiguity was first encountered in the specifications of  
 @c Algol 60 and is called the ``dangling @code{else}'' ambiguity.  
 文法があいまいに書かれているために、衝突が起きます。  文法があいまいに書かれているために、衝突が起きます。
 つまり、入れ子になったif文について、どちらの構文解析結果も正当なのです。  つまり、入れ子になったif文について、どちらの構文解析結果も正当なのです。
 確立された習慣では、else節をもっとも内側のif文に対応させて、  確立された習慣では、else節をもっとも内側のif文に対応させて、
Line 6654  if x then do; if y then win (); end; els Line 4401  if x then do; if y then win (); end; els
 この問題は、Algol 60の仕様の中に現れたのが最初で、  この問題は、Algol 60の仕様の中に現れたのが最初で、
 「ぶらさがり@code{else}(dangling @code{else})」問題と呼ばれています。  「ぶらさがり@code{else}(dangling @code{else})」問題と呼ばれています。
 @c To avoid warnings from Bison about predictable, legitimate shift/reduce  
 @c conflicts, use the @code{%expect @var{n}} declaration.  There will be no  
 @c warning as long as the number of shift/reduce conflicts is exactly @var{n}.  
 @c @xref{Expect Decl, ,Suppressing Conflict Warnings}.  
 予測可能で正当なシフト還元衝突について、Bisonが警告を表示しないように、  予測可能で正当なシフト還元衝突について、Bisonが警告を表示しないように、
 @code{%expect @var{n}}宣言を使えます。  @code{%expect @var{n}}宣言を使えます。
 すると、ちょうど@var{n}個のシフト還元衝突があるかぎり、  すると、ちょうど@var{n}個のシフト還元衝突があるかぎり、
 警告は表示されません。  警告は表示されません。
 @xref{Expect Decl, ,Suppressing Conflict Warnings}。  @xref{Expect Decl, ,Suppressing Conflict Warnings}。
 @c The definition of @code{if_stmt} above is solely to blame for the  
 @c conflict, but the conflict does not actually appear without additional  
 @c rules.  Here is a complete Bison input file that actually manifests the  
 @c conflict:  
 上記の@code{if_stmt}の定義は、衝突をわざと発生させるために書きましたが、  上記の@code{if_stmt}の定義は、衝突をわざと発生させるために書きましたが、
 追加の規則がなければ実際には衝突が起きません。  追加の規則がなければ実際には衝突が起きません。
 次に、実際に衝突を含む完全なBison入力ファイルの例を示します。  次に、実際に衝突を含む完全なBison入力ファイルの例を示します。
Line 6697  expr:     variable Line 4434  expr:     variable
 @end example  @end example
 @c =====================================================================  
 @node Precedence, Contextual Precedence, Shift/Reduce, Algorithm  @node Precedence, Contextual Precedence, Shift/Reduce, Algorithm
 @c @section Operator Precedence  
 @section 演算子の優先順位  @section 演算子の優先順位
 @cindex operator precedence  @cindex operator precedence
 @cindex precedence of operators  @cindex precedence of operators
 @cindex 演算子の優先順位  @cindex 演算子の優先順位
 @cindex 優先順位, 演算子  @cindex 優先順位, 演算子
 @c Another situation where shift/reduce conflicts appear is in arithmetic  
 @c expressions.  Here shifting is not always the preferred resolution; the  
 @c Bison declarations for operator precedence allow you to specify when to  
 @c shift and when to reduce.  
 シフト還元衝突が起きる別の可能性は、算術式の中にあります。  シフト還元衝突が起きる別の可能性は、算術式の中にあります。
 この場合には、シフトの選択が望ましい解決策であるとは限りません。  この場合には、シフトの選択が望ましい解決策であるとは限りません。
 どのような場合にシフトしてどのような場合に還元するべきか指定するために、  どのような場合にシフトしてどのような場合に還元するべきか指定するために、
Line 6724  expr:     variable Line 4454  expr:     variable
 @end menu  @end menu
 @c =====================================================================  
 @node Why Precedence, Using Precedence,  , Precedence  @node Why Precedence, Using Precedence,  , Precedence
 @c @subsection When Precedence is Needed  
 @subsection 優先順位が必要な場合  @subsection 優先順位が必要な場合
 @c Consider the following ambiguous grammar fragment (ambiguous because the  
 @c input @w{@samp{1 - 2 * 3}} can be parsed in two different ways):  
 次のあいまいな文法の一部を見てください。  次のあいまいな文法の一部を見てください。
 入力@w{@samp{1 - 2 * 3}}が2通りに構文解析されうるので、  入力@w{@samp{1 - 2 * 3}}が2通りに構文解析されうるので、
 この文法はあいまいです。  この文法はあいまいです。
Line 6747  expr:     expr '-' expr Line 4472  expr:     expr '-' expr
 @end group  @end group
 @end example  @end example
 @c @noindent  
 @c Suppose the parser has seen the tokens @samp{1}, @samp{-} and @samp{2};  
 @c should it reduce them via the rule for the addition operator?  It depends  
 @c on the next token.  Of course, if the next token is @samp{)}, we must  
 @c reduce; shifting is invalid because no single rule can reduce the token  
 @c sequence @w{@samp{- 2 )}} or anything starting with that.  But if the next  
 @c token is @samp{*} or @samp{<}, we have a choice: either shifting or  
 @c reduction would allow the parse to complete, but with different  
 @c results.  
 構文解析器が、@samp{1}、@samp{-}、@samp{2}というトークンを  構文解析器が、@samp{1}、@samp{-}、@samp{2}というトークンを
 読み込んだと仮定します。構文解析器は、減算演算子の規則に従って、  読み込んだと仮定します。構文解析器は、減算演算子の規則に従って、
 これらのトークンを還元するべきでしょうか。  これらのトークンを還元するべきでしょうか。
Line 6768  expr:     expr '-' expr Line 4483  expr:     expr '-' expr
 シフトと還元のどちらも可能です。  シフトと還元のどちらも可能です。
 どちらを選んでも構文解析を完了できますが、解析の結果は異なります。  どちらを選んでも構文解析を完了できますが、解析の結果は異なります。
 @c To decide which one Bison should do, we must consider the  
 @c results.  If the next operator token @var{op} is shifted, then it  
 @c must be reduced first in order to permit another opportunity to  
 @c reduce the sum.  The result is (in effect) @w{@samp{1 - (2  
 @c @var{op} 3)}}.  On the other hand, if the subtraction is reduced  
 @c before shifting @var{op}, the result is @w{@samp{(1 - 2) @var{op}  
 @c 3}}.  Clearly, then, the choice of shift or reduce should depend  
 @c on the relative precedence of the operators @samp{-} and  
 @c @var{op}: @samp{*} should be shifted first, but not @samp{<}.  
 @c 原文で和と差が逆になっている(訳者)。  
 Bison字句解析器がどちらの処理をすべきか決めるために、  Bison字句解析器がどちらの処理をすべきか決めるために、
 構文解析の結果を考慮する必要があります。  構文解析の結果を考慮する必要があります。
 もし、次の演算子トークン@var{op}がシフトされるならば、  もし、次の演算子トークン@var{op}がシフトされるならば、
Line 6793  Bison字句解析器がどちらの処理をすべきか Line 4496  Bison字句解析器がどちらの処理をすべきか
 @samp{*}は先にシフトされるべきですが、@samp{<}は違います。  @samp{*}は先にシフトされるべきですが、@samp{<}は違います。
 @cindex associativity  @cindex associativity
 @c What about input such as @w{@samp{1 - 2 - 5}}; should this be  
 @c @w{@samp{(1 - 2) - 5}} or should it be @w{@samp{1 - (2 - 5)}}?  For  
 @c most operators we prefer the former, which is called @dfn{left  
 @c association}.  The latter alternative, @dfn{right association}, is  
 @c desirable for assignment operators.  The choice of left or right  
 @c association is a matter of whether the parser chooses to shift or  
 @c reduce when the stack contains @w{@samp{1 - 2}} and the look-ahead  
 @c token is @samp{-}: shifting makes right-associativity.  
 @cindex 結合性  @cindex 結合性
 @w{@samp{1 - 2 - 5}}のような例ではどうなるでしょうか。  @w{@samp{1 - 2 - 5}}のような例ではどうなるでしょうか。
 @w{@samp{(1 - 2) - 5}}と処理するべきでしょうか。  @w{@samp{(1 - 2) - 5}}と処理するべきでしょうか。
Line 6814  Bison字句解析器がどちらの処理をすべきか Line 4508  Bison字句解析器がどちらの処理をすべきか
 シフトを選ぶと、右結合的になります。  シフトを選ぶと、右結合的になります。
 @c =====================================================================  
 @node Using Precedence, Precedence Examples, Why Precedence, Precedence  @node Using Precedence, Precedence Examples, Why Precedence, Precedence
 @c @subsection Specifying Operator Precedence  
 @subsection 演算子の優先順位の指定  @subsection 演算子の優先順位の指定
 @findex %left  @findex %left
 @findex %right  @findex %right
 @findex %nonassoc  @findex %nonassoc
 @c Bison allows you to specify these choices with the operator precedence  
 @c declarations @code{%left} and @code{%right}.  Each such declaration  
 @c contains a list of tokens, which are operators whose precedence and  
 @c associativity is being declared.  The @code{%left} declaration makes all  
 @c those operators left-associative and the @code{%right} declaration makes  
 @c them right-associative.  A third alternative is @code{%nonassoc}, which  
 @c declares that it is a syntax error to find the same operator twice ``in a  
 @c row''.  
 演算子優先順位宣言@code{%left}と@code{%right}によって、  演算子優先順位宣言@code{%left}と@code{%right}によって、
 演算子の優先順位と結合規則を指定できます。  演算子の優先順位と結合規則を指定できます。
 どちらの宣言も、優先順位と結合規則を指定したい演算子である、  どちらの宣言も、優先順位と結合規則を指定したい演算子である、
Line 6840  Bison字句解析器がどちらの処理をすべきか Line 4523  Bison字句解析器がどちらの処理をすべきか
 第3の選択肢は@code{%nonassoc}宣言で、これで宣言した演算子が  第3の選択肢は@code{%nonassoc}宣言で、これで宣言した演算子が
 続けて2回以上現れると、構文解析器が文法エラーを指摘します。  続けて2回以上現れると、構文解析器が文法エラーを指摘します。
 @c The relative precedence of different operators is controlled by the  
 @c order in which they are declared.  The first @code{%left} or  
 @c @code{%right} declaration in the file declares the operators whose  
 @c precedence is lowest, the next such declaration declares the operators  
 @c whose precedence is a little higher, and so on.  
 異なる演算子の相対的な優先順位は、それらが宣言される順序で決まります。  異なる演算子の相対的な優先順位は、それらが宣言される順序で決まります。
 文法ファイルの中の最初の@code{%left}宣言または@code{%right}宣言で  文法ファイルの中の最初の@code{%left}宣言または@code{%right}宣言で
 宣言された演算子が、もっとも低い優先順位を持ちます。  宣言された演算子が、もっとも低い優先順位を持ちます。
 後から宣言される演算子ほど、高い優先順位を持ちます。  後から宣言される演算子ほど、高い優先順位を持ちます。
 @c =====================================================================  
 @node Precedence Examples, How Precedence, Using Precedence, Precedence  @node Precedence Examples, How Precedence, Using Precedence, Precedence
 @c @subsection Precedence Examples  
 @subsection 優先順位の例  @subsection 優先順位の例
 @c In our example, we would want the following declarations:  
 先ほどの例では、次のように宣言するべきでした。  先ほどの例では、次のように宣言するべきでした。
 @example  @example
Line 6867  Bison字句解析器がどちらの処理をすべきか Line 4540  Bison字句解析器がどちらの処理をすべきか
 %left '*'  %left '*'
 @end example  @end example
 @c @c In a more complete example, which supports other operators as well, we  
 @c @c would declare them in groups of equal precedence.  
 @c For example, @code{'+'} is declared with @code{'-'}:  
 もっと複雑な例では、より多くの演算子を使うだけでなく、  もっと複雑な例では、より多くの演算子を使うだけでなく、
 同じ優先順位を持つ演算子があります。  同じ優先順位を持つ演算子があります。
 次の例では、@code{'+'}演算子と@code{'-'}演算子が同じ優先順位を持ちます。  次の例では、@code{'+'}演算子と@code{'-'}演算子が同じ優先順位を持ちます。
Line 6881  Bison字句解析器がどちらの処理をすべきか Line 4550  Bison字句解析器がどちらの処理をすべきか
 %left '*' '/'  %left '*' '/'
 @end example  @end example
 @c @noindent  
 @c (Here @code{NE} and so on stand for the operators for ``not equal''  
 @c and so on.  We assume that these tokens are more than one character long  
 @c and therefore are represented by names, not character literals.)  
 (この例で、@code{NE}は「等しくない」演算子を表し、他も同様です。  (この例で、@code{NE}は「等しくない」演算子を表し、他も同様です。
 これらのトークンは、2文字以上からなるので、  これらのトークンは、2文字以上からなるので、
 1文字リテラルではなく名前で表されると仮定しています)  1文字リテラルではなく名前で表されると仮定しています)
 @c =====================================================================  
 @node How Precedence,  , Precedence Examples, Precedence  @node How Precedence,  , Precedence Examples, Precedence
 @c @subsection How Precedence Works  
 @subsection 優先順位が働く仕組み  @subsection 優先順位が働く仕組み
 @c The first effect of the precedence declarations is to assign precedence  
 @c levels to the terminal symbols declared.  The second effect is to assign  
 @c precedence levels to certain rules: each rule gets its precedence from the  
 @c last terminal symbol mentioned in the components.  (You can also specify  
 @c explicitly the precedence of a rule.  
 @c @xref{Contextual Precedence, ,Context-Dependent Precedence}.)  
 優先順位宣言の最初の働きは、宣言された終端記号への優先順位の割り当てです。  優先順位宣言の最初の働きは、宣言された終端記号への優先順位の割り当てです。
 第2の働きは、規則に含まれる最後の終端記号が優先順位を示すように、  第2の働きは、規則に含まれる最後の終端記号が優先順位を示すように、
 ある規則に優先順位を割り当てることです  ある規則に優先順位を割り当てることです
 (規則に対して、明示的に優先順位を指定することも可能です。  (規則に対して、明示的に優先順位を指定することも可能です。
 @xref{Contextual Precedence, ,Context-Dependent Precedence})。  @xref{Contextual Precedence, ,Context-Dependent Precedence})。
 @c Finally, the resolution of conflicts works by comparing the  
 @c precedence of the rule being considered with that of the  
 @c look-ahead token.  If the token's precedence is higher, the  
 @c choice is to shift.  If the rule's precedence is higher, the  
 @c choice is to reduce.  If they have equal precedence, the choice  
 @c is made based on the associativity of that precedence level.  The  
 @c verbose output file made by @samp{-v}  
 @c (@pxref{Invocation, ,Invoking Bison}) says  
 @c how each conflict was resolved.  
 最後に、衝突の解決は、問題になっている規則の優先順位と、  最後に、衝突の解決は、問題になっている規則の優先順位と、
 先読みトークンの優先順位の比較によって行われます。  先読みトークンの優先順位の比較によって行われます。
 もし、先読みトークンの優先順位が高ければ、還元されます。  もし、先読みトークンの優先順位が高ければ、還元されます。
Line 6928  Bison字句解析器がどちらの処理をすべきか Line 4573  Bison字句解析器がどちらの処理をすべきか
 どのように衝突が解決されているかがわかります  どのように衝突が解決されているかがわかります
 (@pxref{Invocation, ,Invoking Bison})。  (@pxref{Invocation, ,Invoking Bison})。
 @c Not all rules and not all tokens have precedence.  If either the rule or  
 @c the look-ahead token has no precedence, then the default is to shift.  
 すべての規則とトークンが優先順位を持っているとはかぎりません。  すべての規則とトークンが優先順位を持っているとはかぎりません。
 もし、規則と先読みトークンが優先順位を持っていなければ、  もし、規則と先読みトークンが優先順位を持っていなければ、
 シフトが行われます。  シフトが行われます。
 @c =====================================================================  
 @node Contextual Precedence, Parser States, Precedence, Algorithm  @node Contextual Precedence, Parser States, Precedence, Algorithm
 @c @section Context-Dependent Precedence  
 @section 文脈依存優先順位  @section 文脈依存優先順位
 @cindex context-dependent precedence  @cindex context-dependent precedence
 @cindex unary operator precedence  @cindex unary operator precedence
Line 6950  Bison字句解析器がどちらの処理をすべきか Line 4590  Bison字句解析器がどちらの処理をすべきか
 @cindex 優先順位, 文脈依存  @cindex 優先順位, 文脈依存
 @cindex 優先順位, 単項演算子  @cindex 優先順位, 単項演算子
 @c Often the precedence of an operator depends on the context.  This sounds  
 @c outlandish at first, but it is really very common.  For example, a minus  
 @c sign typically has a very high precedence as a unary operator, and a  
 @c somewhat lower precedence (lower than multiplication) as a binary operator.  
 しばしば、演算子の優先順位は文脈に依存します。  しばしば、演算子の優先順位は文脈に依存します。
 これは、最初は奇異に感じるかもしれませんが、  これは、最初は奇異に感じるかもしれませんが、
 実際によく起きていることなのです。  実際によく起きていることなのです。
Line 6962  Bison字句解析器がどちらの処理をすべきか Line 4597  Bison字句解析器がどちらの処理をすべきか
 単項演算子としては非常に高い優先順位を持ちますが、  単項演算子としては非常に高い優先順位を持ちますが、
 2項演算子としては乗除算よりも低い優先順位を持ちます。  2項演算子としては乗除算よりも低い優先順位を持ちます。
 @c The Bison precedence declarations, @code{%left}, @code{%right} and  
 @c @code{%nonassoc}, can only be used once for a given token; so a token has  
 @c only one precedence declared in this way.  For context-dependent  
 @c precedence, you need to use an additional mechanism: the @code{%prec}  
 @c modifier for rules.@refill  
 Bisonの優先順位宣言、@code{%left}、@code{%right}、@code{%nonassoc}は、  Bisonの優先順位宣言、@code{%left}、@code{%right}、@code{%nonassoc}は、
 あるトークンに対して1回のみ使え、この方法では、  あるトークンに対して1回のみ使え、この方法では、
 トークンは唯一の優先順位を宣言されます。  トークンは唯一の優先順位を宣言されます。
 文脈に依存する優先順位のためには、別の方法、すなわち、  文脈に依存する優先順位のためには、別の方法、すなわち、
 @code{%prec}で規則を修飾する方法が必要になります。  @code{%prec}で規則を修飾する方法が必要になります。
 @c The @code{%prec} modifier declares the precedence of a particular rule by  
 @c specifying a terminal symbol whose precedence should be used for that rule.  
 @c It's not necessary for that symbol to appear otherwise in the rule.  The  
 @c modifier's syntax is:  
 @code{%prec}修飾子は、ある規則で使われるべき終端記号の優先順位を指定して、  @code{%prec}修飾子は、ある規則で使われるべき終端記号の優先順位を指定して、
 その規則の優先順位を宣言します。  その規則の優先順位を宣言します。
 その記号がその規則の中以外に現れる必要はありません。  その記号がその規則の中以外に現れる必要はありません。
Line 6988  Bisonの優先順位宣言、@code{%left}、@code Line 4612  Bisonの優先順位宣言、@code{%left}、@code
 %prec @var{terminal-symbol}  %prec @var{terminal-symbol}
 @end example  @end example
 @c @noindent  
 @c and it is written after the components of the rule.  Its effect is to  
 @c assign the rule the precedence of @var{terminal-symbol}, overriding  
 @c the precedence that would be deduced for it in the ordinary way.  The  
 @c altered rule precedence then affects how conflicts involving that rule  
 @c are resolved (@pxref{Precedence, ,Operator Precedence}).  
 これは、規則の構成要素の後に書かれます。  これは、規則の構成要素の後に書かれます。
 これによって、通常の方法で導かれる優先順位に代わって、  これによって、通常の方法で導かれる優先順位に代わって、
 @var{terminal-symbol}の優先順位を規則に割り当てます。  @var{terminal-symbol}の優先順位を規則に割り当てます。
 規則の優先順位が変更されて、その規則が関係している衝突の解決に影響します  規則の優先順位が変更されて、その規則が関係している衝突の解決に影響します
 (@pxref{Precedence, ,Operator Precedence})。  (@pxref{Precedence, ,Operator Precedence})。
 @c Here is how @code{%prec} solves the problem of unary minus.  First, declare  
 @c a precedence for a fictitious terminal symbol named @code{UMINUS}.  There  
 @c are no tokens of this type, but the symbol serves to stand for its  
 @c precedence:  
 @code{%prec}がどのように単項負記号を解決するかを示します。  @code{%prec}がどのように単項負記号を解決するかを示します。
 まず、@code{UMINUS}という名前の終端記号に対する優先順位を宣言します。  まず、@code{UMINUS}という名前の終端記号に対する優先順位を宣言します。
 この型のトークンは存在しませんが、  この型のトークンは存在しませんが、
Line 7018  Bisonの優先順位宣言、@code{%left}、@code Line 4630  Bisonの優先順位宣言、@code{%left}、@code
 %left UMINUS  %left UMINUS
 @end example  @end example
 @c Now the precedence of @code{UMINUS} can be used in specific rules:  
 さて、@code{UNIMIS}の優先順位を、規則の中で使えます。  さて、@code{UNIMIS}の優先順位を、規則の中で使えます。
 @example  @example
Line 7032  exp:    @dots{} Line 4642  exp:    @dots{}
 @end example  @end example
 @c =====================================================================  
 @node Parser States, Reduce/Reduce, Contextual Precedence, Algorithm  @node Parser States, Reduce/Reduce, Contextual Precedence, Algorithm
 @c @section Parser States  
 @section 構文解析器の状態  @section 構文解析器の状態
 @cindex finite-state machine  @cindex finite-state machine
 @cindex parser state  @cindex parser state
Line 7043  exp:    @dots{} Line 4651  exp:    @dots{}
 @cindex 構文解析器の状態  @cindex 構文解析器の状態
 @cindex 状態, 構文解析器  @cindex 状態, 構文解析器
 @c The function @code{yyparse} is implemented using a finite-state machine.  
 @c The values pushed on the parser stack are not simply token type codes; they  
 @c represent the entire sequence of terminal and nonterminal symbols at or  
 @c near the top of the stack.  The current state collects all the information  
 @c about previous input which is relevant to deciding what to do next.  
 関数@code{yyparse}は、有限状態機械を使って実装されています。  関数@code{yyparse}は、有限状態機械を使って実装されています。
 構文解析器のスタックに積まれる値は、トークン型番号だけでなく、  構文解析器のスタックに積まれる値は、トークン型番号だけでなく、
 スタックの先頭またはその近くにある終端記号と非終端記号の列を  スタックの先頭またはその近くにある終端記号と非終端記号の列を
 表現しています。現在の状態は、次にすべきことに関連する、  表現しています。現在の状態は、次にすべきことに関連する、
 今までの入力の情報全体の集まりです。  今までの入力の情報全体の集まりです。
 @c Each time a look-ahead token is read, the current parser state together  
 @c with the type of look-ahead token are looked up in a table.  This table  
 @c entry can say, ``Shift the look-ahead token.''  In this case, it also  
 @c specifies the new parser state, which is pushed onto the top of the  
 @c parser stack.  Or it can say, ``Reduce using rule number @var{n}.''  
 @c This means that a certain number of tokens or groupings are taken off  
 @c the top of the stack, and replaced by one grouping.  In other words,  
 @c that number of states are popped from the stack, and one new state is  
 @c pushed.  
 先読みトークンが読まれるたびに、先読みトークンの型と  先読みトークンが読まれるたびに、先読みトークンの型と
 現在の構文解析器の状態によって、表が引かれます。  現在の構文解析器の状態によって、表が引かれます。
 この表の項目には、「先読みトークンをシフトしなさい」というような  この表の項目には、「先読みトークンをシフトしなさい」というような
Line 7077  exp:    @dots{} Line 4669  exp:    @dots{}
 言い換えると、その数の状態がスタックからポップされ、  言い換えると、その数の状態がスタックからポップされ、
 新しい1個の状態がスタックにプッシュされます。  新しい1個の状態がスタックにプッシュされます。
 @c There is one other alternative: the table can say that the look-ahead token  
 @c is erroneous in the current state.  This causes error processing to begin  
 @c (@pxref{Error Recovery}).  
 これには、1つの例外があります。  これには、1つの例外があります。
 先読みトークンが現在の状態に対してエラーであるという項目もあります。  先読みトークンが現在の状態に対してエラーであるという項目もあります。
 この場合には、エラー処理が起こります  この場合には、エラー処理が起こります
 (@pxref{Error Recovery})。  (@pxref{Error Recovery})。
 @c =====================================================================  
 @node Reduce/Reduce, Mystery Conflicts, Parser States, Algorithm  @node Reduce/Reduce, Mystery Conflicts, Parser States, Algorithm
 @c @section Reduce/Reduce Conflicts  
 @section 還元/還元衝突  @section 還元/還元衝突
 @cindex reduce/reduce conflict  @cindex reduce/reduce conflict
 @cindex conflicts, reduce/reduce  @cindex conflicts, reduce/reduce
 @cindex 還元/還元衝突  @cindex 還元/還元衝突
 @cindex 衝突, 還元/還元  @cindex 衝突, 還元/還元
 @c A reduce/reduce conflict occurs if there are two or more rules that apply  
 @c to the same sequence of input.  This usually indicates a serious error  
 @c in the grammar.  
 同一の入力列に対して2個以上の規則が適用可能であると、  同一の入力列に対して2個以上の規則が適用可能であると、
 還元/還元衝突が起きます。  還元/還元衝突が起きます。
 これは、通常、文法の重大なエラーを意味します。  これは、通常、文法の重大なエラーを意味します。
 @c For example, here is an erroneous attempt to define a sequence  
 @c of zero or more @code{word} groupings.  
 0個以上の@code{word}の並びをグループ化する、  0個以上の@code{word}の並びをグループ化する、
 誤った試みの例を示します。  誤った試みの例を示します。
 @example  @example
 @c sequence: /* empty */  
 sequence: /* 空 */  sequence: /* 空 */
                 @{ printf ("empty sequence\n"); @}                  @{ printf ("empty sequence\n"); @}
         | maybeword          | maybeword
Line 7119  sequence: /* 空 */ Line 4697  sequence: /* 空 */
                 @{ printf ("added word %s\n", $2); @}                  @{ printf ("added word %s\n", $2); @}
         ;          ;
 @c maybeword: /* empty */  
 maybeword: /* 空 */  maybeword: /* 空 */
                 @{ printf ("empty maybeword\n"); @}                  @{ printf ("empty maybeword\n"); @}
         | word          | word
Line 7127  maybeword: /* 空 */ Line 4704  maybeword: /* 空 */
         ;          ;
 @end example  @end example
 @c @noindent  
 @c The error is an ambiguity: there is more than one way to parse a single  
 @c @code{word} into a @code{sequence}.  It could be reduced to a  
 @c @code{maybeword} and then into a @code{sequence} via the second rule.  
 @c Alternatively, nothing-at-all could be reduced into a @code{sequence}  
 @c via the first rule, and this could be combined with the @code{word}  
 @c using the third rule for @code{sequence}.  
 エラーは、あいまいさにあります。  エラーは、あいまいさにあります。
 つまり、1個の@code{word}を@code{sequence}に構文解析する、  つまり、1個の@code{word}を@code{sequence}に構文解析する、
 2個以上の方法があります。  2個以上の方法があります。
Line 7144  maybeword: /* 空 */ Line 4713  maybeword: /* 空 */
 それが第3の規則によって@code{word}と組み合わされて  それが第3の規則によって@code{word}と組み合わされて
 @code{sequence}になりえます。  @code{sequence}になりえます。
 @c There is also more than one way to reduce nothing-at-all into a  
 @c @code{sequence}.  This can be done directly via the first rule,  
 @c or indirectly via @code{maybeword} and then the second rule.  
 さらに、空データが@code{sequence}に還元される方法が2つ以上あります。  さらに、空データが@code{sequence}に還元される方法が2つ以上あります。
 第1の規則で直接還元される方法と、  第1の規則で直接還元される方法と、
 @code{maybeword}を経由して第2の規則で還元される方法です。  @code{maybeword}を経由して第2の規則で還元される方法です。
 @c You might think that this is a distinction without a difference, because it  
 @c does not change whether any particular input is valid or not.  But it does  
 @c affect which actions are run.  One parsing order runs the second rule's  
 @c action; the other runs the first rule's action and the third rule's action.  
 @c In this example, the output of the program changes.  
 この違いは、特定の入力が正当であるかどうかに関係ないので、  この違いは、特定の入力が正当であるかどうかに関係ないので、
 ささいなことに思えるかもしれません。  ささいなことに思えるかもしれません。
 しかし、これは、どのアクションが実行されるかに影響します。  しかし、これは、どのアクションが実行されるかに影響します。
Line 7166  maybeword: /* 空 */ Line 4725  maybeword: /* 空 */
 実行されます。  実行されます。
 この例では、プログラムの出力が異なります。  この例では、プログラムの出力が異なります。
 @c Bison resolves a reduce/reduce conflict by choosing to use the rule that  
 @c appears first in the grammar, but it is very risky to rely on this.  Every  
 @c reduce/reduce conflict must be studied and usually eliminated.  Here is the  
 @c proper way to define @code{sequence}:  
 Bisonは、最初に現れた文法を選ぶことで、還元/還元衝突を解決しますが、  Bisonは、最初に現れた文法を選ぶことで、還元/還元衝突を解決しますが、
 これに頼ることは非常に危険です。  これに頼ることは非常に危険です。
 還元/還元衝突のそれぞれは、人間によって解析され、  還元/還元衝突のそれぞれは、人間によって解析され、
Line 7178  Bisonは、最初に現れた文法を選ぶことで、 Line 4732  Bisonは、最初に現れた文法を選ぶことで、
 @code{sequence}を定義する正しい方法を示します。  @code{sequence}を定義する正しい方法を示します。
 @example  @example
 @c sequence: /* empty */  
 sequence: /* 空 */  sequence: /* 空 */
                 @{ printf ("empty sequence\n"); @}                  @{ printf ("empty sequence\n"); @}
         | sequence word          | sequence word
Line 7186  sequence: /* 空 */ Line 4739  sequence: /* 空 */
         ;          ;
 @end example  @end example
 @c Here is another common error that yields a reduce/reduce conflict:  
 還元/還元衝突を起こす、別のありがちなエラーの例を示します。  還元/還元衝突を起こす、別のありがちなエラーの例を示します。
 @example  @example
 @c sequence: /* empty */  
 sequence: /* 空 */  sequence: /* 空 */
         | sequence words          | sequence words
         | sequence redirects          | sequence redirects
         ;          ;
 @c words:    /* empty */  
 words:    /* 空 */  words:    /* 空 */
         | words word          | words word
         ;          ;
 @c redirects:/* empty */  
 redirects:/* 空 */  redirects:/* 空 */
         | redirects redirect          | redirects redirect
         ;          ;
 @end example  @end example
 @c @noindent  
 @c The intention here is to define a sequence which can contain either  
 @c @code{word} or @code{redirect} groupings.  The individual definitions of  
 @c @code{sequence}, @code{words} and @code{redirects} are error-free, but the  
 @c three together make a subtle ambiguity: even an empty input can be parsed  
 @c in infinitely many ways!  
 ここは、@code{word}または@code{redirect}グループのどちらかを含む  ここは、@code{word}または@code{redirect}グループのどちらかを含む
 列の定義が目的です。  列の定義が目的です。
 @code{sequence}、@code{words}、@code{redirects}それぞれ個別の  @code{sequence}、@code{words}、@code{redirects}それぞれ個別の
 定義にエラーはありません。しかし、3個を合わせると、あいまいになります。  定義にエラーはありません。しかし、3個を合わせると、あいまいになります。
 空の入力には、無限個の構文解析方法があります。  空の入力には、無限個の構文解析方法があります。
 @c Consider: nothing-at-all could be a @code{words}.  Or it could be two  
 @c @code{words} in a row, or three, or any number.  It could equally well be a  
 @c @code{redirects}, or two, or any number.  Or it could be a @code{words}  
 @c followed by three @code{redirects} and another @code{words}.  And so on.  
 空データが@code{words}になったと仮定しましょう。  空データが@code{words}になったと仮定しましょう。
 それは、2個の@code{words}にも、3個の@code{words}にも、  それは、2個の@code{words}にも、3個の@code{words}にも、
 何個の@code{words}にもなりえます。  何個の@code{words}にもなりえます。
 あるいは、1個の@code{words}に3個の@code{redirects}ともう1個の@code{word}が  あるいは、1個の@code{words}に3個の@code{redirects}ともう1個の@code{word}が
 続くことも考えられます。同様に、無限の解釈が可能です。  続くことも考えられます。同様に、無限の解釈が可能です。
 @c Here are two ways to correct these rules.  First, to make it a single level  
 @c of sequence:  
 これらの規則を直す方法が2つあります。  これらの規則を直す方法が2つあります。
 第1に、1段階の列にする方法です。  第1に、1段階の列にする方法です。
 @example  @example
 @c sequence: /* empty */  
 sequence: /* 空 */  sequence: /* 空 */
         | sequence word          | sequence word
         | sequence redirect          | sequence redirect
         ;          ;
 @end example  @end example
 @c Second, to prevent either a @code{words} or a @code{redirects}  
 @c from being empty:  
 第2に、@code{words}と@code{redirects}が空になるのを防ぐ方法です。  第2に、@code{words}と@code{redirects}が空になるのを防ぐ方法です。
 @example  @example
 @c sequence: /* empty */  
 sequence: /* 空 */  sequence: /* 空 */
         | sequence words          | sequence words
         | sequence redirects          | sequence redirects
Line 7268  redirects:redirect Line 4796  redirects:redirect
 @end example  @end example
 @c =====================================================================  
 @node Mystery Conflicts, Stack Overflow, Reduce/Reduce, Algorithm  @node Mystery Conflicts, Stack Overflow, Reduce/Reduce, Algorithm
 @c @section Mysterious Reduce/Reduce Conflicts  
 @section 不可解な還元/還元衝突  @section 不可解な還元/還元衝突
 @c Sometimes reduce/reduce conflicts can occur that don't look warranted.  
 @c Here is an example:  
 そうなるはずがないように見えるのに、ときどき  そうなるはずがないように見えるのに、ときどき
 還元/還元衝突が起きることがあります。  還元/還元衝突が起きることがあります。
 例を示します。  例を示します。
Line 7312  name_list: Line 4835  name_list:
 @end group  @end group
 @end example  @end example
 @c It would seem that this grammar can be parsed with only a single token  
 @c of look-ahead: when a @code{param_spec} is being read, an @code{ID} is   
 @c a @code{name} if a comma or colon follows, or a @code{type} if another  
 @c @code{ID} follows.  In other words, this grammar is LR(1).  
 この文法は、1個のトークンの先読みによって、構文解析できるように見えます。  この文法は、1個のトークンの先読みによって、構文解析できるように見えます。
 たとえば、@code{pram_spec}が読まれた後で、  たとえば、@code{pram_spec}が読まれた後で、
 @code{ID}はカンマかセミコロンが続くならば@code{name}、  @code{ID}はカンマかセミコロンが続くならば@code{name}、
Line 7325  name_list: Line 4843  name_list:
 @cindex LR(1)  @cindex LR(1)
 @cindex LALR(1)  @cindex LALR(1)
 @c However, Bison, like most parser generators, cannot actually handle all  
 @c LR(1) grammars.  In this grammar, two contexts, that after an @code{ID}  
 @c at the beginning of a @code{param_spec} and likewise at the beginning of  
 @c a @code{return_spec}, are similar enough that Bison assumes they are the  
 @c same.  They appear similar because the same set of rules would be  
 @c active---the rule for reducing to a @code{name} and that for reducing to  
 @c a @code{type}.  Bison is unable to determine at that stage of processing  
 @c that the rules would require different look-ahead tokens in the two  
 @c contexts, so it makes a single parser state for them both.  Combining  
 @c the two contexts causes a conflict later.  In parser terminology, this  
 @c occurrence means that the grammar is not LALR(1).  
 しかし、Bisonは、多くの構文解析器生成器と同様に、  しかし、Bisonは、多くの構文解析器生成器と同様に、
 すべてのLR(1)文法を扱えるわけではありません。  すべてのLR(1)文法を扱えるわけではありません。
 前述の例では、@code{ID}の後で、そこが@code{param_spec}の先頭であるという  前述の例では、@code{ID}の後で、そこが@code{param_spec}の先頭であるという
Line 7351  Bisonは、その規則が2つの文脈で異なる先読 Line 4857  Bisonは、その規則が2つの文脈で異なる先読
 構文解析器の用語でいえば、この問題の発生は、  構文解析器の用語でいえば、この問題の発生は、
 文法がLALR(1)でないことを意味します。  文法がLALR(1)でないことを意味します。
 @c In general, it is better to fix deficiencies than to document them.  But  
 @c this particular deficiency is intrinsically hard to fix; parser  
 @c generators that can handle LR(1) grammars are hard to write and tend to  
 @c produce parsers that are very large.  In practice, Bison is more useful  
 @c as it is now.  
 一般に、このような欠点は解決して、文書化するべきです。  一般に、このような欠点は解決して、文書化するべきです。
 しかし、この問題は本質的に解決困難です。  しかし、この問題は本質的に解決困難です。
 LR(1)文法を扱える構文解析器生成器は、作成困難で、  LR(1)文法を扱える構文解析器生成器は、作成困難で、
 生成される構文解析器が巨大になってしまいます。  生成される構文解析器が巨大になってしまいます。
 実用上、Bisonは今のままでも有用です。  実用上、Bisonは今のままでも有用です。
 @c When the problem arises, you can often fix it by identifying the two  
 @c parser states that are being confused, and adding something to make them  
 @c look distinct.  In the above example, adding one rule to  
 @c @code{return_spec} as follows makes the problem go away:  
 このような問題が現れた場合に、混乱の元になっている2種類の構文解析器の  このような問題が現れた場合に、混乱の元になっている2種類の構文解析器の
 状態を区別し、それらが違うという目印か何かを追加することによって、  状態を区別し、それらが違うという目印か何かを追加することによって、
 しばしば問題を解決できます。  しばしば問題を解決できます。
Line 7383  LR(1)文法を扱える構文解析器生成器は、作 Line 4878  LR(1)文法を扱える構文解析器生成器は、作
 return_spec:  return_spec:
              type               type
         |    name ':' type          |    name ':' type
 @c         /* This rule is never used.  */  
          /* この規則は決して使われない。  */           /* この規則は決して使われない。  */
         |    ID BOGUS          |    ID BOGUS
         ;          ;
 @end group  @end group
 @end example  @end example
 @c This corrects the problem because it introduces the possibility of an  
 @c additional active rule in the context  
 @c after the @code{ID} at the beginning of  
 @c @code{return_spec}.  This rule is not active in the corresponding context  
 @c in a @code{param_spec}, so the two contexts receive distinct parser states.  
 @c As long as the token @code{BOGUS} is never generated by @code{yylex},  
 @c the added rule cannot alter the way actual input is parsed.  
 @code{ID}の次で@code{return_spec}の先頭である文脈で、  @code{ID}の次で@code{return_spec}の先頭である文脈で、
 追加の規則が有効になる可能性を導入して、問題を解決しています。  追加の規則が有効になる可能性を導入して、問題を解決しています。
 この規則は、@code{param_spec}に関連する文脈では有効にならないので、  この規則は、@code{param_spec}に関連する文脈では有効にならないので、
Line 7405  return_spec: Line 4891  return_spec:
 @code{BOGUS}は@code{yylex}によっては決して生成されないので、  @code{BOGUS}は@code{yylex}によっては決して生成されないので、
 追加された規則は入力が実際に構文解析される方法には影響しません。  追加された規則は入力が実際に構文解析される方法には影響しません。
 @c In this particular example, there is another way to solve the problem:  
 @c rewrite the rule for @code{return_spec} to use @code{ID} directly  
 @c instead of via @code{name}.  This also causes the two confusing  
 @c contexts to have different sets of active rules, because the one for  
 @c @code{return_spec} activates the altered rule for @code{return_spec}  
 @c rather than the one for @code{name}.  
 この具体例では、問題を解決する別の方法があります。  この具体例では、問題を解決する別の方法があります。
 つまり、@code{return_spec}の規則を、@code{name}経由ではなく  つまり、@code{return_spec}の規則を、@code{name}経由ではなく
 @code{ID}を直接使うように書き換えるのです。  @code{ID}を直接使うように書き換えるのです。
Line 7431  return_spec: Line 4910  return_spec:
 @end example  @end example
 @c =====================================================================  
 @node Stack Overflow,  , Mystery Conflicts, Algorithm  @node Stack Overflow,  , Mystery Conflicts, Algorithm
 @c @section Stack Overflow, and How to Avoid It  
 @section スタックオーバーフローと防ぎ方  @section スタックオーバーフローと防ぎ方
 @cindex stack overflow  @cindex stack overflow
 @cindex parser stack overflow  @cindex parser stack overflow
Line 7442  return_spec: Line 4919  return_spec:
 @cindex 構文解析器のスタックオーバーフロー  @cindex 構文解析器のスタックオーバーフロー
 @cindex オーバーフロー, 構文解析器のスタック  @cindex オーバーフロー, 構文解析器のスタック
 @c The Bison parser stack can overflow if too many tokens are shifted and  
 @c not reduced.  When this happens, the parser function @code{yyparse}  
 @c returns a nonzero value, pausing only to call @code{yyerror} to report  
 @c the overflow.  
 Bison構文解析器のスタックは、あまりにも多くのトークンがシフトされて  Bison構文解析器のスタックは、あまりにも多くのトークンがシフトされて
 還元されないでいると、オーバーフローする可能性があります。  還元されないでいると、オーバーフローする可能性があります。
 スタックがオーバーフローすると、オーバーフローを報告するために@code{yyerror}  スタックがオーバーフローすると、オーバーフローを報告するために@code{yyerror}
 を呼び出して、関数@code{yyparse}は0でない値を返します。  を呼び出して、関数@code{yyparse}は0でない値を返します。
 @c By defining the macro @code{YYMAXDEPTH}, you can control how deep the  
 @c parser stack can become before a stack overflow occurs.  Define the  
 @c macro with a value that is an integer.  This value is the maximum number  
 @c of tokens that can be shifted (and not reduced) before overflow.  
 @c It must be a constant expression whose value is known at compile time.  
 マクロ@code{YYMAXDEPTH}を定義して、スタックオーバーフローが起こらないように、  マクロ@code{YYMAXDEPTH}を定義して、スタックオーバーフローが起こらないように、
 構文解析器のスタックの深さを調節できます。  構文解析器のスタックの深さを調節できます。
 マクロの値として、整数値を定義してください。  マクロの値として、整数値を定義してください。
Line 7466  Bison構文解析器のスタックは、あまりにも Line 4932  Bison構文解析器のスタックは、あまりにも
 最大数になります。  最大数になります。
 マクロの値として、コンパイル時に決定可能な定数式を指定してください。  マクロの値として、コンパイル時に決定可能な定数式を指定してください。
 @c The stack space allowed is not necessarily allocated.  If you specify a  
 @c large value for @code{YYMAXDEPTH}, the parser actually allocates a small  
 @c stack at first, and then makes it bigger by stages as needed.  This  
 @c increasing allocation happens automatically and silently.  Therefore,  
 @c you do not need to make @code{YYMAXDEPTH} painfully small merely to save  
 @c space for ordinary inputs that do not need much stack.  
 指定されたスタック領域は、割り当てられる必要はありません。  指定されたスタック領域は、割り当てられる必要はありません。
 大きな@code{YYMAXDEPTH}を指定すると、  大きな@code{YYMAXDEPTH}を指定すると、
 構文解析器はまず小さなスタック領域を割り当て、  構文解析器はまず小さなスタック領域を割り当て、
Line 7484  Bison構文解析器のスタックは、あまりにも Line 4943  Bison構文解析器のスタックは、あまりにも
 @cindex default stack limit  @cindex default stack limit
 @cindex 省略時のスタックの限界  @cindex 省略時のスタックの限界
 @cindex スタックの限界, 省略時  @cindex スタックの限界, 省略時
 @c The default value of @code{YYMAXDEPTH}, if you do not define it, is  
 @c 10000.  
 特に指定しないと、@code{YYMAXDEPTH}の値は10000になります。  特に指定しないと、@code{YYMAXDEPTH}の値は10000になります。
 @c You can control how much stack is allocated initially by defining the  
 @c macro @code{YYINITDEPTH}.  This value too must be a compile-time  
 @c constant integer.  The default is 200.  
 マクロ@code{YYINIDEPTH}を指定して、最初に割り当てられるスタックの量を  マクロ@code{YYINIDEPTH}を指定して、最初に割り当てられるスタックの量を
 調節できます。この値は、コンパイル時に決定可能な整定数の必要があります。  調節できます。この値は、コンパイル時に決定可能な整定数の必要があります。
 特に指定しないと、200になります。  特に指定しないと、200になります。
 @c =====================================================================  
 @node Error Recovery, Context Dependency, Algorithm, Top  @node Error Recovery, Context Dependency, Algorithm, Top
 @c @chapter Error Recovery  
 @chapter エラーからの回復  @chapter エラーからの回復
 @cindex error recovery  @cindex error recovery
 @cindex recovery from errors  @cindex recovery from errors
 @cindex エラーからの回復  @cindex エラーからの回復
 @cindex 回復  @cindex 回復
 @c It is not usually acceptable to have a program terminate on a parse  
 @c error.  For example, a compiler should recover sufficiently to parse the  
 @c rest of the input file and check it for errors; a calculator should accept  
 @c another expression.  
 構文解析エラーが起きた場合に、構文解析プログラムが止まることは、  構文解析エラーが起きた場合に、構文解析プログラムが止まることは、
 通常望ましくありません。  通常望ましくありません。
 たとえば、コンパイラは入力の残りを構文解析して他のエラーを探せるように  たとえば、コンパイラは入力の残りを構文解析して他のエラーを探せるように
 エラーから回復するべきですし、電卓は次の式を受け入れるべきです。  エラーから回復するべきですし、電卓は次の式を受け入れるべきです。
 @c In a simple interactive command parser where each input is one line, it may  
 @c be sufficient to allow @code{yyparse} to return 1 on error and have the  
 @c caller ignore the rest of the input line when that happens (and then call  
 @c @code{yyparse} again).  But this is inadequate for a compiler, because it  
 @c forgets all the syntactic context leading up to the error.  A syntax error  
 @c deep within a function in the compiler input should not cause the compiler  
 @c to treat the following line like the beginning of a source file.  
 入力を1行ごとに処理する単純な対話的構文解析器は、  入力を1行ごとに処理する単純な対話的構文解析器は、
 エラーが発生した場合に@code{yyparse}が1を返し、  エラーが発生した場合に@code{yyparse}が1を返し、
 入力行の残りを無視し、  入力行の残りを無視し、
Line 7537  Bison構文解析器のスタックは、あまりにも Line 4974  Bison構文解析器のスタックは、あまりにも
 扱うべきではありません。  扱うべきではありません。
 @findex error  @findex error
 @c You can define how to recover from a syntax error by writing rules to  
 @c recognize the special token @code{error}.  This is a terminal symbol that  
 @c is always defined (you need not declare it) and reserved for error  
 @c handling.  The Bison parser generates an @code{error} token whenever a  
 @c syntax error happens; if you have provided a rule to recognize this token  
 @c in the current context, the parse can continue.    
 特別なトークン@code{error}を認識するような規則を書くことによって、  特別なトークン@code{error}を認識するような規則を書くことによって、
 構文エラーから回復する方法を定義できます。  構文エラーから回復する方法を定義できます。
 @code{error}は定義済みの終端記号で、自分で宣言する必要はなく、  @code{error}は定義済みの終端記号で、自分で宣言する必要はなく、
Line 7552  Bison構文解析器は、構文エラーが起こるた Line 4982  Bison構文解析器は、構文エラーが起こるた
 現在の文脈で@code{error}トークンを認識できる規則を書いていれば、  現在の文脈で@code{error}トークンを認識できる規則を書いていれば、
 構文解析を継続できます。  構文解析を継続できます。
 @c For example:  
 例を示します。  例を示します。
 @example  @example
 @c stmnts:  /* empty string */  
 stmnts:  /* 空文字列 */  stmnts:  /* 空文字列 */